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_branch_prediction.h>
  36 #include <rte_common.h>
  37 #include <rte_mbuf.h>
  38 #include <rte_ethdev.h>
  39 #include <rte_malloc.h>
  40 #include <rte_vdev.h>
  41 #include <rte_kvargs.h>
  42 #include <rte_net.h>
  43
  44 #include <sys/types.h>
  45 #include <sys/stat.h>
  46 #include <sys/socket.h>
  47 #include <sys/ioctl.h>
  48 #include <sys/utsname.h>
  49 #include <sys/mman.h>
  50 #include <errno.h>
  51 #include <signal.h>
  52 #include <stdint.h>
  53 #include <sys/uio.h>
  54 #include <unistd.h>
  55 #include <arpa/inet.h>
  56 #include <net/if.h>
  57 #include <linux/if_tun.h>
  58 #include <linux/if_ether.h>
  59 #include <linux/version.h>
  60 #include <fcntl.h>
  61
  62 #include <rte_eth_tap.h>
  63 #include <tap_flow.h>
  64 #include <tap_netlink.h>
  65 #include <tap_tcmsgs.h>
  66
  67 /* Linux based path to the TUN device */
  68 #define TUN_TAP_DEV_PATH        "/dev/net/tun"
  69 #define DEFAULT_TAP_NAME        "dtap"
  70
  71 #define ETH_TAP_IFACE_ARG       "iface"
  72 #define ETH_TAP_SPEED_ARG       "speed"
  73 #define ETH_TAP_REMOTE_ARG      "remote"
  74
  75 #ifdef IFF_MULTI_QUEUE
  76 #define RTE_PMD_TAP_MAX_QUEUES  16
  77 #else
  78 #define RTE_PMD_TAP_MAX_QUEUES  1
  79 #endif
  80
  81 #define FLOWER_KERNEL_VERSION KERNEL_VERSION(4, 2, 0)
  82 #define FLOWER_VLAN_KERNEL_VERSION KERNEL_VERSION(4, 9, 0)
  83
  84 static struct rte_vdev_driver pmd_tap_drv;
  85
  86 static const char *valid_arguments[] = {
  87         ETH_TAP_IFACE_ARG,
  88         ETH_TAP_SPEED_ARG,
  89         ETH_TAP_REMOTE_ARG,
  90         NULL
  91 };
  92
  93 static int tap_unit;
  94
  95 static volatile uint32_t tap_trigger;   /* Rx trigger */
  96
  97 static struct rte_eth_link pmd_link = {
  98         .link_speed = ETH_SPEED_NUM_10G,
  99         .link_duplex = ETH_LINK_FULL_DUPLEX,
 100         .link_status = ETH_LINK_DOWN,
 101         .link_autoneg = ETH_LINK_SPEED_AUTONEG
 102 };
 103
 104 static void
 105 tap_trigger_cb(int sig __rte_unused)
 106 {
 107         /* Valid trigger values are nonzero */
 108         tap_trigger = (tap_trigger + 1) | 0x80000000;
 109 }
 110
 111 /* Specifies on what netdevices the ioctl should be applied */
 112 enum ioctl_mode {
 113         LOCAL_AND_REMOTE,
 114         LOCAL_ONLY,
 115         REMOTE_ONLY,
 116 };
 117
 118 static int
 119 tap_ioctl(struct pmd_internals *pmd, unsigned long request,
 120           struct ifreq *ifr, int set, enum ioctl_mode mode);
 121
 122 static int tap_intr_handle_set(struct rte_eth_dev *dev, int set);
 123
 124 /* Tun/Tap allocation routine
 125  *
 126  * name is the number of the interface to use, unless NULL to take the host
 127  * supplied name.
 128  */
 129 static int
 130 tun_alloc(struct pmd_internals *pmd, uint16_t qid)
 131 {
 132         struct ifreq ifr;
 133 #ifdef IFF_MULTI_QUEUE
 134         unsigned int features;
 135 #endif
 136         int fd;
 137
 138         memset(&ifr, 0, sizeof(struct ifreq));
 139
 140         /*
 141          * Do not set IFF_NO_PI as packet information header will be needed
 142          * to check if a received packet has been truncated.
 143          */
 144         ifr.ifr_flags = IFF_TAP;
 145         snprintf(ifr.ifr_name, IFNAMSIZ, "%s", pmd->name);
 146
 147         RTE_LOG(DEBUG, PMD, "ifr_name '%s'\n", ifr.ifr_name);
 148
 149         fd = open(TUN_TAP_DEV_PATH, O_RDWR);
 150         if (fd < 0) {
 151                 RTE_LOG(ERR, PMD, "Unable to create TAP interface");
 152                 goto error;
 153         }
 154
 155 #ifdef IFF_MULTI_QUEUE
 156         /* Grab the TUN features to verify we can work multi-queue */
 157         if (ioctl(fd, TUNGETFEATURES, &features) < 0) {
 158                 RTE_LOG(ERR, PMD, "TAP unable to get TUN/TAP features\n");
 159                 goto error;
 160         }
 161         RTE_LOG(DEBUG, PMD, "  TAP Features %08x\n", features);
 162
 163         if (features & IFF_MULTI_QUEUE) {
 164                 RTE_LOG(DEBUG, PMD, "  Multi-queue support for %d queues\n",
 165                         RTE_PMD_TAP_MAX_QUEUES);
 166                 ifr.ifr_flags |= IFF_MULTI_QUEUE;
 167         } else
 168 #endif
 169         {
 170                 ifr.ifr_flags |= IFF_ONE_QUEUE;
 171                 RTE_LOG(DEBUG, PMD, "  Single queue only support\n");
 172         }
 173
 174         /* Set the TUN/TAP configuration and set the name if needed */
 175         if (ioctl(fd, TUNSETIFF, (void *)&ifr) < 0) {
 176                 RTE_LOG(WARNING, PMD,
 177                         "Unable to set TUNSETIFF for %s\n",
 178                         ifr.ifr_name);
 179                 perror("TUNSETIFF");
 180                 goto error;
 181         }
 182
 183         /* Always set the file descriptor to non-blocking */
 184         if (fcntl(fd, F_SETFL, O_NONBLOCK) < 0) {
 185                 RTE_LOG(WARNING, PMD,
 186                         "Unable to set %s to nonblocking\n",
 187                         ifr.ifr_name);
 188                 perror("F_SETFL, NONBLOCK");
 189                 goto error;
 190         }
 191
 192         /* Set up trigger to optimize empty Rx bursts */
 193         errno = 0;
 194         do {
 195                 struct sigaction sa;
 196                 int flags = fcntl(fd, F_GETFL);
 197
 198                 if (flags == -1 || sigaction(SIGIO, NULL, &sa) == -1)
 199                         break;
 200                 if (sa.sa_handler != tap_trigger_cb) {
 201                         /*
 202                          * Make sure SIGIO is not already taken. This is done
 203                          * as late as possible to leave the application a
 204                          * chance to set up its own signal handler first.
 205                          */
 206                         if (sa.sa_handler != SIG_IGN &&
 207                             sa.sa_handler != SIG_DFL) {
 208                                 errno = EBUSY;
 209                                 break;
 210                         }
 211                         sa = (struct sigaction){
 212                                 .sa_flags = SA_RESTART,
 213                                 .sa_handler = tap_trigger_cb,
 214                         };
 215                         if (sigaction(SIGIO, &sa, NULL) == -1)
 216                                 break;
 217                 }
 218                 /* Enable SIGIO on file descriptor */
 219                 fcntl(fd, F_SETFL, flags | O_ASYNC);
 220                 fcntl(fd, F_SETOWN, getpid());
 221         } while (0);
 222         if (errno) {
 223                 /* Disable trigger globally in case of error */
 224                 tap_trigger = 0;
 225                 RTE_LOG(WARNING, PMD, "Rx trigger disabled: %s\n",
 226                         strerror(errno));
 227         }
 228
 229         if (qid == 0) {
 230                 struct ifreq ifr;
 231
 232                 /*
 233                  * pmd->eth_addr contains the desired MAC, either from remote
 234                  * or from a random assignment. Sync it with the tap netdevice.
 235                  */
 236                 ifr.ifr_hwaddr.sa_family = AF_LOCAL;
 237                 rte_memcpy(ifr.ifr_hwaddr.sa_data, &pmd->eth_addr,
 238                            ETHER_ADDR_LEN);
 239                 if (tap_ioctl(pmd, SIOCSIFHWADDR, &ifr, 0, LOCAL_ONLY) < 0)
 240                         goto error;
 241
 242                 pmd->if_index = if_nametoindex(pmd->name);
 243                 if (!pmd->if_index) {
 244                         RTE_LOG(ERR, PMD,
 245                                 "Could not find ifindex for %s: rte_flow won't be usable.\n",
 246                                 pmd->name);
 247                         return fd;
 248                 }
 249                 if (!pmd->flower_support)
 250                         return fd;
 251                 if (qdisc_create_multiq(pmd->nlsk_fd, pmd->if_index) < 0) {
 252                         RTE_LOG(ERR, PMD,
 253                                 "Could not create multiq qdisc for %s: rte_flow won't be usable.\n",
 254                                 pmd->name);
 255                         return fd;
 256                 }
 257                 if (qdisc_create_ingress(pmd->nlsk_fd, pmd->if_index) < 0) {
 258                         RTE_LOG(ERR, PMD,
 259                                 "Could not create multiq qdisc for %s: rte_flow won't be usable.\n",
 260                                 pmd->name);
 261                         return fd;
 262                 }
 263                 if (pmd->remote_if_index) {
 264                         /*
 265                          * Flush usually returns negative value because it tries
 266                          * to delete every QDISC (and on a running device, one
 267                          * QDISC at least is needed). Ignore negative return
 268                          * value.
 269                          */
 270                         qdisc_flush(pmd->nlsk_fd, pmd->remote_if_index);
 271                         if (qdisc_create_ingress(pmd->nlsk_fd,
 272                                                  pmd->remote_if_index) < 0)
 273                                 goto remote_fail;
 274                         LIST_INIT(&pmd->implicit_flows);
 275                         if (tap_flow_implicit_create(
 276                                     pmd, TAP_REMOTE_LOCAL_MAC) < 0)
 277                                 goto remote_fail;
 278                         if (tap_flow_implicit_create(
 279                                     pmd, TAP_REMOTE_BROADCAST) < 0)
 280                                 goto remote_fail;
 281                         if (tap_flow_implicit_create(
 282                                     pmd, TAP_REMOTE_BROADCASTV6) < 0)
 283                                 goto remote_fail;
 284                         if (tap_flow_implicit_create(
 285                                     pmd, TAP_REMOTE_TX) < 0)
 286                                 goto remote_fail;
 287                 }
 288         }
 289
 290         return fd;
 291
 292 remote_fail:
 293         RTE_LOG(ERR, PMD,
 294                 "Could not set up remote flow rules for %s: remote disabled.\n",
 295                 pmd->name);
 296         pmd->remote_if_index = 0;
 297         tap_flow_implicit_flush(pmd, NULL);
 298         return fd;
 299
 300 error:
 301         if (fd > 0)
 302                 close(fd);
 303         return -1;
 304 }
 305
 306 /* Callback to handle the rx burst of packets to the correct interface and
 307  * file descriptor(s) in a multi-queue setup.
 308  */
 309 static uint16_t
 310 pmd_rx_burst(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 311 {
 312         struct rx_queue *rxq = queue;
 313         uint16_t num_rx;
 314         unsigned long num_rx_bytes = 0;
 315         uint32_t trigger = tap_trigger;
 316
 317         if (trigger == rxq->trigger_seen)
 318                 return 0;
 319         if (trigger)
 320                 rxq->trigger_seen = trigger;
 321         rte_compiler_barrier();
 322         for (num_rx = 0; num_rx < nb_pkts; ) {
 323                 struct rte_mbuf *mbuf = rxq->pool;
 324                 struct rte_mbuf *seg = NULL;
 325                 struct rte_mbuf *new_tail = NULL;
 326                 uint16_t data_off = rte_pktmbuf_headroom(mbuf);
 327                 int len;
 328
 329                 len = readv(rxq->fd, *rxq->iovecs,
 330                             1 + (rxq->rxmode->enable_scatter ?
 331                                  rxq->nb_rx_desc : 1));
 332                 if (len < (int)sizeof(struct tun_pi))
 333                         break;
 334
 335                 /* Packet couldn't fit in the provided mbuf */
 336                 if (unlikely(rxq->pi.flags & TUN_PKT_STRIP)) {
 337                         rxq->stats.ierrors++;
 338                         continue;
 339                 }
 340
 341                 len -= sizeof(struct tun_pi);
 342
 343                 mbuf->pkt_len = len;
 344                 mbuf->port = rxq->in_port;
 345                 while (1) {
 346                         struct rte_mbuf *buf = rte_pktmbuf_alloc(rxq->mp);
 347
 348                         if (unlikely(!buf)) {
 349                                 rxq->stats.rx_nombuf++;
 350                                 /* No new buf has been allocated: do nothing */
 351                                 if (!new_tail || !seg)
 352                                         goto end;
 353
 354                                 seg->next = NULL;
 355                                 rte_pktmbuf_free(mbuf);
 356
 357                                 goto end;
 358                         }
 359                         seg = seg ? seg->next : mbuf;
 360                         if (rxq->pool == mbuf)
 361                                 rxq->pool = buf;
 362                         if (new_tail)
 363                                 new_tail->next = buf;
 364                         new_tail = buf;
 365                         new_tail->next = seg->next;
 366
 367                         /* iovecs[0] is reserved for packet info (pi) */
 368                         (*rxq->iovecs)[mbuf->nb_segs].iov_len =
 369                                 buf->buf_len - data_off;
 370                         (*rxq->iovecs)[mbuf->nb_segs].iov_base =
 371                                 (char *)buf->buf_addr + data_off;
 372
 373                         seg->data_len = RTE_MIN(seg->buf_len - data_off, len);
 374                         seg->data_off = data_off;
 375
 376                         len -= seg->data_len;
 377                         if (len <= 0)
 378                                 break;
 379                         mbuf->nb_segs++;
 380                         /* First segment has headroom, not the others */
 381                         data_off = 0;
 382                 }
 383                 seg->next = NULL;
 384                 mbuf->packet_type = rte_net_get_ptype(mbuf, NULL,
 385                                                       RTE_PTYPE_ALL_MASK);
 386
 387                 /* account for the receive frame */
 388                 bufs[num_rx++] = mbuf;
 389                 num_rx_bytes += mbuf->pkt_len;
 390         }
 391 end:
 392         rxq->stats.ipackets += num_rx;
 393         rxq->stats.ibytes += num_rx_bytes;
 394
 395         return num_rx;
 396 }
 397
 398 /* Callback to handle sending packets from the tap interface
 399  */
 400 static uint16_t
 401 pmd_tx_burst(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 402 {
 403         struct tx_queue *txq = queue;
 404         uint16_t num_tx = 0;
 405         unsigned long num_tx_bytes = 0;
 406         uint32_t max_size;
 407         int i;
 408
 409         if (unlikely(nb_pkts == 0))
 410                 return 0;
 411
 412         max_size = *txq->mtu + (ETHER_HDR_LEN + ETHER_CRC_LEN + 4);
 413         for (i = 0; i < nb_pkts; i++) {
 414                 struct rte_mbuf *mbuf = bufs[num_tx];
 415                 struct iovec iovecs[mbuf->nb_segs + 1];
 416                 struct tun_pi pi = { .flags = 0 };
 417                 struct rte_mbuf *seg = mbuf;
 418                 int n;
 419                 int j;
 420
 421                 /* stats.errs will be incremented */
 422                 if (rte_pktmbuf_pkt_len(mbuf) > max_size)
 423                         break;
 424
 425                 iovecs[0].iov_base = &pi;
 426                 iovecs[0].iov_len = sizeof(pi);
 427                 for (j = 1; j <= mbuf->nb_segs; j++) {
 428                         iovecs[j].iov_len = rte_pktmbuf_data_len(seg);
 429                         iovecs[j].iov_base =
 430                                 rte_pktmbuf_mtod(seg, void *);
 431                         seg = seg->next;
 432                 }
 433                 /* copy the tx frame data */
 434                 n = writev(txq->fd, iovecs, mbuf->nb_segs + 1);
 435                 if (n <= 0)
 436                         break;
 437
 438                 num_tx++;
 439                 num_tx_bytes += mbuf->pkt_len;
 440                 rte_pktmbuf_free(mbuf);
 441         }
 442
 443         txq->stats.opackets += num_tx;
 444         txq->stats.errs += nb_pkts - num_tx;
 445         txq->stats.obytes += num_tx_bytes;
 446
 447         return num_tx;
 448 }
 449
 450 static int
 451 tap_ioctl(struct pmd_internals *pmd, unsigned long request,
 452           struct ifreq *ifr, int set, enum ioctl_mode mode)
 453 {
 454         short req_flags = ifr->ifr_flags;
 455         int remote = pmd->remote_if_index &&
 456                 (mode == REMOTE_ONLY || mode == LOCAL_AND_REMOTE);
 457
 458         if (!pmd->remote_if_index && mode == REMOTE_ONLY)
 459                 return 0;
 460         /*
 461          * If there is a remote netdevice, apply ioctl on it, then apply it on
 462          * the tap netdevice.
 463          */
 464 apply:
 465         if (remote)
 466                 snprintf(ifr->ifr_name, IFNAMSIZ, "%s", pmd->remote_iface);
 467         else if (mode == LOCAL_ONLY || mode == LOCAL_AND_REMOTE)
 468                 snprintf(ifr->ifr_name, IFNAMSIZ, "%s", pmd->name);
 469         switch (request) {
 470         case SIOCSIFFLAGS:
 471                 /* fetch current flags to leave other flags untouched */
 472                 if (ioctl(pmd->ioctl_sock, SIOCGIFFLAGS, ifr) < 0)
 473                         goto error;
 474                 if (set)
 475                         ifr->ifr_flags |= req_flags;
 476                 else
 477                         ifr->ifr_flags &= ~req_flags;
 478                 break;
 479         case SIOCGIFFLAGS:
 480         case SIOCGIFHWADDR:
 481         case SIOCSIFHWADDR:
 482         case SIOCSIFMTU:
 483                 break;
 484         default:
 485                 RTE_LOG(WARNING, PMD, "%s: ioctl() called with wrong arg\n",
 486                         pmd->name);
 487                 return -EINVAL;
 488         }
 489         if (ioctl(pmd->ioctl_sock, request, ifr) < 0)
 490                 goto error;
 491         if (remote-- && mode == LOCAL_AND_REMOTE)
 492                 goto apply;
 493         return 0;
 494
 495 error:
 496         RTE_LOG(ERR, PMD, "%s: ioctl(%lu) failed with error: %s\n",
 497                 ifr->ifr_name, request, strerror(errno));
 498         return -errno;
 499 }
 500
 501 static int
 502 tap_link_set_down(struct rte_eth_dev *dev)
 503 {
 504         struct pmd_internals *pmd = dev->data->dev_private;
 505         struct ifreq ifr = { .ifr_flags = IFF_UP };
 506
 507         dev->data->dev_link.link_status = ETH_LINK_DOWN;
 508         return tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 0, LOCAL_AND_REMOTE);
 509 }
 510
 511 static int
 512 tap_link_set_up(struct rte_eth_dev *dev)
 513 {
 514         struct pmd_internals *pmd = dev->data->dev_private;
 515         struct ifreq ifr = { .ifr_flags = IFF_UP };
 516
 517         dev->data->dev_link.link_status = ETH_LINK_UP;
 518         return tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 1, LOCAL_AND_REMOTE);
 519 }
 520
 521 static int
 522 tap_dev_start(struct rte_eth_dev *dev)
 523 {
 524         int err;
 525
 526         err = tap_intr_handle_set(dev, 1);
 527         if (err)
 528                 return err;
 529         return tap_link_set_up(dev);
 530 }
 531
 532 /* This function gets called when the current port gets stopped.
 533  */
 534 static void
 535 tap_dev_stop(struct rte_eth_dev *dev)
 536 {
 537         tap_intr_handle_set(dev, 0);
 538         tap_link_set_down(dev);
 539 }
 540
 541 static int
 542 tap_dev_configure(struct rte_eth_dev *dev __rte_unused)
 543 {
 544         return 0;
 545 }
 546
 547 static uint32_t
 548 tap_dev_speed_capa(void)
 549 {
 550         uint32_t speed = pmd_link.link_speed;
 551         uint32_t capa = 0;
 552
 553         if (speed >= ETH_SPEED_NUM_10M)
 554                 capa |= ETH_LINK_SPEED_10M;
 555         if (speed >= ETH_SPEED_NUM_100M)
 556                 capa |= ETH_LINK_SPEED_100M;
 557         if (speed >= ETH_SPEED_NUM_1G)
 558                 capa |= ETH_LINK_SPEED_1G;
 559         if (speed >= ETH_SPEED_NUM_5G)
 560                 capa |= ETH_LINK_SPEED_2_5G;
 561         if (speed >= ETH_SPEED_NUM_5G)
 562                 capa |= ETH_LINK_SPEED_5G;
 563         if (speed >= ETH_SPEED_NUM_10G)
 564                 capa |= ETH_LINK_SPEED_10G;
 565         if (speed >= ETH_SPEED_NUM_20G)
 566                 capa |= ETH_LINK_SPEED_20G;
 567         if (speed >= ETH_SPEED_NUM_25G)
 568                 capa |= ETH_LINK_SPEED_25G;
 569         if (speed >= ETH_SPEED_NUM_40G)
 570                 capa |= ETH_LINK_SPEED_40G;
 571         if (speed >= ETH_SPEED_NUM_50G)
 572                 capa |= ETH_LINK_SPEED_50G;
 573         if (speed >= ETH_SPEED_NUM_56G)
 574                 capa |= ETH_LINK_SPEED_56G;
 575         if (speed >= ETH_SPEED_NUM_100G)
 576                 capa |= ETH_LINK_SPEED_100G;
 577
 578         return capa;
 579 }
 580
 581 static void
 582 tap_dev_info(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
 583 {
 584         struct pmd_internals *internals = dev->data->dev_private;
 585
 586         dev_info->if_index = internals->if_index;
 587         dev_info->max_mac_addrs = 1;
 588         dev_info->max_rx_pktlen = (uint32_t)ETHER_MAX_VLAN_FRAME_LEN;
 589         dev_info->max_rx_queues = internals->nb_queues;
 590         dev_info->max_tx_queues = internals->nb_queues;
 591         dev_info->min_rx_bufsize = 0;
 592         dev_info->pci_dev = NULL;
 593         dev_info->speed_capa = tap_dev_speed_capa();
 594 }
 595
 596 static void
 597 tap_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *tap_stats)
 598 {
 599         unsigned int i, imax;
 600         unsigned long rx_total = 0, tx_total = 0, tx_err_total = 0;
 601         unsigned long rx_bytes_total = 0, tx_bytes_total = 0;
 602         unsigned long rx_nombuf = 0, ierrors = 0;
 603         const struct pmd_internals *pmd = dev->data->dev_private;
 604
 605         imax = (pmd->nb_queues < RTE_ETHDEV_QUEUE_STAT_CNTRS) ?
 606                 pmd->nb_queues : RTE_ETHDEV_QUEUE_STAT_CNTRS;
 607
 608         for (i = 0; i < imax; i++) {
 609                 tap_stats->q_ipackets[i] = pmd->rxq[i].stats.ipackets;
 610                 tap_stats->q_ibytes[i] = pmd->rxq[i].stats.ibytes;
 611                 rx_total += tap_stats->q_ipackets[i];
 612                 rx_bytes_total += tap_stats->q_ibytes[i];
 613                 rx_nombuf += pmd->rxq[i].stats.rx_nombuf;
 614                 ierrors += pmd->rxq[i].stats.ierrors;
 615
 616                 tap_stats->q_opackets[i] = pmd->txq[i].stats.opackets;
 617                 tap_stats->q_errors[i] = pmd->txq[i].stats.errs;
 618                 tap_stats->q_obytes[i] = pmd->txq[i].stats.obytes;
 619                 tx_total += tap_stats->q_opackets[i];
 620                 tx_err_total += tap_stats->q_errors[i];
 621                 tx_bytes_total += tap_stats->q_obytes[i];
 622         }
 623
 624         tap_stats->ipackets = rx_total;
 625         tap_stats->ibytes = rx_bytes_total;
 626         tap_stats->ierrors = ierrors;
 627         tap_stats->rx_nombuf = rx_nombuf;
 628         tap_stats->opackets = tx_total;
 629         tap_stats->oerrors = tx_err_total;
 630         tap_stats->obytes = tx_bytes_total;
 631 }
 632
 633 static void
 634 tap_stats_reset(struct rte_eth_dev *dev)
 635 {
 636         int i;
 637         struct pmd_internals *pmd = dev->data->dev_private;
 638
 639         for (i = 0; i < pmd->nb_queues; i++) {
 640                 pmd->rxq[i].stats.ipackets = 0;
 641                 pmd->rxq[i].stats.ibytes = 0;
 642                 pmd->rxq[i].stats.ierrors = 0;
 643                 pmd->rxq[i].stats.rx_nombuf = 0;
 644
 645                 pmd->txq[i].stats.opackets = 0;
 646                 pmd->txq[i].stats.errs = 0;
 647                 pmd->txq[i].stats.obytes = 0;
 648         }
 649 }
 650
 651 static void
 652 tap_dev_close(struct rte_eth_dev *dev __rte_unused)
 653 {
 654         int i;
 655         struct pmd_internals *internals = dev->data->dev_private;
 656
 657         tap_link_set_down(dev);
 658         tap_flow_flush(dev, NULL);
 659         tap_flow_implicit_flush(internals, NULL);
 660
 661         for (i = 0; i < internals->nb_queues; i++) {
 662                 if (internals->rxq[i].fd != -1)
 663                         close(internals->rxq[i].fd);
 664                 internals->rxq[i].fd = -1;
 665                 internals->txq[i].fd = -1;
 666         }
 667 }
 668
 669 static void
 670 tap_rx_queue_release(void *queue)
 671 {
 672         struct rx_queue *rxq = queue;
 673
 674         if (rxq && (rxq->fd > 0)) {
 675                 close(rxq->fd);
 676                 rxq->fd = -1;
 677                 rte_pktmbuf_free(rxq->pool);
 678                 rte_free(rxq->iovecs);
 679                 rxq->pool = NULL;
 680                 rxq->iovecs = NULL;
 681         }
 682 }
 683
 684 static void
 685 tap_tx_queue_release(void *queue)
 686 {
 687         struct tx_queue *txq = queue;
 688
 689         if (txq && (txq->fd > 0)) {
 690                 close(txq->fd);
 691                 txq->fd = -1;
 692         }
 693 }
 694
 695 static int
 696 tap_link_update(struct rte_eth_dev *dev, int wait_to_complete __rte_unused)
 697 {
 698         struct rte_eth_link *dev_link = &dev->data->dev_link;
 699         struct pmd_internals *pmd = dev->data->dev_private;
 700         struct ifreq ifr = { .ifr_flags = 0 };
 701
 702         if (pmd->remote_if_index) {
 703                 tap_ioctl(pmd, SIOCGIFFLAGS, &ifr, 0, REMOTE_ONLY);
 704                 if (!(ifr.ifr_flags & IFF_UP) ||
 705                     !(ifr.ifr_flags & IFF_RUNNING)) {
 706                         dev_link->link_status = ETH_LINK_DOWN;
 707                         return 0;
 708                 }
 709         }
 710         tap_ioctl(pmd, SIOCGIFFLAGS, &ifr, 0, LOCAL_ONLY);
 711         dev_link->link_status =
 712                 ((ifr.ifr_flags & IFF_UP) && (ifr.ifr_flags & IFF_RUNNING) ?
 713                  ETH_LINK_UP :
 714                  ETH_LINK_DOWN);
 715         return 0;
 716 }
 717
 718 static void
 719 tap_promisc_enable(struct rte_eth_dev *dev)
 720 {
 721         struct pmd_internals *pmd = dev->data->dev_private;
 722         struct ifreq ifr = { .ifr_flags = IFF_PROMISC };
 723
 724         dev->data->promiscuous = 1;
 725         tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 1, LOCAL_AND_REMOTE);
 726         if (pmd->remote_if_index)
 727                 tap_flow_implicit_create(pmd, TAP_REMOTE_PROMISC);
 728 }
 729
 730 static void
 731 tap_promisc_disable(struct rte_eth_dev *dev)
 732 {
 733         struct pmd_internals *pmd = dev->data->dev_private;
 734         struct ifreq ifr = { .ifr_flags = IFF_PROMISC };
 735
 736         dev->data->promiscuous = 0;
 737         tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 0, LOCAL_AND_REMOTE);
 738         if (pmd->remote_if_index)
 739                 tap_flow_implicit_destroy(pmd, TAP_REMOTE_PROMISC);
 740 }
 741
 742 static void
 743 tap_allmulti_enable(struct rte_eth_dev *dev)
 744 {
 745         struct pmd_internals *pmd = dev->data->dev_private;
 746         struct ifreq ifr = { .ifr_flags = IFF_ALLMULTI };
 747
 748         dev->data->all_multicast = 1;
 749         tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 1, LOCAL_AND_REMOTE);
 750         if (pmd->remote_if_index)
 751                 tap_flow_implicit_create(pmd, TAP_REMOTE_ALLMULTI);
 752 }
 753
 754 static void
 755 tap_allmulti_disable(struct rte_eth_dev *dev)
 756 {
 757         struct pmd_internals *pmd = dev->data->dev_private;
 758         struct ifreq ifr = { .ifr_flags = IFF_ALLMULTI };
 759
 760         dev->data->all_multicast = 0;
 761         tap_ioctl(pmd, SIOCSIFFLAGS, &ifr, 0, LOCAL_AND_REMOTE);
 762         if (pmd->remote_if_index)
 763                 tap_flow_implicit_destroy(pmd, TAP_REMOTE_ALLMULTI);
 764 }
 765
 766
 767 static void
 768 tap_mac_set(struct rte_eth_dev *dev, struct ether_addr *mac_addr)
 769 {
 770         struct pmd_internals *pmd = dev->data->dev_private;
 771         struct ifreq ifr;
 772
 773         if (is_zero_ether_addr(mac_addr)) {
 774                 RTE_LOG(ERR, PMD, "%s: can't set an empty MAC address\n",
 775                         dev->data->name);
 776                 return;
 777         }
 778
 779         ifr.ifr_hwaddr.sa_family = AF_LOCAL;
 780         rte_memcpy(ifr.ifr_hwaddr.sa_data, mac_addr, ETHER_ADDR_LEN);
 781         if (tap_ioctl(pmd, SIOCSIFHWADDR, &ifr, 1, LOCAL_AND_REMOTE) < 0)
 782                 return;
 783         rte_memcpy(&pmd->eth_addr, mac_addr, ETHER_ADDR_LEN);
 784 }
 785
 786 static int
 787 tap_setup_queue(struct rte_eth_dev *dev,
 788                 struct pmd_internals *internals,
 789                 uint16_t qid)
 790 {
 791         struct pmd_internals *pmd = dev->data->dev_private;
 792         struct rx_queue *rx = &internals->rxq[qid];
 793         struct tx_queue *tx = &internals->txq[qid];
 794         int fd;
 795
 796         fd = rx->fd;
 797         if (fd < 0) {
 798                 fd = tx->fd;
 799                 if (fd < 0) {
 800                         RTE_LOG(INFO, PMD, "Add queue to TAP %s for qid %d\n",
 801                                 pmd->name, qid);
 802                         fd = tun_alloc(pmd, qid);
 803                         if (fd < 0) {
 804                                 RTE_LOG(ERR, PMD, "tun_alloc(%s, %d) failed\n",
 805                                         pmd->name, qid);
 806                                 return -1;
 807                         }
 808                         if (qid == 0) {
 809                                 struct ifreq ifr;
 810
 811                                 ifr.ifr_mtu = dev->data->mtu;
 812                                 if (tap_ioctl(pmd, SIOCSIFMTU, &ifr, 1,
 813                                               LOCAL_AND_REMOTE) < 0) {
 814                                         close(fd);
 815                                         return -1;
 816                                 }
 817                         }
 818                 }
 819         }
 820
 821         rx->fd = fd;
 822         tx->fd = fd;
 823         tx->mtu = &dev->data->mtu;
 824         rx->rxmode = &dev->data->dev_conf.rxmode;
 825
 826         return fd;
 827 }
 828
 829 static int
 830 rx_setup_queue(struct rte_eth_dev *dev,
 831                 struct pmd_internals *internals,
 832                 uint16_t qid)
 833 {
 834         dev->data->rx_queues[qid] = &internals->rxq[qid];
 835
 836         return tap_setup_queue(dev, internals, qid);
 837 }
 838
 839 static int
 840 tx_setup_queue(struct rte_eth_dev *dev,
 841                 struct pmd_internals *internals,
 842                 uint16_t qid)
 843 {
 844         dev->data->tx_queues[qid] = &internals->txq[qid];
 845
 846         return tap_setup_queue(dev, internals, qid);
 847 }
 848
 849 static int
 850 tap_rx_queue_setup(struct rte_eth_dev *dev,
 851                    uint16_t rx_queue_id,
 852                    uint16_t nb_rx_desc,
 853                    unsigned int socket_id,
 854                    const struct rte_eth_rxconf *rx_conf __rte_unused,
 855                    struct rte_mempool *mp)
 856 {
 857         struct pmd_internals *internals = dev->data->dev_private;
 858         struct rx_queue *rxq = &internals->rxq[rx_queue_id];
 859         struct rte_mbuf **tmp = &rxq->pool;
 860         struct iovec (*iovecs)[nb_rx_desc + 1];
 861         int data_off = RTE_PKTMBUF_HEADROOM;
 862         int ret = 0;
 863         int fd;
 864         int i;
 865
 866         if ((rx_queue_id >= internals->nb_queues) || !mp) {
 867                 RTE_LOG(WARNING, PMD,
 868                         "nb_queues %d too small or mempool NULL\n",
 869                         internals->nb_queues);
 870                 return -1;
 871         }
 872
 873         rxq->mp = mp;
 874         rxq->trigger_seen = 1; /* force initial burst */
 875         rxq->in_port = dev->data->port_id;
 876         rxq->nb_rx_desc = nb_rx_desc;
 877         iovecs = rte_zmalloc_socket(dev->data->name, sizeof(*iovecs), 0,
 878                                     socket_id);
 879         if (!iovecs) {
 880                 RTE_LOG(WARNING, PMD,
 881                         "%s: Couldn't allocate %d RX descriptors\n",
 882                         dev->data->name, nb_rx_desc);
 883                 return -ENOMEM;
 884         }
 885         rxq->iovecs = iovecs;
 886
 887         fd = rx_setup_queue(dev, internals, rx_queue_id);
 888         if (fd == -1) {
 889                 ret = fd;
 890                 goto error;
 891         }
 892
 893         (*rxq->iovecs)[0].iov_len = sizeof(struct tun_pi);
 894         (*rxq->iovecs)[0].iov_base = &rxq->pi;
 895
 896         for (i = 1; i <= nb_rx_desc; i++) {
 897                 *tmp = rte_pktmbuf_alloc(rxq->mp);
 898                 if (!*tmp) {
 899                         RTE_LOG(WARNING, PMD,
 900                                 "%s: couldn't allocate memory for queue %d\n",
 901                                 dev->data->name, rx_queue_id);
 902                         ret = -ENOMEM;
 903                         goto error;
 904                 }
 905                 (*rxq->iovecs)[i].iov_len = (*tmp)->buf_len - data_off;
 906                 (*rxq->iovecs)[i].iov_base =
 907                         (char *)(*tmp)->buf_addr + data_off;
 908                 data_off = 0;
 909                 tmp = &(*tmp)->next;
 910         }
 911
 912         RTE_LOG(DEBUG, PMD, "  RX TAP device name %s, qid %d on fd %d\n",
 913                 internals->name, rx_queue_id, internals->rxq[rx_queue_id].fd);
 914
 915         return 0;
 916
 917 error:
 918         rte_pktmbuf_free(rxq->pool);
 919         rxq->pool = NULL;
 920         rte_free(rxq->iovecs);
 921         rxq->iovecs = NULL;
 922         return ret;
 923 }
 924
 925 static int
 926 tap_tx_queue_setup(struct rte_eth_dev *dev,
 927                    uint16_t tx_queue_id,
 928                    uint16_t nb_tx_desc __rte_unused,
 929                    unsigned int socket_id __rte_unused,
 930                    const struct rte_eth_txconf *tx_conf __rte_unused)
 931 {
 932         struct pmd_internals *internals = dev->data->dev_private;
 933         int ret;
 934
 935         if (tx_queue_id >= internals->nb_queues)
 936                 return -1;
 937
 938         ret = tx_setup_queue(dev, internals, tx_queue_id);
 939         if (ret == -1)
 940                 return -1;
 941
 942         RTE_LOG(DEBUG, PMD, "  TX TAP device name %s, qid %d on fd %d\n",
 943                 internals->name, tx_queue_id, internals->txq[tx_queue_id].fd);
 944
 945         return 0;
 946 }
 947
 948 static int
 949 tap_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
 950 {
 951         struct pmd_internals *pmd = dev->data->dev_private;
 952         struct ifreq ifr = { .ifr_mtu = mtu };
 953         int err = 0;
 954
 955         err = tap_ioctl(pmd, SIOCSIFMTU, &ifr, 1, LOCAL_AND_REMOTE);
 956         if (!err)
 957                 dev->data->mtu = mtu;
 958
 959         return err;
 960 }
 961
 962 static int
 963 tap_set_mc_addr_list(struct rte_eth_dev *dev __rte_unused,
 964                      struct ether_addr *mc_addr_set __rte_unused,
 965                      uint32_t nb_mc_addr __rte_unused)
 966 {
 967         /*
 968          * Nothing to do actually: the tap has no filtering whatsoever, every
 969          * packet is received.
 970          */
 971         return 0;
 972 }
 973
 974 static int
 975 tap_nl_msg_handler(struct nlmsghdr *nh, void *arg)
 976 {
 977         struct rte_eth_dev *dev = arg;
 978         struct pmd_internals *pmd = dev->data->dev_private;
 979         struct ifinfomsg *info = NLMSG_DATA(nh);
 980
 981         if (nh->nlmsg_type != RTM_NEWLINK ||
 982             (info->ifi_index != pmd->if_index &&
 983              info->ifi_index != pmd->remote_if_index))
 984                 return 0;
 985         return tap_link_update(dev, 0);
 986 }
 987
 988 static void
 989 tap_dev_intr_handler(struct rte_intr_handle *intr_handle __rte_unused,
 990                      void *cb_arg)
 991 {
 992         struct rte_eth_dev *dev = cb_arg;
 993         struct pmd_internals *pmd = dev->data->dev_private;
 994
 995         nl_recv(pmd->intr_handle.fd, tap_nl_msg_handler, dev);
 996 }
 997
 998 static int
 999 tap_intr_handle_set(struct rte_eth_dev *dev, int set)
