dpdk kni开关

您好！对于DPDK（Data Plane Development Kit）中的KNI（Kernel NIC Interface），它是用于在用户空间和内核空间之间传递数据包的接口。KNI可以通过在DPDK应用程序和Linux内核之间创建虚拟设备来实现这种通信。

要开启KNI功能，您需要在DPDK应用程序中进行一些设置。下面是一些基本步骤：

1. 在DPDK应用程序的配置文件（例如config文件）中启用KNI支持。您可以通过设置`CONFIG_RTE_KNI=y`来实现。

2. 在DPDK应用程序的初始化代码中，使用`rte_kni_init()`函数来初始化KNI接口。

3. 在初始化代码中，使用`rte_kni_alloc()`函数来分配一个或多个KNI设备。您可以指定每个设备的名称、MTU（最大传输单元）等参数。

4. 配置KNI设备的网络参数，例如IP地址和MAC地址。您可以使用`rte_kni_config_network_interface()`函数来设置这些参数。

5. 启动KNI设备。使用`rte_kni_start()`函数来启动已配置的KNI设备。

通过执行上述步骤，您将能够在DPDK应用程序中启用并使用KNI接口。这样，您就可以在用户空间和内核空间之间传递数据包，并实现更灵活的数据包处理和网络功能。

请注意，KNI的具体配置和使用可能会因DPDK版本和应用程序需求而有所不同。上述步骤仅提供了一般的指导，您可能需要根据实际情况进行适当的调整和配置。

相关问题

dpdk kni接管

### 使用DPDK KNI进行网络接口接管

#### 配置DPDK环境
为了使用DPDK KNI进行网络接口接管，首先需要确保已经正确安装并配置好DPDK环境。这包括下载适合版本的DPDK源码包、编译以及设置大页内存等必要操作[^2]。

#### 编写KNI示例程序
编写简单的测试应用程序来验证KNI功能是否正常工作非常重要。通常情况下，可以从官方文档中的例子入手，在此基础上修改以满足特定需求。例如创建一个新的虚拟网口并与之关联相应的物理端口：

#include <rte_kni.h>
// 创建KNI实例函数...
struct rte_kni *kni = rte_kni_alloc(...);

#### 理解KNI工作机制
当涉及到具体实现细节时，理解KNI的工作机制至关重要。它实际上是在用户空间和内核之间建立了一座桥梁——即所谓的“Kernel NIC Interface”。此接口能够有效地减少数据传输过程中的复制次数，并且使得基于DPDK的应用可以直接利用Linux系统的标准命令行工具来进行管理和监控[^1]。

#### 接入内核协议栈
为了让来自外部的数据帧进入操作系统内部处理流程（比如TCP/IP堆栈），必须将捕获到的信息传递给上层软件组件。对于每一个接收到的新分组而言，如果发现其目的地正是本地主机，则应该调用`rte_kni_tx_burst()`方法将其送至对应的队列等待进一步解析；相反地，如果是准备发送出去的内容则需经过类似的路径反向流动直至最终抵达目标位置[^4]。

#### 调试与优化
在整个过程中可能会遇到各种各样的挑战，因此掌握有效的调试技巧显得尤为关键。除了依赖于传统的日志记录外，还可以借助于诸如perf之类的性能分析器找出潜在瓶颈所在之处加以改进。另外值得注意的是，由于不同硬件平台间存在差异性，所以在移植项目之前务必仔细阅读相关手册以便做出适当调整。

dpdk kni代码示例

以下是一个使用DPDK KNI的简单代码示例，该代码示例将从一个物理端口接收数据包并将其发送回同一端口，同时使用KNI将数据包从内核接收并发送到用户空间，以便进一步处理或分析：

#include <stdio.h>
#include <string.h>
#include <errno.h>
#include <unistd.h>
#include <signal.h>
#include <stdint.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/queue.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#include <rte_eal.h>
#include <rte_common.h>
#include <rte_ethdev.h>
#include <rte_kni.h>
#include <rte_malloc.h>

#define RX_RING_SIZE 1024
#define TX_RING_SIZE 1024
#define NUM_MBUFS 8191
#define MBUF_CACHE_SIZE 250
#define BURST_SIZE 32

#define KNI_PORT_ID 1
#define KNI_RX_QUEUE_ID 0
#define KNI_TX_QUEUE_ID 0

static volatile bool force_quit;

static void
signal_handler(int signum)
{
    if (signum == SIGINT || signum == SIGTERM) {
        printf("signal %d received, preparing to exit...\n", signum);
        force_quit = true;
    }
}

