nvme: add flags type nvme_print_flags_t

Change the flags type to the type from enum nvme_print_flags.

Signed-off-by: Tokunori Ikegami <ikegami.t@gmail.com>

diff --git a/fabrics.c b/fabrics.c
index 59e52ba3d969896505ac86635d573a47df887ad5..f1e0bd7772738ee2658538856bb3f6170b51a201 100644 (file)
--- a/fabrics.c
+++ b/fabrics.c
@@ -261,7 +261,7 @@ static void save_discovery_log(char *raw, struct nvmf_discovery_log *log)
 
 static int __discover(nvme_ctrl_t c, struct nvme_fabrics_config *defcfg,
                      char *raw, bool connect, bool persistent,
-                     enum nvme_print_flags flags)
+                     nvme_print_flags_t flags)
 {
        struct nvmf_discovery_log *log = NULL;
        nvme_subsystem_t s = nvme_ctrl_get_subsystem(c);
@@ -407,7 +407,7 @@ static int discover_from_conf_file(nvme_root_t r, nvme_host_t h,
        int argc, ret = 0;
        unsigned int verbose = 0;
        FILE *f;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        char *format = "normal";
        struct nvme_fabrics_config cfg;
        bool force = false;
@@ -505,7 +505,7 @@ out:
 static int discover_from_json_config_file(nvme_root_t r, nvme_host_t h,
                                          const char *desc, bool connect,
                                          const struct nvme_fabrics_config *defcfg,
-                                         enum nvme_print_flags flags,
+                                         nvme_print_flags_t flags,
                                          bool force)
 {
        const char *transport, *traddr, *host_traddr, *host_iface, *trsvcid, *subsysnqn;
@@ -693,7 +693,7 @@ int nvmf_discover(const char *desc, int argc, char **argv, bool connect)
        char *config_file = PATH_NVMF_CONFIG;
        char *hnqn = NULL, *hid = NULL;
        char *context = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        nvme_root_t r;
        nvme_host_t h;
        nvme_ctrl_t c = NULL;
@@ -917,7 +917,7 @@ int nvmf_connect(const char *desc, int argc, char **argv)
        nvme_host_t h;
        nvme_ctrl_t c;
        int ret;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        struct nvme_fabrics_config cfg = { 0 };
        char *format = "normal";
        char *hostnqn_arg, *hostid_arg;

diff --git a/nbft.c b/nbft.c
index 8c03a1f53b474d74ee558b46dd5716e4c9838cb1..f93b4a57ad3eea080e1bdd689d9e45e671a07d50 100644 (file)
--- a/nbft.c
+++ b/nbft.c
@@ -110,7 +110,7 @@ static int do_connect(nvme_root_t r,
                      struct nbft_info_subsystem_ns *ss,
                      struct tr_config *trcfg,
                      struct nvme_fabrics_config *cfg,
-                     enum nvme_print_flags flags,
+                     nvme_print_flags_t flags,
                      unsigned int verbose)
 {
        nvme_ctrl_t c;
@@ -184,7 +184,7 @@ static int do_discover(struct nbft_info_discovery *dd,
                       nvme_ctrl_t c,
                       struct nvme_fabrics_config *defcfg,
                       struct tr_config *deftrcfg,
-                      enum nvme_print_flags flags,
+                      nvme_print_flags_t flags,
                       unsigned int verbose)
 {
        struct nvmf_discovery_log *log = NULL;
@@ -286,7 +286,7 @@ int discover_from_nbft(nvme_root_t r, char *hostnqn_arg, char *hostid_arg,
                       char *hostnqn_sys, char *hostid_sys,
                       const char *desc, bool connect,
                       struct nvme_fabrics_config *cfg, char *nbft_path,
-                      enum nvme_print_flags flags, unsigned int verbose)
+                      nvme_print_flags_t flags, unsigned int verbose)
 {
        char *hostnqn = NULL, *hostid = NULL, *host_traddr = NULL;
        nvme_host_t h;

diff --git a/nbft.h b/nbft.h
index 5dfb8704fd9074f7fdcb6c264438df910a4fa528..88e0f357ae5f34444c14cb039eadb03e961768df 100644 (file)
--- a/nbft.h
+++ b/nbft.h
@@ -16,4 +16,4 @@ extern int discover_from_nbft(nvme_root_t r, char *hostnqn_arg, char *hostid_arg
                              char *hostnqn_sys, char *hostid_sys,
                              const char *desc, bool connect,
                              struct nvme_fabrics_config *cfg, char *nbft_path,
-                             enum nvme_print_flags flags, unsigned int verbose);
+                             nvme_print_flags_t flags, unsigned int verbose);

diff --git a/nvme-print-binary.c b/nvme-print-binary.c
index d743b3e041ab31a2135dca16e7216acae88840b0..1743f6fe8d9fa4832d9e790e4999674b947ebeba 100644 (file)
--- a/nvme-print-binary.c
+++ b/nvme-print-binary.c
@@ -379,7 +379,7 @@ static struct print_ops binary_print_ops = {
        .show_error_status              = NULL,
 };
 
-struct print_ops *nvme_get_binary_print_ops(enum nvme_print_flags flags)
+struct print_ops *nvme_get_binary_print_ops(nvme_print_flags_t flags)
 {
        binary_print_ops.flags = flags;
        return &binary_print_ops;

diff --git a/nvme-print-json.c b/nvme-print-json.c
index 0bb7a705871cba4044a400849c45ad793856fc00..ec04f79b127b0d0f24732c4492bf7ce173c3a809 100644 (file)
--- a/nvme-print-json.c
+++ b/nvme-print-json.c
@@ -4739,7 +4739,7 @@ static struct print_ops json_print_ops = {
        .show_error_status              = json_output_error_status,
 };
 
-struct print_ops *nvme_get_json_print_ops(enum nvme_print_flags flags)
+struct print_ops *nvme_get_json_print_ops(nvme_print_flags_t flags)
 {
        json_print_ops.flags = flags;
        return &json_print_ops;

diff --git a/nvme-print-stdout.c b/nvme-print-stdout.c
index 01c0019af2b0c9a30f5b6c1d1a40928bd78eef81..d24cf74d08522aba6c5b0828a56347b6682aecf6 100644 (file)
--- a/nvme-print-stdout.c
+++ b/nvme-print-stdout.c
@@ -5216,7 +5216,7 @@ static struct print_ops stdout_print_ops = {
        .show_error_status              = stdout_error_status,
 };
 
-struct print_ops *nvme_get_stdout_print_ops(enum nvme_print_flags flags)
+struct print_ops *nvme_get_stdout_print_ops(nvme_print_flags_t flags)
 {
        stdout_print_ops.flags = flags;
        return &stdout_print_ops;

diff --git a/nvme-print.c b/nvme-print.c
index 3e4f309c7906561c8233aac6d000d4d1e4616289..a3b8ddf34c1682d18e5f5d20177aa9ae8d1ca166 100644 (file)
--- a/nvme-print.c
+++ b/nvme-print.c
@@ -25,7 +25,7 @@
 #define nvme_print_output_format(name, ...)                    \
        nvme_print(name, nvme_is_output_format_json() ? JSON : NORMAL, ##__VA_ARGS__);
 
-static struct print_ops *nvme_print_ops(enum nvme_print_flags flags)
+static struct print_ops *nvme_print_ops(nvme_print_flags_t flags)
 {
        struct print_ops *ops = NULL;
 
@@ -134,7 +134,7 @@ const char *nvme_sstat_status_to_string(__u16 status)
 void nvme_show_predictable_latency_per_nvmset(
        struct nvme_nvmset_predictable_lat_log *plpns_log,
        __u16 nvmset_id, const char *devname,
-       enum nvme_print_flags flags)
+       nvme_print_flags_t flags)
 {
        nvme_print(predictable_latency_per_nvmset, flags,
                   plpns_log, nvmset_id, devname);
@@ -143,7 +143,7 @@ void nvme_show_predictable_latency_per_nvmset(
 void nvme_show_predictable_latency_event_agg_log(
        struct nvme_aggregate_predictable_lat_event *pea_log,
        __u64 log_entries, __u32 size, const char *devname,
-       enum nvme_print_flags flags)
+       nvme_print_flags_t flags)
 {
        nvme_print(predictable_latency_event_agg_log, flags,
                   pea_log, log_entries, size, devname);
@@ -228,7 +228,7 @@ const char *nvme_nss_hw_error_to_string(__u16 error_code)
 
 void nvme_show_persistent_event_log(void *pevent_log_info,
        __u8 action, __u32 size, const char *devname,
-       enum nvme_print_flags flags)
+       nvme_print_flags_t flags)
 {
        nvme_print(persistent_event_log, flags,
                   pevent_log_info, action, size, devname);
@@ -237,14 +237,14 @@ void nvme_show_persistent_event_log(void *pevent_log_info,
 void nvme_show_endurance_group_event_agg_log(
        struct nvme_aggregate_predictable_lat_event *endurance_log,
        __u64 log_entries, __u32 size, const char *devname,
-       enum nvme_print_flags flags)
+       nvme_print_flags_t flags)
 {
        nvme_print(endurance_group_event_agg_log, flags,
                   endurance_log, log_entries, size, devname);
 }
 
 void nvme_show_lba_status_log(void *lba_status, __u32 size,
-       const char *devname, enum nvme_print_flags flags)
+       const char *devname, nvme_print_flags_t flags)
 {
        nvme_print(lba_status_log, flags, lba_status, size, devname);
 }
@@ -261,56 +261,56 @@ const char *nvme_resv_notif_to_string(__u8 type)
 }
 
 void nvme_show_resv_notif_log(struct nvme_resv_notification_log *resv,
-       const char *devname, enum nvme_print_flags flags)
+       const char *devname, nvme_print_flags_t flags)
 {
        nvme_print(resv_notification_log, flags, resv, devname);
 }
 
 void nvme_show_fid_support_effects_log(struct nvme_fid_supported_effects_log *fid_log,
-       const char *devname, enum nvme_print_flags flags)
+       const char *devname, nvme_print_flags_t flags)
 {
        nvme_print(fid_supported_effects_log, flags, fid_log, devname);
 }
 
 void nvme_show_mi_cmd_support_effects_log(struct nvme_mi_cmd_supported_effects_log *mi_cmd_log,
-       const char *devname, enum nvme_print_flags flags)
+       const char *devname, nvme_print_flags_t flags)
 {
        nvme_print(mi_cmd_support_effects_log, flags,
                   mi_cmd_log, devname);
 }
 
 void nvme_show_boot_part_log(void *bp_log, const char *devname,
-       __u32 size, enum nvme_print_flags flags)
+       __u32 size, nvme_print_flags_t flags)
 {
        nvme_print(boot_part_log, flags, bp_log, devname, size);
 }
 
 void nvme_show_phy_rx_eom_log(struct nvme_phy_rx_eom_log *log, __u16 controller,
-       enum nvme_print_flags flags)
+       nvme_print_flags_t flags)
 {
        nvme_print(phy_rx_eom_log, flags, log, controller);
 }
 
 void nvme_show_media_unit_stat_log(struct nvme_media_unit_stat_log *mus_log,
-                                  enum nvme_print_flags flags)
+                                  nvme_print_flags_t flags)
 {
        nvme_print(media_unit_stat_log, flags, mus_log);
 }
 
 void nvme_show_fdp_configs(struct nvme_fdp_config_log *log, size_t len,
-               enum nvme_print_flags flags)
+               nvme_print_flags_t flags)
 {
        nvme_print(fdp_config_log, flags, log, len);
 }
 
 void nvme_show_fdp_usage(struct nvme_fdp_ruhu_log *log, size_t len,
-               enum nvme_print_flags flags)
+               nvme_print_flags_t flags)
 {
        nvme_print(fdp_usage_log, flags,log, len);
 }
 
 void nvme_show_fdp_stats(struct nvme_fdp_stats_log *log,
-               enum nvme_print_flags flags)
+               nvme_print_flags_t flags)
 {
        nvme_print(fdp_stats_log, flags, log);
 }
