1
// 方式一：使用 BTF 定义（推荐，CO-RE 兼容）
2
struct {
3
    __uint(type, BPF_MAP_TYPE_HASH);
4
    __uint(max_entries, 1024);
5
    __type(key, u32);
6
    __type(value, struct event);
7
} my_map SEC(".maps");
8

9
// 方式二：使用 struct bpf_map_def（传统方式）
10
struct bpf_map_def SEC("maps") my_map = {
11
    .type = BPF_MAP_TYPE_HASH,
12
    .key_size = sizeof(u32),
13
    .value_size = sizeof(struct event),
14
    .max_entries = 1024,
15
};

1
// 连接跟踪 Map
2
struct conn_key {
3
    u32 src_ip;
4
    u32 dst_ip;
5
    u16 src_port;
6
    u16 dst_port;
7
    u8 protocol;
8
};
9

10
struct conn_value {
11
    u64 packets;
12
    u64 bytes;
13
    u64 last_seen;
14
};
15

16
struct {
17
    __uint(type, BPF_MAP_TYPE_HASH);
18
    __uint(max_entries, 65536);
19
    __type(key, struct conn_key);
20
    __type(value, struct conn_value);
21
} conn_track SEC(".maps");
22

23
SEC("xdp")
24
int track_connections(struct xdp_md *ctx)
25
{
26
    struct conn_key key = {};
27
    struct conn_value *val;
28

29
    // 解析数据包填充 key
30
    if (parse_packet(ctx, &key) < 0)
31
        return XDP_PASS;
32

33
    // 查找或创建连接记录
34
    val = bpf_map_lookup_elem(&conn_track, &key);
35
    if (val) {
36
        // 更新已有记录
37
        __sync_fetch_and_add(&val->packets, 1);
38
        val->last_seen = bpf_ktime_get_ns();
39
    } else {
40
        // 插入新记录
41
        struct conn_value new_val = {
42
            .packets = 1,
43
            .last_seen = bpf_ktime_get_ns(),
44
        };
45
        bpf_map_update_elem(&conn_track, &key, &new_val, BPF_ANY);
46
    }
47

48
    return XDP_PASS;
49
}

1
// 配置 Map
2
struct config {
3
    u32 action;     // 0=PASS, 1=DROP, 2=REDIRECT
4
    u32 target_if;  // 重定向目标接口
5
    u32 rate_limit; // 速率限制（PPS）
6
};
7

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

15
SEC("xdp")
16
int xdp_filter(struct xdp_md *ctx)
17
{
18
    u32 key = 0;
19
    struct config *cfg = bpf_map_lookup_elem(&config_map, &key);
20
    if (!cfg)
21
        return XDP_PASS;
22

23
    switch (cfg->action) {
24
    case 0: return XDP_PASS;
25
    case 1: return XDP_DROP;
26
    case 2: return bpf_redirect(cfg->target_if, 0);
27
    default: return XDP_PASS;
28
    }
29
}

1
struct {
2
    __uint(type, BPF_MAP_TYPE_PROG_ARRAY);
3
    __uint(max_entries, 8);
4
    __type(key, u32);
5
    __type(value, u32);
6
} prog_array SEC(".maps");
7

8
SEC("xdp")
9
int xdp_dispatcher(struct xdp_md *ctx)
10
{
11
    // 根据协议分发到不同处理程序
12
    u8 proto = get_protocol(ctx);
13
    bpf_tail_call(ctx, &prog_array, proto);
14
    return XDP_PASS;  // 尾调用失败时的默认行为
15
}

1
// Per-CPU 计数器
2
struct {
3
    __uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
4
    __uint(max_entries, 1);
5
    __type(key, u32);
6
    __type(value, u64);
7
} pkt_counter SEC(".maps");
8

9
SEC("xdp")
10
int count_packets(struct xdp_md *ctx)
11
{
12
    u32 key = 0;
13
    u64 *count = bpf_map_lookup_elem(&pkt_counter, &key);
14
    if (count)
15
        *count += 1;  // 无锁更新！
16
    return XDP_PASS;
17
}

1
// 用户态读取 Per-CPU Map
2
u32 key = 0;
3
u64 values[num_cpus];
4
bpf_map_lookup_elem(map_fd, &key, values);
5

6
u64 total = 0;
7
for (int i = 0; i < num_cpus; i++)
8
    total += values[i];
9
printf("Total packets: %lu\n", total);

1
struct event {
2
    u32 pid;
3
    u32 tid;
4
    char comm[16];
5
    char filename[256];
6
};
7

8
struct {
9
    __uint(type, BPF_MAP_TYPE_RINGBUF);
10
    __uint(max_entries, 256 * 1024);  // 256 KB
11
} events SEC(".maps");
12

13
SEC("tracepoint/syscalls/sys_enter_openat")
14
int trace_openat(struct trace_event_raw_sys_enter *ctx)
15
{
16
    struct event *e;
17

18
    // 从 Ring Buffer 预留空间
19
    e = bpf_ringbuf_reserve(&events, sizeof(*e), 0);
20
    if (!e)
21
        return 0;
22

23
    // 填充事件数据
24
    u64 pid_tgid = bpf_get_current_pid_tgid();
25
    e->pid = pid_tgid >> 32;
26
    e->tid = (u32)pid_tgid;
27
    bpf_get_current_comm(&e->comm, sizeof(e->comm));
28

29
    const char *filename = (const char *)ctx->args[1];
30
    bpf_probe_read_user_str(&e->filename, sizeof(e->filename), filename);
31

32
    // 提交事件
33
    bpf_ringbuf_submit(e, 0);
34

35
    return 0;
36
}

