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

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

#define ISCSI_DBG_CONN(_conn, dbg_fmt, arg...)			\
	do {							\
		if (iscsi_dbg_lib)				\
			iscsi_conn_printk(KERN_INFO, _conn,	\
					     "%s " dbg_fmt,	\
					     __func__, ##arg);	\
	} while (0);

#define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...)			\
	do {								\
		if (iscsi_dbg_lib)					\
			iscsi_session_printk(KERN_INFO, _session,	\
					     "%s " dbg_fmt,		\
					     __func__, ##arg);		\
	} while (0);

63 64
/* Serial Number Arithmetic, 32 bits, less than, RFC1982 */
#define SNA32_CHECK 2147483648UL
M
Mike Christie 已提交
65

66 67 68 69 70 71 72 73 74 75 76 77 78
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)));
}

79 80 81 82 83 84 85 86 87
inline void iscsi_conn_queue_work(struct iscsi_conn *conn)
{
	struct Scsi_Host *shost = conn->session->host;
	struct iscsi_host *ihost = shost_priv(shost);

	queue_work(ihost->workq, &conn->xmitwork);
}
EXPORT_SYMBOL_GPL(iscsi_conn_queue_work);

88 89
void
iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr)
M
Mike Christie 已提交
90 91 92 93
{
	uint32_t max_cmdsn = be32_to_cpu(hdr->max_cmdsn);
	uint32_t exp_cmdsn = be32_to_cpu(hdr->exp_cmdsn);

94 95 96 97 98 99 100 101 102
	/*
	 * 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 已提交
103 104
		session->exp_cmdsn = exp_cmdsn;

105 106 107 108 109 110 111 112
	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
		 */
		if (!list_empty(&session->leadconn->xmitqueue) ||
113 114
		    !list_empty(&session->leadconn->mgmtqueue)) {
			if (!(session->tt->caps & CAP_DATA_PATH_OFFLOAD))
115
				iscsi_conn_queue_work(session->leadconn);
116
		}
117
	}
M
Mike Christie 已提交
118
}
119
EXPORT_SYMBOL_GPL(iscsi_update_cmdsn);
M
Mike Christie 已提交
120

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

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

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

163
static int iscsi_add_hdr(struct iscsi_task *task, unsigned len)
164
{
165
	unsigned exp_len = task->hdr_len + len;
166

167
	if (exp_len > task->hdr_max) {
168 169 170 171 172
		WARN_ON(1);
		return -EINVAL;
	}

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

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

188
	ecdb_ahdr = iscsi_next_hdr(task);
189 190 191 192 193 194 195
	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);

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

209 210 211 212 213
	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);
214 215 216
	return 0;
}

217
static int iscsi_prep_bidi_ahs(struct iscsi_task *task)
218
{
219
	struct scsi_cmnd *sc = task->sc;
220 221 222
	struct iscsi_rlength_ahdr *rlen_ahdr;
	int rc;

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

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

M
Mike Christie 已提交
243 244
/**
 * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu
245
 * @task: iscsi task
M
Mike Christie 已提交
246 247 248 249
 *
 * 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
 */
250
static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task)
M
Mike Christie 已提交
251
{
252
	struct iscsi_conn *conn = task->conn;
M
Mike Christie 已提交
253
	struct iscsi_session *session = conn->session;
254
	struct scsi_cmnd *sc = task->sc;
255
	struct iscsi_cmd *hdr;
256
	unsigned hdrlength, cmd_len;
257
	itt_t itt;
258
	int rc;
M
Mike Christie 已提交
259

260
	rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD);
261 262 263
	if (rc)
		return rc;
	hdr = (struct iscsi_cmd *) task->hdr;
264
	itt = hdr->itt;
265 266
	memset(hdr, 0, sizeof(*hdr));

267 268 269 270 271
	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);
272 273
	task->hdr_len = 0;
	rc = iscsi_add_hdr(task, sizeof(*hdr));
274 275
	if (rc)
		return rc;
276 277 278
	hdr->opcode = ISCSI_OP_SCSI_CMD;
	hdr->flags = ISCSI_ATTR_SIMPLE;
	int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun);
279 280
	memcpy(task->lun, hdr->lun, sizeof(task->lun));
	hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn);
281 282
	session->cmdsn++;
	hdr->exp_statsn = cpu_to_be32(conn->exp_statsn);
283 284 285 286
	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) {
287
		rc = iscsi_prep_ecdb_ahs(task);
288 289 290 291 292
		if (rc)
			return rc;
		cmd_len = ISCSI_CDB_SIZE;
	}
	memcpy(hdr->cdb, sc->cmnd, cmd_len);
M
Mike Christie 已提交
293

294
	task->imm_count = 0;
295 296
	if (scsi_bidi_cmnd(sc)) {
		hdr->flags |= ISCSI_FLAG_CMD_READ;
297
		rc = iscsi_prep_bidi_ahs(task);
298 299 300
		if (rc)
			return rc;
	}
M
Mike Christie 已提交
301
	if (sc->sc_data_direction == DMA_TO_DEVICE) {
302
		unsigned out_len = scsi_out(sc)->length;
303 304
		struct iscsi_r2t_info *r2t = &task->unsol_r2t;

305
		hdr->data_length = cpu_to_be32(out_len);
M
Mike Christie 已提交
306 307 308 309 310 311 312 313 314 315 316
		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
		 *
317
		 *	r2t data_length bytes to be sent via R2T ack's
M
Mike Christie 已提交
318 319 320
		 *
		 *      pad_count       bytes to be sent as zero-padding
		 */
321
		memset(r2t, 0, sizeof(*r2t));
M
Mike Christie 已提交
322 323

		if (session->imm_data_en) {
324
			if (out_len >= session->first_burst)
325
				task->imm_count = min(session->first_burst,
M
Mike Christie 已提交
326 327
							conn->max_xmit_dlength);
			else
328
				task->imm_count = min(out_len,
M
Mike Christie 已提交
329
							conn->max_xmit_dlength);
330
			hton24(hdr->dlength, task->imm_count);
M
Mike Christie 已提交
331
		} else
332
			zero_data(hdr->dlength);
M
Mike Christie 已提交
333

334
		if (!session->initial_r2t_en) {
335 336 337 338 339
			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);
340 341
		}

342
		if (!task->unsol_r2t.data_length)
M
Mike Christie 已提交
343
			/* No unsolicit Data-Out's */
344
			hdr->flags |= ISCSI_FLAG_CMD_FINAL;
M
Mike Christie 已提交
345 346 347
	} else {
		hdr->flags |= ISCSI_FLAG_CMD_FINAL;
		zero_data(hdr->dlength);
348
		hdr->data_length = cpu_to_be32(scsi_in(sc)->length);
M
Mike Christie 已提交
349 350 351 352 353

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

354
	/* calculate size of additional header segments (AHSs) */
355
	hdrlength = task->hdr_len - sizeof(*hdr);
356 357 358 359 360 361 362

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

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

363
	if (session->tt->init_task && session->tt->init_task(task))
364 365
		return -EIO;

366 367
	task->state = ISCSI_TASK_RUNNING;
	list_move_tail(&task->running, &conn->run_list);
368

369
	conn->scsicmd_pdus_cnt++;
370 371 372 373 374 375 376 377 378
	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);
379
	return 0;
M
Mike Christie 已提交
380 381 382
}

/**
383
 * iscsi_complete_command - finish a task
384
 * @task: iscsi cmd task
M
Mike Christie 已提交
385 386
 *
 * Must be called with session lock.
387 388
 * This function returns the scsi command to scsi-ml or cleans
 * up mgmt tasks then returns the task to the pool.
M
Mike Christie 已提交
389
 */
390
static void iscsi_complete_command(struct iscsi_task *task)
M
Mike Christie 已提交
391
{
392
	struct iscsi_conn *conn = task->conn;
393
	struct iscsi_session *session = conn->session;
394
	struct scsi_cmnd *sc = task->sc;
M
Mike Christie 已提交
395

396
	session->tt->cleanup_task(task);
397 398 399
	list_del_init(&task->running);
	task->state = ISCSI_TASK_COMPLETED;
	task->sc = NULL;
400

401 402
	if (conn->task == task)
		conn->task = NULL;
403
	/*
404
	 * login task is preallocated so do not free
405
	 */
406
	if (conn->login_task == task)
407 408
		return;

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

411 412
	if (conn->ping_task == task)
		conn->ping_task = NULL;
413 414

	if (sc) {
415
		task->sc = NULL;
416 417 418 419 420 421 422 423 424
		/* SCSI eh reuses commands to verify us */
		sc->SCp.ptr = NULL;
		/*
		 * queue command may call this to free the task, but
		 * not have setup the sc callback
		 */
		if (sc->scsi_done)
			sc->scsi_done(sc);
	}
M
Mike Christie 已提交
425 426
}

427
void __iscsi_get_task(struct iscsi_task *task)
428
{
429
	atomic_inc(&task->refcount);
430
}
431
EXPORT_SYMBOL_GPL(__iscsi_get_task);
432

433
static void __iscsi_put_task(struct iscsi_task *task)
434
{
435 436
	if (atomic_dec_and_test(&task->refcount))
		iscsi_complete_command(task);
437 438
}

439
void iscsi_put_task(struct iscsi_task *task)
440
{
441
	struct iscsi_session *session = task->conn->session;
442 443

	spin_lock_bh(&session->lock);
444
	__iscsi_put_task(task);
445 446
	spin_unlock_bh(&session->lock);
}
447
EXPORT_SYMBOL_GPL(iscsi_put_task);
448

449 450 451
/*
 * session lock must be held
 */
452
static void fail_command(struct iscsi_conn *conn, struct iscsi_task *task,
453 454 455 456
			 int err)
{
	struct scsi_cmnd *sc;

457
	sc = task->sc;
458 459 460
	if (!sc)
		return;

461
	if (task->state == ISCSI_TASK_PENDING)
462 463 464 465 466 467 468
		/*
		 * cmd never made it to the xmit thread, so we should not count
		 * the cmd in the sequencing
		 */
		conn->session->queued_cmdsn--;

	sc->result = err;
469 470 471 472 473 474
	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;
	}
