1
Hash Map 内存 ≈ max_entries × (key_size + value_size + sizeof(struct htab_elem))
2
Array Map 内存 ≈ max_entries × value_size
3
Per-CPU Map 内存 ≈ CPU 数 × max_entries × value_size
4
Ring Buffer 内存 = max_entries（由用户指定）

1
// 优化 1：使用 BPF_F_NO_PREALLOC 避免预分配
2
struct {
3
    __uint(type, BPF_MAP_TYPE_HASH);
4
    __uint(max_entries, 1000000);
5
    __uint(map_flags, BPF_F_NO_PREALLOC);  // 按需分配
6
    __type(key, u32);
7
    __type(value, struct event);
8
} large_map SEC(".maps");
9

10
// 优化 2：使用 LRU 替代无限增长
11
struct {
12
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
13
    __uint(max_entries, 100000);  // 自动淘汰
14
    __type(key, struct conn_key);
15
    __type(value, struct conn_value);
16
} conn_track SEC(".maps");
17

18
// 优化 3：减小 value 大小
19
// 浪费空间
20
struct big_value {
21
    char filename[256];  // 大部分时候用不到 256 字节
22
    u64 timestamp;
23
};
24

25
//  紧凑存储
26
struct compact_value {
27
    char filename[64];   // 按需截断
28
    u64 timestamp;
29
};

1
// 栈溢出：两个数组就超过 512 字节
2
SEC("kprobe/do_sys_open")
3
int trace_open(struct pt_regs *ctx)
4
{
5
    char filename[256];  // 256 字节
6
    char comm[256];      // 256 字节 → 合计 512 字节，加上其他局部变量必溢出
7
    // 验证器报错：combined stack size of 4 calls is 528. Too large
8
}

1
// 使用尾调用拆分逻辑，每个子程序独立使用 512 字节栈
2
struct {
3
    __uint(type, BPF_MAP_TYPE_PROG_ARRAY);
4
    __uint(max_entries, 4);
5
    __type(key, u32);
6
    __type(value, u32);
7
} prog_array SEC(".maps");
8

9
// 阶段 1：解析数据包头
10
SEC("xdp")
11
int xdp_parse(struct xdp_md *ctx)
12
{
13
    // 只做解析，栈占用少
14
    struct hdr_info info = parse_header(ctx);
15

16
    // 尾调用到阶段 2，当前栈帧被替换
17
    bpf_tail_call(ctx, &prog_array, 1);
18
    return XDP_PASS;
19
}
20

21
// 阶段 2：执行过滤逻辑（独立 512 字节栈）
22
SEC("xdp")
23
int xdp_filter(struct xdp_md *ctx)
24
{
25
    // 可以使用新的 512 字节栈空间
26
    char payload[256];
27
    // ...
28
    return XDP_DROP;
29
}

1
// 用 Per-CPU Array 作为 scratch 空间
2
struct scratch_space {
3
    char buf[256];
4
    u32 len;
5
    u32 flags;
6
};
7

8
struct {
9
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
10
    __uint(max_entries, 1);
11
    __type(key, u32);
12
    __type(value, struct scratch_space);
13
} scratch SEC(".maps");
14

15
SEC("kprobe/do_sys_open")
16
int trace_open(struct pt_regs *ctx)
17
{
18
    u32 key = 0;
19
    struct scratch_space *sp = bpf_map_lookup_elem(&scratch, &key);
20
    if (!sp) return 0;
21

22
    // 使用 sp->buf 代替栈上的局部数组
23
    bpf_probe_read_user_str(sp->buf, sizeof(sp->buf), (void *)PT_REGS_PARM2(ctx));
24
    sp->len = __builtin_strlen(sp->buf);
25
    // ...
26
    return 0;
27
}

1
# Cilium DaemonSet：独立 Pod 运行 eBPF
2
apiVersion: apps/v1
3
kind: DaemonSet
4
metadata:
5
  name: cilium
6
spec:
7
  template:
8
    spec:
9
      containers:
10
      - name: cilium-agent
11
        resources:
12
          requests:
13
            memory: "512Mi"
14
          limits:
15
            memory: "1Gi"  # 预留 eBPF 内存

1
#include "vmlinux.h"
2
#include <bpf/bpf_helpers.h>
3

4
struct alloc_event {
5
    u32 pid;
6
    u64 size;
7
    u64 addr;
8
    char comm[16];
9
};
10

