第27周：eBPF Maps 与用户态交互

2026-06-14

字数统计: 2.6k字 | 阅读时长≈ 14分

第27周：eBPF Maps 与用户态交互

目标：深入掌握 BPF maps 的使用，实现用户态程序与内核 BPF 程序的高效数据交互。

1. BPF Maps 详解

1.1 Map 特性

BPF Map = 内核态共享数据结构

  关键特性：
  - BPF 程序读写（带验证）
  - 用户态程序通过文件描述符读写
  - 多种类型（hash、array、lru、ringbuf 等）
  - 支持 per-CPU 变体（避免锁）
  - 支持 BPF-to-BPF 引用（map of maps）

1.2 主要 Map 类型

┌─────────────────────┬────────────────────────────────┐
│ HASH                │ 通用 key-value（最常用）       │
│ ARRAY               │ 固定下标的数组                 │
│ PERCPU_ARRAY        │ 数组，每个 CPU 独立            │
│ PERCPU_HASH         │ hash，每个 CPU 独立            │
│ LRU_HASH            │ hash，自动淘汰最近最少使用    │
│ LPM_TRIE            │ 最长前缀匹配（路由）          │
│ STACK_TRACE         │ 栈跟踪                         │
│ RINGBUF             │ 环形缓冲（推荐，事件传递）    │
│ PERF_EVENT_ARRAY    │ 性能事件（旧式）              │
│ ARRAY_OF_MAPS       │ map 数组                       │
│ HASH_OF_MAPS        │ hash of maps                   │
│ DEVMAP              │ XDP 设备重定向                │
│ CPUMAP              │ XDP CPU 重定向                │
│ PROG_ARRAY          │ tail call 跳转                │
│ QUEUE/STACK         │ 队列/栈（用户态）             │
└─────────────────────┴────────────────────────────────┘

2. BPF 程序中 Map 的使用

2.1 通用 BPF Map 操作

// === 查找元素 ===
void *bpf_map_lookup_elem(void *map, const void *key);
// 返回 value 指针，未找到返回 NULL

// === 更新/插入元素 ===
int bpf_map_update_elem(void *map, const void *key,
                        const void *value, u64 flags);
// flags:
//   BPF_ANY     — 插入或更新
//   BPF_NOEXIST — 仅插入（存在则失败）
//   BPF_EXIST   — 仅更新（不存在则失败）

// === 删除元素 ===
int bpf_map_delete_elem(void *map, const void *key);
// 返回 0 成功，-ENOENT 不存在

// === 查找并删除（LRCU_HASH） ===
int bpf_map_delete_elem_flags(void *map, const void *key, u64 flags);
// flags = BPF_F_LOCK

2.2 各种 Map 示例

// === HASH MAP ===
struct {
    __uint(type, BPF_MAP_TYPE_HASH);
    __uint(max_entries, 1024);
    __type(key, u32);
    __type(value, u64);
} my_hash SEC(".maps");

SEC("xdp")
int xdp_use_hash(struct xdp_md *ctx) {
    u32 key = 1234;
    u64 *value = bpf_map_lookup_elem(&my_hash, &key);
    if (value) {
        // 命中
        (*value)++;
    } else {
        u64 init = 1;
        bpf_map_update_elem(&my_hash, &key, &init, BPF_ANY);
    }
    return XDP_PASS;
}

// === ARRAY MAP（固定大小）===
struct {
    __uint(type, BPF_MAP_TYPE_ARRAY);
    __uint(max_entries, 1);   // 数组大小
    __type(key, u32);          // 数组下标
    __type(value, struct data);
} my_array SEC(".maps");

SEC("xdp")
int xdp_use_array(struct xdp_md *ctx) {
    u32 key = 0;
    struct data *d = bpf_map_lookup_elem(&my_array, &key);
    if (d) {
        d->count++;
    }
    return XDP_PASS;
}

// === PERCPU_ARRAY（避免锁）===
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __uint(max_entries, 256);
    __type(key, u32);
    __type(value, u64);
} percpu_counters SEC(".maps");

