libiscsi.c 96.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 <linux/slab.h>
29
#include <linux/module.h>
30
#include <asm/unaligned.h>
M
Mike Christie 已提交
31 32 33 34 35 36 37 38 39 40 41 42
#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>

43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
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.");
63 64 65

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

#define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...)			\
	do {								\
74 75 76 77 78 79 80 81 82
		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)					\
83 84 85 86 87
			iscsi_session_printk(KERN_INFO, _session,	\
					     "%s " dbg_fmt,		\
					     __func__, ##arg);		\
	} while (0);

88 89 90 91 92
inline void iscsi_conn_queue_work(struct iscsi_conn *conn)
{
	struct Scsi_Host *shost = conn->session->host;
	struct iscsi_host *ihost = shost_priv(shost);

93 94
	if (ihost->workq)
		queue_work(ihost->workq, &conn->xmitwork);
95 96 97
}
EXPORT_SYMBOL_GPL(iscsi_conn_queue_work);

98 99
static void __iscsi_update_cmdsn(struct iscsi_session *session,
				 uint32_t exp_cmdsn, uint32_t max_cmdsn)
M
Mike Christie 已提交
100
{
101 102 103 104 105 106 107 108 109
	/*
	 * 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 已提交
110 111
		session->exp_cmdsn = exp_cmdsn;

112
	if (max_cmdsn != session->max_cmdsn &&
113
	    !iscsi_sna_lt(max_cmdsn, session->max_cmdsn))
114
		session->max_cmdsn = max_cmdsn;
M
Mike Christie 已提交
115
}
116 117 118 119 120 121

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));
}
122
EXPORT_SYMBOL_GPL(iscsi_update_cmdsn);
M
Mike Christie 已提交
123

124 125 126 127 128 129 130 131 132 133 134 135 136 137
/**
 * 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 已提交
138
{
139
	struct iscsi_conn *conn = task->conn;
140 141 142
	unsigned int left = r2t->data_length - r2t->sent;

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

	memset(hdr, 0, sizeof(struct iscsi_data));
145 146 147
	hdr->ttt = r2t->ttt;
	hdr->datasn = cpu_to_be32(r2t->datasn);
	r2t->datasn++;
M
Mike Christie 已提交
148
	hdr->opcode = ISCSI_OP_SCSI_DATA_OUT;
149
	hdr->lun = task->lun;
150 151 152 153
	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 已提交
154
		hton24(hdr->dlength, conn->max_xmit_dlength);
155
		r2t->data_count = conn->max_xmit_dlength;
M
Mike Christie 已提交
156 157
		hdr->flags = 0;
	} else {
158 159
		hton24(hdr->dlength, left);
		r2t->data_count = left;
M
Mike Christie 已提交
160 161
		hdr->flags = ISCSI_FLAG_CMD_FINAL;
	}
162
	conn->dataout_pdus_cnt++;
M
Mike Christie 已提交
163
}
164
EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu);
M
Mike Christie 已提交
165

166
static int iscsi_add_hdr(struct iscsi_task *task, unsigned len)
167
{
168
	unsigned exp_len = task->hdr_len + len;
169

170
	if (exp_len > task->hdr_max) {
171 172 173 174 175
		WARN_ON(1);
		return -EINVAL;
	}

	WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */
176
	task->hdr_len = exp_len;
177 178 179
	return 0;
}

180 181 182
/*
 * make an extended cdb AHS
 */
183
static int iscsi_prep_ecdb_ahs(struct iscsi_task *task)
184
{
185
	struct scsi_cmnd *cmd = task->sc;
186 187 188 189 190
	unsigned rlen, pad_len;
	unsigned short ahslength;
	struct iscsi_ecdb_ahdr *ecdb_ahdr;
	int rc;

191
	ecdb_ahdr = iscsi_next_hdr(task);
192 193 194 195 196 197 198
	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);

199
	rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) +
200 201 202 203 204 205 206 207 208 209 210 211
	                   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);

212 213 214 215 216
	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);
217 218 219
	return 0;
}

220
static int iscsi_prep_bidi_ahs(struct iscsi_task *task)
221
{
222
	struct scsi_cmnd *sc = task->sc;
223 224 225
	struct iscsi_rlength_ahdr *rlen_ahdr;
	int rc;

226 227
	rlen_ahdr = iscsi_next_hdr(task);
	rc = iscsi_add_hdr(task, sizeof(*rlen_ahdr));
228 229 230 231 232 233 234 235 236 237
	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);

238 239 240 241 242
	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));
243 244 245
	return 0;
}

246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262
/**
 * iscsi_check_tmf_restrictions - check if a task is affected by TMF
 * @task: iscsi task
 * @opcode: opcode to check for
 *
 * During TMF a task has to be checked if it's affected.
 * All unrelated I/O can be passed through, but I/O to the
 * affected LUN should be restricted.
 * If 'fast_abort' is set we won't be sending any I/O to the
 * affected LUN.
 * Otherwise the target is waiting for all TTTs to be completed,
 * so we have to send all outstanding Data-Out PDUs to the target.
 */
static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode)
{
	struct iscsi_conn *conn = task->conn;
	struct iscsi_tm *tmf = &conn->tmhdr;
H
Hannes Reinecke 已提交
263
	u64 hdr_lun;
264 265 266 267 268 269 270 271 272 273 274 275

	if (conn->tmf_state == TMF_INITIAL)
		return 0;

	if ((tmf->opcode & ISCSI_OPCODE_MASK) != ISCSI_OP_SCSI_TMFUNC)
		return 0;

	switch (ISCSI_TM_FUNC_VALUE(tmf)) {
	case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET:
		/*
		 * Allow PDUs for unrelated LUNs
		 */
276
		hdr_lun = scsilun_to_int(&tmf->lun);
277 278
		if (hdr_lun != task->sc->device->lun)
			return 0;
279 280
		/* fall through */
	case ISCSI_TM_FUNC_TARGET_WARM_RESET:
281 282 283 284 285 286
		/*
		 * Fail all SCSI cmd PDUs
		 */
		if (opcode != ISCSI_OP_SCSI_DATA_OUT) {
			iscsi_conn_printk(KERN_INFO, conn,
					  "task [op %x/%x itt "
287
					  "0x%x/0x%x] "
288 289
					  "rejected.\n",
					  task->hdr->opcode, opcode,
290
					  task->itt, task->hdr_itt);
291 292 293 294 295 296 297 298 299
			return -EACCES;
		}
		/*
		 * And also all data-out PDUs in response to R2T
		 * if fast_abort is set.
		 */
		if (conn->session->fast_abort) {
			iscsi_conn_printk(KERN_INFO, conn,
					  "task [op %x/%x itt "
300
					  "0x%x/0x%x] fast abort.\n",
301
					  task->hdr->opcode, opcode,
302
					  task->itt, task->hdr_itt);
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327
			return -EACCES;
		}
		break;
	case ISCSI_TM_FUNC_ABORT_TASK:
		/*
		 * the caller has already checked if the task
		 * they want to abort was in the pending queue so if
		 * we are here the cmd pdu has gone out already, and
		 * we will only hit this for data-outs
		 */
		if (opcode == ISCSI_OP_SCSI_DATA_OUT &&
		    task->hdr_itt == tmf->rtt) {
			ISCSI_DBG_SESSION(conn->session,
					  "Preventing task %x/%x from sending "
					  "data-out due to abort task in "
					  "progress\n", task->itt,
					  task->hdr_itt);
			return -EACCES;
		}
		break;
	}

	return 0;
}

M
Mike Christie 已提交
328 329
/**
 * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu
330
 * @task: iscsi task
M
Mike Christie 已提交
331 332 333 334
 *
 * 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
 */
335
static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
M
Mike Christie 已提交
336
{
337
	struct iscsi_conn *conn = task->conn;
M
Mike Christie 已提交
338
	struct iscsi_session *session = conn->session;
339
	struct scsi_cmnd *sc = task->sc;
340
	struct iscsi_scsi_req *hdr;
341
	unsigned hdrlength, cmd_len, transfer_length;
342
	itt_t itt;
343
	int rc;
M
Mike Christie 已提交
344

345 346 347 348
	rc = iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_CMD);
	if (rc)
		return rc;

349 350 351 352 353
	if (conn->session->tt->alloc_pdu) {
		rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD);
		if (rc)
			return rc;
	}
354
	hdr = (struct iscsi_scsi_req *)task->hdr;
355
	itt = hdr->itt;
356 357
	memset(hdr, 0, sizeof(*hdr));

358 359 360 361 362
	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);
363 364
	task->hdr_len = 0;
	rc = iscsi_add_hdr(task, sizeof(*hdr));
365 366
	if (rc)
		return rc;
367 368
	hdr->opcode = ISCSI_OP_SCSI_CMD;
	hdr->flags = ISCSI_ATTR_SIMPLE;
369 370
	int_to_scsilun(sc->device->lun, &hdr->lun);
	task->lun = hdr->lun;
371
	hdr->exp_statsn = cpu_to_be32(conn->exp_statsn);
372 373 374 375
	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) {
376
		rc = iscsi_prep_ecdb_ahs(task);
377 378 379 380 381
		if (rc)
			return rc;
		cmd_len = ISCSI_CDB_SIZE;
	}
	memcpy(hdr->cdb, sc->cmnd, cmd_len);
M
Mike Christie 已提交
382

383
	task->imm_count = 0;
384 385
	if (scsi_bidi_cmnd(sc)) {
		hdr->flags |= ISCSI_FLAG_CMD_READ;
386
		rc = iscsi_prep_bidi_ahs(task);
387 388 389
		if (rc)
			return rc;
	}
390 391 392 393

	if (scsi_get_prot_op(sc) != SCSI_PROT_NORMAL)
		task->protected = true;

394 395
	transfer_length = scsi_transfer_length(sc);
	hdr->data_length = cpu_to_be32(transfer_length);
M
Mike Christie 已提交
396
	if (sc->sc_data_direction == DMA_TO_DEVICE) {
397 398
		struct iscsi_r2t_info *r2t = &task->unsol_r2t;

M
Mike Christie 已提交
399 400 401 402 403 404 405 406 407 408 409
		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
		 *
410
		 *	r2t data_length bytes to be sent via R2T ack's
M
Mike Christie 已提交
411 412 413
		 *
		 *      pad_count       bytes to be sent as zero-padding
		 */
414
		memset(r2t, 0, sizeof(*r2t));
M
Mike Christie 已提交
415 416

		if (session->imm_data_en) {
417
			if (transfer_length >= session->first_burst)
418
				task->imm_count = min(session->first_burst,
M
Mike Christie 已提交
419 420
							conn->max_xmit_dlength);
			else
421 422
				task->imm_count = min(transfer_length,
						      conn->max_xmit_dlength);
423
			hton24(hdr->dlength, task->imm_count);
M
Mike Christie 已提交
424
		} else
425
			zero_data(hdr->dlength);
M
Mike Christie 已提交
426

427
		if (!session->initial_r2t_en) {
428 429
			r2t->data_length = min(session->first_burst,
					       transfer_length) -
430 431 432 433
					       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);
434 435
		}

436
		if (!task->unsol_r2t.data_length)
M
Mike Christie 已提交
437
			/* No unsolicit Data-Out's */
438
			hdr->flags |= ISCSI_FLAG_CMD_FINAL;
M
Mike Christie 已提交
439 440 441 442 443 444 445 446
	} else {
		hdr->flags |= ISCSI_FLAG_CMD_FINAL;
		zero_data(hdr->dlength);

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

447
	/* calculate size of additional header segments (AHSs) */
448
	hdrlength = task->hdr_len - sizeof(*hdr);
449 450 451 452 453 454

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

	WARN_ON(hdrlength >= 256);
	hdr->hlength = hdrlength & 0xFF;
455
	hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn);
456

457
	if (session->tt->init_task && session->tt->init_task(task))
458 459
		return -EIO;

460
	task->state = ISCSI_TASK_RUNNING;
461
	session->cmdsn++;
462

463
	conn->scsicmd_pdus_cnt++;
464 465 466 467 468
	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],
469
			  task->itt, transfer_length,
470 471 472
			  scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0,
			  session->cmdsn,
			  session->max_cmdsn - session->exp_cmdsn + 1);
473
	return 0;
M
Mike Christie 已提交
474 475 476
}

/**
477
 * iscsi_free_task - free a task
478
 * @task: iscsi cmd task
M
Mike Christie 已提交
479
 *
480
 * Must be called with session back_lock.
481 482
 * This function returns the scsi command to scsi-ml or cleans
 * up mgmt tasks then returns the task to the pool.
M
Mike Christie 已提交
483
 */
484
static void iscsi_free_task(struct iscsi_task *task)
M
Mike Christie 已提交
485
{
486
	struct iscsi_conn *conn = task->conn;
487
	struct iscsi_session *session = conn->session;
488
	struct scsi_cmnd *sc = task->sc;
489
	int oldstate = task->state;
M
Mike Christie 已提交
490

491 492 493
	ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n",
			  task->itt, task->state, task->sc);

494
	session->tt->cleanup_task(task);
495
	task->state = ISCSI_TASK_FREE;
496
	task->sc = NULL;
497
	/*
498
	 * login task is preallocated so do not free
499
	 */
500
	if (conn->login_task == task)
501 502
		return;

