1传统内核模块 vs eBPF程序
 2┌─────────────────────┬─────────────────────┐
 3│   传统内核模块         │     eBPF程序         │
 4├─────────────────────┼─────────────────────┤
 5│ 直接访问内核内存       │ 沙盒化执行环境        │
 6│ 需要重新编译内核       │ 动态加载和更新        │
 7│ 崩溃可能导致系统宕机    │ 程序崩溃不影响内核    │
 8│ 无移植性              │ 跨内核版本可移植      │
 9│ 开发调试困难          │ 丰富的调试工具        │
10└─────────────────────┴─────────────────────┘

11993年 - BPF诞生
2├── 发明者：Steven McCanne和Van Jacobson (伯克利实验室)
3├── 设计目的：高效的包过滤机制
4├── 初始应用：用户级包捕获 (tcpdump, libpcap)
5└── 技术特点：简单的字节码虚拟机

 12014年12月 - Linux 3.18
 2├── eBPF正式诞生 (2014年9月26日为官方生日)
 3├── 引入bpf()系统调用
 4├── 实现验证器和Maps概念
 5└── 扩展到网络之外的应用场景
 6
 72015年 - 系统追踪革命
 8├── kprobes集成
 9├── 开启Linux系统追踪新纪元
10└── 可观测性应用爆发
11
12Linux 4.8 (2016年)
13├── XDP (eXpress Data Path)引入
14├── 实现极高性能包处理 (~10-20M pps)
15└── 开启高性能网络时代
16
17Linux 4.18 (2018年)
18├── BTF (BPF Type Format)引入
19├── 提供丰富的类型信息
20└── 为CO-RE技术奠定基础
21
222020年 - 安全领域突破
23├── LSM BPF支持
24├── 建立安全工具平台
25└── 细粒度安全控制成为可能
26
272022年 - 现代eBPF
28├── Linux 5.16-6.1版本
29├── 程序指令限制：4,096条 → 100万条
30└── 300+名内核开发者贡献
31
322024年10月 - 标准化里程碑
33├── IETF RFC 9669发布
34├── BPF指令集架构规范
35└── 行业标准正式确立

 1## XDP (eXpress Data Path)
 2# 在网络驱动层处理数据包，提供最高性能
 3BPF_PROG_TYPE_XDP
 4- 用途：DDoS防护、负载均衡、包过滤
 5- 性能：~10-20M pps（百万包每秒）
 6
 7## TC (Traffic Control) 
 8# 在Linux流量控制层工作
 9BPF_PROG_TYPE_SCHED_CLS  # 分类器
10BPF_PROG_TYPE_SCHED_ACT  # 动作器
11- 用途：流量整形、QoS控制、包修改
12
13## Socket相关
14BPF_PROG_TYPE_SOCKET_FILTER  # socket过滤器
15BPF_PROG_TYPE_SOCK_OPS       # socket操作
16BPF_PROG_TYPE_SK_SKB         # socket buffer处理

 1## Kprobe/Kretprobe - 内核函数跟踪
 2BPF_PROG_TYPE_KPROBE
 3- 动态插桩任意内核函数
 4- 获取函数参数和返回值
 5
 6## Uprobe/Uretprobe - 用户空间函数跟踪  
 7BPF_PROG_TYPE_UPROBE
 8- 跟踪用户态函数调用
 9- 性能分析和调试
10
11## Tracepoint - 静态跟踪点
12BPF_PROG_TYPE_TRACEPOINT
13- 使用内核预定义的跟踪点
14- 稳定的ABI，升级兼容性好
15
16## perf_event - 性能事件
17BPF_PROG_TYPE_PERF_EVENT
18- CPU性能计数器
19- 硬件/软件事件统计

1# 以CentOS为例
2yum install bpftrace

 1# 实时监控系统调用
 2[root@dev ~]# bpftrace -e 'tracepoint:syscalls:sys_enter_openat { printf("%s %s\n", comm, str(args->filename)); }'
 3### 输出 
 4Attaching 1 probe...
 5mandb /usr/share/man/man3/pcre_jit_stack_alloc.3.gz
 6mandb /usr/share/man/man3/pcre_jit_stack_alloc.3.gz
 7mandb /usr/share/man/man3/pcre_compile.3.gz
 8mandb /usr/share/man/man3/pcre_compile.3.gz
 9mandb /usr/share/man/man3/pcre_compile2.3.gz
10mandb /usr/share/man/man3/pcre_compile2.3.gz
11mandb /usr/share/man/man3/pcre_jit_stack_free.3.gz
12mandb /usr/share/man/man3/pcre_jit_stack_free.3.gz
13mandb /usr/share/man/man3/pcre_maketables.3.gz
14mandb /usr/share/man/man3/pcre_maketables.3.gz
15mandb /usr/share/man/man3/pcre_pattern_to_host_byte_order.3.gz
16argusagent /proc/uptime
17argusagent /proc/loadavg
18
19# 统计进程CPU使用时间
20[root@dev ~]# bpftrace -e 'profile:hz:99 { @[comm] = count(); }'
21# 输出
22Attaching 1 probe...
23^C
24
25@[kworker/u4:2]: 1
26@[algo-manage-ser]: 1
27@[ksoftirqd/0]: 1
28@[aliyun-service]: 1
29@[rcu_sched]: 1
30
31
32# 监控网络连接(打印对应的pid和端口)
33[root@dev ~]# bpftrace -e 'kprobe:tcp_connect { printf("TCP connect by PID %d (%s) to %s\n", pid, comm, ntop(arg1)); }'
34Attaching 1 probe...
35TCP connect by PID 641917 (pg_isready) to 0.0.0.0
36TCP connect by PID 641934 (curl) to 76.125.136.65 # 这个很意外发现，链接的有外网的地址？？？
37TCP connect by PID 641950 (pg_isready) to 0.0.0.0
38TCP connect by PID 641967 (pg_isready) to 0.0.0.0
39TCP connect by PID 641984 (pg_isready) to 0.0.0.0
40TCP connect by PID 642000 (pg_isready) to 0.0.0.0
41TCP connect by PID 642017 (pg_isready) to 0.0.0.0

 1# Python示例：监控文件打开
 2from bcc import BPF
 3
 4# BPF程序
 5program = """
 6int trace_openat(struct pt_regs *ctx, int dfd, const char __user *filename) {
 7    bpf_trace_printk("openat called by %s\\n", bpf_get_current_comm());
 8    return 0;
 9}
10"""
11
12b = BPF(text=program)
13b.attach_kprobe(event="sys_openat", fn_name="trace_openat")
14
15# 输出跟踪信息
16print("Tracing openat syscall... Ctrl-C to end")
17try:
18    b.trace_print()
19except KeyboardInterrupt:
20    print("Detaching...")

 1// 使用libbpf加载eBPF程序
 2#include <bpf/libbpf.h>
 3
 4int main() {
 5    struct bpf_program *prog;
 6    struct bpf_object *obj;
 7    int prog_fd;
 8    
 9    // 加载eBPF对象文件
10    obj = bpf_object__open("program.o");
11    bpf_object__load(obj);
12    
13    // 获取程序文件描述符
14    prog = bpf_object__find_program_by_name(obj, "my_program");
15    prog_fd = bpf_program__fd(prog);
16    
17    // 附加到内核
18    bpf_program__attach_kprobe(prog, false, "sys_openat");
19    
20    return 0;
21}

 1## 哈希表 - 通用键值存储
 2BPF_MAP_TYPE_HASH
 3struct {
 4    __uint(type, BPF_MAP_TYPE_HASH);
 5    __uint(max_entries, 10240);
 6    __type(key, __u32);          // PID
 7    __type(value, __u64);        // 计数器
 8} pid_count SEC(".maps");
 9
