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 ether_hdr) +
  43                         offsetof(struct 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 ether_hdr) +
  53                         offsetof(struct 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 ether_hdr) +
  63                         offsetof(struct 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 ether_hdr) +
  76                         sizeof(struct ipv4_hdr) +
  77                         offsetof(struct 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 ether_hdr) +
  86                         sizeof(struct ipv4_hdr) +
  87                         offsetof(struct 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, IPv4(2, 2, 2, 3), IPv4(2, 2, 2, 7)}
  99 };
 100 static const struct rte_flow_item_ipv4 ipv4_mask_24 = {
 101         .hdr = {
 102                 .next_proto_id = 0xff,
 103                 .src_addr = 0xffffff00,
 104                 .dst_addr = 0xffffff00,
 105         },
 106 };
 107 static struct rte_flow_item_udp udp_spec_1 = {
 108         { 32, 33, 0, 0 }
 109 };
 110
 111 static struct rte_flow_item  eth_item = { RTE_FLOW_ITEM_TYPE_ETH,
 112         0, 0, 0 };
 113 static struct rte_flow_item  eth_item_bad = { -1, 0, 0, 0 };
 114
 115 static struct rte_flow_item  ipv4_udp_item_1 = { RTE_FLOW_ITEM_TYPE_IPV4,
 116         &ipv4_udp_spec_1, 0, &ipv4_mask_24};
 117 static struct rte_flow_item  ipv4_udp_item_bad = { RTE_FLOW_ITEM_TYPE_IPV4,
 118         NULL, 0, NULL};
 119
 120 static struct rte_flow_item  udp_item_1 = { RTE_FLOW_ITEM_TYPE_UDP,
 121         &udp_spec_1, 0, &rte_flow_item_udp_mask};
 122 static struct rte_flow_item  udp_item_bad = { RTE_FLOW_ITEM_TYPE_UDP,
 123         NULL, 0, NULL};
 124
 125 static struct rte_flow_item  end_item = { RTE_FLOW_ITEM_TYPE_END,
 126         0, 0, 0 };
 127 static struct rte_flow_item  end_item_bad = { -1, 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, IPv4(1, 2, 3, 4), IPv4(5, 6, 7, 8)}
 135 };
 136
 137 static struct rte_flow_item_tcp tcp_spec_1 = {
 138         { 16, 17, 0, 0, 0, 0, 0, 0, 0}
 139 };
 140
 141 static struct rte_flow_item  ipv4_tcp_item_1 = { RTE_FLOW_ITEM_TYPE_IPV4,
 142         &ipv4_tcp_spec_1, 0, &ipv4_mask_24};
 143
 144 static struct rte_flow_item  tcp_item_1 = { RTE_FLOW_ITEM_TYPE_TCP,
 145         &tcp_spec_1, 0, &rte_flow_item_tcp_mask};
 146
 147 /* test SCTP pattern:
 148  * "eth / ipv4 src spec 1.2.3.4 src mask 255.255.255.00 dst spec 5.6.7.8
 149  *  dst mask 255.255.255.00 / sctp src is 16 dst is 17/ end"
 150  */
 151 static struct rte_flow_item_ipv4 ipv4_sctp_spec_1 = {
 152         { 0, 0, 0, 0, 0, 0, IPPROTO_SCTP, 0, IPv4(11, 12, 13, 14),
 153         IPv4(15, 16, 17, 18)}
 154 };
 155
 156 static struct rte_flow_item_sctp sctp_spec_1 = {
 157         { 10, 11, 0, 0}
 158 };
 159
 160 static struct rte_flow_item  ipv4_sctp_item_1 = { RTE_FLOW_ITEM_TYPE_IPV4,
 161         &ipv4_sctp_spec_1, 0, &ipv4_mask_24};
 162
 163 static struct rte_flow_item  sctp_item_1 = { RTE_FLOW_ITEM_TYPE_SCTP,
 164         &sctp_spec_1, 0, &rte_flow_item_sctp_mask};
 165
 166
 167 /* test actions:
 168  * "actions count / end"
 169  */
 170 static struct rte_flow_query_count count = {
 171         .reset = 1,
 172         .hits_set = 1,
 173         .bytes_set = 1,
 174         .hits = 0,
 175         .bytes = 0,
 176 };
 177 static struct rte_flow_action count_action = { RTE_FLOW_ACTION_TYPE_COUNT,
 178         &count};
 179 static struct rte_flow_action count_action_bad = { -1, 0};
 180
 181 static struct rte_flow_action end_action = { RTE_FLOW_ACTION_TYPE_END, 0};
 182 static struct rte_flow_action end_action_bad =  { -1, 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_bad;
 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         actions[0] = count_action;
 460         actions[1] = end_action_bad;
 461
 462         ret = rte_flow_classify_validate(cls->cls, &attr, pattern,
 463                         actions, &error);
 464         if (!ret) {
 465                 printf("Line %i: rte_flow_classify_validate", __LINE__);
 466                 printf(" should have failed!\n");
 467                 return -1;
 468         }
 469
 470         rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
 471                         actions, &key_found, &error);
 472         if (rule) {
 473                 printf("Line %i: flow_classify_table_entry_add", __LINE__);
 474                 printf(" should have failed!\n");
 475                 return -1;
 476         }
 477
 478         ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 479         if (!ret) {
 480                 printf("Line %i: rte_flow_classify_table_entry_delete",
 481                         __LINE__);
 482                 printf("should have failed!\n");
 483                 return -1;
 484         }
 485         return 0;
 486 }
 487
 488 static int
 489 init_ipv4_udp_traffic(struct rte_mempool *mp,
 490              struct rte_mbuf **pkts_burst, uint32_t burst_size)
 491 {
 492         struct ether_hdr pkt_eth_hdr;
 493         struct ipv4_hdr pkt_ipv4_hdr;
 494         struct udp_hdr pkt_udp_hdr;
 495         uint32_t src_addr = IPV4_ADDR(2, 2, 2, 3);
 496         uint32_t dst_addr = IPV4_ADDR(2, 2, 2, 7);
 497         uint16_t src_port = 32;
 498         uint16_t dst_port = 33;
 499         uint16_t pktlen;
 500
 501         static uint8_t src_mac[] = { 0x00, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF };
 502         static uint8_t dst_mac[] = { 0x00, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA };
 503
 504         printf("Set up IPv4 UDP traffic\n");
 505         initialize_eth_header(&pkt_eth_hdr,
 506                 (struct ether_addr *)src_mac,
 507                 (struct ether_addr *)dst_mac, ETHER_TYPE_IPv4, 0, 0);
 508         pktlen = (uint16_t)(sizeof(struct ether_hdr));
 509         printf("ETH  pktlen %u\n", pktlen);
 510
 511         pktlen = initialize_ipv4_header(&pkt_ipv4_hdr, src_addr, dst_addr,
 512                                         pktlen);
 513         printf("ETH + IPv4 pktlen %u\n", pktlen);
 514
 515         pktlen = initialize_udp_header(&pkt_udp_hdr, src_port, dst_port,
 516                                         pktlen);
 517         printf("ETH + IPv4 + UDP pktlen %u\n\n", pktlen);
 518
 519         return generate_packet_burst(mp, pkts_burst, &pkt_eth_hdr,
 520                                      0, &pkt_ipv4_hdr, 1,
 521                                      &pkt_udp_hdr, burst_size,
 522                                      PACKET_BURST_GEN_PKT_LEN, 1);
 523 }
 524
 525 static int
 526 init_ipv4_tcp_traffic(struct rte_mempool *mp,
 527              struct rte_mbuf **pkts_burst, uint32_t burst_size)
 528 {
 529         struct ether_hdr pkt_eth_hdr;
 530         struct ipv4_hdr pkt_ipv4_hdr;
 531         struct tcp_hdr pkt_tcp_hdr;
 532         uint32_t src_addr = IPV4_ADDR(1, 2, 3, 4);
 533         uint32_t dst_addr = IPV4_ADDR(5, 6, 7, 8);
 534         uint16_t src_port = 16;
 535         uint16_t dst_port = 17;
 536         uint16_t pktlen;
 537
 538         static uint8_t src_mac[] = { 0x00, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF };
 539         static uint8_t dst_mac[] = { 0x00, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA };
 540
 541         printf("Set up IPv4 TCP traffic\n");
 542         initialize_eth_header(&pkt_eth_hdr,
 543                 (struct ether_addr *)src_mac,
 544                 (struct ether_addr *)dst_mac, ETHER_TYPE_IPv4, 0, 0);
 545         pktlen = (uint16_t)(sizeof(struct ether_hdr));
 546         printf("ETH  pktlen %u\n", pktlen);
 547
 548         pktlen = initialize_ipv4_header_proto(&pkt_ipv4_hdr, src_addr,
 549                                         dst_addr, pktlen, IPPROTO_TCP);
 550         printf("ETH + IPv4 pktlen %u\n", pktlen);
 551
 552         pktlen = initialize_tcp_header(&pkt_tcp_hdr, src_port, dst_port,
 553                                         pktlen);
 554         printf("ETH + IPv4 + TCP pktlen %u\n\n", pktlen);
 555
 556         return generate_packet_burst_proto(mp, pkts_burst, &pkt_eth_hdr,
 557                                         0, &pkt_ipv4_hdr, 1, IPPROTO_TCP,
 558                                         &pkt_tcp_hdr, burst_size,
 559                                         PACKET_BURST_GEN_PKT_LEN, 1);
 560 }
 561
 562 static int
 563 init_ipv4_sctp_traffic(struct rte_mempool *mp,
 564              struct rte_mbuf **pkts_burst, uint32_t burst_size)
 565 {
 566         struct ether_hdr pkt_eth_hdr;
 567         struct ipv4_hdr pkt_ipv4_hdr;
 568         struct sctp_hdr pkt_sctp_hdr;
 569         uint32_t src_addr = IPV4_ADDR(11, 12, 13, 14);
 570         uint32_t dst_addr = IPV4_ADDR(15, 16, 17, 18);
 571         uint16_t src_port = 10;
 572         uint16_t dst_port = 11;
 573         uint16_t pktlen;
 574
 575         static uint8_t src_mac[] = { 0x00, 0xFF, 0xAA, 0xFF, 0xAA, 0xFF };
 576         static uint8_t dst_mac[] = { 0x00, 0xAA, 0xFF, 0xAA, 0xFF, 0xAA };
 577
 578         printf("Set up IPv4 SCTP traffic\n");
 579         initialize_eth_header(&pkt_eth_hdr,
 580                 (struct ether_addr *)src_mac,
 581                 (struct ether_addr *)dst_mac, ETHER_TYPE_IPv4, 0, 0);
 582         pktlen = (uint16_t)(sizeof(struct ether_hdr));
 583         printf("ETH  pktlen %u\n", pktlen);
 584
 585         pktlen = initialize_ipv4_header_proto(&pkt_ipv4_hdr, src_addr,
 586                                         dst_addr, pktlen, IPPROTO_SCTP);
 587         printf("ETH + IPv4 pktlen %u\n", pktlen);
 588
 589         pktlen = initialize_sctp_header(&pkt_sctp_hdr, src_port, dst_port,
 590                                         pktlen);
 591         printf("ETH + IPv4 + SCTP pktlen %u\n\n", pktlen);
 592
 593         return generate_packet_burst_proto(mp, pkts_burst, &pkt_eth_hdr,
 594                                         0, &pkt_ipv4_hdr, 1, IPPROTO_SCTP,
 595                                         &pkt_sctp_hdr, burst_size,
 596                                         PACKET_BURST_GEN_PKT_LEN, 1);
 597 }
 598
 599 static int
 600 init_mbufpool(void)
 601 {
 602         int socketid;
 603         int ret = 0;
 604         unsigned int lcore_id;
 605         char s[64];
 606
 607         for (lcore_id = 0; lcore_id < RTE_MAX_LCORE; lcore_id++) {
 608                 if (rte_lcore_is_enabled(lcore_id) == 0)
 609                         continue;
 610
 611                 socketid = rte_lcore_to_socket_id(lcore_id);
 612                 if (socketid >= NB_SOCKETS) {
 613                         printf(
 614                                 "Socket %d of lcore %u is out of range %d\n",
 615                                 socketid, lcore_id, NB_SOCKETS);
 616                         ret = -1;
 617                         break;
 618                 }
 619                 if (mbufpool[socketid] == NULL) {
 620                         snprintf(s, sizeof(s), "mbuf_pool_%d", socketid);
 621                         mbufpool[socketid] =
 622                                 rte_pktmbuf_pool_create(s, NB_MBUF,
 623                                         MEMPOOL_CACHE_SIZE, 0, MBUF_SIZE,
 624                                         socketid);
 625                         if (mbufpool[socketid]) {
 626                                 printf("Allocated mbuf pool on socket %d\n",
 627                                         socketid);
 628                         } else {
 629                                 printf("Cannot init mbuf pool on socket %d\n",
 630                                         socketid);
 631                                 ret = -ENOMEM;
 632                                 break;
 633                         }
 634                 }
 635         }
 636         return ret;
 637 }
 638
 639 static int
 640 test_query_udp(void)
 641 {
 642         struct rte_flow_error error;
 643         struct rte_flow_classify_rule *rule;
 644         int ret;
 645         int i;
 646         int key_found;
 647
 648         ret = init_ipv4_udp_traffic(mbufpool[0], bufs, MAX_PKT_BURST);
 649         if (ret != MAX_PKT_BURST) {
 650                 printf("Line %i: init_udp_ipv4_traffic has failed!\n",
 651                                 __LINE__);
 652                 return -1;
 653         }
 654
 655         for (i = 0; i < MAX_PKT_BURST; i++)
 656                 bufs[i]->packet_type = RTE_PTYPE_L3_IPV4;
 657
 658         /*
 659          * set up parameters for rte_flow_classify_validate,
 660          * rte_flow_classify_table_entry_add and
 661          * rte_flow_classify_table_entry_delete
 662          */
 663
 664         attr.ingress = 1;
 665         attr.priority = 1;
 666         pattern[0] = eth_item;
 667         pattern[1] = ipv4_udp_item_1;
 668         pattern[2] = udp_item_1;
 669         pattern[3] = end_item;
 670         actions[0] = count_action;
 671         actions[1] = end_action;
 672
 673         ret = rte_flow_classify_validate(cls->cls, &attr, pattern,
 674                         actions, &error);
 675         if (ret) {
 676                 printf("Line %i: rte_flow_classify_validate", __LINE__);
 677                 printf(" should not have failed!\n");
 678                 return -1;
 679         }
 680
 681         rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
 682                         actions, &key_found, &error);
 683         if (!rule) {
 684                 printf("Line %i: flow_classify_table_entry_add", __LINE__);
 685                 printf(" should not have failed!\n");
 686                 return -1;
 687         }
 688
 689         ret = rte_flow_classifier_query(cls->cls, bufs, MAX_PKT_BURST,
 690                         rule, &udp_classify_stats);
 691         if (ret) {
 692                 printf("Line %i: flow_classifier_query", __LINE__);
 693                 printf(" should not have failed!\n");
 694                 return -1;
 695         }
 696
 697         ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 698         if (ret) {
 699                 printf("Line %i: rte_flow_classify_table_entry_delete",
 700                         __LINE__);
 701                 printf(" should not have failed!\n");
 702                 return -1;
 703         }
 704         return 0;
 705 }
 706
 707 static int
 708 test_query_tcp(void)
 709 {
 710         struct rte_flow_classify_rule *rule;
 711         int ret;
 712         int i;
 713         int key_found;
 714
 715         ret = init_ipv4_tcp_traffic(mbufpool[0], bufs, MAX_PKT_BURST);
 716         if (ret != MAX_PKT_BURST) {
 717                 printf("Line %i: init_ipv4_tcp_traffic has failed!\n",
 718                                 __LINE__);
 719                 return -1;
 720         }
 721
 722         for (i = 0; i < MAX_PKT_BURST; i++)
 723                 bufs[i]->packet_type = RTE_PTYPE_L3_IPV4;
 724
 725         /*
 726          * set up parameters for rte_flow_classify_validate,
 727          * rte_flow_classify_table_entry_add and
 728          * rte_flow_classify_table_entry_delete
 729          */
 730
 731         attr.ingress = 1;
 732         attr.priority = 1;
 733         pattern[0] = eth_item;
 734         pattern[1] = ipv4_tcp_item_1;
 735         pattern[2] = tcp_item_1;
 736         pattern[3] = end_item;
 737         actions[0] = count_action;
 738         actions[1] = end_action;
 739
 740         ret = rte_flow_classify_validate(cls->cls, &attr, pattern,
 741                         actions, &error);
 742         if (ret) {
 743                 printf("Line %i: flow_classifier_query", __LINE__);
 744                 printf(" should not have failed!\n");
 745                 return -1;
 746         }
 747
 748         rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
 749                         actions, &key_found, &error);
 750         if (!rule) {
 751                 printf("Line %i: flow_classify_table_entry_add", __LINE__);
 752                 printf(" should not have failed!\n");
 753                 return -1;
 754         }
 755
 756         ret = rte_flow_classifier_query(cls->cls, bufs, MAX_PKT_BURST,
 757                         rule, &tcp_classify_stats);
 758         if (ret) {
 759                 printf("Line %i: flow_classifier_query", __LINE__);
 760                 printf(" should not have failed!\n");
 761                 return -1;
 762         }
 763
 764         ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 765         if (ret) {
 766                 printf("Line %i: rte_flow_classify_table_entry_delete",
 767                         __LINE__);
 768                 printf(" should not have failed!\n");
 769                 return -1;
 770         }
 771         return 0;
 772 }
 773
 774 static int
 775 test_query_sctp(void)
 776 {
 777         struct rte_flow_classify_rule *rule;
 778         int ret;
 779         int i;
 780         int key_found;
 781
 782         ret = init_ipv4_sctp_traffic(mbufpool[0], bufs, MAX_PKT_BURST);
 783         if (ret != MAX_PKT_BURST) {
 784                 printf("Line %i: init_ipv4_tcp_traffic has failed!\n",
 785                         __LINE__);
 786                 return -1;
 787         }
 788
 789         for (i = 0; i < MAX_PKT_BURST; i++)
 790                 bufs[i]->packet_type = RTE_PTYPE_L3_IPV4;
 791
 792         /*
 793          * set up parameters rte_flow_classify_validate,
 794          * rte_flow_classify_table_entry_add and
 795          * rte_flow_classify_table_entry_delete
 796          */
 797
 798         attr.ingress = 1;
 799         attr.priority = 1;
 800         pattern[0] = eth_item;
 801         pattern[1] = ipv4_sctp_item_1;
 802         pattern[2] = sctp_item_1;
 803         pattern[3] = end_item;
 804         actions[0] = count_action;
 805         actions[1] = end_action;
 806
 807         ret = rte_flow_classify_validate(cls->cls, &attr, pattern,
 808                         actions, &error);
 809         if (ret) {
 810                 printf("Line %i: flow_classifier_query", __LINE__);
 811                 printf(" should not have failed!\n");
 812                 return -1;
 813         }
 814
 815         rule = rte_flow_classify_table_entry_add(cls->cls, &attr, pattern,
 816                         actions, &key_found, &error);
 817         if (!rule) {
 818                 printf("Line %i: flow_classify_table_entry_add", __LINE__);
 819                 printf(" should not have failed!\n");
 820                 return -1;
 821         }
 822
 823         ret = rte_flow_classifier_query(cls->cls, bufs, MAX_PKT_BURST,
 824                         rule, &sctp_classify_stats);
 825         if (ret) {
 826                 printf("Line %i: flow_classifier_query", __LINE__);
 827                 printf(" should not have failed!\n");
 828                 return -1;
 829         }
 830
 831         ret = rte_flow_classify_table_entry_delete(cls->cls, rule);
 832         if (ret) {
 833                 printf("Line %i: rte_flow_classify_table_entry_delete",
 834                         __LINE__);
 835                 printf(" should not have failed!\n");
 836                 return -1;
 837         }
 838         return 0;
 839 }
 840
 841 static int
 842 test_flow_classify(void)
 843 {
 844         struct rte_table_acl_params table_acl_params;
 845         struct rte_flow_classify_table_params cls_table_params;
 846         struct rte_flow_classifier_params cls_params;
 847         int ret;
 848         uint32_t size;
 849
 850         /* Memory allocation */
 851         size = RTE_CACHE_LINE_ROUNDUP(sizeof(struct flow_classifier_acl));
 852         cls = rte_zmalloc(NULL, size, RTE_CACHE_LINE_SIZE);
 853
 854         cls_params.name = "flow_classifier";
 855         cls_params.socket_id = 0;
 856         cls->cls = rte_flow_classifier_create(&cls_params);
 857
 858         /* initialise ACL table params */
 859         table_acl_params.n_rule_fields = RTE_DIM(ipv4_defs);
 860         table_acl_params.name = "table_acl_ipv4_5tuple";
 861         table_acl_params.n_rules = FLOW_CLASSIFY_MAX_RULE_NUM;
 862         memcpy(table_acl_params.field_format, ipv4_defs, sizeof(ipv4_defs));
 863
 864         /* initialise table create params */
 865         cls_table_params.ops = &rte_table_acl_ops;
 866         cls_table_params.arg_create = &table_acl_params;
 867         cls_table_params.type = RTE_FLOW_CLASSIFY_TABLE_ACL_IP4_5TUPLE;
 868
 869         ret = rte_flow_classify_table_create(cls->cls, &cls_table_params);
 870         if (ret) {
 871                 printf("Line %i: f_create has failed!\n", __LINE__);
 872                 rte_flow_classifier_free(cls->cls);
 873                 rte_free(cls);
 874                 return TEST_FAILED;
 875         }
 876         printf("Created table_acl for for IPv4 five tuple packets\n");
 877
 878         ret = init_mbufpool();
 879         if (ret) {
 880                 printf("Line %i: init_mbufpool has failed!\n", __LINE__);
 881                 return TEST_FAILED;
 882         }
 883
 884         if (test_invalid_parameters() < 0)
 885                 return TEST_FAILED;
 886         if (test_valid_parameters() < 0)
 887                 return TEST_FAILED;
 888         if (test_invalid_patterns() < 0)
 889                 return TEST_FAILED;
 890         if (test_invalid_actions() < 0)
 891                 return TEST_FAILED;
 892         if (test_query_udp() < 0)
 893                 return TEST_FAILED;
 894         if (test_query_tcp() < 0)
 895                 return TEST_FAILED;
 896         if (test_query_sctp() < 0)
 897                 return TEST_FAILED;
 898
 899         return TEST_SUCCESS;
 900 }
 901
 902 REGISTER_TEST_COMMAND(flow_classify_autotest, test_flow_classify);