libiscsi.c 83.5 KB
Newer Older
M
Mike Christie 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
/*
 * iSCSI lib functions
 *
 * Copyright (C) 2006 Red Hat, Inc.  All rights reserved.
 * Copyright (C) 2004 - 2006 Mike Christie
 * Copyright (C) 2004 - 2005 Dmitry Yusupov
 * Copyright (C) 2004 - 2005 Alex Aizman
 * maintained by open-iscsi@googlegroups.com
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */
#include <linux/types.h>
#include <linux/kfifo.h>
#include <linux/delay.h>
27
#include <linux/log2.h>
28
#include <asm/unaligned.h>
M
Mike Christie 已提交
29 30 31 32 33 34 35 36 37 38 39 40
#include <net/tcp.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_eh.h>
#include <scsi/scsi_tcq.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi.h>
#include <scsi/iscsi_proto.h>
#include <scsi/scsi_transport.h>
#include <scsi/scsi_transport_iscsi.h>
#include <scsi/libiscsi.h>

41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
static int iscsi_dbg_lib_conn;
module_param_named(debug_libiscsi_conn, iscsi_dbg_lib_conn, int,
		   S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug_libiscsi_conn,
		 "Turn on debugging for connections in libiscsi module. "
		 "Set to 1 to turn on, and zero to turn off. Default is off.");

static int iscsi_dbg_lib_session;
module_param_named(debug_libiscsi_session, iscsi_dbg_lib_session, int,
		   S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug_libiscsi_session,
		 "Turn on debugging for sessions in libiscsi module. "
		 "Set to 1 to turn on, and zero to turn off. Default is off.");

static int iscsi_dbg_lib_eh;
module_param_named(debug_libiscsi_eh, iscsi_dbg_lib_eh, int,
		   S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug_libiscsi_eh,
		 "Turn on debugging for error handling in libiscsi module. "
		 "Set to 1 to turn on, and zero to turn off. Default is off.");
61 62 63

#define ISCSI_DBG_CONN(_conn, dbg_fmt, arg...)			\
	do {							\
64
		if (iscsi_dbg_lib_conn)				\
65 66 67 68 69 70 71
			iscsi_conn_printk(KERN_INFO, _conn,	\
					     "%s " dbg_fmt,	\
					     __func__, ##arg);	\
	} while (0);

#define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...)			\
	do {								\
72 73 74 75 76 77 78 79 80
		if (iscsi_dbg_lib_session)				\
			iscsi_session_printk(KERN_INFO, _session,	\
					     "%s " dbg_fmt,		\
					     __func__, ##arg);		\
	} while (0);

#define ISCSI_DBG_EH(_session, dbg_fmt, arg...)				\
	do {								\
		if (iscsi_dbg_lib_eh)					\
81 82 83 84 85
			iscsi_session_printk(KERN_INFO, _session,	\
					     "%s " dbg_fmt,		\
					     __func__, ##arg);		\
	} while (0);

86 87
/* Serial Number Arithmetic, 32 bits, less than, RFC1982 */
#define SNA32_CHECK 2147483648UL
M
Mike Christie 已提交
88

89 90 91 92 93 94 95 96 97 98 99 100 101
static int iscsi_sna_lt(u32 n1, u32 n2)
{
	return n1 != n2 && ((n1 < n2 && (n2 - n1 < SNA32_CHECK)) ||
			    (n1 > n2 && (n2 - n1 < SNA32_CHECK)));
}

/* Serial Number Arithmetic, 32 bits, less than, RFC1982 */
static int iscsi_sna_lte(u32 n1, u32 n2)
{
	return n1 == n2 || ((n1 < n2 && (n2 - n1 < SNA32_CHECK)) ||
			    (n1 > n2 && (n2 - n1 < SNA32_CHECK)));
}

102 103 104 105 106
inline void iscsi_conn_queue_work(struct iscsi_conn *conn)
{
	struct Scsi_Host *shost = conn->session->host;
	struct iscsi_host *ihost = shost_priv(shost);

107 108
	if (ihost->workq)
		queue_work(ihost->workq, &conn->xmitwork);
109 110 111
}
EXPORT_SYMBOL_GPL(iscsi_conn_queue_work);

112 113
static void __iscsi_update_cmdsn(struct iscsi_session *session,
				 uint32_t exp_cmdsn, uint32_t max_cmdsn)
M
Mike Christie 已提交
114
{
115 116 117 118 119 120 121 122 123
	/*
	 * standard specifies this check for when to update expected and
	 * max sequence numbers
	 */
	if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1))
		return;

	if (exp_cmdsn != session->exp_cmdsn &&
	    !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn))
M
Mike Christie 已提交
124 125
		session->exp_cmdsn = exp_cmdsn;

126 127 128 129 130 131 132
	if (max_cmdsn != session->max_cmdsn &&
	    !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) {
		session->max_cmdsn = max_cmdsn;
		/*
		 * if the window closed with IO queued, then kick the
		 * xmit thread
		 */
133
		if (!list_empty(&session->leadconn->cmdqueue) ||
134 135
		    !list_empty(&session->leadconn->mgmtqueue))
			iscsi_conn_queue_work(session->leadconn);
136
	}
M
Mike Christie 已提交
137
}
138 139 140 141 142 143

void iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr)
{
	__iscsi_update_cmdsn(session, be32_to_cpu(hdr->exp_cmdsn),
			     be32_to_cpu(hdr->max_cmdsn));
}
144
EXPORT_SYMBOL_GPL(iscsi_update_cmdsn);
M
Mike Christie 已提交
145

146 147 148 149 150 151 152 153 154 155 156 157 158 159
/**
 * iscsi_prep_data_out_pdu - initialize Data-Out
 * @task: scsi command task
 * @r2t: R2T info
 * @hdr: iscsi data in pdu
 *
 * Notes:
 *	Initialize Data-Out within this R2T sequence and finds
 *	proper data_offset within this SCSI command.
 *
 *	This function is called with connection lock taken.
 **/
void iscsi_prep_data_out_pdu(struct iscsi_task *task, struct iscsi_r2t_info *r2t,
			   struct iscsi_data *hdr)
M
Mike Christie 已提交
160
{
161
	struct iscsi_conn *conn = task->conn;
162 163 164
	unsigned int left = r2t->data_length - r2t->sent;

	task->hdr_len = sizeof(struct iscsi_data);
M
Mike Christie 已提交
165 166

	memset(hdr, 0, sizeof(struct iscsi_data));
167 168 169
	hdr->ttt = r2t->ttt;
	hdr->datasn = cpu_to_be32(r2t->datasn);
	r2t->datasn++;
M
Mike Christie 已提交
170
	hdr->opcode = ISCSI_OP_SCSI_DATA_OUT;
171 172 173 174 175
	memcpy(hdr->lun, task->lun, sizeof(hdr->lun));
	hdr->itt = task->hdr_itt;
	hdr->exp_statsn = r2t->exp_statsn;
	hdr->offset = cpu_to_be32(r2t->data_offset + r2t->sent);
	if (left > conn->max_xmit_dlength) {
M
Mike Christie 已提交
176
		hton24(hdr->dlength, conn->max_xmit_dlength);
177
		r2t->data_count = conn->max_xmit_dlength;
M
Mike Christie 已提交
178 179
		hdr->flags = 0;
	} else {
180 181
		hton24(hdr->dlength, left);
		r2t->data_count = left;
M
Mike Christie 已提交
182 183
		hdr->flags = ISCSI_FLAG_CMD_FINAL;
	}
184
	conn->dataout_pdus_cnt++;
M
Mike Christie 已提交
185
}
186
EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu);
M
Mike Christie 已提交
187

188
static int iscsi_add_hdr(struct iscsi_task *task, unsigned len)
189
{
190
	unsigned exp_len = task->hdr_len + len;
191

192
	if (exp_len > task->hdr_max) {
193 194 195 196 197
		WARN_ON(1);
		return -EINVAL;
	}

	WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */
198
	task->hdr_len = exp_len;
199 200 201
	return 0;
}

202 203 204
/*
 * make an extended cdb AHS
 */
205
static int iscsi_prep_ecdb_ahs(struct iscsi_task *task)
206
{
207
	struct scsi_cmnd *cmd = task->sc;
208 209 210 211 212
	unsigned rlen, pad_len;
	unsigned short ahslength;
	struct iscsi_ecdb_ahdr *ecdb_ahdr;
	int rc;

213
	ecdb_ahdr = iscsi_next_hdr(task);
214 215 216 217 218 219 220
	rlen = cmd->cmd_len - ISCSI_CDB_SIZE;

	BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb));
	ahslength = rlen + sizeof(ecdb_ahdr->reserved);

	pad_len = iscsi_padding(rlen);

221
	rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) +
222 223 224 225 226 227 228 229 230 231 232 233
	                   sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len);
	if (rc)
		return rc;

	if (pad_len)
		memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len);

	ecdb_ahdr->ahslength = cpu_to_be16(ahslength);
	ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB;
	ecdb_ahdr->reserved = 0;
	memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen);

234 235 236 237 238
	ISCSI_DBG_SESSION(task->conn->session,
			  "iscsi_prep_ecdb_ahs: varlen_cdb_len %d "
		          "rlen %d pad_len %d ahs_length %d iscsi_headers_size "
		          "%u\n", cmd->cmd_len, rlen, pad_len, ahslength,
		          task->hdr_len);
239 240 241
	return 0;
}

242
static int iscsi_prep_bidi_ahs(struct iscsi_task *task)
243
{
244
	struct scsi_cmnd *sc = task->sc;
245 246 247
	struct iscsi_rlength_ahdr *rlen_ahdr;
	int rc;

248 249
	rlen_ahdr = iscsi_next_hdr(task);
	rc = iscsi_add_hdr(task, sizeof(*rlen_ahdr));
250 251 252 253 254 255 256 257 258 259
	if (rc)
		return rc;

	rlen_ahdr->ahslength =
		cpu_to_be16(sizeof(rlen_ahdr->read_length) +
						  sizeof(rlen_ahdr->reserved));
	rlen_ahdr->ahstype = ISCSI_AHSTYPE_RLENGTH;
	rlen_ahdr->reserved = 0;
	rlen_ahdr->read_length = cpu_to_be32(scsi_in(sc)->length);

260 261 262 263 264
	ISCSI_DBG_SESSION(task->conn->session,
			  "bidi-in rlen_ahdr->read_length(%d) "
		          "rlen_ahdr->ahslength(%d)\n",
		          be32_to_cpu(rlen_ahdr->read_length),
		          be16_to_cpu(rlen_ahdr->ahslength));
265 266 267
	return 0;
}

M
Mike Christie 已提交
268 269
/**
 * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu
270
 * @task: iscsi task
M
Mike Christie 已提交
271 272 273 274
 *
 * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set
 * fields like dlength or final based on how much data it sends
 */
275
static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
M
Mike Christie 已提交
276
{
277
	struct iscsi_conn *conn = task->conn;
M
Mike Christie 已提交
278
	struct iscsi_session *session = conn->session;
279
	struct scsi_cmnd *sc = task->sc;
280
	struct iscsi_cmd *hdr;
281
	unsigned hdrlength, cmd_len;
282
	itt_t itt;
283
	int rc;
M
Mike Christie 已提交
284

285 286 287 288 289
	if (conn->session->tt->alloc_pdu) {
		rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD);
		if (rc)
			return rc;
	}
290
	hdr = (struct iscsi_cmd *) task->hdr;
291
	itt = hdr->itt;
292 293
	memset(hdr, 0, sizeof(*hdr));

294 295 296 297 298
	if (session->tt->parse_pdu_itt)
		hdr->itt = task->hdr_itt = itt;
	else
		hdr->itt = task->hdr_itt = build_itt(task->itt,
						     task->conn->session->age);
299 300
	task->hdr_len = 0;
	rc = iscsi_add_hdr(task, sizeof(*hdr));
301 302
	if (rc)
		return rc;
303 304 305
	hdr->opcode = ISCSI_OP_SCSI_CMD;
	hdr->flags = ISCSI_ATTR_SIMPLE;
	int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun);
306
	memcpy(task->lun, hdr->lun, sizeof(task->lun));
307
	hdr->exp_statsn = cpu_to_be32(conn->exp_statsn);
308 309 310 311
	cmd_len = sc->cmd_len;
	if (cmd_len < ISCSI_CDB_SIZE)
		memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len);
	else if (cmd_len > ISCSI_CDB_SIZE) {
312
		rc = iscsi_prep_ecdb_ahs(task);
313 314 315 316 317
		if (rc)
			return rc;
		cmd_len = ISCSI_CDB_SIZE;
	}
	memcpy(hdr->cdb, sc->cmnd, cmd_len);
M
Mike Christie 已提交
318

319
	task->imm_count = 0;
320 321
	if (scsi_bidi_cmnd(sc)) {
		hdr->flags |= ISCSI_FLAG_CMD_READ;
322
		rc = iscsi_prep_bidi_ahs(task);
323 324 325
		if (rc)
			return rc;
	}
M
Mike Christie 已提交
326
	if (sc->sc_data_direction == DMA_TO_DEVICE) {
327
		unsigned out_len = scsi_out(sc)->length;
328 329
		struct iscsi_r2t_info *r2t = &task->unsol_r2t;

330
		hdr->data_length = cpu_to_be32(out_len);
M
Mike Christie 已提交
331 332 333 334 335 336 337 338 339 340 341
		hdr->flags |= ISCSI_FLAG_CMD_WRITE;
		/*
		 * Write counters:
		 *
		 *	imm_count	bytes to be sent right after
		 *			SCSI PDU Header
		 *
		 *	unsol_count	bytes(as Data-Out) to be sent
		 *			without	R2T ack right after
		 *			immediate data
		 *
342
		 *	r2t data_length bytes to be sent via R2T ack's
M
Mike Christie 已提交
343 344 345
		 *
		 *      pad_count       bytes to be sent as zero-padding
		 */
346
		memset(r2t, 0, sizeof(*r2t));
M
Mike Christie 已提交
347 348

		if (session->imm_data_en) {
349
			if (out_len >= session->first_burst)
350
				task->imm_count = min(session->first_burst,
M
Mike Christie 已提交
351 352
							conn->max_xmit_dlength);
			else
353
				task->imm_count = min(out_len,
M
Mike Christie 已提交
354
							conn->max_xmit_dlength);
355
			hton24(hdr->dlength, task->imm_count);
M
Mike Christie 已提交
356
		} else
357
			zero_data(hdr->dlength);
M
Mike Christie 已提交
358

359
		if (!session->initial_r2t_en) {
360 361 362 363 364
			r2t->data_length = min(session->first_burst, out_len) -
					       task->imm_count;
			r2t->data_offset = task->imm_count;
			r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG);
			r2t->exp_statsn = cpu_to_be32(conn->exp_statsn);
365 366
		}

367
		if (!task->unsol_r2t.data_length)
M
Mike Christie 已提交
368
			/* No unsolicit Data-Out's */
369
			hdr->flags |= ISCSI_FLAG_CMD_FINAL;
M
Mike Christie 已提交
370 371 372
	} else {
		hdr->flags |= ISCSI_FLAG_CMD_FINAL;
		zero_data(hdr->dlength);
373
		hdr->data_length = cpu_to_be32(scsi_in(sc)->length);
M
Mike Christie 已提交
374 375 376 377 378

		if (sc->sc_data_direction == DMA_FROM_DEVICE)
			hdr->flags |= ISCSI_FLAG_CMD_READ;
	}