1
struct {
2
    __uint(type, BPF_MAP_TYPE_LRU_HASH);
3
    __uint(max_entries, 10000);
4
    __type(key, struct conn_key);
5
    __type(value, struct conn_value);
6
} conn_cache SEC(".maps");
7

8
// 当条目数达到 max_entries 时，自动淘汰最久未访问的条目
9
// 无需手动删除旧条目

1
struct {
2
    __uint(type, BPF_MAP_TYPE_STACK_TRACE);
3
    __uint(max_entries, 10000);
4
    __type(key, u32);
5
    __type(value, struct stack_trace_t);  // 自动定义
6
} stack_traces SEC(".maps");
7

8
SEC("kprobe/do_sys_open")
9
int trace_open(struct pt_regs *ctx)
10
{
11
    u32 pid = bpf_get_current_pid_tgid() >> 32;
12
    // 捕获当前调用栈
13
    long stack_id = bpf_get_stackid(ctx, &stack_traces, BPF_F_FAST_STACK);
14
    if (stack_id >= 0) {
15
        // stack_id 可用于从用户态查询完整调用栈
16
    }
17
    return 0;
18
}

1
struct {
2
    __uint(type, BPF_MAP_TYPE_SOCKHASH);
3
    __uint(max_entries, 65536);
4
    __type(key, struct sock_key);
5
    __type(value, u32);
6
} sock_map SEC(".maps");
7

8
SEC("sk_msg")
9
int bpf_prog(struct sk_msg_md *msg)
10
{
11
    // 根据 Socket 信息重定向到目标 Socket
12
    struct sock_key key = {
13
        .sip = msg->remote_ip4,
14
        .dip = msg->local_ip4,
15
        .sport = msg->remote_port,
16
        .dport = msg->local_port,
17
    };
18
    bpf_msg_redirect_hash(msg, &sock_map, &key, BPF_F_INGRESS);
19
    return SK_PASS;
20
}

1
# 列出所有 Map
2
sudo bpftool map list
3

4
# 查看 Map 详细信息
5
sudo bpftool map show id 123
6

7
# 查看 Map 内容
8
sudo bpftool map dump id 123
9

10
# 更新 Map 条目
11
sudo bpftool map update id 123 key 0 0 0 0 value 1 0 0 0
12

13
# 查找特定条目
14
sudo bpftool map lookup id 123 key 0 0 0 0
15

16
# 删除条目
17
sudo bpftool map delete id 123 key 0 0 0 0

1
#include <bpf/libbpf.h>
2
#include <bpf/bpf.h>
3

4
// 获取 Map fd
5
int map_fd = bpf_map__fd(skel->maps.my_map);
6

7
// 查找
8
u32 key = 1;
9
struct event value;
10
int err = bpf_map_lookup_elem(map_fd, &key, &value);
11
if (err == 0) {
12
    printf("Found: pid=%u\n", value.pid);
13
}
14

15
// 更新
16
value.pid = 1234;
17
bpf_map_update_elem(map_fd, &key, &value, BPF_ANY);
18

19
// 遍历
20
u32 next_key;
21
while (bpf_map_get_next_key(map_fd, &key, &next_key) == 0) {
22
    bpf_map_lookup_elem(map_fd, &next_key, &value);
23
    printf("key=%u pid=%u\n", next_key, value.pid);
24
    key = next_key;
25
}
26

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

1
package main
2

3
import (
4
    "fmt"
5
    "github.com/cilium/ebpf"
6
)
7

8
func main() {
9
    // 打开 Map
10
    m, err := ebpf.NewMapFromFile("/sys/fs/bpf/my_map")
11
    if err != nil {
12
        panic(err)
13
    }
14
    defer m.Close()
15

16
    // 查找
17
    var key uint32 = 1
18
    var value uint64
19
    err = m.Lookup(&key, &value)
20
    if err == nil {
21
        fmt.Printf("Found: key=%d value=%d\n", key, value)
22
    }
23

24
    // 更新
25
    value = 42
26
    err = m.Update(&key, &value, ebpf.UpdateAny)
27

28
    // 遍历
29
    var iterKey uint32
30
    iter := m.Iterate()
31
    for iter.Next(&iterKey, &value) {
32
        fmt.Printf("key=%d value=%d\n", iterKey, value)
33
    }
34
}

1
# 创建一个 Hash Map
2
sudo bpftool map create /sys/fs/bpf/my_hash \
3
    type hash key 4 value 8 entries 1024 name my_hash
4

5
# 插入条目
6
sudo bpftool map update pinned /sys/fs/bpf/my_hash \
7
    key 1 0 0 0 value 42 0 0 0 0 0 0 0
8

9
# 查找条目
10
sudo bpftool map lookup pinned /sys/fs/bpf/my_hash \
11
    key 1 0 0 0
12

13
# 遍历所有条目
14
sudo bpftool map dump pinned /sys/fs/bpf/my_hash

1
# 统计每个进程的系统调用次数（使用 Map）
2
sudo bpftrace -e '
3
tracepoint:raw_syscalls:sys_enter {
4
    @syscalls[comm] = count();
5
}
6
interval:s:5 {
7
    print(@syscalls);
8
    clear(@syscalls);
9
}'
10

11
# 统计每个进程的读字节数（使用 Map）
12
sudo bpftrace -e '
13
tracepoint:syscalls:sys_exit_read
14
/args->ret > 0/ {
15
    @bytes[comm] = sum(args->ret);
16
}'

1
# 查看 Map 内存使用
2
sudo bpftool map show id 123
3
# 输出包含：bytes_used, max_entries, key_size, value_size
4

5
# 查看系统所有 eBPF Map 的内存占用
6
sudo bpftool map list
7
sudo bpftool map show