mi: fix coding style and indentation errors

Basically this is to follow the checkpatch.pl checks.

Signed-off-by: Tokunori Ikegami <[email protected]>

Author: ikegami-t

src/nvme/mi.c

@@ -21,8 +21,7 @@
 #include "mi.h"
 #include "private.h"
 
-static const int default_timeout = 1000; /* milliseconds; endpoints may
-					    override */
+static const int default_timeout = 1000; /* milliseconds; endpoints may override */
 
 static bool nvme_mi_probe_enabled_default(void)
 {
@@ -38,7 +37,8 @@ static bool nvme_mi_probe_enabled_default(void)
 
 }
 
-/* MI-equivalent of nvme_create_root, but avoids clashing symbol names
+/*
+ * MI-equivalent of nvme_create_root, but avoids clashing symbol names
  * when linking against both libnvme and libnvme-mi.
  */
 nvme_root_t nvme_mi_create_root(FILE *fp, int log_level)
@@ -58,8 +58,9 @@ nvme_root_t nvme_mi_create_root(FILE *fp, int log_level)
 			free(r);
 			return NULL;
 		}
-	} else
+	} else {
 		fd = STDERR_FILENO;
+	}
 
 	r->log.fd = fd;
 	r->log.level = log_level;
@@ -119,7 +120,8 @@ static void __nvme_mi_format_mn(struct nvme_id_ctrl *id,
 	const size_t id_mn_size = sizeof(id->mn);
 	int i;
 
-	/* A BUILD_ASSERT() would be nice here, but we're not const enough for
+	/*
+	 * A BUILD_ASSERT() would be nice here, but we're not const enough for
 	 * that
 	 */
 	if (mn_len <= id_mn_size)
@@ -144,14 +146,16 @@ void nvme_mi_ep_probe(struct nvme_mi_ep *ep)
 	struct nvme_mi_ctrl *ctrl;
 	int rc;
 
-	/* Ensure the probe occurs at most once. This isn't just to mitigate doubling
+	/*
+	 * Ensure the probe occurs at most once. This isn't just to mitigate doubling
 	 * a linear stream of commands, it also terminates recursion via the
 	 * nvme_mi_submit() call issued by nvme_mi_admin_identify_partial() below.
 	 */
 	if (ep->quirks_probed)
 		return;
 
-	/* Mark ep->quirks as valid. Note that for the purpose of quirk probing,
+	/*
+	 * Mark ep->quirks as valid. Note that for the purpose of quirk probing,
 	 * the quirk probe itself cannot rely on quirks, and so the fact that none are
 	 * yet set is desirable. The request that triggered nvme_mi_submit() will have
 	 * an initialised ep->quirks when we return from the root probe call.
@@ -168,7 +172,8 @@ void nvme_mi_ep_probe(struct nvme_mi_ep *ep)
 	if (!ctrl)
 		return;
 
-	/* Do enough of an identify (assuming controller 0) to retrieve
+	/*
+	 * Do enough of an identify (assuming controller 0) to retrieve
 	 * device and firmware identification information. This gives us the
 	 * following fields in id:
 	 *
@@ -188,14 +193,15 @@ void nvme_mi_ep_probe(struct nvme_mi_ep *ep)
 	id_args.csi = NVME_CSI_NVM;
 
 	rc = nvme_mi_admin_identify_partial(ctrl, &id_args, 0,
-				    offsetof(struct nvme_id_ctrl, rab));
+					    offsetof(struct nvme_id_ctrl, rab));
 	if (rc) {
 		nvme_msg(ep->root, LOG_WARNING,
 			 "Identify Controller failed, no quirks applied\n");
 		goto out_close;
 	}
 
-	/* Samsung MZUL2512: cannot receive commands sent within ~1ms of
+	/*
+	 * Samsung MZUL2512: cannot receive commands sent within ~1ms of
 	 * the previous response. Set an inter-command delay of 1.2ms for
 	 * a little extra tolerance.
 	 */
@@ -204,7 +210,8 @@ void nvme_mi_ep_probe(struct nvme_mi_ep *ep)
 		ep->inter_command_us = 1200;
 	}
 