379
	/* calculate size of additional header segments (AHSs) */
380
	hdrlength = task->hdr_len - sizeof(*hdr);
381 382 383 384 385 386 387

	WARN_ON(hdrlength & (ISCSI_PAD_LEN-1));
	hdrlength /= ISCSI_PAD_LEN;

	WARN_ON(hdrlength >= 256);
	hdr->hlength = hdrlength & 0xFF;

388
	if (session->tt->init_task && session->tt->init_task(task))
389 390
		return -EIO;

391
	task->state = ISCSI_TASK_RUNNING;
392 393
	hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn);
	session->cmdsn++;
394

395
	conn->scsicmd_pdus_cnt++;
396 397 398 399 400 401 402 403 404
	ISCSI_DBG_SESSION(session, "iscsi prep [%s cid %d sc %p cdb 0x%x "
			  "itt 0x%x len %d bidi_len %d cmdsn %d win %d]\n",
			  scsi_bidi_cmnd(sc) ? "bidirectional" :
			  sc->sc_data_direction == DMA_TO_DEVICE ?
			  "write" : "read", conn->id, sc, sc->cmnd[0],
			  task->itt, scsi_bufflen(sc),
			  scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0,
			  session->cmdsn,
			  session->max_cmdsn - session->exp_cmdsn + 1);
405
	return 0;
M
Mike Christie 已提交
406 407 408
}

/**
409
 * iscsi_free_task - free a task
410
 * @task: iscsi cmd task
M
Mike Christie 已提交
411 412
 *
 * Must be called with session lock.
413 414
 * This function returns the scsi command to scsi-ml or cleans
 * up mgmt tasks then returns the task to the pool.
M
Mike Christie 已提交
415
 */
416
static void iscsi_free_task(struct iscsi_task *task)
M
Mike Christie 已提交
417
{
418
	struct iscsi_conn *conn = task->conn;
419
	struct iscsi_session *session = conn->session;
420
	struct scsi_cmnd *sc = task->sc;
M
Mike Christie 已提交
421

422 423 424
	ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n",
			  task->itt, task->state, task->sc);

425
	session->tt->cleanup_task(task);
426
	task->state = ISCSI_TASK_FREE;
427
	task->sc = NULL;
428
	/*
429
	 * login task is preallocated so do not free
430
	 */
431
	if (conn->login_task == task)
432 433
		return;

434
	__kfifo_put(session->cmdpool.queue, (void*)&task, sizeof(void*));
435

436
	if (sc) {
437
		task->sc = NULL;
438 439 440 441 442 443 444 445 446
		/* SCSI eh reuses commands to verify us */
		sc->SCp.ptr = NULL;
		/*
		 * queue command may call this to free the task, but
		 * not have setup the sc callback
		 */
		if (sc->scsi_done)
			sc->scsi_done(sc);
	}
M
Mike Christie 已提交
447 448
}

449
void __iscsi_get_task(struct iscsi_task *task)
450
{
451
	atomic_inc(&task->refcount);
452
}
453
EXPORT_SYMBOL_GPL(__iscsi_get_task);
454

455
static void __iscsi_put_task(struct iscsi_task *task)
456
{
457
	if (atomic_dec_and_test(&task->refcount))
458
		iscsi_free_task(task);
459 460
}

461
void iscsi_put_task(struct iscsi_task *task)
462
{
463
	struct iscsi_session *session = task->conn->session;
464 465

	spin_lock_bh(&session->lock);
466
	__iscsi_put_task(task);
467 468
	spin_unlock_bh(&session->lock);
}
469
EXPORT_SYMBOL_GPL(iscsi_put_task);
470

471 472 473
/**
 * iscsi_complete_task - finish a task
 * @task: iscsi cmd task
474
 * @state: state to complete task with
475 476 477
 *
 * Must be called with session lock.
 */
478
static void iscsi_complete_task(struct iscsi_task *task, int state)
479 480 481
{
	struct iscsi_conn *conn = task->conn;

482 483 484
	ISCSI_DBG_SESSION(conn->session,
			  "complete task itt 0x%x state %d sc %p\n",
			  task->itt, task->state, task->sc);
485 486 487
	if (task->state == ISCSI_TASK_COMPLETED ||
	    task->state == ISCSI_TASK_ABRT_TMF ||
	    task->state == ISCSI_TASK_ABRT_SESS_RECOV)
488 489
		return;
	WARN_ON_ONCE(task->state == ISCSI_TASK_FREE);
490
	task->state = state;
491 492 493 494 495 496 497 498 499 500 501 502 503 504

	if (!list_empty(&task->running))
		list_del_init(&task->running);

	if (conn->task == task)
		conn->task = NULL;

	if (conn->ping_task == task)
		conn->ping_task = NULL;

	/* release get from queueing */
	__iscsi_put_task(task);
}

505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529
/**
 * iscsi_complete_scsi_task - finish scsi task normally
 * @task: iscsi task for scsi cmd
 * @exp_cmdsn: expected cmd sn in cpu format
 * @max_cmdsn: max cmd sn in cpu format
 *
 * This is used when drivers do not need or cannot perform
 * lower level pdu processing.
 *
 * Called with session lock
 */
void iscsi_complete_scsi_task(struct iscsi_task *task,
			      uint32_t exp_cmdsn, uint32_t max_cmdsn)
{
	struct iscsi_conn *conn = task->conn;

	ISCSI_DBG_SESSION(conn->session, "[itt 0x%x]\n", task->itt);

	conn->last_recv = jiffies;
	__iscsi_update_cmdsn(conn->session, exp_cmdsn, max_cmdsn);
	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
}
EXPORT_SYMBOL_GPL(iscsi_complete_scsi_task);


530
/*
531 532 533
 * session lock must be held and if not called for a task that is
 * still pending or from the xmit thread, then xmit thread must
 * be suspended.
534
 */
535
static void fail_scsi_task(struct iscsi_task *task, int err)
536
{
537
	struct iscsi_conn *conn = task->conn;
538
	struct scsi_cmnd *sc;
539
	int state;
540

541 542 543 544 545
	/*
	 * if a command completes and we get a successful tmf response
	 * we will hit this because the scsi eh abort code does not take
	 * a ref to the task.
	 */
546
	sc = task->sc;
547 548 549
	if (!sc)
		return;

550
	if (task->state == ISCSI_TASK_PENDING) {
551 552 553 554 555
		/*
		 * cmd never made it to the xmit thread, so we should not count
		 * the cmd in the sequencing
		 */
		conn->session->queued_cmdsn--;
556 557 558 559 560 561
		/* it was never sent so just complete like normal */
		state = ISCSI_TASK_COMPLETED;
	} else if (err == DID_TRANSPORT_DISRUPTED)
		state = ISCSI_TASK_ABRT_SESS_RECOV;
	else
		state = ISCSI_TASK_ABRT_TMF;
562

563
	sc->result = err << 16;
564 565 566 567 568 569
	if (!scsi_bidi_cmnd(sc))
		scsi_set_resid(sc, scsi_bufflen(sc));
	else {
		scsi_out(sc)->resid = scsi_out(sc)->length;
		scsi_in(sc)->resid = scsi_in(sc)->length;
	}
570

571
	iscsi_complete_task(task, state);
572 573
}

574
static int iscsi_prep_mgmt_task(struct iscsi_conn *conn,
575
				struct iscsi_task *task)
576 577
{
	struct iscsi_session *session = conn->session;
578
	struct iscsi_hdr *hdr = task->hdr;
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
	struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr;

	if (conn->session->state == ISCSI_STATE_LOGGING_OUT)
		return -ENOTCONN;

	if (hdr->opcode != (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) &&
	    hdr->opcode != (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE))
		nop->exp_statsn = cpu_to_be32(conn->exp_statsn);
	/*
	 * pre-format CmdSN for outgoing PDU.
	 */
	nop->cmdsn = cpu_to_be32(session->cmdsn);
	if (hdr->itt != RESERVED_ITT) {
		/*
		 * TODO: We always use immediate, so we never hit this.
		 * If we start to send tmfs or nops as non-immediate then
		 * we should start checking the cmdsn numbers for mgmt tasks.
		 */
		if (conn->c_stage == ISCSI_CONN_STARTED &&
		    !(hdr->opcode & ISCSI_OP_IMMEDIATE)) {
			session->queued_cmdsn++;
			session->cmdsn++;
		}
	}

604 605
	if (session->tt->init_task && session->tt->init_task(task))
		return -EIO;
606 607 608 609

	if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT)
		session->state = ISCSI_STATE_LOGGING_OUT;

610
	task->state = ISCSI_TASK_RUNNING;
611 612 613
	ISCSI_DBG_SESSION(session, "mgmtpdu [op 0x%x hdr->itt 0x%x "
			  "datalen %d]\n", hdr->opcode & ISCSI_OPCODE_MASK,
			  hdr->itt, task->data_count);
614 615 616
	return 0;
}

617
static struct iscsi_task *
618 619 620 621
__iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
		      char *data, uint32_t data_size)
{
	struct iscsi_session *session = conn->session;
622
	struct iscsi_host *ihost = shost_priv(session->host);
623
	struct iscsi_task *task;
624
	itt_t itt;
625 626 627 628 629 630 631 632 633

	if (session->state == ISCSI_STATE_TERMINATE)
		return NULL;

	if (hdr->opcode == (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) ||
	    hdr->opcode == (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE))
		/*
		 * Login and Text are sent serially, in
		 * request-followed-by-response sequence.
634 635
		 * Same task can be used. Same ITT must be used.
		 * Note that login_task is preallocated at conn_create().
636
		 */
637
		task = conn->login_task;
638
	else {
639 640 641
		if (session->state != ISCSI_STATE_LOGGED_IN)
			return NULL;

642 643 644
		BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE);
		BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED);

645
		if (!__kfifo_get(session->cmdpool.queue,
646
				 (void*)&task, sizeof(void*)))
647 648
			return NULL;
	}
649 650 651 652 653
	/*
	 * released in complete pdu for task we expect a response for, and
	 * released by the lld when it has transmitted the task for
	 * pdus we do not expect a response for.
	 */
654 655 656
	atomic_set(&task->refcount, 1);
	task->conn = conn;
	task->sc = NULL;
657 658
	INIT_LIST_HEAD(&task->running);
	task->state = ISCSI_TASK_PENDING;
659 660

	if (data_size) {
661 662
		memcpy(task->data, data, data_size);
		task->data_count = data_size;
663
	} else
664
		task->data_count = 0;
665

666 667 668 669
	if (conn->session->tt->alloc_pdu) {
		if (conn->session->tt->alloc_pdu(task, hdr->opcode)) {
			iscsi_conn_printk(KERN_ERR, conn, "Could not allocate "
					 "pdu for mgmt task.\n");
670
			goto free_task;
671
		}
672
	}
673

674
	itt = task->hdr->itt;
675
	task->hdr_len = sizeof(struct iscsi_hdr);
676
	memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr));
677 678 679 680 681 682 683 684 685

	if (hdr->itt != RESERVED_ITT) {
		if (session->tt->parse_pdu_itt)
			task->hdr->itt = itt;
		else
			task->hdr->itt = build_itt(task->itt,
						   task->conn->session->age);
	}

686
	if (!ihost->workq) {
687 688
		if (iscsi_prep_mgmt_task(conn, task))
			goto free_task;
689

690
		if (session->tt->xmit_task(task))
691
			goto free_task;
692 693
	} else {
		list_add_tail(&task->running, &conn->mgmtqueue);
694
		iscsi_conn_queue_work(conn);
695
	}
696

697
	return task;
698 699 700 701

free_task:
	__iscsi_put_task(task);
	return NULL;
702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718
}

int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr,
			char *data, uint32_t data_size)
{
	struct iscsi_conn *conn = cls_conn->dd_data;
	struct iscsi_session *session = conn->session;
	int err = 0;

	spin_lock_bh(&session->lock);
	if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size))
		err = -EPERM;
	spin_unlock_bh(&session->lock);
	return err;
}
EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu);

M
Mike Christie 已提交
719 720 721 722
/**
 * iscsi_cmd_rsp - SCSI Command Response processing
 * @conn: iscsi connection
 * @hdr: iscsi header
723
 * @task: scsi command task
M
Mike Christie 已提交
724 725 726 727
 * @data: cmd data buffer
 * @datalen: len of buffer
 *
 * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and
728
 * then completes the command and task.
M
Mike Christie 已提交
729
 **/
730
static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
731
			       struct iscsi_task *task, char *data,
732
			       int datalen)
M
Mike Christie 已提交
733 734 735
{
	struct iscsi_cmd_rsp *rhdr = (struct iscsi_cmd_rsp *)hdr;
	struct iscsi_session *session = conn->session;
736
	struct scsi_cmnd *sc = task->sc;
M
Mike Christie 已提交
737

738
	iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr);
M
Mike Christie 已提交
739 740 741 742 743 744 745 746 747 748
	conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1;

	sc->result = (DID_OK << 16) | rhdr->cmd_status;

	if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) {
		sc->result = DID_ERROR << 16;
		goto out;
	}

	if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) {
749
		uint16_t senselen;
M
Mike Christie 已提交
750 751 752

		if (datalen < 2) {
invalid_datalen:
753 754 755
			iscsi_conn_printk(KERN_ERR,  conn,
					 "Got CHECK_CONDITION but invalid data "
					 "buffer size of %d\n", datalen);
M
Mike Christie 已提交
756 757 758 759
			sc->result = DID_BAD_TARGET << 16;
			goto out;
		}

760
		senselen = get_unaligned_be16(data);
M
Mike Christie 已提交
761 762 763 764
		if (datalen < senselen)
			goto invalid_datalen;

		memcpy(sc->sense_buffer, data + 2,
765
		       min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE));
766 767 768
		ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n",
				  min_t(uint16_t, senselen,
				  SCSI_SENSE_BUFFERSIZE));
M
Mike Christie 已提交
769 770
	}

771 772 773 774 775 776 777 778 779 780 781 782
	if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW |
			   ISCSI_FLAG_CMD_BIDI_OVERFLOW)) {
		int res_count = be32_to_cpu(rhdr->bi_residual_count);

		if (scsi_bidi_cmnd(sc) && res_count > 0 &&
				(rhdr->flags & ISCSI_FLAG_CMD_BIDI_OVERFLOW ||
				 res_count <= scsi_in(sc)->length))
			scsi_in(sc)->resid = res_count;
		else
			sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
	}

783 784
	if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW |
	                   ISCSI_FLAG_CMD_OVERFLOW)) {
M
Mike Christie 已提交
785 786
		int res_count = be32_to_cpu(rhdr->residual_count);

787 788 789
		if (res_count > 0 &&
		    (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW ||
		     res_count <= scsi_bufflen(sc)))
790
			/* write side for bidi or uni-io set_resid */
791
			scsi_set_resid(sc, res_count);
M
Mike Christie 已提交
792 793
		else
			sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
794
	}
M
Mike Christie 已提交
795
out:
796
	ISCSI_DBG_SESSION(session, "cmd rsp done [sc %p res %d itt 0x%x]\n",
797
			  sc, sc->result, task->itt);
M
Mike Christie 已提交
798
	conn->scsirsp_pdus_cnt++;