10## 数组 - 固定大小数组
11BPF_MAP_TYPE_ARRAY
12struct {
13    __uint(type, BPF_MAP_TYPE_ARRAY);
14    __uint(max_entries, 256);
15    __type(key, __u32);
16    __type(value, struct event_t);
17} events SEC(".maps");
18
19## LRU哈希表 - 自动淘汰最少使用项
20BPF_MAP_TYPE_LRU_HASH
21- 内存自动管理
22- 适合缓存场景
23
24## Ring Buffer - 高效的用户态通信（Linux 5.8+）
25BPF_MAP_TYPE_RINGBUF
26- 无锁设计，高性能
27- 替代传统的perf buffer

 1// 时间和随机数相关
 2bpf_ktime_get_ns()          // 获取当前纳秒时间戳
 3bpf_get_prandom_u32()       // 生成随机数
 4
 5// 进程和上下文信息
 6bpf_get_current_pid_tgid()  // 获取当前进程PID/TGID
 7bpf_get_current_uid_gid()   // 获取当前用户ID/组ID
 8bpf_get_current_comm()      // 获取当前进程名
 9bpf_get_current_task()      // 获取当前task_struct
10
11// Map操作
12bpf_map_lookup_elem()       // 查找Map元素
13bpf_map_update_elem()       // 更新Map元素
14bpf_map_delete_elem()       // 删除Map元素
15
16// 内存和字符串操作
17bpf_probe_read()           // 安全读取内存
18bpf_probe_read_str()       // 安全读取字符串
19bpf_probe_read_user()      // 读取用户空间内存
20bpf_probe_read_kernel()    // 读取内核空间内存
21
22// 网络相关
23bpf_redirect()             // 网络包重定向
24bpf_clone_redirect()       // 克隆并重定向包
25bpf_skb_change_head()      // 修改包头空间
26
27// 调试和输出
28bpf_trace_printk()         // 调试输出（限制64字符）
29bpf_perf_event_output()    // 输出事件到用户空间

 1// 2024年性能研究表明，Helper函数调用是性能关键因素
 2// 优化建议：
 31. 减少Helper函数调用次数
 42. 批量处理数据
 53. 缓存频繁访问的信息
 6
 7// 示例：优化前vs优化后
 8// 优化前 - 多次调用
 9for (int i = 0; i < count; i++) {
10    __u64 ts = bpf_ktime_get_ns();
11    process_event(events[i], ts);
12}
13
14// 优化后 - 一次调用，复用结果
15__u64 ts = bpf_ktime_get_ns();
16for (int i = 0; i < count; i++) {
17    process_event(events[i], ts);
18}

 1// 内核跟踪Hook Points
 2kprobe/kretprobe           // 动态内核函数跟踪
 3fentry/fexit               // 函数入口/出口跟踪（性能更优）
 4tracepoint                 // 静态跟踪点
 5perf_event                 // 硬件/软件性能事件
 6
 7// 网络Hook Points  
 8XDP                        // eXpress Data Path，驱动层包处理
 9TC (Traffic Control)       // 流量控制层
10socket filter              // Socket层过滤
11cgroup/skb                 // cgroup网络控制
12
13// 安全Hook Points
14LSM (Linux Security Module) // 安全模块接口
15seccomp                    // 系统调用过滤
16
17// 用户空间Hook Points
18uprobe/uretprobe           // 用户空间函数跟踪
19USDT                       // 用户静态定义跟踪点

1# 性能排序（从高到低）
2网络处理：XDP > TC > Socket Filter > Netfilter
3系统跟踪：Tracepoint > Fentry/Fexit > Kprobe > Uprobe
4
5# 稳定性排序（从高到低）
6Tracepoint > Fentry/Fexit > Kprobe > Uprobe
7
8# 灵活性排序（从高到低）
9Kprobe > Fentry/Fexit > Tracepoint

 1// Tail Calls Map定义
 2struct {
 3    __uint(type, BPF_MAP_TYPE_PROG_ARRAY);
 4    __uint(max_entries, 32);
 5    __type(key, __u32);
 6    __type(value, __u32);
 7} prog_array SEC(".maps");
 8
 9// 主程序
10SEC("xdp")
11int main_prog(struct xdp_md *ctx) {
12    // 执行一些逻辑
13    if (condition1) {
14        // 跳转到程序1
15        bpf_tail_call(ctx, &prog_array, 1);
16    } else if (condition2) {
17        // 跳转到程序2  
18        bpf_tail_call(ctx, &prog_array, 2);
19    }
20    
21    // 如果tail call失败，继续执行
22    return XDP_PASS;
23}
24
25// 子程序1
26SEC("xdp")
27int sub_prog1(struct xdp_md *ctx) {
28    // 处理特定逻辑
29    // 可以继续tail call到其他程序
30    return XDP_DROP;
31}
32
33// 子程序2
34SEC("xdp") 
35int sub_prog2(struct xdp_md *ctx) {
36    // 处理另一种逻辑
37    return XDP_PASS;
38}

 1// Tail Calls限制
 2- 最大调用深度：32层
 3- 程序数组大小限制：取决于Map大小限制
 4- 无法返回到调用者：这是真正的"尾调用"
 5
 6// 2024年JIT优化
 7// 针对tail call和helper函数调用进行了显著优化
 8// 性能提升：减少了调用开销，提高了执行效率
 9
10// 使用场景
111. 复杂包处理流水线
122. 协议栈分层处理
133. 安全策略链式检查
144. 负载均衡算法切换

 1用户空间程序 (bpftrace, BCC, 自定义程序)
 2        |
 3        | (系统调用)
 4        ▼
 5    内核BPF子系统
 6        |
 7        ├── BPF验证器 (Verifier)
 8        |   ├── 静态分析程序安全性
 9        |   ├── 确保不会崩溃内核
10        |   └── 验证内存访问合法性
11        |
12        ├── BPF JIT编译器 
13        |   ├── 将字节码编译为本地机器码
14        |   └── 优化执行性能
15        |
16        └── BPF虚拟机
17            ├── 寄存器：R0-R10 (64位)
18            ├── 指令集：类RISC架构
19            └── 安全执行环境

1# eBPF汇编示例
2mov %r1, 0x10        # 移动立即数到寄存器
3ldxdw %r2, [%r1+8]   # 从内存加载双字
4add %r2, 1           # 加法运算
5stxdw [%r1+8], %r2   # 存储到内存
6exit                 # 退出程序

