From: Daniel Wagner Date: Tue, 1 Apr 2025 13:02:52 +0000 (+0200) Subject: Revert "nvme-print-json: display only verbose output" X-Git-Url: https://www.infradead.org/git/?a=commitdiff_plain;h=4064edc4b67b49f3966290387c1f79de2c50b6ad;p=users%2Fsagi%2Fnvme-cli.git Revert "nvme-print-json: display only verbose output" This reverts commit 929f4619a9aa9c900247384480fe60ff96931b07. The output format chagned and breaks existing automation. Signed-off-by: Daniel Wagner --- diff --git a/nvme-print-json.c b/nvme-print-json.c index 775bbc00..7cdd7895 100644 --- a/nvme-print-json.c +++ b/nvme-print-json.c @@ -197,6 +197,11 @@ static void json_id_iocs_iocsc(struct json_object *obj_iocsc, __u64 iocsc) obj_add_str(obj_iocsc, "NVM Command Set", nvmcs ? "Selected" : "Not selected"); } +static bool human(void) +{ + return json_print_ops.flags & VERBOSE; +} + static void json_id_iocs(struct nvme_id_iocs *iocs) { struct json_object *r = json_create_object(); @@ -694,17 +699,21 @@ static void json_smart_log(struct nvme_smart_log *smart, unsigned int nsid, nvme_uint128_t media_errors = le128_to_cpu(smart->media_errors); nvme_uint128_t num_err_log_entries = le128_to_cpu(smart->num_err_log_entries); - struct json_object *crt = json_create_object(); + if (human()) { + struct json_object *crt = json_create_object(); - obj_add_int(crt, "value", smart->critical_warning); - obj_add_int(crt, "available_spare", smart->critical_warning & 1); - obj_add_int(crt, "temp_threshold", (smart->critical_warning & 2) >> 1); - obj_add_int(crt, "reliability_degraded", (smart->critical_warning & 4) >> 2); - obj_add_int(crt, "ro", (smart->critical_warning & 8) >> 3); - obj_add_int(crt, "vmbu_failed", (smart->critical_warning & 0x10) >> 4); - obj_add_int(crt, "pmr_ro", (smart->critical_warning & 0x20) >> 5); + obj_add_int(crt, "value", smart->critical_warning); + obj_add_int(crt, "available_spare", smart->critical_warning & 1); + obj_add_int(crt, "temp_threshold", (smart->critical_warning & 2) >> 1); + obj_add_int(crt, "reliability_degraded", (smart->critical_warning & 4) >> 2); + obj_add_int(crt, "ro", (smart->critical_warning & 8) >> 3); + obj_add_int(crt, "vmbu_failed", (smart->critical_warning & 0x10) >> 4); + obj_add_int(crt, "pmr_ro", (smart->critical_warning & 0x20) >> 5); - obj_add_obj(r, "critical_warning", crt); + obj_add_obj(r, "critical_warning", crt); + } else { + obj_add_int(r, "critical_warning", smart->critical_warning); + } obj_add_int(r, "temperature", temperature); obj_add_int(r, "avail_spare", smart->avail_spare); @@ -1345,8 +1354,24 @@ static void json_single_property_human(int offset, uint64_t value64, struct json static void json_single_property(int offset, uint64_t value64) { struct json_object *r = json_create_object(); + char json_str[STR_LEN]; + uint32_t value32 = (uint32_t)value64; + + if (human()) { + json_single_property_human(offset, value64, r); + } else { + sprintf(json_str, "0x%02x", offset); + obj_add_str(r, "property", json_str); - json_single_property_human(offset, value64, r); + obj_add_str(r, "name", nvme_register_to_string(offset)); + + if (nvme_is_64bit_reg(offset)) + sprintf(json_str, "%"PRIx64"", value64); + else + sprintf(json_str, "%x", value32); + + obj_add_str(r, "value", json_str); + } json_print(r); } @@ -2515,10 +2540,12 @@ static void json_print_nvme_subsystem_list(nvme_root_t r, bool show_ana) obj_add_str(subsystem_attrs, "Name", nvme_subsystem_get_name(s)); obj_add_str(subsystem_attrs, "NQN", nvme_subsystem_get_nqn(s)); - obj_add_str(subsystem_attrs, "IOPolicy", - nvme_subsystem_get_iopolicy(s)); - obj_add_str(subsystem_attrs, "Type", - nvme_subsystem_get_type(s)); + if (json_print_ops.flags & VERBOSE) { + obj_add_str(subsystem_attrs, "IOPolicy", + nvme_subsystem_get_iopolicy(s)); + obj_add_str(subsystem_attrs, "Type", + nvme_subsystem_get_type(s)); + } array_add_obj(subsystems, subsystem_attrs); paths = json_create_array(); @@ -2539,84 +2566,120 @@ static void json_ctrl_registers_cap(void *bar, struct json_object *r) { uint64_t cap = mmio_read64(bar + NVME_REG_CAP); - json_registers_cap((struct nvme_bar_cap *)&cap, obj_create_array_obj(r, "cap")); + if (human()) + json_registers_cap((struct nvme_bar_cap *)&cap, obj_create_array_obj(r, "cap")); + else + obj_add_uint64(r, "cap", cap); } static void json_ctrl_registers_vs(void *bar, struct json_object *r) { uint32_t vs = mmio_read32(bar + NVME_REG_VS); - json_registers_version(vs, obj_create_array_obj(r, "vs")); + if (human()) + json_registers_version(vs, obj_create_array_obj(r, "vs")); + else + obj_add_int(r, "vs", vs); } static void json_ctrl_registers_intms(void *bar, struct json_object *r) { uint32_t intms = mmio_read32(bar + NVME_REG_INTMS); - json_registers_intms(intms, obj_create_array_obj(r, "intms")); + if (human()) + json_registers_intms(intms, obj_create_array_obj(r, "intms")); + else + obj_add_int(r, "intms", intms); } static void json_ctrl_registers_intmc(void *bar, struct json_object *r) { uint32_t intmc = mmio_read32(bar + NVME_REG_INTMC); - json_registers_intmc(intmc, obj_create_array_obj(r, "intmc")); + if (human()) + json_registers_intmc(intmc, obj_create_array_obj(r, "intmc")); + else + obj_add_int(r, "intmc", intmc); } static void json_ctrl_registers_cc(void *bar, struct json_object *r) { uint32_t cc = mmio_read32(bar + NVME_REG_CC); - json_registers_cc(cc, obj_create_array_obj(r, "cc")); + if (human()) + json_registers_cc(cc, obj_create_array_obj(r, "cc")); + else + obj_add_int(r, "cc", cc); } static void json_ctrl_registers_csts(void *bar, struct json_object *r) { uint32_t csts = mmio_read32(bar + NVME_REG_CSTS); - json_registers_csts(csts, obj_create_array_obj(r, "csts")); + if (human()) + json_registers_csts(csts, obj_create_array_obj(r, "csts")); + else + obj_add_int(r, "csts", csts); } static void json_ctrl_registers_nssr(void *bar, struct json_object *r) { uint32_t nssr = mmio_read32(bar + NVME_REG_NSSR); - json_registers_nssr(nssr, obj_create_array_obj(r, "nssr")); + if (human()) + json_registers_nssr(nssr, obj_create_array_obj(r, "nssr")); + else + obj_add_int(r, "nssr", nssr); } static void json_ctrl_registers_nssd(void *bar, struct json_object *r) { uint32_t nssd = mmio_read32(bar + NVME_REG_NSSD); - json_registers_nssd(nssd, obj_create_array_obj(r, "nssd")); + if (human()) + json_registers_nssd(nssd, obj_create_array_obj(r, "nssd")); + else + obj_add_int(r, "nssd", nssd); } static void json_ctrl_registers_crto(void *bar, struct json_object *r) { uint32_t crto = mmio_read32(bar + NVME_REG_CRTO); - json_registers_crto(crto, obj_create_array_obj(r, "crto")); + if (human()) + json_registers_crto(crto, obj_create_array_obj(r, "crto")); + else + obj_add_int(r, "crto", crto); } static void json_ctrl_registers_aqa(void *bar, struct json_object *r) { uint32_t aqa = mmio_read32(bar + NVME_REG_AQA); - json_registers_aqa(aqa, obj_create_array_obj(r, "aqa")); + if (human()) + json_registers_aqa(aqa, obj_create_array_obj(r, "aqa")); + else + obj_add_int(r, "aqa", aqa); } static void json_ctrl_registers_asq(void *bar, struct json_object *r) { uint64_t asq = mmio_read64(bar + NVME_REG_ASQ); - json_registers_asq(asq, obj_create_array_obj(r, "asq")); + if (human()) + json_registers_asq(asq, obj_create_array_obj(r, "asq")); + else + obj_add_uint64(r, "asq", asq); } static void json_ctrl_registers_acq(void *bar, struct json_object *r) { uint64_t acq = mmio_read64(bar + NVME_REG_ACQ); - json_registers_acq(acq, obj_create_array_obj(r, "acq")); + if (human()) + json_registers_acq(acq, obj_create_array_obj(r, "acq")); + else + obj_add_uint64(r, "acq", acq); } static void json_ctrl_registers_cmbloc(void *bar, struct json_object *r) @@ -2625,79 +2688,113 @@ static void json_ctrl_registers_cmbloc(void *bar, struct json_object *r) uint32_t cmbsz; bool support; - cmbsz = mmio_read32(bar + NVME_REG_CMBSZ); - support = nvme_registers_cmbloc_support(cmbsz); - json_registers_cmbloc(cmbloc, support, obj_create_array_obj(r, "cmbloc")); + if (human()) { + cmbsz = mmio_read32(bar + NVME_REG_CMBSZ); + support = nvme_registers_cmbloc_support(cmbsz); + json_registers_cmbloc(cmbloc, support, obj_create_array_obj(r, "cmbloc")); + } else { + obj_add_int(r, "cmbloc", cmbloc); + } } static void json_ctrl_registers_cmbsz(void *bar, struct json_object *r) { uint32_t cmbsz = mmio_read32(bar + NVME_REG_CMBSZ); - json_registers_cmbsz(cmbsz, obj_create_array_obj(r, "cmbsz")); + if (human()) + json_registers_cmbsz(cmbsz, obj_create_array_obj(r, "cmbsz")); + else + obj_add_int(r, "cmbsz", cmbsz); } static void json_ctrl_registers_bpinfo(void *bar, struct json_object *r) { uint32_t bpinfo = mmio_read32(bar + NVME_REG_BPINFO); - json_registers_bpinfo(bpinfo, obj_create_array_obj(r, "bpinfo")); + if (human()) + json_registers_bpinfo(bpinfo, obj_create_array_obj(r, "bpinfo")); + else + obj_add_int(r, "bpinfo", bpinfo); } static void json_ctrl_registers_bprsel(void *bar, struct json_object *r) { uint32_t bprsel = mmio_read32(bar + NVME_REG_BPRSEL); - json_registers_bprsel(bprsel, obj_create_array_obj(r, "bprsel")); + if (human()) + json_registers_bprsel(bprsel, obj_create_array_obj(r, "bprsel")); + else + obj_add_int(r, "bprsel", bprsel); } static void json_ctrl_registers_bpmbl(void *bar, struct json_object *r) { uint64_t bpmbl = mmio_read64(bar + NVME_REG_BPMBL); - json_registers_bpmbl(bpmbl, obj_create_array_obj(r, "bpmbl")); + if (human()) + json_registers_bpmbl(bpmbl, obj_create_array_obj(r, "bpmbl")); + else + obj_add_uint64(r, "bpmbl", bpmbl); } static void json_ctrl_registers_cmbmsc(void *bar, struct json_object *r) { uint64_t cmbmsc = mmio_read64(bar + NVME_REG_CMBMSC); - json_registers_cmbmsc(cmbmsc, obj_create_array_obj(r, "cmbmsc")); + if (human()) + json_registers_cmbmsc(cmbmsc, obj_create_array_obj(r, "cmbmsc")); + else + obj_add_uint64(r, "cmbmsc", cmbmsc); } static void json_ctrl_registers_cmbsts(void *bar, struct json_object *r) { uint32_t cmbsts = mmio_read32(bar + NVME_REG_CMBSTS); - json_registers_cmbsts(cmbsts, obj_create_array_obj(r, "cmbsts")); + if (human()) + json_registers_cmbsts(cmbsts, obj_create_array_obj(r, "cmbsts")); + else + obj_add_int(r, "cmbsts", cmbsts); } static void json_ctrl_registers_cmbebs(void *bar, struct json_object *r) { uint32_t cmbebs = mmio_read32(bar + NVME_REG_CMBEBS); - json_registers_cmbebs(cmbebs, obj_create_array_obj(r, "cmbebs")); + if (human()) + json_registers_cmbebs(cmbebs, obj_create_array_obj(r, "cmbebs")); + else + obj_add_int(r, "cmbebs", cmbebs); } static void json_ctrl_registers_cmbswtp(void *bar, struct json_object *r) { uint32_t cmbswtp = mmio_read32(bar + NVME_REG_CMBSWTP); - json_registers_cmbswtp(cmbswtp, obj_create_array_obj(r, "cmbswtp")); + if (human()) + json_registers_cmbswtp(cmbswtp, obj_create_array_obj(r, "cmbswtp")); + else + obj_add_int(r, "cmbswtp", cmbswtp); } static void json_ctrl_registers_pmrcap(void *bar, struct json_object *r) { uint32_t pmrcap = mmio_read32(bar + NVME_REG_PMRCAP); - json_registers_pmrcap(pmrcap, obj_create_array_obj(r, "pmrcap")); + if (human()) + json_registers_pmrcap(pmrcap, obj_create_array_obj(r, "pmrcap")); + else + obj_add_int(r, "pmrcap", pmrcap); } static void json_ctrl_registers_pmrctl(void *bar, struct json_object *r) { uint32_t pmrctl = mmio_read32(bar + NVME_REG_PMRCTL); - json_registers_pmrctl(pmrctl, obj_create_array_obj(r, "pmrctl")); + if (human()) + json_registers_pmrctl(pmrctl, obj_create_array_obj(r, "pmrctl")); + else + obj_add_int(r, "pmrctl", pmrctl); } static void json_ctrl_registers_pmrsts(void *bar, struct json_object *r) @@ -2706,37 +2803,53 @@ static void json_ctrl_registers_pmrsts(void *bar, struct json_object *r) uint32_t pmrctl; bool ready; - pmrctl = mmio_read32(bar + NVME_REG_PMRCTL); - ready = nvme_registers_pmrctl_ready(pmrctl); - json_registers_pmrsts(pmrsts, ready, obj_create_array_obj(r, "pmrsts")); + if (human()) { + pmrctl = mmio_read32(bar + NVME_REG_PMRCTL); + ready = nvme_registers_pmrctl_ready(pmrctl); + json_registers_pmrsts(pmrsts, ready, obj_create_array_obj(r, "pmrsts")); + } else { + obj_add_int(r, "pmrsts", pmrsts); + } } static void json_ctrl_registers_pmrebs(void *bar, struct json_object *r) { uint32_t pmrebs = mmio_read32(bar + NVME_REG_PMREBS); - json_registers_pmrebs(pmrebs, obj_create_array_obj(r, "pmrebs")); + if (human()) + json_registers_pmrebs(pmrebs, obj_create_array_obj(r, "pmrebs")); + else + obj_add_int(r, "pmrebs", pmrebs); } static void json_ctrl_registers_pmrswtp(void *bar, struct json_object *r) { uint32_t pmrswtp = mmio_read32(bar + NVME_REG_PMRSWTP); - json_registers_pmrswtp(pmrswtp, obj_create_array_obj(r, "pmrswtp")); + if (human()) + json_registers_pmrswtp(pmrswtp, obj_create_array_obj(r, "pmrswtp")); + else + obj_add_int(r, "pmrswtp", pmrswtp); } static void json_ctrl_registers_pmrmscl(void *bar, struct json_object *r) { uint32_t pmrmscl = mmio_read32(bar + NVME_REG_PMRMSCL); - json_registers_pmrmscl(pmrmscl, obj_create_array_obj(r, "pmrmscl")); + if (human()) + json_registers_pmrmscl(pmrmscl, obj_create_array_obj(r, "pmrmscl")); + else + obj_add_uint(r, "pmrmscl", pmrmscl); } static void json_ctrl_registers_pmrmscu(void *bar, struct json_object *r) { uint32_t pmrmscu = mmio_read32(bar + NVME_REG_PMRMSCU); - json_registers_pmrmscu(pmrmscu, obj_create_array_obj(r, "pmrmscu")); + if (human()) + json_registers_pmrmscu(pmrmscu, obj_create_array_obj(r, "pmrmscu")); + else + obj_add_uint(r, "pmrmscu", pmrmscu); } static void json_ctrl_registers(void *bar, bool fabrics) @@ -2878,14 +2991,20 @@ static void json_ctrl_register_human(int offset, uint64_t value, struct json_obj static void json_ctrl_register(int offset, uint64_t value) { + bool human = json_print_ops.flags & VERBOSE; struct json_object *r; char json_str[STR_LEN]; sprintf(json_str, "register: %#04x", offset); r = obj_create(json_str); - obj_add_uint64(r, nvme_register_to_string(offset), value); - json_ctrl_register_human(offset, value, r); + if (human) { + obj_add_uint64(r, nvme_register_to_string(offset), value); + json_ctrl_register_human(offset, value, r); + } else { + obj_add_str(r, "name", nvme_register_symbol_to_string(offset)); + obj_add_uint64(r, "value", value); + } } static void json_nvme_cmd_set_independent_id_ns(struct nvme_id_independent_id_ns *ns, @@ -2993,8 +3112,6 @@ static void json_nvme_id_ns_descs(void *data, unsigned int nsid) static void json_nvme_id_ctrl_nvm(struct nvme_id_ctrl_nvm *ctrl_nvm) { struct json_object *r = json_create_object(); - __u16 rsvd = (ctrl_nvm->aocs & 0xfffe) >> 1; - __u8 ralbas = ctrl_nvm->aocs & 0x1; obj_add_uint(r, "vsl", ctrl_nvm->vsl); obj_add_uint(r, "wzsl", ctrl_nvm->wzsl); @@ -3006,9 +3123,14 @@ static void json_nvme_id_ctrl_nvm(struct nvme_id_ctrl_nvm *ctrl_nvm) obj_add_uint(r, "wzdsl", ctrl_nvm->wzdsl); obj_add_uint(r, "aocs", le16_to_cpu(ctrl_nvm->aocs)); - if (rsvd) - obj_add_uint(r, "[15:1]: Reserved", rsvd); - obj_add_uint(r, "[0:0]: Reporting Allocated LBA Supported", ralbas); + if (json_print_ops.flags & VERBOSE) { + __u16 rsvd = (ctrl_nvm->aocs & 0xfffe) >> 1; + __u8 ralbas = ctrl_nvm->aocs & 0x1; + + if (rsvd) + obj_add_uint(r, "[15:1]: Reserved", rsvd); + obj_add_uint(r, "[0:0]: Reporting Allocated LBA Supported", ralbas); + } obj_add_uint(r, "ver", le32_to_cpu(ctrl_nvm->ver)); obj_add_uint(r, "lbamqf", ctrl_nvm->lbamqf); @@ -4241,6 +4363,33 @@ static struct json_object *json_list_item_obj(nvme_ns_t n) return r; } +static void json_simple_list(nvme_root_t t) +{ + struct json_object *r = json_create_object(); + struct json_object *jdevices = json_create_array(); + + nvme_host_t h; + nvme_subsystem_t s; + nvme_ctrl_t c; + nvme_ns_t n; + + nvme_for_each_host(t, h) { + nvme_for_each_subsystem(h, s) { + nvme_subsystem_for_each_ns(s, n) + array_add_obj(jdevices, json_list_item_obj(n)); + + nvme_subsystem_for_each_ctrl(s, c) { + nvme_ctrl_for_each_ns(c, n) + array_add_obj(jdevices, json_list_item_obj(n)); + } + } + } + + obj_add_array(r, "Devices", jdevices); + + json_print(r); +} + static void json_list_item(nvme_ns_t n) { struct json_object *r = json_list_item_obj(n); @@ -4250,7 +4399,10 @@ static void json_list_item(nvme_ns_t n) static void json_print_list_items(nvme_root_t t) { - json_detail_list(t); + if (json_print_ops.flags & VERBOSE) + json_detail_list(t); + else + json_simple_list(t); } static unsigned int json_subsystem_topology_multipath(nvme_subsystem_t s, @@ -4344,10 +4496,12 @@ static void json_simple_topology(nvme_root_t r) obj_add_str(subsystem_attrs, "Name", nvme_subsystem_get_name(s)); obj_add_str(subsystem_attrs, "NQN", nvme_subsystem_get_nqn(s)); - obj_add_str(subsystem_attrs, "IOPolicy", - nvme_subsystem_get_iopolicy(s)); - obj_add_str(subsystem_attrs, "Type", - nvme_subsystem_get_type(s)); + if (json_print_ops.flags & VERBOSE) { + obj_add_str(subsystem_attrs, "IOPolicy", + nvme_subsystem_get_iopolicy(s)); + obj_add_str(subsystem_attrs, "Type", + nvme_subsystem_get_type(s)); + } array_add_obj(subsystems, subsystem_attrs); namespaces = json_create_array(); @@ -4462,6 +4616,7 @@ static void json_directive_show(__u8 type, __u8 oper, __u16 spec, __u32 nsid, __ void *buf, __u32 len) { struct json_object *r = json_create_object(); + struct json_object *data; char json_str[STR_LEN]; sprintf(json_str, "%#x", type); @@ -4475,7 +4630,13 @@ static void json_directive_show(__u8 type, __u8 oper, __u16 spec, __u32 nsid, __ sprintf(json_str, "%#x", result); obj_add_result(r, json_str); - json_directive_show_fields(type, oper, result, buf, r); + if (json_print_ops.flags & VERBOSE) { + json_directive_show_fields(type, oper, result, buf, r); + } else if (buf) { + data = json_create_array(); + d_json((unsigned char *)buf, len, 16, 1, data); + obj_add_array(r, "data", data); + } json_print(r); }