503
	kfifo_in(&session->cmdpool.queue, (void*)&task, sizeof(void*));
504

505 506 507 508
	if (sc) {
		/* SCSI eh reuses commands to verify us */
		sc->SCp.ptr = NULL;
		/*
509 510
		 * queue command may call this to free the task, so
		 * it will decide how to return sc to scsi-ml.
511
		 */
512
		if (oldstate != ISCSI_TASK_REQUEUE_SCSIQ)
513 514
			sc->scsi_done(sc);
	}
M
Mike Christie 已提交
515 516
}

517
void __iscsi_get_task(struct iscsi_task *task)
518
{
519
	atomic_inc(&task->refcount);
520
}
521
EXPORT_SYMBOL_GPL(__iscsi_get_task);
522

523
void __iscsi_put_task(struct iscsi_task *task)
524
{
525
	if (atomic_dec_and_test(&task->refcount))
526
		iscsi_free_task(task);
527
}
528
EXPORT_SYMBOL_GPL(__iscsi_put_task);
529

530
void iscsi_put_task(struct iscsi_task *task)
531
{
532
	struct iscsi_session *session = task->conn->session;
533

534 535
	/* regular RX path uses back_lock */
	spin_lock_bh(&session->back_lock);
536
	__iscsi_put_task(task);
537
	spin_unlock_bh(&session->back_lock);
538
}
539
EXPORT_SYMBOL_GPL(iscsi_put_task);
540

541 542 543
/**
 * iscsi_complete_task - finish a task
 * @task: iscsi cmd task
544
 * @state: state to complete task with
545
 *
546
 * Must be called with session back_lock.
547
 */
548
static void iscsi_complete_task(struct iscsi_task *task, int state)
549 550 551
{
	struct iscsi_conn *conn = task->conn;

552 553 554
	ISCSI_DBG_SESSION(conn->session,
			  "complete task itt 0x%x state %d sc %p\n",
			  task->itt, task->state, task->sc);
555 556
	if (task->state == ISCSI_TASK_COMPLETED ||
	    task->state == ISCSI_TASK_ABRT_TMF ||
557 558
	    task->state == ISCSI_TASK_ABRT_SESS_RECOV ||
	    task->state == ISCSI_TASK_REQUEUE_SCSIQ)
559 560
		return;
	WARN_ON_ONCE(task->state == ISCSI_TASK_FREE);
561
	task->state = state;
562 563 564 565 566 567 568 569 570 571 572 573 574 575

	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);
}

576 577 578 579 580 581 582 583 584
/**
 * 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.
 *
585
 * Called with session back_lock
586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
 */
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);


601
/*
602
 * session back_lock must be held and if not called for a task that is
603 604
 * still pending or from the xmit thread, then xmit thread must
 * be suspended.
605
 */
606
static void fail_scsi_task(struct iscsi_task *task, int err)
607
{
608
	struct iscsi_conn *conn = task->conn;
609
	struct scsi_cmnd *sc;
610
	int state;
611

612 613 614 615 616
	/*
	 * 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.
	 */
617
	sc = task->sc;
618 619 620
	if (!sc)
		return;

621
	if (task->state == ISCSI_TASK_PENDING) {
622 623 624 625 626
		/*
		 * cmd never made it to the xmit thread, so we should not count
		 * the cmd in the sequencing
		 */
		conn->session->queued_cmdsn--;
627 628 629 630 631 632
		/* 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;
633

634
	sc->result = err << 16;
635 636 637 638 639 640
	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;
	}
641

642 643
	/* regular RX path uses back_lock */
	spin_lock_bh(&conn->session->back_lock);
644
	iscsi_complete_task(task, state);
645
	spin_unlock_bh(&conn->session->back_lock);
646 647
}

648
static int iscsi_prep_mgmt_task(struct iscsi_conn *conn,
649
				struct iscsi_task *task)
650 651
{
	struct iscsi_session *session = conn->session;
652
	struct iscsi_hdr *hdr = task->hdr;
653
	struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr;
654
	uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK;
655 656 657 658

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

659
	if (opcode != ISCSI_OP_LOGIN && opcode != ISCSI_OP_TEXT)
660 661 662 663 664 665 666
		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) {
		/*
667
		 * TODO: We always use immediate for normal session pdus.
668 669
		 * If we start to send tmfs or nops as non-immediate then
		 * we should start checking the cmdsn numbers for mgmt tasks.
670 671 672
		 *
		 * During discovery sessions iscsid sends TEXT as non immediate,
		 * but we always only send one PDU at a time.
673 674 675 676 677 678 679 680
		 */
		if (conn->c_stage == ISCSI_CONN_STARTED &&
		    !(hdr->opcode & ISCSI_OP_IMMEDIATE)) {
			session->queued_cmdsn++;
			session->cmdsn++;
		}
	}

681 682
	if (session->tt->init_task && session->tt->init_task(task))
		return -EIO;
683 684 685 686

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

687
	task->state = ISCSI_TASK_RUNNING;
688 689 690
	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);
691 692 693
	return 0;
}

694
static struct iscsi_task *
695 696 697 698
__iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
		      char *data, uint32_t data_size)
{
	struct iscsi_session *session = conn->session;
699
	struct iscsi_host *ihost = shost_priv(session->host);
700
	uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK;
701
	struct iscsi_task *task;
702
	itt_t itt;
703 704 705 706

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

707
	if (opcode == ISCSI_OP_LOGIN || opcode == ISCSI_OP_TEXT) {
708 709 710
		/*
		 * Login and Text are sent serially, in
		 * request-followed-by-response sequence.
711 712
		 * Same task can be used. Same ITT must be used.
		 * Note that login_task is preallocated at conn_create().
713
		 */
714 715 716 717 718 719
		if (conn->login_task->state != ISCSI_TASK_FREE) {
			iscsi_conn_printk(KERN_ERR, conn, "Login/Text in "
					  "progress. Cannot start new task.\n");
			return NULL;
		}

720 721 722 723 724
		if (data_size > ISCSI_DEF_MAX_RECV_SEG_LEN) {
			iscsi_conn_printk(KERN_ERR, conn, "Invalid buffer len of %u for login task. Max len is %u\n", data_size, ISCSI_DEF_MAX_RECV_SEG_LEN);
			return NULL;
		}

725
		task = conn->login_task;
726
	} else {
727 728 729
		if (session->state != ISCSI_STATE_LOGGED_IN)
			return NULL;

730 731 732 733 734
		if (data_size != 0) {
			iscsi_conn_printk(KERN_ERR, conn, "Can not send data buffer of len %u for op 0x%x\n", data_size, opcode);
			return NULL;
		}

735 736 737
		BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE);
		BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED);

738
		if (!kfifo_out(&session->cmdpool.queue,
739
				 (void*)&task, sizeof(void*)))
740 741
			return NULL;
	}
742 743 744 745 746
	/*
	 * 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.
	 */
747 748 749
	atomic_set(&task->refcount, 1);
	task->conn = conn;
	task->sc = NULL;
750 751
	INIT_LIST_HEAD(&task->running);
	task->state = ISCSI_TASK_PENDING;
752 753

	if (data_size) {
754 755
		memcpy(task->data, data, data_size);
		task->data_count = data_size;
756
	} else
757
		task->data_count = 0;
758

759 760 761 762
	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");
763
			goto free_task;
764
		}
765
	}
766

767
	itt = task->hdr->itt;
768
	task->hdr_len = sizeof(struct iscsi_hdr);
769
	memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr));
770 771 772 773 774 775 776 777 778

	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);
	}

779
	if (!ihost->workq) {
780 781
		if (iscsi_prep_mgmt_task(conn, task))
			goto free_task;
782

783
		if (session->tt->xmit_task(task))
784
			goto free_task;
785 786
	} else {
		list_add_tail(&task->running, &conn->mgmtqueue);
787
		iscsi_conn_queue_work(conn);
788
	}
789

790
	return task;
791 792

free_task:
793 794
	/* regular RX path uses back_lock */
	spin_lock_bh(&session->back_lock);
795
	__iscsi_put_task(task);
796
	spin_unlock_bh(&session->back_lock);
797
	return NULL;
798 799 800 801 802 803 804 805 806
}

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;

807
	spin_lock_bh(&session->frwd_lock);
808 809
	if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size))
		err = -EPERM;
810
	spin_unlock_bh(&session->frwd_lock);
811 812 813 814
	return err;
}
EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu);

M
Mike Christie 已提交
815 816 817 818
/**
 * iscsi_cmd_rsp - SCSI Command Response processing
 * @conn: iscsi connection
 * @hdr: iscsi header
819
 * @task: scsi command task
M
Mike Christie 已提交
820 821 822 823
 * @data: cmd data buffer
 * @datalen: len of buffer
 *
 * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and
824
 * then completes the command and task.
M
Mike Christie 已提交
825
 **/
826
static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
827
			       struct iscsi_task *task, char *data,
828
			       int datalen)
M
Mike Christie 已提交
829
{
830
	struct iscsi_scsi_rsp *rhdr = (struct iscsi_scsi_rsp *)hdr;
M
Mike Christie 已提交
831
	struct iscsi_session *session = conn->session;
832
	struct scsi_cmnd *sc = task->sc;
M
Mike Christie 已提交
833

834
	iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr);
M
Mike Christie 已提交
835 836 837 838
	conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1;

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

839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855
	if (task->protected) {
		sector_t sector;
		u8 ascq;

		/**
		 * Transports that didn't implement check_protection
		 * callback but still published T10-PI support to scsi-mid
		 * deserve this BUG_ON.
		 **/
		BUG_ON(!session->tt->check_protection);

		ascq = session->tt->check_protection(task, &sector);
		if (ascq) {
			sc->result = DRIVER_SENSE << 24 |
				     SAM_STAT_CHECK_CONDITION;
			scsi_build_sense_buffer(1, sc->sense_buffer,
						ILLEGAL_REQUEST, 0x10, ascq);
856 857 858
			scsi_set_sense_information(sc->sense_buffer,
						   SCSI_SENSE_BUFFERSIZE,
						   sector);
859 860 861 862
			goto out;
		}
	}

M
Mike Christie 已提交
863 864 865 866 867 868
	if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) {
		sc->result = DID_ERROR << 16;
		goto out;
	}

	if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) {
869
		uint16_t senselen;
M
Mike Christie 已提交
870 871 872

		if (datalen < 2) {
invalid_datalen:
873 874 875
			iscsi_conn_printk(KERN_ERR,  conn,
					 "Got CHECK_CONDITION but invalid data "
					 "buffer size of %d\n", datalen);
M
Mike Christie 已提交
876 877 878 879
			sc->result = DID_BAD_TARGET << 16;
			goto out;
		}

880
		senselen = get_unaligned_be16(data);
M
Mike Christie 已提交
881 882 883 884
		if (datalen < senselen)
			goto invalid_datalen;

		memcpy(sc->sense_buffer, data + 2,
885
		       min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE));
886 887 888
		ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n",
				  min_t(uint16_t, senselen,
				  SCSI_SENSE_BUFFERSIZE));
M
Mike Christie 已提交
889 890
	}

891 892 893 894 895 896 897 898 899 900 901 902
	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;
	}

903 904
	if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW |
	                   ISCSI_FLAG_CMD_OVERFLOW)) {
M
Mike Christie 已提交
905 906
		int res_count = be32_to_cpu(rhdr->residual_count);

907 908 909
		if (res_count > 0 &&
		    (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW ||
		     res_count <= scsi_bufflen(sc)))
910
			/* write side for bidi or uni-io set_resid */
911
			scsi_set_resid(sc, res_count);
M
Mike Christie 已提交
912 913
		else
			sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
914
	}
M
Mike Christie 已提交
915
out:
916
	ISCSI_DBG_SESSION(session, "cmd rsp done [sc %p res %d itt 0x%x]\n",
917
			  sc, sc->result, task->itt);
M
Mike Christie 已提交
918
	conn->scsirsp_pdus_cnt++;
919
	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
M
Mike Christie 已提交
920 921
}

922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937
/**
 * 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;

938
	iscsi_update_cmdsn(conn->session, (struct iscsi_nopin *)hdr);
939 940 941 942 943 944 945 946 947 948 949 950 951 952
	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;
	}

953 954 955
	ISCSI_DBG_SESSION(conn->session, "data in with status done "
			  "[sc %p res %d itt 0x%x]\n",
			  sc, sc->result, task->itt);
956
	conn->scsirsp_pdus_cnt++;
957
	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
958 959
}

960 961 962 963 964 965 966
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++;

967
	if (conn->tmf_state != TMF_QUEUED)
968 969 970
		return;

	if (tmf->response == ISCSI_TMF_RSP_COMPLETE)
971
		conn->tmf_state = TMF_SUCCESS;
972
	else if (tmf->response == ISCSI_TMF_RSP_NO_TASK)
973
		conn->tmf_state = TMF_NOT_FOUND;
974
	else
975
		conn->tmf_state = TMF_FAILED;
976 977 978
	wake_up(&conn->ehwait);
}

979
static int iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr)
980 981
{
        struct iscsi_nopout hdr;
982
	struct iscsi_task *task;
983

984
	if (!rhdr && conn->ping_task)
985
		return -EINVAL;
986 987 988 989 990 991

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

	if (rhdr) {
992
		hdr.lun = rhdr->lun;
993 994 995 996 997
		hdr.ttt = rhdr->ttt;
		hdr.itt = RESERVED_ITT;
	} else
		hdr.ttt = RESERVED_ITT;

998
	task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0);
999
	if (!task) {
1000
		iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n");
1001 1002
		return -EIO;
	} else if (!rhdr) {
1003 1004 1005 1006
		/* only track our nops */
		conn->ping_task = task;
		conn->last_ping = jiffies;
	}