@@ -330,26 +330,26 @@ const char *nvme_fdp_event_to_string(enum nvme_fdp_event_type event)
 }
 
 void nvme_show_fdp_events(struct nvme_fdp_events_log *log,
-               enum nvme_print_flags flags)
+               nvme_print_flags_t flags)
 {
        nvme_print(fdp_event_log, flags, log);
 }
 
 void nvme_show_fdp_ruh_status(struct nvme_fdp_ruh_status *status, size_t len,
-               enum nvme_print_flags flags)
+               nvme_print_flags_t flags)
 {
        nvme_print(fdp_ruh_status, flags, status, len);
 }
 
 void nvme_show_supported_cap_config_log(
        struct nvme_supported_cap_config_list_log *cap,
-       enum nvme_print_flags flags)
+       nvme_print_flags_t flags)
 {
        nvme_print(supported_cap_config_list_log, flags, cap);
 }
 
 void nvme_show_subsystem_list(nvme_root_t r, bool show_ana,
-                             enum nvme_print_flags flags)
+                             nvme_print_flags_t flags)
 {
        nvme_print(print_nvme_subsystem_list, flags, r, show_ana);
 }
@@ -424,7 +424,7 @@ bool nvme_registers_pmrctl_ready(__u32 pmrctl)
        return NVME_PMRCTL_EN(pmrctl);
 }
 
-void nvme_show_ctrl_register(void *bar, bool fabrics, int offset, enum nvme_print_flags flags)
+void nvme_show_ctrl_register(void *bar, bool fabrics, int offset, nvme_print_flags_t flags)
 {
        uint64_t value;
 
@@ -442,12 +442,12 @@ void nvme_show_ctrl_register(void *bar, bool fabrics, int offset, enum nvme_prin
        nvme_print(ctrl_register, flags, offset, value);
 }
 
-void nvme_show_ctrl_registers(void *bar, bool fabrics, enum nvme_print_flags flags)
+void nvme_show_ctrl_registers(void *bar, bool fabrics, nvme_print_flags_t flags)
 {
        nvme_print(ctrl_registers, flags, bar, fabrics);
 }
 
-void nvme_show_single_property(int offset, uint64_t value64, enum nvme_print_flags flags)
+void nvme_show_single_property(int offset, uint64_t value64, nvme_print_flags_t flags)
 {
        nvme_print(single_property, flags, offset, value64);
 }
@@ -496,13 +496,13 @@ void nvme_show_error_status(int status, const char *msg, ...)
        va_end(ap);
 }
 
-void nvme_show_id_ctrl_rpmbs(__le32 ctrl_rpmbs, enum nvme_print_flags flags)
+void nvme_show_id_ctrl_rpmbs(__le32 ctrl_rpmbs, nvme_print_flags_t flags)
 {
        nvme_print(id_ctrl_rpmbs, flags, ctrl_rpmbs);
 }
 
 void nvme_show_id_ns(struct nvme_id_ns *ns, unsigned int nsid,
-               unsigned int lba_index, bool cap_only, enum nvme_print_flags flags)
+               unsigned int lba_index, bool cap_only, nvme_print_flags_t flags)
 {
        nvme_print(id_ns, flags, ns, nsid, lba_index, cap_only);
 }
@@ -510,67 +510,67 @@ void nvme_show_id_ns(struct nvme_id_ns *ns, unsigned int nsid,
 
 void nvme_show_cmd_set_independent_id_ns(
        struct nvme_id_independent_id_ns *ns, unsigned int nsid,
-       enum nvme_print_flags flags)
+       nvme_print_flags_t flags)
 {
        nvme_print(id_independent_id_ns, flags, ns, nsid);
 }
 
-void nvme_show_id_ns_descs(void *data, unsigned int nsid, enum nvme_print_flags flags)
+void nvme_show_id_ns_descs(void *data, unsigned int nsid, nvme_print_flags_t flags)
 {
        nvme_print(id_ns_descs, flags, data, nsid);
 }
 
-void nvme_show_id_ctrl(struct nvme_id_ctrl *ctrl, enum nvme_print_flags flags,
+void nvme_show_id_ctrl(struct nvme_id_ctrl *ctrl, nvme_print_flags_t flags,
                        void (*vendor_show)(__u8 *vs, struct json_object *root))
 {
        nvme_print(id_ctrl, flags, ctrl, vendor_show);
 }
 
 void nvme_show_id_ctrl_nvm(struct nvme_id_ctrl_nvm *ctrl_nvm,
-       enum nvme_print_flags flags)
+       nvme_print_flags_t flags)
 {
        nvme_print(id_ctrl_nvm, flags, ctrl_nvm);
 }
 
 void nvme_show_nvm_id_ns(struct nvme_nvm_id_ns *nvm_ns, unsigned int nsid,
                                                struct nvme_id_ns *ns, unsigned int lba_index,
-                                               bool cap_only, enum nvme_print_flags flags)
+                                               bool cap_only, nvme_print_flags_t flags)
 {
        nvme_print(nvm_id_ns, flags, nvm_ns, nsid, ns, lba_index, cap_only);
 }
 
 void nvme_show_zns_id_ctrl(struct nvme_zns_id_ctrl *ctrl,
-                          enum nvme_print_flags flags)
+                          nvme_print_flags_t flags)
 {
        nvme_print(zns_id_ctrl, flags, ctrl);
 }
 
 void nvme_show_zns_id_ns(struct nvme_zns_id_ns *ns,
                         struct nvme_id_ns *id_ns,
-                        enum nvme_print_flags flags)
+                        nvme_print_flags_t flags)
 {
        nvme_print(zns_id_ns, flags, ns, id_ns);
 }
 
