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

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

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

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

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

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

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

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

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

113 114
static void __iscsi_update_cmdsn(struct iscsi_session *session,
				 uint32_t exp_cmdsn, uint32_t max_cmdsn)
M
Mike Christie 已提交
115
{
116 117 118 119 120 121 122 123 124
	/*
	 * 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 已提交
125 126
		session->exp_cmdsn = exp_cmdsn;

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

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

147 148 149 150 151 152 153 154 155 156 157 158 159 160
/**
 * 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 已提交
161
{
162
	struct iscsi_conn *conn = task->conn;
163 164 165
	unsigned int left = r2t->data_length - r2t->sent;

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

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

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

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

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

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

214
	ecdb_ahdr = iscsi_next_hdr(task);
215 216 217 218 219 220 221
	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);

222
	rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) +
223 224 225 226 227 228 229 230 231 232 233 234
	                   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);

235 236 237 238 239
	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);
240 241 242
	return 0;
}

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

249 250
	rlen_ahdr = iscsi_next_hdr(task);
	rc = iscsi_add_hdr(task, sizeof(*rlen_ahdr));
251 252 253 254 255 256 257 258 259 260
	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);

261 262 263 264 265
	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));
266 267 268
	return 0;
}

269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
/**
 * 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;
	unsigned int hdr_lun;

	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
		 */
		hdr_lun = scsilun_to_int((struct scsi_lun *)tmf->lun);
		if (hdr_lun != task->sc->device->lun)
			return 0;
302 303
		/* fall through */
	case ISCSI_TM_FUNC_TARGET_WARM_RESET:
304 305 306 307 308 309
		/*
		 * Fail all SCSI cmd PDUs
		 */
		if (opcode != ISCSI_OP_SCSI_DATA_OUT) {
			iscsi_conn_printk(KERN_INFO, conn,
					  "task [op %x/%x itt "
310
					  "0x%x/0x%x] "
311 312
					  "rejected.\n",
					  task->hdr->opcode, opcode,
313
					  task->itt, task->hdr_itt);
314 315 316 317 318 319 320 321 322
			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 "
323
					  "0x%x/0x%x] fast abort.\n",
324
					  task->hdr->opcode, opcode,
325
					  task->itt, task->hdr_itt);
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
			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 已提交
351 352
/**
 * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu
353
 * @task: iscsi task
M
Mike Christie 已提交
354 355 356 357
 *
 * 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
 */
358
static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
M
Mike Christie 已提交
359
{
360
	struct iscsi_conn *conn = task->conn;
M
Mike Christie 已提交
361
	struct iscsi_session *session = conn->session;
362
	struct scsi_cmnd *sc = task->sc;
363
	struct iscsi_cmd *hdr;
364
	unsigned hdrlength, cmd_len;
365
	itt_t itt;
366
	int rc;
M
Mike Christie 已提交
367

368 369 370 371
	rc = iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_CMD);
	if (rc)
		return rc;

372 373 374 375 376
	if (conn->session->tt->alloc_pdu) {
		rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD);
		if (rc)
			return rc;
	}
377
	hdr = (struct iscsi_cmd *) task->hdr;
378
	itt = hdr->itt;
379 380
	memset(hdr, 0, sizeof(*hdr));

381 382 383 384 385
	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);
386 387
	task->hdr_len = 0;
	rc = iscsi_add_hdr(task, sizeof(*hdr));
388 389
	if (rc)
		return rc;
390 391 392
	hdr->opcode = ISCSI_OP_SCSI_CMD;
	hdr->flags = ISCSI_ATTR_SIMPLE;
	int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun);
393
	memcpy(task->lun, hdr->lun, sizeof(task->lun));
394
	hdr->exp_statsn = cpu_to_be32(conn->exp_statsn);
395 396 397 398
	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) {
399
		rc = iscsi_prep_ecdb_ahs(task);
400 401 402 403 404
		if (rc)
			return rc;
		cmd_len = ISCSI_CDB_SIZE;
	}
	memcpy(hdr->cdb, sc->cmnd, cmd_len);
M
Mike Christie 已提交
405

406
	task->imm_count = 0;
407 408
	if (scsi_bidi_cmnd(sc)) {
		hdr->flags |= ISCSI_FLAG_CMD_READ;
409
		rc = iscsi_prep_bidi_ahs(task);
410 411 412
		if (rc)
			return rc;
	}
M
Mike Christie 已提交
413
	if (sc->sc_data_direction == DMA_TO_DEVICE) {
414
		unsigned out_len = scsi_out(sc)->length;
415 416
		struct iscsi_r2t_info *r2t = &task->unsol_r2t;

417
		hdr->data_length = cpu_to_be32(out_len);
M
Mike Christie 已提交
418 419 420 421 422 423 424 425 426 427 428
		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
		 *
429
		 *	r2t data_length bytes to be sent via R2T ack's
M
Mike Christie 已提交
430 431 432
		 *
		 *      pad_count       bytes to be sent as zero-padding
		 */
433
		memset(r2t, 0, sizeof(*r2t));
M
Mike Christie 已提交
434 435

		if (session->imm_data_en) {
436
			if (out_len >= session->first_burst)
437
				task->imm_count = min(session->first_burst,
M
Mike Christie 已提交
438 439
							conn->max_xmit_dlength);
			else
440
				task->imm_count = min(out_len,
M
Mike Christie 已提交
441
							conn->max_xmit_dlength);
442
			hton24(hdr->dlength, task->imm_count);
M
Mike Christie 已提交
443
		} else
444
			zero_data(hdr->dlength);
M
Mike Christie 已提交
445

446
		if (!session->initial_r2t_en) {
447 448 449 450 451
			r2t->data_length = min(session->first_burst, out_len) -
					       task->imm_count;
			r2t->data_offset = task->imm_count;
			r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG);
			r2t->exp_statsn = cpu_to_be32(conn->exp_statsn);
452 453
		}

454
		if (!task->unsol_r2t.data_length)
M
Mike Christie 已提交
455
			/* No unsolicit Data-Out's */
456
			hdr->flags |= ISCSI_FLAG_CMD_FINAL;
M
Mike Christie 已提交
457 458 459
	} else {
		hdr->flags |= ISCSI_FLAG_CMD_FINAL;
		zero_data(hdr->dlength);
460
		hdr->data_length = cpu_to_be32(scsi_in(sc)->length);
M
Mike Christie 已提交
461 462 463 464 465

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

466
	/* calculate size of additional header segments (AHSs) */
467
	hdrlength = task->hdr_len - sizeof(*hdr);
468 469 470 471 472 473

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

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

476
	if (session->tt->init_task && session->tt->init_task(task))
477 478
		return -EIO;

479
	task->state = ISCSI_TASK_RUNNING;
480
	session->cmdsn++;
481

482
	conn->scsicmd_pdus_cnt++;
483 484 485 486 487 488 489 490 491
	ISCSI_DBG_SESSION(session, "iscsi prep [%s cid %d sc %p cdb 0x%x "
			  "itt 0x%x len %d bidi_len %d cmdsn %d win %d]\n",
			  scsi_bidi_cmnd(sc) ? "bidirectional" :
			  sc->sc_data_direction == DMA_TO_DEVICE ?
			  "write" : "read", conn->id, sc, sc->cmnd[0],
			  task->itt, scsi_bufflen(sc),
			  scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0,
			  session->cmdsn,
			  session->max_cmdsn - session->exp_cmdsn + 1);
492
	return 0;
M
Mike Christie 已提交
493 494 495
}

/**
496
 * iscsi_free_task - free a task
497
 * @task: iscsi cmd task
M
Mike Christie 已提交
498 499
 *
 * Must be called with session lock.
500 501
 * This function returns the scsi command to scsi-ml or cleans
 * up mgmt tasks then returns the task to the pool.
M
Mike Christie 已提交
502
 */
503
static void iscsi_free_task(struct iscsi_task *task)
M
Mike Christie 已提交
504
{
505
	struct iscsi_conn *conn = task->conn;
506
	struct iscsi_session *session = conn->session;
507
	struct scsi_cmnd *sc = task->sc;
508
	int oldstate = task->state;
M
Mike Christie 已提交
509

510 511 512
	ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n",
			  task->itt, task->state, task->sc);

513
	session->tt->cleanup_task(task);
514
	task->state = ISCSI_TASK_FREE;
515
	task->sc = NULL;
516
	/*
517
	 * login task is preallocated so do not free
518
	 */
519
	if (conn->login_task == task)
520 521
		return;

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

524
	if (sc) {
525
		task->sc = NULL;
526 527 528
		/* SCSI eh reuses commands to verify us */
		sc->SCp.ptr = NULL;
		/*
529 530
		 * queue command may call this to free the task, so
		 * it will decide how to return sc to scsi-ml.
531
		 */
532
		if (oldstate != ISCSI_TASK_REQUEUE_SCSIQ)
533 534
			sc->scsi_done(sc);
	}
M
Mike Christie 已提交
535 536
}

537
void __iscsi_get_task(struct iscsi_task *task)
538
{
539
	atomic_inc(&task->refcount);
540
}
541
EXPORT_SYMBOL_GPL(__iscsi_get_task);
542

543
void __iscsi_put_task(struct iscsi_task *task)
544
{
545
	if (atomic_dec_and_test(&task->refcount))
546
		iscsi_free_task(task);
547
}
548
EXPORT_SYMBOL_GPL(__iscsi_put_task);
549

550
void iscsi_put_task(struct iscsi_task *task)
551
{
552
	struct iscsi_session *session = task->conn->session;
553 554

	spin_lock_bh(&session->lock);
555
	__iscsi_put_task(task);
556 557
	spin_unlock_bh(&session->lock);
}
558
EXPORT_SYMBOL_GPL(iscsi_put_task);
559

560 561 562
/**
 * iscsi_complete_task - finish a task
 * @task: iscsi cmd task
563
 * @state: state to complete task with
564 565 566
 *
 * Must be called with session lock.
 */