475

476 477
	if (conn->task == task)
		conn->task = NULL;
478
	/* release ref from queuecommand */
479
	__iscsi_put_task(task);
480 481
}

482
static int iscsi_prep_mgmt_task(struct iscsi_conn *conn,
483
				struct iscsi_task *task)
484 485
{
	struct iscsi_session *session = conn->session;
486
	struct iscsi_hdr *hdr = task->hdr;
487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511
	struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr;

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

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

512 513
	if (session->tt->init_task && session->tt->init_task(task))
		return -EIO;
514 515 516 517

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

518
	task->state = ISCSI_TASK_RUNNING;
519
	list_move_tail(&task->running, &conn->mgmt_run_list);
520 521 522
	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);
523 524 525
	return 0;
}

526
static struct iscsi_task *
527 528 529 530
__iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
		      char *data, uint32_t data_size)
{
	struct iscsi_session *session = conn->session;
531
	struct iscsi_task *task;
532
	itt_t itt;
533 534 535 536 537 538 539 540 541

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

	if (hdr->opcode == (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) ||
	    hdr->opcode == (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE))
		/*
		 * Login and Text are sent serially, in
		 * request-followed-by-response sequence.
542 543
		 * Same task can be used. Same ITT must be used.
		 * Note that login_task is preallocated at conn_create().
544
		 */
545
		task = conn->login_task;
546 547 548 549
	else {
		BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE);
		BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED);

550
		if (!__kfifo_get(session->cmdpool.queue,
551
				 (void*)&task, sizeof(void*)))
552 553
			return NULL;
	}
554 555 556 557 558
	/*
	 * 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.
	 */
559 560 561
	atomic_set(&task->refcount, 1);
	task->conn = conn;
	task->sc = NULL;
562 563

	if (data_size) {
564 565
		memcpy(task->data, data, data_size);
		task->data_count = data_size;
566
	} else
567
		task->data_count = 0;
568

569
	if (conn->session->tt->alloc_pdu(task, hdr->opcode)) {
570 571 572 573
		iscsi_conn_printk(KERN_ERR, conn, "Could not allocate "
				 "pdu for mgmt task.\n");
		goto requeue_task;
	}
574
	itt = task->hdr->itt;
575
	task->hdr_len = sizeof(struct iscsi_hdr);
576
	memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr));
577 578 579 580 581 582 583 584 585

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

586 587
	INIT_LIST_HEAD(&task->running);
	list_add_tail(&task->running, &conn->mgmtqueue);
588 589

	if (session->tt->caps & CAP_DATA_PATH_OFFLOAD) {
590 591
		if (iscsi_prep_mgmt_task(conn, task))
			goto free_task;
592

593
		if (session->tt->xmit_task(task))
594
			goto free_task;
595 596

	} else
597
		iscsi_conn_queue_work(conn);
598

599
	return task;
600 601 602 603 604 605 606 607 608 609

free_task:
	__iscsi_put_task(task);
	return NULL;

requeue_task:
	if (task != conn->login_task)
		__kfifo_put(session->cmdpool.queue, (void*)&task,
			    sizeof(void*));
	return NULL;
610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626
}

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 已提交
627 628 629 630
/**
 * iscsi_cmd_rsp - SCSI Command Response processing
 * @conn: iscsi connection
 * @hdr: iscsi header
631
 * @task: scsi command task
M
Mike Christie 已提交
632 633 634 635
 * @data: cmd data buffer
 * @datalen: len of buffer
 *
 * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and
636
 * then completes the command and task.
M
Mike Christie 已提交
637
 **/
638
static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
639
			       struct iscsi_task *task, char *data,
640
			       int datalen)
M
Mike Christie 已提交
641 642 643
{
	struct iscsi_cmd_rsp *rhdr = (struct iscsi_cmd_rsp *)hdr;
	struct iscsi_session *session = conn->session;
644
	struct scsi_cmnd *sc = task->sc;
M
Mike Christie 已提交
645

646
	iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr);
M
Mike Christie 已提交
647 648 649 650 651 652 653 654 655 656
	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) {
657
		uint16_t senselen;
M
Mike Christie 已提交
658 659 660

		if (datalen < 2) {
invalid_datalen:
661 662 663
			iscsi_conn_printk(KERN_ERR,  conn,
					 "Got CHECK_CONDITION but invalid data "
					 "buffer size of %d\n", datalen);
M
Mike Christie 已提交
664 665 666 667
			sc->result = DID_BAD_TARGET << 16;
			goto out;
		}

668
		senselen = get_unaligned_be16(data);
M
Mike Christie 已提交
669 670 671 672
		if (datalen < senselen)
			goto invalid_datalen;

		memcpy(sc->sense_buffer, data + 2,
673
		       min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE));
674 675 676
		ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n",
				  min_t(uint16_t, senselen,
				  SCSI_SENSE_BUFFERSIZE));
M
Mike Christie 已提交
677 678
	}

679 680 681 682 683 684 685 686 687 688 689 690
	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;
	}

691 692
	if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW |
	                   ISCSI_FLAG_CMD_OVERFLOW)) {
M
Mike Christie 已提交
693 694
		int res_count = be32_to_cpu(rhdr->residual_count);

695 696 697
		if (res_count > 0 &&
		    (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW ||
		     res_count <= scsi_bufflen(sc)))
698
			/* write side for bidi or uni-io set_resid */
699
			scsi_set_resid(sc, res_count);
M
Mike Christie 已提交
700 701
		else
			sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status;
702
	}
M
Mike Christie 已提交
703
out:
704 705
	ISCSI_DBG_SESSION(session, "done [sc %p res %d itt 0x%x]\n",
			  sc, sc->result, task->itt);
M
Mike Christie 已提交
706 707
	conn->scsirsp_pdus_cnt++;

708
	__iscsi_put_task(task);
M
Mike Christie 已提交
709 710
}

711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744
/**
 * 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;

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

	conn->scsirsp_pdus_cnt++;
	__iscsi_put_task(task);
}

745 746 747 748 749 750 751
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++;

752
	if (conn->tmf_state != TMF_QUEUED)
753 754 755
		return;

	if (tmf->response == ISCSI_TMF_RSP_COMPLETE)
756
		conn->tmf_state = TMF_SUCCESS;
757
	else if (tmf->response == ISCSI_TMF_RSP_NO_TASK)
758
		conn->tmf_state = TMF_NOT_FOUND;
759
	else
760
		conn->tmf_state = TMF_FAILED;
761 762 763
	wake_up(&conn->ehwait);
}

764 765 766
static void iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr)
{
        struct iscsi_nopout hdr;
767
	struct iscsi_task *task;
768

769
	if (!rhdr && conn->ping_task)
770 771 772 773 774 775 776 777 778 779 780 781 782
		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;

783 784
	task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0);
	if (!task)
785
		iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n");
786 787 788 789 790
	else if (!rhdr) {
		/* only track our nops */
		conn->ping_task = task;
		conn->last_ping = jiffies;
	}
791 792
}

793 794 795 796 797 798 799 800 801 802 803 804 805 806
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;

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

	if (reject->reason == ISCSI_REASON_DATA_DIGEST_ERROR) {
		if (ntoh24(reject->dlength) > datalen)
			return ISCSI_ERR_PROTO;

		if (ntoh24(reject->dlength) >= sizeof(struct iscsi_hdr)) {
			memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr));
807
			iscsi_conn_printk(KERN_ERR, conn,
808 809
					  "pdu (op 0x%x) rejected "
					  "due to DataDigest error.\n",
810
					  rejected_pdu.opcode);
811 812 813 814 815
		}
	}
	return 0;
}

816 817 818 819 820 821 822 823 824 825 826 827 828
/**
 * 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.
 */
static struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt)
{
	struct iscsi_session *session = conn->session;
829
	int i;
830 831 832 833

	if (itt == RESERVED_ITT)
		return NULL;

834 835 836 837
	if (session->tt->parse_pdu_itt)
		session->tt->parse_pdu_itt(conn, itt, &i, NULL);
	else
		i = get_itt(itt);
838 839 840 841 842 843
	if (i >= session->cmds_max)
		return NULL;

	return session->cmds[i];
}

M
Mike Christie 已提交
844 845 846 847 848 849 850 851 852 853 854
/**
 * __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.
 */
855 856
int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr,
			 char *data, int datalen)
M
Mike Christie 已提交
857 858 859
{
	struct iscsi_session *session = conn->session;
	int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0;
860
	struct iscsi_task *task;
M
Mike Christie 已提交
861 862
	uint32_t itt;

863
	conn->last_recv = jiffies;
864 865 866 867
	rc = iscsi_verify_itt(conn, hdr->itt);
	if (rc)
		return rc;

A
Al Viro 已提交
868 869
	if (hdr->itt != RESERVED_ITT)
		itt = get_itt(hdr->itt);
M
Mike Christie 已提交
870
	else
A
Al Viro 已提交
871
		itt = ~0U;
M
Mike Christie 已提交
872

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

876
	if (itt == ~0U) {
877
		iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr);
878

M
Mike Christie 已提交
879 880
		switch(opcode) {
		case ISCSI_OP_NOOP_IN:
881
			if (datalen) {
M
Mike Christie 已提交
882
				rc = ISCSI_ERR_PROTO;
883 884 885
				break;
			}

A
Al Viro 已提交
886
			if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG))
887 888
				break;

889
			iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr);
M
Mike Christie 已提交
890 891
			break;
		case ISCSI_OP_REJECT:
892 893
			rc = iscsi_handle_reject(conn, hdr, data, datalen);
			break;
M
Mike Christie 已提交
894
		case ISCSI_OP_ASYNC_EVENT:
895
			conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1;
M
Mike Christie 已提交
896 897
			if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen))
				rc = ISCSI_ERR_CONN_FAILED;