-void nvme_show_list_ns(struct nvme_ns_list *ns_list, enum nvme_print_flags flags)
+void nvme_show_list_ns(struct nvme_ns_list *ns_list, nvme_print_flags_t flags)
 {
        nvme_print(ns_list, flags, ns_list);
 }
 
 void nvme_zns_start_zone_list(__u64 nr_zones, struct json_object **zone_list,
-                             enum nvme_print_flags flags)
+                             nvme_print_flags_t flags)
 {
        nvme_print(zns_start_zone_list, flags, nr_zones, zone_list);
 }
 
 void nvme_show_zns_changed(struct nvme_zns_changed_zone_log *log,
-                          enum nvme_print_flags flags)
+                          nvme_print_flags_t flags)
 {
        nvme_print(zns_changed_zone_log, flags, log);
 }
 
 void nvme_zns_finish_zone_list(__u64 nr_zones, struct json_object *zone_list,
-                              enum nvme_print_flags flags)
+                              nvme_print_flags_t flags)
 {
        nvme_print(zns_finish_zone_list, flags, nr_zones, zone_list);
 }
@@ -610,33 +610,33 @@ const char *nvme_zone_state_to_string(__u8 state)
 void nvme_show_zns_report_zones(void *report, __u32 descs,
                                __u8 ext_size, __u32 report_size,
                                struct json_object *zone_list,
-                               enum nvme_print_flags flags)
+                               nvme_print_flags_t flags)
 {
        nvme_print(zns_report_zones, flags,
                   report, descs, ext_size, report_size, zone_list);
 }
 
 void nvme_show_list_ctrl(struct nvme_ctrl_list *ctrl_list,
-       enum nvme_print_flags flags)
+       nvme_print_flags_t flags)
 {
        nvme_print(ctrl_list, flags, ctrl_list);
 }
 
 void nvme_show_id_nvmset(struct nvme_id_nvmset_list *nvmset, unsigned nvmset_id,
-       enum nvme_print_flags flags)
+       nvme_print_flags_t flags)
 {
        nvme_print(id_nvmset_list, flags, nvmset, nvmset_id);
 }
 
 void nvme_show_primary_ctrl_cap(const struct nvme_primary_ctrl_cap *caps,
-                               enum nvme_print_flags flags)
+                               nvme_print_flags_t flags)
 {
        nvme_print(primary_ctrl_cap, flags, caps);
 }
 
 void nvme_show_list_secondary_ctrl(
        const struct nvme_secondary_ctrl_list *sc_list,
-       __u32 count, enum nvme_print_flags flags)
+       __u32 count, nvme_print_flags_t flags)
 {
        __u16 num = sc_list->num;
        __u32 entries = min(num, count);
@@ -645,30 +645,30 @@ void nvme_show_list_secondary_ctrl(
 }
 
 void nvme_show_id_ns_granularity_list(const struct nvme_id_ns_granularity_list *glist,
-       enum nvme_print_flags flags)
+       nvme_print_flags_t flags)
 {
        nvme_print(id_ns_granularity_list, flags, glist);
 }
 
 void nvme_show_id_uuid_list(const struct nvme_id_uuid_list *uuid_list,
-                               enum nvme_print_flags flags)
+                               nvme_print_flags_t flags)
 {
        nvme_print(id_uuid_list, flags, uuid_list);
 }
 
 void nvme_show_id_domain_list(struct nvme_id_domain_list *id_dom,
-       enum nvme_print_flags flags)
+       nvme_print_flags_t flags)
 {
        nvme_print(id_domain_list, flags, id_dom);
 }
 
 void nvme_show_endurance_group_list(struct nvme_id_endurance_group_list *endgrp_list,
-       enum nvme_print_flags flags)
+       nvme_print_flags_t flags)
 {
        nvme_print(endurance_group_list, flags, endgrp_list);
 }
 
-void nvme_show_id_iocs(struct nvme_id_iocs *iocs, enum nvme_print_flags flags)
+void nvme_show_id_iocs(struct nvme_id_iocs *iocs, nvme_print_flags_t flags)
 {
        nvme_print(id_iocs, flags, iocs);
 }
@@ -687,32 +687,32 @@ const char *nvme_trtype_to_string(__u8 trtype)
 }
 
 void nvme_show_error_log(struct nvme_error_log_page *err_log, int entries,
-                        const char *devname, enum nvme_print_flags flags)
+                        const char *devname, nvme_print_flags_t flags)
 {
        nvme_print(error_log, flags, err_log, entries, devname);
 }
 
 void nvme_show_resv_report(struct nvme_resv_status *status, int bytes,
-                          bool eds, enum nvme_print_flags flags)
+                          bool eds, nvme_print_flags_t flags)
 {
        nvme_print(resv_report, flags, status, bytes, eds);
 }
 
 void nvme_show_fw_log(struct nvme_firmware_slot *fw_log,
-       const char *devname, enum nvme_print_flags flags)
+       const char *devname, nvme_print_flags_t flags)
 {
        nvme_print(fw_log, flags, fw_log, devname);
 }
 
 void nvme_show_changed_ns_list_log(struct nvme_ns_list *log,
                                   const char *devname,
-                                  enum nvme_print_flags flags)
+                                  nvme_print_flags_t flags)
 {
        nvme_print(ns_list_log, flags, log, devname);
 }
 
 void nvme_print_effects_log_pages(struct list_head *list,
-                                 enum nvme_print_flags flags)
+                                 nvme_print_flags_t flags)
 {
        nvme_print(effects_log_list, flags, list);
 }
@@ -755,14 +755,14 @@ const char *nvme_log_to_string(__u8 lid)
 }
 
 void nvme_show_supported_log(struct nvme_supported_log_pages *support_log,
-       const char *devname, enum nvme_print_flags flags)
+       const char *devname, nvme_print_flags_t flags)
 {
        nvme_print(supported_log_pages, flags, support_log, devname);
 }
 
 void nvme_show_endurance_log(struct nvme_endurance_group_log *endurance_log,
                             __u16 group_id, const char *devname,
-                            enum nvme_print_flags flags)
+                            nvme_print_flags_t flags)
 {
        nvme_print(endurance_log, flags, endurance_log, group_id, devname);
 }
@@ -782,25 +782,25 @@ const char *nvme_degrees_string(long t, bool fahrenheit)
 }
 
 void nvme_show_smart_log(struct nvme_smart_log *smart, unsigned int nsid,
-                        const char *devname, enum nvme_print_flags flags)
+                        const char *devname, nvme_print_flags_t flags)
 {
        nvme_print(smart_log, flags, smart, nsid, devname);
 }
 
 void nvme_show_ana_log(struct nvme_ana_log *ana_log, const char *devname,
-                      size_t len, enum nvme_print_flags flags)
+                      size_t len, nvme_print_flags_t flags)
 {
        nvme_print(ana_log, flags, ana_log, devname, len);
 }
 
 void nvme_show_self_test_log(struct nvme_self_test_log *self_test, __u8 dst_entries,
-                               __u32 size, const char *devname, enum nvme_print_flags flags)
+                               __u32 size, const char *devname, nvme_print_flags_t flags)
 {
        nvme_print(self_test_log, flags, self_test, dst_entries, size, devname);
 }
 
 void nvme_show_sanitize_log(struct nvme_sanitize_log_page *sanitize,
-                           const char *devname, enum nvme_print_flags flags)
+                           const char *devname, nvme_print_flags_t flags)
 {
        nvme_print(sanitize_log_page, flags, sanitize, devname);
 }
@@ -953,7 +953,7 @@ const char *nvme_feature_lba_type_to_string(__u8 type)
 }
 
 void nvme_show_lba_range(struct nvme_lba_range_type *lbrt, int nr_ranges,
-                        enum nvme_print_flags flags)
+                        nvme_print_flags_t flags)
 {
        nvme_print(lba_range, flags, lbrt, nr_ranges);
 }
@@ -1010,7 +1010,7 @@ const char *nvme_ns_wp_cfg_to_string(enum nvme_ns_write_protect_cfg state)
 }
 
 void nvme_directive_show(__u8 type, __u8 oper, __u16 spec, __u32 nsid, __u32 result,
-                        void *buf, __u32 len, enum nvme_print_flags flags)
+                        void *buf, __u32 len, nvme_print_flags_t flags)
 {
        nvme_print(directive, flags, type, oper, spec, nsid, result, buf, len);
 }
@@ -1200,7 +1200,7 @@ void nvme_feature_show_fields(enum nvme_features_id fid, unsigned int result, un
 }
 
 void nvme_show_lba_status(struct nvme_lba_status *list, unsigned long len,
-                         enum nvme_print_flags flags)
+                         nvme_print_flags_t flags)
 {
        nvme_print(lba_status, flags, list, len);
 }
