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