Commit 30a6c652 authored by Mike Christie's avatar Mike Christie Committed by James Bottomley
Browse files

[SCSI] iscsi: fix up iscsi eh 



The current iscsi_tcp eh is not nicely setup for dm-multipath
and performs some extra task management functions when they
are not needed.

The attached patch:

- Fixes the TMF issues. If a session is rebuilt
then we do not send aborts.

- Fixes the problem where if the host reset fired, we would
return SUCCESS even though we had not really done anything
yet. This ends up causing problem with scsi_error.c's TUR.

- If someone has turned on the userspace nop daemon code to try
and detect network problems before the scsi command timeout
we can now drop and clean up the session before the scsi command
timesout and fires the eh speeding up the time it takes for a
command to go from one patch to another. For network problems
we fail the command with DID_BUS_BUSY so if failfast is set
scsi_decide_disposition fails the command up to dm for it to
try on another path.

- And we had to add some basic iscsi session block code. Previously
if we were trying to repair a session we would retrun a MLQUEUE code
in the queuecommand. This worked but it was not the most efficient
or pretty thing to do since it would take a while to relogin
to the target. For iscsi_tcp/open-iscsi a lot of the iscsi error handler
is in userspace the block code is pretty bare. We will be
adding to that for qla4xxx.

Signed-off-by: default avatarMike Christie <michaelc@cs.wisc.edu>
Signed-off-by: default avatarJames Bottomley <James.Bottomley@SteelEye.com>
parent fd7255f5

drivers/scsi/iscsi_tcp.c

+395 −264
Original line number Diff line number Diff line
@@ -82,6 +82,9 @@ module_param_named(max_lun, iscsi_max_lun, uint, S_IRUGO); 
/* global data */

static kmem_cache_t *taskcache;



#define session_to_cls(_sess) \

	hostdata_session(_sess->host->hostdata)



static inline void

iscsi_buf_init_virt(struct iscsi_buf *ibuf, char *vbuf, int size)

{
@@ -230,17 +233,19 @@ iscsi_hdr_extract(struct iscsi_conn *conn) 
	return 0;

}



static inline void

iscsi_ctask_cleanup(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)

/*

 * must be called with session lock

 */

static void

__iscsi_ctask_cleanup(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)

{

	struct scsi_cmnd *sc = ctask->sc;

	struct iscsi_session *session = conn->session;

	struct scsi_cmnd *sc;



	spin_lock(&session->lock);

	if (unlikely(!sc)) {

		spin_unlock(&session->lock);

	sc = ctask->sc;

	if (unlikely(!sc))

		return;

	}



	if (sc->sc_data_direction == DMA_TO_DEVICE) {

		struct iscsi_data_task *dtask, *n;

		/* WRITE: cleanup Data-Out's if any */
@@ -252,7 +257,20 @@ iscsi_ctask_cleanup(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask) 
	ctask->xmstate = XMSTATE_IDLE;

	ctask->r2t = NULL;

	ctask->sc = NULL;

	list_del(&ctask->running);



	__kfifo_put(session->cmdpool.queue, (void*)&ctask, sizeof(void*));



	sc->scsi_done(sc);

}



static void

iscsi_ctask_cleanup(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask)

{

	struct iscsi_session *session = conn->session;



	spin_lock(&session->lock);

	__iscsi_ctask_cleanup(conn, ctask);

	spin_unlock(&session->lock);

}
@@ -311,7 +329,6 @@ out: 
		   (long)sc, sc->result, ctask->itt);

	conn->scsirsp_pdus_cnt++;

	iscsi_ctask_cleanup(conn, ctask);

	sc->scsi_done(sc);

	return rc;

}
@@ -395,6 +412,7 @@ iscsi_solicit_data_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask, 


	dtask = mempool_alloc(ctask->datapool, GFP_ATOMIC);

	BUG_ON(!dtask);

	INIT_LIST_HEAD(&dtask->item);

	hdr = &dtask->hdr;

	memset(hdr, 0, sizeof(struct iscsi_data));

	hdr->ttt = r2t->ttt;
@@ -710,8 +728,6 @@ iscsi_hdr_recv(struct iscsi_conn *conn) 
			conn->tmfrsp_pdus_cnt++;

			spin_lock(&session->lock);

			if (conn->tmabort_state == TMABORT_INITIAL) {

				__kfifo_put(session->mgmtpool.queue,

						(void*)&mtask, sizeof(void*));

				conn->tmabort_state =

					((struct iscsi_tm_rsp *)hdr)->

					response == ISCSI_TMF_RSP_COMPLETE ?
@@ -986,7 +1002,6 @@ done: 
			   (long)sc, sc->result, ctask->itt);

		conn->scsirsp_pdus_cnt++;

		iscsi_ctask_cleanup(conn, ctask);

		sc->scsi_done(sc);

	}



	return rc;
