hardenedbsd/HardenedBSD
1
0
Fork 0
mirror of https://git.hardenedbsd.org/hardenedbsd/HardenedBSD.git synced 2024-11-14 22:32:30 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

nvmecontrol: Use the NVMEV macro instead of expanded versions

Browse Source 
Reviewed by:	imp
Sponsored by:	Chelsio Communications
Differential Revision:	https://reviews.freebsd.org/D43597
This commit is contained in:
John Baldwin 2024-01-29 10:34:02 -08:00
parent 2cb78e7150
commit fba73a4083
10 changed files with 167 additions and 262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
sbin/nvmecontrol/devlist.c
View File

@ -82,10 +82,8 @@ ns_get_sector_size(struct nvme_namespace_data *nsdata)
{
uint8_t flbas_fmt, lbads;
flbas_fmt = (nsdata->flbas >> NVME_NS_DATA_FLBAS_FORMAT_SHIFT) &
NVME_NS_DATA_FLBAS_FORMAT_MASK;
lbads = (nsdata->lbaf[flbas_fmt] >> NVME_NS_DATA_LBAF_LBADS_SHIFT) &
NVME_NS_DATA_LBAF_LBADS_MASK;
flbas_fmt = NVMEV(NVME_NS_DATA_FLBAS_FORMAT, nsdata->flbas);
lbads = NVMEV(NVME_NS_DATA_LBAF_LBADS, nsdata->lbaf[flbas_fmt]);
return (1 << lbads);
}

9
sbin/nvmecontrol/firmware.c
View File

