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_dev.h>
31 #include <rte_errno.h>
32 #include <rte_ethdev.h>
33 #include <rte_ether.h>
34 #include <rte_hypervisor.h>
35 #include <rte_kvargs.h>
36 #include <rte_log.h>
37 #include <rte_string_fns.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_DRIVER_NAME_LEN 15
42 #define VDEV_NETVSC_ARG_IFACE "iface"
43 #define VDEV_NETVSC_ARG_MAC "mac"
44 #define VDEV_NETVSC_ARG_FORCE "force"
45 #define VDEV_NETVSC_ARG_IGNORE "ignore"
46 #define VDEV_NETVSC_PROBE_MS 1000
47
48 #define NETVSC_CLASS_ID "{f8615163-df3e-46c5-913f-f2d2f965ed0e}"
49 #define NETVSC_MAX_ROUTE_LINE_SIZE 300
50
51 RTE_LOG_REGISTER(vdev_netvsc_logtype, pmd.net.vdev_netvsc, NOTICE);
52
53 #define DRV_LOG(level, ...) \
54 rte_log(RTE_LOG_ ## level, \
55 vdev_netvsc_logtype, \
56 RTE_FMT(VDEV_NETVSC_DRIVER_NAME ": " \
57 RTE_FMT_HEAD(__VA_ARGS__,) "\n", \
58 RTE_FMT_TAIL(__VA_ARGS__,)))
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 rte_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
vdev_netvsc_ctx_destroy(struct vdev_netvsc_ctx * ctx)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
vdev_netvsc_iface_is_netvsc(const struct if_nameindex * iface)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
vdev_netvsc_foreach_iface(int (* func)(const struct if_nameindex * iface,const struct rte_ether_addr * eth_addr,va_list ap),int is_netvsc,...)157 vdev_netvsc_foreach_iface(int (*func)(const struct if_nameindex *iface,
158 const struct rte_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 rte_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 strlcpy(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 continue;
194 memcpy(eth_addr.addr_bytes, req.ifr_hwaddr.sa_data,
195 RTE_DIM(eth_addr.addr_bytes));
196 va_start(ap, is_netvsc);
197 ret = func(&iface[i], ð_addr, ap);
198 va_end(ap);
199 if (ret)
200 break;
201 }
202 error:
203 if (s != -1)
204 close(s);
205 if (iface)
206 if_freenameindex(iface);
207 return ret;
208 }
209
210 /**
211 * Determine if a network interface has a route.
212 *
213 * @param[in] name
214 * Network device name.
215 * @param[in] family
216 * Address family: AF_INET for IPv4 or AF_INET6 for IPv6.
217 *
218 * @return
219 * 1 when interface has a route, negative errno value in case of error and
220 * 0 otherwise.
221 */
222 static int
vdev_netvsc_has_route(const struct if_nameindex * iface,const unsigned char family)223 vdev_netvsc_has_route(const struct if_nameindex *iface,
224 const unsigned char family)
225 {
226 /*
227 * The implementation can be simpler by getifaddrs() function usage but
228 * it works for IPv6 only starting from glibc 2.3.3.
229 */
230 char buf[4096];
231 int len;
232 int ret = 0;
233 int res;
234 int sock;
235 struct nlmsghdr *retmsg = (struct nlmsghdr *)buf;
236 struct sockaddr_nl sa;
237 struct {
238 struct nlmsghdr nlhdr;
239 struct ifaddrmsg addrmsg;
240 } msg;
241
242 if (!iface || (family != AF_INET && family != AF_INET6)) {
243 DRV_LOG(ERR, "%s", rte_strerror(EINVAL));
244 return -EINVAL;
245 }
246 sock = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
247 if (sock == -1) {
248 DRV_LOG(ERR, "cannot open socket: %s", rte_strerror(errno));
249 return -errno;
250 }
251 memset(&sa, 0, sizeof(sa));
252 sa.nl_family = AF_NETLINK;
253 sa.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR;
254 res = bind(sock, (struct sockaddr *)&sa, sizeof(sa));
255 if (res == -1) {
256 ret = -errno;
257 DRV_LOG(ERR, "cannot bind socket: %s", rte_strerror(errno));
258 goto close;
259 }
260 memset(&msg, 0, sizeof(msg));
261 msg.nlhdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
262 msg.nlhdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
263 msg.nlhdr.nlmsg_type = RTM_GETADDR;
264 msg.nlhdr.nlmsg_pid = getpid();
265 msg.addrmsg.ifa_family = family;
266 msg.addrmsg.ifa_index = iface->if_index;
267 res = send(sock, &msg, msg.nlhdr.nlmsg_len, 0);
268 if (res == -1) {
269 ret = -errno;
270 DRV_LOG(ERR, "cannot send socket message: %s",
271 rte_strerror(errno));
272 goto close;
273 }
274 memset(buf, 0, sizeof(buf));
275 len = recv(sock, buf, sizeof(buf), 0);
276 if (len == -1) {
277 ret = -errno;
278 DRV_LOG(ERR, "cannot receive socket message: %s",
279 rte_strerror(errno));
280 goto close;
281 }
282 while (NLMSG_OK(retmsg, (unsigned int)len)) {
283 struct ifaddrmsg *retaddr =
284 (struct ifaddrmsg *)NLMSG_DATA(retmsg);
285
286 if (retaddr->ifa_family == family &&
287 retaddr->ifa_index == iface->if_index) {
288 struct rtattr *retrta = IFA_RTA(retaddr);
289 int attlen = IFA_PAYLOAD(retmsg);
290
291 while (RTA_OK(retrta, attlen)) {
292 if (retrta->rta_type == IFA_ADDRESS) {
293 ret = 1;
294 DRV_LOG(DEBUG, "interface %s has IP",
295 iface->if_name);
296 goto close;
297 }
298 retrta = RTA_NEXT(retrta, attlen);
299 }
300 }
301 retmsg = NLMSG_NEXT(retmsg, len);
302 }
303 close:
304 close(sock);
305 return ret;
306 }
307
308 /**
309 * Retrieve network interface data from sysfs symbolic link.
310 *
311 * @param[out] buf
312 * Output data buffer.
313 * @param size
314 * Output buffer size.
315 * @param[in] if_name
316 * Netdevice name.
317 * @param[in] relpath
318 * Symbolic link path relative to netdevice sysfs entry.
319 *
320 * @return
321 * 0 on success, a negative error code otherwise.
322 */
323 static int
vdev_netvsc_sysfs_readlink(char * buf,size_t size,const char * if_name,const char * relpath)324 vdev_netvsc_sysfs_readlink(char *buf, size_t size, const char *if_name,
325 const char *relpath)
326 {
327 struct vdev_netvsc_ctx *ctx;
328 char in[RTE_MAX(sizeof(ctx->yield), 256u)];
329 int ret;
330
331 ret = snprintf(in, sizeof(in), "/sys/class/net/%s/%s",
332 if_name, relpath);
333 if (ret == -1 || (size_t)ret >= sizeof(in))
334 return -ENOBUFS;
335 ret = readlink(in, 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
vdev_netvsc_device_probe(const struct if_nameindex * iface,const struct rte_ether_addr * eth_addr,va_list ap)368 vdev_netvsc_device_probe(const struct if_nameindex *iface,
369 const struct rte_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 strlcpy(ctx->if_name, iface->if_name, sizeof(ctx->if_name));
386 return 0;
387 }
388 if (!rte_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
vdev_netvsc_alarm(__rte_unused void * arg)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
vdev_netvsc_netvsc_probe(const struct if_nameindex * iface,const struct rte_ether_addr * eth_addr,va_list ap)507 vdev_netvsc_netvsc_probe(const struct if_nameindex *iface,
508 const struct rte_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 rte_ether_addr tmp;
529
530 if (rte_ether_unformat_addr(pair->value, &tmp) != 0) {
531 DRV_LOG(ERR,
532 "invalid MAC address format"
533 " \"%s\"",
534 pair->value);
535 return -EINVAL;
536 }
537 if (rte_is_same_ether_addr(eth_addr, &tmp))
538 break;
539 }
540 }
541 if (i == kvargs->count)
542 return 0;
543 ++(*matched);
544 }
545 /* Weed out interfaces already handled. */
546 LIST_FOREACH(ctx, &vdev_netvsc_ctx_list, entry)
547 if (ctx->if_index == iface->if_index)
548 break;
549 if (ctx) {
550 if (!specified)
551 return 0;
552 DRV_LOG(WARNING,
553 "interface \"%s\" (index %u) is already handled,"
554 " skipping",
555 iface->if_name, iface->if_index);
556 return 0;
557 }
558 /* Routed NetVSC should not be probed. */
559 if (vdev_netvsc_has_route(iface, AF_INET) ||
560 vdev_netvsc_has_route(iface, AF_INET6)) {
561 if (!specified)
562 return 0;
563 DRV_LOG(WARNING, "probably using routed NetVSC interface \"%s\""
564 " (index %u)", iface->if_name, iface->if_index);
565 }
566 /* Create interface context. */
567 ctx = calloc(1, sizeof(*ctx));
568 if (!ctx) {
569 ret = -errno;
570 DRV_LOG(ERR, "cannot allocate context for interface \"%s\": %s",
571 iface->if_name, rte_strerror(errno));
572 goto error;
573 }
574 ctx->id = vdev_netvsc_ctx_count;
575 strlcpy(ctx->if_name, iface->if_name, sizeof(ctx->if_name));
576 ctx->if_index = iface->if_index;
577 ctx->if_addr = *eth_addr;
578 ctx->pipe[0] = -1;
579 ctx->pipe[1] = -1;
580 ctx->yield[0] = '\0';
581 if (pipe(ctx->pipe) == -1) {
582 ret = -errno;
583 DRV_LOG(ERR,
584 "cannot allocate control pipe for interface \"%s\": %s",
585 ctx->if_name, rte_strerror(errno));
586 goto error;
587 }
588 for (i = 0; i != RTE_DIM(ctx->pipe); ++i) {
589 int flf = fcntl(ctx->pipe[i], F_GETFL);
590
591 if (flf != -1 &&
592 fcntl(ctx->pipe[i], F_SETFL, flf | O_NONBLOCK) != -1)
593 continue;
594 ret = -errno;
595 DRV_LOG(ERR, "cannot toggle non-blocking flag on control file"
596 " descriptor #%u (%d): %s", i, ctx->pipe[i],
597 rte_strerror(errno));
598 goto error;
599 }
600 /* Generate virtual device name and arguments. */
601 i = 0;
602 ret = snprintf(ctx->name, sizeof(ctx->name), "%s_id%u",
603 name, ctx->id);
604 if (ret == -1 || (size_t)ret >= sizeof(ctx->name))
605 ++i;
606 ret = snprintf(ctx->devname, sizeof(ctx->devname), "net_failsafe_vsc%u",
607 ctx->id);
608 if (ret == -1 || (size_t)ret >= sizeof(ctx->devname))
609 ++i;
610 ret = snprintf(ctx->devargs, sizeof(ctx->devargs),
611 "fd(%d),dev(net_tap_vsc%u,remote=%s)",
612 ctx->pipe[0], ctx->id, ctx->if_name);
613 if (ret == -1 || (size_t)ret >= sizeof(ctx->devargs))
614 ++i;
615 if (i) {
616 ret = -ENOBUFS;
617 DRV_LOG(ERR, "generated virtual device name or argument list"
618 " too long for interface \"%s\"", ctx->if_name);
619 goto error;
620 }
621 /* Request virtual device generation. */
622 DRV_LOG(DEBUG, "generating virtual device \"%s\" with arguments \"%s\"",
623 ctx->devname, ctx->devargs);
624 vdev_netvsc_foreach_iface(vdev_netvsc_device_probe, 0, ctx);
625 ret = rte_eal_hotplug_add("vdev", ctx->devname, ctx->devargs);
626 if (ret < 0)
627 goto error;
628 LIST_INSERT_HEAD(&vdev_netvsc_ctx_list, ctx, entry);
629 ++vdev_netvsc_ctx_count;
630 DRV_LOG(DEBUG, "added NetVSC interface \"%s\" to context list",
631 ctx->if_name);
632 return 0;
633 error:
634 if (ctx)
635 vdev_netvsc_ctx_destroy(ctx);
636 return ret;
637 }
638
639 /**
640 * Probe NetVSC interfaces.
641 *
642 * This function probes system netdevices according to the specified device
643 * arguments and starts a periodic alarm callback to notify the resulting
644 * fail-safe PMD instances of their sub-devices whereabouts.
645 *
646 * @param dev
647 * Virtual device context for driver instance.
648 *
649 * @return
650 * Always 0, even in case of errors.
651 */
652 static int
vdev_netvsc_vdev_probe(struct rte_vdev_device * dev)653 vdev_netvsc_vdev_probe(struct rte_vdev_device *dev)
654 {
655 static const char *const vdev_netvsc_arg[] = {
656 VDEV_NETVSC_ARG_IFACE,
657 VDEV_NETVSC_ARG_MAC,
658 VDEV_NETVSC_ARG_FORCE,
659 VDEV_NETVSC_ARG_IGNORE,
660 NULL,
661 };
662 const char *name = rte_vdev_device_name(dev);
663 const char *args = rte_vdev_device_args(dev);
664 struct rte_kvargs *kvargs = rte_kvargs_parse(args ? args : "",
665 vdev_netvsc_arg);
666 unsigned int specified = 0;
667 unsigned int matched = 0;
668 int force = 0;
669 int ignore = 0;
670 unsigned int i;
671 int ret;
672
673 DRV_LOG(DEBUG, "invoked as \"%s\", using arguments \"%s\"", name, args);
674 rte_eal_alarm_cancel(vdev_netvsc_alarm, NULL);
675 if (!kvargs) {
676 DRV_LOG(ERR, "cannot parse arguments list");
677 goto error;
678 }
679 for (i = 0; i != kvargs->count; ++i) {
680 const struct rte_kvargs_pair *pair = &kvargs->pairs[i];
681
682 if (!strcmp(pair->key, VDEV_NETVSC_ARG_FORCE))
683 force = !!atoi(pair->value);
684 else if (!strcmp(pair->key, VDEV_NETVSC_ARG_IGNORE))
685 ignore = !!atoi(pair->value);
686 else if (!strcmp(pair->key, VDEV_NETVSC_ARG_IFACE) ||
687 !strcmp(pair->key, VDEV_NETVSC_ARG_MAC))
688 ++specified;
689 }
690 if (ignore)
691 goto ignore;
692 if (specified > 1) {
693 DRV_LOG(ERR, "More than one way used to specify the netvsc"
694 " device.");
695 goto error;
696 }
697 /* Gather interfaces. */
698 ret = vdev_netvsc_foreach_iface(vdev_netvsc_netvsc_probe, 1, name,
699 kvargs, specified, &matched);
700 if (ret < 0)
701 goto error;
702 if (specified && matched < specified) {
703 if (!force) {
704 DRV_LOG(ERR, "Cannot find the specified netvsc device");
705 goto error;
706 }
707 /* Try to force probing on non-netvsc specified device. */
708 if (vdev_netvsc_foreach_iface(vdev_netvsc_netvsc_probe, 0, name,
709 kvargs, specified, &matched) < 0)
710 goto error;
711 if (matched < specified) {
712 DRV_LOG(ERR, "Cannot find the specified device");
713 goto error;
714 }
715 DRV_LOG(WARNING, "non-netvsc device was probed as netvsc");
716 }
717 error:
718 ++vdev_netvsc_ctx_inst;
719 ignore:
720 if (kvargs)
721 rte_kvargs_free(kvargs);
722 /* Reset alarm if there are device context created */
723 if (vdev_netvsc_ctx_count) {
724 ret = rte_eal_alarm_set(VDEV_NETVSC_PROBE_MS * 1000,
725 vdev_netvsc_alarm, NULL);
726 if (ret < 0)
727 DRV_LOG(ERR, "unable to schedule alarm callback: %s",
728 rte_strerror(-ret));
729 }
730 return 0;
731 }
732
733 /**
734 * Remove driver instance.
735 *
736 * The alarm callback and underlying vdev_netvsc context instances are only
737 * destroyed after the last PMD instance is removed.
738 *
739 * @param dev
740 * Virtual device context for driver instance.
741 *
742 * @return
743 * Always 0.
744 */
745 static int
vdev_netvsc_vdev_remove(__rte_unused struct rte_vdev_device * dev)746 vdev_netvsc_vdev_remove(__rte_unused struct rte_vdev_device *dev)
747 {
748 if (--vdev_netvsc_ctx_inst)
749 return 0;
750 rte_eal_alarm_cancel(vdev_netvsc_alarm, NULL);
751 while (!LIST_EMPTY(&vdev_netvsc_ctx_list)) {
752 struct vdev_netvsc_ctx *ctx = LIST_FIRST(&vdev_netvsc_ctx_list);
753
754 LIST_REMOVE(ctx, entry);
755 --vdev_netvsc_ctx_count;
756 vdev_netvsc_ctx_destroy(ctx);
757 }
758 return 0;
759 }
760
761 /** Virtual device descriptor. */
762 static struct rte_vdev_driver vdev_netvsc_vdev = {
763 .probe = vdev_netvsc_vdev_probe,
764 .remove = vdev_netvsc_vdev_remove,
765 };
766
767 RTE_PMD_REGISTER_VDEV(VDEV_NETVSC_DRIVER, vdev_netvsc_vdev);
768 RTE_PMD_REGISTER_ALIAS(VDEV_NETVSC_DRIVER, eth_vdev_netvsc);
769 RTE_PMD_REGISTER_PARAM_STRING(net_vdev_netvsc,
770 VDEV_NETVSC_ARG_IFACE "=<string> "
771 VDEV_NETVSC_ARG_MAC "=<string> "
772 VDEV_NETVSC_ARG_FORCE "=<int> "
773 VDEV_NETVSC_ARG_IGNORE "=<int>");
774
775 /** Compare function for vdev find device operation. */
776 static int
vdev_netvsc_cmp_rte_device(const struct rte_device * dev1,__rte_unused const void * _dev2)777 vdev_netvsc_cmp_rte_device(const struct rte_device *dev1,
778 __rte_unused const void *_dev2)
779 {
780 return strncmp(dev1->devargs->name, VDEV_NETVSC_DRIVER_NAME,
781 VDEV_NETVSC_DRIVER_NAME_LEN);
782 }
783
784 /**
785 * A callback called by vdev bus scan function to ensure this driver probing
786 * automatically in Hyper-V VM system unless it already exists in the
787 * devargs list.
788 */
789 static void
vdev_netvsc_scan_callback(__rte_unused void * arg)790 vdev_netvsc_scan_callback(__rte_unused void *arg)
791 {
792 struct rte_device *dev;
793 struct rte_devargs *devargs;
794 struct rte_bus *vbus = rte_bus_find_by_name("vdev");
795
796 RTE_EAL_DEVARGS_FOREACH("vdev", devargs)
797 if (!strncmp(devargs->name, VDEV_NETVSC_DRIVER_NAME,
798 VDEV_NETVSC_DRIVER_NAME_LEN))
799 return;
800
801 dev = vbus->find_device(NULL, vdev_netvsc_cmp_rte_device,
802 VDEV_NETVSC_DRIVER_NAME);
803 if (dev)
804 return;
805 if (rte_devargs_add(RTE_DEVTYPE_VIRTUAL, VDEV_NETVSC_DRIVER_NAME))
806 DRV_LOG(ERR, "unable to add netvsc devargs.");
807 }
808
809 /** Initialize the custom scan. */
RTE_INIT(vdev_netvsc_custom_scan_add)810 RTE_INIT(vdev_netvsc_custom_scan_add)
811 {
812 if (rte_hypervisor_get() == RTE_HYPERVISOR_HYPERV)
813 rte_vdev_add_custom_scan(vdev_netvsc_scan_callback, NULL);
814 }
815