@@ -1254,14 +1254,14 @@ void nvme_show_list_item(nvme_ns_t n)
        nvme_print(list_item, NORMAL, n);
 }
 
-void nvme_show_list_items(nvme_root_t r, enum nvme_print_flags flags)
+void nvme_show_list_items(nvme_root_t r, nvme_print_flags_t flags)
 {
        nvme_print(list_items, flags, r);
 }
 
 void nvme_show_topology(nvme_root_t r,
                        enum nvme_cli_topo_ranking ranking,
-                       enum nvme_print_flags flags)
+                       nvme_print_flags_t flags)
 {
        if (ranking == NVME_CLI_TOPO_NAMESPACE)
                nvme_print(topology_namespace, flags, r);
@@ -1297,12 +1297,12 @@ void nvme_show_perror(const char *msg)
 }
 
 void nvme_show_discovery_log(struct nvmf_discovery_log *log, uint64_t numrec,
-                            enum nvme_print_flags flags)
+                            nvme_print_flags_t flags)
 {
        nvme_print(discovery_log, flags, log, numrec);
 }
 
-void nvme_show_connect_msg(nvme_ctrl_t c, enum nvme_print_flags flags)
+void nvme_show_connect_msg(nvme_ctrl_t c, nvme_print_flags_t flags)
 {
        nvme_print(connect_msg, flags, c);
 }

diff --git a/nvme-print.h b/nvme-print.h
index 8d9d2cd82448eba5941915777f593d2efb67b61b..11928af60e7e40c98acc06d35025b0e3b345a7a3 100644 (file)
--- a/nvme-print.h
+++ b/nvme-print.h
@@ -105,7 +105,7 @@ struct print_ops {
        void (*show_status)(int status);
        void (*show_error_status)(int status, const char *msg, va_list ap);
 
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
 };
 
 struct nvme_bar_cap {
@@ -131,158 +131,158 @@ struct nvme_bar_cap {
 
 #ifdef CONFIG_JSONC
 
-struct print_ops *nvme_get_json_print_ops(enum nvme_print_flags flags);
+struct print_ops *nvme_get_json_print_ops(nvme_print_flags_t flags);
 
 #else /* !CONFIG_JSONC */
 
-static inline struct print_ops *nvme_get_json_print_ops(enum nvme_print_flags flags) { return NULL; }
+static inline struct print_ops *nvme_get_json_print_ops(nvme_print_flags_t flags) { return NULL; }
 
 #endif /* !CONFIG_JSONC */
 
-struct print_ops *nvme_get_stdout_print_ops(enum nvme_print_flags flags);
-struct print_ops *nvme_get_binary_print_ops(enum nvme_print_flags flags);
+struct print_ops *nvme_get_stdout_print_ops(nvme_print_flags_t flags);
+struct print_ops *nvme_get_binary_print_ops(nvme_print_flags_t flags);
 
 void nvme_show_status(int status);
 void nvme_show_lba_status_info(__u32 result);
 void nvme_show_relatives(const char *name);
 
-void nvme_show_id_iocs(struct nvme_id_iocs *iocs, enum nvme_print_flags flags);
-void nvme_show_id_ctrl(struct nvme_id_ctrl *ctrl, enum nvme_print_flags flags,
+void nvme_show_id_iocs(struct nvme_id_iocs *iocs, nvme_print_flags_t flags);
+void nvme_show_id_ctrl(struct nvme_id_ctrl *ctrl, nvme_print_flags_t flags,
        void (*vendor_show)(__u8 *vs, struct json_object *root));
-void nvme_show_id_ctrl_rpmbs(__le32 ctrl_rpmbs, enum nvme_print_flags flags);
+void nvme_show_id_ctrl_rpmbs(__le32 ctrl_rpmbs, nvme_print_flags_t flags);
 void nvme_show_id_ns(struct nvme_id_ns *ns, unsigned int nsid,
-               unsigned int lba_index, bool cap_only, enum nvme_print_flags flags);
+               unsigned int lba_index, bool cap_only, nvme_print_flags_t flags);
 void nvme_show_cmd_set_independent_id_ns(
        struct nvme_id_independent_id_ns *ns, unsigned int nsid,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_resv_report(struct nvme_resv_status *status, int bytes, bool eds,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_lba_range(struct nvme_lba_range_type *lbrt, int nr_ranges,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_supported_log(struct nvme_supported_log_pages *support,
-       const char *devname, enum nvme_print_flags flags);
+       const char *devname, nvme_print_flags_t flags);
 void nvme_show_error_log(struct nvme_error_log_page *err_log, int entries,
-       const char *devname, enum nvme_print_flags flags);
+       const char *devname, nvme_print_flags_t flags);
 void nvme_show_smart_log(struct nvme_smart_log *smart, unsigned int nsid, const char *devname,
-                        enum nvme_print_flags flags);
+                        nvme_print_flags_t flags);
 void nvme_show_ana_log(struct nvme_ana_log *ana_log, const char *devname,
-                      size_t len, enum nvme_print_flags flags);
+                      size_t len, nvme_print_flags_t flags);
 void nvme_show_self_test_log(struct nvme_self_test_log *self_test, __u8 dst_entries,
-       __u32 size, const char *devname, enum nvme_print_flags flags);
+       __u32 size, const char *devname, nvme_print_flags_t flags);
 void nvme_show_fw_log(struct nvme_firmware_slot *fw_log, const char *devname,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_print_effects_log_pages(struct list_head *list,
-                                 enum nvme_print_flags flags);
+                                 nvme_print_flags_t flags);
 void nvme_show_changed_ns_list_log(struct nvme_ns_list *log,
-       const char *devname, enum nvme_print_flags flags);
+       const char *devname, nvme_print_flags_t flags);
 void nvme_show_endurance_log(struct nvme_endurance_group_log *endurance_log,
-       __u16 group_id, const char *devname, enum nvme_print_flags flags);
+       __u16 group_id, const char *devname, nvme_print_flags_t flags);
 void nvme_show_sanitize_log(struct nvme_sanitize_log_page *sanitize,
-       const char *devname, enum nvme_print_flags flags);
+       const char *devname, nvme_print_flags_t flags);
 void nvme_show_predictable_latency_per_nvmset(
        struct nvme_nvmset_predictable_lat_log *plpns_log,
-       __u16 nvmset_id, const char *devname, enum nvme_print_flags flags);
+       __u16 nvmset_id, const char *devname, nvme_print_flags_t flags);
 void nvme_show_predictable_latency_event_agg_log(
        struct nvme_aggregate_predictable_lat_event *pea_log,
        __u64 log_entries, __u32 size, const char *devname,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_persistent_event_log(void *pevent_log_info,
        __u8 action, __u32 size, const char *devname,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_endurance_group_event_agg_log(
        struct nvme_aggregate_predictable_lat_event *endurance_log,
        __u64 log_entries, __u32 size, const char *devname,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_lba_status_log(void *lba_status, __u32 size,
-       const char *devname, enum nvme_print_flags flags);
+       const char *devname, nvme_print_flags_t flags);
 void nvme_show_resv_notif_log(struct nvme_resv_notification_log *resv,
-       const char *devname, enum nvme_print_flags flags);
+       const char *devname, nvme_print_flags_t flags);
 void nvme_show_boot_part_log(void *bp_log, const char *devname,
-       __u32 size, enum nvme_print_flags flags);
+       __u32 size, nvme_print_flags_t flags);
 void nvme_show_phy_rx_eom_log(struct nvme_phy_rx_eom_log *log,
-       __u16 controller, enum nvme_print_flags flags);
+       __u16 controller, nvme_print_flags_t flags);
 void nvme_show_fid_support_effects_log(struct nvme_fid_supported_effects_log *fid_log,
-       const char *devname, enum nvme_print_flags flags);
+       const char *devname, nvme_print_flags_t flags);
 void nvme_show_mi_cmd_support_effects_log(struct nvme_mi_cmd_supported_effects_log *mi_cmd_log,
-       const char *devname, enum nvme_print_flags flags);
+       const char *devname, nvme_print_flags_t flags);
 void nvme_show_media_unit_stat_log(struct nvme_media_unit_stat_log *mus,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_supported_cap_config_log(struct nvme_supported_cap_config_list_log *caplog,
-                               enum nvme_print_flags flags);
-void nvme_show_ctrl_registers(void *bar, bool fabrics, enum nvme_print_flags flags);
-void nvme_show_ctrl_register(void *bar, bool fabrics, int offset, enum nvme_print_flags flags);
-void nvme_show_single_property(int offset, uint64_t prop, enum nvme_print_flags flags);
-void nvme_show_id_ns_descs(void *data, unsigned int nsid, enum nvme_print_flags flags);
+                               nvme_print_flags_t flags);
+void nvme_show_ctrl_registers(void *bar, bool fabrics, nvme_print_flags_t flags);
+void nvme_show_ctrl_register(void *bar, bool fabrics, int offset, nvme_print_flags_t flags);
+void nvme_show_single_property(int offset, uint64_t prop, nvme_print_flags_t flags);
+void nvme_show_id_ns_descs(void *data, unsigned int nsid, nvme_print_flags_t flags);
 void nvme_show_lba_status(struct nvme_lba_status *list, unsigned long len,
-       enum nvme_print_flags flags);
-void nvme_show_list_items(nvme_root_t t, enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
+void nvme_show_list_items(nvme_root_t t, nvme_print_flags_t flags);
 void nvme_show_subsystem_list(nvme_root_t t, bool show_ana,
-                             enum nvme_print_flags flags);
+                             nvme_print_flags_t flags);
 void nvme_show_id_nvmset(struct nvme_id_nvmset_list *nvmset, unsigned nvmset_id,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_primary_ctrl_cap(const struct nvme_primary_ctrl_cap *cap,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_list_secondary_ctrl(const struct nvme_secondary_ctrl_list *sc_list,
-       __u32 count, enum nvme_print_flags flags);
+       __u32 count, nvme_print_flags_t flags);
 void nvme_show_id_ns_granularity_list(const struct nvme_id_ns_granularity_list *glist,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_id_uuid_list(const struct nvme_id_uuid_list *uuid_list,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_list_ctrl(struct nvme_ctrl_list *ctrl_list,
-        enum nvme_print_flags flags);
+        nvme_print_flags_t flags);
 void nvme_show_id_domain_list(struct nvme_id_domain_list *id_dom,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_endurance_group_list(struct nvme_id_endurance_group_list *endgrp_list,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_list_ns(struct nvme_ns_list *ns_list,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_topology(nvme_root_t t,
                        enum nvme_cli_topo_ranking ranking,
-                       enum nvme_print_flags flags);
+                       nvme_print_flags_t flags);
 
 void nvme_feature_show(enum nvme_features_id fid, int sel, unsigned int result);
 void nvme_feature_show_fields(enum nvme_features_id fid, unsigned int result, unsigned char *buf);
 void nvme_directive_show(__u8 type, __u8 oper, __u16 spec, __u32 nsid, __u32 result,
-       void *buf, __u32 len, enum nvme_print_flags flags);
+       void *buf, __u32 len, nvme_print_flags_t flags);
 void nvme_show_select_result(enum nvme_features_id fid, __u32 result);
 
 void nvme_show_zns_id_ctrl(struct nvme_zns_id_ctrl *ctrl,
-                          enum nvme_print_flags flags);
+                          nvme_print_flags_t flags);
 void nvme_show_id_ctrl_nvm(struct nvme_id_ctrl_nvm *ctrl_nvm,
-       enum nvme_print_flags flags);
+       nvme_print_flags_t flags);
 void nvme_show_nvm_id_ns(struct nvme_nvm_id_ns *nvm_ns, unsigned int nsid,
                                                struct nvme_id_ns *ns, unsigned int lba_index,
-                                               bool cap_only, enum nvme_print_flags flags);
+                                               bool cap_only, nvme_print_flags_t flags);
 void nvme_show_zns_id_ns(struct nvme_zns_id_ns *ns,
-                        struct nvme_id_ns *id_ns, enum nvme_print_flags flags);
+                        struct nvme_id_ns *id_ns, nvme_print_flags_t flags);
 void nvme_zns_start_zone_list(__u64 nr_zones, struct json_object **zone_list,
-                             enum nvme_print_flags flags);
+                             nvme_print_flags_t flags);
 void nvme_show_zns_changed(struct nvme_zns_changed_zone_log *log,
-                          enum nvme_print_flags flags);
+                          nvme_print_flags_t flags);
 void nvme_zns_finish_zone_list(__u64 nr_zones, struct json_object *zone_list,
-                              enum nvme_print_flags flags);
+                              nvme_print_flags_t flags);
 void nvme_show_zns_report_zones(void *report, __u32 descs,
                                __u8 ext_size, __u32 report_size,
                                struct json_object *zone_list,
-                               enum nvme_print_flags flags);
+                               nvme_print_flags_t flags);
 void json_nvme_finish_zone_list(__u64 nr_zones, 
        struct json_object *zone_list);
 void nvme_show_list_item(nvme_ns_t n);
 
 void nvme_show_fdp_configs(struct nvme_fdp_config_log *configs, size_t len,
-               enum nvme_print_flags flags);
+               nvme_print_flags_t flags);
 void nvme_show_fdp_stats(struct nvme_fdp_stats_log *log,
-               enum nvme_print_flags flags);
+               nvme_print_flags_t flags);
 void nvme_show_fdp_events(struct nvme_fdp_events_log *log,
-               enum nvme_print_flags flags);
+               nvme_print_flags_t flags);
 void nvme_show_fdp_usage(struct nvme_fdp_ruhu_log *log, size_t len,
-               enum nvme_print_flags flags);
+               nvme_print_flags_t flags);
 void nvme_show_fdp_ruh_status(struct nvme_fdp_ruh_status *status, size_t len,
-               enum nvme_print_flags flags);
+               nvme_print_flags_t flags);
 
 void nvme_show_discovery_log(struct nvmf_discovery_log *log, uint64_t numrec,
-                            enum nvme_print_flags flags);
-void nvme_show_connect_msg(nvme_ctrl_t c, enum nvme_print_flags flags);
+                            nvme_print_flags_t flags);
+void nvme_show_connect_msg(nvme_ctrl_t c, nvme_print_flags_t flags);
 
 const char *nvme_ana_state_to_string(enum nvme_ana_state state);
 const char *nvme_cmd_to_string(int admin, __u8 opcode);

