drivers/net/vdev_netvsc/vdev_netvsc.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2017 6WIND S.A.
   3  * Copyright 2017 Mellanox Technologies, Ltd
   4  */
   5
   6 #include <errno.h>
   7 #include <fcntl.h>
   8 #include <inttypes.h>
   9 #include <linux/sockios.h>
  10 #include <linux/netlink.h>
  11 #include <linux/rtnetlink.h>
  12 #include <net/if.h>
  13 #include <net/if_arp.h>
  14 #include <netinet/ip.h>
  15 #include <stdarg.h>
  16 #include <stddef.h>
  17 #include <stdlib.h>
  18 #include <stdint.h>
  19 #include <stdio.h>
  20 #include <string.h>
  21 #include <sys/ioctl.h>
  22 #include <sys/queue.h>
  23 #include <sys/socket.h>
  24 #include <unistd.h>
  25
  26 #include <rte_alarm.h>
  27 #include <rte_bus.h>
  28 #include <rte_bus_vdev.h>
  29 #include <rte_common.h>
  30 #include <rte_config.h>
  31 #include <rte_dev.h>
  32 #include <rte_errno.h>
  33 #include <rte_ethdev.h>
  34 #include <rte_ether.h>
  35 #include <rte_hypervisor.h>
  36 #include <rte_kvargs.h>
  37 #include <rte_log.h>
  38
  39 #define VDEV_NETVSC_DRIVER net_vdev_netvsc
  40 #define VDEV_NETVSC_DRIVER_NAME RTE_STR(VDEV_NETVSC_DRIVER)
  41 #define VDEV_NETVSC_ARG_IFACE "iface"
  42 #define VDEV_NETVSC_ARG_MAC "mac"
  43 #define VDEV_NETVSC_ARG_FORCE "force"
  44 #define VDEV_NETVSC_ARG_IGNORE "ignore"
  45 #define VDEV_NETVSC_PROBE_MS 1000
  46
  47 #define NETVSC_CLASS_ID "{f8615163-df3e-46c5-913f-f2d2f965ed0e}"
  48 #define NETVSC_MAX_ROUTE_LINE_SIZE 300
  49
  50 #define DRV_LOG(level, ...) \
  51         rte_log(RTE_LOG_ ## level, \
  52                 vdev_netvsc_logtype, \
  53                 RTE_FMT(VDEV_NETVSC_DRIVER_NAME ": " \
  54                         RTE_FMT_HEAD(__VA_ARGS__,) "\n", \
  55                 RTE_FMT_TAIL(__VA_ARGS__,)))
  56
  57 /** Driver-specific log messages type. */
  58 static int vdev_netvsc_logtype;
  59
  60 /** Context structure for a vdev_netvsc instance. */
  61 struct vdev_netvsc_ctx {
  62         LIST_ENTRY(vdev_netvsc_ctx) entry; /**< Next entry in list. */
  63         unsigned int id;                   /**< Unique ID. */
  64         char name[64];                     /**< Unique name. */
  65         char devname[64];                  /**< Fail-safe instance name. */
  66         char devargs[256];                 /**< Fail-safe device arguments. */
  67         char if_name[IF_NAMESIZE];         /**< NetVSC netdevice name. */
  68         unsigned int if_index;             /**< NetVSC netdevice index. */
  69         struct ether_addr if_addr;         /**< NetVSC MAC address. */
  70         int pipe[2];                       /**< Fail-safe communication pipe. */
  71         char yield[256];                   /**< PCI sub-device arguments. */
  72 };
  73
  74 /** Context list is common to all driver instances. */
  75 static LIST_HEAD(, vdev_netvsc_ctx) vdev_netvsc_ctx_list =
  76         LIST_HEAD_INITIALIZER(vdev_netvsc_ctx_list);
  77
  78 /** Number of entries in context list. */
  79 static unsigned int vdev_netvsc_ctx_count;
  80
  81 /** Number of driver instances relying on context list. */
  82 static unsigned int vdev_netvsc_ctx_inst;
  83
  84 /**
  85  * Destroy a vdev_netvsc context instance.
  86  *
  87  * @param ctx
  88  *   Context to destroy.
  89  */
  90 static void
  91 vdev_netvsc_ctx_destroy(struct vdev_netvsc_ctx *ctx)
  92 {
  93         if (ctx->pipe[0] != -1)
  94                 close(ctx->pipe[0]);
  95         if (ctx->pipe[1] != -1)
  96                 close(ctx->pipe[1]);
  97         free(ctx);
  98 }
  99
 100 /**
 101  * Determine if a network interface is NetVSC.
 102  *
 103  * @param[in] iface
 104  *   Pointer to netdevice description structure (name and index).
 105  *
 106  * @return
 107  *   A nonzero value when interface is detected as NetVSC. In case of error,
 108  *   rte_errno is updated and 0 returned.
 109  */
 110 static int
 111 vdev_netvsc_iface_is_netvsc(const struct if_nameindex *iface)
 112 {
 113         static const char temp[] = "/sys/class/net/%s/device/class_id";
 114         char path[sizeof(temp) + IF_NAMESIZE];
 115         FILE *f;
 116         int ret;
 117         int len = 0;
 118
 119         ret = snprintf(path, sizeof(path), temp, iface->if_name);
 120         if (ret == -1 || (size_t)ret >= sizeof(path)) {
 121                 rte_errno = ENOBUFS;
 122                 return 0;
 123         }
 124         f = fopen(path, "r");
 125         if (!f) {
 126                 rte_errno = errno;
 127                 return 0;
 128         }
 129         ret = fscanf(f, NETVSC_CLASS_ID "%n", &len);
 130         if (ret == EOF)
 131                 rte_errno = errno;
 132         ret = len == (int)strlen(NETVSC_CLASS_ID);
 133         fclose(f);
 134         return ret;
 135 }
 136
 137 /**
 138  * Iterate over system network interfaces.
 139  *
 140  * This function runs a given callback function for each netdevice found on
 141  * the system.
 142  *
 143  * @param func
 144  *   Callback function pointer. List traversal is aborted when this function
 145  *   returns a nonzero value.
 146  * @param is_netvsc
 147  *   Indicates the device type to iterate - netvsc or non-netvsc.
 148  * @param ...
 149  *   Variable parameter list passed as @p va_list to @p func.
 150  *
 151  * @return
 152  *   0 when the entire list is traversed successfully, a negative error code
 153  *   in case or failure, or the nonzero value returned by @p func when list
 154  *   traversal is aborted.
 155  */
 156 static int
 157 vdev_netvsc_foreach_iface(int (*func)(const struct if_nameindex *iface,
 158                                       const struct ether_addr *eth_addr,
 159                                       va_list ap), int is_netvsc, ...)
 160 {
 161         struct if_nameindex *iface = if_nameindex();
 162         int s = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
 163         unsigned int i;
 164         int ret = 0;
 165
 166         if (!iface) {
 167                 ret = -ENOBUFS;
 168                 DRV_LOG(ERR, "cannot retrieve system network interfaces");
 169                 goto error;
 170         }
 171         if (s == -1) {
 172                 ret = -errno;
 173                 DRV_LOG(ERR, "cannot open socket: %s", rte_strerror(errno));
 174                 goto error;
 175         }
 176         for (i = 0; iface[i].if_name; ++i) {
 177                 int is_netvsc_ret;
 178                 struct ifreq req;
 179                 struct ether_addr eth_addr;
 180                 va_list ap;
 181
 182                 is_netvsc_ret = vdev_netvsc_iface_is_netvsc(&iface[i]) ? 1 : 0;
 183                 if (is_netvsc ^ is_netvsc_ret)
 184                         continue;
 185                 strncpy(req.ifr_name, iface[i].if_name, sizeof(req.ifr_name));
 186                 if (ioctl(s, SIOCGIFHWADDR, &req) == -1) {
 187                         DRV_LOG(WARNING, "cannot retrieve information about"
 188                                          " interface \"%s\": %s",
 189                                          req.ifr_name, rte_strerror(errno));
 190                         continue;
 191                 }
 192                 if (req.ifr_hwaddr.sa_family != ARPHRD_ETHER) {
 193                         DRV_LOG(DEBUG, "interface %s is non-ethernet device",
 194                                 req.ifr_name);
 195                         continue;
 196                 }
 197                 memcpy(eth_addr.addr_bytes, req.ifr_hwaddr.sa_data,
 198                        RTE_DIM(eth_addr.addr_bytes));
 199                 va_start(ap, is_netvsc);
 200                 ret = func(&iface[i], &eth_addr, ap);
 201                 va_end(ap);
 202                 if (ret)
 203                         break;
 204         }
 205 error:
 206         if (s != -1)
 207                 close(s);
 208         if (iface)
 209                 if_freenameindex(iface);
 210         return ret;
 211 }
 212
 213 /**
 214  * Determine if a network interface has a route.
 215  *
 216  * @param[in] name
 217  *   Network device name.
 218  * @param[in] family
 219  *   Address family: AF_INET for IPv4 or AF_INET6 for IPv6.
 220  *
 221  * @return
 222  *   1 when interface has a route, negative errno value in case of error and
 223  *   0 otherwise.
 224  */
 225 static int
 226 vdev_netvsc_has_route(const struct if_nameindex *iface,
 227                       const unsigned char family)
 228 {
 229         /*
 230          * The implementation can be simpler by getifaddrs() function usage but
 231          * it works for IPv6 only starting from glibc 2.3.3.
 232          */
 233         char buf[4096];
 234         int len;
 235         int ret = 0;
 236         int res;
 237         int sock;
 238         struct nlmsghdr *retmsg = (struct nlmsghdr *)buf;
 239         struct sockaddr_nl sa;
 240         struct {
 241                 struct nlmsghdr nlhdr;
 242                 struct ifaddrmsg addrmsg;
 243         } msg;
 244
 245         if (!iface || (family != AF_INET && family != AF_INET6)) {
 246                 DRV_LOG(ERR, "%s", rte_strerror(EINVAL));
 247                 return -EINVAL;
 248         }
 249         sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
 250         if (sock == -1) {
 251                 DRV_LOG(ERR, "cannot open socket: %s", rte_strerror(errno));
 252                 return -errno;
 253         }
 254         memset(&sa, 0, sizeof(sa));
 255         sa.nl_family = AF_NETLINK;
 256         sa.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR;
 257         res = bind(sock, (struct sockaddr *)&sa, sizeof(sa));
 258         if (res == -1) {
 259                 ret = -errno;
 260                 DRV_LOG(ERR, "cannot bind socket: %s", rte_strerror(errno));
 261                 goto close;
 262         }
 263         memset(&msg, 0, sizeof(msg));
 264         msg.nlhdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
 265         msg.nlhdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
 266         msg.nlhdr.nlmsg_type = RTM_GETADDR;
 267         msg.nlhdr.nlmsg_pid = getpid();
 268         msg.addrmsg.ifa_family = family;
 269         msg.addrmsg.ifa_index = iface->if_index;
 270         res = send(sock, &msg, msg.nlhdr.nlmsg_len, 0);
 271         if (res == -1) {
 272                 ret = -errno;
 273                 DRV_LOG(ERR, "cannot send socket message: %s",
 274                         rte_strerror(errno));
 275                 goto close;
 276         }
 277         memset(buf, 0, sizeof(buf));
 278         len = recv(sock, buf, sizeof(buf), 0);
 279         if (len == -1) {
 280                 ret = -errno;
 281                 DRV_LOG(ERR, "cannot receive socket message: %s",
 282                         rte_strerror(errno));
 283                 goto close;
 284         }
 285         while (NLMSG_OK(retmsg, (unsigned int)len)) {
 286                 struct ifaddrmsg *retaddr =
 287                                 (struct ifaddrmsg *)NLMSG_DATA(retmsg);
 288
 289                 if (retaddr->ifa_family == family &&
 290                     retaddr->ifa_index == iface->if_index) {
 291                         struct rtattr *retrta = IFA_RTA(retaddr);
 292                         int attlen = IFA_PAYLOAD(retmsg);
 293
 294                         while (RTA_OK(retrta, attlen)) {
 295                                 if (retrta->rta_type == IFA_ADDRESS) {
 296                                         ret = 1;
 297                                         DRV_LOG(DEBUG, "interface %s has IP",
 298                                                 iface->if_name);
 299                                         goto close;
 300                                 }
 301                                 retrta = RTA_NEXT(retrta, attlen);
 302                         }
 303                 }
 304                 retmsg = NLMSG_NEXT(retmsg, len);
 305         }
 306 close:
 307         close(sock);
 308         return ret;
 309 }
 310
 311 /**
 312  * Retrieve network interface data from sysfs symbolic link.
 313  *
 314  * @param[out] buf
 315  *   Output data buffer.
 316  * @param size
 317  *   Output buffer size.
 318  * @param[in] if_name
 319  *   Netdevice name.
 320  * @param[in] relpath
 321  *   Symbolic link path relative to netdevice sysfs entry.
 322  *
 323  * @return
 324  *   0 on success, a negative error code otherwise.
 325  */
 326 static int
 327 vdev_netvsc_sysfs_readlink(char *buf, size_t size, const char *if_name,
 328                            const char *relpath)
 329 {
 330         int ret;
 331
 332         ret = snprintf(buf, size, "/sys/class/net/%s/%s", if_name, relpath);
 333         if (ret == -1 || (size_t)ret >= size)
 334                 return -ENOBUFS;
 335         ret = readlink(buf, buf, size);
 336         if (ret == -1)
 337                 return -errno;
 338         if ((size_t)ret >= size - 1)
 339                 return -ENOBUFS;
 340         buf[ret] = '\0';
 341         return 0;
 342 }
 343
 344 /**
 345  * Probe a network interface to associate with vdev_netvsc context.
 346  *
 347  * This function determines if the network device matches the properties of
 348  * the NetVSC interface associated with the vdev_netvsc context and
 349  * communicates its bus address to the fail-safe PMD instance if so.
 350  *
 351  * It is normally used with vdev_netvsc_foreach_iface().
 352  *
 353  * @param[in] iface
 354  *   Pointer to netdevice description structure (name and index).
 355  * @param[in] eth_addr
 356  *   MAC address associated with @p iface.
 357  * @param ap
 358  *   Variable arguments list comprising:
 359  *
 360  *   - struct vdev_netvsc_ctx *ctx:
 361  *     Context to associate network interface with.
 362  *
 363  * @return
 364  *   A nonzero value when interface matches, 0 otherwise or in case of
 365  *   error.
 366  */
 367 static int
 368 vdev_netvsc_device_probe(const struct if_nameindex *iface,
 369                     const struct ether_addr *eth_addr,
 370                     va_list ap)
 371 {
 372         struct vdev_netvsc_ctx *ctx = va_arg(ap, struct vdev_netvsc_ctx *);
 373         char buf[RTE_MAX(sizeof(ctx->yield), 256u)];
 374         const char *addr;
 375         size_t len;
 376         int ret;
 377
 378         /* Skip non-matching or unwanted NetVSC interfaces. */
 379         if (ctx->if_index == iface->if_index) {
 380                 if (!strcmp(ctx->if_name, iface->if_name))
 381                         return 0;
 382                 DRV_LOG(DEBUG,
 383                         "NetVSC interface \"%s\" (index %u) renamed \"%s\"",
 384                         ctx->if_name, ctx->if_index, iface->if_name);
 385                 strncpy(ctx->if_name, iface->if_name, sizeof(ctx->if_name));
 386                 return 0;
 387         }
 388         if (!is_same_ether_addr(eth_addr, &ctx->if_addr))
 389                 return 0;
 390         /* Look for associated PCI device. */
 391         ret = vdev_netvsc_sysfs_readlink(buf, sizeof(buf), iface->if_name,
 392                                          "device/subsystem");
 393         if (ret)
 394                 return 0;
 395         addr = strrchr(buf, '/');
 396         addr = addr ? addr + 1 : buf;
 397         if (strcmp(addr, "pci"))
 398                 return 0;
 399         ret = vdev_netvsc_sysfs_readlink(buf, sizeof(buf), iface->if_name,
 400                                          "device");
 401         if (ret)
 402                 return 0;
 403         addr = strrchr(buf, '/');
 404         addr = addr ? addr + 1 : buf;
 405         len = strlen(addr);
 406         if (!len)
 407                 return 0;
 408         /* Send PCI device argument to fail-safe PMD instance. */
 409         if (strcmp(addr, ctx->yield))
 410                 DRV_LOG(DEBUG, "associating PCI device \"%s\" with NetVSC"
 411                         " interface \"%s\" (index %u)", addr, ctx->if_name,
 412                         ctx->if_index);
 413         memmove(buf, addr, len + 1);
 414         addr = buf;
 415         buf[len] = '\n';
 416         ret = write(ctx->pipe[1], addr, len + 1);
 417         buf[len] = '\0';
 418         if (ret == -1) {
 419                 if (errno == EINTR || errno == EAGAIN)
 420                         return 1;
 421                 DRV_LOG(WARNING, "cannot associate PCI device name \"%s\" with"
 422                         " interface \"%s\": %s", addr, ctx->if_name,
 423                         rte_strerror(errno));
 424                 return 1;
 425         }
 426         if ((size_t)ret != len + 1) {
 427                 /*
 428                  * Attempt to override previous partial write, no need to
 429                  * recover if that fails.
 430                  */
 431                 ret = write(ctx->pipe[1], "\n", 1);
 432                 (void)ret;
 433                 return 1;
 434         }
 435         fsync(ctx->pipe[1]);
 436         memcpy(ctx->yield, addr, len + 1);
 437         return 1;
 438 }
 439
 440 /**
 441  * Alarm callback that regularly probes system network interfaces.
 442  *
 443  * This callback runs at a frequency determined by VDEV_NETVSC_PROBE_MS as
 444  * long as an vdev_netvsc context instance exists.
 445  *
 446  * @param arg
 447  *   Ignored.
 448  */
 449 static void
 450 vdev_netvsc_alarm(__rte_unused void *arg)
 451 {
 452         struct vdev_netvsc_ctx *ctx;
 453         int ret;
 454
 455         LIST_FOREACH(ctx, &vdev_netvsc_ctx_list, entry) {
 456                 ret = vdev_netvsc_foreach_iface(vdev_netvsc_device_probe, 0,
 457                       ctx);
 458                 if (ret < 0)
 459                         break;
 460         }
 461         if (!vdev_netvsc_ctx_count)
 462                 return;
 463         ret = rte_eal_alarm_set(VDEV_NETVSC_PROBE_MS * 1000,
 464                                 vdev_netvsc_alarm, NULL);
 465         if (ret < 0) {
 466                 DRV_LOG(ERR, "unable to reschedule alarm callback: %s",
 467                         rte_strerror(-ret));
 468         }
 469 }
 470
 471 /**
 472  * Probe a NetVSC interface to generate a vdev_netvsc context from.
 473  *
 474  * This function instantiates vdev_netvsc contexts either for all NetVSC
 475  * devices found on the system or only a subset provided as device
 476  * arguments.
 477  *
 478  * It is normally used with vdev_netvsc_foreach_iface().
 479  *
 480  * @param[in] iface
 481  *   Pointer to netdevice description structure (name and index).
 482  * @param[in] eth_addr
 483  *   MAC address associated with @p iface.
 484  * @param ap
 485  *   Variable arguments list comprising:
 486  *
 487  *   - const char *name:
 488  *     Name associated with current driver instance.
 489  *
 490  *   - struct rte_kvargs *kvargs:
 491  *     Device arguments provided to current driver instance.
 492  *
 493  *   - int force:
 494  *     Accept specified interface even if not detected as NetVSC.
 495  *
 496  *   - unsigned int specified:
 497  *     Number of specific netdevices provided as device arguments.
 498  *
 499  *   - unsigned int *matched:
 500  *     The number of specified netdevices matched by this function.
 501  *
 502  * @return
 503  *   A nonzero value when interface matches, 0 otherwise or in case of
 504  *   error.
 505  */
 506 static int
 507 vdev_netvsc_netvsc_probe(const struct if_nameindex *iface,
 508                          const struct ether_addr *eth_addr,
 509                          va_list ap)
 510 {
 511         const char *name = va_arg(ap, const char *);
 512         struct rte_kvargs *kvargs = va_arg(ap, struct rte_kvargs *);
 513         unsigned int specified = va_arg(ap, unsigned int);
 514         unsigned int *matched = va_arg(ap, unsigned int *);
 515         unsigned int i;
 516         struct vdev_netvsc_ctx *ctx;
 517         int ret;
 518
 519         /* Probe all interfaces when none are specified. */
 520         if (specified) {
 521                 for (i = 0; i != kvargs->count; ++i) {
 522                         const struct rte_kvargs_pair *pair = &kvargs->pairs[i];
 523
 524                         if (!strcmp(pair->key, VDEV_NETVSC_ARG_IFACE)) {
 525                                 if (!strcmp(pair->value, iface->if_name))
 526                                         break;
 527                         } else if (!strcmp(pair->key, VDEV_NETVSC_ARG_MAC)) {
 528                                 struct ether_addr tmp;
 529
 530                                 if (sscanf(pair->value,
 531                                            "%" SCNx8 ":%" SCNx8 ":%" SCNx8 ":"
 532                                            "%" SCNx8 ":%" SCNx8 ":%" SCNx8,
 533                                            &tmp.addr_bytes[0],
 534                                            &tmp.addr_bytes[1],
 535                                            &tmp.addr_bytes[2],
 536                                            &tmp.addr_bytes[3],
 537                                            &tmp.addr_bytes[4],
 538                                            &tmp.addr_bytes[5]) != 6) {
 539                                         DRV_LOG(ERR,
 540                                                 "invalid MAC address format"
 541                                                 " \"%s\"",
 542                                                 pair->value);
 543                                         return -EINVAL;
 544                                 }
 545                                 if (is_same_ether_addr(eth_addr, &tmp))
 546                                         break;
 547                         }
 548                 }
 549                 if (i == kvargs->count)
 550                         return 0;
 551                 ++(*matched);
 552         }
 553         /* Weed out interfaces already handled. */
 554         LIST_FOREACH(ctx, &vdev_netvsc_ctx_list, entry)
 555                 if (ctx->if_index == iface->if_index)
 556                         break;
 557         if (ctx) {
 558                 if (!specified)
 559                         return 0;
 560                 DRV_LOG(WARNING,
 561                         "interface \"%s\" (index %u) is already handled,"
 562                         " skipping",
 563                         iface->if_name, iface->if_index);
 564                 return 0;
 565         }
 566         /* Routed NetVSC should not be probed. */
 567         if (vdev_netvsc_has_route(iface, AF_INET) ||
 568             vdev_netvsc_has_route(iface, AF_INET6)) {
 569                 if (!specified)
 570                         return 0;
 571                 DRV_LOG(WARNING, "probably using routed NetVSC interface \"%s\""
 572                         " (index %u)", iface->if_name, iface->if_index);
 573         }
 574         /* Create interface context. */
 575         ctx = calloc(1, sizeof(*ctx));
 576         if (!ctx) {
 577                 ret = -errno;
 578                 DRV_LOG(ERR, "cannot allocate context for interface \"%s\": %s",
 579                         iface->if_name, rte_strerror(errno));
 580                 goto error;
 581         }
 582         ctx->id = vdev_netvsc_ctx_count;
 583         strncpy(ctx->if_name, iface->if_name, sizeof(ctx->if_name));
 584         ctx->if_index = iface->if_index;
 585         ctx->if_addr = *eth_addr;
 586         ctx->pipe[0] = -1;
 587         ctx->pipe[1] = -1;
 588         ctx->yield[0] = '\0';
 589         if (pipe(ctx->pipe) == -1) {
 590                 ret = -errno;
 591                 DRV_LOG(ERR,
 592                         "cannot allocate control pipe for interface \"%s\": %s",
 593                         ctx->if_name, rte_strerror(errno));
 594                 goto error;
 595         }
 596         for (i = 0; i != RTE_DIM(ctx->pipe); ++i) {
 597                 int flf = fcntl(ctx->pipe[i], F_GETFL);
 598
 599                 if (flf != -1 &&
 600                     fcntl(ctx->pipe[i], F_SETFL, flf | O_NONBLOCK) != -1)
 601                         continue;
 602                 ret = -errno;
 603                 DRV_LOG(ERR, "cannot toggle non-blocking flag on control file"
 604                         " descriptor #%u (%d): %s", i, ctx->pipe[i],
 605                         rte_strerror(errno));
 606                 goto error;
 607         }
 608         /* Generate virtual device name and arguments. */
 609         i = 0;
 610         ret = snprintf(ctx->name, sizeof(ctx->name), "%s_id%u",
 611                        name, ctx->id);
 612         if (ret == -1 || (size_t)ret >= sizeof(ctx->name))
 613                 ++i;
 614         ret = snprintf(ctx->devname, sizeof(ctx->devname), "net_failsafe_vsc%u",
 615                        ctx->id);
 616         if (ret == -1 || (size_t)ret >= sizeof(ctx->devname))
 617                 ++i;
 618         ret = snprintf(ctx->devargs, sizeof(ctx->devargs),
 619                        "fd(%d),dev(net_tap_vsc%u,remote=%s)",
 620                        ctx->pipe[0], ctx->id, ctx->if_name);
 621         if (ret == -1 || (size_t)ret >= sizeof(ctx->devargs))
 622                 ++i;
 623         if (i) {
 624                 ret = -ENOBUFS;
 625                 DRV_LOG(ERR, "generated virtual device name or argument list"
 626                         " too long for interface \"%s\"", ctx->if_name);
 627                 goto error;
 628         }
 629         /* Request virtual device generation. */
 630         DRV_LOG(DEBUG, "generating virtual device \"%s\" with arguments \"%s\"",
 631                 ctx->devname, ctx->devargs);
 632         vdev_netvsc_foreach_iface(vdev_netvsc_device_probe, 0, ctx);
 633         ret = rte_eal_hotplug_add("vdev", ctx->devname, ctx->devargs);
 634         if (ret)
 635                 goto error;
 636         LIST_INSERT_HEAD(&vdev_netvsc_ctx_list, ctx, entry);
 637         ++vdev_netvsc_ctx_count;
 638         DRV_LOG(DEBUG, "added NetVSC interface \"%s\" to context list",
 639                 ctx->if_name);
 640         return 0;
 641 error:
 642         if (ctx)
 643                 vdev_netvsc_ctx_destroy(ctx);
 644         return ret;
 645 }
 646
 647 /**
 648  * Probe NetVSC interfaces.
 649  *
 650  * This function probes system netdevices according to the specified device
 651  * arguments and starts a periodic alarm callback to notify the resulting
 652  * fail-safe PMD instances of their sub-devices whereabouts.
 653  *
 654  * @param dev
 655  *   Virtual device context for driver instance.
 656  *
 657  * @return
 658  *    Always 0, even in case of errors.
 659  */
 660 static int
 661 vdev_netvsc_vdev_probe(struct rte_vdev_device *dev)
 662 {
 663         static const char *const vdev_netvsc_arg[] = {
 664                 VDEV_NETVSC_ARG_IFACE,
 665                 VDEV_NETVSC_ARG_MAC,
 666                 VDEV_NETVSC_ARG_FORCE,
 667                 VDEV_NETVSC_ARG_IGNORE,
 668                 NULL,
 669         };
 670         const char *name = rte_vdev_device_name(dev);
 671         const char *args = rte_vdev_device_args(dev);
 672         struct rte_kvargs *kvargs = rte_kvargs_parse(args ? args : "",
 673                                                      vdev_netvsc_arg);
 674         unsigned int specified = 0;
 675         unsigned int matched = 0;
 676         int force = 0;
 677         int ignore = 0;
 678         unsigned int i;
 679         int ret;
 680
 681         DRV_LOG(DEBUG, "invoked as \"%s\", using arguments \"%s\"", name, args);
 682         if (!kvargs) {
 683                 DRV_LOG(ERR, "cannot parse arguments list");
 684                 goto error;
 685         }
 686         for (i = 0; i != kvargs->count; ++i) {
 687                 const struct rte_kvargs_pair *pair = &kvargs->pairs[i];
 688
 689                 if (!strcmp(pair->key, VDEV_NETVSC_ARG_FORCE))
 690                         force = !!atoi(pair->value);
 691                 else if (!strcmp(pair->key, VDEV_NETVSC_ARG_IGNORE))
 692                         ignore = !!atoi(pair->value);
 693                 else if (!strcmp(pair->key, VDEV_NETVSC_ARG_IFACE) ||
 694                          !strcmp(pair->key, VDEV_NETVSC_ARG_MAC))
 695                         ++specified;
 696         }
 697         if (ignore) {
 698                 if (kvargs)
 699                         rte_kvargs_free(kvargs);
 700                 return 0;
 701         }
 702         if (specified > 1) {
 703                 DRV_LOG(ERR, "More than one way used to specify the netvsc"
 704                         " device.");
 705                 goto error;
 706         }
 707         rte_eal_alarm_cancel(vdev_netvsc_alarm, NULL);
 708         /* Gather interfaces. */
 709         ret = vdev_netvsc_foreach_iface(vdev_netvsc_netvsc_probe, 1, name,
 710                                         kvargs, specified, &matched);
 711         if (ret < 0)
 712                 goto error;
 713         if (specified && matched < specified) {
 714                 if (!force) {
 715                         DRV_LOG(ERR, "Cannot find the specified netvsc device");
 716                         goto error;
 717                 }
 718                 /* Try to force probing on non-netvsc specified device. */
 719                 if (vdev_netvsc_foreach_iface(vdev_netvsc_netvsc_probe, 0, name,
 720                                               kvargs, specified, &matched) < 0)
 721                         goto error;
 722                 if (matched < specified) {
 723                         DRV_LOG(ERR, "Cannot find the specified device");
 724                         goto error;
 725                 }
 726                 DRV_LOG(WARNING, "non-netvsc device was probed as netvsc");
 727         }
 728         ret = rte_eal_alarm_set(VDEV_NETVSC_PROBE_MS * 1000,
 729                                 vdev_netvsc_alarm, NULL);
 730         if (ret < 0) {
 731                 DRV_LOG(ERR, "unable to schedule alarm callback: %s",
 732                         rte_strerror(-ret));
 733                 goto error;
 734         }
 735 error:
 736         if (kvargs)
 737                 rte_kvargs_free(kvargs);
 738         ++vdev_netvsc_ctx_inst;
 739         return 0;
 740 }
 741
 742 /**
 743  * Remove driver instance.
 744  *
 745  * The alarm callback and underlying vdev_netvsc context instances are only
 746  * destroyed after the last PMD instance is removed.
 747  *
 748  * @param dev
 749  *   Virtual device context for driver instance.
 750  *
 751  * @return
 752  *   Always 0.
 753  */
 754 static int
 755 vdev_netvsc_vdev_remove(__rte_unused struct rte_vdev_device *dev)
 756 {
 757         if (--vdev_netvsc_ctx_inst)
 758                 return 0;
 759         rte_eal_alarm_cancel(vdev_netvsc_alarm, NULL);
 760         while (!LIST_EMPTY(&vdev_netvsc_ctx_list)) {
 761                 struct vdev_netvsc_ctx *ctx = LIST_FIRST(&vdev_netvsc_ctx_list);
 762
 763                 LIST_REMOVE(ctx, entry);
 764                 --vdev_netvsc_ctx_count;
 765                 vdev_netvsc_ctx_destroy(ctx);
 766         }
 767         return 0;
 768 }
 769
 770 /** Virtual device descriptor. */
 771 static struct rte_vdev_driver vdev_netvsc_vdev = {
 772         .probe = vdev_netvsc_vdev_probe,
 773         .remove = vdev_netvsc_vdev_remove,
 774 };
 775
 776 RTE_PMD_REGISTER_VDEV(VDEV_NETVSC_DRIVER, vdev_netvsc_vdev);
 777 RTE_PMD_REGISTER_ALIAS(VDEV_NETVSC_DRIVER, eth_vdev_netvsc);
 778 RTE_PMD_REGISTER_PARAM_STRING(net_vdev_netvsc,
 779                               VDEV_NETVSC_ARG_IFACE "=<string> "
 780                               VDEV_NETVSC_ARG_MAC "=<string> "
 781                               VDEV_NETVSC_ARG_FORCE "=<int> "
 782                               VDEV_NETVSC_ARG_IGNORE "=<int>");
 783
 784 /** Initialize driver log type. */
 785 RTE_INIT(vdev_netvsc_init_log)
 786 {
 787         vdev_netvsc_logtype = rte_log_register("pmd.vdev_netvsc");
 788         if (vdev_netvsc_logtype >= 0)
 789                 rte_log_set_level(vdev_netvsc_logtype, RTE_LOG_NOTICE);
 790 }
 791
 792 /** Compare function for vdev find device operation. */
 793 static int
 794 vdev_netvsc_cmp_rte_device(const struct rte_device *dev1,
 795                            __rte_unused const void *_dev2)
 796 {
 797         return strcmp(dev1->devargs->name, VDEV_NETVSC_DRIVER_NAME);
 798 }
 799
 800 /**
 801  * A callback called by vdev bus scan function to ensure this driver probing
 802  * automatically in Hyper-V VM system unless it already exists in the
 803  * devargs list.
 804  */
 805 static void
 806 vdev_netvsc_scan_callback(__rte_unused void *arg)
 807 {
 808         struct rte_vdev_device *dev;
 809         struct rte_devargs *devargs;
 810         struct rte_bus *vbus = rte_bus_find_by_name("vdev");
 811
 812         RTE_EAL_DEVARGS_FOREACH("vdev", devargs)
 813                 if (!strcmp(devargs->name, VDEV_NETVSC_DRIVER_NAME))
 814                         return;
 815         dev = (struct rte_vdev_device *)vbus->find_device(NULL,
 816                 vdev_netvsc_cmp_rte_device, VDEV_NETVSC_DRIVER_NAME);
 817         if (dev)
 818                 return;
 819         if (rte_devargs_add(RTE_DEVTYPE_VIRTUAL, VDEV_NETVSC_DRIVER_NAME))
 820                 DRV_LOG(ERR, "unable to add netvsc devargs.");
 821 }
 822
 823 /** Initialize the custom scan. */
 824 RTE_INIT(vdev_netvsc_custom_scan_add)
 825 {
 826         if (rte_hypervisor_get() == RTE_HYPERVISOR_HYPERV)
 827                 rte_vdev_add_custom_scan(vdev_netvsc_scan_callback, NULL);
 828 }