Chinaunix首页 | 论坛 | 博客

技术之美

首页　| 　博文目录　| 　关于我

lvyilong316

  • 博客访问： 3450597
  • 博文数量： 198
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 7256
  • 用 户 组： 普通用户
  • 注册时间： 2013-01-23 18:56
个人简介

将晦涩难懂的技术讲的通俗易懂

文章分类

全部博文（198）

文章存档

2024年（1）

2023年（9）

2022年（4）

2021年（12）

2020年（8）

2019年（18）

2018年（19）

2017年（9）

2016年（26）

2015年（18）

2014年（54）

2013年（20）

我的朋友
最近访客
推荐博文
相关博文
DPDK KNI原理和实现

分类： LINUX

2021-10-23 20:56:16

DPDK KNI原理和实现

——lvyilong316

kni的整体的整体实现原理是采用共享内存方式，如下图通过DPDK创建rx_q，tx_q，并将其地址传递给kni内核模块，来实现rx_q和tx_q的内存共享，之后DPDK和内核就可以将数据放入对应的共享内存队列中完成报文的收发。下面分别介绍kni的内核部分和用户态部分。

用户态部分

首先我们看用户态部分。用户态部分我们直接看DPDK的kni example。其中关键初始化函数是main函数中调用的init_kni()。其中主要调用rte_kni_init。

点击(此处)折叠或打开

  1. void
  2. rte_kni_init(unsigned int max_kni_ifaces)
  3. {
  4.     uint32_t i;
  5.     struct rte_kni_memzone_slot *it;
  6.     const struct rte_memzone *mz;
  7. #define OBJNAMSIZ 32
  8.     char obj_name[OBJNAMSIZ];
  9.     char mz_name[RTE_MEMZONE_NAMESIZE];

  11.     /* Immediately return if KNI is already initialized */
  12.     if (kni_memzone_pool.initialized) {
  13.         RTE_LOG(WARNING, KNI, "Double call to rte_kni_init()");
  14.         return;
  15.     }

  17.     if (max_kni_ifaces == 0) {
  18.         RTE_LOG(ERR, KNI, "Invalid number of max_kni_ifaces %d\n",
  19.                             max_kni_ifaces);
  20.         RTE_LOG(ERR, KNI, "Unable to initialize KNI\n");
  21.         return;
  22.     }
  23.     /* 对/dev/kni调用open */
  24.     /* Check FD and open */
  25.     if (kni_fd < 0) {
  26.         kni_fd = open("/dev/" KNI_DEVICE, O_RDWR);
  27.         if (kni_fd < 0) {
  28.             RTE_LOG(ERR, KNI,
  29.                 "Can not open /dev/%s\n", KNI_DEVICE);
  30.             return;
  31.         }
  32.     }

  34.     /* Allocate slot objects */
  35.     kni_memzone_pool.slots = (struct rte_kni_memzone_slot *)
  36.                     rte_malloc(NULL,
  37.                     sizeof(struct rte_kni_memzone_slot) *
  38.                     max_kni_ifaces,
  39.                     0);
  40.     KNI_MEM_CHECK(kni_memzone_pool.slots == NULL);

  42.     /* Initialize general pool variables */
  43.     kni_memzone_pool.initialized = 1;
  44.     kni_memzone_pool.max_ifaces = max_kni_ifaces;
  45.     kni_memzone_pool.free = &kni_memzone_pool.slots[0];
  46.     rte_spinlock_init(&kni_memzone_pool.mutex);
  47.     /* 根据kni设备数量初始化对应的kni slot，每个slot存放着kni需要使用的各种queue */
  48.     /* Pre-allocate all memzones of all the slots; panic on error */
  49.     for (i = 0; i < max_kni_ifaces; i++) {

  51.         /* Recover current slot */
  52.         it = &kni_memzone_pool.slots[i];
  53.         it->id = i;

  55.         /* Allocate KNI context */
  56.         snprintf(mz_name, RTE_MEMZONE_NAMESIZE, "KNI_INFO_%d", i);
  57.         mz = kni_memzone_reserve(mz_name, sizeof(struct rte_kni),
  58.                     SOCKET_ID_ANY, 0);
  59.         KNI_MEM_CHECK(mz == NULL);
  60.         it->m_ctx = mz;

  62.         /* TX RING */
  63.         snprintf(obj_name, OBJNAMSIZ, "kni_tx_%d", i);
  64.         mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
  65.                             SOCKET_ID_ANY, 0);
  66.         KNI_MEM_CHECK(mz == NULL);
  67.         it->m_tx_q = mz;

  69.         /* RX RING */
  70.         snprintf(obj_name, OBJNAMSIZ, "kni_rx_%d", i);
  71.         mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
  72.                             SOCKET_ID_ANY, 0);
  73.         KNI_MEM_CHECK(mz == NULL);
  74.         it->m_rx_q = mz;

  76.         /* ALLOC RING */
  77.         snprintf(obj_name, OBJNAMSIZ, "kni_alloc_%d", i);
  78.         mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
  79.                             SOCKET_ID_ANY, 0);
  80.         KNI_MEM_CHECK(mz == NULL);
  81.         it->m_alloc_q = mz;

  83.         /* FREE RING */
  84.         snprintf(obj_name, OBJNAMSIZ, "kni_free_%d", i);
  85.         mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
  86.                             SOCKET_ID_ANY, 0);
  87.         KNI_MEM_CHECK(mz == NULL);
  88.         it->m_free_q = mz;

  90.         /* Request RING */
  91.         snprintf(obj_name, OBJNAMSIZ, "kni_req_%d", i);
  92.         mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
  93.                             SOCKET_ID_ANY, 0);
  94.         KNI_MEM_CHECK(mz == NULL);
  95.         it->m_req_q = mz;

  97.         /* Response RING */
  98.         snprintf(obj_name, OBJNAMSIZ, "kni_resp_%d", i);
  99.         mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
  100.                             SOCKET_ID_ANY, 0);
  101.         KNI_MEM_CHECK(mz == NULL);
  102.         it->m_resp_q = mz;

  104.         /* Req/Resp sync mem area */
  105.         snprintf(obj_name, OBJNAMSIZ, "kni_sync_%d", i);
  106.         mz = kni_memzone_reserve(obj_name, KNI_FIFO_SIZE,
  107.                             SOCKET_ID_ANY, 0);
  108.         KNI_MEM_CHECK(mz == NULL);
  109.         it->m_sync_addr = mz;

  111.         if ((i+1) == max_kni_ifaces) {
  112.             it->next = NULL;
  113.             kni_memzone_pool.free_tail = it;
  114.         } else
  115.             it->next = &kni_memzone_pool.slots[i+1];
  116.     }

  118.     return;

  120. kni_fail:
  121.     RTE_LOG(ERR, KNI, "Unable to allocate memory for max_kni_ifaces:%d."
  122.         "Increase the amount of hugepages memory\n", max_kni_ifaces);
  123. }

