高性能收发原始数据包的框架(Netmap)

一、Netmap 简介

Netmap 是一个高性能收发原始数据包的框架，由 Luigi Rizzo 等人开发完成，其包含了内核模块以及用户态库函数。其目标是，不修改现有操作系统软件以及不需要特殊硬件支持，实现用户态和网卡之间数据包的高性能传递。其原理图如下，数据包不经过操作系统内核进行处理，用户空间程序收发数据包时，直接与网卡进行通信。

下面是我们用了netmap下的情况，你看到了，我们的netmap接收到数据后采用mmap的方式

直接映射到内存上，那么我们取数据就可以直接从内存上取数据，就是从网卡取数据了，不需

要像内核协议栈那样，拷贝两次才行，那么这就大大提高了网络的传输速度

1.数据结构

在 Netmap 框架下，内核拥有数据包池，发送环接收环上的数据包不需要动态申请，有数据到达网卡时，当有数据到达后，直接从数据包池中取出一个数据包，然后将数据放入此数据包中，再将数据包的描述符放入接收环中。内核中的数据包池，通过 mmap 技术映射到用户空间。用户态程序最终通过 netmap_if 获取接收发送环 netmap_ring，进行数据包的获取发送。

2.特点总结

（1）性能高：数据包不走传统协议栈，不需要层层解析，用户态直接与网卡的接受环和发送环交互。性能高的具体原因有一下三个：

（a）系统调用以及处理数据包的时间花费少
（b）不需要进行数据包的内存分配：采用数据包池，当有数据到达后，直接从数据包池中取出一个数据包，然后将数据放入此数据包中，再将数据包的描述符放入接收环中。
（c）数据拷贝次数少：内核中的数据包采用 mmap 技术映射到用户态。所以数据包在到达用户态时，不需要进行数据包的拷贝。
（2）稳定性高：有关网卡寄存器数据的维护都是在内核模块进行，用户不会直接操作寄存器。所以在用户态操作时，不会导致操作系统崩溃

（3）亲和性：可采用了 CPU 亲和性，实现 CPU 和网卡绑定，提高性能。

（4）易用性好：API 操作简单，用户态只需要调用 ioctl 函数即可完成数据包收发工作

（5）与硬件解耦：不依赖硬件，只需要对网卡驱动程序稍微做点修改就可以使用此框架（几十行行），传统网卡驱动将数据包传递给操作系统内核中协议栈，而修改后的数据包直接放入 Netmap_ring 供用户使用。

二、Netmap API 介绍

1.简要说明

netmap API 主要为两个头文件 netmap.h 和 netmap_user.h ，当解压下载好的 netmap
程序后，在./netmap/sys/net/目录下，本文主要对这两个头文件进行分析。
2.我们从 netmap_user.h 头文件开始看起

2.likely()和 unlikely()

这两个宏定义是对编译器做优化的，并不会对变量做什么改变。后面看到这两个宏的调用自动忽略就好了。

#ifndef likely

#define likely(x) #define unlikely(x)

3.netmap.h 头文件

1.netmap.h 被 netmap_user.h 调用，里面定义了一些宏和几个主要的结构体，如 nmreq{}, netmap_if{}, netmap_ring{}, netmap_slot{} 。
2.一个网卡(或者网络接口)只有一个 netmap_if{}结构，在使用 mmap()申请的共享内存中，通过 netmap_if{}结构可以访问到任何一个发送/接收环(也就是 netmap_ring{}结构，一个netmap_if{}可以对应多发送/接收环,这应该和物理硬件有关，我在虚拟机下只有一对环，在真实主机上有两队环)。
3.找到 netmap_ring{}的地址后，我们就可以找到环中每一个 buffer 的地址(buffer 里面存储的是将要发送/接收的数据包)。后面会讲解这是如何实现的。
4.通过一个 nifp 是如何访问到多个收/发环的，通过一个 ring 如何找到多个不同的 buffer 地址的，其实都是通过存储这些结构体相邻的后面一部分空间实现。(申请共享内存的时候，这些均已被设计好)

4.几个重要的宏定义

1._NETMAP_OFFSET

解释：该宏定义的作用是将 ptr 指针(强转成 char *类型)向右偏移 offset 个字节，再将其转化为指定的类型 type。

2.NETMAP_IF
解释：该宏定义将_base 指针向右偏移_ofs 个字节后，强转为 netmap_if *类型返回。在 nemap中通过此宏得到 d->nifp 的地址。

3.NETMAP_TXRING
解释：

