1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright(c) 2010-2018 Intel Corporation 3 */ 4 5 #include <stdio.h> 6 #include <stdint.h> 7 #include <stdlib.h> 8 #include <string.h> 9 10 #include <rte_common.h> 11 #include <rte_cycles.h> 12 #include <rte_ethdev.h> 13 14 #include "cli.h" 15 16 #include "cryptodev.h" 17 #include "kni.h" 18 #include "link.h" 19 #include "mempool.h" 20 #include "parser.h" 21 #include "pipeline.h" 22 #include "swq.h" 23 #include "tap.h" 24 #include "thread.h" 25 #include "tmgr.h" 26 27 #ifndef CMD_MAX_TOKENS 28 #define CMD_MAX_TOKENS 256 29 #endif 30 31 #define MSG_OUT_OF_MEMORY "Not enough memory.\n" 32 #define MSG_CMD_UNKNOWN "Unknown command \"%s\".\n" 33 #define MSG_CMD_UNIMPLEM "Command \"%s\" not implemented.\n" 34 #define MSG_ARG_NOT_ENOUGH "Not enough arguments for command \"%s\".\n" 35 #define MSG_ARG_TOO_MANY "Too many arguments for command \"%s\".\n" 36 #define MSG_ARG_MISMATCH "Wrong number of arguments for command \"%s\".\n" 37 #define MSG_ARG_NOT_FOUND "Argument \"%s\" not found.\n" 38 #define MSG_ARG_INVALID "Invalid value for argument \"%s\".\n" 39 #define MSG_FILE_ERR "Error in file \"%s\" at line %u.\n" 40 #define MSG_FILE_NOT_ENOUGH "Not enough rules in file \"%s\".\n" 41 #define MSG_CMD_FAIL "Command \"%s\" failed.\n" 42 43 static int 44 is_comment(char *in) 45 { 46 if ((strlen(in) && index("!#%;", in[0])) || 47 (strncmp(in, "//", 2) == 0) || 48 (strncmp(in, "--", 2) == 0)) 49 return 1; 50 51 return 0; 52 } 53 54 static const char cmd_mempool_help[] = 55 "mempool <mempool_name>\n" 56 " buffer <buffer_size>\n" 57 " pool <pool_size>\n" 58 " cache <cache_size>\n" 59 " cpu <cpu_id>\n"; 60 61 static void 62 cmd_mempool(char **tokens, 63 uint32_t n_tokens, 64 char *out, 65 size_t out_size) 66 { 67 struct mempool_params p; 68 char *name; 69 struct mempool *mempool; 70 71 if (n_tokens != 10) { 72 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 73 return; 74 } 75 76 name = tokens[1]; 77 78 if (strcmp(tokens[2], "buffer") != 0) { 79 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "buffer"); 80 return; 81 } 82 83 if (parser_read_uint32(&p.buffer_size, tokens[3]) != 0) { 84 snprintf(out, out_size, MSG_ARG_INVALID, "buffer_size"); 85 return; 86 } 87 88 if (strcmp(tokens[4], "pool") != 0) { 89 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pool"); 90 return; 91 } 92 93 if (parser_read_uint32(&p.pool_size, tokens[5]) != 0) { 94 snprintf(out, out_size, MSG_ARG_INVALID, "pool_size"); 95 return; 96 } 97 98 if (strcmp(tokens[6], "cache") != 0) { 99 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cache"); 100 return; 101 } 102 103 if (parser_read_uint32(&p.cache_size, tokens[7]) != 0) { 104 snprintf(out, out_size, MSG_ARG_INVALID, "cache_size"); 105 return; 106 } 107 108 if (strcmp(tokens[8], "cpu") != 0) { 109 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cpu"); 110 return; 111 } 112 113 if (parser_read_uint32(&p.cpu_id, tokens[9]) != 0) { 114 snprintf(out, out_size, MSG_ARG_INVALID, "cpu_id"); 115 return; 116 } 117 118 mempool = mempool_create(name, &p); 119 if (mempool == NULL) { 120 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 121 return; 122 } 123 } 124 125 static const char cmd_link_help[] = 126 "link <link_name>\n" 127 " dev <device_name> | port <port_id>\n" 128 " rxq <n_queues> <queue_size> <mempool_name>\n" 129 " txq <n_queues> <queue_size>\n" 130 " promiscuous on | off\n" 131 " [rss <qid_0> ... <qid_n>]\n"; 132 133 static void 134 cmd_link(char **tokens, 135 uint32_t n_tokens, 136 char *out, 137 size_t out_size) 138 { 139 struct link_params p; 140 struct link_params_rss rss; 141 struct link *link; 142 char *name; 143 144 memset(&p, 0, sizeof(p)); 145 146 if ((n_tokens < 13) || (n_tokens > 14 + LINK_RXQ_RSS_MAX)) { 147 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 148 return; 149 } 150 name = tokens[1]; 151 152 if (strcmp(tokens[2], "dev") == 0) 153 p.dev_name = tokens[3]; 154 else if (strcmp(tokens[2], "port") == 0) { 155 p.dev_name = NULL; 156 157 if (parser_read_uint16(&p.port_id, tokens[3]) != 0) { 158 snprintf(out, out_size, MSG_ARG_INVALID, "port_id"); 159 return; 160 } 161 } else { 162 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "dev or port"); 163 return; 164 } 165 166 if (strcmp(tokens[4], "rxq") != 0) { 167 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rxq"); 168 return; 169 } 170 171 if (parser_read_uint32(&p.rx.n_queues, tokens[5]) != 0) { 172 snprintf(out, out_size, MSG_ARG_INVALID, "n_queues"); 173 return; 174 } 175 if (parser_read_uint32(&p.rx.queue_size, tokens[6]) != 0) { 176 snprintf(out, out_size, MSG_ARG_INVALID, "queue_size"); 177 return; 178 } 179 180 p.rx.mempool_name = tokens[7]; 181 182 if (strcmp(tokens[8], "txq") != 0) { 183 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "txq"); 184 return; 185 } 186 187 if (parser_read_uint32(&p.tx.n_queues, tokens[9]) != 0) { 188 snprintf(out, out_size, MSG_ARG_INVALID, "n_queues"); 189 return; 190 } 191 192 if (parser_read_uint32(&p.tx.queue_size, tokens[10]) != 0) { 193 snprintf(out, out_size, MSG_ARG_INVALID, "queue_size"); 194 return; 195 } 196 197 if (strcmp(tokens[11], "promiscuous") != 0) { 198 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "promiscuous"); 199 return; 200 } 201 202 if (strcmp(tokens[12], "on") == 0) 203 p.promiscuous = 1; 204 else if (strcmp(tokens[12], "off") == 0) 205 p.promiscuous = 0; 206 else { 207 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "on or off"); 208 return; 209 } 210 211 /* RSS */ 212 p.rx.rss = NULL; 213 if (n_tokens > 13) { 214 uint32_t queue_id, i; 215 216 if (strcmp(tokens[13], "rss") != 0) { 217 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rss"); 218 return; 219 } 220 221 p.rx.rss = &rss; 222 223 rss.n_queues = 0; 224 for (i = 14; i < n_tokens; i++) { 225 if (parser_read_uint32(&queue_id, tokens[i]) != 0) { 226 snprintf(out, out_size, MSG_ARG_INVALID, 227 "queue_id"); 228 return; 229 } 230 231 rss.queue_id[rss.n_queues] = queue_id; 232 rss.n_queues++; 233 } 234 } 235 236 link = link_create(name, &p); 237 if (link == NULL) { 238 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 239 return; 240 } 241 } 242 243 /* Print the link stats and info */ 244 static void 245 print_link_info(struct link *link, char *out, size_t out_size) 246 { 247 struct rte_eth_stats stats; 248 struct ether_addr mac_addr; 249 struct rte_eth_link eth_link; 250 uint16_t mtu; 251 252 memset(&stats, 0, sizeof(stats)); 253 rte_eth_stats_get(link->port_id, &stats); 254 255 rte_eth_macaddr_get(link->port_id, &mac_addr); 256 rte_eth_link_get(link->port_id, ð_link); 257 rte_eth_dev_get_mtu(link->port_id, &mtu); 258 259 snprintf(out, out_size, 260 "\n" 261 "%s: flags=<%s> mtu %u\n" 262 "\tether %02X:%02X:%02X:%02X:%02X:%02X rxqueues %u txqueues %u\n" 263 "\tport# %u speed %u Mbps\n" 264 "\tRX packets %" PRIu64" bytes %" PRIu64"\n" 265 "\tRX errors %" PRIu64" missed %" PRIu64" no-mbuf %" PRIu64"\n" 266 "\tTX packets %" PRIu64" bytes %" PRIu64"\n" 267 "\tTX errors %" PRIu64"\n", 268 link->name, 269 eth_link.link_status == 0 ? "DOWN" : "UP", 270 mtu, 271 mac_addr.addr_bytes[0], mac_addr.addr_bytes[1], 272 mac_addr.addr_bytes[2], mac_addr.addr_bytes[3], 273 mac_addr.addr_bytes[4], mac_addr.addr_bytes[5], 274 link->n_rxq, 275 link->n_txq, 276 link->port_id, 277 eth_link.link_speed, 278 stats.ipackets, 279 stats.ibytes, 280 stats.ierrors, 281 stats.imissed, 282 stats.rx_nombuf, 283 stats.opackets, 284 stats.obytes, 285 stats.oerrors); 286 } 287 288 /* 289 * link show [<link_name>] 290 */ 291 static void 292 cmd_link_show(char **tokens, uint32_t n_tokens, char *out, size_t out_size) 293 { 294 struct link *link; 295 char *link_name; 296 297 if (n_tokens != 2 && n_tokens != 3) { 298 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 299 return; 300 } 301 302 if (n_tokens == 2) { 303 link = link_next(NULL); 304 305 while (link != NULL) { 306 out_size = out_size - strlen(out); 307 out = &out[strlen(out)]; 308 309 print_link_info(link, out, out_size); 310 link = link_next(link); 311 } 312 } else { 313 out_size = out_size - strlen(out); 314 out = &out[strlen(out)]; 315 316 link_name = tokens[2]; 317 link = link_find(link_name); 318 319 if (link == NULL) { 320 snprintf(out, out_size, MSG_ARG_INVALID, 321 "Link does not exist"); 322 return; 323 } 324 print_link_info(link, out, out_size); 325 } 326 } 327 328 static const char cmd_swq_help[] = 329 "swq <swq_name>\n" 330 " size <size>\n" 331 " cpu <cpu_id>\n"; 332 333 static void 334 cmd_swq(char **tokens, 335 uint32_t n_tokens, 336 char *out, 337 size_t out_size) 338 { 339 struct swq_params p; 340 char *name; 341 struct swq *swq; 342 343 if (n_tokens != 6) { 344 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 345 return; 346 } 347 348 name = tokens[1]; 349 350 if (strcmp(tokens[2], "size") != 0) { 351 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size"); 352 return; 353 } 354 355 if (parser_read_uint32(&p.size, tokens[3]) != 0) { 356 snprintf(out, out_size, MSG_ARG_INVALID, "size"); 357 return; 358 } 359 360 if (strcmp(tokens[4], "cpu") != 0) { 361 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cpu"); 362 return; 363 } 364 365 if (parser_read_uint32(&p.cpu_id, tokens[5]) != 0) { 366 snprintf(out, out_size, MSG_ARG_INVALID, "cpu_id"); 367 return; 368 } 369 370 swq = swq_create(name, &p); 371 if (swq == NULL) { 372 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 373 return; 374 } 375 } 376 377 static const char cmd_tmgr_subport_profile_help[] = 378 "tmgr subport profile\n" 379 " <tb_rate> <tb_size>\n" 380 " <tc0_rate> <tc1_rate> <tc2_rate> <tc3_rate>\n" 381 " <tc_period>\n"; 382 383 static void 384 cmd_tmgr_subport_profile(char **tokens, 385 uint32_t n_tokens, 386 char *out, 387 size_t out_size) 388 { 389 struct rte_sched_subport_params p; 390 int status, i; 391 392 if (n_tokens != 10) { 393 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 394 return; 395 } 396 397 if (parser_read_uint32(&p.tb_rate, tokens[3]) != 0) { 398 snprintf(out, out_size, MSG_ARG_INVALID, "tb_rate"); 399 return; 400 } 401 402 if (parser_read_uint32(&p.tb_size, tokens[4]) != 0) { 403 snprintf(out, out_size, MSG_ARG_INVALID, "tb_size"); 404 return; 405 } 406 407 for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++) 408 if (parser_read_uint32(&p.tc_rate[i], tokens[5 + i]) != 0) { 409 snprintf(out, out_size, MSG_ARG_INVALID, "tc_rate"); 410 return; 411 } 412 413 if (parser_read_uint32(&p.tc_period, tokens[9]) != 0) { 414 snprintf(out, out_size, MSG_ARG_INVALID, "tc_period"); 415 return; 416 } 417 418 status = tmgr_subport_profile_add(&p); 419 if (status != 0) { 420 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 421 return; 422 } 423 } 424 425 static const char cmd_tmgr_pipe_profile_help[] = 426 "tmgr pipe profile\n" 427 " <tb_rate> <tb_size>\n" 428 " <tc0_rate> <tc1_rate> <tc2_rate> <tc3_rate>\n" 429 " <tc_period>\n" 430 " <tc_ov_weight>\n" 431 " <wrr_weight0..15>\n"; 432 433 static void 434 cmd_tmgr_pipe_profile(char **tokens, 435 uint32_t n_tokens, 436 char *out, 437 size_t out_size) 438 { 439 struct rte_sched_pipe_params p; 440 int status, i; 441 442 if (n_tokens != 27) { 443 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 444 return; 445 } 446 447 if (parser_read_uint32(&p.tb_rate, tokens[3]) != 0) { 448 snprintf(out, out_size, MSG_ARG_INVALID, "tb_rate"); 449 return; 450 } 451 452 if (parser_read_uint32(&p.tb_size, tokens[4]) != 0) { 453 snprintf(out, out_size, MSG_ARG_INVALID, "tb_size"); 454 return; 455 } 456 457 for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++) 458 if (parser_read_uint32(&p.tc_rate[i], tokens[5 + i]) != 0) { 459 snprintf(out, out_size, MSG_ARG_INVALID, "tc_rate"); 460 return; 461 } 462 463 if (parser_read_uint32(&p.tc_period, tokens[9]) != 0) { 464 snprintf(out, out_size, MSG_ARG_INVALID, "tc_period"); 465 return; 466 } 467 468 #ifdef RTE_SCHED_SUBPORT_TC_OV 469 if (parser_read_uint8(&p.tc_ov_weight, tokens[10]) != 0) { 470 snprintf(out, out_size, MSG_ARG_INVALID, "tc_ov_weight"); 471 return; 472 } 473 #endif 474 475 for (i = 0; i < RTE_SCHED_QUEUES_PER_PIPE; i++) 476 if (parser_read_uint8(&p.wrr_weights[i], tokens[11 + i]) != 0) { 477 snprintf(out, out_size, MSG_ARG_INVALID, "wrr_weights"); 478 return; 479 } 480 481 status = tmgr_pipe_profile_add(&p); 482 if (status != 0) { 483 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 484 return; 485 } 486 } 487 488 static const char cmd_tmgr_help[] = 489 "tmgr <tmgr_name>\n" 490 " rate <rate>\n" 491 " spp <n_subports_per_port>\n" 492 " pps <n_pipes_per_subport>\n" 493 " qsize <qsize_tc0> <qsize_tc1> <qsize_tc2> <qsize_tc3>\n" 494 " fo <frame_overhead>\n" 495 " mtu <mtu>\n" 496 " cpu <cpu_id>\n"; 497 498 static void 499 cmd_tmgr(char **tokens, 500 uint32_t n_tokens, 501 char *out, 502 size_t out_size) 503 { 504 struct tmgr_port_params p; 505 char *name; 506 struct tmgr_port *tmgr_port; 507 int i; 508 509 if (n_tokens != 19) { 510 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 511 return; 512 } 513 514 name = tokens[1]; 515 516 if (strcmp(tokens[2], "rate") != 0) { 517 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rate"); 518 return; 519 } 520 521 if (parser_read_uint32(&p.rate, tokens[3]) != 0) { 522 snprintf(out, out_size, MSG_ARG_INVALID, "rate"); 523 return; 524 } 525 526 if (strcmp(tokens[4], "spp") != 0) { 527 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "spp"); 528 return; 529 } 530 531 if (parser_read_uint32(&p.n_subports_per_port, tokens[5]) != 0) { 532 snprintf(out, out_size, MSG_ARG_INVALID, "n_subports_per_port"); 533 return; 534 } 535 536 if (strcmp(tokens[6], "pps") != 0) { 537 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pps"); 538 return; 539 } 540 541 if (parser_read_uint32(&p.n_pipes_per_subport, tokens[7]) != 0) { 542 snprintf(out, out_size, MSG_ARG_INVALID, "n_pipes_per_subport"); 543 return; 544 } 545 546 if (strcmp(tokens[8], "qsize") != 0) { 547 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "qsize"); 548 return; 549 } 550 551 for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++) 552 if (parser_read_uint16(&p.qsize[i], tokens[9 + i]) != 0) { 553 snprintf(out, out_size, MSG_ARG_INVALID, "qsize"); 554 return; 555 } 556 557 if (strcmp(tokens[13], "fo") != 0) { 558 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "fo"); 559 return; 560 } 561 562 if (parser_read_uint32(&p.frame_overhead, tokens[14]) != 0) { 563 snprintf(out, out_size, MSG_ARG_INVALID, "frame_overhead"); 564 return; 565 } 566 567 if (strcmp(tokens[15], "mtu") != 0) { 568 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mtu"); 569 return; 570 } 571 572 if (parser_read_uint32(&p.mtu, tokens[16]) != 0) { 573 snprintf(out, out_size, MSG_ARG_INVALID, "mtu"); 574 return; 575 } 576 577 if (strcmp(tokens[17], "cpu") != 0) { 578 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cpu"); 579 return; 580 } 581 582 if (parser_read_uint32(&p.cpu_id, tokens[18]) != 0) { 583 snprintf(out, out_size, MSG_ARG_INVALID, "cpu_id"); 584 return; 585 } 586 587 tmgr_port = tmgr_port_create(name, &p); 588 if (tmgr_port == NULL) { 589 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 590 return; 591 } 592 } 593 594 static const char cmd_tmgr_subport_help[] = 595 "tmgr <tmgr_name> subport <subport_id>\n" 596 " profile <subport_profile_id>\n"; 597 598 static void 599 cmd_tmgr_subport(char **tokens, 600 uint32_t n_tokens, 601 char *out, 602 size_t out_size) 603 { 604 uint32_t subport_id, subport_profile_id; 605 int status; 606 char *name; 607 608 if (n_tokens != 6) { 609 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 610 return; 611 } 612 613 name = tokens[1]; 614 615 if (parser_read_uint32(&subport_id, tokens[3]) != 0) { 616 snprintf(out, out_size, MSG_ARG_INVALID, "subport_id"); 617 return; 618 } 619 620 if (parser_read_uint32(&subport_profile_id, tokens[5]) != 0) { 621 snprintf(out, out_size, MSG_ARG_INVALID, "subport_profile_id"); 622 return; 623 } 624 625 status = tmgr_subport_config(name, subport_id, subport_profile_id); 626 if (status) { 627 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 628 return; 629 } 630 } 631 632 633 static const char cmd_tmgr_subport_pipe_help[] = 634 "tmgr <tmgr_name> subport <subport_id> pipe\n" 635 " from <pipe_id_first> to <pipe_id_last>\n" 636 " profile <pipe_profile_id>\n"; 637 638 static void 639 cmd_tmgr_subport_pipe(char **tokens, 640 uint32_t n_tokens, 641 char *out, 642 size_t out_size) 643 { 644 uint32_t subport_id, pipe_id_first, pipe_id_last, pipe_profile_id; 645 int status; 646 char *name; 647 648 if (n_tokens != 11) { 649 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 650 return; 651 } 652 653 name = tokens[1]; 654 655 if (parser_read_uint32(&subport_id, tokens[3]) != 0) { 656 snprintf(out, out_size, MSG_ARG_INVALID, "subport_id"); 657 return; 658 } 659 660 if (strcmp(tokens[4], "pipe") != 0) { 661 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pipe"); 662 return; 663 } 664 665 if (strcmp(tokens[5], "from") != 0) { 666 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "from"); 667 return; 668 } 669 670 if (parser_read_uint32(&pipe_id_first, tokens[6]) != 0) { 671 snprintf(out, out_size, MSG_ARG_INVALID, "pipe_id_first"); 672 return; 673 } 674 675 if (strcmp(tokens[7], "to") != 0) { 676 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "to"); 677 return; 678 } 679 680 if (parser_read_uint32(&pipe_id_last, tokens[8]) != 0) { 681 snprintf(out, out_size, MSG_ARG_INVALID, "pipe_id_last"); 682 return; 683 } 684 685 if (strcmp(tokens[9], "profile") != 0) { 686 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile"); 687 return; 688 } 689 690 if (parser_read_uint32(&pipe_profile_id, tokens[10]) != 0) { 691 snprintf(out, out_size, MSG_ARG_INVALID, "pipe_profile_id"); 692 return; 693 } 694 695 status = tmgr_pipe_config(name, subport_id, pipe_id_first, 696 pipe_id_last, pipe_profile_id); 697 if (status) { 698 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 699 return; 700 } 701 } 702 703 704 static const char cmd_tap_help[] = 705 "tap <tap_name>\n"; 706 707 static void 708 cmd_tap(char **tokens, 709 uint32_t n_tokens, 710 char *out, 711 size_t out_size) 712 { 713 char *name; 714 struct tap *tap; 715 716 if (n_tokens != 2) { 717 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 718 return; 719 } 720 721 name = tokens[1]; 722 723 tap = tap_create(name); 724 if (tap == NULL) { 725 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 726 return; 727 } 728 } 729 730 static const char cmd_kni_help[] = 731 "kni <kni_name>\n" 732 " link <link_name>\n" 733 " mempool <mempool_name>\n" 734 " [thread <thread_id>]\n"; 735 736 static void 737 cmd_kni(char **tokens, 738 uint32_t n_tokens, 739 char *out, 740 size_t out_size) 741 { 742 struct kni_params p; 743 char *name; 744 struct kni *kni; 745 746 memset(&p, 0, sizeof(p)); 747 if ((n_tokens != 6) && (n_tokens != 8)) { 748 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 749 return; 750 } 751 752 name = tokens[1]; 753 754 if (strcmp(tokens[2], "link") != 0) { 755 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "link"); 756 return; 757 } 758 759 p.link_name = tokens[3]; 760 761 if (strcmp(tokens[4], "mempool") != 0) { 762 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mempool"); 763 return; 764 } 765 766 p.mempool_name = tokens[5]; 767 768 if (n_tokens == 8) { 769 if (strcmp(tokens[6], "thread") != 0) { 770 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "thread"); 771 return; 772 } 773 774 if (parser_read_uint32(&p.thread_id, tokens[7]) != 0) { 775 snprintf(out, out_size, MSG_ARG_INVALID, "thread_id"); 776 return; 777 } 778 779 p.force_bind = 1; 780 } else 781 p.force_bind = 0; 782 783 kni = kni_create(name, &p); 784 if (kni == NULL) { 785 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 786 return; 787 } 788 } 789 790 static const char cmd_cryptodev_help[] = 791 "cryptodev <cryptodev_name>\n" 792 " dev <device_name> | dev_id <device_id>\n" 793 " queue <n_queues> <queue_size>\n"; 794 795 static void 796 cmd_cryptodev(char **tokens, 797 uint32_t n_tokens, 798 char *out, 799 size_t out_size) 800 { 801 struct cryptodev_params params; 802 char *name; 803 804 memset(¶ms, 0, sizeof(params)); 805 if (n_tokens != 7) { 806 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 807 return; 808 } 809 810 name = tokens[1]; 811 812 if (strcmp(tokens[2], "dev") == 0) 813 params.dev_name = tokens[3]; 814 else if (strcmp(tokens[2], "dev_id") == 0) { 815 if (parser_read_uint32(¶ms.dev_id, tokens[3]) < 0) { 816 snprintf(out, out_size, MSG_ARG_INVALID, 817 "dev_id"); 818 return; 819 } 820 } else { 821 snprintf(out, out_size, MSG_ARG_INVALID, 822 "cryptodev"); 823 return; 824 } 825 826 if (strcmp(tokens[4], "queue")) { 827 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 828 "4"); 829 return; 830 } 831 832 if (parser_read_uint32(¶ms.n_queues, tokens[5]) < 0) { 833 snprintf(out, out_size, MSG_ARG_INVALID, 834 "q"); 835 return; 836 } 837 838 if (parser_read_uint32(¶ms.queue_size, tokens[6]) < 0) { 839 snprintf(out, out_size, MSG_ARG_INVALID, 840 "queue_size"); 841 return; 842 } 843 844 if (cryptodev_create(name, ¶ms) == NULL) { 845 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 846 return; 847 } 848 } 849 850 static const char cmd_port_in_action_profile_help[] = 851 "port in action profile <profile_name>\n" 852 " [filter match | mismatch offset <key_offset> mask <key_mask> key <key_value> port <port_id>]\n" 853 " [balance offset <key_offset> mask <key_mask> port <port_id0> ... <port_id15>]\n"; 854 855 static void 856 cmd_port_in_action_profile(char **tokens, 857 uint32_t n_tokens, 858 char *out, 859 size_t out_size) 860 { 861 struct port_in_action_profile_params p; 862 struct port_in_action_profile *ap; 863 char *name; 864 uint32_t t0; 865 866 memset(&p, 0, sizeof(p)); 867 868 if (n_tokens < 5) { 869 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 870 return; 871 } 872 873 if (strcmp(tokens[1], "in") != 0) { 874 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in"); 875 return; 876 } 877 878 if (strcmp(tokens[2], "action") != 0) { 879 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "action"); 880 return; 881 } 882 883 if (strcmp(tokens[3], "profile") != 0) { 884 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile"); 885 return; 886 } 887 888 name = tokens[4]; 889 890 t0 = 5; 891 892 if ((t0 < n_tokens) && (strcmp(tokens[t0], "filter") == 0)) { 893 uint32_t size; 894 895 if (n_tokens < t0 + 10) { 896 snprintf(out, out_size, MSG_ARG_MISMATCH, "port in action profile filter"); 897 return; 898 } 899 900 if (strcmp(tokens[t0 + 1], "match") == 0) 901 p.fltr.filter_on_match = 1; 902 else if (strcmp(tokens[t0 + 1], "mismatch") == 0) 903 p.fltr.filter_on_match = 0; 904 else { 905 snprintf(out, out_size, MSG_ARG_INVALID, "match or mismatch"); 906 return; 907 } 908 909 if (strcmp(tokens[t0 + 2], "offset") != 0) { 910 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset"); 911 return; 912 } 913 914 if (parser_read_uint32(&p.fltr.key_offset, tokens[t0 + 3]) != 0) { 915 snprintf(out, out_size, MSG_ARG_INVALID, "key_offset"); 916 return; 917 } 918 919 if (strcmp(tokens[t0 + 4], "mask") != 0) { 920 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mask"); 921 return; 922 } 923 924 size = RTE_PORT_IN_ACTION_FLTR_KEY_SIZE; 925 if ((parse_hex_string(tokens[t0 + 5], p.fltr.key_mask, &size) != 0) || 926 (size != RTE_PORT_IN_ACTION_FLTR_KEY_SIZE)) { 927 snprintf(out, out_size, MSG_ARG_INVALID, "key_mask"); 928 return; 929 } 930 931 if (strcmp(tokens[t0 + 6], "key") != 0) { 932 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "key"); 933 return; 934 } 935 936 size = RTE_PORT_IN_ACTION_FLTR_KEY_SIZE; 937 if ((parse_hex_string(tokens[t0 + 7], p.fltr.key, &size) != 0) || 938 (size != RTE_PORT_IN_ACTION_FLTR_KEY_SIZE)) { 939 snprintf(out, out_size, MSG_ARG_INVALID, "key_value"); 940 return; 941 } 942 943 if (strcmp(tokens[t0 + 8], "port") != 0) { 944 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port"); 945 return; 946 } 947 948 if (parser_read_uint32(&p.fltr.port_id, tokens[t0 + 9]) != 0) { 949 snprintf(out, out_size, MSG_ARG_INVALID, "port_id"); 950 return; 951 } 952 953 p.action_mask |= 1LLU << RTE_PORT_IN_ACTION_FLTR; 954 t0 += 10; 955 } /* filter */ 956 957 if ((t0 < n_tokens) && (strcmp(tokens[t0], "balance") == 0)) { 958 uint32_t i; 959 960 if (n_tokens < t0 + 22) { 961 snprintf(out, out_size, MSG_ARG_MISMATCH, 962 "port in action profile balance"); 963 return; 964 } 965 966 if (strcmp(tokens[t0 + 1], "offset") != 0) { 967 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset"); 968 return; 969 } 970 971 if (parser_read_uint32(&p.lb.key_offset, tokens[t0 + 2]) != 0) { 972 snprintf(out, out_size, MSG_ARG_INVALID, "key_offset"); 973 return; 974 } 975 976 if (strcmp(tokens[t0 + 3], "mask") != 0) { 977 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mask"); 978 return; 979 } 980 981 p.lb.key_size = RTE_PORT_IN_ACTION_LB_KEY_SIZE_MAX; 982 if (parse_hex_string(tokens[t0 + 4], p.lb.key_mask, &p.lb.key_size) != 0) { 983 snprintf(out, out_size, MSG_ARG_INVALID, "key_mask"); 984 return; 985 } 986 987 if (strcmp(tokens[t0 + 5], "port") != 0) { 988 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port"); 989 return; 990 } 991 992 for (i = 0; i < 16; i++) 993 if (parser_read_uint32(&p.lb.port_id[i], tokens[t0 + 6 + i]) != 0) { 994 snprintf(out, out_size, MSG_ARG_INVALID, "port_id"); 995 return; 996 } 997 998 p.action_mask |= 1LLU << RTE_PORT_IN_ACTION_LB; 999 t0 += 22; 1000 } /* balance */ 1001 1002 if (t0 < n_tokens) { 1003 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 1004 return; 1005 } 1006 1007 ap = port_in_action_profile_create(name, &p); 1008 if (ap == NULL) { 1009 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 1010 return; 1011 } 1012 } 1013 1014 1015 static const char cmd_table_action_profile_help[] = 1016 "table action profile <profile_name>\n" 1017 " ipv4 | ipv6\n" 1018 " offset <ip_offset>\n" 1019 " fwd\n" 1020 " [balance offset <key_offset> mask <key_mask> outoffset <out_offset>]\n" 1021 " [meter srtcm | trtcm\n" 1022 " tc <n_tc>\n" 1023 " stats none | pkts | bytes | both]\n" 1024 " [tm spp <n_subports_per_port> pps <n_pipes_per_subport>]\n" 1025 " [encap ether | vlan | qinq | mpls | pppoe |\n" 1026 " vxlan offset <ether_offset> ipv4 | ipv6 vlan on | off]\n" 1027 " [nat src | dst\n" 1028 " proto udp | tcp]\n" 1029 " [ttl drop | fwd\n" 1030 " stats none | pkts]\n" 1031 " [stats pkts | bytes | both]\n" 1032 " [time]\n" 1033 " [sym_crypto dev <CRYPTODEV_NAME> offset <op_offset> " 1034 " mempool_create <mempool_name>\n" 1035 " mempool_init <mempool_name>]\n" 1036 " [tag]\n" 1037 " [decap]\n"; 1038 1039 static void 1040 cmd_table_action_profile(char **tokens, 1041 uint32_t n_tokens, 1042 char *out, 1043 size_t out_size) 1044 { 1045 struct table_action_profile_params p; 1046 struct table_action_profile *ap; 1047 char *name; 1048 uint32_t t0; 1049 1050 memset(&p, 0, sizeof(p)); 1051 1052 if (n_tokens < 8) { 1053 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 1054 return; 1055 } 1056 1057 if (strcmp(tokens[1], "action") != 0) { 1058 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "action"); 1059 return; 1060 } 1061 1062 if (strcmp(tokens[2], "profile") != 0) { 1063 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile"); 1064 return; 1065 } 1066 1067 name = tokens[3]; 1068 1069 if (strcmp(tokens[4], "ipv4") == 0) 1070 p.common.ip_version = 1; 1071 else if (strcmp(tokens[4], "ipv6") == 0) 1072 p.common.ip_version = 0; 1073 else { 1074 snprintf(out, out_size, MSG_ARG_INVALID, "ipv4 or ipv6"); 1075 return; 1076 } 1077 1078 if (strcmp(tokens[5], "offset") != 0) { 1079 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset"); 1080 return; 1081 } 1082 1083 if (parser_read_uint32(&p.common.ip_offset, tokens[6]) != 0) { 1084 snprintf(out, out_size, MSG_ARG_INVALID, "ip_offset"); 1085 return; 1086 } 1087 1088 if (strcmp(tokens[7], "fwd") != 0) { 1089 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "fwd"); 1090 return; 1091 } 1092 1093 p.action_mask |= 1LLU << RTE_TABLE_ACTION_FWD; 1094 1095 t0 = 8; 1096 if ((t0 < n_tokens) && (strcmp(tokens[t0], "balance") == 0)) { 1097 if (n_tokens < t0 + 7) { 1098 snprintf(out, out_size, MSG_ARG_MISMATCH, "table action profile balance"); 1099 return; 1100 } 1101 1102 if (strcmp(tokens[t0 + 1], "offset") != 0) { 1103 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset"); 1104 return; 1105 } 1106 1107 if (parser_read_uint32(&p.lb.key_offset, tokens[t0 + 2]) != 0) { 1108 snprintf(out, out_size, MSG_ARG_INVALID, "key_offset"); 1109 return; 1110 } 1111 1112 if (strcmp(tokens[t0 + 3], "mask") != 0) { 1113 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mask"); 1114 return; 1115 } 1116 1117 p.lb.key_size = RTE_PORT_IN_ACTION_LB_KEY_SIZE_MAX; 1118 if (parse_hex_string(tokens[t0 + 4], p.lb.key_mask, &p.lb.key_size) != 0) { 1119 snprintf(out, out_size, MSG_ARG_INVALID, "key_mask"); 1120 return; 1121 } 1122 1123 if (strcmp(tokens[t0 + 5], "outoffset") != 0) { 1124 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "outoffset"); 1125 return; 1126 } 1127 1128 if (parser_read_uint32(&p.lb.out_offset, tokens[t0 + 6]) != 0) { 1129 snprintf(out, out_size, MSG_ARG_INVALID, "out_offset"); 1130 return; 1131 } 1132 1133 p.action_mask |= 1LLU << RTE_TABLE_ACTION_LB; 1134 t0 += 7; 1135 } /* balance */ 1136 1137 if ((t0 < n_tokens) && (strcmp(tokens[t0], "meter") == 0)) { 1138 if (n_tokens < t0 + 6) { 1139 snprintf(out, out_size, MSG_ARG_MISMATCH, 1140 "table action profile meter"); 1141 return; 1142 } 1143 1144 if (strcmp(tokens[t0 + 1], "srtcm") == 0) 1145 p.mtr.alg = RTE_TABLE_ACTION_METER_SRTCM; 1146 else if (strcmp(tokens[t0 + 1], "trtcm") == 0) 1147 p.mtr.alg = RTE_TABLE_ACTION_METER_TRTCM; 1148 else { 1149 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1150 "srtcm or trtcm"); 1151 return; 1152 } 1153 1154 if (strcmp(tokens[t0 + 2], "tc") != 0) { 1155 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "tc"); 1156 return; 1157 } 1158 1159 if (parser_read_uint32(&p.mtr.n_tc, tokens[t0 + 3]) != 0) { 1160 snprintf(out, out_size, MSG_ARG_INVALID, "n_tc"); 1161 return; 1162 } 1163 1164 if (strcmp(tokens[t0 + 4], "stats") != 0) { 1165 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats"); 1166 return; 1167 } 1168 1169 if (strcmp(tokens[t0 + 5], "none") == 0) { 1170 p.mtr.n_packets_enabled = 0; 1171 p.mtr.n_bytes_enabled = 0; 1172 } else if (strcmp(tokens[t0 + 5], "pkts") == 0) { 1173 p.mtr.n_packets_enabled = 1; 1174 p.mtr.n_bytes_enabled = 0; 1175 } else if (strcmp(tokens[t0 + 5], "bytes") == 0) { 1176 p.mtr.n_packets_enabled = 0; 1177 p.mtr.n_bytes_enabled = 1; 1178 } else if (strcmp(tokens[t0 + 5], "both") == 0) { 1179 p.mtr.n_packets_enabled = 1; 1180 p.mtr.n_bytes_enabled = 1; 1181 } else { 1182 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1183 "none or pkts or bytes or both"); 1184 return; 1185 } 1186 1187 p.action_mask |= 1LLU << RTE_TABLE_ACTION_MTR; 1188 t0 += 6; 1189 } /* meter */ 1190 1191 if ((t0 < n_tokens) && (strcmp(tokens[t0], "tm") == 0)) { 1192 if (n_tokens < t0 + 5) { 1193 snprintf(out, out_size, MSG_ARG_MISMATCH, 1194 "table action profile tm"); 1195 return; 1196 } 1197 1198 if (strcmp(tokens[t0 + 1], "spp") != 0) { 1199 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "spp"); 1200 return; 1201 } 1202 1203 if (parser_read_uint32(&p.tm.n_subports_per_port, 1204 tokens[t0 + 2]) != 0) { 1205 snprintf(out, out_size, MSG_ARG_INVALID, 1206 "n_subports_per_port"); 1207 return; 1208 } 1209 1210 if (strcmp(tokens[t0 + 3], "pps") != 0) { 1211 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pps"); 1212 return; 1213 } 1214 1215 if (parser_read_uint32(&p.tm.n_pipes_per_subport, 1216 tokens[t0 + 4]) != 0) { 1217 snprintf(out, out_size, MSG_ARG_INVALID, 1218 "n_pipes_per_subport"); 1219 return; 1220 } 1221 1222 p.action_mask |= 1LLU << RTE_TABLE_ACTION_TM; 1223 t0 += 5; 1224 } /* tm */ 1225 1226 if ((t0 < n_tokens) && (strcmp(tokens[t0], "encap") == 0)) { 1227 uint32_t n_extra_tokens = 0; 1228 1229 if (n_tokens < t0 + 2) { 1230 snprintf(out, out_size, MSG_ARG_MISMATCH, 1231 "action profile encap"); 1232 return; 1233 } 1234 1235 if (strcmp(tokens[t0 + 1], "ether") == 0) 1236 p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_ETHER; 1237 else if (strcmp(tokens[t0 + 1], "vlan") == 0) 1238 p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_VLAN; 1239 else if (strcmp(tokens[t0 + 1], "qinq") == 0) 1240 p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_QINQ; 1241 else if (strcmp(tokens[t0 + 1], "mpls") == 0) 1242 p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_MPLS; 1243 else if (strcmp(tokens[t0 + 1], "pppoe") == 0) 1244 p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_PPPOE; 1245 else if (strcmp(tokens[t0 + 1], "vxlan") == 0) { 1246 if (n_tokens < t0 + 2 + 5) { 1247 snprintf(out, out_size, MSG_ARG_MISMATCH, 1248 "action profile encap vxlan"); 1249 return; 1250 } 1251 1252 if (strcmp(tokens[t0 + 2], "offset") != 0) { 1253 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1254 "vxlan: offset"); 1255 return; 1256 } 1257 1258 if (parser_read_uint32(&p.encap.vxlan.data_offset, 1259 tokens[t0 + 2 + 1]) != 0) { 1260 snprintf(out, out_size, MSG_ARG_INVALID, 1261 "vxlan: ether_offset"); 1262 return; 1263 } 1264 1265 if (strcmp(tokens[t0 + 2 + 2], "ipv4") == 0) 1266 p.encap.vxlan.ip_version = 1; 1267 else if (strcmp(tokens[t0 + 2 + 2], "ipv6") == 0) 1268 p.encap.vxlan.ip_version = 0; 1269 else { 1270 snprintf(out, out_size, MSG_ARG_INVALID, 1271 "vxlan: ipv4 or ipv6"); 1272 return; 1273 } 1274 1275 if (strcmp(tokens[t0 + 2 + 3], "vlan") != 0) { 1276 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1277 "vxlan: vlan"); 1278 return; 1279 } 1280 1281 if (strcmp(tokens[t0 + 2 + 4], "on") == 0) 1282 p.encap.vxlan.vlan = 1; 1283 else if (strcmp(tokens[t0 + 2 + 4], "off") == 0) 1284 p.encap.vxlan.vlan = 0; 1285 else { 1286 snprintf(out, out_size, MSG_ARG_INVALID, 1287 "vxlan: on or off"); 1288 return; 1289 } 1290 1291 p.encap.encap_mask = 1LLU << RTE_TABLE_ACTION_ENCAP_VXLAN; 1292 n_extra_tokens = 5; 1293 } else { 1294 snprintf(out, out_size, MSG_ARG_MISMATCH, "encap"); 1295 return; 1296 } 1297 1298 p.action_mask |= 1LLU << RTE_TABLE_ACTION_ENCAP; 1299 t0 += 2 + n_extra_tokens; 1300 } /* encap */ 1301 1302 if ((t0 < n_tokens) && (strcmp(tokens[t0], "nat") == 0)) { 1303 if (n_tokens < t0 + 4) { 1304 snprintf(out, out_size, MSG_ARG_MISMATCH, 1305 "table action profile nat"); 1306 return; 1307 } 1308 1309 if (strcmp(tokens[t0 + 1], "src") == 0) 1310 p.nat.source_nat = 1; 1311 else if (strcmp(tokens[t0 + 1], "dst") == 0) 1312 p.nat.source_nat = 0; 1313 else { 1314 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1315 "src or dst"); 1316 return; 1317 } 1318 1319 if (strcmp(tokens[t0 + 2], "proto") != 0) { 1320 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "proto"); 1321 return; 1322 } 1323 1324 if (strcmp(tokens[t0 + 3], "tcp") == 0) 1325 p.nat.proto = 0x06; 1326 else if (strcmp(tokens[t0 + 3], "udp") == 0) 1327 p.nat.proto = 0x11; 1328 else { 1329 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1330 "tcp or udp"); 1331 return; 1332 } 1333 1334 p.action_mask |= 1LLU << RTE_TABLE_ACTION_NAT; 1335 t0 += 4; 1336 } /* nat */ 1337 1338 if ((t0 < n_tokens) && (strcmp(tokens[t0], "ttl") == 0)) { 1339 if (n_tokens < t0 + 4) { 1340 snprintf(out, out_size, MSG_ARG_MISMATCH, 1341 "table action profile ttl"); 1342 return; 1343 } 1344 1345 if (strcmp(tokens[t0 + 1], "drop") == 0) 1346 p.ttl.drop = 1; 1347 else if (strcmp(tokens[t0 + 1], "fwd") == 0) 1348 p.ttl.drop = 0; 1349 else { 1350 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1351 "drop or fwd"); 1352 return; 1353 } 1354 1355 if (strcmp(tokens[t0 + 2], "stats") != 0) { 1356 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats"); 1357 return; 1358 } 1359 1360 if (strcmp(tokens[t0 + 3], "none") == 0) 1361 p.ttl.n_packets_enabled = 0; 1362 else if (strcmp(tokens[t0 + 3], "pkts") == 0) 1363 p.ttl.n_packets_enabled = 1; 1364 else { 1365 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1366 "none or pkts"); 1367 return; 1368 } 1369 1370 p.action_mask |= 1LLU << RTE_TABLE_ACTION_TTL; 1371 t0 += 4; 1372 } /* ttl */ 1373 1374 if ((t0 < n_tokens) && (strcmp(tokens[t0], "stats") == 0)) { 1375 if (n_tokens < t0 + 2) { 1376 snprintf(out, out_size, MSG_ARG_MISMATCH, 1377 "table action profile stats"); 1378 return; 1379 } 1380 1381 if (strcmp(tokens[t0 + 1], "pkts") == 0) { 1382 p.stats.n_packets_enabled = 1; 1383 p.stats.n_bytes_enabled = 0; 1384 } else if (strcmp(tokens[t0 + 1], "bytes") == 0) { 1385 p.stats.n_packets_enabled = 0; 1386 p.stats.n_bytes_enabled = 1; 1387 } else if (strcmp(tokens[t0 + 1], "both") == 0) { 1388 p.stats.n_packets_enabled = 1; 1389 p.stats.n_bytes_enabled = 1; 1390 } else { 1391 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1392 "pkts or bytes or both"); 1393 return; 1394 } 1395 1396 p.action_mask |= 1LLU << RTE_TABLE_ACTION_STATS; 1397 t0 += 2; 1398 } /* stats */ 1399 1400 if ((t0 < n_tokens) && (strcmp(tokens[t0], "time") == 0)) { 1401 p.action_mask |= 1LLU << RTE_TABLE_ACTION_TIME; 1402 t0 += 1; 1403 } /* time */ 1404 1405 if ((t0 < n_tokens) && (strcmp(tokens[t0], "sym_crypto") == 0)) { 1406 struct cryptodev *cryptodev; 1407 struct mempool *mempool; 1408 1409 if (n_tokens < t0 + 9 || 1410 strcmp(tokens[t0 + 1], "dev") || 1411 strcmp(tokens[t0 + 3], "offset") || 1412 strcmp(tokens[t0 + 5], "mempool_create") || 1413 strcmp(tokens[t0 + 7], "mempool_init")) { 1414 snprintf(out, out_size, MSG_ARG_MISMATCH, 1415 "table action profile sym_crypto"); 1416 return; 1417 } 1418 1419 cryptodev = cryptodev_find(tokens[t0 + 2]); 1420 if (cryptodev == NULL) { 1421 snprintf(out, out_size, MSG_ARG_INVALID, 1422 "table action profile sym_crypto"); 1423 return; 1424 } 1425 1426 p.sym_crypto.cryptodev_id = cryptodev->dev_id; 1427 1428 if (parser_read_uint32(&p.sym_crypto.op_offset, 1429 tokens[t0 + 4]) != 0) { 1430 snprintf(out, out_size, MSG_ARG_INVALID, 1431 "table action profile sym_crypto"); 1432 return; 1433 } 1434 1435 mempool = mempool_find(tokens[t0 + 6]); 1436 if (mempool == NULL) { 1437 snprintf(out, out_size, MSG_ARG_INVALID, 1438 "table action profile sym_crypto"); 1439 return; 1440 } 1441 p.sym_crypto.mp_create = mempool->m; 1442 1443 mempool = mempool_find(tokens[t0 + 8]); 1444 if (mempool == NULL) { 1445 snprintf(out, out_size, MSG_ARG_INVALID, 1446 "table action profile sym_crypto"); 1447 return; 1448 } 1449 p.sym_crypto.mp_init = mempool->m; 1450 1451 p.action_mask |= 1LLU << RTE_TABLE_ACTION_SYM_CRYPTO; 1452 1453 t0 += 9; 1454 } /* sym_crypto */ 1455 1456 if ((t0 < n_tokens) && (strcmp(tokens[t0], "tag") == 0)) { 1457 p.action_mask |= 1LLU << RTE_TABLE_ACTION_TAG; 1458 t0 += 1; 1459 } /* tag */ 1460 1461 if ((t0 < n_tokens) && (strcmp(tokens[t0], "decap") == 0)) { 1462 p.action_mask |= 1LLU << RTE_TABLE_ACTION_DECAP; 1463 t0 += 1; 1464 } /* decap */ 1465 1466 if (t0 < n_tokens) { 1467 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 1468 return; 1469 } 1470 1471 ap = table_action_profile_create(name, &p); 1472 if (ap == NULL) { 1473 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 1474 return; 1475 } 1476 } 1477 1478 static const char cmd_pipeline_help[] = 1479 "pipeline <pipeline_name>\n" 1480 " period <timer_period_ms>\n" 1481 " offset_port_id <offset_port_id>\n" 1482 " cpu <cpu_id>\n"; 1483 1484 static void 1485 cmd_pipeline(char **tokens, 1486 uint32_t n_tokens, 1487 char *out, 1488 size_t out_size) 1489 { 1490 struct pipeline_params p; 1491 char *name; 1492 struct pipeline *pipeline; 1493 1494 if (n_tokens != 8) { 1495 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 1496 return; 1497 } 1498 1499 name = tokens[1]; 1500 1501 if (strcmp(tokens[2], "period") != 0) { 1502 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "period"); 1503 return; 1504 } 1505 1506 if (parser_read_uint32(&p.timer_period_ms, tokens[3]) != 0) { 1507 snprintf(out, out_size, MSG_ARG_INVALID, "timer_period_ms"); 1508 return; 1509 } 1510 1511 if (strcmp(tokens[4], "offset_port_id") != 0) { 1512 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset_port_id"); 1513 return; 1514 } 1515 1516 if (parser_read_uint32(&p.offset_port_id, tokens[5]) != 0) { 1517 snprintf(out, out_size, MSG_ARG_INVALID, "offset_port_id"); 1518 return; 1519 } 1520 1521 if (strcmp(tokens[6], "cpu") != 0) { 1522 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cpu"); 1523 return; 1524 } 1525 1526 if (parser_read_uint32(&p.cpu_id, tokens[7]) != 0) { 1527 snprintf(out, out_size, MSG_ARG_INVALID, "cpu_id"); 1528 return; 1529 } 1530 1531 pipeline = pipeline_create(name, &p); 1532 if (pipeline == NULL) { 1533 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 1534 return; 1535 } 1536 } 1537 1538 static const char cmd_pipeline_port_in_help[] = 1539 "pipeline <pipeline_name> port in\n" 1540 " bsz <burst_size>\n" 1541 " link <link_name> rxq <queue_id>\n" 1542 " | swq <swq_name>\n" 1543 " | tmgr <tmgr_name>\n" 1544 " | tap <tap_name> mempool <mempool_name> mtu <mtu>\n" 1545 " | kni <kni_name>\n" 1546 " | source mempool <mempool_name> file <file_name> bpp <n_bytes_per_pkt>\n" 1547 " | cryptodev <cryptodev_name> rxq <queue_id>\n" 1548 " [action <port_in_action_profile_name>]\n" 1549 " [disabled]\n"; 1550 1551 static void 1552 cmd_pipeline_port_in(char **tokens, 1553 uint32_t n_tokens, 1554 char *out, 1555 size_t out_size) 1556 { 1557 struct port_in_params p; 1558 char *pipeline_name; 1559 uint32_t t0; 1560 int enabled, status; 1561 1562 if (n_tokens < 7) { 1563 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 1564 return; 1565 } 1566 1567 pipeline_name = tokens[1]; 1568 1569 if (strcmp(tokens[2], "port") != 0) { 1570 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port"); 1571 return; 1572 } 1573 1574 if (strcmp(tokens[3], "in") != 0) { 1575 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in"); 1576 return; 1577 } 1578 1579 if (strcmp(tokens[4], "bsz") != 0) { 1580 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "bsz"); 1581 return; 1582 } 1583 1584 if (parser_read_uint32(&p.burst_size, tokens[5]) != 0) { 1585 snprintf(out, out_size, MSG_ARG_INVALID, "burst_size"); 1586 return; 1587 } 1588 1589 t0 = 6; 1590 1591 if (strcmp(tokens[t0], "link") == 0) { 1592 if (n_tokens < t0 + 4) { 1593 snprintf(out, out_size, MSG_ARG_MISMATCH, 1594 "pipeline port in link"); 1595 return; 1596 } 1597 1598 p.type = PORT_IN_RXQ; 1599 1600 p.dev_name = tokens[t0 + 1]; 1601 1602 if (strcmp(tokens[t0 + 2], "rxq") != 0) { 1603 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rxq"); 1604 return; 1605 } 1606 1607 if (parser_read_uint16(&p.rxq.queue_id, tokens[t0 + 3]) != 0) { 1608 snprintf(out, out_size, MSG_ARG_INVALID, 1609 "queue_id"); 1610 return; 1611 } 1612 t0 += 4; 1613 } else if (strcmp(tokens[t0], "swq") == 0) { 1614 if (n_tokens < t0 + 2) { 1615 snprintf(out, out_size, MSG_ARG_MISMATCH, 1616 "pipeline port in swq"); 1617 return; 1618 } 1619 1620 p.type = PORT_IN_SWQ; 1621 1622 p.dev_name = tokens[t0 + 1]; 1623 1624 t0 += 2; 1625 } else if (strcmp(tokens[t0], "tmgr") == 0) { 1626 if (n_tokens < t0 + 2) { 1627 snprintf(out, out_size, MSG_ARG_MISMATCH, 1628 "pipeline port in tmgr"); 1629 return; 1630 } 1631 1632 p.type = PORT_IN_TMGR; 1633 1634 p.dev_name = tokens[t0 + 1]; 1635 1636 t0 += 2; 1637 } else if (strcmp(tokens[t0], "tap") == 0) { 1638 if (n_tokens < t0 + 6) { 1639 snprintf(out, out_size, MSG_ARG_MISMATCH, 1640 "pipeline port in tap"); 1641 return; 1642 } 1643 1644 p.type = PORT_IN_TAP; 1645 1646 p.dev_name = tokens[t0 + 1]; 1647 1648 if (strcmp(tokens[t0 + 2], "mempool") != 0) { 1649 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1650 "mempool"); 1651 return; 1652 } 1653 1654 p.tap.mempool_name = tokens[t0 + 3]; 1655 1656 if (strcmp(tokens[t0 + 4], "mtu") != 0) { 1657 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1658 "mtu"); 1659 return; 1660 } 1661 1662 if (parser_read_uint32(&p.tap.mtu, tokens[t0 + 5]) != 0) { 1663 snprintf(out, out_size, MSG_ARG_INVALID, "mtu"); 1664 return; 1665 } 1666 1667 t0 += 6; 1668 } else if (strcmp(tokens[t0], "kni") == 0) { 1669 if (n_tokens < t0 + 2) { 1670 snprintf(out, out_size, MSG_ARG_MISMATCH, 1671 "pipeline port in kni"); 1672 return; 1673 } 1674 1675 p.type = PORT_IN_KNI; 1676 1677 p.dev_name = tokens[t0 + 1]; 1678 1679 t0 += 2; 1680 } else if (strcmp(tokens[t0], "source") == 0) { 1681 if (n_tokens < t0 + 6) { 1682 snprintf(out, out_size, MSG_ARG_MISMATCH, 1683 "pipeline port in source"); 1684 return; 1685 } 1686 1687 p.type = PORT_IN_SOURCE; 1688 1689 p.dev_name = NULL; 1690 1691 if (strcmp(tokens[t0 + 1], "mempool") != 0) { 1692 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1693 "mempool"); 1694 return; 1695 } 1696 1697 p.source.mempool_name = tokens[t0 + 2]; 1698 1699 if (strcmp(tokens[t0 + 3], "file") != 0) { 1700 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1701 "file"); 1702 return; 1703 } 1704 1705 p.source.file_name = tokens[t0 + 4]; 1706 1707 if (strcmp(tokens[t0 + 5], "bpp") != 0) { 1708 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1709 "bpp"); 1710 return; 1711 } 1712 1713 if (parser_read_uint32(&p.source.n_bytes_per_pkt, tokens[t0 + 6]) != 0) { 1714 snprintf(out, out_size, MSG_ARG_INVALID, 1715 "n_bytes_per_pkt"); 1716 return; 1717 } 1718 1719 t0 += 7; 1720 } else if (strcmp(tokens[t0], "cryptodev") == 0) { 1721 if (n_tokens < t0 + 3) { 1722 snprintf(out, out_size, MSG_ARG_MISMATCH, 1723 "pipeline port in cryptodev"); 1724 return; 1725 } 1726 1727 p.type = PORT_IN_CRYPTODEV; 1728 1729 p.dev_name = tokens[t0 + 1]; 1730 if (parser_read_uint16(&p.rxq.queue_id, tokens[t0 + 3]) != 0) { 1731 snprintf(out, out_size, MSG_ARG_INVALID, 1732 "rxq"); 1733 return; 1734 } 1735 1736 p.cryptodev.arg_callback = NULL; 1737 p.cryptodev.f_callback = NULL; 1738 1739 t0 += 4; 1740 } else { 1741 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]); 1742 return; 1743 } 1744 1745 p.action_profile_name = NULL; 1746 if ((n_tokens > t0) && (strcmp(tokens[t0], "action") == 0)) { 1747 if (n_tokens < t0 + 2) { 1748 snprintf(out, out_size, MSG_ARG_MISMATCH, "action"); 1749 return; 1750 } 1751 1752 p.action_profile_name = tokens[t0 + 1]; 1753 1754 t0 += 2; 1755 } 1756 1757 enabled = 1; 1758 if ((n_tokens > t0) && 1759 (strcmp(tokens[t0], "disabled") == 0)) { 1760 enabled = 0; 1761 1762 t0 += 1; 1763 } 1764 1765 if (n_tokens != t0) { 1766 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 1767 return; 1768 } 1769 1770 status = pipeline_port_in_create(pipeline_name, 1771 &p, enabled); 1772 if (status) { 1773 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 1774 return; 1775 } 1776 } 1777 1778 static const char cmd_pipeline_port_out_help[] = 1779 "pipeline <pipeline_name> port out\n" 1780 " bsz <burst_size>\n" 1781 " link <link_name> txq <txq_id>\n" 1782 " | swq <swq_name>\n" 1783 " | tmgr <tmgr_name>\n" 1784 " | tap <tap_name>\n" 1785 " | kni <kni_name>\n" 1786 " | sink [file <file_name> pkts <max_n_pkts>]\n" 1787 " | cryptodev <cryptodev_name> txq <txq_id> offset <crypto_op_offset>\n"; 1788 1789 static void 1790 cmd_pipeline_port_out(char **tokens, 1791 uint32_t n_tokens, 1792 char *out, 1793 size_t out_size) 1794 { 1795 struct port_out_params p; 1796 char *pipeline_name; 1797 int status; 1798 1799 memset(&p, 0, sizeof(p)); 1800 1801 if (n_tokens < 7) { 1802 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 1803 return; 1804 } 1805 1806 pipeline_name = tokens[1]; 1807 1808 if (strcmp(tokens[2], "port") != 0) { 1809 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port"); 1810 return; 1811 } 1812 1813 if (strcmp(tokens[3], "out") != 0) { 1814 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "out"); 1815 return; 1816 } 1817 1818 if (strcmp(tokens[4], "bsz") != 0) { 1819 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "bsz"); 1820 return; 1821 } 1822 1823 if (parser_read_uint32(&p.burst_size, tokens[5]) != 0) { 1824 snprintf(out, out_size, MSG_ARG_INVALID, "burst_size"); 1825 return; 1826 } 1827 1828 if (strcmp(tokens[6], "link") == 0) { 1829 if (n_tokens != 10) { 1830 snprintf(out, out_size, MSG_ARG_MISMATCH, 1831 "pipeline port out link"); 1832 return; 1833 } 1834 1835 p.type = PORT_OUT_TXQ; 1836 1837 p.dev_name = tokens[7]; 1838 1839 if (strcmp(tokens[8], "txq") != 0) { 1840 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "txq"); 1841 return; 1842 } 1843 1844 if (parser_read_uint16(&p.txq.queue_id, tokens[9]) != 0) { 1845 snprintf(out, out_size, MSG_ARG_INVALID, "queue_id"); 1846 return; 1847 } 1848 } else if (strcmp(tokens[6], "swq") == 0) { 1849 if (n_tokens != 8) { 1850 snprintf(out, out_size, MSG_ARG_MISMATCH, 1851 "pipeline port out swq"); 1852 return; 1853 } 1854 1855 p.type = PORT_OUT_SWQ; 1856 1857 p.dev_name = tokens[7]; 1858 } else if (strcmp(tokens[6], "tmgr") == 0) { 1859 if (n_tokens != 8) { 1860 snprintf(out, out_size, MSG_ARG_MISMATCH, 1861 "pipeline port out tmgr"); 1862 return; 1863 } 1864 1865 p.type = PORT_OUT_TMGR; 1866 1867 p.dev_name = tokens[7]; 1868 } else if (strcmp(tokens[6], "tap") == 0) { 1869 if (n_tokens != 8) { 1870 snprintf(out, out_size, MSG_ARG_MISMATCH, 1871 "pipeline port out tap"); 1872 return; 1873 } 1874 1875 p.type = PORT_OUT_TAP; 1876 1877 p.dev_name = tokens[7]; 1878 } else if (strcmp(tokens[6], "kni") == 0) { 1879 if (n_tokens != 8) { 1880 snprintf(out, out_size, MSG_ARG_MISMATCH, 1881 "pipeline port out kni"); 1882 return; 1883 } 1884 1885 p.type = PORT_OUT_KNI; 1886 1887 p.dev_name = tokens[7]; 1888 } else if (strcmp(tokens[6], "sink") == 0) { 1889 if ((n_tokens != 7) && (n_tokens != 11)) { 1890 snprintf(out, out_size, MSG_ARG_MISMATCH, 1891 "pipeline port out sink"); 1892 return; 1893 } 1894 1895 p.type = PORT_OUT_SINK; 1896 1897 p.dev_name = NULL; 1898 1899 if (n_tokens == 7) { 1900 p.sink.file_name = NULL; 1901 p.sink.max_n_pkts = 0; 1902 } else { 1903 if (strcmp(tokens[7], "file") != 0) { 1904 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 1905 "file"); 1906 return; 1907 } 1908 1909 p.sink.file_name = tokens[8]; 1910 1911 if (strcmp(tokens[9], "pkts") != 0) { 1912 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pkts"); 1913 return; 1914 } 1915 1916 if (parser_read_uint32(&p.sink.max_n_pkts, tokens[10]) != 0) { 1917 snprintf(out, out_size, MSG_ARG_INVALID, "max_n_pkts"); 1918 return; 1919 } 1920 } 1921 1922 } else if (strcmp(tokens[6], "cryptodev") == 0) { 1923 if (n_tokens != 12) { 1924 snprintf(out, out_size, MSG_ARG_MISMATCH, 1925 "pipeline port out cryptodev"); 1926 return; 1927 } 1928 1929 p.type = PORT_OUT_CRYPTODEV; 1930 1931 p.dev_name = tokens[7]; 1932 1933 if (strcmp(tokens[8], "txq")) { 1934 snprintf(out, out_size, MSG_ARG_MISMATCH, 1935 "pipeline port out cryptodev"); 1936 return; 1937 } 1938 1939 if (parser_read_uint16(&p.cryptodev.queue_id, tokens[9]) 1940 != 0) { 1941 snprintf(out, out_size, MSG_ARG_INVALID, "queue_id"); 1942 return; 1943 } 1944 1945 if (strcmp(tokens[10], "offset")) { 1946 snprintf(out, out_size, MSG_ARG_MISMATCH, 1947 "pipeline port out cryptodev"); 1948 return; 1949 } 1950 1951 if (parser_read_uint32(&p.cryptodev.op_offset, tokens[11]) 1952 != 0) { 1953 snprintf(out, out_size, MSG_ARG_INVALID, "queue_id"); 1954 return; 1955 } 1956 } else { 1957 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]); 1958 return; 1959 } 1960 1961 status = pipeline_port_out_create(pipeline_name, &p); 1962 if (status) { 1963 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 1964 return; 1965 } 1966 } 1967 1968 static const char cmd_pipeline_table_help[] = 1969 "pipeline <pipeline_name> table\n" 1970 " match\n" 1971 " acl\n" 1972 " ipv4 | ipv6\n" 1973 " offset <ip_header_offset>\n" 1974 " size <n_rules>\n" 1975 " | array\n" 1976 " offset <key_offset>\n" 1977 " size <n_keys>\n" 1978 " | hash\n" 1979 " ext | lru\n" 1980 " key <key_size>\n" 1981 " mask <key_mask>\n" 1982 " offset <key_offset>\n" 1983 " buckets <n_buckets>\n" 1984 " size <n_keys>\n" 1985 " | lpm\n" 1986 " ipv4 | ipv6\n" 1987 " offset <ip_header_offset>\n" 1988 " size <n_rules>\n" 1989 " | stub\n" 1990 " [action <table_action_profile_name>]\n"; 1991 1992 static void 1993 cmd_pipeline_table(char **tokens, 1994 uint32_t n_tokens, 1995 char *out, 1996 size_t out_size) 1997 { 1998 uint8_t key_mask[TABLE_RULE_MATCH_SIZE_MAX]; 1999 struct table_params p; 2000 char *pipeline_name; 2001 uint32_t t0; 2002 int status; 2003 2004 if (n_tokens < 5) { 2005 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 2006 return; 2007 } 2008 2009 pipeline_name = tokens[1]; 2010 2011 if (strcmp(tokens[2], "table") != 0) { 2012 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table"); 2013 return; 2014 } 2015 2016 if (strcmp(tokens[3], "match") != 0) { 2017 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match"); 2018 return; 2019 } 2020 2021 t0 = 4; 2022 if (strcmp(tokens[t0], "acl") == 0) { 2023 if (n_tokens < t0 + 6) { 2024 snprintf(out, out_size, MSG_ARG_MISMATCH, 2025 "pipeline table acl"); 2026 return; 2027 } 2028 2029 p.match_type = TABLE_ACL; 2030 2031 if (strcmp(tokens[t0 + 1], "ipv4") == 0) 2032 p.match.acl.ip_version = 1; 2033 else if (strcmp(tokens[t0 + 1], "ipv6") == 0) 2034 p.match.acl.ip_version = 0; 2035 else { 2036 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 2037 "ipv4 or ipv6"); 2038 return; 2039 } 2040 2041 if (strcmp(tokens[t0 + 2], "offset") != 0) { 2042 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset"); 2043 return; 2044 } 2045 2046 if (parser_read_uint32(&p.match.acl.ip_header_offset, 2047 tokens[t0 + 3]) != 0) { 2048 snprintf(out, out_size, MSG_ARG_INVALID, 2049 "ip_header_offset"); 2050 return; 2051 } 2052 2053 if (strcmp(tokens[t0 + 4], "size") != 0) { 2054 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size"); 2055 return; 2056 } 2057 2058 if (parser_read_uint32(&p.match.acl.n_rules, 2059 tokens[t0 + 5]) != 0) { 2060 snprintf(out, out_size, MSG_ARG_INVALID, "n_rules"); 2061 return; 2062 } 2063 2064 t0 += 6; 2065 } else if (strcmp(tokens[t0], "array") == 0) { 2066 if (n_tokens < t0 + 5) { 2067 snprintf(out, out_size, MSG_ARG_MISMATCH, 2068 "pipeline table array"); 2069 return; 2070 } 2071 2072 p.match_type = TABLE_ARRAY; 2073 2074 if (strcmp(tokens[t0 + 1], "offset") != 0) { 2075 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset"); 2076 return; 2077 } 2078 2079 if (parser_read_uint32(&p.match.array.key_offset, 2080 tokens[t0 + 2]) != 0) { 2081 snprintf(out, out_size, MSG_ARG_INVALID, "key_offset"); 2082 return; 2083 } 2084 2085 if (strcmp(tokens[t0 + 3], "size") != 0) { 2086 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size"); 2087 return; 2088 } 2089 2090 if (parser_read_uint32(&p.match.array.n_keys, 2091 tokens[t0 + 4]) != 0) { 2092 snprintf(out, out_size, MSG_ARG_INVALID, "n_keys"); 2093 return; 2094 } 2095 2096 t0 += 5; 2097 } else if (strcmp(tokens[t0], "hash") == 0) { 2098 uint32_t key_mask_size = TABLE_RULE_MATCH_SIZE_MAX; 2099 2100 if (n_tokens < t0 + 12) { 2101 snprintf(out, out_size, MSG_ARG_MISMATCH, 2102 "pipeline table hash"); 2103 return; 2104 } 2105 2106 p.match_type = TABLE_HASH; 2107 2108 if (strcmp(tokens[t0 + 1], "ext") == 0) 2109 p.match.hash.extendable_bucket = 1; 2110 else if (strcmp(tokens[t0 + 1], "lru") == 0) 2111 p.match.hash.extendable_bucket = 0; 2112 else { 2113 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 2114 "ext or lru"); 2115 return; 2116 } 2117 2118 if (strcmp(tokens[t0 + 2], "key") != 0) { 2119 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "key"); 2120 return; 2121 } 2122 2123 if ((parser_read_uint32(&p.match.hash.key_size, 2124 tokens[t0 + 3]) != 0) || 2125 (p.match.hash.key_size == 0) || 2126 (p.match.hash.key_size > TABLE_RULE_MATCH_SIZE_MAX)) { 2127 snprintf(out, out_size, MSG_ARG_INVALID, "key_size"); 2128 return; 2129 } 2130 2131 if (strcmp(tokens[t0 + 4], "mask") != 0) { 2132 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "mask"); 2133 return; 2134 } 2135 2136 if ((parse_hex_string(tokens[t0 + 5], 2137 key_mask, &key_mask_size) != 0) || 2138 (key_mask_size != p.match.hash.key_size)) { 2139 snprintf(out, out_size, MSG_ARG_INVALID, "key_mask"); 2140 return; 2141 } 2142 p.match.hash.key_mask = key_mask; 2143 2144 if (strcmp(tokens[t0 + 6], "offset") != 0) { 2145 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset"); 2146 return; 2147 } 2148 2149 if (parser_read_uint32(&p.match.hash.key_offset, 2150 tokens[t0 + 7]) != 0) { 2151 snprintf(out, out_size, MSG_ARG_INVALID, "key_offset"); 2152 return; 2153 } 2154 2155 if (strcmp(tokens[t0 + 8], "buckets") != 0) { 2156 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "buckets"); 2157 return; 2158 } 2159 2160 if (parser_read_uint32(&p.match.hash.n_buckets, 2161 tokens[t0 + 9]) != 0) { 2162 snprintf(out, out_size, MSG_ARG_INVALID, "n_buckets"); 2163 return; 2164 } 2165 2166 if (strcmp(tokens[t0 + 10], "size") != 0) { 2167 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size"); 2168 return; 2169 } 2170 2171 if (parser_read_uint32(&p.match.hash.n_keys, 2172 tokens[t0 + 11]) != 0) { 2173 snprintf(out, out_size, MSG_ARG_INVALID, "n_keys"); 2174 return; 2175 } 2176 2177 t0 += 12; 2178 } else if (strcmp(tokens[t0], "lpm") == 0) { 2179 if (n_tokens < t0 + 6) { 2180 snprintf(out, out_size, MSG_ARG_MISMATCH, 2181 "pipeline table lpm"); 2182 return; 2183 } 2184 2185 p.match_type = TABLE_LPM; 2186 2187 if (strcmp(tokens[t0 + 1], "ipv4") == 0) 2188 p.match.lpm.key_size = 4; 2189 else if (strcmp(tokens[t0 + 1], "ipv6") == 0) 2190 p.match.lpm.key_size = 16; 2191 else { 2192 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 2193 "ipv4 or ipv6"); 2194 return; 2195 } 2196 2197 if (strcmp(tokens[t0 + 2], "offset") != 0) { 2198 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "offset"); 2199 return; 2200 } 2201 2202 if (parser_read_uint32(&p.match.lpm.key_offset, 2203 tokens[t0 + 3]) != 0) { 2204 snprintf(out, out_size, MSG_ARG_INVALID, "key_offset"); 2205 return; 2206 } 2207 2208 if (strcmp(tokens[t0 + 4], "size") != 0) { 2209 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "size"); 2210 return; 2211 } 2212 2213 if (parser_read_uint32(&p.match.lpm.n_rules, 2214 tokens[t0 + 5]) != 0) { 2215 snprintf(out, out_size, MSG_ARG_INVALID, "n_rules"); 2216 return; 2217 } 2218 2219 t0 += 6; 2220 } else if (strcmp(tokens[t0], "stub") == 0) { 2221 p.match_type = TABLE_STUB; 2222 2223 t0 += 1; 2224 } else { 2225 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]); 2226 return; 2227 } 2228 2229 p.action_profile_name = NULL; 2230 if ((n_tokens > t0) && (strcmp(tokens[t0], "action") == 0)) { 2231 if (n_tokens < t0 + 2) { 2232 snprintf(out, out_size, MSG_ARG_MISMATCH, "action"); 2233 return; 2234 } 2235 2236 p.action_profile_name = tokens[t0 + 1]; 2237 2238 t0 += 2; 2239 } 2240 2241 if (n_tokens > t0) { 2242 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 2243 return; 2244 } 2245 2246 status = pipeline_table_create(pipeline_name, &p); 2247 if (status) { 2248 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 2249 return; 2250 } 2251 } 2252 2253 static const char cmd_pipeline_port_in_table_help[] = 2254 "pipeline <pipeline_name> port in <port_id> table <table_id>\n"; 2255 2256 static void 2257 cmd_pipeline_port_in_table(char **tokens, 2258 uint32_t n_tokens, 2259 char *out, 2260 size_t out_size) 2261 { 2262 char *pipeline_name; 2263 uint32_t port_id, table_id; 2264 int status; 2265 2266 if (n_tokens != 7) { 2267 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 2268 return; 2269 } 2270 2271 pipeline_name = tokens[1]; 2272 2273 if (strcmp(tokens[2], "port") != 0) { 2274 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port"); 2275 return; 2276 } 2277 2278 if (strcmp(tokens[3], "in") != 0) { 2279 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in"); 2280 return; 2281 } 2282 2283 if (parser_read_uint32(&port_id, tokens[4]) != 0) { 2284 snprintf(out, out_size, MSG_ARG_INVALID, "port_id"); 2285 return; 2286 } 2287 2288 if (strcmp(tokens[5], "table") != 0) { 2289 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table"); 2290 return; 2291 } 2292 2293 if (parser_read_uint32(&table_id, tokens[6]) != 0) { 2294 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 2295 return; 2296 } 2297 2298 status = pipeline_port_in_connect_to_table(pipeline_name, 2299 port_id, 2300 table_id); 2301 if (status) { 2302 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 2303 return; 2304 } 2305 } 2306 2307 2308 static const char cmd_pipeline_port_in_stats_help[] = 2309 "pipeline <pipeline_name> port in <port_id> stats read [clear]\n"; 2310 2311 #define MSG_PIPELINE_PORT_IN_STATS \ 2312 "Pkts in: %" PRIu64 "\n" \ 2313 "Pkts dropped by AH: %" PRIu64 "\n" \ 2314 "Pkts dropped by other: %" PRIu64 "\n" 2315 2316 static void 2317 cmd_pipeline_port_in_stats(char **tokens, 2318 uint32_t n_tokens, 2319 char *out, 2320 size_t out_size) 2321 { 2322 struct rte_pipeline_port_in_stats stats; 2323 char *pipeline_name; 2324 uint32_t port_id; 2325 int clear, status; 2326 2327 if ((n_tokens != 7) && (n_tokens != 8)) { 2328 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 2329 return; 2330 } 2331 2332 pipeline_name = tokens[1]; 2333 2334 if (strcmp(tokens[2], "port") != 0) { 2335 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port"); 2336 return; 2337 } 2338 2339 if (strcmp(tokens[3], "in") != 0) { 2340 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in"); 2341 return; 2342 } 2343 2344 if (parser_read_uint32(&port_id, tokens[4]) != 0) { 2345 snprintf(out, out_size, MSG_ARG_INVALID, "port_id"); 2346 return; 2347 } 2348 2349 if (strcmp(tokens[5], "stats") != 0) { 2350 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats"); 2351 return; 2352 } 2353 2354 if (strcmp(tokens[6], "read") != 0) { 2355 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read"); 2356 return; 2357 } 2358 2359 clear = 0; 2360 if (n_tokens == 8) { 2361 if (strcmp(tokens[7], "clear") != 0) { 2362 snprintf(out, out_size, MSG_ARG_INVALID, "clear"); 2363 return; 2364 } 2365 2366 clear = 1; 2367 } 2368 2369 status = pipeline_port_in_stats_read(pipeline_name, 2370 port_id, 2371 &stats, 2372 clear); 2373 if (status) { 2374 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 2375 return; 2376 } 2377 2378 snprintf(out, out_size, MSG_PIPELINE_PORT_IN_STATS, 2379 stats.stats.n_pkts_in, 2380 stats.n_pkts_dropped_by_ah, 2381 stats.stats.n_pkts_drop); 2382 } 2383 2384 2385 static const char cmd_pipeline_port_in_enable_help[] = 2386 "pipeline <pipeline_name> port in <port_id> enable\n"; 2387 2388 static void 2389 cmd_pipeline_port_in_enable(char **tokens, 2390 uint32_t n_tokens, 2391 char *out, 2392 size_t out_size) 2393 { 2394 char *pipeline_name; 2395 uint32_t port_id; 2396 int status; 2397 2398 if (n_tokens != 6) { 2399 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 2400 return; 2401 } 2402 2403 pipeline_name = tokens[1]; 2404 2405 if (strcmp(tokens[2], "port") != 0) { 2406 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port"); 2407 return; 2408 } 2409 2410 if (strcmp(tokens[3], "in") != 0) { 2411 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in"); 2412 return; 2413 } 2414 2415 if (parser_read_uint32(&port_id, tokens[4]) != 0) { 2416 snprintf(out, out_size, MSG_ARG_INVALID, "port_id"); 2417 return; 2418 } 2419 2420 if (strcmp(tokens[5], "enable") != 0) { 2421 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "enable"); 2422 return; 2423 } 2424 2425 status = pipeline_port_in_enable(pipeline_name, port_id); 2426 if (status) { 2427 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 2428 return; 2429 } 2430 } 2431 2432 2433 static const char cmd_pipeline_port_in_disable_help[] = 2434 "pipeline <pipeline_name> port in <port_id> disable\n"; 2435 2436 static void 2437 cmd_pipeline_port_in_disable(char **tokens, 2438 uint32_t n_tokens, 2439 char *out, 2440 size_t out_size) 2441 { 2442 char *pipeline_name; 2443 uint32_t port_id; 2444 int status; 2445 2446 if (n_tokens != 6) { 2447 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 2448 return; 2449 } 2450 2451 pipeline_name = tokens[1]; 2452 2453 if (strcmp(tokens[2], "port") != 0) { 2454 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port"); 2455 return; 2456 } 2457 2458 if (strcmp(tokens[3], "in") != 0) { 2459 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "in"); 2460 return; 2461 } 2462 2463 if (parser_read_uint32(&port_id, tokens[4]) != 0) { 2464 snprintf(out, out_size, MSG_ARG_INVALID, "port_id"); 2465 return; 2466 } 2467 2468 if (strcmp(tokens[5], "disable") != 0) { 2469 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "disable"); 2470 return; 2471 } 2472 2473 status = pipeline_port_in_disable(pipeline_name, port_id); 2474 if (status) { 2475 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 2476 return; 2477 } 2478 } 2479 2480 2481 static const char cmd_pipeline_port_out_stats_help[] = 2482 "pipeline <pipeline_name> port out <port_id> stats read [clear]\n"; 2483 2484 #define MSG_PIPELINE_PORT_OUT_STATS \ 2485 "Pkts in: %" PRIu64 "\n" \ 2486 "Pkts dropped by AH: %" PRIu64 "\n" \ 2487 "Pkts dropped by other: %" PRIu64 "\n" 2488 2489 static void 2490 cmd_pipeline_port_out_stats(char **tokens, 2491 uint32_t n_tokens, 2492 char *out, 2493 size_t out_size) 2494 { 2495 struct rte_pipeline_port_out_stats stats; 2496 char *pipeline_name; 2497 uint32_t port_id; 2498 int clear, status; 2499 2500 if ((n_tokens != 7) && (n_tokens != 8)) { 2501 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 2502 return; 2503 } 2504 2505 pipeline_name = tokens[1]; 2506 2507 if (strcmp(tokens[2], "port") != 0) { 2508 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port"); 2509 return; 2510 } 2511 2512 if (strcmp(tokens[3], "out") != 0) { 2513 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "out"); 2514 return; 2515 } 2516 2517 if (parser_read_uint32(&port_id, tokens[4]) != 0) { 2518 snprintf(out, out_size, MSG_ARG_INVALID, "port_id"); 2519 return; 2520 } 2521 2522 if (strcmp(tokens[5], "stats") != 0) { 2523 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats"); 2524 return; 2525 } 2526 2527 if (strcmp(tokens[6], "read") != 0) { 2528 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read"); 2529 return; 2530 } 2531 2532 clear = 0; 2533 if (n_tokens == 8) { 2534 if (strcmp(tokens[7], "clear") != 0) { 2535 snprintf(out, out_size, MSG_ARG_INVALID, "clear"); 2536 return; 2537 } 2538 2539 clear = 1; 2540 } 2541 2542 status = pipeline_port_out_stats_read(pipeline_name, 2543 port_id, 2544 &stats, 2545 clear); 2546 if (status) { 2547 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 2548 return; 2549 } 2550 2551 snprintf(out, out_size, MSG_PIPELINE_PORT_OUT_STATS, 2552 stats.stats.n_pkts_in, 2553 stats.n_pkts_dropped_by_ah, 2554 stats.stats.n_pkts_drop); 2555 } 2556 2557 2558 static const char cmd_pipeline_table_stats_help[] = 2559 "pipeline <pipeline_name> table <table_id> stats read [clear]\n"; 2560 2561 #define MSG_PIPELINE_TABLE_STATS \ 2562 "Pkts in: %" PRIu64 "\n" \ 2563 "Pkts in with lookup miss: %" PRIu64 "\n" \ 2564 "Pkts in with lookup hit dropped by AH: %" PRIu64 "\n" \ 2565 "Pkts in with lookup hit dropped by others: %" PRIu64 "\n" \ 2566 "Pkts in with lookup miss dropped by AH: %" PRIu64 "\n" \ 2567 "Pkts in with lookup miss dropped by others: %" PRIu64 "\n" 2568 2569 static void 2570 cmd_pipeline_table_stats(char **tokens, 2571 uint32_t n_tokens, 2572 char *out, 2573 size_t out_size) 2574 { 2575 struct rte_pipeline_table_stats stats; 2576 char *pipeline_name; 2577 uint32_t table_id; 2578 int clear, status; 2579 2580 if ((n_tokens != 6) && (n_tokens != 7)) { 2581 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 2582 return; 2583 } 2584 2585 pipeline_name = tokens[1]; 2586 2587 if (strcmp(tokens[2], "table") != 0) { 2588 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port"); 2589 return; 2590 } 2591 2592 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 2593 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 2594 return; 2595 } 2596 2597 if (strcmp(tokens[4], "stats") != 0) { 2598 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats"); 2599 return; 2600 } 2601 2602 if (strcmp(tokens[5], "read") != 0) { 2603 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read"); 2604 return; 2605 } 2606 2607 clear = 0; 2608 if (n_tokens == 7) { 2609 if (strcmp(tokens[6], "clear") != 0) { 2610 snprintf(out, out_size, MSG_ARG_INVALID, "clear"); 2611 return; 2612 } 2613 2614 clear = 1; 2615 } 2616 2617 status = pipeline_table_stats_read(pipeline_name, 2618 table_id, 2619 &stats, 2620 clear); 2621 if (status) { 2622 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 2623 return; 2624 } 2625 2626 snprintf(out, out_size, MSG_PIPELINE_TABLE_STATS, 2627 stats.stats.n_pkts_in, 2628 stats.stats.n_pkts_lookup_miss, 2629 stats.n_pkts_dropped_by_lkp_hit_ah, 2630 stats.n_pkts_dropped_lkp_hit, 2631 stats.n_pkts_dropped_by_lkp_miss_ah, 2632 stats.n_pkts_dropped_lkp_miss); 2633 } 2634 2635 /** 2636 * <match> ::= 2637 * 2638 * match 2639 * acl 2640 * priority <priority> 2641 * ipv4 | ipv6 <sa> <sa_depth> <da> <da_depth> 2642 * <sp0> <sp1> <dp0> <dp1> <proto> 2643 * | array <pos> 2644 * | hash 2645 * raw <key> 2646 * | ipv4_5tuple <sa> <da> <sp> <dp> <proto> 2647 * | ipv6_5tuple <sa> <da> <sp> <dp> <proto> 2648 * | ipv4_addr <addr> 2649 * | ipv6_addr <addr> 2650 * | qinq <svlan> <cvlan> 2651 * | lpm 2652 * ipv4 | ipv6 <addr> <depth> 2653 */ 2654 struct pkt_key_qinq { 2655 uint16_t ethertype_svlan; 2656 uint16_t svlan; 2657 uint16_t ethertype_cvlan; 2658 uint16_t cvlan; 2659 } __attribute__((__packed__)); 2660 2661 struct pkt_key_ipv4_5tuple { 2662 uint8_t time_to_live; 2663 uint8_t proto; 2664 uint16_t hdr_checksum; 2665 uint32_t sa; 2666 uint32_t da; 2667 uint16_t sp; 2668 uint16_t dp; 2669 } __attribute__((__packed__)); 2670 2671 struct pkt_key_ipv6_5tuple { 2672 uint16_t payload_length; 2673 uint8_t proto; 2674 uint8_t hop_limit; 2675 uint8_t sa[16]; 2676 uint8_t da[16]; 2677 uint16_t sp; 2678 uint16_t dp; 2679 } __attribute__((__packed__)); 2680 2681 struct pkt_key_ipv4_addr { 2682 uint32_t addr; 2683 } __attribute__((__packed__)); 2684 2685 struct pkt_key_ipv6_addr { 2686 uint8_t addr[16]; 2687 } __attribute__((__packed__)); 2688 2689 static uint32_t 2690 parse_match(char **tokens, 2691 uint32_t n_tokens, 2692 char *out, 2693 size_t out_size, 2694 struct table_rule_match *m) 2695 { 2696 memset(m, 0, sizeof(*m)); 2697 2698 if (n_tokens < 2) 2699 return 0; 2700 2701 if (strcmp(tokens[0], "match") != 0) { 2702 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match"); 2703 return 0; 2704 } 2705 2706 if (strcmp(tokens[1], "acl") == 0) { 2707 if (n_tokens < 14) { 2708 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 2709 return 0; 2710 } 2711 2712 m->match_type = TABLE_ACL; 2713 2714 if (strcmp(tokens[2], "priority") != 0) { 2715 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "priority"); 2716 return 0; 2717 } 2718 2719 if (parser_read_uint32(&m->match.acl.priority, 2720 tokens[3]) != 0) { 2721 snprintf(out, out_size, MSG_ARG_INVALID, "priority"); 2722 return 0; 2723 } 2724 2725 if (strcmp(tokens[4], "ipv4") == 0) { 2726 struct in_addr saddr, daddr; 2727 2728 m->match.acl.ip_version = 1; 2729 2730 if (parse_ipv4_addr(tokens[5], &saddr) != 0) { 2731 snprintf(out, out_size, MSG_ARG_INVALID, "sa"); 2732 return 0; 2733 } 2734 m->match.acl.ipv4.sa = rte_be_to_cpu_32(saddr.s_addr); 2735 2736 if (parse_ipv4_addr(tokens[7], &daddr) != 0) { 2737 snprintf(out, out_size, MSG_ARG_INVALID, "da"); 2738 return 0; 2739 } 2740 m->match.acl.ipv4.da = rte_be_to_cpu_32(daddr.s_addr); 2741 } else if (strcmp(tokens[4], "ipv6") == 0) { 2742 struct in6_addr saddr, daddr; 2743 2744 m->match.acl.ip_version = 0; 2745 2746 if (parse_ipv6_addr(tokens[5], &saddr) != 0) { 2747 snprintf(out, out_size, MSG_ARG_INVALID, "sa"); 2748 return 0; 2749 } 2750 memcpy(m->match.acl.ipv6.sa, saddr.s6_addr, 16); 2751 2752 if (parse_ipv6_addr(tokens[7], &daddr) != 0) { 2753 snprintf(out, out_size, MSG_ARG_INVALID, "da"); 2754 return 0; 2755 } 2756 memcpy(m->match.acl.ipv6.da, daddr.s6_addr, 16); 2757 } else { 2758 snprintf(out, out_size, MSG_ARG_NOT_FOUND, 2759 "ipv4 or ipv6"); 2760 return 0; 2761 } 2762 2763 if (parser_read_uint32(&m->match.acl.sa_depth, 2764 tokens[6]) != 0) { 2765 snprintf(out, out_size, MSG_ARG_INVALID, "sa_depth"); 2766 return 0; 2767 } 2768 2769 if (parser_read_uint32(&m->match.acl.da_depth, 2770 tokens[8]) != 0) { 2771 snprintf(out, out_size, MSG_ARG_INVALID, "da_depth"); 2772 return 0; 2773 } 2774 2775 if (parser_read_uint16(&m->match.acl.sp0, tokens[9]) != 0) { 2776 snprintf(out, out_size, MSG_ARG_INVALID, "sp0"); 2777 return 0; 2778 } 2779 2780 if (parser_read_uint16(&m->match.acl.sp1, tokens[10]) != 0) { 2781 snprintf(out, out_size, MSG_ARG_INVALID, "sp1"); 2782 return 0; 2783 } 2784 2785 if (parser_read_uint16(&m->match.acl.dp0, tokens[11]) != 0) { 2786 snprintf(out, out_size, MSG_ARG_INVALID, "dp0"); 2787 return 0; 2788 } 2789 2790 if (parser_read_uint16(&m->match.acl.dp1, tokens[12]) != 0) { 2791 snprintf(out, out_size, MSG_ARG_INVALID, "dp1"); 2792 return 0; 2793 } 2794 2795 if (parser_read_uint8(&m->match.acl.proto, tokens[13]) != 0) { 2796 snprintf(out, out_size, MSG_ARG_INVALID, "proto"); 2797 return 0; 2798 } 2799 2800 m->match.acl.proto_mask = 0xff; 2801 2802 return 14; 2803 } /* acl */ 2804 2805 if (strcmp(tokens[1], "array") == 0) { 2806 if (n_tokens < 3) { 2807 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 2808 return 0; 2809 } 2810 2811 m->match_type = TABLE_ARRAY; 2812 2813 if (parser_read_uint32(&m->match.array.pos, tokens[2]) != 0) { 2814 snprintf(out, out_size, MSG_ARG_INVALID, "pos"); 2815 return 0; 2816 } 2817 2818 return 3; 2819 } /* array */ 2820 2821 if (strcmp(tokens[1], "hash") == 0) { 2822 if (n_tokens < 3) { 2823 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 2824 return 0; 2825 } 2826 2827 m->match_type = TABLE_HASH; 2828 2829 if (strcmp(tokens[2], "raw") == 0) { 2830 uint32_t key_size = TABLE_RULE_MATCH_SIZE_MAX; 2831 2832 if (n_tokens < 4) { 2833 snprintf(out, out_size, MSG_ARG_MISMATCH, 2834 tokens[0]); 2835 return 0; 2836 } 2837 2838 if (parse_hex_string(tokens[3], 2839 m->match.hash.key, &key_size) != 0) { 2840 snprintf(out, out_size, MSG_ARG_INVALID, "key"); 2841 return 0; 2842 } 2843 2844 return 4; 2845 } /* hash raw */ 2846 2847 if (strcmp(tokens[2], "ipv4_5tuple") == 0) { 2848 struct pkt_key_ipv4_5tuple *ipv4 = 2849 (struct pkt_key_ipv4_5tuple *) m->match.hash.key; 2850 struct in_addr saddr, daddr; 2851 uint16_t sp, dp; 2852 uint8_t proto; 2853 2854 if (n_tokens < 8) { 2855 snprintf(out, out_size, MSG_ARG_MISMATCH, 2856 tokens[0]); 2857 return 0; 2858 } 2859 2860 if (parse_ipv4_addr(tokens[3], &saddr) != 0) { 2861 snprintf(out, out_size, MSG_ARG_INVALID, "sa"); 2862 return 0; 2863 } 2864 2865 if (parse_ipv4_addr(tokens[4], &daddr) != 0) { 2866 snprintf(out, out_size, MSG_ARG_INVALID, "da"); 2867 return 0; 2868 } 2869 2870 if (parser_read_uint16(&sp, tokens[5]) != 0) { 2871 snprintf(out, out_size, MSG_ARG_INVALID, "sp"); 2872 return 0; 2873 } 2874 2875 if (parser_read_uint16(&dp, tokens[6]) != 0) { 2876 snprintf(out, out_size, MSG_ARG_INVALID, "dp"); 2877 return 0; 2878 } 2879 2880 if (parser_read_uint8(&proto, tokens[7]) != 0) { 2881 snprintf(out, out_size, MSG_ARG_INVALID, 2882 "proto"); 2883 return 0; 2884 } 2885 2886 ipv4->sa = saddr.s_addr; 2887 ipv4->da = daddr.s_addr; 2888 ipv4->sp = rte_cpu_to_be_16(sp); 2889 ipv4->dp = rte_cpu_to_be_16(dp); 2890 ipv4->proto = proto; 2891 2892 return 8; 2893 } /* hash ipv4_5tuple */ 2894 2895 if (strcmp(tokens[2], "ipv6_5tuple") == 0) { 2896 struct pkt_key_ipv6_5tuple *ipv6 = 2897 (struct pkt_key_ipv6_5tuple *) m->match.hash.key; 2898 struct in6_addr saddr, daddr; 2899 uint16_t sp, dp; 2900 uint8_t proto; 2901 2902 if (n_tokens < 8) { 2903 snprintf(out, out_size, MSG_ARG_MISMATCH, 2904 tokens[0]); 2905 return 0; 2906 } 2907 2908 if (parse_ipv6_addr(tokens[3], &saddr) != 0) { 2909 snprintf(out, out_size, MSG_ARG_INVALID, "sa"); 2910 return 0; 2911 } 2912 2913 if (parse_ipv6_addr(tokens[4], &daddr) != 0) { 2914 snprintf(out, out_size, MSG_ARG_INVALID, "da"); 2915 return 0; 2916 } 2917 2918 if (parser_read_uint16(&sp, tokens[5]) != 0) { 2919 snprintf(out, out_size, MSG_ARG_INVALID, "sp"); 2920 return 0; 2921 } 2922 2923 if (parser_read_uint16(&dp, tokens[6]) != 0) { 2924 snprintf(out, out_size, MSG_ARG_INVALID, "dp"); 2925 return 0; 2926 } 2927 2928 if (parser_read_uint8(&proto, tokens[7]) != 0) { 2929 snprintf(out, out_size, MSG_ARG_INVALID, 2930 "proto"); 2931 return 0; 2932 } 2933 2934 memcpy(ipv6->sa, saddr.s6_addr, 16); 2935 memcpy(ipv6->da, daddr.s6_addr, 16); 2936 ipv6->sp = rte_cpu_to_be_16(sp); 2937 ipv6->dp = rte_cpu_to_be_16(dp); 2938 ipv6->proto = proto; 2939 2940 return 8; 2941 } /* hash ipv6_5tuple */ 2942 2943 if (strcmp(tokens[2], "ipv4_addr") == 0) { 2944 struct pkt_key_ipv4_addr *ipv4_addr = 2945 (struct pkt_key_ipv4_addr *) m->match.hash.key; 2946 struct in_addr addr; 2947 2948 if (n_tokens < 4) { 2949 snprintf(out, out_size, MSG_ARG_MISMATCH, 2950 tokens[0]); 2951 return 0; 2952 } 2953 2954 if (parse_ipv4_addr(tokens[3], &addr) != 0) { 2955 snprintf(out, out_size, MSG_ARG_INVALID, 2956 "addr"); 2957 return 0; 2958 } 2959 2960 ipv4_addr->addr = addr.s_addr; 2961 2962 return 4; 2963 } /* hash ipv4_addr */ 2964 2965 if (strcmp(tokens[2], "ipv6_addr") == 0) { 2966 struct pkt_key_ipv6_addr *ipv6_addr = 2967 (struct pkt_key_ipv6_addr *) m->match.hash.key; 2968 struct in6_addr addr; 2969 2970 if (n_tokens < 4) { 2971 snprintf(out, out_size, MSG_ARG_MISMATCH, 2972 tokens[0]); 2973 return 0; 2974 } 2975 2976 if (parse_ipv6_addr(tokens[3], &addr) != 0) { 2977 snprintf(out, out_size, MSG_ARG_INVALID, 2978 "addr"); 2979 return 0; 2980 } 2981 2982 memcpy(ipv6_addr->addr, addr.s6_addr, 16); 2983 2984 return 4; 2985 } /* hash ipv6_5tuple */ 2986 2987 if (strcmp(tokens[2], "qinq") == 0) { 2988 struct pkt_key_qinq *qinq = 2989 (struct pkt_key_qinq *) m->match.hash.key; 2990 uint16_t svlan, cvlan; 2991 2992 if (n_tokens < 5) { 2993 snprintf(out, out_size, MSG_ARG_MISMATCH, 2994 tokens[0]); 2995 return 0; 2996 } 2997 2998 if ((parser_read_uint16(&svlan, tokens[3]) != 0) || 2999 (svlan > 0xFFF)) { 3000 snprintf(out, out_size, MSG_ARG_INVALID, 3001 "svlan"); 3002 return 0; 3003 } 3004 3005 if ((parser_read_uint16(&cvlan, tokens[4]) != 0) || 3006 (cvlan > 0xFFF)) { 3007 snprintf(out, out_size, MSG_ARG_INVALID, 3008 "cvlan"); 3009 return 0; 3010 } 3011 3012 qinq->svlan = rte_cpu_to_be_16(svlan); 3013 qinq->cvlan = rte_cpu_to_be_16(cvlan); 3014 3015 return 5; 3016 } /* hash qinq */ 3017 3018 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 3019 return 0; 3020 } /* hash */ 3021 3022 if (strcmp(tokens[1], "lpm") == 0) { 3023 if (n_tokens < 5) { 3024 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 3025 return 0; 3026 } 3027 3028 m->match_type = TABLE_LPM; 3029 3030 if (strcmp(tokens[2], "ipv4") == 0) { 3031 struct in_addr addr; 3032 3033 m->match.lpm.ip_version = 1; 3034 3035 if (parse_ipv4_addr(tokens[3], &addr) != 0) { 3036 snprintf(out, out_size, MSG_ARG_INVALID, 3037 "addr"); 3038 return 0; 3039 } 3040 3041 m->match.lpm.ipv4 = rte_be_to_cpu_32(addr.s_addr); 3042 } else if (strcmp(tokens[2], "ipv6") == 0) { 3043 struct in6_addr addr; 3044 3045 m->match.lpm.ip_version = 0; 3046 3047 if (parse_ipv6_addr(tokens[3], &addr) != 0) { 3048 snprintf(out, out_size, MSG_ARG_INVALID, 3049 "addr"); 3050 return 0; 3051 } 3052 3053 memcpy(m->match.lpm.ipv6, addr.s6_addr, 16); 3054 } else { 3055 snprintf(out, out_size, MSG_ARG_MISMATCH, 3056 "ipv4 or ipv6"); 3057 return 0; 3058 } 3059 3060 if (parser_read_uint8(&m->match.lpm.depth, tokens[4]) != 0) { 3061 snprintf(out, out_size, MSG_ARG_INVALID, "depth"); 3062 return 0; 3063 } 3064 3065 return 5; 3066 } /* lpm */ 3067 3068 snprintf(out, out_size, MSG_ARG_MISMATCH, 3069 "acl or array or hash or lpm"); 3070 return 0; 3071 } 3072 3073 /** 3074 * table_action ::= 3075 * 3076 * action 3077 * fwd 3078 * drop 3079 * | port <port_id> 3080 * | meta 3081 * | table <table_id> 3082 * [balance <out0> ... <out7>] 3083 * [meter 3084 * tc0 meter <meter_profile_id> policer g <pa> y <pa> r <pa> 3085 * [tc1 meter <meter_profile_id> policer g <pa> y <pa> r <pa> 3086 * tc2 meter <meter_profile_id> policer g <pa> y <pa> r <pa> 3087 * tc3 meter <meter_profile_id> policer g <pa> y <pa> r <pa>]] 3088 * [tm subport <subport_id> pipe <pipe_id>] 3089 * [encap 3090 * ether <da> <sa> 3091 * | vlan <da> <sa> <pcp> <dei> <vid> 3092 * | qinq <da> <sa> <pcp> <dei> <vid> <pcp> <dei> <vid> 3093 * | mpls unicast | multicast 3094 * <da> <sa> 3095 * label0 <label> <tc> <ttl> 3096 * [label1 <label> <tc> <ttl> 3097 * [label2 <label> <tc> <ttl> 3098 * [label3 <label> <tc> <ttl>]]] 3099 * | pppoe <da> <sa> <session_id> 3100 * | vxlan ether <da> <sa> 3101 * [vlan <pcp> <dei> <vid>] 3102 * ipv4 <sa> <da> <dscp> <ttl> 3103 * | ipv6 <sa> <da> <flow_label> <dscp> <hop_limit> 3104 * udp <sp> <dp> 3105 * vxlan <vni>] 3106 * [nat ipv4 | ipv6 <addr> <port>] 3107 * [ttl dec | keep] 3108 * [stats] 3109 * [time] 3110 * [sym_crypto 3111 * encrypt | decrypt 3112 * type 3113 * | cipher 3114 * cipher_algo <algo> cipher_key <key> cipher_iv <iv> 3115 * | cipher_auth 3116 * cipher_algo <algo> cipher_key <key> cipher_iv <iv> 3117 * auth_algo <algo> auth_key <key> digest_size <size> 3118 * | aead 3119 * aead_algo <algo> aead_key <key> aead_iv <iv> aead_aad <aad> 3120 * digest_size <size> 3121 * data_offset <data_offset>] 3122 * [tag <tag>] 3123 * [decap <n>] 3124 * 3125 * where: 3126 * <pa> ::= g | y | r | drop 3127 */ 3128 static uint32_t 3129 parse_table_action_fwd(char **tokens, 3130 uint32_t n_tokens, 3131 struct table_rule_action *a) 3132 { 3133 if ((n_tokens == 0) || (strcmp(tokens[0], "fwd") != 0)) 3134 return 0; 3135 3136 tokens++; 3137 n_tokens--; 3138 3139 if (n_tokens && (strcmp(tokens[0], "drop") == 0)) { 3140 a->fwd.action = RTE_PIPELINE_ACTION_DROP; 3141 a->action_mask |= 1 << RTE_TABLE_ACTION_FWD; 3142 return 1 + 1; 3143 } 3144 3145 if (n_tokens && (strcmp(tokens[0], "port") == 0)) { 3146 uint32_t id; 3147 3148 if ((n_tokens < 2) || 3149 parser_read_uint32(&id, tokens[1])) 3150 return 0; 3151 3152 a->fwd.action = RTE_PIPELINE_ACTION_PORT; 3153 a->fwd.id = id; 3154 a->action_mask |= 1 << RTE_TABLE_ACTION_FWD; 3155 return 1 + 2; 3156 } 3157 3158 if (n_tokens && (strcmp(tokens[0], "meta") == 0)) { 3159 a->fwd.action = RTE_PIPELINE_ACTION_PORT_META; 3160 a->action_mask |= 1 << RTE_TABLE_ACTION_FWD; 3161 return 1 + 1; 3162 } 3163 3164 if (n_tokens && (strcmp(tokens[0], "table") == 0)) { 3165 uint32_t id; 3166 3167 if ((n_tokens < 2) || 3168 parser_read_uint32(&id, tokens[1])) 3169 return 0; 3170 3171 a->fwd.action = RTE_PIPELINE_ACTION_TABLE; 3172 a->fwd.id = id; 3173 a->action_mask |= 1 << RTE_TABLE_ACTION_FWD; 3174 return 1 + 2; 3175 } 3176 3177 return 0; 3178 } 3179 3180 static uint32_t 3181 parse_table_action_balance(char **tokens, 3182 uint32_t n_tokens, 3183 struct table_rule_action *a) 3184 { 3185 uint32_t i; 3186 3187 if ((n_tokens == 0) || (strcmp(tokens[0], "balance") != 0)) 3188 return 0; 3189 3190 tokens++; 3191 n_tokens--; 3192 3193 if (n_tokens < RTE_TABLE_ACTION_LB_TABLE_SIZE) 3194 return 0; 3195 3196 for (i = 0; i < RTE_TABLE_ACTION_LB_TABLE_SIZE; i++) 3197 if (parser_read_uint32(&a->lb.out[i], tokens[i]) != 0) 3198 return 0; 3199 3200 a->action_mask |= 1 << RTE_TABLE_ACTION_LB; 3201 return 1 + RTE_TABLE_ACTION_LB_TABLE_SIZE; 3202 3203 } 3204 3205 static int 3206 parse_policer_action(char *token, enum rte_table_action_policer *a) 3207 { 3208 if (strcmp(token, "g") == 0) { 3209 *a = RTE_TABLE_ACTION_POLICER_COLOR_GREEN; 3210 return 0; 3211 } 3212 3213 if (strcmp(token, "y") == 0) { 3214 *a = RTE_TABLE_ACTION_POLICER_COLOR_YELLOW; 3215 return 0; 3216 } 3217 3218 if (strcmp(token, "r") == 0) { 3219 *a = RTE_TABLE_ACTION_POLICER_COLOR_RED; 3220 return 0; 3221 } 3222 3223 if (strcmp(token, "drop") == 0) { 3224 *a = RTE_TABLE_ACTION_POLICER_DROP; 3225 return 0; 3226 } 3227 3228 return -1; 3229 } 3230 3231 static uint32_t 3232 parse_table_action_meter_tc(char **tokens, 3233 uint32_t n_tokens, 3234 struct rte_table_action_mtr_tc_params *mtr) 3235 { 3236 if ((n_tokens < 9) || 3237 strcmp(tokens[0], "meter") || 3238 parser_read_uint32(&mtr->meter_profile_id, tokens[1]) || 3239 strcmp(tokens[2], "policer") || 3240 strcmp(tokens[3], "g") || 3241 parse_policer_action(tokens[4], &mtr->policer[e_RTE_METER_GREEN]) || 3242 strcmp(tokens[5], "y") || 3243 parse_policer_action(tokens[6], &mtr->policer[e_RTE_METER_YELLOW]) || 3244 strcmp(tokens[7], "r") || 3245 parse_policer_action(tokens[8], &mtr->policer[e_RTE_METER_RED])) 3246 return 0; 3247 3248 return 9; 3249 } 3250 3251 static uint32_t 3252 parse_table_action_meter(char **tokens, 3253 uint32_t n_tokens, 3254 struct table_rule_action *a) 3255 { 3256 if ((n_tokens == 0) || strcmp(tokens[0], "meter")) 3257 return 0; 3258 3259 tokens++; 3260 n_tokens--; 3261 3262 if ((n_tokens < 10) || 3263 strcmp(tokens[0], "tc0") || 3264 (parse_table_action_meter_tc(tokens + 1, 3265 n_tokens - 1, 3266 &a->mtr.mtr[0]) == 0)) 3267 return 0; 3268 3269 tokens += 10; 3270 n_tokens -= 10; 3271 3272 if ((n_tokens == 0) || strcmp(tokens[0], "tc1")) { 3273 a->mtr.tc_mask = 1; 3274 a->action_mask |= 1 << RTE_TABLE_ACTION_MTR; 3275 return 1 + 10; 3276 } 3277 3278 if ((n_tokens < 30) || 3279 (parse_table_action_meter_tc(tokens + 1, 3280 n_tokens - 1, &a->mtr.mtr[1]) == 0) || 3281 strcmp(tokens[10], "tc2") || 3282 (parse_table_action_meter_tc(tokens + 11, 3283 n_tokens - 11, &a->mtr.mtr[2]) == 0) || 3284 strcmp(tokens[20], "tc3") || 3285 (parse_table_action_meter_tc(tokens + 21, 3286 n_tokens - 21, &a->mtr.mtr[3]) == 0)) 3287 return 0; 3288 3289 a->mtr.tc_mask = 0xF; 3290 a->action_mask |= 1 << RTE_TABLE_ACTION_MTR; 3291 return 1 + 10 + 3 * 10; 3292 } 3293 3294 static uint32_t 3295 parse_table_action_tm(char **tokens, 3296 uint32_t n_tokens, 3297 struct table_rule_action *a) 3298 { 3299 uint32_t subport_id, pipe_id; 3300 3301 if ((n_tokens < 5) || 3302 strcmp(tokens[0], "tm") || 3303 strcmp(tokens[1], "subport") || 3304 parser_read_uint32(&subport_id, tokens[2]) || 3305 strcmp(tokens[3], "pipe") || 3306 parser_read_uint32(&pipe_id, tokens[4])) 3307 return 0; 3308 3309 a->tm.subport_id = subport_id; 3310 a->tm.pipe_id = pipe_id; 3311 a->action_mask |= 1 << RTE_TABLE_ACTION_TM; 3312 return 5; 3313 } 3314 3315 static uint32_t 3316 parse_table_action_encap(char **tokens, 3317 uint32_t n_tokens, 3318 struct table_rule_action *a) 3319 { 3320 if ((n_tokens == 0) || strcmp(tokens[0], "encap")) 3321 return 0; 3322 3323 tokens++; 3324 n_tokens--; 3325 3326 /* ether */ 3327 if (n_tokens && (strcmp(tokens[0], "ether") == 0)) { 3328 if ((n_tokens < 3) || 3329 parse_mac_addr(tokens[1], &a->encap.ether.ether.da) || 3330 parse_mac_addr(tokens[2], &a->encap.ether.ether.sa)) 3331 return 0; 3332 3333 a->encap.type = RTE_TABLE_ACTION_ENCAP_ETHER; 3334 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP; 3335 return 1 + 3; 3336 } 3337 3338 /* vlan */ 3339 if (n_tokens && (strcmp(tokens[0], "vlan") == 0)) { 3340 uint32_t pcp, dei, vid; 3341 3342 if ((n_tokens < 6) || 3343 parse_mac_addr(tokens[1], &a->encap.vlan.ether.da) || 3344 parse_mac_addr(tokens[2], &a->encap.vlan.ether.sa) || 3345 parser_read_uint32(&pcp, tokens[3]) || 3346 (pcp > 0x7) || 3347 parser_read_uint32(&dei, tokens[4]) || 3348 (dei > 0x1) || 3349 parser_read_uint32(&vid, tokens[5]) || 3350 (vid > 0xFFF)) 3351 return 0; 3352 3353 a->encap.vlan.vlan.pcp = pcp & 0x7; 3354 a->encap.vlan.vlan.dei = dei & 0x1; 3355 a->encap.vlan.vlan.vid = vid & 0xFFF; 3356 a->encap.type = RTE_TABLE_ACTION_ENCAP_VLAN; 3357 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP; 3358 return 1 + 6; 3359 } 3360 3361 /* qinq */ 3362 if (n_tokens && (strcmp(tokens[0], "qinq") == 0)) { 3363 uint32_t svlan_pcp, svlan_dei, svlan_vid; 3364 uint32_t cvlan_pcp, cvlan_dei, cvlan_vid; 3365 3366 if ((n_tokens < 9) || 3367 parse_mac_addr(tokens[1], &a->encap.qinq.ether.da) || 3368 parse_mac_addr(tokens[2], &a->encap.qinq.ether.sa) || 3369 parser_read_uint32(&svlan_pcp, tokens[3]) || 3370 (svlan_pcp > 0x7) || 3371 parser_read_uint32(&svlan_dei, tokens[4]) || 3372 (svlan_dei > 0x1) || 3373 parser_read_uint32(&svlan_vid, tokens[5]) || 3374 (svlan_vid > 0xFFF) || 3375 parser_read_uint32(&cvlan_pcp, tokens[6]) || 3376 (cvlan_pcp > 0x7) || 3377 parser_read_uint32(&cvlan_dei, tokens[7]) || 3378 (cvlan_dei > 0x1) || 3379 parser_read_uint32(&cvlan_vid, tokens[8]) || 3380 (cvlan_vid > 0xFFF)) 3381 return 0; 3382 3383 a->encap.qinq.svlan.pcp = svlan_pcp & 0x7; 3384 a->encap.qinq.svlan.dei = svlan_dei & 0x1; 3385 a->encap.qinq.svlan.vid = svlan_vid & 0xFFF; 3386 a->encap.qinq.cvlan.pcp = cvlan_pcp & 0x7; 3387 a->encap.qinq.cvlan.dei = cvlan_dei & 0x1; 3388 a->encap.qinq.cvlan.vid = cvlan_vid & 0xFFF; 3389 a->encap.type = RTE_TABLE_ACTION_ENCAP_QINQ; 3390 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP; 3391 return 1 + 9; 3392 } 3393 3394 /* mpls */ 3395 if (n_tokens && (strcmp(tokens[0], "mpls") == 0)) { 3396 uint32_t label, tc, ttl; 3397 3398 if (n_tokens < 8) 3399 return 0; 3400 3401 if (strcmp(tokens[1], "unicast") == 0) 3402 a->encap.mpls.unicast = 1; 3403 else if (strcmp(tokens[1], "multicast") == 0) 3404 a->encap.mpls.unicast = 0; 3405 else 3406 return 0; 3407 3408 if (parse_mac_addr(tokens[2], &a->encap.mpls.ether.da) || 3409 parse_mac_addr(tokens[3], &a->encap.mpls.ether.sa) || 3410 strcmp(tokens[4], "label0") || 3411 parser_read_uint32(&label, tokens[5]) || 3412 (label > 0xFFFFF) || 3413 parser_read_uint32(&tc, tokens[6]) || 3414 (tc > 0x7) || 3415 parser_read_uint32(&ttl, tokens[7]) || 3416 (ttl > 0x3F)) 3417 return 0; 3418 3419 a->encap.mpls.mpls[0].label = label; 3420 a->encap.mpls.mpls[0].tc = tc; 3421 a->encap.mpls.mpls[0].ttl = ttl; 3422 3423 tokens += 8; 3424 n_tokens -= 8; 3425 3426 if ((n_tokens == 0) || strcmp(tokens[0], "label1")) { 3427 a->encap.mpls.mpls_count = 1; 3428 a->encap.type = RTE_TABLE_ACTION_ENCAP_MPLS; 3429 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP; 3430 return 1 + 8; 3431 } 3432 3433 if ((n_tokens < 4) || 3434 parser_read_uint32(&label, tokens[1]) || 3435 (label > 0xFFFFF) || 3436 parser_read_uint32(&tc, tokens[2]) || 3437 (tc > 0x7) || 3438 parser_read_uint32(&ttl, tokens[3]) || 3439 (ttl > 0x3F)) 3440 return 0; 3441 3442 a->encap.mpls.mpls[1].label = label; 3443 a->encap.mpls.mpls[1].tc = tc; 3444 a->encap.mpls.mpls[1].ttl = ttl; 3445 3446 tokens += 4; 3447 n_tokens -= 4; 3448 3449 if ((n_tokens == 0) || strcmp(tokens[0], "label2")) { 3450 a->encap.mpls.mpls_count = 2; 3451 a->encap.type = RTE_TABLE_ACTION_ENCAP_MPLS; 3452 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP; 3453 return 1 + 8 + 4; 3454 } 3455 3456 if ((n_tokens < 4) || 3457 parser_read_uint32(&label, tokens[1]) || 3458 (label > 0xFFFFF) || 3459 parser_read_uint32(&tc, tokens[2]) || 3460 (tc > 0x7) || 3461 parser_read_uint32(&ttl, tokens[3]) || 3462 (ttl > 0x3F)) 3463 return 0; 3464 3465 a->encap.mpls.mpls[2].label = label; 3466 a->encap.mpls.mpls[2].tc = tc; 3467 a->encap.mpls.mpls[2].ttl = ttl; 3468 3469 tokens += 4; 3470 n_tokens -= 4; 3471 3472 if ((n_tokens == 0) || strcmp(tokens[0], "label3")) { 3473 a->encap.mpls.mpls_count = 3; 3474 a->encap.type = RTE_TABLE_ACTION_ENCAP_MPLS; 3475 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP; 3476 return 1 + 8 + 4 + 4; 3477 } 3478 3479 if ((n_tokens < 4) || 3480 parser_read_uint32(&label, tokens[1]) || 3481 (label > 0xFFFFF) || 3482 parser_read_uint32(&tc, tokens[2]) || 3483 (tc > 0x7) || 3484 parser_read_uint32(&ttl, tokens[3]) || 3485 (ttl > 0x3F)) 3486 return 0; 3487 3488 a->encap.mpls.mpls[3].label = label; 3489 a->encap.mpls.mpls[3].tc = tc; 3490 a->encap.mpls.mpls[3].ttl = ttl; 3491 3492 a->encap.mpls.mpls_count = 4; 3493 a->encap.type = RTE_TABLE_ACTION_ENCAP_MPLS; 3494 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP; 3495 return 1 + 8 + 4 + 4 + 4; 3496 } 3497 3498 /* pppoe */ 3499 if (n_tokens && (strcmp(tokens[0], "pppoe") == 0)) { 3500 if ((n_tokens < 4) || 3501 parse_mac_addr(tokens[1], &a->encap.pppoe.ether.da) || 3502 parse_mac_addr(tokens[2], &a->encap.pppoe.ether.sa) || 3503 parser_read_uint16(&a->encap.pppoe.pppoe.session_id, 3504 tokens[3])) 3505 return 0; 3506 3507 a->encap.type = RTE_TABLE_ACTION_ENCAP_PPPOE; 3508 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP; 3509 return 1 + 4; 3510 } 3511 3512 /* vxlan */ 3513 if (n_tokens && (strcmp(tokens[0], "vxlan") == 0)) { 3514 uint32_t n = 0; 3515 3516 n_tokens--; 3517 tokens++; 3518 n++; 3519 3520 /* ether <da> <sa> */ 3521 if ((n_tokens < 3) || 3522 strcmp(tokens[0], "ether") || 3523 parse_mac_addr(tokens[1], &a->encap.vxlan.ether.da) || 3524 parse_mac_addr(tokens[2], &a->encap.vxlan.ether.sa)) 3525 return 0; 3526 3527 n_tokens -= 3; 3528 tokens += 3; 3529 n += 3; 3530 3531 /* [vlan <pcp> <dei> <vid>] */ 3532 if (strcmp(tokens[0], "vlan") == 0) { 3533 uint32_t pcp, dei, vid; 3534 3535 if ((n_tokens < 4) || 3536 parser_read_uint32(&pcp, tokens[1]) || 3537 (pcp > 7) || 3538 parser_read_uint32(&dei, tokens[2]) || 3539 (dei > 1) || 3540 parser_read_uint32(&vid, tokens[3]) || 3541 (vid > 0xFFF)) 3542 return 0; 3543 3544 a->encap.vxlan.vlan.pcp = pcp; 3545 a->encap.vxlan.vlan.dei = dei; 3546 a->encap.vxlan.vlan.vid = vid; 3547 3548 n_tokens -= 4; 3549 tokens += 4; 3550 n += 4; 3551 } 3552 3553 /* ipv4 <sa> <da> <dscp> <ttl> 3554 | ipv6 <sa> <da> <flow_label> <dscp> <hop_limit> */ 3555 if (strcmp(tokens[0], "ipv4") == 0) { 3556 struct in_addr sa, da; 3557 uint8_t dscp, ttl; 3558 3559 if ((n_tokens < 5) || 3560 parse_ipv4_addr(tokens[1], &sa) || 3561 parse_ipv4_addr(tokens[2], &da) || 3562 parser_read_uint8(&dscp, tokens[3]) || 3563 (dscp > 64) || 3564 parser_read_uint8(&ttl, tokens[4])) 3565 return 0; 3566 3567 a->encap.vxlan.ipv4.sa = rte_be_to_cpu_32(sa.s_addr); 3568 a->encap.vxlan.ipv4.da = rte_be_to_cpu_32(da.s_addr); 3569 a->encap.vxlan.ipv4.dscp = dscp; 3570 a->encap.vxlan.ipv4.ttl = ttl; 3571 3572 n_tokens -= 5; 3573 tokens += 5; 3574 n += 5; 3575 } else if (strcmp(tokens[0], "ipv6") == 0) { 3576 struct in6_addr sa, da; 3577 uint32_t flow_label; 3578 uint8_t dscp, hop_limit; 3579 3580 if ((n_tokens < 6) || 3581 parse_ipv6_addr(tokens[1], &sa) || 3582 parse_ipv6_addr(tokens[2], &da) || 3583 parser_read_uint32(&flow_label, tokens[3]) || 3584 parser_read_uint8(&dscp, tokens[4]) || 3585 (dscp > 64) || 3586 parser_read_uint8(&hop_limit, tokens[5])) 3587 return 0; 3588 3589 memcpy(a->encap.vxlan.ipv6.sa, sa.s6_addr, 16); 3590 memcpy(a->encap.vxlan.ipv6.da, da.s6_addr, 16); 3591 a->encap.vxlan.ipv6.flow_label = flow_label; 3592 a->encap.vxlan.ipv6.dscp = dscp; 3593 a->encap.vxlan.ipv6.hop_limit = hop_limit; 3594 3595 n_tokens -= 6; 3596 tokens += 6; 3597 n += 6; 3598 } else 3599 return 0; 3600 3601 /* udp <sp> <dp> */ 3602 if ((n_tokens < 3) || 3603 strcmp(tokens[0], "udp") || 3604 parser_read_uint16(&a->encap.vxlan.udp.sp, tokens[1]) || 3605 parser_read_uint16(&a->encap.vxlan.udp.dp, tokens[2])) 3606 return 0; 3607 3608 n_tokens -= 3; 3609 tokens += 3; 3610 n += 3; 3611 3612 /* vxlan <vni> */ 3613 if ((n_tokens < 2) || 3614 strcmp(tokens[0], "vxlan") || 3615 parser_read_uint32(&a->encap.vxlan.vxlan.vni, tokens[1]) || 3616 (a->encap.vxlan.vxlan.vni > 0xFFFFFF)) 3617 return 0; 3618 3619 n_tokens -= 2; 3620 tokens += 2; 3621 n += 2; 3622 3623 a->encap.type = RTE_TABLE_ACTION_ENCAP_VXLAN; 3624 a->action_mask |= 1 << RTE_TABLE_ACTION_ENCAP; 3625 return 1 + n; 3626 } 3627 3628 return 0; 3629 } 3630 3631 static uint32_t 3632 parse_table_action_nat(char **tokens, 3633 uint32_t n_tokens, 3634 struct table_rule_action *a) 3635 { 3636 if ((n_tokens < 4) || 3637 strcmp(tokens[0], "nat")) 3638 return 0; 3639 3640 if (strcmp(tokens[1], "ipv4") == 0) { 3641 struct in_addr addr; 3642 uint16_t port; 3643 3644 if (parse_ipv4_addr(tokens[2], &addr) || 3645 parser_read_uint16(&port, tokens[3])) 3646 return 0; 3647 3648 a->nat.ip_version = 1; 3649 a->nat.addr.ipv4 = rte_be_to_cpu_32(addr.s_addr); 3650 a->nat.port = port; 3651 a->action_mask |= 1 << RTE_TABLE_ACTION_NAT; 3652 return 4; 3653 } 3654 3655 if (strcmp(tokens[1], "ipv6") == 0) { 3656 struct in6_addr addr; 3657 uint16_t port; 3658 3659 if (parse_ipv6_addr(tokens[2], &addr) || 3660 parser_read_uint16(&port, tokens[3])) 3661 return 0; 3662 3663 a->nat.ip_version = 0; 3664 memcpy(a->nat.addr.ipv6, addr.s6_addr, 16); 3665 a->nat.port = port; 3666 a->action_mask |= 1 << RTE_TABLE_ACTION_NAT; 3667 return 4; 3668 } 3669 3670 return 0; 3671 } 3672 3673 static uint32_t 3674 parse_table_action_ttl(char **tokens, 3675 uint32_t n_tokens, 3676 struct table_rule_action *a) 3677 { 3678 if ((n_tokens < 2) || 3679 strcmp(tokens[0], "ttl")) 3680 return 0; 3681 3682 if (strcmp(tokens[1], "dec") == 0) 3683 a->ttl.decrement = 1; 3684 else if (strcmp(tokens[1], "keep") == 0) 3685 a->ttl.decrement = 0; 3686 else 3687 return 0; 3688 3689 a->action_mask |= 1 << RTE_TABLE_ACTION_TTL; 3690 return 2; 3691 } 3692 3693 static uint32_t 3694 parse_table_action_stats(char **tokens, 3695 uint32_t n_tokens, 3696 struct table_rule_action *a) 3697 { 3698 if ((n_tokens < 1) || 3699 strcmp(tokens[0], "stats")) 3700 return 0; 3701 3702 a->stats.n_packets = 0; 3703 a->stats.n_bytes = 0; 3704 a->action_mask |= 1 << RTE_TABLE_ACTION_STATS; 3705 return 1; 3706 } 3707 3708 static uint32_t 3709 parse_table_action_time(char **tokens, 3710 uint32_t n_tokens, 3711 struct table_rule_action *a) 3712 { 3713 if ((n_tokens < 1) || 3714 strcmp(tokens[0], "time")) 3715 return 0; 3716 3717 a->time.time = rte_rdtsc(); 3718 a->action_mask |= 1 << RTE_TABLE_ACTION_TIME; 3719 return 1; 3720 } 3721 3722 static void 3723 parse_free_sym_crypto_param_data(struct rte_table_action_sym_crypto_params *p) 3724 { 3725 struct rte_crypto_sym_xform *xform[2] = {NULL}; 3726 uint32_t i; 3727 3728 xform[0] = p->xform; 3729 if (xform[0]) 3730 xform[1] = xform[0]->next; 3731 3732 for (i = 0; i < 2; i++) { 3733 if (xform[i] == NULL) 3734 continue; 3735 3736 switch (xform[i]->type) { 3737 case RTE_CRYPTO_SYM_XFORM_CIPHER: 3738 if (xform[i]->cipher.key.data) 3739 free(xform[i]->cipher.key.data); 3740 if (p->cipher_auth.cipher_iv.val) 3741 free(p->cipher_auth.cipher_iv.val); 3742 if (p->cipher_auth.cipher_iv_update.val) 3743 free(p->cipher_auth.cipher_iv_update.val); 3744 break; 3745 case RTE_CRYPTO_SYM_XFORM_AUTH: 3746 if (xform[i]->auth.key.data) 3747 free(xform[i]->cipher.key.data); 3748 if (p->cipher_auth.auth_iv.val) 3749 free(p->cipher_auth.cipher_iv.val); 3750 if (p->cipher_auth.auth_iv_update.val) 3751 free(p->cipher_auth.cipher_iv_update.val); 3752 break; 3753 case RTE_CRYPTO_SYM_XFORM_AEAD: 3754 if (xform[i]->aead.key.data) 3755 free(xform[i]->cipher.key.data); 3756 if (p->aead.iv.val) 3757 free(p->aead.iv.val); 3758 if (p->aead.aad.val) 3759 free(p->aead.aad.val); 3760 break; 3761 default: 3762 continue; 3763 } 3764 } 3765 3766 } 3767 3768 static struct rte_crypto_sym_xform * 3769 parse_table_action_cipher(struct rte_table_action_sym_crypto_params *p, 3770 char **tokens, uint32_t n_tokens, uint32_t encrypt, 3771 uint32_t *used_n_tokens) 3772 { 3773 struct rte_crypto_sym_xform *xform_cipher; 3774 int status; 3775 size_t len; 3776 3777 if (n_tokens < 7 || strcmp(tokens[1], "cipher_algo") || 3778 strcmp(tokens[3], "cipher_key") || 3779 strcmp(tokens[5], "cipher_iv")) 3780 return NULL; 3781 3782 xform_cipher = calloc(1, sizeof(*xform_cipher)); 3783 if (xform_cipher == NULL) 3784 return NULL; 3785 3786 xform_cipher->type = RTE_CRYPTO_SYM_XFORM_CIPHER; 3787 xform_cipher->cipher.op = encrypt ? RTE_CRYPTO_CIPHER_OP_ENCRYPT : 3788 RTE_CRYPTO_CIPHER_OP_DECRYPT; 3789 3790 /* cipher_algo */ 3791 status = rte_cryptodev_get_cipher_algo_enum( 3792 &xform_cipher->cipher.algo, tokens[2]); 3793 if (status < 0) 3794 goto error_exit; 3795 3796 /* cipher_key */ 3797 len = strlen(tokens[4]); 3798 xform_cipher->cipher.key.data = calloc(1, len / 2 + 1); 3799 if (xform_cipher->cipher.key.data == NULL) 3800 goto error_exit; 3801 3802 status = parse_hex_string(tokens[4], 3803 xform_cipher->cipher.key.data, 3804 (uint32_t *)&len); 3805 if (status < 0) 3806 goto error_exit; 3807 3808 xform_cipher->cipher.key.length = (uint16_t)len; 3809 3810 /* cipher_iv */ 3811 len = strlen(tokens[6]); 3812 3813 p->cipher_auth.cipher_iv.val = calloc(1, len / 2 + 1); 3814 if (p->cipher_auth.cipher_iv.val == NULL) 3815 goto error_exit; 3816 3817 status = parse_hex_string(tokens[6], 3818 p->cipher_auth.cipher_iv.val, 3819 (uint32_t *)&len); 3820 if (status < 0) 3821 goto error_exit; 3822 3823 xform_cipher->cipher.iv.length = (uint16_t)len; 3824 xform_cipher->cipher.iv.offset = RTE_TABLE_ACTION_SYM_CRYPTO_IV_OFFSET; 3825 p->cipher_auth.cipher_iv.length = (uint32_t)len; 3826 *used_n_tokens = 7; 3827 3828 return xform_cipher; 3829 3830 error_exit: 3831 if (xform_cipher->cipher.key.data) 3832 free(xform_cipher->cipher.key.data); 3833 3834 if (p->cipher_auth.cipher_iv.val) { 3835 free(p->cipher_auth.cipher_iv.val); 3836 p->cipher_auth.cipher_iv.val = NULL; 3837 } 3838 3839 free(xform_cipher); 3840 3841 return NULL; 3842 } 3843 3844 static struct rte_crypto_sym_xform * 3845 parse_table_action_cipher_auth(struct rte_table_action_sym_crypto_params *p, 3846 char **tokens, uint32_t n_tokens, uint32_t encrypt, 3847 uint32_t *used_n_tokens) 3848 { 3849 struct rte_crypto_sym_xform *xform_cipher; 3850 struct rte_crypto_sym_xform *xform_auth; 3851 int status; 3852 size_t len; 3853 3854 if (n_tokens < 13 || 3855 strcmp(tokens[7], "auth_algo") || 3856 strcmp(tokens[9], "auth_key") || 3857 strcmp(tokens[11], "digest_size")) 3858 return NULL; 3859 3860 xform_auth = calloc(1, sizeof(*xform_auth)); 3861 if (xform_auth == NULL) 3862 return NULL; 3863 3864 xform_auth->type = RTE_CRYPTO_SYM_XFORM_AUTH; 3865 xform_auth->auth.op = encrypt ? RTE_CRYPTO_AUTH_OP_GENERATE : 3866 RTE_CRYPTO_AUTH_OP_VERIFY; 3867 3868 /* auth_algo */ 3869 status = rte_cryptodev_get_auth_algo_enum(&xform_auth->auth.algo, 3870 tokens[8]); 3871 if (status < 0) 3872 goto error_exit; 3873 3874 /* auth_key */ 3875 len = strlen(tokens[10]); 3876 xform_auth->auth.key.data = calloc(1, len / 2 + 1); 3877 if (xform_auth->auth.key.data == NULL) 3878 goto error_exit; 3879 3880 status = parse_hex_string(tokens[10], 3881 xform_auth->auth.key.data, (uint32_t *)&len); 3882 if (status < 0) 3883 goto error_exit; 3884 3885 xform_auth->auth.key.length = (uint16_t)len; 3886 3887 if (strcmp(tokens[11], "digest_size")) 3888 goto error_exit; 3889 3890 status = parser_read_uint16(&xform_auth->auth.digest_length, 3891 tokens[12]); 3892 if (status < 0) 3893 goto error_exit; 3894 3895 xform_cipher = parse_table_action_cipher(p, tokens, 7, encrypt, 3896 used_n_tokens); 3897 if (xform_cipher == NULL) 3898 goto error_exit; 3899 3900 *used_n_tokens += 6; 3901 3902 if (encrypt) { 3903 xform_cipher->next = xform_auth; 3904 return xform_cipher; 3905 } else { 3906 xform_auth->next = xform_cipher; 3907 return xform_auth; 3908 } 3909 3910 error_exit: 3911 if (xform_auth->auth.key.data) 3912 free(xform_auth->auth.key.data); 3913 if (p->cipher_auth.auth_iv.val) { 3914 free(p->cipher_auth.auth_iv.val); 3915 p->cipher_auth.auth_iv.val = 0; 3916 } 3917 3918 free(xform_auth); 3919 3920 return NULL; 3921 } 3922 3923 static struct rte_crypto_sym_xform * 3924 parse_table_action_aead(struct rte_table_action_sym_crypto_params *p, 3925 char **tokens, uint32_t n_tokens, uint32_t encrypt, 3926 uint32_t *used_n_tokens) 3927 { 3928 struct rte_crypto_sym_xform *xform_aead; 3929 int status; 3930 size_t len; 3931 3932 if (n_tokens < 11 || strcmp(tokens[1], "aead_algo") || 3933 strcmp(tokens[3], "aead_key") || 3934 strcmp(tokens[5], "aead_iv") || 3935 strcmp(tokens[7], "aead_aad") || 3936 strcmp(tokens[9], "digest_size")) 3937 return NULL; 3938 3939 xform_aead = calloc(1, sizeof(*xform_aead)); 3940 if (xform_aead == NULL) 3941 return NULL; 3942 3943 xform_aead->type = RTE_CRYPTO_SYM_XFORM_AEAD; 3944 xform_aead->aead.op = encrypt ? RTE_CRYPTO_AEAD_OP_ENCRYPT : 3945 RTE_CRYPTO_AEAD_OP_DECRYPT; 3946 3947 /* aead_algo */ 3948 status = rte_cryptodev_get_aead_algo_enum(&xform_aead->aead.algo, 3949 tokens[2]); 3950 if (status < 0) 3951 goto error_exit; 3952 3953 /* aead_key */ 3954 len = strlen(tokens[4]); 3955 xform_aead->aead.key.data = calloc(1, len / 2 + 1); 3956 if (xform_aead->aead.key.data == NULL) 3957 goto error_exit; 3958 3959 status = parse_hex_string(tokens[4], xform_aead->aead.key.data, 3960 (uint32_t *)&len); 3961 if (status < 0) 3962 goto error_exit; 3963 3964 xform_aead->aead.key.length = (uint16_t)len; 3965 3966 /* aead_iv */ 3967 len = strlen(tokens[6]); 3968 p->aead.iv.val = calloc(1, len / 2 + 1); 3969 if (p->aead.iv.val == NULL) 3970 goto error_exit; 3971 3972 status = parse_hex_string(tokens[6], p->aead.iv.val, 3973 (uint32_t *)&len); 3974 if (status < 0) 3975 goto error_exit; 3976 3977 xform_aead->aead.iv.length = (uint16_t)len; 3978 xform_aead->aead.iv.offset = RTE_TABLE_ACTION_SYM_CRYPTO_IV_OFFSET; 3979 p->aead.iv.length = (uint32_t)len; 3980 3981 /* aead_aad */ 3982 len = strlen(tokens[8]); 3983 p->aead.aad.val = calloc(1, len / 2 + 1); 3984 if (p->aead.aad.val == NULL) 3985 goto error_exit; 3986 3987 status = parse_hex_string(tokens[8], p->aead.aad.val, (uint32_t *)&len); 3988 if (status < 0) 3989 goto error_exit; 3990 3991 xform_aead->aead.aad_length = (uint16_t)len; 3992 p->aead.aad.length = (uint32_t)len; 3993 3994 /* digest_size */ 3995 status = parser_read_uint16(&xform_aead->aead.digest_length, 3996 tokens[10]); 3997 if (status < 0) 3998 goto error_exit; 3999 4000 *used_n_tokens = 11; 4001 4002 return xform_aead; 4003 4004 error_exit: 4005 if (xform_aead->aead.key.data) 4006 free(xform_aead->aead.key.data); 4007 if (p->aead.iv.val) { 4008 free(p->aead.iv.val); 4009 p->aead.iv.val = NULL; 4010 } 4011 if (p->aead.aad.val) { 4012 free(p->aead.aad.val); 4013 p->aead.aad.val = NULL; 4014 } 4015 4016 free(xform_aead); 4017 4018 return NULL; 4019 } 4020 4021 4022 static uint32_t 4023 parse_table_action_sym_crypto(char **tokens, 4024 uint32_t n_tokens, 4025 struct table_rule_action *a) 4026 { 4027 struct rte_table_action_sym_crypto_params *p = &a->sym_crypto; 4028 struct rte_crypto_sym_xform *xform = NULL; 4029 uint32_t used_n_tokens; 4030 uint32_t encrypt; 4031 int status; 4032 4033 if ((n_tokens < 12) || 4034 strcmp(tokens[0], "sym_crypto") || 4035 strcmp(tokens[2], "type")) 4036 return 0; 4037 4038 memset(p, 0, sizeof(*p)); 4039 4040 if (strcmp(tokens[1], "encrypt") == 0) 4041 encrypt = 1; 4042 else 4043 encrypt = 0; 4044 4045 status = parser_read_uint32(&p->data_offset, tokens[n_tokens - 1]); 4046 if (status < 0) 4047 return 0; 4048 4049 if (strcmp(tokens[3], "cipher") == 0) { 4050 tokens += 3; 4051 n_tokens -= 3; 4052 4053 xform = parse_table_action_cipher(p, tokens, n_tokens, encrypt, 4054 &used_n_tokens); 4055 } else if (strcmp(tokens[3], "cipher_auth") == 0) { 4056 tokens += 3; 4057 n_tokens -= 3; 4058 4059 xform = parse_table_action_cipher_auth(p, tokens, n_tokens, 4060 encrypt, &used_n_tokens); 4061 } else if (strcmp(tokens[3], "aead") == 0) { 4062 tokens += 3; 4063 n_tokens -= 3; 4064 4065 xform = parse_table_action_aead(p, tokens, n_tokens, encrypt, 4066 &used_n_tokens); 4067 } 4068 4069 if (xform == NULL) 4070 return 0; 4071 4072 p->xform = xform; 4073 4074 if (strcmp(tokens[used_n_tokens], "data_offset")) { 4075 parse_free_sym_crypto_param_data(p); 4076 return 0; 4077 } 4078 4079 a->action_mask |= 1 << RTE_TABLE_ACTION_SYM_CRYPTO; 4080 4081 return used_n_tokens + 5; 4082 } 4083 4084 static uint32_t 4085 parse_table_action_tag(char **tokens, 4086 uint32_t n_tokens, 4087 struct table_rule_action *a) 4088 { 4089 if ((n_tokens < 2) || 4090 strcmp(tokens[0], "tag")) 4091 return 0; 4092 4093 if (parser_read_uint32(&a->tag.tag, tokens[1])) 4094 return 0; 4095 4096 a->action_mask |= 1 << RTE_TABLE_ACTION_TAG; 4097 return 2; 4098 } 4099 4100 static uint32_t 4101 parse_table_action_decap(char **tokens, 4102 uint32_t n_tokens, 4103 struct table_rule_action *a) 4104 { 4105 if ((n_tokens < 2) || 4106 strcmp(tokens[0], "decap")) 4107 return 0; 4108 4109 if (parser_read_uint16(&a->decap.n, tokens[1])) 4110 return 0; 4111 4112 a->action_mask |= 1 << RTE_TABLE_ACTION_DECAP; 4113 return 2; 4114 } 4115 4116 static uint32_t 4117 parse_table_action(char **tokens, 4118 uint32_t n_tokens, 4119 char *out, 4120 size_t out_size, 4121 struct table_rule_action *a) 4122 { 4123 uint32_t n_tokens0 = n_tokens; 4124 4125 memset(a, 0, sizeof(*a)); 4126 4127 if ((n_tokens < 2) || 4128 strcmp(tokens[0], "action")) 4129 return 0; 4130 4131 tokens++; 4132 n_tokens--; 4133 4134 if (n_tokens && (strcmp(tokens[0], "fwd") == 0)) { 4135 uint32_t n; 4136 4137 n = parse_table_action_fwd(tokens, n_tokens, a); 4138 if (n == 0) { 4139 snprintf(out, out_size, MSG_ARG_INVALID, 4140 "action fwd"); 4141 return 0; 4142 } 4143 4144 tokens += n; 4145 n_tokens -= n; 4146 } 4147 4148 if (n_tokens && (strcmp(tokens[0], "balance") == 0)) { 4149 uint32_t n; 4150 4151 n = parse_table_action_balance(tokens, n_tokens, a); 4152 if (n == 0) { 4153 snprintf(out, out_size, MSG_ARG_INVALID, 4154 "action balance"); 4155 return 0; 4156 } 4157 4158 tokens += n; 4159 n_tokens -= n; 4160 } 4161 4162 if (n_tokens && (strcmp(tokens[0], "meter") == 0)) { 4163 uint32_t n; 4164 4165 n = parse_table_action_meter(tokens, n_tokens, a); 4166 if (n == 0) { 4167 snprintf(out, out_size, MSG_ARG_INVALID, 4168 "action meter"); 4169 return 0; 4170 } 4171 4172 tokens += n; 4173 n_tokens -= n; 4174 } 4175 4176 if (n_tokens && (strcmp(tokens[0], "tm") == 0)) { 4177 uint32_t n; 4178 4179 n = parse_table_action_tm(tokens, n_tokens, a); 4180 if (n == 0) { 4181 snprintf(out, out_size, MSG_ARG_INVALID, 4182 "action tm"); 4183 return 0; 4184 } 4185 4186 tokens += n; 4187 n_tokens -= n; 4188 } 4189 4190 if (n_tokens && (strcmp(tokens[0], "encap") == 0)) { 4191 uint32_t n; 4192 4193 n = parse_table_action_encap(tokens, n_tokens, a); 4194 if (n == 0) { 4195 snprintf(out, out_size, MSG_ARG_INVALID, 4196 "action encap"); 4197 return 0; 4198 } 4199 4200 tokens += n; 4201 n_tokens -= n; 4202 } 4203 4204 if (n_tokens && (strcmp(tokens[0], "nat") == 0)) { 4205 uint32_t n; 4206 4207 n = parse_table_action_nat(tokens, n_tokens, a); 4208 if (n == 0) { 4209 snprintf(out, out_size, MSG_ARG_INVALID, 4210 "action nat"); 4211 return 0; 4212 } 4213 4214 tokens += n; 4215 n_tokens -= n; 4216 } 4217 4218 if (n_tokens && (strcmp(tokens[0], "ttl") == 0)) { 4219 uint32_t n; 4220 4221 n = parse_table_action_ttl(tokens, n_tokens, a); 4222 if (n == 0) { 4223 snprintf(out, out_size, MSG_ARG_INVALID, 4224 "action ttl"); 4225 return 0; 4226 } 4227 4228 tokens += n; 4229 n_tokens -= n; 4230 } 4231 4232 if (n_tokens && (strcmp(tokens[0], "stats") == 0)) { 4233 uint32_t n; 4234 4235 n = parse_table_action_stats(tokens, n_tokens, a); 4236 if (n == 0) { 4237 snprintf(out, out_size, MSG_ARG_INVALID, 4238 "action stats"); 4239 return 0; 4240 } 4241 4242 tokens += n; 4243 n_tokens -= n; 4244 } 4245 4246 if (n_tokens && (strcmp(tokens[0], "time") == 0)) { 4247 uint32_t n; 4248 4249 n = parse_table_action_time(tokens, n_tokens, a); 4250 if (n == 0) { 4251 snprintf(out, out_size, MSG_ARG_INVALID, 4252 "action time"); 4253 return 0; 4254 } 4255 4256 tokens += n; 4257 n_tokens -= n; 4258 } 4259 4260 if (n_tokens && (strcmp(tokens[0], "sym_crypto") == 0)) { 4261 uint32_t n; 4262 4263 n = parse_table_action_sym_crypto(tokens, n_tokens, a); 4264 if (n == 0) { 4265 snprintf(out, out_size, MSG_ARG_INVALID, 4266 "action sym_crypto"); 4267 } 4268 4269 tokens += n; 4270 n_tokens -= n; 4271 } 4272 4273 if (n_tokens && (strcmp(tokens[0], "tag") == 0)) { 4274 uint32_t n; 4275 4276 n = parse_table_action_tag(tokens, n_tokens, a); 4277 if (n == 0) { 4278 snprintf(out, out_size, MSG_ARG_INVALID, 4279 "action tag"); 4280 return 0; 4281 } 4282 4283 tokens += n; 4284 n_tokens -= n; 4285 } 4286 4287 if (n_tokens && (strcmp(tokens[0], "decap") == 0)) { 4288 uint32_t n; 4289 4290 n = parse_table_action_decap(tokens, n_tokens, a); 4291 if (n == 0) { 4292 snprintf(out, out_size, MSG_ARG_INVALID, 4293 "action decap"); 4294 return 0; 4295 } 4296 4297 tokens += n; 4298 n_tokens -= n; 4299 } 4300 4301 if (n_tokens0 - n_tokens == 1) { 4302 snprintf(out, out_size, MSG_ARG_INVALID, "action"); 4303 return 0; 4304 } 4305 4306 return n_tokens0 - n_tokens; 4307 } 4308 4309 4310 static const char cmd_pipeline_table_rule_add_help[] = 4311 "pipeline <pipeline_name> table <table_id> rule add\n" 4312 " match <match>\n" 4313 " action <table_action>\n"; 4314 4315 static void 4316 cmd_pipeline_table_rule_add(char **tokens, 4317 uint32_t n_tokens, 4318 char *out, 4319 size_t out_size) 4320 { 4321 struct table_rule_match m; 4322 struct table_rule_action a; 4323 char *pipeline_name; 4324 uint32_t table_id, t0, n_tokens_parsed; 4325 int status; 4326 4327 if (n_tokens < 8) { 4328 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 4329 return; 4330 } 4331 4332 pipeline_name = tokens[1]; 4333 4334 if (strcmp(tokens[2], "table") != 0) { 4335 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table"); 4336 return; 4337 } 4338 4339 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 4340 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 4341 return; 4342 } 4343 4344 if (strcmp(tokens[4], "rule") != 0) { 4345 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule"); 4346 return; 4347 } 4348 4349 if (strcmp(tokens[5], "add") != 0) { 4350 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "add"); 4351 return; 4352 } 4353 4354 t0 = 6; 4355 4356 /* match */ 4357 n_tokens_parsed = parse_match(tokens + t0, 4358 n_tokens - t0, 4359 out, 4360 out_size, 4361 &m); 4362 if (n_tokens_parsed == 0) 4363 return; 4364 t0 += n_tokens_parsed; 4365 4366 /* action */ 4367 n_tokens_parsed = parse_table_action(tokens + t0, 4368 n_tokens - t0, 4369 out, 4370 out_size, 4371 &a); 4372 if (n_tokens_parsed == 0) 4373 return; 4374 t0 += n_tokens_parsed; 4375 4376 if (t0 != n_tokens) { 4377 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]); 4378 return; 4379 } 4380 4381 status = pipeline_table_rule_add(pipeline_name, table_id, &m, &a); 4382 if (status) { 4383 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 4384 return; 4385 } 4386 4387 if (a.action_mask & 1 << RTE_TABLE_ACTION_SYM_CRYPTO) 4388 parse_free_sym_crypto_param_data(&a.sym_crypto); 4389 } 4390 4391 4392 static const char cmd_pipeline_table_rule_add_default_help[] = 4393 "pipeline <pipeline_name> table <table_id> rule add\n" 4394 " match\n" 4395 " default\n" 4396 " action\n" 4397 " fwd\n" 4398 " drop\n" 4399 " | port <port_id>\n" 4400 " | meta\n" 4401 " | table <table_id>\n"; 4402 4403 static void 4404 cmd_pipeline_table_rule_add_default(char **tokens, 4405 uint32_t n_tokens, 4406 char *out, 4407 size_t out_size) 4408 { 4409 struct table_rule_action action; 4410 char *pipeline_name; 4411 uint32_t table_id; 4412 int status; 4413 4414 if ((n_tokens != 11) && (n_tokens != 12)) { 4415 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 4416 return; 4417 } 4418 4419 pipeline_name = tokens[1]; 4420 4421 if (strcmp(tokens[2], "table") != 0) { 4422 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table"); 4423 return; 4424 } 4425 4426 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 4427 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 4428 return; 4429 } 4430 4431 if (strcmp(tokens[4], "rule") != 0) { 4432 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule"); 4433 return; 4434 } 4435 4436 if (strcmp(tokens[5], "add") != 0) { 4437 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "add"); 4438 return; 4439 } 4440 4441 if (strcmp(tokens[6], "match") != 0) { 4442 snprintf(out, out_size, MSG_ARG_INVALID, "match"); 4443 return; 4444 } 4445 4446 if (strcmp(tokens[7], "default") != 0) { 4447 snprintf(out, out_size, MSG_ARG_INVALID, "default"); 4448 return; 4449 } 4450 4451 if (strcmp(tokens[8], "action") != 0) { 4452 snprintf(out, out_size, MSG_ARG_INVALID, "action"); 4453 return; 4454 } 4455 4456 if (strcmp(tokens[9], "fwd") != 0) { 4457 snprintf(out, out_size, MSG_ARG_INVALID, "fwd"); 4458 return; 4459 } 4460 4461 action.action_mask = 1 << RTE_TABLE_ACTION_FWD; 4462 4463 if (strcmp(tokens[10], "drop") == 0) { 4464 if (n_tokens != 11) { 4465 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 4466 return; 4467 } 4468 4469 action.fwd.action = RTE_PIPELINE_ACTION_DROP; 4470 } else if (strcmp(tokens[10], "port") == 0) { 4471 uint32_t id; 4472 4473 if (n_tokens != 12) { 4474 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 4475 return; 4476 } 4477 4478 if (parser_read_uint32(&id, tokens[11]) != 0) { 4479 snprintf(out, out_size, MSG_ARG_INVALID, "port_id"); 4480 return; 4481 } 4482 4483 action.fwd.action = RTE_PIPELINE_ACTION_PORT; 4484 action.fwd.id = id; 4485 } else if (strcmp(tokens[10], "meta") == 0) { 4486 if (n_tokens != 11) { 4487 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 4488 return; 4489 } 4490 4491 action.fwd.action = RTE_PIPELINE_ACTION_PORT_META; 4492 } else if (strcmp(tokens[10], "table") == 0) { 4493 uint32_t id; 4494 4495 if (n_tokens != 12) { 4496 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 4497 return; 4498 } 4499 4500 if (parser_read_uint32(&id, tokens[11]) != 0) { 4501 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 4502 return; 4503 } 4504 4505 action.fwd.action = RTE_PIPELINE_ACTION_TABLE; 4506 action.fwd.id = id; 4507 } else { 4508 snprintf(out, out_size, MSG_ARG_INVALID, 4509 "drop or port or meta or table"); 4510 return; 4511 } 4512 4513 status = pipeline_table_rule_add_default(pipeline_name, 4514 table_id, 4515 &action); 4516 if (status) { 4517 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 4518 return; 4519 } 4520 } 4521 4522 4523 static const char cmd_pipeline_table_rule_add_bulk_help[] = 4524 "pipeline <pipeline_name> table <table_id> rule add bulk <file_name>\n" 4525 "\n" 4526 " File <file_name>:\n" 4527 " - line format: match <match> action <action>\n"; 4528 4529 static int 4530 cli_rule_file_process(const char *file_name, 4531 size_t line_len_max, 4532 struct table_rule_list **rule_list, 4533 uint32_t *n_rules, 4534 uint32_t *line_number, 4535 char *out, 4536 size_t out_size); 4537 4538 static void 4539 cmd_pipeline_table_rule_add_bulk(char **tokens, 4540 uint32_t n_tokens, 4541 char *out, 4542 size_t out_size) 4543 { 4544 struct table_rule_list *list = NULL; 4545 char *pipeline_name, *file_name; 4546 uint32_t table_id, n_rules, n_rules_added, n_rules_not_added, line_number; 4547 int status; 4548 4549 if (n_tokens != 8) { 4550 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 4551 return; 4552 } 4553 4554 pipeline_name = tokens[1]; 4555 4556 if (strcmp(tokens[2], "table") != 0) { 4557 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table"); 4558 return; 4559 } 4560 4561 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 4562 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 4563 return; 4564 } 4565 4566 if (strcmp(tokens[4], "rule") != 0) { 4567 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule"); 4568 return; 4569 } 4570 4571 if (strcmp(tokens[5], "add") != 0) { 4572 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "add"); 4573 return; 4574 } 4575 4576 if (strcmp(tokens[6], "bulk") != 0) { 4577 snprintf(out, out_size, MSG_ARG_INVALID, "bulk"); 4578 return; 4579 } 4580 4581 file_name = tokens[7]; 4582 4583 /* Load rules from file. */ 4584 status = cli_rule_file_process(file_name, 4585 1024, 4586 &list, 4587 &n_rules, 4588 &line_number, 4589 out, 4590 out_size); 4591 if (status) { 4592 snprintf(out, out_size, MSG_FILE_ERR, file_name, line_number); 4593 return; 4594 } 4595 4596 /* Rule bulk add */ 4597 status = pipeline_table_rule_add_bulk(pipeline_name, 4598 table_id, 4599 list, 4600 &n_rules_added, 4601 &n_rules_not_added); 4602 if (status) { 4603 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 4604 return; 4605 } 4606 4607 snprintf(out, out_size, "Added %u rules out of %u.\n", 4608 n_rules_added, 4609 n_rules); 4610 } 4611 4612 4613 static const char cmd_pipeline_table_rule_delete_help[] = 4614 "pipeline <pipeline_name> table <table_id> rule delete\n" 4615 " match <match>\n"; 4616 4617 static void 4618 cmd_pipeline_table_rule_delete(char **tokens, 4619 uint32_t n_tokens, 4620 char *out, 4621 size_t out_size) 4622 { 4623 struct table_rule_match m; 4624 char *pipeline_name; 4625 uint32_t table_id, n_tokens_parsed, t0; 4626 int status; 4627 4628 if (n_tokens < 8) { 4629 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 4630 return; 4631 } 4632 4633 pipeline_name = tokens[1]; 4634 4635 if (strcmp(tokens[2], "table") != 0) { 4636 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table"); 4637 return; 4638 } 4639 4640 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 4641 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 4642 return; 4643 } 4644 4645 if (strcmp(tokens[4], "rule") != 0) { 4646 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule"); 4647 return; 4648 } 4649 4650 if (strcmp(tokens[5], "delete") != 0) { 4651 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "delete"); 4652 return; 4653 } 4654 4655 t0 = 6; 4656 4657 /* match */ 4658 n_tokens_parsed = parse_match(tokens + t0, 4659 n_tokens - t0, 4660 out, 4661 out_size, 4662 &m); 4663 if (n_tokens_parsed == 0) 4664 return; 4665 t0 += n_tokens_parsed; 4666 4667 if (n_tokens != t0) { 4668 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 4669 return; 4670 } 4671 4672 status = pipeline_table_rule_delete(pipeline_name, 4673 table_id, 4674 &m); 4675 if (status) { 4676 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 4677 return; 4678 } 4679 } 4680 4681 4682 static const char cmd_pipeline_table_rule_delete_default_help[] = 4683 "pipeline <pipeline_name> table <table_id> rule delete\n" 4684 " match\n" 4685 " default\n"; 4686 4687 static void 4688 cmd_pipeline_table_rule_delete_default(char **tokens, 4689 uint32_t n_tokens, 4690 char *out, 4691 size_t out_size) 4692 { 4693 char *pipeline_name; 4694 uint32_t table_id; 4695 int status; 4696 4697 if (n_tokens != 8) { 4698 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 4699 return; 4700 } 4701 4702 pipeline_name = tokens[1]; 4703 4704 if (strcmp(tokens[2], "table") != 0) { 4705 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table"); 4706 return; 4707 } 4708 4709 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 4710 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 4711 return; 4712 } 4713 4714 if (strcmp(tokens[4], "rule") != 0) { 4715 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule"); 4716 return; 4717 } 4718 4719 if (strcmp(tokens[5], "delete") != 0) { 4720 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "delete"); 4721 return; 4722 } 4723 4724 if (strcmp(tokens[6], "match") != 0) { 4725 snprintf(out, out_size, MSG_ARG_INVALID, "match"); 4726 return; 4727 } 4728 4729 if (strcmp(tokens[7], "default") != 0) { 4730 snprintf(out, out_size, MSG_ARG_INVALID, "default"); 4731 return; 4732 } 4733 4734 status = pipeline_table_rule_delete_default(pipeline_name, 4735 table_id); 4736 if (status) { 4737 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 4738 return; 4739 } 4740 } 4741 4742 static void 4743 ether_addr_show(FILE *f, struct ether_addr *addr) 4744 { 4745 fprintf(f, "%02x:%02x:%02x:%02x:%02x:%02x", 4746 (uint32_t)addr->addr_bytes[0], (uint32_t)addr->addr_bytes[1], 4747 (uint32_t)addr->addr_bytes[2], (uint32_t)addr->addr_bytes[3], 4748 (uint32_t)addr->addr_bytes[4], (uint32_t)addr->addr_bytes[5]); 4749 } 4750 4751 static void 4752 ipv4_addr_show(FILE *f, uint32_t addr) 4753 { 4754 fprintf(f, "%u.%u.%u.%u", 4755 addr >> 24, 4756 (addr >> 16) & 0xFF, 4757 (addr >> 8) & 0xFF, 4758 addr & 0xFF); 4759 } 4760 4761 static void 4762 ipv6_addr_show(FILE *f, uint8_t *addr) 4763 { 4764 fprintf(f, "%02x%02x:%02x%02x:%02x%02x:%02x%02x:" 4765 "%02x%02x:%02x%02x:%02x%02x:%02x%02x:", 4766 (uint32_t)addr[0], (uint32_t)addr[1], 4767 (uint32_t)addr[2], (uint32_t)addr[3], 4768 (uint32_t)addr[4], (uint32_t)addr[5], 4769 (uint32_t)addr[6], (uint32_t)addr[7], 4770 (uint32_t)addr[8], (uint32_t)addr[9], 4771 (uint32_t)addr[10], (uint32_t)addr[11], 4772 (uint32_t)addr[12], (uint32_t)addr[13], 4773 (uint32_t)addr[14], (uint32_t)addr[15]); 4774 } 4775 4776 static const char * 4777 policer_action_string(enum rte_table_action_policer action) { 4778 switch (action) { 4779 case RTE_TABLE_ACTION_POLICER_COLOR_GREEN: return "G"; 4780 case RTE_TABLE_ACTION_POLICER_COLOR_YELLOW: return "Y"; 4781 case RTE_TABLE_ACTION_POLICER_COLOR_RED: return "R"; 4782 case RTE_TABLE_ACTION_POLICER_DROP: return "D"; 4783 default: return "?"; 4784 } 4785 } 4786 4787 static int 4788 table_rule_show(const char *pipeline_name, 4789 uint32_t table_id, 4790 const char *file_name) 4791 { 4792 struct pipeline *p; 4793 struct table *table; 4794 struct table_rule *rule; 4795 FILE *f = NULL; 4796 uint32_t i; 4797 4798 /* Check input params. */ 4799 if ((pipeline_name == NULL) || 4800 (file_name == NULL)) 4801 return -1; 4802 4803 p = pipeline_find(pipeline_name); 4804 if ((p == NULL) || 4805 (table_id >= p->n_tables)) 4806 return -1; 4807 4808 table = &p->table[table_id]; 4809 4810 /* Open file. */ 4811 f = fopen(file_name, "w"); 4812 if (f == NULL) 4813 return -1; 4814 4815 /* Write table rules to file. */ 4816 TAILQ_FOREACH(rule, &table->rules, node) { 4817 struct table_rule_match *m = &rule->match; 4818 struct table_rule_action *a = &rule->action; 4819 4820 fprintf(f, "match "); 4821 switch (m->match_type) { 4822 case TABLE_ACL: 4823 fprintf(f, "acl priority %u ", 4824 m->match.acl.priority); 4825 4826 fprintf(f, m->match.acl.ip_version ? "ipv4 " : "ipv6 "); 4827 4828 if (m->match.acl.ip_version) 4829 ipv4_addr_show(f, m->match.acl.ipv4.sa); 4830 else 4831 ipv6_addr_show(f, m->match.acl.ipv6.sa); 4832 4833 fprintf(f, "%u", m->match.acl.sa_depth); 4834 4835 if (m->match.acl.ip_version) 4836 ipv4_addr_show(f, m->match.acl.ipv4.da); 4837 else 4838 ipv6_addr_show(f, m->match.acl.ipv6.da); 4839 4840 fprintf(f, "%u", m->match.acl.da_depth); 4841 4842 fprintf(f, "%u %u %u %u %u ", 4843 (uint32_t)m->match.acl.sp0, 4844 (uint32_t)m->match.acl.sp1, 4845 (uint32_t)m->match.acl.dp0, 4846 (uint32_t)m->match.acl.dp1, 4847 (uint32_t)m->match.acl.proto); 4848 break; 4849 4850 case TABLE_ARRAY: 4851 fprintf(f, "array %u ", 4852 m->match.array.pos); 4853 break; 4854 4855 case TABLE_HASH: 4856 fprintf(f, "hash raw "); 4857 for (i = 0; i < table->params.match.hash.key_size; i++) 4858 fprintf(f, "%02x", m->match.hash.key[i]); 4859 fprintf(f, " "); 4860 break; 4861 4862 case TABLE_LPM: 4863 fprintf(f, "lpm "); 4864 4865 fprintf(f, m->match.lpm.ip_version ? "ipv4 " : "ipv6 "); 4866 4867 if (m->match.acl.ip_version) 4868 ipv4_addr_show(f, m->match.lpm.ipv4); 4869 else 4870 ipv6_addr_show(f, m->match.lpm.ipv6); 4871 4872 fprintf(f, "%u ", 4873 (uint32_t)m->match.lpm.depth); 4874 break; 4875 4876 default: 4877 fprintf(f, "unknown "); 4878 } 4879 4880 fprintf(f, "action "); 4881 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_FWD)) { 4882 fprintf(f, "fwd "); 4883 switch (a->fwd.action) { 4884 case RTE_PIPELINE_ACTION_DROP: 4885 fprintf(f, "drop "); 4886 break; 4887 4888 case RTE_PIPELINE_ACTION_PORT: 4889 fprintf(f, "port %u ", a->fwd.id); 4890 break; 4891 4892 case RTE_PIPELINE_ACTION_PORT_META: 4893 fprintf(f, "meta "); 4894 break; 4895 4896 case RTE_PIPELINE_ACTION_TABLE: 4897 default: 4898 fprintf(f, "table %u ", a->fwd.id); 4899 } 4900 } 4901 4902 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_LB)) { 4903 fprintf(f, "balance "); 4904 for (i = 0; i < RTE_DIM(a->lb.out); i++) 4905 fprintf(f, "%u ", a->lb.out[i]); 4906 } 4907 4908 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_MTR)) { 4909 fprintf(f, "mtr "); 4910 for (i = 0; i < RTE_TABLE_ACTION_TC_MAX; i++) 4911 if (a->mtr.tc_mask & (1 << i)) { 4912 struct rte_table_action_mtr_tc_params *p = 4913 &a->mtr.mtr[i]; 4914 enum rte_table_action_policer ga = 4915 p->policer[e_RTE_METER_GREEN]; 4916 enum rte_table_action_policer ya = 4917 p->policer[e_RTE_METER_YELLOW]; 4918 enum rte_table_action_policer ra = 4919 p->policer[e_RTE_METER_RED]; 4920 4921 fprintf(f, "tc%u meter %u policer g %s y %s r %s ", 4922 i, 4923 a->mtr.mtr[i].meter_profile_id, 4924 policer_action_string(ga), 4925 policer_action_string(ya), 4926 policer_action_string(ra)); 4927 } 4928 } 4929 4930 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_TM)) 4931 fprintf(f, "tm subport %u pipe %u ", 4932 a->tm.subport_id, 4933 a->tm.pipe_id); 4934 4935 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_ENCAP)) { 4936 fprintf(f, "encap "); 4937 switch (a->encap.type) { 4938 case RTE_TABLE_ACTION_ENCAP_ETHER: 4939 fprintf(f, "ether "); 4940 ether_addr_show(f, &a->encap.ether.ether.da); 4941 fprintf(f, " "); 4942 ether_addr_show(f, &a->encap.ether.ether.sa); 4943 fprintf(f, " "); 4944 break; 4945 4946 case RTE_TABLE_ACTION_ENCAP_VLAN: 4947 fprintf(f, "vlan "); 4948 ether_addr_show(f, &a->encap.vlan.ether.da); 4949 fprintf(f, " "); 4950 ether_addr_show(f, &a->encap.vlan.ether.sa); 4951 fprintf(f, " pcp %u dei %u vid %u ", 4952 a->encap.vlan.vlan.pcp, 4953 a->encap.vlan.vlan.dei, 4954 a->encap.vlan.vlan.vid); 4955 break; 4956 4957 case RTE_TABLE_ACTION_ENCAP_QINQ: 4958 fprintf(f, "qinq "); 4959 ether_addr_show(f, &a->encap.qinq.ether.da); 4960 fprintf(f, " "); 4961 ether_addr_show(f, &a->encap.qinq.ether.sa); 4962 fprintf(f, " pcp %u dei %u vid %u pcp %u dei %u vid %u ", 4963 a->encap.qinq.svlan.pcp, 4964 a->encap.qinq.svlan.dei, 4965 a->encap.qinq.svlan.vid, 4966 a->encap.qinq.cvlan.pcp, 4967 a->encap.qinq.cvlan.dei, 4968 a->encap.qinq.cvlan.vid); 4969 break; 4970 4971 case RTE_TABLE_ACTION_ENCAP_MPLS: 4972 fprintf(f, "mpls %s ", (a->encap.mpls.unicast) ? 4973 "unicast " : "multicast "); 4974 ether_addr_show(f, &a->encap.mpls.ether.da); 4975 fprintf(f, " "); 4976 ether_addr_show(f, &a->encap.mpls.ether.sa); 4977 fprintf(f, " "); 4978 for (i = 0; i < a->encap.mpls.mpls_count; i++) { 4979 struct rte_table_action_mpls_hdr *l = 4980 &a->encap.mpls.mpls[i]; 4981 4982 fprintf(f, "label%u %u %u %u ", 4983 i, 4984 l->label, 4985 l->tc, 4986 l->ttl); 4987 } 4988 break; 4989 4990 case RTE_TABLE_ACTION_ENCAP_PPPOE: 4991 fprintf(f, "pppoe "); 4992 ether_addr_show(f, &a->encap.pppoe.ether.da); 4993 fprintf(f, " "); 4994 ether_addr_show(f, &a->encap.pppoe.ether.sa); 4995 fprintf(f, " %u ", a->encap.pppoe.pppoe.session_id); 4996 break; 4997 4998 case RTE_TABLE_ACTION_ENCAP_VXLAN: 4999 fprintf(f, "vxlan ether "); 5000 ether_addr_show(f, &a->encap.vxlan.ether.da); 5001 fprintf(f, " "); 5002 ether_addr_show(f, &a->encap.vxlan.ether.sa); 5003 if (table->ap->params.encap.vxlan.vlan) 5004 fprintf(f, " vlan pcp %u dei %u vid %u ", 5005 a->encap.vxlan.vlan.pcp, 5006 a->encap.vxlan.vlan.dei, 5007 a->encap.vxlan.vlan.vid); 5008 if (table->ap->params.encap.vxlan.ip_version) { 5009 fprintf(f, " ipv4 "); 5010 ipv4_addr_show(f, a->encap.vxlan.ipv4.sa); 5011 fprintf(f, " "); 5012 ipv4_addr_show(f, a->encap.vxlan.ipv4.da); 5013 fprintf(f, " %u %u ", 5014 (uint32_t)a->encap.vxlan.ipv4.dscp, 5015 (uint32_t)a->encap.vxlan.ipv4.ttl); 5016 } else { 5017 fprintf(f, " ipv6 "); 5018 ipv6_addr_show(f, a->encap.vxlan.ipv6.sa); 5019 fprintf(f, " "); 5020 ipv6_addr_show(f, a->encap.vxlan.ipv6.da); 5021 fprintf(f, " %u %u %u ", 5022 a->encap.vxlan.ipv6.flow_label, 5023 (uint32_t)a->encap.vxlan.ipv6.dscp, 5024 (uint32_t)a->encap.vxlan.ipv6.hop_limit); 5025 fprintf(f, " udp %u %u vxlan %u ", 5026 a->encap.vxlan.udp.sp, 5027 a->encap.vxlan.udp.dp, 5028 a->encap.vxlan.vxlan.vni); 5029 } 5030 break; 5031 5032 default: 5033 fprintf(f, "unknown "); 5034 } 5035 } 5036 5037 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_NAT)) { 5038 fprintf(f, "nat %s ", (a->nat.ip_version) ? "ipv4 " : "ipv6 "); 5039 if (a->nat.ip_version) 5040 ipv4_addr_show(f, a->nat.addr.ipv4); 5041 else 5042 ipv6_addr_show(f, a->nat.addr.ipv6); 5043 fprintf(f, " %u ", (uint32_t)(a->nat.port)); 5044 } 5045 5046 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_TTL)) 5047 fprintf(f, "ttl %s ", (a->ttl.decrement) ? "dec" : "keep"); 5048 5049 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_STATS)) 5050 fprintf(f, "stats "); 5051 5052 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_TIME)) 5053 fprintf(f, "time "); 5054 5055 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_SYM_CRYPTO)) 5056 fprintf(f, "sym_crypto "); 5057 5058 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_TAG)) 5059 fprintf(f, "tag %u ", a->tag.tag); 5060 5061 if (a->action_mask & (1LLU << RTE_TABLE_ACTION_DECAP)) 5062 fprintf(f, "decap %u ", a->decap.n); 5063 5064 /* end */ 5065 fprintf(f, "\n"); 5066 } 5067 5068 /* Write table default rule to file. */ 5069 if (table->rule_default) { 5070 struct table_rule_action *a = &table->rule_default->action; 5071 5072 fprintf(f, "# match default action fwd "); 5073 5074 switch (a->fwd.action) { 5075 case RTE_PIPELINE_ACTION_DROP: 5076 fprintf(f, "drop "); 5077 break; 5078 5079 case RTE_PIPELINE_ACTION_PORT: 5080 fprintf(f, "port %u ", a->fwd.id); 5081 break; 5082 5083 case RTE_PIPELINE_ACTION_PORT_META: 5084 fprintf(f, "meta "); 5085 break; 5086 5087 case RTE_PIPELINE_ACTION_TABLE: 5088 default: 5089 fprintf(f, "table %u ", a->fwd.id); 5090 } 5091 } else 5092 fprintf(f, "# match default action fwd drop "); 5093 5094 fprintf(f, "\n"); 5095 5096 /* Close file. */ 5097 fclose(f); 5098 5099 return 0; 5100 } 5101 5102 static const char cmd_pipeline_table_rule_show_help[] = 5103 "pipeline <pipeline_name> table <table_id> rule show\n" 5104 " file <file_name>\n"; 5105 5106 static void 5107 cmd_pipeline_table_rule_show(char **tokens, 5108 uint32_t n_tokens, 5109 char *out, 5110 size_t out_size) 5111 { 5112 char *file_name = NULL, *pipeline_name; 5113 uint32_t table_id; 5114 int status; 5115 5116 if (n_tokens != 8) { 5117 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 5118 return; 5119 } 5120 5121 pipeline_name = tokens[1]; 5122 5123 if (strcmp(tokens[2], "table") != 0) { 5124 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table"); 5125 return; 5126 } 5127 5128 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 5129 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 5130 return; 5131 } 5132 5133 if (strcmp(tokens[4], "rule") != 0) { 5134 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule"); 5135 return; 5136 } 5137 5138 if (strcmp(tokens[5], "show") != 0) { 5139 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "show"); 5140 return; 5141 } 5142 5143 if (strcmp(tokens[6], "file") != 0) { 5144 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "file"); 5145 return; 5146 } 5147 5148 file_name = tokens[7]; 5149 5150 status = table_rule_show(pipeline_name, table_id, file_name); 5151 if (status) { 5152 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 5153 return; 5154 } 5155 } 5156 5157 static const char cmd_pipeline_table_rule_stats_read_help[] = 5158 "pipeline <pipeline_name> table <table_id> rule read stats [clear]\n" 5159 " match <match>\n"; 5160 5161 static void 5162 cmd_pipeline_table_rule_stats_read(char **tokens, 5163 uint32_t n_tokens, 5164 char *out, 5165 size_t out_size) 5166 { 5167 struct table_rule_match m; 5168 struct rte_table_action_stats_counters stats; 5169 char *pipeline_name; 5170 uint32_t table_id, n_tokens_parsed; 5171 int clear = 0, status; 5172 5173 if (n_tokens < 7) { 5174 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 5175 return; 5176 } 5177 5178 pipeline_name = tokens[1]; 5179 5180 if (strcmp(tokens[2], "table") != 0) { 5181 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table"); 5182 return; 5183 } 5184 5185 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 5186 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 5187 return; 5188 } 5189 5190 if (strcmp(tokens[4], "rule") != 0) { 5191 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule"); 5192 return; 5193 } 5194 5195 if (strcmp(tokens[5], "read") != 0) { 5196 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read"); 5197 return; 5198 } 5199 5200 if (strcmp(tokens[6], "stats") != 0) { 5201 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "stats"); 5202 return; 5203 } 5204 5205 n_tokens -= 7; 5206 tokens += 7; 5207 5208 /* clear */ 5209 if (n_tokens && (strcmp(tokens[0], "clear") == 0)) { 5210 clear = 1; 5211 5212 n_tokens--; 5213 tokens++; 5214 } 5215 5216 /* match */ 5217 if ((n_tokens == 0) || strcmp(tokens[0], "match")) { 5218 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match"); 5219 return; 5220 } 5221 5222 n_tokens_parsed = parse_match(tokens, 5223 n_tokens, 5224 out, 5225 out_size, 5226 &m); 5227 if (n_tokens_parsed == 0) 5228 return; 5229 n_tokens -= n_tokens_parsed; 5230 tokens += n_tokens_parsed; 5231 5232 /* end */ 5233 if (n_tokens) { 5234 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]); 5235 return; 5236 } 5237 5238 /* Read table rule stats. */ 5239 status = pipeline_table_rule_stats_read(pipeline_name, 5240 table_id, 5241 &m, 5242 &stats, 5243 clear); 5244 if (status) { 5245 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 5246 return; 5247 } 5248 5249 /* Print stats. */ 5250 if (stats.n_packets_valid && stats.n_bytes_valid) 5251 snprintf(out, out_size, "Packets: %" PRIu64 "; Bytes: %" PRIu64 "\n", 5252 stats.n_packets, 5253 stats.n_bytes); 5254 5255 if (stats.n_packets_valid && !stats.n_bytes_valid) 5256 snprintf(out, out_size, "Packets: %" PRIu64 "; Bytes: N/A\n", 5257 stats.n_packets); 5258 5259 if (!stats.n_packets_valid && stats.n_bytes_valid) 5260 snprintf(out, out_size, "Packets: N/A; Bytes: %" PRIu64 "\n", 5261 stats.n_bytes); 5262 5263 if (!stats.n_packets_valid && !stats.n_bytes_valid) 5264 snprintf(out, out_size, "Packets: N/A ; Bytes: N/A\n"); 5265 } 5266 5267 static const char cmd_pipeline_table_meter_profile_add_help[] = 5268 "pipeline <pipeline_name> table <table_id> meter profile <meter_profile_id>\n" 5269 " add srtcm cir <cir> cbs <cbs> ebs <ebs>\n" 5270 " | trtcm cir <cir> pir <pir> cbs <cbs> pbs <pbs>\n"; 5271 5272 static void 5273 cmd_pipeline_table_meter_profile_add(char **tokens, 5274 uint32_t n_tokens, 5275 char *out, 5276 size_t out_size) 5277 { 5278 struct rte_table_action_meter_profile p; 5279 char *pipeline_name; 5280 uint32_t table_id, meter_profile_id; 5281 int status; 5282 5283 if (n_tokens < 9) { 5284 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 5285 return; 5286 } 5287 5288 pipeline_name = tokens[1]; 5289 5290 if (strcmp(tokens[2], "table") != 0) { 5291 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port"); 5292 return; 5293 } 5294 5295 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 5296 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 5297 return; 5298 } 5299 5300 if (strcmp(tokens[4], "meter") != 0) { 5301 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "meter"); 5302 return; 5303 } 5304 5305 if (strcmp(tokens[5], "profile") != 0) { 5306 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile"); 5307 return; 5308 } 5309 5310 if (parser_read_uint32(&meter_profile_id, tokens[6]) != 0) { 5311 snprintf(out, out_size, MSG_ARG_INVALID, "meter_profile_id"); 5312 return; 5313 } 5314 5315 if (strcmp(tokens[7], "add") != 0) { 5316 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "add"); 5317 return; 5318 } 5319 5320 if (strcmp(tokens[8], "srtcm") == 0) { 5321 if (n_tokens != 15) { 5322 snprintf(out, out_size, MSG_ARG_MISMATCH, 5323 tokens[0]); 5324 return; 5325 } 5326 5327 p.alg = RTE_TABLE_ACTION_METER_SRTCM; 5328 5329 if (strcmp(tokens[9], "cir") != 0) { 5330 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cir"); 5331 return; 5332 } 5333 5334 if (parser_read_uint64(&p.srtcm.cir, tokens[10]) != 0) { 5335 snprintf(out, out_size, MSG_ARG_INVALID, "cir"); 5336 return; 5337 } 5338 5339 if (strcmp(tokens[11], "cbs") != 0) { 5340 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cbs"); 5341 return; 5342 } 5343 5344 if (parser_read_uint64(&p.srtcm.cbs, tokens[12]) != 0) { 5345 snprintf(out, out_size, MSG_ARG_INVALID, "cbs"); 5346 return; 5347 } 5348 5349 if (strcmp(tokens[13], "ebs") != 0) { 5350 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "ebs"); 5351 return; 5352 } 5353 5354 if (parser_read_uint64(&p.srtcm.ebs, tokens[14]) != 0) { 5355 snprintf(out, out_size, MSG_ARG_INVALID, "ebs"); 5356 return; 5357 } 5358 } else if (strcmp(tokens[8], "trtcm") == 0) { 5359 if (n_tokens != 17) { 5360 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 5361 return; 5362 } 5363 5364 p.alg = RTE_TABLE_ACTION_METER_TRTCM; 5365 5366 if (strcmp(tokens[9], "cir") != 0) { 5367 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cir"); 5368 return; 5369 } 5370 5371 if (parser_read_uint64(&p.trtcm.cir, tokens[10]) != 0) { 5372 snprintf(out, out_size, MSG_ARG_INVALID, "cir"); 5373 return; 5374 } 5375 5376 if (strcmp(tokens[11], "pir") != 0) { 5377 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pir"); 5378 return; 5379 } 5380 5381 if (parser_read_uint64(&p.trtcm.pir, tokens[12]) != 0) { 5382 snprintf(out, out_size, MSG_ARG_INVALID, "pir"); 5383 return; 5384 } 5385 if (strcmp(tokens[13], "cbs") != 0) { 5386 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "cbs"); 5387 return; 5388 } 5389 5390 if (parser_read_uint64(&p.trtcm.cbs, tokens[14]) != 0) { 5391 snprintf(out, out_size, MSG_ARG_INVALID, "cbs"); 5392 return; 5393 } 5394 5395 if (strcmp(tokens[15], "pbs") != 0) { 5396 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pbs"); 5397 return; 5398 } 5399 5400 if (parser_read_uint64(&p.trtcm.pbs, tokens[16]) != 0) { 5401 snprintf(out, out_size, MSG_ARG_INVALID, "pbs"); 5402 return; 5403 } 5404 } else { 5405 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 5406 return; 5407 } 5408 5409 status = pipeline_table_mtr_profile_add(pipeline_name, 5410 table_id, 5411 meter_profile_id, 5412 &p); 5413 if (status) { 5414 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 5415 return; 5416 } 5417 } 5418 5419 5420 static const char cmd_pipeline_table_meter_profile_delete_help[] = 5421 "pipeline <pipeline_name> table <table_id>\n" 5422 " meter profile <meter_profile_id> delete\n"; 5423 5424 static void 5425 cmd_pipeline_table_meter_profile_delete(char **tokens, 5426 uint32_t n_tokens, 5427 char *out, 5428 size_t out_size) 5429 { 5430 char *pipeline_name; 5431 uint32_t table_id, meter_profile_id; 5432 int status; 5433 5434 if (n_tokens != 8) { 5435 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 5436 return; 5437 } 5438 5439 pipeline_name = tokens[1]; 5440 5441 if (strcmp(tokens[2], "table") != 0) { 5442 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port"); 5443 return; 5444 } 5445 5446 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 5447 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 5448 return; 5449 } 5450 5451 if (strcmp(tokens[4], "meter") != 0) { 5452 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "meter"); 5453 return; 5454 } 5455 5456 if (strcmp(tokens[5], "profile") != 0) { 5457 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "profile"); 5458 return; 5459 } 5460 5461 if (parser_read_uint32(&meter_profile_id, tokens[6]) != 0) { 5462 snprintf(out, out_size, MSG_ARG_INVALID, "meter_profile_id"); 5463 return; 5464 } 5465 5466 if (strcmp(tokens[7], "delete") != 0) { 5467 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "delete"); 5468 return; 5469 } 5470 5471 status = pipeline_table_mtr_profile_delete(pipeline_name, 5472 table_id, 5473 meter_profile_id); 5474 if (status) { 5475 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 5476 return; 5477 } 5478 } 5479 5480 5481 static const char cmd_pipeline_table_rule_meter_read_help[] = 5482 "pipeline <pipeline_name> table <table_id> rule read meter [clear]\n" 5483 " match <match>\n"; 5484 5485 static void 5486 cmd_pipeline_table_rule_meter_read(char **tokens, 5487 uint32_t n_tokens, 5488 char *out, 5489 size_t out_size) 5490 { 5491 struct table_rule_match m; 5492 struct rte_table_action_mtr_counters stats; 5493 char *pipeline_name; 5494 uint32_t table_id, n_tokens_parsed; 5495 int clear = 0, status; 5496 5497 if (n_tokens < 7) { 5498 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 5499 return; 5500 } 5501 5502 pipeline_name = tokens[1]; 5503 5504 if (strcmp(tokens[2], "table") != 0) { 5505 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table"); 5506 return; 5507 } 5508 5509 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 5510 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 5511 return; 5512 } 5513 5514 if (strcmp(tokens[4], "rule") != 0) { 5515 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule"); 5516 return; 5517 } 5518 5519 if (strcmp(tokens[5], "read") != 0) { 5520 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read"); 5521 return; 5522 } 5523 5524 if (strcmp(tokens[6], "meter") != 0) { 5525 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "meter"); 5526 return; 5527 } 5528 5529 n_tokens -= 7; 5530 tokens += 7; 5531 5532 /* clear */ 5533 if (n_tokens && (strcmp(tokens[0], "clear") == 0)) { 5534 clear = 1; 5535 5536 n_tokens--; 5537 tokens++; 5538 } 5539 5540 /* match */ 5541 if ((n_tokens == 0) || strcmp(tokens[0], "match")) { 5542 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match"); 5543 return; 5544 } 5545 5546 n_tokens_parsed = parse_match(tokens, 5547 n_tokens, 5548 out, 5549 out_size, 5550 &m); 5551 if (n_tokens_parsed == 0) 5552 return; 5553 n_tokens -= n_tokens_parsed; 5554 tokens += n_tokens_parsed; 5555 5556 /* end */ 5557 if (n_tokens) { 5558 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]); 5559 return; 5560 } 5561 5562 /* Read table rule meter stats. */ 5563 status = pipeline_table_rule_mtr_read(pipeline_name, 5564 table_id, 5565 &m, 5566 &stats, 5567 clear); 5568 if (status) { 5569 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 5570 return; 5571 } 5572 5573 /* Print stats. */ 5574 } 5575 5576 5577 static const char cmd_pipeline_table_dscp_help[] = 5578 "pipeline <pipeline_name> table <table_id> dscp <file_name>\n" 5579 "\n" 5580 " File <file_name>:\n" 5581 " - exactly 64 lines\n" 5582 " - line format: <tc_id> <tc_queue_id> <color>, with <color> as: g | y | r\n"; 5583 5584 static int 5585 load_dscp_table(struct rte_table_action_dscp_table *dscp_table, 5586 const char *file_name, 5587 uint32_t *line_number) 5588 { 5589 FILE *f = NULL; 5590 uint32_t dscp, l; 5591 5592 /* Check input arguments */ 5593 if ((dscp_table == NULL) || 5594 (file_name == NULL) || 5595 (line_number == NULL)) { 5596 if (line_number) 5597 *line_number = 0; 5598 return -EINVAL; 5599 } 5600 5601 /* Open input file */ 5602 f = fopen(file_name, "r"); 5603 if (f == NULL) { 5604 *line_number = 0; 5605 return -EINVAL; 5606 } 5607 5608 /* Read file */ 5609 for (dscp = 0, l = 1; ; l++) { 5610 char line[64]; 5611 char *tokens[3]; 5612 enum rte_meter_color color; 5613 uint32_t tc_id, tc_queue_id, n_tokens = RTE_DIM(tokens); 5614 5615 if (fgets(line, sizeof(line), f) == NULL) 5616 break; 5617 5618 if (is_comment(line)) 5619 continue; 5620 5621 if (parse_tokenize_string(line, tokens, &n_tokens)) { 5622 *line_number = l; 5623 fclose(f); 5624 return -EINVAL; 5625 } 5626 5627 if (n_tokens == 0) 5628 continue; 5629 5630 if ((dscp >= RTE_DIM(dscp_table->entry)) || 5631 (n_tokens != RTE_DIM(tokens)) || 5632 parser_read_uint32(&tc_id, tokens[0]) || 5633 (tc_id >= RTE_TABLE_ACTION_TC_MAX) || 5634 parser_read_uint32(&tc_queue_id, tokens[1]) || 5635 (tc_queue_id >= RTE_TABLE_ACTION_TC_QUEUE_MAX) || 5636 (strlen(tokens[2]) != 1)) { 5637 *line_number = l; 5638 fclose(f); 5639 return -EINVAL; 5640 } 5641 5642 switch (tokens[2][0]) { 5643 case 'g': 5644 case 'G': 5645 color = e_RTE_METER_GREEN; 5646 break; 5647 5648 case 'y': 5649 case 'Y': 5650 color = e_RTE_METER_YELLOW; 5651 break; 5652 5653 case 'r': 5654 case 'R': 5655 color = e_RTE_METER_RED; 5656 break; 5657 5658 default: 5659 *line_number = l; 5660 fclose(f); 5661 return -EINVAL; 5662 } 5663 5664 dscp_table->entry[dscp].tc_id = tc_id; 5665 dscp_table->entry[dscp].tc_queue_id = tc_queue_id; 5666 dscp_table->entry[dscp].color = color; 5667 dscp++; 5668 } 5669 5670 /* Close file */ 5671 fclose(f); 5672 return 0; 5673 } 5674 5675 static void 5676 cmd_pipeline_table_dscp(char **tokens, 5677 uint32_t n_tokens, 5678 char *out, 5679 size_t out_size) 5680 { 5681 struct rte_table_action_dscp_table dscp_table; 5682 char *pipeline_name, *file_name; 5683 uint32_t table_id, line_number; 5684 int status; 5685 5686 if (n_tokens != 6) { 5687 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 5688 return; 5689 } 5690 5691 pipeline_name = tokens[1]; 5692 5693 if (strcmp(tokens[2], "table") != 0) { 5694 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "port"); 5695 return; 5696 } 5697 5698 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 5699 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 5700 return; 5701 } 5702 5703 if (strcmp(tokens[4], "dscp") != 0) { 5704 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "dscp"); 5705 return; 5706 } 5707 5708 file_name = tokens[5]; 5709 5710 status = load_dscp_table(&dscp_table, file_name, &line_number); 5711 if (status) { 5712 snprintf(out, out_size, MSG_FILE_ERR, file_name, line_number); 5713 return; 5714 } 5715 5716 status = pipeline_table_dscp_table_update(pipeline_name, 5717 table_id, 5718 UINT64_MAX, 5719 &dscp_table); 5720 if (status) { 5721 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 5722 return; 5723 } 5724 } 5725 5726 5727 static const char cmd_pipeline_table_rule_ttl_read_help[] = 5728 "pipeline <pipeline_name> table <table_id> rule read ttl [clear]\n" 5729 " match <match>\n"; 5730 5731 static void 5732 cmd_pipeline_table_rule_ttl_read(char **tokens, 5733 uint32_t n_tokens, 5734 char *out, 5735 size_t out_size) 5736 { 5737 struct table_rule_match m; 5738 struct rte_table_action_ttl_counters stats; 5739 char *pipeline_name; 5740 uint32_t table_id, n_tokens_parsed; 5741 int clear = 0, status; 5742 5743 if (n_tokens < 7) { 5744 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 5745 return; 5746 } 5747 5748 pipeline_name = tokens[1]; 5749 5750 if (strcmp(tokens[2], "table") != 0) { 5751 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table"); 5752 return; 5753 } 5754 5755 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 5756 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 5757 return; 5758 } 5759 5760 if (strcmp(tokens[4], "rule") != 0) { 5761 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule"); 5762 return; 5763 } 5764 5765 if (strcmp(tokens[5], "read") != 0) { 5766 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read"); 5767 return; 5768 } 5769 5770 if (strcmp(tokens[6], "ttl") != 0) { 5771 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "ttl"); 5772 return; 5773 } 5774 5775 n_tokens -= 7; 5776 tokens += 7; 5777 5778 /* clear */ 5779 if (n_tokens && (strcmp(tokens[0], "clear") == 0)) { 5780 clear = 1; 5781 5782 n_tokens--; 5783 tokens++; 5784 } 5785 5786 /* match */ 5787 if ((n_tokens == 0) || strcmp(tokens[0], "match")) { 5788 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match"); 5789 return; 5790 } 5791 5792 n_tokens_parsed = parse_match(tokens, 5793 n_tokens, 5794 out, 5795 out_size, 5796 &m); 5797 if (n_tokens_parsed == 0) 5798 return; 5799 n_tokens -= n_tokens_parsed; 5800 tokens += n_tokens_parsed; 5801 5802 /* end */ 5803 if (n_tokens) { 5804 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]); 5805 return; 5806 } 5807 5808 /* Read table rule TTL stats. */ 5809 status = pipeline_table_rule_ttl_read(pipeline_name, 5810 table_id, 5811 &m, 5812 &stats, 5813 clear); 5814 if (status) { 5815 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 5816 return; 5817 } 5818 5819 /* Print stats. */ 5820 snprintf(out, out_size, "Packets: %" PRIu64 "\n", 5821 stats.n_packets); 5822 } 5823 5824 static const char cmd_pipeline_table_rule_time_read_help[] = 5825 "pipeline <pipeline_name> table <table_id> rule read time\n" 5826 " match <match>\n"; 5827 5828 static void 5829 cmd_pipeline_table_rule_time_read(char **tokens, 5830 uint32_t n_tokens, 5831 char *out, 5832 size_t out_size) 5833 { 5834 struct table_rule_match m; 5835 char *pipeline_name; 5836 uint64_t timestamp; 5837 uint32_t table_id, n_tokens_parsed; 5838 int status; 5839 5840 if (n_tokens < 7) { 5841 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 5842 return; 5843 } 5844 5845 pipeline_name = tokens[1]; 5846 5847 if (strcmp(tokens[2], "table") != 0) { 5848 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "table"); 5849 return; 5850 } 5851 5852 if (parser_read_uint32(&table_id, tokens[3]) != 0) { 5853 snprintf(out, out_size, MSG_ARG_INVALID, "table_id"); 5854 return; 5855 } 5856 5857 if (strcmp(tokens[4], "rule") != 0) { 5858 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "rule"); 5859 return; 5860 } 5861 5862 if (strcmp(tokens[5], "read") != 0) { 5863 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "read"); 5864 return; 5865 } 5866 5867 if (strcmp(tokens[6], "time") != 0) { 5868 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "time"); 5869 return; 5870 } 5871 5872 n_tokens -= 7; 5873 tokens += 7; 5874 5875 /* match */ 5876 if ((n_tokens == 0) || strcmp(tokens[0], "match")) { 5877 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "match"); 5878 return; 5879 } 5880 5881 n_tokens_parsed = parse_match(tokens, 5882 n_tokens, 5883 out, 5884 out_size, 5885 &m); 5886 if (n_tokens_parsed == 0) 5887 return; 5888 n_tokens -= n_tokens_parsed; 5889 tokens += n_tokens_parsed; 5890 5891 /* end */ 5892 if (n_tokens) { 5893 snprintf(out, out_size, MSG_ARG_INVALID, tokens[0]); 5894 return; 5895 } 5896 5897 /* Read table rule timestamp. */ 5898 status = pipeline_table_rule_time_read(pipeline_name, 5899 table_id, 5900 &m, 5901 ×tamp); 5902 if (status) { 5903 snprintf(out, out_size, MSG_CMD_FAIL, tokens[0]); 5904 return; 5905 } 5906 5907 /* Print stats. */ 5908 snprintf(out, out_size, "Packets: %" PRIu64 "\n", timestamp); 5909 } 5910 5911 static const char cmd_thread_pipeline_enable_help[] = 5912 "thread <thread_id> pipeline <pipeline_name> enable\n"; 5913 5914 static void 5915 cmd_thread_pipeline_enable(char **tokens, 5916 uint32_t n_tokens, 5917 char *out, 5918 size_t out_size) 5919 { 5920 char *pipeline_name; 5921 uint32_t thread_id; 5922 int status; 5923 5924 if (n_tokens != 5) { 5925 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 5926 return; 5927 } 5928 5929 if (parser_read_uint32(&thread_id, tokens[1]) != 0) { 5930 snprintf(out, out_size, MSG_ARG_INVALID, "thread_id"); 5931 return; 5932 } 5933 5934 if (strcmp(tokens[2], "pipeline") != 0) { 5935 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pipeline"); 5936 return; 5937 } 5938 5939 pipeline_name = tokens[3]; 5940 5941 if (strcmp(tokens[4], "enable") != 0) { 5942 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "enable"); 5943 return; 5944 } 5945 5946 status = thread_pipeline_enable(thread_id, pipeline_name); 5947 if (status) { 5948 snprintf(out, out_size, MSG_CMD_FAIL, "thread pipeline enable"); 5949 return; 5950 } 5951 } 5952 5953 5954 static const char cmd_thread_pipeline_disable_help[] = 5955 "thread <thread_id> pipeline <pipeline_name> disable\n"; 5956 5957 static void 5958 cmd_thread_pipeline_disable(char **tokens, 5959 uint32_t n_tokens, 5960 char *out, 5961 size_t out_size) 5962 { 5963 char *pipeline_name; 5964 uint32_t thread_id; 5965 int status; 5966 5967 if (n_tokens != 5) { 5968 snprintf(out, out_size, MSG_ARG_MISMATCH, tokens[0]); 5969 return; 5970 } 5971 5972 if (parser_read_uint32(&thread_id, tokens[1]) != 0) { 5973 snprintf(out, out_size, MSG_ARG_INVALID, "thread_id"); 5974 return; 5975 } 5976 5977 if (strcmp(tokens[2], "pipeline") != 0) { 5978 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "pipeline"); 5979 return; 5980 } 5981 5982 pipeline_name = tokens[3]; 5983 5984 if (strcmp(tokens[4], "disable") != 0) { 5985 snprintf(out, out_size, MSG_ARG_NOT_FOUND, "disable"); 5986 return; 5987 } 5988 5989 status = thread_pipeline_disable(thread_id, pipeline_name); 5990 if (status) { 5991 snprintf(out, out_size, MSG_CMD_FAIL, 5992 "thread pipeline disable"); 5993 return; 5994 } 5995 } 5996 5997 static void 5998 cmd_help(char **tokens, uint32_t n_tokens, char *out, size_t out_size) 5999 { 6000 tokens++; 6001 n_tokens--; 6002 6003 if (n_tokens == 0) { 6004 snprintf(out, out_size, 6005 "Type 'help <command>' for details on each command.\n\n" 6006 "List of commands:\n" 6007 "\tmempool\n" 6008 "\tlink\n" 6009 "\tswq\n" 6010 "\ttmgr subport profile\n" 6011 "\ttmgr pipe profile\n" 6012 "\ttmgr\n" 6013 "\ttmgr subport\n" 6014 "\ttmgr subport pipe\n" 6015 "\ttap\n" 6016 "\tkni\n" 6017 "\tport in action profile\n" 6018 "\ttable action profile\n" 6019 "\tpipeline\n" 6020 "\tpipeline port in\n" 6021 "\tpipeline port out\n" 6022 "\tpipeline table\n" 6023 "\tpipeline port in table\n" 6024 "\tpipeline port in stats\n" 6025 "\tpipeline port in enable\n" 6026 "\tpipeline port in disable\n" 6027 "\tpipeline port out stats\n" 6028 "\tpipeline table stats\n" 6029 "\tpipeline table rule add\n" 6030 "\tpipeline table rule add default\n" 6031 "\tpipeline table rule add bulk\n" 6032 "\tpipeline table rule delete\n" 6033 "\tpipeline table rule delete default\n" 6034 "\tpipeline table rule show\n" 6035 "\tpipeline table rule stats read\n" 6036 "\tpipeline table meter profile add\n" 6037 "\tpipeline table meter profile delete\n" 6038 "\tpipeline table rule meter read\n" 6039 "\tpipeline table dscp\n" 6040 "\tpipeline table rule ttl read\n" 6041 "\tpipeline table rule time read\n" 6042 "\tthread pipeline enable\n" 6043 "\tthread pipeline disable\n\n"); 6044 return; 6045 } 6046 6047 if (strcmp(tokens[0], "mempool") == 0) { 6048 snprintf(out, out_size, "\n%s\n", cmd_mempool_help); 6049 return; 6050 } 6051 6052 if (strcmp(tokens[0], "link") == 0) { 6053 snprintf(out, out_size, "\n%s\n", cmd_link_help); 6054 return; 6055 } 6056 6057 if (strcmp(tokens[0], "swq") == 0) { 6058 snprintf(out, out_size, "\n%s\n", cmd_swq_help); 6059 return; 6060 } 6061 6062 if (strcmp(tokens[0], "tmgr") == 0) { 6063 if (n_tokens == 1) { 6064 snprintf(out, out_size, "\n%s\n", cmd_tmgr_help); 6065 return; 6066 } 6067 6068 if ((n_tokens == 2) && 6069 (strcmp(tokens[1], "subport")) == 0) { 6070 snprintf(out, out_size, "\n%s\n", cmd_tmgr_subport_help); 6071 return; 6072 } 6073 6074 if ((n_tokens == 3) && 6075 (strcmp(tokens[1], "subport") == 0) && 6076 (strcmp(tokens[2], "profile") == 0)) { 6077 snprintf(out, out_size, "\n%s\n", 6078 cmd_tmgr_subport_profile_help); 6079 return; 6080 } 6081 6082 if ((n_tokens == 3) && 6083 (strcmp(tokens[1], "subport") == 0) && 6084 (strcmp(tokens[2], "pipe") == 0)) { 6085 snprintf(out, out_size, "\n%s\n", cmd_tmgr_subport_pipe_help); 6086 return; 6087 } 6088 6089 if ((n_tokens == 3) && 6090 (strcmp(tokens[1], "pipe") == 0) && 6091 (strcmp(tokens[2], "profile") == 0)) { 6092 snprintf(out, out_size, "\n%s\n", cmd_tmgr_pipe_profile_help); 6093 return; 6094 } 6095 } 6096 6097 if (strcmp(tokens[0], "tap") == 0) { 6098 snprintf(out, out_size, "\n%s\n", cmd_tap_help); 6099 return; 6100 } 6101 6102 if (strcmp(tokens[0], "kni") == 0) { 6103 snprintf(out, out_size, "\n%s\n", cmd_kni_help); 6104 return; 6105 } 6106 6107 if (strcmp(tokens[0], "cryptodev") == 0) { 6108 snprintf(out, out_size, "\n%s\n", cmd_cryptodev_help); 6109 return; 6110 } 6111 6112 if ((n_tokens == 4) && 6113 (strcmp(tokens[0], "port") == 0) && 6114 (strcmp(tokens[1], "in") == 0) && 6115 (strcmp(tokens[2], "action") == 0) && 6116 (strcmp(tokens[3], "profile") == 0)) { 6117 snprintf(out, out_size, "\n%s\n", cmd_port_in_action_profile_help); 6118 return; 6119 } 6120 6121 if ((n_tokens == 3) && 6122 (strcmp(tokens[0], "table") == 0) && 6123 (strcmp(tokens[1], "action") == 0) && 6124 (strcmp(tokens[2], "profile") == 0)) { 6125 snprintf(out, out_size, "\n%s\n", cmd_table_action_profile_help); 6126 return; 6127 } 6128 6129 if ((strcmp(tokens[0], "pipeline") == 0) && (n_tokens == 1)) { 6130 snprintf(out, out_size, "\n%s\n", cmd_pipeline_help); 6131 return; 6132 } 6133 6134 if ((strcmp(tokens[0], "pipeline") == 0) && 6135 (strcmp(tokens[1], "port") == 0)) { 6136 if ((n_tokens == 3) && (strcmp(tokens[2], "in")) == 0) { 6137 snprintf(out, out_size, "\n%s\n", cmd_pipeline_port_in_help); 6138 return; 6139 } 6140 6141 if ((n_tokens == 3) && (strcmp(tokens[2], "out")) == 0) { 6142 snprintf(out, out_size, "\n%s\n", cmd_pipeline_port_out_help); 6143 return; 6144 } 6145 6146 if ((n_tokens == 4) && 6147 (strcmp(tokens[2], "in") == 0) && 6148 (strcmp(tokens[3], "table") == 0)) { 6149 snprintf(out, out_size, "\n%s\n", 6150 cmd_pipeline_port_in_table_help); 6151 return; 6152 } 6153 6154 if ((n_tokens == 4) && 6155 (strcmp(tokens[2], "in") == 0) && 6156 (strcmp(tokens[3], "stats") == 0)) { 6157 snprintf(out, out_size, "\n%s\n", 6158 cmd_pipeline_port_in_stats_help); 6159 return; 6160 } 6161 6162 if ((n_tokens == 4) && 6163 (strcmp(tokens[2], "in") == 0) && 6164 (strcmp(tokens[3], "enable") == 0)) { 6165 snprintf(out, out_size, "\n%s\n", 6166 cmd_pipeline_port_in_enable_help); 6167 return; 6168 } 6169 6170 if ((n_tokens == 4) && 6171 (strcmp(tokens[2], "in") == 0) && 6172 (strcmp(tokens[3], "disable") == 0)) { 6173 snprintf(out, out_size, "\n%s\n", 6174 cmd_pipeline_port_in_disable_help); 6175 return; 6176 } 6177 6178 if ((n_tokens == 4) && 6179 (strcmp(tokens[2], "out") == 0) && 6180 (strcmp(tokens[3], "stats") == 0)) { 6181 snprintf(out, out_size, "\n%s\n", 6182 cmd_pipeline_port_out_stats_help); 6183 return; 6184 } 6185 } 6186 6187 if ((strcmp(tokens[0], "pipeline") == 0) && 6188 (strcmp(tokens[1], "table") == 0)) { 6189 if (n_tokens == 2) { 6190 snprintf(out, out_size, "\n%s\n", cmd_pipeline_table_help); 6191 return; 6192 } 6193 6194 if ((n_tokens == 3) && strcmp(tokens[2], "stats") == 0) { 6195 snprintf(out, out_size, "\n%s\n", 6196 cmd_pipeline_table_stats_help); 6197 return; 6198 } 6199 6200 if ((n_tokens == 3) && strcmp(tokens[2], "dscp") == 0) { 6201 snprintf(out, out_size, "\n%s\n", 6202 cmd_pipeline_table_dscp_help); 6203 return; 6204 } 6205 6206 if ((n_tokens == 4) && 6207 (strcmp(tokens[2], "rule") == 0) && 6208 (strcmp(tokens[3], "add") == 0)) { 6209 snprintf(out, out_size, "\n%s\n", 6210 cmd_pipeline_table_rule_add_help); 6211 return; 6212 } 6213 6214 if ((n_tokens == 5) && 6215 (strcmp(tokens[2], "rule") == 0) && 6216 (strcmp(tokens[3], "add") == 0) && 6217 (strcmp(tokens[4], "default") == 0)) { 6218 snprintf(out, out_size, "\n%s\n", 6219 cmd_pipeline_table_rule_add_default_help); 6220 return; 6221 } 6222 6223 if ((n_tokens == 5) && 6224 (strcmp(tokens[2], "rule") == 0) && 6225 (strcmp(tokens[3], "add") == 0) && 6226 (strcmp(tokens[4], "bulk") == 0)) { 6227 snprintf(out, out_size, "\n%s\n", 6228 cmd_pipeline_table_rule_add_bulk_help); 6229 return; 6230 } 6231 6232 if ((n_tokens == 4) && 6233 (strcmp(tokens[2], "rule") == 0) && 6234 (strcmp(tokens[3], "delete") == 0)) { 6235 snprintf(out, out_size, "\n%s\n", 6236 cmd_pipeline_table_rule_delete_help); 6237 return; 6238 } 6239 6240 if ((n_tokens == 5) && 6241 (strcmp(tokens[2], "rule") == 0) && 6242 (strcmp(tokens[3], "delete") == 0) && 6243 (strcmp(tokens[4], "default") == 0)) { 6244 snprintf(out, out_size, "\n%s\n", 6245 cmd_pipeline_table_rule_delete_default_help); 6246 return; 6247 } 6248 6249 if ((n_tokens == 4) && 6250 (strcmp(tokens[2], "rule") == 0) && 6251 (strcmp(tokens[3], "show") == 0)) { 6252 snprintf(out, out_size, "\n%s\n", 6253 cmd_pipeline_table_rule_show_help); 6254 return; 6255 } 6256 6257 if ((n_tokens == 5) && 6258 (strcmp(tokens[2], "rule") == 0) && 6259 (strcmp(tokens[3], "stats") == 0) && 6260 (strcmp(tokens[4], "read") == 0)) { 6261 snprintf(out, out_size, "\n%s\n", 6262 cmd_pipeline_table_rule_stats_read_help); 6263 return; 6264 } 6265 6266 if ((n_tokens == 5) && 6267 (strcmp(tokens[2], "meter") == 0) && 6268 (strcmp(tokens[3], "profile") == 0) && 6269 (strcmp(tokens[4], "add") == 0)) { 6270 snprintf(out, out_size, "\n%s\n", 6271 cmd_pipeline_table_meter_profile_add_help); 6272 return; 6273 } 6274 6275 if ((n_tokens == 5) && 6276 (strcmp(tokens[2], "meter") == 0) && 6277 (strcmp(tokens[3], "profile") == 0) && 6278 (strcmp(tokens[4], "delete") == 0)) { 6279 snprintf(out, out_size, "\n%s\n", 6280 cmd_pipeline_table_meter_profile_delete_help); 6281 return; 6282 } 6283 6284 if ((n_tokens == 5) && 6285 (strcmp(tokens[2], "rule") == 0) && 6286 (strcmp(tokens[3], "meter") == 0) && 6287 (strcmp(tokens[4], "read") == 0)) { 6288 snprintf(out, out_size, "\n%s\n", 6289 cmd_pipeline_table_rule_meter_read_help); 6290 return; 6291 } 6292 6293 if ((n_tokens == 5) && 6294 (strcmp(tokens[2], "rule") == 0) && 6295 (strcmp(tokens[3], "ttl") == 0) && 6296 (strcmp(tokens[4], "read") == 0)) { 6297 snprintf(out, out_size, "\n%s\n", 6298 cmd_pipeline_table_rule_ttl_read_help); 6299 return; 6300 } 6301 6302 if ((n_tokens == 5) && 6303 (strcmp(tokens[2], "rule") == 0) && 6304 (strcmp(tokens[3], "time") == 0) && 6305 (strcmp(tokens[4], "read") == 0)) { 6306 snprintf(out, out_size, "\n%s\n", 6307 cmd_pipeline_table_rule_time_read_help); 6308 return; 6309 } 6310 } 6311 6312 if ((n_tokens == 3) && 6313 (strcmp(tokens[0], "thread") == 0) && 6314 (strcmp(tokens[1], "pipeline") == 0)) { 6315 if (strcmp(tokens[2], "enable") == 0) { 6316 snprintf(out, out_size, "\n%s\n", 6317 cmd_thread_pipeline_enable_help); 6318 return; 6319 } 6320 6321 if (strcmp(tokens[2], "disable") == 0) { 6322 snprintf(out, out_size, "\n%s\n", 6323 cmd_thread_pipeline_disable_help); 6324 return; 6325 } 6326 } 6327 6328 snprintf(out, out_size, "Invalid command\n"); 6329 } 6330 6331 void 6332 cli_process(char *in, char *out, size_t out_size) 6333 { 6334 char *tokens[CMD_MAX_TOKENS]; 6335 uint32_t n_tokens = RTE_DIM(tokens); 6336 int status; 6337 6338 if (is_comment(in)) 6339 return; 6340 6341 status = parse_tokenize_string(in, tokens, &n_tokens); 6342 if (status) { 6343 snprintf(out, out_size, MSG_ARG_TOO_MANY, ""); 6344 return; 6345 } 6346 6347 if (n_tokens == 0) 6348 return; 6349 6350 if (strcmp(tokens[0], "help") == 0) { 6351 cmd_help(tokens, n_tokens, out, out_size); 6352 return; 6353 } 6354 6355 if (strcmp(tokens[0], "mempool") == 0) { 6356 cmd_mempool(tokens, n_tokens, out, out_size); 6357 return; 6358 } 6359 6360 if (strcmp(tokens[0], "link") == 0) { 6361 if (strcmp(tokens[1], "show") == 0) { 6362 cmd_link_show(tokens, n_tokens, out, out_size); 6363 return; 6364 } 6365 6366 cmd_link(tokens, n_tokens, out, out_size); 6367 return; 6368 } 6369 6370 if (strcmp(tokens[0], "swq") == 0) { 6371 cmd_swq(tokens, n_tokens, out, out_size); 6372 return; 6373 } 6374 6375 if (strcmp(tokens[0], "tmgr") == 0) { 6376 if ((n_tokens >= 3) && 6377 (strcmp(tokens[1], "subport") == 0) && 6378 (strcmp(tokens[2], "profile") == 0)) { 6379 cmd_tmgr_subport_profile(tokens, n_tokens, 6380 out, out_size); 6381 return; 6382 } 6383 6384 if ((n_tokens >= 3) && 6385 (strcmp(tokens[1], "pipe") == 0) && 6386 (strcmp(tokens[2], "profile") == 0)) { 6387 cmd_tmgr_pipe_profile(tokens, n_tokens, out, out_size); 6388 return; 6389 } 6390 6391 if ((n_tokens >= 5) && 6392 (strcmp(tokens[2], "subport") == 0) && 6393 (strcmp(tokens[4], "profile") == 0)) { 6394 cmd_tmgr_subport(tokens, n_tokens, out, out_size); 6395 return; 6396 } 6397 6398 if ((n_tokens >= 5) && 6399 (strcmp(tokens[2], "subport") == 0) && 6400 (strcmp(tokens[4], "pipe") == 0)) { 6401 cmd_tmgr_subport_pipe(tokens, n_tokens, out, out_size); 6402 return; 6403 } 6404 6405 cmd_tmgr(tokens, n_tokens, out, out_size); 6406 return; 6407 } 6408 6409 if (strcmp(tokens[0], "tap") == 0) { 6410 cmd_tap(tokens, n_tokens, out, out_size); 6411 return; 6412 } 6413 6414 if (strcmp(tokens[0], "kni") == 0) { 6415 cmd_kni(tokens, n_tokens, out, out_size); 6416 return; 6417 } 6418 6419 if (strcmp(tokens[0], "cryptodev") == 0) { 6420 cmd_cryptodev(tokens, n_tokens, out, out_size); 6421 return; 6422 } 6423 6424 if (strcmp(tokens[0], "port") == 0) { 6425 cmd_port_in_action_profile(tokens, n_tokens, out, out_size); 6426 return; 6427 } 6428 6429 if (strcmp(tokens[0], "table") == 0) { 6430 cmd_table_action_profile(tokens, n_tokens, out, out_size); 6431 return; 6432 } 6433 6434 if (strcmp(tokens[0], "pipeline") == 0) { 6435 if ((n_tokens >= 3) && 6436 (strcmp(tokens[2], "period") == 0)) { 6437 cmd_pipeline(tokens, n_tokens, out, out_size); 6438 return; 6439 } 6440 6441 if ((n_tokens >= 5) && 6442 (strcmp(tokens[2], "port") == 0) && 6443 (strcmp(tokens[3], "in") == 0) && 6444 (strcmp(tokens[4], "bsz") == 0)) { 6445 cmd_pipeline_port_in(tokens, n_tokens, out, out_size); 6446 return; 6447 } 6448 6449 if ((n_tokens >= 5) && 6450 (strcmp(tokens[2], "port") == 0) && 6451 (strcmp(tokens[3], "out") == 0) && 6452 (strcmp(tokens[4], "bsz") == 0)) { 6453 cmd_pipeline_port_out(tokens, n_tokens, out, out_size); 6454 return; 6455 } 6456 6457 if ((n_tokens >= 4) && 6458 (strcmp(tokens[2], "table") == 0) && 6459 (strcmp(tokens[3], "match") == 0)) { 6460 cmd_pipeline_table(tokens, n_tokens, out, out_size); 6461 return; 6462 } 6463 6464 if ((n_tokens >= 6) && 6465 (strcmp(tokens[2], "port") == 0) && 6466 (strcmp(tokens[3], "in") == 0) && 6467 (strcmp(tokens[5], "table") == 0)) { 6468 cmd_pipeline_port_in_table(tokens, n_tokens, 6469 out, out_size); 6470 return; 6471 } 6472 6473 if ((n_tokens >= 6) && 6474 (strcmp(tokens[2], "port") == 0) && 6475 (strcmp(tokens[3], "in") == 0) && 6476 (strcmp(tokens[5], "stats") == 0)) { 6477 cmd_pipeline_port_in_stats(tokens, n_tokens, 6478 out, out_size); 6479 return; 6480 } 6481 6482 if ((n_tokens >= 6) && 6483 (strcmp(tokens[2], "port") == 0) && 6484 (strcmp(tokens[3], "in") == 0) && 6485 (strcmp(tokens[5], "enable") == 0)) { 6486 cmd_pipeline_port_in_enable(tokens, n_tokens, 6487 out, out_size); 6488 return; 6489 } 6490 6491 if ((n_tokens >= 6) && 6492 (strcmp(tokens[2], "port") == 0) && 6493 (strcmp(tokens[3], "in") == 0) && 6494 (strcmp(tokens[5], "disable") == 0)) { 6495 cmd_pipeline_port_in_disable(tokens, n_tokens, 6496 out, out_size); 6497 return; 6498 } 6499 6500 if ((n_tokens >= 6) && 6501 (strcmp(tokens[2], "port") == 0) && 6502 (strcmp(tokens[3], "out") == 0) && 6503 (strcmp(tokens[5], "stats") == 0)) { 6504 cmd_pipeline_port_out_stats(tokens, n_tokens, 6505 out, out_size); 6506 return; 6507 } 6508 6509 if ((n_tokens >= 5) && 6510 (strcmp(tokens[2], "table") == 0) && 6511 (strcmp(tokens[4], "stats") == 0)) { 6512 cmd_pipeline_table_stats(tokens, n_tokens, 6513 out, out_size); 6514 return; 6515 } 6516 6517 if ((n_tokens >= 7) && 6518 (strcmp(tokens[2], "table") == 0) && 6519 (strcmp(tokens[4], "rule") == 0) && 6520 (strcmp(tokens[5], "add") == 0) && 6521 (strcmp(tokens[6], "match") == 0)) { 6522 if ((n_tokens >= 8) && 6523 (strcmp(tokens[7], "default") == 0)) { 6524 cmd_pipeline_table_rule_add_default(tokens, 6525 n_tokens, out, out_size); 6526 return; 6527 } 6528 6529 cmd_pipeline_table_rule_add(tokens, n_tokens, 6530 out, out_size); 6531 return; 6532 } 6533 6534 if ((n_tokens >= 7) && 6535 (strcmp(tokens[2], "table") == 0) && 6536 (strcmp(tokens[4], "rule") == 0) && 6537 (strcmp(tokens[5], "add") == 0) && 6538 (strcmp(tokens[6], "bulk") == 0)) { 6539 cmd_pipeline_table_rule_add_bulk(tokens, 6540 n_tokens, out, out_size); 6541 return; 6542 } 6543 6544 if ((n_tokens >= 7) && 6545 (strcmp(tokens[2], "table") == 0) && 6546 (strcmp(tokens[4], "rule") == 0) && 6547 (strcmp(tokens[5], "delete") == 0) && 6548 (strcmp(tokens[6], "match") == 0)) { 6549 if ((n_tokens >= 8) && 6550 (strcmp(tokens[7], "default") == 0)) { 6551 cmd_pipeline_table_rule_delete_default(tokens, 6552 n_tokens, out, out_size); 6553 return; 6554 } 6555 6556 cmd_pipeline_table_rule_delete(tokens, n_tokens, 6557 out, out_size); 6558 return; 6559 } 6560 6561 if ((n_tokens >= 6) && 6562 (strcmp(tokens[2], "table") == 0) && 6563 (strcmp(tokens[4], "rule") == 0) && 6564 (strcmp(tokens[5], "show") == 0)) { 6565 cmd_pipeline_table_rule_show(tokens, n_tokens, 6566 out, out_size); 6567 return; 6568 } 6569 6570 if ((n_tokens >= 7) && 6571 (strcmp(tokens[2], "table") == 0) && 6572 (strcmp(tokens[4], "rule") == 0) && 6573 (strcmp(tokens[5], "read") == 0) && 6574 (strcmp(tokens[6], "stats") == 0)) { 6575 cmd_pipeline_table_rule_stats_read(tokens, n_tokens, 6576 out, out_size); 6577 return; 6578 } 6579 6580 if ((n_tokens >= 8) && 6581 (strcmp(tokens[2], "table") == 0) && 6582 (strcmp(tokens[4], "meter") == 0) && 6583 (strcmp(tokens[5], "profile") == 0) && 6584 (strcmp(tokens[7], "add") == 0)) { 6585 cmd_pipeline_table_meter_profile_add(tokens, n_tokens, 6586 out, out_size); 6587 return; 6588 } 6589 6590 if ((n_tokens >= 8) && 6591 (strcmp(tokens[2], "table") == 0) && 6592 (strcmp(tokens[4], "meter") == 0) && 6593 (strcmp(tokens[5], "profile") == 0) && 6594 (strcmp(tokens[7], "delete") == 0)) { 6595 cmd_pipeline_table_meter_profile_delete(tokens, 6596 n_tokens, out, out_size); 6597 return; 6598 } 6599 6600 if ((n_tokens >= 7) && 6601 (strcmp(tokens[2], "table") == 0) && 6602 (strcmp(tokens[4], "rule") == 0) && 6603 (strcmp(tokens[5], "read") == 0) && 6604 (strcmp(tokens[6], "meter") == 0)) { 6605 cmd_pipeline_table_rule_meter_read(tokens, n_tokens, 6606 out, out_size); 6607 return; 6608 } 6609 6610 if ((n_tokens >= 5) && 6611 (strcmp(tokens[2], "table") == 0) && 6612 (strcmp(tokens[4], "dscp") == 0)) { 6613 cmd_pipeline_table_dscp(tokens, n_tokens, 6614 out, out_size); 6615 return; 6616 } 6617 6618 if ((n_tokens >= 7) && 6619 (strcmp(tokens[2], "table") == 0) && 6620 (strcmp(tokens[4], "rule") == 0) && 6621 (strcmp(tokens[5], "read") == 0) && 6622 (strcmp(tokens[6], "ttl") == 0)) { 6623 cmd_pipeline_table_rule_ttl_read(tokens, n_tokens, 6624 out, out_size); 6625 return; 6626 } 6627 6628 if ((n_tokens >= 7) && 6629 (strcmp(tokens[2], "table") == 0) && 6630 (strcmp(tokens[4], "rule") == 0) && 6631 (strcmp(tokens[5], "read") == 0) && 6632 (strcmp(tokens[6], "time") == 0)) { 6633 cmd_pipeline_table_rule_time_read(tokens, n_tokens, 6634 out, out_size); 6635 return; 6636 } 6637 } 6638 6639 if (strcmp(tokens[0], "thread") == 0) { 6640 if ((n_tokens >= 5) && 6641 (strcmp(tokens[4], "enable") == 0)) { 6642 cmd_thread_pipeline_enable(tokens, n_tokens, 6643 out, out_size); 6644 return; 6645 } 6646 6647 if ((n_tokens >= 5) && 6648 (strcmp(tokens[4], "disable") == 0)) { 6649 cmd_thread_pipeline_disable(tokens, n_tokens, 6650 out, out_size); 6651 return; 6652 } 6653 } 6654 6655 snprintf(out, out_size, MSG_CMD_UNKNOWN, tokens[0]); 6656 } 6657 6658 int 6659 cli_script_process(const char *file_name, 6660 size_t msg_in_len_max, 6661 size_t msg_out_len_max) 6662 { 6663 char *msg_in = NULL, *msg_out = NULL; 6664 FILE *f = NULL; 6665 6666 /* Check input arguments */ 6667 if ((file_name == NULL) || 6668 (strlen(file_name) == 0) || 6669 (msg_in_len_max == 0) || 6670 (msg_out_len_max == 0)) 6671 return -EINVAL; 6672 6673 msg_in = malloc(msg_in_len_max + 1); 6674 msg_out = malloc(msg_out_len_max + 1); 6675 if ((msg_in == NULL) || 6676 (msg_out == NULL)) { 6677 free(msg_out); 6678 free(msg_in); 6679 return -ENOMEM; 6680 } 6681 6682 /* Open input file */ 6683 f = fopen(file_name, "r"); 6684 if (f == NULL) { 6685 free(msg_out); 6686 free(msg_in); 6687 return -EIO; 6688 } 6689 6690 /* Read file */ 6691 for ( ; ; ) { 6692 if (fgets(msg_in, msg_in_len_max + 1, f) == NULL) 6693 break; 6694 6695 printf("%s", msg_in); 6696 msg_out[0] = 0; 6697 6698 cli_process(msg_in, 6699 msg_out, 6700 msg_out_len_max); 6701 6702 if (strlen(msg_out)) 6703 printf("%s", msg_out); 6704 } 6705 6706 /* Close file */ 6707 fclose(f); 6708 free(msg_out); 6709 free(msg_in); 6710 return 0; 6711 } 6712 6713 static int 6714 cli_rule_file_process(const char *file_name, 6715 size_t line_len_max, 6716 struct table_rule_list **rule_list, 6717 uint32_t *n_rules, 6718 uint32_t *line_number, 6719 char *out, 6720 size_t out_size) 6721 { 6722 struct table_rule_list *list = NULL; 6723 char *line = NULL; 6724 FILE *f = NULL; 6725 uint32_t rule_id = 0, line_id = 0; 6726 int status = 0; 6727 6728 /* Check input arguments */ 6729 if ((file_name == NULL) || 6730 (strlen(file_name) == 0) || 6731 (line_len_max == 0) || 6732 (rule_list == NULL) || 6733 (n_rules == NULL) || 6734 (line_number == NULL) || 6735 (out == NULL)) { 6736 status = -EINVAL; 6737 goto cli_rule_file_process_free; 6738 } 6739 6740 /* Memory allocation */ 6741 list = malloc(sizeof(struct table_rule_list)); 6742 if (list == NULL) { 6743 status = -ENOMEM; 6744 goto cli_rule_file_process_free; 6745 } 6746 6747 TAILQ_INIT(list); 6748 6749 line = malloc(line_len_max + 1); 6750 if (line == NULL) { 6751 status = -ENOMEM; 6752 goto cli_rule_file_process_free; 6753 } 6754 6755 /* Open file */ 6756 f = fopen(file_name, "r"); 6757 if (f == NULL) { 6758 status = -EIO; 6759 goto cli_rule_file_process_free; 6760 } 6761 6762 /* Read file */ 6763 for (line_id = 1, rule_id = 0; ; line_id++) { 6764 char *tokens[CMD_MAX_TOKENS]; 6765 struct table_rule *rule = NULL; 6766 uint32_t n_tokens, n_tokens_parsed, t0; 6767 6768 /* Read next line from file. */ 6769 if (fgets(line, line_len_max + 1, f) == NULL) 6770 break; 6771 6772 /* Comment. */ 6773 if (is_comment(line)) 6774 continue; 6775 6776 /* Parse line. */ 6777 n_tokens = RTE_DIM(tokens); 6778 status = parse_tokenize_string(line, tokens, &n_tokens); 6779 if (status) { 6780 status = -EINVAL; 6781 goto cli_rule_file_process_free; 6782 } 6783 6784 /* Empty line. */ 6785 if (n_tokens == 0) 6786 continue; 6787 t0 = 0; 6788 6789 /* Rule alloc and insert. */ 6790 rule = calloc(1, sizeof(struct table_rule)); 6791 if (rule == NULL) { 6792 status = -ENOMEM; 6793 goto cli_rule_file_process_free; 6794 } 6795 6796 TAILQ_INSERT_TAIL(list, rule, node); 6797 6798 /* Rule match. */ 6799 n_tokens_parsed = parse_match(tokens + t0, 6800 n_tokens - t0, 6801 out, 6802 out_size, 6803 &rule->match); 6804 if (n_tokens_parsed == 0) { 6805 status = -EINVAL; 6806 goto cli_rule_file_process_free; 6807 } 6808 t0 += n_tokens_parsed; 6809 6810 /* Rule action. */ 6811 n_tokens_parsed = parse_table_action(tokens + t0, 6812 n_tokens - t0, 6813 out, 6814 out_size, 6815 &rule->action); 6816 if (n_tokens_parsed == 0) { 6817 status = -EINVAL; 6818 goto cli_rule_file_process_free; 6819 } 6820 t0 += n_tokens_parsed; 6821 6822 /* Line completed. */ 6823 if (t0 < n_tokens) { 6824 status = -EINVAL; 6825 goto cli_rule_file_process_free; 6826 } 6827 6828 /* Increment rule count */ 6829 rule_id++; 6830 } 6831 6832 /* Close file */ 6833 fclose(f); 6834 6835 /* Memory free */ 6836 free(line); 6837 6838 *rule_list = list; 6839 *n_rules = rule_id; 6840 *line_number = line_id; 6841 return 0; 6842 6843 cli_rule_file_process_free: 6844 *rule_list = NULL; 6845 *n_rules = rule_id; 6846 *line_number = line_id; 6847 6848 for ( ; ; ) { 6849 struct table_rule *rule; 6850 6851 rule = TAILQ_FIRST(list); 6852 if (rule == NULL) 6853 break; 6854 6855 TAILQ_REMOVE(list, rule, node); 6856 free(rule); 6857 } 6858 6859 if (f) 6860 fclose(f); 6861 free(line); 6862 free(list); 6863 6864 return status; 6865 } 6866