其核心就是根据kni设备数量初始化对应的 rte_kni_memzone_slot，其中 rte_kni_memzone_slot中主要保存着这个kni设备需要在数据传输中使用的各种queue，如tx_q，rx_q，free_q等，每个queue对应一个DPDK memzone。初始化完如下图所示。

另外一个关键初始化函数是main函数中对每个kni port调用的kni_alloc，而kni_alloc中主要调用rte_kni_alloc。关于rte_kni_alloc的部分这里就不再展开，主要是分配一个可用的rte_kni_memzone_slot，并将其相关信息赋值给一个struct rte_kni_device_info结构，然后用struct rte_kni_device_info作为参数调用kni设备的ioctl create：

ret = ioctl(kni_fd, RTE_KNI_IOCTL_CREATE, &dev_info);

这样就将DPDK用户态那些queue对应的内存和内核kni设备关联起来了。然后我们看用户态数据是如何发往内核的。DPDK侧的主要发送函数为rte_kni_tx_burst

点击(此处)折叠或打开

  1. unsigned
  2. rte_kni_tx_burst(struct rte_kni *kni, struct rte_mbuf **mbufs, unsigned num)
  3. {
  4.     void *phy_mbufs[num];
  5.     unsigned int ret;
  6.     unsigned int i;

  8.     for (i = 0; i < num; i++)
  9.         phy_mbufs[i] = va2pa(mbufs[i]);

  11.     ret = kni_fifo_put(kni->rx_q, phy_mbufs, num);

  13.     /* Get mbufs from free_q and then free them */
  14.     kni_free_mbufs(kni);

  16.     return ret;
  17. }

rte_kni_tx_burst主要调用 kni_fifo_put将mbuf的物理地址写入fifo中。

