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