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