1
# 方法1：使用 bpftool 查看 eBPF 程序运行时间
2
bpftool prog show --json | jq '.[] | {name: .name, run_time_ns: .run_time_ns, run_cnt: .run_cnt}'
3

4
# 方法2：使用 perf 追踪 eBPF 事件
5
sudo perf stat -e bpf:* -a sleep 10
6

7
# 方法3：在 eBPF 程序中手动计时
8
# C 代码中：
9
bpf_trace_printk("start\\n");
10
// ... 处理逻辑 ...
11
bpf_trace_printk("end\\n");
12

13
# 方法4：使用 bpftrace 测量
14
sudo bpftrace -e '
15
kprobe:do_sys_open { @start[tid] = nsecs; }
16
kretprobe:do_sys_open /@start[tid]/ {
17
    @latency = hist(nsecs - @start[tid]);
18
    delete(@start[tid]);
19
}'

1
// 低效：每次都查 Map
2
SEC("kprobe/do_sys_open")
3
int trace_open(struct pt_regs *ctx) {
4
    u32 key = 0;
5
    struct data *val = bpf_map_lookup_elem(&config, &key);
6
    if (!val) return 0;
7
    // 每次调用都查 Map
8
}
9

10
// 优化：使用 per-CPU Map 减少锁竞争
11
struct {
12
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
13
    __uint(max_entries, 1);
14
    __type(key, u32);
15
    __type(value, struct config);
16
} config SEC(".maps");
17

18
// 优化：使用尾调用拆分复杂逻辑
19
struct {
20
    __uint(type, BPF_MAP_TYPE_PROG_ARRAY);
21
    __uint(max_entries, 4);
22
    __type(key, u32);
23
    __type(value, u32);
24
} prog_array SEC(".maps");
25

26
SEC("xdp")
27
int xdp_main(struct xdp_md *ctx) {
28
    // 快速路径：简单判断后尾调用
29
    bpf_tail_call(ctx, &prog_array, 1);
30
    return XDP_PASS;
31
}

1
SEC("kprobe/do_sys_open")
2
int trace_open(struct pt_regs *ctx) {
3
    // 输出调试信息到 /sys/kernel/debug/tracing/trace_pipe
4
    bpf_trace_printk("open called, fd=%d\\n", PT_REGS_RC(ctx));
5
    return 0;
6
}

1
# 查看调试输出
2
sudo cat /sys/kernel/debug/tracing/trace_pipe

1
# 查看 eBPF 程序列表
2
sudo bpftool prog list
3

4
# 查看程序详细信息（包括字节码）
5
sudo bpftool prog dump xlated id <ID>
6

7
# 查看 JIT 编译后的机器码
8
sudo bpftool prog dump jited id <ID>
9

10
# 查看 Map 内容
11
sudo bpftool map dump id <ID>
12

13
# 查看 Map 详细信息
14
sudo bpftool map show id <ID>
15

16
# 查看 attach 的链接
17
sudo bpftool link list

1
# 追踪特定函数的调用频率
2
sudo bpftrace -e 'kprobe:do_sys_open { @opens = count(); }'
3

4
# 追踪调用栈
5
sudo bpftrace -e 'kprobe:do_sys_open { printf("%s\\n", kstack); }'
6

7
# 追踪 Map 操作
8
sudo bpftrace -e '
9
uprobe:/path/to/binary:bpf_map_lookup_elem {
10
    printf("map_lookup: map_fd=%d\\n", arg1);
11
}'
12

13
# 追踪 eBPF 程序执行时间
14
sudo bpftrace -e '
15
kprobe:your_bpf_func { @start[tid] = nsecs; }
16
kretprobe:your_bpf_func /@start[tid]/ {
17
    @ns[comm] = hist(nsecs - @start[tid]);
18
    delete(@start[tid]);
19
}'

1
// CO-RE 兼容的结构体访问
2
struct task_struct___old {
3
    int pid;
4
} __attribute__((preserve_access_index));
5

6
struct task_struct___new {
7
    int tgid;
8
    int pid;
9
} __attribute__((preserve_access_index));
10

