1. O que é eBPF?

eBPF (extended Berkeley Packet Filter) é um subsistema do kernel Linux que permite executar programas sandboxed dentro do kernel sem modificar o código fonte do kernel ou carregar módulos do kernel. Os programas são verificados por um verificador de bytes do kernel antes da execução, garantindo segurança.

Para redes, os programas eBPF são anexados na pilha de rede do kernel e pode inspecionar, modificar, redirecionar ou soltar pacotes. A principal vantagem sobre ou módulos de kernel é desempenho e programabilidade: os programas eBPF são compilados com JIT para código nativo e podem compartilhar estado via (armazenagens de valor chave compartilhadas entre kernel e espaço de usuário).

Gancho	Localização	Latência	Caso de Uso
XDP	Controlador NIC, antes da alocação do sk buff	Menor	DDoS gota, balanceamento de carga
tc entrada/entrada	Após a alocação do sk buff	Baixo	Formação, marcação e reorientação do tráfego
filtro de tomada	Caminho de recepção do Socket	Médio	filtragem em estilo tcpdump
kprobe/tracepoint	Entrada/saída da função Kernel	Variações	Observabilidade, rastreio

2. Pontos de Gancho XDP

Os programas XDP (eXpress Data Path) são executados o mais rapidamente possível na pilha de rede — dentro do driver NIC, antes que o kernel aloque um Isto significa:

XDP nativo
XDP genéricosk_buff
XDP descarregado

Um programa XDP devolve um dos cinco veredictos:

Código de Retorno	Acção
`XDP_DROP`	Pacote de gotas imediatamente — descarte de menor latência
`XDP_PASS`	Passar para a pilha de rede normal
`XDP_TX`	Transmitir de volta para fora da mesma interface
`XDP_REDIRECT`	Redirecionar para outra interface ou soquete AF XDP
`XDP_ABORTED`	Caminho do erro — drop with trace event

3. XDP Packet Drop Exemplo

O seguinte programa solta todos os pacotes UDP de um IP fonte armazenado em um mapa eBPF, permitindo que um plano de controle do espaço de usuário atualize a lista de bloqueios em tempo de execução.

// 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 verificação dos limites é obrigatória.data_end

Carregar e anexar com :

# 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 principais:

UMEM
Anéis
Modo de cópia zero

AF XDP é ideal para processamento personalizado de pacotes a taxa de linha sem a complexidade operacional do DPDK (sem grandes páginas, sem necessidade de pinning de CPU para uso básico).

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. Limitação de Taxa com Mapas eBPF

Os mapas eBPF permitem o processamento de estado. O seguinte padrão implementa por fonte-IP limitação da taxa usando um balde token armazenado em um :

// 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. Introdução à bpftool & bpftrace

Duas ferramentas essenciais para trabalhar com programas eBPF ao 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. Comparação: eBPF/XDP vs DPDK vs RDMA

Característica	eBPF/XDP	DPDK	RDMA
Participação do Kernel	Mínimo (XDP no controlador)	Nenhum (bypass completo)	Nenhuma (RDMA NIC)
Modelo de memória	Padrão + AF XDP UMEM	Enormes páginas necessárias	Regiões de memória registadas
Produção máxima	~ 100 Gbps XDP nativo	> 100 Gbps	200+ Gbps (InfiniBand)
Utilização da CPU	Baixo (dirigido a eventos)	Alto (núcleos de poluente ocupado)	Perto de zero (deslocado)
Complexidade das operações	Ferramentas de baixa qualidade	Alto — núcleos dedicados, páginas enormes	Alta gestão de tecidos
Caso de uso	DDoS mitigação, LB, observação	Roteadores virtuais, NFV, geração de pacotes	Armazenamento (NVMe-oF), HPC MPI
Língua	Limitado C / Rust	C / Rust	API Verbs (C)

Regra do polegar:

Linux eBPF & XDP Networking Primer

1. O que é eBPF?

2. Pontos de Gancho XDP

3. XDP Packet Drop Exemplo

4. AF XDP: Kernel- Bypass

5. tc BPF: Traffic Shaping & Filtering

6. Limitação de Taxa com Mapas eBPF

7. Introdução à bpftool & bpftrace

8. Comparação: eBPF/XDP vs DPDK vs RDMA