prog: friendly error w/ sentinel if kernel doesn't support bpf2bpf

If a program has function references, return ErrNotSupported if program
creation fails and we know the kernel doesn't support bpf2bpf calls, or if the
user is unprivileged.

Signed-off-by: Timo Beckers <timo@isovalent.com>

internal/btf/core_reloc_test.go

@@ -90,8 +90,6 @@ func TestCORERelocationRead(t *testing.T) {
 		}
 		defer tgt.Close()
 
-		testutils.SkipOnOldKernel(t, "4.16", "bpf2bpf calls")
-
 		for _, progSpec := range spec.Programs {
 			t.Run(progSpec.Name, func(t *testing.T) {
 				if _, err := tgt.Seek(0, io.SeekStart); err != nil {
@@ -101,6 +99,7 @@ func TestCORERelocationRead(t *testing.T) {
 				prog, err := ebpf.NewProgramWithOptions(progSpec, ebpf.ProgramOptions{
 					TargetBTF: tgt,
 				})
+				testutils.SkipIfNotSupported(t, err)
 				if err != nil {
 					t.Fatal("Load program:", err)
 				}

linker.go

@@ -110,6 +110,17 @@ func findReferences(progs map[string]*ProgramSpec) error {
 	return nil
 }
 
+// hasReferences returns true if insns contains one or more bpf2bpf
+// function references.
+func hasReferences(insns asm.Instructions) bool {
+	for _, i := range insns {
+		if i.IsFunctionReference() {
+			return true
+		}
+	}
+	return false
+}
+
 // applyRelocations collects and applies any CO-RE relocations in insns.
 //
 // Passing a nil target will relocate against the running kernel. insns are

linker_test.go

@@ -42,9 +42,8 @@ func TestFindReferences(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	testutils.SkipOnOldKernel(t, "4.16", "bpf2bpf calls")
-
 	prog, err := NewProgram(progs["entrypoint"])
+	testutils.SkipIfNotSupported(t, err)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -66,8 +65,6 @@ func TestForwardFunctionDeclaration(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		testutils.SkipOnOldKernel(t, "4.16", "bpf2bpf calls")
-
 		if coll.ByteOrder != internal.NativeEndian {
 			return
 		}
@@ -91,6 +88,7 @@ func TestForwardFunctionDeclaration(t *testing.T) {
 		spec.BTF = nil
 
 		prog, err := NewProgram(spec)
+		testutils.SkipIfNotSupported(t, err)
 		if err != nil {
 			t.Fatal(err)
 		}

prog.go

@@ -361,6 +361,12 @@ func newProgramWithOptions(spec *ProgramSpec, opts ProgramOptions, handles *hand
 		}
 	}
 
+	if (errors.Is(err, unix.EINVAL) || errors.Is(err, unix.EPERM)) && hasReferences(spec.Instructions) {
+		if err := haveBPFToBPFCalls(); err != nil {
+			return nil, fmt.Errorf("load program: %w", internal.ErrorWithLog(err, logBuf, logErr))
+		}
+	}
+
 	if errors.Is(logErr, unix.EPERM) && len(logBuf) > 0 && logBuf[0] == 0 {
 		// EPERM due to RLIMIT_MEMLOCK happens before the verifier, so we can
 		// check that the log is empty to reduce false positives.

prog_test.go

@@ -374,6 +374,7 @@ func TestProgramWithUnsatisfiedMap(t *testing.T) {
 	progSpec.ByteOrder = nil
 
 	_, err = NewProgram(progSpec)
+	testutils.SkipIfNotSupported(t, err)
 	if !errors.Is(err, asm.ErrUnsatisfiedMapReference) {
 		t.Fatal("Expected an error wrapping asm.ErrUnsatisfiedMapReference, got", err)
 	}