info: expose func info from ProgramInfo

`bpf_prog_info` supports func info since commit
torvalds/linux@838e96904ff3 ("bpf: Introduce bpf_func_info").

Signed-off-by: Leon Hwang <[email protected]>

Author: Asphaltt

info.go

@@ -532,6 +532,64 @@ func (pi *ProgramInfo) KsymAddrs() ([]uintptr, bool) {
 	return ptrs, pi.numKsymInfos > 0
 }
 
+// ProgramFunctionInfo describes a function of an insn in a program.
+type ProgramFunctionInfo struct {
+	// InstructionOffset is the offset of the insn in the program's instructions.
+	InstructionOffset uint64
+
+	// FuncInfo is the BTF function information.
+	FuncInfo *btf.Func
+}
+
+// FuncInfos returns the function information of bpf programs, including
+// subprograms, of current bpf program.
+//
+// Available from 5.0.
+func (pi *ProgramInfo) FuncInfos() ([]ProgramFunctionInfo, error) {
+	if pi.numFuncInfos == 0 {
+		return nil, nil
+	}
+
+	btfID, ok := pi.BTFID()
+	if !ok {
+		return nil, nil
+	}
+
+	handle, err := btf.NewHandleFromID(btfID)
+	if err != nil {
+		return nil, fmt.Errorf("unable to get BTF handle: %w", err)
+	}
+	defer handle.Close()
+
+	btfSpec, err := handle.Spec(nil)
+	if err != nil {
+		return nil, fmt.Errorf("unable to get BTF spec: %w", err)
+	}
+
+	funcs := make([]ProgramFunctionInfo, 0, pi.numFuncInfos)
+
+	ptr := (*sys.FuncInfo)(unsafe.Pointer(&pi.funcInfos[0]))
+	funcInfos := unsafe.Slice(ptr, int(pi.numFuncInfos))
+	for _, funcInfo := range funcInfos {
+		btfInfo, err := btfSpec.TypeByID(sys.TypeID(funcInfo.TypeId))
+		if err != nil {
+			return nil, fmt.Errorf("unable to get BTF type: %w", err)
+		}
+
+		funcBtfInfo, ok := btfInfo.(*btf.Func)
+		if !ok {
+			return nil, fmt.Errorf("unexpected BTF type: %T, expected %T", btfInfo, funcBtfInfo)
+		}
+
+		funcs = append(funcs, ProgramFunctionInfo{
+			InstructionOffset: uint64(funcInfo.InsnOff),
+			FuncInfo:          funcBtfInfo,
+		})
+	}
+
+	return funcs, nil
+}
+
 func scanFdInfo(fd *sys.FD, fields map[string]interface{}) error {
 	fh, err := os.Open(fmt.Sprintf("/proc/self/fdinfo/%d", fd.Int()))
 	if err != nil {

info_test.go

@@ -546,3 +546,56 @@ func TestProgInfoKsym(t *testing.T) {
 		}
 	}
 }
+
+func TestProgInfoFuncInfo(t *testing.T) {
+	testutils.SkipOnOldKernel(t, "5.0", "Program func info")
+
+	spec, err := LoadCollectionSpec(testutils.NativeFile(t, "testdata/loader-%s.elf"))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	var obj struct {
+		Main *Program `ebpf:"xdp_prog"`
+	}
+
+	err = spec.LoadAndAssign(&obj, nil)
+	testutils.SkipIfNotSupported(t, err)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer obj.Main.Close()
+
+	info, err := obj.Main.Info()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	funcs, err := info.FuncInfos()
+	if err != nil {
+		t.Fatalf("failed to get func infos: %v", err)
+	}
+
+	expectedNumFuncInfos := uint32(5)
+	if info.numFuncInfos != expectedNumFuncInfos {
+		t.Fatalf("expected %d ksym infos, got %d", expectedNumFuncInfos, info.numFuncInfos)
+	}
+
+	expectedFuncInfo := map[string]bool{
+		"xdp_prog":   false,
+		"static_fn":  false,
+		"global_fn":  false,
+		"global_fn2": false,
+		"global_fn3": false,
+	}
+
+	for _, funcInfo := range funcs {
+		expectedFuncInfo[funcInfo.FuncInfo.Name] = true
+	}
+
+	for fn, found := range expectedFuncInfo {
+		if !found {
+			t.Errorf("func %q not found", fn)
+		}
+	}
+}