Vad är eBPF?

eBPF (förlängd Berkeley Packet Filter) är ett Linux-kärnans delsystem som låter dig köra sandboxade program inuti kärnan utan att ändra kärnkällakod eller ladda kärnmoduler. Program verifieras av en kärna bytesverifier innan utförandet, vilket garanterar säkerheten.

För nätverk, eBPF program bifoga till i kärnans nätverksstapel och kan inspektera, ändra, omdirigera eller släppa paket. Den viktigaste fördelen över eller kärnmoduler är prestanda och programmerbarhet: eBPF-program är JIT-kompilerade till inhemsk kod och kan dela staten via (Key-value-butiker som delas mellan kärna och användarrum).

Hook	Plats	Latency	Använd fall
XDP	NIC förare, innan sk buff allokering	Lägsta	DDoS drop, lastbalansering
TC ingress/Egress	Efter sk buff allokering	Låg	Trafikformning, markering, omdirigering
Socket filter	Socket får väg	Medium	tcpdump-stil filtrering
Kprobe/tracepoint	Kernel funktion inträde/exit	Varierar	Observability, Tracing

XDP Hook Points

XDP-programmen (eXpress Data Path) körs på den tidigaste möjliga punkten i nätverksstapeln - inuti NIC-drivrutinen, innan kärnan tilldelar en Detta betyder:

Native XDP
Generisk XDPsk_buff
Offloaded XDP

Ett XDP-program returnerar en av fem domar:

Return Code	Action
`XDP_DROP`	Släpp paket omedelbart - lägsta latenskass
`XDP_PASS`	Passera upp till normal nätverksstapel
`XDP_TX`	Skicka tillbaka samma gränssnitt (bounce)
`XDP_REDIRECT`	Omdirigera till ett annat gränssnitt eller AF XDP-uttag
`XDP_ABORTED`	Felbana - släpp med spårhändelse

XDP Packet Drop Exempel

Följande program släpper alla UDP-paket från en käll IP som lagras i en eBPF-karta, så att ett användarpace-kontrollplan kan uppdatera blocklistan vid drifttid.

// xdp_drop_udp.c — Drop UDP from IPs in a BPF map
#include 
#include 
#include 
#include 
#include 

// BPF map: src IP → drop flag (1 = drop)
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 1024);
    __type(key, __u32);    // source IPv4 address
    __type(value, __u32);  // 1 = block
} blocklist SEC(".maps");

SEC("xdp")
int xdp_drop_udp(struct xdp_md *ctx) {
    void *data     = (void *)(long)ctx->data;
    void *data_end = (void *)(long)ctx->data_end;

    // Parse Ethernet header
    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end) return XDP_PASS;
    if (eth->h_proto != __constant_htons(ETH_P_IP)) return XDP_PASS;

    // Parse IPv4 header
    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end) return XDP_PASS;
    if (ip->protocol != IPPROTO_UDP) return XDP_PASS;

    // Check blocklist map
    __u32 src = ip->saddr;
    __u32 *val = bpf_map_lookup_elem(&blocklist, &src);
    if (val && *val == 1) return XDP_DROP;

    return XDP_PASS;
}

char _license[] SEC("license") = "GPL";

Gränskontroll är obligatorisk.data_end

Ladda och fästa med Från:

# Compile
clang -O2 -target bpf -c xdp_drop_udp.c -o xdp_drop_udp.o

# Attach to interface (native XDP)
ip link set eth0 xdp obj xdp_drop_udp.o sec xdp

# Add an IP to the blocklist via bpftool
bpftool map update name blocklist key 0x01 0x02 0x03 0x04 value 0x01 0x00 0x00 0x00

# Remove XDP program
ip link set eth0 xdp off

AF XDP: Kernel-Bypass

AF_XDPXDP_REDIRECT

Viktiga komponenter:

Umem
Ringar
Zero-kopieringsläge

AF XDP är idealisk för anpassad paketbearbetning i linje med driftskomplexiteten hos DPDK (inga stora sidor, ingen CPU-pinning krävs för grundläggande användning).

5. tc BPF: Trafikformning och filtrering

tcclsactsk_buff

// tc_mark.c — Mark packets with DSCP EF (46) for VoIP traffic on port 5060
#include 
#include 
#include 
#include 
#include 

