1 /*- 2 * BSD LICENSE 3 * 4 * Copyright(c) 2015-2016 Intel Corporation. All rights reserved. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include <time.h> 35 #include <stdio.h> 36 #include <stdlib.h> 37 #include <string.h> 38 #include <stdint.h> 39 #include <inttypes.h> 40 #include <sys/types.h> 41 #include <sys/queue.h> 42 #include <netinet/in.h> 43 #include <setjmp.h> 44 #include <stdarg.h> 45 #include <ctype.h> 46 #include <errno.h> 47 #include <getopt.h> 48 #include <fcntl.h> 49 #include <unistd.h> 50 51 #include <rte_atomic.h> 52 #include <rte_branch_prediction.h> 53 #include <rte_common.h> 54 #include <rte_cryptodev.h> 55 #include <rte_cycles.h> 56 #include <rte_debug.h> 57 #include <rte_eal.h> 58 #include <rte_ether.h> 59 #include <rte_ethdev.h> 60 #include <rte_interrupts.h> 61 #include <rte_ip.h> 62 #include <rte_launch.h> 63 #include <rte_lcore.h> 64 #include <rte_log.h> 65 #include <rte_malloc.h> 66 #include <rte_mbuf.h> 67 #include <rte_memcpy.h> 68 #include <rte_memory.h> 69 #include <rte_mempool.h> 70 #include <rte_memzone.h> 71 #include <rte_pci.h> 72 #include <rte_per_lcore.h> 73 #include <rte_prefetch.h> 74 #include <rte_random.h> 75 #include <rte_hexdump.h> 76 77 enum cdev_type { 78 CDEV_TYPE_ANY, 79 CDEV_TYPE_HW, 80 CDEV_TYPE_SW 81 }; 82 83 #define RTE_LOGTYPE_L2FWD RTE_LOGTYPE_USER1 84 85 #define NB_MBUF 8192 86 87 #define MAX_STR_LEN 32 88 #define MAX_KEY_SIZE 128 89 #define MAX_PKT_BURST 32 90 #define BURST_TX_DRAIN_US 100 /* TX drain every ~100us */ 91 92 /* 93 * Configurable number of RX/TX ring descriptors 94 */ 95 #define RTE_TEST_RX_DESC_DEFAULT 128 96 #define RTE_TEST_TX_DESC_DEFAULT 512 97 98 static uint16_t nb_rxd = RTE_TEST_RX_DESC_DEFAULT; 99 static uint16_t nb_txd = RTE_TEST_TX_DESC_DEFAULT; 100 101 /* ethernet addresses of ports */ 102 static struct ether_addr l2fwd_ports_eth_addr[RTE_MAX_ETHPORTS]; 103 104 /* mask of enabled ports */ 105 static uint64_t l2fwd_enabled_port_mask; 106 static uint64_t l2fwd_enabled_crypto_mask; 107 108 /* list of enabled ports */ 109 static uint32_t l2fwd_dst_ports[RTE_MAX_ETHPORTS]; 110 111 112 struct pkt_buffer { 113 unsigned len; 114 struct rte_mbuf *buffer[MAX_PKT_BURST]; 115 }; 116 117 struct op_buffer { 118 unsigned len; 119 struct rte_crypto_op *buffer[MAX_PKT_BURST]; 120 }; 121 122 #define MAX_RX_QUEUE_PER_LCORE 16 123 #define MAX_TX_QUEUE_PER_PORT 16 124 125 enum l2fwd_crypto_xform_chain { 126 L2FWD_CRYPTO_CIPHER_HASH, 127 L2FWD_CRYPTO_HASH_CIPHER, 128 L2FWD_CRYPTO_CIPHER_ONLY, 129 L2FWD_CRYPTO_HASH_ONLY 130 }; 131 132 struct l2fwd_key { 133 uint8_t *data; 134 uint32_t length; 135 phys_addr_t phys_addr; 136 }; 137 138 char supported_auth_algo[RTE_CRYPTO_AUTH_LIST_END][MAX_STR_LEN]; 139 char supported_cipher_algo[RTE_CRYPTO_CIPHER_LIST_END][MAX_STR_LEN]; 140 141 /** l2fwd crypto application command line options */ 142 struct l2fwd_crypto_options { 143 unsigned portmask; 144 unsigned nb_ports_per_lcore; 145 unsigned refresh_period; 146 unsigned single_lcore:1; 147 148 enum cdev_type type; 149 unsigned sessionless:1; 150 151 enum l2fwd_crypto_xform_chain xform_chain; 152 153 struct rte_crypto_sym_xform cipher_xform; 154 unsigned ckey_param; 155 int ckey_random_size; 156 157 struct l2fwd_key iv; 158 unsigned iv_param; 159 int iv_random_size; 160 161 struct rte_crypto_sym_xform auth_xform; 162 uint8_t akey_param; 163 int akey_random_size; 164 165 struct l2fwd_key aad; 166 unsigned aad_param; 167 int aad_random_size; 168 169 int digest_size; 170 171 uint16_t block_size; 172 char string_type[MAX_STR_LEN]; 173 }; 174 175 /** l2fwd crypto lcore params */ 176 struct l2fwd_crypto_params { 177 uint8_t dev_id; 178 uint8_t qp_id; 179 180 unsigned digest_length; 181 unsigned block_size; 182 183 struct l2fwd_key iv; 184 struct l2fwd_key aad; 185 struct rte_cryptodev_sym_session *session; 186 187 uint8_t do_cipher; 188 uint8_t do_hash; 189 uint8_t hash_verify; 190 191 enum rte_crypto_cipher_algorithm cipher_algo; 192 enum rte_crypto_auth_algorithm auth_algo; 193 }; 194 195 /** lcore configuration */ 196 struct lcore_queue_conf { 197 unsigned nb_rx_ports; 198 unsigned rx_port_list[MAX_RX_QUEUE_PER_LCORE]; 199 200 unsigned nb_crypto_devs; 201 unsigned cryptodev_list[MAX_RX_QUEUE_PER_LCORE]; 202 203 struct op_buffer op_buf[RTE_MAX_ETHPORTS]; 204 struct pkt_buffer pkt_buf[RTE_MAX_ETHPORTS]; 205 } __rte_cache_aligned; 206 207 struct lcore_queue_conf lcore_queue_conf[RTE_MAX_LCORE]; 208 209 static const struct rte_eth_conf port_conf = { 210 .rxmode = { 211 .mq_mode = ETH_MQ_RX_NONE, 212 .max_rx_pkt_len = ETHER_MAX_LEN, 213 .split_hdr_size = 0, 214 .header_split = 0, /**< Header Split disabled */ 215 .hw_ip_checksum = 0, /**< IP checksum offload disabled */ 216 .hw_vlan_filter = 0, /**< VLAN filtering disabled */ 217 .jumbo_frame = 0, /**< Jumbo Frame Support disabled */ 218 .hw_strip_crc = 0, /**< CRC stripped by hardware */ 219 }, 220 .txmode = { 221 .mq_mode = ETH_MQ_TX_NONE, 222 }, 223 }; 224 225 struct rte_mempool *l2fwd_pktmbuf_pool; 226 struct rte_mempool *l2fwd_crypto_op_pool; 227 228 /* Per-port statistics struct */ 229 struct l2fwd_port_statistics { 230 uint64_t tx; 231 uint64_t rx; 232 233 uint64_t crypto_enqueued; 234 uint64_t crypto_dequeued; 235 236 uint64_t dropped; 237 } __rte_cache_aligned; 238 239 struct l2fwd_crypto_statistics { 240 uint64_t enqueued; 241 uint64_t dequeued; 242 243 uint64_t errors; 244 } __rte_cache_aligned; 245 246 struct l2fwd_port_statistics port_statistics[RTE_MAX_ETHPORTS]; 247 struct l2fwd_crypto_statistics crypto_statistics[RTE_CRYPTO_MAX_DEVS]; 248 249 /* A tsc-based timer responsible for triggering statistics printout */ 250 #define TIMER_MILLISECOND 2000000ULL /* around 1ms at 2 Ghz */ 251 #define MAX_TIMER_PERIOD 86400UL /* 1 day max */ 252 253 /* default period is 10 seconds */ 254 static int64_t timer_period = 10 * TIMER_MILLISECOND * 1000; 255 256 /* Print out statistics on packets dropped */ 257 static void 258 print_stats(void) 259 { 260 uint64_t total_packets_dropped, total_packets_tx, total_packets_rx; 261 uint64_t total_packets_enqueued, total_packets_dequeued, 262 total_packets_errors; 263 unsigned portid; 264 uint64_t cdevid; 265 266 total_packets_dropped = 0; 267 total_packets_tx = 0; 268 total_packets_rx = 0; 269 total_packets_enqueued = 0; 270 total_packets_dequeued = 0; 271 total_packets_errors = 0; 272 273 const char clr[] = { 27, '[', '2', 'J', '\0' }; 274 const char topLeft[] = { 27, '[', '1', ';', '1', 'H', '\0' }; 275 276 /* Clear screen and move to top left */ 277 printf("%s%s", clr, topLeft); 278 279 printf("\nPort statistics ===================================="); 280 281 for (portid = 0; portid < RTE_MAX_ETHPORTS; portid++) { 282 /* skip disabled ports */ 283 if ((l2fwd_enabled_port_mask & (1 << portid)) == 0) 284 continue; 285 printf("\nStatistics for port %u ------------------------------" 286 "\nPackets sent: %32"PRIu64 287 "\nPackets received: %28"PRIu64 288 "\nPackets dropped: %29"PRIu64, 289 portid, 290 port_statistics[portid].tx, 291 port_statistics[portid].rx, 292 port_statistics[portid].dropped); 293 294 total_packets_dropped += port_statistics[portid].dropped; 295 total_packets_tx += port_statistics[portid].tx; 296 total_packets_rx += port_statistics[portid].rx; 297 } 298 printf("\nCrypto statistics =================================="); 299 300 for (cdevid = 0; cdevid < RTE_CRYPTO_MAX_DEVS; cdevid++) { 301 /* skip disabled ports */ 302 if ((l2fwd_enabled_crypto_mask & (1lu << cdevid)) == 0) 303 continue; 304 printf("\nStatistics for cryptodev %"PRIu64 305 " -------------------------" 306 "\nPackets enqueued: %28"PRIu64 307 "\nPackets dequeued: %28"PRIu64 308 "\nPackets errors: %30"PRIu64, 309 cdevid, 310 crypto_statistics[cdevid].enqueued, 311 crypto_statistics[cdevid].dequeued, 312 crypto_statistics[cdevid].errors); 313 314 total_packets_enqueued += crypto_statistics[cdevid].enqueued; 315 total_packets_dequeued += crypto_statistics[cdevid].dequeued; 316 total_packets_errors += crypto_statistics[cdevid].errors; 317 } 318 printf("\nAggregate statistics ===============================" 319 "\nTotal packets received: %22"PRIu64 320 "\nTotal packets enqueued: %22"PRIu64 321 "\nTotal packets dequeued: %22"PRIu64 322 "\nTotal packets sent: %26"PRIu64 323 "\nTotal packets dropped: %23"PRIu64 324 "\nTotal packets crypto errors: %17"PRIu64, 325 total_packets_rx, 326 total_packets_enqueued, 327 total_packets_dequeued, 328 total_packets_tx, 329 total_packets_dropped, 330 total_packets_errors); 331 printf("\n====================================================\n"); 332 } 333 334 static void 335 fill_supported_algorithm_tables(void) 336 { 337 unsigned i; 338 339 for (i = 0; i < RTE_CRYPTO_AUTH_LIST_END; i++) 340 strcpy(supported_auth_algo[i], "NOT_SUPPORTED"); 341 342 strcpy(supported_auth_algo[RTE_CRYPTO_AUTH_AES_GCM], "AES_GCM"); 343 strcpy(supported_auth_algo[RTE_CRYPTO_AUTH_MD5_HMAC], "MD5_HMAC"); 344 strcpy(supported_auth_algo[RTE_CRYPTO_AUTH_NULL], "NULL"); 345 strcpy(supported_auth_algo[RTE_CRYPTO_AUTH_AES_XCBC_MAC], 346 "AES_XCBC_MAC"); 347 strcpy(supported_auth_algo[RTE_CRYPTO_AUTH_SHA1_HMAC], "SHA1_HMAC"); 348 strcpy(supported_auth_algo[RTE_CRYPTO_AUTH_SHA224_HMAC], "SHA224_HMAC"); 349 strcpy(supported_auth_algo[RTE_CRYPTO_AUTH_SHA256_HMAC], "SHA256_HMAC"); 350 strcpy(supported_auth_algo[RTE_CRYPTO_AUTH_SHA384_HMAC], "SHA384_HMAC"); 351 strcpy(supported_auth_algo[RTE_CRYPTO_AUTH_SHA512_HMAC], "SHA512_HMAC"); 352 strcpy(supported_auth_algo[RTE_CRYPTO_AUTH_SNOW3G_UIA2], "SNOW3G_UIA2"); 353 strcpy(supported_auth_algo[RTE_CRYPTO_AUTH_KASUMI_F9], "KASUMI_F9"); 354 355 for (i = 0; i < RTE_CRYPTO_CIPHER_LIST_END; i++) 356 strcpy(supported_cipher_algo[i], "NOT_SUPPORTED"); 357 358 strcpy(supported_cipher_algo[RTE_CRYPTO_CIPHER_AES_CBC], "AES_CBC"); 359 strcpy(supported_cipher_algo[RTE_CRYPTO_CIPHER_AES_CTR], "AES_CTR"); 360 strcpy(supported_cipher_algo[RTE_CRYPTO_CIPHER_AES_GCM], "AES_GCM"); 361 strcpy(supported_cipher_algo[RTE_CRYPTO_CIPHER_NULL], "NULL"); 362 strcpy(supported_cipher_algo[RTE_CRYPTO_CIPHER_SNOW3G_UEA2], "SNOW3G_UEA2"); 363 strcpy(supported_cipher_algo[RTE_CRYPTO_CIPHER_KASUMI_F8], "KASUMI_F8"); 364 } 365 366 367 static int 368 l2fwd_crypto_send_burst(struct lcore_queue_conf *qconf, unsigned n, 369 struct l2fwd_crypto_params *cparams) 370 { 371 struct rte_crypto_op **op_buffer; 372 unsigned ret; 373 374 op_buffer = (struct rte_crypto_op **) 375 qconf->op_buf[cparams->dev_id].buffer; 376 377 ret = rte_cryptodev_enqueue_burst(cparams->dev_id, 378 cparams->qp_id, op_buffer, (uint16_t) n); 379 380 crypto_statistics[cparams->dev_id].enqueued += ret; 381 if (unlikely(ret < n)) { 382 crypto_statistics[cparams->dev_id].errors += (n - ret); 383 do { 384 rte_pktmbuf_free(op_buffer[ret]->sym->m_src); 385 rte_crypto_op_free(op_buffer[ret]); 386 } while (++ret < n); 387 } 388 389 return 0; 390 } 391 392 static int 393 l2fwd_crypto_enqueue(struct rte_crypto_op *op, 394 struct l2fwd_crypto_params *cparams) 395 { 396 unsigned lcore_id, len; 397 struct lcore_queue_conf *qconf; 398 399 lcore_id = rte_lcore_id(); 400 401 qconf = &lcore_queue_conf[lcore_id]; 402 len = qconf->op_buf[cparams->dev_id].len; 403 qconf->op_buf[cparams->dev_id].buffer[len] = op; 404 len++; 405 406 /* enough ops to be sent */ 407 if (len == MAX_PKT_BURST) { 408 l2fwd_crypto_send_burst(qconf, MAX_PKT_BURST, cparams); 409 len = 0; 410 } 411 412 qconf->op_buf[cparams->dev_id].len = len; 413 return 0; 414 } 415 416 static int 417 l2fwd_simple_crypto_enqueue(struct rte_mbuf *m, 418 struct rte_crypto_op *op, 419 struct l2fwd_crypto_params *cparams) 420 { 421 struct ether_hdr *eth_hdr; 422 struct ipv4_hdr *ip_hdr; 423 424 unsigned ipdata_offset, pad_len, data_len; 425 char *padding; 426 427 eth_hdr = rte_pktmbuf_mtod(m, struct ether_hdr *); 428 429 if (eth_hdr->ether_type != rte_cpu_to_be_16(ETHER_TYPE_IPv4)) 430 return -1; 431 432 ipdata_offset = sizeof(struct ether_hdr); 433 434 ip_hdr = (struct ipv4_hdr *)(rte_pktmbuf_mtod(m, char *) + 435 ipdata_offset); 436 437 ipdata_offset += (ip_hdr->version_ihl & IPV4_HDR_IHL_MASK) 438 * IPV4_IHL_MULTIPLIER; 439 440 441 /* Zero pad data to be crypto'd so it is block aligned */ 442 data_len = rte_pktmbuf_data_len(m) - ipdata_offset; 443 pad_len = data_len % cparams->block_size ? cparams->block_size - 444 (data_len % cparams->block_size) : 0; 445 446 if (pad_len) { 447 padding = rte_pktmbuf_append(m, pad_len); 448 if (unlikely(!padding)) 449 return -1; 450 451 data_len += pad_len; 452 memset(padding, 0, pad_len); 453 } 454 455 /* Set crypto operation data parameters */ 456 rte_crypto_op_attach_sym_session(op, cparams->session); 457 458 if (cparams->do_hash) { 459 if (!cparams->hash_verify) { 460 /* Append space for digest to end of packet */ 461 op->sym->auth.digest.data = (uint8_t *)rte_pktmbuf_append(m, 462 cparams->digest_length); 463 } else { 464 op->sym->auth.digest.data = (uint8_t *)rte_pktmbuf_append(m, 465 cparams->digest_length); 466 } 467 468 op->sym->auth.digest.phys_addr = rte_pktmbuf_mtophys_offset(m, 469 rte_pktmbuf_pkt_len(m) - cparams->digest_length); 470 op->sym->auth.digest.length = cparams->digest_length; 471 472 /* For SNOW3G/KASUMI algorithms, offset/length must be in bits */ 473 if (cparams->auth_algo == RTE_CRYPTO_AUTH_SNOW3G_UIA2 || 474 cparams->auth_algo == RTE_CRYPTO_AUTH_KASUMI_F9) { 475 op->sym->auth.data.offset = ipdata_offset << 3; 476 op->sym->auth.data.length = data_len << 3; 477 } else { 478 op->sym->auth.data.offset = ipdata_offset; 479 op->sym->auth.data.length = data_len; 480 } 481 482 if (cparams->aad.length) { 483 op->sym->auth.aad.data = cparams->aad.data; 484 op->sym->auth.aad.phys_addr = cparams->aad.phys_addr; 485 op->sym->auth.aad.length = cparams->aad.length; 486 } 487 } 488 489 if (cparams->do_cipher) { 490 op->sym->cipher.iv.data = cparams->iv.data; 491 op->sym->cipher.iv.phys_addr = cparams->iv.phys_addr; 492 op->sym->cipher.iv.length = cparams->iv.length; 493 494 /* For SNOW3G algorithms, offset/length must be in bits */ 495 if (cparams->cipher_algo == RTE_CRYPTO_CIPHER_SNOW3G_UEA2 || 496 cparams->cipher_algo == RTE_CRYPTO_CIPHER_KASUMI_F8) { 497 op->sym->cipher.data.offset = ipdata_offset << 3; 498 if (cparams->do_hash && cparams->hash_verify) 499 /* Do not cipher the hash tag */ 500 op->sym->cipher.data.length = (data_len - 501 cparams->digest_length) << 3; 502 else 503 op->sym->cipher.data.length = data_len << 3; 504 505 } else { 506 op->sym->cipher.data.offset = ipdata_offset; 507 if (cparams->do_hash && cparams->hash_verify) 508 /* Do not cipher the hash tag */ 509 op->sym->cipher.data.length = data_len - 510 cparams->digest_length; 511 else 512 op->sym->cipher.data.length = data_len; 513 } 514 } 515 516 op->sym->m_src = m; 517 518 return l2fwd_crypto_enqueue(op, cparams); 519 } 520 521 522 /* Send the burst of packets on an output interface */ 523 static int 524 l2fwd_send_burst(struct lcore_queue_conf *qconf, unsigned n, 525 uint8_t port) 526 { 527 struct rte_mbuf **pkt_buffer; 528 unsigned ret; 529 530 pkt_buffer = (struct rte_mbuf **)qconf->pkt_buf[port].buffer; 531 532 ret = rte_eth_tx_burst(port, 0, pkt_buffer, (uint16_t)n); 533 port_statistics[port].tx += ret; 534 if (unlikely(ret < n)) { 535 port_statistics[port].dropped += (n - ret); 536 do { 537 rte_pktmbuf_free(pkt_buffer[ret]); 538 } while (++ret < n); 539 } 540 541 return 0; 542 } 543 544 /* Enqueue packets for TX and prepare them to be sent */ 545 static int 546 l2fwd_send_packet(struct rte_mbuf *m, uint8_t port) 547 { 548 unsigned lcore_id, len; 549 struct lcore_queue_conf *qconf; 550 551 lcore_id = rte_lcore_id(); 552 553 qconf = &lcore_queue_conf[lcore_id]; 554 len = qconf->pkt_buf[port].len; 555 qconf->pkt_buf[port].buffer[len] = m; 556 len++; 557 558 /* enough pkts to be sent */ 559 if (unlikely(len == MAX_PKT_BURST)) { 560 l2fwd_send_burst(qconf, MAX_PKT_BURST, port); 561 len = 0; 562 } 563 564 qconf->pkt_buf[port].len = len; 565 return 0; 566 } 567 568 static void 569 l2fwd_simple_forward(struct rte_mbuf *m, unsigned portid) 570 { 571 struct ether_hdr *eth; 572 void *tmp; 573 unsigned dst_port; 574 575 dst_port = l2fwd_dst_ports[portid]; 576 eth = rte_pktmbuf_mtod(m, struct ether_hdr *); 577 578 /* 02:00:00:00:00:xx */ 579 tmp = ð->d_addr.addr_bytes[0]; 580 *((uint64_t *)tmp) = 0x000000000002 + ((uint64_t)dst_port << 40); 581 582 /* src addr */ 583 ether_addr_copy(&l2fwd_ports_eth_addr[dst_port], ð->s_addr); 584 585 l2fwd_send_packet(m, (uint8_t) dst_port); 586 } 587 588 /** Generate random key */ 589 static void 590 generate_random_key(uint8_t *key, unsigned length) 591 { 592 int fd; 593 int ret; 594 595 fd = open("/dev/urandom", O_RDONLY); 596 if (fd < 0) 597 rte_exit(EXIT_FAILURE, "Failed to generate random key\n"); 598 599 ret = read(fd, key, length); 600 close(fd); 601 602 if (ret != (signed)length) 603 rte_exit(EXIT_FAILURE, "Failed to generate random key\n"); 604 } 605 606 static struct rte_cryptodev_sym_session * 607 initialize_crypto_session(struct l2fwd_crypto_options *options, 608 uint8_t cdev_id) 609 { 610 struct rte_crypto_sym_xform *first_xform; 611 612 if (options->xform_chain == L2FWD_CRYPTO_CIPHER_HASH) { 613 first_xform = &options->cipher_xform; 614 first_xform->next = &options->auth_xform; 615 } else if (options->xform_chain == L2FWD_CRYPTO_HASH_CIPHER) { 616 first_xform = &options->auth_xform; 617 first_xform->next = &options->cipher_xform; 618 } else if (options->xform_chain == L2FWD_CRYPTO_CIPHER_ONLY) { 619 first_xform = &options->cipher_xform; 620 } else { 621 first_xform = &options->auth_xform; 622 } 623 624 /* Setup Cipher Parameters */ 625 return rte_cryptodev_sym_session_create(cdev_id, first_xform); 626 } 627 628 static void 629 l2fwd_crypto_options_print(struct l2fwd_crypto_options *options); 630 631 /* main processing loop */ 632 static void 633 l2fwd_main_loop(struct l2fwd_crypto_options *options) 634 { 635 struct rte_mbuf *m, *pkts_burst[MAX_PKT_BURST]; 636 struct rte_crypto_op *ops_burst[MAX_PKT_BURST]; 637 638 unsigned lcore_id = rte_lcore_id(); 639 uint64_t prev_tsc = 0, diff_tsc, cur_tsc, timer_tsc = 0; 640 unsigned i, j, portid, nb_rx, len; 641 struct lcore_queue_conf *qconf = &lcore_queue_conf[lcore_id]; 642 const uint64_t drain_tsc = (rte_get_tsc_hz() + US_PER_S - 1) / 643 US_PER_S * BURST_TX_DRAIN_US; 644 struct l2fwd_crypto_params *cparams; 645 struct l2fwd_crypto_params port_cparams[qconf->nb_crypto_devs]; 646 647 if (qconf->nb_rx_ports == 0) { 648 RTE_LOG(INFO, L2FWD, "lcore %u has nothing to do\n", lcore_id); 649 return; 650 } 651 652 RTE_LOG(INFO, L2FWD, "entering main loop on lcore %u\n", lcore_id); 653 654 for (i = 0; i < qconf->nb_rx_ports; i++) { 655 656 portid = qconf->rx_port_list[i]; 657 RTE_LOG(INFO, L2FWD, " -- lcoreid=%u portid=%u\n", lcore_id, 658 portid); 659 } 660 661 for (i = 0; i < qconf->nb_crypto_devs; i++) { 662 port_cparams[i].do_cipher = 0; 663 port_cparams[i].do_hash = 0; 664 665 switch (options->xform_chain) { 666 case L2FWD_CRYPTO_CIPHER_HASH: 667 case L2FWD_CRYPTO_HASH_CIPHER: 668 port_cparams[i].do_cipher = 1; 669 port_cparams[i].do_hash = 1; 670 break; 671 case L2FWD_CRYPTO_HASH_ONLY: 672 port_cparams[i].do_hash = 1; 673 break; 674 case L2FWD_CRYPTO_CIPHER_ONLY: 675 port_cparams[i].do_cipher = 1; 676 break; 677 } 678 679 port_cparams[i].dev_id = qconf->cryptodev_list[i]; 680 port_cparams[i].qp_id = 0; 681 682 port_cparams[i].block_size = options->block_size; 683 684 if (port_cparams[i].do_hash) { 685 port_cparams[i].digest_length = 686 options->auth_xform.auth.digest_length; 687 if (options->auth_xform.auth.add_auth_data_length) { 688 port_cparams[i].aad.data = options->aad.data; 689 port_cparams[i].aad.length = 690 options->auth_xform.auth.add_auth_data_length; 691 port_cparams[i].aad.phys_addr = options->aad.phys_addr; 692 if (!options->aad_param) 693 generate_random_key(port_cparams[i].aad.data, 694 port_cparams[i].aad.length); 695 696 } 697 698 if (options->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_VERIFY) 699 port_cparams[i].hash_verify = 1; 700 else 701 port_cparams[i].hash_verify = 0; 702 703 port_cparams[i].auth_algo = options->auth_xform.auth.algo; 704 } 705 706 if (port_cparams[i].do_cipher) { 707 port_cparams[i].iv.data = options->iv.data; 708 port_cparams[i].iv.length = options->iv.length; 709 port_cparams[i].iv.phys_addr = options->iv.phys_addr; 710 if (!options->iv_param) 711 generate_random_key(port_cparams[i].iv.data, 712 port_cparams[i].iv.length); 713 714 port_cparams[i].cipher_algo = options->cipher_xform.cipher.algo; 715 } 716 717 port_cparams[i].session = initialize_crypto_session(options, 718 port_cparams[i].dev_id); 719 720 if (port_cparams[i].session == NULL) 721 return; 722 RTE_LOG(INFO, L2FWD, " -- lcoreid=%u cryptoid=%u\n", lcore_id, 723 port_cparams[i].dev_id); 724 } 725 726 l2fwd_crypto_options_print(options); 727 728 /* 729 * Initialize previous tsc timestamp before the loop, 730 * to avoid showing the port statistics immediately, 731 * so user can see the crypto information. 732 */ 733 prev_tsc = rte_rdtsc(); 734 while (1) { 735 736 cur_tsc = rte_rdtsc(); 737 738 /* 739 * Crypto device/TX burst queue drain 740 */ 741 diff_tsc = cur_tsc - prev_tsc; 742 if (unlikely(diff_tsc > drain_tsc)) { 743 /* Enqueue all crypto ops remaining in buffers */ 744 for (i = 0; i < qconf->nb_crypto_devs; i++) { 745 cparams = &port_cparams[i]; 746 len = qconf->op_buf[cparams->dev_id].len; 747 l2fwd_crypto_send_burst(qconf, len, cparams); 748 qconf->op_buf[cparams->dev_id].len = 0; 749 } 750 /* Transmit all packets remaining in buffers */ 751 for (portid = 0; portid < RTE_MAX_ETHPORTS; portid++) { 752 if (qconf->pkt_buf[portid].len == 0) 753 continue; 754 l2fwd_send_burst(&lcore_queue_conf[lcore_id], 755 qconf->pkt_buf[portid].len, 756 (uint8_t) portid); 757 qconf->pkt_buf[portid].len = 0; 758 } 759 760 /* if timer is enabled */ 761 if (timer_period > 0) { 762 763 /* advance the timer */ 764 timer_tsc += diff_tsc; 765 766 /* if timer has reached its timeout */ 767 if (unlikely(timer_tsc >= 768 (uint64_t)timer_period)) { 769 770 /* do this only on master core */ 771 if (lcore_id == rte_get_master_lcore() 772 && options->refresh_period) { 773 print_stats(); 774 timer_tsc = 0; 775 } 776 } 777 } 778 779 prev_tsc = cur_tsc; 780 } 781 782 /* 783 * Read packet from RX queues 784 */ 785 for (i = 0; i < qconf->nb_rx_ports; i++) { 786 portid = qconf->rx_port_list[i]; 787 788 cparams = &port_cparams[i]; 789 790 nb_rx = rte_eth_rx_burst((uint8_t) portid, 0, 791 pkts_burst, MAX_PKT_BURST); 792 793 port_statistics[portid].rx += nb_rx; 794 795 if (nb_rx) { 796 /* 797 * If we can't allocate a crypto_ops, then drop 798 * the rest of the burst and dequeue and 799 * process the packets to free offload structs 800 */ 801 if (rte_crypto_op_bulk_alloc( 802 l2fwd_crypto_op_pool, 803 RTE_CRYPTO_OP_TYPE_SYMMETRIC, 804 ops_burst, nb_rx) != 805 nb_rx) { 806 for (j = 0; j < nb_rx; j++) 807 rte_pktmbuf_free(pkts_burst[i]); 808 809 nb_rx = 0; 810 } 811 812 /* Enqueue packets from Crypto device*/ 813 for (j = 0; j < nb_rx; j++) { 814 m = pkts_burst[j]; 815 816 l2fwd_simple_crypto_enqueue(m, 817 ops_burst[j], cparams); 818 } 819 } 820 821 /* Dequeue packets from Crypto device */ 822 do { 823 nb_rx = rte_cryptodev_dequeue_burst( 824 cparams->dev_id, cparams->qp_id, 825 ops_burst, MAX_PKT_BURST); 826 827 crypto_statistics[cparams->dev_id].dequeued += 828 nb_rx; 829 830 /* Forward crypto'd packets */ 831 for (j = 0; j < nb_rx; j++) { 832 m = ops_burst[j]->sym->m_src; 833 834 rte_crypto_op_free(ops_burst[j]); 835 l2fwd_simple_forward(m, portid); 836 } 837 } while (nb_rx == MAX_PKT_BURST); 838 } 839 } 840 } 841 842 static int 843 l2fwd_launch_one_lcore(void *arg) 844 { 845 l2fwd_main_loop((struct l2fwd_crypto_options *)arg); 846 return 0; 847 } 848 849 /* Display command line arguments usage */ 850 static void 851 l2fwd_crypto_usage(const char *prgname) 852 { 853 printf("%s [EAL options] --\n" 854 " -p PORTMASK: hexadecimal bitmask of ports to configure\n" 855 " -q NQ: number of queue (=ports) per lcore (default is 1)\n" 856 " -s manage all ports from single lcore\n" 857 " -T PERIOD: statistics will be refreshed each PERIOD seconds" 858 " (0 to disable, 10 default, 86400 maximum)\n" 859 860 " --cdev_type HW / SW / ANY\n" 861 " --chain HASH_CIPHER / CIPHER_HASH\n" 862 863 " --cipher_algo ALGO\n" 864 " --cipher_op ENCRYPT / DECRYPT\n" 865 " --cipher_key KEY (bytes separated with \":\")\n" 866 " --cipher_key_random_size SIZE: size of cipher key when generated randomly\n" 867 " --iv IV (bytes separated with \":\")\n" 868 " --iv_random_size SIZE: size of IV when generated randomly\n" 869 870 " --auth_algo ALGO\n" 871 " --auth_op GENERATE / VERIFY\n" 872 " --auth_key KEY (bytes separated with \":\")\n" 873 " --auth_key_random_size SIZE: size of auth key when generated randomly\n" 874 " --aad AAD (bytes separated with \":\")\n" 875 " --aad_random_size SIZE: size of AAD when generated randomly\n" 876 " --digest_size SIZE: size of digest to be generated/verified\n" 877 878 " --sessionless\n", 879 prgname); 880 } 881 882 /** Parse crypto device type command line argument */ 883 static int 884 parse_cryptodev_type(enum cdev_type *type, char *optarg) 885 { 886 if (strcmp("HW", optarg) == 0) { 887 *type = CDEV_TYPE_HW; 888 return 0; 889 } else if (strcmp("SW", optarg) == 0) { 890 *type = CDEV_TYPE_SW; 891 return 0; 892 } else if (strcmp("ANY", optarg) == 0) { 893 *type = CDEV_TYPE_ANY; 894 return 0; 895 } 896 897 return -1; 898 } 899 900 /** Parse crypto chain xform command line argument */ 901 static int 902 parse_crypto_opt_chain(struct l2fwd_crypto_options *options, char *optarg) 903 { 904 if (strcmp("CIPHER_HASH", optarg) == 0) { 905 options->xform_chain = L2FWD_CRYPTO_CIPHER_HASH; 906 return 0; 907 } else if (strcmp("HASH_CIPHER", optarg) == 0) { 908 options->xform_chain = L2FWD_CRYPTO_HASH_CIPHER; 909 return 0; 910 } else if (strcmp("CIPHER_ONLY", optarg) == 0) { 911 options->xform_chain = L2FWD_CRYPTO_CIPHER_ONLY; 912 return 0; 913 } else if (strcmp("HASH_ONLY", optarg) == 0) { 914 options->xform_chain = L2FWD_CRYPTO_HASH_ONLY; 915 return 0; 916 } 917 918 return -1; 919 } 920 921 /** Parse crypto cipher algo option command line argument */ 922 static int 923 parse_cipher_algo(enum rte_crypto_cipher_algorithm *algo, char *optarg) 924 { 925 unsigned i; 926 927 for (i = 0; i < RTE_CRYPTO_CIPHER_LIST_END; i++) { 928 if (!strcmp(supported_cipher_algo[i], optarg)) { 929 *algo = (enum rte_crypto_cipher_algorithm)i; 930 return 0; 931 } 932 } 933 934 printf("Cipher algorithm not supported!\n"); 935 return -1; 936 } 937 938 /** Parse crypto cipher operation command line argument */ 939 static int 940 parse_cipher_op(enum rte_crypto_cipher_operation *op, char *optarg) 941 { 942 if (strcmp("ENCRYPT", optarg) == 0) { 943 *op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 944 return 0; 945 } else if (strcmp("DECRYPT", optarg) == 0) { 946 *op = RTE_CRYPTO_CIPHER_OP_DECRYPT; 947 return 0; 948 } 949 950 printf("Cipher operation not supported!\n"); 951 return -1; 952 } 953 954 /** Parse crypto key command line argument */ 955 static int 956 parse_key(uint8_t *data, char *input_arg) 957 { 958 unsigned byte_count; 959 char *token; 960 961 for (byte_count = 0, token = strtok(input_arg, ":"); 962 (byte_count < MAX_KEY_SIZE) && (token != NULL); 963 token = strtok(NULL, ":")) { 964 965 int number = (int)strtol(token, NULL, 16); 966 967 if (errno == EINVAL || errno == ERANGE || number > 0xFF) 968 return -1; 969 970 data[byte_count++] = (uint8_t)number; 971 } 972 973 return byte_count; 974 } 975 976 /** Parse size param*/ 977 static int 978 parse_size(int *size, const char *q_arg) 979 { 980 char *end = NULL; 981 unsigned long n; 982 983 /* parse hexadecimal string */ 984 n = strtoul(q_arg, &end, 10); 985 if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0')) 986 n = 0; 987 988 if (n == 0) { 989 printf("invalid size\n"); 990 return -1; 991 } 992 993 *size = n; 994 return 0; 995 } 996 997 /** Parse crypto cipher operation command line argument */ 998 static int 999 parse_auth_algo(enum rte_crypto_auth_algorithm *algo, char *optarg) 1000 { 1001 unsigned i; 1002 1003 for (i = 0; i < RTE_CRYPTO_AUTH_LIST_END; i++) { 1004 if (!strcmp(supported_auth_algo[i], optarg)) { 1005 *algo = (enum rte_crypto_auth_algorithm)i; 1006 return 0; 1007 } 1008 } 1009 1010 printf("Authentication algorithm specified not supported!\n"); 1011 return -1; 1012 } 1013 1014 static int 1015 parse_auth_op(enum rte_crypto_auth_operation *op, char *optarg) 1016 { 1017 if (strcmp("VERIFY", optarg) == 0) { 1018 *op = RTE_CRYPTO_AUTH_OP_VERIFY; 1019 return 0; 1020 } else if (strcmp("GENERATE", optarg) == 0) { 1021 *op = RTE_CRYPTO_AUTH_OP_GENERATE; 1022 return 0; 1023 } 1024 1025 printf("Authentication operation specified not supported!\n"); 1026 return -1; 1027 } 1028 1029 /** Parse long options */ 1030 static int 1031 l2fwd_crypto_parse_args_long_options(struct l2fwd_crypto_options *options, 1032 struct option *lgopts, int option_index) 1033 { 1034 int retval; 1035 1036 if (strcmp(lgopts[option_index].name, "cdev_type") == 0) { 1037 retval = parse_cryptodev_type(&options->type, optarg); 1038 if (retval == 0) 1039 snprintf(options->string_type, MAX_STR_LEN, 1040 "%s", optarg); 1041 return retval; 1042 } 1043 1044 else if (strcmp(lgopts[option_index].name, "chain") == 0) 1045 return parse_crypto_opt_chain(options, optarg); 1046 1047 /* Cipher options */ 1048 else if (strcmp(lgopts[option_index].name, "cipher_algo") == 0) 1049 return parse_cipher_algo(&options->cipher_xform.cipher.algo, 1050 optarg); 1051 1052 else if (strcmp(lgopts[option_index].name, "cipher_op") == 0) 1053 return parse_cipher_op(&options->cipher_xform.cipher.op, 1054 optarg); 1055 1056 else if (strcmp(lgopts[option_index].name, "cipher_key") == 0) { 1057 options->ckey_param = 1; 1058 options->cipher_xform.cipher.key.length = 1059 parse_key(options->cipher_xform.cipher.key.data, optarg); 1060 if (options->cipher_xform.cipher.key.length > 0) 1061 return 0; 1062 else 1063 return -1; 1064 } 1065 1066 else if (strcmp(lgopts[option_index].name, "cipher_key_random_size") == 0) 1067 return parse_size(&options->ckey_random_size, optarg); 1068 1069 else if (strcmp(lgopts[option_index].name, "iv") == 0) { 1070 options->iv_param = 1; 1071 options->iv.length = 1072 parse_key(options->iv.data, optarg); 1073 if (options->iv.length > 0) 1074 return 0; 1075 else 1076 return -1; 1077 } 1078 1079 else if (strcmp(lgopts[option_index].name, "iv_random_size") == 0) 1080 return parse_size(&options->iv_random_size, optarg); 1081 1082 /* Authentication options */ 1083 else if (strcmp(lgopts[option_index].name, "auth_algo") == 0) { 1084 return parse_auth_algo(&options->auth_xform.auth.algo, 1085 optarg); 1086 } 1087 1088 else if (strcmp(lgopts[option_index].name, "auth_op") == 0) 1089 return parse_auth_op(&options->auth_xform.auth.op, 1090 optarg); 1091 1092 else if (strcmp(lgopts[option_index].name, "auth_key") == 0) { 1093 options->akey_param = 1; 1094 options->auth_xform.auth.key.length = 1095 parse_key(options->auth_xform.auth.key.data, optarg); 1096 if (options->auth_xform.auth.key.length > 0) 1097 return 0; 1098 else 1099 return -1; 1100 } 1101 1102 else if (strcmp(lgopts[option_index].name, "auth_key_random_size") == 0) { 1103 return parse_size(&options->akey_random_size, optarg); 1104 } 1105 1106 else if (strcmp(lgopts[option_index].name, "aad") == 0) { 1107 options->aad_param = 1; 1108 options->aad.length = 1109 parse_key(options->aad.data, optarg); 1110 if (options->aad.length > 0) 1111 return 0; 1112 else 1113 return -1; 1114 } 1115 1116 else if (strcmp(lgopts[option_index].name, "aad_random_size") == 0) { 1117 return parse_size(&options->aad_random_size, optarg); 1118 } 1119 1120 else if (strcmp(lgopts[option_index].name, "digest_size") == 0) { 1121 return parse_size(&options->digest_size, optarg); 1122 } 1123 1124 else if (strcmp(lgopts[option_index].name, "sessionless") == 0) { 1125 options->sessionless = 1; 1126 return 0; 1127 } 1128 1129 return -1; 1130 } 1131 1132 /** Parse port mask */ 1133 static int 1134 l2fwd_crypto_parse_portmask(struct l2fwd_crypto_options *options, 1135 const char *q_arg) 1136 { 1137 char *end = NULL; 1138 unsigned long pm; 1139 1140 /* parse hexadecimal string */ 1141 pm = strtoul(q_arg, &end, 16); 1142 if ((pm == '\0') || (end == NULL) || (*end != '\0')) 1143 pm = 0; 1144 1145 options->portmask = pm; 1146 if (options->portmask == 0) { 1147 printf("invalid portmask specified\n"); 1148 return -1; 1149 } 1150 1151 return pm; 1152 } 1153 1154 /** Parse number of queues */ 1155 static int 1156 l2fwd_crypto_parse_nqueue(struct l2fwd_crypto_options *options, 1157 const char *q_arg) 1158 { 1159 char *end = NULL; 1160 unsigned long n; 1161 1162 /* parse hexadecimal string */ 1163 n = strtoul(q_arg, &end, 10); 1164 if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0')) 1165 n = 0; 1166 else if (n >= MAX_RX_QUEUE_PER_LCORE) 1167 n = 0; 1168 1169 options->nb_ports_per_lcore = n; 1170 if (options->nb_ports_per_lcore == 0) { 1171 printf("invalid number of ports selected\n"); 1172 return -1; 1173 } 1174 1175 return 0; 1176 } 1177 1178 /** Parse timer period */ 1179 static int 1180 l2fwd_crypto_parse_timer_period(struct l2fwd_crypto_options *options, 1181 const char *q_arg) 1182 { 1183 char *end = NULL; 1184 unsigned long n; 1185 1186 /* parse number string */ 1187 n = (unsigned)strtol(q_arg, &end, 10); 1188 if ((q_arg[0] == '\0') || (end == NULL) || (*end != '\0')) 1189 n = 0; 1190 1191 if (n >= MAX_TIMER_PERIOD) { 1192 printf("Warning refresh period specified %lu is greater than " 1193 "max value %lu! using max value", 1194 n, MAX_TIMER_PERIOD); 1195 n = MAX_TIMER_PERIOD; 1196 } 1197 1198 options->refresh_period = n * 1000 * TIMER_MILLISECOND; 1199 1200 return 0; 1201 } 1202 1203 /** Generate default options for application */ 1204 static void 1205 l2fwd_crypto_default_options(struct l2fwd_crypto_options *options) 1206 { 1207 options->portmask = 0xffffffff; 1208 options->nb_ports_per_lcore = 1; 1209 options->refresh_period = 10000; 1210 options->single_lcore = 0; 1211 options->sessionless = 0; 1212 1213 options->xform_chain = L2FWD_CRYPTO_CIPHER_HASH; 1214 1215 /* Cipher Data */ 1216 options->cipher_xform.type = RTE_CRYPTO_SYM_XFORM_CIPHER; 1217 options->cipher_xform.next = NULL; 1218 options->ckey_param = 0; 1219 options->ckey_random_size = -1; 1220 options->cipher_xform.cipher.key.length = 0; 1221 options->iv_param = 0; 1222 options->iv_random_size = -1; 1223 options->iv.length = 0; 1224 1225 options->cipher_xform.cipher.algo = RTE_CRYPTO_CIPHER_AES_CBC; 1226 options->cipher_xform.cipher.op = RTE_CRYPTO_CIPHER_OP_ENCRYPT; 1227 1228 /* Authentication Data */ 1229 options->auth_xform.type = RTE_CRYPTO_SYM_XFORM_AUTH; 1230 options->auth_xform.next = NULL; 1231 options->akey_param = 0; 1232 options->akey_random_size = -1; 1233 options->auth_xform.auth.key.length = 0; 1234 options->aad_param = 0; 1235 options->aad_random_size = -1; 1236 options->aad.length = 0; 1237 options->digest_size = -1; 1238 1239 options->auth_xform.auth.algo = RTE_CRYPTO_AUTH_SHA1_HMAC; 1240 options->auth_xform.auth.op = RTE_CRYPTO_AUTH_OP_GENERATE; 1241 1242 options->type = CDEV_TYPE_ANY; 1243 } 1244 1245 static void 1246 display_cipher_info(struct l2fwd_crypto_options *options) 1247 { 1248 printf("\n---- Cipher information ---\n"); 1249 printf("Algorithm: %s\n", 1250 supported_cipher_algo[options->cipher_xform.cipher.algo]); 1251 rte_hexdump(stdout, "Cipher key:", 1252 options->cipher_xform.cipher.key.data, 1253 options->cipher_xform.cipher.key.length); 1254 rte_hexdump(stdout, "IV:", options->iv.data, options->iv.length); 1255 } 1256 1257 static void 1258 display_auth_info(struct l2fwd_crypto_options *options) 1259 { 1260 printf("\n---- Authentication information ---\n"); 1261 printf("Algorithm: %s\n", 1262 supported_auth_algo[options->auth_xform.auth.algo]); 1263 rte_hexdump(stdout, "Auth key:", 1264 options->auth_xform.auth.key.data, 1265 options->auth_xform.auth.key.length); 1266 rte_hexdump(stdout, "AAD:", options->aad.data, options->aad.length); 1267 } 1268 1269 static void 1270 l2fwd_crypto_options_print(struct l2fwd_crypto_options *options) 1271 { 1272 char string_cipher_op[MAX_STR_LEN]; 1273 char string_auth_op[MAX_STR_LEN]; 1274 1275 if (options->cipher_xform.cipher.op == RTE_CRYPTO_CIPHER_OP_ENCRYPT) 1276 strcpy(string_cipher_op, "Encrypt"); 1277 else 1278 strcpy(string_cipher_op, "Decrypt"); 1279 1280 if (options->auth_xform.auth.op == RTE_CRYPTO_AUTH_OP_GENERATE) 1281 strcpy(string_auth_op, "Auth generate"); 1282 else 1283 strcpy(string_auth_op, "Auth verify"); 1284 1285 printf("Options:-\nn"); 1286 printf("portmask: %x\n", options->portmask); 1287 printf("ports per lcore: %u\n", options->nb_ports_per_lcore); 1288 printf("refresh period : %u\n", options->refresh_period); 1289 printf("single lcore mode: %s\n", 1290 options->single_lcore ? "enabled" : "disabled"); 1291 printf("stats_printing: %s\n", 1292 options->refresh_period == 0 ? "disabled" : "enabled"); 1293 1294 printf("sessionless crypto: %s\n", 1295 options->sessionless ? "enabled" : "disabled"); 1296 1297 if (options->ckey_param && (options->ckey_random_size != -1)) 1298 printf("Cipher key already parsed, ignoring size of random key\n"); 1299 1300 if (options->akey_param && (options->akey_random_size != -1)) 1301 printf("Auth key already parsed, ignoring size of random key\n"); 1302 1303 if (options->iv_param && (options->iv_random_size != -1)) 1304 printf("IV already parsed, ignoring size of random IV\n"); 1305 1306 if (options->aad_param && (options->aad_random_size != -1)) 1307 printf("AAD already parsed, ignoring size of random AAD\n"); 1308 1309 printf("\nCrypto chain: "); 1310 switch (options->xform_chain) { 1311 case L2FWD_CRYPTO_CIPHER_HASH: 1312 printf("Input --> %s --> %s --> Output\n", 1313 string_cipher_op, string_auth_op); 1314 display_cipher_info(options); 1315 display_auth_info(options); 1316 break; 1317 case L2FWD_CRYPTO_HASH_CIPHER: 1318 printf("Input --> %s --> %s --> Output\n", 1319 string_auth_op, string_cipher_op); 1320 display_cipher_info(options); 1321 display_auth_info(options); 1322 break; 1323 case L2FWD_CRYPTO_HASH_ONLY: 1324 printf("Input --> %s --> Output\n", string_auth_op); 1325 display_auth_info(options); 1326 break; 1327 case L2FWD_CRYPTO_CIPHER_ONLY: 1328 printf("Input --> %s --> Output\n", string_cipher_op); 1329 display_cipher_info(options); 1330 break; 1331 } 1332 } 1333 1334 /* Parse the argument given in the command line of the application */ 1335 static int 1336 l2fwd_crypto_parse_args(struct l2fwd_crypto_options *options, 1337 int argc, char **argv) 1338 { 1339 int opt, retval, option_index; 1340 char **argvopt = argv, *prgname = argv[0]; 1341 1342 static struct option lgopts[] = { 1343 { "sessionless", no_argument, 0, 0 }, 1344 1345 { "cdev_type", required_argument, 0, 0 }, 1346 { "chain", required_argument, 0, 0 }, 1347 1348 { "cipher_algo", required_argument, 0, 0 }, 1349 { "cipher_op", required_argument, 0, 0 }, 1350 { "cipher_key", required_argument, 0, 0 }, 1351 { "cipher_key_random_size", required_argument, 0, 0 }, 1352 1353 { "auth_algo", required_argument, 0, 0 }, 1354 { "auth_op", required_argument, 0, 0 }, 1355 { "auth_key", required_argument, 0, 0 }, 1356 { "auth_key_random_size", required_argument, 0, 0 }, 1357 1358 { "iv", required_argument, 0, 0 }, 1359 { "iv_random_size", required_argument, 0, 0 }, 1360 { "aad", required_argument, 0, 0 }, 1361 { "aad_random_size", required_argument, 0, 0 }, 1362 { "digest_size", required_argument, 0, 0 }, 1363 1364 { "sessionless", no_argument, 0, 0 }, 1365 1366 { NULL, 0, 0, 0 } 1367 }; 1368 1369 l2fwd_crypto_default_options(options); 1370 1371 while ((opt = getopt_long(argc, argvopt, "p:q:st:", lgopts, 1372 &option_index)) != EOF) { 1373 switch (opt) { 1374 /* long options */ 1375 case 0: 1376 retval = l2fwd_crypto_parse_args_long_options(options, 1377 lgopts, option_index); 1378 if (retval < 0) { 1379 l2fwd_crypto_usage(prgname); 1380 return -1; 1381 } 1382 break; 1383 1384 /* portmask */ 1385 case 'p': 1386 retval = l2fwd_crypto_parse_portmask(options, optarg); 1387 if (retval < 0) { 1388 l2fwd_crypto_usage(prgname); 1389 return -1; 1390 } 1391 break; 1392 1393 /* nqueue */ 1394 case 'q': 1395 retval = l2fwd_crypto_parse_nqueue(options, optarg); 1396 if (retval < 0) { 1397 l2fwd_crypto_usage(prgname); 1398 return -1; 1399 } 1400 break; 1401 1402 /* single */ 1403 case 's': 1404 options->single_lcore = 1; 1405 1406 break; 1407 1408 /* timer period */ 1409 case 'T': 1410 retval = l2fwd_crypto_parse_timer_period(options, 1411 optarg); 1412 if (retval < 0) { 1413 l2fwd_crypto_usage(prgname); 1414 return -1; 1415 } 1416 break; 1417 1418 default: 1419 l2fwd_crypto_usage(prgname); 1420 return -1; 1421 } 1422 } 1423 1424 1425 if (optind >= 0) 1426 argv[optind-1] = prgname; 1427 1428 retval = optind-1; 1429 optind = 0; /* reset getopt lib */ 1430 1431 return retval; 1432 } 1433 1434 /* Check the link status of all ports in up to 9s, and print them finally */ 1435 static void 1436 check_all_ports_link_status(uint8_t port_num, uint32_t port_mask) 1437 { 1438 #define CHECK_INTERVAL 100 /* 100ms */ 1439 #define MAX_CHECK_TIME 90 /* 9s (90 * 100ms) in total */ 1440 uint8_t portid, count, all_ports_up, print_flag = 0; 1441 struct rte_eth_link link; 1442 1443 printf("\nChecking link status"); 1444 fflush(stdout); 1445 for (count = 0; count <= MAX_CHECK_TIME; count++) { 1446 all_ports_up = 1; 1447 for (portid = 0; portid < port_num; portid++) { 1448 if ((port_mask & (1 << portid)) == 0) 1449 continue; 1450 memset(&link, 0, sizeof(link)); 1451 rte_eth_link_get_nowait(portid, &link); 1452 /* print link status if flag set */ 1453 if (print_flag == 1) { 1454 if (link.link_status) 1455 printf("Port %d Link Up - speed %u " 1456 "Mbps - %s\n", (uint8_t)portid, 1457 (unsigned)link.link_speed, 1458 (link.link_duplex == ETH_LINK_FULL_DUPLEX) ? 1459 ("full-duplex") : ("half-duplex\n")); 1460 else 1461 printf("Port %d Link Down\n", 1462 (uint8_t)portid); 1463 continue; 1464 } 1465 /* clear all_ports_up flag if any link down */ 1466 if (link.link_status == ETH_LINK_DOWN) { 1467 all_ports_up = 0; 1468 break; 1469 } 1470 } 1471 /* after finally printing all link status, get out */ 1472 if (print_flag == 1) 1473 break; 1474 1475 if (all_ports_up == 0) { 1476 printf("."); 1477 fflush(stdout); 1478 rte_delay_ms(CHECK_INTERVAL); 1479 } 1480 1481 /* set the print_flag if all ports up or timeout */ 1482 if (all_ports_up == 1 || count == (MAX_CHECK_TIME - 1)) { 1483 print_flag = 1; 1484 printf("done\n"); 1485 } 1486 } 1487 } 1488 1489 /* Check if device has to be HW/SW or any */ 1490 static int 1491 check_type(struct l2fwd_crypto_options *options, struct rte_cryptodev_info *dev_info) 1492 { 1493 if (options->type == CDEV_TYPE_HW && 1494 (dev_info->feature_flags & RTE_CRYPTODEV_FF_HW_ACCELERATED)) 1495 return 0; 1496 if (options->type == CDEV_TYPE_SW && 1497 !(dev_info->feature_flags & RTE_CRYPTODEV_FF_HW_ACCELERATED)) 1498 return 0; 1499 if (options->type == CDEV_TYPE_ANY) 1500 return 0; 1501 1502 return -1; 1503 } 1504 1505 static inline int 1506 check_supported_size(uint16_t length, uint16_t min, uint16_t max, 1507 uint16_t increment) 1508 { 1509 uint16_t supp_size; 1510 1511 /* Single value */ 1512 if (increment == 0) { 1513 if (length == min) 1514 return 0; 1515 else 1516 return -1; 1517 } 1518 1519 /* Range of values */ 1520 for (supp_size = min; supp_size <= max; supp_size += increment) { 1521 if (length == supp_size) 1522 return 0; 1523 } 1524 1525 return -1; 1526 } 1527 static int 1528 initialize_cryptodevs(struct l2fwd_crypto_options *options, unsigned nb_ports, 1529 uint8_t *enabled_cdevs) 1530 { 1531 unsigned i, cdev_id, cdev_count, enabled_cdev_count = 0; 1532 const struct rte_cryptodev_capabilities *cap; 1533 enum rte_crypto_auth_algorithm cap_auth_algo; 1534 enum rte_crypto_auth_algorithm opt_auth_algo; 1535 enum rte_crypto_cipher_algorithm cap_cipher_algo; 1536 enum rte_crypto_cipher_algorithm opt_cipher_algo; 1537 int retval; 1538 1539 cdev_count = rte_cryptodev_count(); 1540 if (cdev_count == 0) { 1541 printf("No crypto devices available\n"); 1542 return -1; 1543 } 1544 1545 for (cdev_id = 0; cdev_id < cdev_count && enabled_cdev_count < nb_ports; 1546 cdev_id++) { 1547 struct rte_cryptodev_qp_conf qp_conf; 1548 struct rte_cryptodev_info dev_info; 1549 1550 struct rte_cryptodev_config conf = { 1551 .nb_queue_pairs = 1, 1552 .socket_id = SOCKET_ID_ANY, 1553 .session_mp = { 1554 .nb_objs = 2048, 1555 .cache_size = 64 1556 } 1557 }; 1558 1559 rte_cryptodev_info_get(cdev_id, &dev_info); 1560 1561 /* Set cipher parameters */ 1562 if (options->xform_chain == L2FWD_CRYPTO_CIPHER_HASH || 1563 options->xform_chain == L2FWD_CRYPTO_HASH_CIPHER || 1564 options->xform_chain == L2FWD_CRYPTO_CIPHER_ONLY) { 1565 /* Check if device supports cipher algo */ 1566 i = 0; 1567 opt_cipher_algo = options->cipher_xform.cipher.algo; 1568 cap = &dev_info.capabilities[i]; 1569 while (cap->op != RTE_CRYPTO_OP_TYPE_UNDEFINED) { 1570 cap_cipher_algo = cap->sym.cipher.algo; 1571 if (cap->sym.xform_type == 1572 RTE_CRYPTO_SYM_XFORM_CIPHER) { 1573 if (cap_cipher_algo == opt_cipher_algo) { 1574 if (check_type(options, &dev_info) == 0) 1575 break; 1576 } 1577 } 1578 cap = &dev_info.capabilities[++i]; 1579 } 1580 1581 if (cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED) { 1582 printf("Algorithm %s not supported by cryptodev %u" 1583 " or device not of preferred type (%s)\n", 1584 supported_cipher_algo[opt_cipher_algo], 1585 cdev_id, 1586 options->string_type); 1587 continue; 1588 } 1589 1590 options->block_size = cap->sym.cipher.block_size; 1591 /* 1592 * Check if length of provided IV is supported 1593 * by the algorithm chosen. 1594 */ 1595 if (options->iv_param) { 1596 if (check_supported_size(options->iv.length, 1597 cap->sym.cipher.iv_size.min, 1598 cap->sym.cipher.iv_size.max, 1599 cap->sym.cipher.iv_size.increment) 1600 != 0) { 1601 printf("Unsupported IV length\n"); 1602 return -1; 1603 } 1604 /* 1605 * Check if length of IV to be randomly generated 1606 * is supported by the algorithm chosen. 1607 */ 1608 } else if (options->iv_random_size != -1) { 1609 if (check_supported_size(options->iv_random_size, 1610 cap->sym.cipher.iv_size.min, 1611 cap->sym.cipher.iv_size.max, 1612 cap->sym.cipher.iv_size.increment) 1613 != 0) { 1614 printf("Unsupported IV length\n"); 1615 return -1; 1616 } 1617 options->iv.length = options->iv_random_size; 1618 /* No size provided, use minimum size. */ 1619 } else 1620 options->iv.length = cap->sym.cipher.iv_size.min; 1621 1622 /* 1623 * Check if length of provided cipher key is supported 1624 * by the algorithm chosen. 1625 */ 1626 if (options->ckey_param) { 1627 if (check_supported_size( 1628 options->cipher_xform.cipher.key.length, 1629 cap->sym.cipher.key_size.min, 1630 cap->sym.cipher.key_size.max, 1631 cap->sym.cipher.key_size.increment) 1632 != 0) { 1633 printf("Unsupported cipher key length\n"); 1634 return -1; 1635 } 1636 /* 1637 * Check if length of the cipher key to be randomly generated 1638 * is supported by the algorithm chosen. 1639 */ 1640 } else if (options->ckey_random_size != -1) { 1641 if (check_supported_size(options->ckey_random_size, 1642 cap->sym.cipher.key_size.min, 1643 cap->sym.cipher.key_size.max, 1644 cap->sym.cipher.key_size.increment) 1645 != 0) { 1646 printf("Unsupported cipher key length\n"); 1647 return -1; 1648 } 1649 options->cipher_xform.cipher.key.length = 1650 options->ckey_random_size; 1651 /* No size provided, use minimum size. */ 1652 } else 1653 options->cipher_xform.cipher.key.length = 1654 cap->sym.cipher.key_size.min; 1655 1656 if (!options->ckey_param) 1657 generate_random_key( 1658 options->cipher_xform.cipher.key.data, 1659 options->cipher_xform.cipher.key.length); 1660 1661 } 1662 1663 /* Set auth parameters */ 1664 if (options->xform_chain == L2FWD_CRYPTO_CIPHER_HASH || 1665 options->xform_chain == L2FWD_CRYPTO_HASH_CIPHER || 1666 options->xform_chain == L2FWD_CRYPTO_HASH_ONLY) { 1667 /* Check if device supports auth algo */ 1668 i = 0; 1669 opt_auth_algo = options->auth_xform.auth.algo; 1670 cap = &dev_info.capabilities[i]; 1671 while (cap->op != RTE_CRYPTO_OP_TYPE_UNDEFINED) { 1672 cap_auth_algo = cap->sym.auth.algo; 1673 if ((cap->sym.xform_type == RTE_CRYPTO_SYM_XFORM_AUTH) && 1674 (cap_auth_algo == opt_auth_algo) && 1675 (check_type(options, &dev_info) == 0)) { 1676 break; 1677 } 1678 cap = &dev_info.capabilities[++i]; 1679 } 1680 1681 if (cap->op == RTE_CRYPTO_OP_TYPE_UNDEFINED) { 1682 printf("Algorithm %s not supported by cryptodev %u" 1683 " or device not of preferred type (%s)\n", 1684 supported_auth_algo[opt_auth_algo], 1685 cdev_id, 1686 options->string_type); 1687 continue; 1688 } 1689 1690 options->block_size = cap->sym.auth.block_size; 1691 /* 1692 * Check if length of provided AAD is supported 1693 * by the algorithm chosen. 1694 */ 1695 if (options->aad_param) { 1696 if (check_supported_size(options->aad.length, 1697 cap->sym.auth.aad_size.min, 1698 cap->sym.auth.aad_size.max, 1699 cap->sym.auth.aad_size.increment) 1700 != 0) { 1701 printf("Unsupported AAD length\n"); 1702 return -1; 1703 } 1704 /* 1705 * Check if length of AAD to be randomly generated 1706 * is supported by the algorithm chosen. 1707 */ 1708 } else if (options->aad_random_size != -1) { 1709 if (check_supported_size(options->aad_random_size, 1710 cap->sym.auth.aad_size.min, 1711 cap->sym.auth.aad_size.max, 1712 cap->sym.auth.aad_size.increment) 1713 != 0) { 1714 printf("Unsupported AAD length\n"); 1715 return -1; 1716 } 1717 options->aad.length = options->aad_random_size; 1718 /* No size provided, use minimum size. */ 1719 } else 1720 options->aad.length = cap->sym.auth.aad_size.min; 1721 1722 options->auth_xform.auth.add_auth_data_length = 1723 options->aad.length; 1724 1725 /* 1726 * Check if length of provided auth key is supported 1727 * by the algorithm chosen. 1728 */ 1729 if (options->akey_param) { 1730 if (check_supported_size( 1731 options->auth_xform.auth.key.length, 1732 cap->sym.auth.key_size.min, 1733 cap->sym.auth.key_size.max, 1734 cap->sym.auth.key_size.increment) 1735 != 0) { 1736 printf("Unsupported auth key length\n"); 1737 return -1; 1738 } 1739 /* 1740 * Check if length of the auth key to be randomly generated 1741 * is supported by the algorithm chosen. 1742 */ 1743 } else if (options->akey_random_size != -1) { 1744 if (check_supported_size(options->akey_random_size, 1745 cap->sym.auth.key_size.min, 1746 cap->sym.auth.key_size.max, 1747 cap->sym.auth.key_size.increment) 1748 != 0) { 1749 printf("Unsupported auth key length\n"); 1750 return -1; 1751 } 1752 options->auth_xform.auth.key.length = 1753 options->akey_random_size; 1754 /* No size provided, use minimum size. */ 1755 } else 1756 options->auth_xform.auth.key.length = 1757 cap->sym.auth.key_size.min; 1758 1759 if (!options->akey_param) 1760 generate_random_key( 1761 options->auth_xform.auth.key.data, 1762 options->auth_xform.auth.key.length); 1763 1764 /* Check if digest size is supported by the algorithm. */ 1765 if (options->digest_size != -1) { 1766 if (check_supported_size(options->digest_size, 1767 cap->sym.auth.digest_size.min, 1768 cap->sym.auth.digest_size.max, 1769 cap->sym.auth.digest_size.increment) 1770 != 0) { 1771 printf("Unsupported digest length\n"); 1772 return -1; 1773 } 1774 options->auth_xform.auth.digest_length = 1775 options->digest_size; 1776 /* No size provided, use minimum size. */ 1777 } else 1778 options->auth_xform.auth.digest_length = 1779 cap->sym.auth.digest_size.min; 1780 } 1781 1782 retval = rte_cryptodev_configure(cdev_id, &conf); 1783 if (retval < 0) { 1784 printf("Failed to configure cryptodev %u", cdev_id); 1785 return -1; 1786 } 1787 1788 qp_conf.nb_descriptors = 2048; 1789 1790 retval = rte_cryptodev_queue_pair_setup(cdev_id, 0, &qp_conf, 1791 SOCKET_ID_ANY); 1792 if (retval < 0) { 1793 printf("Failed to setup queue pair %u on cryptodev %u", 1794 0, cdev_id); 1795 return -1; 1796 } 1797 1798 retval = rte_cryptodev_start(cdev_id); 1799 if (retval < 0) { 1800 printf("Failed to start device %u: error %d\n", 1801 cdev_id, retval); 1802 return -1; 1803 } 1804 1805 l2fwd_enabled_crypto_mask |= (1 << cdev_id); 1806 1807 enabled_cdevs[cdev_id] = 1; 1808 enabled_cdev_count++; 1809 } 1810 1811 return enabled_cdev_count; 1812 } 1813 1814 static int 1815 initialize_ports(struct l2fwd_crypto_options *options) 1816 { 1817 uint8_t last_portid, portid; 1818 unsigned enabled_portcount = 0; 1819 unsigned nb_ports = rte_eth_dev_count(); 1820 1821 if (nb_ports == 0) { 1822 printf("No Ethernet ports - bye\n"); 1823 return -1; 1824 } 1825 1826 /* Reset l2fwd_dst_ports */ 1827 for (portid = 0; portid < RTE_MAX_ETHPORTS; portid++) 1828 l2fwd_dst_ports[portid] = 0; 1829 1830 for (last_portid = 0, portid = 0; portid < nb_ports; portid++) { 1831 int retval; 1832 1833 /* Skip ports that are not enabled */ 1834 if ((options->portmask & (1 << portid)) == 0) 1835 continue; 1836 1837 /* init port */ 1838 printf("Initializing port %u... ", (unsigned) portid); 1839 fflush(stdout); 1840 retval = rte_eth_dev_configure(portid, 1, 1, &port_conf); 1841 if (retval < 0) { 1842 printf("Cannot configure device: err=%d, port=%u\n", 1843 retval, (unsigned) portid); 1844 return -1; 1845 } 1846 1847 /* init one RX queue */ 1848 fflush(stdout); 1849 retval = rte_eth_rx_queue_setup(portid, 0, nb_rxd, 1850 rte_eth_dev_socket_id(portid), 1851 NULL, l2fwd_pktmbuf_pool); 1852 if (retval < 0) { 1853 printf("rte_eth_rx_queue_setup:err=%d, port=%u\n", 1854 retval, (unsigned) portid); 1855 return -1; 1856 } 1857 1858 /* init one TX queue on each port */ 1859 fflush(stdout); 1860 retval = rte_eth_tx_queue_setup(portid, 0, nb_txd, 1861 rte_eth_dev_socket_id(portid), 1862 NULL); 1863 if (retval < 0) { 1864 printf("rte_eth_tx_queue_setup:err=%d, port=%u\n", 1865 retval, (unsigned) portid); 1866 1867 return -1; 1868 } 1869 1870 /* Start device */ 1871 retval = rte_eth_dev_start(portid); 1872 if (retval < 0) { 1873 printf("rte_eth_dev_start:err=%d, port=%u\n", 1874 retval, (unsigned) portid); 1875 return -1; 1876 } 1877 1878 rte_eth_promiscuous_enable(portid); 1879 1880 rte_eth_macaddr_get(portid, &l2fwd_ports_eth_addr[portid]); 1881 1882 printf("Port %u, MAC address: %02X:%02X:%02X:%02X:%02X:%02X\n\n", 1883 (unsigned) portid, 1884 l2fwd_ports_eth_addr[portid].addr_bytes[0], 1885 l2fwd_ports_eth_addr[portid].addr_bytes[1], 1886 l2fwd_ports_eth_addr[portid].addr_bytes[2], 1887 l2fwd_ports_eth_addr[portid].addr_bytes[3], 1888 l2fwd_ports_eth_addr[portid].addr_bytes[4], 1889 l2fwd_ports_eth_addr[portid].addr_bytes[5]); 1890 1891 /* initialize port stats */ 1892 memset(&port_statistics, 0, sizeof(port_statistics)); 1893 1894 /* Setup port forwarding table */ 1895 if (enabled_portcount % 2) { 1896 l2fwd_dst_ports[portid] = last_portid; 1897 l2fwd_dst_ports[last_portid] = portid; 1898 } else { 1899 last_portid = portid; 1900 } 1901 1902 l2fwd_enabled_port_mask |= (1 << portid); 1903 enabled_portcount++; 1904 } 1905 1906 if (enabled_portcount == 1) { 1907 l2fwd_dst_ports[last_portid] = last_portid; 1908 } else if (enabled_portcount % 2) { 1909 printf("odd number of ports in portmask- bye\n"); 1910 return -1; 1911 } 1912 1913 check_all_ports_link_status(nb_ports, l2fwd_enabled_port_mask); 1914 1915 return enabled_portcount; 1916 } 1917 1918 static void 1919 reserve_key_memory(struct l2fwd_crypto_options *options) 1920 { 1921 options->cipher_xform.cipher.key.data = rte_malloc("crypto key", 1922 MAX_KEY_SIZE, 0); 1923 if (options->cipher_xform.cipher.key.data == NULL) 1924 rte_exit(EXIT_FAILURE, "Failed to allocate memory for cipher key"); 1925 1926 1927 options->auth_xform.auth.key.data = rte_malloc("auth key", 1928 MAX_KEY_SIZE, 0); 1929 if (options->auth_xform.auth.key.data == NULL) 1930 rte_exit(EXIT_FAILURE, "Failed to allocate memory for auth key"); 1931 1932 options->iv.data = rte_malloc("iv", MAX_KEY_SIZE, 0); 1933 if (options->iv.data == NULL) 1934 rte_exit(EXIT_FAILURE, "Failed to allocate memory for IV"); 1935 options->iv.phys_addr = rte_malloc_virt2phy(options->iv.data); 1936 1937 options->aad.data = rte_malloc("aad", MAX_KEY_SIZE, 0); 1938 if (options->aad.data == NULL) 1939 rte_exit(EXIT_FAILURE, "Failed to allocate memory for AAD"); 1940 options->aad.phys_addr = rte_malloc_virt2phy(options->aad.data); 1941 } 1942 1943 int 1944 main(int argc, char **argv) 1945 { 1946 struct lcore_queue_conf *qconf; 1947 struct l2fwd_crypto_options options; 1948 1949 uint8_t nb_ports, nb_cryptodevs, portid, cdev_id; 1950 unsigned lcore_id, rx_lcore_id; 1951 int ret, enabled_cdevcount, enabled_portcount; 1952 uint8_t enabled_cdevs[RTE_CRYPTO_MAX_DEVS] = {0}; 1953 1954 /* init EAL */ 1955 ret = rte_eal_init(argc, argv); 1956 if (ret < 0) 1957 rte_exit(EXIT_FAILURE, "Invalid EAL arguments\n"); 1958 argc -= ret; 1959 argv += ret; 1960 1961 /* reserve memory for Cipher/Auth key and IV */ 1962 reserve_key_memory(&options); 1963 1964 /* fill out the supported algorithm tables */ 1965 fill_supported_algorithm_tables(); 1966 1967 /* parse application arguments (after the EAL ones) */ 1968 ret = l2fwd_crypto_parse_args(&options, argc, argv); 1969 if (ret < 0) 1970 rte_exit(EXIT_FAILURE, "Invalid L2FWD-CRYPTO arguments\n"); 1971 1972 /* create the mbuf pool */ 1973 l2fwd_pktmbuf_pool = rte_pktmbuf_pool_create("mbuf_pool", NB_MBUF, 512, 1974 sizeof(struct rte_crypto_op), 1975 RTE_MBUF_DEFAULT_BUF_SIZE, rte_socket_id()); 1976 if (l2fwd_pktmbuf_pool == NULL) 1977 rte_exit(EXIT_FAILURE, "Cannot create mbuf pool\n"); 1978 1979 /* create crypto op pool */ 1980 l2fwd_crypto_op_pool = rte_crypto_op_pool_create("crypto_op_pool", 1981 RTE_CRYPTO_OP_TYPE_SYMMETRIC, NB_MBUF, 128, 0, 1982 rte_socket_id()); 1983 if (l2fwd_crypto_op_pool == NULL) 1984 rte_exit(EXIT_FAILURE, "Cannot create crypto op pool\n"); 1985 1986 /* Enable Ethernet ports */ 1987 enabled_portcount = initialize_ports(&options); 1988 if (enabled_portcount < 1) 1989 rte_exit(EXIT_FAILURE, "Failed to initial Ethernet ports\n"); 1990 1991 nb_ports = rte_eth_dev_count(); 1992 /* Initialize the port/queue configuration of each logical core */ 1993 for (rx_lcore_id = 0, qconf = NULL, portid = 0; 1994 portid < nb_ports; portid++) { 1995 1996 /* skip ports that are not enabled */ 1997 if ((options.portmask & (1 << portid)) == 0) 1998 continue; 1999 2000 if (options.single_lcore && qconf == NULL) { 2001 while (rte_lcore_is_enabled(rx_lcore_id) == 0) { 2002 rx_lcore_id++; 2003 if (rx_lcore_id >= RTE_MAX_LCORE) 2004 rte_exit(EXIT_FAILURE, 2005 "Not enough cores\n"); 2006 } 2007 } else if (!options.single_lcore) { 2008 /* get the lcore_id for this port */ 2009 while (rte_lcore_is_enabled(rx_lcore_id) == 0 || 2010 lcore_queue_conf[rx_lcore_id].nb_rx_ports == 2011 options.nb_ports_per_lcore) { 2012 rx_lcore_id++; 2013 if (rx_lcore_id >= RTE_MAX_LCORE) 2014 rte_exit(EXIT_FAILURE, 2015 "Not enough cores\n"); 2016 } 2017 } 2018 2019 /* Assigned a new logical core in the loop above. */ 2020 if (qconf != &lcore_queue_conf[rx_lcore_id]) 2021 qconf = &lcore_queue_conf[rx_lcore_id]; 2022 2023 qconf->rx_port_list[qconf->nb_rx_ports] = portid; 2024 qconf->nb_rx_ports++; 2025 2026 printf("Lcore %u: RX port %u\n", rx_lcore_id, (unsigned)portid); 2027 } 2028 2029 /* Enable Crypto devices */ 2030 enabled_cdevcount = initialize_cryptodevs(&options, enabled_portcount, 2031 enabled_cdevs); 2032 if (enabled_cdevcount < 0) 2033 rte_exit(EXIT_FAILURE, "Failed to initialize crypto devices\n"); 2034 2035 if (enabled_cdevcount < enabled_portcount) 2036 rte_exit(EXIT_FAILURE, "Number of capable crypto devices (%d) " 2037 "has to be more or equal to number of ports (%d)\n", 2038 enabled_cdevcount, enabled_portcount); 2039 2040 nb_cryptodevs = rte_cryptodev_count(); 2041 2042 /* Initialize the port/cryptodev configuration of each logical core */ 2043 for (rx_lcore_id = 0, qconf = NULL, cdev_id = 0; 2044 cdev_id < nb_cryptodevs && enabled_cdevcount; 2045 cdev_id++) { 2046 /* Crypto op not supported by crypto device */ 2047 if (!enabled_cdevs[cdev_id]) 2048 continue; 2049 2050 if (options.single_lcore && qconf == NULL) { 2051 while (rte_lcore_is_enabled(rx_lcore_id) == 0) { 2052 rx_lcore_id++; 2053 if (rx_lcore_id >= RTE_MAX_LCORE) 2054 rte_exit(EXIT_FAILURE, 2055 "Not enough cores\n"); 2056 } 2057 } else if (!options.single_lcore) { 2058 /* get the lcore_id for this port */ 2059 while (rte_lcore_is_enabled(rx_lcore_id) == 0 || 2060 lcore_queue_conf[rx_lcore_id].nb_crypto_devs == 2061 options.nb_ports_per_lcore) { 2062 rx_lcore_id++; 2063 if (rx_lcore_id >= RTE_MAX_LCORE) 2064 rte_exit(EXIT_FAILURE, 2065 "Not enough cores\n"); 2066 } 2067 } 2068 2069 /* Assigned a new logical core in the loop above. */ 2070 if (qconf != &lcore_queue_conf[rx_lcore_id]) 2071 qconf = &lcore_queue_conf[rx_lcore_id]; 2072 2073 qconf->cryptodev_list[qconf->nb_crypto_devs] = cdev_id; 2074 qconf->nb_crypto_devs++; 2075 2076 enabled_cdevcount--; 2077 2078 printf("Lcore %u: cryptodev %u\n", rx_lcore_id, 2079 (unsigned)cdev_id); 2080 } 2081 2082 /* launch per-lcore init on every lcore */ 2083 rte_eal_mp_remote_launch(l2fwd_launch_one_lcore, (void *)&options, 2084 CALL_MASTER); 2085 RTE_LCORE_FOREACH_SLAVE(lcore_id) { 2086 if (rte_eal_wait_lcore(lcore_id) < 0) 2087 return -1; 2088 } 2089 2090 return 0; 2091 } 2092