11
struct {
12
    __uint(type, BPF_MAP_TYPE_RINGBUF);
13
    __uint(max_entries, 256 * 1024);
14
} events SEC(".maps");
15

16
// 追踪 kmalloc
17
SEC("kprobe/kmalloc")
18
int trace_kmalloc(struct pt_regs *ctx)
19
{
20
    struct alloc_event *e;
21

22
    e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
23
    if (!e) return 0;
24

25
    e->pid = bpf_get_current_pid_tgid() >> 32;
26
    e->size = PT_REGS_PARM1(ctx);  // size 参数
27
    bpf_get_current_comm(&e->comm, sizeof(e->comm));
28

29
    bpf_ringbuf_submit(e, 0);
30
    return 0;
31
}
32

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

1
# 使用 bpftrace 追踪容器内存分配
2
sudo bpftrace -e '
3
kprobe:kmalloc /pid == $TARGET_PID/ {
4
    @alloc_size[comm] = hist(arg1);
5
}'
6

7
# 追踪页面分配
8
sudo bpftrace -e '
9
kprobe:alloc_pages {
10
    @alloc[comm] = count();
11
}'
12

13
# 追踪 cgroup 内存事件
14
sudo bpftrace -e '
15
kprobe:mem_cgroup_charge {
16
    printf("cgroup charge: %d bytes\n", arg1);
17
}'

1
// 在 Map value 中存储内核指针
2
struct value_with_kptr {
3
    int data;
4
    struct task_struct __kptr *task;  // 内核指针
5
};
6

7
struct {
8
    __uint(type, BPF_MAP_TYPE_HASH);
9
    __uint(max_entries, 1024);
10
    __type(key, u32);
11
    __type(value, struct value_with_kptr);
12
} kptr_map SEC(".maps");

1
// 定义 arena（内核 6.9+）
2
struct {
3
    __uint(type, BPF_MAP_TYPE_ARENA);
4
    __uint(map_flags, BPF_F_MMAPABLE);
5
    __uint(max_entries, 4096);  // 4096 页 = 16 MB
6
    __uint(value_size, 4096);   // 页大小
7
} arena SEC(".maps");
8

9
// 在 eBPF 程序中通过指针访问 arena
10
SEC("kprobe/do_sys_open")
11
int trace_open(struct pt_regs *ctx)
12
{
13
    // arena 中的数据可跨程序共享
14
    int *counter = (int *)arena + 0;  // arena 基址偏移
15
    __sync_fetch_and_add(counter, 1);
16
    return 0;
17
}

1
struct timer_value {
2
    struct bpf_timer timer;
3
    u32 callback_count;
4
};
5

