1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright 2014 6WIND S.A.
5 /* This file manages the list of devices and their arguments, as given
6 * by the user at startup
14 #include <rte_class.h>
15 #include <rte_compat.h>
17 #include <rte_devargs.h>
18 #include <rte_errno.h>
19 #include <rte_kvargs.h>
21 #include <rte_tailq.h>
22 #include <rte_string_fns.h>
23 #include "eal_private.h"
25 /** user device double-linked queue type definition */
26 TAILQ_HEAD(rte_devargs_list, rte_devargs);
28 /** Global list of user devices */
29 static struct rte_devargs_list devargs_list =
30 TAILQ_HEAD_INITIALIZER(devargs_list);
33 devargs_layer_count(const char *s)
37 while (s != NULL && s[0] != '\0') {
44 /* Resolve devargs name from bus arguments. */
46 devargs_bus_parse_default(struct rte_devargs *devargs,
47 struct rte_kvargs *bus_args)
51 /* Parse devargs name from bus key-value list. */
52 name = rte_kvargs_get(bus_args, "name");
54 RTE_LOG(INFO, EAL, "devargs name not found: %s\n",
58 if (rte_strscpy(devargs->name, name, sizeof(devargs->name)) < 0) {
59 RTE_LOG(ERR, EAL, "devargs name too long: %s\n",
67 rte_devargs_layers_parse(struct rte_devargs *devargs,
73 struct rte_kvargs *kvlist;
75 { RTE_DEVARGS_KEY_BUS "=", NULL, NULL, },
76 { RTE_DEVARGS_KEY_CLASS "=", NULL, NULL, },
77 { RTE_DEVARGS_KEY_DRIVER "=", NULL, NULL, },
79 struct rte_kvargs_pair *kv = NULL;
80 struct rte_class *cls = NULL;
81 struct rte_bus *bus = NULL;
82 const char *s = devstr;
86 bool allocated_data = false;
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",
97 /* If the devargs points the devstr
98 * as source data, then it should not allocate
99 * anything and keep referring only to it.
101 if (devargs->data != devstr) {
102 devargs->data = strdup(devstr);
103 if (devargs->data == NULL) {
104 RTE_LOG(ERR, EAL, "OOM\n");
108 allocated_data = true;
113 if (i >= RTE_DIM(layers)) {
114 RTE_LOG(ERR, EAL, "Unrecognized layer %s\n", s);
119 * The last layer is free-form.
120 * The "driver" key is not required (but accepted).
122 if (strncmp(layers[i].key, s, strlen(layers[i].key)) &&
123 i != RTE_DIM(layers) - 1)
126 layers[i].kvlist = rte_kvargs_parse_delim(s, NULL, "/");
127 if (layers[i].kvlist == NULL) {
138 /* Parse each sub-list. */
139 for (i = 0; i < RTE_DIM(layers); i++) {
140 if (layers[i].kvlist == NULL)
142 kv = &layers[i].kvlist->pairs[0];
145 if (strcmp(kv->key, RTE_DEVARGS_KEY_BUS) == 0) {
146 bus = rte_bus_find_by_name(kv->value);
148 RTE_LOG(ERR, EAL, "Could not find bus \"%s\"\n",
153 } else if (strcmp(kv->key, RTE_DEVARGS_KEY_CLASS) == 0) {
154 cls = rte_class_find_by_name(kv->value);
156 RTE_LOG(ERR, EAL, "Could not find class \"%s\"\n",
161 } else if (strcmp(kv->key, RTE_DEVARGS_KEY_DRIVER) == 0) {
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;
174 /* If we own the data, clean up a bit
175 * the several layers string, to ease
176 * their parsing afterward.
178 if (devargs->data != devstr) {
179 char *s = devargs->data;
181 while ((s = strchr(s, '/'))) {
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);
194 for (i = 0; i < RTE_DIM(layers); i++) {
195 if (layers[i].kvlist)
196 rte_kvargs_free(layers[i].kvlist);
199 if (allocated_data) {
200 /* Free duplicated data. */
202 devargs->data = NULL;
210 bus_name_cmp(const struct rte_bus *bus, const void *name)
212 return strncmp(bus->name, name, strlen(bus->name));
216 rte_devargs_parse(struct rte_devargs *da, const char *dev)
218 struct rte_bus *bus = NULL;
220 const size_t maxlen = sizeof(da->name);
226 /* First parse according global device syntax. */
227 if (rte_devargs_layers_parse(da, dev) == 0) {
228 if (da->bus != NULL || da->cls != NULL)
230 rte_devargs_reset(da);
233 /* Otherwise fallback to legacy syntax: */
235 /* Retrieve eventual bus info */
238 bus = rte_bus_find(bus, bus_name_cmp, dev);
241 devname = dev + strlen(bus->name) + 1;
242 if (rte_bus_find_by_device_name(devname) == bus)
245 /* Store device name */
247 while (devname[i] != '\0' && devname[i] != ',') {
248 da->name[i] = devname[i];
251 RTE_LOG(WARNING, EAL, "Parsing \"%s\": device name should be shorter than %zu\n",
253 da->name[i - 1] = '\0';
259 bus = rte_bus_find_by_device_name(da->name);
261 RTE_LOG(ERR, EAL, "failed to parse device \"%s\"\n",
267 /* Parse eventual device arguments */
268 if (devname[i] == ',')
269 da->data = strdup(&devname[i + 1]);
271 da->data = strdup("");
272 if (da->data == NULL) {
273 RTE_LOG(ERR, EAL, "not enough memory to parse arguments\n");
276 da->drv_str = da->data;
281 rte_devargs_parsef(struct rte_devargs *da, const char *format, ...)
291 va_start(ap, format);
292 len = vsnprintf(NULL, 0, format, ap);
298 dev = calloc(1, (size_t)len);
300 RTE_LOG(ERR, EAL, "not enough memory to parse device\n");
304 va_start(ap, format);
305 vsnprintf(dev, (size_t)len, format, ap);
308 ret = rte_devargs_parse(da, dev);
315 rte_devargs_reset(struct rte_devargs *da)
325 rte_devargs_insert(struct rte_devargs **da)
327 struct rte_devargs *listed_da;
330 if (*da == NULL || (*da)->bus == NULL)
333 RTE_TAILQ_FOREACH_SAFE(listed_da, &devargs_list, next, tmp) {
334 if (listed_da == *da)
335 /* devargs already in the list */
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);
343 /* replace provided devargs with found one */
349 /* new device in the list */
350 TAILQ_INSERT_TAIL(&devargs_list, *da, next);
354 /* store in allowed list parameter for later parsing */
356 rte_devargs_add(enum rte_devtype devtype, const char *devargs_str)
358 struct rte_devargs *devargs = NULL;
359 struct rte_bus *bus = NULL;
360 const char *dev = devargs_str;
362 /* use calloc instead of rte_zmalloc as it's called early at init */
363 devargs = calloc(1, sizeof(*devargs));
367 if (rte_devargs_parse(devargs, dev))
369 devargs->type = devtype;
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;
379 TAILQ_INSERT_TAIL(&devargs_list, devargs, next);
384 rte_devargs_reset(devargs);
392 rte_devargs_remove(struct rte_devargs *devargs)
394 struct rte_devargs *d;
397 if (devargs == NULL || devargs->bus == NULL)
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);
412 /* count the number of devices of a specified type */
414 rte_devargs_type_count(enum rte_devtype devtype)
416 struct rte_devargs *devargs;
417 unsigned int count = 0;
419 TAILQ_FOREACH(devargs, &devargs_list, next) {
420 if (devargs->type != devtype)
427 /* dump the user devices on the console */
429 rte_devargs_dump(FILE *f)
431 struct rte_devargs *devargs;
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);
441 /* bus-aware rte_devargs iterator. */
443 rte_devargs_next(const char *busname, const struct rte_devargs *start)
445 struct rte_devargs *da;
448 da = TAILQ_NEXT(start, next);
450 da = TAILQ_FIRST(&devargs_list);
452 if (busname == NULL ||
453 (strcmp(busname, da->bus->name) == 0))
455 da = TAILQ_NEXT(da, next);