drivers/net/virtio/virtio_user/vhost_kernel_tap.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2016 Intel Corporation
   3  */
   4
   5 #include <unistd.h>
   6 #include <sys/types.h>
   7 #include <sys/stat.h>
   8 #include <fcntl.h>
   9 #include <net/if.h>
  10 #include <net/if_arp.h>
  11 #include <errno.h>
  12 #include <string.h>
  13 #include <limits.h>
  14
  15 #include <rte_ether.h>
  16
  17 #include "vhost_kernel_tap.h"
  18 #include "../virtio_logs.h"
  19 #include "../virtio_pci.h"
  20
  21 int
  22 vhost_kernel_tap_set_offload(int fd, uint64_t features)
  23 {
  24         unsigned int offload = 0;
  25
  26         if (features & (1ULL << VIRTIO_NET_F_GUEST_CSUM)) {
  27                 offload |= TUN_F_CSUM;
  28                 if (features & (1ULL << VIRTIO_NET_F_GUEST_TSO4))
  29                         offload |= TUN_F_TSO4;
  30                 if (features & (1ULL << VIRTIO_NET_F_GUEST_TSO6))
  31                         offload |= TUN_F_TSO6;
  32                 if (features & ((1ULL << VIRTIO_NET_F_GUEST_TSO4) |
  33                         (1ULL << VIRTIO_NET_F_GUEST_TSO6)) &&
  34                         (features & (1ULL << VIRTIO_NET_F_GUEST_ECN)))
  35                         offload |= TUN_F_TSO_ECN;
  36                 if (features & (1ULL << VIRTIO_NET_F_GUEST_UFO))
  37                         offload |= TUN_F_UFO;
  38         }
  39
  40         /* Check if our kernel supports TUNSETOFFLOAD */
  41         if (ioctl(fd, TUNSETOFFLOAD, 0) != 0 && errno == EINVAL) {
  42                 PMD_DRV_LOG(ERR, "Kernel does't support TUNSETOFFLOAD\n");
  43                 return -ENOTSUP;
  44         }
  45
  46         if (ioctl(fd, TUNSETOFFLOAD, offload) != 0) {
  47                 offload &= ~TUN_F_UFO;
  48                 if (ioctl(fd, TUNSETOFFLOAD, offload) != 0) {
  49                         PMD_DRV_LOG(ERR, "TUNSETOFFLOAD ioctl() failed: %s\n",
  50                                 strerror(errno));
  51                         return -1;
  52                 }
  53         }
  54
  55         return 0;
  56 }
  57
  58 int
  59 vhost_kernel_tap_set_queue(int fd, bool attach)
  60 {
  61         struct ifreq ifr = {
  62                 .ifr_flags = attach ? IFF_ATTACH_QUEUE : IFF_DETACH_QUEUE,
  63         };
  64
  65         return ioctl(fd, TUNSETQUEUE, &ifr);
  66 }
  67
  68 int
  69 vhost_kernel_open_tap(char **p_ifname, int hdr_size, int req_mq,
  70                          const char *mac, uint64_t features)
  71 {
  72         unsigned int tap_features;
  73         char *tap_name = NULL;
  74         int sndbuf = INT_MAX;
  75         struct ifreq ifr;
  76         int tapfd;
  77         int ret;
  78
  79         /* TODO:
  80          * 1. verify we can get/set vnet_hdr_len, tap_probe_vnet_hdr_len
  81          * 2. get number of memory regions from vhost module parameter
  82          * max_mem_regions, supported in newer version linux kernel
  83          */
  84         tapfd = open(PATH_NET_TUN, O_RDWR);
  85         if (tapfd < 0) {
  86                 PMD_DRV_LOG(ERR, "fail to open %s: %s",
  87                             PATH_NET_TUN, strerror(errno));
  88                 return -1;
  89         }
  90
  91         /* Construct ifr */
  92         memset(&ifr, 0, sizeof(ifr));
  93         ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
  94
  95         if (ioctl(tapfd, TUNGETFEATURES, &tap_features) == -1) {
  96                 PMD_DRV_LOG(ERR, "TUNGETFEATURES failed: %s", strerror(errno));
  97                 goto error;
  98         }
  99         if (tap_features & IFF_ONE_QUEUE)
 100                 ifr.ifr_flags |= IFF_ONE_QUEUE;
 101
 102         /* Let tap instead of vhost-net handle vnet header, as the latter does
 103          * not support offloading. And in this case, we should not set feature
 104          * bit VHOST_NET_F_VIRTIO_NET_HDR.
 105          */
 106         if (tap_features & IFF_VNET_HDR) {
 107                 ifr.ifr_flags |= IFF_VNET_HDR;
 108         } else {
 109                 PMD_DRV_LOG(ERR, "TAP does not support IFF_VNET_HDR");
 110                 goto error;
 111         }
 112
 113         if (req_mq)
 114                 ifr.ifr_flags |= IFF_MULTI_QUEUE;
 115
 116         if (*p_ifname)
 117                 strncpy(ifr.ifr_name, *p_ifname, IFNAMSIZ - 1);
 118         else
 119                 strncpy(ifr.ifr_name, "tap%d", IFNAMSIZ - 1);
 120         if (ioctl(tapfd, TUNSETIFF, (void *)&ifr) == -1) {
 121                 PMD_DRV_LOG(ERR, "TUNSETIFF failed: %s", strerror(errno));
 122                 goto error;
 123         }
 124
 125         tap_name = strdup(ifr.ifr_name);
 126         if (!tap_name) {
 127                 PMD_DRV_LOG(ERR, "strdup ifname failed: %s", strerror(errno));
 128                 goto error;
 129         }
 130
 131         if (fcntl(tapfd, F_SETFL, O_NONBLOCK) < 0) {
 132                 PMD_DRV_LOG(ERR, "fcntl tapfd failed: %s", strerror(errno));
 133                 goto error;
 134         }
 135
 136         if (ioctl(tapfd, TUNSETVNETHDRSZ, &hdr_size) < 0) {
 137                 PMD_DRV_LOG(ERR, "TUNSETVNETHDRSZ failed: %s", strerror(errno));
 138                 goto error;
 139         }
 140
 141         if (ioctl(tapfd, TUNSETSNDBUF, &sndbuf) < 0) {
 142                 PMD_DRV_LOG(ERR, "TUNSETSNDBUF failed: %s", strerror(errno));
 143                 goto error;
 144         }
 145
 146         ret = vhost_kernel_tap_set_offload(tapfd, features);
 147         if (ret < 0 && ret != -ENOTSUP)
 148                 goto error;
 149
 150         memset(&ifr, 0, sizeof(ifr));
 151         ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
 152         memcpy(ifr.ifr_hwaddr.sa_data, mac, RTE_ETHER_ADDR_LEN);
 153         if (ioctl(tapfd, SIOCSIFHWADDR, (void *)&ifr) == -1) {
 154                 PMD_DRV_LOG(ERR, "SIOCSIFHWADDR failed: %s", strerror(errno));
 155                 goto error;
 156         }
 157
 158         free(*p_ifname);
 159         *p_ifname = tap_name;
 160
 161         return tapfd;
 162 error:
 163         free(tap_name);
 164         close(tapfd);
 165         return -1;
 166 }