M
Mike Christie 已提交
898 899 900 901 902
			break;
		default:
			rc = ISCSI_ERR_BAD_OPCODE;
			break;
		}
903 904 905 906 907
		goto out;
	}

	switch(opcode) {
	case ISCSI_OP_SCSI_CMD_RSP:
908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932
	case ISCSI_OP_SCSI_DATA_IN:
		task = iscsi_itt_to_ctask(conn, hdr->itt);
		if (!task)
			return ISCSI_ERR_BAD_ITT;
		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:
933
		iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen);
934 935
		break;
	case ISCSI_OP_SCSI_DATA_IN:
936
		iscsi_data_in_rsp(conn, hdr, task);
937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961
		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);
962
		__iscsi_put_task(task);
963 964 965 966 967 968 969 970 971
		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;

972
		if (conn->ping_task != task)
973 974 975 976 977
			/*
			 * If this is not in response to one of our
			 * nops then it must be from userspace.
			 */
			goto recv_pdu;
978 979 980

		mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout);
		__iscsi_put_task(task);
981 982 983 984 985
		break;
	default:
		rc = ISCSI_ERR_BAD_OPCODE;
		break;
	}
M
Mike Christie 已提交
986

987 988 989 990 991
out:
	return rc;
recv_pdu:
	if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen))
		rc = ISCSI_ERR_CONN_FAILED;
992
	__iscsi_put_task(task);
M
Mike Christie 已提交
993 994
	return rc;
}
995
EXPORT_SYMBOL_GPL(__iscsi_complete_pdu);
M
Mike Christie 已提交
996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008

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

1009
int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt)
M
Mike Christie 已提交
1010 1011
{
	struct iscsi_session *session = conn->session;
1012
	int age = 0, i = 0;
M
Mike Christie 已提交
1013

1014 1015
	if (itt == RESERVED_ITT)
		return 0;
M
Mike Christie 已提交
1016

1017 1018 1019 1020 1021 1022 1023 1024
	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) {
1025 1026
		iscsi_conn_printk(KERN_ERR, conn,
				  "received itt %x expected session age (%x)\n",
1027
				  (__force u32)itt, session->age);
1028 1029
		return ISCSI_ERR_BAD_ITT;
	}
M
Mike Christie 已提交
1030

1031 1032 1033 1034 1035
	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 已提交
1036 1037 1038 1039 1040
	}
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_verify_itt);

1041 1042 1043 1044 1045 1046 1047 1048 1049 1050
/**
 * 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)
1051
{
1052
	struct iscsi_task *task;
1053 1054 1055 1056

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

1057 1058
	task = iscsi_itt_to_task(conn, itt);
	if (!task || !task->sc)
1059 1060
		return NULL;

1061 1062 1063 1064
	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);
1065
		return NULL;
1066
	}
1067

1068
	return task;
1069 1070 1071
}
EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask);

1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103
void iscsi_session_failure(struct iscsi_cls_session *cls_session,
			   enum iscsi_err err)
{
	struct iscsi_session *session = cls_session->dd_data;
	struct iscsi_conn *conn;
	struct device *dev;
	unsigned long flags;

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

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

M
Mike Christie 已提交
1104 1105 1106 1107 1108 1109
void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err)
{
	struct iscsi_session *session = conn->session;
	unsigned long flags;

	spin_lock_irqsave(&session->lock, flags);
1110 1111 1112 1113 1114
	if (session->state == ISCSI_STATE_FAILED) {
		spin_unlock_irqrestore(&session->lock, flags);
		return;
	}

1115
	if (conn->stop_stage == 0)
M
Mike Christie 已提交
1116 1117
		session->state = ISCSI_STATE_FAILED;
	spin_unlock_irqrestore(&session->lock, flags);
1118

M
Mike Christie 已提交
1119 1120
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx);
1121
	iscsi_conn_error_event(conn->cls_conn, err);
M
Mike Christie 已提交
1122 1123 1124
}
EXPORT_SYMBOL_GPL(iscsi_conn_failure);

1125 1126 1127 1128 1129 1130 1131
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
	 */
1132
	if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) {
1133 1134 1135 1136
		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);
1137 1138 1139 1140 1141
		return -ENOSPC;
	}
	return 0;
}

1142
static int iscsi_xmit_task(struct iscsi_conn *conn)
1143
{
1144
	struct iscsi_task *task = conn->task;
1145
	int rc;
1146

1147
	__iscsi_get_task(task);
1148
	spin_unlock_bh(&conn->session->lock);
1149
	rc = conn->session->tt->xmit_task(task);
1150
	spin_lock_bh(&conn->session->lock);
1151
	__iscsi_put_task(task);
1152
	if (!rc)
1153 1154
		/* done with this task */
		conn->task = NULL;
1155 1156 1157
	return rc;
}

1158
/**
1159 1160
 * iscsi_requeue_task - requeue task to run from session workqueue
 * @task: task to requeue
1161
 *
1162
 * LLDs that need to run a task from the session workqueue should call
1163 1164
 * this. The session lock must be held. This should only be called
 * by software drivers.
1165
 */
1166
void iscsi_requeue_task(struct iscsi_task *task)
1167
{
1168
	struct iscsi_conn *conn = task->conn;
1169

1170
	list_move_tail(&task->running, &conn->requeue);
1171
	iscsi_conn_queue_work(conn);
1172
}
1173
EXPORT_SYMBOL_GPL(iscsi_requeue_task);
1174

M
Mike Christie 已提交
1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185
/**
 * 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)
{
1186
	int rc = 0;
M
Mike Christie 已提交
1187

1188
	spin_lock_bh(&conn->session->lock);
M
Mike Christie 已提交
1189
	if (unlikely(conn->suspend_tx)) {
1190
		ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n");
1191
		spin_unlock_bh(&conn->session->lock);
1192
		return -ENODATA;
M
Mike Christie 已提交
1193 1194
	}

1195 1196
	if (conn->task) {
		rc = iscsi_xmit_task(conn);
1197
	        if (rc)
M
Mike Christie 已提交
1198 1199 1200
		        goto again;
	}

1201 1202 1203 1204 1205 1206
	/*
	 * 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:
1207
	while (!list_empty(&conn->mgmtqueue)) {
1208 1209 1210 1211 1212
		conn->task = list_entry(conn->mgmtqueue.next,
					 struct iscsi_task, running);
		if (iscsi_prep_mgmt_task(conn, conn->task)) {
			__iscsi_put_task(conn->task);
			conn->task = NULL;
1213 1214
			continue;
		}
1215
		rc = iscsi_xmit_task(conn);
1216 1217
		if (rc)
			goto again;
M
Mike Christie 已提交
1218 1219
	}

1220
	/* process pending command queue */
1221
	while (!list_empty(&conn->xmitqueue)) {
1222 1223 1224
		if (conn->tmf_state == TMF_QUEUED)
			break;

1225 1226
		conn->task = list_entry(conn->xmitqueue.next,
					 struct iscsi_task, running);
1227
		if (conn->session->state == ISCSI_STATE_LOGGING_OUT) {
1228
			fail_command(conn, conn->task, DID_IMM_RETRY << 16);
1229 1230
			continue;
		}
1231 1232 1233 1234 1235 1236 1237
		rc = iscsi_prep_scsi_cmd_pdu(conn->task);
		if (rc) {
			if (rc == -ENOMEM) {
				conn->task = NULL;
				goto again;
			} else
				fail_command(conn, conn->task, DID_ABORT << 16);
1238 1239
			continue;
		}
1240
		rc = iscsi_xmit_task(conn);
1241
		if (rc)
1242
			goto again;
1243
		/*
1244
		 * we could continuously get new task requests so
1245 1246 1247
		 * we need to check the mgmt queue for nops that need to
		 * be sent to aviod starvation
		 */
1248 1249 1250 1251 1252 1253 1254 1255
		if (!list_empty(&conn->mgmtqueue))
			goto check_mgmt;
	}

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

1256 1257 1258 1259 1260 1261
		/*
		 * we always do fastlogout - conn stop code will clean up.
		 */
		if (conn->session->state == ISCSI_STATE_LOGGING_OUT)
			break;

1262 1263 1264
		conn->task = list_entry(conn->requeue.next,
					 struct iscsi_task, running);
		conn->task->state = ISCSI_TASK_RUNNING;
1265
		list_move_tail(conn->requeue.next, &conn->run_list);
1266
		rc = iscsi_xmit_task(conn);
1267 1268 1269
		if (rc)
			goto again;
		if (!list_empty(&conn->mgmtqueue))
1270
			goto check_mgmt;
M
Mike Christie 已提交
1271
	}
1272
	spin_unlock_bh(&conn->session->lock);
1273
	return -ENODATA;
M
Mike Christie 已提交
1274 1275 1276

again:
	if (unlikely(conn->suspend_tx))
1277 1278
		rc = -ENODATA;
	spin_unlock_bh(&conn->session->lock);
1279
	return rc;
M
Mike Christie 已提交
1280 1281
}

D
David Howells 已提交
1282
static void iscsi_xmitworker(struct work_struct *work)
M
Mike Christie 已提交
1283
{
D
David Howells 已提交
1284 1285
	struct iscsi_conn *conn =
		container_of(work, struct iscsi_conn, xmitwork);
1286
	int rc;
M
Mike Christie 已提交
1287 1288 1289
	/*
	 * serialize Xmit worker on a per-connection basis.
	 */
1290 1291 1292
	do {
		rc = iscsi_data_xmit(conn);
	} while (rc >= 0 || rc == -EAGAIN);
M
Mike Christie 已提交
1293 1294
}

1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314
static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn,
						  struct scsi_cmnd *sc)
{
	struct iscsi_task *task;

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

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

	atomic_set(&task->refcount, 1);
	task->state = ISCSI_TASK_PENDING;
	task->conn = conn;
	task->sc = sc;
	INIT_LIST_HEAD(&task->running);
	return task;
}

