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> 285a0e3ad6STejun Heo #include <linux/slab.h> 29acf3368fSPaul Gortmaker #include <linux/module.h> 308eb00539SMike Christie #include <asm/unaligned.h> 317996a778SMike Christie #include <net/tcp.h> 327996a778SMike Christie #include <scsi/scsi_cmnd.h> 337996a778SMike Christie #include <scsi/scsi_device.h> 347996a778SMike Christie #include <scsi/scsi_eh.h> 357996a778SMike Christie #include <scsi/scsi_tcq.h> 367996a778SMike Christie #include <scsi/scsi_host.h> 377996a778SMike Christie #include <scsi/scsi.h> 387996a778SMike Christie #include <scsi/iscsi_proto.h> 397996a778SMike Christie #include <scsi/scsi_transport.h> 407996a778SMike Christie #include <scsi/scsi_transport_iscsi.h> 417996a778SMike Christie #include <scsi/libiscsi.h> 427996a778SMike Christie 43bd2199d4SErez Zilber static int iscsi_dbg_lib_conn; 44bd2199d4SErez Zilber module_param_named(debug_libiscsi_conn, iscsi_dbg_lib_conn, int, 45bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 46bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_conn, 47bd2199d4SErez Zilber "Turn on debugging for connections in libiscsi module. " 48bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 49bd2199d4SErez Zilber 50bd2199d4SErez Zilber static int iscsi_dbg_lib_session; 51bd2199d4SErez Zilber module_param_named(debug_libiscsi_session, iscsi_dbg_lib_session, int, 52bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 53bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_session, 54bd2199d4SErez Zilber "Turn on debugging for sessions in libiscsi module. " 55bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 56bd2199d4SErez Zilber 57bd2199d4SErez Zilber static int iscsi_dbg_lib_eh; 58bd2199d4SErez Zilber module_param_named(debug_libiscsi_eh, iscsi_dbg_lib_eh, int, 59bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 60bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_eh, 61bd2199d4SErez Zilber "Turn on debugging for error handling in libiscsi module. " 62bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 631b2c7af8SMike Christie 641b2c7af8SMike Christie #define ISCSI_DBG_CONN(_conn, dbg_fmt, arg...) \ 651b2c7af8SMike Christie do { \ 66bd2199d4SErez Zilber if (iscsi_dbg_lib_conn) \ 671b2c7af8SMike Christie iscsi_conn_printk(KERN_INFO, _conn, \ 681b2c7af8SMike Christie "%s " dbg_fmt, \ 691b2c7af8SMike Christie __func__, ##arg); \ 701b2c7af8SMike Christie } while (0); 711b2c7af8SMike Christie 721b2c7af8SMike Christie #define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...) \ 731b2c7af8SMike Christie do { \ 74bd2199d4SErez Zilber if (iscsi_dbg_lib_session) \ 75bd2199d4SErez Zilber iscsi_session_printk(KERN_INFO, _session, \ 76bd2199d4SErez Zilber "%s " dbg_fmt, \ 77bd2199d4SErez Zilber __func__, ##arg); \ 78bd2199d4SErez Zilber } while (0); 79bd2199d4SErez Zilber 80bd2199d4SErez Zilber #define ISCSI_DBG_EH(_session, dbg_fmt, arg...) \ 81bd2199d4SErez Zilber do { \ 82bd2199d4SErez Zilber if (iscsi_dbg_lib_eh) \ 831b2c7af8SMike Christie iscsi_session_printk(KERN_INFO, _session, \ 841b2c7af8SMike Christie "%s " dbg_fmt, \ 851b2c7af8SMike Christie __func__, ##arg); \ 861b2c7af8SMike Christie } while (0); 871b2c7af8SMike Christie 8832ae763eSMike Christie inline void iscsi_conn_queue_work(struct iscsi_conn *conn) 8932ae763eSMike Christie { 9032ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 9132ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 9232ae763eSMike Christie 931336aed1SMike Christie if (ihost->workq) 9432ae763eSMike Christie queue_work(ihost->workq, &conn->xmitwork); 9532ae763eSMike Christie } 9632ae763eSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_queue_work); 9732ae763eSMike Christie 984c0ba5d2SMike Christie static void __iscsi_update_cmdsn(struct iscsi_session *session, 994c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 1007996a778SMike Christie { 10177a23c21SMike Christie /* 10277a23c21SMike Christie * standard specifies this check for when to update expected and 10377a23c21SMike Christie * max sequence numbers 10477a23c21SMike Christie */ 10577a23c21SMike Christie if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1)) 10677a23c21SMike Christie return; 10777a23c21SMike Christie 10877a23c21SMike Christie if (exp_cmdsn != session->exp_cmdsn && 10977a23c21SMike Christie !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn)) 1107996a778SMike Christie session->exp_cmdsn = exp_cmdsn; 1117996a778SMike Christie 11277a23c21SMike Christie if (max_cmdsn != session->max_cmdsn && 11377a23c21SMike Christie !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) { 11477a23c21SMike Christie session->max_cmdsn = max_cmdsn; 11577a23c21SMike Christie /* 11677a23c21SMike Christie * if the window closed with IO queued, then kick the 11777a23c21SMike Christie * xmit thread 11877a23c21SMike Christie */ 1193bbaaad9SMike Christie if (!list_empty(&session->leadconn->cmdqueue) || 1201336aed1SMike Christie !list_empty(&session->leadconn->mgmtqueue)) 12132ae763eSMike Christie iscsi_conn_queue_work(session->leadconn); 1227996a778SMike Christie } 12377a23c21SMike Christie } 1244c0ba5d2SMike Christie 1254c0ba5d2SMike Christie void iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr) 1264c0ba5d2SMike Christie { 1274c0ba5d2SMike Christie __iscsi_update_cmdsn(session, be32_to_cpu(hdr->exp_cmdsn), 1284c0ba5d2SMike Christie be32_to_cpu(hdr->max_cmdsn)); 1294c0ba5d2SMike Christie } 13077a23c21SMike Christie EXPORT_SYMBOL_GPL(iscsi_update_cmdsn); 1317996a778SMike Christie 132577577daSMike Christie /** 133577577daSMike Christie * iscsi_prep_data_out_pdu - initialize Data-Out 134577577daSMike Christie * @task: scsi command task 135577577daSMike Christie * @r2t: R2T info 136577577daSMike Christie * @hdr: iscsi data in pdu 137577577daSMike Christie * 138577577daSMike Christie * Notes: 139577577daSMike Christie * Initialize Data-Out within this R2T sequence and finds 140577577daSMike Christie * proper data_offset within this SCSI command. 141577577daSMike Christie * 142577577daSMike Christie * This function is called with connection lock taken. 143577577daSMike Christie **/ 144577577daSMike Christie void iscsi_prep_data_out_pdu(struct iscsi_task *task, struct iscsi_r2t_info *r2t, 145ffd0436eSMike Christie struct iscsi_data *hdr) 1467996a778SMike Christie { 1479c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 148577577daSMike Christie unsigned int left = r2t->data_length - r2t->sent; 149577577daSMike Christie 150577577daSMike Christie task->hdr_len = sizeof(struct iscsi_data); 1517996a778SMike Christie 1527996a778SMike Christie memset(hdr, 0, sizeof(struct iscsi_data)); 153577577daSMike Christie hdr->ttt = r2t->ttt; 154577577daSMike Christie hdr->datasn = cpu_to_be32(r2t->datasn); 155577577daSMike Christie r2t->datasn++; 1567996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_DATA_OUT; 15755bdabdfSAndy Grover hdr->lun = task->lun; 158577577daSMike Christie hdr->itt = task->hdr_itt; 159577577daSMike Christie hdr->exp_statsn = r2t->exp_statsn; 160577577daSMike Christie hdr->offset = cpu_to_be32(r2t->data_offset + r2t->sent); 161577577daSMike Christie if (left > conn->max_xmit_dlength) { 1627996a778SMike Christie hton24(hdr->dlength, conn->max_xmit_dlength); 163577577daSMike Christie r2t->data_count = conn->max_xmit_dlength; 1647996a778SMike Christie hdr->flags = 0; 1657996a778SMike Christie } else { 166577577daSMike Christie hton24(hdr->dlength, left); 167577577daSMike Christie r2t->data_count = left; 1687996a778SMike Christie hdr->flags = ISCSI_FLAG_CMD_FINAL; 1697996a778SMike Christie } 170577577daSMike Christie conn->dataout_pdus_cnt++; 1717996a778SMike Christie } 172577577daSMike Christie EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu); 1737996a778SMike Christie 1749c19a7d0SMike Christie static int iscsi_add_hdr(struct iscsi_task *task, unsigned len) 175004d6530SBoaz Harrosh { 1769c19a7d0SMike Christie unsigned exp_len = task->hdr_len + len; 177004d6530SBoaz Harrosh 1789c19a7d0SMike Christie if (exp_len > task->hdr_max) { 179004d6530SBoaz Harrosh WARN_ON(1); 180004d6530SBoaz Harrosh return -EINVAL; 181004d6530SBoaz Harrosh } 182004d6530SBoaz Harrosh 183004d6530SBoaz Harrosh WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */ 1849c19a7d0SMike Christie task->hdr_len = exp_len; 185004d6530SBoaz Harrosh return 0; 186004d6530SBoaz Harrosh } 187004d6530SBoaz Harrosh 18838d1c069SBoaz Harrosh /* 18938d1c069SBoaz Harrosh * make an extended cdb AHS 19038d1c069SBoaz Harrosh */ 1919c19a7d0SMike Christie static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) 19238d1c069SBoaz Harrosh { 1939c19a7d0SMike Christie struct scsi_cmnd *cmd = task->sc; 19438d1c069SBoaz Harrosh unsigned rlen, pad_len; 19538d1c069SBoaz Harrosh unsigned short ahslength; 19638d1c069SBoaz Harrosh struct iscsi_ecdb_ahdr *ecdb_ahdr; 19738d1c069SBoaz Harrosh int rc; 19838d1c069SBoaz Harrosh 1999c19a7d0SMike Christie ecdb_ahdr = iscsi_next_hdr(task); 20038d1c069SBoaz Harrosh rlen = cmd->cmd_len - ISCSI_CDB_SIZE; 20138d1c069SBoaz Harrosh 20238d1c069SBoaz Harrosh BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb)); 20338d1c069SBoaz Harrosh ahslength = rlen + sizeof(ecdb_ahdr->reserved); 20438d1c069SBoaz Harrosh 20538d1c069SBoaz Harrosh pad_len = iscsi_padding(rlen); 20638d1c069SBoaz Harrosh 2079c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) + 20838d1c069SBoaz Harrosh sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len); 20938d1c069SBoaz Harrosh if (rc) 21038d1c069SBoaz Harrosh return rc; 21138d1c069SBoaz Harrosh 21238d1c069SBoaz Harrosh if (pad_len) 21338d1c069SBoaz Harrosh memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len); 21438d1c069SBoaz Harrosh 21538d1c069SBoaz Harrosh ecdb_ahdr->ahslength = cpu_to_be16(ahslength); 21638d1c069SBoaz Harrosh ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB; 21738d1c069SBoaz Harrosh ecdb_ahdr->reserved = 0; 21838d1c069SBoaz Harrosh memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen); 21938d1c069SBoaz Harrosh 2201b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2211b2c7af8SMike Christie "iscsi_prep_ecdb_ahs: varlen_cdb_len %d " 2221b2c7af8SMike Christie "rlen %d pad_len %d ahs_length %d iscsi_headers_size " 2231b2c7af8SMike Christie "%u\n", cmd->cmd_len, rlen, pad_len, ahslength, 2241b2c7af8SMike Christie task->hdr_len); 22538d1c069SBoaz Harrosh return 0; 22638d1c069SBoaz Harrosh } 22738d1c069SBoaz Harrosh 2289c19a7d0SMike Christie static int iscsi_prep_bidi_ahs(struct iscsi_task *task) 229c07d4444SBoaz Harrosh { 2309c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 231c07d4444SBoaz Harrosh struct iscsi_rlength_ahdr *rlen_ahdr; 232c07d4444SBoaz Harrosh int rc; 233c07d4444SBoaz Harrosh 2349c19a7d0SMike Christie rlen_ahdr = iscsi_next_hdr(task); 2359c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*rlen_ahdr)); 236c07d4444SBoaz Harrosh if (rc) 237c07d4444SBoaz Harrosh return rc; 238c07d4444SBoaz Harrosh 239c07d4444SBoaz Harrosh rlen_ahdr->ahslength = 240c07d4444SBoaz Harrosh cpu_to_be16(sizeof(rlen_ahdr->read_length) + 241c07d4444SBoaz Harrosh sizeof(rlen_ahdr->reserved)); 242c07d4444SBoaz Harrosh rlen_ahdr->ahstype = ISCSI_AHSTYPE_RLENGTH; 243c07d4444SBoaz Harrosh rlen_ahdr->reserved = 0; 244c07d4444SBoaz Harrosh rlen_ahdr->read_length = cpu_to_be32(scsi_in(sc)->length); 245c07d4444SBoaz Harrosh 2461b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2471b2c7af8SMike Christie "bidi-in rlen_ahdr->read_length(%d) " 248c07d4444SBoaz Harrosh "rlen_ahdr->ahslength(%d)\n", 249c07d4444SBoaz Harrosh be32_to_cpu(rlen_ahdr->read_length), 250c07d4444SBoaz Harrosh be16_to_cpu(rlen_ahdr->ahslength)); 251c07d4444SBoaz Harrosh return 0; 252c07d4444SBoaz Harrosh } 253c07d4444SBoaz Harrosh 2547996a778SMike Christie /** 2555d12c05eSMike Christie * iscsi_check_tmf_restrictions - check if a task is affected by TMF 2565d12c05eSMike Christie * @task: iscsi task 2575d12c05eSMike Christie * @opcode: opcode to check for 2585d12c05eSMike Christie * 2595d12c05eSMike Christie * During TMF a task has to be checked if it's affected. 2605d12c05eSMike Christie * All unrelated I/O can be passed through, but I/O to the 2615d12c05eSMike Christie * affected LUN should be restricted. 2625d12c05eSMike Christie * If 'fast_abort' is set we won't be sending any I/O to the 2635d12c05eSMike Christie * affected LUN. 2645d12c05eSMike Christie * Otherwise the target is waiting for all TTTs to be completed, 2655d12c05eSMike Christie * so we have to send all outstanding Data-Out PDUs to the target. 2665d12c05eSMike Christie */ 2675d12c05eSMike Christie static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode) 2685d12c05eSMike Christie { 2695d12c05eSMike Christie struct iscsi_conn *conn = task->conn; 2705d12c05eSMike Christie struct iscsi_tm *tmf = &conn->tmhdr; 2715d12c05eSMike Christie unsigned int hdr_lun; 2725d12c05eSMike Christie 2735d12c05eSMike Christie if (conn->tmf_state == TMF_INITIAL) 2745d12c05eSMike Christie return 0; 2755d12c05eSMike Christie 2765d12c05eSMike Christie if ((tmf->opcode & ISCSI_OPCODE_MASK) != ISCSI_OP_SCSI_TMFUNC) 2775d12c05eSMike Christie return 0; 2785d12c05eSMike Christie 2795d12c05eSMike Christie switch (ISCSI_TM_FUNC_VALUE(tmf)) { 2805d12c05eSMike Christie case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET: 2815d12c05eSMike Christie /* 2825d12c05eSMike Christie * Allow PDUs for unrelated LUNs 2835d12c05eSMike Christie */ 28455bdabdfSAndy Grover hdr_lun = scsilun_to_int(&tmf->lun); 2855d12c05eSMike Christie if (hdr_lun != task->sc->device->lun) 2865d12c05eSMike Christie return 0; 2873fe5ae8bSMike Christie /* fall through */ 2883fe5ae8bSMike Christie case ISCSI_TM_FUNC_TARGET_WARM_RESET: 2895d12c05eSMike Christie /* 2905d12c05eSMike Christie * Fail all SCSI cmd PDUs 2915d12c05eSMike Christie */ 2925d12c05eSMike Christie if (opcode != ISCSI_OP_SCSI_DATA_OUT) { 2935d12c05eSMike Christie iscsi_conn_printk(KERN_INFO, conn, 2945d12c05eSMike Christie "task [op %x/%x itt " 2953fe5ae8bSMike Christie "0x%x/0x%x] " 2965d12c05eSMike Christie "rejected.\n", 2975d12c05eSMike Christie task->hdr->opcode, opcode, 2983fe5ae8bSMike Christie task->itt, task->hdr_itt); 2995d12c05eSMike Christie return -EACCES; 3005d12c05eSMike Christie } 3015d12c05eSMike Christie /* 3025d12c05eSMike Christie * And also all data-out PDUs in response to R2T 3035d12c05eSMike Christie * if fast_abort is set. 3045d12c05eSMike Christie */ 3055d12c05eSMike Christie if (conn->session->fast_abort) { 3065d12c05eSMike Christie iscsi_conn_printk(KERN_INFO, conn, 3075d12c05eSMike Christie "task [op %x/%x itt " 3083fe5ae8bSMike Christie "0x%x/0x%x] fast abort.\n", 3095d12c05eSMike Christie task->hdr->opcode, opcode, 3103fe5ae8bSMike Christie task->itt, task->hdr_itt); 3115d12c05eSMike Christie return -EACCES; 3125d12c05eSMike Christie } 3135d12c05eSMike Christie break; 3145d12c05eSMike Christie case ISCSI_TM_FUNC_ABORT_TASK: 3155d12c05eSMike Christie /* 3165d12c05eSMike Christie * the caller has already checked if the task 3175d12c05eSMike Christie * they want to abort was in the pending queue so if 3185d12c05eSMike Christie * we are here the cmd pdu has gone out already, and 3195d12c05eSMike Christie * we will only hit this for data-outs 3205d12c05eSMike Christie */ 3215d12c05eSMike Christie if (opcode == ISCSI_OP_SCSI_DATA_OUT && 3225d12c05eSMike Christie task->hdr_itt == tmf->rtt) { 3235d12c05eSMike Christie ISCSI_DBG_SESSION(conn->session, 3245d12c05eSMike Christie "Preventing task %x/%x from sending " 3255d12c05eSMike Christie "data-out due to abort task in " 3265d12c05eSMike Christie "progress\n", task->itt, 3275d12c05eSMike Christie task->hdr_itt); 3285d12c05eSMike Christie return -EACCES; 3295d12c05eSMike Christie } 3305d12c05eSMike Christie break; 3315d12c05eSMike Christie } 3325d12c05eSMike Christie 3335d12c05eSMike Christie return 0; 3345d12c05eSMike Christie } 3355d12c05eSMike Christie 3365d12c05eSMike Christie /** 3377996a778SMike Christie * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu 3389c19a7d0SMike Christie * @task: iscsi task 3397996a778SMike Christie * 3407996a778SMike Christie * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set 3417996a778SMike Christie * fields like dlength or final based on how much data it sends 3427996a778SMike Christie */ 3439c19a7d0SMike Christie static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task) 3447996a778SMike Christie { 3459c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 3467996a778SMike Christie struct iscsi_session *session = conn->session; 3479c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 34812352183SNicholas Bellinger struct iscsi_scsi_req *hdr; 34938d1c069SBoaz Harrosh unsigned hdrlength, cmd_len; 350262ef636SMike Christie itt_t itt; 351004d6530SBoaz Harrosh int rc; 3527996a778SMike Christie 3535d12c05eSMike Christie rc = iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_CMD); 3545d12c05eSMike Christie if (rc) 3555d12c05eSMike Christie return rc; 3565d12c05eSMike Christie 357184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 3582ff79d52SMike Christie rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD); 359577577daSMike Christie if (rc) 360577577daSMike Christie return rc; 361184b57c6SMike Christie } 36212352183SNicholas Bellinger hdr = (struct iscsi_scsi_req *)task->hdr; 363262ef636SMike Christie itt = hdr->itt; 364577577daSMike Christie memset(hdr, 0, sizeof(*hdr)); 365577577daSMike Christie 3662ff79d52SMike Christie if (session->tt->parse_pdu_itt) 3672ff79d52SMike Christie hdr->itt = task->hdr_itt = itt; 3682ff79d52SMike Christie else 3692ff79d52SMike Christie hdr->itt = task->hdr_itt = build_itt(task->itt, 3702ff79d52SMike Christie task->conn->session->age); 3719c19a7d0SMike Christie task->hdr_len = 0; 3729c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*hdr)); 373004d6530SBoaz Harrosh if (rc) 374004d6530SBoaz Harrosh return rc; 3757996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_CMD; 3767996a778SMike Christie hdr->flags = ISCSI_ATTR_SIMPLE; 37755bdabdfSAndy Grover int_to_scsilun(sc->device->lun, &hdr->lun); 37855bdabdfSAndy Grover task->lun = hdr->lun; 3797996a778SMike Christie hdr->exp_statsn = cpu_to_be32(conn->exp_statsn); 38038d1c069SBoaz Harrosh cmd_len = sc->cmd_len; 38138d1c069SBoaz Harrosh if (cmd_len < ISCSI_CDB_SIZE) 38238d1c069SBoaz Harrosh memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len); 38338d1c069SBoaz Harrosh else if (cmd_len > ISCSI_CDB_SIZE) { 3849c19a7d0SMike Christie rc = iscsi_prep_ecdb_ahs(task); 38538d1c069SBoaz Harrosh if (rc) 38638d1c069SBoaz Harrosh return rc; 38738d1c069SBoaz Harrosh cmd_len = ISCSI_CDB_SIZE; 38838d1c069SBoaz Harrosh } 38938d1c069SBoaz Harrosh memcpy(hdr->cdb, sc->cmnd, cmd_len); 3907996a778SMike Christie 3919c19a7d0SMike Christie task->imm_count = 0; 392c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc)) { 393c07d4444SBoaz Harrosh hdr->flags |= ISCSI_FLAG_CMD_READ; 3949c19a7d0SMike Christie rc = iscsi_prep_bidi_ahs(task); 395c07d4444SBoaz Harrosh if (rc) 396c07d4444SBoaz Harrosh return rc; 397c07d4444SBoaz Harrosh } 3987996a778SMike Christie if (sc->sc_data_direction == DMA_TO_DEVICE) { 399c07d4444SBoaz Harrosh unsigned out_len = scsi_out(sc)->length; 400577577daSMike Christie struct iscsi_r2t_info *r2t = &task->unsol_r2t; 401577577daSMike Christie 402c07d4444SBoaz Harrosh hdr->data_length = cpu_to_be32(out_len); 4037996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_WRITE; 4047996a778SMike Christie /* 4057996a778SMike Christie * Write counters: 4067996a778SMike Christie * 4077996a778SMike Christie * imm_count bytes to be sent right after 4087996a778SMike Christie * SCSI PDU Header 4097996a778SMike Christie * 4107996a778SMike Christie * unsol_count bytes(as Data-Out) to be sent 4117996a778SMike Christie * without R2T ack right after 4127996a778SMike Christie * immediate data 4137996a778SMike Christie * 414577577daSMike Christie * r2t data_length bytes to be sent via R2T ack's 4157996a778SMike Christie * 4167996a778SMike Christie * pad_count bytes to be sent as zero-padding 4177996a778SMike Christie */ 418577577daSMike Christie memset(r2t, 0, sizeof(*r2t)); 4197996a778SMike Christie 4207996a778SMike Christie if (session->imm_data_en) { 421c07d4444SBoaz Harrosh if (out_len >= session->first_burst) 4229c19a7d0SMike Christie task->imm_count = min(session->first_burst, 4237996a778SMike Christie conn->max_xmit_dlength); 4247996a778SMike Christie else 4259c19a7d0SMike Christie task->imm_count = min(out_len, 4267996a778SMike Christie conn->max_xmit_dlength); 4279c19a7d0SMike Christie hton24(hdr->dlength, task->imm_count); 4287996a778SMike Christie } else 429a8ac6311SOlaf Kirch zero_data(hdr->dlength); 4307996a778SMike Christie 431ffd0436eSMike Christie if (!session->initial_r2t_en) { 432577577daSMike Christie r2t->data_length = min(session->first_burst, out_len) - 433577577daSMike Christie task->imm_count; 434577577daSMike Christie r2t->data_offset = task->imm_count; 435577577daSMike Christie r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG); 436577577daSMike Christie r2t->exp_statsn = cpu_to_be32(conn->exp_statsn); 437ffd0436eSMike Christie } 438ffd0436eSMike Christie 439577577daSMike Christie if (!task->unsol_r2t.data_length) 4407996a778SMike Christie /* No unsolicit Data-Out's */ 441a8ac6311SOlaf Kirch hdr->flags |= ISCSI_FLAG_CMD_FINAL; 4427996a778SMike Christie } else { 4437996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 4447996a778SMike Christie zero_data(hdr->dlength); 445c07d4444SBoaz Harrosh hdr->data_length = cpu_to_be32(scsi_in(sc)->length); 4467996a778SMike Christie 4477996a778SMike Christie if (sc->sc_data_direction == DMA_FROM_DEVICE) 4487996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_READ; 4497996a778SMike Christie } 4507996a778SMike Christie 451004d6530SBoaz Harrosh /* calculate size of additional header segments (AHSs) */ 4529c19a7d0SMike Christie hdrlength = task->hdr_len - sizeof(*hdr); 453004d6530SBoaz Harrosh 454004d6530SBoaz Harrosh WARN_ON(hdrlength & (ISCSI_PAD_LEN-1)); 455004d6530SBoaz Harrosh hdrlength /= ISCSI_PAD_LEN; 456004d6530SBoaz Harrosh 457004d6530SBoaz Harrosh WARN_ON(hdrlength >= 256); 458004d6530SBoaz Harrosh hdr->hlength = hdrlength & 0xFF; 45996b1f96dSMike Christie hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn); 460004d6530SBoaz Harrosh 461577577daSMike Christie if (session->tt->init_task && session->tt->init_task(task)) 462052d0144SMike Christie return -EIO; 463052d0144SMike Christie 4649c19a7d0SMike Christie task->state = ISCSI_TASK_RUNNING; 465d3305f34SMike Christie session->cmdsn++; 46677a23c21SMike Christie 467a8ac6311SOlaf Kirch conn->scsicmd_pdus_cnt++; 4681b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi prep [%s cid %d sc %p cdb 0x%x " 4691b2c7af8SMike Christie "itt 0x%x len %d bidi_len %d cmdsn %d win %d]\n", 4701b2c7af8SMike Christie scsi_bidi_cmnd(sc) ? "bidirectional" : 4711b2c7af8SMike Christie sc->sc_data_direction == DMA_TO_DEVICE ? 4721b2c7af8SMike Christie "write" : "read", conn->id, sc, sc->cmnd[0], 4731b2c7af8SMike Christie task->itt, scsi_bufflen(sc), 4743e5c28adSMike Christie scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0, 4751b2c7af8SMike Christie session->cmdsn, 4761b2c7af8SMike Christie session->max_cmdsn - session->exp_cmdsn + 1); 477004d6530SBoaz Harrosh return 0; 4787996a778SMike Christie } 4797996a778SMike Christie 4807996a778SMike Christie /** 4813bbaaad9SMike Christie * iscsi_free_task - free a task 4829c19a7d0SMike Christie * @task: iscsi cmd task 4837996a778SMike Christie * 4847996a778SMike Christie * Must be called with session lock. 4853e5c28adSMike Christie * This function returns the scsi command to scsi-ml or cleans 4863e5c28adSMike Christie * up mgmt tasks then returns the task to the pool. 4877996a778SMike Christie */ 4883bbaaad9SMike Christie static void iscsi_free_task(struct iscsi_task *task) 4897996a778SMike Christie { 4909c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 491c1635cb7SMike Christie struct iscsi_session *session = conn->session; 4929c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 493f41d4721SMike Christie int oldstate = task->state; 4947996a778SMike Christie 4954421c9ebSMike Christie ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n", 4964421c9ebSMike Christie task->itt, task->state, task->sc); 4974421c9ebSMike Christie 498577577daSMike Christie session->tt->cleanup_task(task); 4993bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 5009c19a7d0SMike Christie task->sc = NULL; 5013e5c28adSMike Christie /* 5029c19a7d0SMike Christie * login task is preallocated so do not free 5033e5c28adSMike Christie */ 5049c19a7d0SMike Christie if (conn->login_task == task) 5053e5c28adSMike Christie return; 5063e5c28adSMike Christie 5077acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&task, sizeof(void*)); 5083e5c28adSMike Christie 5093e5c28adSMike Christie if (sc) { 5109c19a7d0SMike Christie task->sc = NULL; 511f47f2cf5SMike Christie /* SCSI eh reuses commands to verify us */ 512f47f2cf5SMike Christie sc->SCp.ptr = NULL; 5133e5c28adSMike Christie /* 514f41d4721SMike Christie * queue command may call this to free the task, so 515f41d4721SMike Christie * it will decide how to return sc to scsi-ml. 5163e5c28adSMike Christie */ 517f41d4721SMike Christie if (oldstate != ISCSI_TASK_REQUEUE_SCSIQ) 5187996a778SMike Christie sc->scsi_done(sc); 5197996a778SMike Christie } 5203e5c28adSMike Christie } 5217996a778SMike Christie 522913e5bf4SMike Christie void __iscsi_get_task(struct iscsi_task *task) 52360ecebf5SMike Christie { 5249c19a7d0SMike Christie atomic_inc(&task->refcount); 52560ecebf5SMike Christie } 526913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_get_task); 52760ecebf5SMike Christie 5288eea2f55SEddie Wai void __iscsi_put_task(struct iscsi_task *task) 52960ecebf5SMike Christie { 5309c19a7d0SMike Christie if (atomic_dec_and_test(&task->refcount)) 5313bbaaad9SMike Christie iscsi_free_task(task); 53260ecebf5SMike Christie } 5338eea2f55SEddie Wai EXPORT_SYMBOL_GPL(__iscsi_put_task); 53460ecebf5SMike Christie 5359c19a7d0SMike Christie void iscsi_put_task(struct iscsi_task *task) 5363e5c28adSMike Christie { 5379c19a7d0SMike Christie struct iscsi_session *session = task->conn->session; 5383e5c28adSMike Christie 5393e5c28adSMike Christie spin_lock_bh(&session->lock); 5409c19a7d0SMike Christie __iscsi_put_task(task); 5413e5c28adSMike Christie spin_unlock_bh(&session->lock); 5423e5c28adSMike Christie } 5439c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_put_task); 5443e5c28adSMike Christie 5453bbaaad9SMike Christie /** 5463bbaaad9SMike Christie * iscsi_complete_task - finish a task 5473bbaaad9SMike Christie * @task: iscsi cmd task 548b3cd5050SMike Christie * @state: state to complete task with 5493bbaaad9SMike Christie * 5503bbaaad9SMike Christie * Must be called with session lock. 551b3a7ea8dSMike Christie */ 552b3cd5050SMike Christie static void iscsi_complete_task(struct iscsi_task *task, int state) 553b3a7ea8dSMike Christie { 5543bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 5553bbaaad9SMike Christie 5564421c9ebSMike Christie ISCSI_DBG_SESSION(conn->session, 5574421c9ebSMike Christie "complete task itt 0x%x state %d sc %p\n", 5584421c9ebSMike Christie task->itt, task->state, task->sc); 559b3cd5050SMike Christie if (task->state == ISCSI_TASK_COMPLETED || 560b3cd5050SMike Christie task->state == ISCSI_TASK_ABRT_TMF || 561f41d4721SMike Christie task->state == ISCSI_TASK_ABRT_SESS_RECOV || 562f41d4721SMike Christie task->state == ISCSI_TASK_REQUEUE_SCSIQ) 5633bbaaad9SMike Christie return; 5643bbaaad9SMike Christie WARN_ON_ONCE(task->state == ISCSI_TASK_FREE); 565b3cd5050SMike Christie task->state = state; 5663bbaaad9SMike Christie 5673bbaaad9SMike Christie if (!list_empty(&task->running)) 5683bbaaad9SMike Christie list_del_init(&task->running); 5693bbaaad9SMike Christie 5703bbaaad9SMike Christie if (conn->task == task) 5713bbaaad9SMike Christie conn->task = NULL; 5723bbaaad9SMike Christie 5733bbaaad9SMike Christie if (conn->ping_task == task) 5743bbaaad9SMike Christie conn->ping_task = NULL; 5753bbaaad9SMike Christie 5763bbaaad9SMike Christie /* release get from queueing */ 5773bbaaad9SMike Christie __iscsi_put_task(task); 5783bbaaad9SMike Christie } 5793bbaaad9SMike Christie 5804c0ba5d2SMike Christie /** 5814c0ba5d2SMike Christie * iscsi_complete_scsi_task - finish scsi task normally 5824c0ba5d2SMike Christie * @task: iscsi task for scsi cmd 5834c0ba5d2SMike Christie * @exp_cmdsn: expected cmd sn in cpu format 5844c0ba5d2SMike Christie * @max_cmdsn: max cmd sn in cpu format 5854c0ba5d2SMike Christie * 5864c0ba5d2SMike Christie * This is used when drivers do not need or cannot perform 5874c0ba5d2SMike Christie * lower level pdu processing. 5884c0ba5d2SMike Christie * 5894c0ba5d2SMike Christie * Called with session lock 5904c0ba5d2SMike Christie */ 5914c0ba5d2SMike Christie void iscsi_complete_scsi_task(struct iscsi_task *task, 5924c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 5934c0ba5d2SMike Christie { 5944c0ba5d2SMike Christie struct iscsi_conn *conn = task->conn; 5954c0ba5d2SMike Christie 5964c0ba5d2SMike Christie ISCSI_DBG_SESSION(conn->session, "[itt 0x%x]\n", task->itt); 5974c0ba5d2SMike Christie 5984c0ba5d2SMike Christie conn->last_recv = jiffies; 5994c0ba5d2SMike Christie __iscsi_update_cmdsn(conn->session, exp_cmdsn, max_cmdsn); 6004c0ba5d2SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 6014c0ba5d2SMike Christie } 6024c0ba5d2SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_scsi_task); 6034c0ba5d2SMike Christie 6044c0ba5d2SMike Christie 6053bbaaad9SMike Christie /* 6063bbaaad9SMike Christie * session lock must be held and if not called for a task that is 6073bbaaad9SMike Christie * still pending or from the xmit thread, then xmit thread must 6083bbaaad9SMike Christie * be suspended. 6093bbaaad9SMike Christie */ 6103bbaaad9SMike Christie static void fail_scsi_task(struct iscsi_task *task, int err) 6113bbaaad9SMike Christie { 6123bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 613b3a7ea8dSMike Christie struct scsi_cmnd *sc; 614b3cd5050SMike Christie int state; 615b3a7ea8dSMike Christie 6163bbaaad9SMike Christie /* 6173bbaaad9SMike Christie * if a command completes and we get a successful tmf response 6183bbaaad9SMike Christie * we will hit this because the scsi eh abort code does not take 6193bbaaad9SMike Christie * a ref to the task. 6203bbaaad9SMike Christie */ 6219c19a7d0SMike Christie sc = task->sc; 622b3a7ea8dSMike Christie if (!sc) 623b3a7ea8dSMike Christie return; 624b3a7ea8dSMike Christie 625b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) { 626b3a7ea8dSMike Christie /* 627b3a7ea8dSMike Christie * cmd never made it to the xmit thread, so we should not count 628b3a7ea8dSMike Christie * the cmd in the sequencing 629b3a7ea8dSMike Christie */ 630b3a7ea8dSMike Christie conn->session->queued_cmdsn--; 631b3cd5050SMike Christie /* it was never sent so just complete like normal */ 632b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 633b3cd5050SMike Christie } else if (err == DID_TRANSPORT_DISRUPTED) 634b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 635b3cd5050SMike Christie else 636b3cd5050SMike Christie state = ISCSI_TASK_ABRT_TMF; 637b3a7ea8dSMike Christie 638b3cd5050SMike Christie sc->result = err << 16; 639c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 640b3a7ea8dSMike Christie scsi_set_resid(sc, scsi_bufflen(sc)); 641c07d4444SBoaz Harrosh else { 642c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 643c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 644c07d4444SBoaz Harrosh } 6453e5c28adSMike Christie 646b3cd5050SMike Christie iscsi_complete_task(task, state); 647b3a7ea8dSMike Christie } 648b3a7ea8dSMike Christie 6493e5c28adSMike Christie static int iscsi_prep_mgmt_task(struct iscsi_conn *conn, 6509c19a7d0SMike Christie struct iscsi_task *task) 651052d0144SMike Christie { 652052d0144SMike Christie struct iscsi_session *session = conn->session; 653577577daSMike Christie struct iscsi_hdr *hdr = task->hdr; 654052d0144SMike Christie struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr; 6554f704dc0SMike Christie uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 656052d0144SMike Christie 657052d0144SMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 658052d0144SMike Christie return -ENOTCONN; 659052d0144SMike Christie 6604f704dc0SMike Christie if (opcode != ISCSI_OP_LOGIN && opcode != ISCSI_OP_TEXT) 661052d0144SMike Christie nop->exp_statsn = cpu_to_be32(conn->exp_statsn); 662052d0144SMike Christie /* 663052d0144SMike Christie * pre-format CmdSN for outgoing PDU. 664052d0144SMike Christie */ 665052d0144SMike Christie nop->cmdsn = cpu_to_be32(session->cmdsn); 666052d0144SMike Christie if (hdr->itt != RESERVED_ITT) { 667052d0144SMike Christie /* 6684f704dc0SMike Christie * TODO: We always use immediate for normal session pdus. 669052d0144SMike Christie * If we start to send tmfs or nops as non-immediate then 670052d0144SMike Christie * we should start checking the cmdsn numbers for mgmt tasks. 6714f704dc0SMike Christie * 6724f704dc0SMike Christie * During discovery sessions iscsid sends TEXT as non immediate, 6734f704dc0SMike Christie * but we always only send one PDU at a time. 674052d0144SMike Christie */ 675052d0144SMike Christie if (conn->c_stage == ISCSI_CONN_STARTED && 676052d0144SMike Christie !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 677052d0144SMike Christie session->queued_cmdsn++; 678052d0144SMike Christie session->cmdsn++; 679052d0144SMike Christie } 680052d0144SMike Christie } 681052d0144SMike Christie 682ae15f801SMike Christie if (session->tt->init_task && session->tt->init_task(task)) 683ae15f801SMike Christie return -EIO; 684052d0144SMike Christie 685052d0144SMike Christie if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT) 686052d0144SMike Christie session->state = ISCSI_STATE_LOGGING_OUT; 687052d0144SMike Christie 688577577daSMike Christie task->state = ISCSI_TASK_RUNNING; 6891b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "mgmtpdu [op 0x%x hdr->itt 0x%x " 6901b2c7af8SMike Christie "datalen %d]\n", hdr->opcode & ISCSI_OPCODE_MASK, 6911b2c7af8SMike Christie hdr->itt, task->data_count); 692052d0144SMike Christie return 0; 693052d0144SMike Christie } 694052d0144SMike Christie 6959c19a7d0SMike Christie static struct iscsi_task * 696f6d5180cSMike Christie __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 697f6d5180cSMike Christie char *data, uint32_t data_size) 698f6d5180cSMike Christie { 699f6d5180cSMike Christie struct iscsi_session *session = conn->session; 7001336aed1SMike Christie struct iscsi_host *ihost = shost_priv(session->host); 7014f704dc0SMike Christie uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 7029c19a7d0SMike Christie struct iscsi_task *task; 703262ef636SMike Christie itt_t itt; 704f6d5180cSMike Christie 705f6d5180cSMike Christie if (session->state == ISCSI_STATE_TERMINATE) 706f6d5180cSMike Christie return NULL; 707f6d5180cSMike Christie 7084f704dc0SMike Christie if (opcode == ISCSI_OP_LOGIN || opcode == ISCSI_OP_TEXT) { 709f6d5180cSMike Christie /* 710f6d5180cSMike Christie * Login and Text are sent serially, in 711f6d5180cSMike Christie * request-followed-by-response sequence. 7123e5c28adSMike Christie * Same task can be used. Same ITT must be used. 7133e5c28adSMike Christie * Note that login_task is preallocated at conn_create(). 714f6d5180cSMike Christie */ 7154f704dc0SMike Christie if (conn->login_task->state != ISCSI_TASK_FREE) { 7164f704dc0SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Login/Text in " 7174f704dc0SMike Christie "progress. Cannot start new task.\n"); 7184f704dc0SMike Christie return NULL; 7194f704dc0SMike Christie } 7204f704dc0SMike Christie 7219c19a7d0SMike Christie task = conn->login_task; 7224f704dc0SMike Christie } else { 72326013ad4SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 72426013ad4SMike Christie return NULL; 72526013ad4SMike Christie 726f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE); 727f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED); 728f6d5180cSMike Christie 7297acd72ebSStefani Seibold if (!kfifo_out(&session->cmdpool.queue, 7309c19a7d0SMike Christie (void*)&task, sizeof(void*))) 731f6d5180cSMike Christie return NULL; 732f6d5180cSMike Christie } 7333e5c28adSMike Christie /* 7343e5c28adSMike Christie * released in complete pdu for task we expect a response for, and 7353e5c28adSMike Christie * released by the lld when it has transmitted the task for 7363e5c28adSMike Christie * pdus we do not expect a response for. 7373e5c28adSMike Christie */ 7389c19a7d0SMike Christie atomic_set(&task->refcount, 1); 7399c19a7d0SMike Christie task->conn = conn; 7409c19a7d0SMike Christie task->sc = NULL; 7413bbaaad9SMike Christie INIT_LIST_HEAD(&task->running); 7423bbaaad9SMike Christie task->state = ISCSI_TASK_PENDING; 743f6d5180cSMike Christie 744f6d5180cSMike Christie if (data_size) { 7459c19a7d0SMike Christie memcpy(task->data, data, data_size); 7469c19a7d0SMike Christie task->data_count = data_size; 747f6d5180cSMike Christie } else 7489c19a7d0SMike Christie task->data_count = 0; 749f6d5180cSMike Christie 750184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 7512ff79d52SMike Christie if (conn->session->tt->alloc_pdu(task, hdr->opcode)) { 752577577daSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not allocate " 753577577daSMike Christie "pdu for mgmt task.\n"); 7543bbaaad9SMike Christie goto free_task; 755577577daSMike Christie } 756184b57c6SMike Christie } 757184b57c6SMike Christie 758262ef636SMike Christie itt = task->hdr->itt; 759577577daSMike Christie task->hdr_len = sizeof(struct iscsi_hdr); 7609c19a7d0SMike Christie memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr)); 761262ef636SMike Christie 762262ef636SMike Christie if (hdr->itt != RESERVED_ITT) { 763262ef636SMike Christie if (session->tt->parse_pdu_itt) 764262ef636SMike Christie task->hdr->itt = itt; 765262ef636SMike Christie else 766262ef636SMike Christie task->hdr->itt = build_itt(task->itt, 767262ef636SMike Christie task->conn->session->age); 768262ef636SMike Christie } 769262ef636SMike Christie 7701336aed1SMike Christie if (!ihost->workq) { 771577577daSMike Christie if (iscsi_prep_mgmt_task(conn, task)) 772577577daSMike Christie goto free_task; 773052d0144SMike Christie 7749c19a7d0SMike Christie if (session->tt->xmit_task(task)) 775577577daSMike Christie goto free_task; 7763bbaaad9SMike Christie } else { 7773bbaaad9SMike Christie list_add_tail(&task->running, &conn->mgmtqueue); 77832ae763eSMike Christie iscsi_conn_queue_work(conn); 7793bbaaad9SMike Christie } 780052d0144SMike Christie 7819c19a7d0SMike Christie return task; 782577577daSMike Christie 783577577daSMike Christie free_task: 784577577daSMike Christie __iscsi_put_task(task); 785577577daSMike Christie return NULL; 786f6d5180cSMike Christie } 787f6d5180cSMike Christie 788f6d5180cSMike Christie int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr, 789f6d5180cSMike Christie char *data, uint32_t data_size) 790f6d5180cSMike Christie { 791f6d5180cSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 792f6d5180cSMike Christie struct iscsi_session *session = conn->session; 793f6d5180cSMike Christie int err = 0; 794f6d5180cSMike Christie 795f6d5180cSMike Christie spin_lock_bh(&session->lock); 796f6d5180cSMike Christie if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size)) 797f6d5180cSMike Christie err = -EPERM; 798f6d5180cSMike Christie spin_unlock_bh(&session->lock); 799f6d5180cSMike Christie return err; 800f6d5180cSMike Christie } 801f6d5180cSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu); 802f6d5180cSMike Christie 8037996a778SMike Christie /** 8047996a778SMike Christie * iscsi_cmd_rsp - SCSI Command Response processing 8057996a778SMike Christie * @conn: iscsi connection 8067996a778SMike Christie * @hdr: iscsi header 8079c19a7d0SMike Christie * @task: scsi command task 8087996a778SMike Christie * @data: cmd data buffer 8097996a778SMike Christie * @datalen: len of buffer 8107996a778SMike Christie * 8117996a778SMike Christie * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and 8129c19a7d0SMike Christie * then completes the command and task. 8137996a778SMike Christie **/ 81477a23c21SMike Christie static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 8159c19a7d0SMike Christie struct iscsi_task *task, char *data, 8167996a778SMike Christie int datalen) 8177996a778SMike Christie { 81812352183SNicholas Bellinger struct iscsi_scsi_rsp *rhdr = (struct iscsi_scsi_rsp *)hdr; 8197996a778SMike Christie struct iscsi_session *session = conn->session; 8209c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 8217996a778SMike Christie 82277a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr); 8237996a778SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 8247996a778SMike Christie 8257996a778SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 8267996a778SMike Christie 8277996a778SMike Christie if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) { 8287996a778SMike Christie sc->result = DID_ERROR << 16; 8297996a778SMike Christie goto out; 8307996a778SMike Christie } 8317996a778SMike Christie 8327996a778SMike Christie if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) { 8339b80cb4bSMike Christie uint16_t senselen; 8347996a778SMike Christie 8357996a778SMike Christie if (datalen < 2) { 8367996a778SMike Christie invalid_datalen: 837322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 838322d739dSMike Christie "Got CHECK_CONDITION but invalid data " 839322d739dSMike Christie "buffer size of %d\n", datalen); 8407996a778SMike Christie sc->result = DID_BAD_TARGET << 16; 8417996a778SMike Christie goto out; 8427996a778SMike Christie } 8437996a778SMike Christie 8448f333991SHarvey Harrison senselen = get_unaligned_be16(data); 8457996a778SMike Christie if (datalen < senselen) 8467996a778SMike Christie goto invalid_datalen; 8477996a778SMike Christie 8487996a778SMike Christie memcpy(sc->sense_buffer, data + 2, 8499b80cb4bSMike Christie min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 8501b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n", 8511b2c7af8SMike Christie min_t(uint16_t, senselen, 8521b2c7af8SMike Christie SCSI_SENSE_BUFFERSIZE)); 8537996a778SMike Christie } 8547996a778SMike Christie 855c07d4444SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW | 856c07d4444SBoaz Harrosh ISCSI_FLAG_CMD_BIDI_OVERFLOW)) { 857c07d4444SBoaz Harrosh int res_count = be32_to_cpu(rhdr->bi_residual_count); 858c07d4444SBoaz Harrosh 859c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc) && res_count > 0 && 860c07d4444SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_BIDI_OVERFLOW || 861c07d4444SBoaz Harrosh res_count <= scsi_in(sc)->length)) 862c07d4444SBoaz Harrosh scsi_in(sc)->resid = res_count; 863c07d4444SBoaz Harrosh else 864c07d4444SBoaz Harrosh sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 865c07d4444SBoaz Harrosh } 866c07d4444SBoaz Harrosh 8677207fea4SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW | 8687207fea4SBoaz Harrosh ISCSI_FLAG_CMD_OVERFLOW)) { 8697996a778SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 8707996a778SMike Christie 8717207fea4SBoaz Harrosh if (res_count > 0 && 8727207fea4SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 8737207fea4SBoaz Harrosh res_count <= scsi_bufflen(sc))) 874c07d4444SBoaz Harrosh /* write side for bidi or uni-io set_resid */ 8751c138991SFUJITA Tomonori scsi_set_resid(sc, res_count); 8767996a778SMike Christie else 8777996a778SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 878c07d4444SBoaz Harrosh } 8797996a778SMike Christie out: 8803bbaaad9SMike Christie ISCSI_DBG_SESSION(session, "cmd rsp done [sc %p res %d itt 0x%x]\n", 8811b2c7af8SMike Christie sc, sc->result, task->itt); 8827996a778SMike Christie conn->scsirsp_pdus_cnt++; 883b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 8847996a778SMike Christie } 8857996a778SMike Christie 8861d9edf02SMike Christie /** 8871d9edf02SMike Christie * iscsi_data_in_rsp - SCSI Data-In Response processing 8881d9edf02SMike Christie * @conn: iscsi connection 8891d9edf02SMike Christie * @hdr: iscsi pdu 8901d9edf02SMike Christie * @task: scsi command task 8911d9edf02SMike Christie **/ 8921d9edf02SMike Christie static void 8931d9edf02SMike Christie iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 8941d9edf02SMike Christie struct iscsi_task *task) 8951d9edf02SMike Christie { 8961d9edf02SMike Christie struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr; 8971d9edf02SMike Christie struct scsi_cmnd *sc = task->sc; 8981d9edf02SMike Christie 8991d9edf02SMike Christie if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS)) 9001d9edf02SMike Christie return; 9011d9edf02SMike Christie 902edbc9aa0SMike Christie iscsi_update_cmdsn(conn->session, (struct iscsi_nopin *)hdr); 9031d9edf02SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 9041d9edf02SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 9051d9edf02SMike Christie if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW | 9061d9edf02SMike Christie ISCSI_FLAG_DATA_OVERFLOW)) { 9071d9edf02SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 9081d9edf02SMike Christie 9091d9edf02SMike Christie if (res_count > 0 && 9101d9edf02SMike Christie (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 9111d9edf02SMike Christie res_count <= scsi_in(sc)->length)) 9121d9edf02SMike Christie scsi_in(sc)->resid = res_count; 9131d9edf02SMike Christie else 9141d9edf02SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 9151d9edf02SMike Christie } 9161d9edf02SMike Christie 9173bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, "data in with status done " 9183bbaaad9SMike Christie "[sc %p res %d itt 0x%x]\n", 9193bbaaad9SMike Christie sc, sc->result, task->itt); 9201d9edf02SMike Christie conn->scsirsp_pdus_cnt++; 921b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 9221d9edf02SMike Christie } 9231d9edf02SMike Christie 9247ea8b828SMike Christie static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) 9257ea8b828SMike Christie { 9267ea8b828SMike Christie struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; 9277ea8b828SMike Christie 9287ea8b828SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 9297ea8b828SMike Christie conn->tmfrsp_pdus_cnt++; 9307ea8b828SMike Christie 931843c0a8aSMike Christie if (conn->tmf_state != TMF_QUEUED) 9327ea8b828SMike Christie return; 9337ea8b828SMike Christie 9347ea8b828SMike Christie if (tmf->response == ISCSI_TMF_RSP_COMPLETE) 935843c0a8aSMike Christie conn->tmf_state = TMF_SUCCESS; 9367ea8b828SMike Christie else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) 937843c0a8aSMike Christie conn->tmf_state = TMF_NOT_FOUND; 9387ea8b828SMike Christie else 939843c0a8aSMike Christie conn->tmf_state = TMF_FAILED; 9407ea8b828SMike Christie wake_up(&conn->ehwait); 9417ea8b828SMike Christie } 9427ea8b828SMike Christie 943f6d5180cSMike Christie static void iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) 944f6d5180cSMike Christie { 945f6d5180cSMike Christie struct iscsi_nopout hdr; 9469c19a7d0SMike Christie struct iscsi_task *task; 947f6d5180cSMike Christie 9489c19a7d0SMike Christie if (!rhdr && conn->ping_task) 949f6d5180cSMike Christie return; 950f6d5180cSMike Christie 951f6d5180cSMike Christie memset(&hdr, 0, sizeof(struct iscsi_nopout)); 952f6d5180cSMike Christie hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE; 953f6d5180cSMike Christie hdr.flags = ISCSI_FLAG_CMD_FINAL; 954f6d5180cSMike Christie 955f6d5180cSMike Christie if (rhdr) { 95655bdabdfSAndy Grover hdr.lun = rhdr->lun; 957f6d5180cSMike Christie hdr.ttt = rhdr->ttt; 958f6d5180cSMike Christie hdr.itt = RESERVED_ITT; 959f6d5180cSMike Christie } else 960f6d5180cSMike Christie hdr.ttt = RESERVED_ITT; 961f6d5180cSMike Christie 9629c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0); 9639c19a7d0SMike Christie if (!task) 964322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n"); 965d3acf022SMike Christie else if (!rhdr) { 966d3acf022SMike Christie /* only track our nops */ 967d3acf022SMike Christie conn->ping_task = task; 968d3acf022SMike Christie conn->last_ping = jiffies; 969d3acf022SMike Christie } 970f6d5180cSMike Christie } 971f6d5180cSMike Christie 9728afa1439SMike Christie static int iscsi_nop_out_rsp(struct iscsi_task *task, 9738afa1439SMike Christie struct iscsi_nopin *nop, char *data, int datalen) 9748afa1439SMike Christie { 9758afa1439SMike Christie struct iscsi_conn *conn = task->conn; 9768afa1439SMike Christie int rc = 0; 9778afa1439SMike Christie 9788afa1439SMike Christie if (conn->ping_task != task) { 9798afa1439SMike Christie /* 9808afa1439SMike Christie * If this is not in response to one of our 9818afa1439SMike Christie * nops then it must be from userspace. 9828afa1439SMike Christie */ 9838afa1439SMike Christie if (iscsi_recv_pdu(conn->cls_conn, (struct iscsi_hdr *)nop, 9848afa1439SMike Christie data, datalen)) 9858afa1439SMike Christie rc = ISCSI_ERR_CONN_FAILED; 9868afa1439SMike Christie } else 9878afa1439SMike Christie mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout); 9888afa1439SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 9898afa1439SMike Christie return rc; 9908afa1439SMike Christie } 9918afa1439SMike Christie 99262f38300SMike Christie static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 99362f38300SMike Christie char *data, int datalen) 99462f38300SMike Christie { 99562f38300SMike Christie struct iscsi_reject *reject = (struct iscsi_reject *)hdr; 99662f38300SMike Christie struct iscsi_hdr rejected_pdu; 9978afa1439SMike Christie int opcode, rc = 0; 99862f38300SMike Christie 99962f38300SMike Christie conn->exp_statsn = be32_to_cpu(reject->statsn) + 1; 100062f38300SMike Christie 10018afa1439SMike Christie if (ntoh24(reject->dlength) > datalen || 10028afa1439SMike Christie ntoh24(reject->dlength) < sizeof(struct iscsi_hdr)) { 10038afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Cannot handle rejected " 10048afa1439SMike Christie "pdu. Invalid data length (pdu dlength " 10058afa1439SMike Christie "%u, datalen %d\n", ntoh24(reject->dlength), 10068afa1439SMike Christie datalen); 100762f38300SMike Christie return ISCSI_ERR_PROTO; 10088afa1439SMike Christie } 100962f38300SMike Christie memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr)); 10108afa1439SMike Christie opcode = rejected_pdu.opcode & ISCSI_OPCODE_MASK; 10118afa1439SMike Christie 10128afa1439SMike Christie switch (reject->reason) { 10138afa1439SMike Christie case ISCSI_REASON_DATA_DIGEST_ERROR: 1014322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 10158afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected " 1016262ef636SMike Christie "due to DataDigest error.\n", 10178afa1439SMike Christie rejected_pdu.itt, opcode); 10188afa1439SMike Christie break; 10198afa1439SMike Christie case ISCSI_REASON_IMM_CMD_REJECT: 10208afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 10218afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Too many " 10228afa1439SMike Christie "immediate commands.\n", 10238afa1439SMike Christie rejected_pdu.itt, opcode); 10248afa1439SMike Christie /* 10258afa1439SMike Christie * We only send one TMF at a time so if the target could not 10268afa1439SMike Christie * handle it, then it should get fixed (RFC mandates that 10278afa1439SMike Christie * a target can handle one immediate TMF per conn). 10288afa1439SMike Christie * 10298afa1439SMike Christie * For nops-outs, we could have sent more than one if 10308afa1439SMike Christie * the target is sending us lots of nop-ins 10318afa1439SMike Christie */ 10328afa1439SMike Christie if (opcode != ISCSI_OP_NOOP_OUT) 103362f38300SMike Christie return 0; 10348afa1439SMike Christie 10358afa1439SMike Christie if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG)) 10368afa1439SMike Christie /* 10378afa1439SMike Christie * nop-out in response to target's nop-out rejected. 10388afa1439SMike Christie * Just resend. 10398afa1439SMike Christie */ 10408afa1439SMike Christie iscsi_send_nopout(conn, 10418afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu); 10428afa1439SMike Christie else { 10438afa1439SMike Christie struct iscsi_task *task; 10448afa1439SMike Christie /* 10458afa1439SMike Christie * Our nop as ping got dropped. We know the target 10468afa1439SMike Christie * and transport are ok so just clean up 10478afa1439SMike Christie */ 10488afa1439SMike Christie task = iscsi_itt_to_task(conn, rejected_pdu.itt); 10498afa1439SMike Christie if (!task) { 10508afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 10518afa1439SMike Christie "Invalid pdu reject. Could " 10528afa1439SMike Christie "not lookup rejected task.\n"); 10538afa1439SMike Christie rc = ISCSI_ERR_BAD_ITT; 10548afa1439SMike Christie } else 10558afa1439SMike Christie rc = iscsi_nop_out_rsp(task, 10568afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu, 10578afa1439SMike Christie NULL, 0); 10588afa1439SMike Christie } 10598afa1439SMike Christie break; 10608afa1439SMike Christie default: 10618afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 10628afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Reason " 10638afa1439SMike Christie "code 0x%x\n", rejected_pdu.itt, 10648afa1439SMike Christie rejected_pdu.opcode, reject->reason); 10658afa1439SMike Christie break; 10668afa1439SMike Christie } 10678afa1439SMike Christie return rc; 106862f38300SMike Christie } 106962f38300SMike Christie 10707996a778SMike Christie /** 1071913e5bf4SMike Christie * iscsi_itt_to_task - look up task by itt 1072913e5bf4SMike Christie * @conn: iscsi connection 1073913e5bf4SMike Christie * @itt: itt 1074913e5bf4SMike Christie * 1075913e5bf4SMike Christie * This should be used for mgmt tasks like login and nops, or if 1076913e5bf4SMike Christie * the LDD's itt space does not include the session age. 1077913e5bf4SMike Christie * 1078913e5bf4SMike Christie * The session lock must be held. 1079913e5bf4SMike Christie */ 10808f9256ceSMike Christie struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt) 1081913e5bf4SMike Christie { 1082913e5bf4SMike Christie struct iscsi_session *session = conn->session; 1083262ef636SMike Christie int i; 1084913e5bf4SMike Christie 1085913e5bf4SMike Christie if (itt == RESERVED_ITT) 1086913e5bf4SMike Christie return NULL; 1087913e5bf4SMike Christie 1088262ef636SMike Christie if (session->tt->parse_pdu_itt) 1089262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, NULL); 1090262ef636SMike Christie else 1091913e5bf4SMike Christie i = get_itt(itt); 1092913e5bf4SMike Christie if (i >= session->cmds_max) 1093913e5bf4SMike Christie return NULL; 1094913e5bf4SMike Christie 1095913e5bf4SMike Christie return session->cmds[i]; 1096913e5bf4SMike Christie } 10978f9256ceSMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_task); 1098913e5bf4SMike Christie 1099913e5bf4SMike Christie /** 11007996a778SMike Christie * __iscsi_complete_pdu - complete pdu 11017996a778SMike Christie * @conn: iscsi conn 11027996a778SMike Christie * @hdr: iscsi header 11037996a778SMike Christie * @data: data buffer 11047996a778SMike Christie * @datalen: len of data buffer 11057996a778SMike Christie * 11067996a778SMike Christie * Completes pdu processing by freeing any resources allocated at 11077996a778SMike Christie * queuecommand or send generic. session lock must be held and verify 11087996a778SMike Christie * itt must have been called. 11097996a778SMike Christie */ 1110913e5bf4SMike Christie int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 11117996a778SMike Christie char *data, int datalen) 11127996a778SMike Christie { 11137996a778SMike Christie struct iscsi_session *session = conn->session; 11147996a778SMike Christie int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0; 11159c19a7d0SMike Christie struct iscsi_task *task; 11167996a778SMike Christie uint32_t itt; 11177996a778SMike Christie 1118f6d5180cSMike Christie conn->last_recv = jiffies; 11190af967f5SMike Christie rc = iscsi_verify_itt(conn, hdr->itt); 11200af967f5SMike Christie if (rc) 11210af967f5SMike Christie return rc; 11220af967f5SMike Christie 1123b4377356SAl Viro if (hdr->itt != RESERVED_ITT) 1124b4377356SAl Viro itt = get_itt(hdr->itt); 11257996a778SMike Christie else 1126b4377356SAl Viro itt = ~0U; 11277996a778SMike Christie 11281b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "[op 0x%x cid %d itt 0x%x len %d]\n", 11293e5c28adSMike Christie opcode, conn->id, itt, datalen); 11307996a778SMike Christie 11313e5c28adSMike Christie if (itt == ~0U) { 113277a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 113362f38300SMike Christie 11347996a778SMike Christie switch(opcode) { 11357996a778SMike Christie case ISCSI_OP_NOOP_IN: 113640527afeSMike Christie if (datalen) { 113740527afeSMike Christie rc = ISCSI_ERR_PROTO; 113840527afeSMike Christie break; 113940527afeSMike Christie } 114040527afeSMike Christie 1141b4377356SAl Viro if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) 114240527afeSMike Christie break; 114340527afeSMike Christie 1144f6d5180cSMike Christie iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr); 11457996a778SMike Christie break; 11467996a778SMike Christie case ISCSI_OP_REJECT: 114762f38300SMike Christie rc = iscsi_handle_reject(conn, hdr, data, datalen); 114862f38300SMike Christie break; 11497996a778SMike Christie case ISCSI_OP_ASYNC_EVENT: 11508d2860b3SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 11515831c737SMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 11525831c737SMike Christie rc = ISCSI_ERR_CONN_FAILED; 11537996a778SMike Christie break; 11547996a778SMike Christie default: 11557996a778SMike Christie rc = ISCSI_ERR_BAD_OPCODE; 11567996a778SMike Christie break; 11577996a778SMike Christie } 11583e5c28adSMike Christie goto out; 11593e5c28adSMike Christie } 11607996a778SMike Christie 11613e5c28adSMike Christie switch(opcode) { 11623e5c28adSMike Christie case ISCSI_OP_SCSI_CMD_RSP: 1163913e5bf4SMike Christie case ISCSI_OP_SCSI_DATA_IN: 1164913e5bf4SMike Christie task = iscsi_itt_to_ctask(conn, hdr->itt); 1165913e5bf4SMike Christie if (!task) 1166913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1167d355e57dSMike Christie task->last_xfer = jiffies; 11683e5c28adSMike Christie break; 1169913e5bf4SMike Christie case ISCSI_OP_R2T: 1170913e5bf4SMike Christie /* 1171913e5bf4SMike Christie * LLD handles R2Ts if they need to. 1172913e5bf4SMike Christie */ 1173913e5bf4SMike Christie return 0; 1174913e5bf4SMike Christie case ISCSI_OP_LOGOUT_RSP: 1175913e5bf4SMike Christie case ISCSI_OP_LOGIN_RSP: 1176913e5bf4SMike Christie case ISCSI_OP_TEXT_RSP: 1177913e5bf4SMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 1178913e5bf4SMike Christie case ISCSI_OP_NOOP_IN: 1179913e5bf4SMike Christie task = iscsi_itt_to_task(conn, hdr->itt); 1180913e5bf4SMike Christie if (!task) 1181913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1182913e5bf4SMike Christie break; 1183913e5bf4SMike Christie default: 1184913e5bf4SMike Christie return ISCSI_ERR_BAD_OPCODE; 11853e5c28adSMike Christie } 1186913e5bf4SMike Christie 1187913e5bf4SMike Christie switch(opcode) { 1188913e5bf4SMike Christie case ISCSI_OP_SCSI_CMD_RSP: 11899c19a7d0SMike Christie iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen); 11903e5c28adSMike Christie break; 11913e5c28adSMike Christie case ISCSI_OP_SCSI_DATA_IN: 11921d9edf02SMike Christie iscsi_data_in_rsp(conn, hdr, task); 11933e5c28adSMike Christie break; 11943e5c28adSMike Christie case ISCSI_OP_LOGOUT_RSP: 11953e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 11963e5c28adSMike Christie if (datalen) { 11973e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 11983e5c28adSMike Christie break; 11993e5c28adSMike Christie } 12003e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 12013e5c28adSMike Christie goto recv_pdu; 12023e5c28adSMike Christie case ISCSI_OP_LOGIN_RSP: 12033e5c28adSMike Christie case ISCSI_OP_TEXT_RSP: 12043e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12053e5c28adSMike Christie /* 12063e5c28adSMike Christie * login related PDU's exp_statsn is handled in 12073e5c28adSMike Christie * userspace 12083e5c28adSMike Christie */ 12093e5c28adSMike Christie goto recv_pdu; 12103e5c28adSMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 12113e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12123e5c28adSMike Christie if (datalen) { 12133e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12143e5c28adSMike Christie break; 12153e5c28adSMike Christie } 12163e5c28adSMike Christie 12173e5c28adSMike Christie iscsi_tmf_rsp(conn, hdr); 1218b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 12193e5c28adSMike Christie break; 12203e5c28adSMike Christie case ISCSI_OP_NOOP_IN: 12213e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12223e5c28adSMike Christie if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) { 12233e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12243e5c28adSMike Christie break; 12253e5c28adSMike Christie } 12263e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 12273e5c28adSMike Christie 12288afa1439SMike Christie rc = iscsi_nop_out_rsp(task, (struct iscsi_nopin*)hdr, 12298afa1439SMike Christie data, datalen); 12303e5c28adSMike Christie break; 12313e5c28adSMike Christie default: 12323e5c28adSMike Christie rc = ISCSI_ERR_BAD_OPCODE; 12333e5c28adSMike Christie break; 12343e5c28adSMike Christie } 12353e5c28adSMike Christie 12363e5c28adSMike Christie out: 12373e5c28adSMike Christie return rc; 12383e5c28adSMike Christie recv_pdu: 12393e5c28adSMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 12403e5c28adSMike Christie rc = ISCSI_ERR_CONN_FAILED; 1241b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 12427996a778SMike Christie return rc; 12437996a778SMike Christie } 1244913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_complete_pdu); 12457996a778SMike Christie 12467996a778SMike Christie int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 12477996a778SMike Christie char *data, int datalen) 12487996a778SMike Christie { 12497996a778SMike Christie int rc; 12507996a778SMike Christie 12517996a778SMike Christie spin_lock(&conn->session->lock); 12527996a778SMike Christie rc = __iscsi_complete_pdu(conn, hdr, data, datalen); 12537996a778SMike Christie spin_unlock(&conn->session->lock); 12547996a778SMike Christie return rc; 12557996a778SMike Christie } 12567996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_pdu); 12577996a778SMike Christie 12580af967f5SMike Christie int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt) 12597996a778SMike Christie { 12607996a778SMike Christie struct iscsi_session *session = conn->session; 1261262ef636SMike Christie int age = 0, i = 0; 12627996a778SMike Christie 12630af967f5SMike Christie if (itt == RESERVED_ITT) 12640af967f5SMike Christie return 0; 12650af967f5SMike Christie 1266262ef636SMike Christie if (session->tt->parse_pdu_itt) 1267262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, &age); 1268262ef636SMike Christie else { 1269262ef636SMike Christie i = get_itt(itt); 1270262ef636SMike Christie age = ((__force u32)itt >> ISCSI_AGE_SHIFT) & ISCSI_AGE_MASK; 1271262ef636SMike Christie } 1272262ef636SMike Christie 1273262ef636SMike Christie if (age != session->age) { 1274322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 12750af967f5SMike Christie "received itt %x expected session age (%x)\n", 1276913e5bf4SMike Christie (__force u32)itt, session->age); 12777996a778SMike Christie return ISCSI_ERR_BAD_ITT; 12787996a778SMike Christie } 12797996a778SMike Christie 12803e5c28adSMike Christie if (i >= session->cmds_max) { 12813e5c28adSMike Christie iscsi_conn_printk(KERN_ERR, conn, 12823e5c28adSMike Christie "received invalid itt index %u (max cmds " 12833e5c28adSMike Christie "%u.\n", i, session->cmds_max); 12843e5c28adSMike Christie return ISCSI_ERR_BAD_ITT; 12857996a778SMike Christie } 12867996a778SMike Christie return 0; 12877996a778SMike Christie } 12887996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_verify_itt); 12897996a778SMike Christie 1290913e5bf4SMike Christie /** 1291913e5bf4SMike Christie * iscsi_itt_to_ctask - look up ctask by itt 1292913e5bf4SMike Christie * @conn: iscsi connection 1293913e5bf4SMike Christie * @itt: itt 1294913e5bf4SMike Christie * 1295913e5bf4SMike Christie * This should be used for cmd tasks. 1296913e5bf4SMike Christie * 1297913e5bf4SMike Christie * The session lock must be held. 1298913e5bf4SMike Christie */ 1299913e5bf4SMike Christie struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt) 13000af967f5SMike Christie { 13019c19a7d0SMike Christie struct iscsi_task *task; 13020af967f5SMike Christie 13030af967f5SMike Christie if (iscsi_verify_itt(conn, itt)) 13040af967f5SMike Christie return NULL; 13050af967f5SMike Christie 1306913e5bf4SMike Christie task = iscsi_itt_to_task(conn, itt); 1307913e5bf4SMike Christie if (!task || !task->sc) 13080af967f5SMike Christie return NULL; 13090af967f5SMike Christie 1310913e5bf4SMike Christie if (task->sc->SCp.phase != conn->session->age) { 1311913e5bf4SMike Christie iscsi_session_printk(KERN_ERR, conn->session, 1312913e5bf4SMike Christie "task's session age %d, expected %d\n", 1313913e5bf4SMike Christie task->sc->SCp.phase, conn->session->age); 13140af967f5SMike Christie return NULL; 1315913e5bf4SMike Christie } 13160af967f5SMike Christie 13179c19a7d0SMike Christie return task; 13180af967f5SMike Christie } 13190af967f5SMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask); 13200af967f5SMike Christie 132140a06e75SMike Christie void iscsi_session_failure(struct iscsi_session *session, 1322e5bd7b54SMike Christie enum iscsi_err err) 1323e5bd7b54SMike Christie { 1324e5bd7b54SMike Christie struct iscsi_conn *conn; 1325e5bd7b54SMike Christie struct device *dev; 1326e5bd7b54SMike Christie 1327bfcf72e4SMike Christie spin_lock_bh(&session->lock); 1328e5bd7b54SMike Christie conn = session->leadconn; 1329e5bd7b54SMike Christie if (session->state == ISCSI_STATE_TERMINATE || !conn) { 1330bfcf72e4SMike Christie spin_unlock_bh(&session->lock); 1331e5bd7b54SMike Christie return; 1332e5bd7b54SMike Christie } 1333e5bd7b54SMike Christie 1334e5bd7b54SMike Christie dev = get_device(&conn->cls_conn->dev); 1335bfcf72e4SMike Christie spin_unlock_bh(&session->lock); 1336e5bd7b54SMike Christie if (!dev) 1337e5bd7b54SMike Christie return; 1338e5bd7b54SMike Christie /* 1339e5bd7b54SMike Christie * if the host is being removed bypass the connection 1340e5bd7b54SMike Christie * recovery initialization because we are going to kill 1341e5bd7b54SMike Christie * the session. 1342e5bd7b54SMike Christie */ 1343e5bd7b54SMike Christie if (err == ISCSI_ERR_INVALID_HOST) 1344e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 1345e5bd7b54SMike Christie else 1346e5bd7b54SMike Christie iscsi_conn_failure(conn, err); 1347e5bd7b54SMike Christie put_device(dev); 1348e5bd7b54SMike Christie } 1349e5bd7b54SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_failure); 1350e5bd7b54SMike Christie 13517996a778SMike Christie void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err) 13527996a778SMike Christie { 13537996a778SMike Christie struct iscsi_session *session = conn->session; 13547996a778SMike Christie 1355bfcf72e4SMike Christie spin_lock_bh(&session->lock); 1356656cffc9SMike Christie if (session->state == ISCSI_STATE_FAILED) { 1357bfcf72e4SMike Christie spin_unlock_bh(&session->lock); 1358656cffc9SMike Christie return; 1359656cffc9SMike Christie } 1360656cffc9SMike Christie 136167a61114SMike Christie if (conn->stop_stage == 0) 13627996a778SMike Christie session->state = ISCSI_STATE_FAILED; 1363bfcf72e4SMike Christie spin_unlock_bh(&session->lock); 1364e5bd7b54SMike Christie 13657996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 13667996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 1367e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 13687996a778SMike Christie } 13697996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_failure); 13707996a778SMike Christie 137177a23c21SMike Christie static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn) 137277a23c21SMike Christie { 137377a23c21SMike Christie struct iscsi_session *session = conn->session; 137477a23c21SMike Christie 137577a23c21SMike Christie /* 137677a23c21SMike Christie * Check for iSCSI window and take care of CmdSN wrap-around 137777a23c21SMike Christie */ 1378e0726407SMike Christie if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) { 13791b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iSCSI CmdSN closed. ExpCmdSn " 13801b2c7af8SMike Christie "%u MaxCmdSN %u CmdSN %u/%u\n", 13811b2c7af8SMike Christie session->exp_cmdsn, session->max_cmdsn, 13821b2c7af8SMike Christie session->cmdsn, session->queued_cmdsn); 138377a23c21SMike Christie return -ENOSPC; 138477a23c21SMike Christie } 138577a23c21SMike Christie return 0; 138677a23c21SMike Christie } 138777a23c21SMike Christie 13889c19a7d0SMike Christie static int iscsi_xmit_task(struct iscsi_conn *conn) 138977a23c21SMike Christie { 13909c19a7d0SMike Christie struct iscsi_task *task = conn->task; 1391843c0a8aSMike Christie int rc; 139277a23c21SMike Christie 139370b31c15SMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) 139470b31c15SMike Christie return -ENODATA; 139570b31c15SMike Christie 13969c19a7d0SMike Christie __iscsi_get_task(task); 139777a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 13989c19a7d0SMike Christie rc = conn->session->tt->xmit_task(task); 139977a23c21SMike Christie spin_lock_bh(&conn->session->lock); 1400d355e57dSMike Christie if (!rc) { 14019c19a7d0SMike Christie /* done with this task */ 1402d355e57dSMike Christie task->last_xfer = jiffies; 14039c19a7d0SMike Christie conn->task = NULL; 1404d355e57dSMike Christie } 1405d355e57dSMike Christie __iscsi_put_task(task); 140677a23c21SMike Christie return rc; 140777a23c21SMike Christie } 140877a23c21SMike Christie 14097996a778SMike Christie /** 14109c19a7d0SMike Christie * iscsi_requeue_task - requeue task to run from session workqueue 14119c19a7d0SMike Christie * @task: task to requeue 1412843c0a8aSMike Christie * 14139c19a7d0SMike Christie * LLDs that need to run a task from the session workqueue should call 1414052d0144SMike Christie * this. The session lock must be held. This should only be called 1415052d0144SMike Christie * by software drivers. 1416843c0a8aSMike Christie */ 14179c19a7d0SMike Christie void iscsi_requeue_task(struct iscsi_task *task) 1418843c0a8aSMike Christie { 14199c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 1420843c0a8aSMike Christie 14213bbaaad9SMike Christie /* 14223bbaaad9SMike Christie * this may be on the requeue list already if the xmit_task callout 14233bbaaad9SMike Christie * is handling the r2ts while we are adding new ones 14243bbaaad9SMike Christie */ 14253bbaaad9SMike Christie if (list_empty(&task->running)) 14263bbaaad9SMike Christie list_add_tail(&task->running, &conn->requeue); 142732ae763eSMike Christie iscsi_conn_queue_work(conn); 1428843c0a8aSMike Christie } 14299c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_requeue_task); 1430843c0a8aSMike Christie 1431843c0a8aSMike Christie /** 14327996a778SMike Christie * iscsi_data_xmit - xmit any command into the scheduled connection 14337996a778SMike Christie * @conn: iscsi connection 14347996a778SMike Christie * 14357996a778SMike Christie * Notes: 14367996a778SMike Christie * The function can return -EAGAIN in which case the caller must 14377996a778SMike Christie * re-schedule it again later or recover. '0' return code means 14387996a778SMike Christie * successful xmit. 14397996a778SMike Christie **/ 14407996a778SMike Christie static int iscsi_data_xmit(struct iscsi_conn *conn) 14417996a778SMike Christie { 14425d12c05eSMike Christie struct iscsi_task *task; 14433219e529SMike Christie int rc = 0; 14447996a778SMike Christie 144577a23c21SMike Christie spin_lock_bh(&conn->session->lock); 144670b31c15SMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) { 14471b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n"); 144877a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 14493219e529SMike Christie return -ENODATA; 14507996a778SMike Christie } 14517996a778SMike Christie 14529c19a7d0SMike Christie if (conn->task) { 14539c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 14543219e529SMike Christie if (rc) 145570b31c15SMike Christie goto done; 14567996a778SMike Christie } 145777a23c21SMike Christie 145877a23c21SMike Christie /* 145977a23c21SMike Christie * process mgmt pdus like nops before commands since we should 146077a23c21SMike Christie * only have one nop-out as a ping from us and targets should not 146177a23c21SMike Christie * overflow us with nop-ins 146277a23c21SMike Christie */ 146377a23c21SMike Christie check_mgmt: 1464843c0a8aSMike Christie while (!list_empty(&conn->mgmtqueue)) { 14659c19a7d0SMike Christie conn->task = list_entry(conn->mgmtqueue.next, 14669c19a7d0SMike Christie struct iscsi_task, running); 14673bbaaad9SMike Christie list_del_init(&conn->task->running); 14689c19a7d0SMike Christie if (iscsi_prep_mgmt_task(conn, conn->task)) { 14699c19a7d0SMike Christie __iscsi_put_task(conn->task); 14709c19a7d0SMike Christie conn->task = NULL; 1471b3a7ea8dSMike Christie continue; 1472b3a7ea8dSMike Christie } 14739c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 14743219e529SMike Christie if (rc) 147570b31c15SMike Christie goto done; 14767996a778SMike Christie } 14777996a778SMike Christie 1478843c0a8aSMike Christie /* process pending command queue */ 14793bbaaad9SMike Christie while (!list_empty(&conn->cmdqueue)) { 14805d12c05eSMike Christie conn->task = list_entry(conn->cmdqueue.next, struct iscsi_task, 14815d12c05eSMike Christie running); 14823bbaaad9SMike Christie list_del_init(&conn->task->running); 1483b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) { 1484b3cd5050SMike Christie fail_scsi_task(conn->task, DID_IMM_RETRY); 1485b3a7ea8dSMike Christie continue; 1486b3a7ea8dSMike Christie } 1487577577daSMike Christie rc = iscsi_prep_scsi_cmd_pdu(conn->task); 1488577577daSMike Christie if (rc) { 14895d12c05eSMike Christie if (rc == -ENOMEM || rc == -EACCES) { 14903bbaaad9SMike Christie list_add_tail(&conn->task->running, 14913bbaaad9SMike Christie &conn->cmdqueue); 1492577577daSMike Christie conn->task = NULL; 149370b31c15SMike Christie goto done; 1494577577daSMike Christie } else 1495b3cd5050SMike Christie fail_scsi_task(conn->task, DID_ABORT); 1496004d6530SBoaz Harrosh continue; 1497004d6530SBoaz Harrosh } 14989c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 14993219e529SMike Christie if (rc) 150070b31c15SMike Christie goto done; 150177a23c21SMike Christie /* 15029c19a7d0SMike Christie * we could continuously get new task requests so 150377a23c21SMike Christie * we need to check the mgmt queue for nops that need to 150477a23c21SMike Christie * be sent to aviod starvation 150577a23c21SMike Christie */ 1506843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 1507843c0a8aSMike Christie goto check_mgmt; 1508843c0a8aSMike Christie } 1509843c0a8aSMike Christie 1510843c0a8aSMike Christie while (!list_empty(&conn->requeue)) { 1511b3a7ea8dSMike Christie /* 1512b3a7ea8dSMike Christie * we always do fastlogout - conn stop code will clean up. 1513b3a7ea8dSMike Christie */ 1514b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 1515b3a7ea8dSMike Christie break; 1516b3a7ea8dSMike Christie 15175d12c05eSMike Christie task = list_entry(conn->requeue.next, struct iscsi_task, 15185d12c05eSMike Christie running); 15195d12c05eSMike Christie if (iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_DATA_OUT)) 15205d12c05eSMike Christie break; 15215d12c05eSMike Christie 15225d12c05eSMike Christie conn->task = task; 15233bbaaad9SMike Christie list_del_init(&conn->task->running); 15249c19a7d0SMike Christie conn->task->state = ISCSI_TASK_RUNNING; 15259c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 1526843c0a8aSMike Christie if (rc) 152770b31c15SMike Christie goto done; 1528843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 152977a23c21SMike Christie goto check_mgmt; 15307996a778SMike Christie } 153177a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 15323219e529SMike Christie return -ENODATA; 15337996a778SMike Christie 153470b31c15SMike Christie done: 153577a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 15363219e529SMike Christie return rc; 15377996a778SMike Christie } 15387996a778SMike Christie 1539c4028958SDavid Howells static void iscsi_xmitworker(struct work_struct *work) 15407996a778SMike Christie { 1541c4028958SDavid Howells struct iscsi_conn *conn = 1542c4028958SDavid Howells container_of(work, struct iscsi_conn, xmitwork); 15433219e529SMike Christie int rc; 15447996a778SMike Christie /* 15457996a778SMike Christie * serialize Xmit worker on a per-connection basis. 15467996a778SMike Christie */ 15473219e529SMike Christie do { 15483219e529SMike Christie rc = iscsi_data_xmit(conn); 15493219e529SMike Christie } while (rc >= 0 || rc == -EAGAIN); 15507996a778SMike Christie } 15517996a778SMike Christie 1552577577daSMike Christie static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn, 1553577577daSMike Christie struct scsi_cmnd *sc) 1554577577daSMike Christie { 1555577577daSMike Christie struct iscsi_task *task; 1556577577daSMike Christie 15577acd72ebSStefani Seibold if (!kfifo_out(&conn->session->cmdpool.queue, 1558577577daSMike Christie (void *) &task, sizeof(void *))) 1559577577daSMike Christie return NULL; 1560577577daSMike Christie 1561577577daSMike Christie sc->SCp.phase = conn->session->age; 1562577577daSMike Christie sc->SCp.ptr = (char *) task; 1563577577daSMike Christie 1564577577daSMike Christie atomic_set(&task->refcount, 1); 1565577577daSMike Christie task->state = ISCSI_TASK_PENDING; 1566577577daSMike Christie task->conn = conn; 1567577577daSMike Christie task->sc = sc; 1568d355e57dSMike Christie task->have_checked_conn = false; 1569d355e57dSMike Christie task->last_timeout = jiffies; 1570d355e57dSMike Christie task->last_xfer = jiffies; 1571577577daSMike Christie INIT_LIST_HEAD(&task->running); 1572577577daSMike Christie return task; 1573577577daSMike Christie } 1574577577daSMike Christie 15757996a778SMike Christie enum { 15767996a778SMike Christie FAILURE_BAD_HOST = 1, 15777996a778SMike Christie FAILURE_SESSION_FAILED, 15787996a778SMike Christie FAILURE_SESSION_FREED, 15797996a778SMike Christie FAILURE_WINDOW_CLOSED, 158060ecebf5SMike Christie FAILURE_OOM, 15817996a778SMike Christie FAILURE_SESSION_TERMINATE, 1582656cffc9SMike Christie FAILURE_SESSION_IN_RECOVERY, 15837996a778SMike Christie FAILURE_SESSION_RECOVERY_TIMEOUT, 1584b3a7ea8dSMike Christie FAILURE_SESSION_LOGGING_OUT, 15856eabafbeSMike Christie FAILURE_SESSION_NOT_READY, 15867996a778SMike Christie }; 15877996a778SMike Christie 1588f41d4721SMike Christie int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc) 15897996a778SMike Christie { 159075613521SMike Christie struct iscsi_cls_session *cls_session; 15911336aed1SMike Christie struct iscsi_host *ihost; 15927996a778SMike Christie int reason = 0; 15937996a778SMike Christie struct iscsi_session *session; 15947996a778SMike Christie struct iscsi_conn *conn; 15959c19a7d0SMike Christie struct iscsi_task *task = NULL; 15967996a778SMike Christie 15977996a778SMike Christie sc->result = 0; 1598f47f2cf5SMike Christie sc->SCp.ptr = NULL; 15997996a778SMike Christie 16001336aed1SMike Christie ihost = shost_priv(host); 16017996a778SMike Christie 160275613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 160375613521SMike Christie session = cls_session->dd_data; 1604f41d4721SMike Christie spin_lock_bh(&session->lock); 16057996a778SMike Christie 160675613521SMike Christie reason = iscsi_session_chkready(cls_session); 16076eabafbeSMike Christie if (reason) { 16086eabafbeSMike Christie sc->result = reason; 16096eabafbeSMike Christie goto fault; 16106eabafbeSMike Christie } 16116eabafbeSMike Christie 1612301e0f7eSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1613656cffc9SMike Christie /* 1614656cffc9SMike Christie * to handle the race between when we set the recovery state 1615656cffc9SMike Christie * and block the session we requeue here (commands could 1616656cffc9SMike Christie * be entering our queuecommand while a block is starting 1617656cffc9SMike Christie * up because the block code is not locked) 1618656cffc9SMike Christie */ 16199000bcd6SMike Christie switch (session->state) { 1620301e0f7eSMike Christie case ISCSI_STATE_FAILED: 16219000bcd6SMike Christie case ISCSI_STATE_IN_RECOVERY: 1622656cffc9SMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1623301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1624301e0f7eSMike Christie break; 16259000bcd6SMike Christie case ISCSI_STATE_LOGGING_OUT: 16269000bcd6SMike Christie reason = FAILURE_SESSION_LOGGING_OUT; 1627301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1628301e0f7eSMike Christie break; 1629b3a7ea8dSMike Christie case ISCSI_STATE_RECOVERY_FAILED: 1630656cffc9SMike Christie reason = FAILURE_SESSION_RECOVERY_TIMEOUT; 163156d7fcfaSMike Christie sc->result = DID_TRANSPORT_FAILFAST << 16; 1632b3a7ea8dSMike Christie break; 1633b3a7ea8dSMike Christie case ISCSI_STATE_TERMINATE: 1634656cffc9SMike Christie reason = FAILURE_SESSION_TERMINATE; 16356eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1636b3a7ea8dSMike Christie break; 1637b3a7ea8dSMike Christie default: 16387996a778SMike Christie reason = FAILURE_SESSION_FREED; 16396eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1640b3a7ea8dSMike Christie } 16417996a778SMike Christie goto fault; 16427996a778SMike Christie } 16437996a778SMike Christie 16447996a778SMike Christie conn = session->leadconn; 164598644047SMike Christie if (!conn) { 164698644047SMike Christie reason = FAILURE_SESSION_FREED; 16476eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 164898644047SMike Christie goto fault; 164998644047SMike Christie } 16507996a778SMike Christie 1651661134adSMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) { 1652661134adSMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1653661134adSMike Christie sc->result = DID_REQUEUE; 1654661134adSMike Christie goto fault; 1655661134adSMike Christie } 1656661134adSMike Christie 165777a23c21SMike Christie if (iscsi_check_cmdsn_window_closed(conn)) { 165877a23c21SMike Christie reason = FAILURE_WINDOW_CLOSED; 165977a23c21SMike Christie goto reject; 166077a23c21SMike Christie } 166177a23c21SMike Christie 1662577577daSMike Christie task = iscsi_alloc_task(conn, sc); 1663577577daSMike Christie if (!task) { 166460ecebf5SMike Christie reason = FAILURE_OOM; 166560ecebf5SMike Christie goto reject; 166660ecebf5SMike Christie } 16677996a778SMike Christie 16681336aed1SMike Christie if (!ihost->workq) { 1669577577daSMike Christie reason = iscsi_prep_scsi_cmd_pdu(task); 1670577577daSMike Christie if (reason) { 16715d12c05eSMike Christie if (reason == -ENOMEM || reason == -EACCES) { 1672577577daSMike Christie reason = FAILURE_OOM; 1673577577daSMike Christie goto prepd_reject; 1674577577daSMike Christie } else { 1675052d0144SMike Christie sc->result = DID_ABORT << 16; 1676577577daSMike Christie goto prepd_fault; 1677577577daSMike Christie } 1678052d0144SMike Christie } 16799c19a7d0SMike Christie if (session->tt->xmit_task(task)) { 1680d3305f34SMike Christie session->cmdsn--; 1681052d0144SMike Christie reason = FAILURE_SESSION_NOT_READY; 1682577577daSMike Christie goto prepd_reject; 1683052d0144SMike Christie } 16843bbaaad9SMike Christie } else { 16853bbaaad9SMike Christie list_add_tail(&task->running, &conn->cmdqueue); 168632ae763eSMike Christie iscsi_conn_queue_work(conn); 16873bbaaad9SMike Christie } 1688052d0144SMike Christie 1689052d0144SMike Christie session->queued_cmdsn++; 1690f41d4721SMike Christie spin_unlock_bh(&session->lock); 16917996a778SMike Christie return 0; 16927996a778SMike Christie 1693577577daSMike Christie prepd_reject: 1694f41d4721SMike Christie iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 16957996a778SMike Christie reject: 1696f41d4721SMike Christie spin_unlock_bh(&session->lock); 16971b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n", 16981b2c7af8SMike Christie sc->cmnd[0], reason); 1699d6d13ee1SMike Christie return SCSI_MLQUEUE_TARGET_BUSY; 17007996a778SMike Christie 1701577577daSMike Christie prepd_fault: 1702f41d4721SMike Christie iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 17037996a778SMike Christie fault: 1704f41d4721SMike Christie spin_unlock_bh(&session->lock); 17051b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n", 17061b2c7af8SMike Christie sc->cmnd[0], reason); 1707c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 17081c138991SFUJITA Tomonori scsi_set_resid(sc, scsi_bufflen(sc)); 1709c07d4444SBoaz Harrosh else { 1710c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 1711c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 1712c07d4444SBoaz Harrosh } 1713f41d4721SMike Christie sc->scsi_done(sc); 17147996a778SMike Christie return 0; 17157996a778SMike Christie } 17167996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_queuecommand); 17177996a778SMike Christie 1718e881a172SMike Christie int iscsi_change_queue_depth(struct scsi_device *sdev, int depth, int reason) 17197996a778SMike Christie { 17201796e722SMike Christie switch (reason) { 17211796e722SMike Christie case SCSI_QDEPTH_DEFAULT: 17227996a778SMike Christie scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); 17231796e722SMike Christie break; 17241796e722SMike Christie case SCSI_QDEPTH_QFULL: 17251796e722SMike Christie scsi_track_queue_full(sdev, depth); 17261796e722SMike Christie break; 17271796e722SMike Christie case SCSI_QDEPTH_RAMP_UP: 17281796e722SMike Christie scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); 17291796e722SMike Christie break; 17301796e722SMike Christie default: 17311796e722SMike Christie return -EOPNOTSUPP; 17321796e722SMike Christie } 17337996a778SMike Christie return sdev->queue_depth; 17347996a778SMike Christie } 17357996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_change_queue_depth); 17367996a778SMike Christie 17376b5d6c44SMike Christie int iscsi_target_alloc(struct scsi_target *starget) 17386b5d6c44SMike Christie { 17396b5d6c44SMike Christie struct iscsi_cls_session *cls_session = starget_to_session(starget); 17406b5d6c44SMike Christie struct iscsi_session *session = cls_session->dd_data; 17416b5d6c44SMike Christie 17426b5d6c44SMike Christie starget->can_queue = session->scsi_cmds_max; 17436b5d6c44SMike Christie return 0; 17446b5d6c44SMike Christie } 17456b5d6c44SMike Christie EXPORT_SYMBOL_GPL(iscsi_target_alloc); 17466b5d6c44SMike Christie 1747843c0a8aSMike Christie static void iscsi_tmf_timedout(unsigned long data) 17487996a778SMike Christie { 1749843c0a8aSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 17507996a778SMike Christie struct iscsi_session *session = conn->session; 17517996a778SMike Christie 17527996a778SMike Christie spin_lock(&session->lock); 1753843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) { 1754843c0a8aSMike Christie conn->tmf_state = TMF_TIMEDOUT; 1755bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf timedout\n"); 17567996a778SMike Christie /* unblock eh_abort() */ 17577996a778SMike Christie wake_up(&conn->ehwait); 17587996a778SMike Christie } 17597996a778SMike Christie spin_unlock(&session->lock); 17607996a778SMike Christie } 17617996a778SMike Christie 17629c19a7d0SMike Christie static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, 1763f6d5180cSMike Christie struct iscsi_tm *hdr, int age, 1764f6d5180cSMike Christie int timeout) 17657996a778SMike Christie { 17667996a778SMike Christie struct iscsi_session *session = conn->session; 17679c19a7d0SMike Christie struct iscsi_task *task; 17687996a778SMike Christie 17699c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr, 17707996a778SMike Christie NULL, 0); 17719c19a7d0SMike Christie if (!task) { 17726724add1SMike Christie spin_unlock_bh(&session->lock); 1773df4da5cdSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send TMF.\n"); 17747996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1775843c0a8aSMike Christie spin_lock_bh(&session->lock); 177677a23c21SMike Christie return -EPERM; 17777996a778SMike Christie } 17787996a778SMike Christie conn->tmfcmd_pdus_cnt++; 1779f6d5180cSMike Christie conn->tmf_timer.expires = timeout * HZ + jiffies; 1780843c0a8aSMike Christie conn->tmf_timer.function = iscsi_tmf_timedout; 1781843c0a8aSMike Christie conn->tmf_timer.data = (unsigned long)conn; 1782843c0a8aSMike Christie add_timer(&conn->tmf_timer); 1783bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf set timeout\n"); 1784843c0a8aSMike Christie 17857996a778SMike Christie spin_unlock_bh(&session->lock); 17866724add1SMike Christie mutex_unlock(&session->eh_mutex); 17877996a778SMike Christie 17887996a778SMike Christie /* 17897996a778SMike Christie * block eh thread until: 17907996a778SMike Christie * 1791843c0a8aSMike Christie * 1) tmf response 1792843c0a8aSMike Christie * 2) tmf timeout 17937996a778SMike Christie * 3) session is terminated or restarted or userspace has 17947996a778SMike Christie * given up on recovery 17957996a778SMike Christie */ 1796843c0a8aSMike Christie wait_event_interruptible(conn->ehwait, age != session->age || 17977996a778SMike Christie session->state != ISCSI_STATE_LOGGED_IN || 1798843c0a8aSMike Christie conn->tmf_state != TMF_QUEUED); 17997996a778SMike Christie if (signal_pending(current)) 18007996a778SMike Christie flush_signals(current); 1801843c0a8aSMike Christie del_timer_sync(&conn->tmf_timer); 1802843c0a8aSMike Christie 18036724add1SMike Christie mutex_lock(&session->eh_mutex); 180477a23c21SMike Christie spin_lock_bh(&session->lock); 18059c19a7d0SMike Christie /* if the session drops it will clean up the task */ 1806843c0a8aSMike Christie if (age != session->age || 1807843c0a8aSMike Christie session->state != ISCSI_STATE_LOGGED_IN) 1808843c0a8aSMike Christie return -ENOTCONN; 18097996a778SMike Christie return 0; 18107996a778SMike Christie } 18117996a778SMike Christie 18127996a778SMike Christie /* 1813843c0a8aSMike Christie * Fail commands. session lock held and recv side suspended and xmit 1814843c0a8aSMike Christie * thread flushed 1815843c0a8aSMike Christie */ 18163bbaaad9SMike Christie static void fail_scsi_tasks(struct iscsi_conn *conn, unsigned lun, 18176eabafbeSMike Christie int error) 1818843c0a8aSMike Christie { 18193bbaaad9SMike Christie struct iscsi_task *task; 18203bbaaad9SMike Christie int i; 1821843c0a8aSMike Christie 18223bbaaad9SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 18233bbaaad9SMike Christie task = conn->session->cmds[i]; 18243bbaaad9SMike Christie if (!task->sc || task->state == ISCSI_TASK_FREE) 18253bbaaad9SMike Christie continue; 1826843c0a8aSMike Christie 18273bbaaad9SMike Christie if (lun != -1 && lun != task->sc->device->lun) 18283bbaaad9SMike Christie continue; 18293bbaaad9SMike Christie 18301b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, 18313bbaaad9SMike Christie "failing sc %p itt 0x%x state %d\n", 18323bbaaad9SMike Christie task->sc, task->itt, task->state); 1833b3cd5050SMike Christie fail_scsi_task(task, error); 1834843c0a8aSMike Christie } 1835843c0a8aSMike Christie } 1836843c0a8aSMike Christie 1837661134adSMike Christie /** 1838661134adSMike Christie * iscsi_suspend_queue - suspend iscsi_queuecommand 1839661134adSMike Christie * @conn: iscsi conn to stop queueing IO on 1840661134adSMike Christie * 1841661134adSMike Christie * This grabs the session lock to make sure no one is in 1842661134adSMike Christie * xmit_task/queuecommand, and then sets suspend to prevent 1843661134adSMike Christie * new commands from being queued. This only needs to be called 1844661134adSMike Christie * by offload drivers that need to sync a path like ep disconnect 1845661134adSMike Christie * with the iscsi_queuecommand/xmit_task. To start IO again libiscsi 1846661134adSMike Christie * will call iscsi_start_tx and iscsi_unblock_session when in FFP. 1847661134adSMike Christie */ 1848661134adSMike Christie void iscsi_suspend_queue(struct iscsi_conn *conn) 1849661134adSMike Christie { 1850661134adSMike Christie spin_lock_bh(&conn->session->lock); 1851661134adSMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1852661134adSMike Christie spin_unlock_bh(&conn->session->lock); 1853661134adSMike Christie } 1854661134adSMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_queue); 1855661134adSMike Christie 1856661134adSMike Christie /** 1857661134adSMike Christie * iscsi_suspend_tx - suspend iscsi_data_xmit 1858661134adSMike Christie * @conn: iscsi conn tp stop processing IO on. 1859661134adSMike Christie * 1860661134adSMike Christie * This function sets the suspend bit to prevent iscsi_data_xmit 1861661134adSMike Christie * from sending new IO, and if work is queued on the xmit thread 1862661134adSMike Christie * it will wait for it to be completed. 1863661134adSMike Christie */ 1864b40977d9SMike Christie void iscsi_suspend_tx(struct iscsi_conn *conn) 18656724add1SMike Christie { 186632ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 186732ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 186832ae763eSMike Christie 18696724add1SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 18701336aed1SMike Christie if (ihost->workq) 187132ae763eSMike Christie flush_workqueue(ihost->workq); 18726724add1SMike Christie } 1873b40977d9SMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_tx); 18746724add1SMike Christie 18756724add1SMike Christie static void iscsi_start_tx(struct iscsi_conn *conn) 18766724add1SMike Christie { 18776724add1SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 187832ae763eSMike Christie iscsi_conn_queue_work(conn); 18796724add1SMike Christie } 18806724add1SMike Christie 18814c48a829SMike Christie /* 18824c48a829SMike Christie * We want to make sure a ping is in flight. It has timed out. 18834c48a829SMike Christie * And we are not busy processing a pdu that is making 18844c48a829SMike Christie * progress but got started before the ping and is taking a while 18854c48a829SMike Christie * to complete so the ping is just stuck behind it in a queue. 18864c48a829SMike Christie */ 18874c48a829SMike Christie static int iscsi_has_ping_timed_out(struct iscsi_conn *conn) 18884c48a829SMike Christie { 18894c48a829SMike Christie if (conn->ping_task && 18904c48a829SMike Christie time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) + 18914c48a829SMike Christie (conn->ping_timeout * HZ), jiffies)) 18924c48a829SMike Christie return 1; 18934c48a829SMike Christie else 18944c48a829SMike Christie return 0; 18954c48a829SMike Christie } 18964c48a829SMike Christie 1897d355e57dSMike Christie static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc) 1898f6d5180cSMike Christie { 1899d355e57dSMike Christie enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED; 190092ed4d69SMike Christie struct iscsi_task *task = NULL, *running_task; 1901f6d5180cSMike Christie struct iscsi_cls_session *cls_session; 1902f6d5180cSMike Christie struct iscsi_session *session; 1903f6d5180cSMike Christie struct iscsi_conn *conn; 190492ed4d69SMike Christie int i; 1905f6d5180cSMike Christie 1906d355e57dSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 190775613521SMike Christie session = cls_session->dd_data; 1908f6d5180cSMike Christie 1909bd2199d4SErez Zilber ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc); 1910f6d5180cSMike Christie 1911f6d5180cSMike Christie spin_lock(&session->lock); 1912f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1913f6d5180cSMike Christie /* 1914f6d5180cSMike Christie * We are probably in the middle of iscsi recovery so let 1915f6d5180cSMike Christie * that complete and handle the error. 1916f6d5180cSMike Christie */ 1917242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1918f6d5180cSMike Christie goto done; 1919f6d5180cSMike Christie } 1920f6d5180cSMike Christie 1921f6d5180cSMike Christie conn = session->leadconn; 1922f6d5180cSMike Christie if (!conn) { 1923f6d5180cSMike Christie /* In the middle of shuting down */ 1924242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1925f6d5180cSMike Christie goto done; 1926f6d5180cSMike Christie } 1927f6d5180cSMike Christie 1928d355e57dSMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 192992ed4d69SMike Christie if (!task) { 193092ed4d69SMike Christie /* 193192ed4d69SMike Christie * Raced with completion. Just reset timer, and let it 193292ed4d69SMike Christie * complete normally 193392ed4d69SMike Christie */ 193492ed4d69SMike Christie rc = BLK_EH_RESET_TIMER; 1935d355e57dSMike Christie goto done; 193692ed4d69SMike Christie } 193792ed4d69SMike Christie 1938d355e57dSMike Christie /* 1939d355e57dSMike Christie * If we have sent (at least queued to the network layer) a pdu or 1940d355e57dSMike Christie * recvd one for the task since the last timeout ask for 1941d355e57dSMike Christie * more time. If on the next timeout we have not made progress 1942d355e57dSMike Christie * we can check if it is the task or connection when we send the 1943d355e57dSMike Christie * nop as a ping. 1944d355e57dSMike Christie */ 194592ed4d69SMike Christie if (time_after(task->last_xfer, task->last_timeout)) { 1946bd2199d4SErez Zilber ISCSI_DBG_EH(session, "Command making progress. Asking " 1947d355e57dSMike Christie "scsi-ml for more time to complete. " 194892ed4d69SMike Christie "Last data xfer at %lu. Last timeout was at " 1949d355e57dSMike Christie "%lu\n.", task->last_xfer, task->last_timeout); 1950d355e57dSMike Christie task->have_checked_conn = false; 1951d355e57dSMike Christie rc = BLK_EH_RESET_TIMER; 1952d355e57dSMike Christie goto done; 1953d355e57dSMike Christie } 1954d355e57dSMike Christie 1955f6d5180cSMike Christie if (!conn->recv_timeout && !conn->ping_timeout) 1956f6d5180cSMike Christie goto done; 1957f6d5180cSMike Christie /* 1958f6d5180cSMike Christie * if the ping timedout then we are in the middle of cleaning up 1959f6d5180cSMike Christie * and can let the iscsi eh handle it 1960f6d5180cSMike Christie */ 19614c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 1962242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 19634c48a829SMike Christie goto done; 19644c48a829SMike Christie } 1965d355e57dSMike Christie 196692ed4d69SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 196792ed4d69SMike Christie running_task = conn->session->cmds[i]; 196892ed4d69SMike Christie if (!running_task->sc || running_task == task || 196992ed4d69SMike Christie running_task->state != ISCSI_TASK_RUNNING) 197092ed4d69SMike Christie continue; 197192ed4d69SMike Christie 197292ed4d69SMike Christie /* 197392ed4d69SMike Christie * Only check if cmds started before this one have made 197492ed4d69SMike Christie * progress, or this could never fail 197592ed4d69SMike Christie */ 197692ed4d69SMike Christie if (time_after(running_task->sc->jiffies_at_alloc, 197792ed4d69SMike Christie task->sc->jiffies_at_alloc)) 197892ed4d69SMike Christie continue; 197992ed4d69SMike Christie 198092ed4d69SMike Christie if (time_after(running_task->last_xfer, task->last_timeout)) { 198192ed4d69SMike Christie /* 198292ed4d69SMike Christie * This task has not made progress, but a task 198392ed4d69SMike Christie * started before us has transferred data since 198492ed4d69SMike Christie * we started/last-checked. We could be queueing 198592ed4d69SMike Christie * too many tasks or the LU is bad. 198692ed4d69SMike Christie * 198792ed4d69SMike Christie * If the device is bad the cmds ahead of us on 198892ed4d69SMike Christie * other devs will complete, and this loop will 198992ed4d69SMike Christie * eventually fail starting the scsi eh. 199092ed4d69SMike Christie */ 199192ed4d69SMike Christie ISCSI_DBG_EH(session, "Command has not made progress " 199292ed4d69SMike Christie "but commands ahead of it have. " 199392ed4d69SMike Christie "Asking scsi-ml for more time to " 199492ed4d69SMike Christie "complete. Our last xfer vs running task " 199592ed4d69SMike Christie "last xfer %lu/%lu. Last check %lu.\n", 199692ed4d69SMike Christie task->last_xfer, running_task->last_xfer, 199792ed4d69SMike Christie task->last_timeout); 199892ed4d69SMike Christie rc = BLK_EH_RESET_TIMER; 199992ed4d69SMike Christie goto done; 200092ed4d69SMike Christie } 200192ed4d69SMike Christie } 200292ed4d69SMike Christie 2003d355e57dSMike Christie /* Assumes nop timeout is shorter than scsi cmd timeout */ 2004d355e57dSMike Christie if (task->have_checked_conn) 2005d355e57dSMike Christie goto done; 2006d355e57dSMike Christie 2007f6d5180cSMike Christie /* 2008d355e57dSMike Christie * Checking the transport already or nop from a cmd timeout still 2009d355e57dSMike Christie * running 2010f6d5180cSMike Christie */ 2011d355e57dSMike Christie if (conn->ping_task) { 2012d355e57dSMike Christie task->have_checked_conn = true; 2013242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 20144c48a829SMike Christie goto done; 20154c48a829SMike Christie } 20164c48a829SMike Christie 2017d355e57dSMike Christie /* Make sure there is a transport check done */ 2018d355e57dSMike Christie iscsi_send_nopout(conn, NULL); 2019d355e57dSMike Christie task->have_checked_conn = true; 2020242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 2021d355e57dSMike Christie 2022f6d5180cSMike Christie done: 2023d355e57dSMike Christie if (task) 2024d355e57dSMike Christie task->last_timeout = jiffies; 2025f6d5180cSMike Christie spin_unlock(&session->lock); 2026bd2199d4SErez Zilber ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ? 2027242f9dcbSJens Axboe "timer reset" : "nh"); 2028f6d5180cSMike Christie return rc; 2029f6d5180cSMike Christie } 2030f6d5180cSMike Christie 2031f6d5180cSMike Christie static void iscsi_check_transport_timeouts(unsigned long data) 2032f6d5180cSMike Christie { 2033f6d5180cSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 2034f6d5180cSMike Christie struct iscsi_session *session = conn->session; 20354cf10435SMike Christie unsigned long recv_timeout, next_timeout = 0, last_recv; 2036f6d5180cSMike Christie 2037f6d5180cSMike Christie spin_lock(&session->lock); 2038f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 2039f6d5180cSMike Christie goto done; 2040f6d5180cSMike Christie 20414cf10435SMike Christie recv_timeout = conn->recv_timeout; 20424cf10435SMike Christie if (!recv_timeout) 2043f6d5180cSMike Christie goto done; 2044f6d5180cSMike Christie 20454cf10435SMike Christie recv_timeout *= HZ; 2046f6d5180cSMike Christie last_recv = conn->last_recv; 20474c48a829SMike Christie 20484c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 2049322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs " 20504c48a829SMike Christie "expired, recv timeout %d, last rx %lu, " 20514c48a829SMike Christie "last ping %lu, now %lu\n", 20524c48a829SMike Christie conn->ping_timeout, conn->recv_timeout, 20534c48a829SMike Christie last_recv, conn->last_ping, jiffies); 2054f6d5180cSMike Christie spin_unlock(&session->lock); 2055f6d5180cSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 2056f6d5180cSMike Christie return; 2057f6d5180cSMike Christie } 2058f6d5180cSMike Christie 20594cf10435SMike Christie if (time_before_eq(last_recv + recv_timeout, jiffies)) { 2060f6d5180cSMike Christie /* send a ping to try to provoke some traffic */ 20611b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Sending nopout as ping\n"); 2062f6d5180cSMike Christie iscsi_send_nopout(conn, NULL); 20634cf10435SMike Christie next_timeout = conn->last_ping + (conn->ping_timeout * HZ); 2064ad294e9cSMike Christie } else 20654cf10435SMike Christie next_timeout = last_recv + recv_timeout; 2066f6d5180cSMike Christie 20671b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout); 2068f6d5180cSMike Christie mod_timer(&conn->transport_timer, next_timeout); 2069f6d5180cSMike Christie done: 2070f6d5180cSMike Christie spin_unlock(&session->lock); 2071f6d5180cSMike Christie } 2072f6d5180cSMike Christie 20739c19a7d0SMike Christie static void iscsi_prep_abort_task_pdu(struct iscsi_task *task, 2074843c0a8aSMike Christie struct iscsi_tm *hdr) 2075843c0a8aSMike Christie { 2076843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2077843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2078843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK; 2079843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 208055bdabdfSAndy Grover hdr->lun = task->lun; 2081577577daSMike Christie hdr->rtt = task->hdr_itt; 2082577577daSMike Christie hdr->refcmdsn = task->cmdsn; 2083843c0a8aSMike Christie } 2084843c0a8aSMike Christie 20857996a778SMike Christie int iscsi_eh_abort(struct scsi_cmnd *sc) 20867996a778SMike Christie { 208775613521SMike Christie struct iscsi_cls_session *cls_session; 208875613521SMike Christie struct iscsi_session *session; 2089f47f2cf5SMike Christie struct iscsi_conn *conn; 20909c19a7d0SMike Christie struct iscsi_task *task; 2091843c0a8aSMike Christie struct iscsi_tm *hdr; 2092843c0a8aSMike Christie int rc, age; 20937996a778SMike Christie 209475613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 209575613521SMike Christie session = cls_session->dd_data; 209675613521SMike Christie 2097bd2199d4SErez Zilber ISCSI_DBG_EH(session, "aborting sc %p\n", sc); 20984421c9ebSMike Christie 20996724add1SMike Christie mutex_lock(&session->eh_mutex); 21006724add1SMike Christie spin_lock_bh(&session->lock); 2101f47f2cf5SMike Christie /* 2102f47f2cf5SMike Christie * if session was ISCSI_STATE_IN_RECOVERY then we may not have 2103f47f2cf5SMike Christie * got the command. 2104f47f2cf5SMike Christie */ 2105f47f2cf5SMike Christie if (!sc->SCp.ptr) { 2106bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc never reached iscsi layer or " 21071b2c7af8SMike Christie "it completed.\n"); 21086724add1SMike Christie spin_unlock_bh(&session->lock); 21096724add1SMike Christie mutex_unlock(&session->eh_mutex); 2110f47f2cf5SMike Christie return SUCCESS; 2111f47f2cf5SMike Christie } 2112f47f2cf5SMike Christie 21137996a778SMike Christie /* 21147996a778SMike Christie * If we are not logged in or we have started a new session 21157996a778SMike Christie * then let the host reset code handle this 21167996a778SMike Christie */ 2117843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN || 2118843c0a8aSMike Christie sc->SCp.phase != session->age) { 2119843c0a8aSMike Christie spin_unlock_bh(&session->lock); 2120843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2121bd2199d4SErez Zilber ISCSI_DBG_EH(session, "failing abort due to dropped " 21224421c9ebSMike Christie "session.\n"); 2123843c0a8aSMike Christie return FAILED; 2124843c0a8aSMike Christie } 2125843c0a8aSMike Christie 2126843c0a8aSMike Christie conn = session->leadconn; 2127843c0a8aSMike Christie conn->eh_abort_cnt++; 2128843c0a8aSMike Christie age = session->age; 2129843c0a8aSMike Christie 21309c19a7d0SMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 2131bd2199d4SErez Zilber ISCSI_DBG_EH(session, "aborting [sc %p itt 0x%x]\n", 21321b2c7af8SMike Christie sc, task->itt); 21337996a778SMike Christie 21349c19a7d0SMike Christie /* task completed before time out */ 21359c19a7d0SMike Christie if (!task->sc) { 2136bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in progress\n"); 213777a23c21SMike Christie goto success; 21387ea8b828SMike Christie } 21397996a778SMike Christie 21409c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) { 2141b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 214277a23c21SMike Christie goto success; 214377a23c21SMike Christie } 21447996a778SMike Christie 2145843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2146843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 21477996a778SMike Christie goto failed; 2148843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 21497996a778SMike Christie 2150843c0a8aSMike Christie hdr = &conn->tmhdr; 21519c19a7d0SMike Christie iscsi_prep_abort_task_pdu(task, hdr); 2152843c0a8aSMike Christie 21539c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) { 2154843c0a8aSMike Christie rc = FAILED; 2155843c0a8aSMike Christie goto failed; 2156843c0a8aSMike Christie } 2157843c0a8aSMike Christie 2158843c0a8aSMike Christie switch (conn->tmf_state) { 2159843c0a8aSMike Christie case TMF_SUCCESS: 21607ea8b828SMike Christie spin_unlock_bh(&session->lock); 2161913e5bf4SMike Christie /* 2162913e5bf4SMike Christie * stop tx side incase the target had sent a abort rsp but 2163913e5bf4SMike Christie * the initiator was still writing out data. 2164913e5bf4SMike Christie */ 21656724add1SMike Christie iscsi_suspend_tx(conn); 21667996a778SMike Christie /* 2167913e5bf4SMike Christie * we do not stop the recv side because targets have been 2168913e5bf4SMike Christie * good and have never sent us a successful tmf response 2169913e5bf4SMike Christie * then sent more data for the cmd. 21707996a778SMike Christie */ 21716187c242SMike Christie spin_lock_bh(&session->lock); 2172b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 2173843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 21745d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 21756187c242SMike Christie spin_unlock_bh(&session->lock); 21766724add1SMike Christie iscsi_start_tx(conn); 217777a23c21SMike Christie goto success_unlocked; 2178843c0a8aSMike Christie case TMF_TIMEDOUT: 2179843c0a8aSMike Christie spin_unlock_bh(&session->lock); 2180df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2181843c0a8aSMike Christie goto failed_unlocked; 2182843c0a8aSMike Christie case TMF_NOT_FOUND: 2183843c0a8aSMike Christie if (!sc->SCp.ptr) { 2184843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 21855d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 21869c19a7d0SMike Christie /* task completed before tmf abort response */ 2187bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in " 2188bd2199d4SErez Zilber "progress\n"); 218977a23c21SMike Christie goto success; 219077a23c21SMike Christie } 219177a23c21SMike Christie /* fall through */ 219277a23c21SMike Christie default: 2193843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2194843c0a8aSMike Christie goto failed; 219577a23c21SMike Christie } 21967996a778SMike Christie 219777a23c21SMike Christie success: 219877a23c21SMike Christie spin_unlock_bh(&session->lock); 219977a23c21SMike Christie success_unlocked: 2200bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n", 22011b2c7af8SMike Christie sc, task->itt); 22026724add1SMike Christie mutex_unlock(&session->eh_mutex); 22037996a778SMike Christie return SUCCESS; 22047996a778SMike Christie 22057996a778SMike Christie failed: 22067996a778SMike Christie spin_unlock_bh(&session->lock); 220777a23c21SMike Christie failed_unlocked: 2208bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc, 22099c19a7d0SMike Christie task ? task->itt : 0); 22106724add1SMike Christie mutex_unlock(&session->eh_mutex); 22117996a778SMike Christie return FAILED; 22127996a778SMike Christie } 22137996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_abort); 22147996a778SMike Christie 2215843c0a8aSMike Christie static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 2216843c0a8aSMike Christie { 2217843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2218843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2219843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK; 2220843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 222155bdabdfSAndy Grover int_to_scsilun(sc->device->lun, &hdr->lun); 2222f6d5180cSMike Christie hdr->rtt = RESERVED_ITT; 2223843c0a8aSMike Christie } 2224843c0a8aSMike Christie 2225843c0a8aSMike Christie int iscsi_eh_device_reset(struct scsi_cmnd *sc) 2226843c0a8aSMike Christie { 222775613521SMike Christie struct iscsi_cls_session *cls_session; 222875613521SMike Christie struct iscsi_session *session; 2229843c0a8aSMike Christie struct iscsi_conn *conn; 2230843c0a8aSMike Christie struct iscsi_tm *hdr; 2231843c0a8aSMike Christie int rc = FAILED; 2232843c0a8aSMike Christie 223375613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 223475613521SMike Christie session = cls_session->dd_data; 223575613521SMike Christie 2236bd2199d4SErez Zilber ISCSI_DBG_EH(session, "LU Reset [sc %p lun %u]\n", sc, sc->device->lun); 2237843c0a8aSMike Christie 2238843c0a8aSMike Christie mutex_lock(&session->eh_mutex); 2239843c0a8aSMike Christie spin_lock_bh(&session->lock); 2240843c0a8aSMike Christie /* 2241843c0a8aSMike Christie * Just check if we are not logged in. We cannot check for 2242843c0a8aSMike Christie * the phase because the reset could come from a ioctl. 2243843c0a8aSMike Christie */ 2244843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 2245843c0a8aSMike Christie goto unlock; 2246843c0a8aSMike Christie conn = session->leadconn; 2247843c0a8aSMike Christie 2248843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2249843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 2250843c0a8aSMike Christie goto unlock; 2251843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 2252843c0a8aSMike Christie 2253843c0a8aSMike Christie hdr = &conn->tmhdr; 2254843c0a8aSMike Christie iscsi_prep_lun_reset_pdu(sc, hdr); 2255843c0a8aSMike Christie 22569c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 2257f6d5180cSMike Christie session->lu_reset_timeout)) { 2258843c0a8aSMike Christie rc = FAILED; 2259843c0a8aSMike Christie goto unlock; 2260843c0a8aSMike Christie } 2261843c0a8aSMike Christie 2262843c0a8aSMike Christie switch (conn->tmf_state) { 2263843c0a8aSMike Christie case TMF_SUCCESS: 2264843c0a8aSMike Christie break; 2265843c0a8aSMike Christie case TMF_TIMEDOUT: 2266843c0a8aSMike Christie spin_unlock_bh(&session->lock); 2267df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2268843c0a8aSMike Christie goto done; 2269843c0a8aSMike Christie default: 2270843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2271843c0a8aSMike Christie goto unlock; 2272843c0a8aSMike Christie } 2273843c0a8aSMike Christie 2274843c0a8aSMike Christie rc = SUCCESS; 2275843c0a8aSMike Christie spin_unlock_bh(&session->lock); 2276843c0a8aSMike Christie 2277843c0a8aSMike Christie iscsi_suspend_tx(conn); 2278913e5bf4SMike Christie 2279a3439148SMike Christie spin_lock_bh(&session->lock); 22805d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 22813bbaaad9SMike Christie fail_scsi_tasks(conn, sc->device->lun, DID_ERROR); 2282843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2283a3439148SMike Christie spin_unlock_bh(&session->lock); 2284843c0a8aSMike Christie 2285843c0a8aSMike Christie iscsi_start_tx(conn); 2286843c0a8aSMike Christie goto done; 2287843c0a8aSMike Christie 2288843c0a8aSMike Christie unlock: 2289843c0a8aSMike Christie spin_unlock_bh(&session->lock); 2290843c0a8aSMike Christie done: 2291bd2199d4SErez Zilber ISCSI_DBG_EH(session, "dev reset result = %s\n", 2292843c0a8aSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 2293843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2294843c0a8aSMike Christie return rc; 2295843c0a8aSMike Christie } 2296843c0a8aSMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_device_reset); 2297843c0a8aSMike Christie 22983fe5ae8bSMike Christie void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) 22993fe5ae8bSMike Christie { 23003fe5ae8bSMike Christie struct iscsi_session *session = cls_session->dd_data; 23013fe5ae8bSMike Christie 23023fe5ae8bSMike Christie spin_lock_bh(&session->lock); 23033fe5ae8bSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 23043fe5ae8bSMike Christie session->state = ISCSI_STATE_RECOVERY_FAILED; 23053fe5ae8bSMike Christie if (session->leadconn) 23063fe5ae8bSMike Christie wake_up(&session->leadconn->ehwait); 23073fe5ae8bSMike Christie } 23083fe5ae8bSMike Christie spin_unlock_bh(&session->lock); 23093fe5ae8bSMike Christie } 23103fe5ae8bSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout); 23113fe5ae8bSMike Christie 23123fe5ae8bSMike Christie /** 23133fe5ae8bSMike Christie * iscsi_eh_session_reset - drop session and attempt relogin 23143fe5ae8bSMike Christie * @sc: scsi command 23153fe5ae8bSMike Christie * 23163fe5ae8bSMike Christie * This function will wait for a relogin, session termination from 23173fe5ae8bSMike Christie * userspace, or a recovery/replacement timeout. 23183fe5ae8bSMike Christie */ 2319309ce156SJayamohan Kallickal int iscsi_eh_session_reset(struct scsi_cmnd *sc) 23203fe5ae8bSMike Christie { 23213fe5ae8bSMike Christie struct iscsi_cls_session *cls_session; 23223fe5ae8bSMike Christie struct iscsi_session *session; 23233fe5ae8bSMike Christie struct iscsi_conn *conn; 23243fe5ae8bSMike Christie 23253fe5ae8bSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 23263fe5ae8bSMike Christie session = cls_session->dd_data; 23273fe5ae8bSMike Christie conn = session->leadconn; 23283fe5ae8bSMike Christie 23293fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 23303fe5ae8bSMike Christie spin_lock_bh(&session->lock); 23313fe5ae8bSMike Christie if (session->state == ISCSI_STATE_TERMINATE) { 23323fe5ae8bSMike Christie failed: 23333fe5ae8bSMike Christie ISCSI_DBG_EH(session, 23343fe5ae8bSMike Christie "failing session reset: Could not log back into " 23353fe5ae8bSMike Christie "%s, %s [age %d]\n", session->targetname, 23363fe5ae8bSMike Christie conn->persistent_address, session->age); 23373fe5ae8bSMike Christie spin_unlock_bh(&session->lock); 23383fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 23393fe5ae8bSMike Christie return FAILED; 23403fe5ae8bSMike Christie } 23413fe5ae8bSMike Christie 23423fe5ae8bSMike Christie spin_unlock_bh(&session->lock); 23433fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 23443fe5ae8bSMike Christie /* 23453fe5ae8bSMike Christie * we drop the lock here but the leadconn cannot be destoyed while 23463fe5ae8bSMike Christie * we are in the scsi eh 23473fe5ae8bSMike Christie */ 2348df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 23493fe5ae8bSMike Christie 23503fe5ae8bSMike Christie ISCSI_DBG_EH(session, "wait for relogin\n"); 23513fe5ae8bSMike Christie wait_event_interruptible(conn->ehwait, 23523fe5ae8bSMike Christie session->state == ISCSI_STATE_TERMINATE || 23533fe5ae8bSMike Christie session->state == ISCSI_STATE_LOGGED_IN || 23543fe5ae8bSMike Christie session->state == ISCSI_STATE_RECOVERY_FAILED); 23553fe5ae8bSMike Christie if (signal_pending(current)) 23563fe5ae8bSMike Christie flush_signals(current); 23573fe5ae8bSMike Christie 23583fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 23593fe5ae8bSMike Christie spin_lock_bh(&session->lock); 23603fe5ae8bSMike Christie if (session->state == ISCSI_STATE_LOGGED_IN) { 23613fe5ae8bSMike Christie ISCSI_DBG_EH(session, 23623fe5ae8bSMike Christie "session reset succeeded for %s,%s\n", 23633fe5ae8bSMike Christie session->targetname, conn->persistent_address); 23643fe5ae8bSMike Christie } else 23653fe5ae8bSMike Christie goto failed; 23663fe5ae8bSMike Christie spin_unlock_bh(&session->lock); 23673fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 23683fe5ae8bSMike Christie return SUCCESS; 23693fe5ae8bSMike Christie } 2370309ce156SJayamohan Kallickal EXPORT_SYMBOL_GPL(iscsi_eh_session_reset); 23713fe5ae8bSMike Christie 23723fe5ae8bSMike Christie static void iscsi_prep_tgt_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 23733fe5ae8bSMike Christie { 23743fe5ae8bSMike Christie memset(hdr, 0, sizeof(*hdr)); 23753fe5ae8bSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 23763fe5ae8bSMike Christie hdr->flags = ISCSI_TM_FUNC_TARGET_WARM_RESET & ISCSI_FLAG_TM_FUNC_MASK; 23773fe5ae8bSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 23783fe5ae8bSMike Christie hdr->rtt = RESERVED_ITT; 23793fe5ae8bSMike Christie } 23803fe5ae8bSMike Christie 23813fe5ae8bSMike Christie /** 23823fe5ae8bSMike Christie * iscsi_eh_target_reset - reset target 23833fe5ae8bSMike Christie * @sc: scsi command 23843fe5ae8bSMike Christie * 2385309ce156SJayamohan Kallickal * This will attempt to send a warm target reset. 23863fe5ae8bSMike Christie */ 23873fe5ae8bSMike Christie int iscsi_eh_target_reset(struct scsi_cmnd *sc) 23883fe5ae8bSMike Christie { 23893fe5ae8bSMike Christie struct iscsi_cls_session *cls_session; 23903fe5ae8bSMike Christie struct iscsi_session *session; 23913fe5ae8bSMike Christie struct iscsi_conn *conn; 23923fe5ae8bSMike Christie struct iscsi_tm *hdr; 23933fe5ae8bSMike Christie int rc = FAILED; 23943fe5ae8bSMike Christie 23953fe5ae8bSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 23963fe5ae8bSMike Christie session = cls_session->dd_data; 23973fe5ae8bSMike Christie 23983fe5ae8bSMike Christie ISCSI_DBG_EH(session, "tgt Reset [sc %p tgt %s]\n", sc, 23993fe5ae8bSMike Christie session->targetname); 24003fe5ae8bSMike Christie 24013fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 24023fe5ae8bSMike Christie spin_lock_bh(&session->lock); 24033fe5ae8bSMike Christie /* 24043fe5ae8bSMike Christie * Just check if we are not logged in. We cannot check for 24053fe5ae8bSMike Christie * the phase because the reset could come from a ioctl. 24063fe5ae8bSMike Christie */ 24073fe5ae8bSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 24083fe5ae8bSMike Christie goto unlock; 24093fe5ae8bSMike Christie conn = session->leadconn; 24103fe5ae8bSMike Christie 24113fe5ae8bSMike Christie /* only have one tmf outstanding at a time */ 24123fe5ae8bSMike Christie if (conn->tmf_state != TMF_INITIAL) 24133fe5ae8bSMike Christie goto unlock; 24143fe5ae8bSMike Christie conn->tmf_state = TMF_QUEUED; 24153fe5ae8bSMike Christie 24163fe5ae8bSMike Christie hdr = &conn->tmhdr; 24173fe5ae8bSMike Christie iscsi_prep_tgt_reset_pdu(sc, hdr); 24183fe5ae8bSMike Christie 24193fe5ae8bSMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 24203fe5ae8bSMike Christie session->tgt_reset_timeout)) { 24213fe5ae8bSMike Christie rc = FAILED; 24223fe5ae8bSMike Christie goto unlock; 24233fe5ae8bSMike Christie } 24243fe5ae8bSMike Christie 24253fe5ae8bSMike Christie switch (conn->tmf_state) { 24263fe5ae8bSMike Christie case TMF_SUCCESS: 24273fe5ae8bSMike Christie break; 24283fe5ae8bSMike Christie case TMF_TIMEDOUT: 24293fe5ae8bSMike Christie spin_unlock_bh(&session->lock); 2430df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 24313fe5ae8bSMike Christie goto done; 24323fe5ae8bSMike Christie default: 24333fe5ae8bSMike Christie conn->tmf_state = TMF_INITIAL; 24343fe5ae8bSMike Christie goto unlock; 24353fe5ae8bSMike Christie } 24363fe5ae8bSMike Christie 24373fe5ae8bSMike Christie rc = SUCCESS; 24383fe5ae8bSMike Christie spin_unlock_bh(&session->lock); 24393fe5ae8bSMike Christie 24403fe5ae8bSMike Christie iscsi_suspend_tx(conn); 24413fe5ae8bSMike Christie 24423fe5ae8bSMike Christie spin_lock_bh(&session->lock); 24433fe5ae8bSMike Christie memset(hdr, 0, sizeof(*hdr)); 24443fe5ae8bSMike Christie fail_scsi_tasks(conn, -1, DID_ERROR); 24453fe5ae8bSMike Christie conn->tmf_state = TMF_INITIAL; 24463fe5ae8bSMike Christie spin_unlock_bh(&session->lock); 24473fe5ae8bSMike Christie 24483fe5ae8bSMike Christie iscsi_start_tx(conn); 24493fe5ae8bSMike Christie goto done; 24503fe5ae8bSMike Christie 24513fe5ae8bSMike Christie unlock: 24523fe5ae8bSMike Christie spin_unlock_bh(&session->lock); 24533fe5ae8bSMike Christie done: 24543fe5ae8bSMike Christie ISCSI_DBG_EH(session, "tgt %s reset result = %s\n", session->targetname, 24553fe5ae8bSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 24563fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 2457309ce156SJayamohan Kallickal return rc; 2458309ce156SJayamohan Kallickal } 2459309ce156SJayamohan Kallickal EXPORT_SYMBOL_GPL(iscsi_eh_target_reset); 24603fe5ae8bSMike Christie 2461309ce156SJayamohan Kallickal /** 2462309ce156SJayamohan Kallickal * iscsi_eh_recover_target - reset target and possibly the session 2463309ce156SJayamohan Kallickal * @sc: scsi command 2464309ce156SJayamohan Kallickal * 2465309ce156SJayamohan Kallickal * This will attempt to send a warm target reset. If that fails, 2466309ce156SJayamohan Kallickal * we will escalate to ERL0 session recovery. 2467309ce156SJayamohan Kallickal */ 2468309ce156SJayamohan Kallickal int iscsi_eh_recover_target(struct scsi_cmnd *sc) 2469309ce156SJayamohan Kallickal { 2470309ce156SJayamohan Kallickal int rc; 2471309ce156SJayamohan Kallickal 2472309ce156SJayamohan Kallickal rc = iscsi_eh_target_reset(sc); 24733fe5ae8bSMike Christie if (rc == FAILED) 24743fe5ae8bSMike Christie rc = iscsi_eh_session_reset(sc); 24753fe5ae8bSMike Christie return rc; 24763fe5ae8bSMike Christie } 2477309ce156SJayamohan Kallickal EXPORT_SYMBOL_GPL(iscsi_eh_recover_target); 24783fe5ae8bSMike Christie 24796320377fSOlaf Kirch /* 24806320377fSOlaf Kirch * Pre-allocate a pool of @max items of @item_size. By default, the pool 24816320377fSOlaf Kirch * should be accessed via kfifo_{get,put} on q->queue. 24826320377fSOlaf Kirch * Optionally, the caller can obtain the array of object pointers 24836320377fSOlaf Kirch * by passing in a non-NULL @items pointer 24846320377fSOlaf Kirch */ 24857996a778SMike Christie int 24866320377fSOlaf Kirch iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size) 24877996a778SMike Christie { 24886320377fSOlaf Kirch int i, num_arrays = 1; 24897996a778SMike Christie 24906320377fSOlaf Kirch memset(q, 0, sizeof(*q)); 24917996a778SMike Christie 24927996a778SMike Christie q->max = max; 24936320377fSOlaf Kirch 24946320377fSOlaf Kirch /* If the user passed an items pointer, he wants a copy of 24956320377fSOlaf Kirch * the array. */ 24966320377fSOlaf Kirch if (items) 24976320377fSOlaf Kirch num_arrays++; 24986320377fSOlaf Kirch q->pool = kzalloc(num_arrays * max * sizeof(void*), GFP_KERNEL); 24996320377fSOlaf Kirch if (q->pool == NULL) 2500f474a37bSJean Delvare return -ENOMEM; 25017996a778SMike Christie 2502c1e13f25SStefani Seibold kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*)); 25037996a778SMike Christie 25047996a778SMike Christie for (i = 0; i < max; i++) { 25056320377fSOlaf Kirch q->pool[i] = kzalloc(item_size, GFP_KERNEL); 25067996a778SMike Christie if (q->pool[i] == NULL) { 25076320377fSOlaf Kirch q->max = i; 25086320377fSOlaf Kirch goto enomem; 25097996a778SMike Christie } 25107acd72ebSStefani Seibold kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*)); 25117996a778SMike Christie } 25126320377fSOlaf Kirch 25136320377fSOlaf Kirch if (items) { 25146320377fSOlaf Kirch *items = q->pool + max; 25156320377fSOlaf Kirch memcpy(*items, q->pool, max * sizeof(void *)); 25166320377fSOlaf Kirch } 25176320377fSOlaf Kirch 25187996a778SMike Christie return 0; 25196320377fSOlaf Kirch 25206320377fSOlaf Kirch enomem: 25216320377fSOlaf Kirch iscsi_pool_free(q); 25226320377fSOlaf Kirch return -ENOMEM; 25237996a778SMike Christie } 25247996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_init); 25257996a778SMike Christie 25266320377fSOlaf Kirch void iscsi_pool_free(struct iscsi_pool *q) 25277996a778SMike Christie { 25287996a778SMike Christie int i; 25297996a778SMike Christie 25307996a778SMike Christie for (i = 0; i < q->max; i++) 25316320377fSOlaf Kirch kfree(q->pool[i]); 25327996a778SMike Christie kfree(q->pool); 25337996a778SMike Christie } 25347996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_free); 25357996a778SMike Christie 2536a4804cd6SMike Christie /** 2537a4804cd6SMike Christie * iscsi_host_add - add host to system 2538a4804cd6SMike Christie * @shost: scsi host 2539a4804cd6SMike Christie * @pdev: parent device 2540a4804cd6SMike Christie * 2541a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers 2542a4804cd6SMike Christie * to add a host to the system. 2543a4804cd6SMike Christie */ 2544a4804cd6SMike Christie int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev) 25457996a778SMike Christie { 25468e9a20ceSMike Christie if (!shost->can_queue) 25478e9a20ceSMike Christie shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX; 25488e9a20ceSMike Christie 25494d108350SMike Christie if (!shost->cmd_per_lun) 25504d108350SMike Christie shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN; 25514d108350SMike Christie 2552308cec14SMike Christie if (!shost->transportt->eh_timed_out) 2553308cec14SMike Christie shost->transportt->eh_timed_out = iscsi_eh_cmd_timed_out; 2554a4804cd6SMike Christie return scsi_add_host(shost, pdev); 2555a4804cd6SMike Christie } 2556a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_add); 2557a4804cd6SMike Christie 2558a4804cd6SMike Christie /** 2559a4804cd6SMike Christie * iscsi_host_alloc - allocate a host and driver data 2560a4804cd6SMike Christie * @sht: scsi host template 2561a4804cd6SMike Christie * @dd_data_size: driver host data size 256232ae763eSMike Christie * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue 2563a4804cd6SMike Christie * 2564a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers. 2565a4804cd6SMike Christie * To access the driver specific memory use the iscsi_host_priv() macro. 2566a4804cd6SMike Christie */ 2567a4804cd6SMike Christie struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht, 25684d108350SMike Christie int dd_data_size, bool xmit_can_sleep) 2569a4804cd6SMike Christie { 2570a4804cd6SMike Christie struct Scsi_Host *shost; 2571e5bd7b54SMike Christie struct iscsi_host *ihost; 2572a4804cd6SMike Christie 2573a4804cd6SMike Christie shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size); 2574a4804cd6SMike Christie if (!shost) 2575a4804cd6SMike Christie return NULL; 2576e5bd7b54SMike Christie ihost = shost_priv(shost); 257732ae763eSMike Christie 257832ae763eSMike Christie if (xmit_can_sleep) { 257932ae763eSMike Christie snprintf(ihost->workq_name, sizeof(ihost->workq_name), 258032ae763eSMike Christie "iscsi_q_%d", shost->host_no); 258132ae763eSMike Christie ihost->workq = create_singlethread_workqueue(ihost->workq_name); 258232ae763eSMike Christie if (!ihost->workq) 258332ae763eSMike Christie goto free_host; 258432ae763eSMike Christie } 258532ae763eSMike Christie 2586e5bd7b54SMike Christie spin_lock_init(&ihost->lock); 2587e5bd7b54SMike Christie ihost->state = ISCSI_HOST_SETUP; 2588e5bd7b54SMike Christie ihost->num_sessions = 0; 2589e5bd7b54SMike Christie init_waitqueue_head(&ihost->session_removal_wq); 2590a4804cd6SMike Christie return shost; 259132ae763eSMike Christie 259232ae763eSMike Christie free_host: 259332ae763eSMike Christie scsi_host_put(shost); 259432ae763eSMike Christie return NULL; 259575613521SMike Christie } 2596a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_alloc); 259775613521SMike Christie 2598e5bd7b54SMike Christie static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session) 2599e5bd7b54SMike Christie { 260040a06e75SMike Christie iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST); 2601e5bd7b54SMike Christie } 2602e5bd7b54SMike Christie 2603a4804cd6SMike Christie /** 2604a4804cd6SMike Christie * iscsi_host_remove - remove host and sessions 2605a4804cd6SMike Christie * @shost: scsi host 2606a4804cd6SMike Christie * 2607e5bd7b54SMike Christie * If there are any sessions left, this will initiate the removal and wait 2608e5bd7b54SMike Christie * for the completion. 2609a4804cd6SMike Christie */ 2610a4804cd6SMike Christie void iscsi_host_remove(struct Scsi_Host *shost) 2611a4804cd6SMike Christie { 2612e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2613e5bd7b54SMike Christie unsigned long flags; 2614e5bd7b54SMike Christie 2615e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2616e5bd7b54SMike Christie ihost->state = ISCSI_HOST_REMOVED; 2617e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2618e5bd7b54SMike Christie 2619e5bd7b54SMike Christie iscsi_host_for_each_session(shost, iscsi_notify_host_removed); 2620e5bd7b54SMike Christie wait_event_interruptible(ihost->session_removal_wq, 2621e5bd7b54SMike Christie ihost->num_sessions == 0); 2622e5bd7b54SMike Christie if (signal_pending(current)) 2623e5bd7b54SMike Christie flush_signals(current); 2624e5bd7b54SMike Christie 2625a4804cd6SMike Christie scsi_remove_host(shost); 262632ae763eSMike Christie if (ihost->workq) 262732ae763eSMike Christie destroy_workqueue(ihost->workq); 2628a4804cd6SMike Christie } 2629a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_remove); 2630a4804cd6SMike Christie 2631a4804cd6SMike Christie void iscsi_host_free(struct Scsi_Host *shost) 263275613521SMike Christie { 263375613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 263475613521SMike Christie 263575613521SMike Christie kfree(ihost->netdev); 263675613521SMike Christie kfree(ihost->hwaddress); 263775613521SMike Christie kfree(ihost->initiatorname); 2638a4804cd6SMike Christie scsi_host_put(shost); 263975613521SMike Christie } 2640a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_free); 264175613521SMike Christie 2642e5bd7b54SMike Christie static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost) 2643e5bd7b54SMike Christie { 2644e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2645e5bd7b54SMike Christie unsigned long flags; 2646e5bd7b54SMike Christie 2647e5bd7b54SMike Christie shost = scsi_host_get(shost); 2648e5bd7b54SMike Christie if (!shost) { 2649e5bd7b54SMike Christie printk(KERN_ERR "Invalid state. Cannot notify host removal " 2650e5bd7b54SMike Christie "of session teardown event because host already " 2651e5bd7b54SMike Christie "removed.\n"); 2652e5bd7b54SMike Christie return; 2653e5bd7b54SMike Christie } 2654e5bd7b54SMike Christie 2655e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2656e5bd7b54SMike Christie ihost->num_sessions--; 2657e5bd7b54SMike Christie if (ihost->num_sessions == 0) 2658e5bd7b54SMike Christie wake_up(&ihost->session_removal_wq); 2659e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2660e5bd7b54SMike Christie scsi_host_put(shost); 2661e5bd7b54SMike Christie } 2662e5bd7b54SMike Christie 266375613521SMike Christie /** 266475613521SMike Christie * iscsi_session_setup - create iscsi cls session and host and session 266575613521SMike Christie * @iscsit: iscsi transport template 266675613521SMike Christie * @shost: scsi host 266775613521SMike Christie * @cmds_max: session can queue 26689c19a7d0SMike Christie * @cmd_task_size: LLD task private data size 266975613521SMike Christie * @initial_cmdsn: initial CmdSN 267075613521SMike Christie * 267175613521SMike Christie * This can be used by software iscsi_transports that allocate 267275613521SMike Christie * a session per scsi host. 26733cf7b233SMike Christie * 26743cf7b233SMike Christie * Callers should set cmds_max to the largest total numer (mgmt + scsi) of 26753cf7b233SMike Christie * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks 26763cf7b233SMike Christie * for nop handling and login/logout requests. 267775613521SMike Christie */ 267875613521SMike Christie struct iscsi_cls_session * 267975613521SMike Christie iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, 2680b8b9e1b8SJayamohan Kallickal uint16_t cmds_max, int dd_size, int cmd_task_size, 26817970634bSMike Christie uint32_t initial_cmdsn, unsigned int id) 268275613521SMike Christie { 2683e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 268475613521SMike Christie struct iscsi_session *session; 268575613521SMike Christie struct iscsi_cls_session *cls_session; 26863cf7b233SMike Christie int cmd_i, scsi_cmds, total_cmds = cmds_max; 2687e5bd7b54SMike Christie unsigned long flags; 2688e5bd7b54SMike Christie 2689e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2690e5bd7b54SMike Christie if (ihost->state == ISCSI_HOST_REMOVED) { 2691e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2692e5bd7b54SMike Christie return NULL; 2693e5bd7b54SMike Christie } 2694e5bd7b54SMike Christie ihost->num_sessions++; 2695e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 26968e9a20ceSMike Christie 26978e9a20ceSMike Christie if (!total_cmds) 26988e9a20ceSMike Christie total_cmds = ISCSI_DEF_XMIT_CMDS_MAX; 26993e5c28adSMike Christie /* 27003cf7b233SMike Christie * The iscsi layer needs some tasks for nop handling and tmfs, 27013cf7b233SMike Christie * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX 27023cf7b233SMike Christie * + 1 command for scsi IO. 27033e5c28adSMike Christie */ 27043cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 27053cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 27063cf7b233SMike Christie "must be a power of two that is at least %d.\n", 27073cf7b233SMike Christie total_cmds, ISCSI_TOTAL_CMDS_MIN); 2708e5bd7b54SMike Christie goto dec_session_count; 27091548271eSMike Christie } 27103cf7b233SMike Christie 27113cf7b233SMike Christie if (total_cmds > ISCSI_TOTAL_CMDS_MAX) { 27123cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 27133cf7b233SMike Christie "must be a power of 2 less than or equal to %d.\n", 27143cf7b233SMike Christie cmds_max, ISCSI_TOTAL_CMDS_MAX); 27153cf7b233SMike Christie total_cmds = ISCSI_TOTAL_CMDS_MAX; 27163cf7b233SMike Christie } 27173cf7b233SMike Christie 27183cf7b233SMike Christie if (!is_power_of_2(total_cmds)) { 27193cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 27203cf7b233SMike Christie "must be a power of 2.\n", total_cmds); 27213cf7b233SMike Christie total_cmds = rounddown_pow_of_two(total_cmds); 27223cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) 27233cf7b233SMike Christie return NULL; 27243cf7b233SMike Christie printk(KERN_INFO "iscsi: Rounding can_queue to %d.\n", 27253cf7b233SMike Christie total_cmds); 27263cf7b233SMike Christie } 27273cf7b233SMike Christie scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX; 27281548271eSMike Christie 27295d91e209SMike Christie cls_session = iscsi_alloc_session(shost, iscsit, 2730b8b9e1b8SJayamohan Kallickal sizeof(struct iscsi_session) + 2731b8b9e1b8SJayamohan Kallickal dd_size); 273275613521SMike Christie if (!cls_session) 2733e5bd7b54SMike Christie goto dec_session_count; 273475613521SMike Christie session = cls_session->dd_data; 273575613521SMike Christie session->cls_session = cls_session; 27367996a778SMike Christie session->host = shost; 27377996a778SMike Christie session->state = ISCSI_STATE_FREE; 2738f6d5180cSMike Christie session->fast_abort = 1; 27393fe5ae8bSMike Christie session->tgt_reset_timeout = 30; 27404cd49ea1SMike Christie session->lu_reset_timeout = 15; 27414cd49ea1SMike Christie session->abort_timeout = 10; 27423cf7b233SMike Christie session->scsi_cmds_max = scsi_cmds; 27433cf7b233SMike Christie session->cmds_max = total_cmds; 2744e0726407SMike Christie session->queued_cmdsn = session->cmdsn = initial_cmdsn; 27457996a778SMike Christie session->exp_cmdsn = initial_cmdsn + 1; 27467996a778SMike Christie session->max_cmdsn = initial_cmdsn + 1; 27477996a778SMike Christie session->max_r2t = 1; 27487996a778SMike Christie session->tt = iscsit; 2749b8b9e1b8SJayamohan Kallickal session->dd_data = cls_session->dd_data + sizeof(*session); 27506724add1SMike Christie mutex_init(&session->eh_mutex); 275175613521SMike Christie spin_lock_init(&session->lock); 27527996a778SMike Christie 27537996a778SMike Christie /* initialize SCSI PDU commands pool */ 27547996a778SMike Christie if (iscsi_pool_init(&session->cmdpool, session->cmds_max, 27557996a778SMike Christie (void***)&session->cmds, 27569c19a7d0SMike Christie cmd_task_size + sizeof(struct iscsi_task))) 27577996a778SMike Christie goto cmdpool_alloc_fail; 27587996a778SMike Christie 27597996a778SMike Christie /* pre-format cmds pool with ITT */ 27607996a778SMike Christie for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) { 27619c19a7d0SMike Christie struct iscsi_task *task = session->cmds[cmd_i]; 27627996a778SMike Christie 27639c19a7d0SMike Christie if (cmd_task_size) 27649c19a7d0SMike Christie task->dd_data = &task[1]; 27659c19a7d0SMike Christie task->itt = cmd_i; 27663bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 27679c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 27687996a778SMike Christie } 27697996a778SMike Christie 2770f53a88daSMike Christie if (!try_module_get(iscsit->owner)) 277175613521SMike Christie goto module_get_fail; 277275613521SMike Christie 27737970634bSMike Christie if (iscsi_add_session(cls_session, id)) 2774f53a88daSMike Christie goto cls_session_fail; 2775e5bd7b54SMike Christie 27767996a778SMike Christie return cls_session; 27777996a778SMike Christie 27787996a778SMike Christie cls_session_fail: 277975613521SMike Christie module_put(iscsit->owner); 278075613521SMike Christie module_get_fail: 27816320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 27827996a778SMike Christie cmdpool_alloc_fail: 278375613521SMike Christie iscsi_free_session(cls_session); 2784e5bd7b54SMike Christie dec_session_count: 2785e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 27867996a778SMike Christie return NULL; 27877996a778SMike Christie } 27887996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_setup); 27897996a778SMike Christie 27907996a778SMike Christie /** 27917996a778SMike Christie * iscsi_session_teardown - destroy session, host, and cls_session 279275613521SMike Christie * @cls_session: iscsi session 27937996a778SMike Christie * 279475613521SMike Christie * The driver must have called iscsi_remove_session before 279575613521SMike Christie * calling this. 279675613521SMike Christie */ 27977996a778SMike Christie void iscsi_session_teardown(struct iscsi_cls_session *cls_session) 27987996a778SMike Christie { 279975613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 280063f75cc8SMike Christie struct module *owner = cls_session->transport->owner; 2801e5bd7b54SMike Christie struct Scsi_Host *shost = session->host; 28027996a778SMike Christie 28036320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 28047996a778SMike Christie 2805b2c64167SMike Christie kfree(session->password); 2806b2c64167SMike Christie kfree(session->password_in); 2807b2c64167SMike Christie kfree(session->username); 2808b2c64167SMike Christie kfree(session->username_in); 2809f3ff0c36SMike Christie kfree(session->targetname); 28103c5c4801SVikas Chaudhary kfree(session->targetalias); 281188dfd340SMike Christie kfree(session->initiatorname); 281288dfd340SMike Christie kfree(session->ifacename); 2813f3ff0c36SMike Christie 281475613521SMike Christie iscsi_destroy_session(cls_session); 2815e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 281663f75cc8SMike Christie module_put(owner); 28177996a778SMike Christie } 28187996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_teardown); 28197996a778SMike Christie 28207996a778SMike Christie /** 28217996a778SMike Christie * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn 28227996a778SMike Christie * @cls_session: iscsi_cls_session 28235d91e209SMike Christie * @dd_size: private driver data size 28247996a778SMike Christie * @conn_idx: cid 28255d91e209SMike Christie */ 28267996a778SMike Christie struct iscsi_cls_conn * 28275d91e209SMike Christie iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, 28285d91e209SMike Christie uint32_t conn_idx) 28297996a778SMike Christie { 283075613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 28317996a778SMike Christie struct iscsi_conn *conn; 28327996a778SMike Christie struct iscsi_cls_conn *cls_conn; 2833d36ab6f3SMike Christie char *data; 28347996a778SMike Christie 28355d91e209SMike Christie cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size, 28365d91e209SMike Christie conn_idx); 28377996a778SMike Christie if (!cls_conn) 28387996a778SMike Christie return NULL; 28397996a778SMike Christie conn = cls_conn->dd_data; 28405d91e209SMike Christie memset(conn, 0, sizeof(*conn) + dd_size); 28417996a778SMike Christie 28425d91e209SMike Christie conn->dd_data = cls_conn->dd_data + sizeof(*conn); 28437996a778SMike Christie conn->session = session; 28447996a778SMike Christie conn->cls_conn = cls_conn; 28457996a778SMike Christie conn->c_stage = ISCSI_CONN_INITIAL_STAGE; 28467996a778SMike Christie conn->id = conn_idx; 28477996a778SMike Christie conn->exp_statsn = 0; 2848843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2849f6d5180cSMike Christie 2850f6d5180cSMike Christie init_timer(&conn->transport_timer); 2851f6d5180cSMike Christie conn->transport_timer.data = (unsigned long)conn; 2852f6d5180cSMike Christie conn->transport_timer.function = iscsi_check_transport_timeouts; 2853f6d5180cSMike Christie 2854843c0a8aSMike Christie INIT_LIST_HEAD(&conn->mgmtqueue); 28553bbaaad9SMike Christie INIT_LIST_HEAD(&conn->cmdqueue); 2856843c0a8aSMike Christie INIT_LIST_HEAD(&conn->requeue); 2857c4028958SDavid Howells INIT_WORK(&conn->xmitwork, iscsi_xmitworker); 28587996a778SMike Christie 28599c19a7d0SMike Christie /* allocate login_task used for the login/text sequences */ 28607996a778SMike Christie spin_lock_bh(&session->lock); 28617acd72ebSStefani Seibold if (!kfifo_out(&session->cmdpool.queue, 28629c19a7d0SMike Christie (void*)&conn->login_task, 28637996a778SMike Christie sizeof(void*))) { 28647996a778SMike Christie spin_unlock_bh(&session->lock); 28659c19a7d0SMike Christie goto login_task_alloc_fail; 28667996a778SMike Christie } 28677996a778SMike Christie spin_unlock_bh(&session->lock); 28687996a778SMike Christie 2869cfeb2cf9SMike Christie data = (char *) __get_free_pages(GFP_KERNEL, 2870cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2871d36ab6f3SMike Christie if (!data) 28729c19a7d0SMike Christie goto login_task_data_alloc_fail; 28739c19a7d0SMike Christie conn->login_task->data = conn->data = data; 2874d36ab6f3SMike Christie 2875843c0a8aSMike Christie init_timer(&conn->tmf_timer); 28767996a778SMike Christie init_waitqueue_head(&conn->ehwait); 28777996a778SMike Christie 28787996a778SMike Christie return cls_conn; 28797996a778SMike Christie 28809c19a7d0SMike Christie login_task_data_alloc_fail: 28817acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 2882d36ab6f3SMike Christie sizeof(void*)); 28839c19a7d0SMike Christie login_task_alloc_fail: 28847996a778SMike Christie iscsi_destroy_conn(cls_conn); 28857996a778SMike Christie return NULL; 28867996a778SMike Christie } 28877996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_setup); 28887996a778SMike Christie 28897996a778SMike Christie /** 28907996a778SMike Christie * iscsi_conn_teardown - teardown iscsi connection 28917996a778SMike Christie * cls_conn: iscsi class connection 28927996a778SMike Christie * 28937996a778SMike Christie * TODO: we may need to make this into a two step process 28947996a778SMike Christie * like scsi-mls remove + put host 28957996a778SMike Christie */ 28967996a778SMike Christie void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) 28977996a778SMike Christie { 28987996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 28997996a778SMike Christie struct iscsi_session *session = conn->session; 29007996a778SMike Christie unsigned long flags; 29017996a778SMike Christie 2902f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 2903f6d5180cSMike Christie 29047996a778SMike Christie spin_lock_bh(&session->lock); 29057996a778SMike Christie conn->c_stage = ISCSI_CONN_CLEANUP_WAIT; 29067996a778SMike Christie if (session->leadconn == conn) { 29077996a778SMike Christie /* 29087996a778SMike Christie * leading connection? then give up on recovery. 29097996a778SMike Christie */ 29107996a778SMike Christie session->state = ISCSI_STATE_TERMINATE; 29117996a778SMike Christie wake_up(&conn->ehwait); 29127996a778SMike Christie } 29137996a778SMike Christie spin_unlock_bh(&session->lock); 29147996a778SMike Christie 29157996a778SMike Christie /* 29167996a778SMike Christie * Block until all in-progress commands for this connection 29177996a778SMike Christie * time out or fail. 29187996a778SMike Christie */ 29197996a778SMike Christie for (;;) { 29207996a778SMike Christie spin_lock_irqsave(session->host->host_lock, flags); 29217996a778SMike Christie if (!session->host->host_busy) { /* OK for ERL == 0 */ 29227996a778SMike Christie spin_unlock_irqrestore(session->host->host_lock, flags); 29237996a778SMike Christie break; 29247996a778SMike Christie } 29257996a778SMike Christie spin_unlock_irqrestore(session->host->host_lock, flags); 29267996a778SMike Christie msleep_interruptible(500); 2927322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "iscsi conn_destroy(): " 2928322d739dSMike Christie "host_busy %d host_failed %d\n", 2929322d739dSMike Christie session->host->host_busy, 2930be2df72eSOr Gerlitz session->host->host_failed); 29317996a778SMike Christie /* 29327996a778SMike Christie * force eh_abort() to unblock 29337996a778SMike Christie */ 29347996a778SMike Christie wake_up(&conn->ehwait); 29357996a778SMike Christie } 29367996a778SMike Christie 2937779ea120SMike Christie /* flush queued up work because we free the connection below */ 2938843c0a8aSMike Christie iscsi_suspend_tx(conn); 2939779ea120SMike Christie 29407996a778SMike Christie spin_lock_bh(&session->lock); 2941cfeb2cf9SMike Christie free_pages((unsigned long) conn->data, 2942cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2943f3ff0c36SMike Christie kfree(conn->persistent_address); 29447acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 29457996a778SMike Christie sizeof(void*)); 2946e0726407SMike Christie if (session->leadconn == conn) 29477996a778SMike Christie session->leadconn = NULL; 29487996a778SMike Christie spin_unlock_bh(&session->lock); 29497996a778SMike Christie 29507996a778SMike Christie iscsi_destroy_conn(cls_conn); 29517996a778SMike Christie } 29527996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_teardown); 29537996a778SMike Christie 29547996a778SMike Christie int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 29557996a778SMike Christie { 29567996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 29577996a778SMike Christie struct iscsi_session *session = conn->session; 29587996a778SMike Christie 2959ffd0436eSMike Christie if (!session) { 2960322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 2961322d739dSMike Christie "can't start unbound connection\n"); 29627996a778SMike Christie return -EPERM; 29637996a778SMike Christie } 29647996a778SMike Christie 2965db98ccdeSMike Christie if ((session->imm_data_en || !session->initial_r2t_en) && 2966db98ccdeSMike Christie session->first_burst > session->max_burst) { 2967322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: " 2968ffd0436eSMike Christie "first_burst %d max_burst %d\n", 2969ffd0436eSMike Christie session->first_burst, session->max_burst); 2970ffd0436eSMike Christie return -EINVAL; 2971ffd0436eSMike Christie } 2972ffd0436eSMike Christie 2973f6d5180cSMike Christie if (conn->ping_timeout && !conn->recv_timeout) { 2974322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of " 2975322d739dSMike Christie "zero. Using 5 seconds\n."); 2976f6d5180cSMike Christie conn->recv_timeout = 5; 2977f6d5180cSMike Christie } 2978f6d5180cSMike Christie 2979f6d5180cSMike Christie if (conn->recv_timeout && !conn->ping_timeout) { 2980322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of " 2981322d739dSMike Christie "zero. Using 5 seconds.\n"); 2982f6d5180cSMike Christie conn->ping_timeout = 5; 2983f6d5180cSMike Christie } 2984f6d5180cSMike Christie 29857996a778SMike Christie spin_lock_bh(&session->lock); 29867996a778SMike Christie conn->c_stage = ISCSI_CONN_STARTED; 29877996a778SMike Christie session->state = ISCSI_STATE_LOGGED_IN; 2988e0726407SMike Christie session->queued_cmdsn = session->cmdsn; 29897996a778SMike Christie 2990f6d5180cSMike Christie conn->last_recv = jiffies; 2991f6d5180cSMike Christie conn->last_ping = jiffies; 2992f6d5180cSMike Christie if (conn->recv_timeout && conn->ping_timeout) 2993f6d5180cSMike Christie mod_timer(&conn->transport_timer, 2994f6d5180cSMike Christie jiffies + (conn->recv_timeout * HZ)); 2995f6d5180cSMike Christie 29967996a778SMike Christie switch(conn->stop_stage) { 29977996a778SMike Christie case STOP_CONN_RECOVER: 29987996a778SMike Christie /* 29997996a778SMike Christie * unblock eh_abort() if it is blocked. re-try all 30007996a778SMike Christie * commands after successful recovery 30017996a778SMike Christie */ 30027996a778SMike Christie conn->stop_stage = 0; 3003843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 30047996a778SMike Christie session->age++; 30058b1d0343SMike Christie if (session->age == 16) 30068b1d0343SMike Christie session->age = 0; 30076eabafbeSMike Christie break; 30087996a778SMike Christie case STOP_CONN_TERM: 30097996a778SMike Christie conn->stop_stage = 0; 30107996a778SMike Christie break; 30117996a778SMike Christie default: 30127996a778SMike Christie break; 30137996a778SMike Christie } 30147996a778SMike Christie spin_unlock_bh(&session->lock); 30157996a778SMike Christie 301675613521SMike Christie iscsi_unblock_session(session->cls_session); 30176eabafbeSMike Christie wake_up(&conn->ehwait); 30187996a778SMike Christie return 0; 30197996a778SMike Christie } 30207996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_start); 30217996a778SMike Christie 30227996a778SMike Christie static void 30233bbaaad9SMike Christie fail_mgmt_tasks(struct iscsi_session *session, struct iscsi_conn *conn) 30247996a778SMike Christie { 30253bbaaad9SMike Christie struct iscsi_task *task; 3026b3cd5050SMike Christie int i, state; 30277996a778SMike Christie 30283bbaaad9SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 30293bbaaad9SMike Christie task = conn->session->cmds[i]; 30303bbaaad9SMike Christie if (task->sc) 30313bbaaad9SMike Christie continue; 30323bbaaad9SMike Christie 30333bbaaad9SMike Christie if (task->state == ISCSI_TASK_FREE) 30343bbaaad9SMike Christie continue; 30353bbaaad9SMike Christie 30363bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, 30373bbaaad9SMike Christie "failing mgmt itt 0x%x state %d\n", 30383bbaaad9SMike Christie task->itt, task->state); 3039b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 3040b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) 3041b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 3042b3cd5050SMike Christie iscsi_complete_task(task, state); 3043b3cd5050SMike Christie 30447996a778SMike Christie } 30457996a778SMike Christie } 30467996a778SMike Christie 3047656cffc9SMike Christie static void iscsi_start_session_recovery(struct iscsi_session *session, 30487996a778SMike Christie struct iscsi_conn *conn, int flag) 30497996a778SMike Christie { 3050ed2abc7fSMike Christie int old_stop_stage; 3051ed2abc7fSMike Christie 30526724add1SMike Christie mutex_lock(&session->eh_mutex); 30537996a778SMike Christie spin_lock_bh(&session->lock); 3054ed2abc7fSMike Christie if (conn->stop_stage == STOP_CONN_TERM) { 30557996a778SMike Christie spin_unlock_bh(&session->lock); 30566724add1SMike Christie mutex_unlock(&session->eh_mutex); 30576724add1SMike Christie return; 30586724add1SMike Christie } 30596724add1SMike Christie 30606724add1SMike Christie /* 3061ed2abc7fSMike Christie * When this is called for the in_login state, we only want to clean 30629c19a7d0SMike Christie * up the login task and connection. We do not need to block and set 306367a61114SMike Christie * the recovery state again 3064ed2abc7fSMike Christie */ 306567a61114SMike Christie if (flag == STOP_CONN_TERM) 306667a61114SMike Christie session->state = ISCSI_STATE_TERMINATE; 306767a61114SMike Christie else if (conn->stop_stage != STOP_CONN_RECOVER) 306867a61114SMike Christie session->state = ISCSI_STATE_IN_RECOVERY; 30694ae0a6c1SMike Christie 30704ae0a6c1SMike Christie old_stop_stage = conn->stop_stage; 30714ae0a6c1SMike Christie conn->stop_stage = flag; 307226013ad4SMike Christie spin_unlock_bh(&session->lock); 3073ed2abc7fSMike Christie 307426013ad4SMike Christie del_timer_sync(&conn->transport_timer); 307526013ad4SMike Christie iscsi_suspend_tx(conn); 307626013ad4SMike Christie 307726013ad4SMike Christie spin_lock_bh(&session->lock); 307867a61114SMike Christie conn->c_stage = ISCSI_CONN_STOPPED; 30797996a778SMike Christie spin_unlock_bh(&session->lock); 30806724add1SMike Christie 30817996a778SMike Christie /* 30827996a778SMike Christie * for connection level recovery we should not calculate 30837996a778SMike Christie * header digest. conn->hdr_size used for optimization 30847996a778SMike Christie * in hdr_extract() and will be re-negotiated at 30857996a778SMike Christie * set_param() time. 30867996a778SMike Christie */ 30877996a778SMike Christie if (flag == STOP_CONN_RECOVER) { 30887996a778SMike Christie conn->hdrdgst_en = 0; 30897996a778SMike Christie conn->datadgst_en = 0; 3090656cffc9SMike Christie if (session->state == ISCSI_STATE_IN_RECOVERY && 309167a61114SMike Christie old_stop_stage != STOP_CONN_RECOVER) { 30921b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "blocking session\n"); 309375613521SMike Christie iscsi_block_session(session->cls_session); 30947996a778SMike Christie } 309567a61114SMike Christie } 3096656cffc9SMike Christie 3097656cffc9SMike Christie /* 3098656cffc9SMike Christie * flush queues. 3099656cffc9SMike Christie */ 3100656cffc9SMike Christie spin_lock_bh(&session->lock); 31013bbaaad9SMike Christie fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED); 31023bbaaad9SMike Christie fail_mgmt_tasks(session, conn); 31035d12c05eSMike Christie memset(&conn->tmhdr, 0, sizeof(conn->tmhdr)); 3104656cffc9SMike Christie spin_unlock_bh(&session->lock); 31056724add1SMike Christie mutex_unlock(&session->eh_mutex); 31067996a778SMike Christie } 31077996a778SMike Christie 31087996a778SMike Christie void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 31097996a778SMike Christie { 31107996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 31117996a778SMike Christie struct iscsi_session *session = conn->session; 31127996a778SMike Christie 31137996a778SMike Christie switch (flag) { 31147996a778SMike Christie case STOP_CONN_RECOVER: 31157996a778SMike Christie case STOP_CONN_TERM: 31167996a778SMike Christie iscsi_start_session_recovery(session, conn, flag); 31178d2860b3SMike Christie break; 31187996a778SMike Christie default: 3119322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 3120322d739dSMike Christie "invalid stop flag %d\n", flag); 31217996a778SMike Christie } 31227996a778SMike Christie } 31237996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_stop); 31247996a778SMike Christie 31257996a778SMike Christie int iscsi_conn_bind(struct iscsi_cls_session *cls_session, 31267996a778SMike Christie struct iscsi_cls_conn *cls_conn, int is_leading) 31277996a778SMike Christie { 312875613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 312998644047SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 31307996a778SMike Christie 31317996a778SMike Christie spin_lock_bh(&session->lock); 31327996a778SMike Christie if (is_leading) 31337996a778SMike Christie session->leadconn = conn; 313498644047SMike Christie spin_unlock_bh(&session->lock); 31357996a778SMike Christie 31367996a778SMike Christie /* 31377996a778SMike Christie * Unblock xmitworker(), Login Phase will pass through. 31387996a778SMike Christie */ 31397996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 31407996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 31417996a778SMike Christie return 0; 31427996a778SMike Christie } 31437996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_bind); 31447996a778SMike Christie 31455700b1afSMike Christie static int iscsi_switch_str_param(char **param, char *new_val_buf) 31465700b1afSMike Christie { 31475700b1afSMike Christie char *new_val; 31485700b1afSMike Christie 31495700b1afSMike Christie if (*param) { 31505700b1afSMike Christie if (!strcmp(*param, new_val_buf)) 31515700b1afSMike Christie return 0; 31525700b1afSMike Christie } 31535700b1afSMike Christie 31545700b1afSMike Christie new_val = kstrdup(new_val_buf, GFP_NOIO); 31555700b1afSMike Christie if (!new_val) 31565700b1afSMike Christie return -ENOMEM; 31575700b1afSMike Christie 31585700b1afSMike Christie kfree(*param); 31595700b1afSMike Christie *param = new_val; 31605700b1afSMike Christie return 0; 31615700b1afSMike Christie } 3162a54a52caSMike Christie 3163a54a52caSMike Christie int iscsi_set_param(struct iscsi_cls_conn *cls_conn, 3164a54a52caSMike Christie enum iscsi_param param, char *buf, int buflen) 3165a54a52caSMike Christie { 3166a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 3167a54a52caSMike Christie struct iscsi_session *session = conn->session; 3168a54a52caSMike Christie 3169a54a52caSMike Christie switch(param) { 3170843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 3171843c0a8aSMike Christie sscanf(buf, "%d", &session->fast_abort); 3172843c0a8aSMike Christie break; 3173f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 3174f6d5180cSMike Christie sscanf(buf, "%d", &session->abort_timeout); 3175f6d5180cSMike Christie break; 3176f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 3177f6d5180cSMike Christie sscanf(buf, "%d", &session->lu_reset_timeout); 3178f6d5180cSMike Christie break; 31793fe5ae8bSMike Christie case ISCSI_PARAM_TGT_RESET_TMO: 31803fe5ae8bSMike Christie sscanf(buf, "%d", &session->tgt_reset_timeout); 31813fe5ae8bSMike Christie break; 3182f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 3183f6d5180cSMike Christie sscanf(buf, "%d", &conn->ping_timeout); 3184f6d5180cSMike Christie break; 3185f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 3186f6d5180cSMike Christie sscanf(buf, "%d", &conn->recv_timeout); 3187f6d5180cSMike Christie break; 3188a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 3189a54a52caSMike Christie sscanf(buf, "%d", &conn->max_recv_dlength); 3190a54a52caSMike Christie break; 3191a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3192a54a52caSMike Christie sscanf(buf, "%d", &conn->max_xmit_dlength); 3193a54a52caSMike Christie break; 3194a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 3195a54a52caSMike Christie sscanf(buf, "%d", &conn->hdrdgst_en); 3196a54a52caSMike Christie break; 3197a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 3198a54a52caSMike Christie sscanf(buf, "%d", &conn->datadgst_en); 3199a54a52caSMike Christie break; 3200a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 3201a54a52caSMike Christie sscanf(buf, "%d", &session->initial_r2t_en); 3202a54a52caSMike Christie break; 3203a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 3204a54a52caSMike Christie sscanf(buf, "%d", &session->max_r2t); 3205a54a52caSMike Christie break; 3206a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 3207a54a52caSMike Christie sscanf(buf, "%d", &session->imm_data_en); 3208a54a52caSMike Christie break; 3209a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 3210a54a52caSMike Christie sscanf(buf, "%d", &session->first_burst); 3211a54a52caSMike Christie break; 3212a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 3213a54a52caSMike Christie sscanf(buf, "%d", &session->max_burst); 3214a54a52caSMike Christie break; 3215a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 3216a54a52caSMike Christie sscanf(buf, "%d", &session->pdu_inorder_en); 3217a54a52caSMike Christie break; 3218a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 3219a54a52caSMike Christie sscanf(buf, "%d", &session->dataseq_inorder_en); 3220a54a52caSMike Christie break; 3221a54a52caSMike Christie case ISCSI_PARAM_ERL: 3222a54a52caSMike Christie sscanf(buf, "%d", &session->erl); 3223a54a52caSMike Christie break; 3224a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 3225a54a52caSMike Christie sscanf(buf, "%u", &conn->exp_statsn); 3226a54a52caSMike Christie break; 3227b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 32285700b1afSMike Christie return iscsi_switch_str_param(&session->username, buf); 3229b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 32305700b1afSMike Christie return iscsi_switch_str_param(&session->username_in, buf); 3231b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 32325700b1afSMike Christie return iscsi_switch_str_param(&session->password, buf); 3233b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 32345700b1afSMike Christie return iscsi_switch_str_param(&session->password_in, buf); 3235a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 32365700b1afSMike Christie return iscsi_switch_str_param(&session->targetname, buf); 32373c5c4801SVikas Chaudhary case ISCSI_PARAM_TARGET_ALIAS: 32383c5c4801SVikas Chaudhary return iscsi_switch_str_param(&session->targetalias, buf); 3239a54a52caSMike Christie case ISCSI_PARAM_TPGT: 3240a54a52caSMike Christie sscanf(buf, "%d", &session->tpgt); 3241a54a52caSMike Christie break; 3242a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3243a54a52caSMike Christie sscanf(buf, "%d", &conn->persistent_port); 3244a54a52caSMike Christie break; 3245a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 32465700b1afSMike Christie return iscsi_switch_str_param(&conn->persistent_address, buf); 324788dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 32485700b1afSMike Christie return iscsi_switch_str_param(&session->ifacename, buf); 324988dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 32505700b1afSMike Christie return iscsi_switch_str_param(&session->initiatorname, buf); 3251a54a52caSMike Christie default: 3252a54a52caSMike Christie return -ENOSYS; 3253a54a52caSMike Christie } 3254a54a52caSMike Christie 3255a54a52caSMike Christie return 0; 3256a54a52caSMike Christie } 3257a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_set_param); 3258a54a52caSMike Christie 3259a54a52caSMike Christie int iscsi_session_get_param(struct iscsi_cls_session *cls_session, 3260a54a52caSMike Christie enum iscsi_param param, char *buf) 3261a54a52caSMike Christie { 326275613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 3263a54a52caSMike Christie int len; 3264a54a52caSMike Christie 3265a54a52caSMike Christie switch(param) { 3266843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 3267843c0a8aSMike Christie len = sprintf(buf, "%d\n", session->fast_abort); 3268843c0a8aSMike Christie break; 3269f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 3270f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->abort_timeout); 3271f6d5180cSMike Christie break; 3272f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 3273f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->lu_reset_timeout); 3274f6d5180cSMike Christie break; 32753fe5ae8bSMike Christie case ISCSI_PARAM_TGT_RESET_TMO: 32763fe5ae8bSMike Christie len = sprintf(buf, "%d\n", session->tgt_reset_timeout); 32773fe5ae8bSMike Christie break; 3278a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 3279a54a52caSMike Christie len = sprintf(buf, "%d\n", session->initial_r2t_en); 3280a54a52caSMike Christie break; 3281a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 3282a54a52caSMike Christie len = sprintf(buf, "%hu\n", session->max_r2t); 3283a54a52caSMike Christie break; 3284a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 3285a54a52caSMike Christie len = sprintf(buf, "%d\n", session->imm_data_en); 3286a54a52caSMike Christie break; 3287a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 3288a54a52caSMike Christie len = sprintf(buf, "%u\n", session->first_burst); 3289a54a52caSMike Christie break; 3290a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 3291a54a52caSMike Christie len = sprintf(buf, "%u\n", session->max_burst); 3292a54a52caSMike Christie break; 3293a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 3294a54a52caSMike Christie len = sprintf(buf, "%d\n", session->pdu_inorder_en); 3295a54a52caSMike Christie break; 3296a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 3297a54a52caSMike Christie len = sprintf(buf, "%d\n", session->dataseq_inorder_en); 3298a54a52caSMike Christie break; 3299a54a52caSMike Christie case ISCSI_PARAM_ERL: 3300a54a52caSMike Christie len = sprintf(buf, "%d\n", session->erl); 3301a54a52caSMike Christie break; 3302a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 3303a54a52caSMike Christie len = sprintf(buf, "%s\n", session->targetname); 3304a54a52caSMike Christie break; 33053c5c4801SVikas Chaudhary case ISCSI_PARAM_TARGET_ALIAS: 33063c5c4801SVikas Chaudhary len = sprintf(buf, "%s\n", session->targetalias); 33073c5c4801SVikas Chaudhary break; 3308a54a52caSMike Christie case ISCSI_PARAM_TPGT: 3309a54a52caSMike Christie len = sprintf(buf, "%d\n", session->tpgt); 3310a54a52caSMike Christie break; 3311b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 3312b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username); 3313b2c64167SMike Christie break; 3314b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 3315b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username_in); 3316b2c64167SMike Christie break; 3317b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 3318b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password); 3319b2c64167SMike Christie break; 3320b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 3321b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password_in); 3322b2c64167SMike Christie break; 332388dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 332488dfd340SMike Christie len = sprintf(buf, "%s\n", session->ifacename); 332588dfd340SMike Christie break; 332688dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 332788dfd340SMike Christie len = sprintf(buf, "%s\n", session->initiatorname); 332888dfd340SMike Christie break; 3329a54a52caSMike Christie default: 3330a54a52caSMike Christie return -ENOSYS; 3331a54a52caSMike Christie } 3332a54a52caSMike Christie 3333a54a52caSMike Christie return len; 3334a54a52caSMike Christie } 3335a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_get_param); 3336a54a52caSMike Christie 333700f3708eSMike Christie int iscsi_conn_get_addr_param(struct sockaddr_storage *addr, 333800f3708eSMike Christie enum iscsi_param param, char *buf) 333900f3708eSMike Christie { 334000f3708eSMike Christie struct sockaddr_in6 *sin6 = NULL; 334100f3708eSMike Christie struct sockaddr_in *sin = NULL; 334200f3708eSMike Christie int len; 334300f3708eSMike Christie 334400f3708eSMike Christie switch (addr->ss_family) { 334500f3708eSMike Christie case AF_INET: 334600f3708eSMike Christie sin = (struct sockaddr_in *)addr; 334700f3708eSMike Christie break; 334800f3708eSMike Christie case AF_INET6: 334900f3708eSMike Christie sin6 = (struct sockaddr_in6 *)addr; 335000f3708eSMike Christie break; 335100f3708eSMike Christie default: 335200f3708eSMike Christie return -EINVAL; 335300f3708eSMike Christie } 335400f3708eSMike Christie 335500f3708eSMike Christie switch (param) { 335600f3708eSMike Christie case ISCSI_PARAM_CONN_ADDRESS: 335700f3708eSMike Christie case ISCSI_HOST_PARAM_IPADDRESS: 335800f3708eSMike Christie if (sin) 335900f3708eSMike Christie len = sprintf(buf, "%pI4\n", &sin->sin_addr.s_addr); 336000f3708eSMike Christie else 336100f3708eSMike Christie len = sprintf(buf, "%pI6\n", &sin6->sin6_addr); 336200f3708eSMike Christie break; 336300f3708eSMike Christie case ISCSI_PARAM_CONN_PORT: 336400f3708eSMike Christie if (sin) 336500f3708eSMike Christie len = sprintf(buf, "%hu\n", be16_to_cpu(sin->sin_port)); 336600f3708eSMike Christie else 336700f3708eSMike Christie len = sprintf(buf, "%hu\n", 336800f3708eSMike Christie be16_to_cpu(sin6->sin6_port)); 336900f3708eSMike Christie break; 337000f3708eSMike Christie default: 337100f3708eSMike Christie return -EINVAL; 337200f3708eSMike Christie } 337300f3708eSMike Christie 337400f3708eSMike Christie return len; 337500f3708eSMike Christie } 337600f3708eSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_addr_param); 337700f3708eSMike Christie 3378a54a52caSMike Christie int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, 3379a54a52caSMike Christie enum iscsi_param param, char *buf) 3380a54a52caSMike Christie { 3381a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 3382a54a52caSMike Christie int len; 3383a54a52caSMike Christie 3384a54a52caSMike Christie switch(param) { 3385f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 3386f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->ping_timeout); 3387f6d5180cSMike Christie break; 3388f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 3389f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->recv_timeout); 3390f6d5180cSMike Christie break; 3391a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 3392a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_recv_dlength); 3393a54a52caSMike Christie break; 3394a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3395a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_xmit_dlength); 3396a54a52caSMike Christie break; 3397a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 3398a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->hdrdgst_en); 3399a54a52caSMike Christie break; 3400a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 3401a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->datadgst_en); 3402a54a52caSMike Christie break; 3403a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 3404a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ifmarker_en); 3405a54a52caSMike Christie break; 3406a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 3407a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ofmarker_en); 3408a54a52caSMike Christie break; 3409a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 3410a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->exp_statsn); 3411a54a52caSMike Christie break; 3412a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3413a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->persistent_port); 3414a54a52caSMike Christie break; 3415a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 3416a54a52caSMike Christie len = sprintf(buf, "%s\n", conn->persistent_address); 3417a54a52caSMike Christie break; 3418a54a52caSMike Christie default: 3419a54a52caSMike Christie return -ENOSYS; 3420a54a52caSMike Christie } 3421a54a52caSMike Christie 3422a54a52caSMike Christie return len; 3423a54a52caSMike Christie } 3424a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_param); 3425a54a52caSMike Christie 34260801c242SMike Christie int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param, 34270801c242SMike Christie char *buf) 34280801c242SMike Christie { 342975613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 34300801c242SMike Christie int len; 34310801c242SMike Christie 34320801c242SMike Christie switch (param) { 3433d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 343475613521SMike Christie len = sprintf(buf, "%s\n", ihost->netdev); 3435d8196ed2SMike Christie break; 34360801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 343775613521SMike Christie len = sprintf(buf, "%s\n", ihost->hwaddress); 34380801c242SMike Christie break; 34398ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 344075613521SMike Christie len = sprintf(buf, "%s\n", ihost->initiatorname); 34418ad5781aSMike Christie break; 34420801c242SMike Christie default: 34430801c242SMike Christie return -ENOSYS; 34440801c242SMike Christie } 34450801c242SMike Christie 34460801c242SMike Christie return len; 34470801c242SMike Christie } 34480801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_param); 34490801c242SMike Christie 34500801c242SMike Christie int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param, 34510801c242SMike Christie char *buf, int buflen) 34520801c242SMike Christie { 345375613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 34540801c242SMike Christie 34550801c242SMike Christie switch (param) { 3456d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 34575700b1afSMike Christie return iscsi_switch_str_param(&ihost->netdev, buf); 34580801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 34595700b1afSMike Christie return iscsi_switch_str_param(&ihost->hwaddress, buf); 34608ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 34615700b1afSMike Christie return iscsi_switch_str_param(&ihost->initiatorname, buf); 34620801c242SMike Christie default: 34630801c242SMike Christie return -ENOSYS; 34640801c242SMike Christie } 34650801c242SMike Christie 34660801c242SMike Christie return 0; 34670801c242SMike Christie } 34680801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_set_param); 34690801c242SMike Christie 34707996a778SMike Christie MODULE_AUTHOR("Mike Christie"); 34717996a778SMike Christie MODULE_DESCRIPTION("iSCSI library functions"); 34727996a778SMike Christie MODULE_LICENSE("GPL"); 3473