eBPF 网络流量观测深度实战：从 XDP 到 tc 的全栈可观测性工程

引言

传统网络观测工具（tcpdump、iptables LOG、WireShark）在高带宽场景下存在致命瓶颈：要么拷贝全部数据包到用户态造成 CPU 风暴，要么规则匹配无法触及内核协议栈深层状态。eBPF 的出现改变了这一切——它允许在内核空间安全地执行沙盒程序，在不修改内核源码、不加载内核模块的前提下，实现纳秒级的数据包处理、协议解析和流量统计。

本文将从 eBPF 网络编程的核心机制出发，系统拆解 XDP、tc、sockmap/sockhash、cgroup 套接字程序这四大挂载点的工程差异，并通过生产级案例展示如何构建完整的网络流量可观测性体系。

一、eBPF 网络程序的执行模型

1.1 网络数据路径上的挂载点

Linux 内核网络数据路径上的 eBPF 挂载点从上到下依次为：

用户态应用
    │
    ▼
┌─────────────────┐
│  cgroup/sock    │  ← 套接字创建时触发（ingress/egress 未决）
│  sockops        │  ← 套接字状态变更事件
│  sk_msg         │  ← 套接字层重定向
│  sk_reuseport   │  ← SO_REUSEPORT 套接字选择
├─────────────────┤
│  XDP (Driver)   │  ← 网卡驱动层，最早介入
│  XDP (Generic)  │  ← 内核通用层（Fallback）
├─────────────────┤
│  TC Ingress     │  ← 流量控制入口（进入协议栈后）
│  TC Egress      │  ← 流量控制出口
├─────────────────┤
│  Socket Filter  │  ← BPF_PROG_TYPE_SOCKET_FILTER
│  Kprobe/Tracepoint │ ← 动态探针（内核函数挂载）
└─────────────────┘

每个挂载点拥有不同的上下文结构体和可用辅助函数，决定了能观测到什么数据以及如何干预流量。

1.2 关键数据结构体

XDP 上下文（xdp_md）：

struct xdp_md {
    __u32 data;              // 数据包起始地址
    __u32 data_end;          // 数据包结束地址
    __u32 data_meta;         // 元数据区域
    __u32 ingress_ifindex;   // 入接口索引
    __u32 rx_queue_index;    // RX 队列索引
    __u32 egress_ifindex;    // 出接口索引（仅 TC）
};

TC 上下文（__sk_buff）：

struct __sk_buff {
    __u32 len;               // 数据包长度
    __u32 pkt_type;          // 包类型（广播/组播/单播）
    __u32 mark;              // Socket mark
    __u32 queue_mapping;     // 队列映射
    __u32 protocol;          // 协议类型
    __u32 vlan_present;      // VLAN 标签存在
    __u32 vlan_tci;          // VLAN TCI
    // ... 共 100+ 个字段
};

1.3 返回码语义差异

二、XDP 高性能数据包处理

2.1 XDP 执行流程

XDP 在网卡驱动收取数据包后、分配 sk_buff 之前执行，是所有 eBPF 挂载点中最早介入的。这意味着：

• 零 sk_buff 分配开销：DMA 缓冲区直接可用
• 单核 25Mpps 以上：Cilium 实测数据
• 但受限于数据包原始指针：不能越界访问，Verifier 严格检查

2.2 XDP 程序安全访问模式

SEC("xdp")
int xdp_observer(struct xdp_md *ctx) {
    void *data_end = (void *)(long)ctx->data_end;
    void *data     = (void *)(long)ctx->data;

    // 必须显式检查边界，Verifier 要求
    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)
        return XDP_PASS;

    struct iphdr *ip = data + sizeof(struct ethhdr);
    if ((void *)(ip + 1) > data_end)
        return XDP_PASS;

    // BPF 辅助函数用于边界安全扩展
    // bpf_xdp_adjust_head(ctx, -28);  // 添加 Geneve 头
    // bpf_xdp_adjust_tail(ctx, -20);  // 截断尾部

    return XDP_PASS;
}