SEC("xdp")
int xdp_percpu_count(struct xdp_md *ctx) {
    u32 key = bpf_get_smp_processor_id();
    u64 *count = bpf_map_lookup_elem(&percpu_counters, &key);
    if (count) (*count)++;
    return XDP_PASS;
}

// === LPM_TRIE（最长前缀匹配，路由）===
struct lpm_key {
    u32 prefixlen;    // 必须在 key 第一位！
    u32 addr;
};

struct {
    __uint(type, BPF_MAP_TYPE_LPM_TRIE);
    __uint(max_entries, 1024);
    __uint(key_size, sizeof(struct lpm_key));
    __uint(value_size, sizeof(u32));
} lpm_map SEC(".maps");

SEC("xdp")
int xdp_lpm(struct xdp_md *ctx) {
    struct lpm_key key = {
        .prefixlen = 32,
        .addr = 0x0A000001,  // 10.0.0.1
    };
    u32 *port = bpf_map_lookup_elem(&lpm_map, &key);
    if (port) {
        // 匹配
    }
    return XDP_PASS;
}

2.3 LRU Hash（自动淘汰）

// LRU_HASH：内存满时自动淘汰最近最少使用的元素
struct {
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
    __uint(max_entries, 65536);
    __type(key, struct flow_key);
    __type(value, struct flow_data);
} lru_flows SEC(".maps");

// 插入时：
bpf_map_update_elem(&lru_flows, &key, &value, BPF_ANY);
// 如果满了，BPF 自动删除最久未访问的

3. 用户态操作 Map

3.1 使用 bpftool

# === 查看所有 map ===
sudo bpftool map list

# === 查看 map 详情 ===
sudo bpftool map show id 10

# 输出：
# 10: hash  name my_hash  flags 0x1
#     key 4B  value 8B  max_entries 1024
#     memlock 8192B
#     pids test_prog(1234)

# === 读取所有条目 ===
sudo bpftool map dump id 10

# 输出：
# key: 01 00 00 00  value: e8 03 00 00 00 00 00 00
# key: 02 00 00 00  value: 2a 00 00 00 00 00 00 00

# === 查找单个 key ===
sudo bpftool map lookup id 10 key 0x1234 0x5678 0x9abc 0xdef0

# === 更新条目 ===
sudo bpftool map update id 10 key 0x1234 0x5678 0x9abc 0xdef0 value 0x1111 0x2222 0x3333 0x4444

# === 删除条目 ===
sudo bpftool map delete id 10 key 0x1234 0x5678 0x9abc 0xdef0

# === 删除所有条目 ===
sudo bpftool map clear id 10

# === 持有引用（避免释放）===
# 固定 map ID：
sudo bpftool map pin id 10 /sys/fs/bpf/my_map
# 之后：
sudo bpftool map lookup pinned /sys/fs/bpf/my_map key ...

3.2 使用 libbpf

// === 简单读取（libbpf API）===
#include <bpf/bpf.h>

int main(void) {
    int map_fd = bpf_obj_get("/sys/fs/bpf/my_map");

    // 查找
    u32 key = 1234;
    u64 value;
    if (bpf_map_lookup_elem(map_fd, &key, &value) == 0) {
        printf("Found: %lu\n", value);
    }

    // 遍历
    struct bpf_map_iter_opts opts = {0};
    // 或使用 bpf_map_get_next_key 循环
    u32 k, next_k;
    k = 0;
    while (bpf_map_get_next_key(map_fd, &k, &next_k) == 0) {
        u64 v;
        bpf_map_lookup_elem(map_fd, &next_k, &v);
        printf("Key: %u, Value: %lu\n", next_k, v);
        k = next_k;
    }

    // 更新
    u64 new_value = 100;
    bpf_map_update_elem(map_fd, &key, &new_value, BPF_ANY);

    // 删除
    bpf_map_delete_elem(map_fd, &key);

    close(map_fd);
    return 0;
}

3.3 使用 Skeleton（推荐）

// 自动生成的 skeleton（bpftool gen skeleton）
// my_prog.skel.h