1007 1008

	return 0;
1009 1010
}

1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030
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;
}

1031 1032 1033 1034 1035
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;
1036
	int opcode, rc = 0;
1037 1038 1039

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

1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055
	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",
1056
				  opcode, rejected_pdu.itt);
1057 1058 1059 1060 1061
		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",
1062
				  opcode, rejected_pdu.itt);
1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
		/*
		 * 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;
1073

1074
		 if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG)) {
1075 1076 1077 1078
			/*
			 * nop-out in response to target's nop-out rejected.
			 * Just resend.
			 */
1079 1080 1081
			/* In RX path we are under back lock */
			spin_unlock(&conn->session->back_lock);
			spin_lock(&conn->session->frwd_lock);
1082 1083
			iscsi_send_nopout(conn,
					  (struct iscsi_nopin*)&rejected_pdu);
1084 1085 1086
			spin_unlock(&conn->session->frwd_lock);
			spin_lock(&conn->session->back_lock);
		} else {
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101
			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);
1102
		}
1103 1104 1105 1106
		break;
	default:
		iscsi_conn_printk(KERN_ERR, conn,
				  "pdu (op 0x%x itt 0x%x) rejected. Reason "
1107 1108
				  "code 0x%x\n", rejected_pdu.opcode,
				  rejected_pdu.itt, reject->reason);
1109
		break;
1110
	}
1111
	return rc;
1112 1113
}

1114 1115 1116 1117 1118 1119 1120 1121
/**
 * 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.
 *
1122
 * The session back_lock must be held.
1123
 */
1124
struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt)
1125 1126
{
	struct iscsi_session *session = conn->session;
1127
	int i;
1128 1129 1130 1131

	if (itt == RESERVED_ITT)
		return NULL;

1132 1133 1134 1135
	if (session->tt->parse_pdu_itt)
		session->tt->parse_pdu_itt(conn, itt, &i, NULL);
	else
		i = get_itt(itt);
1136 1137 1138 1139 1140
	if (i >= session->cmds_max)
		return NULL;

	return session->cmds[i];
}
1141
EXPORT_SYMBOL_GPL(iscsi_itt_to_task);
1142

M
Mike Christie 已提交
1143 1144 1145 1146 1147 1148 1149 1150
/**
 * __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
1151
 * queuecommand or send generic. session back_lock must be held and verify
M
Mike Christie 已提交
1152 1153
 * itt must have been called.
 */
1154 1155
int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
			 char *data, int datalen)
M
Mike Christie 已提交
1156 1157 1158
{
	struct iscsi_session *session = conn->session;
	int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0;
1159
	struct iscsi_task *task;
M
Mike Christie 已提交
1160 1161
	uint32_t itt;

1162
	conn->last_recv = jiffies;
1163 1164 1165 1166
	rc = iscsi_verify_itt(conn, hdr->itt);
	if (rc)
		return rc;

A
Al Viro 已提交
1167 1168
	if (hdr->itt != RESERVED_ITT)
		itt = get_itt(hdr->itt);
M
Mike Christie 已提交
1169
	else
A
Al Viro 已提交
1170
		itt = ~0U;
M
Mike Christie 已提交
1171

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

1175
	if (itt == ~0U) {
1176
		iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
1177

M
Mike Christie 已提交
1178 1179
		switch(opcode) {
		case ISCSI_OP_NOOP_IN:
1180
			if (datalen) {
M
Mike Christie 已提交
1181
				rc = ISCSI_ERR_PROTO;
1182 1183 1184
				break;
			}

A
Al Viro 已提交
1185
			if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG))
1186 1187
				break;

1188 1189 1190
			/* In RX path we are under back lock */
			spin_unlock(&session->back_lock);
			spin_lock(&session->frwd_lock);
1191
			iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr);
1192 1193
			spin_unlock(&session->frwd_lock);
			spin_lock(&session->back_lock);
M
Mike Christie 已提交
1194 1195
			break;
		case ISCSI_OP_REJECT:
1196 1197
			rc = iscsi_handle_reject(conn, hdr, data, datalen);
			break;
M
Mike Christie 已提交
1198
		case ISCSI_OP_ASYNC_EVENT:
1199
			conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
M
Mike Christie 已提交
1200 1201
			if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen))
				rc = ISCSI_ERR_CONN_FAILED;
M
Mike Christie 已提交
1202 1203 1204 1205 1206
			break;
		default:
			rc = ISCSI_ERR_BAD_OPCODE;
			break;
		}
1207 1208 1209 1210 1211
		goto out;
	}

	switch(opcode) {
	case ISCSI_OP_SCSI_CMD_RSP:
1212 1213 1214 1215
	case ISCSI_OP_SCSI_DATA_IN:
		task = iscsi_itt_to_ctask(conn, hdr->itt);
		if (!task)
			return ISCSI_ERR_BAD_ITT;
1216
		task->last_xfer = jiffies;
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237
		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:
1238
		iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen);
1239 1240
		break;
	case ISCSI_OP_SCSI_DATA_IN:
1241
		iscsi_data_in_rsp(conn, hdr, task);
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
		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);
1267
		iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
1268 1269 1270 1271 1272 1273 1274 1275 1276
		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;

1277 1278
		rc = iscsi_nop_out_rsp(task, (struct iscsi_nopin*)hdr,
				       data, datalen);
1279 1280 1281 1282 1283
		break;
	default:
		rc = ISCSI_ERR_BAD_OPCODE;
		break;
	}
M
Mike Christie 已提交
1284

1285 1286 1287 1288 1289
out:
	return rc;
recv_pdu:
	if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen))
		rc = ISCSI_ERR_CONN_FAILED;
1290
	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
M
Mike Christie 已提交
1291 1292
	return rc;
}
1293
EXPORT_SYMBOL_GPL(__iscsi_complete_pdu);
M
Mike Christie 已提交
1294 1295 1296 1297 1298 1299

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

1300
	spin_lock(&conn->session->back_lock);
M
Mike Christie 已提交
1301
	rc = __iscsi_complete_pdu(conn, hdr, data, datalen);
1302
	spin_unlock(&conn->session->back_lock);
M
Mike Christie 已提交
1303 1304 1305 1306
	return rc;
}
EXPORT_SYMBOL_GPL(iscsi_complete_pdu);

1307
int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt)
M
Mike Christie 已提交
1308 1309
{
	struct iscsi_session *session = conn->session;
1310
	int age = 0, i = 0;
M
Mike Christie 已提交
1311

1312 1313
	if (itt == RESERVED_ITT)
		return 0;
M
Mike Christie 已提交
1314

1315 1316 1317 1318 1319 1320 1321 1322
	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) {
1323 1324
		iscsi_conn_printk(KERN_ERR, conn,
				  "received itt %x expected session age (%x)\n",
1325
				  (__force u32)itt, session->age);
1326 1327
		return ISCSI_ERR_BAD_ITT;
	}
M
Mike Christie 已提交
1328

1329 1330 1331 1332 1333
	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 已提交
1334 1335 1336 1337 1338
	}
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_verify_itt);

1339 1340 1341 1342 1343 1344 1345
/**
 * iscsi_itt_to_ctask - look up ctask by itt
 * @conn: iscsi connection
 * @itt: itt
 *
 * This should be used for cmd tasks.
 *
1346
 * The session back_lock must be held.
1347 1348
 */
struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt)
1349
{
1350
	struct iscsi_task *task;
1351 1352 1353 1354

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

1355 1356
	task = iscsi_itt_to_task(conn, itt);
	if (!task || !task->sc)
1357 1358
		return NULL;

1359 1360 1361 1362
	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);
1363
		return NULL;
1364
	}
1365

1366
	return task;
1367 1368 1369
}
EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask);

1370
void iscsi_session_failure(struct iscsi_session *session,
1371 1372 1373 1374 1375
			   enum iscsi_err err)
{
	struct iscsi_conn *conn;
	struct device *dev;

1376
	spin_lock_bh(&session->frwd_lock);
1377 1378
	conn = session->leadconn;
	if (session->state == ISCSI_STATE_TERMINATE || !conn) {
1379
		spin_unlock_bh(&session->frwd_lock);
1380 1381 1382 1383
		return;
	}

	dev = get_device(&conn->cls_conn->dev);
1384
	spin_unlock_bh(&session->frwd_lock);
1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
	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 已提交
1400 1401 1402 1403
void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err)
{
	struct iscsi_session *session = conn->session;

1404
	spin_lock_bh(&session->frwd_lock);
1405
	if (session->state == ISCSI_STATE_FAILED) {
1406
		spin_unlock_bh(&session->frwd_lock);
1407 1408 1409
		return;
	}

1410
	if (conn->stop_stage == 0)
M
Mike Christie 已提交
1411
		session->state = ISCSI_STATE_FAILED;
1412
	spin_unlock_bh(&session->frwd_lock);
1413

M
Mike Christie 已提交
1414 1415
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
1416
	iscsi_conn_error_event(conn->cls_conn, err);
M
Mike Christie 已提交
1417 1418 1419
}
EXPORT_SYMBOL_GPL(iscsi_conn_failure);

1420 1421 1422 1423 1424 1425 1426
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
	 */
1427
	if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) {
1428 1429 1430 1431
		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);
1432 1433 1434 1435 1436
		return -ENOSPC;
	}
	return 0;
}

1437
static int iscsi_xmit_task(struct iscsi_conn *conn)
1438
{
1439
	struct iscsi_task *task = conn->task;
1440
	int rc;
1441

1442 1443 1444
	if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx))
		return -ENODATA;

1445
	__iscsi_get_task(task);
1446
	spin_unlock_bh(&conn->session->frwd_lock);
1447
	rc = conn->session->tt->xmit_task(task);
1448
	spin_lock_bh(&conn->session->frwd_lock);
1449
	if (!rc) {
1450
		/* done with this task */
1451
		task->last_xfer = jiffies;
1452
		conn->task = NULL;
1453
	}
1454
	/* regular RX path uses back_lock */
1455
	spin_lock(&conn->session->back_lock);
1456
	__iscsi_put_task(task);
1457
	spin_unlock(&conn->session->back_lock);
1458 1459 1460
	return rc;
}

1461
/**
1462 1463
 * iscsi_requeue_task - requeue task to run from session workqueue
 * @task: task to requeue
1464
 *
1465
 * LLDs that need to run a task from the session workqueue should call
1466
 * this. The session frwd_lock must be held. This should only be called
1467
 * by software drivers.
1468
 */
1469
void iscsi_requeue_task(struct iscsi_task *task)
1470
{
1471
	struct iscsi_conn *conn = task->conn;
1472

1473 1474 1475 1476 1477 1478
	/*
	 * 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);
1479
	iscsi_conn_queue_work(conn);
1480
}
1481
EXPORT_SYMBOL_GPL(iscsi_requeue_task);
1482

M
Mike Christie 已提交
1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493
/**
 * 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)
{
1494
	struct iscsi_task *task;
1495
	int rc = 0;
M
Mike Christie 已提交
1496

1497
	spin_lock_bh(&conn->session->frwd_lock);
1498
	if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) {
1499
		ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n");
1500
		spin_unlock_bh(&conn->session->frwd_lock);
1501
		return -ENODATA;
M
Mike Christie 已提交
1502 1503
	}

1504 1505
	if (conn->task) {
		rc = iscsi_xmit_task(conn);
1506
	        if (rc)
1507
		        goto done;
M
Mike Christie 已提交
1508 1509
	}

1510 1511 1512 1513 1514 1515
	/*
	 * 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:
1516
	while (!list_empty(&conn->mgmtqueue)) {
1517 1518
		conn->task = list_entry(conn->mgmtqueue.next,
					 struct iscsi_task, running);
1519
		list_del_init(&conn->task->running);
1520
		if (iscsi_prep_mgmt_task(conn, conn->task)) {
1521 1522
			/* regular RX path uses back_lock */
			spin_lock_bh(&conn->session->back_lock);
1523
			__iscsi_put_task(conn->task);
1524
			spin_unlock_bh(&conn->session->back_lock);
1525
			conn->task = NULL;
1526 1527
			continue;
		}
1528
		rc = iscsi_xmit_task(conn);
1529
		if (rc)
1530
			goto done;
M
Mike Christie 已提交
1531 1532
	}

1533
	/* process pending command queue */