Verifier 的核心规则： 1. 所有指针访问前必须做边界检查 2. 循环必须有确定上界（#pragma unroll 辅助） 3. 不超过 4096 条指令（5.10+ 内核提升） 4. 禁止不可达代码

2.3 XDP 三种运行模式对比

# 查看网卡 XDP 支持
ethtool -i eth0 | grep driver
# 加载 XDP 程序
ip link set eth0 xdp obj xdp.o sec xdp
# 查看当前 XDP 状态
ip link show eth0

2.4 XDP 实战：DDoS 流量清洗

struct {
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
    __type(key, __u32);     // Source IP
    __type(value, struct flow_stats);
    __uint(max_entries, 65536);
} flow_table SEC(".maps");

SEC("xdp")
int xdp_ddos_filter(struct xdp_md *ctx) {
    void *data_end = (void *)(long)ctx->data_end;
    void *data = (void *)(long)ctx->data;

    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)
        return XDP_PASS;

    if (eth->h_proto != bpf_htons(ETH_P_IP))
        return XDP_PASS;

    struct iphdr *ip = (void *)(eth + 1);
    if ((void *)(ip + 1) > data_end)
        return XDP_PASS;

    __u32 src_ip = ip->saddr;

    // 查找流表
    struct flow_stats *stats = bpf_map_lookup_elem(&flow_table, &src_ip);
    if (stats) {
        __sync_fetch_and_add(&stats->pkt_count, 1);
        if (stats->pkt_count > THRESHOLD)
            return XDP_DROP;
    } else {
        struct flow_stats new_stats = {1, bpf_ktime_get_ns()};
        bpf_map_update_elem(&flow_table, &src_ip, &new_stats, BPF_NOEXIST);
    }

    return XDP_PASS;
}

2.5 XDP 重定向：负载均衡实现

struct {
    __uint(type, BPF_MAP_TYPE_DEVMAP);
    __type(key, __u32);
    __type(value, __u32);
    __uint(max_entries, 256);
} tx_port SEC(".maps");

struct {
    __uint(type, BPF_MAP_TYPE_CPUMAP);
    __type(key, __u32);
    __type(value, __u32);
    __uint(max_entries, 256);
} cpu_map SEC(".maps");

SEC("xdp")
int xdp_loadbalancer(struct xdp_md *ctx) {
    // 基于五元组的选择后端
    __u32 backend = select_backend(ctx);
    __u32 key = 0;

    // 方式1：转发到另一个网卡接口
    bpf_redirect_map(&tx_port, backend, XDP_DROP);

    // 方式2：分发到不同 CPU 处理
    bpf_redirect_map(&cpu_map, bpf_get_smp_processor_id(), XDP_PASS);

    return XDP_ABORTED; // 理论上不会到达
}

三、TC 流量控制与深度观测

3.1 TC eBPF 与 XDP 的关系

TC eBPF 程序在数据包进入内核协议栈后执行，相比 XDP 的优势：

• 可访问完整的 sk_buff 结构（含协议栈元信息）
• 支持 ingress/egress 双向挂载
• 可修改数据包（NAT、修改 DSCP）
• 与 cgroup 套接字程序协同

劣势：性能略低（sk_buff 已分配，约 XDP 的 60-70%）

3.2 TC Ingress 实战：七层流量分类

SEC("tc")
int tc_classifier(struct __sk_buff *skb) {
    // 直接访问 sk_buff 字段，无需越界检查
    __u32 pkt_len = skb->len;
    __u32 ifindex = skb->ifindex;

    // 获取 IP 头（内核已解析）
    void *data = (void *)(long)skb->data;
    void *data_end = (void *)(long)skb->data_end;

    // 使用 bpf_skb_load_bytes 做边界安全读取
    struct iphdr ip;
    bpf_skb_load_bytes(skb, ETH_HLEN, &ip, sizeof(ip));

    // HTTP Host 头解析（TCP 80 端口）
    if (ip.protocol == IPPROTO_TCP) {
        struct tcphdr tcp;
        bpf_skb_load_bytes(skb, ETH_HLEN + ip.ihl*4,
                          &tcp, sizeof(tcp));
        if (bpf_ntohs(tcp.dest) == 80) {
            char host[64];
            bpf_skb_load_bytes(skb,
                ETH_HLEN + ip.ihl*4 + tcp.doff*4 + 20,
                host, sizeof(host));
            bpf_perf_event_output(skb, &events, BPF_F_CURRENT_CPU,
                                host, sizeof(host));
        }
    }

    return TC_ACT_OK;
}