1R0  - 返回值寄存器，函数返回值
2R1-R5 - 函数参数寄存器
3R6-R9 - 通用寄存器（被调用函数保存）
4R10 - 只读栈指针，指向栈顶

 1// eBPF安全边界
 2┌─────────────────────────────────────┐
 3│            eBPF沙盒环境               │
 4├─────────────────────────────────────┤
 5│ ✓ 受控的内存访问                     │
 6│ ✓ 有限的指令集                       │
 7│ ✓ 确定性执行（无无限循环）            │
 8│ ✓ 预定义的Helper函数                 │
 9│ ✓ 栈大小限制 (512字节)               │
10│ ✓ 程序大小限制 (100万条指令)          │
11└─────────────────────────────────────┘

1// 验证器检查项目 - 2024年版本
2- 程序大小限制：从4,096条指令扩展到100万条指令
3- 循环检测：禁止无限循环，确保程序运行完成
4- 死代码消除：移除永远不会执行的代码
5- 寄存器状态跟踪：跟踪每个寄存器的类型和值域
6- 内存访问边界检查：防止越界访问
7- 指针算术验证：确保指针操作的安全性

 1// 验证器跟踪每个寄存器的类型
 2enum bpf_reg_type {
 3    NOT_INIT,           // 未初始化
 4    SCALAR_VALUE,       // 标量值  
 5    PTR_TO_CTX,         // 上下文指针
 6    PTR_TO_MAP_VALUE,   // Map值指针
 7    PTR_TO_STACK,       // 栈指针
 8    PTR_TO_PACKET,      // 包数据指针
 9    // ... 更多类型
10};

1// 验证器模拟所有可能的执行路径
2static int check_cfg(struct bpf_verifier_env *env) {
3    // 深度优先搜索所有路径
4    // 确保每条路径都是安全的
5    // 验证所有分支的寄存器状态一致性
6}

1// JIT编译流程
2BPF字节码 → 架构特定优化 → 本地机器码
3
4# x86_64机器码生成示例
5BPF: mov %r1, 0x10     →  x86: mov $0x10, %rdi  
6BPF: add %r1, %r2      →  x86: add %rsi, %rdi
7BPF: exit              →  x86: ret

 1// XDP程序 - 包级别统计
 2SEC("xdp")
 3int xdp_stats(struct xdp_md *ctx) {
 4    void *data = (void *)(long)ctx->data;
 5    void *data_end = (void *)(long)ctx->data_end;
 6    
 7    struct ethhdr *eth = data;
 8    if ((void *)(eth + 1) > data_end)
 9        return XDP_PASS;
10    
11    if (eth->h_proto != htons(ETH_P_IP))
12        return XDP_PASS;
13    
14    struct iphdr *ip = (struct iphdr *)(eth + 1);
15    if ((void *)(ip + 1) > data_end)
16        return XDP_PASS;
17    
18    if (ip->protocol != IPPROTO_TCP)
19        return XDP_PASS;
20    
21    // 更新统计信息
22    struct stats_key key = {
23        .src_ip = ip->saddr,
24        .dst_ip = ip->daddr,
25    };
26    
27    struct stats_value *value;
28    value = bpf_map_lookup_elem(&tcp_stats, &key);
29    if (value) {
30        __sync_fetch_and_add(&value->packets, 1);
31        __sync_fetch_and_add(&value->bytes, ntohs(ip->tot_len));
32    } else {
33        struct stats_value new_value = {
34            .packets = 1,
35            .bytes = ntohs(ip->tot_len),
36            .start_time = bpf_ktime_get_ns(),
37        };
38        bpf_map_update_elem(&tcp_stats, &key, &new_value, BPF_ANY);
39    }
40    
41    return XDP_PASS;
42}
43
44// kprobe程序 - 连接状态跟踪
45SEC("kprobe/tcp_set_state")
46int trace_tcp_set_state(struct pt_regs *ctx) {
47    struct sock *sk = (struct sock *)PT_REGS_PARM1(ctx);
48    int state = (int)PT_REGS_PARM2(ctx);
49    
50    if (state == TCP_ESTABLISHED) {
51        // 记录连接建立
52        struct conn_event event = {
53            .event_type = CONN_ESTABLISHED,
54            .pid = bpf_get_current_pid_tgid() >> 32,
55            .timestamp = bpf_ktime_get_ns(),
56        };
57        
58        // 从socket中提取IP和端口信息
59        extract_sock_info(sk, &event);
60        
61        // 发送事件到用户空间
62        bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU, 
63                              &event, sizeof(event));
64    }
65    
66    return 0;
67}

 1#!/usr/bin/env python3
 2from bcc import BPF
 3import time
 4import socket
 5import struct
 6
 7# 加载eBPF程序
 8b = BPF(src_file="network_monitor.c")
 9
10# 附加XDP程序到网卡
11interface = "eth0"
12b.attach_xdp(interface, b.load_func("xdp_stats", BPF.XDP))
13
14# 附加kprobe
15b.attach_kprobe(event="tcp_set_state", fn_name="trace_tcp_set_state")
16
17# 事件处理回调
18def handle_event(cpu, data, size):
19    event = b["events"].event(data)
20    print(f"[{time.strftime('%H:%M:%S')}] "
21          f"PID {event.pid}: TCP connection "
22          f"{socket.inet_ntoa(struct.pack('I', event.src_ip))}:"
23          f"{event.src_port} -> "
24          f"{socket.inet_ntoa(struct.pack('I', event.dst_ip))}:"
25          f"{event.dst_port}")
26
27# 打开perf buffer
28b["events"].open_perf_buffer(handle_event)
29
30print("Monitoring network connections... Press Ctrl-C to stop")
31try:
32    while True:
33        # 获取统计数据
34        tcp_stats = b.get_table("tcp_stats")
35        print(f"\nActive connections: {len(tcp_stats)}")
36        
37        # 显示top 10连接
38        top_connections = sorted(
39            [(k, v) for k, v in tcp_stats.items()],
40            key=lambda x: x[1].bytes,
41            reverse=True
42        )[:10]
43        
44        for i, (key, value) in enumerate(top_connections, 1):
45            src_ip = socket.inet_ntoa(struct.pack('I', key.src_ip))
46            dst_ip = socket.inet_ntoa(struct.pack('I', key.dst_ip))
47            print(f"{i:2d}. {src_ip} -> {dst_ip}: "
48                  f"{value.packets:,} packets, {value.bytes:,} bytes")
49        
50        # 处理perf事件
51        b.perf_buffer_poll(timeout=1000)
52        time.sleep(5)
53        
54except KeyboardInterrupt:
55    print("\nDetaching...")
56    b.remove_xdp(interface)

 1// 1. 使用合适的Map类型
 2struct {
 3    __uint(type, BPF_MAP_TYPE_LRU_HASH);  // 自动清理
 4    __uint(max_entries, 100000);          // 合适的大小
 5    __type(key, struct stats_key);
 6    __type(value, struct stats_value);
 7} tcp_stats SEC(".maps");
 8
 9// 2. 减少Map查找次数