567
static void iscsi_complete_task(struct iscsi_task *task, int state)
568 569 570
{
	struct iscsi_conn *conn = task->conn;

571 572 573
	ISCSI_DBG_SESSION(conn->session,
			  "complete task itt 0x%x state %d sc %p\n",
			  task->itt, task->state, task->sc);
574 575
	if (task->state == ISCSI_TASK_COMPLETED ||
	    task->state == ISCSI_TASK_ABRT_TMF ||
576 577
	    task->state == ISCSI_TASK_ABRT_SESS_RECOV ||
	    task->state == ISCSI_TASK_REQUEUE_SCSIQ)
578 579
		return;
	WARN_ON_ONCE(task->state == ISCSI_TASK_FREE);
580
	task->state = state;
581 582 583 584 585 586 587 588 589 590 591 592 593 594

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

595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619
/**
 * iscsi_complete_scsi_task - finish scsi task normally
 * @task: iscsi task for scsi cmd
 * @exp_cmdsn: expected cmd sn in cpu format
 * @max_cmdsn: max cmd sn in cpu format
 *
 * This is used when drivers do not need or cannot perform
 * lower level pdu processing.
 *
 * Called with session lock
 */
void iscsi_complete_scsi_task(struct iscsi_task *task,
			      uint32_t exp_cmdsn, uint32_t max_cmdsn)
{
	struct iscsi_conn *conn = task->conn;

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

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


620
/*
621 622 623
 * session lock must be held and if not called for a task that is
 * still pending or from the xmit thread, then xmit thread must
 * be suspended.
624
 */
625
static void fail_scsi_task(struct iscsi_task *task, int err)
626
{
627
	struct iscsi_conn *conn = task->conn;
628
	struct scsi_cmnd *sc;
629
	int state;
630

631 632 633 634 635
	/*
	 * 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.
	 */
636
	sc = task->sc;
637 638 639
	if (!sc)
		return;

640
	if (task->state == ISCSI_TASK_PENDING) {
641 642 643 644 645
		/*
		 * cmd never made it to the xmit thread, so we should not count
		 * the cmd in the sequencing
		 */
		conn->session->queued_cmdsn--;
646 647 648 649 650 651
		/* 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;
652

653
	sc->result = err << 16;
654 655 656 657 658 659
	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;
	}
660

661
	iscsi_complete_task(task, state);
662 663
}

664
static int iscsi_prep_mgmt_task(struct iscsi_conn *conn,
665
				struct iscsi_task *task)
666 667
{
	struct iscsi_session *session = conn->session;
668
	struct iscsi_hdr *hdr = task->hdr;
669
	struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr;
670
	uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK;
671 672 673 674

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

675
	if (opcode != ISCSI_OP_LOGIN && opcode != ISCSI_OP_TEXT)
676 677 678 679 680 681 682
		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) {
		/*
683
		 * TODO: We always use immediate for normal session pdus.
684 685
		 * If we start to send tmfs or nops as non-immediate then
		 * we should start checking the cmdsn numbers for mgmt tasks.
686 687 688
		 *
		 * During discovery sessions iscsid sends TEXT as non immediate,
		 * but we always only send one PDU at a time.
689 690 691 692 693 694 695 696
		 */
		if (conn->c_stage == ISCSI_CONN_STARTED &&
		    !(hdr->opcode & ISCSI_OP_IMMEDIATE)) {
			session->queued_cmdsn++;
			session->cmdsn++;
		}
	}

697 698
	if (session->tt->init_task && session->tt->init_task(task))
		return -EIO;
699 700 701 702

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

703
	task->state = ISCSI_TASK_RUNNING;
704 705 706
	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);
707 708 709
	return 0;
}

710
static struct iscsi_task *
711 712 713 714
__iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
		      char *data, uint32_t data_size)
{
	struct iscsi_session *session = conn->session;
715
	struct iscsi_host *ihost = shost_priv(session->host);
716
	uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK;
717
	struct iscsi_task *task;
718
	itt_t itt;
719 720 721 722

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

723
	if (opcode == ISCSI_OP_LOGIN || opcode == ISCSI_OP_TEXT) {
724 725 726
		/*
		 * Login and Text are sent serially, in
		 * request-followed-by-response sequence.
727 728
		 * Same task can be used. Same ITT must be used.
		 * Note that login_task is preallocated at conn_create().
729
		 */
730 731 732 733 734 735
		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;
		}

736
		task = conn->login_task;
737
	} else {
738 739 740
		if (session->state != ISCSI_STATE_LOGGED_IN)
			return NULL;

741 742 743
		BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE);
		BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED);

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

	if (data_size) {
760 761
		memcpy(task->data, data, data_size);
		task->data_count = data_size;
762
	} else
763
		task->data_count = 0;
764

765 766 767 768
	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");
769
			goto free_task;
770
		}
771
	}
772

773
	itt = task->hdr->itt;
774
	task->hdr_len = sizeof(struct iscsi_hdr);
775
	memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr));
776 777 778 779 780 781 782 783 784

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

785
	if (!ihost->workq) {
786 787
		if (iscsi_prep_mgmt_task(conn, task))
			goto free_task;
788

789
		if (session->tt->xmit_task(task))
790
			goto free_task;
791 792
	} else {
		list_add_tail(&task->running, &conn->mgmtqueue);
793
		iscsi_conn_queue_work(conn);
794
	}
795

796
	return task;
797 798 799 800

free_task:
	__iscsi_put_task(task);
	return NULL;
801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817
}

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

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

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

837
	iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr);
M
Mike Christie 已提交
838 839 840 841 842 843 844 845 846 847
	conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1;

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

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

	if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) {
848
		uint16_t senselen;
M
Mike Christie 已提交
849 850 851

		if (datalen < 2) {
invalid_datalen:
852 853 854
			iscsi_conn_printk(KERN_ERR,  conn,
					 "Got CHECK_CONDITION but invalid data "
					 "buffer size of %d\n", datalen);
M
Mike Christie 已提交
855 856 857 858
			sc->result = DID_BAD_TARGET << 16;
			goto out;
		}

859
		senselen = get_unaligned_be16(data);
M
Mike Christie 已提交
860 861 862 863
		if (datalen < senselen)
			goto invalid_datalen;

		memcpy(sc->sense_buffer, data + 2,
864
		       min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE));
865 866 867
		ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n",
				  min_t(uint16_t, senselen,
				  SCSI_SENSE_BUFFERSIZE));
M
Mike Christie 已提交
868 869
	}

870 871 872 873 874 875 876 877 878 879 880 881
	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;
	}

882 883
	if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW |
	                   ISCSI_FLAG_CMD_OVERFLOW)) {
M
Mike Christie 已提交
884 885
		int res_count = be32_to_cpu(rhdr->residual_count);

886 887 888
		if (res_count > 0 &&
		    (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW ||
		     res_count <= scsi_bufflen(sc)))
889
			/* write side for bidi or uni-io set_resid */
890
			scsi_set_resid(sc, res_count);
M
Mike Christie 已提交
891 892
		else
			sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
893
	}
M
Mike Christie 已提交
894
out:
895
	ISCSI_DBG_SESSION(session, "cmd rsp done [sc %p res %d itt 0x%x]\n",
896
			  sc, sc->result, task->itt);
M
Mike Christie 已提交
897
	conn->scsirsp_pdus_cnt++;
898
	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
M
Mike Christie 已提交
899 900
}

901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916
/**
 * 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;

917
	iscsi_update_cmdsn(conn->session, (struct iscsi_nopin *)hdr);
918 919 920 921 922 923 924 925 926 927 928 929 930 931
	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;
	}

932 933 934
	ISCSI_DBG_SESSION(conn->session, "data in with status done "
			  "[sc %p res %d itt 0x%x]\n",
			  sc, sc->result, task->itt);
935
	conn->scsirsp_pdus_cnt++;
936
	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
937 938
}

939 940 941 942 943 944 945
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++;

946
	if (conn->tmf_state != TMF_QUEUED)
947 948 949
		return;

	if (tmf->response == ISCSI_TMF_RSP_COMPLETE)
950
		conn->tmf_state = TMF_SUCCESS;
951
	else if (tmf->response == ISCSI_TMF_RSP_NO_TASK)
952
		conn->tmf_state = TMF_NOT_FOUND;
953
	else
954
		conn->tmf_state = TMF_FAILED;
955 956 957
	wake_up(&conn->ehwait);
}

958 959 960
static void iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr)
{
        struct iscsi_nopout hdr;
961
	struct iscsi_task *task;
962

963
	if (!rhdr && conn->ping_task)
964 965 966 967 968 969 970 971 972 973 974 975 976
		return;

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

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

977 978
	task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0);
	if (!task)
979
		iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n");
980 981 982 983 984
	else if (!rhdr) {
		/* only track our nops */
		conn->ping_task = task;
		conn->last_ping = jiffies;
	}
985 986
}

987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006
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;
}

1007 1008 1009 1010 1011
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;
1012
	int opcode, rc = 0;
1013 1014 1015

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

1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
	if (ntoh24(reject->dlength) > datalen ||
	    ntoh24(reject->dlength) < sizeof(struct iscsi_hdr)) {
		iscsi_conn_printk(KERN_ERR, conn, "Cannot handle rejected "
				  "pdu. Invalid data length (pdu dlength "
				  "%u, datalen %d\n", ntoh24(reject->dlength),
				  datalen);
		return ISCSI_ERR_PROTO;
	}
	memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr));
	opcode = rejected_pdu.opcode & ISCSI_OPCODE_MASK;

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

1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072
		 if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG))
			/*
			 * nop-out in response to target's nop-out rejected.
			 * Just resend.
			 */
			iscsi_send_nopout(conn,
					  (struct iscsi_nopin*)&rejected_pdu);
		else {
			struct iscsi_task *task;
			/*
			 * Our nop as ping got dropped. We know the target
			 * and transport are ok so just clean up
			 */
			task = iscsi_itt_to_task(conn, rejected_pdu.itt);
			if (!task) {
				iscsi_conn_printk(KERN_ERR, conn,
						 "Invalid pdu reject. Could "
						 "not lookup rejected task.\n");
				rc = ISCSI_ERR_BAD_ITT;
			} else
				rc = iscsi_nop_out_rsp(task,
					(struct iscsi_nopin*)&rejected_pdu,
					NULL, 0);
1073
		}
1074 1075 1076 1077 1078 1079 1080
		break;
	default:
		iscsi_conn_printk(KERN_ERR, conn,
				  "pdu (op 0x%x itt 0x%x) rejected. Reason "
				  "code 0x%x\n", rejected_pdu.itt,
				  rejected_pdu.opcode, reject->reason);
		break;
1081
	}
1082
	return rc;
1083 1084
}

1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
/**
 * iscsi_itt_to_task - look up task by itt
 * @conn: iscsi connection
 * @itt: itt
 *
 * This should be used for mgmt tasks like login and nops, or if
 * the LDD's itt space does not include the session age.
 *
 * The session lock must be held.
 */
1095
struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt)
1096 1097
{
	struct iscsi_session *session = conn->session;
1098
	int i;
1099 1100 1101 1102

	if (itt == RESERVED_ITT)
		return NULL;

1103 1104 1105 1106
	if (session->tt->parse_pdu_itt)
		session->tt->parse_pdu_itt(conn, itt, &i, NULL);
	else
		i = get_itt(itt);
1107 1108 1109 1110 1111
	if (i >= session->cmds_max)
		return NULL;

	return session->cmds[i];
}
1112
EXPORT_SYMBOL_GPL(iscsi_itt_to_task);
1113

M
Mike Christie 已提交
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124
/**
 * __iscsi_complete_pdu - complete pdu
 * @conn: iscsi conn
 * @hdr: iscsi header
 * @data: data buffer
 * @datalen: len of data buffer
 *
 * Completes pdu processing by freeing any resources allocated at
 * queuecommand or send generic. session lock must be held and verify
 * itt must have been called.
 */
1125 1126
int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
			 char *data, int datalen)