3.3 TC Egress 实战：QoS 标记

SEC("tc")
int tc_qos_mark(struct __sk_buff *skb) {
    // 根据协议类型设置 skb->priority（影响 tc qdisc）
    __u8 proto = skb->protocol;

    // 读取 IP 头获取 DSCP 字段
    struct iphdr ip;
    bpf_skb_load_bytes(skb, ETH_HLEN, &ip, sizeof(ip));
    __u8 dscp = (ip.tos & 0xFC) >> 2;

    if (dscp == 46) {
        // EF (Expedited Forwarding) - VoIP
        skb->priority = 1;
    } else if (dscp == 10) {
        // AF11 - Video
        skb->priority = 2;
    } else {
        // Best Effort
        skb->priority = 0;
    }

    return TC_ACT_OK;
}

3.4 TC 与 iptables/nftables 协同

在 Cilium 等大型项目中，TC eBPF 替代了大部分 iptables 规则：

# 传统 iptables 方式（低效，线性匹配）
iptables -A INPUT -p tcp --dport 80 -j ACCEPT
iptables -A INPUT -p tcp --dport 443 -j ACCEPT

# 等价的 tc eBPF 方式（O(1) 哈希查找）
tc filter add eth0 ingress bpf obj tc.o sec tc_classifier

性能差异： - iptables 1000 规则：~50μs/pkt - eBPF 哈希表 1000 条目：~0.5μs/pkt

四、套接字层观测：sockops & sk_msg

4.1 sockops：套接字级统计

sockops 程序在 TCP 状态变更、RTT 测量、重传事件时触发，是观测 TCP 健康的最佳挂载点。

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, struct sock_key);
    __type(value, struct sock_stats);
    __uint(max_entries, 65536);
} sock_stats SEC(".maps");

struct sock_key {
    __u32 src_ip;
    __u32 dst_ip;
    __u16 src_port;
    __u16 dst_port;
    __u32 family;
};

SEC("sockops")
int sockops_monitor(struct bpf_sock_ops *skops) {
    __u32 op = skops->op;

    switch (op) {
    case BPF_SOCK_OPS_TCP_CONNECT_CB:
        // 连接发起
        record_connect(skops);
        break;

    case BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB:
        // 主动连接建立
        record_established(skops);
        break;

    case BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB:
        // 被动接受连接
        record_accept(skops);
        break;

    case BPF_SOCK_OPS_RTT_CB:
        // RTT 采样（核心！）
        {
            struct sock_stats *stats = find_or_create(skops);
            if (stats) {
                stats->rtt_min = min(stats->rtt_min, skops->srtt_us >> 3);
                stats->rtt_max = max(stats->rtt_max, skops->srtt_us >> 3);
                stats->rtt_avg = ewma(stats->rtt_avg, skops->srtt_us >> 3);
                stats->rtt_cnt++;
                stats->bytes_acked = skops->bytes_acked;
                stats->bytes_received = skops->bytes_received;
                stats->retrans_out = skops->retrans_out;
                stats->segs_out = skops->segs_out;
                stats->segs_in = skops->segs_in;
            }
        }
        break;

    case BPF_SOCK_OPS_TCP_STATE_CB:
        // TCP 状态变更
        log_state_change(skops->sk, skops->args[0], skops->args[1]);
        break;
    }

    return 0;
}

4.2 sk_msg：套接字层重定向

sk_msg 在数据从用户态写入套接字（sendmsg/write）时触发，主要用于：

• 双向观测：同时捕获发送和接收路径
• L7 策略执行：基于 HTTP/gRPC 内容进行路由
• 性能零拷贝重定向：避免数据经过网络栈

