DPDK flow_filtering 源码阅读

最新推荐文章于 2023-10-15 11:25:59 发布
最新推荐文章于 2023-10-15 11:25:59 发布
阅读量470 收藏 2
点赞数 1
文章标签： 操作系统
原文链接：http://www.cnblogs.com/ZCplayground/p/9350354.html
版权

代码部分

main.c

/*-
 *   BSD LICENSE
 *
 *   Copyright 2017 Mellanox.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of Mellanox. nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/queue.h>
#include <netinet/in.h>
#include <setjmp.h>
#include <stdarg.h>
#include <ctype.h>
#include <errno.h>
#include <getopt.h>
#include <signal.h>
#include <stdbool.h>

#include <rte_eal.h>
#include <rte_common.h>
#include <rte_malloc.h>
#include <rte_ether.h>
#include <rte_ethdev.h>
#include <rte_mempool.h>
#include <rte_mbuf.h>
#include <rte_net.h>
#include <rte_flow.h>
#include <rte_cycles.h>

static volatile bool force_quit; // 确保本条指令不会因编译器的优化而省略
                                 // 用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。

static uint16_t port_id;
static uint16_t nr_queues = 5; // 收发队列各5条
static uint8_t selected_queue = 1;
struct rte_mempool *mbuf_pool;
struct rte_flow *flow;

#define SRC_IP ((0<<24) + (0<<16) + (0<<8) + 0) /* src ip = 0.0.0.0 */
#define DEST_IP ((192<<24) + (168<<16) + (1<<8) + 1) /* dest ip = 192.168.1.1 */
#define FULL_MASK 0xffffffff /* full mask */
#define EMPTY_MASK 0x0 /* empty mask */

#include "flow_blocks.c" // generate_ipv4_flow

static inline void
print_ether_addr(const char *what, struct ether_addr *eth_addr)
{
    char buf[ETHER_ADDR_FMT_SIZE];
    ether_format_addr(buf, ETHER_ADDR_FMT_SIZE, eth_addr); // Format 48bits Ethernet address in pattern xx:xx:xx:xx:xx:xx.
    printf("%s%s", what, buf);
}

static void
main_loop(void)
{
    struct rte_mbuf *mbufs[32];
    struct ether_hdr *eth_hdr;
    struct rte_flow_error error;
    uint16_t nb_rx;
    uint16_t i;
    uint16_t j;

    while (!force_quit) {
        for (i = 0; i < nr_queues; i++) {
            nb_rx = rte_eth_rx_burst(port_id,
                        i, mbufs, 32); // 收包
            if (nb_rx) {  // 该应用程序的主要工作是从所有队列读取数据包并打印目标队列的每个数据包
                for (j = 0; j < nb_rx; j++) {
                    struct rte_mbuf *m = mbufs[j];

                    eth_hdr = rte_pktmbuf_mtod(m,
                            struct ether_hdr *);
                    
                    /*rte_pktmbuf_mtod(m,t) 是一个宏，m 是 mbuf 指针
                    返回一个被强制转换成 t * 的指针。指向 mbuf 里的数据的开始处。
                    */
                        
                    print_ether_addr("src=",
                            &eth_hdr->s_addr); // 见文件 rte_ether.h 
                    print_ether_addr(" - dst=",
                            &eth_hdr->d_addr);
                    printf(" - queue=0x%x",
                            (unsigned int)i);
                    printf("\n");

                    rte_pktmbuf_free(m); // 收的包就直接free掉
                }
            }
        }
    }

    /* closing and releasing resources */
    rte_flow_flush(port_id, &error); // Destroy all flow rules associated with a port.
    rte_eth_dev_stop(port_id); // Stop an Ethernet device. 是函数 rte_eth_dev_start()的反义词
    rte_eth_dev_close(port_id); // Close a stopped Ethernet device. The device cannot be restarted
}

#define CHECK_INTERVAL 1000  /* 100ms */
#define MAX_REPEAT_TIMES 90  /* 9s (90 * 100ms) in total */