M
Mike Christie 已提交
1315 1316 1317 1318 1319
enum {
	FAILURE_BAD_HOST = 1,
	FAILURE_SESSION_FAILED,
	FAILURE_SESSION_FREED,
	FAILURE_WINDOW_CLOSED,
1320
	FAILURE_OOM,
M
Mike Christie 已提交
1321
	FAILURE_SESSION_TERMINATE,
1322
	FAILURE_SESSION_IN_RECOVERY,
M
Mike Christie 已提交
1323
	FAILURE_SESSION_RECOVERY_TIMEOUT,
1324
	FAILURE_SESSION_LOGGING_OUT,
1325
	FAILURE_SESSION_NOT_READY,
M
Mike Christie 已提交
1326 1327 1328 1329
};

int iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
{
1330
	struct iscsi_cls_session *cls_session;
M
Mike Christie 已提交
1331 1332 1333 1334
	struct Scsi_Host *host;
	int reason = 0;
	struct iscsi_session *session;
	struct iscsi_conn *conn;
1335
	struct iscsi_task *task = NULL;
M
Mike Christie 已提交
1336 1337 1338

	sc->scsi_done = done;
	sc->result = 0;
1339
	sc->SCp.ptr = NULL;
M
Mike Christie 已提交
1340 1341

	host = sc->device->host;
1342
	spin_unlock(host->host_lock);
M
Mike Christie 已提交
1343

1344 1345
	cls_session = starget_to_session(scsi_target(sc->device));
	session = cls_session->dd_data;
M
Mike Christie 已提交
1346 1347
	spin_lock(&session->lock);

1348
	reason = iscsi_session_chkready(cls_session);
1349 1350 1351 1352 1353
	if (reason) {
		sc->result = reason;
		goto fault;
	}

1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366
	/*
	 * ISCSI_STATE_FAILED is a temp. state. The recovery
	 * code will decide what is best to do with command queued
	 * during this time
	 */
	if (session->state != ISCSI_STATE_LOGGED_IN &&
	    session->state != ISCSI_STATE_FAILED) {
		/*
		 * 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)
		 */
1367 1368
		switch (session->state) {
		case ISCSI_STATE_IN_RECOVERY:
1369
			reason = FAILURE_SESSION_IN_RECOVERY;
1370
			goto reject;
1371 1372
		case ISCSI_STATE_LOGGING_OUT:
			reason = FAILURE_SESSION_LOGGING_OUT;
1373
			goto reject;
1374
		case ISCSI_STATE_RECOVERY_FAILED:
1375
			reason = FAILURE_SESSION_RECOVERY_TIMEOUT;
1376
			sc->result = DID_TRANSPORT_FAILFAST << 16;
1377 1378
			break;
		case ISCSI_STATE_TERMINATE:
1379
			reason = FAILURE_SESSION_TERMINATE;
1380
			sc->result = DID_NO_CONNECT << 16;
1381 1382
			break;
		default:
1383
			reason = FAILURE_SESSION_FREED;
1384
			sc->result = DID_NO_CONNECT << 16;
1385
		}
M
Mike Christie 已提交
1386 1387 1388 1389
		goto fault;
	}

	conn = session->leadconn;
1390 1391
	if (!conn) {
		reason = FAILURE_SESSION_FREED;
1392
		sc->result = DID_NO_CONNECT << 16;
1393 1394
		goto fault;
	}
M
Mike Christie 已提交
1395

1396 1397 1398 1399 1400
	if (iscsi_check_cmdsn_window_closed(conn)) {
		reason = FAILURE_WINDOW_CLOSED;
		goto reject;
	}

1401 1402
	task = iscsi_alloc_task(conn, sc);
	if (!task) {
1403 1404 1405
		reason = FAILURE_OOM;
		goto reject;
	}
1406
	list_add_tail(&task->running, &conn->xmitqueue);
M
Mike Christie 已提交
1407

1408
	if (session->tt->caps & CAP_DATA_PATH_OFFLOAD) {
1409 1410 1411 1412 1413 1414 1415 1416 1417
		reason = iscsi_prep_scsi_cmd_pdu(task);
		if (reason) {
			if (reason == -ENOMEM) {
				reason = FAILURE_OOM;
				goto prepd_reject;
			} else {
				sc->result = DID_ABORT << 16;
				goto prepd_fault;
			}
1418
		}
1419
		if (session->tt->xmit_task(task)) {
1420
			reason = FAILURE_SESSION_NOT_READY;
1421
			goto prepd_reject;
1422 1423
		}
	} else
1424
		iscsi_conn_queue_work(conn);
1425 1426 1427

	session->queued_cmdsn++;
	spin_unlock(&session->lock);
1428
	spin_lock(host->host_lock);
M
Mike Christie 已提交
1429 1430
	return 0;

1431 1432 1433
prepd_reject:
	sc->scsi_done = NULL;
	iscsi_complete_command(task);
M
Mike Christie 已提交
1434 1435
reject:
	spin_unlock(&session->lock);
1436 1437
	ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n",
			  sc->cmnd[0], reason);
1438
	spin_lock(host->host_lock);
1439
	return SCSI_MLQUEUE_TARGET_BUSY;
M
Mike Christie 已提交
1440

1441 1442 1443
prepd_fault:
	sc->scsi_done = NULL;
	iscsi_complete_command(task);
M
Mike Christie 已提交
1444 1445
fault:
	spin_unlock(&session->lock);
1446 1447
	ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n",
			  sc->cmnd[0], reason);
1448 1449 1450 1451 1452 1453
	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;
	}
1454
	done(sc);
1455
	spin_lock(host->host_lock);
M
Mike Christie 已提交
1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_queuecommand);

int iscsi_change_queue_depth(struct scsi_device *sdev, int depth)
{
	scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth);
	return sdev->queue_depth;
}
EXPORT_SYMBOL_GPL(iscsi_change_queue_depth);

void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session)
{
1469
	struct iscsi_session *session = cls_session->dd_data;
M
Mike Christie 已提交
1470 1471 1472

	spin_lock_bh(&session->lock);
	if (session->state != ISCSI_STATE_LOGGED_IN) {
1473
		session->state = ISCSI_STATE_RECOVERY_FAILED;
1474 1475
		if (session->leadconn)
			wake_up(&session->leadconn->ehwait);
M
Mike Christie 已提交
1476 1477 1478 1479 1480
	}
	spin_unlock_bh(&session->lock);
}
EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout);

1481
int iscsi_eh_target_reset(struct scsi_cmnd *sc)
M
Mike Christie 已提交
1482
{
1483 1484 1485 1486 1487 1488 1489
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
	struct iscsi_conn *conn;

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

1491
	mutex_lock(&session->eh_mutex);
M
Mike Christie 已提交
1492 1493 1494
	spin_lock_bh(&session->lock);
	if (session->state == ISCSI_STATE_TERMINATE) {
failed:
1495 1496 1497 1498
		iscsi_session_printk(KERN_INFO, session,
				     "failing target reset: Could not log "
				     "back into target [age %d]\n",
				     session->age);
M
Mike Christie 已提交
1499
		spin_unlock_bh(&session->lock);
1500
		mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
1501 1502 1503 1504
		return FAILED;
	}

	spin_unlock_bh(&session->lock);
1505
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
1506 1507 1508 1509
	/*
	 * we drop the lock here but the leadconn cannot be destoyed while
	 * we are in the scsi eh
	 */
1510
	iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
M
Mike Christie 已提交
1511

1512
	ISCSI_DBG_SESSION(session, "wait for relogin\n");
M
Mike Christie 已提交
1513 1514 1515
	wait_event_interruptible(conn->ehwait,
				 session->state == ISCSI_STATE_TERMINATE ||
				 session->state == ISCSI_STATE_LOGGED_IN ||
1516
				 session->state == ISCSI_STATE_RECOVERY_FAILED);
M
Mike Christie 已提交
1517 1518 1519
	if (signal_pending(current))
		flush_signals(current);

1520
	mutex_lock(&session->eh_mutex);
M
Mike Christie 已提交
1521 1522
	spin_lock_bh(&session->lock);
	if (session->state == ISCSI_STATE_LOGGED_IN)
1523
		iscsi_session_printk(KERN_INFO, session,
1524
				     "target reset succeeded\n");
M
Mike Christie 已提交
1525 1526 1527
	else
		goto failed;
	spin_unlock_bh(&session->lock);
1528
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
1529 1530
	return SUCCESS;
}
1531
EXPORT_SYMBOL_GPL(iscsi_eh_target_reset);
M
Mike Christie 已提交
1532

1533
static void iscsi_tmf_timedout(unsigned long data)
M
Mike Christie 已提交
1534
{
1535
	struct iscsi_conn *conn = (struct iscsi_conn *)data;
M
Mike Christie 已提交
1536 1537 1538
	struct iscsi_session *session = conn->session;

	spin_lock(&session->lock);
1539 1540
	if (conn->tmf_state == TMF_QUEUED) {
		conn->tmf_state = TMF_TIMEDOUT;
1541
		ISCSI_DBG_SESSION(session, "tmf timedout\n");
M
Mike Christie 已提交
1542 1543 1544 1545 1546 1547
		/* unblock eh_abort() */
		wake_up(&conn->ehwait);
	}
	spin_unlock(&session->lock);
}

1548
static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn,
1549 1550
				   struct iscsi_tm *hdr, int age,
				   int timeout)
M
Mike Christie 已提交
1551 1552
{
	struct iscsi_session *session = conn->session;
1553
	struct iscsi_task *task;
M
Mike Christie 已提交
1554

1555
	task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr,
1556
				      NULL, 0);
1557
	if (!task) {
1558
		spin_unlock_bh(&session->lock);
M
Mike Christie 已提交
1559
		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
1560
		spin_lock_bh(&session->lock);
1561
		ISCSI_DBG_SESSION(session, "tmf exec failure\n");
1562
		return -EPERM;
M
Mike Christie 已提交
1563
	}
1564
	conn->tmfcmd_pdus_cnt++;
1565
	conn->tmf_timer.expires = timeout * HZ + jiffies;
