1. Què és eBPF?

eBPF (Candre de paquets de Berkeley) és un subsistema de nucli Linux que us permet executar programes de proves dins del nucli sense modificar el codi font del nucli o carregar mòduls del nucli. Els programes són verificats per un codis de bytes del nucli abans de l' execució, assegurant seguretat.

Per a la xarxa, s' han adjuntat els programes eBPF a la pila de xarxa del nucli i pot inspeccionar, modificar, redireccionar o deixar anar paquets. L' avantatge clau sobre o mòduls del nucli és rendiment i programabilitat: Els programes eBPF són JIT- compilats al codi natiu i poden compartir estat via (clau- valor desa les botigues compartides entre nucli i espai d' usuari).

Garfi	Localització	Latència	Cas d' ús
XDPName	Controlador NIC, abans de l'assignació d'sk buff	Més baix	Baixa el DDoS, carrega l'equilibri
tc ingres/egres	Després de l' assignació d'sk bauff	Baixa	Format de trànsit, marca, redirecció
filtre de sòcol	S' ha rebut la ruta del sòcol	Mitjà	Filtrat d' estil tcpdump
kprobe/tracepoint	Entrada/exit de funció del nucli	Variacions	Observabilitat, traçador

2. XDP Punts del Hook

S' executen programes de camí de dades XDP (eXpress) en el primer punt possible a la pila de xarxa kOST a dins del controlador NIC, abans que el nucli usi un Això vol dir:

Nadiu XDP
XDP genèricsk_buff
XDP carregat

Un programa XDP retorna un dels cinc veredictes:

Torna el codi	Acció
`XDP_DROP`	Baixa el paquet immediatament el tancament més baix de la llicència
`XDP_PASS`	Passa a la pila de xarxa normal
`XDP_TX`	Transmuteu la mateixa interfície (bou)
`XDP_REDIRECT`	Redirigeix a una altra interfície o connector AF XDP
`XDP_ABORTED`	Ruta d' error a la sortida de l' escriptori de traces

Exemple de deixar anar paquets XDP

El següent programa baixa tots els paquets UDP des d' un IP de codi font emmagatzemat en un mapa eBPF, permetent un avió de control d'usuari per actualitzar la llista de blocs en temps d' execució.

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

El control il·limitat és obligatori.data_end

Carrega i adjunta amb :

# 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: nucli- passa

AF_XDPXDP_REDIRECT

Components de clau:

UMEM
Anells
Mode zero- copia

AF XDP és ideal per a processament de paquets personalitzats sense la complexitat operativa del DPDK (sense pàgines enormes, no es requereix CPU per a ús bàsic).

5. tc BPF: S' està filtrant i filtrant

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. Velocitat límit amb mapes eBPF

Els mapes eBPF permeten processos d'estat. El següent patró implementa la taxa de límit per programari usant un cub de fitxes emmagatzemat en 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 i bpftrace Introducció

Dues eines essencials per treballar amb programes eBPF en directe:

# 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, Comparació: eBPF/ XDP contra DDK contra RDMA

Característica	eBPF/ XDP	DPDK	RDMA
La participació del nucli	Mínim (XDP al controlador)	Cap (punt complet)	Cap (RDMA NIC)
Model de memòria	Estàndard + AF XDP UMEM	Calen diferents pàgines	regions de memòria registrades
Màx. a través del rendiment	~100 Gbps natiu XDP	>100 Gbps	200+ Gbps (InfiniBand)
Ús de la CPU	Baix (imunitat)	Alta (poy-poll nuclis)	A prop de zero (desactualitzat)
La complexitat d' ops	Eines estàndard per programari baixa	Particions molt aplicades, pàgines enormes	Gestió de teixits d'alt teixit
Usa casella	DDoS mitigation, LB, obsferència	Encaminadors virtuals, NFV, mòdul de paquet	Emmagatzematge (NVM- oF), HPC MPDI
Idioma	Restringeix C / Rust	C / Rust	Verbs API (C)

Regla del polze:

Entorn de xarxa per al Linux eBPF i XDP

1. Què és eBPF?

2. XDP Punts del Hook

Exemple de deixar anar paquets XDP

4. AF XDP: nucli- passa

5. tc BPF: S' està filtrant i filtrant

6. Velocitat límit amb mapes eBPF

7, bpftool i bpftrace Introducció

8, Comparació: eBPF/ XDP contra DDK contra RDMA