@ -277,21 +277,18 @@ firmware(const struct cmd *f, int argc, char *argv[])
if (read_controller_data(fd, &cdata))
errx(EX_IOERR, "Identify request failed");
oacs_fw = (cdata.oacs >> NVME_CTRLR_DATA_OACS_FIRMWARE_SHIFT) &
NVME_CTRLR_DATA_OACS_FIRMWARE_MASK;
oacs_fw = NVMEV(NVME_CTRLR_DATA_OACS_FIRMWARE, cdata.oacs);
if (oacs_fw == 0)
errx(EX_UNAVAILABLE,
"controller does not support firmware activate/download");
fw_slot1_ro = (cdata.frmw >> NVME_CTRLR_DATA_FRMW_SLOT1_RO_SHIFT) &
NVME_CTRLR_DATA_FRMW_SLOT1_RO_MASK;
fw_slot1_ro = NVMEV(NVME_CTRLR_DATA_FRMW_SLOT1_RO, cdata.frmw);
if (opt.fw_img && opt.slot == 1 && fw_slot1_ro)
errx(EX_UNAVAILABLE, "slot %d is marked as read only", opt.slot);
fw_num_slots = (cdata.frmw >> NVME_CTRLR_DATA_FRMW_NUM_SLOTS_SHIFT) &
NVME_CTRLR_DATA_FRMW_NUM_SLOTS_MASK;
fw_num_slots = NVMEV(NVME_CTRLR_DATA_FRMW_NUM_SLOTS, cdata.frmw);
if (opt.slot > fw_num_slots)
errx(EX_UNAVAILABLE,

27
sbin/nvmecontrol/format.c
View File

@ -159,38 +159,33 @@ format(const struct cmd *f, int argc, char *argv[])
/* Check that controller can execute this command. */
if (read_controller_data(fd, &cd))
errx(EX_IOERR, "Identify request failed");
if (((cd.oacs >> NVME_CTRLR_DATA_OACS_FORMAT_SHIFT) &
NVME_CTRLR_DATA_OACS_FORMAT_MASK) == 0)
if (NVMEV(NVME_CTRLR_DATA_OACS_FORMAT, cd.oacs) == 0)
errx(EX_UNAVAILABLE, "controller does not support format");
if (((cd.fna >> NVME_CTRLR_DATA_FNA_CRYPTO_ERASE_SHIFT) &
NVME_CTRLR_DATA_FNA_CRYPTO_ERASE_MASK) == 0 && ses == SES_CRYPTO)
if (NVMEV(NVME_CTRLR_DATA_FNA_CRYPTO_ERASE, cd.fna) == 0 &&
ses == SES_CRYPTO)
errx(EX_UNAVAILABLE, "controller does not support cryptographic erase");
if (nsid != NVME_GLOBAL_NAMESPACE_TAG) {
if (((cd.fna >> NVME_CTRLR_DATA_FNA_FORMAT_ALL_SHIFT) &
NVME_CTRLR_DATA_FNA_FORMAT_ALL_MASK) && ses == SES_NONE)
if (NVMEV(NVME_CTRLR_DATA_FNA_FORMAT_ALL, cd.fna) &&
ses == SES_NONE)
errx(EX_UNAVAILABLE, "controller does not support per-NS format");
if (((cd.fna >> NVME_CTRLR_DATA_FNA_ERASE_ALL_SHIFT) &
NVME_CTRLR_DATA_FNA_ERASE_ALL_MASK) && ses != SES_NONE)
if (NVMEV(NVME_CTRLR_DATA_FNA_ERASE_ALL, cd.fna) &&
ses != SES_NONE)
errx(EX_UNAVAILABLE, "controller does not support per-NS erase");
/* Try to keep previous namespace parameters. */
if (read_namespace_data(fd, nsid, &nsd))
errx(EX_IOERR, "Identify request failed");
if (lbaf < 0)
lbaf = (nsd.flbas >> NVME_NS_DATA_FLBAS_FORMAT_SHIFT)
& NVME_NS_DATA_FLBAS_FORMAT_MASK;
lbaf = NVMEV(NVME_NS_DATA_FLBAS_FORMAT, nsd.flbas);
if (lbaf > nsd.nlbaf)
errx(EX_USAGE, "LBA format is out of range");
if (ms < 0)
ms = (nsd.flbas >> NVME_NS_DATA_FLBAS_EXTENDED_SHIFT)
& NVME_NS_DATA_FLBAS_EXTENDED_MASK;
ms = NVMEV(NVME_NS_DATA_FLBAS_EXTENDED, nsd.flbas);
if (pi < 0)
pi = (nsd.dps >> NVME_NS_DATA_DPS_MD_START_SHIFT)
& NVME_NS_DATA_DPS_MD_START_MASK;
pi = NVMEV(NVME_NS_DATA_DPS_MD_START, nsd.dps);
if (pil < 0)
pil = (nsd.dps >> NVME_NS_DATA_DPS_PIT_SHIFT)
& NVME_NS_DATA_DPS_PIT_MASK;
pil = NVMEV(NVME_NS_DATA_DPS_PIT, nsd.dps);
} else {
/* We have no previous parameters, so default to zeroes. */

109
sbin/nvmecontrol/identify.c
View File

@ -66,11 +66,9 @@ print_namespace(struct nvme_namespace_data *nsdata)
uint8_t thin_prov, ptype;
uint8_t flbas_fmt, t;
thin_prov = (nsdata->nsfeat >> NVME_NS_DATA_NSFEAT_THIN_PROV_SHIFT) &
NVME_NS_DATA_NSFEAT_THIN_PROV_MASK;
thin_prov = NVMEV(NVME_NS_DATA_NSFEAT_THIN_PROV, nsdata->nsfeat);
flbas_fmt = (nsdata->flbas >> NVME_NS_DATA_FLBAS_FORMAT_SHIFT) &
NVME_NS_DATA_FLBAS_FORMAT_MASK;
flbas_fmt = NVMEV(NVME_NS_DATA_FLBAS_FORMAT, nsdata->flbas);
printf("Size: %lld blocks\n",
(long long)nsdata->nsze);
@ -82,83 +80,77 @@ print_namespace(struct nvme_namespace_data *nsdata)
thin_prov ? "Supported" : "Not Supported");
printf("Number of LBA Formats: %d\n", nsdata->nlbaf+1);
printf("Current LBA Format: LBA Format #%02d", flbas_fmt);
if (nsdata->lbaf[flbas_fmt] >> NVME_NS_DATA_LBAF_MS_SHIFT & NVME_NS_DATA_LBAF_MS_MASK)
printf(" %s metadata\n", nsdata->flbas >> NVME_NS_DATA_FLBAS_EXTENDED_SHIFT &
NVME_NS_DATA_FLBAS_EXTENDED_MASK ? "Extended" : "Separate");
if (NVMEV(NVME_NS_DATA_LBAF_MS, nsdata->lbaf[flbas_fmt]) != 0)
printf(" %s metadata\n",
NVMEV(NVME_NS_DATA_FLBAS_EXTENDED, nsdata->flbas) != 0 ?
"Extended" : "Separate");
else
printf("\n");
printf("Metadata Capabilities\n");
printf(" Extended: %s\n",
nsdata->mc >> NVME_NS_DATA_MC_EXTENDED_SHIFT & NVME_NS_DATA_MC_EXTENDED_MASK ? "Supported" : "Not Supported");
NVMEV(NVME_NS_DATA_MC_EXTENDED, nsdata->mc) != 0 ? "Supported" :
"Not Supported");
printf(" Separate: %s\n",
nsdata->mc >> NVME_NS_DATA_MC_POINTER_SHIFT & NVME_NS_DATA_MC_POINTER_MASK ? "Supported" : "Not Supported");
NVMEV(NVME_NS_DATA_MC_POINTER, nsdata->mc) != 0 ? "Supported" :
"Not Supported");
printf("Data Protection Caps: %s%s%s%s%s%s\n",
(nsdata->dpc == 0) ? "Not Supported" : "",
((nsdata->dpc >> NVME_NS_DATA_DPC_MD_END_SHIFT) &
NVME_NS_DATA_DPC_MD_END_MASK) ? "Last Bytes, " : "",
((nsdata->dpc >> NVME_NS_DATA_DPC_MD_START_SHIFT) &
NVME_NS_DATA_DPC_MD_START_MASK) ? "First Bytes, " : "",
((nsdata->dpc >> NVME_NS_DATA_DPC_PIT3_SHIFT) &
NVME_NS_DATA_DPC_PIT3_MASK) ? "Type 3, " : "",
((nsdata->dpc >> NVME_NS_DATA_DPC_PIT2_SHIFT) &
NVME_NS_DATA_DPC_PIT2_MASK) ? "Type 2, " : "",
((nsdata->dpc >> NVME_NS_DATA_DPC_PIT1_SHIFT) &
NVME_NS_DATA_DPC_PIT1_MASK) ? "Type 1" : "");
NVMEV(NVME_NS_DATA_DPC_MD_END, nsdata->dpc) != 0 ? "Last Bytes, " :
"",
NVMEV(NVME_NS_DATA_DPC_MD_START, nsdata->dpc) != 0 ?
"First Bytes, " : "",
NVMEV(NVME_NS_DATA_DPC_PIT3, nsdata->dpc) != 0 ? "Type 3, " : "",
NVMEV(NVME_NS_DATA_DPC_PIT2, nsdata->dpc) != 0 ? "Type 2, " : "",
NVMEV(NVME_NS_DATA_DPC_PIT1, nsdata->dpc) != 0 ? "Type 1" : "");
printf("Data Protection Settings: ");
ptype = (nsdata->dps >> NVME_NS_DATA_DPS_PIT_SHIFT) &
NVME_NS_DATA_DPS_PIT_MASK;
if (ptype) {
ptype = NVMEV(NVME_NS_DATA_DPS_PIT, nsdata->dps);
if (ptype != 0) {
printf("Type %d, %s Bytes\n", ptype,
((nsdata->dps >> NVME_NS_DATA_DPS_MD_START_SHIFT) &
NVME_NS_DATA_DPS_MD_START_MASK) ? "First" : "Last");
NVMEV(NVME_NS_DATA_DPS_MD_START, nsdata->dps) != 0 ?
"First" : "Last");
} else {
printf("Not Enabled\n");
}
printf("Multi-Path I/O Capabilities: %s%s\n",
(nsdata->nmic == 0) ? "Not Supported" : "",
((nsdata->nmic >> NVME_NS_DATA_NMIC_MAY_BE_SHARED_SHIFT) &
NVME_NS_DATA_NMIC_MAY_BE_SHARED_MASK) ? "May be shared" : "");
NVMEV(NVME_NS_DATA_NMIC_MAY_BE_SHARED, nsdata->nmic) != 0 ?
"May be shared" : "");
printf("Reservation Capabilities: %s%s%s%s%s%s%s%s%s\n",
(nsdata->rescap == 0) ? "Not Supported" : "",
((nsdata->rescap >> NVME_NS_DATA_RESCAP_IEKEY13_SHIFT) &
NVME_NS_DATA_RESCAP_IEKEY13_MASK) ? "IEKEY13, " : "",
((nsdata->rescap >> NVME_NS_DATA_RESCAP_EX_AC_AR_SHIFT) &
NVME_NS_DATA_RESCAP_EX_AC_AR_MASK) ? "EX_AC_AR, " : "",
((nsdata->rescap >> NVME_NS_DATA_RESCAP_WR_EX_AR_SHIFT) &
NVME_NS_DATA_RESCAP_WR_EX_AR_MASK) ? "WR_EX_AR, " : "",
((nsdata->rescap >> NVME_NS_DATA_RESCAP_EX_AC_RO_SHIFT) &
NVME_NS_DATA_RESCAP_EX_AC_RO_MASK) ? "EX_AC_RO, " : "",
((nsdata->rescap >> NVME_NS_DATA_RESCAP_WR_EX_RO_SHIFT) &
NVME_NS_DATA_RESCAP_WR_EX_RO_MASK) ? "WR_EX_RO, " : "",
((nsdata->rescap >> NVME_NS_DATA_RESCAP_EX_AC_SHIFT) &
NVME_NS_DATA_RESCAP_EX_AC_MASK) ? "EX_AC, " : "",
((nsdata->rescap >> NVME_NS_DATA_RESCAP_WR_EX_SHIFT) &
NVME_NS_DATA_RESCAP_WR_EX_MASK) ? "WR_EX, " : "",
((nsdata->rescap >> NVME_NS_DATA_RESCAP_PTPL_SHIFT) &
NVME_NS_DATA_RESCAP_PTPL_MASK) ? "PTPL" : "");
NVMEV(NVME_NS_DATA_RESCAP_IEKEY13, nsdata->rescap) != 0 ?
"IEKEY13, " : "",
NVMEV(NVME_NS_DATA_RESCAP_EX_AC_AR, nsdata->rescap) != 0 ?
"EX_AC_AR, " : "",
NVMEV(NVME_NS_DATA_RESCAP_WR_EX_AR, nsdata->rescap) != 0 ?
"WR_EX_AR, " : "",
NVMEV(NVME_NS_DATA_RESCAP_EX_AC_RO, nsdata->rescap) != 0 ?
"EX_AC_RO, " : "",
NVMEV(NVME_NS_DATA_RESCAP_WR_EX_RO, nsdata->rescap) != 0 ?
"WR_EX_RO, " : "",
NVMEV(NVME_NS_DATA_RESCAP_EX_AC, nsdata->rescap) != 0 ?
"EX_AC, " : "",
NVMEV(NVME_NS_DATA_RESCAP_WR_EX, nsdata->rescap) != 0 ?
"WR_EX, " : "",
NVMEV(NVME_NS_DATA_RESCAP_PTPL, nsdata->rescap) != 0 ? "PTPL" : "");
printf("Format Progress Indicator: ");
if ((nsdata->fpi >> NVME_NS_DATA_FPI_SUPP_SHIFT) &
NVME_NS_DATA_FPI_SUPP_MASK) {
if (NVMEV(NVME_NS_DATA_FPI_SUPP, nsdata->fpi) != 0) {
printf("%u%% remains\n",
(nsdata->fpi >> NVME_NS_DATA_FPI_PERC_SHIFT) &
NVME_NS_DATA_FPI_PERC_MASK);
NVMEV(NVME_NS_DATA_FPI_PERC, nsdata->fpi));
} else
printf("Not Supported\n");
t = (nsdata->dlfeat >> NVME_NS_DATA_DLFEAT_READ_SHIFT) &
NVME_NS_DATA_DLFEAT_READ_MASK;
t = NVMEV(NVME_NS_DATA_DLFEAT_READ, nsdata->dlfeat);
printf("Deallocate Logical Block: Read %s%s%s\n",
(t == NVME_NS_DATA_DLFEAT_READ_NR) ? "Not Reported" :
(t == NVME_NS_DATA_DLFEAT_READ_00) ? "00h" :
(t == NVME_NS_DATA_DLFEAT_READ_FF) ? "FFh" : "Unknown",
(nsdata->dlfeat >> NVME_NS_DATA_DLFEAT_DWZ_SHIFT) &
NVME_NS_DATA_DLFEAT_DWZ_MASK ? ", Write Zero" : "",
(nsdata->dlfeat >> NVME_NS_DATA_DLFEAT_GCRC_SHIFT) &
NVME_NS_DATA_DLFEAT_GCRC_MASK ? ", Guard CRC" : "");
NVMEV(NVME_NS_DATA_DLFEAT_DWZ, nsdata->dlfeat) != 0 ?
", Write Zero" : "",
NVMEV(NVME_NS_DATA_DLFEAT_GCRC, nsdata->dlfeat) != 0 ?
", Guard CRC" : "");
printf("Optimal I/O Boundary: %u blocks\n", nsdata->noiob);
printf("NVM Capacity: %s bytes\n",
uint128_to_str(to128(nsdata->nvmcap), cbuf, sizeof(cbuf)));
if ((nsdata->nsfeat >> NVME_NS_DATA_NSFEAT_NPVALID_SHIFT) &
NVME_NS_DATA_NSFEAT_NPVALID_MASK) {
if (NVMEV(NVME_NS_DATA_NSFEAT_NPVALID, nsdata->nsfeat) != 0) {
printf("Preferred Write Granularity: %u blocks\n",
nsdata->npwg + 1);
printf("Preferred Write Alignment: %u blocks\n",
@ -180,14 +172,11 @@ print_namespace(struct nvme_namespace_data *nsdata)
printf("\n");
for (i = 0; i <= nsdata->nlbaf; i++) {
lbaf = nsdata->lbaf[i];
lbads = (lbaf >> NVME_NS_DATA_LBAF_LBADS_SHIFT) &
NVME_NS_DATA_LBAF_LBADS_MASK;
lbads = NVMEV(NVME_NS_DATA_LBAF_LBADS, lbaf);
if (lbads == 0)
continue;
ms = (lbaf >> NVME_NS_DATA_LBAF_MS_SHIFT) &
NVME_NS_DATA_LBAF_MS_MASK;
rp = (lbaf >> NVME_NS_DATA_LBAF_RP_SHIFT) &
NVME_NS_DATA_LBAF_RP_MASK;
ms = NVMEV(NVME_NS_DATA_LBAF_MS, lbaf);
rp = NVMEV(NVME_NS_DATA_LBAF_RP, lbaf);
printf("LBA Format #%02d: Data Size: %5d Metadata Size: %5d"
" Performance: %s\n",
i, 1 << lbads, ms, (rp == 0) ? "Best" :

149
sbin/nvmecontrol/identify_ext.c
View File

@ -56,41 +56,27 @@ nvme_print_controller(struct nvme_controller_data *cdata)
uint8_t fwug;
oncs = cdata->oncs;
compare = (oncs >> NVME_CTRLR_DATA_ONCS_COMPARE_SHIFT) &
NVME_CTRLR_DATA_ONCS_COMPARE_MASK;
write_unc = (oncs >> NVME_CTRLR_DATA_ONCS_WRITE_UNC_SHIFT) &
NVME_CTRLR_DATA_ONCS_WRITE_UNC_MASK;
dsm = (oncs >> NVME_CTRLR_DATA_ONCS_DSM_SHIFT) &
NVME_CTRLR_DATA_ONCS_DSM_MASK;
compare = NVMEV(NVME_CTRLR_DATA_ONCS_COMPARE, oncs);
write_unc = NVMEV(NVME_CTRLR_DATA_ONCS_WRITE_UNC, oncs);
dsm = NVMEV(NVME_CTRLR_DATA_ONCS_DSM, oncs);
oacs = cdata->oacs;
security = (oacs >> NVME_CTRLR_DATA_OACS_SECURITY_SHIFT) &
NVME_CTRLR_DATA_OACS_SECURITY_MASK;
fmt = (oacs >> NVME_CTRLR_DATA_OACS_FORMAT_SHIFT) &
NVME_CTRLR_DATA_OACS_FORMAT_MASK;
fw = (oacs >> NVME_CTRLR_DATA_OACS_FIRMWARE_SHIFT) &
NVME_CTRLR_DATA_OACS_FIRMWARE_MASK;
nsmgmt = (oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) &
NVME_CTRLR_DATA_OACS_NSMGMT_MASK;
security = NVMEV(NVME_CTRLR_DATA_OACS_SECURITY, oacs);
fmt = NVMEV(NVME_CTRLR_DATA_OACS_FORMAT, oacs);
fw = NVMEV(NVME_CTRLR_DATA_OACS_FIRMWARE, oacs);
nsmgmt = NVMEV(NVME_CTRLR_DATA_OACS_NSMGMT, oacs);
fw_num_slots = (cdata->frmw >> NVME_CTRLR_DATA_FRMW_NUM_SLOTS_SHIFT) &
NVME_CTRLR_DATA_FRMW_NUM_SLOTS_MASK;
fw_slot1_ro = (cdata->frmw >> NVME_CTRLR_DATA_FRMW_SLOT1_RO_SHIFT) &
NVME_CTRLR_DATA_FRMW_SLOT1_RO_MASK;
fw_num_slots = NVMEV(NVME_CTRLR_DATA_FRMW_NUM_SLOTS, cdata->frmw);
fw_slot1_ro = NVMEV(NVME_CTRLR_DATA_FRMW_SLOT1_RO, cdata->frmw);
fwug = cdata->fwug;
ns_smart = (cdata->lpa >> NVME_CTRLR_DATA_LPA_NS_SMART_SHIFT) &
NVME_CTRLR_DATA_LPA_NS_SMART_MASK;
ns_smart = NVMEV(NVME_CTRLR_DATA_LPA_NS_SMART, cdata->lpa);
sqes_min = (cdata->sqes >> NVME_CTRLR_DATA_SQES_MIN_SHIFT) &
NVME_CTRLR_DATA_SQES_MIN_MASK;
sqes_max = (cdata->sqes >> NVME_CTRLR_DATA_SQES_MAX_SHIFT) &
NVME_CTRLR_DATA_SQES_MAX_MASK;
sqes_min = NVMEV(NVME_CTRLR_DATA_SQES_MIN, cdata->sqes);
sqes_max = NVMEV(NVME_CTRLR_DATA_SQES_MAX, cdata->sqes);
cqes_min = (cdata->cqes >> NVME_CTRLR_DATA_CQES_MIN_SHIFT) &
NVME_CTRLR_DATA_CQES_MIN_MASK;
cqes_max = (cdata->cqes >> NVME_CTRLR_DATA_CQES_MAX_SHIFT) &
NVME_CTRLR_DATA_CQES_MAX_MASK;
cqes_min = NVMEV(NVME_CTRLR_DATA_CQES_MIN, cdata->cqes);
cqes_max = NVMEV(NVME_CTRLR_DATA_CQES_MAX, cdata->cqes);
printf("Controller Capabilities/Features\n");
printf("================================\n");
@ -107,14 +93,14 @@ nvme_print_controller(struct nvme_controller_data *cdata)
cdata->ieee[2], cdata->ieee[1], cdata->ieee[0]);
printf("Multi-Path I/O Capabilities: %s%s%s%s%s\n",
(cdata->mic == 0) ? "Not Supported" : "",
((cdata->mic >> NVME_CTRLR_DATA_MIC_ANAR_SHIFT) &
NVME_CTRLR_DATA_MIC_SRIOVVF_MASK) ? "Asymmetric, " : "",
((cdata->mic >> NVME_CTRLR_DATA_MIC_SRIOVVF_SHIFT) &
NVME_CTRLR_DATA_MIC_SRIOVVF_MASK) ? "SR-IOV VF, " : "",
((cdata->mic >> NVME_CTRLR_DATA_MIC_MCTRLRS_SHIFT) &
NVME_CTRLR_DATA_MIC_MCTRLRS_MASK) ? "Multiple controllers, " : "",
((cdata->mic >> NVME_CTRLR_DATA_MIC_MPORTS_SHIFT) &
NVME_CTRLR_DATA_MIC_MPORTS_MASK) ? "Multiple ports" : "");
NVMEV(NVME_CTRLR_DATA_MIC_ANAR, cdata->mic) != 0 ?
"Asymmetric, " : "",
NVMEV(NVME_CTRLR_DATA_MIC_SRIOVVF, cdata->mic) != 0 ?
"SR-IOV VF, " : "",
NVMEV(NVME_CTRLR_DATA_MIC_MCTRLRS, cdata->mic) != 0 ?
"Multiple controllers, " : "",
NVMEV(NVME_CTRLR_DATA_MIC_MPORTS, cdata->mic) != 0 ?
"Multiple ports" : "");
/* TODO: Use CAP.MPSMIN to determine true memory page size. */
printf("Max Data Transfer Size: ");
if (cdata->mdts == 0)
@ -122,24 +108,19 @@ nvme_print_controller(struct nvme_controller_data *cdata)
else
printf("%ld bytes\n", PAGE_SIZE * (1L << cdata->mdts));
printf("Sanitize Crypto Erase: %s\n",
((cdata->sanicap >> NVME_CTRLR_DATA_SANICAP_CES_SHIFT) &
NVME_CTRLR_DATA_SANICAP_CES_MASK) ?
"Supported" : "Not Supported");
NVMEV(NVME_CTRLR_DATA_SANICAP_CES, cdata->sanicap) != 0 ?
"Supported" : "Not Supported");
printf("Sanitize Block Erase: %s\n",
((cdata->sanicap >> NVME_CTRLR_DATA_SANICAP_BES_SHIFT) &
NVME_CTRLR_DATA_SANICAP_BES_MASK) ?
"Supported" : "Not Supported");
NVMEV(NVME_CTRLR_DATA_SANICAP_BES, cdata->sanicap) != 0 ?
"Supported" : "Not Supported");
printf("Sanitize Overwrite: %s\n",
((cdata->sanicap >> NVME_CTRLR_DATA_SANICAP_OWS_SHIFT) &
NVME_CTRLR_DATA_SANICAP_OWS_MASK) ?
"Supported" : "Not Supported");
NVMEV(NVME_CTRLR_DATA_SANICAP_OWS, cdata->sanicap) != 0 ?
"Supported" : "Not Supported");
printf("Sanitize NDI: %s\n",
((cdata->sanicap >> NVME_CTRLR_DATA_SANICAP_NDI_SHIFT) &
NVME_CTRLR_DATA_SANICAP_NDI_MASK) ?
"Supported" : "Not Supported");
NVMEV(NVME_CTRLR_DATA_SANICAP_NDI, cdata->sanicap) != 0 ?
"Supported" : "Not Supported");
printf("Sanitize NODMMAS: ");
switch (((cdata->sanicap >> NVME_CTRLR_DATA_SANICAP_NODMMAS_SHIFT) &
NVME_CTRLR_DATA_SANICAP_NODMMAS_MASK)) {
switch (NVMEV(NVME_CTRLR_DATA_SANICAP_NODMMAS, cdata->sanicap)) {
case NVME_CTRLR_DATA_SANICAP_NODMMAS_UNDEF:
printf("Undefined\n");
break;
@ -170,32 +151,26 @@ nvme_print_controller(struct nvme_controller_data *cdata)
printf("Namespace Management: %s\n",
nsmgmt ? "Supported" : "Not Supported");
printf("Device Self-test: %sSupported\n",
((oacs >> NVME_CTRLR_DATA_OACS_SELFTEST_SHIFT) &
NVME_CTRLR_DATA_OACS_SELFTEST_MASK) ? "" : "Not ");
NVMEV(NVME_CTRLR_DATA_OACS_SELFTEST, oacs) != 0 ? "" : "Not ");
printf("Directives: %sSupported\n",
((oacs >> NVME_CTRLR_DATA_OACS_DIRECTIVES_SHIFT) &
NVME_CTRLR_DATA_OACS_DIRECTIVES_MASK) ? "" : "Not ");
NVMEV(NVME_CTRLR_DATA_OACS_DIRECTIVES, oacs) != 0 ? "" : "Not ");
printf("NVMe-MI Send/Receive: %sSupported\n",
((oacs >> NVME_CTRLR_DATA_OACS_NVMEMI_SHIFT) &
NVME_CTRLR_DATA_OACS_NVMEMI_MASK) ? "" : "Not ");
NVMEV(NVME_CTRLR_DATA_OACS_NVMEMI, oacs) != 0 ? "" : "Not ");
printf("Virtualization Management: %sSupported\n",
((oacs >> NVME_CTRLR_DATA_OACS_VM_SHIFT) &
NVME_CTRLR_DATA_OACS_VM_MASK) ? "" : "Not ");
NVMEV(NVME_CTRLR_DATA_OACS_VM, oacs) != 0 ? "" : "Not ");
printf("Doorbell Buffer Config: %sSupported\n",
((oacs >> NVME_CTRLR_DATA_OACS_DBBUFFER_SHIFT) &
NVME_CTRLR_DATA_OACS_DBBUFFER_MASK) ? "" : "Not ");
NVMEV(NVME_CTRLR_DATA_OACS_DBBUFFER, oacs) != 0 ? "" : "Not ");
printf("Get LBA Status: %sSupported\n",
((oacs >> NVME_CTRLR_DATA_OACS_GETLBA_SHIFT) &
NVME_CTRLR_DATA_OACS_GETLBA_MASK) ? "" : "Not ");
NVMEV(NVME_CTRLR_DATA_OACS_GETLBA, oacs) != 0 ? "" : "Not ");
printf("Sanitize: ");
if (cdata->sanicap != 0) {
printf("%s%s%s\n",
((cdata->sanicap >> NVME_CTRLR_DATA_SANICAP_CES_SHIFT) &
NVME_CTRLR_DATA_SANICAP_CES_MASK) ? "crypto, " : "",
((cdata->sanicap >> NVME_CTRLR_DATA_SANICAP_BES_SHIFT) &
NVME_CTRLR_DATA_SANICAP_BES_MASK) ? "block, " : "",
((cdata->sanicap >> NVME_CTRLR_DATA_SANICAP_OWS_SHIFT) &
NVME_CTRLR_DATA_SANICAP_OWS_MASK) ? "overwrite" : "");
NVMEV(NVME_CTRLR_DATA_SANICAP_CES, cdata->sanicap) != 0 ?
"crypto, " : "",
NVMEV(NVME_CTRLR_DATA_SANICAP_BES, cdata->sanicap) != 0 ?
"block, " : "",
NVMEV(NVME_CTRLR_DATA_SANICAP_OWS, cdata->sanicap) != 0 ?
"overwrite" : "");
} else {
printf("Not Supported\n");
}
@ -244,36 +219,30 @@ nvme_print_controller(struct nvme_controller_data *cdata)
printf("Dataset Management Command: %s\n",
dsm ? "Supported" : "Not Supported");
printf("Write Zeroes Command: %sSupported\n",
((oncs >> NVME_CTRLR_DATA_ONCS_WRZERO_SHIFT) &
NVME_CTRLR_DATA_ONCS_WRZERO_MASK) ? "" : "Not ");
NVMEV(NVME_CTRLR_DATA_ONCS_WRZERO, oncs) != 0 ? "" : "Not ");
printf("Save Features: %sSupported\n",
((oncs >> NVME_CTRLR_DATA_ONCS_SAVEFEAT_SHIFT) &
NVME_CTRLR_DATA_ONCS_SAVEFEAT_MASK) ? "" : "Not ");
NVMEV(NVME_CTRLR_DATA_ONCS_SAVEFEAT, oncs) != 0 ? "" : "Not ");
printf("Reservations: %sSupported\n",
((oncs >> NVME_CTRLR_DATA_ONCS_RESERV_SHIFT) &
NVME_CTRLR_DATA_ONCS_RESERV_MASK) ? "" : "Not ");
NVMEV(NVME_CTRLR_DATA_ONCS_RESERV, oncs) != 0 ? "" : "Not ");
printf("Timestamp feature: %sSupported\n",
((oncs >> NVME_CTRLR_DATA_ONCS_TIMESTAMP_SHIFT) &
NVME_CTRLR_DATA_ONCS_TIMESTAMP_MASK) ? "" : "Not ");
NVMEV(NVME_CTRLR_DATA_ONCS_TIMESTAMP, oncs) != 0 ? "" : "Not ");
printf("Verify feature: %sSupported\n",
((oncs >> NVME_CTRLR_DATA_ONCS_VERIFY_SHIFT) &
NVME_CTRLR_DATA_ONCS_VERIFY_MASK) ? "" : "Not ");
NVMEV(NVME_CTRLR_DATA_ONCS_VERIFY, oncs) != 0 ? "" : "Not ");
printf("Fused Operation Support: %s%s\n",
(cdata->fuses == 0) ? "Not Supported" : "",
((cdata->fuses >> NVME_CTRLR_DATA_FUSES_CNW_SHIFT) &
NVME_CTRLR_DATA_FUSES_CNW_MASK) ? "Compare and Write" : "");
NVMEV(NVME_CTRLR_DATA_FUSES_CNW, cdata->fuses) != 0 ?
"Compare and Write" : "");
printf("Format NVM Attributes: %s%s Erase, %s Format\n",
((cdata->fna >> NVME_CTRLR_DATA_FNA_CRYPTO_ERASE_SHIFT) &
NVME_CTRLR_DATA_FNA_CRYPTO_ERASE_MASK) ? "Crypto Erase, " : "",
((cdata->fna >> NVME_CTRLR_DATA_FNA_ERASE_ALL_SHIFT) &
NVME_CTRLR_DATA_FNA_ERASE_ALL_MASK) ? "All-NVM" : "Per-NS",
((cdata->fna >> NVME_CTRLR_DATA_FNA_FORMAT_ALL_SHIFT) &
NVME_CTRLR_DATA_FNA_FORMAT_ALL_MASK) ? "All-NVM" : "Per-NS");
t = (cdata->vwc >> NVME_CTRLR_DATA_VWC_ALL_SHIFT) &
NVME_CTRLR_DATA_VWC_ALL_MASK;
NVMEV(NVME_CTRLR_DATA_FNA_CRYPTO_ERASE, cdata->fna) != 0 ?
"Crypto Erase, " : "",
NVMEV(NVME_CTRLR_DATA_FNA_ERASE_ALL, cdata->fna) != 0 ?
"All-NVM" : "Per-NS",
NVMEV(NVME_CTRLR_DATA_FNA_FORMAT_ALL, cdata->fna) != 0 ?
"All-NVM" : "Per-NS");
t = NVMEV(NVME_CTRLR_DATA_VWC_ALL, cdata->vwc);
printf("Volatile Write Cache: %s%s\n",
((cdata->vwc >> NVME_CTRLR_DATA_VWC_PRESENT_SHIFT) &
NVME_CTRLR_DATA_VWC_PRESENT_MASK) ? "Present" : "Not Present",
NVMEV(NVME_CTRLR_DATA_VWC_PRESENT, cdata->vwc) != 0 ?
"Present" : "Not Present",
(t == NVME_CTRLR_DATA_VWC_ALL_NO) ? ", no flush all" :
(t == NVME_CTRLR_DATA_VWC_ALL_YES) ? ", flush all" : "");