1534
	while (!list_empty(&conn->cmdqueue)) {
1535 1536
		conn->task = list_entry(conn->cmdqueue.next, struct iscsi_task,
					running);
1537
		list_del_init(&conn->task->running);
1538
		if (conn->session->state == ISCSI_STATE_LOGGING_OUT) {
1539
			fail_scsi_task(conn->task, DID_IMM_RETRY);
1540 1541
			continue;
		}
1542 1543
		rc = iscsi_prep_scsi_cmd_pdu(conn->task);
		if (rc) {
1544
			if (rc == -ENOMEM || rc == -EACCES) {
1545 1546
				list_add_tail(&conn->task->running,
					      &conn->cmdqueue);
1547
				conn->task = NULL;
1548
				goto done;
1549
			} else
1550
				fail_scsi_task(conn->task, DID_ABORT);
1551 1552
			continue;
		}
1553
		rc = iscsi_xmit_task(conn);
1554
		if (rc)
1555
			goto done;
1556
		/*
1557
		 * we could continuously get new task requests so
1558 1559 1560
		 * we need to check the mgmt queue for nops that need to
		 * be sent to aviod starvation
		 */
1561 1562 1563 1564 1565
		if (!list_empty(&conn->mgmtqueue))
			goto check_mgmt;
	}

	while (!list_empty(&conn->requeue)) {
1566 1567 1568 1569 1570 1571
		/*
		 * we always do fastlogout - conn stop code will clean up.
		 */
		if (conn->session->state == ISCSI_STATE_LOGGING_OUT)
			break;

1572 1573 1574 1575 1576 1577
		task = list_entry(conn->requeue.next, struct iscsi_task,
				  running);
		if (iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_DATA_OUT))
			break;

		conn->task = task;
1578
		list_del_init(&conn->task->running);
1579 1580
		conn->task->state = ISCSI_TASK_RUNNING;
		rc = iscsi_xmit_task(conn);
1581
		if (rc)
1582
			goto done;
1583
		if (!list_empty(&conn->mgmtqueue))
1584
			goto check_mgmt;
M
Mike Christie 已提交
1585
	}
1586
	spin_unlock_bh(&conn->session->frwd_lock);
1587
	return -ENODATA;
M
Mike Christie 已提交
1588

1589
done:
1590
	spin_unlock_bh(&conn->session->frwd_lock);
1591
	return rc;
M
Mike Christie 已提交
1592 1593
}

D
David Howells 已提交
1594
static void iscsi_xmitworker(struct work_struct *work)
M
Mike Christie 已提交
1595
{
D
David Howells 已提交
1596 1597
	struct iscsi_conn *conn =
		container_of(work, struct iscsi_conn, xmitwork);
1598
	int rc;
M
Mike Christie 已提交
1599 1600 1601
	/*
	 * serialize Xmit worker on a per-connection basis.
	 */
1602 1603 1604
	do {
		rc = iscsi_data_xmit(conn);
	} while (rc >= 0 || rc == -EAGAIN);
M
Mike Christie 已提交
1605 1606
}

1607 1608 1609 1610 1611
static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn,
						  struct scsi_cmnd *sc)
{
	struct iscsi_task *task;

1612
	if (!kfifo_out(&conn->session->cmdpool.queue,
1613 1614 1615 1616 1617 1618 1619 1620 1621 1622
			 (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;
1623 1624 1625
	task->have_checked_conn = false;
	task->last_timeout = jiffies;
	task->last_xfer = jiffies;
1626
	task->protected = false;
1627 1628 1629 1630
	INIT_LIST_HEAD(&task->running);
	return task;
}

M
Mike Christie 已提交
1631 1632 1633 1634 1635
enum {
	FAILURE_BAD_HOST = 1,
	FAILURE_SESSION_FAILED,
	FAILURE_SESSION_FREED,
	FAILURE_WINDOW_CLOSED,
1636
	FAILURE_OOM,
M
Mike Christie 已提交
1637
	FAILURE_SESSION_TERMINATE,
1638
	FAILURE_SESSION_IN_RECOVERY,
M
Mike Christie 已提交
1639
	FAILURE_SESSION_RECOVERY_TIMEOUT,
1640
	FAILURE_SESSION_LOGGING_OUT,
1641
	FAILURE_SESSION_NOT_READY,
M
Mike Christie 已提交
1642 1643
};

1644
int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc)
M
Mike Christie 已提交
1645
{
1646
	struct iscsi_cls_session *cls_session;
1647
	struct iscsi_host *ihost;
M
Mike Christie 已提交
1648 1649 1650
	int reason = 0;
	struct iscsi_session *session;
	struct iscsi_conn *conn;
1651
	struct iscsi_task *task = NULL;
M
Mike Christie 已提交
1652 1653

	sc->result = 0;
1654
	sc->SCp.ptr = NULL;
M
Mike Christie 已提交
1655

1656
	ihost = shost_priv(host);
M
Mike Christie 已提交
1657

1658 1659
	cls_session = starget_to_session(scsi_target(sc->device));
	session = cls_session->dd_data;
1660
	spin_lock_bh(&session->frwd_lock);
M
Mike Christie 已提交
1661

1662
	reason = iscsi_session_chkready(cls_session);
1663 1664 1665 1666 1667
	if (reason) {
		sc->result = reason;
		goto fault;
	}

1668
	if (session->state != ISCSI_STATE_LOGGED_IN) {
1669 1670 1671 1672 1673 1674
		/*
		 * 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)
		 */
1675
		switch (session->state) {
1676
		case ISCSI_STATE_FAILED:
1677
		case ISCSI_STATE_IN_RECOVERY:
1678
			reason = FAILURE_SESSION_IN_RECOVERY;
1679 1680
			sc->result = DID_IMM_RETRY << 16;
			break;
1681 1682
		case ISCSI_STATE_LOGGING_OUT:
			reason = FAILURE_SESSION_LOGGING_OUT;
1683 1684
			sc->result = DID_IMM_RETRY << 16;
			break;
1685
		case ISCSI_STATE_RECOVERY_FAILED:
1686
			reason = FAILURE_SESSION_RECOVERY_TIMEOUT;
1687
			sc->result = DID_TRANSPORT_FAILFAST << 16;
1688 1689
			break;
		case ISCSI_STATE_TERMINATE:
1690
			reason = FAILURE_SESSION_TERMINATE;
1691
			sc->result = DID_NO_CONNECT << 16;
1692 1693
			break;
		default:
1694
			reason = FAILURE_SESSION_FREED;
1695
			sc->result = DID_NO_CONNECT << 16;
1696
		}
M
Mike Christie 已提交
1697 1698 1699 1700
		goto fault;
	}

	conn = session->leadconn;
1701 1702
	if (!conn) {
		reason = FAILURE_SESSION_FREED;
1703
		sc->result = DID_NO_CONNECT << 16;
1704 1705
		goto fault;
	}
M
Mike Christie 已提交
1706

1707 1708 1709 1710 1711 1712
	if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) {
		reason = FAILURE_SESSION_IN_RECOVERY;
		sc->result = DID_REQUEUE;
		goto fault;
	}

1713 1714 1715 1716 1717
	if (iscsi_check_cmdsn_window_closed(conn)) {
		reason = FAILURE_WINDOW_CLOSED;
		goto reject;
	}

1718 1719
	task = iscsi_alloc_task(conn, sc);
	if (!task) {
1720 1721 1722
		reason = FAILURE_OOM;
		goto reject;
	}
M
Mike Christie 已提交
1723

1724
	if (!ihost->workq) {
1725 1726
		reason = iscsi_prep_scsi_cmd_pdu(task);
		if (reason) {
1727
			if (reason == -ENOMEM ||  reason == -EACCES) {
1728 1729 1730 1731 1732 1733
				reason = FAILURE_OOM;
				goto prepd_reject;
			} else {
				sc->result = DID_ABORT << 16;
				goto prepd_fault;
			}
1734
		}
1735
		if (session->tt->xmit_task(task)) {
1736
			session->cmdsn--;
1737
			reason = FAILURE_SESSION_NOT_READY;
1738
			goto prepd_reject;
1739
		}
1740 1741
	} else {
		list_add_tail(&task->running, &conn->cmdqueue);
1742
		iscsi_conn_queue_work(conn);
1743
	}
1744 1745

	session->queued_cmdsn++;
1746
	spin_unlock_bh(&session->frwd_lock);
M
Mike Christie 已提交
1747 1748
	return 0;

1749
prepd_reject:
1750
	iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ);
M
Mike Christie 已提交
1751
reject:
1752
	spin_unlock_bh(&session->frwd_lock);
1753 1754
	ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n",
			  sc->cmnd[0], reason);
1755
	return SCSI_MLQUEUE_TARGET_BUSY;
M
Mike Christie 已提交
1756

1757
prepd_fault:
1758
	iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ);
M
Mike Christie 已提交
1759
fault:
1760
	spin_unlock_bh(&session->frwd_lock);
1761 1762
	ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n",
			  sc->cmnd[0], reason);
1763 1764 1765 1766 1767 1768
	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;
	}
1769
	sc->scsi_done(sc);
M
Mike Christie 已提交
1770 1771 1772 1773
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_queuecommand);

1774 1775 1776 1777 1778 1779 1780 1781 1782 1783
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);

1784
static void iscsi_tmf_timedout(unsigned long data)
M
Mike Christie 已提交
1785
{
1786
	struct iscsi_conn *conn = (struct iscsi_conn *)data;
M
Mike Christie 已提交
1787 1788
	struct iscsi_session *session = conn->session;

1789
	spin_lock(&session->frwd_lock);
1790 1791
	if (conn->tmf_state == TMF_QUEUED) {
		conn->tmf_state = TMF_TIMEDOUT;
1792
		ISCSI_DBG_EH(session, "tmf timedout\n");
M
Mike Christie 已提交
1793 1794 1795
		/* unblock eh_abort() */
		wake_up(&conn->ehwait);
	}
1796
	spin_unlock(&session->frwd_lock);
M
Mike Christie 已提交
1797 1798
}

1799
static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn,
1800 1801
				   struct iscsi_tm *hdr, int age,
				   int timeout)
M
Mike Christie 已提交
1802 1803
{
	struct iscsi_session *session = conn->session;
1804
	struct iscsi_task *task;
M
Mike Christie 已提交
1805

1806
	task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr,
1807
				      NULL, 0);
1808
	if (!task) {
1809
		spin_unlock_bh(&session->frwd_lock);
1810
		iscsi_conn_printk(KERN_ERR, conn, "Could not send TMF.\n");
M
Mike Christie 已提交
1811
		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
1812
		spin_lock_bh(&session->frwd_lock);
1813
		return -EPERM;
M
Mike Christie 已提交
1814
	}
1815
	conn->tmfcmd_pdus_cnt++;
1816
	conn->tmf_timer.expires = timeout * HZ + jiffies;
1817 1818 1819
	conn->tmf_timer.function = iscsi_tmf_timedout;
	conn->tmf_timer.data = (unsigned long)conn;
	add_timer(&conn->tmf_timer);
1820
	ISCSI_DBG_EH(session, "tmf set timeout\n");
M
Mike Christie 已提交
1821

1822
	spin_unlock_bh(&session->frwd_lock);
1823
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
1824 1825 1826 1827

	/*
	 * block eh thread until:
	 *
1828 1829
	 * 1) tmf response
	 * 2) tmf timeout
M
Mike Christie 已提交
1830 1831 1832
	 * 3) session is terminated or restarted or userspace has
	 * given up on recovery
	 */
1833
	wait_event_interruptible(conn->ehwait, age != session->age ||
M
Mike Christie 已提交
1834
				 session->state != ISCSI_STATE_LOGGED_IN ||
1835
				 conn->tmf_state != TMF_QUEUED);
M
Mike Christie 已提交
1836 1837
	if (signal_pending(current))
		flush_signals(current);
1838 1839
	del_timer_sync(&conn->tmf_timer);

1840
	mutex_lock(&session->eh_mutex);
1841
	spin_lock_bh(&session->frwd_lock);
1842
	/* if the session drops it will clean up the task */
1843 1844 1845
	if (age != session->age ||
	    session->state != ISCSI_STATE_LOGGED_IN)
		return -ENOTCONN;
M
Mike Christie 已提交
1846 1847 1848
	return 0;
}

1849 1850 1851 1852
/*
 * Fail commands. session lock held and recv side suspended and xmit
 * thread flushed
 */
H
Hannes Reinecke 已提交
1853
static void fail_scsi_tasks(struct iscsi_conn *conn, u64 lun, int error)
1854
{
1855 1856
	struct iscsi_task *task;
	int i;
1857

1858 1859 1860 1861
	for (i = 0; i < conn->session->cmds_max; i++) {
		task = conn->session->cmds[i];
		if (!task->sc || task->state == ISCSI_TASK_FREE)
			continue;
1862

1863 1864
		if (lun != -1 && lun != task->sc->device->lun)
			continue;
1865

1866 1867 1868
		ISCSI_DBG_SESSION(conn->session,
				  "failing sc %p itt 0x%x state %d\n",
				  task->sc, task->itt, task->state);
1869
		fail_scsi_task(task, error);
1870 1871 1872
	}
}

1873 1874 1875 1876
/**
 * iscsi_suspend_queue - suspend iscsi_queuecommand
 * @conn: iscsi conn to stop queueing IO on
 *
1877
 * This grabs the session frwd_lock to make sure no one is in
1878 1879 1880 1881 1882 1883 1884 1885
 * 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)
{
1886
	spin_lock_bh(&conn->session->frwd_lock);
1887
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
1888
	spin_unlock_bh(&conn->session->frwd_lock);
1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899
}
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.
 */
