dpdk网卡收发包分析
——lvyilong316
在前面我们分析过dpdk程序启动过程中的对网卡设备初始化已经绑定驱动的逻辑。但是仅仅这样程序还不能正常的收发数据包，因为程序启动通过rte_eal_init初始化的仅仅是设备的基本结构，和网卡设备转发相关的配置以及队列的初始化，是由应用程序自身调用相应api来完成的。
我们以dpdk example中的l2fwd为例，分析一下通常网卡转发的初始化和转发逻辑，由于不同网卡由和驱动有关，我们这里以intel的82599网卡为例，其对应驱动为drivers\net\ixgbe。我们分为两个部分分析，第一部分是网卡设备信息的配置及启动，第二部分是数据包的收发。
1.1 网卡设备信息的配置及启动
正常配置网卡设备信息由如下五步组成：
(1) 创建一个mbuf_pool：rte_pktmbuf_pool_create；
(2) 配置队列的个数，以及接口的配置信息： rte_eth_dev_configure；
(3) 使用之前创建mbuf_pool初始化每个接收队列：rte_eth_rx_queue_setup；
(4) 初始化发送队列：rte_eth_tx_queue_setup；
(5) 启动设备：rte_eth_dev_start。
第一步创建mbuf pool的逻辑我们不再分析，但这里重点说一下这个mbuf pool的作用。这个mbuf pool主要是给网卡接收数据包提供mbuf的，换句话说网卡通过DMA收到数据需要把数据包通过DMA传送到一块内存，正式这个mbuf pool中的内存。另一方面，既然是个pool，那么这个mbuf pool就可以被一个设备的多个接收队列使用，或者是多个队列使用，因为归根结底网卡接收使用的是pool中的mbuf，至于mbuf是来自一个pool还是多个pool并不重要。下面我们逐个分析其余的四步。
1.1.1 rte_eth_dev_configure
-
/*
-
* @port_id：设备对应的port_id，即rte_eth_dev在全局数组rte_eth_devices的下标
-
* @nb_rx_q：配置的接收队列个数；
-
* @nb_tx_q：配置的发送队列个数；
-
* @dev_conf：设备的其他具体配置信息，如收发模式，速率等；
-
*/
-
int
-
rte_eth_dev_configure(uint8_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
-
const struct rte_eth_conf *dev_conf)
-
{
-
struct rte_eth_dev *dev;
-
struct rte_eth_dev_info dev_info;
-
int diag;
-
-
/*......*/
-
/* 获取对应的设备结构 */
-
dev = &rte_eth_devices[port_id];
-
-
RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP);
-
RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_configure, -ENOTSUP);
-
/* 如果设备已经开启，则返错 */
-
if (dev->data->dev_started) {
-
RTE_PMD_DEBUG_TRACE(
-
"port %d must be stopped to allow configuration\n", port_id);
-
return -EBUSY;
-
}
-
/* 将设备的配置信息拷贝到设备结构中 */
-
/* Copy the dev_conf parameter into the dev structure */
-
memcpy(&dev->data->dev_conf, dev_conf, sizeof(dev->data->dev_conf));
-
-
/*
-
* Check that the numbers of RX and TX queues are not greater
-
* than the maximum number of RX and TX queues supported by the
-
* configured device.
-
*/
-
/* 调用具体的设备驱动函数获取设备的信息，主要是为了和将要配置的一些信息对比，做检查 */
-
(*dev->dev_ops->dev_infos_get)(dev, &dev_info);
-
/* 配置队列的个数不能为0 */
-
if (nb_rx_q == 0 && nb_tx_q == 0) {
-
RTE_PMD_DEBUG_TRACE("ethdev port_id=%d both rx and tx queue cannot be 0\n", port_id);
-
return -EINVAL;
-
}
-
/* 配置的队列个数不能超过设备支持的最大值 */
-
if (nb_rx_q > dev_info.max_rx_queues) {
-
RTE_PMD_DEBUG_TRACE("ethdev port_id=%d nb_rx_queues=%d > %d\n",
-
port_id, nb_rx_q, dev_info.max_rx_queues);
-
return -EINVAL;
-
}
-
-
if (nb_tx_q > dev_info.max_tx_queues) {
-
RTE_PMD_DEBUG_TRACE("ethdev port_id=%d nb_tx_queues=%d > %d\n",
-
port_id, nb_tx_q, dev_info.max_tx_queues);
-
return -EINVAL;
-
}
-
-
/*
-
* If link state interrupt is enabled, check that the
-
* device supports it.
-
*/
-
if ((dev_conf->intr_conf.lsc == 1) &&
-
(!(dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC))) {
-
RTE_PMD_DEBUG_TRACE("driver %s does not support lsc\n",
-
dev->data->drv_name);
-
return -EINVAL;
-
}
-
-
/*
-
* If jumbo frames are enabled, check that the maximum RX packet
-
* length is supported by the configured device.
-
*/
-
/* 如果开启了接收大包的功能，则检查配置的接收长度是否超过了设备限制 */
-
if (dev_conf->rxmode.jumbo_frame == 1) {
-
if (dev_conf->rxmode.max_rx_pkt_len >
-
dev_info.max_rx_pktlen) {
-
RTE_PMD_DEBUG_TRACE("ethdev port_id=%d max_rx_pkt_len %u"
-
" > max valid value %u\n",
-
port_id,
-
(unsigned)dev_conf->rxmode.max_rx_pkt_len,
-
(unsigned)dev_info.max_rx_pktlen);
-
return -EINVAL;
-
} else if (dev_conf->rxmode.max_rx_pkt_len < ETHER_MIN_LEN) {
-
RTE_PMD_DEBUG_TRACE("ethdev port_id=%d max_rx_pkt_len %u"
-
" < min valid value %u\n",
-
port_id,
-
(unsigned)dev_conf->rxmode.max_rx_pkt_len,
-
(unsigned)ETHER_MIN_LEN);
-
return -EINVAL;
-
}
-
} else {
-
if (dev_conf->rxmode.max_rx_pkt_len < ETHER_MIN_LEN ||
-
dev_conf->rxmode.max_rx_pkt_len > ETHER_MAX_LEN)
-
/* Use default value */
-
dev->data->dev_conf.rxmode.max_rx_pkt_len =
-
ETHER_MAX_LEN;
-
}
-
-
/*
-
* Setup new number of RX/TX queues and reconfigure device.
-
*/
-
/* 配置接收队列 */
-
diag = rte_eth_dev_rx_queue_config(dev, nb_rx_q);
-
if (diag != 0) {
-
RTE_PMD_DEBUG_TRACE("port%d rte_eth_dev_rx_queue_config = %d\n",
-
port_id, diag);
-
return diag;
-
}
-
/* 配置发送队列 */
-
diag = rte_eth_dev_tx_queue_config(dev, nb_tx_q);
-
if (diag != 0) {
-
RTE_PMD_DEBUG_TRACE("port%d rte_eth_dev_tx_queue_config = %d\n",
-
port_id, diag);
-
rte_eth_dev_rx_queue_config(dev, 0);
-
return diag;
-
}
-
/* 调用设备的配置函数，进行最后的配置 */
-
diag = (*dev->dev_ops->dev_configure)(dev);
-
if (diag != 0) {
-
RTE_PMD_DEBUG_TRACE("port%d dev_configure = %d\n",
-
port_id, diag);
-
rte_eth_dev_rx_queue_config(dev, 0);
-
rte_eth_dev_tx_queue_config(dev, 0);
-
return diag;
-
}
-
-
return 0;
-
}
这个函数参数会配置队列的个数，以及接口的配置信息，如队列的使用模式，多队列的方式等。前面会先进行一些各项检查，如果设备已经启动，就得先停下来才能配置（这时应该叫再配置吧）。然后把传进去的配置参数拷贝到设备的数据区。
memcpy(&dev->data->dev_conf,
dev_conf, sizeof(dev->data->dev_conf));
之后获取设备的信息，主要也是为了后面的检查使用：
(*dev->dev_ops->dev_infos_get)(dev,
&dev_info);
这里的dev_infos_get是在驱动初始化过程中设备初始化时配置的(eth_ixgbe_dev_init())
eth_dev->dev_ops
= &ixgbe_eth_dev_ops;
重要的信息检查过后，下面就是对发送和接收队列进行配置。先看接收队列的配置，接收队列是从rte_eth_dev_tx_queue_config()开始的。
在接收配置中，考虑的是有两种情况，一种是第一次配置；另一种是重新配置。所以，代码中都做了区分。
(1) 如果是第一次配置，那么就为每个队列分配一个指针（注意这里只分配了指针，没有分配实际队列）。
代码如下：dev->data->rx_queues =
rte_zmalloc("ethdev->rx_queues",
sizeof(dev->data->rx_queues[0])
* nb_queues, RTE_CACHE_LINE_SIZE);
(2)如果是重新配置，配置的queue数量不为0，那么就取消之前的配置，重新配置。
(3)如果是重新配置，但要求的queue为0，那么释放已有的配置。
发送的配置也是同样的，在rte_eth_dev_tx_queue_config()。
当收发队列配置完成后，就调用设备的配置函数，进行最后的配置。(*dev->dev_ops->dev_configure)(dev)，我们找到对应的配置函数，进入ixgbe_dev_configure()来分析其过程,其实这个函数并没有做太多的事。
在函数中，先调用了ixgbe_check_mq_mode()来检查队列的模式。然后设置允许接收批量和向量的模式
adapter->rx_bulk_alloc_allowed = true;
adapter->rx_vec_allowed = true;
到此rte_eth_dev_configure函数的工作就做完了。
1.1.2 队列的初始化
接下来就是收发队列的初始化，非常关键的一部分内容，这部分内容按照收发分别介绍：
l 接收队列的初始化
接收队列的初始化是从rte_eth_rx_queue_setup()开始的，这里的参数需要指定要初始化的port_id,queue_id,以及描述符的个数，还可以指定接收的配置，如释放和回写的阈值等，另外重要的一点是要指定用来接收存放数据使用的mbuf
pool，而发送队列是不需要这个的。
依然如其他函数的套路一样，先进行各种检查，如初始化的队列号是否合法有效，设备如果已经启动，就不能继续初始化了。检查函数指针是否有效等。检查mbuf的数据大小是否满足默认的设备信息里的配置。
l rte_eth_rx_queue_setup
-
/*
-
* @port_id: 设备的port_id
-
* @rx_queue_id: 所要配置的queue id
-
* @nb_rx_desc: 设置队列的接收描述符(desc)的个数，也决定这接收队列的大小
-
* @socket_id: 队列的socket_id
-
* @rx_conf: 接收的配置，如释放和回写的阈值等
-
* @mp:
-
*/
-
int
-
rte_eth_rx_queue_setup(uint8_t port_id, uint16_t rx_queue_id,
-
uint16_t nb_rx_desc, unsigned int socket_id,
-
const struct rte_eth_rxconf *rx_conf,
-
struct rte_mempool *mp)
-
{
-
int ret;
-
uint32_t mbp_buf_size;
-
struct rte_eth_dev *dev;
-
struct rte_eth_dev_info dev_info;
-
void **rxq;
-
-
RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
-
/* 获取对应的设备数据结构 */
-
dev = &rte_eth_devices[port_id];
-
/* 检查当前配置的队列是否超出了之前设置的队列个数范围 */
-
if (rx_queue_id >= dev->data->nb_rx_queues) {
-
return -EINVAL;
-
}
-
/* 如果设备已经启动，就不能再配置队列了 */
-
if (dev->data->dev_started) {
-
return -EBUSY;
-
}
-
-
RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->dev_infos_get, -ENOTSUP);
-
RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_setup, -ENOTSUP);
-
-
/*
-
* Check the size of the mbuf data buffer.
-
* This value must be provided in the private data of the memory pool.
-
* First check that the memory pool has a valid private data.
-
*/
-
/* 这里获取了设备的信息, 用于校验当前的要配置的信息 */
-
rte_eth_dev_info_get(port_id, &dev_info);
-
if (mp->private_data_size < sizeof(struct rte_pktmbuf_pool_private)) {
-
return -ENOSPC;
-
}
-
mbp_buf_size = rte_pktmbuf_data_room_size(mp);
-
-
if ((mbp_buf_size - RTE_PKTMBUF_HEADROOM) < dev_info.min_rx_bufsize) {
-
return -EINVAL;
-
}
-
/* 检查接收描述符的大小是否合法 */
-
if (nb_rx_desc > dev_info.rx_desc_lim.nb_max ||
-
nb_rx_desc < dev_info.rx_desc_lim.nb_min ||
-
nb_rx_desc % dev_info.rx_desc_lim.nb_align != 0) {
-
return -EINVAL;
-
}
-
-
rxq = dev->data->rx_queues;
-
if (rxq[rx_queue_id]) { /* 如果之前已经对队列初始化过，则先释放之前的资源 */
-
RTE_FUNC_PTR_OR_ERR_RET(*dev->dev_ops->rx_queue_release,
-
-ENOTSUP);
-
(*dev->dev_ops->rx_queue_release)(rxq[rx_queue_id]);
-
rxq[rx_queue_id] = NULL;
-
}
-
/* 如果调用初始化函数时没有指定rx_conf配置，就会设备配置信息里的默认值 */
-
if (rx_conf == NULL)
-
rx_conf = &dev_info.default_rxconf;
-
/* 调用到队列的setup函数做最后的初始化 */
-
ret = (*dev->dev_ops->rx_queue_setup)(dev, rx_queue_id, nb_rx_desc,
-
socket_id, rx_conf, mp);
-
if (!ret) {
-
if (!dev->data->min_rx_buf_size ||
-
dev->data->min_rx_buf_size > mbp_buf_size)
-
dev->data->min_rx_buf_size = mbp_buf_size;
-
}
-
-
return ret;
-
}
如果调用初始化函数时没有指定rx_conf配置，就会设备配置信息里的默认值
-
dev_info->default_rxconf = (struct rte_eth_rxconf) {
-
.rx_thresh = {
-
.pthresh = IXGBE_DEFAULT_RX_PTHRESH,
-
.hthresh = IXGBE_DEFAULT_RX_HTHRESH,
-
.wthresh = IXGBE_DEFAULT_RX_WTHRESH,
-
},
-
.rx_free_thresh = IXGBE_DEFAULT_RX_FREE_THRESH,
-
.rx_drop_en = 0,
-
};
最后，调用到队列的setup函数做最后的初始化。
-
ret = (*dev->dev_ops->rx_queue_setup)(dev, rx_queue_id, nb_rx_desc,
-
socket_id, rx_conf, mp);
对于ixgbe设备，rx_queue_setup就是函数ixgbe_dev_rx_queue_setup()，这里就是队列最终的初始化。
l ixgbe_dev_rx_queue_setup
-
int ixgbe_dev_rx_queue_setup(struct rte_eth_dev *dev,
-
uint16_t queue_idx,
-
uint16_t nb_desc,
-
unsigned int socket_id,
-
const struct rte_eth_rxconf *rx_conf,
-
struct rte_mempool *mp)
-
{
-
const struct rte_memzone *rz;
-
struct ixgbe_rx_queue *rxq;
-
struct ixgbe_hw *hw;
-
uint16_t len;
-
struct ixgbe_adapter *adapter =
-
(struct ixgbe_adapter *)dev->data->dev_private;
-
-
PMD_INIT_FUNC_TRACE();
-
hw = IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
-
-
if (nb_desc % IXGBE_RXD_ALIGN != 0 ||
-
(nb_desc > IXGBE_MAX_RING_DESC) ||
-
(nb_desc < IXGBE_MIN_RING_DESC)) {
-
return -EINVAL;
-
}
-
-
/* Free memory prior to re-allocation if needed... */
-
if (dev->data->rx_queues[queue_idx] != NULL) {
-
ixgbe_rx_queue_release(dev->data->rx_queues[queue_idx]);
-
dev->data->rx_queues[queue_idx] = NULL;
-
}
-
-
/* First allocate the rx queue data structure */
-
/* 分配接收队列的数据结构 */
-
rxq = rte_zmalloc_socket("ethdev RX queue", sizeof(struct ixgbe_rx_queue),
-
RTE_CACHE_LINE_SIZE, socket_id);
-
if (rxq == NULL)
-
return -ENOMEM;
-
rxq->mb_pool = mp; /* 将之前传入的mbuf pool和队列相关联 */
-
rxq->nb_rx_desc = nb_desc; /* 设置队列的接收描述符个数 */
-
rxq->rx_free_thresh = rx_conf->rx_free_thresh;
-
rxq->queue_id = queue_idx;
-
rxq->reg_idx = (uint16_t)((RTE_ETH_DEV_SRIOV(dev).active == 0) ?
-
queue_idx : RTE_ETH_DEV_SRIOV(dev).def_pool_q_idx + queue_idx);
-
rxq->port_id = dev->data->port_id;
-
rxq->crc_len = (uint8_t) ((dev->data->dev_conf.rxmode.hw_strip_crc) ?
-
0 : ETHER_CRC_LEN);
-
rxq->drop_en = rx_conf->rx_drop_en;
-
rxq->rx_deferred_start = rx_conf->rx_deferred_start;
-
-
/* ...... */
-
-
/*
-
* Allocate RX ring hardware descriptors. A memzone large enough to
-
* handle the maximum ring size is allocated in order to allow for
-
* resizing in later calls to the queue setup function.
-
*/
-
/* 分配描述符队列的空间，这里直接按照做大个数的描述符分配而不是传入的个数，
-
*是为了方便以后调整描述符个数大小 */
-
rz = rte_eth_dma_zone_reserve(dev, "rx_ring", queue_idx,
-
RX_RING_SZ, IXGBE_ALIGN, socket_id);
-
if (rz == NULL) {
-
ixgbe_rx_queue_release(rxq);
-
return -ENOMEM;
-
}
-
-
/*
-
* Zero init all the descriptors in the ring.
-
*/
-
memset(rz->addr, 0, RX_RING_SZ);
-
-
/* ...... */
-
/* 设置队列的接收描述符ring的物理地址和虚拟地址 */
-
rxq->rx_ring_phys_addr = rte_mem_phy2mch(rz->memseg_id, rz->phys_addr);
-
rxq->rx_ring = (union ixgbe_adv_rx_desc *) rz->addr;
-
-
/*
-
* Certain constraints must be met in order to use the bulk buffer
-
* allocation Rx burst function. If any of Rx queues doesn't meet them
-
* the feature should be disabled for the whole port.
-
*/
-
if (check_rx_burst_bulk_alloc_preconditions(rxq)) {
-
adapter->rx_bulk_alloc_allowed = false;
-
}
-
-
/*
-
* Allocate software ring. Allow for space at the end of the
-
* S/W ring to make sure look-ahead logic in bulk alloc Rx burst
-
* function does not access an invalid memory region.
-
*/
-
len = nb_desc;
-
if (adapter->rx_bulk_alloc_allowed)
-
len += RTE_PMD_IXGBE_RX_MAX_BURST;
-
-
rxq->sw_ring = rte_zmalloc_socket("rxq->sw_ring",
-
sizeof(struct ixgbe_rx_entry) * len,
-
RTE_CACHE_LINE_SIZE, socket_id);
-
if (!rxq->sw_ring) {
-
ixgbe_rx_queue_release(rxq);
-
return -ENOMEM;
-
}
-
-
/*
-
* Always allocate even if it's not going to be needed in order to
-
* simplify the code.
-
*
-
* This ring is used in LRO and Scattered Rx cases and Scattered Rx may
-
* be requested in ixgbe_dev_rx_init(), which is called later from
-
* dev_start() flow.
-
*/
-
rxq->sw_sc_ring =
-
rte_zmalloc_socket("rxq->sw_sc_ring",
-
sizeof(struct ixgbe_scattered_rx_entry) * len,
-
RTE_CACHE_LINE_SIZE, socket_id);
-
if (!rxq->sw_sc_ring) {
-
ixgbe_rx_queue_release(rxq);
-
return -ENOMEM;
-
}
-
-
if (!rte_is_power_of_2(nb_desc)) {
-
adapter->rx_vec_allowed = false;
-
} else
-
ixgbe_rxq_vec_setup(rxq);
-
-
dev->data->rx_queues[queue_idx] = rxq;
-
-
ixgbe_reset_rx_queue(adapter, rxq);
-
-
return 0;
-
}
依然是先检查，检查描述符的数量最大不能大于IXGBE_MAX_RING_DESC个，最小不能小于IXGBE_MIN_RING_DESC个。接下来的都是重点：
(1) 分配队列结构体，并填充结构
rxq = rte_zmalloc_socket("ethdev RX queue", sizeof(struct ixgbe_rx_queue),
RTE_CACHE_LINE_SIZE,
socket_id);
填充结构体的所属内存池，描述符个数，队列号，队列所属接口号等成员。
(2) 分配描述符队列的空间，按照最大的描述符个数进行分配
rz =
rte_eth_dma_zone_reserve(dev, "rx_ring", queue_idx,
RX_RING_SZ, IXGBE_ALIGN,
socket_id);
(3) 接着获取描述符队列的头和尾寄存器的地址，在收发包后，软件要对这个寄存器进行处理。
rxq->rdt_reg_addr =
IXGBE_PCI_REG_ADDR(hw,
IXGBE_RDT(rxq->reg_idx));
rxq->rdh_reg_addr =
IXGBE_PCI_REG_ADDR(hw,
IXGBE_RDH(rxq->reg_idx));
(4) 设置队列的接收描述符ring的物理地址和虚拟地址。
rxq->rx_ring_phys_addr=rte_mem_phy2mch(rz->memseg_id,rz->phys_addr);
rxq->rx_ring = (union ixgbe_adv_rx_desc *) rz->addr;
(5) 分配sw_ring，这个ring中存储的对象是struct ixgbe_rx_entry，其实里面就是数据包mbuf的指针。
rxq->sw_ring = rte_zmalloc_socket("rxq->sw_ring",
sizeof(struct ixgbe_rx_entry) * len,
RTE_CACHE_LINE_SIZE,
socket_id);
以上几步做完以后，新分配的队列结构体重要的部分就已经填充完了，下面需要重置一下其他成员
l ixgbe_reset_rx_queue
先把分配的描述符队列清空，其实清空在分配的时候就已经做了，没必要重复做
for (i = 0; i < len; i++) {
rxq->rx_ring[i] = zeroed_desc;
}
然后初始化队列中一下其他成员
rxq->rx_nb_avail = 0;
rxq->rx_next_avail = 0;
rxq->rx_free_trigger =
(uint16_t)(rxq->rx_free_thresh - 1);
rxq->rx_tail = 0;
rxq->nb_rx_hold = 0;
rxq->pkt_first_seg = NULL;
rxq->pkt_last_seg = NULL;
这样，接收队列就初始化完了。
l 发送队列的初始化
发送队列的初始化在前面的检查基本和接收队列一样，只有些许区别在于setup环节，我们就从这个函数说起：ixgbe_dev_tx_queue_setup()。在发送队列配置中，重点设置了tx_rs_thresh和tx_free_thresh的值。
然后分配了一个发送队列结构txq,之后分配发送队列ring的空间，并填充txq的结构体
txq->tx_ring_phys_addr = rte_mem_phy2mch(tz->memseg_id,tz->phys_addr);
txq->tx_ring = (union ixgbe_adv_tx_desc *) tz->addr;
然后，分配队列的sw_ring,也挂载队列上。
l 重置发送队列
ixgbe_reset_tx_queue()
和接收队列一样，也是要把队列ring（描述符ring）清空，设置发送队列sw_ring,设置其他参数，队尾位置设置为0
-
txq->tx_next_dd = (uint16_t)(txq->tx_rs_thresh - 1);
-
txq->tx_next_rs = (uint16_t)(txq->tx_rs_thresh - 1);
-
txq->tx_tail = 0;
-
txq->nb_tx_used = 0;
-
/*
-
* Always allow 1 descriptor to be un-allocated to avoid
-
* a H/W race condition
-
*/
-
txq->last_desc_cleaned = (uint16_t)(txq->nb_tx_desc - 1);
-
txq->nb_tx_free = (uint16_t)(txq->nb_tx_desc - 1);
-
txq->ctx_curr = 0;
这样发送队列的初始化就完成了。
1.1.3设备的启动
经过上面的队列初始化，队列的ring和sw_ring都分配了，但是发现木有，DMA仍然还不知道要把数据包拷贝到哪里，那么我们分配的mempool中的对象怎么和队列以及驱动联系起来呢？接下来就是最精彩的时刻了----建立mempool、queue、DMA、ring之间的关系。话说，这个为什么不是在队列的初始化中就做呢？设备的启动是从rte_eth_dev_start()中开始的：
diag = (*dev->dev_ops->dev_start)(dev);
进而，找到设备启动的真正启动函数：ixgbe_dev_start()，我们只保留关键的代码。
l ixgbe_dev_start
-
static int ixgbe_dev_start(struct rte_eth_dev *dev)
-
{
-
struct ixgbe_hw *hw =
-
IXGBE_DEV_PRIVATE_TO_HW(dev->data->dev_private);
-
struct ixgbe_vf_info *vfinfo =
-
*IXGBE_DEV_PRIVATE_TO_P_VFDATA(dev->data->dev_private);
-
struct rte_pci_device *pci_dev = IXGBE_DEV_TO_PCI(dev);
-
struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
-
uint32_t intr_vector = 0;
-
int err, link_up = 0, negotiate = 0;
-
uint32_t speed = 0;
-
int mask = 0;
-
int status;
-
uint16_t vf, idx;
-
uint32_t *link_speeds;
-
-
/*先检查设备的链路设置，暂时不支持半双工和固定速率的模式*/
-
if (dev->data->dev_conf.link_speeds & ETH_LINK_SPEED_FIXED) {
-
PMD_INIT_LOG(ERR, "Invalid link_speeds for port %hhu; fix speed not supported",
-
dev->data->port_id);
-
return -EINVAL;
-
}
-
-
/* disable uio/vfio intr/eventfd mapping */
-
rte_intr_disable(intr_handle);
-
-
/* stop adapter */
-
hw->adapter_stopped = 0;
-
/* 然后把中断禁掉，同时，停掉适配器 */
-
ixgbe_stop_adapter(hw);
-
-
status = ixgbe_pf_reset_hw(hw);
-
-
/* 如果支持多队列，则初始化多个中断向量 */
-
/* check and configure queue intr-vector mapping */
-
if ((rte_intr_cap_multiple(intr_handle) ||
-
!RTE_ETH_DEV_SRIOV(dev).active) &&
-
dev->data->dev_conf.intr_conf.rxq != 0) {
-
intr_vector = dev->data->nb_rx_queues;
-
if (rte_intr_efd_enable(intr_handle, intr_vector))
-
return -1;
-
}
-
-
/* initialize transmission unit */
-
ixgbe_dev_tx_init(dev);
-
-
/* This can fail when allocating mbufs for descriptor rings */
-
err = ixgbe_dev_rx_init(dev);
-
-
err = ixgbe_dev_rxtx_start(dev);
-
-
dev->data->dev_link.link_status = link_up;
-
-
err = ixgbe_get_link_capabilities(hw, &speed, &negotiate);
-
if (err)
-
goto error;
-
-
err = ixgbe_setup_link(hw, speed, link_up);
-
if (err)
-
goto error;
-
-
skip_link_setup:
-
-
return 0;
-
-
error:
-
ixgbe_dev_clear_queues(dev);
-
return -EIO;
-
}
(1) 先检查设备的链路设置，暂时不支持半双工和固定速率的模式。看来是暂时只有自适应模式；
(2) 然后把中断禁掉，同时，停掉适配器: ixgbe_stop_adapter(hw),在其中，就是调用了ixgbe_stop_adapter_generic(),主要的工作就是停止发送和接收单元。这是直接写寄存器来完成的;
(3) 然后重启硬件，ixgbe_pf_reset_hw()->ixgbe_reset_hw()->ixgbe_reset_hw_82599(),最终都是设置寄存器，这里就不细究了。之后，就启动了硬件。
(4) 接着如果是多队列，则为每个队列分配对应的中断向量；
(5) 再然后是初始化接收单元：ixgbe_dev_rx_init()；
在这个函数中，主要就是设置各类寄存器，比如配置CRC校验，如果支持巨帧，配置对应的寄存器。还有如果配置了loopback模式，也要配置寄存器。
接下来最重要的就是为每个队列设置DMA寄存器，标识每个队列的描述符ring的地址，长度，头，尾等。
-
/* Setup RX queues */
-
for (i = 0; i < dev->data->nb_rx_queues; i++) {
-
rxq = dev->data->rx_queues[i];
-
/*
-
* Reset crc_len in case it was changed after queue setup by a
-
* call to configure.
-
*/
-
rxq->crc_len = rx_conf->hw_strip_crc ? 0 : ETHER_CRC_LEN;
-
/* Setup the Base and Length of the Rx Descriptor Rings */
-
bus_addr = rxq->rx_ring_phys_addr;
-
IXGBE_WRITE_REG(hw, IXGBE_RDBAL(rxq->reg_idx),
-
(uint32_t)(bus_addr & 0x00000000ffffffffULL));
-
IXGBE_WRITE_REG(hw, IXGBE_RDBAH(rxq->reg_idx),
-
(uint32_t)(bus_addr >> 32));
-
IXGBE_WRITE_REG(hw, IXGBE_RDLEN(rxq->reg_idx),
-
rxq->nb_rx_desc * sizeof(union ixgbe_adv_rx_desc));
-
IXGBE_WRITE_REG(hw, IXGBE_RDH(rxq->reg_idx), 0);
-
IXGBE_WRITE_REG(hw, IXGBE_RDT(rxq->reg_idx), 0);
-
}
这里可以看到把描述符ring的物理地址写入了寄存器，还写入了描述符ring的长度。接下来这个函数还计算了数据包数据的长度，写入到寄存器中.然后对于网卡的多队列设置,也进行了配置：ixgbe_dev_mq_rx_configure()；
同时如果设置了接收校验和，还对校验和进行了寄存器设置。
最后，调用ixgbe_set_rx_function()对接收函数再进行设置，主要是针对支持LRO，vector,bulk等处理方法。
这样，接收单元的初始化就完成了。
(6) 初始化发送单元：ixgbe_dev_tx_init();
发送单元的的初始化和接收单元的初始化基本操作是一样的，都是填充寄存器的值，重点是设置描述符队列的基地址和长度。
-
/* Setup the Base and Length of the Tx Descriptor Rings */
-
for (i = 0; i < dev->data->nb_tx_queues; i++) {
-
txq = dev->data->tx_queues[i];
-
-
bus_addr = txq->tx_ring_phys_addr;
-
IXGBE_WRITE_REG(hw, IXGBE_TDBAL(txq->reg_idx),
-
(uint32_t)(bus_addr & 0x00000000ffffffffULL));
-
IXGBE_WRITE_REG(hw, IXGBE_TDBAH(txq->reg_idx),
-
(uint32_t)(bus_addr >> 32));
-
IXGBE_WRITE_REG(hw, IXGBE_TDLEN(txq->reg_idx),
-
txq->nb_tx_desc * sizeof(union ixgbe_adv_tx_desc));
-
/* Setup the HW Tx Head and TX Tail descriptor pointers */
-
IXGBE_WRITE_REG(hw, IXGBE_TDH(txq->reg_idx), 0);
-
IXGBE_WRITE_REG(hw, IXGBE_TDT(txq->reg_idx), 0);
-
}
最后配置一下多队列使用相关的寄存器：ixgbe_dev_mq_tx_configure()。
如此，发送单元的初始化就完成了。
(7) 启动设备的收发单元：ixgbe_dev_rxtx_start()
先对每个发送队列的threshold相关寄存器进行设置，这是发送时的阈值参数，这个东西在发送部分有说明。然后就是依次启动每个接收队列：
-
for (i = 0; i < dev->data->nb_rx_queues; i++) {
-
rxq = dev->data->rx_queues[i];
-
if (!rxq->rx_deferred_start) {
-
ret = ixgbe_dev_rx_queue_start(dev, i);
-
if (ret < 0)
-
return ret;
-
}
-
}
l ixgbe_dev_rx_queue_start
先检查，如果要启动的队列是合法的，那么就为这个接收队列分配存放mbuf的实际空间。
-
if (rx_queue_id < dev->data->nb_rx_queues) {
-
rxq = dev->data->rx_queues[rx_queue_id];
-
/* Allocate buffers for descriptor rings */
-
if (ixgbe_alloc_rx_queue_mbufs(rxq) != 0) {
-
PMD_INIT_LOG(ERR, "Could not alloc mbuf for queue:%d",
-
rx_queue_id);
-
return -1;
-
}
-
}
l ixgbe_alloc_rx_queue_mbufs
这里是重点，完成了建立mempool、queue、DMA、ring之间的关系。
-
static int __attribute__((cold))
-
ixgbe_alloc_rx_queue_mbufs(struct ixgbe_rx_queue *rxq)
-
{
-
struct ixgbe_rx_entry *rxe = rxq->sw_ring;
-
uint64_t dma_addr;
-
unsigned int i;
-
/* Initialize software ring entries */
-
for (i = 0; i < rxq->nb_rx_desc; i++) {
-
volatile union ixgbe_adv_rx_desc *rxd;
-
/* 从mbuf pool中分配一个mbuf */
-
struct rte_mbuf *mbuf = rte_mbuf_raw_alloc(rxq->mb_pool);
-
if (mbuf == NULL) {
-
PMD_INIT_LOG(ERR, "RX mbuf alloc failed queue_id=%u",
-
(unsigned) rxq->queue_id);
-
return -ENOMEM;
-
}
-
rte_mbuf_refcnt_set(mbuf, 1);
-
mbuf->next = NULL;
-
mbuf->data_off = RTE_PKTMBUF_HEADROOM;
-
mbuf->nb_segs = 1;
-
mbuf->port = rxq->port_id;
-
dma_addr =
-
rte_cpu_to_le_64(rte_mbuf_data_dma_addr_default(mbuf));
-
rxd = &rxq->rx_ring[i];
-
rxd->read.hdr_addr = 0;
-
rxd->read.pkt_addr = dma_addr; /*设置描述符的dma地址为mbuf对应的地址*/
-
rxe[i].mbuf = mbuf;
-
}
-
return 0;
-
}
我们看到，从队列所属内存池的ring中循环取出了nb_rx_desc个mbuf指针，也就是为了填充rxq->rx_ring。每个指针都指向内存池里的一个数据包空间。然后就先填充了新分配的mbuf结构，最最重要的是填充计算了dma_addr：
dma_addr =
rte_cpu_to_le_64(rte_mbuf_data_dma_addr_default(mbuf));
然后初始化queue ring，即rxd的信息，标明了驱动把数据包放在dma_addr处。最后一句，把分配的mbuf“放入”queue 的rx_ring中，这样，驱动收过来的包，就直接放在了rx_ring中。
以上最重要的工作就完成了，下面就可以使能DMA引擎啦，准备收包，完成接收队列的启动。
hw->mac.ops.enable_rx_dma(hw, rxctrl);
接着依次启动每个发送队列：
发送队列的启动比接收队列的启动要简单，只是配置了txdctl寄存器，延时等待TX使能完成，最后，设置队列的头和尾位置都为0。
-
txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(txq->reg_idx));
-
txdctl |= IXGBE_TXDCTL_ENABLE;
-
IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(txq->reg_idx), txdctl);
-
-
IXGBE_WRITE_REG(hw, IXGBE_TDH(txq->reg_idx), 0);
-
IXGBE_WRITE_REG(hw, IXGBE_TDT(txq->reg_idx), 0);
这样发送队列就启动完成了。
到此网卡设备信息的配置及初始化的主要工作就完成了，我们用下图来回顾一下。
1.2 网卡数据包的收发
数据包的获取是指驱动把数据包放入了内存中，上层应用从队列中去取出这些数据包；发送是指把要发送的数据包放入到发送队列中，为实际发送做准备。
1.2.1数据包的获取
业务层面获取数据包是从rte_eth_rx_burst()开始的
int16_t nb_rx =
(*dev->rx_pkt_burst)(dev->data->rx_queues[queue_id],
rx_pkts,
nb_pkts);
这里的dev->rx_pkt_burst在驱动初始化的时候已经注册过了，对于ixgbe设备，就是ixgbe_recv_pkts()函数。
在说收包之前，先了解网卡的DD标志，这个标志标识着一个描述符是否可用的情况：网卡在使用这个描述符前，先检查DD位是否为0，如果为0，那么就可以使用描述符，把数据拷贝到描述符指定的地址，之后把DD标志位置为1，否则表示不能使用这个描述符。而对于驱动而言，恰恰相反，在读取数据包时，先检查DD位是否为1，如果为1，表示网卡已经把数据放到了内存中，可以读取，读取完后，再把DD位设置为0，否则，就表示没有数据包可读。就重点从这个函数看看，数据包是怎么被取出来的。
首先，取值rx_id = rxq->rx_tail,这个值初始化时为0，用来标识当前ring的尾。然后循环读取请求数量的描述符，这时候第一步判断就是这个描述符是否可用
staterr = rxdp->wb.upper.status_error;
if (!(staterr & rte_cpu_to_le_32(IXGBE_RXDADV_STAT_DD)))
break;
如果描述符的DD位不为1，则表明这个描述符网卡还没有准备好，也就是没有包！没有包，就跳出循环。如果描述符准备好了，就取出对应的描述符，因为网卡已经把一些信息存到了描述符里，可以后面把这些信息填充到新分配的数据包里。
下面就是一个狸猫换太子的事了，先从mempool的ring中分配一个新的“狸猫”---mbuf
nmb = rte_mbuf_raw_alloc(rxq->mb_pool);
然后找到当前描述符对应的“太子”---ixgbe_rx_entry
*rxe
rxe = &sw_ring[rx_id];
中间略掉关于预取的操作代码，之后，就要用这个狸猫换个太子
rxm = rxe->mbuf;
rxe->mbuf = nmb;
这样换出来的太子rxm就是我们要取出来的数据包指针，在下面填充一些必要的信息，就可以把包返给接收的用户了
-
rxm->data_off = RTE_PKTMBUF_HEADROOM;
-
rte_packet_prefetch((char *)rxm->buf_addr + rxm->data_off);
-
rxm->nb_segs = 1;
-
rxm->next = NULL;
-
rxm->pkt_len = pkt_len;
-
rxm->data_len = pkt_len;
-
rxm->port = rxq->port_id;
-
pkt_info = rte_le_to_cpu_32(rxd.wb.lower.lo_dword.data);
-
/* Only valid if PKT_RX_VLAN_PKT set in pkt_flags */
-
rxm->vlan_tci = rte_le_to_cpu_16(rxd.wb.upper.vlan);
-
pkt_flags = rx_desc_status_to_pkt_flags(staterr, vlan_flags);
-
pkt_flags = pkt_flags | rx_desc_error_to_pkt_flags(staterr);
-
pkt_flags = pkt_flags |
-
ixgbe_rxd_pkt_info_to_pkt_flags((uint16_t)pkt_info);
-
rxm->ol_flags = pkt_flags;
-
rxm->packet_type =
-
ixgbe_rxd_pkt_info_to_pkt_type(pkt_info,
-
rxq->pkt_type_mask);
-
if (likely(pkt_flags & PKT_RX_RSS_HASH))
-
rxm->hash.rss = rte_le_to_cpu_32(
-
rxd.wb.lower.hi_dword.rss);
-
else if (pkt_flags & PKT_RX_FDIR) {
-
rxm->hash.fdir.hash = rte_le_to_cpu_16(
-
rxd.wb.lower.hi_dword.csum_ip.csum) &
-
IXGBE_ATR_HASH_MASK;
-
rxm->hash.fdir.id = rte_le_to_cpu_16(
-
rxd.wb.lower.hi_dword.csum_ip.ip_id);
-
}
-
/*
-
* Store the mbuf address into the next entry of the array
-
* of returned packets.
-
*/
-
rx_pkts[nb_rx++] = rxm;
注意最后一句话，就是把包的指针返回给用户。
其实在换太子中间过程中，还有一件非常重要的事要做，就是开头说的，在驱动读取完数据包后，要把描述符的DD标志位置为0，同时设置新的DMA地址指向新的mbuf空间，这么描述符就可以再次被网卡硬件使用，拷贝数据到mbuf空间了。
dma_addr = rte_cpu_to_le_64(rte_mbuf_data_dma_addr_default(nmb));
rxdp->read.hdr_addr = 0;
rxdp->read.pkt_addr = dma_addr;
rxdp->read.hdr_addr
= 0;一句中，就包含了设置DD位为0。
最后，就是检查空余可用描述符数量是否小于阀值，如果小于阀值，进行处理。不详细说了。
这样过后，收取数据包就完成啦！Done！
1.2.2数据包的发送
在说发送之前，先说一下描述符的回写（write-back），回写是指把用过后的描述符，恢复其重新使用的过程。在接收数据包过程中，回写是立马执行的，也就是DMA使用描述符标识包可读取，然后驱动程序读取数据包，读取之后，就会把DD位置0，同时进行回写操作，这个描述符也就可以再次被网卡硬件使用了。
但是发送过程中，回写却不是立刻完成的。发送有两种方式进行回写：
(1) Updating
by writing back into the Tx descriptor;
(2) Update
by writing to the head pointer in system memory;
第二种回写方式貌似针对的网卡比较老，对于82599，使用第一种回写方式。在下面三种情况下，才能进行回写操作：
(1) TXDCTL[n].WTHRESH
= 0 and a descriptor that has RS set is ready to be written back.
(2) TXDCTL[n].WTHRESH
> 0 and TXDCTL[n].WTHRESH descriptors have accumulated.
(3) TXDCTL[n].WTHRESH
> 0 and the corresponding EITR counter has reached zero. The timer
expiration flushes any accumulated descriptors and sets an interrupt
event(TXDW).
而在代码中，发送队列的初始化的时候，ixgbe_dev_tx_queue_setup()中
txq->pthresh = tx_conf->tx_thresh.pthresh;
txq->hthresh = tx_conf->tx_thresh.hthresh;
txq->wthresh = tx_conf->tx_thresh.wthresh;
pthresh,hthresh,wthresh的值，都是从tx_conf中配置的默认值，而tx_conf如果在我们的应用中没有赋值的话，就是采用的默认值：
-
dev_info->default_txconf = (struct rte_eth_txconf) {
-
.tx_thresh = {
-
.pthresh = IXGBE_DEFAULT_TX_PTHRESH,
-
.hthresh = IXGBE_DEFAULT_TX_HTHRESH,
-
.wthresh = IXGBE_DEFAULT_TX_WTHRESH,
-
},
-
.tx_free_thresh = IXGBE_DEFAULT_TX_FREE_THRESH,
-
.tx_rs_thresh = IXGBE_DEFAULT_TX_RSBIT_THRESH,
-
.txq_flags = ETH_TXQ_FLAGS_NOMULTSEGS |
-
ETH_TXQ_FLAGS_NOOFFLOADS,
-
};
其中的wthresh就是0，其余两个是32.也就是说这种设置下，回写取决于RS标志位。RS标志位主要就是为了标识已经积累了一定数量的描述符，要进行回写了。
了解了这个，就来看看代码吧，从ixgbe_xmit_pkts()开始，为了看主要的框架，我们忽略掉网卡卸载等相关的功能的代码，主要看发送和回写
先检查剩余的描述符是否已经小于阈值，如果小于阈值，那么就先清理回收一下描述符
if (txq->nb_tx_free < txq->tx_free_thresh)
ixgbe_xmit_cleanup(txq);
这是一个重要的操作，进去看看是怎么清理回收的：ixgbe_xmit_cleanup(txq)
取出上次清理的描述符位置，很明显，这次清理就接着上次的位置开始。所以，根据上次的位置，加上txq->tx_rs_thresh个描述符，就是标记有RS的描述符的位置，因为，tx_rs_thresh就是表示这么多个描述符后，设置RS位，进行回写。所以，从上次清理的位置跳过tx_rs_thresh个描述符，就能找到标记有RS的位置。
desc_to_clean_to = (uint16_t)(last_desc_cleaned + txq->tx_rs_thresh);
当网卡把队列的数据包发送完成后，就会把DD位设置为1，这个时候，先检查标记RS位置的描述符DD位，如果已经设置为1，则可以进行清理回收，否则，就不能清理。接下来确认要清理的描述符个数
-
if (last_desc_cleaned > desc_to_clean_to)
-
nb_tx_to_clean = (uint16_t)((nb_tx_desc - last_desc_cleaned) +
-
desc_to_clean_to);
-
else
-
nb_tx_to_clean = (uint16_t)(desc_to_clean_to -
-
last_desc_cleaned)
然后，就把标记有RS位的描述符中的RS位清掉，确切的说，DD位等都清空了。调整上次清理的位置和空闲描述符大小。
txr[desc_to_clean_to].wb.status = 0;
/* Update the
txq to reflect the last descriptor that was cleaned */
txq->last_desc_cleaned = desc_to_clean_to;
txq->nb_tx_free = (uint16_t)(txq->nb_tx_free + nb_tx_to_clean);
这样，就算清理完毕了！
继续看发送，依次处理每个要发送的数据包：
取出数据包，取出其中的卸载标志
-
ol_flags = tx_pkt->ol_flags;
-
/* If hardware offload required */
-
tx_ol_req = ol_flags & IXGBE_TX_OFFLOAD_MASK;
-
if (tx_ol_req) {
-
tx_offload.l2_len = tx_pkt->l2_len;
-
tx_offload.l3_len = tx_pkt->l3_len;
-
tx_offload.l4_len = tx_pkt->l4_len;
-
tx_offload.vlan_tci = tx_pkt->vlan_tci;
-
tx_offload.tso_segsz = tx_pkt->tso_segsz;
-
tx_offload.outer_l2_len = tx_pkt->outer_l2_len;
-
tx_offload.outer_l3_len = tx_pkt->outer_l3_len;
-
/* If new context need be built or reuse the exist ctx. */
-
ctx = what_advctx_update(txq, tx_ol_req,
-
tx_offload);
-
/* Only allocate context descriptor if required*/
-
new_ctx = (ctx == IXGBE_CTX_NUM);
-
ctx = txq->ctx_curr;
-
}
这里卸载还要使用一个描述符，暂时不明白。
计算了发送这个包需要的描述符数量，主要是有些大包会分成几个segment,每个segment
nb_used = (uint16_t)(tx_pkt->nb_segs + new_ctx);
如果这次要用的数量加上设置RS之后积累的数量，又到达了tx_rs_thresh，那么就设置RS标志。
if (txp != NULL &&
nb_used +
txq->nb_tx_used >= txq->tx_rs_thresh)
/* set RS on
the previous packet in the burst */
txp->read.cmd_type_len |=
rte_cpu_to_le_32(IXGBE_TXD_CMD_RS);
接下来要确保用足够可用的描述符
如果描述符不够用了，就先进行清理回收，如果没能清理出空间，则把最后一个打上RS标志，更新队列尾寄存器，返回已经发送的数量。
-
if (txp != NULL)
-
txp->read.cmd_type_len |= rte_cpu_to_le_32(IXGBE_TXD_CMD_RS);
-
rte_wmb();
-
/*
-
* Set the Transmit Descriptor Tail (TDT)
-
*/
-
PMD_TX_LOG(DEBUG, "port_id=%u queue_id=%u tx_tail=%u nb_tx=%u",
-
(unsigned) txq->port_id, (unsigned) txq->queue_id,
-
(unsigned) tx_id, (unsigned) nb_tx);
-
IXGBE_PCI_REG_WRITE_RELAXED(txq->tdt_reg_addr, tx_id);
-
txq->tx_tail = tx_id;
接下来的判断就很有意思了，
unlikely(nb_used > txq->tx_rs_thresh)
为什么说它奇怪呢？其实他自己都标明了unlikely,一个数据包会分为N多segment,多于txq->tx_rs_thresh（默认可是32啊），但即使出现了这种情况，也没做更多的处理，只是说会影响性能，然后开始清理描述符，其实这跟描述符还剩多少没有半毛钱关系，只是一个包占的描述符就超过了tx_rs_thresh,然而，并不见得是没有描述符了。所以，这时候清理描述符意义不明。
下面的处理应该都是已经有充足的描述符了，如果卸载有标志，就填充对应的值。不详细说了。
然后，就把数据包放到发送队列的sw_ring,并填充信息
-
m_seg = tx_pkt;
-
do {
-
txd = &txr[tx_id];
-
txn = &sw_ring[txe->next_id];
-
rte_prefetch0(&txn->mbuf->pool);
-
if (txe->mbuf != NULL)
-
rte_pktmbuf_free_seg(txe->mbuf);
-
txe->mbuf = m_seg;
-
/*
-
* Set up Transmit Data Descriptor.
-
*/
-
slen = m_seg->data_len;
-
buf_dma_addr = rte_mbuf_data_dma_addr(m_seg);
-
txd->read.buffer_addr =
-
rte_cpu_to_le_64(buf_dma_addr);
-
txd->read.cmd_type_len =
-
rte_cpu_to_le_32(cmd_type_len | slen);
-
txd->read.olinfo_status =
-
rte_cpu_to_le_32(olinfo_status);
-
txe->last_id = tx_last;
-
tx_id = txe->next_id;
-
txe = txn;
-
m_seg = m_seg->next;
-
} while (m_seg != NULL);
这里是把数据包的每个segment都放到队列sw_ring，很关键的是设置DMA地址，设置数据包长度和卸载参数。
一个数据包最后的segment的描述符需要一个EOP标志来结束。再更新剩余的描述符数：
cmd_type_len |= IXGBE_TXD_CMD_EOP;
txq->nb_tx_used = (uint16_t)(txq->nb_tx_used + nb_used);
txq->nb_tx_free = (uint16_t)(txq->nb_tx_free - nb_used);
然后再次检查是否已经达到了tx_rs_thresh，并做处理
-
if (txq->nb_tx_used >= txq->tx_rs_thresh) {
-
PMD_TX_FREE_LOG(DEBUG,
-
"Setting RS bit on TXD id="
-
"%4u (port=%d queue=%d)",
-
tx_last, txq->port_id, txq->queue_id);
-
cmd_type_len |= IXGBE_TXD_CMD_RS;
-
/* Update txq RS bit counters */
-
txq->nb_tx_used = 0;
-
txp = NULL;
-
} else
-
txp = txd;
-
txd->read.cmd_type_len |= rte_cpu_to_le_32(cmd_type_len);
最后仍是做一下末尾的处理，更新队列尾指针。发送就结束啦！！
IXGBE_PCI_REG_WRITE_RELAXED(txq->tdt_reg_addr, tx_id);
txq->tx_tail = tx_id;
1.2.3总结
可以看出数据包的发送和接收过程与驱动紧密相关，也与我们的配置有关，尤其是对于收发队列的参数配置，将直接影响性能，可以根据实际进行调整。