M
Mike Christie 已提交
1127 1128 1129
{
	struct iscsi_session *session = conn->session;
	int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0;
1130
	struct iscsi_task *task;
M
Mike Christie 已提交
1131 1132
	uint32_t itt;

1133
	conn->last_recv = jiffies;
1134 1135 1136 1137
	rc = iscsi_verify_itt(conn, hdr->itt);
	if (rc)
		return rc;

A
Al Viro 已提交
1138 1139
	if (hdr->itt != RESERVED_ITT)
		itt = get_itt(hdr->itt);
M
Mike Christie 已提交
1140
	else
A
Al Viro 已提交
1141
		itt = ~0U;
M
Mike Christie 已提交
1142

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

1146
	if (itt == ~0U) {
1147
		iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
1148

M
Mike Christie 已提交
1149 1150
		switch(opcode) {
		case ISCSI_OP_NOOP_IN:
1151
			if (datalen) {
M
Mike Christie 已提交
1152
				rc = ISCSI_ERR_PROTO;
1153 1154 1155
				break;
			}

A
Al Viro 已提交
1156
			if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG))
1157 1158
				break;

1159
			iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr);
M
Mike Christie 已提交
1160 1161
			break;
		case ISCSI_OP_REJECT:
1162 1163
			rc = iscsi_handle_reject(conn, hdr, data, datalen);
			break;
M
Mike Christie 已提交
1164
		case ISCSI_OP_ASYNC_EVENT:
1165
			conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
M
Mike Christie 已提交
1166 1167
			if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen))
				rc = ISCSI_ERR_CONN_FAILED;
M
Mike Christie 已提交
1168 1169 1170 1171 1172
			break;
		default:
			rc = ISCSI_ERR_BAD_OPCODE;
			break;
		}
1173 1174 1175 1176 1177
		goto out;
	}

	switch(opcode) {
	case ISCSI_OP_SCSI_CMD_RSP:
1178 1179 1180 1181
	case ISCSI_OP_SCSI_DATA_IN:
		task = iscsi_itt_to_ctask(conn, hdr->itt);
		if (!task)
			return ISCSI_ERR_BAD_ITT;
1182
		task->last_xfer = jiffies;
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
		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:
1204
		iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen);
1205 1206
		break;
	case ISCSI_OP_SCSI_DATA_IN:
1207
		iscsi_data_in_rsp(conn, hdr, task);
1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
		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);
1233
		iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
1234 1235 1236 1237 1238 1239 1240 1241 1242
		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;

1243 1244
		rc = iscsi_nop_out_rsp(task, (struct iscsi_nopin*)hdr,
				       data, datalen);
1245 1246 1247 1248 1249
		break;
	default:
		rc = ISCSI_ERR_BAD_OPCODE;
		break;
	}
M
Mike Christie 已提交
1250

1251 1252 1253 1254 1255
out:
	return rc;
recv_pdu:
	if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen))
		rc = ISCSI_ERR_CONN_FAILED;
1256
	iscsi_complete_task(task, ISCSI_TASK_COMPLETED);
M
Mike Christie 已提交
1257 1258
	return rc;
}
1259
EXPORT_SYMBOL_GPL(__iscsi_complete_pdu);
M
Mike Christie 已提交
1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272

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

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

1273
int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt)
M
Mike Christie 已提交
1274 1275
{
	struct iscsi_session *session = conn->session;
1276
	int age = 0, i = 0;
M
Mike Christie 已提交
1277

1278 1279
	if (itt == RESERVED_ITT)
		return 0;
M
Mike Christie 已提交
1280

1281 1282 1283 1284 1285 1286 1287 1288
	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) {
1289 1290
		iscsi_conn_printk(KERN_ERR, conn,
				  "received itt %x expected session age (%x)\n",
1291
				  (__force u32)itt, session->age);
1292 1293
		return ISCSI_ERR_BAD_ITT;
	}
M
Mike Christie 已提交
1294

1295 1296 1297 1298 1299
	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 已提交
1300 1301 1302 1303 1304
	}
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_verify_itt);

1305 1306 1307 1308 1309 1310 1311 1312 1313 1314
/**
 * iscsi_itt_to_ctask - look up ctask by itt
 * @conn: iscsi connection
 * @itt: itt
 *
 * This should be used for cmd tasks.
 *
 * The session lock must be held.
 */
struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt)
1315
{
1316
	struct iscsi_task *task;
1317 1318 1319 1320

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

1321 1322
	task = iscsi_itt_to_task(conn, itt);
	if (!task || !task->sc)
1323 1324
		return NULL;

1325 1326 1327 1328
	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);
1329
		return NULL;
1330
	}
1331

1332
	return task;
1333 1334 1335
}
EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask);

1336
void iscsi_session_failure(struct iscsi_session *session,
1337 1338 1339 1340 1341
			   enum iscsi_err err)
{
	struct iscsi_conn *conn;
	struct device *dev;

1342
	spin_lock_bh(&session->lock);
1343 1344
	conn = session->leadconn;
	if (session->state == ISCSI_STATE_TERMINATE || !conn) {
1345
		spin_unlock_bh(&session->lock);
1346 1347 1348 1349
		return;
	}

	dev = get_device(&conn->cls_conn->dev);
1350
	spin_unlock_bh(&session->lock);
1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365
	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 已提交
1366 1367 1368 1369
void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err)
{
	struct iscsi_session *session = conn->session;

1370
	spin_lock_bh(&session->lock);
1371
	if (session->state == ISCSI_STATE_FAILED) {
1372
		spin_unlock_bh(&session->lock);
1373 1374 1375
		return;
	}

1376
	if (conn->stop_stage == 0)
M
Mike Christie 已提交
1377
		session->state = ISCSI_STATE_FAILED;
1378
	spin_unlock_bh(&session->lock);
1379

M
Mike Christie 已提交
1380 1381
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
1382
	iscsi_conn_error_event(conn->cls_conn, err);
M
Mike Christie 已提交
1383 1384 1385
}
EXPORT_SYMBOL_GPL(iscsi_conn_failure);

1386 1387 1388 1389 1390 1391 1392
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
	 */
1393
	if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) {
1394 1395 1396 1397
		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);
1398 1399 1400 1401 1402
		return -ENOSPC;
	}
	return 0;
}

1403
static int iscsi_xmit_task(struct iscsi_conn *conn)
1404
{
1405
	struct iscsi_task *task = conn->task;
1406
	int rc;
1407

1408 1409 1410
	if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx))
		return -ENODATA;

1411
	__iscsi_get_task(task);
1412
	spin_unlock_bh(&conn->session->lock);
1413
	rc = conn->session->tt->xmit_task(task);
1414
	spin_lock_bh(&conn->session->lock);
1415
	if (!rc) {
1416
		/* done with this task */
1417
		task->last_xfer = jiffies;
1418
		conn->task = NULL;
1419 1420
	}
	__iscsi_put_task(task);
1421 1422 1423
	return rc;
}

1424
/**
1425 1426
 * iscsi_requeue_task - requeue task to run from session workqueue
 * @task: task to requeue
1427
 *
1428
 * LLDs that need to run a task from the session workqueue should call
1429 1430
 * this. The session lock must be held. This should only be called
 * by software drivers.
1431
 */
1432
void iscsi_requeue_task(struct iscsi_task *task)
1433
{
1434
	struct iscsi_conn *conn = task->conn;
1435

1436 1437 1438 1439 1440 1441
	/*
	 * 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);
1442
	iscsi_conn_queue_work(conn);
1443
}
1444
EXPORT_SYMBOL_GPL(iscsi_requeue_task);
1445

M
Mike Christie 已提交
1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456
/**
 * 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)
{
1457
	struct iscsi_task *task;
1458
	int rc = 0;
M
Mike Christie 已提交
1459

1460
	spin_lock_bh(&conn->session->lock);
1461
	if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) {
1462
		ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n");
1463
		spin_unlock_bh(&conn->session->lock);
1464
		return -ENODATA;
M
Mike Christie 已提交
1465 1466
	}

1467 1468
	if (conn->task) {
		rc = iscsi_xmit_task(conn);
1469
	        if (rc)
1470
		        goto done;
M
Mike Christie 已提交
1471 1472
	}

1473 1474 1475 1476 1477 1478
	/*
	 * 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:
1479
	while (!list_empty(&conn->mgmtqueue)) {
1480 1481
		conn->task = list_entry(conn->mgmtqueue.next,
					 struct iscsi_task, running);
1482
		list_del_init(&conn->task->running);
1483 1484 1485
		if (iscsi_prep_mgmt_task(conn, conn->task)) {
			__iscsi_put_task(conn->task);
			conn->task = NULL;
1486 1487
			continue;
		}
1488
		rc = iscsi_xmit_task(conn);
1489
		if (rc)
1490
			goto done;
M
Mike Christie 已提交
1491 1492
	}

1493
	/* process pending command queue */
1494
	while (!list_empty(&conn->cmdqueue)) {
1495 1496
		conn->task = list_entry(conn->cmdqueue.next, struct iscsi_task,
					running);
1497
		list_del_init(&conn->task->running);
1498
		if (conn->session->state == ISCSI_STATE_LOGGING_OUT) {
1499
			fail_scsi_task(conn->task, DID_IMM_RETRY);
1500 1501
			continue;
		}
1502 1503
		rc = iscsi_prep_scsi_cmd_pdu(conn->task);
		if (rc) {
1504
			if (rc == -ENOMEM || rc == -EACCES) {
1505 1506
				list_add_tail(&conn->task->running,
					      &conn->cmdqueue);
1507
				conn->task = NULL;
1508
				goto done;
1509
			} else
1510
				fail_scsi_task(conn->task, DID_ABORT);
1511 1512
			continue;
		}
1513
		rc = iscsi_xmit_task(conn);
1514
		if (rc)
1515
			goto done;
1516
		/*
1517
		 * we could continuously get new task requests so
1518 1519 1520
		 * we need to check the mgmt queue for nops that need to
		 * be sent to aviod starvation
		 */
1521 1522 1523 1524 1525
		if (!list_empty(&conn->mgmtqueue))
			goto check_mgmt;
	}

	while (!list_empty(&conn->requeue)) {
1526 1527 1528 1529 1530 1531
		/*
		 * we always do fastlogout - conn stop code will clean up.
		 */
		if (conn->session->state == ISCSI_STATE_LOGGING_OUT)
			break;

1532 1533 1534 1535 1536 1537
		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;
1538
		list_del_init(&conn->task->running);
1539 1540
		conn->task->state = ISCSI_TASK_RUNNING;
		rc = iscsi_xmit_task(conn);
1541
		if (rc)
1542
			goto done;
1543
		if (!list_empty(&conn->mgmtqueue))
1544
			goto check_mgmt;
M
Mike Christie 已提交
1545
	}
1546
	spin_unlock_bh(&conn->session->lock);
1547
	return -ENODATA;
M
Mike Christie 已提交
1548

1549
done:
1550
	spin_unlock_bh(&conn->session->lock);
1551
	return rc;
M
Mike Christie 已提交
1552 1553
}

D
David Howells 已提交
1554
static void iscsi_xmitworker(struct work_struct *work)
M
Mike Christie 已提交
1555
{
D
David Howells 已提交
1556 1557
	struct iscsi_conn *conn =
		container_of(work, struct iscsi_conn, xmitwork);
1558
	int rc;
M
Mike Christie 已提交
1559 1560 1561
	/*
	 * serialize Xmit worker on a per-connection basis.
	 */
1562 1563 1564
	do {
		rc = iscsi_data_xmit(conn);
	} while (rc >= 0 || rc == -EAGAIN);
M
Mike Christie 已提交
1565 1566
}