点击(此处)折叠或打开

  1. static inline uint32_t
  2. kni_fifo_put(struct rte_kni_fifo *fifo, void **data, uint32_t num)
  3. {
  4.     uint32_t i = 0;
  5.     uint32_t fifo_write = fifo->write;
  6.     uint32_t fifo_read = fifo->read;
  7.     uint32_t new_write = fifo_write;

  9.     for (i = 0; i < num; i++) {
  10.         new_write = (new_write + 1) & (fifo->len - 1);

  12.         if (new_write == fifo_read)
  13.             break;
  14.         fifo->buffer[fifo_write] = data[i];
  15.         fifo_write = new_write;
  16.     }
  17.     fifo->write = fifo_write;

  19.     return i;
  20. }

    至于内核的接收部分的接收逻辑我们在后续内核部分讲。用户态的接收逻辑也类似，从对应的rx_q fifo中取出数据转换为mbuf，这里就不再展开了。

内核部分

KNI是DPDK中带有的内核模块，在新版本的DPDK中KNI已经从DPDK代码库中移除独立维护了。我们这里就以老版本的DPDK来分析，以DPDK17.11.2来说，KNI模块对应的代码路径为：dpdk-stable-17.11.2\lib\librte_eal\linuxapp\kni。

其初始化函数为kni_init。

点击(此处)折叠或打开

  1. static int __init
  2. kni_init(void)
  3. {
  4.     int rc;

  6.     if (kni_parse_kthread_mode() < 0) { //kni的线程模式、单线程还是多线程
  7.         pr_err("Invalid parameter for kthread_mode\n");
  8.         return -EINVAL;
  9.     }

  11.     if (multiple_kthread_on == 0)
  12.         pr_debug("Single kernel thread for all KNI devices\n");
  13.     else
  14.         pr_debug("Multiple kernel thread mode enabled\n");

  16. #ifdef HAVE_SIMPLIFIED_PERNET_OPERATIONS
  17.     rc = register_pernet_subsys(&kni_net_ops); //在每个namespace中执行kni_net_ops->init函数
  18. #else
  19.     rc = register_pernet_gen_subsys(&kni_net_id, &kni_net_ops);
  20. #endif
  21.     if (rc)
  22.         return -EPERM;

  24.     rc = misc_register(&kni_misc); //注册kni misc设备
  25.     if (rc != 0) {
  26.         pr_err("Misc registration failed\n");
  27.         goto out;
  28.     }

  30.     /* Configure the lo mode according to the input parameter */
  31.     kni_net_config_lo_mode(lo_mode);

  33.     return 0;

  35. out:
  36. #ifdef HAVE_SIMPLIFIED_PERNET_OPERATIONS
  37.     unregister_pernet_subsys(&kni_net_ops);
  38. #else
  39.     unregister_pernet_gen_subsys(kni_net_id, &kni_net_ops);
  40. #endif
  41.     return rc;
  42. }

代码比较简单，首先选择kni的线程模式，分为单线程还是多线程，所谓单线程是指所有的kni端口收发都由一个线程守护，多线程只是每一个kni端口分为由一个线程守护，这部分是在插入模块时带入参数选择。

接着调用register_pernet_subsys在每个namespace中调用kni_net_ops->init函数，也就是kni_init_net。kni_init_net会在对应的namespace分配struct kni_net结构。

     最后调用注册函数misc_register，将kni注册为一个混杂设备，注册之后就会出现/dev/kni路径，用户态程序就可以对其进行open。其中kni_misc结构体里面定义了该混杂设备的一些操作

点击(此处)折叠或打开

  1. static struct miscdevice kni_misc = {
  2.     .minor = MISC_DYNAMIC_MINOR,
  3.     .name = KNI_DEVICE,
  4.     .fops = &kni_fops,
  5. };

这里主要看.fops里面的结构体

点击(此处)折叠或打开

  1. static const struct file_operations kni_fops = {
  2.     .owner = THIS_MODULE,
  3.     .open = kni_open,
  4.     .release = kni_release,
  5.     .unlocked_ioctl = (void *)kni_ioctl,
  6.     .compat_ioctl = (void *)kni_compat_ioctl,
  7. };

   其中任何用户态程序（如DPDK）要想内核kni发送数据前都需要调用这里的open函数，即kni_open。

