drivers/net/tap/rte_eth_tap.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2016 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 <rte_atomic.h>
  35 #include <rte_common.h>
  36 #include <rte_mbuf.h>
  37 #include <rte_ethdev.h>
  38 #include <rte_malloc.h>
  39 #include <rte_vdev.h>
  40 #include <rte_kvargs.h>
  41
  42 #include <sys/types.h>
  43 #include <sys/stat.h>
  44 #include <sys/socket.h>
  45 #include <sys/ioctl.h>
  46 #include <sys/mman.h>
  47 #include <errno.h>
  48 #include <signal.h>
  49 #include <stdint.h>
  50 #include <unistd.h>
  51 #include <arpa/inet.h>
  52 #include <linux/if.h>
  53 #include <linux/if_tun.h>
  54 #include <linux/if_ether.h>
  55 #include <fcntl.h>
  56
  57 /* Linux based path to the TUN device */
  58 #define TUN_TAP_DEV_PATH        "/dev/net/tun"
  59 #define DEFAULT_TAP_NAME        "dtap"
  60
  61 #define ETH_TAP_IFACE_ARG       "iface"
  62 #define ETH_TAP_SPEED_ARG       "speed"
  63
  64 #ifdef IFF_MULTI_QUEUE
  65 #define RTE_PMD_TAP_MAX_QUEUES  16
  66 #else
  67 #define RTE_PMD_TAP_MAX_QUEUES  1
  68 #endif
  69
  70 static struct rte_vdev_driver pmd_tap_drv;
  71
  72 static const char *valid_arguments[] = {
  73         ETH_TAP_IFACE_ARG,
  74         ETH_TAP_SPEED_ARG,
  75         NULL
  76 };
  77
  78 static int tap_unit;
  79
  80 static volatile uint32_t tap_trigger;   /* Rx trigger */
  81
  82 static struct rte_eth_link pmd_link = {
  83         .link_speed = ETH_SPEED_NUM_10G,
  84         .link_duplex = ETH_LINK_FULL_DUPLEX,
  85         .link_status = ETH_LINK_DOWN,
  86         .link_autoneg = ETH_LINK_SPEED_AUTONEG
  87 };
  88
  89 struct pkt_stats {
  90         uint64_t opackets;              /* Number of output packets */
  91         uint64_t ipackets;              /* Number of input packets */
  92         uint64_t obytes;                /* Number of bytes on output */
  93         uint64_t ibytes;                /* Number of bytes on input */
  94         uint64_t errs;                  /* Number of error packets */
  95 };
  96
  97 struct rx_queue {
  98         struct rte_mempool *mp;         /* Mempool for RX packets */
  99         uint32_t trigger_seen;          /* Last seen Rx trigger value */
 100         uint16_t in_port;               /* Port ID */
 101         int fd;
 102
 103         struct pkt_stats stats;         /* Stats for this RX queue */
 104 };
 105
 106 struct tx_queue {
 107         int fd;
 108         struct pkt_stats stats;         /* Stats for this TX queue */
 109 };
 110
 111 struct pmd_internals {
 112         char name[RTE_ETH_NAME_MAX_LEN];        /* Internal Tap device name */
 113         uint16_t nb_queues;             /* Number of queues supported */
 114         struct ether_addr eth_addr;     /* Mac address of the device port */
 115
 116         int if_index;                   /* IF_INDEX for the port */
 117         int ioctl_sock;                 /* socket for ioctl calls */
 118
 119         struct rx_queue rxq[RTE_PMD_TAP_MAX_QUEUES];    /* List of RX queues */
 120         struct tx_queue txq[RTE_PMD_TAP_MAX_QUEUES];    /* List of TX queues */
 121 };
 122
 123 static void
 124 tap_trigger_cb(int sig __rte_unused)
 125 {
 126         /* Valid trigger values are nonzero */
 127         tap_trigger = (tap_trigger + 1) | 0x80000000;
 128 }
 129
 130 static int
 131 tap_ioctl(struct pmd_internals *pmd, unsigned long request,
 132           struct ifreq *ifr, int set);
 133
 134 /* Tun/Tap allocation routine
 135  *
 136  * name is the number of the interface to use, unless NULL to take the host
 137  * supplied name.
 138  */
 139 static int
 140 tun_alloc(struct pmd_internals *pmd, uint16_t qid)
 141 {
 142         struct ifreq ifr;
 143 #ifdef IFF_MULTI_QUEUE
 144         unsigned int features;
 145 #endif
 146         int fd;
 147
 148         memset(&ifr, 0, sizeof(struct ifreq));
 149
 150         ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
 151         snprintf(ifr.ifr_name, IFNAMSIZ, "%s", pmd->name);
 152
 153         RTE_LOG(DEBUG, PMD, "ifr_name '%s'\n", ifr.ifr_name);
 154
 155         fd = open(TUN_TAP_DEV_PATH, O_RDWR);
 156         if (fd < 0) {
 157                 RTE_LOG(ERR, PMD, "Unable to create TAP interface");
 158                 goto error;
 159         }
 160
 161 #ifdef IFF_MULTI_QUEUE
 162         /* Grab the TUN features to verify we can work multi-queue */
 163         if (ioctl(fd, TUNGETFEATURES, &features) < 0) {
 164                 RTE_LOG(ERR, PMD, "TAP unable to get TUN/TAP features\n");
 165                 goto error;
 166         }
 167         RTE_LOG(DEBUG, PMD, "  TAP Features %08x\n", features);
 168
 169         if (features & IFF_MULTI_QUEUE) {
 170                 RTE_LOG(DEBUG, PMD, "  Multi-queue support for %d queues\n",
 171                         RTE_PMD_TAP_MAX_QUEUES);
 172                 ifr.ifr_flags |= IFF_MULTI_QUEUE;
 173         } else
 174 #endif
 175         {
 176                 ifr.ifr_flags |= IFF_ONE_QUEUE;
 177                 RTE_LOG(DEBUG, PMD, "  Single queue only support\n");
 178         }
 179
 180         /* Set the TUN/TAP configuration and set the name if needed */
 181         if (ioctl(fd, TUNSETIFF, (void *)&ifr) < 0) {
 182                 RTE_LOG(WARNING, PMD,
 183                         "Unable to set TUNSETIFF for %s\n",
 184                         ifr.ifr_name);
 185                 perror("TUNSETIFF");
 186                 goto error;
 187         }
 188
 189         /* Always set the file descriptor to non-blocking */
 190         if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
 191                 RTE_LOG(WARNING, PMD,
 192                         "Unable to set %s to nonblocking\n",
 193                         ifr.ifr_name);
 194                 perror("F_SETFL, NONBLOCK");
 195                 goto error;
 196         }
 197
 198         /* Set up trigger to optimize empty Rx bursts */
 199         errno = 0;
 200         do {
 201                 struct sigaction sa;
 202                 int flags = fcntl(fd, F_GETFL);
 203
 204                 if (flags == -1 || sigaction(SIGIO, NULL, &sa) == -1)
 205                         break;
 206                 if (sa.sa_handler != tap_trigger_cb) {
 207                         /*
 208                          * Make sure SIGIO is not already taken. This is done
 209                          * as late as possible to leave the application a
 210                          * chance to set up its own signal handler first.
 211                          */
 212                         if (sa.sa_handler != SIG_IGN &&
 213                             sa.sa_handler != SIG_DFL) {
 214                                 errno = EBUSY;
 215                                 break;
 216                         }
 217                         sa = (struct sigaction){
 218                                 .sa_flags = SA_RESTART,
 219                                 .sa_handler = tap_trigger_cb,
 220                         };
 221                         if (sigaction(SIGIO, &sa, NULL) == -1)
 222                                 break;
 223                 }
 224                 /* Enable SIGIO on file descriptor */
 225                 fcntl(fd, F_SETFL, flags | O_ASYNC);
 226                 fcntl(fd, F_SETOWN, getpid());
 227         } while (0);
 228         if (errno) {
 229                 /* Disable trigger globally in case of error */
 230                 tap_trigger = 0;
 231                 RTE_LOG(WARNING, PMD, "Rx trigger disabled: %s\n",
 232                         strerror(errno));
 233         }
 234
 235         if (qid == 0) {
 236                 struct ifreq ifr;
 237
 238                 if (tap_ioctl(pmd, SIOCGIFHWADDR, &ifr, 0) < 0)
 239                         goto error;
 240                 rte_memcpy(&pmd->eth_addr, ifr.ifr_hwaddr.sa_data,
 241                            ETHER_ADDR_LEN);
 242         }
 243
 244         return fd;
 245
 246 error:
 247         if (fd > 0)
 248                 close(fd);
 249         return -1;
 250 }
 251
 252 /* Callback to handle the rx burst of packets to the correct interface and
 253  * file descriptor(s) in a multi-queue setup.
 254  */
 255 static uint16_t
 256 pmd_rx_burst(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 257 {
 258         int len;
 259         struct rte_mbuf *mbuf;
 260         struct rx_queue *rxq = queue;
 261         uint16_t num_rx;
 262         unsigned long num_rx_bytes = 0;
 263         uint32_t trigger = tap_trigger;
 264
 265         if (trigger == rxq->trigger_seen)
 266                 return 0;
 267         if (trigger)
 268                 rxq->trigger_seen = trigger;
 269         rte_compiler_barrier();
 270         for (num_rx = 0; num_rx < nb_pkts; ) {
 271                 /* allocate the next mbuf */
 272                 mbuf = rte_pktmbuf_alloc(rxq->mp);
 273                 if (unlikely(!mbuf)) {
 274                         RTE_LOG(WARNING, PMD, "TAP unable to allocate mbuf\n");
 275                         break;
 276                 }
 277
 278                 len = read(rxq->fd, rte_pktmbuf_mtod(mbuf, char *),
 279                            rte_pktmbuf_tailroom(mbuf));
 280                 if (len <= 0) {
 281                         rte_pktmbuf_free(mbuf);
 282                         break;
 283                 }
 284
 285                 mbuf->data_len = len;
 286                 mbuf->pkt_len = len;
 287                 mbuf->port = rxq->in_port;
 288
 289                 /* account for the receive frame */
 290                 bufs[num_rx++] = mbuf;
 291                 num_rx_bytes += mbuf->pkt_len;
 292         }
 293         rxq->stats.ipackets += num_rx;
 294         rxq->stats.ibytes += num_rx_bytes;
 295
 296         return num_rx;
 297 }
 298
 299 /* Callback to handle sending packets from the tap interface
 300  */
 301 static uint16_t
 302 pmd_tx_burst(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 303 {
 304         struct rte_mbuf *mbuf;
 305         struct tx_queue *txq = queue;
 306         uint16_t num_tx = 0;
 307         unsigned long num_tx_bytes = 0;
 308         int i, n;
 309
 310         if (unlikely(nb_pkts == 0))
 311                 return 0;
 312
 313         for (i = 0; i < nb_pkts; i++) {
 314                 /* copy the tx frame data */
 315                 mbuf = bufs[num_tx];
 316                 n = write(txq->fd,
 317                           rte_pktmbuf_mtod(mbuf, void *),
 318                           rte_pktmbuf_pkt_len(mbuf));
 319                 if (n <= 0)
 320                         break;
 321
 322                 num_tx++;
 323                 num_tx_bytes += mbuf->pkt_len;
 324                 rte_pktmbuf_free(mbuf);
 325         }
 326
 327         txq->stats.opackets += num_tx;
 328         txq->stats.errs += nb_pkts - num_tx;
 329         txq->stats.obytes += num_tx_bytes;
 330
 331         return num_tx;
 332 }
 333
 334 static int
 335 tap_ioctl(struct pmd_internals *pmd, unsigned long request,
 336           struct ifreq *ifr, int set)
 337 {
 338         short req_flags = ifr->ifr_flags;
 339
 340         snprintf(ifr->ifr_name, IFNAMSIZ, "%s", pmd->name);
 341         switch (request) {
 342         case SIOCSIFFLAGS:
 343                 /* fetch current flags to leave other flags untouched */
 344                 if (ioctl(pmd->ioctl_sock, SIOCGIFFLAGS, ifr) < 0)
 345                         goto error;
 346                 if (set)
 347                         ifr->ifr_flags |= req_flags;
 348                 else
 349                         ifr->ifr_flags &= ~req_flags;
 350                 break;
 351         case SIOCGIFHWADDR:
 352         case SIOCSIFHWADDR:
 353         case SIOCSIFMTU:
 354                 break;
 355         default:
 356                 RTE_LOG(WARNING, PMD, "%s: ioctl() called with wrong arg\n",
 357                         pmd->name);
 358                 return -EINVAL;
 359         }
 360         if (ioctl(pmd->ioctl_sock, request, ifr) < 0)
 361                 goto error;
 362         return 0;
 363
 364 error:
 365         RTE_LOG(ERR, PMD, "%s: ioctl(%lu) failed with error: %s\n",
 366                 ifr->ifr_name, request, strerror(errno));
 367         return -errno;
 368 }
 369
 370 static int
 371 tap_link_set_down(struct rte_eth_dev *dev)
 372 {
 373         struct pmd_internals *pmd = dev->data->dev_private;
 374         struct ifreq ifr = { .ifr_flags = IFF_UP };
 375
 376         dev->data->dev_link.link_status = ETH_LINK_DOWN;
 377         return tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 0);
 378 }
 379
 380 static int
 381 tap_link_set_up(struct rte_eth_dev *dev)
 382 {
 383         struct pmd_internals *pmd = dev->data->dev_private;
 384         struct ifreq ifr = { .ifr_flags = IFF_UP };
 385
 386         dev->data->dev_link.link_status = ETH_LINK_UP;
 387         return tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 1);
 388 }
 389
 390 static int
 391 tap_dev_start(struct rte_eth_dev *dev)
 392 {
 393         return tap_link_set_up(dev);
 394 }
 395
 396 /* This function gets called when the current port gets stopped.
 397  */
 398 static void
 399 tap_dev_stop(struct rte_eth_dev *dev)
 400 {
 401         tap_link_set_down(dev);
 402 }
 403
 404 static int
 405 tap_dev_configure(struct rte_eth_dev *dev __rte_unused)
 406 {
 407         return 0;
 408 }
 409
 410 static uint32_t
 411 tap_dev_speed_capa(void)
 412 {
 413         uint32_t speed = pmd_link.link_speed;
 414         uint32_t capa = 0;
 415
 416         if (speed >= ETH_SPEED_NUM_10M)
 417                 capa |= ETH_LINK_SPEED_10M;
 418         if (speed >= ETH_SPEED_NUM_100M)
 419                 capa |= ETH_LINK_SPEED_100M;
 420         if (speed >= ETH_SPEED_NUM_1G)
 421                 capa |= ETH_LINK_SPEED_1G;
 422         if (speed >= ETH_SPEED_NUM_5G)
 423                 capa |= ETH_LINK_SPEED_2_5G;
 424         if (speed >= ETH_SPEED_NUM_5G)
 425                 capa |= ETH_LINK_SPEED_5G;
 426         if (speed >= ETH_SPEED_NUM_10G)
 427                 capa |= ETH_LINK_SPEED_10G;
 428         if (speed >= ETH_SPEED_NUM_20G)
 429                 capa |= ETH_LINK_SPEED_20G;
 430         if (speed >= ETH_SPEED_NUM_25G)
 431                 capa |= ETH_LINK_SPEED_25G;
 432         if (speed >= ETH_SPEED_NUM_40G)
 433                 capa |= ETH_LINK_SPEED_40G;
 434         if (speed >= ETH_SPEED_NUM_50G)
 435                 capa |= ETH_LINK_SPEED_50G;
 436         if (speed >= ETH_SPEED_NUM_56G)
 437                 capa |= ETH_LINK_SPEED_56G;
 438         if (speed >= ETH_SPEED_NUM_100G)
 439                 capa |= ETH_LINK_SPEED_100G;
 440
 441         return capa;
 442 }
 443
 444 static void
 445 tap_dev_info(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
 446 {
 447         struct pmd_internals *internals = dev->data->dev_private;
 448
 449         dev_info->if_index = internals->if_index;
 450         dev_info->max_mac_addrs = 1;
 451         dev_info->max_rx_pktlen = (uint32_t)ETHER_MAX_VLAN_FRAME_LEN;
 452         dev_info->max_rx_queues = internals->nb_queues;
 453         dev_info->max_tx_queues = internals->nb_queues;
 454         dev_info->min_rx_bufsize = 0;
 455         dev_info->pci_dev = NULL;
 456         dev_info->speed_capa = tap_dev_speed_capa();
 457 }
 458
 459 static void
 460 tap_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *tap_stats)
 461 {
 462         unsigned int i, imax;
 463         unsigned long rx_total = 0, tx_total = 0, tx_err_total = 0;
 464         unsigned long rx_bytes_total = 0, tx_bytes_total = 0;
 465         const struct pmd_internals *pmd = dev->data->dev_private;
 466
 467         imax = (pmd->nb_queues < RTE_ETHDEV_QUEUE_STAT_CNTRS) ?
 468                 pmd->nb_queues : RTE_ETHDEV_QUEUE_STAT_CNTRS;
 469
 470         for (i = 0; i < imax; i++) {
 471                 tap_stats->q_ipackets[i] = pmd->rxq[i].stats.ipackets;
 472                 tap_stats->q_ibytes[i] = pmd->rxq[i].stats.ibytes;
 473                 rx_total += tap_stats->q_ipackets[i];
 474                 rx_bytes_total += tap_stats->q_ibytes[i];
 475
 476                 tap_stats->q_opackets[i] = pmd->txq[i].stats.opackets;
 477                 tap_stats->q_errors[i] = pmd->txq[i].stats.errs;
 478                 tap_stats->q_obytes[i] = pmd->txq[i].stats.obytes;
 479                 tx_total += tap_stats->q_opackets[i];
 480                 tx_err_total += tap_stats->q_errors[i];
 481                 tx_bytes_total += tap_stats->q_obytes[i];
 482         }
 483
 484         tap_stats->ipackets = rx_total;
 485         tap_stats->ibytes = rx_bytes_total;
 486         tap_stats->opackets = tx_total;
 487         tap_stats->oerrors = tx_err_total;
 488         tap_stats->obytes = tx_bytes_total;
 489 }
 490
 491 static void
 492 tap_stats_reset(struct rte_eth_dev *dev)
 493 {
 494         int i;
 495         struct pmd_internals *pmd = dev->data->dev_private;
 496
 497         for (i = 0; i < pmd->nb_queues; i++) {
 498                 pmd->rxq[i].stats.ipackets = 0;
 499                 pmd->rxq[i].stats.ibytes = 0;
 500
 501                 pmd->txq[i].stats.opackets = 0;
 502                 pmd->txq[i].stats.errs = 0;
 503                 pmd->txq[i].stats.obytes = 0;
 504         }
 505 }
 506
 507 static void
 508 tap_dev_close(struct rte_eth_dev *dev __rte_unused)
 509 {
 510         int i;
 511         struct pmd_internals *internals = dev->data->dev_private;
 512
 513         tap_link_set_down(dev);
 514
 515         for (i = 0; i < internals->nb_queues; i++) {
 516                 if (internals->rxq[i].fd != -1)
 517                         close(internals->rxq[i].fd);
 518                 internals->rxq[i].fd = -1;
 519                 internals->txq[i].fd = -1;
 520         }
 521 }
 522
 523 static void
 524 tap_rx_queue_release(void *queue)
 525 {
 526         struct rx_queue *rxq = queue;
 527
 528         if (rxq && (rxq->fd > 0)) {
 529                 close(rxq->fd);
 530                 rxq->fd = -1;
 531         }
 532 }
 533
 534 static void
 535 tap_tx_queue_release(void *queue)
 536 {
 537         struct tx_queue *txq = queue;
 538
 539         if (txq && (txq->fd > 0)) {
 540                 close(txq->fd);
 541                 txq->fd = -1;
 542         }
 543 }
 544
 545 static int
 546 tap_link_update(struct rte_eth_dev *dev __rte_unused,
 547                 int wait_to_complete __rte_unused)
 548 {
 549         return 0;
 550 }
 551
 552 static void
 553 tap_promisc_enable(struct rte_eth_dev *dev)
 554 {
 555         struct pmd_internals *pmd = dev->data->dev_private;
 556         struct ifreq ifr = { .ifr_flags = IFF_PROMISC };
 557
 558         dev->data->promiscuous = 1;
 559         tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 1);
 560 }
 561
 562 static void
 563 tap_promisc_disable(struct rte_eth_dev *dev)
 564 {
 565         struct pmd_internals *pmd = dev->data->dev_private;
 566         struct ifreq ifr = { .ifr_flags = IFF_PROMISC };
 567
 568         dev->data->promiscuous = 0;
 569         tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 0);
 570 }
 571
 572 static void
 573 tap_allmulti_enable(struct rte_eth_dev *dev)
 574 {
 575         struct pmd_internals *pmd = dev->data->dev_private;
 576         struct ifreq ifr = { .ifr_flags = IFF_ALLMULTI };
 577
 578         dev->data->all_multicast = 1;
 579         tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 1);
 580 }
 581
 582 static void
 583 tap_allmulti_disable(struct rte_eth_dev *dev)
 584 {
 585         struct pmd_internals *pmd = dev->data->dev_private;
 586         struct ifreq ifr = { .ifr_flags = IFF_ALLMULTI };
 587
 588         dev->data->all_multicast = 0;
 589         tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 0);
 590 }
 591
 592
 593 static void
 594 tap_mac_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
 595 {
 596         struct pmd_internals *pmd = dev->data->dev_private;
 597         struct ifreq ifr;
 598
 599         if (is_zero_ether_addr(mac_addr)) {
 600                 RTE_LOG(ERR, PMD, "%s: can't set an empty MAC address\n",
 601                         dev->data->name);
 602                 return;
 603         }
 604
 605         ifr.ifr_hwaddr.sa_family = AF_LOCAL;
 606         rte_memcpy(ifr.ifr_hwaddr.sa_data, mac_addr, ETHER_ADDR_LEN);
 607         if (tap_ioctl(pmd, SIOCSIFHWADDR, &ifr, 1) < 0)
 608                 return;
 609         rte_memcpy(&pmd->eth_addr, mac_addr, ETHER_ADDR_LEN);
 610 }
 611
 612 static int
 613 tap_setup_queue(struct rte_eth_dev *dev,
 614                 struct pmd_internals *internals,
 615                 uint16_t qid)
 616 {
 617         struct pmd_internals *pmd = dev->data->dev_private;
 618         struct rx_queue *rx = &internals->rxq[qid];
 619         struct tx_queue *tx = &internals->txq[qid];
 620         int fd;
 621
 622         fd = rx->fd;
 623         if (fd < 0) {
 624                 fd = tx->fd;
 625                 if (fd < 0) {
 626                         RTE_LOG(INFO, PMD, "Add queue to TAP %s for qid %d\n",
 627                                 pmd->name, qid);
 628                         fd = tun_alloc(pmd, qid);
 629                         if (fd < 0) {
 630                                 RTE_LOG(ERR, PMD, "tun_alloc(%s, %d) failed\n",
 631                                         pmd->name, qid);
 632                                 return -1;
 633                         }
 634                         if (qid == 0) {
 635                                 struct ifreq ifr;
 636
 637                                 ifr.ifr_mtu = dev->data->mtu;
 638                                 if (tap_ioctl(pmd, SIOCSIFMTU, &ifr, 1) < 0) {
 639                                         close(fd);
 640                                         return -1;
 641                                 }
 642                         }
 643                 }
 644         }
 645
 646         rx->fd = fd;
 647         tx->fd = fd;
 648
 649         return fd;
 650 }
 651
 652 static int
 653 rx_setup_queue(struct rte_eth_dev *dev,
 654                 struct pmd_internals *internals,
 655                 uint16_t qid)
 656 {
 657         dev->data->rx_queues[qid] = &internals->rxq[qid];
 658
 659         return tap_setup_queue(dev, internals, qid);
 660 }
 661
 662 static int
 663 tx_setup_queue(struct rte_eth_dev *dev,
 664                 struct pmd_internals *internals,
 665                 uint16_t qid)
 666 {
 667         dev->data->tx_queues[qid] = &internals->txq[qid];
 668
 669         return tap_setup_queue(dev, internals, qid);
 670 }
 671
 672 static int
 673 tap_rx_queue_setup(struct rte_eth_dev *dev,
 674                    uint16_t rx_queue_id,
 675                    uint16_t nb_rx_desc __rte_unused,
 676                    unsigned int socket_id __rte_unused,
 677                    const struct rte_eth_rxconf *rx_conf __rte_unused,
 678                    struct rte_mempool *mp)
 679 {
 680         struct pmd_internals *internals = dev->data->dev_private;
 681         uint16_t buf_size;
 682         int fd;
 683
 684         if ((rx_queue_id >= internals->nb_queues) || !mp) {
 685                 RTE_LOG(WARNING, PMD,
 686                         "nb_queues %d too small or mempool NULL\n",
 687                         internals->nb_queues);
 688                 return -1;
 689         }
 690
 691         internals->rxq[rx_queue_id].mp = mp;
 692         internals->rxq[rx_queue_id].trigger_seen = 1; /* force initial burst */
 693         internals->rxq[rx_queue_id].in_port = dev->data->port_id;
 694
 695         /* Now get the space available for data in the mbuf */
 696         buf_size = (uint16_t)(rte_pktmbuf_data_room_size(mp) -
 697                                 RTE_PKTMBUF_HEADROOM);
 698
 699         if (buf_size < ETH_FRAME_LEN) {
 700                 RTE_LOG(WARNING, PMD,
 701                         "%s: %d bytes will not fit in mbuf (%d bytes)\n",
 702                         dev->data->name, ETH_FRAME_LEN, buf_size);
 703                 return -ENOMEM;
 704         }
 705
 706         fd = rx_setup_queue(dev, internals, rx_queue_id);
 707         if (fd == -1)
 708                 return -1;
 709
 710         RTE_LOG(DEBUG, PMD, "  RX TAP device name %s, qid %d on fd %d\n",
 711                 internals->name, rx_queue_id, internals->rxq[rx_queue_id].fd);
 712
 713         return 0;
 714 }
 715
 716 static int
 717 tap_tx_queue_setup(struct rte_eth_dev *dev,
 718                    uint16_t tx_queue_id,
 719                    uint16_t nb_tx_desc __rte_unused,
 720                    unsigned int socket_id __rte_unused,
 721                    const struct rte_eth_txconf *tx_conf __rte_unused)
 722 {
 723         struct pmd_internals *internals = dev->data->dev_private;
 724         int ret;
 725
 726         if (tx_queue_id >= internals->nb_queues)
 727                 return -1;
 728
 729         ret = tx_setup_queue(dev, internals, tx_queue_id);
 730         if (ret == -1)
 731                 return -1;
 732
 733         RTE_LOG(DEBUG, PMD, "  TX TAP device name %s, qid %d on fd %d\n",
 734                 internals->name, tx_queue_id, internals->txq[tx_queue_id].fd);
 735
 736         return 0;
 737 }
 738
 739 static int
 740 tap_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 741 {
 742         struct pmd_internals *pmd = dev->data->dev_private;
 743         struct ifreq ifr = { .ifr_mtu = mtu };
 744         int err = 0;
 745
 746         err = tap_ioctl(pmd, SIOCSIFMTU, &ifr, 1);
 747         if (!err)
 748                 dev->data->mtu = mtu;
 749
 750         return err;
 751 }
 752
 753 static int
 754 tap_set_mc_addr_list(struct rte_eth_dev *dev __rte_unused,
 755                      struct ether_addr *mc_addr_set __rte_unused,
 756                      uint32_t nb_mc_addr __rte_unused)
 757 {
 758         /*
 759          * Nothing to do actually: the tap has no filtering whatsoever, every
 760          * packet is received.
 761          */
 762         return 0;
 763 }
 764
 765 static const struct eth_dev_ops ops = {
 766         .dev_start              = tap_dev_start,
 767         .dev_stop               = tap_dev_stop,
 768         .dev_close              = tap_dev_close,
 769         .dev_configure          = tap_dev_configure,
 770         .dev_infos_get          = tap_dev_info,
 771         .rx_queue_setup         = tap_rx_queue_setup,
 772         .tx_queue_setup         = tap_tx_queue_setup,
 773         .rx_queue_release       = tap_rx_queue_release,
 774         .tx_queue_release       = tap_tx_queue_release,
 775         .link_update            = tap_link_update,
 776         .dev_set_link_up        = tap_link_set_up,
 777         .dev_set_link_down      = tap_link_set_down,
 778         .promiscuous_enable     = tap_promisc_enable,
 779         .promiscuous_disable    = tap_promisc_disable,
 780         .allmulticast_enable    = tap_allmulti_enable,
 781         .allmulticast_disable   = tap_allmulti_disable,
 782         .mac_addr_set           = tap_mac_set,
 783         .mtu_set                = tap_mtu_set,
 784         .set_mc_addr_list       = tap_set_mc_addr_list,
 785         .stats_get              = tap_stats_get,
 786         .stats_reset            = tap_stats_reset,
 787 };
 788
 789 static int
 790 eth_dev_tap_create(const char *name, char *tap_name)
 791 {
 792         int numa_node = rte_socket_id();
 793         struct rte_eth_dev *dev = NULL;
 794         struct pmd_internals *pmd = NULL;
 795         struct rte_eth_dev_data *data = NULL;
 796         int i;
 797
 798         RTE_LOG(DEBUG, PMD, "  TAP device on numa %u\n", rte_socket_id());
 799
 800         data = rte_zmalloc_socket(tap_name, sizeof(*data), 0, numa_node);
 801         if (!data) {
 802                 RTE_LOG(ERR, PMD, "TAP Failed to allocate data\n");
 803                 goto error_exit;
 804         }
 805
 806         pmd = rte_zmalloc_socket(tap_name, sizeof(*pmd), 0, numa_node);
 807         if (!pmd) {
 808                 RTE_LOG(ERR, PMD, "TAP Unable to allocate internal struct\n");
 809                 goto error_exit;
 810         }
 811
 812         /* name in allocation and data->name must be consistent */
 813         snprintf(data->name, sizeof(data->name), "%s", name);
 814         dev = rte_eth_dev_allocate(name);
 815         if (!dev) {
 816                 RTE_LOG(ERR, PMD, "TAP Unable to allocate device struct\n");
 817                 goto error_exit;
 818         }
 819
 820         snprintf(pmd->name, sizeof(pmd->name), "%s", tap_name);
 821
 822         pmd->nb_queues = RTE_PMD_TAP_MAX_QUEUES;
 823
 824         pmd->ioctl_sock = socket(AF_INET, SOCK_DGRAM, 0);
 825         if (pmd->ioctl_sock == -1) {
 826                 RTE_LOG(ERR, PMD,
 827                         "TAP Unable to get a socket for management: %s\n",
 828                         strerror(errno));
 829                 goto error_exit;
 830         }
 831
 832         /* Setup some default values */
 833         data->dev_private = pmd;
 834         data->port_id = dev->data->port_id;
 835         data->mtu = dev->data->mtu;
 836         data->dev_flags = RTE_ETH_DEV_DETACHABLE;
 837         data->kdrv = RTE_KDRV_NONE;
 838         data->drv_name = pmd_tap_drv.driver.name;
 839         data->numa_node = numa_node;
 840
 841         data->dev_link = pmd_link;
 842         data->mac_addrs = &pmd->eth_addr;
 843         data->nb_rx_queues = pmd->nb_queues;
 844         data->nb_tx_queues = pmd->nb_queues;
 845
 846         dev->data = data;
 847         dev->dev_ops = &ops;
 848         dev->driver = NULL;
 849         dev->rx_pkt_burst = pmd_rx_burst;
 850         dev->tx_pkt_burst = pmd_tx_burst;
 851
 852         /* Presetup the fds to -1 as being not valid */
 853         for (i = 0; i < RTE_PMD_TAP_MAX_QUEUES; i++) {
 854                 pmd->rxq[i].fd = -1;
 855                 pmd->txq[i].fd = -1;
 856         }
 857
 858         return 0;
 859
 860 error_exit:
 861         RTE_LOG(DEBUG, PMD, "TAP Unable to initialize %s\n", name);
 862
 863         rte_free(data);
 864         rte_free(pmd);
 865
 866         rte_eth_dev_release_port(dev);
 867
 868         return -EINVAL;
 869 }
 870
 871 static int
 872 set_interface_name(const char *key __rte_unused,
 873                    const char *value,
 874                    void *extra_args)
 875 {
 876         char *name = (char *)extra_args;
 877
 878         if (value)
 879                 snprintf(name, RTE_ETH_NAME_MAX_LEN - 1, "%s", value);
 880         else
 881                 snprintf(name, RTE_ETH_NAME_MAX_LEN - 1, "%s%d",
 882                          DEFAULT_TAP_NAME, (tap_unit - 1));
 883
 884         return 0;
 885 }
 886
 887 static int
 888 set_interface_speed(const char *key __rte_unused,
 889                     const char *value,
 890                     void *extra_args)
 891 {
 892         *(int *)extra_args = (value) ? atoi(value) : ETH_SPEED_NUM_10G;
 893
 894         return 0;
 895 }
 896
 897 /* Open a TAP interface device.
 898  */
 899 static int
 900 rte_pmd_tap_probe(const char *name, const char *params)
 901 {
 902         int ret;
 903         struct rte_kvargs *kvlist = NULL;
 904         int speed;
 905         char tap_name[RTE_ETH_NAME_MAX_LEN];
 906
 907         speed = ETH_SPEED_NUM_10G;
 908         snprintf(tap_name, sizeof(tap_name), "%s%d",
 909                  DEFAULT_TAP_NAME, tap_unit++);
 910
 911         if (params && (params[0] != '\0')) {
 912                 RTE_LOG(DEBUG, PMD, "paramaters (%s)\n", params);
 913
 914                 kvlist = rte_kvargs_parse(params, valid_arguments);
 915                 if (kvlist) {
 916                         if (rte_kvargs_count(kvlist, ETH_TAP_SPEED_ARG) == 1) {
 917                                 ret = rte_kvargs_process(kvlist,
 918                                                          ETH_TAP_SPEED_ARG,
 919                                                          &set_interface_speed,
 920                                                          &speed);
 921                                 if (ret == -1)
 922                                         goto leave;
 923                         }
 924
 925                         if (rte_kvargs_count(kvlist, ETH_TAP_IFACE_ARG) == 1) {
 926                                 ret = rte_kvargs_process(kvlist,
 927                                                          ETH_TAP_IFACE_ARG,
 928                                                          &set_interface_name,
 929                                                          tap_name);
 930                                 if (ret == -1)
 931                                         goto leave;
 932                         }
 933                 }
 934         }
 935         pmd_link.link_speed = speed;
 936
 937         RTE_LOG(NOTICE, PMD, "Initializing pmd_tap for %s as %s\n",
 938                 name, tap_name);
 939
 940         ret = eth_dev_tap_create(name, tap_name);
 941
 942 leave:
 943         if (ret == -1) {
 944                 RTE_LOG(ERR, PMD, "Failed to create pmd for %s as %s\n",
 945                         name, tap_name);
 946                 tap_unit--;             /* Restore the unit number */
 947         }
 948         rte_kvargs_free(kvlist);
 949
 950         return ret;
 951 }
 952
 953 /* detach a TAP device.
 954  */
 955 static int
 956 rte_pmd_tap_remove(const char *name)
 957 {
 958         struct rte_eth_dev *eth_dev = NULL;
 959         struct pmd_internals *internals;
 960         int i;
 961
 962         RTE_LOG(DEBUG, PMD, "Closing TUN/TAP Ethernet device on numa %u\n",
 963                 rte_socket_id());
 964
 965         /* find the ethdev entry */
 966         eth_dev = rte_eth_dev_allocated(name);
 967         if (!eth_dev)
 968                 return 0;
 969
 970         internals = eth_dev->data->dev_private;
 971         for (i = 0; i < internals->nb_queues; i++)
 972                 if (internals->rxq[i].fd != -1)
 973                         close(internals->rxq[i].fd);
 974
 975         close(internals->ioctl_sock);
 976         rte_free(eth_dev->data->dev_private);
 977         rte_free(eth_dev->data);
 978
 979         rte_eth_dev_release_port(eth_dev);
 980
 981         return 0;
 982 }
 983
 984 static struct rte_vdev_driver pmd_tap_drv = {
 985         .probe = rte_pmd_tap_probe,
 986         .remove = rte_pmd_tap_remove,
 987 };
 988 RTE_PMD_REGISTER_VDEV(net_tap, pmd_tap_drv);
 989 RTE_PMD_REGISTER_ALIAS(net_tap, eth_tap);
 990 RTE_PMD_REGISTER_PARAM_STRING(net_tap, "iface=<string>,speed=N");