10struct stats_value *value;
11value = bpf_map_lookup_elem(&tcp_stats, &key);
12if (value) {
13    // 一次查找，多次使用
14    value->packets++;
15    value->bytes += len;
16    value->last_seen = bpf_ktime_get_ns();
17} else {
18    // 插入新条目
19    struct stats_value new_value = {1, len, bpf_ktime_get_ns()};
20    bpf_map_update_elem(&tcp_stats, &key, &new_value, BPF_ANY);
21}
22
23// 3. 使用批量操作
24#define BATCH_SIZE 32
25__u32 batch_keys[BATCH_SIZE];
26struct stats_value batch_values[BATCH_SIZE];
27
28// 批量删除过期条目
29bpf_map_delete_batch(&tcp_stats, batch_keys, BATCH_SIZE);

  1// 安全监控eBPF程序
  2#include <uapi/linux/ptrace.h>
  3#include <linux/sched.h>
  4#include <linux/nsproxy.h>
  5
  6// 可疑系统调用定义
  7enum suspicious_syscalls {
  8    SYS_EXECVE = 59,
  9    SYS_EXECVEAT = 322,
 10    SYS_PTRACE = 101,
 11    SYS_MOUNT = 165,
 12    SYS_SETUID = 105,
 13    SYS_SETGID = 106,
 14};
 15
 16// 事件结构
 17struct security_event {
 18    __u32 pid;
 19    __u32 ppid;
 20    __u32 uid;
 21    __u32 gid;
 22    __u32 syscall_nr;
 23    __u64 timestamp;
 24    char comm[16];
 25    char container_id[64];
 26    char namespace_id[32];
 27};
 28
 29BPF_PERF_OUTPUT(security_events);
 30
 31// 容器信息Map
 32struct {
 33    __uint(type, BPF_MAP_TYPE_HASH);
 34    __uint(max_entries, 10000);
 35    __type(key, __u32);  // PID
 36    __type(value, struct container_info);
 37} container_map SEC(".maps");
 38
 39// 白名单Map
 40struct {
 41    __uint(type, BPF_MAP_TYPE_HASH);
 42    __uint(max_entries, 1000);
 43    __type(key, struct whitelist_key);
 44    __type(value, __u8);
 45} whitelist SEC(".maps");
 46
 47SEC("kprobe/sys_execve")
 48int trace_execve(struct pt_regs *ctx) {
 49    __u64 pid_tgid = bpf_get_current_pid_tgid();
 50    __u32 pid = pid_tgid >> 32;
 51    
 52    // 获取当前进程信息
 53    struct task_struct *task = (struct task_struct *)bpf_get_current_task();
 54    
 55    // 检查是否在容器中
 56    if (!is_in_container(task))
 57        return 0;
 58    
 59    // 获取容器信息
 60    struct container_info *container = bpf_map_lookup_elem(&container_map, &pid);
 61    if (!container) {
 62        // 提取容器信息
 63        extract_container_info(task, &container);
 64        bpf_map_update_elem(&container_map, &pid, container, BPF_ANY);
 65    }
 66    
 67    // 检查白名单
 68    struct whitelist_key wl_key = {
 69        .container_id_hash = hash_string(container->container_id),
 70        .syscall_nr = SYS_EXECVE,
 71    };
 72    
 73    if (bpf_map_lookup_elem(&whitelist, &wl_key))
 74        return 0;  // 在白名单中，跳过
 75    
 76    // 记录安全事件
 77    struct security_event event = {};
 78    event.pid = pid;
 79    event.ppid = task->parent->pid;
 80    event.uid = bpf_get_current_uid_gid() & 0xffffffff;
 81    event.gid = bpf_get_current_uid_gid() >> 32;
 82    event.syscall_nr = SYS_EXECVE;
 83    event.timestamp = bpf_ktime_get_ns();
 84    bpf_get_current_comm(&event.comm, sizeof(event.comm));
 85    
 86    // 复制容器信息
 87    bpf_probe_read_str(&event.container_id, sizeof(event.container_id), 
 88                       container->container_id);
 89    bpf_probe_read_str(&event.namespace_id, sizeof(event.namespace_id),
 90                       container->namespace_id);
 91    
 92    // 发送事件
 93    bpf_perf_event_output(ctx, &security_events, BPF_F_CURRENT_CPU,
 94                          &event, sizeof(event));
 95    
 96    return 0;
 97}
 98
 99// 辅助函数：检查进程是否在容器中
100static __always_inline bool is_in_container(struct task_struct *task) {
101    struct nsproxy *nsproxy = task->nsproxy;
102    if (!nsproxy)
103        return false;
104    
105    // 检查是否有独立的PID命名空间
106    struct pid_namespace *pid_ns = nsproxy->pid_ns_for_children;
107    if (pid_ns && pid_ns->level > 0)
108        return true;
109    
110    return false;
111}
112
113// 提取容器信息
114static __always_inline void extract_container_info(struct task_struct *task,
115                                                   struct container_info *info) {
116    // 从cgroup路径提取容器ID
117    // 实际实现会解析/proc/self/cgroup文件
118    // 这里简化处理
119    char cgroup_path[256];
120    // bpf_probe_read_str(cgroup_path, sizeof(cgroup_path), task->cgroups->...);
121    
122    // 解析Docker容器ID (通常在cgroup路径中)
123    // /docker/container_id 或 /kubepods/pod_id/container_id
124    parse_container_id(cgroup_path, info->container_id);
125    
126    // 提取namespace ID
127    struct nsproxy *nsproxy = task->nsproxy;
128    if (nsproxy && nsproxy->pid_ns_for_children) {
129        __u32 ns_id = nsproxy->pid_ns_for_children->ns.inum;
130        bpf_probe_read_str(info->namespace_id, sizeof(info->namespace_id), &ns_id);
131    }
132}

  1#!/usr/bin/env python3
  2import json
  3import time
  4from bcc import BPF
  5from kubernetes import client, config
  6import logging
  7
  8class ContainerSecurityMonitor:
  9    def __init__(self):
 10        self.bpf = BPF(src_file="container_security.c")
 11        self.k8s_client = self.init_k8s_client()
 12        self.threat_rules = self.load_threat_rules()
 13        self.setup_logging()
 14        
 15    def init_k8s_client(self):
 16        """初始化Kubernetes客户端"""
 17        try:
 18            config.load_incluster_config()  # 集群内运行
 19        except:
 20            config.load_kube_config()  # 本地开发环境
 21        return client.CoreV1Api()
 22    
 23    def load_threat_rules(self):
 24        """加载威胁检测规则"""
 25        return {
 26            'suspicious_execve': {
 27                'commands': ['/bin/sh', '/bin/bash', 'wget', 'curl', 'nc'],
 28                'severity': 'medium'
 29            },
 30            'privilege_escalation': {
 31                'syscalls': ['setuid', 'setgid', 'ptrace'],
 32                'severity': 'high'
 33            },
 34            'container_escape': {
 35                'patterns': ['mount', 'unshare', 'nsenter'],
 36                'severity': 'critical'
 37            }
 38        }
 39    
 40    def setup_logging(self):
 41        """配置日志"""
 42        logging.basicConfig(
 43            level=logging.INFO,
 44            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
 45            handlers=[
 46                logging.FileHandler('/var/log/container-security.log'),
 47                logging.StreamHandler()
 48            ]
 49        )
 50        self.logger = logging.getLogger(__name__)
 51    
 52    def handle_security_event(self, cpu, data, size):
 53        """处理安全事件"""
 54        event = self.bpf["security_events"].event(data)
 55        
 56        # 获取Pod信息
 57        pod_info = self.get_pod_info(event.container_id)
 58        
 59        # 威胁分析
 60        threat_level = self.analyze_threat(event)
 61        
 62        if threat_level > 0:
 63            alert = {
 64                'timestamp': time.time(),
 65                'container_id': event.container_id.decode('utf-8'),
 66                'namespace': pod_info.get('namespace', 'unknown'),
 67                'pod_name': pod_info.get('pod_name', 'unknown'),
 68                'node_name': pod_info.get('node_name', 'unknown'),
 69                'process': {
 70                    'pid': event.pid,
 71                    'ppid': event.ppid,
 72                    'comm': event.comm.decode('utf-8'),
 73                    'uid': event.uid,
 74                    'gid': event.gid,
 75                },
 76                'syscall': event.syscall_nr,
 77                'threat_level': threat_level,
 78                'description': self.get_threat_description(event, threat_level)
 79            }
 80            
 81            # 记录警报
 82            self.logger.warning(f"Security Alert: {json.dumps(alert, indent=2)}")
 83            
 84            # 发送到安全中心
 85            self.send_alert(alert)
 86            
 87            # 如果是高危威胁，执行响应措施
 88            if threat_level >= 8:
 89                self.execute_response(alert)
 90    
 91    def analyze_threat(self, event):
 92        """威胁分析算法"""
 93        score = 0
 94        
 95        # 检查可疑命令
 96        comm = event.comm.decode('utf-8')
 97        if comm in self.threat_rules['suspicious_execve']['commands']:
 98            score += 5
 99        
