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