diff --git a/drivers/target/iscsi/cxgbit/cxgbit_cm.c b/drivers/target/iscsi/cxgbit/cxgbit_cm.c
index 2575549cb579..036e275de088 100644
--- a/drivers/target/iscsi/cxgbit/cxgbit_cm.c
+++ b/drivers/target/iscsi/cxgbit/cxgbit_cm.c
@@ -1249,8 +1249,7 @@ cxgbit_pass_accept_req(struct cxgbit_device *cdev, struct sk_buff *skb)
 
 	/* Find output route */
 	if (iptype == 4)  {
-		target_debug("%s parent sock %p tid %u laddr %pI4 raddr %pI4 "
-			     "lport %d rport %d peer_mss %d\n",
+		target_debug("%s parent sock %p tid %u laddr %pI4 raddr %pI4 lport %d rport %d peer_mss %d\n",
 			     __func__, cnp, tid, local_ip, peer_ip, ntohs(local_port),
 			     ntohs(peer_port), peer_mss);
 		dst = cxgb_find_route(&cdev->lldi, cxgbit_get_real_dev,
@@ -1259,8 +1258,7 @@ cxgbit_pass_accept_req(struct cxgbit_device *cdev, struct sk_buff *skb)
 				      local_port, peer_port,
 				      PASS_OPEN_TOS_G(ntohl(req->tos_stid)));
 	} else {
-		target_debug("%s parent sock %p tid %u laddr %pI6 raddr %pI6 "
-			     "lport %d rport %d peer_mss %d\n",
+		target_debug("%s parent sock %p tid %u laddr %pI6 raddr %pI6 lport %d rport %d peer_mss %d\n",
 			     __func__, cnp, tid, local_ip, peer_ip, ntohs(local_port),
 			     ntohs(peer_port), peer_mss);
 		dst = cxgb_find_route6(&cdev->lldi, cxgbit_get_real_dev,
diff --git a/drivers/target/iscsi/cxgbit/cxgbit_target.c b/drivers/target/iscsi/cxgbit/cxgbit_target.c
index c49d3d975c80..95301f3c62a2 100644
--- a/drivers/target/iscsi/cxgbit/cxgbit_target.c
+++ b/drivers/target/iscsi/cxgbit/cxgbit_target.c
@@ -860,9 +860,7 @@ cxgbit_handle_immediate_data(struct iscsit_cmd *cmd, struct iscsi_scsi_req *hdr,
 	if (pdu_cb->flags & PDUCBF_RX_DCRC_ERR) {
 		target_err("ImmediateData CRC32C DataDigest error\n");
 		if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
-			target_err("Unable to recover from"
-				   " Immediate Data digest failure while"
-				   " in ERL=0.\n");
+			target_err("Unable to recover from Immediate Data digest failure while in ERL=0.\n");
 			iscsit_reject_cmd(cmd, ISCSI_REASON_DATA_DIGEST_ERROR,
 					  (unsigned char *)hdr);
 			return IMMEDIATE_DATA_CANNOT_RECOVER;
@@ -1034,17 +1032,15 @@ static int cxgbit_handle_iscsi_dataout(struct cxgbit_sock *csk)
 	}
 
 	if (pdu_cb->flags & PDUCBF_RX_DCRC_ERR) {
-		target_err("ITT: 0x%08x, Offset: %u, Length: %u,"
-			   " DataSN: 0x%08x\n",
-			   hdr->itt, hdr->offset, data_len, hdr->datasn);
+		target_err("ITT: 0x%08x, Offset: %u, Length: %u, DataSN: 0x%08x\n", hdr->itt,
+			   hdr->offset, data_len, hdr->datasn);
 
 		dcrc_err = true;
 		goto check_payload;
 	}
 
-	target_debug("DataOut data_len: %u, "
-		     "write_data_done: %u, data_length: %u\n",
-		     data_len, cmd->write_data_done, cmd->se_cmd.data_length);
+	target_debug("DataOut data_len: %u, write_data_done: %u, data_length: %u\n", data_len,
+		     cmd->write_data_done, cmd->se_cmd.data_length);
 
 	if (!(pdu_cb->flags & PDUCBF_RX_DATA_DDPD)) {
 		u32 skip = data_offset % PAGE_SIZE;
@@ -1094,9 +1090,7 @@ static int cxgbit_handle_nop_out(struct cxgbit_sock *csk, struct iscsit_cmd *cmd
 
 	if (pdu_cb->flags & PDUCBF_RX_DCRC_ERR) {
 		if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
-			target_err("Unable to recover from"
-				   " NOPOUT Ping DataCRC failure while in"
-				   " ERL=0.\n");
+			target_err("Unable to recover from NOPOUT Ping DataCRC failure while in ERL=0.\n");
 			ret = -1;
 			goto out;
 		} else {
@@ -1104,9 +1098,7 @@ static int cxgbit_handle_nop_out(struct cxgbit_sock *csk, struct iscsit_cmd *cmd
 			 * drop this PDU and let the
 			 * initiator plug the CmdSN gap.
 			 */
-			target_info("Dropping NOPOUT"
-				    " Command CmdSN: 0x%08x due to"
-				    " DataCRC error.\n",
+			target_info("Dropping NOPOUT Command CmdSN: 0x%08x due to DataCRC error.\n",
 				    hdr->cmdsn);
 			ret = 0;
 			goto out;
@@ -1119,8 +1111,7 @@ static int cxgbit_handle_nop_out(struct cxgbit_sock *csk, struct iscsit_cmd *cmd
 	if (payload_length && hdr->ttt == cpu_to_be32(0xFFFFFFFF)) {
 		ping_data = kzalloc(payload_length + 1, GFP_KERNEL);
 		if (!ping_data) {
-			target_err("Unable to allocate memory for"
-				   " NOPOUT ping data.\n");
+			target_err("Unable to allocate memory for NOPOUT ping data.\n");
 			ret = -1;
 			goto out;
 		}
@@ -1135,9 +1126,7 @@ static int cxgbit_handle_nop_out(struct cxgbit_sock *csk, struct iscsit_cmd *cmd
 		cmd->buf_ptr = ping_data;
 		cmd->buf_ptr_size = payload_length;
 
-		target_debug("Got %u bytes of NOPOUT ping"
-			     " data.\n",
-			     payload_length);
+		target_debug("Got %u bytes of NOPOUT ping data.\n", payload_length);
 		target_debug("Ping Data: \"%s\"\n", ping_data);
 	}
 
@@ -1164,18 +1153,14 @@ cxgbit_handle_text_cmd(struct cxgbit_sock *csk, struct iscsit_cmd *cmd)
 
 	if (pdu_cb->flags & PDUCBF_RX_DCRC_ERR) {
 		if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
-			target_err("Unable to recover from"
-				   " Text Data digest failure while in"
-				   " ERL=0.\n");
+			target_err("Unable to recover from Text Data digest failure while in ERL=0.\n");
 			goto reject;
 		} else {
 			/*
 			 * drop this PDU and let the
 			 * initiator plug the CmdSN gap.
 			 */
-			target_info("Dropping Text"
-				    " Command CmdSN: 0x%08x due to"
-				    " DataCRC error.\n",
+			target_info("Dropping Text Command CmdSN: 0x%08x due to DataCRC error.\n",
 				    hdr->cmdsn);
 			return 0;
 		}
@@ -1301,8 +1286,7 @@ static int cxgbit_rx_opcode(struct cxgbit_sock *csk)
 	if (conn->sess->sess_ops->SessionType &&
 	    ((!(opcode & ISCSI_OP_TEXT)) ||
 	     (!(opcode & ISCSI_OP_LOGOUT)))) {
-		target_err("Received illegal iSCSI Opcode: 0x%02x"
-			   " while in Discovery Session, rejecting.\n",
+		target_err("Received illegal iSCSI Opcode: 0x%02x while in Discovery Session, rejecting.\n",
 			   opcode);
 		iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
 				  (unsigned char *)hdr);
@@ -1328,8 +1312,7 @@ static int cxgbit_rx_login_pdu(struct cxgbit_sock *csk)
 	login_req = (struct iscsi_login_req *)login->req;
 	memcpy(login_req, pdu_cb->hdr, sizeof(*login_req));
 
-	target_debug("Got Login Command, Flags 0x%02x, ITT: 0x%08x,"
-		     " CmdSN: 0x%08x, ExpStatSN: 0x%08x, CID: %hu, Length: %u\n",
+	target_debug("Got Login Command, Flags 0x%02x, ITT: 0x%08x, CmdSN: 0x%08x, ExpStatSN: 0x%08x, CID: %hu, Length: %u\n",
 		     login_req->flags, login_req->itt, login_req->cmdsn, login_req->exp_statsn,
 		     login_req->cid, pdu_cb->dlen);
 	/*
@@ -1393,9 +1376,8 @@ static void cxgbit_lro_skb_dump(struct sk_buff *skb)
 		    lro_cb->pdu_totallen);
 
 	for (i = 0; i < lro_cb->pdu_idx; i++, pdu_cb++)
-		target_info("skb 0x%p, pdu %d, %u, f 0x%x, seq 0x%x, dcrc 0x%x, "
-			    "frags %u.\n",
-			    skb, i, pdu_cb->pdulen, pdu_cb->flags, pdu_cb->seq, pdu_cb->ddigest,
+		target_info("skb 0x%p, pdu %d, %u, f 0x%x, seq 0x%x, dcrc 0x%x, frags %u.\n", skb,
+			    i, pdu_cb->pdulen, pdu_cb->flags, pdu_cb->seq, pdu_cb->ddigest,
 			    pdu_cb->frags);
 	for (i = 0; i < ssi->nr_frags; i++)
 		target_info("skb 0x%p, frag %d, off %u, sz %u.\n", skb, i,
diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index 5c0482ba3da5..313b829d6c54 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -514,9 +514,8 @@ iscsit_xmit_nondatain_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 
 		iov[0].iov_len += ISCSI_CRC_LEN;
 		tx_size += ISCSI_CRC_LEN;
-		target_debug("Attaching CRC32C HeaderDigest"
-			     " to opcode 0x%x 0x%08x\n",
-			     hdr->opcode, *header_digest);
+		target_debug("Attaching CRC32C HeaderDigest to opcode 0x%x 0x%08x\n", hdr->opcode,
+			     *header_digest);
 	}
 
 	if (data_buf_len) {
@@ -530,9 +529,7 @@ iscsit_xmit_nondatain_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 			iov[niov].iov_base = &cmd->pad_bytes;
 			iov[niov++].iov_len = padding;
 			tx_size += padding;
-			target_debug("Attaching %u additional"
-				     " padding bytes.\n",
-				     padding);
+			target_debug("Attaching %u additional padding bytes.\n", padding);
 		}
 
 		if (conn->conn_ops->DataDigest) {
@@ -544,8 +541,7 @@ iscsit_xmit_nondatain_pdu(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 			iov[niov].iov_base = &cmd->data_crc;
 			iov[niov++].iov_len = ISCSI_CRC_LEN;
 			tx_size += ISCSI_CRC_LEN;
-			target_debug("Attached DataDigest for %u"
-				     " bytes opcode 0x%x, CRC 0x%08x\n",
+			target_debug("Attached DataDigest for %u bytes opcode 0x%x, CRC 0x%08x\n",
 				     data_buf_len, hdr->opcode, cmd->data_crc);
 		}
 	}
@@ -710,8 +706,7 @@ static int __init iscsi_target_init_module(void)
 			sizeof(struct iscsi_queue_req),
 			__alignof__(struct iscsi_queue_req), 0, NULL);
 	if (!lio_qr_cache) {
-		target_err("Unable to kmem_cache_create() for"
-			   " lio_qr_cache\n");
+		target_err("Unable to kmem_cache_create() for lio_qr_cache\n");
 		goto cpumask_out;
 	}
 
@@ -719,8 +714,7 @@ static int __init iscsi_target_init_module(void)
 			sizeof(struct iscsi_datain_req),
 			__alignof__(struct iscsi_datain_req), 0, NULL);
 	if (!lio_dr_cache) {
-		target_err("Unable to kmem_cache_create() for"
-			   " lio_dr_cache\n");
+		target_err("Unable to kmem_cache_create() for lio_dr_cache\n");
 		goto qr_out;
 	}
 
@@ -728,8 +722,7 @@ static int __init iscsi_target_init_module(void)
 			sizeof(struct iscsi_ooo_cmdsn),
 			__alignof__(struct iscsi_ooo_cmdsn), 0, NULL);
 	if (!lio_ooo_cache) {
-		target_err("Unable to kmem_cache_create() for"
-			   " lio_ooo_cache\n");
+		target_err("Unable to kmem_cache_create() for lio_ooo_cache\n");
 		goto dr_out;
 	}
 
@@ -737,8 +730,7 @@ static int __init iscsi_target_init_module(void)
 			sizeof(struct iscsi_r2t), __alignof__(struct iscsi_r2t),
 			0, NULL);
 	if (!lio_r2t_cache) {
-		target_err("Unable to kmem_cache_create() for"
-			   " lio_r2t_cache\n");
+		target_err("Unable to kmem_cache_create() for lio_r2t_cache\n");
 		goto ooo_out;
 	}
 
@@ -1015,8 +1007,7 @@ int iscsit_setup_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 
 	if (!(hdr->flags & ISCSI_FLAG_CMD_WRITE) &&
 	    !(hdr->flags & ISCSI_FLAG_CMD_FINAL)) {
-		target_err("ISCSI_FLAG_CMD_WRITE & ISCSI_FLAG_CMD_FINAL"
-			   " not set. Bad iSCSI Initiator.\n");
+		target_err("ISCSI_FLAG_CMD_WRITE & ISCSI_FLAG_CMD_FINAL not set. Bad iSCSI Initiator.\n");
 		return iscsit_add_reject_cmd(cmd,
 					     ISCSI_REASON_BOOKMARK_INVALID, buf);
 	}
@@ -1036,17 +1027,13 @@ int iscsit_setup_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 		hdr->flags &= ~ISCSI_FLAG_CMD_READ;
 		hdr->flags &= ~ISCSI_FLAG_CMD_WRITE;
 
-		target_warn("ISCSI_FLAG_CMD_READ or ISCSI_FLAG_CMD_WRITE"
-			    " set when Expected Data Transfer Length is 0 for"
-			    " CDB: 0x%02x, Fixing up flags\n",
+		target_warn("ISCSI_FLAG_CMD_READ or ISCSI_FLAG_CMD_WRITE set when Expected Data Transfer Length is 0 for CDB: 0x%02x, Fixing up flags\n",
 			    hdr->cdb[0]);
 	}
 
 	if (!(hdr->flags & ISCSI_FLAG_CMD_READ) &&
 	    !(hdr->flags & ISCSI_FLAG_CMD_WRITE) && (hdr->data_length != 0)) {
-		target_err("ISCSI_FLAG_CMD_READ and/or ISCSI_FLAG_CMD_WRITE"
-			   " MUST be set if Expected Data Transfer Length is not 0."
-			   " Bad iSCSI Initiator\n");
+		target_err("ISCSI_FLAG_CMD_READ and/or ISCSI_FLAG_CMD_WRITE MUST be set if Expected Data Transfer Length is not 0. Bad iSCSI Initiator\n");
 		return iscsit_add_reject_cmd(cmd,
 					     ISCSI_REASON_BOOKMARK_INVALID, buf);
 	}
@@ -1059,15 +1046,13 @@ int iscsit_setup_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 	}
 
 	if (hdr->opcode & ISCSI_OP_IMMEDIATE) {
-		target_err("Illegally set Immediate Bit in iSCSI Initiator"
-			   " Scsi Command PDU.\n");
+		target_err("Illegally set Immediate Bit in iSCSI Initiator Scsi Command PDU.\n");
 		return iscsit_add_reject_cmd(cmd,
 					     ISCSI_REASON_BOOKMARK_INVALID, buf);
 	}
 
 	if (payload_length && !conn->sess->sess_ops->ImmediateData) {
-		target_err("ImmediateData=No but DataSegmentLength=%u,"
-			   " protocol error.\n",
+		target_err("ImmediateData=No but DataSegmentLength=%u, protocol error.\n",
 			   payload_length);
 		return iscsit_add_reject_cmd(cmd,
 					     ISCSI_REASON_PROTOCOL_ERROR, buf);
@@ -1075,32 +1060,27 @@ int iscsit_setup_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 
 	if ((be32_to_cpu(hdr->data_length) == payload_length) &&
 	    (!(hdr->flags & ISCSI_FLAG_CMD_FINAL))) {
-		target_err("Expected Data Transfer Length and Length of"
-			   " Immediate Data are the same, but ISCSI_FLAG_CMD_FINAL"
-			   " bit is not set protocol error\n");
+		target_err("Expected Data Transfer Length and Length of Immediate Data are the same, but ISCSI_FLAG_CMD_FINAL bit is not set protocol error\n");
 		return iscsit_add_reject_cmd(cmd,
 					     ISCSI_REASON_PROTOCOL_ERROR, buf);
 	}
 
 	if (payload_length > be32_to_cpu(hdr->data_length)) {
-		target_err("DataSegmentLength: %u is greater than"
-			   " EDTL: %u, protocol error.\n",
+		target_err("DataSegmentLength: %u is greater than EDTL: %u, protocol error.\n",
 			   payload_length, hdr->data_length);
 		return iscsit_add_reject_cmd(cmd,
 					     ISCSI_REASON_PROTOCOL_ERROR, buf);
 	}
 
 	if (payload_length > conn->conn_ops->MaxXmitDataSegmentLength) {
-		target_err("DataSegmentLength: %u is greater than"
-			   " MaxXmitDataSegmentLength: %u, protocol error.\n",
+		target_err("DataSegmentLength: %u is greater than MaxXmitDataSegmentLength: %u, protocol error.\n",
 			   payload_length, conn->conn_ops->MaxXmitDataSegmentLength);
 		return iscsit_add_reject_cmd(cmd,
 					     ISCSI_REASON_PROTOCOL_ERROR, buf);
 	}
 
 	if (payload_length > conn->sess->sess_ops->FirstBurstLength) {
-		target_err("DataSegmentLength: %u is greater than"
-			   " FirstBurstLength: %u, protocol error.\n",
+		target_err("DataSegmentLength: %u is greater than FirstBurstLength: %u, protocol error.\n",
 			   payload_length, conn->sess->sess_ops->FirstBurstLength);
 		return iscsit_add_reject_cmd(cmd,
 					     ISCSI_REASON_BOOKMARK_INVALID, buf);
@@ -1146,8 +1126,7 @@ int iscsit_setup_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 	else if (iscsi_task_attr == ISCSI_ATTR_ACA)
 		sam_task_attr = TCM_ACA_TAG;
 	else {
-		target_debug("Unknown iSCSI Task Attribute: 0x%02x, using"
-			     " TCM_SIMPLE_TAG\n",
+		target_debug("Unknown iSCSI Task Attribute: 0x%02x, using TCM_SIMPLE_TAG\n",
 			     iscsi_task_attr);
 		sam_task_attr = TCM_SIMPLE_TAG;
 	}
@@ -1194,8 +1173,7 @@ int iscsit_setup_scsi_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 			  cmd->sense_buffer + 2, scsilun_to_int(&hdr->lun),
 			  conn->cmd_cnt);
 
-	target_debug("Got SCSI Command, ITT: 0x%08x, CmdSN: 0x%08x,"
-		     " ExpXferLen: %u, Length: %u, CID: %hu\n",
+	target_debug("Got SCSI Command, ITT: 0x%08x, CmdSN: 0x%08x, ExpXferLen: %u, Length: %u, CID: %hu\n",
 		     hdr->itt, hdr->cmdsn, be32_to_cpu(hdr->data_length), payload_length,
 		     conn->cid);
 
@@ -1489,21 +1467,18 @@ __iscsit_check_dataout_hdr(struct iscsit_conn *conn, void *buf,
 	/* iSCSI write */
 	atomic_long_add(payload_length, &conn->sess->rx_data_octets);
 
-	target_debug("Got DataOut ITT: 0x%08x, TTT: 0x%08x,"
-		     " DataSN: 0x%08x, Offset: %u, Length: %u, CID: %hu\n",
+	target_debug("Got DataOut ITT: 0x%08x, TTT: 0x%08x, DataSN: 0x%08x, Offset: %u, Length: %u, CID: %hu\n",
 		     hdr->itt, hdr->ttt, hdr->datasn, ntohl(hdr->offset), payload_length,
 		     conn->cid);
 
 	if (cmd->cmd_flags & ICF_GOT_LAST_DATAOUT) {
-		target_err("Command ITT: 0x%08x received DataOUT after"
-			   " last DataOUT received, dumping payload\n",
+		target_err("Command ITT: 0x%08x received DataOUT after last DataOUT received, dumping payload\n",
 			   cmd->init_task_tag);
 		return iscsit_dump_data_payload(conn, payload_length, 1);
 	}
 
 	if (cmd->data_direction != DMA_TO_DEVICE) {
-		target_err("Command ITT: 0x%08x received DataOUT for a"
-			   " NON-WRITE command.\n",
+		target_err("Command ITT: 0x%08x received DataOUT for a NON-WRITE command.\n",
 			   cmd->init_task_tag);
 		return iscsit_dump_data_payload(conn, payload_length, 1);
 	}
@@ -1520,8 +1495,7 @@ __iscsit_check_dataout_hdr(struct iscsit_conn *conn, void *buf,
 		int dump_unsolicited_data = 0;
 
 		if (conn->sess->sess_ops->InitialR2T) {
-			target_err("Received unexpected unsolicited data"
-				   " while InitialR2T=Yes, protocol error.\n");
+			target_err("Received unexpected unsolicited data while InitialR2T=Yes, protocol error.\n");
 			transport_send_check_condition_and_sense(&cmd->se_cmd,
 					TCM_UNEXPECTED_UNSOLICITED_DATA, 0);
 			return -1;
@@ -1597,8 +1571,7 @@ iscsit_check_dataout_hdr(struct iscsit_conn *conn, void *buf,
 	}
 
 	if (payload_length > conn->conn_ops->MaxXmitDataSegmentLength) {
-		target_err_ratelimited("DataSegmentLength: %u is greater than"
-				       " MaxXmitDataSegmentLength: %u\n",
+		target_err_ratelimited("DataSegmentLength: %u is greater than MaxXmitDataSegmentLength: %u\n",
 				       payload_length, conn->conn_ops->MaxXmitDataSegmentLength);
 		return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR, buf);
 	}
@@ -1668,15 +1641,12 @@ iscsit_get_dataout(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 						    cmd->pad_bytes);
 
 		if (checksum != data_crc) {
-			target_err("ITT: 0x%08x, Offset: %u, Length: %u,"
-				   " DataSN: 0x%08x, CRC32C DataDigest 0x%08x"
-				   " does not match computed 0x%08x\n",
+			target_err("ITT: 0x%08x, Offset: %u, Length: %u, DataSN: 0x%08x, CRC32C DataDigest 0x%08x does not match computed 0x%08x\n",
 				   hdr->itt, hdr->offset, payload_length, hdr->datasn, checksum,
 				   data_crc);
 			data_crc_failed = 1;
 		} else {
-			target_debug("Got CRC32C DataDigest 0x%08x for"
-				     " %u bytes of Data Out\n",
+			target_debug("Got CRC32C DataDigest 0x%08x for %u bytes of Data Out\n",
 				     checksum, payload_length);
 		}
 	}
@@ -1761,8 +1731,7 @@ int iscsit_setup_nop_out(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 	}
 
 	if (hdr->itt == RESERVED_ITT && !(hdr->opcode & ISCSI_OP_IMMEDIATE)) {
-		target_err("NOPOUT ITT is reserved, but Immediate Bit is"
-			   " not set, protocol error.\n");
+		target_err("NOPOUT ITT is reserved, but Immediate Bit is not set, protocol error.\n");
 		if (!cmd)
 			return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
 						 (unsigned char *)hdr);
@@ -1772,9 +1741,7 @@ int iscsit_setup_nop_out(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 	}
 
 	if (payload_length > conn->conn_ops->MaxXmitDataSegmentLength) {
-		target_err("NOPOUT Ping Data DataSegmentLength: %u is"
-			   " greater than MaxXmitDataSegmentLength: %u, protocol"
-			   " error.\n",
+		target_err("NOPOUT Ping Data DataSegmentLength: %u is greater than MaxXmitDataSegmentLength: %u, protocol error.\n",
 			   payload_length, conn->conn_ops->MaxXmitDataSegmentLength);
 		if (!cmd)
 			return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
@@ -1784,8 +1751,7 @@ int iscsit_setup_nop_out(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 					 (unsigned char *)hdr);
 	}
 
-	target_debug("Got NOPOUT Ping %s ITT: 0x%08x, TTT: 0x%08x,"
-		     " CmdSN: 0x%08x, ExpStatSN: 0x%08x, Length: %u\n",
+	target_debug("Got NOPOUT Ping %s ITT: 0x%08x, TTT: 0x%08x, CmdSN: 0x%08x, ExpStatSN: 0x%08x, Length: %u\n",
 		     hdr->itt == RESERVED_ITT ? "Response" : "Request", hdr->itt, hdr->ttt,
 		     hdr->cmdsn, hdr->exp_statsn, payload_length);
 	/*
@@ -1904,9 +1870,7 @@ static int iscsit_handle_nop_out(struct iscsit_conn *conn, struct iscsit_cmd *cm
 
 		padding = ((-payload_length) & 3);
 		if (padding != 0) {
-			target_debug("Receiving %u additional bytes"
-				     " for padding.\n",
-				     padding);
+			target_debug("Receiving %u additional bytes for padding.\n", padding);
 			iov[niov].iov_base	= &cmd->pad_bytes;
 			iov[niov++].iov_len	= padding;
 			rx_size += padding;
@@ -1930,13 +1894,10 @@ static int iscsit_handle_nop_out(struct iscsit_conn *conn, struct iscsit_cmd *cm
 						  cmd->pad_bytes, &data_crc);
 
 			if (checksum != data_crc) {
-				target_err("Ping data CRC32C DataDigest"
-					   " 0x%08x does not match computed 0x%08x\n",
+				target_err("Ping data CRC32C DataDigest 0x%08x does not match computed 0x%08x\n",
 					   checksum, data_crc);
 				if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
-					target_err("Unable to recover from"
-						   " NOPOUT Ping DataCRC failure while in"
-						   " ERL=0.\n");
+					target_err("Unable to recover from NOPOUT Ping DataCRC failure while in ERL=0.\n");
 					ret = -1;
 					goto out;
 				} else {
@@ -1944,16 +1905,13 @@ static int iscsit_handle_nop_out(struct iscsit_conn *conn, struct iscsit_cmd *cm
 					 * Silently drop this PDU and let the
 					 * initiator plug the CmdSN gap.
 					 */
-					target_debug("Dropping NOPOUT"
-						     " Command CmdSN: 0x%08x due to"
-						     " DataCRC error.\n",
+					target_debug("Dropping NOPOUT Command CmdSN: 0x%08x due to DataCRC error.\n",
 						     hdr->cmdsn);
 					ret = 0;
 					goto out;
 				}
 			} else {
-				target_debug("Got CRC32C DataDigest"
-					     " 0x%08x for %u bytes of ping data.\n",
+				target_debug("Got CRC32C DataDigest 0x%08x for %u bytes of ping data.\n",
 					     checksum, payload_length);
 			}
 		}
@@ -1965,9 +1923,7 @@ static int iscsit_handle_nop_out(struct iscsit_conn *conn, struct iscsit_cmd *cm
 		cmd->buf_ptr = ping_data;
 		cmd->buf_ptr_size = payload_length;
 
-		target_debug("Got %u bytes of NOPOUT ping"
-			     " data.\n",
-			     payload_length);
+		target_debug("Got %u bytes of NOPOUT ping data.\n", payload_length);
 		target_debug("Ping Data: \"%s\"\n", ping_data);
 	}
 
@@ -2016,9 +1972,7 @@ iscsit_handle_task_mgt_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 	hdr->flags &= ~ISCSI_FLAG_CMD_FINAL;
 	function = hdr->flags;
 
-	target_debug("Got Task Management Request ITT: 0x%08x, CmdSN:"
-		     " 0x%08x, Function: 0x%02x, RefTaskTag: 0x%08x, RefCmdSN:"
-		     " 0x%08x, CID: %hu\n",
+	target_debug("Got Task Management Request ITT: 0x%08x, CmdSN: 0x%08x, Function: 0x%02x, RefTaskTag: 0x%08x, RefCmdSN: 0x%08x, CID: %hu\n",
 		     hdr->itt, hdr->cmdsn, function, hdr->rtt, hdr->refcmdsn, conn->cid);
 
 	if ((function != ISCSI_TM_FUNC_ABORT_TASK) &&
@@ -2030,9 +1984,7 @@ iscsit_handle_task_mgt_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 
 	if ((function == ISCSI_TM_FUNC_TASK_REASSIGN) &&
 			!(hdr->opcode & ISCSI_OP_IMMEDIATE)) {
-		target_err("Task Management Request TASK_REASSIGN not"
-			   " issued as immediate command, bad iSCSI Initiator"
-			   "implementation\n");
+		target_err("Task Management Request TASK_REASSIGN not issued as immediate command, bad iSCSI Initiator implementation\n");
 		return iscsit_add_reject_cmd(cmd,
 					     ISCSI_REASON_PROTOCOL_ERROR, buf);
 	}
@@ -2063,9 +2015,7 @@ iscsit_handle_task_mgt_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 	if (function != ISCSI_TM_FUNC_TASK_REASSIGN) {
 		tcm_function = iscsit_convert_tmf(function);
 		if (tcm_function == TMR_UNKNOWN) {
-			target_err("Unknown iSCSI TMR Function:"
-				   " 0x%02x\n",
-				   function);
+			target_err("Unknown iSCSI TMR Function: 0x%02x\n", function);
 			return iscsit_add_reject_cmd(cmd,
 				ISCSI_REASON_BOOKMARK_NO_RESOURCES, buf);
 		}
@@ -2135,9 +2085,7 @@ iscsit_handle_task_mgt_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 					ISCSI_REASON_BOOKMARK_INVALID, buf);
 		break;
 	default:
-		target_err("Unknown TMR function: 0x%02x, protocol"
-			   " error.\n",
-			   function);
+		target_err("Unknown TMR function: 0x%02x, protocol error.\n", function);
 		se_tmr->response = ISCSI_TMF_RSP_NOT_SUPPORTED;
 		goto attach;
 	}
@@ -2193,8 +2141,7 @@ iscsit_setup_text_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 	u32 payload_length = ntoh24(hdr->dlength);
 
 	if (payload_length > conn->conn_ops->MaxXmitDataSegmentLength) {
-		target_err("Unable to accept text parameter length: %u"
-			   "greater than MaxXmitDataSegmentLength %u.\n",
+		target_err("Unable to accept text parameter length: %u greater than MaxXmitDataSegmentLength %u.\n",
 			   payload_length, conn->conn_ops->MaxXmitDataSegmentLength);
 		return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
 					 (unsigned char *)hdr);
@@ -2207,8 +2154,7 @@ iscsit_setup_text_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 					(unsigned char *)hdr);
 	}
 
-	target_debug("Got Text Request: ITT: 0x%08x, CmdSN: 0x%08x,"
-		     " ExpStatSN: 0x%08x, Length: %u\n",
+	target_debug("Got Text Request: ITT: 0x%08x, CmdSN: 0x%08x, ExpStatSN: 0x%08x, Length: %u\n",
 		     hdr->itt, hdr->cmdsn, hdr->exp_statsn, payload_length);
 
 	cmd->iscsi_opcode	= ISCSI_OP_TEXT;
@@ -2236,15 +2182,13 @@ iscsit_process_text_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 	if (!text_in) {
 		cmd->targ_xfer_tag = be32_to_cpu(hdr->ttt);
 		if (cmd->targ_xfer_tag == 0xFFFFFFFF) {
-			target_err("Unable to locate text_in buffer for sendtargets"
-				   " discovery\n");
+			target_err("Unable to locate text_in buffer for sendtargets discovery\n");
 			goto reject;
 		}
 		goto empty_sendtargets;
 	}
 	if (strncmp("SendTargets=", text_in, 12) != 0) {
-		target_err("Received Text Data that is not"
-			   " SendTargets, cannot continue.\n");
+		target_err("Received Text Data that is not SendTargets, cannot continue.\n");
 		goto reject;
 	}
 	/* '=' confirmed in strncmp */
@@ -2317,9 +2261,7 @@ iscsit_handle_text_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 
 		padding = rx_size - payload_length;
 		if (padding)
-			target_debug("Receiving %u additional bytes"
-				     " for padding.\n",
-				     padding);
+			target_debug("Receiving %u additional bytes for padding.\n", padding);
 		if (conn->conn_ops->DataDigest) {
 			iov[niov].iov_base	= &checksum;
 			iov[niov++].iov_len	= ISCSI_CRC_LEN;
@@ -2337,37 +2279,28 @@ iscsit_handle_text_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 						  &data_crc);
 
 			if (checksum != data_crc) {
-				target_err("Text data CRC32C DataDigest"
-					   " 0x%08x does not match computed"
-					   " 0x%08x\n",
+				target_err("Text data CRC32C DataDigest 0x%08x does not match computed 0x%08x\n",
 					   checksum, data_crc);
 				if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
-					target_err("Unable to recover from"
-						   " Text Data digest failure while in"
-						   " ERL=0.\n");
+					target_err("Unable to recover from Text Data digest failure while in ERL=0.\n");
 					goto reject;
 				} else {
 					/*
 					 * Silently drop this PDU and let the
 					 * initiator plug the CmdSN gap.
 					 */
-					target_debug("Dropping Text"
-						     " Command CmdSN: 0x%08x due to"
-						     " DataCRC error.\n",
+					target_debug("Dropping Text Command CmdSN: 0x%08x due to DataCRC error.\n",
 						     hdr->cmdsn);
 					kfree(text_in);
 					return 0;
 				}
 			} else {
-				target_debug("Got CRC32C DataDigest"
-					     " 0x%08x for %u bytes of text data.\n",
+				target_debug("Got CRC32C DataDigest 0x%08x for %u bytes of text data.\n",
 					     checksum, payload_length);
 			}
 		}
 		text_in[payload_length - 1] = '\0';
-		target_debug("Successfully read %d bytes of text"
-			     " data.\n",
-			     payload_length);
+		target_debug("Successfully read %d bytes of text data.\n", payload_length);
 	}
 
 	return iscsit_process_text_cmd(conn, cmd, hdr);
@@ -2383,9 +2316,8 @@ int iscsit_logout_closesession(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
 	struct iscsit_conn *conn_p;
 	struct iscsit_session *sess = conn->sess;
 
-	target_debug("Received logout request CLOSESESSION on CID: %hu"
-		     " for SID: %u.\n",
-		     conn->cid, conn->sess->sid);
+	target_debug("Received logout request CLOSESESSION on CID: %hu for SID: %u.\n", conn->cid,
+		     conn->sess->sid);
 
 	atomic_set(&sess->session_logout, 1);
 	atomic_set(&conn->conn_logout_remove, 1);
@@ -2414,8 +2346,7 @@ int iscsit_logout_closeconnection(struct iscsit_cmd *cmd, struct iscsit_conn *co
 	struct iscsit_conn *l_conn;
 	struct iscsit_session *sess = conn->sess;
 
-	target_debug("Received logout request CLOSECONNECTION for CID:"
-		     " %hu on CID: %hu.\n",
+	target_debug("Received logout request CLOSECONNECTION for CID: %hu on CID: %hu.\n",
 		     cmd->logout_cid, conn->cid);
 
 	/*
@@ -2462,21 +2393,18 @@ int iscsit_logout_removeconnforrecovery(struct iscsit_cmd *cmd, struct iscsit_co
 {
 	struct iscsit_session *sess = conn->sess;
 
-	target_debug("Received explicit REMOVECONNFORRECOVERY logout for"
-		     " CID: %hu on CID: %hu.\n",
+	target_debug("Received explicit REMOVECONNFORRECOVERY logout for CID: %hu on CID: %hu.\n",
 		     cmd->logout_cid, conn->cid);
 
 	if (sess->sess_ops->ErrorRecoveryLevel != 2) {
-		target_err("Received Logout Request REMOVECONNFORRECOVERY"
-			   " while ERL!=2.\n");
+		target_err("Received Logout Request REMOVECONNFORRECOVERY while ERL!=2.\n");
 		cmd->logout_response = ISCSI_LOGOUT_RECOVERY_UNSUPPORTED;
 		iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
 		return 0;
 	}
 
 	if (conn->cid == cmd->logout_cid) {
-		target_err("Received Logout Request REMOVECONNFORRECOVERY"
-			   " with CID: %hu on CID: %hu, implementation error.\n",
+		target_err("Received Logout Request REMOVECONNFORRECOVERY with CID: %hu on CID: %hu, implementation error.\n",
 			   cmd->logout_cid, conn->cid);
 		cmd->logout_response = ISCSI_LOGOUT_CLEANUP_FAILED;
 		iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
@@ -2509,13 +2437,11 @@ iscsit_handle_logout_cmd(struct iscsit_conn *conn, struct iscsit_cmd *cmd,
 		spin_unlock(&tiqn->logout_stats.lock);
 	}
 
-	target_debug("Got Logout Request ITT: 0x%08x CmdSN: 0x%08x"
-		     " ExpStatSN: 0x%08x Reason: 0x%02x CID: %hu on CID: %hu\n",
+	target_debug("Got Logout Request ITT: 0x%08x CmdSN: 0x%08x ExpStatSN: 0x%08x Reason: 0x%02x CID: %hu on CID: %hu\n",
 		     hdr->itt, hdr->cmdsn, hdr->exp_statsn, reason_code, hdr->cid, conn->cid);
 
 	if (conn->conn_state != TARG_CONN_STATE_LOGGED_IN) {
-		target_err("Received logout request on connection that"
-			   " is not in logged in state, ignoring request.\n");
+		target_err("Received logout request on connection that is not in logged in state, ignoring request.\n");
 		iscsit_free_cmd(cmd, false);
 		return 0;
 	}
@@ -2577,14 +2503,11 @@ int iscsit_handle_snack(
 	hdr			= (struct iscsi_snack *) buf;
 	hdr->flags		&= ~ISCSI_FLAG_CMD_FINAL;
 
-	target_debug("Got ISCSI_INIT_SNACK, ITT: 0x%08x, ExpStatSN:"
-		     " 0x%08x, Type: 0x%02x, BegRun: 0x%08x, RunLength: 0x%08x,"
-		     " CID: %hu\n",
+	target_debug("Got ISCSI_INIT_SNACK, ITT: 0x%08x, ExpStatSN: 0x%08x, Type: 0x%02x, BegRun: 0x%08x, RunLength: 0x%08x, CID: %hu\n",
 		     hdr->itt, hdr->exp_statsn, hdr->flags, hdr->begrun, hdr->runlength, conn->cid);
 
 	if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
-		target_err("Initiator sent SNACK request while in"
-			   " ErrorRecoveryLevel=0.\n");
+		target_err("Initiator sent SNACK request while in ErrorRecoveryLevel=0.\n");
 		return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
 					 buf);
 	}
@@ -2613,9 +2536,7 @@ int iscsit_handle_snack(
 		return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
 					 buf);
 	default:
-		target_err("Unknown SNACK type 0x%02x, protocol"
-			   " error.\n",
-			   hdr->flags & 0x0f);
+		target_err("Unknown SNACK type 0x%02x, protocol error.\n", hdr->flags & 0x0f);
 		return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
 					 buf);
 	}
@@ -2703,14 +2624,11 @@ static int iscsit_handle_immediate_data(
 						    cmd->pad_bytes);
 
 		if (checksum != data_crc) {
-			target_err("ImmediateData CRC32C DataDigest 0x%08x"
-				   " does not match computed 0x%08x\n",
+			target_err("ImmediateData CRC32C DataDigest 0x%08x does not match computed 0x%08x\n",
 				   checksum, data_crc);
 
 			if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
-				target_err("Unable to recover from"
-					   " Immediate Data digest failure while"
-					   " in ERL=0.\n");
+				target_err("Unable to recover from Immediate Data digest failure while in ERL=0.\n");
 				iscsit_reject_cmd(cmd,
 						ISCSI_REASON_DATA_DIGEST_ERROR,
 						(unsigned char *)hdr);
@@ -2722,8 +2640,7 @@ static int iscsit_handle_immediate_data(
 				return IMMEDIATE_DATA_ERL1_CRC_FAILURE;
 			}
 		} else {
-			target_debug("Got CRC32C DataDigest 0x%08x for"
-				     " %u bytes of Immediate Data\n",
+			target_debug("Got CRC32C DataDigest 0x%08x for %u bytes of Immediate Data\n",
 				     checksum, length);
 		}
 	}
@@ -2806,8 +2723,7 @@ static int iscsit_send_conn_drop_async_message(
 	hdr->param2		= cpu_to_be16(conn->sess->sess_ops->DefaultTime2Wait);
 	hdr->param3		= cpu_to_be16(conn->sess->sess_ops->DefaultTime2Retain);
 
-	target_debug("Sending Connection Dropped Async Message StatSN:"
-		     " 0x%08x, for CID: %hu on CID: %hu\n",
+	target_debug("Sending Connection Dropped Async Message StatSN: 0x%08x, for CID: %hu on CID: %hu\n",
 		     cmd->stat_sn, cmd->logout_cid, conn->cid);
 
 	return conn->conn_transport->iscsit_xmit_pdu(conn, cmd, NULL, NULL, 0);
@@ -2862,8 +2778,7 @@ iscsit_build_datain_pdu(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
 	hdr->datasn		= cpu_to_be32(datain->data_sn);
 	hdr->offset		= cpu_to_be32(datain->offset);
 
-	target_debug("Built DataIN ITT: 0x%08x, StatSN: 0x%08x,"
-		     " DataSN: 0x%08x, Offset: %u, Length: %u, CID: %hu\n",
+	target_debug("Built DataIN ITT: 0x%08x, StatSN: 0x%08x, DataSN: 0x%08x, Offset: %u, Length: %u, CID: %hu\n",
 		     cmd->init_task_tag, ntohl(hdr->statsn), ntohl(hdr->datasn), ntohl(hdr->offset),
 		     datain->length, conn->cid);
 }
@@ -2887,8 +2802,7 @@ static int iscsit_send_datain(struct iscsit_cmd *cmd, struct iscsit_conn *conn)
 	 * Be paranoid and double check the logic for now.
 	 */
 	if ((datain.offset + datain.length) > cmd->se_cmd.data_length) {
-		target_err("Command ITT: 0x%08x, datain.offset: %u and"
-			   " datain.length: %u exceeds cmd->data_length: %u\n",
+		target_err("Command ITT: 0x%08x, datain.offset: %u and datain.length: %u exceeds cmd->data_length: %u\n",
 			   cmd->init_task_tag, datain.offset, datain.length,
 			   cmd->se_cmd.data_length);
 		return -1;
@@ -2942,8 +2856,7 @@ iscsit_build_logout_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
 	 */
 	switch (cmd->logout_reason) {
 	case ISCSI_LOGOUT_REASON_CLOSE_SESSION:
-		target_debug("iSCSI session logout successful, setting"
-			     " logout response to ISCSI_LOGOUT_SUCCESS.\n");
+		target_debug("iSCSI session logout successful, setting logout response to ISCSI_LOGOUT_SUCCESS.\n");
 		cmd->logout_response = ISCSI_LOGOUT_SUCCESS;
 		break;
 	case ISCSI_LOGOUT_REASON_CLOSE_CONNECTION:
@@ -2961,9 +2874,8 @@ iscsit_build_logout_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
 		 * is stopped in iscsit_logout_post_handler_diffcid().
 		 */
 
-		target_debug("iSCSI CID: %hu logout on CID: %hu"
-			     " successful.\n",
-			     cmd->logout_cid, conn->cid);
+		target_debug("iSCSI CID: %hu logout on CID: %hu successful.\n", cmd->logout_cid,
+			     conn->cid);
 		cmd->logout_response = ISCSI_LOGOUT_SUCCESS;
 		break;
 	case ISCSI_LOGOUT_REASON_RECOVERY:
@@ -2984,8 +2896,7 @@ iscsit_build_logout_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
 		cr = iscsit_get_inactive_connection_recovery_entry(
 				conn->sess, cmd->logout_cid);
 		if (!cr) {
-			target_err("Unable to locate CID: %hu for"
-				   " REMOVECONNFORRECOVERY Logout Request.\n",
+			target_err("Unable to locate CID: %hu for REMOVECONNFORRECOVERY Logout Request.\n",
 				   cmd->logout_cid);
 			cmd->logout_response = ISCSI_LOGOUT_CID_NOT_FOUND;
 			break;
@@ -2993,8 +2904,7 @@ iscsit_build_logout_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
 
 		iscsit_discard_cr_cmds_by_expstatsn(cr, cmd->exp_stat_sn);
 
-		target_debug("iSCSI REMOVECONNFORRECOVERY logout"
-			     " for recovery for CID: %hu on CID: %hu successful.\n",
+		target_debug("iSCSI REMOVECONNFORRECOVERY logout for recovery for CID: %hu on CID: %hu successful.\n",
 			     cmd->logout_cid, conn->cid);
 		cmd->logout_response = ISCSI_LOGOUT_SUCCESS;
 		break;
@@ -3014,8 +2924,7 @@ iscsit_build_logout_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
 	hdr->exp_cmdsn		= cpu_to_be32(conn->sess->exp_cmd_sn);
 	hdr->max_cmdsn		= cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn));
 
-	target_debug("Built Logout Response ITT: 0x%08x StatSN:"
-		     " 0x%08x Response: 0x%02x CID: %hu on CID: %hu\n",
+	target_debug("Built Logout Response ITT: 0x%08x StatSN: 0x%08x Response: 0x%02x CID: %hu on CID: %hu\n",
 		     cmd->init_task_tag, cmd->stat_sn, hdr->response, cmd->logout_cid, conn->cid);
 
 	return 0;
@@ -3056,8 +2965,7 @@ iscsit_build_nopin_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
 	hdr->exp_cmdsn		= cpu_to_be32(conn->sess->exp_cmd_sn);
 	hdr->max_cmdsn		= cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn));
 
-	target_debug("Built NOPIN %s Response ITT: 0x%08x, TTT: 0x%08x,"
-		     " StatSN: 0x%08x, Length %u\n",
+	target_debug("Built NOPIN %s Response ITT: 0x%08x, TTT: 0x%08x, StatSN: 0x%08x, Length %u\n",
 		     (nopout_response) ? "Solicited" : "Unsolicited", cmd->init_task_tag,
 		     cmd->targ_xfer_tag, cmd->stat_sn, cmd->buf_ptr_size);
 }
@@ -3076,9 +2984,8 @@ static int iscsit_send_unsolicited_nopin(
 
 	iscsit_build_nopin_rsp(cmd, conn, hdr, false);
 
-	target_debug("Sending Unsolicited NOPIN TTT: 0x%08x StatSN:"
-		     " 0x%08x CID: %hu\n",
-		     hdr->ttt, cmd->stat_sn, conn->cid);
+	target_debug("Sending Unsolicited NOPIN TTT: 0x%08x StatSN: 0x%08x CID: %hu\n", hdr->ttt,
+		     cmd->stat_sn, conn->cid);
 
 	ret = conn->conn_transport->iscsit_xmit_pdu(conn, cmd, NULL, NULL, 0);
 	if (ret < 0)
@@ -3141,8 +3048,7 @@ static int iscsit_send_r2t(
 	hdr->data_offset	= cpu_to_be32(r2t->offset);
 	hdr->data_length	= cpu_to_be32(r2t->xfer_len);
 
-	target_debug("Built %sR2T, ITT: 0x%08x, TTT: 0x%08x, StatSN:"
-		     " 0x%08x, R2TSN: 0x%08x, Offset: %u, DDTL: %u, CID: %hu\n",
+	target_debug("Built %sR2T, ITT: 0x%08x, TTT: 0x%08x, StatSN: 0x%08x, R2TSN: 0x%08x, Offset: %u, DDTL: %u, CID: %hu\n",
 		     (!r2t->recovery_r2t) ? "" : "Recovery ", cmd->init_task_tag,
 		     r2t->targ_xfer_tag, ntohl(hdr->statsn), r2t->r2t_sn, r2t->offset,
 		     r2t->xfer_len, conn->cid);
@@ -3278,8 +3184,7 @@ void iscsit_build_rsp_pdu(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
 	hdr->exp_cmdsn		= cpu_to_be32(conn->sess->exp_cmd_sn);
 	hdr->max_cmdsn		= cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn));
 
-	target_debug("Built SCSI Response, ITT: 0x%08x, StatSN: 0x%08x,"
-		     " Response: 0x%02x, SAM Status: 0x%02x, CID: %hu\n",
+	target_debug("Built SCSI Response, ITT: 0x%08x, StatSN: 0x%08x, Response: 0x%02x, SAM Status: 0x%02x, CID: %hu\n",
 		     cmd->init_task_tag, cmd->stat_sn, cmd->se_cmd.scsi_status,
 		     cmd->se_cmd.scsi_status, conn->cid);
 }
@@ -3311,13 +3216,10 @@ static int iscsit_send_response(struct iscsit_cmd *cmd, struct iscsit_conn *conn
 		if (padding) {
 			memset(cmd->sense_buffer +
 				cmd->se_cmd.scsi_sense_length, 0, padding);
-			target_debug("Adding %u bytes of padding to"
-				     " SENSE.\n",
-				     padding);
+			target_debug("Adding %u bytes of padding to SENSE.\n", padding);
 		}
 
-		target_debug("Attaching SENSE DATA: %u bytes to iSCSI"
-			     " Response PDU\n",
+		target_debug("Attaching SENSE DATA: %u bytes to iSCSI Response PDU\n",
 			     cmd->se_cmd.scsi_sense_length);
 	}
 
@@ -3359,8 +3261,7 @@ iscsit_build_task_mgt_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
 	hdr->exp_cmdsn		= cpu_to_be32(conn->sess->exp_cmd_sn);
 	hdr->max_cmdsn		= cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn));
 
-	target_debug("Built Task Management Response ITT: 0x%08x,"
-		     " StatSN: 0x%08x, Response: 0x%02x, CID: %hu\n",
+	target_debug("Built Task Management Response ITT: 0x%08x, StatSN: 0x%08x, Response: 0x%02x, CID: %hu\n",
 		     cmd->init_task_tag, cmd->stat_sn, hdr->response, conn->cid);
 }
 EXPORT_SYMBOL(iscsit_build_task_mgt_rsp);
@@ -3407,9 +3308,7 @@ iscsit_build_sendtargets_response(struct iscsit_cmd *cmd,
 	if (cmd->cmd_flags & ICF_SENDTARGETS_SINGLE) {
 		text_ptr = strchr(text_in, '=');
 		if (!text_ptr) {
-			target_err("Unable to locate '=' string in text_in:"
-				   " %s\n",
-				   text_in);
+			target_err("Unable to locate '=' string in text_in: %s\n", text_in);
 			kfree(payload);
 			return -EINVAL;
 		}
@@ -3568,8 +3467,7 @@ iscsit_build_text_rsp(struct iscsit_cmd *cmd, struct iscsit_conn *conn,
 	hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn);
 	hdr->max_cmdsn = cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn));
 
-	target_debug("Built Text Response: ITT: 0x%08x, TTT: 0x%08x, StatSN: 0x%08x,"
-		     " Length: %u, CID: %hu F: %d C: %d\n",
+	target_debug("Built Text Response: ITT: 0x%08x, TTT: 0x%08x, StatSN: 0x%08x, Length: %u, CID: %hu F: %d C: %d\n",
 		     cmd->init_task_tag, cmd->targ_xfer_tag, cmd->stat_sn, text_length, conn->cid,
 		     !!(hdr->flags & ISCSI_FLAG_CMD_FINAL),
 		     !!(hdr->flags & ISCSI_FLAG_TEXT_CONTINUE));
@@ -3620,8 +3518,7 @@ static int iscsit_send_reject(
 
 	iscsit_build_reject(cmd, conn, hdr);
 
-	target_debug("Built Reject PDU StatSN: 0x%08x, Reason: 0x%02x,"
-		     " CID: %hu\n",
+	target_debug("Built Reject PDU StatSN: 0x%08x, Reason: 0x%02x, CID: %hu\n",
 		     ntohl(hdr->statsn), hdr->reason, conn->cid);
 
 	return conn->conn_transport->iscsit_xmit_pdu(conn, cmd, NULL,
@@ -3758,8 +3655,7 @@ iscsit_immediate_queue(struct iscsit_conn *conn, struct iscsit_cmd *cmd, int sta
 			goto err;
 		break;
 	default:
-		target_err("Unknown Opcode: 0x%02x ITT:"
-			   " 0x%08x, i_state: %d on CID: %hu\n",
+		target_err("Unknown Opcode: 0x%02x ITT: 0x%08x, i_state: %d on CID: %hu\n",
 			   cmd->iscsi_opcode, cmd->init_task_tag, state, conn->cid);
 		goto err;
 	}
@@ -3858,8 +3754,7 @@ iscsit_response_queue(struct iscsit_conn *conn, struct iscsit_cmd *cmd, int stat
 		ret = iscsit_send_text_rsp(cmd, conn);
 		break;
 	default:
-		target_err("Unknown Opcode: 0x%02x ITT:"
-			   " 0x%08x, i_state: %d on CID: %hu\n",
+		target_err("Unknown Opcode: 0x%02x ITT: 0x%08x, i_state: %d on CID: %hu\n",
 			   cmd->iscsi_opcode, cmd->init_task_tag, state, conn->cid);
 		goto err;
 	}
@@ -3883,8 +3778,7 @@ iscsit_response_queue(struct iscsit_conn *conn, struct iscsit_cmd *cmd, int stat
 		spin_unlock_bh(&cmd->istate_lock);
 		break;
 	default:
-		target_err("Unknown Opcode: 0x%02x ITT:"
-			   " 0x%08x, i_state: %d on CID: %hu\n",
+		target_err("Unknown Opcode: 0x%02x ITT: 0x%08x, i_state: %d on CID: %hu\n",
 			   cmd->iscsi_opcode, cmd->init_task_tag, cmd->i_state, conn->cid);
 		goto err;
 	}
@@ -4040,12 +3934,10 @@ static int iscsi_target_rx_opcode(struct iscsit_conn *conn, unsigned char *buf)
 	default:
 		target_err("Got unknown iSCSI OpCode: 0x%02x\n", hdr->opcode);
 		if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
-			target_err("Cannot recover from unknown"
-				   " opcode while ERL=0, closing iSCSI connection.\n");
+			target_err("Cannot recover from unknown opcode while ERL=0, closing iSCSI connection.\n");
 			return -1;
 		}
-		target_err("Unable to recover from unknown opcode while OFMarker=No,"
-			   " closing iSCSI connection.\n");
+		target_err("Unable to recover from unknown opcode while OFMarker=No, closing iSCSI connection.\n");
 		ret = -1;
 		break;
 	}
@@ -4130,8 +4022,7 @@ static void iscsit_get_rx_pdu(struct iscsit_conn *conn)
 						  &checksum);
 
 			if (digest != checksum) {
-				target_err("HeaderDigest CRC32C failed,"
-					   " received 0x%08x, computed 0x%08x\n",
+				target_err("HeaderDigest CRC32C failed, received 0x%08x, computed 0x%08x\n",
 					   digest, checksum);
 				/*
 				 * Set the PDU to 0xff so it will intentionally
@@ -4140,9 +4031,7 @@ static void iscsit_get_rx_pdu(struct iscsit_conn *conn)
 				memset(buffer, 0xff, ISCSI_HDR_LEN);
 				atomic_long_inc(&conn->sess->conn_digest_errors);
 			} else {
-				target_debug("Got HeaderDigest CRC32C"
-					     " 0x%08x\n",
-					     checksum);
+				target_debug("Got HeaderDigest CRC32C 0x%08x\n", checksum);
 			}
 		}
 
@@ -4154,8 +4043,7 @@ static void iscsit_get_rx_pdu(struct iscsit_conn *conn)
 		if (conn->sess->sess_ops->SessionType &&
 		   ((!(opcode & ISCSI_OP_TEXT)) ||
 		    (!(opcode & ISCSI_OP_LOGOUT)))) {
-			target_err("Received illegal iSCSI Opcode: 0x%02x"
-				   " while in Discovery Session, rejecting.\n",
+			target_err("Received illegal iSCSI Opcode: 0x%02x while in Discovery Session, rejecting.\n",
 				   opcode);
 			iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
 					  buffer);
@@ -4292,9 +4180,7 @@ int iscsit_close_connection(
 	int conn_logout = (conn->conn_state == TARG_CONN_STATE_IN_LOGOUT);
 	struct iscsit_session	*sess = conn->sess;
 
-	target_debug("Closing iSCSI connection CID %hu on SID:"
-		     " %u\n",
-		     conn->cid, sess->sid);
+	target_debug("Closing iSCSI connection CID %hu on SID: %u\n", conn->cid, sess->sid);
 	/*
 	 * Always up conn_logout_comp for the traditional TCP and HW_OFFLOAD
 	 * case just in case the RX Thread in iscsi_target_rx_opcode() is
@@ -4439,8 +4325,7 @@ int iscsit_close_connection(
 
 	spin_lock_bh(&sess->conn_lock);
 	atomic_dec(&sess->nconn);
-	target_debug("Decremented iSCSI connection count to %d from node:"
-		     " %s\n",
+	target_debug("Decremented iSCSI connection count to %d from node: %s\n",
 		     atomic_read(&sess->nconn), sess->sess_ops->InitiatorName);
 	/*
 	 * Make sure that if one connection fails in an non ERL=2 iSCSI
@@ -4534,8 +4419,7 @@ int iscsit_close_session(struct iscsit_session *sess, bool can_sleep)
 	struct se_portal_group *se_tpg = &tpg->tpg_se_tpg;
 
 	if (atomic_read(&sess->nconn)) {
-		target_err("%d connection(s) still exist for iSCSI session"
-			   " to %s\n",
+		target_err("%d connection(s) still exist for iSCSI session to %s\n",
 			   atomic_read(&sess->nconn), sess->sess_ops->InitiatorName);
 		BUG();
 	}
@@ -4582,8 +4466,7 @@ int iscsit_close_session(struct iscsit_session *sess, bool can_sleep)
 	if (tpg->tpg_tiqn)
 		tpg->tpg_tiqn->tiqn_nsessions--;
 
-	target_debug("Decremented number of active iSCSI Sessions on"
-		     " iSCSI TPG: %hu to %u\n",
+	target_debug("Decremented number of active iSCSI Sessions on iSCSI TPG: %hu to %u\n",
 		     tpg->tpgt, tpg->nsessions);
 
 	ida_free(&sess_ida, sess->session_index);
@@ -4845,9 +4728,8 @@ int iscsit_release_sessions_for_tpg(struct iscsi_portal_group *tpg, int force)
 		session_count++;
 	}
 
-	target_debug("Released %d iSCSI Session(s) from Target Portal"
-		     " Group: %hu\n",
-		     session_count, tpg->tpgt);
+	target_debug("Released %d iSCSI Session(s) from Target Portal Group: %hu\n", session_count,
+		     tpg->tpgt);
 	return 0;
 }
 
diff --git a/drivers/target/iscsi/iscsi_target_auth.c b/drivers/target/iscsi/iscsi_target_auth.c
index 694b2ec612cd..8308a1947605 100644
--- a/drivers/target/iscsi/iscsi_target_auth.c
+++ b/drivers/target/iscsi/iscsi_target_auth.c
@@ -146,8 +146,7 @@ static struct iscsi_chap *chap_server_open(
 
 	if (!(auth->naf_flags & NAF_USERID_SET) ||
 	    !(auth->naf_flags & NAF_PASSWORD_SET)) {
-		target_err("CHAP user or password not set for"
-			   " Initiator ACL\n");
+		target_err("CHAP user or password not set for Initiator ACL\n");
 		return NULL;
 	}
 
@@ -401,8 +400,7 @@ static int chap_server_compute_hash(
 		target_debug("[server] %s Digests do not match!\n\n", chap->digest_name);
 		goto out;
 	} else
-		target_debug("[server] %s Digests match, CHAP connection"
-			     " successful.\n\n",
+		target_debug("[server] %s Digests match, CHAP connection successful.\n\n",
 			     chap->digest_name);
 	/*
 	 * One way authentication has succeeded, return now if mutual
@@ -501,8 +499,7 @@ static int chap_server_compute_hash(
 	if (initiatorchg_len == chap->challenge_len &&
 				!memcmp(initiatorchg_binhex, chap->challenge,
 				initiatorchg_len)) {
-		target_err("initiator CHAP_C matches target CHAP_C, failing"
-			   " login attempt\n");
+		target_err("initiator CHAP_C matches target CHAP_C, failing login attempt\n");
 		goto out;
 	}
 	/*
@@ -525,8 +522,7 @@ static int chap_server_compute_hash(
 	ret = crypto_shash_update(desc, auth->password_mutual,
 				  strlen(auth->password_mutual));
 	if (ret < 0) {
-		target_err("crypto_shash_update() failed for"
-			   " password_mutual\n");
+		target_err("crypto_shash_update() failed for password_mutual\n");
 		goto out;
 	}
 	/*
diff --git a/drivers/target/iscsi/iscsi_target_configfs.c b/drivers/target/iscsi/iscsi_target_configfs.c
index 8f2578bf8621..bf820981b0da 100644
--- a/drivers/target/iscsi/iscsi_target_configfs.c
+++ b/drivers/target/iscsi/iscsi_target_configfs.c
@@ -72,8 +72,7 @@ static ssize_t lio_target_np_driver_store(struct config_item *item,
 	}
 	np = tpg_np->tpg_np;
 	if (!np) {
-		target_err("Unable to locate struct iscsi_np from"
-			   " struct iscsi_tpg_np\n");
+		target_err("Unable to locate struct iscsi_np from struct iscsi_tpg_np\n");
 		return -EINVAL;
 	}
 
@@ -173,8 +172,7 @@ static struct se_tpg_np *lio_target_call_addnptotpg(
 	if (str) {
 		str2 = strstr(str, "]");
 		if (!str2) {
-			target_err("Unable to locate trailing \"]\""
-				   " in IPv6 iSCSI network portal address\n");
+			target_err("Unable to locate trailing \"]\" in IPv6 iSCSI network portal address\n");
 			return ERR_PTR(-EINVAL);
 		}
 
@@ -184,8 +182,7 @@ static struct se_tpg_np *lio_target_call_addnptotpg(
 
 		port_str = strstr(str2, ":");
 		if (!port_str) {
-			target_err("Unable to locate \":port\""
-				   " in IPv6 iSCSI network portal address\n");
+			target_err("Unable to locate \":port\" in IPv6 iSCSI network portal address\n");
 			return ERR_PTR(-EINVAL);
 		}
 		*port_str = '\0'; /* Terminate string for IP */
@@ -194,8 +191,7 @@ static struct se_tpg_np *lio_target_call_addnptotpg(
 		ip_str = &buf[0];
 		port_str = strstr(ip_str, ":");
 		if (!port_str) {
-			target_err("Unable to locate \":port\""
-				   " in IPv4 iSCSI network portal address\n");
+			target_err("Unable to locate \":port\" in IPv4 iSCSI network portal address\n");
 			return ERR_PTR(-EINVAL);
 		}
 		*port_str = '\0'; /* Terminate string for IP */
@@ -214,8 +210,7 @@ static struct se_tpg_np *lio_target_call_addnptotpg(
 	if (ret < 0)
 		return ERR_PTR(-EINVAL);
 
-	target_debug("LIO_Target_ConfigFS: REGISTER -> %s TPGT: %hu"
-		     " PORTAL: %s\n",
+	target_debug("LIO_Target_ConfigFS: REGISTER -> %s TPGT: %hu PORTAL: %s\n",
 		     config_item_name(&se_tpg->se_tpg_wwn->wwn_group.cg_item), tpg->tpgt, name);
 	/*
 	 * Assume ISCSI_TCP by default.  Other network portals for other
@@ -257,8 +252,7 @@ static void lio_target_call_delnpfromtpg(
 		return;
 
 	se_tpg = &tpg->tpg_se_tpg;
-	target_debug("LIO_Target_ConfigFS: DEREGISTER -> %s TPGT: %hu"
-		     " PORTAL: %pISpc\n",
+	target_debug("LIO_Target_ConfigFS: DEREGISTER -> %s TPGT: %hu PORTAL: %pISpc\n",
 		     config_item_name(&se_tpg->se_tpg_wwn->wwn_group.cg_item), tpg->tpgt,
 		     &tpg_np->tpg_np->np_sockaddr);
 
@@ -657,8 +651,7 @@ static ssize_t lio_target_nacl_cmdsn_depth_store(struct config_item *item,
 	if (ret)
 		return ret;
 	if (cmdsn_depth > TA_DEFAULT_CMDSN_DEPTH_MAX) {
-		target_err("Passed cmdsn_depth: %u exceeds"
-			   " TA_DEFAULT_CMDSN_DEPTH_MAX: %u\n",
+		target_err("Passed cmdsn_depth: %u exceeds TA_DEFAULT_CMDSN_DEPTH_MAX: %u\n",
 			   cmdsn_depth, TA_DEFAULT_CMDSN_DEPTH_MAX);
 		return -EINVAL;
 	}
@@ -683,8 +676,7 @@ static ssize_t lio_target_nacl_cmdsn_depth_store(struct config_item *item,
 
 	ret = core_tpg_set_initiator_node_queue_depth(se_nacl, cmdsn_depth);
 
-	target_debug("LIO_Target_ConfigFS: %s/%s Set CmdSN Window: %u for"
-		     "InitiatorName: %s\n",
+	target_debug("LIO_Target_ConfigFS: %s/%s Set CmdSN Window: %u for InitiatorName: %s\n",
 		     config_item_name(wwn_ci), config_item_name(tpg_ci), cmdsn_depth,
 		     config_item_name(acl_ci));
 
@@ -1052,8 +1044,7 @@ static struct se_portal_group *lio_target_tiqn_addtpg(struct se_wwn *wwn,
 	 */
 	tpgt_str = strstr(name, "tpgt_");
 	if (!tpgt_str) {
-		target_err("Unable to locate \"tpgt_#\" directory"
-			   " group\n");
+		target_err("Unable to locate \"tpgt_#\" directory group\n");
 		return NULL;
 	}
 	tpgt_str += 5; /* Skip ahead of "tpgt_" */
@@ -1192,9 +1183,7 @@ static struct se_wwn *lio_target_call_coreaddtiqn(
 		return ERR_CAST(tiqn);
 
 	target_debug("LIO_Target_ConfigFS: REGISTER -> %s\n", tiqn->tiqn);
-	target_debug("LIO_Target_ConfigFS: REGISTER -> Allocated Node:"
-		     " %s\n",
-		     name);
+	target_debug("LIO_Target_ConfigFS: REGISTER -> Allocated Node: %s\n", name);
 	return &tiqn->tiqn_wwn;
 }
 
@@ -1294,9 +1283,7 @@ static ssize_t iscsi_disc_enforce_discovery_auth_store(struct config_item *item,
 	if (err)
 		return -EINVAL;
 	if ((op != 1) && (op != 0)) {
-		target_err("Illegal value for enforce_discovery_auth:"
-			   " %u\n",
-			   op);
+		target_err("Illegal value for enforce_discovery_auth: %u\n", op);
 		return -EINVAL;
 	}
 
@@ -1319,9 +1306,7 @@ static ssize_t iscsi_disc_enforce_discovery_auth_store(struct config_item *item,
 
 		discovery_tpg->tpg_attrib.authentication = 1;
 		iscsit_global->discovery_acl.node_auth.enforce_discovery_auth = 1;
-		target_debug("LIO-CORE[0] Successfully enabled"
-			     " authentication enforcement for iSCSI"
-			     " Discovery TPG\n");
+		target_debug("LIO-CORE[0] Successfully enabled authentication enforcement for iSCSI Discovery TPG\n");
 	} else {
 		/*
 		 * Reset the AuthMethod key to CHAP,None
@@ -1331,9 +1316,7 @@ static ssize_t iscsi_disc_enforce_discovery_auth_store(struct config_item *item,
 
 		discovery_tpg->tpg_attrib.authentication = 0;
 		iscsit_global->discovery_acl.node_auth.enforce_discovery_auth = 0;
-		target_debug("LIO-CORE[0] Successfully disabled"
-			     " authentication enforcement for iSCSI"
-			     " Discovery TPG\n");
+		target_debug("LIO-CORE[0] Successfully disabled authentication enforcement for iSCSI Discovery TPG\n");
 	}
 
 	return count;
diff --git a/drivers/target/iscsi/iscsi_target_datain_values.c b/drivers/target/iscsi/iscsi_target_datain_values.c
index 84ba97e935e1..57e887945de4 100644
--- a/drivers/target/iscsi/iscsi_target_datain_values.c
+++ b/drivers/target/iscsi/iscsi_target_datain_values.c
@@ -23,8 +23,7 @@ struct iscsi_datain_req *iscsit_allocate_datain_req(void)
 
 	dr = kmem_cache_zalloc(lio_dr_cache, GFP_ATOMIC);
 	if (!dr) {
-		target_err("Unable to allocate memory for"
-			   " struct iscsi_datain_req\n");
+		target_err("Unable to allocate memory for struct iscsi_datain_req\n");
 		return NULL;
 	}
 	INIT_LIST_HEAD(&dr->cmd_datain_node);
@@ -63,9 +62,7 @@ void iscsit_free_all_datain_reqs(struct iscsit_cmd *cmd)
 struct iscsi_datain_req *iscsit_get_datain_req(struct iscsit_cmd *cmd)
 {
 	if (list_empty(&cmd->datain_list)) {
-		target_err("cmd->datain_list is empty for ITT:"
-			   " 0x%08x\n",
-			   cmd->init_task_tag);
+		target_err("cmd->datain_list is empty for ITT: 0x%08x\n", cmd->init_task_tag);
 		return NULL;
 	}
 
diff --git a/drivers/target/iscsi/iscsi_target_erl0.c b/drivers/target/iscsi/iscsi_target_erl0.c
index 800fe7b6322d..0607cc3b6f07 100644
--- a/drivers/target/iscsi/iscsi_target_erl0.c
+++ b/drivers/target/iscsi/iscsi_target_erl0.c
@@ -123,9 +123,8 @@ static int iscsit_dataout_within_command_recovery_check(
 	return DATAOUT_NORMAL;
 
 dump:
-	target_err("Dumping DataOUT PDU Offset: %u Length: %d DataSN:"
-		   " 0x%08x\n",
-		   hdr->offset, payload_length, hdr->datasn);
+	target_err("Dumping DataOUT PDU Offset: %u Length: %d DataSN: 0x%08x\n", hdr->offset,
+		   payload_length, hdr->datasn);
 	return iscsit_dump_data_payload(conn, payload_length, 1);
 }
 
@@ -141,9 +140,7 @@ static int iscsit_dataout_check_unsolicited_sequence(
 
 	if ((be32_to_cpu(hdr->offset) < cmd->seq_start_offset) ||
 	   ((be32_to_cpu(hdr->offset) + payload_length) > cmd->seq_end_offset)) {
-		target_err("Command ITT: 0x%08x with Offset: %u,"
-			   " Length: %u outside of Unsolicited Sequence %u:%u while"
-			   " DataSequenceInOrder=Yes.\n",
+		target_err("Command ITT: 0x%08x with Offset: %u, Length: %u outside of Unsolicited Sequence %u:%u while DataSequenceInOrder=Yes.\n",
 			   cmd->init_task_tag, be32_to_cpu(hdr->offset), payload_length,
 			   cmd->seq_start_offset, cmd->seq_end_offset);
 		return DATAOUT_CANNOT_RECOVER;
@@ -152,8 +149,7 @@ static int iscsit_dataout_check_unsolicited_sequence(
 	first_burst_len = (cmd->first_burst_len + payload_length);
 
 	if (first_burst_len > conn->sess->sess_ops->FirstBurstLength) {
-		target_err("Total %u bytes exceeds FirstBurstLength: %u"
-			   " for this Unsolicited DataOut Burst.\n",
+		target_err("Total %u bytes exceeds FirstBurstLength: %u for this Unsolicited DataOut Burst.\n",
 			   first_burst_len, conn->sess->sess_ops->FirstBurstLength);
 		transport_send_check_condition_and_sense(&cmd->se_cmd,
 				TCM_INCORRECT_AMOUNT_OF_DATA, 0);
@@ -175,9 +171,7 @@ static int iscsit_dataout_check_unsolicited_sequence(
 
 		if ((first_burst_len != cmd->se_cmd.data_length) &&
 		    (first_burst_len != conn->sess->sess_ops->FirstBurstLength)) {
-			target_err("Unsolicited non-immediate data"
-				   " received %u does not equal FirstBurstLength: %u, and"
-				   " does not equal ExpXferLen %u.\n",
+			target_err("Unsolicited non-immediate data received %u does not equal FirstBurstLength: %u, and does not equal ExpXferLen %u.\n",
 				   first_burst_len, conn->sess->sess_ops->FirstBurstLength,
 				   cmd->se_cmd.data_length);
 			transport_send_check_condition_and_sense(&cmd->se_cmd,
@@ -186,16 +180,12 @@ static int iscsit_dataout_check_unsolicited_sequence(
 		}
 	} else {
 		if (first_burst_len == conn->sess->sess_ops->FirstBurstLength) {
-			target_err("Command ITT: 0x%08x reached"
-				   " FirstBurstLength: %u, but ISCSI_FLAG_CMD_FINAL is not set. protocol"
-				   " error.\n",
+			target_err("Command ITT: 0x%08x reached FirstBurstLength: %u, but ISCSI_FLAG_CMD_FINAL is not set. protocol error.\n",
 				   cmd->init_task_tag, conn->sess->sess_ops->FirstBurstLength);
 			return DATAOUT_CANNOT_RECOVER;
 		}
 		if (first_burst_len == cmd->se_cmd.data_length) {
-			target_err("Command ITT: 0x%08x reached"
-				   " ExpXferLen: %u, but ISCSI_FLAG_CMD_FINAL is not set. protocol"
-				   " error.\n",
+			target_err("Command ITT: 0x%08x reached ExpXferLen: %u, but ISCSI_FLAG_CMD_FINAL is not set. protocol error.\n",
 				   cmd->init_task_tag, cmd->se_cmd.data_length);
 			return DATAOUT_CANNOT_RECOVER;
 		}
@@ -230,9 +220,7 @@ static int iscsit_dataout_check_sequence(
 		 */
 		if ((be32_to_cpu(hdr->offset) < cmd->seq_start_offset) ||
 		   ((be32_to_cpu(hdr->offset) + payload_length) > cmd->seq_end_offset)) {
-			target_err("Command ITT: 0x%08x with Offset: %u,"
-				   " Length: %u outside of Sequence %u:%u while"
-				   " DataSequenceInOrder=Yes.\n",
+			target_err("Command ITT: 0x%08x with Offset: %u, Length: %u outside of Sequence %u:%u while DataSequenceInOrder=Yes.\n",
 				   cmd->init_task_tag, be32_to_cpu(hdr->offset), payload_length,
 				   cmd->seq_start_offset, cmd->seq_end_offset);
 
@@ -262,9 +250,7 @@ static int iscsit_dataout_check_sequence(
 	}
 
 	if (next_burst_len > conn->sess->sess_ops->MaxBurstLength) {
-		target_err("Command ITT: 0x%08x, NextBurstLength: %u and"
-			   " Length: %u exceeds MaxBurstLength: %u. protocol"
-			   " error.\n",
+		target_err("Command ITT: 0x%08x, NextBurstLength: %u and Length: %u exceeds MaxBurstLength: %u. protocol error.\n",
 			   cmd->init_task_tag, (next_burst_len - payload_length), payload_length,
 			   conn->sess->sess_ops->MaxBurstLength);
 		return DATAOUT_CANNOT_RECOVER;
@@ -288,17 +274,13 @@ static int iscsit_dataout_check_sequence(
 			     conn->sess->sess_ops->MaxBurstLength) &&
 			   ((cmd->write_data_done + payload_length) <
 			     cmd->se_cmd.data_length)) {
-				target_err("Command ITT: 0x%08x set ISCSI_FLAG_CMD_FINAL"
-					   " before end of DataOUT sequence, protocol"
-					   " error.\n",
+				target_err("Command ITT: 0x%08x set ISCSI_FLAG_CMD_FINAL before end of DataOUT sequence, protocol error.\n",
 					   cmd->init_task_tag);
 				return DATAOUT_CANNOT_RECOVER;
 			}
 		} else {
 			if (next_burst_len < seq->xfer_len) {
-				target_err("Command ITT: 0x%08x set ISCSI_FLAG_CMD_FINAL"
-					   " before end of DataOUT sequence, protocol"
-					   " error.\n",
+				target_err("Command ITT: 0x%08x set ISCSI_FLAG_CMD_FINAL before end of DataOUT sequence, protocol error.\n",
 					   cmd->init_task_tag);
 				return DATAOUT_CANNOT_RECOVER;
 			}
@@ -307,26 +289,20 @@ static int iscsit_dataout_check_sequence(
 		if (conn->sess->sess_ops->DataSequenceInOrder) {
 			if (next_burst_len ==
 					conn->sess->sess_ops->MaxBurstLength) {
-				target_err("Command ITT: 0x%08x reached"
-					   " MaxBurstLength: %u, but ISCSI_FLAG_CMD_FINAL is"
-					   " not set, protocol error.",
+				target_err("Command ITT: 0x%08x reached MaxBurstLength: %u, but ISCSI_FLAG_CMD_FINAL is not set, protocol error.",
 					   cmd->init_task_tag,
 					   conn->sess->sess_ops->MaxBurstLength);
 				return DATAOUT_CANNOT_RECOVER;
 			}
 			if ((cmd->write_data_done + payload_length) ==
 					cmd->se_cmd.data_length) {
-				target_err("Command ITT: 0x%08x reached"
-					   " last DataOUT PDU in sequence but ISCSI_FLAG_"
-					   "CMD_FINAL is not set, protocol error.\n",
+				target_err("Command ITT: 0x%08x reached last DataOUT PDU in sequence but ISCSI_FLAG_CMD_FINAL is not set, protocol error.\n",
 					   cmd->init_task_tag);
 				return DATAOUT_CANNOT_RECOVER;
 			}
 		} else {
 			if (next_burst_len == seq->xfer_len) {
-				target_err("Command ITT: 0x%08x reached"
-					   " last DataOUT PDU in sequence but ISCSI_FLAG_"
-					   "CMD_FINAL is not set, protocol error.\n",
+				target_err("Command ITT: 0x%08x reached last DataOUT PDU in sequence but ISCSI_FLAG_CMD_FINAL is not set, protocol error.\n",
 					   cmd->init_task_tag);
 				return DATAOUT_CANNOT_RECOVER;
 			}
@@ -362,13 +338,11 @@ static int iscsit_dataout_check_datasn(
 	}
 
 	if (be32_to_cpu(hdr->datasn) > data_sn) {
-		target_err("Command ITT: 0x%08x, received DataSN: 0x%08x"
-			   " higher than expected 0x%08x.\n",
+		target_err("Command ITT: 0x%08x, received DataSN: 0x%08x higher than expected 0x%08x.\n",
 			   cmd->init_task_tag, be32_to_cpu(hdr->datasn), data_sn);
 		goto recover;
 	} else if (be32_to_cpu(hdr->datasn) < data_sn) {
-		target_err("Command ITT: 0x%08x, received DataSN: 0x%08x"
-			   " lower than expected 0x%08x, discarding payload.\n",
+		target_err("Command ITT: 0x%08x, received DataSN: 0x%08x lower than expected 0x%08x, discarding payload.\n",
 			   cmd->init_task_tag, be32_to_cpu(hdr->datasn), data_sn);
 		goto dump;
 	}
@@ -377,8 +351,7 @@ static int iscsit_dataout_check_datasn(
 
 recover:
 	if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
-		target_err("Unable to perform within-command recovery"
-			   " while ERL=0.\n");
+		target_err("Unable to perform within-command recovery while ERL=0.\n");
 		return DATAOUT_CANNOT_RECOVER;
 	}
 dump:
@@ -408,8 +381,7 @@ static int iscsit_dataout_pre_datapduinorder_yes(
 	 */
 	if (conn->sess->sess_ops->DataSequenceInOrder) {
 		if (be32_to_cpu(hdr->offset) != cmd->write_data_done) {
-			target_err("Command ITT: 0x%08x, received offset"
-				   " %u different than expected %u.\n",
+			target_err("Command ITT: 0x%08x, received offset %u different than expected %u.\n",
 				   cmd->init_task_tag, be32_to_cpu(hdr->offset),
 				   cmd->write_data_done);
 			recovery = 1;
@@ -419,14 +391,12 @@ static int iscsit_dataout_pre_datapduinorder_yes(
 		struct iscsi_seq *seq = cmd->seq_ptr;
 
 		if (be32_to_cpu(hdr->offset) > seq->offset) {
-			target_err("Command ITT: 0x%08x, received offset"
-				   " %u greater than expected %u.\n",
+			target_err("Command ITT: 0x%08x, received offset %u greater than expected %u.\n",
 				   cmd->init_task_tag, be32_to_cpu(hdr->offset), seq->offset);
 			recovery = 1;
 			goto recover;
 		} else if (be32_to_cpu(hdr->offset) < seq->offset) {
-			target_err("Command ITT: 0x%08x, received offset"
-				   " %u less than expected %u, discarding payload.\n",
+			target_err("Command ITT: 0x%08x, received offset %u less than expected %u, discarding payload.\n",
 				   cmd->init_task_tag, be32_to_cpu(hdr->offset), seq->offset);
 			dump = 1;
 			goto dump;
@@ -437,8 +407,7 @@ static int iscsit_dataout_pre_datapduinorder_yes(
 
 recover:
 	if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
-		target_err("Unable to perform within-command recovery"
-			   " while ERL=0.\n");
+		target_err("Unable to perform within-command recovery while ERL=0.\n");
 		return DATAOUT_CANNOT_RECOVER;
 	}
 dump:
@@ -471,8 +440,7 @@ static int iscsit_dataout_pre_datapduinorder_no(
 	case ISCSI_PDU_TIMED_OUT:
 		break;
 	case ISCSI_PDU_RECEIVED_OK:
-		target_err("Command ITT: 0x%08x received already gotten"
-			   " Offset: %u, Length: %u\n",
+		target_err("Command ITT: 0x%08x received already gotten Offset: %u, Length: %u\n",
 			   cmd->init_task_tag, be32_to_cpu(hdr->offset), payload_length);
 		return iscsit_dump_data_payload(cmd->conn, payload_length, 1);
 	default:
@@ -734,8 +702,7 @@ int iscsit_check_post_dataout(
 		return iscsit_dataout_post_crc_passed(cmd, buf);
 	else {
 		if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
-			target_err("Unable to recover from DataOUT CRC"
-				   " failure while ERL=0, closing session.\n");
+			target_err("Unable to recover from DataOUT CRC failure while ERL=0, closing session.\n");
 			iscsit_reject_cmd(cmd, ISCSI_REASON_DATA_DIGEST_ERROR,
 					  buf);
 			return DATAOUT_CANNOT_RECOVER;
@@ -758,15 +725,13 @@ void iscsit_handle_time2retain_timeout(struct timer_list *t)
 		return;
 	}
 	if (atomic_read(&sess->session_reinstatement)) {
-		target_err("Exiting Time2Retain handler because"
-			   " session_reinstatement=1\n");
+		target_err("Exiting Time2Retain handler because session_reinstatement=1\n");
 		spin_unlock_bh(&se_tpg->session_lock);
 		return;
 	}
 	sess->time2retain_timer_flags |= ISCSI_TF_EXPIRED;
 
-	target_err("Time2Retain timer expired for SID: %u, cleaning up"
-		   " iSCSI session.\n",
+	target_err("Time2Retain timer expired for SID: %u, cleaning up iSCSI session.\n",
 		   sess->sid);
 
 	iscsit_fill_cxn_timeout_err_stats(sess);
@@ -791,8 +756,7 @@ void iscsit_start_time2retain_handler(struct iscsit_session *sess)
 	if (sess->time2retain_timer_flags & ISCSI_TF_RUNNING)
 		return;
 
-	target_debug("Starting Time2Retain timer for %u seconds on"
-		     " SID: %u\n",
+	target_debug("Starting Time2Retain timer for %u seconds on SID: %u\n",
 		     sess->sess_ops->DefaultTime2Retain, sess->sid);
 
 	sess->time2retain_timer_flags &= ~ISCSI_TF_STOP;
@@ -888,9 +852,7 @@ EXPORT_SYMBOL(iscsit_cause_connection_reinstatement);
 
 void iscsit_fall_back_to_erl0(struct iscsit_session *sess)
 {
-	target_debug("Falling back to ErrorRecoveryLevel=0 for SID:"
-		     " %u\n",
-		     sess->sid);
+	target_debug("Falling back to ErrorRecoveryLevel=0 for SID: %u\n", sess->sid);
 
 	atomic_set(&sess->session_fall_back_to_erl0, 1);
 }
@@ -904,8 +866,7 @@ static void iscsit_handle_connection_cleanup(struct iscsit_conn *conn)
 	    !atomic_read(&sess->session_fall_back_to_erl0))
 		iscsit_connection_recovery_transport_reset(conn);
 	else {
-		target_debug("Performing cleanup for failed iSCSI"
-			     " Connection ID: %hu from %s\n",
+		target_debug("Performing cleanup for failed iSCSI Connection ID: %hu from %s\n",
 			     conn->cid, sess->sess_ops->InitiatorName);
 		iscsit_close_connection(conn);
 	}
diff --git a/drivers/target/iscsi/iscsi_target_erl1.c b/drivers/target/iscsi/iscsi_target_erl1.c
index 210530b586ef..54dc01d289cf 100644
--- a/drivers/target/iscsi/iscsi_target_erl1.c
+++ b/drivers/target/iscsi/iscsi_target_erl1.c
@@ -58,9 +58,7 @@ int iscsit_dump_data_payload(
 
 	buf = kzalloc(length, GFP_ATOMIC);
 	if (!buf) {
-		target_err("Unable to allocate %u bytes for offload"
-			   " buffer.\n",
-			   length);
+		target_err("Unable to allocate %u bytes for offload buffer.\n", length);
 		return -1;
 	}
 	memset(&iov, 0, sizeof(struct kvec));
@@ -124,10 +122,7 @@ static int iscsit_handle_r2t_snack(
 	 */
 	if ((cmd->cmd_flags & ICF_GOT_DATACK_SNACK) &&
 	    (begrun <= cmd->acked_data_sn)) {
-		target_err("ITT: 0x%08x, R2T SNACK requesting"
-			   " retransmission of R2TSN: 0x%08x to 0x%08x but already"
-			   " acked to  R2TSN: 0x%08x by TMR TASK_REASSIGN,"
-			   " protocol error.\n",
+		target_err("ITT: 0x%08x, R2T SNACK requesting retransmission of R2TSN: 0x%08x to 0x%08x but already acked to  R2TSN: 0x%08x by TMR TASK_REASSIGN, protocol error.\n",
 			   cmd->init_task_tag, begrun, (begrun + runlength), cmd->acked_data_sn);
 
 		return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR, buf);
@@ -135,9 +130,7 @@ static int iscsit_handle_r2t_snack(
 
 	if (runlength) {
 		if ((begrun + runlength) > cmd->r2t_sn) {
-			target_err("Command ITT: 0x%08x received R2T SNACK"
-				   " with BegRun: 0x%08x, RunLength: 0x%08x, exceeds"
-				   " current R2TSN: 0x%08x, protocol error.\n",
+			target_err("Command ITT: 0x%08x received R2T SNACK with BegRun: 0x%08x, RunLength: 0x%08x, exceeds current R2TSN: 0x%08x, protocol error.\n",
 				   cmd->init_task_tag, begrun, runlength, cmd->r2t_sn);
 			return iscsit_reject_cmd(cmd,
 					ISCSI_REASON_BOOKMARK_INVALID, buf);
@@ -249,8 +242,7 @@ int iscsit_create_recovery_datain_values_datasequenceinorder_no(
 		 * seq->first_datasn and seq->last_datasn have not been set.
 		 */
 		if (!seq->sent) {
-			target_err("Ignoring non-sent sequence 0x%08x ->"
-				   " 0x%08x\n\n",
+			target_err("Ignoring non-sent sequence 0x%08x -> 0x%08x\n\n",
 				   seq->first_datasn, seq->last_datasn);
 			continue;
 		}
@@ -262,9 +254,8 @@ int iscsit_create_recovery_datain_values_datasequenceinorder_no(
 		 */
 		if ((seq->first_datasn < begrun) &&
 				(seq->last_datasn < begrun)) {
-			target_err("Pre BegRun sequence 0x%08x ->"
-				   " 0x%08x\n",
-				   seq->first_datasn, seq->last_datasn);
+			target_err("Pre BegRun sequence 0x%08x -> 0x%08x\n", seq->first_datasn,
+				   seq->last_datasn);
 
 			read_data_done += cmd->seq_list[i].xfer_len;
 			seq->next_burst_len = seq->pdu_send_order = 0;
@@ -276,9 +267,8 @@ int iscsit_create_recovery_datain_values_datasequenceinorder_no(
 		 */
 		if ((seq->first_datasn <= begrun) &&
 				(seq->last_datasn >= begrun)) {
-			target_err("Found sequence begrun: 0x%08x in"
-				   " 0x%08x -> 0x%08x\n",
-				   begrun, seq->first_datasn, seq->last_datasn);
+			target_err("Found sequence begrun: 0x%08x in 0x%08x -> 0x%08x\n", begrun,
+				   seq->first_datasn, seq->last_datasn);
 
 			seq_send_order = seq->seq_send_order;
 			data_sn = seq->first_datasn;
@@ -346,8 +336,7 @@ int iscsit_create_recovery_datain_values_datasequenceinorder_no(
 	if (!found_seq) {
 		if (!begrun) {
 			if (!first_seq) {
-				target_err("ITT: 0x%08x, Begrun: 0x%08x"
-					   " but first_seq is NULL\n",
+				target_err("ITT: 0x%08x, Begrun: 0x%08x but first_seq is NULL\n",
 					   cmd->init_task_tag, begrun);
 				return -1;
 			}
@@ -356,9 +345,7 @@ int iscsit_create_recovery_datain_values_datasequenceinorder_no(
 			goto done;
 		}
 
-		target_err("Unable to locate struct iscsi_seq for ITT: 0x%08x,"
-			   " BegRun: 0x%08x, RunLength: 0x%08x while"
-			   " DataSequenceInOrder=No and DataPDUInOrder=%s.\n",
+		target_err("Unable to locate struct iscsi_seq for ITT: 0x%08x, BegRun: 0x%08x, RunLength: 0x%08x while DataSequenceInOrder=No and DataPDUInOrder=%s.\n",
 			   cmd->init_task_tag, begrun, runlength,
 			   (conn->sess->sess_ops->DataPDUInOrder) ? "Yes" : "No");
 		return -1;
@@ -392,10 +379,7 @@ static int iscsit_handle_recovery_datain(
 	 */
 	if ((cmd->cmd_flags & ICF_GOT_DATACK_SNACK) &&
 	    (begrun <= cmd->acked_data_sn)) {
-		target_err("ITT: 0x%08x, Data SNACK requesting"
-			   " retransmission of DataSN: 0x%08x to 0x%08x but"
-			   " already acked to DataSN: 0x%08x by Data ACK SNACK,"
-			   " protocol error.\n",
+		target_err("ITT: 0x%08x, Data SNACK requesting retransmission of DataSN: 0x%08x to 0x%08x but already acked to DataSN: 0x%08x by Data ACK SNACK, protocol error.\n",
 			   cmd->init_task_tag, begrun, (begrun + runlength), cmd->acked_data_sn);
 
 		return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR, buf);
@@ -406,8 +390,7 @@ static int iscsit_handle_recovery_datain(
 	 * Note: (cmd->data_sn - 1) will carry the maximum DataSN sent.
 	 */
 	if ((begrun + runlength) > (cmd->data_sn - 1)) {
-		target_err("Initiator requesting BegRun: 0x%08x, RunLength"
-			   ": 0x%08x greater than maximum DataSN: 0x%08x.\n",
+		target_err("Initiator requesting BegRun: 0x%08x, RunLength: 0x%08x greater than maximum DataSN: 0x%08x.\n",
 			   begrun, runlength, (cmd->data_sn - 1));
 		return iscsit_reject_cmd(cmd, ISCSI_REASON_BOOKMARK_INVALID,
 					 buf);
@@ -477,9 +460,7 @@ int iscsit_handle_status_snack(
 	if (!begrun) {
 		begrun = conn->exp_statsn;
 	} else if (conn->exp_statsn > begrun) {
-		target_err("Got Status SNACK Begrun: 0x%08x, RunLength:"
-			   " 0x%08x but already got ExpStatSN: 0x%08x on CID:"
-			   " %hu.\n",
+		target_err("Got Status SNACK Begrun: 0x%08x, RunLength: 0x%08x but already got ExpStatSN: 0x%08x on CID: %hu.\n",
 			   begrun, runlength, conn->exp_statsn, conn->cid);
 		return 0;
 	}
@@ -499,10 +480,7 @@ int iscsit_handle_status_snack(
 		spin_unlock_bh(&conn->cmd_lock);
 
 		if (!found_cmd) {
-			target_err("Unable to find StatSN: 0x%08x for"
-				   " a Status SNACK, assuming this was a"
-				   " protactic SNACK for an untransmitted"
-				   " StatSN, ignoring.\n",
+			target_err("Unable to find StatSN: 0x%08x for a Status SNACK, assuming this was a protactic SNACK for an untransmitted StatSN, ignoring.\n",
 				   begrun);
 			begrun++;
 			continue;
@@ -511,10 +489,7 @@ int iscsit_handle_status_snack(
 		spin_lock_bh(&cmd->istate_lock);
 		if (cmd->i_state == ISTATE_SEND_DATAIN) {
 			spin_unlock_bh(&cmd->istate_lock);
-			target_err("Ignoring Status SNACK for BegRun:"
-				   " 0x%08x, RunLength: 0x%08x, assuming this was"
-				   " a protactic SNACK for an untransmitted"
-				   " StatSN\n",
+			target_err("Ignoring Status SNACK for BegRun: 0x%08x, RunLength: 0x%08x, assuming this was a protactic SNACK for an untransmitted StatSN\n",
 				   begrun, runlength);
 			begrun++;
 			continue;
@@ -539,15 +514,12 @@ int iscsit_handle_data_ack(
 
 	cmd = iscsit_find_cmd_from_ttt(conn, targ_xfer_tag);
 	if (!cmd) {
-		target_err("Data ACK SNACK for TTT: 0x%08x is"
-			   " invalid.\n",
-			   targ_xfer_tag);
+		target_err("Data ACK SNACK for TTT: 0x%08x is invalid.\n", targ_xfer_tag);
 		return -1;
 	}
 
 	if (begrun <= cmd->acked_data_sn) {
-		target_err("ITT: 0x%08x Data ACK SNACK BegRUN: 0x%08x is"
-			   " less than the already acked DataSN: 0x%08x.\n",
+		target_err("ITT: 0x%08x Data ACK SNACK BegRUN: 0x%08x is less than the already acked DataSN: 0x%08x.\n",
 			   cmd->init_task_tag, begrun, cmd->acked_data_sn);
 		return -1;
 	}
@@ -559,8 +531,7 @@ int iscsit_handle_data_ack(
 	cmd->cmd_flags |= ICF_GOT_DATACK_SNACK;
 	cmd->acked_data_sn = (begrun - 1);
 
-	target_debug("Received Data ACK SNACK for ITT: 0x%08x,"
-		     " updated acked DataSN to 0x%08x.\n",
+	target_debug("Received Data ACK SNACK for ITT: 0x%08x, updated acked DataSN to 0x%08x.\n",
 		     cmd->init_task_tag, cmd->acked_data_sn);
 
 	return 0;
@@ -758,8 +729,7 @@ static struct iscsi_ooo_cmdsn *iscsit_allocate_ooo_cmdsn(void)
 
 	ooo_cmdsn = kmem_cache_zalloc(lio_ooo_cache, GFP_ATOMIC);
 	if (!ooo_cmdsn) {
-		target_err("Unable to allocate memory for"
-			   " struct iscsi_ooo_cmdsn.\n");
+		target_err("Unable to allocate memory for struct iscsi_ooo_cmdsn.\n");
 		return NULL;
 	}
 	INIT_LIST_HEAD(&ooo_cmdsn->ooo_list);
@@ -864,8 +834,7 @@ int iscsit_execute_ooo_cmdsns(struct iscsit_session *sess)
 		cmd->i_state = cmd->deferred_i_state;
 		ooo_count++;
 		sess->exp_cmd_sn++;
-		target_debug("Executing out of order CmdSN: 0x%08x,"
-			     " incremented ExpCmdSN to 0x%08x.\n",
+		target_debug("Executing out of order CmdSN: 0x%08x, incremented ExpCmdSN to 0x%08x.\n",
 			     cmd->cmd_sn, sess->exp_cmd_sn);
 
 		iscsit_remove_ooo_cmdsn(sess, ooo_cmdsn);
@@ -979,8 +948,7 @@ int iscsit_execute_cmd(struct iscsit_cmd *cmd, int ooo)
 			lr = iscsit_logout_removeconnforrecovery(cmd, cmd->conn);
 			break;
 		default:
-			target_err("Unknown iSCSI Logout Request Code:"
-				   " 0x%02x\n",
+			target_err("Unknown iSCSI Logout Request Code: 0x%02x\n",
 				   cmd->logout_reason);
 			return -1;
 		}
@@ -988,8 +956,7 @@ int iscsit_execute_cmd(struct iscsit_cmd *cmd, int ooo)
 		return lr;
 	default:
 		spin_unlock_bh(&cmd->istate_lock);
-		target_err("Cannot perform out of order execution for"
-			   " unknown iSCSI Opcode: 0x%02x\n",
+		target_err("Cannot perform out of order execution for unknown iSCSI Opcode: 0x%02x\n",
 			   cmd->iscsi_opcode);
 		return -1;
 	}
@@ -1085,8 +1052,7 @@ static int iscsit_set_dataout_timeout_values(
 	}
 	spin_unlock_bh(&cmd->r2t_lock);
 
-	target_err("Unable to locate any incomplete DataOUT"
-		   " sequences for ITT: 0x%08x.\n",
+	target_err("Unable to locate any incomplete DataOUT sequences for ITT: 0x%08x.\n",
 		   cmd->init_task_tag);
 
 	return -1;
@@ -1117,18 +1083,14 @@ void iscsit_handle_dataout_timeout(struct timer_list *t)
 	na = iscsit_tpg_get_node_attrib(sess);
 
 	if (!sess->sess_ops->ErrorRecoveryLevel) {
-		target_err("Unable to recover from DataOut timeout while"
-			   " in ERL=0, closing iSCSI connection for I_T Nexus"
-			   " %s,i,0x%6phN,%s,t,0x%02x\n",
+		target_err("Unable to recover from DataOut timeout while in ERL=0, closing iSCSI connection for I_T Nexus %s,i,0x%6phN,%s,t,0x%02x\n",
 			   sess->sess_ops->InitiatorName, sess->isid, sess->tpg->tpg_tiqn->tiqn,
 			   (u32)sess->tpg->tpgt);
 		goto failure;
 	}
 
 	if (++cmd->dataout_timeout_retries == na->dataout_timeout_retries) {
-		target_err("Command ITT: 0x%08x exceeded max retries"
-			   " for DataOUT timeout %u, closing iSCSI connection for"
-			   " I_T Nexus %s,i,0x%6phN,%s,t,0x%02x\n",
+		target_err("Command ITT: 0x%08x exceeded max retries for DataOUT timeout %u, closing iSCSI connection for I_T Nexus %s,i,0x%6phN,%s,t,0x%02x\n",
 			   cmd->init_task_tag, na->dataout_timeout_retries,
 			   sess->sess_ops->InitiatorName, sess->isid, sess->tpg->tpg_tiqn->tiqn,
 			   (u32)sess->tpg->tpgt);
@@ -1162,8 +1124,7 @@ void iscsit_handle_dataout_timeout(struct timer_list *t)
 			&r2t_offset, &r2t_length) < 0)
 		goto failure;
 
-	target_debug("Command ITT: 0x%08x timed out waiting for"
-		     " completion of %sDataOUT Sequence Offset: %u, Length: %u\n",
+	target_debug("Command ITT: 0x%08x timed out waiting for completion of %sDataOUT Sequence Offset: %u, Length: %u\n",
 		     cmd->init_task_tag, (cmd->unsolicited_data) ? "Unsolicited " : "", r2t_offset,
 		     r2t_length);
 
@@ -1213,9 +1174,8 @@ void iscsit_start_dataout_timer(
 	if (cmd->dataout_timer_flags & ISCSI_TF_RUNNING)
 		return;
 
-	target_debug("Starting DataOUT timer for ITT: 0x%08x on"
-		     " CID: %hu.\n",
-		     cmd->init_task_tag, conn->cid);
+	target_debug("Starting DataOUT timer for ITT: 0x%08x on CID: %hu.\n", cmd->init_task_tag,
+		     conn->cid);
 
 	cmd->dataout_timer_flags &= ~ISCSI_TF_STOP;
 	cmd->dataout_timer_flags |= ISCSI_TF_RUNNING;
diff --git a/drivers/target/iscsi/iscsi_target_erl2.c b/drivers/target/iscsi/iscsi_target_erl2.c
index 8b84ff97b0f0..96fb0ea0ad4c 100644
--- a/drivers/target/iscsi/iscsi_target_erl2.c
+++ b/drivers/target/iscsi/iscsi_target_erl2.c
@@ -92,8 +92,7 @@ static int iscsit_attach_inactive_connection_recovery_entry(
 	list_add_tail(&cr->cr_list, &sess->cr_inactive_list);
 
 	sess->conn_recovery_count++;
-	target_debug("Incremented connection recovery count to %u for"
-		     " SID: %u\n",
+	target_debug("Incremented connection recovery count to %u for SID: %u\n",
 		     sess->conn_recovery_count, sess->sid);
 	spin_unlock(&sess->cr_i_lock);
 
@@ -176,8 +175,7 @@ int iscsit_remove_active_connection_recovery_entry(
 	list_del(&cr->cr_list);
 
 	sess->conn_recovery_count--;
-	target_debug("Decremented connection recovery count to %u for"
-		     " SID: %u\n",
+	target_debug("Decremented connection recovery count to %u for SID: %u\n",
 		     sess->conn_recovery_count, sess->sid);
 	spin_unlock(&sess->cr_a_lock);
 
@@ -205,8 +203,7 @@ int iscsit_remove_cmd_from_connection_recovery(
 	struct iscsi_conn_recovery *cr;
 
 	if (!cmd->cr) {
-		target_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x"
-			   " is NULL!\n",
+		target_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x is NULL!\n",
 			   cmd->init_task_tag);
 		BUG();
 	}
@@ -235,8 +232,7 @@ void iscsit_discard_cr_cmds_by_expstatsn(
 		}
 
 		dropped_count++;
-		target_debug("Dropping Acknowledged ITT: 0x%08x, StatSN:"
-			     " 0x%08x, CID: %hu.\n",
+		target_debug("Dropping Acknowledged ITT: 0x%08x, StatSN: 0x%08x, CID: %hu.\n",
 			     cmd->init_task_tag, cmd->stat_sn, cr->cid);
 
 		iscsit_remove_cmd_from_connection_recovery(cmd, sess);
@@ -247,18 +243,15 @@ void iscsit_discard_cr_cmds_by_expstatsn(
 	}
 	spin_unlock(&cr->conn_recovery_cmd_lock);
 
-	target_debug("Dropped %u total acknowledged commands on"
-		     " CID: %hu less than old ExpStatSN: 0x%08x\n",
+	target_debug("Dropped %u total acknowledged commands on CID: %hu less than old ExpStatSN: 0x%08x\n",
 		     dropped_count, cr->cid, exp_statsn);
 
 	if (!cr->cmd_count) {
-		target_debug("No commands to be reassigned for failed"
-			     " connection CID: %hu on SID: %u\n",
+		target_debug("No commands to be reassigned for failed connection CID: %hu on SID: %u\n",
 			     cr->cid, sess->sid);
 		iscsit_remove_inactive_connection_recovery_entry(cr, sess);
 		iscsit_attach_active_connection_recovery_entry(sess, cr);
-		target_debug("iSCSI connection recovery successful for CID:"
-			     " %hu on SID: %u\n",
+		target_debug("iSCSI connection recovery successful for CID: %hu on SID: %u\n",
 			     cr->cid, sess->sid);
 		iscsit_remove_active_connection_recovery_entry(cr, sess);
 	} else {
@@ -282,8 +275,7 @@ int iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(struct iscsit_conn *conn)
 			continue;
 
 		dropped_count++;
-		target_debug("Dropping unacknowledged CmdSN:"
-			     " 0x%08x during connection recovery on CID: %hu\n",
+		target_debug("Dropping unacknowledged CmdSN: 0x%08x during connection recovery on CID: %hu\n",
 			     ooo_cmdsn->cmdsn, conn->cid);
 		iscsit_remove_ooo_cmdsn(sess, ooo_cmdsn);
 	}
@@ -302,8 +294,7 @@ int iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(struct iscsit_conn *conn)
 	}
 	spin_unlock_bh(&conn->cmd_lock);
 
-	target_debug("Dropped %u total unacknowledged commands on CID:"
-		     " %hu for ExpCmdSN: 0x%08x.\n",
+	target_debug("Dropped %u total unacknowledged commands on CID: %hu for ExpCmdSN: 0x%08x.\n",
 		     dropped_count, conn->cid, sess->exp_cmd_sn);
 	return 0;
 }
@@ -322,8 +313,7 @@ int iscsit_prepare_cmds_for_reallegiance(struct iscsit_conn *conn)
 	 */
 	cr = kzalloc(sizeof(struct iscsi_conn_recovery), GFP_KERNEL);
 	if (!cr) {
-		target_err("Unable to allocate memory for"
-			   " struct iscsi_conn_recovery.\n");
+		target_err("Unable to allocate memory for struct iscsi_conn_recovery.\n");
 		return -1;
 	}
 	INIT_LIST_HEAD(&cr->cr_list);
@@ -343,9 +333,7 @@ int iscsit_prepare_cmds_for_reallegiance(struct iscsit_conn *conn)
 
 		if ((cmd->iscsi_opcode != ISCSI_OP_SCSI_CMD) &&
 		    (cmd->iscsi_opcode != ISCSI_OP_NOOP_OUT)) {
-			target_debug("Not performing reallegiance on"
-				     " Opcode: 0x%02x, ITT: 0x%08x, CmdSN: 0x%08x,"
-				     " CID: %hu\n",
+			target_debug("Not performing reallegiance on Opcode: 0x%02x, ITT: 0x%08x, CmdSN: 0x%08x, CID: %hu\n",
 				     cmd->iscsi_opcode, cmd->init_task_tag, cmd->cmd_sn, conn->cid);
 
 			list_del_init(&cmd->i_conn_node);
@@ -376,9 +364,7 @@ int iscsit_prepare_cmds_for_reallegiance(struct iscsit_conn *conn)
 		}
 
 		cmd_count++;
-		target_debug("Preparing Opcode: 0x%02x, ITT: 0x%08x,"
-			     " CmdSN: 0x%08x, StatSN: 0x%08x, CID: %hu for"
-			     " reallegiance.\n",
+		target_debug("Preparing Opcode: 0x%02x, ITT: 0x%08x, CmdSN: 0x%08x, StatSN: 0x%08x, CID: %hu for reallegiance.\n",
 			     cmd->iscsi_opcode, cmd->init_task_tag, cmd->cmd_sn, cmd->stat_sn,
 			     conn->cid);
 
diff --git a/drivers/target/iscsi/iscsi_target_login.c b/drivers/target/iscsi/iscsi_target_login.c
index 99dfe612bdcc..0450408bd9a3 100644
--- a/drivers/target/iscsi/iscsi_target_login.c
+++ b/drivers/target/iscsi/iscsi_target_login.c
@@ -117,8 +117,7 @@ static int iscsi_login_check_initiator_version(
 	u8 version_min)
 {
 	if ((version_max != 0x00) || (version_min != 0x00)) {
-		target_err("Unsupported iSCSI IETF Pre-RFC Revision,"
-			   " version Min/Max 0x%02x/0x%02x, rejecting login.\n",
+		target_err("Unsupported iSCSI IETF Pre-RFC Revision, version Min/Max 0x%02x/0x%02x, rejecting login.\n",
 			   version_min, version_max);
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 				ISCSI_LOGIN_STATUS_NO_VERSION);
@@ -184,8 +183,7 @@ int iscsi_check_for_session_reinstatement(struct iscsit_conn *conn)
 	if (!sess)
 		return 0;
 
-	target_debug("%s iSCSI Session SID %u is still active for %s,"
-		     " performing session reinstatement.\n",
+	target_debug("%s iSCSI Session SID %u is still active for %s, performing session reinstatement.\n",
 		     (sessiontype) ? "Discovery" : "Normal", sess->sid,
 		     sess->sess_ops->InitiatorName);
 
@@ -312,8 +310,7 @@ static int iscsi_login_zero_tsih_s1(
 	if (!sess->sess_ops) {
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
 				ISCSI_LOGIN_STATUS_NO_RESOURCES);
-		target_err("Unable to allocate memory for"
-			   " struct iscsi_sess_ops.\n");
+		target_err("Unable to allocate memory for struct iscsi_sess_ops.\n");
 		goto free_id;
 	}
 
@@ -442,8 +439,7 @@ static int iscsi_login_zero_tsih_s2(
 		else
 			mrdsl -= off;
 
-		target_warn("Aligning ISER MaxRecvDataSegmentLength: %lu down"
-			    " to PAGE_SIZE\n",
+		target_warn("Aligning ISER MaxRecvDataSegmentLength: %lu down to PAGE_SIZE\n",
 			    mrdsl);
 
 		if (iscsi_change_param_sprintf(conn, "MaxRecvDataSegmentLength=%lu\n", mrdsl))
@@ -463,8 +459,7 @@ static int iscsi_login_zero_tsih_s2(
 			if (iscsi_change_param_sprintf(conn, "InitialR2T=Yes"))
 				return -1;
 
-			target_debug("Forcing ImmediateData=No + InitialR2T=Yes for"
-				     " T10-PI enabled ISER session\n");
+			target_debug("Forcing ImmediateData=No + InitialR2T=Yes for T10-PI enabled ISER session\n");
 		}
 	}
 
@@ -518,8 +513,7 @@ static int iscsi_login_non_zero_tsih_s2(
 	 * If the Time2Retain handler has expired, the session is already gone.
 	 */
 	if (!sess) {
-		target_err("Initiator attempting to add a connection to"
-			   " a non-existent session, rejecting iSCSI Login.\n");
+		target_err("Initiator attempting to add a connection to a non-existent session, rejecting iSCSI Login.\n");
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 				ISCSI_LOGIN_STATUS_NO_SESSION);
 		return -1;
@@ -577,8 +571,7 @@ int iscsi_login_post_auth_non_zero_tsih(
 	 */
 	conn_ptr = iscsit_get_conn_from_cid_rcfr(sess, cid);
 	if (conn_ptr) {
-		target_err("Connection exists with CID %hu for %s,"
-			   " performing connection reinstatement.\n",
+		target_err("Connection exists with CID %hu for %s, performing connection reinstatement.\n",
 			   conn_ptr->cid, sess->sess_ops->InitiatorName);
 
 		iscsit_connection_reinstatement_rcfr(conn_ptr);
@@ -598,8 +591,7 @@ int iscsi_login_post_auth_non_zero_tsih(
 		cr = iscsit_get_inactive_connection_recovery_entry(
 				sess, cid);
 		if (cr) {
-			target_debug("Performing implicit logout"
-				     " for connection recovery on CID: %hu\n",
+			target_debug("Performing implicit logout for connection recovery on CID: %hu\n",
 				     conn->cid);
 			iscsit_discard_cr_cmds_by_expstatsn(cr, exp_statsn);
 		}
@@ -615,8 +607,7 @@ int iscsi_login_post_auth_non_zero_tsih(
 		     sess->sess_ops->InitiatorName);
 
 	if ((atomic_read(&sess->nconn) + 1) > sess->sess_ops->MaxConnections) {
-		target_err("Adding additional connection to this session"
-			   " would exceed MaxConnections %d, login failed.\n",
+		target_err("Adding additional connection to this session would exceed MaxConnections %d, login failed.\n",
 			   sess->sess_ops->MaxConnections);
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 				ISCSI_LOGIN_STATUS_ISID_ERROR);
@@ -649,8 +640,7 @@ int iscsit_start_kthreads(struct iscsit_conn *conn)
 	spin_unlock(&iscsit_global->ts_bitmap_lock);
 
 	if (conn->bitmap_id < 0) {
-		target_err("bitmap_find_free_region() failed for"
-			   " iscsit_start_kthreads()\n");
+		target_err("bitmap_find_free_region() failed for iscsit_start_kthreads()\n");
 		return -ENOMEM;
 	}
 
@@ -717,20 +707,17 @@ void iscsi_post_login_handler(
 		spin_lock_bh(&sess->conn_lock);
 		atomic_set(&sess->session_continuation, 0);
 		if (sess->session_state == TARG_SESS_STATE_FAILED) {
-			target_debug("Moving to"
-				     " TARG_SESS_STATE_LOGGED_IN.\n");
+			target_debug("Moving to TARG_SESS_STATE_LOGGED_IN.\n");
 			sess->session_state = TARG_SESS_STATE_LOGGED_IN;
 			stop_timer = 1;
 		}
 
-		target_debug("iSCSI Login successful on CID: %hu from %pISpc to"
-			     " %pISpc,%hu\n",
+		target_debug("iSCSI Login successful on CID: %hu from %pISpc to %pISpc,%hu\n",
 			     conn->cid, &conn->login_sockaddr, &conn->local_sockaddr, tpg->tpgt);
 
 		list_add_tail(&conn->conn_list, &sess->sess_conn_list);
 		atomic_inc(&sess->nconn);
-		target_debug("Incremented iSCSI Connection count to %d"
-			     " from node: %s\n",
+		target_debug("Incremented iSCSI Connection count to %d from node: %s\n",
 			     atomic_read(&sess->nconn), sess->sess_ops->InitiatorName);
 		spin_unlock_bh(&sess->conn_lock);
 
@@ -776,8 +763,7 @@ void iscsi_post_login_handler(
 	spin_lock_bh(&sess->conn_lock);
 	list_add_tail(&conn->conn_list, &sess->sess_conn_list);
 	atomic_inc(&sess->nconn);
-	target_debug("Incremented iSCSI Connection count to %d from node:"
-		     " %s\n",
+	target_debug("Incremented iSCSI Connection count to %d from node: %s\n",
 		     atomic_read(&sess->nconn), sess->sess_ops->InitiatorName);
 	spin_unlock_bh(&sess->conn_lock);
 
@@ -790,8 +776,7 @@ void iscsi_post_login_handler(
 	if (tpg->tpg_tiqn)
 		tpg->tpg_tiqn->tiqn_nsessions++;
 
-	target_debug("Incremented number of active iSCSI sessions to %u on"
-		     " iSCSI Target Portal Group: %hu\n",
+	target_debug("Incremented number of active iSCSI sessions to %u on iSCSI Target Portal Group: %hu\n",
 		     tpg->nsessions, tpg->tpgt);
 	spin_unlock_bh(&se_tpg->session_lock);
 
@@ -976,8 +961,7 @@ int iscsit_get_login_rx(struct iscsit_conn *conn, struct iscsi_login *login)
 	payload_length	= ntoh24(login_req->dlength);
 	padding = ((-payload_length) & 3);
 
-	target_debug("Got Login Command, Flags 0x%02x, ITT: 0x%08x,"
-		     " CmdSN: 0x%08x, ExpStatSN: 0x%08x, CID: %hu, Length: %u\n",
+	target_debug("Got Login Command, Flags 0x%02x, ITT: 0x%08x, CmdSN: 0x%08x, ExpStatSN: 0x%08x, CID: %hu, Length: %u\n",
 		     login_req->flags, login_req->itt, login_req->cmdsn, login_req->exp_statsn,
 		     login_req->cid, payload_length);
 	/*
@@ -1277,8 +1261,7 @@ static int __iscsi_target_login_thread(struct iscsi_np *np)
 	spin_lock_bh(&np->np_thread_lock);
 	if (np->np_thread_state != ISCSI_NP_THREAD_ACTIVE) {
 		spin_unlock_bh(&np->np_thread_lock);
-		target_err("iSCSI Network Portal on %pISpc currently not"
-			   " active.\n",
+		target_err("iSCSI Network Portal on %pISpc currently not active.\n",
 			   &np->np_sockaddr);
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
 				ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE);
@@ -1288,8 +1271,7 @@ static int __iscsi_target_login_thread(struct iscsi_np *np)
 
 	conn->network_transport = np->np_network_transport;
 
-	target_debug("Received iSCSI login request from %pISpc on %s Network"
-		     " Portal %pISpc\n",
+	target_debug("Received iSCSI login request from %pISpc on %s Network Portal %pISpc\n",
 		     &conn->login_sockaddr, np->np_transport->name, &conn->local_sockaddr);
 
 	target_debug("Moving to TARG_CONN_STATE_IN_LOGIN.\n");
diff --git a/drivers/target/iscsi/iscsi_target_nego.c b/drivers/target/iscsi/iscsi_target_nego.c
index 5e7f3baa13bb..4f60ec03c95c 100644
--- a/drivers/target/iscsi/iscsi_target_nego.c
+++ b/drivers/target/iscsi/iscsi_target_nego.c
@@ -88,9 +88,7 @@ int extract_param(
 		return -EINVAL;
 
 	if (len >= max_length) {
-		target_err("Length of input: %d exceeds max_length:"
-			   " %d\n",
-			   len, max_length);
+		target_err("Length of input: %d exceeds max_length: %d\n", len, max_length);
 		return -EINVAL;
 	}
 	memcpy(out_buf, ptr, len);
@@ -181,8 +179,7 @@ int iscsi_target_check_login_request(
 
 	if ((login_req->flags & ISCSI_FLAG_LOGIN_CONTINUE) &&
 	    (login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT)) {
-		target_err("Login request has both ISCSI_FLAG_LOGIN_CONTINUE"
-			   " and ISCSI_FLAG_LOGIN_TRANSIT set, protocol error.\n");
+		target_err("Login request has both ISCSI_FLAG_LOGIN_CONTINUE and ISCSI_FLAG_LOGIN_TRANSIT set, protocol error.\n");
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 				ISCSI_LOGIN_STATUS_INIT_ERR);
 		return -1;
@@ -192,8 +189,7 @@ int iscsi_target_check_login_request(
 	req_nsg = ISCSI_LOGIN_NEXT_STAGE(login_req->flags);
 
 	if (req_csg != login->current_stage) {
-		target_err("Initiator unexpectedly changed login stage"
-			   " from %d to %d, login failed.\n",
+		target_err("Initiator unexpectedly changed login stage from %d to %d, login failed.\n",
 			   login->current_stage, req_csg);
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 				ISCSI_LOGIN_STATUS_INIT_ERR);
@@ -203,8 +199,7 @@ int iscsi_target_check_login_request(
 	if ((req_nsg == 2) || (req_csg >= 2) ||
 	   ((login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT) &&
 	    (req_nsg <= req_csg))) {
-		target_err("Illegal login_req->flags Combination, CSG: %d,"
-			   " NSG: %d, ISCSI_FLAG_LOGIN_TRANSIT: %d.\n",
+		target_err("Illegal login_req->flags Combination, CSG: %d, NSG: %d, ISCSI_FLAG_LOGIN_TRANSIT: %d.\n",
 			   req_csg, req_nsg, (login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT));
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 				ISCSI_LOGIN_STATUS_INIT_ERR);
@@ -213,8 +208,7 @@ int iscsi_target_check_login_request(
 
 	if ((login_req->max_version != login->version_max) ||
 	    (login_req->min_version != login->version_min)) {
-		target_err("Login request changed Version Max/Nin"
-			   " unexpectedly to 0x%02x/0x%02x, protocol error\n",
+		target_err("Login request changed Version Max/Nin unexpectedly to 0x%02x/0x%02x, protocol error\n",
 			   login_req->max_version, login_req->min_version);
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 				ISCSI_LOGIN_STATUS_INIT_ERR);
@@ -222,16 +216,14 @@ int iscsi_target_check_login_request(
 	}
 
 	if (memcmp(login_req->isid, login->isid, 6) != 0) {
-		target_err("Login request changed ISID unexpectedly,"
-			   " protocol error.\n");
+		target_err("Login request changed ISID unexpectedly, protocol error.\n");
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 				ISCSI_LOGIN_STATUS_INIT_ERR);
 		return -1;
 	}
 
 	if (login_req->itt != login->init_task_tag) {
-		target_err("Login request changed ITT unexpectedly to"
-			   " 0x%08x, protocol error.\n",
+		target_err("Login request changed ITT unexpectedly to 0x%08x, protocol error.\n",
 			   login_req->itt);
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 				ISCSI_LOGIN_STATUS_INIT_ERR);
@@ -239,8 +231,7 @@ int iscsi_target_check_login_request(
 	}
 
 	if (payload_length > MAX_KEY_VALUE_PAIRS) {
-		target_err("Login request payload exceeds default"
-			   " MaxRecvDataSegmentLength: %u, protocol error.\n",
+		target_err("Login request payload exceeds default MaxRecvDataSegmentLength: %u, protocol error.\n",
 			   MAX_KEY_VALUE_PAIRS);
 		return -1;
 	}
@@ -261,8 +252,7 @@ static int iscsi_target_check_first_request(
 	list_for_each_entry(param, &conn->param_list->param_list, p_list) {
 		if (!strncmp(param->name, SESSIONTYPE, 11)) {
 			if (!IS_PSTATE_ACCEPTOR(param)) {
-				target_err("SessionType key not received"
-					   " in first login request.\n");
+				target_err("SessionType key not received in first login request.\n");
 				iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 					ISCSI_LOGIN_STATUS_MISSING_FIELDS);
 				return -1;
@@ -276,8 +266,7 @@ static int iscsi_target_check_first_request(
 				if (!login->leading_connection)
 					continue;
 
-				target_err("InitiatorName key not received"
-					   " in first login request.\n");
+				target_err("InitiatorName key not received in first login request.\n");
 				iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 					ISCSI_LOGIN_STATUS_MISSING_FIELDS);
 				return -1;
@@ -291,8 +280,7 @@ static int iscsi_target_check_first_request(
 			if (!login->leading_connection) {
 				se_nacl = conn->sess->se_sess->se_node_acl;
 				if (!se_nacl) {
-					target_err("Unable to locate"
-						   " struct se_node_acl\n");
+					target_err("Unable to locate struct se_node_acl\n");
 					iscsit_tx_login_rsp(conn,
 							ISCSI_STATUS_CLS_INITIATOR_ERR,
 							ISCSI_LOGIN_STATUS_TGT_NOT_FOUND);
@@ -301,9 +289,7 @@ static int iscsi_target_check_first_request(
 
 				if (strcmp(param->value,
 						se_nacl->initiatorname)) {
-					target_err("Incorrect"
-						   " InitiatorName: %s for this"
-						   " iSCSI Initiator Node.\n",
+					target_err("Incorrect InitiatorName: %s for this iSCSI Initiator Node.\n",
 						   param->value);
 					iscsit_tx_login_rsp(conn,
 							ISCSI_STATUS_CLS_INITIATOR_ERR,
@@ -333,9 +319,7 @@ static int iscsi_target_do_tx_login_io(struct iscsit_conn *conn, struct iscsi_lo
 	login_rsp->exp_cmdsn		= cpu_to_be32(conn->sess->exp_cmd_sn);
 	login_rsp->max_cmdsn		= cpu_to_be32((u32) atomic_read(&conn->sess->max_cmd_sn));
 
-	target_debug("Sending Login Response, Flags: 0x%02x, ITT: 0x%08x,"
-		     " ExpCmdSN; 0x%08x, MaxCmdSN: 0x%08x, StatSN: 0x%08x, Length:"
-		     " %u\n",
+	target_debug("Sending Login Response, Flags: 0x%02x, ITT: 0x%08x, ExpCmdSN; 0x%08x, MaxCmdSN: 0x%08x, StatSN: 0x%08x, Length: %u\n",
 		     login_rsp->flags, (__force u32)login_rsp->itt, ntohl(login_rsp->exp_cmdsn),
 		     ntohl(login_rsp->max_cmdsn), ntohl(login_rsp->statsn), login->rsp_length);
 
@@ -416,8 +400,7 @@ static void iscsi_target_sk_data_ready(struct sock *sk)
 
 	rc = schedule_delayed_work(&conn->login_work, 0);
 	if (!rc) {
-		target_debug("iscsi_target_sk_data_ready, schedule_delayed_work"
-			     " got false\n");
+		target_debug("iscsi_target_sk_data_ready, schedule_delayed_work got false\n");
 	}
 	write_unlock_bh(&sk->sk_callback_lock);
 }
@@ -475,8 +458,7 @@ static int iscsi_target_do_login(struct iscsit_conn *, struct iscsi_login *);
 static bool __iscsi_target_sk_check_close(struct sock *sk)
 {
 	if (sk->sk_state == TCP_CLOSE_WAIT || sk->sk_state == TCP_CLOSE) {
-		target_debug("__iscsi_target_sk_check_close: TCP_CLOSE_WAIT|TCP_CLOSE,"
-			     "returning TRUE\n");
+		target_debug("__iscsi_target_sk_check_close: TCP_CLOSE_WAIT|TCP_CLOSE,returning TRUE\n");
 		return true;
 	}
 	return false;
@@ -682,8 +664,7 @@ static void iscsi_target_sk_state_change(struct sock *sk)
 
 	if (test_bit(LOGIN_FLAGS_READ_ACTIVE, &conn->login_flags) ||
 	    test_bit(LOGIN_FLAGS_WRITE_ACTIVE, &conn->login_flags)) {
-		target_debug("Got LOGIN_FLAGS_{READ|WRITE}_ACTIVE=1"
-			     " sk_state_change conn: %p\n",
+		target_debug("Got LOGIN_FLAGS_{READ|WRITE}_ACTIVE=1 sk_state_change conn: %p\n",
 			     conn);
 		if (state)
 			set_bit(LOGIN_FLAGS_CLOSED, &conn->login_flags);
@@ -777,12 +758,10 @@ static int iscsi_target_do_authentication(
 			param->value);
 	switch (authret) {
 	case 0:
-		target_debug("Received OK response"
-			     " from LIO Authentication, continuing.\n");
+		target_debug("Received OK response from LIO Authentication, continuing.\n");
 		break;
 	case 1:
-		target_debug("iSCSI security negotiation"
-			     " completed successfully.\n");
+		target_debug("iSCSI security negotiation completed successfully.\n");
 		login->auth_complete = 1;
 		if ((login_req->flags & ISCSI_FLAG_LOGIN_NEXT_STAGE1) &&
 		    (login_req->flags & ISCSI_FLAG_LOGIN_TRANSIT)) {
@@ -793,15 +772,12 @@ static int iscsi_target_do_authentication(
 		return iscsi_target_check_for_existing_instances(
 				conn, login);
 	case 2:
-		target_err("Security negotiation"
-			   " failed.\n");
+		target_err("Security negotiation failed.\n");
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 				ISCSI_LOGIN_STATUS_AUTH_FAILED);
 		return -1;
 	default:
-		target_err("Received unknown error %d from LIO"
-			   " Authentication\n",
-			   authret);
+		target_err("Received unknown error %d from LIO Authentication\n", authret);
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
 				ISCSI_LOGIN_STATUS_TARGET_ERROR);
 		return -1;
@@ -873,9 +849,7 @@ static int iscsi_target_handle_csg_zero(
 
 	if (ret > 0) {
 		if (login->auth_complete) {
-			target_err("Initiator has already been"
-				   " successfully authenticated, but is still"
-				   " sending %s keys.\n",
+			target_err("Initiator has already been successfully authenticated, but is still sending %s keys.\n",
 				   param->value);
 			iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 					ISCSI_LOGIN_STATUS_INIT_ERR);
@@ -884,8 +858,7 @@ static int iscsi_target_handle_csg_zero(
 
 		goto do_auth;
 	} else if (!payload_length) {
-		target_err("Initiator sent zero length security payload,"
-			   " login failed\n");
+		target_err("Initiator sent zero length security payload, login failed\n");
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 				    ISCSI_LOGIN_STATUS_AUTH_FAILED);
 		return -1;
@@ -910,9 +883,7 @@ static int iscsi_target_handle_csg_zero(
 
 		if (auth_required) {
 			if (!strncmp(param->value, NONE, 4)) {
-				target_err("Initiator sent AuthMethod=None but"
-					   " Target is enforcing iSCSI Authentication,"
-					   " login failed.\n");
+				target_err("Initiator sent AuthMethod=None but Target is enforcing iSCSI Authentication, login failed.\n");
 				iscsit_tx_login_rsp(conn,
 						ISCSI_STATUS_CLS_INITIATOR_ERR,
 						ISCSI_LOGIN_STATUS_AUTH_FAILED);
@@ -996,9 +967,7 @@ static int iscsi_target_handle_csg_one(struct iscsit_conn *conn, struct iscsi_lo
 	}
 
 	if (!iscsi_conn_authenticated(conn, login)) {
-		target_err("Initiator is requesting CSG: 1, has not been"
-			   " successfully authenticated, and the Target is"
-			   " enforcing iSCSI Authentication, login failed.\n");
+		target_err("Initiator is requesting CSG: 1, has not been successfully authenticated, and the Target is enforcing iSCSI Authentication, login failed.\n");
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 				ISCSI_LOGIN_STATUS_AUTH_FAILED);
 		return -1;
@@ -1067,8 +1036,7 @@ static int iscsi_target_do_login(struct iscsit_conn *conn, struct iscsi_login *l
 			}
 			break;
 		default:
-			target_err("Illegal CSG: %d received from"
-				   " Initiator, protocol error.\n",
+			target_err("Illegal CSG: %d received from Initiator, protocol error.\n",
 				   ISCSI_LOGIN_CURRENT_STAGE(login_req->flags));
 			break;
 		}
@@ -1160,8 +1128,7 @@ int iscsi_target_locate_portal(
 	 * See 5.3.  Login Phase.
 	 */
 	if (!i_buf) {
-		target_err("InitiatorName key not received"
-			   " in first login request.\n");
+		target_err("InitiatorName key not received in first login request.\n");
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 			ISCSI_LOGIN_STATUS_MISSING_FIELDS);
 		ret = -1;
@@ -1178,8 +1145,7 @@ int iscsi_target_locate_portal(
 		if (!login->leading_connection)
 			goto get_target;
 
-		target_err("SessionType key not received"
-			   " in first login request.\n");
+		target_err("SessionType key not received in first login request.\n");
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 			ISCSI_LOGIN_STATUS_MISSING_FIELDS);
 		ret = -1;
@@ -1221,9 +1187,7 @@ int iscsi_target_locate_portal(
 
 get_target:
 	if (!t_buf) {
-		target_err("TargetName key not received"
-			   " in first login request while"
-			   " SessionType=Normal.\n");
+		target_err("TargetName key not received in first login request while SessionType=Normal.\n");
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 			ISCSI_LOGIN_STATUS_MISSING_FIELDS);
 		ret = -1;
@@ -1235,9 +1199,7 @@ int iscsi_target_locate_portal(
 	 */
 	tiqn = iscsit_get_tiqn_for_login(t_buf);
 	if (!tiqn) {
-		target_err("Unable to locate Target IQN: %s in"
-			   " Storage Node\n",
-			   t_buf);
+		target_err("Unable to locate Target IQN: %s in Storage Node\n", t_buf);
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
 				ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE);
 		ret = -1;
@@ -1250,9 +1212,7 @@ int iscsi_target_locate_portal(
 	 */
 	conn->tpg = iscsit_get_tpg_from_np(tiqn, np, &tpg_np);
 	if (!conn->tpg) {
-		target_err("Unable to locate Target Portal Group"
-			   " on %s\n",
-			   tiqn->tiqn);
+		target_err("Unable to locate Target Portal Group on %s\n", tiqn->tiqn);
 		iscsit_put_tiqn_for_login(tiqn);
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_TARGET_ERR,
 				ISCSI_LOGIN_STATUS_SVC_UNAVAILABLE);
@@ -1307,8 +1267,7 @@ int iscsi_target_locate_portal(
 	sess->se_sess->se_node_acl = core_tpg_check_initiator_node_acl(
 			&conn->tpg->tpg_se_tpg, i_buf);
 	if (!sess->se_sess->se_node_acl) {
-		target_err("iSCSI Initiator Node: %s is not authorized to"
-			   " access iSCSI target portal group: %hu.\n",
+		target_err("iSCSI Initiator Node: %s is not authorized to access iSCSI target portal group: %hu.\n",
 			   i_buf, conn->tpg->tpgt);
 		iscsit_tx_login_rsp(conn, ISCSI_STATUS_CLS_INITIATOR_ERR,
 				ISCSI_LOGIN_STATUS_TGT_FORBIDDEN);
diff --git a/drivers/target/iscsi/iscsi_target_nodeattrib.c b/drivers/target/iscsi/iscsi_target_nodeattrib.c
index 5b1269fe9184..7a2a92d7d7bb 100644
--- a/drivers/target/iscsi/iscsi_target_nodeattrib.c
+++ b/drivers/target/iscsi/iscsi_target_nodeattrib.c
@@ -48,21 +48,18 @@ int iscsit_na_dataout_timeout(
 	struct iscsi_node_attrib *a = &acl->node_attrib;
 
 	if (dataout_timeout > NA_DATAOUT_TIMEOUT_MAX) {
-		target_err("Requested DataOut Timeout %u larger than"
-			   " maximum %u\n",
-			   dataout_timeout, NA_DATAOUT_TIMEOUT_MAX);
+		target_err("Requested DataOut Timeout %u larger than maximum %u\n", dataout_timeout,
+			   NA_DATAOUT_TIMEOUT_MAX);
 		return -EINVAL;
 	} else if (dataout_timeout < NA_DATAOUT_TIMEOUT_MIX) {
-		target_err("Requested DataOut Timeout %u smaller than"
-			   " minimum %u\n",
+		target_err("Requested DataOut Timeout %u smaller than minimum %u\n",
 			   dataout_timeout, NA_DATAOUT_TIMEOUT_MIX);
 		return -EINVAL;
 	}
 
 	a->dataout_timeout = dataout_timeout;
-	target_debug("Set DataOut Timeout to %u for Initiator Node"
-		     " %s\n",
-		     a->dataout_timeout, iscsit_na_get_initiatorname(acl));
+	target_debug("Set DataOut Timeout to %u for Initiator Node %s\n", a->dataout_timeout,
+		     iscsit_na_get_initiatorname(acl));
 
 	return 0;
 }
@@ -74,20 +71,17 @@ int iscsit_na_dataout_timeout_retries(
 	struct iscsi_node_attrib *a = &acl->node_attrib;
 
 	if (dataout_timeout_retries > NA_DATAOUT_TIMEOUT_RETRIES_MAX) {
-		target_err("Requested DataOut Timeout Retries %u larger"
-			   " than maximum %u",
+		target_err("Requested DataOut Timeout Retries %u larger than maximum %u",
 			   dataout_timeout_retries, NA_DATAOUT_TIMEOUT_RETRIES_MAX);
 		return -EINVAL;
 	} else if (dataout_timeout_retries < NA_DATAOUT_TIMEOUT_RETRIES_MIN) {
-		target_err("Requested DataOut Timeout Retries %u smaller"
-			   " than minimum %u",
+		target_err("Requested DataOut Timeout Retries %u smaller than minimum %u",
 			   dataout_timeout_retries, NA_DATAOUT_TIMEOUT_RETRIES_MIN);
 		return -EINVAL;
 	}
 
 	a->dataout_timeout_retries = dataout_timeout_retries;
-	target_debug("Set DataOut Timeout Retries to %u for"
-		     " Initiator Node %s\n",
+	target_debug("Set DataOut Timeout Retries to %u for Initiator Node %s\n",
 		     a->dataout_timeout_retries, iscsit_na_get_initiatorname(acl));
 
 	return 0;
@@ -105,22 +99,19 @@ int iscsit_na_nopin_timeout(
 	u32 orig_nopin_timeout = a->nopin_timeout;
 
 	if (nopin_timeout > NA_NOPIN_TIMEOUT_MAX) {
-		target_err("Requested NopIn Timeout %u larger than maximum"
-			   " %u\n",
-			   nopin_timeout, NA_NOPIN_TIMEOUT_MAX);
+		target_err("Requested NopIn Timeout %u larger than maximum %u\n", nopin_timeout,
+			   NA_NOPIN_TIMEOUT_MAX);
 		return -EINVAL;
 	} else if ((nopin_timeout < NA_NOPIN_TIMEOUT_MIN) &&
 		   (nopin_timeout != 0)) {
-		target_err("Requested NopIn Timeout %u smaller than"
-			   " minimum %u and not 0\n",
+		target_err("Requested NopIn Timeout %u smaller than minimum %u and not 0\n",
 			   nopin_timeout, NA_NOPIN_TIMEOUT_MIN);
 		return -EINVAL;
 	}
 
 	a->nopin_timeout = nopin_timeout;
-	target_debug("Set NopIn Timeout to %u for Initiator"
-		     " Node %s\n",
-		     a->nopin_timeout, iscsit_na_get_initiatorname(acl));
+	target_debug("Set NopIn Timeout to %u for Initiator Node %s\n", a->nopin_timeout,
+		     iscsit_na_get_initiatorname(acl));
 	/*
 	 * Reenable disabled nopin_timeout timer for all iSCSI connections.
 	 */
@@ -156,21 +147,18 @@ int iscsit_na_nopin_response_timeout(
 	struct iscsi_node_attrib *a = &acl->node_attrib;
 
 	if (nopin_response_timeout > NA_NOPIN_RESPONSE_TIMEOUT_MAX) {
-		target_err("Requested NopIn Response Timeout %u larger"
-			   " than maximum %u\n",
+		target_err("Requested NopIn Response Timeout %u larger than maximum %u\n",
 			   nopin_response_timeout, NA_NOPIN_RESPONSE_TIMEOUT_MAX);
 		return -EINVAL;
 	} else if (nopin_response_timeout < NA_NOPIN_RESPONSE_TIMEOUT_MIN) {
-		target_err("Requested NopIn Response Timeout %u smaller"
-			   " than minimum %u\n",
+		target_err("Requested NopIn Response Timeout %u smaller than minimum %u\n",
 			   nopin_response_timeout, NA_NOPIN_RESPONSE_TIMEOUT_MIN);
 		return -EINVAL;
 	}
 
 	a->nopin_response_timeout = nopin_response_timeout;
-	target_debug("Set NopIn Response Timeout to %u for"
-		     " Initiator Node %s\n",
-		     a->nopin_timeout, iscsit_na_get_initiatorname(acl));
+	target_debug("Set NopIn Response Timeout to %u for Initiator Node %s\n", a->nopin_timeout,
+		     iscsit_na_get_initiatorname(acl));
 
 	return 0;
 }
@@ -182,15 +170,13 @@ int iscsit_na_random_datain_pdu_offsets(
 	struct iscsi_node_attrib *a = &acl->node_attrib;
 
 	if (random_datain_pdu_offsets != 0 && random_datain_pdu_offsets != 1) {
-		target_err("Requested Random DataIN PDU Offsets: %u not"
-			   " 0 or 1\n",
+		target_err("Requested Random DataIN PDU Offsets: %u not 0 or 1\n",
 			   random_datain_pdu_offsets);
 		return -EINVAL;
 	}
 
 	a->random_datain_pdu_offsets = random_datain_pdu_offsets;
-	target_debug("Set Random DataIN PDU Offsets to %u for"
-		     " Initiator Node %s\n",
+	target_debug("Set Random DataIN PDU Offsets to %u for Initiator Node %s\n",
 		     a->random_datain_pdu_offsets, iscsit_na_get_initiatorname(acl));
 
 	return 0;
@@ -203,15 +189,13 @@ int iscsit_na_random_datain_seq_offsets(
 	struct iscsi_node_attrib *a = &acl->node_attrib;
 
 	if (random_datain_seq_offsets != 0 && random_datain_seq_offsets != 1) {
-		target_err("Requested Random DataIN Sequence Offsets: %u"
-			   " not 0 or 1\n",
+		target_err("Requested Random DataIN Sequence Offsets: %u not 0 or 1\n",
 			   random_datain_seq_offsets);
 		return -EINVAL;
 	}
 
 	a->random_datain_seq_offsets = random_datain_seq_offsets;
-	target_debug("Set Random DataIN Sequence Offsets to %u for"
-		     " Initiator Node %s\n",
+	target_debug("Set Random DataIN Sequence Offsets to %u for Initiator Node %s\n",
 		     a->random_datain_seq_offsets, iscsit_na_get_initiatorname(acl));
 
 	return 0;
@@ -224,16 +208,13 @@ int iscsit_na_random_r2t_offsets(
 	struct iscsi_node_attrib *a = &acl->node_attrib;
 
 	if (random_r2t_offsets != 0 && random_r2t_offsets != 1) {
-		target_err("Requested Random R2T Offsets: %u not"
-			   " 0 or 1\n",
-			   random_r2t_offsets);
+		target_err("Requested Random R2T Offsets: %u not 0 or 1\n", random_r2t_offsets);
 		return -EINVAL;
 	}
 
 	a->random_r2t_offsets = random_r2t_offsets;
-	target_debug("Set Random R2T Offsets to %u for"
-		     " Initiator Node %s\n",
-		     a->random_r2t_offsets, iscsit_na_get_initiatorname(acl));
+	target_debug("Set Random R2T Offsets to %u for Initiator Node %s\n", a->random_r2t_offsets,
+		     iscsit_na_get_initiatorname(acl));
 
 	return 0;
 }
@@ -250,9 +231,8 @@ int iscsit_na_default_erl(
 	}
 
 	a->default_erl = default_erl;
-	target_debug("Set use ERL0 flag to %u for Initiator"
-		     " Node %s\n",
-		     a->default_erl, iscsit_na_get_initiatorname(acl));
+	target_debug("Set use ERL0 flag to %u for Initiator Node %s\n", a->default_erl,
+		     iscsit_na_get_initiatorname(acl));
 
 	return 0;
 }
diff --git a/drivers/target/iscsi/iscsi_target_parameters.c b/drivers/target/iscsi/iscsi_target_parameters.c
index a195b45cb28a..4b8429c53904 100644
--- a/drivers/target/iscsi/iscsi_target_parameters.c
+++ b/drivers/target/iscsi/iscsi_target_parameters.c
@@ -183,8 +183,7 @@ int iscsi_create_default_params(struct iscsi_param_list **param_list_ptr)
 
 	pl = kzalloc(sizeof(struct iscsi_param_list), GFP_KERNEL);
 	if (!pl) {
-		target_err("Unable to allocate memory for"
-			   " struct iscsi_param_list.\n");
+		target_err("Unable to allocate memory for struct iscsi_param_list.\n");
 		return -ENOMEM;
 	}
 	INIT_LIST_HEAD(&pl->param_list);
@@ -663,8 +662,7 @@ int iscsi_extract_key_value(char *textbuf, char **key, char **value)
 {
 	*value = strchr(textbuf, '=');
 	if (!*value) {
-		target_err("Unable to locate \"=\" separator for key,"
-			   " ignoring request.\n");
+		target_err("Unable to locate \"=\" separator for key, ignoring request.\n");
 		return -1;
 	}
 
@@ -697,16 +695,14 @@ static int iscsi_add_notunderstood_response(
 	struct iscsi_extra_response *extra_response;
 
 	if (strlen(value) > VALUE_MAXLEN) {
-		target_err("Value for notunderstood key \"%s\" exceeds %d,"
-			   " protocol error.\n",
-			   key, VALUE_MAXLEN);
+		target_err("Value for notunderstood key \"%s\" exceeds %d, protocol error.\n", key,
+			   VALUE_MAXLEN);
 		return -1;
 	}
 
 	extra_response = kzalloc(sizeof(struct iscsi_extra_response), GFP_KERNEL);
 	if (!extra_response) {
-		target_err("Unable to allocate memory for"
-			   " struct iscsi_extra_response.\n");
+		target_err("Unable to allocate memory for struct iscsi_extra_response.\n");
 		return -ENOMEM;
 	}
 	INIT_LIST_HEAD(&extra_response->er_list);
@@ -783,8 +779,7 @@ static void iscsi_check_proposer_for_optional_reply(struct iscsi_param *param,
 static int iscsi_check_boolean_value(struct iscsi_param *param, char *value)
 {
 	if (strcmp(value, YES) && strcmp(value, NO)) {
-		target_err("Illegal value for \"%s\", must be either"
-			   " \"%s\" or \"%s\".\n",
+		target_err("Illegal value for \"%s\", must be either \"%s\" or \"%s\".\n",
 			   param->name, YES, NO);
 		return -1;
 	}
@@ -801,8 +796,7 @@ static int iscsi_check_numerical_value(struct iscsi_param *param, char *value_pt
 
 	if (IS_TYPERANGE_0_TO_2(param)) {
 		if ((value < 0) || (value > 2)) {
-			target_err("Illegal value for \"%s\", must be"
-				   " between 0 and 2.\n",
+			target_err("Illegal value for \"%s\", must be between 0 and 2.\n",
 				   param->name);
 			return -1;
 		}
@@ -810,8 +804,7 @@ static int iscsi_check_numerical_value(struct iscsi_param *param, char *value_pt
 	}
 	if (IS_TYPERANGE_0_TO_3600(param)) {
 		if ((value < 0) || (value > 3600)) {
-			target_err("Illegal value for \"%s\", must be"
-				   " between 0 and 3600.\n",
+			target_err("Illegal value for \"%s\", must be between 0 and 3600.\n",
 				   param->name);
 			return -1;
 		}
@@ -819,8 +812,7 @@ static int iscsi_check_numerical_value(struct iscsi_param *param, char *value_pt
 	}
 	if (IS_TYPERANGE_0_TO_32767(param)) {
 		if ((value < 0) || (value > 32767)) {
-			target_err("Illegal value for \"%s\", must be"
-				   " between 0 and 32767.\n",
+			target_err("Illegal value for \"%s\", must be between 0 and 32767.\n",
 				   param->name);
 			return -1;
 		}
@@ -828,8 +820,7 @@ static int iscsi_check_numerical_value(struct iscsi_param *param, char *value_pt
 	}
 	if (IS_TYPERANGE_0_TO_65535(param)) {
 		if ((value < 0) || (value > 65535)) {
-			target_err("Illegal value for \"%s\", must be"
-				   " between 0 and 65535.\n",
+			target_err("Illegal value for \"%s\", must be between 0 and 65535.\n",
 				   param->name);
 			return -1;
 		}
@@ -837,8 +828,7 @@ static int iscsi_check_numerical_value(struct iscsi_param *param, char *value_pt
 	}
 	if (IS_TYPERANGE_1_TO_65535(param)) {
 		if ((value < 1) || (value > 65535)) {
-			target_err("Illegal value for \"%s\", must be"
-				   " between 1 and 65535.\n",
+			target_err("Illegal value for \"%s\", must be between 1 and 65535.\n",
 				   param->name);
 			return -1;
 		}
@@ -846,8 +836,7 @@ static int iscsi_check_numerical_value(struct iscsi_param *param, char *value_pt
 	}
 	if (IS_TYPERANGE_2_TO_3600(param)) {
 		if ((value < 2) || (value > 3600)) {
-			target_err("Illegal value for \"%s\", must be"
-				   " between 2 and 3600.\n",
+			target_err("Illegal value for \"%s\", must be between 2 and 3600.\n",
 				   param->name);
 			return -1;
 		}
@@ -855,8 +844,7 @@ static int iscsi_check_numerical_value(struct iscsi_param *param, char *value_pt
 	}
 	if (IS_TYPERANGE_512_TO_16777215(param)) {
 		if ((value < 512) || (value > 16777215)) {
-			target_err("Illegal value for \"%s\", must be"
-				   " between 512 and 16777215.\n",
+			target_err("Illegal value for \"%s\", must be between 512 and 16777215.\n",
 				   param->name);
 			return -1;
 		}
@@ -875,25 +863,21 @@ static int iscsi_check_string_or_list_value(struct iscsi_param *param, char *val
 		if (strcmp(value, KRB5) && strcmp(value, SPKM1) &&
 		    strcmp(value, SPKM2) && strcmp(value, SRP) &&
 		    strcmp(value, CHAP) && strcmp(value, NONE)) {
-			target_err("Illegal value for \"%s\", must be"
-				   " \"%s\", \"%s\", \"%s\", \"%s\", \"%s\""
-				   " or \"%s\".\n",
+			target_err("Illegal value for \"%s\", must be \"%s\", \"%s\", \"%s\", \"%s\", \"%s\" or \"%s\".\n",
 				   param->name, KRB5, SPKM1, SPKM2, SRP, CHAP, NONE);
 			return -1;
 		}
 	}
 	if (IS_TYPERANGE_DIGEST_PARAM(param)) {
 		if (strcmp(value, CRC32C) && strcmp(value, NONE)) {
-			target_err("Illegal value for \"%s\", must be"
-				   " \"%s\" or \"%s\".\n",
+			target_err("Illegal value for \"%s\", must be \"%s\" or \"%s\".\n",
 				   param->name, CRC32C, NONE);
 			return -1;
 		}
 	}
 	if (IS_TYPERANGE_SESSIONTYPE(param)) {
 		if (strcmp(value, DISCOVERY) && strcmp(value, NORMAL)) {
-			target_err("Illegal value for \"%s\", must be"
-				   " \"%s\" or \"%s\".\n",
+			target_err("Illegal value for \"%s\", must be \"%s\" or \"%s\".\n",
 				   param->name, DISCOVERY, NORMAL);
 			return -1;
 		}
@@ -1032,8 +1016,7 @@ static int iscsi_check_acceptor_state(struct iscsi_param *param, char *value,
 				return -1;
 
 			conn->conn_ops->MaxRecvDataSegmentLength = tmp;
-			target_debug("Saving op->MaxRecvDataSegmentLength from"
-				     " original initiator received value: %u\n",
+			target_debug("Saving op->MaxRecvDataSegmentLength from original initiator received value: %u\n",
 				     conn->conn_ops->MaxRecvDataSegmentLength);
 
 			param_mxdsl = iscsi_find_param_from_key(
@@ -1054,9 +1037,7 @@ static int iscsi_check_acceptor_state(struct iscsi_param *param, char *value,
 		negotiated_value = iscsi_check_valuelist_for_support(
 					param, value);
 		if (!negotiated_value) {
-			target_err("Proposer's value list \"%s\" contains"
-				   " no valid values from Acceptor's value list"
-				   " \"%s\".\n",
+			target_err("Proposer's value list \"%s\" contains no valid values from Acceptor's value list \"%s\".\n",
 				   value, param->value);
 			return -1;
 		}
@@ -1127,8 +1108,7 @@ static int iscsi_check_value(struct iscsi_param *param, char *value)
 		}
 
 /* #warning FIXME: Add check for X-ExtensionKey here */
-		target_err("Standard iSCSI key \"%s\" cannot be answered"
-			   " with \"%s\", protocol error.\n",
+		target_err("Standard iSCSI key \"%s\" cannot be answered with \"%s\", protocol error.\n",
 			   param->name, value);
 		return -1;
 	}
@@ -1138,9 +1118,7 @@ static int iscsi_check_value(struct iscsi_param *param, char *value)
 		comma_ptr = strchr(value, ',');
 
 		if (comma_ptr && !IS_TYPE_VALUE_LIST(param)) {
-			target_err("Detected value separator \",\", but"
-				   " key \"%s\" does not allow a value list,"
-				   " protocol error.\n",
+			target_err("Detected value separator \",\", but key \"%s\" does not allow a value list, protocol error.\n",
 				   param->name);
 			return -1;
 		}
@@ -1148,8 +1126,7 @@ static int iscsi_check_value(struct iscsi_param *param, char *value)
 			*comma_ptr = '\0';
 
 		if (strlen(value) > VALUE_MAXLEN) {
-			target_err("Value for key \"%s\" exceeds %d,"
-				   " protocol error.\n",
+			target_err("Value for key \"%s\" exceeds %d, protocol error.\n",
 				   param->name, VALUE_MAXLEN);
 			return -1;
 		}
@@ -1194,16 +1171,14 @@ static struct iscsi_param *__iscsi_check_key(
 		return NULL;
 
 	if ((sender & SENDER_INITIATOR) && !IS_SENDER_INITIATOR(param)) {
-		target_err("Key \"%s\" may not be sent to %s,"
-			   " protocol error.\n",
-			   param->name, (sender & SENDER_RECEIVER) ? "target" : "initiator");
+		target_err("Key \"%s\" may not be sent to %s, protocol error.\n", param->name,
+			   (sender & SENDER_RECEIVER) ? "target" : "initiator");
 		return NULL;
 	}
 
 	if ((sender & SENDER_TARGET) && !IS_SENDER_TARGET(param)) {
-		target_err("Key \"%s\" may not be sent to %s,"
-			   " protocol error.\n",
-			   param->name, (sender & SENDER_RECEIVER) ? "initiator" : "target");
+		target_err("Key \"%s\" may not be sent to %s, protocol error.\n", param->name,
+			   (sender & SENDER_RECEIVER) ? "initiator" : "target");
 		return NULL;
 	}
 
@@ -1230,15 +1205,13 @@ static struct iscsi_param *iscsi_check_key(
 		return NULL;
 
 	if ((sender & SENDER_INITIATOR) && !IS_SENDER_INITIATOR(param)) {
-		target_err("Key \"%s\" may not be sent to %s,"
-			   " protocol error.\n",
-			   param->name, (sender & SENDER_RECEIVER) ? "target" : "initiator");
+		target_err("Key \"%s\" may not be sent to %s, protocol error.\n", param->name,
+			   (sender & SENDER_RECEIVER) ? "target" : "initiator");
 		return NULL;
 	}
 	if ((sender & SENDER_TARGET) && !IS_SENDER_TARGET(param)) {
-		target_err("Key \"%s\" may not be sent to %s,"
-			   " protocol error.\n",
-			   param->name, (sender & SENDER_RECEIVER) ? "initiator" : "target");
+		target_err("Key \"%s\" may not be sent to %s, protocol error.\n", param->name,
+			   (sender & SENDER_RECEIVER) ? "initiator" : "target");
 		return NULL;
 	}
 
@@ -1527,8 +1500,7 @@ void iscsi_set_connection_parameters(
 	char *tmpptr;
 	struct iscsi_param *param;
 
-	target_debug("---------------------------------------------------"
-		     "---------------\n");
+	target_debug("------------------------------------------------------------------\n");
 	list_for_each_entry(param, &param_list->param_list, p_list) {
 		/*
 		 * Special case to set MAXXMITDATASEGMENTLENGTH from the
@@ -1575,8 +1547,7 @@ void iscsi_set_connection_parameters(
 			target_debug("Set MXDSL from TargetRecvDataSegmentLength\n");
 		}
 	}
-	target_debug("----------------------------------------------------"
-		     "--------------\n");
+	target_debug("------------------------------------------------------------------\n");
 }
 
 void iscsi_set_session_parameters(
@@ -1587,8 +1558,7 @@ void iscsi_set_session_parameters(
 	char *tmpptr;
 	struct iscsi_param *param;
 
-	target_debug("----------------------------------------------------"
-		     "--------------\n");
+	target_debug("------------------------------------------------------------------\n");
 	list_for_each_entry(param, &param_list->param_list, p_list) {
 		if (!IS_PSTATE_ACCEPTOR(param) && !IS_PSTATE_PROPOSER(param))
 			continue;
@@ -1673,6 +1643,5 @@ void iscsi_set_session_parameters(
 			target_debug("RDMAExtensions:               %s\n", param->value);
 		}
 	}
-	target_debug("----------------------------------------------------"
-		     "--------------\n");
+	target_debug("------------------------------------------------------------------\n");
 }
diff --git a/drivers/target/iscsi/iscsi_target_seq_pdu_list.c b/drivers/target/iscsi/iscsi_target_seq_pdu_list.c
index a563b780d8e5..e60d69199504 100644
--- a/drivers/target/iscsi/iscsi_target_seq_pdu_list.c
+++ b/drivers/target/iscsi/iscsi_target_seq_pdu_list.c
@@ -27,9 +27,7 @@ static void iscsit_dump_seq_list(struct iscsit_cmd *cmd)
 
 	for (i = 0; i < cmd->seq_count; i++) {
 		seq = &cmd->seq_list[i];
-		target_debug("i: %d, pdu_start: %d, pdu_count: %d,"
-			     " offset: %d, xfer_len: %d, seq_send_order: %d,"
-			     " seq_no: %d\n",
+		target_debug("i: %d, pdu_start: %d, pdu_count: %d, offset: %d, xfer_len: %d, seq_send_order: %d, seq_no: %d\n",
 			     i, seq->pdu_start, seq->pdu_count, seq->offset, seq->xfer_len,
 			     seq->seq_send_order, seq->seq_no);
 	}
@@ -44,9 +42,8 @@ static void iscsit_dump_pdu_list(struct iscsit_cmd *cmd)
 
 	for (i = 0; i < cmd->pdu_count; i++) {
 		pdu = &cmd->pdu_list[i];
-		target_debug("i: %d, offset: %d, length: %d,"
-			     " pdu_send_order: %d, seq_no: %d\n",
-			     i, pdu->offset, pdu->length, pdu->pdu_send_order, pdu->seq_no);
+		target_debug("i: %d, offset: %d, length: %d, pdu_send_order: %d, seq_no: %d\n", i,
+			     pdu->offset, pdu->length, pdu->pdu_send_order, pdu->seq_no);
 	}
 }
 #else
@@ -129,8 +126,7 @@ static int iscsit_randomize_pdu_lists(
 		}
 		array = kcalloc(seq_count, sizeof(u32), GFP_KERNEL);
 		if (!array) {
-			target_err("Unable to allocate memory"
-				   " for random array.\n");
+			target_err("Unable to allocate memory for random array.\n");
 			return -ENOMEM;
 		}
 		iscsit_create_random_array(array, seq_count);
@@ -149,8 +145,7 @@ static int iscsit_randomize_pdu_lists(
 	if (seq_count) {
 		array = kcalloc(seq_count, sizeof(u32), GFP_KERNEL);
 		if (!array) {
-			target_err("Unable to allocate memory for"
-				   " random array.\n");
+			target_err("Unable to allocate memory for random array.\n");
 			return -ENOMEM;
 		}
 		iscsit_create_random_array(array, seq_count);
@@ -575,8 +570,7 @@ struct iscsi_pdu *iscsit_get_pdu_holder(
 		if ((pdu[i].offset == offset) && (pdu[i].length == length))
 			return &pdu[i];
 
-	target_err("Unable to locate PDU holder for ITT: 0x%08x, Offset:"
-		   " %u, Length: %u\n",
+	target_err("Unable to locate PDU holder for ITT: 0x%08x, Offset: %u, Length: %u\n",
 		   cmd->init_task_tag, offset, length);
 	return NULL;
 }
@@ -599,9 +593,7 @@ struct iscsi_pdu *iscsit_get_pdu_holder_for_seq(
 		pdu = &cmd->pdu_list[cmd->pdu_start];
 
 		for (i = 0; pdu[i].seq_no != cmd->seq_no; i++) {
-			target_debug("pdu[i].seq_no: %d, pdu[i].pdu"
-				     "_send_order: %d, pdu[i].offset: %d,"
-				     " pdu[i].length: %d\n",
+			target_debug("pdu[i].seq_no: %d, pdu[i].pdu_send_order: %d, pdu[i].offset: %d, pdu[i].length: %d\n",
 				     pdu[i].seq_no, pdu[i].pdu_send_order, pdu[i].offset,
 				     pdu[i].length);
 
@@ -618,8 +610,7 @@ struct iscsi_pdu *iscsit_get_pdu_holder_for_seq(
 		if (cmd->pdu_start < cmd->pdu_count)
 			goto redo;
 
-		target_err("Command ITT: 0x%08x unable to locate"
-			   " struct iscsi_pdu for cmd->pdu_send_order: %u.\n",
+		target_err("Command ITT: 0x%08x unable to locate struct iscsi_pdu for cmd->pdu_send_order: %u.\n",
 			   cmd->init_task_tag, cmd->pdu_send_order);
 		return NULL;
 	} else {
@@ -628,15 +619,13 @@ struct iscsi_pdu *iscsit_get_pdu_holder_for_seq(
 			return NULL;
 		}
 
-		target_debug("seq->pdu_start: %d, seq->pdu_count: %d,"
-			     " seq->seq_no: %d\n",
+		target_debug("seq->pdu_start: %d, seq->pdu_count: %d, seq->seq_no: %d\n",
 			     seq->pdu_start, seq->pdu_count, seq->seq_no);
 
 		pdu = &cmd->pdu_list[seq->pdu_start];
 
 		if (seq->pdu_send_order == seq->pdu_count) {
-			target_err("Command ITT: 0x%08x seq->pdu_send"
-				   "_order: %u equals seq->pdu_count: %u\n",
+			target_err("Command ITT: 0x%08x seq->pdu_send_order: %u equals seq->pdu_count: %u\n",
 				   cmd->init_task_tag, seq->pdu_send_order, seq->pdu_count);
 			return NULL;
 		}
@@ -648,8 +637,7 @@ struct iscsi_pdu *iscsit_get_pdu_holder_for_seq(
 			}
 		}
 
-		target_err("Command ITT: 0x%08x unable to locate iscsi"
-			   "_pdu_t for seq->pdu_send_order: %u.\n",
+		target_err("Command ITT: 0x%08x unable to locate iscsi_pdu_t for seq->pdu_send_order: %u.\n",
 			   cmd->init_task_tag, seq->pdu_send_order);
 		return NULL;
 	}
@@ -670,8 +658,7 @@ struct iscsi_seq *iscsit_get_seq_holder(
 	}
 
 	for (i = 0; i < cmd->seq_count; i++) {
-		target_debug("seq_list[i].orig_offset: %d, seq_list[i]."
-			     "xfer_len: %d, seq_list[i].seq_no %u\n",
+		target_debug("seq_list[i].orig_offset: %d, seq_list[i].xfer_len: %d, seq_list[i].seq_no %u\n",
 			     cmd->seq_list[i].orig_offset, cmd->seq_list[i].xfer_len,
 			     cmd->seq_list[i].seq_no);
 
@@ -681,8 +668,7 @@ struct iscsi_seq *iscsit_get_seq_holder(
 			return &cmd->seq_list[i];
 	}
 
-	target_err("Unable to locate Sequence holder for ITT: 0x%08x,"
-		   " Offset: %u, Length: %u\n",
+	target_err("Unable to locate Sequence holder for ITT: 0x%08x, Offset: %u, Length: %u\n",
 		   cmd->init_task_tag, offset, length);
 	return NULL;
 }
diff --git a/drivers/target/iscsi/iscsi_target_tmr.c b/drivers/target/iscsi/iscsi_target_tmr.c
index f40987cc5793..c9f55f3cf7e3 100644
--- a/drivers/target/iscsi/iscsi_target_tmr.c
+++ b/drivers/target/iscsi/iscsi_target_tmr.c
@@ -39,16 +39,14 @@ u8 iscsit_tmr_abort_task(
 
 	ref_cmd = iscsit_find_cmd_from_itt(conn, hdr->rtt);
 	if (!ref_cmd) {
-		target_err("Unable to locate RefTaskTag: 0x%08x on CID:"
-			   " %hu.\n",
-			   hdr->rtt, conn->cid);
+		target_err("Unable to locate RefTaskTag: 0x%08x on CID: %hu.\n", hdr->rtt,
+			   conn->cid);
 		return (iscsi_sna_gte(be32_to_cpu(hdr->refcmdsn), conn->sess->exp_cmd_sn) &&
 			iscsi_sna_lte(be32_to_cpu(hdr->refcmdsn), (u32) atomic_read(&conn->sess->max_cmd_sn))) ?
 			ISCSI_TMF_RSP_COMPLETE : ISCSI_TMF_RSP_NO_TASK;
 	}
 	if (ref_cmd->cmd_sn != be32_to_cpu(hdr->refcmdsn)) {
-		target_err("RefCmdSN 0x%08x does not equal"
-			   " task's CmdSN 0x%08x. Rejecting ABORT_TASK.\n",
+		target_err("RefCmdSN 0x%08x does not equal task's CmdSN 0x%08x. Rejecting ABORT_TASK.\n",
 			   hdr->refcmdsn, ref_cmd->cmd_sn);
 		return ISCSI_TMF_RSP_REJECTED;
 	}
@@ -72,8 +70,7 @@ int iscsit_tmr_task_warm_reset(
 	struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
 
 	if (!na->tmr_warm_reset) {
-		target_err("TMR Opcode TARGET_WARM_RESET authorization"
-			   " failed for Initiator Node: %s\n",
+		target_err("TMR Opcode TARGET_WARM_RESET authorization failed for Initiator Node: %s\n",
 			   sess->se_sess->se_node_acl->initiatorname);
 		return -1;
 	}
@@ -92,8 +89,7 @@ int iscsit_tmr_task_cold_reset(
 	struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
 
 	if (!na->tmr_cold_reset) {
-		target_err("TMR Opcode TARGET_COLD_RESET authorization"
-			   " failed for Initiator Node: %s\n",
+		target_err("TMR Opcode TARGET_COLD_RESET authorization failed for Initiator Node: %s\n",
 			   sess->se_sess->se_node_acl->initiatorname);
 		return -1;
 	}
@@ -115,25 +111,21 @@ u8 iscsit_tmr_task_reassign(
 	struct iscsi_tm *hdr = (struct iscsi_tm *) buf;
 	u64 ret, ref_lun;
 
-	target_debug("Got TASK_REASSIGN TMR ITT: 0x%08x,"
-		     " RefTaskTag: 0x%08x, ExpDataSN: 0x%08x, CID: %hu\n",
+	target_debug("Got TASK_REASSIGN TMR ITT: 0x%08x, RefTaskTag: 0x%08x, ExpDataSN: 0x%08x, CID: %hu\n",
 		     hdr->itt, hdr->rtt, hdr->exp_datasn, conn->cid);
 
 	if (conn->sess->sess_ops->ErrorRecoveryLevel != 2) {
-		target_err("TMR TASK_REASSIGN not supported in ERL<2,"
-			   " ignoring request.\n");
+		target_err("TMR TASK_REASSIGN not supported in ERL<2, ignoring request.\n");
 		return ISCSI_TMF_RSP_NOT_SUPPORTED;
 	}
 
 	ret = iscsit_find_cmd_for_recovery(conn->sess, &ref_cmd, &cr, hdr->rtt);
 	if (ret == -2) {
-		target_err("Command ITT: 0x%08x is still alligent to CID:"
-			   " %hu\n",
+		target_err("Command ITT: 0x%08x is still alligent to CID: %hu\n",
 			   ref_cmd->init_task_tag, cr->cid);
 		return ISCSI_TMF_RSP_TASK_ALLEGIANT;
 	} else if (ret == -1) {
-		target_err("Unable to locate RefTaskTag: 0x%08x in"
-			   " connection recovery command list.\n",
+		target_err("Unable to locate RefTaskTag: 0x%08x in connection recovery command list.\n",
 			   hdr->rtt);
 		return ISCSI_TMF_RSP_NO_TASK;
 	}
@@ -143,23 +135,18 @@ u8 iscsit_tmr_task_reassign(
 	 */
 	if (cr->maxrecvdatasegmentlength !=
 	    conn->conn_ops->MaxRecvDataSegmentLength) {
-		target_err("Unable to perform connection recovery for"
-			   " differing MaxRecvDataSegmentLength, rejecting"
-			   " TMR TASK_REASSIGN.\n");
+		target_err("Unable to perform connection recovery for differing MaxRecvDataSegmentLength, rejecting TMR TASK_REASSIGN.\n");
 		return ISCSI_TMF_RSP_REJECTED;
 	}
 	if (cr->maxxmitdatasegmentlength !=
 	    conn->conn_ops->MaxXmitDataSegmentLength) {
-		target_err("Unable to perform connection recovery for"
-			   " differing MaxXmitDataSegmentLength, rejecting"
-			   " TMR TASK_REASSIGN.\n");
+		target_err("Unable to perform connection recovery for differing MaxXmitDataSegmentLength, rejecting TMR TASK_REASSIGN.\n");
 		return ISCSI_TMF_RSP_REJECTED;
 	}
 
 	ref_lun = scsilun_to_int(&hdr->lun);
 	if (ref_lun != ref_cmd->se_cmd.orig_fe_lun) {
-		target_err("Unable to perform connection recovery for"
-			   " differing ref_lun: %llu ref_cmd orig_fe_lun: %llu\n",
+		target_err("Unable to perform connection recovery for differing ref_lun: %llu ref_cmd orig_fe_lun: %llu\n",
 			   ref_lun, ref_cmd->se_cmd.orig_fe_lun);
 		return ISCSI_TMF_RSP_REJECTED;
 	}
@@ -188,8 +175,7 @@ static void iscsit_task_reassign_remove_cmd(
 	ret = iscsit_remove_cmd_from_connection_recovery(cmd, sess);
 	spin_unlock(&cr->conn_recovery_cmd_lock);
 	if (!ret) {
-		target_debug("iSCSI connection recovery successful for CID:"
-			     " %hu on SID: %u\n",
+		target_debug("iSCSI connection recovery successful for CID: %hu on SID: %u\n",
 			     cr->cid, sess->sid);
 		iscsit_remove_active_connection_recovery_entry(cr, sess);
 	}
@@ -203,8 +189,7 @@ static int iscsit_task_reassign_complete_nop_out(
 	struct iscsi_conn_recovery *cr;
 
 	if (!cmd->cr) {
-		target_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x"
-			   " is NULL!\n",
+		target_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x is NULL!\n",
 			   cmd->init_task_tag);
 		return -1;
 	}
@@ -255,8 +240,7 @@ static int iscsit_task_reassign_complete_write(
 	 */
 	if (cmd->cmd_flags & ICF_GOT_LAST_DATAOUT) {
 		if (!(cmd->se_cmd.transport_state & CMD_T_SENT)) {
-			target_debug("WRITE ITT: 0x%08x: t_state: %d"
-				     " never sent to transport\n",
+			target_debug("WRITE ITT: 0x%08x: t_state: %d never sent to transport\n",
 				     cmd->init_task_tag, cmd->se_cmd.t_state);
 			target_execute_cmd(se_cmd);
 			return 0;
@@ -320,16 +304,14 @@ static int iscsit_task_reassign_complete_read(
 	}
 
 	if (!(cmd->se_cmd.transport_state & CMD_T_SENT)) {
-		target_debug("READ ITT: 0x%08x: t_state: %d never sent to"
-			     " transport\n",
+		target_debug("READ ITT: 0x%08x: t_state: %d never sent to transport\n",
 			     cmd->init_task_tag, cmd->se_cmd.t_state);
 		target_submit(se_cmd);
 		return 0;
 	}
 
 	if (!(se_cmd->transport_state & CMD_T_COMPLETE)) {
-		target_err("READ ITT: 0x%08x: t_state: %d, never returned"
-			   " from transport\n",
+		target_err("READ ITT: 0x%08x: t_state: %d, never returned from transport\n",
 			   cmd->init_task_tag, cmd->se_cmd.t_state);
 		return -1;
 	}
@@ -372,8 +354,7 @@ static int iscsit_task_reassign_complete_scsi_cmnd(
 	struct iscsi_conn_recovery *cr;
 
 	if (!cmd->cr) {
-		target_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x"
-			   " is NULL!\n",
+		target_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x is NULL!\n",
 			   cmd->init_task_tag);
 		return -1;
 	}
@@ -436,8 +417,7 @@ static int iscsit_task_reassign_complete(
 		ret = iscsit_task_reassign_complete_scsi_cmnd(tmr_req, conn);
 		break;
 	default:
-		target_err("Illegal iSCSI Opcode 0x%02x during"
-			   " command reallegiance\n",
+		target_err("Illegal iSCSI Opcode 0x%02x during command reallegiance\n",
 			   cmd->iscsi_opcode);
 		return -1;
 	}
@@ -445,8 +425,7 @@ static int iscsit_task_reassign_complete(
 	if (ret != 0)
 		return ret;
 
-	target_debug("Completed connection reallegiance for Opcode: 0x%02x,"
-		     " ITT: 0x%08x to CID: %hu.\n",
+	target_debug("Completed connection reallegiance for Opcode: 0x%02x, ITT: 0x%08x to CID: %hu.\n",
 		     cmd->iscsi_opcode, cmd->init_task_tag, conn->cid);
 
 	return 0;
@@ -733,10 +712,7 @@ static int iscsit_task_reassign_prepare_write(
 			continue;
 
 		if (r2t->seq_complete) {
-			target_err("Initiator is requesting R2Ts from"
-				   " R2TSN: 0x%08x, but R2TSN: 0x%08x, Offset: %u,"
-				   " Length: %u is already complete."
-				   "   BAD INITIATOR ERL=2 IMPLEMENTATION!\n",
+			target_err("Initiator is requesting R2Ts from R2TSN: 0x%08x, but R2TSN: 0x%08x, Offset: %u, Length: %u is already complete.   BAD INITIATOR ERL=2 IMPLEMENTATION!\n",
 				   tmr_req->exp_data_sn, r2t->r2t_sn, r2t->offset, r2t->xfer_len);
 			spin_unlock_bh(&cmd->r2t_lock);
 			return -1;
@@ -804,18 +780,13 @@ int iscsit_check_task_reassign_expdatasn(
 	 */
 	if (ref_cmd->data_direction == DMA_FROM_DEVICE) {
 		if (tmr_req->exp_data_sn > ref_cmd->data_sn) {
-			target_err("Received ExpDataSN: 0x%08x for READ"
-				   " in TMR TASK_REASSIGN greater than command's"
-				   " DataSN: 0x%08x.\n",
+			target_err("Received ExpDataSN: 0x%08x for READ in TMR TASK_REASSIGN greater than command's DataSN: 0x%08x.\n",
 				   tmr_req->exp_data_sn, ref_cmd->data_sn);
 			return -1;
 		}
 		if ((ref_cmd->cmd_flags & ICF_GOT_DATACK_SNACK) &&
 		    (tmr_req->exp_data_sn <= ref_cmd->acked_data_sn)) {
-			target_err("Received ExpDataSN: 0x%08x for READ"
-				   " in TMR TASK_REASSIGN for previously"
-				   " acknowledged DataIN: 0x%08x,"
-				   " protocol error\n",
+			target_err("Received ExpDataSN: 0x%08x for READ in TMR TASK_REASSIGN for previously acknowledged DataIN: 0x%08x, protocol error\n",
 				   tmr_req->exp_data_sn, ref_cmd->acked_data_sn);
 			return -1;
 		}
@@ -830,9 +801,7 @@ int iscsit_check_task_reassign_expdatasn(
 	 */
 	if (ref_cmd->data_direction == DMA_TO_DEVICE) {
 		if (tmr_req->exp_data_sn > ref_cmd->r2t_sn) {
-			target_err("Received ExpDataSN: 0x%08x for WRITE"
-				   " in TMR TASK_REASSIGN greater than command's"
-				   " R2TSN: 0x%08x.\n",
+			target_err("Received ExpDataSN: 0x%08x for WRITE in TMR TASK_REASSIGN greater than command's R2TSN: 0x%08x.\n",
 				   tmr_req->exp_data_sn, ref_cmd->r2t_sn);
 			return -1;
 		}
diff --git a/drivers/target/iscsi/iscsi_target_tpg.c b/drivers/target/iscsi/iscsi_target_tpg.c
index 532f4cff5bed..2d069354f384 100644
--- a/drivers/target/iscsi/iscsi_target_tpg.c
+++ b/drivers/target/iscsi/iscsi_target_tpg.c
@@ -227,8 +227,7 @@ static void iscsit_set_default_tpg_attribs(struct iscsi_portal_group *tpg)
 int iscsit_tpg_add_portal_group(struct iscsi_tiqn *tiqn, struct iscsi_portal_group *tpg)
 {
 	if (tpg->tpg_state != TPG_STATE_FREE) {
-		target_err("Unable to add iSCSI Target Portal Group: %d"
-			   " while not in TPG_STATE_FREE state.\n",
+		target_err("Unable to add iSCSI Target Portal Group: %d while not in TPG_STATE_FREE state.\n",
 			   tpg->tpgt);
 		return -EEXIST;
 	}
@@ -271,8 +270,7 @@ int iscsit_tpg_del_portal_group(
 	spin_unlock(&tpg->tpg_state_lock);
 
 	if (iscsit_release_sessions_for_tpg(tpg, force) < 0) {
-		target_err("Unable to delete iSCSI Target Portal Group:"
-			   " %hu while active sessions exist, and force=0\n",
+		target_err("Unable to delete iSCSI Target Portal Group: %hu while active sessions exist, and force=0\n",
 			   tpg->tpgt);
 		tpg->tpg_state = old_state;
 		return -EPERM;
@@ -308,8 +306,7 @@ int iscsit_tpg_enable_portal_group(struct iscsi_portal_group *tpg)
 	int ret;
 
 	if (tpg->tpg_state == TPG_STATE_ACTIVE) {
-		target_err("iSCSI target portal group: %hu is already"
-			   " active, ignoring request.\n",
+		target_err("iSCSI target portal group: %hu is already active, ignoring request.\n",
 			   tpg->tpgt);
 		return -EINVAL;
 	}
@@ -356,8 +353,7 @@ int iscsit_tpg_disable_portal_group(struct iscsi_portal_group *tpg, int force)
 
 	spin_lock(&tpg->tpg_state_lock);
 	if (tpg->tpg_state == TPG_STATE_INACTIVE) {
-		target_err("iSCSI Target Portal Group: %hu is already"
-			   " inactive, ignoring request.\n",
+		target_err("iSCSI Target Portal Group: %hu is already inactive, ignoring request.\n",
 			   tpg->tpgt);
 		spin_unlock(&tpg->tpg_state_lock);
 		return -EINVAL;
@@ -371,8 +367,7 @@ int iscsit_tpg_disable_portal_group(struct iscsi_portal_group *tpg, int force)
 		spin_lock(&tpg->tpg_state_lock);
 		tpg->tpg_state = old_state;
 		spin_unlock(&tpg->tpg_state_lock);
-		target_err("Unable to disable iSCSI Target Portal Group:"
-			   " %hu while active sessions exist, and force=0\n",
+		target_err("Unable to disable iSCSI Target Portal Group: %hu while active sessions exist, and force=0\n",
 			   tpg->tpgt);
 		return -EPERM;
 	}
@@ -463,8 +458,7 @@ struct iscsi_tpg_np *iscsit_tpg_add_network_portal(
 	if (!tpg_np_parent) {
 		if (iscsit_tpg_check_network_portal(tpg->tpg_tiqn, sockaddr,
 				network_transport)) {
-			target_err("Network Portal: %pISc already exists on a"
-				   " different TPG on %s\n",
+			target_err("Network Portal: %pISc already exists on a different TPG on %s\n",
 				   sockaddr, tpg->tpg_tiqn->tiqn);
 			return ERR_PTR(-EEXIST);
 		}
@@ -472,8 +466,7 @@ struct iscsi_tpg_np *iscsit_tpg_add_network_portal(
 
 	tpg_np = kzalloc(sizeof(struct iscsi_tpg_np), GFP_KERNEL);
 	if (!tpg_np) {
-		target_err("Unable to allocate memory for"
-			   " struct iscsi_tpg_np.\n");
+		target_err("Unable to allocate memory for struct iscsi_tpg_np.\n");
 		return ERR_PTR(-ENOMEM);
 	}
 
@@ -542,8 +535,7 @@ int iscsit_tpg_del_network_portal(
 
 	np = tpg_np->tpg_np;
 	if (!np) {
-		target_err("Unable to locate struct iscsi_np from"
-			   " struct iscsi_tpg_np\n");
+		target_err("Unable to locate struct iscsi_np from struct iscsi_tpg_np\n");
 		return -EINVAL;
 	}
 
@@ -558,9 +550,7 @@ int iscsit_tpg_del_network_portal(
 				tpg_np_child_list) {
 			ret = iscsit_tpg_del_network_portal(tpg, tpg_np_child);
 			if (ret < 0)
-				target_err("iscsit_tpg_del_network_portal()"
-					   " failed: %d\n",
-					   ret);
+				target_err("iscsit_tpg_del_network_portal() failed: %d\n", ret);
 		}
 	} else {
 		/*
@@ -590,8 +580,7 @@ int iscsit_ta_authentication(struct iscsi_portal_group *tpg, u32 authentication)
 	struct iscsi_tpg_attrib *a = &tpg->tpg_attrib;
 
 	if ((authentication != 1) && (authentication != 0)) {
-		target_err("Illegal value for authentication parameter:"
-			   " %u, ignoring request.\n",
+		target_err("Illegal value for authentication parameter: %u, ignoring request.\n",
 			   authentication);
 		return -EINVAL;
 	}
@@ -650,21 +639,18 @@ int iscsit_ta_login_timeout(
 	struct iscsi_tpg_attrib *a = &tpg->tpg_attrib;
 
 	if (login_timeout > TA_LOGIN_TIMEOUT_MAX) {
-		target_err("Requested Login Timeout %u larger than maximum"
-			   " %u\n",
-			   login_timeout, TA_LOGIN_TIMEOUT_MAX);
+		target_err("Requested Login Timeout %u larger than maximum %u\n", login_timeout,
+			   TA_LOGIN_TIMEOUT_MAX);
 		return -EINVAL;
 	} else if (login_timeout < TA_LOGIN_TIMEOUT_MIN) {
-		target_err("Requested Logout Timeout %u smaller than"
-			   " minimum %u\n",
-			   login_timeout, TA_LOGIN_TIMEOUT_MIN);
+		target_err("Requested Logout Timeout %u smaller than minimum %u\n", login_timeout,
+			   TA_LOGIN_TIMEOUT_MIN);
 		return -EINVAL;
 	}
 
 	a->login_timeout = login_timeout;
-	target_debug("Set Logout Timeout to %u for Target Portal Group"
-		     " %hu\n",
-		     a->login_timeout, tpg->tpgt);
+	target_debug("Set Logout Timeout to %u for Target Portal Group %hu\n", a->login_timeout,
+		     tpg->tpgt);
 
 	return 0;
 }
@@ -685,8 +671,7 @@ int iscsit_ta_generate_node_acls(
 		     (a->generate_node_acls) ? "Enabled" : "Disabled");
 
 	if (flag == 1 && a->cache_dynamic_acls == 0) {
-		target_debug("Explicitly setting cache_dynamic_acls=1 when "
-			     "generate_node_acls=1\n");
+		target_debug("Explicitly setting cache_dynamic_acls=1 when generate_node_acls=1\n");
 		a->cache_dynamic_acls = 1;
 	}
 
@@ -700,14 +685,12 @@ int iscsit_ta_default_cmdsn_depth(
 	struct iscsi_tpg_attrib *a = &tpg->tpg_attrib;
 
 	if (tcq_depth > TA_DEFAULT_CMDSN_DEPTH_MAX) {
-		target_err("Requested Default Queue Depth: %u larger"
-			   " than maximum %u\n",
-			   tcq_depth, TA_DEFAULT_CMDSN_DEPTH_MAX);
+		target_err("Requested Default Queue Depth: %u larger than maximum %u\n", tcq_depth,
+			   TA_DEFAULT_CMDSN_DEPTH_MAX);
 		return -EINVAL;
 	} else if (tcq_depth < TA_DEFAULT_CMDSN_DEPTH_MIN) {
-		target_err("Requested Default Queue Depth: %u smaller"
-			   " than minimum %u\n",
-			   tcq_depth, TA_DEFAULT_CMDSN_DEPTH_MIN);
+		target_err("Requested Default Queue Depth: %u smaller than minimum %u\n", tcq_depth,
+			   TA_DEFAULT_CMDSN_DEPTH_MIN);
 		return -EINVAL;
 	}
 
@@ -730,15 +713,13 @@ int iscsit_ta_cache_dynamic_acls(
 	}
 
 	if (a->generate_node_acls == 1 && flag == 0) {
-		target_debug("Skipping cache_dynamic_acls=0 when"
-			     " generate_node_acls=1\n");
+		target_debug("Skipping cache_dynamic_acls=0 when generate_node_acls=1\n");
 		return 0;
 	}
 
 	a->cache_dynamic_acls = flag;
-	target_debug("iSCSI_TPG[%hu] - Cache Dynamic Initiator Portal Group"
-		     " ACLs %s\n",
-		     tpg->tpgt, (a->cache_dynamic_acls) ? "Enabled" : "Disabled");
+	target_debug("iSCSI_TPG[%hu] - Cache Dynamic Initiator Portal Group ACLs %s\n", tpg->tpgt,
+		     (a->cache_dynamic_acls) ? "Enabled" : "Disabled");
 
 	return 0;
 }
@@ -773,9 +754,8 @@ int iscsit_ta_prod_mode_write_protect(
 	}
 
 	a->prod_mode_write_protect = flag;
-	target_debug("iSCSI_TPG[%hu] - Production Mode Write Protect bit:"
-		     " %s\n",
-		     tpg->tpgt, (a->prod_mode_write_protect) ? "ON" : "OFF");
+	target_debug("iSCSI_TPG[%hu] - Production Mode Write Protect bit: %s\n", tpg->tpgt,
+		     (a->prod_mode_write_protect) ? "ON" : "OFF");
 
 	return 0;
 }
@@ -792,9 +772,8 @@ int iscsit_ta_demo_mode_discovery(
 	}
 
 	a->demo_mode_discovery = flag;
-	target_debug("iSCSI_TPG[%hu] - Demo Mode Discovery bit:"
-		     " %s\n",
-		     tpg->tpgt, (a->demo_mode_discovery) ? "ON" : "OFF");
+	target_debug("iSCSI_TPG[%hu] - Demo Mode Discovery bit: %s\n", tpg->tpgt,
+		     (a->demo_mode_discovery) ? "ON" : "OFF");
 
 	return 0;
 }
@@ -828,9 +807,8 @@ int iscsit_ta_t10_pi(
 	}
 
 	a->t10_pi = flag;
-	target_debug("iSCSI_TPG[%hu] - T10 Protection information bit:"
-		     " %s\n",
-		     tpg->tpgt, (a->t10_pi) ? "ON" : "OFF");
+	target_debug("iSCSI_TPG[%hu] - T10 Protection information bit: %s\n", tpg->tpgt,
+		     (a->t10_pi) ? "ON" : "OFF");
 
 	return 0;
 }
@@ -864,9 +842,8 @@ int iscsit_ta_tpg_enabled_sendtargets(
 	}
 
 	a->tpg_enabled_sendtargets = flag;
-	target_debug("iSCSI_TPG[%hu] - TPG enabled bit required for SendTargets:"
-		     " %s\n",
-		     tpg->tpgt, (a->tpg_enabled_sendtargets) ? "ON" : "OFF");
+	target_debug("iSCSI_TPG[%hu] - TPG enabled bit required for SendTargets: %s\n", tpg->tpgt,
+		     (a->tpg_enabled_sendtargets) ? "ON" : "OFF");
 
 	return 0;
 }
diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c
index 26408a9f5546..f64f35083b61 100644
--- a/drivers/target/iscsi/iscsi_target_util.c
+++ b/drivers/target/iscsi/iscsi_target_util.c
@@ -81,9 +81,7 @@ struct iscsi_r2t *iscsit_get_r2t_for_eos(
 	}
 	spin_unlock_bh(&cmd->r2t_lock);
 
-	target_err("Unable to locate R2T for Offset: %u, Length:"
-		   " %u\n",
-		   offset, length);
+	target_err("Unable to locate R2T for Offset: %u, Length: %u\n", offset, length);
 	return NULL;
 }
 
@@ -100,9 +98,7 @@ struct iscsi_r2t *iscsit_get_r2t_from_list(struct iscsit_cmd *cmd)
 	}
 	spin_unlock_bh(&cmd->r2t_lock);
 
-	target_err("Unable to locate next R2T to send for ITT:"
-		   " 0x%08x.\n",
-		   cmd->init_task_tag);
+	target_err("Unable to locate next R2T to send for ITT: 0x%08x.\n", cmd->init_task_tag);
 	return NULL;
 }
 
@@ -253,27 +249,23 @@ static inline int iscsit_check_received_cmdsn(struct iscsit_session *sess, u32 c
 	 */
 	max_cmdsn = atomic_read(&sess->max_cmd_sn);
 	if (iscsi_sna_gt(cmdsn, max_cmdsn)) {
-		target_err("Received CmdSN: 0x%08x is greater than"
-			   " MaxCmdSN: 0x%08x, ignoring.\n",
+		target_err("Received CmdSN: 0x%08x is greater than MaxCmdSN: 0x%08x, ignoring.\n",
 			   cmdsn, max_cmdsn);
 		ret = CMDSN_MAXCMDSN_OVERRUN;
 
 	} else if (cmdsn == sess->exp_cmd_sn) {
 		sess->exp_cmd_sn++;
-		target_debug("Received CmdSN matches ExpCmdSN,"
-			     " incremented ExpCmdSN to: 0x%08x\n",
+		target_debug("Received CmdSN matches ExpCmdSN, incremented ExpCmdSN to: 0x%08x\n",
 			     sess->exp_cmd_sn);
 		ret = CMDSN_NORMAL_OPERATION;
 
 	} else if (iscsi_sna_gt(cmdsn, sess->exp_cmd_sn)) {
-		target_debug("Received CmdSN: 0x%08x is greater"
-			     " than ExpCmdSN: 0x%08x, not acknowledging.\n",
+		target_debug("Received CmdSN: 0x%08x is greater than ExpCmdSN: 0x%08x, not acknowledging.\n",
 			     cmdsn, sess->exp_cmd_sn);
 		ret = CMDSN_HIGHER_THAN_EXP;
 
 	} else {
-		target_err("Received CmdSN: 0x%08x is less than"
-			   " ExpCmdSN: 0x%08x, ignoring.\n",
+		target_err("Received CmdSN: 0x%08x is less than ExpCmdSN: 0x%08x, ignoring.\n",
 			   cmdsn, sess->exp_cmd_sn);
 		ret = CMDSN_LOWER_THAN_EXP;
 	}
@@ -344,8 +336,7 @@ int iscsit_check_unsolicited_dataout(struct iscsit_cmd *cmd, unsigned char *buf)
 	u32 payload_length = ntoh24(hdr->dlength);
 
 	if (conn->sess->sess_ops->InitialR2T) {
-		target_err("Received unexpected unsolicited data"
-			   " while InitialR2T=Yes, protocol error.\n");
+		target_err("Received unexpected unsolicited data while InitialR2T=Yes, protocol error.\n");
 		transport_send_check_condition_and_sense(se_cmd,
 				TCM_UNEXPECTED_UNSOLICITED_DATA, 0);
 		return -1;
@@ -353,8 +344,7 @@ int iscsit_check_unsolicited_dataout(struct iscsit_cmd *cmd, unsigned char *buf)
 
 	if ((cmd->first_burst_len + payload_length) >
 	     conn->sess->sess_ops->FirstBurstLength) {
-		target_err("Total %u bytes exceeds FirstBurstLength: %u"
-			   " for this Unsolicited DataOut Burst.\n",
+		target_err("Total %u bytes exceeds FirstBurstLength: %u for this Unsolicited DataOut Burst.\n",
 			   (cmd->first_burst_len + payload_length),
 			   conn->sess->sess_ops->FirstBurstLength);
 		transport_send_check_condition_and_sense(se_cmd,
@@ -368,9 +358,7 @@ int iscsit_check_unsolicited_dataout(struct iscsit_cmd *cmd, unsigned char *buf)
 	if (((cmd->first_burst_len + payload_length) != cmd->se_cmd.data_length) &&
 	    ((cmd->first_burst_len + payload_length) !=
 	      conn->sess->sess_ops->FirstBurstLength)) {
-		target_err("Unsolicited non-immediate data received %u"
-			   " does not equal FirstBurstLength: %u, and does"
-			   " not equal ExpXferLen %u.\n",
+		target_err("Unsolicited non-immediate data received %u does not equal FirstBurstLength: %u, and does not equal ExpXferLen %u.\n",
 			   (cmd->first_burst_len + payload_length),
 			   conn->sess->sess_ops->FirstBurstLength, cmd->se_cmd.data_length);
 		transport_send_check_condition_and_sense(se_cmd,
@@ -418,9 +406,8 @@ struct iscsit_cmd *iscsit_find_cmd_from_itt_or_dump(
 	}
 	spin_unlock_bh(&conn->cmd_lock);
 
-	target_err("Unable to locate ITT: 0x%08x on CID: %hu,"
-		   " dumping payload\n",
-		   init_task_tag, conn->cid);
+	target_err("Unable to locate ITT: 0x%08x on CID: %hu, dumping payload\n", init_task_tag,
+		   conn->cid);
 	if (length)
 		iscsit_dump_data_payload(conn, length, 1);
 
@@ -508,8 +495,7 @@ void iscsit_add_cmd_to_immediate_queue(
 
 	qr = kmem_cache_zalloc(lio_qr_cache, GFP_ATOMIC);
 	if (!qr) {
-		target_err("Unable to allocate memory for"
-			   " struct iscsi_queue_req\n");
+		target_err("Unable to allocate memory for struct iscsi_queue_req\n");
 		return;
 	}
 	INIT_LIST_HEAD(&qr->qr_list);
@@ -583,8 +569,7 @@ int iscsit_add_cmd_to_response_queue(
 
 	qr = kmem_cache_zalloc(lio_qr_cache, GFP_ATOMIC);
 	if (!qr) {
-		target_err("Unable to allocate memory for"
-			   " struct iscsi_queue_req\n");
+		target_err("Unable to allocate memory for struct iscsi_queue_req\n");
 		return -ENOMEM;
 	}
 	INIT_LIST_HEAD(&qr->qr_list);
@@ -907,8 +892,7 @@ void iscsit_handle_nopin_response_timeout(struct timer_list *t)
 		return;
 	}
 
-	target_err("Did not receive response to NOPIN on CID: %hu, failing"
-		   " connection for I_T Nexus %s,i,0x%6phN,%s,t,0x%02x\n",
+	target_err("Did not receive response to NOPIN on CID: %hu, failing connection for I_T Nexus %s,i,0x%6phN,%s,t,0x%02x\n",
 		   conn->cid, sess->sess_ops->InitiatorName, sess->isid, sess->tpg->tpg_tiqn->tiqn,
 		   (u32)sess->tpg->tpgt);
 	conn->nopin_response_timer_flags &= ~ISCSI_TF_RUNNING;
@@ -951,9 +935,8 @@ void iscsit_start_nopin_response_timer(struct iscsit_conn *conn)
 	mod_timer(&conn->nopin_response_timer,
 		  jiffies + na->nopin_response_timeout * HZ);
 
-	target_debug("Started NOPIN Response Timer on CID: %d to %u"
-		     " seconds\n",
-		     conn->cid, na->nopin_response_timeout);
+	target_debug("Started NOPIN Response Timer on CID: %d to %u seconds\n", conn->cid,
+		     na->nopin_response_timeout);
 	spin_unlock_bh(&conn->nopin_timer_lock);
 }
 
@@ -1013,9 +996,8 @@ void __iscsit_start_nopin_timer(struct iscsit_conn *conn)
 	conn->nopin_timer_flags |= ISCSI_TF_RUNNING;
 	mod_timer(&conn->nopin_timer, jiffies + na->nopin_timeout * HZ);
 
-	target_debug("Started NOPIN Timer on CID: %d at %u second"
-		     " interval\n",
-		     conn->cid, na->nopin_timeout);
+	target_debug("Started NOPIN Timer on CID: %d at %u second interval\n", conn->cid,
+		     na->nopin_timeout);
 }
 
 void iscsit_start_nopin_timer(struct iscsit_conn *conn)
@@ -1258,8 +1240,7 @@ void iscsit_print_session_params(struct iscsit_session *sess)
 {
 	struct iscsit_conn *conn;
 
-	target_debug("-----------------------------[Session Params for"
-		     " SID: %u]-----------------------------\n",
+	target_debug("-----------------------------[Session Params for SID: %u]-----------------------------\n",
 		     sess->sid);
 	spin_lock_bh(&sess->conn_lock);
 	list_for_each_entry(conn, &sess->sess_conn_list, conn_list)
diff --git a/drivers/target/target_core_alua.c b/drivers/target/target_core_alua.c
index a5906012c369..20fe346c270a 100644
--- a/drivers/target/target_core_alua.c
+++ b/drivers/target/target_core_alua.c
@@ -62,9 +62,7 @@ target_emulate_report_referrals(struct se_cmd *cmd)
 	u32 rd_len = 0, off;
 
 	if (cmd->data_length < 4) {
-		target_warn("REPORT REFERRALS allocation length %u too"
-			    " small\n",
-			    cmd->data_length);
+		target_warn("REPORT REFERRALS allocation length %u too small\n", cmd->data_length);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -153,8 +151,7 @@ target_emulate_report_target_port_groups(struct se_cmd *cmd)
 		off = 4;
 
 	if (cmd->data_length < off) {
-		target_warn("REPORT TARGET PORT GROUPS allocation length %u too"
-			    " small for %s header\n",
+		target_warn("REPORT TARGET PORT GROUPS allocation length %u too small for %s header\n",
 			    cmd->data_length, (ext_hdr) ? "extended" : "normal");
 		return TCM_INVALID_CDB_FIELD;
 	}
@@ -283,8 +280,7 @@ target_emulate_set_target_port_groups(struct se_cmd *cmd)
 	u16 tg_pt_id, rtpi;
 
 	if (cmd->data_length < 4) {
-		target_warn("SET TARGET PORT GROUPS parameter list length %u too"
-			    " small\n",
+		target_warn("SET TARGET PORT GROUPS parameter list length %u too small\n",
 			    cmd->data_length);
 		return TCM_INVALID_PARAMETER_LIST;
 	}
@@ -308,8 +304,7 @@ target_emulate_set_target_port_groups(struct se_cmd *cmd)
 
 	if (!(l_tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_EXPLICIT_ALUA)) {
 		rcu_read_unlock();
-		target_debug("Unable to process SET_TARGET_PORT_GROUPS"
-			     " while TPGS_EXPLICIT_ALUA is disabled\n");
+		target_debug("Unable to process SET_TARGET_PORT_GROUPS while TPGS_EXPLICIT_ALUA is disabled\n");
 		rc = TCM_UNSUPPORTED_SCSI_OPCODE;
 		goto out;
 	}
@@ -663,8 +658,7 @@ target_alua_state_check(struct se_cmd *cmd)
 	 * access state: OFFLINE
 	 */
 	if (atomic_read(&lun->lun_tg_pt_secondary_offline)) {
-		target_debug("ALUA: Got secondary offline status for local"
-			     " target port\n");
+		target_debug("ALUA: Got secondary offline status for local target port\n");
 		return TCM_ALUA_OFFLINE;
 	}
 	rcu_read_lock();
@@ -714,8 +708,7 @@ target_alua_state_check(struct se_cmd *cmd)
 	}
 
 	if (rc && rc != TCM_INVALID_CDB_FIELD) {
-		target_debug("[%s]: ALUA TG Port not available, "
-			     "SenseKey: NOT_READY, ASC/rc: 0x04/%d\n",
+		target_debug("[%s]: ALUA TG Port not available, SenseKey: NOT_READY, ASC/rc: 0x04/%d\n",
 			     cmd->se_tfo->fabric_name, rc);
 	}
 
@@ -1036,8 +1029,7 @@ static int core_alua_do_transition_tg_pt(
 		core_alua_update_tpg_primary_metadata(tg_pt_gp);
 	}
 
-	target_debug("Successful %s ALUA transition TG PT Group: %s ID: %hu"
-		     " from primary access state %s to %s\n",
+	target_debug("Successful %s ALUA transition TG PT Group: %s ID: %hu from primary access state %s to %s\n",
 		     (explicit) ? "explicit" : "implicit",
 		     config_item_name(&tg_pt_gp->tg_pt_gp_group.cg_item), tg_pt_gp->tg_pt_gp_id,
 		     core_alua_dump_state(prev_state), core_alua_dump_state(new_state));
@@ -1152,8 +1144,7 @@ int core_alua_do_port_transition(
 	spin_unlock(&lu_gp->lu_gp_lock);
 
 	if (!rc) {
-		target_debug("Successfully processed LU Group: %s all ALUA TG PT"
-			     " Group IDs: %hu %s transition to primary state: %s\n",
+		target_debug("Successfully processed LU Group: %s all ALUA TG PT Group IDs: %hu %s transition to primary state: %s\n",
 			     config_item_name(&lu_gp->lu_gp_group.cg_item), l_tg_pt_gp->tg_pt_gp_id,
 			     (explicit) ? "explicit" : "implicit", core_alua_dump_state(new_state));
 	}
@@ -1221,8 +1212,7 @@ static int core_alua_set_tg_pt_secondary_state(
 	tg_pt_gp = rcu_dereference(lun->lun_tg_pt_gp);
 	if (!tg_pt_gp) {
 		rcu_read_unlock();
-		target_err("Unable to complete secondary state"
-			   " transition\n");
+		target_err("Unable to complete secondary state transition\n");
 		return -EINVAL;
 	}
 	trans_delay_msecs = tg_pt_gp->tg_pt_gp_trans_delay_msecs;
@@ -1239,8 +1229,7 @@ static int core_alua_set_tg_pt_secondary_state(
 			ALUA_STATUS_ALTERED_BY_EXPLICIT_STPG :
 			ALUA_STATUS_ALTERED_BY_IMPLICIT_ALUA;
 
-	target_debug("Successful %s ALUA transition TG PT Group: %s ID: %hu"
-		     " to secondary access state: %s\n",
+	target_debug("Successful %s ALUA transition TG PT Group: %s ID: %hu to secondary access state: %s\n",
 		     (explicit) ? "explicit" : "implicit",
 		     config_item_name(&tg_pt_gp->tg_pt_gp_group.cg_item), tg_pt_gp->tg_pt_gp_id,
 		     (offline) ? "OFFLINE" : "ONLINE");
@@ -1395,15 +1384,13 @@ int core_alua_set_lu_gp_id(struct t10_alua_lu_gp *lu_gp, u16 lu_gp_id)
 	 * The lu_gp->lu_gp_id may only be set once..
 	 */
 	if (lu_gp->lu_gp_valid_id) {
-		target_warn("ALUA LU Group already has a valid ID,"
-			    " ignoring request\n");
+		target_warn("ALUA LU Group already has a valid ID, ignoring request\n");
 		return -EINVAL;
 	}
 
 	spin_lock(&lu_gps_lock);
 	if (alua_lu_gps_count == 0x0000ffff) {
-		target_err("Maximum ALUA alua_lu_gps_count:"
-			   " 0x0000ffff reached\n");
+		target_err("Maximum ALUA alua_lu_gps_count: 0x0000ffff reached\n");
 		spin_unlock(&lu_gps_lock);
 		kmem_cache_free(t10_alua_lu_gp_cache, lu_gp);
 		return -ENOSPC;
@@ -1417,8 +1404,7 @@ int core_alua_set_lu_gp_id(struct t10_alua_lu_gp *lu_gp, u16 lu_gp_id)
 			if (!lu_gp_id)
 				goto again;
 
-			target_warn("ALUA Logical Unit Group ID: %hu"
-				    " already exists, ignoring request\n",
+			target_warn("ALUA Logical Unit Group ID: %hu already exists, ignoring request\n",
 				    lu_gp_id);
 			spin_unlock(&lu_gps_lock);
 			return -EINVAL;
@@ -1663,15 +1649,13 @@ int core_alua_set_tg_pt_gp_id(
 	 * The tg_pt_gp->tg_pt_gp_id may only be set once..
 	 */
 	if (tg_pt_gp->tg_pt_gp_valid_id) {
-		target_warn("ALUA TG PT Group already has a valid ID,"
-			    " ignoring request\n");
+		target_warn("ALUA TG PT Group already has a valid ID, ignoring request\n");
 		return -EINVAL;
 	}
 
 	spin_lock(&dev->t10_alua.tg_pt_gps_lock);
 	if (dev->t10_alua.alua_tg_pt_gps_count == 0x0000ffff) {
-		target_err("Maximum ALUA alua_tg_pt_gps_count:"
-			   " 0x0000ffff reached\n");
+		target_err("Maximum ALUA alua_tg_pt_gps_count: 0x0000ffff reached\n");
 		spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
 		return -ENOSPC;
 	}
@@ -1685,8 +1669,7 @@ int core_alua_set_tg_pt_gp_id(
 			if (!tg_pt_gp_id)
 				goto again;
 
-			target_err("ALUA Target Port Group ID: %hu already"
-				   " exists, ignoring request\n",
+			target_err("ALUA Target Port Group ID: %hu already exists, ignoring request\n",
 				   tg_pt_gp_id);
 			spin_unlock(&dev->t10_alua.tg_pt_gps_lock);
 			return -EINVAL;
@@ -1941,10 +1924,7 @@ ssize_t core_alua_store_tg_pt_gp_info(
 		 * with the default_tg_pt_gp.
 		 */
 		if (!tg_pt_gp_new) {
-			target_debug("Target_Core_ConfigFS: Moving"
-				     " %s/tpgt_%hu/%s from ALUA Target Port Group:"
-				     " alua/%s, ID: %hu back to"
-				     " default_tg_pt_gp\n",
+			target_debug("Target_Core_ConfigFS: Moving %s/tpgt_%hu/%s from ALUA Target Port Group: alua/%s, ID: %hu back to default_tg_pt_gp\n",
 				     tpg->se_tpg_tfo->tpg_get_wwn(tpg),
 				     tpg->se_tpg_tfo->tpg_get_tag(tpg),
 				     config_item_name(&lun->lun_group.cg_item),
@@ -1962,8 +1942,7 @@ ssize_t core_alua_store_tg_pt_gp_info(
 
 	target_swap_tg_pt_gp(lun, tg_pt_gp, tg_pt_gp_new);
 	spin_unlock(&lun->lun_tg_pt_gp_lock);
-	target_debug("Target_Core_ConfigFS: %s %s/tpgt_%hu/%s to ALUA"
-		     " Target Port Group: alua/%s, ID: %hu\n",
+	target_debug("Target_Core_ConfigFS: %s %s/tpgt_%hu/%s to ALUA Target Port Group: alua/%s, ID: %hu\n",
 		     (move) ? "Moving" : "Adding", tpg->se_tpg_tfo->tpg_get_wwn(tpg),
 		     tpg->se_tpg_tfo->tpg_get_tag(tpg), config_item_name(&lun->lun_group.cg_item),
 		     config_item_name(&tg_pt_gp_new->tg_pt_gp_group.cg_item),
@@ -2004,9 +1983,7 @@ ssize_t core_alua_store_access_type(
 		return ret;
 	}
 	if ((tmp != 0) && (tmp != 1) && (tmp != 2) && (tmp != 3)) {
-		target_err("Illegal value for alua_access_type:"
-			   " %lu\n",
-			   tmp);
+		target_err("Illegal value for alua_access_type: %lu\n", tmp);
 		return -EINVAL;
 	}
 	if (tmp == 3)
@@ -2043,8 +2020,7 @@ ssize_t core_alua_store_nonop_delay_msecs(
 		return ret;
 	}
 	if (tmp > ALUA_MAX_NONOP_DELAY_MSECS) {
-		target_err("Passed nonop_delay_msecs: %lu, exceeds"
-			   " ALUA_MAX_NONOP_DELAY_MSECS: %d\n",
+		target_err("Passed nonop_delay_msecs: %lu, exceeds ALUA_MAX_NONOP_DELAY_MSECS: %d\n",
 			   tmp, ALUA_MAX_NONOP_DELAY_MSECS);
 		return -EINVAL;
 	}
@@ -2074,8 +2050,7 @@ ssize_t core_alua_store_trans_delay_msecs(
 		return ret;
 	}
 	if (tmp > ALUA_MAX_TRANS_DELAY_MSECS) {
-		target_err("Passed trans_delay_msecs: %lu, exceeds"
-			   " ALUA_MAX_TRANS_DELAY_MSECS: %d\n",
+		target_err("Passed trans_delay_msecs: %lu, exceeds ALUA_MAX_TRANS_DELAY_MSECS: %d\n",
 			   tmp, ALUA_MAX_TRANS_DELAY_MSECS);
 		return -EINVAL;
 	}
@@ -2105,8 +2080,7 @@ ssize_t core_alua_store_implicit_trans_secs(
 		return ret;
 	}
 	if (tmp > ALUA_MAX_IMPLICIT_TRANS_SECS) {
-		target_err("Passed implicit_trans_secs: %lu, exceeds"
-			   " ALUA_MAX_IMPLICIT_TRANS_SECS: %d\n",
+		target_err("Passed implicit_trans_secs: %lu, exceeds ALUA_MAX_IMPLICIT_TRANS_SECS: %d\n",
 			   tmp, ALUA_MAX_IMPLICIT_TRANS_SECS);
 		return  -EINVAL;
 	}
@@ -2236,9 +2210,7 @@ ssize_t core_alua_store_secondary_write_metadata(
 		return ret;
 	}
 	if ((tmp != 0) && (tmp != 1)) {
-		target_err("Illegal value for alua_tg_pt_write_md:"
-			   " %lu\n",
-			   tmp);
+		target_err("Illegal value for alua_tg_pt_write_md: %lu\n", tmp);
 		return -EINVAL;
 	}
 	lun->lun_tg_pt_secondary_write_md = (int)tmp;
@@ -2266,8 +2238,7 @@ int core_setup_alua(struct se_device *dev)
 				default_lu_gp);
 		spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
 
-		target_debug("%s: Adding to default ALUA LU Group:"
-			     " core/alua/lu_gps/default_lu_gp\n",
+		target_debug("%s: Adding to default ALUA LU Group: core/alua/lu_gps/default_lu_gp\n",
 			     dev->transport->name);
 	}
 
diff --git a/drivers/target/target_core_configfs.c b/drivers/target/target_core_configfs.c
index 081521f8eb1a..433afdc20dc1 100644
--- a/drivers/target/target_core_configfs.c
+++ b/drivers/target/target_core_configfs.c
@@ -189,9 +189,7 @@ static struct config_group *target_core_register_fabric(
 	struct target_fabric_configfs *tf;
 	int ret;
 
-	target_debug("Target_Core_ConfigFS: REGISTER -> group: %p name:"
-		     " %s\n",
-		     group, name);
+	target_debug("Target_Core_ConfigFS: REGISTER -> group: %p name: %s\n", group, name);
 
 	tf = target_core_get_fabric(name);
 	if (!tf) {
@@ -217,8 +215,7 @@ static struct config_group *target_core_register_fabric(
 			 */
 			ret = request_module("iscsi_target_mod");
 			if (ret < 0) {
-				target_debug("request_module() failed for"
-					     " iscsi_target_mod.ko: %d\n",
+				target_debug("request_module() failed for iscsi_target_mod.ko: %d\n",
 					     ret);
 				return ERR_PTR(-EINVAL);
 			}
@@ -231,9 +228,7 @@ static struct config_group *target_core_register_fabric(
 			 */
 			ret = request_module("tcm_loop");
 			if (ret < 0) {
-				target_debug("request_module() failed for"
-					     " tcm_loop.ko: %d\n",
-					     ret);
+				target_debug("request_module() failed for tcm_loop.ko: %d\n", ret);
 				return ERR_PTR(-EINVAL);
 			}
 		}
@@ -245,8 +240,7 @@ static struct config_group *target_core_register_fabric(
 		target_debug("target_core_get_fabric() failed for %s\n", name);
 		return ERR_PTR(-EINVAL);
 	}
-	target_debug("Target_Core_ConfigFS: REGISTER -> Located fabric:"
-		     " %s\n",
+	target_debug("Target_Core_ConfigFS: REGISTER -> Located fabric: %s\n",
 		     tf->tf_ops->fabric_name);
 	/*
 	 * On a successful target_core_get_fabric() look, the returned
@@ -275,17 +269,14 @@ static void target_core_deregister_fabric(
 	struct target_fabric_configfs *tf = container_of(
 		to_config_group(item), struct target_fabric_configfs, tf_group);
 
-	target_debug("Target_Core_ConfigFS: DEREGISTER -> Looking up %s in"
-		     " tf list\n",
+	target_debug("Target_Core_ConfigFS: DEREGISTER -> Looking up %s in tf list\n",
 		     config_item_name(item));
 
-	target_debug("Target_Core_ConfigFS: DEREGISTER -> located fabric:"
-		     " %s\n",
+	target_debug("Target_Core_ConfigFS: DEREGISTER -> located fabric: %s\n",
 		     tf->tf_ops->fabric_name);
 	atomic_dec(&tf->tf_access_cnt);
 
-	target_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing ci"
-		     " %s\n",
+	target_debug("Target_Core_ConfigFS: DEREGISTER -> Releasing ci %s\n",
 		     config_item_name(item));
 
 	configfs_remove_default_groups(&tf->tf_group);
@@ -367,8 +358,7 @@ static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo)
 {
 	if (tfo->fabric_alias) {
 		if (strlen(tfo->fabric_alias) >= TARGET_FABRIC_NAME_SIZE) {
-			target_err("Passed alias: %s exceeds "
-				   "TARGET_FABRIC_NAME_SIZE\n",
+			target_err("Passed alias: %s exceeds TARGET_FABRIC_NAME_SIZE\n",
 				   tfo->fabric_alias);
 			return -EINVAL;
 		}
@@ -378,9 +368,7 @@ static int target_fabric_tf_ops_check(const struct target_core_fabric_ops *tfo)
 		return -EINVAL;
 	}
 	if (strlen(tfo->fabric_name) >= TARGET_FABRIC_NAME_SIZE) {
-		target_err("Passed name: %s exceeds "
-			   "TARGET_FABRIC_NAME_SIZE\n",
-			   tfo->fabric_name);
+		target_err("Passed name: %s exceeds TARGET_FABRIC_NAME_SIZE\n", tfo->fabric_name);
 		return -EINVAL;
 	}
 	if (!tfo->tpg_get_wwn) {
@@ -647,8 +635,7 @@ static void dev_set_t10_wwn_model_alias(struct se_device *dev)
 
 	configname = config_item_name(&dev->dev_group.cg_item);
 	if (strlen(configname) >= INQUIRY_MODEL_LEN) {
-		target_warn("dev[%p]: Backstore name '%s' is too long for "
-			    "INQUIRY_MODEL, truncating to 15 characters\n",
+		target_warn("dev[%p]: Backstore name '%s' is too long for INQUIRY_MODEL, truncating to 15 characters\n",
 			    dev, configname);
 	}
 	/*
@@ -668,9 +655,8 @@ static ssize_t emulate_model_alias_store(struct config_item *item,
 	int ret;
 
 	if (dev->export_count) {
-		target_err("dev[%p]: Unable to change model alias"
-			   " while export_count is %d\n",
-			   dev, dev->export_count);
+		target_err("dev[%p]: Unable to change model alias while export_count is %d\n", dev,
+			   dev->export_count);
 		return -EINVAL;
 	}
 
@@ -729,8 +715,7 @@ static ssize_t emulate_ua_intlck_ctrl_store(struct config_item *item,
 	}
 
 	if (da->da_dev->export_count) {
-		target_err("dev[%p]: Unable to change SE Device"
-			   " UA_INTRLCK_CTRL while export_count is %d\n",
+		target_err("dev[%p]: Unable to change SE Device UA_INTRLCK_CTRL while export_count is %d\n",
 			   da->da_dev, da->da_dev->export_count);
 		return -EINVAL;
 	}
@@ -751,8 +736,7 @@ static ssize_t emulate_tas_store(struct config_item *item,
 		return ret;
 
 	if (da->da_dev->export_count) {
-		target_err("dev[%p]: Unable to change SE Device TAS while"
-			   " export_count is %d\n",
+		target_err("dev[%p]: Unable to change SE Device TAS while export_count is %d\n",
 			   da->da_dev, da->da_dev->export_count);
 		return -EINVAL;
 	}
@@ -860,8 +844,7 @@ static ssize_t pi_prot_type_store(struct config_item *item,
 		return -ENOSYS;
 	}
 	if (da->hw_pi_prot_type) {
-		target_warn("DIF protection enabled on underlying hardware,"
-			    " ignoring\n");
+		target_warn("DIF protection enabled on underlying hardware, ignoring\n");
 		return count;
 	}
 	if (!dev->transport->init_prot || !dev->transport->free_prot) {
@@ -877,8 +860,7 @@ static ssize_t pi_prot_type_store(struct config_item *item,
 		return -ENODEV;
 	}
 	if (dev->export_count) {
-		target_err("dev[%p]: Unable to change SE Device PROT type while"
-			   " export_count is %d\n",
+		target_err("dev[%p]: Unable to change SE Device PROT type while export_count is %d\n",
 			   dev, dev->export_count);
 		return -EINVAL;
 	}
@@ -933,8 +915,7 @@ static ssize_t pi_prot_format_store(struct config_item *item,
 		return -ENODEV;
 	}
 	if (dev->export_count) {
-		target_err("dev[%p]: Unable to format SE Device PROT type while"
-			   " export_count is %d\n",
+		target_err("dev[%p]: Unable to format SE Device PROT type while export_count is %d\n",
 			   dev, dev->export_count);
 		return -EINVAL;
 	}
@@ -963,8 +944,7 @@ static ssize_t pi_prot_verify_store(struct config_item *item,
 		return count;
 	}
 	if (da->hw_pi_prot_type) {
-		target_warn("DIF protection enabled on underlying hardware,"
-			    " ignoring\n");
+		target_warn("DIF protection enabled on underlying hardware, ignoring\n");
 		return count;
 	}
 	if (!da->pi_prot_type) {
@@ -987,8 +967,7 @@ static ssize_t force_pr_aptpl_store(struct config_item *item,
 	if (ret < 0)
 		return ret;
 	if (da->da_dev->export_count) {
-		target_err("dev[%p]: Unable to set force_pr_aptpl while"
-			   " export_count is %d\n",
+		target_err("dev[%p]: Unable to set force_pr_aptpl while export_count is %d\n",
 			   da->da_dev, da->da_dev->export_count);
 		return -EINVAL;
 	}
@@ -1010,8 +989,7 @@ static ssize_t emulate_rest_reord_store(struct config_item *item,
 		return ret;
 
 	if (flag != 0) {
-		target_err("dev[%p]: SE Device emulation of restricted"
-			   " reordering not implemented\n",
+		target_err("dev[%p]: SE Device emulation of restricted reordering not implemented\n",
 			   da->da_dev);
 		return -ENOSYS;
 	}
@@ -1033,8 +1011,7 @@ static ssize_t unmap_zeroes_data_store(struct config_item *item,
 		return ret;
 
 	if (da->da_dev->export_count) {
-		target_err("dev[%p]: Unable to change SE Device"
-			   " unmap_zeroes_data while export_count is %d\n",
+		target_err("dev[%p]: Unable to change SE Device unmap_zeroes_data while export_count is %d\n",
 			   da->da_dev, da->da_dev->export_count);
 		return -EINVAL;
 	}
@@ -1068,8 +1045,7 @@ static ssize_t queue_depth_store(struct config_item *item,
 		return ret;
 
 	if (dev->export_count) {
-		target_err("dev[%p]: Unable to change SE Device TCQ while"
-			   " export_count is %d\n",
+		target_err("dev[%p]: Unable to change SE Device TCQ while export_count is %d\n",
 			   dev, dev->export_count);
 		return -EINVAL;
 	}
@@ -1080,9 +1056,7 @@ static ssize_t queue_depth_store(struct config_item *item,
 
 	if (val > dev->dev_attrib.queue_depth) {
 		if (val > dev->dev_attrib.hw_queue_depth) {
-			target_err("dev[%p]: Passed queue_depth:"
-				   " %u exceeds TCM/SE_Device MAX"
-				   " TCQ: %u\n",
+			target_err("dev[%p]: Passed queue_depth: %u exceeds TCM/SE_Device MAX TCQ: %u\n",
 				   dev, val, dev->dev_attrib.hw_queue_depth);
 			return -EINVAL;
 		}
@@ -1104,14 +1078,12 @@ static ssize_t optimal_sectors_store(struct config_item *item,
 		return ret;
 
 	if (da->da_dev->export_count) {
-		target_err("dev[%p]: Unable to change SE Device"
-			   " optimal_sectors while export_count is %d\n",
+		target_err("dev[%p]: Unable to change SE Device optimal_sectors while export_count is %d\n",
 			   da->da_dev, da->da_dev->export_count);
 		return -EINVAL;
 	}
 	if (val > da->hw_max_sectors) {
-		target_err("dev[%p]: Passed optimal_sectors %u cannot be"
-			   " greater than hw_max_sectors: %u\n",
+		target_err("dev[%p]: Passed optimal_sectors %u cannot be greater than hw_max_sectors: %u\n",
 			   da->da_dev, val, da->hw_max_sectors);
 		return -EINVAL;
 	}
@@ -1133,15 +1105,13 @@ static ssize_t block_size_store(struct config_item *item,
 		return ret;
 
 	if (da->da_dev->export_count) {
-		target_err("dev[%p]: Unable to change SE Device block_size"
-			   " while export_count is %d\n",
+		target_err("dev[%p]: Unable to change SE Device block_size while export_count is %d\n",
 			   da->da_dev, da->da_dev->export_count);
 		return -EINVAL;
 	}
 
 	if (val != 512 && val != 1024 && val != 2048 && val != 4096) {
-		target_err("dev[%p]: Illegal value for block_device: %u"
-			   " for SE device, must be 512, 1024, 2048 or 4096\n",
+		target_err("dev[%p]: Illegal value for block_device: %u for SE device, must be 512, 1024, 2048 or 4096\n",
 			   da->da_dev, val);
 		return -EINVAL;
 	}
@@ -1179,8 +1149,7 @@ static ssize_t alua_support_store(struct config_item *item,
 
 	if (!(dev->transport->transport_flags_changeable &
 	      TRANSPORT_FLAG_PASSTHROUGH_ALUA)) {
-		target_err("dev[%p]: Unable to change SE Device alua_support:"
-			   " alua_support has fixed value\n",
+		target_err("dev[%p]: Unable to change SE Device alua_support: alua_support has fixed value\n",
 			   dev);
 		return -ENOSYS;
 	}
@@ -1219,8 +1188,7 @@ static ssize_t pgr_support_store(struct config_item *item,
 
 	if (!(dev->transport->transport_flags_changeable &
 	      TRANSPORT_FLAG_PASSTHROUGH_PGR)) {
-		target_err("dev[%p]: Unable to change SE Device pgr_support:"
-			   " pgr_support has fixed value\n",
+		target_err("dev[%p]: Unable to change SE Device pgr_support: pgr_support has fixed value\n",
 			   dev);
 		return -ENOSYS;
 	}
@@ -1441,8 +1409,8 @@ static ssize_t target_wwn_vendor_id_store(struct config_item *item,
 		len = strlen(stripped);
 	}
 	if (len < 0 || len > INQUIRY_VENDOR_LEN) {
-		target_err("Emulated T10 Vendor Identification exceeds"
-			   " INQUIRY_VENDOR_LEN: " __stringify(INQUIRY_VENDOR_LEN) "\n");
+		target_err("Emulated T10 Vendor Identification exceeds INQUIRY_VENDOR_LEN: "
+			   __stringify(INQUIRY_VENDOR_LEN) "\n");
 		return -EOVERFLOW;
 	}
 
@@ -1458,8 +1426,7 @@ static ssize_t target_wwn_vendor_id_store(struct config_item *item,
 	 * effects.
 	 */
 	if (dev->export_count) {
-		target_err("Unable to set T10 Vendor Identification while"
-			   " active %d exports exist\n",
+		target_err("Unable to set T10 Vendor Identification while active %d exports exist\n",
 			   dev->export_count);
 		return -EINVAL;
 	}
@@ -1467,8 +1434,7 @@ static ssize_t target_wwn_vendor_id_store(struct config_item *item,
 	BUILD_BUG_ON(sizeof(dev->t10_wwn.vendor) != INQUIRY_VENDOR_LEN + 1);
 	strscpy(dev->t10_wwn.vendor, stripped, sizeof(dev->t10_wwn.vendor));
 
-	target_debug("Target_Core_ConfigFS: Set emulated T10 Vendor Identification:"
-		     " %s\n",
+	target_debug("Target_Core_ConfigFS: Set emulated T10 Vendor Identification: %s\n",
 		     dev->t10_wwn.vendor);
 
 	return count;
@@ -1658,14 +1624,12 @@ static ssize_t target_wwn_vpd_unit_serial_store(struct config_item *item,
 	 * VPD Unit Serial Number that OS dependent multipath can depend on.
 	 */
 	if (dev->dev_flags & DF_FIRMWARE_VPD_UNIT_SERIAL) {
-		target_err("Underlying SCSI device firmware provided VPD"
-			   " Unit Serial, ignoring request\n");
+		target_err("Underlying SCSI device firmware provided VPD Unit Serial, ignoring request\n");
 		return -EOPNOTSUPP;
 	}
 
 	if (strlen(page) >= INQUIRY_VPD_SERIAL_LEN) {
-		target_err("Emulated VPD Unit Serial exceeds"
-			   " INQUIRY_VPD_SERIAL_LEN: %d\n",
+		target_err("Emulated VPD Unit Serial exceeds INQUIRY_VPD_SERIAL_LEN: %d\n",
 			   INQUIRY_VPD_SERIAL_LEN);
 		return -EOVERFLOW;
 	}
@@ -1676,8 +1640,7 @@ static ssize_t target_wwn_vpd_unit_serial_store(struct config_item *item,
 	 * could cause negative effects.
 	 */
 	if (dev->export_count) {
-		target_err("Unable to set VPD Unit Serial while"
-			   " active %d $FABRIC_MOD exports exist\n",
+		target_err("Unable to set VPD Unit Serial while active %d $FABRIC_MOD exports exist\n",
 			   dev->export_count);
 		return -EINVAL;
 	}
@@ -1693,8 +1656,7 @@ static ssize_t target_wwn_vpd_unit_serial_store(struct config_item *item,
 			"%s", strstrip(buf));
 	dev->dev_flags |= DF_EMULATED_VPD_UNIT_SERIAL;
 
-	target_debug("Target_Core_ConfigFS: Set emulated VPD Unit Serial:"
-		     " %s\n",
+	target_debug("Target_Core_ConfigFS: Set emulated VPD Unit Serial: %s\n",
 		     dev->t10_wwn.unit_serial);
 
 	return count;
@@ -2078,8 +2040,7 @@ static ssize_t target_pr_res_aptpl_metadata_store(struct config_item *item,
 		return count;
 
 	if (dev->export_count) {
-		target_debug("Unable to process APTPL metadata while"
-			     " active fabric exports exist\n");
+		target_debug("Unable to process APTPL metadata while active fabric exports exist\n");
 		return -EINVAL;
 	}
 
@@ -2108,8 +2069,7 @@ static ssize_t target_pr_res_aptpl_metadata_store(struct config_item *item,
 				goto out;
 			}
 			if (strlen(i_port) >= PR_APTPL_MAX_IPORT_LEN) {
-				target_err("APTPL metadata initiator_node="
-					   " exceeds PR_APTPL_MAX_IPORT_LEN: %d\n",
+				target_err("APTPL metadata initiator_node= exceeds PR_APTPL_MAX_IPORT_LEN: %d\n",
 					   PR_APTPL_MAX_IPORT_LEN);
 				ret = -EINVAL;
 				break;
@@ -2122,8 +2082,7 @@ static ssize_t target_pr_res_aptpl_metadata_store(struct config_item *item,
 				goto out;
 			}
 			if (strlen(isid) >= PR_REG_ISID_LEN) {
-				target_err("APTPL metadata initiator_isid"
-					   "= exceeds PR_REG_ISID_LEN: %d\n",
+				target_err("APTPL metadata initiator_isid= exceeds PR_REG_ISID_LEN: %d\n",
 					   PR_REG_ISID_LEN);
 				ret = -EINVAL;
 				break;
@@ -2186,8 +2145,7 @@ static ssize_t target_pr_res_aptpl_metadata_store(struct config_item *item,
 				goto out;
 			}
 			if (strlen(t_port) >= PR_APTPL_MAX_TPORT_LEN) {
-				target_err("APTPL metadata target_node="
-					   " exceeds PR_APTPL_MAX_TPORT_LEN: %d\n",
+				target_err("APTPL metadata target_node= exceeds PR_APTPL_MAX_TPORT_LEN: %d\n",
 					   PR_APTPL_MAX_TPORT_LEN);
 				ret = -EINVAL;
 				break;
@@ -2222,9 +2180,7 @@ static ssize_t target_pr_res_aptpl_metadata_store(struct config_item *item,
 	}
 
 	if (res_holder && !(type)) {
-		target_err("Illegal PR type: 0x%02x for reservation"
-			   " holder\n",
-			   type);
+		target_err("Illegal PR type: 0x%02x for reservation holder\n", type);
 		ret = -EINVAL;
 		goto out;
 	}
@@ -2316,9 +2272,8 @@ static ssize_t target_dev_alias_store(struct config_item *item,
 	ssize_t read_bytes;
 
 	if (count > (SE_DEV_ALIAS_LEN-1)) {
-		target_err("alias count: %d exceeds"
-			   " SE_DEV_ALIAS_LEN-1: %u\n",
-			   (int)count, SE_DEV_ALIAS_LEN - 1);
+		target_err("alias count: %d exceeds SE_DEV_ALIAS_LEN-1: %u\n", (int)count,
+			   SE_DEV_ALIAS_LEN - 1);
 		return -EINVAL;
 	}
 
@@ -2355,9 +2310,8 @@ static ssize_t target_dev_udev_path_store(struct config_item *item,
 	ssize_t read_bytes;
 
 	if (count > (SE_UDEV_PATH_LEN-1)) {
-		target_err("udev_path count: %d exceeds"
-			   " SE_UDEV_PATH_LEN-1: %u\n",
-			   (int)count, SE_UDEV_PATH_LEN - 1);
+		target_err("udev_path count: %d exceeds SE_UDEV_PATH_LEN-1: %u\n", (int)count,
+			   SE_UDEV_PATH_LEN - 1);
 		return -EINVAL;
 	}
 
@@ -2393,8 +2347,7 @@ static ssize_t target_dev_enable_store(struct config_item *item,
 
 	ptr = strstr(page, "1");
 	if (!ptr) {
-		target_err("For dev_enable ops, only valid value"
-			   " is \"1\"\n");
+		target_err("For dev_enable ops, only valid value is \"1\"\n");
 		return -EINVAL;
 	}
 
@@ -2470,9 +2423,7 @@ static ssize_t target_dev_alua_lu_gp_store(struct config_item *item,
 		 * with NULL
 		 */
 		if (!lu_gp_new) {
-			target_debug("Target_Core_ConfigFS: Releasing %s/%s"
-				     " from ALUA LU Group: core/alua/lu_gps/%s, ID:"
-				     " %hu\n",
+			target_debug("Target_Core_ConfigFS: Releasing %s/%s from ALUA LU Group: core/alua/lu_gps/%s, ID: %hu\n",
 				     config_item_name(&hba->hba_group.cg_item),
 				     config_item_name(&dev->dev_group.cg_item),
 				     config_item_name(&lu_gp->lu_gp_group.cg_item),
@@ -2495,8 +2446,7 @@ static ssize_t target_dev_alua_lu_gp_store(struct config_item *item,
 	__core_alua_attach_lu_gp_mem(lu_gp_mem, lu_gp_new);
 	spin_unlock(&lu_gp_mem->lu_gp_mem_lock);
 
-	target_debug("Target_Core_ConfigFS: %s %s/%s to ALUA LU Group:"
-		     " core/alua/lu_gps/%s, ID: %hu\n",
+	target_debug("Target_Core_ConfigFS: %s %s/%s to ALUA LU Group: core/alua/lu_gps/%s, ID: %hu\n",
 		     (move) ? "Moving" : "Adding", config_item_name(&hba->hba_group.cg_item),
 		     config_item_name(&dev->dev_group.cg_item),
 		     config_item_name(&lu_gp_new->lu_gp_group.cg_item), lu_gp_new->lu_gp_id);
@@ -2631,9 +2581,8 @@ static ssize_t target_dev_lba_map_store(struct config_item *item,
 			ret = core_alua_allocate_lba_map_mem(lba_map,
 							     pg_id, alua_state);
 			if (ret) {
-				target_err("Invalid target descriptor %d:%c "
-					   "at line %d\n",
-					   pg_id, state, num);
+				target_err("Invalid target descriptor %d:%c at line %d\n", pg_id,
+					   state, num);
 				break;
 			}
 			pg++;
@@ -2646,8 +2595,8 @@ static ssize_t target_dev_lba_map_store(struct config_item *item,
 		if (pg_num == -1)
 		    pg_num = pg;
 		else if (pg != pg_num) {
-			target_err("Only %d from %d port groups definitions "
-				   "at line %d\n", pg, pg_num, num);
+			target_err("Only %d from %d port groups definitions at line %d\n", pg,
+				   pg_num, num);
 			ret = -EINVAL;
 			break;
 		}
@@ -2731,15 +2680,11 @@ static ssize_t target_lu_gp_lu_gp_id_store(struct config_item *item,
 
 	ret = kstrtoul(page, 0, &lu_gp_id);
 	if (ret < 0) {
-		target_err("kstrtoul() returned %d for"
-			   " lu_gp_id\n",
-			   ret);
+		target_err("kstrtoul() returned %d for lu_gp_id\n", ret);
 		return ret;
 	}
 	if (lu_gp_id > 0x0000ffff) {
-		target_err("ALUA lu_gp_id: %lu exceeds maximum:"
-			   " 0x0000ffff\n",
-			   lu_gp_id);
+		target_err("ALUA lu_gp_id: %lu exceeds maximum: 0x0000ffff\n", lu_gp_id);
 		return -EINVAL;
 	}
 
@@ -2747,8 +2692,7 @@ static ssize_t target_lu_gp_lu_gp_id_store(struct config_item *item,
 	if (ret < 0)
 		return -EINVAL;
 
-	target_debug("Target_Core_ConfigFS: Set ALUA Logical Unit"
-		     " Group: core/alua/lu_gps/%s to ID: %hu\n",
+	target_debug("Target_Core_ConfigFS: Set ALUA Logical Unit Group: core/alua/lu_gps/%s to ID: %hu\n",
 		     config_item_name(&alua_lu_gp_cg->cg_item), lu_gp->lu_gp_id);
 
 	return count;
@@ -2774,8 +2718,7 @@ static ssize_t target_lu_gp_members_show(struct config_item *item, char *page)
 		cur_len++; /* Extra byte for NULL terminator */
 
 		if ((cur_len + len) > PAGE_SIZE) {
-			target_warn("Ran out of lu_gp_show_attr"
-				    "_members buffer\n");
+			target_warn("Ran out of lu_gp_show_attr_members buffer\n");
 			break;
 		}
 		memcpy(page+len, buf, cur_len);
@@ -2835,8 +2778,7 @@ static struct config_group *target_core_alua_create_lu_gp(
 	config_group_init_type_name(alua_lu_gp_cg, name,
 			&target_core_alua_lu_gp_cit);
 
-	target_debug("Target_Core_ConfigFS: Allocated ALUA Logical Unit"
-		     " Group: core/alua/lu_gps/%s\n",
+	target_debug("Target_Core_ConfigFS: Allocated ALUA Logical Unit Group: core/alua/lu_gps/%s\n",
 		     config_item_name(alua_lu_gp_ci));
 
 	return alua_lu_gp_cg;
@@ -2850,8 +2792,7 @@ static void target_core_alua_drop_lu_gp(
 	struct t10_alua_lu_gp *lu_gp = container_of(to_config_group(item),
 			struct t10_alua_lu_gp, lu_gp_group);
 
-	target_debug("Target_Core_ConfigFS: Releasing ALUA Logical Unit"
-		     " Group: core/alua/lu_gps/%s, ID: %hu\n",
+	target_debug("Target_Core_ConfigFS: Releasing ALUA Logical Unit Group: core/alua/lu_gps/%s, ID: %hu\n",
 		     config_item_name(item), lu_gp->lu_gp_id);
 	/*
 	 * core_alua_free_lu_gp() is called from target_core_alua_lu_gp_ops->release()
@@ -2901,30 +2842,25 @@ static ssize_t target_tg_pt_gp_alua_access_state_store(struct config_item *item,
 		return -EINVAL;
 	}
 	if (!target_dev_configured(dev)) {
-		target_err("Unable to set alua_access_state while device is"
-			   " not configured\n");
+		target_err("Unable to set alua_access_state while device is not configured\n");
 		return -ENODEV;
 	}
 
 	ret = kstrtoul(page, 0, &tmp);
 	if (ret < 0) {
-		target_err("Unable to extract new ALUA access state from"
-			   " %s\n",
-			   page);
+		target_err("Unable to extract new ALUA access state from %s\n", page);
 		return ret;
 	}
 	new_state = (int)tmp;
 
 	if (!(tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_IMPLICIT_ALUA)) {
-		target_err("Unable to process implicit configfs ALUA"
-			   " transition while TPGS_IMPLICIT_ALUA is disabled\n");
+		target_err("Unable to process implicit configfs ALUA transition while TPGS_IMPLICIT_ALUA is disabled\n");
 		return -EINVAL;
 	}
 	if (tg_pt_gp->tg_pt_gp_alua_access_type & TPGS_EXPLICIT_ALUA &&
 	    new_state == ALUA_ACCESS_STATE_LBA_DEPENDENT) {
 		/* LBA DEPENDENT is only allowed with implicit ALUA */
-		target_err("Unable to process implicit configfs ALUA transition"
-			   " while explicit ALUA management is enabled\n");
+		target_err("Unable to process implicit configfs ALUA transition while explicit ALUA management is enabled\n");
 		return -EINVAL;
 	}
 
@@ -2955,9 +2891,7 @@ static ssize_t target_tg_pt_gp_alua_access_status_store(
 
 	ret = kstrtoul(page, 0, &tmp);
 	if (ret < 0) {
-		target_err("Unable to extract new ALUA access status"
-			   " from %s\n",
-			   page);
+		target_err("Unable to extract new ALUA access status from %s\n", page);
 		return ret;
 	}
 	new_status = (int)tmp;
@@ -3052,9 +2986,7 @@ static ssize_t target_tg_pt_gp_alua_write_metadata_store(
 	}
 
 	if ((tmp != 0) && (tmp != 1)) {
-		target_err("Illegal value for alua_write_metadata:"
-			   " %lu\n",
-			   tmp);
+		target_err("Illegal value for alua_write_metadata: %lu\n", tmp);
 		return -EINVAL;
 	}
 	tg_pt_gp->tg_pt_gp_write_metadata = (int)tmp;
@@ -3145,8 +3077,7 @@ static ssize_t target_tg_pt_gp_tg_pt_gp_id_store(struct config_item *item,
 	if (ret < 0)
 		return -EINVAL;
 
-	target_debug("Target_Core_ConfigFS: Set ALUA Target Port Group: "
-		     "core/alua/tg_pt_gps/%s to ID: %hu\n",
+	target_debug("Target_Core_ConfigFS: Set ALUA Target Port Group: core/alua/tg_pt_gps/%s to ID: %hu\n",
 		     config_item_name(&alua_tg_pt_gp_cg->cg_item), tg_pt_gp->tg_pt_gp_id);
 
 	return count;
@@ -3173,8 +3104,7 @@ static ssize_t target_tg_pt_gp_members_show(struct config_item *item,
 		cur_len++; /* Extra byte for NULL terminator */
 
 		if ((cur_len + len) > PAGE_SIZE) {
-			target_warn("Ran out of lu_gp_show_attr"
-				    "_members buffer\n");
+			target_warn("Ran out of lu_gp_show_attr_members buffer\n");
 			break;
 		}
 		memcpy(page+len, buf, cur_len);
@@ -3266,8 +3196,7 @@ static struct config_group *target_core_alua_create_tg_pt_gp(
 	config_group_init_type_name(alua_tg_pt_gp_cg, name,
 			&target_core_alua_tg_pt_gp_cit);
 
-	target_debug("Target_Core_ConfigFS: Allocated ALUA Target Port"
-		     " Group: alua/tg_pt_gps/%s\n",
+	target_debug("Target_Core_ConfigFS: Allocated ALUA Target Port Group: alua/tg_pt_gps/%s\n",
 		     config_item_name(alua_tg_pt_gp_ci));
 
 	return alua_tg_pt_gp_cg;
@@ -3280,8 +3209,7 @@ static void target_core_alua_drop_tg_pt_gp(
 	struct t10_alua_tg_pt_gp *tg_pt_gp = container_of(to_config_group(item),
 			struct t10_alua_tg_pt_gp, tg_pt_gp_group);
 
-	target_debug("Target_Core_ConfigFS: Releasing ALUA Target Port"
-		     " Group: alua/tg_pt_gps/%s, ID: %hu\n",
+	target_debug("Target_Core_ConfigFS: Releasing ALUA Target Port Group: alua/tg_pt_gps/%s, ID: %hu\n",
 		     config_item_name(item), tg_pt_gp->tg_pt_gp_id);
 	/*
 	 * core_alua_free_tg_pt_gp() is called from target_core_alua_tg_pt_gp_ops->release()
@@ -3559,8 +3487,7 @@ static struct config_group *target_core_call_addhbatotarget(
 	int ret;
 
 	if (strlen(name) >= TARGET_CORE_NAME_MAX_LEN) {
-		target_err("Passed *name strlen(): %d exceeds"
-			   " TARGET_CORE_NAME_MAX_LEN: %d\n",
+		target_err("Passed *name strlen(): %d exceeds TARGET_CORE_NAME_MAX_LEN: %d\n",
 			   (int)strlen(name), TARGET_CORE_NAME_MAX_LEN);
 		return ERR_PTR(-ENAMETOOLONG);
 	}
@@ -3588,9 +3515,7 @@ static struct config_group *target_core_call_addhbatotarget(
 
 	ret = kstrtoul(str, 0, &plugin_dep_id);
 	if (ret < 0) {
-		target_err("kstrtoul() returned %d for"
-			   " plugin_dep_id\n",
-			   ret);
+		target_err("kstrtoul() returned %d for plugin_dep_id\n", ret);
 		return ERR_PTR(ret);
 	}
 	/*
@@ -3673,9 +3598,8 @@ static int __init target_core_init_configfs(void)
 	const struct cred *old_cred;
 	int ret;
 
-	target_debug("TARGET_CORE[0]: Loading Generic Kernel Storage"
-		     " Engine: %s on %s/%s on " UTS_RELEASE "\n",
-		     TARGET_CORE_VERSION, utsname()->sysname, utsname()->machine);
+	target_debug("TARGET_CORE[0]: Loading Generic Kernel Storage Engine: %s on %s/%s on "
+		     UTS_RELEASE "\n", TARGET_CORE_VERSION, utsname()->sysname, utsname()->machine);
 
 	config_group_init(&subsys->su_group);
 	mutex_init(&subsys->su_mutex);
@@ -3729,9 +3653,8 @@ static int __init target_core_init_configfs(void)
 			   subsys->su_group.cg_item.ci_namebuf);
 		goto out_global;
 	}
-	target_debug("TARGET_CORE[0]: Initialized ConfigFS Fabric"
-		     " Infrastructure: " TARGET_CORE_VERSION " on %s/%s"
-		     " on " UTS_RELEASE "\n",
+	target_debug("TARGET_CORE[0]: Initialized ConfigFS Fabric Infrastructure: "
+		     TARGET_CORE_VERSION " on %s/%s on " UTS_RELEASE "\n",
 		     utsname()->sysname, utsname()->machine);
 	/*
 	 * Register built-in RAMDISK subsystem logic for virtual LUN 0
@@ -3790,8 +3713,7 @@ static void __exit target_core_exit_configfs(void)
 	core_alua_free_lu_gp(default_lu_gp);
 	default_lu_gp = NULL;
 
-	target_debug("TARGET_CORE[0]: Released ConfigFS Fabric"
-		     " Infrastructure\n");
+	target_debug("TARGET_CORE[0]: Released ConfigFS Fabric Infrastructure\n");
 
 	core_dev_release_virtual_lun0();
 	rd_module_exit();
diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index 7e530bdab04e..0317d77331c8 100644
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -66,8 +66,7 @@ transport_lookup_cmd_lun(struct se_cmd *se_cmd)
 
 		if ((se_cmd->data_direction == DMA_TO_DEVICE) &&
 		    deve->lun_access_ro) {
-			target_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN"
-				   " Access for 0x%08llx\n",
+			target_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN Access for 0x%08llx\n",
 				   se_cmd->se_tfo->fabric_name, se_cmd->orig_fe_lun);
 			rcu_read_unlock();
 			return TCM_WRITE_PROTECTED;
@@ -95,8 +94,7 @@ transport_lookup_cmd_lun(struct se_cmd *se_cmd)
 		 * MappedLUN=0 exists for this Initiator Port.
 		 */
 		if (se_cmd->orig_fe_lun != 0) {
-			target_err("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
-				   " Access for 0x%08llx from %s\n",
+			target_err("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN Access for 0x%08llx from %s\n",
 				   se_cmd->se_tfo->fabric_name, se_cmd->orig_fe_lun,
 				   nacl->initiatorname);
 			return TCM_NON_EXISTENT_LUN;
@@ -164,8 +162,7 @@ int transport_lookup_tmr_lun(struct se_cmd *se_cmd)
 	rcu_read_unlock();
 
 	if (!se_lun) {
-		target_debug("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
-			     " Access for 0x%08llx for %s\n",
+		target_debug("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN Access for 0x%08llx for %s\n",
 			     se_cmd->se_tfo->fabric_name, se_cmd->orig_fe_lun, nacl->initiatorname);
 		return -ENODEV;
 	}
@@ -208,8 +205,7 @@ struct se_dev_entry *core_get_se_deve_from_rtpi(
 	hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) {
 		lun = deve->se_lun;
 		if (!lun) {
-			target_err("%s device entries device pointer is"
-				   " NULL, but Initiator has access.\n",
+			target_err("%s device entries device pointer is NULL, but Initiator has access.\n",
 				   tpg->se_tpg_tfo->fabric_name);
 			continue;
 		}
@@ -343,18 +339,14 @@ int core_enable_device_list_for_node(
 		struct se_lun *orig_lun = orig->se_lun;
 
 		if (orig_lun != lun) {
-			target_err("Existing orig->se_lun doesn't match new lun"
-				   " for dynamic -> explicit NodeACL conversion:"
-				   " %s\n",
+			target_err("Existing orig->se_lun doesn't match new lun for dynamic -> explicit NodeACL conversion: %s\n",
 				   nacl->initiatorname);
 			mutex_unlock(&nacl->lun_entry_mutex);
 			kfree(new);
 			return -EINVAL;
 		}
 		if (orig->se_lun_acl != NULL) {
-			target_warn_ratelimited("Detected existing explicit"
-						" se_lun_acl->se_lun_group reference for %s"
-						" mapped_lun: %llu, failing\n",
+			target_warn_ratelimited("Detected existing explicit se_lun_acl->se_lun_group reference for %s mapped_lun: %llu, failing\n",
 						nacl->initiatorname, mapped_lun);
 			mutex_unlock(&nacl->lun_entry_mutex);
 			kfree(new);
@@ -512,8 +504,7 @@ int core_dev_add_lun(
 	if (rc < 0)
 		return rc;
 
-	target_debug("%s_TPG[%u]_LUN[%llu] - Activated %s Logical Unit from"
-		     " CORE HBA: %u\n",
+	target_debug("%s_TPG[%u]_LUN[%llu] - Activated %s Logical Unit from CORE HBA: %u\n",
 		     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
 		     lun->unpacked_lun, tpg->se_tpg_tfo->fabric_name, dev->se_hba->hba_id);
 	/*
@@ -545,8 +536,7 @@ void core_dev_del_lun(
 	struct se_portal_group *tpg,
 	struct se_lun *lun)
 {
-	target_debug("%s_TPG[%u]_LUN[%llu] - Deactivating %s Logical Unit from"
-		     " device object\n",
+	target_debug("%s_TPG[%u]_LUN[%llu] - Deactivating %s Logical Unit from device object\n",
 		     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
 		     lun->unpacked_lun, tpg->se_tpg_tfo->fabric_name);
 
@@ -605,8 +595,7 @@ int core_dev_add_initiator_node_lun_acl(
 			lun_access_ro, nacl, tpg) < 0)
 		return -EINVAL;
 
-	target_debug("%s_TPG[%hu]_LUN[%llu->%llu] - Added %s ACL for "
-		     " InitiatorNode: %s\n",
+	target_debug("%s_TPG[%hu]_LUN[%llu->%llu] - Added %s ACL for  InitiatorNode: %s\n",
 		     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
 		     lun->unpacked_lun, lacl->mapped_lun, lun_access_ro ? "RO" : "RW",
 		     nacl->initiatorname);
@@ -637,8 +626,7 @@ int core_dev_del_initiator_node_lun_acl(
 		core_disable_device_list_for_node(lun, deve, nacl, tpg);
 	mutex_unlock(&nacl->lun_entry_mutex);
 
-	target_debug("%s_TPG[%hu]_LUN[%llu] - Removed ACL for"
-		     " InitiatorNode: %s Mapped LUN: %llu\n",
+	target_debug("%s_TPG[%hu]_LUN[%llu] - Removed ACL for InitiatorNode: %s Mapped LUN: %llu\n",
 		     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
 		     lun->unpacked_lun, nacl->initiatorname, lacl->mapped_lun);
 
@@ -649,8 +637,7 @@ void core_dev_free_initiator_node_lun_acl(
 	struct se_portal_group *tpg,
 	struct se_lun_acl *lacl)
 {
-	target_debug("%s_TPG[%hu] - Freeing ACL for %s InitiatorNode: %s"
-		     " Mapped LUN: %llu\n",
+	target_debug("%s_TPG[%hu] - Freeing ACL for %s InitiatorNode: %s Mapped LUN: %llu\n",
 		     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
 		     tpg->se_tpg_tfo->fabric_name, lacl->se_lun_nacl->initiatorname,
 		     lacl->mapped_lun);
@@ -890,8 +877,7 @@ int target_configure_device(struct se_device *dev)
 	int ret, id;
 
 	if (target_dev_configured(dev)) {
-		target_err("se_dev->se_dev_ptr already set for storage"
-			   " object\n");
+		target_err("se_dev->se_dev_ptr already set for storage object\n");
 		return -EEXIST;
 	}
 
diff --git a/drivers/target/target_core_fabric_configfs.c b/drivers/target/target_core_fabric_configfs.c
index c2a4287361bd..f56baa63a278 100644
--- a/drivers/target/target_core_fabric_configfs.c
+++ b/drivers/target/target_core_fabric_configfs.c
@@ -90,8 +90,7 @@ static int target_fabric_mappedlun_link(
 		return -EINVAL;
 	}
 	if (lun->lun_shutdown) {
-		target_err("Unable to create mappedlun symlink because"
-			   " lun->lun_shutdown=true\n");
+		target_err("Unable to create mappedlun symlink because lun->lun_shutdown=true\n");
 		return -EINVAL;
 	}
 	se_tpg = lun->lun_tpg;
@@ -110,8 +109,7 @@ static int target_fabric_mappedlun_link(
 		return -EINVAL;
 	}
 	if (strcmp(config_item_name(tpg_ci), config_item_name(tpg_ci_s))) {
-		target_err("Illegal Initiator ACL Symlink outside of %s"
-			   " TPGT: %s\n",
+		target_err("Illegal Initiator ACL Symlink outside of %s TPGT: %s\n",
 			   config_item_name(wwn_ci), config_item_name(tpg_ci));
 		return -EINVAL;
 	}
@@ -194,8 +192,7 @@ static ssize_t target_fabric_mappedlun_write_protect_store(
 	/* wp=1 means lun_access_ro=true */
 	core_update_device_list_access(lacl->mapped_lun, wp, lacl->se_lun_nacl);
 
-	target_debug("%s_ConfigFS: Changed Initiator ACL: %s"
-		     " Mapped LUN: %llu Write Protect bit to %s\n",
+	target_debug("%s_ConfigFS: Changed Initiator ACL: %s Mapped LUN: %llu Write Protect bit to %s\n",
 		     se_tpg->se_tpg_tfo->fabric_name, se_nacl->initiatorname, lacl->mapped_lun,
 		     (wp) ? "ON" : "OFF");
 
@@ -285,9 +282,7 @@ static struct config_group *target_fabric_make_mappedlun(
 	 * Make sure user is creating iscsi/$IQN/$TPGT/acls/$INITIATOR/lun_$ID.
 	 */
 	if (strstr(buf, "lun_") != buf) {
-		target_err("Unable to locate \"lun_\" from buf: %s"
-			   " name: %s\n",
-			   buf, name);
+		target_err("Unable to locate \"lun_\" from buf: %s name: %s\n", buf, name);
 		ret = -EINVAL;
 		goto out;
 	}
@@ -750,8 +745,7 @@ static struct config_group *target_fabric_make_lun(
 	int errno;
 
 	if (strstr(name, "lun_") != name) {
-		target_err("Unable to locate \'_\" in"
-			   " \"lun_$LUN_NUMBER\"\n");
+		target_err("Unable to locate \'_\" in \"lun_$LUN_NUMBER\"\n");
 		return ERR_PTR(-EINVAL);
 	}
 	errno = kstrtoull(name + 4, 0, &unpacked_lun);
diff --git a/drivers/target/target_core_fabric_lib.c b/drivers/target/target_core_fabric_lib.c
index 9e619e0028ce..c0fda2769553 100644
--- a/drivers/target/target_core_fabric_lib.c
+++ b/drivers/target/target_core_fabric_lib.c
@@ -280,8 +280,7 @@ static char *iscsi_parse_pr_out_transport_id(
 	 *            Reserved
 	 */
 	if ((format_code != 0x00) && (format_code != 0x40)) {
-		target_err("Illegal format code: 0x%02x for iSCSI"
-			   " Initiator Transport ID\n",
+		target_err("Illegal format code: 0x%02x for iSCSI Initiator Transport ID\n",
 			   format_code);
 		return NULL;
 	}
@@ -304,8 +303,7 @@ static char *iscsi_parse_pr_out_transport_id(
 	if (format_code == 0x40) {
 		p = strstr(&buf[4], ",i,0x");
 		if (!p) {
-			target_err("Unable to locate \",i,0x\" separator"
-				   " for Initiator port identifier: %s\n",
+			target_err("Unable to locate \",i,0x\" separator for Initiator port identifier: %s\n",
 				   &buf[4]);
 			return NULL;
 		}
diff --git a/drivers/target/target_core_file.c b/drivers/target/target_core_file.c
index e1ac26e2f35a..902e68447c24 100644
--- a/drivers/target/target_core_file.c
+++ b/drivers/target/target_core_file.c
@@ -48,8 +48,7 @@ static int fd_attach_hba(struct se_hba *hba, u32 host_id)
 
 	hba->hba_ptr = fd_host;
 
-	target_debug("CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic"
-		     " Target Core Stack %s\n",
+	target_debug("CORE_HBA[%d] - TCM FILEIO HBA Driver %s on Generic Target Core Stack %s\n",
 		     hba->hba_id, FD_VERSION, TARGET_CORE_VERSION);
 	target_debug("CORE_HBA[%d] - Attached FILEIO HBA: %u to Generic\n", hba->hba_id,
 		     fd_host->fd_host_id);
@@ -61,8 +60,7 @@ static void fd_detach_hba(struct se_hba *hba)
 {
 	struct fd_host *fd_host = hba->hba_ptr;
 
-	target_debug("CORE_HBA[%d] - Detached FILEIO HBA: %u from Generic"
-		     " Target Core\n",
+	target_debug("CORE_HBA[%d] - Detached FILEIO HBA: %u from Generic Target Core\n",
 		     hba->hba_id, fd_host->fd_host_id);
 
 	kfree(fd_host);
@@ -164,8 +162,7 @@ static int fd_configure_device(struct se_device *dev)
 		dev_size = (i_size_read(file->f_mapping->host) -
 				       fd_dev->fd_block_size);
 
-		target_debug("FILEIO: Using size: %llu bytes from struct"
-			     " block_device blocks: %llu logical_block_size: %d\n",
+		target_debug("FILEIO: Using size: %llu bytes from struct block_device blocks: %llu logical_block_size: %d\n",
 			     dev_size, div_u64(dev_size, fd_dev->fd_block_size),
 			     fd_dev->fd_block_size);
 		/*
@@ -178,9 +175,7 @@ static int fd_configure_device(struct se_device *dev)
 			dev->dev_attrib.is_nonrot = 1;
 	} else {
 		if (!(fd_dev->fbd_flags & FBDF_HAS_SIZE)) {
-			target_err("FILEIO: Missing fd_dev_size="
-				   " parameter, and no backing struct"
-				   " block_device\n");
+			target_err("FILEIO: Missing fd_dev_size= parameter, and no backing struct block_device\n");
 			goto fail;
 		}
 
@@ -198,16 +193,14 @@ static int fd_configure_device(struct se_device *dev)
 	dev->dev_attrib.hw_queue_depth = FD_MAX_DEVICE_QUEUE_DEPTH;
 
 	if (fd_dev->fbd_flags & FDBD_HAS_BUFFERED_IO_WCE) {
-		target_debug("FILEIO: Forcing setting of emulate_write_cache=1"
-			     " with FDBD_HAS_BUFFERED_IO_WCE\n");
+		target_debug("FILEIO: Forcing setting of emulate_write_cache=1 with FDBD_HAS_BUFFERED_IO_WCE\n");
 		dev->dev_attrib.emulate_write_cache = 1;
 	}
 
 	fd_dev->fd_dev_id = fd_host->fd_host_dev_id_count++;
 	fd_dev->fd_queue_depth = dev->queue_depth;
 
-	target_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s,"
-		     " %llu total bytes\n",
+	target_debug("CORE_FILE[%u] - Added TCM FILEIO Device ID: %u at %s, %llu total bytes\n",
 		     fd_host->fd_host_id, fd_dev->fd_dev_id, fd_dev->fd_dev_name,
 		     fd_dev->fd_dev_size);
 
@@ -353,9 +346,8 @@ static int fd_do_rw(struct se_cmd *cmd, struct file *fd,
 		 */
 		if (S_ISBLK(file_inode(fd)->i_mode)) {
 			if (ret < 0 || ret != data_length) {
-				target_err("%s() returned %d, expecting %u for "
-					   "S_ISBLK\n",
-					   __func__, ret, data_length);
+				target_err("%s() returned %d, expecting %u for S_ISBLK\n", __func__,
+					   ret, data_length);
 				if (ret >= 0)
 					ret = -EINVAL;
 			}
@@ -438,8 +430,7 @@ fd_execute_write_same(struct se_cmd *cmd)
 	ssize_t ret;
 
 	if (cmd->prot_op) {
-		target_err("WRITE_SAME: Protection information with FILEIO"
-			   " backends not supported\n");
+		target_err("WRITE_SAME: Protection information with FILEIO backends not supported\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 
@@ -448,8 +439,7 @@ fd_execute_write_same(struct se_cmd *cmd)
 
 	if (cmd->t_data_nents > 1 ||
 	    cmd->t_data_sg[0].length != cmd->se_dev->dev_attrib.block_size) {
-		target_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u"
-			   " block_size: %u\n",
+		target_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u block_size: %u\n",
 			   cmd->t_data_nents, cmd->t_data_sg[0].length,
 			   cmd->se_dev->dev_attrib.block_size);
 		return TCM_INVALID_CDB_FIELD;
@@ -675,8 +665,7 @@ fd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
 	 * single vfs_[writev,readv] call.
 	 */
 	if (cmd->data_length > FD_MAX_BYTES) {
-		target_err("FILEIO: Not able to process I/O of %u bytes due to"
-			   "FD_MAX_BYTES: %u iovec count limitation\n",
+		target_err("FILEIO: Not able to process I/O of %u bytes due to FD_MAX_BYTES: %u iovec count limitation\n",
 			   cmd->data_length, FD_MAX_BYTES);
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
@@ -737,13 +726,10 @@ static ssize_t fd_set_configfs_dev_params(struct se_device *dev,
 			ret = kstrtoull(arg_p, 0, &fd_dev->fd_dev_size);
 			kfree(arg_p);
 			if (ret < 0) {
-				target_err("kstrtoull() failed for"
-					   " fd_dev_size=\n");
+				target_err("kstrtoull() failed for fd_dev_size=\n");
 				goto out;
 			}
-			target_debug("FILEIO: Referencing Size: %llu"
-				     " bytes\n",
-				     fd_dev->fd_dev_size);
+			target_debug("FILEIO: Referencing Size: %llu bytes\n", fd_dev->fd_dev_size);
 			fd_dev->fbd_flags |= FBDF_HAS_SIZE;
 			break;
 		case Opt_fd_buffered_io:
@@ -756,8 +742,7 @@ static ssize_t fd_set_configfs_dev_params(struct se_device *dev,
 				goto out;
 			}
 
-			target_debug("FILEIO: Using buffered I/O"
-				     " operations for struct fd_dev\n");
+			target_debug("FILEIO: Using buffered I/O operations for struct fd_dev\n");
 
 			fd_dev->fbd_flags |= FDBD_HAS_BUFFERED_IO_WCE;
 			break;
@@ -771,8 +756,7 @@ static ssize_t fd_set_configfs_dev_params(struct se_device *dev,
 				goto out;
 			}
 
-			target_debug("FILEIO: Using async I/O"
-				     " operations for struct fd_dev\n");
+			target_debug("FILEIO: Using async I/O operations for struct fd_dev\n");
 
 			fd_dev->fbd_flags |= FDBD_HAS_ASYNC_IO;
 			break;
@@ -835,8 +819,7 @@ static int fd_init_prot(struct se_device *dev)
 
 	inode = file->f_mapping->host;
 	if (S_ISBLK(inode->i_mode)) {
-		target_err("FILEIO Protection emulation only supported on"
-			   " !S_ISBLK\n");
+		target_err("FILEIO Protection emulation only supported on !S_ISBLK\n");
 		return -ENOSYS;
 	}
 
diff --git a/drivers/target/target_core_hba.c b/drivers/target/target_core_hba.c
index 02501fd45b24..0edb17711a52 100644
--- a/drivers/target/target_core_hba.c
+++ b/drivers/target/target_core_hba.c
@@ -138,9 +138,7 @@ core_alloc_hba(const char *plugin_name, u32 plugin_dep_id, u32 hba_flags)
 	list_add_tail(&hba->hba_node, &hba_list);
 	spin_unlock(&hba_lock);
 
-	target_debug("CORE_HBA[%d] - Attached HBA to Generic Target"
-		     " Core\n",
-		     hba->hba_id);
+	target_debug("CORE_HBA[%d] - Attached HBA to Generic Target Core\n", hba->hba_id);
 
 	return hba;
 
@@ -163,9 +161,7 @@ core_delete_hba(struct se_hba *hba)
 	list_del(&hba->hba_node);
 	spin_unlock(&hba_lock);
 
-	target_debug("CORE_HBA[%d] - Detached HBA from Generic Target"
-		     " Core\n",
-		     hba->hba_id);
+	target_debug("CORE_HBA[%d] - Detached HBA from Generic Target Core\n", hba->hba_id);
 
 	module_put(hba->backend->ops->owner);
 
diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c
index 843f5903e390..1731fa059d4d 100644
--- a/drivers/target/target_core_iblock.c
+++ b/drivers/target/target_core_iblock.c
@@ -45,8 +45,7 @@ static inline struct iblock_dev *IBLOCK_DEV(struct se_device *dev)
 
 static int iblock_attach_hba(struct se_hba *hba, u32 host_id)
 {
-	target_debug("CORE_HBA[%d] - TCM iBlock HBA Driver %s on"
-		     " Generic Target Core Stack %s\n",
+	target_debug("CORE_HBA[%d] - TCM iBlock HBA Driver %s on Generic Target Core Stack %s\n",
 		     hba->hba_id, IBLOCK_VERSION, TARGET_CORE_VERSION);
 	return 0;
 }
@@ -504,8 +503,7 @@ iblock_execute_write_same(struct se_cmd *cmd)
 					sbc_get_write_same_sectors(cmd));
 
 	if (cmd->prot_op) {
-		target_err("WRITE_SAME: Protection information with IBLOCK"
-			   " backends not supported\n");
+		target_err("WRITE_SAME: Protection information with IBLOCK backends not supported\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 
@@ -516,8 +514,7 @@ iblock_execute_write_same(struct se_cmd *cmd)
 
 	if (cmd->t_data_nents > 1 ||
 	    sg->length != cmd->se_dev->dev_attrib.block_size) {
-		target_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u"
-			   " block_size: %u\n",
+		target_err("WRITE_SAME: Illegal SGL t_data_nents: %u length: %u block_size: %u\n",
 			   cmd->t_data_nents, sg->length, cmd->se_dev->dev_attrib.block_size);
 		return TCM_INVALID_CDB_FIELD;
 	}
@@ -604,8 +601,7 @@ static ssize_t iblock_set_configfs_dev_params(struct se_device *dev,
 		switch (token) {
 		case Opt_udev_path:
 			if (ib_dev->ibd_bd) {
-				target_err("Unable to set udev_path= while"
-					   " ib_dev->ibd_bd exists\n");
+				target_err("Unable to set udev_path= while ib_dev->ibd_bd exists\n");
 				ret = -EEXIST;
 				goto out;
 			}
@@ -626,8 +622,7 @@ static ssize_t iblock_set_configfs_dev_params(struct se_device *dev,
 			ret = kstrtoul(arg_p, 0, &tmp_readonly);
 			kfree(arg_p);
 			if (ret < 0) {
-				target_err("kstrtoul() failed for"
-					   " readonly=\n");
+				target_err("kstrtoul() failed for readonly=\n");
 				goto out;
 			}
 			ib_dev->ibd_readonly = tmp_readonly;
diff --git a/drivers/target/target_core_pr.c b/drivers/target/target_core_pr.c
index a2d0bc1da2bd..c2c6fd957dff 100644
--- a/drivers/target/target_core_pr.c
+++ b/drivers/target/target_core_pr.c
@@ -178,9 +178,7 @@ static int target_check_scsi2_reservation_conflict(struct se_cmd *cmd)
 	}
 
 	if (conflict) {
-		target_err("Received legacy SPC-2 RESERVE/RELEASE"
-			   " while active SPC-3 registrations exist,"
-			   " returning RESERVATION_CONFLICT\n");
+		target_err("Received legacy SPC-2 RESERVE/RELEASE while active SPC-3 registrations exist, returning RESERVATION_CONFLICT\n");
 		return -EBUSY;
 	}
 
@@ -225,8 +223,7 @@ target_scsi2_reservation_release(struct se_cmd *cmd)
 
 	target_release_reservation(dev);
 	tpg = sess->se_tpg;
-	target_debug("SCSI-2 Released reservation for %s LUN: %llu ->"
-		     " MAPPED LUN: %llu for %s\n",
+	target_debug("SCSI-2 Released reservation for %s LUN: %llu -> MAPPED LUN: %llu for %s\n",
 		     tpg->se_tpg_tfo->fabric_name, cmd->se_lun->unpacked_lun, cmd->orig_fe_lun,
 		     sess->se_node_acl->initiatorname);
 
@@ -272,8 +269,7 @@ target_scsi2_reservation_reserve(struct se_cmd *cmd)
 			   tpg->se_tpg_tfo->fabric_name);
 		target_err("Original reserver LUN: %llu %s\n", cmd->se_lun->unpacked_lun,
 			   dev->reservation_holder->se_node_acl->initiatorname);
-		target_err("Current attempt - LUN: %llu -> MAPPED LUN: %llu"
-			   " from %s \n",
+		target_err("Current attempt - LUN: %llu -> MAPPED LUN: %llu from %s\n",
 			   cmd->se_lun->unpacked_lun, cmd->orig_fe_lun,
 			   sess->se_node_acl->initiatorname);
 		ret = TCM_RESERVATION_CONFLICT;
@@ -286,8 +282,7 @@ target_scsi2_reservation_reserve(struct se_cmd *cmd)
 		dev->dev_res_bin_isid = sess->sess_bin_isid;
 		dev->dev_reservation_flags |= DRF_SPC2_RESERVATIONS_WITH_ISID;
 	}
-	target_debug("SCSI-2 Reserved %s LUN: %llu -> MAPPED LUN: %llu"
-		     " for %s\n",
+	target_debug("SCSI-2 Reserved %s LUN: %llu -> MAPPED LUN: %llu for %s\n",
 		     tpg->se_tpg_tfo->fabric_name, cmd->se_lun->unpacked_lun, cmd->orig_fe_lun,
 		     sess->se_node_acl->initiatorname);
 
@@ -411,8 +406,7 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
 			ret = (registered_nexus) ? 0 : 1;
 			break;
 		default:
-			target_err("Unknown PERSISTENT_RESERVE_OUT service"
-				   " action: 0x%02x\n",
+			target_err("Unknown PERSISTENT_RESERVE_OUT service action: 0x%02x\n",
 				   cdb[1] & 0x1f);
 			return -EINVAL;
 		}
@@ -483,9 +477,8 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
 	 * statement.
 	 */
 	if (!ret && !other_cdb) {
-		target_debug("Allowing explicit CDB: 0x%02x for %s"
-			     " reservation holder\n",
-			     cdb[0], core_scsi3_pr_dump_type(pr_reg_type));
+		target_debug("Allowing explicit CDB: 0x%02x for %s reservation holder\n", cdb[0],
+			     core_scsi3_pr_dump_type(pr_reg_type));
 
 		return ret;
 	}
@@ -498,8 +491,7 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
 			/*
 			 * Conflict for write exclusive
 			 */
-			target_debug("%s Conflict for unregistered nexus"
-				     " %s CDB: 0x%02x to %s reservation\n",
+			target_debug("%s Conflict for unregistered nexus %s CDB: 0x%02x to %s reservation\n",
 				     transport_dump_cmd_direction(cmd),
 				     se_sess->se_node_acl->initiatorname, cdb[0],
 				     core_scsi3_pr_dump_type(pr_reg_type));
@@ -516,9 +508,7 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
 			 */
 
 			if (!registered_nexus) {
-				target_debug("Allowing implicit CDB: 0x%02x"
-					     " for %s reservation on unregistered"
-					     " nexus\n",
+				target_debug("Allowing implicit CDB: 0x%02x for %s reservation on unregistered nexus\n",
 					     cdb[0], core_scsi3_pr_dump_type(pr_reg_type));
 			}
 
@@ -531,9 +521,8 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
 			 * allow commands from registered nexuses.
 			 */
 
-			target_debug("Allowing implicit CDB: 0x%02x for %s"
-				     " reservation\n",
-				     cdb[0], core_scsi3_pr_dump_type(pr_reg_type));
+			target_debug("Allowing implicit CDB: 0x%02x for %s reservation\n", cdb[0],
+				     core_scsi3_pr_dump_type(pr_reg_type));
 
 			return 0;
 		}
@@ -543,15 +532,13 @@ static int core_scsi3_pr_seq_non_holder(struct se_cmd *cmd, u32 pr_reg_type,
                 * from all registrants.
                 */
                if (cmd->data_direction == DMA_FROM_DEVICE) {
-			target_debug("Allowing READ CDB: 0x%02x for %s"
-				     " reservation\n",
-				     cdb[0], core_scsi3_pr_dump_type(pr_reg_type));
+			target_debug("Allowing READ CDB: 0x%02x for %s reservation\n", cdb[0],
+				     core_scsi3_pr_dump_type(pr_reg_type));
 
                        return 0;
                }
 	}
-	target_debug("%s Conflict for %sregistered nexus %s CDB: 0x%2x"
-		     " for %s reservation\n",
+	target_debug("%s Conflict for %sregistered nexus %s CDB: 0x%2x for %s reservation\n",
 		     transport_dump_cmd_direction(cmd), (registered_nexus) ? "" : "un",
 		     se_sess->se_node_acl->initiatorname, cdb[0],
 		     core_scsi3_pr_dump_type(pr_reg_type));
@@ -769,8 +756,7 @@ static struct t10_pr_registration *__core_scsi3_alloc_registration(
 			 */
 			ret = core_scsi3_lunacl_depend_item(deve_tmp);
 			if (ret < 0) {
-				target_err("core_scsi3_lunacl_depend"
-					   "_item() failed\n");
+				target_err("core_scsi3_lunacl_depend_item() failed\n");
 				percpu_ref_put(&lun_tmp->lun_ref);
 				kref_put(&deve_tmp->pr_kref, target_pr_kref_release);
 				goto out;
@@ -882,8 +868,7 @@ int core_scsi3_alloc_aptpl_registration(
 	pr_reg->pr_res_holder = res_holder;
 
 	list_add_tail(&pr_reg->pr_reg_aptpl_list, &pr_tmpl->aptpl_reg_list);
-	target_debug("SPC-3 PR APTPL Successfully added registration%s from"
-		     " metadata\n",
+	target_debug("SPC-3 PR APTPL Successfully added registration%s from metadata\n",
 		     (res_holder) ? "+reservation" : "");
 	return 0;
 }
@@ -902,8 +887,7 @@ static void core_scsi3_aptpl_reserve(
 	dev->dev_pr_res_holder = pr_reg;
 	spin_unlock(&dev->dev_reservation_lock);
 
-	target_debug("SPC-3 PR [%s] Service Action: APTPL RESERVE created"
-		     " new reservation holder TYPE: %s ALL_TG_PT: %d\n",
+	target_debug("SPC-3 PR [%s] Service Action: APTPL RESERVE created new reservation holder TYPE: %s ALL_TG_PT: %d\n",
 		     tpg->se_tpg_tfo->fabric_name, core_scsi3_pr_dump_type(pr_reg->pr_res_type),
 		     (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
 	target_debug("SPC-3 PR [%s] RESERVE Node: %s%s\n", tpg->se_tpg_tfo->fabric_name,
@@ -956,8 +940,7 @@ static int __core_scsi3_check_aptpl_registration(
 			rcu_read_lock();
 			pr_reg->pr_reg_deve = target_nacl_find_deve(nacl, mapped_lun);
 			if (!pr_reg->pr_reg_deve) {
-				target_err("Unable to locate PR APTPL %s mapped_lun:"
-					   " %llu\n",
+				target_err("Unable to locate PR APTPL %s mapped_lun: %llu\n",
 					   nacl->initiatorname, mapped_lun);
 				rcu_read_unlock();
 				continue;
@@ -1021,18 +1004,16 @@ static void __core_scsi3_dump_registration(
 
 	core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
 
-	target_debug("SPC-3 PR [%s] Service Action: REGISTER%s Initiator"
-		     " Node: %s%s\n", tfo->fabric_name, (register_type == REGISTER_AND_MOVE) ?
+	target_debug("SPC-3 PR [%s] Service Action: REGISTER%s Initiator Node: %s%s\n",
+		     tfo->fabric_name, (register_type == REGISTER_AND_MOVE) ?
 		     "_AND_MOVE" : (register_type == REGISTER_AND_IGNORE_EXISTING_KEY) ?
 		     "_AND_IGNORE_EXISTING_KEY" : "", nacl->initiatorname, i_buf);
 	target_debug("SPC-3 PR [%s] registration on Target Port: %s,0x%04x\n", tfo->fabric_name,
 		     tfo->tpg_get_wwn(se_tpg), tfo->tpg_get_tag(se_tpg));
-	target_debug("SPC-3 PR [%s] for %s TCM Subsystem %s Object Target"
-		     " Port(s)\n",
+	target_debug("SPC-3 PR [%s] for %s TCM Subsystem %s Object Target Port(s)\n",
 		     tfo->fabric_name, (pr_reg->pr_reg_all_tg_pt) ? "ALL" : "SINGLE",
 		     dev->transport->name);
-	target_debug("SPC-3 PR [%s] SA Res Key: 0x%016Lx PRgeneration:"
-		     " 0x%08x  APTPL: %d\n",
+	target_debug("SPC-3 PR [%s] SA Res Key: 0x%016Lx PRgeneration: 0x%08x  APTPL: %d\n",
 		     tfo->fabric_name, pr_reg->pr_res_key, pr_reg->pr_res_generation,
 		     pr_reg->pr_reg_aptpl);
 }
@@ -1252,10 +1233,7 @@ static int core_scsi3_check_implicit_release(
 		  (!strcmp(pr_res_holder->pr_reg_nacl->initiatorname,
 			  pr_reg->pr_reg_nacl->initiatorname)) &&
 		  (pr_res_holder->pr_res_key == pr_reg->pr_res_key)) {
-		target_err("SPC-3 PR: Unable to perform ALL_TG_PT=1"
-			   " UNREGISTER while existing reservation with matching"
-			   " key 0x%016Lx is present from another SCSI Initiator"
-			   " Port\n",
+		target_err("SPC-3 PR: Unable to perform ALL_TG_PT=1 UNREGISTER while existing reservation with matching key 0x%016Lx is present from another SCSI Initiator Port\n",
 			   pr_reg->pr_res_key);
 		ret = -EPERM;
 	}
@@ -1311,16 +1289,13 @@ static void __core_scsi3_free_registration(
 	rcu_read_unlock();
 
 	spin_lock(&pr_tmpl->registration_lock);
-	target_debug("SPC-3 PR [%s] Service Action: UNREGISTER Initiator"
-		     " Node: %s%s\n",
+	target_debug("SPC-3 PR [%s] Service Action: UNREGISTER Initiator Node: %s%s\n",
 		     tfo->fabric_name, pr_reg->pr_reg_nacl->initiatorname, i_buf);
-	target_debug("SPC-3 PR [%s] for %s TCM Subsystem %s Object Target"
-		     " Port(s)\n",
+	target_debug("SPC-3 PR [%s] for %s TCM Subsystem %s Object Target Port(s)\n",
 		     tfo->fabric_name, (pr_reg->pr_reg_all_tg_pt) ? "ALL" : "SINGLE",
 		     dev->transport->name);
-	target_debug("SPC-3 PR [%s] SA Res Key: 0x%016Lx PRgeneration:"
-		     " 0x%08x\n",
-		     tfo->fabric_name, pr_reg->pr_res_key, pr_reg->pr_res_generation);
+	target_debug("SPC-3 PR [%s] SA Res Key: 0x%016Lx PRgeneration: 0x%08x\n", tfo->fabric_name,
+		     pr_reg->pr_res_key, pr_reg->pr_res_generation);
 
 	if (!preempt_and_abort_list) {
 		pr_reg->pr_reg_deve = NULL;
@@ -1514,8 +1489,7 @@ core_scsi3_decode_spec_i_port(
 	list_add_tail(&tidh_new->dest_list, &tid_dest_list);
 
 	if (cmd->data_length < 28) {
-		target_warn("SPC-PR: Received PR OUT parameter list"
-			    " length too small: %u\n",
+		target_warn("SPC-PR: Received PR OUT parameter list length too small: %u\n",
 			    cmd->data_length);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
@@ -1535,8 +1509,7 @@ core_scsi3_decode_spec_i_port(
 	tpdl = get_unaligned_be32(&buf[24]);
 
 	if ((tpdl + 28) != cmd->data_length) {
-		target_err("SPC-3 PR: Illegal tpdl: %u + 28 byte header"
-			   " does not equal CDB data_length: %u\n",
+		target_err("SPC-3 PR: Illegal tpdl: %u + 28 byte header does not equal CDB data_length: %u\n",
 			   tpdl, cmd->data_length);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out_unmap;
@@ -1590,8 +1563,7 @@ core_scsi3_decode_spec_i_port(
 			spin_unlock(&dev->se_port_lock);
 
 			if (core_scsi3_tpg_depend_item(tmp_tpg)) {
-				target_err(" core_scsi3_tpg_depend_item()"
-					   " for tmp_tpg\n");
+				target_err(" core_scsi3_tpg_depend_item() for tmp_tpg\n");
 				atomic_dec_mb(&tmp_tpg->tpg_pr_ref_count);
 				ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 				goto out_unmap;
@@ -1615,8 +1587,7 @@ core_scsi3_decode_spec_i_port(
 			}
 
 			if (core_scsi3_nodeacl_depend_item(dest_node_acl)) {
-				target_err("configfs_depend_item() failed"
-					   " for dest_node_acl->acl_group\n");
+				target_err("configfs_depend_item() failed for dest_node_acl->acl_group\n");
 				atomic_dec_mb(&dest_node_acl->acl_pr_ref_count);
 				core_scsi3_tpg_undepend_item(tmp_tpg);
 				ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
@@ -1634,20 +1605,17 @@ core_scsi3_decode_spec_i_port(
 		spin_unlock(&dev->se_port_lock);
 
 		if (!dest_tpg) {
-			target_err("SPC-3 PR SPEC_I_PT: Unable to locate"
-				   " dest_tpg\n");
+			target_err("SPC-3 PR SPEC_I_PT: Unable to locate dest_tpg\n");
 			ret = TCM_INVALID_PARAMETER_LIST;
 			goto out_unmap;
 		}
 
-		target_debug("SPC-3 PR SPEC_I_PT: Got %s data_length: %u tpdl: %u"
-			     " tid_len: %d for %s + %s\n",
+		target_debug("SPC-3 PR SPEC_I_PT: Got %s data_length: %u tpdl: %u tid_len: %d for %s + %s\n",
 			     dest_tpg->se_tpg_tfo->fabric_name, cmd->data_length, tpdl, tid_len,
 			     i_str, iport_ptr);
 
 		if (tid_len > tpdl) {
-			target_err("SPC-3 PR SPEC_I_PT: Illegal tid_len:"
-				   " %u for Transport ID: %s\n",
+			target_err("SPC-3 PR SPEC_I_PT: Illegal tid_len: %u for Transport ID: %s\n",
 				   tid_len, ptr);
 			core_scsi3_nodeacl_undepend_item(dest_node_acl);
 			core_scsi3_tpg_undepend_item(dest_tpg);
@@ -1672,8 +1640,7 @@ core_scsi3_decode_spec_i_port(
 		}
 
 		if (core_scsi3_lunacl_depend_item(dest_se_deve)) {
-			target_err("core_scsi3_lunacl_depend_item()"
-				   " failed\n");
+			target_err("core_scsi3_lunacl_depend_item() failed\n");
 			kref_put(&dest_se_deve->pr_kref, target_pr_kref_release);
 			core_scsi3_nodeacl_undepend_item(dest_node_acl);
 			core_scsi3_tpg_undepend_item(dest_tpg);
@@ -1681,8 +1648,7 @@ core_scsi3_decode_spec_i_port(
 			goto out_unmap;
 		}
 
-		target_debug("SPC-3 PR SPEC_I_PT: Located %s Node: %s"
-			     " dest_se_deve mapped_lun: %llu\n",
+		target_debug("SPC-3 PR SPEC_I_PT: Located %s Node: %s dest_se_deve mapped_lun: %llu\n",
 			     dest_tpg->se_tpg_tfo->fabric_name, dest_node_acl->initiatorname,
 			     dest_se_deve->mapped_lun);
 
@@ -1791,9 +1757,7 @@ core_scsi3_decode_spec_i_port(
 		__core_scsi3_add_registration(cmd->se_dev, dest_node_acl,
 					dest_pr_reg, 0, 0);
 
-		target_debug("SPC-3 PR [%s] SPEC_I_PT: Successfully"
-			     " registered Transport ID for Node: %s%s Mapped LUN:"
-			     " %llu\n",
+		target_debug("SPC-3 PR [%s] SPEC_I_PT: Successfully registered Transport ID for Node: %s%s Mapped LUN: %llu\n",
 			     dest_tpg->se_tpg_tfo->fabric_name, dest_node_acl->initiatorname, i_buf,
 			     (dest_se_deve) ? dest_se_deve->mapped_lun : 0);
 
@@ -1908,8 +1872,7 @@ static int core_scsi3_update_aptpl_buf(
 		}
 
 		if ((len + strlen(tmp) >= pr_aptpl_buf_len)) {
-			target_err("Unable to update renaming APTPL metadata,"
-				   " reallocating larger buffer\n");
+			target_err("Unable to update renaming APTPL metadata, reallocating larger buffer\n");
 			ret = -EMSGSIZE;
 			goto out;
 		}
@@ -1927,8 +1890,7 @@ static int core_scsi3_update_aptpl_buf(
 			reg_count);
 
 		if ((len + strlen(tmp) >= pr_aptpl_buf_len)) {
-			target_err("Unable to update renaming APTPL metadata,"
-				   " reallocating larger buffer\n");
+			target_err("Unable to update renaming APTPL metadata, reallocating larger buffer\n");
 			ret = -EMSGSIZE;
 			goto out;
 		}
@@ -1965,9 +1927,7 @@ static int __core_scsi3_write_aptpl_to_file(
 
 	file = filp_open(path, flags, 0600);
 	if (IS_ERR(file)) {
-		target_err("filp_open(%s) for APTPL metadata"
-			   " failed\n",
-			   path);
+		target_err("filp_open(%s) for APTPL metadata failed\n", path);
 		kfree(path);
 		return PTR_ERR(file);
 	}
@@ -2061,8 +2021,7 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
 	pr_reg = core_scsi3_locate_pr_reg(dev, se_sess->se_node_acl, se_sess);
 	if (!pr_reg) {
 		if (res_key) {
-			target_warn("SPC-3 PR: Reservation Key non-zero"
-				    " for SA REGISTER, returning CONFLICT\n");
+			target_warn("SPC-3 PR: Reservation Key non-zero for SA REGISTER, returning CONFLICT\n");
 			return TCM_RESERVATION_CONFLICT;
 		}
 		/*
@@ -2082,8 +2041,7 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
 					NULL, cmd->orig_fe_lun, isid_ptr,
 					sa_res_key, all_tg_pt, aptpl,
 					register_type, 0)) {
-				target_err("Unable to allocate"
-					   " struct t10_pr_registration\n");
+				target_err("Unable to allocate struct t10_pr_registration\n");
 				return TCM_INSUFFICIENT_REGISTRATION_RESOURCES;
 			}
 		} else {
@@ -2106,18 +2064,14 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
 	/* ok, existing registration */
 
 	if ((register_type == REGISTER) && (res_key != pr_reg->pr_res_key)) {
-		target_err("SPC-3 PR REGISTER: Received"
-			   " res_key: 0x%016Lx does not match"
-			   " existing SA REGISTER res_key:"
-			   " 0x%016Lx\n",
+		target_err("SPC-3 PR REGISTER: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
 			   res_key, pr_reg->pr_res_key);
 		ret = TCM_RESERVATION_CONFLICT;
 		goto out;
 	}
 
 	if (spec_i_pt) {
-		target_err("SPC-3 PR REGISTER: SPEC_I_PT"
-			   " set on a registered nexus\n");
+		target_err("SPC-3 PR REGISTER: SPEC_I_PT set on a registered nexus\n");
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
 	}
@@ -2127,9 +2081,7 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
 	 * must also set ALL_TG_PT=1 in the incoming PROUT.
 	 */
 	if (pr_reg->pr_reg_all_tg_pt && !all_tg_pt) {
-		target_err("SPC-3 PR REGISTER: ALL_TG_PT=1"
-			   " registration exists, but ALL_TG_PT=1 bit not"
-			   " present in received PROUT\n");
+		target_err("SPC-3 PR REGISTER: ALL_TG_PT=1 registration exists, but ALL_TG_PT=1 bit not present in received PROUT\n");
 		ret = TCM_INVALID_CDB_FIELD;
 		goto out;
 	}
@@ -2145,9 +2097,8 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
 		 */
 		pr_reg->pr_res_generation = core_scsi3_pr_generation(cmd->se_dev);
 		pr_reg->pr_res_key = sa_res_key;
-		target_debug("SPC-3 PR [%s] REGISTER%s: Changed Reservation"
-			     " Key for %s to: 0x%016Lx PRgeneration:"
-			     " 0x%08x\n", cmd->se_tfo->fabric_name,
+		target_debug("SPC-3 PR [%s] REGISTER%s: Changed Reservation Key for %s to: 0x%016Lx PRgeneration: 0x%08x\n",
+			     cmd->se_tfo->fabric_name,
 			     (register_type == REGISTER_AND_IGNORE_EXISTING_KEY) ?
 			     "_AND_IGNORE_EXISTING_KEY" : "", pr_reg->pr_reg_nacl->initiatorname,
 			     pr_reg->pr_res_key, pr_reg->pr_res_generation);
@@ -2275,8 +2226,7 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
 	pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl,
 				se_sess);
 	if (!pr_reg) {
-		target_err("SPC-3 PR: Unable to locate"
-			   " PR_REGISTERED *pr_reg for RESERVE\n");
+		target_err("SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for RESERVE\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 	/*
@@ -2289,9 +2239,7 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
 	 * 	 registered with the logical unit for the I_T nexus; and
 	 */
 	if (res_key != pr_reg->pr_res_key) {
-		target_err("SPC-3 PR RESERVE: Received res_key: 0x%016Lx"
-			   " does not match existing SA REGISTER res_key:"
-			   " 0x%016Lx\n",
+		target_err("SPC-3 PR RESERVE: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
 			   res_key, pr_reg->pr_res_key);
 		ret = TCM_RESERVATION_CONFLICT;
 		goto out_put_pr_reg;
@@ -2331,9 +2279,7 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
 		 */
 		if (!is_reservation_holder(pr_res_holder, pr_reg)) {
 			struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl;
-			target_err("SPC-3 PR: Attempted RESERVE from"
-				   " [%s]: %s while reservation already held by"
-				   " [%s]: %s, returning RESERVATION_CONFLICT\n",
+			target_err("SPC-3 PR: Attempted RESERVE from [%s]: %s while reservation already held by [%s]: %s, returning RESERVATION_CONFLICT\n",
 				   cmd->se_tfo->fabric_name, se_sess->se_node_acl->initiatorname,
 				   pr_res_nacl->se_tpg->se_tpg_tfo->fabric_name,
 				   pr_res_holder->pr_reg_nacl->initiatorname);
@@ -2352,10 +2298,7 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
 		if ((pr_res_holder->pr_res_type != type) ||
 		    (pr_res_holder->pr_res_scope != scope)) {
 			struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl;
-			target_err("SPC-3 PR: Attempted RESERVE from"
-				   " [%s]: %s trying to change TYPE and/or SCOPE,"
-				   " while reservation already held by [%s]: %s,"
-				   " returning RESERVATION_CONFLICT\n",
+			target_err("SPC-3 PR: Attempted RESERVE from [%s]: %s trying to change TYPE and/or SCOPE, while reservation already held by [%s]: %s, returning RESERVATION_CONFLICT\n",
 				   cmd->se_tfo->fabric_name, se_sess->se_node_acl->initiatorname,
 				   pr_res_nacl->se_tpg->se_tpg_tfo->fabric_name,
 				   pr_res_holder->pr_reg_nacl->initiatorname);
@@ -2388,8 +2331,7 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
 	dev->dev_pr_res_holder = pr_reg;
 	core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
 
-	target_debug("SPC-3 PR [%s] Service Action: RESERVE created new"
-		     " reservation holder TYPE: %s ALL_TG_PT: %d\n",
+	target_debug("SPC-3 PR [%s] Service Action: RESERVE created new reservation holder TYPE: %s ALL_TG_PT: %d\n",
 		     cmd->se_tfo->fabric_name, core_scsi3_pr_dump_type(type),
 		     (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
 	target_debug("SPC-3 PR [%s] RESERVE Node: %s%s\n", cmd->se_tfo->fabric_name,
@@ -2418,9 +2360,7 @@ core_scsi3_emulate_pro_reserve(struct se_cmd *cmd, int type, int scope,
 	case PR_TYPE_EXCLUSIVE_ACCESS_ALLREG:
 		return core_scsi3_pro_reserve(cmd, type, scope, res_key);
 	default:
-		target_err("SPC-3 PR: Unknown Service Action RESERVE Type:"
-			   " 0x%02x\n",
-			   type);
+		target_err("SPC-3 PR: Unknown Service Action RESERVE Type: 0x%02x\n", type);
 		return TCM_INVALID_CDB_FIELD;
 	}
 }
@@ -2477,8 +2417,7 @@ static void __core_scsi3_complete_pro_release(
 	spin_unlock(&dev->t10_pr.registration_lock);
 out:
 	if (!dev->dev_pr_res_holder) {
-		target_debug("SPC-3 PR [%s] Service Action: %s RELEASE cleared"
-			     " reservation holder TYPE: %s ALL_TG_PT: %d\n",
+		target_debug("SPC-3 PR [%s] Service Action: %s RELEASE cleared reservation holder TYPE: %s ALL_TG_PT: %d\n",
 			     tfo->fabric_name, (explicit) ? "explicit" : "implicit",
 			     core_scsi3_pr_dump_type(pr_res_type),
 			     (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
@@ -2511,8 +2450,7 @@ core_scsi3_emulate_pro_release(struct se_cmd *cmd, int type, int scope,
 	 */
 	pr_reg = core_scsi3_locate_pr_reg(dev, se_sess->se_node_acl, se_sess);
 	if (!pr_reg) {
-		target_err("SPC-3 PR: Unable to locate"
-			   " PR_REGISTERED *pr_reg for RELEASE\n");
+		target_err("SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for RELEASE\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 	/*
@@ -2561,9 +2499,7 @@ core_scsi3_emulate_pro_release(struct se_cmd *cmd, int type, int scope,
 	 *	  that is registered with the logical unit for the I_T nexus;
 	 */
 	if (res_key != pr_reg->pr_res_key) {
-		target_err("SPC-3 PR RELEASE: Received res_key: 0x%016Lx"
-			   " does not match existing SA REGISTER res_key:"
-			   " 0x%016Lx\n",
+		target_err("SPC-3 PR RELEASE: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
 			   res_key, pr_reg->pr_res_key);
 		spin_unlock(&dev->dev_reservation_lock);
 		ret = TCM_RESERVATION_CONFLICT;
@@ -2578,10 +2514,7 @@ core_scsi3_emulate_pro_release(struct se_cmd *cmd, int type, int scope,
 	if ((pr_res_holder->pr_res_type != type) ||
 	    (pr_res_holder->pr_res_scope != scope)) {
 		struct se_node_acl *pr_res_nacl = pr_res_holder->pr_reg_nacl;
-		target_err("SPC-3 PR RELEASE: Attempted to release"
-			   " reservation from [%s]: %s with different TYPE "
-			   "and/or SCOPE  while reservation already held by"
-			   " [%s]: %s, returning RESERVATION_CONFLICT\n",
+		target_err("SPC-3 PR RELEASE: Attempted to release reservation from [%s]: %s with different TYPE and/or SCOPE  while reservation already held by [%s]: %s, returning RESERVATION_CONFLICT\n",
 			   cmd->se_tfo->fabric_name, se_sess->se_node_acl->initiatorname,
 			   pr_res_nacl->se_tpg->se_tpg_tfo->fabric_name,
 			   pr_res_holder->pr_reg_nacl->initiatorname);
@@ -2664,8 +2597,7 @@ core_scsi3_emulate_pro_clear(struct se_cmd *cmd, u64 res_key)
 	pr_reg_n = core_scsi3_locate_pr_reg(cmd->se_dev,
 			se_sess->se_node_acl, se_sess);
 	if (!pr_reg_n) {
-		target_err("SPC-3 PR: Unable to locate"
-			   " PR_REGISTERED *pr_reg for CLEAR\n");
+		target_err("SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for CLEAR\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 	/*
@@ -2680,10 +2612,7 @@ core_scsi3_emulate_pro_clear(struct se_cmd *cmd, u64 res_key)
 	 * 	   that is registered with the logical unit for the I_T nexus.
 	 */
 	if (res_key != pr_reg_n->pr_res_key) {
-		target_err("SPC-3 PR REGISTER: Received"
-			   " res_key: 0x%016Lx does not match"
-			   " existing SA REGISTER res_key:"
-			   " 0x%016Lx\n",
+		target_err("SPC-3 PR REGISTER: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
 			   res_key, pr_reg_n->pr_res_key);
 		core_scsi3_put_pr_reg(pr_reg_n);
 		return TCM_RESERVATION_CONFLICT;
@@ -2759,8 +2688,7 @@ static void __core_scsi3_complete_pro_preempt(
 	pr_reg->pr_res_type = type;
 	pr_reg->pr_res_scope = scope;
 
-	target_debug("SPC-3 PR [%s] Service Action: PREEMPT%s created new"
-		     " reservation holder TYPE: %s ALL_TG_PT: %d\n",
+	target_debug("SPC-3 PR [%s] Service Action: PREEMPT%s created new reservation holder TYPE: %s ALL_TG_PT: %d\n",
 		     tfo->fabric_name, (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "",
 		     core_scsi3_pr_dump_type(type), (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
 	target_debug("SPC-3 PR [%s] PREEMPT%s from Node: %s%s\n", tfo->fabric_name,
@@ -2820,8 +2748,7 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
 	pr_reg_n = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl,
 				se_sess);
 	if (!pr_reg_n) {
-		target_err("SPC-3 PR: Unable to locate"
-			   " PR_REGISTERED *pr_reg for PREEMPT%s\n",
+		target_err("SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for PREEMPT%s\n",
 			   (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "");
 		return TCM_RESERVATION_CONFLICT;
 	}
@@ -3123,8 +3050,7 @@ core_scsi3_emulate_pro_preempt(struct se_cmd *cmd, int type, int scope,
 		return core_scsi3_pro_preempt(cmd, type, scope, res_key,
 					      sa_res_key, preempt_type);
 	default:
-		target_err("SPC-3 PR: Unknown Service Action PREEMPT%s"
-			   " Type: 0x%02x\n",
+		target_err("SPC-3 PR: Unknown Service Action PREEMPT%s Type: 0x%02x\n",
 			   (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "", type);
 		return TCM_INVALID_CDB_FIELD;
 	}
@@ -3169,8 +3095,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev, se_sess->se_node_acl,
 				se_sess);
 	if (!pr_reg) {
-		target_err("SPC-3 PR: Unable to locate PR_REGISTERED"
-			   " *pr_reg for REGISTER_AND_MOVE\n");
+		target_err("SPC-3 PR: Unable to locate PR_REGISTERED *pr_reg for REGISTER_AND_MOVE\n");
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 	}
 	/*
@@ -3178,9 +3103,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	 * provided during this initiator's I_T nexus registration.
 	 */
 	if (res_key != pr_reg->pr_res_key) {
-		target_warn("SPC-3 PR REGISTER_AND_MOVE: Received"
-			    " res_key: 0x%016Lx does not match existing SA REGISTER"
-			    " res_key: 0x%016Lx\n",
+		target_warn("SPC-3 PR REGISTER_AND_MOVE: Received res_key: 0x%016Lx does not match existing SA REGISTER res_key: 0x%016Lx\n",
 			    res_key, pr_reg->pr_res_key);
 		ret = TCM_RESERVATION_CONFLICT;
 		goto out_put_pr_reg;
@@ -3189,8 +3112,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	 * The service active reservation key needs to be non zero
 	 */
 	if (!sa_res_key) {
-		target_warn("SPC-3 PR REGISTER_AND_MOVE: Received zero"
-			    " sa_res_key\n");
+		target_warn("SPC-3 PR REGISTER_AND_MOVE: Received zero sa_res_key\n");
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out_put_pr_reg;
 	}
@@ -3212,8 +3134,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	buf = NULL;
 
 	if ((tid_len + 24) != cmd->data_length) {
-		target_err("SPC-3 PR: Illegal tid_len: %u + 24 byte header"
-			   " does not equal CDB data_length: %u\n",
+		target_err("SPC-3 PR: Illegal tid_len: %u + 24 byte header does not equal CDB data_length: %u\n",
 			   tid_len, cmd->data_length);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out_put_pr_reg;
@@ -3232,8 +3153,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 		spin_unlock(&dev->se_port_lock);
 
 		if (core_scsi3_tpg_depend_item(dest_se_tpg)) {
-			target_err("core_scsi3_tpg_depend_item() failed"
-				   " for dest_se_tpg\n");
+			target_err("core_scsi3_tpg_depend_item() failed for dest_se_tpg\n");
 			atomic_dec_mb(&dest_se_tpg->tpg_pr_ref_count);
 			ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 			goto out_put_pr_reg;
@@ -3245,9 +3165,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	spin_unlock(&dev->se_port_lock);
 
 	if (!dest_se_tpg || !dest_tf_ops) {
-		target_err("SPC-3 PR REGISTER_AND_MOVE: Unable to locate"
-			   " fabric ops from Relative Target Port Identifier:"
-			   " %hu\n",
+		target_err("SPC-3 PR REGISTER_AND_MOVE: Unable to locate fabric ops from Relative Target Port Identifier: %hu\n",
 			   rtpi);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out_put_pr_reg;
@@ -3260,14 +3178,11 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	}
 	proto_ident = (buf[24] & 0x0f);
 
-	target_debug("SPC-3 PR REGISTER_AND_MOVE: Extracted Protocol Identifier:"
-		     " 0x%02x\n",
+	target_debug("SPC-3 PR REGISTER_AND_MOVE: Extracted Protocol Identifier: 0x%02x\n",
 		     proto_ident);
 
 	if (proto_ident != dest_se_tpg->proto_id) {
-		target_err("SPC-3 PR REGISTER_AND_MOVE: Received"
-			   " proto_ident: 0x%02x does not match ident: 0x%02x"
-			   " from fabric: %s\n",
+		target_err("SPC-3 PR REGISTER_AND_MOVE: Received proto_ident: 0x%02x does not match ident: 0x%02x from fabric: %s\n",
 			   proto_ident, dest_se_tpg->proto_id, dest_tf_ops->fabric_name);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
@@ -3275,8 +3190,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	initiator_str = target_parse_pr_out_transport_id(dest_se_tpg,
 			&buf[24], &tmp_tid_len, &iport_ptr);
 	if (!initiator_str) {
-		target_err("SPC-3 PR REGISTER_AND_MOVE: Unable to locate"
-			   " initiator_str from Transport ID\n");
+		target_err("SPC-3 PR REGISTER_AND_MOVE: Unable to locate initiator_str from Transport ID\n");
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
 	}
@@ -3284,8 +3198,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	transport_kunmap_data_sg(cmd);
 	buf = NULL;
 
-	target_debug("SPC-3 PR [%s] Extracted initiator %s identifier: %s"
-		     " %s\n",
+	target_debug("SPC-3 PR [%s] Extracted initiator %s identifier: %s %s\n",
 		     dest_tf_ops->fabric_name, (iport_ptr != NULL) ? "port" : "device",
 		     initiator_str, (iport_ptr != NULL) ? iport_ptr : "");
 	/*
@@ -3303,15 +3216,13 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 		goto after_iport_check;
 
 	if (!iport_ptr || !pr_reg->isid_present_at_reg) {
-		target_err("SPC-3 PR REGISTER_AND_MOVE: TransportID: %s"
-			   " matches: %s on received I_T Nexus\n",
+		target_err("SPC-3 PR REGISTER_AND_MOVE: TransportID: %s matches: %s on received I_T Nexus\n",
 			   initiator_str, pr_reg_nacl->initiatorname);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
 	}
 	if (!strcmp(iport_ptr, pr_reg->pr_reg_isid)) {
-		target_err("SPC-3 PR REGISTER_AND_MOVE: TransportID: %s %s"
-			   " matches: %s %s on received I_T Nexus\n",
+		target_err("SPC-3 PR REGISTER_AND_MOVE: TransportID: %s %s matches: %s %s on received I_T Nexus\n",
 			   initiator_str, iport_ptr, pr_reg_nacl->initiatorname,
 			   pr_reg->pr_reg_isid);
 		ret = TCM_INVALID_PARAMETER_LIST;
@@ -3329,24 +3240,21 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	mutex_unlock(&dest_se_tpg->acl_node_mutex);
 
 	if (!dest_node_acl) {
-		target_err("Unable to locate %s dest_node_acl for"
-			   " TransportID%s\n",
+		target_err("Unable to locate %s dest_node_acl for TransportID%s\n",
 			   dest_tf_ops->fabric_name, initiator_str);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
 	}
 
 	if (core_scsi3_nodeacl_depend_item(dest_node_acl)) {
-		target_err("core_scsi3_nodeacl_depend_item() for"
-			   " dest_node_acl\n");
+		target_err("core_scsi3_nodeacl_depend_item() for dest_node_acl\n");
 		atomic_dec_mb(&dest_node_acl->acl_pr_ref_count);
 		dest_node_acl = NULL;
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
 	}
 
-	target_debug("SPC-3 PR REGISTER_AND_MOVE: Found %s dest_node_acl:"
-		     " %s from TransportID\n",
+	target_debug("SPC-3 PR REGISTER_AND_MOVE: Found %s dest_node_acl: %s from TransportID\n",
 		     dest_tf_ops->fabric_name, dest_node_acl->initiatorname);
 
 	/*
@@ -3355,8 +3263,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	 */
 	dest_se_deve = core_get_se_deve_from_rtpi(dest_node_acl, rtpi);
 	if (!dest_se_deve) {
-		target_err("Unable to locate %s dest_se_deve from RTPI:"
-			   " %hu\n",
+		target_err("Unable to locate %s dest_se_deve from RTPI: %hu\n",
 			   dest_tf_ops->fabric_name, rtpi);
 		ret = TCM_INVALID_PARAMETER_LIST;
 		goto out;
@@ -3370,8 +3277,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 		goto out;
 	}
 
-	target_debug("SPC-3 PR REGISTER_AND_MOVE: Located %s node %s LUN"
-		     " ACL for dest_se_deve->mapped_lun: %llu\n",
+	target_debug("SPC-3 PR REGISTER_AND_MOVE: Located %s node %s LUN ACL for dest_se_deve->mapped_lun: %llu\n",
 		     dest_tf_ops->fabric_name, dest_node_acl->initiatorname,
 		     dest_se_deve->mapped_lun);
 
@@ -3382,8 +3288,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	spin_lock(&dev->dev_reservation_lock);
 	pr_res_holder = dev->dev_pr_res_holder;
 	if (!pr_res_holder) {
-		target_warn("SPC-3 PR REGISTER_AND_MOVE: No reservation"
-			    " currently held\n");
+		target_warn("SPC-3 PR REGISTER_AND_MOVE: No reservation currently held\n");
 		spin_unlock(&dev->dev_reservation_lock);
 		ret = TCM_INVALID_CDB_FIELD;
 		goto out;
@@ -3395,8 +3300,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	 * 	Register behaviors for a REGISTER AND MOVE service action
 	 */
 	if (!is_reservation_holder(pr_res_holder, pr_reg)) {
-		target_warn("SPC-3 PR REGISTER_AND_MOVE: Calling I_T"
-			    " Nexus is not reservation holder\n");
+		target_warn("SPC-3 PR REGISTER_AND_MOVE: Calling I_T Nexus is not reservation holder\n");
 		spin_unlock(&dev->dev_reservation_lock);
 		ret = TCM_RESERVATION_CONFLICT;
 		goto out;
@@ -3412,8 +3316,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 	 */
 	if ((pr_res_holder->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_ALLREG) ||
 	    (pr_res_holder->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_ALLREG)) {
-		target_warn("SPC-3 PR REGISTER_AND_MOVE: Unable to move"
-			    " reservation for type: %s\n",
+		target_warn("SPC-3 PR REGISTER_AND_MOVE: Unable to move reservation for type: %s\n",
 			    core_scsi3_pr_dump_type(pr_res_holder->pr_res_type));
 		spin_unlock(&dev->dev_reservation_lock);
 		ret = TCM_RESERVATION_CONFLICT;
@@ -3489,13 +3392,10 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
 		dest_pr_reg->pr_res_generation = pr_tmpl->pr_generation++;
 	spin_unlock(&dev->dev_reservation_lock);
 
-	target_debug("SPC-3 PR [%s] Service Action: REGISTER_AND_MOVE"
-		     " created new reservation holder TYPE: %s on object RTPI:"
-		     " %hu  PRGeneration: 0x%08x\n",
+	target_debug("SPC-3 PR [%s] Service Action: REGISTER_AND_MOVE created new reservation holder TYPE: %s on object RTPI: %hu  PRGeneration: 0x%08x\n",
 		     dest_tf_ops->fabric_name, core_scsi3_pr_dump_type(type), rtpi,
 		     dest_pr_reg->pr_res_generation);
-	target_debug("SPC-3 PR Successfully moved reservation from"
-		     " %s Fabric Node: %s%s -> %s Fabric Node: %s %s\n",
+	target_debug("SPC-3 PR Successfully moved reservation from %s Fabric Node: %s%s -> %s Fabric Node: %s %s\n",
 		     tf_ops->fabric_name, pr_reg_nacl->initiatorname, i_buf,
 		     dest_tf_ops->fabric_name, dest_node_acl->initiatorname,
 		     (iport_ptr != NULL) ? iport_ptr : "");
@@ -3590,9 +3490,7 @@ target_scsi3_emulate_pr_out(struct se_cmd *cmd)
 	 * CONFLICT status.
 	 */
 	if (cmd->se_dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) {
-		target_err("Received PERSISTENT_RESERVE CDB while legacy"
-			   " SPC-2 reservation is held, returning"
-			   " RESERVATION_CONFLICT\n");
+		target_err("Received PERSISTENT_RESERVE CDB while legacy SPC-2 reservation is held, returning RESERVATION_CONFLICT\n");
 		return TCM_RESERVATION_CONFLICT;
 	}
 
@@ -3604,8 +3502,7 @@ target_scsi3_emulate_pr_out(struct se_cmd *cmd)
 		return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
 
 	if (cmd->data_length < 24) {
-		target_warn("SPC-PR: Received PR OUT parameter list"
-			    " length too small: %u\n",
+		target_warn("SPC-PR: Received PR OUT parameter list length too small: %u\n",
 			    cmd->data_length);
 		return TCM_PARAMETER_LIST_LENGTH_ERROR;
 	}
@@ -3665,8 +3562,7 @@ target_scsi3_emulate_pr_out(struct se_cmd *cmd)
 	 */
 	if (!spec_i_pt && (sa != PRO_REGISTER_AND_MOVE) &&
 	    (cmd->data_length != 24)) {
-		target_warn("SPC-PR: Received PR OUT illegal parameter"
-			    " list length: %u\n",
+		target_warn("SPC-PR: Received PR OUT illegal parameter list length: %u\n",
 			    cmd->data_length);
 		return TCM_PARAMETER_LIST_LENGTH_ERROR;
 	}
@@ -3713,9 +3609,7 @@ target_scsi3_emulate_pr_out(struct se_cmd *cmd)
 				sa_res_key, aptpl, unreg);
 		break;
 	default:
-		target_err("Unknown PERSISTENT_RESERVE_OUT service"
-			   " action: 0x%02x\n",
-			   sa);
+		target_err("Unknown PERSISTENT_RESERVE_OUT service action: 0x%02x\n", sa);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -3739,9 +3633,7 @@ core_scsi3_pri_read_keys(struct se_cmd *cmd)
 	u32 add_len = 0, off = 8;
 
 	if (cmd->data_length < 8) {
-		target_err("PRIN SA READ_KEYS SCSI Data Length: %u"
-			   " too small\n",
-			   cmd->data_length);
+		target_err("PRIN SA READ_KEYS SCSI Data Length: %u too small\n", cmd->data_length);
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -3795,8 +3687,7 @@ core_scsi3_pri_read_reservation(struct se_cmd *cmd)
 	u32 add_len = 0;
 
 	if (cmd->data_length < 8) {
-		target_err("PRIN SA READ_RESERVATIONS SCSI Data Length: %u"
-			   " too small\n",
+		target_err("PRIN SA READ_RESERVATIONS SCSI Data Length: %u too small\n",
 			   cmd->data_length);
 		return TCM_INVALID_CDB_FIELD;
 	}
@@ -3872,8 +3763,7 @@ core_scsi3_pri_report_capabilities(struct se_cmd *cmd)
 	u16 len = 8; /* Hardcoded to 8. */
 
 	if (cmd->data_length < 6) {
-		target_err("PRIN SA REPORT_CAPABILITIES SCSI Data Length:"
-			   " %u too small\n",
+		target_err("PRIN SA REPORT_CAPABILITIES SCSI Data Length: %u too small\n",
 			   cmd->data_length);
 		return TCM_INVALID_CDB_FIELD;
 	}
@@ -3939,8 +3829,7 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
 	bool all_reg = false;
 
 	if (cmd->data_length < 8) {
-		target_err("PRIN SA READ_FULL_STATUS SCSI Data Length: %u"
-			   " too small\n",
+		target_err("PRIN SA READ_FULL_STATUS SCSI Data Length: %u too small\n",
 			   cmd->data_length);
 		return TCM_INVALID_CDB_FIELD;
 	}
@@ -3982,8 +3871,7 @@ core_scsi3_pri_read_full_status(struct se_cmd *cmd)
 					&format_code);
 		if (exp_desc_len < 0 ||
 		    exp_desc_len + add_len > cmd->data_length) {
-			target_warn("SPC-3 PRIN READ_FULL_STATUS ran"
-				    " out of buffer: %d\n",
+			target_warn("SPC-3 PRIN READ_FULL_STATUS ran out of buffer: %d\n",
 				    cmd->data_length);
 			spin_lock(&pr_tmpl->registration_lock);
 			atomic_dec_mb(&pr_reg->pr_res_holders);
@@ -4129,9 +4017,7 @@ target_scsi3_emulate_pr_in(struct se_cmd *cmd)
 	 * CONFLICT status.
 	 */
 	if (cmd->se_dev->dev_reservation_flags & DRF_SPC2_RESERVATIONS) {
-		target_err("Received PERSISTENT_RESERVE CDB while legacy"
-			   " SPC-2 reservation is held, returning"
-			   " RESERVATION_CONFLICT\n");
+		target_err("Received PERSISTENT_RESERVE CDB while legacy SPC-2 reservation is held, returning RESERVATION_CONFLICT\n");
 		return TCM_RESERVATION_CONFLICT;
 	}
 
@@ -4154,8 +4040,7 @@ target_scsi3_emulate_pr_in(struct se_cmd *cmd)
 		ret = core_scsi3_pri_read_full_status(cmd);
 		break;
 	default:
-		target_err("Unknown PERSISTENT_RESERVE_IN service"
-			   " action: 0x%02x\n",
+		target_err("Unknown PERSISTENT_RESERVE_IN service action: 0x%02x\n",
 			   cmd->t_task_cdb[1] & 0x1f);
 		return TCM_INVALID_CDB_FIELD;
 	}
diff --git a/drivers/target/target_core_pscsi.c b/drivers/target/target_core_pscsi.c
index a697993dbfaa..25288d8b82c8 100644
--- a/drivers/target/target_core_pscsi.c
+++ b/drivers/target/target_core_pscsi.c
@@ -60,8 +60,7 @@ static int pscsi_attach_hba(struct se_hba *hba, u32 host_id)
 
 	hba->hba_ptr = phv;
 
-	target_debug("CORE_HBA[%d] - TCM SCSI HBA Driver %s on"
-		     " Generic Target Core Stack %s\n",
+	target_debug("CORE_HBA[%d] - TCM SCSI HBA Driver %s on Generic Target Core Stack %s\n",
 		     hba->hba_id, PSCSI_VERSION, TARGET_CORE_VERSION);
 	target_debug("CORE_HBA[%d] - Attached SCSI HBA to Generic\n", hba->hba_id);
 
@@ -76,13 +75,11 @@ static void pscsi_detach_hba(struct se_hba *hba)
 	if (scsi_host) {
 		scsi_host_put(scsi_host);
 
-		target_debug("CORE_HBA[%d] - Detached SCSI HBA: %s from"
-			     " Generic Target Core\n",
+		target_debug("CORE_HBA[%d] - Detached SCSI HBA: %s from Generic Target Core\n",
 			     hba->hba_id,
 			     (scsi_host->hostt->name) ? (scsi_host->hostt->name) : "Unknown");
 	} else
-		target_debug("CORE_HBA[%d] - Detached Virtual SCSI HBA"
-			     " from Generic Target Core\n",
+		target_debug("CORE_HBA[%d] - Detached Virtual SCSI HBA from Generic Target Core\n",
 			     hba->hba_id);
 
 	kfree(phv);
@@ -103,9 +100,8 @@ static int pscsi_pmode_enable_hba(struct se_hba *hba, unsigned long mode_flag)
 		phv->phv_lld_host = NULL;
 		phv->phv_mode = PHV_VIRTUAL_HOST_ID;
 
-		target_debug("CORE_HBA[%d] - Disabled pSCSI HBA Passthrough"
-			     " %s\n",
-			     hba->hba_id, (sh->hostt->name) ? (sh->hostt->name) : "Unknown");
+		target_debug("CORE_HBA[%d] - Disabled pSCSI HBA Passthrough %s\n", hba->hba_id,
+			     (sh->hostt->name) ? (sh->hostt->name) : "Unknown");
 
 		scsi_host_put(sh);
 		return 0;
@@ -116,8 +112,7 @@ static int pscsi_pmode_enable_hba(struct se_hba *hba, unsigned long mode_flag)
 	 */
 	sh = scsi_host_lookup(phv->phv_host_id);
 	if (!sh) {
-		target_err("pSCSI: Unable to locate SCSI Host for"
-			   " phv_host_id: %d\n",
+		target_err("pSCSI: Unable to locate SCSI Host for phv_host_id: %d\n",
 			   phv->phv_host_id);
 		return -EINVAL;
 	}
@@ -241,16 +236,14 @@ pscsi_get_inquiry_vpd_device_ident(struct scsi_device *sdev,
 		page_83 = &buf[off];
 		ident_len = page_83[3];
 		if (!ident_len) {
-			target_err("page_83[3]: identifier"
-				   " length zero!\n");
+			target_err("page_83[3]: identifier length zero!\n");
 			break;
 		}
 		target_debug("T10 VPD Identifier Length: %d\n", ident_len);
 
 		vpd = kzalloc(sizeof(struct t10_vpd), GFP_KERNEL);
 		if (!vpd) {
-			target_err("Unable to allocate memory for"
-				   " struct t10_vpd\n");
+			target_err("Unable to allocate memory for struct t10_vpd\n");
 			goto out;
 		}
 		INIT_LIST_HEAD(&vpd->vpd_list);
@@ -291,9 +284,8 @@ static int pscsi_add_device_to_list(struct se_device *dev,
 	if (!sd->queue_depth) {
 		sd->queue_depth = PSCSI_DEFAULT_QUEUEDEPTH;
 
-		target_err("Set broken SCSI Device %d:%d:%llu"
-			   " queue_depth to %d\n",
-			   sd->channel, sd->id, sd->lun, sd->queue_depth);
+		target_err("Set broken SCSI Device %d:%d:%llu queue_depth to %d\n", sd->channel,
+			   sd->id, sd->lun, sd->queue_depth);
 	}
 
 	dev->dev_attrib.hw_block_size =
@@ -431,8 +423,7 @@ static int pscsi_configure_device(struct se_device *dev)
 	if (!(pdv->pdv_flags & PDF_HAS_CHANNEL_ID) ||
 	    !(pdv->pdv_flags & PDF_HAS_TARGET_ID) ||
 	    !(pdv->pdv_flags & PDF_HAS_LUN_ID)) {
-		target_err("Missing scsi_channel_id=, scsi_target_id= and"
-			   " scsi_lun_id= parameters\n");
+		target_err("Missing scsi_channel_id=, scsi_target_id= and scsi_lun_id= parameters\n");
 		return -EINVAL;
 	}
 
@@ -442,8 +433,7 @@ static int pscsi_configure_device(struct se_device *dev)
 	 */
 	if (!sh) {
 		if (phv->phv_mode == PHV_LLD_SCSI_HOST_NO) {
-			target_err("pSCSI: Unable to locate struct"
-				   " Scsi_Host for PHV_LLD_SCSI_HOST_NO\n");
+			target_err("pSCSI: Unable to locate struct Scsi_Host for PHV_LLD_SCSI_HOST_NO\n");
 			return -ENODEV;
 		}
 		/*
@@ -451,8 +441,7 @@ static int pscsi_configure_device(struct se_device *dev)
 		 * reference, we enforce that udev_path has been set
 		 */
 		if (!(dev->dev_flags & DF_USING_UDEV_PATH)) {
-			target_err("pSCSI: udev_path attribute has not"
-				   " been set before ENABLE=1\n");
+			target_err("pSCSI: udev_path attribute has not been set before ENABLE=1\n");
 			return -EINVAL;
 		}
 		/*
@@ -462,8 +451,7 @@ static int pscsi_configure_device(struct se_device *dev)
 		 */
 		if (!(pdv->pdv_flags & PDF_HAS_VIRT_HOST_ID)) {
 			if (hba->dev_count) {
-				target_err("pSCSI: Unable to set hba_mode"
-					   " with active devices\n");
+				target_err("pSCSI: Unable to set hba_mode with active devices\n");
 				return -EEXIST;
 			}
 
@@ -476,8 +464,7 @@ static int pscsi_configure_device(struct se_device *dev)
 		} else {
 			sh = scsi_host_lookup(pdv->pdv_host_id);
 			if (!sh) {
-				target_err("pSCSI: Unable to locate"
-					   " pdv_host_id: %d\n",
+				target_err("pSCSI: Unable to locate pdv_host_id: %d\n",
 					   pdv->pdv_host_id);
 				return -EINVAL;
 			}
@@ -485,8 +472,7 @@ static int pscsi_configure_device(struct se_device *dev)
 		}
 	} else {
 		if (phv->phv_mode == PHV_VIRTUAL_HOST_ID) {
-			target_err("pSCSI: PHV_VIRTUAL_HOST_ID set while"
-				   " struct Scsi_Host exists\n");
+			target_err("pSCSI: PHV_VIRTUAL_HOST_ID set while struct Scsi_Host exists\n");
 			return -EEXIST;
 		}
 	}
@@ -731,9 +717,7 @@ static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
 		switch (token) {
 		case Opt_scsi_host_id:
 			if (phv->phv_mode == PHV_LLD_SCSI_HOST_NO) {
-				target_err("PSCSI[%d]: Unable to accept"
-					   " scsi_host_id while phv_mode =="
-					   " PHV_LLD_SCSI_HOST_NO\n",
+				target_err("PSCSI[%d]: Unable to accept scsi_host_id while phv_mode == PHV_LLD_SCSI_HOST_NO\n",
 					   phv->phv_host_id);
 				ret = -EINVAL;
 				goto out;
@@ -742,9 +726,8 @@ static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
 			if (ret)
 				goto out;
 			pdv->pdv_host_id = arg;
-			target_debug("PSCSI[%d]: Referencing SCSI Host ID:"
-				     " %d\n",
-				     phv->phv_host_id, pdv->pdv_host_id);
+			target_debug("PSCSI[%d]: Referencing SCSI Host ID: %d\n", phv->phv_host_id,
+				     pdv->pdv_host_id);
 			pdv->pdv_flags |= PDF_HAS_VIRT_HOST_ID;
 			break;
 		case Opt_scsi_channel_id:
@@ -752,8 +735,7 @@ static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
 			if (ret)
 				goto out;
 			pdv->pdv_channel_id = arg;
-			target_debug("PSCSI[%d]: Referencing SCSI Channel"
-				     " ID: %d\n",
+			target_debug("PSCSI[%d]: Referencing SCSI Channel ID: %d\n",
 				     phv->phv_host_id, pdv->pdv_channel_id);
 			pdv->pdv_flags |= PDF_HAS_CHANNEL_ID;
 			break;
@@ -762,8 +744,7 @@ static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
 			if (ret)
 				goto out;
 			pdv->pdv_target_id = arg;
-			target_debug("PSCSI[%d]: Referencing SCSI Target"
-				     " ID: %d\n",
+			target_debug("PSCSI[%d]: Referencing SCSI Target ID: %d\n",
 				     phv->phv_host_id, pdv->pdv_target_id);
 			pdv->pdv_flags |= PDF_HAS_TARGET_ID;
 			break;
@@ -772,9 +753,8 @@ static ssize_t pscsi_set_configfs_dev_params(struct se_device *dev,
 			if (ret)
 				goto out;
 			pdv->pdv_lun_id = arg;
-			target_debug("PSCSI[%d]: Referencing SCSI LUN ID:"
-				     " %d\n",
-				     phv->phv_host_id, pdv->pdv_lun_id);
+			target_debug("PSCSI[%d]: Referencing SCSI LUN ID: %d\n", phv->phv_host_id,
+				     pdv->pdv_lun_id);
 			pdv->pdv_flags |= PDF_HAS_LUN_ID;
 			break;
 		default:
@@ -868,13 +848,11 @@ pscsi_map_sg(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
 					 rw ? REQ_OP_WRITE : REQ_OP_READ);
 				bio->bi_end_io = pscsi_bi_endio;
 
-				target_debug("PSCSI: Allocated bio: %p,"
-					     " dir: %s nr_vecs: %d\n",
-					     bio, (rw) ? "rw" : "r", nr_vecs);
+				target_debug("PSCSI: Allocated bio: %p, dir: %s nr_vecs: %d\n", bio,
+					     (rw) ? "rw" : "r", nr_vecs);
 			}
 
-			target_debug("PSCSI: Calling bio_add_pc_page() i: %d"
-				     " bio: %p page: %p len: %d off: %d\n",
+			target_debug("PSCSI: Calling bio_add_pc_page() i: %d bio: %p page: %p len: %d off: %d\n",
 				     i, bio, page, len, off);
 
 			rc = bio_add_pc_page(pdv->pdv_sd->request_queue,
@@ -882,9 +860,7 @@ pscsi_map_sg(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
 			target_debug("PSCSI: bio->bi_vcnt: %d nr_vecs: %d\n", bio_segments(bio),
 				     nr_vecs);
 			if (rc != bytes) {
-				target_debug("PSCSI: Reached bio->bi_vcnt max:"
-					     " %d i: %d bio: %p, allocating another"
-					     " bio\n",
+				target_debug("PSCSI: Reached bio->bi_vcnt max: %d i: %d bio: %p, allocating another bio\n",
 					     bio->bi_vcnt, i, bio);
 
 				rc = blk_rq_append_bio(req, bio);
@@ -1015,8 +991,7 @@ static enum rq_end_io_ret pscsi_req_done(struct request *req,
 	u8 *cdb = cmd->priv;
 
 	if (scsi_status != SAM_STAT_GOOD) {
-		target_debug("PSCSI Status Byte exception at cmd: %p CDB:"
-			     " 0x%02x Result: 0x%08x\n",
+		target_debug("PSCSI Status Byte exception at cmd: %p CDB: 0x%02x Result: 0x%08x\n",
 			     cmd, cdb[0], scmd->result);
 	}
 
@@ -1027,8 +1002,7 @@ static enum rq_end_io_ret pscsi_req_done(struct request *req,
 		target_complete_cmd_with_length(cmd, scsi_status, valid_data);
 		break;
 	default:
-		target_debug("PSCSI Host Byte exception at cmd: %p CDB:"
-			     " 0x%02x Result: 0x%08x\n",
+		target_debug("PSCSI Host Byte exception at cmd: %p CDB: 0x%02x Result: 0x%08x\n",
 			     cmd, cdb[0], scmd->result);
 		target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
 		break;
diff --git a/drivers/target/target_core_rd.c b/drivers/target/target_core_rd.c
index 7d83a4ed93da..974b6527f1ce 100644
--- a/drivers/target/target_core_rd.c
+++ b/drivers/target/target_core_rd.c
@@ -42,8 +42,7 @@ static int rd_attach_hba(struct se_hba *hba, u32 host_id)
 
 	hba->hba_ptr = rd_host;
 
-	target_debug("CORE_HBA[%d] - TCM Ramdisk HBA Driver %s on"
-		     " Generic Target Core Stack %s\n",
+	target_debug("CORE_HBA[%d] - TCM Ramdisk HBA Driver %s on Generic Target Core Stack %s\n",
 		     hba->hba_id, RD_HBA_VERSION, TARGET_CORE_VERSION);
 
 	return 0;
@@ -53,8 +52,7 @@ static void rd_detach_hba(struct se_hba *hba)
 {
 	struct rd_host *rd_host = hba->hba_ptr;
 
-	target_debug("CORE_HBA[%d] - Detached Ramdisk HBA: %u from"
-		     " Generic Target Core\n",
+	target_debug("CORE_HBA[%d] - Detached Ramdisk HBA: %u from Generic Target Core\n",
 		     hba->hba_id, rd_host->rd_host_id);
 
 	kfree(rd_host);
@@ -96,8 +94,7 @@ static void rd_release_device_space(struct rd_dev *rd_dev)
 	page_count = rd_release_sgl_table(rd_dev, rd_dev->sg_table_array,
 					  rd_dev->sg_table_count);
 
-	target_debug("CORE_RD[%u] - Released device space for Ramdisk"
-		     " Device ID: %u, pages %u in %u tables total bytes %lu\n",
+	target_debug("CORE_RD[%u] - Released device space for Ramdisk Device ID: %u, pages %u in %u tables total bytes %lu\n",
 		     rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, page_count,
 		     rd_dev->sg_table_count, (unsigned long)page_count * PAGE_SIZE);
 
@@ -153,8 +150,7 @@ static int rd_allocate_sgl_table(struct rd_dev *rd_dev, struct rd_dev_sg_table *
 		for (j = 0; j < sg_per_table; j++) {
 			pg = alloc_pages(GFP_KERNEL, 0);
 			if (!pg) {
-				target_err("Unable to allocate scatterlist"
-					   " pages for struct rd_dev_sg_table\n");
+				target_err("Unable to allocate scatterlist pages for struct rd_dev_sg_table\n");
 				return -ENOMEM;
 			}
 			sg_assign_page(&sg[j], pg);
@@ -203,8 +199,7 @@ static int rd_build_device_space(struct rd_dev *rd_dev)
 	if (rc)
 		return rc;
 
-	target_debug("CORE_RD[%u] - Built Ramdisk Device ID: %u space of"
-		     " %u pages in %u tables\n",
+	target_debug("CORE_RD[%u] - Built Ramdisk Device ID: %u space of %u pages in %u tables\n",
 		     rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, rd_dev->rd_page_count,
 		     rd_dev->sg_table_count);
 
@@ -221,8 +216,7 @@ static void rd_release_prot_space(struct rd_dev *rd_dev)
 	page_count = rd_release_sgl_table(rd_dev, rd_dev->sg_prot_array,
 					  rd_dev->sg_prot_count);
 
-	target_debug("CORE_RD[%u] - Released protection space for Ramdisk"
-		     " Device ID: %u, pages %u in %u tables total bytes %lu\n",
+	target_debug("CORE_RD[%u] - Released protection space for Ramdisk Device ID: %u, pages %u in %u tables total bytes %lu\n",
 		     rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, page_count,
 		     rd_dev->sg_table_count, (unsigned long)page_count * PAGE_SIZE);
 
@@ -260,8 +254,7 @@ static int rd_build_prot_space(struct rd_dev *rd_dev, int prot_length, int block
 	if (rc)
 		return rc;
 
-	target_debug("CORE_RD[%u] - Built Ramdisk Device ID: %u prot space of"
-		     " %u pages in %u tables\n",
+	target_debug("CORE_RD[%u] - Built Ramdisk Device ID: %u prot space of %u pages in %u tables\n",
 		     rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, total_sg_needed,
 		     rd_dev->sg_prot_count);
 
@@ -304,8 +297,7 @@ static int rd_configure_device(struct se_device *dev)
 
 	rd_dev->rd_dev_id = rd_host->rd_host_dev_id_count++;
 
-	target_debug("CORE_RD[%u] - Added TCM MEMCPY Ramdisk Device ID: %u of"
-		     " %u pages in %u tables, %lu total bytes\n",
+	target_debug("CORE_RD[%u] - Added TCM MEMCPY Ramdisk Device ID: %u of %u pages in %u tables, %lu total bytes\n",
 		     rd_host->rd_host_id, rd_dev->rd_dev_id, rd_dev->rd_page_count,
 		     rd_dev->sg_table_count, (unsigned long)(rd_dev->rd_page_count * PAGE_SIZE));
 
@@ -471,8 +463,7 @@ rd_execute_rw(struct se_cmd *cmd, struct scatterlist *sgl, u32 sgl_nents,
 		}
 		len = min((u32)m.length, src_len);
 		if (len > rd_size) {
-			target_debug("RD[%u]: size underrun page %d offset %d "
-				     "size %d\n",
+			target_debug("RD[%u]: size underrun page %d offset %d size %d\n",
 				     dev->rd_dev_id, rd_page, rd_offset, rd_size);
 			len = rd_size;
 		}
@@ -560,8 +551,7 @@ static ssize_t rd_set_configfs_dev_params(struct se_device *dev,
 		case Opt_rd_pages:
 			match_int(args, &arg);
 			rd_dev->rd_page_count = arg;
-			target_debug("RAMDISK: Referencing Page"
-				     " Count: %u\n",
+			target_debug("RAMDISK: Referencing Page Count: %u\n",
 				     rd_dev->rd_page_count);
 			rd_dev->rd_flags |= RDF_HAS_PAGE_COUNT;
 			break;
diff --git a/drivers/target/target_core_sbc.c b/drivers/target/target_core_sbc.c
index 8c4bb62e96fc..20756a92a2af 100644
--- a/drivers/target/target_core_sbc.c
+++ b/drivers/target/target_core_sbc.c
@@ -280,9 +280,7 @@ sbc_setup_write_same(struct se_cmd *cmd, unsigned char flags,
 	sense_reason_t ret;
 
 	if ((flags & 0x04) || (flags & 0x02)) {
-		target_err("WRITE_SAME PBDATA and LBDATA"
-			   " bits not supported for Block Discard"
-			   " Emulation\n");
+		target_err("WRITE_SAME PBDATA and LBDATA bits not supported for Block Discard Emulation\n");
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 	if (sectors > cmd->se_dev->dev_attrib.max_write_same_len) {
@@ -320,8 +318,7 @@ sbc_setup_write_same(struct se_cmd *cmd, unsigned char flags,
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 
 		if (!dev->dev_attrib.emulate_tpws) {
-			target_err("Got WRITE_SAME w/ UNMAP=1, but backend device"
-				   " has emulate_tpws disabled\n");
+			target_err("Got WRITE_SAME w/ UNMAP=1, but backend device has emulate_tpws disabled\n");
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		}
 		cmd->execute_cmd = sbc_execute_write_same_unmap;
@@ -472,8 +469,7 @@ static sense_reason_t compare_and_write_callback(struct se_cmd *cmd, bool succes
 	 * been failed with a non-zero SCSI status.
 	 */
 	if (cmd->scsi_status) {
-		target_debug("compare_and_write_callback: non zero scsi_status:"
-			     " 0x%02x\n",
+		target_debug("compare_and_write_callback: non zero scsi_status: 0x%02x\n",
 			     cmd->scsi_status);
 		*post_ret = 1;
 		if (cmd->scsi_status == SAM_STAT_CHECK_CONDITION)
@@ -674,8 +670,7 @@ sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char protect,
 	if (!cmd->t_prot_sg || !cmd->t_prot_nents) {
 		if (unlikely(protect &&
 		    !dev->dev_attrib.pi_prot_type && !cmd->se_sess->sess_prot_type)) {
-			target_err("CDB contains protect bit, but device + fabric does"
-				   " not advertise PROTECT=1 feature bit\n");
+			target_err("CDB contains protect bit, but device + fabric does not advertise PROTECT=1 feature bit\n");
 			return TCM_INVALID_CDB_FIELD;
 		}
 		if (cmd->prot_pto)
@@ -713,8 +708,7 @@ sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char protect,
 			return TCM_NO_SENSE;
 		fallthrough;
 	default:
-		target_err("Unable to determine pi_prot_type for CDB: 0x%02x "
-			   "PROTECT: 0x%02x\n",
+		target_err("Unable to determine pi_prot_type for CDB: 0x%02x PROTECT: 0x%02x\n",
 			   cmd->t_task_cdb[0], protect);
 		return TCM_INVALID_CDB_FIELD;
 	}
@@ -734,8 +728,7 @@ sbc_check_prot(struct se_device *dev, struct se_cmd *cmd, unsigned char protect,
 	if (protect)
 		cmd->data_length = sectors * dev->dev_attrib.block_size;
 
-	target_debug("%s: prot_type=%d, data_length=%d, prot_length=%d "
-		     "prot_op=%d prot_checks=%d\n",
+	target_debug("%s: prot_type=%d, data_length=%d, prot_length=%d prot_op=%d prot_checks=%d\n",
 		     __func__, cmd->prot_type, cmd->data_length, cmd->prot_length, cmd->prot_op,
 		     cmd->prot_checks);
 
@@ -748,16 +741,14 @@ sbc_check_dpofua(struct se_device *dev, struct se_cmd *cmd, unsigned char *cdb)
 	if (cdb[1] & 0x10) {
 		/* see explanation in spc_emulate_modesense */
 		if (!target_check_fua(dev)) {
-			target_err("Got CDB: 0x%02x with DPO bit set, but device"
-				   " does not advertise support for DPO\n",
+			target_err("Got CDB: 0x%02x with DPO bit set, but device does not advertise support for DPO\n",
 				   cdb[0]);
 			return -EINVAL;
 		}
 	}
 	if (cdb[1] & 0x8) {
 		if (!target_check_fua(dev)) {
-			target_err("Got CDB: 0x%02x with FUA bit set, but device"
-				   " does not advertise support for FUA write\n",
+			target_err("Got CDB: 0x%02x with FUA bit set, but device does not advertise support for FUA write\n",
 				   cdb[0]);
 			return -EINVAL;
 		}
@@ -883,8 +874,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)
 		case WRITE_SAME_32:
 			sectors = transport_get_sectors_32(cdb);
 			if (!sectors) {
-				target_err("WSNZ=1, WRITE_SAME w/sectors=0 not"
-					   " supported\n");
+				target_err("WSNZ=1, WRITE_SAME w/sectors=0 not supported\n");
 				return TCM_INVALID_CDB_FIELD;
 			}
 
@@ -896,8 +886,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)
 				return ret;
 			break;
 		default:
-			target_err("VARIABLE_LENGTH_CMD service action"
-				   " 0x%04x not supported\n",
+			target_err("VARIABLE_LENGTH_CMD service action 0x%04x not supported\n",
 				   service_action);
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		}
@@ -916,9 +905,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)
 		 * Currently enforce COMPARE_AND_WRITE for a single sector
 		 */
 		if (sectors > 1) {
-			target_err("COMPARE_AND_WRITE contains NoLB: %u greater"
-				   " than 1\n",
-				   sectors);
+			target_err("COMPARE_AND_WRITE contains NoLB: %u greater than 1\n", sectors);
 			return TCM_INVALID_CDB_FIELD;
 		}
 		if (sbc_check_dpofua(dev, cmd, cdb))
@@ -974,8 +961,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 
 		if (!dev->dev_attrib.emulate_tpu) {
-			target_err("Got UNMAP, but backend device has"
-				   " emulate_tpu disabled\n");
+			target_err("Got UNMAP, but backend device has emulate_tpu disabled\n");
 			return TCM_UNSUPPORTED_SCSI_OPCODE;
 		}
 		size = get_unaligned_be16(&cdb[7]);
@@ -1057,9 +1043,8 @@ sbc_parse_cdb(struct se_cmd *cmd, struct exec_cmd_ops *ops)
 		end_lba = dev->transport->get_blocks(dev) + 1;
 		if (((cmd->t_task_lba + sectors) < cmd->t_task_lba) ||
 		    ((cmd->t_task_lba + sectors) > end_lba)) {
-			target_err("cmd exceeds last lba %llu "
-				   "(lba %llu, sectors %u)\n",
-				   end_lba, cmd->t_task_lba, sectors);
+			target_err("cmd exceeds last lba %llu (lba %llu, sectors %u)\n", end_lba,
+				   cmd->t_task_lba, sectors);
 			return TCM_ADDRESS_OUT_OF_RANGE;
 		}
 
@@ -1124,8 +1109,7 @@ sbc_execute_unmap(struct se_cmd *cmd)
 
 	/* First UNMAP block descriptor starts at 8 byte offset */
 	ptr = &buf[8];
-	target_debug("UNMAP: Sub: %s Using dl: %u bd_dl: %u size: %u"
-		     " ptr: %p\n",
+	target_debug("UNMAP: Sub: %s Using dl: %u bd_dl: %u size: %u ptr: %p\n",
 		     dev->transport->name, dl, bd_dl, size, ptr);
 
 	while (size >= 16) {
@@ -1214,8 +1198,7 @@ sbc_dif_generate(struct se_cmd *cmd)
 				sdt->ref_tag = cpu_to_be32(sector & 0xffffffff);
 			sdt->app_tag = 0;
 
-			target_debug("DIF %s INSERT sector: %llu guard_tag: 0x%04x"
-				     " app_tag: 0x%04x ref_tag: %u\n",
+			target_debug("DIF %s INSERT sector: %llu guard_tag: 0x%04x app_tag: 0x%04x ref_tag: %u\n",
 				     (cmd->data_direction == DMA_TO_DEVICE) ? "WRITE" : "READ",
 				     (unsigned long long)sector, sdt->guard_tag, sdt->app_tag,
 				     be32_to_cpu(sdt->ref_tag));
@@ -1240,8 +1223,7 @@ sbc_dif_v1_verify(struct se_cmd *cmd, struct t10_pi_tuple *sdt,
 	csum = cpu_to_be16(crc);
 
 	if (sdt->guard_tag != csum) {
-		target_err("DIFv1 checksum failed on sector %llu guard tag 0x%04x"
-			   " csum 0x%04x\n",
+		target_err("DIFv1 checksum failed on sector %llu guard tag 0x%04x csum 0x%04x\n",
 			   (unsigned long long)sector, be16_to_cpu(sdt->guard_tag),
 			   be16_to_cpu(csum));
 		return TCM_LOGICAL_BLOCK_GUARD_CHECK_FAILED;
@@ -1253,8 +1235,7 @@ sbc_dif_v1_verify(struct se_cmd *cmd, struct t10_pi_tuple *sdt,
 
 	if (cmd->prot_type == TARGET_DIF_TYPE1_PROT &&
 	    be32_to_cpu(sdt->ref_tag) != (sector & 0xffffffff)) {
-		target_err("DIFv1 Type 1 reference failed on sector: %llu tag: 0x%08x"
-			   " sector MSB: 0x%08x\n",
+		target_err("DIFv1 Type 1 reference failed on sector: %llu tag: 0x%08x sector MSB: 0x%08x\n",
 			   (unsigned long long)sector, be32_to_cpu(sdt->ref_tag),
 			   (u32)(sector & 0xffffffff));
 		return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED;
@@ -1262,8 +1243,7 @@ sbc_dif_v1_verify(struct se_cmd *cmd, struct t10_pi_tuple *sdt,
 
 	if (cmd->prot_type == TARGET_DIF_TYPE2_PROT &&
 	    be32_to_cpu(sdt->ref_tag) != ei_lba) {
-		target_err("DIFv1 Type 2 reference failed on sector: %llu tag: 0x%08x"
-			   " ei_lba: 0x%08x\n",
+		target_err("DIFv1 Type 2 reference failed on sector: %llu tag: 0x%08x ei_lba: 0x%08x\n",
 			   (unsigned long long)sector, be32_to_cpu(sdt->ref_tag), ei_lba);
 		return TCM_LOGICAL_BLOCK_REF_TAG_CHECK_FAILED;
 	}
@@ -1353,8 +1333,7 @@ sbc_dif_verify(struct se_cmd *cmd, sector_t start, unsigned int sectors,
 
 			sdt = paddr + i;
 
-			target_debug("DIF READ sector: %llu guard_tag: 0x%04x"
-				     " app_tag: 0x%04x ref_tag: %u\n",
+			target_debug("DIF READ sector: %llu guard_tag: 0x%04x app_tag: 0x%04x ref_tag: %u\n",
 				     (unsigned long long)sector, sdt->guard_tag, sdt->app_tag,
 				     be32_to_cpu(sdt->ref_tag));
 
diff --git a/drivers/target/target_core_spc.c b/drivers/target/target_core_spc.c
index 7c5c117389cc..f8e6698eede1 100644
--- a/drivers/target/target_core_spc.c
+++ b/drivers/target/target_core_spc.c
@@ -62,8 +62,7 @@ spc_find_scsi_transport_vd(int proto_id)
 	case SCSI_PROTOCOL_SRP:
 		return SCSI_VERSION_DESCRIPTOR_SRP;
 	default:
-		target_warn("Cannot find VERSION DESCRIPTOR value for unknown SCSI"
-			    " transport PROTOCOL IDENTIFIER %#x\n",
+		target_warn("Cannot find VERSION DESCRIPTOR value for unknown SCSI transport PROTOCOL IDENTIFIER %#x\n",
 			    proto_id);
 		return 0;
 	}
@@ -1212,8 +1211,7 @@ static sense_reason_t spc_emulate_request_sense(struct se_cmd *cmd)
 	memset(buf, 0, SE_SENSE_BUF);
 
 	if (cdb[1] & 0x01) {
-		target_err("REQUEST_SENSE description emulation not"
-			   " supported\n");
+		target_err("REQUEST_SENSE description emulation not supported\n");
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -2125,8 +2123,7 @@ spc_rsoc_get_descr(struct se_cmd *cmd, struct target_opcode_descriptor **opcode)
 	*opcode = NULL;
 
 	if (opts > 3) {
-		target_debug("TARGET_CORE[%s]: Invalid REPORT SUPPORTED OPERATION CODES"
-			     " with unsupported REPORTING OPTIONS %#x for 0x%08llx from %s\n",
+		target_debug("TARGET_CORE[%s]: Invalid REPORT SUPPORTED OPERATION CODES with unsupported REPORTING OPTIONS %#x for 0x%08llx from %s\n",
 			     cmd->se_tfo->fabric_name, opts, cmd->se_lun->unpacked_lun,
 			     sess->se_node_acl->initiatorname);
 		return TCM_INVALID_CDB_FIELD;
diff --git a/drivers/target/target_core_tmr.c b/drivers/target/target_core_tmr.c
index aa1c099fa92e..09bc8afe5252 100644
--- a/drivers/target/target_core_tmr.c
+++ b/drivers/target/target_core_tmr.c
@@ -87,8 +87,7 @@ static bool __target_check_io_state(struct se_cmd *se_cmd,
 	 */
 	spin_lock(&se_cmd->t_state_lock);
 	if (se_cmd->transport_state & (CMD_T_COMPLETE | CMD_T_FABRIC_STOP)) {
-		target_debug("Attempted to abort io tag: %llu already complete or"
-			     " fabric stop, skipping\n",
+		target_debug("Attempted to abort io tag: %llu already complete or fabric stop, skipping\n",
 			     se_cmd->tag);
 		spin_unlock(&se_cmd->t_state_lock);
 		return false;
@@ -236,8 +235,7 @@ static void core_tmr_drain_tmr_list(
 		list_del_init(&tmr_p->tmr_list);
 		cmd = tmr_p->task_cmd;
 
-		target_debug("LUN_RESET: %s releasing TMR %p Function: 0x%02x,"
-			     " Response: 0x%02x, t_state: %d\n",
+		target_debug("LUN_RESET: %s releasing TMR %p Function: 0x%02x, Response: 0x%02x, t_state: %d\n",
 			     (preempt_and_abort_list) ? "Preempt" : "", tmr_p, tmr_p->function,
 			     tmr_p->response, cmd->t_state);
 
@@ -382,8 +380,7 @@ int core_tmr_lun_reset(
 		tmr_nacl = tmr_sess->se_node_acl;
 		tmr_tpg = tmr_sess->se_tpg;
 		if (tmr_nacl && tmr_tpg) {
-			target_debug("LUN_RESET: TMR caller fabric: %s"
-				     " initiator port %s\n",
+			target_debug("LUN_RESET: TMR caller fabric: %s initiator port %s\n",
 				     tmr_tpg->se_tpg_tfo->fabric_name, tmr_nacl->initiatorname);
 		}
 	}
diff --git a/drivers/target/target_core_tpg.c b/drivers/target/target_core_tpg.c
index 90d59ac5e4aa..9992714af597 100644
--- a/drivers/target/target_core_tpg.c
+++ b/drivers/target/target_core_tpg.c
@@ -134,8 +134,7 @@ void core_tpg_add_node_to_devs(
 				lun_access_ro = false;
 		}
 
-		target_debug("TARGET_CORE[%s]->TPG[%u]_LUN[%llu] - Adding %s"
-			     " access for LUN in Demo Mode\n",
+		target_debug("TARGET_CORE[%s]->TPG[%u]_LUN[%llu] - Adding %s access for LUN in Demo Mode\n",
 			     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
 			     lun->unpacked_lun, lun_access_ro ? "READ-ONLY" : "READ-WRITE");
 
@@ -159,8 +158,7 @@ target_set_nacl_queue_depth(struct se_portal_group *tpg,
 	acl->queue_depth = queue_depth;
 
 	if (!acl->queue_depth) {
-		target_warn("Queue depth for %s Initiator Node: %s is 0,"
-			    "defaulting to 1.\n",
+		target_warn("Queue depth for %s Initiator Node: %s is 0, defaulting to 1.\n",
 			    tpg->se_tpg_tfo->fabric_name, acl->initiatorname);
 		acl->queue_depth = 1;
 	}
@@ -209,8 +207,7 @@ static void target_add_node_acl(struct se_node_acl *acl)
 	list_add_tail(&acl->acl_list, &tpg->acl_node_list);
 	mutex_unlock(&tpg->acl_node_mutex);
 
-	target_debug("%s_TPG[%hu] - Added %s ACL with TCQ Depth: %d for %s"
-		     " Initiator Node: %s\n",
+	target_debug("%s_TPG[%hu] - Added %s ACL with TCQ Depth: %d for %s Initiator Node: %s\n",
 		     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
 		     acl->dynamic_node_acl ? "DYNAMIC" : "", acl->queue_depth,
 		     tpg->se_tpg_tfo->fabric_name, acl->initiatorname);
@@ -293,17 +290,14 @@ struct se_node_acl *core_tpg_add_initiator_node_acl(
 	if (acl) {
 		if (acl->dynamic_node_acl) {
 			acl->dynamic_node_acl = 0;
-			target_debug("%s_TPG[%u] - Replacing dynamic ACL"
-				     " for %s\n",
+			target_debug("%s_TPG[%u] - Replacing dynamic ACL for %s\n",
 				     tpg->se_tpg_tfo->fabric_name,
 				     tpg->se_tpg_tfo->tpg_get_tag(tpg), initiatorname);
 			mutex_unlock(&tpg->acl_node_mutex);
 			return acl;
 		}
 
-		target_err("ACL entry for %s Initiator"
-			   " Node %s already exists for TPG %u, ignoring"
-			   " request.\n",
+		target_err("ACL entry for %s Initiator Node %s already exists for TPG %u, ignoring request.\n",
 			   tpg->se_tpg_tfo->fabric_name, initiatorname,
 			   tpg->se_tpg_tfo->tpg_get_tag(tpg));
 		mutex_unlock(&tpg->acl_node_mutex);
@@ -362,8 +356,7 @@ void core_tpg_del_initiator_node_acl(struct se_node_acl *acl)
 	core_tpg_wait_for_nacl_pr_ref(acl);
 	core_free_device_list_for_node(acl, tpg);
 
-	target_debug("%s_TPG[%hu] - Deleted ACL with TCQ Depth: %d for %s"
-		     " Initiator Node: %s\n",
+	target_debug("%s_TPG[%hu] - Deleted ACL with TCQ Depth: %d for %s Initiator Node: %s\n",
 		     tpg->se_tpg_tfo->fabric_name, tpg->se_tpg_tfo->tpg_get_tag(tpg),
 		     acl->queue_depth, tpg->se_tpg_tfo->fabric_name, acl->initiatorname);
 
@@ -399,8 +392,7 @@ int core_tpg_set_initiator_node_queue_depth(
 	 */
 	target_shutdown_sessions(acl);
 
-	target_debug("Successfully changed queue depth to: %d for Initiator"
-		     " Node: %s on %s Target Portal Group: %u\n",
+	target_debug("Successfully changed queue depth to: %d for Initiator Node: %s on %s Target Portal Group: %u\n",
 		     acl->queue_depth, acl->initiatorname, tpg->se_tpg_tfo->fabric_name,
 		     tpg->se_tpg_tfo->tpg_get_tag(tpg));
 
@@ -550,8 +542,7 @@ int core_tpg_register(
 		}
 	}
 
-	target_debug("TARGET_CORE[%s]: Allocated portal_group for endpoint: %s, "
-		     "Proto: %d, Portal Tag: %u\n",
+	target_debug("TARGET_CORE[%s]: Allocated portal_group for endpoint: %s, Proto: %d, Portal Tag: %u\n",
 		     se_tpg->se_tpg_tfo->fabric_name,
 		     se_tpg->se_tpg_tfo->tpg_get_wwn(se_tpg) ?
 		     se_tpg->se_tpg_tfo->tpg_get_wwn(se_tpg) : NULL,
@@ -567,8 +558,7 @@ int core_tpg_deregister(struct se_portal_group *se_tpg)
 	struct se_node_acl *nacl, *nacl_tmp;
 	LIST_HEAD(node_list);
 
-	target_debug("TARGET_CORE[%s]: Deallocating portal_group for endpoint: %s, "
-		     "Proto: %d, Portal Tag: %u\n",
+	target_debug("TARGET_CORE[%s]: Deallocating portal_group for endpoint: %s, Proto: %d, Portal Tag: %u\n",
 		     tfo->fabric_name, tfo->tpg_get_wwn(se_tpg) ? tfo->tpg_get_wwn(se_tpg) : NULL,
 		     se_tpg->proto_id, tfo->tpg_get_tag(se_tpg));
 
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index 65a7d8fb52ec..4bfce006eefd 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -63,8 +63,7 @@ int init_se_kmem_caches(void)
 			sizeof(struct se_session), __alignof__(struct se_session),
 			0, NULL);
 	if (!se_sess_cache) {
-		target_err("kmem_cache_create() for struct se_session"
-			   " failed\n");
+		target_err("kmem_cache_create() for struct se_session failed\n");
 		goto out;
 	}
 	se_ua_cache = kmem_cache_create("se_ua_cache",
@@ -78,32 +77,28 @@ int init_se_kmem_caches(void)
 			sizeof(struct t10_pr_registration),
 			__alignof__(struct t10_pr_registration), 0, NULL);
 	if (!t10_pr_reg_cache) {
-		target_err("kmem_cache_create() for struct t10_pr_registration"
-			   " failed\n");
+		target_err("kmem_cache_create() for struct t10_pr_registration failed\n");
 		goto out_free_ua_cache;
 	}
 	t10_alua_lu_gp_cache = kmem_cache_create("t10_alua_lu_gp_cache",
 			sizeof(struct t10_alua_lu_gp), __alignof__(struct t10_alua_lu_gp),
 			0, NULL);
 	if (!t10_alua_lu_gp_cache) {
-		target_err("kmem_cache_create() for t10_alua_lu_gp_cache"
-			   " failed\n");
+		target_err("kmem_cache_create() for t10_alua_lu_gp_cache failed\n");
 		goto out_free_pr_reg_cache;
 	}
 	t10_alua_lu_gp_mem_cache = kmem_cache_create("t10_alua_lu_gp_mem_cache",
 			sizeof(struct t10_alua_lu_gp_member),
 			__alignof__(struct t10_alua_lu_gp_member), 0, NULL);
 	if (!t10_alua_lu_gp_mem_cache) {
-		target_err("kmem_cache_create() for t10_alua_lu_gp_mem_"
-			   "cache failed\n");
+		target_err("kmem_cache_create() for t10_alua_lu_gp_mem_cache failed\n");
 		goto out_free_lu_gp_cache;
 	}
 	t10_alua_tg_pt_gp_cache = kmem_cache_create("t10_alua_tg_pt_gp_cache",
 			sizeof(struct t10_alua_tg_pt_gp),
 			__alignof__(struct t10_alua_tg_pt_gp), 0, NULL);
 	if (!t10_alua_tg_pt_gp_cache) {
-		target_err("kmem_cache_create() for t10_alua_tg_pt_gp_"
-			   "cache failed\n");
+		target_err("kmem_cache_create() for t10_alua_tg_pt_gp_cache failed\n");
 		goto out_free_lu_gp_mem_cache;
 	}
 	t10_alua_lba_map_cache = kmem_cache_create(
@@ -111,8 +106,7 @@ int init_se_kmem_caches(void)
 			sizeof(struct t10_alua_lba_map),
 			__alignof__(struct t10_alua_lba_map), 0, NULL);
 	if (!t10_alua_lba_map_cache) {
-		target_err("kmem_cache_create() for t10_alua_lba_map_"
-			   "cache failed\n");
+		target_err("kmem_cache_create() for t10_alua_lba_map_cache failed\n");
 		goto out_free_tg_pt_gp_cache;
 	}
 	t10_alua_lba_map_mem_cache = kmem_cache_create(
@@ -120,8 +114,7 @@ int init_se_kmem_caches(void)
 			sizeof(struct t10_alua_lba_map_member),
 			__alignof__(struct t10_alua_lba_map_member), 0, NULL);
 	if (!t10_alua_lba_map_mem_cache) {
-		target_err("kmem_cache_create() for t10_alua_lba_map_mem_"
-			   "cache failed\n");
+		target_err("kmem_cache_create() for t10_alua_lba_map_mem_cache failed\n");
 		goto out_free_lba_map_cache;
 	}
 
@@ -292,8 +285,7 @@ struct se_session *transport_alloc_session(enum target_prot_op sup_prot_ops)
 
 	se_sess = kmem_cache_zalloc(se_sess_cache, GFP_KERNEL);
 	if (!se_sess) {
-		target_err("Unable to allocate struct se_session from"
-			   " se_sess_cache\n");
+		target_err("Unable to allocate struct se_session from se_sess_cache\n");
 		return ERR_PTR(-ENOMEM);
 	}
 	transport_init_session(se_sess);
@@ -325,9 +317,7 @@ int transport_alloc_session_tags(struct se_session *se_sess,
 	rc = sbitmap_queue_init_node(&se_sess->sess_tag_pool, tag_num, -1,
 			false, GFP_KERNEL, NUMA_NO_NODE);
 	if (rc < 0) {
-		target_err("Unable to init se_sess->sess_tag_pool,"
-			   " tag_num: %u\n",
-			   tag_num);
+		target_err("Unable to init se_sess->sess_tag_pool, tag_num: %u\n", tag_num);
 		kvfree(se_sess->sess_cmd_map);
 		se_sess->sess_cmd_map = NULL;
 		return -ENOMEM;
@@ -352,14 +342,12 @@ transport_init_session_tags(unsigned int tag_num, unsigned int tag_size,
 	int rc;
 
 	if (tag_num != 0 && !tag_size) {
-		target_err("init_session_tags called with percpu-ida tag_num:"
-			   " %u, but zero tag_size\n",
+		target_err("init_session_tags called with percpu-ida tag_num: %u, but zero tag_size\n",
 			   tag_num);
 		return ERR_PTR(-EINVAL);
 	}
 	if (!tag_num && tag_size) {
-		target_err("init_session_tags called with percpu-ida tag_size:"
-			   " %u, but zero tag_num\n",
+		target_err("init_session_tags called with percpu-ida tag_size: %u, but zero tag_num\n",
 			   tag_size);
 		return ERR_PTR(-EINVAL);
 	}
@@ -1016,8 +1004,7 @@ void target_qf_do_work(struct work_struct *work)
 		list_del(&cmd->se_qf_node);
 		atomic_dec_mb(&dev->dev_qf_count);
 
-		target_debug("Processing %s cmd: %p QUEUE_FULL in work queue"
-			     " context: %s\n",
+		target_debug("Processing %s cmd: %p QUEUE_FULL in work queue context: %s\n",
 			     cmd->se_tfo->fabric_name, cmd,
 			     (cmd->t_state == TRANSPORT_COMPLETE_QF_OK) ? "COMPLETE_OK" :
 			     (cmd->t_state == TRANSPORT_COMPLETE_QF_WP) ? "WRITE_PENDING"
@@ -1393,9 +1380,7 @@ target_cmd_size_check(struct se_cmd *cmd, unsigned int size)
 	if (cmd->unknown_data_length) {
 		cmd->data_length = size;
 	} else if (size != cmd->data_length) {
-		target_warn_ratelimited("TARGET_CORE[%s]: Expected Transfer Length:"
-					" %u does not match SCSI CDB Length: %u for SAM Opcode:"
-					" 0x%02x\n",
+		target_warn_ratelimited("TARGET_CORE[%s]: Expected Transfer Length: %u does not match SCSI CDB Length: %u for SAM Opcode: 0x%02x\n",
 					cmd->se_tfo->fabric_name, cmd->data_length, size,
 					cmd->t_task_cdb[0]);
 		/*
@@ -1421,8 +1406,7 @@ target_cmd_size_check(struct se_cmd *cmd, unsigned int size)
 
 		if (cmd->data_direction == DMA_TO_DEVICE) {
 			if (cmd->se_cmd_flags & SCF_SCSI_DATA_CDB) {
-				target_err_ratelimited("Rejecting underflow/overflow"
-						       " for WRITE data CDB\n");
+				target_err_ratelimited("Rejecting underflow/overflow for WRITE data CDB\n");
 				return TCM_INVALID_FIELD_IN_COMMAND_IU;
 			}
 			/*
@@ -1432,8 +1416,7 @@ target_cmd_size_check(struct se_cmd *cmd, unsigned int size)
 			 * is introduced tree-wide.
 			 */
 			if (size > cmd->data_length) {
-				target_err_ratelimited("Rejecting overflow for"
-						       " WRITE control CDB\n");
+				target_err_ratelimited("Rejecting overflow for WRITE control CDB\n");
 				return TCM_INVALID_CDB_FIELD;
 			}
 		}
@@ -1496,8 +1479,7 @@ transport_check_alloc_task_attr(struct se_cmd *cmd)
 		return 0;
 
 	if (cmd->sam_task_attr == TCM_ACA_TAG) {
-		target_debug("SAM Task Attribute ACA"
-			     " emulation is not supported\n");
+		target_debug("SAM Task Attribute ACA emulation is not supported\n");
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -1514,8 +1496,7 @@ target_cmd_init_cdb(struct se_cmd *cmd, unsigned char *cdb, gfp_t gfp)
 	 * for VARIABLE_LENGTH_CMD
 	 */
 	if (scsi_command_size(cdb) > SCSI_MAX_VARLEN_CDB_SIZE) {
-		target_err("Received SCSI CDB with command_size: %d that"
-			   " exceeds SCSI_MAX_VARLEN_CDB_SIZE: %d\n",
+		target_err("Received SCSI CDB with command_size: %d that exceeds SCSI_MAX_VARLEN_CDB_SIZE: %d\n",
 			   scsi_command_size(cdb), SCSI_MAX_VARLEN_CDB_SIZE);
 		ret = TCM_INVALID_CDB_FIELD;
 		goto err;
@@ -1528,8 +1509,7 @@ target_cmd_init_cdb(struct se_cmd *cmd, unsigned char *cdb, gfp_t gfp)
 	if (scsi_command_size(cdb) > sizeof(cmd->__t_task_cdb)) {
 		cmd->t_task_cdb = kzalloc(scsi_command_size(cdb), gfp);
 		if (!cmd->t_task_cdb) {
-			target_err("Unable to allocate cmd->t_task_cdb"
-				   " %u > sizeof(cmd->__t_task_cdb): %lu ops\n",
+			target_err("Unable to allocate cmd->t_task_cdb %u > sizeof(cmd->__t_task_cdb): %lu ops\n",
 				   scsi_command_size(cdb),
 				   (unsigned long)sizeof(cmd->__t_task_cdb));
 			ret = TCM_OUT_OF_RESOURCES;
@@ -1654,8 +1634,7 @@ transport_generic_map_mem_to_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
 	 * passes for the original expected data transfer length.
 	 */
 	if (cmd->se_cmd_flags & SCF_OVERFLOW_BIT) {
-		target_warn("Rejecting SCSI DATA overflow for fabric using"
-			    " SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC\n");
+		target_warn("Rejecting SCSI DATA overflow for fabric using SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC\n");
 		return TCM_INVALID_CDB_FIELD;
 	}
 
@@ -2649,9 +2628,8 @@ static void target_complete_ok_work(struct work_struct *work)
 	return;
 
 queue_full:
-	target_debug("Handling complete_ok QUEUE_FULL: se_cmd: %p,"
-		     " data_direction: %d\n",
-		     cmd, cmd->data_direction);
+	target_debug("Handling complete_ok QUEUE_FULL: se_cmd: %p, data_direction: %d\n", cmd,
+		     cmd->data_direction);
 
 	transport_handle_queue_full(cmd, cmd->se_dev, ret, false);
 }
@@ -3278,8 +3256,7 @@ __transport_wait_for_tasks(struct se_cmd *cmd, bool fabric_stop,
 	spin_lock_irqsave(&cmd->t_state_lock, *flags);
 	cmd->transport_state &= ~(CMD_T_ACTIVE | CMD_T_STOP);
 
-	target_debug("wait_for_tasks: Stopped wait_for_completion(&cmd->"
-		     "t_transport_stop_comp) for ITT: 0x%08llx\n",
+	target_debug("wait_for_tasks: Stopped wait_for_completion(&cmd->t_transport_stop_comp) for ITT: 0x%08llx\n",
 		     cmd->tag);
 
 	return true;
diff --git a/drivers/target/target_core_ua.c b/drivers/target/target_core_ua.c
index 825039a5be08..faa7a3ffec68 100644
--- a/drivers/target/target_core_ua.c
+++ b/drivers/target/target_core_ua.c
@@ -146,8 +146,7 @@ int core_scsi3_ua_allocate(
 	list_add_tail(&ua->ua_nacl_list, &deve->ua_list);
 	spin_unlock(&deve->ua_lock);
 
-	target_debug("Allocated UNIT ATTENTION, mapped LUN: %llu, ASC:"
-		     " 0x%02x, ASCQ: 0x%02x\n",
+	target_debug("Allocated UNIT ATTENTION, mapped LUN: %llu, ASC: 0x%02x, ASCQ: 0x%02x\n",
 		     deve->mapped_lun, asc, ascq);
 
 	return 0;
@@ -252,9 +251,7 @@ bool core_scsi3_ua_for_check_condition(struct se_cmd *cmd, u8 *key, u8 *asc,
 	spin_unlock(&deve->ua_lock);
 	rcu_read_unlock();
 
-	target_debug("[%s]: %s UNIT ATTENTION condition with"
-		     " INTLCK_CTRL: %d, mapped LUN: %llu, got CDB: 0x%02x"
-		     " reported ASC: 0x%02x, ASCQ: 0x%02x\n",
+	target_debug("[%s]: %s UNIT ATTENTION condition with INTLCK_CTRL: %d, mapped LUN: %llu, got CDB: 0x%02x reported ASC: 0x%02x, ASCQ: 0x%02x\n",
 		     nacl->se_tpg->se_tpg_tfo->fabric_name,
 		     dev_ua_intlck_clear ? "Releasing" : "Reporting",
 		     dev->dev_attrib.emulate_ua_intlck_ctrl, cmd->orig_fe_lun, cmd->t_task_cdb[0],
@@ -314,9 +311,7 @@ int core_scsi3_ua_clear_for_request_sense(
 	spin_unlock(&deve->ua_lock);
 	rcu_read_unlock();
 
-	target_debug("[%s]: Released UNIT ATTENTION condition, mapped"
-		     " LUN: %llu, got REQUEST_SENSE reported ASC: 0x%02x,"
-		     " ASCQ: 0x%02x\n",
+	target_debug("[%s]: Released UNIT ATTENTION condition, mapped LUN: %llu, got REQUEST_SENSE reported ASC: 0x%02x, ASCQ: 0x%02x\n",
 		     nacl->se_tpg->se_tpg_tfo->fabric_name, cmd->orig_fe_lun, *asc, *ascq);
 
 	return (head) ? -EPERM : 0;
diff --git a/drivers/target/target_core_xcopy.c b/drivers/target/target_core_xcopy.c
index 30fd6d0f3e10..23b4f75e74ea 100644
--- a/drivers/target/target_core_xcopy.c
+++ b/drivers/target/target_core_xcopy.c
@@ -157,8 +157,7 @@ static int target_xcopy_parse_tiddesc_e4(struct se_cmd *se_cmd, struct xcopy_op
 	}
 
 	if (cscd_index != xop->stdi && cscd_index != xop->dtdi) {
-		target_debug("XCOPY 0xe4: ignoring CSCD entry %d - neither src nor "
-			     "dest\n",
+		target_debug("XCOPY 0xe4: ignoring CSCD entry %d - neither src nor dest\n",
 			     cscd_index);
 		return 0;
 	}
@@ -172,8 +171,7 @@ static int target_xcopy_parse_tiddesc_e4(struct se_cmd *se_cmd, struct xcopy_op
 				XCOPY_NAA_IEEE_REGEX_LEN)) {
 			xop->op_origin = XCOL_SOURCE_RECV_OP;
 			xop->src_dev = se_cmd->se_dev;
-			target_debug("XCOPY 0xe4: Set xop->src_dev %p from source"
-				     " received xop\n",
+			target_debug("XCOPY 0xe4: Set xop->src_dev %p from source received xop\n",
 				     xop->src_dev);
 		}
 	}
@@ -190,8 +188,7 @@ static int target_xcopy_parse_tiddesc_e4(struct se_cmd *se_cmd, struct xcopy_op
 				XCOPY_NAA_IEEE_REGEX_LEN)) {
 			xop->op_origin = XCOL_DEST_RECV_OP;
 			xop->dst_dev = se_cmd->se_dev;
-			target_debug("XCOPY 0xe4: Set xop->dst_dev: %p from destination"
-				     " received xop\n",
+			target_debug("XCOPY 0xe4: Set xop->dst_dev: %p from destination received xop\n",
 				     xop->dst_dev);
 		}
 	}
@@ -212,15 +209,13 @@ static int target_xcopy_parse_target_descriptors(struct se_cmd *se_cmd,
 	*sense_ret = TCM_INVALID_PARAMETER_LIST;
 
 	if (offset != 0) {
-		target_err("XCOPY target descriptor list length is not"
-			   " multiple of %d\n",
+		target_err("XCOPY target descriptor list length is not multiple of %d\n",
 			   XCOPY_TARGET_DESC_LEN);
 		*sense_ret = TCM_UNSUPPORTED_TARGET_DESC_TYPE_CODE;
 		return -EINVAL;
 	}
 	if (tdll > RCR_OP_MAX_TARGET_DESC_COUNT * XCOPY_TARGET_DESC_LEN) {
-		target_err("XCOPY target descriptor supports a maximum"
-			   " two src/dest descriptors, tdll: %hu too large..\n",
+		target_err("XCOPY target descriptor supports a maximum two src/dest descriptors, tdll: %hu too large..\n",
 			   tdll);
 		/* spc4r37 6.4.3.4 CSCD DESCRIPTOR LIST LENGTH field */
 		*sense_ret = TCM_TOO_MANY_TARGET_DESCS;
@@ -250,9 +245,7 @@ static int target_xcopy_parse_target_descriptors(struct se_cmd *se_cmd,
 			cscd_index++;
 			break;
 		default:
-			target_err("XCOPY unsupported descriptor type code:"
-				   " 0x%02x\n",
-				   desc[0]);
+			target_err("XCOPY unsupported descriptor type code: 0x%02x\n", desc[0]);
 			*sense_ret = TCM_UNSUPPORTED_TARGET_DESC_TYPE_CODE;
 			goto out;
 		}
@@ -272,8 +265,7 @@ static int target_xcopy_parse_target_descriptors(struct se_cmd *se_cmd,
 						&xop->remote_lun_ref);
 		break;
 	default:
-		target_err("XCOPY CSCD descriptor IDs not found in CSCD list - "
-			   "stdi: %hu dtdi: %hu\n",
+		target_err("XCOPY CSCD descriptor IDs not found in CSCD list - stdi: %hu dtdi: %hu\n",
 			   xop->stdi, xop->dtdi);
 		rc = -EINVAL;
 		break;
@@ -308,9 +300,7 @@ static int target_xcopy_parse_segdesc_02(struct xcopy_op *xop, unsigned char *p)
 
 	desc_len = get_unaligned_be16(&desc[2]);
 	if (desc_len != 0x18) {
-		target_err("XCOPY segment desc 0x02: Illegal desc_len:"
-			   " %hu\n",
-			   desc_len);
+		target_err("XCOPY segment desc 0x02: Illegal desc_len: %hu\n", desc_len);
 		return -EINVAL;
 	}
 
@@ -347,15 +337,13 @@ static int target_xcopy_parse_segment_descriptors(struct xcopy_op *xop,
 	*sense_ret = TCM_INVALID_PARAMETER_LIST;
 
 	if (offset != 0) {
-		target_err("XCOPY segment descriptor list length is not"
-			   " multiple of %d\n",
+		target_err("XCOPY segment descriptor list length is not multiple of %d\n",
 			   XCOPY_SEGMENT_DESC_LEN);
 		*sense_ret = TCM_UNSUPPORTED_SEGMENT_DESC_TYPE_CODE;
 		return -EINVAL;
 	}
 	if (sdll > RCR_OP_MAX_SG_DESC_COUNT * XCOPY_SEGMENT_DESC_LEN) {
-		target_err("XCOPY supports %u segment descriptor(s), sdll: %u too"
-			   " large..\n",
+		target_err("XCOPY supports %u segment descriptor(s), sdll: %u too large..\n",
 			   RCR_OP_MAX_SG_DESC_COUNT, sdll);
 		/* spc4r37 6.4.3.5 SEGMENT DESCRIPTOR LIST LENGTH field */
 		*sense_ret = TCM_TOO_MANY_SEGMENT_DESCS;
@@ -377,9 +365,7 @@ static int target_xcopy_parse_segment_descriptors(struct xcopy_op *xop,
 			desc += XCOPY_SEGMENT_DESC_LEN;
 			break;
 		default:
-			target_err("XCOPY unsupported segment descriptor"
-				   "type: 0x%02x\n",
-				   desc[0]);
+			target_err("XCOPY unsupported segment descriptortype: 0x%02x\n", desc[0]);
 			*sense_ret = TCM_UNSUPPORTED_SEGMENT_DESC_TYPE_CODE;
 			goto out;
 		}
@@ -548,9 +534,8 @@ static int target_xcopy_setup_pt_cmd(
 					xop->xop_data_nents, NULL, 0))
 		return -EINVAL;
 
-	target_debug("Setup PASSTHROUGH_NOALLOC t_data_sg: %p t_data_nents:"
-		     " %u\n",
-		     cmd->t_data_sg, cmd->t_data_nents);
+	target_debug("Setup PASSTHROUGH_NOALLOC t_data_sg: %p t_data_nents: %u\n", cmd->t_data_sg,
+		     cmd->t_data_nents);
 
 	return 0;
 }
@@ -608,8 +593,7 @@ static int target_xcopy_read_source(
 		goto out;
 	}
 
-	target_debug("XCOPY-READ: Saved xop->xop_data_sg: %p, num: %u for READ"
-		     " memory\n",
+	target_debug("XCOPY-READ: Saved xop->xop_data_sg: %p, num: %u for READ memory\n",
 		     xop->xop_data_sg, xop->xop_data_nents);
 
 	rc = target_xcopy_issue_pt_cmd(&xpt_cmd);
@@ -829,15 +813,13 @@ static sense_reason_t target_parse_xcopy_cmd(struct xcopy_op *xop)
 	}
 
 	if (se_cmd->data_length < (XCOPY_HDR_LEN + tdll + sdll + inline_dl)) {
-		target_err("XCOPY parameter truncation: data length %u too small "
-			   "for tdll: %hu sdll: %u inline_dl: %u\n",
+		target_err("XCOPY parameter truncation: data length %u too small for tdll: %hu sdll: %u inline_dl: %u\n",
 			   se_cmd->data_length, tdll, sdll, inline_dl);
 		ret = TCM_PARAMETER_LIST_LENGTH_ERROR;
 		goto out;
 	}
 
-	target_debug("Processing XCOPY with list_id: 0x%02x list_id_usage: 0x%02x"
-		     " tdll: %hu sdll: %u inline_dl: %u\n",
+	target_debug("Processing XCOPY with list_id: 0x%02x list_id_usage: 0x%02x tdll: %hu sdll: %u inline_dl: %u\n",
 		     list_id, list_id_usage, tdll, sdll, inline_dl);
 
 	/*
@@ -859,8 +841,7 @@ static sense_reason_t target_parse_xcopy_cmd(struct xcopy_op *xop)
 
 	if (xop->src_dev->dev_attrib.block_size !=
 	    xop->dst_dev->dev_attrib.block_size) {
-		target_err("XCOPY: Non matching src_dev block_size: %u + dst_dev"
-			   " block_size: %u currently unsupported\n",
+		target_err("XCOPY: Non matching src_dev block_size: %u + dst_dev block_size: %u currently unsupported\n",
 			   xop->src_dev->dev_attrib.block_size,
 			   xop->dst_dev->dev_attrib.block_size);
 		xcopy_pt_undepend_remotedev(xop);
@@ -928,14 +909,12 @@ static sense_reason_t target_rcr_operating_parameters(struct se_cmd *se_cmd)
 
 	p = transport_kmap_data_sg(se_cmd);
 	if (!p) {
-		target_err("transport_kmap_data_sg failed in"
-			   " target_rcr_operating_parameters\n");
+		target_err("transport_kmap_data_sg failed in target_rcr_operating_parameters\n");
 		return TCM_OUT_OF_RESOURCES;
 	}
 
 	if (se_cmd->data_length < 54) {
-		target_err("Receive Copy Results Op Parameters length"
-			   " too small: %u\n",
+		target_err("Receive Copy Results Op Parameters length too small: %u\n",
 			   se_cmd->data_length);
 		transport_kunmap_data_sg(se_cmd);
 		return TCM_INVALID_CDB_FIELD;
@@ -1025,13 +1004,11 @@ sense_reason_t target_do_receive_copy_results(struct se_cmd *se_cmd)
 		return TCM_UNSUPPORTED_SCSI_OPCODE;
 	}
 
-	target_debug("Entering target_do_receive_copy_results: SA: 0x%02x, List ID:"
-		     " 0x%02x, AL: %u\n",
+	target_debug("Entering target_do_receive_copy_results: SA: 0x%02x, List ID: 0x%02x, AL: %u\n",
 		     sa, list_id, se_cmd->data_length);
 
 	if (list_id != 0) {
-		target_err("Receive Copy Results with non zero list identifier"
-			   " not supported\n");
+		target_err("Receive Copy Results with non zero list identifier not supported\n");
 		return TCM_INVALID_CDB_FIELD;
 	}
 
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index 9ab560d9f520..2372f08b91c3 100644
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -44,15 +44,13 @@ static void _ft_dump_cmd(struct ft_cmd *cmd, const char *caller)
 		     se_cmd->t_data_nents, se_cmd->data_length, se_cmd->se_cmd_flags);
 
 	for_each_sg(se_cmd->t_data_sg, sg, se_cmd->t_data_nents, count)
-		target_debug("%s: cmd %p sg %p page %p "
-			     "len 0x%x off 0x%x\n",
-			     caller, cmd, sg, sg_page(sg), sg->length, sg->offset);
+		target_debug("%s: cmd %p sg %p page %p len 0x%x off 0x%x\n", caller, cmd, sg,
+			     sg_page(sg), sg->length, sg->offset);
 
 	sp = cmd->seq;
 	if (sp) {
 		ep = fc_seq_exch(sp);
-		target_debug("%s: cmd %p sid %x did %x "
-			     "ox_id %x rx_id %x seq_id %x e_stat %x\n",
+		target_debug("%s: cmd %p sid %x did %x ox_id %x rx_id %x seq_id %x e_stat %x\n",
 			     caller, cmd, ep->sid, ep->did, ep->oxid, ep->rxid, sp->id,
 			     ep->esb_stat);
 	}
@@ -149,8 +147,7 @@ int ft_queue_status(struct se_cmd *se_cmd)
 
 	rc = fc_seq_send(lport, cmd->seq, fp);
 	if (rc) {
-		target_info_ratelimited("%s: Failed to send response frame %p, "
-					"xid <0x%x>\n",
+		target_info_ratelimited("%s: Failed to send response frame %p, xid <0x%x>\n",
 					__func__, fp, ep->xid);
 		/*
 		 * Generate a TASK_SET_FULL status to notify the initiator
diff --git a/drivers/target/tcm_fc/tfc_io.c b/drivers/target/tcm_fc/tfc_io.c
index cc772793149e..852c2bccf759 100644
--- a/drivers/target/tcm_fc/tfc_io.c
+++ b/drivers/target/tcm_fc/tfc_io.c
@@ -161,9 +161,7 @@ int ft_queue_data_in(struct se_cmd *se_cmd)
 			       FC_TYPE_FCP, f_ctl, fh_off);
 		error = fc_seq_send(lport, seq, fp);
 		if (error) {
-			target_info_ratelimited("%s: Failed to send frame %p, "
-						"xid <0x%x>, remaining %zu, "
-						"lso_max <0x%x>\n",
+			target_info_ratelimited("%s: Failed to send frame %p, xid <0x%x>, remaining %zu, lso_max <0x%x>\n",
 						__func__, fp, ep->xid, remaining, lport->lso_max);
 			/*
 			 * Go ahead and set TASK_SET_FULL status ignoring the
@@ -225,12 +223,7 @@ void ft_recv_write_data(struct ft_cmd *cmd, struct fc_frame *fp)
 		 */
 		buf = fc_frame_payload_get(fp, 1);
 		if (buf)
-			target_err("%s: xid 0x%x, f_ctl 0x%x, cmd->sg %p, "
-				   "cmd->sg_cnt 0x%x. DDP was setup"
-				   " hence not expected to receive frame with "
-				   "payload, Frame will be dropped if"
-				   "'Sequence Initiative' bit in f_ctl is"
-				   "not set\n",
+			target_err("%s: xid 0x%x, f_ctl 0x%x, cmd->sg %p, cmd->sg_cnt 0x%x. DDP was setup hence not expected to receive frame with payload, Frame will be dropped if'Sequence Initiative' bit in f_ctl isnot set\n",
 				   __func__, ep->xid, f_ctl, se_cmd->t_data_sg,
 				   se_cmd->t_data_nents);
 		/*
