Merge pull request #386 from CodeConstruct/mi

MI: Update MI Admin API to suit core

Author: dwsuse

examples/mi-mctp.c

@@ -177,13 +177,15 @@ static const char *__copy_id_str(const void *field, size_t size,
 
 int do_identify(nvme_mi_ep_t ep, int argc, char **argv)
 {
+	struct nvme_identify_args id_args = { 0 };
 	struct nvme_mi_ctrl *ctrl;
 	struct nvme_id_ctrl id;
 	uint16_t ctrl_id;
 	char buf[41];
+	bool partial;
 	int rc, tmp;
 
-	if (argc != 2) {
+	if (argc < 2) {
 		fprintf(stderr, "no controller ID specified\n");
 		return -1;
 	}
@@ -196,15 +198,33 @@ int do_identify(nvme_mi_ep_t ep, int argc, char **argv)
 
 	ctrl_id = tmp & 0xffff;
 
+	partial = argc > 2 && !strcmp(argv[2], "--partial");
+
 	ctrl = nvme_mi_init_ctrl(ep, tmp);
 	if (!ctrl) {
 		warn("can't create controller");
 		return -1;
 	}
 
-	/* we only use the fields before rab; just request partial ID data */
-	rc = nvme_mi_admin_identify_ctrl_partial(ctrl, &id, 0,
-					 offsetof(struct nvme_id_ctrl, rab));
+	id_args.data = &id;
+	id_args.args_size = sizeof(id_args);
+	id_args.cns = NVME_IDENTIFY_CNS_CTRL;
+	id_args.nsid = NVME_NSID_NONE;
+	id_args.cntid = ctrl_id;
+	id_args.csi = NVME_CSI_NVM;
+
+	/* for this example code, we can either do a full or partial identify;
+	 * since we're only printing the fields before the 'rab' member,
+	 * these will be equivalent, aside from the size of the MI
+	 * response.
+	 */
+	if (partial) {
+		rc = nvme_mi_admin_identify_partial(ctrl, &id_args, 0,
+					    offsetof(struct nvme_id_ctrl, rab));
+	} else {
+		rc = nvme_mi_admin_identify(ctrl, &id_args);
+	}
+
 	if (rc) {
 		warn("can't perform Admin Identify command");
 		return -1;
@@ -241,7 +261,7 @@ int main(int argc, char **argv)
 		fprintf(stderr, "where action is:\n"
 			"  info\n"
 			"  controllers\n"
-			"  identify <controller-id>\n");
+			"  identify <controller-id> [--partial]\n");
 		return EXIT_FAILURE;
 	}
 

src/libnvme-mi.map

@@ -10,9 +10,7 @@ LIBNVME_MI_1_1 {
 		nvme_mi_mi_read_mi_data_ctrl_list;
 		nvme_mi_mi_read_mi_data_ctrl;
 		nvme_mi_mi_subsystem_health_status_poll;
-		nvme_mi_admin_identify_ctrl;
-		nvme_mi_admin_identify_ctrl_partial;
-		nvme_mi_admin_identify_ctrl_list;
+		nvme_mi_admin_identify_partial;
 		nvme_mi_open_mctp;
 	local:
 		*;

src/nvme/mi.c

@@ -146,23 +146,26 @@ static void nvme_mi_admin_init_resp(struct nvme_mi_resp *resp,
 	resp->hdr_len = sizeof(*hdr);
 }
 
-static int nvme_mi_admin_identify(nvme_mi_ctrl_t ctrl,
-				  enum nvme_identify_cns cns,
-				  __u16 cid, __u16 nsid, void *id,
-				  off_t offset, size_t size)
+int nvme_mi_admin_identify_partial(nvme_mi_ctrl_t ctrl,
+				   struct nvme_identify_args *args,
+				   off_t offset, size_t size)
 {
 	struct nvme_mi_admin_resp_hdr resp_hdr;
 	struct nvme_mi_admin_req_hdr req_hdr;
 	struct nvme_mi_resp resp;
 	struct nvme_mi_req req;
 	int rc;
 
+	if (args->args_size < sizeof(*args))
+		return -EINVAL;
+
 	if (!size || size > 0xffffffff)
 		return -EINVAL;
 
 	nvme_mi_admin_init_req(&req, &req_hdr, ctrl->id, nvme_admin_identify);
-	req_hdr.cdw10 = cpu_to_le16(cid) << 16 | cpu_to_le16(cns);
-	req_hdr.cdw11 = cpu_to_le16(nsid);
+	req_hdr.cdw10 = cpu_to_le16(args->cntid) << 16 | cpu_to_le16(args->cns);
+	req_hdr.cdw11 = cpu_to_le16(args->nsid);
+	req_hdr.cdw14 = args->uuidx & 0xff;
 	req_hdr.dlen = cpu_to_le32(size & 0xffffffff);
 	req_hdr.flags = 0x1;
 	if (offset) {
@@ -173,50 +176,36 @@ static int nvme_mi_admin_identify(nvme_mi_ctrl_t ctrl,
 	nvme_mi_calc_req_mic(&req);
 
 	nvme_mi_admin_init_resp(&resp, &resp_hdr);
-	resp.data = id;
+	resp.data = args->data;
 	resp.data_len = size;
 
 	rc = nvme_mi_submit(ctrl->ep, &req, &resp);
 	if (rc)
 		return rc;
 
-	/* check status, map to return value */
+	if (args->result)
+		*args->result = le32_to_cpu(resp_hdr.cdw0);
+
+	/* callers will expect a full response; if the data buffer isn't
+	 * fully valid, return an error */
+	if (resp.data_len != size)
+		return -EPROTO;
 
 	return 0;
 }
 
 int nvme_mi_admin_identify_ctrl(nvme_mi_ctrl_t ctrl,
 				struct nvme_id_ctrl *id)
 {
-	return nvme_mi_admin_identify(ctrl, NVME_IDENTIFY_CNS_CTRL,
-				      0, 0, id, 0, sizeof(*id));
-}
-
-int nvme_mi_admin_identify_ctrl_partial(nvme_mi_ctrl_t ctrl,
-					struct nvme_id_ctrl *id,
-					off_t offset, size_t size)
-{
-	void *buf;
-
-	if (offset > sizeof(*id))
-		return -EINVAL;
-	if (size > sizeof(*id))
-		return -EINVAL;
-	if (offset + size > sizeof(*id))
-		return -EINVAL;
-
-	buf = id;
-	buf += offset;
-
-	return nvme_mi_admin_identify(ctrl, NVME_IDENTIFY_CNS_CTRL,
-				      0, 0, buf, offset, size);
-}
-
-int nvme_mi_admin_identify_ctrl_list(nvme_mi_ctrl_t ctrl,
-				     struct nvme_ctrl_list *ctrllist)
-{
-	return nvme_mi_admin_identify(ctrl, NVME_IDENTIFY_CNS_CTRL_LIST,
-					 0, 0, ctrllist, 0, sizeof(*ctrllist));
+	struct nvme_identify_args id_args = {
+		.args_size = sizeof(id_args),
+		.data = id,
+		.cns = NVME_IDENTIFY_CNS_CTRL,
+		.nsid = NVME_NSID_NONE,
+		.cntid = ctrl->id,
+	};
+
+	return nvme_mi_admin_identify(ctrl, &id_args);
 }
 
 static int nvme_mi_read_data(nvme_mi_ep_t ep, __u32 cdw0,

src/nvme/mi.h

@@ -124,12 +124,60 @@ int nvme_mi_mi_subsystem_health_status_poll(nvme_mi_ep_t ep, bool clear,
 					    struct nvme_mi_nvm_ss_health_status *nshds);
 
 /* Admin channel functions */
-int nvme_mi_admin_identify_ctrl(nvme_mi_ctrl_t ctrl,
-				struct nvme_id_ctrl *id);
-int nvme_mi_admin_identify_ctrl_partial(nvme_mi_ctrl_t ctrl,
-					struct nvme_id_ctrl *id,
-					off_t offset, size_t size);
-int nvme_mi_admin_identify_ctrl_list(nvme_mi_ctrl_t ctrl,
-				     struct nvme_ctrl_list *ctrllist);
+int nvme_mi_admin_identify_partial(nvme_mi_ctrl_t ctrl,
+				   struct nvme_identify_args *args,
+				   off_t offset, size_t size);
+
+/* Helpers for identify commands */
+static inline int nvme_mi_admin_identify(nvme_mi_ctrl_t ctrl,
+					 struct nvme_identify_args *args)
+{
+	return nvme_mi_admin_identify_partial(ctrl, args,
+					      0, NVME_IDENTIFY_DATA_SIZE);
+}
+
+static inline int nvme_mi_admin_identify_cns_nsid(nvme_mi_ctrl_t ctrl,
+						  enum nvme_identify_cns cns,
+						  __u32 nsid, void *data)
+{
+	struct nvme_identify_args args = {
+		.result = NULL,
+		.data = data,
+		.args_size = sizeof(args),
+		.cns = cns,
+		.csi = NVME_CSI_NVM,
+		.nsid = nsid,
+		.cntid = NVME_CNTLID_NONE,
+		.cns_specific_id = NVME_CNSSPECID_NONE,
+		.uuidx = NVME_UUID_NONE,
+	};
+
+	return nvme_mi_admin_identify(ctrl, &args);
+}
+
+static inline int nvme_mi_identify_ctrl(nvme_mi_ctrl_t ctrl,
+					struct nvme_id_ctrl *id)
+{
+	return nvme_mi_admin_identify_cns_nsid(ctrl, NVME_IDENTIFY_CNS_CTRL,
+					       NVME_NSID_NONE, id);
+}
+
+static inline int nvme_mi_identify_ctrl_list(nvme_mi_ctrl_t ctrl, __u16 cntid,
+					     struct nvme_ctrl_list *list)
+{
+	struct nvme_identify_args args = {
+		.result = NULL,
+		.data = list,
+		.args_size = sizeof(args),
+		.cns = NVME_IDENTIFY_CNS_CTRL_LIST,
+		.csi = NVME_CSI_NVM,
+		.nsid = NVME_NSID_NONE,
+		.cntid = cntid,
+		.cns_specific_id = NVME_CNSSPECID_NONE,
+		.uuidx = NVME_UUID_NONE,
+	};
+
+	return nvme_mi_admin_identify(ctrl, &args);
+}
 
 #endif /* _LIBNVME_MI_MI_H */