1. Čo je eBPF?

eBPF (rozšírený Berkeley Packet Filter) je subsystém jadra Linux, ktorý vám umožňuje spustiť sandboxed programy vnútri jadra bez úpravy zdrojového kódu jadra alebo načítavanie modulov jadra. Programy sú overené overovateľom kódu jadra pred vykonaním, zabezpečenie bezpečnosti.

Pre vytváranie sietí, eBPF programy pripojiť k v sieťovom zásobníku jadra a môže kontrolovať, upravovať, presmerovať alebo pustiť pakety. Kľúčová výhoda oproti alebo moduly jadra sú výkon a programovateľnosť: eBPF programy sú JIT-kompilované k natívnemu kódu a môžu zdieľať stav cez (uloženie kľúčovej hodnoty zdieľané medzi jadrom a užívateľským priestorom).

Hook	Umiestnenie	LatencyName	Prípad použitia
XDP	Vodič NIC, pred pridelením sk buff	Najnižšia	DDoS drop, vyrovnávanie zaťaženia
tc vstup/výstup	Po pridelení sk buff	nízka	Formovanie, označovanie, presmerovanie
zásuvkový filter	Socket dostane cestu	Stredná	filtrácia typu tcpdump
kprobe/tracepoint	Vstup/výstup funkcie kernelu	Vary	Pozorovateľnosť, sledovanie

2. XDP hákové body

XDP (eXpress Data Path) programy bežia v čo najskoršom možnom bode v sieťovom stack To znamená:

Natívny XDP
Generic XDPsk_buff
Vyložený XDP

XDP program vracia jeden z piatich verdiktov:

Kód vrátenia	Činnosť
`XDP_DROP`	Drop packet chearly
`XDP_PASS`	Prejsť až do normálnej siete stack
`XDP_TX`	Prenos späť z rovnakého rozhrania (bounce)
`XDP_REDIRECT`	Presmerovať na iné rozhranie alebo AF XDP soket
`XDP_ABORTED`	Cesta k chybám

3. XDP Packet Drop Príklad

Nasledujúci program pustí všetky UDP pakety zo zdrojového IP uloženého v mape eBPF, čo umožní ovládaciu rovinu používateľského priestoru aktualizovať zoznam v čase spustenia.

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

Kontrola hraníc je povinná.data_end

Zaťažiť a pripojiť :

# 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

Kľúčové zložky:

UMEM
Prstene
Režim nulová kópia

AF XDP je ideálny pre vlastné spracovanie paketov pri čiarovej rýchlosti bez prevádzkovej zložitosti DPDK (žiadne obrovské stránky, žiadne CPU pinking potrebné pre základné použitie).

5. tc BPF: tvarovanie a filtrovanie dopravy

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. Obmedzenie rýchlosti pomocou eBPF máp

Mapy eBPF umožňujú dôsledné spracovanie. Nasledujúci vzorec zavádza na-zdroj-IP rýchlosť limitovaná pomocou žetónového vedra uloženého v :

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

Dva základné nástroje pre prácu so živými programami eBPF:

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

Funkcia	eBPF/XDP	DPDK	RDMA
Zapojenie kernelu	Minimálna (XDP u vodiča)	Žiadne (úplný bypass)	Žiadne (RDMA NIC)
Pamäťový model	Štandard + AF XDP UMEM	Požadované objatia	Registrované pamäťové oblasti
Max. priepustnosť	~100 Gbps natívne XDP	> 100 Gbps	200 + Gbps (InfiniBand)
Použitie procesora	Nízka (hnaná udalosťami)	Vysoké (prúdové)	Blízko nuly (vyložené)
Ops zložitosť	Nízka hodnota štandardných nástrojov	Vysoké	Vysoko kvalitné riadenie tkaniny
Prípad použitia	DDoS zmiernenie, LB, pozorovateľnosť	Virtuálne smerovače, NFV, paket gen	Storage (NVMe-oF), HPC MPI
Jazyk	Obmedzená C / Rust	C / Rust	Sloves API (C)

Pravidlo palca:

Linux eBPF & XDP sieťový Primer

1. Čo je eBPF?

2. XDP hákové body

3. XDP Packet Drop Príklad

4. AF XDP: Kernel-Bypass

5. tc BPF: tvarovanie a filtrovanie dopravy

6. Obmedzenie rýchlosti pomocou eBPF máp

7. bpftool & bpftrace Introspection

8. Porovnanie: eBPF/XDP vs DPDK vs RDMA