借助libbpf/libxdp使用AF_XDP，我们都需要做什么——以一个简单程序为例

最新推荐文章于 2024-08-20 18:38:00 发布
最新推荐文章于 2024-08-20 18:38:00 发布
阅读量3.6k 收藏 16
点赞数 11
文章标签： 网络 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tunmang5421/article/details/128195304
版权

前言

AF_XDP是一种Linux提供的针对高性能数据包处理进行优化的地址族协议，为了进一步的理解和熟悉，我们以一个返回IPv4 ICMP Ping报文的程序为例，看看借助libbpf/libxdp使用AF_XDP，我们都需要做什么。例程不做复杂处理，就只是简单的交换源/目的IP、MAC，修改ICMP头部的type字段为ICMP_ECHOREPLY，最后重新计算ICMP头部校验和；

ICMP的校验和是要校验ICMP首部和数据部分的，当时没注意这点导致程序卡了半天……

涉及两部分程序：

  • XDP程序，需要挂载到我们使用的网卡接口上；（注意别用本地的lo接口，虽然试过可以加载SKB模式的XDP程序，但是容易出乱子）
  • 用户程序，用于创建umem、xsk、处理各个ring收发包、处理数据包等；

先说XDP程序

XDP程序其实比较简单了，甚至更简单一点，我们可以直接用libbpf/libxdp[^libbpf和libxdp]提供的默认XDP程序；

libbpf/libxdp提供的xsk_socket__create函数，如果给其提供的配置参数struct xsk_socket_config *为空或者将其中的libbpf_flags / libxdp_flags置为0，就会默认加载一个简单的XDP程序到所给出的接口，把所有配置的queue_id对应的网卡队列收到的包都redirect到该xsk；

如果将其中的libbpf_flags / libxdp_flags置为XSK_LIBBPF_FLAGS__INHIBIT_PROG_LOAD或XSK_LIBXDP_FLAGS__INHIBIT_PROG_LOAD，就可以禁止默认XDP程序的加载，后边就得自己写程序自己加载和更新xsks_map映射了，但这样能让程序更可控一些；

我们还是自己写一个XDP程序，过滤出IPv4 ICMP报文，将其redirect到XSK，其余数据包则是通过XDP_PASS给内核去继续处理；顺便通过ELF约定格式，预定义BPF_MAP_TYPE_XSKMAP类型的xsks_map，等会儿用户程序创建好xsk了需要更新[queue_idx, xsk_fd]键值对到该映射中；

给出程序：

/* SPDX-License-Identifier: GPL-2.0 */

#include <linux/bpf.h>
#include <linux/if_ether.h>
#include <linux/ip.h>
#include <linux/in.h>

#include <bpf/bpf_endian.h>
#include <bpf/bpf_helpers.h>

struct {
	__uint(type, BPF_MAP_TYPE_XSKMAP);
	__uint(max_entries, 64);
	__type(key, int);
	__type(value, int);
} xsks_map SEC(".maps");

SEC("xdp")
int xdp_prog(struct xdp_md *ctx)
{
	__u32 off;
	void *data_end = (void *)(long)ctx->data_end;
	void *data = (void *)(long)ctx->data;

	struct ethhdr *eth = data;
	struct iphdr *ip = data + sizeof(*eth);

	off = sizeof(struct ethhdr);
	if (data + off > data_end) // To pass verifier
		return XDP_PASS;

	if (bpf_htons(eth->h_proto) == ETH_P_IP) {

        off += sizeof(struct iphdr);
		if (data + off > data_end) // To pass verifier
			return XDP_PASS;
		/* We redirect IPv4 ICMP pkts only. */
		if (ip->protocol == IPPROTO_ICMP) {
			int idx = ctx->rx_queue_index;
            /* 如果idx对应网卡队列已绑定xsk并更新到了xsks_map中，数据包就会被redirect到该xsk */
			if (bpf_map_lookup_elem(&xsks_map, &idx)) {
				return bpf_redirect_map(&xsks_map, idx, 0);
			}
		}
	}
	return XDP_PASS;
}

char _license[] SEC("license") = "GPL";

再看用户程序

