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 void
 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;
 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
 334 static void
 335 eth_queue_release(void *q)
 336 {
 337         struct null_queue *nq;
 338
 339         if (q == NULL)
 340                 return;
 341
 342         nq = q;
 343         rte_free(nq->dummy_packet);
 344 }
 345
 346 static int
 347 eth_link_update(struct rte_eth_dev *dev __rte_unused,
 348                 int wait_to_complete __rte_unused) { return 0; }
 349
 350 static int
 351 eth_rss_reta_update(struct rte_eth_dev *dev,
 352                 struct rte_eth_rss_reta_entry64 *reta_conf, uint16_t reta_size)
 353 {
 354         int i, j;
 355         struct pmd_internals *internal = dev->data->dev_private;
 356
 357         if (reta_size != internal->reta_size)
 358                 return -EINVAL;
 359
 360         rte_spinlock_lock(&internal->rss_lock);
 361
 362         /* Copy RETA table */
 363         for (i = 0; i < (internal->reta_size / RTE_RETA_GROUP_SIZE); i++) {
 364                 internal->reta_conf[i].mask = reta_conf[i].mask;
 365                 for (j = 0; j < RTE_RETA_GROUP_SIZE; j++)
 366                         if ((reta_conf[i].mask >> j) & 0x01)
 367                                 internal->reta_conf[i].reta[j] = reta_conf[i].reta[j];
 368         }
 369
 370         rte_spinlock_unlock(&internal->rss_lock);
 371
 372         return 0;
 373 }
 374
 375 static int
 376 eth_rss_reta_query(struct rte_eth_dev *dev,
 377                 struct rte_eth_rss_reta_entry64 *reta_conf, uint16_t reta_size)
 378 {
 379         int i, j;
 380         struct pmd_internals *internal = dev->data->dev_private;
 381
 382         if (reta_size != internal->reta_size)
 383                 return -EINVAL;
 384
 385         rte_spinlock_lock(&internal->rss_lock);
 386
 387         /* Copy RETA table */
 388         for (i = 0; i < (internal->reta_size / RTE_RETA_GROUP_SIZE); i++) {
 389                 for (j = 0; j < RTE_RETA_GROUP_SIZE; j++)
 390                         if ((reta_conf[i].mask >> j) & 0x01)
 391                                 reta_conf[i].reta[j] = internal->reta_conf[i].reta[j];
 392         }
 393
 394         rte_spinlock_unlock(&internal->rss_lock);
 395
 396         return 0;
 397 }
 398
 399 static int
 400 eth_rss_hash_update(struct rte_eth_dev *dev, struct rte_eth_rss_conf *rss_conf)
 401 {
 402         struct pmd_internals *internal = dev->data->dev_private;
 403
 404         rte_spinlock_lock(&internal->rss_lock);
 405
 406         if ((rss_conf->rss_hf & internal->flow_type_rss_offloads) != 0)
 407                 dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf =
 408                                 rss_conf->rss_hf & internal->flow_type_rss_offloads;
 409
 410         if (rss_conf->rss_key)
 411                 rte_memcpy(internal->rss_key, rss_conf->rss_key, 40);
 412
 413         rte_spinlock_unlock(&internal->rss_lock);
 414
 415         return 0;
 416 }
 417
 418 static int
 419 eth_rss_hash_conf_get(struct rte_eth_dev *dev,
 420                 struct rte_eth_rss_conf *rss_conf)
 421 {
 422         struct pmd_internals *internal = dev->data->dev_private;
 423
 424         rte_spinlock_lock(&internal->rss_lock);
 425
 426         rss_conf->rss_hf = dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf;
 427         if (rss_conf->rss_key)
 428                 rte_memcpy(rss_conf->rss_key, internal->rss_key, 40);
 429
 430         rte_spinlock_unlock(&internal->rss_lock);
 431
 432         return 0;
 433 }
 434
 435 static int
 436 eth_mac_address_set(__rte_unused struct rte_eth_dev *dev,
 437                     __rte_unused struct rte_ether_addr *addr)
 438 {
 439         return 0;
 440 }
 441
 442 static const struct eth_dev_ops ops = {
 443         .dev_start = eth_dev_start,
 444         .dev_stop = eth_dev_stop,
 445         .dev_configure = eth_dev_configure,
 446         .dev_infos_get = eth_dev_info,
 447         .rx_queue_setup = eth_rx_queue_setup,
 448         .tx_queue_setup = eth_tx_queue_setup,
 449         .rx_queue_release = eth_queue_release,
 450         .tx_queue_release = eth_queue_release,
 451         .mtu_set = eth_mtu_set,
 452         .link_update = eth_link_update,
 453         .mac_addr_set = eth_mac_address_set,
 454         .stats_get = eth_stats_get,
 455         .stats_reset = eth_stats_reset,
 456         .reta_update = eth_rss_reta_update,
 457         .reta_query = eth_rss_reta_query,
 458         .rss_hash_update = eth_rss_hash_update,
 459         .rss_hash_conf_get = eth_rss_hash_conf_get
 460 };
 461
 462 static int
 463 eth_dev_null_create(struct rte_vdev_device *dev,
 464                 unsigned packet_size,
 465                 unsigned packet_copy)
 466 {
 467         const unsigned nb_rx_queues = 1;
 468         const unsigned nb_tx_queues = 1;
 469         struct rte_eth_dev_data *data;
 470         struct pmd_internals *internals = NULL;
 471         struct rte_eth_dev *eth_dev = NULL;
 472
 473         static const uint8_t default_rss_key[40] = {
 474                 0x6D, 0x5A, 0x56, 0xDA, 0x25, 0x5B, 0x0E, 0xC2, 0x41, 0x67, 0x25, 0x3D,
 475                 0x43, 0xA3, 0x8F, 0xB0, 0xD0, 0xCA, 0x2B, 0xCB, 0xAE, 0x7B, 0x30, 0xB4,
 476                 0x77, 0xCB, 0x2D, 0xA3, 0x80, 0x30, 0xF2, 0x0C, 0x6A, 0x42, 0xB7, 0x3B,
 477                 0xBE, 0xAC, 0x01, 0xFA
 478         };
 479
 480         if (dev->device.numa_node == SOCKET_ID_ANY)
 481                 dev->device.numa_node = rte_socket_id();
 482
 483         PMD_LOG(INFO, "Creating null ethdev on numa socket %u",
 484                 dev->device.numa_node);
 485
 486         eth_dev = rte_eth_vdev_allocate(dev, sizeof(*internals));
 487         if (!eth_dev)
 488                 return -ENOMEM;
 489
 490         /* now put it all together
 491          * - store queue data in internals,
 492          * - store numa_node info in ethdev data
 493          * - point eth_dev_data to internals
 494          * - and point eth_dev structure to new eth_dev_data structure
 495          */
 496         /* NOTE: we'll replace the data element, of originally allocated eth_dev
 497          * so the nulls are local per-process */
 498
 499         internals = eth_dev->data->dev_private;
 500         internals->packet_size = packet_size;
 501         internals->packet_copy = packet_copy;
 502         internals->port_id = eth_dev->data->port_id;
 503         rte_eth_random_addr(internals->eth_addr.addr_bytes);
 504
 505         internals->flow_type_rss_offloads =  ETH_RSS_PROTO_MASK;
 506         internals->reta_size = RTE_DIM(internals->reta_conf) * RTE_RETA_GROUP_SIZE;
 507
 508         rte_memcpy(internals->rss_key, default_rss_key, 40);
 509
 510         data = eth_dev->data;
 511         data->nb_rx_queues = (uint16_t)nb_rx_queues;
 512         data->nb_tx_queues = (uint16_t)nb_tx_queues;
 513         data->dev_link = pmd_link;
 514         data->mac_addrs = &internals->eth_addr;
 515
 516         eth_dev->dev_ops = &ops;
 517
 518         /* finally assign rx and tx ops */
 519         if (packet_copy) {
 520                 eth_dev->rx_pkt_burst = eth_null_copy_rx;
 521                 eth_dev->tx_pkt_burst = eth_null_copy_tx;
 522         } else {
 523                 eth_dev->rx_pkt_burst = eth_null_rx;
 524                 eth_dev->tx_pkt_burst = eth_null_tx;
 525         }
 526
 527         rte_eth_dev_probing_finish(eth_dev);
 528         return 0;
 529 }
 530
 531 static inline int
 532 get_packet_size_arg(const char *key __rte_unused,
 533                 const char *value, void *extra_args)
 534 {
 535         const char *a = value;
 536         unsigned *packet_size = extra_args;
 537
 538         if ((value == NULL) || (extra_args == NULL))
 539                 return -EINVAL;
 540
 541         *packet_size = (unsigned)strtoul(a, NULL, 0);
 542         if (*packet_size == UINT_MAX)
 543                 return -1;
 544
 545         return 0;
 546 }
 547
 548 static inline int
 549 get_packet_copy_arg(const char *key __rte_unused,
 550                 const char *value, void *extra_args)
 551 {
 552         const char *a = value;
 553         unsigned *packet_copy = extra_args;
 554
 555         if ((value == NULL) || (extra_args == NULL))
 556                 return -EINVAL;
 557
 558         *packet_copy = (unsigned)strtoul(a, NULL, 0);
 559         if (*packet_copy == UINT_MAX)
 560                 return -1;
 561
 562         return 0;
 563 }
 564
 565 static int
 566 rte_pmd_null_probe(struct rte_vdev_device *dev)
 567 {
 568         const char *name, *params;
 569         unsigned packet_size = default_packet_size;
 570         unsigned packet_copy = default_packet_copy;
 571         struct rte_kvargs *kvlist = NULL;
 572         struct rte_eth_dev *eth_dev;
 573         int ret;
 574
 575         if (!dev)
 576                 return -EINVAL;
 577
 578         name = rte_vdev_device_name(dev);
 579         params = rte_vdev_device_args(dev);
 580         PMD_LOG(INFO, "Initializing pmd_null for %s", name);
 581
 582         if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
 583                 eth_dev = rte_eth_dev_attach_secondary(name);
 584                 if (!eth_dev) {
 585                         PMD_LOG(ERR, "Failed to probe %s", name);
 586                         return -1;
 587                 }
 588                 /* TODO: request info from primary to set up Rx and Tx */
 589                 eth_dev->dev_ops = &ops;
 590                 eth_dev->device = &dev->device;
 591                 rte_eth_dev_probing_finish(eth_dev);
 592                 return 0;
 593         }
 594
 595         if (params != NULL) {
 596                 kvlist = rte_kvargs_parse(params, valid_arguments);
 597                 if (kvlist == NULL)
 598                         return -1;
 599
 600                 if (rte_kvargs_count(kvlist, ETH_NULL_PACKET_SIZE_ARG) == 1) {
 601
 602                         ret = rte_kvargs_process(kvlist,
 603                                         ETH_NULL_PACKET_SIZE_ARG,
 604                                         &get_packet_size_arg, &packet_size);
 605                         if (ret < 0)
 606                                 goto free_kvlist;
 607                 }
 608
 609                 if (rte_kvargs_count(kvlist, ETH_NULL_PACKET_COPY_ARG) == 1) {
 610
 611                         ret = rte_kvargs_process(kvlist,
 612                                         ETH_NULL_PACKET_COPY_ARG,
 613                                         &get_packet_copy_arg, &packet_copy);
 614                         if (ret < 0)
 615                                 goto free_kvlist;
 616                 }
 617         }
 618
 619         PMD_LOG(INFO, "Configure pmd_null: packet size is %d, "
 620                         "packet copy is %s", packet_size,
 621                         packet_copy ? "enabled" : "disabled");
 622
 623         ret = eth_dev_null_create(dev, packet_size, packet_copy);
 624
 625 free_kvlist:
 626         if (kvlist)
 627                 rte_kvargs_free(kvlist);
 628         return ret;
 629 }
 630
 631 static int
 632 rte_pmd_null_remove(struct rte_vdev_device *dev)
 633 {
 634         struct rte_eth_dev *eth_dev = NULL;
 635
 636         if (!dev)
 637                 return -EINVAL;
 638
 639         PMD_LOG(INFO, "Closing null ethdev on numa socket %u",
 640                         rte_socket_id());
 641
 642         /* find the ethdev entry */
 643         eth_dev = rte_eth_dev_allocated(rte_vdev_device_name(dev));
 644         if (eth_dev == NULL)
 645                 return -1;
 646
 647         if (rte_eal_process_type() == RTE_PROC_PRIMARY)
 648                 /* mac_addrs must not be freed alone because part of dev_private */
 649                 eth_dev->data->mac_addrs = NULL;
 650
 651         rte_eth_dev_release_port(eth_dev);
 652
 653         return 0;
 654 }
 655
 656 static struct rte_vdev_driver pmd_null_drv = {
 657         .probe = rte_pmd_null_probe,
 658         .remove = rte_pmd_null_remove,
 659 };
 660
 661 RTE_PMD_REGISTER_VDEV(net_null, pmd_null_drv);
 662 RTE_PMD_REGISTER_ALIAS(net_null, eth_null);
 663 RTE_PMD_REGISTER_PARAM_STRING(net_null,
 664         "size=<int> "
 665         "copy=<int>");
 666
 667 RTE_INIT(eth_null_init_log)
 668 {
 669         eth_null_logtype = rte_log_register("pmd.net.null");
 670         if (eth_null_logtype >= 0)
 671                 rte_log_set_level(eth_null_logtype, RTE_LOG_NOTICE);
 672 }