[deliverable/linux.git] / drivers / target / iscsi / iscsi_target_erl2.c

/*******************************************************************************
 * This file contains error recovery level two functions used by
 * the iSCSI Target driver.
 *
 * \u00a9 Copyright 2007-2011 RisingTide Systems LLC.
 *
 * Licensed to the Linux Foundation under the General Public License (GPL) version 2.
 *
 * Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
 *
 * 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.
 ******************************************************************************/

#include <scsi/iscsi_proto.h>
#include <target/target_core_base.h>
#include <target/target_core_transport.h>

#include "iscsi_target_core.h"
#include "iscsi_target_datain_values.h"
#include "iscsi_target_util.h"
#include "iscsi_target_erl0.h"
#include "iscsi_target_erl1.h"
#include "iscsi_target_erl2.h"
#include "iscsi_target.h"

/*
 *	FIXME: Does RData SNACK apply here as well?
 */
void iscsit_create_conn_recovery_datain_values(
	struct iscsi_cmd *cmd,
	u32 exp_data_sn)
{
	u32 data_sn = 0;
	struct iscsi_conn *conn = cmd->conn;

	cmd->next_burst_len = 0;
	cmd->read_data_done = 0;

	while (exp_data_sn > data_sn) {
		if ((cmd->next_burst_len +
		     conn->conn_ops->MaxRecvDataSegmentLength) <
		     conn->sess->sess_ops->MaxBurstLength) {
			cmd->read_data_done +=
			       conn->conn_ops->MaxRecvDataSegmentLength;
			cmd->next_burst_len +=
			       conn->conn_ops->MaxRecvDataSegmentLength;
		} else {
			cmd->read_data_done +=
				(conn->sess->sess_ops->MaxBurstLength -
				cmd->next_burst_len);
			cmd->next_burst_len = 0;
		}
		data_sn++;
	}
}

void iscsit_create_conn_recovery_dataout_values(
	struct iscsi_cmd *cmd)
{
	u32 write_data_done = 0;
	struct iscsi_conn *conn = cmd->conn;

	cmd->data_sn = 0;
	cmd->next_burst_len = 0;

	while (cmd->write_data_done > write_data_done) {
		if ((write_data_done + conn->sess->sess_ops->MaxBurstLength) <=
		     cmd->write_data_done)
			write_data_done += conn->sess->sess_ops->MaxBurstLength;
		else
			break;
	}

	cmd->write_data_done = write_data_done;
}

static int iscsit_attach_active_connection_recovery_entry(
	struct iscsi_session *sess,
	struct iscsi_conn_recovery *cr)
{
	spin_lock(&sess->cr_a_lock);
	list_add_tail(&cr->cr_list, &sess->cr_active_list);
	spin_unlock(&sess->cr_a_lock);

	return 0;
}

static int iscsit_attach_inactive_connection_recovery_entry(
	struct iscsi_session *sess,
	struct iscsi_conn_recovery *cr)
{
	spin_lock(&sess->cr_i_lock);
	list_add_tail(&cr->cr_list, &sess->cr_inactive_list);

	sess->conn_recovery_count++;
	pr_debug("Incremented connection recovery count to %u for"
		" SID: %u\n", sess->conn_recovery_count, sess->sid);
	spin_unlock(&sess->cr_i_lock);

	return 0;
}

struct iscsi_conn_recovery *iscsit_get_inactive_connection_recovery_entry(
	struct iscsi_session *sess,
	u16 cid)
{
	struct iscsi_conn_recovery *cr;

	spin_lock(&sess->cr_i_lock);
	list_for_each_entry(cr, &sess->cr_inactive_list, cr_list) {
		if (cr->cid == cid) {
			spin_unlock(&sess->cr_i_lock);
			return cr;
		}
	}
	spin_unlock(&sess->cr_i_lock);

	return NULL;
}