-	/* If we're quirking for the inter-command time, record the last
+	/*
+	 * If we're quirking for the inter-command time, record the last
 	 * command time now, so we don't conflict with the just-sent identify.
 	 */
 	if (ep->quirks & NVME_QUIRK_MIN_INTER_COMMAND_TIME)
@@ -224,6 +231,7 @@ void nvme_mi_ep_probe(struct nvme_mi_ep *ep)
 }
 
 static const int nsec_per_sec = 1000 * 1000 * 1000;
+
 /* timercmp and timersub, but for struct timespec */
 #define timespec_cmp(a, b, CMP)						\
 	(((a)->tv_sec == (b)->tv_sec)					\
@@ -531,8 +539,8 @@ static void nvme_mi_admin_init_resp(struct nvme_mi_resp *resp,
 }
 
 static void nvme_mi_control_init_req(struct nvme_mi_req *req,
-				    struct nvme_mi_control_req *control_req,
-				    __u8 opcode, __u16 cpsp)
+				     struct nvme_mi_control_req *control_req, __u8 opcode,
+				     __u16 cpsp)
 {
 	memset(req, 0, sizeof(*req));
 	memset(control_req, 0, sizeof(*control_req));
@@ -548,7 +556,7 @@ static void nvme_mi_control_init_req(struct nvme_mi_req *req,
 }
 
 static void nvme_mi_control_init_resp(struct nvme_mi_resp *resp,
-				    struct nvme_mi_control_resp *control_resp)
+				      struct nvme_mi_control_resp *control_resp)
 {
 	memset(resp, 0, sizeof(*resp));
 	resp->hdr = &control_resp->hdr;
@@ -562,7 +570,8 @@ static int nvme_mi_admin_parse_status(struct nvme_mi_resp *resp, __u32 *result)
 	__u32 nvme_status;
 	__u32 nvme_result;
 
-	/* we have a few different sources of "result" here: the status header
+	/*
+	 * we have a few different sources of "result" here: the status header
 	 * in the MI response, the cdw3 status field, and (command specific)
 	 * return values in cdw0. The latter is returned in the result pointer,
 	 * the former two generate return values here
@@ -574,15 +583,17 @@ static int nvme_mi_admin_parse_status(struct nvme_mi_resp *resp, __u32 *result)
 	}
 	resp_hdr = (struct nvme_mi_msg_resp *)resp->hdr;
 
-	/* If we have a MI error, we can't be sure there's an admin header
+	/*
+	 * If we have a MI error, we can't be sure there's an admin header
 	 * following; return just the MI status, with the status type
 	 * indicator of MI.
 	 */
 	if (resp_hdr->status)
 		return resp_hdr->status |
 			(NVME_STATUS_TYPE_MI << NVME_STATUS_TYPE_SHIFT);
 
-	/* We shouldn't hit this, as we'd have an error reported earlier.
+	/*
+	 * We shouldn't hit this, as we'd have an error reported earlier.
 	 * However, for pointer safety, ensure we have a full admin header
 	 */
 	if (resp->hdr_len < sizeof(*admin_hdr)) {
@@ -593,7 +604,8 @@ static int nvme_mi_admin_parse_status(struct nvme_mi_resp *resp, __u32 *result)
 	admin_hdr = (struct nvme_mi_admin_resp_hdr *)resp->hdr;
 	nvme_result = le32_to_cpu(admin_hdr->cdw0);
 
-	/* Shift down 17 here: the SC starts at bit 17, and the NVME_SC_*
+	/*
+	 * Shift down 17 here: the SC starts at bit 17, and the NVME_SC_*
 	 * definitions align to this bit (and up). The CRD, MORE and DNR
 	 * bits are defined accordingly (eg., DNR is 0x4000).
 	 */
@@ -638,7 +650,8 @@ int nvme_mi_admin_xfer(nvme_mi_ctrl_t ctrl,
 	__u32 dlen, doff;
 	int rc;
 
-	/* length/offset checks. The common _submit() API will do further
+	/*
+	 * length/offset checks. The common _submit() API will do further
 	 * checking on the message lengths too, so these are kept specific
 	 * to the requirements of the Admin command set
 	 */
@@ -675,8 +688,7 @@ int nvme_mi_admin_xfer(nvme_mi_ctrl_t ctrl,
 	}
 
 	admin_req->hdr.type = NVME_MI_MSGTYPE_NVME;
-	admin_req->hdr.nmp = (NVME_MI_ROR_REQ << 7) |
-				(NVME_MI_MT_ADMIN << 3);
+	admin_req->hdr.nmp = (NVME_MI_ROR_REQ << 7) | (NVME_MI_MT_ADMIN << 3);
 	admin_req->ctrl_id = cpu_to_le16(ctrl->id);
 	memset(&req, 0, sizeof(req));
 	req.hdr = &admin_req->hdr;
@@ -882,8 +894,10 @@ int nvme_mi_admin_identify_partial(nvme_mi_ctrl_t ctrl,
 	if (rc)
 		return rc;
 
-	/* callers will expect a full response; if the data buffer isn't
-	 * fully valid, return an error */
+	/*
+	 * callers will expect a full response; if the data buffer isn't
+	 * fully valid, return an error
+	 */
 	if (resp.data_len != size) {
 		errno = EPROTO;
 		return -1;
@@ -915,15 +929,16 @@ int nvme_mi_control(nvme_mi_ep_t ep, __u8 opcode,
 	return 0;
 }
 
-/* retrieves a MCTP-messsage-sized chunk of log page data. offset and len are
+/*
+ * retrieves a MCTP-messsage-sized chunk of log page data. offset and len are
  * specified within the args->data area. The `offset` parameter is a relative
  * offset to the args->lpo !
  *
  * What's more, we change the LPO of original command to chunk the request
  * message into proper size which is allowed by MI interface. One reason is that
  * this option seems to be supported better by devices.  For more information
  * about this option, please check https://github.com/linux-nvme/libnvme/pull/539
- * */
+ */
 static int __nvme_mi_admin_get_log(nvme_mi_ctrl_t ctrl,
 				   const struct nvme_get_log_args *args,
 				   off_t offset, size_t *lenp, bool final)
@@ -937,8 +952,10 @@ static int __nvme_mi_admin_get_log(nvme_mi_ctrl_t ctrl,
 	__u32 ndw;
 	int rc;
 
-	/* MI spec requires that the data length field is less than or equal
-	 * to 4096 */
+	/*
+	 * MI spec requires that the data length field is less than or equal
+	 * to 4096
+	 */
 	len = *lenp;
 	if (!len || len > 4096 || len < 4) {
 		errno = EINVAL;
@@ -1020,8 +1037,10 @@ int nvme_mi_admin_get_log_page(nvme_mi_ctrl_t ctrl, __u32 xfer_size,
 			break;
 
 		xfer_offset += xfered_size;
-		/* if we returned less data than expected, consider that
-		 * the end of the log page */
+		/*
+		 * if we returned less data than expected, consider that
+		 * the end of the log page
+		 */
 		if (xfered_size != cur_xfer_size)
 			break;
 	}
@@ -1167,7 +1186,6 @@ int nvme_mi_admin_get_ana_log_atomic(nvme_mi_ctrl_t ctrl, bool rgo, bool rae,
 int nvme_mi_admin_security_send(nvme_mi_ctrl_t ctrl,
 				struct nvme_security_send_args *args)
 {
-
 	struct nvme_mi_admin_resp_hdr resp_hdr;
 	struct nvme_mi_admin_req_hdr req_hdr;
 	struct nvme_mi_resp resp;
@@ -1213,7 +1231,6 @@ int nvme_mi_admin_security_send(nvme_mi_ctrl_t ctrl,
 int nvme_mi_admin_security_recv(nvme_mi_ctrl_t ctrl,
 				struct nvme_security_receive_args *args)
 {
-
 	struct nvme_mi_admin_resp_hdr resp_hdr;
 	struct nvme_mi_admin_req_hdr req_hdr;
 	struct nvme_mi_resp resp;
@@ -1378,8 +1395,7 @@ int nvme_mi_admin_ns_mgmt(nvme_mi_ctrl_t ctrl,
 			req.data = args->data;
 			data_len = sizeof(*args->data);
 		}
-	}
-	else {
+	} else {
 		if (args->ns) {
 			req.data = args->ns;
 			data_len = sizeof(*args->ns);
@@ -1624,11 +1640,8 @@ static int nvme_mi_read_data(nvme_mi_ep_t ep, __u32 cdw0,
 	return 0;
 }
 
-int nvme_mi_mi_xfer(nvme_mi_ep_t ep,
-		       struct nvme_mi_mi_req_hdr *mi_req,
-		       size_t req_data_size,
-		       struct nvme_mi_mi_resp_hdr *mi_resp,
-		       size_t *resp_data_size)
+int nvme_mi_mi_xfer(nvme_mi_ep_t ep, struct nvme_mi_mi_req_hdr *mi_req, size_t req_data_size,
+		    struct nvme_mi_mi_resp_hdr *mi_resp, size_t *resp_data_size)
 {
 	int rc;
 	struct nvme_mi_req req;
@@ -1664,8 +1677,7 @@ int nvme_mi_mi_xfer(nvme_mi_ep_t ep,
 	}
 
 	mi_req->hdr.type = NVME_MI_MSGTYPE_NVME;
-	mi_req->hdr.nmp = (NVME_MI_ROR_REQ << 7) |
-				(NVME_MI_MT_MI << 3);
+	mi_req->hdr.nmp = (NVME_MI_ROR_REQ << 7) | (NVME_MI_MT_MI << 3);
 
 	memset(&req, 0, sizeof(req));
 	req.hdr = &mi_req->hdr;
@@ -1739,7 +1751,7 @@ int nvme_mi_mi_read_mi_data_port(nvme_mi_ep_t ep, __u8 portid,
 }
 
 int nvme_mi_mi_read_mi_data_ctrl_list(nvme_mi_ep_t ep, __u8 start_ctrlid,
-				       struct nvme_ctrl_list *list)
+				      struct nvme_ctrl_list *list)
 {
 	size_t len;
 	__u32 cdw0;
@@ -1965,26 +1977,25 @@ nvme_mi_ctrl_t nvme_mi_next_ctrl(nvme_mi_ep_t ep, nvme_mi_ctrl_t c)
 	return c ? list_next(&ep->controllers, c, ep_entry) : NULL;
 }
 
-
 static const char *const mi_status[] = {
-        [NVME_MI_RESP_MPR]                   = "More Processing Required: The command message is in progress and requires more time to complete processing",
-        [NVME_MI_RESP_INTERNAL_ERR]          = "Internal Error: The request message could not be processed due to a vendor-specific error",
-        [NVME_MI_RESP_INVALID_OPCODE]        = "Invalid Command Opcode",
-        [NVME_MI_RESP_INVALID_PARAM]         = "Invalid Parameter",
-        [NVME_MI_RESP_INVALID_CMD_SIZE]      = "Invalid Command Size: The size of the message body of the request was different than expected",
-        [NVME_MI_RESP_INVALID_INPUT_SIZE]    = "Invalid Command Input Data Size: The command requires data and contains too much or too little data",
-        [NVME_MI_RESP_ACCESS_DENIED]         = "Access Denied. Processing prohibited due to a vendor-specific mechanism of the Command and Feature lockdown function",
-        [NVME_MI_RESP_VPD_UPDATES_EXCEEDED]  = "VPD Updates Exceeded",
-        [NVME_MI_RESP_PCIE_INACCESSIBLE]     = "PCIe Inaccessible. The PCIe functionality is not available at this time",
-        [NVME_MI_RESP_MEB_SANITIZED]         = "Management Endpoint Buffer Cleared Due to Sanitize",
-        [NVME_MI_RESP_ENC_SERV_FAILURE]      = "Enclosure Services Failure",
-        [NVME_MI_RESP_ENC_SERV_XFER_FAILURE] = "Enclosure Services Transfer Failure: Communication with the Enclosure Services Process has failed",
-        [NVME_MI_RESP_ENC_FAILURE]           = "An unrecoverable enclosure failure has been detected by the Enclosuer Services Process",
-        [NVME_MI_RESP_ENC_XFER_REFUSED]      = "Enclosure Services Transfer Refused: The NVM Subsystem or Enclosure Services Process indicated an error or an invalid format in communication",
-        [NVME_MI_RESP_ENC_FUNC_UNSUP]        = "Unsupported Enclosure Function: An SES Send command has been attempted to a simple Subenclosure",
-        [NVME_MI_RESP_ENC_SERV_UNAVAIL]      = "Enclosure Services Unavailable: The NVM Subsystem or Enclosure Services Process has encountered an error but may become available again",
-        [NVME_MI_RESP_ENC_DEGRADED]          = "Enclosure Degraded: A noncritical failure has been detected by the Enclosure Services Process",
-        [NVME_MI_RESP_SANITIZE_IN_PROGRESS]  = "Sanitize In Progress: The requested command is prohibited while a sanitize operation is in progress",
+	[NVME_MI_RESP_MPR]                   = "More Processing Required: The command message is in progress and requires more time to complete processing",
+	[NVME_MI_RESP_INTERNAL_ERR]          = "Internal Error: The request message could not be processed due to a vendor-specific error",
+	[NVME_MI_RESP_INVALID_OPCODE]        = "Invalid Command Opcode",
+	[NVME_MI_RESP_INVALID_PARAM]         = "Invalid Parameter",
+	[NVME_MI_RESP_INVALID_CMD_SIZE]      = "Invalid Command Size: The size of the message body of the request was different than expected",
+	[NVME_MI_RESP_INVALID_INPUT_SIZE]    = "Invalid Command Input Data Size: The command requires data and contains too much or too little data",
+	[NVME_MI_RESP_ACCESS_DENIED]         = "Access Denied. Processing prohibited due to a vendor-specific mechanism of the Command and Feature lockdown function",
+	[NVME_MI_RESP_VPD_UPDATES_EXCEEDED]  = "VPD Updates Exceeded",
+	[NVME_MI_RESP_PCIE_INACCESSIBLE]     = "PCIe Inaccessible. The PCIe functionality is not available at this time",
+	[NVME_MI_RESP_MEB_SANITIZED]         = "Management Endpoint Buffer Cleared Due to Sanitize",
+	[NVME_MI_RESP_ENC_SERV_FAILURE]      = "Enclosure Services Failure",
+	[NVME_MI_RESP_ENC_SERV_XFER_FAILURE] = "Enclosure Services Transfer Failure: Communication with the Enclosure Services Process has failed",
+	[NVME_MI_RESP_ENC_FAILURE]           = "An unrecoverable enclosure failure has been detected by the Enclosuer Services Process",
+	[NVME_MI_RESP_ENC_XFER_REFUSED]      = "Enclosure Services Transfer Refused: The NVM Subsystem or Enclosure Services Process indicated an error or an invalid format in communication",
+	[NVME_MI_RESP_ENC_FUNC_UNSUP]        = "Unsupported Enclosure Function: An SES Send command has been attempted to a simple Subenclosure",
+	[NVME_MI_RESP_ENC_SERV_UNAVAIL]      = "Enclosure Services Unavailable: The NVM Subsystem or Enclosure Services Process has encountered an error but may become available again",
+	[NVME_MI_RESP_ENC_DEGRADED]          = "Enclosure Degraded: A noncritical failure has been detected by the Enclosure Services Process",
+	[NVME_MI_RESP_SANITIZE_IN_PROGRESS]  = "Sanitize In Progress: The requested command is prohibited while a sanitize operation is in progress",
 };
 
 /* kept in mi.c while we have a split libnvme/libnvme-mi; consider moving
@@ -1994,7 +2005,7 @@ const char *nvme_mi_status_to_string(int status)
 	const char *s = "Unknown status";
 
 	if (status < ARRAY_SIZE(mi_status) && mi_status[status])
-                s = mi_status[status];
+		s = mi_status[status];
 
-        return s;
+	return s;
 }

src/nvme/mi.h

@@ -3096,5 +3096,4 @@ int nvme_mi_admin_format_nvm(nvme_mi_ctrl_t ctrl,
  */
 int nvme_mi_admin_sanitize_nvm(nvme_mi_ctrl_t ctrl,
 			       struct nvme_sanitize_nvm_args *args);
-
 #endif /* _LIBNVME_MI_MI_H */