static void
assert_link_status(void)
{
    struct rte_eth_link link; // 用于检索以太网端口的链路级别信息的结构体
    uint8_t rep_cnt = MAX_REPEAT_TIMES;

    memset(&link, 0, sizeof(link));
    do {
        rte_eth_link_get(port_id, &link); // 获取链路的状态，可以获得如下信息：
        /*
        1. 开启或关闭（ON、OFF）
        2. 链路速度（单位 Mbps）
        3. 通信模式（半双工 or 全双工）
        
        两个参数，port id 和 rte_eth_link 的结构体指针
        这个函数可能会阻塞 9 秒钟。
        */
        if (link.link_status == ETH_LINK_UP) // 链路开启
            break;
        rte_delay_ms(CHECK_INTERVAL); // 等待至少N毫秒，位于rte_cycles.h
    } while (--rep_cnt);

    if (link.link_status == ETH_LINK_DOWN) // 链路关闭
        rte_exit(EXIT_FAILURE, ":: error: link is still down\n");
}

static void
init_port(void)
{
    int ret;
    uint16_t i;
    struct rte_eth_conf port_conf = { // 用于配置以太网口的结构体
        .rxmode = { // 端口 rx 配置
            .split_hdr_size = 0, // hdr buf size （todo）
            .ignore_offload_bitfield = 1, //（todo）
            .offloads = DEV_RX_OFFLOAD_CRC_STRIP, // 不进行 CRC
        },
        .txmode = { // 端口 tx 配置
            .offloads =
                DEV_TX_OFFLOAD_VLAN_INSERT |
                DEV_TX_OFFLOAD_IPV4_CKSUM  |
                DEV_TX_OFFLOAD_UDP_CKSUM   |
                DEV_TX_OFFLOAD_TCP_CKSUM   |
                DEV_TX_OFFLOAD_SCTP_CKSUM  |
                DEV_TX_OFFLOAD_TCP_TSO,
        },
    };
    struct rte_eth_txconf txq_conf;
    struct rte_eth_rxconf rxq_conf;
    struct rte_eth_dev_info dev_info;

    printf(":: initializing port: %d\n", port_id);
    ret = rte_eth_dev_configure(port_id, // 配置网口
                nr_queues, nr_queues, &port_conf); // 收发队列各5条
    if (ret < 0) {
        rte_exit(EXIT_FAILURE,
            ":: cannot configure device: err=%d, port=%u\n",
            ret, port_id);
    }

    rte_eth_dev_info_get(port_id, &dev_info); // 查询以太网设备信息
    rxq_conf = dev_info.default_rxconf; // Default RX configuration，类型：struct rte_eth_rxconf 
    rxq_conf.offloads = port_conf.rxmode.offloads;

    /* only set Rx queues: something we care only so far */
    for (i = 0; i < nr_queues; i++) { // 设置 rx queues
        ret = rte_eth_rx_queue_setup(port_id, i, 512,
                     rte_eth_dev_socket_id(port_id),
                     &rxq_conf, // rx queue的配置数据，类型是 const struct rte_eth_rxconf * 指针
                     mbuf_pool);
        if (ret < 0) {
            rte_exit(EXIT_FAILURE,
                ":: Rx queue setup failed: err=%d, port=%u\n",
                ret, port_id);
        }
    }

    txq_conf = dev_info.default_txconf;
    txq_conf.offloads = port_conf.txmode.offloads;

    for (i = 0; i < nr_queues; i++) { // 设置 tx queues
        ret = rte_eth_tx_queue_setup(port_id, i, 512,
                rte_eth_dev_socket_id(port_id),
                &txq_conf);// tx queue的配置数据，类型是 const struct rte_eth_txconf * 指针
        if (ret < 0) {
            rte_exit(EXIT_FAILURE,
                ":: Tx queue setup failed: err=%d, port=%u\n",
                ret, port_id);
        }
    }

    rte_eth_promiscuous_enable(port_id); // 启用混杂模式
    ret = rte_eth_dev_start(port_id); // 启动设备
    if (ret < 0) {
        rte_exit(EXIT_FAILURE,
            "rte_eth_dev_start:err=%d, port=%u\n",
            ret, port_id);
    }

    assert_link_status();

    printf(":: initializing port: %d done\n", port_id);
}

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