点击(此处)折叠或打开

  1. static int
  2. kni_open(struct inode *inode, struct file *file)
  3. {
  4.     struct net *net = current->nsproxy->net_ns;
  5.     struct kni_net *knet = net_generic(net, kni_net_id);

  7.     /* kni device can be opened by one user only per netns */
  8.     if (test_and_set_bit(KNI_DEV_IN_USE_BIT_NUM, &knet->device_in_use))
  9.         return -EBUSY;

  11.     file->private_data = get_net(net);
  12.     pr_debug("/dev/kni opened\n");

  14.     return 0;
  15. }

kni_open主要是完成内核file结构private_data的设置。内核另外一个关键初始化函数为kni_ioctl_create，这是由用户态程序调用ioctl create执行的。此外我们注意到kni的kni_fops没有read/write函数，所以其不能像tap设备一样使用读写文件的方式进行数据收发。下面重点看kni_ioctl_create，简化后其主要流程如下：

点击(此处)折叠或打开

  1. static int
  2. kni_ioctl_create(struct net *net, uint32_t ioctl_num,
  3.         unsigned long ioctl_param)
  4. {
  5.     struct kni_net *knet = net_generic(net, kni_net_id);
  6.     int ret;
  7.     struct rte_kni_device_info dev_info;
  8.     struct net_device *net_dev = NULL;
  9.     struct kni_dev *kni, *dev, *n;

  11.     /* Copy kni info from user space */
  12.     ret = copy_from_user(&dev_info, (void *)ioctl_param, sizeof(dev_info));
  13.     if (ret) {
  14.         pr_err("copy_from_user in kni_ioctl_create");
  15.         return -EIO;
  16.     }

  18.     list_for_each_entry_safe(dev, n, &knet->kni_list_head, list) {
  19.         if (kni_check_param(dev, &dev_info) < 0) {
  20.             up_read(&knet->kni_list_lock);
  21.             return -EINVAL;
  22.         }
  23.     }
  24.     up_read(&knet->kni_list_lock);

  26.     /* 分配struct net_device结构，并将struct kni_dev作为net_device的private，并使用入参初始化 */
  27.     net_dev = alloc_netdev(sizeof(struct kni_dev), dev_info.name,
  28.                             kni_net_init);
  29.     if (net_dev == NULL) {
  30.         pr_err("error allocating device \"%s\"\n", dev_info.name);
  31.         return -EBUSY;
  32.     }
  33.     
  34.     dev_net_set(net_dev, net);

  36.     kni = netdev_priv(net_dev);

  38.     kni->net_dev = net_dev;
  39.     kni->group_id = dev_info.group_id;
  40.     kni->core_id = dev_info.core_id;
  41.     strncpy(kni->name, dev_info.name, RTE_KNI_NAMESIZE);

  43.     /* Translate user space info into kernel space info */
  44.     kni->tx_q = phys_to_virt(dev_info.tx_phys);
  45.     kni->rx_q = phys_to_virt(dev_info.rx_phys);
  46.     kni->alloc_q = phys_to_virt(dev_info.alloc_phys);
  47.     kni->free_q = phys_to_virt(dev_info.free_phys);

  49.     kni->req_q = phys_to_virt(dev_info.req_phys);
  50.     kni->resp_q = phys_to_virt(dev_info.resp_phys);
  51.     kni->sync_va = dev_info.sync_va;
  52.     kni->sync_kva = phys_to_virt(dev_info.sync_phys);

  54.     kni->mbuf_size = dev_info.mbuf_size;

  56.     if (kni->lad_dev)
  57.         ether_addr_copy(net_dev->dev_addr, kni->lad_dev->dev_addr);
  58.     else
  59.         /*
  60.          * Generate random mac address. eth_random_addr() is the newer
  61.          * version of generating mac address in linux kernel.
  62.          */
  63.         random_ether_addr(net_dev->dev_addr);
  64.     /* 将net_device结构注册在系统 */
  65.     ret = register_netdev(net_dev);

  67.     /* 创建数据处理线程 */
  68.     ret = kni_run_thread(knet, kni, dev_info.force_bind);
  69.     if (ret != 0)
  70.         return ret;

  72.     down_write(&knet->kni_list_lock);
  73.     list_add(&kni->list, &knet->kni_list_head);
  74.     up_write(&knet->kni_list_lock);

  76.     return 0;
  77. }

分配struct net_device结构使用kni_net_init进行初始化，并将struct kni_dev作为net_device的private，并使用入参初始化net_device，入参我们从DPDK用户态部分知道为struct rte_kni_device_info，而其又是存放kni设备对应的rte_kni_memzone_slot信息。所以这里就将用户态DPDK的rte_kni_memzone_slot中存放的各种queue的内存地址传递给内核kni_dev设备，实现了queue区域的内存共享。如下图所示。

