1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2010-2014 Intel Corporation. All rights reserved. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <string.h> 35 #include <rte_pipeline.h> 36 #include <rte_log.h> 37 #include <inttypes.h> 38 #include <rte_hexdump.h> 39 #include "test_table.h" 40 #include "test_table_pipeline.h" 41 42 #if 0 43 44 static rte_pipeline_port_out_action_handler port_action_0x00 45 (struct rte_mbuf **pkts, uint32_t n, uint64_t *pkts_mask, void *arg); 46 static rte_pipeline_port_out_action_handler port_action_0xFF 47 (struct rte_mbuf **pkts, uint32_t n, uint64_t *pkts_mask, void *arg); 48 static rte_pipeline_port_out_action_handler port_action_stub 49 (struct rte_mbuf **pkts, uint32_t n, uint64_t *pkts_mask, void *arg); 50 51 52 rte_pipeline_port_out_action_handler port_action_0x00(struct rte_mbuf **pkts, 53 uint32_t n, 54 uint64_t *pkts_mask, 55 void *arg) 56 { 57 RTE_SET_USED(pkts); 58 RTE_SET_USED(n); 59 RTE_SET_USED(arg); 60 printf("Port Action 0x00\n"); 61 *pkts_mask = 0x00; 62 return 0; 63 } 64 65 rte_pipeline_port_out_action_handler port_action_0xFF(struct rte_mbuf **pkts, 66 uint32_t n, 67 uint64_t *pkts_mask, 68 void *arg) 69 { 70 RTE_SET_USED(pkts); 71 RTE_SET_USED(n); 72 RTE_SET_USED(arg); 73 printf("Port Action 0xFF\n"); 74 *pkts_mask = 0xFF; 75 return 0; 76 } 77 78 rte_pipeline_port_out_action_handler port_action_stub(struct rte_mbuf **pkts, 79 uint32_t n, 80 uint64_t *pkts_mask, 81 void *arg) 82 { 83 RTE_SET_USED(pkts); 84 RTE_SET_USED(n); 85 RTE_SET_USED(pkts_mask); 86 RTE_SET_USED(arg); 87 printf("Port Action stub\n"); 88 return 0; 89 } 90 91 #endif 92 93 rte_pipeline_table_action_handler_hit 94 table_action_0x00(struct rte_pipeline *p, struct rte_mbuf **pkts, 95 uint64_t pkts_mask, struct rte_pipeline_table_entry **entry, void *arg); 96 97 rte_pipeline_table_action_handler_hit 98 table_action_stub_hit(struct rte_pipeline *p, struct rte_mbuf **pkts, 99 uint64_t pkts_mask, struct rte_pipeline_table_entry **entry, void *arg); 100 101 rte_pipeline_table_action_handler_miss 102 table_action_stub_miss(struct rte_pipeline *p, struct rte_mbuf **pkts, 103 uint64_t pkts_mask, struct rte_pipeline_table_entry **entry, void *arg); 104 105 rte_pipeline_table_action_handler_hit 106 table_action_0x00(__attribute__((unused)) struct rte_pipeline *p, 107 __attribute__((unused)) struct rte_mbuf **pkts, 108 uint64_t pkts_mask, 109 __attribute__((unused)) struct rte_pipeline_table_entry **entry, 110 __attribute__((unused)) void *arg) 111 { 112 printf("Table Action, setting pkts_mask to 0x00\n"); 113 pkts_mask = ~0x00; 114 rte_pipeline_ah_packet_drop(p, pkts_mask); 115 return 0; 116 } 117 118 rte_pipeline_table_action_handler_hit 119 table_action_stub_hit(__attribute__((unused)) struct rte_pipeline *p, 120 __attribute__((unused)) struct rte_mbuf **pkts, 121 uint64_t pkts_mask, 122 __attribute__((unused)) struct rte_pipeline_table_entry **entry, 123 __attribute__((unused)) void *arg) 124 { 125 printf("STUB Table Action Hit - doing nothing\n"); 126 printf("STUB Table Action Hit - setting mask to 0x%"PRIx64"\n", 127 override_hit_mask); 128 pkts_mask = (~override_hit_mask) & 0x3; 129 rte_pipeline_ah_packet_drop(p, pkts_mask); 130 return 0; 131 } 132 133 rte_pipeline_table_action_handler_miss 134 table_action_stub_miss(struct rte_pipeline *p, 135 __attribute__((unused)) struct rte_mbuf **pkts, 136 uint64_t pkts_mask, 137 __attribute__((unused)) struct rte_pipeline_table_entry **entry, 138 __attribute__((unused)) void *arg) 139 { 140 printf("STUB Table Action Miss - setting mask to 0x%"PRIx64"\n", 141 override_miss_mask); 142 pkts_mask = (~override_miss_mask) & 0x3; 143 rte_pipeline_ah_packet_drop(p, pkts_mask); 144 return 0; 145 } 146 147 enum e_test_type { 148 e_TEST_STUB = 0, 149 e_TEST_LPM, 150 e_TEST_LPM6, 151 e_TEST_HASH_LRU_8, 152 e_TEST_HASH_LRU_16, 153 e_TEST_HASH_LRU_32, 154 e_TEST_HASH_EXT_8, 155 e_TEST_HASH_EXT_16, 156 e_TEST_HASH_EXT_32 157 }; 158 159 char pipeline_test_names[][64] = { 160 "Stub", 161 "LPM", 162 "LPMv6", 163 "8-bit LRU Hash", 164 "16-bit LRU Hash", 165 "32-bit LRU Hash", 166 "16-bit Ext Hash", 167 "8-bit Ext Hash", 168 "32-bit Ext Hash", 169 "" 170 }; 171 172 173 static int 174 cleanup_pipeline(void) 175 { 176 177 rte_pipeline_free(p); 178 179 return 0; 180 } 181 182 183 static int check_pipeline_invalid_params(void); 184 185 static int 186 check_pipeline_invalid_params(void) 187 { 188 struct rte_pipeline_params pipeline_params_1 = { 189 .name = NULL, 190 .socket_id = 0, 191 }; 192 struct rte_pipeline_params pipeline_params_2 = { 193 .name = "PIPELINE", 194 .socket_id = -1, 195 }; 196 struct rte_pipeline_params pipeline_params_3 = { 197 .name = "PIPELINE", 198 .socket_id = 127, 199 }; 200 201 p = rte_pipeline_create(NULL); 202 if (p != NULL) { 203 RTE_LOG(INFO, PIPELINE, 204 "%s: configured pipeline with null params\n", 205 __func__); 206 goto fail; 207 } 208 p = rte_pipeline_create(&pipeline_params_1); 209 if (p != NULL) { 210 RTE_LOG(INFO, PIPELINE, "%s: Configure pipeline with NULL " 211 "name\n", __func__); 212 goto fail; 213 } 214 215 p = rte_pipeline_create(&pipeline_params_2); 216 if (p != NULL) { 217 RTE_LOG(INFO, PIPELINE, "%s: Configure pipeline with invalid " 218 "socket\n", __func__); 219 goto fail; 220 } 221 222 p = rte_pipeline_create(&pipeline_params_3); 223 if (p != NULL) { 224 RTE_LOG(INFO, PIPELINE, "%s: Configure pipeline with invalid " 225 "socket\n", __func__); 226 goto fail; 227 } 228 229 /* Check pipeline consistency */ 230 if (!rte_pipeline_check(p)) { 231 rte_panic("Pipeline consistency reported as OK\n"); 232 goto fail; 233 } 234 235 236 return 0; 237 fail: 238 return -1; 239 } 240 241 242 static int 243 setup_pipeline(int test_type) 244 { 245 int ret; 246 int i; 247 struct rte_pipeline_params pipeline_params = { 248 .name = "PIPELINE", 249 .socket_id = 0, 250 }; 251 252 RTE_LOG(INFO, PIPELINE, "%s: **** Setting up %s test\n", 253 __func__, pipeline_test_names[test_type]); 254 255 /* Pipeline configuration */ 256 p = rte_pipeline_create(&pipeline_params); 257 if (p == NULL) { 258 RTE_LOG(INFO, PIPELINE, "%s: Failed to configure pipeline\n", 259 __func__); 260 goto fail; 261 } 262 263 ret = rte_pipeline_free(p); 264 if (ret != 0) { 265 RTE_LOG(INFO, PIPELINE, "%s: Failed to free pipeline\n", 266 __func__); 267 goto fail; 268 } 269 270 /* Pipeline configuration */ 271 p = rte_pipeline_create(&pipeline_params); 272 if (p == NULL) { 273 RTE_LOG(INFO, PIPELINE, "%s: Failed to configure pipeline\n", 274 __func__); 275 goto fail; 276 } 277 278 279 /* Input port configuration */ 280 for (i = 0; i < N_PORTS; i++) { 281 struct rte_port_ring_reader_params port_ring_params = { 282 .ring = rings_rx[i], 283 }; 284 285 struct rte_pipeline_port_in_params port_params = { 286 .ops = &rte_port_ring_reader_ops, 287 .arg_create = (void *) &port_ring_params, 288 .f_action = NULL, 289 .burst_size = BURST_SIZE, 290 }; 291 292 /* Put in action for some ports */ 293 if (i) 294 port_params.f_action = NULL; 295 296 ret = rte_pipeline_port_in_create(p, &port_params, 297 &port_in_id[i]); 298 if (ret) { 299 rte_panic("Unable to configure input port %d, ret:%d\n", 300 i, ret); 301 goto fail; 302 } 303 } 304 305 /* output Port configuration */ 306 for (i = 0; i < N_PORTS; i++) { 307 struct rte_port_ring_writer_params port_ring_params = { 308 .ring = rings_tx[i], 309 .tx_burst_sz = BURST_SIZE, 310 }; 311 312 struct rte_pipeline_port_out_params port_params = { 313 .ops = &rte_port_ring_writer_ops, 314 .arg_create = (void *) &port_ring_params, 315 .f_action = NULL, 316 .arg_ah = NULL, 317 }; 318 319 if (i) 320 port_params.f_action = port_out_action; 321 322 if (rte_pipeline_port_out_create(p, &port_params, 323 &port_out_id[i])) { 324 rte_panic("Unable to configure output port %d\n", i); 325 goto fail; 326 } 327 } 328 329 /* Table configuration */ 330 for (i = 0; i < N_PORTS; i++) { 331 struct rte_pipeline_table_params table_params = { 332 .ops = &rte_table_stub_ops, 333 .arg_create = NULL, 334 .f_action_hit = action_handler_hit, 335 .f_action_miss = action_handler_miss, 336 .action_data_size = 0, 337 }; 338 339 if (rte_pipeline_table_create(p, &table_params, &table_id[i])) { 340 rte_panic("Unable to configure table %u\n", i); 341 goto fail; 342 } 343 344 if (connect_miss_action_to_table) 345 if (rte_pipeline_table_create(p, &table_params, 346 &table_id[i+2])) { 347 rte_panic("Unable to configure table %u\n", i); 348 goto fail; 349 } 350 } 351 352 for (i = 0; i < N_PORTS; i++) 353 if (rte_pipeline_port_in_connect_to_table(p, port_in_id[i], 354 table_id[i])) { 355 rte_panic("Unable to connect input port %u to " 356 "table %u\n", port_in_id[i], table_id[i]); 357 goto fail; 358 } 359 360 /* Add entries to tables */ 361 for (i = 0; i < N_PORTS; i++) { 362 struct rte_pipeline_table_entry default_entry = { 363 .action = (enum rte_pipeline_action) 364 table_entry_default_action, 365 {.port_id = port_out_id[i^1]}, 366 }; 367 struct rte_pipeline_table_entry *default_entry_ptr; 368 369 if (connect_miss_action_to_table) { 370 printf("Setting first table to output to next table\n"); 371 default_entry.action = RTE_PIPELINE_ACTION_TABLE; 372 default_entry.table_id = table_id[i+2]; 373 } 374 375 /* Add the default action for the table. */ 376 ret = rte_pipeline_table_default_entry_add(p, table_id[i], 377 &default_entry, &default_entry_ptr); 378 if (ret < 0) { 379 rte_panic("Unable to add default entry to table %u " 380 "code %d\n", table_id[i], ret); 381 goto fail; 382 } else 383 printf("Added default entry to table id %d with " 384 "action %x\n", 385 table_id[i], default_entry.action); 386 387 if (connect_miss_action_to_table) { 388 /* We create a second table so the first can pass 389 traffic into it */ 390 struct rte_pipeline_table_entry default_entry = { 391 .action = RTE_PIPELINE_ACTION_PORT, 392 {.port_id = port_out_id[i^1]}, 393 }; 394 printf("Setting secont table to output to port\n"); 395 396 /* Add the default action for the table. */ 397 ret = rte_pipeline_table_default_entry_add(p, 398 table_id[i+2], 399 &default_entry, &default_entry_ptr); 400 if (ret < 0) { 401 rte_panic("Unable to add default entry to " 402 "table %u code %d\n", 403 table_id[i], ret); 404 goto fail; 405 } else 406 printf("Added default entry to table id %d " 407 "with action %x\n", 408 table_id[i], default_entry.action); 409 } 410 } 411 412 /* Enable input ports */ 413 for (i = 0; i < N_PORTS ; i++) 414 if (rte_pipeline_port_in_enable(p, port_in_id[i])) 415 rte_panic("Unable to enable input port %u\n", 416 port_in_id[i]); 417 418 /* Check pipeline consistency */ 419 if (rte_pipeline_check(p) < 0) { 420 rte_panic("Pipeline consistency check failed\n"); 421 goto fail; 422 } else 423 printf("Pipeline Consistency OK!\n"); 424 425 return 0; 426 fail: 427 428 return -1; 429 } 430 431 static int 432 test_pipeline_single_filter(int test_type, int expected_count) 433 { 434 int i; 435 int j; 436 int ret; 437 int tx_count; 438 439 RTE_LOG(INFO, PIPELINE, "%s: **** Running %s test\n", 440 __func__, pipeline_test_names[test_type]); 441 /* Run pipeline once */ 442 for (i = 0; i < N_PORTS; i++) 443 rte_pipeline_run(p); 444 445 446 ret = rte_pipeline_flush(NULL); 447 if (ret != -EINVAL) { 448 RTE_LOG(INFO, PIPELINE, 449 "%s: No pipeline flush error NULL pipeline (%d)\n", 450 __func__, ret); 451 goto fail; 452 } 453 454 /* 455 * Allocate a few mbufs and manually insert into the rings. */ 456 for (i = 0; i < N_PORTS; i++) 457 for (j = 0; j < N_PORTS; j++) { 458 struct rte_mbuf *m; 459 uint8_t *key; 460 uint32_t *k32; 461 462 m = rte_pktmbuf_alloc(pool); 463 if (m == NULL) { 464 rte_panic("Failed to alloc mbuf from pool\n"); 465 return -1; 466 } 467 key = RTE_MBUF_METADATA_UINT8_PTR(m, 468 APP_METADATA_OFFSET(32)); 469 470 k32 = (uint32_t *) key; 471 k32[0] = 0xadadadad >> (j % 2); 472 473 RTE_LOG(INFO, PIPELINE, "%s: Enqueue onto ring %d\n", 474 __func__, i); 475 rte_ring_enqueue(rings_rx[i], m); 476 } 477 478 /* Run pipeline once */ 479 for (i = 0; i < N_PORTS; i++) 480 rte_pipeline_run(p); 481 482 /* 483 * need to flush the pipeline, as there may be less hits than the burst 484 size and they will not have been flushed to the tx rings. */ 485 rte_pipeline_flush(p); 486 487 /* 488 * Now we'll see what we got back on the tx rings. We should see whatever 489 * packets we had hits on that were destined for the output ports. 490 */ 491 tx_count = 0; 492 493 for (i = 0; i < N_PORTS; i++) { 494 void *objs[RING_TX_SIZE]; 495 struct rte_mbuf *mbuf; 496 497 ret = rte_ring_sc_dequeue_burst(rings_tx[i], objs, 10); 498 if (ret <= 0) 499 printf("Got no objects from ring %d - error code %d\n", 500 i, ret); 501 else { 502 printf("Got %d object(s) from ring %d!\n", ret, i); 503 for (j = 0; j < ret; j++) { 504 mbuf = (struct rte_mbuf *)objs[j]; 505 rte_hexdump(stdout, "Object:", 506 rte_pktmbuf_mtod(mbuf, char *), 507 mbuf->data_len); 508 rte_pktmbuf_free(mbuf); 509 } 510 tx_count += ret; 511 } 512 } 513 514 if (tx_count != expected_count) { 515 RTE_LOG(INFO, PIPELINE, 516 "%s: Unexpected packets out for %s test, expected %d, " 517 "got %d\n", __func__, pipeline_test_names[test_type], 518 expected_count, tx_count); 519 goto fail; 520 } 521 522 cleanup_pipeline(); 523 524 return 0; 525 fail: 526 return -1; 527 528 } 529 530 int 531 test_table_pipeline(void) 532 { 533 /* TEST - All packets dropped */ 534 action_handler_hit = NULL; 535 action_handler_miss = NULL; 536 table_entry_default_action = RTE_PIPELINE_ACTION_DROP; 537 setup_pipeline(e_TEST_STUB); 538 if (test_pipeline_single_filter(e_TEST_STUB, 0) < 0) 539 return -1; 540 541 /* TEST - All packets passed through */ 542 table_entry_default_action = RTE_PIPELINE_ACTION_PORT; 543 setup_pipeline(e_TEST_STUB); 544 if (test_pipeline_single_filter(e_TEST_STUB, 4) < 0) 545 return -1; 546 547 /* TEST - one packet per port */ 548 action_handler_hit = NULL; 549 action_handler_miss = 550 (rte_pipeline_table_action_handler_miss) table_action_stub_miss; 551 table_entry_default_action = RTE_PIPELINE_ACTION_PORT; 552 override_miss_mask = 0x01; /* one packet per port */ 553 setup_pipeline(e_TEST_STUB); 554 if (test_pipeline_single_filter(e_TEST_STUB, 2) < 0) 555 return -1; 556 557 /* TEST - one packet per port */ 558 override_miss_mask = 0x02; /*all per port */ 559 setup_pipeline(e_TEST_STUB); 560 if (test_pipeline_single_filter(e_TEST_STUB, 2) < 0) 561 return -1; 562 563 /* TEST - all packets per port */ 564 override_miss_mask = 0x03; /*all per port */ 565 setup_pipeline(e_TEST_STUB); 566 if (test_pipeline_single_filter(e_TEST_STUB, 4) < 0) 567 return -1; 568 569 /* 570 * This test will set up two tables in the pipeline. the first table 571 * will forward to another table on miss, and the second table will 572 * forward to port. 573 */ 574 connect_miss_action_to_table = 1; 575 table_entry_default_action = RTE_PIPELINE_ACTION_TABLE; 576 action_handler_hit = NULL; /* not for stub, hitmask always zero */ 577 action_handler_miss = NULL; 578 setup_pipeline(e_TEST_STUB); 579 if (test_pipeline_single_filter(e_TEST_STUB, 4) < 0) 580 return -1; 581 connect_miss_action_to_table = 0; 582 583 printf("TEST - two tables, hitmask override to 0x01\n"); 584 connect_miss_action_to_table = 1; 585 action_handler_miss = 586 (rte_pipeline_table_action_handler_miss)table_action_stub_miss; 587 override_miss_mask = 0x01; 588 setup_pipeline(e_TEST_STUB); 589 if (test_pipeline_single_filter(e_TEST_STUB, 2) < 0) 590 return -1; 591 connect_miss_action_to_table = 0; 592 593 if (check_pipeline_invalid_params()) { 594 RTE_LOG(INFO, PIPELINE, "%s: Check pipeline invalid params " 595 "failed.\n", __func__); 596 return -1; 597 } 598 599 return 0; 600 } 601