Page MenuHomeFreeBSD
Files F102105263

D43597.id133517.diff
No OneTemporary
Actions

D43597.id133517.diff
View Options

diff --git a/sbin/nvmecontrol/devlist.c b/sbin/nvmecontrol/devlist.c
--- a/sbin/nvmecontrol/devlist.c
+++ b/sbin/nvmecontrol/devlist.c
@@ -82,10 +82,8 @@
{
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);
}
diff --git a/sbin/nvmecontrol/firmware.c b/sbin/nvmecontrol/firmware.c
--- a/sbin/nvmecontrol/firmware.c
+++ b/sbin/nvmecontrol/firmware.c
@@ -277,21 +277,18 @@
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,
diff --git a/sbin/nvmecontrol/format.c b/sbin/nvmecontrol/format.c
--- a/sbin/nvmecontrol/format.c
+++ b/sbin/nvmecontrol/format.c
@@ -159,38 +159,33 @@
/* 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. */
diff --git a/sbin/nvmecontrol/identify.c b/sbin/nvmecontrol/identify.c
--- a/sbin/nvmecontrol/identify.c
+++ b/sbin/nvmecontrol/identify.c
@@ -66,11 +66,9 @@
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 @@
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 @@
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" :
diff --git a/sbin/nvmecontrol/identify_ext.c b/sbin/nvmecontrol/identify_ext.c
--- a/sbin/nvmecontrol/identify_ext.c
+++ b/sbin/nvmecontrol/identify_ext.c
@@ -56,41 +56,27 @@
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 @@
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 @@
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 @@
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 @@
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" : "");
diff --git a/sbin/nvmecontrol/logpage.c b/sbin/nvmecontrol/logpage.c
--- a/sbin/nvmecontrol/logpage.c
+++ b/sbin/nvmecontrol/logpage.c
@@ -405,13 +405,10 @@
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 @@
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 @@
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 @@
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 @@
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
diff --git a/sbin/nvmecontrol/ns.c b/sbin/nvmecontrol/ns.c
--- a/sbin/nvmecontrol/ns.c
+++ b/sbin/nvmecontrol/ns.c
@@ -416,8 +416,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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));
diff --git a/sbin/nvmecontrol/power.c b/sbin/nvmecontrol/power.c
--- a/sbin/nvmecontrol/power.c
+++ b/sbin/nvmecontrol/power.c
@@ -62,14 +62,10 @@
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)
diff --git a/sbin/nvmecontrol/sanitize.c b/sbin/nvmecontrol/sanitize.c
--- a/sbin/nvmecontrol/sanitize.c
+++ b/sbin/nvmecontrol/sanitize.c
@@ -154,14 +154,11 @@
/* 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 @@
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;
diff --git a/sbin/nvmecontrol/selftest.c b/sbin/nvmecontrol/selftest.c
--- a/sbin/nvmecontrol/selftest.c
+++ b/sbin/nvmecontrol/selftest.c
@@ -99,8 +99,7 @@
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);

File Metadata

Mime Type
text/plain
Expires
Fri, Nov 8, 4:28 PM (21 h, 25 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
14536722
Default Alt Text
D43597.id133517.diff (33 KB)

Event Timeline