void iscsit_free_connection_recovery_entires(struct iscsi_session *sess)
{
	struct iscsi_cmd *cmd, *cmd_tmp;
	struct iscsi_conn_recovery *cr, *cr_tmp;

	spin_lock(&sess->cr_a_lock);
	list_for_each_entry_safe(cr, cr_tmp, &sess->cr_active_list, cr_list) {
		list_del(&cr->cr_list);
		spin_unlock(&sess->cr_a_lock);

		spin_lock(&cr->conn_recovery_cmd_lock);
		list_for_each_entry_safe(cmd, cmd_tmp,
				&cr->conn_recovery_cmd_list, i_list) {

			list_del(&cmd->i_list);
			cmd->conn = NULL;
			spin_unlock(&cr->conn_recovery_cmd_lock);
			if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) ||
			    !(cmd->se_cmd.transport_wait_for_tasks))
				iscsit_release_cmd(cmd);
			else
				cmd->se_cmd.transport_wait_for_tasks(
						&cmd->se_cmd, 1, 1);
			spin_lock(&cr->conn_recovery_cmd_lock);
		}
		spin_unlock(&cr->conn_recovery_cmd_lock);
		spin_lock(&sess->cr_a_lock);

		kfree(cr);
	}
	spin_unlock(&sess->cr_a_lock);

	spin_lock(&sess->cr_i_lock);
	list_for_each_entry_safe(cr, cr_tmp, &sess->cr_inactive_list, cr_list) {
		list_del(&cr->cr_list);
		spin_unlock(&sess->cr_i_lock);

		spin_lock(&cr->conn_recovery_cmd_lock);
		list_for_each_entry_safe(cmd, cmd_tmp,
				&cr->conn_recovery_cmd_list, i_list) {

			list_del(&cmd->i_list);
			cmd->conn = NULL;
			spin_unlock(&cr->conn_recovery_cmd_lock);
			if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) ||
			    !(cmd->se_cmd.transport_wait_for_tasks))
				iscsit_release_cmd(cmd);
			else
				cmd->se_cmd.transport_wait_for_tasks(
						&cmd->se_cmd, 1, 1);
			spin_lock(&cr->conn_recovery_cmd_lock);
		}
		spin_unlock(&cr->conn_recovery_cmd_lock);
		spin_lock(&sess->cr_i_lock);

		kfree(cr);
	}
	spin_unlock(&sess->cr_i_lock);
}

int iscsit_remove_active_connection_recovery_entry(
	struct iscsi_conn_recovery *cr,
	struct iscsi_session *sess)
{
	spin_lock(&sess->cr_a_lock);
	list_del(&cr->cr_list);

	sess->conn_recovery_count--;
	pr_debug("Decremented connection recovery count to %u for"
		" SID: %u\n", sess->conn_recovery_count, sess->sid);
	spin_unlock(&sess->cr_a_lock);

	kfree(cr);

	return 0;
}

int iscsit_remove_inactive_connection_recovery_entry(
	struct iscsi_conn_recovery *cr,
	struct iscsi_session *sess)
{
	spin_lock(&sess->cr_i_lock);
	list_del(&cr->cr_list);
	spin_unlock(&sess->cr_i_lock);

	return 0;
}

/*
 *	Called with cr->conn_recovery_cmd_lock help.
 */
int iscsit_remove_cmd_from_connection_recovery(
	struct iscsi_cmd *cmd,
	struct iscsi_session *sess)
{
	struct iscsi_conn_recovery *cr;

	if (!cmd->cr) {
		pr_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x"
			" is NULL!\n", cmd->init_task_tag);
		BUG();
	}
	cr = cmd->cr;

	list_del(&cmd->i_list);
	return --cr->cmd_count;
}

void iscsit_discard_cr_cmds_by_expstatsn(
	struct iscsi_conn_recovery *cr,
	u32 exp_statsn)
{
	u32 dropped_count = 0;
	struct iscsi_cmd *cmd, *cmd_tmp;
	struct iscsi_session *sess = cr->sess;

	spin_lock(&cr->conn_recovery_cmd_lock);
	list_for_each_entry_safe(cmd, cmd_tmp,
			&cr->conn_recovery_cmd_list, i_list) {

		if (((cmd->deferred_i_state != ISTATE_SENT_STATUS) &&
		     (cmd->deferred_i_state != ISTATE_REMOVE)) ||
		     (cmd->stat_sn >= exp_statsn)) {
			continue;
		}

		dropped_count++;
		pr_debug("Dropping Acknowledged ITT: 0x%08x, StatSN:"
			" 0x%08x, CID: %hu.\n", cmd->init_task_tag,
				cmd->stat_sn, cr->cid);

		iscsit_remove_cmd_from_connection_recovery(cmd, sess);

		spin_unlock(&cr->conn_recovery_cmd_lock);
		if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) ||
		    !(cmd->se_cmd.transport_wait_for_tasks))
			iscsit_release_cmd(cmd);
		else
			cmd->se_cmd.transport_wait_for_tasks(
					&cmd->se_cmd, 1, 0);
		spin_lock(&cr->conn_recovery_cmd_lock);
	}
	spin_unlock(&cr->conn_recovery_cmd_lock);

	pr_debug("Dropped %u total acknowledged commands on"
		" CID: %hu less than old ExpStatSN: 0x%08x\n",
			dropped_count, cr->cid, exp_statsn);

	if (!cr->cmd_count) {
		pr_debug("No commands to be reassigned for failed"
			" connection CID: %hu on SID: %u\n",
			cr->cid, sess->sid);
		iscsit_remove_inactive_connection_recovery_entry(cr, sess);
		iscsit_attach_active_connection_recovery_entry(sess, cr);
		pr_debug("iSCSI connection recovery successful for CID:"
			" %hu on SID: %u\n", cr->cid, sess->sid);
		iscsit_remove_active_connection_recovery_entry(cr, sess);
	} else {
		iscsit_remove_inactive_connection_recovery_entry(cr, sess);
		iscsit_attach_active_connection_recovery_entry(sess, cr);
	}
}

int iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(struct iscsi_conn *conn)
{
	u32 dropped_count = 0;
	struct iscsi_cmd *cmd, *cmd_tmp;
	struct iscsi_ooo_cmdsn *ooo_cmdsn, *ooo_cmdsn_tmp;
	struct iscsi_session *sess = conn->sess;

	mutex_lock(&sess->cmdsn_mutex);
	list_for_each_entry_safe(ooo_cmdsn, ooo_cmdsn_tmp,
			&sess->sess_ooo_cmdsn_list, ooo_list) {

		if (ooo_cmdsn->cid != conn->cid)
			continue;

		dropped_count++;
		pr_debug("Dropping unacknowledged CmdSN:"
		" 0x%08x during connection recovery on CID: %hu\n",
			ooo_cmdsn->cmdsn, conn->cid);
		iscsit_remove_ooo_cmdsn(sess, ooo_cmdsn);
	}
	mutex_unlock(&sess->cmdsn_mutex);

	spin_lock_bh(&conn->cmd_lock);
	list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_list) {
		if (!(cmd->cmd_flags & ICF_OOO_CMDSN))
			continue;

		list_del(&cmd->i_list);

		spin_unlock_bh(&conn->cmd_lock);
		if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) ||
		    !(cmd->se_cmd.transport_wait_for_tasks))
			iscsit_release_cmd(cmd);
		else
			cmd->se_cmd.transport_wait_for_tasks(
					&cmd->se_cmd, 1, 1);
		spin_lock_bh(&conn->cmd_lock);
	}
	spin_unlock_bh(&conn->cmd_lock);

	pr_debug("Dropped %u total unacknowledged commands on CID:"
		" %hu for ExpCmdSN: 0x%08x.\n", dropped_count, conn->cid,
				sess->exp_cmd_sn);
	return 0;
}

