DPDK rte_acl 学习踩坑及示例

最近开始需要用 DPDK ACL 来实现一些如包负载长度匹配的需求，因此开始学习 ACL 相关的内容，刚开始上手觉得还是挺难的，花了大概三四天看了官方的文档和一些示例，大概搞明白了 ACL 的用法，也踩了一些坑，这篇博客记录下这段时间的学习内容，最后提供了一个我写的小例子来参考。

rte_acl_field_def

要用 ACL 首先要定义规则的结构，这里会用到 rte_acl_field_def 结构体，下面解释一下各个字段的含义：

1. type：有三种取值：

取值	含义
RTE_ACL_FIELD_TYPE_BITMASK	和 MASK 不同，MASK 里 mask_range 表示的是掩码的长度，而 BITMASK 的 mask_range 则是实际用 bit 表示的掩码，通常我们用于协议号的匹配，比如要匹配的协议号是 0x6，则 value 为 0x6,mask_range 为 0xff 即可，value 和 range 全 0 表示匹配所有
RTE_ACL_FIELD_TYPE_MASK	字段值/掩码，非常像带掩码的 IP 地址，一般也是用来匹配 IP 地址，mask 是掩码的长度，value 和 range 全 0 表示匹配所有的 IP 地址
RTE_ACL_FIELD_TYPE_RANGE	用来一个范围，比如端口范围，value 和 mask 是上下限，value 为 0，range 为 65535 表示匹配所有端口，value 和 range 为同一个值则表示匹配一个具体的数值

这里的掩码和 range 类型实际上给我们提供了挺大的灵活性，可以实现诸如 ip 范围匹配，端口的大于等于等逻辑，还是非常给力的。

2. size
   表示字段的大小，可以是 1、2、4、8 个字节，不可以随意设置

3. field_index
   该字段是第几个字段，通常和下面的示例一样定义一个 enum 递增就可以了，没啥好说的

4. input_index
   该字段属于那个分组，这里有一个坑，ACL 要求第一个字段一定是 1 个字节大小，后面的要字段要 4 个字节为一个分组，不满的要自己凑齐

5. offset
   该字段在待匹配数据中的偏移

RTE_ACL_RULE_DEF

这是一个宏定义，可以根据我们之前写的 rte_acl_field_def 生成对应的规则结构体，然后你就可以定义这样的结构体并往里填充数据了

ACL 使用流程

1. 定义规则结构和匹配数据结构
2. 创建 ACL 的上下文
3. 添加规则到 ACL 上下文中
4. 编译 ACL 规则
5. 进行报文数据匹配
6. 销毁 ACL 上下文

字节序问题

ACL 中添加规则用的是小端序，而匹配时数据需要大端序

IPV4 匹配示例代码

#include <netinet/in.h>
#include <rte_acl.h>
#include <rte_eal.h>
#include <rte_ip.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define ACL_MAX_RULE_NUM 1000

struct pkt_data {
    uint8_t proto;
    uint32_t ip1;
    uint32_t ip2;
    uint16_t port1;
    uint16_t port2;
};

enum { PROTO_FIELD_IPV4, SRC_FIELD_IPV4, DST_FIELD_IPV4, SRCP_FIELD_IPV4, DSTP_FIELD_IPV4, NUM_FIELDS_IPV4 };

enum { ACL_IPV4_PROTO = 0, ACL_IPV4_SRC, ACL_IPV4_DST, ACL_IPV4_PORTS, ACL_IPV4_NUM };
struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
    {
        .type = RTE_ACL_FIELD_TYPE_BITMASK,
        .size = sizeof(uint8_t),
        .field_index = PROTO_FIELD_IPV4,
        .input_index = ACL_IPV4_PROTO,
        .offset = offsetof(struct pkt_data, proto),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_MASK,
        .size = sizeof(uint32_t),
        .field_index = SRC_FIELD_IPV4,
        .input_index = ACL_IPV4_SRC,
        .offset = offsetof(struct pkt_data, ip1),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_MASK,
        .size = sizeof(uint32_t),
        .field_index = DST_FIELD_IPV4,
        .input_index = ACL_IPV4_DST,
        .offset = offsetof(struct pkt_data, ip2),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_RANGE,
        .size = sizeof(uint16_t),
        .field_index = SRCP_FIELD_IPV4,
        .input_index = ACL_IPV4_PORTS,
        .offset = offsetof(struct pkt_data, port1),
    },
    {
        .type = RTE_ACL_FIELD_TYPE_RANGE,
        .size = sizeof(uint16_t),
        .field_index = DSTP_FIELD_IPV4,
        .input_index = ACL_IPV4_PORTS,
        .offset = offsetof(struct pkt_data, port2),
    },
};
RTE_ACL_RULE_DEF(ipv4_rule, RTE_DIM(ipv4_defs));

static struct rte_acl_ctx* g_acl_ipv4_ctx = NULL;

