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
   9 #include <stdio.h>
  10 #include <string.h>
  11 #include <stdarg.h>
  12
  13 #include <rte_bus.h>
  14 #include <rte_class.h>
  15 #include <rte_compat.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 "eal_private.h"
  23
  24 /** user device double-linked queue type definition */
  25 TAILQ_HEAD(rte_devargs_list, rte_devargs);
  26
  27 /** Global list of user devices */
  28 struct rte_devargs_list devargs_list =
  29         TAILQ_HEAD_INITIALIZER(devargs_list);
  30
  31 int
  32 rte_eal_parse_devargs_str(const char *devargs_str,
  33                         char **drvname, char **drvargs)
  34 {
  35         char *sep;
  36
  37         if ((devargs_str) == NULL || (drvname) == NULL || (drvargs == NULL))
  38                 return -1;
  39
  40         *drvname = strdup(devargs_str);
  41         if (*drvname == NULL)
  42                 return -1;
  43
  44         /* set the first ',' to '\0' to split name and arguments */
  45         sep = strchr(*drvname, ',');
  46         if (sep != NULL) {
  47                 sep[0] = '\0';
  48                 *drvargs = strdup(sep + 1);
  49         } else {
  50                 *drvargs = strdup("");
  51         }
  52
  53         if (*drvargs == NULL) {
  54                 free(*drvname);
  55                 *drvname = NULL;
  56                 return -1;
  57         }
  58         return 0;
  59 }
  60
  61 static size_t
  62 devargs_layer_count(const char *s)
  63 {
  64         size_t i = s ? 1 : 0;
  65
  66         while (s != NULL && s[0] != '\0') {
  67                 i += s[0] == '/';
  68                 s++;
  69         }
  70         return i;
  71 }
  72
  73 int
  74 rte_devargs_layers_parse(struct rte_devargs *devargs,
  75                          const char *devstr)
  76 {
  77         struct {
  78                 const char *key;
  79                 const char *str;
  80                 struct rte_kvargs *kvlist;
  81         } layers[] = {
  82                 { "bus=",    NULL, NULL, },
  83                 { "class=",  NULL, NULL, },
  84                 { "driver=", NULL, NULL, },
  85         };
  86         struct rte_kvargs_pair *kv = NULL;
  87         struct rte_class *cls = NULL;
  88         struct rte_bus *bus = NULL;
  89         const char *s = devstr;
  90         size_t nblayer;
  91         size_t i = 0;
  92         int ret = 0;
  93
  94         /* Split each sub-lists. */
  95         nblayer = devargs_layer_count(devstr);
  96         if (nblayer > RTE_DIM(layers)) {
  97                 RTE_LOG(ERR, EAL, "Invalid format: too many layers (%zu)\n",
  98                         nblayer);
  99                 ret = -E2BIG;
 100                 goto get_out;
 101         }
 102
 103         /* If the devargs points the devstr
 104          * as source data, then it should not allocate
 105          * anything and keep referring only to it.
 106          */
 107         if (devargs->data != devstr) {
 108                 devargs->data = strdup(devstr);
 109                 if (devargs->data == NULL) {
 110                         RTE_LOG(ERR, EAL, "OOM\n");
 111                         ret = -ENOMEM;
 112                         goto get_out;
 113                 }
 114                 s = devargs->data;
 115         }
 116
 117         while (s != NULL) {
 118                 if (i >= RTE_DIM(layers)) {
 119                         RTE_LOG(ERR, EAL, "Unrecognized layer %s\n", s);
 120                         ret = -EINVAL;
 121                         goto get_out;
 122                 }
 123                 /*
 124                  * The last layer is free-form.
 125                  * The "driver" key is not required (but accepted).
 126                  */
 127                 if (strncmp(layers[i].key, s, strlen(layers[i].key)) &&
 128                                 i != RTE_DIM(layers) - 1)
 129                         goto next_layer;
 130                 layers[i].str = s;
 131                 layers[i].kvlist = rte_kvargs_parse_delim(s, NULL, "/");
 132                 if (layers[i].kvlist == NULL) {
 133                         RTE_LOG(ERR, EAL, "Could not parse %s\n", s);
 134                         ret = -EINVAL;
 135                         goto get_out;
 136                 }
 137                 s = strchr(s, '/');
 138                 if (s != NULL)
 139                         s++;
 140 next_layer:
 141                 i++;
 142         }
 143
 144         /* Parse each sub-list. */
 145         for (i = 0; i < RTE_DIM(layers); i++) {
 146                 if (layers[i].kvlist == NULL)
 147                         continue;
 148                 kv = &layers[i].kvlist->pairs[0];
 149                 if (strcmp(kv->key, "bus") == 0) {
 150                         bus = rte_bus_find_by_name(kv->value);
 151                         if (bus == NULL) {
 152                                 RTE_LOG(ERR, EAL, "Could not find bus \"%s\"\n",
 153                                         kv->value);
 154                                 ret = -EFAULT;
 155                                 goto get_out;
 156                         }
 157                 } else if (strcmp(kv->key, "class") == 0) {
 158                         cls = rte_class_find_by_name(kv->value);
 159                         if (cls == NULL) {
 160                                 RTE_LOG(ERR, EAL, "Could not find class \"%s\"\n",
 161                                         kv->value);
 162                                 ret = -EFAULT;
 163                                 goto get_out;
 164                         }
 165                 } else if (strcmp(kv->key, "driver") == 0) {
 166                         /* Ignore */
 167                         continue;
 168                 }
 169         }
 170
 171         /* Fill devargs fields. */
 172         devargs->bus_str = layers[0].str;
 173         devargs->cls_str = layers[1].str;
 174         devargs->drv_str = layers[2].str;
 175         devargs->bus = bus;
 176         devargs->cls = cls;
 177
 178         /* If we own the data, clean up a bit
 179          * the several layers string, to ease
 180          * their parsing afterward.
 181          */
 182         if (devargs->data != devstr) {
 183                 char *s = (void *)(intptr_t)(devargs->data);
 184
 185                 while ((s = strchr(s, '/'))) {
 186                         *s = '\0';
 187                         s++;
 188                 }
 189         }
 190
 191 get_out:
 192         for (i = 0; i < RTE_DIM(layers); i++) {
 193                 if (layers[i].kvlist)
 194                         rte_kvargs_free(layers[i].kvlist);
 195         }
 196         if (ret != 0)
 197                 rte_errno = -ret;
 198         return ret;
 199 }
 200
 201 static int
 202 bus_name_cmp(const struct rte_bus *bus, const void *name)
 203 {
 204         return strncmp(bus->name, name, strlen(bus->name));
 205 }
 206
 207 __rte_experimental
 208 int
 209 rte_devargs_parse(struct rte_devargs *da, const char *dev)
 210 {
 211         struct rte_bus *bus = NULL;
 212         const char *devname;
 213         const size_t maxlen = sizeof(da->name);
 214         size_t i;
 215
 216         if (da == NULL)
 217                 return -EINVAL;
 218
 219         /* Retrieve eventual bus info */
 220         do {
 221                 devname = dev;
 222                 bus = rte_bus_find(bus, bus_name_cmp, dev);
 223                 if (bus == NULL)
 224                         break;
 225                 devname = dev + strlen(bus->name) + 1;
 226                 if (rte_bus_find_by_device_name(devname) == bus)
 227                         break;
 228         } while (1);
 229         /* Store device name */
 230         i = 0;
 231         while (devname[i] != '\0' && devname[i] != ',') {
 232                 da->name[i] = devname[i];
 233                 i++;
 234                 if (i == maxlen) {
 235                         RTE_LOG(WARNING, EAL, "Parsing \"%s\": device name should be shorter than %zu\n",
 236                                 dev, maxlen);
 237                         da->name[i - 1] = '\0';
 238                         return -EINVAL;
 239                 }
 240         }
 241         da->name[i] = '\0';
 242         if (bus == NULL) {
 243                 bus = rte_bus_find_by_device_name(da->name);
 244                 if (bus == NULL) {
 245                         RTE_LOG(ERR, EAL, "failed to parse device \"%s\"\n",
 246                                 da->name);
 247                         return -EFAULT;
 248                 }
 249         }
 250         da->bus = bus;
 251         /* Parse eventual device arguments */
 252         if (devname[i] == ',')
 253                 da->args = strdup(&devname[i + 1]);
 254         else
 255                 da->args = strdup("");
 256         if (da->args == NULL) {
 257                 RTE_LOG(ERR, EAL, "not enough memory to parse arguments\n");
 258                 return -ENOMEM;
 259         }
 260         return 0;
 261 }
 262
 263 __rte_experimental
 264 int
 265 rte_devargs_parsef(struct rte_devargs *da, const char *format, ...)
 266 {
 267         va_list ap;
 268         size_t len;
 269         char *dev;
 270
 271         if (da == NULL)
 272                 return -EINVAL;
 273
 274         va_start(ap, format);
 275         len = vsnprintf(NULL, 0, format, ap);
 276         va_end(ap);
 277
 278         dev = calloc(1, len + 1);
 279         if (dev == NULL) {
 280                 RTE_LOG(ERR, EAL, "not enough memory to parse device\n");
 281                 return -ENOMEM;
 282         }
 283
 284         va_start(ap, format);
 285         vsnprintf(dev, len + 1, format, ap);
 286         va_end(ap);
 287
 288         return rte_devargs_parse(da, dev);
 289 }
 290
 291 int __rte_experimental
 292 rte_devargs_insert(struct rte_devargs *da)
 293 {
 294         int ret;
 295
 296         ret = rte_devargs_remove(da->bus->name, da->name);
 297         if (ret < 0)
 298                 return ret;
 299         TAILQ_INSERT_TAIL(&devargs_list, da, next);
 300         return 0;
 301 }
 302
 303 /* store a whitelist parameter for later parsing */
 304 __rte_experimental
 305 int
 306 rte_devargs_add(enum rte_devtype devtype, const char *devargs_str)
 307 {
 308         struct rte_devargs *devargs = NULL;
 309         struct rte_bus *bus = NULL;
 310         const char *dev = devargs_str;
 311
 312         /* use calloc instead of rte_zmalloc as it's called early at init */
 313         devargs = calloc(1, sizeof(*devargs));
 314         if (devargs == NULL)
 315                 goto fail;
 316
 317         if (rte_devargs_parse(devargs, dev))
 318                 goto fail;
 319         devargs->type = devtype;
 320         bus = devargs->bus;
 321         if (devargs->type == RTE_DEVTYPE_BLACKLISTED_PCI)
 322                 devargs->policy = RTE_DEV_BLACKLISTED;
 323         if (bus->conf.scan_mode == RTE_BUS_SCAN_UNDEFINED) {
 324                 if (devargs->policy == RTE_DEV_WHITELISTED)
 325                         bus->conf.scan_mode = RTE_BUS_SCAN_WHITELIST;
 326                 else if (devargs->policy == RTE_DEV_BLACKLISTED)
 327                         bus->conf.scan_mode = RTE_BUS_SCAN_BLACKLIST;
 328         }
 329         TAILQ_INSERT_TAIL(&devargs_list, devargs, next);
 330         return 0;
 331
 332 fail:
 333         if (devargs) {
 334                 free(devargs->args);
 335                 free(devargs);
 336         }
 337
 338         return -1;
 339 }
 340
 341 int __rte_experimental
 342 rte_devargs_remove(const char *busname, const char *devname)
 343 {
 344         struct rte_devargs *d;
 345         void *tmp;
 346
 347         TAILQ_FOREACH_SAFE(d, &devargs_list, next, tmp) {
 348                 if (strcmp(d->bus->name, busname) == 0 &&
 349                     strcmp(d->name, devname) == 0) {
 350                         TAILQ_REMOVE(&devargs_list, d, next);
 351                         free(d->args);
 352                         free(d);
 353                         return 0;
 354                 }
 355         }
 356         return 1;
 357 }
 358
 359 /* count the number of devices of a specified type */
 360 __rte_experimental
 361 unsigned int
 362 rte_devargs_type_count(enum rte_devtype devtype)
 363 {
 364         struct rte_devargs *devargs;
 365         unsigned int count = 0;
 366
 367         TAILQ_FOREACH(devargs, &devargs_list, next) {
 368                 if (devargs->type != devtype)
 369                         continue;
 370                 count++;
 371         }
 372         return count;
 373 }
 374
 375 /* dump the user devices on the console */
 376 __rte_experimental
 377 void
 378 rte_devargs_dump(FILE *f)
 379 {
 380         struct rte_devargs *devargs;
 381
 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);
 387         }
 388 }
 389
 390 /* bus-aware rte_devargs iterator. */
 391 __rte_experimental
 392 struct rte_devargs *
 393 rte_devargs_next(const char *busname, const struct rte_devargs *start)
 394 {
 395         struct rte_devargs *da;
 396
 397         if (start != NULL)
 398                 da = TAILQ_NEXT(start, next);
 399         else
 400                 da = TAILQ_FIRST(&devargs_list);
 401         while (da != NULL) {
 402                 if (busname == NULL ||
 403                     (strcmp(busname, da->bus->name) == 0))
 404                         return da;
 405                 da = TAILQ_NEXT(da, next);
 406         }
 407         return NULL;
 408 }