1. Wat is eBPF?

eBPF (extended Berkeley Packet Filter) is een Linux kernel subsysteem waarmee je programma's in de kernel kunt uitvoeren zonder de kernelbroncode te wijzigen of kernelmodules te laden. Programma's worden geverifieerd door een kernel bytecode verificateur voordat ze worden uitgevoerd, wat veiligheid garandeert.

Voor netwerken, eBPF programma's koppelen aan in de netwerkstapel van de kernel en kan pakketten inspecteren, wijzigen, omleiden of neerzetten. Het belangrijkste voordeel of kernelmodules zijn prestaties en programmeerbaarheid: eBPF-programma's zijn JIT-gecompileerd naar native code en kunnen de status delen via (sleutelwaarde slaat gedeeld tussen kernel en userspace).

Haak	Locatie	Matigheid	Geval gebruiken
XDP	NIC-stuurprogramma, vóór sk buff-allocatie	Laagste	DDoS drop, load balancing
tc in-/uitgang	Na sk buff allocatie	Laag	Verkeersvorm, markering, omleiding
socketfilter	Socket-pad ontvangen	Middel	tcpdump-stijl filteren
kprobe/tracepoint	Kernelfunctie ingang/uitgang	Varieert	Waarneming, opsporing

2. XDP Haakpunten

XDP (eXpress Data Path) programma's draaien op het vroegst mogelijke punt in de netwerk stack Dit betekent:

Inheemse XDP
Algemeen XDPsk_buff
Uitgeladen XDP

Een XDP programma geeft een van de vijf vonnissen terug:

Code terugkeer	Actie
`XDP_DROP`	Pakket onmiddellijk laten vallen
`XDP_PASS`	Doorgeven naar normale netwerk stack
`XDP_TX`	Terugsturen van dezelfde interface (bounce)
`XDP_REDIRECT`	Ga door naar een andere interface of AF XDP socket
`XDP_ABORTED`	Fout bij het pad met sporen

3. XDP Packet Drop Voorbeeld

Het volgende programma laat alle UDP pakketten van een bron IP opgeslagen in een eBPF kaart, waardoor een userspace control plane om de bloklijst bij te werken op runtime.

// 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";

Controle van de grenzen is verplicht.data_end

Laden en bevestigen met :

# 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

4. AF XDP: Kernel-Bypass

AF_XDPXDP_REDIRECT

Sleutelcomponenten:

UUM
Ringen
Nulkopiemodus

AF XDP is ideaal voor aangepaste pakketverwerking op lijnsnelheid zonder de operationele complexiteit van DPDK (geen enorme pagina's, geen CPU-pinning nodig voor basisgebruik).

5. tc BPF: Traffic Shaping & Filtering

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

6. Bereken Beperken met eBPF Maps

eBPF-kaarten maken stateful verwerking mogelijk. Het volgende patroon implementeert per-source-IP-snelheid te beperken met behulp van een token emmer opgeslagen in een :

// 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 Introspectie

Twee essentiële hulpmiddelen voor het werken met live eBPF-programma's:

# 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); }'

8. Vergelijking: eBPF/XDP vs DPK vs RDMA

Functie	eBPF/XDP	DPDK	RDMA
Betrokkenheid van de kernel	Minimaal (XDP in stuurprogramma)	Geen (volledige bypass)	Geen (RDMA NIC)
Geheugenmodel	Standaard + AF XDP UMEM	Enorme pagina's vereist	Geregistreerde geheugengebieden
Maximale doorvoer	~100 Gbps native XDP	> 100 Gbps	200+ Gbps (InfiniBand)
CPU-gebruik	Laag (eventgedreven)	Hoog (bezet-pollkernen)	Bijna nul (ontladen)
Ops complexiteit	Laag standaard gereedschap	Hoge	Hoge kwaliteit textielbeheer
Use case	DDoS mitigatie, LB, observeerbaarheid	Virtuele routers, NFV, pakketgen	Opslag (NVMe-oF), HPC MPI
Taal	Beperkte C / Rust	C / Rust	Werkwoorden API (C)

Vuistregel:

Linux eBPF & XDP Networking Primer

1. Wat is eBPF?

2. XDP Haakpunten

3. XDP Packet Drop Voorbeeld

4. AF XDP: Kernel-Bypass

5. tc BPF: Traffic Shaping & Filtering

6. Bereken Beperken met eBPF Maps

7. bpftool & bpftrace Introspectie

8. Vergelijking: eBPF/XDP vs DPK vs RDMA