1. Hva er eBPF?

eBPF (utvidet Berkeley Packet Filter) er et Linux kjerne delsystem som lar deg kjøre sandboksede programmer i kjernen uten å endre kjernekildekode eller lasting kjernemoduler. Programmer verifiseres av en kjerne bytekode-sponsor før gjennomføring, og sikrer sikkerhet.

For nettverk, eBPF programmer knyttet til i kjernens nettverksstabel og kan inspisere, endre, omdirigere eller slippe pakker. Nøkkelfordelen over eller kjernemoduler er ytelse og programmerbarhet: eBPF-programmer er JIT-komplisert til innfødt kode og kan dele tilstand via (nøkkelverdi lagres delt mellom kjernen og brukerrommet).

Hook	Beliggenhet	Latens	Bruk kasus
XDP	NIC driver, før sk buff tildeling	Laveste	DDoS drop, belastningsbalansering
tc ingress/egress	Etter e buff-tildeling	Lav	Trafikkforming, merking, omdirigering
sokkelfilter	Socket mottar bane	Middels	tcpdump-stil filtrering
kprobe/tracepoint	Kernel funksjonsinngang/utgang	Varies	Observerbarhet, sporing

2. XDP Hook poeng

XDP (eXpress Data Path) programmer kjører tidligst mulig i nettverksstabelen - inne i NIC driveren, før kjernen tildeler en Dette betyr:

Native XDP
Generisk XDPsk_buff
Avlastet XDP

Et XDP-program returnerer en av fem dommer:

Returkode	Handling
`XDP_DROP`	Drop pakke umiddelbart - laveste latens kassering
`XDP_PASS`	Pass opp til normal nettverksstabel
`XDP_TX`	Send tilbake ut samme grensesnitt (bounce)
`XDP_REDIRECT`	Omdiriger til et annet grensesnitt eller AF XDP-kontakt
`XDP_ABORTED`	Feilsti - slipp med sporhending

3. XDP-pakke Drop Eksempel

Følgende program dråper alle UDP-pakker fra en kilde-IP lagret i et eBPF-kart, slik at et userspace-styreplan kan oppdatere blokklisten ved kjøring.

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

Grensekontroll er obligatorisk.data_end

Last inn og fest med :)

# 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

Nøkkelkomponenter:

UMEM
Ringer
Nullkopimodus

AF XDP er ideell for tilpasset pakkebehandling i linjehastighet uten den operasjonelle kompleksiteten til DPDK (ingen store sider, ingen CPU-pinning nødvendig for grunnbruk).

5. tc BPF: Traffic Shaping & 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

6. Begrense med eBPF-kart

eBPF-kart muliggjør statlig behandling. Følgende mønster implementerer per-kilde-IP-hastighetsbegrensning ved hjelp av en polenbøtte lagret i en :)

// 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 & bpftace Introspeksjon

To viktige verktøy for å jobbe med live eBPF-programmer:

# 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. Sammenligning: eBPF/XDP vs DDDK vs RDMA

Funksjon	eBPF/XDP	DPDK	RDMA
Kernel involvering	Minimal (XDP i driver)	Ingen (full forbigang)	Ingen (RDMA NIC)
Minnemodell	Standard + AF XDP UMEM	Store sider som kreves	Registrerte minneområder
Max gjennomstrømning	~100 Gbps innfødt XDP	>100 Gbps	200+ Gbps (InfiniBand)
CPU-bruk	Lav (event-drevet)	Høye (busy-poll kjerner)	Nær null (avlastet)
Ops kompleksitet	Lavt — standardverktøy	Høye — dedikerte kjerner, enorme sider	Høy — stoffhåndtering
Bruk tilfelle	DDoS reduksjon, LB, observerbarhet	Virtuelle rutere, NFV, pakke gen	Oppbevaring (NVMe-oF), HPC MPI
Språk	Begrenset C / Rust	C / Rust	Verbs API (C)

Tummens regel:

Linux eBPF og XDP nettverk Primer

1. Hva er eBPF?

2. XDP Hook poeng

3. XDP-pakke Drop Eksempel

4. AF XDP: Kernel-Bypass

5. tc BPF: Traffic Shaping & Filtrering

6. Begrense med eBPF-kart

7. bpftool & bpftace Introspeksjon

8. Sammenligning: eBPF/XDP vs DDDK vs RDMA