799
	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
M
Mike Christie 已提交
800 801
}

802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817
/**
 * iscsi_data_in_rsp - SCSI Data-In Response processing
 * @conn: iscsi connection
 * @hdr:  iscsi pdu
 * @task: scsi command task
 **/
static void
iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
		  struct iscsi_task *task)
{
	struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr;
	struct scsi_cmnd *sc = task->sc;

	if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS))
		return;

818
	iscsi_update_cmdsn(conn->session, (struct iscsi_nopin *)hdr);
819 820 821 822 823 824 825 826 827 828 829 830 831 832
	sc->result = (DID_OK << 16) | rhdr->cmd_status;
	conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1;
	if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW |
	                   ISCSI_FLAG_DATA_OVERFLOW)) {
		int res_count = be32_to_cpu(rhdr->residual_count);

		if (res_count > 0 &&
		    (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW ||
		     res_count <= scsi_in(sc)->length))
			scsi_in(sc)->resid = res_count;
		else
			sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
	}

833 834 835
	ISCSI_DBG_SESSION(conn->session, "data in with status done "
			  "[sc %p res %d itt 0x%x]\n",
			  sc, sc->result, task->itt);
836
	conn->scsirsp_pdus_cnt++;
837
	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
838 839
}

840 841 842 843 844 845 846
static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr)
{
	struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr;

	conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
	conn->tmfrsp_pdus_cnt++;

847
	if (conn->tmf_state != TMF_QUEUED)
848 849 850
		return;

	if (tmf->response == ISCSI_TMF_RSP_COMPLETE)
851
		conn->tmf_state = TMF_SUCCESS;
852
	else if (tmf->response == ISCSI_TMF_RSP_NO_TASK)
853
		conn->tmf_state = TMF_NOT_FOUND;
854
	else
855
		conn->tmf_state = TMF_FAILED;
856 857 858
	wake_up(&conn->ehwait);
}

859 860 861
static void iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr)
{
        struct iscsi_nopout hdr;
862
	struct iscsi_task *task;
863

864
	if (!rhdr && conn->ping_task)
865 866 867 868 869 870 871 872 873 874 875 876 877
		return;

	memset(&hdr, 0, sizeof(struct iscsi_nopout));
	hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE;
	hdr.flags = ISCSI_FLAG_CMD_FINAL;

	if (rhdr) {
		memcpy(hdr.lun, rhdr->lun, 8);
		hdr.ttt = rhdr->ttt;
		hdr.itt = RESERVED_ITT;
	} else
		hdr.ttt = RESERVED_ITT;

878 879
	task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0);
	if (!task)
880
		iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n");
881 882 883 884 885
	else if (!rhdr) {
		/* only track our nops */
		conn->ping_task = task;
		conn->last_ping = jiffies;
	}
886 887
}

888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907
static int iscsi_nop_out_rsp(struct iscsi_task *task,
			     struct iscsi_nopin *nop, char *data, int datalen)
{
	struct iscsi_conn *conn = task->conn;
	int rc = 0;

	if (conn->ping_task != task) {
		/*
		 * If this is not in response to one of our
		 * nops then it must be from userspace.
		 */
		if (iscsi_recv_pdu(conn->cls_conn, (struct iscsi_hdr *)nop,
				   data, datalen))
			rc = ISCSI_ERR_CONN_FAILED;
	} else
		mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout);
	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
	return rc;
}

908 909 910 911 912
static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
			       char *data, int datalen)
{
	struct iscsi_reject *reject = (struct iscsi_reject *)hdr;
	struct iscsi_hdr rejected_pdu;
913
	int opcode, rc = 0;
914 915 916

	conn->exp_statsn = be32_to_cpu(reject->statsn) + 1;

917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949
	if (ntoh24(reject->dlength) > datalen ||
	    ntoh24(reject->dlength) < sizeof(struct iscsi_hdr)) {
		iscsi_conn_printk(KERN_ERR, conn, "Cannot handle rejected "
				  "pdu. Invalid data length (pdu dlength "
				  "%u, datalen %d\n", ntoh24(reject->dlength),
				  datalen);
		return ISCSI_ERR_PROTO;
	}
	memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr));
	opcode = rejected_pdu.opcode & ISCSI_OPCODE_MASK;

	switch (reject->reason) {
	case ISCSI_REASON_DATA_DIGEST_ERROR:
		iscsi_conn_printk(KERN_ERR, conn,
				  "pdu (op 0x%x itt 0x%x) rejected "
				  "due to DataDigest error.\n",
				  rejected_pdu.itt, opcode);
		break;
	case ISCSI_REASON_IMM_CMD_REJECT:
		iscsi_conn_printk(KERN_ERR, conn,
				  "pdu (op 0x%x itt 0x%x) rejected. Too many "
				  "immediate commands.\n",
				  rejected_pdu.itt, opcode);
		/*
		 * We only send one TMF at a time so if the target could not
		 * handle it, then it should get fixed (RFC mandates that
		 * a target can handle one immediate TMF per conn).
		 *
		 * For nops-outs, we could have sent more than one if
		 * the target is sending us lots of nop-ins
		 */
		if (opcode != ISCSI_OP_NOOP_OUT)
			return 0;
950

951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973
		 if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG))
			/*
			 * nop-out in response to target's nop-out rejected.
			 * Just resend.
			 */
			iscsi_send_nopout(conn,
					  (struct iscsi_nopin*)&rejected_pdu);
		else {
			struct iscsi_task *task;
			/*
			 * Our nop as ping got dropped. We know the target
			 * and transport are ok so just clean up
			 */
			task = iscsi_itt_to_task(conn, rejected_pdu.itt);
			if (!task) {
				iscsi_conn_printk(KERN_ERR, conn,
						 "Invalid pdu reject. Could "
						 "not lookup rejected task.\n");
				rc = ISCSI_ERR_BAD_ITT;
			} else
				rc = iscsi_nop_out_rsp(task,
					(struct iscsi_nopin*)&rejected_pdu,
					NULL, 0);
974
		}
975 976 977 978 979 980 981
		break;
	default:
		iscsi_conn_printk(KERN_ERR, conn,
				  "pdu (op 0x%x itt 0x%x) rejected. Reason "
				  "code 0x%x\n", rejected_pdu.itt,
				  rejected_pdu.opcode, reject->reason);
		break;
982
	}
983
	return rc;
984 985
}

986 987 988 989 990 991 992 993 994 995
/**
 * iscsi_itt_to_task - look up task by itt
 * @conn: iscsi connection
 * @itt: itt
 *
 * This should be used for mgmt tasks like login and nops, or if
 * the LDD's itt space does not include the session age.
 *
 * The session lock must be held.
 */
996
struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt)
997 998
{
	struct iscsi_session *session = conn->session;
999
	int i;
1000 1001 1002 1003

	if (itt == RESERVED_ITT)
		return NULL;

1004 1005 1006 1007
	if (session->tt->parse_pdu_itt)
		session->tt->parse_pdu_itt(conn, itt, &i, NULL);
	else
		i = get_itt(itt);
1008 1009 1010 1011 1012
	if (i >= session->cmds_max)
		return NULL;

	return session->cmds[i];
}
1013
EXPORT_SYMBOL_GPL(iscsi_itt_to_task);
1014

M
Mike Christie 已提交
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025
/**
 * __iscsi_complete_pdu - complete pdu
 * @conn: iscsi conn
 * @hdr: iscsi header
 * @data: data buffer
 * @datalen: len of data buffer
 *
 * Completes pdu processing by freeing any resources allocated at
 * queuecommand or send generic. session lock must be held and verify
 * itt must have been called.
 */
1026 1027
int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
			 char *data, int datalen)
M
Mike Christie 已提交
1028 1029 1030
{
	struct iscsi_session *session = conn->session;
	int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0;
1031
	struct iscsi_task *task;
M
Mike Christie 已提交
1032 1033
	uint32_t itt;

1034
	conn->last_recv = jiffies;
1035 1036 1037 1038
	rc = iscsi_verify_itt(conn, hdr->itt);
	if (rc)
		return rc;

A
Al Viro 已提交
1039 1040
	if (hdr->itt != RESERVED_ITT)
		itt = get_itt(hdr->itt);
M
Mike Christie 已提交
1041
	else
A
Al Viro 已提交
1042
		itt = ~0U;
M
Mike Christie 已提交
1043

1044 1045
	ISCSI_DBG_SESSION(session, "[op 0x%x cid %d itt 0x%x len %d]\n",
			  opcode, conn->id, itt, datalen);
M
Mike Christie 已提交
1046

1047
	if (itt == ~0U) {
1048
		iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
1049

M
Mike Christie 已提交
1050 1051
		switch(opcode) {
		case ISCSI_OP_NOOP_IN:
1052
			if (datalen) {
M
Mike Christie 已提交
1053
				rc = ISCSI_ERR_PROTO;
1054 1055 1056
				break;
			}

A
Al Viro 已提交
1057
			if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG))
1058 1059
				break;

1060
			iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr);
M
Mike Christie 已提交
1061 1062
			break;
		case ISCSI_OP_REJECT:
1063 1064
			rc = iscsi_handle_reject(conn, hdr, data, datalen);
			break;
M
Mike Christie 已提交
1065
		case ISCSI_OP_ASYNC_EVENT:
1066
			conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
M
Mike Christie 已提交
1067 1068
			if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen))
				rc = ISCSI_ERR_CONN_FAILED;
M
Mike Christie 已提交
1069 1070 1071 1072 1073
			break;
		default:
			rc = ISCSI_ERR_BAD_OPCODE;
			break;
		}
1074 1075 1076 1077 1078
		goto out;
	}

	switch(opcode) {
	case ISCSI_OP_SCSI_CMD_RSP:
1079 1080 1081 1082
	case ISCSI_OP_SCSI_DATA_IN:
		task = iscsi_itt_to_ctask(conn, hdr->itt);
		if (!task)
			return ISCSI_ERR_BAD_ITT;
1083
		task->last_xfer = jiffies;
1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104
		break;
	case ISCSI_OP_R2T:
		/*
		 * LLD handles R2Ts if they need to.
		 */
		return 0;
	case ISCSI_OP_LOGOUT_RSP:
	case ISCSI_OP_LOGIN_RSP:
	case ISCSI_OP_TEXT_RSP:
	case ISCSI_OP_SCSI_TMFUNC_RSP:
	case ISCSI_OP_NOOP_IN:
		task = iscsi_itt_to_task(conn, hdr->itt);
		if (!task)
			return ISCSI_ERR_BAD_ITT;
		break;
	default:
		return ISCSI_ERR_BAD_OPCODE;
	}

	switch(opcode) {
	case ISCSI_OP_SCSI_CMD_RSP:
1105
		iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen);
1106 1107
		break;
	case ISCSI_OP_SCSI_DATA_IN:
1108
		iscsi_data_in_rsp(conn, hdr, task);
1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
		break;
	case ISCSI_OP_LOGOUT_RSP:
		iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
		if (datalen) {
			rc = ISCSI_ERR_PROTO;
			break;
		}
		conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
		goto recv_pdu;
	case ISCSI_OP_LOGIN_RSP:
	case ISCSI_OP_TEXT_RSP:
		iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
		/*
		 * login related PDU's exp_statsn is handled in
		 * userspace
		 */
		goto recv_pdu;
	case ISCSI_OP_SCSI_TMFUNC_RSP:
		iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
		if (datalen) {
			rc = ISCSI_ERR_PROTO;
			break;
		}

		iscsi_tmf_rsp(conn, hdr);
1134
		iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
1135 1136 1137 1138 1139 1140 1141 1142 1143
		break;
	case ISCSI_OP_NOOP_IN:
		iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
		if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) {
			rc = ISCSI_ERR_PROTO;
			break;
		}
		conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;

1144 1145
		rc = iscsi_nop_out_rsp(task, (struct iscsi_nopin*)hdr,
				       data, datalen);
1146 1147 1148 1149 1150
		break;
	default:
		rc = ISCSI_ERR_BAD_OPCODE;
		break;
	}
M
Mike Christie 已提交
1151

1152 1153 1154 1155 1156
out:
	return rc;
recv_pdu:
	if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen))
		rc = ISCSI_ERR_CONN_FAILED;
1157
	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
M
Mike Christie 已提交
1158 1159
	return rc;
}
1160
EXPORT_SYMBOL_GPL(__iscsi_complete_pdu);
M
Mike Christie 已提交
1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173

int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
		       char *data, int datalen)
{
	int rc;

	spin_lock(&conn->session->lock);
	rc = __iscsi_complete_pdu(conn, hdr, data, datalen);
	spin_unlock(&conn->session->lock);
	return rc;
}
EXPORT_SYMBOL_GPL(iscsi_complete_pdu);

1174
int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt)
M
Mike Christie 已提交
1175 1176
{
	struct iscsi_session *session = conn->session;
1177
	int age = 0, i = 0;
M
Mike Christie 已提交
1178

1179 1180
	if (itt == RESERVED_ITT)
		return 0;
M
Mike Christie 已提交
1181

1182 1183 1184 1185 1186 1187 1188 1189
	if (session->tt->parse_pdu_itt)
		session->tt->parse_pdu_itt(conn, itt, &i, &age);
	else {
		i = get_itt(itt);
		age = ((__force u32)itt >> ISCSI_AGE_SHIFT) & ISCSI_AGE_MASK;
	}

	if (age != session->age) {
1190 1191
		iscsi_conn_printk(KERN_ERR, conn,
				  "received itt %x expected session age (%x)\n",
1192
				  (__force u32)itt, session->age);
1193 1194
		return ISCSI_ERR_BAD_ITT;
	}
M
Mike Christie 已提交
1195

1196 1197 1198 1199 1200
	if (i >= session->cmds_max) {
		iscsi_conn_printk(KERN_ERR, conn,
				  "received invalid itt index %u (max cmds "
				   "%u.\n", i, session->cmds_max);
		return ISCSI_ERR_BAD_ITT;
M
Mike Christie 已提交
1201 1202 1203 1204 1205
	}
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_verify_itt);

1206 1207 1208 1209 1210 1211 1212 1213 1214 1215
/**
 * iscsi_itt_to_ctask - look up ctask by itt
 * @conn: iscsi connection
 * @itt: itt
 *
 * This should be used for cmd tasks.
 *
 * The session lock must be held.
 */
struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt)
1216
{
1217
	struct iscsi_task *task;
1218 1219 1220 1221

	if (iscsi_verify_itt(conn, itt))
		return NULL;

1222 1223
	task = iscsi_itt_to_task(conn, itt);
	if (!task || !task->sc)
1224 1225
		return NULL;

1226 1227 1228 1229
	if (task->sc->SCp.phase != conn->session->age) {
		iscsi_session_printk(KERN_ERR, conn->session,
				  "task's session age %d, expected %d\n",
				  task->sc->SCp.phase, conn->session->age);
1230
		return NULL;
1231
	}
1232

1233
	return task;
1234 1235 1236
}
EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask);

1237
void iscsi_session_failure(struct iscsi_session *session,
1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267
			   enum iscsi_err err)
{
	struct iscsi_conn *conn;
	struct device *dev;
	unsigned long flags;

	spin_lock_irqsave(&session->lock, flags);
	conn = session->leadconn;
	if (session->state == ISCSI_STATE_TERMINATE || !conn) {
		spin_unlock_irqrestore(&session->lock, flags);
		return;
	}