diff --git a/nvme.c b/nvme.c
index 91012faf98e55ceabcc4a09ada9f5581f672dcad..528eb448b4c05de5e4ffaf418b8dc093dc656386 100644 (file)
--- a/nvme.c
+++ b/nvme.c
@@ -489,9 +489,9 @@ int open_exclusive(struct nvme_dev **dev, int argc, char **argv,
        return get_dev(dev, argc, argv, flags);
 }
 
-int validate_output_format(const char *format, enum nvme_print_flags *flags)
+int validate_output_format(const char *format, nvme_print_flags_t *flags)
 {
-       enum nvme_print_flags f;
+       nvme_print_flags_t f;
 
        if (!format)
                return -EINVAL;
@@ -512,7 +512,7 @@ int validate_output_format(const char *format, enum nvme_print_flags *flags)
 
 bool nvme_is_output_format_json(void)
 {
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
 
        if (validate_output_format(nvme_cfg.output_format, &flags))
                return false;
@@ -543,7 +543,7 @@ static int get_smart_log(int argc, char **argv, struct command *cmd, struct plug
        _cleanup_free_ struct nvme_smart_log *smart_log = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
        const char *namespace = "(optional) desired namespace";
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        struct config {
@@ -613,7 +613,7 @@ static int get_ana_log(int argc, char **argv, struct command *cmd,
        _cleanup_free_ struct nvme_ana_log *ana_log = NULL;
        size_t max_ana_log_len;
        __u32 ana_log_len;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        struct config {
@@ -986,7 +986,7 @@ static int get_endurance_log(int argc, char **argv, struct command *cmd, struct
 
        _cleanup_free_ struct nvme_endurance_group_log *endurance_log = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -1059,7 +1059,7 @@ static int get_effects_log(int argc, char **argv, struct command *cmd, struct pl
        void *bar = NULL;
 
        int err = -1;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
 
        struct config {
                bool    human_readable;
@@ -1149,7 +1149,7 @@ static int get_supported_log_pages(int argc, char **argv, struct command *cmd,
 
        _cleanup_free_ struct nvme_supported_log_pages *supports = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        NVME_ARGS(opts);
@@ -1193,7 +1193,7 @@ static int get_error_log(int argc, char **argv, struct command *cmd, struct plug
        _cleanup_free_ struct nvme_error_log_page *err_log = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
        struct nvme_id_ctrl ctrl;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        struct config {
@@ -1261,7 +1261,7 @@ static int get_fw_log(int argc, char **argv, struct command *cmd, struct plugin
 
        _cleanup_free_ struct nvme_firmware_slot *fw_log = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -1310,7 +1310,7 @@ static int get_changed_ns_list_log(int argc, char **argv, struct command *cmd, s
 
        _cleanup_free_ struct nvme_ns_list *changed_ns_list_log = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -1364,7 +1364,7 @@ static int get_pred_lat_per_nvmset_log(int argc, char **argv,
 
        _cleanup_free_ struct nvme_nvmset_predictable_lat_log *plpns_log = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -1422,7 +1422,7 @@ static int get_pred_lat_event_agg_log(int argc, char **argv,
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
        _cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
        _cleanup_free_ void *pea_log = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        __u32 log_size;
        int err;
 
@@ -1508,7 +1508,7 @@ static int get_persistent_event_log(int argc, char **argv,
        struct nvme_persistent_event_log *pevent_collected = NULL;
        _cleanup_huge_ struct nvme_mem_huge mh = { 0, };
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        void *pevent_log_info;
        int err;
 
@@ -1624,7 +1624,7 @@ static int get_endurance_event_agg_log(int argc, char **argv,
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
        _cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
        _cleanup_free_ void *endurance_log = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        __u32 log_size;
        int err;
 
@@ -1705,7 +1705,7 @@ static int get_lba_status_log(int argc, char **argv,
 
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
        _cleanup_free_ void *lba_status = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        __u32 lslplen;
        int err;
 
@@ -1765,7 +1765,7 @@ static int get_resv_notif_log(int argc, char **argv,
 
        _cleanup_free_ struct nvme_resv_notification_log *resv = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        NVME_ARGS(opts);
@@ -1806,7 +1806,7 @@ static int get_boot_part_log(int argc, char **argv, struct command *cmd, struct
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
        _cleanup_free_ struct nvme_boot_partition *boot = NULL;
        _cleanup_free_ __u8 *bp_log = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
        _cleanup_file_ int output = -1;
        __u32 bpsz = 0;
@@ -1900,7 +1900,7 @@ static int get_phy_rx_eom_log(int argc, char **argv, struct command *cmd,
        const char *controller = "Target Controller ID.";
        _cleanup_free_ struct nvme_phy_rx_eom_log *phy_rx_eom_log = NULL;
        size_t phy_rx_eom_log_len;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
        int err = -1;
        __u8 lsp_tmp;
@@ -1990,7 +1990,7 @@ static int get_media_unit_stat_log(int argc, char **argv, struct command *cmd,
 
        _cleanup_free_ struct nvme_media_unit_stat_log *mus = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        struct config {
@@ -2042,7 +2042,7 @@ static int get_supp_cap_config_log(int argc, char **argv, struct command *cmd,
 
        _cleanup_free_ struct nvme_supported_cap_config_list_log *cap_log = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        struct config {
@@ -2399,7 +2399,7 @@ static int sanitize_log(int argc, char **argv, struct command *command, struct p
 
        _cleanup_free_ struct nvme_sanitize_log_page *sanitize_log = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -2457,7 +2457,7 @@ static int get_fid_support_effects_log(int argc, char **argv, struct command *cm
 
        _cleanup_free_ struct nvme_fid_supported_effects_log *fid_support_log = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        struct config {
@@ -2506,7 +2506,7 @@ static int get_mi_cmd_support_effects_log(int argc, char **argv, struct command
 
        _cleanup_free_ struct nvme_mi_cmd_supported_effects_log *mi_cmd_support_log = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        struct config {
@@ -2556,7 +2556,7 @@ static int list_ctrl(int argc, char **argv, struct command *cmd, struct plugin *
 
        _cleanup_free_ struct nvme_ctrl_list *cntlist = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -2612,7 +2612,7 @@ static int list_ns(int argc, char **argv, struct command *cmd, struct plugin *pl
 
        _cleanup_free_ struct nvme_ns_list *ns_list = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -2685,7 +2685,7 @@ static int id_ns_lba_format(int argc, char **argv, struct command *cmd, struct p
 
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
        _cleanup_free_ struct nvme_id_ns *ns = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        struct config {
@@ -2740,7 +2740,7 @@ static int id_endurance_grp_list(int argc, char **argv, struct command *cmd,
 
        _cleanup_free_ struct nvme_id_endurance_group_list *endgrp_list = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        struct config {
@@ -3310,7 +3310,7 @@ static int list_subsys(int argc, char **argv, struct command *cmd,
                struct plugin *plugin)
 {
        _cleanup_nvme_root_ nvme_root_t r = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        const char *desc = "Retrieve information for subsystems";
        nvme_scan_filter_t filter = NULL;
        char *devname;
@@ -3371,7 +3371,7 @@ static int list_subsys(int argc, char **argv, struct command *cmd,
 static int list(int argc, char **argv, struct command *cmd, struct plugin *plugin)
 {
        const char *desc = "Retrieve basic information for all NVMe namespaces";
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        _cleanup_nvme_root_ nvme_root_t r = NULL;
        int err = 0;
 
@@ -3419,7 +3419,7 @@ int __id_ctrl(int argc, char **argv, struct command *cmd, struct plugin *plugin,
 
        _cleanup_free_ struct nvme_id_ctrl *ctrl = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -3487,7 +3487,7 @@ static int nvm_id_ctrl(int argc, char **argv, struct command *cmd,
 
        _cleanup_free_ struct nvme_id_ctrl_nvm *ctrl_nvm = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        NVME_ARGS(opts);
@@ -3527,7 +3527,7 @@ static int nvm_id_ns(int argc, char **argv, struct command *cmd,
        _cleanup_free_ struct nvme_nvm_id_ns *id_ns = NULL;
        _cleanup_free_ struct nvme_id_ns *ns = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        struct config {
@@ -3601,7 +3601,7 @@ static int nvm_id_ns_lba_format(int argc, char **argv, struct command *cmd, stru
        _cleanup_free_ struct nvme_nvm_id_ns *nvm_ns = NULL;
        _cleanup_free_ struct nvme_id_ns *ns = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        struct config {
@@ -3666,7 +3666,7 @@ static int ns_descs(int argc, char **argv, struct command *cmd, struct plugin *p
 
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
        _cleanup_free_ void *nsdescs = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -3733,7 +3733,7 @@ static int id_ns(int argc, char **argv, struct command *cmd, struct plugin *plug
 
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
        _cleanup_free_ struct nvme_id_ns *ns = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -3814,7 +3814,7 @@ static int cmd_set_independent_id_ns(int argc, char **argv, struct command *cmd,
 
        _cleanup_free_ struct nvme_id_independent_id_ns *ns = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err = -1;
 
        struct config {
@@ -3882,7 +3882,7 @@ static int id_ns_granularity(int argc, char **argv, struct command *cmd, struct
 
        _cleanup_free_ struct nvme_id_ns_granularity_list *granularity_list = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        NVME_ARGS(opts);
@@ -3922,7 +3922,7 @@ static int id_nvmset(int argc, char **argv, struct command *cmd, struct plugin *
 
        _cleanup_free_ struct nvme_id_nvmset_list *nvmset = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -3971,7 +3971,7 @@ static int id_uuid(int argc, char **argv, struct command *cmd, struct plugin *pl
 
        _cleanup_free_ struct nvme_id_uuid_list *uuid_list = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -4071,7 +4071,7 @@ static int id_domain(int argc, char **argv, struct command *cmd, struct plugin *
 
        _cleanup_free_ struct nvme_id_domain_list *id_domain = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -4214,7 +4214,7 @@ static int primary_ctrl_caps(int argc, char **argv, struct command *cmd, struct
 
        _cleanup_free_ struct nvme_primary_ctrl_cap *caps = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -4269,7 +4269,7 @@ static int list_secondary_ctrl(int argc, char **argv, struct command *cmd, struc
 
        _cleanup_free_ struct nvme_secondary_ctrl_list *sc_list = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -4527,7 +4527,7 @@ static int self_test_log(int argc, char **argv, struct command *cmd, struct plug
 
        _cleanup_free_ struct nvme_self_test_log *log = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err;
 
        struct config {
@@ -5418,7 +5418,7 @@ static int show_registers(int argc, char **argv, struct command *cmd, struct plu
            "show info in readable format in case of output_format == normal";
 
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        bool fabrics = false;
        void *bar;
        int err;
@@ -5618,7 +5618,7 @@ bool nvme_is_ctrl_reg(int offset)
 }
 
 static bool get_register_offset(void *bar, bool fabrics, struct get_reg_config *cfg,
-                               enum nvme_print_flags flags)
+                               nvme_print_flags_t flags)
 {
        bool offset_matched = cfg->offset >= 0;
        int offset;
@@ -5665,7 +5665,7 @@ static int get_register(int argc, char **argv, struct command *cmd, struct plugi
 
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
        int err;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        bool fabrics = false;
 
        void *bar;
@@ -7630,7 +7630,7 @@ static int resv_report(int argc, char **argv, struct command *cmd, struct plugin
 
        _cleanup_free_ struct nvme_resv_status *status = NULL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int err, size;
 
        struct config {
@@ -8319,7 +8319,7 @@ static int get_lba_status(int argc, char **argv, struct command *cmd,
 
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
        _cleanup_free_ void *buf = NULL;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        unsigned long buf_len;
        int err;
 
@@ -8466,7 +8466,7 @@ static int dir_receive(int argc, char **argv, struct command *cmd, struct plugin
        const char *desc = "Read directive parameters of the specified directive type.";
        const char *nsr = "namespace stream requested";
 
-       enum nvme_print_flags flags = NORMAL;
+       nvme_print_flags_t flags = NORMAL;
        _cleanup_nvme_dev_ struct nvme_dev *dev = NULL;
        _cleanup_free_ void *buf = NULL;
        __u32 result;
@@ -9542,7 +9542,7 @@ static int show_topology_cmd(int argc, char **argv, struct command *command, str
 {
        const char *desc = "Show the topology\n";
        const char *ranking = "Ranking order: namespace|ctrl";
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        _cleanup_nvme_root_ nvme_root_t r = NULL;
        enum nvme_cli_topo_ranking rank;
        int err;

diff --git a/nvme.h b/nvme.h
index 66b544fc9fff4c9125c3e1a5dbe2d824320dddf7..051fdf0030b7f6f5e7f1956081b6da7f0eb3b4fb 100644 (file)
--- a/nvme.h
+++ b/nvme.h
@@ -41,6 +41,8 @@ enum nvme_print_flags {
        FAHRENHEIT      = 1 << 4,       /* show temperatures in degrees fahrenheit */
 };
 
+typedef uint32_t nvme_print_flags_t;
+
 enum nvme_cli_topo_ranking {
        NVME_CLI_TOPO_NAMESPACE,
        NVME_CLI_TOPO_CTRL,
@@ -109,7 +111,7 @@ static inline DEFINE_CLEANUP_FUNC(
 
 extern const char *output_format;
 
-int validate_output_format(const char *format, enum nvme_print_flags *flags);
+int validate_output_format(const char *format, nvme_print_flags_t *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 2a221f865752cc2377992249e2cee2dda16e13e7..1efdd76d25d5f3d4090626af8c9ec88797c7b445 100644 (file)
--- a/plugins/fdp/fdp.c
+++ b/plugins/fdp/fdp.c
@@ -25,7 +25,7 @@ static int fdp_configs(int argc, char **argv, struct command *cmd,
        const char *human_readable = "show log in readable format";
        const char *raw = "use binary output";
 
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        struct nvme_dev *dev;
        struct nvme_fdp_config_log hdr;
        void *log = NULL;
@@ -107,7 +107,7 @@ static int fdp_usage(int argc, char **argv, struct command *cmd, struct plugin *
        const char *egid = "Endurance group identifier";
        const char *raw = "use binary output";
 
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        struct nvme_dev *dev;
        struct nvme_fdp_ruhu_log hdr;
        size_t len;
@@ -180,7 +180,7 @@ static int fdp_stats(int argc, char **argv, struct command *cmd, struct plugin *
        const char *egid = "Endurance group identifier";
        const char *raw = "use binary output";
 
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        struct nvme_dev *dev;
        struct nvme_fdp_stats_log stats;
        int err;
@@ -238,7 +238,7 @@ static int fdp_events(int argc, char **argv, struct command *cmd, struct plugin
        const char *host_events = "Get host events";
        const char *raw = "use binary output";
 
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        struct nvme_dev *dev;
        struct nvme_fdp_events_log events;
        int err;
@@ -299,7 +299,7 @@ static int fdp_status(int argc, char **argv, struct command *cmd, struct plugin
        const char *namespace_id = "Namespace identifier";
        const char *raw = "use binary output";
 
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        struct nvme_dev *dev;
        struct nvme_fdp_ruh_status hdr;
        size_t len;

diff --git a/plugins/huawei/huawei-nvme.c b/plugins/huawei/huawei-nvme.c
index 0272dead347946a9cdea5d63f97223f8f748c01f..c09d8d3874f62b057bc08acd5284b961bb45573e 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;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        const char *desc = "Retrieve basic information for the given huawei device";
        struct config {
                char *output_format;

diff --git a/plugins/nbft/nbft-plugin.c b/plugins/nbft/nbft-plugin.c
index 21f97b10bed5096087f06d0aa1026c808908364e..f25941a5dbc077bc55d8da38b109e85509bd59ac 100644 (file)
--- a/plugins/nbft/nbft-plugin.c
+++ b/plugins/nbft/nbft-plugin.c
@@ -531,7 +531,7 @@ int show_nbft(int argc, char **argv, struct command *cmd, struct plugin *plugin)
        struct list_head nbft_list;
        char *format = "normal";
        char *nbft_path = NBFT_SYSFS_PATH;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int ret;
        bool show_subsys = false, show_hfi = false, show_discovery = false;
        unsigned int verbose = 0;

diff --git a/plugins/ocp/ocp-fw-activation-history.c b/plugins/ocp/ocp-fw-activation-history.c
index 16598a0be437beb85e8f919bd9dd0a9fc49fa823..543042f485ec773343259496aa573df984594c02 100644 (file)
--- a/plugins/ocp/ocp-fw-activation-history.c
+++ b/plugins/ocp/ocp-fw-activation-history.c
@@ -207,7 +207,7 @@ int ocp_fw_activation_history_log(int argc, char **argv, struct command *cmd,
        }
 
        if (!err) {
-               enum nvme_print_flags print_flag;
+               nvme_print_flags_t print_flag;
 
                err = validate_output_format(format, &print_flag);
                if (err < 0) {

diff --git a/plugins/ocp/ocp-nvme.c b/plugins/ocp/ocp-nvme.c
index 3a8efab7ff523e4aeac6bd73734c33f65db43642..5327518f6fba9c2156daaf65bbe9872c804ff057 100644 (file)
--- a/plugins/ocp/ocp-nvme.c
+++ b/plugins/ocp/ocp-nvme.c
@@ -397,7 +397,7 @@ 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;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        int ret;
        __u8 *data;
        int i;
@@ -1511,7 +1511,7 @@ 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)
 {
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        int ret;
        __u8 *data;
        int i;
@@ -1738,7 +1738,7 @@ 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)
 {
        struct ocp_error_recovery_log_page *log_data;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        int ret;
        __u8 *data;
        int i, j;
@@ -1954,7 +1954,7 @@ 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)
 {
        struct ocp_device_capabilities_log_page *log_data;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        int ret;
        __u8 *data;
        int i, j;
@@ -3143,7 +3143,7 @@ static int get_c9_log_page(struct nvme_dev *dev, char *format)
        int ret = 0;
        __u8 *header_data;
        struct telemetry_str_log_format *log_data;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        __u8 *full_log_buf_data = NULL;
        __le64 stat_id_str_table_ofst = 0;
        __le64 event_str_table_ofst = 0;
@@ -3435,7 +3435,7 @@ static void ocp_print_c7_log_binary(struct tcg_configuration_log *log_data)
 
 static int get_c7_log_page(struct nvme_dev *dev, char *format)
 {
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        int ret;
        __u8 *data;
        int i;

diff --git a/plugins/ocp/ocp-smart-extended-log.c b/plugins/ocp/ocp-smart-extended-log.c
index 0d8ba810693b3b484f2b541c42d3adbbe9c7d42f..6a524d3e3be3077636874b7b0c28b00b53f892e2 100644 (file)
--- a/plugins/ocp/ocp-smart-extended-log.c
+++ b/plugins/ocp/ocp-smart-extended-log.c
@@ -252,7 +252,7 @@ static void ocp_print_C0_log_json(void *data)
 
 static int get_c0_log_page(int fd, char *format)
 {
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        __u8 *data;
        int i;
        int ret;

diff --git a/plugins/solidigm/solidigm-garbage-collection.c b/plugins/solidigm/solidigm-garbage-collection.c
index 002b187fea17e3084f6d1d179aebc85c083cec2b..3c046b0ed4dd4e1bbeb90b3c70011c70082d235e 100644 (file)
--- a/plugins/solidigm/solidigm-garbage-collection.c
+++ b/plugins/solidigm/solidigm-garbage-collection.c
@@ -68,7 +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;
+       nvme_print_flags_t flags;
        struct nvme_dev *dev;
        int err;
        __u8 uuid_index;

diff --git a/plugins/solidigm/solidigm-get-drive-info.c b/plugins/solidigm/solidigm-get-drive-info.c
index 21f59bb8658da7ccd7c7c8ff1d57aa3f15adee37..c783fa8abda2326d24bdd46395aac3050863c4be 100644 (file)
--- a/plugins/solidigm/solidigm-get-drive-info.c
+++ b/plugins/solidigm/solidigm-get-drive-info.c
@@ -16,7 +16,7 @@ int sldgm_get_drive_info(int argc, char **argv, struct command *cmd, struct plug
        const char *desc = "Get drive HW information";
        const char *FTL_unit_size_str = "FTL_unit_size";
        char *output_format = "normal";
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        nvme_root_t r;
        nvme_ctrl_t c;
        nvme_ns_t n;

diff --git a/plugins/solidigm/solidigm-latency-tracking.c b/plugins/solidigm/solidigm-latency-tracking.c
index c6c33157c2d356955b66a0c4b465f4ad1ee97528..899075d7ace9c63ebdda63e7b3406ac7b8bb3de6 100644 (file)
--- a/plugins/solidigm/solidigm-latency-tracking.c
+++ b/plugins/solidigm/solidigm-latency-tracking.c
@@ -45,7 +45,7 @@ struct latency_tracker {
        int fd;
        __u8 uuid_index;
        struct config cfg;
-       enum nvme_print_flags print_flags;
+       nvme_print_flags_t print_flags;
        struct latency_statistics stats;
        struct json_object *bucket_list;
        __u32 bucket_list_size;

diff --git a/plugins/solidigm/solidigm-log-page-dir.c b/plugins/solidigm/solidigm-log-page-dir.c
index 7d7c027f3eee47efd4edd201124abc61050b5c44..f8d19743f0340c60b0050a30c29db09b7c349ed4 100644 (file)
--- a/plugins/solidigm/solidigm-log-page-dir.c
+++ b/plugins/solidigm/solidigm-log-page-dir.c
@@ -241,7 +241,7 @@ int solidigm_get_log_page_directory_log(int argc, char **argv, struct command *c
        }
 
        if (!err) {
-               enum nvme_print_flags print_flag;
+               nvme_print_flags_t print_flag;
 
                err = validate_output_format(format, &print_flag);
                if (err < 0) {

diff --git a/plugins/solidigm/solidigm-smart.c b/plugins/solidigm/solidigm-smart.c
index a97abe2bcc6e0ea09013ffa0e9aa49c4e2cedcf1..002753a54ef86b2dd6172018f14f737c639e53ba 100644 (file)
--- a/plugins/solidigm/solidigm-smart.c
+++ b/plugins/solidigm/solidigm-smart.c
@@ -197,7 +197,7 @@ int solidigm_get_additional_smart_log(int argc, char **argv, struct command *cmd
            "Get Solidigm vendor specific smart log (optionally, for the specified namespace), and show it.";
        const int solidigm_vu_smart_log_id = 0xCA;
        struct vu_smart_log smart_log_payload;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        struct nvme_dev *dev;
        int err;
        __u8 uuid_index;

diff --git a/plugins/wdc/wdc-nvme.c b/plugins/wdc/wdc-nvme.c
index 75250550450e224fa5c8ddef4b1b42560fdcdb70..89b0d73814c6adeb21a57ae7745e844344e8a062 100644 (file)
--- a/plugins/wdc/wdc-nvme.c
+++ b/plugins/wdc/wdc-nvme.c
@@ -6998,7 +6998,7 @@ static int wdc_get_c0_log_page(nvme_root_t r, struct nvme_dev *dev, char *format
                               __u32 namespace_id)
 {
        uint32_t device_id, read_vendor_id;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        int ret;
        __u8 *data;
        __u8 log_id;
@@ -7296,7 +7296,7 @@ static int wdc_get_ca_log_page(nvme_root_t r, struct nvme_dev *dev, char *format
 {
        uint32_t read_device_id, read_vendor_id;
        struct wdc_ssd_ca_perf_stats *perf;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        __u32 cust_id;
        __u8 *data;
        int ret;
@@ -7427,7 +7427,7 @@ static int wdc_get_c1_log_page(nvme_root_t r, struct nvme_dev *dev,
        struct wdc_log_page_subpage_header *sph;
        struct wdc_ssd_perf_stats *perf;
        struct wdc_log_page_header *l;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        int total_subpages;
        int skip_cnt = 4;
        __u8 *data;
@@ -7484,7 +7484,7 @@ 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)
 {
        struct wdc_ssd_latency_monitor_log *log_data;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        __u8 *data;
        int ret;
        int i;
@@ -7556,7 +7556,7 @@ out:
 static int wdc_get_ocp_c1_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
 {
        struct wdc_ocp_c1_error_recovery_log *log_data;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        __u8 *data;
        int ret;
        int i;
@@ -7627,7 +7627,7 @@ out:
 static int wdc_get_ocp_c4_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
 {
        struct wdc_ocp_C4_dev_cap_log *log_data;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        __u8 *data;
        int ret;
        int i;
@@ -7697,7 +7697,7 @@ out:
 static int wdc_get_ocp_c5_log_page(nvme_root_t r, struct nvme_dev *dev, char *format)
 {
        struct wdc_ocp_C5_unsupported_reqs *log_data;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        int ret;
        __u8 *data;
        int i;
@@ -7767,7 +7767,7 @@ 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;
+       nvme_print_flags_t fmt;
        int ret = 0;
        __u8 *data;
 
@@ -8049,7 +8049,7 @@ 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;
+       nvme_print_flags_t fmt;
        struct nvme_dev *dev;
        nvme_root_t r;
        int ret = 0;
@@ -8219,7 +8219,7 @@ 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;
+       nvme_print_flags_t fmt;
        __u64 capabilities = 0;
        struct nvme_dev *dev;
        nvme_root_t r;
@@ -8290,7 +8290,7 @@ 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;
+       nvme_print_flags_t fmt;
        __u64 capabilities = 0;
        struct nvme_dev *dev;
        int ret;
@@ -8375,7 +8375,7 @@ 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;
+       nvme_print_flags_t fmt;
        struct nvme_dev *dev;
        __u8 *data;
        nvme_root_t r;
@@ -8932,7 +8932,7 @@ static int wdc_get_fw_act_history(nvme_root_t r, struct nvme_dev *dev,
                                  char *format)
 {
        struct wdc_fw_act_history_log_hdr *fw_act_history_hdr;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        int ret;
        __u8 *data;
 
@@ -9016,7 +9016,7 @@ static int wdc_get_fw_act_history_C2(nvme_root_t r, struct nvme_dev *dev,
        __u32 tot_entries = 0, num_entries = 0;
        __u32 vendor_id = 0, device_id = 0;
        __u32 cust_id = 0;
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        __u8 *data;
        int ret;
        bool c2GuidMatch = false;
@@ -10498,7 +10498,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;
+       nvme_print_flags_t fmt;
        struct nvme_dev *dev;
        int ret = 0;
        nvme_root_t r;
@@ -11158,7 +11158,7 @@ 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)
 {
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        uint8_t *data = NULL;
        int ret;
 
@@ -11197,7 +11197,7 @@ out:
 
 static int wdc_do_vs_nand_stats(struct nvme_dev *dev, char *format)
 {
-       enum nvme_print_flags fmt;
+       nvme_print_flags_t fmt;
        uint8_t *output = NULL;
        __u16 version = 0;
        int ret;
@@ -11321,7 +11321,7 @@ 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;
+       nvme_print_flags_t fmt;
        struct nvme_dev *dev;
        nvme_root_t r;
        int ret;
@@ -11396,7 +11396,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_print_flags_t fmt;
        nvme_root_t r;
        uint64_t capabilities = 0;
        struct nvme_dev *dev;
@@ -11663,7 +11663,7 @@ 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;
+       nvme_print_flags_t fmt;
        struct nvme_dev *dev;
        nvme_root_t r;
        uint64_t capabilities = 0;

diff --git a/plugins/zns/zns.c b/plugins/zns/zns.c
index a7a37663b5f112c561b544c93976136d1bdbf0d1..94336d781b6ae47d68666e57d0d02d1b23cc7cbc 100644 (file)
--- a/plugins/zns/zns.c
+++ b/plugins/zns/zns.c
@@ -114,7 +114,7 @@ static int id_ctrl(int argc, char **argv, struct command *cmd, struct plugin *pl
                           "the given device and report information about the specified\n"
                           "controller in various formats.";
 
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        struct nvme_zns_id_ctrl ctrl;
        struct nvme_dev *dev;
        int err = -1;
@@ -160,7 +160,7 @@ static int id_ns(int argc, char **argv, struct command *cmd, struct plugin *plug
        const char *vendor_specific = "dump binary vendor fields";
        const char *human_readable = "show identify in readable format";
 
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        struct nvme_zns_id_ns ns;
        struct nvme_id_ns id_ns;
        struct nvme_dev *dev;
@@ -732,7 +732,7 @@ static int zone_mgmt_recv(int argc, char **argv, struct command *cmd, struct plu
        const char *partial = "Zone Receive Action Specific Features(Partial Report)";
        const char *data_len = "length of data in bytes";
 
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        struct nvme_dev *dev;
        void *data = NULL;
        int err = -1;
@@ -830,7 +830,7 @@ static int report_zones(int argc, char **argv, struct command *cmd, struct plugi
        const char *part = "set to use the partial report";
        const char *verbose = "show report zones verbosity";
 
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        int zdes = 0, err = -1;
        struct nvme_dev *dev;
        __u32 report_size;
@@ -1222,7 +1222,7 @@ static int changed_zone_list(int argc, char **argv, struct command *cmd, struct
        const char *rae = "retain an asynchronous event";
 
        struct nvme_zns_changed_zone_log log;
-       enum nvme_print_flags flags;
+       nvme_print_flags_t flags;
        struct nvme_dev *dev;
        int err = -1;