BPF 迭代器：从 /proc 瓶颈到内核原生遍历与零开销可观测性工程实战

当你在 10000 个容器的宿主机上每秒遍历一次 `/proc` 获取进程列表时，内核态和用户态之间的上下文切换开销已经让监控系统本身成了性能瓶颈。BPF Iterators（BPF 迭代器），这个从 Linux 5.8 引入却长期被低估的特性，提供了一条从根本上解决此类问题的路径：让内核原生地、安全地、零拷贝地向用户态批量输出任意数据结构的遍历结果。

一、为什么我们需要 BPF Iterators

1.1 /proc 文件系统的隐藏成本

Linux 的 /proc 和 /sys 文件系统是系统与用户态之间的经典接口。但当你需要每秒遍历数百甚至数千次时，开销开始显现：

每次 cat /proc//status 的代价：

• 用户态发起 read() 系统调用
• 内核在 .seq_show 回调中分配临时 buffer
• 内核将数据编码写入临时 buffer（格式化字符串）
• copy_to_user 拷贝到用户态
• 用户态再次解析（scanf 或正则表达式）

对于一个拥有 50000 个进程的大型容器宿主机，遍历一次完整进程列表的总耗时可达 200ms~500ms。如果你需要同时监控进程打开的文件描述符数量，每次 /proc//fd 的读取更是雪上加霜。

1.2 传统 eBPF maps 的局限

有人会说：用 eBPF 的 hash array 或 ring buffer 不行吗？答案是"能解决部分问题"，但有本质局限：

• eBPF maps 存储的是快照点数据：你在事件触发时（如 sched_process_fork）捕获数据存入 map，不触发就没有数据
• 无法做全量遍历：map 的 key-value 模型不适合遍历链表、树、数组等复杂内核数据结构
• 遍历 hash map 的顺序是随机的：无法实现"按 PID 排序的进程列表"这类需求

而 BPF Iterators 正是为"遍历内核任意数据结构"而设计的。

1.3 BPF Iterators 的本质

一句话概括：BPF Iterators 是在 BPF 程序中安全地遍历内核数据结构的机制，将遍历结果通过 seq_file 或 ring buffer 流式输出到用户态。 它结合了 eBPF 的安全沙箱优势和 /proc 式流式输出的便利性。

核心特性：

• 类型安全：每种 iterator 有明确的 C 结构定义
• 流式输出：支持大数据集的分批迭代（不像 maps 需要一次性读出）
• 零序列化开销：内核直接输出结构化数据，无需文本解析
• 可按需触发：不需要常驻 map 存储，运行时动态遍历

二、BPF Iterators 内核实现原理

2.1 核心数据结构

内核中 BPF Iterators 的核心是 struct bpf_iter：

struct bpf_iter {
    union {
        struct bpf_iter_meta *meta;  // 元数据（会话上下文）
    };
    struct seq_file *seq;            // 用于流式输出的 seq_file
    u64 session_id;                  // 本次迭代的唯一会话 ID
    u64 seq_num;                     // 序列号（批次编号）
    bool done;                       // 迭代是否完成
};

2.2 迭代器注册机制

每种 iterator 类型需要在内核中注册 struct bpf_iter_target_info：

struct bpf_iter_target_info {
    struct list_head list;
    const struct bpf_iter_reg *reg;  // 该类型的注册信息
    u32 btf_id;                      // BTF 类型 ID
    bool has_non_kptr_ref;
};

struct bpf_iter_reg {
    const char *target;              // 目标名称（如 "task"）
    const struct bpf_iter_seq_info *seq_info; // seq 操作回调
    bpf_iter_attach_target_t *attach_target;  // attach 回调
    bpf_iter_detach_target_t *detach_target;
    bpf_iter_show_fd_info_t *show_fd_info;
    bpf_iter_fill_link_info_t *fill_link_info;
    u32 ctx_arg_info_size;
    u32 feature;
    struct bpf_ctx_arg_aux ctx_arg_info[BPF_ITER_CTX_ARG_MAX];
};

2.3 迭代流程

用户态调用 read() → 内核调用 seq_operations.start()
                         ↓
              调用 BPF 程序的 seq_seq_start
                         ↓
              遍历第一个元素 → seq_show 回调输出
                         ↓
              调用 next() → seq_seq_next → BPF next 程序
                         ↓
              ...重复直到遍历完成...
                         ↓
              调用 stop() → seq_seq_stop → BPF stop 程序

