1. Kio estas eBPF?

eBPF (plilongigita Berkeley Packet Filter) estas Linukso-kerna subsistemo, kiu ebligas al vi ruli sablokesitajn programojn ene de la kerno sen modifi kernan fontkodon aŭ ŝarĝi kernajn modulojn. Programoj estas kontrolitaj de kerna bajtekkoda kontrolilo antaŭ ekzekuto, certigante sekurecon.

Por interkonektado, eBPF-programoj aliĝas alhokpunktojen la retstako de la kerno kaj povas inspekti, modifi, alidirekti aŭ faligi pakaĵetojn. La ŝlosila avantaĝo superiptablesaŭ kernmoduloj estas rendimento kaj programebleco: eBPF-programoj estas JIT-kompilitaj al indiĝena kodo kaj povas kunhavi ŝtaton permapoj(ŝlosilvaloraj vendejoj dividitaj inter kerno kaj uzantspaco).

Hoko	Loko	Latenteco	Uzkazo
XDP	NIC-ŝoforo, antaŭ sk_buff-atribuo	Plej malalta	DDoS-falo, ŝarĝo-ekvilibro
tc eniro/eliro	Post sk_buff-atribuo	Malalta	Trafikformado, markado, alidirekto
ingofiltrilo	Socket ricevvojo	Meza	tcpdump-stila filtrado
kprobe/spurpunkto	Kerna funkcio eniro/eliro	Varias	Observability, spurado

2. XDP Hoko-Poentoj

XDP (eXpress Data Path) programoj funkcias ĉe la plej frua ebla punkto en la retstako - ene de la NIC-ŝoforo, antaŭ ol la kerno asignassk_buff. Ĉi tio signifas:

Denaska XDP: Ŝoforo subtenas XDP denaske (Intel i40e, Mellanox mlx5, ktp.). Plej rapida — funkcias en ŝoforo kunteksto.
Ĝenerala XDP: Rezervo por ŝoforoj sen denaska subteno. Kuras postsk_buffallocation — ankoraŭ pli rapida ol iptables sed ne tiel rapide kiel denaska.
Elŝutita XDP: Programo funkcias per la NIC ASIC mem. Postulas SmartNIC-aparaton (ekz. Netronome). Nula CPU-kosto.

XDP-programo resendas unu el kvin juĝoj:

Revenkodo	Ago
`XDP_DROP`	Forigu pakaĵon tuj - plej malalta latencia forĵeto
`XDP_PASS`	Transiru al normala reto-stako
`XDP_TX`	Elsendi reen eksteren la saman interfacon (resalto)
`XDP_REDIRECT`	Alidirekti al alia interfaco aŭ AF_XDP-ingo
`XDP_ABORTED`	Erara vojo - faligi kun spurokazaĵo

3. XDP Paka Guto Ekzemplo

La sekva programo faligas ĉiujn UDP-pakaĵojn de fonto IP stokita en eBPF-mapo, permesante al uzantspaca kontrolaviadilo ĝisdatigi la blokliston ĉe rultempo.

// xdp_drop_udp.c — Drop UDP from IPs in a BPF map
#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <bpf/bpf_helpers.h>

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

Kontrolado de limoj estas deviga.La eBPF-kontrolilo malakceptas programojn kiuj aliras memoron preteredata_end. Ĉiu puntera aritmetika operacio devas esti sekvita per limkontrolo aŭ la programo ne ŝargiĝos.

Ŝarĝu kaj ligu perip:

# 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_XDPestas ingofamilio kiu, kombinita kun XDP-ojXDP_REDIRECTverdikto, liveras pakaĵetojn rekte al uzantspaca memorregiono (UMEM) sen kernel-implikiĝo po-pako. Ĉi tio estas la respondo de la ekosistemo eBPF al la modelo de kerno-preteriĝo de DPDK.

Ŝlosilaj komponantoj:

UMEM: uzantspaco-registrita memorregiono dividita en kadrojn. Kunhavita inter kerno kaj uzantspaco per komuna memoro.
Ringoj: Kvar senŝlosaj ringoj per ingo: Plenigi (uzantspaco → kerno kun liberaj kadroj), Kompletigo (kerno → uzantspaco kun TX-faritaj kadroj), RX-ringo (kerno → uzantspaco kun ricevitaj kadroj), TX-ringo (uzantspaco → kerno kun kadroj sendi).
Nula kopia reĝimo: Se la ŝoforo subtenas ĝin, kadroj estas transdonitaj sen iu ajn kopio — nur montrilo.

AF_XDP estas ideala por laŭmenda pakaĵprilaborado ĉe liniorapideco sen la funkcia komplekseco de DPDK (neniu grandegaj paĝoj, neniu CPU-alpinglado necesa por baza uzo).

5. tc BPF: Trafikformado & Filtrilo

tc(trafika kontrolo) BPF-programoj aliĝas ĉe laclsactqdisc kaj povas funkcii ĉe eniro aŭ eliro. Male al XDP, ili vidas la plenansk_buffkaj povas aliri ingometadatenojn, VLANojn, kaj tunelajn titolojn.

// tc_mark.c — Mark packets with DSCP EF (46) for VoIP traffic on port 5060
#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/udp.h>
#include <bpf/bpf_helpers.h>

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. Tarifa Limigo kun eBPF-Mapoj

eBPF-mapoj ebligas ŝtatan prilaboradon. La sekva ŝablono efektivigas per-fonta-IP-indico-limigon uzante ĵeton-sitelon stokita en aBPF_MAP_TYPE_LRU_HASH:

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

Du esencaj iloj por labori kun vivaj eBPF-programoj:

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

Karakterizaĵo	eBPF/XDP	DPDK	RDMA
Kernel-implikiĝo	Minimuma (XDP en ŝoforo)	Neniu (plena pretervojo)	Neniu (RDMA NIC)
Memormodelo	Norma + AF_XDP UMEM	Grandegaj paĝoj bezonataj	Registritaj memorregionoj
Maksimuma trafluo	~100 Gbps denaska XDP	>100 Gbps	200+ Gbps (InfiniBand)
CPU-uzado	Malalta (okazaĵo-movita)	Alta (okupataj kernoj)	Proksime de nulo (elŝutita)
Ops komplekseco	Malalta - normaj iloj	Alta — dediĉitaj kernoj, grandegaj paĝoj	Alta — mastrumado de ŝtofoj
Uzkazo	DDoS mildigo, LB, observeblo	Virtualaj enkursigiloj, NFV, pakaĵeto	Stokado (NVMe-oF), HPC MPI
Lingvo	Restriktita C/ Rust	C/ Rusto	Verboj API (C)

Ordona regulo:Komencu per eBPF/XDP - ĝi integriĝas kun ekzistantaj kernaj iloj, postulas neniun specialan aparataron aŭ grandegajn paĝojn, kaj pritraktas plej alt-efikecajn retajn uzkazojn malpli ol 100 Gbps. Moviĝu al DPDK nur kiam vi bezonas dediĉitajn CPU-kernojn kaj ne povas toleri iun ajn kernan planadon superkoste.

Linukso eBPF & XDP-Reto-Enkonduko

1. Kio estas eBPF?

2. XDP Hoko-Poentoj

3. XDP Paka Guto Ekzemplo

4. AF_XDP: Kernel-Bypass

5. tc BPF: Trafikformado & Filtrilo

6. Tarifa Limigo kun eBPF-Mapoj

7. bpftool & bpftrace Introspekto

8. Komparo: eBPF/XDP vs DPDK vs RDMA