SEC("sk_msg")
int sk_msg_redirect(struct sk_msg_md *msg) {
    // 读取用户态写入的数据
    char buf[128];
    bpf_msg_pull_data(msg, 0, sizeof(buf), 0);

    // HTTP 路由决策
    if (is_http_get(msg)) {
        __u32 backend = lookup_backend(msg);
        bpf_msg_redirect_hash(msg, &sock_map, &backend, 0);
    }

    return SK_PASS;
}

4.3 sockmap/sockhash：高性能 socket 重定向

sockmap 和 sockhash 是专门用于 eBPF 套接字重定向的映射类型，可将数据直接从一个 socket 转发到另一个 socket，绕过网络栈。

                                          传统路径
应用 ──write()──▶ socket ──TCP──▶ qdisc ──NIC Driver ──▶ 网卡
                                    │
                sockmap 加速路径     │
应用 ──write()──▶ socket ──sk_redirect_map()──────────▶ 目标 socket
                          （完全绕过 TCP/IP 栈和 sk_buff 分配）

struct {
    __uint(type, BPF_MAP_TYPE_SOCKHASH);
    __type(key, struct sock_key);
    __type(value, __u32);  // socket cookie
    __uint(max_entries, 65536);
} sock_map SEC(".maps");

SEC("sockops")
int sockops_capture(struct bpf_sock_ops *skops) {
    if (skops->op == BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB ||
        skops->op == BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB) {
        struct sock_key key = {
            .src_ip   = skops->remote_ip4,
            .dst_ip   = skops->local_ip4,
            .src_port = bpf_ntohs(skops->remote_port),
            .dst_port = skops->local_port,
            .family   = skops->family,
        };
        bpf_sock_hash_update(skops, &sock_map, &key, BPF_NOEXIST);
    }
    return 0;
}

SEC("sk_msg")
int sk_msg_redirect(struct sk_msg_md *msg) {
    struct sock_key key = extract_key(msg);
    // O(1) 时间复杂度重定向
    bpf_msg_redirect_hash(msg, &sock_map, &key, BPF_F_INGRESS);
    return SK_PASS;
}

Cilium 使用此技术实现 KubeProxy 替代方案，单核可达 500K req/s。

五、cgroup 观测：容器级流量追踪

5.1 cgroup/sock 与 cgroup/skb

// cgroup/sock：为 socket 打标记
SEC("cgroup/sock")
int cgroup_sock_monitor(struct bpf_sock *sk) {
    __u32 cgroup = bpf_get_current_cgroup_id();
    bpf_sk_storage_get(&sk_storage, sk, NULL, BPF_SK_STORAGE_GET_F_CREATE);
    return 1; // 1 = allow, 0 = deny
}

// cgroup/skb：流量统计
SEC("cgroup/skb/egress")
int cgroup_egress(struct __sk_buff *skb) {
    __u32 cgroup = bpf_get_current_cgroup_id();
    struct traffic_stats *stats = bpf_map_lookup_elem(&cgroup_stats, &cgroup);
    if (stats) {
        __sync_fetch_and_add(&stats->tx_bytes, skb->len);
        __sync_fetch_and_add(&stats->tx_pkts, 1);
    }
    return 1;
}

六、Kprobe/Tracepoint：内核协议栈可观测性

6.1 Tracepoint 稳定观测

Tracepoint 是内核提供的稳定 ABI，升级内核后仍可工作。

SEC("tracepoint/skb/kfree_skbint")
int trace_kfree_skb(struct trace_event_raw_kfree_skb *ctx) {
    // 捕获所有丢包事件
    struct event e = {};
    e.timestamp = bpf_ktime_get_ns();
    e.saddr = ctx->skaddr;  // 需要从 skb 解析
    e.sport = ctx->skport;
    e.reason = ctx->reason;  // LINUX_MIB_TCPBACKLOGDROP 等

    bpf_perf_event_output(ctx, &drop_event, BPF_F_CURRENT_CPU, &e, sizeof(e));
    return 0;
}

6.2 Kprobe 动态追踪

Kprobe 可挂载到内核任何函数，适合追踪内部状态变化：