100        # 检查系统调用模式
101        if event.syscall_nr in [105, 106, 101]:  # setuid, setgid, ptrace
102            score += 7
103        
104        # 检查时间模式（夜间活动）
105        current_hour = time.localtime().tm_hour
106        if 0 <= current_hour <= 6:
107            score += 2
108        
109        # 检查进程树异常
110        if self.check_process_tree_anomaly(event):
111            score += 3
112        
113        return min(score, 10)  # 最高10分
114    
115    def get_pod_info(self, container_id):
116        """获取Pod信息"""
117        try:
118            # 通过容器ID查找对应的Pod
119            pods = self.k8s_client.list_pod_for_all_namespaces()
120            for pod in pods.items:
121                if pod.status.container_statuses:
122                    for container in pod.status.container_statuses:
123                        if container_id.startswith(container.container_id):
124                            return {
125                                'namespace': pod.metadata.namespace,
126                                'pod_name': pod.metadata.name,
127                                'node_name': pod.spec.node_name,
128                                'labels': pod.metadata.labels or {}
129                            }
130        except Exception as e:
131            self.logger.error(f"Failed to get pod info: {e}")
132        
133        return {}
134    
135    def execute_response(self, alert):
136        """执行安全响应措施"""
137        self.logger.critical(f"Executing security response for {alert['pod_name']}")
138        
139        # 1. 隔离Pod网络
140        self.isolate_pod_network(alert['namespace'], alert['pod_name'])
141        
142        # 2. 创建事件记录
143        self.create_k8s_event(alert)
144        
145        # 3. 发送紧急通知
146        self.send_emergency_notification(alert)
147    
148    def run(self):
149        """启动监控"""
150        # 附加eBPF程序
151        self.bpf.attach_kprobe(event="sys_execve", fn_name="trace_execve")
152        
153        # 打开perf buffer
154        self.bpf["security_events"].open_perf_buffer(self.handle_security_event)
155        
156        self.logger.info("Container security monitor started")
157        
158        try:
159            while True:
160                self.bpf.perf_buffer_poll()
161        except KeyboardInterrupt:
162            self.logger.info("Shutting down...")
163
164if __name__ == "__main__":
165    monitor = ContainerSecurityMonitor()
166    monitor.run()

 1// 数据库连接监控
 2SEC("uprobe/connect")
 3int trace_db_connect(struct pt_regs *ctx) {
 4    __u64 pid_tgid = bpf_get_current_pid_tgid();
 5    __u32 pid = pid_tgid >> 32;
 6    
 7    // 记录连接开始时间
 8    __u64 ts = bpf_ktime_get_ns();
 9    bpf_map_update_elem(&connect_start, &pid, &ts, BPF_ANY);
10    
11    return 0;
12}
13
14SEC("uretprobe/connect") 
15int trace_db_connect_return(struct pt_regs *ctx) {
16    __u64 pid_tgid = bpf_get_current_pid_tgid();
17    __u32 pid = pid_tgid >> 32;
18    
19    __u64 *start_ts = bpf_map_lookup_elem(&connect_start, &pid);
20    if (!start_ts)
21        return 0;
22    
23    // 计算连接耗时
24    __u64 duration = bpf_ktime_get_ns() - *start_ts;
25    
26    // 更新统计信息
27    struct conn_stats stats = {
28        .count = 1,
29        .total_time = duration,
30        .min_time = duration,
31        .max_time = duration,
32    };
33    
34    bpf_map_update_elem(&connection_stats, &pid, &stats, BPF_ANY);
35    bpf_map_delete_elem(&connect_start, &pid);
36    
37    return 0;
38}

1# 网络处理性能排序（从高到低）
2XDP > TC > Socket Filter > Netfilter
3
4# 系统跟踪性能排序
5Tracepoint > Kprobe > Uprobe

 1// 批量操作 vs 单个操作
 2// 好的做法
 3#define BATCH_SIZE 32
 4__u32 keys[BATCH_SIZE];
 5struct value values[BATCH_SIZE];
 6bpf_map_lookup_batch(&my_map, keys, values, BATCH_SIZE);
 7
 8// 避免的做法
 9for (int i = 0; i < BATCH_SIZE; i++) {
10    bpf_map_lookup_elem(&my_map, &keys[i]);
11}

 1// 使用零拷贝技术
 2SEC("xdp")
 3int xdp_pass_through(struct xdp_md *ctx) {
 4    // 直接操作包数据，避免拷贝
 5    void *data = (void *)(long)ctx->data;
 6    void *data_end = (void *)(long)ctx->data_end;
 7    
 8    // 原地修改包头
 9    struct ethhdr *eth = data;
10    if ((void *)(eth + 1) <= data_end) {
11        // 修改MAC地址
12        __builtin_memcpy(eth->h_dest, new_mac, 6);
13    }
14    
15    return XDP_TX;  // 直接转发，零拷贝
16}

1// 在eBPF程序中添加调试信息
2bpf_trace_printk("Debug: pid=%d, value=%llu\n", pid, value);
3
4# 用户空间读取调试信息
5## cat /sys/kernel/debug/tracing/trace_pipe

 1# 查看加载的程序
 2## bpftool prog show
 3
 4# 查看Map内容
 5## bpftool map dump id 10
 6
 7# 查看程序字节码
 8## bpftool prog dump xlated id 25
 9
10# 查看JIT编译结果
11## bpftool prog dump jited id 25