static int
init_kni(uint16_t port_id, struct rte_mempool *mbuf_pool, struct rte_kni **kni)
{
    struct rte_kni_conf conf;
    struct rte_kni_ops ops;
    int ret;

    memset(&conf, 0, sizeof(conf));
    memset(&ops, 0, sizeof(ops));

    snprintf(conf.name, RTE_KNI_NAMESIZE, "kni%d", port_id);
    conf.core_id = rte_lcore_id();
    conf.force_bind = 1;
    conf.group_id = (uint16_t)rte_eth_dev_socket_id(port_id);

    ops.port_id = port_id;
    ops.change_mtu = NULL;
    ops.config_network_if = NULL;
    ops.config_mac_address = NULL;

    *kni = rte_kni_alloc(mbuf_pool, &conf, &ops);
    if (*kni == NULL) {
        printf("Failed to create kni for port %u: %s\n", port_id, strerror(errno));
        return -1;
    }

    ret = rte_kni_tx_burst(*kni, NULL, 0);
    if (ret < 0) {
        printf("Failed to send kni request for port %u: %s\n", port_id, strerror(errno));
        rte_kni_release(*kni);
        return -1;
    }

    return 0;
}

static int
init_port(uint16_t port_id, struct rte_mempool *mbuf_pool)
{
    struct rte_eth_conf port_conf = {
        .rxmode = {
            .max_rx_pkt_len = RTE_ETHER_MAX_LEN,
            .split_hdr_size = 0,
            .header_split = 0,
            .hw_ip_checksum = 0,
            .hw_vlan_filter = 0,
            .hw_vlan_strip = 0,
            .hw_vlan_extend = 0,
            .jumbo_frame = 0,
            .hw_strip_crc = 0,
            .hw_fcs_strip = 0,
        },
        .txmode = {
            .mq_mode = ETH_MQ_TX_NONE,
        },
    };
    const uint16_t rx_rings = 1, tx_rings = 1;
    struct rte_eth_dev_info dev_info;
    struct rte_eth_txconf txconf;
    int ret;
    uint16_t q;
    struct rte_eth_rxconf rxconf;

    if (!rte_eth_dev_is_valid_port(port_id)) {
        printf("Invalid port id %u\n", port_id);
        return -1;
    }

    rte_eth_dev_info_get(port_id, &dev_info);
    if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
        port_conf.txmode.offloads |= DEV_TX_OFFLOAD_MBUF_FAST_FREE;

    ret = rte_eth_dev_configure(port_id, rx_rings, tx_rings, &port_conf);
    if (ret != 0) {
        printf("Failed to configure port %u: %s\n", port_id, strerror(-ret));
        return ret;
    }

    ret = rte_eth_dev_adjust_nb_rx_tx_desc(port_id, RX_RING_SIZE, TX_RING_SIZE);
    if (ret != 0) {
        printf("Failed to adjust number of rx/tx descriptors for port %u: %s\n", port_id, strerror(-ret));
        return ret;
    }

    rxconf = dev_info.default_rxconf;
    rxconf.offloads = port_conf.rxmode.offloads;
    for (q = 0; q < rx_rings; q++) {
        ret = rte_eth_rx_queue_setup(port_id, q, RX_RING_SIZE, rte_eth_dev_socket_id(port_id), &rxconf, mbuf_pool);
        if (ret < 0) {
            printf("Failed to setup rx queue %u for port %u: %s\n", q, port_id, strerror(-ret));
            return ret;
        }
    }

    txconf = dev_info.default_txconf;
    txconf.offloads = port_conf.txmode.offloads;
    for (q = 0; q < tx_rings; q++) {
        ret = rte_eth_tx_queue_setup(port_id, q, TX_RING_SIZE, rte_eth_dev_socket_id(port_id), &txconf);
        if (ret < 0) {
            printf("Failed to setup tx queue %u for port %u: %s\n", q, port_id, strerror(-ret));
            return ret;
        }
    }

    ret = rte_eth_dev_start(port_id);
    if (ret < 0) {
        printf("Failed to start port %u: %s\n", port_id, strerror(-ret));
        return ret;
    }

    rte_eth_promiscuous_enable(port_id);

    return 0;
}