// 头文件中的主要 API：

// 1. 打开/加载
struct my_prog *skel = my_prog__open();
my_prog__load(skel);

// 2. 附加
my_prog__attach(skel);

// 3. 访问 BPF 对象
struct bpf_map *map = skel->maps.my_hash;
int fd = bpf_map__fd(map);

// 4. 查找/更新
u32 key = 1;
u64 value = 100;
bpf_map__lookup_elem(map, &key, sizeof(key), &value, sizeof(value), 0);
bpf_map__update_elem(map, &key, sizeof(key), &value, sizeof(value), BPF_ANY);

// 5. 销毁
my_prog__destroy(skel);

4. Per-CPU Map 性能

4.1 为什么用 Per-CPU？

普通 hash map 的并发问题：

  CPU 0 ──┐
          │  共享锁
  CPU 1 ──┘  hash 修改时锁整个表
  
  → 高并发下性能差

Per-CPU hash map：

  CPU 0 ── 本地 hash（无锁）
  CPU 1 ── 本地 hash（无锁）
  CPU 2 ── 本地 hash（无锁）

  写入：每个 CPU 独立，无锁
  读取：用户态汇总各 CPU 值

4.2 Per-CPU 计数

// BPF 端：每个 CPU 独立计数
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __uint(max_entries, 1);
    __type(key, u32);
    __type(value, u64);
} pkt_count SEC(".maps");

SEC("xdp")
int xdp_count(struct xdp_md *ctx) {
    u32 key = 0;
    u64 *count = bpf_map_lookup_elem(&pkt_count, &key);
    if (count) (*count)++;
    return XDP_PASS;
}

// 用户态：汇总所有 CPU 的值
void read_percpu_count(struct bpf_map *map) {
    int ncpu = libbpf_num_possible_cpus();
    u64 values[ncpu];
    u32 key = 0;

    if (bpf_map__lookup_elem(map, &key, sizeof(key),
                              values, sizeof(values), 0) == 0) {
        u64 total = 0;
        for (int i = 0; i < ncpu; i++) {
            total += values[i];
            printf("CPU %d: %lu\n", i, values[i]);
        }
        printf("Total: %lu\n", total);
    }
}

5. Ring Buffer（推荐的事件传递机制）

5.1 Ring Buffer vs Perf Event

Perf Event Array（旧）：
  - 每个 CPU 独立 buffer
  - 用户态需要 poll 多个 fd
  - 难以保证顺序
  - 默认大小 8KB/page

Ring Buffer（新，5.8+）：
  - 共享环形 buffer
  - 单一 fd，简化用户态
  - 保证消息顺序
  - 更大的 size，零拷贝支持

5.2 Ring Buffer 使用

// === BPF 端 ===
struct {
    __uint(type, BPF_MAP_TYPE_RINGBUF);
    __uint(max_entries, 256 * 1024);  // 256KB
} events SEC(".maps");

struct event {
    u32 pid;
    u64 latency_ns;
    char comm[16];
};

SEC("xdp")
int xdp_event(struct xdp_md *ctx) {
    struct event *e;

    // 预留空间（reserve 模式，无 memcpy）
    e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
    if (!e) return XDP_PASS;  // 缓冲区满

    // 填充数据
    e->pid = bpf_get_current_pid_tgid() >> 32;
    e->latency_ns = bpf_ktime_get_ns();
    bpf_get_current_comm(e->comm, sizeof(e->comm));

    // 提交（用户态可见）
    bpf_ringbuf_submit(e, 0);

    return XDP_PASS;
}

// === 用户态 ===
#include <bpf/ringbuf.h>

struct event {
    u32 pid;
    u64 latency_ns;
    char comm[16];
};

// 事件回调
static int handle_event(void *ctx, void *data, size_t data_sz) {
    const struct event *e = data;
    printf("pid=%d latency=%lu comm=%s\n",
           e->pid, e->latency_ns, e->comm);
    return 0;
}