11
// 使用 CO-RE 重定位读取进程 PID
12
SEC("kprobe/do_sys_open")
13
int trace_open(struct pt_regs *ctx)
14
{
15
    // CO-RE 会自动处理字段偏移差异
16
    struct task_struct *task = (void *)bpf_get_current_task();
17
    u32 pid = BPF_CORE_READ(task, tgid);
18
    return 0;
19
}

1
// 策略1：运行时特性检测
2
if (bpf_program__set_autoload(prog, false) != 0) {
3
    // 内核不支持此程序，跳过加载
4
    fprintf(stderr, "Skipping program: not supported by kernel\n");
5
}
6

7
// 策略2：条件编译
8
#ifdef __TARGET_ARCH_x86
9
    // x86 特定逻辑
10
#else
11
    // 通用逻辑
12
#endif
13

14
// 策略3：优雅降级
15
// 尝试加载高版本功能，失败则回退到低版本替代
16
struct bpf_program *prog = bpf_object__find_program_by_name(obj, "xdp_advanced");
17
if (!prog || bpf_program__fd(prog) < 0) {
18
    // 回退到基础版本
19
    prog = bpf_object__find_program_by_name(obj, "xdp_basic");
20
}

1
# 检查内核版本
2
uname -r
3

4
# 检查 BTF 支持
5
ls /sys/kernel/btf/vmlinux && echo "BTF: supported" || echo "BTF: not supported"
6

7
# 检查 eBPF 特性
8
bpftool feature probe
9

10
# 检查特定功能
11
bpftool feature probe kernel | grep "bpf_kptr"
12
bpftool feature probe kernel | grep "bpf_timer"
13

14
# 检查可用的 attach 类型
15
bpftool feature probe | grep "program_type"

1
# Kubernetes 灰度发布示例
2
apiVersion: v1
3
kind: ConfigMap
4
metadata:
5
  name: ebpf-canary-config
6
data:
7
  # 控制哪些节点加载 eBPF 程序
8
  target_nodes: "canary-pool"
9
  # XDP 程序配置
10
  xdp_mode: "native"  # native / skb / hw
11
  # 是否启用高级功能
12
  enable_lsm: "false"  # 5.10+ 才启用
13
  # 采样率（0-100）
14
  sample_rate: "10"  # 只处理 10% 流量

1
// eBPF 程序自监控：统计异常事件
2
struct {
3
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
4
    __uint(max_entries, 4);
5
    __type(key, u32);
6
    __type(value, u64);
7
} stats SEC(".maps");
8

9
enum stat_type {
10
    STAT_TOTAL = 0,
11
    STAT_ERROR = 1,
12
    STAT_DROP  = 2,
13
    STAT_PASS  = 3,
14
};
15

16
SEC("xdp")
17
int xdp_main(struct xdp_md *ctx)
18
{
19
    u32 key = STAT_TOTAL;
20
    u64 *val = bpf_map_lookup_elem(&stats, &key);
21
    if (val) __sync_fetch_and_add(val, 1);
22

23
    // ... 处理逻辑 ...
24

25
    return XDP_PASS;
26
}

1
# 增加 eBPF 相关资源限制
2

3
# 锁定内存（eBPF Map 需要锁定内存）
4
ulimit -l unlimited
5

6
# 增加文件描述符限制（每个 eBPF 程序和 Map 都需要 fd）
7
ulimit -n 65535
8

9
# 内核参数调优
10
sysctl -w kernel.bpf.max_prog_cnt=1024
11
sysctl -w kernel.bpf.max_map_cnt=1024

1
# 限制 eBPF 权限（仅允许特定用户组）
2
groupadd bpf-users
3
usermod -aG bpf-users cilium
4

5
# 设置 eBPF 设备权限
6
chmod 0660 /dev/bpf
7
chown root:bpf-users /dev/bpf
8

9
# 使用 Linux Capabilities 代替 root
10
setcap cap_bpf+ep /usr/bin/cilium
11
setcap cap_net_admin+ep /usr/bin/cilium
12
setcap cap_perfmon+ep /usr/bin/cilium