drivers/net/softnic/rte_eth_softnic.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2017 Intel Corporation
   3  */
   4
   5 #include <stdint.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8
   9 #include <rte_ethdev_driver.h>
  10 #include <rte_ethdev_vdev.h>
  11 #include <rte_malloc.h>
  12 #include <rte_bus_vdev.h>
  13 #include <rte_kvargs.h>
  14 #include <rte_errno.h>
  15 #include <rte_ring.h>
  16 #include <rte_sched.h>
  17 #include <rte_tm_driver.h>
  18
  19 #include "rte_eth_softnic.h"
  20 #include "rte_eth_softnic_internals.h"
  21
  22 #define DEV_HARD(p)                                     \
  23         (&rte_eth_devices[p->hard.port_id])
  24
  25 #define PMD_PARAM_SOFT_TM                                       "soft_tm"
  26 #define PMD_PARAM_SOFT_TM_RATE                          "soft_tm_rate"
  27 #define PMD_PARAM_SOFT_TM_NB_QUEUES                     "soft_tm_nb_queues"
  28 #define PMD_PARAM_SOFT_TM_QSIZE0                        "soft_tm_qsize0"
  29 #define PMD_PARAM_SOFT_TM_QSIZE1                        "soft_tm_qsize1"
  30 #define PMD_PARAM_SOFT_TM_QSIZE2                        "soft_tm_qsize2"
  31 #define PMD_PARAM_SOFT_TM_QSIZE3                        "soft_tm_qsize3"
  32 #define PMD_PARAM_SOFT_TM_ENQ_BSZ                       "soft_tm_enq_bsz"
  33 #define PMD_PARAM_SOFT_TM_DEQ_BSZ                       "soft_tm_deq_bsz"
  34
  35 #define PMD_PARAM_HARD_NAME                                     "hard_name"
  36 #define PMD_PARAM_HARD_TX_QUEUE_ID                      "hard_tx_queue_id"
  37
  38 static const char *pmd_valid_args[] = {
  39         PMD_PARAM_SOFT_TM,
  40         PMD_PARAM_SOFT_TM_RATE,
  41         PMD_PARAM_SOFT_TM_NB_QUEUES,
  42         PMD_PARAM_SOFT_TM_QSIZE0,
  43         PMD_PARAM_SOFT_TM_QSIZE1,
  44         PMD_PARAM_SOFT_TM_QSIZE2,
  45         PMD_PARAM_SOFT_TM_QSIZE3,
  46         PMD_PARAM_SOFT_TM_ENQ_BSZ,
  47         PMD_PARAM_SOFT_TM_DEQ_BSZ,
  48         PMD_PARAM_HARD_NAME,
  49         PMD_PARAM_HARD_TX_QUEUE_ID,
  50         NULL
  51 };
  52
  53 static const struct rte_eth_dev_info pmd_dev_info = {
  54         .min_rx_bufsize = 0,
  55         .max_rx_pktlen = UINT32_MAX,
  56         .max_rx_queues = UINT16_MAX,
  57         .max_tx_queues = UINT16_MAX,
  58         .rx_desc_lim = {
  59                 .nb_max = UINT16_MAX,
  60                 .nb_min = 0,
  61                 .nb_align = 1,
  62         },
  63         .tx_desc_lim = {
  64                 .nb_max = UINT16_MAX,
  65                 .nb_min = 0,
  66                 .nb_align = 1,
  67         },
  68 };
  69
  70 static int pmd_softnic_logtype;
  71
  72 #define PMD_LOG(level, fmt, args...) \
  73         rte_log(RTE_LOG_ ## level, pmd_softnic_logtype, \
  74                 "%s(): " fmt "\n", __func__, ##args)
  75
  76 static void
  77 pmd_dev_infos_get(struct rte_eth_dev *dev __rte_unused,
  78         struct rte_eth_dev_info *dev_info)
  79 {
  80         memcpy(dev_info, &pmd_dev_info, sizeof(*dev_info));
  81 }
  82
  83 static int
  84 pmd_dev_configure(struct rte_eth_dev *dev)
  85 {
  86         struct pmd_internals *p = dev->data->dev_private;
  87         struct rte_eth_dev *hard_dev = DEV_HARD(p);
  88
  89         if (dev->data->nb_rx_queues > hard_dev->data->nb_rx_queues)
  90                 return -1;
  91
  92         if (p->params.hard.tx_queue_id >= hard_dev->data->nb_tx_queues)
  93                 return -1;
  94
  95         return 0;
  96 }
  97
  98 static int
  99 pmd_rx_queue_setup(struct rte_eth_dev *dev,
 100         uint16_t rx_queue_id,
 101         uint16_t nb_rx_desc __rte_unused,
 102         unsigned int socket_id,
 103         const struct rte_eth_rxconf *rx_conf __rte_unused,
 104         struct rte_mempool *mb_pool __rte_unused)
 105 {
 106         struct pmd_internals *p = dev->data->dev_private;
 107
 108         if (p->params.soft.intrusive == 0) {
 109                 struct pmd_rx_queue *rxq;
 110
 111                 rxq = rte_zmalloc_socket(p->params.soft.name,
 112                         sizeof(struct pmd_rx_queue), 0, socket_id);
 113                 if (rxq == NULL)
 114                         return -ENOMEM;
 115
 116                 rxq->hard.port_id = p->hard.port_id;
 117                 rxq->hard.rx_queue_id = rx_queue_id;
 118                 dev->data->rx_queues[rx_queue_id] = rxq;
 119         } else {
 120                 struct rte_eth_dev *hard_dev = DEV_HARD(p);
 121                 void *rxq = hard_dev->data->rx_queues[rx_queue_id];
 122
 123                 if (rxq == NULL)
 124                         return -1;
 125
 126                 dev->data->rx_queues[rx_queue_id] = rxq;
 127         }
 128         return 0;
 129 }
 130
 131 static int
 132 pmd_tx_queue_setup(struct rte_eth_dev *dev,
 133         uint16_t tx_queue_id,
 134         uint16_t nb_tx_desc,
 135         unsigned int socket_id,
 136         const struct rte_eth_txconf *tx_conf __rte_unused)
 137 {
 138         uint32_t size = RTE_ETH_NAME_MAX_LEN + strlen("_txq") + 4;
 139         char name[size];
 140         struct rte_ring *r;
 141
 142         snprintf(name, sizeof(name), "%s_txq%04x",
 143                 dev->data->name, tx_queue_id);
 144         r = rte_ring_create(name, nb_tx_desc, socket_id,
 145                 RING_F_SP_ENQ | RING_F_SC_DEQ);
 146         if (r == NULL)
 147                 return -1;
 148
 149         dev->data->tx_queues[tx_queue_id] = r;
 150         return 0;
 151 }
 152
 153 static int
 154 pmd_dev_start(struct rte_eth_dev *dev)
 155 {
 156         struct pmd_internals *p = dev->data->dev_private;
 157
 158         if (tm_used(dev)) {
 159                 int status = tm_start(p);
 160
 161                 if (status)
 162                         return status;
 163         }
 164
 165         dev->data->dev_link.link_status = ETH_LINK_UP;
 166
 167         if (p->params.soft.intrusive) {
 168                 struct rte_eth_dev *hard_dev = DEV_HARD(p);
 169
 170                 /* The hard_dev->rx_pkt_burst should be stable by now */
 171                 dev->rx_pkt_burst = hard_dev->rx_pkt_burst;
 172         }
 173
 174         return 0;
 175 }
 176
 177 static void
 178 pmd_dev_stop(struct rte_eth_dev *dev)
 179 {
 180         struct pmd_internals *p = dev->data->dev_private;
 181
 182         dev->data->dev_link.link_status = ETH_LINK_DOWN;
 183
 184         if (tm_used(dev))
 185                 tm_stop(p);
 186 }
 187
 188 static void
 189 pmd_dev_close(struct rte_eth_dev *dev)
 190 {
 191         uint32_t i;
 192
 193         /* TX queues */
 194         for (i = 0; i < dev->data->nb_tx_queues; i++)
 195                 rte_ring_free((struct rte_ring *)dev->data->tx_queues[i]);
 196 }
 197
 198 static int
 199 pmd_link_update(struct rte_eth_dev *dev __rte_unused,
 200         int wait_to_complete __rte_unused)
 201 {
 202         return 0;
 203 }
 204
 205 static int
 206 pmd_tm_ops_get(struct rte_eth_dev *dev, void *arg)
 207 {
 208         *(const struct rte_tm_ops **)arg =
 209                 (tm_enabled(dev)) ? &pmd_tm_ops : NULL;
 210
 211         return 0;
 212 }
 213
 214 static const struct eth_dev_ops pmd_ops = {
 215         .dev_configure = pmd_dev_configure,
 216         .dev_start = pmd_dev_start,
 217         .dev_stop = pmd_dev_stop,
 218         .dev_close = pmd_dev_close,
 219         .link_update = pmd_link_update,
 220         .dev_infos_get = pmd_dev_infos_get,
 221         .rx_queue_setup = pmd_rx_queue_setup,
 222         .tx_queue_setup = pmd_tx_queue_setup,
 223         .tm_ops_get = pmd_tm_ops_get,
 224 };
 225
 226 static uint16_t
 227 pmd_rx_pkt_burst(void *rxq,
 228         struct rte_mbuf **rx_pkts,
 229         uint16_t nb_pkts)
 230 {
 231         struct pmd_rx_queue *rx_queue = rxq;
 232
 233         return rte_eth_rx_burst(rx_queue->hard.port_id,
 234                 rx_queue->hard.rx_queue_id,
 235                 rx_pkts,
 236                 nb_pkts);
 237 }
 238
 239 static uint16_t
 240 pmd_tx_pkt_burst(void *txq,
 241         struct rte_mbuf **tx_pkts,
 242         uint16_t nb_pkts)
 243 {
 244         return (uint16_t)rte_ring_enqueue_burst(txq,
 245                 (void **)tx_pkts,
 246                 nb_pkts,
 247                 NULL);
 248 }
 249
 250 static __rte_always_inline int
 251 run_default(struct rte_eth_dev *dev)
 252 {
 253         struct pmd_internals *p = dev->data->dev_private;
 254
 255         /* Persistent context: Read Only (update not required) */
 256         struct rte_mbuf **pkts = p->soft.def.pkts;
 257         uint16_t nb_tx_queues = dev->data->nb_tx_queues;
 258
 259         /* Persistent context: Read - Write (update required) */
 260         uint32_t txq_pos = p->soft.def.txq_pos;
 261         uint32_t pkts_len = p->soft.def.pkts_len;
 262         uint32_t flush_count = p->soft.def.flush_count;
 263
 264         /* Not part of the persistent context */
 265         uint32_t pos;
 266         uint16_t i;
 267
 268         /* Soft device TXQ read, Hard device TXQ write */
 269         for (i = 0; i < nb_tx_queues; i++) {
 270                 struct rte_ring *txq = dev->data->tx_queues[txq_pos];
 271
 272                 /* Read soft device TXQ burst to packet enqueue buffer */
 273                 pkts_len += rte_ring_sc_dequeue_burst(txq,
 274                         (void **)&pkts[pkts_len],
 275                         DEFAULT_BURST_SIZE,
 276                         NULL);
 277
 278                 /* Increment soft device TXQ */
 279                 txq_pos++;
 280                 if (txq_pos >= nb_tx_queues)
 281                         txq_pos = 0;
 282
 283                 /* Hard device TXQ write when complete burst is available */
 284                 if (pkts_len >= DEFAULT_BURST_SIZE) {
 285                         for (pos = 0; pos < pkts_len; )
 286                                 pos += rte_eth_tx_burst(p->hard.port_id,
 287                                         p->params.hard.tx_queue_id,
 288                                         &pkts[pos],
 289                                         (uint16_t)(pkts_len - pos));
 290
 291                         pkts_len = 0;
 292                         flush_count = 0;
 293                         break;
 294                 }
 295         }
 296
 297         if (flush_count >= FLUSH_COUNT_THRESHOLD) {
 298                 for (pos = 0; pos < pkts_len; )
 299                         pos += rte_eth_tx_burst(p->hard.port_id,
 300                                 p->params.hard.tx_queue_id,
 301                                 &pkts[pos],
 302                                 (uint16_t)(pkts_len - pos));
 303
 304                 pkts_len = 0;
 305                 flush_count = 0;
 306         }
 307
 308         p->soft.def.txq_pos = txq_pos;
 309         p->soft.def.pkts_len = pkts_len;
 310         p->soft.def.flush_count = flush_count + 1;
 311
 312         return 0;
 313 }
 314
 315 static __rte_always_inline int
 316 run_tm(struct rte_eth_dev *dev)
 317 {
 318         struct pmd_internals *p = dev->data->dev_private;
 319
 320         /* Persistent context: Read Only (update not required) */
 321         struct rte_sched_port *sched = p->soft.tm.sched;
 322         struct rte_mbuf **pkts_enq = p->soft.tm.pkts_enq;
 323         struct rte_mbuf **pkts_deq = p->soft.tm.pkts_deq;
 324         uint32_t enq_bsz = p->params.soft.tm.enq_bsz;
 325         uint32_t deq_bsz = p->params.soft.tm.deq_bsz;
 326         uint16_t nb_tx_queues = dev->data->nb_tx_queues;
 327
 328         /* Persistent context: Read - Write (update required) */
 329         uint32_t txq_pos = p->soft.tm.txq_pos;
 330         uint32_t pkts_enq_len = p->soft.tm.pkts_enq_len;
 331         uint32_t flush_count = p->soft.tm.flush_count;
 332
 333         /* Not part of the persistent context */
 334         uint32_t pkts_deq_len, pos;
 335         uint16_t i;
 336
 337         /* Soft device TXQ read, TM enqueue */
 338         for (i = 0; i < nb_tx_queues; i++) {
 339                 struct rte_ring *txq = dev->data->tx_queues[txq_pos];
 340
 341                 /* Read TXQ burst to packet enqueue buffer */
 342                 pkts_enq_len += rte_ring_sc_dequeue_burst(txq,
 343                         (void **)&pkts_enq[pkts_enq_len],
 344                         enq_bsz,
 345                         NULL);
 346
 347                 /* Increment TXQ */
 348                 txq_pos++;
 349                 if (txq_pos >= nb_tx_queues)
 350                         txq_pos = 0;
 351
 352                 /* TM enqueue when complete burst is available */
 353                 if (pkts_enq_len >= enq_bsz) {
 354                         rte_sched_port_enqueue(sched, pkts_enq, pkts_enq_len);
 355
 356                         pkts_enq_len = 0;
 357                         flush_count = 0;
 358                         break;
 359                 }
 360         }
 361
 362         if (flush_count >= FLUSH_COUNT_THRESHOLD) {
 363                 if (pkts_enq_len)
 364                         rte_sched_port_enqueue(sched, pkts_enq, pkts_enq_len);
 365
 366                 pkts_enq_len = 0;
 367                 flush_count = 0;
 368         }
 369
 370         p->soft.tm.txq_pos = txq_pos;
 371         p->soft.tm.pkts_enq_len = pkts_enq_len;
 372         p->soft.tm.flush_count = flush_count + 1;
 373
 374         /* TM dequeue, Hard device TXQ write */
 375         pkts_deq_len = rte_sched_port_dequeue(sched, pkts_deq, deq_bsz);
 376
 377         for (pos = 0; pos < pkts_deq_len; )
 378                 pos += rte_eth_tx_burst(p->hard.port_id,
 379                         p->params.hard.tx_queue_id,
 380                         &pkts_deq[pos],
 381                         (uint16_t)(pkts_deq_len - pos));
 382
 383         return 0;
 384 }
 385
 386 int
 387 rte_pmd_softnic_run(uint16_t port_id)
 388 {
 389         struct rte_eth_dev *dev = &rte_eth_devices[port_id];
 390
 391 #ifdef RTE_LIBRTE_ETHDEV_DEBUG
 392         RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, 0);
 393 #endif
 394
 395         return (tm_used(dev)) ? run_tm(dev) : run_default(dev);
 396 }
 397
 398 static struct ether_addr eth_addr = { .addr_bytes = {0} };
 399
 400 static uint32_t
 401 eth_dev_speed_max_mbps(uint32_t speed_capa)
 402 {
 403         uint32_t rate_mbps[32] = {
 404                 ETH_SPEED_NUM_NONE,
 405                 ETH_SPEED_NUM_10M,
 406                 ETH_SPEED_NUM_10M,
 407                 ETH_SPEED_NUM_100M,
 408                 ETH_SPEED_NUM_100M,
 409                 ETH_SPEED_NUM_1G,
 410                 ETH_SPEED_NUM_2_5G,
 411                 ETH_SPEED_NUM_5G,
 412                 ETH_SPEED_NUM_10G,
 413                 ETH_SPEED_NUM_20G,
 414                 ETH_SPEED_NUM_25G,
 415                 ETH_SPEED_NUM_40G,
 416                 ETH_SPEED_NUM_50G,
 417                 ETH_SPEED_NUM_56G,
 418                 ETH_SPEED_NUM_100G,
 419         };
 420
 421         uint32_t pos = (speed_capa) ? (31 - __builtin_clz(speed_capa)) : 0;
 422         return rate_mbps[pos];
 423 }
 424
 425 static int
 426 default_init(struct pmd_internals *p,
 427         struct pmd_params *params,
 428         int numa_node)
 429 {
 430         p->soft.def.pkts = rte_zmalloc_socket(params->soft.name,
 431                 2 * DEFAULT_BURST_SIZE * sizeof(struct rte_mbuf *),
 432                 0,
 433                 numa_node);
 434
 435         if (p->soft.def.pkts == NULL)
 436                 return -ENOMEM;
 437
 438         return 0;
 439 }
 440
 441 static void
 442 default_free(struct pmd_internals *p)
 443 {
 444         rte_free(p->soft.def.pkts);
 445 }
 446
 447 static void *
 448 pmd_init(struct pmd_params *params, int numa_node)
 449 {
 450         struct pmd_internals *p;
 451         int status;
 452
 453         p = rte_zmalloc_socket(params->soft.name,
 454                 sizeof(struct pmd_internals),
 455                 0,
 456                 numa_node);
 457         if (p == NULL)
 458                 return NULL;
 459
 460         memcpy(&p->params, params, sizeof(p->params));
 461         rte_eth_dev_get_port_by_name(params->hard.name, &p->hard.port_id);
 462
 463         /* Default */
 464         status = default_init(p, params, numa_node);
 465         if (status) {
 466                 free(p->params.hard.name);
 467                 rte_free(p);
 468                 return NULL;
 469         }
 470
 471         /* Traffic Management (TM)*/
 472         if (params->soft.flags & PMD_FEATURE_TM) {
 473                 status = tm_init(p, params, numa_node);
 474                 if (status) {
 475                         default_free(p);
 476                         free(p->params.hard.name);
 477                         rte_free(p);
 478                         return NULL;
 479                 }
 480         }
 481
 482         return p;
 483 }
 484
 485 static void
 486 pmd_free(struct pmd_internals *p)
 487 {
 488         if (p->params.soft.flags & PMD_FEATURE_TM)
 489                 tm_free(p);
 490
 491         default_free(p);
 492
 493         free(p->params.hard.name);
 494         rte_free(p);
 495 }
 496
 497 static int
 498 pmd_ethdev_register(struct rte_vdev_device *vdev,
 499         struct pmd_params *params,
 500         void *dev_private)
 501 {
 502         struct rte_eth_dev_info hard_info;
 503         struct rte_eth_dev *soft_dev;
 504         uint32_t hard_speed;
 505         int numa_node;
 506         uint16_t hard_port_id;
 507
 508         rte_eth_dev_get_port_by_name(params->hard.name, &hard_port_id);
 509         rte_eth_dev_info_get(hard_port_id, &hard_info);
 510         hard_speed = eth_dev_speed_max_mbps(hard_info.speed_capa);
 511         numa_node = rte_eth_dev_socket_id(hard_port_id);
 512
 513         /* Ethdev entry allocation */
 514         soft_dev = rte_eth_dev_allocate(params->soft.name);
 515         if (!soft_dev)
 516                 return -ENOMEM;
 517
 518         /* dev */
 519         soft_dev->rx_pkt_burst = (params->soft.intrusive) ?
 520                 NULL : /* set up later */
 521                 pmd_rx_pkt_burst;
 522         soft_dev->tx_pkt_burst = pmd_tx_pkt_burst;
 523         soft_dev->tx_pkt_prepare = NULL;
 524         soft_dev->dev_ops = &pmd_ops;
 525         soft_dev->device = &vdev->device;
 526
 527         /* dev->data */
 528         soft_dev->data->dev_private = dev_private;
 529         soft_dev->data->dev_link.link_speed = hard_speed;
 530         soft_dev->data->dev_link.link_duplex = ETH_LINK_FULL_DUPLEX;
 531         soft_dev->data->dev_link.link_autoneg = ETH_LINK_FIXED;
 532         soft_dev->data->dev_link.link_status = ETH_LINK_DOWN;
 533         soft_dev->data->mac_addrs = &eth_addr;
 534         soft_dev->data->promiscuous = 1;
 535         soft_dev->data->kdrv = RTE_KDRV_NONE;
 536         soft_dev->data->numa_node = numa_node;
 537
 538         return 0;
 539 }
 540
 541 static int
 542 get_string(const char *key __rte_unused, const char *value, void *extra_args)
 543 {
 544         if (!value || !extra_args)
 545                 return -EINVAL;
 546
 547         *(char **)extra_args = strdup(value);
 548
 549         if (!*(char **)extra_args)
 550                 return -ENOMEM;
 551
 552         return 0;
 553 }
 554
 555 static int
 556 get_uint32(const char *key __rte_unused, const char *value, void *extra_args)
 557 {
 558         if (!value || !extra_args)
 559                 return -EINVAL;
 560
 561         *(uint32_t *)extra_args = strtoull(value, NULL, 0);
 562
 563         return 0;
 564 }
 565
 566 static int
 567 pmd_parse_args(struct pmd_params *p, const char *name, const char *params)
 568 {
 569         struct rte_kvargs *kvlist;
 570         int i, ret;
 571
 572         kvlist = rte_kvargs_parse(params, pmd_valid_args);
 573         if (kvlist == NULL)
 574                 return -EINVAL;
 575
 576         /* Set default values */
 577         memset(p, 0, sizeof(*p));
 578         p->soft.name = name;
 579         p->soft.intrusive = INTRUSIVE;
 580         p->soft.tm.rate = 0;
 581         p->soft.tm.nb_queues = SOFTNIC_SOFT_TM_NB_QUEUES;
 582         for (i = 0; i < RTE_SCHED_TRAFFIC_CLASSES_PER_PIPE; i++)
 583                 p->soft.tm.qsize[i] = SOFTNIC_SOFT_TM_QUEUE_SIZE;
 584         p->soft.tm.enq_bsz = SOFTNIC_SOFT_TM_ENQ_BSZ;
 585         p->soft.tm.deq_bsz = SOFTNIC_SOFT_TM_DEQ_BSZ;
 586         p->hard.tx_queue_id = SOFTNIC_HARD_TX_QUEUE_ID;
 587
 588         /* SOFT: TM (optional) */
 589         if (rte_kvargs_count(kvlist, PMD_PARAM_SOFT_TM) == 1) {
 590                 char *s;
 591
 592                 ret = rte_kvargs_process(kvlist, PMD_PARAM_SOFT_TM,
 593                         &get_string, &s);
 594                 if (ret < 0)
 595                         goto out_free;
 596
 597                 if (strcmp(s, "on") == 0)
 598                         p->soft.flags |= PMD_FEATURE_TM;
 599                 else if (strcmp(s, "off") == 0)
 600                         p->soft.flags &= ~PMD_FEATURE_TM;
 601                 else
 602                         ret = -EINVAL;
 603
 604                 free(s);
 605                 if (ret)
 606                         goto out_free;
 607         }
 608
 609         /* SOFT: TM rate (measured in bytes/second) (optional) */
 610         if (rte_kvargs_count(kvlist, PMD_PARAM_SOFT_TM_RATE) == 1) {
 611                 ret = rte_kvargs_process(kvlist, PMD_PARAM_SOFT_TM_RATE,
 612                         &get_uint32, &p->soft.tm.rate);
 613                 if (ret < 0)
 614                         goto out_free;
 615
 616                 p->soft.flags |= PMD_FEATURE_TM;
 617         }
 618
 619         /* SOFT: TM number of queues (optional) */
 620         if (rte_kvargs_count(kvlist, PMD_PARAM_SOFT_TM_NB_QUEUES) == 1) {
 621                 ret = rte_kvargs_process(kvlist, PMD_PARAM_SOFT_TM_NB_QUEUES,
 622                         &get_uint32, &p->soft.tm.nb_queues);
 623                 if (ret < 0)
 624                         goto out_free;
 625
 626                 p->soft.flags |= PMD_FEATURE_TM;
 627         }
 628
 629         /* SOFT: TM queue size 0 .. 3 (optional) */
 630         if (rte_kvargs_count(kvlist, PMD_PARAM_SOFT_TM_QSIZE0) == 1) {
 631                 uint32_t qsize;
 632
 633                 ret = rte_kvargs_process(kvlist, PMD_PARAM_SOFT_TM_QSIZE0,
 634                         &get_uint32, &qsize);
 635                 if (ret < 0)
 636                         goto out_free;
 637
 638                 p->soft.tm.qsize[0] = (uint16_t)qsize;
 639                 p->soft.flags |= PMD_FEATURE_TM;
 640         }
 641
 642         if (rte_kvargs_count(kvlist, PMD_PARAM_SOFT_TM_QSIZE1) == 1) {
 643                 uint32_t qsize;
 644
 645                 ret = rte_kvargs_process(kvlist, PMD_PARAM_SOFT_TM_QSIZE1,
 646                         &get_uint32, &qsize);
 647                 if (ret < 0)
 648                         goto out_free;
 649
 650                 p->soft.tm.qsize[1] = (uint16_t)qsize;
 651                 p->soft.flags |= PMD_FEATURE_TM;
 652         }
 653
 654         if (rte_kvargs_count(kvlist, PMD_PARAM_SOFT_TM_QSIZE2) == 1) {
 655                 uint32_t qsize;
 656
 657                 ret = rte_kvargs_process(kvlist, PMD_PARAM_SOFT_TM_QSIZE2,
 658                         &get_uint32, &qsize);
 659                 if (ret < 0)
 660                         goto out_free;
 661
 662                 p->soft.tm.qsize[2] = (uint16_t)qsize;
 663                 p->soft.flags |= PMD_FEATURE_TM;
 664         }
 665
 666         if (rte_kvargs_count(kvlist, PMD_PARAM_SOFT_TM_QSIZE3) == 1) {
 667                 uint32_t qsize;
 668
 669                 ret = rte_kvargs_process(kvlist, PMD_PARAM_SOFT_TM_QSIZE3,
 670                         &get_uint32, &qsize);
 671                 if (ret < 0)
 672                         goto out_free;
 673
 674                 p->soft.tm.qsize[3] = (uint16_t)qsize;
 675                 p->soft.flags |= PMD_FEATURE_TM;
 676         }
 677
 678         /* SOFT: TM enqueue burst size (optional) */
 679         if (rte_kvargs_count(kvlist, PMD_PARAM_SOFT_TM_ENQ_BSZ) == 1) {
 680                 ret = rte_kvargs_process(kvlist, PMD_PARAM_SOFT_TM_ENQ_BSZ,
 681                         &get_uint32, &p->soft.tm.enq_bsz);
 682                 if (ret < 0)
 683                         goto out_free;
 684
 685                 p->soft.flags |= PMD_FEATURE_TM;
 686         }
 687
 688         /* SOFT: TM dequeue burst size (optional) */
 689         if (rte_kvargs_count(kvlist, PMD_PARAM_SOFT_TM_DEQ_BSZ) == 1) {
 690                 ret = rte_kvargs_process(kvlist, PMD_PARAM_SOFT_TM_DEQ_BSZ,
 691                         &get_uint32, &p->soft.tm.deq_bsz);
 692                 if (ret < 0)
 693                         goto out_free;
 694
 695                 p->soft.flags |= PMD_FEATURE_TM;
 696         }
 697
 698         /* HARD: name (mandatory) */
 699         if (rte_kvargs_count(kvlist, PMD_PARAM_HARD_NAME) == 1) {
 700                 ret = rte_kvargs_process(kvlist, PMD_PARAM_HARD_NAME,
 701                         &get_string, &p->hard.name);
 702                 if (ret < 0)
 703                         goto out_free;
 704         } else {
 705                 ret = -EINVAL;
 706                 goto out_free;
 707         }
 708
 709         /* HARD: tx_queue_id (optional) */
 710         if (rte_kvargs_count(kvlist, PMD_PARAM_HARD_TX_QUEUE_ID) == 1) {
 711                 ret = rte_kvargs_process(kvlist, PMD_PARAM_HARD_TX_QUEUE_ID,
 712                         &get_uint32, &p->hard.tx_queue_id);
 713                 if (ret < 0)
 714                         goto out_free;
 715         }
 716
 717 out_free:
 718         rte_kvargs_free(kvlist);
 719         return ret;
 720 }
 721
 722 static int
 723 pmd_probe(struct rte_vdev_device *vdev)
 724 {
 725         struct pmd_params p;
 726         const char *params;
 727         int status;
 728
 729         struct rte_eth_dev_info hard_info;
 730         uint32_t hard_speed;
 731         uint16_t hard_port_id;
 732         int numa_node;
 733         void *dev_private;
 734         struct rte_eth_dev *eth_dev;
 735         const char *name = rte_vdev_device_name(vdev);
 736
 737         PMD_LOG(INFO, "Probing device \"%s\"", name);
 738
 739         /* Parse input arguments */
 740         params = rte_vdev_device_args(vdev);
 741
 742         if (rte_eal_process_type() == RTE_PROC_SECONDARY &&
 743             strlen(params) == 0) {
 744                 eth_dev = rte_eth_dev_attach_secondary(name);
 745                 if (!eth_dev) {
 746                         PMD_LOG(ERR, "Failed to probe %s", name);
 747                         return -1;
 748                 }
 749                 /* TODO: request info from primary to set up Rx and Tx */
 750                 eth_dev->dev_ops = &pmd_ops;
 751                 return 0;
 752         }
 753
 754         if (!params)
 755                 return -EINVAL;
 756
 757         status = pmd_parse_args(&p, rte_vdev_device_name(vdev), params);
 758         if (status)
 759                 return status;
 760
 761         /* Check input arguments */
 762         if (rte_eth_dev_get_port_by_name(p.hard.name, &hard_port_id))
 763                 return -EINVAL;
 764
 765         rte_eth_dev_info_get(hard_port_id, &hard_info);
 766         hard_speed = eth_dev_speed_max_mbps(hard_info.speed_capa);
 767         numa_node = rte_eth_dev_socket_id(hard_port_id);
 768
 769         if (p.hard.tx_queue_id >= hard_info.max_tx_queues)
 770                 return -EINVAL;
 771
 772         if (p.soft.flags & PMD_FEATURE_TM) {
 773                 status = tm_params_check(&p, hard_speed);
 774
 775                 if (status)
 776                         return status;
 777         }
 778
 779         /* Allocate and initialize soft ethdev private data */
 780         dev_private = pmd_init(&p, numa_node);
 781         if (dev_private == NULL)
 782                 return -ENOMEM;
 783
 784         /* Register soft ethdev */
 785         PMD_LOG(INFO,
 786                 "Creating soft ethdev \"%s\" for hard ethdev \"%s\"",
 787                 p.soft.name, p.hard.name);
 788
 789         status = pmd_ethdev_register(vdev, &p, dev_private);
 790         if (status) {
 791                 pmd_free(dev_private);
 792                 return status;
 793         }
 794
 795         return 0;
 796 }
 797
 798 static int
 799 pmd_remove(struct rte_vdev_device *vdev)
 800 {
 801         struct rte_eth_dev *dev = NULL;
 802         struct pmd_internals *p;
 803
 804         if (!vdev)
 805                 return -EINVAL;
 806
 807         PMD_LOG(INFO, "Removing device \"%s\"",
 808                 rte_vdev_device_name(vdev));
 809
 810         /* Find the ethdev entry */
 811         dev = rte_eth_dev_allocated(rte_vdev_device_name(vdev));
 812         if (dev == NULL)
 813                 return -ENODEV;
 814         p = dev->data->dev_private;
 815
 816         /* Free device data structures*/
 817         pmd_free(p);
 818         rte_free(dev->data);
 819         rte_eth_dev_release_port(dev);
 820
 821         return 0;
 822 }
 823
 824 static struct rte_vdev_driver pmd_softnic_drv = {
 825         .probe = pmd_probe,
 826         .remove = pmd_remove,
 827 };
 828
 829 RTE_PMD_REGISTER_VDEV(net_softnic, pmd_softnic_drv);
 830 RTE_PMD_REGISTER_PARAM_STRING(net_softnic,
 831         PMD_PARAM_SOFT_TM        "=on|off "
 832         PMD_PARAM_SOFT_TM_RATE "=<int> "
 833         PMD_PARAM_SOFT_TM_NB_QUEUES "=<int> "
 834         PMD_PARAM_SOFT_TM_QSIZE0 "=<int> "
 835         PMD_PARAM_SOFT_TM_QSIZE1 "=<int> "
 836         PMD_PARAM_SOFT_TM_QSIZE2 "=<int> "
 837         PMD_PARAM_SOFT_TM_QSIZE3 "=<int> "
 838         PMD_PARAM_SOFT_TM_ENQ_BSZ "=<int> "
 839         PMD_PARAM_SOFT_TM_DEQ_BSZ "=<int> "
 840         PMD_PARAM_HARD_NAME "=<string> "
 841         PMD_PARAM_HARD_TX_QUEUE_ID "=<int>");
 842
 843 RTE_INIT(pmd_softnic_init_log);
 844 static void
 845 pmd_softnic_init_log(void)
 846 {
 847         pmd_softnic_logtype = rte_log_register("pmd.net.softnic");
 848         if (pmd_softnic_logtype >= 0)
 849                 rte_log_set_level(pmd_softnic_logtype, RTE_LOG_NOTICE);
 850 }