whiterose

linux unikernel
Log | Files | Refs | README | LICENSE | git clone https://git.ne02ptzero.me/git/whiterose

libiscsi.c (100106B)


      1 /*
      2  * iSCSI lib functions
      3  *
      4  * Copyright (C) 2006 Red Hat, Inc.  All rights reserved.
      5  * Copyright (C) 2004 - 2006 Mike Christie
      6  * Copyright (C) 2004 - 2005 Dmitry Yusupov
      7  * Copyright (C) 2004 - 2005 Alex Aizman
      8  * maintained by open-iscsi@googlegroups.com
      9  *
     10  * This program is free software; you can redistribute it and/or modify
     11  * it under the terms of the GNU General Public License as published by
     12  * the Free Software Foundation; either version 2 of the License, or
     13  * (at your option) any later version.
     14  *
     15  * This program is distributed in the hope that it will be useful,
     16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
     17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     18  * GNU General Public License for more details.
     19  *
     20  * You should have received a copy of the GNU General Public License
     21  * along with this program; if not, write to the Free Software
     22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
     23  */
     24 #include <linux/types.h>
     25 #include <linux/kfifo.h>
     26 #include <linux/delay.h>
     27 #include <linux/log2.h>
     28 #include <linux/slab.h>
     29 #include <linux/sched/signal.h>
     30 #include <linux/module.h>
     31 #include <asm/unaligned.h>
     32 #include <net/tcp.h>
     33 #include <scsi/scsi_cmnd.h>
     34 #include <scsi/scsi_device.h>
     35 #include <scsi/scsi_eh.h>
     36 #include <scsi/scsi_tcq.h>
     37 #include <scsi/scsi_host.h>
     38 #include <scsi/scsi.h>
     39 #include <scsi/iscsi_proto.h>
     40 #include <scsi/scsi_transport.h>
     41 #include <scsi/scsi_transport_iscsi.h>
     42 #include <scsi/libiscsi.h>
     43 #include <trace/events/iscsi.h>
     44 
     45 static int iscsi_dbg_lib_conn;
     46 module_param_named(debug_libiscsi_conn, iscsi_dbg_lib_conn, int,
     47 		   S_IRUGO | S_IWUSR);
     48 MODULE_PARM_DESC(debug_libiscsi_conn,
     49 		 "Turn on debugging for connections in libiscsi module. "
     50 		 "Set to 1 to turn on, and zero to turn off. Default is off.");
     51 
     52 static int iscsi_dbg_lib_session;
     53 module_param_named(debug_libiscsi_session, iscsi_dbg_lib_session, int,
     54 		   S_IRUGO | S_IWUSR);
     55 MODULE_PARM_DESC(debug_libiscsi_session,
     56 		 "Turn on debugging for sessions in libiscsi module. "
     57 		 "Set to 1 to turn on, and zero to turn off. Default is off.");
     58 
     59 static int iscsi_dbg_lib_eh;
     60 module_param_named(debug_libiscsi_eh, iscsi_dbg_lib_eh, int,
     61 		   S_IRUGO | S_IWUSR);
     62 MODULE_PARM_DESC(debug_libiscsi_eh,
     63 		 "Turn on debugging for error handling in libiscsi module. "
     64 		 "Set to 1 to turn on, and zero to turn off. Default is off.");
     65 
     66 #define ISCSI_DBG_CONN(_conn, dbg_fmt, arg...)			\
     67 	do {							\
     68 		if (iscsi_dbg_lib_conn)				\
     69 			iscsi_conn_printk(KERN_INFO, _conn,	\
     70 					     "%s " dbg_fmt,	\
     71 					     __func__, ##arg);	\
     72 		iscsi_dbg_trace(trace_iscsi_dbg_conn,		\
     73 				&(_conn)->cls_conn->dev,	\
     74 				"%s " dbg_fmt, __func__, ##arg);\
     75 	} while (0);
     76 
     77 #define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...)			\
     78 	do {								\
     79 		if (iscsi_dbg_lib_session)				\
     80 			iscsi_session_printk(KERN_INFO, _session,	\
     81 					     "%s " dbg_fmt,		\
     82 					     __func__, ##arg);		\
     83 		iscsi_dbg_trace(trace_iscsi_dbg_session, 		\
     84 				&(_session)->cls_session->dev,		\
     85 				"%s " dbg_fmt, __func__, ##arg);	\
     86 	} while (0);
     87 
     88 #define ISCSI_DBG_EH(_session, dbg_fmt, arg...)				\
     89 	do {								\
     90 		if (iscsi_dbg_lib_eh)					\
     91 			iscsi_session_printk(KERN_INFO, _session,	\
     92 					     "%s " dbg_fmt,		\
     93 					     __func__, ##arg);		\
     94 		iscsi_dbg_trace(trace_iscsi_dbg_eh,			\
     95 				&(_session)->cls_session->dev,		\
     96 				"%s " dbg_fmt, __func__, ##arg);	\
     97 	} while (0);
     98 
     99 inline void iscsi_conn_queue_work(struct iscsi_conn *conn)
    100 {
    101 	struct Scsi_Host *shost = conn->session->host;
    102 	struct iscsi_host *ihost = shost_priv(shost);
    103 
    104 	if (ihost->workq)
    105 		queue_work(ihost->workq, &conn->xmitwork);
    106 }
    107 EXPORT_SYMBOL_GPL(iscsi_conn_queue_work);
    108 
    109 static void __iscsi_update_cmdsn(struct iscsi_session *session,
    110 				 uint32_t exp_cmdsn, uint32_t max_cmdsn)
    111 {
    112 	/*
    113 	 * standard specifies this check for when to update expected and
    114 	 * max sequence numbers
    115 	 */
    116 	if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1))
    117 		return;
    118 
    119 	if (exp_cmdsn != session->exp_cmdsn &&
    120 	    !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn))
    121 		session->exp_cmdsn = exp_cmdsn;
    122 
    123 	if (max_cmdsn != session->max_cmdsn &&
    124 	    !iscsi_sna_lt(max_cmdsn, session->max_cmdsn))
    125 		session->max_cmdsn = max_cmdsn;
    126 }
    127 
    128 void iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr)
    129 {
    130 	__iscsi_update_cmdsn(session, be32_to_cpu(hdr->exp_cmdsn),
    131 			     be32_to_cpu(hdr->max_cmdsn));
    132 }
    133 EXPORT_SYMBOL_GPL(iscsi_update_cmdsn);
    134 
    135 /**
    136  * iscsi_prep_data_out_pdu - initialize Data-Out
    137  * @task: scsi command task
    138  * @r2t: R2T info
    139  * @hdr: iscsi data in pdu
    140  *
    141  * Notes:
    142  *	Initialize Data-Out within this R2T sequence and finds
    143  *	proper data_offset within this SCSI command.
    144  *
    145  *	This function is called with connection lock taken.
    146  **/
    147 void iscsi_prep_data_out_pdu(struct iscsi_task *task, struct iscsi_r2t_info *r2t,
    148 			   struct iscsi_data *hdr)
    149 {
    150 	struct iscsi_conn *conn = task->conn;
    151 	unsigned int left = r2t->data_length - r2t->sent;
    152 
    153 	task->hdr_len = sizeof(struct iscsi_data);
    154 
    155 	memset(hdr, 0, sizeof(struct iscsi_data));
    156 	hdr->ttt = r2t->ttt;
    157 	hdr->datasn = cpu_to_be32(r2t->datasn);
    158 	r2t->datasn++;
    159 	hdr->opcode = ISCSI_OP_SCSI_DATA_OUT;
    160 	hdr->lun = task->lun;
    161 	hdr->itt = task->hdr_itt;
    162 	hdr->exp_statsn = r2t->exp_statsn;
    163 	hdr->offset = cpu_to_be32(r2t->data_offset + r2t->sent);
    164 	if (left > conn->max_xmit_dlength) {
    165 		hton24(hdr->dlength, conn->max_xmit_dlength);
    166 		r2t->data_count = conn->max_xmit_dlength;
    167 		hdr->flags = 0;
    168 	} else {
    169 		hton24(hdr->dlength, left);
    170 		r2t->data_count = left;
    171 		hdr->flags = ISCSI_FLAG_CMD_FINAL;
    172 	}
    173 	conn->dataout_pdus_cnt++;
    174 }
    175 EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu);
    176 
    177 static int iscsi_add_hdr(struct iscsi_task *task, unsigned len)
    178 {
    179 	unsigned exp_len = task->hdr_len + len;
    180 
    181 	if (exp_len > task->hdr_max) {
    182 		WARN_ON(1);
    183 		return -EINVAL;
    184 	}
    185 
    186 	WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */
    187 	task->hdr_len = exp_len;
    188 	return 0;
    189 }
    190 
    191 /*
    192  * make an extended cdb AHS
    193  */
    194 static int iscsi_prep_ecdb_ahs(struct iscsi_task *task)
    195 {
    196 	struct scsi_cmnd *cmd = task->sc;
    197 	unsigned rlen, pad_len;
    198 	unsigned short ahslength;
    199 	struct iscsi_ecdb_ahdr *ecdb_ahdr;
    200 	int rc;
    201 
    202 	ecdb_ahdr = iscsi_next_hdr(task);
    203 	rlen = cmd->cmd_len - ISCSI_CDB_SIZE;
    204 
    205 	BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb));
    206 	ahslength = rlen + sizeof(ecdb_ahdr->reserved);
    207 
    208 	pad_len = iscsi_padding(rlen);
    209 
    210 	rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) +
    211 	                   sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len);
    212 	if (rc)
    213 		return rc;
    214 
    215 	if (pad_len)
    216 		memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len);
    217 
    218 	ecdb_ahdr->ahslength = cpu_to_be16(ahslength);
    219 	ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB;
    220 	ecdb_ahdr->reserved = 0;
    221 	memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen);
    222 
    223 	ISCSI_DBG_SESSION(task->conn->session,
    224 			  "iscsi_prep_ecdb_ahs: varlen_cdb_len %d "
    225 		          "rlen %d pad_len %d ahs_length %d iscsi_headers_size "
    226 		          "%u\n", cmd->cmd_len, rlen, pad_len, ahslength,
    227 		          task->hdr_len);
    228 	return 0;
    229 }
    230 
    231 /**
    232  * iscsi_check_tmf_restrictions - check if a task is affected by TMF
    233  * @task: iscsi task
    234  * @opcode: opcode to check for
    235  *
    236  * During TMF a task has to be checked if it's affected.
    237  * All unrelated I/O can be passed through, but I/O to the
    238  * affected LUN should be restricted.
    239  * If 'fast_abort' is set we won't be sending any I/O to the
    240  * affected LUN.
    241  * Otherwise the target is waiting for all TTTs to be completed,
    242  * so we have to send all outstanding Data-Out PDUs to the target.
    243  */
    244 static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode)
    245 {
    246 	struct iscsi_conn *conn = task->conn;
    247 	struct iscsi_tm *tmf = &conn->tmhdr;
    248 	u64 hdr_lun;
    249 
    250 	if (conn->tmf_state == TMF_INITIAL)
    251 		return 0;
    252 
    253 	if ((tmf->opcode & ISCSI_OPCODE_MASK) != ISCSI_OP_SCSI_TMFUNC)
    254 		return 0;
    255 
    256 	switch (ISCSI_TM_FUNC_VALUE(tmf)) {
    257 	case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET:
    258 		/*
    259 		 * Allow PDUs for unrelated LUNs
    260 		 */
    261 		hdr_lun = scsilun_to_int(&tmf->lun);
    262 		if (hdr_lun != task->sc->device->lun)
    263 			return 0;
    264 		/* fall through */
    265 	case ISCSI_TM_FUNC_TARGET_WARM_RESET:
    266 		/*
    267 		 * Fail all SCSI cmd PDUs
    268 		 */
    269 		if (opcode != ISCSI_OP_SCSI_DATA_OUT) {
    270 			iscsi_conn_printk(KERN_INFO, conn,
    271 					  "task [op %x itt "
    272 					  "0x%x/0x%x] "
    273 					  "rejected.\n",
    274 					  opcode, task->itt,
    275 					  task->hdr_itt);
    276 			return -EACCES;
    277 		}
    278 		/*
    279 		 * And also all data-out PDUs in response to R2T
    280 		 * if fast_abort is set.
    281 		 */
    282 		if (conn->session->fast_abort) {
    283 			iscsi_conn_printk(KERN_INFO, conn,
    284 					  "task [op %x itt "
    285 					  "0x%x/0x%x] fast abort.\n",
    286 					  opcode, task->itt,
    287 					  task->hdr_itt);
    288 			return -EACCES;
    289 		}
    290 		break;
    291 	case ISCSI_TM_FUNC_ABORT_TASK:
    292 		/*
    293 		 * the caller has already checked if the task
    294 		 * they want to abort was in the pending queue so if
    295 		 * we are here the cmd pdu has gone out already, and
    296 		 * we will only hit this for data-outs
    297 		 */
    298 		if (opcode == ISCSI_OP_SCSI_DATA_OUT &&
    299 		    task->hdr_itt == tmf->rtt) {
    300 			ISCSI_DBG_SESSION(conn->session,
    301 					  "Preventing task %x/%x from sending "
    302 					  "data-out due to abort task in "
    303 					  "progress\n", task->itt,
    304 					  task->hdr_itt);
    305 			return -EACCES;
    306 		}
    307 		break;
    308 	}
    309 
    310 	return 0;
    311 }
    312 
    313 /**
    314  * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu
    315  * @task: iscsi task
    316  *
    317  * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set
    318  * fields like dlength or final based on how much data it sends
    319  */
    320 static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
    321 {
    322 	struct iscsi_conn *conn = task->conn;
    323 	struct iscsi_session *session = conn->session;
    324 	struct scsi_cmnd *sc = task->sc;
    325 	struct iscsi_scsi_req *hdr;
    326 	unsigned hdrlength, cmd_len, transfer_length;
    327 	itt_t itt;
    328 	int rc;
    329 
    330 	rc = iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_CMD);
    331 	if (rc)
    332 		return rc;
    333 
    334 	if (conn->session->tt->alloc_pdu) {
    335 		rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD);
    336 		if (rc)
    337 			return rc;
    338 	}
    339 	hdr = (struct iscsi_scsi_req *)task->hdr;
    340 	itt = hdr->itt;
    341 	memset(hdr, 0, sizeof(*hdr));
    342 
    343 	if (session->tt->parse_pdu_itt)
    344 		hdr->itt = task->hdr_itt = itt;
    345 	else
    346 		hdr->itt = task->hdr_itt = build_itt(task->itt,
    347 						     task->conn->session->age);
    348 	task->hdr_len = 0;
    349 	rc = iscsi_add_hdr(task, sizeof(*hdr));
    350 	if (rc)
    351 		return rc;
    352 	hdr->opcode = ISCSI_OP_SCSI_CMD;
    353 	hdr->flags = ISCSI_ATTR_SIMPLE;
    354 	int_to_scsilun(sc->device->lun, &hdr->lun);
    355 	task->lun = hdr->lun;
    356 	hdr->exp_statsn = cpu_to_be32(conn->exp_statsn);
    357 	cmd_len = sc->cmd_len;
    358 	if (cmd_len < ISCSI_CDB_SIZE)
    359 		memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len);
    360 	else if (cmd_len > ISCSI_CDB_SIZE) {
    361 		rc = iscsi_prep_ecdb_ahs(task);
    362 		if (rc)
    363 			return rc;
    364 		cmd_len = ISCSI_CDB_SIZE;
    365 	}
    366 	memcpy(hdr->cdb, sc->cmnd, cmd_len);
    367 
    368 	task->imm_count = 0;
    369 	if (scsi_get_prot_op(sc) != SCSI_PROT_NORMAL)
    370 		task->protected = true;
    371 
    372 	transfer_length = scsi_transfer_length(sc);
    373 	hdr->data_length = cpu_to_be32(transfer_length);
    374 	if (sc->sc_data_direction == DMA_TO_DEVICE) {
    375 		struct iscsi_r2t_info *r2t = &task->unsol_r2t;
    376 
    377 		hdr->flags |= ISCSI_FLAG_CMD_WRITE;
    378 		/*
    379 		 * Write counters:
    380 		 *
    381 		 *	imm_count	bytes to be sent right after
    382 		 *			SCSI PDU Header
    383 		 *
    384 		 *	unsol_count	bytes(as Data-Out) to be sent
    385 		 *			without	R2T ack right after
    386 		 *			immediate data
    387 		 *
    388 		 *	r2t data_length bytes to be sent via R2T ack's
    389 		 *
    390 		 *      pad_count       bytes to be sent as zero-padding
    391 		 */
    392 		memset(r2t, 0, sizeof(*r2t));
    393 
    394 		if (session->imm_data_en) {
    395 			if (transfer_length >= session->first_burst)
    396 				task->imm_count = min(session->first_burst,
    397 							conn->max_xmit_dlength);
    398 			else
    399 				task->imm_count = min(transfer_length,
    400 						      conn->max_xmit_dlength);
    401 			hton24(hdr->dlength, task->imm_count);
    402 		} else
    403 			zero_data(hdr->dlength);
    404 
    405 		if (!session->initial_r2t_en) {
    406 			r2t->data_length = min(session->first_burst,
    407 					       transfer_length) -
    408 					       task->imm_count;
    409 			r2t->data_offset = task->imm_count;
    410 			r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG);
    411 			r2t->exp_statsn = cpu_to_be32(conn->exp_statsn);
    412 		}
    413 
    414 		if (!task->unsol_r2t.data_length)
    415 			/* No unsolicit Data-Out's */
    416 			hdr->flags |= ISCSI_FLAG_CMD_FINAL;
    417 	} else {
    418 		hdr->flags |= ISCSI_FLAG_CMD_FINAL;
    419 		zero_data(hdr->dlength);
    420 
    421 		if (sc->sc_data_direction == DMA_FROM_DEVICE)
    422 			hdr->flags |= ISCSI_FLAG_CMD_READ;
    423 	}
    424 
    425 	/* calculate size of additional header segments (AHSs) */
    426 	hdrlength = task->hdr_len - sizeof(*hdr);
    427 
    428 	WARN_ON(hdrlength & (ISCSI_PAD_LEN-1));
    429 	hdrlength /= ISCSI_PAD_LEN;
    430 
    431 	WARN_ON(hdrlength >= 256);
    432 	hdr->hlength = hdrlength & 0xFF;
    433 	hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn);
    434 
    435 	if (session->tt->init_task && session->tt->init_task(task))
    436 		return -EIO;
    437 
    438 	task->state = ISCSI_TASK_RUNNING;
    439 	session->cmdsn++;
    440 
    441 	conn->scsicmd_pdus_cnt++;
    442 	ISCSI_DBG_SESSION(session, "iscsi prep [%s cid %d sc %p cdb 0x%x "
    443 			  "itt 0x%x len %d cmdsn %d win %d]\n",
    444 			  sc->sc_data_direction == DMA_TO_DEVICE ?
    445 			  "write" : "read", conn->id, sc, sc->cmnd[0],
    446 			  task->itt, transfer_length,
    447 			  session->cmdsn,
    448 			  session->max_cmdsn - session->exp_cmdsn + 1);
    449 	return 0;
    450 }
    451 
    452 /**
    453  * iscsi_free_task - free a task
    454  * @task: iscsi cmd task
    455  *
    456  * Must be called with session back_lock.
    457  * This function returns the scsi command to scsi-ml or cleans
    458  * up mgmt tasks then returns the task to the pool.
    459  */
    460 static void iscsi_free_task(struct iscsi_task *task)
    461 {
    462 	struct iscsi_conn *conn = task->conn;
    463 	struct iscsi_session *session = conn->session;
    464 	struct scsi_cmnd *sc = task->sc;
    465 	int oldstate = task->state;
    466 
    467 	ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n",
    468 			  task->itt, task->state, task->sc);
    469 
    470 	session->tt->cleanup_task(task);
    471 	task->state = ISCSI_TASK_FREE;
    472 	task->sc = NULL;
    473 	/*
    474 	 * login task is preallocated so do not free
    475 	 */
    476 	if (conn->login_task == task)
    477 		return;
    478 
    479 	kfifo_in(&session->cmdpool.queue, (void*)&task, sizeof(void*));
    480 
    481 	if (sc) {
    482 		/* SCSI eh reuses commands to verify us */
    483 		sc->SCp.ptr = NULL;
    484 		/*
    485 		 * queue command may call this to free the task, so
    486 		 * it will decide how to return sc to scsi-ml.
    487 		 */
    488 		if (oldstate != ISCSI_TASK_REQUEUE_SCSIQ)
    489 			sc->scsi_done(sc);
    490 	}
    491 }
    492 
    493 void __iscsi_get_task(struct iscsi_task *task)
    494 {
    495 	refcount_inc(&task->refcount);
    496 }
    497 EXPORT_SYMBOL_GPL(__iscsi_get_task);
    498 
    499 void __iscsi_put_task(struct iscsi_task *task)
    500 {
    501 	if (refcount_dec_and_test(&task->refcount))
    502 		iscsi_free_task(task);
    503 }
    504 EXPORT_SYMBOL_GPL(__iscsi_put_task);
    505 
    506 void iscsi_put_task(struct iscsi_task *task)
    507 {
    508 	struct iscsi_session *session = task->conn->session;
    509 
    510 	/* regular RX path uses back_lock */
    511 	spin_lock_bh(&session->back_lock);
    512 	__iscsi_put_task(task);
    513 	spin_unlock_bh(&session->back_lock);
    514 }
    515 EXPORT_SYMBOL_GPL(iscsi_put_task);
    516 
    517 /**
    518  * iscsi_complete_task - finish a task
    519  * @task: iscsi cmd task
    520  * @state: state to complete task with
    521  *
    522  * Must be called with session back_lock.
    523  */
    524 static void iscsi_complete_task(struct iscsi_task *task, int state)
    525 {
    526 	struct iscsi_conn *conn = task->conn;
    527 
    528 	ISCSI_DBG_SESSION(conn->session,
    529 			  "complete task itt 0x%x state %d sc %p\n",
    530 			  task->itt, task->state, task->sc);
    531 	if (task->state == ISCSI_TASK_COMPLETED ||
    532 	    task->state == ISCSI_TASK_ABRT_TMF ||
    533 	    task->state == ISCSI_TASK_ABRT_SESS_RECOV ||
    534 	    task->state == ISCSI_TASK_REQUEUE_SCSIQ)
    535 		return;
    536 	WARN_ON_ONCE(task->state == ISCSI_TASK_FREE);
    537 	task->state = state;
    538 
    539 	spin_lock_bh(&conn->taskqueuelock);
    540 	if (!list_empty(&task->running)) {
    541 		pr_debug_once("%s while task on list", __func__);
    542 		list_del_init(&task->running);
    543 	}
    544 	spin_unlock_bh(&conn->taskqueuelock);
    545 
    546 	if (conn->task == task)
    547 		conn->task = NULL;
    548 
    549 	if (conn->ping_task == task)
    550 		conn->ping_task = NULL;
    551 
    552 	/* release get from queueing */
    553 	__iscsi_put_task(task);
    554 }
    555 
    556 /**
    557  * iscsi_complete_scsi_task - finish scsi task normally
    558  * @task: iscsi task for scsi cmd
    559  * @exp_cmdsn: expected cmd sn in cpu format
    560  * @max_cmdsn: max cmd sn in cpu format
    561  *
    562  * This is used when drivers do not need or cannot perform
    563  * lower level pdu processing.
    564  *
    565  * Called with session back_lock
    566  */
    567 void iscsi_complete_scsi_task(struct iscsi_task *task,
    568 			      uint32_t exp_cmdsn, uint32_t max_cmdsn)
    569 {
    570 	struct iscsi_conn *conn = task->conn;
    571 
    572 	ISCSI_DBG_SESSION(conn->session, "[itt 0x%x]\n", task->itt);
    573 
    574 	conn->last_recv = jiffies;
    575 	__iscsi_update_cmdsn(conn->session, exp_cmdsn, max_cmdsn);
    576 	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
    577 }
    578 EXPORT_SYMBOL_GPL(iscsi_complete_scsi_task);
    579 
    580 
    581 /*
    582  * session back_lock must be held and if not called for a task that is
    583  * still pending or from the xmit thread, then xmit thread must
    584  * be suspended.
    585  */
    586 static void fail_scsi_task(struct iscsi_task *task, int err)
    587 {
    588 	struct iscsi_conn *conn = task->conn;
    589 	struct scsi_cmnd *sc;
    590 	int state;
    591 
    592 	/*
    593 	 * if a command completes and we get a successful tmf response
    594 	 * we will hit this because the scsi eh abort code does not take
    595 	 * a ref to the task.
    596 	 */
    597 	sc = task->sc;
    598 	if (!sc)
    599 		return;
    600 
    601 	if (task->state == ISCSI_TASK_PENDING) {
    602 		/*
    603 		 * cmd never made it to the xmit thread, so we should not count
    604 		 * the cmd in the sequencing
    605 		 */
    606 		conn->session->queued_cmdsn--;
    607 		/* it was never sent so just complete like normal */
    608 		state = ISCSI_TASK_COMPLETED;
    609 	} else if (err == DID_TRANSPORT_DISRUPTED)
    610 		state = ISCSI_TASK_ABRT_SESS_RECOV;
    611 	else
    612 		state = ISCSI_TASK_ABRT_TMF;
    613 
    614 	sc->result = err << 16;
    615 	scsi_set_resid(sc, scsi_bufflen(sc));
    616 
    617 	/* regular RX path uses back_lock */
    618 	spin_lock_bh(&conn->session->back_lock);
    619 	iscsi_complete_task(task, state);
    620 	spin_unlock_bh(&conn->session->back_lock);
    621 }
    622 
    623 static int iscsi_prep_mgmt_task(struct iscsi_conn *conn,
    624 				struct iscsi_task *task)
    625 {
    626 	struct iscsi_session *session = conn->session;
    627 	struct iscsi_hdr *hdr = task->hdr;
    628 	struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr;
    629 	uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK;
    630 
    631 	if (conn->session->state == ISCSI_STATE_LOGGING_OUT)
    632 		return -ENOTCONN;
    633 
    634 	if (opcode != ISCSI_OP_LOGIN && opcode != ISCSI_OP_TEXT)
    635 		nop->exp_statsn = cpu_to_be32(conn->exp_statsn);
    636 	/*
    637 	 * pre-format CmdSN for outgoing PDU.
    638 	 */
    639 	nop->cmdsn = cpu_to_be32(session->cmdsn);
    640 	if (hdr->itt != RESERVED_ITT) {
    641 		/*
    642 		 * TODO: We always use immediate for normal session pdus.
    643 		 * If we start to send tmfs or nops as non-immediate then
    644 		 * we should start checking the cmdsn numbers for mgmt tasks.
    645 		 *
    646 		 * During discovery sessions iscsid sends TEXT as non immediate,
    647 		 * but we always only send one PDU at a time.
    648 		 */
    649 		if (conn->c_stage == ISCSI_CONN_STARTED &&
    650 		    !(hdr->opcode & ISCSI_OP_IMMEDIATE)) {
    651 			session->queued_cmdsn++;
    652 			session->cmdsn++;
    653 		}
    654 	}
    655 
    656 	if (session->tt->init_task && session->tt->init_task(task))
    657 		return -EIO;
    658 
    659 	if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT)
    660 		session->state = ISCSI_STATE_LOGGING_OUT;
    661 
    662 	task->state = ISCSI_TASK_RUNNING;
    663 	ISCSI_DBG_SESSION(session, "mgmtpdu [op 0x%x hdr->itt 0x%x "
    664 			  "datalen %d]\n", hdr->opcode & ISCSI_OPCODE_MASK,
    665 			  hdr->itt, task->data_count);
    666 	return 0;
    667 }
    668 
    669 static struct iscsi_task *
    670 __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
    671 		      char *data, uint32_t data_size)
    672 {
    673 	struct iscsi_session *session = conn->session;
    674 	struct iscsi_host *ihost = shost_priv(session->host);
    675 	uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK;
    676 	struct iscsi_task *task;
    677 	itt_t itt;
    678 
    679 	if (session->state == ISCSI_STATE_TERMINATE)
    680 		return NULL;
    681 
    682 	if (opcode == ISCSI_OP_LOGIN || opcode == ISCSI_OP_TEXT) {
    683 		/*
    684 		 * Login and Text are sent serially, in
    685 		 * request-followed-by-response sequence.
    686 		 * Same task can be used. Same ITT must be used.
    687 		 * Note that login_task is preallocated at conn_create().
    688 		 */
    689 		if (conn->login_task->state != ISCSI_TASK_FREE) {
    690 			iscsi_conn_printk(KERN_ERR, conn, "Login/Text in "
    691 					  "progress. Cannot start new task.\n");
    692 			return NULL;
    693 		}
    694 
    695 		if (data_size > ISCSI_DEF_MAX_RECV_SEG_LEN) {
    696 			iscsi_conn_printk(KERN_ERR, conn, "Invalid buffer len of %u for login task. Max len is %u\n", data_size, ISCSI_DEF_MAX_RECV_SEG_LEN);
    697 			return NULL;
    698 		}
    699 
    700 		task = conn->login_task;
    701 	} else {
    702 		if (session->state != ISCSI_STATE_LOGGED_IN)
    703 			return NULL;
    704 
    705 		if (data_size != 0) {
    706 			iscsi_conn_printk(KERN_ERR, conn, "Can not send data buffer of len %u for op 0x%x\n", data_size, opcode);
    707 			return NULL;
    708 		}
    709 
    710 		BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE);
    711 		BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED);
    712 
    713 		if (!kfifo_out(&session->cmdpool.queue,
    714 				 (void*)&task, sizeof(void*)))
    715 			return NULL;
    716 	}
    717 	/*
    718 	 * released in complete pdu for task we expect a response for, and
    719 	 * released by the lld when it has transmitted the task for
    720 	 * pdus we do not expect a response for.
    721 	 */
    722 	refcount_set(&task->refcount, 1);
    723 	task->conn = conn;
    724 	task->sc = NULL;
    725 	INIT_LIST_HEAD(&task->running);
    726 	task->state = ISCSI_TASK_PENDING;
    727 
    728 	if (data_size) {
    729 		memcpy(task->data, data, data_size);
    730 		task->data_count = data_size;
    731 	} else
    732 		task->data_count = 0;
    733 
    734 	if (conn->session->tt->alloc_pdu) {
    735 		if (conn->session->tt->alloc_pdu(task, hdr->opcode)) {
    736 			iscsi_conn_printk(KERN_ERR, conn, "Could not allocate "
    737 					 "pdu for mgmt task.\n");
    738 			goto free_task;
    739 		}
    740 	}
    741 
    742 	itt = task->hdr->itt;
    743 	task->hdr_len = sizeof(struct iscsi_hdr);
    744 	memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr));
    745 
    746 	if (hdr->itt != RESERVED_ITT) {
    747 		if (session->tt->parse_pdu_itt)
    748 			task->hdr->itt = itt;
    749 		else
    750 			task->hdr->itt = build_itt(task->itt,
    751 						   task->conn->session->age);
    752 	}
    753 
    754 	if (!ihost->workq) {
    755 		if (iscsi_prep_mgmt_task(conn, task))
    756 			goto free_task;
    757 
    758 		if (session->tt->xmit_task(task))
    759 			goto free_task;
    760 	} else {
    761 		spin_lock_bh(&conn->taskqueuelock);
    762 		list_add_tail(&task->running, &conn->mgmtqueue);
    763 		spin_unlock_bh(&conn->taskqueuelock);
    764 		iscsi_conn_queue_work(conn);
    765 	}
    766 
    767 	return task;
    768 
    769 free_task:
    770 	/* regular RX path uses back_lock */
    771 	spin_lock(&session->back_lock);
    772 	__iscsi_put_task(task);
    773 	spin_unlock(&session->back_lock);
    774 	return NULL;
    775 }
    776 
    777 int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr,
    778 			char *data, uint32_t data_size)
    779 {
    780 	struct iscsi_conn *conn = cls_conn->dd_data;
    781 	struct iscsi_session *session = conn->session;
    782 	int err = 0;
    783 
    784 	spin_lock_bh(&session->frwd_lock);
    785 	if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size))
    786 		err = -EPERM;
    787 	spin_unlock_bh(&session->frwd_lock);
    788 	return err;
    789 }
    790 EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu);
    791 
    792 /**
    793  * iscsi_cmd_rsp - SCSI Command Response processing
    794  * @conn: iscsi connection
    795  * @hdr: iscsi header
    796  * @task: scsi command task
    797  * @data: cmd data buffer
    798  * @datalen: len of buffer
    799  *
    800  * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and
    801  * then completes the command and task. called under back_lock
    802  **/
    803 static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
    804 			       struct iscsi_task *task, char *data,
    805 			       int datalen)
    806 {
    807 	struct iscsi_scsi_rsp *rhdr = (struct iscsi_scsi_rsp *)hdr;
    808 	struct iscsi_session *session = conn->session;
    809 	struct scsi_cmnd *sc = task->sc;
    810 
    811 	iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr);
    812 	conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1;
    813 
    814 	sc->result = (DID_OK << 16) | rhdr->cmd_status;
    815 
    816 	if (task->protected) {
    817 		sector_t sector;
    818 		u8 ascq;
    819 
    820 		/**
    821 		 * Transports that didn't implement check_protection
    822 		 * callback but still published T10-PI support to scsi-mid
    823 		 * deserve this BUG_ON.
    824 		 **/
    825 		BUG_ON(!session->tt->check_protection);
    826 
    827 		ascq = session->tt->check_protection(task, &sector);
    828 		if (ascq) {
    829 			sc->result = DRIVER_SENSE << 24 |
    830 				     SAM_STAT_CHECK_CONDITION;
    831 			scsi_build_sense_buffer(1, sc->sense_buffer,
    832 						ILLEGAL_REQUEST, 0x10, ascq);
    833 			scsi_set_sense_information(sc->sense_buffer,
    834 						   SCSI_SENSE_BUFFERSIZE,
    835 						   sector);
    836 			goto out;
    837 		}
    838 	}
    839 
    840 	if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) {
    841 		sc->result = DID_ERROR << 16;
    842 		goto out;
    843 	}
    844 
    845 	if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) {
    846 		uint16_t senselen;
    847 
    848 		if (datalen < 2) {
    849 invalid_datalen:
    850 			iscsi_conn_printk(KERN_ERR,  conn,
    851 					 "Got CHECK_CONDITION but invalid data "
    852 					 "buffer size of %d\n", datalen);
    853 			sc->result = DID_BAD_TARGET << 16;
    854 			goto out;
    855 		}
    856 
    857 		senselen = get_unaligned_be16(data);
    858 		if (datalen < senselen)
    859 			goto invalid_datalen;
    860 
    861 		memcpy(sc->sense_buffer, data + 2,
    862 		       min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE));
    863 		ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n",
    864 				  min_t(uint16_t, senselen,
    865 				  SCSI_SENSE_BUFFERSIZE));
    866 	}
    867 
    868 	if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW |
    869 			   ISCSI_FLAG_CMD_BIDI_OVERFLOW)) {
    870 		sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
    871 	}
    872 
    873 	if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW |
    874 	                   ISCSI_FLAG_CMD_OVERFLOW)) {
    875 		int res_count = be32_to_cpu(rhdr->residual_count);
    876 
    877 		if (res_count > 0 &&
    878 		    (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW ||
    879 		     res_count <= scsi_bufflen(sc)))
    880 			/* write side for bidi or uni-io set_resid */
    881 			scsi_set_resid(sc, res_count);
    882 		else
    883 			sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
    884 	}
    885 out:
    886 	ISCSI_DBG_SESSION(session, "cmd rsp done [sc %p res %d itt 0x%x]\n",
    887 			  sc, sc->result, task->itt);
    888 	conn->scsirsp_pdus_cnt++;
    889 	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
    890 }
    891 
    892 /**
    893  * iscsi_data_in_rsp - SCSI Data-In Response processing
    894  * @conn: iscsi connection
    895  * @hdr:  iscsi pdu
    896  * @task: scsi command task
    897  *
    898  * iscsi_data_in_rsp sets up the scsi_cmnd fields based on the data received
    899  * then completes the command and task. called under back_lock
    900  **/
    901 static void
    902 iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
    903 		  struct iscsi_task *task)
    904 {
    905 	struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr;
    906 	struct scsi_cmnd *sc = task->sc;
    907 
    908 	if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS))
    909 		return;
    910 
    911 	iscsi_update_cmdsn(conn->session, (struct iscsi_nopin *)hdr);
    912 	sc->result = (DID_OK << 16) | rhdr->cmd_status;
    913 	conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1;
    914 	if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW |
    915 	                   ISCSI_FLAG_DATA_OVERFLOW)) {
    916 		int res_count = be32_to_cpu(rhdr->residual_count);
    917 
    918 		if (res_count > 0 &&
    919 		    (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW ||
    920 		     res_count <= sc->sdb.length))
    921 			scsi_set_resid(sc, res_count);
    922 		else
    923 			sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
    924 	}
    925 
    926 	ISCSI_DBG_SESSION(conn->session, "data in with status done "
    927 			  "[sc %p res %d itt 0x%x]\n",
    928 			  sc, sc->result, task->itt);
    929 	conn->scsirsp_pdus_cnt++;
    930 	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
    931 }
    932 
    933 static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
    934 {
    935 	struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr;
    936 
    937 	conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
    938 	conn->tmfrsp_pdus_cnt++;
    939 
    940 	if (conn->tmf_state != TMF_QUEUED)
    941 		return;
    942 
    943 	if (tmf->response == ISCSI_TMF_RSP_COMPLETE)
    944 		conn->tmf_state = TMF_SUCCESS;
    945 	else if (tmf->response == ISCSI_TMF_RSP_NO_TASK)
    946 		conn->tmf_state = TMF_NOT_FOUND;
    947 	else
    948 		conn->tmf_state = TMF_FAILED;
    949 	wake_up(&conn->ehwait);
    950 }
    951 
    952 static int iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr)
    953 {
    954         struct iscsi_nopout hdr;
    955 	struct iscsi_task *task;
    956 
    957 	if (!rhdr && conn->ping_task)
    958 		return -EINVAL;
    959 
    960 	memset(&hdr, 0, sizeof(struct iscsi_nopout));
    961 	hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE;
    962 	hdr.flags = ISCSI_FLAG_CMD_FINAL;
    963 
    964 	if (rhdr) {
    965 		hdr.lun = rhdr->lun;
    966 		hdr.ttt = rhdr->ttt;
    967 		hdr.itt = RESERVED_ITT;
    968 	} else
    969 		hdr.ttt = RESERVED_ITT;
    970 
    971 	task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0);
    972 	if (!task) {
    973 		iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n");
    974 		return -EIO;
    975 	} else if (!rhdr) {
    976 		/* only track our nops */
    977 		conn->ping_task = task;
    978 		conn->last_ping = jiffies;
    979 	}
    980 
    981 	return 0;
    982 }
    983 
    984 /**
    985  * iscsi_nop_out_rsp - SCSI NOP Response processing
    986  * @task: scsi command task
    987  * @nop: the nop structure
    988  * @data: where to put the data
    989  * @datalen: length of data
    990  *
    991  * iscsi_nop_out_rsp handles nop response from use or
    992  * from user space. called under back_lock
    993  **/
    994 static int iscsi_nop_out_rsp(struct iscsi_task *task,
    995 			     struct iscsi_nopin *nop, char *data, int datalen)
    996 {
    997 	struct iscsi_conn *conn = task->conn;
    998 	int rc = 0;
    999 
   1000 	if (conn->ping_task != task) {
   1001 		/*
   1002 		 * If this is not in response to one of our
   1003 		 * nops then it must be from userspace.
   1004 		 */
   1005 		if (iscsi_recv_pdu(conn->cls_conn, (struct iscsi_hdr *)nop,
   1006 				   data, datalen))
   1007 			rc = ISCSI_ERR_CONN_FAILED;
   1008 	} else
   1009 		mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout);
   1010 	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
   1011 	return rc;
   1012 }
   1013 
   1014 static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
   1015 			       char *data, int datalen)
   1016 {
   1017 	struct iscsi_reject *reject = (struct iscsi_reject *)hdr;
   1018 	struct iscsi_hdr rejected_pdu;
   1019 	int opcode, rc = 0;
   1020 
   1021 	conn->exp_statsn = be32_to_cpu(reject->statsn) + 1;
   1022 
   1023 	if (ntoh24(reject->dlength) > datalen ||
   1024 	    ntoh24(reject->dlength) < sizeof(struct iscsi_hdr)) {
   1025 		iscsi_conn_printk(KERN_ERR, conn, "Cannot handle rejected "
   1026 				  "pdu. Invalid data length (pdu dlength "
   1027 				  "%u, datalen %d\n", ntoh24(reject->dlength),
   1028 				  datalen);
   1029 		return ISCSI_ERR_PROTO;
   1030 	}
   1031 	memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr));
   1032 	opcode = rejected_pdu.opcode & ISCSI_OPCODE_MASK;
   1033 
   1034 	switch (reject->reason) {
   1035 	case ISCSI_REASON_DATA_DIGEST_ERROR:
   1036 		iscsi_conn_printk(KERN_ERR, conn,
   1037 				  "pdu (op 0x%x itt 0x%x) rejected "
   1038 				  "due to DataDigest error.\n",
   1039 				  opcode, rejected_pdu.itt);
   1040 		break;
   1041 	case ISCSI_REASON_IMM_CMD_REJECT:
   1042 		iscsi_conn_printk(KERN_ERR, conn,
   1043 				  "pdu (op 0x%x itt 0x%x) rejected. Too many "
   1044 				  "immediate commands.\n",
   1045 				  opcode, rejected_pdu.itt);
   1046 		/*
   1047 		 * We only send one TMF at a time so if the target could not
   1048 		 * handle it, then it should get fixed (RFC mandates that
   1049 		 * a target can handle one immediate TMF per conn).
   1050 		 *
   1051 		 * For nops-outs, we could have sent more than one if
   1052 		 * the target is sending us lots of nop-ins
   1053 		 */
   1054 		if (opcode != ISCSI_OP_NOOP_OUT)
   1055 			return 0;
   1056 
   1057 		if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG)) {
   1058 			/*
   1059 			 * nop-out in response to target's nop-out rejected.
   1060 			 * Just resend.
   1061 			 */
   1062 			/* In RX path we are under back lock */
   1063 			spin_unlock(&conn->session->back_lock);
   1064 			spin_lock(&conn->session->frwd_lock);
   1065 			iscsi_send_nopout(conn,
   1066 					  (struct iscsi_nopin*)&rejected_pdu);
   1067 			spin_unlock(&conn->session->frwd_lock);
   1068 			spin_lock(&conn->session->back_lock);
   1069 		} else {
   1070 			struct iscsi_task *task;
   1071 			/*
   1072 			 * Our nop as ping got dropped. We know the target
   1073 			 * and transport are ok so just clean up
   1074 			 */
   1075 			task = iscsi_itt_to_task(conn, rejected_pdu.itt);
   1076 			if (!task) {
   1077 				iscsi_conn_printk(KERN_ERR, conn,
   1078 						 "Invalid pdu reject. Could "
   1079 						 "not lookup rejected task.\n");
   1080 				rc = ISCSI_ERR_BAD_ITT;
   1081 			} else
   1082 				rc = iscsi_nop_out_rsp(task,
   1083 					(struct iscsi_nopin*)&rejected_pdu,
   1084 					NULL, 0);
   1085 		}
   1086 		break;
   1087 	default:
   1088 		iscsi_conn_printk(KERN_ERR, conn,
   1089 				  "pdu (op 0x%x itt 0x%x) rejected. Reason "
   1090 				  "code 0x%x\n", rejected_pdu.opcode,
   1091 				  rejected_pdu.itt, reject->reason);
   1092 		break;
   1093 	}
   1094 	return rc;
   1095 }
   1096 
   1097 /**
   1098  * iscsi_itt_to_task - look up task by itt
   1099  * @conn: iscsi connection
   1100  * @itt: itt
   1101  *
   1102  * This should be used for mgmt tasks like login and nops, or if
   1103  * the LDD's itt space does not include the session age.
   1104  *
   1105  * The session back_lock must be held.
   1106  */
   1107 struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt)
   1108 {
   1109 	struct iscsi_session *session = conn->session;
   1110 	int i;
   1111 
   1112 	if (itt == RESERVED_ITT)
   1113 		return NULL;
   1114 
   1115 	if (session->tt->parse_pdu_itt)
   1116 		session->tt->parse_pdu_itt(conn, itt, &i, NULL);
   1117 	else
   1118 		i = get_itt(itt);
   1119 	if (i >= session->cmds_max)
   1120 		return NULL;
   1121 
   1122 	return session->cmds[i];
   1123 }
   1124 EXPORT_SYMBOL_GPL(iscsi_itt_to_task);
   1125 
   1126 /**
   1127  * __iscsi_complete_pdu - complete pdu
   1128  * @conn: iscsi conn
   1129  * @hdr: iscsi header
   1130  * @data: data buffer
   1131  * @datalen: len of data buffer
   1132  *
   1133  * Completes pdu processing by freeing any resources allocated at
   1134  * queuecommand or send generic. session back_lock must be held and verify
   1135  * itt must have been called.
   1136  */
   1137 int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
   1138 			 char *data, int datalen)
   1139 {
   1140 	struct iscsi_session *session = conn->session;
   1141 	int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0;
   1142 	struct iscsi_task *task;
   1143 	uint32_t itt;
   1144 
   1145 	conn->last_recv = jiffies;
   1146 	rc = iscsi_verify_itt(conn, hdr->itt);
   1147 	if (rc)
   1148 		return rc;
   1149 
   1150 	if (hdr->itt != RESERVED_ITT)
   1151 		itt = get_itt(hdr->itt);
   1152 	else
   1153 		itt = ~0U;
   1154 
   1155 	ISCSI_DBG_SESSION(session, "[op 0x%x cid %d itt 0x%x len %d]\n",
   1156 			  opcode, conn->id, itt, datalen);
   1157 
   1158 	if (itt == ~0U) {
   1159 		iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
   1160 
   1161 		switch(opcode) {
   1162 		case ISCSI_OP_NOOP_IN:
   1163 			if (datalen) {
   1164 				rc = ISCSI_ERR_PROTO;
   1165 				break;
   1166 			}
   1167 
   1168 			if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG))
   1169 				break;
   1170 
   1171 			/* In RX path we are under back lock */
   1172 			spin_unlock(&session->back_lock);
   1173 			spin_lock(&session->frwd_lock);
   1174 			iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr);
   1175 			spin_unlock(&session->frwd_lock);
   1176 			spin_lock(&session->back_lock);
   1177 			break;
   1178 		case ISCSI_OP_REJECT:
   1179 			rc = iscsi_handle_reject(conn, hdr, data, datalen);
   1180 			break;
   1181 		case ISCSI_OP_ASYNC_EVENT:
   1182 			conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
   1183 			if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen))
   1184 				rc = ISCSI_ERR_CONN_FAILED;
   1185 			break;
   1186 		default:
   1187 			rc = ISCSI_ERR_BAD_OPCODE;
   1188 			break;
   1189 		}
   1190 		goto out;
   1191 	}
   1192 
   1193 	switch(opcode) {
   1194 	case ISCSI_OP_SCSI_CMD_RSP:
   1195 	case ISCSI_OP_SCSI_DATA_IN:
   1196 		task = iscsi_itt_to_ctask(conn, hdr->itt);
   1197 		if (!task)
   1198 			return ISCSI_ERR_BAD_ITT;
   1199 		task->last_xfer = jiffies;
   1200 		break;
   1201 	case ISCSI_OP_R2T:
   1202 		/*
   1203 		 * LLD handles R2Ts if they need to.
   1204 		 */
   1205 		return 0;
   1206 	case ISCSI_OP_LOGOUT_RSP:
   1207 	case ISCSI_OP_LOGIN_RSP:
   1208 	case ISCSI_OP_TEXT_RSP:
   1209 	case ISCSI_OP_SCSI_TMFUNC_RSP:
   1210 	case ISCSI_OP_NOOP_IN:
   1211 		task = iscsi_itt_to_task(conn, hdr->itt);
   1212 		if (!task)
   1213 			return ISCSI_ERR_BAD_ITT;
   1214 		break;
   1215 	default:
   1216 		return ISCSI_ERR_BAD_OPCODE;
   1217 	}
   1218 
   1219 	switch(opcode) {
   1220 	case ISCSI_OP_SCSI_CMD_RSP:
   1221 		iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen);
   1222 		break;
   1223 	case ISCSI_OP_SCSI_DATA_IN:
   1224 		iscsi_data_in_rsp(conn, hdr, task);
   1225 		break;
   1226 	case ISCSI_OP_LOGOUT_RSP:
   1227 		iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
   1228 		if (datalen) {
   1229 			rc = ISCSI_ERR_PROTO;
   1230 			break;
   1231 		}
   1232 		conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
   1233 		goto recv_pdu;
   1234 	case ISCSI_OP_LOGIN_RSP:
   1235 	case ISCSI_OP_TEXT_RSP:
   1236 		iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
   1237 		/*
   1238 		 * login related PDU's exp_statsn is handled in
   1239 		 * userspace
   1240 		 */
   1241 		goto recv_pdu;
   1242 	case ISCSI_OP_SCSI_TMFUNC_RSP:
   1243 		iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
   1244 		if (datalen) {
   1245 			rc = ISCSI_ERR_PROTO;
   1246 			break;
   1247 		}
   1248 
   1249 		iscsi_tmf_rsp(conn, hdr);
   1250 		iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
   1251 		break;
   1252 	case ISCSI_OP_NOOP_IN:
   1253 		iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
   1254 		if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) {
   1255 			rc = ISCSI_ERR_PROTO;
   1256 			break;
   1257 		}
   1258 		conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
   1259 
   1260 		rc = iscsi_nop_out_rsp(task, (struct iscsi_nopin*)hdr,
   1261 				       data, datalen);
   1262 		break;
   1263 	default:
   1264 		rc = ISCSI_ERR_BAD_OPCODE;
   1265 		break;
   1266 	}
   1267 
   1268 out:
   1269 	return rc;
   1270 recv_pdu:
   1271 	if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen))
   1272 		rc = ISCSI_ERR_CONN_FAILED;
   1273 	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
   1274 	return rc;
   1275 }
   1276 EXPORT_SYMBOL_GPL(__iscsi_complete_pdu);
   1277 
   1278 int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
   1279 		       char *data, int datalen)
   1280 {
   1281 	int rc;
   1282 
   1283 	spin_lock(&conn->session->back_lock);
   1284 	rc = __iscsi_complete_pdu(conn, hdr, data, datalen);
   1285 	spin_unlock(&conn->session->back_lock);
   1286 	return rc;
   1287 }
   1288 EXPORT_SYMBOL_GPL(iscsi_complete_pdu);
   1289 
   1290 int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt)
   1291 {
   1292 	struct iscsi_session *session = conn->session;
   1293 	int age = 0, i = 0;
   1294 
   1295 	if (itt == RESERVED_ITT)
   1296 		return 0;
   1297 
   1298 	if (session->tt->parse_pdu_itt)
   1299 		session->tt->parse_pdu_itt(conn, itt, &i, &age);
   1300 	else {
   1301 		i = get_itt(itt);
   1302 		age = ((__force u32)itt >> ISCSI_AGE_SHIFT) & ISCSI_AGE_MASK;
   1303 	}
   1304 
   1305 	if (age != session->age) {
   1306 		iscsi_conn_printk(KERN_ERR, conn,
   1307 				  "received itt %x expected session age (%x)\n",
   1308 				  (__force u32)itt, session->age);
   1309 		return ISCSI_ERR_BAD_ITT;
   1310 	}
   1311 
   1312 	if (i >= session->cmds_max) {
   1313 		iscsi_conn_printk(KERN_ERR, conn,
   1314 				  "received invalid itt index %u (max cmds "
   1315 				   "%u.\n", i, session->cmds_max);
   1316 		return ISCSI_ERR_BAD_ITT;
   1317 	}
   1318 	return 0;
   1319 }
   1320 EXPORT_SYMBOL_GPL(iscsi_verify_itt);
   1321 
   1322 /**
   1323  * iscsi_itt_to_ctask - look up ctask by itt
   1324  * @conn: iscsi connection
   1325  * @itt: itt
   1326  *
   1327  * This should be used for cmd tasks.
   1328  *
   1329  * The session back_lock must be held.
   1330  */
   1331 struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt)
   1332 {
   1333 	struct iscsi_task *task;
   1334 
   1335 	if (iscsi_verify_itt(conn, itt))
   1336 		return NULL;
   1337 
   1338 	task = iscsi_itt_to_task(conn, itt);
   1339 	if (!task || !task->sc)
   1340 		return NULL;
   1341 
   1342 	if (task->sc->SCp.phase != conn->session->age) {
   1343 		iscsi_session_printk(KERN_ERR, conn->session,
   1344 				  "task's session age %d, expected %d\n",
   1345 				  task->sc->SCp.phase, conn->session->age);
   1346 		return NULL;
   1347 	}
   1348 
   1349 	return task;
   1350 }
   1351 EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask);
   1352 
   1353 void iscsi_session_failure(struct iscsi_session *session,
   1354 			   enum iscsi_err err)
   1355 {
   1356 	struct iscsi_conn *conn;
   1357 	struct device *dev;
   1358 
   1359 	spin_lock_bh(&session->frwd_lock);
   1360 	conn = session->leadconn;
   1361 	if (session->state == ISCSI_STATE_TERMINATE || !conn) {
   1362 		spin_unlock_bh(&session->frwd_lock);
   1363 		return;
   1364 	}
   1365 
   1366 	dev = get_device(&conn->cls_conn->dev);
   1367 	spin_unlock_bh(&session->frwd_lock);
   1368 	if (!dev)
   1369 	        return;
   1370 	/*
   1371 	 * if the host is being removed bypass the connection
   1372 	 * recovery initialization because we are going to kill
   1373 	 * the session.
   1374 	 */
   1375 	if (err == ISCSI_ERR_INVALID_HOST)
   1376 		iscsi_conn_error_event(conn->cls_conn, err);
   1377 	else
   1378 		iscsi_conn_failure(conn, err);
   1379 	put_device(dev);
   1380 }
   1381 EXPORT_SYMBOL_GPL(iscsi_session_failure);
   1382 
   1383 void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err)
   1384 {
   1385 	struct iscsi_session *session = conn->session;
   1386 
   1387 	spin_lock_bh(&session->frwd_lock);
   1388 	if (session->state == ISCSI_STATE_FAILED) {
   1389 		spin_unlock_bh(&session->frwd_lock);
   1390 		return;
   1391 	}
   1392 
   1393 	if (conn->stop_stage == 0)
   1394 		session->state = ISCSI_STATE_FAILED;
   1395 	spin_unlock_bh(&session->frwd_lock);
   1396 
   1397 	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
   1398 	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
   1399 	iscsi_conn_error_event(conn->cls_conn, err);
   1400 }
   1401 EXPORT_SYMBOL_GPL(iscsi_conn_failure);
   1402 
   1403 static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn)
   1404 {
   1405 	struct iscsi_session *session = conn->session;
   1406 
   1407 	/*
   1408 	 * Check for iSCSI window and take care of CmdSN wrap-around
   1409 	 */
   1410 	if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) {
   1411 		ISCSI_DBG_SESSION(session, "iSCSI CmdSN closed. ExpCmdSn "
   1412 				  "%u MaxCmdSN %u CmdSN %u/%u\n",
   1413 				  session->exp_cmdsn, session->max_cmdsn,
   1414 				  session->cmdsn, session->queued_cmdsn);
   1415 		return -ENOSPC;
   1416 	}
   1417 	return 0;
   1418 }
   1419 
   1420 static int iscsi_xmit_task(struct iscsi_conn *conn)
   1421 {
   1422 	struct iscsi_task *task = conn->task;
   1423 	int rc;
   1424 
   1425 	if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx))
   1426 		return -ENODATA;
   1427 
   1428 	spin_lock_bh(&conn->session->back_lock);
   1429 	if (conn->task == NULL) {
   1430 		spin_unlock_bh(&conn->session->back_lock);
   1431 		return -ENODATA;
   1432 	}
   1433 	__iscsi_get_task(task);
   1434 	spin_unlock_bh(&conn->session->back_lock);
   1435 	spin_unlock_bh(&conn->session->frwd_lock);
   1436 	rc = conn->session->tt->xmit_task(task);
   1437 	spin_lock_bh(&conn->session->frwd_lock);
   1438 	if (!rc) {
   1439 		/* done with this task */
   1440 		task->last_xfer = jiffies;
   1441 		conn->task = NULL;
   1442 	}
   1443 	/* regular RX path uses back_lock */
   1444 	spin_lock(&conn->session->back_lock);
   1445 	__iscsi_put_task(task);
   1446 	spin_unlock(&conn->session->back_lock);
   1447 	return rc;
   1448 }
   1449 
   1450 /**
   1451  * iscsi_requeue_task - requeue task to run from session workqueue
   1452  * @task: task to requeue
   1453  *
   1454  * LLDs that need to run a task from the session workqueue should call
   1455  * this. The session frwd_lock must be held. This should only be called
   1456  * by software drivers.
   1457  */
   1458 void iscsi_requeue_task(struct iscsi_task *task)
   1459 {
   1460 	struct iscsi_conn *conn = task->conn;
   1461 
   1462 	/*
   1463 	 * this may be on the requeue list already if the xmit_task callout
   1464 	 * is handling the r2ts while we are adding new ones
   1465 	 */
   1466 	spin_lock_bh(&conn->taskqueuelock);
   1467 	if (list_empty(&task->running))
   1468 		list_add_tail(&task->running, &conn->requeue);
   1469 	spin_unlock_bh(&conn->taskqueuelock);
   1470 	iscsi_conn_queue_work(conn);
   1471 }
   1472 EXPORT_SYMBOL_GPL(iscsi_requeue_task);
   1473 
   1474 /**
   1475  * iscsi_data_xmit - xmit any command into the scheduled connection
   1476  * @conn: iscsi connection
   1477  *
   1478  * Notes:
   1479  *	The function can return -EAGAIN in which case the caller must
   1480  *	re-schedule it again later or recover. '0' return code means
   1481  *	successful xmit.
   1482  **/
   1483 static int iscsi_data_xmit(struct iscsi_conn *conn)
   1484 {
   1485 	struct iscsi_task *task;
   1486 	int rc = 0;
   1487 
   1488 	spin_lock_bh(&conn->session->frwd_lock);
   1489 	if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) {
   1490 		ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n");
   1491 		spin_unlock_bh(&conn->session->frwd_lock);
   1492 		return -ENODATA;
   1493 	}
   1494 
   1495 	if (conn->task) {
   1496 		rc = iscsi_xmit_task(conn);
   1497 	        if (rc)
   1498 		        goto done;
   1499 	}
   1500 
   1501 	/*
   1502 	 * process mgmt pdus like nops before commands since we should
   1503 	 * only have one nop-out as a ping from us and targets should not
   1504 	 * overflow us with nop-ins
   1505 	 */
   1506 	spin_lock_bh(&conn->taskqueuelock);
   1507 check_mgmt:
   1508 	while (!list_empty(&conn->mgmtqueue)) {
   1509 		conn->task = list_entry(conn->mgmtqueue.next,
   1510 					 struct iscsi_task, running);
   1511 		list_del_init(&conn->task->running);
   1512 		spin_unlock_bh(&conn->taskqueuelock);
   1513 		if (iscsi_prep_mgmt_task(conn, conn->task)) {
   1514 			/* regular RX path uses back_lock */
   1515 			spin_lock_bh(&conn->session->back_lock);
   1516 			__iscsi_put_task(conn->task);
   1517 			spin_unlock_bh(&conn->session->back_lock);
   1518 			conn->task = NULL;
   1519 			spin_lock_bh(&conn->taskqueuelock);
   1520 			continue;
   1521 		}
   1522 		rc = iscsi_xmit_task(conn);
   1523 		if (rc)
   1524 			goto done;
   1525 		spin_lock_bh(&conn->taskqueuelock);
   1526 	}
   1527 
   1528 	/* process pending command queue */
   1529 	while (!list_empty(&conn->cmdqueue)) {
   1530 		conn->task = list_entry(conn->cmdqueue.next, struct iscsi_task,
   1531 					running);
   1532 		list_del_init(&conn->task->running);
   1533 		spin_unlock_bh(&conn->taskqueuelock);
   1534 		if (conn->session->state == ISCSI_STATE_LOGGING_OUT) {
   1535 			fail_scsi_task(conn->task, DID_IMM_RETRY);
   1536 			spin_lock_bh(&conn->taskqueuelock);
   1537 			continue;
   1538 		}
   1539 		rc = iscsi_prep_scsi_cmd_pdu(conn->task);
   1540 		if (rc) {
   1541 			if (rc == -ENOMEM || rc == -EACCES) {
   1542 				spin_lock_bh(&conn->taskqueuelock);
   1543 				list_add_tail(&conn->task->running,
   1544 					      &conn->cmdqueue);
   1545 				conn->task = NULL;
   1546 				spin_unlock_bh(&conn->taskqueuelock);
   1547 				goto done;
   1548 			} else
   1549 				fail_scsi_task(conn->task, DID_ABORT);
   1550 			spin_lock_bh(&conn->taskqueuelock);
   1551 			continue;
   1552 		}
   1553 		rc = iscsi_xmit_task(conn);
   1554 		if (rc)
   1555 			goto done;
   1556 		/*
   1557 		 * we could continuously get new task requests so
   1558 		 * we need to check the mgmt queue for nops that need to
   1559 		 * be sent to aviod starvation
   1560 		 */
   1561 		spin_lock_bh(&conn->taskqueuelock);
   1562 		if (!list_empty(&conn->mgmtqueue))
   1563 			goto check_mgmt;
   1564 	}
   1565 
   1566 	while (!list_empty(&conn->requeue)) {
   1567 		/*
   1568 		 * we always do fastlogout - conn stop code will clean up.
   1569 		 */
   1570 		if (conn->session->state == ISCSI_STATE_LOGGING_OUT)
   1571 			break;
   1572 
   1573 		task = list_entry(conn->requeue.next, struct iscsi_task,
   1574 				  running);
   1575 		if (iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_DATA_OUT))
   1576 			break;
   1577 
   1578 		conn->task = task;
   1579 		list_del_init(&conn->task->running);
   1580 		conn->task->state = ISCSI_TASK_RUNNING;
   1581 		spin_unlock_bh(&conn->taskqueuelock);
   1582 		rc = iscsi_xmit_task(conn);
   1583 		if (rc)
   1584 			goto done;
   1585 		spin_lock_bh(&conn->taskqueuelock);
   1586 		if (!list_empty(&conn->mgmtqueue))
   1587 			goto check_mgmt;
   1588 	}
   1589 	spin_unlock_bh(&conn->taskqueuelock);
   1590 	spin_unlock_bh(&conn->session->frwd_lock);
   1591 	return -ENODATA;
   1592 
   1593 done:
   1594 	spin_unlock_bh(&conn->session->frwd_lock);
   1595 	return rc;
   1596 }
   1597 
   1598 static void iscsi_xmitworker(struct work_struct *work)
   1599 {
   1600 	struct iscsi_conn *conn =
   1601 		container_of(work, struct iscsi_conn, xmitwork);
   1602 	int rc;
   1603 	/*
   1604 	 * serialize Xmit worker on a per-connection basis.
   1605 	 */
   1606 	do {
   1607 		rc = iscsi_data_xmit(conn);
   1608 	} while (rc >= 0 || rc == -EAGAIN);
   1609 }
   1610 
   1611 static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn,
   1612 						  struct scsi_cmnd *sc)
   1613 {
   1614 	struct iscsi_task *task;
   1615 
   1616 	if (!kfifo_out(&conn->session->cmdpool.queue,
   1617 			 (void *) &task, sizeof(void *)))
   1618 		return NULL;
   1619 
   1620 	sc->SCp.phase = conn->session->age;
   1621 	sc->SCp.ptr = (char *) task;
   1622 
   1623 	refcount_set(&task->refcount, 1);
   1624 	task->state = ISCSI_TASK_PENDING;
   1625 	task->conn = conn;
   1626 	task->sc = sc;
   1627 	task->have_checked_conn = false;
   1628 	task->last_timeout = jiffies;
   1629 	task->last_xfer = jiffies;
   1630 	task->protected = false;
   1631 	INIT_LIST_HEAD(&task->running);
   1632 	return task;
   1633 }
   1634 
   1635 enum {
   1636 	FAILURE_BAD_HOST = 1,
   1637 	FAILURE_SESSION_FAILED,
   1638 	FAILURE_SESSION_FREED,
   1639 	FAILURE_WINDOW_CLOSED,
   1640 	FAILURE_OOM,
   1641 	FAILURE_SESSION_TERMINATE,
   1642 	FAILURE_SESSION_IN_RECOVERY,
   1643 	FAILURE_SESSION_RECOVERY_TIMEOUT,
   1644 	FAILURE_SESSION_LOGGING_OUT,
   1645 	FAILURE_SESSION_NOT_READY,
   1646 };
   1647 
   1648 int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc)
   1649 {
   1650 	struct iscsi_cls_session *cls_session;
   1651 	struct iscsi_host *ihost;
   1652 	int reason = 0;
   1653 	struct iscsi_session *session;
   1654 	struct iscsi_conn *conn;
   1655 	struct iscsi_task *task = NULL;
   1656 
   1657 	sc->result = 0;
   1658 	sc->SCp.ptr = NULL;
   1659 
   1660 	ihost = shost_priv(host);
   1661 
   1662 	cls_session = starget_to_session(scsi_target(sc->device));
   1663 	session = cls_session->dd_data;
   1664 	spin_lock_bh(&session->frwd_lock);
   1665 
   1666 	reason = iscsi_session_chkready(cls_session);
   1667 	if (reason) {
   1668 		sc->result = reason;
   1669 		goto fault;
   1670 	}
   1671 
   1672 	if (session->state != ISCSI_STATE_LOGGED_IN) {
   1673 		/*
   1674 		 * to handle the race between when we set the recovery state
   1675 		 * and block the session we requeue here (commands could
   1676 		 * be entering our queuecommand while a block is starting
   1677 		 * up because the block code is not locked)
   1678 		 */
   1679 		switch (session->state) {
   1680 		case ISCSI_STATE_FAILED:
   1681 			/*
   1682 			 * cmds should fail during shutdown, if the session
   1683 			 * state is bad, allowing completion to happen
   1684 			 */
   1685 			if (unlikely(system_state != SYSTEM_RUNNING)) {
   1686 				reason = FAILURE_SESSION_FAILED;
   1687 				sc->result = DID_NO_CONNECT << 16;
   1688 				break;
   1689 			}
   1690 			/* fall through */
   1691 		case ISCSI_STATE_IN_RECOVERY:
   1692 			reason = FAILURE_SESSION_IN_RECOVERY;
   1693 			sc->result = DID_IMM_RETRY << 16;
   1694 			break;
   1695 		case ISCSI_STATE_LOGGING_OUT:
   1696 			reason = FAILURE_SESSION_LOGGING_OUT;
   1697 			sc->result = DID_IMM_RETRY << 16;
   1698 			break;
   1699 		case ISCSI_STATE_RECOVERY_FAILED:
   1700 			reason = FAILURE_SESSION_RECOVERY_TIMEOUT;
   1701 			sc->result = DID_TRANSPORT_FAILFAST << 16;
   1702 			break;
   1703 		case ISCSI_STATE_TERMINATE:
   1704 			reason = FAILURE_SESSION_TERMINATE;
   1705 			sc->result = DID_NO_CONNECT << 16;
   1706 			break;
   1707 		default:
   1708 			reason = FAILURE_SESSION_FREED;
   1709 			sc->result = DID_NO_CONNECT << 16;
   1710 		}
   1711 		goto fault;
   1712 	}
   1713 
   1714 	conn = session->leadconn;
   1715 	if (!conn) {
   1716 		reason = FAILURE_SESSION_FREED;
   1717 		sc->result = DID_NO_CONNECT << 16;
   1718 		goto fault;
   1719 	}
   1720 
   1721 	if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) {
   1722 		reason = FAILURE_SESSION_IN_RECOVERY;
   1723 		sc->result = DID_REQUEUE << 16;
   1724 		goto fault;
   1725 	}
   1726 
   1727 	if (iscsi_check_cmdsn_window_closed(conn)) {
   1728 		reason = FAILURE_WINDOW_CLOSED;
   1729 		goto reject;
   1730 	}
   1731 
   1732 	task = iscsi_alloc_task(conn, sc);
   1733 	if (!task) {
   1734 		reason = FAILURE_OOM;
   1735 		goto reject;
   1736 	}
   1737 
   1738 	if (!ihost->workq) {
   1739 		reason = iscsi_prep_scsi_cmd_pdu(task);
   1740 		if (reason) {
   1741 			if (reason == -ENOMEM ||  reason == -EACCES) {
   1742 				reason = FAILURE_OOM;
   1743 				goto prepd_reject;
   1744 			} else {
   1745 				sc->result = DID_ABORT << 16;
   1746 				goto prepd_fault;
   1747 			}
   1748 		}
   1749 		if (session->tt->xmit_task(task)) {
   1750 			session->cmdsn--;
   1751 			reason = FAILURE_SESSION_NOT_READY;
   1752 			goto prepd_reject;
   1753 		}
   1754 	} else {
   1755 		spin_lock_bh(&conn->taskqueuelock);
   1756 		list_add_tail(&task->running, &conn->cmdqueue);
   1757 		spin_unlock_bh(&conn->taskqueuelock);
   1758 		iscsi_conn_queue_work(conn);
   1759 	}
   1760 
   1761 	session->queued_cmdsn++;
   1762 	spin_unlock_bh(&session->frwd_lock);
   1763 	return 0;
   1764 
   1765 prepd_reject:
   1766 	spin_lock_bh(&session->back_lock);
   1767 	iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ);
   1768 	spin_unlock_bh(&session->back_lock);
   1769 reject:
   1770 	spin_unlock_bh(&session->frwd_lock);
   1771 	ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n",
   1772 			  sc->cmnd[0], reason);
   1773 	return SCSI_MLQUEUE_TARGET_BUSY;
   1774 
   1775 prepd_fault:
   1776 	spin_lock_bh(&session->back_lock);
   1777 	iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ);
   1778 	spin_unlock_bh(&session->back_lock);
   1779 fault:
   1780 	spin_unlock_bh(&session->frwd_lock);
   1781 	ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n",
   1782 			  sc->cmnd[0], reason);
   1783 	scsi_set_resid(sc, scsi_bufflen(sc));
   1784 	sc->scsi_done(sc);
   1785 	return 0;
   1786 }
   1787 EXPORT_SYMBOL_GPL(iscsi_queuecommand);
   1788 
   1789 int iscsi_target_alloc(struct scsi_target *starget)
   1790 {
   1791 	struct iscsi_cls_session *cls_session = starget_to_session(starget);
   1792 	struct iscsi_session *session = cls_session->dd_data;
   1793 
   1794 	starget->can_queue = session->scsi_cmds_max;
   1795 	return 0;
   1796 }
   1797 EXPORT_SYMBOL_GPL(iscsi_target_alloc);
   1798 
   1799 static void iscsi_tmf_timedout(struct timer_list *t)
   1800 {
   1801 	struct iscsi_conn *conn = from_timer(conn, t, tmf_timer);
   1802 	struct iscsi_session *session = conn->session;
   1803 
   1804 	spin_lock(&session->frwd_lock);
   1805 	if (conn->tmf_state == TMF_QUEUED) {
   1806 		conn->tmf_state = TMF_TIMEDOUT;
   1807 		ISCSI_DBG_EH(session, "tmf timedout\n");
   1808 		/* unblock eh_abort() */
   1809 		wake_up(&conn->ehwait);
   1810 	}
   1811 	spin_unlock(&session->frwd_lock);
   1812 }
   1813 
   1814 static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn,
   1815 				   struct iscsi_tm *hdr, int age,
   1816 				   int timeout)
   1817 	__must_hold(&session->frwd_lock)
   1818 {
   1819 	struct iscsi_session *session = conn->session;
   1820 	struct iscsi_task *task;
   1821 
   1822 	task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr,
   1823 				      NULL, 0);
   1824 	if (!task) {
   1825 		spin_unlock_bh(&session->frwd_lock);
   1826 		iscsi_conn_printk(KERN_ERR, conn, "Could not send TMF.\n");
   1827 		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
   1828 		spin_lock_bh(&session->frwd_lock);
   1829 		return -EPERM;
   1830 	}
   1831 	conn->tmfcmd_pdus_cnt++;
   1832 	conn->tmf_timer.expires = timeout * HZ + jiffies;
   1833 	add_timer(&conn->tmf_timer);
   1834 	ISCSI_DBG_EH(session, "tmf set timeout\n");
   1835 
   1836 	spin_unlock_bh(&session->frwd_lock);
   1837 	mutex_unlock(&session->eh_mutex);
   1838 
   1839 	/*
   1840 	 * block eh thread until:
   1841 	 *
   1842 	 * 1) tmf response
   1843 	 * 2) tmf timeout
   1844 	 * 3) session is terminated or restarted or userspace has
   1845 	 * given up on recovery
   1846 	 */
   1847 	wait_event_interruptible(conn->ehwait, age != session->age ||
   1848 				 session->state != ISCSI_STATE_LOGGED_IN ||
   1849 				 conn->tmf_state != TMF_QUEUED);
   1850 	if (signal_pending(current))
   1851 		flush_signals(current);
   1852 	del_timer_sync(&conn->tmf_timer);
   1853 
   1854 	mutex_lock(&session->eh_mutex);
   1855 	spin_lock_bh(&session->frwd_lock);
   1856 	/* if the session drops it will clean up the task */
   1857 	if (age != session->age ||
   1858 	    session->state != ISCSI_STATE_LOGGED_IN)
   1859 		return -ENOTCONN;
   1860 	return 0;
   1861 }
   1862 
   1863 /*
   1864  * Fail commands. session lock held and recv side suspended and xmit
   1865  * thread flushed
   1866  */
   1867 static void fail_scsi_tasks(struct iscsi_conn *conn, u64 lun, int error)
   1868 {
   1869 	struct iscsi_task *task;
   1870 	int i;
   1871 
   1872 	for (i = 0; i < conn->session->cmds_max; i++) {
   1873 		task = conn->session->cmds[i];
   1874 		if (!task->sc || task->state == ISCSI_TASK_FREE)
   1875 			continue;
   1876 
   1877 		if (lun != -1 && lun != task->sc->device->lun)
   1878 			continue;
   1879 
   1880 		ISCSI_DBG_SESSION(conn->session,
   1881 				  "failing sc %p itt 0x%x state %d\n",
   1882 				  task->sc, task->itt, task->state);
   1883 		fail_scsi_task(task, error);
   1884 	}
   1885 }
   1886 
   1887 /**
   1888  * iscsi_suspend_queue - suspend iscsi_queuecommand
   1889  * @conn: iscsi conn to stop queueing IO on
   1890  *
   1891  * This grabs the session frwd_lock to make sure no one is in
   1892  * xmit_task/queuecommand, and then sets suspend to prevent
   1893  * new commands from being queued. This only needs to be called
   1894  * by offload drivers that need to sync a path like ep disconnect
   1895  * with the iscsi_queuecommand/xmit_task. To start IO again libiscsi
   1896  * will call iscsi_start_tx and iscsi_unblock_session when in FFP.
   1897  */
   1898 void iscsi_suspend_queue(struct iscsi_conn *conn)
   1899 {
   1900 	spin_lock_bh(&conn->session->frwd_lock);
   1901 	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
   1902 	spin_unlock_bh(&conn->session->frwd_lock);
   1903 }
   1904 EXPORT_SYMBOL_GPL(iscsi_suspend_queue);
   1905 
   1906 /**
   1907  * iscsi_suspend_tx - suspend iscsi_data_xmit
   1908  * @conn: iscsi conn tp stop processing IO on.
   1909  *
   1910  * This function sets the suspend bit to prevent iscsi_data_xmit
   1911  * from sending new IO, and if work is queued on the xmit thread
   1912  * it will wait for it to be completed.
   1913  */
   1914 void iscsi_suspend_tx(struct iscsi_conn *conn)
   1915 {
   1916 	struct Scsi_Host *shost = conn->session->host;
   1917 	struct iscsi_host *ihost = shost_priv(shost);
   1918 
   1919 	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
   1920 	if (ihost->workq)
   1921 		flush_workqueue(ihost->workq);
   1922 }
   1923 EXPORT_SYMBOL_GPL(iscsi_suspend_tx);
   1924 
   1925 static void iscsi_start_tx(struct iscsi_conn *conn)
   1926 {
   1927 	clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
   1928 	iscsi_conn_queue_work(conn);
   1929 }
   1930 
   1931 /*
   1932  * We want to make sure a ping is in flight. It has timed out.
   1933  * And we are not busy processing a pdu that is making
   1934  * progress but got started before the ping and is taking a while
   1935  * to complete so the ping is just stuck behind it in a queue.
   1936  */
   1937 static int iscsi_has_ping_timed_out(struct iscsi_conn *conn)
   1938 {
   1939 	if (conn->ping_task &&
   1940 	    time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) +
   1941 			   (conn->ping_timeout * HZ), jiffies))
   1942 		return 1;
   1943 	else
   1944 		return 0;
   1945 }
   1946 
   1947 enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
   1948 {
   1949 	enum blk_eh_timer_return rc = BLK_EH_DONE;
   1950 	struct iscsi_task *task = NULL, *running_task;
   1951 	struct iscsi_cls_session *cls_session;
   1952 	struct iscsi_session *session;
   1953 	struct iscsi_conn *conn;
   1954 	int i;
   1955 
   1956 	cls_session = starget_to_session(scsi_target(sc->device));
   1957 	session = cls_session->dd_data;
   1958 
   1959 	ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc);
   1960 
   1961 	spin_lock(&session->frwd_lock);
   1962 	task = (struct iscsi_task *)sc->SCp.ptr;
   1963 	if (!task) {
   1964 		/*
   1965 		 * Raced with completion. Blk layer has taken ownership
   1966 		 * so let timeout code complete it now.
   1967 		 */
   1968 		rc = BLK_EH_DONE;
   1969 		goto done;
   1970 	}
   1971 
   1972 	if (session->state != ISCSI_STATE_LOGGED_IN) {
   1973 		/*
   1974 		 * During shutdown, if session is prematurely disconnected,
   1975 		 * recovery won't happen and there will be hung cmds. Not
   1976 		 * handling cmds would trigger EH, also bad in this case.
   1977 		 * Instead, handle cmd, allow completion to happen and let
   1978 		 * upper layer to deal with the result.
   1979 		 */
   1980 		if (unlikely(system_state != SYSTEM_RUNNING)) {
   1981 			sc->result = DID_NO_CONNECT << 16;
   1982 			ISCSI_DBG_EH(session, "sc on shutdown, handled\n");
   1983 			rc = BLK_EH_DONE;
   1984 			goto done;
   1985 		}
   1986 		/*
   1987 		 * We are probably in the middle of iscsi recovery so let
   1988 		 * that complete and handle the error.
   1989 		 */
   1990 		rc = BLK_EH_RESET_TIMER;
   1991 		goto done;
   1992 	}
   1993 
   1994 	conn = session->leadconn;
   1995 	if (!conn) {
   1996 		/* In the middle of shuting down */
   1997 		rc = BLK_EH_RESET_TIMER;
   1998 		goto done;
   1999 	}
   2000 
   2001 	/*
   2002 	 * If we have sent (at least queued to the network layer) a pdu or
   2003 	 * recvd one for the task since the last timeout ask for
   2004 	 * more time. If on the next timeout we have not made progress
   2005 	 * we can check if it is the task or connection when we send the
   2006 	 * nop as a ping.
   2007 	 */
   2008 	if (time_after(task->last_xfer, task->last_timeout)) {
   2009 		ISCSI_DBG_EH(session, "Command making progress. Asking "
   2010 			     "scsi-ml for more time to complete. "
   2011 			     "Last data xfer at %lu. Last timeout was at "
   2012 			     "%lu\n.", task->last_xfer, task->last_timeout);
   2013 		task->have_checked_conn = false;
   2014 		rc = BLK_EH_RESET_TIMER;
   2015 		goto done;
   2016 	}
   2017 
   2018 	if (!conn->recv_timeout && !conn->ping_timeout)
   2019 		goto done;
   2020 	/*
   2021 	 * if the ping timedout then we are in the middle of cleaning up
   2022 	 * and can let the iscsi eh handle it
   2023 	 */
   2024 	if (iscsi_has_ping_timed_out(conn)) {
   2025 		rc = BLK_EH_RESET_TIMER;
   2026 		goto done;
   2027 	}
   2028 
   2029 	for (i = 0; i < conn->session->cmds_max; i++) {
   2030 		running_task = conn->session->cmds[i];
   2031 		if (!running_task->sc || running_task == task ||
   2032 		     running_task->state != ISCSI_TASK_RUNNING)
   2033 			continue;
   2034 
   2035 		/*
   2036 		 * Only check if cmds started before this one have made
   2037 		 * progress, or this could never fail
   2038 		 */
   2039 		if (time_after(running_task->sc->jiffies_at_alloc,
   2040 			       task->sc->jiffies_at_alloc))
   2041 			continue;
   2042 
   2043 		if (time_after(running_task->last_xfer, task->last_timeout)) {
   2044 			/*
   2045 			 * This task has not made progress, but a task
   2046 			 * started before us has transferred data since
   2047 			 * we started/last-checked. We could be queueing
   2048 			 * too many tasks or the LU is bad.
   2049 			 *
   2050 			 * If the device is bad the cmds ahead of us on
   2051 			 * other devs will complete, and this loop will
   2052 			 * eventually fail starting the scsi eh.
   2053 			 */
   2054 			ISCSI_DBG_EH(session, "Command has not made progress "
   2055 				     "but commands ahead of it have. "
   2056 				     "Asking scsi-ml for more time to "
   2057 				     "complete. Our last xfer vs running task "
   2058 				     "last xfer %lu/%lu. Last check %lu.\n",
   2059 				     task->last_xfer, running_task->last_xfer,
   2060 				     task->last_timeout);
   2061 			rc = BLK_EH_RESET_TIMER;
   2062 			goto done;
   2063 		}
   2064 	}
   2065 
   2066 	/* Assumes nop timeout is shorter than scsi cmd timeout */
   2067 	if (task->have_checked_conn)
   2068 		goto done;
   2069 
   2070 	/*
   2071 	 * Checking the transport already or nop from a cmd timeout still
   2072 	 * running
   2073 	 */
   2074 	if (conn->ping_task) {
   2075 		task->have_checked_conn = true;
   2076 		rc = BLK_EH_RESET_TIMER;
   2077 		goto done;
   2078 	}
   2079 
   2080 	/* Make sure there is a transport check done */
   2081 	iscsi_send_nopout(conn, NULL);
   2082 	task->have_checked_conn = true;
   2083 	rc = BLK_EH_RESET_TIMER;
   2084 
   2085 done:
   2086 	if (task)
   2087 		task->last_timeout = jiffies;
   2088 	spin_unlock(&session->frwd_lock);
   2089 	ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ?
   2090 		     "timer reset" : "shutdown or nh");
   2091 	return rc;
   2092 }
   2093 EXPORT_SYMBOL_GPL(iscsi_eh_cmd_timed_out);
   2094 
   2095 static void iscsi_check_transport_timeouts(struct timer_list *t)
   2096 {
   2097 	struct iscsi_conn *conn = from_timer(conn, t, transport_timer);
   2098 	struct iscsi_session *session = conn->session;
   2099 	unsigned long recv_timeout, next_timeout = 0, last_recv;
   2100 
   2101 	spin_lock(&session->frwd_lock);
   2102 	if (session->state != ISCSI_STATE_LOGGED_IN)
   2103 		goto done;
   2104 
   2105 	recv_timeout = conn->recv_timeout;
   2106 	if (!recv_timeout)
   2107 		goto done;
   2108 
   2109 	recv_timeout *= HZ;
   2110 	last_recv = conn->last_recv;
   2111 
   2112 	if (iscsi_has_ping_timed_out(conn)) {
   2113 		iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs "
   2114 				  "expired, recv timeout %d, last rx %lu, "
   2115 				  "last ping %lu, now %lu\n",
   2116 				  conn->ping_timeout, conn->recv_timeout,
   2117 				  last_recv, conn->last_ping, jiffies);
   2118 		spin_unlock(&session->frwd_lock);
   2119 		iscsi_conn_failure(conn, ISCSI_ERR_NOP_TIMEDOUT);
   2120 		return;
   2121 	}
   2122 
   2123 	if (time_before_eq(last_recv + recv_timeout, jiffies)) {
   2124 		/* send a ping to try to provoke some traffic */
   2125 		ISCSI_DBG_CONN(conn, "Sending nopout as ping\n");
   2126 		if (iscsi_send_nopout(conn, NULL))
   2127 			next_timeout = jiffies + (1 * HZ);
   2128 		else
   2129 			next_timeout = conn->last_ping + (conn->ping_timeout * HZ);
   2130 	} else
   2131 		next_timeout = last_recv + recv_timeout;
   2132 
   2133 	ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout);
   2134 	mod_timer(&conn->transport_timer, next_timeout);
   2135 done:
   2136 	spin_unlock(&session->frwd_lock);
   2137 }
   2138 
   2139 static void iscsi_prep_abort_task_pdu(struct iscsi_task *task,
   2140 				      struct iscsi_tm *hdr)
   2141 {
   2142 	memset(hdr, 0, sizeof(*hdr));
   2143 	hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE;
   2144 	hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK;
   2145 	hdr->flags |= ISCSI_FLAG_CMD_FINAL;
   2146 	hdr->lun = task->lun;
   2147 	hdr->rtt = task->hdr_itt;
   2148 	hdr->refcmdsn = task->cmdsn;
   2149 }
   2150 
   2151 int iscsi_eh_abort(struct scsi_cmnd *sc)
   2152 {
   2153 	struct iscsi_cls_session *cls_session;
   2154 	struct iscsi_session *session;
   2155 	struct iscsi_conn *conn;
   2156 	struct iscsi_task *task;
   2157 	struct iscsi_tm *hdr;
   2158 	int age;
   2159 
   2160 	cls_session = starget_to_session(scsi_target(sc->device));
   2161 	session = cls_session->dd_data;
   2162 
   2163 	ISCSI_DBG_EH(session, "aborting sc %p\n", sc);
   2164 
   2165 	mutex_lock(&session->eh_mutex);
   2166 	spin_lock_bh(&session->frwd_lock);
   2167 	/*
   2168 	 * if session was ISCSI_STATE_IN_RECOVERY then we may not have
   2169 	 * got the command.
   2170 	 */
   2171 	if (!sc->SCp.ptr) {
   2172 		ISCSI_DBG_EH(session, "sc never reached iscsi layer or "
   2173 				      "it completed.\n");
   2174 		spin_unlock_bh(&session->frwd_lock);
   2175 		mutex_unlock(&session->eh_mutex);
   2176 		return SUCCESS;
   2177 	}
   2178 
   2179 	/*
   2180 	 * If we are not logged in or we have started a new session
   2181 	 * then let the host reset code handle this
   2182 	 */
   2183 	if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN ||
   2184 	    sc->SCp.phase != session->age) {
   2185 		spin_unlock_bh(&session->frwd_lock);
   2186 		mutex_unlock(&session->eh_mutex);
   2187 		ISCSI_DBG_EH(session, "failing abort due to dropped "
   2188 				  "session.\n");
   2189 		return FAILED;
   2190 	}
   2191 
   2192 	conn = session->leadconn;
   2193 	conn->eh_abort_cnt++;
   2194 	age = session->age;
   2195 
   2196 	task = (struct iscsi_task *)sc->SCp.ptr;
   2197 	ISCSI_DBG_EH(session, "aborting [sc %p itt 0x%x]\n",
   2198 		     sc, task->itt);
   2199 
   2200 	/* task completed before time out */
   2201 	if (!task->sc) {
   2202 		ISCSI_DBG_EH(session, "sc completed while abort in progress\n");
   2203 		goto success;
   2204 	}
   2205 
   2206 	if (task->state == ISCSI_TASK_PENDING) {
   2207 		fail_scsi_task(task, DID_ABORT);
   2208 		goto success;
   2209 	}
   2210 
   2211 	/* only have one tmf outstanding at a time */
   2212 	if (conn->tmf_state != TMF_INITIAL)
   2213 		goto failed;
   2214 	conn->tmf_state = TMF_QUEUED;
   2215 
   2216 	hdr = &conn->tmhdr;
   2217 	iscsi_prep_abort_task_pdu(task, hdr);
   2218 
   2219 	if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout))
   2220 		goto failed;
   2221 
   2222 	switch (conn->tmf_state) {
   2223 	case TMF_SUCCESS:
   2224 		spin_unlock_bh(&session->frwd_lock);
   2225 		/*
   2226 		 * stop tx side incase the target had sent a abort rsp but
   2227 		 * the initiator was still writing out data.
   2228 		 */
   2229 		iscsi_suspend_tx(conn);
   2230 		/*
   2231 		 * we do not stop the recv side because targets have been
   2232 		 * good and have never sent us a successful tmf response
   2233 		 * then sent more data for the cmd.
   2234 		 */
   2235 		spin_lock_bh(&session->frwd_lock);
   2236 		fail_scsi_task(task, DID_ABORT);
   2237 		conn->tmf_state = TMF_INITIAL;
   2238 		memset(hdr, 0, sizeof(*hdr));
   2239 		spin_unlock_bh(&session->frwd_lock);
   2240 		iscsi_start_tx(conn);
   2241 		goto success_unlocked;
   2242 	case TMF_TIMEDOUT:
   2243 		spin_unlock_bh(&session->frwd_lock);
   2244 		iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
   2245 		goto failed_unlocked;
   2246 	case TMF_NOT_FOUND:
   2247 		if (!sc->SCp.ptr) {
   2248 			conn->tmf_state = TMF_INITIAL;
   2249 			memset(hdr, 0, sizeof(*hdr));
   2250 			/* task completed before tmf abort response */
   2251 			ISCSI_DBG_EH(session, "sc completed while abort	in "
   2252 					      "progress\n");
   2253 			goto success;
   2254 		}
   2255 		/* fall through */
   2256 	default:
   2257 		conn->tmf_state = TMF_INITIAL;
   2258 		goto failed;
   2259 	}
   2260 
   2261 success:
   2262 	spin_unlock_bh(&session->frwd_lock);
   2263 success_unlocked:
   2264 	ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n",
   2265 		     sc, task->itt);
   2266 	mutex_unlock(&session->eh_mutex);
   2267 	return SUCCESS;
   2268 
   2269 failed:
   2270 	spin_unlock_bh(&session->frwd_lock);
   2271 failed_unlocked:
   2272 	ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc,
   2273 		     task ? task->itt : 0);
   2274 	mutex_unlock(&session->eh_mutex);
   2275 	return FAILED;
   2276 }
   2277 EXPORT_SYMBOL_GPL(iscsi_eh_abort);
   2278 
   2279 static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr)
   2280 {
   2281 	memset(hdr, 0, sizeof(*hdr));
   2282 	hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE;
   2283 	hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK;
   2284 	hdr->flags |= ISCSI_FLAG_CMD_FINAL;
   2285 	int_to_scsilun(sc->device->lun, &hdr->lun);
   2286 	hdr->rtt = RESERVED_ITT;
   2287 }
   2288 
   2289 int iscsi_eh_device_reset(struct scsi_cmnd *sc)
   2290 {
   2291 	struct iscsi_cls_session *cls_session;
   2292 	struct iscsi_session *session;
   2293 	struct iscsi_conn *conn;
   2294 	struct iscsi_tm *hdr;
   2295 	int rc = FAILED;
   2296 
   2297 	cls_session = starget_to_session(scsi_target(sc->device));
   2298 	session = cls_session->dd_data;
   2299 
   2300 	ISCSI_DBG_EH(session, "LU Reset [sc %p lun %llu]\n", sc,
   2301 		     sc->device->lun);
   2302 
   2303 	mutex_lock(&session->eh_mutex);
   2304 	spin_lock_bh(&session->frwd_lock);
   2305 	/*
   2306 	 * Just check if we are not logged in. We cannot check for
   2307 	 * the phase because the reset could come from a ioctl.
   2308 	 */
   2309 	if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN)
   2310 		goto unlock;
   2311 	conn = session->leadconn;
   2312 
   2313 	/* only have one tmf outstanding at a time */
   2314 	if (conn->tmf_state != TMF_INITIAL)
   2315 		goto unlock;
   2316 	conn->tmf_state = TMF_QUEUED;
   2317 
   2318 	hdr = &conn->tmhdr;
   2319 	iscsi_prep_lun_reset_pdu(sc, hdr);
   2320 
   2321 	if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age,
   2322 				    session->lu_reset_timeout)) {
   2323 		rc = FAILED;
   2324 		goto unlock;
   2325 	}
   2326 
   2327 	switch (conn->tmf_state) {
   2328 	case TMF_SUCCESS:
   2329 		break;
   2330 	case TMF_TIMEDOUT:
   2331 		spin_unlock_bh(&session->frwd_lock);
   2332 		iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
   2333 		goto done;
   2334 	default:
   2335 		conn->tmf_state = TMF_INITIAL;
   2336 		goto unlock;
   2337 	}
   2338 
   2339 	rc = SUCCESS;
   2340 	spin_unlock_bh(&session->frwd_lock);
   2341 
   2342 	iscsi_suspend_tx(conn);
   2343 
   2344 	spin_lock_bh(&session->frwd_lock);
   2345 	memset(hdr, 0, sizeof(*hdr));
   2346 	fail_scsi_tasks(conn, sc->device->lun, DID_ERROR);
   2347 	conn->tmf_state = TMF_INITIAL;
   2348 	spin_unlock_bh(&session->frwd_lock);
   2349 
   2350 	iscsi_start_tx(conn);
   2351 	goto done;
   2352 
   2353 unlock:
   2354 	spin_unlock_bh(&session->frwd_lock);
   2355 done:
   2356 	ISCSI_DBG_EH(session, "dev reset result = %s\n",
   2357 		     rc == SUCCESS ? "SUCCESS" : "FAILED");
   2358 	mutex_unlock(&session->eh_mutex);
   2359 	return rc;
   2360 }
   2361 EXPORT_SYMBOL_GPL(iscsi_eh_device_reset);
   2362 
   2363 void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session)
   2364 {
   2365 	struct iscsi_session *session = cls_session->dd_data;
   2366 
   2367 	spin_lock_bh(&session->frwd_lock);
   2368 	if (session->state != ISCSI_STATE_LOGGED_IN) {
   2369 		session->state = ISCSI_STATE_RECOVERY_FAILED;
   2370 		if (session->leadconn)
   2371 			wake_up(&session->leadconn->ehwait);
   2372 	}
   2373 	spin_unlock_bh(&session->frwd_lock);
   2374 }
   2375 EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout);
   2376 
   2377 /**
   2378  * iscsi_eh_session_reset - drop session and attempt relogin
   2379  * @sc: scsi command
   2380  *
   2381  * This function will wait for a relogin, session termination from
   2382  * userspace, or a recovery/replacement timeout.
   2383  */
   2384 int iscsi_eh_session_reset(struct scsi_cmnd *sc)
   2385 {
   2386 	struct iscsi_cls_session *cls_session;
   2387 	struct iscsi_session *session;
   2388 	struct iscsi_conn *conn;
   2389 
   2390 	cls_session = starget_to_session(scsi_target(sc->device));
   2391 	session = cls_session->dd_data;
   2392 	conn = session->leadconn;
   2393 
   2394 	mutex_lock(&session->eh_mutex);
   2395 	spin_lock_bh(&session->frwd_lock);
   2396 	if (session->state == ISCSI_STATE_TERMINATE) {
   2397 failed:
   2398 		ISCSI_DBG_EH(session,
   2399 			     "failing session reset: Could not log back into "
   2400 			     "%s [age %d]\n", session->targetname,
   2401 			     session->age);
   2402 		spin_unlock_bh(&session->frwd_lock);
   2403 		mutex_unlock(&session->eh_mutex);
   2404 		return FAILED;
   2405 	}
   2406 
   2407 	spin_unlock_bh(&session->frwd_lock);
   2408 	mutex_unlock(&session->eh_mutex);
   2409 	/*
   2410 	 * we drop the lock here but the leadconn cannot be destoyed while
   2411 	 * we are in the scsi eh
   2412 	 */
   2413 	iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
   2414 
   2415 	ISCSI_DBG_EH(session, "wait for relogin\n");
   2416 	wait_event_interruptible(conn->ehwait,
   2417 				 session->state == ISCSI_STATE_TERMINATE ||
   2418 				 session->state == ISCSI_STATE_LOGGED_IN ||
   2419 				 session->state == ISCSI_STATE_RECOVERY_FAILED);
   2420 	if (signal_pending(current))
   2421 		flush_signals(current);
   2422 
   2423 	mutex_lock(&session->eh_mutex);
   2424 	spin_lock_bh(&session->frwd_lock);
   2425 	if (session->state == ISCSI_STATE_LOGGED_IN) {
   2426 		ISCSI_DBG_EH(session,
   2427 			     "session reset succeeded for %s,%s\n",
   2428 			     session->targetname, conn->persistent_address);
   2429 	} else
   2430 		goto failed;
   2431 	spin_unlock_bh(&session->frwd_lock);
   2432 	mutex_unlock(&session->eh_mutex);
   2433 	return SUCCESS;
   2434 }
   2435 EXPORT_SYMBOL_GPL(iscsi_eh_session_reset);
   2436 
   2437 static void iscsi_prep_tgt_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr)
   2438 {
   2439 	memset(hdr, 0, sizeof(*hdr));
   2440 	hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE;
   2441 	hdr->flags = ISCSI_TM_FUNC_TARGET_WARM_RESET & ISCSI_FLAG_TM_FUNC_MASK;
   2442 	hdr->flags |= ISCSI_FLAG_CMD_FINAL;
   2443 	hdr->rtt = RESERVED_ITT;
   2444 }
   2445 
   2446 /**
   2447  * iscsi_eh_target_reset - reset target
   2448  * @sc: scsi command
   2449  *
   2450  * This will attempt to send a warm target reset.
   2451  */
   2452 static int iscsi_eh_target_reset(struct scsi_cmnd *sc)
   2453 {
   2454 	struct iscsi_cls_session *cls_session;
   2455 	struct iscsi_session *session;
   2456 	struct iscsi_conn *conn;
   2457 	struct iscsi_tm *hdr;
   2458 	int rc = FAILED;
   2459 
   2460 	cls_session = starget_to_session(scsi_target(sc->device));
   2461 	session = cls_session->dd_data;
   2462 
   2463 	ISCSI_DBG_EH(session, "tgt Reset [sc %p tgt %s]\n", sc,
   2464 		     session->targetname);
   2465 
   2466 	mutex_lock(&session->eh_mutex);
   2467 	spin_lock_bh(&session->frwd_lock);
   2468 	/*
   2469 	 * Just check if we are not logged in. We cannot check for
   2470 	 * the phase because the reset could come from a ioctl.
   2471 	 */
   2472 	if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN)
   2473 		goto unlock;
   2474 	conn = session->leadconn;
   2475 
   2476 	/* only have one tmf outstanding at a time */
   2477 	if (conn->tmf_state != TMF_INITIAL)
   2478 		goto unlock;
   2479 	conn->tmf_state = TMF_QUEUED;
   2480 
   2481 	hdr = &conn->tmhdr;
   2482 	iscsi_prep_tgt_reset_pdu(sc, hdr);
   2483 
   2484 	if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age,
   2485 				    session->tgt_reset_timeout)) {
   2486 		rc = FAILED;
   2487 		goto unlock;
   2488 	}
   2489 
   2490 	switch (conn->tmf_state) {
   2491 	case TMF_SUCCESS:
   2492 		break;
   2493 	case TMF_TIMEDOUT:
   2494 		spin_unlock_bh(&session->frwd_lock);
   2495 		iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
   2496 		goto done;
   2497 	default:
   2498 		conn->tmf_state = TMF_INITIAL;
   2499 		goto unlock;
   2500 	}
   2501 
   2502 	rc = SUCCESS;
   2503 	spin_unlock_bh(&session->frwd_lock);
   2504 
   2505 	iscsi_suspend_tx(conn);
   2506 
   2507 	spin_lock_bh(&session->frwd_lock);
   2508 	memset(hdr, 0, sizeof(*hdr));
   2509 	fail_scsi_tasks(conn, -1, DID_ERROR);
   2510 	conn->tmf_state = TMF_INITIAL;
   2511 	spin_unlock_bh(&session->frwd_lock);
   2512 
   2513 	iscsi_start_tx(conn);
   2514 	goto done;
   2515 
   2516 unlock:
   2517 	spin_unlock_bh(&session->frwd_lock);
   2518 done:
   2519 	ISCSI_DBG_EH(session, "tgt %s reset result = %s\n", session->targetname,
   2520 		     rc == SUCCESS ? "SUCCESS" : "FAILED");
   2521 	mutex_unlock(&session->eh_mutex);
   2522 	return rc;
   2523 }
   2524 
   2525 /**
   2526  * iscsi_eh_recover_target - reset target and possibly the session
   2527  * @sc: scsi command
   2528  *
   2529  * This will attempt to send a warm target reset. If that fails,
   2530  * we will escalate to ERL0 session recovery.
   2531  */
   2532 int iscsi_eh_recover_target(struct scsi_cmnd *sc)
   2533 {
   2534 	int rc;
   2535 
   2536 	rc = iscsi_eh_target_reset(sc);
   2537 	if (rc == FAILED)
   2538 		rc = iscsi_eh_session_reset(sc);
   2539 	return rc;
   2540 }
   2541 EXPORT_SYMBOL_GPL(iscsi_eh_recover_target);
   2542 
   2543 /*
   2544  * Pre-allocate a pool of @max items of @item_size. By default, the pool
   2545  * should be accessed via kfifo_{get,put} on q->queue.
   2546  * Optionally, the caller can obtain the array of object pointers
   2547  * by passing in a non-NULL @items pointer
   2548  */
   2549 int
   2550 iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size)
   2551 {
   2552 	int i, num_arrays = 1;
   2553 
   2554 	memset(q, 0, sizeof(*q));
   2555 
   2556 	q->max = max;
   2557 
   2558 	/* If the user passed an items pointer, he wants a copy of
   2559 	 * the array. */
   2560 	if (items)
   2561 		num_arrays++;
   2562 	q->pool = kvcalloc(num_arrays * max, sizeof(void *), GFP_KERNEL);
   2563 	if (q->pool == NULL)
   2564 		return -ENOMEM;
   2565 
   2566 	kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*));
   2567 
   2568 	for (i = 0; i < max; i++) {
   2569 		q->pool[i] = kzalloc(item_size, GFP_KERNEL);
   2570 		if (q->pool[i] == NULL) {
   2571 			q->max = i;
   2572 			goto enomem;
   2573 		}
   2574 		kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*));
   2575 	}
   2576 
   2577 	if (items) {
   2578 		*items = q->pool + max;
   2579 		memcpy(*items, q->pool, max * sizeof(void *));
   2580 	}
   2581 
   2582 	return 0;
   2583 
   2584 enomem:
   2585 	iscsi_pool_free(q);
   2586 	return -ENOMEM;
   2587 }
   2588 EXPORT_SYMBOL_GPL(iscsi_pool_init);
   2589 
   2590 void iscsi_pool_free(struct iscsi_pool *q)
   2591 {
   2592 	int i;
   2593 
   2594 	for (i = 0; i < q->max; i++)
   2595 		kfree(q->pool[i]);
   2596 	kvfree(q->pool);
   2597 }
   2598 EXPORT_SYMBOL_GPL(iscsi_pool_free);
   2599 
   2600 /**
   2601  * iscsi_host_add - add host to system
   2602  * @shost: scsi host
   2603  * @pdev: parent device
   2604  *
   2605  * This should be called by partial offload and software iscsi drivers
   2606  * to add a host to the system.
   2607  */
   2608 int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev)
   2609 {
   2610 	if (!shost->can_queue)
   2611 		shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX;
   2612 
   2613 	if (!shost->cmd_per_lun)
   2614 		shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN;
   2615 
   2616 	return scsi_add_host(shost, pdev);
   2617 }
   2618 EXPORT_SYMBOL_GPL(iscsi_host_add);
   2619 
   2620 /**
   2621  * iscsi_host_alloc - allocate a host and driver data
   2622  * @sht: scsi host template
   2623  * @dd_data_size: driver host data size
   2624  * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue
   2625  *
   2626  * This should be called by partial offload and software iscsi drivers.
   2627  * To access the driver specific memory use the iscsi_host_priv() macro.
   2628  */
   2629 struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht,
   2630 				   int dd_data_size, bool xmit_can_sleep)
   2631 {
   2632 	struct Scsi_Host *shost;
   2633 	struct iscsi_host *ihost;
   2634 
   2635 	shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size);
   2636 	if (!shost)
   2637 		return NULL;
   2638 	ihost = shost_priv(shost);
   2639 
   2640 	if (xmit_can_sleep) {
   2641 		snprintf(ihost->workq_name, sizeof(ihost->workq_name),
   2642 			"iscsi_q_%d", shost->host_no);
   2643 		ihost->workq = create_singlethread_workqueue(ihost->workq_name);
   2644 		if (!ihost->workq)
   2645 			goto free_host;
   2646 	}
   2647 
   2648 	spin_lock_init(&ihost->lock);
   2649 	ihost->state = ISCSI_HOST_SETUP;
   2650 	ihost->num_sessions = 0;
   2651 	init_waitqueue_head(&ihost->session_removal_wq);
   2652 	return shost;
   2653 
   2654 free_host:
   2655 	scsi_host_put(shost);
   2656 	return NULL;
   2657 }
   2658 EXPORT_SYMBOL_GPL(iscsi_host_alloc);
   2659 
   2660 static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session)
   2661 {
   2662 	iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST);
   2663 }
   2664 
   2665 /**
   2666  * iscsi_host_remove - remove host and sessions
   2667  * @shost: scsi host
   2668  *
   2669  * If there are any sessions left, this will initiate the removal and wait
   2670  * for the completion.
   2671  */
   2672 void iscsi_host_remove(struct Scsi_Host *shost)
   2673 {
   2674 	struct iscsi_host *ihost = shost_priv(shost);
   2675 	unsigned long flags;
   2676 
   2677 	spin_lock_irqsave(&ihost->lock, flags);
   2678 	ihost->state = ISCSI_HOST_REMOVED;
   2679 	spin_unlock_irqrestore(&ihost->lock, flags);
   2680 
   2681 	iscsi_host_for_each_session(shost, iscsi_notify_host_removed);
   2682 	wait_event_interruptible(ihost->session_removal_wq,
   2683 				 ihost->num_sessions == 0);
   2684 	if (signal_pending(current))
   2685 		flush_signals(current);
   2686 
   2687 	scsi_remove_host(shost);
   2688 	if (ihost->workq)
   2689 		destroy_workqueue(ihost->workq);
   2690 }
   2691 EXPORT_SYMBOL_GPL(iscsi_host_remove);
   2692 
   2693 void iscsi_host_free(struct Scsi_Host *shost)
   2694 {
   2695 	struct iscsi_host *ihost = shost_priv(shost);
   2696 
   2697 	kfree(ihost->netdev);
   2698 	kfree(ihost->hwaddress);
   2699 	kfree(ihost->initiatorname);
   2700 	scsi_host_put(shost);
   2701 }
   2702 EXPORT_SYMBOL_GPL(iscsi_host_free);
   2703 
   2704 static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost)
   2705 {
   2706 	struct iscsi_host *ihost = shost_priv(shost);
   2707 	unsigned long flags;
   2708 
   2709 	shost = scsi_host_get(shost);
   2710 	if (!shost) {
   2711 		printk(KERN_ERR "Invalid state. Cannot notify host removal "
   2712 		      "of session teardown event because host already "
   2713 		      "removed.\n");
   2714 		return;
   2715 	}
   2716 
   2717 	spin_lock_irqsave(&ihost->lock, flags);
   2718 	ihost->num_sessions--;
   2719 	if (ihost->num_sessions == 0)
   2720 		wake_up(&ihost->session_removal_wq);
   2721 	spin_unlock_irqrestore(&ihost->lock, flags);
   2722 	scsi_host_put(shost);
   2723 }
   2724 
   2725 /**
   2726  * iscsi_session_setup - create iscsi cls session and host and session
   2727  * @iscsit: iscsi transport template
   2728  * @shost: scsi host
   2729  * @cmds_max: session can queue
   2730  * @dd_size: private driver data size, added to session allocation size
   2731  * @cmd_task_size: LLD task private data size
   2732  * @initial_cmdsn: initial CmdSN
   2733  * @id: target ID to add to this session
   2734  *
   2735  * This can be used by software iscsi_transports that allocate
   2736  * a session per scsi host.
   2737  *
   2738  * Callers should set cmds_max to the largest total numer (mgmt + scsi) of
   2739  * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks
   2740  * for nop handling and login/logout requests.
   2741  */
   2742 struct iscsi_cls_session *
   2743 iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost,
   2744 		    uint16_t cmds_max, int dd_size, int cmd_task_size,
   2745 		    uint32_t initial_cmdsn, unsigned int id)
   2746 {
   2747 	struct iscsi_host *ihost = shost_priv(shost);
   2748 	struct iscsi_session *session;
   2749 	struct iscsi_cls_session *cls_session;
   2750 	int cmd_i, scsi_cmds, total_cmds = cmds_max;
   2751 	unsigned long flags;
   2752 
   2753 	spin_lock_irqsave(&ihost->lock, flags);
   2754 	if (ihost->state == ISCSI_HOST_REMOVED) {
   2755 		spin_unlock_irqrestore(&ihost->lock, flags);
   2756 		return NULL;
   2757 	}
   2758 	ihost->num_sessions++;
   2759 	spin_unlock_irqrestore(&ihost->lock, flags);
   2760 
   2761 	if (!total_cmds)
   2762 		total_cmds = ISCSI_DEF_XMIT_CMDS_MAX;
   2763 	/*
   2764 	 * The iscsi layer needs some tasks for nop handling and tmfs,
   2765 	 * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX
   2766 	 * + 1 command for scsi IO.
   2767 	 */
   2768 	if (total_cmds < ISCSI_TOTAL_CMDS_MIN) {
   2769 		printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue "
   2770 		       "must be a power of two that is at least %d.\n",
   2771 		       total_cmds, ISCSI_TOTAL_CMDS_MIN);
   2772 		goto dec_session_count;
   2773 	}
   2774 
   2775 	if (total_cmds > ISCSI_TOTAL_CMDS_MAX) {
   2776 		printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue "
   2777 		       "must be a power of 2 less than or equal to %d.\n",
   2778 		       cmds_max, ISCSI_TOTAL_CMDS_MAX);
   2779 		total_cmds = ISCSI_TOTAL_CMDS_MAX;
   2780 	}
   2781 
   2782 	if (!is_power_of_2(total_cmds)) {
   2783 		printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue "
   2784 		       "must be a power of 2.\n", total_cmds);
   2785 		total_cmds = rounddown_pow_of_two(total_cmds);
   2786 		if (total_cmds < ISCSI_TOTAL_CMDS_MIN)
   2787 			return NULL;
   2788 		printk(KERN_INFO "iscsi: Rounding can_queue to %d.\n",
   2789 		       total_cmds);
   2790 	}
   2791 	scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX;
   2792 
   2793 	cls_session = iscsi_alloc_session(shost, iscsit,
   2794 					  sizeof(struct iscsi_session) +
   2795 					  dd_size);
   2796 	if (!cls_session)
   2797 		goto dec_session_count;
   2798 	session = cls_session->dd_data;
   2799 	session->cls_session = cls_session;
   2800 	session->host = shost;
   2801 	session->state = ISCSI_STATE_FREE;
   2802 	session->fast_abort = 1;
   2803 	session->tgt_reset_timeout = 30;
   2804 	session->lu_reset_timeout = 15;
   2805 	session->abort_timeout = 10;
   2806 	session->scsi_cmds_max = scsi_cmds;
   2807 	session->cmds_max = total_cmds;
   2808 	session->queued_cmdsn = session->cmdsn = initial_cmdsn;
   2809 	session->exp_cmdsn = initial_cmdsn + 1;
   2810 	session->max_cmdsn = initial_cmdsn + 1;
   2811 	session->max_r2t = 1;
   2812 	session->tt = iscsit;
   2813 	session->dd_data = cls_session->dd_data + sizeof(*session);
   2814 
   2815 	mutex_init(&session->eh_mutex);
   2816 	spin_lock_init(&session->frwd_lock);
   2817 	spin_lock_init(&session->back_lock);
   2818 
   2819 	/* initialize SCSI PDU commands pool */
   2820 	if (iscsi_pool_init(&session->cmdpool, session->cmds_max,
   2821 			    (void***)&session->cmds,
   2822 			    cmd_task_size + sizeof(struct iscsi_task)))
   2823 		goto cmdpool_alloc_fail;
   2824 
   2825 	/* pre-format cmds pool with ITT */
   2826 	for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) {
   2827 		struct iscsi_task *task = session->cmds[cmd_i];
   2828 
   2829 		if (cmd_task_size)
   2830 			task->dd_data = &task[1];
   2831 		task->itt = cmd_i;
   2832 		task->state = ISCSI_TASK_FREE;
   2833 		INIT_LIST_HEAD(&task->running);
   2834 	}
   2835 
   2836 	if (!try_module_get(iscsit->owner))
   2837 		goto module_get_fail;
   2838 
   2839 	if (iscsi_add_session(cls_session, id))
   2840 		goto cls_session_fail;
   2841 
   2842 	return cls_session;
   2843 
   2844 cls_session_fail:
   2845 	module_put(iscsit->owner);
   2846 module_get_fail:
   2847 	iscsi_pool_free(&session->cmdpool);
   2848 cmdpool_alloc_fail:
   2849 	iscsi_free_session(cls_session);
   2850 dec_session_count:
   2851 	iscsi_host_dec_session_cnt(shost);
   2852 	return NULL;
   2853 }
   2854 EXPORT_SYMBOL_GPL(iscsi_session_setup);
   2855 
   2856 /**
   2857  * iscsi_session_teardown - destroy session, host, and cls_session
   2858  * @cls_session: iscsi session
   2859  */
   2860 void iscsi_session_teardown(struct iscsi_cls_session *cls_session)
   2861 {
   2862 	struct iscsi_session *session = cls_session->dd_data;
   2863 	struct module *owner = cls_session->transport->owner;
   2864 	struct Scsi_Host *shost = session->host;
   2865 
   2866 	iscsi_pool_free(&session->cmdpool);
   2867 
   2868 	iscsi_remove_session(cls_session);
   2869 
   2870 	kfree(session->password);
   2871 	kfree(session->password_in);
   2872 	kfree(session->username);
   2873 	kfree(session->username_in);
   2874 	kfree(session->targetname);
   2875 	kfree(session->targetalias);
   2876 	kfree(session->initiatorname);
   2877 	kfree(session->boot_root);
   2878 	kfree(session->boot_nic);
   2879 	kfree(session->boot_target);
   2880 	kfree(session->ifacename);
   2881 	kfree(session->portal_type);
   2882 	kfree(session->discovery_parent_type);
   2883 
   2884 	iscsi_free_session(cls_session);
   2885 
   2886 	iscsi_host_dec_session_cnt(shost);
   2887 	module_put(owner);
   2888 }
   2889 EXPORT_SYMBOL_GPL(iscsi_session_teardown);
   2890 
   2891 /**
   2892  * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn
   2893  * @cls_session: iscsi_cls_session
   2894  * @dd_size: private driver data size
   2895  * @conn_idx: cid
   2896  */
   2897 struct iscsi_cls_conn *
   2898 iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
   2899 		 uint32_t conn_idx)
   2900 {
   2901 	struct iscsi_session *session = cls_session->dd_data;
   2902 	struct iscsi_conn *conn;
   2903 	struct iscsi_cls_conn *cls_conn;
   2904 	char *data;
   2905 
   2906 	cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size,
   2907 				     conn_idx);
   2908 	if (!cls_conn)
   2909 		return NULL;
   2910 	conn = cls_conn->dd_data;
   2911 	memset(conn, 0, sizeof(*conn) + dd_size);
   2912 
   2913 	conn->dd_data = cls_conn->dd_data + sizeof(*conn);
   2914 	conn->session = session;
   2915 	conn->cls_conn = cls_conn;
   2916 	conn->c_stage = ISCSI_CONN_INITIAL_STAGE;
   2917 	conn->id = conn_idx;
   2918 	conn->exp_statsn = 0;
   2919 	conn->tmf_state = TMF_INITIAL;
   2920 
   2921 	timer_setup(&conn->transport_timer, iscsi_check_transport_timeouts, 0);
   2922 
   2923 	INIT_LIST_HEAD(&conn->mgmtqueue);
   2924 	INIT_LIST_HEAD(&conn->cmdqueue);
   2925 	INIT_LIST_HEAD(&conn->requeue);
   2926 	spin_lock_init(&conn->taskqueuelock);
   2927 	INIT_WORK(&conn->xmitwork, iscsi_xmitworker);
   2928 
   2929 	/* allocate login_task used for the login/text sequences */
   2930 	spin_lock_bh(&session->frwd_lock);
   2931 	if (!kfifo_out(&session->cmdpool.queue,
   2932                          (void*)&conn->login_task,
   2933 			 sizeof(void*))) {
   2934 		spin_unlock_bh(&session->frwd_lock);
   2935 		goto login_task_alloc_fail;
   2936 	}
   2937 	spin_unlock_bh(&session->frwd_lock);
   2938 
   2939 	data = (char *) __get_free_pages(GFP_KERNEL,
   2940 					 get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
   2941 	if (!data)
   2942 		goto login_task_data_alloc_fail;
   2943 	conn->login_task->data = conn->data = data;
   2944 
   2945 	timer_setup(&conn->tmf_timer, iscsi_tmf_timedout, 0);
   2946 	init_waitqueue_head(&conn->ehwait);
   2947 
   2948 	return cls_conn;
   2949 
   2950 login_task_data_alloc_fail:
   2951 	kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
   2952 		    sizeof(void*));
   2953 login_task_alloc_fail:
   2954 	iscsi_destroy_conn(cls_conn);
   2955 	return NULL;
   2956 }
   2957 EXPORT_SYMBOL_GPL(iscsi_conn_setup);
   2958 
   2959 /**
   2960  * iscsi_conn_teardown - teardown iscsi connection
   2961  * @cls_conn: iscsi class connection
   2962  *
   2963  * TODO: we may need to make this into a two step process
   2964  * like scsi-mls remove + put host
   2965  */
   2966 void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn)
   2967 {
   2968 	struct iscsi_conn *conn = cls_conn->dd_data;
   2969 	struct iscsi_session *session = conn->session;
   2970 
   2971 	del_timer_sync(&conn->transport_timer);
   2972 
   2973 	mutex_lock(&session->eh_mutex);
   2974 	spin_lock_bh(&session->frwd_lock);
   2975 	conn->c_stage = ISCSI_CONN_CLEANUP_WAIT;
   2976 	if (session->leadconn == conn) {
   2977 		/*
   2978 		 * leading connection? then give up on recovery.
   2979 		 */
   2980 		session->state = ISCSI_STATE_TERMINATE;
   2981 		wake_up(&conn->ehwait);
   2982 	}
   2983 	spin_unlock_bh(&session->frwd_lock);
   2984 
   2985 	/* flush queued up work because we free the connection below */
   2986 	iscsi_suspend_tx(conn);
   2987 
   2988 	spin_lock_bh(&session->frwd_lock);
   2989 	free_pages((unsigned long) conn->data,
   2990 		   get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
   2991 	kfree(conn->persistent_address);
   2992 	kfree(conn->local_ipaddr);
   2993 	/* regular RX path uses back_lock */
   2994 	spin_lock_bh(&session->back_lock);
   2995 	kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
   2996 		    sizeof(void*));
   2997 	spin_unlock_bh(&session->back_lock);
   2998 	if (session->leadconn == conn)
   2999 		session->leadconn = NULL;
   3000 	spin_unlock_bh(&session->frwd_lock);
   3001 	mutex_unlock(&session->eh_mutex);
   3002 
   3003 	iscsi_destroy_conn(cls_conn);
   3004 }
   3005 EXPORT_SYMBOL_GPL(iscsi_conn_teardown);
   3006 
   3007 int iscsi_conn_start(struct iscsi_cls_conn *cls_conn)
   3008 {
   3009 	struct iscsi_conn *conn = cls_conn->dd_data;
   3010 	struct iscsi_session *session = conn->session;
   3011 
   3012 	if (!session) {
   3013 		iscsi_conn_printk(KERN_ERR, conn,
   3014 				  "can't start unbound connection\n");
   3015 		return -EPERM;
   3016 	}
   3017 
   3018 	if ((session->imm_data_en || !session->initial_r2t_en) &&
   3019 	     session->first_burst > session->max_burst) {
   3020 		iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: "
   3021 				  "first_burst %d max_burst %d\n",
   3022 				  session->first_burst, session->max_burst);
   3023 		return -EINVAL;
   3024 	}
   3025 
   3026 	if (conn->ping_timeout && !conn->recv_timeout) {
   3027 		iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of "
   3028 				  "zero. Using 5 seconds\n.");
   3029 		conn->recv_timeout = 5;
   3030 	}
   3031 
   3032 	if (conn->recv_timeout && !conn->ping_timeout) {
   3033 		iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of "
   3034 				  "zero. Using 5 seconds.\n");
   3035 		conn->ping_timeout = 5;
   3036 	}
   3037 
   3038 	spin_lock_bh(&session->frwd_lock);
   3039 	conn->c_stage = ISCSI_CONN_STARTED;
   3040 	session->state = ISCSI_STATE_LOGGED_IN;
   3041 	session->queued_cmdsn = session->cmdsn;
   3042 
   3043 	conn->last_recv = jiffies;
   3044 	conn->last_ping = jiffies;
   3045 	if (conn->recv_timeout && conn->ping_timeout)
   3046 		mod_timer(&conn->transport_timer,
   3047 			  jiffies + (conn->recv_timeout * HZ));
   3048 
   3049 	switch(conn->stop_stage) {
   3050 	case STOP_CONN_RECOVER:
   3051 		/*
   3052 		 * unblock eh_abort() if it is blocked. re-try all
   3053 		 * commands after successful recovery
   3054 		 */
   3055 		conn->stop_stage = 0;
   3056 		conn->tmf_state = TMF_INITIAL;
   3057 		session->age++;
   3058 		if (session->age == 16)
   3059 			session->age = 0;
   3060 		break;
   3061 	case STOP_CONN_TERM:
   3062 		conn->stop_stage = 0;
   3063 		break;
   3064 	default:
   3065 		break;
   3066 	}
   3067 	spin_unlock_bh(&session->frwd_lock);
   3068 
   3069 	iscsi_unblock_session(session->cls_session);
   3070 	wake_up(&conn->ehwait);
   3071 	return 0;
   3072 }
   3073 EXPORT_SYMBOL_GPL(iscsi_conn_start);
   3074 
   3075 static void
   3076 fail_mgmt_tasks(struct iscsi_session *session, struct iscsi_conn *conn)
   3077 {
   3078 	struct iscsi_task *task;
   3079 	int i, state;
   3080 
   3081 	for (i = 0; i < conn->session->cmds_max; i++) {
   3082 		task = conn->session->cmds[i];
   3083 		if (task->sc)
   3084 			continue;
   3085 
   3086 		if (task->state == ISCSI_TASK_FREE)
   3087 			continue;
   3088 
   3089 		ISCSI_DBG_SESSION(conn->session,
   3090 				  "failing mgmt itt 0x%x state %d\n",
   3091 				  task->itt, task->state);
   3092 		state = ISCSI_TASK_ABRT_SESS_RECOV;
   3093 		if (task->state == ISCSI_TASK_PENDING)
   3094 			state = ISCSI_TASK_COMPLETED;
   3095 		spin_lock_bh(&session->back_lock);
   3096 		iscsi_complete_task(task, state);
   3097 		spin_unlock_bh(&session->back_lock);
   3098 	}
   3099 }
   3100 
   3101 static void iscsi_start_session_recovery(struct iscsi_session *session,
   3102 					 struct iscsi_conn *conn, int flag)
   3103 {
   3104 	int old_stop_stage;
   3105 
   3106 	mutex_lock(&session->eh_mutex);
   3107 	spin_lock_bh(&session->frwd_lock);
   3108 	if (conn->stop_stage == STOP_CONN_TERM) {
   3109 		spin_unlock_bh(&session->frwd_lock);
   3110 		mutex_unlock(&session->eh_mutex);
   3111 		return;
   3112 	}
   3113 
   3114 	/*
   3115 	 * When this is called for the in_login state, we only want to clean
   3116 	 * up the login task and connection. We do not need to block and set
   3117 	 * the recovery state again
   3118 	 */
   3119 	if (flag == STOP_CONN_TERM)
   3120 		session->state = ISCSI_STATE_TERMINATE;
   3121 	else if (conn->stop_stage != STOP_CONN_RECOVER)
   3122 		session->state = ISCSI_STATE_IN_RECOVERY;
   3123 
   3124 	old_stop_stage = conn->stop_stage;
   3125 	conn->stop_stage = flag;
   3126 	spin_unlock_bh(&session->frwd_lock);
   3127 
   3128 	del_timer_sync(&conn->transport_timer);
   3129 	iscsi_suspend_tx(conn);
   3130 
   3131 	spin_lock_bh(&session->frwd_lock);
   3132 	conn->c_stage = ISCSI_CONN_STOPPED;
   3133 	spin_unlock_bh(&session->frwd_lock);
   3134 
   3135 	/*
   3136 	 * for connection level recovery we should not calculate
   3137 	 * header digest. conn->hdr_size used for optimization
   3138 	 * in hdr_extract() and will be re-negotiated at
   3139 	 * set_param() time.
   3140 	 */
   3141 	if (flag == STOP_CONN_RECOVER) {
   3142 		conn->hdrdgst_en = 0;
   3143 		conn->datadgst_en = 0;
   3144 		if (session->state == ISCSI_STATE_IN_RECOVERY &&
   3145 		    old_stop_stage != STOP_CONN_RECOVER) {
   3146 			ISCSI_DBG_SESSION(session, "blocking session\n");
   3147 			iscsi_block_session(session->cls_session);
   3148 		}
   3149 	}
   3150 
   3151 	/*
   3152 	 * flush queues.
   3153 	 */
   3154 	spin_lock_bh(&session->frwd_lock);
   3155 	fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED);
   3156 	fail_mgmt_tasks(session, conn);
   3157 	memset(&conn->tmhdr, 0, sizeof(conn->tmhdr));
   3158 	spin_unlock_bh(&session->frwd_lock);
   3159 	mutex_unlock(&session->eh_mutex);
   3160 }
   3161 
   3162 void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
   3163 {
   3164 	struct iscsi_conn *conn = cls_conn->dd_data;
   3165 	struct iscsi_session *session = conn->session;
   3166 
   3167 	switch (flag) {
   3168 	case STOP_CONN_RECOVER:
   3169 	case STOP_CONN_TERM:
   3170 		iscsi_start_session_recovery(session, conn, flag);
   3171 		break;
   3172 	default:
   3173 		iscsi_conn_printk(KERN_ERR, conn,
   3174 				  "invalid stop flag %d\n", flag);
   3175 	}
   3176 }
   3177 EXPORT_SYMBOL_GPL(iscsi_conn_stop);
   3178 
   3179 int iscsi_conn_bind(struct iscsi_cls_session *cls_session,
   3180 		    struct iscsi_cls_conn *cls_conn, int is_leading)
   3181 {
   3182 	struct iscsi_session *session = cls_session->dd_data;
   3183 	struct iscsi_conn *conn = cls_conn->dd_data;
   3184 
   3185 	spin_lock_bh(&session->frwd_lock);
   3186 	if (is_leading)
   3187 		session->leadconn = conn;
   3188 	spin_unlock_bh(&session->frwd_lock);
   3189 
   3190 	/*
   3191 	 * Unblock xmitworker(), Login Phase will pass through.
   3192 	 */
   3193 	clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
   3194 	clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
   3195 	return 0;
   3196 }
   3197 EXPORT_SYMBOL_GPL(iscsi_conn_bind);
   3198 
   3199 int iscsi_switch_str_param(char **param, char *new_val_buf)
   3200 {
   3201 	char *new_val;
   3202 
   3203 	if (*param) {
   3204 		if (!strcmp(*param, new_val_buf))
   3205 			return 0;
   3206 	}
   3207 
   3208 	new_val = kstrdup(new_val_buf, GFP_NOIO);
   3209 	if (!new_val)
   3210 		return -ENOMEM;
   3211 
   3212 	kfree(*param);
   3213 	*param = new_val;
   3214 	return 0;
   3215 }
   3216 EXPORT_SYMBOL_GPL(iscsi_switch_str_param);
   3217 
   3218 int iscsi_set_param(struct iscsi_cls_conn *cls_conn,
   3219 		    enum iscsi_param param, char *buf, int buflen)
   3220 {
   3221 	struct iscsi_conn *conn = cls_conn->dd_data;
   3222 	struct iscsi_session *session = conn->session;
   3223 	int val;
   3224 
   3225 	switch(param) {
   3226 	case ISCSI_PARAM_FAST_ABORT:
   3227 		sscanf(buf, "%d", &session->fast_abort);
   3228 		break;
   3229 	case ISCSI_PARAM_ABORT_TMO:
   3230 		sscanf(buf, "%d", &session->abort_timeout);
   3231 		break;
   3232 	case ISCSI_PARAM_LU_RESET_TMO:
   3233 		sscanf(buf, "%d", &session->lu_reset_timeout);
   3234 		break;
   3235 	case ISCSI_PARAM_TGT_RESET_TMO:
   3236 		sscanf(buf, "%d", &session->tgt_reset_timeout);
   3237 		break;
   3238 	case ISCSI_PARAM_PING_TMO:
   3239 		sscanf(buf, "%d", &conn->ping_timeout);
   3240 		break;
   3241 	case ISCSI_PARAM_RECV_TMO:
   3242 		sscanf(buf, "%d", &conn->recv_timeout);
   3243 		break;
   3244 	case ISCSI_PARAM_MAX_RECV_DLENGTH:
   3245 		sscanf(buf, "%d", &conn->max_recv_dlength);
   3246 		break;
   3247 	case ISCSI_PARAM_MAX_XMIT_DLENGTH:
   3248 		sscanf(buf, "%d", &conn->max_xmit_dlength);
   3249 		break;
   3250 	case ISCSI_PARAM_HDRDGST_EN:
   3251 		sscanf(buf, "%d", &conn->hdrdgst_en);
   3252 		break;
   3253 	case ISCSI_PARAM_DATADGST_EN:
   3254 		sscanf(buf, "%d", &conn->datadgst_en);
   3255 		break;
   3256 	case ISCSI_PARAM_INITIAL_R2T_EN:
   3257 		sscanf(buf, "%d", &session->initial_r2t_en);
   3258 		break;
   3259 	case ISCSI_PARAM_MAX_R2T:
   3260 		sscanf(buf, "%hu", &session->max_r2t);
   3261 		break;
   3262 	case ISCSI_PARAM_IMM_DATA_EN:
   3263 		sscanf(buf, "%d", &session->imm_data_en);
   3264 		break;
   3265 	case ISCSI_PARAM_FIRST_BURST:
   3266 		sscanf(buf, "%d", &session->first_burst);
   3267 		break;
   3268 	case ISCSI_PARAM_MAX_BURST:
   3269 		sscanf(buf, "%d", &session->max_burst);
   3270 		break;
   3271 	case ISCSI_PARAM_PDU_INORDER_EN:
   3272 		sscanf(buf, "%d", &session->pdu_inorder_en);
   3273 		break;
   3274 	case ISCSI_PARAM_DATASEQ_INORDER_EN:
   3275 		sscanf(buf, "%d", &session->dataseq_inorder_en);
   3276 		break;
   3277 	case ISCSI_PARAM_ERL:
   3278 		sscanf(buf, "%d", &session->erl);
   3279 		break;
   3280 	case ISCSI_PARAM_EXP_STATSN:
   3281 		sscanf(buf, "%u", &conn->exp_statsn);
   3282 		break;
   3283 	case ISCSI_PARAM_USERNAME:
   3284 		return iscsi_switch_str_param(&session->username, buf);
   3285 	case ISCSI_PARAM_USERNAME_IN:
   3286 		return iscsi_switch_str_param(&session->username_in, buf);
   3287 	case ISCSI_PARAM_PASSWORD:
   3288 		return iscsi_switch_str_param(&session->password, buf);
   3289 	case ISCSI_PARAM_PASSWORD_IN:
   3290 		return iscsi_switch_str_param(&session->password_in, buf);
   3291 	case ISCSI_PARAM_TARGET_NAME:
   3292 		return iscsi_switch_str_param(&session->targetname, buf);
   3293 	case ISCSI_PARAM_TARGET_ALIAS:
   3294 		return iscsi_switch_str_param(&session->targetalias, buf);
   3295 	case ISCSI_PARAM_TPGT:
   3296 		sscanf(buf, "%d", &session->tpgt);
   3297 		break;
   3298 	case ISCSI_PARAM_PERSISTENT_PORT:
   3299 		sscanf(buf, "%d", &conn->persistent_port);
   3300 		break;
   3301 	case ISCSI_PARAM_PERSISTENT_ADDRESS:
   3302 		return iscsi_switch_str_param(&conn->persistent_address, buf);
   3303 	case ISCSI_PARAM_IFACE_NAME:
   3304 		return iscsi_switch_str_param(&session->ifacename, buf);
   3305 	case ISCSI_PARAM_INITIATOR_NAME:
   3306 		return iscsi_switch_str_param(&session->initiatorname, buf);
   3307 	case ISCSI_PARAM_BOOT_ROOT:
   3308 		return iscsi_switch_str_param(&session->boot_root, buf);
   3309 	case ISCSI_PARAM_BOOT_NIC:
   3310 		return iscsi_switch_str_param(&session->boot_nic, buf);
   3311 	case ISCSI_PARAM_BOOT_TARGET:
   3312 		return iscsi_switch_str_param(&session->boot_target, buf);
   3313 	case ISCSI_PARAM_PORTAL_TYPE:
   3314 		return iscsi_switch_str_param(&session->portal_type, buf);
   3315 	case ISCSI_PARAM_DISCOVERY_PARENT_TYPE:
   3316 		return iscsi_switch_str_param(&session->discovery_parent_type,
   3317 					      buf);
   3318 	case ISCSI_PARAM_DISCOVERY_SESS:
   3319 		sscanf(buf, "%d", &val);
   3320 		session->discovery_sess = !!val;
   3321 		break;
   3322 	case ISCSI_PARAM_LOCAL_IPADDR:
   3323 		return iscsi_switch_str_param(&conn->local_ipaddr, buf);
   3324 	default:
   3325 		return -ENOSYS;
   3326 	}
   3327 
   3328 	return 0;
   3329 }
   3330 EXPORT_SYMBOL_GPL(iscsi_set_param);
   3331 
   3332 int iscsi_session_get_param(struct iscsi_cls_session *cls_session,
   3333 			    enum iscsi_param param, char *buf)
   3334 {
   3335 	struct iscsi_session *session = cls_session->dd_data;
   3336 	int len;
   3337 
   3338 	switch(param) {
   3339 	case ISCSI_PARAM_FAST_ABORT:
   3340 		len = sprintf(buf, "%d\n", session->fast_abort);
   3341 		break;
   3342 	case ISCSI_PARAM_ABORT_TMO:
   3343 		len = sprintf(buf, "%d\n", session->abort_timeout);
   3344 		break;
   3345 	case ISCSI_PARAM_LU_RESET_TMO:
   3346 		len = sprintf(buf, "%d\n", session->lu_reset_timeout);
   3347 		break;
   3348 	case ISCSI_PARAM_TGT_RESET_TMO:
   3349 		len = sprintf(buf, "%d\n", session->tgt_reset_timeout);
   3350 		break;
   3351 	case ISCSI_PARAM_INITIAL_R2T_EN:
   3352 		len = sprintf(buf, "%d\n", session->initial_r2t_en);
   3353 		break;
   3354 	case ISCSI_PARAM_MAX_R2T:
   3355 		len = sprintf(buf, "%hu\n", session->max_r2t);
   3356 		break;
   3357 	case ISCSI_PARAM_IMM_DATA_EN:
   3358 		len = sprintf(buf, "%d\n", session->imm_data_en);
   3359 		break;
   3360 	case ISCSI_PARAM_FIRST_BURST:
   3361 		len = sprintf(buf, "%u\n", session->first_burst);
   3362 		break;
   3363 	case ISCSI_PARAM_MAX_BURST:
   3364 		len = sprintf(buf, "%u\n", session->max_burst);
   3365 		break;
   3366 	case ISCSI_PARAM_PDU_INORDER_EN:
   3367 		len = sprintf(buf, "%d\n", session->pdu_inorder_en);
   3368 		break;
   3369 	case ISCSI_PARAM_DATASEQ_INORDER_EN:
   3370 		len = sprintf(buf, "%d\n", session->dataseq_inorder_en);
   3371 		break;
   3372 	case ISCSI_PARAM_DEF_TASKMGMT_TMO:
   3373 		len = sprintf(buf, "%d\n", session->def_taskmgmt_tmo);
   3374 		break;
   3375 	case ISCSI_PARAM_ERL:
   3376 		len = sprintf(buf, "%d\n", session->erl);
   3377 		break;
   3378 	case ISCSI_PARAM_TARGET_NAME:
   3379 		len = sprintf(buf, "%s\n", session->targetname);
   3380 		break;
   3381 	case ISCSI_PARAM_TARGET_ALIAS:
   3382 		len = sprintf(buf, "%s\n", session->targetalias);
   3383 		break;
   3384 	case ISCSI_PARAM_TPGT:
   3385 		len = sprintf(buf, "%d\n", session->tpgt);
   3386 		break;
   3387 	case ISCSI_PARAM_USERNAME:
   3388 		len = sprintf(buf, "%s\n", session->username);
   3389 		break;
   3390 	case ISCSI_PARAM_USERNAME_IN:
   3391 		len = sprintf(buf, "%s\n", session->username_in);
   3392 		break;
   3393 	case ISCSI_PARAM_PASSWORD:
   3394 		len = sprintf(buf, "%s\n", session->password);
   3395 		break;
   3396 	case ISCSI_PARAM_PASSWORD_IN:
   3397 		len = sprintf(buf, "%s\n", session->password_in);
   3398 		break;
   3399 	case ISCSI_PARAM_IFACE_NAME:
   3400 		len = sprintf(buf, "%s\n", session->ifacename);
   3401 		break;
   3402 	case ISCSI_PARAM_INITIATOR_NAME:
   3403 		len = sprintf(buf, "%s\n", session->initiatorname);
   3404 		break;
   3405 	case ISCSI_PARAM_BOOT_ROOT:
   3406 		len = sprintf(buf, "%s\n", session->boot_root);
   3407 		break;
   3408 	case ISCSI_PARAM_BOOT_NIC:
   3409 		len = sprintf(buf, "%s\n", session->boot_nic);
   3410 		break;
   3411 	case ISCSI_PARAM_BOOT_TARGET:
   3412 		len = sprintf(buf, "%s\n", session->boot_target);
   3413 		break;
   3414 	case ISCSI_PARAM_AUTO_SND_TGT_DISABLE:
   3415 		len = sprintf(buf, "%u\n", session->auto_snd_tgt_disable);
   3416 		break;
   3417 	case ISCSI_PARAM_DISCOVERY_SESS:
   3418 		len = sprintf(buf, "%u\n", session->discovery_sess);
   3419 		break;
   3420 	case ISCSI_PARAM_PORTAL_TYPE:
   3421 		len = sprintf(buf, "%s\n", session->portal_type);
   3422 		break;
   3423 	case ISCSI_PARAM_CHAP_AUTH_EN:
   3424 		len = sprintf(buf, "%u\n", session->chap_auth_en);
   3425 		break;
   3426 	case ISCSI_PARAM_DISCOVERY_LOGOUT_EN:
   3427 		len = sprintf(buf, "%u\n", session->discovery_logout_en);
   3428 		break;
   3429 	case ISCSI_PARAM_BIDI_CHAP_EN:
   3430 		len = sprintf(buf, "%u\n", session->bidi_chap_en);
   3431 		break;
   3432 	case ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL:
   3433 		len = sprintf(buf, "%u\n", session->discovery_auth_optional);
   3434 		break;
   3435 	case ISCSI_PARAM_DEF_TIME2WAIT:
   3436 		len = sprintf(buf, "%d\n", session->time2wait);
   3437 		break;
   3438 	case ISCSI_PARAM_DEF_TIME2RETAIN:
   3439 		len = sprintf(buf, "%d\n", session->time2retain);
   3440 		break;
   3441 	case ISCSI_PARAM_TSID:
   3442 		len = sprintf(buf, "%u\n", session->tsid);
   3443 		break;
   3444 	case ISCSI_PARAM_ISID:
   3445 		len = sprintf(buf, "%02x%02x%02x%02x%02x%02x\n",
   3446 			      session->isid[0], session->isid[1],
   3447 			      session->isid[2], session->isid[3],
   3448 			      session->isid[4], session->isid[5]);
   3449 		break;
   3450 	case ISCSI_PARAM_DISCOVERY_PARENT_IDX:
   3451 		len = sprintf(buf, "%u\n", session->discovery_parent_idx);
   3452 		break;
   3453 	case ISCSI_PARAM_DISCOVERY_PARENT_TYPE:
   3454 		if (session->discovery_parent_type)
   3455 			len = sprintf(buf, "%s\n",
   3456 				      session->discovery_parent_type);
   3457 		else
   3458 			len = sprintf(buf, "\n");
   3459 		break;
   3460 	default:
   3461 		return -ENOSYS;
   3462 	}
   3463 
   3464 	return len;
   3465 }
   3466 EXPORT_SYMBOL_GPL(iscsi_session_get_param);
   3467 
   3468 int iscsi_conn_get_addr_param(struct sockaddr_storage *addr,
   3469 			      enum iscsi_param param, char *buf)
   3470 {
   3471 	struct sockaddr_in6 *sin6 = NULL;
   3472 	struct sockaddr_in *sin = NULL;
   3473 	int len;
   3474 
   3475 	switch (addr->ss_family) {
   3476 	case AF_INET:
   3477 		sin = (struct sockaddr_in *)addr;
   3478 		break;
   3479 	case AF_INET6:
   3480 		sin6 = (struct sockaddr_in6 *)addr;
   3481 		break;
   3482 	default:
   3483 		return -EINVAL;
   3484 	}
   3485 
   3486 	switch (param) {
   3487 	case ISCSI_PARAM_CONN_ADDRESS:
   3488 	case ISCSI_HOST_PARAM_IPADDRESS:
   3489 		if (sin)
   3490 			len = sprintf(buf, "%pI4\n", &sin->sin_addr.s_addr);
   3491 		else
   3492 			len = sprintf(buf, "%pI6\n", &sin6->sin6_addr);
   3493 		break;
   3494 	case ISCSI_PARAM_CONN_PORT:
   3495 	case ISCSI_PARAM_LOCAL_PORT:
   3496 		if (sin)
   3497 			len = sprintf(buf, "%hu\n", be16_to_cpu(sin->sin_port));
   3498 		else
   3499 			len = sprintf(buf, "%hu\n",
   3500 				      be16_to_cpu(sin6->sin6_port));
   3501 		break;
   3502 	default:
   3503 		return -EINVAL;
   3504 	}
   3505 
   3506 	return len;
   3507 }
   3508 EXPORT_SYMBOL_GPL(iscsi_conn_get_addr_param);
   3509 
   3510 int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn,
   3511 			 enum iscsi_param param, char *buf)
   3512 {
   3513 	struct iscsi_conn *conn = cls_conn->dd_data;
   3514 	int len;
   3515 
   3516 	switch(param) {
   3517 	case ISCSI_PARAM_PING_TMO:
   3518 		len = sprintf(buf, "%u\n", conn->ping_timeout);
   3519 		break;
   3520 	case ISCSI_PARAM_RECV_TMO:
   3521 		len = sprintf(buf, "%u\n", conn->recv_timeout);
   3522 		break;
   3523 	case ISCSI_PARAM_MAX_RECV_DLENGTH:
   3524 		len = sprintf(buf, "%u\n", conn->max_recv_dlength);
   3525 		break;
   3526 	case ISCSI_PARAM_MAX_XMIT_DLENGTH:
   3527 		len = sprintf(buf, "%u\n", conn->max_xmit_dlength);
   3528 		break;
   3529 	case ISCSI_PARAM_HDRDGST_EN:
   3530 		len = sprintf(buf, "%d\n", conn->hdrdgst_en);
   3531 		break;
   3532 	case ISCSI_PARAM_DATADGST_EN:
   3533 		len = sprintf(buf, "%d\n", conn->datadgst_en);
   3534 		break;
   3535 	case ISCSI_PARAM_IFMARKER_EN:
   3536 		len = sprintf(buf, "%d\n", conn->ifmarker_en);
   3537 		break;
   3538 	case ISCSI_PARAM_OFMARKER_EN:
   3539 		len = sprintf(buf, "%d\n", conn->ofmarker_en);
   3540 		break;
   3541 	case ISCSI_PARAM_EXP_STATSN:
   3542 		len = sprintf(buf, "%u\n", conn->exp_statsn);
   3543 		break;
   3544 	case ISCSI_PARAM_PERSISTENT_PORT:
   3545 		len = sprintf(buf, "%d\n", conn->persistent_port);
   3546 		break;
   3547 	case ISCSI_PARAM_PERSISTENT_ADDRESS:
   3548 		len = sprintf(buf, "%s\n", conn->persistent_address);
   3549 		break;
   3550 	case ISCSI_PARAM_STATSN:
   3551 		len = sprintf(buf, "%u\n", conn->statsn);
   3552 		break;
   3553 	case ISCSI_PARAM_MAX_SEGMENT_SIZE:
   3554 		len = sprintf(buf, "%u\n", conn->max_segment_size);
   3555 		break;
   3556 	case ISCSI_PARAM_KEEPALIVE_TMO:
   3557 		len = sprintf(buf, "%u\n", conn->keepalive_tmo);
   3558 		break;
   3559 	case ISCSI_PARAM_LOCAL_PORT:
   3560 		len = sprintf(buf, "%u\n", conn->local_port);
   3561 		break;
   3562 	case ISCSI_PARAM_TCP_TIMESTAMP_STAT:
   3563 		len = sprintf(buf, "%u\n", conn->tcp_timestamp_stat);
   3564 		break;
   3565 	case ISCSI_PARAM_TCP_NAGLE_DISABLE:
   3566 		len = sprintf(buf, "%u\n", conn->tcp_nagle_disable);
   3567 		break;
   3568 	case ISCSI_PARAM_TCP_WSF_DISABLE:
   3569 		len = sprintf(buf, "%u\n", conn->tcp_wsf_disable);
   3570 		break;
   3571 	case ISCSI_PARAM_TCP_TIMER_SCALE:
   3572 		len = sprintf(buf, "%u\n", conn->tcp_timer_scale);
   3573 		break;
   3574 	case ISCSI_PARAM_TCP_TIMESTAMP_EN:
   3575 		len = sprintf(buf, "%u\n", conn->tcp_timestamp_en);
   3576 		break;
   3577 	case ISCSI_PARAM_IP_FRAGMENT_DISABLE:
   3578 		len = sprintf(buf, "%u\n", conn->fragment_disable);
   3579 		break;
   3580 	case ISCSI_PARAM_IPV4_TOS:
   3581 		len = sprintf(buf, "%u\n", conn->ipv4_tos);
   3582 		break;
   3583 	case ISCSI_PARAM_IPV6_TC:
   3584 		len = sprintf(buf, "%u\n", conn->ipv6_traffic_class);
   3585 		break;
   3586 	case ISCSI_PARAM_IPV6_FLOW_LABEL:
   3587 		len = sprintf(buf, "%u\n", conn->ipv6_flow_label);
   3588 		break;
   3589 	case ISCSI_PARAM_IS_FW_ASSIGNED_IPV6:
   3590 		len = sprintf(buf, "%u\n", conn->is_fw_assigned_ipv6);
   3591 		break;
   3592 	case ISCSI_PARAM_TCP_XMIT_WSF:
   3593 		len = sprintf(buf, "%u\n", conn->tcp_xmit_wsf);
   3594 		break;
   3595 	case ISCSI_PARAM_TCP_RECV_WSF:
   3596 		len = sprintf(buf, "%u\n", conn->tcp_recv_wsf);
   3597 		break;
   3598 	case ISCSI_PARAM_LOCAL_IPADDR:
   3599 		len = sprintf(buf, "%s\n", conn->local_ipaddr);
   3600 		break;
   3601 	default:
   3602 		return -ENOSYS;
   3603 	}
   3604 
   3605 	return len;
   3606 }
   3607 EXPORT_SYMBOL_GPL(iscsi_conn_get_param);
   3608 
   3609 int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param,
   3610 			 char *buf)
   3611 {
   3612 	struct iscsi_host *ihost = shost_priv(shost);
   3613 	int len;
   3614 
   3615 	switch (param) {
   3616 	case ISCSI_HOST_PARAM_NETDEV_NAME:
   3617 		len = sprintf(buf, "%s\n", ihost->netdev);
   3618 		break;
   3619 	case ISCSI_HOST_PARAM_HWADDRESS:
   3620 		len = sprintf(buf, "%s\n", ihost->hwaddress);
   3621 		break;
   3622 	case ISCSI_HOST_PARAM_INITIATOR_NAME:
   3623 		len = sprintf(buf, "%s\n", ihost->initiatorname);
   3624 		break;
   3625 	default:
   3626 		return -ENOSYS;
   3627 	}
   3628 
   3629 	return len;
   3630 }
   3631 EXPORT_SYMBOL_GPL(iscsi_host_get_param);
   3632 
   3633 int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param,
   3634 			 char *buf, int buflen)
   3635 {
   3636 	struct iscsi_host *ihost = shost_priv(shost);
   3637 
   3638 	switch (param) {
   3639 	case ISCSI_HOST_PARAM_NETDEV_NAME:
   3640 		return iscsi_switch_str_param(&ihost->netdev, buf);
   3641 	case ISCSI_HOST_PARAM_HWADDRESS:
   3642 		return iscsi_switch_str_param(&ihost->hwaddress, buf);
   3643 	case ISCSI_HOST_PARAM_INITIATOR_NAME:
   3644 		return iscsi_switch_str_param(&ihost->initiatorname, buf);
   3645 	default:
   3646 		return -ENOSYS;
   3647 	}
   3648 
   3649 	return 0;
   3650 }
   3651 EXPORT_SYMBOL_GPL(iscsi_host_set_param);
   3652 
   3653 MODULE_AUTHOR("Mike Christie");
   3654 MODULE_DESCRIPTION("iSCSI library functions");
   3655 MODULE_LICENSE("GPL");