From 2f1be3fe389653bdaa4bba41ddb60463bdf1c145 Mon Sep 17 00:00:00 2001 From: sridhar Date: Fri, 13 Feb 2026 12:25:18 -0800 Subject: [PATCH 1/5] Fix BPF Tests in 25.10 kernel. --- felix/bpf/libbpf/libbpf.go | 1 + felix/bpf/libbpf/libbpf_stub.go | 1 + felix/bpf/ut/attach_test.go | 72 ++++++++++++++++++----------- felix/bpf/ut/bpf_prog_test.go | 6 ++- felix/dataplane/linux/bpf_ep_mgr.go | 1 + felix/fv/bpf_test.go | 58 +++++++++++++++++------ 6 files changed, 97 insertions(+), 42 deletions(-) diff --git a/felix/bpf/libbpf/libbpf.go b/felix/bpf/libbpf/libbpf.go index b49a9374f67..7f8e103d19e 100644 --- a/felix/bpf/libbpf/libbpf.go +++ b/felix/bpf/libbpf/libbpf.go @@ -607,6 +607,7 @@ const ( AttachTypeTcxIngress uint32 = C.BPF_TCX_INGRESS AttachTypeTcxEgress uint32 = C.BPF_TCX_EGRESS + AttachTypeXDP uint32 = C.BPF_XDP ) func (t *TcGlobalData) Set(m *Map) error { diff --git a/felix/bpf/libbpf/libbpf_stub.go b/felix/bpf/libbpf/libbpf_stub.go index 5724b430145..6f13e68cacd 100644 --- a/felix/bpf/libbpf/libbpf_stub.go +++ b/felix/bpf/libbpf/libbpf_stub.go @@ -205,6 +205,7 @@ const ( GlobalsEgressPacketRateConfigured uint32 = 12345 AttachTypeTcxIngress uint32 = 12345 AttachTypeTcxEgress uint32 = 12345 + AttachTypeXDP uint32 = 12345 ) func (m *Map) SetSize(size int) error { diff --git a/felix/bpf/ut/attach_test.go b/felix/bpf/ut/attach_test.go index 07e5b9bcc88..49aa2546bdf 100644 --- a/felix/bpf/ut/attach_test.go +++ b/felix/bpf/ut/attach_test.go @@ -1266,21 +1266,23 @@ func TestAttachTcx(t *testing.T) { Expect(err).NotTo(HaveOccurred()) loglevel := "off" - bpfEpMgr, err := newBPFTestEpMgr( - &linux.Config{ - Hostname: "uthost", - BPFLogLevel: loglevel, - BPFDataIfacePattern: regexp.MustCompile("^hostep[12]"), - VXLANMTU: 1000, - VXLANPort: 1234, - BPFNodePortDSREnabled: false, - RulesConfig: rules.Config{ - EndpointToHostAction: "RETURN", - }, - BPFExtToServiceConnmark: 0, - BPFPolicyDebugEnabled: true, - BPFAttachType: v3.BPFAttachOptionTCX, + bpfConfig := &linux.Config{ + Hostname: "uthost", + BPFLogLevel: loglevel, + BPFDataIfacePattern: regexp.MustCompile("^hostep[12]"), + VXLANMTU: 1000, + VXLANPort: 1234, + BPFNodePortDSREnabled: false, + RulesConfig: rules.Config{ + EndpointToHostAction: "RETURN", }, + BPFExtToServiceConnmark: 0, + BPFPolicyDebugEnabled: true, + BPFAttachType: v3.BPFAttachOptionTCX, + } + + bpfEpMgr, err := newBPFTestEpMgr( + bpfConfig, bpfmaps, regexp.MustCompile("^workloadep[0123]"), ) @@ -1321,20 +1323,26 @@ func TestAttachTcx(t *testing.T) { tcxProgs, err := tc.ListAttachedTcxPrograms("workloadep0", "ingress") Expect(err).NotTo(HaveOccurred()) Expect(len(tcxProgs)).To(Equal(1)) - // Now attach Tc program. - ap := &tc.AttachPoint{ - AttachPoint: bpf.AttachPoint{ - Iface: "workloadep0", - Hook: hook.Ingress, - }, - HostIPv4: net.IPv4(1, 2, 3, 4), - IntfIPv4: net.IPv4(1, 6, 6, 6), - AttachType: v3.BPFAttachOptionTC, - } - _, err = tc.EnsureQdisc("workloadep0") + bpfConfig.BPFAttachType = v3.BPFAttachOptionTC + bpfEpMgr, err = newBPFTestEpMgr( + bpfConfig, + bpfmaps, + regexp.MustCompile("^workloadep[0123]"), + ) Expect(err).NotTo(HaveOccurred()) - err = ap.AttachProgram() + bpfEpMgr.OnUpdate(&proto.HostMetadataUpdate{Hostname: "uthost", Ipv4Addr: "1.2.3.4"}) + bpfEpMgr.OnUpdate(linux.NewIfaceStateUpdate("workloadep0", ifacemonitor.StateUp, workload0.Attrs().Index)) + bpfEpMgr.OnUpdate(linux.NewIfaceAddrsUpdate("workloadep0", "1.6.6.6")) + bpfEpMgr.OnUpdate(&proto.WorkloadEndpointUpdate{ + Id: &proto.WorkloadEndpointID{ + OrchestratorId: "k8s", + WorkloadId: "workloadep0", + EndpointId: "workloadep0", + }, + Endpoint: &proto.WorkloadEndpoint{Name: "workloadep0"}, + }) + err = bpfEpMgr.CompleteDeferredWork() Expect(err).NotTo(HaveOccurred()) progs, err = tc.ListAttachedPrograms("workloadep0", hook.Ingress.String(), true) Expect(err).NotTo(HaveOccurred()) @@ -1344,7 +1352,17 @@ func TestAttachTcx(t *testing.T) { tcxProgs, err = tc.ListAttachedTcxPrograms("workloadep0", "ingress") Expect(err).NotTo(HaveOccurred()) Expect(len(tcxProgs)).To(Equal(0)) - // Now attach TCx again + + bpfConfig.BPFAttachType = v3.BPFAttachOptionTCX + bpfEpMgr, err = newBPFTestEpMgr( + bpfConfig, + bpfmaps, + regexp.MustCompile("^workloadep[0123]"), + ) + Expect(err).NotTo(HaveOccurred()) + bpfEpMgr.OnUpdate(&proto.HostMetadataUpdate{Hostname: "uthost", Ipv4Addr: "1.2.3.4"}) + bpfEpMgr.OnUpdate(linux.NewIfaceStateUpdate("workloadep0", ifacemonitor.StateUp, workload0.Attrs().Index)) + bpfEpMgr.OnUpdate(linux.NewIfaceAddrsUpdate("workloadep0", "1.6.6.6")) bpfEpMgr.OnUpdate(&proto.WorkloadEndpointUpdate{ Id: &proto.WorkloadEndpointID{ OrchestratorId: "k8s", diff --git a/felix/bpf/ut/bpf_prog_test.go b/felix/bpf/ut/bpf_prog_test.go index e39bda747a7..f31ac7c8ee8 100644 --- a/felix/bpf/ut/bpf_prog_test.go +++ b/felix/bpf/ut/bpf_prog_test.go @@ -474,14 +474,16 @@ func setupAndRun(logger testLogger, loglevel, section string, rules *polprog.Rul } Expect(errs).To(BeEmpty()) }() - var progType uint32 + progType := uint32(0) + attachType := uint32(0) if topts.xdp { progType = unix.BPF_PROG_TYPE_XDP + attachType = libbpf.AttachTypeXDP } else { progType = unix.BPF_PROG_TYPE_SCHED_CLS } for i, p := range insns { - polProgFD, err := bpf.LoadBPFProgramFromInsns(p, "calico_policy", "Apache-2.0", progType) + polProgFD, err := bpf.LoadBPFProgramFromInsnsWithAttachType(p, "calico_policy", "Apache-2.0", progType, attachType) Expect(err).NotTo(HaveOccurred(), "failed to load program into the kernel") Expect(polProgFD).NotTo(BeZero()) polProgFDs = append(polProgFDs, polProgFD) diff --git a/felix/dataplane/linux/bpf_ep_mgr.go b/felix/dataplane/linux/bpf_ep_mgr.go index c94c5815d9a..a1c8eff637c 100644 --- a/felix/dataplane/linux/bpf_ep_mgr.go +++ b/felix/dataplane/linux/bpf_ep_mgr.go @@ -4145,6 +4145,7 @@ func (m *bpfEndpointManager) doUpdatePolicyProgram( if hk == hook.XDP { polProgsMap = m.commonMaps.XDPJumpMap stride = jump.XDPMaxEntryPoints + attachType = libbpf.AttachTypeXDP } opts = append(opts, polprog.WithPolicyMapIndexAndStride(polJumpMapIdx, stride)) diff --git a/felix/fv/bpf_test.go b/felix/fv/bpf_test.go index a8233c916e5..9b702ec7ce3 100644 --- a/felix/fv/bpf_test.go +++ b/felix/fv/bpf_test.go @@ -1190,6 +1190,40 @@ func describeBPFTests(opts ...bpfTestOpt) bool { By("Waiting for dp to get setup up") ensureBPFProgramsAttached(tc.Felixes[0], "bpfout.cali") + getPreambleProgramIDs := func() []int { + var bpfnet []struct { + TC []struct { + Name string `json:"name"` + ID int `json:"prog_id"` + } `json:"tc"` + } + out, err := tc.Felixes[0].ExecOutput("bpftool", "net", "show", "-j") + Expect(err).NotTo(HaveOccurred()) + err = json.Unmarshal([]byte(out), &bpfnet) + Expect(err).NotTo(HaveOccurred()) + var preambleIDs []int + for _, entry := range bpfnet { + for _, prog := range entry.TC { + if strings.Contains(prog.Name, "cali_tc_pream") { + preambleIDs = append(preambleIDs, prog.ID) + } + } + } + return preambleIDs + } + Eventually(func() int { + return len(getPreambleProgramIDs()) + }, "15s", "1s").Should(Equal(10)) // 10 = 2 (ingress+egress) * 5 interfaces (bpfout, lo, eth0, caliXXX x2) + + // check for bpf maps + out, err := tc.Felixes[0].ExecOutput("ls", "/sys/fs/bpf/tc/globals/") + Expect(err).NotTo(HaveOccurred()) + Expect(out).To(Not(Equal(""))) + + // check for cgroups + out, err = tc.Felixes[0].ExecOutput("bpftool", "cgroup", "show", "/run/calico/cgroup") + Expect(err).NotTo(HaveOccurred()) + Expect(out).To(ContainSubstring("calico_connect")) By("Changing env and restarting felix") @@ -1198,21 +1232,19 @@ func describeBPFTests(opts ...bpfTestOpt) bool { By("Checking that all programs got cleaned up") - Eventually(func() string { - out, _ := tc.Felixes[0].ExecOutput("bpftool", "-jp", "prog", "show") - return out - }, "15s", "1s").ShouldNot( - Or(ContainSubstring("cali_"), ContainSubstring("calico_"), ContainSubstring("xdp_cali_"))) + Eventually(func() int { + return len(getPreambleProgramIDs()) + }, "15s", "1s").Should(Equal(0)) - // N.B. calico_failsafe map is created in iptables mode by - // bpf.NewFailsafeMap() It has calico_ prefix. All other bpf - // maps have only cali_ prefix. - Eventually(func() string { - out, _ := tc.Felixes[0].ExecOutput("bpftool", "-jp", "map", "show") - return out - }, "15s", "1s").ShouldNot(Or(ContainSubstring("cali_"), ContainSubstring("xdp_cali_"))) + out, err = tc.Felixes[0].ExecOutput("ls", "/sys/fs/bpf/tc/globals/") + Expect(err).NotTo(HaveOccurred()) + Expect(out).To(Equal("")) + + out, err = tc.Felixes[0].ExecOutput("bpftool", "cgroup", "show", "/run/calico/cgroup") + Expect(err).NotTo(HaveOccurred()) + Expect(out).NotTo(ContainSubstring("calico_connect")) - out, _ := tc.Felixes[0].ExecCombinedOutput("ip", "link", "show", "dev", "bpfin.cali") + out, _ = tc.Felixes[0].ExecCombinedOutput("ip", "link", "show", "dev", "bpfin.cali") Expect(out).To(Equal("Device \"bpfin.cali\" does not exist.\n")) out, _ = tc.Felixes[0].ExecCombinedOutput("ip", "link", "show", "dev", "bpfout.cali") Expect(out).To(Equal("Device \"bpfout.cali\" does not exist.\n")) From e87729acf86433277dcfa98edbef008bb2a11540 Mon Sep 17 00:00:00 2001 From: sridhar Date: Mon, 16 Feb 2026 10:42:57 -0800 Subject: [PATCH 2/5] Revert changes to fv --- felix/fv/bpf_test.go | 58 ++++++++++---------------------------------- 1 file changed, 13 insertions(+), 45 deletions(-) diff --git a/felix/fv/bpf_test.go b/felix/fv/bpf_test.go index 9b702ec7ce3..a8233c916e5 100644 --- a/felix/fv/bpf_test.go +++ b/felix/fv/bpf_test.go @@ -1190,40 +1190,6 @@ func describeBPFTests(opts ...bpfTestOpt) bool { By("Waiting for dp to get setup up") ensureBPFProgramsAttached(tc.Felixes[0], "bpfout.cali") - getPreambleProgramIDs := func() []int { - var bpfnet []struct { - TC []struct { - Name string `json:"name"` - ID int `json:"prog_id"` - } `json:"tc"` - } - out, err := tc.Felixes[0].ExecOutput("bpftool", "net", "show", "-j") - Expect(err).NotTo(HaveOccurred()) - err = json.Unmarshal([]byte(out), &bpfnet) - Expect(err).NotTo(HaveOccurred()) - var preambleIDs []int - for _, entry := range bpfnet { - for _, prog := range entry.TC { - if strings.Contains(prog.Name, "cali_tc_pream") { - preambleIDs = append(preambleIDs, prog.ID) - } - } - } - return preambleIDs - } - Eventually(func() int { - return len(getPreambleProgramIDs()) - }, "15s", "1s").Should(Equal(10)) // 10 = 2 (ingress+egress) * 5 interfaces (bpfout, lo, eth0, caliXXX x2) - - // check for bpf maps - out, err := tc.Felixes[0].ExecOutput("ls", "/sys/fs/bpf/tc/globals/") - Expect(err).NotTo(HaveOccurred()) - Expect(out).To(Not(Equal(""))) - - // check for cgroups - out, err = tc.Felixes[0].ExecOutput("bpftool", "cgroup", "show", "/run/calico/cgroup") - Expect(err).NotTo(HaveOccurred()) - Expect(out).To(ContainSubstring("calico_connect")) By("Changing env and restarting felix") @@ -1232,19 +1198,21 @@ func describeBPFTests(opts ...bpfTestOpt) bool { By("Checking that all programs got cleaned up") - Eventually(func() int { - return len(getPreambleProgramIDs()) - }, "15s", "1s").Should(Equal(0)) - - out, err = tc.Felixes[0].ExecOutput("ls", "/sys/fs/bpf/tc/globals/") - Expect(err).NotTo(HaveOccurred()) - Expect(out).To(Equal("")) + Eventually(func() string { + out, _ := tc.Felixes[0].ExecOutput("bpftool", "-jp", "prog", "show") + return out + }, "15s", "1s").ShouldNot( + Or(ContainSubstring("cali_"), ContainSubstring("calico_"), ContainSubstring("xdp_cali_"))) - out, err = tc.Felixes[0].ExecOutput("bpftool", "cgroup", "show", "/run/calico/cgroup") - Expect(err).NotTo(HaveOccurred()) - Expect(out).NotTo(ContainSubstring("calico_connect")) + // N.B. calico_failsafe map is created in iptables mode by + // bpf.NewFailsafeMap() It has calico_ prefix. All other bpf + // maps have only cali_ prefix. + Eventually(func() string { + out, _ := tc.Felixes[0].ExecOutput("bpftool", "-jp", "map", "show") + return out + }, "15s", "1s").ShouldNot(Or(ContainSubstring("cali_"), ContainSubstring("xdp_cali_"))) - out, _ = tc.Felixes[0].ExecCombinedOutput("ip", "link", "show", "dev", "bpfin.cali") + out, _ := tc.Felixes[0].ExecCombinedOutput("ip", "link", "show", "dev", "bpfin.cali") Expect(out).To(Equal("Device \"bpfin.cali\" does not exist.\n")) out, _ = tc.Felixes[0].ExecCombinedOutput("ip", "link", "show", "dev", "bpfout.cali") Expect(out).To(Equal("Device \"bpfout.cali\" does not exist.\n")) From d9d556b80656d7297b924654e616f77e485fb176 Mon Sep 17 00:00:00 2001 From: sridhar Date: Tue, 17 Feb 2026 07:23:23 -0800 Subject: [PATCH 3/5] Fix bpf cleanup FV --- felix/fv/bpf_test.go | 109 +++++++++++++++++++++++++++++++++++++------ 1 file changed, 96 insertions(+), 13 deletions(-) diff --git a/felix/fv/bpf_test.go b/felix/fv/bpf_test.go index a8233c916e5..c232f93e8ee 100644 --- a/felix/fv/bpf_test.go +++ b/felix/fv/bpf_test.go @@ -59,6 +59,7 @@ import ( libapi "github.com/projectcalico/calico/libcalico-go/lib/apis/v3" client "github.com/projectcalico/calico/libcalico-go/lib/clientv3" options2 "github.com/projectcalico/calico/libcalico-go/lib/options" + "github.com/projectcalico/calico/libcalico-go/lib/set" ) // We run with and without connection-time load balancing for a couple of reasons: @@ -1190,6 +1191,63 @@ func describeBPFTests(opts ...bpfTestOpt) bool { By("Waiting for dp to get setup up") ensureBPFProgramsAttached(tc.Felixes[0], "bpfout.cali") + progIDs := set.New[int]() + mapIDs := set.New[int]() + // Get the program IDs of the preamble programs that we attach + // as part of this test. There can be other preamble programs + // from previous tests and we want to ignore those when checking that programs are cleaned up after disabling BPF. + getPreambleProgramIDs := func() set.Set[int] { + var bpfnet []struct { + TC []struct { + Name string `json:"name"` + ID int `json:"prog_id"` + } `json:"tc"` + } + out, err := tc.Felixes[0].ExecOutput("bpftool", "net", "show", "-j") + Expect(err).NotTo(HaveOccurred()) + err = json.Unmarshal([]byte(out), &bpfnet) + Expect(err).NotTo(HaveOccurred()) + preambleIDs := set.New[int]() + for _, entry := range bpfnet { + for _, prog := range entry.TC { + if strings.Contains(prog.Name, "cali_tc_pream") { + preambleIDs.Add(prog.ID) + } + } + } + return preambleIDs + } + + var preambleIDsBefore set.Set[int] + Eventually(func() int { + preambleIDsBefore = getPreambleProgramIDs() + return preambleIDsBefore.Len() + }, "15s", "1s").Should(Equal(10)) // 10 = 2 (ingress+egress) * 5 interfaces (bpfout, lo, eth0, caliXXX x2) + + type bpfProgs []struct { + ID int `json:"id"` + Name string `json:"name"` + MapIDs []int `json:"map_ids"` + } + programs := bpfProgs{} + out, err := tc.Felixes[0].ExecOutput("bpftool", "prog", "show", "-j") + Expect(err).NotTo(HaveOccurred()) + err = json.Unmarshal([]byte(out), &programs) + Expect(err).NotTo(HaveOccurred()) + + // Get the program and map IDs of all program that are currently attached. + for _, prog := range programs { + if strings.Contains(prog.Name, "cali_tc_pream") && !preambleIDsBefore.Contains(prog.ID) { + continue + } + progIDs.Add(prog.ID) + mapIDs.AddAll(prog.MapIDs) + } + + // check for cgroups + out, err = tc.Felixes[0].ExecOutput("bpftool", "cgroup", "show", "/run/calico/cgroup") + Expect(err).NotTo(HaveOccurred()) + Expect(out).To(ContainSubstring("calico_connect")) By("Changing env and restarting felix") @@ -1198,21 +1256,46 @@ func describeBPFTests(opts ...bpfTestOpt) bool { By("Checking that all programs got cleaned up") - Eventually(func() string { - out, _ := tc.Felixes[0].ExecOutput("bpftool", "-jp", "prog", "show") - return out - }, "15s", "1s").ShouldNot( - Or(ContainSubstring("cali_"), ContainSubstring("calico_"), ContainSubstring("xdp_cali_"))) + // Check that the preamble programs we attached got cleaned up. + Eventually(func() int { + return getPreambleProgramIDs().Len() + }, "15s", "1s").Should(Equal(0)) - // N.B. calico_failsafe map is created in iptables mode by - // bpf.NewFailsafeMap() It has calico_ prefix. All other bpf - // maps have only cali_ prefix. - Eventually(func() string { - out, _ := tc.Felixes[0].ExecOutput("bpftool", "-jp", "map", "show") - return out - }, "15s", "1s").ShouldNot(Or(ContainSubstring("cali_"), ContainSubstring("xdp_cali_"))) + programs = bpfProgs{} + out, err = tc.Felixes[0].ExecOutput("bpftool", "prog", "show", "-j") + Expect(err).NotTo(HaveOccurred()) + err = json.Unmarshal([]byte(out), &programs) + Expect(err).NotTo(HaveOccurred()) + mapIDsAfter := set.New[int]() + progIDsAfter := set.New[int]() + for _, prog := range programs { + progIDsAfter.Add(prog.ID) + } + + for _, prog := range progIDs.Slice() { + Expect(progIDsAfter).NotTo(ContainElement(prog)) + } + + var bpfMaps []struct { + ID int `json:"id"` + } + out, err = tc.Felixes[0].ExecOutput("bpftool", "map", "show", "-j") + Expect(err).NotTo(HaveOccurred()) + err = json.Unmarshal([]byte(out), &bpfMaps) + Expect(err).NotTo(HaveOccurred()) + + for _, m := range bpfMaps { + mapIDsAfter.Add(m.ID) + } + for _, id := range mapIDs.Slice() { + Expect(mapIDsAfter).NotTo(ContainElement(id)) + } + + out, err = tc.Felixes[0].ExecOutput("bpftool", "cgroup", "show", "/run/calico/cgroup") + Expect(err).NotTo(HaveOccurred()) + Expect(out).NotTo(ContainSubstring("calico_connect")) - out, _ := tc.Felixes[0].ExecCombinedOutput("ip", "link", "show", "dev", "bpfin.cali") + out, _ = tc.Felixes[0].ExecCombinedOutput("ip", "link", "show", "dev", "bpfin.cali") Expect(out).To(Equal("Device \"bpfin.cali\" does not exist.\n")) out, _ = tc.Felixes[0].ExecCombinedOutput("ip", "link", "show", "dev", "bpfout.cali") Expect(out).To(Equal("Device \"bpfout.cali\" does not exist.\n")) From 689409d0d7b99ea78f8b40ab7de3fd709db64c70 Mon Sep 17 00:00:00 2001 From: sridhar Date: Tue, 17 Feb 2026 09:18:10 -0800 Subject: [PATCH 4/5] Add debug --- felix/fv/bpf_test.go | 1 + 1 file changed, 1 insertion(+) diff --git a/felix/fv/bpf_test.go b/felix/fv/bpf_test.go index c232f93e8ee..fdacbd5dbb7 100644 --- a/felix/fv/bpf_test.go +++ b/felix/fv/bpf_test.go @@ -1205,6 +1205,7 @@ func describeBPFTests(opts ...bpfTestOpt) bool { } out, err := tc.Felixes[0].ExecOutput("bpftool", "net", "show", "-j") Expect(err).NotTo(HaveOccurred()) + fmt.Printf("bpftool net show output: %s\n", out) err = json.Unmarshal([]byte(out), &bpfnet) Expect(err).NotTo(HaveOccurred()) preambleIDs := set.New[int]() From e6b3c139c3d083cdf952014254e20c9590d53f1b Mon Sep 17 00:00:00 2001 From: sridhar Date: Tue, 17 Feb 2026 10:16:39 -0800 Subject: [PATCH 5/5] Fix difference between tc and tcx --- felix/fv/bpf_test.go | 35 +++++++++++++++++++++++++++-------- 1 file changed, 27 insertions(+), 8 deletions(-) diff --git a/felix/fv/bpf_test.go b/felix/fv/bpf_test.go index fdacbd5dbb7..99009fa591e 100644 --- a/felix/fv/bpf_test.go +++ b/felix/fv/bpf_test.go @@ -1193,26 +1193,45 @@ func describeBPFTests(opts ...bpfTestOpt) bool { ensureBPFProgramsAttached(tc.Felixes[0], "bpfout.cali") progIDs := set.New[int]() mapIDs := set.New[int]() + // Get the program IDs of the preamble programs that we attach // as part of this test. There can be other preamble programs // from previous tests and we want to ignore those when checking that programs are cleaned up after disabling BPF. getPreambleProgramIDs := func() set.Set[int] { - var bpfnet []struct { + var bpfnetTCX []struct { TC []struct { Name string `json:"name"` ID int `json:"prog_id"` } `json:"tc"` } + + var bpfnet []struct { + TC []struct { + Name string `json:"name"` + ID int `json:"id"` + } `json:"tc"` + } out, err := tc.Felixes[0].ExecOutput("bpftool", "net", "show", "-j") Expect(err).NotTo(HaveOccurred()) - fmt.Printf("bpftool net show output: %s\n", out) - err = json.Unmarshal([]byte(out), &bpfnet) - Expect(err).NotTo(HaveOccurred()) preambleIDs := set.New[int]() - for _, entry := range bpfnet { - for _, prog := range entry.TC { - if strings.Contains(prog.Name, "cali_tc_pream") { - preambleIDs.Add(prog.ID) + if BPFAttachType() == "tc" { + err = json.Unmarshal([]byte(out), &bpfnet) + Expect(err).NotTo(HaveOccurred()) + for _, entry := range bpfnet { + for _, prog := range entry.TC { + if strings.Contains(prog.Name, "cali_tc_pream") { + preambleIDs.Add(prog.ID) + } + } + } + } else { + err = json.Unmarshal([]byte(out), &bpfnetTCX) + Expect(err).NotTo(HaveOccurred()) + for _, entry := range bpfnetTCX { + for _, prog := range entry.TC { + if strings.Contains(prog.Name, "cali_tc_pream") { + preambleIDs.Add(prog.ID) + } } } }