1566 1567 1568
	conn->tmf_timer.function = iscsi_tmf_timedout;
	conn->tmf_timer.data = (unsigned long)conn;
	add_timer(&conn->tmf_timer);
1569
	ISCSI_DBG_SESSION(session, "tmf set timeout\n");
M
Mike Christie 已提交
1570 1571

	spin_unlock_bh(&session->lock);
1572
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
1573 1574 1575 1576

	/*
	 * block eh thread until:
	 *
1577 1578
	 * 1) tmf response
	 * 2) tmf timeout
M
Mike Christie 已提交
1579 1580 1581
	 * 3) session is terminated or restarted or userspace has
	 * given up on recovery
	 */
1582
	wait_event_interruptible(conn->ehwait, age != session->age ||
M
Mike Christie 已提交
1583
				 session->state != ISCSI_STATE_LOGGED_IN ||
1584
				 conn->tmf_state != TMF_QUEUED);
M
Mike Christie 已提交
1585 1586
	if (signal_pending(current))
		flush_signals(current);
1587 1588
	del_timer_sync(&conn->tmf_timer);

1589
	mutex_lock(&session->eh_mutex);
1590
	spin_lock_bh(&session->lock);
1591
	/* if the session drops it will clean up the task */
1592 1593 1594
	if (age != session->age ||
	    session->state != ISCSI_STATE_LOGGED_IN)
		return -ENOTCONN;
M
Mike Christie 已提交
1595 1596 1597
	return 0;
}

1598 1599 1600 1601
/*
 * Fail commands. session lock held and recv side suspended and xmit
 * thread flushed
 */
1602 1603
static void fail_all_commands(struct iscsi_conn *conn, unsigned lun,
			      int error)
1604
{
1605
	struct iscsi_task *task, *tmp;
1606

1607 1608
	if (conn->task && (conn->task->sc->device->lun == lun || lun == -1))
		conn->task = NULL;
1609 1610

	/* flush pending */
1611 1612
	list_for_each_entry_safe(task, tmp, &conn->xmitqueue, running) {
		if (lun == task->sc->device->lun || lun == -1) {
1613 1614 1615
			ISCSI_DBG_SESSION(conn->session,
					  "failing pending sc %p itt 0x%x\n",
					  task->sc, task->itt);
1616
			fail_command(conn, task, error << 16);
1617 1618 1619
		}
	}

1620 1621
	list_for_each_entry_safe(task, tmp, &conn->requeue, running) {
		if (lun == task->sc->device->lun || lun == -1) {
1622 1623 1624
			ISCSI_DBG_SESSION(conn->session,
					  "failing requeued sc %p itt 0x%x\n",
					  task->sc, task->itt);
1625
			fail_command(conn, task, error << 16);
1626 1627 1628 1629
		}
	}

	/* fail all other running */
1630 1631
	list_for_each_entry_safe(task, tmp, &conn->run_list, running) {
		if (lun == task->sc->device->lun || lun == -1) {
1632 1633 1634
			ISCSI_DBG_SESSION(conn->session,
					 "failing in progress sc %p itt 0x%x\n",
					 task->sc, task->itt);
1635
			fail_command(conn, task, error << 16);
1636 1637 1638 1639
		}
	}
}

1640
void iscsi_suspend_tx(struct iscsi_conn *conn)
1641
{
1642 1643 1644
	struct Scsi_Host *shost = conn->session->host;
	struct iscsi_host *ihost = shost_priv(shost);

1645
	set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
1646
	if (!(conn->session->tt->caps & CAP_DATA_PATH_OFFLOAD))
1647
		flush_workqueue(ihost->workq);
1648
}
1649
EXPORT_SYMBOL_GPL(iscsi_suspend_tx);
1650 1651 1652 1653

static void iscsi_start_tx(struct iscsi_conn *conn)
{
	clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx);
1654
	if (!(conn->session->tt->caps & CAP_DATA_PATH_OFFLOAD))
1655
		iscsi_conn_queue_work(conn);
1656 1657
}

J
Jens Axboe 已提交
1658
static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *scmd)
1659 1660 1661 1662
{
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
	struct iscsi_conn *conn;
J
Jens Axboe 已提交
1663
	enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED;
1664 1665

	cls_session = starget_to_session(scsi_target(scmd->device));
1666
	session = cls_session->dd_data;
1667

1668
	ISCSI_DBG_SESSION(session, "scsi cmd %p timedout\n", scmd);
1669 1670 1671 1672 1673 1674 1675

	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 已提交
1676
		rc = BLK_EH_RESET_TIMER;
1677 1678 1679 1680 1681 1682
		goto done;
	}

	conn = session->leadconn;
	if (!conn) {
		/* In the middle of shuting down */
J
Jens Axboe 已提交
1683
		rc = BLK_EH_RESET_TIMER;
1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694
		goto done;
	}

	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
	 */
	if (time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) +
			    (conn->ping_timeout * HZ), jiffies))
J
Jens Axboe 已提交
1695
		rc = BLK_EH_RESET_TIMER;
1696 1697 1698 1699 1700 1701
	/*
	 * if we are about to check the transport then give the command
	 * more time
	 */
	if (time_before_eq(conn->last_recv + (conn->recv_timeout * HZ),
			   jiffies))
J
Jens Axboe 已提交
1702
		rc = BLK_EH_RESET_TIMER;
1703
	/* if in the middle of checking the transport then give us more time */
1704
	if (conn->ping_task)
J
Jens Axboe 已提交
1705
		rc = BLK_EH_RESET_TIMER;
1706 1707
done:
	spin_unlock(&session->lock);
1708 1709
	ISCSI_DBG_SESSION(session, "return %s\n", rc == BLK_EH_RESET_TIMER ?
			  "timer reset" : "nh");
1710 1711 1712 1713 1714 1715 1716
	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;
1717
	unsigned long recv_timeout, next_timeout = 0, last_recv;
1718 1719 1720 1721 1722

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

1723 1724
	recv_timeout = conn->recv_timeout;
	if (!recv_timeout)
1725 1726
		goto done;

1727
	recv_timeout *= HZ;
1728
	last_recv = conn->last_recv;
1729
	if (conn->ping_task &&
1730
	    time_before_eq(conn->last_ping + (conn->ping_timeout * HZ),
1731
			   jiffies)) {
1732 1733 1734 1735
		iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs "
				  "expired, last rx %lu, last ping %lu, "
				  "now %lu\n", conn->ping_timeout, last_recv,
				  conn->last_ping, jiffies);
1736 1737 1738 1739 1740
		spin_unlock(&session->lock);
		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
		return;
	}

1741
	if (time_before_eq(last_recv + recv_timeout, jiffies)) {
1742
		/* send a ping to try to provoke some traffic */
1743
		ISCSI_DBG_CONN(conn, "Sending nopout as ping\n");
1744
		iscsi_send_nopout(conn, NULL);
1745
		next_timeout = conn->last_ping + (conn->ping_timeout * HZ);
1746
	} else
1747
		next_timeout = last_recv + recv_timeout;
1748

1749
	ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout);
1750
	mod_timer(&conn->transport_timer, next_timeout);
1751 1752 1753 1754
done:
	spin_unlock(&session->lock);
}

1755
static void iscsi_prep_abort_task_pdu(struct iscsi_task *task,
1756 1757 1758 1759 1760 1761
				      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;
1762 1763 1764
	memcpy(hdr->lun, task->lun, sizeof(hdr->lun));
	hdr->rtt = task->hdr_itt;
	hdr->refcmdsn = task->cmdsn;
1765 1766
}

M
Mike Christie 已提交
1767 1768
int iscsi_eh_abort(struct scsi_cmnd *sc)
{
1769 1770
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
1771
	struct iscsi_conn *conn;
1772
	struct iscsi_task *task;
1773 1774
	struct iscsi_tm *hdr;
	int rc, age;
M
Mike Christie 已提交
1775

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

1779 1780
	mutex_lock(&session->eh_mutex);
	spin_lock_bh(&session->lock);
1781 1782 1783 1784 1785
	/*
	 * if session was ISCSI_STATE_IN_RECOVERY then we may not have
	 * got the command.
	 */
	if (!sc->SCp.ptr) {
1786 1787
		ISCSI_DBG_SESSION(session, "sc never reached iscsi layer or "
				  "it completed.\n");
1788 1789
		spin_unlock_bh(&session->lock);
		mutex_unlock(&session->eh_mutex);
1790 1791 1792
		return SUCCESS;
	}

M
Mike Christie 已提交
1793 1794 1795 1796
	/*
	 * If we are not logged in or we have started a new session
	 * then let the host reset code handle this
	 */
1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807
	if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN ||
	    sc->SCp.phase != session->age) {
		spin_unlock_bh(&session->lock);
		mutex_unlock(&session->eh_mutex);
		return FAILED;
	}

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

1808
	task = (struct iscsi_task *)sc->SCp.ptr;
1809 1810
	ISCSI_DBG_SESSION(session, "aborting [sc %p itt 0x%x]\n",
			  sc, task->itt);
M
Mike Christie 已提交
1811

1812 1813
	/* task completed before time out */
	if (!task->sc) {
1814 1815
		ISCSI_DBG_SESSION(session, "sc completed while abort in "
				  "progress\n");
1816
		goto success;
1817
	}
M
Mike Christie 已提交
1818

1819 1820
	if (task->state == ISCSI_TASK_PENDING) {
		fail_command(conn, task, DID_ABORT << 16);
1821 1822
		goto success;
	}
M
Mike Christie 已提交
1823

1824 1825
	/* only have one tmf outstanding at a time */
	if (conn->tmf_state != TMF_INITIAL)
M
Mike Christie 已提交
1826
		goto failed;
1827
	conn->tmf_state = TMF_QUEUED;
M
Mike Christie 已提交
1828

1829
	hdr = &conn->tmhdr;
1830
	iscsi_prep_abort_task_pdu(task, hdr);
1831

