drivers/net/null/rte_eth_null.c

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