iscsi-target: Fix CmdSN comparison (use cmd->cmd_sn instead of cmd->stat_sn)
[~shefty/rdma-dev.git] / drivers / target / iscsi / iscsi_target_erl2.c
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_fabric.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         __be32 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 (be32_to_cpu(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_conn_node) {
142
143                         list_del(&cmd->i_conn_node);
144                         cmd->conn = NULL;
145                         spin_unlock(&cr->conn_recovery_cmd_lock);
146                         iscsit_free_cmd(cmd);
147                         spin_lock(&cr->conn_recovery_cmd_lock);
148                 }
149                 spin_unlock(&cr->conn_recovery_cmd_lock);
150                 spin_lock(&sess->cr_a_lock);
151
152                 kfree(cr);
153         }
154         spin_unlock(&sess->cr_a_lock);
155
156         spin_lock(&sess->cr_i_lock);
157         list_for_each_entry_safe(cr, cr_tmp, &sess->cr_inactive_list, cr_list) {
158                 list_del(&cr->cr_list);
159                 spin_unlock(&sess->cr_i_lock);
160
161                 spin_lock(&cr->conn_recovery_cmd_lock);
162                 list_for_each_entry_safe(cmd, cmd_tmp,
163                                 &cr->conn_recovery_cmd_list, i_conn_node) {
164
165                         list_del(&cmd->i_conn_node);
166                         cmd->conn = NULL;
167                         spin_unlock(&cr->conn_recovery_cmd_lock);
168                         iscsit_free_cmd(cmd);
169                         spin_lock(&cr->conn_recovery_cmd_lock);
170                 }
171                 spin_unlock(&cr->conn_recovery_cmd_lock);
172                 spin_lock(&sess->cr_i_lock);
173
174                 kfree(cr);
175         }
176         spin_unlock(&sess->cr_i_lock);
177 }
178
179 int iscsit_remove_active_connection_recovery_entry(
180         struct iscsi_conn_recovery *cr,
181         struct iscsi_session *sess)
182 {
183         spin_lock(&sess->cr_a_lock);
184         list_del(&cr->cr_list);
185
186         sess->conn_recovery_count--;
187         pr_debug("Decremented connection recovery count to %u for"
188                 " SID: %u\n", sess->conn_recovery_count, sess->sid);
189         spin_unlock(&sess->cr_a_lock);
190
191         kfree(cr);
192
193         return 0;
194 }
195
196 static void iscsit_remove_inactive_connection_recovery_entry(
197         struct iscsi_conn_recovery *cr,
198         struct iscsi_session *sess)
199 {
200         spin_lock(&sess->cr_i_lock);
201         list_del(&cr->cr_list);
202         spin_unlock(&sess->cr_i_lock);
203 }
204
205 /*
206  *      Called with cr->conn_recovery_cmd_lock help.
207  */
208 int iscsit_remove_cmd_from_connection_recovery(
209         struct iscsi_cmd *cmd,
210         struct iscsi_session *sess)
211 {
212         struct iscsi_conn_recovery *cr;
213
214         if (!cmd->cr) {
215                 pr_err("struct iscsi_conn_recovery pointer for ITT: 0x%08x"
216                         " is NULL!\n", cmd->init_task_tag);
217                 BUG();
218         }
219         cr = cmd->cr;
220
221         list_del(&cmd->i_conn_node);
222         return --cr->cmd_count;
223 }
224
225 void iscsit_discard_cr_cmds_by_expstatsn(
226         struct iscsi_conn_recovery *cr,
227         u32 exp_statsn)
228 {
229         u32 dropped_count = 0;
230         struct iscsi_cmd *cmd, *cmd_tmp;
231         struct iscsi_session *sess = cr->sess;
232
233         spin_lock(&cr->conn_recovery_cmd_lock);
234         list_for_each_entry_safe(cmd, cmd_tmp,
235                         &cr->conn_recovery_cmd_list, i_conn_node) {
236
237                 if (((cmd->deferred_i_state != ISTATE_SENT_STATUS) &&
238                      (cmd->deferred_i_state != ISTATE_REMOVE)) ||
239                      (cmd->stat_sn >= exp_statsn)) {
240                         continue;
241                 }
242
243                 dropped_count++;
244                 pr_debug("Dropping Acknowledged ITT: 0x%08x, StatSN:"
245                         " 0x%08x, CID: %hu.\n", cmd->init_task_tag,
246                                 cmd->stat_sn, cr->cid);
247
248                 iscsit_remove_cmd_from_connection_recovery(cmd, sess);
249
250                 spin_unlock(&cr->conn_recovery_cmd_lock);
251                 iscsit_free_cmd(cmd);
252                 spin_lock(&cr->conn_recovery_cmd_lock);
253         }
254         spin_unlock(&cr->conn_recovery_cmd_lock);
255
256         pr_debug("Dropped %u total acknowledged commands on"
257                 " CID: %hu less than old ExpStatSN: 0x%08x\n",
258                         dropped_count, cr->cid, exp_statsn);
259
260         if (!cr->cmd_count) {
261                 pr_debug("No commands to be reassigned for failed"
262                         " connection CID: %hu on SID: %u\n",
263                         cr->cid, sess->sid);
264                 iscsit_remove_inactive_connection_recovery_entry(cr, sess);
265                 iscsit_attach_active_connection_recovery_entry(sess, cr);
266                 pr_debug("iSCSI connection recovery successful for CID:"
267                         " %hu on SID: %u\n", cr->cid, sess->sid);
268                 iscsit_remove_active_connection_recovery_entry(cr, sess);
269         } else {
270                 iscsit_remove_inactive_connection_recovery_entry(cr, sess);
271                 iscsit_attach_active_connection_recovery_entry(sess, cr);
272         }
273 }
274
275 int iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(struct iscsi_conn *conn)
276 {
277         u32 dropped_count = 0;
278         struct iscsi_cmd *cmd, *cmd_tmp;
279         struct iscsi_ooo_cmdsn *ooo_cmdsn, *ooo_cmdsn_tmp;
280         struct iscsi_session *sess = conn->sess;
281
282         mutex_lock(&sess->cmdsn_mutex);
283         list_for_each_entry_safe(ooo_cmdsn, ooo_cmdsn_tmp,
284                         &sess->sess_ooo_cmdsn_list, ooo_list) {
285
286                 if (ooo_cmdsn->cid != conn->cid)
287                         continue;
288
289                 dropped_count++;
290                 pr_debug("Dropping unacknowledged CmdSN:"
291                 " 0x%08x during connection recovery on CID: %hu\n",
292                         ooo_cmdsn->cmdsn, conn->cid);
293                 iscsit_remove_ooo_cmdsn(sess, ooo_cmdsn);
294         }
295         mutex_unlock(&sess->cmdsn_mutex);
296
297         spin_lock_bh(&conn->cmd_lock);
298         list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_conn_node) {
299                 if (!(cmd->cmd_flags & ICF_OOO_CMDSN))
300                         continue;
301
302                 list_del(&cmd->i_conn_node);
303
304                 spin_unlock_bh(&conn->cmd_lock);
305                 iscsit_free_cmd(cmd);
306                 spin_lock_bh(&conn->cmd_lock);
307         }
308         spin_unlock_bh(&conn->cmd_lock);
309
310         pr_debug("Dropped %u total unacknowledged commands on CID:"
311                 " %hu for ExpCmdSN: 0x%08x.\n", dropped_count, conn->cid,
312                                 sess->exp_cmd_sn);
313         return 0;
314 }
315
316 int iscsit_prepare_cmds_for_realligance(struct iscsi_conn *conn)
317 {
318         u32 cmd_count = 0;
319         struct iscsi_cmd *cmd, *cmd_tmp;
320         struct iscsi_conn_recovery *cr;
321
322         /*
323          * Allocate an struct iscsi_conn_recovery for this connection.
324          * Each struct iscsi_cmd contains an struct iscsi_conn_recovery pointer
325          * (struct iscsi_cmd->cr) so we need to allocate this before preparing the
326          * connection's command list for connection recovery.
327          */
328         cr = kzalloc(sizeof(struct iscsi_conn_recovery), GFP_KERNEL);
329         if (!cr) {
330                 pr_err("Unable to allocate memory for"
331                         " struct iscsi_conn_recovery.\n");
332                 return -1;
333         }
334         INIT_LIST_HEAD(&cr->cr_list);
335         INIT_LIST_HEAD(&cr->conn_recovery_cmd_list);
336         spin_lock_init(&cr->conn_recovery_cmd_lock);
337         /*
338          * Only perform connection recovery on ISCSI_OP_SCSI_CMD or
339          * ISCSI_OP_NOOP_OUT opcodes.  For all other opcodes call
340          * list_del(&cmd->i_conn_node); to release the command to the
341          * session pool and remove it from the connection's list.
342          *
343          * Also stop the DataOUT timer, which will be restarted after
344          * sending the TMR response.
345          */
346         spin_lock_bh(&conn->cmd_lock);
347         list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_conn_node) {
348
349                 if ((cmd->iscsi_opcode != ISCSI_OP_SCSI_CMD) &&
350                     (cmd->iscsi_opcode != ISCSI_OP_NOOP_OUT)) {
351                         pr_debug("Not performing realligence on"
352                                 " Opcode: 0x%02x, ITT: 0x%08x, CmdSN: 0x%08x,"
353                                 " CID: %hu\n", cmd->iscsi_opcode,
354                                 cmd->init_task_tag, cmd->cmd_sn, conn->cid);
355
356                         list_del(&cmd->i_conn_node);
357                         spin_unlock_bh(&conn->cmd_lock);
358                         iscsit_free_cmd(cmd);
359                         spin_lock_bh(&conn->cmd_lock);
360                         continue;
361                 }
362
363                 /*
364                  * Special case where commands greater than or equal to
365                  * the session's ExpCmdSN are attached to the connection
366                  * list but not to the out of order CmdSN list.  The one
367                  * obvious case is when a command with immediate data
368                  * attached must only check the CmdSN against ExpCmdSN
369                  * after the data is received.  The special case below
370                  * is when the connection fails before data is received,
371                  * but also may apply to other PDUs, so it has been
372                  * made generic here.
373                  */
374                 if (!(cmd->cmd_flags & ICF_OOO_CMDSN) && !cmd->immediate_cmd &&
375                      iscsi_sna_gte(cmd->cmd_sn, conn->sess->exp_cmd_sn)) {
376                         list_del(&cmd->i_conn_node);
377                         spin_unlock_bh(&conn->cmd_lock);
378                         iscsit_free_cmd(cmd);
379                         spin_lock_bh(&conn->cmd_lock);
380                         continue;
381                 }
382
383                 cmd_count++;
384                 pr_debug("Preparing Opcode: 0x%02x, ITT: 0x%08x,"
385                         " CmdSN: 0x%08x, StatSN: 0x%08x, CID: %hu for"
386                         " realligence.\n", cmd->iscsi_opcode,
387                         cmd->init_task_tag, cmd->cmd_sn, cmd->stat_sn,
388                         conn->cid);
389
390                 cmd->deferred_i_state = cmd->i_state;
391                 cmd->i_state = ISTATE_IN_CONNECTION_RECOVERY;
392
393                 if (cmd->data_direction == DMA_TO_DEVICE)
394                         iscsit_stop_dataout_timer(cmd);
395
396                 cmd->sess = conn->sess;
397
398                 list_del(&cmd->i_conn_node);
399                 spin_unlock_bh(&conn->cmd_lock);
400
401                 iscsit_free_all_datain_reqs(cmd);
402
403                 transport_wait_for_tasks(&cmd->se_cmd);
404                 /*
405                  * Add the struct iscsi_cmd to the connection recovery cmd list
406                  */
407                 spin_lock(&cr->conn_recovery_cmd_lock);
408                 list_add_tail(&cmd->i_conn_node, &cr->conn_recovery_cmd_list);
409                 spin_unlock(&cr->conn_recovery_cmd_lock);
410
411                 spin_lock_bh(&conn->cmd_lock);
412                 cmd->cr = cr;
413                 cmd->conn = NULL;
414         }
415         spin_unlock_bh(&conn->cmd_lock);
416         /*
417          * Fill in the various values in the preallocated struct iscsi_conn_recovery.
418          */
419         cr->cid = conn->cid;
420         cr->cmd_count = cmd_count;
421         cr->maxrecvdatasegmentlength = conn->conn_ops->MaxRecvDataSegmentLength;
422         cr->maxxmitdatasegmentlength = conn->conn_ops->MaxXmitDataSegmentLength;
423         cr->sess = conn->sess;
424
425         iscsit_attach_inactive_connection_recovery_entry(conn->sess, cr);
426
427         return 0;
428 }
429
430 int iscsit_connection_recovery_transport_reset(struct iscsi_conn *conn)
431 {
432         atomic_set(&conn->connection_recovery, 1);
433
434         if (iscsit_close_connection(conn) < 0)
435                 return -1;
436
437         return 0;
438 }