4 * Copyright 2017 6WIND S.A.
5 * Copyright 2017 Mellanox.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of 6WIND S.A. nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
41 #include <rte_debug.h>
42 #include <rte_devargs.h>
43 #include <rte_malloc.h>
44 #include <rte_kvargs.h>
46 #include "failsafe_private.h"
48 #define DEVARGS_MAXLEN 4096
50 /* Callback used when a new device is found in devargs */
51 typedef int (parse_cb)(struct rte_eth_dev *dev, const char *params,
54 uint64_t hotplug_poll = FAILSAFE_HOTPLUG_DEFAULT_TIMEOUT_MS;
57 const char *pmd_failsafe_init_parameters[] = {
58 PMD_FAILSAFE_HOTPLUG_POLL_KVARG,
59 PMD_FAILSAFE_MAC_KVARG,
65 * output: 0: if text[0] != '(',
66 * 0: if there are no corresponding ')'
67 * n: distance to corresponding ')' otherwise
70 closing_paren(const char *text)
75 while (text[i] != '\0') {
88 fs_parse_device(struct sub_device *sdev, char *args)
90 struct rte_devargs *d;
95 ret = rte_eal_devargs_parse(args, d);
97 DEBUG("devargs parsing failed with code %d", ret);
101 sdev->state = DEV_PARSED;
106 fs_sanitize_cmdline(char *args)
110 nl = strrchr(args, '\n');
116 fs_execute_cmd(struct sub_device *sdev, char *cmdline)
119 /* store possible newline as well */
120 char output[DEVARGS_MAXLEN + 1];
124 RTE_ASSERT(cmdline != NULL || sdev->cmdline != NULL);
125 if (sdev->cmdline == NULL) {
128 len = strlen(cmdline) + 1;
129 sdev->cmdline = calloc(1, len);
130 if (sdev->cmdline == NULL) {
131 ERROR("Command line allocation failed");
134 snprintf(sdev->cmdline, len, "%s", cmdline);
135 /* Replace all commas in the command line by spaces */
136 for (i = 0; i < len; i++)
137 if (sdev->cmdline[i] == ',')
138 sdev->cmdline[i] = ' ';
140 DEBUG("'%s'", sdev->cmdline);
141 fp = popen(sdev->cmdline, "r");
144 ERROR("popen: %s", strerror(errno));
147 /* We only read one line */
148 if (fgets(output, sizeof(output) - 1, fp) == NULL) {
149 DEBUG("Could not read command output");
153 fs_sanitize_cmdline(output);
154 if (output[0] == '\0') {
158 ret = fs_parse_device(sdev, output);
160 ERROR("Parsing device '%s' failed", output);
162 if (pclose(fp) == -1)
163 ERROR("pclose: %s", strerror(errno));
168 fs_read_fd(struct sub_device *sdev, char *fd_str)
172 /* store possible newline as well */
173 char output[DEVARGS_MAXLEN + 1];
178 RTE_ASSERT(fd_str != NULL || sdev->fd_str != NULL);
179 if (sdev->fd_str == NULL) {
180 sdev->fd_str = strdup(fd_str);
181 if (sdev->fd_str == NULL) {
182 ERROR("Command line allocation failed");
187 fd = strtol(fd_str, &fd_str, 0);
188 if (errno || *fd_str || fd < 0) {
189 ERROR("Parsing FD number failed");
192 /* Fiddle with copy of file descriptor */
196 oflags = fcntl(fd, F_GETFL);
199 if (fcntl(fd, F_SETFL, oflags | O_NONBLOCK) == -1)
201 fp = fdopen(fd, "r");
205 /* Only take the last line into account */
207 while (fgets(output, sizeof(output), fp))
211 else if (ferror(fp) && errno != EAGAIN)
213 /* Line must end with a newline character */
214 fs_sanitize_cmdline(output);
215 if (output[0] == '\0')
217 err = fs_parse_device(sdev, output);
219 ERROR("Parsing device '%s' failed", output);
229 fs_parse_device_param(struct rte_eth_dev *dev, const char *param,
232 struct fs_priv *priv;
233 struct sub_device *sdev;
242 while (param[b] != '(' &&
246 b += closing_paren(¶m[b]);
248 ERROR("Dangling parenthesis");
252 args = strndup(¶m[a], b - a);
254 ERROR("Not enough memory for parameter parsing");
257 sdev = &priv->subs[head];
258 if (strncmp(param, "dev", 3) == 0) {
259 ret = fs_parse_device(sdev, args);
262 } else if (strncmp(param, "exec", 4) == 0) {
263 ret = fs_execute_cmd(sdev, args);
264 if (ret == -ENODEV) {
265 DEBUG("Reading device info from command line failed");
270 } else if (strncmp(param, "fd(", 3) == 0) {
271 ret = fs_read_fd(sdev, args);
272 if (ret == -ENODEV) {
273 DEBUG("Reading device info from FD failed");
279 ERROR("Unrecognized device type: %.*s", (int)b, param);
288 fs_parse_sub_devices(parse_cb *cb,
289 struct rte_eth_dev *dev, const char *params)
298 while (params[a] != '\0') {
300 while (params[b] != '(' &&
305 ERROR("Invalid parameter");
308 if (params[b] == ',') {
312 if (params[b] == '(') {
315 b += closing_paren(¶ms[b]);
317 ERROR("Dangling parenthesis");
320 ret = (*cb)(dev, ¶ms[a], head);
325 if (params[b] == '\0')
334 fs_remove_sub_devices_definition(char params[DEVARGS_MAXLEN])
336 char buffer[DEVARGS_MAXLEN] = {0};
342 while (params[a] != '\0') {
344 while (params[b] != '(' &&
349 ERROR("Invalid parameter");
352 if (params[b] == ',' || params[b] == '\0') {
357 snprintf(&buffer[i], len + 1, "%s%s",
358 i ? "," : "", ¶ms[a]);
360 } else if (params[b] == '(') {
363 b += closing_paren(¶ms[b]);
367 if (params[b] == '\0')
373 snprintf(params, DEVARGS_MAXLEN, "%s", buffer);
378 fs_get_u64_arg(const char *key __rte_unused,
379 const char *value, void *out)
384 if ((value == NULL) || (out == NULL))
387 *u64 = strtoull(value, &endptr, 0);
396 fs_get_mac_addr_arg(const char *key __rte_unused,
397 const char *value, void *out)
399 struct ether_addr *ea = out;
402 if ((value == NULL) || (out == NULL))
404 ret = sscanf(value, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
405 &ea->addr_bytes[0], &ea->addr_bytes[1],
406 &ea->addr_bytes[2], &ea->addr_bytes[3],
407 &ea->addr_bytes[4], &ea->addr_bytes[5]);
408 return ret != ETHER_ADDR_LEN;
412 failsafe_args_parse(struct rte_eth_dev *dev, const char *params)
414 struct fs_priv *priv;
415 char mut_params[DEVARGS_MAXLEN] = "";
416 struct rte_kvargs *kvlist = NULL;
417 unsigned int arg_count;
423 priv->subs_tx = FAILSAFE_MAX_ETHPORTS;
424 /* default parameters */
425 n = snprintf(mut_params, sizeof(mut_params), "%s", params);
426 if (n >= sizeof(mut_params)) {
427 ERROR("Parameter string too long (>=%zu)",
431 ret = fs_parse_sub_devices(fs_parse_device_param,
435 ret = fs_remove_sub_devices_definition(mut_params);
438 if (strnlen(mut_params, sizeof(mut_params)) > 0) {
439 kvlist = rte_kvargs_parse(mut_params,
440 pmd_failsafe_init_parameters);
441 if (kvlist == NULL) {
442 ERROR("Error parsing parameters, usage:\n"
443 PMD_FAILSAFE_PARAM_STRING);
446 /* PLUG_IN event poll timer */
447 arg_count = rte_kvargs_count(kvlist,
448 PMD_FAILSAFE_HOTPLUG_POLL_KVARG);
449 if (arg_count == 1) {
450 ret = rte_kvargs_process(kvlist,
451 PMD_FAILSAFE_HOTPLUG_POLL_KVARG,
452 &fs_get_u64_arg, &hotplug_poll);
457 arg_count = rte_kvargs_count(kvlist,
458 PMD_FAILSAFE_MAC_KVARG);
460 ret = rte_kvargs_process(kvlist,
461 PMD_FAILSAFE_MAC_KVARG,
462 &fs_get_mac_addr_arg,
463 &dev->data->mac_addrs[0]);
470 PRIV(dev)->state = DEV_PARSED;
472 rte_kvargs_free(kvlist);
477 failsafe_args_free(struct rte_eth_dev *dev)
479 struct sub_device *sdev;
482 FOREACH_SUBDEV(sdev, i, dev) {
484 sdev->cmdline = NULL;
487 free(sdev->devargs.args);
488 sdev->devargs.args = NULL;
493 fs_count_device(struct rte_eth_dev *dev, const char *param,
494 uint8_t head __rte_unused)
498 while (param[b] != '(' &&
501 if (strncmp(param, "dev", b) != 0 &&
502 strncmp(param, "exec", b) != 0 &&
503 strncmp(param, "fd(", b) != 0) {
504 ERROR("Unrecognized device type: %.*s", (int)b, param);
507 PRIV(dev)->subs_tail += 1;
512 failsafe_args_count_subdevice(struct rte_eth_dev *dev,
515 return fs_parse_sub_devices(fs_count_device,
520 fs_parse_sub_device(struct sub_device *sdev)
522 struct rte_devargs *da;
523 char devstr[DEVARGS_MAXLEN] = "";
526 snprintf(devstr, sizeof(devstr), "%s,%s", da->name, da->args);
527 return fs_parse_device(sdev, devstr);
531 failsafe_args_parse_subs(struct rte_eth_dev *dev)
533 struct sub_device *sdev;
537 FOREACH_SUBDEV(sdev, i, dev) {
538 if (sdev->state >= DEV_PARSED)
541 ret = fs_execute_cmd(sdev, sdev->cmdline);
542 else if (sdev->fd_str)
543 ret = fs_read_fd(sdev, sdev->fd_str);
545 ret = fs_parse_sub_device(sdev);
547 sdev->state = DEV_PARSED;