int
main(int argc, char **argv)
{
    int ret;
    uint8_t nr_ports;
    struct rte_flow_error error;

    ret = rte_eal_init(argc, argv); // 初始化 EAL
    if (ret < 0)
        rte_exit(EXIT_FAILURE, ":: invalid EAL arguments\n");

    /* signal(sig, handler) 设置某一信号的对应动作
    第一个参数signum指明了所要处理的信号类型，它可以取除了SIGKILL和SIGSTOP外的任何一种信号。
    第二个参数handler描述了与信号关联的动作，它可以取以下三种值：
    1.一个无返回值的函数地址
    2. SIG_IGN ：忽略
    3. SIG_DFL ：恢复默认处理
    */

    force_quit = false;
    signal(SIGINT, signal_handler);  // 中断信号
    signal(SIGTERM, signal_handler); // 程序结束(terminate)信号

    nr_ports = rte_eth_dev_count();
    if (nr_ports == 0)
        rte_exit(EXIT_FAILURE, ":: no Ethernet ports found\n");
    port_id = 0;
    if (nr_ports != 1) { // 本程序只需要使用 1 个以太网设备
        printf(":: warn: %d ports detected, but we use only one: port %u\n",
            nr_ports, port_id);
    }
    mbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", 4096, 128, 0,
                        RTE_MBUF_DEFAULT_BUF_SIZE,
                        rte_socket_id()); // 创建 mempool
    if (mbuf_pool == NULL)
        rte_exit(EXIT_FAILURE, "Cannot init mbuf pool\n");

    init_port(); // 端口初始化

    /* create flow for send packet with */
    // 参数：port id、queue index、IP四元组、error
    // flow 是 struct rte_flow
    flow = generate_ipv4_flow(port_id, selected_queue, // 将目的地ip等于192.168.1.1的数据包发送到队列号1
                SRC_IP, EMPTY_MASK,
                DEST_IP, FULL_MASK, &error);
    // 虽然配置了5条队列，但会把特定IP地址的流量放到一条特定的队列。
    // 是对 rte_flow_create() 这个函数的一层封装

    if (!flow) {
        printf("Flow can't be created %d message: %s\n",
            error.type,
            error.message ? error.message : "(no stated reason)");
        rte_exit(EXIT_FAILURE, "error in creating flow");
    }

    main_loop();

    return 0;
}

flow_blocks.c：

/*-
 *   BSD LICENSE
 *
 *   Copyright 2017 Mellanox.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of Mellanox nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#define MAX_PATTERN_NUM     4

struct rte_flow *
generate_ipv4_flow(uint16_t port_id, uint16_t rx_q,
        uint32_t src_ip, uint32_t src_mask,
        uint32_t dest_ip, uint32_t dest_mask,
        struct rte_flow_error *error);


/**
 * create a flow rule that sends packets with matching src and dest ip
 * to selected queue.
 *
 * @param port_id
 *   The selected port.
 * @param rx_q
 *   The selected target queue.
 * @param src_ip
 *   The src ip value to match the input packet.
 * @param src_mask
 *   The mask to apply to the src ip.
 * @param dest_ip
 *   The dest ip value to match the input packet.
 * @param dest_mask
 *   The mask to apply to the dest ip.
 * @param[out] error
 *   Perform verbose error reporting if not NULL.
 *
 * @return
 *   A flow if the rule could be created else return NULL.
 */