	dev = get_device(&conn->cls_conn->dev);
	spin_unlock_irqrestore(&session->lock, flags);
	if (!dev)
	        return;
	/*
	 * if the host is being removed bypass the connection
	 * recovery initialization because we are going to kill
	 * the session.
	 */
	if (err == ISCSI_ERR_INVALID_HOST)
		iscsi_conn_error_event(conn->cls_conn, err);
	else
		iscsi_conn_failure(conn, err);
	put_device(dev);
}
EXPORT_SYMBOL_GPL(iscsi_session_failure);

M
Mike Christie 已提交
1268 1269 1270 1271 1272 1273
void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err)
{
	struct iscsi_session *session = conn->session;
	unsigned long flags;

	spin_lock_irqsave(&session->lock, flags);
1274 1275 1276 1277 1278
	if (session->state == ISCSI_STATE_FAILED) {
		spin_unlock_irqrestore(&session->lock, flags);
		return;
	}

1279
	if (conn->stop_stage == 0)
M
Mike Christie 已提交
1280 1281
		session->state = ISCSI_STATE_FAILED;
	spin_unlock_irqrestore(&session->lock, flags);
1282

M
Mike Christie 已提交
1283 1284
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
1285
	iscsi_conn_error_event(conn->cls_conn, err);
M
Mike Christie 已提交
1286 1287 1288
}
EXPORT_SYMBOL_GPL(iscsi_conn_failure);

1289 1290 1291 1292 1293 1294 1295
static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn)
{
	struct iscsi_session *session = conn->session;

	/*
	 * Check for iSCSI window and take care of CmdSN wrap-around
	 */
1296
	if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) {
1297 1298 1299 1300
		ISCSI_DBG_SESSION(session, "iSCSI CmdSN closed. ExpCmdSn "
				  "%u MaxCmdSN %u CmdSN %u/%u\n",
				  session->exp_cmdsn, session->max_cmdsn,
				  session->cmdsn, session->queued_cmdsn);
1301 1302 1303 1304 1305
		return -ENOSPC;
	}
	return 0;
}

1306
static int iscsi_xmit_task(struct iscsi_conn *conn)
1307
{
1308
	struct iscsi_task *task = conn->task;
1309
	int rc;
1310

1311 1312 1313
	if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx))
		return -ENODATA;

1314
	__iscsi_get_task(task);
1315
	spin_unlock_bh(&conn->session->lock);
1316
	rc = conn->session->tt->xmit_task(task);
1317
	spin_lock_bh(&conn->session->lock);
1318
	if (!rc) {
1319
		/* done with this task */
1320
		task->last_xfer = jiffies;
1321
		conn->task = NULL;
1322 1323
	}
	__iscsi_put_task(task);
1324 1325 1326
	return rc;
}

1327
/**
1328 1329
 * iscsi_requeue_task - requeue task to run from session workqueue
 * @task: task to requeue
1330
 *
1331
 * LLDs that need to run a task from the session workqueue should call
1332 1333
 * this. The session lock must be held. This should only be called
 * by software drivers.
1334
 */
1335
void iscsi_requeue_task(struct iscsi_task *task)
1336
{
1337
	struct iscsi_conn *conn = task->conn;
1338

1339 1340 1341 1342 1343 1344
	/*
	 * this may be on the requeue list already if the xmit_task callout
	 * is handling the r2ts while we are adding new ones
	 */
	if (list_empty(&task->running))
		list_add_tail(&task->running, &conn->requeue);
1345
	iscsi_conn_queue_work(conn);
1346
}
1347
EXPORT_SYMBOL_GPL(iscsi_requeue_task);
1348

M
Mike Christie 已提交
1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359
/**
 * iscsi_data_xmit - xmit any command into the scheduled connection
 * @conn: iscsi connection
 *
 * Notes:
 *	The function can return -EAGAIN in which case the caller must
 *	re-schedule it again later or recover. '0' return code means
 *	successful xmit.
 **/
static int iscsi_data_xmit(struct iscsi_conn *conn)
{
1360
	int rc = 0;
M
Mike Christie 已提交
1361

1362
	spin_lock_bh(&conn->session->lock);
1363
	if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) {
1364
		ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n");
1365
		spin_unlock_bh(&conn->session->lock);
1366
		return -ENODATA;
M
Mike Christie 已提交
1367 1368
	}

1369 1370
	if (conn->task) {
		rc = iscsi_xmit_task(conn);
1371
	        if (rc)
1372
		        goto done;
M
Mike Christie 已提交
1373 1374
	}

1375 1376 1377 1378 1379 1380
	/*
	 * process mgmt pdus like nops before commands since we should
	 * only have one nop-out as a ping from us and targets should not
	 * overflow us with nop-ins
	 */
check_mgmt:
1381
	while (!list_empty(&conn->mgmtqueue)) {
1382 1383
		conn->task = list_entry(conn->mgmtqueue.next,
					 struct iscsi_task, running);
1384
		list_del_init(&conn->task->running);
1385 1386 1387
		if (iscsi_prep_mgmt_task(conn, conn->task)) {
			__iscsi_put_task(conn->task);
			conn->task = NULL;
1388 1389
			continue;
		}
1390
		rc = iscsi_xmit_task(conn);
1391
		if (rc)
1392
			goto done;
M
Mike Christie 已提交
1393 1394
	}

1395
	/* process pending command queue */
1396
	while (!list_empty(&conn->cmdqueue)) {
1397 1398 1399
		if (conn->tmf_state == TMF_QUEUED)
			break;

1400
		conn->task = list_entry(conn->cmdqueue.next,
1401
					 struct iscsi_task, running);
1402
		list_del_init(&conn->task->running);
1403
		if (conn->session->state == ISCSI_STATE_LOGGING_OUT) {
1404
			fail_scsi_task(conn->task, DID_IMM_RETRY);
1405 1406
			continue;
		}
1407 1408 1409
		rc = iscsi_prep_scsi_cmd_pdu(conn->task);
		if (rc) {
			if (rc == -ENOMEM) {
1410 1411
				list_add_tail(&conn->task->running,
					      &conn->cmdqueue);
1412
				conn->task = NULL;
1413
				goto done;
1414
			} else
1415
				fail_scsi_task(conn->task, DID_ABORT);
1416 1417
			continue;
		}
1418
		rc = iscsi_xmit_task(conn);
1419
		if (rc)
1420
			goto done;
1421
		/*
1422
		 * we could continuously get new task requests so
1423 1424 1425
		 * we need to check the mgmt queue for nops that need to
		 * be sent to aviod starvation
		 */
1426 1427 1428 1429 1430 1431 1432 1433
		if (!list_empty(&conn->mgmtqueue))
			goto check_mgmt;
	}

	while (!list_empty(&conn->requeue)) {
		if (conn->session->fast_abort && conn->tmf_state != TMF_INITIAL)
			break;

1434 1435 1436 1437 1438 1439
		/*
		 * we always do fastlogout - conn stop code will clean up.
		 */
		if (conn->session->state == ISCSI_STATE_LOGGING_OUT)
			break;

1440 1441
		conn->task = list_entry(conn->requeue.next,
					 struct iscsi_task, running);
1442
		list_del_init(&conn->task->running);
1443 1444
		conn->task->state = ISCSI_TASK_RUNNING;
		rc = iscsi_xmit_task(conn);
1445
		if (rc)
1446
			goto done;
1447
		if (!list_empty(&conn->mgmtqueue))
1448
			goto check_mgmt;
M
Mike Christie 已提交
1449
	}
1450
	spin_unlock_bh(&conn->session->lock);
1451
	return -ENODATA;
M
Mike Christie 已提交
1452

1453
done:
1454
	spin_unlock_bh(&conn->session->lock);
1455
	return rc;
M
Mike Christie 已提交
1456 1457
}

D
David Howells 已提交
1458
static void iscsi_xmitworker(struct work_struct *work)
M
Mike Christie 已提交
1459
{
D
David Howells 已提交
1460 1461
	struct iscsi_conn *conn =
		container_of(work, struct iscsi_conn, xmitwork);
1462
	int rc;
M
Mike Christie 已提交
1463 1464 1465
	/*
	 * serialize Xmit worker on a per-connection basis.
	 */
1466 1467 1468
	do {
		rc = iscsi_data_xmit(conn);
	} while (rc >= 0 || rc == -EAGAIN);
M
Mike Christie 已提交
1469 1470
}

1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486
static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn,
						  struct scsi_cmnd *sc)
{
	struct iscsi_task *task;

	if (!__kfifo_get(conn->session->cmdpool.queue,
			 (void *) &task, sizeof(void *)))
		return NULL;

	sc->SCp.phase = conn->session->age;
	sc->SCp.ptr = (char *) task;

	atomic_set(&task->refcount, 1);
	task->state = ISCSI_TASK_PENDING;
	task->conn = conn;
	task->sc = sc;
1487 1488 1489
	task->have_checked_conn = false;
	task->last_timeout = jiffies;
	task->last_xfer = jiffies;
1490 1491 1492 1493
	INIT_LIST_HEAD(&task->running);
	return task;
}

M
Mike Christie 已提交
1494 1495 1496 1497 1498
enum {
	FAILURE_BAD_HOST = 1,
	FAILURE_SESSION_FAILED,
	FAILURE_SESSION_FREED,
	FAILURE_WINDOW_CLOSED,
1499
	FAILURE_OOM,
M
Mike Christie 已提交
1500
	FAILURE_SESSION_TERMINATE,
1501
	FAILURE_SESSION_IN_RECOVERY,
M
Mike Christie 已提交
1502
	FAILURE_SESSION_RECOVERY_TIMEOUT,
1503
	FAILURE_SESSION_LOGGING_OUT,
1504
	FAILURE_SESSION_NOT_READY,
M
Mike Christie 已提交
1505 1506 1507 1508
};

int iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
{
1509
	struct iscsi_cls_session *cls_session;
M
Mike Christie 已提交
1510
	struct Scsi_Host *host;
1511
	struct iscsi_host *ihost;
M
Mike Christie 已提交
1512 1513 1514
	int reason = 0;
	struct iscsi_session *session;
	struct iscsi_conn *conn;
1515
	struct iscsi_task *task = NULL;
M
Mike Christie 已提交
1516 1517 1518

	sc->scsi_done = done;
	sc->result = 0;
1519
	sc->SCp.ptr = NULL;
M
Mike Christie 已提交
1520 1521

	host = sc->device->host;
1522
	ihost = shost_priv(host);
1523
	spin_unlock(host->host_lock);
M
Mike Christie 已提交
1524

1525 1526
	cls_session = starget_to_session(scsi_target(sc->device));
	session = cls_session->dd_data;
M
Mike Christie 已提交
1527 1528
	spin_lock(&session->lock);

1529
	reason = iscsi_session_chkready(cls_session);
1530 1531 1532 1533 1534
	if (reason) {
		sc->result = reason;
		goto fault;
	}

1535
	if (session->state != ISCSI_STATE_LOGGED_IN) {
1536 1537 1538 1539 1540 1541
		/*
		 * to handle the race between when we set the recovery state
		 * and block the session we requeue here (commands could
		 * be entering our queuecommand while a block is starting
		 * up because the block code is not locked)
		 */
1542
		switch (session->state) {
1543
		case ISCSI_STATE_FAILED:
1544
		case ISCSI_STATE_IN_RECOVERY:
1545
			reason = FAILURE_SESSION_IN_RECOVERY;
1546 1547
			sc->result = DID_IMM_RETRY << 16;
			break;
1548 1549
		case ISCSI_STATE_LOGGING_OUT:
			reason = FAILURE_SESSION_LOGGING_OUT;
1550 1551
			sc->result = DID_IMM_RETRY << 16;
			break;
1552
		case ISCSI_STATE_RECOVERY_FAILED:
1553
			reason = FAILURE_SESSION_RECOVERY_TIMEOUT;
1554
			sc->result = DID_TRANSPORT_FAILFAST << 16;
1555 1556
			break;
		case ISCSI_STATE_TERMINATE:
1557
			reason = FAILURE_SESSION_TERMINATE;
1558
			sc->result = DID_NO_CONNECT << 16;
1559 1560
			break;
		default:
1561
			reason = FAILURE_SESSION_FREED;
1562
			sc->result = DID_NO_CONNECT << 16;
1563
		}
M
Mike Christie 已提交
1564 1565 1566 1567
		goto fault;
	}

	conn = session->leadconn;
1568 1569
	if (!conn) {
		reason = FAILURE_SESSION_FREED;
1570
		sc->result = DID_NO_CONNECT << 16;
1571 1572
		goto fault;
	}
M
Mike Christie 已提交
1573

1574 1575 1576 1577 1578 1579
	if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) {
		reason = FAILURE_SESSION_IN_RECOVERY;
		sc->result = DID_REQUEUE;
		goto fault;
	}

1580 1581 1582 1583 1584
	if (iscsi_check_cmdsn_window_closed(conn)) {
		reason = FAILURE_WINDOW_CLOSED;
		goto reject;
	}

1585 1586
	task = iscsi_alloc_task(conn, sc);
	if (!task) {
1587 1588 1589
		reason = FAILURE_OOM;
		goto reject;
	}
M
Mike Christie 已提交
1590

1591
	if (!ihost->workq) {
1592 1593 1594 1595 1596 1597 1598 1599 1600
		reason = iscsi_prep_scsi_cmd_pdu(task);
		if (reason) {
			if (reason == -ENOMEM) {
				reason = FAILURE_OOM;
				goto prepd_reject;
			} else {
				sc->result = DID_ABORT << 16;
				goto prepd_fault;
			}
1601
		}
1602
		if (session->tt->xmit_task(task)) {
1603
			session->cmdsn--;
1604
			reason = FAILURE_SESSION_NOT_READY;
1605
			goto prepd_reject;
1606
		}
1607 1608
	} else {
		list_add_tail(&task->running, &conn->cmdqueue);
1609
		iscsi_conn_queue_work(conn);
1610
	}
1611 1612 1613

	session->queued_cmdsn++;
	spin_unlock(&session->lock);
1614
	spin_lock(host->host_lock);
M
Mike Christie 已提交
1615 1616
	return 0;

1617 1618
prepd_reject:
	sc->scsi_done = NULL;
1619
	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
M
Mike Christie 已提交
1620 1621
reject:
	spin_unlock(&session->lock);
1622 1623
	ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n",
			  sc->cmnd[0], reason);
1624
	spin_lock(host->host_lock);
1625
	return SCSI_MLQUEUE_TARGET_BUSY;
M
Mike Christie 已提交
1626

1627 1628
prepd_fault:
	sc->scsi_done = NULL;
1629
	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
M
Mike Christie 已提交
1630 1631
fault:
	spin_unlock(&session->lock);
1632 1633
	ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n",
			  sc->cmnd[0], reason);
1634 1635 1636 1637 1638 1639
	if (!scsi_bidi_cmnd(sc))
		scsi_set_resid(sc, scsi_bufflen(sc));
	else {
		scsi_out(sc)->resid = scsi_out(sc)->length;
		scsi_in(sc)->resid = scsi_in(sc)->length;
	}
1640
	done(sc);
1641
	spin_lock(host->host_lock);
M
Mike Christie 已提交
1642 1643 1644 1645
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_queuecommand);

1646
int iscsi_change_queue_depth(struct scsi_device *sdev, int depth, int reason)
M
Mike Christie 已提交
1647
{
1648 1649 1650
	if (reason != SCSI_QDEPTH_DEFAULT)
		return -EOPNOTSUPP;

M
Mike Christie 已提交
1651 1652 1653 1654 1655
	scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
	return sdev->queue_depth;
}
EXPORT_SYMBOL_GPL(iscsi_change_queue_depth);

1656 1657 1658 1659 1660 1661 1662 1663 1664 1665
int iscsi_target_alloc(struct scsi_target *starget)
{
	struct iscsi_cls_session *cls_session = starget_to_session(starget);
	struct iscsi_session *session = cls_session->dd_data;

	starget->can_queue = session->scsi_cmds_max;
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_target_alloc);

M
Mike Christie 已提交
1666 1667
void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session)
{
1668
	struct iscsi_session *session = cls_session->dd_data;
M
Mike Christie 已提交
1669 1670 1671

	spin_lock_bh(&session->lock);
	if (session->state != ISCSI_STATE_LOGGED_IN) {
1672
		session->state = ISCSI_STATE_RECOVERY_FAILED;
1673 1674
		if (session->leadconn)
			wake_up(&session->leadconn->ehwait);
M
Mike Christie 已提交
1675 1676 1677 1678 1679
	}
	spin_unlock_bh(&session->lock);
}
EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout);

1680
int iscsi_eh_target_reset(struct scsi_cmnd *sc)
M
Mike Christie 已提交
1681
{
1682 1683 1684 1685 1686 1687 1688
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
	struct iscsi_conn *conn;

	cls_session = starget_to_session(scsi_target(sc->device));
	session = cls_session->dd_data;
	conn = session->leadconn;
M
Mike Christie 已提交
1689

1690
	mutex_lock(&session->eh_mutex);
M
Mike Christie 已提交
1691 1692 1693
	spin_lock_bh(&session->lock);
	if (session->state == ISCSI_STATE_TERMINATE) {
failed:
1694 1695 1696 1697
		ISCSI_DBG_EH(session,
			     "failing target reset: Could not log back into "
			     "target [age %d]\n",
			     session->age);
M
Mike Christie 已提交
1698
		spin_unlock_bh(&session->lock);
1699
		mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
1700 1701 1702 1703
		return FAILED;
	}

	spin_unlock_bh(&session->lock);
1704
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
1705 1706 1707 1708
	/*
	 * we drop the lock here but the leadconn cannot be destoyed while
	 * we are in the scsi eh
	 */
1709
	iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
M
Mike Christie 已提交
1710

1711
	ISCSI_DBG_EH(session, "wait for relogin\n");
M
Mike Christie 已提交
1712 1713 1714
	wait_event_interruptible(conn->ehwait,
				 session->state == ISCSI_STATE_TERMINATE ||
				 session->state == ISCSI_STATE_LOGGED_IN ||
1715
				 session->state == ISCSI_STATE_RECOVERY_FAILED);
M
Mike Christie 已提交
1716 1717 1718
	if (signal_pending(current))
		flush_signals(current);

1719
	mutex_lock(&session->eh_mutex);
M
Mike Christie 已提交
1720
	spin_lock_bh(&session->lock);
1721 1722 1723 1724
	if (session->state == ISCSI_STATE_LOGGED_IN) {
		ISCSI_DBG_EH(session,
			     "target reset succeeded\n");
	} else
M
Mike Christie 已提交
1725 1726
		goto failed;
	spin_unlock_bh(&session->lock);
1727
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
1728 1729
	return SUCCESS;
}
1730
EXPORT_SYMBOL_GPL(iscsi_eh_target_reset);
M
Mike Christie 已提交
1731

1732
static void iscsi_tmf_timedout(unsigned long data)
M
Mike Christie 已提交
1733
{
1734
	struct iscsi_conn *conn = (struct iscsi_conn *)data;
M
Mike Christie 已提交
1735 1736 1737
	struct iscsi_session *session = conn->session;

	spin_lock(&session->lock);
1738 1739
	if (conn->tmf_state == TMF_QUEUED) {
		conn->tmf_state = TMF_TIMEDOUT;
1740
		ISCSI_DBG_EH(session, "tmf timedout\n");
M
Mike Christie 已提交
1741 1742 1743 1744 1745 1746
		/* unblock eh_abort() */
		wake_up(&conn->ehwait);
	}
	spin_unlock(&session->lock);
}

1747
static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn,
1748 1749
				   struct iscsi_tm *hdr, int age,
				   int timeout)
M
Mike Christie 已提交
1750 1751
{
	struct iscsi_session *session = conn->session;
1752
	struct iscsi_task *task;
M
Mike Christie 已提交
1753

1754
	task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr,
1755
				      NULL, 0);
1756
	if (!task) {
1757
		spin_unlock_bh(&session->lock);
M
Mike Christie 已提交
1758
		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
1759
		spin_lock_bh(&session->lock);
1760
		ISCSI_DBG_EH(session, "tmf exec failure\n");
1761
		return -EPERM;
M
Mike Christie 已提交
1762
	}
1763
	conn->tmfcmd_pdus_cnt++;
1764
	conn->tmf_timer.expires = timeout * HZ + jiffies;
1765 1766 1767
	conn->tmf_timer.function = iscsi_tmf_timedout;
	conn->tmf_timer.data = (unsigned long)conn;
	add_timer(&conn->tmf_timer);
1768
	ISCSI_DBG_EH(session, "tmf set timeout\n");
M
Mike Christie 已提交
1769 1770

	spin_unlock_bh(&session->lock);
1771
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
1772 1773 1774 1775

	/*
	 * block eh thread until:
	 *
1776 1777
	 * 1) tmf response
	 * 2) tmf timeout
M
Mike Christie 已提交
1778 1779 1780
	 * 3) session is terminated or restarted or userspace has
	 * given up on recovery
	 */
1781
	wait_event_interruptible(conn->ehwait, age != session->age ||
M
Mike Christie 已提交
1782
				 session->state != ISCSI_STATE_LOGGED_IN ||
1783
				 conn->tmf_state != TMF_QUEUED);
M
Mike Christie 已提交
1784 1785
	if (signal_pending(current))
		flush_signals(current);
1786 1787
	del_timer_sync(&conn->tmf_timer);

1788
	mutex_lock(&session->eh_mutex);
1789
	spin_lock_bh(&session->lock);
1790
	/* if the session drops it will clean up the task */
1791 1792 1793
	if (age != session->age ||
	    session->state != ISCSI_STATE_LOGGED_IN)
		return -ENOTCONN;
M
Mike Christie 已提交
1794 1795 1796
	return 0;
}

1797 1798 1799 1800
/*
 * Fail commands. session lock held and recv side suspended and xmit
 * thread flushed
 */
1801 1802
static void fail_scsi_tasks(struct iscsi_conn *conn, unsigned lun,
			    int error)
1803
{
1804 1805
	struct iscsi_task *task;
	int i;
1806

1807 1808 1809 1810
	for (i = 0; i < conn->session->cmds_max; i++) {
		task = conn->session->cmds[i];
		if (!task->sc || task->state == ISCSI_TASK_FREE)
			continue;
1811

1812 1813
		if (lun != -1 && lun != task->sc->device->lun)
			continue;
1814

1815 1816 1817
		ISCSI_DBG_SESSION(conn->session,
				  "failing sc %p itt 0x%x state %d\n",
				  task->sc, task->itt, task->state);
1818
		fail_scsi_task(task, error);
1819 1820 1821
	}
}

1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848
/**
 * iscsi_suspend_queue - suspend iscsi_queuecommand
 * @conn: iscsi conn to stop queueing IO on
 *
 * This grabs the session lock to make sure no one is in
 * xmit_task/queuecommand, and then sets suspend to prevent
 * new commands from being queued. This only needs to be called
 * by offload drivers that need to sync a path like ep disconnect
 * with the iscsi_queuecommand/xmit_task. To start IO again libiscsi
 * will call iscsi_start_tx and iscsi_unblock_session when in FFP.
 */
void iscsi_suspend_queue(struct iscsi_conn *conn)
{
	spin_lock_bh(&conn->session->lock);
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
	spin_unlock_bh(&conn->session->lock);
}
EXPORT_SYMBOL_GPL(iscsi_suspend_queue);

/**
 * iscsi_suspend_tx - suspend iscsi_data_xmit
 * @conn: iscsi conn tp stop processing IO on.
 *
 * This function sets the suspend bit to prevent iscsi_data_xmit
 * from sending new IO, and if work is queued on the xmit thread
 * it will wait for it to be completed.
 */
1849
void iscsi_suspend_tx(struct iscsi_conn *conn)
1850
{
1851 1852 1853
	struct Scsi_Host *shost = conn->session->host;
	struct iscsi_host *ihost = shost_priv(shost);

1854
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
1855
	if (ihost->workq)
1856
		flush_workqueue(ihost->workq);
1857
}
1858
EXPORT_SYMBOL_GPL(iscsi_suspend_tx);
1859 1860 1861 1862

static void iscsi_start_tx(struct iscsi_conn *conn)
{
	clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
1863
	iscsi_conn_queue_work(conn);
1864 1865
}

1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881
/*
 * We want to make sure a ping is in flight. It has timed out.
 * And we are not busy processing a pdu that is making
 * progress but got started before the ping and is taking a while
 * to complete so the ping is just stuck behind it in a queue.
 */
static int iscsi_has_ping_timed_out(struct iscsi_conn *conn)
{
	if (conn->ping_task &&
	    time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) +
			   (conn->ping_timeout * HZ), jiffies))
		return 1;
	else
		return 0;
}

1882
static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
1883
{
1884 1885
	enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED;
	struct iscsi_task *task = NULL;
1886 1887 1888 1889
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
	struct iscsi_conn *conn;

1890
	cls_session = starget_to_session(scsi_target(sc->device));
1891
	session = cls_session->dd_data;
1892

1893
	ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc);
1894 1895 1896 1897 1898 1899 1900

	spin_lock(&session->lock);
	if (session->state != ISCSI_STATE_LOGGED_IN) {
		/*
		 * We are probably in the middle of iscsi recovery so let
		 * that complete and handle the error.
		 */
J
Jens Axboe 已提交
1901
		rc = BLK_EH_RESET_TIMER;
1902 1903 1904 1905 1906 1907
		goto done;
	}

	conn = session->leadconn;
	if (!conn) {
		/* In the middle of shuting down */
J
Jens Axboe 已提交
1908
		rc = BLK_EH_RESET_TIMER;
1909 1910 1911
		goto done;
	}

1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922
	task = (struct iscsi_task *)sc->SCp.ptr;
	if (!task)
		goto done;
	/*
	 * If we have sent (at least queued to the network layer) a pdu or
	 * recvd one for the task since the last timeout ask for
	 * more time. If on the next timeout we have not made progress
	 * we can check if it is the task or connection when we send the
	 * nop as a ping.
	 */
	if (time_after_eq(task->last_xfer, task->last_timeout)) {
1923 1924 1925 1926
		ISCSI_DBG_EH(session, "Command making progress. Asking "
			     "scsi-ml for more time to complete. "
			     "Last data recv at %lu. Last timeout was at "
			     "%lu\n.", task->last_xfer, task->last_timeout);
1927 1928 1929 1930 1931
		task->have_checked_conn = false;
		rc = BLK_EH_RESET_TIMER;
		goto done;
	}

1932 1933 1934 1935 1936 1937
	if (!conn->recv_timeout && !conn->ping_timeout)
		goto done;
	/*
	 * if the ping timedout then we are in the middle of cleaning up
	 * and can let the iscsi eh handle it
	 */
1938
	if (iscsi_has_ping_timed_out(conn)) {
J
Jens Axboe 已提交
1939
		rc = BLK_EH_RESET_TIMER;
1940 1941
		goto done;
	}
1942 1943 1944 1945 1946

	/* Assumes nop timeout is shorter than scsi cmd timeout */
	if (task->have_checked_conn)
		goto done;

1947
	/*
1948 1949
	 * Checking the transport already or nop from a cmd timeout still
	 * running
1950
	 */
1951 1952
	if (conn->ping_task) {
		task->have_checked_conn = true;
J
Jens Axboe 已提交
1953
		rc = BLK_EH_RESET_TIMER;
1954 1955 1956
		goto done;
	}

1957 1958 1959 1960 1961
	/* Make sure there is a transport check done */
	iscsi_send_nopout(conn, NULL);
	task->have_checked_conn = true;
	rc = BLK_EH_RESET_TIMER;

1962
done:
1963 1964
	if (task)
		task->last_timeout = jiffies;
1965
	spin_unlock(&session->lock);
1966 1967
	ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ?
		     "timer reset" : "nh");
1968 1969 1970 1971 1972 1973 1974
	return rc;
}

static void iscsi_check_transport_timeouts(unsigned long data)
{
	struct iscsi_conn *conn = (struct iscsi_conn *)data;
	struct iscsi_session *session = conn->session;
1975
	unsigned long recv_timeout, next_timeout = 0, last_recv;
1976 1977 1978 1979 1980

	spin_lock(&session->lock);
	if (session->state != ISCSI_STATE_LOGGED_IN)
		goto done;

1981 1982
	recv_timeout = conn->recv_timeout;
	if (!recv_timeout)
1983 1984
		goto done;

1985
	recv_timeout *= HZ;
1986
	last_recv = conn->last_recv;
1987 1988

	if (iscsi_has_ping_timed_out(conn)) {
1989
		iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs "
1990 1991 1992 1993
				  "expired, recv timeout %d, last rx %lu, "
				  "last ping %lu, now %lu\n",
				  conn->ping_timeout, conn->recv_timeout,
				  last_recv, conn->last_ping, jiffies);
1994 1995 1996 1997 1998
		spin_unlock(&session->lock);
		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
		return;
	}

1999
	if (time_before_eq(last_recv + recv_timeout, jiffies)) {
2000
		/* send a ping to try to provoke some traffic */
2001
		ISCSI_DBG_CONN(conn, "Sending nopout as ping\n");
2002
		iscsi_send_nopout(conn, NULL);
2003
		next_timeout = conn->last_ping + (conn->ping_timeout * HZ);
2004
	} else
2005
		next_timeout = last_recv + recv_timeout;
2006

2007
	ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout);
2008
	mod_timer(&conn->transport_timer, next_timeout);
2009 2010 2011 2012
done:
	spin_unlock(&session->lock);
}

2013
static void iscsi_prep_abort_task_pdu(struct iscsi_task *task,
2014 2015 2016 2017 2018 2019
				      struct iscsi_tm *hdr)
{
	memset(hdr, 0, sizeof(*hdr));
	hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE;
	hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK;
	hdr->flags |= ISCSI_FLAG_CMD_FINAL;
2020 2021 2022
	memcpy(hdr->lun, task->lun, sizeof(hdr->lun));
	hdr->rtt = task->hdr_itt;
	hdr->refcmdsn = task->cmdsn;
2023 2024
}