SEC("classifier")
int tc_mark_voip(struct __sk_buff *skb) {
    void *data     = (void *)(long)skb->data;
    void *data_end = (void *)(long)skb->data_end;

    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end) return TC_ACT_OK;
    if (eth->h_proto != __constant_htons(ETH_P_IP)) return TC_ACT_OK;

    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end) return TC_ACT_OK;
    if (ip->protocol != IPPROTO_UDP) return TC_ACT_OK;

    struct udphdr *udp = (void *)(ip + 1);
    if ((void *)(udp + 1) > data_end) return TC_ACT_OK;

    // Mark SIP traffic (port 5060) with DSCP EF (46 = 0xB8 in TOS byte)
    if (udp->dest == __constant_htons(5060) || udp->source == __constant_htons(5060)) {
        // DSCP EF = 46, shifted left 2 bits in TOS field = 184 (0xB8)
        bpf_skb_store_bytes(skb, offsetof(struct iphdr, tos) + sizeof(struct ethhdr),
                            &((__u8){184}), 1, BPF_F_RECOMPUTE_CSUM);
    }
    return TC_ACT_OK;
}

char _license[] SEC("license") = "GPL";

# Attach tc BPF program
tc qdisc add dev eth0 clsact
tc filter add dev eth0 egress bpf da obj tc_mark.o sec classifier

Rate Limiting med eBPF Maps

eBPF kartor möjliggör statlig bearbetning. Följande mönster implementerar per-source-IP-ränta som begränsar med en token hink lagrad i en Från:

// Conceptual token bucket per source IP — checks tokens, drops if exceeded
struct ratelimit_entry {
    __u64 tokens;        // current token count
    __u64 last_update;   // nanoseconds timestamp
};

struct {
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
    __uint(max_entries, 65536);
    __type(key, __u32);                     // source IP
    __type(value, struct ratelimit_entry);
} rate_map SEC(".maps");

// In XDP program:
// 1. bpf_ktime_get_ns() — get current time
// 2. Lookup entry for src IP
// 3. Refill tokens: tokens += (elapsed_ns / 1e9) * rate_pps
// 4. If tokens >= 1: decrement and XDP_PASS
// 5. Else: XDP_DROP

7. bpftool & bpftrace introspektion

Två viktiga verktyg för att arbeta med live eBPF-program:

# bpftool — inspect loaded programs and maps
bpftool prog list                         # list all loaded eBPF programs
bpftool prog show id 42                   # details for program ID 42
bpftool prog dump xlated id 42            # disassemble to eBPF bytecode
bpftool prog dump jited id 42            # dump JIT-compiled native code
bpftool map list                          # list all BPF maps
bpftool map dump name blocklist           # dump all entries in map "blocklist"
bpftool map update name blocklist \
    key 192 168 1 100 value 1 0 0 0       # add entry (network byte order)

# bpftrace — DTrace-style one-liners for kernel tracing
# Count XDP drops per second
bpftrace -e 'tracepoint:xdp:xdp_exception { @drops[args->action] = count(); } interval:s:1 { print(@drops); clear(@drops); }'

# Trace tcp_retransmit_skb — show retransmit events with comm name
bpftrace -e 'kprobe:tcp_retransmit_skb { printf("%s retransmit\n", comm); }'

# Histogram of packet sizes on eth0
bpftrace -e 'tracepoint:net:netif_receive_skb /args->name == "eth0"/ { @size = hist(args->len); }'

Jämförelse: eBPF/XDP vs DPDK vs RDMA

Funktion	eBPF/XDP	DPDK	RDMA
Kernel engagemang	Minimal (XDP i förare)	Ingen (full bypass)	Ingen (RDMA NIC)
Minnesmodell	Standard + AF XDP UMEM	Hugepages krävs	Registrerade minnesregioner
Max genomströmning	~ 100 Gbps infödd XDP	>100 Gbps	200+ Gbps (InfiniBand)
CPU användning	Låg (event-driven)	Höga (busy-poll cores)	Nära noll (offloaded)
Ops komplexitet	Låg – standardverktyg	Hög - dedikerade kärnor, stora sidor	Hög - tyghantering
Använd fall	DDoS mitigation, LB, observerbarhet	Virtuella routrar, NFV, paketgen	Lagring (NVMe-oF), HPC MPI
Språkspråk	Begränsad C / Rust	C / Rust	Verbs API (C)

Tumregel:

Linux eBPF & XDP Networking Primer

Vad är eBPF?

XDP Hook Points

XDP Packet Drop Exempel

AF XDP: Kernel-Bypass

5. tc BPF: Trafikformning och filtrering

Rate Limiting med eBPF Maps

7. bpftool & bpftrace introspektion

Jämförelse: eBPF/XDP vs DPDK vs RDMA