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