1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright 2017 6WIND S.A.
3 * Copyright 2017 Mellanox.
13 #include <rte_debug.h>
14 #include <rte_devargs.h>
15 #include <rte_malloc.h>
16 #include <rte_kvargs.h>
18 #include "failsafe_private.h"
20 /* Callback used when a new device is found in devargs */
21 typedef int (parse_cb)(struct rte_eth_dev *dev, const char *params,
24 uint64_t hotplug_poll = FAILSAFE_HOTPLUG_DEFAULT_TIMEOUT_MS;
27 const char *pmd_failsafe_init_parameters[] = {
28 PMD_FAILSAFE_HOTPLUG_POLL_KVARG,
29 PMD_FAILSAFE_MAC_KVARG,
35 * output: 0: if text[0] != '(',
36 * 0: if there are no corresponding ')'
37 * n: distance to corresponding ')' otherwise
40 closing_paren(const char *text)
45 while (text[i] != '\0') {
58 fs_parse_device(struct sub_device *sdev, char *args)
60 struct rte_devargs *d;
65 ret = rte_eal_devargs_parse(args, d);
67 DEBUG("devargs parsing failed with code %d", ret);
71 sdev->state = DEV_PARSED;
76 fs_sanitize_cmdline(char *args)
80 nl = strrchr(args, '\n');
86 fs_execute_cmd(struct sub_device *sdev, char *cmdline)
89 /* store possible newline as well */
90 char output[DEVARGS_MAXLEN + 1];
94 RTE_ASSERT(cmdline != NULL || sdev->cmdline != NULL);
95 if (sdev->cmdline == NULL) {
98 len = strlen(cmdline) + 1;
99 sdev->cmdline = calloc(1, len);
100 if (sdev->cmdline == NULL) {
101 ERROR("Command line allocation failed");
104 snprintf(sdev->cmdline, len, "%s", cmdline);
105 /* Replace all commas in the command line by spaces */
106 for (i = 0; i < len; i++)
107 if (sdev->cmdline[i] == ',')
108 sdev->cmdline[i] = ' ';
110 DEBUG("'%s'", sdev->cmdline);
111 fp = popen(sdev->cmdline, "r");
114 ERROR("popen: %s", strerror(errno));
117 /* We only read one line */
118 if (fgets(output, sizeof(output) - 1, fp) == NULL) {
119 DEBUG("Could not read command output");
123 fs_sanitize_cmdline(output);
124 if (output[0] == '\0') {
128 ret = fs_parse_device(sdev, output);
130 ERROR("Parsing device '%s' failed", output);
132 if (pclose(fp) == -1)
133 ERROR("pclose: %s", strerror(errno));
138 fs_read_fd(struct sub_device *sdev, char *fd_str)
142 /* store possible newline as well */
143 char output[DEVARGS_MAXLEN + 1];
148 RTE_ASSERT(fd_str != NULL || sdev->fd_str != NULL);
149 if (sdev->fd_str == NULL) {
150 sdev->fd_str = strdup(fd_str);
151 if (sdev->fd_str == NULL) {
152 ERROR("Command line allocation failed");
157 fd = strtol(fd_str, &fd_str, 0);
158 if (errno || *fd_str || fd < 0) {
159 ERROR("Parsing FD number failed");
162 /* Fiddle with copy of file descriptor */
166 oflags = fcntl(fd, F_GETFL);
169 if (fcntl(fd, F_SETFL, oflags | O_NONBLOCK) == -1)
171 fp = fdopen(fd, "r");
175 /* Only take the last line into account */
177 while (fgets(output, sizeof(output), fp))
181 else if (ferror(fp) && errno != EAGAIN)
183 /* Line must end with a newline character */
184 fs_sanitize_cmdline(output);
185 if (output[0] == '\0')
187 err = fs_parse_device(sdev, output);
189 ERROR("Parsing device '%s' failed", output);
199 fs_parse_device_param(struct rte_eth_dev *dev, const char *param,
202 struct fs_priv *priv;
203 struct sub_device *sdev;
212 while (param[b] != '(' &&
216 b += closing_paren(¶m[b]);
218 ERROR("Dangling parenthesis");
222 args = strndup(¶m[a], b - a);
224 ERROR("Not enough memory for parameter parsing");
227 sdev = &priv->subs[head];
228 if (strncmp(param, "dev", 3) == 0) {
229 ret = fs_parse_device(sdev, args);
232 } else if (strncmp(param, "exec", 4) == 0) {
233 ret = fs_execute_cmd(sdev, args);
234 if (ret == -ENODEV) {
235 DEBUG("Reading device info from command line failed");
240 } else if (strncmp(param, "fd(", 3) == 0) {
241 ret = fs_read_fd(sdev, args);
242 if (ret == -ENODEV) {
243 DEBUG("Reading device info from FD failed");
249 ERROR("Unrecognized device type: %.*s", (int)b, param);
258 fs_parse_sub_devices(parse_cb *cb,
259 struct rte_eth_dev *dev, const char *params)
268 while (params[a] != '\0') {
270 while (params[b] != '(' &&
275 ERROR("Invalid parameter");
278 if (params[b] == ',') {
282 if (params[b] == '(') {
285 b += closing_paren(¶ms[b]);
287 ERROR("Dangling parenthesis");
290 ret = (*cb)(dev, ¶ms[a], head);
295 if (params[b] == '\0')
304 fs_remove_sub_devices_definition(char params[DEVARGS_MAXLEN])
306 char buffer[DEVARGS_MAXLEN] = {0};
312 while (params[a] != '\0') {
314 while (params[b] != '(' &&
319 ERROR("Invalid parameter");
322 if (params[b] == ',' || params[b] == '\0') {
327 snprintf(&buffer[i], len + 1, "%s%s",
328 i ? "," : "", ¶ms[a]);
330 } else if (params[b] == '(') {
333 b += closing_paren(¶ms[b]);
337 if (params[b] == '\0')
343 snprintf(params, DEVARGS_MAXLEN, "%s", buffer);
348 fs_get_u64_arg(const char *key __rte_unused,
349 const char *value, void *out)
354 if ((value == NULL) || (out == NULL))
357 *u64 = strtoull(value, &endptr, 0);
366 fs_get_mac_addr_arg(const char *key __rte_unused,
367 const char *value, void *out)
369 struct ether_addr *ea = out;
372 if ((value == NULL) || (out == NULL))
374 ret = sscanf(value, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
375 &ea->addr_bytes[0], &ea->addr_bytes[1],
376 &ea->addr_bytes[2], &ea->addr_bytes[3],
377 &ea->addr_bytes[4], &ea->addr_bytes[5]);
378 return ret != ETHER_ADDR_LEN;
382 failsafe_args_parse(struct rte_eth_dev *dev, const char *params)
384 struct fs_priv *priv;
385 char mut_params[DEVARGS_MAXLEN] = "";
386 struct rte_kvargs *kvlist = NULL;
387 unsigned int arg_count;
393 priv->subs_tx = FAILSAFE_MAX_ETHPORTS;
394 /* default parameters */
395 n = snprintf(mut_params, sizeof(mut_params), "%s", params);
396 if (n >= sizeof(mut_params)) {
397 ERROR("Parameter string too long (>=%zu)",
401 ret = fs_parse_sub_devices(fs_parse_device_param,
405 ret = fs_remove_sub_devices_definition(mut_params);
408 if (strnlen(mut_params, sizeof(mut_params)) > 0) {
409 kvlist = rte_kvargs_parse(mut_params,
410 pmd_failsafe_init_parameters);
411 if (kvlist == NULL) {
412 ERROR("Error parsing parameters, usage:\n"
413 PMD_FAILSAFE_PARAM_STRING);
416 /* PLUG_IN event poll timer */
417 arg_count = rte_kvargs_count(kvlist,
418 PMD_FAILSAFE_HOTPLUG_POLL_KVARG);
419 if (arg_count == 1) {
420 ret = rte_kvargs_process(kvlist,
421 PMD_FAILSAFE_HOTPLUG_POLL_KVARG,
422 &fs_get_u64_arg, &hotplug_poll);
427 arg_count = rte_kvargs_count(kvlist,
428 PMD_FAILSAFE_MAC_KVARG);
430 ret = rte_kvargs_process(kvlist,
431 PMD_FAILSAFE_MAC_KVARG,
432 &fs_get_mac_addr_arg,
433 &dev->data->mac_addrs[0]);
440 PRIV(dev)->state = DEV_PARSED;
442 rte_kvargs_free(kvlist);
447 failsafe_args_free(struct rte_eth_dev *dev)
449 struct sub_device *sdev;
452 FOREACH_SUBDEV(sdev, i, dev) {
454 sdev->cmdline = NULL;
457 free(sdev->devargs.args);
458 sdev->devargs.args = NULL;
463 fs_count_device(struct rte_eth_dev *dev, const char *param,
464 uint8_t head __rte_unused)
468 while (param[b] != '(' &&
471 if (strncmp(param, "dev", b) != 0 &&
472 strncmp(param, "exec", b) != 0 &&
473 strncmp(param, "fd(", b) != 0) {
474 ERROR("Unrecognized device type: %.*s", (int)b, param);
477 PRIV(dev)->subs_tail += 1;
482 failsafe_args_count_subdevice(struct rte_eth_dev *dev,
485 return fs_parse_sub_devices(fs_count_device,
490 fs_parse_sub_device(struct sub_device *sdev)
492 struct rte_devargs *da;
493 char devstr[DEVARGS_MAXLEN] = "";
496 snprintf(devstr, sizeof(devstr), "%s,%s", da->name, da->args);
497 return fs_parse_device(sdev, devstr);
501 failsafe_args_parse_subs(struct rte_eth_dev *dev)
503 struct sub_device *sdev;
507 FOREACH_SUBDEV(sdev, i, dev) {
508 if (sdev->state >= DEV_PARSED)
511 ret = fs_execute_cmd(sdev, sdev->cmdline);
512 else if (sdev->fd_str)
513 ret = fs_read_fd(sdev, sdev->fd_str);
515 ret = fs_parse_sub_device(sdev);
517 sdev->state = DEV_PARSED;