1832
	if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) {
1833 1834 1835 1836 1837 1838
		rc = FAILED;
		goto failed;
	}

	switch (conn->tmf_state) {
	case TMF_SUCCESS:
1839
		spin_unlock_bh(&session->lock);
1840 1841 1842 1843
		/*
		 * stop tx side incase the target had sent a abort rsp but
		 * the initiator was still writing out data.
		 */
1844
		iscsi_suspend_tx(conn);
1845
		/*
1846 1847 1848
		 * 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.
1849 1850
		 */
		spin_lock(&session->lock);
1851
		fail_command(conn, task, DID_ABORT << 16);
1852
		conn->tmf_state = TMF_INITIAL;
1853
		spin_unlock(&session->lock);
1854
		iscsi_start_tx(conn);
1855
		goto success_unlocked;
1856 1857 1858 1859 1860 1861 1862
	case TMF_TIMEDOUT:
		spin_unlock_bh(&session->lock);
		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);
		goto failed_unlocked;
	case TMF_NOT_FOUND:
		if (!sc->SCp.ptr) {
			conn->tmf_state = TMF_INITIAL;
1863
			/* task completed before tmf abort response */
1864 1865
			ISCSI_DBG_SESSION(session, "sc completed while abort "
					  "in progress\n");
1866
			goto success;
1867 1868 1869
		}
		/* fall through */
	default:
1870 1871
		conn->tmf_state = TMF_INITIAL;
		goto failed;
M
Mike Christie 已提交
1872 1873
	}

1874
success:
M
Mike Christie 已提交
1875
	spin_unlock_bh(&session->lock);
1876
success_unlocked:
1877 1878
	ISCSI_DBG_SESSION(session, "abort success [sc %p itt 0x%x]\n",
			  sc, task->itt);
1879
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
1880 1881 1882 1883
	return SUCCESS;

failed:
	spin_unlock_bh(&session->lock);
1884
failed_unlocked:
1885 1886
	ISCSI_DBG_SESSION(session, "abort failed [sc %p itt 0x%x]\n", sc,
			  task ? task->itt : 0);
1887
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
1888 1889 1890 1891
	return FAILED;
}
EXPORT_SYMBOL_GPL(iscsi_eh_abort);

1892 1893 1894 1895 1896 1897 1898
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);
1899
	hdr->rtt = RESERVED_ITT;
1900 1901 1902 1903
}

int iscsi_eh_device_reset(struct scsi_cmnd *sc)
{
1904 1905
	struct iscsi_cls_session *cls_session;
	struct iscsi_session *session;
1906 1907 1908 1909
	struct iscsi_conn *conn;
	struct iscsi_tm *hdr;
	int rc = FAILED;

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

1913 1914
	ISCSI_DBG_SESSION(session, "LU Reset [sc %p lun %u]\n",
			  sc, sc->device->lun);
1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933

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

1934
	if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age,
1935
				    session->lu_reset_timeout)) {
1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955
		rc = FAILED;
		goto unlock;
	}

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

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

	iscsi_suspend_tx(conn);
1956

1957
	spin_lock_bh(&session->lock);
1958
	fail_all_commands(conn, sc->device->lun, DID_ERROR);
1959
	conn->tmf_state = TMF_INITIAL;
1960
	spin_unlock_bh(&session->lock);
1961 1962 1963 1964 1965 1966 1967

	iscsi_start_tx(conn);
	goto done;

unlock:
	spin_unlock_bh(&session->lock);
done:
1968 1969
	ISCSI_DBG_SESSION(session, "dev reset result = %s\n",
			 rc == SUCCESS ? "SUCCESS" : "FAILED");
1970 1971 1972 1973 1974
	mutex_unlock(&session->eh_mutex);
	return rc;
}
EXPORT_SYMBOL_GPL(iscsi_eh_device_reset);

1975 1976 1977 1978 1979 1980
/*
 * 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 已提交
1981
int
1982
iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size)
M
Mike Christie 已提交
1983
{
1984
	int i, num_arrays = 1;
M
Mike Christie 已提交
1985

1986
	memset(q, 0, sizeof(*q));
M
Mike Christie 已提交
1987 1988

	q->max = max;
1989 1990 1991 1992 1993 1994 1995

	/* 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)
1996
		return -ENOMEM;
M
Mike Christie 已提交
1997 1998 1999

	q->queue = kfifo_init((void*)q->pool, max * sizeof(void*),
			      GFP_KERNEL, NULL);
2000 2001
	if (q->queue == ERR_PTR(-ENOMEM))
		goto enomem;
M
Mike Christie 已提交
2002 2003

	for (i = 0; i < max; i++) {
2004
		q->pool[i] = kzalloc(item_size, GFP_KERNEL);
M
Mike Christie 已提交
2005
		if (q->pool[i] == NULL) {
2006 2007
			q->max = i;
			goto enomem;
M
Mike Christie 已提交
2008 2009 2010
		}
		__kfifo_put(q->queue, (void*)&q->pool[i], sizeof(void*));
	}
2011 2012 2013 2014 2015 2016

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

M
Mike Christie 已提交
2017
	return 0;
2018 2019 2020 2021

enomem:
	iscsi_pool_free(q);
	return -ENOMEM;
M
Mike Christie 已提交
2022 2023 2024
}
EXPORT_SYMBOL_GPL(iscsi_pool_init);

2025
void iscsi_pool_free(struct iscsi_pool *q)
M
Mike Christie 已提交
2026 2027 2028 2029
{
	int i;

	for (i = 0; i < q->max; i++)
2030
		kfree(q->pool[i]);
2031
	kfree(q->pool);
2032
	kfree(q->queue);
M
Mike Christie 已提交
2033 2034 2035
}
EXPORT_SYMBOL_GPL(iscsi_pool_free);

2036 2037 2038 2039 2040 2041 2042 2043 2044 2045
/**
 * 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)
{
2046 2047 2048
	if (!shost->can_queue)
		shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX;

2049 2050
	if (!shost->transportt->eh_timed_out)
		shost->transportt->eh_timed_out = iscsi_eh_cmd_timed_out;
2051 2052 2053 2054 2055 2056 2057 2058 2059
	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
 * @qdepth: default device queue depth
2060
 * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue
2061 2062 2063 2064 2065
 *
 * 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,
2066 2067
				   int dd_data_size, uint16_t qdepth,
				   bool xmit_can_sleep)
2068
{
2069
	struct Scsi_Host *shost;
2070
	struct iscsi_host *ihost;
2071 2072 2073 2074 2075

	shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size);
	if (!shost)
		return NULL;

2076
	if (qdepth == 0)
2077 2078
		qdepth = ISCSI_DEF_CMD_PER_LUN;
	shost->cmd_per_lun = qdepth;
2079
	ihost = shost_priv(shost);
2080 2081 2082 2083 2084 2085 2086 2087 2088

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

2089 2090 2091 2092
	spin_lock_init(&ihost->lock);
	ihost->state = ISCSI_HOST_SETUP;
	ihost->num_sessions = 0;
	init_waitqueue_head(&ihost->session_removal_wq);
2093
	return shost;
2094 2095 2096 2097

free_host:
	scsi_host_put(shost);
	return NULL;
2098 2099 2100
}
EXPORT_SYMBOL_GPL(iscsi_host_alloc);

2101 2102 2103 2104 2105
static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session)
{
	iscsi_session_failure(cls_session, ISCSI_ERR_INVALID_HOST);
}

2106 2107 2108 2109
/**
 * iscsi_host_remove - remove host and sessions
 * @shost: scsi host
 *
2110 2111
 * If there are any sessions left, this will initiate the removal and wait
 * for the completion.
2112 2113 2114
 */
void iscsi_host_remove(struct Scsi_Host *shost)
{
2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127
	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);

2128
	scsi_remove_host(shost);
2129 2130
	if (ihost->workq)
		destroy_workqueue(ihost->workq);
2131
}
2132
EXPORT_SYMBOL_GPL(iscsi_host_remove);
M
Mike Christie 已提交
2133

2134
void iscsi_host_free(struct Scsi_Host *shost)
2135 2136
{
	struct iscsi_host *ihost = shost_priv(shost);
M
Mike Christie 已提交
2137

2138 2139 2140
	kfree(ihost->netdev);
	kfree(ihost->hwaddress);
	kfree(ihost->initiatorname);
2141
	scsi_host_put(shost);
2142
}
2143
EXPORT_SYMBOL_GPL(iscsi_host_free);
M
Mike Christie 已提交
2144

2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165
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 已提交
2166 2167 2168
/**
 * iscsi_session_setup - create iscsi cls session and host and session
 * @iscsit: iscsi transport template
2169 2170
 * @shost: scsi host
 * @cmds_max: session can queue
2171
 * @cmd_task_size: LLD task private data size
M
Mike Christie 已提交
2172 2173 2174 2175
 * @initial_cmdsn: initial CmdSN
 *
 * This can be used by software iscsi_transports that allocate
 * a session per scsi host.
2176 2177 2178 2179
 *
 * 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.
2180
 */
M
Mike Christie 已提交
2181
struct iscsi_cls_session *
2182
iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost,
2183
		    uint16_t cmds_max, int cmd_task_size,
2184
		    uint32_t initial_cmdsn, unsigned int id)
M
Mike Christie 已提交
2185
{
2186
	struct iscsi_host *ihost = shost_priv(shost);
M
Mike Christie 已提交
2187 2188
	struct iscsi_session *session;
	struct iscsi_cls_session *cls_session;
2189
	int cmd_i, scsi_cmds, total_cmds = cmds_max;
2190 2191 2192 2193 2194 2195 2196 2197 2198
	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);
2199 2200 2201

	if (!total_cmds)
		total_cmds = ISCSI_DEF_XMIT_CMDS_MAX;
2202
	/*
2203 2204 2205
	 * 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.
2206
	 */
2207 2208 2209 2210
	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);
2211
		goto dec_session_count;
2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228
	}

	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);
2229
	}
2230
	scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX;
2231

2232 2233
	cls_session = iscsi_alloc_session(shost, iscsit,
					  sizeof(struct iscsi_session));
2234
	if (!cls_session)
2235
		goto dec_session_count;
