Merging upstream version 2.1~rc0 (Closes: #1015722).
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
parent
9489161ac8
commit
316e846c86
GPG key ID:
FBB4F0E80A80222F
504 changed files with 6751 additions and 2957 deletions
393
nvme-print.c
393
nvme-print.c
|
|
@ -1,3 +1,4 @@
|
|||
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||
#include <assert.h>
|
||||
#include <errno.h>
|
||||
#include <stdio.h>
|
||||
|
|
@ -31,7 +32,7 @@ struct nvme_bar_cap {
|
|||
__u8 to;
|
||||
__u16 bps_css_nssrs_dstrd;
|
||||
__u8 mpsmax_mpsmin;
|
||||
__u8 rsvd_cmbs_pmrs;
|
||||
__u8 rsvd_crms_nsss_cmbs_pmrs;
|
||||
};
|
||||
|
||||
static long double int128_to_double(__u8 *data)
|
||||
|
|
@ -86,8 +87,8 @@ const char *nvme_cmd_to_string(int admin, __u8 opcode)
|
|||
case nvme_admin_directive_send: return "Directive Send";
|
||||
case nvme_admin_directive_recv: return "Directive Receive";
|
||||
case nvme_admin_virtual_mgmt: return "Virtualization Management";
|
||||
case nvme_admin_nvme_mi_send: return "NVMEe-MI Send";
|
||||
case nvme_admin_nvme_mi_recv: return "NVMEe-MI Receive";
|
||||
case nvme_admin_nvme_mi_send: return "NVMe-MI Send";
|
||||
case nvme_admin_nvme_mi_recv: return "NVMe-MI Receive";
|
||||
case nvme_admin_dbbuf: return "Doorbell Buffer Config";
|
||||
case nvme_admin_format_nvm: return "Format NVM";
|
||||
case nvme_admin_security_send: return "Security Send";
|
||||
|
|
@ -185,7 +186,7 @@ static void json_nvme_id_ns(struct nvme_id_ns *ns, bool cap_only)
|
|||
json_object_add_value_int(root, "nabo", le16_to_cpu(ns->nabo));
|
||||
json_object_add_value_int(root, "nabspf", le16_to_cpu(ns->nabspf));
|
||||
json_object_add_value_int(root, "noiob", le16_to_cpu(ns->noiob));
|
||||
json_object_add_value_float(root, "nvmcap", nvmcap);
|
||||
json_object_add_value_double(root, "nvmcap", nvmcap);
|
||||
json_object_add_value_int(root, "nsattr", ns->nsattr);
|
||||
json_object_add_value_int(root, "nvmsetid", le16_to_cpu(ns->nvmsetid));
|
||||
|
||||
|
|
@ -298,8 +299,8 @@ static void json_nvme_id_ctrl(struct nvme_id_ctrl *ctrl,
|
|||
json_object_add_value_int(root, "mtfa", le16_to_cpu(ctrl->mtfa));
|
||||
json_object_add_value_uint(root, "hmpre", le32_to_cpu(ctrl->hmpre));
|
||||
json_object_add_value_uint(root, "hmmin", le32_to_cpu(ctrl->hmmin));
|
||||
json_object_add_value_float(root, "tnvmcap", tnvmcap);
|
||||
json_object_add_value_float(root, "unvmcap", unvmcap);
|
||||
json_object_add_value_double(root, "tnvmcap", tnvmcap);
|
||||
json_object_add_value_double(root, "unvmcap", unvmcap);
|
||||
json_object_add_value_uint(root, "rpmbs", le32_to_cpu(ctrl->rpmbs));
|
||||
json_object_add_value_int(root, "edstt", le16_to_cpu(ctrl->edstt));
|
||||
json_object_add_value_int(root, "dsto", ctrl->dsto);
|
||||
|
|
@ -321,7 +322,7 @@ static void json_nvme_id_ctrl(struct nvme_id_ctrl *ctrl,
|
|||
json_object_add_value_int(root, "nanagrpid",
|
||||
le32_to_cpu(ctrl->nanagrpid));
|
||||
json_object_add_value_int(root, "domainid", le16_to_cpu(ctrl->domainid));
|
||||
json_object_add_value_float(root, "megcap", megcap);
|
||||
json_object_add_value_double(root, "megcap", megcap);
|
||||
json_object_add_value_int(root, "sqes", ctrl->sqes);
|
||||
json_object_add_value_int(root, "cqes", ctrl->cqes);
|
||||
json_object_add_value_int(root, "maxcmd", le16_to_cpu(ctrl->maxcmd));
|
||||
|
|
@ -337,7 +338,7 @@ static void json_nvme_id_ctrl(struct nvme_id_ctrl *ctrl,
|
|||
json_object_add_value_int(root, "acwu", le16_to_cpu(ctrl->acwu));
|
||||
json_object_add_value_int(root, "ocfs", le16_to_cpu(ctrl->ocfs));
|
||||
json_object_add_value_int(root, "sgls", le32_to_cpu(ctrl->sgls));
|
||||
json_object_add_value_float(root, "maxdna", maxdna);
|
||||
json_object_add_value_double(root, "maxdna", maxdna);
|
||||
json_object_add_value_int(root, "maxcna", le32_to_cpu(ctrl->maxcna));
|
||||
|
||||
if (strlen(subnqn))
|
||||
|
|
@ -374,10 +375,12 @@ static void json_nvme_id_ctrl(struct nvme_id_ctrl *ctrl,
|
|||
json_object_add_value_int(psd, "idle_power",
|
||||
le16_to_cpu(ctrl->psd[i].idlp));
|
||||
json_object_add_value_int(psd, "idle_scale",
|
||||
ctrl->psd[i].ips);
|
||||
nvme_psd_power_scale(ctrl->psd[i].ips));
|
||||
json_object_add_value_int(psd, "active_power",
|
||||
le16_to_cpu(ctrl->psd[i].actp));
|
||||
json_object_add_value_int(psd, "active_work_scale",
|
||||
json_object_add_value_int(psd, "active_power_work",
|
||||
ctrl->psd[i].apws & 0x7);
|
||||
json_object_add_value_int(psd, "active_scale",
|
||||
nvme_psd_power_scale(ctrl->psd[i].apws));
|
||||
|
||||
json_array_add_value_object(psds, psd);
|
||||
|
|
@ -609,18 +612,18 @@ static void json_endurance_log(struct nvme_endurance_group_log *endurance_group,
|
|||
endurance_group->avl_spare_threshold);
|
||||
json_object_add_value_int(root, "percent_used",
|
||||
endurance_group->percent_used);
|
||||
json_object_add_value_float(root, "endurance_estimate",
|
||||
json_object_add_value_double(root, "endurance_estimate",
|
||||
endurance_estimate);
|
||||
json_object_add_value_float(root, "data_units_read", data_units_read);
|
||||
json_object_add_value_float(root, "data_units_written",
|
||||
json_object_add_value_double(root, "data_units_read", data_units_read);
|
||||
json_object_add_value_double(root, "data_units_written",
|
||||
data_units_written);
|
||||
json_object_add_value_float(root, "mediate_write_commands",
|
||||
json_object_add_value_double(root, "mediate_write_commands",
|
||||
media_units_written);
|
||||
json_object_add_value_float(root, "host_read_cmds", host_read_cmds);
|
||||
json_object_add_value_float(root, "host_write_cmds", host_write_cmds);
|
||||
json_object_add_value_float(root, "media_data_integrity_err",
|
||||
json_object_add_value_double(root, "host_read_cmds", host_read_cmds);
|
||||
json_object_add_value_double(root, "host_write_cmds", host_write_cmds);
|
||||
json_object_add_value_double(root, "media_data_integrity_err",
|
||||
media_data_integrity_err);
|
||||
json_object_add_value_float(root, "num_err_info_log_entries",
|
||||
json_object_add_value_double(root, "num_err_info_log_entries",
|
||||
num_err_info_log_entries);
|
||||
|
||||
json_print_object(root, NULL);
|
||||
|
|
@ -673,20 +676,20 @@ static void json_smart_log(struct nvme_smart_log *smart, unsigned int nsid,
|
|||
json_object_add_value_int(root, "percent_used", smart->percent_used);
|
||||
json_object_add_value_int(root, "endurance_grp_critical_warning_summary",
|
||||
smart->endu_grp_crit_warn_sumry);
|
||||
json_object_add_value_float(root, "data_units_read", data_units_read);
|
||||
json_object_add_value_float(root, "data_units_written",
|
||||
json_object_add_value_double(root, "data_units_read", data_units_read);
|
||||
json_object_add_value_double(root, "data_units_written",
|
||||
data_units_written);
|
||||
json_object_add_value_float(root, "host_read_commands",
|
||||
json_object_add_value_double(root, "host_read_commands",
|
||||
host_read_commands);
|
||||
json_object_add_value_float(root, "host_write_commands",
|
||||
json_object_add_value_double(root, "host_write_commands",
|
||||
host_write_commands);
|
||||
json_object_add_value_float(root, "controller_busy_time",
|
||||
json_object_add_value_double(root, "controller_busy_time",
|
||||
controller_busy_time);
|
||||
json_object_add_value_float(root, "power_cycles", power_cycles);
|
||||
json_object_add_value_float(root, "power_on_hours", power_on_hours);
|
||||
json_object_add_value_float(root, "unsafe_shutdowns", unsafe_shutdowns);
|
||||
json_object_add_value_float(root, "media_errors", media_errors);
|
||||
json_object_add_value_float(root, "num_err_log_entries",
|
||||
json_object_add_value_double(root, "power_cycles", power_cycles);
|
||||
json_object_add_value_double(root, "power_on_hours", power_on_hours);
|
||||
json_object_add_value_double(root, "unsafe_shutdowns", unsafe_shutdowns);
|
||||
json_object_add_value_double(root, "media_errors", media_errors);
|
||||
json_object_add_value_double(root, "num_err_log_entries",
|
||||
num_err_log_entries);
|
||||
json_object_add_value_uint(root, "warning_temp_time",
|
||||
le32_to_cpu(smart->warning_temp_time));
|
||||
|
|
@ -1188,7 +1191,7 @@ static void json_persistent_event_log(void *pevent_log_info, __u32 size)
|
|||
le16_to_cpu(pevent_log_head->lhl));
|
||||
json_object_add_value_uint64(root, "timestamp",
|
||||
le64_to_cpu(pevent_log_head->ts));
|
||||
json_object_add_value_float(root, "power_on_hours",
|
||||
json_object_add_value_double(root, "power_on_hours",
|
||||
int128_to_double(pevent_log_head->poh));
|
||||
json_object_add_value_uint64(root, "power_cycle_count",
|
||||
le64_to_cpu(pevent_log_head->pcc));
|
||||
|
|
@ -1277,25 +1280,25 @@ static void json_persistent_event_log(void *pevent_log_info, __u32 size)
|
|||
json_object_add_value_int(valid_attrs,
|
||||
"endurance_grp_critical_warning_summary",
|
||||
smart_event->endu_grp_crit_warn_sumry);
|
||||
json_object_add_value_float(valid_attrs, "data_units_read",
|
||||
json_object_add_value_double(valid_attrs, "data_units_read",
|
||||
data_units_read);
|
||||
json_object_add_value_float(valid_attrs, "data_units_written",
|
||||
json_object_add_value_double(valid_attrs, "data_units_written",
|
||||
data_units_written);
|
||||
json_object_add_value_float(valid_attrs, "host_read_commands",
|
||||
json_object_add_value_double(valid_attrs, "host_read_commands",
|
||||
host_read_commands);
|
||||
json_object_add_value_float(valid_attrs, "host_write_commands",
|
||||
json_object_add_value_double(valid_attrs, "host_write_commands",
|
||||
host_write_commands);
|
||||
json_object_add_value_float(valid_attrs, "controller_busy_time",
|
||||
json_object_add_value_double(valid_attrs, "controller_busy_time",
|
||||
controller_busy_time);
|
||||
json_object_add_value_float(valid_attrs, "power_cycles",
|
||||
json_object_add_value_double(valid_attrs, "power_cycles",
|
||||
power_cycles);
|
||||
json_object_add_value_float(valid_attrs, "power_on_hours",
|
||||
json_object_add_value_double(valid_attrs, "power_on_hours",
|
||||
power_on_hours);
|
||||
json_object_add_value_float(valid_attrs, "unsafe_shutdowns",
|
||||
json_object_add_value_double(valid_attrs, "unsafe_shutdowns",
|
||||
unsafe_shutdowns);
|
||||
json_object_add_value_float(valid_attrs, "media_errors",
|
||||
json_object_add_value_double(valid_attrs, "media_errors",
|
||||
media_errors);
|
||||
json_object_add_value_float(valid_attrs, "num_err_log_entries",
|
||||
json_object_add_value_double(valid_attrs, "num_err_log_entries",
|
||||
num_err_log_entries);
|
||||
json_object_add_value_uint(valid_attrs, "warning_temp_time",
|
||||
le32_to_cpu(smart_event->warning_temp_time));
|
||||
|
|
@ -1477,7 +1480,7 @@ static void nvme_show_persistent_event_log_rci(__le32 pel_header_rci)
|
|||
printf("\tReporting Context Port Identifier Type (RCPIT): %u(%s)\n", rcpit,
|
||||
(rcpit == 0x00) ? "Does not already exist" :
|
||||
(rcpit == 0x01) ? "NVM subsystem port" :
|
||||
(rcpit == 0x10) ? "NVMe-MI port" : "Reserved");
|
||||
(rcpit == 0x02) ? "NVMe-MI port" : "Reserved");
|
||||
printf("\tReporting Context Port Identifier (RCPID): %#x\n\n", rcpid);
|
||||
}
|
||||
|
||||
|
|
@ -1490,8 +1493,8 @@ static void nvme_show_persistent_event_entry_ehai(__u8 ehai)
|
|||
printf("\tPort Identifier Type (PIT): %u(%s)\n", pit,
|
||||
(pit == 0x00) ? "PIT not reported and PELPID does not apply" :
|
||||
(pit == 0x01) ? "NVM subsystem port" :
|
||||
(pit == 0x10) ? "NVMe-MI port" :
|
||||
(pit == 0x11) ? "Event not associated with any port and PELPID does not apply" : "Reserved");
|
||||
(pit == 0x02) ? "NVMe-MI port" :
|
||||
"Event not associated with any port and PELPID does not apply");
|
||||
}
|
||||
|
||||
void nvme_show_persistent_event_log(void *pevent_log_info,
|
||||
|
|
@ -1737,13 +1740,12 @@ void nvme_show_persistent_event_log(void *pevent_log_info,
|
|||
fid = le32_to_cpu(set_feat_event->cdw_mem[0]) & 0x000f;
|
||||
cdw11 = le32_to_cpu(set_feat_event->cdw_mem[1]);
|
||||
|
||||
if (((set_feat_event->layout & 0xff) >> 2) != 0)
|
||||
mem_buf = (unsigned char *)(set_feat_event + 4 + dword_cnt * 4);
|
||||
|
||||
printf("Set Feature ID :%#02x (%s), value:%#08x\n", fid,
|
||||
nvme_feature_to_string(fid), cdw11);
|
||||
|
||||
nvme_feature_show_fields(fid, cdw11, mem_buf);
|
||||
if (((set_feat_event->layout & 0xff) >> 2) != 0) {
|
||||
mem_buf = (unsigned char *)(set_feat_event + 4 + dword_cnt * 4);
|
||||
nvme_feature_show_fields(fid, cdw11, mem_buf);
|
||||
}
|
||||
break;
|
||||
case NVME_PEL_TELEMETRY_CRT:
|
||||
d(pevent_log_info + offset, 512, 16, 1);
|
||||
|
|
@ -2261,9 +2263,9 @@ static void json_supported_cap_config_log(
|
|||
le16_to_cpu(cap_log->cap_config_desc[i].egcd[j].endgid));
|
||||
json_object_add_value_uint(endurance, "cap_adj_factor",
|
||||
le16_to_cpu(cap_log->cap_config_desc[i].egcd[j].cap_adj_factor));
|
||||
json_object_add_value_float(endurance, "tegcap",
|
||||
json_object_add_value_double(endurance, "tegcap",
|
||||
int128_to_double(cap_log->cap_config_desc[i].egcd[j].tegcap));
|
||||
json_object_add_value_float(endurance, "segcap",
|
||||
json_object_add_value_double(endurance, "segcap",
|
||||
int128_to_double(cap_log->cap_config_desc[i].egcd[j].segcap));
|
||||
json_object_add_value_uint(endurance, "egsets",
|
||||
le16_to_cpu(cap_log->cap_config_desc[i].egcd[j].egsets));
|
||||
|
|
@ -2373,25 +2375,31 @@ void nvme_show_supported_cap_config_log(
|
|||
}
|
||||
}
|
||||
|
||||
static unsigned int nvme_show_subsystem_multipath(nvme_subsystem_t s)
|
||||
static unsigned int nvme_show_subsystem_multipath(nvme_subsystem_t s,
|
||||
bool show_ana)
|
||||
{
|
||||
nvme_ns_t n;
|
||||
nvme_path_t p;
|
||||
unsigned int i = 0;
|
||||
|
||||
nvme_subsystem_for_each_ns(s, n) {
|
||||
nvme_path_t p;
|
||||
n = nvme_subsystem_first_ns(s);
|
||||
if (!n)
|
||||
return 0;
|
||||
|
||||
nvme_namespace_for_each_path(n, p) {
|
||||
nvme_ctrl_t c = nvme_path_get_ctrl(p);
|
||||
nvme_namespace_for_each_path(n, p) {
|
||||
nvme_ctrl_t c = nvme_path_get_ctrl(p);
|
||||
const char *ana_state = "";
|
||||
|
||||
printf(" +- %s %s %s %s %s\n",
|
||||
nvme_ctrl_get_name(c),
|
||||
nvme_ctrl_get_transport(c),
|
||||
nvme_ctrl_get_address(c),
|
||||
nvme_ctrl_get_state(c),
|
||||
nvme_path_get_ana_state(p));
|
||||
i++;
|
||||
}
|
||||
if (show_ana)
|
||||
ana_state = nvme_path_get_ana_state(p);
|
||||
|
||||
printf(" +- %s %s %s %s %s\n",
|
||||
nvme_ctrl_get_name(c),
|
||||
nvme_ctrl_get_transport(c),
|
||||
nvme_ctrl_get_address(c),
|
||||
nvme_ctrl_get_state(c),
|
||||
ana_state);
|
||||
i++;
|
||||
}
|
||||
|
||||
return i;
|
||||
|
|
@ -2410,7 +2418,7 @@ static void nvme_show_subsystem_ctrls(nvme_subsystem_t s)
|
|||
}
|
||||
}
|
||||
|
||||
static void nvme_show_subsystem(nvme_root_t r)
|
||||
static void nvme_show_subsystem(nvme_root_t r, bool show_ana)
|
||||
{
|
||||
nvme_host_t h;
|
||||
|
||||
|
|
@ -2422,39 +2430,42 @@ static void nvme_show_subsystem(nvme_root_t r)
|
|||
nvme_subsystem_get_nqn(s));
|
||||
printf("\\\n");
|
||||
|
||||
if (!nvme_show_subsystem_multipath(s))
|
||||
if (!nvme_show_subsystem_multipath(s, show_ana))
|
||||
nvme_show_subsystem_ctrls(s);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static unsigned int json_print_nvme_subsystem_multipath(nvme_subsystem_t s,
|
||||
bool show_ana,
|
||||
json_object *paths)
|
||||
{
|
||||
nvme_ns_t n;
|
||||
nvme_path_t p;
|
||||
unsigned int i = 0;
|
||||
|
||||
nvme_subsystem_for_each_ns(s, n) {
|
||||
nvme_path_t p;
|
||||
n = nvme_subsystem_first_ns(s);
|
||||
if (!n)
|
||||
return 0;
|
||||
|
||||
nvme_namespace_for_each_path(n, p) {
|
||||
struct json_object *path_attrs;
|
||||
nvme_ctrl_t c = nvme_path_get_ctrl(p);
|
||||
nvme_namespace_for_each_path(n, p) {
|
||||
struct json_object *path_attrs;
|
||||
nvme_ctrl_t c = nvme_path_get_ctrl(p);
|
||||
|
||||
path_attrs = json_create_object();
|
||||
json_object_add_value_string(path_attrs, "Name",
|
||||
nvme_ctrl_get_name(c));
|
||||
json_object_add_value_string(path_attrs, "Transport",
|
||||
nvme_ctrl_get_transport(c));
|
||||
json_object_add_value_string(path_attrs, "Address",
|
||||
nvme_ctrl_get_address(c));
|
||||
json_object_add_value_string(path_attrs, "State",
|
||||
nvme_ctrl_get_state(c));
|
||||
path_attrs = json_create_object();
|
||||
json_object_add_value_string(path_attrs, "Name",
|
||||
nvme_ctrl_get_name(c));
|
||||
json_object_add_value_string(path_attrs, "Transport",
|
||||
nvme_ctrl_get_transport(c));
|
||||
json_object_add_value_string(path_attrs, "Address",
|
||||
nvme_ctrl_get_address(c));
|
||||
json_object_add_value_string(path_attrs, "State",
|
||||
nvme_ctrl_get_state(c));
|
||||
if (show_ana)
|
||||
json_object_add_value_string(path_attrs, "ANAState",
|
||||
nvme_path_get_ana_state(p));
|
||||
json_array_add_value_object(paths, path_attrs);
|
||||
i++;
|
||||
}
|
||||
json_array_add_value_object(paths, path_attrs);
|
||||
i++;
|
||||
}
|
||||
|
||||
return i;
|
||||
|
|
@ -2481,7 +2492,7 @@ static void json_print_nvme_subsystem_ctrls(nvme_subsystem_t s,
|
|||
}
|
||||
}
|
||||
|
||||
static void json_print_nvme_subsystem_list(nvme_root_t r)
|
||||
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;
|
||||
|
|
@ -2509,7 +2520,7 @@ static void json_print_nvme_subsystem_list(nvme_root_t r)
|
|||
json_array_add_value_object(subsystems, subsystem_attrs);
|
||||
paths = json_create_array();
|
||||
|
||||
if (!json_print_nvme_subsystem_multipath(s, paths))
|
||||
if (!json_print_nvme_subsystem_multipath(s, show_ana, paths))
|
||||
json_print_nvme_subsystem_ctrls(s, paths);
|
||||
|
||||
json_object_add_value_array(subsystem_attrs, "Paths",
|
||||
|
|
@ -2523,20 +2534,25 @@ static void json_print_nvme_subsystem_list(nvme_root_t r)
|
|||
json_free_object(root);
|
||||
}
|
||||
|
||||
void nvme_show_subsystem_list(nvme_root_t r, enum nvme_print_flags flags)
|
||||
void nvme_show_subsystem_list(nvme_root_t r, bool show_ana,
|
||||
enum nvme_print_flags flags)
|
||||
{
|
||||
if (flags & JSON)
|
||||
return json_print_nvme_subsystem_list(r);
|
||||
nvme_show_subsystem(r);
|
||||
return json_print_nvme_subsystem_list(r, show_ana);
|
||||
nvme_show_subsystem(r, show_ana);
|
||||
}
|
||||
|
||||
static void nvme_show_registers_cap(struct nvme_bar_cap *cap)
|
||||
{
|
||||
printf("\tController Ready With Media Support (CRWMS): %s\n",
|
||||
((cap->rsvd_crms_nsss_cmbs_pmrs & 0x08) >> 3) ? "Supported" : "Not Supported");
|
||||
printf("\tController Ready Independent of Media Support (CRIMS): %s\n",
|
||||
((cap->rsvd_crms_nsss_cmbs_pmrs & 0x10) >> 4) ? "Supported" : "Not Supported");
|
||||
printf("\tController Memory Buffer Supported (CMBS): The Controller Memory Buffer is %s\n",
|
||||
((cap->rsvd_cmbs_pmrs & 0x02) >> 1) ? "Supported" :
|
||||
((cap->rsvd_crms_nsss_cmbs_pmrs & 0x02) >> 1) ? "Supported" :
|
||||
"Not Supported");
|
||||
printf("\tPersistent Memory Region Supported (PMRS): The Persistent Memory Region is %s\n",
|
||||
(cap->rsvd_cmbs_pmrs & 0x01) ? "Supported" : "Not Supported");
|
||||
(cap->rsvd_crms_nsss_cmbs_pmrs & 0x01) ? "Supported" : "Not Supported");
|
||||
printf("\tMemory Page Size Maximum (MPSMAX): %u bytes\n",
|
||||
1 << (12 + ((cap->mpsmax_mpsmin & 0xf0) >> 4)));
|
||||
printf("\tMemory Page Size Minimum (MPSMIN): %u bytes\n",
|
||||
|
|
@ -2608,6 +2624,9 @@ static void nvme_show_registers_cc_shn (__u8 shn)
|
|||
|
||||
static void nvme_show_registers_cc(__u32 cc)
|
||||
{
|
||||
printf("\tController Ready Independent of Media Enable (CRIME): %s\n",
|
||||
NVME_CC_CRIME(cc) ? "Enabled":"Disabled");
|
||||
|
||||
printf("\tI/O Completion Queue Entry Size (IOCQES): %u bytes\n",
|
||||
1 << ((cc & 0x00f00000) >> NVME_CC_IOCQES_SHIFT));
|
||||
printf("\tI/O Submission Queue Entry Size (IOSQES): %u bytes\n",
|
||||
|
|
@ -2656,6 +2675,14 @@ static void nvme_show_registers_csts(__u32 csts)
|
|||
|
||||
}
|
||||
|
||||
static void nvme_show_registers_crto(__u32 crto)
|
||||
{
|
||||
printf("\tCRIMT : %d secs\n",
|
||||
NVME_CRTO_CRIMT(crto)/2 );
|
||||
printf("\tCRWMT : %d secs\n",
|
||||
NVME_CRTO_CRWMT(crto)/2 );
|
||||
}
|
||||
|
||||
static void nvme_show_registers_aqa(__u32 aqa)
|
||||
{
|
||||
printf("\tAdmin Completion Queue Size (ACQS): %u\n",
|
||||
|
|
@ -2894,7 +2921,7 @@ static void nvme_show_registers_pmrmscu(uint32_t pmrmscu)
|
|||
static void json_ctrl_registers(void *bar)
|
||||
{
|
||||
uint64_t cap, asq, acq, bpmbl, cmbmsc;
|
||||
uint32_t vs, intms, intmc, cc, csts, nssr, aqa, cmbsz, cmbloc,
|
||||
uint32_t vs, intms, intmc, cc, csts, nssr, crto, aqa, cmbsz, cmbloc,
|
||||
bpinfo, bprsel, cmbsts, pmrcap, pmrctl, pmrsts, pmrebs, pmrswtp,
|
||||
pmrmscl, pmrmscu;
|
||||
struct json_object *root;
|
||||
|
|
@ -2906,6 +2933,7 @@ static void json_ctrl_registers(void *bar)
|
|||
cc = mmio_read32(bar + NVME_REG_CC);
|
||||
csts = mmio_read32(bar + NVME_REG_CSTS);
|
||||
nssr = mmio_read32(bar + NVME_REG_NSSR);
|
||||
crto = mmio_read32(bar + NVME_REG_CRTO);
|
||||
aqa = mmio_read32(bar + NVME_REG_AQA);
|
||||
asq = mmio_read64(bar + NVME_REG_ASQ);
|
||||
acq = mmio_read64(bar + NVME_REG_ACQ);
|
||||
|
|
@ -2925,22 +2953,23 @@ static void json_ctrl_registers(void *bar)
|
|||
pmrmscu = mmio_read32(bar + NVME_REG_PMRMSCU);
|
||||
|
||||
root = json_create_object();
|
||||
json_object_add_value_uint(root, "cap", cap);
|
||||
json_object_add_value_uint64(root, "cap", cap);
|
||||
json_object_add_value_int(root, "vs", vs);
|
||||
json_object_add_value_int(root, "intms", intms);
|
||||
json_object_add_value_int(root, "intmc", intmc);
|
||||
json_object_add_value_int(root, "cc", cc);
|
||||
json_object_add_value_int(root, "csts", csts);
|
||||
json_object_add_value_int(root, "nssr", nssr);
|
||||
json_object_add_value_int(root, "crto", crto);
|
||||
json_object_add_value_int(root, "aqa", aqa);
|
||||
json_object_add_value_uint(root, "asq", asq);
|
||||
json_object_add_value_uint(root, "acq", acq);
|
||||
json_object_add_value_uint64(root, "asq", asq);
|
||||
json_object_add_value_uint64(root, "acq", acq);
|
||||
json_object_add_value_int(root, "cmbloc", cmbloc);
|
||||
json_object_add_value_int(root, "cmbsz", cmbsz);
|
||||
json_object_add_value_int(root, "bpinfo", bpinfo);
|
||||
json_object_add_value_int(root, "bprsel", bprsel);
|
||||
json_object_add_value_uint(root, "bpmbl", bpmbl);
|
||||
json_object_add_value_uint(root, "cmbmsc", cmbmsc);
|
||||
json_object_add_value_uint64(root, "bpmbl", bpmbl);
|
||||
json_object_add_value_uint64(root, "cmbmsc", cmbmsc);
|
||||
json_object_add_value_int(root, "cmbsts", cmbsts);
|
||||
json_object_add_value_int(root, "pmrcap", pmrcap);
|
||||
json_object_add_value_int(root, "pmrctl", pmrctl);
|
||||
|
|
@ -2958,7 +2987,7 @@ void nvme_show_ctrl_registers(void *bar, bool fabrics, enum nvme_print_flags fla
|
|||
{
|
||||
const unsigned int reg_size = 0x0e1c; /* 0x0000 to 0x0e1b */
|
||||
uint64_t cap, asq, acq, bpmbl, cmbmsc;
|
||||
uint32_t vs, intms, intmc, cc, csts, nssr, aqa, cmbsz, cmbloc, bpinfo,
|
||||
uint32_t vs, intms, intmc, cc, csts, nssr, crto, aqa, cmbsz, cmbloc, bpinfo,
|
||||
bprsel, cmbsts, pmrcap, pmrctl, pmrsts, pmrebs, pmrswtp,
|
||||
pmrmscl, pmrmscu;
|
||||
int human = flags & VERBOSE;
|
||||
|
|
@ -2975,6 +3004,7 @@ void nvme_show_ctrl_registers(void *bar, bool fabrics, enum nvme_print_flags fla
|
|||
cc = mmio_read32(bar + NVME_REG_CC);
|
||||
csts = mmio_read32(bar + NVME_REG_CSTS);
|
||||
nssr = mmio_read32(bar + NVME_REG_NSSR);
|
||||
crto = mmio_read32(bar + NVME_REG_CRTO);
|
||||
aqa = mmio_read32(bar + NVME_REG_AQA);
|
||||
asq = mmio_read64(bar + NVME_REG_ASQ);
|
||||
acq = mmio_read64(bar + NVME_REG_ACQ);
|
||||
|
|
@ -3015,6 +3045,10 @@ void nvme_show_ctrl_registers(void *bar, bool fabrics, enum nvme_print_flags fla
|
|||
printf("\tNVM Subsystem Reset Control (NSSRC): %u\n\n",
|
||||
nssr);
|
||||
}
|
||||
if (crto != 0xffffffff) {
|
||||
printf("crto : %x\n", crto);
|
||||
nvme_show_registers_crto(crto);
|
||||
}
|
||||
if (!fabrics) {
|
||||
printf("intms : %x\n", intms);
|
||||
printf("\tInterrupt Vector Mask Set (IVMS): %x\n\n",
|
||||
|
|
@ -3087,6 +3121,8 @@ void nvme_show_ctrl_registers(void *bar, bool fabrics, enum nvme_print_flags fla
|
|||
printf("csts : %x\n", csts);
|
||||
if (nssr != 0xffffffff)
|
||||
printf("nssr : %x\n", nssr);
|
||||
if (crto != 0xffffffff)
|
||||
printf("crto : %x\n", crto);
|
||||
if (!fabrics) {
|
||||
printf("intms : %x\n", intms);
|
||||
printf("intmc : %x\n", intmc);
|
||||
|
|
@ -3157,6 +3193,11 @@ void nvme_show_single_property(int offset, uint64_t value64, int human)
|
|||
value32);
|
||||
break;
|
||||
|
||||
case NVME_REG_CRTO:
|
||||
printf("crto : %x\n", value32);
|
||||
nvme_show_registers_crto(value32);
|
||||
break;
|
||||
|
||||
default:
|
||||
printf("unknown property: 0x%02x (%s), value: %"PRIx64"\n",
|
||||
offset, nvme_register_to_string(offset), value64);
|
||||
|
|
@ -3331,10 +3372,10 @@ static void nvme_show_id_ctrl_ctratt(__le32 ctrl_ctratt)
|
|||
__u32 rrl = (ctratt & NVME_CTRL_CTRATT_READ_RECV_LVLS) >> 3;
|
||||
__u32 eg = (ctratt & NVME_CTRL_CTRATT_ENDURANCE_GROUPS) >> 4;
|
||||
__u32 iod = (ctratt & NVME_CTRL_CTRATT_PREDICTABLE_LAT) >> 5;
|
||||
__u32 tbkas = (ctratt & NVME_CTRL_CTRATT_TBKAS) >> 6;
|
||||
__u32 ng = (ctratt & NVME_CTRL_CTRATT_NAMESPACE_GRANULARITY) >> 7;
|
||||
__u32 sqa = (ctratt & NVME_CTRL_CTRATT_SQ_ASSOCIATIONS) >> 8;
|
||||
__u32 uuidlist = (ctratt & NVME_CTRL_CTRATT_UUID_LIST) >> 9;
|
||||
__u32 rsvd6 = (ctratt & 0x00000040) >> 6;
|
||||
__u32 rsvd8 = (ctratt & 0x00000100) >> 8;
|
||||
|
||||
if (rsvd)
|
||||
printf(" [31:16] : %#x\tReserved\n", rsvd);
|
||||
|
|
@ -3352,12 +3393,12 @@ static void nvme_show_id_ctrl_ctratt(__le32 ctrl_ctratt)
|
|||
mds, mds ? "" : "Not ");
|
||||
printf(" [9:9] : %#x\tUUID List %sSupported\n",
|
||||
uuidlist, uuidlist ? "" : "Not ");
|
||||
if (rsvd8)
|
||||
printf(" [8:8] : %#x\tReserved\n", rsvd8);
|
||||
printf(" [8:8] : %#x\tSQ Associations %sSupported\n",
|
||||
sqa, sqa ? "" : "Not ");
|
||||
printf(" [7:7] : %#x\tNamespace Granularity %sSupported\n",
|
||||
ng, ng ? "" : "Not ");
|
||||
if (rsvd6)
|
||||
printf(" [6:6] : %#x\tReserved\n", rsvd6);
|
||||
printf(" [6:6] : %#x\tTraffic Based Keep Alive %sSupported\n",
|
||||
tbkas, tbkas ? "" : "Not ");
|
||||
printf(" [5:5] : %#x\tPredictable Latency Mode %sSupported\n",
|
||||
iod, iod ? "" : "Not ");
|
||||
printf(" [4:4] : %#x\tEndurance Groups %sSupported\n",
|
||||
|
|
@ -3772,7 +3813,7 @@ static void nvme_show_id_ctrl_fna(__u8 fna)
|
|||
__u8 fmns = fna & 0x1;
|
||||
if (rsvd)
|
||||
printf(" [7:4] : %#x\tReserved\n", rsvd);
|
||||
printf(" [3:3] : %#x\tFormatNVM Broadcast NSID (FFFFFFFFh) %sSupported\n",
|
||||
printf(" [3:3] : %#x\tFormat NVM Broadcast NSID (FFFFFFFFh) %sSupported\n",
|
||||
bcnsid, bcnsid ? "Not " : "");
|
||||
printf(" [2:2] : %#x\tCrypto Erase %sSupported as part of Secure Erase\n",
|
||||
cese, cese ? "" : "Not ");
|
||||
|
|
@ -4280,7 +4321,7 @@ void nvme_show_cmd_set_independent_id_ns(
|
|||
if (flags & JSON)
|
||||
return json_nvme_cmd_set_independent_id_ns(ns);
|
||||
|
||||
printf("NVME Identify Command Set Idependent Namespace %d:\n", nsid);
|
||||
printf("NVME Identify Command Set Independent Namespace %d:\n", nsid);
|
||||
printf("nsfeat : %#x\n", ns->nsfeat);
|
||||
if (human)
|
||||
nvme_show_cmd_set_independent_id_ns_nsfeat(ns->nsfeat);
|
||||
|
|
@ -4362,12 +4403,12 @@ static void json_nvme_id_ns_descs(void *data)
|
|||
|
||||
case NVME_NIDT_CSI:
|
||||
memcpy(&desc.csi, data + off, sizeof(desc.csi));
|
||||
json_str_p += sprintf(json_str_p, "%#x", desc.csi);
|
||||
sprintf(json_str_p, "%#x", desc.csi);
|
||||
len += sizeof(desc.csi);
|
||||
nidt_name = "csi";
|
||||
break;
|
||||
default:
|
||||
/* Skip unnkown types */
|
||||
/* Skip unknown types */
|
||||
len = cur->nidl;
|
||||
break;
|
||||
}
|
||||
|
|
@ -4452,7 +4493,7 @@ void nvme_show_id_ns_descs(void *data, unsigned nsid, enum nvme_print_flags flag
|
|||
len += sizeof(csi);
|
||||
break;
|
||||
default:
|
||||
/* Skip unnkown types */
|
||||
/* Skip unknown types */
|
||||
len = cur->nidl;
|
||||
break;
|
||||
}
|
||||
|
|
@ -4461,22 +4502,45 @@ void nvme_show_id_ns_descs(void *data, unsigned nsid, enum nvme_print_flags flag
|
|||
}
|
||||
}
|
||||
|
||||
static void print_psd_workload(__u8 apw)
|
||||
{
|
||||
switch (apw & 0x7) {
|
||||
case NVME_PSD_WORKLOAD_NP:
|
||||
/* Unknown or not provided */
|
||||
printf("-");
|
||||
break;
|
||||
|
||||
case 1:
|
||||
/* Extended idle period with burst of random write */
|
||||
printf("1MiB 32 RW, 30s idle");
|
||||
break;
|
||||
|
||||
case 2:
|
||||
/* Heavy sequential writes */
|
||||
printf("80K 128KiB SW");
|
||||
break;
|
||||
|
||||
default:
|
||||
printf("reserved");
|
||||
}
|
||||
}
|
||||
|
||||
static void print_ps_power_and_scale(__le16 ctr_power, __u8 scale)
|
||||
{
|
||||
__u16 power = le16_to_cpu(ctr_power);
|
||||
|
||||
switch (scale & 0x3) {
|
||||
case 0:
|
||||
case NVME_PSD_PS_NOT_REPORTED:
|
||||
/* Not reported for this power state */
|
||||
printf("-");
|
||||
break;
|
||||
|
||||
case 1:
|
||||
case NVME_PSD_PS_100_MICRO_WATT:
|
||||
/* Units of 0.0001W */
|
||||
printf("%01u.%04uW", power / 10000, power % 10000);
|
||||
break;
|
||||
|
||||
case 2:
|
||||
case NVME_PSD_PS_10_MILLI_WATT:
|
||||
/* Units of 0.01W */
|
||||
printf("%01u.%02uW", power / 100, power % 100);
|
||||
break;
|
||||
|
|
@ -4493,7 +4557,7 @@ static void nvme_show_id_ctrl_power(struct nvme_id_ctrl *ctrl)
|
|||
for (i = 0; i <= ctrl->npss; i++) {
|
||||
__u16 max_power = le16_to_cpu(ctrl->psd[i].mp);
|
||||
|
||||
printf("ps %4d : mp:", i);
|
||||
printf("ps %4d : mp:", i);
|
||||
|
||||
if (ctrl->psd[i].flags & NVME_PSD_FLAGS_MXPS)
|
||||
printf("%01u.%04uW ", max_power / 10000, max_power % 10000);
|
||||
|
|
@ -4504,7 +4568,7 @@ static void nvme_show_id_ctrl_power(struct nvme_id_ctrl *ctrl)
|
|||
printf("non-");
|
||||
|
||||
printf("operational enlat:%d exlat:%d rrt:%d rrl:%d\n"
|
||||
" rwt:%d rwl:%d idle_power:",
|
||||
" rwt:%d rwl:%d idle_power:",
|
||||
le32_to_cpu(ctrl->psd[i].enlat),
|
||||
le32_to_cpu(ctrl->psd[i].exlat),
|
||||
ctrl->psd[i].rrt, ctrl->psd[i].rrl,
|
||||
|
|
@ -4514,6 +4578,8 @@ static void nvme_show_id_ctrl_power(struct nvme_id_ctrl *ctrl)
|
|||
printf(" active_power:");
|
||||
print_ps_power_and_scale(ctrl->psd[i].actp,
|
||||
nvme_psd_power_scale(ctrl->psd[i].apws));
|
||||
printf("\n active_power_workload:");
|
||||
print_psd_workload(ctrl->psd[i].apws);
|
||||
printf("\n");
|
||||
|
||||
}
|
||||
|
|
@ -4568,7 +4634,7 @@ void nvme_show_id_ctrl(struct nvme_id_ctrl *ctrl, enum nvme_print_flags flags,
|
|||
nvme_show_id_ctrl_vwci(ctrl->vwci);
|
||||
printf("mec : %u\n", ctrl->mec);
|
||||
if (human)
|
||||
nvme_show_id_ctrl_mec(ctrl->vwci);
|
||||
nvme_show_id_ctrl_mec(ctrl->mec);
|
||||
|
||||
printf("oacs : %#x\n", le16_to_cpu(ctrl->oacs));
|
||||
if (human)
|
||||
|
|
@ -4662,7 +4728,7 @@ void nvme_show_id_ctrl(struct nvme_id_ctrl *ctrl, enum nvme_print_flags flags,
|
|||
nvme_show_id_ctrl_vwc(ctrl->vwc);
|
||||
printf("awun : %d\n", le16_to_cpu(ctrl->awun));
|
||||
printf("awupf : %d\n", le16_to_cpu(ctrl->awupf));
|
||||
printf("icsvscc : %d\n", ctrl->icsvscc);
|
||||
printf("icsvscc : %d\n", ctrl->icsvscc);
|
||||
if (human)
|
||||
nvme_show_id_ctrl_icsvscc(ctrl->icsvscc);
|
||||
printf("nwpc : %d\n", ctrl->nwpc);
|
||||
|
|
@ -4767,12 +4833,14 @@ static void json_nvme_nvm_id_ns(struct nvme_nvm_id_ns *nvm_ns,
|
|||
|
||||
static void nvme_show_nvm_id_ns_pic(__u8 pic)
|
||||
{
|
||||
__u8 rsvd = (pic & 0xFC) >> 2;
|
||||
__u8 rsvd = (pic & 0xF8) >> 3;
|
||||
__u8 stcrs = (pic & 0x3) >> 2;
|
||||
__u8 pic_16bpistm = (pic & 0x2) >> 1;
|
||||
__u8 pic_16bpists = pic & 0x1;
|
||||
|
||||
if (rsvd)
|
||||
printf(" [7:2] : %#x\tReserved\n", rsvd);
|
||||
printf(" [7:3] : %#x\tReserved\n", rsvd);
|
||||
printf(" [2:2] : %#x\tStorage Tag Check Read Support\n", stcrs);
|
||||
printf(" [1:1] : %#x\t16b Guard Protection Information Storage Tag Mask\n",
|
||||
pic_16bpistm);
|
||||
printf(" [0:0] : %#x\t16b Guard Protection Information Storage Tag Support\n",
|
||||
|
|
@ -4917,14 +4985,14 @@ static void show_nvme_id_ns_zoned_ozcs(__le16 ns_ozcs)
|
|||
zrwasup ? "Yes" : "No");
|
||||
}
|
||||
|
||||
static void nvme_show_zns_id_ns_recommandeded_limit(__le32 ns_rl, int human,
|
||||
static void nvme_show_zns_id_ns_recommended_limit(__le32 ns_rl, int human,
|
||||
const char *target_limit)
|
||||
{
|
||||
unsigned int recommandeded_limit = le32_to_cpu(ns_rl);
|
||||
if (!recommandeded_limit && human)
|
||||
unsigned int recommended_limit = le32_to_cpu(ns_rl);
|
||||
if (!recommended_limit && human)
|
||||
printf("%s : Not Reported\n", target_limit);
|
||||
else
|
||||
printf("%s : %u\n", target_limit, recommandeded_limit);
|
||||
printf("%s : %u\n", target_limit, recommended_limit);
|
||||
}
|
||||
|
||||
static void nvme_show_zns_id_ns_zrwacap(__u8 zrwacap)
|
||||
|
|
@ -4988,14 +5056,14 @@ void nvme_show_zns_id_ns(struct nvme_zns_id_ns *ns,
|
|||
printf("mor : %#x\n", le32_to_cpu(ns->mor));
|
||||
}
|
||||
|
||||
nvme_show_zns_id_ns_recommandeded_limit(ns->rrl, human, "rrl ");
|
||||
nvme_show_zns_id_ns_recommandeded_limit(ns->frl, human, "frl ");
|
||||
nvme_show_zns_id_ns_recommandeded_limit(ns->rrl1, human, "rrl1");
|
||||
nvme_show_zns_id_ns_recommandeded_limit(ns->rrl2, human, "rrl2");
|
||||
nvme_show_zns_id_ns_recommandeded_limit(ns->rrl3, human, "rrl3");
|
||||
nvme_show_zns_id_ns_recommandeded_limit(ns->frl, human, "frl1");
|
||||
nvme_show_zns_id_ns_recommandeded_limit(ns->frl, human, "frl2");
|
||||
nvme_show_zns_id_ns_recommandeded_limit(ns->frl, human, "frl3");
|
||||
nvme_show_zns_id_ns_recommended_limit(ns->rrl, human, "rrl ");
|
||||
nvme_show_zns_id_ns_recommended_limit(ns->frl, human, "frl ");
|
||||
nvme_show_zns_id_ns_recommended_limit(ns->rrl1, human, "rrl1");
|
||||
nvme_show_zns_id_ns_recommended_limit(ns->rrl2, human, "rrl2");
|
||||
nvme_show_zns_id_ns_recommended_limit(ns->rrl3, human, "rrl3");
|
||||
nvme_show_zns_id_ns_recommended_limit(ns->frl, human, "frl1");
|
||||
nvme_show_zns_id_ns_recommended_limit(ns->frl, human, "frl2");
|
||||
nvme_show_zns_id_ns_recommended_limit(ns->frl, human, "frl3");
|
||||
|
||||
printf("numzrwa : %#x\n", le32_to_cpu(ns->numzrwa));
|
||||
printf("zrwafg : %u\n", le16_to_cpu(ns->zrwafg));
|
||||
|
|
@ -5172,16 +5240,16 @@ static void json_nvme_zns_report_zones(void *report, __u32 descs,
|
|||
|
||||
static void nvme_show_zns_report_zone_attributes(__u8 za, __u8 zai)
|
||||
{
|
||||
const char *const recommanded_limit[4] = {"","1","2","3"};
|
||||
const char *const recommended_limit[4] = {"","1","2","3"};
|
||||
printf("Attrs: Zone Descriptor Extension is %sVaild\n",
|
||||
(za & NVME_ZNS_ZA_ZDEV)? "" : "Not ");
|
||||
if(za & NVME_ZNS_ZA_RZR) {
|
||||
printf(" Reset Zone Recommended with Reset Recommended Limit%s\n",
|
||||
recommanded_limit[(zai&0xd)>>2]);
|
||||
recommended_limit[(zai&0xd)>>2]);
|
||||
}
|
||||
if (za & NVME_ZNS_ZA_FZR) {
|
||||
printf(" Finish Zone Recommended with Finish Recommended Limit%s\n",
|
||||
recommanded_limit[zai&0x3]);
|
||||
recommended_limit[zai&0x3]);
|
||||
}
|
||||
if (za & NVME_ZNS_ZA_ZFC) {
|
||||
printf(" Zone Finished by Controller\n");
|
||||
|
|
@ -5298,9 +5366,9 @@ static void json_nvme_id_nvmset(struct nvme_id_nvmset_list *nvmset)
|
|||
le32_to_cpu(nvmset->ent[i].rr4kt));
|
||||
json_object_add_value_int(entry, "optimal_write_size",
|
||||
le32_to_cpu(nvmset->ent[i].ows));
|
||||
json_object_add_value_float(entry, "total_nvmset_cap",
|
||||
json_object_add_value_double(entry, "total_nvmset_cap",
|
||||
int128_to_double(nvmset->ent[i].tnvmsetcap));
|
||||
json_object_add_value_float(entry, "unalloc_nvmset_cap",
|
||||
json_object_add_value_double(entry, "unalloc_nvmset_cap",
|
||||
int128_to_double(nvmset->ent[i].unvmsetcap));
|
||||
json_array_add_value_object(entries, entry);
|
||||
}
|
||||
|
|
@ -5648,9 +5716,9 @@ static void json_id_domain_list(struct nvme_id_domain_list *id_dom)
|
|||
max_egrp_dom_cap = int128_to_double(id_dom->domain_attr[i].max_egrp_dom_cap);
|
||||
|
||||
json_object_add_value_uint(entry, "dom_id", le16_to_cpu(id_dom->domain_attr[i].dom_id));
|
||||
json_object_add_value_float(entry, "dom_cap", dom_cap);
|
||||
json_object_add_value_float(entry, "unalloc_dom_cap", unalloc_dom_cap);
|
||||
json_object_add_value_float(entry, "max_egrp_dom_cap", max_egrp_dom_cap);
|
||||
json_object_add_value_double(entry, "dom_cap", dom_cap);
|
||||
json_object_add_value_double(entry, "unalloc_dom_cap", unalloc_dom_cap);
|
||||
json_object_add_value_double(entry, "max_egrp_dom_cap", max_egrp_dom_cap);
|
||||
|
||||
json_array_add_value_object(entries, entry);
|
||||
}
|
||||
|
|
@ -5670,7 +5738,7 @@ void nvme_show_id_domain_list(struct nvme_id_domain_list *id_dom,
|
|||
else if (flags & JSON)
|
||||
return json_id_domain_list(id_dom);
|
||||
|
||||
printf("Number of Domain Entires: %u\n", id_dom->num);
|
||||
printf("Number of Domain Entries: %u\n", id_dom->num);
|
||||
for (i = 0; i < id_dom->num; i++) {
|
||||
printf("Domain Id for Attr Entry[%u]: %u\n", i,
|
||||
le16_to_cpu(id_dom->domain_attr[i].dom_id));
|
||||
|
|
@ -5678,7 +5746,7 @@ void nvme_show_id_domain_list(struct nvme_id_domain_list *id_dom,
|
|||
int128_to_double(id_dom->domain_attr[i].dom_cap));
|
||||
printf("Unallocated Domain Capacity for Attr Entry[%u]: %.0Lf\n", i,
|
||||
int128_to_double(id_dom->domain_attr[i].unalloc_dom_cap));
|
||||
printf("Max Endurange Group Domain Capacity for Attr Entry[%u]: %.0Lf\n", i,
|
||||
printf("Max Endurance Group Domain Capacity for Attr Entry[%u]: %.0Lf\n", i,
|
||||
int128_to_double(id_dom->domain_attr[i].max_egrp_dom_cap));
|
||||
}
|
||||
}
|
||||
|
|
@ -6093,7 +6161,7 @@ void nvme_show_supported_log(struct nvme_supported_log_pages *support_log,
|
|||
else if (flags & JSON)
|
||||
return json_support_log(support_log);
|
||||
|
||||
printf("Support Log Pages Deatils for %s:\n", devname);
|
||||
printf("Support Log Pages Details for %s:\n", devname);
|
||||
for (lid = 0; lid < 256; lid++) {
|
||||
support = le32_to_cpu(support_log->lid_support[lid]);
|
||||
if (support & 0x1) {
|
||||
|
|
@ -6473,12 +6541,12 @@ const char *nvme_feature_to_string(enum nvme_features_id feature)
|
|||
case NVME_FEAT_FID_HCTM: return "Host Controlled Thermal Management";
|
||||
case NVME_FEAT_FID_NOPSC: return "Non-Operational Power State Config";
|
||||
case NVME_FEAT_FID_RRL: return "Read Recovery Level";
|
||||
case NVME_FEAT_FID_PLM_CONFIG: return "Predicatable Latency Mode Config";
|
||||
case NVME_FEAT_FID_PLM_WINDOW: return "Predicatable Latency Mode Window";
|
||||
case NVME_FEAT_FID_PLM_CONFIG: return "Predictable Latency Mode Config";
|
||||
case NVME_FEAT_FID_PLM_WINDOW: return "Predictable Latency Mode Window";
|
||||
case NVME_FEAT_FID_LBA_STS_INTERVAL: return "LBA Status Interval";
|
||||
case NVME_FEAT_FID_HOST_BEHAVIOR: return "Host Behavior";
|
||||
case NVME_FEAT_FID_SANITIZE: return "Sanitize";
|
||||
case NVME_FEAT_FID_ENDURANCE_EVT_CFG: return "Enduarance Event Group Configuration";
|
||||
case NVME_FEAT_FID_ENDURANCE_EVT_CFG: return "Endurance Event Group Configuration";
|
||||
case NVME_FEAT_FID_IOCS_PROFILE: return "I/O Command Set Profile";
|
||||
case NVME_FEAT_FID_SPINUP_CONTROL: return "Spinup Control";
|
||||
case NVME_FEAT_FID_ENH_CTRL_METADATA: return "Enhanced Controller Metadata";
|
||||
|
|
@ -6488,7 +6556,7 @@ const char *nvme_feature_to_string(enum nvme_features_id feature)
|
|||
case NVME_FEAT_FID_HOST_ID: return "Host Identifier";
|
||||
case NVME_FEAT_FID_RESV_MASK: return "Reservation Notification Mask";
|
||||
case NVME_FEAT_FID_RESV_PERSIST:return "Reservation Persistence";
|
||||
case NVME_FEAT_FID_WRITE_PROTECT: return "Namespce Write Protect";
|
||||
case NVME_FEAT_FID_WRITE_PROTECT: return "Namespace Write Protect";
|
||||
}
|
||||
/*
|
||||
* We don't use the "default:" statement to let the compiler warning if
|
||||
|
|
@ -6637,14 +6705,14 @@ static void nvme_show_auto_pst(struct nvme_feat_auto_pst *apst)
|
|||
static void nvme_show_timestamp(struct nvme_timestamp *ts)
|
||||
{
|
||||
struct tm *tm;
|
||||
char buffer[32];
|
||||
char buffer[320];
|
||||
time_t timestamp = int48_to_long(ts->timestamp) / 1000;
|
||||
|
||||
tm = localtime(×tamp);
|
||||
strftime(buffer, sizeof(buffer), "%c %Z", tm);
|
||||
|
||||
printf("\tThe timestamp is : %"PRIu64" (%s)\n",
|
||||
int48_to_long(ts->timestamp), buffer);
|
||||
printf("\tThe timestamp is : %'"PRIu64" (%s)\n",
|
||||
int48_to_long(ts->timestamp),
|
||||
strftime(buffer, sizeof(buffer), "%c %Z", tm) ? buffer : "-");
|
||||
printf("\t%s\n", (ts->attr & 2) ?
|
||||
"The Timestamp field was initialized with a "\
|
||||
"Timestamp value using a Set Features command." :
|
||||
|
|
@ -6726,7 +6794,7 @@ static void nvme_directive_show_fields(__u8 dtype, __u8 doper,
|
|||
*(__u32 *) (field + 16));
|
||||
printf("\tStream Granularity Size (in unit of SWS) (SGS): %u\n",
|
||||
*(__u16 *) (field + 20));
|
||||
printf("\tNamespece Streams Allocated (NSA): %u\n",
|
||||
printf("\tNamespace Streams Allocated (NSA): %u\n",
|
||||
*(__u16 *) (field + 22));
|
||||
printf("\tNamespace Streams Open (NSO): %u\n",
|
||||
*(__u16 *) (field + 24));
|
||||
|
|
@ -6907,7 +6975,8 @@ void nvme_feature_show_fields(enum nvme_features_id fid, unsigned int result, un
|
|||
case NVME_FEAT_FID_LBA_RANGE:
|
||||
field = result & 0x0000003f;
|
||||
printf("\tNumber of LBA Ranges (NUM): %u\n", field + 1);
|
||||
nvme_show_lba_range((struct nvme_lba_range_type *)buf, field);
|
||||
if (buf)
|
||||
nvme_show_lba_range((struct nvme_lba_range_type *)buf, field);
|
||||
break;
|
||||
case NVME_FEAT_FID_TEMP_THRESH:
|
||||
field = (result & 0x00300000) >> 20;
|
||||
|
|
@ -6966,14 +7035,17 @@ void nvme_feature_show_fields(enum nvme_features_id fid, unsigned int result, un
|
|||
case NVME_FEAT_FID_AUTO_PST:
|
||||
printf("\tAutonomous Power State Transition Enable (APSTE): %s\n",
|
||||
(result & 0x00000001) ? "Enabled":"Disabled");
|
||||
nvme_show_auto_pst((struct nvme_feat_auto_pst *)buf);
|
||||
if (buf)
|
||||
nvme_show_auto_pst((struct nvme_feat_auto_pst *)buf);
|
||||
break;
|
||||
case NVME_FEAT_FID_HOST_MEM_BUF:
|
||||
printf("\tEnable Host Memory (EHM): %s\n", (result & 0x00000001) ? "Enabled":"Disabled");
|
||||
nvme_show_host_mem_buffer((struct nvme_host_mem_buf_attrs *)buf);
|
||||
if (buf)
|
||||
nvme_show_host_mem_buffer((struct nvme_host_mem_buf_attrs *)buf);
|
||||
break;
|
||||
case NVME_FEAT_FID_TIMESTAMP:
|
||||
nvme_show_timestamp((struct nvme_timestamp *)buf);
|
||||
if (buf)
|
||||
nvme_show_timestamp((struct nvme_timestamp *)buf);
|
||||
break;
|
||||
case NVME_FEAT_FID_KATO:
|
||||
printf("\tKeep Alive Timeout (KATO) in milliseconds: %u\n", result);
|
||||
|
|
@ -6993,7 +7065,8 @@ void nvme_feature_show_fields(enum nvme_features_id fid, unsigned int result, un
|
|||
break;
|
||||
case NVME_FEAT_FID_PLM_CONFIG:
|
||||
printf("\tPredictable Latency Window Enabled: %s\n", result & 0x1 ? "True":"False");
|
||||
nvme_show_plm_config((struct nvme_plm_config *)buf);
|
||||
if (buf)
|
||||
nvme_show_plm_config((struct nvme_plm_config *)buf);
|
||||
break;
|
||||
case NVME_FEAT_FID_PLM_WINDOW:
|
||||
printf("\tWindow Select: %s", nvme_plm_window(result));
|
||||
|
|
@ -7002,7 +7075,8 @@ void nvme_feature_show_fields(enum nvme_features_id fid, unsigned int result, un
|
|||
nvme_show_lba_status_info(result);
|
||||
break;
|
||||
case NVME_FEAT_FID_HOST_BEHAVIOR:
|
||||
printf("\tHost Behavior Support: %s\n", (buf[0] & 0x1) ? "True" : "False");
|
||||
if (buf)
|
||||
printf("\tHost Behavior Support: %s\n", (buf[0] & 0x1) ? "True" : "False");
|
||||
break;
|
||||
case NVME_FEAT_FID_SANITIZE:
|
||||
printf("\tNo-Deallocate Response Mode (NODRM) : %u\n", result & 0x1);
|
||||
|
|
@ -7020,16 +7094,19 @@ void nvme_feature_show_fields(enum nvme_features_id fid, unsigned int result, un
|
|||
case NVME_FEAT_FID_ENH_CTRL_METADATA:
|
||||
case NVME_FEAT_FID_CTRL_METADATA:
|
||||
case NVME_FEAT_FID_NS_METADATA:
|
||||
nvme_show_host_metadata(fid, (struct nvme_host_metadata *)buf);
|
||||
if (buf)
|
||||
nvme_show_host_metadata(fid, (struct nvme_host_metadata *)buf);
|
||||
break;
|
||||
case NVME_FEAT_FID_SW_PROGRESS:
|
||||
printf("\tPre-boot Software Load Count (PBSLC): %u\n", result & 0x000000ff);
|
||||
break;
|
||||
case NVME_FEAT_FID_HOST_ID:
|
||||
ull = buf[7]; ull <<= 8; ull |= buf[6]; ull <<= 8; ull |= buf[5]; ull <<= 8;
|
||||
ull |= buf[4]; ull <<= 8; ull |= buf[3]; ull <<= 8; ull |= buf[2]; ull <<= 8;
|
||||
ull |= buf[1]; ull <<= 8; ull |= buf[0];
|
||||
printf("\tHost Identifier (HOSTID): %" PRIu64 "\n", ull);
|
||||
if (buf) {
|
||||
ull = buf[7]; ull <<= 8; ull |= buf[6]; ull <<= 8; ull |= buf[5]; ull <<= 8;
|
||||
ull |= buf[4]; ull <<= 8; ull |= buf[3]; ull <<= 8; ull |= buf[2]; ull <<= 8;
|
||||
ull |= buf[1]; ull <<= 8; ull |= buf[0];
|
||||
printf("\tHost Identifier (HOSTID): %" PRIu64 "\n", ull);
|
||||
}
|
||||
break;
|
||||
case NVME_FEAT_FID_RESV_MASK:
|
||||
printf("\tMask Reservation Preempted Notification (RESPRE): %s\n",
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue