dpdk实例flow_classify
Posted 想实习犯法吗
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了dpdk实例flow_classify相关的知识，希望对你有一定的参考价值。
文章目录
一.前言
Flow Classify示例应用程序基于转发应用程序的简单框架示例。
它旨在演示使用Flow Classify库API的DPDK转发应用程序的基本组件。
flow_classify例子对于DPDK的学习具有很重要的意义，是比较重要的章节。有点类似于linux网络中的iptables功能，也有点类似于我们在linux内核中开发的防火墙功能。我们可以使用flow模块对数据包进行统计，丢弃等基本的操作。
二.源码
/* SPDX-License-Identifier: BSD-3-Clause
* Copyright(c) 2017 Intel Corporation
*/
#include <stdint.h>
#include <inttypes.h>
#include <getopt.h>
#include <rte_eal.h>
#include <rte_ethdev.h>
#include <rte_cycles.h>
#include <rte_lcore.h>
#include <rte_mbuf.h>
#include <rte_flow.h>
#include <rte_flow_classify.h>
#include <rte_table_acl.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 MAX_NUM_CLASSIFY 30
#define FLOW_CLASSIFY_MAX_RULE_NUM 91
#define FLOW_CLASSIFY_MAX_PRIORITY 8
#define FLOW_CLASSIFIER_NAME_SIZE 64
#define COMMENT_LEAD_CHAR ('#')
#define OPTION_RULE_IPV4 "rule_ipv4"
#define RTE_LOGTYPE_FLOW_CLASSIFY RTE_LOGTYPE_USER3
#define flow_classify_log(format, ...) \\
RTE_LOG(ERR, FLOW_CLASSIFY, format, ##__VA_ARGS__)
#define uint32_t_to_char(ip, a, b, c, d) do \\
*a = (unsigned char)(ip >> 24 & 0xff);\\
*b = (unsigned char)(ip >> 16 & 0xff);\\
*c = (unsigned char)(ip >> 8 & 0xff);\\
*d = (unsigned char)(ip & 0xff);\\
while (0)
enum
CB_FLD_SRC_ADDR,//0
CB_FLD_DST_ADDR,//1
CB_FLD_SRC_PORT,//2
CB_FLD_SRC_PORT_DLM,//3
CB_FLD_SRC_PORT_MASK,//4
CB_FLD_DST_PORT,//5
CB_FLD_DST_PORT_DLM,//6
CB_FLD_DST_PORT_MASK,//7
CB_FLD_PROTO,//8
CB_FLD_PRIORITY,//9
CB_FLD_NUM,//10
;
/* 一条 rule 占一行，格式，以及分词后的在in数组内的下标如下：
#源IP/前缀 目的IP/前缀 源端口号 : 掩码 目的端口号 : 掩码 协议/掩码 优先级
2.2.2.3/24 2.2.2.7/24 32 : 0xffff 33 : 0xffff 17/0xff 0
0 1 2 3 4 5 6 7 8 9 ← in数组下标
用上述枚举类型来进行表示in数组的下标
*/
static struct
const char *rule_ipv4_name;
parm_config;// 用于文件访问的
const char cb_port_delim[] = ":";
//网口默认配置，RX接收的数据包大小默认为ETHER链路帧包的最大值（MTU）
static const struct rte_eth_conf port_conf_default =
.rxmode =
.max_rx_pkt_len = RTE_ETHER_MAX_LEN,
,
;
struct flow_classifier
struct rte_flow_classifier *cls;
;
/*
struct rte_flow_classifier
// classifier的参数，要 create() 时传入结构体。
char name[RTE_FLOW_CLASSIFIER_MAX_NAME_SZ];
int socket_id;
// 其余的内部字段
// n tuple 过滤器，也就是流规则的匹配项目了。
struct rte_eth_ntuple_filter ntuple_filter;
// tables
struct rte_cls_table tables[RTE_FLOW_CLASSIFY_TABLE_MAX];
uint32_t table_mask;
uint32_t num_tables;
uint16_t nb_pkts;
struct rte_flow_classify_table_entry
*entries[RTE_PORT_IN_BURST_SIZE_MAX];
__rte_cache_aligned;
*/
struct flow_classifier_acl
struct flow_classifier cls;
__rte_cache_aligned;
/* ACL field definitions for IPv4 5 tuple rule */
enum
PROTO_FIELD_IPV4,
SRC_FIELD_IPV4,
DST_FIELD_IPV4,
SRCP_FIELD_IPV4,
DSTP_FIELD_IPV4,
NUM_FIELDS_IPV4
;
enum
PROTO_INPUT_IPV4,
SRC_INPUT_IPV4,
DST_INPUT_IPV4,
SRCP_DESTP_INPUT_IPV4
;
/* 数据结构 rte_acl_field_def：ACL 访问控制表的字段的定义
ACL规则中的每个字段都有一个关联定义。有五个，分别是：
字段的类型 type：
RTE_ACL_FIELD_TYPE_BITMASK：单字节区域如ip头部一个字节的proto字段；
RTE_ACL_FIELD_TYPE_MASK：采用MASK方式描述，一般对应4字节的源/目的地址；
RTE_ACL_FIELD_TYPE_RANGE：一般对应TCP或UDP头部2字节的PORT区域。
字段的字节数大小 size，
字段的索引（指示哪一个字段）field_index 一个0开始的值，用来指定字段在规则内部的位置，0~n-1表示n个字段。
输入索引 input_index（0-N） 所有输入字段，除了第一个，其他必须以4个连续字节分组，这个input_index就是来指定字段在那个组
偏移量offset 定义了字段的偏移量，为查找指定从缓冲区的起始位置的偏移。
*/
/*
rule “规则” 有一些独有规则：
1. 规则定义的第一个字段必须是一个字节的长度
2. 之后的字段必须以4个连续的字节分组
这主要是为性能考虑，查找函数处理第一个输入字节做为这个流的设置的一部分，然后这查找函数的内部循环被展开来同时处理4字节的输入。
*/
static struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = // 共 5 个字段，每个字段都要有一个关联的五个定义
/* first input field - always one byte long. */
.type = RTE_ACL_FIELD_TYPE_BITMASK,
.size = sizeof(uint8_t),//1个字节
.field_index = PROTO_FIELD_IPV4,
.input_index = PROTO_INPUT_IPV4,
.offset = sizeof(struct rte_ether_hdr) +
offsetof(struct rte_ipv4_hdr, next_proto_id),
,
/* next input field (IPv4 source address) - 4 consecutive bytes. */
/* rte_flow uses a bit mask for IPv4 addresses */
// 第二个字段 源IP地址
.type = RTE_ACL_FIELD_TYPE_BITMASK,
.size = sizeof(uint32_t),
.field_index = SRC_FIELD_IPV4,
.input_index = SRC_INPUT_IPV4,
.offset = sizeof(struct rte_ether_hdr) +
offsetof(struct rte_ipv4_hdr, src_addr),
,
/* next input field (IPv4 destination address) - 4 consecutive bytes. */
/* rte_flow uses a bit mask for IPv4 addresses */
// 第三个字段 目的IP地址
.type = RTE_ACL_FIELD_TYPE_BITMASK,
.size = sizeof(uint32_t),
.field_index = DST_FIELD_IPV4,
.input_index = DST_INPUT_IPV4,
.offset = sizeof(struct rte_ether_hdr) +
offsetof(struct rte_ipv4_hdr, dst_addr),
,
/*
* Next 2 fields (src & dst ports) form 4 consecutive bytes.
* They share the same input index.
*/
/* rte_flow uses a bit mask for protocol ports */
// 接下来的 两个端口号 才组成一个 4 字节，所以共享同样的一个 input index
.type = RTE_ACL_FIELD_TYPE_BITMASK,
.size = sizeof(uint16_t),
.field_index = SRCP_FIELD_IPV4,
.input_index = SRCP_DESTP_INPUT_IPV4,
.offset = sizeof(struct rte_ether_hdr) +
sizeof(struct rte_ipv4_hdr) +
offsetof(struct rte_tcp_hdr, src_port),
,
/* rte_flow uses a bit mask for protocol ports */
// 第三个字段 传输层协议
.type = RTE_ACL_FIELD_TYPE_BITMASK,
.size = sizeof(uint16_t),
.field_index = DSTP_FIELD_IPV4,
.input_index = SRCP_DESTP_INPUT_IPV4,
.offset = sizeof(struct rte_ether_hdr) +
sizeof(struct rte_ipv4_hdr) +
offsetof(struct rte_tcp_hdr, dst_port),
,
;
/* flow classify data */
static int num_classify_rules;// rules数组的下标
static struct rte_flow_classify_rule *rules[MAX_NUM_CLASSIFY];// rules 数组
static struct rte_flow_classify_ipv4_5tuple_stats ntuple_stats;
static struct rte_flow_classify_stats classify_stats =
.stats = (void **)&ntuple_stats// 有计数功能
;
/* parameters for rte_flow_classify_validate and
* rte_flow_classify_table_entry_add functions
*/
/* rte_flow_item 四个字段：
1. type，是 enum 定义。见 rte_flow.h：http://doc.dpdk.org/api/rte__flow_8h_source.html
2. spec，指向相关项类型结构的有效指针，在许多情况下，可以设置成 NULL以请求广泛（非特定）匹配。在此情况下，last 和 mask 也要设置成 NULL
3. last，可以指向相同类型的结构，以定义包含范围。
4. Mask，是在解释spec和last的内容之前应用的简单位掩码
*/
static struct rte_flow_item eth_item = RTE_FLOW_ITEM_TYPE_ETH,
0, 0, 0 ;
static struct rte_flow_item end_item = RTE_FLOW_ITEM_TYPE_END,
0, 0, 0 ;
/* sample actions:
* "actions count / end"
*/
struct rte_flow_query_count count = // 计数器查询的结构体
.reset = 1,// Reset counters after query
.hits_set = 1,// 启用 hits 字段
.bytes_set = 1,// 启用 bytes字段
.hits = 0,// Number of hits for this rule
.bytes = 0,
;
static struct rte_flow_action count_action = RTE_FLOW_ACTION_TYPE_COUNT,
&count;
static struct rte_flow_action end_action = RTE_FLOW_ACTION_TYPE_END, 0;
static struct rte_flow_action actions[2];
// rte_flow_action 见 programmers’ guides 的第九章 ：http://doc.dpdk.org/guides/prog_guide/rte_flow.html
// actions 数组代表当 pkt 被 pattern 匹配时要执行的一系列操作。
// 在这个例子里，数组长度为二，actions[0] 就是计数，actions[1] 就是用来提示结尾。
// rte_flow_action的具体定义不清楚
// 估计第一个字段是 enum rte_flow_action_type ，具体的 enum 定义见：http://doc.dpdk.org/api/rte__flow_8h.html#a78f0386e683cfc491462a771df8b971a
// 第二个字段计数器查询的结构体
/* sample attributes */
static struct rte_flow_attr attr;
/* flow_classify.c: * Based on DPDK skeleton forwarding example. */
/*
* Initializes a given port using global settings and with the RX buffers
* coming from the mbuf_pool passed as a parameter.
*/
//端口初始化
//1.获取可用 eth 的个数
//2.配置网卡设备
//3.每个 port 1 个 rx 队列
//4.每个 port 1 个 tx 队列
//5.启用网卡设备
//6.设置网卡混杂模式
static inline int
port_init(uint8_t port, struct rte_mempool *mbuf_pool)
struct rte_eth_conf port_conf = port_conf_default;
struct rte_ether_addr addr;
const uint16_t rx_rings = 1, tx_rings = 1;
int retval;
uint16_t q;
struct rte_eth_dev_info dev_info;
struct rte_eth_txconf txconf;
if (!rte_eth_dev_is_valid_port(port))
return -1;
retval = rte_eth_dev_info_get(port, &dev_info);
if (retval != 0)
printf("Error during getting device (port %u) info: %s\\n",
port, strerror(-retval));
return retval;
if (dev_info.tx_offload_capa & DEV_TX_OFFLOAD_MBUF_FAST_FREE)
port_conf.txmode.offloads |=
DEV_TX_OFFLOAD_MBUF_FAST_FREE;
/* Configure the Ethernet device. */
retval = rte_eth_dev_configure(port, rx_rings, tx_rings, &port_conf);
if (retval != 0)
return retval;
/* Allocate and set up 1 RX queue per Ethernet port. */
for (q = 0; q < rx_rings; q++)
retval = rte_eth_rx_queue_setup(port, q, RX_RING_SIZE,
rte_eth_dev_socket_id(port), NULL, mbuf_pool);
if (retval < 0)
return retval;
txconf = dev_info.default_txconf;
txconf.offloads = port_conf.txmode.offloads;
/* Allocate and set up 1 TX queue per Ethernet port. */
for (q = 0; q < tx_rings; q++)
retval = rte_eth_tx_queue_setup(port, q, TX_RING_SIZE,
rte_eth_dev_socket_id(port), &txconf);
if (retval < 0)
return retval;
/* Start the Ethernet port. */
retval = rte_eth_dev_start(port);
if (retval < 0)
return retval;
/* Display the port MAC address. */
retval = rte_eth_macaddr_get(port, &addr);
if (retval != 0)
return retval;
printf("Port %u MAC: %02" PRIx8 " %02" PRIx8 " %02" PRIx8
" %02" PRIx8 " %02" PRIx8 " %02" PRIx8 "\\n",
port,
addr.addr_bytes[0], addr.addr_bytes[1],
addr.addr_bytes[2], addr.addr_bytes[3],
addr.addr_bytes[4], addr.addr_bytes[5]);
/* Enable RX in promiscuous mode for the Ethernet device. */
retval = rte_eth_promiscuous_enable(port);
if (retval != 0)
return retval;
return 0;
/*
* The lcore main. This is the main thread that does the work, reading from
* an input port classifying the packets and writing to an output port.
*/
//这是完成工作的主线程，它从输入端口读取并写入输出端口。
static __rte_noreturn void
lcore_main(struct flow_classifier *cls_app)
uint16_t port;
int ret;
int i = 0;
//测试：删除一条规则
ret = rte_flow_classify_table_entry_delete(cls_app->cls,
rules[7]);
if (ret)
printf("table_entry_delete failed [7] %d\\n\\n", ret);
else
printf("table_entry_delete succeeded [7]\\n\\n");
/*
* Check that the port is on the same NUMA node as the polling thread
* for best performance.
*/
//检查端口是否与轮询线程在同一NUMA节点上，以获得最佳性能。
RTE_ETH_FOREACH_DEV(port)//遍历每个端口
if (rte_eth_dev_socket_id(port) > 0 &&
rte_eth_dev_socket_id(port) != (int)rte_socket_id())
printf("\\n\\n");
printf("WARNING: port %u is on remote NUMA node\\n",
port);
printf("to polling thread.\\n");
printf("Performance will not be optimal.\\n");
printf("\\nCore %u forwarding packets. ", rte_lcore_id());
printf("[Ctrl+C to quit]\\n");
/* Run until the application is quit or killed. */
for (;;)
/*
* Receive packets on a port, classify them and forward them
* on the paired port.
* The mapping is 0 -> 1, 1 -> 0, 2 -> 3, 3 -> 2, etc.
*/
RTE_ETH_FOREACH_DEV(port)
/* Get burst of RX packets, from first port of pair. */
struct rte_mbuf *bufs[BURST_SIZE];
const uint16_t nb_rx = rte_eth_rx_burst(port, 0,
bufs, BURST_SIZE);
if (unlikely(nb_rx == 0))
continue;
for (i = 0; i < MAX_NUM_CLASSIFY; i++)
if (rules[i]) // 对classifier里的每条规则（用一个数组来保存插入成功时返回的rule指针）
/* rte_flow_classifier_query()，查看burst中是否有任何数据包与表中的一条流规则匹配。
参数：流分类器句柄、要处理的数据包的mbuf
一个burst的数据包数量、要查询的规则、查询的stat */
ret = rte_flow_classifier_query(
cls_app->cls,
bufs, nb_rx, rules[i],
&classify_stats);
if (ret)
printf(
"rule [%d] query failed ret [%d]\\n\\n",
i, ret);
else // 返回 0 代表有match
printf(
"rule[%d] count=%"PRIu64"\\n",
i, ntuple_stats.counter1);
printf("proto = %d\\n",
ntuple_stats.ipv4_5tuple.proto);
/* Send burst of TX packets, to second port of pair. */
const uint16_t nb_tx = rte_eth_tx_burst(port ^ 1, 0,
bufs, nb_rx);// port 异或 1 --> 0就和1是一对，2就和3是一对。
// 0 收到包就从 1 转发， 3 收到包 就从 2 口转发。
//对于发不出去的包就把内存释放掉，也就是drop这些包
//对于DPDK的收包和转发来说，都是一次处理多个数据包
//原因是cache行的内存对齐可以一次处理多个地址
//并且可以充分利用处理器内部的乱序执行和并行处理能力
/* Free any unsent packets. */
if (unlikely(nb_tx < nb_rx))
uint16_t buf;
for (buf = nb_tx; buf < nb_rx; buf++)
rte_pktmbuf_free(bufs[buf]);
/*
* Parse IPv4 5 tuple rules file, ipv4_rules_file.txt.
* Expected format:
* <src_ipv4_addr>'/'<masklen> <space> \\
* <dst_ipv4_addr>'/'<masklen> <space> \\
* <src_port> <space> ":" <src_port_mask> <space> \\
* <dst_port> <space> ":" <dst_port_mask> <space> \\
* <proto>'/'<proto_mask> <space> \\
* <priority>
*/
static int
get_cb_field(char **in, uint32_t *fd, int base, unsigned long lim,
char dlm)
unsigned long val;
char *end;
errno = 0;
val = strtoul(*in, &end, base);
/* unsigned long int strtoul(const char *str, char **endptr, int base)
把参数 str 所指向的字符串根据给定的 base 转换为一个无符号长整数（unsigned long int 型）。
str -- 要转换为无符号长整数的字符串。
endptr -- 对类型为 char* 的对象的引用，其值会由函数设置为 str 中数值后的下一个字符。
（end 会指向点分十进制中的下一个点）
base -- 基数，必须介于 2 和 36（包含）之间，或者是特殊值 0。
当base = 0,自动判断字符串的类型，并按10进制输出，例如"0xa", 就会把字符串当做16进制处理，输出为 10。
参考：http://www.runoob.com/cprogramming/c-function-strtoul.html
https://blog.csdn.net/chuhongcai/article/details/52032926
*/
if (errno != 0 || end[0] != dlm || val > lim)
return -EINVAL;
*fd = (uint32_t)val;
*in = end + 1;例如 2.2.2.3 会依次转换 2 2 2 3
return 0;
static int
parse_ipv4_net(char *indpdk实例flow_classify