1# 使用perf分析eBPF程序性能
2## perf record -e bpf:* -a sleep 10
3## perf report
4
5# 使用bpftrace进行实时分析
6## bpftrace -e 'profile:hz:99 /comm == "my_program"/ { @[ustack] = count(); }'

 1// 错误的代码
 2char *data = (char *)ctx->data;
 3char byte = data[100];  // 未检查边界
 4
 5// 正确的代码  
 6char *data = (char *)ctx->data;
 7char *data_end = (char *)ctx->data_end;
 8if (data + 100 < data_end) {
 9    char byte = data[100];
10}

1// 错误：存在永远不会执行的代码
2if (condition) {
3    return 0;
4} else {
5    return 1;
6}
7// 这行代码永远不会执行
8bpf_trace_printk("unreachable\n");

 1// 错误的锁处理
 2struct value *v = bpf_map_lookup_elem(&my_map, &key);
 3if (v) {
 4    bpf_spin_lock(&v->lock);
 5    // 忘记释放锁就返回
 6    if (condition)
 7        return 0;  // BUG: 锁未释放
 8    bpf_spin_unlock(&v->lock);
 9}
10
11// 正确的处理
12struct value *v = bpf_map_lookup_elem(&my_map, &key);
13if (v) {
14    bpf_spin_lock(&v->lock);
15    if (condition) {
16        bpf_spin_unlock(&v->lock);
17        return 0;
18    }
19    bpf_spin_unlock(&v->lock);
20}

1// 根据实际需求设置合适的大小
2struct {
3    __uint(type, BPF_MAP_TYPE_HASH);
4    __uint(max_entries, 1000000);  // 太大浪费内存
5    // 改为合理大小
6    __uint(max_entries, 10000);    // 根据实际场景调整
7} my_map SEC(".maps");

 1// BTF提供丰富的类型信息
 2struct task_struct {
 3    int pid;
 4    int tgid;
 5    char comm[16];
 6    struct task_struct *parent;
 7    // ... 更多字段
 8};
 9
10// 使用BTF信息进行字段访问
11SEC("kprobe/sys_openat")
12int trace_openat(struct pt_regs *ctx) {
13    struct task_struct *task = (struct task_struct *)bpf_get_current_task();
14    
15    // BTF确保字段访问在不同内核版本中正确
16    int pid = BPF_CORE_READ(task, pid);
17    int tgid = BPF_CORE_READ(task, tgid);
18    
19    return 0;
20}

 1// 使用CO-RE宏实现兼容性
 2#include "vmlinux.h"  // 包含BTF类型定义
 3
 4SEC("kprobe/tcp_sendmsg")  
 5int trace_tcp_sendmsg(struct pt_regs *ctx) {
 6    struct sock *sk = (struct sock *)PT_REGS_PARM1(ctx);
 7    
 8    // CO-RE重定位确保字段偏移正确
 9    __u16 family = BPF_CORE_READ(sk, __sk_common.skc_family);
10    __u32 saddr = BPF_CORE_READ(sk, __sk_common.skc_rcv_saddr);
11    __u32 daddr = BPF_CORE_READ(sk, __sk_common.skc_daddr);
12    
13    bpf_trace_printk("TCP: %pI4 -> %pI4\n", &saddr, &daddr);
14    return 0;
15}

 1// hello.bpf.c - eBPF内核程序
 2#include "vmlinux.h"
 3#include <bpf/bpf_helpers.h>
 4
 5struct {
 6    __uint(type, BPF_MAP_TYPE_RINGBUF);
 7    __uint(max_entries, 256 * 1024);
 8} rb SEC(".maps");
 9
10struct event {
11    int pid;
12    char comm[16];
13};
14
15SEC("kprobe/sys_openat")
16int BPF_KPROBE(trace_openat, int dfd, const char __user *filename, int flags) {
17    struct event *e;
18    
19    e = bpf_ringbuf_reserve(&rb, sizeof(*e), 0);
20    if (!e)
21        return 0;
22    
23    e->pid = bpf_get_current_pid_tgid() >> 32;
24    bpf_get_current_comm(&e->comm, sizeof(e->comm));
25    
26    bpf_ringbuf_submit(e, 0);
27    return 0;
28}
29
30char LICENSE[] SEC("license") = "GPL";

 1// hello.c - 用户空间程序
 2#include <bpf/libbpf.h>
 3#include <bpf/bpf.h>
 4#include "hello.skel.h"  // 自动生成的skeleton
 5
 6static int handle_event(void *ctx, void *data, size_t data_sz) {
 7    const struct event *e = data;
 8    printf("PID %d (%s) opened file\n", e->pid, e->comm);
 9    return 0;
10}
11
12int main() {
13    struct hello_bpf *skel;
14    struct ring_buffer *rb = NULL;
15    int err;
16
17    // 打开并加载eBPF程序
18    skel = hello_bpf__open_and_load();
19    if (!skel) {
20        fprintf(stderr, "Failed to open BPF skeleton\n");
21        return 1;
22    }
23
24    // 附加程序到内核
25    err = hello_bpf__attach(skel);
26    if (err) {
27        fprintf(stderr, "Failed to attach BPF skeleton\n");
28        goto cleanup;
29    }
30
31    // 设置ring buffer
32    rb = ring_buffer__new(bpf_map__fd(skel->maps.rb), handle_event, NULL, NULL);
33    if (!rb) {
34        err = -1;
35        fprintf(stderr, "Failed to create ring buffer\n");
36        goto cleanup;
37    }
38
39    printf("Successfully started! Please run `sudo cat /sys/kernel/debug/tracing/trace_pipe` "
40           "to see output of the BPF programs.\n");
41
42    while (true) {
43        err = ring_buffer__poll(rb, 100);
44        if (err == -EINTR) {
45            err = 0;
46            break;
47        }
48        if (err < 0) {
49            printf("Error polling perf buffer: %d\n", err);
50            break;
51        }
52    }
53
54cleanup:
55    ring_buffer__free(rb);
56    hello_bpf__destroy(skel);
57    return -err;
58}

 1// 新一代函数跟踪，性能更高
 2SEC("fentry/tcp_sendmsg")
 3int BPF_PROG(tcp_sendmsg_entry, struct sock *sk, struct msghdr *msg, size_t size) {
 4    __u32 pid = bpf_get_current_pid_tgid() >> 32;
 5    bpf_trace_printk("tcp_sendmsg called by PID %d, size %d\n", pid, size);
 6    return 0;
 7}
 8
 9SEC("fexit/tcp_sendmsg")  