int main(void) {
    struct my_prog *skel = my_prog__open_and_load();
    my_prog__attach(skel);

    // 创建 ring buffer
    struct ring_buffer *rb = ring_buffer__new(
        bpf_map__fd(skel->maps.events),
        handle_event, NULL, NULL);

    // 轮询
    while (1) {
        ring_buffer__poll(rb, 1000);  // 超时 1 秒
    }

    return 0;
}

6. 实践：基于 XDP 的包计数器

6.1 BPF 程序

// xdp_counter.bpf.c
#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <bpf/bpf_helpers.h>
#include <bpf/bpf_endian.h>

// 按 IP 统计包数
struct {
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
    __uint(max_entries, 10240);
    __type(key, u32);   // 源 IP
    __type(value, u64); // 包数
} ip_count SEC(".maps");

// 总统计
struct {
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
    __uint(max_entries, 1);
    __type(key, u32);
    __type(value, struct {
        u64 total;
        u64 ipv4;
        u64 ipv6;
        u64 dropped;
    });
} global_stats SEC(".maps");

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

    // 边界检查
    struct ethhdr *eth = data;
    if ((void *)(eth + 1) > data_end)
        return XDP_PASS;

    // 总统计
    u32 key = 0;
    struct {
        u64 total, ipv4, ipv6, dropped;
    } *stats = bpf_map_lookup_elem(&global_stats, &key);
    if (stats) stats->total++;

    // 只统计 IPv4
    if (eth->h_proto != bpf_htons(ETH_P_IP)) {
        if (eth->h_proto == bpf_htons(ETH_P_IPV6)) {
            if (stats) stats->ipv6++;
        }
        return XDP_PASS;
    }

    if (stats) stats->ipv4++;

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

    // 按源 IP 计数
    u32 src_ip = ip->saddr;
    u64 *count = bpf_map_lookup_elem(&ip_count, &src_ip);
    if (count) {
        (*count)++;
    } else {
        u64 init = 1;
        bpf_map_update_elem(&ip_count, &src_ip, &init, BPF_ANY);
    }

    return XDP_PASS;
}

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

6.2 用户态加载器

// xdp_counter.c
#include <stdio.h>
#include <signal.h>
#include <bpf/bpf.h>
#include <bpf/libbpf.h>
#include <net/if.h>
#include <arpa/inet.h>
#include "xdp_counter.skel.h"

static volatile bool exiting = false;
static void sig_handler(int sig) { (void)sig; exiting = true; }

// 打印全局统计
static int print_stats(struct xdp_counter_bpf *skel) {
    int ncpu = libbpf_num_possible_cpus();
    struct {
        u64 total, ipv4, ipv6, dropped;
    } values[ncpu];
    u32 key = 0;

    if (bpf_map__lookup_elem(skel->maps.global_stats, &key, sizeof(key),
                              values, sizeof(values), 0) != 0) {
        return -1;
    }

    u64 total = 0, ipv4 = 0, ipv6 = 0;
    for (int i = 0; i < ncpu; i++) {
        total += values[i].total;
        ipv4 += values[i].ipv4;
        ipv6 += values[i].ipv6;
    }

    printf("Total: %lu, IPv4: %lu, IPv6: %lu\n", total, ipv4, ipv6);
    return 0;
}

// 打印 TOP IP
static int print_top_ips(struct xdp_counter_bpf *skel, int n) {
    struct top_entry {
        u32 ip;
        u64 count;
    } top[20] = {0};

    // 遍历 map
    u32 key, next_key;
    u64 value;
    int i = 0;

    key = 0;
    while (bpf_map__get_next_key(skel->maps.ip_count, &key, sizeof(key),
                                  &next_key, sizeof(next_key), 0) == 0) {
        bpf_map__lookup_elem(skel->maps.ip_count, &next_key, sizeof(next_key),
                              &value, sizeof(value), 0);
        // 排序/输出
        if (i < 20) {
            top[i].ip = next_key;
            top[i].count = value;
            i++;
        }
        key = next_key;
    }

    printf("\nTop IPs:\n");
    for (int j = 0; j < i; j++) {
        struct in_addr addr = { .s_addr = top[j].ip };
        printf("  %s: %lu\n", inet_ntoa(addr), top[j].count);
    }
    return 0;
}