SEC("kprobe/tcp_sendmsg")
int kprobe_tcp_sendmsg(struct pt_regs *ctx) {
    struct sock *sk = (struct sock *)PT_REGS_PARM1(ctx);
    size_t size = (size_t)PT_REGS_PARM3(ctx);

    // 提取 TCP 连接信息
    struct tcp_info info = {};
    bpf_probe_read(&info, sizeof(info),
        (void *)&sk->sk_state);  // 注意：实际字段访问更复杂

    // 推送至用户态
    struct event e = {
        .pid = bpf_get_current_pid_tgid() >> 32,
        .bytes = size,
        .state = info.tcpi_state,
    };
    bpf_map_update_elem(&conn_events, &sk, &e, BPF_ANY);

    return 0;
}

6.3 关键网络 tracepoint 列表

net:net_dev_queue          → 数据包进入发送队列
net:net_dev_xmit           → 提交给驱动
net:netif_receive_skb      → 数据包接收
net:netif_rx               → NAPI 接收
sock:inet_sock_set_state   → TCP 状态机变更
skb:kfree_skbint           → 丢包事件
skb:consume_skb            → 包正常消费
skb:skb_copy_datagram_iovec → 数据交付用户态
tcp:tcp_retransmit_skb     → TCP 重传
tcp:tcp_receive_reset      → RST 接收
tcp:tcp_probe              → TCP 内部状态变更

七、BPF 映射输出通道：Perf Buffer vs Ring Buffer

7.1 BPF_MAP_TYPE_PERF_EVENT_ARRAY

struct {
    __uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
    __type(key, __u32);
    __type(value, __u32);
    __uint(max_entries, 128);  // 128 CPUs max
} events SEC(".maps");

// 内核态推送
bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, &data, sizeof(data));

// 用户态读取
struct perf_buffer *pb = perf_buffer__new(map_fd, 8, handle_event, handle_lost, NULL, NULL);
perf_buffer__poll(pb, 100);

7.2 BPF_MAP_TYPE_RINGBUF（5.8+ 内核）

struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 256 * 1024);  // 256KB ring buffer
} rb SEC(".maps");

// 内核态预留和提交
void *data = ringbuf_reserve(&rb, sizeof(struct event), 0);
if (data) {
    memcpy(data, &event, sizeof(event));
    ringbuf_submit(data, 0);
}

// 用户态消费
struct ring_buffer *rb = ring_buffer__new(map_fd, handle_event, NULL, NULL);
ring_buffer__poll(rb, 100);

对比：

八、libbpf 用户态开发完整流程

8.1 编译 eBPF 对象

# 使用 CO-RE（Compile Once, Run Everywhere）
clang -O2 -g -target bpf -D__TARGET_ARCH_x86 \
    -I/usr/include/bpf \
    -c network_observer.bpf.c -o network_observer.bpf.o

# 生成骨架头文件
bpftool gen skeleton network_observer.bpf.o > network_observer.skel.h

8.2 用户态加载器

#include "network_observer.skel.h"

int main(int argc, char **argv) {
    struct network_observer_bpf *skel;
    struct perf_buffer *pb = NULL;
    int err;

    // 1. 打开骨架
    skel = network_observer_bpf__open();
    if (!skel) {
        fprintf(stderr, "Failed to open BPF skeleton\n");
        return 1;
    }

    // 2. 设置参数
    skel->rodata->target_port = 80;
    skel->rodata->threshold_pps = 1000;

    // 3. 加载并验证
    err = network_observer_bpf__load(skel);
    if (err) {
        fprintf(stderr, "Failed to load BPF skeleton\n");
        goto cleanup;
    }

    // 4. 挂载到 TC
    err = bpf_program__attach(skel->progs.tc_classifier);
    if (err) {
        fprintf(stderr, "Failed to attach TC program\n");
        goto cleanup;
    }

    // 5. 设置 perf buffer 回调
    pb = perf_buffer__new(bpf_map__fd(skel->maps.events),
                          8, handle_event, handle_lost, NULL, NULL);

    // 6. 事件循环
    while (true) {
        err = perf_buffer__poll(pb, 100);
        if (err == -EINTR) continue;
        if (err < 0) break;
    }

cleanup:
    perf_buffer__free(pb);
    network_observer_bpf__destroy(skel);
    return err;
}

