app/test/test_flow_classify.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Intel Corporation
   3  */
   4
   5 #include <string.h>
   6 #include <errno.h>
   7
   8 #include "test.h"
   9
  10 #include <rte_string_fns.h>
  11 #include <rte_mbuf.h>
  12 #include <rte_byteorder.h>
  13 #include <rte_ip.h>
  14 #include <rte_acl.h>
  15 #include <rte_common.h>
  16 #include <rte_table_acl.h>
  17 #include <rte_flow.h>
  18 #include <rte_flow_classify.h>
  19
  20 #include "packet_burst_generator.h"
  21 #include "test_flow_classify.h"
  22
  23
  24 #define FLOW_CLASSIFY_MAX_RULE_NUM 100
  25 #define MAX_PKT_BURST              32
  26 #define NB_SOCKETS                 1
  27 #define MEMPOOL_CACHE_SIZE         256
  28 #define MBUF_SIZE                  512
  29 #define NB_MBUF                    512
  30
  31 /* test UDP, TCP and SCTP packets */
  32 static struct rte_mempool *mbufpool[NB_SOCKETS];
  33 static struct rte_mbuf *bufs[MAX_PKT_BURST];
  34
  35 static struct rte_acl_field_def ipv4_defs[NUM_FIELDS_IPV4] = {
  36         /* first input field - always one byte long. */
  37         {
  38                 .type = RTE_ACL_FIELD_TYPE_BITMASK,
  39                 .size = sizeof(uint8_t),
  40                 .field_index = PROTO_FIELD_IPV4,
  41                 .input_index = PROTO_INPUT_IPV4,
  42                 .offset = sizeof(struct rte_ether_hdr) +
  43                         offsetof(struct rte_ipv4_hdr, next_proto_id),
  44         },
  45         /* next input field (IPv4 source address) - 4 consecutive bytes. */
  46         {
  47                 /* rte_flow uses a bit mask for IPv4 addresses */
  48                 .type = RTE_ACL_FIELD_TYPE_BITMASK,
  49                 .size = sizeof(uint32_t),
  50                 .field_index = SRC_FIELD_IPV4,
  51                 .input_index = SRC_INPUT_IPV4,
  52                 .offset = sizeof(struct rte_ether_hdr) +
  53                         offsetof(struct rte_ipv4_hdr, src_addr),
  54         },
  55         /* next input field (IPv4 destination address) - 4 consecutive bytes. */
  56         {
  57                 /* rte_flow uses a bit mask for IPv4 addresses */
  58                 .type = RTE_ACL_FIELD_TYPE_BITMASK,
  59                 .size = sizeof(uint32_t),
  60                 .field_index = DST_FIELD_IPV4,
  61                 .input_index = DST_INPUT_IPV4,
  62                 .offset = sizeof(struct rte_ether_hdr) +
  63                         offsetof(struct rte_ipv4_hdr, dst_addr),
  64         },
  65         /*
  66          * Next 2 fields (src & dst ports) form 4 consecutive bytes.
  67          * They share the same input index.
  68          */
  69         {
  70                 /* rte_flow uses a bit mask for protocol ports */
  71                 .type = RTE_ACL_FIELD_TYPE_BITMASK,
  72                 .size = sizeof(uint16_t),
  73                 .field_index = SRCP_FIELD_IPV4,
  74                 .input_index = SRCP_DESTP_INPUT_IPV4,
  75                 .offset = sizeof(struct rte_ether_hdr) +
  76                         sizeof(struct rte_ipv4_hdr) +
  77                         offsetof(struct rte_tcp_hdr, src_port),
  78         },
  79         {
  80                 /* rte_flow uses a bit mask for protocol ports */
  81                 .type = RTE_ACL_FIELD_TYPE_BITMASK,
  82                 .size = sizeof(uint16_t),
  83                 .field_index = DSTP_FIELD_IPV4,
  84                 .input_index = SRCP_DESTP_INPUT_IPV4,
  85                 .offset = sizeof(struct rte_ether_hdr) +
  86                         sizeof(struct rte_ipv4_hdr) +
  87                         offsetof(struct rte_tcp_hdr, dst_port),
  88         },
  89 };
  90
  91 /* parameters for rte_flow_classify_validate and rte_flow_classify_create */
  92
  93 /* test UDP pattern:
  94  * "eth / ipv4 src spec 2.2.2.3 src mask 255.255.255.00 dst spec 2.2.2.7
  95  *  dst mask 255.255.255.00 / udp src is 32 dst is 33 / end"
  96  */
  97 static struct rte_flow_item_ipv4 ipv4_udp_spec_1 = {
  98         { 0, 0, 0, 0, 0, 0, IPPROTO_UDP, 0,
  99           RTE_IPV4(2, 2, 2, 3), RTE_IPV4(2, 2, 2, 7)}
 100 };
 101 static const struct rte_flow_item_ipv4 ipv4_mask_24 = {
 102         .hdr = {
 103                 .next_proto_id = 0xff,
 104                 .src_addr = 0xffffff00,
 105                 .dst_addr = 0xffffff00,
 106         },
 107 };
 108 static struct rte_flow_item_udp udp_spec_1 = {
 109         { 32, 33, 0, 0 }
 110 };
 111
 112 static struct rte_flow_item  eth_item = { RTE_FLOW_ITEM_TYPE_ETH,
 113         0, 0, 0 };
 114 static struct rte_flow_item  eth_item_bad = { -1, 0, 0, 0 };
 115
 116 static struct rte_flow_item  ipv4_udp_item_1 = { RTE_FLOW_ITEM_TYPE_IPV4,
 117         &ipv4_udp_spec_1, 0, &ipv4_mask_24};
 118 static struct rte_flow_item  ipv4_udp_item_bad = { RTE_FLOW_ITEM_TYPE_IPV4,
 119         NULL, 0, NULL};
 120
 121 static struct rte_flow_item  udp_item_1 = { RTE_FLOW_ITEM_TYPE_UDP,
 122         &udp_spec_1, 0, &rte_flow_item_udp_mask};
 123 static struct rte_flow_item  udp_item_bad = { RTE_FLOW_ITEM_TYPE_UDP,
 124         NULL, 0, NULL};
 125
 126 static struct rte_flow_item  end_item = { RTE_FLOW_ITEM_TYPE_END,
 127         0, 0, 0 };
 128
 129 /* test TCP pattern:
 130  * "eth / ipv4 src spec 1.2.3.4 src mask 255.255.255.00 dst spec 5.6.7.8
 131  *  dst mask 255.255.255.00 / tcp src is 16 dst is 17 / end"
 132  */
 133 static struct rte_flow_item_ipv4 ipv4_tcp_spec_1 = {
 134         { 0, 0, 0, 0, 0, 0, IPPROTO_TCP, 0,
 135           RTE_IPV4(1, 2, 3, 4), RTE_IPV4(5, 6, 7, 8)}
 136 };
 137
 138 static struct rte_flow_item_tcp tcp_spec_1 = {
 139         { 16, 17, 0, 0, 0, 0, 0, 0, 0}
 140 };
 141
 142 static struct rte_flow_item  ipv4_tcp_item_1 = { RTE_FLOW_ITEM_TYPE_IPV4,
 143         &ipv4_tcp_spec_1, 0, &ipv4_mask_24};
 144
 145 static struct rte_flow_item  tcp_item_1 = { RTE_FLOW_ITEM_TYPE_TCP,
 146         &tcp_spec_1, 0, &rte_flow_item_tcp_mask};
 147
 148 /* test SCTP pattern:
 149  * "eth / ipv4 src spec 1.2.3.4 src mask 255.255.255.00 dst spec 5.6.7.8
 150  *  dst mask 255.255.255.00 / sctp src is 16 dst is 17/ end"
 151  */
 152 static struct rte_flow_item_ipv4 ipv4_sctp_spec_1 = {
 153         { 0, 0, 0, 0, 0, 0, IPPROTO_SCTP, 0, RTE_IPV4(11, 12, 13, 14),
 154         RTE_IPV4(15, 16, 17, 18)}
 155 };
 156
 157 static struct rte_flow_item_sctp sctp_spec_1 = {
 158         { 10, 11, 0, 0}
 159 };
 160
 161 static struct rte_flow_item  ipv4_sctp_item_1 = { RTE_FLOW_ITEM_TYPE_IPV4,
 162         &ipv4_sctp_spec_1, 0, &ipv4_mask_24};
 163
 164 static struct rte_flow_item  sctp_item_1 = { RTE_FLOW_ITEM_TYPE_SCTP,
 165         &sctp_spec_1, 0, &rte_flow_item_sctp_mask};
 166
 167
 168 /* test actions:
 169  * "actions count / end"
 170  */
 171 static struct rte_flow_query_count count = {
 172         .reset = 1,
 173         .hits_set = 1,
 174         .bytes_set = 1,
 175         .hits = 0,
 176         .bytes = 0,
 177 };
 178 static struct rte_flow_action count_action = { RTE_FLOW_ACTION_TYPE_COUNT,
 179         &count};
 180 static struct rte_flow_action count_action_bad = { -1, 0};
 181
 182 static struct rte_flow_action end_action = { RTE_FLOW_ACTION_TYPE_END, 0};
 183
 184 static struct rte_flow_action actions[2];
 185
 186 /* test attributes */
 187 static struct rte_flow_attr attr;
 188
 189 /* test error */
 190 static struct rte_flow_error error;
 191
 192 /* test pattern */
 193 static struct rte_flow_item  pattern[4];
 194
 195 /* flow classify data for UDP burst */
 196 static struct rte_flow_classify_ipv4_5tuple_stats udp_ntuple_stats;
 197 static struct rte_flow_classify_stats udp_classify_stats = {
 198                 .stats = (void *)&udp_ntuple_stats
 199 };
 200
 201 /* flow classify data for TCP burst */
 202 static struct rte_flow_classify_ipv4_5tuple_stats tcp_ntuple_stats;
 203 static struct rte_flow_classify_stats tcp_classify_stats = {
 204                 .stats = (void *)&tcp_ntuple_stats
 205 };
 206
 207 /* flow classify data for SCTP burst */
 208 static struct rte_flow_classify_ipv4_5tuple_stats sctp_ntuple_stats;
 209 static struct rte_flow_classify_stats sctp_classify_stats = {
 210                 .stats = (void *)&sctp_ntuple_stats
 211 };
 212
 213 struct flow_classifier_acl *cls;
 214
 215 struct flow_classifier_acl {
 216         struct rte_flow_classifier *cls;
 217 } __rte_cache_aligned;
 218
 219 /*
 220  * test functions by passing invalid or
 221  * non-workable parameters.
 222  */
 223 static int
 224 test_invalid_parameters(void)
 225 {
 226         struct rte_flow_classify_rule *rule;
 227         int ret;
 228
 229         ret = rte_flow_classify_validate(NULL, NULL, NULL, NULL, NULL);
 230         if (!ret) {
 231                 printf("Line %i: rte_flow_classify_validate",
 232                         __LINE__);
 233                 printf(" with NULL param should have failed!\n");
 234                 return -1;
 235         }
 236
 237         rule = rte_flow_classify_table_entry_add(NULL, NULL, NULL, NULL,
 238                         NULL, NULL);
 239         if (rule) {
 240                 printf("Line %i: flow_classifier_table_entry_add", __LINE__);
 241                 printf(" with NULL param should have failed!\n");
 242                 return -1;
 243         }
 244
 245         ret = rte_flow_classify_table_entry_delete(NULL, NULL);
 246         if (!ret) {
 247                 printf("Line %i: rte_flow_classify_table_entry_delete",
 248                         __LINE__);
 249                 printf(" with NULL param should have failed!\n");
 250                 return -1;
 251         }
 252
 253         ret = rte_flow_classifier_query(NULL, NULL, 0, NULL, NULL);
 254         if (!ret) {
 255                 printf("Line %i: flow_classifier_query", __LINE__);
 256                 printf(" with NULL param should have failed!\n");
 257                 return -1;
 258         }
 259
 260         rule = rte_flow_classify_table_entry_add(NULL, NULL, NULL, NULL,
 261                 NULL, &error);
 262         if (rule) {
 263                 printf("Line %i: flow_classify_table_entry_add ", __LINE__);
 264                 printf("with NULL param should have failed!\n");
 265                 return -1;
 266         }
 267
 268         ret = rte_flow_classify_table_entry_delete(NULL, NULL);
 269         if (!ret) {
 270                 printf("Line %i: rte_flow_classify_table_entry_delete",
 271                         __LINE__);
 272                 printf("with NULL param should have failed!\n");
 273                 return -1;
 274         }
 275
 276         ret = rte_flow_classifier_query(NULL, NULL, 0, NULL, NULL);
 277         if (!ret) {
 278                 printf("Line %i: flow_classifier_query", __LINE__);
 279                 printf(" with NULL param should have failed!\n");
 280                 return -1;
 281         }
 282         return 0;
 283 }
 284
 285 static int
 286 test_valid_parameters(void)
 287 {
 288         struct rte_flow_classify_rule *rule;
 289         int ret;
 290         int key_found;
 291
 292         /*
 293          * set up parameters for rte_flow_classify_validate,
 294          * rte_flow_classify_table_entry_add and
 295          * rte_flow_classify_table_entry_delete
 296          */
 297
 298         attr.ingress = 1;
 299         attr.priority = 1;
 300         pattern[0] = eth_item;
 301         pattern[1] = ipv4_udp_item_1;
 302         pattern[2] = udp_item_1;
 303         pattern[3] = end_item;
 304         actions[0] = count_action;
 305         actions[1] = end_action;
 306
 307         ret = rte_flow_classify_validate(cls->cls, &attr, pattern,
 308                         actions, &error);
 309         if (ret) {
 310                 printf("Line %i: rte_flow_classify_validate",
 311                         __LINE__);
 312                 printf(" should not have failed!\n");
 313                 return -1;
 314         }
 315         rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
 316                         actions, &key_found, &error);
 317
 318         if (!rule) {
 319                 printf("Line %i: flow_classify_table_entry_add", __LINE__);
 320                 printf(" should not have failed!\n");
 321                 return -1;
 322         }
 323
 324         ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 325         if (ret) {
 326                 printf("Line %i: rte_flow_classify_table_entry_delete",
 327                         __LINE__);
 328                 printf(" should not have failed!\n");
 329                 return -1;
 330         }
 331         return 0;
 332 }
 333
 334 static int
 335 test_invalid_patterns(void)
 336 {
 337         struct rte_flow_classify_rule *rule;
 338         int ret;
 339         int key_found;
 340
 341         /*
 342          * set up parameters for rte_flow_classify_validate,
 343          * rte_flow_classify_table_entry_add and
 344          * rte_flow_classify_table_entry_delete
 345          */
 346
 347         attr.ingress = 1;
 348         attr.priority = 1;
 349         pattern[0] = eth_item_bad;
 350         pattern[1] = ipv4_udp_item_1;
 351         pattern[2] = udp_item_1;
 352         pattern[3] = end_item;
 353         actions[0] = count_action;
 354         actions[1] = end_action;
 355
 356         pattern[0] = eth_item;
 357         pattern[1] = ipv4_udp_item_bad;
 358
 359         ret = rte_flow_classify_validate(cls->cls, &attr, pattern,
 360                         actions, &error);
 361         if (!ret) {
 362                 printf("Line %i: rte_flow_classify_validate", __LINE__);
 363                 printf(" should have failed!\n");
 364                 return -1;
 365         }
 366
 367         rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
 368                         actions, &key_found, &error);
 369         if (rule) {
 370                 printf("Line %i: flow_classify_table_entry_add", __LINE__);
 371                 printf(" should have failed!\n");
 372                 return -1;
 373         }
 374
 375         ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 376         if (!ret) {
 377                 printf("Line %i: rte_flow_classify_table_entry_delete",
 378                         __LINE__);
 379                 printf(" should have failed!\n");
 380                 return -1;
 381         }
 382
 383         pattern[1] = ipv4_udp_item_1;
 384         pattern[2] = udp_item_bad;
 385         pattern[3] = end_item;
 386
 387         ret = rte_flow_classify_validate(cls->cls, &attr, pattern,
 388                         actions, &error);
 389         if (!ret) {
 390                 printf("Line %i: rte_flow_classify_validate", __LINE__);
 391                 printf(" should have failed!\n");
 392                 return -1;
 393         }
 394
 395         rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
 396                         actions, &key_found, &error);
 397         if (rule) {
 398                 printf("Line %i: flow_classify_table_entry_add", __LINE__);
 399                 printf(" should have failed!\n");
 400                 return -1;
 401         }
 402
 403         ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 404         if (!ret) {
 405                 printf("Line %i: rte_flow_classify_table_entry_delete",
 406                         __LINE__);
 407                 printf(" should have failed!\n");
 408                 return -1;
 409         }
 410         return 0;
 411 }
 412
 413 static int
 414 test_invalid_actions(void)
 415 {
 416         struct rte_flow_classify_rule *rule;
 417         int ret;
 418         int key_found;
 419
 420         /*
 421          * set up parameters for rte_flow_classify_validate,
 422          * rte_flow_classify_table_entry_add and
 423          * rte_flow_classify_table_entry_delete
 424          */
 425
 426         attr.ingress = 1;
 427         attr.priority = 1;
 428         pattern[0] = eth_item;
 429         pattern[1] = ipv4_udp_item_1;
 430         pattern[2] = udp_item_1;
 431         pattern[3] = end_item;
 432         actions[0] = count_action_bad;
 433         actions[1] = end_action;
 434
 435         ret = rte_flow_classify_validate(cls->cls, &attr, pattern,
 436                         actions, &error);
 437         if (!ret) {
 438                 printf("Line %i: rte_flow_classify_validate", __LINE__);
 439                 printf(" should have failed!\n");
 440                 return -1;
 441         }
 442
 443         rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
 444                         actions, &key_found, &error);
 445         if (rule) {
 446                 printf("Line %i: flow_classify_table_entry_add", __LINE__);
 447                 printf(" should have failed!\n");
 448                 return -1;
 449         }
 450
 451         ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 452         if (!ret) {
 453                 printf("Line %i: rte_flow_classify_table_entry_delete",
 454                         __LINE__);
 455                 printf(" should have failed!\n");
 456                 return -1;
 457         }
 458
 459         return 0;
 460 }
 461
 462 static int
 463 init_ipv4_udp_traffic(struct rte_mempool *mp,
 464              struct rte_mbuf **pkts_burst, uint32_t burst_size)
 465 {
 466         struct rte_ether_hdr pkt_eth_hdr;
 467         struct rte_ipv4_hdr pkt_ipv4_hdr;
 468         struct rte_udp_hdr pkt_udp_hdr;
 469         uint32_t src_addr = IPV4_ADDR(2, 2, 2, 3);
 470         uint32_t dst_addr = IPV4_ADDR(2, 2, 2, 7);
 471         uint16_t src_port = 32;
 472         uint16_t dst_port = 33;
 473         uint16_t pktlen;
 474
 475         static uint8_t src_mac[] = { 0x00, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF };
 476         static uint8_t dst_mac[] = { 0x00, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA };
 477
 478         printf("Set up IPv4 UDP traffic\n");
 479         initialize_eth_header(&pkt_eth_hdr,
 480                 (struct rte_ether_addr *)src_mac,
 481                 (struct rte_ether_addr *)dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
 482         pktlen = (uint16_t)(sizeof(struct rte_ether_hdr));
 483         printf("ETH  pktlen %u\n", pktlen);
 484
 485         pktlen = initialize_ipv4_header(&pkt_ipv4_hdr, src_addr, dst_addr,
 486                                         pktlen);
 487         printf("ETH + IPv4 pktlen %u\n", pktlen);
 488
 489         pktlen = initialize_udp_header(&pkt_udp_hdr, src_port, dst_port,
 490                                         pktlen);
 491         printf("ETH + IPv4 + UDP pktlen %u\n\n", pktlen);
 492
 493         return generate_packet_burst(mp, pkts_burst, &pkt_eth_hdr,
 494                                      0, &pkt_ipv4_hdr, 1,
 495                                      &pkt_udp_hdr, burst_size,
 496                                      PACKET_BURST_GEN_PKT_LEN, 1);
 497 }
 498
 499 static int
 500 init_ipv4_tcp_traffic(struct rte_mempool *mp,
 501              struct rte_mbuf **pkts_burst, uint32_t burst_size)
 502 {
 503         struct rte_ether_hdr pkt_eth_hdr;
 504         struct rte_ipv4_hdr pkt_ipv4_hdr;
 505         struct rte_tcp_hdr pkt_tcp_hdr;
 506         uint32_t src_addr = IPV4_ADDR(1, 2, 3, 4);
 507         uint32_t dst_addr = IPV4_ADDR(5, 6, 7, 8);
 508         uint16_t src_port = 16;
 509         uint16_t dst_port = 17;
 510         uint16_t pktlen;
 511
 512         static uint8_t src_mac[] = { 0x00, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF };
 513         static uint8_t dst_mac[] = { 0x00, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA };
 514
 515         printf("Set up IPv4 TCP traffic\n");
 516         initialize_eth_header(&pkt_eth_hdr,
 517                 (struct rte_ether_addr *)src_mac,
 518                 (struct rte_ether_addr *)dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
 519         pktlen = (uint16_t)(sizeof(struct rte_ether_hdr));
 520         printf("ETH  pktlen %u\n", pktlen);
 521
 522         pktlen = initialize_ipv4_header_proto(&pkt_ipv4_hdr, src_addr,
 523                                         dst_addr, pktlen, IPPROTO_TCP);
 524         printf("ETH + IPv4 pktlen %u\n", pktlen);
 525
 526         pktlen = initialize_tcp_header(&pkt_tcp_hdr, src_port, dst_port,
 527                                         pktlen);
 528         printf("ETH + IPv4 + TCP pktlen %u\n\n", pktlen);
 529
 530         return generate_packet_burst_proto(mp, pkts_burst, &pkt_eth_hdr,
 531                                         0, &pkt_ipv4_hdr, 1, IPPROTO_TCP,
 532                                         &pkt_tcp_hdr, burst_size,
 533                                         PACKET_BURST_GEN_PKT_LEN, 1);
 534 }
 535
 536 static int
 537 init_ipv4_sctp_traffic(struct rte_mempool *mp,
 538              struct rte_mbuf **pkts_burst, uint32_t burst_size)
 539 {
 540         struct rte_ether_hdr pkt_eth_hdr;
 541         struct rte_ipv4_hdr pkt_ipv4_hdr;
 542         struct rte_sctp_hdr pkt_sctp_hdr;
 543         uint32_t src_addr = IPV4_ADDR(11, 12, 13, 14);
 544         uint32_t dst_addr = IPV4_ADDR(15, 16, 17, 18);
 545         uint16_t src_port = 10;
 546         uint16_t dst_port = 11;
 547         uint16_t pktlen;
 548
 549         static uint8_t src_mac[] = { 0x00, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF };
 550         static uint8_t dst_mac[] = { 0x00, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA };
 551
 552         printf("Set up IPv4 SCTP traffic\n");
 553         initialize_eth_header(&pkt_eth_hdr,
 554                 (struct rte_ether_addr *)src_mac,
 555                 (struct rte_ether_addr *)dst_mac, RTE_ETHER_TYPE_IPV4, 0, 0);
 556         pktlen = (uint16_t)(sizeof(struct rte_ether_hdr));
 557         printf("ETH  pktlen %u\n", pktlen);
 558
 559         pktlen = initialize_ipv4_header_proto(&pkt_ipv4_hdr, src_addr,
 560                                         dst_addr, pktlen, IPPROTO_SCTP);
 561         printf("ETH + IPv4 pktlen %u\n", pktlen);
 562
 563         pktlen = initialize_sctp_header(&pkt_sctp_hdr, src_port, dst_port,
 564                                         pktlen);
 565         printf("ETH + IPv4 + SCTP pktlen %u\n\n", pktlen);
 566
 567         return generate_packet_burst_proto(mp, pkts_burst, &pkt_eth_hdr,
 568                                         0, &pkt_ipv4_hdr, 1, IPPROTO_SCTP,
 569                                         &pkt_sctp_hdr, burst_size,
 570                                         PACKET_BURST_GEN_PKT_LEN, 1);
 571 }
 572
 573 static int
 574 init_mbufpool(void)
 575 {
 576         int socketid;
 577         int ret = 0;
 578         unsigned int lcore_id;
 579         char s[64];
 580
 581         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
 582                 if (rte_lcore_is_enabled(lcore_id) == 0)
 583                         continue;
 584
 585                 socketid = rte_lcore_to_socket_id(lcore_id);
 586                 if (socketid >= NB_SOCKETS) {
 587                         printf(
 588                                 "Socket %d of lcore %u is out of range %d\n",
 589                                 socketid, lcore_id, NB_SOCKETS);
 590                         ret = -1;
 591                         break;
 592                 }
 593                 if (mbufpool[socketid] == NULL) {
 594                         snprintf(s, sizeof(s), "mbuf_pool_%d", socketid);
 595                         mbufpool[socketid] =
 596                                 rte_pktmbuf_pool_create(s, NB_MBUF,
 597                                         MEMPOOL_CACHE_SIZE, 0, MBUF_SIZE,
 598                                         socketid);
 599                         if (mbufpool[socketid]) {
 600                                 printf("Allocated mbuf pool on socket %d\n",
 601                                         socketid);
 602                         } else {
 603                                 printf("Cannot init mbuf pool on socket %d\n",
 604                                         socketid);
 605                                 ret = -ENOMEM;
 606                                 break;
 607                         }
 608                 }
 609         }
 610         return ret;
 611 }
 612
 613 static int
 614 test_query_udp(void)
 615 {
 616         struct rte_flow_error error;
 617         struct rte_flow_classify_rule *rule;
 618         int ret;
 619         int i;
 620         int key_found;
 621
 622         ret = init_ipv4_udp_traffic(mbufpool[0], bufs, MAX_PKT_BURST);
 623         if (ret != MAX_PKT_BURST) {
 624                 printf("Line %i: init_udp_ipv4_traffic has failed!\n",
 625                                 __LINE__);
 626                 return -1;
 627         }
 628
 629         for (i = 0; i < MAX_PKT_BURST; i++)
 630                 bufs[i]->packet_type = RTE_PTYPE_L3_IPV4;
 631
 632         /*
 633          * set up parameters for rte_flow_classify_validate,
 634          * rte_flow_classify_table_entry_add and
 635          * rte_flow_classify_table_entry_delete
 636          */
 637
 638         attr.ingress = 1;
 639         attr.priority = 1;
 640         pattern[0] = eth_item;
 641         pattern[1] = ipv4_udp_item_1;
 642         pattern[2] = udp_item_1;
 643         pattern[3] = end_item;
 644         actions[0] = count_action;
 645         actions[1] = end_action;
 646
 647         ret = rte_flow_classify_validate(cls->cls, &attr, pattern,
 648                         actions, &error);
 649         if (ret) {
 650                 printf("Line %i: rte_flow_classify_validate", __LINE__);
 651                 printf(" should not have failed!\n");
 652                 return -1;
 653         }
 654
 655         rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
 656                         actions, &key_found, &error);
 657         if (!rule) {
 658                 printf("Line %i: flow_classify_table_entry_add", __LINE__);
 659                 printf(" should not have failed!\n");
 660                 return -1;
 661         }
 662
 663         ret = rte_flow_classifier_query(cls->cls, bufs, MAX_PKT_BURST,
 664                         rule, &udp_classify_stats);
 665         if (ret) {
 666                 printf("Line %i: flow_classifier_query", __LINE__);
 667                 printf(" should not have failed!\n");
 668                 return -1;
 669         }
 670
 671         ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 672         if (ret) {
 673                 printf("Line %i: rte_flow_classify_table_entry_delete",
 674                         __LINE__);
 675                 printf(" should not have failed!\n");
 676                 return -1;
 677         }
 678         return 0;
 679 }
 680
 681 static int
 682 test_query_tcp(void)
 683 {
 684         struct rte_flow_classify_rule *rule;
 685         int ret;
 686         int i;
 687         int key_found;
 688
 689         ret = init_ipv4_tcp_traffic(mbufpool[0], bufs, MAX_PKT_BURST);
 690         if (ret != MAX_PKT_BURST) {
 691                 printf("Line %i: init_ipv4_tcp_traffic has failed!\n",
 692                                 __LINE__);
 693                 return -1;
 694         }
 695
 696         for (i = 0; i < MAX_PKT_BURST; i++)
 697                 bufs[i]->packet_type = RTE_PTYPE_L3_IPV4;
 698
 699         /*
 700          * set up parameters for rte_flow_classify_validate,
 701          * rte_flow_classify_table_entry_add and
 702          * rte_flow_classify_table_entry_delete
 703          */
 704
 705         attr.ingress = 1;
 706         attr.priority = 1;
 707         pattern[0] = eth_item;
 708         pattern[1] = ipv4_tcp_item_1;
 709         pattern[2] = tcp_item_1;
 710         pattern[3] = end_item;
 711         actions[0] = count_action;
 712         actions[1] = end_action;
 713
 714         ret = rte_flow_classify_validate(cls->cls, &attr, pattern,
 715                         actions, &error);
 716         if (ret) {
 717                 printf("Line %i: flow_classifier_query", __LINE__);
 718                 printf(" should not have failed!\n");
 719                 return -1;
 720         }
 721
 722         rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
 723                         actions, &key_found, &error);
 724         if (!rule) {
 725                 printf("Line %i: flow_classify_table_entry_add", __LINE__);
 726                 printf(" should not have failed!\n");
 727                 return -1;
 728         }
 729
 730         ret = rte_flow_classifier_query(cls->cls, bufs, MAX_PKT_BURST,
 731                         rule, &tcp_classify_stats);
 732         if (ret) {
 733                 printf("Line %i: flow_classifier_query", __LINE__);
 734                 printf(" should not have failed!\n");
 735                 return -1;
 736         }
 737
 738         ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 739         if (ret) {
 740                 printf("Line %i: rte_flow_classify_table_entry_delete",
 741                         __LINE__);
 742                 printf(" should not have failed!\n");
 743                 return -1;
 744         }
 745         return 0;
 746 }
 747
 748 static int
 749 test_query_sctp(void)
 750 {
 751         struct rte_flow_classify_rule *rule;
 752         int ret;
 753         int i;
 754         int key_found;
 755
 756         ret = init_ipv4_sctp_traffic(mbufpool[0], bufs, MAX_PKT_BURST);
 757         if (ret != MAX_PKT_BURST) {
 758                 printf("Line %i: init_ipv4_tcp_traffic has failed!\n",
 759                         __LINE__);
 760                 return -1;
 761         }
 762
 763         for (i = 0; i < MAX_PKT_BURST; i++)
 764                 bufs[i]->packet_type = RTE_PTYPE_L3_IPV4;
 765
 766         /*
 767          * set up parameters rte_flow_classify_validate,
 768          * rte_flow_classify_table_entry_add and
 769          * rte_flow_classify_table_entry_delete
 770          */
 771
 772         attr.ingress = 1;
 773         attr.priority = 1;
 774         pattern[0] = eth_item;
 775         pattern[1] = ipv4_sctp_item_1;
 776         pattern[2] = sctp_item_1;
 777         pattern[3] = end_item;
 778         actions[0] = count_action;
 779         actions[1] = end_action;
 780
 781         ret = rte_flow_classify_validate(cls->cls, &attr, pattern,
 782                         actions, &error);
 783         if (ret) {
 784                 printf("Line %i: flow_classifier_query", __LINE__);
 785                 printf(" should not have failed!\n");
 786                 return -1;
 787         }
 788
 789         rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
 790                         actions, &key_found, &error);
 791         if (!rule) {
 792                 printf("Line %i: flow_classify_table_entry_add", __LINE__);
 793                 printf(" should not have failed!\n");
 794                 return -1;
 795         }
 796
 797         ret = rte_flow_classifier_query(cls->cls, bufs, MAX_PKT_BURST,
 798                         rule, &sctp_classify_stats);
 799         if (ret) {
 800                 printf("Line %i: flow_classifier_query", __LINE__);
 801                 printf(" should not have failed!\n");
 802                 return -1;
 803         }
 804
 805         ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 806         if (ret) {
 807                 printf("Line %i: rte_flow_classify_table_entry_delete",
 808                         __LINE__);
 809                 printf(" should not have failed!\n");
 810                 return -1;
 811         }
 812         return 0;
 813 }
 814
 815 static int
 816 test_flow_classify(void)
 817 {
 818         struct rte_table_acl_params table_acl_params;
 819         struct rte_flow_classify_table_params cls_table_params;
 820         struct rte_flow_classifier_params cls_params;
 821         int ret;
 822         uint32_t size;
 823
 824         /* Memory allocation */
 825         size = RTE_CACHE_LINE_ROUNDUP(sizeof(struct flow_classifier_acl));
 826         cls = rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE);
 827
 828         cls_params.name = "flow_classifier";
 829         cls_params.socket_id = 0;
 830         cls->cls = rte_flow_classifier_create(&cls_params);
 831
 832         /* initialise ACL table params */
 833         table_acl_params.n_rule_fields = RTE_DIM(ipv4_defs);
 834         table_acl_params.name = "table_acl_ipv4_5tuple";
 835         table_acl_params.n_rules = FLOW_CLASSIFY_MAX_RULE_NUM;
 836         memcpy(table_acl_params.field_format, ipv4_defs, sizeof(ipv4_defs));
 837
 838         /* initialise table create params */
 839         cls_table_params.ops = &rte_table_acl_ops;
 840         cls_table_params.arg_create = &table_acl_params;
 841         cls_table_params.type = RTE_FLOW_CLASSIFY_TABLE_ACL_IP4_5TUPLE;
 842
 843         ret = rte_flow_classify_table_create(cls->cls, &cls_table_params);
 844         if (ret) {
 845                 printf("Line %i: f_create has failed!\n", __LINE__);
 846                 rte_flow_classifier_free(cls->cls);
 847                 rte_free(cls);
 848                 return TEST_FAILED;
 849         }
 850         printf("Created table_acl for for IPv4 five tuple packets\n");
 851
 852         ret = init_mbufpool();
 853         if (ret) {
 854                 printf("Line %i: init_mbufpool has failed!\n", __LINE__);
 855                 return TEST_FAILED;
 856         }
 857
 858         if (test_invalid_parameters() < 0)
 859                 return TEST_FAILED;
 860         if (test_valid_parameters() < 0)
 861                 return TEST_FAILED;
 862         if (test_invalid_patterns() < 0)
 863                 return TEST_FAILED;
 864         if (test_invalid_actions() < 0)
 865                 return TEST_FAILED;
 866         if (test_query_udp() < 0)
 867                 return TEST_FAILED;
 868         if (test_query_tcp() < 0)
 869                 return TEST_FAILED;
 870         if (test_query_sctp() < 0)
 871                 return TEST_FAILED;
 872
 873         return TEST_SUCCESS;
 874 }
 875
 876 REGISTER_TEST_COMMAND(flow_classify_autotest, test_flow_classify);