1. Che cosa è eBPF?

eBPF (extended Berkeley Packet Filter) è un sottosistema del kernel Linux che consente di eseguire programmi sandbox all'interno del kernel senza modificare il codice sorgente del kernel o i moduli del kernel di caricamento. I programmi sono verificati da un kernel bytecode verifier prima dell'esecuzione, assicurando la sicurezza.

Per la rete, i programmi eBPF si attaccano a nello stack di rete del kernel e può ispezionare, modificare, reindirizzare o rilasciare pacchetti. Il vantaggio chiave sopra o i moduli del kernel sono prestazioni e programmabilità: i programmi eBPF sono conformi a JIT e possono condividere lo stato tramite (magazzini di valore chiave condivisi tra kernel e userspace).

gancio	Location	Lattice	Utilizzare il caso
XDP	NIC driver, prima sk buff allocazione	Più basso	DDoS drop, bilanciamento del carico
tc ingresso/ingresso	Dopo l'assegnazione di sk buff	Basso	Traffico modellante, marcatura, reindirizzare
filtro presa	Presa ricevere il percorso	Media	tcpdump-style filtering
kprobe/trasporto	Entrata/uscita della funzione del kernel	Vasi	Osservabilità, tracciamento

2. Punti di gancio XDP

I programmi XDP (eXpress Data Path) vengono eseguiti al più presto possibile nello stack di rete — all'interno del driver NIC, prima che il kernel assegna un Questo significa:

XDP nativo
XDP genericosk_buff
XDP scaricato

Un programma XDP restituisce uno dei cinque verdetti:

Codice di ritorno	Azione
`XDP_DROP`	Goccia pacchetto immediatamente — scarto di latenza più basso
`XDP_PASS`	Passa fino a normale stack di rete
`XDP_TX`	Trasmettere indietro la stessa interfaccia (bounce)
`XDP_REDIRECT`	Reindirizza un'altra interfaccia o presa AF XDP
`XDP_ABORTED`	percorso di errore — goccia con evento traccia

3. Esempio di caduta del pacchetto XDP

Il seguente programma lascia cadere tutti i pacchetti UDP da un IP sorgente memorizzato in una mappa eBPF, permettendo a un piano di controllo dello spazio utente di aggiornare il blocklist a 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";

Il controllo dei bound è obbligatorio.data_end

Carica e attacca con :

# 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

Componenti chiave:

UMEM
Anelli
Modalità zero-copia

AF XDP è ideale per l'elaborazione di pacchetti personalizzati a velocità di linea senza la complessità operativa di DPDK (senza pagine enormi, senza pinning della CPU necessaria per l'uso di base).

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. Limitare il tasso con le mappe eBPF

Le mappe eBPF consentono l'elaborazione di dati. Il seguente modello implementa il tasso per-source-IP limitante utilizzando un secchio token memorizzato in un :

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

Due strumenti essenziali per lavorare con programmi live eBPF:

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

Caratteristica	eBPF/XDP	DPDK	RDMA
coinvolgimento del Kernel	Minimal (XDP in driver)	Nessuno (passo completo)	Nessuno (RDMA NIC)
Modello di memoria	Standard + AF XDP UMEM	Hugepages richiesto	Regioni di memoria registrate
Max throughput	~ 100 Gbps nativi XDP	> 100 Gbps	200+ Gbps (InfiniBand)
Utilizzo della CPU	Basso (event-driven)	Elevato (coperture da busy-poll)	Vicino a zero (scaricato)
Ops complessità	Basso — strumenti standard	Alto — core dedicati, pagine enormi	Alta gestione del tessuto
Caso di utilizzo	DDoS mitigazione, LB, osservabilità	router virtuali, NFV, pacchetto gen	Storage (NVMe-oF), HPC MPI
Lingua	Restricted C / Rust	C / Rust	Verbs API (C)

Regola del pollice:

Linux eBPF & XDP Networking Primer

1. Che cosa è eBPF?

2. Punti di gancio XDP

3. Esempio di caduta del pacchetto XDP

4. AF XDP: Kernel-Bypass

5. tc BPF: Traffic Shaping & Filtering

6. Limitare il tasso con le mappe eBPF

7. bpftool & bpftrace Introspezione

8. Confronto: eBPF/XDP vs DPDK vs RDMA