features: simplify HaveProgramHelper

Author: lmb

features/prog.go

@@ -1,9 +1,7 @@
 package features
 
 import (
-	"bytes"
 	"errors"
-	"fmt"
 	"os"
 	"sync"
 
@@ -14,81 +12,6 @@ import (
 	"github.com/cilium/ebpf/internal/unix"
 )
 
-func init() {
-	pc.helpers = make(map[ebpf.ProgramType]map[asm.BuiltinFunc]error)
-	allocHelperCache()
-}
-
-func allocHelperCache() {
-	for pt := ebpf.UnspecifiedProgram + 1; pt <= pt.Max(); pt++ {
-		pc.helpers[pt] = make(map[asm.BuiltinFunc]error)
-	}
-}
-
-var (
-	pc progCache
-)
-
-type progCache struct {
-	helperMu sync.Mutex
-	helpers  map[ebpf.ProgramType]map[asm.BuiltinFunc]error
-}
-
-func createProgLoadAttr(pt ebpf.ProgramType, helper asm.BuiltinFunc) (*sys.ProgLoadAttr, error) {
-	var expectedAttachType ebpf.AttachType
-	var progFlags uint32
-
-	insns := asm.Instructions{
-		asm.LoadImm(asm.R0, 0, asm.DWord),
-		asm.Return(),
-	}
-
-	if helper != asm.FnUnspec {
-		insns = append(asm.Instructions{helper.Call()}, insns...)
-	}
-
-	buf := bytes.NewBuffer(make([]byte, 0, insns.Size()))
-	if err := insns.Marshal(buf, internal.NativeEndian); err != nil {
-		return nil, err
-	}
-
-	bytecode := buf.Bytes()
-	instructions := sys.NewSlicePointer(bytecode)
-
-	// Some programs have expected attach types which are checked during the
-	// BPF_PROG_LOAD syscall.
-	switch pt {
-	case ebpf.CGroupSockAddr:
-		expectedAttachType = ebpf.AttachCGroupInet4Connect
-	case ebpf.CGroupSockopt:
-		expectedAttachType = ebpf.AttachCGroupGetsockopt
-	case ebpf.SkLookup:
-		expectedAttachType = ebpf.AttachSkLookup
-	case ebpf.Syscall:
-		progFlags = unix.BPF_F_SLEEPABLE
-	default:
-		expectedAttachType = ebpf.AttachNone
-	}
-
-	// Kernels before 5.0 (6c4fc209fcf9 "bpf: remove useless version check for prog load")
-	// require the version field to be set to the value of the KERNEL_VERSION
-	// macro for kprobe-type programs.
-	v, err := internal.KernelVersion()
-	if err != nil {
-		return nil, fmt.Errorf("detecting kernel version: %w", err)
-	}
-
-	return &sys.ProgLoadAttr{
-		ProgType:           sys.ProgType(pt),
-		Insns:              instructions,
-		InsnCnt:            uint32(len(bytecode) / asm.InstructionSize),
-		ProgFlags:          progFlags,
-		ExpectedAttachType: sys.AttachType(expectedAttachType),
-		License:            sys.NewStringPointer("GPL"),
-		KernVersion:        v.Kernel(),
-	}, nil
-}
-
 // HaveProgType probes the running kernel for the availability of the specified program type.
 //
 // Deprecated: use HaveProgramType() instead.
@@ -101,21 +24,6 @@ func HaveProgramType(pt ebpf.ProgramType) (err error) {
 	return haveProgramTypeMatrix.Result(pt)
 }
 
-func validateProgramType(pt ebpf.ProgramType) error {
-	if pt > pt.Max() {
-		return os.ErrInvalid
-	}
-
-	if progLoadProbeNotImplemented(pt) {
-		// A probe for a these prog types has BTF requirements we currently cannot meet
-		// Once we figure out how to add a working probe in this package, we can remove
-		// this check
-		return fmt.Errorf("a probe for ProgType %s isn't implemented", pt.String())
-	}
-
-	return nil
-}
-
 func probeProgram(spec *ebpf.ProgramSpec) error {
 	if spec.Instructions == nil {
 		spec.Instructions = asm.Instructions{
@@ -231,6 +139,18 @@ func init() {
 	}
 }
 
+type helperKey struct {
+	typ    ebpf.ProgramType
+	helper asm.BuiltinFunc
+}
+
+var helperCache = struct {
+	sync.Mutex
+	results map[helperKey]error
+}{
+	results: make(map[helperKey]error),
+}
+
 // HaveProgramHelper probes the running kernel for the availability of the specified helper
 // function to a specified program type.
 // Return values have the following semantics:
@@ -250,42 +170,49 @@ func HaveProgramHelper(pt ebpf.ProgramType, helper asm.BuiltinFunc) (err error)
 		err = wrapProbeErrors(err)
 	}()
 
-	if err := validateProgramType(pt); err != nil {
-		return err
-	}
-
-	if err := validateProgramHelper(helper); err != nil {
-		return err
-	}
-
-	return haveProgramHelper(pt, helper)
-}
-
-func validateProgramHelper(helper asm.BuiltinFunc) error {
 	if helper > helper.Max() {
 		return os.ErrInvalid
 	}
 
-	return nil
+	return haveProgramHelper(pt, helper)
 }
 
 func haveProgramHelper(pt ebpf.ProgramType, helper asm.BuiltinFunc) error {
-	pc.helperMu.Lock()
-	defer pc.helperMu.Unlock()
-	if err, ok := pc.helpers[pt][helper]; ok {
+	helperCache.Lock()
+	defer helperCache.Unlock()
+
+	key := helperKey{pt, helper}
+	if err, ok := helperCache.results[key]; ok {
 		return err
 	}
 
-	attr, err := createProgLoadAttr(pt, helper)
-	if err != nil {
-		return fmt.Errorf("couldn't create the program load attribute: %w", err)
+	if err := HaveProgramType(pt); err != nil {
+		return err
 	}
 
-	fd, err := sys.ProgLoad(attr)
-	if fd != nil {
-		fd.Close()
+	spec := &ebpf.ProgramSpec{
+		Type: pt,
+		Instructions: asm.Instructions{
+			helper.Call(),
+			asm.LoadImm(asm.R0, 0, asm.DWord),
+			asm.Return(),
+		},
+		License: "GPL",
 	}
 
+	switch pt {
+	case ebpf.CGroupSockAddr:
+		spec.AttachType = ebpf.AttachCGroupInet4Connect
+	case ebpf.CGroupSockopt:
+		spec.AttachType = ebpf.AttachCGroupGetsockopt
+	case ebpf.SkLookup:
+		spec.AttachType = ebpf.AttachSkLookup
+	case ebpf.Syscall:
+		spec.Flags = unix.BPF_F_SLEEPABLE
+	}
+
+	err := probeProgram(spec)
+
 	switch {
 	// EACCES occurs when attempting to create a program probe with a helper
 	// while the register args when calling this helper aren't set up properly.
@@ -296,23 +223,11 @@ func haveProgramHelper(pt ebpf.ProgramType, helper asm.BuiltinFunc) error {
 		err = nil
 
 	// EINVAL occurs when attempting to create a program with an unknown helper.
-	// E2BIG occurs when BPFProgLoadAttr contains non-zero bytes past the end
-	// of the struct known by the running kernel, meaning the kernel is too old
-	// to support the given prog type.
-	case errors.Is(err, unix.EINVAL), errors.Is(err, unix.E2BIG):
+	case errors.Is(err, unix.EINVAL):
 		// TODO: possibly we need to check verifier output here to be sure
 		err = ebpf.ErrNotSupported
 	}
 
-	pc.helpers[pt][helper] = err
-
+	helperCache.results[key] = err
 	return err
 }
-
-func progLoadProbeNotImplemented(pt ebpf.ProgramType) bool {
-	switch pt {
-	case ebpf.Tracing, ebpf.Extension, ebpf.LSM:
-		return true
-	}
-	return false
-}

features/prog_test.go

@@ -12,40 +12,6 @@ import (
 	"github.com/cilium/ebpf/internal/testutils"
 )
 
-var progTypeMinVersion = map[ebpf.ProgramType]string{
-	ebpf.SocketFilter:          "3.19",
-	ebpf.Kprobe:                "4.1",
-	ebpf.SchedCLS:              "4.1",
-	ebpf.SchedACT:              "4.1",
-	ebpf.TracePoint:            "4.7",
-	ebpf.XDP:                   "4.8",
-	ebpf.PerfEvent:             "4.9",
-	ebpf.CGroupSKB:             "4.10",
-	ebpf.CGroupSock:            "4.10",
-	ebpf.LWTIn:                 "4.10",
-	ebpf.LWTOut:                "4.10",
-	ebpf.LWTXmit:               "4.10",
-	ebpf.SockOps:               "4.13",
-	ebpf.SkSKB:                 "4.14",
-	ebpf.CGroupDevice:          "4.15",
-	ebpf.SkMsg:                 "4.17",
-	ebpf.RawTracepoint:         "4.17",
-	ebpf.CGroupSockAddr:        "4.17",
-	ebpf.LWTSeg6Local:          "4.18",
-	ebpf.LircMode2:             "4.18",
-	ebpf.SkReuseport:           "4.19",
-	ebpf.FlowDissector:         "4.20",
-	ebpf.CGroupSysctl:          "5.2",
-	ebpf.RawTracepointWritable: "5.2",
-	ebpf.CGroupSockopt:         "5.3",
-	ebpf.Tracing:               "5.5",
-	ebpf.StructOps:             "5.6",
-	ebpf.Extension:             "5.6",
-	ebpf.LSM:                   "5.7",
-	ebpf.SkLookup:              "5.9",
-	ebpf.Syscall:               "5.14",
-}
-
 func TestHaveProgramType(t *testing.T) {
 	testutils.CheckFeatureMatrix(t, haveProgramTypeMatrix)
 }
@@ -97,26 +63,10 @@ func TestHaveProgramHelper(t *testing.T) {
 	}
 
 	for _, tc := range testCases {
-		minVersion := progTypeMinVersion[tc.prog]
-
-		progVersion, err := internal.NewVersion(minVersion)
-		if err != nil {
-			t.Fatalf("Could not read kernel version required for program: %v", err)
-		}
-
-		helperVersion, err := internal.NewVersion(tc.version)
-		if err != nil {
-			t.Fatalf("Could not read kernel version required for helper: %v", err)
-		}
-
-		if progVersion.Less(helperVersion) {
-			minVersion = tc.version
-		}
-
 		t.Run(fmt.Sprintf("%s/%s", tc.prog.String(), tc.helper.String()), func(t *testing.T) {
 			feature := fmt.Sprintf("helper %s for program type %s", tc.helper.String(), tc.prog.String())
 
-			testutils.SkipOnOldKernel(t, minVersion, feature)
+			testutils.SkipOnOldKernel(t, tc.version, feature)
 
 			err := HaveProgramHelper(tc.prog, tc.helper)
 			if !errors.Is(err, tc.expected) {
@@ -129,14 +79,9 @@ func TestHaveProgramHelper(t *testing.T) {
 }
 
 func TestHaveProgramHelperUnsupported(t *testing.T) {
-	pt := ebpf.SocketFilter
-	minVersion := progTypeMinVersion[pt]
-
-	feature := fmt.Sprintf("program type %s", pt.String())
-
-	testutils.SkipOnOldKernel(t, minVersion, feature)
+	testutils.SkipIfNotSupported(t, HaveProgramType(ebpf.SocketFilter))
 
-	if err := haveProgramHelper(pt, asm.BuiltinFunc(math.MaxInt32)); !errors.Is(err, ebpf.ErrNotSupported) {
+	if err := haveProgramHelper(ebpf.SocketFilter, asm.BuiltinFunc(math.MaxInt32)); !errors.Is(err, ebpf.ErrNotSupported) {
 		t.Fatalf("Expected ebpf.ErrNotSupported but was: %v", err)
 	}
 }

types.go

@@ -117,11 +117,6 @@ func (mt MapType) canStoreProgram() bool {
 // ProgramType of the eBPF program
 type ProgramType uint32
 
-// Max return the latest supported ProgramType.
-func (ProgramType) Max() ProgramType {
-	return maxProgramType - 1
-}
-
 // eBPF program types
 const (
 	UnspecifiedProgram ProgramType = iota
@@ -156,7 +151,6 @@ const (
 	LSM
 	SkLookup
 	Syscall
-	maxProgramType
 )
 
 // AttachType of the eBPF program, needed to differentiate allowed context accesses in