1900
void iscsi_suspend_tx(struct iscsi_conn *conn)
1901
{
1902 1903 1904
	struct Scsi_Host *shost = conn->session->host;
	struct iscsi_host *ihost = shost_priv(shost);

1905
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
1906
	if (ihost->workq)
1907
		flush_workqueue(ihost->workq);
1908
}
1909
EXPORT_SYMBOL_GPL(iscsi_suspend_tx);
1910 1911 1912 1913

static void iscsi_start_tx(struct iscsi_conn *conn)
{
	clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
1914
	iscsi_conn_queue_work(conn);
1915 1916
}

1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932
/*
 * 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;
}

1933
static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
1934
{
1935
	enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED;
1936
	struct iscsi_task *task = NULL, *running_task;
1937 1938 1939
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
	struct iscsi_conn *conn;
1940
	int i;
1941

1942
	cls_session = starget_to_session(scsi_target(sc->device));
1943
	session = cls_session->dd_data;
1944

1945
	ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc);
1946

1947
	spin_lock(&session->frwd_lock);
1948 1949 1950 1951 1952 1953 1954 1955 1956 1957
	task = (struct iscsi_task *)sc->SCp.ptr;
	if (!task) {
		/*
		 * Raced with completion. Blk layer has taken ownership
		 * so let timeout code complete it now.
		 */
		rc = BLK_EH_HANDLED;
		goto done;
	}

1958 1959 1960 1961 1962
	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 已提交
1963
		rc = BLK_EH_RESET_TIMER;
1964 1965 1966 1967 1968 1969
		goto done;
	}

	conn = session->leadconn;
	if (!conn) {
		/* In the middle of shuting down */
J
Jens Axboe 已提交
1970
		rc = BLK_EH_RESET_TIMER;
1971 1972 1973
		goto done;
	}

1974 1975 1976 1977 1978 1979 1980
	/*
	 * 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.
	 */
1981
	if (time_after(task->last_xfer, task->last_timeout)) {
1982 1983
		ISCSI_DBG_EH(session, "Command making progress. Asking "
			     "scsi-ml for more time to complete. "
1984
			     "Last data xfer at %lu. Last timeout was at "
1985
			     "%lu\n.", task->last_xfer, task->last_timeout);
1986 1987 1988 1989 1990
		task->have_checked_conn = false;
		rc = BLK_EH_RESET_TIMER;
		goto done;
	}

1991 1992 1993 1994 1995 1996
	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
	 */
1997
	if (iscsi_has_ping_timed_out(conn)) {
J
Jens Axboe 已提交
1998
		rc = BLK_EH_RESET_TIMER;
1999 2000
		goto done;
	}
2001

2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038
	for (i = 0; i < conn->session->cmds_max; i++) {
		running_task = conn->session->cmds[i];
		if (!running_task->sc || running_task == task ||
		     running_task->state != ISCSI_TASK_RUNNING)
			continue;

		/*
		 * Only check if cmds started before this one have made
		 * progress, or this could never fail
		 */
		if (time_after(running_task->sc->jiffies_at_alloc,
			       task->sc->jiffies_at_alloc))
			continue;

		if (time_after(running_task->last_xfer, task->last_timeout)) {
			/*
			 * This task has not made progress, but a task
			 * started before us has transferred data since
			 * we started/last-checked. We could be queueing
			 * too many tasks or the LU is bad.
			 *
			 * If the device is bad the cmds ahead of us on
			 * other devs will complete, and this loop will
			 * eventually fail starting the scsi eh.
			 */
			ISCSI_DBG_EH(session, "Command has not made progress "
				     "but commands ahead of it have. "
				     "Asking scsi-ml for more time to "
				     "complete. Our last xfer vs running task "
				     "last xfer %lu/%lu. Last check %lu.\n",
				     task->last_xfer, running_task->last_xfer,
				     task->last_timeout);
			rc = BLK_EH_RESET_TIMER;
			goto done;
		}
	}

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

2043
	/*
2044 2045
	 * Checking the transport already or nop from a cmd timeout still
	 * running
2046
	 */
2047 2048
	if (conn->ping_task) {
		task->have_checked_conn = true;
J
Jens Axboe 已提交
2049
		rc = BLK_EH_RESET_TIMER;
2050 2051 2052
		goto done;
	}

2053 2054 2055 2056 2057
	/* Make sure there is a transport check done */
	iscsi_send_nopout(conn, NULL);
	task->have_checked_conn = true;
	rc = BLK_EH_RESET_TIMER;

2058
done:
2059 2060
	if (task)
		task->last_timeout = jiffies;
2061
	spin_unlock(&session->frwd_lock);
2062 2063
	ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ?
		     "timer reset" : "nh");
2064 2065 2066 2067 2068 2069 2070
	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;
2071
	unsigned long recv_timeout, next_timeout = 0, last_recv;
2072

2073
	spin_lock(&session->frwd_lock);
2074 2075 2076
	if (session->state != ISCSI_STATE_LOGGED_IN)
		goto done;

2077 2078
	recv_timeout = conn->recv_timeout;
	if (!recv_timeout)
2079 2080
		goto done;

2081
	recv_timeout *= HZ;
2082
	last_recv = conn->last_recv;
2083 2084

	if (iscsi_has_ping_timed_out(conn)) {
2085
		iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs "
2086 2087 2088 2089
				  "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);
2090
		spin_unlock(&session->frwd_lock);
2091
		iscsi_conn_failure(conn, ISCSI_ERR_NOP_TIMEDOUT);
2092 2093 2094
		return;
	}

2095
	if (time_before_eq(last_recv + recv_timeout, jiffies)) {
2096
		/* send a ping to try to provoke some traffic */
2097
		ISCSI_DBG_CONN(conn, "Sending nopout as ping\n");
2098 2099 2100 2101
		if (iscsi_send_nopout(conn, NULL))
			next_timeout = jiffies + (1 * HZ);
		else
			next_timeout = conn->last_ping + (conn->ping_timeout * HZ);
2102
	} else
2103
		next_timeout = last_recv + recv_timeout;
2104

2105
	ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout);
2106
	mod_timer(&conn->transport_timer, next_timeout);
2107
done:
2108
	spin_unlock(&session->frwd_lock);
2109 2110
}

2111
static void iscsi_prep_abort_task_pdu(struct iscsi_task *task,
2112 2113 2114 2115 2116 2117
				      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;
2118
	hdr->lun = task->lun;
2119 2120
	hdr->rtt = task->hdr_itt;
	hdr->refcmdsn = task->cmdsn;
2121 2122
}

M
Mike Christie 已提交
2123 2124
int iscsi_eh_abort(struct scsi_cmnd *sc)
{
2125 2126
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
2127
	struct iscsi_conn *conn;
2128
	struct iscsi_task *task;
2129 2130
	struct iscsi_tm *hdr;
	int rc, age;
M
Mike Christie 已提交
2131

2132 2133 2134
	cls_session = starget_to_session(scsi_target(sc->device));
	session = cls_session->dd_data;

2135
	ISCSI_DBG_EH(session, "aborting sc %p\n", sc);
2136

2137
	mutex_lock(&session->eh_mutex);
2138
	spin_lock_bh(&session->frwd_lock);
2139 2140 2141 2142 2143
	/*
	 * if session was ISCSI_STATE_IN_RECOVERY then we may not have
	 * got the command.
	 */
	if (!sc->SCp.ptr) {
2144 2145
		ISCSI_DBG_EH(session, "sc never reached iscsi layer or "
				      "it completed.\n");
2146
		spin_unlock_bh(&session->frwd_lock);
2147
		mutex_unlock(&session->eh_mutex);
2148 2149 2150
		return SUCCESS;
	}

M
Mike Christie 已提交
2151 2152 2153 2154
	/*
	 * If we are not logged in or we have started a new session
	 * then let the host reset code handle this
	 */
2155 2156
	if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN ||
	    sc->SCp.phase != session->age) {
2157
		spin_unlock_bh(&session->frwd_lock);
2158
		mutex_unlock(&session->eh_mutex);
2159
		ISCSI_DBG_EH(session, "failing abort due to dropped "
2160
				  "session.\n");
2161 2162 2163 2164 2165 2166 2167
		return FAILED;
	}

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

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

2172 2173
	/* task completed before time out */
	if (!task->sc) {
2174
		ISCSI_DBG_EH(session, "sc completed while abort in progress\n");
2175
		goto success;
2176
	}
M
Mike Christie 已提交
2177

2178
	if (task->state == ISCSI_TASK_PENDING) {
2179
		fail_scsi_task(task, DID_ABORT);
2180 2181
		goto success;
	}
M
Mike Christie 已提交
2182

2183 2184
	/* only have one tmf outstanding at a time */
	if (conn->tmf_state != TMF_INITIAL)
M
Mike Christie 已提交
2185
		goto failed;
2186
	conn->tmf_state = TMF_QUEUED;
M
Mike Christie 已提交
2187

2188
	hdr = &conn->tmhdr;
2189
	iscsi_prep_abort_task_pdu(task, hdr);
2190

2191
	if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) {
2192 2193 2194 2195 2196 2197
		rc = FAILED;
		goto failed;
	}

	switch (conn->tmf_state) {
	case TMF_SUCCESS:
2198
		spin_unlock_bh(&session->frwd_lock);
2199 2200 2201 2202
		/*
		 * stop tx side incase the target had sent a abort rsp but
		 * the initiator was still writing out data.
		 */
2203
		iscsi_suspend_tx(conn);
2204
		/*
2205 2206 2207
		 * 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.
2208
		 */
2209
		spin_lock_bh(&session->frwd_lock);
2210
		fail_scsi_task(task, DID_ABORT);
2211
		conn->tmf_state = TMF_INITIAL;
2212
		memset(hdr, 0, sizeof(*hdr));
2213
		spin_unlock_bh(&session->frwd_lock);
2214
		iscsi_start_tx(conn);
2215
		goto success_unlocked;
2216
	case TMF_TIMEDOUT:
2217
		spin_unlock_bh(&session->frwd_lock);
2218
		iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
2219 2220 2221 2222
		goto failed_unlocked;
	case TMF_NOT_FOUND:
		if (!sc->SCp.ptr) {
			conn->tmf_state = TMF_INITIAL;
2223
			memset(hdr, 0, sizeof(*hdr));
2224
			/* task completed before tmf abort response */
2225 2226
			ISCSI_DBG_EH(session, "sc completed while abort	in "
					      "progress\n");
2227
			goto success;
2228 2229 2230
		}
		/* fall through */
	default:
2231 2232
		conn->tmf_state = TMF_INITIAL;
		goto failed;
M
Mike Christie 已提交
2233 2234
	}

2235
success:
2236
	spin_unlock_bh(&session->frwd_lock);
2237
success_unlocked:
2238 2239
	ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n",
		     sc, task->itt);
2240
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
2241 2242 2243
	return SUCCESS;

failed:
2244
	spin_unlock_bh(&session->frwd_lock);
2245
failed_unlocked:
2246 2247
	ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc,
		     task ? task->itt : 0);
2248
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
2249 2250 2251 2252
	return FAILED;
}
EXPORT_SYMBOL_GPL(iscsi_eh_abort);

2253 2254 2255 2256 2257 2258
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;
2259
	int_to_scsilun(sc->device->lun, &hdr->lun);
2260
	hdr->rtt = RESERVED_ITT;
2261 2262 2263 2264
}

