ceph/src/seastar/dpdk/drivers/net/failsafe/failsafe_args.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2017 6WIND S.A.
   3  * Copyright 2017 Mellanox Technologies, Ltd
   4  */
   5
   6 #include <fcntl.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <unistd.h>
  11 #include <errno.h>
  12
  13 #include <rte_debug.h>
  14 #include <rte_devargs.h>
  15 #include <rte_malloc.h>
  16 #include <rte_kvargs.h>
  17 #include <rte_string_fns.h>
  18
  19 #include "failsafe_private.h"
  20
  21 /* Callback used when a new device is found in devargs */
  22 typedef int (parse_cb)(struct rte_eth_dev *dev, const char *params,
  23                 uint8_t head);
  24
  25 uint64_t failsafe_hotplug_poll = FAILSAFE_HOTPLUG_DEFAULT_TIMEOUT_MS;
  26 int failsafe_mac_from_arg;
  27
  28 static const char * const pmd_failsafe_init_parameters[] = {
  29         PMD_FAILSAFE_HOTPLUG_POLL_KVARG,
  30         PMD_FAILSAFE_MAC_KVARG,
  31         NULL,
  32 };
  33
  34 /*
  35  * input: text.
  36  * output: 0: if text[0] != '(',
  37  *         0: if there are no corresponding ')'
  38  *         n: distance to corresponding ')' otherwise
  39  */
  40 static size_t
  41 closing_paren(const char *text)
  42 {
  43         int nb_open = 0;
  44         size_t i = 0;
  45
  46         while (text[i] != '\0') {
  47                 if (text[i] == '(')
  48                         nb_open++;
  49                 if (text[i] == ')')
  50                         nb_open--;
  51                 if (nb_open == 0)
  52                         return i;
  53                 i++;
  54         }
  55         return 0;
  56 }
  57
  58 static int
  59 fs_parse_device(struct sub_device *sdev, char *args)
  60 {
  61         struct rte_devargs *d;
  62         int ret;
  63
  64         d = &sdev->devargs;
  65         DEBUG("%s", args);
  66         ret = rte_devargs_parse(d, args);
  67         if (ret) {
  68                 DEBUG("devargs parsing failed with code %d", ret);
  69                 return ret;
  70         }
  71         sdev->bus = d->bus;
  72         sdev->state = DEV_PARSED;
  73         return 0;
  74 }
  75
  76 static void
  77 fs_sanitize_cmdline(char *args)
  78 {
  79         char *nl;
  80
  81         nl = strrchr(args, '\n');
  82         if (nl)
  83                 nl[0] = '\0';
  84 }
  85
  86 static int
  87 fs_execute_cmd(struct sub_device *sdev, char *cmdline)
  88 {
  89         FILE *fp;
  90         /* store possible newline as well */
  91         char output[DEVARGS_MAXLEN + 1];
  92         size_t len;
  93         int ret;
  94
  95         RTE_ASSERT(cmdline != NULL || sdev->cmdline != NULL);
  96         if (sdev->cmdline == NULL) {
  97                 size_t i;
  98
  99                 len = strlen(cmdline) + 1;
 100                 sdev->cmdline = calloc(1, len);
 101                 if (sdev->cmdline == NULL) {
 102                         ERROR("Command line allocation failed");
 103                         return -ENOMEM;
 104                 }
 105                 strlcpy(sdev->cmdline, cmdline, len);
 106                 /* Replace all commas in the command line by spaces */
 107                 for (i = 0; i < len; i++)
 108                         if (sdev->cmdline[i] == ',')
 109                                 sdev->cmdline[i] = ' ';
 110         }
 111         DEBUG("'%s'", sdev->cmdline);
 112         fp = popen(sdev->cmdline, "r");
 113         if (fp == NULL) {
 114                 ret = -errno;
 115                 ERROR("popen: %s", strerror(errno));
 116                 return ret;
 117         }
 118         /* We only read one line */
 119         if (fgets(output, sizeof(output) - 1, fp) == NULL) {
 120                 DEBUG("Could not read command output");
 121                 ret = -ENODEV;
 122                 goto ret_pclose;
 123         }
 124         fs_sanitize_cmdline(output);
 125         if (output[0] == '\0') {
 126                 ret = -ENODEV;
 127                 goto ret_pclose;
 128         }
 129         ret = fs_parse_device(sdev, output);
 130         if (ret)
 131                 ERROR("Parsing device '%s' failed", output);
 132 ret_pclose:
 133         if (pclose(fp) == -1)
 134                 ERROR("pclose: %s", strerror(errno));
 135         return ret;
 136 }
 137
 138 static int
 139 fs_read_fd(struct sub_device *sdev, char *fd_str)
 140 {
 141         FILE *fp = NULL;
 142         int fd = -1;
 143         /* store possible newline as well */
 144         char output[DEVARGS_MAXLEN + 1];
 145         int err = -ENODEV;
 146         int oflags;
 147         int lcount;
 148
 149         RTE_ASSERT(fd_str != NULL || sdev->fd_str != NULL);
 150         if (sdev->fd_str == NULL) {
 151                 sdev->fd_str = strdup(fd_str);
 152                 if (sdev->fd_str == NULL) {
 153                         ERROR("Command line allocation failed");
 154                         return -ENOMEM;
 155                 }
 156         }
 157         errno = 0;
 158         fd = strtol(fd_str, &fd_str, 0);
 159         if (errno || *fd_str || fd < 0) {
 160                 ERROR("Parsing FD number failed");
 161                 goto error;
 162         }
 163         /* Fiddle with copy of file descriptor */
 164         fd = dup(fd);
 165         if (fd == -1)
 166                 goto error;
 167         oflags = fcntl(fd, F_GETFL);
 168         if (oflags == -1)
 169                 goto error;
 170         if (fcntl(fd, F_SETFL, oflags | O_NONBLOCK) == -1)
 171                 goto error;
 172         fp = fdopen(fd, "r");
 173         if (fp == NULL)
 174                 goto error;
 175         fd = -1;
 176         /* Only take the last line into account */
 177         lcount = 0;
 178         while (fgets(output, sizeof(output), fp))
 179                 ++lcount;
 180         if (lcount == 0)
 181                 goto error;
 182         else if (ferror(fp) && errno != EAGAIN)
 183                 goto error;
 184         /* Line must end with a newline character */
 185         fs_sanitize_cmdline(output);
 186         if (output[0] == '\0')
 187                 goto error;
 188         err = fs_parse_device(sdev, output);
 189         if (err)
 190                 ERROR("Parsing device '%s' failed", output);
 191 error:
 192         if (fp)
 193                 fclose(fp);
 194         if (fd != -1)
 195                 close(fd);
 196         return err;
 197 }
 198
 199 static int
 200 fs_parse_device_param(struct rte_eth_dev *dev, const char *param,
 201                 uint8_t head)
 202 {
 203         struct fs_priv *priv;
 204         struct sub_device *sdev;
 205         char *args = NULL;
 206         size_t a, b;
 207         int ret;
 208
 209         priv = PRIV(dev);
 210         a = 0;
 211         b = 0;
 212         ret = 0;
 213         while  (param[b] != '(' &&
 214                 param[b] != '\0')
 215                 b++;
 216         a = b;
 217         b += closing_paren(&param[b]);
 218         if (a == b) {
 219                 ERROR("Dangling parenthesis");
 220                 return -EINVAL;
 221         }
 222         a += 1;
 223         args = strndup(&param[a], b - a);
 224         if (args == NULL) {
 225                 ERROR("Not enough memory for parameter parsing");
 226                 return -ENOMEM;
 227         }
 228         sdev = &priv->subs[head];
 229         if (strncmp(param, "dev", 3) == 0) {
 230                 ret = fs_parse_device(sdev, args);
 231                 if (ret)
 232                         goto free_args;
 233         } else if (strncmp(param, "exec", 4) == 0) {
 234                 ret = fs_execute_cmd(sdev, args);
 235                 if (ret == -ENODEV) {
 236                         DEBUG("Reading device info from command line failed");
 237                         ret = 0;
 238                 }
 239                 if (ret)
 240                         goto free_args;
 241         } else if (strncmp(param, "fd(", 3) == 0) {
 242                 ret = fs_read_fd(sdev, args);
 243                 if (ret == -ENODEV) {
 244                         DEBUG("Reading device info from FD failed");
 245                         ret = 0;
 246                 }
 247                 if (ret)
 248                         goto free_args;
 249         } else {
 250                 ERROR("Unrecognized device type: %.*s", (int)b, param);
 251                 return -EINVAL;
 252         }
 253 free_args:
 254         free(args);
 255         return ret;
 256 }
 257
 258 static int
 259 fs_parse_sub_devices(parse_cb *cb,
 260                 struct rte_eth_dev *dev, const char *params)
 261 {
 262         size_t a, b;
 263         uint8_t head;
 264         int ret;
 265
 266         a = 0;
 267         head = 0;
 268         ret = 0;
 269         while (params[a] != '\0') {
 270                 b = a;
 271                 while (params[b] != '(' &&
 272                        params[b] != ',' &&
 273                        params[b] != '\0')
 274                         b++;
 275                 if (b == a) {
 276                         ERROR("Invalid parameter");
 277                         return -EINVAL;
 278                 }
 279                 if (params[b] == ',') {
 280                         a = b + 1;
 281                         continue;
 282                 }
 283                 if (params[b] == '(') {
 284                         size_t start = b;
 285
 286                         b += closing_paren(&params[b]);
 287                         if (b == start) {
 288                                 ERROR("Dangling parenthesis");
 289                                 return -EINVAL;
 290                         }
 291                         ret = (*cb)(dev, &params[a], head);
 292                         if (ret)
 293                                 return ret;
 294                         head += 1;
 295                         b += 1;
 296                         if (params[b] == '\0')
 297                                 return 0;
 298                 }
 299                 a = b + 1;
 300         }
 301         return 0;
 302 }
 303
 304 static int
 305 fs_remove_sub_devices_definition(char params[DEVARGS_MAXLEN])
 306 {
 307         char buffer[DEVARGS_MAXLEN] = {0};
 308         size_t a, b;
 309         int i;
 310
 311         a = 0;
 312         i = 0;
 313         while (params[a] != '\0') {
 314                 b = a;
 315                 while (params[b] != '(' &&
 316                        params[b] != ',' &&
 317                        params[b] != '\0')
 318                         b++;
 319                 if (b == a) {
 320                         ERROR("Invalid parameter");
 321                         return -EINVAL;
 322                 }
 323                 if (params[b] == ',' || params[b] == '\0') {
 324                         size_t len = b - a;
 325
 326                         if (i > 0)
 327                                 len += 1;
 328                         snprintf(&buffer[i], len + 1, "%s%s",
 329                                         i ? "," : "", &params[a]);
 330                         i += len;
 331                 } else if (params[b] == '(') {
 332                         size_t start = b;
 333
 334                         b += closing_paren(&params[b]);
 335                         if (b == start)
 336                                 return -EINVAL;
 337                         b += 1;
 338                         if (params[b] == '\0')
 339                                 goto out;
 340                 }
 341                 a = b + 1;
 342         }
 343 out:
 344         strlcpy(params, buffer, DEVARGS_MAXLEN);
 345         return 0;
 346 }
 347
 348 static int
 349 fs_get_u64_arg(const char *key __rte_unused,
 350                 const char *value, void *out)
 351 {
 352         uint64_t *u64 = out;
 353         char *endptr = NULL;
 354
 355         if ((value == NULL) || (out == NULL))
 356                 return -EINVAL;
 357         errno = 0;
 358         *u64 = strtoull(value, &endptr, 0);
 359         if (errno != 0)
 360                 return -errno;
 361         if (endptr == value)
 362                 return -1;
 363         return 0;
 364 }
 365
 366 static int
 367 fs_get_mac_addr_arg(const char *key __rte_unused,
 368                 const char *value, void *out)
 369 {
 370         struct ether_addr *ea = out;
 371         int ret;
 372
 373         if ((value == NULL) || (out == NULL))
 374                 return -EINVAL;
 375         ret = sscanf(value, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
 376                 &ea->addr_bytes[0], &ea->addr_bytes[1],
 377                 &ea->addr_bytes[2], &ea->addr_bytes[3],
 378                 &ea->addr_bytes[4], &ea->addr_bytes[5]);
 379         return ret != ETHER_ADDR_LEN;
 380 }
 381
 382 int
 383 failsafe_args_parse(struct rte_eth_dev *dev, const char *params)
 384 {
 385         struct fs_priv *priv;
 386         char mut_params[DEVARGS_MAXLEN] = "";
 387         struct rte_kvargs *kvlist = NULL;
 388         unsigned int arg_count;
 389         size_t n;
 390         int ret;
 391
 392         priv = PRIV(dev);
 393         ret = 0;
 394         priv->subs_tx = FAILSAFE_MAX_ETHPORTS;
 395         /* default parameters */
 396         n = strlcpy(mut_params, params, sizeof(mut_params));
 397         if (n >= sizeof(mut_params)) {
 398                 ERROR("Parameter string too long (>=%zu)",
 399                                 sizeof(mut_params));
 400                 return -ENOMEM;
 401         }
 402         ret = fs_parse_sub_devices(fs_parse_device_param,
 403                                    dev, params);
 404         if (ret < 0)
 405                 return ret;
 406         ret = fs_remove_sub_devices_definition(mut_params);
 407         if (ret < 0)
 408                 return ret;
 409         if (strnlen(mut_params, sizeof(mut_params)) > 0) {
 410                 kvlist = rte_kvargs_parse(mut_params,
 411                                 pmd_failsafe_init_parameters);
 412                 if (kvlist == NULL) {
 413                         ERROR("Error parsing parameters, usage:\n"
 414                                 PMD_FAILSAFE_PARAM_STRING);
 415                         return -1;
 416                 }
 417                 /* PLUG_IN event poll timer */
 418                 arg_count = rte_kvargs_count(kvlist,
 419                                 PMD_FAILSAFE_HOTPLUG_POLL_KVARG);
 420                 if (arg_count == 1) {
 421                         ret = rte_kvargs_process(kvlist,
 422                                         PMD_FAILSAFE_HOTPLUG_POLL_KVARG,
 423                                         &fs_get_u64_arg, &failsafe_hotplug_poll);
 424                         if (ret < 0)
 425                                 goto free_kvlist;
 426                 }
 427                 /* MAC addr */
 428                 arg_count = rte_kvargs_count(kvlist,
 429                                 PMD_FAILSAFE_MAC_KVARG);
 430                 if (arg_count > 0) {
 431                         ret = rte_kvargs_process(kvlist,
 432                                         PMD_FAILSAFE_MAC_KVARG,
 433                                         &fs_get_mac_addr_arg,
 434                                         &dev->data->mac_addrs[0]);
 435                         if (ret < 0)
 436                                 goto free_kvlist;
 437
 438                         failsafe_mac_from_arg = 1;
 439                 }
 440         }
 441         PRIV(dev)->state = DEV_PARSED;
 442 free_kvlist:
 443         rte_kvargs_free(kvlist);
 444         return ret;
 445 }
 446
 447 void
 448 failsafe_args_free(struct rte_eth_dev *dev)
 449 {
 450         struct sub_device *sdev;
 451         uint8_t i;
 452
 453         FOREACH_SUBDEV(sdev, i, dev) {
 454                 free(sdev->cmdline);
 455                 sdev->cmdline = NULL;
 456                 free(sdev->fd_str);
 457                 sdev->fd_str = NULL;
 458                 free(sdev->devargs.args);
 459                 sdev->devargs.args = NULL;
 460         }
 461 }
 462
 463 static int
 464 fs_count_device(struct rte_eth_dev *dev, const char *param,
 465                 uint8_t head __rte_unused)
 466 {
 467         size_t b = 0;
 468
 469         while  (param[b] != '(' &&
 470                 param[b] != '\0')
 471                 b++;
 472         if (strncmp(param, "dev", b) != 0 &&
 473             strncmp(param, "exec", b) != 0 &&
 474             strncmp(param, "fd(", b) != 0) {
 475                 ERROR("Unrecognized device type: %.*s", (int)b, param);
 476                 return -EINVAL;
 477         }
 478         PRIV(dev)->subs_tail += 1;
 479         return 0;
 480 }
 481
 482 int
 483 failsafe_args_count_subdevice(struct rte_eth_dev *dev,
 484                         const char *params)
 485 {
 486         return fs_parse_sub_devices(fs_count_device,
 487                                     dev, params);
 488 }
 489
 490 static int
 491 fs_parse_sub_device(struct sub_device *sdev)
 492 {
 493         struct rte_devargs *da;
 494         char devstr[DEVARGS_MAXLEN] = "";
 495
 496         da = &sdev->devargs;
 497         snprintf(devstr, sizeof(devstr), "%s,%s", da->name, da->args);
 498         return fs_parse_device(sdev, devstr);
 499 }
 500
 501 int
 502 failsafe_args_parse_subs(struct rte_eth_dev *dev)
 503 {
 504         struct sub_device *sdev;
 505         uint8_t i;
 506         int ret = 0;
 507
 508         FOREACH_SUBDEV(sdev, i, dev) {
 509                 if (sdev->state >= DEV_PARSED)
 510                         continue;
 511                 if (sdev->cmdline)
 512                         ret = fs_execute_cmd(sdev, sdev->cmdline);
 513                 else if (sdev->fd_str)
 514                         ret = fs_read_fd(sdev, sdev->fd_str);
 515                 else
 516                         ret = fs_parse_sub_device(sdev);
 517                 if (ret == 0)
 518                         sdev->state = DEV_PARSED;
 519         }
 520         return 0;
 521 }