1 /* 2 * iSCSI lib functions 3 * 4 * Copyright (C) 2006 Red Hat, Inc. All rights reserved. 5 * Copyright (C) 2004 - 2006 Mike Christie 6 * Copyright (C) 2004 - 2005 Dmitry Yusupov 7 * Copyright (C) 2004 - 2005 Alex Aizman 8 * maintained by open-iscsi@googlegroups.com 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 23 */ 24 #include <linux/types.h> 25 #include <linux/kfifo.h> 26 #include <linux/delay.h> 27 #include <linux/log2.h> 28 #include <linux/slab.h> 29 #include <linux/sched/signal.h> 30 #include <linux/module.h> 31 #include <asm/unaligned.h> 32 #include <net/tcp.h> 33 #include <scsi/scsi_cmnd.h> 34 #include <scsi/scsi_device.h> 35 #include <scsi/scsi_eh.h> 36 #include <scsi/scsi_tcq.h> 37 #include <scsi/scsi_host.h> 38 #include <scsi/scsi.h> 39 #include <scsi/iscsi_proto.h> 40 #include <scsi/scsi_transport.h> 41 #include <scsi/scsi_transport_iscsi.h> 42 #include <scsi/libiscsi.h> 43 44 static int iscsi_dbg_lib_conn; 45 module_param_named(debug_libiscsi_conn, iscsi_dbg_lib_conn, int, 46 S_IRUGO | S_IWUSR); 47 MODULE_PARM_DESC(debug_libiscsi_conn, 48 "Turn on debugging for connections in libiscsi module. " 49 "Set to 1 to turn on, and zero to turn off. Default is off."); 50 51 static int iscsi_dbg_lib_session; 52 module_param_named(debug_libiscsi_session, iscsi_dbg_lib_session, int, 53 S_IRUGO | S_IWUSR); 54 MODULE_PARM_DESC(debug_libiscsi_session, 55 "Turn on debugging for sessions in libiscsi module. " 56 "Set to 1 to turn on, and zero to turn off. Default is off."); 57 58 static int iscsi_dbg_lib_eh; 59 module_param_named(debug_libiscsi_eh, iscsi_dbg_lib_eh, int, 60 S_IRUGO | S_IWUSR); 61 MODULE_PARM_DESC(debug_libiscsi_eh, 62 "Turn on debugging for error handling in libiscsi module. " 63 "Set to 1 to turn on, and zero to turn off. Default is off."); 64 65 #define ISCSI_DBG_CONN(_conn, dbg_fmt, arg...) \ 66 do { \ 67 if (iscsi_dbg_lib_conn) \ 68 iscsi_conn_printk(KERN_INFO, _conn, \ 69 "%s " dbg_fmt, \ 70 __func__, ##arg); \ 71 } while (0); 72 73 #define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...) \ 74 do { \ 75 if (iscsi_dbg_lib_session) \ 76 iscsi_session_printk(KERN_INFO, _session, \ 77 "%s " dbg_fmt, \ 78 __func__, ##arg); \ 79 } while (0); 80 81 #define ISCSI_DBG_EH(_session, dbg_fmt, arg...) \ 82 do { \ 83 if (iscsi_dbg_lib_eh) \ 84 iscsi_session_printk(KERN_INFO, _session, \ 85 "%s " dbg_fmt, \ 86 __func__, ##arg); \ 87 } while (0); 88 89 inline void iscsi_conn_queue_work(struct iscsi_conn *conn) 90 { 91 struct Scsi_Host *shost = conn->session->host; 92 struct iscsi_host *ihost = shost_priv(shost); 93 94 if (ihost->workq) 95 queue_work(ihost->workq, &conn->xmitwork); 96 } 97 EXPORT_SYMBOL_GPL(iscsi_conn_queue_work); 98 99 static void __iscsi_update_cmdsn(struct iscsi_session *session, 100 uint32_t exp_cmdsn, uint32_t max_cmdsn) 101 { 102 /* 103 * standard specifies this check for when to update expected and 104 * max sequence numbers 105 */ 106 if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1)) 107 return; 108 109 if (exp_cmdsn != session->exp_cmdsn && 110 !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn)) 111 session->exp_cmdsn = exp_cmdsn; 112 113 if (max_cmdsn != session->max_cmdsn && 114 !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) 115 session->max_cmdsn = max_cmdsn; 116 } 117 118 void iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr) 119 { 120 __iscsi_update_cmdsn(session, be32_to_cpu(hdr->exp_cmdsn), 121 be32_to_cpu(hdr->max_cmdsn)); 122 } 123 EXPORT_SYMBOL_GPL(iscsi_update_cmdsn); 124 125 /** 126 * iscsi_prep_data_out_pdu - initialize Data-Out 127 * @task: scsi command task 128 * @r2t: R2T info 129 * @hdr: iscsi data in pdu 130 * 131 * Notes: 132 * Initialize Data-Out within this R2T sequence and finds 133 * proper data_offset within this SCSI command. 134 * 135 * This function is called with connection lock taken. 136 **/ 137 void iscsi_prep_data_out_pdu(struct iscsi_task *task, struct iscsi_r2t_info *r2t, 138 struct iscsi_data *hdr) 139 { 140 struct iscsi_conn *conn = task->conn; 141 unsigned int left = r2t->data_length - r2t->sent; 142 143 task->hdr_len = sizeof(struct iscsi_data); 144 145 memset(hdr, 0, sizeof(struct iscsi_data)); 146 hdr->ttt = r2t->ttt; 147 hdr->datasn = cpu_to_be32(r2t->datasn); 148 r2t->datasn++; 149 hdr->opcode = ISCSI_OP_SCSI_DATA_OUT; 150 hdr->lun = task->lun; 151 hdr->itt = task->hdr_itt; 152 hdr->exp_statsn = r2t->exp_statsn; 153 hdr->offset = cpu_to_be32(r2t->data_offset + r2t->sent); 154 if (left > conn->max_xmit_dlength) { 155 hton24(hdr->dlength, conn->max_xmit_dlength); 156 r2t->data_count = conn->max_xmit_dlength; 157 hdr->flags = 0; 158 } else { 159 hton24(hdr->dlength, left); 160 r2t->data_count = left; 161 hdr->flags = ISCSI_FLAG_CMD_FINAL; 162 } 163 conn->dataout_pdus_cnt++; 164 } 165 EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu); 166 167 static int iscsi_add_hdr(struct iscsi_task *task, unsigned len) 168 { 169 unsigned exp_len = task->hdr_len + len; 170 171 if (exp_len > task->hdr_max) { 172 WARN_ON(1); 173 return -EINVAL; 174 } 175 176 WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */ 177 task->hdr_len = exp_len; 178 return 0; 179 } 180 181 /* 182 * make an extended cdb AHS 183 */ 184 static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) 185 { 186 struct scsi_cmnd *cmd = task->sc; 187 unsigned rlen, pad_len; 188 unsigned short ahslength; 189 struct iscsi_ecdb_ahdr *ecdb_ahdr; 190 int rc; 191 192 ecdb_ahdr = iscsi_next_hdr(task); 193 rlen = cmd->cmd_len - ISCSI_CDB_SIZE; 194 195 BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb)); 196 ahslength = rlen + sizeof(ecdb_ahdr->reserved); 197 198 pad_len = iscsi_padding(rlen); 199 200 rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) + 201 sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len); 202 if (rc) 203 return rc; 204 205 if (pad_len) 206 memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len); 207 208 ecdb_ahdr->ahslength = cpu_to_be16(ahslength); 209 ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB; 210 ecdb_ahdr->reserved = 0; 211 memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen); 212 213 ISCSI_DBG_SESSION(task->conn->session, 214 "iscsi_prep_ecdb_ahs: varlen_cdb_len %d " 215 "rlen %d pad_len %d ahs_length %d iscsi_headers_size " 216 "%u\n", cmd->cmd_len, rlen, pad_len, ahslength, 217 task->hdr_len); 218 return 0; 219 } 220 221 static int iscsi_prep_bidi_ahs(struct iscsi_task *task) 222 { 223 struct scsi_cmnd *sc = task->sc; 224 struct iscsi_rlength_ahdr *rlen_ahdr; 225 int rc; 226 227 rlen_ahdr = iscsi_next_hdr(task); 228 rc = iscsi_add_hdr(task, sizeof(*rlen_ahdr)); 229 if (rc) 230 return rc; 231 232 rlen_ahdr->ahslength = 233 cpu_to_be16(sizeof(rlen_ahdr->read_length) + 234 sizeof(rlen_ahdr->reserved)); 235 rlen_ahdr->ahstype = ISCSI_AHSTYPE_RLENGTH; 236 rlen_ahdr->reserved = 0; 237 rlen_ahdr->read_length = cpu_to_be32(scsi_in(sc)->length); 238 239 ISCSI_DBG_SESSION(task->conn->session, 240 "bidi-in rlen_ahdr->read_length(%d) " 241 "rlen_ahdr->ahslength(%d)\n", 242 be32_to_cpu(rlen_ahdr->read_length), 243 be16_to_cpu(rlen_ahdr->ahslength)); 244 return 0; 245 } 246 247 /** 248 * iscsi_check_tmf_restrictions - check if a task is affected by TMF 249 * @task: iscsi task 250 * @opcode: opcode to check for 251 * 252 * During TMF a task has to be checked if it's affected. 253 * All unrelated I/O can be passed through, but I/O to the 254 * affected LUN should be restricted. 255 * If 'fast_abort' is set we won't be sending any I/O to the 256 * affected LUN. 257 * Otherwise the target is waiting for all TTTs to be completed, 258 * so we have to send all outstanding Data-Out PDUs to the target. 259 */ 260 static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode) 261 { 262 struct iscsi_conn *conn = task->conn; 263 struct iscsi_tm *tmf = &conn->tmhdr; 264 u64 hdr_lun; 265 266 if (conn->tmf_state == TMF_INITIAL) 267 return 0; 268 269 if ((tmf->opcode & ISCSI_OPCODE_MASK) != ISCSI_OP_SCSI_TMFUNC) 270 return 0; 271 272 switch (ISCSI_TM_FUNC_VALUE(tmf)) { 273 case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET: 274 /* 275 * Allow PDUs for unrelated LUNs 276 */ 277 hdr_lun = scsilun_to_int(&tmf->lun); 278 if (hdr_lun != task->sc->device->lun) 279 return 0; 280 /* fall through */ 281 case ISCSI_TM_FUNC_TARGET_WARM_RESET: 282 /* 283 * Fail all SCSI cmd PDUs 284 */ 285 if (opcode != ISCSI_OP_SCSI_DATA_OUT) { 286 iscsi_conn_printk(KERN_INFO, conn, 287 "task [op %x/%x itt " 288 "0x%x/0x%x] " 289 "rejected.\n", 290 task->hdr->opcode, opcode, 291 task->itt, task->hdr_itt); 292 return -EACCES; 293 } 294 /* 295 * And also all data-out PDUs in response to R2T 296 * if fast_abort is set. 297 */ 298 if (conn->session->fast_abort) { 299 iscsi_conn_printk(KERN_INFO, conn, 300 "task [op %x/%x itt " 301 "0x%x/0x%x] fast abort.\n", 302 task->hdr->opcode, opcode, 303 task->itt, task->hdr_itt); 304 return -EACCES; 305 } 306 break; 307 case ISCSI_TM_FUNC_ABORT_TASK: 308 /* 309 * the caller has already checked if the task 310 * they want to abort was in the pending queue so if 311 * we are here the cmd pdu has gone out already, and 312 * we will only hit this for data-outs 313 */ 314 if (opcode == ISCSI_OP_SCSI_DATA_OUT && 315 task->hdr_itt == tmf->rtt) { 316 ISCSI_DBG_SESSION(conn->session, 317 "Preventing task %x/%x from sending " 318 "data-out due to abort task in " 319 "progress\n", task->itt, 320 task->hdr_itt); 321 return -EACCES; 322 } 323 break; 324 } 325 326 return 0; 327 } 328 329 /** 330 * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu 331 * @task: iscsi task 332 * 333 * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set 334 * fields like dlength or final based on how much data it sends 335 */ 336 static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task) 337 { 338 struct iscsi_conn *conn = task->conn; 339 struct iscsi_session *session = conn->session; 340 struct scsi_cmnd *sc = task->sc; 341 struct iscsi_scsi_req *hdr; 342 unsigned hdrlength, cmd_len, transfer_length; 343 itt_t itt; 344 int rc; 345 346 rc = iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_CMD); 347 if (rc) 348 return rc; 349 350 if (conn->session->tt->alloc_pdu) { 351 rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD); 352 if (rc) 353 return rc; 354 } 355 hdr = (struct iscsi_scsi_req *)task->hdr; 356 itt = hdr->itt; 357 memset(hdr, 0, sizeof(*hdr)); 358 359 if (session->tt->parse_pdu_itt) 360 hdr->itt = task->hdr_itt = itt; 361 else 362 hdr->itt = task->hdr_itt = build_itt(task->itt, 363 task->conn->session->age); 364 task->hdr_len = 0; 365 rc = iscsi_add_hdr(task, sizeof(*hdr)); 366 if (rc) 367 return rc; 368 hdr->opcode = ISCSI_OP_SCSI_CMD; 369 hdr->flags = ISCSI_ATTR_SIMPLE; 370 int_to_scsilun(sc->device->lun, &hdr->lun); 371 task->lun = hdr->lun; 372 hdr->exp_statsn = cpu_to_be32(conn->exp_statsn); 373 cmd_len = sc->cmd_len; 374 if (cmd_len < ISCSI_CDB_SIZE) 375 memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len); 376 else if (cmd_len > ISCSI_CDB_SIZE) { 377 rc = iscsi_prep_ecdb_ahs(task); 378 if (rc) 379 return rc; 380 cmd_len = ISCSI_CDB_SIZE; 381 } 382 memcpy(hdr->cdb, sc->cmnd, cmd_len); 383 384 task->imm_count = 0; 385 if (scsi_bidi_cmnd(sc)) { 386 hdr->flags |= ISCSI_FLAG_CMD_READ; 387 rc = iscsi_prep_bidi_ahs(task); 388 if (rc) 389 return rc; 390 } 391 392 if (scsi_get_prot_op(sc) != SCSI_PROT_NORMAL) 393 task->protected = true; 394 395 transfer_length = scsi_transfer_length(sc); 396 hdr->data_length = cpu_to_be32(transfer_length); 397 if (sc->sc_data_direction == DMA_TO_DEVICE) { 398 struct iscsi_r2t_info *r2t = &task->unsol_r2t; 399 400 hdr->flags |= ISCSI_FLAG_CMD_WRITE; 401 /* 402 * Write counters: 403 * 404 * imm_count bytes to be sent right after 405 * SCSI PDU Header 406 * 407 * unsol_count bytes(as Data-Out) to be sent 408 * without R2T ack right after 409 * immediate data 410 * 411 * r2t data_length bytes to be sent via R2T ack's 412 * 413 * pad_count bytes to be sent as zero-padding 414 */ 415 memset(r2t, 0, sizeof(*r2t)); 416 417 if (session->imm_data_en) { 418 if (transfer_length >= session->first_burst) 419 task->imm_count = min(session->first_burst, 420 conn->max_xmit_dlength); 421 else 422 task->imm_count = min(transfer_length, 423 conn->max_xmit_dlength); 424 hton24(hdr->dlength, task->imm_count); 425 } else 426 zero_data(hdr->dlength); 427 428 if (!session->initial_r2t_en) { 429 r2t->data_length = min(session->first_burst, 430 transfer_length) - 431 task->imm_count; 432 r2t->data_offset = task->imm_count; 433 r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG); 434 r2t->exp_statsn = cpu_to_be32(conn->exp_statsn); 435 } 436 437 if (!task->unsol_r2t.data_length) 438 /* No unsolicit Data-Out's */ 439 hdr->flags |= ISCSI_FLAG_CMD_FINAL; 440 } else { 441 hdr->flags |= ISCSI_FLAG_CMD_FINAL; 442 zero_data(hdr->dlength); 443 444 if (sc->sc_data_direction == DMA_FROM_DEVICE) 445 hdr->flags |= ISCSI_FLAG_CMD_READ; 446 } 447 448 /* calculate size of additional header segments (AHSs) */ 449 hdrlength = task->hdr_len - sizeof(*hdr); 450 451 WARN_ON(hdrlength & (ISCSI_PAD_LEN-1)); 452 hdrlength /= ISCSI_PAD_LEN; 453 454 WARN_ON(hdrlength >= 256); 455 hdr->hlength = hdrlength & 0xFF; 456 hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn); 457 458 if (session->tt->init_task && session->tt->init_task(task)) 459 return -EIO; 460 461 task->state = ISCSI_TASK_RUNNING; 462 session->cmdsn++; 463 464 conn->scsicmd_pdus_cnt++; 465 ISCSI_DBG_SESSION(session, "iscsi prep [%s cid %d sc %p cdb 0x%x " 466 "itt 0x%x len %d bidi_len %d cmdsn %d win %d]\n", 467 scsi_bidi_cmnd(sc) ? "bidirectional" : 468 sc->sc_data_direction == DMA_TO_DEVICE ? 469 "write" : "read", conn->id, sc, sc->cmnd[0], 470 task->itt, transfer_length, 471 scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0, 472 session->cmdsn, 473 session->max_cmdsn - session->exp_cmdsn + 1); 474 return 0; 475 } 476 477 /** 478 * iscsi_free_task - free a task 479 * @task: iscsi cmd task 480 * 481 * Must be called with session back_lock. 482 * This function returns the scsi command to scsi-ml or cleans 483 * up mgmt tasks then returns the task to the pool. 484 */ 485 static void iscsi_free_task(struct iscsi_task *task) 486 { 487 struct iscsi_conn *conn = task->conn; 488 struct iscsi_session *session = conn->session; 489 struct scsi_cmnd *sc = task->sc; 490 int oldstate = task->state; 491 492 ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n", 493 task->itt, task->state, task->sc); 494 495 session->tt->cleanup_task(task); 496 task->state = ISCSI_TASK_FREE; 497 task->sc = NULL; 498 /* 499 * login task is preallocated so do not free 500 */ 501 if (conn->login_task == task) 502 return; 503 504 kfifo_in(&session->cmdpool.queue, (void*)&task, sizeof(void*)); 505 506 if (sc) { 507 /* SCSI eh reuses commands to verify us */ 508 sc->SCp.ptr = NULL; 509 /* 510 * queue command may call this to free the task, so 511 * it will decide how to return sc to scsi-ml. 512 */ 513 if (oldstate != ISCSI_TASK_REQUEUE_SCSIQ) 514 sc->scsi_done(sc); 515 } 516 } 517 518 void __iscsi_get_task(struct iscsi_task *task) 519 { 520 refcount_inc(&task->refcount); 521 } 522 EXPORT_SYMBOL_GPL(__iscsi_get_task); 523 524 void __iscsi_put_task(struct iscsi_task *task) 525 { 526 if (refcount_dec_and_test(&task->refcount)) 527 iscsi_free_task(task); 528 } 529 EXPORT_SYMBOL_GPL(__iscsi_put_task); 530 531 void iscsi_put_task(struct iscsi_task *task) 532 { 533 struct iscsi_session *session = task->conn->session; 534 535 /* regular RX path uses back_lock */ 536 spin_lock_bh(&session->back_lock); 537 __iscsi_put_task(task); 538 spin_unlock_bh(&session->back_lock); 539 } 540 EXPORT_SYMBOL_GPL(iscsi_put_task); 541 542 /** 543 * iscsi_complete_task - finish a task 544 * @task: iscsi cmd task 545 * @state: state to complete task with 546 * 547 * Must be called with session back_lock. 548 */ 549 static void iscsi_complete_task(struct iscsi_task *task, int state) 550 { 551 struct iscsi_conn *conn = task->conn; 552 553 ISCSI_DBG_SESSION(conn->session, 554 "complete task itt 0x%x state %d sc %p\n", 555 task->itt, task->state, task->sc); 556 if (task->state == ISCSI_TASK_COMPLETED || 557 task->state == ISCSI_TASK_ABRT_TMF || 558 task->state == ISCSI_TASK_ABRT_SESS_RECOV || 559 task->state == ISCSI_TASK_REQUEUE_SCSIQ) 560 return; 561 WARN_ON_ONCE(task->state == ISCSI_TASK_FREE); 562 task->state = state; 563 564 spin_lock_bh(&conn->taskqueuelock); 565 if (!list_empty(&task->running)) { 566 pr_debug_once("%s while task on list", __func__); 567 list_del_init(&task->running); 568 } 569 spin_unlock_bh(&conn->taskqueuelock); 570 571 if (conn->task == task) 572 conn->task = NULL; 573 574 if (conn->ping_task == task) 575 conn->ping_task = NULL; 576 577 /* release get from queueing */ 578 __iscsi_put_task(task); 579 } 580 581 /** 582 * iscsi_complete_scsi_task - finish scsi task normally 583 * @task: iscsi task for scsi cmd 584 * @exp_cmdsn: expected cmd sn in cpu format 585 * @max_cmdsn: max cmd sn in cpu format 586 * 587 * This is used when drivers do not need or cannot perform 588 * lower level pdu processing. 589 * 590 * Called with session back_lock 591 */ 592 void iscsi_complete_scsi_task(struct iscsi_task *task, 593 uint32_t exp_cmdsn, uint32_t max_cmdsn) 594 { 595 struct iscsi_conn *conn = task->conn; 596 597 ISCSI_DBG_SESSION(conn->session, "[itt 0x%x]\n", task->itt); 598 599 conn->last_recv = jiffies; 600 __iscsi_update_cmdsn(conn->session, exp_cmdsn, max_cmdsn); 601 iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 602 } 603 EXPORT_SYMBOL_GPL(iscsi_complete_scsi_task); 604 605 606 /* 607 * session back_lock must be held and if not called for a task that is 608 * still pending or from the xmit thread, then xmit thread must 609 * be suspended. 610 */ 611 static void fail_scsi_task(struct iscsi_task *task, int err) 612 { 613 struct iscsi_conn *conn = task->conn; 614 struct scsi_cmnd *sc; 615 int state; 616 617 /* 618 * if a command completes and we get a successful tmf response 619 * we will hit this because the scsi eh abort code does not take 620 * a ref to the task. 621 */ 622 sc = task->sc; 623 if (!sc) 624 return; 625 626 if (task->state == ISCSI_TASK_PENDING) { 627 /* 628 * cmd never made it to the xmit thread, so we should not count 629 * the cmd in the sequencing 630 */ 631 conn->session->queued_cmdsn--; 632 /* it was never sent so just complete like normal */ 633 state = ISCSI_TASK_COMPLETED; 634 } else if (err == DID_TRANSPORT_DISRUPTED) 635 state = ISCSI_TASK_ABRT_SESS_RECOV; 636 else 637 state = ISCSI_TASK_ABRT_TMF; 638 639 sc->result = err << 16; 640 if (!scsi_bidi_cmnd(sc)) 641 scsi_set_resid(sc, scsi_bufflen(sc)); 642 else { 643 scsi_out(sc)->resid = scsi_out(sc)->length; 644 scsi_in(sc)->resid = scsi_in(sc)->length; 645 } 646 647 /* regular RX path uses back_lock */ 648 spin_lock_bh(&conn->session->back_lock); 649 iscsi_complete_task(task, state); 650 spin_unlock_bh(&conn->session->back_lock); 651 } 652 653 static int iscsi_prep_mgmt_task(struct iscsi_conn *conn, 654 struct iscsi_task *task) 655 { 656 struct iscsi_session *session = conn->session; 657 struct iscsi_hdr *hdr = task->hdr; 658 struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr; 659 uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 660 661 if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 662 return -ENOTCONN; 663 664 if (opcode != ISCSI_OP_LOGIN && opcode != ISCSI_OP_TEXT) 665 nop->exp_statsn = cpu_to_be32(conn->exp_statsn); 666 /* 667 * pre-format CmdSN for outgoing PDU. 668 */ 669 nop->cmdsn = cpu_to_be32(session->cmdsn); 670 if (hdr->itt != RESERVED_ITT) { 671 /* 672 * TODO: We always use immediate for normal session pdus. 673 * If we start to send tmfs or nops as non-immediate then 674 * we should start checking the cmdsn numbers for mgmt tasks. 675 * 676 * During discovery sessions iscsid sends TEXT as non immediate, 677 * but we always only send one PDU at a time. 678 */ 679 if (conn->c_stage == ISCSI_CONN_STARTED && 680 !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 681 session->queued_cmdsn++; 682 session->cmdsn++; 683 } 684 } 685 686 if (session->tt->init_task && session->tt->init_task(task)) 687 return -EIO; 688 689 if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT) 690 session->state = ISCSI_STATE_LOGGING_OUT; 691 692 task->state = ISCSI_TASK_RUNNING; 693 ISCSI_DBG_SESSION(session, "mgmtpdu [op 0x%x hdr->itt 0x%x " 694 "datalen %d]\n", hdr->opcode & ISCSI_OPCODE_MASK, 695 hdr->itt, task->data_count); 696 return 0; 697 } 698 699 static struct iscsi_task * 700 __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 701 char *data, uint32_t data_size) 702 { 703 struct iscsi_session *session = conn->session; 704 struct iscsi_host *ihost = shost_priv(session->host); 705 uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 706 struct iscsi_task *task; 707 itt_t itt; 708 709 if (session->state == ISCSI_STATE_TERMINATE) 710 return NULL; 711 712 if (opcode == ISCSI_OP_LOGIN || opcode == ISCSI_OP_TEXT) { 713 /* 714 * Login and Text are sent serially, in 715 * request-followed-by-response sequence. 716 * Same task can be used. Same ITT must be used. 717 * Note that login_task is preallocated at conn_create(). 718 */ 719 if (conn->login_task->state != ISCSI_TASK_FREE) { 720 iscsi_conn_printk(KERN_ERR, conn, "Login/Text in " 721 "progress. Cannot start new task.\n"); 722 return NULL; 723 } 724 725 if (data_size > ISCSI_DEF_MAX_RECV_SEG_LEN) { 726 iscsi_conn_printk(KERN_ERR, conn, "Invalid buffer len of %u for login task. Max len is %u\n", data_size, ISCSI_DEF_MAX_RECV_SEG_LEN); 727 return NULL; 728 } 729 730 task = conn->login_task; 731 } else { 732 if (session->state != ISCSI_STATE_LOGGED_IN) 733 return NULL; 734 735 if (data_size != 0) { 736 iscsi_conn_printk(KERN_ERR, conn, "Can not send data buffer of len %u for op 0x%x\n", data_size, opcode); 737 return NULL; 738 } 739 740 BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE); 741 BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED); 742 743 if (!kfifo_out(&session->cmdpool.queue, 744 (void*)&task, sizeof(void*))) 745 return NULL; 746 } 747 /* 748 * released in complete pdu for task we expect a response for, and 749 * released by the lld when it has transmitted the task for 750 * pdus we do not expect a response for. 751 */ 752 refcount_set(&task->refcount, 1); 753 task->conn = conn; 754 task->sc = NULL; 755 INIT_LIST_HEAD(&task->running); 756 task->state = ISCSI_TASK_PENDING; 757 758 if (data_size) { 759 memcpy(task->data, data, data_size); 760 task->data_count = data_size; 761 } else 762 task->data_count = 0; 763 764 if (conn->session->tt->alloc_pdu) { 765 if (conn->session->tt->alloc_pdu(task, hdr->opcode)) { 766 iscsi_conn_printk(KERN_ERR, conn, "Could not allocate " 767 "pdu for mgmt task.\n"); 768 goto free_task; 769 } 770 } 771 772 itt = task->hdr->itt; 773 task->hdr_len = sizeof(struct iscsi_hdr); 774 memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr)); 775 776 if (hdr->itt != RESERVED_ITT) { 777 if (session->tt->parse_pdu_itt) 778 task->hdr->itt = itt; 779 else 780 task->hdr->itt = build_itt(task->itt, 781 task->conn->session->age); 782 } 783 784 if (!ihost->workq) { 785 if (iscsi_prep_mgmt_task(conn, task)) 786 goto free_task; 787 788 if (session->tt->xmit_task(task)) 789 goto free_task; 790 } else { 791 spin_lock_bh(&conn->taskqueuelock); 792 list_add_tail(&task->running, &conn->mgmtqueue); 793 spin_unlock_bh(&conn->taskqueuelock); 794 iscsi_conn_queue_work(conn); 795 } 796 797 return task; 798 799 free_task: 800 /* regular RX path uses back_lock */ 801 spin_lock(&session->back_lock); 802 __iscsi_put_task(task); 803 spin_unlock(&session->back_lock); 804 return NULL; 805 } 806 807 int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr, 808 char *data, uint32_t data_size) 809 { 810 struct iscsi_conn *conn = cls_conn->dd_data; 811 struct iscsi_session *session = conn->session; 812 int err = 0; 813 814 spin_lock_bh(&session->frwd_lock); 815 if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size)) 816 err = -EPERM; 817 spin_unlock_bh(&session->frwd_lock); 818 return err; 819 } 820 EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu); 821 822 /** 823 * iscsi_cmd_rsp - SCSI Command Response processing 824 * @conn: iscsi connection 825 * @hdr: iscsi header 826 * @task: scsi command task 827 * @data: cmd data buffer 828 * @datalen: len of buffer 829 * 830 * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and 831 * then completes the command and task. 832 **/ 833 static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 834 struct iscsi_task *task, char *data, 835 int datalen) 836 { 837 struct iscsi_scsi_rsp *rhdr = (struct iscsi_scsi_rsp *)hdr; 838 struct iscsi_session *session = conn->session; 839 struct scsi_cmnd *sc = task->sc; 840 841 iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr); 842 conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 843 844 sc->result = (DID_OK << 16) | rhdr->cmd_status; 845 846 if (task->protected) { 847 sector_t sector; 848 u8 ascq; 849 850 /** 851 * Transports that didn't implement check_protection 852 * callback but still published T10-PI support to scsi-mid 853 * deserve this BUG_ON. 854 **/ 855 BUG_ON(!session->tt->check_protection); 856 857 ascq = session->tt->check_protection(task, §or); 858 if (ascq) { 859 sc->result = DRIVER_SENSE << 24 | 860 SAM_STAT_CHECK_CONDITION; 861 scsi_build_sense_buffer(1, sc->sense_buffer, 862 ILLEGAL_REQUEST, 0x10, ascq); 863 scsi_set_sense_information(sc->sense_buffer, 864 SCSI_SENSE_BUFFERSIZE, 865 sector); 866 goto out; 867 } 868 } 869 870 if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) { 871 sc->result = DID_ERROR << 16; 872 goto out; 873 } 874 875 if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) { 876 uint16_t senselen; 877 878 if (datalen < 2) { 879 invalid_datalen: 880 iscsi_conn_printk(KERN_ERR, conn, 881 "Got CHECK_CONDITION but invalid data " 882 "buffer size of %d\n", datalen); 883 sc->result = DID_BAD_TARGET << 16; 884 goto out; 885 } 886 887 senselen = get_unaligned_be16(data); 888 if (datalen < senselen) 889 goto invalid_datalen; 890 891 memcpy(sc->sense_buffer, data + 2, 892 min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 893 ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n", 894 min_t(uint16_t, senselen, 895 SCSI_SENSE_BUFFERSIZE)); 896 } 897 898 if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW | 899 ISCSI_FLAG_CMD_BIDI_OVERFLOW)) { 900 int res_count = be32_to_cpu(rhdr->bi_residual_count); 901 902 if (scsi_bidi_cmnd(sc) && res_count > 0 && 903 (rhdr->flags & ISCSI_FLAG_CMD_BIDI_OVERFLOW || 904 res_count <= scsi_in(sc)->length)) 905 scsi_in(sc)->resid = res_count; 906 else 907 sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 908 } 909 910 if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW | 911 ISCSI_FLAG_CMD_OVERFLOW)) { 912 int res_count = be32_to_cpu(rhdr->residual_count); 913 914 if (res_count > 0 && 915 (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 916 res_count <= scsi_bufflen(sc))) 917 /* write side for bidi or uni-io set_resid */ 918 scsi_set_resid(sc, res_count); 919 else 920 sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 921 } 922 out: 923 ISCSI_DBG_SESSION(session, "cmd rsp done [sc %p res %d itt 0x%x]\n", 924 sc, sc->result, task->itt); 925 conn->scsirsp_pdus_cnt++; 926 iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 927 } 928 929 /** 930 * iscsi_data_in_rsp - SCSI Data-In Response processing 931 * @conn: iscsi connection 932 * @hdr: iscsi pdu 933 * @task: scsi command task 934 **/ 935 static void 936 iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 937 struct iscsi_task *task) 938 { 939 struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr; 940 struct scsi_cmnd *sc = task->sc; 941 942 if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS)) 943 return; 944 945 iscsi_update_cmdsn(conn->session, (struct iscsi_nopin *)hdr); 946 sc->result = (DID_OK << 16) | rhdr->cmd_status; 947 conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 948 if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW | 949 ISCSI_FLAG_DATA_OVERFLOW)) { 950 int res_count = be32_to_cpu(rhdr->residual_count); 951 952 if (res_count > 0 && 953 (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 954 res_count <= scsi_in(sc)->length)) 955 scsi_in(sc)->resid = res_count; 956 else 957 sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 958 } 959 960 ISCSI_DBG_SESSION(conn->session, "data in with status done " 961 "[sc %p res %d itt 0x%x]\n", 962 sc, sc->result, task->itt); 963 conn->scsirsp_pdus_cnt++; 964 iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 965 } 966 967 static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) 968 { 969 struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; 970 971 conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 972 conn->tmfrsp_pdus_cnt++; 973 974 if (conn->tmf_state != TMF_QUEUED) 975 return; 976 977 if (tmf->response == ISCSI_TMF_RSP_COMPLETE) 978 conn->tmf_state = TMF_SUCCESS; 979 else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) 980 conn->tmf_state = TMF_NOT_FOUND; 981 else 982 conn->tmf_state = TMF_FAILED; 983 wake_up(&conn->ehwait); 984 } 985 986 static int iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) 987 { 988 struct iscsi_nopout hdr; 989 struct iscsi_task *task; 990 991 if (!rhdr && conn->ping_task) 992 return -EINVAL; 993 994 memset(&hdr, 0, sizeof(struct iscsi_nopout)); 995 hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE; 996 hdr.flags = ISCSI_FLAG_CMD_FINAL; 997 998 if (rhdr) { 999 hdr.lun = rhdr->lun; 1000 hdr.ttt = rhdr->ttt; 1001 hdr.itt = RESERVED_ITT; 1002 } else 1003 hdr.ttt = RESERVED_ITT; 1004 1005 task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0); 1006 if (!task) { 1007 iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n"); 1008 return -EIO; 1009 } else if (!rhdr) { 1010 /* only track our nops */ 1011 conn->ping_task = task; 1012 conn->last_ping = jiffies; 1013 } 1014 1015 return 0; 1016 } 1017 1018 static int iscsi_nop_out_rsp(struct iscsi_task *task, 1019 struct iscsi_nopin *nop, char *data, int datalen) 1020 { 1021 struct iscsi_conn *conn = task->conn; 1022 int rc = 0; 1023 1024 if (conn->ping_task != task) { 1025 /* 1026 * If this is not in response to one of our 1027 * nops then it must be from userspace. 1028 */ 1029 if (iscsi_recv_pdu(conn->cls_conn, (struct iscsi_hdr *)nop, 1030 data, datalen)) 1031 rc = ISCSI_ERR_CONN_FAILED; 1032 } else 1033 mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout); 1034 iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 1035 return rc; 1036 } 1037 1038 static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 1039 char *data, int datalen) 1040 { 1041 struct iscsi_reject *reject = (struct iscsi_reject *)hdr; 1042 struct iscsi_hdr rejected_pdu; 1043 int opcode, rc = 0; 1044 1045 conn->exp_statsn = be32_to_cpu(reject->statsn) + 1; 1046 1047 if (ntoh24(reject->dlength) > datalen || 1048 ntoh24(reject->dlength) < sizeof(struct iscsi_hdr)) { 1049 iscsi_conn_printk(KERN_ERR, conn, "Cannot handle rejected " 1050 "pdu. Invalid data length (pdu dlength " 1051 "%u, datalen %d\n", ntoh24(reject->dlength), 1052 datalen); 1053 return ISCSI_ERR_PROTO; 1054 } 1055 memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr)); 1056 opcode = rejected_pdu.opcode & ISCSI_OPCODE_MASK; 1057 1058 switch (reject->reason) { 1059 case ISCSI_REASON_DATA_DIGEST_ERROR: 1060 iscsi_conn_printk(KERN_ERR, conn, 1061 "pdu (op 0x%x itt 0x%x) rejected " 1062 "due to DataDigest error.\n", 1063 opcode, rejected_pdu.itt); 1064 break; 1065 case ISCSI_REASON_IMM_CMD_REJECT: 1066 iscsi_conn_printk(KERN_ERR, conn, 1067 "pdu (op 0x%x itt 0x%x) rejected. Too many " 1068 "immediate commands.\n", 1069 opcode, rejected_pdu.itt); 1070 /* 1071 * We only send one TMF at a time so if the target could not 1072 * handle it, then it should get fixed (RFC mandates that 1073 * a target can handle one immediate TMF per conn). 1074 * 1075 * For nops-outs, we could have sent more than one if 1076 * the target is sending us lots of nop-ins 1077 */ 1078 if (opcode != ISCSI_OP_NOOP_OUT) 1079 return 0; 1080 1081 if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG)) { 1082 /* 1083 * nop-out in response to target's nop-out rejected. 1084 * Just resend. 1085 */ 1086 /* In RX path we are under back lock */ 1087 spin_unlock(&conn->session->back_lock); 1088 spin_lock(&conn->session->frwd_lock); 1089 iscsi_send_nopout(conn, 1090 (struct iscsi_nopin*)&rejected_pdu); 1091 spin_unlock(&conn->session->frwd_lock); 1092 spin_lock(&conn->session->back_lock); 1093 } else { 1094 struct iscsi_task *task; 1095 /* 1096 * Our nop as ping got dropped. We know the target 1097 * and transport are ok so just clean up 1098 */ 1099 task = iscsi_itt_to_task(conn, rejected_pdu.itt); 1100 if (!task) { 1101 iscsi_conn_printk(KERN_ERR, conn, 1102 "Invalid pdu reject. Could " 1103 "not lookup rejected task.\n"); 1104 rc = ISCSI_ERR_BAD_ITT; 1105 } else 1106 rc = iscsi_nop_out_rsp(task, 1107 (struct iscsi_nopin*)&rejected_pdu, 1108 NULL, 0); 1109 } 1110 break; 1111 default: 1112 iscsi_conn_printk(KERN_ERR, conn, 1113 "pdu (op 0x%x itt 0x%x) rejected. Reason " 1114 "code 0x%x\n", rejected_pdu.opcode, 1115 rejected_pdu.itt, reject->reason); 1116 break; 1117 } 1118 return rc; 1119 } 1120 1121 /** 1122 * iscsi_itt_to_task - look up task by itt 1123 * @conn: iscsi connection 1124 * @itt: itt 1125 * 1126 * This should be used for mgmt tasks like login and nops, or if 1127 * the LDD's itt space does not include the session age. 1128 * 1129 * The session back_lock must be held. 1130 */ 1131 struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt) 1132 { 1133 struct iscsi_session *session = conn->session; 1134 int i; 1135 1136 if (itt == RESERVED_ITT) 1137 return NULL; 1138 1139 if (session->tt->parse_pdu_itt) 1140 session->tt->parse_pdu_itt(conn, itt, &i, NULL); 1141 else 1142 i = get_itt(itt); 1143 if (i >= session->cmds_max) 1144 return NULL; 1145 1146 return session->cmds[i]; 1147 } 1148 EXPORT_SYMBOL_GPL(iscsi_itt_to_task); 1149 1150 /** 1151 * __iscsi_complete_pdu - complete pdu 1152 * @conn: iscsi conn 1153 * @hdr: iscsi header 1154 * @data: data buffer 1155 * @datalen: len of data buffer 1156 * 1157 * Completes pdu processing by freeing any resources allocated at 1158 * queuecommand or send generic. session back_lock must be held and verify 1159 * itt must have been called. 1160 */ 1161 int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 1162 char *data, int datalen) 1163 { 1164 struct iscsi_session *session = conn->session; 1165 int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0; 1166 struct iscsi_task *task; 1167 uint32_t itt; 1168 1169 conn->last_recv = jiffies; 1170 rc = iscsi_verify_itt(conn, hdr->itt); 1171 if (rc) 1172 return rc; 1173 1174 if (hdr->itt != RESERVED_ITT) 1175 itt = get_itt(hdr->itt); 1176 else 1177 itt = ~0U; 1178 1179 ISCSI_DBG_SESSION(session, "[op 0x%x cid %d itt 0x%x len %d]\n", 1180 opcode, conn->id, itt, datalen); 1181 1182 if (itt == ~0U) { 1183 iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 1184 1185 switch(opcode) { 1186 case ISCSI_OP_NOOP_IN: 1187 if (datalen) { 1188 rc = ISCSI_ERR_PROTO; 1189 break; 1190 } 1191 1192 if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) 1193 break; 1194 1195 /* In RX path we are under back lock */ 1196 spin_unlock(&session->back_lock); 1197 spin_lock(&session->frwd_lock); 1198 iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr); 1199 spin_unlock(&session->frwd_lock); 1200 spin_lock(&session->back_lock); 1201 break; 1202 case ISCSI_OP_REJECT: 1203 rc = iscsi_handle_reject(conn, hdr, data, datalen); 1204 break; 1205 case ISCSI_OP_ASYNC_EVENT: 1206 conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 1207 if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 1208 rc = ISCSI_ERR_CONN_FAILED; 1209 break; 1210 default: 1211 rc = ISCSI_ERR_BAD_OPCODE; 1212 break; 1213 } 1214 goto out; 1215 } 1216 1217 switch(opcode) { 1218 case ISCSI_OP_SCSI_CMD_RSP: 1219 case ISCSI_OP_SCSI_DATA_IN: 1220 task = iscsi_itt_to_ctask(conn, hdr->itt); 1221 if (!task) 1222 return ISCSI_ERR_BAD_ITT; 1223 task->last_xfer = jiffies; 1224 break; 1225 case ISCSI_OP_R2T: 1226 /* 1227 * LLD handles R2Ts if they need to. 1228 */ 1229 return 0; 1230 case ISCSI_OP_LOGOUT_RSP: 1231 case ISCSI_OP_LOGIN_RSP: 1232 case ISCSI_OP_TEXT_RSP: 1233 case ISCSI_OP_SCSI_TMFUNC_RSP: 1234 case ISCSI_OP_NOOP_IN: 1235 task = iscsi_itt_to_task(conn, hdr->itt); 1236 if (!task) 1237 return ISCSI_ERR_BAD_ITT; 1238 break; 1239 default: 1240 return ISCSI_ERR_BAD_OPCODE; 1241 } 1242 1243 switch(opcode) { 1244 case ISCSI_OP_SCSI_CMD_RSP: 1245 iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen); 1246 break; 1247 case ISCSI_OP_SCSI_DATA_IN: 1248 iscsi_data_in_rsp(conn, hdr, task); 1249 break; 1250 case ISCSI_OP_LOGOUT_RSP: 1251 iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 1252 if (datalen) { 1253 rc = ISCSI_ERR_PROTO; 1254 break; 1255 } 1256 conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 1257 goto recv_pdu; 1258 case ISCSI_OP_LOGIN_RSP: 1259 case ISCSI_OP_TEXT_RSP: 1260 iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 1261 /* 1262 * login related PDU's exp_statsn is handled in 1263 * userspace 1264 */ 1265 goto recv_pdu; 1266 case ISCSI_OP_SCSI_TMFUNC_RSP: 1267 iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 1268 if (datalen) { 1269 rc = ISCSI_ERR_PROTO; 1270 break; 1271 } 1272 1273 iscsi_tmf_rsp(conn, hdr); 1274 iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 1275 break; 1276 case ISCSI_OP_NOOP_IN: 1277 iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 1278 if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) { 1279 rc = ISCSI_ERR_PROTO; 1280 break; 1281 } 1282 conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 1283 1284 rc = iscsi_nop_out_rsp(task, (struct iscsi_nopin*)hdr, 1285 data, datalen); 1286 break; 1287 default: 1288 rc = ISCSI_ERR_BAD_OPCODE; 1289 break; 1290 } 1291 1292 out: 1293 return rc; 1294 recv_pdu: 1295 if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 1296 rc = ISCSI_ERR_CONN_FAILED; 1297 iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 1298 return rc; 1299 } 1300 EXPORT_SYMBOL_GPL(__iscsi_complete_pdu); 1301 1302 int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 1303 char *data, int datalen) 1304 { 1305 int rc; 1306 1307 spin_lock(&conn->session->back_lock); 1308 rc = __iscsi_complete_pdu(conn, hdr, data, datalen); 1309 spin_unlock(&conn->session->back_lock); 1310 return rc; 1311 } 1312 EXPORT_SYMBOL_GPL(iscsi_complete_pdu); 1313 1314 int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt) 1315 { 1316 struct iscsi_session *session = conn->session; 1317 int age = 0, i = 0; 1318 1319 if (itt == RESERVED_ITT) 1320 return 0; 1321 1322 if (session->tt->parse_pdu_itt) 1323 session->tt->parse_pdu_itt(conn, itt, &i, &age); 1324 else { 1325 i = get_itt(itt); 1326 age = ((__force u32)itt >> ISCSI_AGE_SHIFT) & ISCSI_AGE_MASK; 1327 } 1328 1329 if (age != session->age) { 1330 iscsi_conn_printk(KERN_ERR, conn, 1331 "received itt %x expected session age (%x)\n", 1332 (__force u32)itt, session->age); 1333 return ISCSI_ERR_BAD_ITT; 1334 } 1335 1336 if (i >= session->cmds_max) { 1337 iscsi_conn_printk(KERN_ERR, conn, 1338 "received invalid itt index %u (max cmds " 1339 "%u.\n", i, session->cmds_max); 1340 return ISCSI_ERR_BAD_ITT; 1341 } 1342 return 0; 1343 } 1344 EXPORT_SYMBOL_GPL(iscsi_verify_itt); 1345 1346 /** 1347 * iscsi_itt_to_ctask - look up ctask by itt 1348 * @conn: iscsi connection 1349 * @itt: itt 1350 * 1351 * This should be used for cmd tasks. 1352 * 1353 * The session back_lock must be held. 1354 */ 1355 struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt) 1356 { 1357 struct iscsi_task *task; 1358 1359 if (iscsi_verify_itt(conn, itt)) 1360 return NULL; 1361 1362 task = iscsi_itt_to_task(conn, itt); 1363 if (!task || !task->sc) 1364 return NULL; 1365 1366 if (task->sc->SCp.phase != conn->session->age) { 1367 iscsi_session_printk(KERN_ERR, conn->session, 1368 "task's session age %d, expected %d\n", 1369 task->sc->SCp.phase, conn->session->age); 1370 return NULL; 1371 } 1372 1373 return task; 1374 } 1375 EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask); 1376 1377 void iscsi_session_failure(struct iscsi_session *session, 1378 enum iscsi_err err) 1379 { 1380 struct iscsi_conn *conn; 1381 struct device *dev; 1382 1383 spin_lock_bh(&session->frwd_lock); 1384 conn = session->leadconn; 1385 if (session->state == ISCSI_STATE_TERMINATE || !conn) { 1386 spin_unlock_bh(&session->frwd_lock); 1387 return; 1388 } 1389 1390 dev = get_device(&conn->cls_conn->dev); 1391 spin_unlock_bh(&session->frwd_lock); 1392 if (!dev) 1393 return; 1394 /* 1395 * if the host is being removed bypass the connection 1396 * recovery initialization because we are going to kill 1397 * the session. 1398 */ 1399 if (err == ISCSI_ERR_INVALID_HOST) 1400 iscsi_conn_error_event(conn->cls_conn, err); 1401 else 1402 iscsi_conn_failure(conn, err); 1403 put_device(dev); 1404 } 1405 EXPORT_SYMBOL_GPL(iscsi_session_failure); 1406 1407 void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err) 1408 { 1409 struct iscsi_session *session = conn->session; 1410 1411 spin_lock_bh(&session->frwd_lock); 1412 if (session->state == ISCSI_STATE_FAILED) { 1413 spin_unlock_bh(&session->frwd_lock); 1414 return; 1415 } 1416 1417 if (conn->stop_stage == 0) 1418 session->state = ISCSI_STATE_FAILED; 1419 spin_unlock_bh(&session->frwd_lock); 1420 1421 set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1422 set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 1423 iscsi_conn_error_event(conn->cls_conn, err); 1424 } 1425 EXPORT_SYMBOL_GPL(iscsi_conn_failure); 1426 1427 static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn) 1428 { 1429 struct iscsi_session *session = conn->session; 1430 1431 /* 1432 * Check for iSCSI window and take care of CmdSN wrap-around 1433 */ 1434 if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) { 1435 ISCSI_DBG_SESSION(session, "iSCSI CmdSN closed. ExpCmdSn " 1436 "%u MaxCmdSN %u CmdSN %u/%u\n", 1437 session->exp_cmdsn, session->max_cmdsn, 1438 session->cmdsn, session->queued_cmdsn); 1439 return -ENOSPC; 1440 } 1441 return 0; 1442 } 1443 1444 static int iscsi_xmit_task(struct iscsi_conn *conn) 1445 { 1446 struct iscsi_task *task = conn->task; 1447 int rc; 1448 1449 if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) 1450 return -ENODATA; 1451 1452 __iscsi_get_task(task); 1453 spin_unlock_bh(&conn->session->frwd_lock); 1454 rc = conn->session->tt->xmit_task(task); 1455 spin_lock_bh(&conn->session->frwd_lock); 1456 if (!rc) { 1457 /* done with this task */ 1458 task->last_xfer = jiffies; 1459 conn->task = NULL; 1460 } 1461 /* regular RX path uses back_lock */ 1462 spin_lock(&conn->session->back_lock); 1463 __iscsi_put_task(task); 1464 spin_unlock(&conn->session->back_lock); 1465 return rc; 1466 } 1467 1468 /** 1469 * iscsi_requeue_task - requeue task to run from session workqueue 1470 * @task: task to requeue 1471 * 1472 * LLDs that need to run a task from the session workqueue should call 1473 * this. The session frwd_lock must be held. This should only be called 1474 * by software drivers. 1475 */ 1476 void iscsi_requeue_task(struct iscsi_task *task) 1477 { 1478 struct iscsi_conn *conn = task->conn; 1479 1480 /* 1481 * this may be on the requeue list already if the xmit_task callout 1482 * is handling the r2ts while we are adding new ones 1483 */ 1484 spin_lock_bh(&conn->taskqueuelock); 1485 if (list_empty(&task->running)) 1486 list_add_tail(&task->running, &conn->requeue); 1487 spin_unlock_bh(&conn->taskqueuelock); 1488 iscsi_conn_queue_work(conn); 1489 } 1490 EXPORT_SYMBOL_GPL(iscsi_requeue_task); 1491 1492 /** 1493 * iscsi_data_xmit - xmit any command into the scheduled connection 1494 * @conn: iscsi connection 1495 * 1496 * Notes: 1497 * The function can return -EAGAIN in which case the caller must 1498 * re-schedule it again later or recover. '0' return code means 1499 * successful xmit. 1500 **/ 1501 static int iscsi_data_xmit(struct iscsi_conn *conn) 1502 { 1503 struct iscsi_task *task; 1504 int rc = 0; 1505 1506 spin_lock_bh(&conn->session->frwd_lock); 1507 if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) { 1508 ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n"); 1509 spin_unlock_bh(&conn->session->frwd_lock); 1510 return -ENODATA; 1511 } 1512 1513 if (conn->task) { 1514 rc = iscsi_xmit_task(conn); 1515 if (rc) 1516 goto done; 1517 } 1518 1519 /* 1520 * process mgmt pdus like nops before commands since we should 1521 * only have one nop-out as a ping from us and targets should not 1522 * overflow us with nop-ins 1523 */ 1524 spin_lock_bh(&conn->taskqueuelock); 1525 check_mgmt: 1526 while (!list_empty(&conn->mgmtqueue)) { 1527 conn->task = list_entry(conn->mgmtqueue.next, 1528 struct iscsi_task, running); 1529 list_del_init(&conn->task->running); 1530 spin_unlock_bh(&conn->taskqueuelock); 1531 if (iscsi_prep_mgmt_task(conn, conn->task)) { 1532 /* regular RX path uses back_lock */ 1533 spin_lock_bh(&conn->session->back_lock); 1534 __iscsi_put_task(conn->task); 1535 spin_unlock_bh(&conn->session->back_lock); 1536 conn->task = NULL; 1537 spin_lock_bh(&conn->taskqueuelock); 1538 continue; 1539 } 1540 rc = iscsi_xmit_task(conn); 1541 if (rc) 1542 goto done; 1543 spin_lock_bh(&conn->taskqueuelock); 1544 } 1545 1546 /* process pending command queue */ 1547 while (!list_empty(&conn->cmdqueue)) { 1548 conn->task = list_entry(conn->cmdqueue.next, struct iscsi_task, 1549 running); 1550 list_del_init(&conn->task->running); 1551 spin_unlock_bh(&conn->taskqueuelock); 1552 if (conn->session->state == ISCSI_STATE_LOGGING_OUT) { 1553 fail_scsi_task(conn->task, DID_IMM_RETRY); 1554 spin_lock_bh(&conn->taskqueuelock); 1555 continue; 1556 } 1557 rc = iscsi_prep_scsi_cmd_pdu(conn->task); 1558 if (rc) { 1559 if (rc == -ENOMEM || rc == -EACCES) { 1560 spin_lock_bh(&conn->taskqueuelock); 1561 list_add_tail(&conn->task->running, 1562 &conn->cmdqueue); 1563 conn->task = NULL; 1564 spin_unlock_bh(&conn->taskqueuelock); 1565 goto done; 1566 } else 1567 fail_scsi_task(conn->task, DID_ABORT); 1568 spin_lock_bh(&conn->taskqueuelock); 1569 continue; 1570 } 1571 rc = iscsi_xmit_task(conn); 1572 if (rc) 1573 goto done; 1574 /* 1575 * we could continuously get new task requests so 1576 * we need to check the mgmt queue for nops that need to 1577 * be sent to aviod starvation 1578 */ 1579 spin_lock_bh(&conn->taskqueuelock); 1580 if (!list_empty(&conn->mgmtqueue)) 1581 goto check_mgmt; 1582 } 1583 1584 while (!list_empty(&conn->requeue)) { 1585 /* 1586 * we always do fastlogout - conn stop code will clean up. 1587 */ 1588 if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 1589 break; 1590 1591 task = list_entry(conn->requeue.next, struct iscsi_task, 1592 running); 1593 if (iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_DATA_OUT)) 1594 break; 1595 1596 conn->task = task; 1597 list_del_init(&conn->task->running); 1598 conn->task->state = ISCSI_TASK_RUNNING; 1599 spin_unlock_bh(&conn->taskqueuelock); 1600 rc = iscsi_xmit_task(conn); 1601 if (rc) 1602 goto done; 1603 spin_lock_bh(&conn->taskqueuelock); 1604 if (!list_empty(&conn->mgmtqueue)) 1605 goto check_mgmt; 1606 } 1607 spin_unlock_bh(&conn->taskqueuelock); 1608 spin_unlock_bh(&conn->session->frwd_lock); 1609 return -ENODATA; 1610 1611 done: 1612 spin_unlock_bh(&conn->session->frwd_lock); 1613 return rc; 1614 } 1615 1616 static void iscsi_xmitworker(struct work_struct *work) 1617 { 1618 struct iscsi_conn *conn = 1619 container_of(work, struct iscsi_conn, xmitwork); 1620 int rc; 1621 /* 1622 * serialize Xmit worker on a per-connection basis. 1623 */ 1624 do { 1625 rc = iscsi_data_xmit(conn); 1626 } while (rc >= 0 || rc == -EAGAIN); 1627 } 1628 1629 static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn, 1630 struct scsi_cmnd *sc) 1631 { 1632 struct iscsi_task *task; 1633 1634 if (!kfifo_out(&conn->session->cmdpool.queue, 1635 (void *) &task, sizeof(void *))) 1636 return NULL; 1637 1638 sc->SCp.phase = conn->session->age; 1639 sc->SCp.ptr = (char *) task; 1640 1641 refcount_set(&task->refcount, 1); 1642 task->state = ISCSI_TASK_PENDING; 1643 task->conn = conn; 1644 task->sc = sc; 1645 task->have_checked_conn = false; 1646 task->last_timeout = jiffies; 1647 task->last_xfer = jiffies; 1648 task->protected = false; 1649 INIT_LIST_HEAD(&task->running); 1650 return task; 1651 } 1652 1653 enum { 1654 FAILURE_BAD_HOST = 1, 1655 FAILURE_SESSION_FAILED, 1656 FAILURE_SESSION_FREED, 1657 FAILURE_WINDOW_CLOSED, 1658 FAILURE_OOM, 1659 FAILURE_SESSION_TERMINATE, 1660 FAILURE_SESSION_IN_RECOVERY, 1661 FAILURE_SESSION_RECOVERY_TIMEOUT, 1662 FAILURE_SESSION_LOGGING_OUT, 1663 FAILURE_SESSION_NOT_READY, 1664 }; 1665 1666 int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc) 1667 { 1668 struct iscsi_cls_session *cls_session; 1669 struct iscsi_host *ihost; 1670 int reason = 0; 1671 struct iscsi_session *session; 1672 struct iscsi_conn *conn; 1673 struct iscsi_task *task = NULL; 1674 1675 sc->result = 0; 1676 sc->SCp.ptr = NULL; 1677 1678 ihost = shost_priv(host); 1679 1680 cls_session = starget_to_session(scsi_target(sc->device)); 1681 session = cls_session->dd_data; 1682 spin_lock_bh(&session->frwd_lock); 1683 1684 reason = iscsi_session_chkready(cls_session); 1685 if (reason) { 1686 sc->result = reason; 1687 goto fault; 1688 } 1689 1690 if (session->state != ISCSI_STATE_LOGGED_IN) { 1691 /* 1692 * to handle the race between when we set the recovery state 1693 * and block the session we requeue here (commands could 1694 * be entering our queuecommand while a block is starting 1695 * up because the block code is not locked) 1696 */ 1697 switch (session->state) { 1698 case ISCSI_STATE_FAILED: 1699 case ISCSI_STATE_IN_RECOVERY: 1700 reason = FAILURE_SESSION_IN_RECOVERY; 1701 sc->result = DID_IMM_RETRY << 16; 1702 break; 1703 case ISCSI_STATE_LOGGING_OUT: 1704 reason = FAILURE_SESSION_LOGGING_OUT; 1705 sc->result = DID_IMM_RETRY << 16; 1706 break; 1707 case ISCSI_STATE_RECOVERY_FAILED: 1708 reason = FAILURE_SESSION_RECOVERY_TIMEOUT; 1709 sc->result = DID_TRANSPORT_FAILFAST << 16; 1710 break; 1711 case ISCSI_STATE_TERMINATE: 1712 reason = FAILURE_SESSION_TERMINATE; 1713 sc->result = DID_NO_CONNECT << 16; 1714 break; 1715 default: 1716 reason = FAILURE_SESSION_FREED; 1717 sc->result = DID_NO_CONNECT << 16; 1718 } 1719 goto fault; 1720 } 1721 1722 conn = session->leadconn; 1723 if (!conn) { 1724 reason = FAILURE_SESSION_FREED; 1725 sc->result = DID_NO_CONNECT << 16; 1726 goto fault; 1727 } 1728 1729 if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) { 1730 reason = FAILURE_SESSION_IN_RECOVERY; 1731 sc->result = DID_REQUEUE; 1732 goto fault; 1733 } 1734 1735 if (iscsi_check_cmdsn_window_closed(conn)) { 1736 reason = FAILURE_WINDOW_CLOSED; 1737 goto reject; 1738 } 1739 1740 task = iscsi_alloc_task(conn, sc); 1741 if (!task) { 1742 reason = FAILURE_OOM; 1743 goto reject; 1744 } 1745 1746 if (!ihost->workq) { 1747 reason = iscsi_prep_scsi_cmd_pdu(task); 1748 if (reason) { 1749 if (reason == -ENOMEM || reason == -EACCES) { 1750 reason = FAILURE_OOM; 1751 goto prepd_reject; 1752 } else { 1753 sc->result = DID_ABORT << 16; 1754 goto prepd_fault; 1755 } 1756 } 1757 if (session->tt->xmit_task(task)) { 1758 session->cmdsn--; 1759 reason = FAILURE_SESSION_NOT_READY; 1760 goto prepd_reject; 1761 } 1762 } else { 1763 spin_lock_bh(&conn->taskqueuelock); 1764 list_add_tail(&task->running, &conn->cmdqueue); 1765 spin_unlock_bh(&conn->taskqueuelock); 1766 iscsi_conn_queue_work(conn); 1767 } 1768 1769 session->queued_cmdsn++; 1770 spin_unlock_bh(&session->frwd_lock); 1771 return 0; 1772 1773 prepd_reject: 1774 iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 1775 reject: 1776 spin_unlock_bh(&session->frwd_lock); 1777 ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n", 1778 sc->cmnd[0], reason); 1779 return SCSI_MLQUEUE_TARGET_BUSY; 1780 1781 prepd_fault: 1782 iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 1783 fault: 1784 spin_unlock_bh(&session->frwd_lock); 1785 ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n", 1786 sc->cmnd[0], reason); 1787 if (!scsi_bidi_cmnd(sc)) 1788 scsi_set_resid(sc, scsi_bufflen(sc)); 1789 else { 1790 scsi_out(sc)->resid = scsi_out(sc)->length; 1791 scsi_in(sc)->resid = scsi_in(sc)->length; 1792 } 1793 sc->scsi_done(sc); 1794 return 0; 1795 } 1796 EXPORT_SYMBOL_GPL(iscsi_queuecommand); 1797 1798 int iscsi_target_alloc(struct scsi_target *starget) 1799 { 1800 struct iscsi_cls_session *cls_session = starget_to_session(starget); 1801 struct iscsi_session *session = cls_session->dd_data; 1802 1803 starget->can_queue = session->scsi_cmds_max; 1804 return 0; 1805 } 1806 EXPORT_SYMBOL_GPL(iscsi_target_alloc); 1807 1808 static void iscsi_tmf_timedout(unsigned long data) 1809 { 1810 struct iscsi_conn *conn = (struct iscsi_conn *)data; 1811 struct iscsi_session *session = conn->session; 1812 1813 spin_lock(&session->frwd_lock); 1814 if (conn->tmf_state == TMF_QUEUED) { 1815 conn->tmf_state = TMF_TIMEDOUT; 1816 ISCSI_DBG_EH(session, "tmf timedout\n"); 1817 /* unblock eh_abort() */ 1818 wake_up(&conn->ehwait); 1819 } 1820 spin_unlock(&session->frwd_lock); 1821 } 1822 1823 static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, 1824 struct iscsi_tm *hdr, int age, 1825 int timeout) 1826 { 1827 struct iscsi_session *session = conn->session; 1828 struct iscsi_task *task; 1829 1830 task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr, 1831 NULL, 0); 1832 if (!task) { 1833 spin_unlock_bh(&session->frwd_lock); 1834 iscsi_conn_printk(KERN_ERR, conn, "Could not send TMF.\n"); 1835 iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1836 spin_lock_bh(&session->frwd_lock); 1837 return -EPERM; 1838 } 1839 conn->tmfcmd_pdus_cnt++; 1840 conn->tmf_timer.expires = timeout * HZ + jiffies; 1841 conn->tmf_timer.function = iscsi_tmf_timedout; 1842 conn->tmf_timer.data = (unsigned long)conn; 1843 add_timer(&conn->tmf_timer); 1844 ISCSI_DBG_EH(session, "tmf set timeout\n"); 1845 1846 spin_unlock_bh(&session->frwd_lock); 1847 mutex_unlock(&session->eh_mutex); 1848 1849 /* 1850 * block eh thread until: 1851 * 1852 * 1) tmf response 1853 * 2) tmf timeout 1854 * 3) session is terminated or restarted or userspace has 1855 * given up on recovery 1856 */ 1857 wait_event_interruptible(conn->ehwait, age != session->age || 1858 session->state != ISCSI_STATE_LOGGED_IN || 1859 conn->tmf_state != TMF_QUEUED); 1860 if (signal_pending(current)) 1861 flush_signals(current); 1862 del_timer_sync(&conn->tmf_timer); 1863 1864 mutex_lock(&session->eh_mutex); 1865 spin_lock_bh(&session->frwd_lock); 1866 /* if the session drops it will clean up the task */ 1867 if (age != session->age || 1868 session->state != ISCSI_STATE_LOGGED_IN) 1869 return -ENOTCONN; 1870 return 0; 1871 } 1872 1873 /* 1874 * Fail commands. session lock held and recv side suspended and xmit 1875 * thread flushed 1876 */ 1877 static void fail_scsi_tasks(struct iscsi_conn *conn, u64 lun, int error) 1878 { 1879 struct iscsi_task *task; 1880 int i; 1881 1882 for (i = 0; i < conn->session->cmds_max; i++) { 1883 task = conn->session->cmds[i]; 1884 if (!task->sc || task->state == ISCSI_TASK_FREE) 1885 continue; 1886 1887 if (lun != -1 && lun != task->sc->device->lun) 1888 continue; 1889 1890 ISCSI_DBG_SESSION(conn->session, 1891 "failing sc %p itt 0x%x state %d\n", 1892 task->sc, task->itt, task->state); 1893 fail_scsi_task(task, error); 1894 } 1895 } 1896 1897 /** 1898 * iscsi_suspend_queue - suspend iscsi_queuecommand 1899 * @conn: iscsi conn to stop queueing IO on 1900 * 1901 * This grabs the session frwd_lock to make sure no one is in 1902 * xmit_task/queuecommand, and then sets suspend to prevent 1903 * new commands from being queued. This only needs to be called 1904 * by offload drivers that need to sync a path like ep disconnect 1905 * with the iscsi_queuecommand/xmit_task. To start IO again libiscsi 1906 * will call iscsi_start_tx and iscsi_unblock_session when in FFP. 1907 */ 1908 void iscsi_suspend_queue(struct iscsi_conn *conn) 1909 { 1910 spin_lock_bh(&conn->session->frwd_lock); 1911 set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1912 spin_unlock_bh(&conn->session->frwd_lock); 1913 } 1914 EXPORT_SYMBOL_GPL(iscsi_suspend_queue); 1915 1916 /** 1917 * iscsi_suspend_tx - suspend iscsi_data_xmit 1918 * @conn: iscsi conn tp stop processing IO on. 1919 * 1920 * This function sets the suspend bit to prevent iscsi_data_xmit 1921 * from sending new IO, and if work is queued on the xmit thread 1922 * it will wait for it to be completed. 1923 */ 1924 void iscsi_suspend_tx(struct iscsi_conn *conn) 1925 { 1926 struct Scsi_Host *shost = conn->session->host; 1927 struct iscsi_host *ihost = shost_priv(shost); 1928 1929 set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1930 if (ihost->workq) 1931 flush_workqueue(ihost->workq); 1932 } 1933 EXPORT_SYMBOL_GPL(iscsi_suspend_tx); 1934 1935 static void iscsi_start_tx(struct iscsi_conn *conn) 1936 { 1937 clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1938 iscsi_conn_queue_work(conn); 1939 } 1940 1941 /* 1942 * We want to make sure a ping is in flight. It has timed out. 1943 * And we are not busy processing a pdu that is making 1944 * progress but got started before the ping and is taking a while 1945 * to complete so the ping is just stuck behind it in a queue. 1946 */ 1947 static int iscsi_has_ping_timed_out(struct iscsi_conn *conn) 1948 { 1949 if (conn->ping_task && 1950 time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) + 1951 (conn->ping_timeout * HZ), jiffies)) 1952 return 1; 1953 else 1954 return 0; 1955 } 1956 1957 enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc) 1958 { 1959 enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED; 1960 struct iscsi_task *task = NULL, *running_task; 1961 struct iscsi_cls_session *cls_session; 1962 struct iscsi_session *session; 1963 struct iscsi_conn *conn; 1964 int i; 1965 1966 cls_session = starget_to_session(scsi_target(sc->device)); 1967 session = cls_session->dd_data; 1968 1969 ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc); 1970 1971 spin_lock(&session->frwd_lock); 1972 task = (struct iscsi_task *)sc->SCp.ptr; 1973 if (!task) { 1974 /* 1975 * Raced with completion. Blk layer has taken ownership 1976 * so let timeout code complete it now. 1977 */ 1978 rc = BLK_EH_HANDLED; 1979 goto done; 1980 } 1981 1982 if (session->state != ISCSI_STATE_LOGGED_IN) { 1983 /* 1984 * We are probably in the middle of iscsi recovery so let 1985 * that complete and handle the error. 1986 */ 1987 rc = BLK_EH_RESET_TIMER; 1988 goto done; 1989 } 1990 1991 conn = session->leadconn; 1992 if (!conn) { 1993 /* In the middle of shuting down */ 1994 rc = BLK_EH_RESET_TIMER; 1995 goto done; 1996 } 1997 1998 /* 1999 * If we have sent (at least queued to the network layer) a pdu or 2000 * recvd one for the task since the last timeout ask for 2001 * more time. If on the next timeout we have not made progress 2002 * we can check if it is the task or connection when we send the 2003 * nop as a ping. 2004 */ 2005 if (time_after(task->last_xfer, task->last_timeout)) { 2006 ISCSI_DBG_EH(session, "Command making progress. Asking " 2007 "scsi-ml for more time to complete. " 2008 "Last data xfer at %lu. Last timeout was at " 2009 "%lu\n.", task->last_xfer, task->last_timeout); 2010 task->have_checked_conn = false; 2011 rc = BLK_EH_RESET_TIMER; 2012 goto done; 2013 } 2014 2015 if (!conn->recv_timeout && !conn->ping_timeout) 2016 goto done; 2017 /* 2018 * if the ping timedout then we are in the middle of cleaning up 2019 * and can let the iscsi eh handle it 2020 */ 2021 if (iscsi_has_ping_timed_out(conn)) { 2022 rc = BLK_EH_RESET_TIMER; 2023 goto done; 2024 } 2025 2026 for (i = 0; i < conn->session->cmds_max; i++) { 2027 running_task = conn->session->cmds[i]; 2028 if (!running_task->sc || running_task == task || 2029 running_task->state != ISCSI_TASK_RUNNING) 2030 continue; 2031 2032 /* 2033 * Only check if cmds started before this one have made 2034 * progress, or this could never fail 2035 */ 2036 if (time_after(running_task->sc->jiffies_at_alloc, 2037 task->sc->jiffies_at_alloc)) 2038 continue; 2039 2040 if (time_after(running_task->last_xfer, task->last_timeout)) { 2041 /* 2042 * This task has not made progress, but a task 2043 * started before us has transferred data since 2044 * we started/last-checked. We could be queueing 2045 * too many tasks or the LU is bad. 2046 * 2047 * If the device is bad the cmds ahead of us on 2048 * other devs will complete, and this loop will 2049 * eventually fail starting the scsi eh. 2050 */ 2051 ISCSI_DBG_EH(session, "Command has not made progress " 2052 "but commands ahead of it have. " 2053 "Asking scsi-ml for more time to " 2054 "complete. Our last xfer vs running task " 2055 "last xfer %lu/%lu. Last check %lu.\n", 2056 task->last_xfer, running_task->last_xfer, 2057 task->last_timeout); 2058 rc = BLK_EH_RESET_TIMER; 2059 goto done; 2060 } 2061 } 2062 2063 /* Assumes nop timeout is shorter than scsi cmd timeout */ 2064 if (task->have_checked_conn) 2065 goto done; 2066 2067 /* 2068 * Checking the transport already or nop from a cmd timeout still 2069 * running 2070 */ 2071 if (conn->ping_task) { 2072 task->have_checked_conn = true; 2073 rc = BLK_EH_RESET_TIMER; 2074 goto done; 2075 } 2076 2077 /* Make sure there is a transport check done */ 2078 iscsi_send_nopout(conn, NULL); 2079 task->have_checked_conn = true; 2080 rc = BLK_EH_RESET_TIMER; 2081 2082 done: 2083 if (task) 2084 task->last_timeout = jiffies; 2085 spin_unlock(&session->frwd_lock); 2086 ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ? 2087 "timer reset" : "nh"); 2088 return rc; 2089 } 2090 EXPORT_SYMBOL_GPL(iscsi_eh_cmd_timed_out); 2091 2092 static void iscsi_check_transport_timeouts(unsigned long data) 2093 { 2094 struct iscsi_conn *conn = (struct iscsi_conn *)data; 2095 struct iscsi_session *session = conn->session; 2096 unsigned long recv_timeout, next_timeout = 0, last_recv; 2097 2098 spin_lock(&session->frwd_lock); 2099 if (session->state != ISCSI_STATE_LOGGED_IN) 2100 goto done; 2101 2102 recv_timeout = conn->recv_timeout; 2103 if (!recv_timeout) 2104 goto done; 2105 2106 recv_timeout *= HZ; 2107 last_recv = conn->last_recv; 2108 2109 if (iscsi_has_ping_timed_out(conn)) { 2110 iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs " 2111 "expired, recv timeout %d, last rx %lu, " 2112 "last ping %lu, now %lu\n", 2113 conn->ping_timeout, conn->recv_timeout, 2114 last_recv, conn->last_ping, jiffies); 2115 spin_unlock(&session->frwd_lock); 2116 iscsi_conn_failure(conn, ISCSI_ERR_NOP_TIMEDOUT); 2117 return; 2118 } 2119 2120 if (time_before_eq(last_recv + recv_timeout, jiffies)) { 2121 /* send a ping to try to provoke some traffic */ 2122 ISCSI_DBG_CONN(conn, "Sending nopout as ping\n"); 2123 if (iscsi_send_nopout(conn, NULL)) 2124 next_timeout = jiffies + (1 * HZ); 2125 else 2126 next_timeout = conn->last_ping + (conn->ping_timeout * HZ); 2127 } else 2128 next_timeout = last_recv + recv_timeout; 2129 2130 ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout); 2131 mod_timer(&conn->transport_timer, next_timeout); 2132 done: 2133 spin_unlock(&session->frwd_lock); 2134 } 2135 2136 static void iscsi_prep_abort_task_pdu(struct iscsi_task *task, 2137 struct iscsi_tm *hdr) 2138 { 2139 memset(hdr, 0, sizeof(*hdr)); 2140 hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2141 hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK; 2142 hdr->flags |= ISCSI_FLAG_CMD_FINAL; 2143 hdr->lun = task->lun; 2144 hdr->rtt = task->hdr_itt; 2145 hdr->refcmdsn = task->cmdsn; 2146 } 2147 2148 int iscsi_eh_abort(struct scsi_cmnd *sc) 2149 { 2150 struct iscsi_cls_session *cls_session; 2151 struct iscsi_session *session; 2152 struct iscsi_conn *conn; 2153 struct iscsi_task *task; 2154 struct iscsi_tm *hdr; 2155 int age; 2156 2157 cls_session = starget_to_session(scsi_target(sc->device)); 2158 session = cls_session->dd_data; 2159 2160 ISCSI_DBG_EH(session, "aborting sc %p\n", sc); 2161 2162 mutex_lock(&session->eh_mutex); 2163 spin_lock_bh(&session->frwd_lock); 2164 /* 2165 * if session was ISCSI_STATE_IN_RECOVERY then we may not have 2166 * got the command. 2167 */ 2168 if (!sc->SCp.ptr) { 2169 ISCSI_DBG_EH(session, "sc never reached iscsi layer or " 2170 "it completed.\n"); 2171 spin_unlock_bh(&session->frwd_lock); 2172 mutex_unlock(&session->eh_mutex); 2173 return SUCCESS; 2174 } 2175 2176 /* 2177 * If we are not logged in or we have started a new session 2178 * then let the host reset code handle this 2179 */ 2180 if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN || 2181 sc->SCp.phase != session->age) { 2182 spin_unlock_bh(&session->frwd_lock); 2183 mutex_unlock(&session->eh_mutex); 2184 ISCSI_DBG_EH(session, "failing abort due to dropped " 2185 "session.\n"); 2186 return FAILED; 2187 } 2188 2189 conn = session->leadconn; 2190 conn->eh_abort_cnt++; 2191 age = session->age; 2192 2193 task = (struct iscsi_task *)sc->SCp.ptr; 2194 ISCSI_DBG_EH(session, "aborting [sc %p itt 0x%x]\n", 2195 sc, task->itt); 2196 2197 /* task completed before time out */ 2198 if (!task->sc) { 2199 ISCSI_DBG_EH(session, "sc completed while abort in progress\n"); 2200 goto success; 2201 } 2202 2203 if (task->state == ISCSI_TASK_PENDING) { 2204 fail_scsi_task(task, DID_ABORT); 2205 goto success; 2206 } 2207 2208 /* only have one tmf outstanding at a time */ 2209 if (conn->tmf_state != TMF_INITIAL) 2210 goto failed; 2211 conn->tmf_state = TMF_QUEUED; 2212 2213 hdr = &conn->tmhdr; 2214 iscsi_prep_abort_task_pdu(task, hdr); 2215 2216 if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) 2217 goto failed; 2218 2219 switch (conn->tmf_state) { 2220 case TMF_SUCCESS: 2221 spin_unlock_bh(&session->frwd_lock); 2222 /* 2223 * stop tx side incase the target had sent a abort rsp but 2224 * the initiator was still writing out data. 2225 */ 2226 iscsi_suspend_tx(conn); 2227 /* 2228 * we do not stop the recv side because targets have been 2229 * good and have never sent us a successful tmf response 2230 * then sent more data for the cmd. 2231 */ 2232 spin_lock_bh(&session->frwd_lock); 2233 fail_scsi_task(task, DID_ABORT); 2234 conn->tmf_state = TMF_INITIAL; 2235 memset(hdr, 0, sizeof(*hdr)); 2236 spin_unlock_bh(&session->frwd_lock); 2237 iscsi_start_tx(conn); 2238 goto success_unlocked; 2239 case TMF_TIMEDOUT: 2240 spin_unlock_bh(&session->frwd_lock); 2241 iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2242 goto failed_unlocked; 2243 case TMF_NOT_FOUND: 2244 if (!sc->SCp.ptr) { 2245 conn->tmf_state = TMF_INITIAL; 2246 memset(hdr, 0, sizeof(*hdr)); 2247 /* task completed before tmf abort response */ 2248 ISCSI_DBG_EH(session, "sc completed while abort in " 2249 "progress\n"); 2250 goto success; 2251 } 2252 /* fall through */ 2253 default: 2254 conn->tmf_state = TMF_INITIAL; 2255 goto failed; 2256 } 2257 2258 success: 2259 spin_unlock_bh(&session->frwd_lock); 2260 success_unlocked: 2261 ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n", 2262 sc, task->itt); 2263 mutex_unlock(&session->eh_mutex); 2264 return SUCCESS; 2265 2266 failed: 2267 spin_unlock_bh(&session->frwd_lock); 2268 failed_unlocked: 2269 ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc, 2270 task ? task->itt : 0); 2271 mutex_unlock(&session->eh_mutex); 2272 return FAILED; 2273 } 2274 EXPORT_SYMBOL_GPL(iscsi_eh_abort); 2275 2276 static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 2277 { 2278 memset(hdr, 0, sizeof(*hdr)); 2279 hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2280 hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK; 2281 hdr->flags |= ISCSI_FLAG_CMD_FINAL; 2282 int_to_scsilun(sc->device->lun, &hdr->lun); 2283 hdr->rtt = RESERVED_ITT; 2284 } 2285 2286 int iscsi_eh_device_reset(struct scsi_cmnd *sc) 2287 { 2288 struct iscsi_cls_session *cls_session; 2289 struct iscsi_session *session; 2290 struct iscsi_conn *conn; 2291 struct iscsi_tm *hdr; 2292 int rc = FAILED; 2293 2294 cls_session = starget_to_session(scsi_target(sc->device)); 2295 session = cls_session->dd_data; 2296 2297 ISCSI_DBG_EH(session, "LU Reset [sc %p lun %llu]\n", sc, 2298 sc->device->lun); 2299 2300 mutex_lock(&session->eh_mutex); 2301 spin_lock_bh(&session->frwd_lock); 2302 /* 2303 * Just check if we are not logged in. We cannot check for 2304 * the phase because the reset could come from a ioctl. 2305 */ 2306 if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 2307 goto unlock; 2308 conn = session->leadconn; 2309 2310 /* only have one tmf outstanding at a time */ 2311 if (conn->tmf_state != TMF_INITIAL) 2312 goto unlock; 2313 conn->tmf_state = TMF_QUEUED; 2314 2315 hdr = &conn->tmhdr; 2316 iscsi_prep_lun_reset_pdu(sc, hdr); 2317 2318 if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 2319 session->lu_reset_timeout)) { 2320 rc = FAILED; 2321 goto unlock; 2322 } 2323 2324 switch (conn->tmf_state) { 2325 case TMF_SUCCESS: 2326 break; 2327 case TMF_TIMEDOUT: 2328 spin_unlock_bh(&session->frwd_lock); 2329 iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2330 goto done; 2331 default: 2332 conn->tmf_state = TMF_INITIAL; 2333 goto unlock; 2334 } 2335 2336 rc = SUCCESS; 2337 spin_unlock_bh(&session->frwd_lock); 2338 2339 iscsi_suspend_tx(conn); 2340 2341 spin_lock_bh(&session->frwd_lock); 2342 memset(hdr, 0, sizeof(*hdr)); 2343 fail_scsi_tasks(conn, sc->device->lun, DID_ERROR); 2344 conn->tmf_state = TMF_INITIAL; 2345 spin_unlock_bh(&session->frwd_lock); 2346 2347 iscsi_start_tx(conn); 2348 goto done; 2349 2350 unlock: 2351 spin_unlock_bh(&session->frwd_lock); 2352 done: 2353 ISCSI_DBG_EH(session, "dev reset result = %s\n", 2354 rc == SUCCESS ? "SUCCESS" : "FAILED"); 2355 mutex_unlock(&session->eh_mutex); 2356 return rc; 2357 } 2358 EXPORT_SYMBOL_GPL(iscsi_eh_device_reset); 2359 2360 void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) 2361 { 2362 struct iscsi_session *session = cls_session->dd_data; 2363 2364 spin_lock_bh(&session->frwd_lock); 2365 if (session->state != ISCSI_STATE_LOGGED_IN) { 2366 session->state = ISCSI_STATE_RECOVERY_FAILED; 2367 if (session->leadconn) 2368 wake_up(&session->leadconn->ehwait); 2369 } 2370 spin_unlock_bh(&session->frwd_lock); 2371 } 2372 EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout); 2373 2374 /** 2375 * iscsi_eh_session_reset - drop session and attempt relogin 2376 * @sc: scsi command 2377 * 2378 * This function will wait for a relogin, session termination from 2379 * userspace, or a recovery/replacement timeout. 2380 */ 2381 int iscsi_eh_session_reset(struct scsi_cmnd *sc) 2382 { 2383 struct iscsi_cls_session *cls_session; 2384 struct iscsi_session *session; 2385 struct iscsi_conn *conn; 2386 2387 cls_session = starget_to_session(scsi_target(sc->device)); 2388 session = cls_session->dd_data; 2389 conn = session->leadconn; 2390 2391 mutex_lock(&session->eh_mutex); 2392 spin_lock_bh(&session->frwd_lock); 2393 if (session->state == ISCSI_STATE_TERMINATE) { 2394 failed: 2395 ISCSI_DBG_EH(session, 2396 "failing session reset: Could not log back into " 2397 "%s, %s [age %d]\n", session->targetname, 2398 conn->persistent_address, session->age); 2399 spin_unlock_bh(&session->frwd_lock); 2400 mutex_unlock(&session->eh_mutex); 2401 return FAILED; 2402 } 2403 2404 spin_unlock_bh(&session->frwd_lock); 2405 mutex_unlock(&session->eh_mutex); 2406 /* 2407 * we drop the lock here but the leadconn cannot be destoyed while 2408 * we are in the scsi eh 2409 */ 2410 iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2411 2412 ISCSI_DBG_EH(session, "wait for relogin\n"); 2413 wait_event_interruptible(conn->ehwait, 2414 session->state == ISCSI_STATE_TERMINATE || 2415 session->state == ISCSI_STATE_LOGGED_IN || 2416 session->state == ISCSI_STATE_RECOVERY_FAILED); 2417 if (signal_pending(current)) 2418 flush_signals(current); 2419 2420 mutex_lock(&session->eh_mutex); 2421 spin_lock_bh(&session->frwd_lock); 2422 if (session->state == ISCSI_STATE_LOGGED_IN) { 2423 ISCSI_DBG_EH(session, 2424 "session reset succeeded for %s,%s\n", 2425 session->targetname, conn->persistent_address); 2426 } else 2427 goto failed; 2428 spin_unlock_bh(&session->frwd_lock); 2429 mutex_unlock(&session->eh_mutex); 2430 return SUCCESS; 2431 } 2432 EXPORT_SYMBOL_GPL(iscsi_eh_session_reset); 2433 2434 static void iscsi_prep_tgt_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 2435 { 2436 memset(hdr, 0, sizeof(*hdr)); 2437 hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2438 hdr->flags = ISCSI_TM_FUNC_TARGET_WARM_RESET & ISCSI_FLAG_TM_FUNC_MASK; 2439 hdr->flags |= ISCSI_FLAG_CMD_FINAL; 2440 hdr->rtt = RESERVED_ITT; 2441 } 2442 2443 /** 2444 * iscsi_eh_target_reset - reset target 2445 * @sc: scsi command 2446 * 2447 * This will attempt to send a warm target reset. 2448 */ 2449 static int iscsi_eh_target_reset(struct scsi_cmnd *sc) 2450 { 2451 struct iscsi_cls_session *cls_session; 2452 struct iscsi_session *session; 2453 struct iscsi_conn *conn; 2454 struct iscsi_tm *hdr; 2455 int rc = FAILED; 2456 2457 cls_session = starget_to_session(scsi_target(sc->device)); 2458 session = cls_session->dd_data; 2459 2460 ISCSI_DBG_EH(session, "tgt Reset [sc %p tgt %s]\n", sc, 2461 session->targetname); 2462 2463 mutex_lock(&session->eh_mutex); 2464 spin_lock_bh(&session->frwd_lock); 2465 /* 2466 * Just check if we are not logged in. We cannot check for 2467 * the phase because the reset could come from a ioctl. 2468 */ 2469 if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 2470 goto unlock; 2471 conn = session->leadconn; 2472 2473 /* only have one tmf outstanding at a time */ 2474 if (conn->tmf_state != TMF_INITIAL) 2475 goto unlock; 2476 conn->tmf_state = TMF_QUEUED; 2477 2478 hdr = &conn->tmhdr; 2479 iscsi_prep_tgt_reset_pdu(sc, hdr); 2480 2481 if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 2482 session->tgt_reset_timeout)) { 2483 rc = FAILED; 2484 goto unlock; 2485 } 2486 2487 switch (conn->tmf_state) { 2488 case TMF_SUCCESS: 2489 break; 2490 case TMF_TIMEDOUT: 2491 spin_unlock_bh(&session->frwd_lock); 2492 iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2493 goto done; 2494 default: 2495 conn->tmf_state = TMF_INITIAL; 2496 goto unlock; 2497 } 2498 2499 rc = SUCCESS; 2500 spin_unlock_bh(&session->frwd_lock); 2501 2502 iscsi_suspend_tx(conn); 2503 2504 spin_lock_bh(&session->frwd_lock); 2505 memset(hdr, 0, sizeof(*hdr)); 2506 fail_scsi_tasks(conn, -1, DID_ERROR); 2507 conn->tmf_state = TMF_INITIAL; 2508 spin_unlock_bh(&session->frwd_lock); 2509 2510 iscsi_start_tx(conn); 2511 goto done; 2512 2513 unlock: 2514 spin_unlock_bh(&session->frwd_lock); 2515 done: 2516 ISCSI_DBG_EH(session, "tgt %s reset result = %s\n", session->targetname, 2517 rc == SUCCESS ? "SUCCESS" : "FAILED"); 2518 mutex_unlock(&session->eh_mutex); 2519 return rc; 2520 } 2521 2522 /** 2523 * iscsi_eh_recover_target - reset target and possibly the session 2524 * @sc: scsi command 2525 * 2526 * This will attempt to send a warm target reset. If that fails, 2527 * we will escalate to ERL0 session recovery. 2528 */ 2529 int iscsi_eh_recover_target(struct scsi_cmnd *sc) 2530 { 2531 int rc; 2532 2533 rc = iscsi_eh_target_reset(sc); 2534 if (rc == FAILED) 2535 rc = iscsi_eh_session_reset(sc); 2536 return rc; 2537 } 2538 EXPORT_SYMBOL_GPL(iscsi_eh_recover_target); 2539 2540 /* 2541 * Pre-allocate a pool of @max items of @item_size. By default, the pool 2542 * should be accessed via kfifo_{get,put} on q->queue. 2543 * Optionally, the caller can obtain the array of object pointers 2544 * by passing in a non-NULL @items pointer 2545 */ 2546 int 2547 iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size) 2548 { 2549 int i, num_arrays = 1; 2550 2551 memset(q, 0, sizeof(*q)); 2552 2553 q->max = max; 2554 2555 /* If the user passed an items pointer, he wants a copy of 2556 * the array. */ 2557 if (items) 2558 num_arrays++; 2559 q->pool = kzalloc(num_arrays * max * sizeof(void*), GFP_KERNEL); 2560 if (q->pool == NULL) 2561 return -ENOMEM; 2562 2563 kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*)); 2564 2565 for (i = 0; i < max; i++) { 2566 q->pool[i] = kzalloc(item_size, GFP_KERNEL); 2567 if (q->pool[i] == NULL) { 2568 q->max = i; 2569 goto enomem; 2570 } 2571 kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*)); 2572 } 2573 2574 if (items) { 2575 *items = q->pool + max; 2576 memcpy(*items, q->pool, max * sizeof(void *)); 2577 } 2578 2579 return 0; 2580 2581 enomem: 2582 iscsi_pool_free(q); 2583 return -ENOMEM; 2584 } 2585 EXPORT_SYMBOL_GPL(iscsi_pool_init); 2586 2587 void iscsi_pool_free(struct iscsi_pool *q) 2588 { 2589 int i; 2590 2591 for (i = 0; i < q->max; i++) 2592 kfree(q->pool[i]); 2593 kfree(q->pool); 2594 } 2595 EXPORT_SYMBOL_GPL(iscsi_pool_free); 2596 2597 /** 2598 * iscsi_host_add - add host to system 2599 * @shost: scsi host 2600 * @pdev: parent device 2601 * 2602 * This should be called by partial offload and software iscsi drivers 2603 * to add a host to the system. 2604 */ 2605 int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev) 2606 { 2607 if (!shost->can_queue) 2608 shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX; 2609 2610 if (!shost->cmd_per_lun) 2611 shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN; 2612 2613 return scsi_add_host(shost, pdev); 2614 } 2615 EXPORT_SYMBOL_GPL(iscsi_host_add); 2616 2617 /** 2618 * iscsi_host_alloc - allocate a host and driver data 2619 * @sht: scsi host template 2620 * @dd_data_size: driver host data size 2621 * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue 2622 * 2623 * This should be called by partial offload and software iscsi drivers. 2624 * To access the driver specific memory use the iscsi_host_priv() macro. 2625 */ 2626 struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht, 2627 int dd_data_size, bool xmit_can_sleep) 2628 { 2629 struct Scsi_Host *shost; 2630 struct iscsi_host *ihost; 2631 2632 shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size); 2633 if (!shost) 2634 return NULL; 2635 ihost = shost_priv(shost); 2636 2637 if (xmit_can_sleep) { 2638 snprintf(ihost->workq_name, sizeof(ihost->workq_name), 2639 "iscsi_q_%d", shost->host_no); 2640 ihost->workq = create_singlethread_workqueue(ihost->workq_name); 2641 if (!ihost->workq) 2642 goto free_host; 2643 } 2644 2645 spin_lock_init(&ihost->lock); 2646 ihost->state = ISCSI_HOST_SETUP; 2647 ihost->num_sessions = 0; 2648 init_waitqueue_head(&ihost->session_removal_wq); 2649 return shost; 2650 2651 free_host: 2652 scsi_host_put(shost); 2653 return NULL; 2654 } 2655 EXPORT_SYMBOL_GPL(iscsi_host_alloc); 2656 2657 static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session) 2658 { 2659 iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST); 2660 } 2661 2662 /** 2663 * iscsi_host_remove - remove host and sessions 2664 * @shost: scsi host 2665 * 2666 * If there are any sessions left, this will initiate the removal and wait 2667 * for the completion. 2668 */ 2669 void iscsi_host_remove(struct Scsi_Host *shost) 2670 { 2671 struct iscsi_host *ihost = shost_priv(shost); 2672 unsigned long flags; 2673 2674 spin_lock_irqsave(&ihost->lock, flags); 2675 ihost->state = ISCSI_HOST_REMOVED; 2676 spin_unlock_irqrestore(&ihost->lock, flags); 2677 2678 iscsi_host_for_each_session(shost, iscsi_notify_host_removed); 2679 wait_event_interruptible(ihost->session_removal_wq, 2680 ihost->num_sessions == 0); 2681 if (signal_pending(current)) 2682 flush_signals(current); 2683 2684 scsi_remove_host(shost); 2685 if (ihost->workq) 2686 destroy_workqueue(ihost->workq); 2687 } 2688 EXPORT_SYMBOL_GPL(iscsi_host_remove); 2689 2690 void iscsi_host_free(struct Scsi_Host *shost) 2691 { 2692 struct iscsi_host *ihost = shost_priv(shost); 2693 2694 kfree(ihost->netdev); 2695 kfree(ihost->hwaddress); 2696 kfree(ihost->initiatorname); 2697 scsi_host_put(shost); 2698 } 2699 EXPORT_SYMBOL_GPL(iscsi_host_free); 2700 2701 static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost) 2702 { 2703 struct iscsi_host *ihost = shost_priv(shost); 2704 unsigned long flags; 2705 2706 shost = scsi_host_get(shost); 2707 if (!shost) { 2708 printk(KERN_ERR "Invalid state. Cannot notify host removal " 2709 "of session teardown event because host already " 2710 "removed.\n"); 2711 return; 2712 } 2713 2714 spin_lock_irqsave(&ihost->lock, flags); 2715 ihost->num_sessions--; 2716 if (ihost->num_sessions == 0) 2717 wake_up(&ihost->session_removal_wq); 2718 spin_unlock_irqrestore(&ihost->lock, flags); 2719 scsi_host_put(shost); 2720 } 2721 2722 /** 2723 * iscsi_session_setup - create iscsi cls session and host and session 2724 * @iscsit: iscsi transport template 2725 * @shost: scsi host 2726 * @cmds_max: session can queue 2727 * @cmd_task_size: LLD task private data size 2728 * @initial_cmdsn: initial CmdSN 2729 * 2730 * This can be used by software iscsi_transports that allocate 2731 * a session per scsi host. 2732 * 2733 * Callers should set cmds_max to the largest total numer (mgmt + scsi) of 2734 * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks 2735 * for nop handling and login/logout requests. 2736 */ 2737 struct iscsi_cls_session * 2738 iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, 2739 uint16_t cmds_max, int dd_size, int cmd_task_size, 2740 uint32_t initial_cmdsn, unsigned int id) 2741 { 2742 struct iscsi_host *ihost = shost_priv(shost); 2743 struct iscsi_session *session; 2744 struct iscsi_cls_session *cls_session; 2745 int cmd_i, scsi_cmds, total_cmds = cmds_max; 2746 unsigned long flags; 2747 2748 spin_lock_irqsave(&ihost->lock, flags); 2749 if (ihost->state == ISCSI_HOST_REMOVED) { 2750 spin_unlock_irqrestore(&ihost->lock, flags); 2751 return NULL; 2752 } 2753 ihost->num_sessions++; 2754 spin_unlock_irqrestore(&ihost->lock, flags); 2755 2756 if (!total_cmds) 2757 total_cmds = ISCSI_DEF_XMIT_CMDS_MAX; 2758 /* 2759 * The iscsi layer needs some tasks for nop handling and tmfs, 2760 * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX 2761 * + 1 command for scsi IO. 2762 */ 2763 if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 2764 printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 2765 "must be a power of two that is at least %d.\n", 2766 total_cmds, ISCSI_TOTAL_CMDS_MIN); 2767 goto dec_session_count; 2768 } 2769 2770 if (total_cmds > ISCSI_TOTAL_CMDS_MAX) { 2771 printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 2772 "must be a power of 2 less than or equal to %d.\n", 2773 cmds_max, ISCSI_TOTAL_CMDS_MAX); 2774 total_cmds = ISCSI_TOTAL_CMDS_MAX; 2775 } 2776 2777 if (!is_power_of_2(total_cmds)) { 2778 printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 2779 "must be a power of 2.\n", total_cmds); 2780 total_cmds = rounddown_pow_of_two(total_cmds); 2781 if (total_cmds < ISCSI_TOTAL_CMDS_MIN) 2782 return NULL; 2783 printk(KERN_INFO "iscsi: Rounding can_queue to %d.\n", 2784 total_cmds); 2785 } 2786 scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX; 2787 2788 cls_session = iscsi_alloc_session(shost, iscsit, 2789 sizeof(struct iscsi_session) + 2790 dd_size); 2791 if (!cls_session) 2792 goto dec_session_count; 2793 session = cls_session->dd_data; 2794 session->cls_session = cls_session; 2795 session->host = shost; 2796 session->state = ISCSI_STATE_FREE; 2797 session->fast_abort = 1; 2798 session->tgt_reset_timeout = 30; 2799 session->lu_reset_timeout = 15; 2800 session->abort_timeout = 10; 2801 session->scsi_cmds_max = scsi_cmds; 2802 session->cmds_max = total_cmds; 2803 session->queued_cmdsn = session->cmdsn = initial_cmdsn; 2804 session->exp_cmdsn = initial_cmdsn + 1; 2805 session->max_cmdsn = initial_cmdsn + 1; 2806 session->max_r2t = 1; 2807 session->tt = iscsit; 2808 session->dd_data = cls_session->dd_data + sizeof(*session); 2809 2810 mutex_init(&session->eh_mutex); 2811 spin_lock_init(&session->frwd_lock); 2812 spin_lock_init(&session->back_lock); 2813 2814 /* initialize SCSI PDU commands pool */ 2815 if (iscsi_pool_init(&session->cmdpool, session->cmds_max, 2816 (void***)&session->cmds, 2817 cmd_task_size + sizeof(struct iscsi_task))) 2818 goto cmdpool_alloc_fail; 2819 2820 /* pre-format cmds pool with ITT */ 2821 for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) { 2822 struct iscsi_task *task = session->cmds[cmd_i]; 2823 2824 if (cmd_task_size) 2825 task->dd_data = &task[1]; 2826 task->itt = cmd_i; 2827 task->state = ISCSI_TASK_FREE; 2828 INIT_LIST_HEAD(&task->running); 2829 } 2830 2831 if (!try_module_get(iscsit->owner)) 2832 goto module_get_fail; 2833 2834 if (iscsi_add_session(cls_session, id)) 2835 goto cls_session_fail; 2836 2837 return cls_session; 2838 2839 cls_session_fail: 2840 module_put(iscsit->owner); 2841 module_get_fail: 2842 iscsi_pool_free(&session->cmdpool); 2843 cmdpool_alloc_fail: 2844 iscsi_free_session(cls_session); 2845 dec_session_count: 2846 iscsi_host_dec_session_cnt(shost); 2847 return NULL; 2848 } 2849 EXPORT_SYMBOL_GPL(iscsi_session_setup); 2850 2851 /** 2852 * iscsi_session_teardown - destroy session, host, and cls_session 2853 * @cls_session: iscsi session 2854 * 2855 * The driver must have called iscsi_remove_session before 2856 * calling this. 2857 */ 2858 void iscsi_session_teardown(struct iscsi_cls_session *cls_session) 2859 { 2860 struct iscsi_session *session = cls_session->dd_data; 2861 struct module *owner = cls_session->transport->owner; 2862 struct Scsi_Host *shost = session->host; 2863 2864 iscsi_pool_free(&session->cmdpool); 2865 2866 kfree(session->password); 2867 kfree(session->password_in); 2868 kfree(session->username); 2869 kfree(session->username_in); 2870 kfree(session->targetname); 2871 kfree(session->targetalias); 2872 kfree(session->initiatorname); 2873 kfree(session->boot_root); 2874 kfree(session->boot_nic); 2875 kfree(session->boot_target); 2876 kfree(session->ifacename); 2877 kfree(session->portal_type); 2878 kfree(session->discovery_parent_type); 2879 2880 iscsi_destroy_session(cls_session); 2881 iscsi_host_dec_session_cnt(shost); 2882 module_put(owner); 2883 } 2884 EXPORT_SYMBOL_GPL(iscsi_session_teardown); 2885 2886 /** 2887 * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn 2888 * @cls_session: iscsi_cls_session 2889 * @dd_size: private driver data size 2890 * @conn_idx: cid 2891 */ 2892 struct iscsi_cls_conn * 2893 iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, 2894 uint32_t conn_idx) 2895 { 2896 struct iscsi_session *session = cls_session->dd_data; 2897 struct iscsi_conn *conn; 2898 struct iscsi_cls_conn *cls_conn; 2899 char *data; 2900 2901 cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size, 2902 conn_idx); 2903 if (!cls_conn) 2904 return NULL; 2905 conn = cls_conn->dd_data; 2906 memset(conn, 0, sizeof(*conn) + dd_size); 2907 2908 conn->dd_data = cls_conn->dd_data + sizeof(*conn); 2909 conn->session = session; 2910 conn->cls_conn = cls_conn; 2911 conn->c_stage = ISCSI_CONN_INITIAL_STAGE; 2912 conn->id = conn_idx; 2913 conn->exp_statsn = 0; 2914 conn->tmf_state = TMF_INITIAL; 2915 2916 init_timer(&conn->transport_timer); 2917 conn->transport_timer.data = (unsigned long)conn; 2918 conn->transport_timer.function = iscsi_check_transport_timeouts; 2919 2920 INIT_LIST_HEAD(&conn->mgmtqueue); 2921 INIT_LIST_HEAD(&conn->cmdqueue); 2922 INIT_LIST_HEAD(&conn->requeue); 2923 spin_lock_init(&conn->taskqueuelock); 2924 INIT_WORK(&conn->xmitwork, iscsi_xmitworker); 2925 2926 /* allocate login_task used for the login/text sequences */ 2927 spin_lock_bh(&session->frwd_lock); 2928 if (!kfifo_out(&session->cmdpool.queue, 2929 (void*)&conn->login_task, 2930 sizeof(void*))) { 2931 spin_unlock_bh(&session->frwd_lock); 2932 goto login_task_alloc_fail; 2933 } 2934 spin_unlock_bh(&session->frwd_lock); 2935 2936 data = (char *) __get_free_pages(GFP_KERNEL, 2937 get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2938 if (!data) 2939 goto login_task_data_alloc_fail; 2940 conn->login_task->data = conn->data = data; 2941 2942 init_timer(&conn->tmf_timer); 2943 init_waitqueue_head(&conn->ehwait); 2944 2945 return cls_conn; 2946 2947 login_task_data_alloc_fail: 2948 kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 2949 sizeof(void*)); 2950 login_task_alloc_fail: 2951 iscsi_destroy_conn(cls_conn); 2952 return NULL; 2953 } 2954 EXPORT_SYMBOL_GPL(iscsi_conn_setup); 2955 2956 /** 2957 * iscsi_conn_teardown - teardown iscsi connection 2958 * cls_conn: iscsi class connection 2959 * 2960 * TODO: we may need to make this into a two step process 2961 * like scsi-mls remove + put host 2962 */ 2963 void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) 2964 { 2965 struct iscsi_conn *conn = cls_conn->dd_data; 2966 struct iscsi_session *session = conn->session; 2967 2968 del_timer_sync(&conn->transport_timer); 2969 2970 mutex_lock(&session->eh_mutex); 2971 spin_lock_bh(&session->frwd_lock); 2972 conn->c_stage = ISCSI_CONN_CLEANUP_WAIT; 2973 if (session->leadconn == conn) { 2974 /* 2975 * leading connection? then give up on recovery. 2976 */ 2977 session->state = ISCSI_STATE_TERMINATE; 2978 wake_up(&conn->ehwait); 2979 } 2980 spin_unlock_bh(&session->frwd_lock); 2981 2982 /* flush queued up work because we free the connection below */ 2983 iscsi_suspend_tx(conn); 2984 2985 spin_lock_bh(&session->frwd_lock); 2986 free_pages((unsigned long) conn->data, 2987 get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2988 kfree(conn->persistent_address); 2989 kfree(conn->local_ipaddr); 2990 /* regular RX path uses back_lock */ 2991 spin_lock_bh(&session->back_lock); 2992 kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 2993 sizeof(void*)); 2994 spin_unlock_bh(&session->back_lock); 2995 if (session->leadconn == conn) 2996 session->leadconn = NULL; 2997 spin_unlock_bh(&session->frwd_lock); 2998 mutex_unlock(&session->eh_mutex); 2999 3000 iscsi_destroy_conn(cls_conn); 3001 } 3002 EXPORT_SYMBOL_GPL(iscsi_conn_teardown); 3003 3004 int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 3005 { 3006 struct iscsi_conn *conn = cls_conn->dd_data; 3007 struct iscsi_session *session = conn->session; 3008 3009 if (!session) { 3010 iscsi_conn_printk(KERN_ERR, conn, 3011 "can't start unbound connection\n"); 3012 return -EPERM; 3013 } 3014 3015 if ((session->imm_data_en || !session->initial_r2t_en) && 3016 session->first_burst > session->max_burst) { 3017 iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: " 3018 "first_burst %d max_burst %d\n", 3019 session->first_burst, session->max_burst); 3020 return -EINVAL; 3021 } 3022 3023 if (conn->ping_timeout && !conn->recv_timeout) { 3024 iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of " 3025 "zero. Using 5 seconds\n."); 3026 conn->recv_timeout = 5; 3027 } 3028 3029 if (conn->recv_timeout && !conn->ping_timeout) { 3030 iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of " 3031 "zero. Using 5 seconds.\n"); 3032 conn->ping_timeout = 5; 3033 } 3034 3035 spin_lock_bh(&session->frwd_lock); 3036 conn->c_stage = ISCSI_CONN_STARTED; 3037 session->state = ISCSI_STATE_LOGGED_IN; 3038 session->queued_cmdsn = session->cmdsn; 3039 3040 conn->last_recv = jiffies; 3041 conn->last_ping = jiffies; 3042 if (conn->recv_timeout && conn->ping_timeout) 3043 mod_timer(&conn->transport_timer, 3044 jiffies + (conn->recv_timeout * HZ)); 3045 3046 switch(conn->stop_stage) { 3047 case STOP_CONN_RECOVER: 3048 /* 3049 * unblock eh_abort() if it is blocked. re-try all 3050 * commands after successful recovery 3051 */ 3052 conn->stop_stage = 0; 3053 conn->tmf_state = TMF_INITIAL; 3054 session->age++; 3055 if (session->age == 16) 3056 session->age = 0; 3057 break; 3058 case STOP_CONN_TERM: 3059 conn->stop_stage = 0; 3060 break; 3061 default: 3062 break; 3063 } 3064 spin_unlock_bh(&session->frwd_lock); 3065 3066 iscsi_unblock_session(session->cls_session); 3067 wake_up(&conn->ehwait); 3068 return 0; 3069 } 3070 EXPORT_SYMBOL_GPL(iscsi_conn_start); 3071 3072 static void 3073 fail_mgmt_tasks(struct iscsi_session *session, struct iscsi_conn *conn) 3074 { 3075 struct iscsi_task *task; 3076 int i, state; 3077 3078 for (i = 0; i < conn->session->cmds_max; i++) { 3079 task = conn->session->cmds[i]; 3080 if (task->sc) 3081 continue; 3082 3083 if (task->state == ISCSI_TASK_FREE) 3084 continue; 3085 3086 ISCSI_DBG_SESSION(conn->session, 3087 "failing mgmt itt 0x%x state %d\n", 3088 task->itt, task->state); 3089 state = ISCSI_TASK_ABRT_SESS_RECOV; 3090 if (task->state == ISCSI_TASK_PENDING) 3091 state = ISCSI_TASK_COMPLETED; 3092 iscsi_complete_task(task, state); 3093 3094 } 3095 } 3096 3097 static void iscsi_start_session_recovery(struct iscsi_session *session, 3098 struct iscsi_conn *conn, int flag) 3099 { 3100 int old_stop_stage; 3101 3102 mutex_lock(&session->eh_mutex); 3103 spin_lock_bh(&session->frwd_lock); 3104 if (conn->stop_stage == STOP_CONN_TERM) { 3105 spin_unlock_bh(&session->frwd_lock); 3106 mutex_unlock(&session->eh_mutex); 3107 return; 3108 } 3109 3110 /* 3111 * When this is called for the in_login state, we only want to clean 3112 * up the login task and connection. We do not need to block and set 3113 * the recovery state again 3114 */ 3115 if (flag == STOP_CONN_TERM) 3116 session->state = ISCSI_STATE_TERMINATE; 3117 else if (conn->stop_stage != STOP_CONN_RECOVER) 3118 session->state = ISCSI_STATE_IN_RECOVERY; 3119 3120 old_stop_stage = conn->stop_stage; 3121 conn->stop_stage = flag; 3122 spin_unlock_bh(&session->frwd_lock); 3123 3124 del_timer_sync(&conn->transport_timer); 3125 iscsi_suspend_tx(conn); 3126 3127 spin_lock_bh(&session->frwd_lock); 3128 conn->c_stage = ISCSI_CONN_STOPPED; 3129 spin_unlock_bh(&session->frwd_lock); 3130 3131 /* 3132 * for connection level recovery we should not calculate 3133 * header digest. conn->hdr_size used for optimization 3134 * in hdr_extract() and will be re-negotiated at 3135 * set_param() time. 3136 */ 3137 if (flag == STOP_CONN_RECOVER) { 3138 conn->hdrdgst_en = 0; 3139 conn->datadgst_en = 0; 3140 if (session->state == ISCSI_STATE_IN_RECOVERY && 3141 old_stop_stage != STOP_CONN_RECOVER) { 3142 ISCSI_DBG_SESSION(session, "blocking session\n"); 3143 iscsi_block_session(session->cls_session); 3144 } 3145 } 3146 3147 /* 3148 * flush queues. 3149 */ 3150 spin_lock_bh(&session->frwd_lock); 3151 fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED); 3152 fail_mgmt_tasks(session, conn); 3153 memset(&conn->tmhdr, 0, sizeof(conn->tmhdr)); 3154 spin_unlock_bh(&session->frwd_lock); 3155 mutex_unlock(&session->eh_mutex); 3156 } 3157 3158 void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 3159 { 3160 struct iscsi_conn *conn = cls_conn->dd_data; 3161 struct iscsi_session *session = conn->session; 3162 3163 switch (flag) { 3164 case STOP_CONN_RECOVER: 3165 case STOP_CONN_TERM: 3166 iscsi_start_session_recovery(session, conn, flag); 3167 break; 3168 default: 3169 iscsi_conn_printk(KERN_ERR, conn, 3170 "invalid stop flag %d\n", flag); 3171 } 3172 } 3173 EXPORT_SYMBOL_GPL(iscsi_conn_stop); 3174 3175 int iscsi_conn_bind(struct iscsi_cls_session *cls_session, 3176 struct iscsi_cls_conn *cls_conn, int is_leading) 3177 { 3178 struct iscsi_session *session = cls_session->dd_data; 3179 struct iscsi_conn *conn = cls_conn->dd_data; 3180 3181 spin_lock_bh(&session->frwd_lock); 3182 if (is_leading) 3183 session->leadconn = conn; 3184 spin_unlock_bh(&session->frwd_lock); 3185 3186 /* 3187 * Unblock xmitworker(), Login Phase will pass through. 3188 */ 3189 clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 3190 clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 3191 return 0; 3192 } 3193 EXPORT_SYMBOL_GPL(iscsi_conn_bind); 3194 3195 int iscsi_switch_str_param(char **param, char *new_val_buf) 3196 { 3197 char *new_val; 3198 3199 if (*param) { 3200 if (!strcmp(*param, new_val_buf)) 3201 return 0; 3202 } 3203 3204 new_val = kstrdup(new_val_buf, GFP_NOIO); 3205 if (!new_val) 3206 return -ENOMEM; 3207 3208 kfree(*param); 3209 *param = new_val; 3210 return 0; 3211 } 3212 EXPORT_SYMBOL_GPL(iscsi_switch_str_param); 3213 3214 int iscsi_set_param(struct iscsi_cls_conn *cls_conn, 3215 enum iscsi_param param, char *buf, int buflen) 3216 { 3217 struct iscsi_conn *conn = cls_conn->dd_data; 3218 struct iscsi_session *session = conn->session; 3219 int val; 3220 3221 switch(param) { 3222 case ISCSI_PARAM_FAST_ABORT: 3223 sscanf(buf, "%d", &session->fast_abort); 3224 break; 3225 case ISCSI_PARAM_ABORT_TMO: 3226 sscanf(buf, "%d", &session->abort_timeout); 3227 break; 3228 case ISCSI_PARAM_LU_RESET_TMO: 3229 sscanf(buf, "%d", &session->lu_reset_timeout); 3230 break; 3231 case ISCSI_PARAM_TGT_RESET_TMO: 3232 sscanf(buf, "%d", &session->tgt_reset_timeout); 3233 break; 3234 case ISCSI_PARAM_PING_TMO: 3235 sscanf(buf, "%d", &conn->ping_timeout); 3236 break; 3237 case ISCSI_PARAM_RECV_TMO: 3238 sscanf(buf, "%d", &conn->recv_timeout); 3239 break; 3240 case ISCSI_PARAM_MAX_RECV_DLENGTH: 3241 sscanf(buf, "%d", &conn->max_recv_dlength); 3242 break; 3243 case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3244 sscanf(buf, "%d", &conn->max_xmit_dlength); 3245 break; 3246 case ISCSI_PARAM_HDRDGST_EN: 3247 sscanf(buf, "%d", &conn->hdrdgst_en); 3248 break; 3249 case ISCSI_PARAM_DATADGST_EN: 3250 sscanf(buf, "%d", &conn->datadgst_en); 3251 break; 3252 case ISCSI_PARAM_INITIAL_R2T_EN: 3253 sscanf(buf, "%d", &session->initial_r2t_en); 3254 break; 3255 case ISCSI_PARAM_MAX_R2T: 3256 sscanf(buf, "%hu", &session->max_r2t); 3257 break; 3258 case ISCSI_PARAM_IMM_DATA_EN: 3259 sscanf(buf, "%d", &session->imm_data_en); 3260 break; 3261 case ISCSI_PARAM_FIRST_BURST: 3262 sscanf(buf, "%d", &session->first_burst); 3263 break; 3264 case ISCSI_PARAM_MAX_BURST: 3265 sscanf(buf, "%d", &session->max_burst); 3266 break; 3267 case ISCSI_PARAM_PDU_INORDER_EN: 3268 sscanf(buf, "%d", &session->pdu_inorder_en); 3269 break; 3270 case ISCSI_PARAM_DATASEQ_INORDER_EN: 3271 sscanf(buf, "%d", &session->dataseq_inorder_en); 3272 break; 3273 case ISCSI_PARAM_ERL: 3274 sscanf(buf, "%d", &session->erl); 3275 break; 3276 case ISCSI_PARAM_EXP_STATSN: 3277 sscanf(buf, "%u", &conn->exp_statsn); 3278 break; 3279 case ISCSI_PARAM_USERNAME: 3280 return iscsi_switch_str_param(&session->username, buf); 3281 case ISCSI_PARAM_USERNAME_IN: 3282 return iscsi_switch_str_param(&session->username_in, buf); 3283 case ISCSI_PARAM_PASSWORD: 3284 return iscsi_switch_str_param(&session->password, buf); 3285 case ISCSI_PARAM_PASSWORD_IN: 3286 return iscsi_switch_str_param(&session->password_in, buf); 3287 case ISCSI_PARAM_TARGET_NAME: 3288 return iscsi_switch_str_param(&session->targetname, buf); 3289 case ISCSI_PARAM_TARGET_ALIAS: 3290 return iscsi_switch_str_param(&session->targetalias, buf); 3291 case ISCSI_PARAM_TPGT: 3292 sscanf(buf, "%d", &session->tpgt); 3293 break; 3294 case ISCSI_PARAM_PERSISTENT_PORT: 3295 sscanf(buf, "%d", &conn->persistent_port); 3296 break; 3297 case ISCSI_PARAM_PERSISTENT_ADDRESS: 3298 return iscsi_switch_str_param(&conn->persistent_address, buf); 3299 case ISCSI_PARAM_IFACE_NAME: 3300 return iscsi_switch_str_param(&session->ifacename, buf); 3301 case ISCSI_PARAM_INITIATOR_NAME: 3302 return iscsi_switch_str_param(&session->initiatorname, buf); 3303 case ISCSI_PARAM_BOOT_ROOT: 3304 return iscsi_switch_str_param(&session->boot_root, buf); 3305 case ISCSI_PARAM_BOOT_NIC: 3306 return iscsi_switch_str_param(&session->boot_nic, buf); 3307 case ISCSI_PARAM_BOOT_TARGET: 3308 return iscsi_switch_str_param(&session->boot_target, buf); 3309 case ISCSI_PARAM_PORTAL_TYPE: 3310 return iscsi_switch_str_param(&session->portal_type, buf); 3311 case ISCSI_PARAM_DISCOVERY_PARENT_TYPE: 3312 return iscsi_switch_str_param(&session->discovery_parent_type, 3313 buf); 3314 case ISCSI_PARAM_DISCOVERY_SESS: 3315 sscanf(buf, "%d", &val); 3316 session->discovery_sess = !!val; 3317 break; 3318 case ISCSI_PARAM_LOCAL_IPADDR: 3319 return iscsi_switch_str_param(&conn->local_ipaddr, buf); 3320 default: 3321 return -ENOSYS; 3322 } 3323 3324 return 0; 3325 } 3326 EXPORT_SYMBOL_GPL(iscsi_set_param); 3327 3328 int iscsi_session_get_param(struct iscsi_cls_session *cls_session, 3329 enum iscsi_param param, char *buf) 3330 { 3331 struct iscsi_session *session = cls_session->dd_data; 3332 int len; 3333 3334 switch(param) { 3335 case ISCSI_PARAM_FAST_ABORT: 3336 len = sprintf(buf, "%d\n", session->fast_abort); 3337 break; 3338 case ISCSI_PARAM_ABORT_TMO: 3339 len = sprintf(buf, "%d\n", session->abort_timeout); 3340 break; 3341 case ISCSI_PARAM_LU_RESET_TMO: 3342 len = sprintf(buf, "%d\n", session->lu_reset_timeout); 3343 break; 3344 case ISCSI_PARAM_TGT_RESET_TMO: 3345 len = sprintf(buf, "%d\n", session->tgt_reset_timeout); 3346 break; 3347 case ISCSI_PARAM_INITIAL_R2T_EN: 3348 len = sprintf(buf, "%d\n", session->initial_r2t_en); 3349 break; 3350 case ISCSI_PARAM_MAX_R2T: 3351 len = sprintf(buf, "%hu\n", session->max_r2t); 3352 break; 3353 case ISCSI_PARAM_IMM_DATA_EN: 3354 len = sprintf(buf, "%d\n", session->imm_data_en); 3355 break; 3356 case ISCSI_PARAM_FIRST_BURST: 3357 len = sprintf(buf, "%u\n", session->first_burst); 3358 break; 3359 case ISCSI_PARAM_MAX_BURST: 3360 len = sprintf(buf, "%u\n", session->max_burst); 3361 break; 3362 case ISCSI_PARAM_PDU_INORDER_EN: 3363 len = sprintf(buf, "%d\n", session->pdu_inorder_en); 3364 break; 3365 case ISCSI_PARAM_DATASEQ_INORDER_EN: 3366 len = sprintf(buf, "%d\n", session->dataseq_inorder_en); 3367 break; 3368 case ISCSI_PARAM_DEF_TASKMGMT_TMO: 3369 len = sprintf(buf, "%d\n", session->def_taskmgmt_tmo); 3370 break; 3371 case ISCSI_PARAM_ERL: 3372 len = sprintf(buf, "%d\n", session->erl); 3373 break; 3374 case ISCSI_PARAM_TARGET_NAME: 3375 len = sprintf(buf, "%s\n", session->targetname); 3376 break; 3377 case ISCSI_PARAM_TARGET_ALIAS: 3378 len = sprintf(buf, "%s\n", session->targetalias); 3379 break; 3380 case ISCSI_PARAM_TPGT: 3381 len = sprintf(buf, "%d\n", session->tpgt); 3382 break; 3383 case ISCSI_PARAM_USERNAME: 3384 len = sprintf(buf, "%s\n", session->username); 3385 break; 3386 case ISCSI_PARAM_USERNAME_IN: 3387 len = sprintf(buf, "%s\n", session->username_in); 3388 break; 3389 case ISCSI_PARAM_PASSWORD: 3390 len = sprintf(buf, "%s\n", session->password); 3391 break; 3392 case ISCSI_PARAM_PASSWORD_IN: 3393 len = sprintf(buf, "%s\n", session->password_in); 3394 break; 3395 case ISCSI_PARAM_IFACE_NAME: 3396 len = sprintf(buf, "%s\n", session->ifacename); 3397 break; 3398 case ISCSI_PARAM_INITIATOR_NAME: 3399 len = sprintf(buf, "%s\n", session->initiatorname); 3400 break; 3401 case ISCSI_PARAM_BOOT_ROOT: 3402 len = sprintf(buf, "%s\n", session->boot_root); 3403 break; 3404 case ISCSI_PARAM_BOOT_NIC: 3405 len = sprintf(buf, "%s\n", session->boot_nic); 3406 break; 3407 case ISCSI_PARAM_BOOT_TARGET: 3408 len = sprintf(buf, "%s\n", session->boot_target); 3409 break; 3410 case ISCSI_PARAM_AUTO_SND_TGT_DISABLE: 3411 len = sprintf(buf, "%u\n", session->auto_snd_tgt_disable); 3412 break; 3413 case ISCSI_PARAM_DISCOVERY_SESS: 3414 len = sprintf(buf, "%u\n", session->discovery_sess); 3415 break; 3416 case ISCSI_PARAM_PORTAL_TYPE: 3417 len = sprintf(buf, "%s\n", session->portal_type); 3418 break; 3419 case ISCSI_PARAM_CHAP_AUTH_EN: 3420 len = sprintf(buf, "%u\n", session->chap_auth_en); 3421 break; 3422 case ISCSI_PARAM_DISCOVERY_LOGOUT_EN: 3423 len = sprintf(buf, "%u\n", session->discovery_logout_en); 3424 break; 3425 case ISCSI_PARAM_BIDI_CHAP_EN: 3426 len = sprintf(buf, "%u\n", session->bidi_chap_en); 3427 break; 3428 case ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL: 3429 len = sprintf(buf, "%u\n", session->discovery_auth_optional); 3430 break; 3431 case ISCSI_PARAM_DEF_TIME2WAIT: 3432 len = sprintf(buf, "%d\n", session->time2wait); 3433 break; 3434 case ISCSI_PARAM_DEF_TIME2RETAIN: 3435 len = sprintf(buf, "%d\n", session->time2retain); 3436 break; 3437 case ISCSI_PARAM_TSID: 3438 len = sprintf(buf, "%u\n", session->tsid); 3439 break; 3440 case ISCSI_PARAM_ISID: 3441 len = sprintf(buf, "%02x%02x%02x%02x%02x%02x\n", 3442 session->isid[0], session->isid[1], 3443 session->isid[2], session->isid[3], 3444 session->isid[4], session->isid[5]); 3445 break; 3446 case ISCSI_PARAM_DISCOVERY_PARENT_IDX: 3447 len = sprintf(buf, "%u\n", session->discovery_parent_idx); 3448 break; 3449 case ISCSI_PARAM_DISCOVERY_PARENT_TYPE: 3450 if (session->discovery_parent_type) 3451 len = sprintf(buf, "%s\n", 3452 session->discovery_parent_type); 3453 else 3454 len = sprintf(buf, "\n"); 3455 break; 3456 default: 3457 return -ENOSYS; 3458 } 3459 3460 return len; 3461 } 3462 EXPORT_SYMBOL_GPL(iscsi_session_get_param); 3463 3464 int iscsi_conn_get_addr_param(struct sockaddr_storage *addr, 3465 enum iscsi_param param, char *buf) 3466 { 3467 struct sockaddr_in6 *sin6 = NULL; 3468 struct sockaddr_in *sin = NULL; 3469 int len; 3470 3471 switch (addr->ss_family) { 3472 case AF_INET: 3473 sin = (struct sockaddr_in *)addr; 3474 break; 3475 case AF_INET6: 3476 sin6 = (struct sockaddr_in6 *)addr; 3477 break; 3478 default: 3479 return -EINVAL; 3480 } 3481 3482 switch (param) { 3483 case ISCSI_PARAM_CONN_ADDRESS: 3484 case ISCSI_HOST_PARAM_IPADDRESS: 3485 if (sin) 3486 len = sprintf(buf, "%pI4\n", &sin->sin_addr.s_addr); 3487 else 3488 len = sprintf(buf, "%pI6\n", &sin6->sin6_addr); 3489 break; 3490 case ISCSI_PARAM_CONN_PORT: 3491 case ISCSI_PARAM_LOCAL_PORT: 3492 if (sin) 3493 len = sprintf(buf, "%hu\n", be16_to_cpu(sin->sin_port)); 3494 else 3495 len = sprintf(buf, "%hu\n", 3496 be16_to_cpu(sin6->sin6_port)); 3497 break; 3498 default: 3499 return -EINVAL; 3500 } 3501 3502 return len; 3503 } 3504 EXPORT_SYMBOL_GPL(iscsi_conn_get_addr_param); 3505 3506 int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, 3507 enum iscsi_param param, char *buf) 3508 { 3509 struct iscsi_conn *conn = cls_conn->dd_data; 3510 int len; 3511 3512 switch(param) { 3513 case ISCSI_PARAM_PING_TMO: 3514 len = sprintf(buf, "%u\n", conn->ping_timeout); 3515 break; 3516 case ISCSI_PARAM_RECV_TMO: 3517 len = sprintf(buf, "%u\n", conn->recv_timeout); 3518 break; 3519 case ISCSI_PARAM_MAX_RECV_DLENGTH: 3520 len = sprintf(buf, "%u\n", conn->max_recv_dlength); 3521 break; 3522 case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3523 len = sprintf(buf, "%u\n", conn->max_xmit_dlength); 3524 break; 3525 case ISCSI_PARAM_HDRDGST_EN: 3526 len = sprintf(buf, "%d\n", conn->hdrdgst_en); 3527 break; 3528 case ISCSI_PARAM_DATADGST_EN: 3529 len = sprintf(buf, "%d\n", conn->datadgst_en); 3530 break; 3531 case ISCSI_PARAM_IFMARKER_EN: 3532 len = sprintf(buf, "%d\n", conn->ifmarker_en); 3533 break; 3534 case ISCSI_PARAM_OFMARKER_EN: 3535 len = sprintf(buf, "%d\n", conn->ofmarker_en); 3536 break; 3537 case ISCSI_PARAM_EXP_STATSN: 3538 len = sprintf(buf, "%u\n", conn->exp_statsn); 3539 break; 3540 case ISCSI_PARAM_PERSISTENT_PORT: 3541 len = sprintf(buf, "%d\n", conn->persistent_port); 3542 break; 3543 case ISCSI_PARAM_PERSISTENT_ADDRESS: 3544 len = sprintf(buf, "%s\n", conn->persistent_address); 3545 break; 3546 case ISCSI_PARAM_STATSN: 3547 len = sprintf(buf, "%u\n", conn->statsn); 3548 break; 3549 case ISCSI_PARAM_MAX_SEGMENT_SIZE: 3550 len = sprintf(buf, "%u\n", conn->max_segment_size); 3551 break; 3552 case ISCSI_PARAM_KEEPALIVE_TMO: 3553 len = sprintf(buf, "%u\n", conn->keepalive_tmo); 3554 break; 3555 case ISCSI_PARAM_LOCAL_PORT: 3556 len = sprintf(buf, "%u\n", conn->local_port); 3557 break; 3558 case ISCSI_PARAM_TCP_TIMESTAMP_STAT: 3559 len = sprintf(buf, "%u\n", conn->tcp_timestamp_stat); 3560 break; 3561 case ISCSI_PARAM_TCP_NAGLE_DISABLE: 3562 len = sprintf(buf, "%u\n", conn->tcp_nagle_disable); 3563 break; 3564 case ISCSI_PARAM_TCP_WSF_DISABLE: 3565 len = sprintf(buf, "%u\n", conn->tcp_wsf_disable); 3566 break; 3567 case ISCSI_PARAM_TCP_TIMER_SCALE: 3568 len = sprintf(buf, "%u\n", conn->tcp_timer_scale); 3569 break; 3570 case ISCSI_PARAM_TCP_TIMESTAMP_EN: 3571 len = sprintf(buf, "%u\n", conn->tcp_timestamp_en); 3572 break; 3573 case ISCSI_PARAM_IP_FRAGMENT_DISABLE: 3574 len = sprintf(buf, "%u\n", conn->fragment_disable); 3575 break; 3576 case ISCSI_PARAM_IPV4_TOS: 3577 len = sprintf(buf, "%u\n", conn->ipv4_tos); 3578 break; 3579 case ISCSI_PARAM_IPV6_TC: 3580 len = sprintf(buf, "%u\n", conn->ipv6_traffic_class); 3581 break; 3582 case ISCSI_PARAM_IPV6_FLOW_LABEL: 3583 len = sprintf(buf, "%u\n", conn->ipv6_flow_label); 3584 break; 3585 case ISCSI_PARAM_IS_FW_ASSIGNED_IPV6: 3586 len = sprintf(buf, "%u\n", conn->is_fw_assigned_ipv6); 3587 break; 3588 case ISCSI_PARAM_TCP_XMIT_WSF: 3589 len = sprintf(buf, "%u\n", conn->tcp_xmit_wsf); 3590 break; 3591 case ISCSI_PARAM_TCP_RECV_WSF: 3592 len = sprintf(buf, "%u\n", conn->tcp_recv_wsf); 3593 break; 3594 case ISCSI_PARAM_LOCAL_IPADDR: 3595 len = sprintf(buf, "%s\n", conn->local_ipaddr); 3596 break; 3597 default: 3598 return -ENOSYS; 3599 } 3600 3601 return len; 3602 } 3603 EXPORT_SYMBOL_GPL(iscsi_conn_get_param); 3604 3605 int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param, 3606 char *buf) 3607 { 3608 struct iscsi_host *ihost = shost_priv(shost); 3609 int len; 3610 3611 switch (param) { 3612 case ISCSI_HOST_PARAM_NETDEV_NAME: 3613 len = sprintf(buf, "%s\n", ihost->netdev); 3614 break; 3615 case ISCSI_HOST_PARAM_HWADDRESS: 3616 len = sprintf(buf, "%s\n", ihost->hwaddress); 3617 break; 3618 case ISCSI_HOST_PARAM_INITIATOR_NAME: 3619 len = sprintf(buf, "%s\n", ihost->initiatorname); 3620 break; 3621 default: 3622 return -ENOSYS; 3623 } 3624 3625 return len; 3626 } 3627 EXPORT_SYMBOL_GPL(iscsi_host_get_param); 3628 3629 int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param, 3630 char *buf, int buflen) 3631 { 3632 struct iscsi_host *ihost = shost_priv(shost); 3633 3634 switch (param) { 3635 case ISCSI_HOST_PARAM_NETDEV_NAME: 3636 return iscsi_switch_str_param(&ihost->netdev, buf); 3637 case ISCSI_HOST_PARAM_HWADDRESS: 3638 return iscsi_switch_str_param(&ihost->hwaddress, buf); 3639 case ISCSI_HOST_PARAM_INITIATOR_NAME: 3640 return iscsi_switch_str_param(&ihost->initiatorname, buf); 3641 default: 3642 return -ENOSYS; 3643 } 3644 3645 return 0; 3646 } 3647 EXPORT_SYMBOL_GPL(iscsi_host_set_param); 3648 3649 MODULE_AUTHOR("Mike Christie"); 3650 MODULE_DESCRIPTION("iSCSI library functions"); 3651 MODULE_LICENSE("GPL"); 3652