既然是redirect到用户空间，主要工作都在用户空间，包括创建umem、xsk、处理各个ring收发包、处理数据包等。

好在有libbpf/libxdp的帮助我们能让事情变得简单点。

我的例程按顺序分以下几个步骤：

  • 创建和配置UMEM、XSK

  • 加载挂载XDP程序到对应的网络接口上（预定义的xsks_map也会在这一步创建）

  • 将我们要绑定的queue_id和得到的xsk_fd更新到xsks_map

  • 收包、处理包、发包

  • 还有就是可以另外创建个线程用于打印收发包状态，我们就忽略了；

创建和配置UMEM

一句话总结就是：

分配和对齐umem所需的内存，通过libxdp提供的xsk_umem__create创建umem。

UMEM是用户空间存放数据包的地方，是预申请好的连续的一整块内存，其中每个元素我们称作一个chunk；

libxdp虽然提供了UMEM创建函数，umem的内存分配和对齐什么的还是得自己做；

关于xsk_umem__create函数自己写了一个描述：

/*!
 * @fn int xsk_umem__create(
 *				struct xsk_umem **umem,
 *				void *umem_area,
 *				__u64 size,
 *				struct xsk_ring_prod *fill,
 *				struct xsk_ring_cons *comp,
 * 				const struct xsk_umem_config *config);
 *
 * @brief   创建umem，XSK收到的包和待发送的包都会放到umem中
 *
 * @param[out] *umem: 我理解算是一个umem的opaque handle，并不是给你用结构体具体内容的
 * @param[in] *umem_area: 提前分配好的umem内存的起始地址
 * @param[in] size: umem大小(Byte)，即umem中元素大小乘元素个数
 * @param[out] *fill: fill ring
 * @param[out] *comp: completion ring
 * @param[in] *config: umem创建相关的配置，传入NULL以使用默认配置
 *
 * @retval 0    Success
 * @retval else Fail
 */

这其中的struct xsk_umem_config：

struct xsk_umem_config {
	__u32 fill_size; // FILL Ring的大小(元素个数), 默认2048，也就是默认UMEM总元素个数的一半
	__u32 comp_size; // COMP Ring的大小(元素个数)，默认2048，也就是默认UMEM总元素个数的一半
	__u32 frame_size; // UMEM数据帧大小(Byte)，即UMEM中每个元素(我们叫chunk)的大小，默认4096B
	__u32 frame_headroom; // (Byte)，如果设置了，那么报文数据将不是从每个chunk的起始地址开始存储，而是要预留出headroom大小的内存，再开始存储报文数据，headroom在隧道网络中比较常见，方便封装外层头部；默认0B
	__u32 flags; // 不知道作甚的，默认0
};

创建和配置XSK

一句话总结就是：

通过libxdp提供的创建XSK的函数：xsk_socket__create，创建xsk。

想多个xsk共用一个umem的话还有这个函数：xsk_socket__create_shared，这里不涉及；

关于xsk_socket__create函数自己写了一个描述：

/*!
 * @fn int int xsk_socket__create(
 *				  struct xsk_socket **xsk,
 *				  const char *ifname, 
 *   			  __u32 queue_id,
 *				  struct xsk_umem *umem,
 *				  struct xsk_ring_cons *rx,
 *				  struct xsk_ring_prod *tx,
 *				  const struct xsk_socket_config *config);
 *
 * @brief   创建xsk
 *
 * @param[out] *xsk: 我理解算是一个xsk的opaque handle，并不是给你用结构体具体内容的
 * @param[in]  ifname: 待绑定的接口名称
 * @param[in]  queue_id: 待绑定的接口队列id
 * @param[in]  *umem: 刚才创建umem得到的指针
 * @param[out] *rx: RX Ring
 * @param[out] *tx: TX Ring
 * @param[in]  *config: xsk创建相关的配置，传入NULL以使用默认配置
 *
 * @retval 0    Success
 * @retval else Fail
 */

此线内为帮助理解的附件：

我们知道，XSK的操作涉及四个Ring：RX、TX、Fill和Completion Ring；都是单生产者单消费者（SCSP）模型，需要内核或者用户程序先生产了，对方才能消费；