随后调用register_netdev将kni对应的struct net_device结构结构注册给系统，因此kni设备我们也能使用ifconfig看到对应的网卡设备，可以使用tcpdump对其进行抓包。

最后kni_run_thread创建内存kni设备的收发线程。我们只看单线程情况，其线程执行函数为kni_thread_single：

点击(此处)折叠或打开

  1. static int
  2. kni_thread_single(void *data)
  3. {
  4.     struct kni_net *knet = data;
  5.     int j;
  6.     struct kni_dev *dev;

  8.     while (!kthread_should_stop()) {
  9.         down_read(&knet->kni_list_lock);
  10.         for (j = 0; j < KNI_RX_LOOP_NUM; j++) {
  11.             list_for_each_entry(dev, &knet->kni_list_head, list) {
  12.                 kni_net_rx(dev);
  13.                 kni_net_poll_resp(dev);
  14.             }
  15.         }
  16.         up_read(&knet->kni_list_lock);
  17.     }

  19.     return 0;
  20. }

   其主要循环遍历所有kni设备，调用kni_net_rx。而kni_net_rx又进一步调用kni_net_rx_func，kni_net_rx_func被初始化为kni_net_rx_normal。

点击(此处)折叠或打开

  1. static void
  2. kni_net_rx_normal(struct kni_dev *kni)
  3. {
  4.     uint32_t ret;
  5.     uint32_t len;
  6.     uint32_t i, num_rx, num_fq;
  7.     struct rte_kni_mbuf *kva;
  8.     void *data_kva;
  9.     struct sk_buff *skb;
  10.     struct net_device *dev = kni->net_dev;

  12.     /* Get the number of free entries in free_q */
  13.     num_fq = kni_fifo_free_count(kni->free_q);
  14.     if (num_fq == 0) {
  15.         /* No room on the free_q, bail out */
  16.         return;
  17.     }

  19.     /* Calculate the number of entries to dequeue from rx_q */
  20.     num_rx = min_t(uint32_t, num_fq, MBUF_BURST_SZ);

  22.     /* Burst dequeue from rx_q */
  23.     num_rx = kni_fifo_get(kni->rx_q, kni->pa, num_rx);
  24.     if (num_rx == 0)
  25.         return;

  27.     /* Transfer received packets to netif */
  28.     for (i = 0; i < num_rx; i++) {
  29.         kva = pa2kva(kni->pa[i]);
  30.         len = kva->pkt_len;
  31.         data_kva = kva2data_kva(kva);
  32.         kni->va[i] = pa2va(kni->pa[i], kva);

  34.         skb = dev_alloc_skb(len + 2);
  35.         if (!skb) {
  36.             /* Update statistics */
  37.             kni->stats.rx_dropped++;
  38.             continue;
  39.         }

  41.         /* Align IP on 16B boundary */
  42.         skb_reserve(skb, 2);

  44.         if (kva->nb_segs == 1) {
  45.             memcpy(skb_put(skb, len), data_kva, len);
  46.         } else {
  47.             int nb_segs;
  48.             int kva_nb_segs = kva->nb_segs;

  50.             for (nb_segs = 0; nb_segs < kva_nb_segs; nb_segs++) {
  51.                 memcpy(skb_put(skb, kva->data_len),
  52.                     data_kva, kva->data_len);

  54.                 if (!kva->next)
  55.                     break;

  57.                 kva = pa2kva(va2pa(kva->next, kva));
  58.                 data_kva = kva2data_kva(kva);
  59.             }
  60.         }

  62.         skb->dev = dev;
  63.         skb->protocol = eth_type_trans(skb, dev);
  64.         skb->ip_summed = CHECKSUM_UNNECESSARY;

  66.         /* Call netif interface */
  67.         netif_rx_ni(skb);

  69.         /* Update statistics */
  70.         kni->stats.rx_bytes += len;
  71.         kni->stats.rx_packets++;
  72.     }

  74.     /* Burst enqueue mbufs into free_q */
  75.     ret = kni_fifo_put(kni->free_q, kni->va, num_rx);
  76.     if (ret != num_rx)
  77.         /* Failing should not happen */
  78.         pr_err("Fail to enqueue entries into free_q\n");
  79. }

   其主要就是从共享内存队列的fifo中取出报文复制到对应的skb中，并注入free buf，最终调用netif_rx_ni(skb)进入协议栈。

   如果内核态向DPDK侧发送数据呢？前面讲到分配struct net_device结构使用kni_net_init进行初始化，其中将net_device的netdev_ops设置为kni_net_netdev_ops：

