static struct rte_acl_ctx *
setup_acl(struct rte_acl_rule *acl_base, unsigned int acl_num, int ipv6,
int socketid)
{
char name[PATH_MAX];
struct rte_acl_param acl_param;
struct rte_acl_config acl_build_param;
struct rte_acl_ctx *context;
int dim = ipv6 ? RTE_DIM(ipv6_defs) : RTE_DIM(ipv4_defs);
static uint32_t ctx_count[NB_SOCKETS] = {0};
if (!acl_num)
return NULL;
/* Create ACL contexts */
snprintf(name, sizeof(name), "%s%d-%d",
ipv6 ? L3FWD_ACL_IPV6_NAME : L3FWD_ACL_IPV4_NAME, socketid, ctx_count[socketid]++);
acl_param.name = name;
acl_param.socket_id = socketid;
acl_param.rule_size = RTE_ACL_RULE_SZ(dim);
acl_param.max_rule_num = MAX_ACL_RULE_NUM;
if ((context = rte_acl_create(&acl_param)) == NULL) {
acl_log("Failed to create ACL context\n");
goto err;
}
if (acl_parm_config.aclavx2 &&
rte_acl_set_ctx_classify(context, RTE_ACL_CLASSIFY_AVX2) != 0) {
acl_log("Failed to setup classify method for ACL context\n");
goto err;
}
if (rte_acl_add_rules(context, acl_base, acl_num) < 0) {
acl_log("add rules failed\n");
goto err;
}
/* Perform builds */
memset(&acl_build_param, 0, sizeof(acl_build_param));
acl_build_param.num_categories = DEFAULT_MAX_CATEGORIES;
acl_build_param.num_fields = dim;
memcpy(&acl_build_param.defs, ipv6 ? ipv6_defs : ipv4_defs,
ipv6 ? sizeof(ipv6_defs) : sizeof(ipv4_defs));
if (rte_acl_build(context, &acl_build_param) != 0) {
acl_log("Failed to build ACL trie\n");
goto err;
}
rte_acl_dump(context);
return context;
err:
rte_acl_free(context);
return NULL;
}
struct rte_acl_ctx * mg_5tuple_create_filter(int socket_id, uint32_t num_rules){
// FIXME: is prm on stack OK? or does this have to be on HEAP?
struct rte_acl_param prm = {
.name = "ACL_5tuple_filter",
.socket_id = socket_id,
.rule_size = RTE_ACL_RULE_SZ(RTE_DIM(ipv4_defs)),
/* number of fields per rule. */
.max_rule_num = num_rules, /* maximum number of rules in the AC context. */
};
return rte_acl_create(&prm);
}
void mg_5tuple_destruct_filter(struct rte_acl_ctx * acl){
rte_acl_free(acl);
}
static struct rte_acl_ctx *
acl4_init(const char *name, int socketid, const struct acl4_rules *rules,
unsigned rules_nb)
{
char s[PATH_MAX];
struct rte_acl_param acl_param;
struct rte_acl_config acl_build_param;
struct rte_acl_ctx *ctx;
printf("Creating SP context with %u max rules\n", MAX_ACL_RULE_NUM);
memset(&acl_param, 0, sizeof(acl_param));
/* Create ACL contexts */
snprintf(s, sizeof(s), "%s_%d", name, socketid);
printf("IPv4 %s entries [%u]:\n", s, rules_nb);
dump_ipv4_rules(rules, rules_nb, 1);
acl_param.name = s;
acl_param.socket_id = socketid;
acl_param.rule_size = RTE_ACL_RULE_SZ(RTE_DIM(ipv4_defs));
acl_param.max_rule_num = MAX_ACL_RULE_NUM;
ctx = rte_acl_create(&acl_param);
if (ctx == NULL)
rte_exit(EXIT_FAILURE, "Failed to create ACL context\n");
if (rte_acl_add_rules(ctx, (const struct rte_acl_rule *)rules,
rules_nb) < 0)
rte_exit(EXIT_FAILURE, "add rules failed\n");
/* Perform builds */
memset(&acl_build_param, 0, sizeof(acl_build_param));
acl_build_param.num_categories = DEFAULT_MAX_CATEGORIES;
acl_build_param.num_fields = RTE_DIM(ipv4_defs);
memcpy(&acl_build_param.defs, ipv4_defs, sizeof(ipv4_defs));
if (rte_acl_build(ctx, &acl_build_param) != 0)
rte_exit(EXIT_FAILURE, "Failed to build ACL trie\n");
rte_acl_dump(ctx);
return ctx;
}
static void *
rte_table_acl_create(
void *params,
int socket_id,
uint32_t entry_size)
{
struct rte_table_acl_params *p = (struct rte_table_acl_params *) params;
struct rte_table_acl *acl;
uint32_t action_table_size, acl_rule_list_size, acl_rule_memory_size;
uint32_t total_size;
RTE_BUILD_BUG_ON(((sizeof(struct rte_table_acl) % RTE_CACHE_LINE_SIZE)
!= 0));
/* Check input parameters */
if (p == NULL) {
RTE_LOG(ERR, TABLE, "%s: Invalid value for params\n", __func__);
return NULL;
}
if (p->name == NULL) {
RTE_LOG(ERR, TABLE, "%s: Invalid value for name\n", __func__);
return NULL;
}
if (p->n_rules == 0) {
RTE_LOG(ERR, TABLE, "%s: Invalid value for n_rules\n",
__func__);
return NULL;
}
if ((p->n_rule_fields == 0) ||
(p->n_rule_fields > RTE_ACL_MAX_FIELDS)) {
RTE_LOG(ERR, TABLE, "%s: Invalid value for n_rule_fields\n",
__func__);
return NULL;
}
entry_size = RTE_ALIGN(entry_size, sizeof(uint64_t));
/* Memory allocation */
action_table_size = RTE_CACHE_LINE_ROUNDUP(p->n_rules * entry_size);
acl_rule_list_size =
RTE_CACHE_LINE_ROUNDUP(p->n_rules * sizeof(struct rte_acl_rule *));
acl_rule_memory_size = RTE_CACHE_LINE_ROUNDUP(p->n_rules *
RTE_ACL_RULE_SZ(p->n_rule_fields));
total_size = sizeof(struct rte_table_acl) + action_table_size +
acl_rule_list_size + acl_rule_memory_size;
acl = rte_zmalloc_socket("TABLE", total_size, RTE_CACHE_LINE_SIZE,
socket_id);
if (acl == NULL) {
RTE_LOG(ERR, TABLE,
"%s: Cannot allocate %u bytes for ACL table\n",
__func__, total_size);
return NULL;
}
acl->action_table = &acl->memory[0];
acl->acl_rule_list =
(struct rte_acl_rule **) &acl->memory[action_table_size];
acl->acl_rule_memory = (uint8_t *)
&acl->memory[action_table_size + acl_rule_list_size];
/* Initialization of internal fields */
snprintf(acl->name[0], RTE_ACL_NAMESIZE, "%s_a", p->name);
snprintf(acl->name[1], RTE_ACL_NAMESIZE, "%s_b", p->name);
acl->name_id = 1;
acl->acl_params.name = acl->name[acl->name_id];
acl->acl_params.socket_id = socket_id;
acl->acl_params.rule_size = RTE_ACL_RULE_SZ(p->n_rule_fields);
acl->acl_params.max_rule_num = p->n_rules;
acl->cfg.num_categories = 1;
acl->cfg.num_fields = p->n_rule_fields;
memcpy(&acl->cfg.defs[0], &p->field_format[0],
p->n_rule_fields * sizeof(struct rte_acl_field_def));
acl->ctx = NULL;
acl->n_rules = p->n_rules;
acl->entry_size = entry_size;
return acl;
}