int iscsi_eh_device_reset(struct scsi_cmnd *sc)
{
2265 2266
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
2267 2268 2269 2270
	struct iscsi_conn *conn;
	struct iscsi_tm *hdr;
	int rc = FAILED;

2271 2272 2273
	cls_session = starget_to_session(scsi_target(sc->device));
	session = cls_session->dd_data;

H
Hannes Reinecke 已提交
2274 2275
	ISCSI_DBG_EH(session, "LU Reset [sc %p lun %llu]\n", sc,
		     sc->device->lun);
2276 2277

	mutex_lock(&session->eh_mutex);
2278
	spin_lock_bh(&session->frwd_lock);
2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294
	/*
	 * 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);

2295
	if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age,
2296
				    session->lu_reset_timeout)) {
2297 2298 2299 2300 2301 2302 2303 2304
		rc = FAILED;
		goto unlock;
	}

	switch (conn->tmf_state) {
	case TMF_SUCCESS:
		break;
	case TMF_TIMEDOUT:
2305
		spin_unlock_bh(&session->frwd_lock);
2306
		iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
2307 2308 2309 2310 2311 2312 2313
		goto done;
	default:
		conn->tmf_state = TMF_INITIAL;
		goto unlock;
	}

	rc = SUCCESS;
2314
	spin_unlock_bh(&session->frwd_lock);
2315 2316

	iscsi_suspend_tx(conn);
2317

2318
	spin_lock_bh(&session->frwd_lock);
2319
	memset(hdr, 0, sizeof(*hdr));
2320
	fail_scsi_tasks(conn, sc->device->lun, DID_ERROR);
2321
	conn->tmf_state = TMF_INITIAL;
2322
	spin_unlock_bh(&session->frwd_lock);
2323 2324 2325 2326 2327

	iscsi_start_tx(conn);
	goto done;

unlock:
2328
	spin_unlock_bh(&session->frwd_lock);
2329
done:
2330 2331
	ISCSI_DBG_EH(session, "dev reset result = %s\n",
		     rc == SUCCESS ? "SUCCESS" : "FAILED");
2332 2333 2334 2335 2336
	mutex_unlock(&session->eh_mutex);
	return rc;
}
EXPORT_SYMBOL_GPL(iscsi_eh_device_reset);

2337 2338 2339 2340
void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session)
{
	struct iscsi_session *session = cls_session->dd_data;

2341
	spin_lock_bh(&session->frwd_lock);
2342 2343 2344 2345 2346
	if (session->state != ISCSI_STATE_LOGGED_IN) {
		session->state = ISCSI_STATE_RECOVERY_FAILED;
		if (session->leadconn)
			wake_up(&session->leadconn->ehwait);
	}
2347
	spin_unlock_bh(&session->frwd_lock);
2348 2349 2350 2351 2352 2353 2354 2355 2356 2357
}
EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout);

/**
 * iscsi_eh_session_reset - drop session and attempt relogin
 * @sc: scsi command
 *
 * This function will wait for a relogin, session termination from
 * userspace, or a recovery/replacement timeout.
 */
2358
int iscsi_eh_session_reset(struct scsi_cmnd *sc)
2359 2360 2361 2362 2363 2364 2365 2366 2367 2368
{
	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;

	mutex_lock(&session->eh_mutex);
2369
	spin_lock_bh(&session->frwd_lock);
2370 2371 2372 2373 2374 2375
	if (session->state == ISCSI_STATE_TERMINATE) {
failed:
		ISCSI_DBG_EH(session,
			     "failing session reset: Could not log back into "
			     "%s, %s [age %d]\n", session->targetname,
			     conn->persistent_address, session->age);
2376
		spin_unlock_bh(&session->frwd_lock);
2377 2378 2379 2380
		mutex_unlock(&session->eh_mutex);
		return FAILED;
	}

2381
	spin_unlock_bh(&session->frwd_lock);
2382 2383 2384 2385 2386
	mutex_unlock(&session->eh_mutex);
	/*
	 * we drop the lock here but the leadconn cannot be destoyed while
	 * we are in the scsi eh
	 */
2387
	iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
2388 2389 2390 2391 2392 2393 2394 2395 2396 2397

	ISCSI_DBG_EH(session, "wait for relogin\n");
	wait_event_interruptible(conn->ehwait,
				 session->state == ISCSI_STATE_TERMINATE ||
				 session->state == ISCSI_STATE_LOGGED_IN ||
				 session->state == ISCSI_STATE_RECOVERY_FAILED);
	if (signal_pending(current))
		flush_signals(current);

	mutex_lock(&session->eh_mutex);
2398
	spin_lock_bh(&session->frwd_lock);
2399 2400 2401 2402 2403 2404
	if (session->state == ISCSI_STATE_LOGGED_IN) {
		ISCSI_DBG_EH(session,
			     "session reset succeeded for %s,%s\n",
			     session->targetname, conn->persistent_address);
	} else
		goto failed;
2405
	spin_unlock_bh(&session->frwd_lock);
2406 2407 2408
	mutex_unlock(&session->eh_mutex);
	return SUCCESS;
}
2409
EXPORT_SYMBOL_GPL(iscsi_eh_session_reset);
2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423

static void iscsi_prep_tgt_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_TARGET_WARM_RESET & ISCSI_FLAG_TM_FUNC_MASK;
	hdr->flags |= ISCSI_FLAG_CMD_FINAL;
	hdr->rtt = RESERVED_ITT;
}

/**
 * iscsi_eh_target_reset - reset target
 * @sc: scsi command
 *
2424
 * This will attempt to send a warm target reset.
2425
 */
2426
static int iscsi_eh_target_reset(struct scsi_cmnd *sc)
2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440
{
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
	struct iscsi_conn *conn;
	struct iscsi_tm *hdr;
	int rc = FAILED;

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

	ISCSI_DBG_EH(session, "tgt Reset [sc %p tgt %s]\n", sc,
		     session->targetname);

	mutex_lock(&session->eh_mutex);
2441
	spin_lock_bh(&session->frwd_lock);
2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467
	/*
	 * 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_tgt_reset_pdu(sc, hdr);

	if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age,
				    session->tgt_reset_timeout)) {
		rc = FAILED;
		goto unlock;
	}

	switch (conn->tmf_state) {
	case TMF_SUCCESS:
		break;
	case TMF_TIMEDOUT:
2468
		spin_unlock_bh(&session->frwd_lock);
2469
		iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
2470 2471 2472 2473 2474 2475 2476
		goto done;
	default:
		conn->tmf_state = TMF_INITIAL;
		goto unlock;
	}

	rc = SUCCESS;
2477
	spin_unlock_bh(&session->frwd_lock);
2478 2479 2480

	iscsi_suspend_tx(conn);

2481
	spin_lock_bh(&session->frwd_lock);
2482 2483 2484
	memset(hdr, 0, sizeof(*hdr));
	fail_scsi_tasks(conn, -1, DID_ERROR);
	conn->tmf_state = TMF_INITIAL;
2485
	spin_unlock_bh(&session->frwd_lock);
2486 2487 2488 2489 2490

	iscsi_start_tx(conn);
	goto done;

unlock:
2491
	spin_unlock_bh(&session->frwd_lock);
2492 2493 2494 2495
done:
	ISCSI_DBG_EH(session, "tgt %s reset result = %s\n", session->targetname,
		     rc == SUCCESS ? "SUCCESS" : "FAILED");
	mutex_unlock(&session->eh_mutex);
2496 2497
	return rc;
}
2498

2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510
/**
 * iscsi_eh_recover_target - reset target and possibly the session
 * @sc: scsi command
 *
 * This will attempt to send a warm target reset. If that fails,
 * we will escalate to ERL0 session recovery.
 */
int iscsi_eh_recover_target(struct scsi_cmnd *sc)
{
	int rc;

	rc = iscsi_eh_target_reset(sc);
2511 2512 2513 2514
	if (rc == FAILED)
		rc = iscsi_eh_session_reset(sc);
	return rc;
}
2515
EXPORT_SYMBOL_GPL(iscsi_eh_recover_target);
2516

2517 2518 2519 2520 2521 2522
/*
 * 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 已提交
2523
int
2524
iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size)
M
Mike Christie 已提交
2525
{
2526
	int i, num_arrays = 1;
M
Mike Christie 已提交
2527

2528
	memset(q, 0, sizeof(*q));
M
Mike Christie 已提交
2529 2530

	q->max = max;
2531 2532 2533 2534 2535 2536 2537

	/* 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)
2538
		return -ENOMEM;
M
Mike Christie 已提交
2539

S
Stefani Seibold 已提交
2540
	kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*));
M
Mike Christie 已提交
2541 2542

	for (i = 0; i < max; i++) {
2543
		q->pool[i] = kzalloc(item_size, GFP_KERNEL);
M
Mike Christie 已提交
2544
		if (q->pool[i] == NULL) {
2545 2546
			q->max = i;
			goto enomem;
M
Mike Christie 已提交
2547
		}
2548
		kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*));
M
Mike Christie 已提交
2549
	}
2550 2551 2552 2553 2554 2555

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

M
Mike Christie 已提交
2556
	return 0;
2557 2558 2559 2560

enomem:
	iscsi_pool_free(q);
	return -ENOMEM;
M
Mike Christie 已提交
2561 2562 2563
}
EXPORT_SYMBOL_GPL(iscsi_pool_init);

2564
void iscsi_pool_free(struct iscsi_pool *q)
M
Mike Christie 已提交
2565 2566 2567 2568
{
	int i;

	for (i = 0; i < q->max; i++)
2569
		kfree(q->pool[i]);
2570
	kfree(q->pool);
M
Mike Christie 已提交
2571 2572 2573
}
EXPORT_SYMBOL_GPL(iscsi_pool_free);

2574 2575 2576 2577 2578 2579 2580 2581 2582 2583
/**
 * 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)
{
2584 2585 2586
	if (!shost->can_queue)
		shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX;

2587 2588 2589
	if (!shost->cmd_per_lun)
		shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN;

2590 2591
	if (!shost->transportt->eh_timed_out)
		shost->transportt->eh_timed_out = iscsi_eh_cmd_timed_out;
2592 2593 2594 2595 2596 2597 2598 2599
	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
2600
 * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue
2601 2602 2603 2604 2605
 *
 * 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,
2606
				   int dd_data_size, bool xmit_can_sleep)
2607
{
2608
	struct Scsi_Host *shost;
2609
	struct iscsi_host *ihost;
2610 2611 2612 2613

	shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size);
	if (!shost)
		return NULL;
2614
	ihost = shost_priv(shost);
2615 2616 2617 2618 2619 2620 2621 2622 2623

	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;
	}

2624 2625 2626 2627
	spin_lock_init(&ihost->lock);
	ihost->state = ISCSI_HOST_SETUP;
	ihost->num_sessions = 0;
	init_waitqueue_head(&ihost->session_removal_wq);
2628
	return shost;
2629 2630 2631 2632

free_host:
	scsi_host_put(shost);
	return NULL;
2633 2634 2635
}
EXPORT_SYMBOL_GPL(iscsi_host_alloc);

2636 2637
static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session)
{
2638
	iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST);
2639 2640
}

2641 2642 2643 2644
/**
 * iscsi_host_remove - remove host and sessions
 * @shost: scsi host
 *
2645 2646
 * If there are any sessions left, this will initiate the removal and wait
 * for the completion.
2647 2648 2649
 */
void iscsi_host_remove(struct Scsi_Host *shost)
{
2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662
	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);

2663
	scsi_remove_host(shost);
2664 2665
	if (ihost->workq)
		destroy_workqueue(ihost->workq);
2666
}
2667
EXPORT_SYMBOL_GPL(iscsi_host_remove);
M
Mike Christie 已提交
2668

2669
void iscsi_host_free(struct Scsi_Host *shost)
2670 2671
{
	struct iscsi_host *ihost = shost_priv(shost);
M
Mike Christie 已提交
2672

2673 2674 2675
	kfree(ihost->netdev);
	kfree(ihost->hwaddress);
	kfree(ihost->initiatorname);
2676
	scsi_host_put(shost);
2677
}
2678
EXPORT_SYMBOL_GPL(iscsi_host_free);
M
Mike Christie 已提交
2679

2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700
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 已提交
2701 2702 2703
/**
 * iscsi_session_setup - create iscsi cls session and host and session
 * @iscsit: iscsi transport template
2704 2705
 * @shost: scsi host
 * @cmds_max: session can queue
2706
 * @cmd_task_size: LLD task private data size
M
Mike Christie 已提交
2707 2708 2709 2710
 * @initial_cmdsn: initial CmdSN
 *
 * This can be used by software iscsi_transports that allocate
 * a session per scsi host.
2711 2712 2713 2714
 *
 * 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.
2715
 */
M
Mike Christie 已提交
2716
struct iscsi_cls_session *
2717
iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost,
2718
		    uint16_t cmds_max, int dd_size, int cmd_task_size,
2719
		    uint32_t initial_cmdsn, unsigned int id)
M
Mike Christie 已提交
2720
{
2721
	struct iscsi_host *ihost = shost_priv(shost);
M
Mike Christie 已提交
2722 2723
	struct iscsi_session *session;
	struct iscsi_cls_session *cls_session;
2724
	int cmd_i, scsi_cmds, total_cmds = cmds_max;
2725 2726 2727 2728 2729 2730 2731 2732 2733
	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);
2734 2735 2736

	if (!total_cmds)
		total_cmds = ISCSI_DEF_XMIT_CMDS_MAX;
2737
	/*
2738 2739 2740
	 * 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.
2741
	 */
2742 2743 2744 2745
	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);
2746
		goto dec_session_count;
2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763
	}

	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);
2764
	}
2765
	scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX;
2766

2767
	cls_session = iscsi_alloc_session(shost, iscsit,
2768 2769
					  sizeof(struct iscsi_session) +
					  dd_size);
2770
	if (!cls_session)
2771
		goto dec_session_count;
2772 2773
	session = cls_session->dd_data;
	session->cls_session = cls_session;
M
Mike Christie 已提交
2774 2775
	session->host = shost;
	session->state = ISCSI_STATE_FREE;
2776
	session->fast_abort = 1;
2777
	session->tgt_reset_timeout = 30;
2778 2779
	session->lu_reset_timeout = 15;
	session->abort_timeout = 10;
2780 2781
	session->scsi_cmds_max = scsi_cmds;
	session->cmds_max = total_cmds;
2782
	session->queued_cmdsn = session->cmdsn = initial_cmdsn;
M
Mike Christie 已提交
2783 2784 2785 2786
	session->exp_cmdsn = initial_cmdsn + 1;
	session->max_cmdsn = initial_cmdsn + 1;
	session->max_r2t = 1;
	session->tt = iscsit;
2787
	session->dd_data = cls_session->dd_data + sizeof(*session);
2788

2789
	mutex_init(&session->eh_mutex);
2790 2791
	spin_lock_init(&session->frwd_lock);
	spin_lock_init(&session->back_lock);
M
Mike Christie 已提交
2792 2793 2794 2795

	/* initialize SCSI PDU commands pool */
	if (iscsi_pool_init(&session->cmdpool, session->cmds_max,
			    (void***)&session->cmds,
2796
			    cmd_task_size + sizeof(struct iscsi_task)))
M
Mike Christie 已提交
2797 2798 2799 2800
		goto cmdpool_alloc_fail;

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