int main(int argc, char **argv) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <ifname>\n", argv[0]);
        return 1;
    }

    signal(SIGINT, sig_handler);
    signal(SIGTERM, sig_handler);

    // 打开 BPF 程序
    struct xdp_counter_bpf *skel = xdp_counter_bpf__open();
    if (!skel) { fprintf(stderr, "Failed to open\n"); return 1; }

    // 加载
    if (xdp_counter_bpf__load(skel)) {
        fprintf(stderr, "Failed to load\n");
        xdp_counter_bpf__destroy(skel);
        return 1;
    }

    // 附加到接口
    int ifindex = if_nametoindex(argv[1]);
    if (xdp_counter_bpf__attach(skel) < 0) {
        fprintf(stderr, "Failed to attach\n");
        return 1;
    }

    // 加载 XDP 到接口
    int prog_fd = bpf_program__fd(skel->progs.xdp_count_packets);
    if (bpf_xdp_attach(ifindex, prog_fd, XDP_FLAGS_SKB_MODE, NULL) < 0) {
        fprintf(stderr, "Failed to attach XDP\n");
        return 1;
    }

    // 主循环：每 5 秒打印一次统计
    while (!exiting) {
        sleep(5);
        print_stats(skel);
        print_top_ips(skel, 10);
    }

    // 清理
    bpf_xdp_detach(ifindex, XDP_FLAGS_SKB_MODE, NULL);
    xdp_counter_bpf__destroy(skel);
    return 0;
}

6.3 编译与运行

# 1. 编译 BPF 程序
clang -O2 -g -target bpf \
    -D__TARGET_ARCH_x86 \
    -I/usr/include/x86_64-linux-gnu \
    -c xdp_counter.bpf.c \
    -o xdp_counter.bpf.o

# 2. 生成 skeleton
bpftool gen skeleton xdp_counter.bpf.o > xdp_counter.skel.h

# 3. 编译用户态
gcc -O2 -o xdp_counter xdp_counter.c -lbpf -lelf -lz

# 4. 运行
sudo ./xdp_counter eth0

# 5. 卸载
sudo ip link set dev eth0 xdp off

7. Map 调试技巧

# 实时查看 map 变化
watch -n 1 'sudo bpftool map dump id 10 | head -20'

# 打印程序统计（map 大小、利用率）
sudo bpftool map show id 10
# 10: hash  name my_hash  flags 0x1
#     key 4B  value 8B  max_entries 1024
#     memlock 8192B

# 性能分析：map 命中率
# 测量 BPF 程序延迟
sudo bpftool prog profile id 42 duration 5

# 运行时修改 map
sudo bpftool map update id 10 key 0x1234 value 0x5678

# 删除条目
sudo bpftool map delete id 10 key 0x1234

8. 关键 API 速查

函数	用途
`bpf_map_lookup_elem()`	查找元素
`bpf_map_update_elem()`	更新/插入元素
`bpf_map_delete_elem()`	删除元素
`bpf_map_get_next_key()`	遍历元素
`bpf_lookup_u32_elem()`	32 位 key 快速查找
`bpf_ringbuf_reserve()`	RingBuf 预留空间
`bpf_ringbuf_submit()`	RingBuf 提交
`bpf_ringbuf_discard()`	RingBuf 丢弃
`bpf_perf_event_output()`	Perf Event 发送
`bpf_redirect_map()`	重定向到 DEVMAP/CPUMAP
`bpf_redirect()`	重定向到接口
`bpf_xdp_adjust_head()`	调整 XDP 头部
`bpf_xdp_adjust_tail()`	调整 XDP 尾部

本文作者： CoderSong
本文链接： https://jack-song-gif.github.io/2026/06/14/第27周：eBPF Maps 与用户态交互/
版权声明： 本博客所有文章除特别声明外，均采用 MIT 许可协议。转载请注明出处！