1. Co to jest eBPF?

eBPF (rozszerzony filtr pakietów Berkeley) jest podsystemem jądra Linuksa, który pozwala na uruchamianie programów piaskowanych wewnątrz jądra bez modyfikacji kodu źródłowego jądra lub ładowania modułów jądra. Programy są weryfikowane przez weryfikatora bajtecode jądra przed wykonaniem, zapewniając bezpieczeństwo.

Programy eBPF dołączają do sieci w stosie sieciowym jądra i może kontrolować, modyfikować, przekierować lub upuść pakiety. Kluczowa przewaga nad lub moduły jądra jest wydajność i programowalność: programy eBPF są zkompilowane do rodzimego kodu i mogą dzielić się stanem poprzez (key- value shares shared between kernel and userspace).

Hak	Lokalizacja	Opóźnienie	Użyj Case
XDP	Kierowca NIC, przed przydzieleniem sk _ buff	Najniższy	Spadek DDoS, równowaga obciążenia
do	Po alokacji sk _ buff	Niski	Kształtowanie ruchu, znakowanie, przekierowanie
Filtr gniazda	Ścieżka odbioru gniazda	Średni	filtrowanie w stylu tcpdump- style
ksonda / tracepoint	Wejście / wyjście funkcji jądra	Zmienne	Obserwacja, śledzenie

2. Punkty hakowe XDP

Programy XDP (eXpress Data Path) uruchamiane w najwcześniejszym możliwym punkcie stosu sieci - wewnątrz sterownika NIC, zanim jądro przydzieli Oznacza to:

Native XDP
Generic XDPsk_buff
Wyładowany XDP

Program XDP zwraca jeden z pięciu werdyktów:

Kod powrotny	Działanie
`XDP_DROP`	Natychmiast upuść pakiet - najniższe opóźnienie wyrzucić
`XDP_PASS`	Przejście do normalnego stosu sieci
`XDP_TX`	Transmituj z powrotem ten sam interfejs (bounce)
`XDP_REDIRECT`	Przekierować do innego interfejsu lub gniazda AF _ XDP
`XDP_ABORTED`	Ścieżka błędu - upuść z zdarzeniem trace

3. Przykład zrzutu pakietów XDP

Poniższy program zrzuca wszystkie pakiety UDP ze źródłowego IP przechowywanego na mapie eBPF, pozwalając użytkownikowi na aktualizację listy blokującej przy starcie.

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

Sprawdzanie granic jest obowiązkowe.data_end

Załaduj i przyłącz :

# 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

Kluczowe elementy:

UMEM
Pierścienie
Tryb zerokopiowania

AF _ XDP idealnie nadaje się do niestandardowego przetwarzania pakietów w trybie liniowym bez złożoności operacyjnej DPDK (brak przytulaczy, brak przypinania procesora do podstawowego zastosowania).

5. tc BPF: Kształtowanie i filtrowanie ruchu

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. Oceń ograniczenie z mapami eBPF

Mapy eBPF umożliwiają etamatyczne przetwarzanie. Poniższy wzór implementuje Per- source- IP ograniczenie szybkości za pomocą wiadro token przechowywane w :

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

Dwa podstawowe narzędzia do pracy z żywymi 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. Porównanie: eBPF / XDP vs DPDK vs RDMA

Cecha	eBPF / XDP	DPDK	RDMA
Zaangażowanie jądra	Minimalne (XDP u kierowcy)	Brak (pełny bajpas)	Brak (RDMA NIC)
Model pamięci	Standard + AF _ XDP UMEM	Wymagane Hugepages	Regiony rejestrowanej pamięci
Maksymalna przepustowość	~ 100 Gbps rodzimych XDP	> 100 Gbps	200 + Gbps (InfiniBand)
Wykorzystanie procesora	Niskie (spowodowane wypadkami)	Wysokie (rdzenie busy- sondażowe)	W pobliżu zera (wyładowywany)
Złożoność operacji	Niskie - standardowe narzędzia	Wysokie - dedykowane rdzenie, hugepages	Wysoka - zarządzanie tkaninami
Przypadek użycia	Ograniczenie DDoS, LB, obserwacja	Wirtualne routery, NFV, pakiet gen	Przechowywanie (NVMe- oF), HPC MPI
Język	Ograniczone C / Rdza	C / Rust	Czasowniki API (C)

Zasada kciuka:

Linux eBPF & XDP Networking Primer

1. Co to jest eBPF?

2. Punkty hakowe XDP

3. Przykład zrzutu pakietów XDP

4. AF _ XDP: Kernel- Bypass

5. tc BPF: Kształtowanie i filtrowanie ruchu

6. Oceń ograniczenie z mapami eBPF

7. bpftool & bpftrace Introspection

8. Porównanie: eBPF / XDP vs DPDK vs RDMA