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 "eal_private.h"
24 /** user device double-linked queue type definition */
25 TAILQ_HEAD(rte_devargs_list, rte_devargs);
27 /** Global list of user devices */
28 static struct rte_devargs_list devargs_list =
29 TAILQ_HEAD_INITIALIZER(devargs_list);
32 devargs_layer_count(const char *s)
36 while (s != NULL && s[0] != '\0') {
44 rte_devargs_layers_parse(struct rte_devargs *devargs,
50 struct rte_kvargs *kvlist;
52 { "bus=", NULL, NULL, },
53 { "class=", NULL, NULL, },
54 { "driver=", NULL, NULL, },
56 struct rte_kvargs_pair *kv = NULL;
57 struct rte_class *cls = NULL;
58 struct rte_bus *bus = NULL;
59 const char *s = devstr;
64 /* Split each sub-lists. */
65 nblayer = devargs_layer_count(devstr);
66 if (nblayer > RTE_DIM(layers)) {
67 RTE_LOG(ERR, EAL, "Invalid format: too many layers (%zu)\n",
73 /* If the devargs points the devstr
74 * as source data, then it should not allocate
75 * anything and keep referring only to it.
77 if (devargs->data != devstr) {
78 devargs->data = strdup(devstr);
79 if (devargs->data == NULL) {
80 RTE_LOG(ERR, EAL, "OOM\n");
88 if (i >= RTE_DIM(layers)) {
89 RTE_LOG(ERR, EAL, "Unrecognized layer %s\n", s);
94 * The last layer is free-form.
95 * The "driver" key is not required (but accepted).
97 if (strncmp(layers[i].key, s, strlen(layers[i].key)) &&
98 i != RTE_DIM(layers) - 1)
101 layers[i].kvlist = rte_kvargs_parse_delim(s, NULL, "/");
102 if (layers[i].kvlist == NULL) {
103 RTE_LOG(ERR, EAL, "Could not parse %s\n", s);
114 /* Parse each sub-list. */
115 for (i = 0; i < RTE_DIM(layers); i++) {
116 if (layers[i].kvlist == NULL)
118 kv = &layers[i].kvlist->pairs[0];
119 if (strcmp(kv->key, "bus") == 0) {
120 bus = rte_bus_find_by_name(kv->value);
122 RTE_LOG(ERR, EAL, "Could not find bus \"%s\"\n",
127 } else if (strcmp(kv->key, "class") == 0) {
128 cls = rte_class_find_by_name(kv->value);
130 RTE_LOG(ERR, EAL, "Could not find class \"%s\"\n",
135 } else if (strcmp(kv->key, "driver") == 0) {
141 /* Fill devargs fields. */
142 devargs->bus_str = layers[0].str;
143 devargs->cls_str = layers[1].str;
144 devargs->drv_str = layers[2].str;
148 /* If we own the data, clean up a bit
149 * the several layers string, to ease
150 * their parsing afterward.
152 if (devargs->data != devstr) {
153 char *s = devargs->data;
155 while ((s = strchr(s, '/'))) {
162 for (i = 0; i < RTE_DIM(layers); i++) {
163 if (layers[i].kvlist)
164 rte_kvargs_free(layers[i].kvlist);
172 bus_name_cmp(const struct rte_bus *bus, const void *name)
174 return strncmp(bus->name, name, strlen(bus->name));
178 rte_devargs_parse(struct rte_devargs *da, const char *dev)
180 struct rte_bus *bus = NULL;
182 const size_t maxlen = sizeof(da->name);
188 /* Retrieve eventual bus info */
191 bus = rte_bus_find(bus, bus_name_cmp, dev);
194 devname = dev + strlen(bus->name) + 1;
195 if (rte_bus_find_by_device_name(devname) == bus)
198 /* Store device name */
200 while (devname[i] != '\0' && devname[i] != ',') {
201 da->name[i] = devname[i];
204 RTE_LOG(WARNING, EAL, "Parsing \"%s\": device name should be shorter than %zu\n",
206 da->name[i - 1] = '\0';
212 bus = rte_bus_find_by_device_name(da->name);
214 RTE_LOG(ERR, EAL, "failed to parse device \"%s\"\n",
220 /* Parse eventual device arguments */
221 if (devname[i] == ',')
222 da->data = strdup(&devname[i + 1]);
224 da->data = strdup("");
225 if (da->data == NULL) {
226 RTE_LOG(ERR, EAL, "not enough memory to parse arguments\n");
229 da->drv_str = da->data;
234 rte_devargs_parsef(struct rte_devargs *da, const char *format, ...)
244 va_start(ap, format);
245 len = vsnprintf(NULL, 0, format, ap);
248 dev = calloc(1, len + 1);
250 RTE_LOG(ERR, EAL, "not enough memory to parse device\n");
254 va_start(ap, format);
255 vsnprintf(dev, len + 1, format, ap);
258 ret = rte_devargs_parse(da, dev);
265 rte_devargs_reset(struct rte_devargs *da)
275 rte_devargs_insert(struct rte_devargs **da)
277 struct rte_devargs *listed_da;
280 if (*da == NULL || (*da)->bus == NULL)
283 TAILQ_FOREACH_SAFE(listed_da, &devargs_list, next, tmp) {
284 if (listed_da == *da)
285 /* devargs already in the list */
287 if (strcmp(listed_da->bus->name, (*da)->bus->name) == 0 &&
288 strcmp(listed_da->name, (*da)->name) == 0) {
289 /* device already in devargs list, must be updated */
290 rte_devargs_reset(listed_da);
292 /* replace provided devargs with found one */
298 /* new device in the list */
299 TAILQ_INSERT_TAIL(&devargs_list, *da, next);
303 /* store in allowed list parameter for later parsing */
305 rte_devargs_add(enum rte_devtype devtype, const char *devargs_str)
307 struct rte_devargs *devargs = NULL;
308 struct rte_bus *bus = NULL;
309 const char *dev = devargs_str;
311 /* use calloc instead of rte_zmalloc as it's called early at init */
312 devargs = calloc(1, sizeof(*devargs));
316 if (rte_devargs_parse(devargs, dev))
318 devargs->type = devtype;
320 if (devargs->type == RTE_DEVTYPE_BLOCKED)
321 devargs->policy = RTE_DEV_BLOCKED;
322 if (bus->conf.scan_mode == RTE_BUS_SCAN_UNDEFINED) {
323 if (devargs->policy == RTE_DEV_ALLOWED)
324 bus->conf.scan_mode = RTE_BUS_SCAN_ALLOWLIST;
325 else if (devargs->policy == RTE_DEV_BLOCKED)
326 bus->conf.scan_mode = RTE_BUS_SCAN_BLOCKLIST;
328 TAILQ_INSERT_TAIL(&devargs_list, devargs, next);
333 rte_devargs_reset(devargs);
341 rte_devargs_remove(struct rte_devargs *devargs)
343 struct rte_devargs *d;
346 if (devargs == NULL || devargs->bus == NULL)
349 TAILQ_FOREACH_SAFE(d, &devargs_list, next, tmp) {
350 if (strcmp(d->bus->name, devargs->bus->name) == 0 &&
351 strcmp(d->name, devargs->name) == 0) {
352 TAILQ_REMOVE(&devargs_list, d, next);
353 rte_devargs_reset(d);
361 /* count the number of devices of a specified type */
363 rte_devargs_type_count(enum rte_devtype devtype)
365 struct rte_devargs *devargs;
366 unsigned int count = 0;
368 TAILQ_FOREACH(devargs, &devargs_list, next) {
369 if (devargs->type != devtype)
376 /* dump the user devices on the console */
378 rte_devargs_dump(FILE *f)
380 struct rte_devargs *devargs;
382 fprintf(f, "User device list:\n");
383 TAILQ_FOREACH(devargs, &devargs_list, next) {
384 fprintf(f, " [%s]: %s %s\n",
385 (devargs->bus ? devargs->bus->name : "??"),
386 devargs->name, devargs->args);
390 /* bus-aware rte_devargs iterator. */
392 rte_devargs_next(const char *busname, const struct rte_devargs *start)
394 struct rte_devargs *da;
397 da = TAILQ_NEXT(start, next);
399 da = TAILQ_FIRST(&devargs_list);
401 if (busname == NULL ||
402 (strcmp(busname, da->bus->name) == 0))
404 da = TAILQ_NEXT(da, next);