1.通过该宏定义，可以找到 nifp 的第 index 个发送环的地址(index 是从 0 开始的)，ring_ofs[index]为偏移量，由内核生成。
2.其中，我们注意到 struct netmap_if{}最后面只定义了 const ssize_t ring_ofs[0]，实际上其它的 netmap 环的偏移量都写在了该结构体后面的内存地址里面，直接访问就可以了。
4.NETMAP_RXRING
解释：通过该宏定义，可以找到 nifp 的第 index 个接收环的地址，其中(nifp)->ring_ofs[]里面的下标为 index+(nifp)->ni_tx_rings+1，正好与发送环的偏移量区间隔开 1 个。(我想这应该是作者特意设计的)

5.NETMAP_BUF
解释：

1.通过该宏定义，可以找到 ring 这个环的第 index 个 buffer 的地址(buffer 里面存的就是我们接收/将发送的完整数据包)，每个 buffer 占的长度是 2048 字节(在(ring)->nr_buf_size
也给出了)。
2.其中(ring) ->buf_ofs 是固定的偏移量，不同的环这个值不相同，但所有的(char *)(ring)+(ring)->buf_ofs 会指向同一个地址，也就是存放 buffer 的连续内存的开始地址 (d->buf_start 会指向该地址)。
6.NETMAP_BUF_IDX
解释：

在讲 NETMAP_BUF 的时候我们说(char *)(ring) + (ring)->buf_ofs)总会指向存放 buffer
的起始位置( 无论是哪一个环)，在这段内存中将第一个 buffer 下标标记为 0 的话，
NETMAP_BUF_IDX 计算的恰好是指针 buf 所指 buffer 的下标。上面几个宏一时没弄懂也没关系，下面调用的时候还会提的。

5.nm_open 函数(主要功能是打开设备，申请并创建初始化出fd所需要的内存)

1.调用 nm_open 函数时，如：nmr = nm_open(“netmap:eth0”, NULL, 0, NULL); nm_open()会对传递的 ifname 指针里面的字符串进行分析，提取出网络接口名。

2.nm_open() 会对 struct nm_desc *d 申请内存空间，并通过 d->fd = open(NETMAP_DEVICE_NAME,O_RDWR);打开一个特殊的设备/dev/netmap 来创建文件描述符d->fd。

3.通过 ioctl(d->fd, NIOCREGIF, &d->req)语句，将 d->fd 绑定到一个特殊的接口，并对 d->req
结构体里面的成员做初始化，包括 a.在共享内存区域中 nifp 的偏移，b.共享区域的大小
nr_memsize，c.tx/rx 环的大小 nr_tx_slots/nr_rx_slots(大小为 256)，d.tx/rx 环的数量 nr_tx_rings、
nr_rx_rings(视硬件性能而定)等。

4.接着在 if ((!(new_flags & NM_OPEN_NO_MMAP) || parent) && nm_mmap(d, parent))语句中调用 nm_mmap 函数，继续给 d 指针指向的内存赋值。

6.nm_mmap 函数(映射函数)

nm_mmap()源码：

static int nm_mmap(struct nm_desc *d, const struct nm_desc *parent) 
{ 
//XXX TODO: check if mmap is already done 
 
    if (IS_NETMAP_DESC(parent) && parent->mem && parent->req.nr_arg2 
== d->req.nr_arg2) 
    { 
        /* do not mmap, inherit from parent */ 
        D("do not mmap, inherit from parent"); 
        d->memsize = parent->memsize; 
        d->mem = parent->mem; 
    } else 
    { 
        /* XXX TODO: 检查如果想申请的内存太大 (or there is overflow) 
*/ 
        d->memsize = d->req.nr_memsize;      /* 将需要申请的内存大小赋值给 d->memsize */ 
        d->mem = mmap(0, d->memsize, PROT_WRITE | PROT_READ, MAP_SHARED, d->fd, 0); /* 申请共享内存 */ 
        if (d->mem == MAP_FAILED) 
        { 
            goto fail; 
        } 
        d->done_mmap = 1; 
    } 
    { 
     struct netmap_if *nifp = NETMAP_IF(d->mem, d->req.nr_offset);  
/*通过 d->req.nr_offset 这个偏移量的到 nifp 的地址，NETMAP_IF 前面说过
*/ 
        int i; 
        /* 
         *for(i=0; i<=2; i++) 
         *   printf("ring_ofs[%d]:0x%x\n",i,nifp->ring_ofs[i]);   // 这里是我自己加的，为了手动计算收/发环的偏移量 
         */ 
        struct netmap_ring *r = NETMAP_RXRING(nifp,); //对 nifp，找接收包的环 r，因为 index 为 0，所以省略了 
 
        *(struct netmap_if **) (uintptr_t) &(d->nifp) = nifp; // 对d->nifp 赋值，虽然 d->nifp 使用 const 定义的，但对其取地址再强值类型转换后，依然可以对其指向的空间进行操作 
        *(struct netmap_ring **) (uintptr_t) &d->some_ring = r; //同理，对 d->some_ring 进行赋值，此处指向了第一个接受(rx)环。 
        //printf("buf_ofs:0x%x\n", (u_int)r->buf_ofs); 
        *(void **) (uintptr_t) &d->buf_start = NETMAP_BUF(r, 0);//计算第一个 buffer 的地址，并存入 d->buf_start 指针中 
        *(void **) (uintptr_t) &d->buf_end = (char *) d->mem + d->memsize; //计算共享区间的最后一个地址，赋值给 d->buf_end 
    } 
 
    return 0; 
 
    fail: return EINVAL; 
}