63
sbin/nvmecontrol/logpage.c
View File

@ -405,13 +405,10 @@ print_log_firmware(const struct nvme_controller_data *cdata, void *buf, uint32_t
uint16_t oacs_fw;
uint8_t fw_num_slots;
afi_slot = fw->afi >> NVME_FIRMWARE_PAGE_AFI_SLOT_SHIFT;
afi_slot &= NVME_FIRMWARE_PAGE_AFI_SLOT_MASK;
afi_slot = NVMEV(NVME_FIRMWARE_PAGE_AFI_SLOT, fw->afi);
oacs_fw = (cdata->oacs >> NVME_CTRLR_DATA_OACS_FIRMWARE_SHIFT) &
NVME_CTRLR_DATA_OACS_FIRMWARE_MASK;
fw_num_slots = (cdata->frmw >> NVME_CTRLR_DATA_FRMW_NUM_SLOTS_SHIFT) &
NVME_CTRLR_DATA_FRMW_NUM_SLOTS_MASK;
oacs_fw = NVMEV(NVME_CTRLR_DATA_OACS_FIRMWARE, cdata->oacs);
fw_num_slots = NVMEV(NVME_CTRLR_DATA_FRMW_NUM_SLOTS, cdata->frmw);
printf("Firmware Slot Log\n");
printf("=================\n");
@ -471,41 +468,27 @@ print_log_command_effects(const struct nvme_controller_data *cdata __unused,
for (i = 0; i < 255; i++) {
s = ce->acs[i];
if (((s >> NVME_CE_PAGE_CSUP_SHIFT) &
NVME_CE_PAGE_CSUP_MASK) == 0)
if (NVMEV(NVME_CE_PAGE_CSUP, s) == 0)
continue;
printf("Admin\t%02x\t%s\t%s\t%s\t%s\t%u\t%s\n", i,
((s >> NVME_CE_PAGE_LBCC_SHIFT) &
NVME_CE_PAGE_LBCC_MASK) ? "Yes" : "No",
((s >> NVME_CE_PAGE_NCC_SHIFT) &
NVME_CE_PAGE_NCC_MASK) ? "Yes" : "No",
((s >> NVME_CE_PAGE_NIC_SHIFT) &
NVME_CE_PAGE_NIC_MASK) ? "Yes" : "No",
((s >> NVME_CE_PAGE_CCC_SHIFT) &
NVME_CE_PAGE_CCC_MASK) ? "Yes" : "No",
((s >> NVME_CE_PAGE_CSE_SHIFT) &
NVME_CE_PAGE_CSE_MASK),
((s >> NVME_CE_PAGE_UUID_SHIFT) &
NVME_CE_PAGE_UUID_MASK) ? "Yes" : "No");
NVMEV(NVME_CE_PAGE_LBCC, s) != 0 ? "Yes" : "No",
NVMEV(NVME_CE_PAGE_NCC, s) != 0 ? "Yes" : "No",
NVMEV(NVME_CE_PAGE_NIC, s) != 0 ? "Yes" : "No",
NVMEV(NVME_CE_PAGE_CCC, s) != 0 ? "Yes" : "No",
NVMEV(NVME_CE_PAGE_CSE, s),
NVMEV(NVME_CE_PAGE_UUID, s) != 0 ? "Yes" : "No");
}
for (i = 0; i < 255; i++) {
s = ce->iocs[i];
if (((s >> NVME_CE_PAGE_CSUP_SHIFT) &
NVME_CE_PAGE_CSUP_MASK) == 0)
if (NVMEV(NVME_CE_PAGE_CSUP, s) == 0)
continue;
printf("I/O\t%02x\t%s\t%s\t%s\t%s\t%u\t%s\n", i,
((s >> NVME_CE_PAGE_LBCC_SHIFT) &
NVME_CE_PAGE_LBCC_MASK) ? "Yes" : "No",
((s >> NVME_CE_PAGE_NCC_SHIFT) &
NVME_CE_PAGE_NCC_MASK) ? "Yes" : "No",
((s >> NVME_CE_PAGE_NIC_SHIFT) &
NVME_CE_PAGE_NIC_MASK) ? "Yes" : "No",
((s >> NVME_CE_PAGE_CCC_SHIFT) &
NVME_CE_PAGE_CCC_MASK) ? "Yes" : "No",
((s >> NVME_CE_PAGE_CSE_SHIFT) &
NVME_CE_PAGE_CSE_MASK),
((s >> NVME_CE_PAGE_UUID_SHIFT) &
NVME_CE_PAGE_UUID_MASK) ? "Yes" : "No");
NVMEV(NVME_CE_PAGE_LBCC, s) != 0 ? "Yes" : "No",
NVMEV(NVME_CE_PAGE_NCC, s) != 0 ? "Yes" : "No",
NVMEV(NVME_CE_PAGE_NIC, s) != 0 ? "Yes" : "No",
NVMEV(NVME_CE_PAGE_CCC, s) != 0 ? "Yes" : "No",
NVMEV(NVME_CE_PAGE_CSE, s),
NVMEV(NVME_CE_PAGE_UUID, s) != 0 ? "Yes" : "No");
}
}
@ -556,8 +539,7 @@ print_log_sanitize_status(const struct nvme_controller_data *cdata __unused,
printf("Sanitize Progress: %u%% (%u/65535)\n",
(ss->sprog * 100 + 32768) / 65536, ss->sprog);
printf("Sanitize Status: ");
switch ((ss->sstat >> NVME_SS_PAGE_SSTAT_STATUS_SHIFT) &
NVME_SS_PAGE_SSTAT_STATUS_MASK) {
switch (NVMEV(NVME_SS_PAGE_SSTAT_STATUS, ss->sstat)) {
case NVME_SS_PAGE_SSTAT_STATUS_NEVER:
printf("Never sanitized");
break;
@ -577,12 +559,10 @@ print_log_sanitize_status(const struct nvme_controller_data *cdata __unused,
printf("Unknown");
break;
}
p = (ss->sstat >> NVME_SS_PAGE_SSTAT_PASSES_SHIFT) &
NVME_SS_PAGE_SSTAT_PASSES_MASK;
p = NVMEV(NVME_SS_PAGE_SSTAT_PASSES, ss->sstat);
if (p > 0)
printf(", %d passes", p);
if ((ss->sstat >> NVME_SS_PAGE_SSTAT_GDE_SHIFT) &
NVME_SS_PAGE_SSTAT_GDE_MASK)
if (NVMEV(NVME_SS_PAGE_SSTAT_GDE, ss->sstat) != 0)
printf(", Global Data Erased");
printf("\n");
printf("Sanitize Command Dword 10: 0x%x\n", ss->scdw10);
@ -804,8 +784,7 @@ logpage(const struct cmd *f, int argc, char *argv[])
if (read_controller_data(fd, &cdata))
errx(EX_IOERR, "Identify request failed");
ns_smart = (cdata.lpa >> NVME_CTRLR_DATA_LPA_NS_SMART_SHIFT) &
NVME_CTRLR_DATA_LPA_NS_SMART_MASK;
ns_smart = NVMEV(NVME_CTRLR_DATA_LPA_NS_SMART, cdata.lpa);
/*
* The log page attributes indicate whether or not the controller

39
sbin/nvmecontrol/ns.c
View File

@ -416,8 +416,7 @@ nsactive(const struct cmd *f, int argc, char *argv[])
errx(EX_IOERR, "Identify request failed");
/* Check that controller can execute this command. */
if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) &
NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0)
if (NVMEV(NVME_CTRLR_DATA_OACS_NSMGMT, cd.oacs) == 0)
errx(EX_UNAVAILABLE, "controller does not support namespace management");
memset(&pt, 0, sizeof(pt));
@ -462,8 +461,7 @@ nsallocated(const struct cmd *f, int argc, char *argv[])
errx(EX_IOERR, "Identify request failed");
/* Check that controller can execute this command. */
if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) &
NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0)
if (NVMEV(NVME_CTRLR_DATA_OACS_NSMGMT, cd.oacs) == 0)
errx(EX_UNAVAILABLE, "controller does not support namespace management");
memset(&pt, 0, sizeof(pt));
@ -508,8 +506,7 @@ nscontrollers(const struct cmd *f, int argc, char *argv[])
errx(EX_IOERR, "Identify request failed");
/* Check that controller can execute this command. */
if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) &
NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0)
if (NVMEV(NVME_CTRLR_DATA_OACS_NSMGMT, cd.oacs) == 0)
errx(EX_UNAVAILABLE, "controller does not support namespace management");
memset(&pt, 0, sizeof(pt));
@ -570,8 +567,7 @@ nscreate(const struct cmd *f, int argc, char *argv[])
errx(EX_IOERR, "Identify request failed");
/* Check that controller can execute this command. */
if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) &
NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0)
if (NVMEV(NVME_CTRLR_DATA_OACS_NSMGMT, cd.oacs) == 0)
errx(EX_UNAVAILABLE, "controller does not support namespace management");
memset(&nsdata, 0, sizeof(nsdata));
@ -629,8 +625,7 @@ nscreate(const struct cmd *f, int argc, char *argv[])
if (nvme_completion_is_error(&pt.cpl)) {
errx(EX_IOERR, "namespace creation failed: %s",
get_res_str((pt.cpl.status >> NVME_STATUS_SC_SHIFT) &
NVME_STATUS_SC_MASK));
get_res_str(NVMEV(NVME_STATUS_SC, pt.cpl.status)));
}
printf("namespace %d created\n", pt.cpl.cdw0);
exit(0);
@ -666,8 +661,7 @@ nsdelete(const struct cmd *f, int argc, char *argv[])
errx(EX_IOERR, "Identify request failed");
/* Check that controller can execute this command. */
if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) &
NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0)
if (NVMEV(NVME_CTRLR_DATA_OACS_NSMGMT, cd.oacs) == 0)
errx(EX_UNAVAILABLE, "controller does not support namespace management");
memset(&pt, 0, sizeof(pt));
@ -683,8 +677,7 @@ nsdelete(const struct cmd *f, int argc, char *argv[])
if (nvme_completion_is_error(&pt.cpl)) {
errx(EX_IOERR, "namespace deletion failed: %s",
get_res_str((pt.cpl.status >> NVME_STATUS_SC_SHIFT) &
NVME_STATUS_SC_MASK));
get_res_str(NVMEV(NVME_STATUS_SC, pt.cpl.status)));
}
printf("namespace %d deleted\n", nsid);
exit(0);
@ -733,8 +726,7 @@ nsattach(const struct cmd *f, int argc, char *argv[])
errx(EX_IOERR, "Identify request failed");
/* Check that controller can execute this command. */
if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) &
NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0)
if (NVMEV(NVME_CTRLR_DATA_OACS_NSMGMT, cd.oacs) == 0)
errx(EX_UNAVAILABLE, "controller does not support namespace management");
if (attach_opt.ctrlrid == NONE) {
@ -770,8 +762,7 @@ nsattach(const struct cmd *f, int argc, char *argv[])
if (nvme_completion_is_error(&pt.cpl)) {
errx(EX_IOERR, "namespace attach failed: %s",
get_res_str((pt.cpl.status >> NVME_STATUS_SC_SHIFT) &
NVME_STATUS_SC_MASK));
get_res_str(NVMEV(NVME_STATUS_SC, pt.cpl.status)));
}
printf("namespace %d attached\n", nsid);
exit(0);
@ -805,8 +796,7 @@ nsdetach(const struct cmd *f, int argc, char *argv[])
errx(EX_IOERR, "Identify request failed");
/* Check that controller can execute this command. */
if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) &
NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0)
if (NVMEV(NVME_CTRLR_DATA_OACS_NSMGMT, cd.oacs) == 0)
errx(EX_UNAVAILABLE, "controller does not support namespace management");
if (detach_opt.ctrlrid == NONE) {
@ -849,8 +839,7 @@ nsdetach(const struct cmd *f, int argc, char *argv[])
if (nvme_completion_is_error(&pt.cpl)) {
errx(EX_IOERR, "namespace detach failed: %s",
get_res_str((pt.cpl.status >> NVME_STATUS_SC_SHIFT) &
NVME_STATUS_SC_MASK));
get_res_str(NVMEV(NVME_STATUS_SC, pt.cpl.status)));
}
printf("namespace %d detached\n", nsid);
exit(0);
@ -884,8 +873,7 @@ nsattached(const struct cmd *f, int argc, char *argv[])
errx(EX_IOERR, "Identify request failed");
/* Check that controller can execute this command. */
if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) &
NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0)
if (NVMEV(NVME_CTRLR_DATA_OACS_NSMGMT, cd.oacs) == 0)
errx(EX_UNAVAILABLE, "controller does not support namespace management");
memset(&pt, 0, sizeof(pt));
@ -938,8 +926,7 @@ nsidentify(const struct cmd *f, int argc, char *argv[])
errx(EX_IOERR, "Identify request failed");
/* Check that controller can execute this command. */
if (((cd.oacs >> NVME_CTRLR_DATA_OACS_NSMGMT_SHIFT) &
NVME_CTRLR_DATA_OACS_NSMGMT_MASK) == 0)
if (NVMEV(NVME_CTRLR_DATA_OACS_NSMGMT, cd.oacs) == 0)
errx(EX_UNAVAILABLE, "controller does not support namespace management");
memset(&pt, 0, sizeof(pt));

