1. Co je eBPF?

eBPF (rozšířený Berkeley Packet Filter) je Linux kernel subsystém, který vám umožní spustit andboxed programy uvnitř jádra bez úpravy zdrojového kódu jádra nebo načítání kernel modulů. Programy jsou ověřovány ověřovatelem jádra bytecode před provedením, což zajišťuje bezpečnost.

Pro vytváření sítí, eBPF programy připojit v síťovém zásobníku jádra a může kontrolovat, modifikovat, přesměrovat nebo upustit pakety. Klíčová výhoda nad nebo kernelové moduly jsou výkon a programovatelnost: eBPF programy jsou JIT- sestaveny na domácí kód a mohou sdílet stav prostřednictvím (key- value obchody sdílené mezi jádrem a uživatelským prostorem).

Háček	Umístění	Latency	Použít pouzdro
XDP	NIC ovladač, před sk _ buff přidělení	Nejnižší	DDoS pokles, vyvažování nákladu
tc ingress / egress	Po přiřazení sk _ buff	Nízká	Utváření dopravy, značení, přesměrování
zásuvkový filtr	Name	Střední	cpdrop- style filtrování
ksond / tracepoint	Funkce jádra vstup / výstup	Varies	Pozorovatelnost, sledování

2. XDP Hook body

XDP (eXpress Data Path) programy běží v nejranějším možném bodě v síťovém zásobníku - uvnitř NIC ovladače, než jádro přiřadí To znamená:

Původní XDP
Generická XDPsk_buff
Uložené XDP

XDP program vrací jeden z pěti verdiktů:

Kód návratu	Akce
`XDP_DROP`	Drop paket okamžitě - nejnižší latence discover
`XDP_PASS`	Přejít na normální síť stack
`XDP_TX`	Odeslat zpět stejné rozhraní (odrazit)
`XDP_REDIRECT`	Přesměrování na jiné rozhraní nebo na zásuvku AF _ XDP
`XDP_ABORTED`	Chyba cesta - pokles se sledovací událostí

3. XDP Packet Drop Příklad

Následující program stáhne všechny UDP pakety ze zdrojového IP systému uloženého v mapě eBPF, což umožňuje uživatelsky prostorové řídící letadlo aktualizovat blocklist v runtime.

// 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 pout je povinná.data_end

Načíst a připojit :

# 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

Klíčové součásti:

UMEM
Prsteny
Režim Zerokopírování

AF _ XDP je ideální pro vlastní zpracování paketů v linkové rychlosti bez provozní složitosti DPDK (žádné hugepages, žádné CPU piny potřebné pro základní použití).

5. tc BPF: ztvárnění a filtrování provozu

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. Omezení rychlosti s mapami eBPF

mapy eBPF umožňují statické zpracování. Následující vzor implementuje per- source- IP omezení rychlostí pomocí token kbelík uložený 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 Úvod

Dva základní nástroje pro práci s programy 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. Srovnání: eBPF / XDP vs DPDK vs RDMA

Funkce	eBPF / XDP	DPDK	RDMA
Zapojení Kernel	Minimální (XDP v ovladači)	Žádné (plný bypass)	Žádné (RDMA NIC)
Model paměti	Standard + AF _ XDP UMEM	Vyžadováno zasunutí	Registrované paměťové oblasti
Maximální propustnost	~ 100 Gbps rodné XDP	> 100 Gbps	200 + Gbps (InfiniBand)
Použití CPU	Nízké (event- drived)	Vysoké (busy- anulovací jádra)	Téměř nula (vyloženo)
Složitost operací	Nízké - standardní nástroje	Vysoké - vyhrazené jádra, hugepages	Vysoké - správa tkanin
Pouzdro	Snížení DDoS, LB, pozorovatelnost	Virtuální routery, NFV, paket gen	Skladování (NVMe-oF), HPC MPI
Jazyk	Omezení C / Rust	C / Rust	Slova API (C)

Pravidlo:

Linux eBPF & XDP Networking Primer

1. Co je eBPF?

2. XDP Hook body

3. XDP Packet Drop Příklad

4. AF _ XDP: Kernel- Bypass

5. tc BPF: ztvárnění a filtrování provozu

6. Omezení rychlosti s mapami eBPF

7. Bpftool & bpftrace Úvod

8. Srovnání: eBPF / XDP vs DPDK vs RDMA