dev->netdev_ops = &kni_net_netdev_ops;

其ndo_start_xmit被设置为kni_net_tx，当我们从kni对应的net设备发送数据时最终就会调用到kni_net_tx。

点击(此处)折叠或打开

  1. static const struct net_device_ops kni_net_netdev_ops = {
  2.     .ndo_open = kni_net_open,
  3.     .ndo_stop = kni_net_release,
  4.     .ndo_set_config = kni_net_config,
  5.     .ndo_start_xmit = kni_net_tx,
  6.     .ndo_change_mtu = kni_net_change_mtu,
  7.     .ndo_do_ioctl = kni_net_ioctl,
  8.     .ndo_set_rx_mode = kni_net_set_rx_mode,
  9.     .ndo_get_stats = kni_net_stats,
  10.     .ndo_tx_timeout = kni_net_tx_timeout,
  11.     .ndo_set_mac_address = kni_net_set_mac,
  12. #ifdef HAVE_CHANGE_CARRIER_CB
  13.     .ndo_change_carrier = kni_net_change_carrier,
  14. #endif
  15. };
  16. static int
  17. kni_net_tx(struct sk_buff *skb, struct net_device *dev)
  18. {
  19.     int len = 0;
  20.     uint32_t ret;
  21.     struct kni_dev *kni = netdev_priv(dev);
  22.     struct rte_kni_mbuf *pkt_kva = NULL;
  23.     void *pkt_pa = NULL;
  24.     void *pkt_va = NULL;

  26.     /**
  27.      * Check if it has at least one free entry in tx_q and
  28.      * one entry in alloc_q.
  29.      */
  30.     if (kni_fifo_free_count(kni->tx_q) == 0 ||
  31.             kni_fifo_count(kni->alloc_q) == 0) {
  32.         /**
  33.          * If no free entry in tx_q or no entry in alloc_q,
  34.          * drops skb and goes out.
  35.          */
  36.         goto drop;
  37.     }

  39.     /* dequeue a mbuf from alloc_q */
  40.     ret = kni_fifo_get(kni->alloc_q, &pkt_pa, 1);
  41.     if (likely(ret == 1)) {
  42.         void *data_kva;

  44.         pkt_kva = pa2kva(pkt_pa);
  45.         data_kva = kva2data_kva(pkt_kva);
  46.         pkt_va = pa2va(pkt_pa, pkt_kva);

  48.         len = skb->len;
  49.         memcpy(data_kva, skb->data, len);
  50.         if (unlikely(len < ETH_ZLEN)) {
  51.             memset(data_kva + len, 0, ETH_ZLEN - len);
  52.             len = ETH_ZLEN;
  53.         }
  54.         pkt_kva->pkt_len = len;
  55.         pkt_kva->data_len = len;

  57.         /* enqueue mbuf into tx_q */
  58.         ret = kni_fifo_put(kni->tx_q, &pkt_va, 1);
  59.         if (unlikely(ret != 1)) {
  60.             /* Failing should not happen */
  61.             pr_err("Fail to enqueue mbuf into tx_q\n");
  62.             goto drop;
  63.         }
  64.     } else {
  65.         /* Failing should not happen */
  66.         pr_err("Fail to dequeue mbuf from alloc_q\n");
  67.         goto drop;
  68.     }

  70.     /* Free skb and update statistics */
  71.     dev_kfree_skb(skb);
  72.     kni->stats.tx_bytes += len;
  73.     kni->stats.tx_packets++;

  75.     return NETDEV_TX_OK;

  77. drop:
  78.     /* Free skb and update statistics */
  79.     dev_kfree_skb(skb);
  80.     kni->stats.tx_dropped++;

  82.     return NETDEV_TX_OK;
  83. }

   其主要逻辑就是将skb报文放入tx_q的fifo中。然后另一端DPDK从fifo中取出报文，完成内核到用户态的交互。以上我们就分析了kni设备的的DPDK和内核交互原理。

阅读(4255) | 评论(0) | 转发(0) |
0

上一篇：DPDK virtio-user介绍及使用

下一篇：linux tun/tap设备的实现（kennel 3.10）

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6