nvme: validate output format split status from flag return value

Just return the status via the return value and return the flag value
via the arguments.

Signed-off-by: Daniel Wagner <dwagner@suse.de>

diff --git a/fabrics.c b/fabrics.c
index 57ca927fce9abed80fec459bf81ab556db5f505d..ca02e353cba98110feb31bb09e0914a00d2671a4 100644 (file)
--- a/fabrics.c
+++ b/fabrics.c
@@ -414,9 +414,11 @@ static int discover_from_conf_file(nvme_root_t r, nvme_host_t h,
 
        nvmf_default_config(&cfg);
 
-       ret = flags = validate_output_format(format);
-       if (ret < 0)
+       ret = validate_output_format(format, &flags);
+       if (ret < 0) {
+               nvme_show_error("Invalid output format");
                return ret;
+       }
 
        f = fopen(PATH_NVMF_DISC, "r");
        if (f == NULL) {
@@ -697,9 +699,11 @@ int nvmf_discover(const char *desc, int argc, char **argv, bool connect)
        if (ret)
                return ret;
 
-       ret = flags = validate_output_format(format);
-       if (ret < 0)
+       ret = validate_output_format(format, &flags);
+       if (ret < 0) {
+               nvme_show_error("Invalid output format");
                return ret;
+       }
 
        if (!strcmp(config_file, "none"))
                config_file = NULL;
@@ -900,7 +904,11 @@ int nvmf_connect(const char *desc, int argc, char **argv)
        if (ret)
                return ret;
 
-       flags = validate_output_format(format);
+       ret = validate_output_format(format, &flags);
+       if (ret < 0) {
+               nvme_show_error("Invalid output format");
+               return ret;
+       }
 
        if (!subsysnqn) {
                fprintf(stderr,

diff --git a/nvme.c b/nvme.c
index 4f946a27288fe9d5ae09fd6e3c1955bed18c5f17..14a5411774719b51cfd07f0df20038e8f364afa7 100644 (file)
--- a/nvme.c
+++ b/nvme.c
@@ -417,26 +417,35 @@ int open_exclusive(struct nvme_dev **dev, int argc, char **argv,
        return get_dev(dev, argc, argv, flags);
 }
 
-enum nvme_print_flags validate_output_format(const char *format)
+int validate_output_format(const char *format, enum nvme_print_flags *flags)
 {
+       enum nvme_print_flags f;
+
        if (!format)
                return -EINVAL;
 
        if (!strcmp(format, "normal"))
-               return NORMAL;
-
-       if (!strcmp(format, "json"))
-               return JSON;
+               f = NORMAL;
+       else if (!strcmp(format, "json"))
+               f = JSON;
+       else if (!strcmp(format, "binary"))
+               f = BINARY;
+       else
+               return -EINVAL;
 
-       if (!strcmp(format, "binary"))
-               return BINARY;
+       *flags = f;
 
-       return -EINVAL;
+       return 0;
 }
 
 bool nvme_is_output_format_json(void)
 {
-       return validate_output_format(output_format_val) == JSON;
+       enum nvme_print_flags flags;
+
+       if (validate_output_format(output_format_val, &flags))
+               return false;
+
+       return flags == JSON;
 }
 
 void dev_close(struct nvme_dev *dev)
@@ -486,7 +495,7 @@ static int get_smart_log(int argc, char **argv, struct command *cmd, struct plug
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -545,7 +554,7 @@ static int get_ana_log(int argc, char **argv, struct command *cmd,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -902,7 +911,7 @@ static int get_endurance_log(int argc, char **argv, struct command *cmd, struct
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -980,7 +989,7 @@ static int get_effects_log(int argc, char **argv, struct command *cmd, struct pl
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1059,7 +1068,7 @@ static int get_supported_log_pages(int argc, char **argv, struct command *cmd,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1115,7 +1124,7 @@ static int get_error_log(int argc, char **argv, struct command *cmd, struct plug
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1180,7 +1189,7 @@ static int get_fw_log(int argc, char **argv, struct command *cmd, struct plugin
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1229,7 +1238,7 @@ static int get_changed_ns_list_log(int argc, char **argv, struct command *cmd, s
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1286,7 +1295,7 @@ static int get_pred_lat_per_nvmset_log(int argc, char **argv,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1348,7 +1357,7 @@ static int get_pred_lat_event_agg_log(int argc, char **argv,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1434,7 +1443,7 @@ static int get_persistent_event_log(int argc, char **argv,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1550,7 +1559,7 @@ static int get_endurance_event_agg_log(int argc, char **argv,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1625,7 +1634,7 @@ static int get_lba_status_log(int argc, char **argv,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1675,7 +1684,7 @@ static int get_resv_notif_log(int argc, char **argv,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1730,7 +1739,7 @@ static int get_boot_part_log(int argc, char **argv, struct command *cmd, struct
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1824,7 +1833,7 @@ static int get_phy_rx_eom_log(int argc, char **argv, struct command *cmd,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1912,7 +1921,7 @@ static int get_media_unit_stat_log(int argc, char **argv, struct command *cmd,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -1964,7 +1973,7 @@ static int get_supp_cap_config_log(int argc, char **argv, struct command *cmd,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -2324,7 +2333,7 @@ static int sanitize_log(int argc, char **argv, struct command *command, struct p
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -2376,7 +2385,7 @@ static int get_fid_support_effects_log(int argc, char **argv, struct command *cm
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -2425,7 +2434,7 @@ static int get_mi_cmd_support_effects_log(int argc, char **argv, struct command
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -2478,7 +2487,7 @@ static int list_ctrl(int argc, char **argv, struct command *cmd, struct plugin *
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -2537,10 +2546,10 @@ static int list_ns(int argc, char **argv, struct command *cmd, struct plugin *pl
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
-       if (flags != JSON && flags != NORMAL) {
+       err = validate_output_format(output_format_val, &flags);
+       if (err < 0 || (flags != JSON && flags != NORMAL)) {
                nvme_show_error("Invalid output format");
-               return err;
+               return -EINVAL;
        }
 
        if (!cfg.namespace_id) {
@@ -2607,7 +2616,7 @@ static int id_ns_lba_format(int argc, char **argv, struct command *cmd, struct p
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -2659,10 +2668,10 @@ static int id_endurance_grp_list(int argc, char **argv, struct command *cmd,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
-       if (flags != JSON && flags != NORMAL) {
+       err = validate_output_format(output_format_val, &flags);
+       if (err < 0 || (flags != JSON && flags != NORMAL)) {
                nvme_show_error("invalid output format");
-               return err;
+               return -EINVAL;
        }
 
        endgrp_list = nvme_alloc(sizeof(*endgrp_list));
@@ -3174,10 +3183,10 @@ static int list_subsys(int argc, char **argv, struct command *cmd,
        if (optind < argc)
                devname = basename(argv[optind++]);
 
-       err = flags = validate_output_format(output_format_val);
-       if (flags != JSON && flags != NORMAL) {
+       err = validate_output_format(output_format_val, &flags);
+       if (err < 0 || (flags != JSON && flags != NORMAL)) {
                nvme_show_error("Invalid output format");
-               goto ret;
+               return -EINVAL;
        }
 
        if (argconfig_parse_seen(opts, "verbose"))
@@ -3231,8 +3240,8 @@ static int list(int argc, char **argv, struct command *cmd, struct plugin *plugi
        if (err < 0)
                return err;
 
-       flags = validate_output_format(output_format_val);
-       if (flags != JSON && flags != NORMAL) {
+       err = validate_output_format(output_format_val, &flags);
+       if (err < 0 || (flags != JSON && flags != NORMAL)) {
                nvme_show_error("Invalid output format");
                return -EINVAL;
        }
@@ -3294,7 +3303,7 @@ int __id_ctrl(int argc, char **argv, struct command *cmd, struct plugin *plugin,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -3347,7 +3356,7 @@ static int nvm_id_ctrl(int argc, char **argv, struct command *cmd,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -3399,7 +3408,7 @@ static int nvm_id_ns(int argc, char **argv, struct command *cmd,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -3473,7 +3482,7 @@ static int nvm_id_ns_lba_format(int argc, char **argv, struct command *cmd, stru
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -3538,7 +3547,7 @@ static int ns_descs(int argc, char **argv, struct command *cmd, struct plugin *p
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -3611,7 +3620,7 @@ static int id_ns(int argc, char **argv, struct command *cmd, struct plugin *plug
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -3686,7 +3695,7 @@ static int cmd_set_independent_id_ns(int argc, char **argv, struct command *cmd,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -3739,7 +3748,7 @@ static int id_ns_granularity(int argc, char **argv, struct command *cmd, struct
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -3788,7 +3797,7 @@ static int id_nvmset(int argc, char **argv, struct command *cmd, struct plugin *
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -3840,7 +3849,7 @@ static int id_uuid(int argc, char **argv, struct command *cmd, struct plugin *pl
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -3937,7 +3946,7 @@ static int id_domain(int argc, char **argv, struct command *cmd, struct plugin *
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -4083,7 +4092,7 @@ static int primary_ctrl_caps(int argc, char **argv, struct command *cmd, struct
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -4138,7 +4147,7 @@ static int list_secondary_ctrl(int argc, char **argv, struct command *cmd, struc
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -4393,7 +4402,7 @@ static int self_test_log(int argc, char **argv, struct command *cmd, struct plug
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -5278,7 +5287,7 @@ static int show_registers(int argc, char **argv, struct command *cmd, struct plu
                return err;
 
        r = nvme_scan(NULL);
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                goto free_tree;
@@ -6961,7 +6970,7 @@ static int resv_report(int argc, char **argv, struct command *cmd, struct plugin
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -7660,7 +7669,7 @@ static int get_lba_status(int argc, char **argv, struct command *cmd,
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;
@@ -8799,7 +8808,7 @@ static int show_topology_cmd(int argc, char **argv, struct command *command, str
        if (err)
                return err;
 
-       err = flags = validate_output_format(output_format_val);
+       err = validate_output_format(output_format_val, &flags);
        if (err < 0) {
                nvme_show_error("Invalid output format");
                return err;

diff --git a/nvme.h b/nvme.h
index 9c2a406930168b8f4917f718c866a8ed23d01aff..39156985996a055277ab8dd2be3f612a261b792f 100644 (file)
--- a/nvme.h
+++ b/nvme.h
@@ -108,7 +108,7 @@ static inline DEFINE_CLEANUP_FUNC(
 
 extern const char *output_format;
 
-enum nvme_print_flags validate_output_format(const char *format);
+int validate_output_format(const char *format, enum nvme_print_flags *flags);
 bool nvme_is_output_format_json(void);
 int __id_ctrl(int argc, char **argv, struct command *cmd,
        struct plugin *plugin, void (*vs)(uint8_t *vs, struct json_object *root));

diff --git a/plugins/fdp/fdp.c b/plugins/fdp/fdp.c
index 8539e187c7d07cc9aff9f8360ab714a38daefc90..2a221f865752cc2377992249e2cee2dda16e13e7 100644 (file)
--- a/plugins/fdp/fdp.c
+++ b/plugins/fdp/fdp.c
@@ -56,7 +56,7 @@ static int fdp_configs(int argc, char **argv, struct command *cmd,
        if (err)
                return err;
 
-       err = flags = validate_output_format(cfg.output_format);
+       err = validate_output_format(cfg.output_format, &flags);
        if (flags < 0)
                goto out;
 
@@ -137,7 +137,7 @@ static int fdp_usage(int argc, char **argv, struct command *cmd, struct plugin *
        if (err)
                return err;
 
-       err = flags = validate_output_format(cfg.output_format);
+       err = validate_output_format(cfg.output_format, &flags);
        if (flags < 0)
                goto out;
 
@@ -208,7 +208,7 @@ static int fdp_stats(int argc, char **argv, struct command *cmd, struct plugin *
        if (err)
                return err;
 
-       err = flags = validate_output_format(cfg.output_format);
+       err = validate_output_format(cfg.output_format, &flags);
        if (flags < 0)
                goto out;
 
@@ -269,7 +269,7 @@ static int fdp_events(int argc, char **argv, struct command *cmd, struct plugin
        if (err)
                return err;
 
-       err = flags = validate_output_format(cfg.output_format);
+       err = validate_output_format(cfg.output_format, &flags);
        if (flags < 0)
                goto out;
 
@@ -328,7 +328,7 @@ static int fdp_status(int argc, char **argv, struct command *cmd, struct plugin
        if (err)
                return err;
 
-       err = flags = validate_output_format(cfg.output_format);
+       err = validate_output_format(cfg.output_format, &flags);
        if (flags < 0)
                goto out;
 

diff --git a/plugins/huawei/huawei-nvme.c b/plugins/huawei/huawei-nvme.c
index 82e190f31cf9a8af78a0cb52797d5cb455f60240..0272dead347946a9cdea5d63f97223f8f748c01f 100644 (file)
--- a/plugins/huawei/huawei-nvme.c
+++ b/plugins/huawei/huawei-nvme.c
@@ -296,7 +296,7 @@ static int huawei_list(int argc, char **argv, struct command *command,
        struct huawei_list_item *list_items;
        unsigned int i, n, ret;
        unsigned int huawei_num = 0;
-       int fmt;
+       enum nvme_print_flags fmt;
        const char *desc = "Retrieve basic information for the given huawei device";
        struct config {
                char *output_format;
@@ -315,9 +315,9 @@ static int huawei_list(int argc, char **argv, struct command *command,
        if (ret)
                return ret;
 
-       fmt = validate_output_format(cfg.output_format);
-       if (fmt != JSON && fmt != NORMAL)
-               return -EINVAL;
+       ret = validate_output_format(cfg.output_format, &fmt);
+       if (ret < 0 || (fmt != JSON && fmt != NORMAL))
+               return ret;
 
        n = scandir("/dev", &devices, nvme_namespace_filter, alphasort);
        if (n <= 0)

diff --git a/plugins/nbft/nbft-plugin.c b/plugins/nbft/nbft-plugin.c
index e8b3fed0917810096f2beba412df41754ac21b97..2193ffb53522d249bb236811023e038260417443 100644 (file)
--- a/plugins/nbft/nbft-plugin.c
+++ b/plugins/nbft/nbft-plugin.c
@@ -543,7 +543,7 @@ int show_nbft(int argc, char **argv, struct command *cmd, struct plugin *plugin)
        if (ret)
                return ret;
 
-       ret = flags = validate_output_format(format);
+       ret = validate_output_format(format, &flags);
        if (ret < 0)
                return ret;
 

diff --git a/plugins/ocp/ocp-fw-activation-history.c b/plugins/ocp/ocp-fw-activation-history.c
index b067346e679fb4e0e16eca9cf9425c0675b28c62..ad96c6be6fce320da7cb2108adbe742b5915bc6f 100644 (file)
--- a/plugins/ocp/ocp-fw-activation-history.c
+++ b/plugins/ocp/ocp-fw-activation-history.c
@@ -207,16 +207,18 @@ int ocp_fw_activation_history_log(int argc, char **argv, struct command *cmd,
        }
 
        if (!err) {
-               const enum nvme_print_flags print_flag = validate_output_format(format);
+               enum nvme_print_flags print_flag;
+
+               err = validate_output_format(format, &print_flag);
+               if (err < 0) {
+                       fprintf(stderr, "Error: Invalid output format.\n");
+                       return err;
+               }
 
                if (print_flag == JSON)
                        ocp_fw_activation_history_json(&fw_history);
                else if (print_flag == NORMAL)
                        ocp_fw_activation_history_normal(&fw_history);
-               else {
-                       fprintf(stderr, "Error: Invalid output format.\n");
-                       err = -EINVAL;
-               }
        }
 
        return err;

diff --git a/plugins/ocp/ocp-nvme.c b/plugins/ocp/ocp-nvme.c
index 43677295ca4991c80f6a4bd780607048c9e60f79..2c0fac53939df9f41016a92e3426a797651144bf 100644 (file)
--- a/plugins/ocp/ocp-nvme.c
+++ b/plugins/ocp/ocp-nvme.c
@@ -416,15 +416,15 @@ static void ocp_print_C3_log_json(struct ssd_latency_monitor_log *log_data)
 static int get_c3_log_page(struct nvme_dev *dev, char *format)
 {
        struct ssd_latency_monitor_log *log_data;
-       int ret = 0;
-       int fmt = -1;
+       enum nvme_print_flags fmt;
+       int ret;
        __u8 *data;
        int i;
 
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR : OCP : invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        data = malloc(sizeof(__u8) * C3_LATENCY_MON_LOG_BUF_LEN);
@@ -481,6 +481,9 @@ static int get_c3_log_page(struct nvme_dev *dev, char *format)
                case JSON:
                        ocp_print_C3_log_json(log_data);
                        break;
+               default:
+                       fprintf(stderr, "unhandled output format\n");
+
                }
        } else {
                fprintf(stderr,
@@ -1324,17 +1327,17 @@ static void ocp_print_c5_log_binary(struct unsupported_requirement_log *log_data
 
 static int get_c5_log_page(struct nvme_dev *dev, char *format)
 {
-       int ret = 0;
-       int fmt = -1;
+       enum nvme_print_flags fmt;
+       int ret;
        __u8 *data;
        int i;
        struct unsupported_requirement_log *log_data;
        int j;
 
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR : OCP : invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        data = (__u8 *)malloc(sizeof(__u8) * C5_UNSUPPORTED_REQS_LEN);
@@ -1386,6 +1389,8 @@ static int get_c5_log_page(struct nvme_dev *dev, char *format)
                case BINARY:
                        ocp_print_c5_log_binary(log_data);
                        break;
+               default:
+                       break;
                }
        } else {
                fprintf(stderr, "ERROR : OCP : Unable to read C3 data from buffer\n");
@@ -1548,16 +1553,16 @@ static void ocp_print_c1_log_binary(struct ocp_error_recovery_log_page *log_data
 
 static int get_c1_log_page(struct nvme_dev *dev, char *format)
 {
-       int ret = 0;
-       int fmt = -1;
+       struct ocp_error_recovery_log_page *log_data;
+       enum nvme_print_flags fmt;
+       int ret;
        __u8 *data;
        int i, j;
-       struct ocp_error_recovery_log_page *log_data;
 
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR : OCP : invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        data = (__u8 *)malloc(sizeof(__u8) * C1_ERROR_RECOVERY_LOG_BUF_LEN);
@@ -1609,6 +1614,8 @@ static int get_c1_log_page(struct nvme_dev *dev, char *format)
                case BINARY:
                        ocp_print_c1_log_binary(log_data);
                        break;
+               default:
+                       break;
                }
        } else {
                fprintf(stderr, "ERROR : OCP : Unable to read C1 data from buffer\n");
@@ -1762,16 +1769,16 @@ static void ocp_print_c4_log_binary(struct ocp_device_capabilities_log_page *log
 
 static int get_c4_log_page(struct nvme_dev *dev, char *format)
 {
-       int ret = 0;
-       int fmt = -1;
+       struct ocp_device_capabilities_log_page *log_data;
+       enum nvme_print_flags fmt;
+       int ret;
        __u8 *data;
        int i, j;
-       struct ocp_device_capabilities_log_page *log_data;
 
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR : OCP : invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        data = (__u8 *)malloc(sizeof(__u8) * C4_DEV_CAP_REQ_LEN);
@@ -1823,6 +1830,8 @@ static int get_c4_log_page(struct nvme_dev *dev, char *format)
                case BINARY:
                        ocp_print_c4_log_binary(log_data);
                        break;
+               default:
+                       break;
                }
        } else {
                fprintf(stderr, "ERROR : OCP : Unable to read C4 data from buffer\n");

diff --git a/plugins/ocp/ocp-smart-extended-log.c b/plugins/ocp/ocp-smart-extended-log.c
index c989d3460d6c332d3deba06ab2c3c43f5621f70c..0d8ba810693b3b484f2b541c42d3adbbe9c7d42f 100644 (file)
--- a/plugins/ocp/ocp-smart-extended-log.c
+++ b/plugins/ocp/ocp-smart-extended-log.c
@@ -252,15 +252,15 @@ static void ocp_print_C0_log_json(void *data)
 
 static int get_c0_log_page(int fd, char *format)
 {
+       enum nvme_print_flags fmt;
        __u8 *data;
        int i;
-       int ret = 0;
-       int fmt = -1;
+       int ret;
 
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR : OCP : invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        data = malloc(sizeof(__u8) * C0_SMART_CLOUD_ATTR_LEN);
@@ -307,6 +307,8 @@ static int get_c0_log_page(int fd, char *format)
                case JSON:
                        ocp_print_C0_log_json(data);
                        break;
+               default:
+                       break;
                }
        } else {
                fprintf(stderr, "ERROR : OCP : Unable to read C0 data from buffer\n");

diff --git a/plugins/solidigm/solidigm-garbage-collection.c b/plugins/solidigm/solidigm-garbage-collection.c
index b26d7542860c9617b8012c813c5b52c564eca854..a37e9c5847187222f8569fd5fa36c63d241d1b2b 100644 (file)
--- a/plugins/solidigm/solidigm-garbage-collection.c
+++ b/plugins/solidigm/solidigm-garbage-collection.c
@@ -68,6 +68,7 @@ static void vu_gc_log_show(struct garbage_control_collection_log *payload, const
 int solidigm_get_garbage_collection_log(int argc, char **argv, struct command *cmd, struct plugin *plugin)
 {
        const char *desc = "Get and parse Solidigm vendor specific garbage collection event log.";
+       enum nvme_print_flags flags;
        struct nvme_dev *dev;
        int err;
        __u8 uuid_index;
@@ -89,9 +90,8 @@ int solidigm_get_garbage_collection_log(int argc, char **argv, struct command *c
        if (err)
                return err;
 
-       enum nvme_print_flags flags = validate_output_format(cfg.output_format);
-
-       if (flags == -EINVAL) {
+       err = validate_output_format(cfg.output_format, &flags);
+       if (err) {
                fprintf(stderr, "Invalid output format '%s'\n", cfg.output_format);
                dev_close(dev);
                return -EINVAL;

diff --git a/plugins/solidigm/solidigm-latency-tracking.c b/plugins/solidigm/solidigm-latency-tracking.c
index 481a8314e3dc4e278e685a2da5135eb1f5d36c50..66f3c560dfc4a07be476ebc9d8d73314b8ee0f46 100644 (file)
--- a/plugins/solidigm/solidigm-latency-tracking.c
+++ b/plugins/solidigm/solidigm-latency-tracking.c
@@ -411,8 +411,8 @@ int solidigm_get_latency_tracking_log(int argc, char **argv, struct command *cmd
 
        lt.fd = dev_fd(dev);
 
-       lt.print_flags = validate_output_format(lt.cfg.output_format);
-       if (lt.print_flags == -EINVAL) {
+       err = validate_output_format(lt.cfg.output_format, &lt.print_flags);
+       if (err < 0) {
                fprintf(stderr, "Invalid output format '%s'\n", lt.cfg.output_format);
                dev_close(dev);
                return -EINVAL;

diff --git a/plugins/solidigm/solidigm-log-page-dir.c b/plugins/solidigm/solidigm-log-page-dir.c
index be5cbc98a2cb43f3a8f63257d2decbfd979d7985..bf272f8da10be82734b01aebe61cbe371adf24ae 100644 (file)
--- a/plugins/solidigm/solidigm-log-page-dir.c
+++ b/plugins/solidigm/solidigm-log-page-dir.c
@@ -264,15 +264,18 @@ int solidigm_get_log_page_directory_log(int argc, char **argv, struct command *c
        }
 
        if (!err) {
-               const enum nvme_print_flags print_flag = validate_output_format(format);
+               enum nvme_print_flags print_flag;
+
+               err = validate_output_format(format, &print_flag);
+               if (err < 0) {
+                       fprintf(stderr, "Error: Invalid output format specified: %s.\n", format);
+                       return err;
+               }
 
                if (print_flag == NORMAL) {
                        supported_log_pages_normal(lid_dirs);
                } else if (print_flag == JSON) {
                        supported_log_pages_json(lid_dirs);
-               } else {
-                       fprintf(stderr, "Error: Invalid output format specified: %s.\n", format);
-                       err = -EINVAL;
                }
        }
 

diff --git a/plugins/solidigm/solidigm-smart.c b/plugins/solidigm/solidigm-smart.c
index aa6a2bf8cb16b49aae2c79316a1777a8c5e6f990..62245fa5378e6ef45d6345dc2dd6bde4077336f5 100644 (file)
--- a/plugins/solidigm/solidigm-smart.c
+++ b/plugins/solidigm/solidigm-smart.c
@@ -222,11 +222,11 @@ int solidigm_get_additional_smart_log(int argc, char **argv, struct command *cmd
        if (err)
                return err;
 
-       flags = validate_output_format(cfg.output_format);
-       if (flags == -EINVAL) {
+       err = validate_output_format(cfg.output_format, &flags);
+       if (err < 0) {
                fprintf(stderr, "Invalid output format '%s'\n", cfg.output_format);
                dev_close(dev);
-               return flags;
+               return err;
        }
 
        uuid_index = solidigm_get_vu_uuid_index(dev);

diff --git a/plugins/wdc/wdc-nvme.c b/plugins/wdc/wdc-nvme.c
index 8c2707c68821804de8660eec3b8c2f80b5673153..000bd43842195307fd3bff2b385562053948ebdf 100644 (file)
--- a/plugins/wdc/wdc-nvme.c
+++ b/plugins/wdc/wdc-nvme.c
@@ -6835,17 +6835,17 @@ static int wdc_get_c0_log_page_sn(nvme_root_t r, struct nvme_dev *dev, int uuid_
 static int wdc_get_c0_log_page(nvme_root_t r, struct nvme_dev *dev, char *format, int uuid_index,
                               __u32 namespace_id)
 {
-       int ret = 0;
-       int fmt = -1;
-       __u8 *data;
        uint32_t device_id, read_vendor_id;
+       enum nvme_print_flags fmt;
+       int ret;
+       __u8 *data;
 
        if (!wdc_check_device(r, dev))
                return -1;
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC: invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        ret = wdc_get_pci_ids(r, dev, &device_id, &read_vendor_id);
@@ -7091,19 +7091,19 @@ static int wdc_print_fw_act_history_log(__u8 *data, int num_entries, int fmt,
 
 static int wdc_get_ca_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
 {
-       int ret = 0;
-       int fmt = -1;
-       __u8 *data;
-       struct wdc_ssd_ca_perf_stats *perf;
        uint32_t read_device_id, read_vendor_id;
+       struct wdc_ssd_ca_perf_stats *perf;
+       enum nvme_print_flags fmt;
        __u32 cust_id;
+       __u8 *data;
+       int ret;
 
        if (!wdc_check_device(r, dev))
                return -1;
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC: invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        /* verify the 0xCA log page is supported */
@@ -7227,23 +7227,24 @@ static int wdc_get_ca_log_page(nvme_root_t r, struct nvme_dev *dev, char *format
 static int wdc_get_c1_log_page(nvme_root_t r, struct nvme_dev *dev,
                               char *format, uint8_t interval)
 {
-       int ret = 0;
-       int fmt = -1;
+       struct wdc_log_page_subpage_header *sph;
+       struct wdc_ssd_perf_stats *perf;
+       struct wdc_log_page_header *l;
+       enum nvme_print_flags fmt;
+       int total_subpages;
+       int skip_cnt = 4;
        __u8 *data;
        __u8 *p;
        int i;
-       int skip_cnt = 4;
-       int total_subpages;
-       struct wdc_log_page_header *l;
-       struct wdc_log_page_subpage_header *sph;
-       struct wdc_ssd_perf_stats *perf;
+       int ret;
 
        if (!wdc_check_device(r, dev))
                return -1;
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC: invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        if (interval < 1 || interval > 15) {
@@ -7285,18 +7286,19 @@ static int wdc_get_c1_log_page(nvme_root_t r, struct nvme_dev *dev,
 
 static int wdc_get_c3_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
 {
-       int ret = 0;
-       int fmt = -1;
+       struct wdc_ssd_latency_monitor_log *log_data;
+       enum nvme_print_flags fmt;
        __u8 *data;
+       int ret;
        int i;
-       struct wdc_ssd_latency_monitor_log *log_data;
 
        if (!wdc_check_device(r, dev))
                return -1;
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC: invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        data = (__u8 *)malloc(sizeof(__u8) * WDC_LATENCY_MON_LOG_BUF_LEN);
@@ -7356,18 +7358,19 @@ out:
 
 static int wdc_get_ocp_c1_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
 {
-       int ret = 0;
-       int fmt = -1;
+       struct wdc_ocp_c1_error_recovery_log *log_data;
+       enum nvme_print_flags fmt;
        __u8 *data;
+       int ret;
        int i;
-       struct wdc_ocp_c1_error_recovery_log *log_data;
 
        if (!wdc_check_device(r, dev))
                return -1;
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC: invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        data = (__u8 *)malloc(sizeof(__u8) * WDC_ERROR_REC_LOG_BUF_LEN);
@@ -7426,18 +7429,19 @@ out:
 
 static int wdc_get_ocp_c4_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
 {
-       int ret = 0;
-       int fmt = -1;
+       struct wdc_ocp_C4_dev_cap_log *log_data;
+       enum nvme_print_flags fmt;
        __u8 *data;
+       int ret;
        int i;
-       struct wdc_ocp_C4_dev_cap_log *log_data;
 
        if (!wdc_check_device(r, dev))
                return -1;
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC: invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        data = (__u8 *)malloc(sizeof(__u8) * WDC_DEV_CAP_LOG_BUF_LEN);
@@ -7495,18 +7499,19 @@ out:
 
 static int wdc_get_ocp_c5_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
 {
-       int ret = 0;
-       int fmt = -1;
+       struct wdc_ocp_C5_unsupported_reqs *log_data;
+       enum nvme_print_flags fmt;
+       int ret;
        __u8 *data;
        int i;
-       struct wdc_ocp_C5_unsupported_reqs *log_data;
 
        if (!wdc_check_device(r, dev))
                return -1;
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC: invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        data = (__u8 *)malloc(sizeof(__u8) * WDC_UNSUPPORTED_REQS_LOG_BUF_LEN);
@@ -7564,17 +7569,18 @@ out:
 
 static int wdc_get_d0_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
 {
+       struct wdc_ssd_d0_smart_log *perf;
+       enum nvme_print_flags fmt;
        int ret = 0;
-       int fmt = -1;
        __u8 *data;
-       struct wdc_ssd_d0_smart_log *perf;
 
        if (!wdc_check_device(r, dev))
                return -1;
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC: invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        /* verify the 0xD0 log page is supported */
@@ -7846,12 +7852,12 @@ static int wdc_vs_smart_add_log(int argc, char **argv, struct command *command,
        const char *log_page_version = "Log Page Version: 0 = vendor, 1 = WDC";
        const char *log_page_mask = "Log Page Mask, comma separated list: 0xC0, 0xC1, 0xCA, 0xD0";
        const char *namespace_id = "desired namespace id";
+       enum nvme_print_flags fmt;
        struct nvme_dev *dev;
        nvme_root_t r;
        int ret = 0;
        int uuid_index = 0;
        int page_mask = 0, num, i;
-       int fmt = -1;
        int log_page_list[16];
        __u64 capabilities = 0;
        __u32 device_id, read_vendor_id;
@@ -7945,8 +7951,8 @@ static int wdc_vs_smart_add_log(int argc, char **argv, struct command *command,
                        struct ocp_cloud_smart_log log;
                        char buf[2 * sizeof(log.log_page_guid) + 3];
 
-                       fmt = validate_output_format(cfg.output_format);
-                       if (fmt < 0) {
+                       ret = validate_output_format(output_format, &fmt);
+                       if (ret < 0) {
                                fprintf(stderr, "Invalid output format: %s\n", cfg.output_format);
                                goto out;
                        }
@@ -7967,9 +7973,9 @@ static int wdc_vs_smart_add_log(int argc, char **argv, struct command *command,
                                if (strcmp(buf, "0xafd514c97c6f4f9ca4f2bfea2810afc5"))
                                        fprintf(stderr, "Invalid GUID: %s\n", buf);
                                else {
-                                       if (fmt & BINARY)
+                                       if (fmt == BINARY)
                                                d_raw((unsigned char *)&log, sizeof(log));
-                                       else if (fmt & JSON)
+                                       else if (fmt == JSON)
                                                show_cloud_smart_log_json(&log);
                                        else
                                                show_cloud_smart_log_normal(&log, dev);
@@ -8016,10 +8022,11 @@ static int wdc_vs_cloud_log(int argc, char **argv, struct command *command,
 {
        const char *desc = "Retrieve Cloud Log Smart/Health Information";
        const char *namespace_id = "desired namespace id";
+       enum nvme_print_flags fmt;
        __u64 capabilities = 0;
        struct nvme_dev *dev;
-       int ret, fmt = -1;
        nvme_root_t r;
+       int ret;
        __u8 *data;
 
        struct config {
@@ -8060,14 +8067,13 @@ static int wdc_vs_cloud_log(int argc, char **argv, struct command *command,
                nvme_show_status(ret);
 
        if (!ret) {
-               fmt = validate_output_format(cfg.output_format);
-               if (fmt < 0) {
+               ret = validate_output_format(cfg.output_format, &fmt);
+               if (ret < 0) {
                        fprintf(stderr, "ERROR: WDC %s: invalid output format\n", __func__);
-                       ret = fmt;
+               } else {
+                       /* parse the data */
+                       wdc_print_ext_smart_cloud_log(data, fmt);
                }
-
-               /* parse the data */
-               wdc_print_ext_smart_cloud_log(data, fmt);
        } else {
                fprintf(stderr, "ERROR: WDC: Unable to read C0 Log Page V1 data\n");
                ret = -1;
@@ -8087,9 +8093,10 @@ static int wdc_vs_hw_rev_log(int argc, char **argv, struct command *command,
 {
        const char *desc = "Retrieve Hardware Revision Log Information";
        const char *namespace_id = "desired namespace id";
+       enum nvme_print_flags fmt;
        __u64 capabilities = 0;
        struct nvme_dev *dev;
-       int ret, fmt = -1;
+       int ret;
        __u8 *data = NULL;
        nvme_root_t r;
 
@@ -8129,10 +8136,9 @@ static int wdc_vs_hw_rev_log(int argc, char **argv, struct command *command,
                nvme_show_status(ret);
 
        if (!ret) {
-               fmt = validate_output_format(cfg.output_format);
-               if (fmt < 0) {
+               ret = validate_output_format(cfg.output_format, &fmt);
+               if (ret < 0) {
                        fprintf(stderr, "ERROR: WDC %s: invalid output format\n", __func__);
-                       ret = fmt;
                        goto free_buf;
                }
 
@@ -8148,6 +8154,8 @@ static int wdc_vs_hw_rev_log(int argc, char **argv, struct command *command,
                case JSON:
                        wdc_print_hw_rev_log_json(data);
                        break;
+               default:
+                       break;
                }
        } else {
                fprintf(stderr, "ERROR: WDC: Unable to read Hardware Revision Log Page data\n");
@@ -8170,11 +8178,11 @@ static int wdc_vs_device_waf(int argc, char **argv, struct command *command,
        const char *desc = "Retrieve Device Write Amplication Factor";
        const char *namespace_id = "desired namespace id";
        struct nvme_smart_log smart_log;
+       enum nvme_print_flags fmt;
        struct nvme_dev *dev;
        __u8 *data;
        nvme_root_t r;
        int ret = 0;
-       int fmt = -1;
        __u64 capabilities = 0;
        struct __packed wdc_nvme_ext_smart_log * ext_smart_log_ptr;
        long double  data_units_written = 0,
@@ -8250,10 +8258,9 @@ static int wdc_vs_device_waf(int argc, char **argv, struct command *command,
        if (strcmp(cfg.output_format, "json"))
                nvme_show_status(ret);
 
-       fmt = validate_output_format(cfg.output_format);
-       if (fmt < 0) {
+       ret = validate_output_format(cfg.output_format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC %s: invalid output format\n", __func__);
-               ret = fmt;
                goto out;
        }
 
@@ -8727,18 +8734,18 @@ out:
 static int wdc_get_fw_act_history(nvme_root_t r, struct nvme_dev *dev,
                                  char *format)
 {
-       int ret = 0;
-       int fmt = -1;
-       __u8 *data;
        struct wdc_fw_act_history_log_hdr *fw_act_history_hdr;
+       enum nvme_print_flags fmt;
+       int ret;
+       __u8 *data;
 
        if (!wdc_check_device(r, dev))
                return -1;
 
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC: invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        /* verify the FW Activate History log page is supported */
@@ -8808,21 +8815,21 @@ static __u32 wdc_get_fw_cust_id(nvme_root_t r, struct nvme_dev *dev)
 static int wdc_get_fw_act_history_C2(nvme_root_t r, struct nvme_dev *dev,
                                     char *format)
 {
-       int ret = 0;
-       int fmt = -1;
-       __u8 *data;
-       __u32 cust_id = 0;
        struct wdc_fw_act_history_log_format_c2 *fw_act_history_log;
        __u32 tot_entries = 0, num_entries = 0;
        __u32 vendor_id = 0, device_id = 0;
+       __u32 cust_id = 0;
+       enum nvme_print_flags fmt;
+       __u8 *data;
+       int ret;
 
        if (!wdc_check_device(r, dev))
                return -1;
 
-       fmt = validate_output_format(format);
-       if (fmt < 0) {
+       ret = validate_output_format(format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC: invalid output format\n");
-               return fmt;
+               return ret;
        }
 
        ret = wdc_get_pci_ids(r, dev, &device_id, &vendor_id);
@@ -10321,6 +10328,7 @@ static int wdc_log_page_directory(int argc, char **argv, struct command *command
                struct plugin *plugin)
 {
        const char *desc = "Retrieve Log Page Directory.";
+       enum nvme_print_flags fmt;
        struct nvme_dev *dev;
        int ret = 0;
        nvme_root_t r;
@@ -10347,13 +10355,12 @@ static int wdc_log_page_directory(int argc, char **argv, struct command *command
        if (ret)
                return ret;
 
-       ret = validate_output_format(cfg.output_format);
+       ret = validate_output_format(cfg.output_format, &fmt);
        if (ret < 0) {
                fprintf(stderr, "%s: ERROR: WDC: invalid output format\n", __func__);
                dev_close(dev);
                return ret;
        }
-       ret = 0;
 
        r = nvme_scan(NULL);
        capabilities = wdc_get_drive_capabilities(r, dev);
@@ -10440,12 +10447,16 @@ static int wdc_log_page_directory(int argc, char **argv, struct command *command
                                        0, &result);
 
                        if (!ret) {
-                               if (!strcmp(cfg.output_format, "binary"))
+                               switch (fmt) {
+                               case BINARY:
                                        d_raw((unsigned char *)data, 32);
-                               else if (!strcmp(cfg.output_format, "json"))
+                                       break;
+                               case JSON:
                                        __json_log_page_directory(dir);
-                               else
+                                       break;
+                               default:
                                        __show_log_page_directory(dir);
+                               }
                        } else {
                                fprintf(stderr, "NVMe Status:%s(%x)\n",
                                        nvme_status_to_string(ret, false), ret);
@@ -10964,9 +10975,9 @@ static void wdc_print_pcie_stats_json(struct wdc_vs_pcie_stats *pcie_stats)
 
 static int wdc_do_vs_nand_stats_sn810_2(struct nvme_dev *dev, char *format)
 {
-       int ret;
-       int fmt = -1;
+       enum nvme_print_flags fmt;
        uint8_t *data = NULL;
+       int ret;
 
        data = NULL;
        ret = nvme_get_ext_smart_cloud_log(dev_fd(dev), &data, 0,
@@ -10976,10 +10987,9 @@ static int wdc_do_vs_nand_stats_sn810_2(struct nvme_dev *dev, char *format)
                fprintf(stderr, "ERROR: WDC: %s : Failed to retrieve NAND stats\n", __func__);
                goto out;
        } else {
-               fmt = validate_output_format(format);
-               if (fmt < 0) {
+               ret = validate_output_format(format, &fmt);
+               if (ret < 0) {
                        fprintf(stderr, "ERROR: WDC: %s : invalid output format\n", __func__);
-                       ret = fmt;
                        goto out;
                }
 
@@ -10991,6 +11001,8 @@ static int wdc_do_vs_nand_stats_sn810_2(struct nvme_dev *dev, char *format)
                case JSON:
                        wdc_print_ext_smart_cloud_log_json(data, WDC_SCA_V1_NAND_STATS);
                        break;
+               default:
+                       break;
                }
        }
 
@@ -11002,10 +11014,10 @@ out:
 
 static int wdc_do_vs_nand_stats(struct nvme_dev *dev, char *format)
 {
-       int ret;
-       int fmt = -1;
+       enum nvme_print_flags fmt;
        uint8_t *output = NULL;
        __u16 version = 0;
+       int ret;
 
        output = (uint8_t *)calloc(WDC_NVME_NAND_STATS_SIZE, sizeof(uint8_t));
        if (!output) {
@@ -11020,10 +11032,9 @@ static int wdc_do_vs_nand_stats(struct nvme_dev *dev, char *format)
                fprintf(stderr, "ERROR: WDC: %s : Failed to retrieve NAND stats\n", __func__);
                goto out;
        } else {
-               fmt = validate_output_format(format);
-               if (fmt < 0) {
+               ret = validate_output_format(format, &fmt);
+               if (ret < 0) {
                        fprintf(stderr, "ERROR: WDC: invalid output format\n");
-                       ret = fmt;
                        goto out;
                }
 
@@ -11037,6 +11048,8 @@ static int wdc_do_vs_nand_stats(struct nvme_dev *dev, char *format)
                case JSON:
                        wdc_print_nand_stats_json(version, output);
                        break;
+               default:
+                       break;
                }
        }
 
@@ -11125,11 +11138,11 @@ static int wdc_vs_pcie_stats(int argc, char **argv, struct command *command,
                struct plugin *plugin)
 {
        const char *desc = "Retrieve PCIE statistics.";
+       enum nvme_print_flags fmt;
        struct nvme_dev *dev;
-       int ret = 0;
        nvme_root_t r;
+       int ret;
        __u64 capabilities = 0;
-       int fmt = -1;
        _cleanup_huge_ struct nvme_mem_huge mh = { 0, };
        struct wdc_vs_pcie_stats *pcieStatsPtr = NULL;
        int pcie_stats_size = sizeof(struct wdc_vs_pcie_stats);
@@ -11151,12 +11164,10 @@ static int wdc_vs_pcie_stats(int argc, char **argv, struct command *command,
        if (ret)
                return ret;
 
-
        r = nvme_scan(NULL);
-       fmt = validate_output_format(cfg.output_format);
-       if (fmt < 0) {
+       ret = validate_output_format(cfg.output_format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC: invalid output format\n");
-               ret = fmt;
                goto out;
        }
 
@@ -11187,6 +11198,8 @@ static int wdc_vs_pcie_stats(int argc, char **argv, struct command *command,
                        case JSON:
                                wdc_print_pcie_stats_json(pcieStatsPtr);
                                break;
+                       default:
+                               break;
                        }
                }
        }
@@ -11200,6 +11213,7 @@ static int wdc_vs_drive_info(int argc, char **argv,
                struct command *command, struct plugin *plugin)
 {
        const char *desc = "Send a vs-drive-info command.";
+       enum nvme_print_flags fmt;
        nvme_root_t r;
        uint64_t capabilities = 0;
        struct nvme_dev *dev;
@@ -11213,7 +11227,6 @@ static int wdc_vs_drive_info(int argc, char **argv,
        __u8 *data = NULL;
        __u32 ftl_unit_size = 0, tcg_dev_ownership = 0;
        __u16 boot_spec_major = 0, boot_spec_minor = 0;
-       int fmt = -1;
        struct json_object *root = NULL;
        char formatter[41] = { 0 };
        char rev_str[16] = { 0 };
@@ -11240,11 +11253,11 @@ static int wdc_vs_drive_info(int argc, char **argv,
        if (ret)
                return ret;
 
-       fmt = validate_output_format(cfg.output_format);
-       if (fmt < 0) {
+       ret = validate_output_format(cfg.output_format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC %s invalid output format\n", __func__);
                dev_close(dev);
-               return fmt;
+               return ret;
        }
 
        /* get the id ctrl data used to fill in drive info below */
@@ -11468,12 +11481,13 @@ static int wdc_vs_temperature_stats(int argc, char **argv,
        const char *desc = "Send a vs-temperature-stats command.";
        struct nvme_smart_log smart_log;
        struct nvme_id_ctrl id_ctrl;
+       enum nvme_print_flags fmt;
        struct nvme_dev *dev;
        nvme_root_t r;
        uint64_t capabilities = 0;
        __u32 hctm_tmt;
        int temperature, temp_tmt1, temp_tmt2;
-       int ret, fmt = -1;
+       int ret;
 
        struct config {
                char *output_format;
@@ -11493,10 +11507,9 @@ static int wdc_vs_temperature_stats(int argc, char **argv,
                return ret;
 
        r = nvme_scan(NULL);
-       fmt = validate_output_format(cfg.output_format);
-       if (fmt < 0) {
+       ret = validate_output_format(cfg.output_format, &fmt);
+       if (ret < 0) {
                fprintf(stderr, "ERROR: WDC: invalid output format\n");
-               ret = fmt;
                goto out;
        }
 

diff --git a/plugins/zns/zns.c b/plugins/zns/zns.c
index f2c146a5c5850733e76896dfa068e66626c36ae1..a7a37663b5f112c561b544c93976136d1bdbf0d1 100644 (file)
--- a/plugins/zns/zns.c
+++ b/plugins/zns/zns.c
@@ -136,8 +136,8 @@ static int id_ctrl(int argc, char **argv, struct command *cmd, struct plugin *pl
        if (err)
                return errno;
 
-       err = flags = validate_output_format(cfg.output_format);
-       if (flags < 0)
+       err = validate_output_format(cfg.output_format, &flags);
+       if (err < 0)
                goto close_dev;
 
        err = nvme_zns_identify_ctrl(dev_fd(dev), &ctrl);
@@ -189,8 +189,8 @@ static int id_ns(int argc, char **argv, struct command *cmd, struct plugin *plug
        if (err)
                return errno;
 
-       flags = validate_output_format(cfg.output_format);
-       if (flags < 0)
+       err = validate_output_format(cfg.output_format, &flags);
+       if (err < 0)
                goto close_dev;
        if (cfg.vendor_specific)
                flags |= VS;
@@ -766,8 +766,8 @@ static int zone_mgmt_recv(int argc, char **argv, struct command *cmd, struct plu
        if (err)
                return errno;
 
-       flags = validate_output_format(cfg.output_format);
-       if (flags < 0)
+       err = validate_output_format(cfg.output_format, &flags);
+       if (err < 0)
                goto close_dev;
 
        if (!cfg.namespace_id) {
@@ -881,8 +881,8 @@ static int report_zones(int argc, char **argv, struct command *cmd, struct plugi
        if (err)
                return errno;
 
-       flags = validate_output_format(cfg.output_format);
-       if (flags < 0)
+       err = validate_output_format(cfg.output_format, &flags);
+       if (err < 0)
                goto close_dev;
        if (cfg.verbose)
                flags |= VERBOSE;
@@ -1247,8 +1247,8 @@ static int changed_zone_list(int argc, char **argv, struct command *cmd, struct
        if (err)
                return errno;
 
-       flags = validate_output_format(cfg.output_format);
-       if (flags < 0)
+       err = validate_output_format(cfg.output_format, &flags);
+       if (err < 0)
                goto close_dev;
 
        if (!cfg.namespace_id) {