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
8 * Code here should not call rte_log since the EAL environment
9 * may not be initialized.
17 #include <rte_class.h>
18 #include <rte_compat.h>
20 #include <rte_devargs.h>
21 #include <rte_errno.h>
22 #include <rte_kvargs.h>
24 #include <rte_tailq.h>
25 #include "eal_private.h"
27 /** user device double-linked queue type definition */
28 TAILQ_HEAD(rte_devargs_list, rte_devargs);
30 /** Global list of user devices */
31 struct rte_devargs_list devargs_list =
32 TAILQ_HEAD_INITIALIZER(devargs_list);
35 rte_eal_parse_devargs_str(const char *devargs_str,
36 char **drvname, char **drvargs)
40 if ((devargs_str) == NULL || (drvname) == NULL || (drvargs == NULL))
43 *drvname = strdup(devargs_str);
47 /* set the first ',' to '\0' to split name and arguments */
48 sep = strchr(*drvname, ',');
51 *drvargs = strdup(sep + 1);
53 *drvargs = strdup("");
56 if (*drvargs == NULL) {
65 devargs_layer_count(const char *s)
69 while (s != NULL && s[0] != '\0') {
77 rte_devargs_layers_parse(struct rte_devargs *devargs,
83 struct rte_kvargs *kvlist;
85 { "bus=", NULL, NULL, },
86 { "class=", NULL, NULL, },
87 { "driver=", NULL, NULL, },
89 struct rte_kvargs_pair *kv = NULL;
90 struct rte_class *cls = NULL;
91 struct rte_bus *bus = NULL;
92 const char *s = devstr;
97 /* Split each sub-lists. */
98 nblayer = devargs_layer_count(devstr);
99 if (nblayer > RTE_DIM(layers)) {
100 RTE_LOG(ERR, EAL, "Invalid format: too many layers (%zu)\n",
106 /* If the devargs points the devstr
107 * as source data, then it should not allocate
108 * anything and keep referring only to it.
110 if (devargs->data != devstr) {
111 devargs->data = strdup(devstr);
112 if (devargs->data == NULL) {
113 RTE_LOG(ERR, EAL, "OOM\n");
121 if (i >= RTE_DIM(layers)) {
122 RTE_LOG(ERR, EAL, "Unrecognized layer %s\n", s);
127 * The last layer is free-form.
128 * The "driver" key is not required (but accepted).
130 if (strncmp(layers[i].key, s, strlen(layers[i].key)) &&
131 i != RTE_DIM(layers) - 1)
134 layers[i].kvlist = rte_kvargs_parse_delim(s, NULL, "/");
135 if (layers[i].kvlist == NULL) {
136 RTE_LOG(ERR, EAL, "Could not parse %s\n", s);
147 /* Parse each sub-list. */
148 for (i = 0; i < RTE_DIM(layers); i++) {
149 if (layers[i].kvlist == NULL)
151 kv = &layers[i].kvlist->pairs[0];
152 if (strcmp(kv->key, "bus") == 0) {
153 bus = rte_bus_find_by_name(kv->value);
155 RTE_LOG(ERR, EAL, "Could not find bus \"%s\"\n",
160 } else if (strcmp(kv->key, "class") == 0) {
161 cls = rte_class_find_by_name(kv->value);
163 RTE_LOG(ERR, EAL, "Could not find class \"%s\"\n",
168 } else if (strcmp(kv->key, "driver") == 0) {
174 /* Fill devargs fields. */
175 devargs->bus_str = layers[0].str;
176 devargs->cls_str = layers[1].str;
177 devargs->drv_str = layers[2].str;
181 /* If we own the data, clean up a bit
182 * the several layers string, to ease
183 * their parsing afterward.
185 if (devargs->data != devstr) {
186 char *s = (void *)(intptr_t)(devargs->data);
188 while ((s = strchr(s, '/'))) {
195 for (i = 0; i < RTE_DIM(layers); i++) {
196 if (layers[i].kvlist)
197 rte_kvargs_free(layers[i].kvlist);
205 bus_name_cmp(const struct rte_bus *bus, const void *name)
207 return strncmp(bus->name, name, strlen(bus->name));
212 rte_devargs_parse(struct rte_devargs *da, const char *dev)
214 struct rte_bus *bus = NULL;
216 const size_t maxlen = sizeof(da->name);
222 /* Retrieve eventual bus info */
225 bus = rte_bus_find(bus, bus_name_cmp, dev);
228 devname = dev + strlen(bus->name) + 1;
229 if (rte_bus_find_by_device_name(devname) == bus)
232 /* Store device name */
234 while (devname[i] != '\0' && devname[i] != ',') {
235 da->name[i] = devname[i];
238 RTE_LOG(WARNING, EAL, "Parsing \"%s\": device name should be shorter than %zu\n",
240 da->name[i - 1] = '\0';
246 bus = rte_bus_find_by_device_name(da->name);
248 RTE_LOG(ERR, EAL, "failed to parse device \"%s\"\n",
254 /* Parse eventual device arguments */
255 if (devname[i] == ',')
256 da->args = strdup(&devname[i + 1]);
258 da->args = strdup("");
259 if (da->args == NULL) {
260 RTE_LOG(ERR, EAL, "not enough memory to parse arguments\n");
268 rte_devargs_parsef(struct rte_devargs *da, const char *format, ...)
277 va_start(ap, format);
278 len = vsnprintf(NULL, 0, format, ap);
281 dev = calloc(1, len + 1);
283 RTE_LOG(ERR, EAL, "not enough memory to parse device\n");
287 va_start(ap, format);
288 vsnprintf(dev, len + 1, format, ap);
291 return rte_devargs_parse(da, dev);
294 int __rte_experimental
295 rte_devargs_insert(struct rte_devargs *da)
299 ret = rte_devargs_remove(da->bus->name, da->name);
302 TAILQ_INSERT_TAIL(&devargs_list, da, next);
306 /* store a whitelist parameter for later parsing */
309 rte_devargs_add(enum rte_devtype devtype, const char *devargs_str)
311 struct rte_devargs *devargs = NULL;
312 struct rte_bus *bus = NULL;
313 const char *dev = devargs_str;
315 /* use calloc instead of rte_zmalloc as it's called early at init */
316 devargs = calloc(1, sizeof(*devargs));
320 if (rte_devargs_parse(devargs, dev))
322 devargs->type = devtype;
324 if (devargs->type == RTE_DEVTYPE_BLACKLISTED_PCI)
325 devargs->policy = RTE_DEV_BLACKLISTED;
326 if (bus->conf.scan_mode == RTE_BUS_SCAN_UNDEFINED) {
327 if (devargs->policy == RTE_DEV_WHITELISTED)
328 bus->conf.scan_mode = RTE_BUS_SCAN_WHITELIST;
329 else if (devargs->policy == RTE_DEV_BLACKLISTED)
330 bus->conf.scan_mode = RTE_BUS_SCAN_BLACKLIST;
332 TAILQ_INSERT_TAIL(&devargs_list, devargs, next);
344 int __rte_experimental
345 rte_devargs_remove(const char *busname, const char *devname)
347 struct rte_devargs *d;
350 TAILQ_FOREACH_SAFE(d, &devargs_list, next, tmp) {
351 if (strcmp(d->bus->name, busname) == 0 &&
352 strcmp(d->name, devname) == 0) {
353 TAILQ_REMOVE(&devargs_list, d, next);
362 /* count the number of devices of a specified type */
365 rte_devargs_type_count(enum rte_devtype devtype)
367 struct rte_devargs *devargs;
368 unsigned int count = 0;
370 TAILQ_FOREACH(devargs, &devargs_list, next) {
371 if (devargs->type != devtype)
378 /* dump the user devices on the console */
381 rte_devargs_dump(FILE *f)
383 struct rte_devargs *devargs;
385 fprintf(f, "User device list:\n");
386 TAILQ_FOREACH(devargs, &devargs_list, next) {
387 fprintf(f, " [%s]: %s %s\n",
388 (devargs->bus ? devargs->bus->name : "??"),
389 devargs->name, devargs->args);
393 /* bus-aware rte_devargs iterator. */
396 rte_devargs_next(const char *busname, const struct rte_devargs *start)
398 struct rte_devargs *da;
401 da = TAILQ_NEXT(start, next);
403 da = TAILQ_FIRST(&devargs_list);
405 if (busname == NULL ||
406 (strcmp(busname, da->bus->name) == 0))
408 da = TAILQ_NEXT(da, next);