九、Aya：Rust 生态 eBPF 框架

9.1 Aya 核心优势

• 无 C 依赖：纯 Rust 编写 BPF 程序和用户态加载
• 类型安全的映射：编译时检查映射键值类型
• 异步用户态：原生 tokio 集成
• BTF CO-RE 支持：开箱即用

use aya::{Bpf, programs::{Xdp, XdpFlags}};
use aya::maps::PerfEventArray;
use aya::util::online_cpus;
use bytes::BytesMut;

#[derive(Debug)]
#[repr(C)]
struct FlowEvent {
    src_ip: u32,
    dst_ip: u32,
    src_port: u16,
    dst_port: u16,
    protocol: u8,
    bytes: u64,
}

#[xdp]
fn xdp_observer(ctx: XdpContext) -> u32 {
    let ethhdr: *const EthHdr = unsafe { ptr_at(&ctx, 0)? };
    let eth_type = unsafe { (*ethhdr).eth_type };

    if eth_type != EtherType::Ipv4 {
        return xdp_action::XDP_PASS;
    }

    let ipv4hdr: *const Ipv4Hdr = unsafe { ptr_at(&ctx, EthHdr::LEN)? };
    let src_ip = u32::from_be(unsafe { (*ipv4hdr).src_addr });
    let dst_ip = u32::from_be(unsafe { (*ipv4hdr).dst_addr });

    // 记录流量
    EVENTS.output(&ctx, &FlowEvent {
        src_ip, dst_ip, src_port, dst_port, protocol, bytes
    }, 0);

    xdp_action::XDP_PASS
}

#[tokio::main]
async fn main() -> Result<()> {
    let mut bpf = Bpf::load(include_bytes_aligned!(
        "../../target/bpfel-unknown-none/debug/network-observer"
    ))?;

    let program: &mut Xdp = bpf.program_mut("xdp_observer").unwrap().try_into()?;
    program.load()?;
    program.attach("eth0", XdpFlags::default())?;

    let mut perf_array = PerfEventArray::try_from(bpf.map_mut("EVENTS")?);
    for cpu_id in online_cpus()? {
        let buf = perf_array.open(cpu_id, None)?;
        tokio::spawn(async move {
            let mut buffers = (0..10).map(|_| BytesMut::with_size(1024)).collect();
            loop {
                let events = buf.read_events(&mut buffers).unwrap();
                for buf in buffers.iter().take(events.read) {
                    let ptr: *const FlowEvent = buf.as_ptr() as *const _;
                    let event = unsafe { ptr.read_unaligned() };
                    println!("{:?}", event);
                }
            }
        });
    }

    tokio::signal::ctrl_c().await?;
    Ok(())
}

十、生产级网络观测系统架构

10.1 全栈可观测性平台设计

┌─────────────────────────────────────────────────────────┐
│                     用户态控制平面                       │
│  ┌─────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐ │
│  │ Grafana │  │ Prometheus│  │   Jaeger │  │  Policy  │ │
│  └────┬────┘  └─────┬────┘  └─────┬────┘  └─────┬────┘ │
└───────┼──────────────┼────────────┼──────────────┼──────┘
        │              │            │              │
┌───────┼──────────────┼────────────┼──────────────┼──────┐
│       ▼              ▼            ▼              ▼      │
│  ┌──────────────────────────────────────────────────┐   │
│  │         eBPF Agent (DaemonSet/单机)               │   │
│  │                                                  │   │
│  │  ┌─────────┐ ┌──────────┐ ┌──────────────────┐  │   │
│  │  │ Metric  │ │  Flow    │ │    Latency       │  │   │
│  │  │ Export  │ │  Record  │ │    Histogram     │  │   │
│  │  └────┬────┘ └────┬─────┘ └───────┬──────────┘  │   │
│  │       │           │               │              │   │
│  │  ┌────▼───────────▼───────────────▼──────────┐   │   │
│  │  │    BPF Map Aggregation Layer              │   │   │
│  │  └────────────────┬─────────────────────────┘   │   │
│  └───────────────────┼────────────────────────────┘   │
└──────────────────────┼─────────────────────────────────┘
                       │
         ┌─────────────┴──────────────┐
         │       Kernel Space         │
         │                            │
         │  XDP ──── Perf/Ring Buffer  │
         │  TC  ──── Hash Map Export  │
         │  Perf event output         │
         │  Kprobe/Tracepoint         │
         └────────────────────────────┘