6
struct {
7
    __uint(type, BPF_MAP_TYPE_HASH);
8
    __uint(max_entries, 100);
9
    __type(key, u32);
10
    __type(value, struct timer_value);
11
} timer_map SEC(".maps);
12

13
// 定时器回调：定期清理过期条目
14
static int timer_callback(void *map, u32 *key, struct timer_value *val)
15
{
16
    val->callback_count++;
17
    // 执行清理逻辑...
18

19
    // 重新设置定时器（周期执行）
20
    bpf_timer_start(&val->timer, timer_callback, 1000000000ULL);  // 1 秒
21
    return 0;
22
}
23

24
SEC("tc")
25
int setup_timer(struct __sk_buff *ctx)
26
{
27
    u32 key = 1;
28
    struct timer_value *val = bpf_map_lookup_elem(&timer_map, &key);
29
    if (val && val->callback_count == 0) {
30
        bpf_timer_init(&val->timer, &timer_map, CLOCK_MONOTONIC);
31
        bpf_timer_start(&val->timer, timer_callback, 1000000000ULL);
32
    }
33
    return TC_ACT_OK;
34
}

1
// bpf_mem_cache 使用示例（内核 6.x+）
2
// 在定时器回调或尾调用中分配临时内存
3
struct {
4
    __uint(type, BPF_MAP_TYPE_HASH);
5
    __uint(max_entries, 1024);
6
    __type(key, u32);
7
    __type(value, struct bpf_mem_cache_ptr);
8
} mem_cache SEC(".maps");

1
# 查看当前 RLIMIT_MEMLOCK
2
ulimit -l
3
# 64  ← 单位 KB，即 64KB（默认值太小）
4

5
# 临时调大（开发环境常用）
6
ulimit -l unlimited
7

8
# 永久设置（/etc/security/limits.conf）
9
# *  hard  memlock  unlimited
10
# *  soft  memlock  unlimited

1
// libbpf 自动处理 RLIMIT_MEMLOCK → cgroup 的迁移
2
// 用户态代码无需修改，libbpf 1.0+ 会自动尝试 cgroup 计费
3

4
// 手动控制（高级场景）
5
struct bpf_object_open_opts opts = {
6
    .sz = sizeof(opts),
7
    // libbpf 1.0+ 默认使用 cgroup 计费
8
    // 如需回退到 RLIMIT_MEMLOCK，设置：
9
    // .btf_custom_path = NULL,
10
};

1
# 检查内核是否支持 cgroup eBPF 计费
2
cat /proc/config.gz | gunzip | grep CONFIG_MEMCG_KMEM
3
# CONFIG_MEMCG_KMEM=y  ← 需要开启
4

5
# 查看 cgroup 中的 eBPF 内存
6
cat /sys/fs/cgroup/memory.stat | grep -i bpf

1
# 查看所有 Map 的内存使用
2
sudo bpftool map show
3

4
# 查看特定 Map 的统计
5
sudo bpftool map show id 123
6

7
# 查看系统 eBPF 内存总量
8
cat /proc/meminfo | grep -i bpf
9

10
# 使用 bpftrace 追踪 Map 操作
11
sudo bpftrace -e '
12
kprobe:bpf_map_update_elem {
13
    @map_ops[comm] = count();
14
}'
15

16
# 追踪内存分配延迟
17
sudo bpftrace -e '
18
kprobe:kmalloc /pid == $TARGET/ {
19
    @ts[tid] = nsecs;
20
}
21
kretprobe:kmalloc /@ts[tid]/ {
22
    @latency = hist(nsecs - @ts[tid]);
23
    delete(@ts[tid]);
24
}'
25

26
# 追踪 slab 分配器行为
27
sudo bpftrace -e '
28
kprobe:kmem_cache_alloc {
29
    @slab[comm, arg0] = count();
30
}'

1
# 第 1 步：查看 OOM 事件
2
dmesg | grep -i oom
3
# Out of memory: Killed process 12345 (agent) total-vm:800MB, anon-rss:500MB
4

5
# 第 2 步：检查 eBPF Map 内存
6
sudo bpftool map show
7
# 发现：一个 HASH Map 占用 200MB（max_entries=1000000, value_size=200）
8

9
# 第 3 步：确认 eBPF 内存计入容器 cgroup
10
cat /sys/fs/cgroup/memory/kubepods/burstable/pod<id>/memory.usage_in_bytes
11
# 536870912  ← 512MB，已到限额
12

13
# 第 4 步：查看 Map 实际使用率
14
sudo bpftool map dump id 123 | wc -l
15
# 实际只有 50000 条目，但预分配了 1000000 的空间

1
// 修复前：过度预分配
2
struct {
3
    __uint(type, BPF_MAP_TYPE_HASH);
4
    __uint(max_entries, 1000000);  // 预分配 ~200MB
5
    __type(key, struct conn_key);
6
    __type(value, struct conn_value);
7
} conn_track SEC(".maps");
8

9
// 修复后：使用 LRU + 合理容量
10
struct {
11
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
12
    __uint(max_entries, 100000);   // 预分配 ~20MB，自动淘汰
13
    __type(key, struct conn_key);
14
    __type(value, struct conn_value);
15
} conn_track SEC(".maps");

1
# 创建不同大小的 Map 并观察内存
2
sudo bpftool map create /sys/fs/bpf/test_hash \
3
    type hash key 4 value 64 entries 100000
4

5
# 查看 Map 内存
6
sudo bpftool map show pinned /sys/fs/bpf/test_hash
7
# 输出包含：bytes_used
8

9
# 清理
10
sudo rm /sys/fs/bpf/test_hash

1
# 使用 bpftrace 追踪 kmalloc 大小分布
2
sudo bpftrace -e '
3
kprobe:kmalloc {
4
    @size[comm] = hist(arg0);
5
}
6
interval:s:10 {
7
    print(@size);
8
    clear(@size);
9
}'

1
# 查看 cgroup 内存使用
2
cat /sys/fs/cgroup/memory/docker/<container_id>/memory.usage_in_bytes
3

4
# 查看 eBPF 程序内存
5
sudo bpftool prog show
6

7
# 查看 Map 内存
8
sudo bpftool map show