2803 2804 2805
		if (cmd_task_size)
			task->dd_data = &task[1];
		task->itt = cmd_i;
2806
		task->state = ISCSI_TASK_FREE;
2807
		INIT_LIST_HEAD(&task->running);
M
Mike Christie 已提交
2808 2809
	}

2810
	if (!try_module_get(iscsit->owner))
2811
		goto module_get_fail;
M
Mike Christie 已提交
2812

2813
	if (iscsi_add_session(cls_session, id))
2814
		goto cls_session_fail;
2815

M
Mike Christie 已提交
2816 2817 2818
	return cls_session;

cls_session_fail:
2819 2820
	module_put(iscsit->owner);
module_get_fail:
2821
	iscsi_pool_free(&session->cmdpool);
M
Mike Christie 已提交
2822
cmdpool_alloc_fail:
2823
	iscsi_free_session(cls_session);
2824 2825
dec_session_count:
	iscsi_host_dec_session_cnt(shost);
M
Mike Christie 已提交
2826 2827 2828 2829 2830 2831
	return NULL;
}
EXPORT_SYMBOL_GPL(iscsi_session_setup);

/**
 * iscsi_session_teardown - destroy session, host, and cls_session
2832
 * @cls_session: iscsi session
M
Mike Christie 已提交
2833
 *
2834 2835 2836
 * The driver must have called iscsi_remove_session before
 * calling this.
 */
M
Mike Christie 已提交
2837 2838
void iscsi_session_teardown(struct iscsi_cls_session *cls_session)
{
2839
	struct iscsi_session *session = cls_session->dd_data;
2840
	struct module *owner = cls_session->transport->owner;
2841
	struct Scsi_Host *shost = session->host;
M
Mike Christie 已提交
2842

2843
	iscsi_pool_free(&session->cmdpool);
M
Mike Christie 已提交
2844

2845 2846 2847 2848
	kfree(session->password);
	kfree(session->password_in);
	kfree(session->username);
	kfree(session->username_in);
2849
	kfree(session->targetname);
2850
	kfree(session->targetalias);
2851
	kfree(session->initiatorname);
2852 2853 2854
	kfree(session->boot_root);
	kfree(session->boot_nic);
	kfree(session->boot_target);
2855
	kfree(session->ifacename);
2856 2857
	kfree(session->portal_type);
	kfree(session->discovery_parent_type);
2858

2859
	iscsi_destroy_session(cls_session);
2860
	iscsi_host_dec_session_cnt(shost);
2861
	module_put(owner);
M
Mike Christie 已提交
2862 2863 2864 2865 2866 2867
}
EXPORT_SYMBOL_GPL(iscsi_session_teardown);

/**
 * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn
 * @cls_session: iscsi_cls_session
2868
 * @dd_size: private driver data size
M
Mike Christie 已提交
2869
 * @conn_idx: cid
2870
 */
M
Mike Christie 已提交
2871
struct iscsi_cls_conn *
2872 2873
iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
		 uint32_t conn_idx)
M
Mike Christie 已提交
2874
{
2875
	struct iscsi_session *session = cls_session->dd_data;
M
Mike Christie 已提交
2876 2877
	struct iscsi_conn *conn;
	struct iscsi_cls_conn *cls_conn;
2878
	char *data;
M
Mike Christie 已提交
2879

2880 2881
	cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size,
				     conn_idx);
M
Mike Christie 已提交
2882 2883 2884
	if (!cls_conn)
		return NULL;
	conn = cls_conn->dd_data;
2885
	memset(conn, 0, sizeof(*conn) + dd_size);
M
Mike Christie 已提交
2886

2887
	conn->dd_data = cls_conn->dd_data + sizeof(*conn);
M
Mike Christie 已提交
2888 2889 2890 2891 2892
	conn->session = session;
	conn->cls_conn = cls_conn;
	conn->c_stage = ISCSI_CONN_INITIAL_STAGE;
	conn->id = conn_idx;
	conn->exp_statsn = 0;
2893
	conn->tmf_state = TMF_INITIAL;
2894 2895 2896 2897 2898

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

2899
	INIT_LIST_HEAD(&conn->mgmtqueue);
2900
	INIT_LIST_HEAD(&conn->cmdqueue);
2901
	INIT_LIST_HEAD(&conn->requeue);
D
David Howells 已提交
2902
	INIT_WORK(&conn->xmitwork, iscsi_xmitworker);
M
Mike Christie 已提交
2903

2904
	/* allocate login_task used for the login/text sequences */
2905
	spin_lock_bh(&session->frwd_lock);
2906
	if (!kfifo_out(&session->cmdpool.queue,
2907
                         (void*)&conn->login_task,
M
Mike Christie 已提交
2908
			 sizeof(void*))) {
2909
		spin_unlock_bh(&session->frwd_lock);
2910
		goto login_task_alloc_fail;
M
Mike Christie 已提交
2911
	}
2912
	spin_unlock_bh(&session->frwd_lock);
M
Mike Christie 已提交
2913

2914 2915
	data = (char *) __get_free_pages(GFP_KERNEL,
					 get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
2916
	if (!data)
2917 2918
		goto login_task_data_alloc_fail;
	conn->login_task->data = conn->data = data;
2919

2920
	init_timer(&conn->tmf_timer);
M
Mike Christie 已提交
2921 2922 2923 2924
	init_waitqueue_head(&conn->ehwait);

	return cls_conn;

2925
login_task_data_alloc_fail:
2926
	kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
2927
		    sizeof(void*));
2928
login_task_alloc_fail:
M
Mike Christie 已提交
2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945
	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;

2946 2947
	del_timer_sync(&conn->transport_timer);

2948
	mutex_lock(&session->eh_mutex);
2949
	spin_lock_bh(&session->frwd_lock);
M
Mike Christie 已提交
2950 2951 2952 2953 2954 2955 2956 2957
	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);
	}
2958
	spin_unlock_bh(&session->frwd_lock);
M
Mike Christie 已提交
2959

2960
	/* flush queued up work because we free the connection below */
2961
	iscsi_suspend_tx(conn);
2962

2963
	spin_lock_bh(&session->frwd_lock);
2964 2965
	free_pages((unsigned long) conn->data,
		   get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
2966
	kfree(conn->persistent_address);
2967
	kfree(conn->local_ipaddr);
2968 2969
	/* regular RX path uses back_lock */
	spin_lock_bh(&session->back_lock);
2970
	kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
M
Mike Christie 已提交
2971
		    sizeof(void*));
2972
	spin_unlock_bh(&session->back_lock);
2973
	if (session->leadconn == conn)
M
Mike Christie 已提交
2974
		session->leadconn = NULL;
2975
	spin_unlock_bh(&session->frwd_lock);
2976
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
2977 2978 2979 2980 2981 2982 2983 2984 2985 2986

	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;

2987
	if (!session) {
2988 2989
		iscsi_conn_printk(KERN_ERR, conn,
				  "can't start unbound connection\n");
M
Mike Christie 已提交
2990 2991 2992
		return -EPERM;
	}

2993 2994
	if ((session->imm_data_en || !session->initial_r2t_en) &&
	     session->first_burst > session->max_burst) {
2995 2996 2997
		iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: "
				  "first_burst %d max_burst %d\n",
				  session->first_burst, session->max_burst);
2998 2999 3000
		return -EINVAL;
	}

3001
	if (conn->ping_timeout && !conn->recv_timeout) {
3002 3003
		iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of "
				  "zero. Using 5 seconds\n.");
3004 3005 3006 3007
		conn->recv_timeout = 5;
	}

	if (conn->recv_timeout && !conn->ping_timeout) {
3008 3009
		iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of "
				  "zero. Using 5 seconds.\n");
3010 3011 3012
		conn->ping_timeout = 5;
	}

3013
	spin_lock_bh(&session->frwd_lock);
M
Mike Christie 已提交
3014 3015
	conn->c_stage = ISCSI_CONN_STARTED;
	session->state = ISCSI_STATE_LOGGED_IN;
3016
	session->queued_cmdsn = session->cmdsn;
M
Mike Christie 已提交
3017

3018 3019 3020 3021 3022 3023
	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 已提交
3024 3025 3026 3027 3028 3029 3030
	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;
3031
		conn->tmf_state = TMF_INITIAL;
M
Mike Christie 已提交
3032
		session->age++;
3033 3034
		if (session->age == 16)
			session->age = 0;
3035
		break;
M
Mike Christie 已提交
3036 3037 3038 3039 3040 3041
	case STOP_CONN_TERM:
		conn->stop_stage = 0;
		break;
	default:
		break;
	}
3042
	spin_unlock_bh(&session->frwd_lock);
M
Mike Christie 已提交
3043

3044
	iscsi_unblock_session(session->cls_session);
3045
	wake_up(&conn->ehwait);
M
Mike Christie 已提交
3046 3047 3048 3049 3050
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_conn_start);

static void
3051
fail_mgmt_tasks(struct iscsi_session *session, struct iscsi_conn *conn)
M
Mike Christie 已提交
3052
{
3053
	struct iscsi_task *task;
3054
	int i, state;
M
Mike Christie 已提交
3055

3056 3057 3058 3059
	for (i = 0; i < conn->session->cmds_max; i++) {
		task = conn->session->cmds[i];
		if (task->sc)
			continue;
M
Mike Christie 已提交
3060

3061 3062
		if (task->state == ISCSI_TASK_FREE)
			continue;
M
Mike Christie 已提交
3063

3064 3065 3066
		ISCSI_DBG_SESSION(conn->session,
				  "failing mgmt itt 0x%x state %d\n",
				  task->itt, task->state);
3067 3068 3069 3070 3071
		state = ISCSI_TASK_ABRT_SESS_RECOV;
		if (task->state == ISCSI_TASK_PENDING)
			state = ISCSI_TASK_COMPLETED;
		iscsi_complete_task(task, state);

3072
	}
M
Mike Christie 已提交
3073 3074
}

3075 3076
static void iscsi_start_session_recovery(struct iscsi_session *session,
					 struct iscsi_conn *conn, int flag)
M
Mike Christie 已提交
3077
{
3078 3079
	int old_stop_stage;

3080
	mutex_lock(&session->eh_mutex);
3081
	spin_lock_bh(&session->frwd_lock);
3082
	if (conn->stop_stage == STOP_CONN_TERM) {
3083
		spin_unlock_bh(&session->frwd_lock);
3084 3085 3086 3087
		mutex_unlock(&session->eh_mutex);
		return;
	}

3088 3089
	/*
	 * When this is called for the in_login state, we only want to clean
3090
	 * up the login task and connection. We do not need to block and set
3091
	 * the recovery state again
3092
	 */
3093 3094 3095 3096
	if (flag == STOP_CONN_TERM)
		session->state = ISCSI_STATE_TERMINATE;
	else if (conn->stop_stage != STOP_CONN_RECOVER)
		session->state = ISCSI_STATE_IN_RECOVERY;
3097 3098 3099

	old_stop_stage = conn->stop_stage;
	conn->stop_stage = flag;
3100
	spin_unlock_bh(&session->frwd_lock);
3101

3102 3103 3104
	del_timer_sync(&conn->transport_timer);
	iscsi_suspend_tx(conn);

3105
	spin_lock_bh(&session->frwd_lock);
3106
	conn->c_stage = ISCSI_CONN_STOPPED;
3107
	spin_unlock_bh(&session->frwd_lock);
3108

M
Mike Christie 已提交
3109 3110 3111 3112 3113 3114 3115 3116 3117
	/*
	 * 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;
3118
		if (session->state == ISCSI_STATE_IN_RECOVERY &&
3119
		    old_stop_stage != STOP_CONN_RECOVER) {
3120
			ISCSI_DBG_SESSION(session, "blocking session\n");
3121
			iscsi_block_session(session->cls_session);
3122
		}
M
Mike Christie 已提交
3123
	}
3124 3125 3126 3127

	/*
	 * flush queues.
	 */
3128
	spin_lock_bh(&session->frwd_lock);
3129
	fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED);
3130
	fail_mgmt_tasks(session, conn);
3131
	memset(&conn->tmhdr, 0, sizeof(conn->tmhdr));
3132
	spin_unlock_bh(&session->frwd_lock);
3133
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144
}

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);
3145
		break;
M
Mike Christie 已提交
3146
	default:
3147 3148
		iscsi_conn_printk(KERN_ERR, conn,
				  "invalid stop flag %d\n", flag);