10.2 Metric 导出模式

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __type(key, struct flow_key);
    __type(value, struct flow_metrics);
    __uint(max_entries, 10000);
} flow_metrics SEC(".maps");

struct flow_metrics {
    __u64 rx_packets;     // Prometheus Counter
    __u64 rx_bytes;       // Prometheus Counter
    __u64 tx_packets;     // Prometheus Counter
    __u64 tx_bytes;       // Prometheus Counter
    __u64 tcp_retrans;    // Prometheus Counter
    __u64 rtt_us;         // Prometheus Gauge (Histogram)
    __u64 last_seen;      // 活跃性判断
};

// 用户态通过 BPF_MAP_TYPE_HASH 定期读取并推送至 Prometheus
static void export_metrics(int map_fd) {
    struct flow_key key = {}, next_key;
    struct flow_metrics metrics;

    while (bpf_map_get_next_key(map_fd, &key, &next_key) == 0) {
        bpf_map_lookup_elem(map_fd, &next_key, &metrics);

        // 推送 Prometheus
        prometheus_counter_set(
            flow_rx_packets, metrics.rx_packets, labels);
        prometheus_histogram_observe(
            flow_rtt, metrics.rtt_us, labels);

        // 清除已导出的计数
        bpf_map_delete_elem(map_fd, &next_key);
        key = next_key;
    }
}

10.3 网络流日志（Flow Log）聚合

struct flow_record {
    __u32 src_ip;
    __u32 dst_ip;
    __u16 src_port;
    __u16 dst_port;
    __u8  protocol;
    __u8  direction;    // ingress/egress
    __u64 start_time;   // 首次观测时间
    __u64 end_time;     // 最后活动时间
    __u64 bytes;
    __u64 packets;
    __u8  tcp_flags;    // TCP 标志位集合
    __u8  flags;        // 流结束标志（FIN/RST）
};

每秒聚合一次推送：减少用户态 99% 的事件量，同时保留连接级详单。

10.4 延迟测量矩阵

十一、性能调优与最佳实践

11.1 BPF 映射选型决策树

需要高性能计数？
  ├─ 是 → BPF_MAP_TYPE_PERCPU_HASH / PERCPU_ARRAY
  └─ 否 ─▶
          需要 LRU 淘汰？
            ├─ 是 → BPF_MAP_TYPE_LRU_HASH
            └─ 否 ─▶
                    键/值是否固定大小？
                      ├─ 否 → BPF_MAP_TYPE_HASH
                      └─ 是 ─▶ 是否需要范围遍历？
                               ├─ 是 → BPF_MAP_TYPE_ARRAY
                               └─ 否 → BPF_MAP_TYPE_HASH

11.2 JIT 编译优化

# 查看 JIT 状态
bpftool prog show

# 开启 JIT（默认开启）
sysctl net.core.bpf_jit_enable=1

# JIT 硬解压模式（高性能网络场景）
sysctl net.core.bpf_jit_harden=0

# 查看 JIT 编译后的汇编
bpftool prog dump xlated pinned /sys/fs/bpf/xdp_observer

11.3 大流量场景下的 CPU 隔离

# 1. 隔离 CPU 核心
 isolcpus=2,3,4,5  # kernel cmdline

# 2. 将网卡中断绑定到特定核心
echo ffe > /proc/irq/IRQ_NUMBER/smp_affinity

# 3. XDP 程序绑定 RX 队列
ip link set eth0 xdp obj xdp.o sec xdp

