Function abnormality after loading xdp through cilium/ebpf library

[wenzi]

Kernel：Ubuntu 22.04.1 LTS (GNU/Linux 5.15.0-84-generic x86_64)

Hi lizrice, I'm having some trouble loading xdp_lb. Loading the xdp program to eth0 of the lizrice/ubuntu-ebpf-lb container through the makefile script you provided can run perfectly, but when I load it through the cilium/ebpf library, it can be loaded successfully, and there is debugging information when accessing lb through the client, but Load balancing cannot be achieved. After capturing packets from backend-A/B, I found that there is only the IP information of the data packet from client to lb.

I guess the modification of the destination address and source address was unsuccessful, but judging from the debug information, the modification was successful. Can you help me take a look? The following is the loading code:

package main

import (
	"bufio"
	"context"
	"flag"
	"github.com/cilium/ebpf/link"
	"io"
	"log"
	"net"
	"os"
	"os/signal"
	"syscall"
)

// $BPF_CLANG and $BPF_CFLAGS are set by the Makefile.
//go:generate go run github.com/cilium/ebpf/cmd/bpf2go -cc $BPF_CLANG -cflags $BPF_CFLAGS bpf lb4.c -- -I../../headers -Ilb4.h

var (
	InterfaceName string
)

func init() {
	flag.StringVar(&InterfaceName, "n", "lo", "a network interface name")
}

func main() {
	flag.Parse()

	if len(InterfaceName) == 0 {
		log.Fatalf("Please specify a network interface")
	}
	// Look up the network interface by name.
	iface, err := net.InterfaceByName(InterfaceName)
	if err != nil {
		log.Fatalf("lookup network iface %s: %s", InterfaceName, err)
	}

	// Load pre-compiled programs into the kernel.
	objs := bpfObjects{}
	if err := loadBpfObjects(&objs, nil); err != nil {
		log.Fatalf("loading objects: %s", err)
	}
	defer objs.Close()

	// Attach the program.
	l, err := link.AttachXDP(link.XDPOptions{
		Program:   objs.XdpLoadBalancer,
		Interface: iface.Index,
	})
	if err != nil {
		log.Fatalf("could not attach XDP program: %s", err)
	}
	defer l.Close()

	log.Printf("Attached XDP program to iface %q (index %d)", iface.Name, iface.Index)
	log.Printf("Press Ctrl-C to exit and remove the program")
	log.Printf("Successfully started! Please run \"sudo cat /sys/kernel/debug/tracing/trace_pipe\" to see output of the BPF programs\n")

	// Wait for a signal and close the XDP program,
	stopper := make(chan os.Signal, 1)
	signal.Notify(stopper, os.Interrupt, syscall.SIGTERM)

	cxt, cancel := context.WithCancel(context.Background())
	go func(cxt context.Context) {
		f, err := os.Open("/sys/kernel/debug/tracing/trace_pipe")
		if err != nil {
			log.Panicf("open file failed, %v", err)
		}
		defer f.Close()

		r := bufio.NewReader(f)
		for {
			select {
			case <-cxt.Done():
				return
			default:
				// ReadLine is a low-level line-reading primitive.
				// Most callers should use ReadBytes('\n') or ReadString('\n') instead or use a Scanner.
				bytes, _, err := r.ReadLine()
				if err == io.EOF {
					break
				}
				if err != nil {
					panic(err)
				}
				log.Println(string(bytes))
			}
		}
	}(cxt)

	<-stopper
	cancel()
	log.Println("Received signal, exiting XDP program..")
}

Complete project address ：https://github.com/Zhouchaowen/ebpf_labs/blob/master/xdp/lb4/main.go