M
Mike Christie 已提交
3149 3150 3151 3152 3153 3154 3155
	}
}
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)
{
3156
	struct iscsi_session *session = cls_session->dd_data;
3157
	struct iscsi_conn *conn = cls_conn->dd_data;
M
Mike Christie 已提交
3158

3159
	spin_lock_bh(&session->frwd_lock);
M
Mike Christie 已提交
3160 3161
	if (is_leading)
		session->leadconn = conn;
3162
	spin_unlock_bh(&session->frwd_lock);
M
Mike Christie 已提交
3163 3164 3165 3166 3167 3168 3169 3170 3171 3172

	/*
	 * 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);

3173
int iscsi_switch_str_param(char **param, char *new_val_buf)
3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189
{
	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;
}
3190
EXPORT_SYMBOL_GPL(iscsi_switch_str_param);
3191 3192 3193 3194 3195 3196

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;
3197
	int val;
3198 3199

	switch(param) {
3200 3201 3202
	case ISCSI_PARAM_FAST_ABORT:
		sscanf(buf, "%d", &session->fast_abort);
		break;
3203 3204 3205 3206 3207 3208
	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;
3209 3210 3211
	case ISCSI_PARAM_TGT_RESET_TMO:
		sscanf(buf, "%d", &session->tgt_reset_timeout);
		break;
3212 3213 3214 3215 3216 3217
	case ISCSI_PARAM_PING_TMO:
		sscanf(buf, "%d", &conn->ping_timeout);
		break;
	case ISCSI_PARAM_RECV_TMO:
		sscanf(buf, "%d", &conn->recv_timeout);
		break;
3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233
	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:
3234
		sscanf(buf, "%hu", &session->max_r2t);
3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250 3251 3252 3253 3254 3255 3256
		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_EXP_STATSN:
		sscanf(buf, "%u", &conn->exp_statsn);
		break;
3257
	case ISCSI_PARAM_USERNAME:
3258
		return iscsi_switch_str_param(&session->username, buf);
3259
	case ISCSI_PARAM_USERNAME_IN:
3260
		return iscsi_switch_str_param(&session->username_in, buf);
3261
	case ISCSI_PARAM_PASSWORD:
3262
		return iscsi_switch_str_param(&session->password, buf);
3263
	case ISCSI_PARAM_PASSWORD_IN:
3264
		return iscsi_switch_str_param(&session->password_in, buf);
3265
	case ISCSI_PARAM_TARGET_NAME:
3266
		return iscsi_switch_str_param(&session->targetname, buf);
3267 3268
	case ISCSI_PARAM_TARGET_ALIAS:
		return iscsi_switch_str_param(&session->targetalias, buf);
3269 3270 3271 3272 3273 3274 3275
	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:
3276
		return iscsi_switch_str_param(&conn->persistent_address, buf);
3277
	case ISCSI_PARAM_IFACE_NAME:
3278
		return iscsi_switch_str_param(&session->ifacename, buf);
3279
	case ISCSI_PARAM_INITIATOR_NAME:
3280
		return iscsi_switch_str_param(&session->initiatorname, buf);
3281 3282 3283 3284 3285 3286
	case ISCSI_PARAM_BOOT_ROOT:
		return iscsi_switch_str_param(&session->boot_root, buf);
	case ISCSI_PARAM_BOOT_NIC:
		return iscsi_switch_str_param(&session->boot_nic, buf);
	case ISCSI_PARAM_BOOT_TARGET:
		return iscsi_switch_str_param(&session->boot_target, buf);
3287 3288 3289 3290 3291
	case ISCSI_PARAM_PORTAL_TYPE:
		return iscsi_switch_str_param(&session->portal_type, buf);
	case ISCSI_PARAM_DISCOVERY_PARENT_TYPE:
		return iscsi_switch_str_param(&session->discovery_parent_type,
					      buf);
3292 3293 3294 3295
	case ISCSI_PARAM_DISCOVERY_SESS:
		sscanf(buf, "%d", &val);
		session->discovery_sess = !!val;
		break;
3296 3297
	case ISCSI_PARAM_LOCAL_IPADDR:
		return iscsi_switch_str_param(&conn->local_ipaddr, buf);
3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308
	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)
{
3309
	struct iscsi_session *session = cls_session->dd_data;
3310 3311 3312
	int len;

	switch(param) {
3313 3314 3315
	case ISCSI_PARAM_FAST_ABORT:
		len = sprintf(buf, "%d\n", session->fast_abort);
		break;
3316 3317 3318 3319 3320 3321
	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;
3322 3323 3324
	case ISCSI_PARAM_TGT_RESET_TMO:
		len = sprintf(buf, "%d\n", session->tgt_reset_timeout);
		break;
3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345
	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;
3346 3347 3348
	case ISCSI_PARAM_DEF_TASKMGMT_TMO:
		len = sprintf(buf, "%d\n", session->def_taskmgmt_tmo);
		break;
3349 3350 3351 3352 3353 3354
	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;
3355 3356 3357
	case ISCSI_PARAM_TARGET_ALIAS:
		len = sprintf(buf, "%s\n", session->targetalias);
		break;
3358 3359 3360
	case ISCSI_PARAM_TPGT:
		len = sprintf(buf, "%d\n", session->tpgt);
		break;
3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372
	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;
3373 3374 3375 3376
	case ISCSI_PARAM_IFACE_NAME:
		len = sprintf(buf, "%s\n", session->ifacename);
		break;
	case ISCSI_PARAM_INITIATOR_NAME:
3377
		len = sprintf(buf, "%s\n", session->initiatorname);
3378
		break;
3379 3380 3381 3382 3383 3384 3385 3386
	case ISCSI_PARAM_BOOT_ROOT:
		len = sprintf(buf, "%s\n", session->boot_root);
		break;
	case ISCSI_PARAM_BOOT_NIC:
		len = sprintf(buf, "%s\n", session->boot_nic);
		break;
	case ISCSI_PARAM_BOOT_TARGET:
		len = sprintf(buf, "%s\n", session->boot_target);
3387
		break;
3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432
	case ISCSI_PARAM_AUTO_SND_TGT_DISABLE:
		len = sprintf(buf, "%u\n", session->auto_snd_tgt_disable);
		break;
	case ISCSI_PARAM_DISCOVERY_SESS:
		len = sprintf(buf, "%u\n", session->discovery_sess);
		break;
	case ISCSI_PARAM_PORTAL_TYPE:
		len = sprintf(buf, "%s\n", session->portal_type);
		break;
	case ISCSI_PARAM_CHAP_AUTH_EN:
		len = sprintf(buf, "%u\n", session->chap_auth_en);
		break;
	case ISCSI_PARAM_DISCOVERY_LOGOUT_EN:
		len = sprintf(buf, "%u\n", session->discovery_logout_en);
		break;
	case ISCSI_PARAM_BIDI_CHAP_EN:
		len = sprintf(buf, "%u\n", session->bidi_chap_en);
		break;
	case ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL:
		len = sprintf(buf, "%u\n", session->discovery_auth_optional);
		break;
	case ISCSI_PARAM_DEF_TIME2WAIT:
		len = sprintf(buf, "%d\n", session->time2wait);
		break;
	case ISCSI_PARAM_DEF_TIME2RETAIN:
		len = sprintf(buf, "%d\n", session->time2retain);
		break;
	case ISCSI_PARAM_TSID:
		len = sprintf(buf, "%u\n", session->tsid);
		break;
	case ISCSI_PARAM_ISID:
		len = sprintf(buf, "%02x%02x%02x%02x%02x%02x\n",
			      session->isid[0], session->isid[1],
			      session->isid[2], session->isid[3],
			      session->isid[4], session->isid[5]);
		break;
	case ISCSI_PARAM_DISCOVERY_PARENT_IDX:
		len = sprintf(buf, "%u\n", session->discovery_parent_idx);
		break;
	case ISCSI_PARAM_DISCOVERY_PARENT_TYPE:
		if (session->discovery_parent_type)
			len = sprintf(buf, "%s\n",
				      session->discovery_parent_type);
		else
			len = sprintf(buf, "\n");
3433
		break;
3434 3435 3436 3437 3438 3439 3440 3441
	default:
		return -ENOSYS;
	}

	return len;
}
EXPORT_SYMBOL_GPL(iscsi_session_get_param);

3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468
int iscsi_conn_get_addr_param(struct sockaddr_storage *addr,
			      enum iscsi_param param, char *buf)
{
	struct sockaddr_in6 *sin6 = NULL;
	struct sockaddr_in *sin = NULL;
	int len;

	switch (addr->ss_family) {
	case AF_INET:
		sin = (struct sockaddr_in *)addr;
		break;
	case AF_INET6:
		sin6 = (struct sockaddr_in6 *)addr;
		break;
	default:
		return -EINVAL;
	}

	switch (param) {
	case ISCSI_PARAM_CONN_ADDRESS:
	case ISCSI_HOST_PARAM_IPADDRESS:
		if (sin)
			len = sprintf(buf, "%pI4\n", &sin->sin_addr.s_addr);
		else
			len = sprintf(buf, "%pI6\n", &sin6->sin6_addr);
		break;
	case ISCSI_PARAM_CONN_PORT:
3469
	case ISCSI_PARAM_LOCAL_PORT:
3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483
		if (sin)
			len = sprintf(buf, "%hu\n", be16_to_cpu(sin->sin_port));
		else
			len = sprintf(buf, "%hu\n",
				      be16_to_cpu(sin6->sin6_port));
		break;
	default:
		return -EINVAL;
	}

	return len;
}
EXPORT_SYMBOL_GPL(iscsi_conn_get_addr_param);

3484 3485 3486 3487 3488 3489 3490
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) {
3491 3492 3493 3494 3495 3496
	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;
3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523
	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;
3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559
	case ISCSI_PARAM_STATSN:
		len = sprintf(buf, "%u\n", conn->statsn);
		break;
	case ISCSI_PARAM_MAX_SEGMENT_SIZE:
		len = sprintf(buf, "%u\n", conn->max_segment_size);
		break;
	case ISCSI_PARAM_KEEPALIVE_TMO:
		len = sprintf(buf, "%u\n", conn->keepalive_tmo);
		break;
	case ISCSI_PARAM_LOCAL_PORT:
		len = sprintf(buf, "%u\n", conn->local_port);
		break;
	case ISCSI_PARAM_TCP_TIMESTAMP_STAT:
		len = sprintf(buf, "%u\n", conn->tcp_timestamp_stat);
		break;
	case ISCSI_PARAM_TCP_NAGLE_DISABLE:
		len = sprintf(buf, "%u\n", conn->tcp_nagle_disable);
		break;
	case ISCSI_PARAM_TCP_WSF_DISABLE:
		len = sprintf(buf, "%u\n", conn->tcp_wsf_disable);
		break;
	case ISCSI_PARAM_TCP_TIMER_SCALE:
		len = sprintf(buf, "%u\n", conn->tcp_timer_scale);
		break;
	case ISCSI_PARAM_TCP_TIMESTAMP_EN:
		len = sprintf(buf, "%u\n", conn->tcp_timestamp_en);
		break;
	case ISCSI_PARAM_IP_FRAGMENT_DISABLE:
		len = sprintf(buf, "%u\n", conn->fragment_disable);
		break;
	case ISCSI_PARAM_IPV4_TOS:
		len = sprintf(buf, "%u\n", conn->ipv4_tos);
		break;
	case ISCSI_PARAM_IPV6_TC:
		len = sprintf(buf, "%u\n", conn->ipv6_traffic_class);
		break;
3560 3561 3562
	case ISCSI_PARAM_IPV6_FLOW_LABEL:
		len = sprintf(buf, "%u\n", conn->ipv6_flow_label);
		break;
3563 3564 3565 3566 3567 3568 3569 3570 3571
	case ISCSI_PARAM_IS_FW_ASSIGNED_IPV6:
		len = sprintf(buf, "%u\n", conn->is_fw_assigned_ipv6);
		break;
	case ISCSI_PARAM_TCP_XMIT_WSF:
		len = sprintf(buf, "%u\n", conn->tcp_xmit_wsf);
		break;
	case ISCSI_PARAM_TCP_RECV_WSF:
		len = sprintf(buf, "%u\n", conn->tcp_recv_wsf);
		break;
3572 3573 3574
	case ISCSI_PARAM_LOCAL_IPADDR:
		len = sprintf(buf, "%s\n", conn->local_ipaddr);
		break;
3575 3576 3577 3578 3579 3580 3581 3582
	default:
		return -ENOSYS;
	}

	return len;
}
EXPORT_SYMBOL_GPL(iscsi_conn_get_param);

3583 3584 3585
int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param,
			 char *buf)
{
3586
	struct iscsi_host *ihost = shost_priv(shost);
3587 3588 3589
	int len;

	switch (param) {
3590
	case ISCSI_HOST_PARAM_NETDEV_NAME:
3591
		len = sprintf(buf, "%s\n", ihost->netdev);
3592
		break;
3593
	case ISCSI_HOST_PARAM_HWADDRESS:
3594
		len = sprintf(buf, "%s\n", ihost->hwaddress);
3595
		break;
3596
	case ISCSI_HOST_PARAM_INITIATOR_NAME:
3597
		len = sprintf(buf, "%s\n", ihost->initiatorname);
3598
		break;
3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609
	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)
{
3610
	struct iscsi_host *ihost = shost_priv(shost);
3611 3612

	switch (param) {
3613
	case ISCSI_HOST_PARAM_NETDEV_NAME:
3614
		return iscsi_switch_str_param(&ihost->netdev, buf);
3615
	case ISCSI_HOST_PARAM_HWADDRESS:
3616
		return iscsi_switch_str_param(&ihost->hwaddress, buf);
3617
	case ISCSI_HOST_PARAM_INITIATOR_NAME:
3618
		return iscsi_switch_str_param(&ihost->initiatorname, buf);
3619 3620 3621 3622 3623 3624 3625 3626
	default:
		return -ENOSYS;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_host_set_param);

M
Mike Christie 已提交
3627 3628 3629
MODULE_AUTHOR("Mike Christie");
MODULE_DESCRIPTION("iSCSI library functions");
MODULE_LICENSE("GPL");