static struct ipv4_rule acl_rules[] = {
    {
        // category1:只有 sip
        // 用于设置此规则属于那些分类, 例如 0x3 表示 category1和2
        // 对于五元组的31中组合，每一个种类占据其中的一个 bit
        .data = {.userdata = 10, .category_mask = 1, .priority = 1},
        /* source IPv4 */
        .field[SRC_FIELD_IPV4] =
            {
                .value.u32 = RTE_IPV4(192, 168, 1, 1),
                .mask_range.u32 = 32,
            },
        /* source port */
        .field[SRCP_FIELD_IPV4] =
            {
                .value.u16 = 0,
                .mask_range.u16 = 0xffff,
            },
        /* destination port */
        .field[DSTP_FIELD_IPV4] =
            {
                .value.u16 = 0,
                .mask_range.u16 = 0xffff,
            },
    },
    {
        // category 2：只有 dip
        .data = {.userdata = 20, .category_mask = 2, .priority = 2},
        /* destination IPv4 */
        .field[DST_FIELD_IPV4] =
            {
                .value.u32 = RTE_IPV4(2, 2, 2, 2),
                .mask_range.u32 = 32,
            },
        /* source port */
        .field[SRCP_FIELD_IPV4] =
            {
                .value.u16 = 0,
                .mask_range.u16 = 0xffff,
            },
        /* destination port */
        .field[DSTP_FIELD_IPV4] =
            {
                .value.u16 = 0,
                .mask_range.u16 = 0xffff,
            },
    },
};

static int acl_rule_add(const struct rte_acl_rule* rules, uint32_t num) {
    int ret = 0;
    ret = rte_acl_add_rules(g_acl_ipv4_ctx, rules, num);
    if (ret != 0) {
        printf("[ACL] add ipv4 rule failed.\n");
    }
    return ret;
}

static int acl_rule_build() {
    int ret = 0;
    struct rte_acl_config cfg;

    memset(&cfg, 0, sizeof(cfg));

    cfg.num_categories = RTE_ACL_MAX_CATEGORIES;
    cfg.num_fields = RTE_DIM(ipv4_defs);
    memcpy(&cfg.defs, ipv4_defs, sizeof(ipv4_defs));

    ret = rte_acl_build(g_acl_ipv4_ctx, &cfg);
    if (ret != 0) {
        printf("failed to build acl context.\n");
    }
    return ret;
}

static int acl_init() {
    int ret = 0;
    struct rte_acl_param prm = {
        .name = "ipv4",
        .socket_id = SOCKET_ID_ANY,
    };
    prm.rule_size = RTE_ACL_RULE_SZ(RTE_DIM(ipv4_defs));
    printf("ipv4_defs RTE_DIM: %ld, RTE_ACL_RULE_SZ(RTE_DIM(ipv4_defs)): %ld\n", RTE_DIM(ipv4_defs),
           RTE_ACL_RULE_SZ(RTE_DIM(ipv4_defs)));
    prm.max_rule_num = ACL_MAX_RULE_NUM;

    g_acl_ipv4_ctx = rte_acl_create(&prm);
    if (g_acl_ipv4_ctx == NULL) {
        printf("failed to create acl context.\n");
        return -1;
    }

    ret = rte_acl_set_ctx_classify(g_acl_ipv4_ctx, RTE_ACL_CLASSIFY_SCALAR);
    if (ret) {
        printf("failed to set up classify method for acl context.\n");
        return ret;
    }
    return ret;
}

static int acl_classify(struct rte_acl_ctx* ctx, struct pkt_data* pctx) {
    int ret = 0;
    const uint8_t* data[1];
    data[0] = (uint8_t*)pctx;

#define RESULTS_NUM 4
    uint32_t results[RESULTS_NUM];
    memset(results, 0x00, sizeof(results));
    uint32_t num = 1;
    uint32_t categories = 4;  // x86 必须是4的倍数

    ret = rte_acl_classify(ctx, (const uint8_t**)data, results, num, categories);

    int i;
    for (i = 0; i < RESULTS_NUM; i++) {
        printf("result[%d] = %u\n", i, results[i]);
    }

    return ret;
}

int main(int argc, char** argv) {
    int ret = 0;
    ret = rte_eal_init(argc, argv);
    if (ret < 0) {
        printf("rte_eal init fail.\n");
        return ret;
    }
    ret = acl_init();
    if (ret) {
        printf("acl_init fail.\n");
        return ret;
    }
    ret = acl_rule_add((struct rte_acl_rule*)acl_rules, 2);
    if (ret) {
        printf("acl_rule_add fail.\n");
        return ret;
    }
    ret = acl_rule_build();
    if (ret) {
        printf("acl_rule_build fail.\n");
        return ret;
    }
    rte_acl_dump(g_acl_ipv4_ctx);

    struct pkt_data buf;
    memset(&buf, 0, sizeof(buf));
    buf.proto = 6;
    buf.port1 = ntohs(111ul);
    buf.port2 = ntohs(80ul);
    buf.ip1 = rte_cpu_to_be_32(RTE_IPV4(192, 168, 1, 1));
    buf.ip2 = rte_cpu_to_be_32(RTE_IPV4(2, 2, 2, 2));
    acl_classify(g_acl_ipv4_ctx, &buf);
    rte_acl_free(g_acl_ipv4_ctx);
    return 0;
}

cmake，我这里使用的是 DPDK21

cmake_minimum_required(VERSION 3.10)
project(ACL_TEST)

find_package(PkgConfig REQUIRED)
pkg_check_modules(DPDK REQUIRED IMPORTED_TARGET libdpdk)

if(DPDK_FOUND)
    add_definitions(${DPDK_CFLAGS})
endif(DPDK_FOUND)

add_executable(test-acl EXCLUDE_FROM_ALL acl_ipv4_test.c)
target_compile_options(test-acl PRIVATE "-Wall")
target_compile_options(test-acl PRIVATE "-Wextra")
target_compile_options(test-acl PRIVATE "-std=gnu99")
target_include_directories(test-acl PRIVATE include)
target_link_libraries(test-acl "-lstdc++")
target_link_libraries(test-acl "-lm")
target_link_libraries(test-acl "-lc")
target_link_libraries(test-acl "-pthread")
target_link_libraries(test-acl "-lpcap")
target_link_libraries(test-acl ${DPDK_LIBRARIES})