#include "nbft.h"
#include "libnvme.h"
#include "nvme-print.h"
-#include "nvme-print-json.h"
#include "fabrics.h"
#define PATH_NVMF_DISC SYSCONFDIR "/nvme/discovery.conf"
#include <assert.h>
#include <errno.h>
-#include "nvme-print-json.h"
+#include "nvme-print.h"
#include "util/json.h"
#include "nvme.h"
#define ERROR_MSG_LEN 100
static const uint8_t zero_uuid[16] = { 0 };
+static struct print_ops json_print_ops;
-void json_nvme_id_ns(struct nvme_id_ns *ns, bool cap_only)
+static void json_nvme_id_ns(struct nvme_id_ns *ns, unsigned int nsid,
+ unsigned int lba_index, bool cap_only)
{
char nguid_buf[2 * sizeof(ns->nguid) + 1],
eui64_buf[2 * sizeof(ns->eui64) + 1];
json_free_object(root);
}
-void json_error_log(struct nvme_error_log_page *err_log, int entries)
+static void json_error_log(struct nvme_error_log_page *err_log, int entries,
+ const char *devname)
{
struct json_object *root;
struct json_object *errors;
json_free_object(root);
}
-void json_endurance_log(struct nvme_endurance_group_log *endurance_group,
- __u16 group_id)
+static void json_endurance_log(struct nvme_endurance_group_log *endurance_group,
+ __u16 group_id, const char *devname)
{
struct json_object *root;
json_free_object(root);
}
-void json_smart_log(struct nvme_smart_log *smart, unsigned int nsid,
- enum nvme_print_flags flags)
+static void json_smart_log(struct nvme_smart_log *smart, unsigned int nsid,
+ const char *devname)
{
- int c, human = flags & VERBOSE;
+ int c, human = json_print_ops.flags & VERBOSE;
struct json_object *root;
char key[21];
json_free_object(root);
}
-void json_ana_log(struct nvme_ana_log *ana_log, const char *devname)
+static void json_ana_log(struct nvme_ana_log *ana_log, const char *devname,
+ size_t len)
{
int offset = sizeof(struct nvme_ana_log);
struct nvme_ana_log *hdr = ana_log;
json_free_object(root);
}
-void json_self_test_log(struct nvme_self_test_log *self_test, __u8 dst_entries)
+static void json_self_test_log(struct nvme_self_test_log *self_test, __u8 dst_entries,
+ __u32 size, const char *devname)
{
struct json_object *valid_attrs;
struct json_object *root;
return root;
}
-void json_effects_log_list(struct list_head *list)
+static void json_effects_log_list(struct list_head *list)
{
struct json_object *json_list;
nvme_effects_log_node_t *node;
json_free_object(json_list);
}
-void json_sanitize_log(struct nvme_sanitize_log_page *sanitize_log,
+static void json_sanitize_log(struct nvme_sanitize_log_page *sanitize_log,
const char *devname)
{
struct json_object *root;
json_free_object(root);
}
-void json_predictable_latency_per_nvmset(
- struct nvme_nvmset_predictable_lat_log *plpns_log,
- __u16 nvmset_id)
+static void json_predictable_latency_per_nvmset(
+ struct nvme_nvmset_predictable_lat_log *plpns_log,
+ __u16 nvmset_id, const char *devname)
{
struct json_object *root;
json_free_object(root);
}
-void json_predictable_latency_event_agg_log(
- struct nvme_aggregate_predictable_lat_event *pea_log,
- __u64 log_entries)
+static void json_predictable_latency_event_agg_log(
+ struct nvme_aggregate_predictable_lat_event *pea_log,
+ __u64 log_entries, __u32 size, const char *devname)
{
struct json_object *root;
struct json_object *valid_attrs;
}
}
-void json_persistent_event_log(void *pevent_log_info, __u32 size)
+
+static void json_persistent_event_log(void *pevent_log_info, __u8 action,
+ __u32 size, const char *devname)
+
{
struct json_object *root;
struct json_object *valid_attrs;
json_free_object(root);
}
-void json_endurance_group_event_agg_log(
- struct nvme_aggregate_predictable_lat_event *endurance_log,
- __u64 log_entries)
+
+static void json_endurance_group_event_agg_log(
+ struct nvme_aggregate_predictable_lat_event *endurance_log,
+ __u64 log_entries, __u32 size, const char *devname)
{
struct json_object *root;
struct json_object *valid_attrs;
json_free_object(root);
}
-void json_lba_status_log(void *lba_status)
+
+static void json_lba_status_log(void *lba_status, __u32 size,
+ const char *devname)
{
struct json_object *root;
struct json_object *desc;
json_free_object(root);
}
-void json_resv_notif_log(struct nvme_resv_notification_log *resv)
+
+static void json_resv_notif_log(struct nvme_resv_notification_log *resv,
+ const char *devname)
{
struct json_object *root;
json_free_object(root);
}
-void json_fid_support_effects_log(struct nvme_fid_supported_effects_log *fid_log)
+
+static void json_fid_support_effects_log(
+ struct nvme_fid_supported_effects_log *fid_log,
+ const char *devname)
{
struct json_object *root;
struct json_object *fids;
json_free_object(root);
}
-void json_mi_cmd_support_effects_log(struct nvme_mi_cmd_supported_effects_log *mi_cmd_log)
+
+static void json_mi_cmd_support_effects_log(
+ struct nvme_mi_cmd_supported_effects_log *mi_cmd_log,
+ const char *devname)
{
struct json_object *root;
struct json_object *mi_cmds;
json_free_object(root);
}
-void json_boot_part_log(void *bp_log)
+
+static void json_boot_part_log(void *bp_log, const char *devname,
+ __u32 size)
{
struct nvme_boot_partition *hdr;
struct json_object *root;
json_free_object(root);
}
-void json_media_unit_stat_log(struct nvme_media_unit_stat_log *mus)
+static void json_media_unit_stat_log(struct nvme_media_unit_stat_log *mus)
{
+
struct json_object *root;
struct json_object *entries;
struct json_object *entry;
json_free_object(root);
}
-void json_supported_cap_config_log(
- struct nvme_supported_cap_config_list_log *cap_log)
+
+static void json_supported_cap_config_log(
+ struct nvme_supported_cap_config_list_log *cap_log)
{
struct json_object *root;
struct json_object *cap_list;
json_free_object(root);
}
-void json_nvme_fdp_configs(struct nvme_fdp_config_log *log, size_t len)
+
+static void json_nvme_fdp_configs(struct nvme_fdp_config_log *log, size_t len)
{
struct json_object *root, *obj_configs;
uint16_t n;
json_free_object(root);
}
-void json_nvme_fdp_usage(struct nvme_fdp_ruhu_log *log, size_t len)
+
+static void json_nvme_fdp_usage(struct nvme_fdp_ruhu_log *log, size_t len)
{
struct json_object *root, *obj_ruhus;
uint16_t nruh;
json_free_object(root);
}
-void json_nvme_fdp_stats(struct nvme_fdp_stats_log *log)
+
+static void json_nvme_fdp_stats(struct nvme_fdp_stats_log *log)
{
struct json_object *root = json_create_object();
json_free_object(root);
}
-void json_nvme_fdp_events(struct nvme_fdp_events_log *log)
+
+static void json_nvme_fdp_events(struct nvme_fdp_events_log *log)
{
struct json_object *root, *obj_events;
uint32_t n;
json_free_object(root);
}
-void json_nvme_fdp_ruh_status(struct nvme_fdp_ruh_status *status, size_t len)
+static void json_nvme_fdp_ruh_status(struct nvme_fdp_ruh_status *status, size_t len)
{
struct json_object *root, *obj_ruhss;
uint16_t nruhsd;
}
}
-void json_print_nvme_subsystem_list(nvme_root_t r, bool show_ana)
+static void json_print_nvme_subsystem_list(nvme_root_t r, bool show_ana)
+
{
struct json_object *host_attrs, *subsystem_attrs;
struct json_object *subsystems, *paths;
json_free_object(root);
}
-void json_ctrl_registers(void *bar)
+static void json_ctrl_registers(void *bar, bool fabrics)
{
uint64_t cap, asq, acq, bpmbl, cmbmsc;
uint32_t vs, intms, intmc, cc, csts, nssr, crto, aqa, cmbsz, cmbloc,
}
}
-void json_nvme_cmd_set_independent_id_ns(
- struct nvme_id_independent_id_ns *ns)
+static void json_nvme_cmd_set_independent_id_ns(
+ struct nvme_id_independent_id_ns *ns,
+ unsigned int nsid)
{
struct json_object *root;
root = json_create_object();
json_free_object(root);
}
-void json_nvme_id_ns_descs(void *data)
+static void json_nvme_id_ns_descs(void *data, unsigned int nsid)
{
/* large enough to hold uuid str (37) or nguid str (32) + zero byte */
char json_str[40];
json_free_object(root);
}
-void json_nvme_id_ctrl_nvm(struct nvme_id_ctrl_nvm *ctrl_nvm)
+static void json_nvme_id_ctrl_nvm(struct nvme_id_ctrl_nvm *ctrl_nvm)
{
struct json_object *root;
json_free_object(root);
}
-void json_nvme_nvm_id_ns(struct nvme_nvm_id_ns *nvm_ns,
- struct nvme_id_ns *ns, bool cap_only)
+static void json_nvme_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)
+
{
struct json_object *root;
struct json_object *elbafs;
json_free_object(root);
}
-void json_nvme_zns_id_ctrl(struct nvme_zns_id_ctrl *ctrl)
+static void json_nvme_zns_id_ctrl(struct nvme_zns_id_ctrl *ctrl)
{
struct json_object *root;
json_free_object(root);
}
-void json_nvme_zns_id_ns(struct nvme_zns_id_ns *ns,
- struct nvme_id_ns *id_ns)
+static void json_nvme_zns_id_ns(struct nvme_zns_id_ns *ns,
+ struct nvme_id_ns *id_ns)
{
struct json_object *root;
struct json_object *lbafs;
json_free_object(root);
}
-void json_nvme_list_ns(struct nvme_ns_list *ns_list)
+static void json_nvme_list_ns(struct nvme_ns_list *ns_list)
{
struct json_object *root;
struct json_object *valid_attrs;
json_free_object(root);
}
-void json_nvme_finish_zone_list(__u64 nr_zones,
- struct json_object *zone_list)
+static void json_zns_finish_zone_list(__u64 nr_zones,
+ struct json_object *zone_list)
{
struct json_object *root = json_create_object();
json_object_add_value_uint(root, "nr_zones", nr_zones);
json_free_object(root);
}
-void json_nvme_zns_report_zones(void *report, __u32 descs,
- __u8 ext_size, __u32 report_size,
- struct json_object *zone_list)
+static void json_nvme_zns_report_zones(void *report, __u32 descs,
+ __u8 ext_size, __u32 report_size,
+ struct json_object *zone_list)
{
struct json_object *zone;
struct json_object *ext_data;
}
}
-void json_nvme_list_ctrl(struct nvme_ctrl_list *ctrl_list, __u16 num)
+static void json_nvme_list_ctrl(struct nvme_ctrl_list *ctrl_list, __u16 num)
{
struct json_object *root;
struct json_object *valid_attrs;
json_free_object(root);
}
-void json_nvme_id_nvmset(struct nvme_id_nvmset_list *nvmset)
+static void json_nvme_id_nvmset(struct nvme_id_nvmset_list *nvmset,
+ unsigned int nvmeset_id)
{
__u32 nent = nvmset->nid;
struct json_object *entries;
json_free_object(root);
}
-void json_nvme_primary_ctrl_cap(const struct nvme_primary_ctrl_cap *caps)
+static void json_nvme_primary_ctrl_cap(const struct nvme_primary_ctrl_cap *caps)
{
struct json_object *root;
json_free_object(root);
}
-void json_nvme_list_secondary_ctrl(const struct nvme_secondary_ctrl_list *sc_list,
+static void json_nvme_list_secondary_ctrl(const struct nvme_secondary_ctrl_list *sc_list,
__u32 count)
{
const struct nvme_secondary_ctrl *sc_entry = &sc_list->sc_entry[0];
json_free_object(root);
}
-void json_nvme_id_ns_granularity_list(
- const struct nvme_id_ns_granularity_list *glist)
+static void json_nvme_id_ns_granularity_list(
+ const struct nvme_id_ns_granularity_list *glist)
{
int i;
struct json_object *root;
json_free_object(root);
}
-void json_nvme_id_uuid_list(const struct nvme_id_uuid_list *uuid_list)
+static void json_nvme_id_uuid_list(const struct nvme_id_uuid_list *uuid_list)
{
struct json_object *root;
struct json_object *entries;
json_free_object(root);
}
-void json_id_domain_list(struct nvme_id_domain_list *id_dom)
+static void json_id_domain_list(struct nvme_id_domain_list *id_dom)
{
struct json_object *root;
struct json_object *entries;
json_free_object(root);
}
-void json_nvme_endurance_group_list(struct nvme_id_endurance_group_list *endgrp_list)
+static void json_nvme_endurance_group_list(struct nvme_id_endurance_group_list *endgrp_list)
{
struct json_object *root;
struct json_object *valid_attrs;
json_free_object(root);
}
-void json_support_log(struct nvme_supported_log_pages *support_log)
+static void json_support_log(struct nvme_supported_log_pages *support_log,
+ const char *devname)
{
struct json_object *root;
struct json_object *valid;
json_free_object(jroot);
}
-void json_print_list_items(nvme_root_t r,
- enum nvme_print_flags flags)
+static void json_print_list_items(nvme_root_t r)
{
- if (flags & VERBOSE)
+ if (json_print_ops.flags & VERBOSE)
json_detail_list(r);
else
json_simple_list(r);
return i;
}
-void json_print_nvme_subsystem_topology(nvme_subsystem_t s,
- json_object *namespaces)
+static void json_print_nvme_subsystem_topology(nvme_subsystem_t s,
+ json_object *namespaces)
{
nvme_ctrl_t c;
nvme_ns_t n;
}
}
-void json_simple_topology(nvme_root_t r)
+static void json_simple_topology(nvme_root_t r)
{
struct json_object *host_attrs, *subsystem_attrs;
struct json_object *subsystems, *namespaces;
json_free_object(root);
}
-void json_discovery_log(struct nvmf_discovery_log *log, int numrec,
- enum nvme_print_flags flags)
+static void json_discovery_log(struct nvmf_discovery_log *log, int numrec)
{
struct json_object *root;
struct json_object *entries;
json_free_object(root);
}
-void json_connect_msg(nvme_ctrl_t c, enum nvme_print_flags flags)
+static void json_connect_msg(nvme_ctrl_t c)
{
struct json_object *root;
json_free_object(root);
}
-void json_output_status(int status)
+static void json_output_status(int status)
{
struct json_object *root = json_create_object();
int val;
json_output_object(root);
}
-void json_output_message(bool error, const char *msg, va_list ap)
+static void json_output_message(bool error, const char *msg, va_list ap)
{
struct json_object *root = json_create_object();
char *value;
free(value);
}
-void json_output_perror(const char *msg)
+static void json_output_perror(const char *msg)
{
struct json_object *root = json_create_object();
char *error;
free(error);
}
+
+static struct print_ops json_print_ops = {
+ .ana_log = json_ana_log,
+ .boot_part_log = json_boot_part_log,
+ .ctrl_list = json_nvme_list_ctrl,
+ .ctrl_registers = json_ctrl_registers,
+ .discovery_log = json_discovery_log,
+ .effects_log_list = json_effects_log_list,
+ .endurance_group_event_agg_log = json_endurance_group_event_agg_log,
+ .endurance_group_list = json_nvme_endurance_group_list,
+ .endurance_log = json_endurance_log,
+ .error_log = json_error_log,
+ .fdp_config_log = json_nvme_fdp_configs,
+ .fdp_event_log = json_nvme_fdp_events,
+ .fdp_ruh_status = json_nvme_fdp_ruh_status,
+ .fdp_stats_log = json_nvme_fdp_stats,
+ .fdp_usage_log = json_nvme_fdp_usage,
+ .fid_supported_effects_log = json_fid_support_effects_log,
+ .fw_log = json_fw_log,
+ .id_ctrl = json_nvme_id_ctrl,
+ .ns_list = json_nvme_list_ns,
+ .nvm_id_ns = json_nvme_nvm_id_ns,
+ .id_ctrl_nvm = json_nvme_id_ctrl_nvm,
+ .id_domain_list = json_id_domain_list,
+ .id_independent_id_ns = json_nvme_cmd_set_independent_id_ns,
+ .id_ns = json_nvme_id_ns,
+ .id_ns_descs = json_nvme_id_ns_descs,
+ .id_ns_granularity_list = json_nvme_id_ns_granularity_list,
+ .id_nvmset_list = json_nvme_id_nvmset,
+ .id_uuid_list = json_nvme_id_uuid_list,
+ .lba_status_log = json_lba_status_log,
+ .media_unit_stat_log = json_media_unit_stat_log,
+ .mi_cmd_support_effects_log = json_mi_cmd_support_effects_log,
+ .ns_list_log = json_changed_ns_list_log,
+ .persistent_event_log = json_persistent_event_log,
+ .predictable_latency_event_agg_log = json_predictable_latency_event_agg_log,
+ .predictable_latency_per_nvmset = json_predictable_latency_per_nvmset,
+ .primary_ctrl_cap = json_nvme_primary_ctrl_cap,
+ .resv_notification_log = json_resv_notif_log,
+ .resv_report = json_nvme_resv_report,
+ .sanitize_log_page = json_sanitize_log,
+ .secondary_ctrl_list = json_nvme_list_secondary_ctrl,
+ .self_test_log = json_self_test_log,
+ .smart_log = json_smart_log,
+ .supported_cap_config_list_log = json_supported_cap_config_log,
+ .supported_log_pages = json_support_log,
+ .zns_changed_zone_log = NULL,
+ .zns_report_zones = json_nvme_zns_report_zones,
+ .zns_finish_zone_list = json_zns_finish_zone_list,
+ .zns_id_ctrl = json_nvme_zns_id_ctrl,
+ .zns_id_ns = json_nvme_zns_id_ns,
+
+ .list_items = json_print_list_items,
+ .print_nvme_subsystem_list = json_print_nvme_subsystem_list,
+ .topology_ctrl = json_simple_topology,
+ .topology_namespace = json_simple_topology,
+
+ .connect_msg = json_connect_msg,
+ .show_message = json_output_message,
+ .show_perror = json_output_perror,
+ .show_status = json_output_status,
+};
+
+struct print_ops *nvme_get_json_print_ops(enum nvme_print_flags flags)
+{
+ json_print_ops.flags = flags;
+ return &json_print_ops;
+}
+++ /dev/null
-#ifndef NVME_PRINT_JSON_H_
-#define NVME_PRINT_JSON_H_
-
-#include "nvme-print.h"
-
-#ifdef CONFIG_JSONC
-
-#define json_output_error(msg, ap) json_output_message(true, msg, ap)
-#define json_output_result(msg, ap) json_output_message(false, msg, ap)
-
-void json_simple_topology(nvme_root_t r);
-void json_print_list_items(nvme_root_t r,
- enum nvme_print_flags flags);
-void json_sanitize_log(struct nvme_sanitize_log_page *sanitize_log,
- const char *devname);
-
-void json_self_test_log(struct nvme_self_test_log *self_test, __u8 dst_entries);
-void json_ana_log(struct nvme_ana_log *ana_log, const char *devname);
-void json_smart_log(struct nvme_smart_log *smart, unsigned int nsid,
- enum nvme_print_flags flags);
-void json_support_log(struct nvme_supported_log_pages *support_log);
-void json_endurance_log(struct nvme_endurance_group_log *endurance_group,
- __u16 group_id);
-void json_effects_log_list(struct list_head *list);
-void json_changed_ns_list_log(struct nvme_ns_list *log,
- const char *devname);
-void json_fw_log(struct nvme_firmware_slot *fw_log, const char *devname);
-void json_error_log(struct nvme_error_log_page *err_log, int entries);
-void json_nvme_resv_report(struct nvme_resv_status *status,
- int bytes, bool eds);
-void json_nvme_endurance_group_list(struct nvme_id_endurance_group_list *endgrp_list);
-void json_id_domain_list(struct nvme_id_domain_list *id_dom);
-void json_nvme_id_uuid_list(const struct nvme_id_uuid_list *uuid_list);
-void json_nvme_id_ns_granularity_list(
- const struct nvme_id_ns_granularity_list *glist);
-void json_nvme_list_secondary_ctrl(const struct nvme_secondary_ctrl_list *sc_list,
- __u32 count);
-void json_nvme_primary_ctrl_cap(const struct nvme_primary_ctrl_cap *caps);
-void json_nvme_id_nvmset(struct nvme_id_nvmset_list *nvmset);
-void json_nvme_list_ctrl(struct nvme_ctrl_list *ctrl_list, __u16 num);
-void json_nvme_zns_report_zones(void *report, __u32 descs,
- __u8 ext_size, __u32 report_size,
- struct json_object *zone_list);
-void json_nvme_list_ctrl(struct nvme_ctrl_list *ctrl_list, __u16 num);
-void json_nvme_list_ns(struct nvme_ns_list *ns_list);
-void json_nvme_zns_id_ns(struct nvme_zns_id_ns *ns,
- struct nvme_id_ns *id_ns);
-void json_nvme_zns_id_ctrl(struct nvme_zns_id_ctrl *ctrl);
-void json_nvme_nvm_id_ns(struct nvme_nvm_id_ns *nvm_ns,
- struct nvme_id_ns *ns, bool cap_only);
-void json_nvme_id_ctrl_nvm(struct nvme_id_ctrl_nvm *ctrl_nvm);
-void json_nvme_id_ctrl(struct nvme_id_ctrl *ctrl,
- void (*vs)(__u8 *vs, struct json_object *root));
-void json_nvme_id_ns_descs(void *data);
-void json_nvme_cmd_set_independent_id_ns(
- struct nvme_id_independent_id_ns *ns);
-void json_ctrl_registers(void *bar);
-void json_nvme_id_ns(struct nvme_id_ns *ns, bool cap_only);
-void json_print_nvme_subsystem_list(nvme_root_t r, bool show_ana);
-void json_supported_cap_config_log(
- struct nvme_supported_cap_config_list_log *cap_log);
-void json_nvme_fdp_ruh_status(struct nvme_fdp_ruh_status *status, size_t len);
-void json_nvme_fdp_events(struct nvme_fdp_events_log *log);
-void json_nvme_fdp_stats(struct nvme_fdp_stats_log *log);
-void json_nvme_fdp_usage(struct nvme_fdp_ruhu_log *log, size_t len);
-void json_nvme_fdp_configs(struct nvme_fdp_config_log *log, size_t len);
-void json_media_unit_stat_log(struct nvme_media_unit_stat_log *mus);
-void json_boot_part_log(void *bp_log);
-void json_mi_cmd_support_effects_log(struct nvme_mi_cmd_supported_effects_log *mi_cmd_log);
-void json_fid_support_effects_log(struct nvme_fid_supported_effects_log *fid_log);
-void json_resv_notif_log(struct nvme_resv_notification_log *resv);
-void json_endurance_group_event_agg_log(
- struct nvme_aggregate_predictable_lat_event *endurance_log,
- __u64 log_entries);
-void json_lba_status_log(void *lba_status);
-void json_persistent_event_log(void *pevent_log_info, __u32 size);
-void json_predictable_latency_event_agg_log(
- struct nvme_aggregate_predictable_lat_event *pea_log,
- __u64 log_entries);
-void json_predictable_latency_per_nvmset(
- struct nvme_nvmset_predictable_lat_log *plpns_log,
- __u16 nvmset_id);
-void json_output_status(int status);
-void json_output_message(bool error, const char *msg, va_list ap);
-void json_output_perror(const char *msg);
-
-/* fabrics.c */
-void json_discovery_log(struct nvmf_discovery_log *log, int numrec,
- enum nvme_print_flags flags);
-void json_connect_msg(nvme_ctrl_t c, enum nvme_print_flags flags);
-
-#else /* !CONFIG_JSONC */
-
-#define json_simple_topology(r)
-#define json_print_list_items(r, flags)
-#define json_sanitize_log(sanitize_log, devname)
-#define json_self_test_log(self_test, dst_entries)
-#define json_ana_log(ana_log, devname)
-#define json_smart_log(smart, nsid, flags)
-#define json_support_log(support_log)
-#define json_endurance_log(endurance_group, group_id)
-#define json_effects_log_list(list)
-#define json_changed_ns_list_log(log, devname)
-#define json_fw_log(fw_log, devname)
-#define json_error_log(err_log, entries)
-#define json_nvme_resv_report(status, bytes, eds)
-#define json_nvme_endurance_group_list(endgrp_list)
-#define json_id_domain_list(id_dom)
-#define json_nvme_id_uuid_list(uuid_list)
-#define json_nvme_id_ns_granularity_list(glist)
-#define json_nvme_list_secondary_ctrl(sc_list, count)
-#define json_nvme_primary_ctrl_cap(caps)
-#define json_nvme_id_nvmset(nvmset)
-#define json_nvme_list_ctrl(ctrl_list, num)
-#define json_nvme_zns_report_zones(report, descs, ext_size, report_size, zone_list)
-#define json_nvme_list_ctrl(ctrl_list, num)
-#define json_nvme_list_ns(ns_list)
-#define json_nvme_zns_id_ns(ns, id_ns)
-#define json_nvme_zns_id_ctrl(ctrl)
-#define json_nvme_nvm_id_ns(nvm_ns, ns, cap_only)
-#define json_nvme_id_ctrl_nvm(ctrl_nvm)
-#define json_nvme_id_ctrl(ctrl, vs)
-#define json_nvme_id_ns_descs(data)
-#define json_nvme_cmd_set_independent_id_ns(ns)
-#define json_ctrl_registers(bar)
-#define json_nvme_id_ns(ns, cap_only)
-#define json_print_nvme_subsystem_list(r, show_ana)
-#define json_supported_cap_config_log(cap_log)
-#define json_nvme_fdp_ruh_status(status, len)
-#define json_nvme_fdp_events(log)
-#define json_nvme_fdp_stats(log)
-#define json_nvme_fdp_usage(log, len)
-#define json_nvme_fdp_configs(log, len)
-#define json_media_unit_stat_log(mus)
-#define json_boot_part_log(bp_log)
-#define json_mi_cmd_support_effects_log(mi_cmd_log)
-#define json_fid_support_effects_log(fid_log)
-#define json_resv_notif_log(resv)
-#define json_endurance_group_event_agg_log(endurance_log, log_entries)
-#define json_lba_status_log(lba_status)
-#define json_persistent_event_log(pevent_log_info, size)
-#define json_predictable_latency_event_agg_log(pea_log, log_entries)
-#define json_predictable_latency_per_nvmset(plpns_log, nvmset_id)
-#define json_output_error(msg, ap)
-#define json_output_result(msg, ap)
-#define json_output_status(status)
-#define json_output_message(error, msg, ap)
-#define json_output_perror(msg)
-
-/* fabrics.c */
-#define json_discovery_log(log, numrec, flags)
-#define json_connect_msg(c, flags)
-
-#endif /* !CONFIG_JSONC */
-
-#endif // NVME_PRINT_JSON_H_
#include "nvme.h"
#include "libnvme.h"
#include "nvme-print.h"
-#include "nvme-print-json.h"
#include "nvme-models.h"
#include "util/suffix.h"
#include "util/types.h"
{
struct print_ops *ops = NULL;
+ if (flags & JSON)
+ ops = nvme_get_json_print_ops(flags);
+
return ops;
}
if (flags & BINARY)
return d_raw((unsigned char *)plpns_log,
sizeof(*plpns_log));
- if (flags & JSON)
- return json_predictable_latency_per_nvmset(plpns_log,
- nvmset_id);
printf("Predictable Latency Per NVM Set Log for device: %s\n",
devname);
if (flags & BINARY)
return d_raw((unsigned char *)pea_log, size);
- if (flags & JSON)
- return json_predictable_latency_event_agg_log(pea_log,
- log_entries);
num_entries = le64_to_cpu(pea_log->num_entries);
printf("Predictable Latency Event Aggregate Log for"\
if (flags & BINARY)
return d_raw((unsigned char *)pevent_log_info, size);
- if (flags & JSON)
- return json_persistent_event_log(pevent_log_info, size);
offset = sizeof(*pevent_log_head);
if (flags & BINARY)
return d_raw((unsigned char *)endurance_log, size);
- if (flags & JSON)
- return json_endurance_group_event_agg_log(endurance_log,
- log_entries);
printf("Endurance Group Event Aggregate Log for"\
" device: %s\n", devname);
if (flags & BINARY)
return d_raw((unsigned char *)lba_status, size);
- if (flags & JSON)
- return json_lba_status_log(lba_status);
hdr = lba_status;
printf("LBA Status Log for device: %s\n", devname);
if (flags & BINARY)
return d_raw((unsigned char *)resv, sizeof(*resv));
- if (flags & JSON)
- return json_resv_notif_log(resv);
printf("Reservation Notif Log for device: %s\n", devname);
printf("Log Page Count : %"PRIx64"\n",
if (flags & BINARY)
return d_raw((unsigned char *)fid_log, sizeof(*fid_log));
- if (flags & JSON)
- return json_fid_support_effects_log(fid_log);
printf("FID Supports Effects Log for device: %s\n", devname);
printf("Admin Command Set\n");
if (flags & BINARY)
return d_raw((unsigned char *)mi_cmd_log, sizeof(*mi_cmd_log));
- if (flags & JSON)
- return json_mi_cmd_support_effects_log(mi_cmd_log);
printf("MI Commands Support Effects Log for device: %s\n", devname);
printf("Admin Command Set\n");
if (flags & BINARY)
return d_raw((unsigned char *)bp_log, size);
- if (flags & JSON)
- return json_boot_part_log(bp_log);
hdr = bp_log;
printf("Boot Partition Log for device: %s\n", devname);
if (flags & BINARY)
return d_raw((unsigned char *)mus_log, sizeof(*mus_log));
- else if (flags & JSON)
- return json_media_unit_stat_log(mus_log);
printf("Number of Media Unit Status Descriptors: %u\n", nmu);
printf("Number of Channels: %u\n", le16_to_cpu(mus_log->cchans));
if (flags & BINARY)
return d_raw((unsigned char *)log, len);
- if (flags & JSON)
- return json_nvme_fdp_configs(log, len);
n = le16_to_cpu(log->n) + 1;
if (flags & BINARY)
return d_raw((unsigned char *)log, len);
- if (flags & JSON)
- return json_nvme_fdp_usage(log, len);
uint16_t nruh = le16_to_cpu(log->nruh);
if (flags & BINARY)
return d_raw((unsigned char*)log, sizeof(*log));
- if (flags & JSON)
- return json_nvme_fdp_stats(log);
printf("Host Bytes with Metadata Written (HBMW): %s\n",
uint128_t_to_l10n_string(le128_to_cpu(log->hbmw)));
if (flags & BINARY)
return d_raw((unsigned char*)log, sizeof(*log));
- if (flags & JSON)
- return json_nvme_fdp_events(log);
uint32_t n = le32_to_cpu(log->n);
if (flags & BINARY)
return d_raw((unsigned char *)status, len);
- if (flags & JSON)
- return json_nvme_fdp_ruh_status(status, len);
uint16_t nruhsd = le16_to_cpu(status->nruhsd);
if (flags & BINARY)
return d_raw((unsigned char *)cap, sizeof(*cap));
- else if (flags & JSON)
- return json_supported_cap_config_log(cap);
sccn = cap->sccn;
printf("Number of Supported Capacity Configurations: %u\n", sccn);
{
nvme_print(print_nvme_subsystem_list, flags, r, show_ana);
- if (flags & JSON)
- return json_print_nvme_subsystem_list(r, show_ana);
nvme_show_subsystem(r, show_ana);
}
if (flags & BINARY)
return d_raw((unsigned char *)bar, reg_size);
- if (flags & JSON)
- return json_ctrl_registers(bar);
cap = mmio_read64(bar + NVME_REG_CAP);
vs = mmio_read32(bar + NVME_REG_VS);
return;
}
- if (argconfig_output_format_json(false))
- return json_output_status(status);
-
/*
* Callers should be checking for negative values first, but provide a
* sensible fallback anyway
if (flags & BINARY)
return d_raw((unsigned char *)ns, sizeof(*ns));
- if (flags & JSON)
- return json_nvme_id_ns(ns, cap_only);
if (!cap_only) {
printf("NVME Identify Namespace %d:\n", nsid);
if (flags & BINARY)
return d_raw((unsigned char *)ns, sizeof(*ns));
- if (flags & JSON)
- return json_nvme_cmd_set_independent_id_ns(ns);
printf("NVME Identify Command Set Independent Namespace %d:\n", nsid);
printf("nsfeat : %#x\n", ns->nsfeat);
if (flags & BINARY)
return d_raw((unsigned char *)data, 0x1000);
- if (flags & JSON)
- return json_nvme_id_ns_descs(data);
printf("NVME Namespace Identification Descriptors NS %d:\n", nsid);
for (pos = 0; pos < NVME_IDENTIFY_DATA_SIZE; pos += len) {
if (flags & BINARY)
return d_raw((unsigned char *)ctrl, sizeof(*ctrl));
- else if (flags & JSON)
- return json_nvme_id_ctrl(ctrl, vendor_show);
printf("NVME Identify Controller:\n");
printf("vid : %#x\n", le16_to_cpu(ctrl->vid));
if (flags & BINARY)
return d_raw((unsigned char *)ctrl_nvm, sizeof(*ctrl_nvm));
- else if (flags & JSON)
- return json_nvme_id_ctrl_nvm(ctrl_nvm);
printf("NVMe Identify Controller NVM:\n");
printf("vsl : %u\n", ctrl_nvm->vsl);
if (flags & BINARY)
return d_raw((unsigned char *)nvm_ns, sizeof(*nvm_ns));
- else if (flags & JSON)
- return json_nvme_nvm_id_ns(nvm_ns, ns, cap_only);
if (!cap_only) {
printf("NVMe NVM Identify Namespace %d:\n", nsid);
if (flags & BINARY)
return d_raw((unsigned char *)ctrl, sizeof(*ctrl));
- else if (flags & JSON)
- return json_nvme_zns_id_ctrl(ctrl);
printf("NVMe ZNS Identify Controller:\n");
printf("zasl : %u\n", ctrl->zasl);
if (flags & BINARY)
return d_raw((unsigned char *)ns, sizeof(*ns));
- else if (flags & JSON)
- return json_nvme_zns_id_ns(ns, id_ns);
printf("ZNS Command Set Identify Namespace:\n");
void nvme_show_list_ns(struct nvme_ns_list *ns_list, enum nvme_print_flags flags)
{
int i;
- if (flags & JSON)
- return json_nvme_list_ns(ns_list);
nvme_print(ns_list, flags, ns_list);
if (flags & BINARY)
return d_raw((unsigned char *)report, report_size);
- else if (flags & JSON)
- return json_nvme_zns_report_zones(report, descs,
- ext_size, report_size, zone_list);
for (i = 0; i < descs; i++) {
desc = (struct nvme_zns_desc *)
if (flags & BINARY)
return d_raw((unsigned char *)ctrl_list, sizeof(*ctrl_list));
- if (flags & JSON)
- return json_nvme_list_ctrl(ctrl_list, num);
printf("num of ctrls present: %u\n", num);
for (i = 0; i < min(num, 2047); i++) {
if (flags & BINARY)
return d_raw((unsigned char *)nvmset, sizeof(*nvmset));
- if (flags & JSON)
- return json_nvme_id_nvmset(nvmset);
nvme_print(id_nvmset_list, flags, nvmset, nvmset_id);
if (flags & BINARY)
return d_raw((unsigned char *)caps, sizeof(*caps));
- else if (flags & JSON)
- return json_nvme_primary_ctrl_cap(caps);
printf("NVME Identify Primary Controller Capabilities:\n");
printf("cntlid : %#x\n", le16_to_cpu(caps->cntlid));
const struct nvme_secondary_ctrl *sc_entry =
&sc_list->sc_entry[0];
static const char * const state_desc[] = { "Offline", "Online" };
-
__u16 num = sc_list->num;
__u32 entries = min(num, count);
int i;
if (flags & BINARY)
return d_raw((unsigned char *)sc_list, sizeof(*sc_list));
- if (flags & JSON)
- return json_nvme_list_secondary_ctrl(sc_list, entries);
printf("Identify Secondary Controller List:\n");
printf(" NUMID : Number of Identifiers : %d\n", num);
if (flags & BINARY)
return d_raw((unsigned char *)glist, sizeof(*glist));
- if (flags & JSON)
- return json_nvme_id_ns_granularity_list(glist);
printf("Identify Namespace Granularity List:\n");
printf(" ATTR : Namespace Granularity Attributes: 0x%x\n",
if (flags & BINARY)
return d_raw((unsigned char *)uuid_list, sizeof(*uuid_list));
- if (flags & JSON)
- return json_nvme_id_uuid_list(uuid_list);
/* The 0th entry is reserved */
printf("NVME Identify UUID:\n");
if (flags & BINARY)
return d_raw((unsigned char *)id_dom, sizeof(*id_dom));
- else if (flags & JSON)
- return json_id_domain_list(id_dom);
printf("Number of Domain Entries: %u\n", id_dom->num);
for (i = 0; i < id_dom->num; i++) {
nvme_print(endurance_group_list, flags, endgrp_list);
- if (flags & JSON)
- return json_nvme_endurance_group_list(endgrp_list);
printf("num of endurance group ids: %u\n", num);
for (i = 0; i < min(num, 2047); i++) {
if (flags & BINARY)
return d_raw((unsigned char *)err_log,
entries * sizeof(*err_log));
- else if (flags & JSON)
- return json_error_log(err_log, entries);
printf("Error Log Entries for device:%s entries:%d\n", devname,
entries);
if (flags & BINARY)
return d_raw((unsigned char *)status, bytes);
- else if (flags & JSON)
- return json_nvme_resv_report(status, bytes, eds);
regctl = status->regctl[0] | (status->regctl[1] << 8);
if (flags & BINARY)
return d_raw((unsigned char *)fw_log, sizeof(*fw_log));
- if (flags & JSON)
- return json_fw_log(fw_log, devname);
printf("Firmware Log for device:%s\n", devname);
printf("afi : %#x\n", fw_log->afi);
if (flags & BINARY)
return d_raw((unsigned char *)log, sizeof(*log));
- else if (flags & JSON)
- return json_changed_ns_list_log(log, devname);
if (log->ns[0] != cpu_to_le32(NVME_NSID_ALL)) {
for (i = 0; i < NVME_ID_NS_LIST_MAX; i++) {
void nvme_print_effects_log_pages(struct list_head *list,
enum nvme_print_flags flags)
{
- if (flags & JSON)
- return json_effects_log_list(list);
-
nvme_print(effects_log_list, flags, list);
nvme_effects_log_node_t *node;
if (flags & BINARY)
return d_raw((unsigned char *)support_log, sizeof(*support_log));
- else if (flags & JSON)
- return json_support_log(support_log);
printf("Support Log Pages Details for %s:\n", devname);
for (lid = 0; lid < 256; lid++) {
if (flags & BINARY)
return d_raw((unsigned char *)endurance_log,
sizeof(*endurance_log));
- else if (flags & JSON)
- return json_endurance_log(endurance_log, group_id);
printf("Endurance Group Log for NVME device:%s Group ID:%x\n", devname,
group_id);
if (flags & BINARY)
return d_raw((unsigned char *)smart, sizeof(*smart));
- else if (flags & JSON)
- return json_smart_log(smart, nsid, flags);
printf("Smart Log for NVME device:%s namespace-id:%x\n", devname, nsid);
printf("critical_warning : %#x\n",
if (flags & BINARY)
return d_raw((unsigned char *)ana_log, len);
- else if (flags & JSON)
- return json_ana_log(ana_log, devname);
printf("Asymmetric Namespace Access Log for NVMe device: %s\n",
devname);
if (flags & BINARY)
return d_raw((unsigned char *)self_test, size);
- if (flags & JSON)
- return json_self_test_log(self_test, dst_entries);
printf("Device Self Test Log for NVME device:%s\n", devname);
printf("Current operation : %#x\n", self_test->current_operation);
if (flags & BINARY)
d_raw((unsigned char *)sanitize, sizeof(*sanitize));
- else if (flags & JSON) {
- json_sanitize_log(sanitize, devname);
- return;
- }
printf("Sanitize Progress (SPROG) : %u",
le16_to_cpu(sanitize->sprog));
nvme_print(list_items, flags, r);
- if (flags & JSON)
- json_print_list_items(r, flags);
- else if (flags & VERBOSE)
+ if (flags & VERBOSE)
nvme_show_detailed_list(r);
else
nvme_show_simple_list(r);
{
nvme_print(topology_namespace, flags, r);
- if (flags & JSON)
- json_simple_topology(r);
- else
- nvme_show_simple_topology(r, ranking);
+ nvme_show_simple_topology(r, ranking);
}
void nvme_show_message(bool error, const char *msg, ...)
return;
}
- if (argconfig_output_format_json(false)) {
- if (error)
- json_output_error(msg, ap);
- else
- json_output_result(msg, ap);
- va_end(ap);
- return;
- }
-
vfprintf(error ? stderr : stdout, msg, ap);
printf("\n");
return;
}
- if (argconfig_output_format_json(false)) {
- json_output_perror(msg);
- return;
- }
-
perror(msg);
}
return;
}
- if (flags & JSON) {
- json_discovery_log(log, numrec, flags);
- return;
- }
-
print_discovery_log(log, numrec, flags);
}
{
nvme_print(connect_msg, flags, c);
- if (flags & JSON) {
- json_connect_msg(c, flags);
- return;
- }
-
print_connect_msg(c, flags);
}
enum nvme_print_flags flags;
};
+#ifdef CONFIG_JSONC
+
+struct print_ops *nvme_get_json_print_ops(enum nvme_print_flags flags);
+
+#else /* !CONFIG_JSONC */
+
+static inline struct print_ops *nvme_get_json_print_ops(enum nvme_print_flags flags) { return NULL; }
+
+#endif /* !CONFIG_JSONC */
+
void nvme_show_status(int status);
void nvme_show_lba_status_info(__u32 result);
void nvme_show_relatives(const char *name);
offset = le64_to_cpu(report->entries[nr_zones_chunks-1].zslba) + zsze;
}
- if (flags & JSON)
- json_nvme_finish_zone_list(total_nr_zones, zone_list);
+ if (flags & JSON) {
+ struct print_ops *ops;
+ ops = nvme_get_json_print_ops(flags);
+ if (ops)
+ ops->zns_finish_zone_list(total_nr_zones, zone_list);
+ }
nvme_free(report, huge);
projects / users / sagi / nvme-cli.git / commitdiff