feat: more link inspection support

internal/cmd/gentypes/main.go

@@ -768,6 +768,16 @@ import (
 				replace(uint64Ptr, "cookies"),
 			},
 		},
+		{"UprobeMultiLinkInfo",
+			[]patch{
+				choose(3, "uprobe_multi"),
+				flattenAnon,
+				replace(bytePtr, "path"),
+				replace(uint64Ptr, "offsets"),
+				replace(uint64Ptr, "ref_ctr_offsets"),
+				replace(uint64Ptr, "cookies"),
+			},
+		},
 		{"PerfEventLinkInfo",
 			[]patch{
 				choose(3, "perf_event"),
@@ -788,6 +798,39 @@ import (
 				replace(bytePtr, "func_name"),
 			},
 		},
+		{"UprobeLinkInfo",
+			[]patch{
+				choose(3, "perf_event"),
+				flattenAnon,
+				renameNth(3, "perf_event_type"),
+				replace(enumTypes["PerfEventType"], "perf_event_type"),
+				choose(4, "uprobe"),
+				flattenAnon,
+				replace(bytePtr, "file_name"),
+			},
+		},
+		{"TracepointLinkInfo",
+			[]patch{
+				choose(3, "perf_event"),
+				flattenAnon,
+				renameNth(3, "perf_event_type"),
+				replace(enumTypes["PerfEventType"], "perf_event_type"),
+				choose(4, "tracepoint"),
+				flattenAnon,
+				replace(bytePtr, "tp_name"),
+			},
+		},
+		{"EventLinkInfo",
+			[]patch{
+				choose(3, "perf_event"),
+				flattenAnon,
+				renameNth(3, "perf_event_type"),
+				replace(enumTypes["PerfEventType"], "perf_event_type"),
+				choose(4, "event"),
+				flattenAnon,
+				renameNth(5, "event_type"),
+			},
+		},
 	}
 
 	sort.Slice(linkInfoExtraTypes, func(i, j int) bool {

internal/sys/syscall.go

@@ -72,10 +72,30 @@ func (i *KprobeMultiLinkInfo) info() (unsafe.Pointer, uint32) {
 	return unsafe.Pointer(i), uint32(unsafe.Sizeof(*i))
 }
 
+func (i *UprobeMultiLinkInfo) info() (unsafe.Pointer, uint32) {
+	return unsafe.Pointer(i), uint32(unsafe.Sizeof(*i))
+}
+
+func (i *RawTracepointLinkInfo) info() (unsafe.Pointer, uint32) {
+	return unsafe.Pointer(i), uint32(unsafe.Sizeof(*i))
+}
+
 func (i *KprobeLinkInfo) info() (unsafe.Pointer, uint32) {
 	return unsafe.Pointer(i), uint32(unsafe.Sizeof(*i))
 }
 
+func (i *UprobeLinkInfo) info() (unsafe.Pointer, uint32) {
+	return unsafe.Pointer(i), uint32(unsafe.Sizeof(*i))
+}
+
+func (i *TracepointLinkInfo) info() (unsafe.Pointer, uint32) {
+	return unsafe.Pointer(i), uint32(unsafe.Sizeof(*i))
+}
+
+func (i *EventLinkInfo) info() (unsafe.Pointer, uint32) {
+	return unsafe.Pointer(i), uint32(unsafe.Sizeof(*i))
+}
+
 var _ Info = (*BtfInfo)(nil)
 
 func (i *BtfInfo) info() (unsafe.Pointer, uint32) {

internal/sys/types.go

@@ -1541,6 +1541,21 @@ type CgroupLinkInfo struct {
 	_          [36]byte
 }
 
+type EventLinkInfo struct {
+	_             structs.HostLayout
+	Type          LinkType
+	Id            LinkID
+	ProgId        uint32
+	_             [4]byte
+	PerfEventType PerfEventType
+	_             [4]byte
+	Config        uint64
+	EventType     uint32
+	_             [4]byte
+	Cookie        uint64
+	_             [16]byte
+}
+
 type IterLinkInfo struct {
 	_             structs.HostLayout
 	Type          LinkType
@@ -1647,6 +1662,21 @@ type TcxLinkInfo struct {
 	_          [40]byte
 }
 
+type TracepointLinkInfo struct {
+	_             structs.HostLayout
+	Type          LinkType
+	Id            LinkID
+	ProgId        uint32
+	_             [4]byte
+	PerfEventType PerfEventType
+	_             [4]byte
+	TpName        TypedPointer[uint8]
+	NameLen       uint32
+	_             [4]byte
+	Cookie        uint64
+	_             [16]byte
+}
+
 type TracingLinkInfo struct {
 	_           structs.HostLayout
 	Type        LinkType
@@ -1659,6 +1689,38 @@ type TracingLinkInfo struct {
 	_           [36]byte
 }
 
+type UprobeLinkInfo struct {
+	_             structs.HostLayout
+	Type          LinkType
+	Id            LinkID
+	ProgId        uint32
+	_             [4]byte
+	PerfEventType PerfEventType
+	_             [4]byte
+	FileName      TypedPointer[uint8]
+	NameLen       uint32
+	Offset        uint32
+	Cookie        uint64
+	RefCtrOffset  uint64
+	_             [8]byte
+}
+
+type UprobeMultiLinkInfo struct {
+	_             structs.HostLayout
+	Type          LinkType
+	Id            LinkID
+	ProgId        uint32
+	_             [4]byte
+	Path          TypedPointer[uint8]
+	Offsets       TypedPointer[uint64]
+	RefCtrOffsets TypedPointer[uint64]
+	Cookies       TypedPointer[uint64]
+	PathSize      uint32
+	Count         uint32
+	Flags         uint32
+	Pid           uint32
+}
+
 type XDPLinkInfo struct {
 	_       structs.HostLayout
 	Type    LinkType

link/kprobe_multi.go

@@ -157,12 +157,30 @@ func (kml *kprobeMultiLink) Update(_ *ebpf.Program) error {
 func (kml *kprobeMultiLink) Info() (*Info, error) {
 	var info sys.KprobeMultiLinkInfo
 	if err := sys.ObjInfo(kml.fd, &info); err != nil {
-		return nil, fmt.Errorf("kprobe multi link info: %s", err)
+		return nil, fmt.Errorf("kprobe multi link info: %w", err)
+	}
+	var addrs = make([]uint64, info.Count)
+	var cookies = make([]uint64, info.Count)
+	info = sys.KprobeMultiLinkInfo{
+		Addrs:   sys.SlicePointer(addrs),
+		Cookies: sys.SlicePointer(cookies),
+		Count:   uint32(len(addrs)),
+	}
+	if err := sys.ObjInfo(kml.fd, &info); err != nil {
+		return nil, fmt.Errorf("kprobe multi link info: %w", err)
+	}
+	if info.Addrs.IsNil() {
+		addrs = nil
+	}
+	if info.Cookies.IsNil() {
+		cookies = nil
 	}
 	extra := &KprobeMultiInfo{
-		count:  info.Count,
-		flags:  info.Flags,
-		missed: info.Missed,
+		count:   info.Count,
+		flags:   info.Flags,
+		missed:  info.Missed,
+		addrs:   addrs,
+		cookies: cookies,
 	}
 
 	return &Info{

link/kprobe_multi_test.go

@@ -31,6 +31,29 @@ func TestKprobeMulti(t *testing.T) {
 	testLink(t, km, prog)
 }
 
+func TestKprobeMultiInfo(t *testing.T) {
+	testutils.SkipIfNotSupported(t, haveBPFLinkKprobeMulti())
+	testutils.SkipOnOldKernel(t, "6.6", "bpf_link_info_kprobe_multi")
+
+	prog := mustLoadProgram(t, ebpf.Kprobe, ebpf.AttachTraceKprobeMulti, "")
+
+	km, err := KprobeMulti(prog, KprobeMultiOptions{Symbols: kprobeMultiSyms})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer km.Close()
+
+	info, err := km.Info()
+	if err != nil {
+		t.Fatal(err)
+	}
+	kmInfo := info.KprobeMulti()
+	addresses, ok := kmInfo.Addresses()
+	qt.Assert(t, qt.IsTrue(ok))
+	// kprobe_multi only returns addresses, no symbols, so we can't verify that the addresses are correct
+	qt.Assert(t, qt.HasLen(addresses, len(kprobeMultiSyms)))
+}
+
 func TestKprobeMultiInput(t *testing.T) {
 	// Program type that loads on all kernels. Not expected to link successfully.
 	prog := mustLoadProgram(t, ebpf.SocketFilter, 0, "")

link/kprobe_test.go

@@ -53,6 +53,21 @@ func TestKprobe(t *testing.T) {
 	testLink(t, k, prog)
 }
 
+func TestKprobeInfo(t *testing.T) {
+	testutils.SkipOnOldKernel(t, "6.6", "bpf_link_info_perf_event")
+
+	prog := mustLoadProgram(t, ebpf.Kprobe, 0, "")
+
+	k, err := Kprobe(ksym, prog, nil)
+	qt.Assert(t, qt.IsNil(err))
+	defer k.Close()
+
+	info, err := k.Info()
+	qt.Assert(t, qt.IsNil(err))
+	qt.Assert(t, qt.Equals(info.PerfEvent().Kprobe().Function, ksym))
+	qt.Assert(t, qt.Equals(info.PerfEvent().Kprobe().Offset, 0))
+}
+
 func TestKprobeOffset(t *testing.T) {
 	prog := mustLoadProgram(t, ebpf.Kprobe, 0, "")