对Fill Ring来说，用户程序作为生产者，得先生产一些元素，我们统一叫desc，这些desc指向umem中的某个chunk，这样内核才能作为消费者，拿走这些desc，找到desc指向的umem的chunk，再把收到的数据包放到该chunk中，示意图：
在这里插入图片描述
对Rx Ring来说：内核存放完数据以后，会往RX Ring生产对应的desc，指向刚才放好数据的chunk；用户程序即可消费RX Ring中的desc，进一步直接处理desc指向的chunk中存放的数据包；

TX和Completion Ring同理；

Ring中存放的元素具体是什么？

FILL Ring和Completion Ring中存放的元素是地址，即相对于umem起始地址buffer的字节偏移量（completion ring这个等我确认一下先）；

libxdp有专门的两个帮助函数用于访问Fill Ring和Completion Ring某个下标idx处的地址的函数：

__u64 *xsk_ring_prod__fill_addr(struct xsk_ring_prod *fill, __u32 idx);
const __u64 * xsk_ring_cons__comp_addr(const struct xsk_ring_cons *comp, __u32 idx);

而RX Ring和TX Ring其中存放的desc元素，是struct xdp_desc，具体结构：

struct xdp_desc{
	__u64 addr;		// 该desc指向的地址，其实是相对于umem起始地址buffer的字节偏移量
    __u32 len;		// 该desc中数据的长度（Byte）
    __u32 options;	// 其他选项，不知道能有啥
}

libxdp还有专门的两个帮助函数用于应用程序访问RX Ring和TX Ring某个下标idx处的xdp_desc指针：

struct xdp_desc *xsk_ring_prod__tx_desc(struct xsk_ring_prod *tx, __u32 idx);
const struct xdp_desc *xsk_ring_cons__rx_desc(const struct xsk_ring_cons *rx, __u32 idx);

Ring的访问方式？

各个Ring是通过下标访问的，虽然更多是叫生产者/消费者指针；看Ring的结构：

#define DEFINE_XSK_RING(name) \
struct name { \
	__u32 cached_prod; \	// 缓存的生产者下标，意思是，接下来要生产的话，从这个下标开始生产
	__u32 cached_cons; \	// 缓存的消费者下标，意思是，接下来要开始消费的话，从这个下标开始消费
	__u32 mask; \			// 掩码的作用，与它相与就可以得到0~(size-1)之间的值，mask值就是size - 1
	__u32 size; \			// ring大小（desc元素个数）
	__u32 *producer; \		// 指向实时的生产者下标
	__u32 *consumer; \		// 指向实时的消费者下标
	void *ring; \			// ring指向起始desc元素
	__u32 *flags; \			// 
}

DEFINE_XSK_RING(xsk_ring_prod);
DEFINE_XSK_RING(xsk_ring_cons);

将下标与mask（值为size - 1）相与&，就能保证随着idx的增加，访问效果像是在访问一个环；

descs[idx & mask]

创建完XSK，我们再填充FILL Ring，即向FILL Ring中生产desc，本例中是直接把FILL Ring填满了；

填充的大体步骤为：

  1. 通过xsk_ring_prod__reserve(fill, nb, idx)向FILL Ring申请预留nb个desc空间，得到起始下标idx，准备填充；

    这些函数细节其实不需要知道，但由于涉及cached_prod和prod的关系，我还是把我的理解放在这；

    size_t xsk_ring_prod__reserve(struct xsk_ring_prod *prod, size_t nb, __u32 *idx)

    预留nb个desc空间，首先是查询当前ring是不是有把当前申请的这么多desc空间，不够的话返回0，够的话将cached_prod赋值给要返回的idx，告诉程序从这个idx开始生产desc，随后cached_prod += nb，返回nb；

  2. 填充，即填充对应的地址（相对于umem起始地址的字节偏移量）到FILL Ring中，从xsk_ring_prod__reserve得到的idx开始填；

  3. 填充完毕以后，通过xsk_ring_prod__submit(fill, nb)提交nb个desc，实时的生产者下标producer会后移nb；

    XDP_ALWAYS_INLINE void xsk_ring_prod__submit(struct xsk_ring_prod *prod, __u32 nb) {
	/* Make sure everything has been written to the ring before indicating
	 * this to the kernel by writing the producer pointer.
	 */
	__atomic_store_n(prod->producer, *prod->producer + nb, __ATOMIC_RELEASE);
}

    提交以后，实时的producer才会后移，这里的操作是原子性的，我也不理解为什么这都需要原子性操作，明明一个xsk只有一个producer指针，而且应该只有一个线程在操作它吧；

