mi: Add ISH bit (admin command cflags)

Add ish bit for mi admin commands that access media

Spec NVM-Express-Management-Interface-Specification
     -Revision-2.1-2025.08.01-Ratified
Figure 136: NVMe Admin Command Request Description
Command Flags (CFLGS): Bit 2 : Ignore Shutdown (ISH)
This bit shall have no effect on the value of the CSTS.SHST field.

(193 page from spec)
If an NVMe Admin Command does not require access to media, then the ISH
bit shall have no effect on the processing of that NVMe Admin Command.

spec NVM-Express-Base-Specification-Revision-2.3-2025.08.01-Ratified
Figure 84: Admin Commands Permitted to Return a Status Code of Admin
           Command Media Not Ready

From Figure 84, we can assume that below Admin commands access media
Capacity Management, Device Self-test, Firmware Commit,
Firmware Image Download, Get LBA Status, Get Log Page,
Namespace Attachment, Namespace Management, Format NVM, Sanitize,
Sanitize Namespace, Security Receive, Security Send, Vendor Specific

Signed-off-by: Steven Seungcheol Lee <[email protected]>
Reported-by: Hojin Ahn <[email protected]>

Author: sc108-lee

libnvme/examples/mi-mctp.c

@@ -565,7 +565,7 @@ int do_security_info(nvme_mi_ep_t ep, int argc, char **argv)
 		return -1;
 	}
 
