devargs: use proper namespace prefix
[dpdk.git] / lib / librte_eal / common / eal_common_devargs.c
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  * Code here should not call rte_log since the EAL environment
9  * may not be initialized.
10  */
11
12 #include <stdio.h>
13 #include <string.h>
14 #include <stdarg.h>
15
16 #include <rte_compat.h>
17 #include <rte_dev.h>
18 #include <rte_devargs.h>
19 #include <rte_tailq.h>
20 #include "eal_private.h"
21
22 /** user device double-linked queue type definition */
23 TAILQ_HEAD(rte_devargs_list, rte_devargs);
24
25 /** Global list of user devices */
26 struct rte_devargs_list devargs_list =
27         TAILQ_HEAD_INITIALIZER(devargs_list);
28
29 int
30 rte_eal_parse_devargs_str(const char *devargs_str,
31                         char **drvname, char **drvargs)
32 {
33         char *sep;
34
35         if ((devargs_str) == NULL || (drvname) == NULL || (drvargs == NULL))
36                 return -1;
37
38         *drvname = strdup(devargs_str);
39         if (*drvname == NULL)
40                 return -1;
41
42         /* set the first ',' to '\0' to split name and arguments */
43         sep = strchr(*drvname, ',');
44         if (sep != NULL) {
45                 sep[0] = '\0';
46                 *drvargs = strdup(sep + 1);
47         } else {
48                 *drvargs = strdup("");
49         }
50
51         if (*drvargs == NULL) {
52                 free(*drvname);
53                 *drvname = NULL;
54                 return -1;
55         }
56         return 0;
57 }
58
59 static int
60 bus_name_cmp(const struct rte_bus *bus, const void *name)
61 {
62         return strncmp(bus->name, name, strlen(bus->name));
63 }
64
65 int __rte_experimental
66 rte_devargs_parse(struct rte_devargs *da, const char *format, ...)
67 {
68         struct rte_bus *bus = NULL;
69         va_list ap;
70         va_start(ap, format);
71         char dev[vsnprintf(NULL, 0, format, ap) + 1];
72         const char *devname;
73         const size_t maxlen = sizeof(da->name);
74         size_t i;
75
76         va_end(ap);
77         if (da == NULL)
78                 return -EINVAL;
79
80         va_start(ap, format);
81         vsnprintf(dev, sizeof(dev), format, ap);
82         va_end(ap);
83         /* Retrieve eventual bus info */
84         do {
85                 devname = dev;
86                 bus = rte_bus_find(bus, bus_name_cmp, dev);
87                 if (bus == NULL)
88                         break;
89                 devname = dev + strlen(bus->name) + 1;
90                 if (rte_bus_find_by_device_name(devname) == bus)
91                         break;
92         } while (1);
93         /* Store device name */
94         i = 0;
95         while (devname[i] != '\0' && devname[i] != ',') {
96                 da->name[i] = devname[i];
97                 i++;
98                 if (i == maxlen) {
99                         fprintf(stderr, "WARNING: Parsing \"%s\": device name should be shorter than %zu\n",
100                                 dev, maxlen);
101                         da->name[i - 1] = '\0';
102                         return -EINVAL;
103                 }
104         }
105         da->name[i] = '\0';
106         if (bus == NULL) {
107                 bus = rte_bus_find_by_device_name(da->name);
108                 if (bus == NULL) {
109                         fprintf(stderr, "ERROR: failed to parse device \"%s\"\n",
110                                 da->name);
111                         return -EFAULT;
112                 }
113         }
114         da->bus = bus;
115         /* Parse eventual device arguments */
116         if (devname[i] == ',')
117                 da->args = strdup(&devname[i + 1]);
118         else
119                 da->args = strdup("");
120         if (da->args == NULL) {
121                 fprintf(stderr, "ERROR: not enough memory to parse arguments\n");
122                 return -ENOMEM;
123         }
124         return 0;
125 }
126
127 int __rte_experimental
128 rte_devargs_insert(struct rte_devargs *da)
129 {
130         int ret;
131
132         ret = rte_devargs_remove(da->bus->name, da->name);
133         if (ret < 0)
134                 return ret;
135         TAILQ_INSERT_TAIL(&devargs_list, da, next);
136         return 0;
137 }
138
139 /* store a whitelist parameter for later parsing */
140 int
141 rte_eal_devargs_add(enum rte_devtype devtype, const char *devargs_str)
142 {
143         struct rte_devargs *devargs = NULL;
144         struct rte_bus *bus = NULL;
145         const char *dev = devargs_str;
146
147         /* use calloc instead of rte_zmalloc as it's called early at init */
148         devargs = calloc(1, sizeof(*devargs));
149         if (devargs == NULL)
150                 goto fail;
151
152         if (rte_devargs_parse(devargs, "%s", dev))
153                 goto fail;
154         devargs->type = devtype;
155         bus = devargs->bus;
156         if (devargs->type == RTE_DEVTYPE_BLACKLISTED_PCI)
157                 devargs->policy = RTE_DEV_BLACKLISTED;
158         if (bus->conf.scan_mode == RTE_BUS_SCAN_UNDEFINED) {
159                 if (devargs->policy == RTE_DEV_WHITELISTED)
160                         bus->conf.scan_mode = RTE_BUS_SCAN_WHITELIST;
161                 else if (devargs->policy == RTE_DEV_BLACKLISTED)
162                         bus->conf.scan_mode = RTE_BUS_SCAN_BLACKLIST;
163         }
164         TAILQ_INSERT_TAIL(&devargs_list, devargs, next);
165         return 0;
166
167 fail:
168         if (devargs) {
169                 free(devargs->args);
170                 free(devargs);
171         }
172
173         return -1;
174 }
175
176 int __rte_experimental
177 rte_devargs_remove(const char *busname, const char *devname)
178 {
179         struct rte_devargs *d;
180         void *tmp;
181
182         TAILQ_FOREACH_SAFE(d, &devargs_list, next, tmp) {
183                 if (strcmp(d->bus->name, busname) == 0 &&
184                     strcmp(d->name, devname) == 0) {
185                         TAILQ_REMOVE(&devargs_list, d, next);
186                         free(d->args);
187                         free(d);
188                         return 0;
189                 }
190         }
191         return 1;
192 }
193
194 /* count the number of devices of a specified type */
195 unsigned int
196 rte_eal_devargs_type_count(enum rte_devtype devtype)
197 {
198         struct rte_devargs *devargs;
199         unsigned int count = 0;
200
201         TAILQ_FOREACH(devargs, &devargs_list, next) {
202                 if (devargs->type != devtype)
203                         continue;
204                 count++;
205         }
206         return count;
207 }
208
209 /* dump the user devices on the console */
210 void
211 rte_eal_devargs_dump(FILE *f)
212 {
213         struct rte_devargs *devargs;
214
215         fprintf(f, "User device list:\n");
216         TAILQ_FOREACH(devargs, &devargs_list, next) {
217                 fprintf(f, "  [%s]: %s %s\n",
218                         (devargs->bus ? devargs->bus->name : "??"),
219                         devargs->name, devargs->args);
220         }
221 }
222
223 /* bus-aware rte_devargs iterator. */
224 __rte_experimental
225 struct rte_devargs *
226 rte_devargs_next(const char *busname, const struct rte_devargs *start)
227 {
228         struct rte_devargs *da;
229
230         if (start != NULL)
231                 da = TAILQ_NEXT(start, next);
232         else
233                 da = TAILQ_FIRST(&devargs_list);
234         while (da != NULL) {
235                 if (busname == NULL ||
236                     (strcmp(busname, da->bus->name) == 0))
237                         return da;
238                 da = TAILQ_NEXT(da, next);
239         }
240         return NULL;
241 }