struct rte_flow *
generate_ipv4_flow(uint16_t port_id, uint16_t rx_q,
        uint32_t src_ip, uint32_t src_mask,
        uint32_t dest_ip, uint32_t dest_mask,
        struct rte_flow_error *error)
{
    struct rte_flow_attr attr;                      // 流的 attr
    struct rte_flow_item pattern[MAX_PATTERN_NUM];  // 流的 pattern。关于 item，见：http://doc.dpdk.org/api/structrte__flow__item.html
    struct rte_flow_action action[MAX_PATTERN_NUM]; // 流的 action ， 这三个是创建一个流的关键。
    struct rte_flow *flow = NULL;
    struct rte_flow_action_queue queue = { .index = rx_q };
    struct rte_flow_item_eth eth_spec; // spec 和
    struct rte_flow_item_eth eth_mask; // mask 是 item 的另外两个字段。void * ，但需要设置成和你选定的特定 type 一样。
    struct rte_flow_item_vlan vlan_spec;
    struct rte_flow_item_vlan vlan_mask;
    struct rte_flow_item_ipv4 ip_spec;
    struct rte_flow_item_ipv4 ip_mask;
    int res;

    memset(pattern, 0, sizeof(pattern));
    memset(action, 0, sizeof(action));

    /*
     * set the rule attribute.
     * in this case only ingress packets will be checked.
     */
    memset(&attr, 0, sizeof(struct rte_flow_attr));
    attr.ingress = 1; // 意思是只对入口流量生效的属性

    /*
     * create the action sequence.
     * one action only,  move packet to queue
     */

    action[0].type = RTE_FLOW_ACTION_TYPE_QUEUE; // 动作是：Assigns packets to a given queue index.
    action[0].conf = &queue;
    action[1].type = RTE_FLOW_ACTION_TYPE_END; // 动作数组必须用 RTE_FLOW_ACTION_TYPE_END 作为最后一个元素来结尾

    /*
     * set the first level of the pattern (eth).
     * since in this example we just want to get the
     * ipv4 we set this level to allow all.
     */

    // 第一个 item 用的是以太网地址
    // rte_flow_item_eth 的字段是 目的MAC地址、源MAC地址、Type
    memset(&eth_spec, 0, sizeof(struct rte_flow_item_eth));
    memset(&eth_mask, 0, sizeof(struct rte_flow_item_eth));
    eth_spec.type = 0;
    eth_mask.type = 0;
    pattern[0].type = RTE_FLOW_ITEM_TYPE_ETH; // item type 是 以太网的 item
    pattern[0].spec = &eth_spec; // 指向 eth_item 的指针（因为第一个type指定了rte_flow_item_eth）
    pattern[0].mask = &eth_mask; // 掩码设置成全 0，意味着所有以太网的header都是被允许的。

    /* spec、mask、last 在 pattern item 中的用途：
    For example, if for an IPv4 address field, spec provides 10.1.2.3, last provides 10.3.4.5 
    and mask provides 255.255.0.0, the effective range becomes 10.1.0.0 to 10.3.255.255.
    */

    /*
     * setting the second level of the pattern (vlan).
     * since in this example we just want to get the
     * ipv4 we also set this level to allow all.
     */
    // 第二个 item 用于匹配 vlan 标签
    // 也设置成了所有皆可匹配
    memset(&vlan_spec, 0, sizeof(struct rte_flow_item_vlan));
    memset(&vlan_mask, 0, sizeof(struct rte_flow_item_vlan));
    pattern[1].type = RTE_FLOW_ITEM_TYPE_VLAN;
    pattern[1].spec = &vlan_spec;
    pattern[1].mask = &vlan_mask;

    /*
     * setting the third level of the pattern (ip).
     * in this example this is the level we care about
     * so we set it according to the parameters.
     */
    // 第三个 item 匹配特定的IP地址，根据本函数的参数。
    memset(&ip_spec, 0, sizeof(struct rte_flow_item_ipv4));
    memset(&ip_mask, 0, sizeof(struct rte_flow_item_ipv4));
    // ipv4 item 的结构体里面有一个字段，是 ipv4_hdr

    ip_spec.hdr.dst_addr = htonl(dest_ip); // 将主机数转换成无符号长整型的网络字节顺序
    ip_mask.hdr.dst_addr = dest_mask;
    ip_spec.hdr.src_addr = htonl(src_ip);
    ip_mask.hdr.src_addr = src_mask;
    pattern[2].type = RTE_FLOW_ITEM_TYPE_IPV4;
    pattern[2].spec = &ip_spec;
    pattern[2].mask = &ip_mask;

