feat(bpf2go): Export go binding generation

Moves the code to generate go bindings to its own dedicated package
and export the necessary functions to use it in bpf2go.

This change will make it possible to reuse this code in other tools,
without having to compile the C programs.

The behaviour of bpf2go is unchanged.

Two additional changes were made:
1. The 'Module' parameter has been made an input to the code generation.
  Otherwise embedding the bindings package in another module would lead to
  incorrect import statements in the generated code.
  I fail to see the value of the 'debug' lookup, the only valid value is
  "github.com/cilium/ebpf", but maybe there are some cilium internal build
  constraints, so I left it configurable.
2. The function which transforms type names to go identifiers has been updated
  to deal with all caps names. These shouldn't be present in C code, but
  appear when using rust. The change ensures the field names in the bindings
  are idiomatic Go field names.

Signed-off-by: Wouter Dullaert <[email protected]>

Author: wdullaer

cmd/bpf2go/output.go renamed to bindings/output.go

@@ -1,4 +1,4 @@
-package main
+package bindings
 
 import (
 	"bytes"
@@ -71,38 +71,43 @@ func (n templateName) CloseHelper() string {
 	return "_" + toUpperFirst(string(n)) + "Close"
 }
 
-type outputArgs struct {
+type GenerateArgs struct {
+	// The package containing the go ebpf code. "github.com/cilium/ebpf" if left empty
+	Module string
 	// Package of the resulting file.
-	pkg string
+	Pkg string
 	// The prefix of all names declared at the top-level.
-	stem string
-	// Build constraints included in the resulting file.
-	constraints constraint.Expr
+	Stem string
+	// Build Constraints included in the resulting file.
+	Constraints constraint.Expr
 	// Maps to be emitted.
-	maps []string
+	Maps []string
 	// Programs to be emitted.
-	programs []string
+	Programs []string
 	// Types to be emitted.
-	types []btf.Type
+	Types []btf.Type
 	// Filename of the ELF object to embed.
-	obj string
-	out io.Writer
+	Obj string
+	Out io.Writer
 }
 
-func output(args outputArgs) error {
+func Generate(args GenerateArgs) error {
+	if args.Module == "" {
+		args.Module = "github.com/cilium/ebpf"
+	}
 	maps := make(map[string]string)
-	for _, name := range args.maps {
+	for _, name := range args.Maps {
 		maps[name] = internal.Identifier(name)
 	}
 
 	programs := make(map[string]string)
-	for _, name := range args.programs {
+	for _, name := range args.Programs {
 		programs[name] = internal.Identifier(name)
 	}
 
 	typeNames := make(map[btf.Type]string)
-	for _, typ := range args.types {
-		typeNames[typ] = args.stem + internal.Identifier(typ.TypeName())
+	for _, typ := range args.Types {
+		typeNames[typ] = args.Stem + internal.Identifier(typ.TypeName())
 	}
 
 	// Ensure we don't have conflicting names and generate a sorted list of
@@ -112,8 +117,6 @@ func output(args outputArgs) error {
 		return err
 	}
 
-	module := currentModule()
-
 	gf := &btf.GoFormatter{
 		Names:      typeNames,
 		Identifier: internal.Identifier,
@@ -132,26 +135,26 @@ func output(args outputArgs) error {
 		File        string
 	}{
 		gf,
-		module,
-		args.pkg,
-		args.constraints,
-		templateName(args.stem),
+		args.Module,
+		args.Pkg,
+		args.Constraints,
+		templateName(args.Stem),
 		maps,
 		programs,
 		types,
 		typeNames,
-		args.obj,
+		args.Obj,
 	}
 
 	var buf bytes.Buffer
 	if err := commonTemplate.Execute(&buf, &ctx); err != nil {
 		return fmt.Errorf("can't generate types: %s", err)
 	}
 
-	return internal.WriteFormatted(buf.Bytes(), args.out)
+	return internal.WriteFormatted(buf.Bytes(), args.Out)
 }
 
-func collectFromSpec(spec *ebpf.CollectionSpec, cTypes []string, skipGlobalTypes bool) (maps, programs []string, types []btf.Type, _ error) {
+func CollectFromSpec(spec *ebpf.CollectionSpec, cTypes []string, skipGlobalTypes bool) (maps, programs []string, types []btf.Type, _ error) {
 	for name := range spec.Maps {
 		// Skip .rodata, .data, .bss, etc. sections
 		if !strings.HasPrefix(name, ".") {

cmd/bpf2go/output.tpl renamed to bindings/output.tpl

@@ -1,4 +1,4 @@
-package main
+package bindings
 
 import (
 	"testing"
@@ -75,21 +75,21 @@ func TestCollectFromSpec(t *testing.T) {
 
 	map1 := spec.Maps["map1"]
 
-	maps, programs, types, err := collectFromSpec(spec, nil, false)
+	maps, programs, types, err := CollectFromSpec(spec, nil, false)
 	if err != nil {
 		t.Fatal(err)
 	}
 	qt.Assert(t, qt.ContentEquals(maps, []string{"map1"}))
 	qt.Assert(t, qt.ContentEquals(programs, []string{"filter"}))
 	qt.Assert(t, qt.CmpEquals(types, []btf.Type{map1.Key, map1.Value}, typesEqualComparer))
 
-	_, _, types, err = collectFromSpec(spec, nil, true)
+	_, _, types, err = CollectFromSpec(spec, nil, true)
 	if err != nil {
 		t.Fatal(err)
 	}
 	qt.Assert(t, qt.CmpEquals[[]btf.Type](types, nil, typesEqualComparer))
 
-	_, _, types, err = collectFromSpec(spec, []string{"barfoo"}, true)
+	_, _, types, err = CollectFromSpec(spec, []string{"barfoo"}, true)
 	if err != nil {
 		t.Fatal(err)
 	}

cmd/bpf2go/output_test.go renamed to bindings/output_test.go

@@ -0,0 +1,11 @@
+package bindings
+
+import (
+	"unicode"
+	"unicode/utf8"
+)
+
+func toUpperFirst(str string) string {
+	first, n := utf8.DecodeRuneInString(str)
+	return string(unicode.ToUpper(first)) + str[n:]
+}

bindings/tools.go

@@ -18,6 +18,7 @@ import (
 	"strings"
 
 	"github.com/cilium/ebpf"
+	"github.com/cilium/ebpf/bindings"
 )
 
 const helpText = `Usage: %[1]s [options] <ident> <source file> [-- <C flags>]
@@ -389,7 +390,7 @@ func (b2g *bpf2go) convert(tgt target, goarches []goarch) (err error) {
 		return fmt.Errorf("can't load BPF from ELF: %s", err)
 	}
 
-	maps, programs, types, err := collectFromSpec(spec, b2g.cTypes, b2g.skipGlobalTypes)
+	maps, programs, types, err := bindings.CollectFromSpec(spec, b2g.cTypes, b2g.skipGlobalTypes)
 	if err != nil {
 		return err
 	}
@@ -402,15 +403,16 @@ func (b2g *bpf2go) convert(tgt target, goarches []goarch) (err error) {
 	}
 	defer removeOnError(goFile)
 
-	err = output(outputArgs{
-		pkg:         b2g.pkg,
-		stem:        b2g.identStem,
-		constraints: constraints,
-		maps:        maps,
-		programs:    programs,
-		types:       types,
-		obj:         filepath.Base(objFileName),
-		out:         goFile,
+	err = bindings.Generate(bindings.GenerateArgs{
+		Module:      currentModule(),
+		Pkg:         b2g.pkg,
+		Stem:        b2g.identStem,
+		Constraints: constraints,
+		Maps:        maps,
+		Programs:    programs,
+		Types:       types,
+		Obj:         filepath.Base(objFileName),
+		Out:         goFile,
 	})
 	if err != nil {
 		return fmt.Errorf("can't write %s: %s", goFileName, err)

cmd/bpf2go/main.go

@@ -5,8 +5,6 @@ import (
 	"fmt"
 	"runtime/debug"
 	"strings"
-	"unicode"
-	"unicode/utf8"
 )
 
 func splitCFlagsFromArgs(in []string) (args, cflags []string) {
@@ -78,11 +76,6 @@ func splitArguments(in string) ([]string, error) {
 	return result, nil
 }
 
-func toUpperFirst(str string) string {
-	first, n := utf8.DecodeRuneInString(str)
-	return string(unicode.ToUpper(first)) + str[n:]
-}
-
 func currentModule() string {
 	bi, ok := debug.ReadBuildInfo()
 	if !ok {

cmd/bpf2go/tools.go

@@ -18,8 +18,11 @@ func Identifier(str string) string {
 		// See https://golang.org/ref/spec#Identifiers
 		switch {
 		case unicode.IsLetter(r):
-			if prev == -1 {
+			switch {
+			case prev == -1:
 				r = unicode.ToUpper(r)
+			case unicode.IsUpper(r):
+				r = unicode.ToLower(r)
 			}
 
 		case r == '_':