-	nvme_init_security_receive(&cmd, 0, 0, 0, 0, 0, data, data_len);
+	nvme_init_security_receive(&cmd, false, 0, 0, 0, 0, 0, data, data_len);
 	rc = nvme_submit_admin_passthru(hdl, &cmd);
 	if (rc) {
 		warnx("can't perform Security Receive command: rc %d", rc);

libnvme/src/nvme/ioctl.c

@@ -188,6 +188,10 @@ int nvme_submit_admin_passthru(struct nvme_transport_handle *hdl,
 {
 	switch (hdl->type) {
 	case NVME_TRANSPORT_HANDLE_TYPE_DIRECT:
+		cmd->flags = 0; /*
+				 * Not supported: intended for command flags
+				 * (eg: SGL, FUSE)
+				 */
 		if (hdl->ioctl64)
 			return nvme_submit_passthru64(hdl,
 				NVME_IOCTL_ADMIN64_CMD, cmd);

libnvme/src/nvme/ioctl.h

@@ -229,15 +229,15 @@ bool nvme_transport_handle_is_mi(struct nvme_transport_handle *hdl)
 	return hdl->type == NVME_TRANSPORT_HANDLE_TYPE_MI;
 }
 
-int nvme_fw_download_seq(struct nvme_transport_handle *hdl, __u32 size,
-		__u32 xfer, __u32 offset, void *buf)
+int nvme_fw_download_seq(struct nvme_transport_handle *hdl, bool ish,
+		__u32 size, __u32 xfer, __u32 offset, void *buf)
 {
 	struct nvme_passthru_cmd cmd;
 	void *data = buf;
 	int err = 0;
 
 	while (size > 0) {
-		err = nvme_init_fw_download(&cmd, data, MIN(xfer, size), offset);
+		err = nvme_init_fw_download(&cmd, ish, data, MIN(xfer, size), offset);
 		if (err)
 			break;
 		err = nvme_submit_admin_passthru(hdl, &cmd);
@@ -525,31 +525,31 @@ int nvme_get_lba_status_log(struct nvme_transport_handle *hdl, bool rae, struct
 	return 0;
 }
 
-static int nvme_ns_attachment(struct nvme_transport_handle *hdl, __u32 nsid,
-		__u16 num_ctrls, __u16 *ctrlist, bool attach)
+static int nvme_ns_attachment(struct nvme_transport_handle *hdl, bool ish,
+		__u32 nsid, __u16 num_ctrls, __u16 *ctrlist, bool attach)
 {
 	struct nvme_ctrl_list cntlist = { 0 };
 	struct nvme_passthru_cmd cmd;
 
 	nvme_init_ctrl_list(&cntlist, num_ctrls, ctrlist);
 	if (attach)
-		nvme_init_ns_attach_ctrls(&cmd, nsid, &cntlist);
+		nvme_init_ns_attach_ctrls(&cmd, ish, nsid, &cntlist);
 	else
-		nvme_init_ns_detach_ctrls(&cmd, nsid, &cntlist);
+		nvme_init_ns_detach_ctrls(&cmd, ish, nsid, &cntlist);
 
 	return nvme_submit_admin_passthru(hdl, &cmd);
 }
 
-int nvme_namespace_attach_ctrls(struct nvme_transport_handle *hdl, __u32 nsid,
-		__u16 num_ctrls, __u16 *ctrlist)
+int nvme_namespace_attach_ctrls(struct nvme_transport_handle *hdl, bool ish,
+		__u32 nsid, __u16 num_ctrls, __u16 *ctrlist)
 {
-	return nvme_ns_attachment(hdl, nsid, num_ctrls, ctrlist, true);
+	return nvme_ns_attachment(hdl, ish, nsid, num_ctrls, ctrlist, true);
 }
 
-int nvme_namespace_detach_ctrls(struct nvme_transport_handle *hdl, __u32 nsid,
-		__u16 num_ctrls, __u16 *ctrlist)
+int nvme_namespace_detach_ctrls(struct nvme_transport_handle *hdl, bool ish,
+		__u32 nsid, __u16 num_ctrls, __u16 *ctrlist)
 {
-	return nvme_ns_attachment(hdl, nsid, num_ctrls, ctrlist, false);
+	return nvme_ns_attachment(hdl, ish, nsid, num_ctrls, ctrlist, false);
 }
 
 size_t nvme_get_ana_log_len_from_id_ctrl(const struct nvme_id_ctrl *id_ctrl,

libnvme/src/nvme/linux.c

@@ -24,6 +24,7 @@
 /**
  * nvme_fw_download_seq() - Firmware download sequence
  * @hdl:	Transport handle
+ * @ish:	Ignore Shutdown (for NVMe-MI command)
  * @size:	Total size of the firmware image to transfer
  * @xfer:	Maximum size to send with each partial transfer
  * @offset:	Starting offset to send with this firmware download
@@ -32,8 +33,8 @@
  * Return: 0 on success, the nvme command status if a response was
  * received (see &enum nvme_status_field) or a negative error otherwise.
  */
-int nvme_fw_download_seq(struct nvme_transport_handle *hdl, __u32 size, __u32 xfer, __u32 offset,
-			 void *buf);
+int nvme_fw_download_seq(struct nvme_transport_handle *hdl, bool ish, __u32 size, __u32 xfer,
+			 __u32 offset, void *buf);
 
 /**
  * nvme_set_etdas() - Set the Extended Telemetry Data Area 4 Supported bit
@@ -193,26 +194,28 @@ int nvme_get_lba_status_log(struct nvme_transport_handle *hdl, bool rae, struct
 /**
  * nvme_namespace_attach_ctrls() - Attach namespace to controller(s)
  * @hdl:	Transport handle
+ * @ish:	Ignore Shutdown (for NVMe-MI command)
  * @nsid:	Namespace ID to attach
  * @num_ctrls:	Number of controllers in ctrlist
  * @ctrlist:	List of controller IDs to perform the attach action
  *
  * Return: 0 on success, the nvme command status if a response was
  * received (see &enum nvme_status_field) or a negative error otherwise.
  */
-int nvme_namespace_attach_ctrls(struct nvme_transport_handle *hdl, __u32 nsid, __u16 num_ctrls, __u16 *ctrlist);
+int nvme_namespace_attach_ctrls(struct nvme_transport_handle *hdl, bool ish, __u32 nsid, __u16 num_ctrls, __u16 *ctrlist);
 
 /**
  * nvme_namespace_detach_ctrls() - Detach namespace from controller(s)
  * @hdl:	Transport handle
+ * @ish:	Ignore Shutdown (for NVMe-MI command)
  * @nsid:	Namespace ID to detach
  * @num_ctrls:	Number of controllers in ctrlist
  * @ctrlist:	List of controller IDs to perform the detach action
  *
  * Return: 0 on success, the nvme command status if a response was
  * received (see &enum nvme_status_field) or a negative error otherwise.
  */
-int nvme_namespace_detach_ctrls(struct nvme_transport_handle *hdl, __u32 nsid, __u16 num_ctrls, __u16 *ctrlist);
+int nvme_namespace_detach_ctrls(struct nvme_transport_handle *hdl, bool ish, __u32 nsid, __u16 num_ctrls, __u16 *ctrlist);
 
 /**
  * nvme_open() - Open an nvme controller or namespace device

libnvme/src/nvme/linux.h

@@ -896,6 +896,7 @@ int nvme_mi_admin_admin_passthru(struct nvme_transport_handle *hdl,
 	}
 
 	nvme_mi_admin_init_req(hdl->ep, &req, &req_hdr, hdl->id, cmd->opcode);
+	req_hdr.flags = cmd->flags;
 	req_hdr.cdw1 = cpu_to_le32(cmd->nsid);
 	req_hdr.cdw2 = cpu_to_le32(cmd->cdw2);
 	req_hdr.cdw3 = cpu_to_le32(cmd->cdw3);
@@ -909,7 +910,7 @@ int nvme_mi_admin_admin_passthru(struct nvme_transport_handle *hdl,
 	if (cmd->data_len != 0) {
 		req_hdr.dlen = cpu_to_le32(cmd->data_len);
 		/* Bit 0 set to 1 means DLEN contains a value */
-		req_hdr.flags = 0x1;
+		req_hdr.flags |= 0x1;
 	}
 
 	if (has_write_data) {

libnvme/src/nvme/mi.c

@@ -34,7 +34,7 @@ static void test_format_nvm(void)
 	int err;
 
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_format_nvm(&cmd, nsid, lbaf, mset, pi, pil, ses);
+	nvme_init_format_nvm(&cmd, false, nsid, lbaf, mset, pi, pil, ses);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
 	check(err == 0, "returned error %d", err);
@@ -61,7 +61,7 @@ static void test_ns_mgmt(void)
 
 	arbitrary(&expected_data, sizeof(expected_data));
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_ns_mgmt(&cmd, nsid, sel, csi, &data);
+	nvme_init_ns_mgmt(&cmd, false, nsid, sel, csi, &data);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
 	check(err == 0, "returned error %d", err);
@@ -89,7 +89,7 @@ static void test_ns_mgmt_create(void)
 
 	arbitrary(&expected_data, sizeof(expected_data));
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_ns_mgmt_create(&cmd, NVME_CSI_ZNS, &data);
+	nvme_init_ns_mgmt_create(&cmd, false, NVME_CSI_ZNS, &data);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
 	check(err == 0, "returned error %d", err);
@@ -109,7 +109,7 @@ static void test_ns_mgmt_delete(void)
 	int err;
 
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_ns_mgmt_delete(&cmd, TEST_NSID);
+	nvme_init_ns_mgmt_delete(&cmd, false, TEST_NSID);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
 	check(err == 0, "returned error %d", err);
@@ -176,7 +176,7 @@ static void test_ns_attach(void)
 
 	arbitrary(&expected_ctrlist, sizeof(expected_ctrlist));
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_ns_attach(&cmd, nsid, sel, &ctrlist);
+	nvme_init_ns_attach(&cmd, false, nsid, sel, &ctrlist);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
 	check(err == 0, "returned error %d", err);
@@ -200,7 +200,7 @@ static void test_ns_attach_ctrls(void)
 
 	arbitrary(&ctrlist, sizeof(ctrlist));
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_ns_attach_ctrls(&cmd, TEST_NSID, &ctrlist);
+	nvme_init_ns_attach_ctrls(&cmd, false, TEST_NSID, &ctrlist);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
 	check(err == 0, "returned error %d", err);
@@ -221,7 +221,7 @@ static void test_ns_detach_ctrls(void)
 
 	arbitrary(&ctrlist, sizeof(ctrlist));
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_ns_detach_ctrls(&cmd, TEST_NSID, &ctrlist);
+	nvme_init_ns_detach_ctrls(&cmd, false, TEST_NSID, &ctrlist);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
 	check(err == 0, "returned error %d", err);
@@ -245,7 +245,7 @@ static void test_fw_download(void)
 	arbitrary(&expected_data, sizeof(expected_data));
 	memcpy(&data, &expected_data, sizeof(expected_data));
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	err = nvme_init_fw_download(&cmd, data, data_len, offset);
+	err = nvme_init_fw_download(&cmd, false, data, data_len, offset);
 	check(err == 0, "download initializing error %d", err);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
@@ -267,7 +267,7 @@ static void test_fw_commit(void)
 	int err;
 
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_fw_commit(&cmd, slot, action, bpid);
+	nvme_init_fw_commit(&cmd, false, slot, action, bpid);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
 	check(err == 0, "returned error %d", err);
@@ -297,7 +297,7 @@ static void test_security_send(void)
 	arbitrary(&expected_data, sizeof(expected_data));
 	memcpy(&data, &expected_data, sizeof(expected_data));
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_security_send(&cmd, nsid, nssf, spsp, secp, tl,
+	nvme_init_security_send(&cmd, false, nsid, nssf, spsp, secp, tl,
 		data, data_len);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
@@ -326,7 +326,7 @@ static void test_security_receive(void)
 
 	arbitrary(&expected_data, sizeof(expected_data));
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_security_receive(&cmd, TEST_NSID, nssf, spsp, secp, al,
+	nvme_init_security_receive(&cmd, false, TEST_NSID, nssf, spsp, secp, al,
 		data, sizeof(data));
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
@@ -368,7 +368,7 @@ static void test_get_lba_status(void)
 
 	arbitrary(expected_lbas, lba_status_size);
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_get_lba_status(&cmd, TEST_NSID, slba, mndw, atype,
+	nvme_init_get_lba_status(&cmd, false, TEST_NSID, slba, mndw, atype,
 		rl, lbas);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
@@ -630,7 +630,7 @@ void test_capacity_mgmt(void)
 	int err;
 
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_capacity_mgmt(&cmd, op, elid, cap);
+	nvme_init_capacity_mgmt(&cmd, false, op, elid, cap);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
 	check(err == 0, "returned error %d", err);
@@ -685,7 +685,7 @@ static void test_sanitize_nvm(void)
 	int err;
 
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_sanitize_nvm(&cmd, sanact, ause, owpass, oipbp, ndas,
+	nvme_init_sanitize_nvm(&cmd, false, sanact, ause, owpass, oipbp, ndas,
 		emvs, ovrpat);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
@@ -706,7 +706,7 @@ static void test_dev_self_test(void)
 	int err;
 
 	set_mock_admin_cmds(&mock_admin_cmd, 1);
-	nvme_init_dev_self_test(&cmd, TEST_NSID, NVME_DST_STC_ABORT);
+	nvme_init_dev_self_test(&cmd, false, TEST_NSID, NVME_DST_STC_ABORT);
 	err = nvme_submit_admin_passthru(test_hdl, &cmd);
 	end_mock_cmds();
 	check(err == 0, "returned error %d", err);