nvme/nvme-cli
1
0
Fork 0
Code Issues Activity

Merging upstream version 2.10.

Browse source 
Signed-off-by: Daniel Baumann <daniel@debian.org>
This commit is contained in:
Daniel Baumann 2025-02-16 12:27:38 +01:00
parent 736f2f7c80
commit 37275c4af3
Signed by: daniel
GPG key ID: FBB4F0E80A80222F
530 changed files with 12276 additions and 4877 deletions
Download patch file Download diff file Expand all files Collapse all files

295
nvme-print-stdout.c
View file

@ -162,9 +162,7 @@ static void nvme_resources_free(struct nvme_resources *res)
static void stdout_feature_show_fields(enum nvme_features_id fid,
unsigned int result,
unsigned char *buf);
static void stdout_smart_log(struct nvme_smart_log *smart,
unsigned int nsid,
const char *devname);
static void stdout_smart_log(struct nvme_smart_log *smart, unsigned int nsid, const char *devname);
static void stdout_predictable_latency_per_nvmset(
struct nvme_nvmset_predictable_lat_log *plpns_log,
@ -248,13 +246,25 @@ static void stdout_add_bitmap(int i, __u8 seb)
}
}
static void stdout_persistent_event_log_fdp_events(unsigned int cdw11,
unsigned int cdw12,
unsigned char *buf)
{
unsigned int num = (cdw11 >> 16) & 0xff;
for (unsigned int i = 0; i < num; i++) {
printf("\t%-53s: %sEnabled\n", nvme_fdp_event_to_string(buf[0]),
cdw12 & 0x1 ? "" : "Not ");
}
}
static void stdout_persistent_event_log(void *pevent_log_info,
__u8 action, __u32 size,
const char *devname)
{
__u32 offset, por_info_len, por_info_list;
__u64 *fw_rev;
int fid, cdw11, dword_cnt;
int fid, cdw11, cdw12, dword_cnt;
unsigned char *mem_buf = NULL;
struct nvme_smart_log *smart_event;
struct nvme_fw_commit_event *fw_commit_event;
@ -490,8 +500,13 @@ static void stdout_persistent_event_log(void *pevent_log_info,
printf("Set Feature ID :%#02x (%s), value:%#08x\n", fid,
nvme_feature_to_string(fid), cdw11);
if (NVME_SET_FEAT_EVENT_MB_COUNT(set_feat_event->layout)) {
mem_buf = (unsigned char *)(set_feat_event + 4 + dword_cnt * 4);
stdout_feature_show_fields(fid, cdw11, mem_buf);
mem_buf = (unsigned char *)set_feat_event + 4 + dword_cnt * 4;
if (fid == NVME_FEAT_FID_FDP_EVENTS) {
cdw12 = le32_to_cpu(set_feat_event->cdw_mem[2]);
stdout_persistent_event_log_fdp_events(cdw11, cdw12,
mem_buf);
} else
stdout_feature_show_fields(fid, cdw11, mem_buf);
}
break;
case NVME_PEL_TELEMETRY_CRT:
@ -623,8 +638,7 @@ static void stdout_fid_support_effects_log(struct nvme_fid_supported_effects_log
fid_effect);
if (human)
stdout_fid_support_effects_log_human(fid_effect);
else
printf("\n");
printf("\n");
}
}
}
@ -666,8 +680,7 @@ static void stdout_mi_cmd_support_effects_log(struct nvme_mi_cmd_supported_effec
mi_cmd_effect);
if (human)
stdout_mi_cmd_support_effects_log_human(mi_cmd_effect);
else
printf("\n");
printf("\n");
}
}
}
@ -1050,6 +1063,18 @@ static void stdout_subsystem_ctrls(nvme_subsystem_t s)
}
}
static void stdout_subsys_config(nvme_subsystem_t s)
{
int len = strlen(nvme_subsystem_get_name(s));
printf("%s - NQN=%s\n", nvme_subsystem_get_name(s),
nvme_subsystem_get_nqn(s));
printf("%*s hostnqn=%s\n", len, " ",
nvme_host_get_hostnqn(nvme_subsystem_get_host(s)));
printf("%*s iopolicy=%s\n", len, " ",
nvme_subsystem_get_iopolicy(s));
}
static void stdout_subsystem(nvme_root_t r, bool show_ana)
{
nvme_host_t h;
@ -1059,18 +1084,11 @@ static void stdout_subsystem(nvme_root_t r, bool show_ana)
nvme_subsystem_t s;
nvme_for_each_subsystem(h, s) {
int len = strlen(nvme_subsystem_get_name(s));
if (!first)
printf("\n");
first = false;
printf("%s - NQN=%s\n", nvme_subsystem_get_name(s),
nvme_subsystem_get_nqn(s));
printf("%*s hostnqn=%s\n", len, " ",
nvme_host_get_hostnqn(nvme_subsystem_get_host(s)));
printf("%*s iopolicy=%s\n", len, " ",
nvme_subsystem_get_iopolicy(s));
stdout_subsys_config(s);
printf("\\\n");
if (!show_ana || !stdout_subsystem_multipath(s))
@ -1379,7 +1397,7 @@ static void stdout_registers_pmrcap(__u32 pmrcap)
printf("\tPersistent Memory Region Timeout (PMRTO): %x\n",
NVME_PMRCAP_PMRTO(pmrcap));
printf("\tPersistent Memory Region Write Barrier Mechanisms (PMRWBM): %x\n",
NVME_PMRCAP_PMRWMB(pmrcap));
NVME_PMRCAP_PMRWBM(pmrcap));
printf("\tPersistent Memory Region Time Units (PMRTU): ");
printf("PMR time unit is %s\n", NVME_PMRCAP_PMRTU(pmrcap) ? "minutes" : "500 milliseconds");
printf("\tBase Indicator Register (BIR): %x\n",
@ -1713,7 +1731,9 @@ static void stdout_id_ctrl_ctratt(__le32 ctrl_ctratt)
__u32 ctratt = le32_to_cpu(ctrl_ctratt);
__u32 rsvd20 = (ctratt >> 20);
__u32 fdps = (ctratt >> 19) & 0x1;
__u32 rsvd16 = (ctratt >> 16) & 0x7;
__u32 rsvd18 = (ctratt >> 18) & 0x1;
__u32 hmbr = (ctratt >> 17) & 0x1;
__u32 mem = (ctratt >> 16) & 0x1;
__u32 elbas = (ctratt >> 15) & 0x1;
__u32 delnvmset = (ctratt >> 14) & 0x1;
__u32 delegrp = (ctratt >> 13) & 0x1;
@ -1735,8 +1755,12 @@ static void stdout_id_ctrl_ctratt(__le32 ctrl_ctratt)
printf(" [31:20] : %#x\tReserved\n", rsvd20);
printf(" [19:19] : %#x\tFlexible Data Placement %sSupported\n",
fdps, fdps ? "" : "Not ");
if (rsvd16)
printf(" [18:16] : %#x\tReserved\n", rsvd16);
if (rsvd18)
printf(" [18:18] : %#x\tReserved\n", rsvd18);
printf(" [17:17] : %#x\tHMB Restrict Non-Operational Power State Access %sSupported\n",
hmbr, hmbr ? "" : "Not ");
printf(" [16:16] : %#x\tMDTS and Size Limits Exclude Metadata %sSupported\n",
mem, mem ? "" : "Not ");
printf(" [15:15] : %#x\tExtended LBA Formats %sSupported\n",
elbas, elbas ? "" : "Not ");
printf(" [14:14] : %#x\tDelete NVM Set %sSupported\n",
@ -1964,15 +1988,15 @@ static void stdout_id_ctrl_apsta(__u8 apsta)
static void stdout_id_ctrl_wctemp(__le16 wctemp)
{
printf(" [15:0] : %ld °C (%u K)\tWarning Composite Temperature Threshold (WCTEMP)\n",
kelvin_to_celsius(le16_to_cpu(wctemp)), le16_to_cpu(wctemp));
printf(" [15:0] : %s (%u K)\tWarning Composite Temperature Threshold (WCTEMP)\n",
nvme_degrees_string(le16_to_cpu(wctemp)), le16_to_cpu(wctemp));
printf("\n");
}
static void stdout_id_ctrl_cctemp(__le16 cctemp)
{
printf(" [15:0] : %ld °C (%u K)\tCritical Composite Temperature Threshold (CCTEMP)\n",
kelvin_to_celsius(le16_to_cpu(cctemp)), le16_to_cpu(cctemp));
printf(" [15:0] : %s (%u K)\tCritical Composite Temperature Threshold (CCTEMP)\n",
nvme_degrees_string(le16_to_cpu(cctemp)), le16_to_cpu(cctemp));
printf("\n");
}
@ -2021,15 +2045,15 @@ static void stdout_id_ctrl_hctma(__le16 ctrl_hctma)
static void stdout_id_ctrl_mntmt(__le16 mntmt)
{
printf(" [15:0] : %ld °C (%u K)\tMinimum Thermal Management Temperature (MNTMT)\n",
kelvin_to_celsius(le16_to_cpu(mntmt)), le16_to_cpu(mntmt));
printf(" [15:0] : %s (%u K)\tMinimum Thermal Management Temperature (MNTMT)\n",
nvme_degrees_string(le16_to_cpu(mntmt)), le16_to_cpu(mntmt));
printf("\n");
}
static void stdout_id_ctrl_mxtmt(__le16 mxtmt)
{
printf(" [15:0] : %ld °C (%u K)\tMaximum Thermal Management Temperature (MXTMT)\n",
kelvin_to_celsius(le16_to_cpu(mxtmt)), le16_to_cpu(mxtmt));
printf(" [15:0] : %s (%u K)\tMaximum Thermal Management Temperature (MXTMT)\n",
nvme_degrees_string(le16_to_cpu(mxtmt)), le16_to_cpu(mxtmt));
printf("\n");
}
@ -2341,17 +2365,18 @@ static void stdout_id_ctrl_ofcs(__le16 ofcs)
static void stdout_id_ns_nsfeat(__u8 nsfeat)
{
__u8 rsvd = (nsfeat & 0xE0) >> 5;
__u8 ioopt = (nsfeat & 0x10) >> 4;
__u8 rsvd = (nsfeat & 0xC0) >> 6;
__u8 optperf = (nsfeat & 0x30) >> 4;
__u8 uidreuse = (nsfeat & 0x8) >> 3;
__u8 dulbe = (nsfeat & 0x4) >> 2;
__u8 na = (nsfeat & 0x2) >> 1;
__u8 thin = nsfeat & 0x1;
if (rsvd)
printf(" [7:5] : %#x\tReserved\n", rsvd);
printf(" [4:4] : %#x\tNPWG, NPWA, NPDG, NPDA, and NOWS are %sSupported\n",
ioopt, ioopt ? "" : "Not ");
printf(" [7:6] : %#x\tReserved\n", rsvd);
printf(" [5:4] : %#x\tNPWG, NPWA, %s%sNPDA, and NOWS are %sSupported\n",
optperf, ((optperf & 0x1) || (!optperf)) ? "NPDG, " : "",
((optperf & 0x2) || (!optperf)) ? "NPDGL, " : "", optperf ? "" : "Not ");
printf(" [3:3] : %#x\tNGUID and EUI64 fields if non-zero, %sReused\n",
uidreuse, uidreuse ? "Never " : "");
printf(" [2:2] : %#x\tDeallocated or Unwritten Logical Block error %sSupported\n",
@ -2584,10 +2609,11 @@ static void stdout_id_ns(struct nvme_id_ns *ns, unsigned int nsid,
printf("noiob : %d\n", le16_to_cpu(ns->noiob));
printf("nvmcap : %s\n",
uint128_t_to_l10n_string(le128_to_cpu(ns->nvmcap)));
if (ns->nsfeat & 0x10) {
if (ns->nsfeat & 0x30) {
printf("npwg : %u\n", le16_to_cpu(ns->npwg));
printf("npwa : %u\n", le16_to_cpu(ns->npwa));
printf("npdg : %u\n", le16_to_cpu(ns->npdg));
if (ns->nsfeat & 0x10)
printf("npdg : %u\n", le16_to_cpu(ns->npdg));
printf("npda : %u\n", le16_to_cpu(ns->npda));
printf("nows : %u\n", le16_to_cpu(ns->nows));
}
@ -3040,30 +3066,69 @@ static void stdout_id_ctrl_nvm(struct nvme_id_ctrl_nvm *ctrl_nvm)
static void stdout_nvm_id_ns_pic(__u8 pic)
{
__u8 rsvd = (pic & 0xF8) >> 3;
__u8 stcrs = (pic & 0x3) >> 2;
__u8 rsvd = (pic & 0xF0) >> 4;
__u8 qpifs = (pic & 0x8) >> 3;
__u8 stcrs = (pic & 0x4) >> 2;
__u8 pic_16bpistm = (pic & 0x2) >> 1;
__u8 pic_16bpists = pic & 0x1;
if (rsvd)
printf(" [7:3] : %#x\tReserved\n", rsvd);
printf(" [2:2] : %#x\tStorage Tag Check Read Support\n", stcrs);
printf(" [7:4] : %#x\tReserved\n", rsvd);
printf(" [3:3] : %#x\tQualified Protection Information Format %sSupported\n",
qpifs, qpifs ? "" : "Not ");
printf(" [2:2] : %#x\tStorage Tag Check Read %sSupported\n",
stcrs, stcrs ? "" : "Not ");
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",
pic_16bpists);
printf(" [0:0] : %#x\t16b Guard Protection Information Storage Tag %sSupported\n",
pic_16bpists, pic_16bpists ? "" : "Not ");
printf("\n");
}
static void stdout_nvm_id_ns_pifa(__u8 pifa)
{
__u8 rsvd = (pifa & 0xF8) >> 3;
__u8 stmla = pifa & 0x7;
if (rsvd)
printf(" [7:3] : %#x\tReserved\n", rsvd);
printf(" [2:0] : %#x\tStorage Tag Masking Level Attribute : %s\n", stmla,
stmla == 0 ? "Bit Granularity Masking" :
stmla == 1 ? "Byte Granularity Masking" :
stmla == 2 ? "Masking Not Supported" : "Reserved");
printf("\n");
}
static char *pif_to_string(__u8 pif, bool qpifs, bool pif_field)
{
switch (pif) {
case NVME_NVM_PIF_16B_GUARD:
return "16b Guard";
case NVME_NVM_PIF_32B_GUARD:
return "32b Guard";
case NVME_NVM_PIF_64B_GUARD:
return "64b Guard";
case NVME_NVM_PIF_QTYPE:
if (pif_field && qpifs)
return "Qualified Type";
default:
return "Reserved";
}
}
static void stdout_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)
{
int i, verbose = stdout_print_ops.flags & VERBOSE;
bool qpifs = (nvm_ns->pic & 0x8) >> 3;
__u32 elbaf;
int pif, sts;
__u8 lbaf;
int pif, sts, qpif;
char *in_use = "(in use)";
nvme_id_ns_flbas_to_lbaf_inuse(ns->flbas, &lbaf);
if (!cap_only) {
printf("NVMe NVM Identify Namespace %d:\n", nsid);
printf("lbstm : %#"PRIx64"\n", le64_to_cpu(nvm_ns->lbstm));
@ -3074,22 +3139,26 @@ static void stdout_nvm_id_ns(struct nvme_nvm_id_ns *nvm_ns, unsigned int nsid,
printf("pic : %#x\n", nvm_ns->pic);
if (verbose)
stdout_nvm_id_ns_pic(nvm_ns->pic);
printf("pifa : %#x\n", nvm_ns->pifa);
if (verbose)
stdout_nvm_id_ns_pifa(nvm_ns->pifa);
for (i = 0; i <= ns->nlbaf + ns->nulbaf; i++) {
elbaf = le32_to_cpu(nvm_ns->elbaf[i]);
qpif = (elbaf >> 9) & 0xF;
pif = (elbaf >> 7) & 0x3;
sts = elbaf & 0x7f;
if (verbose)
printf("Extended LBA Format %2d : Protection Information Format: "
"%s(%d) - Storage Tag Size (MSB): %-2d %s\n",
i, pif == 3 ? "Reserved" :
pif == 2 ? "64b Guard" :
pif == 1 ? "32b Guard" : "16b Guard",
pif, sts, i == (ns->flbas & 0xf) ? in_use : "");
printf("Extended LBA Format %2d : Qualified Protection Information Format: "
"%s(%d) - Protection Information Format: %s(%d) - Storage Tag Size "
"(MSB): %-2d %s\n", i, pif_to_string(qpif, qpifs, false), qpif,
pif_to_string(pif, qpifs, true), pif, sts, i == lbaf ? in_use : "");
else
printf("elbaf %2d : pif:%d sts:%-2d %s\n", i,
pif, sts, i == (ns->flbas & 0xf) ? in_use : "");
printf("elbaf %2d : qpif:%d pif:%d sts:%-2d %s\n", i,
qpif, pif, sts, i == lbaf ? in_use : "");
}
if (ns->nsfeat & 0x20)
printf("npdgl : %#x\n", le32_to_cpu(nvm_ns->npdgl));
}
static void stdout_zns_id_ctrl(struct nvme_zns_id_ctrl *ctrl)
@ -3199,9 +3268,9 @@ static void stdout_zns_id_ns(struct nvme_zns_id_ns *ns,
stdout_zns_id_ns_recommended_limit(ns->rrl1, human, "rrl1");
stdout_zns_id_ns_recommended_limit(ns->rrl2, human, "rrl2");
stdout_zns_id_ns_recommended_limit(ns->rrl3, human, "rrl3");
stdout_zns_id_ns_recommended_limit(ns->frl, human, "frl1");
stdout_zns_id_ns_recommended_limit(ns->frl, human, "frl2");
stdout_zns_id_ns_recommended_limit(ns->frl, human, "frl3");
stdout_zns_id_ns_recommended_limit(ns->frl1, human, "frl1");
stdout_zns_id_ns_recommended_limit(ns->frl2, human, "frl2");
stdout_zns_id_ns_recommended_limit(ns->frl3, human, "frl3");
printf("numzrwa : %#x\n", le32_to_cpu(ns->numzrwa));
printf("zrwafg : %u\n", le16_to_cpu(ns->zrwafg));
@ -3833,80 +3902,79 @@ static void stdout_endurance_log(struct nvme_endurance_group_log *endurance_log,
uint128_t_to_l10n_string(le128_to_cpu(endurance_log->unalloc_end_grp_cap)));
}
static void stdout_smart_log(struct nvme_smart_log *smart, unsigned int nsid,
const char *devname)
static void stdout_smart_log(struct nvme_smart_log *smart, unsigned int nsid, const char *devname)
{
__u16 temperature = smart->temperature[1] << 8 | smart->temperature[0];
int i;
bool human = stdout_print_ops.flags & VERBOSE;
printf("Smart Log for NVME device:%s namespace-id:%x\n", devname, nsid);
printf("critical_warning : %#x\n",
smart->critical_warning);
printf("critical_warning : %#x\n", smart->critical_warning);
if (human) {
printf(" Available Spare[0] : %d\n", smart->critical_warning & 0x01);
printf(" Temp. Threshold[1] : %d\n", (smart->critical_warning & 0x02) >> 1);
printf(" NVM subsystem Reliability[2] : %d\n", (smart->critical_warning & 0x04) >> 2);
printf(" Read-only[3] : %d\n", (smart->critical_warning & 0x08) >> 3);
printf(" Volatile mem. backup failed[4] : %d\n", (smart->critical_warning & 0x10) >> 4);
printf(" Persistent Mem. RO[5] : %d\n", (smart->critical_warning & 0x20) >> 5);
printf(" Available Spare[0] : %d\n",
smart->critical_warning & 0x01);
printf(" Temp. Threshold[1] : %d\n",
(smart->critical_warning & 0x02) >> 1);
printf(" NVM subsystem Reliability[2] : %d\n",
(smart->critical_warning & 0x04) >> 2);
printf(" Read-only[3] : %d\n",
(smart->critical_warning & 0x08) >> 3);
printf(" Volatile mem. backup failed[4] : %d\n",
(smart->critical_warning & 0x10) >> 4);
printf(" Persistent Mem. RO[5] : %d\n",
(smart->critical_warning & 0x20) >> 5);
}
printf("temperature : %ld °C (%u K)\n",
kelvin_to_celsius(temperature), temperature);
printf("available_spare : %u%%\n",
smart->avail_spare);
printf("available_spare_threshold : %u%%\n",
smart->spare_thresh);
printf("percentage_used : %u%%\n",
smart->percent_used);
printf("endurance group critical warning summary: %#x\n",
smart->endu_grp_crit_warn_sumry);
printf("temperature : %s (%u K)\n",
nvme_degrees_string(temperature), temperature);
printf("available_spare : %u%%\n", smart->avail_spare);
printf("available_spare_threshold : %u%%\n", smart->spare_thresh);
printf("percentage_used : %u%%\n", smart->percent_used);
printf("endurance group critical warning summary: %#x\n", smart->endu_grp_crit_warn_sumry);
printf("Data Units Read : %s (%s)\n",
uint128_t_to_l10n_string(le128_to_cpu(smart->data_units_read)),
uint128_t_to_si_string(le128_to_cpu(smart->data_units_read),
1000 * 512));
uint128_t_to_l10n_string(le128_to_cpu(smart->data_units_read)),
uint128_t_to_si_string(le128_to_cpu(smart->data_units_read), 1000 * 512));
printf("Data Units Written : %s (%s)\n",
uint128_t_to_l10n_string(le128_to_cpu(smart->data_units_written)),
uint128_t_to_si_string(le128_to_cpu(smart->data_units_written),
1000 * 512));
uint128_t_to_l10n_string(le128_to_cpu(smart->data_units_written)),
uint128_t_to_si_string(le128_to_cpu(smart->data_units_written), 1000 * 512));
printf("host_read_commands : %s\n",
uint128_t_to_l10n_string(le128_to_cpu(smart->host_reads)));
uint128_t_to_l10n_string(le128_to_cpu(smart->host_reads)));
printf("host_write_commands : %s\n",
uint128_t_to_l10n_string(le128_to_cpu(smart->host_writes)));
uint128_t_to_l10n_string(le128_to_cpu(smart->host_writes)));
printf("controller_busy_time : %s\n",
uint128_t_to_l10n_string(le128_to_cpu(smart->ctrl_busy_time)));
uint128_t_to_l10n_string(le128_to_cpu(smart->ctrl_busy_time)));
printf("power_cycles : %s\n",
uint128_t_to_l10n_string(le128_to_cpu(smart->power_cycles)));
uint128_t_to_l10n_string(le128_to_cpu(smart->power_cycles)));
printf("power_on_hours : %s\n",
uint128_t_to_l10n_string(le128_to_cpu(smart->power_on_hours)));
uint128_t_to_l10n_string(le128_to_cpu(smart->power_on_hours)));
printf("unsafe_shutdowns : %s\n",
uint128_t_to_l10n_string(le128_to_cpu(smart->unsafe_shutdowns)));
uint128_t_to_l10n_string(le128_to_cpu(smart->unsafe_shutdowns)));
printf("media_errors : %s\n",
uint128_t_to_l10n_string(le128_to_cpu(smart->media_errors)));
uint128_t_to_l10n_string(le128_to_cpu(smart->media_errors)));
printf("num_err_log_entries : %s\n",
uint128_t_to_l10n_string(le128_to_cpu(smart->num_err_log_entries)));
uint128_t_to_l10n_string(le128_to_cpu(smart->num_err_log_entries)));
printf("Warning Temperature Time : %u\n",
le32_to_cpu(smart->warning_temp_time));
le32_to_cpu(smart->warning_temp_time));
printf("Critical Composite Temperature Time : %u\n",
le32_to_cpu(smart->critical_comp_time));
for (i = 0; i < 8; i++) {
__s32 temp = le16_to_cpu(smart->temp_sensor[i]);
le32_to_cpu(smart->critical_comp_time));
if (temp == 0)
for (i = 0; i < ARRAY_SIZE(smart->temp_sensor); i++) {
temperature = le16_to_cpu(smart->temp_sensor[i]);
if (!temperature)
continue;
printf("Temperature Sensor %d : %ld °C (%u K)\n",
i + 1, kelvin_to_celsius(temp), temp);
printf("Temperature Sensor %d : %s (%u K)\n", i + 1,
nvme_degrees_string(temperature), temperature);
}
printf("Thermal Management T1 Trans Count : %u\n",
le32_to_cpu(smart->thm_temp1_trans_count));
le32_to_cpu(smart->thm_temp1_trans_count));
printf("Thermal Management T2 Trans Count : %u\n",
le32_to_cpu(smart->thm_temp2_trans_count));
le32_to_cpu(smart->thm_temp2_trans_count));
printf("Thermal Management T1 Total Time : %u\n",
le32_to_cpu(smart->thm_temp1_total_time));
le32_to_cpu(smart->thm_temp1_total_time));
printf("Thermal Management T2 Total Time : %u\n",
le32_to_cpu(smart->thm_temp2_total_time));
le32_to_cpu(smart->thm_temp2_total_time));
}
static void stdout_ana_log(struct nvme_ana_log *ana_log, const char *devname,
@ -4408,8 +4476,8 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
field = (result & 0x000f0000) >> 16;
printf("\tThreshold Temperature Select (TMPSEL): %u - %s\n",
field, nvme_feature_temp_sel_to_string(field));
printf("\tTemperature Threshold (TMPTH): %ld °C (%u K)\n",
kelvin_to_celsius(result & 0x0000ffff), result & 0x0000ffff);
printf("\tTemperature Threshold (TMPTH): %s (%u K)\n",
nvme_degrees_string(result & 0x0000ffff), result & 0x0000ffff);
break;
case NVME_FEAT_FID_ERR_RECOVERY:
printf("\tDeallocated or Unwritten Logical Block Error Enable (DULBE): %s\n",
@ -4463,6 +4531,10 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
break;
case NVME_FEAT_FID_HOST_MEM_BUF:
printf("\tEnable Host Memory (EHM): %s\n", (result & 0x00000001) ? "Enabled" : "Disabled");
printf("\tHost Memory Non-operational Access Restriction Enable (HMNARE): %s\n",
(result & 0x00000004) ? "True" : "False");
printf("\tHost Memory Non-operational Access Restricted (HMNAR): %s\n",
(result & 0x00000008) ? "True" : "False");
if (buf)
stdout_host_mem_buffer((struct nvme_host_mem_buf_attrs *)buf);
break;
@ -4474,10 +4546,10 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
printf("\tKeep Alive Timeout (KATO) in milliseconds: %u\n", result);
break;
case NVME_FEAT_FID_HCTM:
printf("\tThermal Management Temperature 1 (TMT1) : %u K (%ld °C)\n",
result >> 16, kelvin_to_celsius(result >> 16));
printf("\tThermal Management Temperature 2 (TMT2) : %u K (%ld °C)\n",
result & 0x0000ffff, kelvin_to_celsius(result & 0x0000ffff));
printf("\tThermal Management Temperature 1 (TMT1) : %u K (%s)\n",
result >> 16, nvme_degrees_string(result >> 16));
printf("\tThermal Management Temperature 2 (TMT2) : %u K (%s)\n",
result & 0x0000ffff, nvme_degrees_string(result & 0x0000ffff));
break;
case NVME_FEAT_FID_NOPSC:
printf("\tNon-Operational Power State Permissive Mode Enable (NOPPME): %s\n",
@ -5001,18 +5073,11 @@ static void stdout_simple_topology(nvme_root_t r,
nvme_for_each_host(r, h) {
nvme_for_each_subsystem(h, s) {
int len = strlen(nvme_subsystem_get_name(s));
if (!first)
printf("\n");
first = false;
printf("%s - NQN=%s\n", nvme_subsystem_get_name(s),
nvme_subsystem_get_nqn(s));
printf("%*s hostnqn=%s\n", len, " ",
nvme_host_get_hostnqn(nvme_subsystem_get_host(s)));
printf("%*s iopolicy=%s\n", len, " ",
nvme_subsystem_get_iopolicy(s));
stdout_subsys_config(s);
printf("\\\n");
if (nvme_is_multipath(s))
@ -5176,7 +5241,7 @@ static struct print_ops stdout_print_ops = {
.show_error_status = stdout_error_status,
};
struct print_ops *nvme_get_stdout_print_ops(enum nvme_print_flags flags)
struct print_ops *nvme_get_stdout_print_ops(nvme_print_flags_t flags)
{
stdout_print_ops.flags = flags;
return &stdout_print_ops;