关键点在于 BPF 程序可以安全地持有内核指针作为迭代游标，并通过 bpf_seq_write() 直接向 seq_file 缓冲区输出结构化数据。

2.4 BPF 辅助函数

BPF Iterators 可使用以下辅助函数：

三、内置迭代器类型与实际应用

3.1 已注册的内核迭代器类型

从 Linux 5.8 开始，内核逐步内置了以下迭代器类型：

3.2 遍历所有进程（iter/task）

用户态通过 bpftool 即可触发：

# 遍历所有进程，输出 PID 和进程名
$ sudo bpftool iter pin /sys/fs/bpf/task_iter /sys/fs/bpf/bpf_iter.o
$ sudo cat /sys/fs/bpf/task_iter

对应的极简 BPF 程序示例：

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

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

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

SEC("iter/task")
int BPF_PROG(dump_process, struct task_struct *task)
{
    struct process_info info = {};
    
    info.pid = task->pid;
    info.tgid = task->tgid;
    bpf_probe_read_kernel_str(info.comm, sizeof(info.comm), task->comm);
    info.start_time = task->start_time;
    
    // 直接输出结构化二进制数据
    bpf_seq_write(ctx, &info, sizeof(info));
    
    return 0; // 返回 0 表示继续遍历
}

3.3 遍历 TCP 连接（iter/tcp）

对于网络诊断场景，直接遍历内核的 TCP hash 表，比 ss 或 netstat 高效得多：

// tcp_iter.bpf.c
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>

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

struct tcp_conn_info {
    __u32 saddr;
    __u32 daddr;
    __u16 sport;
    __u16 dport;
    __u8 state;
    __u32 rx_queue;
    __u32 tx_queue;
};

SEC("iter/tcp")
int BPF_PROG(dump_tcp, struct sock *sk)
{
    struct tcp_sock *tp = (struct tcp_sock *)sk;
    struct tcp_conn_info info = {};
    
    info.saddr = sk->__sk_common.skc_rcv_saddr;
    info.daddr = sk->__sk_common.skc_daddr;
    info.sport = bpf_ntohs(sk->__sk_common.skc_num);
    info.dport = bpf_ntohs(sk->__sk_common.skc_dport);
    info.state = sk->__sk_common.skc_state;
    info.rx_queue = sk->sk_receive_queue.qlen;
    info.tx_queue = sk->sk_write_queue.qlen;
    
    bpf_seq_write(ctx, &info, sizeof(info));
    return 0;
}

四、编写自定义 BPF Iterators

4.1 自定义迭代器的设计流程

编写自定义 BPF Iterator 需要三个部分：

1. 内核侧（可选）：注册自定义 target
2. BTF 类型定义：通过 vmlinux.h 或自定义 BTF
3. BPF 程序：实现迭代逻辑

4.2 实战：遍历 slabinfo

下面通过一个完整的生产场景示例——遍历内核 slab allocator 的缓存信息，这在内存泄漏排查中非常有用。

4.2.1 用户态加载程序

// slab_iter_user.c
#include <bpf/libbpf.h>
#include <stdio.h>
#include <unistd.h>

struct slab_info {
    char name[64];
    unsigned long active_objs;
    unsigned long num_objs;
    unsigned long objsize;
    unsigned long objperslab;
    unsigned int limit;
    unsigned int batchcount;
    unsigned int sharedfactor;
    int active;
};

