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 rte_ether_addr *ea = out;
 371
 372         if ((value == NULL) || (out == NULL))
 373                 return -EINVAL;
 374
 375         return rte_ether_unformat_addr(value, ea);
 376 }
 377
 378 int
 379 failsafe_args_parse(struct rte_eth_dev *dev, const char *params)
 380 {
 381         struct fs_priv *priv;
 382         char mut_params[DEVARGS_MAXLEN] = "";
 383         struct rte_kvargs *kvlist = NULL;
 384         unsigned int arg_count;
 385         size_t n;
 386         int ret;
 387
 388         priv = PRIV(dev);
 389         ret = 0;
 390         priv->subs_tx = FAILSAFE_MAX_ETHPORTS;
 391         /* default parameters */
 392         n = strlcpy(mut_params, params, sizeof(mut_params));
 393         if (n >= sizeof(mut_params)) {
 394                 ERROR("Parameter string too long (>=%zu)",
 395                                 sizeof(mut_params));
 396                 return -ENOMEM;
 397         }
 398         ret = fs_parse_sub_devices(fs_parse_device_param,
 399                                    dev, params);
 400         if (ret < 0)
 401                 return ret;
 402         ret = fs_remove_sub_devices_definition(mut_params);
 403         if (ret < 0)
 404                 return ret;
 405         if (strnlen(mut_params, sizeof(mut_params)) > 0) {
 406                 kvlist = rte_kvargs_parse(mut_params,
 407                                 pmd_failsafe_init_parameters);
 408                 if (kvlist == NULL) {
 409                         ERROR("Error parsing parameters, usage:\n"
 410                                 PMD_FAILSAFE_PARAM_STRING);
 411                         return -1;
 412                 }
 413                 /* PLUG_IN event poll timer */
 414                 arg_count = rte_kvargs_count(kvlist,
 415                                 PMD_FAILSAFE_HOTPLUG_POLL_KVARG);
 416                 if (arg_count == 1) {
 417                         ret = rte_kvargs_process(kvlist,
 418                                         PMD_FAILSAFE_HOTPLUG_POLL_KVARG,
 419                                         &fs_get_u64_arg, &failsafe_hotplug_poll);
 420                         if (ret < 0)
 421                                 goto free_kvlist;
 422                 }
 423                 /* MAC addr */
 424                 arg_count = rte_kvargs_count(kvlist,
 425                                 PMD_FAILSAFE_MAC_KVARG);
 426                 if (arg_count > 0) {
 427                         ret = rte_kvargs_process(kvlist,
 428                                         PMD_FAILSAFE_MAC_KVARG,
 429                                         &fs_get_mac_addr_arg,
 430                                         &dev->data->mac_addrs[0]);
 431                         if (ret < 0)
 432                                 goto free_kvlist;
 433
 434                         failsafe_mac_from_arg = 1;
 435                 }
 436         }
 437         PRIV(dev)->state = DEV_PARSED;
 438 free_kvlist:
 439         rte_kvargs_free(kvlist);
 440         return ret;
 441 }
 442
 443 void
 444 failsafe_args_free(struct rte_eth_dev *dev)
 445 {
 446         struct sub_device *sdev;
 447         uint8_t i;
 448
 449         FOREACH_SUBDEV(sdev, i, dev) {
 450                 free(sdev->cmdline);
 451                 sdev->cmdline = NULL;
 452                 free(sdev->fd_str);
 453                 sdev->fd_str = NULL;
 454                 free(sdev->devargs.args);
 455                 sdev->devargs.args = NULL;
 456         }
 457 }
 458
 459 static int
 460 fs_count_device(struct rte_eth_dev *dev, const char *param,
 461                 uint8_t head __rte_unused)
 462 {
 463         size_t b = 0;
 464
 465         while  (param[b] != '(' &&
 466                 param[b] != '\0')
 467                 b++;
 468         if (strncmp(param, "dev", b) != 0 &&
 469             strncmp(param, "exec", b) != 0 &&
 470             strncmp(param, "fd(", b) != 0) {
 471                 ERROR("Unrecognized device type: %.*s", (int)b, param);
 472                 return -EINVAL;
 473         }
 474         PRIV(dev)->subs_tail += 1;
 475         return 0;
 476 }
 477
 478 int
 479 failsafe_args_count_subdevice(struct rte_eth_dev *dev,
 480                         const char *params)
 481 {
 482         return fs_parse_sub_devices(fs_count_device,
 483                                     dev, params);
 484 }
 485
 486 static int
 487 fs_parse_sub_device(struct sub_device *sdev)
 488 {
 489         struct rte_devargs *da;
 490         char devstr[DEVARGS_MAXLEN] = "";
 491
 492         da = &sdev->devargs;
 493         snprintf(devstr, sizeof(devstr), "%s,%s", da->name, da->args);
 494         return fs_parse_device(sdev, devstr);
 495 }
 496
 497 int
 498 failsafe_args_parse_subs(struct rte_eth_dev *dev)
 499 {
 500         struct sub_device *sdev;
 501         uint8_t i;
 502         int ret = 0;
 503
 504         FOREACH_SUBDEV(sdev, i, dev) {
 505                 if (sdev->state >= DEV_PARSED)
 506                         continue;
 507                 if (sdev->cmdline)
 508                         ret = fs_execute_cmd(sdev, sdev->cmdline);
 509                 else if (sdev->fd_str)
 510                         ret = fs_read_fd(sdev, sdev->fd_str);
 511                 else
 512                         ret = fs_parse_sub_device(sdev);
 513                 if (ret == 0)
 514                         sdev->state = DEV_PARSED;
 515         }
 516         return 0;
 517 }