10int BPF_PROG(tcp_sendmsg_exit, struct sock *sk, struct msghdr *msg, 
11             size_t size, int ret) {
12    __u32 pid = bpf_get_current_pid_tgid() >> 32;
13    bpf_trace_printk("tcp_sendmsg returned %d for PID %d\n", ret, pid);
14    return 0;
15}

 1// 安全模块钩子，实现细粒度安全控制
 2SEC("lsm/file_open")
 3int BPF_PROG(file_open, struct file *file, const struct cred *cred) {
 4    char filename[256];
 5    struct dentry *dentry = BPF_CORE_READ(file, f_path.dentry);
 6    
 7    bpf_d_path(&file->f_path, filename, sizeof(filename));
 8    
 9    // 阻止访问敏感文件
10    if (bpf_strstr(filename, "/etc/passwd") ||
11        bpf_strstr(filename, "/etc/shadow")) {
12        bpf_trace_printk("Blocked access to %s\n", filename);
13        return -EPERM;
14    }
15    
16    return 0;
17}

 1// XDP程序将包重定向到用户空间
 2SEC("xdp")
 3int xdp_sock_prog(struct xdp_md *ctx) {
 4    int index = ctx->rx_queue_index;
 5    
 6    // 将包重定向到AF_XDP socket
 7    if (index < MAX_SOCKS)
 8        return bpf_redirect_map(&xsks_map, index, 0);
 9    
10    return XDP_PASS;
11}

 1// 用户空间AF_XDP程序
 2#include <xdp/xsk.h>
 3
 4struct xsk_socket_info {
 5    struct xsk_ring_cons rx;
 6    struct xsk_ring_prod tx;
 7    struct xsk_umem_info *umem;
 8    struct xsk_socket *xsk;
 9    int outstanding_tx;
10};
11
12static void handle_receive_packets(struct xsk_socket_info *xsk_info) {
13    unsigned int rcvd, stock_frames, i;
14    uint32_t idx_rx = 0, idx_fq = 0;
15    int ret;
16
17    rcvd = xsk_ring_cons__peek(&xsk_info->rx, RX_BATCH_SIZE, &idx_rx);
18    if (!rcvd)
19        return;
20
21    // 补充frame到fill queue
22    stock_frames = xsk_prod_nb_free(&xsk_info->umem->fq,
23                                    xsk_info->umem->num_frames);
24
25    if (stock_frames > 0) {
26        ret = xsk_ring_prod__reserve(&xsk_info->umem->fq, stock_frames, &idx_fq);
27        while (ret != stock_frames)
28            ret = xsk_ring_prod__reserve(&xsk_info->umem->fq, rcvd, &idx_fq);
29
30        for (i = 0; i < stock_frames; i++)
31            *xsk_ring_prod__fill_addr(&xsk_info->umem->fq, idx_fq++) =
32                alloc_umem_frame(xsk_info);
33
34        xsk_ring_prod__submit(&xsk_info->umem->fq, stock_frames);
35    }
36
37    // 处理接收到的包
38    for (i = 0; i < rcvd; i++) {
39        uint64_t addr = xsk_ring_cons__rx_desc(&xsk_info->rx, idx_rx)->addr;
40        uint32_t len = xsk_ring_cons__rx_desc(&xsk_info->rx, idx_rx++)->len;
41        char *pkt = xsk_umem__get_data(xsk_info->umem->buffer, addr);
42        
43        // 处理数据包
44        process_packet(pkt, len);
45    }
46
47    xsk_ring_cons__release(&xsk_info->rx, rcvd);
48}

 1# 查看程序的详细信息和统计
 2## bpftool prog show id 123 --pretty
 3
 4# 导出程序到文件
 5## bpftool prog dump xlated id 123 file /tmp/prog.txt
 6
 7# 查看程序的JIT编译结果  
 8## bpftool prog dump jited id 123
 9