12
sbin/nvmecontrol/power.c
View File

@ -62,14 +62,10 @@ power_list_one(int i, struct nvme_power_state *nps)
int mpower, apower, ipower;
uint8_t mps, nops, aps, apw;
mps = (nps->mps_nops >> NVME_PWR_ST_MPS_SHIFT) &
NVME_PWR_ST_MPS_MASK;
nops = (nps->mps_nops >> NVME_PWR_ST_NOPS_SHIFT) &
NVME_PWR_ST_NOPS_MASK;
apw = (nps->apw_aps >> NVME_PWR_ST_APW_SHIFT) &
NVME_PWR_ST_APW_MASK;
aps = (nps->apw_aps >> NVME_PWR_ST_APS_SHIFT) &
NVME_PWR_ST_APS_MASK;
mps = NVMEV(NVME_PWR_ST_MPS, nps->mps_nops);
nops = NVMEV(NVME_PWR_ST_NOPS, nps->mps_nops);
apw = NVMEV(NVME_PWR_ST_APW, nps->apw_aps);
aps = NVMEV(NVME_PWR_ST_APS, nps->apw_aps);
mpower = nps->mp;
if (mps == 0)

12
sbin/nvmecontrol/sanitize.c
View File

@ -154,14 +154,11 @@ sanitize(const struct cmd *f, int argc, char *argv[])
/* Check that controller can execute this command. */
if (read_controller_data(fd, &cd))
errx(EX_IOERR, "Identify request failed");
if (((cd.sanicap >> NVME_CTRLR_DATA_SANICAP_BES_SHIFT) &
NVME_CTRLR_DATA_SANICAP_BES_MASK) == 0 && sanact == 2)
if (NVMEV(NVME_CTRLR_DATA_SANICAP_BES, cd.sanicap) == 0 && sanact == 2)
errx(EX_UNAVAILABLE, "controller does not support Block Erase");
if (((cd.sanicap >> NVME_CTRLR_DATA_SANICAP_OWS_SHIFT) &
NVME_CTRLR_DATA_SANICAP_OWS_MASK) == 0 && sanact == 3)
if (NVMEV(NVME_CTRLR_DATA_SANICAP_OWS, cd.sanicap) == 0 && sanact == 3)
errx(EX_UNAVAILABLE, "controller does not support Overwrite");
if (((cd.sanicap >> NVME_CTRLR_DATA_SANICAP_CES_SHIFT) &
NVME_CTRLR_DATA_SANICAP_CES_MASK) == 0 && sanact == 4)
if (NVMEV(NVME_CTRLR_DATA_SANICAP_CES, cd.sanicap) == 0 && sanact == 4)
errx(EX_UNAVAILABLE, "controller does not support Crypto Erase");
/*
@ -186,8 +183,7 @@ sanitize(const struct cmd *f, int argc, char *argv[])
wait:
read_logpage(fd, NVME_LOG_SANITIZE_STATUS,
NVME_GLOBAL_NAMESPACE_TAG, 0, 0, 0, &ss, sizeof(ss));
switch ((ss.sstat >> NVME_SS_PAGE_SSTAT_STATUS_SHIFT) &
NVME_SS_PAGE_SSTAT_STATUS_MASK) {
switch (NVMEV(NVME_SS_PAGE_SSTAT_STATUS, ss.sstat)) {
case NVME_SS_PAGE_SSTAT_STATUS_NEVER:
printf("Never sanitized");
break;

3
sbin/nvmecontrol/selftest.c
View File

@ -99,8 +99,7 @@ selftest(const struct cmd *f, int argc, char *argv[])
if (read_controller_data(fd, &cdata))
errx(EX_IOERR, "Identify request failed");
if (((cdata.oacs >> NVME_CTRLR_DATA_OACS_SELFTEST_SHIFT) &
NVME_CTRLR_DATA_OACS_SELFTEST_MASK) == 0)
if (NVMEV(NVME_CTRLR_DATA_OACS_SELFTEST, cdata.oacs) == 0)
errx(EX_UNAVAILABLE, "controller does not support self-test");
selftest_op(fd, nsid, opt.stc);