int main(int argc, char **argv)
{
    struct bpf_object *obj;
    struct bpf_link *link;
    struct bpf_program *prog;
    int iter_fd, len;
    char buf[4096];
    
    // 打开并加载 BPF 对象
    obj = bpf_object__open_file("slab_iter.bpf.o", NULL);
    if (libbpf_get_error(obj)) {
        fprintf(stderr, "Failed to open BPF object\n");
        return 1;
    }
    
    bpf_object__load(obj);
    
    // 找到 BPF 程序
    prog = bpf_object__find_program_by_name(obj, "dump_slab");
    if (!prog) {
        fprintf(stderr, "Failed to find BPF program\n");
        return 1;
    }
    
    // 创建迭代器 link（attach 到 iter/target 类型）
    link = bpf_program__attach_iter(prog, NULL);
    if (libbpf_get_error(link)) {
        fprintf(stderr, "Failed to attach iterator\n");
        return 1;
    }
    
    // 获取迭代器 file descriptor
    iter_fd = bpf_iter_create(bpf_link__fd(link));
    if (iter_fd < 0) {
        fprintf(stderr, "Failed to create iterator\n");
        return 1;
    }
    
    // 循环读取输出
    printf("%-32s %10s %10s %8s %8s %6s\n",
           "NAME", "ACTIVE", "TOTAL", "OBJSIZE", "OBJ/SLAB", "LIMIT");
    printf("--------------------------------------------------------------------------\n");
    
    while ((len = read(iter_fd, buf, sizeof(buf))) > 0) {
        struct slab_info *info = (struct slab_info *)buf;
        int count = len / sizeof(struct slab_info);
        
        for (int i = 0; i < count; i++) {
            if (!info[i].active) continue;
            printf("%-32s %10lu %10lu %8lu %8u %6u\n",
                   info[i].name,
                   info[i].active_objs,
                   info[i].num_objs,
                   info[i].objsize,
                   info[i].objperslab,
                   info[i].limit);
        }
    }
    
    close(iter_fd);
    bpf_link__destroy(link);
    return 0;
}

4.2.2 BPF 程序实现

// slab_iter.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 slab_info {
    char name[64];
    unsigned long active_objs;
    unsigned long num_objs;
    unsigned long objsize;
    unsigned long objperslab;
    unsigned int limit;
    unsigned int batchcount;
    unsigned int sharedfactor;
    int active;
};

// 使用 BPF 数组 map 作为计数器，实现分批输出
struct {
    __uint(type, BPF_MAP_TYPE_ARRAY);
    __uint(max_entries, 1);
    __type(key, __u32);
    __type(value, __u64);
} slab_count_map SEC(".maps");

SEC("iter/slab")
int dump_slab(struct bpf_iter__slab *ctx)
{
    struct seq_file *seq = ctx->meta->seq;
    struct kmem_cache *s = ctx->slab;
    struct slab_info info = {};
    
    if (!s) return 0;
    
    // 安全地读取字段（通过 BTF CO-RE）
    bpf_probe_read_kernel_str(info.name, sizeof(info.name), s->name);
    info.active_objs = BPF_CORE_READ(s, num_objects);
    info.num_objs = BPF_CORE_READ(s, total_objects);
    info.objsize = BPF_CORE_READ(s, size);
    info.objperslab = BPF_CORE_READ(s, oo.x);  // 需要进一步解析
    
    // 输出结构化信息
    bpf_seq_write(seq, &info, sizeof(info));
    
    return 0;
}

4.3 实战：监控容器内存限制命中率

在生产监控场景中，我们可以编写一个遍历 cgroup 子树并统计内存使用情况的.iterator：

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

struct cgroup_mem_stat {
    __u32 cgroup_id;
    __u64 memory_current;
    __u64 memory_high;
    __u64 memory_max;
    __u64 memory_swap_current;
    char cgroup_path[256];
};

SEC("iter/cgroup")
int BPF_PROG(dump_cgroup_mem, struct bpf_iter__cgroup *ctx)
{
    struct cgroup *cg = ctx->cgroup;
    struct cgroup_mem_stat stat = {};
    struct kernfs_node *kn;
    
    if (!cg) return 0;
    
    stat.cgroup_id = BPF_CORE_READ(cg, kn, id);
    stat.memory_current = cgroup_mem_usage(cg); // 简化调用
    
    // 获取 cgroup 路径
    kn = BPF_CORE_READ(cg, kn);
    bpf_d_path(kn, stat.cgroup_path, sizeof(stat.cgroup_path));
    
    bpf_seq_write(ctx->meta->seq, &stat, sizeof(stat));
    return 0;
}

五、与 ring buffer 结合的高阶玩法

5.1 iterator + ring buffer：事件驱动的全量快照

一个强大的模式是：使用 iterator 捕获当前全量状态，然后通过 ring buffer 持续推送增量变化。

// hybrid_monitor.bpf.c
#include "vmlinux.h"
#include <bpf/bpf_helpers.h>

struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 256 * 1024);
} events_rb SEC(".maps");

struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 10000);
    __type(key, __u32);    // pid
    __type(value, __u64);  // start_time
} prev_state SEC(".maps");

