xref: /dpdk/lib/eal/common/eal_common_devargs.c (revision 03ab51eafda992874a48c392ca66ffb577fe2b71)
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright 2014 6WIND S.A.
3  */
4 
5 /* This file manages the list of devices and their arguments, as given
6  * by the user at startup
7  */
8 
9 #include <stdio.h>
10 #include <string.h>
11 #include <stdarg.h>
12 
13 #include <rte_bus.h>
14 #include <rte_class.h>
15 #include <rte_compat.h>
16 #include <rte_dev.h>
17 #include <rte_devargs.h>
18 #include <rte_errno.h>
19 #include <rte_kvargs.h>
20 #include <rte_log.h>
21 #include <rte_tailq.h>
22 #include <rte_string_fns.h>
23 #include "eal_private.h"
24 
25 /** user device double-linked queue type definition */
26 TAILQ_HEAD(rte_devargs_list, rte_devargs);
27 
28 /** Global list of user devices */
29 static struct rte_devargs_list devargs_list =
30 	TAILQ_HEAD_INITIALIZER(devargs_list);
31 
32 static size_t
33 devargs_layer_count(const char *s)
34 {
35 	size_t i = s ? 1 : 0;
36 
37 	while (s != NULL && s[0] != '\0') {
38 		i += s[0] == '/';
39 		s++;
40 	}
41 	return i;
42 }
43 
44 /* Resolve devargs name from bus arguments. */
45 static int
46 devargs_bus_parse_default(struct rte_devargs *devargs,
47 			  struct rte_kvargs *bus_args)
48 {
49 	const char *name;
50 
51 	/* Parse devargs name from bus key-value list. */
52 	name = rte_kvargs_get(bus_args, "name");
53 	if (name == NULL) {
54 		RTE_LOG(INFO, EAL, "devargs name not found: %s\n",
55 			devargs->data);
56 		return 0;
57 	}
58 	if (rte_strscpy(devargs->name, name, sizeof(devargs->name)) < 0) {
59 		RTE_LOG(ERR, EAL, "devargs name too long: %s\n",
60 			devargs->data);
61 		return -E2BIG;
62 	}
63 	return 0;
64 }
65 
66 int
67 rte_devargs_layers_parse(struct rte_devargs *devargs,
68 			 const char *devstr)
69 {
70 	struct {
71 		const char *key;
72 		const char *str;
73 		struct rte_kvargs *kvlist;
74 	} layers[] = {
75 		{ RTE_DEVARGS_KEY_BUS "=",    NULL, NULL, },
76 		{ RTE_DEVARGS_KEY_CLASS "=",  NULL, NULL, },
77 		{ RTE_DEVARGS_KEY_DRIVER "=", NULL, NULL, },
78 	};
79 	struct rte_kvargs_pair *kv = NULL;
80 	struct rte_class *cls = NULL;
81 	struct rte_bus *bus = NULL;
82 	const char *s = devstr;
83 	size_t nblayer;
84 	size_t i = 0;
85 	int ret = 0;
86 	bool allocated_data = false;
87 
88 	/* Split each sub-lists. */
89 	nblayer = devargs_layer_count(devstr);
90 	if (nblayer > RTE_DIM(layers)) {
91 		RTE_LOG(ERR, EAL, "Invalid format: too many layers (%zu)\n",
92 			nblayer);
93 		ret = -E2BIG;
94 		goto get_out;
95 	}
96 
97 	/* If the devargs points the devstr
98 	 * as source data, then it should not allocate
99 	 * anything and keep referring only to it.
100 	 */
101 	if (devargs->data != devstr) {
102 		devargs->data = strdup(devstr);
103 		if (devargs->data == NULL) {
104 			RTE_LOG(ERR, EAL, "OOM\n");
105 			ret = -ENOMEM;
106 			goto get_out;
107 		}
108 		allocated_data = true;
109 		s = devargs->data;
110 	}
111 
112 	while (s != NULL) {
113 		if (i >= RTE_DIM(layers)) {
114 			RTE_LOG(ERR, EAL, "Unrecognized layer %s\n", s);
115 			ret = -EINVAL;
116 			goto get_out;
117 		}
118 		/*
119 		 * The last layer is free-form.
120 		 * The "driver" key is not required (but accepted).
121 		 */
122 		if (strncmp(layers[i].key, s, strlen(layers[i].key)) &&
123 				i != RTE_DIM(layers) - 1)
124 			goto next_layer;
125 		layers[i].str = s;
126 		layers[i].kvlist = rte_kvargs_parse_delim(s, NULL, "/");
127 		if (layers[i].kvlist == NULL) {
128 			ret = -EINVAL;
129 			goto get_out;
130 		}
131 		s = strchr(s, '/');
132 		if (s != NULL)
133 			s++;
134 next_layer:
135 		i++;
136 	}
137 
138 	/* Parse each sub-list. */
139 	for (i = 0; i < RTE_DIM(layers); i++) {
140 		if (layers[i].kvlist == NULL)
141 			continue;
142 		kv = &layers[i].kvlist->pairs[0];
143 		if (kv->key == NULL)
144 			continue;
145 		if (strcmp(kv->key, RTE_DEVARGS_KEY_BUS) == 0) {
146 			bus = rte_bus_find_by_name(kv->value);
147 			if (bus == NULL) {
148 				RTE_LOG(ERR, EAL, "Could not find bus \"%s\"\n",
149 					kv->value);
150 				ret = -EFAULT;
151 				goto get_out;
152 			}
153 		} else if (strcmp(kv->key, RTE_DEVARGS_KEY_CLASS) == 0) {
154 			cls = rte_class_find_by_name(kv->value);
155 			if (cls == NULL) {
156 				RTE_LOG(ERR, EAL, "Could not find class \"%s\"\n",
157 					kv->value);
158 				ret = -EFAULT;
159 				goto get_out;
160 			}
161 		} else if (strcmp(kv->key, RTE_DEVARGS_KEY_DRIVER) == 0) {
162 			/* Ignore */
163 			continue;
164 		}
165 	}
166 
167 	/* Fill devargs fields. */
168 	devargs->bus_str = layers[0].str;
169 	devargs->cls_str = layers[1].str;
170 	devargs->drv_str = layers[2].str;
171 	devargs->bus = bus;
172 	devargs->cls = cls;
173 
174 	/* If we own the data, clean up a bit
175 	 * the several layers string, to ease
176 	 * their parsing afterward.
177 	 */
178 	if (devargs->data != devstr) {
179 		char *s = devargs->data;
180 
181 		while ((s = strchr(s, '/'))) {
182 			*s = '\0';
183 			s++;
184 		}
185 	}
186 
187 	/* Resolve devargs name. */
188 	if (bus != NULL && bus->devargs_parse != NULL)
189 		ret = bus->devargs_parse(devargs);
190 	else if (layers[0].kvlist != NULL)
191 		ret = devargs_bus_parse_default(devargs, layers[0].kvlist);
192 
193 get_out:
194 	for (i = 0; i < RTE_DIM(layers); i++) {
195 		if (layers[i].kvlist)
196 			rte_kvargs_free(layers[i].kvlist);
197 	}
198 	if (ret != 0) {
199 		if (allocated_data) {
200 			/* Free duplicated data. */
201 			free(devargs->data);
202 			devargs->data = NULL;
203 		}
204 		rte_errno = -ret;
205 	}
206 	return ret;
207 }
208 
209 static int
210 bus_name_cmp(const struct rte_bus *bus, const void *name)
211 {
212 	return strncmp(bus->name, name, strlen(bus->name));
213 }
214 
215 int
216 rte_devargs_parse(struct rte_devargs *da, const char *dev)
217 {
218 	struct rte_bus *bus = NULL;
219 	const char *devname;
220 	const size_t maxlen = sizeof(da->name);
221 	size_t i;
222 
223 	if (da == NULL)
224 		return -EINVAL;
225 
226 	/* First parse according global device syntax. */
227 	if (rte_devargs_layers_parse(da, dev) == 0) {
228 		if (da->bus != NULL || da->cls != NULL)
229 			return 0;
230 		rte_devargs_reset(da);
231 	}
232 
233 	/* Otherwise fallback to legacy syntax: */
234 
235 	/* Retrieve eventual bus info */
236 	do {
237 		devname = dev;
238 		bus = rte_bus_find(bus, bus_name_cmp, dev);
239 		if (bus == NULL)
240 			break;
241 		devname = dev + strlen(bus->name) + 1;
242 		if (rte_bus_find_by_device_name(devname) == bus)
243 			break;
244 	} while (1);
245 	/* Store device name */
246 	i = 0;
247 	while (devname[i] != '\0' && devname[i] != ',') {
248 		da->name[i] = devname[i];
249 		i++;
250 		if (i == maxlen) {
251 			RTE_LOG(WARNING, EAL, "Parsing \"%s\": device name should be shorter than %zu\n",
252 				dev, maxlen);
253 			da->name[i - 1] = '\0';
254 			return -EINVAL;
255 		}
256 	}
257 	da->name[i] = '\0';
258 	if (bus == NULL) {
259 		bus = rte_bus_find_by_device_name(da->name);
260 		if (bus == NULL) {
261 			RTE_LOG(ERR, EAL, "failed to parse device \"%s\"\n",
262 				da->name);
263 			return -EFAULT;
264 		}
265 	}
266 	da->bus = bus;
267 	/* Parse eventual device arguments */
268 	if (devname[i] == ',')
269 		da->data = strdup(&devname[i + 1]);
270 	else
271 		da->data = strdup("");
272 	if (da->data == NULL) {
273 		RTE_LOG(ERR, EAL, "not enough memory to parse arguments\n");
274 		return -ENOMEM;
275 	}
276 	da->drv_str = da->data;
277 	return 0;
278 }
279 
280 int
281 rte_devargs_parsef(struct rte_devargs *da, const char *format, ...)
282 {
283 	va_list ap;
284 	int len;
285 	char *dev;
286 	int ret;
287 
288 	if (da == NULL)
289 		return -EINVAL;
290 
291 	va_start(ap, format);
292 	len = vsnprintf(NULL, 0, format, ap);
293 	va_end(ap);
294 	if (len < 0)
295 		return -EINVAL;
296 
297 	len += 1;
298 	dev = calloc(1, (size_t)len);
299 	if (dev == NULL) {
300 		RTE_LOG(ERR, EAL, "not enough memory to parse device\n");
301 		return -ENOMEM;
302 	}
303 
304 	va_start(ap, format);
305 	vsnprintf(dev, (size_t)len, format, ap);
306 	va_end(ap);
307 
308 	ret = rte_devargs_parse(da, dev);
309 
310 	free(dev);
311 	return ret;
312 }
313 
314 void
315 rte_devargs_reset(struct rte_devargs *da)
316 {
317 	if (da == NULL)
318 		return;
319 	if (da->data)
320 		free(da->data);
321 	da->data = NULL;
322 }
323 
324 int
325 rte_devargs_insert(struct rte_devargs **da)
326 {
327 	struct rte_devargs *listed_da;
328 	void *tmp;
329 
330 	if (*da == NULL || (*da)->bus == NULL)
331 		return -1;
332 
333 	RTE_TAILQ_FOREACH_SAFE(listed_da, &devargs_list, next, tmp) {
334 		if (listed_da == *da)
335 			/* devargs already in the list */
336 			return 0;
337 		if (strcmp(listed_da->bus->name, (*da)->bus->name) == 0 &&
338 				strcmp(listed_da->name, (*da)->name) == 0) {
339 			/* device already in devargs list, must be updated */
340 			(*da)->next = listed_da->next;
341 			rte_devargs_reset(listed_da);
342 			*listed_da = **da;
343 			/* replace provided devargs with found one */
344 			free(*da);
345 			*da = listed_da;
346 			return 0;
347 		}
348 	}
349 	/* new device in the list */
350 	TAILQ_INSERT_TAIL(&devargs_list, *da, next);
351 	return 0;
352 }
353 
354 /* store in allowed list parameter for later parsing */
355 int
356 rte_devargs_add(enum rte_devtype devtype, const char *devargs_str)
357 {
358 	struct rte_devargs *devargs = NULL;
359 	struct rte_bus *bus = NULL;
360 	const char *dev = devargs_str;
361 
362 	/* use calloc instead of rte_zmalloc as it's called early at init */
363 	devargs = calloc(1, sizeof(*devargs));
364 	if (devargs == NULL)
365 		goto fail;
366 
367 	if (rte_devargs_parse(devargs, dev))
368 		goto fail;
369 	devargs->type = devtype;
370 	bus = devargs->bus;
371 	if (devargs->type == RTE_DEVTYPE_BLOCKED)
372 		devargs->policy = RTE_DEV_BLOCKED;
373 	if (bus->conf.scan_mode == RTE_BUS_SCAN_UNDEFINED) {
374 		if (devargs->policy == RTE_DEV_ALLOWED)
375 			bus->conf.scan_mode = RTE_BUS_SCAN_ALLOWLIST;
376 		else if (devargs->policy == RTE_DEV_BLOCKED)
377 			bus->conf.scan_mode = RTE_BUS_SCAN_BLOCKLIST;
378 	}
379 	TAILQ_INSERT_TAIL(&devargs_list, devargs, next);
380 	return 0;
381 
382 fail:
383 	if (devargs) {
384 		rte_devargs_reset(devargs);
385 		free(devargs);
386 	}
387 
388 	return -1;
389 }
390 
391 int
392 rte_devargs_remove(struct rte_devargs *devargs)
393 {
394 	struct rte_devargs *d;
395 	void *tmp;
396 
397 	if (devargs == NULL || devargs->bus == NULL)
398 		return -1;
399 
400 	RTE_TAILQ_FOREACH_SAFE(d, &devargs_list, next, tmp) {
401 		if (strcmp(d->bus->name, devargs->bus->name) == 0 &&
402 		    strcmp(d->name, devargs->name) == 0) {
403 			TAILQ_REMOVE(&devargs_list, d, next);
404 			rte_devargs_reset(d);
405 			free(d);
406 			return 0;
407 		}
408 	}
409 	return 1;
410 }
411 
412 /* count the number of devices of a specified type */
413 unsigned int
414 rte_devargs_type_count(enum rte_devtype devtype)
415 {
416 	struct rte_devargs *devargs;
417 	unsigned int count = 0;
418 
419 	TAILQ_FOREACH(devargs, &devargs_list, next) {
420 		if (devargs->type != devtype)
421 			continue;
422 		count++;
423 	}
424 	return count;
425 }
426 
427 /* dump the user devices on the console */
428 void
429 rte_devargs_dump(FILE *f)
430 {
431 	struct rte_devargs *devargs;
432 
433 	fprintf(f, "User device list:\n");
434 	TAILQ_FOREACH(devargs, &devargs_list, next) {
435 		fprintf(f, "  [%s]: %s %s\n",
436 			(devargs->bus ? devargs->bus->name : "??"),
437 			devargs->name, devargs->args);
438 	}
439 }
440 
441 /* bus-aware rte_devargs iterator. */
442 struct rte_devargs *
443 rte_devargs_next(const char *busname, const struct rte_devargs *start)
444 {
445 	struct rte_devargs *da;
446 
447 	if (start != NULL)
448 		da = TAILQ_NEXT(start, next);
449 	else
450 		da = TAILQ_FIRST(&devargs_list);
451 	while (da != NULL) {
452 		if (busname == NULL ||
453 		    (strcmp(busname, da->bus->name) == 0))
454 			return da;
455 		da = TAILQ_NEXT(da, next);
456 	}
457 	return NULL;
458 }
459