7.nm_nextpkt 函数

1.nm_nextpkt()是用来接收网卡上到来的数据包的函数。
2.nm_nextpkt()会将所有 rx 环都检查一遍，当发现有一个 rx 环有需要接收的数据包时，得到这个数据包的地址，并返回。所以 nm_nextpkt()每次只能取一个数据包。

nm_nextpkt()源代码：

static u_char *nm_nextpkt(struct nm_desc *d, struct nm_pkthdr *hdr) 
{ 
    int ri = d->cur_rx_ring; //当前的接收环的编号 
    do 
    { 
        /* compute current ring to use */ 
        struct netmap_ring *ring = NETMAP_RXRING(d->nifp, ri); // 得到当前 rx 环的地址 
        if (!nm_ring_empty(ring)) //判断环里是否有新到的包 
        { 
            u_int i = ring->cur; //当前该访问哪个槽(buffer)了 
            u_int idx = ring->slot[i].buf_idx; //得到第 i 个 buffer 的下标 
            //printf("%d\n", idx); 
            u_char *buf = (u_char *) NETMAP_BUF(ring, idx); //得到存有到来数据包的地址 
 
            // builtin_prefetch(buf); 
            hdr->ts = ring->ts; 
            hdr->len = hdr->caplen = ring->slot[i].len; 
            ring->cur = nm_ring_next(ring, i); //ring->cur 向后移动一位 
            /* we could postpone advancing head if we want 
             * to hold the buffer. This can be supported in 
             * the future. 
             */ 
            ring->head = ring->cur; 
            d->cur_rx_ring = ri; //将当前环(d->cur_rx_ring)指向第 ri 个(因为可能有多个环)。 
            return buf; //将数据包地址返回 
        } 
        ri++; 
        if (ri > d->last_rx_ring) //如果 ri 超过了 rx 环的数量，则再从第一个 rx 环开始检测是否有包到来。 
            ri = d->first_rx_ring; 
    } while (ri != d->cur_rx_ring); 
    return NULL; /* 什么也没发现 */ 
}

8.nm_inject 函数

1.nm_inject()是用来往共享内存中写入待发送的数据包数据的。数据包经共享内存拷贝到网卡，然后发送出去。所以 nm_inject()是用来发包的。
2.nm_inject()也会查找所有的发送环(tx 环)，找到一个可以发送的槽，就将数据包写入并返回，所以每次函数调用也只能发送一个包。

static int nm_inject(struct nm_desc *d, const void *buf, size_t size) 
{ 
    u_int c, n = d->last_tx_ring - d->first_tx_ring + 1; 
 
    for (c = 0; c < n; c++) 
    { 
        /* 计算当前的环去使用(compute current ring to use) */ 
        struct netmap_ring *ring; 
        uint32_t i, idx; 
        uint32_t ri = d->cur_tx_ring + c; //该访问第几个 tx 环了 
 
        if (ri > d->last_tx_ring) //当超过访问的 tx 环的下标范围时， 从头开始访问 
            ri = d->first_tx_ring; 
        ring = NETMAP_TXRING(d->nifp, ri); //得到当前 tx 环的地址 
        if (nm_ring_empty(ring)) //如果当前 tx 环是满的(ring->cur=ring->tail 表示没地方存数据包了)，就跳过 
        static int nm_inject(struct nm_desc *d, const void *buf, size_t size) 
{ 
    u_int c, n = d->last_tx_ring - d->first_tx_ring + 1; 
 
    for (c = 0; c < n; c++) 
    { 
        /* 计算当前的环去使用(compute current ring to use) */ 
        struct netmap_ring *ring; 
        uint32_t i, idx; 
        uint32_t ri = d->cur_tx_ring + c; //该访问第几个 tx 环了 
 
        if (ri > d->last_tx_ring) //当超过访问的 tx 环的下标范围时， 从头开始访问 
            ri = d->first_tx_ring; 
        ring = NETMAP_TXRING(d->nifp, ri); //得到当前 tx 环的地址 
        if (nm_ring_empty(ring)) //如果当前 tx 环是满的(ring->cur=ring->tail 表示没地方存数据包了)，就跳过