M
Mike Christie 已提交
2025 2026
int iscsi_eh_abort(struct scsi_cmnd *sc)
{
2027 2028
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
2029
	struct iscsi_conn *conn;
2030
	struct iscsi_task *task;
2031 2032
	struct iscsi_tm *hdr;
	int rc, age;
M
Mike Christie 已提交
2033

2034 2035 2036
	cls_session = starget_to_session(scsi_target(sc->device));
	session = cls_session->dd_data;

2037
	ISCSI_DBG_EH(session, "aborting sc %p\n", sc);
2038

2039 2040
	mutex_lock(&session->eh_mutex);
	spin_lock_bh(&session->lock);
2041 2042 2043 2044 2045
	/*
	 * if session was ISCSI_STATE_IN_RECOVERY then we may not have
	 * got the command.
	 */
	if (!sc->SCp.ptr) {
2046 2047
		ISCSI_DBG_EH(session, "sc never reached iscsi layer or "
				      "it completed.\n");
2048 2049
		spin_unlock_bh(&session->lock);
		mutex_unlock(&session->eh_mutex);
2050 2051 2052
		return SUCCESS;
	}

M
Mike Christie 已提交
2053 2054 2055 2056
	/*
	 * If we are not logged in or we have started a new session
	 * then let the host reset code handle this
	 */
2057 2058 2059 2060
	if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN ||
	    sc->SCp.phase != session->age) {
		spin_unlock_bh(&session->lock);
		mutex_unlock(&session->eh_mutex);
2061
		ISCSI_DBG_EH(session, "failing abort due to dropped "
2062
				  "session.\n");
2063 2064 2065 2066 2067 2068 2069
		return FAILED;
	}

	conn = session->leadconn;
	conn->eh_abort_cnt++;
	age = session->age;

2070
	task = (struct iscsi_task *)sc->SCp.ptr;
2071 2072
	ISCSI_DBG_EH(session, "aborting [sc %p itt 0x%x]\n",
		     sc, task->itt);
M
Mike Christie 已提交
2073

2074 2075
	/* task completed before time out */
	if (!task->sc) {
2076
		ISCSI_DBG_EH(session, "sc completed while abort in progress\n");
2077
		goto success;
2078
	}
M
Mike Christie 已提交
2079

2080
	if (task->state == ISCSI_TASK_PENDING) {
2081
		fail_scsi_task(task, DID_ABORT);
2082 2083
		goto success;
	}
M
Mike Christie 已提交
2084

2085 2086
	/* only have one tmf outstanding at a time */
	if (conn->tmf_state != TMF_INITIAL)
M
Mike Christie 已提交
2087
		goto failed;
2088
	conn->tmf_state = TMF_QUEUED;
M
Mike Christie 已提交
2089

2090
	hdr = &conn->tmhdr;
2091
	iscsi_prep_abort_task_pdu(task, hdr);
2092

2093
	if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) {
2094 2095 2096 2097 2098 2099
		rc = FAILED;
		goto failed;
	}

	switch (conn->tmf_state) {
	case TMF_SUCCESS:
2100
		spin_unlock_bh(&session->lock);
2101 2102 2103 2104
		/*
		 * stop tx side incase the target had sent a abort rsp but
		 * the initiator was still writing out data.
		 */
2105
		iscsi_suspend_tx(conn);
2106
		/*
2107 2108 2109
		 * we do not stop the recv side because targets have been
		 * good and have never sent us a successful tmf response
		 * then sent more data for the cmd.
2110
		 */
2111
		spin_lock_bh(&session->lock);
2112
		fail_scsi_task(task, DID_ABORT);
2113
		conn->tmf_state = TMF_INITIAL;
2114
		spin_unlock_bh(&session->lock);
2115
		iscsi_start_tx(conn);
2116
		goto success_unlocked;
2117 2118 2119 2120 2121 2122 2123
	case TMF_TIMEDOUT:
		spin_unlock_bh(&session->lock);
		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
		goto failed_unlocked;
	case TMF_NOT_FOUND:
		if (!sc->SCp.ptr) {
			conn->tmf_state = TMF_INITIAL;
2124
			/* task completed before tmf abort response */
2125 2126
			ISCSI_DBG_EH(session, "sc completed while abort	in "
					      "progress\n");
2127
			goto success;
2128 2129 2130
		}
		/* fall through */
	default:
2131 2132
		conn->tmf_state = TMF_INITIAL;
		goto failed;
M
Mike Christie 已提交
2133 2134
	}

2135
success:
M
Mike Christie 已提交
2136
	spin_unlock_bh(&session->lock);
2137
success_unlocked:
2138 2139
	ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n",
		     sc, task->itt);
2140
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
2141 2142 2143 2144
	return SUCCESS;

failed:
	spin_unlock_bh(&session->lock);
2145
failed_unlocked:
2146 2147
	ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc,
		     task ? task->itt : 0);
2148
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
2149 2150 2151 2152
	return FAILED;
}
EXPORT_SYMBOL_GPL(iscsi_eh_abort);

2153 2154 2155 2156 2157 2158 2159
static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr)
{
	memset(hdr, 0, sizeof(*hdr));
	hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE;
	hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK;
	hdr->flags |= ISCSI_FLAG_CMD_FINAL;
	int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun);
2160
	hdr->rtt = RESERVED_ITT;
2161 2162 2163 2164
}

int iscsi_eh_device_reset(struct scsi_cmnd *sc)
{
2165 2166
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
2167 2168 2169 2170
	struct iscsi_conn *conn;
	struct iscsi_tm *hdr;
	int rc = FAILED;

2171 2172 2173
	cls_session = starget_to_session(scsi_target(sc->device));
	session = cls_session->dd_data;

2174
	ISCSI_DBG_EH(session, "LU Reset [sc %p lun %u]\n", sc, sc->device->lun);
2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193

	mutex_lock(&session->eh_mutex);
	spin_lock_bh(&session->lock);
	/*
	 * Just check if we are not logged in. We cannot check for
	 * the phase because the reset could come from a ioctl.
	 */
	if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN)
		goto unlock;
	conn = session->leadconn;

	/* only have one tmf outstanding at a time */
	if (conn->tmf_state != TMF_INITIAL)
		goto unlock;
	conn->tmf_state = TMF_QUEUED;

	hdr = &conn->tmhdr;
	iscsi_prep_lun_reset_pdu(sc, hdr);

2194
	if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age,
2195
				    session->lu_reset_timeout)) {
2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215
		rc = FAILED;
		goto unlock;
	}

	switch (conn->tmf_state) {
	case TMF_SUCCESS:
		break;
	case TMF_TIMEDOUT:
		spin_unlock_bh(&session->lock);
		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
		goto done;
	default:
		conn->tmf_state = TMF_INITIAL;
		goto unlock;
	}

	rc = SUCCESS;
	spin_unlock_bh(&session->lock);

	iscsi_suspend_tx(conn);
2216

2217
	spin_lock_bh(&session->lock);
2218
	fail_scsi_tasks(conn, sc->device->lun, DID_ERROR);
2219
	conn->tmf_state = TMF_INITIAL;
2220
	spin_unlock_bh(&session->lock);
2221 2222 2223 2224 2225 2226 2227

	iscsi_start_tx(conn);
	goto done;

unlock:
	spin_unlock_bh(&session->lock);
done:
2228 2229
	ISCSI_DBG_EH(session, "dev reset result = %s\n",
		     rc == SUCCESS ? "SUCCESS" : "FAILED");
2230 2231 2232 2233 2234
	mutex_unlock(&session->eh_mutex);
	return rc;
}
EXPORT_SYMBOL_GPL(iscsi_eh_device_reset);

2235 2236 2237 2238 2239 2240
/*
 * Pre-allocate a pool of @max items of @item_size. By default, the pool
 * should be accessed via kfifo_{get,put} on q->queue.
 * Optionally, the caller can obtain the array of object pointers
 * by passing in a non-NULL @items pointer
 */
M
Mike Christie 已提交
2241
int
2242
iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size)
M
Mike Christie 已提交
2243
{
2244
	int i, num_arrays = 1;
M
Mike Christie 已提交
2245

2246
	memset(q, 0, sizeof(*q));
M
Mike Christie 已提交
2247 2248

	q->max = max;
2249 2250 2251 2252 2253 2254 2255

	/* If the user passed an items pointer, he wants a copy of
	 * the array. */
	if (items)
		num_arrays++;
	q->pool = kzalloc(num_arrays * max * sizeof(void*), GFP_KERNEL);
	if (q->pool == NULL)
2256
		return -ENOMEM;
M
Mike Christie 已提交
2257 2258 2259

	q->queue = kfifo_init((void*)q->pool, max * sizeof(void*),
			      GFP_KERNEL, NULL);
2260 2261
	if (IS_ERR(q->queue)) {
		q->queue = NULL;
2262
		goto enomem;
2263
	}
M
Mike Christie 已提交
2264 2265

	for (i = 0; i < max; i++) {
2266
		q->pool[i] = kzalloc(item_size, GFP_KERNEL);
M
Mike Christie 已提交
2267
		if (q->pool[i] == NULL) {
2268 2269
			q->max = i;
			goto enomem;
M
Mike Christie 已提交
2270 2271 2272
		}
		__kfifo_put(q->queue, (void*)&q->pool[i], sizeof(void*));
	}
2273 2274 2275 2276 2277 2278

	if (items) {
		*items = q->pool + max;
		memcpy(*items, q->pool, max * sizeof(void *));
	}

M
Mike Christie 已提交
2279
	return 0;
2280 2281 2282 2283

enomem:
	iscsi_pool_free(q);
	return -ENOMEM;
M
Mike Christie 已提交
2284 2285 2286
}
EXPORT_SYMBOL_GPL(iscsi_pool_init);

2287
void iscsi_pool_free(struct iscsi_pool *q)
M
Mike Christie 已提交
2288 2289 2290 2291
{
	int i;

	for (i = 0; i < q->max; i++)
2292
		kfree(q->pool[i]);
2293
	kfree(q->pool);
2294
	kfree(q->queue);
M
Mike Christie 已提交
2295 2296 2297
}
EXPORT_SYMBOL_GPL(iscsi_pool_free);

2298 2299 2300 2301 2302 2303 2304 2305 2306 2307
/**
 * iscsi_host_add - add host to system
 * @shost: scsi host
 * @pdev: parent device
 *
 * This should be called by partial offload and software iscsi drivers
 * to add a host to the system.
 */
int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev)
{
2308 2309 2310
	if (!shost->can_queue)
		shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX;

2311 2312 2313
	if (!shost->cmd_per_lun)
		shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN;

2314 2315
	if (!shost->transportt->eh_timed_out)
		shost->transportt->eh_timed_out = iscsi_eh_cmd_timed_out;
2316 2317 2318 2319 2320 2321 2322 2323
	return scsi_add_host(shost, pdev);
}
EXPORT_SYMBOL_GPL(iscsi_host_add);

/**
 * iscsi_host_alloc - allocate a host and driver data
 * @sht: scsi host template
 * @dd_data_size: driver host data size
2324
 * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue
2325 2326 2327 2328 2329
 *
 * This should be called by partial offload and software iscsi drivers.
 * To access the driver specific memory use the iscsi_host_priv() macro.
 */
struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht,
2330
				   int dd_data_size, bool xmit_can_sleep)
2331
{
2332
	struct Scsi_Host *shost;
2333
	struct iscsi_host *ihost;
2334 2335 2336 2337

	shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size);
	if (!shost)
		return NULL;
2338
	ihost = shost_priv(shost);
2339 2340 2341 2342 2343 2344 2345 2346 2347

	if (xmit_can_sleep) {
		snprintf(ihost->workq_name, sizeof(ihost->workq_name),
			"iscsi_q_%d", shost->host_no);
		ihost->workq = create_singlethread_workqueue(ihost->workq_name);
		if (!ihost->workq)
			goto free_host;
	}

2348 2349 2350 2351
	spin_lock_init(&ihost->lock);
	ihost->state = ISCSI_HOST_SETUP;
	ihost->num_sessions = 0;
	init_waitqueue_head(&ihost->session_removal_wq);
2352
	return shost;
2353 2354 2355 2356

free_host:
	scsi_host_put(shost);
	return NULL;
2357 2358 2359
}
EXPORT_SYMBOL_GPL(iscsi_host_alloc);

2360 2361
static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session)
{
2362
	iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST);
2363 2364
}

2365 2366 2367 2368
/**
 * iscsi_host_remove - remove host and sessions
 * @shost: scsi host
 *
2369 2370
 * If there are any sessions left, this will initiate the removal and wait
 * for the completion.
2371 2372 2373
 */
void iscsi_host_remove(struct Scsi_Host *shost)
{
2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386
	struct iscsi_host *ihost = shost_priv(shost);
	unsigned long flags;

	spin_lock_irqsave(&ihost->lock, flags);
	ihost->state = ISCSI_HOST_REMOVED;
	spin_unlock_irqrestore(&ihost->lock, flags);

	iscsi_host_for_each_session(shost, iscsi_notify_host_removed);
	wait_event_interruptible(ihost->session_removal_wq,
				 ihost->num_sessions == 0);
	if (signal_pending(current))
		flush_signals(current);

2387
	scsi_remove_host(shost);
2388 2389
	if (ihost->workq)
		destroy_workqueue(ihost->workq);
2390
}
2391
EXPORT_SYMBOL_GPL(iscsi_host_remove);
M
Mike Christie 已提交
2392

2393
void iscsi_host_free(struct Scsi_Host *shost)
2394 2395
{
	struct iscsi_host *ihost = shost_priv(shost);
M
Mike Christie 已提交
2396

2397 2398 2399
	kfree(ihost->netdev);
	kfree(ihost->hwaddress);
	kfree(ihost->initiatorname);
2400
	scsi_host_put(shost);
2401
}
2402
EXPORT_SYMBOL_GPL(iscsi_host_free);
M
Mike Christie 已提交
2403

2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424
static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost)
{
	struct iscsi_host *ihost = shost_priv(shost);
	unsigned long flags;

	shost = scsi_host_get(shost);
	if (!shost) {
		printk(KERN_ERR "Invalid state. Cannot notify host removal "
		      "of session teardown event because host already "
		      "removed.\n");
		return;
	}

	spin_lock_irqsave(&ihost->lock, flags);
	ihost->num_sessions--;
	if (ihost->num_sessions == 0)
		wake_up(&ihost->session_removal_wq);
	spin_unlock_irqrestore(&ihost->lock, flags);
	scsi_host_put(shost);
}

M
Mike Christie 已提交
2425 2426 2427
/**
 * iscsi_session_setup - create iscsi cls session and host and session
 * @iscsit: iscsi transport template
2428 2429
 * @shost: scsi host
 * @cmds_max: session can queue
2430
 * @cmd_task_size: LLD task private data size
M
Mike Christie 已提交
2431 2432 2433 2434
 * @initial_cmdsn: initial CmdSN
 *
 * This can be used by software iscsi_transports that allocate
 * a session per scsi host.
2435 2436 2437 2438
 *
 * Callers should set cmds_max to the largest total numer (mgmt + scsi) of
 * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks
 * for nop handling and login/logout requests.
2439
 */
M
Mike Christie 已提交
2440
struct iscsi_cls_session *
2441
iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost,
2442
		    uint16_t cmds_max, int dd_size, int cmd_task_size,
2443
		    uint32_t initial_cmdsn, unsigned int id)