@@ -1460,6 +1475,7 @@ iscsi_solicit_data_cont(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask, 


	dtask = mempool_alloc(ctask->datapool, GFP_ATOMIC);

	BUG_ON(!dtask);

	INIT_LIST_HEAD(&dtask->item);

	hdr = &dtask->hdr;

	memset(hdr, 0, sizeof(struct iscsi_data));

	hdr->ttt = r2t->ttt;
@@ -1506,6 +1522,7 @@ iscsi_unsolicit_data_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask) 


	dtask = mempool_alloc(ctask->datapool, GFP_ATOMIC);

	BUG_ON(!dtask);

	INIT_LIST_HEAD(&dtask->item);

	hdr = &dtask->hdr;

	memset(hdr, 0, sizeof(struct iscsi_data));

	hdr->ttt = cpu_to_be32(ISCSI_RESERVED_TAG);
@@ -1550,6 +1567,7 @@ iscsi_cmd_init(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask, 


	BUG_ON(__kfifo_len(ctask->r2tqueue));



	INIT_LIST_HEAD(&ctask->running);

	ctask->sc = sc;

	ctask->conn = conn;

	ctask->hdr.opcode = ISCSI_OP_SCSI_CMD;
@@ -2226,6 +2244,7 @@ iscsi_data_xmit(struct iscsi_conn *conn) 
	/* process command queue */

	while (__kfifo_get(conn->xmitqueue, (void*)&conn->ctask,

			   sizeof(void*))) {

		list_add_tail(&conn->ctask->running, &conn->run_list);

		if (iscsi_ctask_xmit(conn, conn->ctask))

			goto again;

	}
@@ -2277,11 +2296,14 @@ iscsi_xmitworker(void *data) 
	mutex_unlock(&conn->xmitmutex);

}



#define FAILURE_BAD_HOST		1

#define FAILURE_SESSION_FAILED		2

#define FAILURE_SESSION_FREED		3

#define FAILURE_WINDOW_CLOSED		4

#define FAILURE_SESSION_TERMINATE	5

enum {

	FAILURE_BAD_HOST = 1,

	FAILURE_SESSION_FAILED,

	FAILURE_SESSION_FREED,

	FAILURE_WINDOW_CLOSED,

	FAILURE_SESSION_TERMINATE,

	FAILURE_SESSION_RECOVERY_TIMEOUT,

};



static int

iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *))
@@ -2297,12 +2319,14 @@ iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *)) 


	host = sc->device->host;

	session = iscsi_hostdata(host->hostdata);

	BUG_ON(host != session->host);



	spin_lock(&session->lock);



	if (session->state != ISCSI_STATE_LOGGED_IN) {

		if (session->state == ISCSI_STATE_FAILED) {

		if (session->recovery_failed) {

			reason = FAILURE_SESSION_RECOVERY_TIMEOUT;

			goto fault;

		} else if (session->state == ISCSI_STATE_FAILED) {

			reason = FAILURE_SESSION_FAILED;

			goto reject;

		} else if (session->state == ISCSI_STATE_TERMINATE) {
@@ -2350,11 +2374,6 @@ fault: 
	spin_unlock(&session->lock);

	printk(KERN_ERR "iscsi_tcp: cmd 0x%x is not queued (%d)\n",

	       sc->cmnd[0], reason);

	sc->sense_buffer[0] = 0x70;

	sc->sense_buffer[2] = NOT_READY;

	sc->sense_buffer[7] = 0x6;

	sc->sense_buffer[12] = 0x08;

	sc->sense_buffer[13] = 0x00;

	sc->result = (DID_NO_CONNECT << 16);

	sc->resid = sc->request_bufflen;

	sc->scsi_done(sc);
@@ -2445,6 +2464,7 @@ iscsi_conn_create(struct iscsi_cls_session *cls_session, uint32_t conn_idx) 
	conn->id = conn_idx;

	conn->exp_statsn = 0;

	conn->tmabort_state = TMABORT_INITIAL;

	INIT_LIST_HEAD(&conn->run_list);



	/* initial operational parameters */

	conn->hdr_size = sizeof(struct iscsi_hdr);
@@ -2701,6 +2721,22 @@ iscsi_conn_bind(struct iscsi_cls_session *cls_session, 
	return 0;

}



static void

iscsi_session_recovery_timedout(struct iscsi_cls_session *csession)

{

	struct Scsi_Host *shost = iscsi_session_to_shost(csession);

	struct iscsi_session *session = iscsi_hostdata(shost->hostdata);

	struct iscsi_conn *conn = session->leadconn;



	spin_lock_bh(&session->lock);

	if (session->state != ISCSI_STATE_LOGGED_IN) {

		session->recovery_failed = 1;

		if (conn)

			wake_up(&conn->ehwait);

	}

	spin_unlock_bh(&session->lock);

}



static int

iscsi_conn_start(struct iscsi_cls_conn *cls_conn)

{
@@ -2716,7 +2752,6 @@ iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 
	}



	sk = conn->sock->sk;



	write_lock_bh(&sk->sk_callback_lock);

	spin_lock_bh(&session->lock);

	conn->c_stage = ISCSI_CONN_STARTED;
@@ -2732,8 +2767,13 @@ iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 
		conn->stop_stage = 0;

		conn->tmabort_state = TMABORT_INITIAL;

		session->age++;

		session->recovery_failed = 0;

		spin_unlock_bh(&session->lock);

		write_unlock_bh(&sk->sk_callback_lock);



		iscsi_unblock_session(session_to_cls(session));

		wake_up(&conn->ehwait);

		break;

		return 0;

	case STOP_CONN_TERM:

		session->conn_cnt++;

		conn->stop_stage = 0;
@@ -2752,40 +2792,130 @@ iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 
	return 0;

}



static void

iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag)

static int

iscsi_ctask_mtask_cleanup(struct iscsi_cmd_task *ctask)

{

	struct iscsi_conn *conn = cls_conn->dd_data;

	struct iscsi_conn *conn = ctask->conn;

	struct iscsi_session *session = conn->session;

	struct iscsi_mgmt_task *mtask;



	if (!ctask->mtask)

		return -EINVAL;



	while (__kfifo_get(conn->immqueue, (void*)&mtask, sizeof(void*))) {

		if (mtask == ctask->mtask)

			break;

		__kfifo_put(conn->immqueue, (void*)&mtask, sizeof(void*));

	}



	__kfifo_put(session->mgmtpool.queue, (void*)&ctask->mtask,

		    sizeof(void*));

	ctask->mtask = NULL;

	return 0;

}



static void

fail_command(struct iscsi_conn *conn, struct iscsi_cmd_task *ctask, int err)

{

	struct iscsi_r2t_info *r2t;

	struct scsi_cmnd *sc;



	/* flush ctask's r2t queues */

	while (__kfifo_get(ctask->r2tqueue, (void*)&r2t, sizeof(void*)))

		__kfifo_put(ctask->r2tpool.queue, (void*)&r2t, sizeof(void*));



	iscsi_ctask_mtask_cleanup(ctask);



	sc = ctask->sc;

	if (!sc)

		return;



	sc->result = err;

	sc->resid = sc->request_bufflen;



	__iscsi_ctask_cleanup(conn, ctask);

}



/* Fail commands. Mutex and session lock held */

static void

fail_all_commands(struct iscsi_session *session, struct iscsi_conn *conn)

{

	struct iscsi_cmd_task *ctask, *tmp;



	/* flush pending */

	while (__kfifo_get(conn->xmitqueue, (void*)&ctask, sizeof(void*))) {

		debug_scsi("failing pending sc %p itt 0x%x\n", ctask->sc,

			   ctask->itt);

		fail_command(conn, ctask, DID_BUS_BUSY << 16);

	}



	/* fail running */

	list_for_each_entry_safe(ctask, tmp, &conn->run_list, running) {

		debug_scsi("failing in progress sc %p itt 0x%x\n",

			   ctask->sc, ctask->itt);

		fail_command(conn, ctask, DID_BUS_BUSY << 16);

	}



	conn->ctask = NULL;

}



static void

flush_control_queues(struct iscsi_session *session, struct iscsi_conn *conn)

{

	struct iscsi_mgmt_task *mtask;



	/* TODO: handle running pdus */

	while (__kfifo_get(conn->immqueue, (void*)&mtask, sizeof(void*)) ||

	       __kfifo_get(conn->mgmtqueue, (void*)&mtask, sizeof(void*))) {

		if (mtask == conn->login_mtask)

			continue;

		__kfifo_put(session->mgmtpool.queue, (void*)&mtask,

			    sizeof(void*));

	}



	if (conn->mtask && conn->mtask != conn->login_mtask)

		__kfifo_put(session->mgmtpool.queue, (void*)&conn->mtask,

			    sizeof(void*));

	conn->mtask = NULL;

}



static void

iscsi_suspend_conn_rx(struct iscsi_conn *conn)

{

	struct sock *sk;

	unsigned long flags;



	BUG_ON(!conn->sock);

	sk = conn->sock->sk;

	write_lock_bh(&sk->sk_callback_lock);

	set_bit(SUSPEND_BIT, &conn->suspend_rx);

	write_unlock_bh(&sk->sk_callback_lock);

}



	mutex_lock(&conn->xmitmutex);



	spin_lock_irqsave(session->host->host_lock, flags);

	spin_lock(&session->lock);

static void

iscsi_start_session_recovery(struct iscsi_session *session,

			     struct iscsi_conn *conn, int flag)

{

	spin_lock_bh(&session->lock);

	if (conn->stop_stage == STOP_CONN_RECOVER ||

	    conn->stop_stage == STOP_CONN_TERM) {

		spin_unlock_bh(&session->lock);

		return;

	}

	conn->stop_stage = flag;

	spin_unlock_bh(&session->lock);



	iscsi_suspend_conn_rx(conn);



	mutex_lock(&conn->xmitmutex);

	spin_lock_bh(&session->lock);

	conn->c_stage = ISCSI_CONN_STOPPED;

	set_bit(SUSPEND_BIT, &conn->suspend_tx);



	if (flag != STOP_CONN_SUSPEND)

	session->conn_cnt--;



	if (session->conn_cnt == 0 || session->leadconn == conn)

		session->state = ISCSI_STATE_FAILED;



	spin_unlock(&session->lock);

	spin_unlock_irqrestore(session->host->host_lock, flags);



	if (flag == STOP_CONN_TERM || flag == STOP_CONN_RECOVER) {

		struct iscsi_cmd_task *ctask;

		struct iscsi_mgmt_task *mtask;

	spin_unlock_bh(&session->lock);



	/*

	 * Socket must go now.
@@ -2795,38 +2925,11 @@ iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 
	sock_put(conn->sock->sk);



	/*

		 * flush xmit queues.

		 */

		spin_lock_bh(&session->lock);

		while (__kfifo_get(conn->writequeue, (void*)&ctask,

			    sizeof(void*)) ||

			__kfifo_get(conn->xmitqueue, (void*)&ctask,

			    sizeof(void*))) {

			struct iscsi_r2t_info *r2t;



			/*

			 * flush ctask's r2t queues

	 * flush queues.

	 */

			while (__kfifo_get(ctask->r2tqueue, (void*)&r2t,

				sizeof(void*)))

				__kfifo_put(ctask->r2tpool.queue, (void*)&r2t,

					    sizeof(void*));



			spin_unlock_bh(&session->lock);

			local_bh_disable();

			iscsi_ctask_cleanup(conn, ctask);

			local_bh_enable();

	spin_lock_bh(&session->lock);

		}

		conn->ctask = NULL;

		while (__kfifo_get(conn->immqueue, (void*)&mtask,

			   sizeof(void*)) ||

			__kfifo_get(conn->mgmtqueue, (void*)&mtask,

			   sizeof(void*))) {

			__kfifo_put(session->mgmtpool.queue,

				    (void*)&mtask, sizeof(void*));

		}

		conn->mtask = NULL;

	fail_all_commands(session, conn);

	flush_control_queues(session, conn);

	spin_unlock_bh(&session->lock);



	/*
@@ -2846,9 +2949,40 @@ iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 
		conn->hdr_size = sizeof(struct iscsi_hdr);

		conn->hdrdgst_en = 0;

		conn->datadgst_en = 0;



		if (session->state == ISCSI_STATE_FAILED)

			iscsi_block_session(session_to_cls(session));

	}

	mutex_unlock(&conn->xmitmutex);

}



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

		return;

	case STOP_CONN_SUSPEND:

		iscsi_suspend_conn_rx(conn);



		mutex_lock(&conn->xmitmutex);

		spin_lock_bh(&session->lock);



		conn->stop_stage = flag;

		conn->c_stage = ISCSI_CONN_STOPPED;

		set_bit(SUSPEND_BIT, &conn->suspend_tx);



		spin_unlock_bh(&session->lock);

		mutex_unlock(&conn->xmitmutex);

		break;

	default:

		printk(KERN_ERR "invalid stop flag %d\n", flag);

	}

}



static int
@@ -2940,23 +3074,54 @@ iscsi_conn_send_generic(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 
static int

iscsi_eh_host_reset(struct scsi_cmnd *sc)

{

	struct iscsi_cmd_task *ctask = (struct iscsi_cmd_task *)sc->SCp.ptr;

	struct iscsi_conn *conn = ctask->conn;

	struct iscsi_session *session = conn->session;

	struct Scsi_Host *host = sc->device->host;

	struct iscsi_session *session = iscsi_hostdata(host->hostdata);

	struct iscsi_conn *conn = session->leadconn;

	int fail_session = 0;



	spin_lock_bh(&session->lock);

	if (session->state == ISCSI_STATE_TERMINATE) {

failed:

		debug_scsi("failing host reset: session terminated "

			   "[CID %d age %d]", conn->id, session->age);

		spin_unlock_bh(&session->lock);

		return FAILED;

	}



	if (sc->SCp.phase == session->age) {

		debug_scsi("failing connection CID %d due to SCSI host reset",

			   conn->id);

		fail_session = 1;

	}

	spin_unlock_bh(&session->lock);



	debug_scsi("failing connection CID %d due to SCSI host reset "

		   "[itt 0x%x age %d]", conn->id, ctask->itt,

		   session->age);

	/*

	 * we drop the lock here but the leadconn cannot be destoyed while

	 * we are in the scsi eh

	 */

	if (fail_session) {

		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);

		/*

		 * if userspace cannot respond then we must kick this off

		 * here for it

		 */

		iscsi_start_session_recovery(session, conn, STOP_CONN_RECOVER);

	}



	debug_scsi("iscsi_eh_host_reset wait for relogin\n");

	wait_event_interruptible(conn->ehwait,

				 session->state == ISCSI_STATE_TERMINATE ||

				 session->state == ISCSI_STATE_LOGGED_IN ||

				 session->recovery_failed);

	if (signal_pending(current))

		flush_signals(current);



	spin_lock_bh(&session->lock);

	if (session->state == ISCSI_STATE_LOGGED_IN)

		printk(KERN_INFO "host reset succeeded\n");

	else

		goto failed;

	spin_unlock_bh(&session->lock);



	return SUCCESS;

}
@@ -2970,8 +3135,6 @@ iscsi_tmabort_timedout(unsigned long data) 


	spin_lock(&session->lock);

	if (conn->tmabort_state == TMABORT_INITIAL) {

		__kfifo_put(session->mgmtpool.queue,

				(void*)&ctask->mtask, sizeof(void*));

		conn->tmabort_state = TMABORT_TIMEDOUT;

		debug_scsi("tmabort timedout [sc %lx itt 0x%x]\n",

			(long)ctask->sc, ctask->itt);
@@ -2981,56 +3144,17 @@ iscsi_tmabort_timedout(unsigned long data) 
	spin_unlock(&session->lock);

}



/* must be called with the mutex lock */

static int

iscsi_eh_abort(struct scsi_cmnd *sc)

iscsi_exec_abort_task(struct scsi_cmnd *sc, struct iscsi_cmd_task *ctask)

{

	int rc;

	struct iscsi_cmd_task *ctask = (struct iscsi_cmd_task *)sc->SCp.ptr;

	struct iscsi_conn *conn = ctask->conn;

	struct iscsi_session *session = conn->session;



	conn->eh_abort_cnt++;

	debug_scsi("aborting [sc %lx itt 0x%x]\n", (long)sc, ctask->itt);



	/*

	 * two cases for ERL=0 here:

	 *

	 * 1) connection-level failure;

	 * 2) recovery due protocol error;

	 */

	mutex_lock(&conn->xmitmutex);

	spin_lock_bh(&session->lock);

	if (session->state != ISCSI_STATE_LOGGED_IN) {

		if (session->state == ISCSI_STATE_TERMINATE) {

			spin_unlock_bh(&session->lock);

			mutex_unlock(&conn->xmitmutex);

			goto failed;

		}

		spin_unlock_bh(&session->lock);

	} else {

	struct iscsi_tm *hdr = &conn->tmhdr;

	int rc;



	/*

		 * Still LOGGED_IN...

		 */



		if (!ctask->sc || sc->SCp.phase != session->age) {

			/*

			 * 1) ctask completed before time out. But session

			 *    is still ok => Happy Retry.

			 * 2) session was re-open during time out of ctask.

			 */

			spin_unlock_bh(&session->lock);

			mutex_unlock(&conn->xmitmutex);

			goto success;

		}

		conn->tmabort_state = TMABORT_INITIAL;

		spin_unlock_bh(&session->lock);



		/*

		 * ctask timed out but session is OK

		 * ERL=0 requires task mgmt abort to be issued on each

		 * failed command. requests must be serialized.

	 * ctask timed out but session is OK requests must be serialized.

	 */

	memset(hdr, 0, sizeof(struct iscsi_tm));

	hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE;
@@ -3044,123 +3168,139 @@ iscsi_eh_abort(struct scsi_cmnd *sc) 
				     NULL, 0);

	if (rc) {

		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);

			debug_scsi("abort sent failure [itt 0x%x]", ctask->itt);

		} else {

			struct iscsi_r2t_info *r2t;

		debug_scsi("abort sent failure [itt 0x%x] %d", ctask->itt, rc);

		return rc;

	}



	debug_scsi("abort sent [itt 0x%x]\n", ctask->itt);



			/*

			 * TMF abort vs. TMF response race logic

			 */

	spin_lock_bh(&session->lock);

	ctask->mtask = (struct iscsi_mgmt_task *)

			session->mgmt_cmds[(hdr->itt & ITT_MASK) -

					ISCSI_MGMT_ITT_OFFSET];

			/*

			 * have to flush r2tqueue to avoid r2t leaks

			 */

			while (__kfifo_get(ctask->r2tqueue, (void*)&r2t,

				sizeof(void*))) {

				__kfifo_put(ctask->r2tpool.queue, (void*)&r2t,

					sizeof(void*));

			}



	if (conn->tmabort_state == TMABORT_INITIAL) {

		conn->tmfcmd_pdus_cnt++;

				conn->tmabort_timer.expires = 3*HZ + jiffies;

				conn->tmabort_timer.function =

						iscsi_tmabort_timedout;

		conn->tmabort_timer.expires = 10*HZ + jiffies;

		conn->tmabort_timer.function = iscsi_tmabort_timedout;

		conn->tmabort_timer.data = (unsigned long)ctask;

		add_timer(&conn->tmabort_timer);

				debug_scsi("abort sent [itt 0x%x]", ctask->itt);

			} else {

				if (!ctask->sc ||

				    conn->tmabort_state == TMABORT_SUCCESS) {

					conn->tmabort_state = TMABORT_INITIAL;

					spin_unlock_bh(&session->lock);

					mutex_unlock(&conn->xmitmutex);

					goto success;

				}

				conn->tmabort_state = TMABORT_INITIAL;

				iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);

		debug_scsi("abort set timeout [itt 0x%x]", ctask->itt);

	}

	spin_unlock_bh(&session->lock);

		}

	}

	mutex_unlock(&conn->xmitmutex);





	/*

	 * block eh thread until:

	 *

	 * 1) abort response;

	 * 2) abort timeout;

	 * 3) session re-opened;

	 * 4) session terminated;

	 * 1) abort response

	 * 2) abort timeout

	 * 3) session is terminated or restarted or userspace has

	 * given up on recovery

	 */

	for (;;) {

		int p_state = session->state;



		rc = wait_event_interruptible(conn->ehwait,

			(p_state == ISCSI_STATE_LOGGED_IN ?

			 (session->state == ISCSI_STATE_TERMINATE ||

			  conn->tmabort_state != TMABORT_INITIAL) :

			 (session->state == ISCSI_STATE_TERMINATE ||

			  session->state == ISCSI_STATE_LOGGED_IN)));

		if (rc) {

			/* shutdown.. */

			session->state = ISCSI_STATE_TERMINATE;

			goto failed;

		}



	wait_event_interruptible(conn->ehwait,

				 sc->SCp.phase != session->age ||

				 session->state != ISCSI_STATE_LOGGED_IN ||

				 conn->tmabort_state != TMABORT_INITIAL ||

				 session->recovery_failed);

	if (signal_pending(current))

		flush_signals(current);

	del_timer_sync(&conn->tmabort_timer);



		if (session->state == ISCSI_STATE_TERMINATE)

			goto failed;

	mutex_lock(&conn->xmitmutex);

	return 0;

}



