先看看之前的sockmap sockmap_ebpf sock_map2 ipvs-ebpf
EBPF：本质上它是一种内核代码注入的技术
- 内核中实现了一个cBPF/eBPF虚拟机
- 用户态可以用C来写运行的代码，再通过一个Clang&LLVM的编译器将C代码编译成BPF目标码
- 用户态通过系统调用bpf()将BPF目标码注入到内核当中
- 内核通过JIT(Just-In-Time)将BPF目编码转换成本地指令码；如果当前架构不支持JIT转换内核则会使用一个解析器(interpreter)来模拟运行，这种运行效率较低；
- 内核在packet filter和tracing等应用中提供了一系列的钩子来运行BPF代码。目前支持以下类型的BPF代码
提供了一种在不修改内核代码的情况下，可以灵活修改内核处理策略的方法
#include <uapi/linux/bpf.h> #include <uapi/linux/if_ether.h> #include <uapi/linux/if_packet.h> #include <uapi/linux/ip.h> #include <bpf/bpf_helpers.h> #include "bpf_legacy.h" struct { __uint(type, BPF_MAP_TYPE_ARRAY); __type(key, u32); __type(value, long); __uint(max_entries, 256); } my_map SEC(".maps"); SEC("socket1") int bpf_prog1(struct __sk_buff *skb) { int index = load_byte(skb, ETH_HLEN + offsetof(struct iphdr, protocol)); long *value; if (skb->pkt_type != PACKET_OUTGOING) return 0; value = bpf_map_lookup_elem(&my_map, &index); if (value) __sync_fetch_and_add(value, skb->len); return 0; } char _license[] SEC("license") = "GPL";
只有一个 my_map 数据结构和 bpf_prog1 函数；bpf_prog1 就是我们在内核执行的程序片段，它的入参是报文 skb。这个函数完成了以下功能：
- 统计各个协议报文的数据量
// SPDX-License-Identifier: GPL-2.0 #include <stdio.h> #include <assert.h> #include <linux/bpf.h> #include <bpf/bpf.h> #include <bpf/libbpf.h> #include "sock_example.h" #include <unistd.h> #include <arpa/inet.h> int main(int ac, char **argv) { struct bpf_object *obj; int map_fd, prog_fd; char filename[256]; int i, sock; FILE *f; snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]); /* 装载文件 sockex1_kern.o */ if (bpf_prog_load(filename, BPF_PROG_TYPE_SOCKET_FILTER, &obj, &prog_fd)) return 1; map_fd = bpf_object__find_map_fd_by_name(obj, "my_map"); sock = open_raw_sock("lo"); /* 创建一个 socket， bind 到环回口设备 */ /* 设置 socket 的 SO_ATTACH_BPF 选项，传入 prog_fd */ assert(setsockopt(sock, SOL_SOCKET, SO_ATTACH_BPF, &prog_fd, sizeof(prog_fd)) == 0); f = popen("ping -4 -c5 localhost", "r"); (void) f; for (i = 0; i < 5; i++) { long long tcp_cnt, udp_cnt, icmp_cnt; int key; key = IPPROTO_TCP; assert(bpf_map_lookup_elem(map_fd, &key, &tcp_cnt) == 0); key = IPPROTO_UDP; assert(bpf_map_lookup_elem(map_fd, &key, &udp_cnt) == 0); key = IPPROTO_ICMP; assert(bpf_map_lookup_elem(map_fd, &key, &icmp_cnt) == 0); printf("TCP %lld UDP %lld ICMP %lld bytes ", tcp_cnt, udp_cnt, icmp_cnt); sleep(1); } return 0; }
sock_user:代码核心分析：
- bpf_prog_load的入参 sockex1_user.o 是如何转换成虚拟机机器码注入内核的？
- 内核代码何时执行，执行的上下文是什么?
- 用户空间和内核空间的程序是如何通过 map 进行通信？
bpf_prog_load是 libbpf苦衷提供的函数；最后会调用 sys_bpf(BPF_PROG_LOAD, &attr, sizeof(attr)); 将code 注入到内核！！、SYSCALL_DEFINE3(bpf, int, cmd, union bpf_attr __user *, uattr, unsigned int, size){
...... case BPF_PROG_LOAD: err = bpf_prog_load(&attr); } static int bpf_prog_load(union bpf_attr *attr) { struct bpf_prog *prog; ...... /* 分配内核 bpf_prog 程序数据结构空间 */ prog = bpf_prog_alloc(bpf_prog_size(attr->insn_cnt), GFP_USER); ..... /* 将 bpf 虚拟机指令从用户空间拷贝到内核空间 */ copy_from_user(prog->insns, u64_to_user_ptr(attr->insns), bpf_prog_insn_size(prog)); ..... /* 分配一个 fd 与 prog 关联，最终这个 fd 将返回用户空间 * /
/*此时 file->private_data = priv; 也就是 file->private_data = prog
表示 注入内核的BPF程序--字节码 关联到 fd的priva_data上
所以后续当内核执行hook的时候，根据hook的fd查找到private-data找到bpf代码执行 */
err = bpf_prog_new_fd(prog); ..... return err; }
用户空间通过系统调用陷入内核后，内核也会分配相应的数据结构 struct bpf_prog，并从用户空间拷贝虚拟机指令。然后分配一个文件系统的 inode 节点，将它与 bpf_prog 关联起来，最后将文件描述符返回给用户空间。
eBPF 程序指令都是在内核的特定 Hook 点执行，不同类型的程序有不同的钩子，有不同的上下文
将指令 load 到内核时，内核会创建 bpf_prog 存储指令，但只是第一步，成功运行这些指令还需要完成以下两个步骤：
- 将 bpf_prog 与内核中的特定 Hook 点关联起来，也就是将程序挂到钩子上。
- 在 Hook 点被访问到时，取出 bpf_prog，执行这些指令。
比如：
SOCKET FILTER 类型 eBPF 程序通过 SO_ATTACH_BPF 选项完成设置
XDP 类型的 eBPF 程序，则通过 Netlink 的方式设置 Hook 点
每一个 load 到内核的 eBPF 程序都有一个 fd 会返回给用户，它对应一个 bpf_prog。
XDP 程序设置 Hook 点的方式就是将这个 fd 与 一个网卡联系起来，通过 Netlink 消息告诉内核。
int main(int argc, char **argv) { struct rlimit r = {RLIM_INFINITY, RLIM_INFINITY}; struct bpf_prog_load_attr prog_load_attr = { .prog_type = BPF_PROG_TYPE_XDP, }; int prog_fd, map_fd, opt; struct bpf_object *obj; struct bpf_map *map; ---------------------- snprintf(filename, sizeof(filename), "%s_kern.o", argv[0]); prog_load_attr.file = filename; if (bpf_prog_load_xattr(&prog_load_attr, &obj, &prog_fd)) return 1; map = bpf_map__next(NULL, obj); map_fd = bpf_map__fd(map); signal(SIGINT, int_exit); signal(SIGTERM, int_exit); if (bpf_set_link_xdp_fd(ifindex, prog_fd, xdp_flags) < 0) { } err = bpf_obj_get_info_by_fd(prog_fd, &info, &info_len); prog_id = info.id; poll_stats(map_fd, 2); return 0; }
其中 ifindex 为网卡的标识，而 prog_fd 为 load 的 eBPF 程序时返回的 fd
int bpf_set_link_xdp_fd(int ifindex, int fd, __u32 flags) { // code omitted ... nla->nla_type = NLA_F_NESTED | IFLA_XDP; // code omitted ... nla_xdp->nla_type = IFLA_XDP_FD; // code omitted ...
bpf_set_link_xdp_fd 打包 Netlink 消息，消息类型为 IFLA_XDP，子类型为 IFLA_XDP_FD， 表示要关联 bpf_prog
内核收到该 Netlink 消息后, 根据消息类型，最终调用到 dev_change_xdp_fd
do_setlink { // code omitted ... if (tb[IFLA_XDP]) { // code omitted ... if (xdp[IFLA_XDP_FD]) { err = dev_change_xdp_fd(dev, extack, nla_get_s32(xdp[IFLA_XDP_FD]),
expected_fd, xdp_flags); } }
dev_change_xdp_fd 意为为 dev 关联一个 XDP 程序的 fd。它使用网卡设备驱动程序的 do_bpf 方法，进行 XDP 程序的安装
/** * dev_change_xdp_fd - set or clear a bpf program for a device rx path * @dev: device * @extack: netlink extended ack * @fd: new program fd or negative value to clear * @expected_fd: old program fd that userspace expects to replace or clear * @flags: xdp-related flags * * Set or clear a bpf program for a device */ int dev_change_xdp_fd(struct net_device *dev, struct netlink_ext_ack *extack, int fd, int expected_fd, u32 flags) { // return f.file->private_data; 同时检测prog 是否为 TYPE_XDP prog = bpf_prog_get_type_dev(fd, BPF_PROG_TYPE_XDP, bpf_op == ops->ndo_bpf); err = dev_xdp_install(dev, bpf_op, extack, flags, prog); }
每个支持 XDP 的网卡都有自己的 ndo_bpf 实现，以 Intel i40e 为例，其实现为 i40e_xdp
static const struct net_device_ops i40e_netdev_ops = { // code omitted ... .ndo_bpf = i40e_xdp, } static int i40e_xdp(struct net_device *dev, struct netdev_bpf *xdp) { struct i40e_netdev_priv *np = netdev_priv(dev); struct i40e_vsi *vsi = np->vsi; switch (xdp->command) { case XDP_SETUP_PROG: return i40e_xdp_setup(vsi, xdp->prog); // add/remove an XDP program // code omitted ... } static int i40e_xdp_setup(struct i40e_vsi *vsi, struct bpf_prog *prog) { // code omitted ... old_prog = xchg(&vsi->xdp_prog, prog); // code omitted ... for (i = 0; i < vsi->num_queue_pairs; i++) WRITE_ONCE(vsi->rx_rings[i]->xdp_prog, vsi->xdp_prog); }
运行 Hook 点上设置的 eBPF 程序
i40e_clean_rx_irq
|
|- if (!skb) {
xdp.data = page_address(rx_buffer->page) +
rx_buffer->page_offset;
xdp.data_hard_start = (void *)((u8 *)xdp.data -
i40e_rx_offset(rx_ring));
xdp.data_end = (void *)((u8 *)xdp.data + size);
skb = i40e_run_xdp(rx_ring, &xdp);i40e_xdp_setup
}
static struct sk_buff *i40e_run_xdp(struct i40e_ring *rx_ring, struct xdp_buff *xdp) { int result = I40E_XDP_PASS; #ifdef HAVE_XDP_SUPPORT struct i40e_ring *xdp_ring; struct bpf_prog *xdp_prog; u32 act; int err; rcu_read_lock(); xdp_prog = READ_ONCE(rx_ring->xdp_prog); if (!xdp_prog) goto xdp_out; prefetchw(xdp->data_hard_start); /* xdp_frame write */ act = bpf_prog_run_xdp(xdp_prog, xdp); // 运行 eBPF 程序 switch (act) { case XDP_PASS: rx_ring->xdp_stats.xdp_pass++; break; case XDP_TX: xdp_ring = rx_ring->vsi->xdp_rings[rx_ring->queue_index]; result = i40e_xmit_xdp_ring(xdp, xdp_ring); rx_ring->xdp_stats.xdp_tx++; break; case XDP_REDIRECT: ----------------------------- case XDP_DROP: result = I40E_XDP_CONSUMED; rx_ring->xdp_stats.xdp_drop++; break; } xdp_out: rcu_read_unlock(); return (struct sk_buff *)ERR_PTR(-result); }
运行 eBPF 程序就是使用 BPF_PROG_RUN，对于 XDP 类型的程序来说，其参数除了指令(prog->insnsi)外，就是报文(struct xdp_buff* xdp )
#define BPF_PROG_RUN(filter, ctx) (*(filter)->bpf_func)(ctx, (filter)->insnsi) static u32 bpf_prog_run_xdp(const struct bpf_prog *prog, struct xdp_buff *xdp) { return BPF_PROG_RUN(prog, xdp); }