17996a778SMike Christie /* 27996a778SMike Christie * iSCSI lib functions 37996a778SMike Christie * 47996a778SMike Christie * Copyright (C) 2006 Red Hat, Inc. All rights reserved. 57996a778SMike Christie * Copyright (C) 2004 - 2006 Mike Christie 67996a778SMike Christie * Copyright (C) 2004 - 2005 Dmitry Yusupov 77996a778SMike Christie * Copyright (C) 2004 - 2005 Alex Aizman 87996a778SMike Christie * maintained by open-iscsi@googlegroups.com 97996a778SMike Christie * 107996a778SMike Christie * This program is free software; you can redistribute it and/or modify 117996a778SMike Christie * it under the terms of the GNU General Public License as published by 127996a778SMike Christie * the Free Software Foundation; either version 2 of the License, or 137996a778SMike Christie * (at your option) any later version. 147996a778SMike Christie * 157996a778SMike Christie * This program is distributed in the hope that it will be useful, 167996a778SMike Christie * but WITHOUT ANY WARRANTY; without even the implied warranty of 177996a778SMike Christie * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 187996a778SMike Christie * GNU General Public License for more details. 197996a778SMike Christie * 207996a778SMike Christie * You should have received a copy of the GNU General Public License 217996a778SMike Christie * along with this program; if not, write to the Free Software 227996a778SMike Christie * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 237996a778SMike Christie */ 247996a778SMike Christie #include <linux/types.h> 257996a778SMike Christie #include <linux/kfifo.h> 267996a778SMike Christie #include <linux/delay.h> 2711836572Svignesh babu #include <linux/log2.h> 288eb00539SMike Christie #include <asm/unaligned.h> 297996a778SMike Christie #include <net/tcp.h> 307996a778SMike Christie #include <scsi/scsi_cmnd.h> 317996a778SMike Christie #include <scsi/scsi_device.h> 327996a778SMike Christie #include <scsi/scsi_eh.h> 337996a778SMike Christie #include <scsi/scsi_tcq.h> 347996a778SMike Christie #include <scsi/scsi_host.h> 357996a778SMike Christie #include <scsi/scsi.h> 367996a778SMike Christie #include <scsi/iscsi_proto.h> 377996a778SMike Christie #include <scsi/scsi_transport.h> 387996a778SMike Christie #include <scsi/scsi_transport_iscsi.h> 397996a778SMike Christie #include <scsi/libiscsi.h> 407996a778SMike Christie 4177a23c21SMike Christie /* Serial Number Arithmetic, 32 bits, less than, RFC1982 */ 4277a23c21SMike Christie #define SNA32_CHECK 2147483648UL 437996a778SMike Christie 4477a23c21SMike Christie static int iscsi_sna_lt(u32 n1, u32 n2) 4577a23c21SMike Christie { 4677a23c21SMike Christie return n1 != n2 && ((n1 < n2 && (n2 - n1 < SNA32_CHECK)) || 4777a23c21SMike Christie (n1 > n2 && (n2 - n1 < SNA32_CHECK))); 4877a23c21SMike Christie } 4977a23c21SMike Christie 5077a23c21SMike Christie /* Serial Number Arithmetic, 32 bits, less than, RFC1982 */ 5177a23c21SMike Christie static int iscsi_sna_lte(u32 n1, u32 n2) 5277a23c21SMike Christie { 5377a23c21SMike Christie return n1 == n2 || ((n1 < n2 && (n2 - n1 < SNA32_CHECK)) || 5477a23c21SMike Christie (n1 > n2 && (n2 - n1 < SNA32_CHECK))); 5577a23c21SMike Christie } 5677a23c21SMike Christie 5777a23c21SMike Christie void 5877a23c21SMike Christie iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr) 597996a778SMike Christie { 607996a778SMike Christie uint32_t max_cmdsn = be32_to_cpu(hdr->max_cmdsn); 617996a778SMike Christie uint32_t exp_cmdsn = be32_to_cpu(hdr->exp_cmdsn); 627996a778SMike Christie 6377a23c21SMike Christie /* 6477a23c21SMike Christie * standard specifies this check for when to update expected and 6577a23c21SMike Christie * max sequence numbers 6677a23c21SMike Christie */ 6777a23c21SMike Christie if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1)) 6877a23c21SMike Christie return; 6977a23c21SMike Christie 7077a23c21SMike Christie if (exp_cmdsn != session->exp_cmdsn && 7177a23c21SMike Christie !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn)) 727996a778SMike Christie session->exp_cmdsn = exp_cmdsn; 737996a778SMike Christie 7477a23c21SMike Christie if (max_cmdsn != session->max_cmdsn && 7577a23c21SMike Christie !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) { 7677a23c21SMike Christie session->max_cmdsn = max_cmdsn; 7777a23c21SMike Christie /* 7877a23c21SMike Christie * if the window closed with IO queued, then kick the 7977a23c21SMike Christie * xmit thread 8077a23c21SMike Christie */ 8177a23c21SMike Christie if (!list_empty(&session->leadconn->xmitqueue) || 82052d0144SMike Christie !list_empty(&session->leadconn->mgmtqueue)) { 83052d0144SMike Christie if (!(session->tt->caps & CAP_DATA_PATH_OFFLOAD)) 8477a23c21SMike Christie scsi_queue_work(session->host, 8577a23c21SMike Christie &session->leadconn->xmitwork); 867996a778SMike Christie } 8777a23c21SMike Christie } 88052d0144SMike Christie } 8977a23c21SMike Christie EXPORT_SYMBOL_GPL(iscsi_update_cmdsn); 907996a778SMike Christie 919c19a7d0SMike Christie void iscsi_prep_unsolicit_data_pdu(struct iscsi_task *task, 92ffd0436eSMike Christie struct iscsi_data *hdr) 937996a778SMike Christie { 949c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 957996a778SMike Christie 967996a778SMike Christie memset(hdr, 0, sizeof(struct iscsi_data)); 977996a778SMike Christie hdr->ttt = cpu_to_be32(ISCSI_RESERVED_TAG); 989c19a7d0SMike Christie hdr->datasn = cpu_to_be32(task->unsol_datasn); 999c19a7d0SMike Christie task->unsol_datasn++; 1007996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_DATA_OUT; 1019c19a7d0SMike Christie memcpy(hdr->lun, task->hdr->lun, sizeof(hdr->lun)); 1027996a778SMike Christie 1039c19a7d0SMike Christie hdr->itt = task->hdr->itt; 1047996a778SMike Christie hdr->exp_statsn = cpu_to_be32(conn->exp_statsn); 1059c19a7d0SMike Christie hdr->offset = cpu_to_be32(task->unsol_offset); 1067996a778SMike Christie 1079c19a7d0SMike Christie if (task->unsol_count > conn->max_xmit_dlength) { 1087996a778SMike Christie hton24(hdr->dlength, conn->max_xmit_dlength); 1099c19a7d0SMike Christie task->data_count = conn->max_xmit_dlength; 1109c19a7d0SMike Christie task->unsol_offset += task->data_count; 1117996a778SMike Christie hdr->flags = 0; 1127996a778SMike Christie } else { 1139c19a7d0SMike Christie hton24(hdr->dlength, task->unsol_count); 1149c19a7d0SMike Christie task->data_count = task->unsol_count; 1157996a778SMike Christie hdr->flags = ISCSI_FLAG_CMD_FINAL; 1167996a778SMike Christie } 1177996a778SMike Christie } 1187996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_prep_unsolicit_data_pdu); 1197996a778SMike Christie 1209c19a7d0SMike Christie static int iscsi_add_hdr(struct iscsi_task *task, unsigned len) 121004d6530SBoaz Harrosh { 1229c19a7d0SMike Christie unsigned exp_len = task->hdr_len + len; 123004d6530SBoaz Harrosh 1249c19a7d0SMike Christie if (exp_len > task->hdr_max) { 125004d6530SBoaz Harrosh WARN_ON(1); 126004d6530SBoaz Harrosh return -EINVAL; 127004d6530SBoaz Harrosh } 128004d6530SBoaz Harrosh 129004d6530SBoaz Harrosh WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */ 1309c19a7d0SMike Christie task->hdr_len = exp_len; 131004d6530SBoaz Harrosh return 0; 132004d6530SBoaz Harrosh } 133004d6530SBoaz Harrosh 13438d1c069SBoaz Harrosh /* 13538d1c069SBoaz Harrosh * make an extended cdb AHS 13638d1c069SBoaz Harrosh */ 1379c19a7d0SMike Christie static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) 13838d1c069SBoaz Harrosh { 1399c19a7d0SMike Christie struct scsi_cmnd *cmd = task->sc; 14038d1c069SBoaz Harrosh unsigned rlen, pad_len; 14138d1c069SBoaz Harrosh unsigned short ahslength; 14238d1c069SBoaz Harrosh struct iscsi_ecdb_ahdr *ecdb_ahdr; 14338d1c069SBoaz Harrosh int rc; 14438d1c069SBoaz Harrosh 1459c19a7d0SMike Christie ecdb_ahdr = iscsi_next_hdr(task); 14638d1c069SBoaz Harrosh rlen = cmd->cmd_len - ISCSI_CDB_SIZE; 14738d1c069SBoaz Harrosh 14838d1c069SBoaz Harrosh BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb)); 14938d1c069SBoaz Harrosh ahslength = rlen + sizeof(ecdb_ahdr->reserved); 15038d1c069SBoaz Harrosh 15138d1c069SBoaz Harrosh pad_len = iscsi_padding(rlen); 15238d1c069SBoaz Harrosh 1539c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) + 15438d1c069SBoaz Harrosh sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len); 15538d1c069SBoaz Harrosh if (rc) 15638d1c069SBoaz Harrosh return rc; 15738d1c069SBoaz Harrosh 15838d1c069SBoaz Harrosh if (pad_len) 15938d1c069SBoaz Harrosh memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len); 16038d1c069SBoaz Harrosh 16138d1c069SBoaz Harrosh ecdb_ahdr->ahslength = cpu_to_be16(ahslength); 16238d1c069SBoaz Harrosh ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB; 16338d1c069SBoaz Harrosh ecdb_ahdr->reserved = 0; 16438d1c069SBoaz Harrosh memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen); 16538d1c069SBoaz Harrosh 16638d1c069SBoaz Harrosh debug_scsi("iscsi_prep_ecdb_ahs: varlen_cdb_len %d " 16738d1c069SBoaz Harrosh "rlen %d pad_len %d ahs_length %d iscsi_headers_size %u\n", 1689c19a7d0SMike Christie cmd->cmd_len, rlen, pad_len, ahslength, task->hdr_len); 16938d1c069SBoaz Harrosh 17038d1c069SBoaz Harrosh return 0; 17138d1c069SBoaz Harrosh } 17238d1c069SBoaz Harrosh 1739c19a7d0SMike Christie static int iscsi_prep_bidi_ahs(struct iscsi_task *task) 174c07d4444SBoaz Harrosh { 1759c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 176c07d4444SBoaz Harrosh struct iscsi_rlength_ahdr *rlen_ahdr; 177c07d4444SBoaz Harrosh int rc; 178c07d4444SBoaz Harrosh 1799c19a7d0SMike Christie rlen_ahdr = iscsi_next_hdr(task); 1809c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*rlen_ahdr)); 181c07d4444SBoaz Harrosh if (rc) 182c07d4444SBoaz Harrosh return rc; 183c07d4444SBoaz Harrosh 184c07d4444SBoaz Harrosh rlen_ahdr->ahslength = 185c07d4444SBoaz Harrosh cpu_to_be16(sizeof(rlen_ahdr->read_length) + 186c07d4444SBoaz Harrosh sizeof(rlen_ahdr->reserved)); 187c07d4444SBoaz Harrosh rlen_ahdr->ahstype = ISCSI_AHSTYPE_RLENGTH; 188c07d4444SBoaz Harrosh rlen_ahdr->reserved = 0; 189c07d4444SBoaz Harrosh rlen_ahdr->read_length = cpu_to_be32(scsi_in(sc)->length); 190c07d4444SBoaz Harrosh 191c07d4444SBoaz Harrosh debug_scsi("bidi-in rlen_ahdr->read_length(%d) " 192c07d4444SBoaz Harrosh "rlen_ahdr->ahslength(%d)\n", 193c07d4444SBoaz Harrosh be32_to_cpu(rlen_ahdr->read_length), 194c07d4444SBoaz Harrosh be16_to_cpu(rlen_ahdr->ahslength)); 195c07d4444SBoaz Harrosh return 0; 196c07d4444SBoaz Harrosh } 197c07d4444SBoaz Harrosh 1987996a778SMike Christie /** 1997996a778SMike Christie * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu 2009c19a7d0SMike Christie * @task: iscsi task 2017996a778SMike Christie * 2027996a778SMike Christie * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set 2037996a778SMike Christie * fields like dlength or final based on how much data it sends 2047996a778SMike Christie */ 2059c19a7d0SMike Christie static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task) 2067996a778SMike Christie { 2079c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 2087996a778SMike Christie struct iscsi_session *session = conn->session; 2099c19a7d0SMike Christie struct iscsi_cmd *hdr = task->hdr; 2109c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 21138d1c069SBoaz Harrosh unsigned hdrlength, cmd_len; 212004d6530SBoaz Harrosh int rc; 2137996a778SMike Christie 2149c19a7d0SMike Christie task->hdr_len = 0; 2159c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*hdr)); 216004d6530SBoaz Harrosh if (rc) 217004d6530SBoaz Harrosh return rc; 2187996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_CMD; 2197996a778SMike Christie hdr->flags = ISCSI_ATTR_SIMPLE; 2207996a778SMike Christie int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun); 2219c19a7d0SMike Christie hdr->itt = build_itt(task->itt, session->age); 2227996a778SMike Christie hdr->cmdsn = cpu_to_be32(session->cmdsn); 2237996a778SMike Christie session->cmdsn++; 2247996a778SMike Christie hdr->exp_statsn = cpu_to_be32(conn->exp_statsn); 22538d1c069SBoaz Harrosh cmd_len = sc->cmd_len; 22638d1c069SBoaz Harrosh if (cmd_len < ISCSI_CDB_SIZE) 22738d1c069SBoaz Harrosh memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len); 22838d1c069SBoaz Harrosh else if (cmd_len > ISCSI_CDB_SIZE) { 2299c19a7d0SMike Christie rc = iscsi_prep_ecdb_ahs(task); 23038d1c069SBoaz Harrosh if (rc) 23138d1c069SBoaz Harrosh return rc; 23238d1c069SBoaz Harrosh cmd_len = ISCSI_CDB_SIZE; 23338d1c069SBoaz Harrosh } 23438d1c069SBoaz Harrosh memcpy(hdr->cdb, sc->cmnd, cmd_len); 2357996a778SMike Christie 2369c19a7d0SMike Christie task->imm_count = 0; 237c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc)) { 238c07d4444SBoaz Harrosh hdr->flags |= ISCSI_FLAG_CMD_READ; 2399c19a7d0SMike Christie rc = iscsi_prep_bidi_ahs(task); 240c07d4444SBoaz Harrosh if (rc) 241c07d4444SBoaz Harrosh return rc; 242c07d4444SBoaz Harrosh } 2437996a778SMike Christie if (sc->sc_data_direction == DMA_TO_DEVICE) { 244c07d4444SBoaz Harrosh unsigned out_len = scsi_out(sc)->length; 245c07d4444SBoaz Harrosh hdr->data_length = cpu_to_be32(out_len); 2467996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_WRITE; 2477996a778SMike Christie /* 2487996a778SMike Christie * Write counters: 2497996a778SMike Christie * 2507996a778SMike Christie * imm_count bytes to be sent right after 2517996a778SMike Christie * SCSI PDU Header 2527996a778SMike Christie * 2537996a778SMike Christie * unsol_count bytes(as Data-Out) to be sent 2547996a778SMike Christie * without R2T ack right after 2557996a778SMike Christie * immediate data 2567996a778SMike Christie * 2577996a778SMike Christie * r2t_data_count bytes to be sent via R2T ack's 2587996a778SMike Christie * 2597996a778SMike Christie * pad_count bytes to be sent as zero-padding 2607996a778SMike Christie */ 2619c19a7d0SMike Christie task->unsol_count = 0; 2629c19a7d0SMike Christie task->unsol_offset = 0; 2639c19a7d0SMike Christie task->unsol_datasn = 0; 2647996a778SMike Christie 2657996a778SMike Christie if (session->imm_data_en) { 266c07d4444SBoaz Harrosh if (out_len >= session->first_burst) 2679c19a7d0SMike Christie task->imm_count = min(session->first_burst, 2687996a778SMike Christie conn->max_xmit_dlength); 2697996a778SMike Christie else 2709c19a7d0SMike Christie task->imm_count = min(out_len, 2717996a778SMike Christie conn->max_xmit_dlength); 2729c19a7d0SMike Christie hton24(hdr->dlength, task->imm_count); 2737996a778SMike Christie } else 274a8ac6311SOlaf Kirch zero_data(hdr->dlength); 2757996a778SMike Christie 276ffd0436eSMike Christie if (!session->initial_r2t_en) { 2779c19a7d0SMike Christie task->unsol_count = min(session->first_burst, out_len) 2789c19a7d0SMike Christie - task->imm_count; 2799c19a7d0SMike Christie task->unsol_offset = task->imm_count; 280ffd0436eSMike Christie } 281ffd0436eSMike Christie 2829c19a7d0SMike Christie if (!task->unsol_count) 2837996a778SMike Christie /* No unsolicit Data-Out's */ 284a8ac6311SOlaf Kirch hdr->flags |= ISCSI_FLAG_CMD_FINAL; 2857996a778SMike Christie } else { 2867996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 2877996a778SMike Christie zero_data(hdr->dlength); 288c07d4444SBoaz Harrosh hdr->data_length = cpu_to_be32(scsi_in(sc)->length); 2897996a778SMike Christie 2907996a778SMike Christie if (sc->sc_data_direction == DMA_FROM_DEVICE) 2917996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_READ; 2927996a778SMike Christie } 2937996a778SMike Christie 294004d6530SBoaz Harrosh /* calculate size of additional header segments (AHSs) */ 2959c19a7d0SMike Christie hdrlength = task->hdr_len - sizeof(*hdr); 296004d6530SBoaz Harrosh 297004d6530SBoaz Harrosh WARN_ON(hdrlength & (ISCSI_PAD_LEN-1)); 298004d6530SBoaz Harrosh hdrlength /= ISCSI_PAD_LEN; 299004d6530SBoaz Harrosh 300004d6530SBoaz Harrosh WARN_ON(hdrlength >= 256); 301004d6530SBoaz Harrosh hdr->hlength = hdrlength & 0xFF; 302004d6530SBoaz Harrosh 3033e5c28adSMike Christie if (conn->session->tt->init_task && 3049c19a7d0SMike Christie conn->session->tt->init_task(task)) 305052d0144SMike Christie return -EIO; 306052d0144SMike Christie 3079c19a7d0SMike Christie task->state = ISCSI_TASK_RUNNING; 3089c19a7d0SMike Christie list_move_tail(&task->running, &conn->run_list); 30977a23c21SMike Christie 310a8ac6311SOlaf Kirch conn->scsicmd_pdus_cnt++; 3113e5c28adSMike Christie debug_scsi("iscsi prep [%s cid %d sc %p cdb 0x%x itt 0x%x len %d " 3123e5c28adSMike Christie "bidi_len %d cmdsn %d win %d]\n", scsi_bidi_cmnd(sc) ? 3133e5c28adSMike Christie "bidirectional" : sc->sc_data_direction == DMA_TO_DEVICE ? 3149c19a7d0SMike Christie "write" : "read", conn->id, sc, sc->cmnd[0], task->itt, 3153e5c28adSMike Christie scsi_bufflen(sc), 3163e5c28adSMike Christie scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0, 31777a23c21SMike Christie session->cmdsn, session->max_cmdsn - session->exp_cmdsn + 1); 318004d6530SBoaz Harrosh return 0; 3197996a778SMike Christie } 3207996a778SMike Christie 3217996a778SMike Christie /** 3223e5c28adSMike Christie * iscsi_complete_command - finish a task 3239c19a7d0SMike Christie * @task: iscsi cmd task 3247996a778SMike Christie * 3257996a778SMike Christie * Must be called with session lock. 3263e5c28adSMike Christie * This function returns the scsi command to scsi-ml or cleans 3273e5c28adSMike Christie * up mgmt tasks then returns the task to the pool. 3287996a778SMike Christie */ 3299c19a7d0SMike Christie static void iscsi_complete_command(struct iscsi_task *task) 3307996a778SMike Christie { 3319c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 332c1635cb7SMike Christie struct iscsi_session *session = conn->session; 3339c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 3347996a778SMike Christie 3359c19a7d0SMike Christie list_del_init(&task->running); 3369c19a7d0SMike Christie task->state = ISCSI_TASK_COMPLETED; 3379c19a7d0SMike Christie task->sc = NULL; 3383e5c28adSMike Christie 3399c19a7d0SMike Christie if (conn->task == task) 3409c19a7d0SMike Christie conn->task = NULL; 3413e5c28adSMike Christie /* 3429c19a7d0SMike Christie * login task is preallocated so do not free 3433e5c28adSMike Christie */ 3449c19a7d0SMike Christie if (conn->login_task == task) 3453e5c28adSMike Christie return; 3463e5c28adSMike Christie 3479c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&task, sizeof(void*)); 3483e5c28adSMike Christie 3499c19a7d0SMike Christie if (conn->ping_task == task) 3509c19a7d0SMike Christie conn->ping_task = NULL; 3513e5c28adSMike Christie 3523e5c28adSMike Christie if (sc) { 3539c19a7d0SMike Christie task->sc = NULL; 354f47f2cf5SMike Christie /* SCSI eh reuses commands to verify us */ 355f47f2cf5SMike Christie sc->SCp.ptr = NULL; 3563e5c28adSMike Christie /* 3573e5c28adSMike Christie * queue command may call this to free the task, but 3583e5c28adSMike Christie * not have setup the sc callback 3593e5c28adSMike Christie */ 360052d0144SMike Christie if (sc->scsi_done) 3617996a778SMike Christie sc->scsi_done(sc); 3627996a778SMike Christie } 3633e5c28adSMike Christie } 3647996a778SMike Christie 365913e5bf4SMike Christie void __iscsi_get_task(struct iscsi_task *task) 36660ecebf5SMike Christie { 3679c19a7d0SMike Christie atomic_inc(&task->refcount); 36860ecebf5SMike Christie } 369913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_get_task); 37060ecebf5SMike Christie 3719c19a7d0SMike Christie static void __iscsi_put_task(struct iscsi_task *task) 37260ecebf5SMike Christie { 3739c19a7d0SMike Christie if (atomic_dec_and_test(&task->refcount)) 3749c19a7d0SMike Christie iscsi_complete_command(task); 37560ecebf5SMike Christie } 37660ecebf5SMike Christie 3779c19a7d0SMike Christie void iscsi_put_task(struct iscsi_task *task) 3783e5c28adSMike Christie { 3799c19a7d0SMike Christie struct iscsi_session *session = task->conn->session; 3803e5c28adSMike Christie 3813e5c28adSMike Christie spin_lock_bh(&session->lock); 3829c19a7d0SMike Christie __iscsi_put_task(task); 3833e5c28adSMike Christie spin_unlock_bh(&session->lock); 3843e5c28adSMike Christie } 3859c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_put_task); 3863e5c28adSMike Christie 387b3a7ea8dSMike Christie /* 388b3a7ea8dSMike Christie * session lock must be held 389b3a7ea8dSMike Christie */ 3909c19a7d0SMike Christie static void fail_command(struct iscsi_conn *conn, struct iscsi_task *task, 391b3a7ea8dSMike Christie int err) 392b3a7ea8dSMike Christie { 393b3a7ea8dSMike Christie struct scsi_cmnd *sc; 394b3a7ea8dSMike Christie 3959c19a7d0SMike Christie sc = task->sc; 396b3a7ea8dSMike Christie if (!sc) 397b3a7ea8dSMike Christie return; 398b3a7ea8dSMike Christie 3999c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) 400b3a7ea8dSMike Christie /* 401b3a7ea8dSMike Christie * cmd never made it to the xmit thread, so we should not count 402b3a7ea8dSMike Christie * the cmd in the sequencing 403b3a7ea8dSMike Christie */ 404b3a7ea8dSMike Christie conn->session->queued_cmdsn--; 405b3a7ea8dSMike Christie else 4069c19a7d0SMike Christie conn->session->tt->cleanup_task(conn, task); 407b3a7ea8dSMike Christie 408b3a7ea8dSMike Christie sc->result = err; 409c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 410b3a7ea8dSMike Christie scsi_set_resid(sc, scsi_bufflen(sc)); 411c07d4444SBoaz Harrosh else { 412c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 413c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 414c07d4444SBoaz Harrosh } 4153e5c28adSMike Christie 4169c19a7d0SMike Christie if (conn->task == task) 4179c19a7d0SMike Christie conn->task = NULL; 418b3a7ea8dSMike Christie /* release ref from queuecommand */ 4199c19a7d0SMike Christie __iscsi_put_task(task); 420b3a7ea8dSMike Christie } 421b3a7ea8dSMike Christie 4223e5c28adSMike Christie static int iscsi_prep_mgmt_task(struct iscsi_conn *conn, 4239c19a7d0SMike Christie struct iscsi_task *task) 424052d0144SMike Christie { 425052d0144SMike Christie struct iscsi_session *session = conn->session; 4269c19a7d0SMike Christie struct iscsi_hdr *hdr = (struct iscsi_hdr *)task->hdr; 427052d0144SMike Christie struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr; 428052d0144SMike Christie 429052d0144SMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 430052d0144SMike Christie return -ENOTCONN; 431052d0144SMike Christie 432052d0144SMike Christie if (hdr->opcode != (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) && 433052d0144SMike Christie hdr->opcode != (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE)) 434052d0144SMike Christie nop->exp_statsn = cpu_to_be32(conn->exp_statsn); 435052d0144SMike Christie /* 436052d0144SMike Christie * pre-format CmdSN for outgoing PDU. 437052d0144SMike Christie */ 438052d0144SMike Christie nop->cmdsn = cpu_to_be32(session->cmdsn); 439052d0144SMike Christie if (hdr->itt != RESERVED_ITT) { 4409c19a7d0SMike Christie hdr->itt = build_itt(task->itt, session->age); 441052d0144SMike Christie /* 442052d0144SMike Christie * TODO: We always use immediate, so we never hit this. 443052d0144SMike Christie * If we start to send tmfs or nops as non-immediate then 444052d0144SMike Christie * we should start checking the cmdsn numbers for mgmt tasks. 445052d0144SMike Christie */ 446052d0144SMike Christie if (conn->c_stage == ISCSI_CONN_STARTED && 447052d0144SMike Christie !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 448052d0144SMike Christie session->queued_cmdsn++; 449052d0144SMike Christie session->cmdsn++; 450052d0144SMike Christie } 451052d0144SMike Christie } 452052d0144SMike Christie 4533e5c28adSMike Christie if (session->tt->init_task) 4549c19a7d0SMike Christie session->tt->init_task(task); 455052d0144SMike Christie 456052d0144SMike Christie if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT) 457052d0144SMike Christie session->state = ISCSI_STATE_LOGGING_OUT; 458052d0144SMike Christie 4599c19a7d0SMike Christie list_move_tail(&task->running, &conn->mgmt_run_list); 460052d0144SMike Christie debug_scsi("mgmtpdu [op 0x%x hdr->itt 0x%x datalen %d]\n", 461052d0144SMike Christie hdr->opcode & ISCSI_OPCODE_MASK, hdr->itt, 4629c19a7d0SMike Christie task->data_count); 463052d0144SMike Christie return 0; 464052d0144SMike Christie } 465052d0144SMike Christie 4669c19a7d0SMike Christie static struct iscsi_task * 467f6d5180cSMike Christie __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 468f6d5180cSMike Christie char *data, uint32_t data_size) 469f6d5180cSMike Christie { 470f6d5180cSMike Christie struct iscsi_session *session = conn->session; 4719c19a7d0SMike Christie struct iscsi_task *task; 472f6d5180cSMike Christie 473f6d5180cSMike Christie if (session->state == ISCSI_STATE_TERMINATE) 474f6d5180cSMike Christie return NULL; 475f6d5180cSMike Christie 476f6d5180cSMike Christie if (hdr->opcode == (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) || 477f6d5180cSMike Christie hdr->opcode == (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE)) 478f6d5180cSMike Christie /* 479f6d5180cSMike Christie * Login and Text are sent serially, in 480f6d5180cSMike Christie * request-followed-by-response sequence. 4813e5c28adSMike Christie * Same task can be used. Same ITT must be used. 4823e5c28adSMike Christie * Note that login_task is preallocated at conn_create(). 483f6d5180cSMike Christie */ 4849c19a7d0SMike Christie task = conn->login_task; 485f6d5180cSMike Christie else { 486f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE); 487f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED); 488f6d5180cSMike Christie 4893e5c28adSMike Christie if (!__kfifo_get(session->cmdpool.queue, 4909c19a7d0SMike Christie (void*)&task, sizeof(void*))) 491f6d5180cSMike Christie return NULL; 492052d0144SMike Christie 493052d0144SMike Christie if ((hdr->opcode == (ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE)) && 494052d0144SMike Christie hdr->ttt == RESERVED_ITT) { 4959c19a7d0SMike Christie conn->ping_task = task; 496052d0144SMike Christie conn->last_ping = jiffies; 497052d0144SMike Christie } 498f6d5180cSMike Christie } 4993e5c28adSMike Christie /* 5003e5c28adSMike Christie * released in complete pdu for task we expect a response for, and 5013e5c28adSMike Christie * released by the lld when it has transmitted the task for 5023e5c28adSMike Christie * pdus we do not expect a response for. 5033e5c28adSMike Christie */ 5049c19a7d0SMike Christie atomic_set(&task->refcount, 1); 5059c19a7d0SMike Christie task->conn = conn; 5069c19a7d0SMike Christie task->sc = NULL; 507f6d5180cSMike Christie 508f6d5180cSMike Christie if (data_size) { 5099c19a7d0SMike Christie memcpy(task->data, data, data_size); 5109c19a7d0SMike Christie task->data_count = data_size; 511f6d5180cSMike Christie } else 5129c19a7d0SMike Christie task->data_count = 0; 513f6d5180cSMike Christie 5149c19a7d0SMike Christie memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr)); 5159c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 5169c19a7d0SMike Christie list_add_tail(&task->running, &conn->mgmtqueue); 517052d0144SMike Christie 518052d0144SMike Christie if (session->tt->caps & CAP_DATA_PATH_OFFLOAD) { 5199c19a7d0SMike Christie if (iscsi_prep_mgmt_task(conn, task)) { 5209c19a7d0SMike Christie __iscsi_put_task(task); 521052d0144SMike Christie return NULL; 522052d0144SMike Christie } 523052d0144SMike Christie 5249c19a7d0SMike Christie if (session->tt->xmit_task(task)) 5259c19a7d0SMike Christie task = NULL; 526052d0144SMike Christie 527052d0144SMike Christie } else 528052d0144SMike Christie scsi_queue_work(conn->session->host, &conn->xmitwork); 529052d0144SMike Christie 5309c19a7d0SMike Christie return task; 531f6d5180cSMike Christie } 532f6d5180cSMike Christie 533f6d5180cSMike Christie int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr, 534f6d5180cSMike Christie char *data, uint32_t data_size) 535f6d5180cSMike Christie { 536f6d5180cSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 537f6d5180cSMike Christie struct iscsi_session *session = conn->session; 538f6d5180cSMike Christie int err = 0; 539f6d5180cSMike Christie 540f6d5180cSMike Christie spin_lock_bh(&session->lock); 541f6d5180cSMike Christie if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size)) 542f6d5180cSMike Christie err = -EPERM; 543f6d5180cSMike Christie spin_unlock_bh(&session->lock); 544f6d5180cSMike Christie return err; 545f6d5180cSMike Christie } 546f6d5180cSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu); 547f6d5180cSMike Christie 5487996a778SMike Christie /** 5497996a778SMike Christie * iscsi_cmd_rsp - SCSI Command Response processing 5507996a778SMike Christie * @conn: iscsi connection 5517996a778SMike Christie * @hdr: iscsi header 5529c19a7d0SMike Christie * @task: scsi command task 5537996a778SMike Christie * @data: cmd data buffer 5547996a778SMike Christie * @datalen: len of buffer 5557996a778SMike Christie * 5567996a778SMike Christie * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and 5579c19a7d0SMike Christie * then completes the command and task. 5587996a778SMike Christie **/ 55977a23c21SMike Christie static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 5609c19a7d0SMike Christie struct iscsi_task *task, char *data, 5617996a778SMike Christie int datalen) 5627996a778SMike Christie { 5637996a778SMike Christie struct iscsi_cmd_rsp *rhdr = (struct iscsi_cmd_rsp *)hdr; 5647996a778SMike Christie struct iscsi_session *session = conn->session; 5659c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 5667996a778SMike Christie 56777a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr); 5687996a778SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 5697996a778SMike Christie 5707996a778SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 5717996a778SMike Christie 5727996a778SMike Christie if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) { 5737996a778SMike Christie sc->result = DID_ERROR << 16; 5747996a778SMike Christie goto out; 5757996a778SMike Christie } 5767996a778SMike Christie 5777996a778SMike Christie if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) { 5789b80cb4bSMike Christie uint16_t senselen; 5797996a778SMike Christie 5807996a778SMike Christie if (datalen < 2) { 5817996a778SMike Christie invalid_datalen: 582322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 583322d739dSMike Christie "Got CHECK_CONDITION but invalid data " 584322d739dSMike Christie "buffer size of %d\n", datalen); 5857996a778SMike Christie sc->result = DID_BAD_TARGET << 16; 5867996a778SMike Christie goto out; 5877996a778SMike Christie } 5887996a778SMike Christie 5898f333991SHarvey Harrison senselen = get_unaligned_be16(data); 5907996a778SMike Christie if (datalen < senselen) 5917996a778SMike Christie goto invalid_datalen; 5927996a778SMike Christie 5937996a778SMike Christie memcpy(sc->sense_buffer, data + 2, 5949b80cb4bSMike Christie min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 5957996a778SMike Christie debug_scsi("copied %d bytes of sense\n", 5968eb00539SMike Christie min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 5977996a778SMike Christie } 5987996a778SMike Christie 599c07d4444SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW | 600c07d4444SBoaz Harrosh ISCSI_FLAG_CMD_BIDI_OVERFLOW)) { 601c07d4444SBoaz Harrosh int res_count = be32_to_cpu(rhdr->bi_residual_count); 602c07d4444SBoaz Harrosh 603c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc) && res_count > 0 && 604c07d4444SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_BIDI_OVERFLOW || 605c07d4444SBoaz Harrosh res_count <= scsi_in(sc)->length)) 606c07d4444SBoaz Harrosh scsi_in(sc)->resid = res_count; 607c07d4444SBoaz Harrosh else 608c07d4444SBoaz Harrosh sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 609c07d4444SBoaz Harrosh } 610c07d4444SBoaz Harrosh 6117207fea4SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW | 6127207fea4SBoaz Harrosh ISCSI_FLAG_CMD_OVERFLOW)) { 6137996a778SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 6147996a778SMike Christie 6157207fea4SBoaz Harrosh if (res_count > 0 && 6167207fea4SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 6177207fea4SBoaz Harrosh res_count <= scsi_bufflen(sc))) 618c07d4444SBoaz Harrosh /* write side for bidi or uni-io set_resid */ 6191c138991SFUJITA Tomonori scsi_set_resid(sc, res_count); 6207996a778SMike Christie else 6217996a778SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 622c07d4444SBoaz Harrosh } 6237996a778SMike Christie out: 6247996a778SMike Christie debug_scsi("done [sc %lx res %d itt 0x%x]\n", 6259c19a7d0SMike Christie (long)sc, sc->result, task->itt); 6267996a778SMike Christie conn->scsirsp_pdus_cnt++; 6277996a778SMike Christie 6289c19a7d0SMike Christie __iscsi_put_task(task); 6297996a778SMike Christie } 6307996a778SMike Christie 6311d9edf02SMike Christie /** 6321d9edf02SMike Christie * iscsi_data_in_rsp - SCSI Data-In Response processing 6331d9edf02SMike Christie * @conn: iscsi connection 6341d9edf02SMike Christie * @hdr: iscsi pdu 6351d9edf02SMike Christie * @task: scsi command task 6361d9edf02SMike Christie **/ 6371d9edf02SMike Christie static void 6381d9edf02SMike Christie iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 6391d9edf02SMike Christie struct iscsi_task *task) 6401d9edf02SMike Christie { 6411d9edf02SMike Christie struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr; 6421d9edf02SMike Christie struct scsi_cmnd *sc = task->sc; 6431d9edf02SMike Christie 6441d9edf02SMike Christie if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS)) 6451d9edf02SMike Christie return; 6461d9edf02SMike Christie 6471d9edf02SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 6481d9edf02SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 6491d9edf02SMike Christie if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW | 6501d9edf02SMike Christie ISCSI_FLAG_DATA_OVERFLOW)) { 6511d9edf02SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 6521d9edf02SMike Christie 6531d9edf02SMike Christie if (res_count > 0 && 6541d9edf02SMike Christie (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 6551d9edf02SMike Christie res_count <= scsi_in(sc)->length)) 6561d9edf02SMike Christie scsi_in(sc)->resid = res_count; 6571d9edf02SMike Christie else 6581d9edf02SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 6591d9edf02SMike Christie } 6601d9edf02SMike Christie 6611d9edf02SMike Christie conn->scsirsp_pdus_cnt++; 6621d9edf02SMike Christie __iscsi_put_task(task); 6631d9edf02SMike Christie } 6641d9edf02SMike Christie 6657ea8b828SMike Christie static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) 6667ea8b828SMike Christie { 6677ea8b828SMike Christie struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; 6687ea8b828SMike Christie 6697ea8b828SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 6707ea8b828SMike Christie conn->tmfrsp_pdus_cnt++; 6717ea8b828SMike Christie 672843c0a8aSMike Christie if (conn->tmf_state != TMF_QUEUED) 6737ea8b828SMike Christie return; 6747ea8b828SMike Christie 6757ea8b828SMike Christie if (tmf->response == ISCSI_TMF_RSP_COMPLETE) 676843c0a8aSMike Christie conn->tmf_state = TMF_SUCCESS; 6777ea8b828SMike Christie else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) 678843c0a8aSMike Christie conn->tmf_state = TMF_NOT_FOUND; 6797ea8b828SMike Christie else 680843c0a8aSMike Christie conn->tmf_state = TMF_FAILED; 6817ea8b828SMike Christie wake_up(&conn->ehwait); 6827ea8b828SMike Christie } 6837ea8b828SMike Christie 684f6d5180cSMike Christie static void iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) 685f6d5180cSMike Christie { 686f6d5180cSMike Christie struct iscsi_nopout hdr; 6879c19a7d0SMike Christie struct iscsi_task *task; 688f6d5180cSMike Christie 6899c19a7d0SMike Christie if (!rhdr && conn->ping_task) 690f6d5180cSMike Christie return; 691f6d5180cSMike Christie 692f6d5180cSMike Christie memset(&hdr, 0, sizeof(struct iscsi_nopout)); 693f6d5180cSMike Christie hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE; 694f6d5180cSMike Christie hdr.flags = ISCSI_FLAG_CMD_FINAL; 695f6d5180cSMike Christie 696f6d5180cSMike Christie if (rhdr) { 697f6d5180cSMike Christie memcpy(hdr.lun, rhdr->lun, 8); 698f6d5180cSMike Christie hdr.ttt = rhdr->ttt; 699f6d5180cSMike Christie hdr.itt = RESERVED_ITT; 700f6d5180cSMike Christie } else 701f6d5180cSMike Christie hdr.ttt = RESERVED_ITT; 702f6d5180cSMike Christie 7039c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0); 7049c19a7d0SMike Christie if (!task) 705322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n"); 706f6d5180cSMike Christie } 707f6d5180cSMike Christie 70862f38300SMike Christie static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 70962f38300SMike Christie char *data, int datalen) 71062f38300SMike Christie { 71162f38300SMike Christie struct iscsi_reject *reject = (struct iscsi_reject *)hdr; 71262f38300SMike Christie struct iscsi_hdr rejected_pdu; 71362f38300SMike Christie uint32_t itt; 71462f38300SMike Christie 71562f38300SMike Christie conn->exp_statsn = be32_to_cpu(reject->statsn) + 1; 71662f38300SMike Christie 71762f38300SMike Christie if (reject->reason == ISCSI_REASON_DATA_DIGEST_ERROR) { 71862f38300SMike Christie if (ntoh24(reject->dlength) > datalen) 71962f38300SMike Christie return ISCSI_ERR_PROTO; 72062f38300SMike Christie 72162f38300SMike Christie if (ntoh24(reject->dlength) >= sizeof(struct iscsi_hdr)) { 72262f38300SMike Christie memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr)); 723b4377356SAl Viro itt = get_itt(rejected_pdu.itt); 724322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 725322d739dSMike Christie "itt 0x%x had pdu (op 0x%x) rejected " 72662f38300SMike Christie "due to DataDigest error.\n", itt, 72762f38300SMike Christie rejected_pdu.opcode); 72862f38300SMike Christie } 72962f38300SMike Christie } 73062f38300SMike Christie return 0; 73162f38300SMike Christie } 73262f38300SMike Christie 7337996a778SMike Christie /** 734913e5bf4SMike Christie * iscsi_itt_to_task - look up task by itt 735913e5bf4SMike Christie * @conn: iscsi connection 736913e5bf4SMike Christie * @itt: itt 737913e5bf4SMike Christie * 738913e5bf4SMike Christie * This should be used for mgmt tasks like login and nops, or if 739913e5bf4SMike Christie * the LDD's itt space does not include the session age. 740913e5bf4SMike Christie * 741913e5bf4SMike Christie * The session lock must be held. 742913e5bf4SMike Christie */ 743913e5bf4SMike Christie static struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt) 744913e5bf4SMike Christie { 745913e5bf4SMike Christie struct iscsi_session *session = conn->session; 746913e5bf4SMike Christie uint32_t i; 747913e5bf4SMike Christie 748913e5bf4SMike Christie if (itt == RESERVED_ITT) 749913e5bf4SMike Christie return NULL; 750913e5bf4SMike Christie 751913e5bf4SMike Christie i = get_itt(itt); 752913e5bf4SMike Christie if (i >= session->cmds_max) 753913e5bf4SMike Christie return NULL; 754913e5bf4SMike Christie 755913e5bf4SMike Christie return session->cmds[i]; 756913e5bf4SMike Christie } 757913e5bf4SMike Christie 758913e5bf4SMike Christie /** 7597996a778SMike Christie * __iscsi_complete_pdu - complete pdu 7607996a778SMike Christie * @conn: iscsi conn 7617996a778SMike Christie * @hdr: iscsi header 7627996a778SMike Christie * @data: data buffer 7637996a778SMike Christie * @datalen: len of data buffer 7647996a778SMike Christie * 7657996a778SMike Christie * Completes pdu processing by freeing any resources allocated at 7667996a778SMike Christie * queuecommand or send generic. session lock must be held and verify 7677996a778SMike Christie * itt must have been called. 7687996a778SMike Christie */ 769913e5bf4SMike Christie int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 7707996a778SMike Christie char *data, int datalen) 7717996a778SMike Christie { 7727996a778SMike Christie struct iscsi_session *session = conn->session; 7737996a778SMike Christie int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0; 7749c19a7d0SMike Christie struct iscsi_task *task; 7757996a778SMike Christie uint32_t itt; 7767996a778SMike Christie 777f6d5180cSMike Christie conn->last_recv = jiffies; 7780af967f5SMike Christie rc = iscsi_verify_itt(conn, hdr->itt); 7790af967f5SMike Christie if (rc) 7800af967f5SMike Christie return rc; 7810af967f5SMike Christie 782b4377356SAl Viro if (hdr->itt != RESERVED_ITT) 783b4377356SAl Viro itt = get_itt(hdr->itt); 7847996a778SMike Christie else 785b4377356SAl Viro itt = ~0U; 7867996a778SMike Christie 7873e5c28adSMike Christie debug_scsi("[op 0x%x cid %d itt 0x%x len %d]\n", 7883e5c28adSMike Christie opcode, conn->id, itt, datalen); 7897996a778SMike Christie 7903e5c28adSMike Christie if (itt == ~0U) { 79177a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 79262f38300SMike Christie 7937996a778SMike Christie switch(opcode) { 7947996a778SMike Christie case ISCSI_OP_NOOP_IN: 79540527afeSMike Christie if (datalen) { 79640527afeSMike Christie rc = ISCSI_ERR_PROTO; 79740527afeSMike Christie break; 79840527afeSMike Christie } 79940527afeSMike Christie 800b4377356SAl Viro if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) 80140527afeSMike Christie break; 80240527afeSMike Christie 803f6d5180cSMike Christie iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr); 8047996a778SMike Christie break; 8057996a778SMike Christie case ISCSI_OP_REJECT: 80662f38300SMike Christie rc = iscsi_handle_reject(conn, hdr, data, datalen); 80762f38300SMike Christie break; 8087996a778SMike Christie case ISCSI_OP_ASYNC_EVENT: 8098d2860b3SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 8105831c737SMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 8115831c737SMike Christie rc = ISCSI_ERR_CONN_FAILED; 8127996a778SMike Christie break; 8137996a778SMike Christie default: 8147996a778SMike Christie rc = ISCSI_ERR_BAD_OPCODE; 8157996a778SMike Christie break; 8167996a778SMike Christie } 8173e5c28adSMike Christie goto out; 8183e5c28adSMike Christie } 8197996a778SMike Christie 8203e5c28adSMike Christie switch(opcode) { 8213e5c28adSMike Christie case ISCSI_OP_SCSI_CMD_RSP: 822913e5bf4SMike Christie case ISCSI_OP_SCSI_DATA_IN: 823913e5bf4SMike Christie task = iscsi_itt_to_ctask(conn, hdr->itt); 824913e5bf4SMike Christie if (!task) 825913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 8263e5c28adSMike Christie break; 827913e5bf4SMike Christie case ISCSI_OP_R2T: 828913e5bf4SMike Christie /* 829913e5bf4SMike Christie * LLD handles R2Ts if they need to. 830913e5bf4SMike Christie */ 831913e5bf4SMike Christie return 0; 832913e5bf4SMike Christie case ISCSI_OP_LOGOUT_RSP: 833913e5bf4SMike Christie case ISCSI_OP_LOGIN_RSP: 834913e5bf4SMike Christie case ISCSI_OP_TEXT_RSP: 835913e5bf4SMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 836913e5bf4SMike Christie case ISCSI_OP_NOOP_IN: 837913e5bf4SMike Christie task = iscsi_itt_to_task(conn, hdr->itt); 838913e5bf4SMike Christie if (!task) 839913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 840913e5bf4SMike Christie break; 841913e5bf4SMike Christie default: 842913e5bf4SMike Christie return ISCSI_ERR_BAD_OPCODE; 8433e5c28adSMike Christie } 844913e5bf4SMike Christie 845913e5bf4SMike Christie switch(opcode) { 846913e5bf4SMike Christie case ISCSI_OP_SCSI_CMD_RSP: 8479c19a7d0SMike Christie iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen); 8483e5c28adSMike Christie break; 8493e5c28adSMike Christie case ISCSI_OP_SCSI_DATA_IN: 8501d9edf02SMike Christie iscsi_data_in_rsp(conn, hdr, task); 8513e5c28adSMike Christie break; 8523e5c28adSMike Christie case ISCSI_OP_LOGOUT_RSP: 8533e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 8543e5c28adSMike Christie if (datalen) { 8553e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 8563e5c28adSMike Christie break; 8573e5c28adSMike Christie } 8583e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 8593e5c28adSMike Christie goto recv_pdu; 8603e5c28adSMike Christie case ISCSI_OP_LOGIN_RSP: 8613e5c28adSMike Christie case ISCSI_OP_TEXT_RSP: 8623e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 8633e5c28adSMike Christie /* 8643e5c28adSMike Christie * login related PDU's exp_statsn is handled in 8653e5c28adSMike Christie * userspace 8663e5c28adSMike Christie */ 8673e5c28adSMike Christie goto recv_pdu; 8683e5c28adSMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 8693e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 8703e5c28adSMike Christie if (datalen) { 8713e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 8723e5c28adSMike Christie break; 8733e5c28adSMike Christie } 8743e5c28adSMike Christie 8753e5c28adSMike Christie iscsi_tmf_rsp(conn, hdr); 8769c19a7d0SMike Christie __iscsi_put_task(task); 8773e5c28adSMike Christie break; 8783e5c28adSMike Christie case ISCSI_OP_NOOP_IN: 8793e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 8803e5c28adSMike Christie if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) { 8813e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 8823e5c28adSMike Christie break; 8833e5c28adSMike Christie } 8843e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 8853e5c28adSMike Christie 8869c19a7d0SMike Christie if (conn->ping_task != task) 8873e5c28adSMike Christie /* 8883e5c28adSMike Christie * If this is not in response to one of our 8893e5c28adSMike Christie * nops then it must be from userspace. 8903e5c28adSMike Christie */ 8913e5c28adSMike Christie goto recv_pdu; 8929c19a7d0SMike Christie 8939c19a7d0SMike Christie mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout); 8949c19a7d0SMike Christie __iscsi_put_task(task); 8953e5c28adSMike Christie break; 8963e5c28adSMike Christie default: 8973e5c28adSMike Christie rc = ISCSI_ERR_BAD_OPCODE; 8983e5c28adSMike Christie break; 8993e5c28adSMike Christie } 9003e5c28adSMike Christie 9013e5c28adSMike Christie out: 9023e5c28adSMike Christie return rc; 9033e5c28adSMike Christie recv_pdu: 9043e5c28adSMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 9053e5c28adSMike Christie rc = ISCSI_ERR_CONN_FAILED; 9069c19a7d0SMike Christie __iscsi_put_task(task); 9077996a778SMike Christie return rc; 9087996a778SMike Christie } 909913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_complete_pdu); 9107996a778SMike Christie 9117996a778SMike Christie int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 9127996a778SMike Christie char *data, int datalen) 9137996a778SMike Christie { 9147996a778SMike Christie int rc; 9157996a778SMike Christie 9167996a778SMike Christie spin_lock(&conn->session->lock); 9177996a778SMike Christie rc = __iscsi_complete_pdu(conn, hdr, data, datalen); 9187996a778SMike Christie spin_unlock(&conn->session->lock); 9197996a778SMike Christie return rc; 9207996a778SMike Christie } 9217996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_pdu); 9227996a778SMike Christie 9230af967f5SMike Christie int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt) 9247996a778SMike Christie { 9257996a778SMike Christie struct iscsi_session *session = conn->session; 9263e5c28adSMike Christie uint32_t i; 9277996a778SMike Christie 9280af967f5SMike Christie if (itt == RESERVED_ITT) 9290af967f5SMike Christie return 0; 9300af967f5SMike Christie 9310af967f5SMike Christie if (((__force u32)itt & ISCSI_AGE_MASK) != 9327996a778SMike Christie (session->age << ISCSI_AGE_SHIFT)) { 933322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 9340af967f5SMike Christie "received itt %x expected session age (%x)\n", 935913e5bf4SMike Christie (__force u32)itt, session->age); 9367996a778SMike Christie return ISCSI_ERR_BAD_ITT; 9377996a778SMike Christie } 9387996a778SMike Christie 9393e5c28adSMike Christie i = get_itt(itt); 9403e5c28adSMike Christie if (i >= session->cmds_max) { 9413e5c28adSMike Christie iscsi_conn_printk(KERN_ERR, conn, 9423e5c28adSMike Christie "received invalid itt index %u (max cmds " 9433e5c28adSMike Christie "%u.\n", i, session->cmds_max); 9443e5c28adSMike Christie return ISCSI_ERR_BAD_ITT; 9457996a778SMike Christie } 9467996a778SMike Christie return 0; 9477996a778SMike Christie } 9487996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_verify_itt); 9497996a778SMike Christie 950913e5bf4SMike Christie /** 951913e5bf4SMike Christie * iscsi_itt_to_ctask - look up ctask by itt 952913e5bf4SMike Christie * @conn: iscsi connection 953913e5bf4SMike Christie * @itt: itt 954913e5bf4SMike Christie * 955913e5bf4SMike Christie * This should be used for cmd tasks. 956913e5bf4SMike Christie * 957913e5bf4SMike Christie * The session lock must be held. 958913e5bf4SMike Christie */ 959913e5bf4SMike Christie struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt) 9600af967f5SMike Christie { 9619c19a7d0SMike Christie struct iscsi_task *task; 9620af967f5SMike Christie 9630af967f5SMike Christie if (iscsi_verify_itt(conn, itt)) 9640af967f5SMike Christie return NULL; 9650af967f5SMike Christie 966913e5bf4SMike Christie task = iscsi_itt_to_task(conn, itt); 967913e5bf4SMike Christie if (!task || !task->sc) 9680af967f5SMike Christie return NULL; 9690af967f5SMike Christie 970913e5bf4SMike Christie if (task->sc->SCp.phase != conn->session->age) { 971913e5bf4SMike Christie iscsi_session_printk(KERN_ERR, conn->session, 972913e5bf4SMike Christie "task's session age %d, expected %d\n", 973913e5bf4SMike Christie task->sc->SCp.phase, conn->session->age); 9740af967f5SMike Christie return NULL; 975913e5bf4SMike Christie } 9760af967f5SMike Christie 9779c19a7d0SMike Christie return task; 9780af967f5SMike Christie } 9790af967f5SMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask); 9800af967f5SMike Christie 981e5bd7b54SMike Christie void iscsi_session_failure(struct iscsi_cls_session *cls_session, 982e5bd7b54SMike Christie enum iscsi_err err) 983e5bd7b54SMike Christie { 984e5bd7b54SMike Christie struct iscsi_session *session = cls_session->dd_data; 985e5bd7b54SMike Christie struct iscsi_conn *conn; 986e5bd7b54SMike Christie struct device *dev; 987e5bd7b54SMike Christie unsigned long flags; 988e5bd7b54SMike Christie 989e5bd7b54SMike Christie spin_lock_irqsave(&session->lock, flags); 990e5bd7b54SMike Christie conn = session->leadconn; 991e5bd7b54SMike Christie if (session->state == ISCSI_STATE_TERMINATE || !conn) { 992e5bd7b54SMike Christie spin_unlock_irqrestore(&session->lock, flags); 993e5bd7b54SMike Christie return; 994e5bd7b54SMike Christie } 995e5bd7b54SMike Christie 996e5bd7b54SMike Christie dev = get_device(&conn->cls_conn->dev); 997e5bd7b54SMike Christie spin_unlock_irqrestore(&session->lock, flags); 998e5bd7b54SMike Christie if (!dev) 999e5bd7b54SMike Christie return; 1000e5bd7b54SMike Christie /* 1001e5bd7b54SMike Christie * if the host is being removed bypass the connection 1002e5bd7b54SMike Christie * recovery initialization because we are going to kill 1003e5bd7b54SMike Christie * the session. 1004e5bd7b54SMike Christie */ 1005e5bd7b54SMike Christie if (err == ISCSI_ERR_INVALID_HOST) 1006e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 1007e5bd7b54SMike Christie else 1008e5bd7b54SMike Christie iscsi_conn_failure(conn, err); 1009e5bd7b54SMike Christie put_device(dev); 1010e5bd7b54SMike Christie } 1011e5bd7b54SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_failure); 1012e5bd7b54SMike Christie 10137996a778SMike Christie void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err) 10147996a778SMike Christie { 10157996a778SMike Christie struct iscsi_session *session = conn->session; 10167996a778SMike Christie unsigned long flags; 10177996a778SMike Christie 10187996a778SMike Christie spin_lock_irqsave(&session->lock, flags); 1019656cffc9SMike Christie if (session->state == ISCSI_STATE_FAILED) { 1020656cffc9SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1021656cffc9SMike Christie return; 1022656cffc9SMike Christie } 1023656cffc9SMike Christie 102467a61114SMike Christie if (conn->stop_stage == 0) 10257996a778SMike Christie session->state = ISCSI_STATE_FAILED; 10267996a778SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1027e5bd7b54SMike Christie 10287996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 10297996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 1030e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 10317996a778SMike Christie } 10327996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_failure); 10337996a778SMike Christie 103477a23c21SMike Christie static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn) 103577a23c21SMike Christie { 103677a23c21SMike Christie struct iscsi_session *session = conn->session; 103777a23c21SMike Christie 103877a23c21SMike Christie /* 103977a23c21SMike Christie * Check for iSCSI window and take care of CmdSN wrap-around 104077a23c21SMike Christie */ 1041e0726407SMike Christie if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) { 1042e0726407SMike Christie debug_scsi("iSCSI CmdSN closed. ExpCmdSn %u MaxCmdSN %u " 1043e0726407SMike Christie "CmdSN %u/%u\n", session->exp_cmdsn, 1044e0726407SMike Christie session->max_cmdsn, session->cmdsn, 1045e0726407SMike Christie session->queued_cmdsn); 104677a23c21SMike Christie return -ENOSPC; 104777a23c21SMike Christie } 104877a23c21SMike Christie return 0; 104977a23c21SMike Christie } 105077a23c21SMike Christie 10519c19a7d0SMike Christie static int iscsi_xmit_task(struct iscsi_conn *conn) 105277a23c21SMike Christie { 10539c19a7d0SMike Christie struct iscsi_task *task = conn->task; 1054843c0a8aSMike Christie int rc; 105577a23c21SMike Christie 10569c19a7d0SMike Christie __iscsi_get_task(task); 105777a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 10589c19a7d0SMike Christie rc = conn->session->tt->xmit_task(task); 105977a23c21SMike Christie spin_lock_bh(&conn->session->lock); 10609c19a7d0SMike Christie __iscsi_put_task(task); 106177a23c21SMike Christie if (!rc) 10629c19a7d0SMike Christie /* done with this task */ 10639c19a7d0SMike Christie conn->task = NULL; 106477a23c21SMike Christie return rc; 106577a23c21SMike Christie } 106677a23c21SMike Christie 10677996a778SMike Christie /** 10689c19a7d0SMike Christie * iscsi_requeue_task - requeue task to run from session workqueue 10699c19a7d0SMike Christie * @task: task to requeue 1070843c0a8aSMike Christie * 10719c19a7d0SMike Christie * LLDs that need to run a task from the session workqueue should call 1072052d0144SMike Christie * this. The session lock must be held. This should only be called 1073052d0144SMike Christie * by software drivers. 1074843c0a8aSMike Christie */ 10759c19a7d0SMike Christie void iscsi_requeue_task(struct iscsi_task *task) 1076843c0a8aSMike Christie { 10779c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 1078843c0a8aSMike Christie 10799c19a7d0SMike Christie list_move_tail(&task->running, &conn->requeue); 1080843c0a8aSMike Christie scsi_queue_work(conn->session->host, &conn->xmitwork); 1081843c0a8aSMike Christie } 10829c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_requeue_task); 1083843c0a8aSMike Christie 1084843c0a8aSMike Christie /** 10857996a778SMike Christie * iscsi_data_xmit - xmit any command into the scheduled connection 10867996a778SMike Christie * @conn: iscsi connection 10877996a778SMike Christie * 10887996a778SMike Christie * Notes: 10897996a778SMike Christie * The function can return -EAGAIN in which case the caller must 10907996a778SMike Christie * re-schedule it again later or recover. '0' return code means 10917996a778SMike Christie * successful xmit. 10927996a778SMike Christie **/ 10937996a778SMike Christie static int iscsi_data_xmit(struct iscsi_conn *conn) 10947996a778SMike Christie { 10953219e529SMike Christie int rc = 0; 10967996a778SMike Christie 109777a23c21SMike Christie spin_lock_bh(&conn->session->lock); 10987996a778SMike Christie if (unlikely(conn->suspend_tx)) { 10997996a778SMike Christie debug_scsi("conn %d Tx suspended!\n", conn->id); 110077a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 11013219e529SMike Christie return -ENODATA; 11027996a778SMike Christie } 11037996a778SMike Christie 11049c19a7d0SMike Christie if (conn->task) { 11059c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 11063219e529SMike Christie if (rc) 11077996a778SMike Christie goto again; 11087996a778SMike Christie } 110977a23c21SMike Christie 111077a23c21SMike Christie /* 111177a23c21SMike Christie * process mgmt pdus like nops before commands since we should 111277a23c21SMike Christie * only have one nop-out as a ping from us and targets should not 111377a23c21SMike Christie * overflow us with nop-ins 111477a23c21SMike Christie */ 111577a23c21SMike Christie check_mgmt: 1116843c0a8aSMike Christie while (!list_empty(&conn->mgmtqueue)) { 11179c19a7d0SMike Christie conn->task = list_entry(conn->mgmtqueue.next, 11189c19a7d0SMike Christie struct iscsi_task, running); 11199c19a7d0SMike Christie if (iscsi_prep_mgmt_task(conn, conn->task)) { 11209c19a7d0SMike Christie __iscsi_put_task(conn->task); 11219c19a7d0SMike Christie conn->task = NULL; 1122b3a7ea8dSMike Christie continue; 1123b3a7ea8dSMike Christie } 11249c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 11253219e529SMike Christie if (rc) 11267996a778SMike Christie goto again; 11277996a778SMike Christie } 11287996a778SMike Christie 1129843c0a8aSMike Christie /* process pending command queue */ 1130b6c395edSMike Christie while (!list_empty(&conn->xmitqueue)) { 1131843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) 1132843c0a8aSMike Christie break; 1133843c0a8aSMike Christie 11349c19a7d0SMike Christie conn->task = list_entry(conn->xmitqueue.next, 11359c19a7d0SMike Christie struct iscsi_task, running); 1136b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) { 11379c19a7d0SMike Christie fail_command(conn, conn->task, DID_IMM_RETRY << 16); 1138b3a7ea8dSMike Christie continue; 1139b3a7ea8dSMike Christie } 11409c19a7d0SMike Christie if (iscsi_prep_scsi_cmd_pdu(conn->task)) { 11419c19a7d0SMike Christie fail_command(conn, conn->task, DID_ABORT << 16); 1142004d6530SBoaz Harrosh continue; 1143004d6530SBoaz Harrosh } 11449c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 11453219e529SMike Christie if (rc) 11467996a778SMike Christie goto again; 114777a23c21SMike Christie /* 11489c19a7d0SMike Christie * we could continuously get new task requests so 114977a23c21SMike Christie * we need to check the mgmt queue for nops that need to 115077a23c21SMike Christie * be sent to aviod starvation 115177a23c21SMike Christie */ 1152843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 1153843c0a8aSMike Christie goto check_mgmt; 1154843c0a8aSMike Christie } 1155843c0a8aSMike Christie 1156843c0a8aSMike Christie while (!list_empty(&conn->requeue)) { 1157843c0a8aSMike Christie if (conn->session->fast_abort && conn->tmf_state != TMF_INITIAL) 1158843c0a8aSMike Christie break; 1159843c0a8aSMike Christie 1160b3a7ea8dSMike Christie /* 1161b3a7ea8dSMike Christie * we always do fastlogout - conn stop code will clean up. 1162b3a7ea8dSMike Christie */ 1163b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 1164b3a7ea8dSMike Christie break; 1165b3a7ea8dSMike Christie 11669c19a7d0SMike Christie conn->task = list_entry(conn->requeue.next, 11679c19a7d0SMike Christie struct iscsi_task, running); 11689c19a7d0SMike Christie conn->task->state = ISCSI_TASK_RUNNING; 1169843c0a8aSMike Christie list_move_tail(conn->requeue.next, &conn->run_list); 11709c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 1171843c0a8aSMike Christie if (rc) 1172843c0a8aSMike Christie goto again; 1173843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 117477a23c21SMike Christie goto check_mgmt; 11757996a778SMike Christie } 117677a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 11773219e529SMike Christie return -ENODATA; 11787996a778SMike Christie 11797996a778SMike Christie again: 11807996a778SMike Christie if (unlikely(conn->suspend_tx)) 118177a23c21SMike Christie rc = -ENODATA; 118277a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 11833219e529SMike Christie return rc; 11847996a778SMike Christie } 11857996a778SMike Christie 1186c4028958SDavid Howells static void iscsi_xmitworker(struct work_struct *work) 11877996a778SMike Christie { 1188c4028958SDavid Howells struct iscsi_conn *conn = 1189c4028958SDavid Howells container_of(work, struct iscsi_conn, xmitwork); 11903219e529SMike Christie int rc; 11917996a778SMike Christie /* 11927996a778SMike Christie * serialize Xmit worker on a per-connection basis. 11937996a778SMike Christie */ 11943219e529SMike Christie do { 11953219e529SMike Christie rc = iscsi_data_xmit(conn); 11963219e529SMike Christie } while (rc >= 0 || rc == -EAGAIN); 11977996a778SMike Christie } 11987996a778SMike Christie 11997996a778SMike Christie enum { 12007996a778SMike Christie FAILURE_BAD_HOST = 1, 12017996a778SMike Christie FAILURE_SESSION_FAILED, 12027996a778SMike Christie FAILURE_SESSION_FREED, 12037996a778SMike Christie FAILURE_WINDOW_CLOSED, 120460ecebf5SMike Christie FAILURE_OOM, 12057996a778SMike Christie FAILURE_SESSION_TERMINATE, 1206656cffc9SMike Christie FAILURE_SESSION_IN_RECOVERY, 12077996a778SMike Christie FAILURE_SESSION_RECOVERY_TIMEOUT, 1208b3a7ea8dSMike Christie FAILURE_SESSION_LOGGING_OUT, 12096eabafbeSMike Christie FAILURE_SESSION_NOT_READY, 12107996a778SMike Christie }; 12117996a778SMike Christie 12127996a778SMike Christie int iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *)) 12137996a778SMike Christie { 121475613521SMike Christie struct iscsi_cls_session *cls_session; 12157996a778SMike Christie struct Scsi_Host *host; 12167996a778SMike Christie int reason = 0; 12177996a778SMike Christie struct iscsi_session *session; 12187996a778SMike Christie struct iscsi_conn *conn; 12199c19a7d0SMike Christie struct iscsi_task *task = NULL; 12207996a778SMike Christie 12217996a778SMike Christie sc->scsi_done = done; 12227996a778SMike Christie sc->result = 0; 1223f47f2cf5SMike Christie sc->SCp.ptr = NULL; 12247996a778SMike Christie 12257996a778SMike Christie host = sc->device->host; 12261040c99dSMike Christie spin_unlock(host->host_lock); 12277996a778SMike Christie 122875613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 122975613521SMike Christie session = cls_session->dd_data; 12307996a778SMike Christie spin_lock(&session->lock); 12317996a778SMike Christie 123275613521SMike Christie reason = iscsi_session_chkready(cls_session); 12336eabafbeSMike Christie if (reason) { 12346eabafbeSMike Christie sc->result = reason; 12356eabafbeSMike Christie goto fault; 12366eabafbeSMike Christie } 12376eabafbeSMike Christie 1238656cffc9SMike Christie /* 1239656cffc9SMike Christie * ISCSI_STATE_FAILED is a temp. state. The recovery 1240656cffc9SMike Christie * code will decide what is best to do with command queued 1241656cffc9SMike Christie * during this time 1242656cffc9SMike Christie */ 1243656cffc9SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN && 1244656cffc9SMike Christie session->state != ISCSI_STATE_FAILED) { 1245656cffc9SMike Christie /* 1246656cffc9SMike Christie * to handle the race between when we set the recovery state 1247656cffc9SMike Christie * and block the session we requeue here (commands could 1248656cffc9SMike Christie * be entering our queuecommand while a block is starting 1249656cffc9SMike Christie * up because the block code is not locked) 1250656cffc9SMike Christie */ 12519000bcd6SMike Christie switch (session->state) { 12529000bcd6SMike Christie case ISCSI_STATE_IN_RECOVERY: 1253656cffc9SMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1254d6d13ee1SMike Christie goto reject; 12559000bcd6SMike Christie case ISCSI_STATE_LOGGING_OUT: 12569000bcd6SMike Christie reason = FAILURE_SESSION_LOGGING_OUT; 1257d6d13ee1SMike Christie goto reject; 1258b3a7ea8dSMike Christie case ISCSI_STATE_RECOVERY_FAILED: 1259656cffc9SMike Christie reason = FAILURE_SESSION_RECOVERY_TIMEOUT; 126056d7fcfaSMike Christie sc->result = DID_TRANSPORT_FAILFAST << 16; 1261b3a7ea8dSMike Christie break; 1262b3a7ea8dSMike Christie case ISCSI_STATE_TERMINATE: 1263656cffc9SMike Christie reason = FAILURE_SESSION_TERMINATE; 12646eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1265b3a7ea8dSMike Christie break; 1266b3a7ea8dSMike Christie default: 12677996a778SMike Christie reason = FAILURE_SESSION_FREED; 12686eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1269b3a7ea8dSMike Christie } 12707996a778SMike Christie goto fault; 12717996a778SMike Christie } 12727996a778SMike Christie 12737996a778SMike Christie conn = session->leadconn; 127498644047SMike Christie if (!conn) { 127598644047SMike Christie reason = FAILURE_SESSION_FREED; 12766eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 127798644047SMike Christie goto fault; 127898644047SMike Christie } 12797996a778SMike Christie 128077a23c21SMike Christie if (iscsi_check_cmdsn_window_closed(conn)) { 128177a23c21SMike Christie reason = FAILURE_WINDOW_CLOSED; 128277a23c21SMike Christie goto reject; 128377a23c21SMike Christie } 128477a23c21SMike Christie 12859c19a7d0SMike Christie if (!__kfifo_get(session->cmdpool.queue, (void*)&task, 128660ecebf5SMike Christie sizeof(void*))) { 128760ecebf5SMike Christie reason = FAILURE_OOM; 128860ecebf5SMike Christie goto reject; 128960ecebf5SMike Christie } 12907996a778SMike Christie sc->SCp.phase = session->age; 12919c19a7d0SMike Christie sc->SCp.ptr = (char *)task; 12927996a778SMike Christie 12939c19a7d0SMike Christie atomic_set(&task->refcount, 1); 12949c19a7d0SMike Christie task->state = ISCSI_TASK_PENDING; 12959c19a7d0SMike Christie task->conn = conn; 12969c19a7d0SMike Christie task->sc = sc; 12979c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 12989c19a7d0SMike Christie list_add_tail(&task->running, &conn->xmitqueue); 12997996a778SMike Christie 1300052d0144SMike Christie if (session->tt->caps & CAP_DATA_PATH_OFFLOAD) { 13019c19a7d0SMike Christie if (iscsi_prep_scsi_cmd_pdu(task)) { 1302052d0144SMike Christie sc->result = DID_ABORT << 16; 1303052d0144SMike Christie sc->scsi_done = NULL; 13049c19a7d0SMike Christie iscsi_complete_command(task); 1305052d0144SMike Christie goto fault; 1306052d0144SMike Christie } 13079c19a7d0SMike Christie if (session->tt->xmit_task(task)) { 1308052d0144SMike Christie sc->scsi_done = NULL; 13099c19a7d0SMike Christie iscsi_complete_command(task); 1310052d0144SMike Christie reason = FAILURE_SESSION_NOT_READY; 1311052d0144SMike Christie goto reject; 1312052d0144SMike Christie } 1313052d0144SMike Christie } else 1314052d0144SMike Christie scsi_queue_work(session->host, &conn->xmitwork); 1315052d0144SMike Christie 1316052d0144SMike Christie session->queued_cmdsn++; 1317052d0144SMike Christie spin_unlock(&session->lock); 13181040c99dSMike Christie spin_lock(host->host_lock); 13197996a778SMike Christie return 0; 13207996a778SMike Christie 13217996a778SMike Christie reject: 13227996a778SMike Christie spin_unlock(&session->lock); 13237996a778SMike Christie debug_scsi("cmd 0x%x rejected (%d)\n", sc->cmnd[0], reason); 13241040c99dSMike Christie spin_lock(host->host_lock); 1325d6d13ee1SMike Christie return SCSI_MLQUEUE_TARGET_BUSY; 13267996a778SMike Christie 13277996a778SMike Christie fault: 13287996a778SMike Christie spin_unlock(&session->lock); 13296eabafbeSMike Christie debug_scsi("iscsi: cmd 0x%x is not queued (%d)\n", sc->cmnd[0], reason); 1330c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 13311c138991SFUJITA Tomonori scsi_set_resid(sc, scsi_bufflen(sc)); 1332c07d4444SBoaz Harrosh else { 1333c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 1334c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 1335c07d4444SBoaz Harrosh } 1336052d0144SMike Christie done(sc); 13371040c99dSMike Christie spin_lock(host->host_lock); 13387996a778SMike Christie return 0; 13397996a778SMike Christie } 13407996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_queuecommand); 13417996a778SMike Christie 13427996a778SMike Christie int iscsi_change_queue_depth(struct scsi_device *sdev, int depth) 13437996a778SMike Christie { 13447996a778SMike Christie if (depth > ISCSI_MAX_CMD_PER_LUN) 13457996a778SMike Christie depth = ISCSI_MAX_CMD_PER_LUN; 13467996a778SMike Christie scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); 13477996a778SMike Christie return sdev->queue_depth; 13487996a778SMike Christie } 13497996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_change_queue_depth); 13507996a778SMike Christie 13517996a778SMike Christie void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) 13527996a778SMike Christie { 135375613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 13547996a778SMike Christie 13557996a778SMike Christie spin_lock_bh(&session->lock); 13567996a778SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1357656cffc9SMike Christie session->state = ISCSI_STATE_RECOVERY_FAILED; 1358843c0a8aSMike Christie if (session->leadconn) 1359843c0a8aSMike Christie wake_up(&session->leadconn->ehwait); 13607996a778SMike Christie } 13617996a778SMike Christie spin_unlock_bh(&session->lock); 13627996a778SMike Christie } 13637996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout); 13647996a778SMike Christie 13658e124525SMike Christie int iscsi_eh_target_reset(struct scsi_cmnd *sc) 13667996a778SMike Christie { 136775613521SMike Christie struct iscsi_cls_session *cls_session; 136875613521SMike Christie struct iscsi_session *session; 136975613521SMike Christie struct iscsi_conn *conn; 137075613521SMike Christie 137175613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 137275613521SMike Christie session = cls_session->dd_data; 137375613521SMike Christie conn = session->leadconn; 13747996a778SMike Christie 1375bc436b27SMike Christie mutex_lock(&session->eh_mutex); 13767996a778SMike Christie spin_lock_bh(&session->lock); 13777996a778SMike Christie if (session->state == ISCSI_STATE_TERMINATE) { 13787996a778SMike Christie failed: 13798e124525SMike Christie debug_scsi("failing target reset: session terminated " 1380d6e24d1cSPete Wyckoff "[CID %d age %d]\n", conn->id, session->age); 13817996a778SMike Christie spin_unlock_bh(&session->lock); 1382bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 13837996a778SMike Christie return FAILED; 13847996a778SMike Christie } 13857996a778SMike Christie 13867996a778SMike Christie spin_unlock_bh(&session->lock); 1387bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 13887996a778SMike Christie /* 13897996a778SMike Christie * we drop the lock here but the leadconn cannot be destoyed while 13907996a778SMike Christie * we are in the scsi eh 13917996a778SMike Christie */ 13927996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 13937996a778SMike Christie 13948e124525SMike Christie debug_scsi("iscsi_eh_target_reset wait for relogin\n"); 13957996a778SMike Christie wait_event_interruptible(conn->ehwait, 13967996a778SMike Christie session->state == ISCSI_STATE_TERMINATE || 13977996a778SMike Christie session->state == ISCSI_STATE_LOGGED_IN || 1398656cffc9SMike Christie session->state == ISCSI_STATE_RECOVERY_FAILED); 13997996a778SMike Christie if (signal_pending(current)) 14007996a778SMike Christie flush_signals(current); 14017996a778SMike Christie 1402bc436b27SMike Christie mutex_lock(&session->eh_mutex); 14037996a778SMike Christie spin_lock_bh(&session->lock); 14047996a778SMike Christie if (session->state == ISCSI_STATE_LOGGED_IN) 1405322d739dSMike Christie iscsi_session_printk(KERN_INFO, session, 14068e124525SMike Christie "target reset succeeded\n"); 14077996a778SMike Christie else 14087996a778SMike Christie goto failed; 14097996a778SMike Christie spin_unlock_bh(&session->lock); 1410bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 14117996a778SMike Christie return SUCCESS; 14127996a778SMike Christie } 14138e124525SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_target_reset); 14147996a778SMike Christie 1415843c0a8aSMike Christie static void iscsi_tmf_timedout(unsigned long data) 14167996a778SMike Christie { 1417843c0a8aSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 14187996a778SMike Christie struct iscsi_session *session = conn->session; 14197996a778SMike Christie 14207996a778SMike Christie spin_lock(&session->lock); 1421843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) { 1422843c0a8aSMike Christie conn->tmf_state = TMF_TIMEDOUT; 1423843c0a8aSMike Christie debug_scsi("tmf timedout\n"); 14247996a778SMike Christie /* unblock eh_abort() */ 14257996a778SMike Christie wake_up(&conn->ehwait); 14267996a778SMike Christie } 14277996a778SMike Christie spin_unlock(&session->lock); 14287996a778SMike Christie } 14297996a778SMike Christie 14309c19a7d0SMike Christie static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, 1431f6d5180cSMike Christie struct iscsi_tm *hdr, int age, 1432f6d5180cSMike Christie int timeout) 14337996a778SMike Christie { 14347996a778SMike Christie struct iscsi_session *session = conn->session; 14359c19a7d0SMike Christie struct iscsi_task *task; 14367996a778SMike Christie 14379c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr, 14387996a778SMike Christie NULL, 0); 14399c19a7d0SMike Christie if (!task) { 14406724add1SMike Christie spin_unlock_bh(&session->lock); 14417996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1442843c0a8aSMike Christie spin_lock_bh(&session->lock); 1443843c0a8aSMike Christie debug_scsi("tmf exec failure\n"); 144477a23c21SMike Christie return -EPERM; 14457996a778SMike Christie } 14467996a778SMike Christie conn->tmfcmd_pdus_cnt++; 1447f6d5180cSMike Christie conn->tmf_timer.expires = timeout * HZ + jiffies; 1448843c0a8aSMike Christie conn->tmf_timer.function = iscsi_tmf_timedout; 1449843c0a8aSMike Christie conn->tmf_timer.data = (unsigned long)conn; 1450843c0a8aSMike Christie add_timer(&conn->tmf_timer); 1451843c0a8aSMike Christie debug_scsi("tmf set timeout\n"); 1452843c0a8aSMike Christie 14537996a778SMike Christie spin_unlock_bh(&session->lock); 14546724add1SMike Christie mutex_unlock(&session->eh_mutex); 14557996a778SMike Christie 14567996a778SMike Christie /* 14577996a778SMike Christie * block eh thread until: 14587996a778SMike Christie * 1459843c0a8aSMike Christie * 1) tmf response 1460843c0a8aSMike Christie * 2) tmf timeout 14617996a778SMike Christie * 3) session is terminated or restarted or userspace has 14627996a778SMike Christie * given up on recovery 14637996a778SMike Christie */ 1464843c0a8aSMike Christie wait_event_interruptible(conn->ehwait, age != session->age || 14657996a778SMike Christie session->state != ISCSI_STATE_LOGGED_IN || 1466843c0a8aSMike Christie conn->tmf_state != TMF_QUEUED); 14677996a778SMike Christie if (signal_pending(current)) 14687996a778SMike Christie flush_signals(current); 1469843c0a8aSMike Christie del_timer_sync(&conn->tmf_timer); 1470843c0a8aSMike Christie 14716724add1SMike Christie mutex_lock(&session->eh_mutex); 147277a23c21SMike Christie spin_lock_bh(&session->lock); 14739c19a7d0SMike Christie /* if the session drops it will clean up the task */ 1474843c0a8aSMike Christie if (age != session->age || 1475843c0a8aSMike Christie session->state != ISCSI_STATE_LOGGED_IN) 1476843c0a8aSMike Christie return -ENOTCONN; 14777996a778SMike Christie return 0; 14787996a778SMike Christie } 14797996a778SMike Christie 14807996a778SMike Christie /* 1481843c0a8aSMike Christie * Fail commands. session lock held and recv side suspended and xmit 1482843c0a8aSMike Christie * thread flushed 1483843c0a8aSMike Christie */ 14846eabafbeSMike Christie static void fail_all_commands(struct iscsi_conn *conn, unsigned lun, 14856eabafbeSMike Christie int error) 1486843c0a8aSMike Christie { 14879c19a7d0SMike Christie struct iscsi_task *task, *tmp; 1488843c0a8aSMike Christie 14899c19a7d0SMike Christie if (conn->task && (conn->task->sc->device->lun == lun || lun == -1)) 14909c19a7d0SMike Christie conn->task = NULL; 1491843c0a8aSMike Christie 1492843c0a8aSMike Christie /* flush pending */ 14939c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->xmitqueue, running) { 14949c19a7d0SMike Christie if (lun == task->sc->device->lun || lun == -1) { 1495843c0a8aSMike Christie debug_scsi("failing pending sc %p itt 0x%x\n", 14969c19a7d0SMike Christie task->sc, task->itt); 14979c19a7d0SMike Christie fail_command(conn, task, error << 16); 1498843c0a8aSMike Christie } 1499843c0a8aSMike Christie } 1500843c0a8aSMike Christie 15019c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->requeue, running) { 15029c19a7d0SMike Christie if (lun == task->sc->device->lun || lun == -1) { 1503843c0a8aSMike Christie debug_scsi("failing requeued sc %p itt 0x%x\n", 15049c19a7d0SMike Christie task->sc, task->itt); 15059c19a7d0SMike Christie fail_command(conn, task, error << 16); 1506843c0a8aSMike Christie } 1507843c0a8aSMike Christie } 1508843c0a8aSMike Christie 1509843c0a8aSMike Christie /* fail all other running */ 15109c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->run_list, running) { 15119c19a7d0SMike Christie if (lun == task->sc->device->lun || lun == -1) { 1512843c0a8aSMike Christie debug_scsi("failing in progress sc %p itt 0x%x\n", 15139c19a7d0SMike Christie task->sc, task->itt); 1514ac26d41dSMike Christie fail_command(conn, task, error << 16); 1515843c0a8aSMike Christie } 1516843c0a8aSMike Christie } 1517843c0a8aSMike Christie } 1518843c0a8aSMike Christie 1519b40977d9SMike Christie void iscsi_suspend_tx(struct iscsi_conn *conn) 15206724add1SMike Christie { 15216724add1SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1522052d0144SMike Christie if (!(conn->session->tt->caps & CAP_DATA_PATH_OFFLOAD)) 15236724add1SMike Christie scsi_flush_work(conn->session->host); 15246724add1SMike Christie } 1525b40977d9SMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_tx); 15266724add1SMike Christie 15276724add1SMike Christie static void iscsi_start_tx(struct iscsi_conn *conn) 15286724add1SMike Christie { 15296724add1SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1530052d0144SMike Christie if (!(conn->session->tt->caps & CAP_DATA_PATH_OFFLOAD)) 15316724add1SMike Christie scsi_queue_work(conn->session->host, &conn->xmitwork); 15326724add1SMike Christie } 15336724add1SMike Christie 1534242f9dcbSJens Axboe static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *scmd) 1535f6d5180cSMike Christie { 1536f6d5180cSMike Christie struct iscsi_cls_session *cls_session; 1537f6d5180cSMike Christie struct iscsi_session *session; 1538f6d5180cSMike Christie struct iscsi_conn *conn; 1539242f9dcbSJens Axboe enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED; 1540f6d5180cSMike Christie 1541f6d5180cSMike Christie cls_session = starget_to_session(scsi_target(scmd->device)); 154275613521SMike Christie session = cls_session->dd_data; 1543f6d5180cSMike Christie 1544f6d5180cSMike Christie debug_scsi("scsi cmd %p timedout\n", scmd); 1545f6d5180cSMike Christie 1546f6d5180cSMike Christie spin_lock(&session->lock); 1547f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1548f6d5180cSMike Christie /* 1549f6d5180cSMike Christie * We are probably in the middle of iscsi recovery so let 1550f6d5180cSMike Christie * that complete and handle the error. 1551f6d5180cSMike Christie */ 1552242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1553f6d5180cSMike Christie goto done; 1554f6d5180cSMike Christie } 1555f6d5180cSMike Christie 1556f6d5180cSMike Christie conn = session->leadconn; 1557f6d5180cSMike Christie if (!conn) { 1558f6d5180cSMike Christie /* In the middle of shuting down */ 1559242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1560f6d5180cSMike Christie goto done; 1561f6d5180cSMike Christie } 1562f6d5180cSMike Christie 1563f6d5180cSMike Christie if (!conn->recv_timeout && !conn->ping_timeout) 1564f6d5180cSMike Christie goto done; 1565f6d5180cSMike Christie /* 1566f6d5180cSMike Christie * if the ping timedout then we are in the middle of cleaning up 1567f6d5180cSMike Christie * and can let the iscsi eh handle it 1568f6d5180cSMike Christie */ 1569f6d5180cSMike Christie if (time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) + 1570f6d5180cSMike Christie (conn->ping_timeout * HZ), jiffies)) 1571242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1572f6d5180cSMike Christie /* 1573f6d5180cSMike Christie * if we are about to check the transport then give the command 1574f6d5180cSMike Christie * more time 1575f6d5180cSMike Christie */ 1576f6d5180cSMike Christie if (time_before_eq(conn->last_recv + (conn->recv_timeout * HZ), 1577f6d5180cSMike Christie jiffies)) 1578242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1579f6d5180cSMike Christie /* if in the middle of checking the transport then give us more time */ 15809c19a7d0SMike Christie if (conn->ping_task) 1581242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1582f6d5180cSMike Christie done: 1583f6d5180cSMike Christie spin_unlock(&session->lock); 1584242f9dcbSJens Axboe debug_scsi("return %s\n", rc == BLK_EH_RESET_TIMER ? 1585242f9dcbSJens Axboe "timer reset" : "nh"); 1586f6d5180cSMike Christie return rc; 1587f6d5180cSMike Christie } 1588f6d5180cSMike Christie 1589f6d5180cSMike Christie static void iscsi_check_transport_timeouts(unsigned long data) 1590f6d5180cSMike Christie { 1591f6d5180cSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 1592f6d5180cSMike Christie struct iscsi_session *session = conn->session; 15934cf10435SMike Christie unsigned long recv_timeout, next_timeout = 0, last_recv; 1594f6d5180cSMike Christie 1595f6d5180cSMike Christie spin_lock(&session->lock); 1596f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 1597f6d5180cSMike Christie goto done; 1598f6d5180cSMike Christie 15994cf10435SMike Christie recv_timeout = conn->recv_timeout; 16004cf10435SMike Christie if (!recv_timeout) 1601f6d5180cSMike Christie goto done; 1602f6d5180cSMike Christie 16034cf10435SMike Christie recv_timeout *= HZ; 1604f6d5180cSMike Christie last_recv = conn->last_recv; 16059c19a7d0SMike Christie if (conn->ping_task && 16064cf10435SMike Christie time_before_eq(conn->last_ping + (conn->ping_timeout * HZ), 1607f6d5180cSMike Christie jiffies)) { 1608322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs " 1609322d739dSMike Christie "expired, last rx %lu, last ping %lu, " 1610322d739dSMike Christie "now %lu\n", conn->ping_timeout, last_recv, 1611f6d5180cSMike Christie conn->last_ping, jiffies); 1612f6d5180cSMike Christie spin_unlock(&session->lock); 1613f6d5180cSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1614f6d5180cSMike Christie return; 1615f6d5180cSMike Christie } 1616f6d5180cSMike Christie 16174cf10435SMike Christie if (time_before_eq(last_recv + recv_timeout, jiffies)) { 1618f6d5180cSMike Christie /* send a ping to try to provoke some traffic */ 1619f6d5180cSMike Christie debug_scsi("Sending nopout as ping on conn %p\n", conn); 1620f6d5180cSMike Christie iscsi_send_nopout(conn, NULL); 16214cf10435SMike Christie next_timeout = conn->last_ping + (conn->ping_timeout * HZ); 1622ad294e9cSMike Christie } else 16234cf10435SMike Christie next_timeout = last_recv + recv_timeout; 1624f6d5180cSMike Christie 1625f6d5180cSMike Christie debug_scsi("Setting next tmo %lu\n", next_timeout); 1626f6d5180cSMike Christie mod_timer(&conn->transport_timer, next_timeout); 1627f6d5180cSMike Christie done: 1628f6d5180cSMike Christie spin_unlock(&session->lock); 1629f6d5180cSMike Christie } 1630f6d5180cSMike Christie 16319c19a7d0SMike Christie static void iscsi_prep_abort_task_pdu(struct iscsi_task *task, 1632843c0a8aSMike Christie struct iscsi_tm *hdr) 1633843c0a8aSMike Christie { 1634843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 1635843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 1636843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK; 1637843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 16389c19a7d0SMike Christie memcpy(hdr->lun, task->hdr->lun, sizeof(hdr->lun)); 16399c19a7d0SMike Christie hdr->rtt = task->hdr->itt; 16409c19a7d0SMike Christie hdr->refcmdsn = task->hdr->cmdsn; 1641843c0a8aSMike Christie } 1642843c0a8aSMike Christie 16437996a778SMike Christie int iscsi_eh_abort(struct scsi_cmnd *sc) 16447996a778SMike Christie { 164575613521SMike Christie struct iscsi_cls_session *cls_session; 164675613521SMike Christie struct iscsi_session *session; 1647f47f2cf5SMike Christie struct iscsi_conn *conn; 16489c19a7d0SMike Christie struct iscsi_task *task; 1649843c0a8aSMike Christie struct iscsi_tm *hdr; 1650843c0a8aSMike Christie int rc, age; 16517996a778SMike Christie 165275613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 165375613521SMike Christie session = cls_session->dd_data; 165475613521SMike Christie 16556724add1SMike Christie mutex_lock(&session->eh_mutex); 16566724add1SMike Christie spin_lock_bh(&session->lock); 1657f47f2cf5SMike Christie /* 1658f47f2cf5SMike Christie * if session was ISCSI_STATE_IN_RECOVERY then we may not have 1659f47f2cf5SMike Christie * got the command. 1660f47f2cf5SMike Christie */ 1661f47f2cf5SMike Christie if (!sc->SCp.ptr) { 1662f47f2cf5SMike Christie debug_scsi("sc never reached iscsi layer or it completed.\n"); 16636724add1SMike Christie spin_unlock_bh(&session->lock); 16646724add1SMike Christie mutex_unlock(&session->eh_mutex); 1665f47f2cf5SMike Christie return SUCCESS; 1666f47f2cf5SMike Christie } 1667f47f2cf5SMike Christie 16687996a778SMike Christie /* 16697996a778SMike Christie * If we are not logged in or we have started a new session 16707996a778SMike Christie * then let the host reset code handle this 16717996a778SMike Christie */ 1672843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN || 1673843c0a8aSMike Christie sc->SCp.phase != session->age) { 1674843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1675843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 1676843c0a8aSMike Christie return FAILED; 1677843c0a8aSMike Christie } 1678843c0a8aSMike Christie 1679843c0a8aSMike Christie conn = session->leadconn; 1680843c0a8aSMike Christie conn->eh_abort_cnt++; 1681843c0a8aSMike Christie age = session->age; 1682843c0a8aSMike Christie 16839c19a7d0SMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 16849c19a7d0SMike Christie debug_scsi("aborting [sc %p itt 0x%x]\n", sc, task->itt); 16857996a778SMike Christie 16869c19a7d0SMike Christie /* task completed before time out */ 16879c19a7d0SMike Christie if (!task->sc) { 16887ea8b828SMike Christie debug_scsi("sc completed while abort in progress\n"); 168977a23c21SMike Christie goto success; 16907ea8b828SMike Christie } 16917996a778SMike Christie 16929c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) { 16939c19a7d0SMike Christie fail_command(conn, task, DID_ABORT << 16); 169477a23c21SMike Christie goto success; 169577a23c21SMike Christie } 16967996a778SMike Christie 1697843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 1698843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 16997996a778SMike Christie goto failed; 1700843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 17017996a778SMike Christie 1702843c0a8aSMike Christie hdr = &conn->tmhdr; 17039c19a7d0SMike Christie iscsi_prep_abort_task_pdu(task, hdr); 1704843c0a8aSMike Christie 17059c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) { 1706843c0a8aSMike Christie rc = FAILED; 1707843c0a8aSMike Christie goto failed; 1708843c0a8aSMike Christie } 1709843c0a8aSMike Christie 1710843c0a8aSMike Christie switch (conn->tmf_state) { 1711843c0a8aSMike Christie case TMF_SUCCESS: 17127ea8b828SMike Christie spin_unlock_bh(&session->lock); 1713913e5bf4SMike Christie /* 1714913e5bf4SMike Christie * stop tx side incase the target had sent a abort rsp but 1715913e5bf4SMike Christie * the initiator was still writing out data. 1716913e5bf4SMike Christie */ 17176724add1SMike Christie iscsi_suspend_tx(conn); 17187996a778SMike Christie /* 1719913e5bf4SMike Christie * we do not stop the recv side because targets have been 1720913e5bf4SMike Christie * good and have never sent us a successful tmf response 1721913e5bf4SMike Christie * then sent more data for the cmd. 17227996a778SMike Christie */ 17237996a778SMike Christie spin_lock(&session->lock); 17249c19a7d0SMike Christie fail_command(conn, task, DID_ABORT << 16); 1725843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 17267996a778SMike Christie spin_unlock(&session->lock); 17276724add1SMike Christie iscsi_start_tx(conn); 172877a23c21SMike Christie goto success_unlocked; 1729843c0a8aSMike Christie case TMF_TIMEDOUT: 1730843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1731843c0a8aSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1732843c0a8aSMike Christie goto failed_unlocked; 1733843c0a8aSMike Christie case TMF_NOT_FOUND: 1734843c0a8aSMike Christie if (!sc->SCp.ptr) { 1735843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 17369c19a7d0SMike Christie /* task completed before tmf abort response */ 173777a23c21SMike Christie debug_scsi("sc completed while abort in progress\n"); 173877a23c21SMike Christie goto success; 173977a23c21SMike Christie } 174077a23c21SMike Christie /* fall through */ 174177a23c21SMike Christie default: 1742843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 1743843c0a8aSMike Christie goto failed; 174477a23c21SMike Christie } 17457996a778SMike Christie 174677a23c21SMike Christie success: 174777a23c21SMike Christie spin_unlock_bh(&session->lock); 174877a23c21SMike Christie success_unlocked: 17499c19a7d0SMike Christie debug_scsi("abort success [sc %lx itt 0x%x]\n", (long)sc, task->itt); 17506724add1SMike Christie mutex_unlock(&session->eh_mutex); 17517996a778SMike Christie return SUCCESS; 17527996a778SMike Christie 17537996a778SMike Christie failed: 17547996a778SMike Christie spin_unlock_bh(&session->lock); 175577a23c21SMike Christie failed_unlocked: 1756843c0a8aSMike Christie debug_scsi("abort failed [sc %p itt 0x%x]\n", sc, 17579c19a7d0SMike Christie task ? task->itt : 0); 17586724add1SMike Christie mutex_unlock(&session->eh_mutex); 17597996a778SMike Christie return FAILED; 17607996a778SMike Christie } 17617996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_abort); 17627996a778SMike Christie 1763843c0a8aSMike Christie static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 1764843c0a8aSMike Christie { 1765843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 1766843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 1767843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK; 1768843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 1769843c0a8aSMike Christie int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun); 1770f6d5180cSMike Christie hdr->rtt = RESERVED_ITT; 1771843c0a8aSMike Christie } 1772843c0a8aSMike Christie 1773843c0a8aSMike Christie int iscsi_eh_device_reset(struct scsi_cmnd *sc) 1774843c0a8aSMike Christie { 177575613521SMike Christie struct iscsi_cls_session *cls_session; 177675613521SMike Christie struct iscsi_session *session; 1777843c0a8aSMike Christie struct iscsi_conn *conn; 1778843c0a8aSMike Christie struct iscsi_tm *hdr; 1779843c0a8aSMike Christie int rc = FAILED; 1780843c0a8aSMike Christie 178175613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 178275613521SMike Christie session = cls_session->dd_data; 178375613521SMike Christie 1784843c0a8aSMike Christie debug_scsi("LU Reset [sc %p lun %u]\n", sc, sc->device->lun); 1785843c0a8aSMike Christie 1786843c0a8aSMike Christie mutex_lock(&session->eh_mutex); 1787843c0a8aSMike Christie spin_lock_bh(&session->lock); 1788843c0a8aSMike Christie /* 1789843c0a8aSMike Christie * Just check if we are not logged in. We cannot check for 1790843c0a8aSMike Christie * the phase because the reset could come from a ioctl. 1791843c0a8aSMike Christie */ 1792843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 1793843c0a8aSMike Christie goto unlock; 1794843c0a8aSMike Christie conn = session->leadconn; 1795843c0a8aSMike Christie 1796843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 1797843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 1798843c0a8aSMike Christie goto unlock; 1799843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 1800843c0a8aSMike Christie 1801843c0a8aSMike Christie hdr = &conn->tmhdr; 1802843c0a8aSMike Christie iscsi_prep_lun_reset_pdu(sc, hdr); 1803843c0a8aSMike Christie 18049c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 1805f6d5180cSMike Christie session->lu_reset_timeout)) { 1806843c0a8aSMike Christie rc = FAILED; 1807843c0a8aSMike Christie goto unlock; 1808843c0a8aSMike Christie } 1809843c0a8aSMike Christie 1810843c0a8aSMike Christie switch (conn->tmf_state) { 1811843c0a8aSMike Christie case TMF_SUCCESS: 1812843c0a8aSMike Christie break; 1813843c0a8aSMike Christie case TMF_TIMEDOUT: 1814843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1815843c0a8aSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1816843c0a8aSMike Christie goto done; 1817843c0a8aSMike Christie default: 1818843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 1819843c0a8aSMike Christie goto unlock; 1820843c0a8aSMike Christie } 1821843c0a8aSMike Christie 1822843c0a8aSMike Christie rc = SUCCESS; 1823843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1824843c0a8aSMike Christie 1825843c0a8aSMike Christie iscsi_suspend_tx(conn); 1826913e5bf4SMike Christie 1827*a3439148SMike Christie spin_lock_bh(&session->lock); 18286eabafbeSMike Christie fail_all_commands(conn, sc->device->lun, DID_ERROR); 1829843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 1830*a3439148SMike Christie spin_unlock_bh(&session->lock); 1831843c0a8aSMike Christie 1832843c0a8aSMike Christie iscsi_start_tx(conn); 1833843c0a8aSMike Christie goto done; 1834843c0a8aSMike Christie 1835843c0a8aSMike Christie unlock: 1836843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1837843c0a8aSMike Christie done: 1838843c0a8aSMike Christie debug_scsi("iscsi_eh_device_reset %s\n", 1839843c0a8aSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 1840843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 1841843c0a8aSMike Christie return rc; 1842843c0a8aSMike Christie } 1843843c0a8aSMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_device_reset); 1844843c0a8aSMike Christie 18456320377fSOlaf Kirch /* 18466320377fSOlaf Kirch * Pre-allocate a pool of @max items of @item_size. By default, the pool 18476320377fSOlaf Kirch * should be accessed via kfifo_{get,put} on q->queue. 18486320377fSOlaf Kirch * Optionally, the caller can obtain the array of object pointers 18496320377fSOlaf Kirch * by passing in a non-NULL @items pointer 18506320377fSOlaf Kirch */ 18517996a778SMike Christie int 18526320377fSOlaf Kirch iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size) 18537996a778SMike Christie { 18546320377fSOlaf Kirch int i, num_arrays = 1; 18557996a778SMike Christie 18566320377fSOlaf Kirch memset(q, 0, sizeof(*q)); 18577996a778SMike Christie 18587996a778SMike Christie q->max = max; 18596320377fSOlaf Kirch 18606320377fSOlaf Kirch /* If the user passed an items pointer, he wants a copy of 18616320377fSOlaf Kirch * the array. */ 18626320377fSOlaf Kirch if (items) 18636320377fSOlaf Kirch num_arrays++; 18646320377fSOlaf Kirch q->pool = kzalloc(num_arrays * max * sizeof(void*), GFP_KERNEL); 18656320377fSOlaf Kirch if (q->pool == NULL) 18666320377fSOlaf Kirch goto enomem; 18677996a778SMike Christie 18687996a778SMike Christie q->queue = kfifo_init((void*)q->pool, max * sizeof(void*), 18697996a778SMike Christie GFP_KERNEL, NULL); 18706320377fSOlaf Kirch if (q->queue == ERR_PTR(-ENOMEM)) 18716320377fSOlaf Kirch goto enomem; 18727996a778SMike Christie 18737996a778SMike Christie for (i = 0; i < max; i++) { 18746320377fSOlaf Kirch q->pool[i] = kzalloc(item_size, GFP_KERNEL); 18757996a778SMike Christie if (q->pool[i] == NULL) { 18766320377fSOlaf Kirch q->max = i; 18776320377fSOlaf Kirch goto enomem; 18787996a778SMike Christie } 18797996a778SMike Christie __kfifo_put(q->queue, (void*)&q->pool[i], sizeof(void*)); 18807996a778SMike Christie } 18816320377fSOlaf Kirch 18826320377fSOlaf Kirch if (items) { 18836320377fSOlaf Kirch *items = q->pool + max; 18846320377fSOlaf Kirch memcpy(*items, q->pool, max * sizeof(void *)); 18856320377fSOlaf Kirch } 18866320377fSOlaf Kirch 18877996a778SMike Christie return 0; 18886320377fSOlaf Kirch 18896320377fSOlaf Kirch enomem: 18906320377fSOlaf Kirch iscsi_pool_free(q); 18916320377fSOlaf Kirch return -ENOMEM; 18927996a778SMike Christie } 18937996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_init); 18947996a778SMike Christie 18956320377fSOlaf Kirch void iscsi_pool_free(struct iscsi_pool *q) 18967996a778SMike Christie { 18977996a778SMike Christie int i; 18987996a778SMike Christie 18997996a778SMike Christie for (i = 0; i < q->max; i++) 19006320377fSOlaf Kirch kfree(q->pool[i]); 19016320377fSOlaf Kirch if (q->pool) 19027996a778SMike Christie kfree(q->pool); 19037996a778SMike Christie } 19047996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_free); 19057996a778SMike Christie 1906a4804cd6SMike Christie /** 1907a4804cd6SMike Christie * iscsi_host_add - add host to system 1908a4804cd6SMike Christie * @shost: scsi host 1909a4804cd6SMike Christie * @pdev: parent device 1910a4804cd6SMike Christie * 1911a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers 1912a4804cd6SMike Christie * to add a host to the system. 1913a4804cd6SMike Christie */ 1914a4804cd6SMike Christie int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev) 19157996a778SMike Christie { 19168e9a20ceSMike Christie if (!shost->can_queue) 19178e9a20ceSMike Christie shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX; 19188e9a20ceSMike Christie 1919a4804cd6SMike Christie return scsi_add_host(shost, pdev); 1920a4804cd6SMike Christie } 1921a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_add); 1922a4804cd6SMike Christie 1923a4804cd6SMike Christie /** 1924a4804cd6SMike Christie * iscsi_host_alloc - allocate a host and driver data 1925a4804cd6SMike Christie * @sht: scsi host template 1926a4804cd6SMike Christie * @dd_data_size: driver host data size 1927a4804cd6SMike Christie * @qdepth: default device queue depth 1928a4804cd6SMike Christie * 1929a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers. 1930a4804cd6SMike Christie * To access the driver specific memory use the iscsi_host_priv() macro. 1931a4804cd6SMike Christie */ 1932a4804cd6SMike Christie struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht, 1933a4804cd6SMike Christie int dd_data_size, uint16_t qdepth) 1934a4804cd6SMike Christie { 1935a4804cd6SMike Christie struct Scsi_Host *shost; 1936e5bd7b54SMike Christie struct iscsi_host *ihost; 1937a4804cd6SMike Christie 1938a4804cd6SMike Christie shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size); 1939a4804cd6SMike Christie if (!shost) 1940a4804cd6SMike Christie return NULL; 1941a4804cd6SMike Christie shost->transportt->eh_timed_out = iscsi_eh_cmd_timed_out; 1942a4804cd6SMike Christie 19431548271eSMike Christie if (qdepth > ISCSI_MAX_CMD_PER_LUN || qdepth < 1) { 19441548271eSMike Christie if (qdepth != 0) 19451548271eSMike Christie printk(KERN_ERR "iscsi: invalid queue depth of %d. " 19461548271eSMike Christie "Queue depth must be between 1 and %d.\n", 19471548271eSMike Christie qdepth, ISCSI_MAX_CMD_PER_LUN); 19481548271eSMike Christie qdepth = ISCSI_DEF_CMD_PER_LUN; 19491548271eSMike Christie } 195075613521SMike Christie shost->cmd_per_lun = qdepth; 1951e5bd7b54SMike Christie 1952e5bd7b54SMike Christie ihost = shost_priv(shost); 1953e5bd7b54SMike Christie spin_lock_init(&ihost->lock); 1954e5bd7b54SMike Christie ihost->state = ISCSI_HOST_SETUP; 1955e5bd7b54SMike Christie ihost->num_sessions = 0; 1956e5bd7b54SMike Christie init_waitqueue_head(&ihost->session_removal_wq); 1957a4804cd6SMike Christie return shost; 195875613521SMike Christie } 1959a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_alloc); 196075613521SMike Christie 1961e5bd7b54SMike Christie static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session) 1962e5bd7b54SMike Christie { 1963e5bd7b54SMike Christie iscsi_session_failure(cls_session, ISCSI_ERR_INVALID_HOST); 1964e5bd7b54SMike Christie } 1965e5bd7b54SMike Christie 1966a4804cd6SMike Christie /** 1967a4804cd6SMike Christie * iscsi_host_remove - remove host and sessions 1968a4804cd6SMike Christie * @shost: scsi host 1969a4804cd6SMike Christie * 1970e5bd7b54SMike Christie * If there are any sessions left, this will initiate the removal and wait 1971e5bd7b54SMike Christie * for the completion. 1972a4804cd6SMike Christie */ 1973a4804cd6SMike Christie void iscsi_host_remove(struct Scsi_Host *shost) 1974a4804cd6SMike Christie { 1975e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 1976e5bd7b54SMike Christie unsigned long flags; 1977e5bd7b54SMike Christie 1978e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 1979e5bd7b54SMike Christie ihost->state = ISCSI_HOST_REMOVED; 1980e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 1981e5bd7b54SMike Christie 1982e5bd7b54SMike Christie iscsi_host_for_each_session(shost, iscsi_notify_host_removed); 1983e5bd7b54SMike Christie wait_event_interruptible(ihost->session_removal_wq, 1984e5bd7b54SMike Christie ihost->num_sessions == 0); 1985e5bd7b54SMike Christie if (signal_pending(current)) 1986e5bd7b54SMike Christie flush_signals(current); 1987e5bd7b54SMike Christie 1988a4804cd6SMike Christie scsi_remove_host(shost); 1989a4804cd6SMike Christie } 1990a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_remove); 1991a4804cd6SMike Christie 1992a4804cd6SMike Christie void iscsi_host_free(struct Scsi_Host *shost) 199375613521SMike Christie { 199475613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 199575613521SMike Christie 199675613521SMike Christie kfree(ihost->netdev); 199775613521SMike Christie kfree(ihost->hwaddress); 199875613521SMike Christie kfree(ihost->initiatorname); 1999a4804cd6SMike Christie scsi_host_put(shost); 200075613521SMike Christie } 2001a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_free); 200275613521SMike Christie 2003e5bd7b54SMike Christie static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost) 2004e5bd7b54SMike Christie { 2005e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2006e5bd7b54SMike Christie unsigned long flags; 2007e5bd7b54SMike Christie 2008e5bd7b54SMike Christie shost = scsi_host_get(shost); 2009e5bd7b54SMike Christie if (!shost) { 2010e5bd7b54SMike Christie printk(KERN_ERR "Invalid state. Cannot notify host removal " 2011e5bd7b54SMike Christie "of session teardown event because host already " 2012e5bd7b54SMike Christie "removed.\n"); 2013e5bd7b54SMike Christie return; 2014e5bd7b54SMike Christie } 2015e5bd7b54SMike Christie 2016e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2017e5bd7b54SMike Christie ihost->num_sessions--; 2018e5bd7b54SMike Christie if (ihost->num_sessions == 0) 2019e5bd7b54SMike Christie wake_up(&ihost->session_removal_wq); 2020e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2021e5bd7b54SMike Christie scsi_host_put(shost); 2022e5bd7b54SMike Christie } 2023e5bd7b54SMike Christie 202475613521SMike Christie /** 202575613521SMike Christie * iscsi_session_setup - create iscsi cls session and host and session 202675613521SMike Christie * @iscsit: iscsi transport template 202775613521SMike Christie * @shost: scsi host 202875613521SMike Christie * @cmds_max: session can queue 20299c19a7d0SMike Christie * @cmd_task_size: LLD task private data size 203075613521SMike Christie * @initial_cmdsn: initial CmdSN 203175613521SMike Christie * 203275613521SMike Christie * This can be used by software iscsi_transports that allocate 203375613521SMike Christie * a session per scsi host. 20343cf7b233SMike Christie * 20353cf7b233SMike Christie * Callers should set cmds_max to the largest total numer (mgmt + scsi) of 20363cf7b233SMike Christie * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks 20373cf7b233SMike Christie * for nop handling and login/logout requests. 203875613521SMike Christie */ 203975613521SMike Christie struct iscsi_cls_session * 204075613521SMike Christie iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, 20413cf7b233SMike Christie uint16_t cmds_max, int cmd_task_size, 20427970634bSMike Christie uint32_t initial_cmdsn, unsigned int id) 204375613521SMike Christie { 2044e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 204575613521SMike Christie struct iscsi_session *session; 204675613521SMike Christie struct iscsi_cls_session *cls_session; 20473cf7b233SMike Christie int cmd_i, scsi_cmds, total_cmds = cmds_max; 2048e5bd7b54SMike Christie unsigned long flags; 2049e5bd7b54SMike Christie 2050e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2051e5bd7b54SMike Christie if (ihost->state == ISCSI_HOST_REMOVED) { 2052e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2053e5bd7b54SMike Christie return NULL; 2054e5bd7b54SMike Christie } 2055e5bd7b54SMike Christie ihost->num_sessions++; 2056e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 20578e9a20ceSMike Christie 20588e9a20ceSMike Christie if (!total_cmds) 20598e9a20ceSMike Christie total_cmds = ISCSI_DEF_XMIT_CMDS_MAX; 20603e5c28adSMike Christie /* 20613cf7b233SMike Christie * The iscsi layer needs some tasks for nop handling and tmfs, 20623cf7b233SMike Christie * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX 20633cf7b233SMike Christie * + 1 command for scsi IO. 20643e5c28adSMike Christie */ 20653cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 20663cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 20673cf7b233SMike Christie "must be a power of two that is at least %d.\n", 20683cf7b233SMike Christie total_cmds, ISCSI_TOTAL_CMDS_MIN); 2069e5bd7b54SMike Christie goto dec_session_count; 20701548271eSMike Christie } 20713cf7b233SMike Christie 20723cf7b233SMike Christie if (total_cmds > ISCSI_TOTAL_CMDS_MAX) { 20733cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 20743cf7b233SMike Christie "must be a power of 2 less than or equal to %d.\n", 20753cf7b233SMike Christie cmds_max, ISCSI_TOTAL_CMDS_MAX); 20763cf7b233SMike Christie total_cmds = ISCSI_TOTAL_CMDS_MAX; 20773cf7b233SMike Christie } 20783cf7b233SMike Christie 20793cf7b233SMike Christie if (!is_power_of_2(total_cmds)) { 20803cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 20813cf7b233SMike Christie "must be a power of 2.\n", total_cmds); 20823cf7b233SMike Christie total_cmds = rounddown_pow_of_two(total_cmds); 20833cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) 20843cf7b233SMike Christie return NULL; 20853cf7b233SMike Christie printk(KERN_INFO "iscsi: Rounding can_queue to %d.\n", 20863cf7b233SMike Christie total_cmds); 20873cf7b233SMike Christie } 20883cf7b233SMike Christie scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX; 20891548271eSMike Christie 20905d91e209SMike Christie cls_session = iscsi_alloc_session(shost, iscsit, 20915d91e209SMike Christie sizeof(struct iscsi_session)); 209275613521SMike Christie if (!cls_session) 2093e5bd7b54SMike Christie goto dec_session_count; 209475613521SMike Christie session = cls_session->dd_data; 209575613521SMike Christie session->cls_session = cls_session; 20967996a778SMike Christie session->host = shost; 20977996a778SMike Christie session->state = ISCSI_STATE_FREE; 2098f6d5180cSMike Christie session->fast_abort = 1; 20994cd49ea1SMike Christie session->lu_reset_timeout = 15; 21004cd49ea1SMike Christie session->abort_timeout = 10; 21013cf7b233SMike Christie session->scsi_cmds_max = scsi_cmds; 21023cf7b233SMike Christie session->cmds_max = total_cmds; 2103e0726407SMike Christie session->queued_cmdsn = session->cmdsn = initial_cmdsn; 21047996a778SMike Christie session->exp_cmdsn = initial_cmdsn + 1; 21057996a778SMike Christie session->max_cmdsn = initial_cmdsn + 1; 21067996a778SMike Christie session->max_r2t = 1; 21077996a778SMike Christie session->tt = iscsit; 21086724add1SMike Christie mutex_init(&session->eh_mutex); 210975613521SMike Christie spin_lock_init(&session->lock); 21107996a778SMike Christie 21117996a778SMike Christie /* initialize SCSI PDU commands pool */ 21127996a778SMike Christie if (iscsi_pool_init(&session->cmdpool, session->cmds_max, 21137996a778SMike Christie (void***)&session->cmds, 21149c19a7d0SMike Christie cmd_task_size + sizeof(struct iscsi_task))) 21157996a778SMike Christie goto cmdpool_alloc_fail; 21167996a778SMike Christie 21177996a778SMike Christie /* pre-format cmds pool with ITT */ 21187996a778SMike Christie for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) { 21199c19a7d0SMike Christie struct iscsi_task *task = session->cmds[cmd_i]; 21207996a778SMike Christie 21219c19a7d0SMike Christie if (cmd_task_size) 21229c19a7d0SMike Christie task->dd_data = &task[1]; 21239c19a7d0SMike Christie task->itt = cmd_i; 21249c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 21257996a778SMike Christie } 21267996a778SMike Christie 2127f53a88daSMike Christie if (!try_module_get(iscsit->owner)) 212875613521SMike Christie goto module_get_fail; 212975613521SMike Christie 21307970634bSMike Christie if (iscsi_add_session(cls_session, id)) 2131f53a88daSMike Christie goto cls_session_fail; 2132e5bd7b54SMike Christie 21337996a778SMike Christie return cls_session; 21347996a778SMike Christie 21357996a778SMike Christie cls_session_fail: 213675613521SMike Christie module_put(iscsit->owner); 213775613521SMike Christie module_get_fail: 21386320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 21397996a778SMike Christie cmdpool_alloc_fail: 214075613521SMike Christie iscsi_free_session(cls_session); 2141e5bd7b54SMike Christie dec_session_count: 2142e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 21437996a778SMike Christie return NULL; 21447996a778SMike Christie } 21457996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_setup); 21467996a778SMike Christie 21477996a778SMike Christie /** 21487996a778SMike Christie * iscsi_session_teardown - destroy session, host, and cls_session 214975613521SMike Christie * @cls_session: iscsi session 21507996a778SMike Christie * 215175613521SMike Christie * The driver must have called iscsi_remove_session before 215275613521SMike Christie * calling this. 215375613521SMike Christie */ 21547996a778SMike Christie void iscsi_session_teardown(struct iscsi_cls_session *cls_session) 21557996a778SMike Christie { 215675613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 215763f75cc8SMike Christie struct module *owner = cls_session->transport->owner; 2158e5bd7b54SMike Christie struct Scsi_Host *shost = session->host; 21597996a778SMike Christie 21606320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 21617996a778SMike Christie 2162b2c64167SMike Christie kfree(session->password); 2163b2c64167SMike Christie kfree(session->password_in); 2164b2c64167SMike Christie kfree(session->username); 2165b2c64167SMike Christie kfree(session->username_in); 2166f3ff0c36SMike Christie kfree(session->targetname); 216788dfd340SMike Christie kfree(session->initiatorname); 216888dfd340SMike Christie kfree(session->ifacename); 2169f3ff0c36SMike Christie 217075613521SMike Christie iscsi_destroy_session(cls_session); 2171e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 217263f75cc8SMike Christie module_put(owner); 21737996a778SMike Christie } 21747996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_teardown); 21757996a778SMike Christie 21767996a778SMike Christie /** 21777996a778SMike Christie * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn 21787996a778SMike Christie * @cls_session: iscsi_cls_session 21795d91e209SMike Christie * @dd_size: private driver data size 21807996a778SMike Christie * @conn_idx: cid 21815d91e209SMike Christie */ 21827996a778SMike Christie struct iscsi_cls_conn * 21835d91e209SMike Christie iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, 21845d91e209SMike Christie uint32_t conn_idx) 21857996a778SMike Christie { 218675613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 21877996a778SMike Christie struct iscsi_conn *conn; 21887996a778SMike Christie struct iscsi_cls_conn *cls_conn; 2189d36ab6f3SMike Christie char *data; 21907996a778SMike Christie 21915d91e209SMike Christie cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size, 21925d91e209SMike Christie conn_idx); 21937996a778SMike Christie if (!cls_conn) 21947996a778SMike Christie return NULL; 21957996a778SMike Christie conn = cls_conn->dd_data; 21965d91e209SMike Christie memset(conn, 0, sizeof(*conn) + dd_size); 21977996a778SMike Christie 21985d91e209SMike Christie conn->dd_data = cls_conn->dd_data + sizeof(*conn); 21997996a778SMike Christie conn->session = session; 22007996a778SMike Christie conn->cls_conn = cls_conn; 22017996a778SMike Christie conn->c_stage = ISCSI_CONN_INITIAL_STAGE; 22027996a778SMike Christie conn->id = conn_idx; 22037996a778SMike Christie conn->exp_statsn = 0; 2204843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2205f6d5180cSMike Christie 2206f6d5180cSMike Christie init_timer(&conn->transport_timer); 2207f6d5180cSMike Christie conn->transport_timer.data = (unsigned long)conn; 2208f6d5180cSMike Christie conn->transport_timer.function = iscsi_check_transport_timeouts; 2209f6d5180cSMike Christie 22107996a778SMike Christie INIT_LIST_HEAD(&conn->run_list); 22117996a778SMike Christie INIT_LIST_HEAD(&conn->mgmt_run_list); 2212843c0a8aSMike Christie INIT_LIST_HEAD(&conn->mgmtqueue); 2213b6c395edSMike Christie INIT_LIST_HEAD(&conn->xmitqueue); 2214843c0a8aSMike Christie INIT_LIST_HEAD(&conn->requeue); 2215c4028958SDavid Howells INIT_WORK(&conn->xmitwork, iscsi_xmitworker); 22167996a778SMike Christie 22179c19a7d0SMike Christie /* allocate login_task used for the login/text sequences */ 22187996a778SMike Christie spin_lock_bh(&session->lock); 22193e5c28adSMike Christie if (!__kfifo_get(session->cmdpool.queue, 22209c19a7d0SMike Christie (void*)&conn->login_task, 22217996a778SMike Christie sizeof(void*))) { 22227996a778SMike Christie spin_unlock_bh(&session->lock); 22239c19a7d0SMike Christie goto login_task_alloc_fail; 22247996a778SMike Christie } 22257996a778SMike Christie spin_unlock_bh(&session->lock); 22267996a778SMike Christie 2227bf32ed33SMike Christie data = kmalloc(ISCSI_DEF_MAX_RECV_SEG_LEN, GFP_KERNEL); 2228d36ab6f3SMike Christie if (!data) 22299c19a7d0SMike Christie goto login_task_data_alloc_fail; 22309c19a7d0SMike Christie conn->login_task->data = conn->data = data; 2231d36ab6f3SMike Christie 2232843c0a8aSMike Christie init_timer(&conn->tmf_timer); 22337996a778SMike Christie init_waitqueue_head(&conn->ehwait); 22347996a778SMike Christie 22357996a778SMike Christie return cls_conn; 22367996a778SMike Christie 22379c19a7d0SMike Christie login_task_data_alloc_fail: 22389c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task, 2239d36ab6f3SMike Christie sizeof(void*)); 22409c19a7d0SMike Christie login_task_alloc_fail: 22417996a778SMike Christie iscsi_destroy_conn(cls_conn); 22427996a778SMike Christie return NULL; 22437996a778SMike Christie } 22447996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_setup); 22457996a778SMike Christie 22467996a778SMike Christie /** 22477996a778SMike Christie * iscsi_conn_teardown - teardown iscsi connection 22487996a778SMike Christie * cls_conn: iscsi class connection 22497996a778SMike Christie * 22507996a778SMike Christie * TODO: we may need to make this into a two step process 22517996a778SMike Christie * like scsi-mls remove + put host 22527996a778SMike Christie */ 22537996a778SMike Christie void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) 22547996a778SMike Christie { 22557996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 22567996a778SMike Christie struct iscsi_session *session = conn->session; 22577996a778SMike Christie unsigned long flags; 22587996a778SMike Christie 2259f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 2260f6d5180cSMike Christie 22617996a778SMike Christie spin_lock_bh(&session->lock); 22627996a778SMike Christie conn->c_stage = ISCSI_CONN_CLEANUP_WAIT; 22637996a778SMike Christie if (session->leadconn == conn) { 22647996a778SMike Christie /* 22657996a778SMike Christie * leading connection? then give up on recovery. 22667996a778SMike Christie */ 22677996a778SMike Christie session->state = ISCSI_STATE_TERMINATE; 22687996a778SMike Christie wake_up(&conn->ehwait); 22697996a778SMike Christie } 22707996a778SMike Christie spin_unlock_bh(&session->lock); 22717996a778SMike Christie 22727996a778SMike Christie /* 22737996a778SMike Christie * Block until all in-progress commands for this connection 22747996a778SMike Christie * time out or fail. 22757996a778SMike Christie */ 22767996a778SMike Christie for (;;) { 22777996a778SMike Christie spin_lock_irqsave(session->host->host_lock, flags); 22787996a778SMike Christie if (!session->host->host_busy) { /* OK for ERL == 0 */ 22797996a778SMike Christie spin_unlock_irqrestore(session->host->host_lock, flags); 22807996a778SMike Christie break; 22817996a778SMike Christie } 22827996a778SMike Christie spin_unlock_irqrestore(session->host->host_lock, flags); 22837996a778SMike Christie msleep_interruptible(500); 2284322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "iscsi conn_destroy(): " 2285322d739dSMike Christie "host_busy %d host_failed %d\n", 2286322d739dSMike Christie session->host->host_busy, 2287be2df72eSOr Gerlitz session->host->host_failed); 22887996a778SMike Christie /* 22897996a778SMike Christie * force eh_abort() to unblock 22907996a778SMike Christie */ 22917996a778SMike Christie wake_up(&conn->ehwait); 22927996a778SMike Christie } 22937996a778SMike Christie 2294779ea120SMike Christie /* flush queued up work because we free the connection below */ 2295843c0a8aSMike Christie iscsi_suspend_tx(conn); 2296779ea120SMike Christie 22977996a778SMike Christie spin_lock_bh(&session->lock); 2298c8dc1e52SMike Christie kfree(conn->data); 2299f3ff0c36SMike Christie kfree(conn->persistent_address); 23009c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task, 23017996a778SMike Christie sizeof(void*)); 2302e0726407SMike Christie if (session->leadconn == conn) 23037996a778SMike Christie session->leadconn = NULL; 23047996a778SMike Christie spin_unlock_bh(&session->lock); 23057996a778SMike Christie 23067996a778SMike Christie iscsi_destroy_conn(cls_conn); 23077996a778SMike Christie } 23087996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_teardown); 23097996a778SMike Christie 23107996a778SMike Christie int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 23117996a778SMike Christie { 23127996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 23137996a778SMike Christie struct iscsi_session *session = conn->session; 23147996a778SMike Christie 2315ffd0436eSMike Christie if (!session) { 2316322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 2317322d739dSMike Christie "can't start unbound connection\n"); 23187996a778SMike Christie return -EPERM; 23197996a778SMike Christie } 23207996a778SMike Christie 2321db98ccdeSMike Christie if ((session->imm_data_en || !session->initial_r2t_en) && 2322db98ccdeSMike Christie session->first_burst > session->max_burst) { 2323322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: " 2324ffd0436eSMike Christie "first_burst %d max_burst %d\n", 2325ffd0436eSMike Christie session->first_burst, session->max_burst); 2326ffd0436eSMike Christie return -EINVAL; 2327ffd0436eSMike Christie } 2328ffd0436eSMike Christie 2329f6d5180cSMike Christie if (conn->ping_timeout && !conn->recv_timeout) { 2330322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of " 2331322d739dSMike Christie "zero. Using 5 seconds\n."); 2332f6d5180cSMike Christie conn->recv_timeout = 5; 2333f6d5180cSMike Christie } 2334f6d5180cSMike Christie 2335f6d5180cSMike Christie if (conn->recv_timeout && !conn->ping_timeout) { 2336322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of " 2337322d739dSMike Christie "zero. Using 5 seconds.\n"); 2338f6d5180cSMike Christie conn->ping_timeout = 5; 2339f6d5180cSMike Christie } 2340f6d5180cSMike Christie 23417996a778SMike Christie spin_lock_bh(&session->lock); 23427996a778SMike Christie conn->c_stage = ISCSI_CONN_STARTED; 23437996a778SMike Christie session->state = ISCSI_STATE_LOGGED_IN; 2344e0726407SMike Christie session->queued_cmdsn = session->cmdsn; 23457996a778SMike Christie 2346f6d5180cSMike Christie conn->last_recv = jiffies; 2347f6d5180cSMike Christie conn->last_ping = jiffies; 2348f6d5180cSMike Christie if (conn->recv_timeout && conn->ping_timeout) 2349f6d5180cSMike Christie mod_timer(&conn->transport_timer, 2350f6d5180cSMike Christie jiffies + (conn->recv_timeout * HZ)); 2351f6d5180cSMike Christie 23527996a778SMike Christie switch(conn->stop_stage) { 23537996a778SMike Christie case STOP_CONN_RECOVER: 23547996a778SMike Christie /* 23557996a778SMike Christie * unblock eh_abort() if it is blocked. re-try all 23567996a778SMike Christie * commands after successful recovery 23577996a778SMike Christie */ 23587996a778SMike Christie conn->stop_stage = 0; 2359843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 23607996a778SMike Christie session->age++; 23618b1d0343SMike Christie if (session->age == 16) 23628b1d0343SMike Christie session->age = 0; 23636eabafbeSMike Christie break; 23647996a778SMike Christie case STOP_CONN_TERM: 23657996a778SMike Christie conn->stop_stage = 0; 23667996a778SMike Christie break; 23677996a778SMike Christie default: 23687996a778SMike Christie break; 23697996a778SMike Christie } 23707996a778SMike Christie spin_unlock_bh(&session->lock); 23717996a778SMike Christie 237275613521SMike Christie iscsi_unblock_session(session->cls_session); 23736eabafbeSMike Christie wake_up(&conn->ehwait); 23747996a778SMike Christie return 0; 23757996a778SMike Christie } 23767996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_start); 23777996a778SMike Christie 23787996a778SMike Christie static void 23797996a778SMike Christie flush_control_queues(struct iscsi_session *session, struct iscsi_conn *conn) 23807996a778SMike Christie { 23819c19a7d0SMike Christie struct iscsi_task *task, *tmp; 23827996a778SMike Christie 23837996a778SMike Christie /* handle pending */ 23849c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->mgmtqueue, running) { 23859c19a7d0SMike Christie debug_scsi("flushing pending mgmt task itt 0x%x\n", task->itt); 23869c19a7d0SMike Christie /* release ref from prep task */ 23879c19a7d0SMike Christie __iscsi_put_task(task); 23887996a778SMike Christie } 23897996a778SMike Christie 23907996a778SMike Christie /* handle running */ 23919c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->mgmt_run_list, running) { 23929c19a7d0SMike Christie debug_scsi("flushing running mgmt task itt 0x%x\n", task->itt); 23939c19a7d0SMike Christie /* release ref from prep task */ 23949c19a7d0SMike Christie __iscsi_put_task(task); 23957996a778SMike Christie } 23967996a778SMike Christie 23979c19a7d0SMike Christie conn->task = NULL; 23987996a778SMike Christie } 23997996a778SMike Christie 2400656cffc9SMike Christie static void iscsi_start_session_recovery(struct iscsi_session *session, 24017996a778SMike Christie struct iscsi_conn *conn, int flag) 24027996a778SMike Christie { 2403ed2abc7fSMike Christie int old_stop_stage; 2404ed2abc7fSMike Christie 2405f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 2406f6d5180cSMike Christie 24076724add1SMike Christie mutex_lock(&session->eh_mutex); 24087996a778SMike Christie spin_lock_bh(&session->lock); 2409ed2abc7fSMike Christie if (conn->stop_stage == STOP_CONN_TERM) { 24107996a778SMike Christie spin_unlock_bh(&session->lock); 24116724add1SMike Christie mutex_unlock(&session->eh_mutex); 24126724add1SMike Christie return; 24136724add1SMike Christie } 24146724add1SMike Christie 24156724add1SMike Christie /* 2416ed2abc7fSMike Christie * When this is called for the in_login state, we only want to clean 24179c19a7d0SMike Christie * up the login task and connection. We do not need to block and set 241867a61114SMike Christie * the recovery state again 2419ed2abc7fSMike Christie */ 242067a61114SMike Christie if (flag == STOP_CONN_TERM) 242167a61114SMike Christie session->state = ISCSI_STATE_TERMINATE; 242267a61114SMike Christie else if (conn->stop_stage != STOP_CONN_RECOVER) 242367a61114SMike Christie session->state = ISCSI_STATE_IN_RECOVERY; 2424ed2abc7fSMike Christie 2425ed2abc7fSMike Christie old_stop_stage = conn->stop_stage; 24267996a778SMike Christie conn->stop_stage = flag; 242767a61114SMike Christie conn->c_stage = ISCSI_CONN_STOPPED; 24287996a778SMike Christie spin_unlock_bh(&session->lock); 24296724add1SMike Christie 24306724add1SMike Christie iscsi_suspend_tx(conn); 24317996a778SMike Christie /* 24327996a778SMike Christie * for connection level recovery we should not calculate 24337996a778SMike Christie * header digest. conn->hdr_size used for optimization 24347996a778SMike Christie * in hdr_extract() and will be re-negotiated at 24357996a778SMike Christie * set_param() time. 24367996a778SMike Christie */ 24377996a778SMike Christie if (flag == STOP_CONN_RECOVER) { 24387996a778SMike Christie conn->hdrdgst_en = 0; 24397996a778SMike Christie conn->datadgst_en = 0; 2440656cffc9SMike Christie if (session->state == ISCSI_STATE_IN_RECOVERY && 244167a61114SMike Christie old_stop_stage != STOP_CONN_RECOVER) { 244267a61114SMike Christie debug_scsi("blocking session\n"); 244375613521SMike Christie iscsi_block_session(session->cls_session); 24447996a778SMike Christie } 244567a61114SMike Christie } 2446656cffc9SMike Christie 2447656cffc9SMike Christie /* 2448656cffc9SMike Christie * flush queues. 2449656cffc9SMike Christie */ 2450656cffc9SMike Christie spin_lock_bh(&session->lock); 245187cd9eabSMike Christie if (flag == STOP_CONN_RECOVER) 245256d7fcfaSMike Christie fail_all_commands(conn, -1, DID_TRANSPORT_DISRUPTED); 245356d7fcfaSMike Christie else 245456d7fcfaSMike Christie fail_all_commands(conn, -1, DID_ERROR); 2455656cffc9SMike Christie flush_control_queues(session, conn); 2456656cffc9SMike Christie spin_unlock_bh(&session->lock); 24576724add1SMike Christie mutex_unlock(&session->eh_mutex); 24587996a778SMike Christie } 24597996a778SMike Christie 24607996a778SMike Christie void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 24617996a778SMike Christie { 24627996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 24637996a778SMike Christie struct iscsi_session *session = conn->session; 24647996a778SMike Christie 24657996a778SMike Christie switch (flag) { 24667996a778SMike Christie case STOP_CONN_RECOVER: 24677996a778SMike Christie case STOP_CONN_TERM: 24687996a778SMike Christie iscsi_start_session_recovery(session, conn, flag); 24698d2860b3SMike Christie break; 24707996a778SMike Christie default: 2471322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 2472322d739dSMike Christie "invalid stop flag %d\n", flag); 24737996a778SMike Christie } 24747996a778SMike Christie } 24757996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_stop); 24767996a778SMike Christie 24777996a778SMike Christie int iscsi_conn_bind(struct iscsi_cls_session *cls_session, 24787996a778SMike Christie struct iscsi_cls_conn *cls_conn, int is_leading) 24797996a778SMike Christie { 248075613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 248198644047SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 24827996a778SMike Christie 24837996a778SMike Christie spin_lock_bh(&session->lock); 24847996a778SMike Christie if (is_leading) 24857996a778SMike Christie session->leadconn = conn; 248698644047SMike Christie spin_unlock_bh(&session->lock); 24877996a778SMike Christie 24887996a778SMike Christie /* 24897996a778SMike Christie * Unblock xmitworker(), Login Phase will pass through. 24907996a778SMike Christie */ 24917996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 24927996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 24937996a778SMike Christie return 0; 24947996a778SMike Christie } 24957996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_bind); 24967996a778SMike Christie 2497a54a52caSMike Christie 2498a54a52caSMike Christie int iscsi_set_param(struct iscsi_cls_conn *cls_conn, 2499a54a52caSMike Christie enum iscsi_param param, char *buf, int buflen) 2500a54a52caSMike Christie { 2501a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 2502a54a52caSMike Christie struct iscsi_session *session = conn->session; 2503a54a52caSMike Christie uint32_t value; 2504a54a52caSMike Christie 2505a54a52caSMike Christie switch(param) { 2506843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 2507843c0a8aSMike Christie sscanf(buf, "%d", &session->fast_abort); 2508843c0a8aSMike Christie break; 2509f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 2510f6d5180cSMike Christie sscanf(buf, "%d", &session->abort_timeout); 2511f6d5180cSMike Christie break; 2512f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 2513f6d5180cSMike Christie sscanf(buf, "%d", &session->lu_reset_timeout); 2514f6d5180cSMike Christie break; 2515f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 2516f6d5180cSMike Christie sscanf(buf, "%d", &conn->ping_timeout); 2517f6d5180cSMike Christie break; 2518f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 2519f6d5180cSMike Christie sscanf(buf, "%d", &conn->recv_timeout); 2520f6d5180cSMike Christie break; 2521a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 2522a54a52caSMike Christie sscanf(buf, "%d", &conn->max_recv_dlength); 2523a54a52caSMike Christie break; 2524a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 2525a54a52caSMike Christie sscanf(buf, "%d", &conn->max_xmit_dlength); 2526a54a52caSMike Christie break; 2527a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 2528a54a52caSMike Christie sscanf(buf, "%d", &conn->hdrdgst_en); 2529a54a52caSMike Christie break; 2530a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 2531a54a52caSMike Christie sscanf(buf, "%d", &conn->datadgst_en); 2532a54a52caSMike Christie break; 2533a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 2534a54a52caSMike Christie sscanf(buf, "%d", &session->initial_r2t_en); 2535a54a52caSMike Christie break; 2536a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 2537a54a52caSMike Christie sscanf(buf, "%d", &session->max_r2t); 2538a54a52caSMike Christie break; 2539a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 2540a54a52caSMike Christie sscanf(buf, "%d", &session->imm_data_en); 2541a54a52caSMike Christie break; 2542a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 2543a54a52caSMike Christie sscanf(buf, "%d", &session->first_burst); 2544a54a52caSMike Christie break; 2545a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 2546a54a52caSMike Christie sscanf(buf, "%d", &session->max_burst); 2547a54a52caSMike Christie break; 2548a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 2549a54a52caSMike Christie sscanf(buf, "%d", &session->pdu_inorder_en); 2550a54a52caSMike Christie break; 2551a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 2552a54a52caSMike Christie sscanf(buf, "%d", &session->dataseq_inorder_en); 2553a54a52caSMike Christie break; 2554a54a52caSMike Christie case ISCSI_PARAM_ERL: 2555a54a52caSMike Christie sscanf(buf, "%d", &session->erl); 2556a54a52caSMike Christie break; 2557a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 2558a54a52caSMike Christie sscanf(buf, "%d", &value); 2559a54a52caSMike Christie BUG_ON(value); 2560a54a52caSMike Christie break; 2561a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 2562a54a52caSMike Christie sscanf(buf, "%d", &value); 2563a54a52caSMike Christie BUG_ON(value); 2564a54a52caSMike Christie break; 2565a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 2566a54a52caSMike Christie sscanf(buf, "%u", &conn->exp_statsn); 2567a54a52caSMike Christie break; 2568b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 2569b2c64167SMike Christie kfree(session->username); 2570b2c64167SMike Christie session->username = kstrdup(buf, GFP_KERNEL); 2571b2c64167SMike Christie if (!session->username) 2572b2c64167SMike Christie return -ENOMEM; 2573b2c64167SMike Christie break; 2574b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 2575b2c64167SMike Christie kfree(session->username_in); 2576b2c64167SMike Christie session->username_in = kstrdup(buf, GFP_KERNEL); 2577b2c64167SMike Christie if (!session->username_in) 2578b2c64167SMike Christie return -ENOMEM; 2579b2c64167SMike Christie break; 2580b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 2581b2c64167SMike Christie kfree(session->password); 2582b2c64167SMike Christie session->password = kstrdup(buf, GFP_KERNEL); 2583b2c64167SMike Christie if (!session->password) 2584b2c64167SMike Christie return -ENOMEM; 2585b2c64167SMike Christie break; 2586b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 2587b2c64167SMike Christie kfree(session->password_in); 2588b2c64167SMike Christie session->password_in = kstrdup(buf, GFP_KERNEL); 2589b2c64167SMike Christie if (!session->password_in) 2590b2c64167SMike Christie return -ENOMEM; 2591b2c64167SMike Christie break; 2592a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 2593a54a52caSMike Christie /* this should not change between logins */ 2594a54a52caSMike Christie if (session->targetname) 2595a54a52caSMike Christie break; 2596a54a52caSMike Christie 2597a54a52caSMike Christie session->targetname = kstrdup(buf, GFP_KERNEL); 2598a54a52caSMike Christie if (!session->targetname) 2599a54a52caSMike Christie return -ENOMEM; 2600a54a52caSMike Christie break; 2601a54a52caSMike Christie case ISCSI_PARAM_TPGT: 2602a54a52caSMike Christie sscanf(buf, "%d", &session->tpgt); 2603a54a52caSMike Christie break; 2604a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 2605a54a52caSMike Christie sscanf(buf, "%d", &conn->persistent_port); 2606a54a52caSMike Christie break; 2607a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 2608a54a52caSMike Christie /* 2609a54a52caSMike Christie * this is the address returned in discovery so it should 2610a54a52caSMike Christie * not change between logins. 2611a54a52caSMike Christie */ 2612a54a52caSMike Christie if (conn->persistent_address) 2613a54a52caSMike Christie break; 2614a54a52caSMike Christie 2615a54a52caSMike Christie conn->persistent_address = kstrdup(buf, GFP_KERNEL); 2616a54a52caSMike Christie if (!conn->persistent_address) 2617a54a52caSMike Christie return -ENOMEM; 2618a54a52caSMike Christie break; 261988dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 262088dfd340SMike Christie if (!session->ifacename) 262188dfd340SMike Christie session->ifacename = kstrdup(buf, GFP_KERNEL); 262288dfd340SMike Christie break; 262388dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 262488dfd340SMike Christie if (!session->initiatorname) 262588dfd340SMike Christie session->initiatorname = kstrdup(buf, GFP_KERNEL); 262688dfd340SMike Christie break; 2627a54a52caSMike Christie default: 2628a54a52caSMike Christie return -ENOSYS; 2629a54a52caSMike Christie } 2630a54a52caSMike Christie 2631a54a52caSMike Christie return 0; 2632a54a52caSMike Christie } 2633a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_set_param); 2634a54a52caSMike Christie 2635a54a52caSMike Christie int iscsi_session_get_param(struct iscsi_cls_session *cls_session, 2636a54a52caSMike Christie enum iscsi_param param, char *buf) 2637a54a52caSMike Christie { 263875613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 2639a54a52caSMike Christie int len; 2640a54a52caSMike Christie 2641a54a52caSMike Christie switch(param) { 2642843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 2643843c0a8aSMike Christie len = sprintf(buf, "%d\n", session->fast_abort); 2644843c0a8aSMike Christie break; 2645f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 2646f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->abort_timeout); 2647f6d5180cSMike Christie break; 2648f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 2649f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->lu_reset_timeout); 2650f6d5180cSMike Christie break; 2651a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 2652a54a52caSMike Christie len = sprintf(buf, "%d\n", session->initial_r2t_en); 2653a54a52caSMike Christie break; 2654a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 2655a54a52caSMike Christie len = sprintf(buf, "%hu\n", session->max_r2t); 2656a54a52caSMike Christie break; 2657a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 2658a54a52caSMike Christie len = sprintf(buf, "%d\n", session->imm_data_en); 2659a54a52caSMike Christie break; 2660a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 2661a54a52caSMike Christie len = sprintf(buf, "%u\n", session->first_burst); 2662a54a52caSMike Christie break; 2663a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 2664a54a52caSMike Christie len = sprintf(buf, "%u\n", session->max_burst); 2665a54a52caSMike Christie break; 2666a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 2667a54a52caSMike Christie len = sprintf(buf, "%d\n", session->pdu_inorder_en); 2668a54a52caSMike Christie break; 2669a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 2670a54a52caSMike Christie len = sprintf(buf, "%d\n", session->dataseq_inorder_en); 2671a54a52caSMike Christie break; 2672a54a52caSMike Christie case ISCSI_PARAM_ERL: 2673a54a52caSMike Christie len = sprintf(buf, "%d\n", session->erl); 2674a54a52caSMike Christie break; 2675a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 2676a54a52caSMike Christie len = sprintf(buf, "%s\n", session->targetname); 2677a54a52caSMike Christie break; 2678a54a52caSMike Christie case ISCSI_PARAM_TPGT: 2679a54a52caSMike Christie len = sprintf(buf, "%d\n", session->tpgt); 2680a54a52caSMike Christie break; 2681b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 2682b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username); 2683b2c64167SMike Christie break; 2684b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 2685b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username_in); 2686b2c64167SMike Christie break; 2687b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 2688b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password); 2689b2c64167SMike Christie break; 2690b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 2691b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password_in); 2692b2c64167SMike Christie break; 269388dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 269488dfd340SMike Christie len = sprintf(buf, "%s\n", session->ifacename); 269588dfd340SMike Christie break; 269688dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 269788dfd340SMike Christie if (!session->initiatorname) 269888dfd340SMike Christie len = sprintf(buf, "%s\n", "unknown"); 269988dfd340SMike Christie else 270088dfd340SMike Christie len = sprintf(buf, "%s\n", session->initiatorname); 270188dfd340SMike Christie break; 2702a54a52caSMike Christie default: 2703a54a52caSMike Christie return -ENOSYS; 2704a54a52caSMike Christie } 2705a54a52caSMike Christie 2706a54a52caSMike Christie return len; 2707a54a52caSMike Christie } 2708a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_get_param); 2709a54a52caSMike Christie 2710a54a52caSMike Christie int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, 2711a54a52caSMike Christie enum iscsi_param param, char *buf) 2712a54a52caSMike Christie { 2713a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 2714a54a52caSMike Christie int len; 2715a54a52caSMike Christie 2716a54a52caSMike Christie switch(param) { 2717f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 2718f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->ping_timeout); 2719f6d5180cSMike Christie break; 2720f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 2721f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->recv_timeout); 2722f6d5180cSMike Christie break; 2723a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 2724a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_recv_dlength); 2725a54a52caSMike Christie break; 2726a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 2727a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_xmit_dlength); 2728a54a52caSMike Christie break; 2729a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 2730a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->hdrdgst_en); 2731a54a52caSMike Christie break; 2732a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 2733a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->datadgst_en); 2734a54a52caSMike Christie break; 2735a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 2736a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ifmarker_en); 2737a54a52caSMike Christie break; 2738a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 2739a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ofmarker_en); 2740a54a52caSMike Christie break; 2741a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 2742a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->exp_statsn); 2743a54a52caSMike Christie break; 2744a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 2745a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->persistent_port); 2746a54a52caSMike Christie break; 2747a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 2748a54a52caSMike Christie len = sprintf(buf, "%s\n", conn->persistent_address); 2749a54a52caSMike Christie break; 2750a54a52caSMike Christie default: 2751a54a52caSMike Christie return -ENOSYS; 2752a54a52caSMike Christie } 2753a54a52caSMike Christie 2754a54a52caSMike Christie return len; 2755a54a52caSMike Christie } 2756a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_param); 2757a54a52caSMike Christie 27580801c242SMike Christie int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param, 27590801c242SMike Christie char *buf) 27600801c242SMike Christie { 276175613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 27620801c242SMike Christie int len; 27630801c242SMike Christie 27640801c242SMike Christie switch (param) { 2765d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 276675613521SMike Christie if (!ihost->netdev) 2767d8196ed2SMike Christie len = sprintf(buf, "%s\n", "default"); 2768d8196ed2SMike Christie else 276975613521SMike Christie len = sprintf(buf, "%s\n", ihost->netdev); 2770d8196ed2SMike Christie break; 27710801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 277275613521SMike Christie if (!ihost->hwaddress) 27730801c242SMike Christie len = sprintf(buf, "%s\n", "default"); 27740801c242SMike Christie else 277575613521SMike Christie len = sprintf(buf, "%s\n", ihost->hwaddress); 27760801c242SMike Christie break; 27778ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 277875613521SMike Christie if (!ihost->initiatorname) 27798ad5781aSMike Christie len = sprintf(buf, "%s\n", "unknown"); 27808ad5781aSMike Christie else 278175613521SMike Christie len = sprintf(buf, "%s\n", ihost->initiatorname); 27828ad5781aSMike Christie break; 278375613521SMike Christie case ISCSI_HOST_PARAM_IPADDRESS: 278475613521SMike Christie if (!strlen(ihost->local_address)) 278575613521SMike Christie len = sprintf(buf, "%s\n", "unknown"); 278675613521SMike Christie else 278775613521SMike Christie len = sprintf(buf, "%s\n", 278875613521SMike Christie ihost->local_address); 278988dfd340SMike Christie break; 27900801c242SMike Christie default: 27910801c242SMike Christie return -ENOSYS; 27920801c242SMike Christie } 27930801c242SMike Christie 27940801c242SMike Christie return len; 27950801c242SMike Christie } 27960801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_param); 27970801c242SMike Christie 27980801c242SMike Christie int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param, 27990801c242SMike Christie char *buf, int buflen) 28000801c242SMike Christie { 280175613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 28020801c242SMike Christie 28030801c242SMike Christie switch (param) { 2804d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 280575613521SMike Christie if (!ihost->netdev) 280675613521SMike Christie ihost->netdev = kstrdup(buf, GFP_KERNEL); 2807d8196ed2SMike Christie break; 28080801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 280975613521SMike Christie if (!ihost->hwaddress) 281075613521SMike Christie ihost->hwaddress = kstrdup(buf, GFP_KERNEL); 28110801c242SMike Christie break; 28128ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 281375613521SMike Christie if (!ihost->initiatorname) 281475613521SMike Christie ihost->initiatorname = kstrdup(buf, GFP_KERNEL); 28158ad5781aSMike Christie break; 28160801c242SMike Christie default: 28170801c242SMike Christie return -ENOSYS; 28180801c242SMike Christie } 28190801c242SMike Christie 28200801c242SMike Christie return 0; 28210801c242SMike Christie } 28220801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_set_param); 28230801c242SMike Christie 28247996a778SMike Christie MODULE_AUTHOR("Mike Christie"); 28257996a778SMike Christie MODULE_DESCRIPTION("iSCSI library functions"); 28267996a778SMike Christie MODULE_LICENSE("GPL"); 2827