1567 1568 1569 1570 1571
static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn,
						  struct scsi_cmnd *sc)
{
	struct iscsi_task *task;

1572
	if (!kfifo_out(&conn->session->cmdpool.queue,
1573 1574 1575 1576 1577 1578 1579 1580 1581 1582
			 (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;
1583 1584 1585
	task->have_checked_conn = false;
	task->last_timeout = jiffies;
	task->last_xfer = jiffies;
1586 1587 1588 1589
	INIT_LIST_HEAD(&task->running);
	return task;
}

M
Mike Christie 已提交
1590 1591 1592 1593 1594
enum {
	FAILURE_BAD_HOST = 1,
	FAILURE_SESSION_FAILED,
	FAILURE_SESSION_FREED,
	FAILURE_WINDOW_CLOSED,
1595
	FAILURE_OOM,
M
Mike Christie 已提交
1596
	FAILURE_SESSION_TERMINATE,
1597
	FAILURE_SESSION_IN_RECOVERY,
M
Mike Christie 已提交
1598
	FAILURE_SESSION_RECOVERY_TIMEOUT,
1599
	FAILURE_SESSION_LOGGING_OUT,
1600
	FAILURE_SESSION_NOT_READY,
M
Mike Christie 已提交
1601 1602
};

1603
int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc)
M
Mike Christie 已提交
1604
{
1605
	struct iscsi_cls_session *cls_session;
1606
	struct iscsi_host *ihost;
M
Mike Christie 已提交
1607 1608 1609
	int reason = 0;
	struct iscsi_session *session;
	struct iscsi_conn *conn;
1610
	struct iscsi_task *task = NULL;
M
Mike Christie 已提交
1611 1612

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

1615
	ihost = shost_priv(host);
M
Mike Christie 已提交
1616

1617 1618
	cls_session = starget_to_session(scsi_target(sc->device));
	session = cls_session->dd_data;
1619
	spin_lock_bh(&session->lock);
M
Mike Christie 已提交
1620

1621
	reason = iscsi_session_chkready(cls_session);
1622 1623 1624 1625 1626
	if (reason) {
		sc->result = reason;
		goto fault;
	}

1627
	if (session->state != ISCSI_STATE_LOGGED_IN) {
1628 1629 1630 1631 1632 1633
		/*
		 * 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)
		 */
1634
		switch (session->state) {
1635
		case ISCSI_STATE_FAILED:
1636
		case ISCSI_STATE_IN_RECOVERY:
1637
			reason = FAILURE_SESSION_IN_RECOVERY;
1638 1639
			sc->result = DID_IMM_RETRY << 16;
			break;
1640 1641
		case ISCSI_STATE_LOGGING_OUT:
			reason = FAILURE_SESSION_LOGGING_OUT;
1642 1643
			sc->result = DID_IMM_RETRY << 16;
			break;
1644
		case ISCSI_STATE_RECOVERY_FAILED:
1645
			reason = FAILURE_SESSION_RECOVERY_TIMEOUT;
1646
			sc->result = DID_TRANSPORT_FAILFAST << 16;
1647 1648
			break;
		case ISCSI_STATE_TERMINATE:
1649
			reason = FAILURE_SESSION_TERMINATE;
1650
			sc->result = DID_NO_CONNECT << 16;
1651 1652
			break;
		default:
1653
			reason = FAILURE_SESSION_FREED;
1654
			sc->result = DID_NO_CONNECT << 16;
1655
		}
M
Mike Christie 已提交
1656 1657 1658 1659
		goto fault;
	}

	conn = session->leadconn;
1660 1661
	if (!conn) {
		reason = FAILURE_SESSION_FREED;
1662
		sc->result = DID_NO_CONNECT << 16;
1663 1664
		goto fault;
	}
M
Mike Christie 已提交
1665

1666 1667 1668 1669 1670 1671
	if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) {
		reason = FAILURE_SESSION_IN_RECOVERY;
		sc->result = DID_REQUEUE;
		goto fault;
	}

1672 1673 1674 1675 1676
	if (iscsi_check_cmdsn_window_closed(conn)) {
		reason = FAILURE_WINDOW_CLOSED;
		goto reject;
	}

1677 1678
	task = iscsi_alloc_task(conn, sc);
	if (!task) {
1679 1680 1681
		reason = FAILURE_OOM;
		goto reject;
	}
M
Mike Christie 已提交
1682

1683
	if (!ihost->workq) {
1684 1685
		reason = iscsi_prep_scsi_cmd_pdu(task);
		if (reason) {
1686
			if (reason == -ENOMEM ||  reason == -EACCES) {
1687 1688 1689 1690 1691 1692
				reason = FAILURE_OOM;
				goto prepd_reject;
			} else {
				sc->result = DID_ABORT << 16;
				goto prepd_fault;
			}
1693
		}
1694
		if (session->tt->xmit_task(task)) {
1695
			session->cmdsn--;
1696
			reason = FAILURE_SESSION_NOT_READY;
1697
			goto prepd_reject;
1698
		}
1699 1700
	} else {
		list_add_tail(&task->running, &conn->cmdqueue);
1701
		iscsi_conn_queue_work(conn);
1702
	}
1703 1704

	session->queued_cmdsn++;
1705
	spin_unlock_bh(&session->lock);
M
Mike Christie 已提交
1706 1707
	return 0;

1708
prepd_reject:
1709
	iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ);
M
Mike Christie 已提交
1710
reject:
1711
	spin_unlock_bh(&session->lock);
1712 1713
	ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n",
			  sc->cmnd[0], reason);
1714
	return SCSI_MLQUEUE_TARGET_BUSY;
M
Mike Christie 已提交
1715

1716
prepd_fault:
1717
	iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ);
M
Mike Christie 已提交
1718
fault:
1719
	spin_unlock_bh(&session->lock);
1720 1721
	ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n",
			  sc->cmnd[0], reason);
1722 1723 1724 1725 1726 1727
	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;
	}
1728
	sc->scsi_done(sc);
M
Mike Christie 已提交
1729 1730 1731 1732
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_queuecommand);

1733
int iscsi_change_queue_depth(struct scsi_device *sdev, int depth, int reason)
M
Mike Christie 已提交
1734
{
1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745
	switch (reason) {
	case SCSI_QDEPTH_DEFAULT:
		scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
		break;
	case SCSI_QDEPTH_QFULL:
		scsi_track_queue_full(sdev, depth);
		break;
	case SCSI_QDEPTH_RAMP_UP:
		scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
		break;
	default:
1746
		return -EOPNOTSUPP;
1747
	}
M
Mike Christie 已提交
1748 1749 1750 1751
	return sdev->queue_depth;
}
EXPORT_SYMBOL_GPL(iscsi_change_queue_depth);

1752 1753 1754 1755 1756 1757 1758 1759 1760 1761
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);

1762
static void iscsi_tmf_timedout(unsigned long data)
M
Mike Christie 已提交
1763
{
1764
	struct iscsi_conn *conn = (struct iscsi_conn *)data;
M
Mike Christie 已提交
1765 1766 1767
	struct iscsi_session *session = conn->session;

	spin_lock(&session->lock);
1768 1769
	if (conn->tmf_state == TMF_QUEUED) {
		conn->tmf_state = TMF_TIMEDOUT;
1770
		ISCSI_DBG_EH(session, "tmf timedout\n");
M
Mike Christie 已提交
1771 1772 1773 1774 1775 1776
		/* unblock eh_abort() */
		wake_up(&conn->ehwait);
	}
	spin_unlock(&session->lock);
}

1777
static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn,
1778 1779
				   struct iscsi_tm *hdr, int age,
				   int timeout)
M
Mike Christie 已提交
1780 1781
{
	struct iscsi_session *session = conn->session;
1782
	struct iscsi_task *task;
M
Mike Christie 已提交
1783

1784
	task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr,
1785
				      NULL, 0);
1786
	if (!task) {
1787
		spin_unlock_bh(&session->lock);
1788
		iscsi_conn_printk(KERN_ERR, conn, "Could not send TMF.\n");
M
Mike Christie 已提交
1789
		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
1790
		spin_lock_bh(&session->lock);
1791
		return -EPERM;
M
Mike Christie 已提交
1792
	}
1793
	conn->tmfcmd_pdus_cnt++;
1794
	conn->tmf_timer.expires = timeout * HZ + jiffies;
1795 1796 1797
	conn->tmf_timer.function = iscsi_tmf_timedout;
	conn->tmf_timer.data = (unsigned long)conn;
	add_timer(&conn->tmf_timer);
1798
	ISCSI_DBG_EH(session, "tmf set timeout\n");
M
Mike Christie 已提交
1799 1800

	spin_unlock_bh(&session->lock);
1801
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
1802 1803 1804 1805

	/*
	 * block eh thread until:
	 *
1806 1807
	 * 1) tmf response
	 * 2) tmf timeout
M
Mike Christie 已提交
1808 1809 1810
	 * 3) session is terminated or restarted or userspace has
	 * given up on recovery
	 */
1811
	wait_event_interruptible(conn->ehwait, age != session->age ||
M
Mike Christie 已提交
1812
				 session->state != ISCSI_STATE_LOGGED_IN ||
1813
				 conn->tmf_state != TMF_QUEUED);
M
Mike Christie 已提交
1814 1815
	if (signal_pending(current))
		flush_signals(current);
1816 1817
	del_timer_sync(&conn->tmf_timer);

1818
	mutex_lock(&session->eh_mutex);
1819
	spin_lock_bh(&session->lock);
1820
	/* if the session drops it will clean up the task */
1821 1822 1823
	if (age != session->age ||
	    session->state != ISCSI_STATE_LOGGED_IN)
		return -ENOTCONN;
M
Mike Christie 已提交
1824 1825 1826
	return 0;
}

1827 1828 1829 1830
/*
 * Fail commands. session lock held and recv side suspended and xmit
 * thread flushed
 */
1831 1832
static void fail_scsi_tasks(struct iscsi_conn *conn, unsigned lun,
			    int error)
1833
{
1834 1835
	struct iscsi_task *task;
	int i;
1836

1837 1838 1839 1840
	for (i = 0; i < conn->session->cmds_max; i++) {
		task = conn->session->cmds[i];
		if (!task->sc || task->state == ISCSI_TASK_FREE)
			continue;
1841

1842 1843
		if (lun != -1 && lun != task->sc->device->lun)
			continue;
1844

1845 1846 1847
		ISCSI_DBG_SESSION(conn->session,
				  "failing sc %p itt 0x%x state %d\n",
				  task->sc, task->itt, task->state);
1848
		fail_scsi_task(task, error);
1849 1850 1851
	}
}

1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878
/**
 * iscsi_suspend_queue - suspend iscsi_queuecommand
 * @conn: iscsi conn to stop queueing IO on
 *
 * This grabs the session lock to make sure no one is in
 * xmit_task/queuecommand, and then sets suspend to prevent
 * new commands from being queued. This only needs to be called
 * by offload drivers that need to sync a path like ep disconnect
 * with the iscsi_queuecommand/xmit_task. To start IO again libiscsi
 * will call iscsi_start_tx and iscsi_unblock_session when in FFP.
 */
void iscsi_suspend_queue(struct iscsi_conn *conn)
{
	spin_lock_bh(&conn->session->lock);
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
	spin_unlock_bh(&conn->session->lock);
}
EXPORT_SYMBOL_GPL(iscsi_suspend_queue);

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