1000 {
1001         struct pmd_internals *pmd = dev->data->dev_private;
1002
1003         /* In any case, disable interrupt if the conf is no longer there. */
1004         if (!dev->data->dev_conf.intr_conf.lsc) {
1005                 if (pmd->intr_handle.fd != -1)
1006                         nl_final(pmd->intr_handle.fd);
1007                 rte_intr_callback_unregister(
1008                         &pmd->intr_handle, tap_dev_intr_handler, dev);
1009                 return 0;
1010         }
1011         if (set) {
1012                 pmd->intr_handle.fd = nl_init(RTMGRP_LINK);
1013                 if (unlikely(pmd->intr_handle.fd == -1))
1014                         return -EBADF;
1015                 return rte_intr_callback_register(
1016                         &pmd->intr_handle, tap_dev_intr_handler, dev);
1017         }
1018         nl_final(pmd->intr_handle.fd);
1019         return rte_intr_callback_unregister(&pmd->intr_handle,
1020                                             tap_dev_intr_handler, dev);
1021 }
1022
1023 static const uint32_t*
1024 tap_dev_supported_ptypes_get(struct rte_eth_dev *dev __rte_unused)
1025 {
1026         static const uint32_t ptypes[] = {
1027                 RTE_PTYPE_INNER_L2_ETHER,
1028                 RTE_PTYPE_INNER_L2_ETHER_VLAN,
1029                 RTE_PTYPE_INNER_L2_ETHER_QINQ,
1030                 RTE_PTYPE_INNER_L3_IPV4,
1031                 RTE_PTYPE_INNER_L3_IPV4_EXT,
1032                 RTE_PTYPE_INNER_L3_IPV6,
1033                 RTE_PTYPE_INNER_L3_IPV6_EXT,
1034                 RTE_PTYPE_INNER_L4_FRAG,
1035                 RTE_PTYPE_INNER_L4_UDP,
1036                 RTE_PTYPE_INNER_L4_TCP,
1037                 RTE_PTYPE_INNER_L4_SCTP,
1038                 RTE_PTYPE_L2_ETHER,
1039                 RTE_PTYPE_L2_ETHER_VLAN,
1040                 RTE_PTYPE_L2_ETHER_QINQ,
1041                 RTE_PTYPE_L3_IPV4,
1042                 RTE_PTYPE_L3_IPV4_EXT,
1043                 RTE_PTYPE_L3_IPV6_EXT,
1044                 RTE_PTYPE_L3_IPV6,
1045                 RTE_PTYPE_L4_FRAG,
1046                 RTE_PTYPE_L4_UDP,
1047                 RTE_PTYPE_L4_TCP,
1048                 RTE_PTYPE_L4_SCTP,
1049         };
1050
1051         return ptypes;
1052 }
1053
1054 static int
1055 tap_flow_ctrl_get(struct rte_eth_dev *dev __rte_unused,
1056                   struct rte_eth_fc_conf *fc_conf)
1057 {
1058         fc_conf->mode = RTE_FC_NONE;
1059         return 0;
1060 }
1061
1062 static int
1063 tap_flow_ctrl_set(struct rte_eth_dev *dev __rte_unused,
1064                   struct rte_eth_fc_conf *fc_conf)
1065 {
1066         if (fc_conf->mode != RTE_FC_NONE)
1067                 return -ENOTSUP;
1068         return 0;
1069 }
1070
1071 static const struct eth_dev_ops ops = {
1072         .dev_start              = tap_dev_start,
1073         .dev_stop               = tap_dev_stop,
1074         .dev_close              = tap_dev_close,
1075         .dev_configure          = tap_dev_configure,
1076         .dev_infos_get          = tap_dev_info,
1077         .rx_queue_setup         = tap_rx_queue_setup,
1078         .tx_queue_setup         = tap_tx_queue_setup,
1079         .rx_queue_release       = tap_rx_queue_release,
1080         .tx_queue_release       = tap_tx_queue_release,
1081         .flow_ctrl_get          = tap_flow_ctrl_get,
1082         .flow_ctrl_set          = tap_flow_ctrl_set,
1083         .link_update            = tap_link_update,
1084         .dev_set_link_up        = tap_link_set_up,
1085         .dev_set_link_down      = tap_link_set_down,
1086         .promiscuous_enable     = tap_promisc_enable,
1087         .promiscuous_disable    = tap_promisc_disable,
1088         .allmulticast_enable    = tap_allmulti_enable,
1089         .allmulticast_disable   = tap_allmulti_disable,
1090         .mac_addr_set           = tap_mac_set,
1091         .mtu_set                = tap_mtu_set,
1092         .set_mc_addr_list       = tap_set_mc_addr_list,
1093         .stats_get              = tap_stats_get,
1094         .stats_reset            = tap_stats_reset,
1095         .dev_supported_ptypes_get = tap_dev_supported_ptypes_get,
1096         .filter_ctrl            = tap_dev_filter_ctrl,
1097 };
1098
1099 static int
1100 tap_kernel_support(struct pmd_internals *pmd)
1101 {
1102         struct utsname utsname;
1103         int ver[3];
1104
1105         if (uname(&utsname) == -1 ||
1106             sscanf(utsname.release, "%d.%d.%d",
1107                    &ver[0], &ver[1], &ver[2]) != 3)
1108                 return 0;
1109         if (KERNEL_VERSION(ver[0], ver[1], ver[2]) >= FLOWER_KERNEL_VERSION)
1110                 pmd->flower_support = 1;
1111         if (KERNEL_VERSION(ver[0], ver[1], ver[2]) >=
1112             FLOWER_VLAN_KERNEL_VERSION)
1113                 pmd->flower_vlan_support = 1;
1114         return 1;
1115 }
1116
1117 static int
1118 eth_dev_tap_create(const char *name, char *tap_name, char *remote_iface)
1119 {
1120         int numa_node = rte_socket_id();
1121         struct rte_eth_dev *dev = NULL;
1122         struct pmd_internals *pmd = NULL;
1123         struct rte_eth_dev_data *data = NULL;
1124         int i;
1125
1126         RTE_LOG(DEBUG, PMD, "  TAP device on numa %u\n", rte_socket_id());
1127
1128         data = rte_zmalloc_socket(tap_name, sizeof(*data), 0, numa_node);
1129         if (!data) {
1130                 RTE_LOG(ERR, PMD, "TAP Failed to allocate data\n");
1131                 goto error_exit;
1132         }
1133
1134         pmd = rte_zmalloc_socket(tap_name, sizeof(*pmd), 0, numa_node);
1135         if (!pmd) {
1136                 RTE_LOG(ERR, PMD, "TAP Unable to allocate internal struct\n");
1137                 goto error_exit;
1138         }
1139
1140         /* name in allocation and data->name must be consistent */
1141         snprintf(data->name, sizeof(data->name), "%s", name);
1142         dev = rte_eth_dev_allocate(name);
1143         if (!dev) {
1144                 RTE_LOG(ERR, PMD, "TAP Unable to allocate device struct\n");
1145                 goto error_exit;
1146         }
1147
1148         snprintf(pmd->name, sizeof(pmd->name), "%s", tap_name);
1149
1150         pmd->nb_queues = RTE_PMD_TAP_MAX_QUEUES;
1151
1152         pmd->ioctl_sock = socket(AF_INET, SOCK_DGRAM, 0);
1153         if (pmd->ioctl_sock == -1) {
1154                 RTE_LOG(ERR, PMD,
1155                         "TAP Unable to get a socket for management: %s\n",
1156                         strerror(errno));
1157                 goto error_exit;
1158         }
1159
1160         /* Setup some default values */
1161         data->dev_private = pmd;
1162         data->port_id = dev->data->port_id;
1163         data->mtu = dev->data->mtu;
1164         data->dev_flags = RTE_ETH_DEV_DETACHABLE | RTE_ETH_DEV_INTR_LSC;
1165         data->kdrv = RTE_KDRV_NONE;
1166         data->drv_name = pmd_tap_drv.driver.name;
1167         data->numa_node = numa_node;
1168
1169         data->dev_link = pmd_link;
1170         data->mac_addrs = &pmd->eth_addr;
1171         data->nb_rx_queues = pmd->nb_queues;
1172         data->nb_tx_queues = pmd->nb_queues;
1173
1174         dev->data = data;
1175         dev->dev_ops = &ops;
1176         dev->driver = NULL;
1177         dev->rx_pkt_burst = pmd_rx_burst;
1178         dev->tx_pkt_burst = pmd_tx_burst;
1179
1180         pmd->intr_handle.type = RTE_INTR_HANDLE_EXT;
1181         pmd->intr_handle.fd = -1;
1182
1183         /* Presetup the fds to -1 as being not valid */
1184         for (i = 0; i < RTE_PMD_TAP_MAX_QUEUES; i++) {
1185                 pmd->rxq[i].fd = -1;
1186                 pmd->txq[i].fd = -1;
1187         }
1188
1189         tap_kernel_support(pmd);
1190         if (!pmd->flower_support)
1191                 return 0;
1192         LIST_INIT(&pmd->flows);
1193         /*
1194          * If no netlink socket can be created, then it will fail when
1195          * creating/destroying flow rules.
1196          */
1197         pmd->nlsk_fd = nl_init(0);
1198         if (strlen(remote_iface)) {
1199                 struct ifreq ifr;
1200
1201                 pmd->remote_if_index = if_nametoindex(remote_iface);
1202                 snprintf(pmd->remote_iface, RTE_ETH_NAME_MAX_LEN,
1203                          "%s", remote_iface);
1204                 if (!pmd->remote_if_index) {
1205                         RTE_LOG(ERR, PMD, "Could not find %s ifindex: "
1206                                 "remote interface will remain unconfigured\n",
1207                                 remote_iface);
1208                         return 0;
1209                 }
1210                 if (tap_ioctl(pmd, SIOCGIFHWADDR, &ifr, 0, REMOTE_ONLY) < 0) {
1211                         RTE_LOG(ERR, PMD, "Could not get remote MAC address\n");
1212                         goto error_exit;
1213                 }
1214                 rte_memcpy(&pmd->eth_addr, ifr.ifr_hwaddr.sa_data,
1215                            ETHER_ADDR_LEN);
1216         } else {
1217                 eth_random_addr((uint8_t *)&pmd->eth_addr);
1218         }
1219
1220         return 0;
1221
1222 error_exit:
1223         RTE_LOG(DEBUG, PMD, "TAP Unable to initialize %s\n", name);
1224
1225         rte_free(data);
1226         rte_free(pmd);
1227
1228         rte_eth_dev_release_port(dev);
1229
1230         return -EINVAL;
1231 }
1232
1233 static int
1234 set_interface_name(const char *key __rte_unused,
1235                    const char *value,
1236                    void *extra_args)
1237 {
1238         char *name = (char *)extra_args;
1239
1240         if (value)
1241                 snprintf(name, RTE_ETH_NAME_MAX_LEN - 1, "%s", value);
1242         else
1243                 snprintf(name, RTE_ETH_NAME_MAX_LEN - 1, "%s%d",
1244                          DEFAULT_TAP_NAME, (tap_unit - 1));
1245
1246         return 0;
1247 }
1248
1249 static int
1250 set_interface_speed(const char *key __rte_unused,
1251                     const char *value,
1252                     void *extra_args)
1253 {
1254         *(int *)extra_args = (value) ? atoi(value) : ETH_SPEED_NUM_10G;
1255
1256         return 0;
1257 }
1258
1259 static int
1260 set_remote_iface(const char *key __rte_unused,
1261                  const char *value,
1262                  void *extra_args)
1263 {
1264         char *name = (char *)extra_args;
1265
1266         if (value)
1267                 snprintf(name, RTE_ETH_NAME_MAX_LEN, "%s", value);
1268
1269         return 0;
1270 }
1271
1272 /* Open a TAP interface device.
1273  */
1274 static int
1275 rte_pmd_tap_probe(const char *name, const char *params)
1276 {
1277         int ret;
1278         struct rte_kvargs *kvlist = NULL;
1279         int speed;
1280         char tap_name[RTE_ETH_NAME_MAX_LEN];
1281         char remote_iface[RTE_ETH_NAME_MAX_LEN];
1282
1283         speed = ETH_SPEED_NUM_10G;
1284         snprintf(tap_name, sizeof(tap_name), "%s%d",
1285                  DEFAULT_TAP_NAME, tap_unit++);
1286         memset(remote_iface, 0, RTE_ETH_NAME_MAX_LEN);
1287
1288         if (params && (params[0] != '\0')) {
1289                 RTE_LOG(DEBUG, PMD, "paramaters (%s)\n", params);
1290
1291                 kvlist = rte_kvargs_parse(params, valid_arguments);
1292                 if (kvlist) {
1293                         if (rte_kvargs_count(kvlist, ETH_TAP_SPEED_ARG) == 1) {
1294                                 ret = rte_kvargs_process(kvlist,
1295                                                          ETH_TAP_SPEED_ARG,
1296                                                          &set_interface_speed,
1297                                                          &speed);
1298                                 if (ret == -1)
1299                                         goto leave;
1300                         }
1301
1302                         if (rte_kvargs_count(kvlist, ETH_TAP_IFACE_ARG) == 1) {
1303                                 ret = rte_kvargs_process(kvlist,
1304                                                          ETH_TAP_IFACE_ARG,
1305                                                          &set_interface_name,
1306                                                          tap_name);
1307                                 if (ret == -1)
1308                                         goto leave;
1309                         }
1310
1311                         if (rte_kvargs_count(kvlist, ETH_TAP_REMOTE_ARG) == 1) {
1312                                 ret = rte_kvargs_process(kvlist,
1313                                                          ETH_TAP_REMOTE_ARG,
1314                                                          &set_remote_iface,
1315                                                          remote_iface);
1316                                 if (ret == -1)
1317                                         goto leave;
1318                         }
1319                 }
1320         }
1321         pmd_link.link_speed = speed;
1322
1323         RTE_LOG(NOTICE, PMD, "Initializing pmd_tap for %s as %s\n",
1324                 name, tap_name);
1325
1326         ret = eth_dev_tap_create(name, tap_name, remote_iface);
1327
1328 leave:
1329         if (ret == -1) {
1330                 RTE_LOG(ERR, PMD, "Failed to create pmd for %s as %s\n",
1331                         name, tap_name);
1332                 tap_unit--;             /* Restore the unit number */
1333         }
1334         rte_kvargs_free(kvlist);
1335
1336         return ret;
1337 }
1338
1339 /* detach a TAP device.
1340  */
1341 static int
1342 rte_pmd_tap_remove(const char *name)
1343 {
1344         struct rte_eth_dev *eth_dev = NULL;
1345         struct pmd_internals *internals;
1346         int i;
1347
1348         RTE_LOG(DEBUG, PMD, "Closing TUN/TAP Ethernet device on numa %u\n",
1349                 rte_socket_id());
1350
1351         /* find the ethdev entry */
1352         eth_dev = rte_eth_dev_allocated(name);
1353         if (!eth_dev)
1354                 return 0;
1355
1356         internals = eth_dev->data->dev_private;
1357         if (internals->flower_support && internals->nlsk_fd) {
1358                 tap_flow_flush(eth_dev, NULL);
1359                 tap_flow_implicit_flush(internals, NULL);
1360                 nl_final(internals->nlsk_fd);
1361         }
1362         for (i = 0; i < internals->nb_queues; i++)
1363                 if (internals->rxq[i].fd != -1)
1364                         close(internals->rxq[i].fd);
1365
1366         close(internals->ioctl_sock);
1367         rte_free(eth_dev->data->dev_private);
1368         rte_free(eth_dev->data);
1369
1370         rte_eth_dev_release_port(eth_dev);
1371
1372         return 0;
1373 }
1374
1375 static struct rte_vdev_driver pmd_tap_drv = {
1376         .probe = rte_pmd_tap_probe,
1377         .remove = rte_pmd_tap_remove,
1378 };
1379 RTE_PMD_REGISTER_VDEV(net_tap, pmd_tap_drv);
1380 RTE_PMD_REGISTER_ALIAS(net_tap, eth_tap);
1381 RTE_PMD_REGISTER_PARAM_STRING(net_tap, "iface=<string>,speed=N");