加载挂载XDP程序到对应的网络接口上

我们直接复用xdp-tools的xdp-loader，免得自己再写加载的部分，怪麻烦的；

将我们要绑定的queue_id和得到的xsk_fd更新到xsks_map

由于没有用libxdp提供的XDP程序和xsks_map映射，我们需要自己去更新映射；

其中key为指定绑定的queue_id，value为xsk的fd，可以通过libxdp提供的帮助函数xsk_socket__fd从struct xsk_socket *xsk指针中拿到；

int xsk_fd = xsk_socket__fd(xsk);
err = bpf_map_update_elem(xsks_map_fd, &opt->xsk_if_queue, &xsk_fd, BPF_ANY);

收包、处理包、发包

和传统的recv收包不同，AF_XDP收包需要看RX Ring，另外也可以通过poll等方式去等待xsk收包；

libxdp中的函数：

size_t xsk_ring_cons__peek(struct xsk_ring_cons *cons, size_t nb, __u32 *idx)

就是用于应用程序从ring中消费的，（函数命名都很规范，看名称就知道是干啥的），peek意为窥视、窥探，也就是探一下cons ring中有没有nb个空闲元素可供消费，没有的话返回0，有的话返回空闲元素个数，最多不超过nb（相当于批处理最多nb个元素）；

大致流程：

  • 内核收到包，消费FILL Ring中的umem地址，将数据包存放到对应地址中，再作为生产者将对应的desc填充到RX Ring中；

  • 随后xsk_ring_cons__peek发现有了一些空闲desc可供消费处理，于是返回可供处理的空闲desc个数，以及起始desc的消费者指针（下标）idx；

  • 这之后就可以用libxdp提供的函数：xsk_ring_cons__rx_desc拿到对应下标的desc，进一步取到desc中的地址addr和数据长度len，再进一步可以通过libxdp提供的帮助函数：void *xsk_umem__get_data(void *umem_area, __u64 addr)拿到具体的data指针，后边就随你解析和操作了，具体的操作也就是：交换源目的IP和MAC，修改ICMP头部的type为reply，重新计算ICMP的校验和；

    void *xsk_umem__get_data(void *umem_area, __u64 addr)中，umem_area是分配给umem的起始地址，后面的addr是desc中的addr，即相对于umem起始地址的字节偏移量，emm不如直接放原函数：

    XDP_ALWAYS_INLINE void *xsk_umem__get_data(void *umem_area, __u64 addr)
{
return &((char *)umem_area)[addr];
}

  • 处理完以后，我们就需要通过TX Ring通知内核发送数据包了，过程和前面填充FILL Ring非常类似：

    • 首先通过libxdp提供的帮助函数xsk_ring_prod__reserve(&xsk->tx, nb, &idx)，从TX Ring中申请预留nb个desc；
    • 随后填充这些desc*（其实就是用我们前面收到数据包的地址和长度填充，毕竟我们处理完数据包长度和地址都没变）*；
    • 最后通过libxdp提供的帮助函数xsk_ring_prod__submit(&xsk->tx, nb)，提交nb个desc给TX Ring；
    • 内核看到TX Ring有空闲后就会消费掉其中的desc（指把desc对应umem中的数据包发送出去）；发送完毕后将用完的地址生产到Completion Ring中，应用再消费这些地址（指把这些地址再放回Fill Ring中，继续下一波循环……）；

总结