1884
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
1885
	if (ihost->workq)
1886
		flush_workqueue(ihost->workq);
1887
}
1888
EXPORT_SYMBOL_GPL(iscsi_suspend_tx);
1889 1890 1891 1892

static void iscsi_start_tx(struct iscsi_conn *conn)
{
	clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
1893
	iscsi_conn_queue_work(conn);
1894 1895
}

1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911
/*
 * 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;
}

1912
static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc)
1913
{
1914
	enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED;
1915
	struct iscsi_task *task = NULL, *running_task;
1916 1917 1918
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
	struct iscsi_conn *conn;
1919
	int i;
1920

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

1924
	ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc);
1925 1926 1927 1928 1929 1930 1931

	spin_lock(&session->lock);
	if (session->state != ISCSI_STATE_LOGGED_IN) {
		/*
		 * We are probably in the middle of iscsi recovery so let
		 * that complete and handle the error.
		 */
J
Jens Axboe 已提交
1932
		rc = BLK_EH_RESET_TIMER;
1933 1934 1935 1936 1937 1938
		goto done;
	}

	conn = session->leadconn;
	if (!conn) {
		/* In the middle of shuting down */
J
Jens Axboe 已提交
1939
		rc = BLK_EH_RESET_TIMER;
1940 1941 1942
		goto done;
	}

1943
	task = (struct iscsi_task *)sc->SCp.ptr;
1944 1945 1946 1947 1948 1949
	if (!task) {
		/*
		 * Raced with completion. Just reset timer, and let it
		 * complete normally
		 */
		rc = BLK_EH_RESET_TIMER;
1950
		goto done;
1951 1952
	}

1953 1954 1955 1956 1957 1958 1959
	/*
	 * 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.
	 */
1960
	if (time_after(task->last_xfer, task->last_timeout)) {
1961 1962
		ISCSI_DBG_EH(session, "Command making progress. Asking "
			     "scsi-ml for more time to complete. "
1963
			     "Last data xfer at %lu. Last timeout was at "
1964
			     "%lu\n.", task->last_xfer, task->last_timeout);
1965 1966 1967 1968 1969
		task->have_checked_conn = false;
		rc = BLK_EH_RESET_TIMER;
		goto done;
	}

1970 1971 1972 1973 1974 1975
	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
	 */
1976
	if (iscsi_has_ping_timed_out(conn)) {
J
Jens Axboe 已提交
1977
		rc = BLK_EH_RESET_TIMER;
1978 1979
		goto done;
	}
1980

1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017
	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;
		}
	}

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

2022
	/*
2023 2024
	 * Checking the transport already or nop from a cmd timeout still
	 * running
2025
	 */
2026 2027
	if (conn->ping_task) {
		task->have_checked_conn = true;
J
Jens Axboe 已提交
2028
		rc = BLK_EH_RESET_TIMER;
2029 2030 2031
		goto done;
	}

2032 2033 2034 2035 2036
	/* Make sure there is a transport check done */
	iscsi_send_nopout(conn, NULL);
	task->have_checked_conn = true;
	rc = BLK_EH_RESET_TIMER;

2037
done:
2038 2039
	if (task)
		task->last_timeout = jiffies;
2040
	spin_unlock(&session->lock);
2041 2042
	ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ?
		     "timer reset" : "nh");
2043 2044 2045 2046 2047 2048 2049
	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;
2050
	unsigned long recv_timeout, next_timeout = 0, last_recv;
2051 2052 2053 2054 2055

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

2056 2057
	recv_timeout = conn->recv_timeout;
	if (!recv_timeout)
2058 2059
		goto done;

2060
	recv_timeout *= HZ;
2061
	last_recv = conn->last_recv;
2062 2063

	if (iscsi_has_ping_timed_out(conn)) {
2064
		iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs "
2065 2066 2067 2068
				  "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);
2069 2070 2071 2072 2073
		spin_unlock(&session->lock);
		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
		return;
	}

2074
	if (time_before_eq(last_recv + recv_timeout, jiffies)) {
2075
		/* send a ping to try to provoke some traffic */
2076
		ISCSI_DBG_CONN(conn, "Sending nopout as ping\n");
2077
		iscsi_send_nopout(conn, NULL);
2078
		next_timeout = conn->last_ping + (conn->ping_timeout * HZ);
2079
	} else
2080
		next_timeout = last_recv + recv_timeout;
2081

2082
	ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout);
2083
	mod_timer(&conn->transport_timer, next_timeout);
2084 2085 2086 2087
done:
	spin_unlock(&session->lock);
}

2088
static void iscsi_prep_abort_task_pdu(struct iscsi_task *task,
2089 2090 2091 2092 2093 2094
				      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;
2095 2096 2097
	memcpy(hdr->lun, task->lun, sizeof(hdr->lun));
	hdr->rtt = task->hdr_itt;
	hdr->refcmdsn = task->cmdsn;
2098 2099
}

M
Mike Christie 已提交
2100 2101
int iscsi_eh_abort(struct scsi_cmnd *sc)
{
2102 2103
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
2104
	struct iscsi_conn *conn;
2105
	struct iscsi_task *task;
2106 2107
	struct iscsi_tm *hdr;
	int rc, age;
M
Mike Christie 已提交
2108

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

2112
	ISCSI_DBG_EH(session, "aborting sc %p\n", sc);
2113

2114 2115
	mutex_lock(&session->eh_mutex);
	spin_lock_bh(&session->lock);
2116 2117 2118 2119 2120
	/*
	 * if session was ISCSI_STATE_IN_RECOVERY then we may not have
	 * got the command.
	 */
	if (!sc->SCp.ptr) {
2121 2122
		ISCSI_DBG_EH(session, "sc never reached iscsi layer or "
				      "it completed.\n");
2123 2124
		spin_unlock_bh(&session->lock);
		mutex_unlock(&session->eh_mutex);
2125 2126 2127
		return SUCCESS;
	}

M
Mike Christie 已提交
2128 2129 2130 2131
	/*
	 * If we are not logged in or we have started a new session
	 * then let the host reset code handle this
	 */
2132 2133 2134 2135
	if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN ||
	    sc->SCp.phase != session->age) {
		spin_unlock_bh(&session->lock);
		mutex_unlock(&session->eh_mutex);
2136
		ISCSI_DBG_EH(session, "failing abort due to dropped "
2137
				  "session.\n");
2138 2139 2140 2141 2142 2143 2144
		return FAILED;
	}

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

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

2149 2150
	/* task completed before time out */
	if (!task->sc) {
2151
		ISCSI_DBG_EH(session, "sc completed while abort in progress\n");
2152
		goto success;
2153
	}
M
Mike Christie 已提交
2154

2155
	if (task->state == ISCSI_TASK_PENDING) {
2156
		fail_scsi_task(task, DID_ABORT);
2157 2158
		goto success;
	}
M
Mike Christie 已提交
2159

2160 2161
	/* only have one tmf outstanding at a time */
	if (conn->tmf_state != TMF_INITIAL)
M
Mike Christie 已提交
2162
		goto failed;
2163
	conn->tmf_state = TMF_QUEUED;
M
Mike Christie 已提交
2164

2165
	hdr = &conn->tmhdr;
2166
	iscsi_prep_abort_task_pdu(task, hdr);
2167

2168
	if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) {
2169 2170 2171 2172 2173 2174
		rc = FAILED;
		goto failed;
	}

	switch (conn->tmf_state) {
	case TMF_SUCCESS:
2175
		spin_unlock_bh(&session->lock);
2176 2177 2178 2179
		/*
		 * stop tx side incase the target had sent a abort rsp but
		 * the initiator was still writing out data.
		 */
2180
		iscsi_suspend_tx(conn);
2181
		/*
2182 2183 2184
		 * 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.
2185
		 */
2186
		spin_lock_bh(&session->lock);
2187
		fail_scsi_task(task, DID_ABORT);
2188
		conn->tmf_state = TMF_INITIAL;
2189
		memset(hdr, 0, sizeof(*hdr));
2190
		spin_unlock_bh(&session->lock);
2191
		iscsi_start_tx(conn);
2192
		goto success_unlocked;
2193 2194
	case TMF_TIMEDOUT:
		spin_unlock_bh(&session->lock);
2195
		iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
2196 2197 2198 2199
		goto failed_unlocked;
	case TMF_NOT_FOUND:
		if (!sc->SCp.ptr) {
			conn->tmf_state = TMF_INITIAL;
2200
			memset(hdr, 0, sizeof(*hdr));
2201
			/* task completed before tmf abort response */
2202 2203
			ISCSI_DBG_EH(session, "sc completed while abort	in "
					      "progress\n");
2204
			goto success;
2205 2206 2207
		}
		/* fall through */
	default:
2208 2209
		conn->tmf_state = TMF_INITIAL;
		goto failed;
M
Mike Christie 已提交
2210 2211
	}

2212
success:
M
Mike Christie 已提交
2213
	spin_unlock_bh(&session->lock);
2214
success_unlocked:
2215 2216
	ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n",
		     sc, task->itt);
2217
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
2218 2219 2220 2221
	return SUCCESS;

failed:
	spin_unlock_bh(&session->lock);
2222
failed_unlocked:
2223 2224
	ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc,
		     task ? task->itt : 0);
2225
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
2226 2227 2228 2229
	return FAILED;
}
EXPORT_SYMBOL_GPL(iscsi_eh_abort);

2230 2231 2232 2233 2234 2235 2236
static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr)
{
	memset(hdr, 0, sizeof(*hdr));
	hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE;
	hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK;
	hdr->flags |= ISCSI_FLAG_CMD_FINAL;
	int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun);
2237
	hdr->rtt = RESERVED_ITT;
2238 2239 2240 2241
}

int iscsi_eh_device_reset(struct scsi_cmnd *sc)
{
2242 2243
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
2244 2245 2246 2247
	struct iscsi_conn *conn;
	struct iscsi_tm *hdr;
	int rc = FAILED;

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

2251
	ISCSI_DBG_EH(session, "LU Reset [sc %p lun %u]\n", sc, sc->device->lun);
2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270

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

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

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

2271
	if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age,
2272
				    session->lu_reset_timeout)) {
2273 2274 2275 2276 2277 2278 2279 2280 2281
		rc = FAILED;
		goto unlock;
	}

	switch (conn->tmf_state) {
	case TMF_SUCCESS:
		break;
	case TMF_TIMEDOUT:
		spin_unlock_bh(&session->lock);
2282
		iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
2283 2284 2285 2286 2287 2288 2289 2290 2291 2292
		goto done;
	default:
		conn->tmf_state = TMF_INITIAL;
		goto unlock;
	}

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

	iscsi_suspend_tx(conn);
2293

2294
	spin_lock_bh(&session->lock);
2295
	memset(hdr, 0, sizeof(*hdr));
2296
	fail_scsi_tasks(conn, sc->device->lun, DID_ERROR);
2297
	conn->tmf_state = TMF_INITIAL;
2298
	spin_unlock_bh(&session->lock);
2299 2300 2301 2302 2303 2304 2305

	iscsi_start_tx(conn);
	goto done;

unlock:
	spin_unlock_bh(&session->lock);
