xref: /dpdk/drivers/bus/vdev/vdev.c (revision 5d7b673d) 
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2016 RehiveTech. All rights reserved.
3  */
4 
5 #include <string.h>
6 #include <inttypes.h>
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <stdint.h>
10 #include <stdbool.h>
11 #include <sys/queue.h>
12 
13 #include <rte_eal.h>
14 #include <rte_dev.h>
15 #include <rte_bus.h>
16 #include <rte_common.h>
17 #include <rte_devargs.h>
18 #include <rte_memory.h>
19 #include <rte_tailq.h>
20 #include <rte_spinlock.h>
21 #include <rte_string_fns.h>
22 #include <rte_errno.h>
23 
24 #include "rte_bus_vdev.h"
25 #include "vdev_logs.h"
26 #include "vdev_private.h"
27 
28 #define VDEV_MP_KEY	"bus_vdev_mp"
29 
30 int vdev_logtype_bus;
31 
32 /* Forward declare to access virtual bus name */
33 static struct rte_bus rte_vdev_bus;
34 
35 /** Double linked list of virtual device drivers. */
36 TAILQ_HEAD(vdev_device_list, rte_vdev_device);
37 
38 static struct vdev_device_list vdev_device_list =
39 	TAILQ_HEAD_INITIALIZER(vdev_device_list);
40 /* The lock needs to be recursive because a vdev can manage another vdev. */
41 static rte_spinlock_recursive_t vdev_device_list_lock =
42 	RTE_SPINLOCK_RECURSIVE_INITIALIZER;
43 
44 struct vdev_driver_list vdev_driver_list =
45 	TAILQ_HEAD_INITIALIZER(vdev_driver_list);
46 
47 struct vdev_custom_scan {
48 	TAILQ_ENTRY(vdev_custom_scan) next;
49 	rte_vdev_scan_callback callback;
50 	void *user_arg;
51 };
52 TAILQ_HEAD(vdev_custom_scans, vdev_custom_scan);
53 static struct vdev_custom_scans vdev_custom_scans =
54 	TAILQ_HEAD_INITIALIZER(vdev_custom_scans);
55 static rte_spinlock_t vdev_custom_scan_lock = RTE_SPINLOCK_INITIALIZER;
56 
57 /* register a driver */
58 void
59 rte_vdev_register(struct rte_vdev_driver *driver)
60 {
61 	TAILQ_INSERT_TAIL(&vdev_driver_list, driver, next);
62 }
63 
64 /* unregister a driver */
65 void
66 rte_vdev_unregister(struct rte_vdev_driver *driver)
67 {
68 	TAILQ_REMOVE(&vdev_driver_list, driver, next);
69 }
70 
71 int
72 rte_vdev_add_custom_scan(rte_vdev_scan_callback callback, void *user_arg)
73 {
74 	struct vdev_custom_scan *custom_scan;
75 
76 	rte_spinlock_lock(&vdev_custom_scan_lock);
77 
78 	/* check if already registered */
79 	TAILQ_FOREACH(custom_scan, &vdev_custom_scans, next) {
80 		if (custom_scan->callback == callback &&
81 				custom_scan->user_arg == user_arg)
82 			break;
83 	}
84 
85 	if (custom_scan == NULL) {
86 		custom_scan = malloc(sizeof(struct vdev_custom_scan));
87 		if (custom_scan != NULL) {
88 			custom_scan->callback = callback;
89 			custom_scan->user_arg = user_arg;
90 			TAILQ_INSERT_TAIL(&vdev_custom_scans, custom_scan, next);
91 		}
92 	}
93 
94 	rte_spinlock_unlock(&vdev_custom_scan_lock);
95 
96 	return (custom_scan == NULL) ? -1 : 0;
97 }
98 
99 int
100 rte_vdev_remove_custom_scan(rte_vdev_scan_callback callback, void *user_arg)
101 {
102 	struct vdev_custom_scan *custom_scan, *tmp_scan;
103 
104 	rte_spinlock_lock(&vdev_custom_scan_lock);
105 	TAILQ_FOREACH_SAFE(custom_scan, &vdev_custom_scans, next, tmp_scan) {
106 		if (custom_scan->callback != callback ||
107 				(custom_scan->user_arg != (void *)-1 &&
108 				custom_scan->user_arg != user_arg))
109 			continue;
110 		TAILQ_REMOVE(&vdev_custom_scans, custom_scan, next);
111 		free(custom_scan);
112 	}
113 	rte_spinlock_unlock(&vdev_custom_scan_lock);
114 
115 	return 0;
116 }
117 
118 static int
119 vdev_parse(const char *name, void *addr)
120 {
121 	struct rte_vdev_driver **out = addr;
122 	struct rte_vdev_driver *driver = NULL;
123 
124 	TAILQ_FOREACH(driver, &vdev_driver_list, next) {
125 		if (strncmp(driver->driver.name, name,
126 			    strlen(driver->driver.name)) == 0)
127 			break;
128 		if (driver->driver.alias &&
129 		    strncmp(driver->driver.alias, name,
130 			    strlen(driver->driver.alias)) == 0)
131 			break;
132 	}
133 	if (driver != NULL &&
134 	    addr != NULL)
135 		*out = driver;
136 	return driver == NULL;
137 }
138 
139 static int
140 vdev_probe_all_drivers(struct rte_vdev_device *dev)
141 {
142 	const char *name;
143 	struct rte_vdev_driver *driver;
144 	int ret;
145 
146 	name = rte_vdev_device_name(dev);
147 
148 	VDEV_LOG(DEBUG, "Search driver %s to probe device %s", name,
149 		rte_vdev_device_name(dev));
150 
151 	if (vdev_parse(name, &driver))
152 		return -1;
153 	ret = driver->probe(dev);
154 	if (ret == 0)
155 		dev->device.driver = &driver->driver;
156 	return ret;
157 }
158 
159 /* The caller shall be responsible for thread-safe */
160 static struct rte_vdev_device *
161 find_vdev(const char *name)
162 {
163 	struct rte_vdev_device *dev;
164 
165 	if (!name)
166 		return NULL;
167 
168 	TAILQ_FOREACH(dev, &vdev_device_list, next) {
169 		const char *devname = rte_vdev_device_name(dev);
170 
171 		if (!strcmp(devname, name))
172 			return dev;
173 	}
174 
175 	return NULL;
176 }
177 
178 static struct rte_devargs *
179 alloc_devargs(const char *name, const char *args)
180 {
181 	struct rte_devargs *devargs;
182 	int ret;
183 
184 	devargs = calloc(1, sizeof(*devargs));
185 	if (!devargs)
186 		return NULL;
187 
188 	devargs->bus = &rte_vdev_bus;
189 	if (args)
190 		devargs->args = strdup(args);
191 	else
192 		devargs->args = strdup("");
193 
194 	ret = snprintf(devargs->name, sizeof(devargs->name), "%s", name);
195 	if (ret < 0 || ret >= (int)sizeof(devargs->name)) {
196 		free(devargs->args);
197 		free(devargs);
198 		return NULL;
199 	}
200 
201 	return devargs;
202 }
203 
204 static int
205 insert_vdev(const char *name, const char *args, struct rte_vdev_device **p_dev)
206 {
207 	struct rte_vdev_device *dev;
208 	struct rte_devargs *devargs;
209 	int ret;
210 
211 	if (name == NULL)
212 		return -EINVAL;
213 
214 	devargs = alloc_devargs(name, args);
215 	if (!devargs)
216 		return -ENOMEM;
217 
218 	dev = calloc(1, sizeof(*dev));
219 	if (!dev) {
220 		ret = -ENOMEM;
221 		goto fail;
222 	}
223 
224 	dev->device.devargs = devargs;
225 	dev->device.numa_node = SOCKET_ID_ANY;
226 	dev->device.name = devargs->name;
227 
228 	if (find_vdev(name)) {
229 		/*
230 		 * A vdev is expected to have only one port.
231 		 * So there is no reason to try probing again,
232 		 * even with new arguments.
233 		 */
234 		ret = -EEXIST;
235 		goto fail;
236 	}
237 
238 	TAILQ_INSERT_TAIL(&vdev_device_list, dev, next);
239 	rte_devargs_insert(devargs);
240 
241 	if (p_dev)
242 		*p_dev = dev;
243 
244 	return 0;
245 fail:
246 	free(devargs->args);
247 	free(devargs);
248 	free(dev);
249 	return ret;
250 }
251 
252 int
253 rte_vdev_init(const char *name, const char *args)
254 {
255 	struct rte_vdev_device *dev;
256 	int ret;
257 
258 	rte_spinlock_recursive_lock(&vdev_device_list_lock);
259 	ret = insert_vdev(name, args, &dev);
260 	if (ret == 0) {
261 		ret = vdev_probe_all_drivers(dev);
262 		if (ret) {
263 			if (ret > 0)
264 				VDEV_LOG(ERR, "no driver found for %s", name);
265 			/* If fails, remove it from vdev list */
266 			TAILQ_REMOVE(&vdev_device_list, dev, next);
267 			rte_devargs_remove(dev->device.devargs);
268 			free(dev);
269 		}
270 	}
271 	rte_spinlock_recursive_unlock(&vdev_device_list_lock);
272 	return ret;
273 }
274 
275 static int
276 vdev_remove_driver(struct rte_vdev_device *dev)
277 {
278 	const char *name = rte_vdev_device_name(dev);
279 	const struct rte_vdev_driver *driver;
280 
281 	if (!dev->device.driver) {
282 		VDEV_LOG(DEBUG, "no driver attach to device %s", name);
283 		return 1;
284 	}
285 
286 	driver = container_of(dev->device.driver, const struct rte_vdev_driver,
287 		driver);
288 	return driver->remove(dev);
289 }
290 
291 int
292 rte_vdev_uninit(const char *name)
293 {
294 	struct rte_vdev_device *dev;
295 	int ret;
296 
297 	if (name == NULL)
298 		return -EINVAL;
299 
300 	rte_spinlock_recursive_lock(&vdev_device_list_lock);
301 
302 	dev = find_vdev(name);
303 	if (!dev) {
304 		ret = -ENOENT;
305 		goto unlock;
306 	}
307 
308 	ret = vdev_remove_driver(dev);
309 	if (ret)
310 		goto unlock;
311 
312 	TAILQ_REMOVE(&vdev_device_list, dev, next);
313 	rte_devargs_remove(dev->device.devargs);
314 	free(dev);
315 
316 unlock:
317 	rte_spinlock_recursive_unlock(&vdev_device_list_lock);
318 	return ret;
319 }
320 
321 struct vdev_param {
322 #define VDEV_SCAN_REQ	1
323 #define VDEV_SCAN_ONE	2
324 #define VDEV_SCAN_REP	3
325 	int type;
326 	int num;
327 	char name[RTE_DEV_NAME_MAX_LEN];
328 };
329 
330 static int vdev_plug(struct rte_device *dev);
331 
332 /**
333  * This function works as the action for both primary and secondary process
334  * for static vdev discovery when a secondary process is booting.
335  *
336  * step 1, secondary process sends a sync request to ask for vdev in primary;
337  * step 2, primary process receives the request, and send vdevs one by one;
338  * step 3, primary process sends back reply, which indicates how many vdevs
339  * are sent.
340  */
341 static int
342 vdev_action(const struct rte_mp_msg *mp_msg, const void *peer)
343 {
344 	struct rte_vdev_device *dev;
345 	struct rte_mp_msg mp_resp;
346 	struct vdev_param *ou = (struct vdev_param *)&mp_resp.param;
347 	const struct vdev_param *in = (const struct vdev_param *)mp_msg->param;
348 	const char *devname;
349 	int num;
350 	int ret;
351 
352 	strlcpy(mp_resp.name, VDEV_MP_KEY, sizeof(mp_resp.name));
353 	mp_resp.len_param = sizeof(*ou);
354 	mp_resp.num_fds = 0;
355 
356 	switch (in->type) {
357 	case VDEV_SCAN_REQ:
358 		ou->type = VDEV_SCAN_ONE;
359 		ou->num = 1;
360 		num = 0;
361 
362 		rte_spinlock_recursive_lock(&vdev_device_list_lock);
363 		TAILQ_FOREACH(dev, &vdev_device_list, next) {
364 			devname = rte_vdev_device_name(dev);
365 			if (strlen(devname) == 0) {
366 				VDEV_LOG(INFO, "vdev with no name is not sent");
367 				continue;
368 			}
369 			VDEV_LOG(INFO, "send vdev, %s", devname);
370 			strlcpy(ou->name, devname, RTE_DEV_NAME_MAX_LEN);
371 			if (rte_mp_sendmsg(&mp_resp) < 0)
372 				VDEV_LOG(ERR, "send vdev, %s, failed, %s",
373 					 devname, strerror(rte_errno));
374 			num++;
375 		}
376 		rte_spinlock_recursive_unlock(&vdev_device_list_lock);
377 
378 		ou->type = VDEV_SCAN_REP;
379 		ou->num = num;
380 		if (rte_mp_reply(&mp_resp, peer) < 0)
381 			VDEV_LOG(ERR, "Failed to reply a scan request");
382 		break;
383 	case VDEV_SCAN_ONE:
384 		VDEV_LOG(INFO, "receive vdev, %s", in->name);
385 		ret = insert_vdev(in->name, NULL, NULL);
386 		if (ret == -EEXIST)
387 			VDEV_LOG(DEBUG, "device already exist, %s", in->name);
388 		else if (ret < 0)
389 			VDEV_LOG(ERR, "failed to add vdev, %s", in->name);
390 		break;
391 	default:
392 		VDEV_LOG(ERR, "vdev cannot recognize this message");
393 	}
394 
395 	return 0;
396 }
397 
398 static int
399 vdev_scan(void)
400 {
401 	struct rte_vdev_device *dev;
402 	struct rte_devargs *devargs;
403 	struct vdev_custom_scan *custom_scan;
404 
405 	if (rte_mp_action_register(VDEV_MP_KEY, vdev_action) < 0 &&
406 	    rte_errno != EEXIST) {
407 		VDEV_LOG(ERR, "Failed to add vdev mp action");
408 		return -1;
409 	}
410 
411 	if (rte_eal_process_type() == RTE_PROC_SECONDARY) {
412 		struct rte_mp_msg mp_req, *mp_rep;
413 		struct rte_mp_reply mp_reply;
414 		struct timespec ts = {.tv_sec = 5, .tv_nsec = 0};
415 		struct vdev_param *req = (struct vdev_param *)mp_req.param;
416 		struct vdev_param *resp;
417 
418 		strlcpy(mp_req.name, VDEV_MP_KEY, sizeof(mp_req.name));
419 		mp_req.len_param = sizeof(*req);
420 		mp_req.num_fds = 0;
421 		req->type = VDEV_SCAN_REQ;
422 		if (rte_mp_request_sync(&mp_req, &mp_reply, &ts) == 0 &&
423 		    mp_reply.nb_received == 1) {
424 			mp_rep = &mp_reply.msgs[0];
425 			resp = (struct vdev_param *)mp_rep->param;
426 			VDEV_LOG(INFO, "Received %d vdevs", resp->num);
427 		} else
428 			VDEV_LOG(ERR, "Failed to request vdev from primary");
429 
430 		/* Fall through to allow private vdevs in secondary process */
431 	}
432 
433 	/* call custom scan callbacks if any */
434 	rte_spinlock_lock(&vdev_custom_scan_lock);
435 	TAILQ_FOREACH(custom_scan, &vdev_custom_scans, next) {
436 		if (custom_scan->callback != NULL)
437 			/*
438 			 * the callback should update devargs list
439 			 * by calling rte_devargs_insert() with
440 			 *     devargs.bus = rte_bus_find_by_name("vdev");
441 			 *     devargs.type = RTE_DEVTYPE_VIRTUAL;
442 			 *     devargs.policy = RTE_DEV_WHITELISTED;
443 			 */
444 			custom_scan->callback(custom_scan->user_arg);
445 	}
446 	rte_spinlock_unlock(&vdev_custom_scan_lock);
447 
448 	/* for virtual devices we scan the devargs_list populated via cmdline */
449 	RTE_EAL_DEVARGS_FOREACH("vdev", devargs) {
450 
451 		dev = calloc(1, sizeof(*dev));
452 		if (!dev)
453 			return -1;
454 
455 		rte_spinlock_recursive_lock(&vdev_device_list_lock);
456 
457 		if (find_vdev(devargs->name)) {
458 			rte_spinlock_recursive_unlock(&vdev_device_list_lock);
459 			free(dev);
460 			continue;
461 		}
462 
463 		dev->device.bus = &rte_vdev_bus;
464 		dev->device.devargs = devargs;
465 		dev->device.numa_node = SOCKET_ID_ANY;
466 		dev->device.name = devargs->name;
467 
468 		TAILQ_INSERT_TAIL(&vdev_device_list, dev, next);
469 
470 		rte_spinlock_recursive_unlock(&vdev_device_list_lock);
471 	}
472 
473 	return 0;
474 }
475 
476 static int
477 vdev_probe(void)
478 {
479 	struct rte_vdev_device *dev;
480 	int ret = 0;
481 
482 	/* call the init function for each virtual device */
483 	TAILQ_FOREACH(dev, &vdev_device_list, next) {
484 		/* we don't use the vdev lock here, as it's only used in DPDK
485 		 * initialization; and we don't want to hold such a lock when
486 		 * we call each driver probe.
487 		 */
488 
489 		if (rte_dev_is_probed(&dev->device))
490 			continue;
491 
492 		if (vdev_probe_all_drivers(dev)) {
493 			VDEV_LOG(ERR, "failed to initialize %s device",
494 				rte_vdev_device_name(dev));
495 			ret = -1;
496 		}
497 	}
498 
499 	return ret;
500 }
501 
502 struct rte_device *
503 rte_vdev_find_device(const struct rte_device *start, rte_dev_cmp_t cmp,
504 		     const void *data)
505 {
506 	const struct rte_vdev_device *vstart;
507 	struct rte_vdev_device *dev;
508 
509 	rte_spinlock_recursive_lock(&vdev_device_list_lock);
510 	if (start != NULL) {
511 		vstart = RTE_DEV_TO_VDEV_CONST(start);
512 		dev = TAILQ_NEXT(vstart, next);
513 	} else {
514 		dev = TAILQ_FIRST(&vdev_device_list);
515 	}
516 	while (dev != NULL) {
517 		if (cmp(&dev->device, data) == 0)
518 			break;
519 		dev = TAILQ_NEXT(dev, next);
520 	}
521 	rte_spinlock_recursive_unlock(&vdev_device_list_lock);
522 
523 	return dev ? &dev->device : NULL;
524 }
525 
526 static int
527 vdev_plug(struct rte_device *dev)
528 {
529 	return vdev_probe_all_drivers(RTE_DEV_TO_VDEV(dev));
530 }
531 
532 static int
533 vdev_unplug(struct rte_device *dev)
534 {
535 	return rte_vdev_uninit(dev->name);
536 }
537 
538 static struct rte_bus rte_vdev_bus = {
539 	.scan = vdev_scan,
540 	.probe = vdev_probe,
541 	.find_device = rte_vdev_find_device,
542 	.plug = vdev_plug,
543 	.unplug = vdev_unplug,
544 	.parse = vdev_parse,
545 	.dev_iterate = rte_vdev_dev_iterate,
546 };
547 
548 RTE_REGISTER_BUS(vdev, rte_vdev_bus);
549 
550 RTE_INIT(vdev_init_log)
551 {
552 	vdev_logtype_bus = rte_log_register("bus.vdev");
553 	if (vdev_logtype_bus >= 0)
554 		rte_log_set_level(vdev_logtype_bus, RTE_LOG_NOTICE);
555 }
556