btf: disable handle API on windows

Windows currently has no / limited BTF support. Disable the API for now.

Signed-off-by: Lorenz Bauer <[email protected]>

Author: lmb

.github/workflows/ci.yml

@@ -348,6 +348,7 @@ jobs:
           gotestsum --raw-command --ignore-non-json-output-lines --junitfile junit.xml --
           go test -short -count 1 -json
           ./asm
+          ./btf
           ./internal
           ./internal/efw
           ./internal/kallsyms

btf/core.go

@@ -11,6 +11,8 @@ import (
 	"strings"
 
 	"github.com/cilium/ebpf/asm"
+	"github.com/cilium/ebpf/internal"
+	"github.com/cilium/ebpf/internal/platform"
 )
 
 // Code in this file is derived from libbpf, which is available under a BSD
@@ -46,6 +48,10 @@ func (f *COREFixup) String() string {
 }
 
 func (f *COREFixup) Apply(ins *asm.Instruction) error {
+	if !platform.IsLinux {
+		return fmt.Errorf("CO-RE fixup: %w", internal.ErrNotSupportedOnOS)
+	}
+
 	if f.poison {
 		// Relocation is poisoned, replace the instruction with an invalid one.
 		if ins.OpCode.IsDWordLoad() {

btf/core_reloc_test.go

@@ -120,15 +120,14 @@ func TestLD64IMMReloc(t *testing.T) {
 	}
 
 	coll, err := ebpf.NewCollection(spec)
+	testutils.SkipIfNotSupportedOnOS(t, err)
 	if err != nil {
 		t.Fatal(err)
 	}
 	defer coll.Close()
 }
 
 func TestCOREPoisonLineInfo(t *testing.T) {
-	testutils.SkipOnOldKernel(t, "5.0", "program ext_infos")
-
 	spec, err := ebpf.LoadCollectionSpec(testutils.NativeFile(t, "../testdata/errors-%s.elf"))
 	qt.Assert(t, qt.IsNil(err))
 

btf/handle.go

@@ -8,6 +8,7 @@ import (
 	"os"
 
 	"github.com/cilium/ebpf/internal"
+	"github.com/cilium/ebpf/internal/platform"
 	"github.com/cilium/ebpf/internal/sys"
 	"github.com/cilium/ebpf/internal/unix"
 )
@@ -43,6 +44,10 @@ func NewHandle(b *Builder) (*Handle, error) {
 func NewHandleFromRawBTF(btf []byte) (*Handle, error) {
 	const minLogSize = 64 * 1024
 
+	if platform.IsWindows {
+		return nil, fmt.Errorf("btf: handle: %w", internal.ErrNotSupportedOnOS)
+	}
+
 	if uint64(len(btf)) > math.MaxUint32 {
 		return nil, errors.New("BTF exceeds the maximum size")
 	}
@@ -110,6 +115,10 @@ func NewHandleFromRawBTF(btf []byte) (*Handle, error) {
 //
 // Requires CAP_SYS_ADMIN.
 func NewHandleFromID(id ID) (*Handle, error) {
+	if platform.IsWindows {
+		return nil, fmt.Errorf("btf: handle: %w", internal.ErrNotSupportedOnOS)
+	}
+
 	fd, err := sys.BtfGetFdById(&sys.BtfGetFdByIdAttr{
 		Id: uint32(id),
 	})
@@ -242,6 +251,11 @@ type HandleIterator struct {
 // Returns true if another BTF object was found. Call [HandleIterator.Err] after
 // the function returns false.
 func (it *HandleIterator) Next() bool {
+	if platform.IsWindows {
+		it.err = fmt.Errorf("btf: %w", internal.ErrNotSupportedOnOS)
+		return false
+	}
+
 	id := it.ID
 	for {
 		attr := &sys.BtfGetNextIdAttr{Id: id}

btf/handle_test.go

@@ -18,6 +18,7 @@ func TestHandleIterator(t *testing.T) {
 	defer it.Handle.Close()
 
 	if !it.Next() {
+		testutils.SkipIfNotSupportedOnOS(t, it.Err())
 		t.Fatalf("No BTF loaded")
 	}
 	if it.Handle == nil {
@@ -57,6 +58,7 @@ func TestParseModuleSplitSpec(t *testing.T) {
 		}
 		return false
 	})
+	testutils.SkipIfNotSupportedOnOS(t, err)
 	if err != nil {
 		t.Fatal(err)
 	}

btf/kernel.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/cilium/ebpf/internal"
 	"github.com/cilium/ebpf/internal/linux"
+	"github.com/cilium/ebpf/internal/platform"
 )
 
 var kernelBTF = struct {
@@ -85,14 +86,18 @@ func LoadKernelModuleSpec(module string) (*Spec, error) {
 
 	spec, err = loadKernelModuleSpec(module, base)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("load kernel module: %w", err)
 	}
 
 	kernelBTF.modules[module] = spec
 	return spec.Copy(), nil
 }
 
 func loadKernelSpec() (_ *Spec, fallback bool, _ error) {
+	if platform.IsWindows {
+		return nil, false, internal.ErrNotSupportedOnOS
+	}
+
 	fh, err := os.Open("/sys/kernel/btf/vmlinux")
 	if err == nil {
 		defer fh.Close()
@@ -112,6 +117,10 @@ func loadKernelSpec() (_ *Spec, fallback bool, _ error) {
 }
 
 func loadKernelModuleSpec(module string, base *Spec) (*Spec, error) {
+	if platform.IsWindows {
+		return nil, internal.ErrNotSupportedOnOS
+	}
+
 	dir, file := filepath.Split(module)
 	if dir != "" || filepath.Ext(file) != "" {
 		return nil, fmt.Errorf("invalid module name %q", module)
@@ -128,6 +137,10 @@ func loadKernelModuleSpec(module string, base *Spec) (*Spec, error) {
 
 // findVMLinux scans multiple well-known paths for vmlinux kernel images.
 func findVMLinux() (*os.File, error) {
+	if platform.IsWindows {
+		return nil, fmt.Errorf("find vmlinux: %w", internal.ErrNotSupportedOnOS)
+	}
+
 	release, err := linux.KernelRelease()
 	if err != nil {
 		return nil, err

btf/workarounds_test.go

@@ -55,6 +55,7 @@ func TestDatasecResolveWorkaround(t *testing.T) {
 			}
 
 			h, err := NewHandle(b)
+			testutils.SkipIfNotSupportedOnOS(t, err)
 			var ve *internal.VerifierError
 			if errors.As(err, &ve) {
 				t.Fatalf("%+v\n", ve)

testdata/errors-eb.elf

@@ -7,12 +7,21 @@ struct nonexist {
 
 enum nonexist_enum { NON_EXIST = 1 };
 
+// Force loading program with BTF by including a relocation for a local type.
+#define FORCE_BTF \
+	do { \
+		if (bpf_core_type_id_local(int) == 0) \
+			return __LINE__; \
+	} while (0)
+
 __section("socket") int poisoned_single() {
+	FORCE_BTF;
 	struct nonexist ne;
 	return core_access(ne.non_exist);
 }
 
 __section("socket") int poisoned_double() {
+	FORCE_BTF;
 	return bpf_core_enum_value(enum nonexist_enum, NON_EXIST);
 }