int iscsit_prepare_cmds_for_realligance(struct iscsi_conn *conn)
{
	u32 cmd_count = 0;
	struct iscsi_cmd *cmd, *cmd_tmp;
	struct iscsi_conn_recovery *cr;

	/*
	 * Allocate an struct iscsi_conn_recovery for this connection.
	 * Each struct iscsi_cmd contains an struct iscsi_conn_recovery pointer
	 * (struct iscsi_cmd->cr) so we need to allocate this before preparing the
	 * connection's command list for connection recovery.
	 */
	cr = kzalloc(sizeof(struct iscsi_conn_recovery), GFP_KERNEL);
	if (!cr) {
		pr_err("Unable to allocate memory for"
			" struct iscsi_conn_recovery.\n");
		return -1;
	}
	INIT_LIST_HEAD(&cr->cr_list);
	INIT_LIST_HEAD(&cr->conn_recovery_cmd_list);
	spin_lock_init(&cr->conn_recovery_cmd_lock);
	/*
	 * Only perform connection recovery on ISCSI_OP_SCSI_CMD or
	 * ISCSI_OP_NOOP_OUT opcodes.  For all other opcodes call
	 * list_del(&cmd->i_list); to release the command to the
	 * session pool and remove it from the connection's list.
	 *
	 * Also stop the DataOUT timer, which will be restarted after
	 * sending the TMR response.
	 */
	spin_lock_bh(&conn->cmd_lock);
	list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_list) {

		if ((cmd->iscsi_opcode != ISCSI_OP_SCSI_CMD) &&
		    (cmd->iscsi_opcode != ISCSI_OP_NOOP_OUT)) {
			pr_debug("Not performing realligence on"
				" Opcode: 0x%02x, ITT: 0x%08x, CmdSN: 0x%08x,"
				" CID: %hu\n", cmd->iscsi_opcode,
				cmd->init_task_tag, cmd->cmd_sn, conn->cid);

			list_del(&cmd->i_list);
			spin_unlock_bh(&conn->cmd_lock);

			if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) ||
			    !(cmd->se_cmd.transport_wait_for_tasks))
				iscsit_release_cmd(cmd);
			else
				cmd->se_cmd.transport_wait_for_tasks(
						&cmd->se_cmd, 1, 0);
			spin_lock_bh(&conn->cmd_lock);
			continue;
		}

		/*
		 * Special case where commands greater than or equal to
		 * the session's ExpCmdSN are attached to the connection
		 * list but not to the out of order CmdSN list.  The one
		 * obvious case is when a command with immediate data
		 * attached must only check the CmdSN against ExpCmdSN
		 * after the data is received.  The special case below
		 * is when the connection fails before data is received,
		 * but also may apply to other PDUs, so it has been
		 * made generic here.
		 */
		if (!(cmd->cmd_flags & ICF_OOO_CMDSN) && !cmd->immediate_cmd &&
		     (cmd->cmd_sn >= conn->sess->exp_cmd_sn)) {
			list_del(&cmd->i_list);
			spin_unlock_bh(&conn->cmd_lock);

			if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) ||
			    !(cmd->se_cmd.transport_wait_for_tasks))
				iscsit_release_cmd(cmd);
			else
				cmd->se_cmd.transport_wait_for_tasks(
						&cmd->se_cmd, 1, 1);
			spin_lock_bh(&conn->cmd_lock);
			continue;
		}

		cmd_count++;
		pr_debug("Preparing Opcode: 0x%02x, ITT: 0x%08x,"
			" CmdSN: 0x%08x, StatSN: 0x%08x, CID: %hu for"
			" realligence.\n", cmd->iscsi_opcode,
			cmd->init_task_tag, cmd->cmd_sn, cmd->stat_sn,
			conn->cid);

		cmd->deferred_i_state = cmd->i_state;
		cmd->i_state = ISTATE_IN_CONNECTION_RECOVERY;

		if (cmd->data_direction == DMA_TO_DEVICE)
			iscsit_stop_dataout_timer(cmd);

		cmd->sess = conn->sess;

		list_del(&cmd->i_list);
		spin_unlock_bh(&conn->cmd_lock);

		iscsit_free_all_datain_reqs(cmd);

		if ((cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) &&
		     cmd->se_cmd.transport_wait_for_tasks)
			cmd->se_cmd.transport_wait_for_tasks(&cmd->se_cmd,
					0, 0);
		/*
		 * Add the struct iscsi_cmd to the connection recovery cmd list
		 */
		spin_lock(&cr->conn_recovery_cmd_lock);
		list_add_tail(&cmd->i_list, &cr->conn_recovery_cmd_list);
		spin_unlock(&cr->conn_recovery_cmd_lock);

		spin_lock_bh(&conn->cmd_lock);
		cmd->cr = cr;
		cmd->conn = NULL;
	}
	spin_unlock_bh(&conn->cmd_lock);
	/*
	 * Fill in the various values in the preallocated struct iscsi_conn_recovery.
	 */
	cr->cid = conn->cid;
	cr->cmd_count = cmd_count;
	cr->maxrecvdatasegmentlength = conn->conn_ops->MaxRecvDataSegmentLength;
	cr->sess = conn->sess;

	iscsit_attach_inactive_connection_recovery_entry(conn->sess, cr);

	return 0;
}

