我需要代码片段来嵌入以太网 header 以及从辅助 DPDK 应用程序到主应用程序的有效载荷

Question

架构如下：

次要 DPDK 应用程序 ------> 主要 DPDK 应用程序 ----> (编辑)接口

在我的辅助节点中，我有一个表示 L2 数据包的 u8 字节向量。我想将此 L2 数据包发送到主应用程序，以便主应用程序可以将其发送到互联网。据我了解，L2 数据包必须用 mbuf 包装才能放在共享环上。但是我不知道如何进行这种包装。

我不太清楚：我的数据包只是一个字节向量，我怎样才能从中提取有用的信息来填充 mbuf 字段？ mbuf 的哪些字段应该最少填充以使其工作？

为了更好地理解，这里是应该逐步发生的事情：

字节向量进入次级（不管如何）
Secondary 从共享内存池中获取一个 mbuf。
Secondary把vector放在mbuf里面（vector是L2数据包）

mbuf 有很多字段代表很多东西，所以我不知道该填哪个字段，填什么。

Secondary 将 mbuf 放在共享环上。
Primary 从共享环中获取 mbuf。
主要将 mbuf 发送到互联网。

这是我目前编写的代码，辅助应用程序是用 Rust 编写的，主要应用程序是用 C 语言编写的。

中学来了 (github):

请记住，L2 Packet 只是 Vec，就像 [1, 222, 23, 34...]，一个简单的数组。

       // GETTING THE MBUF FROM SHARED MEMPOOL 
       let mut my_buffer = self.do_rte_mempool_get();
        while let Err(er) = my_buffer {
            warn!("rte_mempool_get failed, trying again.");
            my_buffer = self.do_rte_mempool_get();
            // it may fail if not enough entries are available.
        }
        warn!("rte_mempool_get success");
        // Let's just send an empty packet for starters.
        let my_buffer = my_buffer.unwrap();
        
        // HERE I SHOULD PUT THE L2 PACKET INSIDE THE MBUF.
        // MY L2 PACKET is a Vec<u8> 
        
        // NOW I PUT THE MBUF ON THE SHARED RING, BYE MBUF

        let mut res = self.do_rte_ring_enqueue(my_buffer);
        // it may fail if not enough room in the ring to enqueue
        while let Err(er) = res {
            warn!("rte_ring_enqueue failed, trying again.");
            res = self.do_rte_ring_enqueue(my_buffer);
        }
        warn!("rte_ring_enqueue success");

Primary 在这里（它只是从 ring 获取 mbufs 并且必须用 rte_eth_tx_burst() 发送它们）：

