drivers/net/tap/rte_eth_tap.c

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