1. ¿Qué es el eBPF?

eBPF (extended Berkeley Packet Filter) es un subsistema del kernel de Linux que le permite ejecutar programas de sandboxed dentro del núcleo sin modificar el código fuente del núcleo o cargar módulos del núcleo. Los programas son verificados por un verificador de código bytecode del núcleo antes de la ejecución, garantizando la seguridad.

Para redes, los programas eBPF se adjuntan a en la pila de red del núcleo y puede inspeccionar, modificar, redirigir o soltar paquetes. La ventaja clave sobre o módulos de núcleo es rendimiento y programabilidad: los programas de eBPF están compuestos por JIT a código nativo y pueden compartir estado a través de (tiendas de valor clave compartidas entre núcleo y espacio de usuario).

Hook	Ubicación	Latency	Caso de uso
XDP	Conductor NIC, antes de la asignación sk buff	Más bajo	DDoS gota, balanceo de carga
tc ingress/egress	Después de la asignación sk buff	Baja	Fabricación de tráfico, marcación, redireccion
filtro de corriente	Socket receive path	Mediana	filtro de estilo tcpdump
kprobe/tracepoint	Entrada/salida de la función del kernel	Variaciones	Observabilidad, localización

2. Puntos de gancho XDP

Los programas XDP (eXpress Data Path) funcionan lo antes posible en la pila de red — dentro del controlador NIC, antes de que el núcleo asigne un Esto significa:

Native XDP
Genérico XDPsk_buff
Offloaded XDP

Un programa XDP devuelve uno de los cinco veredictos:

Código de devolución	Medida
`XDP_DROP`	Retire el paquete inmediatamente — descarte de latencia más baja
`XDP_PASS`	Pasar hasta la pila de red normal
`XDP_TX`	Transmitir de nuevo fuera de la misma interfaz (bounce)
`XDP_REDIRECT`	Redirección a otra interfaz o toma AF XDP
`XDP_ABORTED`	Camino de error: gota con evento de traza

3. XDP Packet Drop Ejemplo

El siguiente programa deja caer todos los paquetes UDP de una fuente IP almacenada en un mapa de eBPF, permitiendo que un avión de control del espacio de usuario actualice la lista de bloqueos en tiempo de ejecució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";

El chequeo es obligatorio.data_end

Carga y adjunta 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

Componentes clave:

UMEM
Anillos
Modo de copia cero

AF XDP es ideal para el procesamiento personalizado de paquetes a velocidad de línea sin la complejidad operativa de DPDK (sin enormes páginas, no se requiere pinning CPU para uso básico).

5. tc BPF: Forma de tráfico " Filtro

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. Limitación de tarifas con mapas eBPF

Los mapas eBPF permiten el procesamiento estatal. El siguiente patrón implementa la tasa por fuente-IP limitando usando un cubo token almacenado 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 " bpftrace Introspection

Dos herramientas esenciales para trabajar con programas eBPF en vivo:

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

Característica	eBPF/XDP	DPDK	RDMA
Participación en el núcleo	Minimal (XDP en conductor)	Ninguno (el bypass completo)	Ninguno (RDMA NIC)
Modelo de memoria	Estándar + AF XDP UMEM	Hugepages required	Regiones de memoria registradas
Max.	~100 Gbps nativo XDP	√100 Gbps	200+ Gbps (InfiniBand)
Uso de CPU	Bajo (disponible con agua corriente)	Altos (centros de carga)	Cerca de cero (descargado)
Competencia de opciones	Herramientas de bajo nivel	Alto — núcleos dedicados, enormes páginas	Alta gestión de tejidos
Caso de uso	DDoS mitigation, LB, observability	routers virtuales, NFV, packet gen	Almacenamiento (NVMe-oF), HPC MPI
Idioma	Restringida C / Rust	C / Rust	Verbs API (C)

Regla de pulgar:

Linux eBPF & XDP Networking Primer

1. ¿Qué es el eBPF?

2. Puntos de gancho XDP

3. XDP Packet Drop Ejemplo

4. AF XDP: Kernel-Bypass

5. tc BPF: Forma de tráfico " Filtro

6. Limitación de tarifas con mapas eBPF

7. bpftool " bpftrace Introspection

8. Comparación: eBPF/XDP vs DPDK vs RDMA