drivers/net/null/rte_eth_null.c

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