net/failsafe: fix missing pclose after popen

[dpdk.git] / drivers / net / failsafe / failsafe_args.c

diff --git a/drivers/net/failsafe/failsafe_args.c b/drivers/net/failsafe/failsafe_args.c
index bde8f2d..3f92a77 100644 (file)
--- a/drivers/net/failsafe/failsafe_args.c
+++ b/drivers/net/failsafe/failsafe_args.c
@@ -32,7 +32,9 @@
  */
 
 #include <string.h>
+#include <errno.h>
 
+#include <rte_debug.h>
 #include <rte_devargs.h>
 #include <rte_malloc.h>
 #include <rte_kvargs.h>
@@ -45,9 +47,11 @@
 typedef int (parse_cb)(struct rte_eth_dev *dev, const char *params,
                uint8_t head);
 
+uint64_t hotplug_poll = FAILSAFE_HOTPLUG_DEFAULT_TIMEOUT_MS;
 int mac_from_arg = 0;
 
 const char *pmd_failsafe_init_parameters[] = {
+       PMD_FAILSAFE_HOTPLUG_POLL_KVARG,
        PMD_FAILSAFE_MAC_KVARG,
        NULL,
 };
@@ -94,6 +98,73 @@ fs_parse_device(struct sub_device *sdev, char *args)
        return 0;
 }
 
+static void
+fs_sanitize_cmdline(char *args)
+{
+       size_t len;
+
+       len = strnlen(args, DEVARGS_MAXLEN);
+       args[len - 1] = '\0';
+}
+
+static int
+fs_execute_cmd(struct sub_device *sdev, char *cmdline)
+{
+       FILE *fp;
+       /* store possible newline as well */
+       char output[DEVARGS_MAXLEN + 1];
+       size_t len;
+       int old_err;
+       int ret, pclose_ret;
+
+       RTE_ASSERT(cmdline != NULL || sdev->cmdline != NULL);
+       if (sdev->cmdline == NULL) {
+               size_t i;
+
+               len = strlen(cmdline) + 1;
+               sdev->cmdline = calloc(1, len);
+               if (sdev->cmdline == NULL) {
+                       ERROR("Command line allocation failed");
+                       return -ENOMEM;
+               }
+               snprintf(sdev->cmdline, len, "%s", cmdline);
+               /* Replace all commas in the command line by spaces */
+               for (i = 0; i < len; i++)
+                       if (sdev->cmdline[i] == ',')
+                               sdev->cmdline[i] = ' ';
+       }
+       DEBUG("'%s'", sdev->cmdline);
+       old_err = errno;
+       fp = popen(sdev->cmdline, "r");
+       if (fp == NULL) {
+               ret = errno;
+               ERROR("popen: %s", strerror(errno));
+               errno = old_err;
+               return ret;
+       }
+       /* We only read one line */
+       if (fgets(output, sizeof(output) - 1, fp) == NULL) {
+               DEBUG("Could not read command output");
+               ret = -ENODEV;
+               goto ret_pclose;
+       }
+       fs_sanitize_cmdline(output);
+       ret = fs_parse_device(sdev, output);
+       if (ret) {
+               ERROR("Parsing device '%s' failed", output);
+               goto ret_pclose;
+       }
+ret_pclose:
+       pclose_ret = pclose(fp);
+       if (pclose_ret) {
+               pclose_ret = errno;
+               ERROR("pclose: %s", strerror(errno));
+               errno = old_err;
+               return pclose_ret;
+       }
+       return ret;
+}
+
 static int
 fs_parse_device_param(struct rte_eth_dev *dev, const char *param,
                uint8_t head)
@@ -128,6 +199,14 @@ fs_parse_device_param(struct rte_eth_dev *dev, const char *param,
                ret = fs_parse_device(sdev, args);
                if (ret)
                        goto free_args;
+       } else if (strncmp(param, "exec", 4) == 0) {
+               ret = fs_execute_cmd(sdev, args);
+               if (ret == -ENODEV) {
+                       DEBUG("Reading device info from command line failed");
+                       ret = 0;
+               }
+               if (ret)
+                       goto free_args;
        } else {
                ERROR("Unrecognized device type: %.*s", (int)b, param);
                return -EINVAL;
@@ -220,6 +299,24 @@ out:
        return 0;
 }
 
