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