/* Run until the application is quit or killed. */
for (;;)
{
    // receive packets on rte ring
    // then send them to NIC


    struct rte_mbuf *bufs[BURST_SIZE];
    void *mbuf;

    if (rte_ring_dequeue(recv_ring, &mbuf) < 0) {
        continue;
    }

    printf("Received mbuf.\n");
    //for now I just want to test it out so I stop here
    continue;

    //* Send packet to port */
    bufs[0] = mbuf;
    uint16_t nbPackets = 1;
    const uint16_t nb_tx = rte_eth_tx_burst(port, 0,
                                            bufs, nbPackets);

    // /* Free any unsent packets. */
    if (unlikely(nb_tx < nbPackets))
    {   
        rte_pktmbuf_free(bufs[nbPackets]);
    }

如果您有任何问题，请告诉我！一如既往，感谢阅读！

更新： dpdk primary 实际上没有连接到互联网。它只是使用虚拟机的界面。 DPDK 次要和主要都在虚拟机中运行并且主要使用的接口通过网桥连接到主机接口。所以我可以使用 tcpdump 在主机上查看有问题的网桥。

我尝试将 L2 数据包放入辅助的 mbuf 中，它看起来像这样：

（你也可以查看github）

 // After receiving something on the channel
        // I want to send it to the primary DPDK
        // And the primary will send it to hardware NIC
        
        let mut my_buffer = self.do_rte_mempool_get();
        while let Err(er) = my_buffer {
            warn!("rte_mempool_get failed, trying again.");
            my_buffer = self.do_rte_mempool_get();
            // it may fail if not enough entries are available.
        }
        warn!("rte_mempool_get success");
        // Let's just send an empty packet for starters.
        let my_buffer = my_buffer.unwrap();
        let my_buffer_struct: *mut rte_mbuf = my_buffer as (*mut rte_mbuf);
        
       unsafe {
            // the packet buffer, not the mbuf
            let buf_addr: *mut c_void = (*my_buffer_struct).buf_addr;
            let mut real_buf_addr = buf_addr.offset((*my_buffer_struct).data_off as isize);
            //try to copy the Vec<u8> inside the mbuf
            copy(my_data.as_mut_ptr(), real_buf_addr as *mut u8, my_data.len());
            (*my_buffer_struct).data_len = my_data.len() as u16;
       };

(my_data就是上面代码片段中的Vec)

现在，在主 DPDK 上，我正在接收那些字节，它们是 L2 数据包的字节。我把它们打印出来了，它们和中学的一样，很棒。

for (;;)
{
    // receive packets on rte ring
    // then send them to NIC


    struct rte_mbuf *bufs[BURST_SIZE];
    void *mbuf;
    unsigned char* my_packet;
    uint16_t data_len;
    uint16_t i = 0;

    if (rte_ring_dequeue(recv_ring, &mbuf) < 0) {
        continue;
    }

    printf("Received mbuf.\n");
    my_packet = ((unsigned char *)(*(struct rte_mbuf *)mbuf).buf_addr) + ((struct rte_mbuf *)mbuf)->data_off;
    data_len = ((struct rte_mbuf *)mbuf)->data_len;
    for (i = 0; i < data_len; i++) {
        printf("%d ", (uint8_t)my_packet[i]);
    }
    printf("\n");



    //for now I just want to test it out so I stop here
    // rte_pktmbuf_free(mbuf);
    // continue;

    //* Send packet to port */
    bufs[0] = (struct rte_mbuf *)mbuf;
    uint16_t nbPackets = 1;
    const uint16_t nb_tx = rte_eth_tx_burst(port, 0,
                                            bufs, nbPackets);

    // /* Free any unsent packets. */
    if (unlikely(nb_tx < nbPackets))
    {   
        rte_pktmbuf_free(bufs[nbPackets]);
    }

但问题是，在使用 eth_tx_burst 从主服务器发送 mbuf 后，我在主机上使用 tcpdump 时看不到任何数据包。所以我猜我没有正确地将数据包包装在 mbuf 中。我希望它更有意义。

Answer 1

@Mihai，如果需要在辅助中创建 DPDK 缓冲区并通过 RTE_RING 发送，请按照以下步骤进行操作

启动辅助应用程序
通过rte_mempool_lookup
通过rte_pktmbuf_alloc
将 mbuf 中的最小字段设置为适当的值，例如 pkt_len, data_len, next and nb_segs。
获取区域的起始位置以 mem 复制您的自定义数据包 rte_pktmbuf_mtod_offset or rte_pktmbuf_mtod
然后memcopy用户向量中的内容到DPDK区

注意：根据checksum offload，实际frame len和chain mbuf mode等字段需要更新。

代码片段

mbuf_ptr = rte_pktmbuf_alloc(mbuf_pool);
mbuf_ptr->data_len = [size of vector preferably under 1500];
mbuf_ptr->pkt_len = mbuf_ptr->data_len;
struct rte_ether_hdr *eth_hdr = rte_pktmbuf_mtod(created_pkt, struct rte_ether_hdr *);
rte_memcpy(&eth_addr, &user_buffer, mbuf_ptr->data_len);

注意：与上述代码类似的代码已在 Rust + C wireguard 中实现，以使用 DPDK 启用。

请将以上代码修改到您的代码中

            warn!("rte_mempool_get success");
            // Let's just send an empty packet for starters.
            let my_buffer = my_buffer.unwrap();
            let my_buffer_struct: *mut rte_mbuf = my_buffer as (*mut rte_mbuf);
            
           unsafe {
                // the packet buffer, not the mbuf
                let buf_addr: *mut c_void = (*my_buffer_struct).buf_addr;
                let mut real_buf_addr = buf_addr.offset((*my_buffer_struct).data_off as isize);
                //try to copy the Vec<u8> inside the mbuf
                copy(my_data.as_mut_ptr(), real_buf_addr as *mut u8, my_data.len());
                (*my_buffer_struct).data_len = my_data.len() as u16;
           };
            
            unsafe {
                warn!("Length of segment buffer: {}", (*my_buffer_struct).buf_len);
                warn!("Data offset: {}", (*my_buffer_struct).data_off);
                let buf_addr: *mut c_void = (*my_buffer_struct).buf_addr;
                let real_buf_addr = buf_addr.offset((*my_buffer_struct).data_off as isize);
                warn!("Address of buf_addr: {:?}", buf_addr);
                warn!("Address of buf_addr + data_off: {:?}", real_buf_addr);
                warn!("\n");
            };

我需要代码片段来嵌入以太网 header 以及从辅助 DPDK 应用程序到主应用程序的有效载荷

I need code snippet to embed the ethernet header with payload from secondary DPDK application to primary

dpdk