lib/librte_flow_classify/rte_flow_classify.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Intel Corporation
   3  */
   4
   5 #include <rte_flow_classify.h>
   6 #include "rte_flow_classify_parse.h"
   7 #include <rte_flow_driver.h>
   8 #include <rte_table_acl.h>
   9 #include <stdbool.h>
  10
  11 int librte_flow_classify_logtype;
  12
  13 static uint32_t unique_id = 1;
  14
  15 enum rte_flow_classify_table_type table_type
  16         = RTE_FLOW_CLASSIFY_TABLE_TYPE_NONE;
  17
  18 struct rte_flow_classify_table_entry {
  19         /* meta-data for classify rule */
  20         uint32_t rule_id;
  21
  22         /* Flow action */
  23         struct classify_action action;
  24 };
  25
  26 struct rte_cls_table {
  27         /* Input parameters */
  28         struct rte_table_ops ops;
  29         uint32_t entry_size;
  30         enum rte_flow_classify_table_type type;
  31
  32         /* Handle to the low-level table object */
  33         void *h_table;
  34 };
  35
  36 #define RTE_FLOW_CLASSIFIER_MAX_NAME_SZ 256
  37
  38 struct rte_flow_classifier {
  39         /* Input parameters */
  40         char name[RTE_FLOW_CLASSIFIER_MAX_NAME_SZ];
  41         int socket_id;
  42
  43         /* Internal */
  44         /* ntuple_filter */
  45         struct rte_eth_ntuple_filter ntuple_filter;
  46
  47         /* classifier tables */
  48         struct rte_cls_table tables[RTE_FLOW_CLASSIFY_TABLE_MAX];
  49         uint32_t table_mask;
  50         uint32_t num_tables;
  51
  52         uint16_t nb_pkts;
  53         struct rte_flow_classify_table_entry
  54                 *entries[RTE_PORT_IN_BURST_SIZE_MAX];
  55 } __rte_cache_aligned;
  56
  57 enum {
  58         PROTO_FIELD_IPV4,
  59         SRC_FIELD_IPV4,
  60         DST_FIELD_IPV4,
  61         SRCP_FIELD_IPV4,
  62         DSTP_FIELD_IPV4,
  63         NUM_FIELDS_IPV4
  64 };
  65
  66 struct acl_keys {
  67         struct rte_table_acl_rule_add_params key_add; /* add key */
  68         struct rte_table_acl_rule_delete_params key_del; /* delete key */
  69 };
  70
  71 struct classify_rules {
  72         enum rte_flow_classify_rule_type type;
  73         union {
  74                 struct rte_flow_classify_ipv4_5tuple ipv4_5tuple;
  75         } u;
  76 };
  77
  78 struct rte_flow_classify_rule {
  79         uint32_t id; /* unique ID of classify rule */
  80         enum rte_flow_classify_table_type tbl_type; /* rule table */
  81         struct classify_rules rules; /* union of rules */
  82         union {
  83                 struct acl_keys key;
  84         } u;
  85         int key_found;   /* rule key found in table */
  86         struct rte_flow_classify_table_entry entry;  /* rule meta data */
  87         void *entry_ptr; /* handle to the table entry for rule meta data */
  88 };
  89
  90 int
  91 rte_flow_classify_validate(
  92                    struct rte_flow_classifier *cls,
  93                    const struct rte_flow_attr *attr,
  94                    const struct rte_flow_item pattern[],
  95                    const struct rte_flow_action actions[],
  96                    struct rte_flow_error *error)
  97 {
  98         struct rte_flow_item *items;
  99         parse_filter_t parse_filter;
 100         uint32_t item_num = 0;
 101         uint32_t i = 0;
 102         int ret;
 103
 104         if (error == NULL)
 105                 return -EINVAL;
 106
 107         if (cls == NULL) {
 108                 RTE_FLOW_CLASSIFY_LOG(ERR,
 109                         "%s: rte_flow_classifier parameter is NULL\n",
 110                         __func__);
 111                 return -EINVAL;
 112         }
 113
 114         if (!attr) {
 115                 rte_flow_error_set(error, EINVAL,
 116                                    RTE_FLOW_ERROR_TYPE_ATTR,
 117                                    NULL, "NULL attribute.");
 118                 return -EINVAL;
 119         }
 120
 121         if (!pattern) {
 122                 rte_flow_error_set(error,
 123                         EINVAL, RTE_FLOW_ERROR_TYPE_ITEM_NUM,
 124                         NULL, "NULL pattern.");
 125                 return -EINVAL;
 126         }
 127
 128         if (!actions) {
 129                 rte_flow_error_set(error, EINVAL,
 130                                    RTE_FLOW_ERROR_TYPE_ACTION_NUM,
 131                                    NULL, "NULL action.");
 132                 return -EINVAL;
 133         }
 134
 135         memset(&cls->ntuple_filter, 0, sizeof(cls->ntuple_filter));
 136
 137         /* Get the non-void item number of pattern */
 138         while ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_END) {
 139                 if ((pattern + i)->type != RTE_FLOW_ITEM_TYPE_VOID)
 140                         item_num++;
 141                 i++;
 142         }
 143         item_num++;
 144
 145         items = malloc(item_num * sizeof(struct rte_flow_item));
 146         if (!items) {
 147                 rte_flow_error_set(error, ENOMEM,
 148                                 RTE_FLOW_ERROR_TYPE_ITEM_NUM,
 149                                 NULL, "No memory for pattern items.");
 150                 return -ENOMEM;
 151         }
 152
 153         memset(items, 0, item_num * sizeof(struct rte_flow_item));
 154         classify_pattern_skip_void_item(items, pattern);
 155
 156         parse_filter = classify_find_parse_filter_func(items);
 157         if (!parse_filter) {
 158                 rte_flow_error_set(error, EINVAL,
 159                                 RTE_FLOW_ERROR_TYPE_ITEM,
 160                                 pattern, "Unsupported pattern");
 161                 free(items);
 162                 return -EINVAL;
 163         }
 164
 165         ret = parse_filter(attr, items, actions, &cls->ntuple_filter, error);
 166         free(items);
 167         return ret;
 168 }
 169
 170
 171 #define uint32_t_to_char(ip, a, b, c, d) do {\
 172                 *a = (unsigned char)(ip >> 24 & 0xff);\
 173                 *b = (unsigned char)(ip >> 16 & 0xff);\
 174                 *c = (unsigned char)(ip >> 8 & 0xff);\
 175                 *d = (unsigned char)(ip & 0xff);\
 176         } while (0)
 177
 178 static inline void
 179 print_acl_ipv4_key_add(struct rte_table_acl_rule_add_params *key)
 180 {
 181         unsigned char a, b, c, d;
 182
 183         printf("%s:    0x%02hhx/0x%hhx ", __func__,
 184                 key->field_value[PROTO_FIELD_IPV4].value.u8,
 185                 key->field_value[PROTO_FIELD_IPV4].mask_range.u8);
 186
 187         uint32_t_to_char(key->field_value[SRC_FIELD_IPV4].value.u32,
 188                         &a, &b, &c, &d);
 189         printf(" %hhu.%hhu.%hhu.%hhu/0x%x ", a, b, c, d,
 190                         key->field_value[SRC_FIELD_IPV4].mask_range.u32);
 191
 192         uint32_t_to_char(key->field_value[DST_FIELD_IPV4].value.u32,
 193                         &a, &b, &c, &d);
 194         printf("%hhu.%hhu.%hhu.%hhu/0x%x ", a, b, c, d,
 195                         key->field_value[DST_FIELD_IPV4].mask_range.u32);
 196
 197         printf("%hu : 0x%x %hu : 0x%x",
 198                 key->field_value[SRCP_FIELD_IPV4].value.u16,
 199                 key->field_value[SRCP_FIELD_IPV4].mask_range.u16,
 200                 key->field_value[DSTP_FIELD_IPV4].value.u16,
 201                 key->field_value[DSTP_FIELD_IPV4].mask_range.u16);
 202
 203         printf(" priority: 0x%x\n", key->priority);
 204 }
 205
 206 static inline void
 207 print_acl_ipv4_key_delete(struct rte_table_acl_rule_delete_params *key)
 208 {
 209         unsigned char a, b, c, d;
 210
 211         printf("%s: 0x%02hhx/0x%hhx ", __func__,
 212                 key->field_value[PROTO_FIELD_IPV4].value.u8,
 213                 key->field_value[PROTO_FIELD_IPV4].mask_range.u8);
 214
 215         uint32_t_to_char(key->field_value[SRC_FIELD_IPV4].value.u32,
 216                         &a, &b, &c, &d);
 217         printf(" %hhu.%hhu.%hhu.%hhu/0x%x ", a, b, c, d,
 218                         key->field_value[SRC_FIELD_IPV4].mask_range.u32);
 219
 220         uint32_t_to_char(key->field_value[DST_FIELD_IPV4].value.u32,
 221                         &a, &b, &c, &d);
 222         printf("%hhu.%hhu.%hhu.%hhu/0x%x ", a, b, c, d,
 223                         key->field_value[DST_FIELD_IPV4].mask_range.u32);
 224
 225         printf("%hu : 0x%x %hu : 0x%x\n",
 226                 key->field_value[SRCP_FIELD_IPV4].value.u16,
 227                 key->field_value[SRCP_FIELD_IPV4].mask_range.u16,
 228                 key->field_value[DSTP_FIELD_IPV4].value.u16,
 229                 key->field_value[DSTP_FIELD_IPV4].mask_range.u16);
 230 }
 231
 232 static int
 233 rte_flow_classifier_check_params(struct rte_flow_classifier_params *params)
 234 {
 235         if (params == NULL) {
 236                 RTE_FLOW_CLASSIFY_LOG(ERR,
 237                         "%s: Incorrect value for parameter params\n", __func__);
 238                 return -EINVAL;
 239         }
 240
 241         /* name */
 242         if (params->name == NULL) {
 243                 RTE_FLOW_CLASSIFY_LOG(ERR,
 244                         "%s: Incorrect value for parameter name\n", __func__);
 245                 return -EINVAL;
 246         }
 247
 248         /* socket */
 249         if ((params->socket_id < 0) ||
 250             (params->socket_id >= RTE_MAX_NUMA_NODES)) {
 251                 RTE_FLOW_CLASSIFY_LOG(ERR,
 252                         "%s: Incorrect value for parameter socket_id\n",
 253                         __func__);
 254                 return -EINVAL;
 255         }
 256
 257         return 0;
 258 }
 259
 260 struct rte_flow_classifier *
 261 rte_flow_classifier_create(struct rte_flow_classifier_params *params)
 262 {
 263         struct rte_flow_classifier *cls;
 264         int ret;
 265
 266         /* Check input parameters */
 267         ret = rte_flow_classifier_check_params(params);
 268         if (ret != 0) {
 269                 RTE_FLOW_CLASSIFY_LOG(ERR,
 270                         "%s: flow classifier params check failed (%d)\n",
 271                         __func__, ret);
 272                 return NULL;
 273         }
 274
 275         /* Allocate memory for the flow classifier */
 276         cls = rte_zmalloc_socket("FLOW_CLASSIFIER",
 277                         sizeof(struct rte_flow_classifier),
 278                         RTE_CACHE_LINE_SIZE, params->socket_id);
 279
 280         if (cls == NULL) {
 281                 RTE_FLOW_CLASSIFY_LOG(ERR,
 282                         "%s: flow classifier memory allocation failed\n",
 283                         __func__);
 284                 return NULL;
 285         }
 286
 287         /* Save input parameters */
 288         snprintf(cls->name, RTE_FLOW_CLASSIFIER_MAX_NAME_SZ, "%s",
 289                         params->name);
 290
 291         cls->socket_id = params->socket_id;
 292
 293         return cls;
 294 }
 295
 296 static void
 297 rte_flow_classify_table_free(struct rte_cls_table *table)
 298 {
 299         if (table->ops.f_free != NULL)
 300                 table->ops.f_free(table->h_table);
 301 }
 302
 303 int
 304 rte_flow_classifier_free(struct rte_flow_classifier *cls)
 305 {
 306         uint32_t i;
 307
 308         /* Check input parameters */
 309         if (cls == NULL) {
 310                 RTE_FLOW_CLASSIFY_LOG(ERR,
 311                         "%s: rte_flow_classifier parameter is NULL\n",
 312                         __func__);
 313                 return -EINVAL;
 314         }
 315
 316         /* Free tables */
 317         for (i = 0; i < cls->num_tables; i++) {
 318                 struct rte_cls_table *table = &cls->tables[i];
 319
 320                 rte_flow_classify_table_free(table);
 321         }
 322
 323         /* Free flow classifier memory */
 324         rte_free(cls);
 325
 326         return 0;
 327 }
 328
 329 static int
 330 rte_table_check_params(struct rte_flow_classifier *cls,
 331                 struct rte_flow_classify_table_params *params)
 332 {
 333         if (cls == NULL) {
 334                 RTE_FLOW_CLASSIFY_LOG(ERR,
 335                         "%s: flow classifier parameter is NULL\n",
 336                         __func__);
 337                 return -EINVAL;
 338         }
 339         if (params == NULL) {
 340                 RTE_FLOW_CLASSIFY_LOG(ERR, "%s: params parameter is NULL\n",
 341                         __func__);
 342                 return -EINVAL;
 343         }
 344
 345         /* ops */
 346         if (params->ops == NULL) {
 347                 RTE_FLOW_CLASSIFY_LOG(ERR, "%s: params->ops is NULL\n",
 348                         __func__);
 349                 return -EINVAL;
 350         }
 351
 352         if (params->ops->f_create == NULL) {
 353                 RTE_FLOW_CLASSIFY_LOG(ERR,
 354                         "%s: f_create function pointer is NULL\n", __func__);
 355                 return -EINVAL;
 356         }
 357
 358         if (params->ops->f_lookup == NULL) {
 359                 RTE_FLOW_CLASSIFY_LOG(ERR,
 360                         "%s: f_lookup function pointer is NULL\n", __func__);
 361                 return -EINVAL;
 362         }
 363
 364         /* De we have room for one more table? */
 365         if (cls->num_tables == RTE_FLOW_CLASSIFY_TABLE_MAX) {
 366                 RTE_FLOW_CLASSIFY_LOG(ERR,
 367                         "%s: Incorrect value for num_tables parameter\n",
 368                         __func__);
 369                 return -EINVAL;
 370         }
 371
 372         return 0;
 373 }
 374
 375 int
 376 rte_flow_classify_table_create(struct rte_flow_classifier *cls,
 377         struct rte_flow_classify_table_params *params)
 378 {
 379         struct rte_cls_table *table;
 380         void *h_table;
 381         uint32_t entry_size;
 382         int ret;
 383
 384         /* Check input arguments */
 385         ret = rte_table_check_params(cls, params);
 386         if (ret != 0)
 387                 return ret;
 388
 389         /* calculate table entry size */
 390         entry_size = sizeof(struct rte_flow_classify_table_entry);
 391
 392         /* Create the table */
 393         h_table = params->ops->f_create(params->arg_create, cls->socket_id,
 394                 entry_size);
 395         if (h_table == NULL) {
 396                 RTE_FLOW_CLASSIFY_LOG(ERR, "%s: Table creation failed\n",
 397                         __func__);
 398                 return -EINVAL;
 399         }
 400
 401         /* Commit current table to the classifier */
 402         table = &cls->tables[cls->num_tables];
 403         table->type = params->type;
 404         cls->num_tables++;
 405
 406         /* Save input parameters */
 407         memcpy(&table->ops, params->ops, sizeof(struct rte_table_ops));
 408
 409         /* Initialize table internal data structure */
 410         table->entry_size = entry_size;
 411         table->h_table = h_table;
 412
 413         return 0;
 414 }
 415
 416 static struct rte_flow_classify_rule *
 417 allocate_acl_ipv4_5tuple_rule(struct rte_flow_classifier *cls)
 418 {
 419         struct rte_flow_classify_rule *rule;
 420         int log_level;
 421
 422         rule = malloc(sizeof(struct rte_flow_classify_rule));
 423         if (!rule)
 424                 return rule;
 425
 426         memset(rule, 0, sizeof(struct rte_flow_classify_rule));
 427         rule->id = unique_id++;
 428         rule->rules.type = RTE_FLOW_CLASSIFY_RULE_TYPE_IPV4_5TUPLE;
 429
 430         /* key add values */
 431         rule->u.key.key_add.priority = cls->ntuple_filter.priority;
 432         rule->u.key.key_add.field_value[PROTO_FIELD_IPV4].mask_range.u8 =
 433                         cls->ntuple_filter.proto_mask;
 434         rule->u.key.key_add.field_value[PROTO_FIELD_IPV4].value.u8 =
 435                         cls->ntuple_filter.proto;
 436         rule->rules.u.ipv4_5tuple.proto = cls->ntuple_filter.proto;
 437         rule->rules.u.ipv4_5tuple.proto_mask = cls->ntuple_filter.proto_mask;
 438
 439         rule->u.key.key_add.field_value[SRC_FIELD_IPV4].mask_range.u32 =
 440                         cls->ntuple_filter.src_ip_mask;
 441         rule->u.key.key_add.field_value[SRC_FIELD_IPV4].value.u32 =
 442                         cls->ntuple_filter.src_ip;
 443         rule->rules.u.ipv4_5tuple.src_ip_mask = cls->ntuple_filter.src_ip_mask;
 444         rule->rules.u.ipv4_5tuple.src_ip = cls->ntuple_filter.src_ip;
 445
 446         rule->u.key.key_add.field_value[DST_FIELD_IPV4].mask_range.u32 =
 447                         cls->ntuple_filter.dst_ip_mask;
 448         rule->u.key.key_add.field_value[DST_FIELD_IPV4].value.u32 =
 449                         cls->ntuple_filter.dst_ip;
 450         rule->rules.u.ipv4_5tuple.dst_ip_mask = cls->ntuple_filter.dst_ip_mask;
 451         rule->rules.u.ipv4_5tuple.dst_ip = cls->ntuple_filter.dst_ip;
 452
 453         rule->u.key.key_add.field_value[SRCP_FIELD_IPV4].mask_range.u16 =
 454                         cls->ntuple_filter.src_port_mask;
 455         rule->u.key.key_add.field_value[SRCP_FIELD_IPV4].value.u16 =
 456                         cls->ntuple_filter.src_port;
 457         rule->rules.u.ipv4_5tuple.src_port_mask =
 458                         cls->ntuple_filter.src_port_mask;
 459         rule->rules.u.ipv4_5tuple.src_port = cls->ntuple_filter.src_port;
 460
 461         rule->u.key.key_add.field_value[DSTP_FIELD_IPV4].mask_range.u16 =
 462                         cls->ntuple_filter.dst_port_mask;
 463         rule->u.key.key_add.field_value[DSTP_FIELD_IPV4].value.u16 =
 464                         cls->ntuple_filter.dst_port;
 465         rule->rules.u.ipv4_5tuple.dst_port_mask =
 466                         cls->ntuple_filter.dst_port_mask;
 467         rule->rules.u.ipv4_5tuple.dst_port = cls->ntuple_filter.dst_port;
 468
 469         log_level = rte_log_get_level(librte_flow_classify_logtype);
 470
 471         if (log_level == RTE_LOG_DEBUG)
 472                 print_acl_ipv4_key_add(&rule->u.key.key_add);
 473
 474         /* key delete values */
 475         memcpy(&rule->u.key.key_del.field_value[PROTO_FIELD_IPV4],
 476                &rule->u.key.key_add.field_value[PROTO_FIELD_IPV4],
 477                NUM_FIELDS_IPV4 * sizeof(struct rte_acl_field));
 478
 479         if (log_level == RTE_LOG_DEBUG)
 480                 print_acl_ipv4_key_delete(&rule->u.key.key_del);
 481
 482         return rule;
 483 }
 484
 485 struct rte_flow_classify_rule *
 486 rte_flow_classify_table_entry_add(struct rte_flow_classifier *cls,
 487                 const struct rte_flow_attr *attr,
 488                 const struct rte_flow_item pattern[],
 489                 const struct rte_flow_action actions[],
 490                 int *key_found,
 491                 struct rte_flow_error *error)
 492 {
 493         struct rte_flow_classify_rule *rule;
 494         struct rte_flow_classify_table_entry *table_entry;
 495         struct classify_action *action;
 496         uint32_t i;
 497         int ret;
 498
 499         if (!error)
 500                 return NULL;
 501
 502         if (key_found == NULL) {
 503                 rte_flow_error_set(error, EINVAL,
 504                                 RTE_FLOW_ERROR_TYPE_UNSPECIFIED,
 505                                 NULL, "NULL key_found.");
 506                 return NULL;
 507         }
 508
 509         /* parse attr, pattern and actions */
 510         ret = rte_flow_classify_validate(cls, attr, pattern, actions, error);
 511         if (ret < 0)
 512                 return NULL;
 513
 514         switch (table_type) {
 515         case RTE_FLOW_CLASSIFY_TABLE_ACL_IP4_5TUPLE:
 516                 rule = allocate_acl_ipv4_5tuple_rule(cls);
 517                 if (!rule)
 518                         return NULL;
 519                 rule->tbl_type = table_type;
 520                 cls->table_mask |= table_type;
 521                 break;
 522         default:
 523                 return NULL;
 524         }
 525
 526         action = classify_get_flow_action();
 527         table_entry = &rule->entry;
 528         table_entry->rule_id = rule->id;
 529         table_entry->action.action_mask = action->action_mask;
 530
 531         /* Copy actions */
 532         if (action->action_mask & (1LLU << RTE_FLOW_ACTION_TYPE_COUNT)) {
 533                 memcpy(&table_entry->action.act.counter, &action->act.counter,
 534                                 sizeof(table_entry->action.act.counter));
 535         }
 536         if (action->action_mask & (1LLU << RTE_FLOW_ACTION_TYPE_MARK)) {
 537                 memcpy(&table_entry->action.act.mark, &action->act.mark,
 538                                 sizeof(table_entry->action.act.mark));
 539         }
 540
 541         for (i = 0; i < cls->num_tables; i++) {
 542                 struct rte_cls_table *table = &cls->tables[i];
 543
 544                 if (table->type == table_type) {
 545                         if (table->ops.f_add != NULL) {
 546                                 ret = table->ops.f_add(
 547                                         table->h_table,
 548                                         &rule->u.key.key_add,
 549                                         &rule->entry,
 550                                         &rule->key_found,
 551                                         &rule->entry_ptr);
 552                                 if (ret) {
 553                                         free(rule);
 554                                         return NULL;
 555                                 }
 556
 557                         *key_found = rule->key_found;
 558                         }
 559
 560                         return rule;
 561                 }
 562         }
 563         return NULL;
 564 }
 565
 566 int
 567 rte_flow_classify_table_entry_delete(struct rte_flow_classifier *cls,
 568                 struct rte_flow_classify_rule *rule)
 569 {
 570         uint32_t i;
 571         int ret = -EINVAL;
 572
 573         if (!cls || !rule)
 574                 return ret;
 575         enum rte_flow_classify_table_type tbl_type = rule->tbl_type;
 576
 577         for (i = 0; i < cls->num_tables; i++) {
 578                 struct rte_cls_table *table = &cls->tables[i];
 579
 580                 if (table->type == tbl_type) {
 581                         if (table->ops.f_delete != NULL) {
 582                                 ret = table->ops.f_delete(table->h_table,
 583                                                 &rule->u.key.key_del,
 584                                                 &rule->key_found,
 585                                                 &rule->entry);
 586
 587                                 return ret;
 588                         }
 589                 }
 590         }
 591         free(rule);
 592         return ret;
 593 }
 594
 595 static int
 596 flow_classifier_lookup(struct rte_flow_classifier *cls,
 597                 struct rte_cls_table *table,
 598                 struct rte_mbuf **pkts,
 599                 const uint16_t nb_pkts)
 600 {
 601         int ret = -EINVAL;
 602         uint64_t pkts_mask;
 603         uint64_t lookup_hit_mask;
 604
 605         pkts_mask = RTE_LEN2MASK(nb_pkts, uint64_t);
 606         ret = table->ops.f_lookup(table->h_table,
 607                 pkts, pkts_mask, &lookup_hit_mask,
 608                 (void **)cls->entries);
 609
 610         if (!ret && lookup_hit_mask)
 611                 cls->nb_pkts = nb_pkts;
 612         else
 613                 cls->nb_pkts = 0;
 614
 615         return ret;
 616 }
 617
 618 static int
 619 action_apply(struct rte_flow_classifier *cls,
 620                 struct rte_flow_classify_rule *rule,
 621                 struct rte_flow_classify_stats *stats)
 622 {
 623         struct rte_flow_classify_ipv4_5tuple_stats *ntuple_stats;
 624         struct rte_flow_classify_table_entry *entry = &rule->entry;
 625         uint64_t count = 0;
 626         uint32_t action_mask = entry->action.action_mask;
 627         int i, ret = -EINVAL;
 628
 629         if (action_mask & (1LLU << RTE_FLOW_ACTION_TYPE_COUNT)) {
 630                 for (i = 0; i < cls->nb_pkts; i++) {
 631                         if (rule->id == cls->entries[i]->rule_id)
 632                                 count++;
 633                 }
 634                 if (count) {
 635                         ret = 0;
 636                         ntuple_stats =
 637                                 (struct rte_flow_classify_ipv4_5tuple_stats *)
 638                                 stats->stats;
 639                         ntuple_stats->counter1 = count;
 640                         ntuple_stats->ipv4_5tuple = rule->rules.u.ipv4_5tuple;
 641                 }
 642         }
 643         return ret;
 644 }
 645
 646 int
 647 rte_flow_classifier_query(struct rte_flow_classifier *cls,
 648                 struct rte_mbuf **pkts,
 649                 const uint16_t nb_pkts,
 650                 struct rte_flow_classify_rule *rule,
 651                 struct rte_flow_classify_stats *stats)
 652 {
 653         enum rte_flow_classify_table_type tbl_type;
 654         uint32_t i;
 655         int ret = -EINVAL;
 656
 657         if (!cls || !rule || !stats || !pkts  || nb_pkts == 0)
 658                 return ret;
 659
 660         tbl_type = rule->tbl_type;
 661         for (i = 0; i < cls->num_tables; i++) {
 662                 struct rte_cls_table *table = &cls->tables[i];
 663
 664                         if (table->type == tbl_type) {
 665                                 ret = flow_classifier_lookup(cls, table,
 666                                                 pkts, nb_pkts);
 667                                 if (!ret) {
 668                                         ret = action_apply(cls, rule, stats);
 669                                         return ret;
 670                                 }
 671                         }
 672         }
 673         return ret;
 674 }
 675
 676 RTE_INIT(librte_flow_classify_init_log);
 677
 678 static void
 679 librte_flow_classify_init_log(void)
 680 {
 681         librte_flow_classify_logtype =
 682                 rte_log_register("lib.flow_classify");
 683         if (librte_flow_classify_logtype >= 0)
 684                 rte_log_set_level(librte_flow_classify_logtype, RTE_LOG_INFO);
 685 }