int iscsit_connection_recovery_transport_reset(struct iscsi_conn *conn)
{
	atomic_set(&conn->connection_recovery, 1);

	if (iscsit_close_connection(conn) < 0)
		return -1;

	return 0;
}
Commit	Line	Data
e48354ce NB	1	/*******************************************************************************
	2	* This file contains error recovery level two functions used by
	3	* the iSCSI Target driver.
	4	*
	5	* \u00a9 Copyright 2007-2011 RisingTide Systems LLC.
	6	*
	7	* Licensed to the Linux Foundation under the General Public License (GPL) version 2.
	8	*
	9	* Author: Nicholas A. Bellinger <nab@linux-iscsi.org>
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
	13	* the Free Software Foundation; either version 2 of the License, or
	14	* (at your option) any later version.
	15	*
	16	* This program is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	******************************************************************************/
	21
	22	#include <scsi/iscsi_proto.h>
	23	#include <target/target_core_base.h>
	24	#include <target/target_core_transport.h>
	25
	26	#include "iscsi_target_core.h"
	27	#include "iscsi_target_datain_values.h"
	28	#include "iscsi_target_util.h"
	29	#include "iscsi_target_erl0.h"
	30	#include "iscsi_target_erl1.h"
	31	#include "iscsi_target_erl2.h"
	32	#include "iscsi_target.h"
	33
	34	/*
	35	* FIXME: Does RData SNACK apply here as well?
	36	*/
	37	void iscsit_create_conn_recovery_datain_values(
	38	struct iscsi_cmd *cmd,
	39	u32 exp_data_sn)
	40	{
	41	u32 data_sn = 0;
	42	struct iscsi_conn *conn = cmd->conn;
	43
	44	cmd->next_burst_len = 0;
	45	cmd->read_data_done = 0;
	46
	47	while (exp_data_sn > data_sn) {
	48	if ((cmd->next_burst_len +
	49	conn->conn_ops->MaxRecvDataSegmentLength) <
	50	conn->sess->sess_ops->MaxBurstLength) {
	51	cmd->read_data_done +=
	52	conn->conn_ops->MaxRecvDataSegmentLength;
	53	cmd->next_burst_len +=
	54	conn->conn_ops->MaxRecvDataSegmentLength;
	55	} else {
	56	cmd->read_data_done +=
	57	(conn->sess->sess_ops->MaxBurstLength -
	58	cmd->next_burst_len);
	59	cmd->next_burst_len = 0;
	60	}
	61	data_sn++;
	62	}
	63	}
	64
