Linux 内核 BPF 迭代器深度实战：从内核数据结构遍历到可编程观测

一、为什么需要 BPF 迭代器？内核观测的"最后一公里"

在 Linux 内核的观测体系中，/proc 文件系统曾是用户态获取内核状态的唯一官方通道。但 procfs 存在固有的设计缺陷：数据在 kernel→user 的 copy 路径上需要经历格式化 snprintf → 用户read → 用户解析文本的两次转换，既浪费 CPU 又丢失精度。

BPF（Berkeley Packet Filter）早在 4.1 版本就通过 kprobes/tracepoint 实现了精准的逐事件观测，但有一个关键空白：无法高效遍历内核中已有的聚合数据结构。例如你需要列出所有进程的内存映射、所有 TCP 连接的状态、所有已加载的 BPF 程序 —— 这些操作过去只能通过 proc 文件逐一读取。

BPF 迭代器（BPF Iterators） 正是填补这一空白的基础设施。它允许在内核态直接、安全、可编程地遍历任意内核数据结构，并将结果通过 ring buffer、perf buffer 或 seq_file 直接投递到用户态，消除了文本序列化的开销与精度损失。

二、架构设计：六种迭代器类型与内核生命周期

从 5.8 开始，内核提供了六类原生迭代器，每类对应一种内核子系统的聚合视图：

迭代器的生命周期严格遵循"打开 → 迭代 → 关闭"三个阶段。当用户调用 bpf_iter_create() 打开一个迭代链接（bpf_link）时，内核分配一个迭代上下文（bpf_iter_target），保存私有数据（如 PID 命名空间、cgroup 句柄），并通过 seq_operations 的 start/show/next/stop 四个回调驱动遍历过程。

三、核心实现：从 bpf_seq_read 到可编程的 show 回调

BPF 迭代器的设计精妙之处在于它复用了内核已有的 seq_file 框架，将传统的"seq_show 函数指针"替换为 BPF 程序的调用入口。

一个 BPF 迭代器程序的关键生命周期如下：

1. prepare（用户态）：通过 bpf_link_create() 指定迭代器类型和可选参数（如 PID_NS），内核 bpf_iter.c 中的 bpf_iter_attach_target() 完成注册。
2. reg_seq：内核为该目标注册一个 seq_operations 实例，其中 seq_show 指向 bpf_iter_run_prog()。
3. read loop：当用户态对 /proc/bpf_iter/<target> 执行 read 时，VFS 触发 bpf_seq_read()，它先将 ctx 传入 BPF 程序， BPF 程序返回值决定是否输出当前条目。
4. show/produce：每次 show 调用时，BPF 程序通过辅助函数 bpf_seq_write()、bpf_seq_printf() 或 bpf_seq_puts() 生成输出数据。
5. teardown：关闭链接时 bpf_iter_detach_target() 释放资源。

这里的关键约束是：BPF 迭代器程序不能修改被遍历的数据结构（只读），这通过 BPF verifier 对辅助函数的访问权限检查来保证。

四、编写 BPF 迭代器程序：从 seq_file 到 ring buffer

先看一个最简单的 BPF 迭代器程序——遍历所有进程并输出其 PID 与内存使用：

// bpf_iter_task.bpf.c
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>
#include <bpf/bpf_core_read.h>

char _license[] SEC("license") = "GPL";

struct process_info {
    __u32 pid;
    __u32 tgid;
    __u64 rss_pages;
    __u64 vmem_bytes;
    char comm[16];
};

SEC("iter/task")
int bpf_iter_task_process(struct bpf_iter__task *ctx)
{
    struct task_struct *task = ctx->task;
    struct process_info info = {};
    
    if (!task)
        return 0;  // meta-record, skip

    info.pid = task->pid;
    info.tgid = task->tgid;
    info.rss_pages = BPF_CORE_READ(task, mm, rss_stat.count[MM_FILEPAGES].counter)
                   + BPF_CORE_READ(task, mm, rss_stat.count[MM_ANONPAGES].counter);
    info.vmem_bytes = BPF_CORE_READ(task, mm, total_vm) << PAGE_SHIFT;
    bpf_probe_read_kernel_str(info.comm, sizeof(info.comm), task->comm);

    // 通过 seq_file 输出到 /proc/bpf_iter/task
    bpf_seq_write(ctx->meta->seq, &info, sizeof(info));
    
    return 0;  // 非0表示跳过当前条目
}

用户态加载与读取：

// loader.c
#include <bpf/libbpf.h>

