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