65	void iscsit_create_conn_recovery_dataout_values(
66	struct iscsi_cmd *cmd)
67	{
68	u32 write_data_done = 0;
69	struct iscsi_conn *conn = cmd->conn;
70
71	cmd->data_sn = 0;
72	cmd->next_burst_len = 0;
73
74	while (cmd->write_data_done > write_data_done) {
75	if ((write_data_done + conn->sess->sess_ops->MaxBurstLength) <=
76	cmd->write_data_done)
77	write_data_done += conn->sess->sess_ops->MaxBurstLength;
78	else
79	break;
80	}
81
82	cmd->write_data_done = write_data_done;
83	}
84
85	static int iscsit_attach_active_connection_recovery_entry(
86	struct iscsi_session *sess,
87	struct iscsi_conn_recovery *cr)
88	{
89	spin_lock(&sess->cr_a_lock);
90	list_add_tail(&cr->cr_list, &sess->cr_active_list);
91	spin_unlock(&sess->cr_a_lock);
92
93	return 0;
94	}
95
96	static int iscsit_attach_inactive_connection_recovery_entry(
97	struct iscsi_session *sess,
98	struct iscsi_conn_recovery *cr)
99	{
100	spin_lock(&sess->cr_i_lock);
101	list_add_tail(&cr->cr_list, &sess->cr_inactive_list);
102
103	sess->conn_recovery_count++;
104	pr_debug("Incremented connection recovery count to %u for"
105	" SID: %u\n", sess->conn_recovery_count, sess->sid);
106	spin_unlock(&sess->cr_i_lock);
107
108	return 0;
109	}
110
111	struct iscsi_conn_recovery *iscsit_get_inactive_connection_recovery_entry(
112	struct iscsi_session *sess,
113	u16 cid)
114	{
115	struct iscsi_conn_recovery *cr;
116
117	spin_lock(&sess->cr_i_lock);
118	list_for_each_entry(cr, &sess->cr_inactive_list, cr_list) {
119	if (cr->cid == cid) {
120	spin_unlock(&sess->cr_i_lock);
121	return cr;
122	}
123	}
124	spin_unlock(&sess->cr_i_lock);
125
126	return NULL;
127	}
128
129	void iscsit_free_connection_recovery_entires(struct iscsi_session *sess)
130	{
131	struct iscsi_cmd cmd, cmd_tmp;
132	struct iscsi_conn_recovery cr, cr_tmp;
133
134	spin_lock(&sess->cr_a_lock);
135	list_for_each_entry_safe(cr, cr_tmp, &sess->cr_active_list, cr_list) {
136	list_del(&cr->cr_list);
137	spin_unlock(&sess->cr_a_lock);
138
139	spin_lock(&cr->conn_recovery_cmd_lock);
140	list_for_each_entry_safe(cmd, cmd_tmp,
141	&cr->conn_recovery_cmd_list, i_list) {
142
143	list_del(&cmd->i_list);
144	cmd->conn = NULL;
145	spin_unlock(&cr->conn_recovery_cmd_lock);
146	if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) \|\|
147	!(cmd->se_cmd.transport_wait_for_tasks))
148	iscsit_release_cmd(cmd);
149	else
150	cmd->se_cmd.transport_wait_for_tasks(
151	&cmd->se_cmd, 1, 1);
152	spin_lock(&cr->conn_recovery_cmd_lock);
153	}
154	spin_unlock(&cr->conn_recovery_cmd_lock);
155	spin_lock(&sess->cr_a_lock);
156
157	kfree(cr);
158	}
159	spin_unlock(&sess->cr_a_lock);
160
161	spin_lock(&sess->cr_i_lock);
162	list_for_each_entry_safe(cr, cr_tmp, &sess->cr_inactive_list, cr_list) {
163	list_del(&cr->cr_list);
164	spin_unlock(&sess->cr_i_lock);
165
166	spin_lock(&cr->conn_recovery_cmd_lock);
167	list_for_each_entry_safe(cmd, cmd_tmp,
168	&cr->conn_recovery_cmd_list, i_list) {
169
170	list_del(&cmd->i_list);
171	cmd->conn = NULL;
172	spin_unlock(&cr->conn_recovery_cmd_lock);
173	if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) \|\|
174	!(cmd->se_cmd.transport_wait_for_tasks))
175	iscsit_release_cmd(cmd);
176	else
177	cmd->se_cmd.transport_wait_for_tasks(
178	&cmd->se_cmd, 1, 1);
179	spin_lock(&cr->conn_recovery_cmd_lock);
180	}
181	spin_unlock(&cr->conn_recovery_cmd_lock);
182	spin_lock(&sess->cr_i_lock);
183
184	kfree(cr);
185	}
186	spin_unlock(&sess->cr_i_lock);
187	}
188
189	int iscsit_remove_active_connection_recovery_entry(
190	struct iscsi_conn_recovery *cr,
191	struct iscsi_session *sess)
192	{
193	spin_lock(&sess->cr_a_lock);
194	list_del(&cr->cr_list);
195
196	sess->conn_recovery_count--;
197	pr_debug("Decremented connection recovery count to %u for"
198	" SID: %u\n", sess->conn_recovery_count, sess->sid);
199	spin_unlock(&sess->cr_a_lock);
200
201	kfree(cr);
202
203	return 0;
204	}
205
206	int iscsit_remove_inactive_connection_recovery_entry(
207	struct iscsi_conn_recovery *cr,
208	struct iscsi_session *sess)
209	{
210	spin_lock(&sess->cr_i_lock);
211	list_del(&cr->cr_list);
212	spin_unlock(&sess->cr_i_lock);
213
214	return 0;
215	}
216
217	/*
218	* Called with cr->conn_recovery_cmd_lock help.
219	*/
220	int iscsit_remove_cmd_from_connection_recovery(
221	struct iscsi_cmd *cmd,
222	struct iscsi_session *sess)
223	{
224	struct iscsi_conn_recovery *cr;
225
226	if (!cmd->cr) {
227	pr_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x"
228	" is NULL!\n", cmd->init_task_tag);
229	BUG();
230	}
231	cr = cmd->cr;
232
233	list_del(&cmd->i_list);
234	return --cr->cmd_count;
235	}
236
237	void iscsit_discard_cr_cmds_by_expstatsn(
238	struct iscsi_conn_recovery *cr,
239	u32 exp_statsn)
240	{
241	u32 dropped_count = 0;
242	struct iscsi_cmd cmd, cmd_tmp;
243	struct iscsi_session *sess = cr->sess;
244
245	spin_lock(&cr->conn_recovery_cmd_lock);
246	list_for_each_entry_safe(cmd, cmd_tmp,
247	&cr->conn_recovery_cmd_list, i_list) {
248
249	if (((cmd->deferred_i_state != ISTATE_SENT_STATUS) &&
250	(cmd->deferred_i_state != ISTATE_REMOVE)) \|\|
251	(cmd->stat_sn >= exp_statsn)) {
252	continue;
253	}
254
255	dropped_count++;
256	pr_debug("Dropping Acknowledged ITT: 0x%08x, StatSN:"
257	" 0x%08x, CID: %hu.\n", cmd->init_task_tag,
258	cmd->stat_sn, cr->cid);
259
260	iscsit_remove_cmd_from_connection_recovery(cmd, sess);
261
262	spin_unlock(&cr->conn_recovery_cmd_lock);
263	if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) \|\|
264	!(cmd->se_cmd.transport_wait_for_tasks))
265	iscsit_release_cmd(cmd);
266	else
267	cmd->se_cmd.transport_wait_for_tasks(
268	&cmd->se_cmd, 1, 0);
269	spin_lock(&cr->conn_recovery_cmd_lock);
270	}
271	spin_unlock(&cr->conn_recovery_cmd_lock);
272
273	pr_debug("Dropped %u total acknowledged commands on"
274	" CID: %hu less than old ExpStatSN: 0x%08x\n",
275	dropped_count, cr->cid, exp_statsn);
276
277	if (!cr->cmd_count) {
278	pr_debug("No commands to be reassigned for failed"
279	" connection CID: %hu on SID: %u\n",
280	cr->cid, sess->sid);
281	iscsit_remove_inactive_connection_recovery_entry(cr, sess);
282	iscsit_attach_active_connection_recovery_entry(sess, cr);
283	pr_debug("iSCSI connection recovery successful for CID:"
284	" %hu on SID: %u\n", cr->cid, sess->sid);
285	iscsit_remove_active_connection_recovery_entry(cr, sess);
286	} else {
287	iscsit_remove_inactive_connection_recovery_entry(cr, sess);
288	iscsit_attach_active_connection_recovery_entry(sess, cr);
289	}
290	}
291
292	int iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(struct iscsi_conn *conn)
293	{
294	u32 dropped_count = 0;
295	struct iscsi_cmd cmd, cmd_tmp;
296	struct iscsi_ooo_cmdsn ooo_cmdsn, ooo_cmdsn_tmp;
297	struct iscsi_session *sess = conn->sess;
298
299	mutex_lock(&sess->cmdsn_mutex);
300	list_for_each_entry_safe(ooo_cmdsn, ooo_cmdsn_tmp,
301	&sess->sess_ooo_cmdsn_list, ooo_list) {
302
303	if (ooo_cmdsn->cid != conn->cid)
304	continue;
305
306	dropped_count++;
307	pr_debug("Dropping unacknowledged CmdSN:"
308	" 0x%08x during connection recovery on CID: %hu\n",
309	ooo_cmdsn->cmdsn, conn->cid);
310	iscsit_remove_ooo_cmdsn(sess, ooo_cmdsn);
311	}
312	mutex_unlock(&sess->cmdsn_mutex);
313
314	spin_lock_bh(&conn->cmd_lock);
315	list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_list) {
316	if (!(cmd->cmd_flags & ICF_OOO_CMDSN))
317	continue;
318
319	list_del(&cmd->i_list);
320
321	spin_unlock_bh(&conn->cmd_lock);
322	if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) \|\|
323	!(cmd->se_cmd.transport_wait_for_tasks))
324	iscsit_release_cmd(cmd);
325	else
326	cmd->se_cmd.transport_wait_for_tasks(
327	&cmd->se_cmd, 1, 1);
328	spin_lock_bh(&conn->cmd_lock);
329	}
330	spin_unlock_bh(&conn->cmd_lock);
331
332	pr_debug("Dropped %u total unacknowledged commands on CID:"
333	" %hu for ExpCmdSN: 0x%08x.\n", dropped_count, conn->cid,
334	sess->exp_cmd_sn);
335	return 0;
336	}
337
338	int iscsit_prepare_cmds_for_realligance(struct iscsi_conn *conn)
339	{
340	u32 cmd_count = 0;
341	struct iscsi_cmd cmd, cmd_tmp;
342	struct iscsi_conn_recovery *cr;
343
344	/*
345	* Allocate an struct iscsi_conn_recovery for this connection.
346	* Each struct iscsi_cmd contains an struct iscsi_conn_recovery pointer
347	* (struct iscsi_cmd->cr) so we need to allocate this before preparing the
348	* connection's command list for connection recovery.
349	*/
350	cr = kzalloc(sizeof(struct iscsi_conn_recovery), GFP_KERNEL);
351	if (!cr) {
352	pr_err("Unable to allocate memory for"
353	" struct iscsi_conn_recovery.\n");
354	return -1;
355	}
356	INIT_LIST_HEAD(&cr->cr_list);
357	INIT_LIST_HEAD(&cr->conn_recovery_cmd_list);
358	spin_lock_init(&cr->conn_recovery_cmd_lock);
359	/*
360	* Only perform connection recovery on ISCSI_OP_SCSI_CMD or
361	* ISCSI_OP_NOOP_OUT opcodes. For all other opcodes call
362	* list_del(&cmd->i_list); to release the command to the
363	* session pool and remove it from the connection's list.
364	*
365	* Also stop the DataOUT timer, which will be restarted after
366	* sending the TMR response.
367	*/
368	spin_lock_bh(&conn->cmd_lock);
369	list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_list) {
370
371	if ((cmd->iscsi_opcode != ISCSI_OP_SCSI_CMD) &&
372	(cmd->iscsi_opcode != ISCSI_OP_NOOP_OUT)) {
373	pr_debug("Not performing realligence on"
374	" Opcode: 0x%02x, ITT: 0x%08x, CmdSN: 0x%08x,"
375	" CID: %hu\n", cmd->iscsi_opcode,
376	cmd->init_task_tag, cmd->cmd_sn, conn->cid);
377
378	list_del(&cmd->i_list);
379	spin_unlock_bh(&conn->cmd_lock);
380
381	if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) \|\|
382	!(cmd->se_cmd.transport_wait_for_tasks))
383	iscsit_release_cmd(cmd);
384	else
385	cmd->se_cmd.transport_wait_for_tasks(
386	&cmd->se_cmd, 1, 0);
387	spin_lock_bh(&conn->cmd_lock);
388	continue;
389	}
390
391	/*
392	* Special case where commands greater than or equal to
393	* the session's ExpCmdSN are attached to the connection
394	* list but not to the out of order CmdSN list. The one
395	* obvious case is when a command with immediate data
396	* attached must only check the CmdSN against ExpCmdSN
397	* after the data is received. The special case below
398	* is when the connection fails before data is received,
399	* but also may apply to other PDUs, so it has been
400	* made generic here.
401	*/
402	if (!(cmd->cmd_flags & ICF_OOO_CMDSN) && !cmd->immediate_cmd &&
403	(cmd->cmd_sn >= conn->sess->exp_cmd_sn)) {
404	list_del(&cmd->i_list);
405	spin_unlock_bh(&conn->cmd_lock);
406
407	if (!(cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) \|\|
408	!(cmd->se_cmd.transport_wait_for_tasks))
409	iscsit_release_cmd(cmd);
410	else
411	cmd->se_cmd.transport_wait_for_tasks(
412	&cmd->se_cmd, 1, 1);
413	spin_lock_bh(&conn->cmd_lock);
414	continue;
415	}
416
417	cmd_count++;
418	pr_debug("Preparing Opcode: 0x%02x, ITT: 0x%08x,"
419	" CmdSN: 0x%08x, StatSN: 0x%08x, CID: %hu for"
420	" realligence.\n", cmd->iscsi_opcode,
421	cmd->init_task_tag, cmd->cmd_sn, cmd->stat_sn,
422	conn->cid);
423
424	cmd->deferred_i_state = cmd->i_state;
425	cmd->i_state = ISTATE_IN_CONNECTION_RECOVERY;
426
427	if (cmd->data_direction == DMA_TO_DEVICE)
428	iscsit_stop_dataout_timer(cmd);
429
430	cmd->sess = conn->sess;
431
432	list_del(&cmd->i_list);
433	spin_unlock_bh(&conn->cmd_lock);
434
435	iscsit_free_all_datain_reqs(cmd);
436
437	if ((cmd->se_cmd.se_cmd_flags & SCF_SE_LUN_CMD) &&
438	cmd->se_cmd.transport_wait_for_tasks)
439	cmd->se_cmd.transport_wait_for_tasks(&cmd->se_cmd,
440	0, 0);
441	/*
442	* Add the struct iscsi_cmd to the connection recovery cmd list
443	*/
444	spin_lock(&cr->conn_recovery_cmd_lock);
445	list_add_tail(&cmd->i_list, &cr->conn_recovery_cmd_list);
446	spin_unlock(&cr->conn_recovery_cmd_lock);
447
448	spin_lock_bh(&conn->cmd_lock);
449	cmd->cr = cr;
450	cmd->conn = NULL;
451	}
452	spin_unlock_bh(&conn->cmd_lock);
453	/*
454	* Fill in the various values in the preallocated struct iscsi_conn_recovery.
455	*/
456	cr->cid = conn->cid;
457	cr->cmd_count = cmd_count;
458	cr->maxrecvdatasegmentlength = conn->conn_ops->MaxRecvDataSegmentLength;
459	cr->sess = conn->sess;
460
461	iscsit_attach_inactive_connection_recovery_entry(conn->sess, cr);
462
463	return 0;
464	}
465
466	int iscsit_connection_recovery_transport_reset(struct iscsi_conn *conn)
467	{
468	atomic_set(&conn->connection_recovery, 1);
469
470	if (iscsit_close_connection(conn) < 0)
471	return -1;
472
473	return 0;
474	}