Merge remote-tracking branch 'oss/master' into initial-windows-support-for-meson-build-system

Author: bcapener

.github/workflows/upload.yml

@@ -48,7 +48,7 @@ jobs:
     name: upload test binary
     runs-on: ubuntu-latest
     needs: build-static
-    if: ${{ github.event_name == 'push' || github.event_name == 'release' && github.repository == 'linux-nvme/nvme-cli' }}
+    if: ${{ (github.event_name == 'push' || github.event_name == 'release') && github.repository == 'linux-nvme/nvme-cli' }}
     steps:
       - uses: actions/download-artifact@70fc10c6e5e1ce46ad2ea6f2b72d43f7d47b13c3 # v8.0.0
         with:

libnvme/src/nvme/cmds.c

@@ -563,6 +563,7 @@ int nvme_get_feature_length(int fid, __u32 cdw11, enum nvme_data_tfr dir,
 	case NVME_FEAT_FID_RESV_PERSIST:
 	case NVME_FEAT_FID_WRITE_PROTECT:
 	case NVME_FEAT_FID_POWER_LIMIT:
+	case NVME_FEAT_FID_POWER_MEASUREMENT:
 		*len = 0;
 		break;
 	case NVME_FEAT_FID_ENH_CTRL_METADATA:

libnvme/src/nvme/types.h

@@ -1092,6 +1092,16 @@ enum nvme_power_measurement_type {
 	NVME_PMT_VS_MAX		 = 0xf,
 };
 
+/**
+ * enum nvme_power_measurement_action - Power measurement actions.
+ * @NVME_PMA_STOP:  Stop power measurement
+ * @NVME_PMA_START: Start power measurement
+ */
+enum nvme_power_measurement_action {
+	NVME_PMA_STOP	= 0x0,
+	NVME_PMA_START	= 0x1,
+};
+
 /**
  * nvme_psd_power_scale() - power scale occupies the upper 3 bits
  * @ps: power scale value
@@ -8835,7 +8845,7 @@ enum nvme_cmd_get_log_lid {
  * @NVME_FEAT_FID_CONF_DEV_PERSONALITY: Configurable Device Personality
  * @NVME_FEAT_FID_POWER_LIMIT:		Power Limit
  * @NVME_FEAT_FID_POWER_THRESH:		Power Threshold
- * @NVME_FEAT_FID_POEWR_MEASUREMENT:	Power Measurement
+ * @NVME_FEAT_FID_POWER_MEASUREMENT:	Power Measurement
  * @NVME_FEAT_FID_EMB_MGMT_CTRL_ADDR:	Embedded Management Controller Address
  * @NVME_FEAT_FID_HOST_MGMT_AGENT_ADDR:	Host Management Agent Address
  * @NVME_FEAT_FID_ENH_CTRL_METADATA:	Enhanced Controller Metadata
@@ -8885,7 +8895,7 @@ enum nvme_features_id {
 	NVME_FEAT_FID_CONF_DEV_PERSONALITY			= 0x22,
 	NVME_FEAT_FID_POWER_LIMIT				= 0x23,
 	NVME_FEAT_FID_POWER_THRESH				= 0x24,
-	NVME_FEAT_FID_POEWR_MEASUREMENT				= 0x25,
+	NVME_FEAT_FID_POWER_MEASUREMENT				= 0x25,
 	NVME_FEAT_FID_EMB_MGMT_CTRL_ADDR			= 0x78,
 	NVME_FEAT_FID_HOST_MGMT_AGENT_ADDR			= 0x79,
 	NVME_FEAT_FID_ENH_CTRL_METADATA				= 0x7d,
@@ -9041,6 +9051,8 @@ enum nvme_features_id {
  * @NVME_FEAT_FDP_INDEX_MASK:
  * @NVME_FEAT_FDP_EVENTS_ENABLE_SHIFT:
  * @NVME_FEAT_FDP_EVENTS_ENABLE_MASK:
+ * @NVME_FEAT_HOST_ID_EXHID_SHIFT:
+ * @NVME_FEAT_HOST_ID_EXHID_MASK:
  * @NVME_FEAT_BPWPC_BP0WPS_SHIFT:
  * @NVME_FEAT_BPWPC_BP0WPS_MASK:
  * @NVME_FEAT_BPWPC_BP1WPS_SHIFT:
@@ -9065,6 +9077,12 @@ enum nvme_features_id {
  * @NVME_FEAT_POWER_THRESH_PMTS_MASK:
  * @NVME_FEAT_POWER_THRESH_EPT_SHIFT:
  * @NVME_FEAT_POWER_THRESH_EPT_MASK:
+ * @NVME_FEAT_POWER_MEAS_ACT_SHIFT:
+ * @NVME_FEAT_POWER_MEAS_ACT_MASK:
+ * @NVME_FEAT_POWER_MEAS_PMTS_SHIFT:
+ * @NVME_FEAT_POWER_MEAS_PMTS_MASK:
+ * @NVME_FEAT_POWER_MEAS_SMT_SHIFT:
+ * @NVME_FEAT_POWER_MEAS_SMT_MASK:
  **/
 enum nvme_feat {
 	NVME_FEAT_ARBITRATION_BURST_SHIFT	= 0,
@@ -9211,6 +9229,8 @@ enum nvme_feat {
 	NVME_FEAT_FDP_INDEX_MASK	= 0xf,
 	NVME_FEAT_FDP_EVENTS_ENABLE_SHIFT = 0,
 	NVME_FEAT_FDP_EVENTS_ENABLE_MASK  = 0x1,
+	NVME_FEAT_HOST_ID_EXHID_SHIFT	= 0,
+	NVME_FEAT_HOST_ID_EXHID_MASK	= 0x1,
 	NVME_FEAT_BPWPC_BP0WPS_SHIFT	= 0,
 	NVME_FEAT_BPWPC_BP0WPS_MASK	= 0x7,
 	NVME_FEAT_BPWPC_BP1WPS_SHIFT	= 3,
@@ -9231,6 +9251,12 @@ enum nvme_feat {
 	NVME_FEAT_POWER_THRESH_PMTS_MASK = 0xf,
 	NVME_FEAT_POWER_THRESH_EPT_SHIFT = 31,
 	NVME_FEAT_POWER_THRESH_EPT_MASK	= 0x1,
+	NVME_FEAT_POWER_MEAS_ACT_SHIFT	= 0,
+	NVME_FEAT_POWER_MEAS_ACT_MASK	= 0xf,
+	NVME_FEAT_POWER_MEAS_PMTS_SHIFT	= 4,
+	NVME_FEAT_POWER_MEAS_PMTS_MASK	= 0xf,
+	NVME_FEAT_POWER_MEAS_SMT_SHIFT	= 16,
+	NVME_FEAT_POWER_MEAS_SMT_MASK	= 0xffff,
 };
 
 /**
@@ -10514,6 +10540,10 @@ static inline void nvme_feature_decode_arbitration(__u32 value, __u8 *ab,
 #define NVME_FEAT_POWER_THRESH_PMTS(v)	NVME_GET(v, FEAT_POWER_THRESH_PMTS)
 #define NVME_FEAT_POWER_THRESH_EPT(v)	NVME_GET(v, FEAT_POWER_THRESH_EPT)
 
+#define NVME_FEAT_POWER_MEAS_ACT(v)	NVME_GET(v, FEAT_POWER_MEAS_ACT)
+#define NVME_FEAT_POWER_MEAS_PMTS(v)	NVME_GET(v, FEAT_POWER_MEAS_PMTS)
+#define NVME_FEAT_POWER_MEAS_SMT(v)	NVME_GET(v, FEAT_POWER_MEAS_SMT)
+
 static inline void
 nvme_feature_decode_power_mgmt(__u32 value, __u8 *ps, __u8 *wh)
 {
@@ -10732,6 +10762,14 @@ nvme_feature_decode_perf_characteristics(__u32 value, __u8 *attri, bool *rvspa)
 	*rvspa = NVME_FEAT_PERFC_RVSPA(value);
 }
 
+#define NVME_FEAT_HOST_ID_EXHID(v) NVME_GET(v, FEAT_HOST_ID_EXHID)
+
+static inline void
+nvme_feature_decode_host_id(__u32 value, bool *exhid)
+{
+	*exhid = NVME_FEAT_HOST_ID_EXHID(value);
+}
+
 #define NVME_FEAT_SPM_PBSLC(v)		NVME_GET(v, FEAT_SPM_PBSLC)
 
 static inline void

nvme-print-json.c

@@ -4133,10 +4133,12 @@ static void json_feature_show_fields_power_limit(struct json_object *r,
 static void json_feature_show_fields_power_thresh(struct json_object *r,
 						  unsigned int result)
 {
-	__u8 field = NVME_FEAT_POWER_THRESH_EPT(result);
-
+	__u8 field;
+	__u16 ptv;
 	_cleanup_free_ char *k = NULL;
 
+	field = NVME_FEAT_POWER_THRESH_EPT(result);
+
 	obj_add_str(r, "Enable Power Threshold (EPT)",
 		    field ? "Enabled" : "Disabled");
 
@@ -4148,13 +4150,33 @@ static void json_feature_show_fields_power_thresh(struct json_object *r,
 	obj_add_str(r, "Power Threshold Scale (PTS)",
 		    nvme_feature_power_limit_scale_to_string(field));
 
-	field = NVME_FEAT_POWER_THRESH_PTV(result);
-	obj_add_uint(r, "Power Threshold Value (PTV)", field);
+	ptv = NVME_FEAT_POWER_THRESH_PTV(result);
+
+	obj_add_uint(r, "Power Threshold Value (PTV)", ptv);
 
-	k = get_power_and_scale(field, NVME_FEAT_POWER_THRESH_PTS(result));
+	k = get_power_and_scale(ptv, NVME_FEAT_POWER_THRESH_PTS(result));
 	obj_add_str(r, "Power Threshold", k);
 }
 
+static void json_feature_show_fields_power_meas(struct json_object *r,
+						unsigned int result)
+{
+	__u8 field;
+	__u16 smt;
+
+	field = NVME_FEAT_POWER_MEAS_ACT(result);
+	obj_add_str(r, "Action (ACT)",
+		nvme_power_measurement_action_to_string(field));
+
+	field = NVME_FEAT_POWER_MEAS_PMTS(result);
+	obj_add_str(r, "Power Measurement Type Select (PMTS)",
+		nvme_power_measurement_type_to_string(field));
+
+	smt = NVME_FEAT_POWER_MEAS_SMT(result);
+
+	obj_add_uint(r, "Stop Measurement Time (SMT)", smt);
+}
+
 static void json_feature_show(enum nvme_features_id fid, int sel, unsigned int result)
 {
 	struct json_object *r;
@@ -4300,6 +4322,9 @@ static void json_feature_show_fields(enum nvme_features_id fid, unsigned int res
 	case NVME_FEAT_FID_POWER_THRESH:
 		json_feature_show_fields_power_thresh(r, result);
 		break;
+	case NVME_FEAT_FID_POWER_MEASUREMENT:
+		json_feature_show_fields_power_meas(r, result);
+		break;
 	default:
 		break;
 	}

nvme-print-stdout.c

@@ -5083,7 +5083,7 @@ static void stdout_feat_perfc_vs(struct nvme_vs_perf_attr *data)
 	d((unsigned char *)data->vs, data->attrl, 16, 1);
 }
 
-static void stdout_feat_perfc(enum nvme_features_id fid, unsigned int result,
+static void stdout_feat_perfc(unsigned int result,
 			      struct nvme_perf_characteristics *data)
 {
 	__u8 attri;
@@ -5133,6 +5133,29 @@ static void stdout_host_metadata(enum nvme_features_id fid,
 	}
 }
 
+static void stdout_feat_host_id(unsigned int result, unsigned char *hostid)
+{
+	uint64_t ull;
+	bool exhid;
+
+	if (!hostid)
+		return;
+
+	nvme_feature_decode_host_id(result, &exhid);
+
+	if (exhid) {
+		printf("\tHost Identifier (HOSTID):  %s\n",
+		       uint128_t_to_l10n_string(le128_to_cpu(hostid)));
+		return;
+	}
+
+	ull =  hostid[7]; ull <<= 8; ull |= hostid[6]; ull <<= 8;
+	ull |= hostid[5]; ull <<= 8; ull |= hostid[4]; ull <<= 8;
+	ull |= hostid[3]; ull <<= 8; ull |= hostid[2]; ull <<= 8;
+	ull |= hostid[1]; ull <<= 8; ull |= hostid[0];
+	printf("\tHost Identifier (HOSTID):  %" PRIu64 "\n", ull);
+}
+
 static void stdout_feature_show(enum nvme_features_id fid, int sel, unsigned int result)
 {
 	printf("get-feature:%#0*x (%s), %s value:%#0*x\n", fid ? 4 : 2, fid,
@@ -5146,7 +5169,6 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
 	const char *async = "Send async event";
 	const char *no_async = "Do not send async event";
 	__u8 field;
-	uint64_t ull;
 
 	switch (fid) {
 	case NVME_FEAT_FID_ARBITRATION:
@@ -5342,7 +5364,8 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
 		       nvme_pls_mode_to_string(NVME_GET(result, FEAT_PLS_MODE)));
 		break;
 	case NVME_FEAT_FID_PERF_CHARACTERISTICS:
-		stdout_feat_perfc(fid, result, (struct nvme_perf_characteristics *)buf);
+		stdout_feat_perfc(result,
+				  (struct nvme_perf_characteristics *)buf);
 		break;
 	case NVME_FEAT_FID_ENH_CTRL_METADATA:
 	case NVME_FEAT_FID_CTRL_METADATA:
@@ -5354,12 +5377,7 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
 		printf("\tPre-boot Software Load Count (PBSLC): %u\n", NVME_FEAT_SPM_PBSLC(result));
 		break;
 	case NVME_FEAT_FID_HOST_ID:
-		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);
-		}
+		stdout_feat_host_id(result, buf);
 		break;
 	case NVME_FEAT_FID_RESV_MASK:
 		printf("\tMask Reservation Preempted Notification  (RESPRE): %s\n",
@@ -5427,6 +5445,16 @@ static void stdout_feature_show_fields(enum nvme_features_id fid,
 				      field);
 		printf("\n");
 		break;
+	case NVME_FEAT_FID_POWER_MEASUREMENT:
+		field = NVME_FEAT_POWER_MEAS_ACT(result);
+		printf("\tAction (ACT): %u - %s\n", field,
+		       nvme_power_measurement_action_to_string(field));
+		field = NVME_FEAT_POWER_MEAS_PMTS(result);
+		printf("\tPower Measurement Type Select (PMTS): %u - %s\n",
+		       field, nvme_power_measurement_type_to_string(field));
+		printf("\tStop Measurement Time (SMT): %u\n",
+		       NVME_FEAT_POWER_MEAS_SMT(result));
+		break;
 	default:
 		break;
 	}

nvme-print.c

@@ -952,7 +952,7 @@ const char *nvme_feature_to_string(enum nvme_features_id feature)
 	case NVME_FEAT_FID_CONF_DEV_PERSONALITY:return "Configurable Device Personality";
 	case NVME_FEAT_FID_POWER_LIMIT:		return "Power Limit";
 	case NVME_FEAT_FID_POWER_THRESH:	return "Power Threshold";
-	case NVME_FEAT_FID_POEWR_MEASUREMENT:	return "Power Measurement";
+	case NVME_FEAT_FID_POWER_MEASUREMENT:	return "Power Measurement";
 	case NVME_FEAT_FID_EMB_MGMT_CTRL_ADDR:	return "Embedded Management Controller Address";
 	case NVME_FEAT_FID_HOST_MGMT_AGENT_ADDR:return "Host Management Agent Address";
 	case NVME_FEAT_FID_ENH_CTRL_METADATA:	return "Enhanced Controller Metadata";
@@ -1526,6 +1526,21 @@ const char *nvme_power_measurement_type_to_string(__u8 pmt)
 	return "Reserved";
 }
 
+
+const char *nvme_power_measurement_action_to_string(__u8 act)
+{
+	switch (act) {
+	case 0:
+		return "Stop";
+	case 1:
+		return "Start";
+	default:
+		break;
+	}
+
+	return "Reserved";
+}
+
 void nvme_feature_show(enum nvme_features_id fid, int sel, unsigned int result)
 {
 	nvme_print(show_feature, NORMAL, fid, sel, result);

nvme-print.h

@@ -343,6 +343,7 @@ const char *nvme_pls_mode_to_string(__u8 mode);
 const char *nvme_bpwps_to_string(__u8 bpwps);
 const char *nvme_feature_power_limit_scale_to_string(__u8 pls);
 const char *nvme_power_measurement_type_to_string(__u8 pmt);
+const char *nvme_power_measurement_action_to_string(__u8 act);
 
 void nvme_dev_full_path(nvme_ns_t n, char *path, size_t len);
 void nvme_generic_full_path(nvme_ns_t n, char *path, size_t len);

nvme.c

@@ -4875,6 +4875,7 @@ static bool is_get_feature_result_set(enum nvme_features_id feature_id)
 {
 	switch (feature_id) {
 	case NVME_FEAT_FID_PERF_CHARACTERISTICS:
+	case NVME_FEAT_FID_HOST_ID:
 		return false;
 	default:
 		break;