M
Mike Christie 已提交
2444
{
2445
	struct iscsi_host *ihost = shost_priv(shost);
M
Mike Christie 已提交
2446 2447
	struct iscsi_session *session;
	struct iscsi_cls_session *cls_session;
2448
	int cmd_i, scsi_cmds, total_cmds = cmds_max;
2449 2450 2451 2452 2453 2454 2455 2456 2457
	unsigned long flags;

	spin_lock_irqsave(&ihost->lock, flags);
	if (ihost->state == ISCSI_HOST_REMOVED) {
		spin_unlock_irqrestore(&ihost->lock, flags);
		return NULL;
	}
	ihost->num_sessions++;
	spin_unlock_irqrestore(&ihost->lock, flags);
2458 2459 2460

	if (!total_cmds)
		total_cmds = ISCSI_DEF_XMIT_CMDS_MAX;
2461
	/*
2462 2463 2464
	 * The iscsi layer needs some tasks for nop handling and tmfs,
	 * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX
	 * + 1 command for scsi IO.
2465
	 */
2466 2467 2468 2469
	if (total_cmds < ISCSI_TOTAL_CMDS_MIN) {
		printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue "
		       "must be a power of two that is at least %d.\n",
		       total_cmds, ISCSI_TOTAL_CMDS_MIN);
2470
		goto dec_session_count;
2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487
	}

	if (total_cmds > ISCSI_TOTAL_CMDS_MAX) {
		printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue "
		       "must be a power of 2 less than or equal to %d.\n",
		       cmds_max, ISCSI_TOTAL_CMDS_MAX);
		total_cmds = ISCSI_TOTAL_CMDS_MAX;
	}

	if (!is_power_of_2(total_cmds)) {
		printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue "
		       "must be a power of 2.\n", total_cmds);
		total_cmds = rounddown_pow_of_two(total_cmds);
		if (total_cmds < ISCSI_TOTAL_CMDS_MIN)
			return NULL;
		printk(KERN_INFO "iscsi: Rounding can_queue to %d.\n",
		       total_cmds);
2488
	}
2489
	scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX;
2490

2491
	cls_session = iscsi_alloc_session(shost, iscsit,
2492 2493
					  sizeof(struct iscsi_session) +
					  dd_size);
2494
	if (!cls_session)
2495
		goto dec_session_count;
2496 2497
	session = cls_session->dd_data;
	session->cls_session = cls_session;
M
Mike Christie 已提交
2498 2499
	session->host = shost;
	session->state = ISCSI_STATE_FREE;
2500
	session->fast_abort = 1;
2501 2502
	session->lu_reset_timeout = 15;
	session->abort_timeout = 10;
2503 2504
	session->scsi_cmds_max = scsi_cmds;
	session->cmds_max = total_cmds;
2505
	session->queued_cmdsn = session->cmdsn = initial_cmdsn;
M
Mike Christie 已提交
2506 2507 2508 2509
	session->exp_cmdsn = initial_cmdsn + 1;
	session->max_cmdsn = initial_cmdsn + 1;
	session->max_r2t = 1;
	session->tt = iscsit;
2510
	session->dd_data = cls_session->dd_data + sizeof(*session);
2511
	mutex_init(&session->eh_mutex);
2512
	spin_lock_init(&session->lock);
M
Mike Christie 已提交
2513 2514 2515 2516

	/* initialize SCSI PDU commands pool */
	if (iscsi_pool_init(&session->cmdpool, session->cmds_max,
			    (void***)&session->cmds,
2517
			    cmd_task_size + sizeof(struct iscsi_task)))
M
Mike Christie 已提交
2518 2519 2520 2521
		goto cmdpool_alloc_fail;

	/* pre-format cmds pool with ITT */
	for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) {
2522
		struct iscsi_task *task = session->cmds[cmd_i];
M
Mike Christie 已提交
2523

2524 2525 2526
		if (cmd_task_size)
			task->dd_data = &task[1];
		task->itt = cmd_i;
2527
		task->state = ISCSI_TASK_FREE;
2528
		INIT_LIST_HEAD(&task->running);
M
Mike Christie 已提交
2529 2530
	}

2531
	if (!try_module_get(iscsit->owner))
2532
		goto module_get_fail;
M
Mike Christie 已提交
2533

2534
	if (iscsi_add_session(cls_session, id))
2535
		goto cls_session_fail;
2536

M
Mike Christie 已提交
2537 2538 2539
	return cls_session;

cls_session_fail:
2540 2541
	module_put(iscsit->owner);
module_get_fail:
2542
	iscsi_pool_free(&session->cmdpool);
M
Mike Christie 已提交
2543
cmdpool_alloc_fail:
2544
	iscsi_free_session(cls_session);
2545 2546
dec_session_count:
	iscsi_host_dec_session_cnt(shost);
M
Mike Christie 已提交
2547 2548 2549 2550 2551 2552
	return NULL;
}
EXPORT_SYMBOL_GPL(iscsi_session_setup);

/**
 * iscsi_session_teardown - destroy session, host, and cls_session
2553
 * @cls_session: iscsi session
M
Mike Christie 已提交
2554
 *
2555 2556 2557
 * The driver must have called iscsi_remove_session before
 * calling this.
 */
M
Mike Christie 已提交
2558 2559
void iscsi_session_teardown(struct iscsi_cls_session *cls_session)
{
2560
	struct iscsi_session *session = cls_session->dd_data;
2561
	struct module *owner = cls_session->transport->owner;
2562
	struct Scsi_Host *shost = session->host;
M
Mike Christie 已提交
2563

2564
	iscsi_pool_free(&session->cmdpool);
M
Mike Christie 已提交
2565

2566 2567 2568 2569
	kfree(session->password);
	kfree(session->password_in);
	kfree(session->username);
	kfree(session->username_in);
2570
	kfree(session->targetname);
2571 2572
	kfree(session->initiatorname);
	kfree(session->ifacename);
2573

2574
	iscsi_destroy_session(cls_session);
2575
	iscsi_host_dec_session_cnt(shost);
2576
	module_put(owner);
M
Mike Christie 已提交
2577 2578 2579 2580 2581 2582
}
EXPORT_SYMBOL_GPL(iscsi_session_teardown);

/**
 * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn
 * @cls_session: iscsi_cls_session
2583
 * @dd_size: private driver data size
M
Mike Christie 已提交
2584
 * @conn_idx: cid
2585
 */
M
Mike Christie 已提交
2586
struct iscsi_cls_conn *
2587 2588
iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
		 uint32_t conn_idx)
M
Mike Christie 已提交
2589
{
2590
	struct iscsi_session *session = cls_session->dd_data;
M
Mike Christie 已提交
2591 2592
	struct iscsi_conn *conn;
	struct iscsi_cls_conn *cls_conn;
2593
	char *data;
M
Mike Christie 已提交
2594

2595 2596
	cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size,
				     conn_idx);
M
Mike Christie 已提交
2597 2598 2599
	if (!cls_conn)
		return NULL;
	conn = cls_conn->dd_data;
2600
	memset(conn, 0, sizeof(*conn) + dd_size);
M
Mike Christie 已提交
2601

2602
	conn->dd_data = cls_conn->dd_data + sizeof(*conn);
M
Mike Christie 已提交
2603 2604 2605 2606 2607
	conn->session = session;
	conn->cls_conn = cls_conn;
	conn->c_stage = ISCSI_CONN_INITIAL_STAGE;
	conn->id = conn_idx;
	conn->exp_statsn = 0;
2608
	conn->tmf_state = TMF_INITIAL;
2609 2610 2611 2612 2613

	init_timer(&conn->transport_timer);
	conn->transport_timer.data = (unsigned long)conn;
	conn->transport_timer.function = iscsi_check_transport_timeouts;

2614
	INIT_LIST_HEAD(&conn->mgmtqueue);
2615
	INIT_LIST_HEAD(&conn->cmdqueue);
2616
	INIT_LIST_HEAD(&conn->requeue);
D
David Howells 已提交
2617
	INIT_WORK(&conn->xmitwork, iscsi_xmitworker);
M
Mike Christie 已提交
2618

2619
	/* allocate login_task used for the login/text sequences */
M
Mike Christie 已提交
2620
	spin_lock_bh(&session->lock);
2621
	if (!__kfifo_get(session->cmdpool.queue,
2622
                         (void*)&conn->login_task,
M
Mike Christie 已提交
2623 2624
			 sizeof(void*))) {
		spin_unlock_bh(&session->lock);
2625
		goto login_task_alloc_fail;
M
Mike Christie 已提交
2626 2627 2628
	}
	spin_unlock_bh(&session->lock);

2629 2630
	data = (char *) __get_free_pages(GFP_KERNEL,
					 get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
2631
	if (!data)
2632 2633
		goto login_task_data_alloc_fail;
	conn->login_task->data = conn->data = data;
2634

2635
	init_timer(&conn->tmf_timer);
M
Mike Christie 已提交
2636 2637 2638 2639
	init_waitqueue_head(&conn->ehwait);

	return cls_conn;

2640 2641
login_task_data_alloc_fail:
	__kfifo_put(session->cmdpool.queue, (void*)&conn->login_task,
2642
		    sizeof(void*));
2643
login_task_alloc_fail:
M
Mike Christie 已提交
2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661
	iscsi_destroy_conn(cls_conn);
	return NULL;
}
EXPORT_SYMBOL_GPL(iscsi_conn_setup);

/**
 * iscsi_conn_teardown - teardown iscsi connection
 * cls_conn: iscsi class connection
 *
 * TODO: we may need to make this into a two step process
 * like scsi-mls remove + put host
 */
void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn)
{
	struct iscsi_conn *conn = cls_conn->dd_data;
	struct iscsi_session *session = conn->session;
	unsigned long flags;

2662 2663
	del_timer_sync(&conn->transport_timer);

M
Mike Christie 已提交
2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686
	spin_lock_bh(&session->lock);
	conn->c_stage = ISCSI_CONN_CLEANUP_WAIT;
	if (session->leadconn == conn) {
		/*
		 * leading connection? then give up on recovery.
		 */
		session->state = ISCSI_STATE_TERMINATE;
		wake_up(&conn->ehwait);
	}
	spin_unlock_bh(&session->lock);

	/*
	 * Block until all in-progress commands for this connection
	 * time out or fail.
	 */
	for (;;) {
		spin_lock_irqsave(session->host->host_lock, flags);
		if (!session->host->host_busy) { /* OK for ERL == 0 */
			spin_unlock_irqrestore(session->host->host_lock, flags);
			break;
		}
		spin_unlock_irqrestore(session->host->host_lock, flags);
		msleep_interruptible(500);
2687 2688 2689 2690
		iscsi_conn_printk(KERN_INFO, conn, "iscsi conn_destroy(): "
				  "host_busy %d host_failed %d\n",
				  session->host->host_busy,
				  session->host->host_failed);
M
Mike Christie 已提交
2691 2692 2693 2694 2695 2696
		/*
		 * force eh_abort() to unblock
		 */
		wake_up(&conn->ehwait);
	}

2697
	/* flush queued up work because we free the connection below */
2698
	iscsi_suspend_tx(conn);
2699

M
Mike Christie 已提交
2700
	spin_lock_bh(&session->lock);
2701 2702
	free_pages((unsigned long) conn->data,
		   get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
2703
	kfree(conn->persistent_address);
2704
	__kfifo_put(session->cmdpool.queue, (void*)&conn->login_task,
M
Mike Christie 已提交
2705
		    sizeof(void*));
2706
	if (session->leadconn == conn)
M
Mike Christie 已提交
2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718
		session->leadconn = NULL;
	spin_unlock_bh(&session->lock);

	iscsi_destroy_conn(cls_conn);
}
EXPORT_SYMBOL_GPL(iscsi_conn_teardown);

int iscsi_conn_start(struct iscsi_cls_conn *cls_conn)
{
	struct iscsi_conn *conn = cls_conn->dd_data;
	struct iscsi_session *session = conn->session;

2719
	if (!session) {
2720 2721
		iscsi_conn_printk(KERN_ERR, conn,
				  "can't start unbound connection\n");
M
Mike Christie 已提交
2722 2723 2724
		return -EPERM;
	}

2725 2726
	if ((session->imm_data_en || !session->initial_r2t_en) &&
	     session->first_burst > session->max_burst) {
2727 2728 2729
		iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: "
				  "first_burst %d max_burst %d\n",
				  session->first_burst, session->max_burst);
2730 2731 2732
		return -EINVAL;
	}

2733
	if (conn->ping_timeout && !conn->recv_timeout) {
2734 2735
		iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of "
				  "zero. Using 5 seconds\n.");
2736 2737 2738 2739
		conn->recv_timeout = 5;
	}

	if (conn->recv_timeout && !conn->ping_timeout) {
2740 2741
		iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of "
				  "zero. Using 5 seconds.\n");
2742 2743 2744
		conn->ping_timeout = 5;
	}

M
Mike Christie 已提交
2745 2746 2747
	spin_lock_bh(&session->lock);
	conn->c_stage = ISCSI_CONN_STARTED;
	session->state = ISCSI_STATE_LOGGED_IN;
2748
	session->queued_cmdsn = session->cmdsn;
M
Mike Christie 已提交
2749

2750 2751 2752 2753 2754 2755
	conn->last_recv = jiffies;
	conn->last_ping = jiffies;
	if (conn->recv_timeout && conn->ping_timeout)
		mod_timer(&conn->transport_timer,
			  jiffies + (conn->recv_timeout * HZ));

M
Mike Christie 已提交
2756 2757 2758 2759 2760 2761 2762
	switch(conn->stop_stage) {
	case STOP_CONN_RECOVER:
		/*
		 * unblock eh_abort() if it is blocked. re-try all
		 * commands after successful recovery
		 */
		conn->stop_stage = 0;
2763
		conn->tmf_state = TMF_INITIAL;
M
Mike Christie 已提交
2764
		session->age++;
2765 2766
		if (session->age == 16)
			session->age = 0;
2767
		break;
M
Mike Christie 已提交
2768 2769 2770 2771 2772 2773 2774 2775
	case STOP_CONN_TERM:
		conn->stop_stage = 0;
		break;
	default:
		break;
	}
	spin_unlock_bh(&session->lock);

2776
	iscsi_unblock_session(session->cls_session);
2777
	wake_up(&conn->ehwait);
M
Mike Christie 已提交
2778 2779 2780 2781 2782
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_conn_start);

static void
2783
fail_mgmt_tasks(struct iscsi_session *session, struct iscsi_conn *conn)
M
Mike Christie 已提交
2784
{
2785
	struct iscsi_task *task;
2786
	int i, state;
M
Mike Christie 已提交
2787

2788 2789 2790 2791
	for (i = 0; i < conn->session->cmds_max; i++) {
		task = conn->session->cmds[i];
		if (task->sc)
			continue;
M
Mike Christie 已提交
2792

2793 2794
		if (task->state == ISCSI_TASK_FREE)
			continue;
M
Mike Christie 已提交
2795

2796 2797 2798
		ISCSI_DBG_SESSION(conn->session,
				  "failing mgmt itt 0x%x state %d\n",
				  task->itt, task->state);
2799 2800 2801 2802 2803
		state = ISCSI_TASK_ABRT_SESS_RECOV;
		if (task->state == ISCSI_TASK_PENDING)
			state = ISCSI_TASK_COMPLETED;
		iscsi_complete_task(task, state);

2804
	}
M
Mike Christie 已提交
2805 2806
}

2807 2808
static void iscsi_start_session_recovery(struct iscsi_session *session,
					 struct iscsi_conn *conn, int flag)