static void
handle_packet(uint16_t port_id, struct rte_mbuf *mbuf, struct rte_kni *kni)
{
    struct rte_mbuf *pkts_burst[1];
    uint16_t nb_rx, nb_tx;
    struct rte_mbuf *bufs[BURST_SIZE];
    unsigned i;

    if (mbuf == NULL) {
        return;
    }

    nb_tx = rte_kni_tx_burst(kni, &mbuf, 1);
    if (nb_tx == 0) {
        rte_pktmbuf_free(mbuf);
        return;
    }

    nb_rx = rte_kni_rx_burst(kni, bufs, BURST_SIZE);
    if (nb_rx > 0) {
        printf("Received %u packets from KNI for port %u\n", nb_rx, port_id);
        for (i = 0; i < nb_rx; i++) {
            pkts_burst[0] = bufs[i];
            nb_tx = rte_eth_tx_burst(port_id, 0, pkts_burst, 1);
            if (nb_tx == 0) {
                rte_pktmbuf_free(pkts_burst[0]);
            }
        }
    }

    rte_pktmbuf_free(mbuf);
}

static int
lcore_main(void *arg)
{
    uint16_t port_id = *(uint16_t *)arg;
    struct rte_mbuf *bufs[BURST_SIZE];
    struct rte_kni *kni;
    unsigned i, nb_rx, nb_tx;

    if (init_kni(port_id, rte_pktmbuf_pool_create("KNI_MBUF_POOL", NUM_MBUFS, MBUF_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id()), &kni) != 0) {
        return -1;
    }

    if (init_port(port_id, rte_pktmbuf_pool_create("MBUF_POOL", NUM_MBUFS, MBUF_CACHE_SIZE, 0, RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id())) != 0) {
        return -1;
    }

    printf("Core %u processing packets for port %u...\n", rte_lcore_id(), port_id);

    while (!force_quit) {
        nb_rx = rte_eth_rx_burst(port_id, 0, bufs, BURST_SIZE);
        if (nb_rx > 0) {
            printf("Received %u packets from port %u\n", nb_rx, port_id);
            for (i = 0; i < nb_rx; i++) {
                handle_packet(port_id, bufs[i], kni);
            }
        }

        nb_tx = rte_eth_tx_burst(port_id, 0, NULL, 0);
        if (nb_tx > 0) {
            printf("Sent %u packets to port %u\n", nb_tx, port_id);
        }
    }

    rte_kni_release(kni);

    return 0;
}

int
main(int argc, char **argv)
{
    int ret;
    uint16_t port_id;
    uint16_t nb_ports;
    uint16_t port_ids[RTE_MAX_ETHPORTS];
    unsigned lcore_id;
    unsigned nb_lcores;

    ret = rte_eal_init(argc, argv);
    if (ret < 0) {
        printf("Failed to initialize EAL: %s\n", rte_strerror(-ret));
        return -1;
    }

    argc -= ret;
    argv += ret;

    if (argc != 1) {
        printf("Invalid arguments\n");
        printf("Usage: %s <port_id>\n", argv[0]);
        return -1;
    }

    port_id = atoi(argv[1]);
    if (port_id >= RTE_MAX_ETHPORTS) {
        printf("Invalid port id %u\n", port_id);
        return -1;
    }

    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);

    nb_ports = rte_eth_dev_count_avail();
    if (nb_ports == 0) {
        printf("No Ethernet ports available\n");
        return -1;
    }

    rte_eth_dev_info_get(port_id, &dev_info);

    nb_lcores = rte_lcore_count();
    if (nb_lcores < 2) {
        printf("Insufficient number of lcores: %u\n", nb_lcores);
        return -1;
    }

    printf("Initializing port %u...\n", port_id);

    ret = rte_eth_dev_get_port_by_name(dev_info.driver_name, dev_info.device->name, &port_id);
    if (ret != 0) {
        printf("Failed to get port id for %s: %s\n", dev_info.device->name, strerror(-ret));
        return -1;
    }

    rte_eth_macaddr_get(port_id, &dev_info.default_mac_addr);

    RTE_ETH_FOREACH_DEV(port_id) {
        port_ids[nb_ports++] = port_id;
    }

    for (lcore_id = 1; lcore_id < nb_lcores; lcore_id++) {
        rte_eal_remote_launch(lcore_main, &port_ids[port_id], lcore_id);
    }

    lcore_id = 0;
    lcore_main(&port_ids[port_id]);

    rte_eal_mp_wait_lcore();

    return 0;
}

这个示例程序使用DPDK KNI将数据包从内核接收并发送到用户空间进行处理，并将处理后的数据包发送回同一物理端口。在实际应用中，可以根据需要对代码进行修改和优化，以满足不同的需求。