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