M
Mike Christie 已提交
2809
{
2810 2811
	int old_stop_stage;

2812
	mutex_lock(&session->eh_mutex);
M
Mike Christie 已提交
2813
	spin_lock_bh(&session->lock);
2814
	if (conn->stop_stage == STOP_CONN_TERM) {
M
Mike Christie 已提交
2815
		spin_unlock_bh(&session->lock);
2816 2817 2818 2819
		mutex_unlock(&session->eh_mutex);
		return;
	}

2820 2821
	/*
	 * When this is called for the in_login state, we only want to clean
2822
	 * up the login task and connection. We do not need to block and set
2823
	 * the recovery state again
2824
	 */
2825 2826 2827 2828
	if (flag == STOP_CONN_TERM)
		session->state = ISCSI_STATE_TERMINATE;
	else if (conn->stop_stage != STOP_CONN_RECOVER)
		session->state = ISCSI_STATE_IN_RECOVERY;
2829
	spin_unlock_bh(&session->lock);
2830

2831 2832 2833 2834
	del_timer_sync(&conn->transport_timer);
	iscsi_suspend_tx(conn);

	spin_lock_bh(&session->lock);
2835
	old_stop_stage = conn->stop_stage;
M
Mike Christie 已提交
2836
	conn->stop_stage = flag;
2837
	conn->c_stage = ISCSI_CONN_STOPPED;
M
Mike Christie 已提交
2838
	spin_unlock_bh(&session->lock);
2839

M
Mike Christie 已提交
2840 2841 2842 2843 2844 2845 2846 2847 2848
	/*
	 * for connection level recovery we should not calculate
	 * header digest. conn->hdr_size used for optimization
	 * in hdr_extract() and will be re-negotiated at
	 * set_param() time.
	 */
	if (flag == STOP_CONN_RECOVER) {
		conn->hdrdgst_en = 0;
		conn->datadgst_en = 0;
2849
		if (session->state == ISCSI_STATE_IN_RECOVERY &&
2850
		    old_stop_stage != STOP_CONN_RECOVER) {
2851
			ISCSI_DBG_SESSION(session, "blocking session\n");
2852
			iscsi_block_session(session->cls_session);
2853
		}
M
Mike Christie 已提交
2854
	}
2855 2856 2857 2858 2859

	/*
	 * flush queues.
	 */
	spin_lock_bh(&session->lock);
2860
	fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED);
2861
	fail_mgmt_tasks(session, conn);
2862
	spin_unlock_bh(&session->lock);
2863
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874
}

void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)
{
	struct iscsi_conn *conn = cls_conn->dd_data;
	struct iscsi_session *session = conn->session;

	switch (flag) {
	case STOP_CONN_RECOVER:
	case STOP_CONN_TERM:
		iscsi_start_session_recovery(session, conn, flag);
2875
		break;
M
Mike Christie 已提交
2876
	default:
2877 2878
		iscsi_conn_printk(KERN_ERR, conn,
				  "invalid stop flag %d\n", flag);
M
Mike Christie 已提交
2879 2880 2881 2882 2883 2884 2885
	}
}
EXPORT_SYMBOL_GPL(iscsi_conn_stop);

int iscsi_conn_bind(struct iscsi_cls_session *cls_session,
		    struct iscsi_cls_conn *cls_conn, int is_leading)
{
2886
	struct iscsi_session *session = cls_session->dd_data;
2887
	struct iscsi_conn *conn = cls_conn->dd_data;
M
Mike Christie 已提交
2888 2889 2890 2891

	spin_lock_bh(&session->lock);
	if (is_leading)
		session->leadconn = conn;
2892
	spin_unlock_bh(&session->lock);
M
Mike Christie 已提交
2893 2894 2895 2896 2897 2898 2899 2900 2901 2902

	/*
	 * Unblock xmitworker(), Login Phase will pass through.
	 */
	clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
	clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_conn_bind);

2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919
static int iscsi_switch_str_param(char **param, char *new_val_buf)
{
	char *new_val;

	if (*param) {
		if (!strcmp(*param, new_val_buf))
			return 0;
	}

	new_val = kstrdup(new_val_buf, GFP_NOIO);
	if (!new_val)
		return -ENOMEM;

	kfree(*param);
	*param = new_val;
	return 0;
}
2920 2921 2922 2923 2924 2925 2926 2927 2928

int iscsi_set_param(struct iscsi_cls_conn *cls_conn,
		    enum iscsi_param param, char *buf, int buflen)
{
	struct iscsi_conn *conn = cls_conn->dd_data;
	struct iscsi_session *session = conn->session;
	uint32_t value;

	switch(param) {
2929 2930 2931
	case ISCSI_PARAM_FAST_ABORT:
		sscanf(buf, "%d", &session->fast_abort);
		break;
2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943
	case ISCSI_PARAM_ABORT_TMO:
		sscanf(buf, "%d", &session->abort_timeout);
		break;
	case ISCSI_PARAM_LU_RESET_TMO:
		sscanf(buf, "%d", &session->lu_reset_timeout);
		break;
	case ISCSI_PARAM_PING_TMO:
		sscanf(buf, "%d", &conn->ping_timeout);
		break;
	case ISCSI_PARAM_RECV_TMO:
		sscanf(buf, "%d", &conn->recv_timeout);
		break;
2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990
	case ISCSI_PARAM_MAX_RECV_DLENGTH:
		sscanf(buf, "%d", &conn->max_recv_dlength);
		break;
	case ISCSI_PARAM_MAX_XMIT_DLENGTH:
		sscanf(buf, "%d", &conn->max_xmit_dlength);
		break;
	case ISCSI_PARAM_HDRDGST_EN:
		sscanf(buf, "%d", &conn->hdrdgst_en);
		break;
	case ISCSI_PARAM_DATADGST_EN:
		sscanf(buf, "%d", &conn->datadgst_en);
		break;
	case ISCSI_PARAM_INITIAL_R2T_EN:
		sscanf(buf, "%d", &session->initial_r2t_en);
		break;
	case ISCSI_PARAM_MAX_R2T:
		sscanf(buf, "%d", &session->max_r2t);
		break;
	case ISCSI_PARAM_IMM_DATA_EN:
		sscanf(buf, "%d", &session->imm_data_en);
		break;
	case ISCSI_PARAM_FIRST_BURST:
		sscanf(buf, "%d", &session->first_burst);
		break;
	case ISCSI_PARAM_MAX_BURST:
		sscanf(buf, "%d", &session->max_burst);
		break;
	case ISCSI_PARAM_PDU_INORDER_EN:
		sscanf(buf, "%d", &session->pdu_inorder_en);
		break;
	case ISCSI_PARAM_DATASEQ_INORDER_EN:
		sscanf(buf, "%d", &session->dataseq_inorder_en);
		break;
	case ISCSI_PARAM_ERL:
		sscanf(buf, "%d", &session->erl);
		break;
	case ISCSI_PARAM_IFMARKER_EN:
		sscanf(buf, "%d", &value);
		BUG_ON(value);
		break;
	case ISCSI_PARAM_OFMARKER_EN:
		sscanf(buf, "%d", &value);
		BUG_ON(value);
		break;
	case ISCSI_PARAM_EXP_STATSN:
		sscanf(buf, "%u", &conn->exp_statsn);
		break;
2991
	case ISCSI_PARAM_USERNAME:
2992
		return iscsi_switch_str_param(&session->username, buf);
2993
	case ISCSI_PARAM_USERNAME_IN:
2994
		return iscsi_switch_str_param(&session->username_in, buf);
2995
	case ISCSI_PARAM_PASSWORD:
2996
		return iscsi_switch_str_param(&session->password, buf);
2997
	case ISCSI_PARAM_PASSWORD_IN:
2998
		return iscsi_switch_str_param(&session->password_in, buf);
2999
	case ISCSI_PARAM_TARGET_NAME:
3000
		return iscsi_switch_str_param(&session->targetname, buf);
3001 3002 3003 3004 3005 3006 3007
	case ISCSI_PARAM_TPGT:
		sscanf(buf, "%d", &session->tpgt);
		break;
	case ISCSI_PARAM_PERSISTENT_PORT:
		sscanf(buf, "%d", &conn->persistent_port);
		break;
	case ISCSI_PARAM_PERSISTENT_ADDRESS:
3008
		return iscsi_switch_str_param(&conn->persistent_address, buf);
3009
	case ISCSI_PARAM_IFACE_NAME:
3010
		return iscsi_switch_str_param(&session->ifacename, buf);
3011
	case ISCSI_PARAM_INITIATOR_NAME:
3012
		return iscsi_switch_str_param(&session->initiatorname, buf);
3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023
	default:
		return -ENOSYS;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_set_param);

int iscsi_session_get_param(struct iscsi_cls_session *cls_session,
			    enum iscsi_param param, char *buf)
{
3024
	struct iscsi_session *session = cls_session->dd_data;
3025 3026 3027
	int len;

	switch(param) {
3028 3029 3030
	case ISCSI_PARAM_FAST_ABORT:
		len = sprintf(buf, "%d\n", session->fast_abort);
		break;
3031 3032 3033 3034 3035 3036
	case ISCSI_PARAM_ABORT_TMO:
		len = sprintf(buf, "%d\n", session->abort_timeout);
		break;
	case ISCSI_PARAM_LU_RESET_TMO:
		len = sprintf(buf, "%d\n", session->lu_reset_timeout);
		break;
3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066
	case ISCSI_PARAM_INITIAL_R2T_EN:
		len = sprintf(buf, "%d\n", session->initial_r2t_en);
		break;
	case ISCSI_PARAM_MAX_R2T:
		len = sprintf(buf, "%hu\n", session->max_r2t);
		break;
	case ISCSI_PARAM_IMM_DATA_EN:
		len = sprintf(buf, "%d\n", session->imm_data_en);
		break;
	case ISCSI_PARAM_FIRST_BURST:
		len = sprintf(buf, "%u\n", session->first_burst);
		break;
	case ISCSI_PARAM_MAX_BURST:
		len = sprintf(buf, "%u\n", session->max_burst);
		break;
	case ISCSI_PARAM_PDU_INORDER_EN:
		len = sprintf(buf, "%d\n", session->pdu_inorder_en);
		break;
	case ISCSI_PARAM_DATASEQ_INORDER_EN:
		len = sprintf(buf, "%d\n", session->dataseq_inorder_en);
		break;
	case ISCSI_PARAM_ERL:
		len = sprintf(buf, "%d\n", session->erl);
		break;
	case ISCSI_PARAM_TARGET_NAME:
		len = sprintf(buf, "%s\n", session->targetname);
		break;
	case ISCSI_PARAM_TPGT:
		len = sprintf(buf, "%d\n", session->tpgt);
		break;
3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078
	case ISCSI_PARAM_USERNAME:
		len = sprintf(buf, "%s\n", session->username);
		break;
	case ISCSI_PARAM_USERNAME_IN:
		len = sprintf(buf, "%s\n", session->username_in);
		break;
	case ISCSI_PARAM_PASSWORD:
		len = sprintf(buf, "%s\n", session->password);
		break;
	case ISCSI_PARAM_PASSWORD_IN:
		len = sprintf(buf, "%s\n", session->password_in);
		break;
3079 3080 3081 3082
	case ISCSI_PARAM_IFACE_NAME:
		len = sprintf(buf, "%s\n", session->ifacename);
		break;
	case ISCSI_PARAM_INITIATOR_NAME:
3083
		len = sprintf(buf, "%s\n", session->initiatorname);
3084
		break;
3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099
	default:
		return -ENOSYS;
	}

	return len;
}
EXPORT_SYMBOL_GPL(iscsi_session_get_param);

int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn,
			 enum iscsi_param param, char *buf)
{
	struct iscsi_conn *conn = cls_conn->dd_data;
	int len;

	switch(param) {
3100 3101 3102 3103 3104 3105
	case ISCSI_PARAM_PING_TMO:
		len = sprintf(buf, "%u\n", conn->ping_timeout);
		break;
	case ISCSI_PARAM_RECV_TMO:
		len = sprintf(buf, "%u\n", conn->recv_timeout);
		break;
3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140
	case ISCSI_PARAM_MAX_RECV_DLENGTH:
		len = sprintf(buf, "%u\n", conn->max_recv_dlength);
		break;
	case ISCSI_PARAM_MAX_XMIT_DLENGTH:
		len = sprintf(buf, "%u\n", conn->max_xmit_dlength);
		break;
	case ISCSI_PARAM_HDRDGST_EN:
		len = sprintf(buf, "%d\n", conn->hdrdgst_en);
		break;
	case ISCSI_PARAM_DATADGST_EN:
		len = sprintf(buf, "%d\n", conn->datadgst_en);
		break;
	case ISCSI_PARAM_IFMARKER_EN:
		len = sprintf(buf, "%d\n", conn->ifmarker_en);
		break;
	case ISCSI_PARAM_OFMARKER_EN:
		len = sprintf(buf, "%d\n", conn->ofmarker_en);
		break;
	case ISCSI_PARAM_EXP_STATSN:
		len = sprintf(buf, "%u\n", conn->exp_statsn);
		break;
	case ISCSI_PARAM_PERSISTENT_PORT:
		len = sprintf(buf, "%d\n", conn->persistent_port);
		break;
	case ISCSI_PARAM_PERSISTENT_ADDRESS:
		len = sprintf(buf, "%s\n", conn->persistent_address);
		break;
	default:
		return -ENOSYS;
	}

	return len;
}
EXPORT_SYMBOL_GPL(iscsi_conn_get_param);

3141 3142 3143
int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param,
			 char *buf)
{
3144
	struct iscsi_host *ihost = shost_priv(shost);
3145 3146 3147
	int len;

	switch (param) {
3148
	case ISCSI_HOST_PARAM_NETDEV_NAME:
3149
		len = sprintf(buf, "%s\n", ihost->netdev);
3150
		break;
3151
	case ISCSI_HOST_PARAM_HWADDRESS:
3152
		len = sprintf(buf, "%s\n", ihost->hwaddress);
3153
		break;
3154
	case ISCSI_HOST_PARAM_INITIATOR_NAME:
3155
		len = sprintf(buf, "%s\n", ihost->initiatorname);
3156
		break;
3157
	case ISCSI_HOST_PARAM_IPADDRESS:
3158
		len = sprintf(buf, "%s\n", ihost->local_address);
3159
		break;
3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170
	default:
		return -ENOSYS;
	}

	return len;
}
EXPORT_SYMBOL_GPL(iscsi_host_get_param);

int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param,
			 char *buf, int buflen)
{
3171
	struct iscsi_host *ihost = shost_priv(shost);
3172 3173

	switch (param) {
3174
	case ISCSI_HOST_PARAM_NETDEV_NAME:
3175
		return iscsi_switch_str_param(&ihost->netdev, buf);
3176
	case ISCSI_HOST_PARAM_HWADDRESS:
3177
		return iscsi_switch_str_param(&ihost->hwaddress, buf);
3178
	case ISCSI_HOST_PARAM_INITIATOR_NAME:
3179
		return iscsi_switch_str_param(&ihost->initiatorname, buf);
3180 3181 3182 3183 3184 3185 3186 3187
	default:
		return -ENOSYS;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_host_set_param);

M
Mike Christie 已提交
3188 3189 3190
MODULE_AUTHOR("Mike Christie");
MODULE_DESCRIPTION("iSCSI library functions");
MODULE_LICENSE("GPL");