1/******************************************************************************* 2 * This file contains the iSCSI Target specific utility functions. 3 * 4 * (c) Copyright 2007-2013 Datera, Inc. 5 * 6 * Author: Nicholas A. Bellinger <nab@linux-iscsi.org> 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 ******************************************************************************/ 18 19#include <linux/list.h> 20#include <linux/percpu_ida.h> 21#include <scsi/scsi_tcq.h> 22#include <scsi/iscsi_proto.h> 23#include <target/target_core_base.h> 24#include <target/target_core_fabric.h> 25#include <target/target_core_configfs.h> 26#include <target/iscsi/iscsi_transport.h> 27 28#include <target/iscsi/iscsi_target_core.h> 29#include "iscsi_target_parameters.h" 30#include "iscsi_target_seq_pdu_list.h" 31#include "iscsi_target_datain_values.h" 32#include "iscsi_target_erl0.h" 33#include "iscsi_target_erl1.h" 34#include "iscsi_target_erl2.h" 35#include "iscsi_target_tpg.h" 36#include "iscsi_target_util.h" 37#include "iscsi_target.h" 38 39#define PRINT_BUFF(buff, len) \ 40{ \ 41 int zzz; \ 42 \ 43 pr_debug("%d:\n", __LINE__); \ 44 for (zzz = 0; zzz < len; zzz++) { \ 45 if (zzz % 16 == 0) { \ 46 if (zzz) \ 47 pr_debug("\n"); \ 48 pr_debug("%4i: ", zzz); \ 49 } \ 50 pr_debug("%02x ", (unsigned char) (buff)[zzz]); \ 51 } \ 52 if ((len + 1) % 16) \ 53 pr_debug("\n"); \ 54} 55 56extern struct list_head g_tiqn_list; 57extern spinlock_t tiqn_lock; 58 59/* 60 * Called with cmd->r2t_lock held. 61 */ 62int iscsit_add_r2t_to_list( 63 struct iscsi_cmd *cmd, 64 u32 offset, 65 u32 xfer_len, 66 int recovery, 67 u32 r2t_sn) 68{ 69 struct iscsi_r2t *r2t; 70 71 r2t = kmem_cache_zalloc(lio_r2t_cache, GFP_ATOMIC); 72 if (!r2t) { 73 pr_err("Unable to allocate memory for struct iscsi_r2t.\n"); 74 return -1; 75 } 76 INIT_LIST_HEAD(&r2t->r2t_list); 77 78 r2t->recovery_r2t = recovery; 79 r2t->r2t_sn = (!r2t_sn) ? cmd->r2t_sn++ : r2t_sn; 80 r2t->offset = offset; 81 r2t->xfer_len = xfer_len; 82 list_add_tail(&r2t->r2t_list, &cmd->cmd_r2t_list); 83 spin_unlock_bh(&cmd->r2t_lock); 84 85 iscsit_add_cmd_to_immediate_queue(cmd, cmd->conn, ISTATE_SEND_R2T); 86 87 spin_lock_bh(&cmd->r2t_lock); 88 return 0; 89} 90 91struct iscsi_r2t *iscsit_get_r2t_for_eos( 92 struct iscsi_cmd *cmd, 93 u32 offset, 94 u32 length) 95{ 96 struct iscsi_r2t *r2t; 97 98 spin_lock_bh(&cmd->r2t_lock); 99 list_for_each_entry(r2t, &cmd->cmd_r2t_list, r2t_list) { 100 if ((r2t->offset <= offset) && 101 (r2t->offset + r2t->xfer_len) >= (offset + length)) { 102 spin_unlock_bh(&cmd->r2t_lock); 103 return r2t; 104 } 105 } 106 spin_unlock_bh(&cmd->r2t_lock); 107 108 pr_err("Unable to locate R2T for Offset: %u, Length:" 109 " %u\n", offset, length); 110 return NULL; 111} 112 113struct iscsi_r2t *iscsit_get_r2t_from_list(struct iscsi_cmd *cmd) 114{ 115 struct iscsi_r2t *r2t; 116 117 spin_lock_bh(&cmd->r2t_lock); 118 list_for_each_entry(r2t, &cmd->cmd_r2t_list, r2t_list) { 119 if (!r2t->sent_r2t) { 120 spin_unlock_bh(&cmd->r2t_lock); 121 return r2t; 122 } 123 } 124 spin_unlock_bh(&cmd->r2t_lock); 125 126 pr_err("Unable to locate next R2T to send for ITT:" 127 " 0x%08x.\n", cmd->init_task_tag); 128 return NULL; 129} 130 131/* 132 * Called with cmd->r2t_lock held. 133 */ 134void iscsit_free_r2t(struct iscsi_r2t *r2t, struct iscsi_cmd *cmd) 135{ 136 list_del(&r2t->r2t_list); 137 kmem_cache_free(lio_r2t_cache, r2t); 138} 139 140void iscsit_free_r2ts_from_list(struct iscsi_cmd *cmd) 141{ 142 struct iscsi_r2t *r2t, *r2t_tmp; 143 144 spin_lock_bh(&cmd->r2t_lock); 145 list_for_each_entry_safe(r2t, r2t_tmp, &cmd->cmd_r2t_list, r2t_list) 146 iscsit_free_r2t(r2t, cmd); 147 spin_unlock_bh(&cmd->r2t_lock); 148} 149 150/* 151 * May be called from software interrupt (timer) context for allocating 152 * iSCSI NopINs. 153 */ 154struct iscsi_cmd *iscsit_allocate_cmd(struct iscsi_conn *conn, int state) 155{ 156 struct iscsi_cmd *cmd; 157 struct se_session *se_sess = conn->sess->se_sess; 158 int size, tag; 159 160 tag = percpu_ida_alloc(&se_sess->sess_tag_pool, state); 161 if (tag < 0) 162 return NULL; 163 164 size = sizeof(struct iscsi_cmd) + conn->conn_transport->priv_size; 165 cmd = (struct iscsi_cmd *)(se_sess->sess_cmd_map + (tag * size)); 166 memset(cmd, 0, size); 167 168 cmd->se_cmd.map_tag = tag; 169 cmd->conn = conn; 170 INIT_LIST_HEAD(&cmd->i_conn_node); 171 INIT_LIST_HEAD(&cmd->datain_list); 172 INIT_LIST_HEAD(&cmd->cmd_r2t_list); 173 spin_lock_init(&cmd->datain_lock); 174 spin_lock_init(&cmd->dataout_timeout_lock); 175 spin_lock_init(&cmd->istate_lock); 176 spin_lock_init(&cmd->error_lock); 177 spin_lock_init(&cmd->r2t_lock); 178 179 return cmd; 180} 181EXPORT_SYMBOL(iscsit_allocate_cmd); 182 183struct iscsi_seq *iscsit_get_seq_holder_for_datain( 184 struct iscsi_cmd *cmd, 185 u32 seq_send_order) 186{ 187 u32 i; 188 189 for (i = 0; i < cmd->seq_count; i++) 190 if (cmd->seq_list[i].seq_send_order == seq_send_order) 191 return &cmd->seq_list[i]; 192 193 return NULL; 194} 195 196struct iscsi_seq *iscsit_get_seq_holder_for_r2t(struct iscsi_cmd *cmd) 197{ 198 u32 i; 199 200 if (!cmd->seq_list) { 201 pr_err("struct iscsi_cmd->seq_list is NULL!\n"); 202 return NULL; 203 } 204 205 for (i = 0; i < cmd->seq_count; i++) { 206 if (cmd->seq_list[i].type != SEQTYPE_NORMAL) 207 continue; 208 if (cmd->seq_list[i].seq_send_order == cmd->seq_send_order) { 209 cmd->seq_send_order++; 210 return &cmd->seq_list[i]; 211 } 212 } 213 214 return NULL; 215} 216 217struct iscsi_r2t *iscsit_get_holder_for_r2tsn( 218 struct iscsi_cmd *cmd, 219 u32 r2t_sn) 220{ 221 struct iscsi_r2t *r2t; 222 223 spin_lock_bh(&cmd->r2t_lock); 224 list_for_each_entry(r2t, &cmd->cmd_r2t_list, r2t_list) { 225 if (r2t->r2t_sn == r2t_sn) { 226 spin_unlock_bh(&cmd->r2t_lock); 227 return r2t; 228 } 229 } 230 spin_unlock_bh(&cmd->r2t_lock); 231 232 return NULL; 233} 234 235static inline int iscsit_check_received_cmdsn(struct iscsi_session *sess, u32 cmdsn) 236{ 237 int ret; 238 239 /* 240 * This is the proper method of checking received CmdSN against 241 * ExpCmdSN and MaxCmdSN values, as well as accounting for out 242 * or order CmdSNs due to multiple connection sessions and/or 243 * CRC failures. 244 */ 245 if (iscsi_sna_gt(cmdsn, sess->max_cmd_sn)) { 246 pr_err("Received CmdSN: 0x%08x is greater than" 247 " MaxCmdSN: 0x%08x, ignoring.\n", cmdsn, 248 sess->max_cmd_sn); 249 ret = CMDSN_MAXCMDSN_OVERRUN; 250 251 } else if (cmdsn == sess->exp_cmd_sn) { 252 sess->exp_cmd_sn++; 253 pr_debug("Received CmdSN matches ExpCmdSN," 254 " incremented ExpCmdSN to: 0x%08x\n", 255 sess->exp_cmd_sn); 256 ret = CMDSN_NORMAL_OPERATION; 257 258 } else if (iscsi_sna_gt(cmdsn, sess->exp_cmd_sn)) { 259 pr_debug("Received CmdSN: 0x%08x is greater" 260 " than ExpCmdSN: 0x%08x, not acknowledging.\n", 261 cmdsn, sess->exp_cmd_sn); 262 ret = CMDSN_HIGHER_THAN_EXP; 263 264 } else { 265 pr_err("Received CmdSN: 0x%08x is less than" 266 " ExpCmdSN: 0x%08x, ignoring.\n", cmdsn, 267 sess->exp_cmd_sn); 268 ret = CMDSN_LOWER_THAN_EXP; 269 } 270 271 return ret; 272} 273 274/* 275 * Commands may be received out of order if MC/S is in use. 276 * Ensure they are executed in CmdSN order. 277 */ 278int iscsit_sequence_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd, 279 unsigned char *buf, __be32 cmdsn) 280{ 281 int ret, cmdsn_ret; 282 bool reject = false; 283 u8 reason = ISCSI_REASON_BOOKMARK_NO_RESOURCES; 284 285 mutex_lock(&conn->sess->cmdsn_mutex); 286 287 cmdsn_ret = iscsit_check_received_cmdsn(conn->sess, be32_to_cpu(cmdsn)); 288 switch (cmdsn_ret) { 289 case CMDSN_NORMAL_OPERATION: 290 ret = iscsit_execute_cmd(cmd, 0); 291 if ((ret >= 0) && !list_empty(&conn->sess->sess_ooo_cmdsn_list)) 292 iscsit_execute_ooo_cmdsns(conn->sess); 293 else if (ret < 0) { 294 reject = true; 295 ret = CMDSN_ERROR_CANNOT_RECOVER; 296 } 297 break; 298 case CMDSN_HIGHER_THAN_EXP: 299 ret = iscsit_handle_ooo_cmdsn(conn->sess, cmd, be32_to_cpu(cmdsn)); 300 if (ret < 0) { 301 reject = true; 302 ret = CMDSN_ERROR_CANNOT_RECOVER; 303 break; 304 } 305 ret = CMDSN_HIGHER_THAN_EXP; 306 break; 307 case CMDSN_LOWER_THAN_EXP: 308 case CMDSN_MAXCMDSN_OVERRUN: 309 default: 310 cmd->i_state = ISTATE_REMOVE; 311 iscsit_add_cmd_to_immediate_queue(cmd, conn, cmd->i_state); 312 /* 313 * Existing callers for iscsit_sequence_cmd() will silently 314 * ignore commands with CMDSN_LOWER_THAN_EXP, so force this 315 * return for CMDSN_MAXCMDSN_OVERRUN as well.. 316 */ 317 ret = CMDSN_LOWER_THAN_EXP; 318 break; 319 } 320 mutex_unlock(&conn->sess->cmdsn_mutex); 321 322 if (reject) 323 iscsit_reject_cmd(cmd, reason, buf); 324 325 return ret; 326} 327EXPORT_SYMBOL(iscsit_sequence_cmd); 328 329int iscsit_check_unsolicited_dataout(struct iscsi_cmd *cmd, unsigned char *buf) 330{ 331 struct iscsi_conn *conn = cmd->conn; 332 struct se_cmd *se_cmd = &cmd->se_cmd; 333 struct iscsi_data *hdr = (struct iscsi_data *) buf; 334 u32 payload_length = ntoh24(hdr->dlength); 335 336 if (conn->sess->sess_ops->InitialR2T) { 337 pr_err("Received unexpected unsolicited data" 338 " while InitialR2T=Yes, protocol error.\n"); 339 transport_send_check_condition_and_sense(se_cmd, 340 TCM_UNEXPECTED_UNSOLICITED_DATA, 0); 341 return -1; 342 } 343 344 if ((cmd->first_burst_len + payload_length) > 345 conn->sess->sess_ops->FirstBurstLength) { 346 pr_err("Total %u bytes exceeds FirstBurstLength: %u" 347 " for this Unsolicited DataOut Burst.\n", 348 (cmd->first_burst_len + payload_length), 349 conn->sess->sess_ops->FirstBurstLength); 350 transport_send_check_condition_and_sense(se_cmd, 351 TCM_INCORRECT_AMOUNT_OF_DATA, 0); 352 return -1; 353 } 354 355 if (!(hdr->flags & ISCSI_FLAG_CMD_FINAL)) 356 return 0; 357 358 if (((cmd->first_burst_len + payload_length) != cmd->se_cmd.data_length) && 359 ((cmd->first_burst_len + payload_length) != 360 conn->sess->sess_ops->FirstBurstLength)) { 361 pr_err("Unsolicited non-immediate data received %u" 362 " does not equal FirstBurstLength: %u, and does" 363 " not equal ExpXferLen %u.\n", 364 (cmd->first_burst_len + payload_length), 365 conn->sess->sess_ops->FirstBurstLength, cmd->se_cmd.data_length); 366 transport_send_check_condition_and_sense(se_cmd, 367 TCM_INCORRECT_AMOUNT_OF_DATA, 0); 368 return -1; 369 } 370 return 0; 371} 372 373struct iscsi_cmd *iscsit_find_cmd_from_itt( 374 struct iscsi_conn *conn, 375 itt_t init_task_tag) 376{ 377 struct iscsi_cmd *cmd; 378 379 spin_lock_bh(&conn->cmd_lock); 380 list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) { 381 if (cmd->init_task_tag == init_task_tag) { 382 spin_unlock_bh(&conn->cmd_lock); 383 return cmd; 384 } 385 } 386 spin_unlock_bh(&conn->cmd_lock); 387 388 pr_err("Unable to locate ITT: 0x%08x on CID: %hu", 389 init_task_tag, conn->cid); 390 return NULL; 391} 392EXPORT_SYMBOL(iscsit_find_cmd_from_itt); 393 394struct iscsi_cmd *iscsit_find_cmd_from_itt_or_dump( 395 struct iscsi_conn *conn, 396 itt_t init_task_tag, 397 u32 length) 398{ 399 struct iscsi_cmd *cmd; 400 401 spin_lock_bh(&conn->cmd_lock); 402 list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) { 403 if (cmd->cmd_flags & ICF_GOT_LAST_DATAOUT) 404 continue; 405 if (cmd->init_task_tag == init_task_tag) { 406 spin_unlock_bh(&conn->cmd_lock); 407 return cmd; 408 } 409 } 410 spin_unlock_bh(&conn->cmd_lock); 411 412 pr_err("Unable to locate ITT: 0x%08x on CID: %hu," 413 " dumping payload\n", init_task_tag, conn->cid); 414 if (length) 415 iscsit_dump_data_payload(conn, length, 1); 416 417 return NULL; 418} 419 420struct iscsi_cmd *iscsit_find_cmd_from_ttt( 421 struct iscsi_conn *conn, 422 u32 targ_xfer_tag) 423{ 424 struct iscsi_cmd *cmd = NULL; 425 426 spin_lock_bh(&conn->cmd_lock); 427 list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) { 428 if (cmd->targ_xfer_tag == targ_xfer_tag) { 429 spin_unlock_bh(&conn->cmd_lock); 430 return cmd; 431 } 432 } 433 spin_unlock_bh(&conn->cmd_lock); 434 435 pr_err("Unable to locate TTT: 0x%08x on CID: %hu\n", 436 targ_xfer_tag, conn->cid); 437 return NULL; 438} 439 440int iscsit_find_cmd_for_recovery( 441 struct iscsi_session *sess, 442 struct iscsi_cmd **cmd_ptr, 443 struct iscsi_conn_recovery **cr_ptr, 444 itt_t init_task_tag) 445{ 446 struct iscsi_cmd *cmd = NULL; 447 struct iscsi_conn_recovery *cr; 448 /* 449 * Scan through the inactive connection recovery list's command list. 450 * If init_task_tag matches the command is still alligent. 451 */ 452 spin_lock(&sess->cr_i_lock); 453 list_for_each_entry(cr, &sess->cr_inactive_list, cr_list) { 454 spin_lock(&cr->conn_recovery_cmd_lock); 455 list_for_each_entry(cmd, &cr->conn_recovery_cmd_list, i_conn_node) { 456 if (cmd->init_task_tag == init_task_tag) { 457 spin_unlock(&cr->conn_recovery_cmd_lock); 458 spin_unlock(&sess->cr_i_lock); 459 460 *cr_ptr = cr; 461 *cmd_ptr = cmd; 462 return -2; 463 } 464 } 465 spin_unlock(&cr->conn_recovery_cmd_lock); 466 } 467 spin_unlock(&sess->cr_i_lock); 468 /* 469 * Scan through the active connection recovery list's command list. 470 * If init_task_tag matches the command is ready to be reassigned. 471 */ 472 spin_lock(&sess->cr_a_lock); 473 list_for_each_entry(cr, &sess->cr_active_list, cr_list) { 474 spin_lock(&cr->conn_recovery_cmd_lock); 475 list_for_each_entry(cmd, &cr->conn_recovery_cmd_list, i_conn_node) { 476 if (cmd->init_task_tag == init_task_tag) { 477 spin_unlock(&cr->conn_recovery_cmd_lock); 478 spin_unlock(&sess->cr_a_lock); 479 480 *cr_ptr = cr; 481 *cmd_ptr = cmd; 482 return 0; 483 } 484 } 485 spin_unlock(&cr->conn_recovery_cmd_lock); 486 } 487 spin_unlock(&sess->cr_a_lock); 488 489 return -1; 490} 491 492void iscsit_add_cmd_to_immediate_queue( 493 struct iscsi_cmd *cmd, 494 struct iscsi_conn *conn, 495 u8 state) 496{ 497 struct iscsi_queue_req *qr; 498 499 qr = kmem_cache_zalloc(lio_qr_cache, GFP_ATOMIC); 500 if (!qr) { 501 pr_err("Unable to allocate memory for" 502 " struct iscsi_queue_req\n"); 503 return; 504 } 505 INIT_LIST_HEAD(&qr->qr_list); 506 qr->cmd = cmd; 507 qr->state = state; 508 509 spin_lock_bh(&conn->immed_queue_lock); 510 list_add_tail(&qr->qr_list, &conn->immed_queue_list); 511 atomic_inc(&cmd->immed_queue_count); 512 atomic_set(&conn->check_immediate_queue, 1); 513 spin_unlock_bh(&conn->immed_queue_lock); 514 515 wake_up(&conn->queues_wq); 516} 517 518struct iscsi_queue_req *iscsit_get_cmd_from_immediate_queue(struct iscsi_conn *conn) 519{ 520 struct iscsi_queue_req *qr; 521 522 spin_lock_bh(&conn->immed_queue_lock); 523 if (list_empty(&conn->immed_queue_list)) { 524 spin_unlock_bh(&conn->immed_queue_lock); 525 return NULL; 526 } 527 qr = list_first_entry(&conn->immed_queue_list, 528 struct iscsi_queue_req, qr_list); 529 530 list_del(&qr->qr_list); 531 if (qr->cmd) 532 atomic_dec(&qr->cmd->immed_queue_count); 533 spin_unlock_bh(&conn->immed_queue_lock); 534 535 return qr; 536} 537 538static void iscsit_remove_cmd_from_immediate_queue( 539 struct iscsi_cmd *cmd, 540 struct iscsi_conn *conn) 541{ 542 struct iscsi_queue_req *qr, *qr_tmp; 543 544 spin_lock_bh(&conn->immed_queue_lock); 545 if (!atomic_read(&cmd->immed_queue_count)) { 546 spin_unlock_bh(&conn->immed_queue_lock); 547 return; 548 } 549 550 list_for_each_entry_safe(qr, qr_tmp, &conn->immed_queue_list, qr_list) { 551 if (qr->cmd != cmd) 552 continue; 553 554 atomic_dec(&qr->cmd->immed_queue_count); 555 list_del(&qr->qr_list); 556 kmem_cache_free(lio_qr_cache, qr); 557 } 558 spin_unlock_bh(&conn->immed_queue_lock); 559 560 if (atomic_read(&cmd->immed_queue_count)) { 561 pr_err("ITT: 0x%08x immed_queue_count: %d\n", 562 cmd->init_task_tag, 563 atomic_read(&cmd->immed_queue_count)); 564 } 565} 566 567void iscsit_add_cmd_to_response_queue( 568 struct iscsi_cmd *cmd, 569 struct iscsi_conn *conn, 570 u8 state) 571{ 572 struct iscsi_queue_req *qr; 573 574 qr = kmem_cache_zalloc(lio_qr_cache, GFP_ATOMIC); 575 if (!qr) { 576 pr_err("Unable to allocate memory for" 577 " struct iscsi_queue_req\n"); 578 return; 579 } 580 INIT_LIST_HEAD(&qr->qr_list); 581 qr->cmd = cmd; 582 qr->state = state; 583 584 spin_lock_bh(&conn->response_queue_lock); 585 list_add_tail(&qr->qr_list, &conn->response_queue_list); 586 atomic_inc(&cmd->response_queue_count); 587 spin_unlock_bh(&conn->response_queue_lock); 588 589 wake_up(&conn->queues_wq); 590} 591 592struct iscsi_queue_req *iscsit_get_cmd_from_response_queue(struct iscsi_conn *conn) 593{ 594 struct iscsi_queue_req *qr; 595 596 spin_lock_bh(&conn->response_queue_lock); 597 if (list_empty(&conn->response_queue_list)) { 598 spin_unlock_bh(&conn->response_queue_lock); 599 return NULL; 600 } 601 602 qr = list_first_entry(&conn->response_queue_list, 603 struct iscsi_queue_req, qr_list); 604 605 list_del(&qr->qr_list); 606 if (qr->cmd) 607 atomic_dec(&qr->cmd->response_queue_count); 608 spin_unlock_bh(&conn->response_queue_lock); 609 610 return qr; 611} 612 613static void iscsit_remove_cmd_from_response_queue( 614 struct iscsi_cmd *cmd, 615 struct iscsi_conn *conn) 616{ 617 struct iscsi_queue_req *qr, *qr_tmp; 618 619 spin_lock_bh(&conn->response_queue_lock); 620 if (!atomic_read(&cmd->response_queue_count)) { 621 spin_unlock_bh(&conn->response_queue_lock); 622 return; 623 } 624 625 list_for_each_entry_safe(qr, qr_tmp, &conn->response_queue_list, 626 qr_list) { 627 if (qr->cmd != cmd) 628 continue; 629 630 atomic_dec(&qr->cmd->response_queue_count); 631 list_del(&qr->qr_list); 632 kmem_cache_free(lio_qr_cache, qr); 633 } 634 spin_unlock_bh(&conn->response_queue_lock); 635 636 if (atomic_read(&cmd->response_queue_count)) { 637 pr_err("ITT: 0x%08x response_queue_count: %d\n", 638 cmd->init_task_tag, 639 atomic_read(&cmd->response_queue_count)); 640 } 641} 642 643bool iscsit_conn_all_queues_empty(struct iscsi_conn *conn) 644{ 645 bool empty; 646 647 spin_lock_bh(&conn->immed_queue_lock); 648 empty = list_empty(&conn->immed_queue_list); 649 spin_unlock_bh(&conn->immed_queue_lock); 650 651 if (!empty) 652 return empty; 653 654 spin_lock_bh(&conn->response_queue_lock); 655 empty = list_empty(&conn->response_queue_list); 656 spin_unlock_bh(&conn->response_queue_lock); 657 658 return empty; 659} 660 661void iscsit_free_queue_reqs_for_conn(struct iscsi_conn *conn) 662{ 663 struct iscsi_queue_req *qr, *qr_tmp; 664 665 spin_lock_bh(&conn->immed_queue_lock); 666 list_for_each_entry_safe(qr, qr_tmp, &conn->immed_queue_list, qr_list) { 667 list_del(&qr->qr_list); 668 if (qr->cmd) 669 atomic_dec(&qr->cmd->immed_queue_count); 670 671 kmem_cache_free(lio_qr_cache, qr); 672 } 673 spin_unlock_bh(&conn->immed_queue_lock); 674 675 spin_lock_bh(&conn->response_queue_lock); 676 list_for_each_entry_safe(qr, qr_tmp, &conn->response_queue_list, 677 qr_list) { 678 list_del(&qr->qr_list); 679 if (qr->cmd) 680 atomic_dec(&qr->cmd->response_queue_count); 681 682 kmem_cache_free(lio_qr_cache, qr); 683 } 684 spin_unlock_bh(&conn->response_queue_lock); 685} 686 687void iscsit_release_cmd(struct iscsi_cmd *cmd) 688{ 689 struct iscsi_session *sess; 690 struct se_cmd *se_cmd = &cmd->se_cmd; 691 692 if (cmd->conn) 693 sess = cmd->conn->sess; 694 else 695 sess = cmd->sess; 696 697 BUG_ON(!sess || !sess->se_sess); 698 699 kfree(cmd->buf_ptr); 700 kfree(cmd->pdu_list); 701 kfree(cmd->seq_list); 702 kfree(cmd->tmr_req); 703 kfree(cmd->iov_data); 704 kfree(cmd->text_in_ptr); 705 706 percpu_ida_free(&sess->se_sess->sess_tag_pool, se_cmd->map_tag); 707} 708EXPORT_SYMBOL(iscsit_release_cmd); 709 710void __iscsit_free_cmd(struct iscsi_cmd *cmd, bool scsi_cmd, 711 bool check_queues) 712{ 713 struct iscsi_conn *conn = cmd->conn; 714 715 if (scsi_cmd) { 716 if (cmd->data_direction == DMA_TO_DEVICE) { 717 iscsit_stop_dataout_timer(cmd); 718 iscsit_free_r2ts_from_list(cmd); 719 } 720 if (cmd->data_direction == DMA_FROM_DEVICE) 721 iscsit_free_all_datain_reqs(cmd); 722 } 723 724 if (conn && check_queues) { 725 iscsit_remove_cmd_from_immediate_queue(cmd, conn); 726 iscsit_remove_cmd_from_response_queue(cmd, conn); 727 } 728} 729 730void iscsit_free_cmd(struct iscsi_cmd *cmd, bool shutdown) 731{ 732 struct se_cmd *se_cmd = NULL; 733 int rc; 734 /* 735 * Determine if a struct se_cmd is associated with 736 * this struct iscsi_cmd. 737 */ 738 switch (cmd->iscsi_opcode) { 739 case ISCSI_OP_SCSI_CMD: 740 se_cmd = &cmd->se_cmd; 741 __iscsit_free_cmd(cmd, true, shutdown); 742 /* 743 * Fallthrough 744 */ 745 case ISCSI_OP_SCSI_TMFUNC: 746 rc = transport_generic_free_cmd(&cmd->se_cmd, shutdown); 747 if (!rc && shutdown && se_cmd && se_cmd->se_sess) { 748 __iscsit_free_cmd(cmd, true, shutdown); 749 target_put_sess_cmd(se_cmd); 750 } 751 break; 752 case ISCSI_OP_REJECT: 753 /* 754 * Handle special case for REJECT when iscsi_add_reject*() has 755 * overwritten the original iscsi_opcode assignment, and the 756 * associated cmd->se_cmd needs to be released. 757 */ 758 if (cmd->se_cmd.se_tfo != NULL) { 759 se_cmd = &cmd->se_cmd; 760 __iscsit_free_cmd(cmd, true, shutdown); 761 762 rc = transport_generic_free_cmd(&cmd->se_cmd, shutdown); 763 if (!rc && shutdown && se_cmd->se_sess) { 764 __iscsit_free_cmd(cmd, true, shutdown); 765 target_put_sess_cmd(se_cmd); 766 } 767 break; 768 } 769 /* Fall-through */ 770 default: 771 __iscsit_free_cmd(cmd, false, shutdown); 772 iscsit_release_cmd(cmd); 773 break; 774 } 775} 776 777int iscsit_check_session_usage_count(struct iscsi_session *sess) 778{ 779 spin_lock_bh(&sess->session_usage_lock); 780 if (sess->session_usage_count != 0) { 781 sess->session_waiting_on_uc = 1; 782 spin_unlock_bh(&sess->session_usage_lock); 783 if (in_interrupt()) 784 return 2; 785 786 wait_for_completion(&sess->session_waiting_on_uc_comp); 787 return 1; 788 } 789 spin_unlock_bh(&sess->session_usage_lock); 790 791 return 0; 792} 793 794void iscsit_dec_session_usage_count(struct iscsi_session *sess) 795{ 796 spin_lock_bh(&sess->session_usage_lock); 797 sess->session_usage_count--; 798 799 if (!sess->session_usage_count && sess->session_waiting_on_uc) 800 complete(&sess->session_waiting_on_uc_comp); 801 802 spin_unlock_bh(&sess->session_usage_lock); 803} 804 805void iscsit_inc_session_usage_count(struct iscsi_session *sess) 806{ 807 spin_lock_bh(&sess->session_usage_lock); 808 sess->session_usage_count++; 809 spin_unlock_bh(&sess->session_usage_lock); 810} 811 812/* 813 * Setup conn->if_marker and conn->of_marker values based upon 814 * the initial marker-less interval. (see iSCSI v19 A.2) 815 */ 816int iscsit_set_sync_and_steering_values(struct iscsi_conn *conn) 817{ 818 int login_ifmarker_count = 0, login_ofmarker_count = 0, next_marker = 0; 819 /* 820 * IFMarkInt and OFMarkInt are negotiated as 32-bit words. 821 */ 822 u32 IFMarkInt = (conn->conn_ops->IFMarkInt * 4); 823 u32 OFMarkInt = (conn->conn_ops->OFMarkInt * 4); 824 825 if (conn->conn_ops->OFMarker) { 826 /* 827 * Account for the first Login Command received not 828 * via iscsi_recv_msg(). 829 */ 830 conn->of_marker += ISCSI_HDR_LEN; 831 if (conn->of_marker <= OFMarkInt) { 832 conn->of_marker = (OFMarkInt - conn->of_marker); 833 } else { 834 login_ofmarker_count = (conn->of_marker / OFMarkInt); 835 next_marker = (OFMarkInt * (login_ofmarker_count + 1)) + 836 (login_ofmarker_count * MARKER_SIZE); 837 conn->of_marker = (next_marker - conn->of_marker); 838 } 839 conn->of_marker_offset = 0; 840 pr_debug("Setting OFMarker value to %u based on Initial" 841 " Markerless Interval.\n", conn->of_marker); 842 } 843 844 if (conn->conn_ops->IFMarker) { 845 if (conn->if_marker <= IFMarkInt) { 846 conn->if_marker = (IFMarkInt - conn->if_marker); 847 } else { 848 login_ifmarker_count = (conn->if_marker / IFMarkInt); 849 next_marker = (IFMarkInt * (login_ifmarker_count + 1)) + 850 (login_ifmarker_count * MARKER_SIZE); 851 conn->if_marker = (next_marker - conn->if_marker); 852 } 853 pr_debug("Setting IFMarker value to %u based on Initial" 854 " Markerless Interval.\n", conn->if_marker); 855 } 856 857 return 0; 858} 859 860struct iscsi_conn *iscsit_get_conn_from_cid(struct iscsi_session *sess, u16 cid) 861{ 862 struct iscsi_conn *conn; 863 864 spin_lock_bh(&sess->conn_lock); 865 list_for_each_entry(conn, &sess->sess_conn_list, conn_list) { 866 if ((conn->cid == cid) && 867 (conn->conn_state == TARG_CONN_STATE_LOGGED_IN)) { 868 iscsit_inc_conn_usage_count(conn); 869 spin_unlock_bh(&sess->conn_lock); 870 return conn; 871 } 872 } 873 spin_unlock_bh(&sess->conn_lock); 874 875 return NULL; 876} 877 878struct iscsi_conn *iscsit_get_conn_from_cid_rcfr(struct iscsi_session *sess, u16 cid) 879{ 880 struct iscsi_conn *conn; 881 882 spin_lock_bh(&sess->conn_lock); 883 list_for_each_entry(conn, &sess->sess_conn_list, conn_list) { 884 if (conn->cid == cid) { 885 iscsit_inc_conn_usage_count(conn); 886 spin_lock(&conn->state_lock); 887 atomic_set(&conn->connection_wait_rcfr, 1); 888 spin_unlock(&conn->state_lock); 889 spin_unlock_bh(&sess->conn_lock); 890 return conn; 891 } 892 } 893 spin_unlock_bh(&sess->conn_lock); 894 895 return NULL; 896} 897 898void iscsit_check_conn_usage_count(struct iscsi_conn *conn) 899{ 900 spin_lock_bh(&conn->conn_usage_lock); 901 if (conn->conn_usage_count != 0) { 902 conn->conn_waiting_on_uc = 1; 903 spin_unlock_bh(&conn->conn_usage_lock); 904 905 wait_for_completion(&conn->conn_waiting_on_uc_comp); 906 return; 907 } 908 spin_unlock_bh(&conn->conn_usage_lock); 909} 910 911void iscsit_dec_conn_usage_count(struct iscsi_conn *conn) 912{ 913 spin_lock_bh(&conn->conn_usage_lock); 914 conn->conn_usage_count--; 915 916 if (!conn->conn_usage_count && conn->conn_waiting_on_uc) 917 complete(&conn->conn_waiting_on_uc_comp); 918 919 spin_unlock_bh(&conn->conn_usage_lock); 920} 921 922void iscsit_inc_conn_usage_count(struct iscsi_conn *conn) 923{ 924 spin_lock_bh(&conn->conn_usage_lock); 925 conn->conn_usage_count++; 926 spin_unlock_bh(&conn->conn_usage_lock); 927} 928 929static int iscsit_add_nopin(struct iscsi_conn *conn, int want_response) 930{ 931 u8 state; 932 struct iscsi_cmd *cmd; 933 934 cmd = iscsit_allocate_cmd(conn, TASK_RUNNING); 935 if (!cmd) 936 return -1; 937 938 cmd->iscsi_opcode = ISCSI_OP_NOOP_IN; 939 state = (want_response) ? ISTATE_SEND_NOPIN_WANT_RESPONSE : 940 ISTATE_SEND_NOPIN_NO_RESPONSE; 941 cmd->init_task_tag = RESERVED_ITT; 942 cmd->targ_xfer_tag = (want_response) ? 943 session_get_next_ttt(conn->sess) : 0xFFFFFFFF; 944 spin_lock_bh(&conn->cmd_lock); 945 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list); 946 spin_unlock_bh(&conn->cmd_lock); 947 948 if (want_response) 949 iscsit_start_nopin_response_timer(conn); 950 iscsit_add_cmd_to_immediate_queue(cmd, conn, state); 951 952 return 0; 953} 954 955static void iscsit_handle_nopin_response_timeout(unsigned long data) 956{ 957 struct iscsi_conn *conn = (struct iscsi_conn *) data; 958 959 iscsit_inc_conn_usage_count(conn); 960 961 spin_lock_bh(&conn->nopin_timer_lock); 962 if (conn->nopin_response_timer_flags & ISCSI_TF_STOP) { 963 spin_unlock_bh(&conn->nopin_timer_lock); 964 iscsit_dec_conn_usage_count(conn); 965 return; 966 } 967 968 pr_debug("Did not receive response to NOPIN on CID: %hu on" 969 " SID: %u, failing connection.\n", conn->cid, 970 conn->sess->sid); 971 conn->nopin_response_timer_flags &= ~ISCSI_TF_RUNNING; 972 spin_unlock_bh(&conn->nopin_timer_lock); 973 974 { 975 struct iscsi_portal_group *tpg = conn->sess->tpg; 976 struct iscsi_tiqn *tiqn = tpg->tpg_tiqn; 977 978 if (tiqn) { 979 spin_lock_bh(&tiqn->sess_err_stats.lock); 980 strcpy(tiqn->sess_err_stats.last_sess_fail_rem_name, 981 conn->sess->sess_ops->InitiatorName); 982 tiqn->sess_err_stats.last_sess_failure_type = 983 ISCSI_SESS_ERR_CXN_TIMEOUT; 984 tiqn->sess_err_stats.cxn_timeout_errors++; 985 atomic_long_inc(&conn->sess->conn_timeout_errors); 986 spin_unlock_bh(&tiqn->sess_err_stats.lock); 987 } 988 } 989 990 iscsit_cause_connection_reinstatement(conn, 0); 991 iscsit_dec_conn_usage_count(conn); 992} 993 994void iscsit_mod_nopin_response_timer(struct iscsi_conn *conn) 995{ 996 struct iscsi_session *sess = conn->sess; 997 struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess); 998 999 spin_lock_bh(&conn->nopin_timer_lock); 1000 if (!(conn->nopin_response_timer_flags & ISCSI_TF_RUNNING)) { 1001 spin_unlock_bh(&conn->nopin_timer_lock); 1002 return; 1003 } 1004 1005 mod_timer(&conn->nopin_response_timer, 1006 (get_jiffies_64() + na->nopin_response_timeout * HZ)); 1007 spin_unlock_bh(&conn->nopin_timer_lock); 1008} 1009 1010/* 1011 * Called with conn->nopin_timer_lock held. 1012 */ 1013void iscsit_start_nopin_response_timer(struct iscsi_conn *conn) 1014{ 1015 struct iscsi_session *sess = conn->sess; 1016 struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess); 1017 1018 spin_lock_bh(&conn->nopin_timer_lock); 1019 if (conn->nopin_response_timer_flags & ISCSI_TF_RUNNING) { 1020 spin_unlock_bh(&conn->nopin_timer_lock); 1021 return; 1022 } 1023 1024 init_timer(&conn->nopin_response_timer); 1025 conn->nopin_response_timer.expires = 1026 (get_jiffies_64() + na->nopin_response_timeout * HZ); 1027 conn->nopin_response_timer.data = (unsigned long)conn; 1028 conn->nopin_response_timer.function = iscsit_handle_nopin_response_timeout; 1029 conn->nopin_response_timer_flags &= ~ISCSI_TF_STOP; 1030 conn->nopin_response_timer_flags |= ISCSI_TF_RUNNING; 1031 add_timer(&conn->nopin_response_timer); 1032 1033 pr_debug("Started NOPIN Response Timer on CID: %d to %u" 1034 " seconds\n", conn->cid, na->nopin_response_timeout); 1035 spin_unlock_bh(&conn->nopin_timer_lock); 1036} 1037 1038void iscsit_stop_nopin_response_timer(struct iscsi_conn *conn) 1039{ 1040 spin_lock_bh(&conn->nopin_timer_lock); 1041 if (!(conn->nopin_response_timer_flags & ISCSI_TF_RUNNING)) { 1042 spin_unlock_bh(&conn->nopin_timer_lock); 1043 return; 1044 } 1045 conn->nopin_response_timer_flags |= ISCSI_TF_STOP; 1046 spin_unlock_bh(&conn->nopin_timer_lock); 1047 1048 del_timer_sync(&conn->nopin_response_timer); 1049 1050 spin_lock_bh(&conn->nopin_timer_lock); 1051 conn->nopin_response_timer_flags &= ~ISCSI_TF_RUNNING; 1052 spin_unlock_bh(&conn->nopin_timer_lock); 1053} 1054 1055static void iscsit_handle_nopin_timeout(unsigned long data) 1056{ 1057 struct iscsi_conn *conn = (struct iscsi_conn *) data; 1058 1059 iscsit_inc_conn_usage_count(conn); 1060 1061 spin_lock_bh(&conn->nopin_timer_lock); 1062 if (conn->nopin_timer_flags & ISCSI_TF_STOP) { 1063 spin_unlock_bh(&conn->nopin_timer_lock); 1064 iscsit_dec_conn_usage_count(conn); 1065 return; 1066 } 1067 conn->nopin_timer_flags &= ~ISCSI_TF_RUNNING; 1068 spin_unlock_bh(&conn->nopin_timer_lock); 1069 1070 iscsit_add_nopin(conn, 1); 1071 iscsit_dec_conn_usage_count(conn); 1072} 1073 1074/* 1075 * Called with conn->nopin_timer_lock held. 1076 */ 1077void __iscsit_start_nopin_timer(struct iscsi_conn *conn) 1078{ 1079 struct iscsi_session *sess = conn->sess; 1080 struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess); 1081 /* 1082 * NOPIN timeout is disabled. 1083 */ 1084 if (!na->nopin_timeout) 1085 return; 1086 1087 if (conn->nopin_timer_flags & ISCSI_TF_RUNNING) 1088 return; 1089 1090 init_timer(&conn->nopin_timer); 1091 conn->nopin_timer.expires = (get_jiffies_64() + na->nopin_timeout * HZ); 1092 conn->nopin_timer.data = (unsigned long)conn; 1093 conn->nopin_timer.function = iscsit_handle_nopin_timeout; 1094 conn->nopin_timer_flags &= ~ISCSI_TF_STOP; 1095 conn->nopin_timer_flags |= ISCSI_TF_RUNNING; 1096 add_timer(&conn->nopin_timer); 1097 1098 pr_debug("Started NOPIN Timer on CID: %d at %u second" 1099 " interval\n", conn->cid, na->nopin_timeout); 1100} 1101 1102void iscsit_start_nopin_timer(struct iscsi_conn *conn) 1103{ 1104 struct iscsi_session *sess = conn->sess; 1105 struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess); 1106 /* 1107 * NOPIN timeout is disabled.. 1108 */ 1109 if (!na->nopin_timeout) 1110 return; 1111 1112 spin_lock_bh(&conn->nopin_timer_lock); 1113 if (conn->nopin_timer_flags & ISCSI_TF_RUNNING) { 1114 spin_unlock_bh(&conn->nopin_timer_lock); 1115 return; 1116 } 1117 1118 init_timer(&conn->nopin_timer); 1119 conn->nopin_timer.expires = (get_jiffies_64() + na->nopin_timeout * HZ); 1120 conn->nopin_timer.data = (unsigned long)conn; 1121 conn->nopin_timer.function = iscsit_handle_nopin_timeout; 1122 conn->nopin_timer_flags &= ~ISCSI_TF_STOP; 1123 conn->nopin_timer_flags |= ISCSI_TF_RUNNING; 1124 add_timer(&conn->nopin_timer); 1125 1126 pr_debug("Started NOPIN Timer on CID: %d at %u second" 1127 " interval\n", conn->cid, na->nopin_timeout); 1128 spin_unlock_bh(&conn->nopin_timer_lock); 1129} 1130 1131void iscsit_stop_nopin_timer(struct iscsi_conn *conn) 1132{ 1133 spin_lock_bh(&conn->nopin_timer_lock); 1134 if (!(conn->nopin_timer_flags & ISCSI_TF_RUNNING)) { 1135 spin_unlock_bh(&conn->nopin_timer_lock); 1136 return; 1137 } 1138 conn->nopin_timer_flags |= ISCSI_TF_STOP; 1139 spin_unlock_bh(&conn->nopin_timer_lock); 1140 1141 del_timer_sync(&conn->nopin_timer); 1142 1143 spin_lock_bh(&conn->nopin_timer_lock); 1144 conn->nopin_timer_flags &= ~ISCSI_TF_RUNNING; 1145 spin_unlock_bh(&conn->nopin_timer_lock); 1146} 1147 1148int iscsit_send_tx_data( 1149 struct iscsi_cmd *cmd, 1150 struct iscsi_conn *conn, 1151 int use_misc) 1152{ 1153 int tx_sent, tx_size; 1154 u32 iov_count; 1155 struct kvec *iov; 1156 1157send_data: 1158 tx_size = cmd->tx_size; 1159 1160 if (!use_misc) { 1161 iov = &cmd->iov_data[0]; 1162 iov_count = cmd->iov_data_count; 1163 } else { 1164 iov = &cmd->iov_misc[0]; 1165 iov_count = cmd->iov_misc_count; 1166 } 1167 1168 tx_sent = tx_data(conn, &iov[0], iov_count, tx_size); 1169 if (tx_size != tx_sent) { 1170 if (tx_sent == -EAGAIN) { 1171 pr_err("tx_data() returned -EAGAIN\n"); 1172 goto send_data; 1173 } else 1174 return -1; 1175 } 1176 cmd->tx_size = 0; 1177 1178 return 0; 1179} 1180 1181int iscsit_fe_sendpage_sg( 1182 struct iscsi_cmd *cmd, 1183 struct iscsi_conn *conn) 1184{ 1185 struct scatterlist *sg = cmd->first_data_sg; 1186 struct kvec iov; 1187 u32 tx_hdr_size, data_len; 1188 u32 offset = cmd->first_data_sg_off; 1189 int tx_sent, iov_off; 1190 1191send_hdr: 1192 tx_hdr_size = ISCSI_HDR_LEN; 1193 if (conn->conn_ops->HeaderDigest) 1194 tx_hdr_size += ISCSI_CRC_LEN; 1195 1196 iov.iov_base = cmd->pdu; 1197 iov.iov_len = tx_hdr_size; 1198 1199 tx_sent = tx_data(conn, &iov, 1, tx_hdr_size); 1200 if (tx_hdr_size != tx_sent) { 1201 if (tx_sent == -EAGAIN) { 1202 pr_err("tx_data() returned -EAGAIN\n"); 1203 goto send_hdr; 1204 } 1205 return -1; 1206 } 1207 1208 data_len = cmd->tx_size - tx_hdr_size - cmd->padding; 1209 /* 1210 * Set iov_off used by padding and data digest tx_data() calls below 1211 * in order to determine proper offset into cmd->iov_data[] 1212 */ 1213 if (conn->conn_ops->DataDigest) { 1214 data_len -= ISCSI_CRC_LEN; 1215 if (cmd->padding) 1216 iov_off = (cmd->iov_data_count - 2); 1217 else 1218 iov_off = (cmd->iov_data_count - 1); 1219 } else { 1220 iov_off = (cmd->iov_data_count - 1); 1221 } 1222 /* 1223 * Perform sendpage() for each page in the scatterlist 1224 */ 1225 while (data_len) { 1226 u32 space = (sg->length - offset); 1227 u32 sub_len = min_t(u32, data_len, space); 1228send_pg: 1229 tx_sent = conn->sock->ops->sendpage(conn->sock, 1230 sg_page(sg), sg->offset + offset, sub_len, 0); 1231 if (tx_sent != sub_len) { 1232 if (tx_sent == -EAGAIN) { 1233 pr_err("tcp_sendpage() returned" 1234 " -EAGAIN\n"); 1235 goto send_pg; 1236 } 1237 1238 pr_err("tcp_sendpage() failure: %d\n", 1239 tx_sent); 1240 return -1; 1241 } 1242 1243 data_len -= sub_len; 1244 offset = 0; 1245 sg = sg_next(sg); 1246 } 1247 1248send_padding: 1249 if (cmd->padding) { 1250 struct kvec *iov_p = &cmd->iov_data[iov_off++]; 1251 1252 tx_sent = tx_data(conn, iov_p, 1, cmd->padding); 1253 if (cmd->padding != tx_sent) { 1254 if (tx_sent == -EAGAIN) { 1255 pr_err("tx_data() returned -EAGAIN\n"); 1256 goto send_padding; 1257 } 1258 return -1; 1259 } 1260 } 1261 1262send_datacrc: 1263 if (conn->conn_ops->DataDigest) { 1264 struct kvec *iov_d = &cmd->iov_data[iov_off]; 1265 1266 tx_sent = tx_data(conn, iov_d, 1, ISCSI_CRC_LEN); 1267 if (ISCSI_CRC_LEN != tx_sent) { 1268 if (tx_sent == -EAGAIN) { 1269 pr_err("tx_data() returned -EAGAIN\n"); 1270 goto send_datacrc; 1271 } 1272 return -1; 1273 } 1274 } 1275 1276 return 0; 1277} 1278 1279/* 1280 * This function is used for mainly sending a ISCSI_TARG_LOGIN_RSP PDU 1281 * back to the Initiator when an expection condition occurs with the 1282 * errors set in status_class and status_detail. 1283 * 1284 * Parameters: iSCSI Connection, Status Class, Status Detail. 1285 * Returns: 0 on success, -1 on error. 1286 */ 1287int iscsit_tx_login_rsp(struct iscsi_conn *conn, u8 status_class, u8 status_detail) 1288{ 1289 struct iscsi_login_rsp *hdr; 1290 struct iscsi_login *login = conn->conn_login; 1291 1292 login->login_failed = 1; 1293 iscsit_collect_login_stats(conn, status_class, status_detail); 1294 1295 memset(&login->rsp[0], 0, ISCSI_HDR_LEN); 1296 1297 hdr = (struct iscsi_login_rsp *)&login->rsp[0]; 1298 hdr->opcode = ISCSI_OP_LOGIN_RSP; 1299 hdr->status_class = status_class; 1300 hdr->status_detail = status_detail; 1301 hdr->itt = conn->login_itt; 1302 1303 return conn->conn_transport->iscsit_put_login_tx(conn, login, 0); 1304} 1305 1306void iscsit_print_session_params(struct iscsi_session *sess) 1307{ 1308 struct iscsi_conn *conn; 1309 1310 pr_debug("-----------------------------[Session Params for" 1311 " SID: %u]-----------------------------\n", sess->sid); 1312 spin_lock_bh(&sess->conn_lock); 1313 list_for_each_entry(conn, &sess->sess_conn_list, conn_list) 1314 iscsi_dump_conn_ops(conn->conn_ops); 1315 spin_unlock_bh(&sess->conn_lock); 1316 1317 iscsi_dump_sess_ops(sess->sess_ops); 1318} 1319 1320static int iscsit_do_rx_data( 1321 struct iscsi_conn *conn, 1322 struct iscsi_data_count *count) 1323{ 1324 int data = count->data_length, rx_loop = 0, total_rx = 0; 1325 struct msghdr msg; 1326 1327 if (!conn || !conn->sock || !conn->conn_ops) 1328 return -1; 1329 1330 memset(&msg, 0, sizeof(struct msghdr)); 1331 iov_iter_kvec(&msg.msg_iter, READ | ITER_KVEC, 1332 count->iov, count->iov_count, data); 1333 1334 while (total_rx < data) { 1335 rx_loop = sock_recvmsg(conn->sock, &msg, 1336 (data - total_rx), MSG_WAITALL); 1337 if (rx_loop <= 0) { 1338 pr_debug("rx_loop: %d total_rx: %d\n", 1339 rx_loop, total_rx); 1340 return rx_loop; 1341 } 1342 total_rx += rx_loop; 1343 pr_debug("rx_loop: %d, total_rx: %d, data: %d\n", 1344 rx_loop, total_rx, data); 1345 } 1346 1347 return total_rx; 1348} 1349 1350static int iscsit_do_tx_data( 1351 struct iscsi_conn *conn, 1352 struct iscsi_data_count *count) 1353{ 1354 int ret, iov_len; 1355 struct kvec *iov_p; 1356 struct msghdr msg; 1357 1358 if (!conn || !conn->sock || !conn->conn_ops) 1359 return -1; 1360 1361 if (count->data_length <= 0) { 1362 pr_err("Data length is: %d\n", count->data_length); 1363 return -1; 1364 } 1365 1366 memset(&msg, 0, sizeof(struct msghdr)); 1367 1368 iov_p = count->iov; 1369 iov_len = count->iov_count; 1370 1371 ret = kernel_sendmsg(conn->sock, &msg, iov_p, iov_len, 1372 count->data_length); 1373 if (ret != count->data_length) { 1374 pr_err("Unexpected ret: %d send data %d\n", 1375 ret, count->data_length); 1376 return -EPIPE; 1377 } 1378 pr_debug("ret: %d, sent data: %d\n", ret, count->data_length); 1379 1380 return ret; 1381} 1382 1383int rx_data( 1384 struct iscsi_conn *conn, 1385 struct kvec *iov, 1386 int iov_count, 1387 int data) 1388{ 1389 struct iscsi_data_count c; 1390 1391 if (!conn || !conn->sock || !conn->conn_ops) 1392 return -1; 1393 1394 memset(&c, 0, sizeof(struct iscsi_data_count)); 1395 c.iov = iov; 1396 c.iov_count = iov_count; 1397 c.data_length = data; 1398 c.type = ISCSI_RX_DATA; 1399 1400 return iscsit_do_rx_data(conn, &c); 1401} 1402 1403int tx_data( 1404 struct iscsi_conn *conn, 1405 struct kvec *iov, 1406 int iov_count, 1407 int data) 1408{ 1409 struct iscsi_data_count c; 1410 1411 if (!conn || !conn->sock || !conn->conn_ops) 1412 return -1; 1413 1414 memset(&c, 0, sizeof(struct iscsi_data_count)); 1415 c.iov = iov; 1416 c.iov_count = iov_count; 1417 c.data_length = data; 1418 c.type = ISCSI_TX_DATA; 1419 1420 return iscsit_do_tx_data(conn, &c); 1421} 1422 1423void iscsit_collect_login_stats( 1424 struct iscsi_conn *conn, 1425 u8 status_class, 1426 u8 status_detail) 1427{ 1428 struct iscsi_param *intrname = NULL; 1429 struct iscsi_tiqn *tiqn; 1430 struct iscsi_login_stats *ls; 1431 1432 tiqn = iscsit_snmp_get_tiqn(conn); 1433 if (!tiqn) 1434 return; 1435 1436 ls = &tiqn->login_stats; 1437 1438 spin_lock(&ls->lock); 1439 if (!strcmp(conn->login_ip, ls->last_intr_fail_ip_addr) && 1440 ((get_jiffies_64() - ls->last_fail_time) < 10)) { 1441 /* We already have the failure info for this login */ 1442 spin_unlock(&ls->lock); 1443 return; 1444 } 1445 1446 if (status_class == ISCSI_STATUS_CLS_SUCCESS) 1447 ls->accepts++; 1448 else if (status_class == ISCSI_STATUS_CLS_REDIRECT) { 1449 ls->redirects++; 1450 ls->last_fail_type = ISCSI_LOGIN_FAIL_REDIRECT; 1451 } else if ((status_class == ISCSI_STATUS_CLS_INITIATOR_ERR) && 1452 (status_detail == ISCSI_LOGIN_STATUS_AUTH_FAILED)) { 1453 ls->authenticate_fails++; 1454 ls->last_fail_type = ISCSI_LOGIN_FAIL_AUTHENTICATE; 1455 } else if ((status_class == ISCSI_STATUS_CLS_INITIATOR_ERR) && 1456 (status_detail == ISCSI_LOGIN_STATUS_TGT_FORBIDDEN)) { 1457 ls->authorize_fails++; 1458 ls->last_fail_type = ISCSI_LOGIN_FAIL_AUTHORIZE; 1459 } else if ((status_class == ISCSI_STATUS_CLS_INITIATOR_ERR) && 1460 (status_detail == ISCSI_LOGIN_STATUS_INIT_ERR)) { 1461 ls->negotiate_fails++; 1462 ls->last_fail_type = ISCSI_LOGIN_FAIL_NEGOTIATE; 1463 } else { 1464 ls->other_fails++; 1465 ls->last_fail_type = ISCSI_LOGIN_FAIL_OTHER; 1466 } 1467 1468 /* Save initiator name, ip address and time, if it is a failed login */ 1469 if (status_class != ISCSI_STATUS_CLS_SUCCESS) { 1470 if (conn->param_list) 1471 intrname = iscsi_find_param_from_key(INITIATORNAME, 1472 conn->param_list); 1473 strlcpy(ls->last_intr_fail_name, 1474 (intrname ? intrname->value : "Unknown"), 1475 sizeof(ls->last_intr_fail_name)); 1476 1477 ls->last_intr_fail_ip_family = conn->login_family; 1478 1479 snprintf(ls->last_intr_fail_ip_addr, IPV6_ADDRESS_SPACE, 1480 "%s", conn->login_ip); 1481 ls->last_fail_time = get_jiffies_64(); 1482 } 1483 1484 spin_unlock(&ls->lock); 1485} 1486 1487struct iscsi_tiqn *iscsit_snmp_get_tiqn(struct iscsi_conn *conn) 1488{ 1489 struct iscsi_portal_group *tpg; 1490 1491 if (!conn || !conn->sess) 1492 return NULL; 1493 1494 tpg = conn->sess->tpg; 1495 if (!tpg) 1496 return NULL; 1497 1498 if (!tpg->tpg_tiqn) 1499 return NULL; 1500 1501 return tpg->tpg_tiqn; 1502} 1503