+static int
+fs_get_u64_arg(const char *key __rte_unused,
+               const char *value, void *out)
+{
+       uint64_t *u64 = out;
+       char *endptr = NULL;
+
+       if ((value == NULL) || (out == NULL))
+               return -EINVAL;
+       errno = 0;
+       *u64 = strtoull(value, &endptr, 0);
+       if (errno != 0)
+               return -errno;
+       if (endptr == value)
+               return -1;
+       return 0;
+}
+
 static int
 fs_get_mac_addr_arg(const char *key __rte_unused,
                const char *value, void *out)
@@ -271,6 +368,16 @@ failsafe_args_parse(struct rte_eth_dev *dev, const char *params)
                                PMD_FAILSAFE_PARAM_STRING);
                        return -1;
                }
+               /* PLUG_IN event poll timer */
+               arg_count = rte_kvargs_count(kvlist,
+                               PMD_FAILSAFE_HOTPLUG_POLL_KVARG);
+               if (arg_count == 1) {
+                       ret = rte_kvargs_process(kvlist,
+                                       PMD_FAILSAFE_HOTPLUG_POLL_KVARG,
+                                       &fs_get_u64_arg, &hotplug_poll);
+                       if (ret < 0)
+                               goto free_kvlist;
+               }
                /* MAC addr */
                arg_count = rte_kvargs_count(kvlist,
                                PMD_FAILSAFE_MAC_KVARG);
@@ -284,6 +391,7 @@ failsafe_args_parse(struct rte_eth_dev *dev, const char *params)
                        mac_from_arg = 1;
                }
        }
+       PRIV(dev)->state = DEV_PARSED;
 free_kvlist:
        rte_kvargs_free(kvlist);
        return ret;
@@ -296,6 +404,8 @@ failsafe_args_free(struct rte_eth_dev *dev)
        uint8_t i;
 
        FOREACH_SUBDEV(sdev, i, dev) {
+               rte_free(sdev->cmdline);
+               sdev->cmdline = NULL;
                free(sdev->devargs.args);
                sdev->devargs.args = NULL;
        }
@@ -310,7 +420,8 @@ fs_count_device(struct rte_eth_dev *dev, const char *param,
        while  (param[b] != '(' &&
                param[b] != '\0')
                b++;
-       if (strncmp(param, "dev", b) != 0) {
+       if (strncmp(param, "dev", b) != 0 &&
+           strncmp(param, "exec", b) != 0) {
                ERROR("Unrecognized device type: %.*s", (int)b, param);
                return -EINVAL;
        }
@@ -325,3 +436,34 @@ failsafe_args_count_subdevice(struct rte_eth_dev *dev,
        return fs_parse_sub_devices(fs_count_device,
                                    dev, params);
 }
+
+static int
+fs_parse_sub_device(struct sub_device *sdev)
+{
+       struct rte_devargs *da;
+       char devstr[DEVARGS_MAXLEN] = "";
+
+       da = &sdev->devargs;
+       snprintf(devstr, sizeof(devstr), "%s,%s", da->name, da->args);
+       return fs_parse_device(sdev, devstr);
+}
+
+int
+failsafe_args_parse_subs(struct rte_eth_dev *dev)
+{
+       struct sub_device *sdev;
+       uint8_t i;
+       int ret = 0;
+
+       FOREACH_SUBDEV(sdev, i, dev) {
+               if (sdev->state >= DEV_PARSED)
+                       continue;
+               if (sdev->cmdline)
+                       ret = fs_execute_cmd(sdev, sdev->cmdline);
+               else
+                       ret = fs_parse_sub_device(sdev);
+               if (ret == 0)
+                       sdev->state = DEV_PARSED;
+       }
+       return 0;
+}