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 <target/iscsi/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 */ 35 void 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 63 void 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 83 static 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 94 static 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 109 struct 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 127 void 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 177 int 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 194 static 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 */ 206 int 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 223 void 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 273 int 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 314 int 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 428 int 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