static int

iscsi_eh_abort(struct scsi_cmnd *sc)

{

	struct iscsi_cmd_task *ctask = (struct iscsi_cmd_task *)sc->SCp.ptr;

	struct iscsi_cmd_task *tmp_ctask;

	struct iscsi_conn *conn = ctask->conn;

	struct iscsi_session *session = conn->session;

	int rc;



	conn->eh_abort_cnt++;

	debug_scsi("aborting [sc %p itt 0x%x]\n", sc, ctask->itt);



	mutex_lock(&conn->xmitmutex);

	spin_lock_bh(&session->lock);

		if (sc->SCp.phase == session->age &&

		   (conn->tmabort_state == TMABORT_TIMEDOUT ||

		    conn->tmabort_state == TMABORT_FAILED)) {

			conn->tmabort_state = TMABORT_INITIAL;

			if (!ctask->sc) {



	/*

				 * ctask completed before tmf abort response or

				 * time out.

				 * But session is still ok => Happy Retry.

	 * If we are not logged in or we have started a new session

	 * then let the host reset code handle this

	 */

				spin_unlock_bh(&session->lock);

				break;

	if (session->state != ISCSI_STATE_LOGGED_IN ||

	    sc->SCp.phase != session->age)

		goto failed;



	/* ctask completed before time out */

	if (!ctask->sc)

		goto success;



	/* what should we do here ? */

	if (conn->ctask == ctask) {

		printk(KERN_INFO "sc %p itt 0x%x partially sent. Failing "

		       "abort\n", sc, ctask->itt);

		goto failed;

	}



	/* check for the easy pending cmd abort */

	while (__kfifo_get(conn->xmitqueue, (void*)&tmp_ctask, sizeof(void*))) {

		if (tmp_ctask->itt == ctask->itt) {

			debug_scsi("found pending task\n");

			goto success;

		}

		__kfifo_put(conn->xmitqueue, (void*)&tmp_ctask, sizeof(void*));

	}



	conn->tmabort_state = TMABORT_INITIAL;



	spin_unlock_bh(&session->lock);

			iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);

			continue;

	rc = iscsi_exec_abort_task(sc, ctask);

	spin_lock_bh(&session->lock);



	iscsi_ctask_mtask_cleanup(ctask);

	if (rc || sc->SCp.phase != session->age ||

	    session->state != ISCSI_STATE_LOGGED_IN)

		goto failed;



	/* ctask completed before tmf abort response */

	if (!ctask->sc) {

		debug_scsi("sc completed while abort in progress\n");

		goto success;

	}



	if (conn->tmabort_state != TMABORT_SUCCESS) {

		spin_unlock_bh(&session->lock);

		break;

		iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED);

		spin_lock_bh(&session->lock);

		goto failed;

	}



success:

	debug_scsi("abort success [sc %lx itt 0x%x]\n", (long)sc, ctask->itt);

	rc = SUCCESS;

	goto exit;



failed:

	debug_scsi("abort failed [sc %lx itt 0x%x]\n", (long)sc, ctask->itt);

	rc = FAILED;



exit:

	del_timer_sync(&conn->tmabort_timer);

	spin_unlock_bh(&session->lock);



	mutex_lock(&conn->xmitmutex);

	/* clean up task if aborted */

	if (conn->sock) {

		struct sock *sk = conn->sock->sk;



		write_lock_bh(&sk->sk_callback_lock);

		iscsi_ctask_cleanup(conn, ctask);

		spin_lock(&session->lock);

		fail_command(conn, ctask, DRIVER_TIMEOUT << 24);

		spin_unlock(&session->lock);

		write_unlock_bh(&sk->sk_callback_lock);

	}

	mutex_unlock(&conn->xmitmutex);

	return rc;

	return SUCCESS;



failed:

	spin_unlock_bh(&session->lock);

	mutex_unlock(&conn->xmitmutex);



	debug_scsi("abort failed [sc %lx itt 0x%x]\n", (long)sc, ctask->itt);

	return FAILED;

}