int main(int argc, char **argv)
{
    struct bpf_object *obj;
    struct bpf_link *link;
    struct bpf_program *prog;
    int iter_fd;
    char buf[4096];
    ssize_t ret;

    obj = bpf_object__open_file("bpf_iter_task.bpf.o", NULL);
    bpf_object__load(obj);

    prog = bpf_object__find_program_by_name(obj, "bpf_iter_task_process");
    link = bpf_iter__attach(prog);  // 关键：iter attach
    if (!link) { /* error */ }

    iter_fd = bpf_iter_create(bpf_link__fd(link));
    if (iter_fd < 0) { /* error */ }

    while ((ret = read(iter_fd, buf, sizeof(buf))) > 0) {
        // 解析 struct process_info 数组
        struct process_info *info = (void *)buf;
        for (ssize_t i = 0; i < ret / sizeof(*info); i++)
            printf("PID=%u TGID=%u RSS=%luMB Comm=%s\n",
                   info[i].pid, info[i].tgid,
                   info[i].rss_pages * 4096 / 1024 / 1024,
                   info[i].comm);
    }

    close(iter_fd);
    bpf_link__destroy(link);
    bpf_object__close(obj);
    return 0;
}

这比读取 /proc/*/status 的方式有本质区别：一次 read 调用即可获取全局快照，不需要数百次文件打开与解析。

五、TCP 连接状态机实时追踪：生产故障定位

生产中最常见的场景是实时追踪 TCP 连接状态。传统做法差取决于 ss -tan 的抽样延迟（默认 1 秒，高负载下丢失率高）。BPF 迭代器可以提供精确、零丢失的连接快照。

// bpf_iter_tcp.bpf.c
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_tracing.h>
#include <bpf/bpf_core_read.h>

struct tcp_sock_info {
    __u32 saddr;       // 本地地址 (网络字节序)
    __u32 daddr;       // 远端地址
    __u16 sport;       // 本地端口
    __u16 dport;       // 远端端口
    __u8  state;       // TCP 状态码
    __u8  ca_state;    // 拥塞控制状态
    __u32 cwnd;        // 拥塞窗口
    __u32 rtt;         // 平滑 RTT (us)
    __u64 bytes_sent;  // 已发送字节数
    __u64 bytes_recv;  // 已接收字节数
};

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 8192);
    __type(key, __u64);     // sk 地址作为 key
    __type(value, struct tcp_sock_info);
} sock_map SEC(".maps");

SEC("iter/tcp6")
int bpf_iter_tcp6(struct bpf_iter__tcp *ctx)
{
    struct tcp_sock_info info = {};
    struct inet_sock *inet = (struct inet_sock *)ctx->sk;
    struct tcp_sock *tp = (struct tcp_sock *)ctx->sk;

    if (!inet || !tp) return 0;

    // 用户态通过 BPF_CORE_READ 自动处理 BTF 重定位
    bpf_probe_read_kernel(&info.saddr, sizeof(info.saddr),
                          &inet->inet_saddr);
    bpf_probe_read_kernel(&info.daddr, sizeof(info.daddr),
                          &inet->pinet_bound_dev_if ? &inet->inet_daddr : 0);

    info.sport = bpf_ntohs(inet->inet_sport);
    info.dport = bpf_ntohs(inet->inet_dport);
    info.state = ctx->sk->__sk_common.skc_state;
    
    // 拥塞控制内部状态
    info.ca_state = BPF_CORE_READ(tp, snd_cwnd);
    info.cwnd = BPF_CORE_READ(tp, snd_cwnd);
    info.rtt = BPF_CORE_READ(tp, srtt_us) >> 3;  // srtt 存储为 8x 值
    
    info.bytes_sent = BPF_CORE_READ(tp, bytes_acked);
    info.bytes_recv = BPF_CORE_READ(tp, bytes_received);

    bpf_seq_write(ctx->meta->seq, &info, sizeof(info));
    return 0;
}

这个程序可以精确捕获 TCP 连接状态切换时的瞬时窗口和 RTT，相比 ss -i 中的抽样表，它能完整记录连接的闭合与重传事件。

六、VMA 遍历：进程内存映射的实时分析

每个进程的 task->mm->mmap 链表包含了完整的虚拟内存区间信息。在生产中经常需要分析特定进程的内存映射构成（heap/stack/mmap-匿名/mmap-文件），传统的 /proc/PID/maps 读取开销极大（高频的 seq_file 重入）。

SEC("iter/task_vma")
int bpf_iter_vma(struct bpf_iter__task_vma *ctx)
{
    struct vm_area_struct *vma = ctx->vma;
    struct vma_info info = {};

    if (!vma) return 0;

    info.vm_start = vma->vm_start;
    info.vm_end = vma->vm_end;
    info.vm_flags = vma->vm_flags;
    info.vm_pgoff = vma->vm_pgoff << PAGE_SHIFT;

    // 如果 VMA 关联文件，记录文件 inode 号和路径
    if (vma->vm_file) {
        struct inode *inode = vma->vm_file->f_inode;
        info.i_ino = BPF_CORE_READ(inode, i_ino);
        bpf_d_path(vma->vm_file, info.fpath, sizeof(info.fpath));
    }

    bpf_seq_write(ctx->meta->seq, &info, sizeof(info));
    return 0;
}

VMA 迭代器的独特价值在于它能以零循环开销直接访问内核结构，避免了用户态拼接文件路径的开销。

七、性能与 CPU 开销：量化评估

在实际生产环境中的性能对比如下：

BPF 迭代器的核心性能优势来源在于：循环执行在内核的 BPF 虚拟机中，避免了用户态/内核态双边上下文切换与文本格式化开销。对于包含百万级条目的大规模遍历（如长连接追踪场景），这种优势更为显著。

八、高级用法：参数化迭代器与 Filter 链

从 5.14 开始，BPF_ITER_CGROUP 支持通过 cgroup fd 进行范围约束，避免全系统扫描。内核通过 bpf_iter_target.info 结构中的 task.cgroup.cgroup_fd 字段将过滤逻辑下沉到内核：

// 用户态代码：绑定迭代器到指定 cgroup
int cgroup_fd = open("/sys/fs/cgroup/my-container", O_RDONLY);

union bpf_iter_link_info info = {
    .task = {
        .cgroup = {
            .cgroup_fd = (__u32)cgroup_fd,
            .order = BPF_ITER_ORDER_CGROUP_PROCS,  // 或 UNSET 遍历直接子 cgroup
        },
    },
};

struct bpf_link *link = bpf_link_create(
    prog_fd,    // 迭代器程序 FD
    -1,         // 迭代器没有 target fd
    BPF_ITER_TASK,
    &info
);

bpf_link_create()                   // kernel/bpf/syscall.c
  → bpf_iter_link_attach()           // kernel/bpf/iter.c
    → bpf_iter_attach_target()
      → target->reg_qialized()       // 检查目标是否注册 (如 target/task.c)
      → bpf_iter_inc_misc()          // 增加模块引用计数
      → seq_open_private()           // 分配文件

seq_read()                          // fs/seq_file.c
  → bpf_seq_read()                  // kernel/bpf/iter.c
    → bpf_iter_run_prog()           // 执行 BPF 程序
      → BPF_PROG_RUN(prog, ctx)     // 进入 BPF 虚拟机

SEC("iter/task")
int bpf_iter_container_use(struct bpf_iter__task *ctx)
{
    struct task_struct *task = ctx->task;
    if (!task) return 0;

    struct use_metrics m = {};
    struct mm_struct *mm = BPF_CORE_READ(task, mm);
    struct signal_struct *sig = BPF_CORE_READ(task, signal);

    // Utilization: 累计运行时间
    m.utime =BPF_CORE_READ(task, utime);
    m.stime = BPF_CORE_READ(task, stime);
    
    // Saturation: 内存缺页压力（非阻塞计入 used 指标）
    m.min_flt = BPF_CORE_READ(task, min_flt);
    m.maj_flt = BPF_CORE_READ(task, maj_flt);
    m.rss_kb = (BPF_CORE_READ(task, mm, rss_stat.count[MM_FILEPAGES].counter)
              + BPF_CORE_READ(task, mm, rss_stat.count[MM_ANONPAGES].counter)) * 4;
    
    // Errors: OOM 评分调整 + 退出信号
    m.om_adj = BPF_CORE_READ(sig, oom_score_adj);
    m.exit_sig = BPF_CORE_READ(task, exit_code) & 0x7f;
    
    // 仅输出异常退出或高 RSS
    if (m.exit_sig != 0 || m.rss_kb > 512 * 1024) {
        m.pid = task->pid;
        bpf_get_current_comm(m.comm, sizeof(m.comm));
        bpf_seq_write(ctx->meta->seq, &m, sizeof(m));
    }
    
    return 0;
}