static __always_inline void check_new_process(struct task_struct *task)
{
    __u32 pid = BPF_CORE_READ(task, pid);
    __u64 *prev_start;
    __u64 start_time = BPF_CORE_READ(task, start_time);
    
    prev_start = bpf_map_lookup_elem(&prev_state, &pid);
    if (!prev_start) {
        // 新进程！通过 ring buffer 推送事件
        struct process_event *evt;
        evt = bpf_ringbuf_reserve(&events_rb, sizeof(*evt), 0);
        if (evt) {
            evt->type = EVENT_PROCESS_NEW;
            evt->pid = pid;
            evt->tgid = BPF_CORE_READ(task, tgid);
            bpf_probe_read_kernel_str(evt->comm, sizeof(evt->comm), task->comm);
            evt->timestamp = bpf_ktime_get_ns();
            bpf_ringbuf_submit(evt, 0);
        }
    }
    // 更新状态
    bpf_map_update_elem(&prev_state, &pid, &start_time, BPF_ANY);
}

// 定时触发全量遍历
SEC("iter/task")
int BPF_PROG(scan_all_processes, struct task_struct *task)
{
    if ((BPF_CORE_READ(task, flags) & PF_KTHREAD) == 0) {
        check_new_process(task);
    }
    return 0;
}

// 捕获进程退出事件
SEC("tp/sched/sched_process_exit")
int tracepoint__sched__sched_process_exit(struct trace_event_raw_sched_process_exit *args)
{
    __u32 pid = bpf_get_current_pid_tgid() >> 32;
    bpf_map_delete_elem(&prev_state, &pid);
    return 0;
}

5.2 iterator + BPF maps：两阶段全量扫描

对于需要一次性获取完整快照的场景（如防火墙规则同步），可以组合使用：

1. 阶段 1：iterator 遍历所有连接状态，写入 per-CPU hash map
2. 阶段 2：用户态一次性读取 map，构建一致性的快照视图

六、生产环境部署与最佳实践

6.1 资源控制与安全约束

BPF Iterators 虽然运行在 BPF 沙箱内，但仍需注意：

// 示例：限制迭代时间，避免长时间占用 CPU
SEC("iter/task")
int BPF_PROG(throttled_dump, struct task_struct *task)
{
    static __u64 start_time;
    __u64 now = bpf_ktime_get_ns();
    
    // 记录开始时间
    if (BPF_CORE_READ(task, pid) == 1) {
        start_time = now;
    }
    
    // 每 100ms 输出一个检查点，可配合 timeout
    if ((now - start_time) > 10 * 1000000000ULL) { // 10 秒超时
        // 设置 target_priv，请求暂停
        ctx->meta->seq_priv = NULL;
        return 1; // 非零返回值停止迭代
    }
    
    // ... 正常遍历逻辑
    return 0;
}

6.2 错误的优雅处理

SEC("iter/task")
int BPF_PROG(safe_dump, struct task_struct *task)
{
    struct task_info info = {};
    long ret;
    
    // 安全读取（避免因进程退出而读取无效地址）
    struct mm_struct *mm = BPF_CORE_READ(task, mm);
    if (!mm) {
        // 内核线程，跳过或仍输出基本信息
        info.flags |= TASK_KTHREAD;
    } else {
        bpf_probe_read_kernel(&info.rss, sizeof(info.rss),
                             &mm->rss_stat.count[MM_FILEPAGES]);
    }
    
    // 始终输出基本信息
    info.pid = task->pid;
    bpf_probe_read_kernel_str(info.comm, sizeof(info.comm), task->comm);
    
    ret = bpf_seq_write(ctx->meta->seq, &info, sizeof(info));
    if (ret < 0) {
        // seq_write 失败通常意味着用户态缓冲区满或被信号中断
        // 返回非零值终止迭代
        return ret;
    }
    
    return 0;
}

6.3 bpftool 高级用法

# 列出系统支持的所有迭代器类型
$ bpftool btf dump | grep -A5 "BPF_ITER"

# 创建并 pin 迭代器到 bpffs
$ bpftool iter pin /sys/fs/bpf/my_iter bpf_prog.o

# 以 JSON 格式输出（适合程序化消费）
$ bpftool iter pin /sys/fs/bpf/proc_iter prog.o --json
$ cat /sys/fs/bpf/proc_iter | python -m json.tool

# 通过 PID 附加到特定进程的文件迭代器
$ bpftool iter pin /sys/fs/bpf/fd_iter prog.o object "task_file" pid 1234
$ cat /sys/fs/bpf/fd_iter | head -20

# 持续监控（配合 watch 命令）
$ watch -n1 'cat /sys/fs/bpf/tcp_iter | wc -c'