done:
2306 2307
	ISCSI_DBG_EH(session, "dev reset result = %s\n",
		     rc == SUCCESS ? "SUCCESS" : "FAILED");
2308 2309 2310 2311 2312
	mutex_unlock(&session->eh_mutex);
	return rc;
}
EXPORT_SYMBOL_GPL(iscsi_eh_device_reset);

2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333
void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session)
{
	struct iscsi_session *session = cls_session->dd_data;

	spin_lock_bh(&session->lock);
	if (session->state != ISCSI_STATE_LOGGED_IN) {
		session->state = ISCSI_STATE_RECOVERY_FAILED;
		if (session->leadconn)
			wake_up(&session->leadconn->ehwait);
	}
	spin_unlock_bh(&session->lock);
}
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.
 */
2334
int iscsi_eh_session_reset(struct scsi_cmnd *sc)
2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362
{
	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);
	spin_lock_bh(&session->lock);
	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);
		spin_unlock_bh(&session->lock);
		mutex_unlock(&session->eh_mutex);
		return FAILED;
	}

	spin_unlock_bh(&session->lock);
	mutex_unlock(&session->eh_mutex);
	/*
	 * we drop the lock here but the leadconn cannot be destoyed while
	 * we are in the scsi eh
	 */
2363
	iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384

	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);
	spin_lock_bh(&session->lock);
	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;
	spin_unlock_bh(&session->lock);
	mutex_unlock(&session->eh_mutex);
	return SUCCESS;
}
2385
EXPORT_SYMBOL_GPL(iscsi_eh_session_reset);
2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399

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
 *
2400
 * This will attempt to send a warm target reset.
2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444
 */
int iscsi_eh_target_reset(struct scsi_cmnd *sc)
{
	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);
	spin_lock_bh(&session->lock);
	/*
	 * Just check if we are not logged in. We cannot check for
	 * the phase because the reset could come from a ioctl.
	 */
	if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN)
		goto unlock;
	conn = session->leadconn;

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

	hdr = &conn->tmhdr;
	iscsi_prep_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:
		spin_unlock_bh(&session->lock);
2445
		iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST);
2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471
		goto done;
	default:
		conn->tmf_state = TMF_INITIAL;
		goto unlock;
	}

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

	iscsi_suspend_tx(conn);

	spin_lock_bh(&session->lock);
	memset(hdr, 0, sizeof(*hdr));
	fail_scsi_tasks(conn, -1, DID_ERROR);
	conn->tmf_state = TMF_INITIAL;
	spin_unlock_bh(&session->lock);

	iscsi_start_tx(conn);
	goto done;

unlock:
	spin_unlock_bh(&session->lock);
done:
	ISCSI_DBG_EH(session, "tgt %s reset result = %s\n", session->targetname,
		     rc == SUCCESS ? "SUCCESS" : "FAILED");
	mutex_unlock(&session->eh_mutex);
2472 2473 2474
	return rc;
}
EXPORT_SYMBOL_GPL(iscsi_eh_target_reset);
2475

2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487
/**
 * 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);
2488 2489 2490 2491
	if (rc == FAILED)
		rc = iscsi_eh_session_reset(sc);
	return rc;
}
2492
EXPORT_SYMBOL_GPL(iscsi_eh_recover_target);
2493

2494 2495 2496 2497 2498 2499
/*
 * 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 已提交
2500
int
2501
iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size)
M
Mike Christie 已提交
2502
{
2503
	int i, num_arrays = 1;
M
Mike Christie 已提交
2504

2505
	memset(q, 0, sizeof(*q));
M
Mike Christie 已提交
2506 2507

	q->max = max;
2508 2509 2510 2511 2512 2513 2514

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

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

	for (i = 0; i < max; i++) {
2520
		q->pool[i] = kzalloc(item_size, GFP_KERNEL);
M
Mike Christie 已提交
2521
		if (q->pool[i] == NULL) {
2522 2523
			q->max = i;
			goto enomem;
M
Mike Christie 已提交
2524
		}
2525
		kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*));
M
Mike Christie 已提交
2526
	}
2527 2528 2529 2530 2531 2532

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

M
Mike Christie 已提交
2533
	return 0;
2534 2535 2536 2537

enomem:
	iscsi_pool_free(q);
	return -ENOMEM;
M
Mike Christie 已提交
2538 2539 2540
}
EXPORT_SYMBOL_GPL(iscsi_pool_init);

2541
void iscsi_pool_free(struct iscsi_pool *q)
M
Mike Christie 已提交
2542 2543 2544 2545
{
	int i;

	for (i = 0; i < q->max; i++)
2546
		kfree(q->pool[i]);
2547
	kfree(q->pool);
M
Mike Christie 已提交
2548 2549 2550
}
EXPORT_SYMBOL_GPL(iscsi_pool_free);

2551 2552 2553 2554 2555 2556 2557 2558 2559 2560
/**
 * 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)
{
2561 2562 2563
	if (!shost->can_queue)
		shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX;

2564 2565 2566
	if (!shost->cmd_per_lun)
		shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN;

2567 2568
	if (!shost->transportt->eh_timed_out)
		shost->transportt->eh_timed_out = iscsi_eh_cmd_timed_out;
2569 2570 2571 2572 2573 2574 2575 2576
	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
2577
 * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue
2578 2579 2580 2581 2582
 *
 * 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,
2583
				   int dd_data_size, bool xmit_can_sleep)
2584
{
2585
	struct Scsi_Host *shost;
2586
	struct iscsi_host *ihost;
2587 2588 2589 2590

	shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size);
	if (!shost)
		return NULL;
2591
	ihost = shost_priv(shost);
2592 2593 2594 2595 2596 2597 2598 2599 2600

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

2601 2602 2603 2604
	spin_lock_init(&ihost->lock);
	ihost->state = ISCSI_HOST_SETUP;
	ihost->num_sessions = 0;
	init_waitqueue_head(&ihost->session_removal_wq);
2605
	return shost;
2606 2607 2608 2609

free_host:
	scsi_host_put(shost);
	return NULL;
2610 2611 2612
}
EXPORT_SYMBOL_GPL(iscsi_host_alloc);

2613 2614
static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session)
{
2615
	iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST);
2616 2617
}

2618 2619 2620 2621
/**
 * iscsi_host_remove - remove host and sessions
 * @shost: scsi host
 *
2622 2623
 * If there are any sessions left, this will initiate the removal and wait
 * for the completion.
2624 2625 2626
 */
void iscsi_host_remove(struct Scsi_Host *shost)
{
2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639
	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);

2640
	scsi_remove_host(shost);
2641 2642
	if (ihost->workq)
		destroy_workqueue(ihost->workq);
2643
}
2644
EXPORT_SYMBOL_GPL(iscsi_host_remove);
M
Mike Christie 已提交
2645

2646
void iscsi_host_free(struct Scsi_Host *shost)
2647 2648
{
	struct iscsi_host *ihost = shost_priv(shost);
M
Mike Christie 已提交
2649

2650 2651 2652
	kfree(ihost->netdev);
	kfree(ihost->hwaddress);
	kfree(ihost->initiatorname);
2653
	scsi_host_put(shost);
2654
}
2655
EXPORT_SYMBOL_GPL(iscsi_host_free);
M
Mike Christie 已提交
2656

2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677
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 已提交
2678 2679 2680
/**
 * iscsi_session_setup - create iscsi cls session and host and session
 * @iscsit: iscsi transport template
2681 2682
 * @shost: scsi host
 * @cmds_max: session can queue
2683
 * @cmd_task_size: LLD task private data size
M
Mike Christie 已提交
2684 2685 2686 2687
 * @initial_cmdsn: initial CmdSN
 *
 * This can be used by software iscsi_transports that allocate
 * a session per scsi host.
2688 2689 2690 2691
 *
 * 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.
2692
 */
M
Mike Christie 已提交
2693
struct iscsi_cls_session *
2694
iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost,
2695
		    uint16_t cmds_max, int dd_size, int cmd_task_size,
2696
		    uint32_t initial_cmdsn, unsigned int id)
M
Mike Christie 已提交
2697
{
2698
	struct iscsi_host *ihost = shost_priv(shost);
M
Mike Christie 已提交
2699 2700
	struct iscsi_session *session;
	struct iscsi_cls_session *cls_session;
2701
	int cmd_i, scsi_cmds, total_cmds = cmds_max;
2702 2703 2704 2705 2706 2707 2708 2709 2710
	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);
2711 2712 2713

	if (!total_cmds)
		total_cmds = ISCSI_DEF_XMIT_CMDS_MAX;
2714
	/*
2715 2716 2717
	 * 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.
2718
	 */
2719 2720 2721 2722
	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);
2723
		goto dec_session_count;
2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740
	}

	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);
2741
	}
2742
	scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX;
2743

2744
	cls_session = iscsi_alloc_session(shost, iscsit,
2745 2746
					  sizeof(struct iscsi_session) +
					  dd_size);
2747
	if (!cls_session)
2748
		goto dec_session_count;
2749 2750
	session = cls_session->dd_data;
	session->cls_session = cls_session;
M
Mike Christie 已提交
2751 2752
	session->host = shost;
	session->state = ISCSI_STATE_FREE;
2753
	session->fast_abort = 1;
2754
	session->tgt_reset_timeout = 30;
2755 2756
	session->lu_reset_timeout = 15;
	session->abort_timeout = 10;
2757 2758
	session->scsi_cmds_max = scsi_cmds;
	session->cmds_max = total_cmds;
2759
	session->queued_cmdsn = session->cmdsn = initial_cmdsn;
M
Mike Christie 已提交
2760 2761 2762 2763
	session->exp_cmdsn = initial_cmdsn + 1;
	session->max_cmdsn = initial_cmdsn + 1;
	session->max_r2t = 1;
	session->tt = iscsit;
2764
	session->dd_data = cls_session->dd_data + sizeof(*session);
2765
	mutex_init(&session->eh_mutex);
2766
	spin_lock_init(&session->lock);
M
Mike Christie 已提交
2767 2768 2769 2770

	/* initialize SCSI PDU commands pool */
	if (iscsi_pool_init(&session->cmdpool, session->cmds_max,
			    (void***)&session->cmds,
2771
			    cmd_task_size + sizeof(struct iscsi_task)))
M
Mike Christie 已提交
2772 2773 2774 2775
		goto cmdpool_alloc_fail;

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

2778 2779 2780
		if (cmd_task_size)
			task->dd_data = &task[1];
		task->itt = cmd_i;
2781
		task->state = ISCSI_TASK_FREE;
2782
		INIT_LIST_HEAD(&task->running);
M
Mike Christie 已提交
2783 2784
	}

2785
	if (!try_module_get(iscsit->owner))
2786
		goto module_get_fail;
M
Mike Christie 已提交
2787

2788
	if (iscsi_add_session(cls_session, id))
2789
		goto cls_session_fail;
2790

M
Mike Christie 已提交
2791 2792 2793
	return cls_session;

cls_session_fail:
2794 2795
	module_put(iscsit->owner);
module_get_fail:
2796
	iscsi_pool_free(&session->cmdpool);
M
Mike Christie 已提交
2797
cmdpool_alloc_fail:
2798
	iscsi_free_session(cls_session);