# 4. 应用线程运行在隔离核心
taskset -c 2-5 ./network_observer

11.4 BPF 验证器优化技巧

// 使用 volatile 强制读取编译器优化后的值
#define BPF_REALLY_READ(ptr) (*(volatile typeof(*(ptr)) *)(ptr))

// Verifier 友好的循环写法
#pragma unroll
for (int i = 0; i < MAX_HEADER_DEPTH; i++) {
    // 每次迭代有明确退出条件
    if (offset >= end_offset)
        break;
    // 解析逻辑...
    offset += header_size;
}

// 使用 bpf_probe_read_kernel/bpf_probe_read_user
// 而非直接指针访问（当指针可能无效时）

十二、调试与排错

12.1 bpftool 调试工具链

# 列出所有 BPF 程序
bpftool prog show

# 即时程序状态
bpftool prog show id 42 --pretty

# 查看映射内容
bpftool map dump id 10

# 追踪 BPF 程序输出
bpftool tracelog

# 检查 BPF 对象文件
bpftool gen object file.o

# 网络相关
bpftool net show          # 接口上挂载的 BPF 程序
bpftool net attach xdp id 42 dev eth0
bpftool net detach xdp dev eth0

12.2 常见验证器错误速查

12.3 性能剖析

# BPF 程序 CPU 热点分析
perf record -a -g sleep 30

# BPF JIT 代码逆向
bpftool prog dump xlated id 42 > /tmp/dump.txt
bpftool prog dump jited id 42 > /tmp/jited.txt

# 识别高频路径
bpftool map dump id 10 | sort -k3 -nr | head -20

十三、安全边界与拒绝服务防护

13.1 Verifier 安全保证

BPF 验证器强制执行：

1. 终止性保证：所有循环必须有界（阻止 DoS）
2. 类型安全：寄存器类型严格追踪（scalar/ptr_to_xxx/spin_lock）
3. 内存边界：所有 memory 访问必须检查边界
4. 无泄漏：不允许泄漏内核地址给用户态（enum bpf_func_id）
5. 受限调用：仅能调用白名单辅助函数

13.2 eBPF 对网络安全的增强

十四、展望：eBPF 与可编程网络未来

14.1 BPF 作为网络操作系统内核

eBPF 正在从根本上改变 Linux 网络栈的设计模式：

• 可替代 iptables/ipset：O(1) 匹配 vs O(n) 遍历
• 替代内核模块：模块化、安全、热加载
• SmartNIC 卸载：BPF 字节码下放至网卡硬件
• P4 → BPF 编译：P4 语言编译为 eBPF 字节码
• QUIC 卸载：可编程 L4 协议处理

14.2 跨内核版本 CO-RE

BTF（BPF Type Format）使得 eBPF 程序可以跨内核运行：

# 生成 BTF 头文件（内核 5.4+）
bpftool btf dump file /sys/kernel/btf/vmlinux format c > vmlinux.h

# 编译 BPF 对象（使用 BTF 信息）
clang -O2 -g -target bpf -D__TARGET_ARCH_x86 -c program.bpf.c

14.3 BPF 生态演进趋势

• 用户态 BPF：BPF 在 WebAssembly 和用户态 JIT 运行
• BPF 命名空间：容器级 BPF 隔离（多租户安全）
• BPF 热更新：不停机替换 BPF 程序和映射
• 硬件 BPF：ARM64/RISC-V 扩展 BPF 指令集

总结

eBPF 网络观测的核心价值在于：在内核空间安全地、高性能地、可编程地观测和干预网络流量。掌握 XDP、TC、sockmap、kprobe 这四大挂载点，配合 libbpf/Aya 开发框架和完善的 BPF 映射设计，可以构建覆盖数据包级、流级、套接字级、cgroup 级的全栈网络可观测性体系。

从 Cloudflare 的 DDoS 防护到 Cilium 的 Kubernetes 网络方案，从 Pixie 的运行时观测到 Falco 的安全审计，eBPF 已成为现代网络基础设施不可或缺的基础能力。理解其核心机制和工程实践，对于构建高性能、可观测、安全的网络系统至关重要。