drivers/net/kni/rte_eth_kni.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2017 Intel Corporation. All rights reserved.
   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 Intel Corporation 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 <fcntl.h>
  35 #include <pthread.h>
  36 #include <unistd.h>
  37
  38 #include <rte_ethdev.h>
  39 #include <rte_ethdev_vdev.h>
  40 #include <rte_kni.h>
  41 #include <rte_kvargs.h>
  42 #include <rte_malloc.h>
  43 #include <rte_vdev.h>
  44
  45 /* Only single queue supported */
  46 #define KNI_MAX_QUEUE_PER_PORT 1
  47
  48 #define MAX_PACKET_SZ 2048
  49 #define MAX_KNI_PORTS 8
  50
  51 #define ETH_KNI_NO_REQUEST_THREAD_ARG   "no_request_thread"
  52 static const char * const valid_arguments[] = {
  53         ETH_KNI_NO_REQUEST_THREAD_ARG,
  54         NULL
  55 };
  56
  57 struct eth_kni_args {
  58         int no_request_thread;
  59 };
  60
  61 struct pmd_queue_stats {
  62         uint64_t pkts;
  63         uint64_t bytes;
  64         uint64_t err_pkts;
  65 };
  66
  67 struct pmd_queue {
  68         struct pmd_internals *internals;
  69         struct rte_mempool *mb_pool;
  70
  71         struct pmd_queue_stats rx;
  72         struct pmd_queue_stats tx;
  73 };
  74
  75 struct pmd_internals {
  76         struct rte_kni *kni;
  77         int is_kni_started;
  78
  79         pthread_t thread;
  80         int stop_thread;
  81         int no_request_thread;
  82
  83         struct ether_addr eth_addr;
  84
  85         struct pmd_queue rx_queues[KNI_MAX_QUEUE_PER_PORT];
  86         struct pmd_queue tx_queues[KNI_MAX_QUEUE_PER_PORT];
  87 };
  88
  89 static const struct rte_eth_link pmd_link = {
  90                 .link_speed = ETH_SPEED_NUM_10G,
  91                 .link_duplex = ETH_LINK_FULL_DUPLEX,
  92                 .link_status = ETH_LINK_DOWN,
  93                 .link_autoneg = ETH_LINK_SPEED_AUTONEG,
  94 };
  95 static int is_kni_initialized;
  96
  97 static uint16_t
  98 eth_kni_rx(void *q, struct rte_mbuf **bufs, uint16_t nb_bufs)
  99 {
 100         struct pmd_queue *kni_q = q;
 101         struct rte_kni *kni = kni_q->internals->kni;
 102         uint16_t nb_pkts;
 103
 104         nb_pkts = rte_kni_rx_burst(kni, bufs, nb_bufs);
 105
 106         kni_q->rx.pkts += nb_pkts;
 107         kni_q->rx.err_pkts += nb_bufs - nb_pkts;
 108
 109         return nb_pkts;
 110 }
 111
 112 static uint16_t
 113 eth_kni_tx(void *q, struct rte_mbuf **bufs, uint16_t nb_bufs)
 114 {
 115         struct pmd_queue *kni_q = q;
 116         struct rte_kni *kni = kni_q->internals->kni;
 117         uint16_t nb_pkts;
 118
 119         nb_pkts =  rte_kni_tx_burst(kni, bufs, nb_bufs);
 120
 121         kni_q->tx.pkts += nb_pkts;
 122         kni_q->tx.err_pkts += nb_bufs - nb_pkts;
 123
 124         return nb_pkts;
 125 }
 126
 127 static void *
 128 kni_handle_request(void *param)
 129 {
 130         struct pmd_internals *internals = param;
 131 #define MS 1000
 132
 133         while (!internals->stop_thread) {
 134                 rte_kni_handle_request(internals->kni);
 135                 usleep(500 * MS);
 136         }
 137
 138         return param;
 139 }
 140
 141 static int
 142 eth_kni_start(struct rte_eth_dev *dev)
 143 {
 144         struct pmd_internals *internals = dev->data->dev_private;
 145         uint16_t port_id = dev->data->port_id;
 146         struct rte_mempool *mb_pool;
 147         struct rte_kni_conf conf;
 148         const char *name = dev->data->name + 4; /* remove net_ */
 149
 150         snprintf(conf.name, RTE_KNI_NAMESIZE, "%s", name);
 151         conf.force_bind = 0;
 152         conf.group_id = port_id;
 153         conf.mbuf_size = MAX_PACKET_SZ;
 154         mb_pool = internals->rx_queues[0].mb_pool;
 155
 156         internals->kni = rte_kni_alloc(mb_pool, &conf, NULL);
 157         if (internals->kni == NULL) {
 158                 RTE_LOG(ERR, PMD,
 159                         "Fail to create kni interface for port: %d\n",
 160                         port_id);
 161                 return -1;
 162         }
 163
 164         return 0;
 165 }
 166
 167 static int
 168 eth_kni_dev_start(struct rte_eth_dev *dev)
 169 {
 170         struct pmd_internals *internals = dev->data->dev_private;
 171         int ret;
 172
 173         if (internals->is_kni_started == 0) {
 174                 ret = eth_kni_start(dev);
 175                 if (ret)
 176                         return -1;
 177                 internals->is_kni_started = 1;
 178         }
 179
 180         if (internals->no_request_thread == 0) {
 181                 ret = pthread_create(&internals->thread, NULL,
 182                         kni_handle_request, internals);
 183                 if (ret) {
 184                         RTE_LOG(ERR, PMD,
 185                                 "Fail to create kni request thread\n");
 186                         return -1;
 187                 }
 188         }
 189
 190         dev->data->dev_link.link_status = 1;
 191
 192         return 0;
 193 }
 194
 195 static void
 196 eth_kni_dev_stop(struct rte_eth_dev *dev)
 197 {
 198         struct pmd_internals *internals = dev->data->dev_private;
 199         int ret;
 200
 201         if (internals->no_request_thread == 0) {
 202                 internals->stop_thread = 1;
 203
 204                 ret = pthread_cancel(internals->thread);
 205                 if (ret)
 206                         RTE_LOG(ERR, PMD, "Can't cancel the thread\n");
 207
 208                 ret = pthread_join(internals->thread, NULL);
 209                 if (ret)
 210                         RTE_LOG(ERR, PMD, "Can't join the thread\n");
 211
 212                 internals->stop_thread = 0;
 213         }
 214
 215         dev->data->dev_link.link_status = 0;
 216 }
 217
 218 static int
 219 eth_kni_dev_configure(struct rte_eth_dev *dev __rte_unused)
 220 {
 221         return 0;
 222 }
 223
 224 static void
 225 eth_kni_dev_info(struct rte_eth_dev *dev __rte_unused,
 226                 struct rte_eth_dev_info *dev_info)
 227 {
 228         dev_info->max_mac_addrs = 1;
 229         dev_info->max_rx_pktlen = UINT32_MAX;
 230         dev_info->max_rx_queues = KNI_MAX_QUEUE_PER_PORT;
 231         dev_info->max_tx_queues = KNI_MAX_QUEUE_PER_PORT;
 232         dev_info->min_rx_bufsize = 0;
 233         dev_info->pci_dev = NULL;
 234 }
 235
 236 static int
 237 eth_kni_rx_queue_setup(struct rte_eth_dev *dev,
 238                 uint16_t rx_queue_id,
 239                 uint16_t nb_rx_desc __rte_unused,
 240                 unsigned int socket_id __rte_unused,
 241                 const struct rte_eth_rxconf *rx_conf __rte_unused,
 242                 struct rte_mempool *mb_pool)
 243 {
 244         struct pmd_internals *internals = dev->data->dev_private;
 245         struct pmd_queue *q;
 246
 247         q = &internals->rx_queues[rx_queue_id];
 248         q->internals = internals;
 249         q->mb_pool = mb_pool;
 250
 251         dev->data->rx_queues[rx_queue_id] = q;
 252
 253         return 0;
 254 }
 255
 256 static int
 257 eth_kni_tx_queue_setup(struct rte_eth_dev *dev,
 258                 uint16_t tx_queue_id,
 259                 uint16_t nb_tx_desc __rte_unused,
 260                 unsigned int socket_id __rte_unused,
 261                 const struct rte_eth_txconf *tx_conf __rte_unused)
 262 {
 263         struct pmd_internals *internals = dev->data->dev_private;
 264         struct pmd_queue *q;
 265
 266         q = &internals->tx_queues[tx_queue_id];
 267         q->internals = internals;
 268
 269         dev->data->tx_queues[tx_queue_id] = q;
 270
 271         return 0;
 272 }
 273
 274 static void
 275 eth_kni_queue_release(void *q __rte_unused)
 276 {
 277 }
 278
 279 static int
 280 eth_kni_link_update(struct rte_eth_dev *dev __rte_unused,
 281                 int wait_to_complete __rte_unused)
 282 {
 283         return 0;
 284 }
 285
 286 static void
 287 eth_kni_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
 288 {
 289         unsigned long rx_packets_total = 0, rx_bytes_total = 0;
 290         unsigned long tx_packets_total = 0, tx_bytes_total = 0;
 291         struct rte_eth_dev_data *data = dev->data;
 292         unsigned long tx_packets_err_total = 0;
 293         unsigned int i, num_stats;
 294         struct pmd_queue *q;
 295
 296         num_stats = RTE_MIN((unsigned int)RTE_ETHDEV_QUEUE_STAT_CNTRS,
 297                         data->nb_rx_queues);
 298         for (i = 0; i < num_stats; i++) {
 299                 q = data->rx_queues[i];
 300                 stats->q_ipackets[i] = q->rx.pkts;
 301                 stats->q_ibytes[i] = q->rx.bytes;
 302                 rx_packets_total += stats->q_ipackets[i];
 303                 rx_bytes_total += stats->q_ibytes[i];
 304         }
 305
 306         num_stats = RTE_MIN((unsigned int)RTE_ETHDEV_QUEUE_STAT_CNTRS,
 307                         data->nb_tx_queues);
 308         for (i = 0; i < num_stats; i++) {
 309                 q = data->tx_queues[i];
 310                 stats->q_opackets[i] = q->tx.pkts;
 311                 stats->q_obytes[i] = q->tx.bytes;
 312                 stats->q_errors[i] = q->tx.err_pkts;
 313                 tx_packets_total += stats->q_opackets[i];
 314                 tx_bytes_total += stats->q_obytes[i];
 315                 tx_packets_err_total += stats->q_errors[i];
 316         }
 317
 318         stats->ipackets = rx_packets_total;
 319         stats->ibytes = rx_bytes_total;
 320         stats->opackets = tx_packets_total;
 321         stats->obytes = tx_bytes_total;
 322         stats->oerrors = tx_packets_err_total;
 323 }
 324
 325 static void
 326 eth_kni_stats_reset(struct rte_eth_dev *dev)
 327 {
 328         struct rte_eth_dev_data *data = dev->data;
 329         struct pmd_queue *q;
 330         unsigned int i;
 331
 332         for (i = 0; i < data->nb_rx_queues; i++) {
 333                 q = data->rx_queues[i];
 334                 q->rx.pkts = 0;
 335                 q->rx.bytes = 0;
 336         }
 337         for (i = 0; i < data->nb_tx_queues; i++) {
 338                 q = data->tx_queues[i];
 339                 q->tx.pkts = 0;
 340                 q->tx.bytes = 0;
 341                 q->tx.err_pkts = 0;
 342         }
 343 }
 344
 345 static const struct eth_dev_ops eth_kni_ops = {
 346         .dev_start = eth_kni_dev_start,
 347         .dev_stop = eth_kni_dev_stop,
 348         .dev_configure = eth_kni_dev_configure,
 349         .dev_infos_get = eth_kni_dev_info,
 350         .rx_queue_setup = eth_kni_rx_queue_setup,
 351         .tx_queue_setup = eth_kni_tx_queue_setup,
 352         .rx_queue_release = eth_kni_queue_release,
 353         .tx_queue_release = eth_kni_queue_release,
 354         .link_update = eth_kni_link_update,
 355         .stats_get = eth_kni_stats_get,
 356         .stats_reset = eth_kni_stats_reset,
 357 };
 358
 359 static struct rte_vdev_driver eth_kni_drv;
 360
 361 static struct rte_eth_dev *
 362 eth_kni_create(struct rte_vdev_device *vdev,
 363                 struct eth_kni_args *args,
 364                 unsigned int numa_node)
 365 {
 366         struct pmd_internals *internals;
 367         struct rte_eth_dev_data *data;
 368         struct rte_eth_dev *eth_dev;
 369         const char *name;
 370
 371         RTE_LOG(INFO, PMD, "Creating kni ethdev on numa socket %u\n",
 372                         numa_node);
 373
 374         name = rte_vdev_device_name(vdev);
 375         data = rte_zmalloc_socket(name, sizeof(*data), 0, numa_node);
 376         if (data == NULL)
 377                 return NULL;
 378
 379         /* reserve an ethdev entry */
 380         eth_dev = rte_eth_vdev_allocate(vdev, sizeof(*internals));
 381         if (eth_dev == NULL) {
 382                 rte_free(data);
 383                 return NULL;
 384         }
 385
 386         internals = eth_dev->data->dev_private;
 387         rte_memcpy(data, eth_dev->data, sizeof(*data));
 388         data->nb_rx_queues = 1;
 389         data->nb_tx_queues = 1;
 390         data->dev_link = pmd_link;
 391         data->mac_addrs = &internals->eth_addr;
 392
 393         eth_random_addr(internals->eth_addr.addr_bytes);
 394
 395         eth_dev->data = data;
 396         eth_dev->dev_ops = &eth_kni_ops;
 397
 398         data->dev_flags = RTE_ETH_DEV_DETACHABLE;
 399
 400         internals->no_request_thread = args->no_request_thread;
 401
 402         return eth_dev;
 403 }
 404
 405 static int
 406 kni_init(void)
 407 {
 408         if (is_kni_initialized == 0)
 409                 rte_kni_init(MAX_KNI_PORTS);
 410
 411         is_kni_initialized++;
 412
 413         return 0;
 414 }
 415
 416 static int
 417 eth_kni_kvargs_process(struct eth_kni_args *args, const char *params)
 418 {
 419         struct rte_kvargs *kvlist;
 420
 421         kvlist = rte_kvargs_parse(params, valid_arguments);
 422         if (kvlist == NULL)
 423                 return -1;
 424
 425         memset(args, 0, sizeof(struct eth_kni_args));
 426
 427         if (rte_kvargs_count(kvlist, ETH_KNI_NO_REQUEST_THREAD_ARG) == 1)
 428                 args->no_request_thread = 1;
 429
 430         rte_kvargs_free(kvlist);
 431
 432         return 0;
 433 }
 434
 435 static int
 436 eth_kni_probe(struct rte_vdev_device *vdev)
 437 {
 438         struct rte_eth_dev *eth_dev;
 439         struct eth_kni_args args;
 440         const char *name;
 441         const char *params;
 442         int ret;
 443
 444         name = rte_vdev_device_name(vdev);
 445         params = rte_vdev_device_args(vdev);
 446         RTE_LOG(INFO, PMD, "Initializing eth_kni for %s\n", name);
 447
 448         ret = eth_kni_kvargs_process(&args, params);
 449         if (ret < 0)
 450                 return ret;
 451
 452         ret = kni_init();
 453         if (ret < 0)
 454                 return ret;
 455
 456         eth_dev = eth_kni_create(vdev, &args, rte_socket_id());
 457         if (eth_dev == NULL)
 458                 goto kni_uninit;
 459
 460         eth_dev->rx_pkt_burst = eth_kni_rx;
 461         eth_dev->tx_pkt_burst = eth_kni_tx;
 462
 463         return 0;
 464
 465 kni_uninit:
 466         is_kni_initialized--;
 467         if (is_kni_initialized == 0)
 468                 rte_kni_close();
 469         return -1;
 470 }
 471
 472 static int
 473 eth_kni_remove(struct rte_vdev_device *vdev)
 474 {
 475         struct rte_eth_dev *eth_dev;
 476         struct pmd_internals *internals;
 477         const char *name;
 478
 479         name = rte_vdev_device_name(vdev);
 480         RTE_LOG(INFO, PMD, "Un-Initializing eth_kni for %s\n", name);
 481
 482         /* find the ethdev entry */
 483         eth_dev = rte_eth_dev_allocated(name);
 484         if (eth_dev == NULL)
 485                 return -1;
 486
 487         eth_kni_dev_stop(eth_dev);
 488
 489         if (eth_dev->data) {
 490                 internals = eth_dev->data->dev_private;
 491                 rte_kni_release(internals->kni);
 492
 493                 rte_free(internals);
 494         }
 495         rte_free(eth_dev->data);
 496
 497         rte_eth_dev_release_port(eth_dev);
 498
 499         is_kni_initialized--;
 500         if (is_kni_initialized == 0)
 501                 rte_kni_close();
 502
 503         return 0;
 504 }
 505
 506 static struct rte_vdev_driver eth_kni_drv = {
 507         .probe = eth_kni_probe,
 508         .remove = eth_kni_remove,
 509 };
 510
 511 RTE_PMD_REGISTER_VDEV(net_kni, eth_kni_drv);
 512 RTE_PMD_REGISTER_PARAM_STRING(net_kni, ETH_KNI_NO_REQUEST_THREAD_ARG "=<int>");