2799 2800
dec_session_count:
	iscsi_host_dec_session_cnt(shost);
M
Mike Christie 已提交
2801 2802 2803 2804 2805 2806
	return NULL;
}
EXPORT_SYMBOL_GPL(iscsi_session_setup);

/**
 * iscsi_session_teardown - destroy session, host, and cls_session
2807
 * @cls_session: iscsi session
M
Mike Christie 已提交
2808
 *
2809 2810 2811
 * The driver must have called iscsi_remove_session before
 * calling this.
 */
M
Mike Christie 已提交
2812 2813
void iscsi_session_teardown(struct iscsi_cls_session *cls_session)
{
2814
	struct iscsi_session *session = cls_session->dd_data;
2815
	struct module *owner = cls_session->transport->owner;
2816
	struct Scsi_Host *shost = session->host;
M
Mike Christie 已提交
2817

2818
	iscsi_pool_free(&session->cmdpool);
M
Mike Christie 已提交
2819

2820 2821 2822 2823
	kfree(session->password);
	kfree(session->password_in);
	kfree(session->username);
	kfree(session->username_in);
2824
	kfree(session->targetname);
2825 2826
	kfree(session->initiatorname);
	kfree(session->ifacename);
2827

2828
	iscsi_destroy_session(cls_session);
2829
	iscsi_host_dec_session_cnt(shost);
2830
	module_put(owner);
M
Mike Christie 已提交
2831 2832 2833 2834 2835 2836
}
EXPORT_SYMBOL_GPL(iscsi_session_teardown);

/**
 * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn
 * @cls_session: iscsi_cls_session
2837
 * @dd_size: private driver data size
M
Mike Christie 已提交
2838
 * @conn_idx: cid
2839
 */
M
Mike Christie 已提交
2840
struct iscsi_cls_conn *
2841 2842
iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
		 uint32_t conn_idx)
M
Mike Christie 已提交
2843
{
2844
	struct iscsi_session *session = cls_session->dd_data;
M
Mike Christie 已提交
2845 2846
	struct iscsi_conn *conn;
	struct iscsi_cls_conn *cls_conn;
2847
	char *data;
M
Mike Christie 已提交
2848

2849 2850
	cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size,
				     conn_idx);
M
Mike Christie 已提交
2851 2852 2853
	if (!cls_conn)
		return NULL;
	conn = cls_conn->dd_data;
2854
	memset(conn, 0, sizeof(*conn) + dd_size);
M
Mike Christie 已提交
2855

2856
	conn->dd_data = cls_conn->dd_data + sizeof(*conn);
M
Mike Christie 已提交
2857 2858 2859 2860 2861
	conn->session = session;
	conn->cls_conn = cls_conn;
	conn->c_stage = ISCSI_CONN_INITIAL_STAGE;
	conn->id = conn_idx;
	conn->exp_statsn = 0;
2862
	conn->tmf_state = TMF_INITIAL;
2863 2864 2865 2866 2867

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

2868
	INIT_LIST_HEAD(&conn->mgmtqueue);
2869
	INIT_LIST_HEAD(&conn->cmdqueue);
2870
	INIT_LIST_HEAD(&conn->requeue);
D
David Howells 已提交
2871
	INIT_WORK(&conn->xmitwork, iscsi_xmitworker);
M
Mike Christie 已提交
2872

2873
	/* allocate login_task used for the login/text sequences */
M
Mike Christie 已提交
2874
	spin_lock_bh(&session->lock);
2875
	if (!kfifo_out(&session->cmdpool.queue,
2876
                         (void*)&conn->login_task,
M
Mike Christie 已提交
2877 2878
			 sizeof(void*))) {
		spin_unlock_bh(&session->lock);
2879
		goto login_task_alloc_fail;
M
Mike Christie 已提交
2880 2881 2882
	}
	spin_unlock_bh(&session->lock);

2883 2884
	data = (char *) __get_free_pages(GFP_KERNEL,
					 get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
2885
	if (!data)
2886 2887
		goto login_task_data_alloc_fail;
	conn->login_task->data = conn->data = data;
2888

2889
	init_timer(&conn->tmf_timer);
M
Mike Christie 已提交
2890 2891 2892 2893
	init_waitqueue_head(&conn->ehwait);

	return cls_conn;

2894
login_task_data_alloc_fail:
2895
	kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
2896
		    sizeof(void*));
2897
login_task_alloc_fail:
M
Mike Christie 已提交
2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915
	iscsi_destroy_conn(cls_conn);
	return NULL;
}
EXPORT_SYMBOL_GPL(iscsi_conn_setup);

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

2916 2917
	del_timer_sync(&conn->transport_timer);

M
Mike Christie 已提交
2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940
	spin_lock_bh(&session->lock);
	conn->c_stage = ISCSI_CONN_CLEANUP_WAIT;
	if (session->leadconn == conn) {
		/*
		 * leading connection? then give up on recovery.
		 */
		session->state = ISCSI_STATE_TERMINATE;
		wake_up(&conn->ehwait);
	}
	spin_unlock_bh(&session->lock);

	/*
	 * Block until all in-progress commands for this connection
	 * time out or fail.
	 */
	for (;;) {
		spin_lock_irqsave(session->host->host_lock, flags);
		if (!session->host->host_busy) { /* OK for ERL == 0 */
			spin_unlock_irqrestore(session->host->host_lock, flags);
			break;
		}
		spin_unlock_irqrestore(session->host->host_lock, flags);
		msleep_interruptible(500);
2941 2942 2943 2944
		iscsi_conn_printk(KERN_INFO, conn, "iscsi conn_destroy(): "
				  "host_busy %d host_failed %d\n",
				  session->host->host_busy,
				  session->host->host_failed);
M
Mike Christie 已提交
2945 2946 2947 2948 2949 2950
		/*
		 * force eh_abort() to unblock
		 */
		wake_up(&conn->ehwait);
	}

2951
	/* flush queued up work because we free the connection below */
2952
	iscsi_suspend_tx(conn);
2953

M
Mike Christie 已提交
2954
	spin_lock_bh(&session->lock);
2955 2956
	free_pages((unsigned long) conn->data,
		   get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
2957
	kfree(conn->persistent_address);
2958
	kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task,
M
Mike Christie 已提交
2959
		    sizeof(void*));
2960
	if (session->leadconn == conn)
M
Mike Christie 已提交
2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972
		session->leadconn = NULL;
	spin_unlock_bh(&session->lock);

	iscsi_destroy_conn(cls_conn);
}
EXPORT_SYMBOL_GPL(iscsi_conn_teardown);

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

2973
	if (!session) {
2974 2975
		iscsi_conn_printk(KERN_ERR, conn,
				  "can't start unbound connection\n");
M
Mike Christie 已提交
2976 2977 2978
		return -EPERM;
	}

2979 2980
	if ((session->imm_data_en || !session->initial_r2t_en) &&
	     session->first_burst > session->max_burst) {
2981 2982 2983
		iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: "
				  "first_burst %d max_burst %d\n",
				  session->first_burst, session->max_burst);
2984 2985 2986
		return -EINVAL;
	}

2987
	if (conn->ping_timeout && !conn->recv_timeout) {
2988 2989
		iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of "
				  "zero. Using 5 seconds\n.");
2990 2991 2992 2993
		conn->recv_timeout = 5;
	}

	if (conn->recv_timeout && !conn->ping_timeout) {
2994 2995
		iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of "
				  "zero. Using 5 seconds.\n");
2996 2997 2998
		conn->ping_timeout = 5;
	}

M
Mike Christie 已提交
2999 3000 3001
	spin_lock_bh(&session->lock);
	conn->c_stage = ISCSI_CONN_STARTED;
	session->state = ISCSI_STATE_LOGGED_IN;
3002
	session->queued_cmdsn = session->cmdsn;
M
Mike Christie 已提交
3003

3004 3005 3006 3007 3008 3009
	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 已提交
3010 3011 3012 3013 3014 3015 3016
	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;
3017
		conn->tmf_state = TMF_INITIAL;
M
Mike Christie 已提交
3018
		session->age++;
3019 3020
		if (session->age == 16)
			session->age = 0;
3021
		break;
M
Mike Christie 已提交
3022 3023 3024 3025 3026 3027 3028 3029
	case STOP_CONN_TERM:
		conn->stop_stage = 0;
		break;
	default:
		break;
	}
	spin_unlock_bh(&session->lock);

3030
	iscsi_unblock_session(session->cls_session);
3031
	wake_up(&conn->ehwait);
M
Mike Christie 已提交
3032 3033 3034 3035 3036
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_conn_start);

static void
3037
fail_mgmt_tasks(struct iscsi_session *session, struct iscsi_conn *conn)
M
Mike Christie 已提交
3038
{
3039
	struct iscsi_task *task;
3040
	int i, state;
M
Mike Christie 已提交
3041

3042 3043 3044 3045
	for (i = 0; i < conn->session->cmds_max; i++) {
		task = conn->session->cmds[i];
		if (task->sc)
			continue;
M
Mike Christie 已提交
3046

3047 3048
		if (task->state == ISCSI_TASK_FREE)
			continue;
M
Mike Christie 已提交
3049

3050 3051 3052
		ISCSI_DBG_SESSION(conn->session,
				  "failing mgmt itt 0x%x state %d\n",
				  task->itt, task->state);
3053 3054 3055 3056 3057
		state = ISCSI_TASK_ABRT_SESS_RECOV;
		if (task->state == ISCSI_TASK_PENDING)
			state = ISCSI_TASK_COMPLETED;
		iscsi_complete_task(task, state);

3058
	}
M
Mike Christie 已提交
3059 3060
}

3061 3062
static void iscsi_start_session_recovery(struct iscsi_session *session,
					 struct iscsi_conn *conn, int flag)
M
Mike Christie 已提交
3063
{
3064 3065
	int old_stop_stage;

3066
	mutex_lock(&session->eh_mutex);
M
Mike Christie 已提交
3067
	spin_lock_bh(&session->lock);
3068
	if (conn->stop_stage == STOP_CONN_TERM) {
M
Mike Christie 已提交
3069
		spin_unlock_bh(&session->lock);
3070 3071 3072 3073
		mutex_unlock(&session->eh_mutex);
		return;
	}

3074 3075
	/*
	 * When this is called for the in_login state, we only want to clean
3076
	 * up the login task and connection. We do not need to block and set
3077
	 * the recovery state again
3078
	 */
3079 3080 3081 3082
	if (flag == STOP_CONN_TERM)
		session->state = ISCSI_STATE_TERMINATE;
	else if (conn->stop_stage != STOP_CONN_RECOVER)
		session->state = ISCSI_STATE_IN_RECOVERY;
3083 3084 3085

	old_stop_stage = conn->stop_stage;
	conn->stop_stage = flag;
3086
	spin_unlock_bh(&session->lock);
3087

3088 3089 3090 3091
	del_timer_sync(&conn->transport_timer);
	iscsi_suspend_tx(conn);

	spin_lock_bh(&session->lock);
3092
	conn->c_stage = ISCSI_CONN_STOPPED;
M
Mike Christie 已提交
3093
	spin_unlock_bh(&session->lock);
3094

M
Mike Christie 已提交
3095 3096 3097 3098 3099 3100 3101 3102 3103
	/*
	 * 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;
3104
		if (session->state == ISCSI_STATE_IN_RECOVERY &&
3105
		    old_stop_stage != STOP_CONN_RECOVER) {
3106
			ISCSI_DBG_SESSION(session, "blocking session\n");
3107
			iscsi_block_session(session->cls_session);
3108
		}
M
Mike Christie 已提交
3109
	}
3110 3111 3112 3113 3114

	/*
	 * flush queues.
	 */
	spin_lock_bh(&session->lock);
3115
	fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED);