    /* the final level must be always type end */
    // pattern 数组的最后必须用 END 宏结尾。
    pattern[3].type = RTE_FLOW_ITEM_TYPE_END;
    
    // 验证这条流的有效性
    res = rte_flow_validate(port_id, &attr, pattern, action, error);
    if (!res)
        flow = rte_flow_create(port_id, &attr, pattern, action, error);
    /* rte_flow_create() 在一个给定的端口上创建一条流规则（flow rule）
    参数五个
    1. port id
    2. attr 数组
    3. pattern 数组
    4. actions 数组
    5. rte_flow_error 指针，当有错误发生时，PMD会在此设置内容。

    返回值类型是  struct rte_flow*
    */

    return flow;
}
  • classify（分类） 与 filtering（过滤）的区别：
    • flow_classify 的思路是创建 classifer 对象，在 classifer 里配置一些 rule，在收到一批包后，主动地调用 query classifer 的 API，查看是否有 packet 符合了 classifer 里面的 rule，并执行对应的 action。
    • flow_filtering 的思路则是在 port 上设定 rule。对于满足 rule 的包，会采取特定的 actions。与 classify 的区别在于，filtering 是在端口上面设定 rule，只要经过这个端口的 ingress/egress 流量，都要进行 rule 的匹配。

可以看到，classify 和 filtering 共同的地方就是 rule。差别在于使用rule的方式。DPDK中，classify的库叫做rte_flow_classify.h，filtering的库叫做rte_flow.h，所以说它们之间还是有比较明显的区别。

  • rule（规则）的代码实现：体现为结构体 rte_flow_item_xxx ，xxx 有 attr、item 和 action
    • attr 是这条 rule 的属性，主要用到的有 ingress 和 egress，指明这条 rule 是针对入口还是出口流量生效。
    • item 就是规则的本体，用来匹配包里的特定的 header 的，代码中是通过堆叠 item 的方式来实现特定的匹配模式（pattern）。
    • action 就是匹配成功后的动作，通过设定宏来定义操作。宏是库文件自带的。常见的例如计数、丢包、转发到特定队列等。

这个 sample flow_filtering 里实现了这样的行为：设立5条收/发队列，收包时将目的IP地址等于 192.168.1.1 的数据包发送到队列号为1的发送队列。所以本 sample 实现的其实是一种类似 QoS 的功能（特定IP地址进入特定的队列处理）。如果真的想实现 filtering（过滤），就把 actions 定义为 Drop 吧。然后，逻辑核上的主线程运行main_loop，主要工作收包后，打印所有包的发送队列号。由于 rule 的作用，应该可以看到目的地 ip 等于192.168.1.1 的数据包的发送队列号一定为 1。

执行情况

1092156-20180722171022137-823989006.png

开始执行后，收到的包都到了0号队列（因为目的IP地址不是192.168.1.1）。然后使用scapy发目的IP地址设定为192.168.1.1的包到0号以太网口，发了十个包，可以看到十个包的转发队列为1号队列。

发包脚本如下：

from scapy.all import *

p_join = Ether(dst='a0:36:9f:20:43:92', src='a0:36:9f:20:43:90') / IP(src='172.17.173.64', dst='192.168.1.1', tos=0xc0)
p_join.show()
i = 0
while i < 10 :
    # enp1s0f0 -->
    # bind enpis0f1 to dpdk
    sendp(p_join,iface='enp1s0f0')
    i = i + 1

注意事项：

  • 本程序只需要绑定一个网口到DPDK即可。
  • 网卡必须支持多队列，且队列数目要5条以上。不然会报错，信息类似于：cannot configure device

reference

转载于:https://www.cnblogs.com/ZCplayground/p/9350354.html