2236 2237
	session = cls_session->dd_data;
	session->cls_session = cls_session;
M
Mike Christie 已提交
2238 2239
	session->host = shost;
	session->state = ISCSI_STATE_FREE;
2240
	session->fast_abort = 1;
2241 2242
	session->lu_reset_timeout = 15;
	session->abort_timeout = 10;
2243 2244
	session->scsi_cmds_max = scsi_cmds;
	session->cmds_max = total_cmds;
2245
	session->queued_cmdsn = session->cmdsn = initial_cmdsn;
M
Mike Christie 已提交
2246 2247 2248 2249
	session->exp_cmdsn = initial_cmdsn + 1;
	session->max_cmdsn = initial_cmdsn + 1;
	session->max_r2t = 1;
	session->tt = iscsit;
2250
	mutex_init(&session->eh_mutex);
2251
	spin_lock_init(&session->lock);
M
Mike Christie 已提交
2252 2253 2254 2255

	/* initialize SCSI PDU commands pool */
	if (iscsi_pool_init(&session->cmdpool, session->cmds_max,
			    (void***)&session->cmds,
2256
			    cmd_task_size + sizeof(struct iscsi_task)))
M
Mike Christie 已提交
2257 2258 2259 2260
		goto cmdpool_alloc_fail;

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

2263 2264 2265 2266
		if (cmd_task_size)
			task->dd_data = &task[1];
		task->itt = cmd_i;
		INIT_LIST_HEAD(&task->running);
M
Mike Christie 已提交
2267 2268
	}

2269
	if (!try_module_get(iscsit->owner))
2270
		goto module_get_fail;
M
Mike Christie 已提交
2271

2272
	if (iscsi_add_session(cls_session, id))
2273
		goto cls_session_fail;
2274

M
Mike Christie 已提交
2275 2276 2277
	return cls_session;

cls_session_fail:
2278 2279
	module_put(iscsit->owner);
module_get_fail:
2280
	iscsi_pool_free(&session->cmdpool);
M
Mike Christie 已提交
2281
cmdpool_alloc_fail:
2282
	iscsi_free_session(cls_session);
2283 2284
dec_session_count:
	iscsi_host_dec_session_cnt(shost);
M
Mike Christie 已提交
2285 2286 2287 2288 2289 2290
	return NULL;
}
EXPORT_SYMBOL_GPL(iscsi_session_setup);

/**
 * iscsi_session_teardown - destroy session, host, and cls_session
2291
 * @cls_session: iscsi session
M
Mike Christie 已提交
2292
 *
2293 2294 2295
 * The driver must have called iscsi_remove_session before
 * calling this.
 */
M
Mike Christie 已提交
2296 2297
void iscsi_session_teardown(struct iscsi_cls_session *cls_session)
{
2298
	struct iscsi_session *session = cls_session->dd_data;
2299
	struct module *owner = cls_session->transport->owner;
2300
	struct Scsi_Host *shost = session->host;
M
Mike Christie 已提交
2301

2302
	iscsi_pool_free(&session->cmdpool);
M
Mike Christie 已提交
2303

2304 2305 2306 2307
	kfree(session->password);
	kfree(session->password_in);
	kfree(session->username);
	kfree(session->username_in);
2308
	kfree(session->targetname);
2309 2310
	kfree(session->initiatorname);
	kfree(session->ifacename);
2311

2312
	iscsi_destroy_session(cls_session);
2313
	iscsi_host_dec_session_cnt(shost);
2314
	module_put(owner);
M
Mike Christie 已提交
2315 2316 2317 2318 2319 2320
}
EXPORT_SYMBOL_GPL(iscsi_session_teardown);

/**
 * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn
 * @cls_session: iscsi_cls_session
2321
 * @dd_size: private driver data size
M
Mike Christie 已提交
2322
 * @conn_idx: cid
2323
 */
M
Mike Christie 已提交
2324
struct iscsi_cls_conn *
2325 2326
iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size,
		 uint32_t conn_idx)
M
Mike Christie 已提交
2327
{
2328
	struct iscsi_session *session = cls_session->dd_data;
M
Mike Christie 已提交
2329 2330
	struct iscsi_conn *conn;
	struct iscsi_cls_conn *cls_conn;
2331
	char *data;
M
Mike Christie 已提交
2332

2333 2334
	cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size,
				     conn_idx);
M
Mike Christie 已提交
2335 2336 2337
	if (!cls_conn)
		return NULL;
	conn = cls_conn->dd_data;
2338
	memset(conn, 0, sizeof(*conn) + dd_size);
M
Mike Christie 已提交
2339

2340
	conn->dd_data = cls_conn->dd_data + sizeof(*conn);
M
Mike Christie 已提交
2341 2342 2343 2344 2345
	conn->session = session;
	conn->cls_conn = cls_conn;
	conn->c_stage = ISCSI_CONN_INITIAL_STAGE;
	conn->id = conn_idx;
	conn->exp_statsn = 0;
2346
	conn->tmf_state = TMF_INITIAL;
2347 2348 2349 2350 2351

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

M
Mike Christie 已提交
2352 2353
	INIT_LIST_HEAD(&conn->run_list);
	INIT_LIST_HEAD(&conn->mgmt_run_list);
2354
	INIT_LIST_HEAD(&conn->mgmtqueue);
2355
	INIT_LIST_HEAD(&conn->xmitqueue);
2356
	INIT_LIST_HEAD(&conn->requeue);
D
David Howells 已提交
2357
	INIT_WORK(&conn->xmitwork, iscsi_xmitworker);
M
Mike Christie 已提交
2358

2359
	/* allocate login_task used for the login/text sequences */
M
Mike Christie 已提交
2360
	spin_lock_bh(&session->lock);
2361
	if (!__kfifo_get(session->cmdpool.queue,
2362
                         (void*)&conn->login_task,
M
Mike Christie 已提交
2363 2364
			 sizeof(void*))) {
		spin_unlock_bh(&session->lock);
2365
		goto login_task_alloc_fail;
M
Mike Christie 已提交
2366 2367 2368
	}
	spin_unlock_bh(&session->lock);

2369 2370
	data = (char *) __get_free_pages(GFP_KERNEL,
					 get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
2371
	if (!data)
2372 2373
		goto login_task_data_alloc_fail;
	conn->login_task->data = conn->data = data;
2374

2375
	init_timer(&conn->tmf_timer);
M
Mike Christie 已提交
2376 2377 2378 2379
	init_waitqueue_head(&conn->ehwait);

	return cls_conn;

2380 2381
login_task_data_alloc_fail:
	__kfifo_put(session->cmdpool.queue, (void*)&conn->login_task,
2382
		    sizeof(void*));
2383
login_task_alloc_fail:
M
Mike Christie 已提交
2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401
	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;

2402 2403
	del_timer_sync(&conn->transport_timer);

M
Mike Christie 已提交
2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426
	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);
2427 2428 2429 2430
		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 已提交
2431 2432 2433 2434 2435 2436
		/*
		 * force eh_abort() to unblock
		 */
		wake_up(&conn->ehwait);
	}

2437
	/* flush queued up work because we free the connection below */
2438
	iscsi_suspend_tx(conn);
2439

M
Mike Christie 已提交
2440
	spin_lock_bh(&session->lock);
2441 2442
	free_pages((unsigned long) conn->data,
		   get_order(ISCSI_DEF_MAX_RECV_SEG_LEN));
2443
	kfree(conn->persistent_address);
2444
	__kfifo_put(session->cmdpool.queue, (void*)&conn->login_task,
M
Mike Christie 已提交
2445
		    sizeof(void*));
2446
	if (session->leadconn == conn)
M
Mike Christie 已提交
2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458
		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;

2459
	if (!session) {
2460 2461
		iscsi_conn_printk(KERN_ERR, conn,
				  "can't start unbound connection\n");
M
Mike Christie 已提交
2462 2463 2464
		return -EPERM;
	}

2465 2466
	if ((session->imm_data_en || !session->initial_r2t_en) &&
	     session->first_burst > session->max_burst) {
2467 2468 2469
		iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: "
				  "first_burst %d max_burst %d\n",
				  session->first_burst, session->max_burst);
2470 2471 2472
		return -EINVAL;
	}

2473
	if (conn->ping_timeout && !conn->recv_timeout) {
2474 2475
		iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of "
				  "zero. Using 5 seconds\n.");
2476 2477 2478 2479
		conn->recv_timeout = 5;
	}

	if (conn->recv_timeout && !conn->ping_timeout) {
2480 2481
		iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of "
				  "zero. Using 5 seconds.\n");
2482 2483 2484
		conn->ping_timeout = 5;
	}

M
Mike Christie 已提交
2485 2486 2487
	spin_lock_bh(&session->lock);
	conn->c_stage = ISCSI_CONN_STARTED;
	session->state = ISCSI_STATE_LOGGED_IN;
2488
	session->queued_cmdsn = session->cmdsn;
M
Mike Christie 已提交
2489

2490 2491 2492 2493 2494 2495
	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 已提交
2496 2497 2498 2499 2500 2501 2502
	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;
2503
		conn->tmf_state = TMF_INITIAL;
M
Mike Christie 已提交
2504
		session->age++;
2505 2506
		if (session->age == 16)
			session->age = 0;
2507
		break;
M
Mike Christie 已提交
2508 2509 2510 2511 2512 2513 2514 2515
	case STOP_CONN_TERM:
		conn->stop_stage = 0;
		break;
	default:
		break;
	}
	spin_unlock_bh(&session->lock);

2516
	iscsi_unblock_session(session->cls_session);
2517
	wake_up(&conn->ehwait);
M
Mike Christie 已提交
2518 2519 2520 2521 2522 2523 2524
	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_conn_start);

