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