weixin_30390075
关注
DPDK igb_uio驱动分析
fengcai_ke的博客
07-06 1002
dpdk igb_uio驱动分析
DPDK开发者手册流分类rte_flow
legend050709的专栏
03-18 4756
目录参考 参考 https://doc.dpdk.org/guides/prog_guide/index.html 【DPDK programmer guide】 https://doc.dpdk.org/guides/prog_guide/packet_distrib_lib.html 【Packet Distributor Library】
dpdk实例flow_classify
XuVowkin的博客
06-10 595
文章目录一.前言二.源码三.运行情况四.改动ipv4_rules_file.txt 一.前言 Flow Classify示例应用程序基于转发应用程序的简单框架示例。 它旨在演示使用Flow Classify库API的DPDK转发应用程序的基本组件。 flow_classify例子对于DPDK的学习具有很重要的意义，是比较重要的章节。有点类似于linux网络中的iptables功能，也有点类似于我们在linux内核中开发的防火墙功能。我们可以使用flow模块对数据包进行统计，丢弃等基本的操作。 二.源码 /*
DPDK官方例程分析(4)-flow_classify
小小程序员的博客
10-26 2430
前言 Flow Classify示例应用程序基于转发应用程序的简单框架示例。 它旨在演示使用Flow Classify库API的DPDK转发应用程序的基本组件 flow_classify例子对于DPDK的学习具有很重要的意义，是比较重要的章节。有点类似于linux网络中的iptables功能，也有点类似于我们在linux内核中开发的防火墙功能。我们可以使用flow模块对数据包进行统计，丢弃等基本的操作。 程序代码 ACL介绍 首先该例程中主要是面向的对象是IP流量中的五元组信息。即源ip地址，目的ip地址，
DPDK的flow_filtering示例
redwingz的博客
04-29 3381
主函数初始化EAL，分配存储mbuf的内存池mempool，初始化接口init_port，DPDK的此示例仅支持一个port接口运行。随后调用完成流控制的generate_ipv4_flow函数。 int main(int argc, char **argv) { ret = rte_eal_init(argc, argv); nr_ports = rte_eth_dev_c...
DPDK flow_classify 源码阅读
weixin_30693683的博客
07-18 1107
代码部分 /* SPDX-License-Identifier: BSD-3-Clause * Copyright(c) 2017 Intel Corporation */ #include <stdint.h> #include <inttypes.h> #include <getopt.h> #include <rte_eal.h> #i...
NXP电机开发套件(MCSPTE1AK144)学习记录
weixin_43626341的博客
01-06 4673
NXP电机开发套件学习记录1. 概述2. 规格2.1. 核心板原理图2.2. 驱动板原理图3. BLDC3.1. BLDC的基本原理3.2. BLDC六步换向控制(HallSensor)3.3. BLDC六步换向控制(无感)4.PMSM4.1. PMSM的基本原理4.2. PMSM FOC控制(Encoder)4.2. PMSM FOC控制(无感) 1. 概述 MCSPTE1AK144是NXP推出的一款电机开发套件，主要用于BLDC和PMSM电机控制应用的快速原型设计和评估。 2. 规格 项目 参数
pktgen-dpdk-pktgen-2.9.7.tar.gz_dpdk 发包_dpdk 发包工具_dpdk发包_发包工具 li
09-20
Pktgen-DPDK是网络测试领域中一个重要的开源项目，它是一个高度可配置的、基于DPDK（Data Plane Development Kit）的流量生成工具。DPDK是一个由Intel开发的库，用于加速网络应用的处理速度，通过绕过操作系统内核，...
dpdk-replay.rar_dpdk_dpdk 数据回放_linux_recognize7z9
07-14
使用dpdk高速回放pcap文件，分为拷贝和不拷贝版本，可根据需要自行选择
dpdk flow filter总结（flow director/ rte_flow）
shaoyunzhe的专栏
07-06 2515
dpdk flow filter
rte_flow流规则的创建流程
a3876247995的博客
02-21 2748
rte_flow的创建流程 DPDK通过rte_flow提供的流控制功能，通过dpdk example中的flow_filtering实例，可以看到rte_flow的简单应用。实例实现的功能为：针对指定目的IP的报文，进入指定的网卡rx队列。实现步骤如下： 创建struct rte_flow_attr，指定匹配报文的方向。 创建struct rte_flow_action，指定动作类型为报文通过特定rx队列接收。 创建struct rte_flow_item，指定匹配报文的IP地址。 调用rte_flow
DPDK数据流过滤规则例程解析—— 网卡流处理功能窥探
weixin_37097605的博客
05-08 1428
作者简介张凯 软件工程师主要从事LINUX内核网络和虚拟化相关研发工作。当前的高性能网卡通常都支持对数据流的定向和过滤功能，可通过配置将指定的数据流定向到指定的设备队列...
DPDK实践二：用TestPMD测试DPDK性能和功能
造梦先森Kai的专栏
01-20 1万+
本文介绍了数据平面开发工具包（DPDK）TestPMD应用程序，展示了如何构建和配置TestPMD, 以及如何用它来检查使用DPDK的不同网络设备的性能和功能。 TestPMD是一个使用DPDK软件包分发的参考应用程序。其主要目的是在网络接口的以太网端口之间转发数据包。此外，用户还可以用TestPMD尝试一些不同驱动程序的功能，例如RSS，过滤器和英特尔®以太网流量控制器（Intel® Ether...
DPDK系列之三十四DPDK并行机制的同步控制
最新发布
fpcc的专栏
10-15 388
锁的机制在不同的层次上有着不同的表述和表现形式，在不同的语言上可能又会衍生出不同的形式。这就需要开发者去仔细的分析其真正使用的哪种锁，从而能更好的对其进行应用。可以试着看一下Mutex在内核中是如何实现的(futex机制)，其实就明白了上面的话的意思。底层建设一直是重要的环节，侯捷老师说过：勿在浮沙筑高台。
关于 DPDK 的 一些零散的杂言杂语的念头/看法
xzhao28的专栏
11-12 802
由于某些原因，回顾了之前 DPDK 的一些学习。有一些零散的杂言杂语的念头/看法，原本分散在各处，之前没有记录下来。这里简单记录补充一下。 =============================================================================================================== @@@ #1. DPDK 的各种 API subset 的定义，肯定是从 通用性的角度 来定义，目标是 “期望尽量generic，定义一些co
DPDK19.05 rte_flow 的 rss 支持情况
Andrew Yang's Note
07-01 1000
DPDK19.05 rte_flow 的 rss 支持情况： 结论 实验和查看源码得出： driver supports supports igb rss ntuple + queue ixgbe rss ntuple + queue i40e eth + rss, vlan + rss ntuple + queue 证据 igb, ixgbe 都没有看到 ntuple 和 rss 组合使用： static int igb_parse_rss_filter(struct rte_
网卡多队列：RPS、RFS、RSS、Flow Director（DPDK支持）
热门推荐
RToax
10-09 1万+
网卡多队列是传统网卡的DMA队列有多个，网卡有基于多个DMA队列的分配机制。多队列网卡已经是当前高速率网卡的主流。默认情况下，每个网络接口都有一个流量队列，一次由一个CPU处理。由于SND（安全网络分发器，SecureXL和CoreXL调度程序）在处理流量队列的CPU上运行，因此用于加速的CPU数量不能超过处理流量的接口数量。多队列可让您为每个网络接口配置多个流量队列。这意味着可以使用多个CPU进行加速。
dpdk- generic flow API-通用流API介绍
qq_39992615的博客
08-30 841
dpdk- generic flow API-通用流库generic flow API介绍流规则属性模式条目 generic flow API介绍 根据我的理解，通用流API的用途主要是进行过滤，比方说我想进行抓包，就可以利用该API对网卡捕捉到的所有包进行过滤，得到我想要的数据包。 ——也就是说它可以根据特定的模式对捕捉到的包进行匹配 该API所引用的头文件为: #include<rte...
DPDK命令行参数处理源码解析
资源摘要信息:"dpdk-cmdline是DPDK(Direct Memory Access for fast network packet)命令行参数解析库的源码。DPDK是一个开源的高性能网络库，用于快速数据包处理。其特点是在用户空间中进行数据包的传输和处理，从而...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值