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