10# 查看程序的验证器日志
11## bpftool prog load program.o /sys/fs/bpf/myprog --debug
12
13# 实时监控程序运行统计
14## bpftool prog tracelog

 1// 使用bpf_printk进行调试
 2#define DEBUG 1
 3
 4#ifdef DEBUG
 5#define dbg_printk(fmt, ...) \
 6    bpf_trace_printk(fmt, sizeof(fmt), ##__VA_ARGS__)
 7#else  
 8#define dbg_printk(fmt, ...) do {} while(0)
 9#endif
10
11SEC("kprobe/sys_openat")
12int trace_openat(struct pt_regs *ctx) {
13    char filename[256];
14    bpf_probe_read_user_str(filename, sizeof(filename), 
15                           (void *)PT_REGS_PARM2(ctx));
16    
17    dbg_printk("openat: %s\n", filename);
18    
19    // 使用专用的调试Map
20    struct debug_event event = {
21        .timestamp = bpf_ktime_get_ns(),
22        .pid = bpf_get_current_pid_tgid() >> 32,
23    };
24    bpf_probe_read_str(&event.filename, sizeof(event.filename), filename);
25    
26    bpf_perf_event_output(ctx, &debug_events, BPF_F_CURRENT_CPU, 
27                          &event, sizeof(event));
28    return 0;
29}

 1// 使用feature detection处理版本差异
 2#include "vmlinux.h"
 3
 4// 检查内核特性是否存在
 5static __always_inline bool has_btf_task_struct_pid() {
 6    return bpf_core_field_exists(struct task_struct, pid);
 7}
 8
 9// 条件编译处理版本差异
10SEC("kprobe/sys_openat")
11int trace_openat(struct pt_regs *ctx) {
12    struct task_struct *task = (struct task_struct *)bpf_get_current_task();
13    
14    if (has_btf_task_struct_pid()) {
15        int pid = BPF_CORE_READ(task, pid);
16        bpf_trace_printk("PID: %d\n", pid);
17    } else {
18        // 回退到其他方式获取PID
19        int pid = bpf_get_current_pid_tgid() >> 32;
20        bpf_trace_printk("PID (fallback): %d\n", pid);
21    }
22    
23    return 0;
24}

 1# Makefile for modern eBPF development
 2BPF_TARGETS := hello
 3BPF_OBJ_FILES := $(addsuffix .bpf.o, $(BPF_TARGETS))
 4USER_TARGETS := $(BPF_TARGETS)
 5USER_OBJ_FILES := $(addsuffix .o, $(USER_TARGETS))
 6
 7LIBBPF_SRC := libbpf/src
 8LIBBPF_OBJ := $(LIBBPF_SRC)/libbpf.a
 9VMLINUX := vmlinux/vmlinux.h
10
11# Clang和LLVM版本要求
12CLANG ?= clang
13LLVM_STRIP ?= llvm-strip
14
15# BPF编译标志
16BPF_CFLAGS := -g -O2 -target bpf -D__TARGET_ARCH_x86_64 \
17              -I$(LIBBPF_SRC) -I. -I$(dir $(VMLINUX))
18
19# 用户程序编译标志
20USER_CFLAGS := -g -Wall -I$(LIBBPF_SRC) -I.
21
22# 生成skeleton头文件
23%.skel.h: %.bpf.o
24	$(BPFTOOL) gen skeleton $< > $@
25
26# 编译BPF程序
27%.bpf.o: %.bpf.c $(LIBBPF_OBJ) $(VMLINUX)
28	$(CLANG) $(BPF_CFLAGS) -c $< -o $@
29	$(LLVM_STRIP) -g $@
30
31# 编译用户程序
32%: %.c %.skel.h $(LIBBPF_OBJ)
33	$(CC) $(USER_CFLAGS) $< $(LIBBPF_OBJ) -lelf -lz -o $@
34
35.PHONY: clean
36clean:
37	rm -f *.o *.skel.h $(BPF_TARGETS)

 1// 性能监控eBPF程序
 2struct {
 3    __uint(type, BPF_MAP_TYPE_HASH);
 4    __uint(max_entries, 10240);
 5    __type(key, __u32);
 6    __type(value, struct perf_metrics);
 7} perf_map SEC(".maps");
 8
 9struct perf_metrics {
10    __u64 cpu_cycles;
11    __u64 instructions;
12    __u64 cache_misses;
13    __u64 timestamp;
14};
15
16SEC("perf_event")
17int sample_perf(struct bpf_perf_event_data *ctx) {
18    __u32 cpu = bpf_get_smp_processor_id();
19    struct perf_metrics *metrics;
20    
21    metrics = bpf_map_lookup_elem(&perf_map, &cpu);
22    if (!metrics) {
23        struct perf_metrics new_metrics = {0};
24        bpf_map_update_elem(&perf_map, &cpu, &new_metrics, BPF_NOEXIST);
25        metrics = bpf_map_lookup_elem(&perf_map, &cpu);
26    }
27    
28    if (metrics) {
29        metrics->cpu_cycles = ctx->sample_period;
30        metrics->timestamp = bpf_ktime_get_ns();
31        
32        // 检测异常情况并发送告警
33        if (metrics->cache_misses > CACHE_MISS_THRESHOLD) {
34            struct alert_event alert = {
35                .cpu = cpu,
36                .metric_type = CACHE_MISS_ALERT,
37                .value = metrics->cache_misses,
38            };
39            bpf_perf_event_output(ctx, &alerts, BPF_F_CURRENT_CPU,
40                                  &alert, sizeof(alert));
41        }
42    }
43    
44    return 0;
45}

 1// 资源使用监控
 2struct {
 3    __uint(type, BPF_MAP_TYPE_CGROUP_ARRAY);
 4    __uint(max_entries, 1);
 5    __uint(key_size, sizeof(__u32));
 6    __uint(value_size, sizeof(__u32));
 7} cgroup_map SEC(".maps");
 8
 9SEC("cgroup/skb")
10int monitor_network_usage(struct __sk_buff *skb) {
11    struct cgroup_info *info;
12    __u32 key = 0;
13    
14    // 获取cgroup信息
15    info = bpf_map_lookup_elem(&cgroup_map, &key);
16    if (!info)
17        return 1;
18        
19    // 更新网络使用统计
20    __sync_fetch_and_add(&info->bytes_sent, skb->len);
21    __sync_fetch_and_add(&info->packets_sent, 1);
22    
23    // 实施速率限制
24    if (info->bytes_sent > RATE_LIMIT_BYTES_PER_SEC) {
25        return 0;  // 丢弃包
26    }
27    
28    return 1;  // 允许通过
29}

 1Cilium
 2├── 功能：eBPF驱动的网络、安全和可观测性
 3├── 特色：CNI插件、服务网格、网络策略
 4└── 应用：Kubernetes网络解决方案
 5
 6BPFire  
 7├── 功能：基于Linux的开源防火墙
 8├── 特色：高性能包过滤
 9└── 应用：网络安全防护
10
11Katran
12├── 功能：C++库和eBPF程序的负载均衡器
13├── 特色：利用XDP实现高性能四层负载均衡
14└── 应用：Facebook生产环境验证

 1Pixie
 2├── 功能：Kubernetes应用可观测性工具
 3├── 特色：自动化应用监控和分析
 4└── 应用：云原生环境性能监控
 5
 6Pyroscope
 7├── 功能：持续性能分析平台
 8├── 特色：特别针对Kubernetes环境优化
 9└── 应用：系统级持续分析，开销最小
10
11Coroot
12├── 功能：开源eBPF可观测性工具
13├── 特色：微服务监控和故障排除
14└── 应用：分布式系统性能分析

1Kubescape
2├── 功能：Kubernetes安全态势管理平台
3├── 特色：利用eBPF执行Linux内核深度实时分析
4├── 应用：检测安全配置错误和运行时威胁
5└── 特点：深度包检查和流量过滤，开销最小

 1BCC (BPF Compiler Collection)
 2├── 语言：Python、Lua、C++前端
 3├── 特点：快速原型开发，丰富的示例
 4└── 适用：学习和快速验证
 5
 6bpftrace
 7├── 语言：高级追踪语言
 8├── 特点：类似awk的脚本语言
 9└── 适用：一行式调试和监控
10
11libbpf
12├── 语言：C语言库
13├── 特点：现代eBPF开发的标准库
14└── 适用：生产级应用开发
15
16cilium/ebpf (Go)
17├── 语言：Go语言库
18├── 特点：纯Go实现，无需cgo
19└── 适用：Go生态系统集成

1RFC 9669 (2024年10月)
2├── 标题：BPF指令集架构规范
3├── 意义：行业标准正式确立
4├── 内容：指令集、寄存器、执行模型标准化
5└── 影响：促进跨平台兼容性和生态发展

1网络处理性能对比：
2┌─────────────────────┬──────────────┬─────────────┐
3│      处理方式         │   性能(pps)   │   延迟      │
4├─────────────────────┼──────────────┼─────────────┤
5│ XDP (eBPF)          │ 10-20M       │ 最低        │
6│ DPDK               │ 10-15M       │ 低          │
7│ 内核网络栈           │ 1-2M         │ 中等        │
8│ 用户空间包处理       │ 100K-500K    │ 高          │
9└─────────────────────┴──────────────┴─────────────┘

1# 传统方式
2strace -p $PID           # 高开销，影响性能
3perf record -g           # 需要采样，可能丢失事件  
4systemtap               # 编译复杂，内核依赖强
5
6# eBPF方式
7bpftrace -e 'tracepoint:syscalls:sys_enter_openat { ... }'
8# 优势：低开销、实时、内核原生支持

1# 传统方式  
2tcpdump -i eth0         # 用户空间处理，开销大
3iptables -j LOG         # 依赖netfilter，性能影响大
4
5# eBPF方式
6XDP + Maps统计         # 内核空间直接处理，零拷贝
7# 优势：高性能、细粒度控制、实时统计

1✓ 高性能网络处理      # XDP优势明显
2✓ 实时系统监控        # 低开销优势
3✓ 云原生环境         # 动态性和安全性
4✓ 容器安全          # 精细化控制
5✓ 服务网格          # 透明代理和策略
6✓ 性能分析          # 内核级可见性

1✓ 复杂计算任务        # 用户空间更灵活
2✓ 需要大量库依赖      # eBPF helper函数有限
3✓ 旧版本内核         # eBPF特性支持有限  
4✓ 一次性脚本任务      # 开发成本考虑

 1标准化影响：
 2├── 跨平台兼容性
 3│   ├── Windows eBPF项目
 4│   ├── FreeBSD BPF扩展
 5│   └── 嵌入式系统支持
 6├── 生态系统发展  
 7│   ├── 编译器标准化
 8│   ├── 调试工具统一
 9│   └── 开发体验改善
10└── 企业级采用
11    ├── 合规性保证
12    ├── 长期技术路线
13    └── 投资决策支持

 1技术发展方向：
 2├── 2025-2026年预期
 3│   ├── Windows eBPF成熟
 4│   ├── 用户空间eBPF虚拟机
 5│   └── AI/ML工作负载集成
 6├── 长期发展
 7│   ├── 硬件加速支持
 8│   ├── 更丰富的程序类型
 9│   └── 更高级的编程抽象
10└── 生态系统扩展
11    ├── 更多语言绑定
12    ├── 图形化开发工具
13    └── 云服务集成