3116
	fail_mgmt_tasks(session, conn);
3117
	memset(&conn->tmhdr, 0, sizeof(conn->tmhdr));
3118
	spin_unlock_bh(&session->lock);
3119
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
3120 3121 3122 3123 3124 3125 3126 3127 3128 3129 3130
}

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);
3131
		break;
M
Mike Christie 已提交
3132
	default:
3133 3134
		iscsi_conn_printk(KERN_ERR, conn,
				  "invalid stop flag %d\n", flag);
M
Mike Christie 已提交
3135 3136 3137 3138 3139 3140 3141
	}
}
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)
{
3142
	struct iscsi_session *session = cls_session->dd_data;
3143
	struct iscsi_conn *conn = cls_conn->dd_data;
M
Mike Christie 已提交
3144 3145 3146 3147

	spin_lock_bh(&session->lock);
	if (is_leading)
		session->leadconn = conn;
3148
	spin_unlock_bh(&session->lock);
M
Mike Christie 已提交
3149 3150 3151 3152 3153 3154 3155 3156 3157 3158

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

3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175
static int iscsi_switch_str_param(char **param, char *new_val_buf)
{
	char *new_val;

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

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

	kfree(*param);
	*param = new_val;
	return 0;
}
3176 3177 3178 3179 3180 3181 3182 3183 3184

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

	switch(param) {
3185 3186 3187
	case ISCSI_PARAM_FAST_ABORT:
		sscanf(buf, "%d", &session->fast_abort);
		break;
3188 3189 3190 3191 3192 3193
	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;
3194 3195 3196
	case ISCSI_PARAM_TGT_RESET_TMO:
		sscanf(buf, "%d", &session->tgt_reset_timeout);
		break;
3197 3198 3199 3200 3201 3202
	case ISCSI_PARAM_PING_TMO:
		sscanf(buf, "%d", &conn->ping_timeout);
		break;
	case ISCSI_PARAM_RECV_TMO:
		sscanf(buf, "%d", &conn->recv_timeout);
		break;
3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249
	case ISCSI_PARAM_MAX_RECV_DLENGTH:
		sscanf(buf, "%d", &conn->max_recv_dlength);
		break;
	case ISCSI_PARAM_MAX_XMIT_DLENGTH:
		sscanf(buf, "%d", &conn->max_xmit_dlength);
		break;
	case ISCSI_PARAM_HDRDGST_EN:
		sscanf(buf, "%d", &conn->hdrdgst_en);
		break;
	case ISCSI_PARAM_DATADGST_EN:
		sscanf(buf, "%d", &conn->datadgst_en);
		break;
	case ISCSI_PARAM_INITIAL_R2T_EN:
		sscanf(buf, "%d", &session->initial_r2t_en);
		break;
	case ISCSI_PARAM_MAX_R2T:
		sscanf(buf, "%d", &session->max_r2t);
		break;
	case ISCSI_PARAM_IMM_DATA_EN:
		sscanf(buf, "%d", &session->imm_data_en);
		break;
	case ISCSI_PARAM_FIRST_BURST:
		sscanf(buf, "%d", &session->first_burst);
		break;
	case ISCSI_PARAM_MAX_BURST:
		sscanf(buf, "%d", &session->max_burst);
		break;
	case ISCSI_PARAM_PDU_INORDER_EN:
		sscanf(buf, "%d", &session->pdu_inorder_en);
		break;
	case ISCSI_PARAM_DATASEQ_INORDER_EN:
		sscanf(buf, "%d", &session->dataseq_inorder_en);
		break;
	case ISCSI_PARAM_ERL:
		sscanf(buf, "%d", &session->erl);
		break;
	case ISCSI_PARAM_IFMARKER_EN:
		sscanf(buf, "%d", &value);
		BUG_ON(value);
		break;
	case ISCSI_PARAM_OFMARKER_EN:
		sscanf(buf, "%d", &value);
		BUG_ON(value);
		break;
	case ISCSI_PARAM_EXP_STATSN:
		sscanf(buf, "%u", &conn->exp_statsn);
		break;
3250
	case ISCSI_PARAM_USERNAME:
3251
		return iscsi_switch_str_param(&session->username, buf);
3252
	case ISCSI_PARAM_USERNAME_IN:
3253
		return iscsi_switch_str_param(&session->username_in, buf);
3254
	case ISCSI_PARAM_PASSWORD:
3255
		return iscsi_switch_str_param(&session->password, buf);
3256
	case ISCSI_PARAM_PASSWORD_IN:
3257
		return iscsi_switch_str_param(&session->password_in, buf);
3258
	case ISCSI_PARAM_TARGET_NAME:
3259
		return iscsi_switch_str_param(&session->targetname, buf);
3260 3261 3262 3263 3264 3265 3266
	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:
3267
		return iscsi_switch_str_param(&conn->persistent_address, buf);
3268
	case ISCSI_PARAM_IFACE_NAME:
3269
		return iscsi_switch_str_param(&session->ifacename, buf);
3270
	case ISCSI_PARAM_INITIATOR_NAME:
3271
		return iscsi_switch_str_param(&session->initiatorname, buf);
3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282
	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)
{
3283
	struct iscsi_session *session = cls_session->dd_data;
3284 3285 3286
	int len;

	switch(param) {
3287 3288 3289
	case ISCSI_PARAM_FAST_ABORT:
		len = sprintf(buf, "%d\n", session->fast_abort);
		break;
3290 3291 3292 3293 3294 3295
	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;
3296 3297 3298
	case ISCSI_PARAM_TGT_RESET_TMO:
		len = sprintf(buf, "%d\n", session->tgt_reset_timeout);
		break;
3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328
	case ISCSI_PARAM_INITIAL_R2T_EN:
		len = sprintf(buf, "%d\n", session->initial_r2t_en);
		break;
	case ISCSI_PARAM_MAX_R2T:
		len = sprintf(buf, "%hu\n", session->max_r2t);
		break;
	case ISCSI_PARAM_IMM_DATA_EN:
		len = sprintf(buf, "%d\n", session->imm_data_en);
		break;
	case ISCSI_PARAM_FIRST_BURST:
		len = sprintf(buf, "%u\n", session->first_burst);
		break;
	case ISCSI_PARAM_MAX_BURST:
		len = sprintf(buf, "%u\n", session->max_burst);
		break;
	case ISCSI_PARAM_PDU_INORDER_EN:
		len = sprintf(buf, "%d\n", session->pdu_inorder_en);
		break;
	case ISCSI_PARAM_DATASEQ_INORDER_EN:
		len = sprintf(buf, "%d\n", session->dataseq_inorder_en);
		break;
	case ISCSI_PARAM_ERL:
		len = sprintf(buf, "%d\n", session->erl);
		break;
	case ISCSI_PARAM_TARGET_NAME:
		len = sprintf(buf, "%s\n", session->targetname);
		break;
	case ISCSI_PARAM_TPGT:
		len = sprintf(buf, "%d\n", session->tpgt);
		break;
3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340
	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;
3341 3342 3343 3344
	case ISCSI_PARAM_IFACE_NAME:
		len = sprintf(buf, "%s\n", session->ifacename);
		break;
	case ISCSI_PARAM_INITIATOR_NAME:
3345
		len = sprintf(buf, "%s\n", session->initiatorname);
3346
		break;
3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361
	default:
		return -ENOSYS;
	}

	return len;
}
EXPORT_SYMBOL_GPL(iscsi_session_get_param);

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

	switch(param) {
3362 3363 3364 3365 3366 3367
	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;
3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402
	case ISCSI_PARAM_MAX_RECV_DLENGTH:
		len = sprintf(buf, "%u\n", conn->max_recv_dlength);
		break;
	case ISCSI_PARAM_MAX_XMIT_DLENGTH:
		len = sprintf(buf, "%u\n", conn->max_xmit_dlength);
		break;
	case ISCSI_PARAM_HDRDGST_EN:
		len = sprintf(buf, "%d\n", conn->hdrdgst_en);
		break;
	case ISCSI_PARAM_DATADGST_EN:
		len = sprintf(buf, "%d\n", conn->datadgst_en);
		break;
	case ISCSI_PARAM_IFMARKER_EN:
		len = sprintf(buf, "%d\n", conn->ifmarker_en);
		break;
	case ISCSI_PARAM_OFMARKER_EN:
		len = sprintf(buf, "%d\n", conn->ofmarker_en);
		break;
	case ISCSI_PARAM_EXP_STATSN:
		len = sprintf(buf, "%u\n", conn->exp_statsn);
		break;
	case ISCSI_PARAM_PERSISTENT_PORT:
		len = sprintf(buf, "%d\n", conn->persistent_port);
		break;
	case ISCSI_PARAM_PERSISTENT_ADDRESS:
		len = sprintf(buf, "%s\n", conn->persistent_address);
		break;
	default:
		return -ENOSYS;
	}

	return len;
}
EXPORT_SYMBOL_GPL(iscsi_conn_get_param);

3403 3404 3405
int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param,
			 char *buf)
{
3406
	struct iscsi_host *ihost = shost_priv(shost);
3407 3408 3409
	int len;

	switch (param) {
3410
	case ISCSI_HOST_PARAM_NETDEV_NAME:
3411
		len = sprintf(buf, "%s\n", ihost->netdev);
3412
		break;
3413
	case ISCSI_HOST_PARAM_HWADDRESS:
3414
		len = sprintf(buf, "%s\n", ihost->hwaddress);
3415
		break;
3416
	case ISCSI_HOST_PARAM_INITIATOR_NAME:
3417
		len = sprintf(buf, "%s\n", ihost->initiatorname);
3418
		break;
3419
	case ISCSI_HOST_PARAM_IPADDRESS:
3420
		len = sprintf(buf, "%s\n", ihost->local_address);
3421
		break;
3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432
	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)
{
3433
	struct iscsi_host *ihost = shost_priv(shost);
3434 3435

	switch (param) {
3436
	case ISCSI_HOST_PARAM_NETDEV_NAME:
3437
		return iscsi_switch_str_param(&ihost->netdev, buf);
3438
	case ISCSI_HOST_PARAM_HWADDRESS:
3439
		return iscsi_switch_str_param(&ihost->hwaddress, buf);
3440
	case ISCSI_HOST_PARAM_INITIATOR_NAME:
3441
		return iscsi_switch_str_param(&ihost->initiatorname, buf);
3442 3443 3444 3445 3446 3447 3448 3449
	default:
		return -ENOSYS;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_host_set_param);

M
Mike Christie 已提交
3450 3451 3452
MODULE_AUTHOR("Mike Christie");
MODULE_DESCRIPTION("iSCSI library functions");
MODULE_LICENSE("GPL");