核心部分其实就是在四个Ring之间来回生产和消费，理解清楚这部分以后，AF_XDP用起来就得心应手了；再次从总体上总结一下几个Ring之间的循环：

  • FILL Ring | 用户生产

    把空闲的umem地址放到FILL Ring中；

  • FILL Ring | 内核消费

    将收到的包放到FILL Ring中空闲的umem地址；

  • RX Ring | 内核生产

    收包完毕后的desc放入RX Ring中；

  • RX Ring | 用户消费

    取收包完毕后的desc，处理数据包；

    如果无需发送，这个desc的地址到这就已经没用了，可以再生产给FILL Ring了；

  • TX Ring | 用户生产

    将准备好的desc放到TX Ring中；

    如果只涉及发送，还需要把desc对应umem中的frame写好；

  • TX Ring | 内核消费

    内核将准备好的desc拿走，将对应umem中的数据包发送出去；

  • Comp Ring | 内核生产

    内核发送完毕后，将desc中的地址放到Comp Ring中；

  • Comp Ring | 用户消费

    用户拿到Comp Ring中的地址，即得知该地址已经空闲了，可以继续填到FILL Ring或者继续填到TX Ring了

  • ……

还是想做个动图，假设我们的数据包速度足够慢，可以让这个循环一个个数据包地完美运行：

请添加图片描述
注：为了简便，每个umem chunk的大小假定为1，以及图示和例程中操作空闲chunk的方式不太一样，但对四个Ring的操作是类似的，具体以程序为准。