static void
flush_control_queues(struct iscsi_session *session, struct iscsi_conn *conn)
{
2525
	struct iscsi_task *task, *tmp;
M
Mike Christie 已提交
2526 2527

	/* handle pending */
2528
	list_for_each_entry_safe(task, tmp, &conn->mgmtqueue, running) {
2529 2530
		ISCSI_DBG_SESSION(session, "flushing pending mgmt task "
				  "itt 0x%x\n", task->itt);
2531 2532
		/* release ref from prep task */
		__iscsi_put_task(task);
M
Mike Christie 已提交
2533 2534 2535
	}

	/* handle running */
2536
	list_for_each_entry_safe(task, tmp, &conn->mgmt_run_list, running) {
2537 2538
		ISCSI_DBG_SESSION(session, "flushing running mgmt task "
				  "itt 0x%x\n", task->itt);
2539 2540
		/* release ref from prep task */
		__iscsi_put_task(task);
M
Mike Christie 已提交
2541 2542
	}

2543
	conn->task = NULL;
M
Mike Christie 已提交
2544 2545
}

2546 2547
static void iscsi_start_session_recovery(struct iscsi_session *session,
					 struct iscsi_conn *conn, int flag)
M
Mike Christie 已提交
2548
{
2549 2550
	int old_stop_stage;

2551 2552
	del_timer_sync(&conn->transport_timer);

2553
	mutex_lock(&session->eh_mutex);
M
Mike Christie 已提交
2554
	spin_lock_bh(&session->lock);
2555
	if (conn->stop_stage == STOP_CONN_TERM) {
M
Mike Christie 已提交
2556
		spin_unlock_bh(&session->lock);
2557 2558 2559 2560
		mutex_unlock(&session->eh_mutex);
		return;
	}

2561 2562
	/*
	 * When this is called for the in_login state, we only want to clean
2563
	 * up the login task and connection. We do not need to block and set
2564
	 * the recovery state again
2565
	 */
2566 2567 2568 2569
	if (flag == STOP_CONN_TERM)
		session->state = ISCSI_STATE_TERMINATE;
	else if (conn->stop_stage != STOP_CONN_RECOVER)
		session->state = ISCSI_STATE_IN_RECOVERY;
2570 2571

	old_stop_stage = conn->stop_stage;
M
Mike Christie 已提交
2572
	conn->stop_stage = flag;
2573
	conn->c_stage = ISCSI_CONN_STOPPED;
M
Mike Christie 已提交
2574
	spin_unlock_bh(&session->lock);
2575 2576

	iscsi_suspend_tx(conn);
M
Mike Christie 已提交
2577 2578 2579 2580 2581 2582 2583 2584 2585
	/*
	 * 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;
2586
		if (session->state == ISCSI_STATE_IN_RECOVERY &&
2587
		    old_stop_stage != STOP_CONN_RECOVER) {
2588
			ISCSI_DBG_SESSION(session, "blocking session\n");
2589
			iscsi_block_session(session->cls_session);
2590
		}
M
Mike Christie 已提交
2591
	}
2592 2593 2594 2595 2596

	/*
	 * flush queues.
	 */
	spin_lock_bh(&session->lock);
2597
	if (flag == STOP_CONN_RECOVER)
2598 2599 2600
		fail_all_commands(conn, -1, DID_TRANSPORT_DISRUPTED);
	else
		fail_all_commands(conn, -1, DID_ERROR);
2601 2602
	flush_control_queues(session, conn);
	spin_unlock_bh(&session->lock);
2603
	mutex_unlock(&session->eh_mutex);
M
Mike Christie 已提交
2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614
}

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);
2615
		break;
M
Mike Christie 已提交
2616
	default:
2617 2618
		iscsi_conn_printk(KERN_ERR, conn,
				  "invalid stop flag %d\n", flag);
M
Mike Christie 已提交
2619 2620 2621 2622 2623 2624 2625
	}
}
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)
{
2626
	struct iscsi_session *session = cls_session->dd_data;
2627
	struct iscsi_conn *conn = cls_conn->dd_data;
M
Mike Christie 已提交
2628 2629 2630 2631

	spin_lock_bh(&session->lock);
	if (is_leading)
		session->leadconn = conn;
2632
	spin_unlock_bh(&session->lock);
M
Mike Christie 已提交
2633 2634 2635 2636 2637 2638 2639 2640 2641 2642

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

2643 2644 2645 2646 2647 2648 2649 2650 2651

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) {
2652 2653 2654
	case ISCSI_PARAM_FAST_ABORT:
		sscanf(buf, "%d", &session->fast_abort);
		break;
2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666
	case ISCSI_PARAM_ABORT_TMO:
		sscanf(buf, "%d", &session->abort_timeout);
		break;
	case ISCSI_PARAM_LU_RESET_TMO:
		sscanf(buf, "%d", &session->lu_reset_timeout);
		break;
	case ISCSI_PARAM_PING_TMO:
		sscanf(buf, "%d", &conn->ping_timeout);
		break;
	case ISCSI_PARAM_RECV_TMO:
		sscanf(buf, "%d", &conn->recv_timeout);
		break;
2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713
	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;
2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737
	case ISCSI_PARAM_USERNAME:
		kfree(session->username);
		session->username = kstrdup(buf, GFP_KERNEL);
		if (!session->username)
			return -ENOMEM;
		break;
	case ISCSI_PARAM_USERNAME_IN:
		kfree(session->username_in);
		session->username_in = kstrdup(buf, GFP_KERNEL);
		if (!session->username_in)
			return -ENOMEM;
		break;
	case ISCSI_PARAM_PASSWORD:
		kfree(session->password);
		session->password = kstrdup(buf, GFP_KERNEL);
		if (!session->password)
			return -ENOMEM;
		break;
	case ISCSI_PARAM_PASSWORD_IN:
		kfree(session->password_in);
		session->password_in = kstrdup(buf, GFP_KERNEL);
		if (!session->password_in)
			return -ENOMEM;
		break;
2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764
	case ISCSI_PARAM_TARGET_NAME:
		/* this should not change between logins */
		if (session->targetname)
			break;

		session->targetname = kstrdup(buf, GFP_KERNEL);
		if (!session->targetname)
			return -ENOMEM;
		break;
	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:
		/*
		 * this is the address returned in discovery so it should
		 * not change between logins.
		 */
		if (conn->persistent_address)
			break;

		conn->persistent_address = kstrdup(buf, GFP_KERNEL);
		if (!conn->persistent_address)
			return -ENOMEM;
		break;
2765 2766 2767 2768 2769 2770 2771 2772
	case ISCSI_PARAM_IFACE_NAME:
		if (!session->ifacename)
			session->ifacename = kstrdup(buf, GFP_KERNEL);
		break;
	case ISCSI_PARAM_INITIATOR_NAME:
		if (!session->initiatorname)
			session->initiatorname = kstrdup(buf, GFP_KERNEL);
		break;
2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783
	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)
{
2784
	struct iscsi_session *session = cls_session->dd_data;
2785 2786 2787
	int len;

	switch(param) {
2788 2789 2790
	case ISCSI_PARAM_FAST_ABORT:
		len = sprintf(buf, "%d\n", session->fast_abort);
		break;
2791 2792 2793 2794 2795 2796
	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;
2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826
	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;
2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838
	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;
2839 2840 2841 2842 2843 2844 2845 2846 2847
	case ISCSI_PARAM_IFACE_NAME:
		len = sprintf(buf, "%s\n", session->ifacename);
		break;
	case ISCSI_PARAM_INITIATOR_NAME:
		if (!session->initiatorname)
			len = sprintf(buf, "%s\n", "unknown");
		else
			len = sprintf(buf, "%s\n", session->initiatorname);
		break;
2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862
	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) {
2863 2864 2865 2866 2867 2868
	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;
2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903
	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);

2904 2905 2906
int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param,
			 char *buf)
{
2907
	struct iscsi_host *ihost = shost_priv(shost);
2908 2909 2910
	int len;

	switch (param) {
2911
	case ISCSI_HOST_PARAM_NETDEV_NAME:
2912
		if (!ihost->netdev)
2913 2914
			len = sprintf(buf, "%s\n", "default");
		else
2915
			len = sprintf(buf, "%s\n", ihost->netdev);
2916
		break;
2917
	case ISCSI_HOST_PARAM_HWADDRESS:
2918
		if (!ihost->hwaddress)
2919 2920
			len = sprintf(buf, "%s\n", "default");
		else
2921
			len = sprintf(buf, "%s\n", ihost->hwaddress);
2922
		break;
2923
	case ISCSI_HOST_PARAM_INITIATOR_NAME:
2924
		if (!ihost->initiatorname)
2925 2926
			len = sprintf(buf, "%s\n", "unknown");
		else
2927
			len = sprintf(buf, "%s\n", ihost->initiatorname);
2928
		break;
2929 2930 2931 2932 2933 2934
	case ISCSI_HOST_PARAM_IPADDRESS:
		if (!strlen(ihost->local_address))
			len = sprintf(buf, "%s\n", "unknown");
		else
			len = sprintf(buf, "%s\n",
				      ihost->local_address);
2935
		break;
2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946
	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)
{
2947
	struct iscsi_host *ihost = shost_priv(shost);
2948 2949

	switch (param) {
2950
	case ISCSI_HOST_PARAM_NETDEV_NAME:
2951 2952
		if (!ihost->netdev)
			ihost->netdev = kstrdup(buf, GFP_KERNEL);
2953
		break;
2954
	case ISCSI_HOST_PARAM_HWADDRESS:
2955 2956
		if (!ihost->hwaddress)
			ihost->hwaddress = kstrdup(buf, GFP_KERNEL);
2957
		break;
2958
	case ISCSI_HOST_PARAM_INITIATOR_NAME:
2959 2960
		if (!ihost->initiatorname)
			ihost->initiatorname = kstrdup(buf, GFP_KERNEL);
2961
		break;
2962 2963 2964 2965 2966 2967 2968 2969
	default:
		return -ENOSYS;
	}

	return 0;
}
EXPORT_SYMBOL_GPL(iscsi_host_set_param);

M
Mike Christie 已提交
2970 2971 2972
MODULE_AUTHOR("Mike Christie");
MODULE_DESCRIPTION("iSCSI library functions");
MODULE_LICENSE("GPL");