static int
@@ -3359,16 +3499,6 @@ iscsi_conn_set_param(struct iscsi_cls_conn *cls_conn, enum iscsi_param param, 
	struct iscsi_conn *conn = cls_conn->dd_data;

	struct iscsi_session *session = conn->session;



	spin_lock_bh(&session->lock);

	if (conn->c_stage != ISCSI_CONN_INITIAL_STAGE &&

	    conn->stop_stage != STOP_CONN_RECOVER) {

		printk(KERN_ERR "iscsi_tcp: can not change parameter [%d]\n",

		       param);

		spin_unlock_bh(&session->lock);

		return 0;

	}

	spin_unlock_bh(&session->lock);



	switch(param) {

	case ISCSI_PARAM_MAX_RECV_DLENGTH: {

		char *saveptr = conn->data;
@@ -3691,6 +3821,7 @@ static struct iscsi_transport iscsi_tcp_transport = { 
	.stop_conn		= iscsi_conn_stop,

	.send_pdu		= iscsi_conn_send_pdu,

	.get_stats		= iscsi_conn_get_stats,

	.session_recovery_timedout = iscsi_session_recovery_timedout,

};



static int __init

drivers/scsi/iscsi_tcp.h

+3 −0
Original line number Diff line number Diff line
@@ -159,6 +159,7 @@ struct iscsi_conn { 
	struct kfifo		*immqueue;	/* immediate xmit queue */

	struct kfifo		*mgmtqueue;	/* mgmt (control) xmit queue */

	struct kfifo		*xmitqueue;	/* data-path cmd queue */

	struct list_head	run_list;	/* list of cmds in progress */

	struct work_struct	xmitwork;	/* per-conn. xmit workqueue */

	struct mutex		xmitmutex;	/* serializes connection xmit,

						 * access to kfifos:	  *
@@ -228,6 +229,7 @@ struct iscsi_session { 
						 * - mgmtpool,		   *

						 * - r2tpool		   */

	int			state;		/* session state           */

	int			recovery_failed;

	struct list_head	item;

	void			*auth_client;

	int			conn_cnt;
@@ -310,6 +312,7 @@ struct iscsi_cmd_task { 
	struct iscsi_conn	*conn;			/* used connection    */

	struct iscsi_mgmt_task	*mtask;			/* tmf mtask in progr */



	struct list_head	running;		/* running cmd list */

	struct iscsi_r2t_info	*r2t;			/* in progress R2T    */

	struct iscsi_queue	r2tpool;

	struct kfifo		*r2tqueue;

drivers/scsi/scsi_transport_iscsi.c

+143 −9

File changed.

Preview size limit exceeded, changes collapsed.

include/scsi/iscsi_if.h

+2 −0
Original line number Diff line number Diff line
@@ -174,6 +174,7 @@ enum iscsi_param { 
	ISCSI_PARAM_TPGT,

	ISCSI_PARAM_PERSISTENT_ADDRESS,

	ISCSI_PARAM_PERSISTENT_PORT,

	ISCSI_PARAM_SESS_RECOVERY_TMO,



	/* pased in through bind conn using transport_fd */

	ISCSI_PARAM_CONN_PORT,
@@ -201,6 +202,7 @@ enum iscsi_param { 
#define ISCSI_TPGT			(1 << ISCSI_PARAM_TPGT)

#define ISCSI_PERSISTENT_ADDRESS	(1 << ISCSI_PARAM_PERSISTENT_ADDRESS)

#define ISCSI_PERSISTENT_PORT		(1 << ISCSI_PARAM_PERSISTENT_PORT)

#define ISCSI_SESS_RECOVERY_TMO		(1 << ISCSI_PARAM_SESS_RECOVERY_TMO)

#define ISCSI_CONN_PORT			(1 << ISCSI_PARAM_CONN_PORT)

#define ISCSI_CONN_ADDRESS		(1 << ISCSI_PARAM_CONN_ADDRESS)

include/scsi/scsi_transport_iscsi.h

+18 −1
Original line number Diff line number Diff line
@@ -90,6 +90,7 @@ struct iscsi_transport { 
			 char *data, uint32_t data_size);

	void (*get_stats) (struct iscsi_cls_conn *conn,

			   struct iscsi_stats *stats);

	void (*session_recovery_timedout) (struct iscsi_cls_session *session);

};



/*
@@ -130,12 +131,20 @@ struct iscsi_cls_conn { 


struct iscsi_cls_session {

	struct list_head sess_list;		/* item in session_list */

	struct list_head host_list;

	struct iscsi_transport *transport;



	/* iSCSI values used as unique id by userspace. */

	char *targetname;

	int tpgt;



	/* recovery fields */

	int recovery_tmo;

	struct work_struct recovery_work;



	int target_id;

	int channel;



	int sid;				/* session id */

	void *dd_data;				/* LLD private data */

	struct device dev;	/* sysfs transport/container device */
@@ -147,15 +156,23 @@ struct iscsi_cls_session { 
#define iscsi_session_to_shost(_session) \

	dev_to_shost(_session->dev.parent)



struct iscsi_host {

	int next_target_id;

	struct list_head sessions;

	struct mutex mutex;

};



/*

 * session and connection functions that can be used by HW iSCSI LLDs

 */

extern struct iscsi_cls_session *iscsi_create_session(struct Scsi_Host *shost,

				struct iscsi_transport *t);

				struct iscsi_transport *t, int channel);

extern int iscsi_destroy_session(struct iscsi_cls_session *session);

extern struct iscsi_cls_conn *iscsi_create_conn(struct iscsi_cls_session *sess,

					    uint32_t cid);

extern int iscsi_destroy_conn(struct iscsi_cls_conn *conn);

extern void iscsi_unblock_session(struct iscsi_cls_session *session);

extern void iscsi_block_session(struct iscsi_cls_session *session);



/*

 * session functions used by software iscsi

CRA Git | Maintained and supported by SUSTech CRA and CCSE