WuPeng_uin
关注
使用libbpf-bootstrap构建第一个libbpf+BPF CO-RE程序
weixin_43144516的博客
07-16 5232
文章目录前言选择libbpf+BPF CO-RE的理由使用libbpf-bootstrap的理由Libbpf-bootstrap结构Minimal:最小应用程序分析运行minimal：代码分析：BPF side代码分析：User space sideMakefile分析动手构建属于自己的Hello World程序 前言 本文参考了相关博客：Building BPF applications with libbpf-bootstrap 选择libbpf+BPF CO-RE的理由 libbpf 是一个比BCC更
DPDK AF_XDP
奋斗中拥有
05-26 4112
DPDK AF_XDP AF_XDP 是 kernel v4.18+ 新加入的一个协议族(如AF_INET), 主要使用 XDP 实现(下图是 XDP 的基本原理图). 核心原理是在 kernel NAPI poll 位置(网卡驱动内部实现, 为内核最早RX数据包位置)运行 BPF 程序, 通过不断调用 poll 方法, 最终将数据包送到正确的XDP程序处理. XDP 支持 3 种工作模式: Native XDP -运行在网卡驱动实现的 poll 函数中, 需网卡驱动支持; Offloaded X
搭建 ebpf 开发测试环境
alittlefish1的博客
12-03 335
这部分主要讲述了如何通过官网学习ebpf，以及如何搭建自己的ebpf开发测试环境，主要是需要安装哪些工具链。
ebpf教程(4.1):XDP程序的加载
最新发布
大草的博客
08-20 802
ebpf教程(4.1):XDP程序的加载
AF_XDP socket 测试
u010643777的专栏
02-26 1249
linux xdp例子测试
XDP环境搭建
qq_38684512的博客
03-20 331
【代码】XDP环境搭建。
kxdpgun ——AF_XDP使用的示例分析（一）
qq_45675153的博客
07-07 785
[TOC] kxdpgun ——AF_XDP使用的示例分析（一）
AF_XDP
tunmang5421的博客
09-11 1979
目录前言AF_XDP概述 前言 本文翻译自https://www.kernel.org/doc/html/latest/networking/af_xdp.html，刚开始学AF_XDP，翻译或有纰漏，还请指出。 文中使用(斜体文字)标出了本人翻译中的疑问，后续围绕本文继续完善概念。 AF_XDP 概述 AF_XDP是优化的地址族，用于高性能包处理。 本文假定读者熟知BPF和XDP，如果对它们不熟悉，Cilium项目对其有一份优秀的指南cilium.readthedocs.io/en/latest/bpf/
kxdpgun ——AF_XDP使用的示例分析（二）
qq_45675153的博客
07-10 792
knot_xdp_send调用了prot_write_eth，而prot_write_eth又调用了prot_write_ipv6/prot_write_ipv4，以此类推写完了报文头部。knot_xdp_send函数首先调用xsk_prod_nb_free查看tx中有没有足够的空闲单元，然后向tx ring中写入msg不为空的报文，最后调用xsk_ring_prod__submit提交写操作。最后调用knot_xdp_send_finish，结束发送过程，本质上是调用了sento。
AF_XDP PMD in DPDK
weixin_37097605的博客
03-25 2261
“常通风、勤洗手、戴口罩、少聚集。”AF_XDP(AddressFamily eXpress Data Path) 和AF_INET,AF_PACKET...
libxdp-1.1.1-2.el8.i686.rpm
01-13
官方离线安装包，测试可用。使用rpm -ivh [rpm完整包名] 进行安装
基于eBPF/XDP快速转发
04-02
eBPF（Extended Berkeley Packet Filter）是Linux内核中的一个技术，它提供了一种安全、灵活的机制来在内核中执行用户定义的程序，而无需修改内核代码。XDP（eXpress Data Path）是eBPF的一种应用，用于在网络数据包...
xdp.rar_MC9S12XDP512 UC_XDP_ucos ii xga_ucos 飞思卡尔_双核
09-14
他们需要编写设备驱动程序来驱动MC9S12XDP512的外设，同时还需要设计合理的任务调度策略，确保双核的协同工作。此外，为了调试和测试，他们可能还使用了诸如JTAG或串口通信等工具，以监控系统的运行状态。 总的来说...
libbpf: Error in bpf_object__probe_name():Operation not permitted(1). Couldn't load basic 'r0 = 0' BPF program. libbpf: Error in bpf_object__probe_global_data():Operation not permitted(1). Couldn't create simple array map. libbpf: failed to create map (name: 'drop_map'): Operation not permitted(-1) libbpf: failed to load object 'xdp_prog.o' ./xdp_drop_user: can't load file xdp_prog.o: Operation not permitted
05-31
您可以尝试使用sudo来运行您的程序或者使用setcap命令给予您的程序CAP_SYS_ADMIN和CAP_SYS_RESOURCE权限，以便您的程序可以运行BPF程序和创建BPF Map。另外，您还需要确保您的内核支持BPF功能。 以下是一个示例命令...
AF_XDP技术简介
天翼云开发者社区
03-30 1083
如果驱动程序不支持 XDP，或者在加载 XDP 程序时显式选择了 XDP_SKB，则采用 XDP_SKB 模式，该模式将 SKB复制到用户空间，适用于任何网络设备的后备模式，该模式在协议栈开始处运行。环是通过 _RING setsockopt 系统调用配置和创建的，然后使用 mmap() 的适当偏移量（XDP_PGOFF_RX_RING、XDP_PGOFF_TX_RING、XDP_UMEM_PGOFF_FILL_RING 和 XDP_UMEM_PGOFF_COMPLETION_RING）映射到用户空间。
网络编程之XDP技术应用
fpcc的专栏
06-10 1051
在上文中介绍了XDP技术，XDP技术的基本原理已经明白，但有一个问题，一个技术如何落地，如何在实际中应用？这就需要有一个承载其的具体的形式。举一个例子，网络编程一般使用Socket方式，那么能不能够在这种方式里使用XDP技术呢？答案是肯定的。 Linux在内核中提供了AF_XDP套接字编程，这就意味着，大部分的编程方式仍然可以以原来的套接字编程为主。这样的好处显而易见，对开发者和维护者来说，都是相对要容易理解和支持。AF_XDP类似于AF_NET（TCP/IP等）等一样，是一个协议族，大家有没有记得在TCP
【转载】AF_XDP技术详解
wsg1100
08-27 977
XDP 定义了一个受限的执行环境（a limited execution environment），运行在一个 eBPF 指令虚拟机中，由网络数据事件触发eBPF虚拟机执行XDP程序指令，使用XDP 提供的 XDP_REDIRECT 操作，可以将将接收的网络包重定向到其他启用 XDP 的设备发送出去或者重定向到其他CPU处理。 AF_XDP是一个基于XDP实现的协议族（例如AF_NET），主要用于高性能报文处理。...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WuPeng_uin

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值