מה זה EBPF?

eBPF (extended ברקלי Packet מסנן) הוא תת-מערכת גרעין לינוקס המאפשרת לך להפעיל תוכניות ארגז חול בתוך הקרנל מבלי לשנות קוד מקור הקרנל או לטעון מודולי גרעין. תוכניות מאומתות על ידי מאמת קודר לפני ביצוע, הבטחת בטיחות.

עבור רשתות, תוכניות eBPF להתחבר בערימה של הרשת של הקרנל ויכול לבדוק, לשנות, לשנות, להפניה או טיפות חבילות. היתרון המרכזי על או kernel מודולים הוא ביצועים ותוכנית: תוכניות eBPF הן JIT-compiled קוד Native ויכול לשתף מדינה באמצעות (חנויות ערכיות משותפות בין הקרנל לבין סביבת המשתמש).

הוקמיקום LocationLatencyשימוש במקרה
XDPנהג NIC, לפני sk buff הקצאהנמוך יותרטיפת DDoS, איזון עומס
תוקפנות/egressלאחר הקצאת sk buffנמוךעיצוב תנועה, סימון, הפניה
מסנןSocket מקבל נתיבבינוני בינוניפילטר בסגנון tcpdump
kprobe/tracepointהכניסה ל-exitVariesאחריות, מעקב

נקודות XDP Hook

XDP (eXpress Data Path) תוכניות לרוץ בשלב מוקדם ביותר האפשרי בערימה של הרשת - בתוך נהג NIC, לפני הקרנל מקצה נקודה זה אומר:

  • Native XDP
  • Generic XDPsk_buff
  • XDP

תוכנית XDP מחזירה את אחד מחמשת פסקי הדין:

קוד החזרהפעולה
XDP_DROPהורידו את החבילה באופן מיידי - הפחתת השקיפות הנמוכה ביותר
XDP_PASSלעבור עד ערימה רשת נורמלית
XDP_TXחזרה לאותו ממשק (bounce)
XDP_REDIRECTהפניה לממשק אחר או ל- AF XDP socket
XDP_ABORTEDמסלול שגיאה - נפילה עם אירוע עקבות

דוגמה: XDP Packet Drop

התוכנית הבאה טיפות את כל חבילות UDP מ IP מקור מאוחסנות במפה eBPF, ומאפשרת למטוס בקרת סביבת המשתמש לעדכן את רשימת הבלוק בעת ריצה.

// 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";
בדיקת Bounds היא חובה.data_end

טעינה ונספח עם :

# 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

מרכיבים מרכזיים:

  • UMEM
  • טבעות טבעות טבעות
  • מצב Zero-copy

AF XDP הוא אידיאלי לעיבוד חבילות מותאם אישית בקצב קו ללא המורכבות התפעולית של DPDK (ללא דפי ענק, שום CPU pinning הנדרש לשימוש בסיסי).

5. tc BPF: Traffic Shaping & filter

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

ראשי התיבות של EBPF Maps

מפות eBPF מאפשרות עיבוד המדינה. התבנית הבאה מיישמת את שיעור הקוד-IP המגביל באמצעות דלי אסיקן המאוחסן בדלי אסימון. :

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

שני כלים חיוניים לעבודה עם תוכניות 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); }'

השוואה: EBPF/XDP לעומת DPDK לעומת RDMA

תכונותEBPF/XDPDPDKRDMA
מעורבות Kernelמינימלי (XDP inנהג)אף אחד (בפס מלא)אף אחד (DMA NIC)
מודל זיכרוןתקן + AF XDP UMEMדפי ענק דרושיםאזורי זיכרון רשומים
מקס באמצעותput100 Gbps Native XDP100 Gbps200+ Gbps (InfiniBand)
שימוש CPUנמוך (אפילו מונע)High (busy-poll ליבות)ליד אפס (מטען)
מורכבותנמוך - כלים סטנדרטייםליבות ייעודיות, ענקיםניהול בד
שימוש במקרההפחתת DDoS, LB, observabilityנתבים וירטואליים, NFV, Pack genאחסון (NVMe-oF), HPC MPI
שפהC / RustC / RustVerbs API (C)
כלל אצבע: