1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (C) IGEL Co.,Ltd. 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 IGEL Co.,Ltd. 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 <rte_mbuf.h> 35 #include <rte_ethdev_driver.h> 36 #include <rte_ethdev_vdev.h> 37 #include <rte_malloc.h> 38 #include <rte_memcpy.h> 39 #include <rte_bus_vdev.h> 40 #include <rte_kvargs.h> 41 #include <rte_spinlock.h> 42 43 #define ETH_NULL_PACKET_SIZE_ARG "size" 44 #define ETH_NULL_PACKET_COPY_ARG "copy" 45 46 static unsigned default_packet_size = 64; 47 static unsigned default_packet_copy; 48 49 static const char *valid_arguments[] = { 50 ETH_NULL_PACKET_SIZE_ARG, 51 ETH_NULL_PACKET_COPY_ARG, 52 NULL 53 }; 54 55 struct pmd_internals; 56 57 struct null_queue { 58 struct pmd_internals *internals; 59 60 struct rte_mempool *mb_pool; 61 struct rte_mbuf *dummy_packet; 62 63 rte_atomic64_t rx_pkts; 64 rte_atomic64_t tx_pkts; 65 rte_atomic64_t err_pkts; 66 }; 67 68 struct pmd_internals { 69 unsigned packet_size; 70 unsigned packet_copy; 71 uint16_t port_id; 72 73 struct null_queue rx_null_queues[RTE_MAX_QUEUES_PER_PORT]; 74 struct null_queue tx_null_queues[RTE_MAX_QUEUES_PER_PORT]; 75 76 struct ether_addr eth_addr; 77 /** Bit mask of RSS offloads, the bit offset also means flow type */ 78 uint64_t flow_type_rss_offloads; 79 80 rte_spinlock_t rss_lock; 81 82 uint16_t reta_size; 83 struct rte_eth_rss_reta_entry64 reta_conf[ETH_RSS_RETA_SIZE_128 / 84 RTE_RETA_GROUP_SIZE]; 85 86 uint8_t rss_key[40]; /**< 40-byte hash key. */ 87 }; 88 static struct rte_eth_link pmd_link = { 89 .link_speed = ETH_SPEED_NUM_10G, 90 .link_duplex = ETH_LINK_FULL_DUPLEX, 91 .link_status = ETH_LINK_DOWN, 92 .link_autoneg = ETH_LINK_AUTONEG, 93 }; 94 95 static uint16_t 96 eth_null_rx(void *q, struct rte_mbuf **bufs, uint16_t nb_bufs) 97 { 98 int i; 99 struct null_queue *h = q; 100 unsigned packet_size; 101 102 if ((q == NULL) || (bufs == NULL)) 103 return 0; 104 105 packet_size = h->internals->packet_size; 106 if (rte_pktmbuf_alloc_bulk(h->mb_pool, bufs, nb_bufs) != 0) 107 return 0; 108 109 for (i = 0; i < nb_bufs; i++) { 110 bufs[i]->data_len = (uint16_t)packet_size; 111 bufs[i]->pkt_len = packet_size; 112 bufs[i]->port = h->internals->port_id; 113 } 114 115 rte_atomic64_add(&(h->rx_pkts), i); 116 117 return i; 118 } 119 120 static uint16_t 121 eth_null_copy_rx(void *q, struct rte_mbuf **bufs, uint16_t nb_bufs) 122 { 123 int i; 124 struct null_queue *h = q; 125 unsigned packet_size; 126 127 if ((q == NULL) || (bufs == NULL)) 128 return 0; 129 130 packet_size = h->internals->packet_size; 131 if (rte_pktmbuf_alloc_bulk(h->mb_pool, bufs, nb_bufs) != 0) 132 return 0; 133 134 for (i = 0; i < nb_bufs; i++) { 135 rte_memcpy(rte_pktmbuf_mtod(bufs[i], void *), h->dummy_packet, 136 packet_size); 137 bufs[i]->data_len = (uint16_t)packet_size; 138 bufs[i]->pkt_len = packet_size; 139 bufs[i]->port = h->internals->port_id; 140 } 141 142 rte_atomic64_add(&(h->rx_pkts), i); 143 144 return i; 145 } 146 147 static uint16_t 148 eth_null_tx(void *q, struct rte_mbuf **bufs, uint16_t nb_bufs) 149 { 150 int i; 151 struct null_queue *h = q; 152 153 if ((q == NULL) || (bufs == NULL)) 154 return 0; 155 156 for (i = 0; i < nb_bufs; i++) 157 rte_pktmbuf_free(bufs[i]); 158 159 rte_atomic64_add(&(h->tx_pkts), i); 160 161 return i; 162 } 163 164 static uint16_t 165 eth_null_copy_tx(void *q, struct rte_mbuf **bufs, uint16_t nb_bufs) 166 { 167 int i; 168 struct null_queue *h = q; 169 unsigned packet_size; 170 171 if ((q == NULL) || (bufs == NULL)) 172 return 0; 173 174 packet_size = h->internals->packet_size; 175 for (i = 0; i < nb_bufs; i++) { 176 rte_memcpy(h->dummy_packet, rte_pktmbuf_mtod(bufs[i], void *), 177 packet_size); 178 rte_pktmbuf_free(bufs[i]); 179 } 180 181 rte_atomic64_add(&(h->tx_pkts), i); 182 183 return i; 184 } 185 186 static int 187 eth_dev_configure(struct rte_eth_dev *dev __rte_unused) 188 { 189 return 0; 190 } 191 192 static int 193 eth_dev_start(struct rte_eth_dev *dev) 194 { 195 if (dev == NULL) 196 return -EINVAL; 197 198 dev->data->dev_link.link_status = ETH_LINK_UP; 199 return 0; 200 } 201 202 static void 203 eth_dev_stop(struct rte_eth_dev *dev) 204 { 205 if (dev == NULL) 206 return; 207 208 dev->data->dev_link.link_status = ETH_LINK_DOWN; 209 } 210 211 static int 212 eth_rx_queue_setup(struct rte_eth_dev *dev, uint16_t rx_queue_id, 213 uint16_t nb_rx_desc __rte_unused, 214 unsigned int socket_id __rte_unused, 215 const struct rte_eth_rxconf *rx_conf __rte_unused, 216 struct rte_mempool *mb_pool) 217 { 218 struct rte_mbuf *dummy_packet; 219 struct pmd_internals *internals; 220 unsigned packet_size; 221 222 if ((dev == NULL) || (mb_pool == NULL)) 223 return -EINVAL; 224 225 internals = dev->data->dev_private; 226 227 if (rx_queue_id >= dev->data->nb_rx_queues) 228 return -ENODEV; 229 230 packet_size = internals->packet_size; 231 232 internals->rx_null_queues[rx_queue_id].mb_pool = mb_pool; 233 dev->data->rx_queues[rx_queue_id] = 234 &internals->rx_null_queues[rx_queue_id]; 235 dummy_packet = rte_zmalloc_socket(NULL, 236 packet_size, 0, dev->data->numa_node); 237 if (dummy_packet == NULL) 238 return -ENOMEM; 239 240 internals->rx_null_queues[rx_queue_id].internals = internals; 241 internals->rx_null_queues[rx_queue_id].dummy_packet = dummy_packet; 242 243 return 0; 244 } 245 246 static int 247 eth_tx_queue_setup(struct rte_eth_dev *dev, uint16_t tx_queue_id, 248 uint16_t nb_tx_desc __rte_unused, 249 unsigned int socket_id __rte_unused, 250 const struct rte_eth_txconf *tx_conf __rte_unused) 251 { 252 struct rte_mbuf *dummy_packet; 253 struct pmd_internals *internals; 254 unsigned packet_size; 255 256 if (dev == NULL) 257 return -EINVAL; 258 259 internals = dev->data->dev_private; 260 261 if (tx_queue_id >= dev->data->nb_tx_queues) 262 return -ENODEV; 263 264 packet_size = internals->packet_size; 265 266 dev->data->tx_queues[tx_queue_id] = 267 &internals->tx_null_queues[tx_queue_id]; 268 dummy_packet = rte_zmalloc_socket(NULL, 269 packet_size, 0, dev->data->numa_node); 270 if (dummy_packet == NULL) 271 return -ENOMEM; 272 273 internals->tx_null_queues[tx_queue_id].internals = internals; 274 internals->tx_null_queues[tx_queue_id].dummy_packet = dummy_packet; 275 276 return 0; 277 } 278 279 static int 280 eth_mtu_set(struct rte_eth_dev *dev __rte_unused, uint16_t mtu __rte_unused) 281 { 282 return 0; 283 } 284 285 static void 286 eth_dev_info(struct rte_eth_dev *dev, 287 struct rte_eth_dev_info *dev_info) 288 { 289 struct pmd_internals *internals; 290 291 if ((dev == NULL) || (dev_info == NULL)) 292 return; 293 294 internals = dev->data->dev_private; 295 dev_info->max_mac_addrs = 1; 296 dev_info->max_rx_pktlen = (uint32_t)-1; 297 dev_info->max_rx_queues = RTE_DIM(internals->rx_null_queues); 298 dev_info->max_tx_queues = RTE_DIM(internals->tx_null_queues); 299 dev_info->min_rx_bufsize = 0; 300 dev_info->reta_size = internals->reta_size; 301 dev_info->flow_type_rss_offloads = internals->flow_type_rss_offloads; 302 } 303 304 static int 305 eth_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *igb_stats) 306 { 307 unsigned i, num_stats; 308 unsigned long rx_total = 0, tx_total = 0, tx_err_total = 0; 309 const struct pmd_internals *internal; 310 311 if ((dev == NULL) || (igb_stats == NULL)) 312 return -EINVAL; 313 314 internal = dev->data->dev_private; 315 num_stats = RTE_MIN((unsigned)RTE_ETHDEV_QUEUE_STAT_CNTRS, 316 RTE_MIN(dev->data->nb_rx_queues, 317 RTE_DIM(internal->rx_null_queues))); 318 for (i = 0; i < num_stats; i++) { 319 igb_stats->q_ipackets[i] = 320 internal->rx_null_queues[i].rx_pkts.cnt; 321 rx_total += igb_stats->q_ipackets[i]; 322 } 323 324 num_stats = RTE_MIN((unsigned)RTE_ETHDEV_QUEUE_STAT_CNTRS, 325 RTE_MIN(dev->data->nb_tx_queues, 326 RTE_DIM(internal->tx_null_queues))); 327 for (i = 0; i < num_stats; i++) { 328 igb_stats->q_opackets[i] = 329 internal->tx_null_queues[i].tx_pkts.cnt; 330 igb_stats->q_errors[i] = 331 internal->tx_null_queues[i].err_pkts.cnt; 332 tx_total += igb_stats->q_opackets[i]; 333 tx_err_total += igb_stats->q_errors[i]; 334 } 335 336 igb_stats->ipackets = rx_total; 337 igb_stats->opackets = tx_total; 338 igb_stats->oerrors = tx_err_total; 339 340 return 0; 341 } 342 343 static void 344 eth_stats_reset(struct rte_eth_dev *dev) 345 { 346 unsigned i; 347 struct pmd_internals *internal; 348 349 if (dev == NULL) 350 return; 351 352 internal = dev->data->dev_private; 353 for (i = 0; i < RTE_DIM(internal->rx_null_queues); i++) 354 internal->rx_null_queues[i].rx_pkts.cnt = 0; 355 for (i = 0; i < RTE_DIM(internal->tx_null_queues); i++) { 356 internal->tx_null_queues[i].tx_pkts.cnt = 0; 357 internal->tx_null_queues[i].err_pkts.cnt = 0; 358 } 359 } 360 361 static void 362 eth_queue_release(void *q) 363 { 364 struct null_queue *nq; 365 366 if (q == NULL) 367 return; 368 369 nq = q; 370 rte_free(nq->dummy_packet); 371 } 372 373 static int 374 eth_link_update(struct rte_eth_dev *dev __rte_unused, 375 int wait_to_complete __rte_unused) { return 0; } 376 377 static int 378 eth_rss_reta_update(struct rte_eth_dev *dev, 379 struct rte_eth_rss_reta_entry64 *reta_conf, uint16_t reta_size) 380 { 381 int i, j; 382 struct pmd_internals *internal = dev->data->dev_private; 383 384 if (reta_size != internal->reta_size) 385 return -EINVAL; 386 387 rte_spinlock_lock(&internal->rss_lock); 388 389 /* Copy RETA table */ 390 for (i = 0; i < (internal->reta_size / RTE_RETA_GROUP_SIZE); i++) { 391 internal->reta_conf[i].mask = reta_conf[i].mask; 392 for (j = 0; j < RTE_RETA_GROUP_SIZE; j++) 393 if ((reta_conf[i].mask >> j) & 0x01) 394 internal->reta_conf[i].reta[j] = reta_conf[i].reta[j]; 395 } 396 397 rte_spinlock_unlock(&internal->rss_lock); 398 399 return 0; 400 } 401 402 static int 403 eth_rss_reta_query(struct rte_eth_dev *dev, 404 struct rte_eth_rss_reta_entry64 *reta_conf, uint16_t reta_size) 405 { 406 int i, j; 407 struct pmd_internals *internal = dev->data->dev_private; 408 409 if (reta_size != internal->reta_size) 410 return -EINVAL; 411 412 rte_spinlock_lock(&internal->rss_lock); 413 414 /* Copy RETA table */ 415 for (i = 0; i < (internal->reta_size / RTE_RETA_GROUP_SIZE); i++) { 416 for (j = 0; j < RTE_RETA_GROUP_SIZE; j++) 417 if ((reta_conf[i].mask >> j) & 0x01) 418 reta_conf[i].reta[j] = internal->reta_conf[i].reta[j]; 419 } 420 421 rte_spinlock_unlock(&internal->rss_lock); 422 423 return 0; 424 } 425 426 static int 427 eth_rss_hash_update(struct rte_eth_dev *dev, struct rte_eth_rss_conf *rss_conf) 428 { 429 struct pmd_internals *internal = dev->data->dev_private; 430 431 rte_spinlock_lock(&internal->rss_lock); 432 433 if ((rss_conf->rss_hf & internal->flow_type_rss_offloads) != 0) 434 dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf = 435 rss_conf->rss_hf & internal->flow_type_rss_offloads; 436 437 if (rss_conf->rss_key) 438 rte_memcpy(internal->rss_key, rss_conf->rss_key, 40); 439 440 rte_spinlock_unlock(&internal->rss_lock); 441 442 return 0; 443 } 444 445 static int 446 eth_rss_hash_conf_get(struct rte_eth_dev *dev, 447 struct rte_eth_rss_conf *rss_conf) 448 { 449 struct pmd_internals *internal = dev->data->dev_private; 450 451 rte_spinlock_lock(&internal->rss_lock); 452 453 rss_conf->rss_hf = dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf; 454 if (rss_conf->rss_key) 455 rte_memcpy(rss_conf->rss_key, internal->rss_key, 40); 456 457 rte_spinlock_unlock(&internal->rss_lock); 458 459 return 0; 460 } 461 462 static int 463 eth_mac_address_set(__rte_unused struct rte_eth_dev *dev, 464 __rte_unused struct ether_addr *addr) 465 { 466 return 0; 467 } 468 469 static const struct eth_dev_ops ops = { 470 .dev_start = eth_dev_start, 471 .dev_stop = eth_dev_stop, 472 .dev_configure = eth_dev_configure, 473 .dev_infos_get = eth_dev_info, 474 .rx_queue_setup = eth_rx_queue_setup, 475 .tx_queue_setup = eth_tx_queue_setup, 476 .rx_queue_release = eth_queue_release, 477 .tx_queue_release = eth_queue_release, 478 .mtu_set = eth_mtu_set, 479 .link_update = eth_link_update, 480 .mac_addr_set = eth_mac_address_set, 481 .stats_get = eth_stats_get, 482 .stats_reset = eth_stats_reset, 483 .reta_update = eth_rss_reta_update, 484 .reta_query = eth_rss_reta_query, 485 .rss_hash_update = eth_rss_hash_update, 486 .rss_hash_conf_get = eth_rss_hash_conf_get 487 }; 488 489 static struct rte_vdev_driver pmd_null_drv; 490 491 static int 492 eth_dev_null_create(struct rte_vdev_device *dev, 493 unsigned packet_size, 494 unsigned packet_copy) 495 { 496 const unsigned nb_rx_queues = 1; 497 const unsigned nb_tx_queues = 1; 498 struct rte_eth_dev_data *data = NULL; 499 struct pmd_internals *internals = NULL; 500 struct rte_eth_dev *eth_dev = NULL; 501 502 static const uint8_t default_rss_key[40] = { 503 0x6D, 0x5A, 0x56, 0xDA, 0x25, 0x5B, 0x0E, 0xC2, 0x41, 0x67, 0x25, 0x3D, 504 0x43, 0xA3, 0x8F, 0xB0, 0xD0, 0xCA, 0x2B, 0xCB, 0xAE, 0x7B, 0x30, 0xB4, 505 0x77, 0xCB, 0x2D, 0xA3, 0x80, 0x30, 0xF2, 0x0C, 0x6A, 0x42, 0xB7, 0x3B, 506 0xBE, 0xAC, 0x01, 0xFA 507 }; 508 509 if (dev->device.numa_node == SOCKET_ID_ANY) 510 dev->device.numa_node = rte_socket_id(); 511 512 RTE_LOG(INFO, PMD, "Creating null ethdev on numa socket %u\n", 513 dev->device.numa_node); 514 515 /* now do all data allocation - for eth_dev structure, dummy pci driver 516 * and internal (private) data 517 */ 518 data = rte_zmalloc_socket(rte_vdev_device_name(dev), sizeof(*data), 0, 519 dev->device.numa_node); 520 if (!data) 521 return -ENOMEM; 522 523 eth_dev = rte_eth_vdev_allocate(dev, sizeof(*internals)); 524 if (!eth_dev) { 525 rte_free(data); 526 return -ENOMEM; 527 } 528 /* now put it all together 529 * - store queue data in internals, 530 * - store numa_node info in ethdev data 531 * - point eth_dev_data to internals 532 * - and point eth_dev structure to new eth_dev_data structure 533 */ 534 /* NOTE: we'll replace the data element, of originally allocated eth_dev 535 * so the nulls are local per-process */ 536 537 internals = eth_dev->data->dev_private; 538 internals->packet_size = packet_size; 539 internals->packet_copy = packet_copy; 540 internals->port_id = eth_dev->data->port_id; 541 eth_random_addr(internals->eth_addr.addr_bytes); 542 543 internals->flow_type_rss_offloads = ETH_RSS_PROTO_MASK; 544 internals->reta_size = RTE_DIM(internals->reta_conf) * RTE_RETA_GROUP_SIZE; 545 546 rte_memcpy(internals->rss_key, default_rss_key, 40); 547 548 rte_memcpy(data, eth_dev->data, sizeof(*data)); 549 data->nb_rx_queues = (uint16_t)nb_rx_queues; 550 data->nb_tx_queues = (uint16_t)nb_tx_queues; 551 data->dev_link = pmd_link; 552 data->mac_addrs = &internals->eth_addr; 553 554 eth_dev->data = data; 555 eth_dev->dev_ops = &ops; 556 557 /* finally assign rx and tx ops */ 558 if (packet_copy) { 559 eth_dev->rx_pkt_burst = eth_null_copy_rx; 560 eth_dev->tx_pkt_burst = eth_null_copy_tx; 561 } else { 562 eth_dev->rx_pkt_burst = eth_null_rx; 563 eth_dev->tx_pkt_burst = eth_null_tx; 564 } 565 566 return 0; 567 } 568 569 static inline int 570 get_packet_size_arg(const char *key __rte_unused, 571 const char *value, void *extra_args) 572 { 573 const char *a = value; 574 unsigned *packet_size = extra_args; 575 576 if ((value == NULL) || (extra_args == NULL)) 577 return -EINVAL; 578 579 *packet_size = (unsigned)strtoul(a, NULL, 0); 580 if (*packet_size == UINT_MAX) 581 return -1; 582 583 return 0; 584 } 585 586 static inline int 587 get_packet_copy_arg(const char *key __rte_unused, 588 const char *value, void *extra_args) 589 { 590 const char *a = value; 591 unsigned *packet_copy = extra_args; 592 593 if ((value == NULL) || (extra_args == NULL)) 594 return -EINVAL; 595 596 *packet_copy = (unsigned)strtoul(a, NULL, 0); 597 if (*packet_copy == UINT_MAX) 598 return -1; 599 600 return 0; 601 } 602 603 static int 604 rte_pmd_null_probe(struct rte_vdev_device *dev) 605 { 606 const char *name, *params; 607 unsigned packet_size = default_packet_size; 608 unsigned packet_copy = default_packet_copy; 609 struct rte_kvargs *kvlist = NULL; 610 int ret; 611 612 if (!dev) 613 return -EINVAL; 614 615 name = rte_vdev_device_name(dev); 616 params = rte_vdev_device_args(dev); 617 RTE_LOG(INFO, PMD, "Initializing pmd_null for %s\n", name); 618 619 if (params != NULL) { 620 kvlist = rte_kvargs_parse(params, valid_arguments); 621 if (kvlist == NULL) 622 return -1; 623 624 if (rte_kvargs_count(kvlist, ETH_NULL_PACKET_SIZE_ARG) == 1) { 625 626 ret = rte_kvargs_process(kvlist, 627 ETH_NULL_PACKET_SIZE_ARG, 628 &get_packet_size_arg, &packet_size); 629 if (ret < 0) 630 goto free_kvlist; 631 } 632 633 if (rte_kvargs_count(kvlist, ETH_NULL_PACKET_COPY_ARG) == 1) { 634 635 ret = rte_kvargs_process(kvlist, 636 ETH_NULL_PACKET_COPY_ARG, 637 &get_packet_copy_arg, &packet_copy); 638 if (ret < 0) 639 goto free_kvlist; 640 } 641 } 642 643 RTE_LOG(INFO, PMD, "Configure pmd_null: packet size is %d, " 644 "packet copy is %s\n", packet_size, 645 packet_copy ? "enabled" : "disabled"); 646 647 ret = eth_dev_null_create(dev, packet_size, packet_copy); 648 649 free_kvlist: 650 if (kvlist) 651 rte_kvargs_free(kvlist); 652 return ret; 653 } 654 655 static int 656 rte_pmd_null_remove(struct rte_vdev_device *dev) 657 { 658 struct rte_eth_dev *eth_dev = NULL; 659 660 if (!dev) 661 return -EINVAL; 662 663 RTE_LOG(INFO, PMD, "Closing null ethdev on numa socket %u\n", 664 rte_socket_id()); 665 666 /* find the ethdev entry */ 667 eth_dev = rte_eth_dev_allocated(rte_vdev_device_name(dev)); 668 if (eth_dev == NULL) 669 return -1; 670 671 rte_free(eth_dev->data->dev_private); 672 rte_free(eth_dev->data); 673 674 rte_eth_dev_release_port(eth_dev); 675 676 return 0; 677 } 678 679 static struct rte_vdev_driver pmd_null_drv = { 680 .probe = rte_pmd_null_probe, 681 .remove = rte_pmd_null_remove, 682 }; 683 684 RTE_PMD_REGISTER_VDEV(net_null, pmd_null_drv); 685 RTE_PMD_REGISTER_ALIAS(net_null, eth_null); 686 RTE_PMD_REGISTER_PARAM_STRING(net_null, 687 "size=<int> " 688 "copy=<int>"); 689