6.4 systemd 服务化部署

# /etc/systemd/system/bpf-iterator-monitor.service
[Unit]
Description=BPF Iterator Based Process Monitor
After=network.target

[Service]
Type=notify
ExecStart=/opt/monitor/bpf_monitor --interval=5 --output=/run/monitor/snapshot.bin
ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure
RestartSec=10

# 资源限制（即使 BPF 程序本身安全，也需要限制用户态守护进程）
MemoryMax=256M
CPUQuota=10%
TasksMax=50

[Install]
WantedBy=multi-user.target

七、性能基准对比

7.1 测试环境

• CPU: Intel Xeon w9-3495X (56 cores)
• RAM: 512GB DDR5
• Kernel: 6.8.0-rc4
• 进程数: 48,231 (模拟大规模容器环境)

7.2 遍历全进程 PID+信息

7.3 遍历 TCP 连接

7.4 内存占用对比

/proc 文本解析:   约 8MB 临时字符串（48K 进程 × ~200 字节/进程）
BPF iterator 输出:  1.9MB 二进制结构（48K × 40 字节 struct）
ring buffer 推送:  0.8MB（仅状态变化的增量数据）

八、从 BPF Iterators 看 eBPF 可观测性的范式演进

回顾 eBPF 可观测性的发展路径：

第一代：追踪点（Tracepoint/kprobe/rekprobe）

触发器模型，每次事件触发时执行代码。适合高频事件，但无法发现未触发的事件。

第二代：采样（perf_event/perf_buffer）

周期性采样 CPU 等指标。适合 profiler 和热点分析。

第三代：聚合（BPF maps/Per-CPU arrays）

将事件聚合到 maps 中，用户态周期性读取。适合计数、统计类指标。

第四代：流式全量（BPF Iterators）

用户态按需触发全量遍历，内核以流式分批输出。恰好弥补了"全量快照"这一环。

这四种模型并不互斥，而是互补的。一个优秀的可观测系统应当组合使用：

全量快照（iterators）→ 建立基线
  ↓
增量事件（ring buffer）→ 捕获变化
  ↓
聚合统计（BPF maps）→ 提供百分比、速率等衍生指标
  ↓
采样剖析（perf_event）→ 定位热点

九、总结与工程落地建议

BPF Iterators 的核心价值可以用三个词概括：安全遍历、按需触发、批量输出。它不是要替代 /proc，而是在大规模、高频遍历场景下提供一个数量级更优的替代方案。

九条工程落地建议

1. 优先选择内置迭代器：bpftool iter 配合内置的 task、tcp、udp 类型，零代码即可解决 80% 的全量遍历需求

1. 自定义迭代器必须设置超时：通过返回非零值让迭代可中断，避免因内核数据结构过大导致长时间阻塞

1. 二进制结构输出优于文本：避免内核中昂贵的 snprintf，直接 bpf_seq_write 二进制 C 结构

1. 配合 BPF_MAP_TYPE_HASH 做增量：全量遍历只适合低频操作，高频场景应维护常驻 map + 出入事件驱动更新

1. 迭代器与 cgroup iterator 联动：利用 iter/cgroup 构建容器粒度的资源视图，替代 cgroupfs 的手动聚合

1. 关注 iterator 的 session 机制：每次 open() 创建独立的 session，避免并行读取互相干扰

1. 用户态消费用 libbpf 而非 shell：生产程序应直接调用 bpf_iter_create() + read() 以获得最佳性能和错误处理能力

1. 监控 iterator 的遍历延迟：通过 bpf_iter__timed 等机制监控单次全量遍历的耗时，超过阈值应告警

1. subscribe to kernel mailing list：BPF Iterators 仍在快速演进，新类型（如 iter/bpf_sk_storage、iter/timer）持续增加，关注上游动态才能保持技术领先

BPF Iterators 让我们第一次能够像遍历用户态链表一样优雅地遍历内核任意数据结构——不是通过不断 /proc//seq_read，而是在一个系统调用上下文中完成全量、流式、类型安全的迭代。当你的集群规模扩大到需要每秒全量扫描数万个进程、连接或文件描述符时，BPF Iterators 就是从"能用"到"好用"的关键跨越。

*本文内核代码参考 Linux 6.8.x 源码（kernel/bpf/iterators/），测试环境为 Ubuntu 24.04 + LLVM 17 + libbpf 1.4。*