Que é o eBPF?

eBPF (extended Berkeley Packet Filter) é un subsistema de kernel de Linux que permite executar programas sandboxed dentro do kernel sen modificar o código fonte do kernel ou módulos de carga. Os programas son verificados por un verificador de código bytecode antes da execución.

Para redes, os programas eBPF adhírense a Na pila de rede do kernel e pode inspeccionar, modificar, redirixir ou soltar paquetes. A principal vantaxe sobre Os módulos do kernel son o rendemento e a programación: os programas eBPF son compilados por JIT ao código nativo e poden compartir estado a través da programación. (Distribucións de valores de clave compartidas entre o kernel e o espazo de usuario).

Hook	Localización	Latencia	Use o caso
XDP	NIC, antes da asignación sk buff	máis baixa	Baixar DDoS, Balance de carga
Tc Ingress/Egress	Distribución sk buff	Baixo	Configuración de tráfico, marcado, redirección
filtro de socket	Socket recibe o camiño	Medio	Filtro de estilo tcpdump
kprobe/tracepoint	Entrada da función Kernel/exit	Varias	Observación, seguimento

Puntos Hook XDP

Os programas de XDP (eXpress Data Path) execútanse no punto máis antigo posible da pila de rede, dentro do controlador NIC, antes de que o kernel asigne un. Isto significa:

Nativo XDP
XDP xenéricosk_buff
Baixar XDP

O programa XDP presenta unha das cinco sentenzas:

Devolve o código	Acción
`XDP_DROP`	Descargar paquete de inmediato - Baixa latencia descartar
`XDP_PASS`	Pasar á rede normal
`XDP_TX`	Transmitir a mesma interface (bounce)
`XDP_REDIRECT`	Redirección a outra interface ou socket AF XDP.
`XDP_ABORTED`	Erro camiño - caer con evento traza

XDP Packet Drop Example

O seguinte programa arroxa todos os paquetes UDP dunha IP de orixe almacenada nun mapa eBPF, permitindo que un avión de control do espazo de usuario actualice a lista de bloqueos en tempo de execución.

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

A verificación de bonos é obrigatoria.data_end

Cargar e pegar 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

AF XDP: Kernel-Bypass

AF_XDPXDP_REDIRECT

Principais compoñentes:

UMEM
Aneis
Modo Zerocopy

AF XDP é ideal para o procesamento de paquetes personalizados a velocidade de liña sen a complexidade operativa de DPDK (sen grandes páxinas, sen pinning de CPU necesaria para uso básico).

5. tc BPF: filtrado e filtrado de tráfico

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

Límite de tarifas con eBPF Maps

Os mapas eBPF permiten o procesamento do estado. O seguinte estándar implementa a taxa de IP por fonte limitando o uso dun balde de token almacenado nun cubo. ::

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

bpftool & bpftrace Introspection

Dúas ferramentas para traballar con eBPF en directo:

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

Comparación: eBPF / XDP vs DPDK vs RDMA

Característica	EBPF/XDP	DPDK	RDMA
Implicación Kernel	Mínima (XDP en condutor)	Ningunha (homónimos)	Ningún (Miguel)
Modelo de memoria	UMEM + AF XDP	Grandes páxinas necesarias	Regras de memoria registradas
Max Throughput	100 Gbps nativos XDP	100 Gbps	200 Gbps (InfiniBand)
Uso de CPU	Baixo (event-driven)	Alta (zonas de combustible)	0 (descargado)
Ops complexidade	Ferramentas estándar	Alta - cores dedicados, páxinas enormes	Alta - Dirección de tecido
Use o caso	Medición DDoS, LB, Observatorio	routers virtuais, NFV, paquete gen	Almacenamento (NVMe-oF), MPI HPC
Lingua	Restrición C / Rust	C / Rust	API Verbs (C)

regra de polgar:

Linux eBPF & XDP Networking Primer

Que é o eBPF?

Puntos Hook XDP

XDP Packet Drop Example

AF XDP: Kernel-Bypass

5. tc BPF: filtrado e filtrado de tráfico

Límite de tarifas con eBPF Maps

bpftool & bpftrace Introspection

Comparación: eBPF / XDP vs DPDK vs RDMA