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> 293f07c014SIngo Molnar #include <linux/sched/signal.h> 30acf3368fSPaul Gortmaker #include <linux/module.h> 318eb00539SMike Christie #include <asm/unaligned.h> 327996a778SMike Christie #include <net/tcp.h> 337996a778SMike Christie #include <scsi/scsi_cmnd.h> 347996a778SMike Christie #include <scsi/scsi_device.h> 357996a778SMike Christie #include <scsi/scsi_eh.h> 367996a778SMike Christie #include <scsi/scsi_tcq.h> 377996a778SMike Christie #include <scsi/scsi_host.h> 387996a778SMike Christie #include <scsi/scsi.h> 397996a778SMike Christie #include <scsi/iscsi_proto.h> 407996a778SMike Christie #include <scsi/scsi_transport.h> 417996a778SMike Christie #include <scsi/scsi_transport_iscsi.h> 427996a778SMike Christie #include <scsi/libiscsi.h> 437996a778SMike Christie 44bd2199d4SErez Zilber static int iscsi_dbg_lib_conn; 45bd2199d4SErez Zilber module_param_named(debug_libiscsi_conn, iscsi_dbg_lib_conn, int, 46bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 47bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_conn, 48bd2199d4SErez Zilber "Turn on debugging for connections in libiscsi module. " 49bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 50bd2199d4SErez Zilber 51bd2199d4SErez Zilber static int iscsi_dbg_lib_session; 52bd2199d4SErez Zilber module_param_named(debug_libiscsi_session, iscsi_dbg_lib_session, int, 53bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 54bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_session, 55bd2199d4SErez Zilber "Turn on debugging for sessions in libiscsi module. " 56bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 57bd2199d4SErez Zilber 58bd2199d4SErez Zilber static int iscsi_dbg_lib_eh; 59bd2199d4SErez Zilber module_param_named(debug_libiscsi_eh, iscsi_dbg_lib_eh, int, 60bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 61bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_eh, 62bd2199d4SErez Zilber "Turn on debugging for error handling in libiscsi module. " 63bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 641b2c7af8SMike Christie 651b2c7af8SMike Christie #define ISCSI_DBG_CONN(_conn, dbg_fmt, arg...) \ 661b2c7af8SMike Christie do { \ 67bd2199d4SErez Zilber if (iscsi_dbg_lib_conn) \ 681b2c7af8SMike Christie iscsi_conn_printk(KERN_INFO, _conn, \ 691b2c7af8SMike Christie "%s " dbg_fmt, \ 701b2c7af8SMike Christie __func__, ##arg); \ 711b2c7af8SMike Christie } while (0); 721b2c7af8SMike Christie 731b2c7af8SMike Christie #define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...) \ 741b2c7af8SMike Christie do { \ 75bd2199d4SErez Zilber if (iscsi_dbg_lib_session) \ 76bd2199d4SErez Zilber iscsi_session_printk(KERN_INFO, _session, \ 77bd2199d4SErez Zilber "%s " dbg_fmt, \ 78bd2199d4SErez Zilber __func__, ##arg); \ 79bd2199d4SErez Zilber } while (0); 80bd2199d4SErez Zilber 81bd2199d4SErez Zilber #define ISCSI_DBG_EH(_session, dbg_fmt, arg...) \ 82bd2199d4SErez Zilber do { \ 83bd2199d4SErez Zilber if (iscsi_dbg_lib_eh) \ 841b2c7af8SMike Christie iscsi_session_printk(KERN_INFO, _session, \ 851b2c7af8SMike Christie "%s " dbg_fmt, \ 861b2c7af8SMike Christie __func__, ##arg); \ 871b2c7af8SMike Christie } while (0); 881b2c7af8SMike Christie 8932ae763eSMike Christie inline void iscsi_conn_queue_work(struct iscsi_conn *conn) 9032ae763eSMike Christie { 9132ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 9232ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 9332ae763eSMike Christie 941336aed1SMike Christie if (ihost->workq) 9532ae763eSMike Christie queue_work(ihost->workq, &conn->xmitwork); 9632ae763eSMike Christie } 9732ae763eSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_queue_work); 9832ae763eSMike Christie 994c0ba5d2SMike Christie static void __iscsi_update_cmdsn(struct iscsi_session *session, 1004c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 1017996a778SMike Christie { 10277a23c21SMike Christie /* 10377a23c21SMike Christie * standard specifies this check for when to update expected and 10477a23c21SMike Christie * max sequence numbers 10577a23c21SMike Christie */ 10677a23c21SMike Christie if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1)) 10777a23c21SMike Christie return; 10877a23c21SMike Christie 10977a23c21SMike Christie if (exp_cmdsn != session->exp_cmdsn && 11077a23c21SMike Christie !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn)) 1117996a778SMike Christie session->exp_cmdsn = exp_cmdsn; 1127996a778SMike Christie 11377a23c21SMike Christie if (max_cmdsn != session->max_cmdsn && 11446a84c65SMike Christie !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) 11577a23c21SMike Christie session->max_cmdsn = max_cmdsn; 11677a23c21SMike Christie } 1174c0ba5d2SMike Christie 1184c0ba5d2SMike Christie void iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr) 1194c0ba5d2SMike Christie { 1204c0ba5d2SMike Christie __iscsi_update_cmdsn(session, be32_to_cpu(hdr->exp_cmdsn), 1214c0ba5d2SMike Christie be32_to_cpu(hdr->max_cmdsn)); 1224c0ba5d2SMike Christie } 12377a23c21SMike Christie EXPORT_SYMBOL_GPL(iscsi_update_cmdsn); 1247996a778SMike Christie 125577577daSMike Christie /** 126577577daSMike Christie * iscsi_prep_data_out_pdu - initialize Data-Out 127577577daSMike Christie * @task: scsi command task 128577577daSMike Christie * @r2t: R2T info 129577577daSMike Christie * @hdr: iscsi data in pdu 130577577daSMike Christie * 131577577daSMike Christie * Notes: 132577577daSMike Christie * Initialize Data-Out within this R2T sequence and finds 133577577daSMike Christie * proper data_offset within this SCSI command. 134577577daSMike Christie * 135577577daSMike Christie * This function is called with connection lock taken. 136577577daSMike Christie **/ 137577577daSMike Christie void iscsi_prep_data_out_pdu(struct iscsi_task *task, struct iscsi_r2t_info *r2t, 138ffd0436eSMike Christie struct iscsi_data *hdr) 1397996a778SMike Christie { 1409c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 141577577daSMike Christie unsigned int left = r2t->data_length - r2t->sent; 142577577daSMike Christie 143577577daSMike Christie task->hdr_len = sizeof(struct iscsi_data); 1447996a778SMike Christie 1457996a778SMike Christie memset(hdr, 0, sizeof(struct iscsi_data)); 146577577daSMike Christie hdr->ttt = r2t->ttt; 147577577daSMike Christie hdr->datasn = cpu_to_be32(r2t->datasn); 148577577daSMike Christie r2t->datasn++; 1497996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_DATA_OUT; 15055bdabdfSAndy Grover hdr->lun = task->lun; 151577577daSMike Christie hdr->itt = task->hdr_itt; 152577577daSMike Christie hdr->exp_statsn = r2t->exp_statsn; 153577577daSMike Christie hdr->offset = cpu_to_be32(r2t->data_offset + r2t->sent); 154577577daSMike Christie if (left > conn->max_xmit_dlength) { 1557996a778SMike Christie hton24(hdr->dlength, conn->max_xmit_dlength); 156577577daSMike Christie r2t->data_count = conn->max_xmit_dlength; 1577996a778SMike Christie hdr->flags = 0; 1587996a778SMike Christie } else { 159577577daSMike Christie hton24(hdr->dlength, left); 160577577daSMike Christie r2t->data_count = left; 1617996a778SMike Christie hdr->flags = ISCSI_FLAG_CMD_FINAL; 1627996a778SMike Christie } 163577577daSMike Christie conn->dataout_pdus_cnt++; 1647996a778SMike Christie } 165577577daSMike Christie EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu); 1667996a778SMike Christie 1679c19a7d0SMike Christie static int iscsi_add_hdr(struct iscsi_task *task, unsigned len) 168004d6530SBoaz Harrosh { 1699c19a7d0SMike Christie unsigned exp_len = task->hdr_len + len; 170004d6530SBoaz Harrosh 1719c19a7d0SMike Christie if (exp_len > task->hdr_max) { 172004d6530SBoaz Harrosh WARN_ON(1); 173004d6530SBoaz Harrosh return -EINVAL; 174004d6530SBoaz Harrosh } 175004d6530SBoaz Harrosh 176004d6530SBoaz Harrosh WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */ 1779c19a7d0SMike Christie task->hdr_len = exp_len; 178004d6530SBoaz Harrosh return 0; 179004d6530SBoaz Harrosh } 180004d6530SBoaz Harrosh 18138d1c069SBoaz Harrosh /* 18238d1c069SBoaz Harrosh * make an extended cdb AHS 18338d1c069SBoaz Harrosh */ 1849c19a7d0SMike Christie static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) 18538d1c069SBoaz Harrosh { 1869c19a7d0SMike Christie struct scsi_cmnd *cmd = task->sc; 18738d1c069SBoaz Harrosh unsigned rlen, pad_len; 18838d1c069SBoaz Harrosh unsigned short ahslength; 18938d1c069SBoaz Harrosh struct iscsi_ecdb_ahdr *ecdb_ahdr; 19038d1c069SBoaz Harrosh int rc; 19138d1c069SBoaz Harrosh 1929c19a7d0SMike Christie ecdb_ahdr = iscsi_next_hdr(task); 19338d1c069SBoaz Harrosh rlen = cmd->cmd_len - ISCSI_CDB_SIZE; 19438d1c069SBoaz Harrosh 19538d1c069SBoaz Harrosh BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb)); 19638d1c069SBoaz Harrosh ahslength = rlen + sizeof(ecdb_ahdr->reserved); 19738d1c069SBoaz Harrosh 19838d1c069SBoaz Harrosh pad_len = iscsi_padding(rlen); 19938d1c069SBoaz Harrosh 2009c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) + 20138d1c069SBoaz Harrosh sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len); 20238d1c069SBoaz Harrosh if (rc) 20338d1c069SBoaz Harrosh return rc; 20438d1c069SBoaz Harrosh 20538d1c069SBoaz Harrosh if (pad_len) 20638d1c069SBoaz Harrosh memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len); 20738d1c069SBoaz Harrosh 20838d1c069SBoaz Harrosh ecdb_ahdr->ahslength = cpu_to_be16(ahslength); 20938d1c069SBoaz Harrosh ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB; 21038d1c069SBoaz Harrosh ecdb_ahdr->reserved = 0; 21138d1c069SBoaz Harrosh memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen); 21238d1c069SBoaz Harrosh 2131b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2141b2c7af8SMike Christie "iscsi_prep_ecdb_ahs: varlen_cdb_len %d " 2151b2c7af8SMike Christie "rlen %d pad_len %d ahs_length %d iscsi_headers_size " 2161b2c7af8SMike Christie "%u\n", cmd->cmd_len, rlen, pad_len, ahslength, 2171b2c7af8SMike Christie task->hdr_len); 21838d1c069SBoaz Harrosh return 0; 21938d1c069SBoaz Harrosh } 22038d1c069SBoaz Harrosh 2219c19a7d0SMike Christie static int iscsi_prep_bidi_ahs(struct iscsi_task *task) 222c07d4444SBoaz Harrosh { 2239c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 224c07d4444SBoaz Harrosh struct iscsi_rlength_ahdr *rlen_ahdr; 225c07d4444SBoaz Harrosh int rc; 226c07d4444SBoaz Harrosh 2279c19a7d0SMike Christie rlen_ahdr = iscsi_next_hdr(task); 2289c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*rlen_ahdr)); 229c07d4444SBoaz Harrosh if (rc) 230c07d4444SBoaz Harrosh return rc; 231c07d4444SBoaz Harrosh 232c07d4444SBoaz Harrosh rlen_ahdr->ahslength = 233c07d4444SBoaz Harrosh cpu_to_be16(sizeof(rlen_ahdr->read_length) + 234c07d4444SBoaz Harrosh sizeof(rlen_ahdr->reserved)); 235c07d4444SBoaz Harrosh rlen_ahdr->ahstype = ISCSI_AHSTYPE_RLENGTH; 236c07d4444SBoaz Harrosh rlen_ahdr->reserved = 0; 237c07d4444SBoaz Harrosh rlen_ahdr->read_length = cpu_to_be32(scsi_in(sc)->length); 238c07d4444SBoaz Harrosh 2391b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2401b2c7af8SMike Christie "bidi-in rlen_ahdr->read_length(%d) " 241c07d4444SBoaz Harrosh "rlen_ahdr->ahslength(%d)\n", 242c07d4444SBoaz Harrosh be32_to_cpu(rlen_ahdr->read_length), 243c07d4444SBoaz Harrosh be16_to_cpu(rlen_ahdr->ahslength)); 244c07d4444SBoaz Harrosh return 0; 245c07d4444SBoaz Harrosh } 246c07d4444SBoaz Harrosh 2477996a778SMike Christie /** 2485d12c05eSMike Christie * iscsi_check_tmf_restrictions - check if a task is affected by TMF 2495d12c05eSMike Christie * @task: iscsi task 2505d12c05eSMike Christie * @opcode: opcode to check for 2515d12c05eSMike Christie * 2525d12c05eSMike Christie * During TMF a task has to be checked if it's affected. 2535d12c05eSMike Christie * All unrelated I/O can be passed through, but I/O to the 2545d12c05eSMike Christie * affected LUN should be restricted. 2555d12c05eSMike Christie * If 'fast_abort' is set we won't be sending any I/O to the 2565d12c05eSMike Christie * affected LUN. 2575d12c05eSMike Christie * Otherwise the target is waiting for all TTTs to be completed, 2585d12c05eSMike Christie * so we have to send all outstanding Data-Out PDUs to the target. 2595d12c05eSMike Christie */ 2605d12c05eSMike Christie static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode) 2615d12c05eSMike Christie { 2625d12c05eSMike Christie struct iscsi_conn *conn = task->conn; 2635d12c05eSMike Christie struct iscsi_tm *tmf = &conn->tmhdr; 2649cb78c16SHannes Reinecke u64 hdr_lun; 2655d12c05eSMike Christie 2665d12c05eSMike Christie if (conn->tmf_state == TMF_INITIAL) 2675d12c05eSMike Christie return 0; 2685d12c05eSMike Christie 2695d12c05eSMike Christie if ((tmf->opcode & ISCSI_OPCODE_MASK) != ISCSI_OP_SCSI_TMFUNC) 2705d12c05eSMike Christie return 0; 2715d12c05eSMike Christie 2725d12c05eSMike Christie switch (ISCSI_TM_FUNC_VALUE(tmf)) { 2735d12c05eSMike Christie case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET: 2745d12c05eSMike Christie /* 2755d12c05eSMike Christie * Allow PDUs for unrelated LUNs 2765d12c05eSMike Christie */ 27755bdabdfSAndy Grover hdr_lun = scsilun_to_int(&tmf->lun); 2785d12c05eSMike Christie if (hdr_lun != task->sc->device->lun) 2795d12c05eSMike Christie return 0; 2803fe5ae8bSMike Christie /* fall through */ 2813fe5ae8bSMike Christie case ISCSI_TM_FUNC_TARGET_WARM_RESET: 2825d12c05eSMike Christie /* 2835d12c05eSMike Christie * Fail all SCSI cmd PDUs 2845d12c05eSMike Christie */ 2855d12c05eSMike Christie if (opcode != ISCSI_OP_SCSI_DATA_OUT) { 2865d12c05eSMike Christie iscsi_conn_printk(KERN_INFO, conn, 2875d12c05eSMike Christie "task [op %x/%x itt " 2883fe5ae8bSMike Christie "0x%x/0x%x] " 2895d12c05eSMike Christie "rejected.\n", 2905d12c05eSMike Christie task->hdr->opcode, opcode, 2913fe5ae8bSMike Christie task->itt, task->hdr_itt); 2925d12c05eSMike Christie return -EACCES; 2935d12c05eSMike Christie } 2945d12c05eSMike Christie /* 2955d12c05eSMike Christie * And also all data-out PDUs in response to R2T 2965d12c05eSMike Christie * if fast_abort is set. 2975d12c05eSMike Christie */ 2985d12c05eSMike Christie if (conn->session->fast_abort) { 2995d12c05eSMike Christie iscsi_conn_printk(KERN_INFO, conn, 3005d12c05eSMike Christie "task [op %x/%x itt " 3013fe5ae8bSMike Christie "0x%x/0x%x] fast abort.\n", 3025d12c05eSMike Christie task->hdr->opcode, opcode, 3033fe5ae8bSMike Christie task->itt, task->hdr_itt); 3045d12c05eSMike Christie return -EACCES; 3055d12c05eSMike Christie } 3065d12c05eSMike Christie break; 3075d12c05eSMike Christie case ISCSI_TM_FUNC_ABORT_TASK: 3085d12c05eSMike Christie /* 3095d12c05eSMike Christie * the caller has already checked if the task 3105d12c05eSMike Christie * they want to abort was in the pending queue so if 3115d12c05eSMike Christie * we are here the cmd pdu has gone out already, and 3125d12c05eSMike Christie * we will only hit this for data-outs 3135d12c05eSMike Christie */ 3145d12c05eSMike Christie if (opcode == ISCSI_OP_SCSI_DATA_OUT && 3155d12c05eSMike Christie task->hdr_itt == tmf->rtt) { 3165d12c05eSMike Christie ISCSI_DBG_SESSION(conn->session, 3175d12c05eSMike Christie "Preventing task %x/%x from sending " 3185d12c05eSMike Christie "data-out due to abort task in " 3195d12c05eSMike Christie "progress\n", task->itt, 3205d12c05eSMike Christie task->hdr_itt); 3215d12c05eSMike Christie return -EACCES; 3225d12c05eSMike Christie } 3235d12c05eSMike Christie break; 3245d12c05eSMike Christie } 3255d12c05eSMike Christie 3265d12c05eSMike Christie return 0; 3275d12c05eSMike Christie } 3285d12c05eSMike Christie 3295d12c05eSMike Christie /** 3307996a778SMike Christie * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu 3319c19a7d0SMike Christie * @task: iscsi task 3327996a778SMike Christie * 3337996a778SMike Christie * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set 3347996a778SMike Christie * fields like dlength or final based on how much data it sends 3357996a778SMike Christie */ 3369c19a7d0SMike Christie static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task) 3377996a778SMike Christie { 3389c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 3397996a778SMike Christie struct iscsi_session *session = conn->session; 3409c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 34112352183SNicholas Bellinger struct iscsi_scsi_req *hdr; 342d77e6535SSagi Grimberg unsigned hdrlength, cmd_len, transfer_length; 343262ef636SMike Christie itt_t itt; 344004d6530SBoaz Harrosh int rc; 3457996a778SMike Christie 3465d12c05eSMike Christie rc = iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_CMD); 3475d12c05eSMike Christie if (rc) 3485d12c05eSMike Christie return rc; 3495d12c05eSMike Christie 350184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 3512ff79d52SMike Christie rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD); 352577577daSMike Christie if (rc) 353577577daSMike Christie return rc; 354184b57c6SMike Christie } 35512352183SNicholas Bellinger hdr = (struct iscsi_scsi_req *)task->hdr; 356262ef636SMike Christie itt = hdr->itt; 357577577daSMike Christie memset(hdr, 0, sizeof(*hdr)); 358577577daSMike Christie 3592ff79d52SMike Christie if (session->tt->parse_pdu_itt) 3602ff79d52SMike Christie hdr->itt = task->hdr_itt = itt; 3612ff79d52SMike Christie else 3622ff79d52SMike Christie hdr->itt = task->hdr_itt = build_itt(task->itt, 3632ff79d52SMike Christie task->conn->session->age); 3649c19a7d0SMike Christie task->hdr_len = 0; 3659c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*hdr)); 366004d6530SBoaz Harrosh if (rc) 367004d6530SBoaz Harrosh return rc; 3687996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_CMD; 3697996a778SMike Christie hdr->flags = ISCSI_ATTR_SIMPLE; 37055bdabdfSAndy Grover int_to_scsilun(sc->device->lun, &hdr->lun); 37155bdabdfSAndy Grover task->lun = hdr->lun; 3727996a778SMike Christie hdr->exp_statsn = cpu_to_be32(conn->exp_statsn); 37338d1c069SBoaz Harrosh cmd_len = sc->cmd_len; 37438d1c069SBoaz Harrosh if (cmd_len < ISCSI_CDB_SIZE) 37538d1c069SBoaz Harrosh memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len); 37638d1c069SBoaz Harrosh else if (cmd_len > ISCSI_CDB_SIZE) { 3779c19a7d0SMike Christie rc = iscsi_prep_ecdb_ahs(task); 37838d1c069SBoaz Harrosh if (rc) 37938d1c069SBoaz Harrosh return rc; 38038d1c069SBoaz Harrosh cmd_len = ISCSI_CDB_SIZE; 38138d1c069SBoaz Harrosh } 38238d1c069SBoaz Harrosh memcpy(hdr->cdb, sc->cmnd, cmd_len); 3837996a778SMike Christie 3849c19a7d0SMike Christie task->imm_count = 0; 385c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc)) { 386c07d4444SBoaz Harrosh hdr->flags |= ISCSI_FLAG_CMD_READ; 3879c19a7d0SMike Christie rc = iscsi_prep_bidi_ahs(task); 388c07d4444SBoaz Harrosh if (rc) 389c07d4444SBoaz Harrosh return rc; 390c07d4444SBoaz Harrosh } 39155e51edaSSagi Grimberg 39255e51edaSSagi Grimberg if (scsi_get_prot_op(sc) != SCSI_PROT_NORMAL) 39355e51edaSSagi Grimberg task->protected = true; 39455e51edaSSagi Grimberg 395d77e6535SSagi Grimberg transfer_length = scsi_transfer_length(sc); 396d77e6535SSagi Grimberg hdr->data_length = cpu_to_be32(transfer_length); 3977996a778SMike Christie if (sc->sc_data_direction == DMA_TO_DEVICE) { 398577577daSMike Christie struct iscsi_r2t_info *r2t = &task->unsol_r2t; 399577577daSMike Christie 4007996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_WRITE; 4017996a778SMike Christie /* 4027996a778SMike Christie * Write counters: 4037996a778SMike Christie * 4047996a778SMike Christie * imm_count bytes to be sent right after 4057996a778SMike Christie * SCSI PDU Header 4067996a778SMike Christie * 4077996a778SMike Christie * unsol_count bytes(as Data-Out) to be sent 4087996a778SMike Christie * without R2T ack right after 4097996a778SMike Christie * immediate data 4107996a778SMike Christie * 411577577daSMike Christie * r2t data_length bytes to be sent via R2T ack's 4127996a778SMike Christie * 4137996a778SMike Christie * pad_count bytes to be sent as zero-padding 4147996a778SMike Christie */ 415577577daSMike Christie memset(r2t, 0, sizeof(*r2t)); 4167996a778SMike Christie 4177996a778SMike Christie if (session->imm_data_en) { 418d77e6535SSagi Grimberg if (transfer_length >= session->first_burst) 4199c19a7d0SMike Christie task->imm_count = min(session->first_burst, 4207996a778SMike Christie conn->max_xmit_dlength); 4217996a778SMike Christie else 422d77e6535SSagi Grimberg task->imm_count = min(transfer_length, 4237996a778SMike Christie conn->max_xmit_dlength); 4249c19a7d0SMike Christie hton24(hdr->dlength, task->imm_count); 4257996a778SMike Christie } else 426a8ac6311SOlaf Kirch zero_data(hdr->dlength); 4277996a778SMike Christie 428ffd0436eSMike Christie if (!session->initial_r2t_en) { 429d77e6535SSagi Grimberg r2t->data_length = min(session->first_burst, 430d77e6535SSagi Grimberg transfer_length) - 431577577daSMike Christie task->imm_count; 432577577daSMike Christie r2t->data_offset = task->imm_count; 433577577daSMike Christie r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG); 434577577daSMike Christie r2t->exp_statsn = cpu_to_be32(conn->exp_statsn); 435ffd0436eSMike Christie } 436ffd0436eSMike Christie 437577577daSMike Christie if (!task->unsol_r2t.data_length) 4387996a778SMike Christie /* No unsolicit Data-Out's */ 439a8ac6311SOlaf Kirch hdr->flags |= ISCSI_FLAG_CMD_FINAL; 4407996a778SMike Christie } else { 4417996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 4427996a778SMike Christie zero_data(hdr->dlength); 4437996a778SMike Christie 4447996a778SMike Christie if (sc->sc_data_direction == DMA_FROM_DEVICE) 4457996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_READ; 4467996a778SMike Christie } 4477996a778SMike Christie 448004d6530SBoaz Harrosh /* calculate size of additional header segments (AHSs) */ 4499c19a7d0SMike Christie hdrlength = task->hdr_len - sizeof(*hdr); 450004d6530SBoaz Harrosh 451004d6530SBoaz Harrosh WARN_ON(hdrlength & (ISCSI_PAD_LEN-1)); 452004d6530SBoaz Harrosh hdrlength /= ISCSI_PAD_LEN; 453004d6530SBoaz Harrosh 454004d6530SBoaz Harrosh WARN_ON(hdrlength >= 256); 455004d6530SBoaz Harrosh hdr->hlength = hdrlength & 0xFF; 45696b1f96dSMike Christie hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn); 457004d6530SBoaz Harrosh 458577577daSMike Christie if (session->tt->init_task && session->tt->init_task(task)) 459052d0144SMike Christie return -EIO; 460052d0144SMike Christie 4619c19a7d0SMike Christie task->state = ISCSI_TASK_RUNNING; 462d3305f34SMike Christie session->cmdsn++; 46377a23c21SMike Christie 464a8ac6311SOlaf Kirch conn->scsicmd_pdus_cnt++; 4651b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi prep [%s cid %d sc %p cdb 0x%x " 4661b2c7af8SMike Christie "itt 0x%x len %d bidi_len %d cmdsn %d win %d]\n", 4671b2c7af8SMike Christie scsi_bidi_cmnd(sc) ? "bidirectional" : 4681b2c7af8SMike Christie sc->sc_data_direction == DMA_TO_DEVICE ? 4691b2c7af8SMike Christie "write" : "read", conn->id, sc, sc->cmnd[0], 470d77e6535SSagi Grimberg task->itt, transfer_length, 4713e5c28adSMike Christie scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0, 4721b2c7af8SMike Christie session->cmdsn, 4731b2c7af8SMike Christie session->max_cmdsn - session->exp_cmdsn + 1); 474004d6530SBoaz Harrosh return 0; 4757996a778SMike Christie } 4767996a778SMike Christie 4777996a778SMike Christie /** 4783bbaaad9SMike Christie * iscsi_free_task - free a task 4799c19a7d0SMike Christie * @task: iscsi cmd task 4807996a778SMike Christie * 481659743b0SShlomo Pongratz * Must be called with session back_lock. 4823e5c28adSMike Christie * This function returns the scsi command to scsi-ml or cleans 4833e5c28adSMike Christie * up mgmt tasks then returns the task to the pool. 4847996a778SMike Christie */ 4853bbaaad9SMike Christie static void iscsi_free_task(struct iscsi_task *task) 4867996a778SMike Christie { 4879c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 488c1635cb7SMike Christie struct iscsi_session *session = conn->session; 4899c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 490f41d4721SMike Christie int oldstate = task->state; 4917996a778SMike Christie 4924421c9ebSMike Christie ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n", 4934421c9ebSMike Christie task->itt, task->state, task->sc); 4944421c9ebSMike Christie 495577577daSMike Christie session->tt->cleanup_task(task); 4963bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 4979c19a7d0SMike Christie task->sc = NULL; 4983e5c28adSMike Christie /* 4999c19a7d0SMike Christie * login task is preallocated so do not free 5003e5c28adSMike Christie */ 5019c19a7d0SMike Christie if (conn->login_task == task) 5023e5c28adSMike Christie return; 5033e5c28adSMike Christie 5047acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&task, sizeof(void*)); 5053e5c28adSMike Christie 5063e5c28adSMike Christie if (sc) { 507f47f2cf5SMike Christie /* SCSI eh reuses commands to verify us */ 508f47f2cf5SMike Christie sc->SCp.ptr = NULL; 5093e5c28adSMike Christie /* 510f41d4721SMike Christie * queue command may call this to free the task, so 511f41d4721SMike Christie * it will decide how to return sc to scsi-ml. 5123e5c28adSMike Christie */ 513f41d4721SMike Christie if (oldstate != ISCSI_TASK_REQUEUE_SCSIQ) 5147996a778SMike Christie sc->scsi_done(sc); 5157996a778SMike Christie } 5163e5c28adSMike Christie } 5177996a778SMike Christie 518913e5bf4SMike Christie void __iscsi_get_task(struct iscsi_task *task) 51960ecebf5SMike Christie { 5206dc618cdSElena Reshetova refcount_inc(&task->refcount); 52160ecebf5SMike Christie } 522913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_get_task); 52360ecebf5SMike Christie 5248eea2f55SEddie Wai void __iscsi_put_task(struct iscsi_task *task) 52560ecebf5SMike Christie { 5266dc618cdSElena Reshetova if (refcount_dec_and_test(&task->refcount)) 5273bbaaad9SMike Christie iscsi_free_task(task); 52860ecebf5SMike Christie } 5298eea2f55SEddie Wai EXPORT_SYMBOL_GPL(__iscsi_put_task); 53060ecebf5SMike Christie 5319c19a7d0SMike Christie void iscsi_put_task(struct iscsi_task *task) 5323e5c28adSMike Christie { 5339c19a7d0SMike Christie struct iscsi_session *session = task->conn->session; 5343e5c28adSMike Christie 535659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 536659743b0SShlomo Pongratz spin_lock_bh(&session->back_lock); 5379c19a7d0SMike Christie __iscsi_put_task(task); 538659743b0SShlomo Pongratz spin_unlock_bh(&session->back_lock); 5393e5c28adSMike Christie } 5409c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_put_task); 5413e5c28adSMike Christie 5423bbaaad9SMike Christie /** 5433bbaaad9SMike Christie * iscsi_complete_task - finish a task 5443bbaaad9SMike Christie * @task: iscsi cmd task 545b3cd5050SMike Christie * @state: state to complete task with 5463bbaaad9SMike Christie * 547659743b0SShlomo Pongratz * Must be called with session back_lock. 548b3a7ea8dSMike Christie */ 549b3cd5050SMike Christie static void iscsi_complete_task(struct iscsi_task *task, int state) 550b3a7ea8dSMike Christie { 5513bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 5523bbaaad9SMike Christie 5534421c9ebSMike Christie ISCSI_DBG_SESSION(conn->session, 5544421c9ebSMike Christie "complete task itt 0x%x state %d sc %p\n", 5554421c9ebSMike Christie task->itt, task->state, task->sc); 556b3cd5050SMike Christie if (task->state == ISCSI_TASK_COMPLETED || 557b3cd5050SMike Christie task->state == ISCSI_TASK_ABRT_TMF || 558f41d4721SMike Christie task->state == ISCSI_TASK_ABRT_SESS_RECOV || 559f41d4721SMike Christie task->state == ISCSI_TASK_REQUEUE_SCSIQ) 5603bbaaad9SMike Christie return; 5613bbaaad9SMike Christie WARN_ON_ONCE(task->state == ISCSI_TASK_FREE); 562b3cd5050SMike Christie task->state = state; 5633bbaaad9SMike Christie 5646f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 5656f8830f5SChris Leech if (!list_empty(&task->running)) { 5666f8830f5SChris Leech pr_debug_once("%s while task on list", __func__); 5673bbaaad9SMike Christie list_del_init(&task->running); 5686f8830f5SChris Leech } 5696f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 5703bbaaad9SMike Christie 5713bbaaad9SMike Christie if (conn->task == task) 5723bbaaad9SMike Christie conn->task = NULL; 5733bbaaad9SMike Christie 5743bbaaad9SMike Christie if (conn->ping_task == task) 5753bbaaad9SMike Christie conn->ping_task = NULL; 5763bbaaad9SMike Christie 5773bbaaad9SMike Christie /* release get from queueing */ 5783bbaaad9SMike Christie __iscsi_put_task(task); 5793bbaaad9SMike Christie } 5803bbaaad9SMike Christie 5814c0ba5d2SMike Christie /** 5824c0ba5d2SMike Christie * iscsi_complete_scsi_task - finish scsi task normally 5834c0ba5d2SMike Christie * @task: iscsi task for scsi cmd 5844c0ba5d2SMike Christie * @exp_cmdsn: expected cmd sn in cpu format 5854c0ba5d2SMike Christie * @max_cmdsn: max cmd sn in cpu format 5864c0ba5d2SMike Christie * 5874c0ba5d2SMike Christie * This is used when drivers do not need or cannot perform 5884c0ba5d2SMike Christie * lower level pdu processing. 5894c0ba5d2SMike Christie * 590659743b0SShlomo Pongratz * Called with session back_lock 5914c0ba5d2SMike Christie */ 5924c0ba5d2SMike Christie void iscsi_complete_scsi_task(struct iscsi_task *task, 5934c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 5944c0ba5d2SMike Christie { 5954c0ba5d2SMike Christie struct iscsi_conn *conn = task->conn; 5964c0ba5d2SMike Christie 5974c0ba5d2SMike Christie ISCSI_DBG_SESSION(conn->session, "[itt 0x%x]\n", task->itt); 5984c0ba5d2SMike Christie 5994c0ba5d2SMike Christie conn->last_recv = jiffies; 6004c0ba5d2SMike Christie __iscsi_update_cmdsn(conn->session, exp_cmdsn, max_cmdsn); 6014c0ba5d2SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 6024c0ba5d2SMike Christie } 6034c0ba5d2SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_scsi_task); 6044c0ba5d2SMike Christie 6054c0ba5d2SMike Christie 6063bbaaad9SMike Christie /* 607659743b0SShlomo Pongratz * session back_lock must be held and if not called for a task that is 6083bbaaad9SMike Christie * still pending or from the xmit thread, then xmit thread must 6093bbaaad9SMike Christie * be suspended. 6103bbaaad9SMike Christie */ 6113bbaaad9SMike Christie static void fail_scsi_task(struct iscsi_task *task, int err) 6123bbaaad9SMike Christie { 6133bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 614b3a7ea8dSMike Christie struct scsi_cmnd *sc; 615b3cd5050SMike Christie int state; 616b3a7ea8dSMike Christie 6173bbaaad9SMike Christie /* 6183bbaaad9SMike Christie * if a command completes and we get a successful tmf response 6193bbaaad9SMike Christie * we will hit this because the scsi eh abort code does not take 6203bbaaad9SMike Christie * a ref to the task. 6213bbaaad9SMike Christie */ 6229c19a7d0SMike Christie sc = task->sc; 623b3a7ea8dSMike Christie if (!sc) 624b3a7ea8dSMike Christie return; 625b3a7ea8dSMike Christie 626b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) { 627b3a7ea8dSMike Christie /* 628b3a7ea8dSMike Christie * cmd never made it to the xmit thread, so we should not count 629b3a7ea8dSMike Christie * the cmd in the sequencing 630b3a7ea8dSMike Christie */ 631b3a7ea8dSMike Christie conn->session->queued_cmdsn--; 632b3cd5050SMike Christie /* it was never sent so just complete like normal */ 633b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 634b3cd5050SMike Christie } else if (err == DID_TRANSPORT_DISRUPTED) 635b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 636b3cd5050SMike Christie else 637b3cd5050SMike Christie state = ISCSI_TASK_ABRT_TMF; 638b3a7ea8dSMike Christie 639b3cd5050SMike Christie sc->result = err << 16; 640c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 641b3a7ea8dSMike Christie scsi_set_resid(sc, scsi_bufflen(sc)); 642c07d4444SBoaz Harrosh else { 643c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 644c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 645c07d4444SBoaz Harrosh } 6463e5c28adSMike Christie 647659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 648659743b0SShlomo Pongratz spin_lock_bh(&conn->session->back_lock); 649b3cd5050SMike Christie iscsi_complete_task(task, state); 650659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->back_lock); 651b3a7ea8dSMike Christie } 652b3a7ea8dSMike Christie 6533e5c28adSMike Christie static int iscsi_prep_mgmt_task(struct iscsi_conn *conn, 6549c19a7d0SMike Christie struct iscsi_task *task) 655052d0144SMike Christie { 656052d0144SMike Christie struct iscsi_session *session = conn->session; 657577577daSMike Christie struct iscsi_hdr *hdr = task->hdr; 658052d0144SMike Christie struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr; 6594f704dc0SMike Christie uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 660052d0144SMike Christie 661052d0144SMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 662052d0144SMike Christie return -ENOTCONN; 663052d0144SMike Christie 6644f704dc0SMike Christie if (opcode != ISCSI_OP_LOGIN && opcode != ISCSI_OP_TEXT) 665052d0144SMike Christie nop->exp_statsn = cpu_to_be32(conn->exp_statsn); 666052d0144SMike Christie /* 667052d0144SMike Christie * pre-format CmdSN for outgoing PDU. 668052d0144SMike Christie */ 669052d0144SMike Christie nop->cmdsn = cpu_to_be32(session->cmdsn); 670052d0144SMike Christie if (hdr->itt != RESERVED_ITT) { 671052d0144SMike Christie /* 6724f704dc0SMike Christie * TODO: We always use immediate for normal session pdus. 673052d0144SMike Christie * If we start to send tmfs or nops as non-immediate then 674052d0144SMike Christie * we should start checking the cmdsn numbers for mgmt tasks. 6754f704dc0SMike Christie * 6764f704dc0SMike Christie * During discovery sessions iscsid sends TEXT as non immediate, 6774f704dc0SMike Christie * but we always only send one PDU at a time. 678052d0144SMike Christie */ 679052d0144SMike Christie if (conn->c_stage == ISCSI_CONN_STARTED && 680052d0144SMike Christie !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 681052d0144SMike Christie session->queued_cmdsn++; 682052d0144SMike Christie session->cmdsn++; 683052d0144SMike Christie } 684052d0144SMike Christie } 685052d0144SMike Christie 686ae15f801SMike Christie if (session->tt->init_task && session->tt->init_task(task)) 687ae15f801SMike Christie return -EIO; 688052d0144SMike Christie 689052d0144SMike Christie if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT) 690052d0144SMike Christie session->state = ISCSI_STATE_LOGGING_OUT; 691052d0144SMike Christie 692577577daSMike Christie task->state = ISCSI_TASK_RUNNING; 6931b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "mgmtpdu [op 0x%x hdr->itt 0x%x " 6941b2c7af8SMike Christie "datalen %d]\n", hdr->opcode & ISCSI_OPCODE_MASK, 6951b2c7af8SMike Christie hdr->itt, task->data_count); 696052d0144SMike Christie return 0; 697052d0144SMike Christie } 698052d0144SMike Christie 6999c19a7d0SMike Christie static struct iscsi_task * 700f6d5180cSMike Christie __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 701f6d5180cSMike Christie char *data, uint32_t data_size) 702f6d5180cSMike Christie { 703f6d5180cSMike Christie struct iscsi_session *session = conn->session; 7041336aed1SMike Christie struct iscsi_host *ihost = shost_priv(session->host); 7054f704dc0SMike Christie uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 7069c19a7d0SMike Christie struct iscsi_task *task; 707262ef636SMike Christie itt_t itt; 708f6d5180cSMike Christie 709f6d5180cSMike Christie if (session->state == ISCSI_STATE_TERMINATE) 710f6d5180cSMike Christie return NULL; 711f6d5180cSMike Christie 7124f704dc0SMike Christie if (opcode == ISCSI_OP_LOGIN || opcode == ISCSI_OP_TEXT) { 713f6d5180cSMike Christie /* 714f6d5180cSMike Christie * Login and Text are sent serially, in 715f6d5180cSMike Christie * request-followed-by-response sequence. 7163e5c28adSMike Christie * Same task can be used. Same ITT must be used. 7173e5c28adSMike Christie * Note that login_task is preallocated at conn_create(). 718f6d5180cSMike Christie */ 7194f704dc0SMike Christie if (conn->login_task->state != ISCSI_TASK_FREE) { 7204f704dc0SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Login/Text in " 7214f704dc0SMike Christie "progress. Cannot start new task.\n"); 7224f704dc0SMike Christie return NULL; 7234f704dc0SMike Christie } 7244f704dc0SMike Christie 725cbaa4221SMike Christie if (data_size > ISCSI_DEF_MAX_RECV_SEG_LEN) { 726cbaa4221SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Invalid buffer len of %u for login task. Max len is %u\n", data_size, ISCSI_DEF_MAX_RECV_SEG_LEN); 727cbaa4221SMike Christie return NULL; 728cbaa4221SMike Christie } 729cbaa4221SMike Christie 7309c19a7d0SMike Christie task = conn->login_task; 7314f704dc0SMike Christie } else { 73226013ad4SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 73326013ad4SMike Christie return NULL; 73426013ad4SMike Christie 735cbaa4221SMike Christie if (data_size != 0) { 736cbaa4221SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Can not send data buffer of len %u for op 0x%x\n", data_size, opcode); 737cbaa4221SMike Christie return NULL; 738cbaa4221SMike Christie } 739cbaa4221SMike Christie 740f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE); 741f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED); 742f6d5180cSMike Christie 7437acd72ebSStefani Seibold if (!kfifo_out(&session->cmdpool.queue, 7449c19a7d0SMike Christie (void*)&task, sizeof(void*))) 745f6d5180cSMike Christie return NULL; 746f6d5180cSMike Christie } 7473e5c28adSMike Christie /* 7483e5c28adSMike Christie * released in complete pdu for task we expect a response for, and 7493e5c28adSMike Christie * released by the lld when it has transmitted the task for 7503e5c28adSMike Christie * pdus we do not expect a response for. 7513e5c28adSMike Christie */ 7526dc618cdSElena Reshetova refcount_set(&task->refcount, 1); 7539c19a7d0SMike Christie task->conn = conn; 7549c19a7d0SMike Christie task->sc = NULL; 7553bbaaad9SMike Christie INIT_LIST_HEAD(&task->running); 7563bbaaad9SMike Christie task->state = ISCSI_TASK_PENDING; 757f6d5180cSMike Christie 758f6d5180cSMike Christie if (data_size) { 7599c19a7d0SMike Christie memcpy(task->data, data, data_size); 7609c19a7d0SMike Christie task->data_count = data_size; 761f6d5180cSMike Christie } else 7629c19a7d0SMike Christie task->data_count = 0; 763f6d5180cSMike Christie 764184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 7652ff79d52SMike Christie if (conn->session->tt->alloc_pdu(task, hdr->opcode)) { 766577577daSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not allocate " 767577577daSMike Christie "pdu for mgmt task.\n"); 7683bbaaad9SMike Christie goto free_task; 769577577daSMike Christie } 770184b57c6SMike Christie } 771184b57c6SMike Christie 772262ef636SMike Christie itt = task->hdr->itt; 773577577daSMike Christie task->hdr_len = sizeof(struct iscsi_hdr); 7749c19a7d0SMike Christie memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr)); 775262ef636SMike Christie 776262ef636SMike Christie if (hdr->itt != RESERVED_ITT) { 777262ef636SMike Christie if (session->tt->parse_pdu_itt) 778262ef636SMike Christie task->hdr->itt = itt; 779262ef636SMike Christie else 780262ef636SMike Christie task->hdr->itt = build_itt(task->itt, 781262ef636SMike Christie task->conn->session->age); 782262ef636SMike Christie } 783262ef636SMike Christie 7841336aed1SMike Christie if (!ihost->workq) { 785577577daSMike Christie if (iscsi_prep_mgmt_task(conn, task)) 786577577daSMike Christie goto free_task; 787052d0144SMike Christie 7889c19a7d0SMike Christie if (session->tt->xmit_task(task)) 789577577daSMike Christie goto free_task; 7903bbaaad9SMike Christie } else { 7916f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 7923bbaaad9SMike Christie list_add_tail(&task->running, &conn->mgmtqueue); 7936f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 79432ae763eSMike Christie iscsi_conn_queue_work(conn); 7953bbaaad9SMike Christie } 796052d0144SMike Christie 7979c19a7d0SMike Christie return task; 798577577daSMike Christie 799577577daSMike Christie free_task: 800659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 8014fa50799SJitendra Bhivare spin_lock(&session->back_lock); 802577577daSMike Christie __iscsi_put_task(task); 8034fa50799SJitendra Bhivare spin_unlock(&session->back_lock); 804577577daSMike Christie return NULL; 805f6d5180cSMike Christie } 806f6d5180cSMike Christie 807f6d5180cSMike Christie int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr, 808f6d5180cSMike Christie char *data, uint32_t data_size) 809f6d5180cSMike Christie { 810f6d5180cSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 811f6d5180cSMike Christie struct iscsi_session *session = conn->session; 812f6d5180cSMike Christie int err = 0; 813f6d5180cSMike Christie 814659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 815f6d5180cSMike Christie if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size)) 816f6d5180cSMike Christie err = -EPERM; 817659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 818f6d5180cSMike Christie return err; 819f6d5180cSMike Christie } 820f6d5180cSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu); 821f6d5180cSMike Christie 8227996a778SMike Christie /** 8237996a778SMike Christie * iscsi_cmd_rsp - SCSI Command Response processing 8247996a778SMike Christie * @conn: iscsi connection 8257996a778SMike Christie * @hdr: iscsi header 8269c19a7d0SMike Christie * @task: scsi command task 8277996a778SMike Christie * @data: cmd data buffer 8287996a778SMike Christie * @datalen: len of buffer 8297996a778SMike Christie * 8307996a778SMike Christie * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and 8319c19a7d0SMike Christie * then completes the command and task. 8327996a778SMike Christie **/ 83377a23c21SMike Christie static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 8349c19a7d0SMike Christie struct iscsi_task *task, char *data, 8357996a778SMike Christie int datalen) 8367996a778SMike Christie { 83712352183SNicholas Bellinger struct iscsi_scsi_rsp *rhdr = (struct iscsi_scsi_rsp *)hdr; 8387996a778SMike Christie struct iscsi_session *session = conn->session; 8399c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 8407996a778SMike Christie 84177a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr); 8427996a778SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 8437996a778SMike Christie 8447996a778SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 8457996a778SMike Christie 84655e51edaSSagi Grimberg if (task->protected) { 84755e51edaSSagi Grimberg sector_t sector; 84855e51edaSSagi Grimberg u8 ascq; 84955e51edaSSagi Grimberg 85055e51edaSSagi Grimberg /** 85155e51edaSSagi Grimberg * Transports that didn't implement check_protection 85255e51edaSSagi Grimberg * callback but still published T10-PI support to scsi-mid 85355e51edaSSagi Grimberg * deserve this BUG_ON. 85455e51edaSSagi Grimberg **/ 85555e51edaSSagi Grimberg BUG_ON(!session->tt->check_protection); 85655e51edaSSagi Grimberg 85755e51edaSSagi Grimberg ascq = session->tt->check_protection(task, §or); 85855e51edaSSagi Grimberg if (ascq) { 85955e51edaSSagi Grimberg sc->result = DRIVER_SENSE << 24 | 86055e51edaSSagi Grimberg SAM_STAT_CHECK_CONDITION; 86155e51edaSSagi Grimberg scsi_build_sense_buffer(1, sc->sense_buffer, 86255e51edaSSagi Grimberg ILLEGAL_REQUEST, 0x10, ascq); 863a73c2a2fSSagi Grimberg scsi_set_sense_information(sc->sense_buffer, 864a73c2a2fSSagi Grimberg SCSI_SENSE_BUFFERSIZE, 865a73c2a2fSSagi Grimberg sector); 86655e51edaSSagi Grimberg goto out; 86755e51edaSSagi Grimberg } 86855e51edaSSagi Grimberg } 86955e51edaSSagi Grimberg 8707996a778SMike Christie if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) { 8717996a778SMike Christie sc->result = DID_ERROR << 16; 8727996a778SMike Christie goto out; 8737996a778SMike Christie } 8747996a778SMike Christie 8757996a778SMike Christie if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) { 8769b80cb4bSMike Christie uint16_t senselen; 8777996a778SMike Christie 8787996a778SMike Christie if (datalen < 2) { 8797996a778SMike Christie invalid_datalen: 880322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 881322d739dSMike Christie "Got CHECK_CONDITION but invalid data " 882322d739dSMike Christie "buffer size of %d\n", datalen); 8837996a778SMike Christie sc->result = DID_BAD_TARGET << 16; 8847996a778SMike Christie goto out; 8857996a778SMike Christie } 8867996a778SMike Christie 8878f333991SHarvey Harrison senselen = get_unaligned_be16(data); 8887996a778SMike Christie if (datalen < senselen) 8897996a778SMike Christie goto invalid_datalen; 8907996a778SMike Christie 8917996a778SMike Christie memcpy(sc->sense_buffer, data + 2, 8929b80cb4bSMike Christie min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 8931b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n", 8941b2c7af8SMike Christie min_t(uint16_t, senselen, 8951b2c7af8SMike Christie SCSI_SENSE_BUFFERSIZE)); 8967996a778SMike Christie } 8977996a778SMike Christie 898c07d4444SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW | 899c07d4444SBoaz Harrosh ISCSI_FLAG_CMD_BIDI_OVERFLOW)) { 900c07d4444SBoaz Harrosh int res_count = be32_to_cpu(rhdr->bi_residual_count); 901c07d4444SBoaz Harrosh 902c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc) && res_count > 0 && 903c07d4444SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_BIDI_OVERFLOW || 904c07d4444SBoaz Harrosh res_count <= scsi_in(sc)->length)) 905c07d4444SBoaz Harrosh scsi_in(sc)->resid = res_count; 906c07d4444SBoaz Harrosh else 907c07d4444SBoaz Harrosh sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 908c07d4444SBoaz Harrosh } 909c07d4444SBoaz Harrosh 9107207fea4SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW | 9117207fea4SBoaz Harrosh ISCSI_FLAG_CMD_OVERFLOW)) { 9127996a778SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 9137996a778SMike Christie 9147207fea4SBoaz Harrosh if (res_count > 0 && 9157207fea4SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 9167207fea4SBoaz Harrosh res_count <= scsi_bufflen(sc))) 917c07d4444SBoaz Harrosh /* write side for bidi or uni-io set_resid */ 9181c138991SFUJITA Tomonori scsi_set_resid(sc, res_count); 9197996a778SMike Christie else 9207996a778SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 921c07d4444SBoaz Harrosh } 9227996a778SMike Christie out: 9233bbaaad9SMike Christie ISCSI_DBG_SESSION(session, "cmd rsp done [sc %p res %d itt 0x%x]\n", 9241b2c7af8SMike Christie sc, sc->result, task->itt); 9257996a778SMike Christie conn->scsirsp_pdus_cnt++; 926b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 9277996a778SMike Christie } 9287996a778SMike Christie 9291d9edf02SMike Christie /** 9301d9edf02SMike Christie * iscsi_data_in_rsp - SCSI Data-In Response processing 9311d9edf02SMike Christie * @conn: iscsi connection 9321d9edf02SMike Christie * @hdr: iscsi pdu 9331d9edf02SMike Christie * @task: scsi command task 9341d9edf02SMike Christie **/ 9351d9edf02SMike Christie static void 9361d9edf02SMike Christie iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 9371d9edf02SMike Christie struct iscsi_task *task) 9381d9edf02SMike Christie { 9391d9edf02SMike Christie struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr; 9401d9edf02SMike Christie struct scsi_cmnd *sc = task->sc; 9411d9edf02SMike Christie 9421d9edf02SMike Christie if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS)) 9431d9edf02SMike Christie return; 9441d9edf02SMike Christie 945edbc9aa0SMike Christie iscsi_update_cmdsn(conn->session, (struct iscsi_nopin *)hdr); 9461d9edf02SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 9471d9edf02SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 9481d9edf02SMike Christie if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW | 9491d9edf02SMike Christie ISCSI_FLAG_DATA_OVERFLOW)) { 9501d9edf02SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 9511d9edf02SMike Christie 9521d9edf02SMike Christie if (res_count > 0 && 9531d9edf02SMike Christie (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 9541d9edf02SMike Christie res_count <= scsi_in(sc)->length)) 9551d9edf02SMike Christie scsi_in(sc)->resid = res_count; 9561d9edf02SMike Christie else 9571d9edf02SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 9581d9edf02SMike Christie } 9591d9edf02SMike Christie 9603bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, "data in with status done " 9613bbaaad9SMike Christie "[sc %p res %d itt 0x%x]\n", 9623bbaaad9SMike Christie sc, sc->result, task->itt); 9631d9edf02SMike Christie conn->scsirsp_pdus_cnt++; 964b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 9651d9edf02SMike Christie } 9661d9edf02SMike Christie 9677ea8b828SMike Christie static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) 9687ea8b828SMike Christie { 9697ea8b828SMike Christie struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; 9707ea8b828SMike Christie 9717ea8b828SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 9727ea8b828SMike Christie conn->tmfrsp_pdus_cnt++; 9737ea8b828SMike Christie 974843c0a8aSMike Christie if (conn->tmf_state != TMF_QUEUED) 9757ea8b828SMike Christie return; 9767ea8b828SMike Christie 9777ea8b828SMike Christie if (tmf->response == ISCSI_TMF_RSP_COMPLETE) 978843c0a8aSMike Christie conn->tmf_state = TMF_SUCCESS; 9797ea8b828SMike Christie else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) 980843c0a8aSMike Christie conn->tmf_state = TMF_NOT_FOUND; 9817ea8b828SMike Christie else 982843c0a8aSMike Christie conn->tmf_state = TMF_FAILED; 9837ea8b828SMike Christie wake_up(&conn->ehwait); 9847ea8b828SMike Christie } 9857ea8b828SMike Christie 98652f5664aSAriel Nahum static int iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) 987f6d5180cSMike Christie { 988f6d5180cSMike Christie struct iscsi_nopout hdr; 9899c19a7d0SMike Christie struct iscsi_task *task; 990f6d5180cSMike Christie 9919c19a7d0SMike Christie if (!rhdr && conn->ping_task) 99252f5664aSAriel Nahum return -EINVAL; 993f6d5180cSMike Christie 994f6d5180cSMike Christie memset(&hdr, 0, sizeof(struct iscsi_nopout)); 995f6d5180cSMike Christie hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE; 996f6d5180cSMike Christie hdr.flags = ISCSI_FLAG_CMD_FINAL; 997f6d5180cSMike Christie 998f6d5180cSMike Christie if (rhdr) { 99955bdabdfSAndy Grover hdr.lun = rhdr->lun; 1000f6d5180cSMike Christie hdr.ttt = rhdr->ttt; 1001f6d5180cSMike Christie hdr.itt = RESERVED_ITT; 1002f6d5180cSMike Christie } else 1003f6d5180cSMike Christie hdr.ttt = RESERVED_ITT; 1004f6d5180cSMike Christie 10059c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0); 100652f5664aSAriel Nahum if (!task) { 1007322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n"); 100852f5664aSAriel Nahum return -EIO; 100952f5664aSAriel Nahum } else if (!rhdr) { 1010d3acf022SMike Christie /* only track our nops */ 1011d3acf022SMike Christie conn->ping_task = task; 1012d3acf022SMike Christie conn->last_ping = jiffies; 1013d3acf022SMike Christie } 101452f5664aSAriel Nahum 101552f5664aSAriel Nahum return 0; 1016f6d5180cSMike Christie } 1017f6d5180cSMike Christie 10188afa1439SMike Christie static int iscsi_nop_out_rsp(struct iscsi_task *task, 10198afa1439SMike Christie struct iscsi_nopin *nop, char *data, int datalen) 10208afa1439SMike Christie { 10218afa1439SMike Christie struct iscsi_conn *conn = task->conn; 10228afa1439SMike Christie int rc = 0; 10238afa1439SMike Christie 10248afa1439SMike Christie if (conn->ping_task != task) { 10258afa1439SMike Christie /* 10268afa1439SMike Christie * If this is not in response to one of our 10278afa1439SMike Christie * nops then it must be from userspace. 10288afa1439SMike Christie */ 10298afa1439SMike Christie if (iscsi_recv_pdu(conn->cls_conn, (struct iscsi_hdr *)nop, 10308afa1439SMike Christie data, datalen)) 10318afa1439SMike Christie rc = ISCSI_ERR_CONN_FAILED; 10328afa1439SMike Christie } else 10338afa1439SMike Christie mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout); 10348afa1439SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 10358afa1439SMike Christie return rc; 10368afa1439SMike Christie } 10378afa1439SMike Christie 103862f38300SMike Christie static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 103962f38300SMike Christie char *data, int datalen) 104062f38300SMike Christie { 104162f38300SMike Christie struct iscsi_reject *reject = (struct iscsi_reject *)hdr; 104262f38300SMike Christie struct iscsi_hdr rejected_pdu; 10438afa1439SMike Christie int opcode, rc = 0; 104462f38300SMike Christie 104562f38300SMike Christie conn->exp_statsn = be32_to_cpu(reject->statsn) + 1; 104662f38300SMike Christie 10478afa1439SMike Christie if (ntoh24(reject->dlength) > datalen || 10488afa1439SMike Christie ntoh24(reject->dlength) < sizeof(struct iscsi_hdr)) { 10498afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Cannot handle rejected " 10508afa1439SMike Christie "pdu. Invalid data length (pdu dlength " 10518afa1439SMike Christie "%u, datalen %d\n", ntoh24(reject->dlength), 10528afa1439SMike Christie datalen); 105362f38300SMike Christie return ISCSI_ERR_PROTO; 10548afa1439SMike Christie } 105562f38300SMike Christie memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr)); 10568afa1439SMike Christie opcode = rejected_pdu.opcode & ISCSI_OPCODE_MASK; 10578afa1439SMike Christie 10588afa1439SMike Christie switch (reject->reason) { 10598afa1439SMike Christie case ISCSI_REASON_DATA_DIGEST_ERROR: 1060322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 10618afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected " 1062262ef636SMike Christie "due to DataDigest error.\n", 1063e5dbbe27SVaughan Cao opcode, rejected_pdu.itt); 10648afa1439SMike Christie break; 10658afa1439SMike Christie case ISCSI_REASON_IMM_CMD_REJECT: 10668afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 10678afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Too many " 10688afa1439SMike Christie "immediate commands.\n", 1069e5dbbe27SVaughan Cao opcode, rejected_pdu.itt); 10708afa1439SMike Christie /* 10718afa1439SMike Christie * We only send one TMF at a time so if the target could not 10728afa1439SMike Christie * handle it, then it should get fixed (RFC mandates that 10738afa1439SMike Christie * a target can handle one immediate TMF per conn). 10748afa1439SMike Christie * 10758afa1439SMike Christie * For nops-outs, we could have sent more than one if 10768afa1439SMike Christie * the target is sending us lots of nop-ins 10778afa1439SMike Christie */ 10788afa1439SMike Christie if (opcode != ISCSI_OP_NOOP_OUT) 107962f38300SMike Christie return 0; 10808afa1439SMike Christie 1081659743b0SShlomo Pongratz if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG)) { 10828afa1439SMike Christie /* 10838afa1439SMike Christie * nop-out in response to target's nop-out rejected. 10848afa1439SMike Christie * Just resend. 10858afa1439SMike Christie */ 1086659743b0SShlomo Pongratz /* In RX path we are under back lock */ 1087659743b0SShlomo Pongratz spin_unlock(&conn->session->back_lock); 1088659743b0SShlomo Pongratz spin_lock(&conn->session->frwd_lock); 10898afa1439SMike Christie iscsi_send_nopout(conn, 10908afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu); 1091659743b0SShlomo Pongratz spin_unlock(&conn->session->frwd_lock); 1092659743b0SShlomo Pongratz spin_lock(&conn->session->back_lock); 1093659743b0SShlomo Pongratz } else { 10948afa1439SMike Christie struct iscsi_task *task; 10958afa1439SMike Christie /* 10968afa1439SMike Christie * Our nop as ping got dropped. We know the target 10978afa1439SMike Christie * and transport are ok so just clean up 10988afa1439SMike Christie */ 10998afa1439SMike Christie task = iscsi_itt_to_task(conn, rejected_pdu.itt); 11008afa1439SMike Christie if (!task) { 11018afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 11028afa1439SMike Christie "Invalid pdu reject. Could " 11038afa1439SMike Christie "not lookup rejected task.\n"); 11048afa1439SMike Christie rc = ISCSI_ERR_BAD_ITT; 11058afa1439SMike Christie } else 11068afa1439SMike Christie rc = iscsi_nop_out_rsp(task, 11078afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu, 11088afa1439SMike Christie NULL, 0); 11098afa1439SMike Christie } 11108afa1439SMike Christie break; 11118afa1439SMike Christie default: 11128afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 11138afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Reason " 1114e5dbbe27SVaughan Cao "code 0x%x\n", rejected_pdu.opcode, 1115e5dbbe27SVaughan Cao rejected_pdu.itt, reject->reason); 11168afa1439SMike Christie break; 11178afa1439SMike Christie } 11188afa1439SMike Christie return rc; 111962f38300SMike Christie } 112062f38300SMike Christie 11217996a778SMike Christie /** 1122913e5bf4SMike Christie * iscsi_itt_to_task - look up task by itt 1123913e5bf4SMike Christie * @conn: iscsi connection 1124913e5bf4SMike Christie * @itt: itt 1125913e5bf4SMike Christie * 1126913e5bf4SMike Christie * This should be used for mgmt tasks like login and nops, or if 1127913e5bf4SMike Christie * the LDD's itt space does not include the session age. 1128913e5bf4SMike Christie * 1129659743b0SShlomo Pongratz * The session back_lock must be held. 1130913e5bf4SMike Christie */ 11318f9256ceSMike Christie struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt) 1132913e5bf4SMike Christie { 1133913e5bf4SMike Christie struct iscsi_session *session = conn->session; 1134262ef636SMike Christie int i; 1135913e5bf4SMike Christie 1136913e5bf4SMike Christie if (itt == RESERVED_ITT) 1137913e5bf4SMike Christie return NULL; 1138913e5bf4SMike Christie 1139262ef636SMike Christie if (session->tt->parse_pdu_itt) 1140262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, NULL); 1141262ef636SMike Christie else 1142913e5bf4SMike Christie i = get_itt(itt); 1143913e5bf4SMike Christie if (i >= session->cmds_max) 1144913e5bf4SMike Christie return NULL; 1145913e5bf4SMike Christie 1146913e5bf4SMike Christie return session->cmds[i]; 1147913e5bf4SMike Christie } 11488f9256ceSMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_task); 1149913e5bf4SMike Christie 1150913e5bf4SMike Christie /** 11517996a778SMike Christie * __iscsi_complete_pdu - complete pdu 11527996a778SMike Christie * @conn: iscsi conn 11537996a778SMike Christie * @hdr: iscsi header 11547996a778SMike Christie * @data: data buffer 11557996a778SMike Christie * @datalen: len of data buffer 11567996a778SMike Christie * 11577996a778SMike Christie * Completes pdu processing by freeing any resources allocated at 1158659743b0SShlomo Pongratz * queuecommand or send generic. session back_lock must be held and verify 11597996a778SMike Christie * itt must have been called. 11607996a778SMike Christie */ 1161913e5bf4SMike Christie int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 11627996a778SMike Christie char *data, int datalen) 11637996a778SMike Christie { 11647996a778SMike Christie struct iscsi_session *session = conn->session; 11657996a778SMike Christie int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0; 11669c19a7d0SMike Christie struct iscsi_task *task; 11677996a778SMike Christie uint32_t itt; 11687996a778SMike Christie 1169f6d5180cSMike Christie conn->last_recv = jiffies; 11700af967f5SMike Christie rc = iscsi_verify_itt(conn, hdr->itt); 11710af967f5SMike Christie if (rc) 11720af967f5SMike Christie return rc; 11730af967f5SMike Christie 1174b4377356SAl Viro if (hdr->itt != RESERVED_ITT) 1175b4377356SAl Viro itt = get_itt(hdr->itt); 11767996a778SMike Christie else 1177b4377356SAl Viro itt = ~0U; 11787996a778SMike Christie 11791b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "[op 0x%x cid %d itt 0x%x len %d]\n", 11803e5c28adSMike Christie opcode, conn->id, itt, datalen); 11817996a778SMike Christie 11823e5c28adSMike Christie if (itt == ~0U) { 118377a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 118462f38300SMike Christie 11857996a778SMike Christie switch(opcode) { 11867996a778SMike Christie case ISCSI_OP_NOOP_IN: 118740527afeSMike Christie if (datalen) { 118840527afeSMike Christie rc = ISCSI_ERR_PROTO; 118940527afeSMike Christie break; 119040527afeSMike Christie } 119140527afeSMike Christie 1192b4377356SAl Viro if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) 119340527afeSMike Christie break; 119440527afeSMike Christie 1195659743b0SShlomo Pongratz /* In RX path we are under back lock */ 1196659743b0SShlomo Pongratz spin_unlock(&session->back_lock); 1197659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 1198f6d5180cSMike Christie iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr); 1199659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 1200659743b0SShlomo Pongratz spin_lock(&session->back_lock); 12017996a778SMike Christie break; 12027996a778SMike Christie case ISCSI_OP_REJECT: 120362f38300SMike Christie rc = iscsi_handle_reject(conn, hdr, data, datalen); 120462f38300SMike Christie break; 12057996a778SMike Christie case ISCSI_OP_ASYNC_EVENT: 12068d2860b3SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 12075831c737SMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 12085831c737SMike Christie rc = ISCSI_ERR_CONN_FAILED; 12097996a778SMike Christie break; 12107996a778SMike Christie default: 12117996a778SMike Christie rc = ISCSI_ERR_BAD_OPCODE; 12127996a778SMike Christie break; 12137996a778SMike Christie } 12143e5c28adSMike Christie goto out; 12153e5c28adSMike Christie } 12167996a778SMike Christie 12173e5c28adSMike Christie switch(opcode) { 12183e5c28adSMike Christie case ISCSI_OP_SCSI_CMD_RSP: 1219913e5bf4SMike Christie case ISCSI_OP_SCSI_DATA_IN: 1220913e5bf4SMike Christie task = iscsi_itt_to_ctask(conn, hdr->itt); 1221913e5bf4SMike Christie if (!task) 1222913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1223d355e57dSMike Christie task->last_xfer = jiffies; 12243e5c28adSMike Christie break; 1225913e5bf4SMike Christie case ISCSI_OP_R2T: 1226913e5bf4SMike Christie /* 1227913e5bf4SMike Christie * LLD handles R2Ts if they need to. 1228913e5bf4SMike Christie */ 1229913e5bf4SMike Christie return 0; 1230913e5bf4SMike Christie case ISCSI_OP_LOGOUT_RSP: 1231913e5bf4SMike Christie case ISCSI_OP_LOGIN_RSP: 1232913e5bf4SMike Christie case ISCSI_OP_TEXT_RSP: 1233913e5bf4SMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 1234913e5bf4SMike Christie case ISCSI_OP_NOOP_IN: 1235913e5bf4SMike Christie task = iscsi_itt_to_task(conn, hdr->itt); 1236913e5bf4SMike Christie if (!task) 1237913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1238913e5bf4SMike Christie break; 1239913e5bf4SMike Christie default: 1240913e5bf4SMike Christie return ISCSI_ERR_BAD_OPCODE; 12413e5c28adSMike Christie } 1242913e5bf4SMike Christie 1243913e5bf4SMike Christie switch(opcode) { 1244913e5bf4SMike Christie case ISCSI_OP_SCSI_CMD_RSP: 12459c19a7d0SMike Christie iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen); 12463e5c28adSMike Christie break; 12473e5c28adSMike Christie case ISCSI_OP_SCSI_DATA_IN: 12481d9edf02SMike Christie iscsi_data_in_rsp(conn, hdr, task); 12493e5c28adSMike Christie break; 12503e5c28adSMike Christie case ISCSI_OP_LOGOUT_RSP: 12513e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12523e5c28adSMike Christie if (datalen) { 12533e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12543e5c28adSMike Christie break; 12553e5c28adSMike Christie } 12563e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 12573e5c28adSMike Christie goto recv_pdu; 12583e5c28adSMike Christie case ISCSI_OP_LOGIN_RSP: 12593e5c28adSMike Christie case ISCSI_OP_TEXT_RSP: 12603e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12613e5c28adSMike Christie /* 12623e5c28adSMike Christie * login related PDU's exp_statsn is handled in 12633e5c28adSMike Christie * userspace 12643e5c28adSMike Christie */ 12653e5c28adSMike Christie goto recv_pdu; 12663e5c28adSMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 12673e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12683e5c28adSMike Christie if (datalen) { 12693e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12703e5c28adSMike Christie break; 12713e5c28adSMike Christie } 12723e5c28adSMike Christie 12733e5c28adSMike Christie iscsi_tmf_rsp(conn, hdr); 1274b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 12753e5c28adSMike Christie break; 12763e5c28adSMike Christie case ISCSI_OP_NOOP_IN: 12773e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12783e5c28adSMike Christie if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) { 12793e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12803e5c28adSMike Christie break; 12813e5c28adSMike Christie } 12823e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 12833e5c28adSMike Christie 12848afa1439SMike Christie rc = iscsi_nop_out_rsp(task, (struct iscsi_nopin*)hdr, 12858afa1439SMike Christie data, datalen); 12863e5c28adSMike Christie break; 12873e5c28adSMike Christie default: 12883e5c28adSMike Christie rc = ISCSI_ERR_BAD_OPCODE; 12893e5c28adSMike Christie break; 12903e5c28adSMike Christie } 12913e5c28adSMike Christie 12923e5c28adSMike Christie out: 12933e5c28adSMike Christie return rc; 12943e5c28adSMike Christie recv_pdu: 12953e5c28adSMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 12963e5c28adSMike Christie rc = ISCSI_ERR_CONN_FAILED; 1297b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 12987996a778SMike Christie return rc; 12997996a778SMike Christie } 1300913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_complete_pdu); 13017996a778SMike Christie 13027996a778SMike Christie int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 13037996a778SMike Christie char *data, int datalen) 13047996a778SMike Christie { 13057996a778SMike Christie int rc; 13067996a778SMike Christie 1307659743b0SShlomo Pongratz spin_lock(&conn->session->back_lock); 13087996a778SMike Christie rc = __iscsi_complete_pdu(conn, hdr, data, datalen); 1309659743b0SShlomo Pongratz spin_unlock(&conn->session->back_lock); 13107996a778SMike Christie return rc; 13117996a778SMike Christie } 13127996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_pdu); 13137996a778SMike Christie 13140af967f5SMike Christie int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt) 13157996a778SMike Christie { 13167996a778SMike Christie struct iscsi_session *session = conn->session; 1317262ef636SMike Christie int age = 0, i = 0; 13187996a778SMike Christie 13190af967f5SMike Christie if (itt == RESERVED_ITT) 13200af967f5SMike Christie return 0; 13210af967f5SMike Christie 1322262ef636SMike Christie if (session->tt->parse_pdu_itt) 1323262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, &age); 1324262ef636SMike Christie else { 1325262ef636SMike Christie i = get_itt(itt); 1326262ef636SMike Christie age = ((__force u32)itt >> ISCSI_AGE_SHIFT) & ISCSI_AGE_MASK; 1327262ef636SMike Christie } 1328262ef636SMike Christie 1329262ef636SMike Christie if (age != session->age) { 1330322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 13310af967f5SMike Christie "received itt %x expected session age (%x)\n", 1332913e5bf4SMike Christie (__force u32)itt, session->age); 13337996a778SMike Christie return ISCSI_ERR_BAD_ITT; 13347996a778SMike Christie } 13357996a778SMike Christie 13363e5c28adSMike Christie if (i >= session->cmds_max) { 13373e5c28adSMike Christie iscsi_conn_printk(KERN_ERR, conn, 13383e5c28adSMike Christie "received invalid itt index %u (max cmds " 13393e5c28adSMike Christie "%u.\n", i, session->cmds_max); 13403e5c28adSMike Christie return ISCSI_ERR_BAD_ITT; 13417996a778SMike Christie } 13427996a778SMike Christie return 0; 13437996a778SMike Christie } 13447996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_verify_itt); 13457996a778SMike Christie 1346913e5bf4SMike Christie /** 1347913e5bf4SMike Christie * iscsi_itt_to_ctask - look up ctask by itt 1348913e5bf4SMike Christie * @conn: iscsi connection 1349913e5bf4SMike Christie * @itt: itt 1350913e5bf4SMike Christie * 1351913e5bf4SMike Christie * This should be used for cmd tasks. 1352913e5bf4SMike Christie * 1353659743b0SShlomo Pongratz * The session back_lock must be held. 1354913e5bf4SMike Christie */ 1355913e5bf4SMike Christie struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt) 13560af967f5SMike Christie { 13579c19a7d0SMike Christie struct iscsi_task *task; 13580af967f5SMike Christie 13590af967f5SMike Christie if (iscsi_verify_itt(conn, itt)) 13600af967f5SMike Christie return NULL; 13610af967f5SMike Christie 1362913e5bf4SMike Christie task = iscsi_itt_to_task(conn, itt); 1363913e5bf4SMike Christie if (!task || !task->sc) 13640af967f5SMike Christie return NULL; 13650af967f5SMike Christie 1366913e5bf4SMike Christie if (task->sc->SCp.phase != conn->session->age) { 1367913e5bf4SMike Christie iscsi_session_printk(KERN_ERR, conn->session, 1368913e5bf4SMike Christie "task's session age %d, expected %d\n", 1369913e5bf4SMike Christie task->sc->SCp.phase, conn->session->age); 13700af967f5SMike Christie return NULL; 1371913e5bf4SMike Christie } 13720af967f5SMike Christie 13739c19a7d0SMike Christie return task; 13740af967f5SMike Christie } 13750af967f5SMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask); 13760af967f5SMike Christie 137740a06e75SMike Christie void iscsi_session_failure(struct iscsi_session *session, 1378e5bd7b54SMike Christie enum iscsi_err err) 1379e5bd7b54SMike Christie { 1380e5bd7b54SMike Christie struct iscsi_conn *conn; 1381e5bd7b54SMike Christie struct device *dev; 1382e5bd7b54SMike Christie 1383659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 1384e5bd7b54SMike Christie conn = session->leadconn; 1385e5bd7b54SMike Christie if (session->state == ISCSI_STATE_TERMINATE || !conn) { 1386659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1387e5bd7b54SMike Christie return; 1388e5bd7b54SMike Christie } 1389e5bd7b54SMike Christie 1390e5bd7b54SMike Christie dev = get_device(&conn->cls_conn->dev); 1391659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1392e5bd7b54SMike Christie if (!dev) 1393e5bd7b54SMike Christie return; 1394e5bd7b54SMike Christie /* 1395e5bd7b54SMike Christie * if the host is being removed bypass the connection 1396e5bd7b54SMike Christie * recovery initialization because we are going to kill 1397e5bd7b54SMike Christie * the session. 1398e5bd7b54SMike Christie */ 1399e5bd7b54SMike Christie if (err == ISCSI_ERR_INVALID_HOST) 1400e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 1401e5bd7b54SMike Christie else 1402e5bd7b54SMike Christie iscsi_conn_failure(conn, err); 1403e5bd7b54SMike Christie put_device(dev); 1404e5bd7b54SMike Christie } 1405e5bd7b54SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_failure); 1406e5bd7b54SMike Christie 14077996a778SMike Christie void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err) 14087996a778SMike Christie { 14097996a778SMike Christie struct iscsi_session *session = conn->session; 14107996a778SMike Christie 1411659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 1412656cffc9SMike Christie if (session->state == ISCSI_STATE_FAILED) { 1413659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1414656cffc9SMike Christie return; 1415656cffc9SMike Christie } 1416656cffc9SMike Christie 141767a61114SMike Christie if (conn->stop_stage == 0) 14187996a778SMike Christie session->state = ISCSI_STATE_FAILED; 1419659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1420e5bd7b54SMike Christie 14217996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 14227996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 1423e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 14247996a778SMike Christie } 14257996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_failure); 14267996a778SMike Christie 142777a23c21SMike Christie static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn) 142877a23c21SMike Christie { 142977a23c21SMike Christie struct iscsi_session *session = conn->session; 143077a23c21SMike Christie 143177a23c21SMike Christie /* 143277a23c21SMike Christie * Check for iSCSI window and take care of CmdSN wrap-around 143377a23c21SMike Christie */ 1434e0726407SMike Christie if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) { 14351b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iSCSI CmdSN closed. ExpCmdSn " 14361b2c7af8SMike Christie "%u MaxCmdSN %u CmdSN %u/%u\n", 14371b2c7af8SMike Christie session->exp_cmdsn, session->max_cmdsn, 14381b2c7af8SMike Christie session->cmdsn, session->queued_cmdsn); 143977a23c21SMike Christie return -ENOSPC; 144077a23c21SMike Christie } 144177a23c21SMike Christie return 0; 144277a23c21SMike Christie } 144377a23c21SMike Christie 14449c19a7d0SMike Christie static int iscsi_xmit_task(struct iscsi_conn *conn) 144577a23c21SMike Christie { 14469c19a7d0SMike Christie struct iscsi_task *task = conn->task; 1447843c0a8aSMike Christie int rc; 144877a23c21SMike Christie 144970b31c15SMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) 145070b31c15SMike Christie return -ENODATA; 145170b31c15SMike Christie 14529c19a7d0SMike Christie __iscsi_get_task(task); 1453659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 14549c19a7d0SMike Christie rc = conn->session->tt->xmit_task(task); 1455659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 1456d355e57dSMike Christie if (!rc) { 14579c19a7d0SMike Christie /* done with this task */ 1458d355e57dSMike Christie task->last_xfer = jiffies; 14599c19a7d0SMike Christie conn->task = NULL; 1460d355e57dSMike Christie } 1461659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 146272b97402SShlomo Pongratz spin_lock(&conn->session->back_lock); 1463d355e57dSMike Christie __iscsi_put_task(task); 146472b97402SShlomo Pongratz spin_unlock(&conn->session->back_lock); 146577a23c21SMike Christie return rc; 146677a23c21SMike Christie } 146777a23c21SMike Christie 14687996a778SMike Christie /** 14699c19a7d0SMike Christie * iscsi_requeue_task - requeue task to run from session workqueue 14709c19a7d0SMike Christie * @task: task to requeue 1471843c0a8aSMike Christie * 14729c19a7d0SMike Christie * LLDs that need to run a task from the session workqueue should call 1473659743b0SShlomo Pongratz * this. The session frwd_lock must be held. This should only be called 1474052d0144SMike Christie * by software drivers. 1475843c0a8aSMike Christie */ 14769c19a7d0SMike Christie void iscsi_requeue_task(struct iscsi_task *task) 1477843c0a8aSMike Christie { 14789c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 1479843c0a8aSMike Christie 14803bbaaad9SMike Christie /* 14813bbaaad9SMike Christie * this may be on the requeue list already if the xmit_task callout 14823bbaaad9SMike Christie * is handling the r2ts while we are adding new ones 14833bbaaad9SMike Christie */ 14846f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 14853bbaaad9SMike Christie if (list_empty(&task->running)) 14863bbaaad9SMike Christie list_add_tail(&task->running, &conn->requeue); 14876f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 148832ae763eSMike Christie iscsi_conn_queue_work(conn); 1489843c0a8aSMike Christie } 14909c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_requeue_task); 1491843c0a8aSMike Christie 1492843c0a8aSMike Christie /** 14937996a778SMike Christie * iscsi_data_xmit - xmit any command into the scheduled connection 14947996a778SMike Christie * @conn: iscsi connection 14957996a778SMike Christie * 14967996a778SMike Christie * Notes: 14977996a778SMike Christie * The function can return -EAGAIN in which case the caller must 14987996a778SMike Christie * re-schedule it again later or recover. '0' return code means 14997996a778SMike Christie * successful xmit. 15007996a778SMike Christie **/ 15017996a778SMike Christie static int iscsi_data_xmit(struct iscsi_conn *conn) 15027996a778SMike Christie { 15035d12c05eSMike Christie struct iscsi_task *task; 15043219e529SMike Christie int rc = 0; 15057996a778SMike Christie 1506659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 150770b31c15SMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) { 15081b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n"); 1509659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 15103219e529SMike Christie return -ENODATA; 15117996a778SMike Christie } 15127996a778SMike Christie 15139c19a7d0SMike Christie if (conn->task) { 15149c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 15153219e529SMike Christie if (rc) 151670b31c15SMike Christie goto done; 15177996a778SMike Christie } 151877a23c21SMike Christie 151977a23c21SMike Christie /* 152077a23c21SMike Christie * process mgmt pdus like nops before commands since we should 152177a23c21SMike Christie * only have one nop-out as a ping from us and targets should not 152277a23c21SMike Christie * overflow us with nop-ins 152377a23c21SMike Christie */ 15246f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 152577a23c21SMike Christie check_mgmt: 1526843c0a8aSMike Christie while (!list_empty(&conn->mgmtqueue)) { 15279c19a7d0SMike Christie conn->task = list_entry(conn->mgmtqueue.next, 15289c19a7d0SMike Christie struct iscsi_task, running); 15293bbaaad9SMike Christie list_del_init(&conn->task->running); 15306f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 15319c19a7d0SMike Christie if (iscsi_prep_mgmt_task(conn, conn->task)) { 1532659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 1533659743b0SShlomo Pongratz spin_lock_bh(&conn->session->back_lock); 15349c19a7d0SMike Christie __iscsi_put_task(conn->task); 1535659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->back_lock); 15369c19a7d0SMike Christie conn->task = NULL; 15376f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 1538b3a7ea8dSMike Christie continue; 1539b3a7ea8dSMike Christie } 15409c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 15413219e529SMike Christie if (rc) 154270b31c15SMike Christie goto done; 15436f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 15447996a778SMike Christie } 15457996a778SMike Christie 1546843c0a8aSMike Christie /* process pending command queue */ 15473bbaaad9SMike Christie while (!list_empty(&conn->cmdqueue)) { 15485d12c05eSMike Christie conn->task = list_entry(conn->cmdqueue.next, struct iscsi_task, 15495d12c05eSMike Christie running); 15503bbaaad9SMike Christie list_del_init(&conn->task->running); 15516f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 1552b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) { 1553b3cd5050SMike Christie fail_scsi_task(conn->task, DID_IMM_RETRY); 15546f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 1555b3a7ea8dSMike Christie continue; 1556b3a7ea8dSMike Christie } 1557577577daSMike Christie rc = iscsi_prep_scsi_cmd_pdu(conn->task); 1558577577daSMike Christie if (rc) { 15595d12c05eSMike Christie if (rc == -ENOMEM || rc == -EACCES) { 15606f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 15613bbaaad9SMike Christie list_add_tail(&conn->task->running, 15623bbaaad9SMike Christie &conn->cmdqueue); 1563577577daSMike Christie conn->task = NULL; 15646f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 156570b31c15SMike Christie goto done; 1566577577daSMike Christie } else 1567b3cd5050SMike Christie fail_scsi_task(conn->task, DID_ABORT); 15686f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 1569004d6530SBoaz Harrosh continue; 1570004d6530SBoaz Harrosh } 15719c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 15723219e529SMike Christie if (rc) 157370b31c15SMike Christie goto done; 157477a23c21SMike Christie /* 15759c19a7d0SMike Christie * we could continuously get new task requests so 157677a23c21SMike Christie * we need to check the mgmt queue for nops that need to 157777a23c21SMike Christie * be sent to aviod starvation 157877a23c21SMike Christie */ 15796f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 1580843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 1581843c0a8aSMike Christie goto check_mgmt; 1582843c0a8aSMike Christie } 1583843c0a8aSMike Christie 1584843c0a8aSMike Christie while (!list_empty(&conn->requeue)) { 1585b3a7ea8dSMike Christie /* 1586b3a7ea8dSMike Christie * we always do fastlogout - conn stop code will clean up. 1587b3a7ea8dSMike Christie */ 1588b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 1589b3a7ea8dSMike Christie break; 1590b3a7ea8dSMike Christie 15915d12c05eSMike Christie task = list_entry(conn->requeue.next, struct iscsi_task, 15925d12c05eSMike Christie running); 15935d12c05eSMike Christie if (iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_DATA_OUT)) 15945d12c05eSMike Christie break; 15955d12c05eSMike Christie 15965d12c05eSMike Christie conn->task = task; 15973bbaaad9SMike Christie list_del_init(&conn->task->running); 15989c19a7d0SMike Christie conn->task->state = ISCSI_TASK_RUNNING; 15996f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 16009c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 1601843c0a8aSMike Christie if (rc) 160270b31c15SMike Christie goto done; 16036f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 1604843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 160577a23c21SMike Christie goto check_mgmt; 16067996a778SMike Christie } 16076f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 1608659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 16093219e529SMike Christie return -ENODATA; 16107996a778SMike Christie 161170b31c15SMike Christie done: 1612659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 16133219e529SMike Christie return rc; 16147996a778SMike Christie } 16157996a778SMike Christie 1616c4028958SDavid Howells static void iscsi_xmitworker(struct work_struct *work) 16177996a778SMike Christie { 1618c4028958SDavid Howells struct iscsi_conn *conn = 1619c4028958SDavid Howells container_of(work, struct iscsi_conn, xmitwork); 16203219e529SMike Christie int rc; 16217996a778SMike Christie /* 16227996a778SMike Christie * serialize Xmit worker on a per-connection basis. 16237996a778SMike Christie */ 16243219e529SMike Christie do { 16253219e529SMike Christie rc = iscsi_data_xmit(conn); 16263219e529SMike Christie } while (rc >= 0 || rc == -EAGAIN); 16277996a778SMike Christie } 16287996a778SMike Christie 1629577577daSMike Christie static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn, 1630577577daSMike Christie struct scsi_cmnd *sc) 1631577577daSMike Christie { 1632577577daSMike Christie struct iscsi_task *task; 1633577577daSMike Christie 16347acd72ebSStefani Seibold if (!kfifo_out(&conn->session->cmdpool.queue, 1635577577daSMike Christie (void *) &task, sizeof(void *))) 1636577577daSMike Christie return NULL; 1637577577daSMike Christie 1638577577daSMike Christie sc->SCp.phase = conn->session->age; 1639577577daSMike Christie sc->SCp.ptr = (char *) task; 1640577577daSMike Christie 16416dc618cdSElena Reshetova refcount_set(&task->refcount, 1); 1642577577daSMike Christie task->state = ISCSI_TASK_PENDING; 1643577577daSMike Christie task->conn = conn; 1644577577daSMike Christie task->sc = sc; 1645d355e57dSMike Christie task->have_checked_conn = false; 1646d355e57dSMike Christie task->last_timeout = jiffies; 1647d355e57dSMike Christie task->last_xfer = jiffies; 164855e51edaSSagi Grimberg task->protected = false; 1649577577daSMike Christie INIT_LIST_HEAD(&task->running); 1650577577daSMike Christie return task; 1651577577daSMike Christie } 1652577577daSMike Christie 16537996a778SMike Christie enum { 16547996a778SMike Christie FAILURE_BAD_HOST = 1, 16557996a778SMike Christie FAILURE_SESSION_FAILED, 16567996a778SMike Christie FAILURE_SESSION_FREED, 16577996a778SMike Christie FAILURE_WINDOW_CLOSED, 165860ecebf5SMike Christie FAILURE_OOM, 16597996a778SMike Christie FAILURE_SESSION_TERMINATE, 1660656cffc9SMike Christie FAILURE_SESSION_IN_RECOVERY, 16617996a778SMike Christie FAILURE_SESSION_RECOVERY_TIMEOUT, 1662b3a7ea8dSMike Christie FAILURE_SESSION_LOGGING_OUT, 16636eabafbeSMike Christie FAILURE_SESSION_NOT_READY, 16647996a778SMike Christie }; 16657996a778SMike Christie 1666f41d4721SMike Christie int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc) 16677996a778SMike Christie { 166875613521SMike Christie struct iscsi_cls_session *cls_session; 16691336aed1SMike Christie struct iscsi_host *ihost; 16707996a778SMike Christie int reason = 0; 16717996a778SMike Christie struct iscsi_session *session; 16727996a778SMike Christie struct iscsi_conn *conn; 16739c19a7d0SMike Christie struct iscsi_task *task = NULL; 16747996a778SMike Christie 16757996a778SMike Christie sc->result = 0; 1676f47f2cf5SMike Christie sc->SCp.ptr = NULL; 16777996a778SMike Christie 16781336aed1SMike Christie ihost = shost_priv(host); 16797996a778SMike Christie 168075613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 168175613521SMike Christie session = cls_session->dd_data; 1682659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 16837996a778SMike Christie 168475613521SMike Christie reason = iscsi_session_chkready(cls_session); 16856eabafbeSMike Christie if (reason) { 16866eabafbeSMike Christie sc->result = reason; 16876eabafbeSMike Christie goto fault; 16886eabafbeSMike Christie } 16896eabafbeSMike Christie 1690301e0f7eSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1691656cffc9SMike Christie /* 1692656cffc9SMike Christie * to handle the race between when we set the recovery state 1693656cffc9SMike Christie * and block the session we requeue here (commands could 1694656cffc9SMike Christie * be entering our queuecommand while a block is starting 1695656cffc9SMike Christie * up because the block code is not locked) 1696656cffc9SMike Christie */ 16979000bcd6SMike Christie switch (session->state) { 1698301e0f7eSMike Christie case ISCSI_STATE_FAILED: 16999000bcd6SMike Christie case ISCSI_STATE_IN_RECOVERY: 1700656cffc9SMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1701301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1702301e0f7eSMike Christie break; 17039000bcd6SMike Christie case ISCSI_STATE_LOGGING_OUT: 17049000bcd6SMike Christie reason = FAILURE_SESSION_LOGGING_OUT; 1705301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1706301e0f7eSMike Christie break; 1707b3a7ea8dSMike Christie case ISCSI_STATE_RECOVERY_FAILED: 1708656cffc9SMike Christie reason = FAILURE_SESSION_RECOVERY_TIMEOUT; 170956d7fcfaSMike Christie sc->result = DID_TRANSPORT_FAILFAST << 16; 1710b3a7ea8dSMike Christie break; 1711b3a7ea8dSMike Christie case ISCSI_STATE_TERMINATE: 1712656cffc9SMike Christie reason = FAILURE_SESSION_TERMINATE; 17136eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1714b3a7ea8dSMike Christie break; 1715b3a7ea8dSMike Christie default: 17167996a778SMike Christie reason = FAILURE_SESSION_FREED; 17176eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1718b3a7ea8dSMike Christie } 17197996a778SMike Christie goto fault; 17207996a778SMike Christie } 17217996a778SMike Christie 17227996a778SMike Christie conn = session->leadconn; 172398644047SMike Christie if (!conn) { 172498644047SMike Christie reason = FAILURE_SESSION_FREED; 17256eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 172698644047SMike Christie goto fault; 172798644047SMike Christie } 17287996a778SMike Christie 1729661134adSMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) { 1730661134adSMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1731661134adSMike Christie sc->result = DID_REQUEUE; 1732661134adSMike Christie goto fault; 1733661134adSMike Christie } 1734661134adSMike Christie 173577a23c21SMike Christie if (iscsi_check_cmdsn_window_closed(conn)) { 173677a23c21SMike Christie reason = FAILURE_WINDOW_CLOSED; 173777a23c21SMike Christie goto reject; 173877a23c21SMike Christie } 173977a23c21SMike Christie 1740577577daSMike Christie task = iscsi_alloc_task(conn, sc); 1741577577daSMike Christie if (!task) { 174260ecebf5SMike Christie reason = FAILURE_OOM; 174360ecebf5SMike Christie goto reject; 174460ecebf5SMike Christie } 17457996a778SMike Christie 17461336aed1SMike Christie if (!ihost->workq) { 1747577577daSMike Christie reason = iscsi_prep_scsi_cmd_pdu(task); 1748577577daSMike Christie if (reason) { 17495d12c05eSMike Christie if (reason == -ENOMEM || reason == -EACCES) { 1750577577daSMike Christie reason = FAILURE_OOM; 1751577577daSMike Christie goto prepd_reject; 1752577577daSMike Christie } else { 1753052d0144SMike Christie sc->result = DID_ABORT << 16; 1754577577daSMike Christie goto prepd_fault; 1755577577daSMike Christie } 1756052d0144SMike Christie } 17579c19a7d0SMike Christie if (session->tt->xmit_task(task)) { 1758d3305f34SMike Christie session->cmdsn--; 1759052d0144SMike Christie reason = FAILURE_SESSION_NOT_READY; 1760577577daSMike Christie goto prepd_reject; 1761052d0144SMike Christie } 17623bbaaad9SMike Christie } else { 17636f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 17643bbaaad9SMike Christie list_add_tail(&task->running, &conn->cmdqueue); 17656f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 176632ae763eSMike Christie iscsi_conn_queue_work(conn); 17673bbaaad9SMike Christie } 1768052d0144SMike Christie 1769052d0144SMike Christie session->queued_cmdsn++; 1770659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 17717996a778SMike Christie return 0; 17727996a778SMike Christie 1773577577daSMike Christie prepd_reject: 1774f41d4721SMike Christie iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 17757996a778SMike Christie reject: 1776659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 17771b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n", 17781b2c7af8SMike Christie sc->cmnd[0], reason); 1779d6d13ee1SMike Christie return SCSI_MLQUEUE_TARGET_BUSY; 17807996a778SMike Christie 1781577577daSMike Christie prepd_fault: 1782f41d4721SMike Christie iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 17837996a778SMike Christie fault: 1784659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 17851b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n", 17861b2c7af8SMike Christie sc->cmnd[0], reason); 1787c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 17881c138991SFUJITA Tomonori scsi_set_resid(sc, scsi_bufflen(sc)); 1789c07d4444SBoaz Harrosh else { 1790c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 1791c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 1792c07d4444SBoaz Harrosh } 1793f41d4721SMike Christie sc->scsi_done(sc); 17947996a778SMike Christie return 0; 17957996a778SMike Christie } 17967996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_queuecommand); 17977996a778SMike Christie 17986b5d6c44SMike Christie int iscsi_target_alloc(struct scsi_target *starget) 17996b5d6c44SMike Christie { 18006b5d6c44SMike Christie struct iscsi_cls_session *cls_session = starget_to_session(starget); 18016b5d6c44SMike Christie struct iscsi_session *session = cls_session->dd_data; 18026b5d6c44SMike Christie 18036b5d6c44SMike Christie starget->can_queue = session->scsi_cmds_max; 18046b5d6c44SMike Christie return 0; 18056b5d6c44SMike Christie } 18066b5d6c44SMike Christie EXPORT_SYMBOL_GPL(iscsi_target_alloc); 18076b5d6c44SMike Christie 1808843c0a8aSMike Christie static void iscsi_tmf_timedout(unsigned long data) 18097996a778SMike Christie { 1810843c0a8aSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 18117996a778SMike Christie struct iscsi_session *session = conn->session; 18127996a778SMike Christie 1813659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 1814843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) { 1815843c0a8aSMike Christie conn->tmf_state = TMF_TIMEDOUT; 1816bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf timedout\n"); 18177996a778SMike Christie /* unblock eh_abort() */ 18187996a778SMike Christie wake_up(&conn->ehwait); 18197996a778SMike Christie } 1820659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 18217996a778SMike Christie } 18227996a778SMike Christie 18239c19a7d0SMike Christie static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, 1824f6d5180cSMike Christie struct iscsi_tm *hdr, int age, 1825f6d5180cSMike Christie int timeout) 18267996a778SMike Christie { 18277996a778SMike Christie struct iscsi_session *session = conn->session; 18289c19a7d0SMike Christie struct iscsi_task *task; 18297996a778SMike Christie 18309c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr, 18317996a778SMike Christie NULL, 0); 18329c19a7d0SMike Christie if (!task) { 1833659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1834df4da5cdSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send TMF.\n"); 18357996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1836659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 183777a23c21SMike Christie return -EPERM; 18387996a778SMike Christie } 18397996a778SMike Christie conn->tmfcmd_pdus_cnt++; 1840f6d5180cSMike Christie conn->tmf_timer.expires = timeout * HZ + jiffies; 1841843c0a8aSMike Christie conn->tmf_timer.function = iscsi_tmf_timedout; 1842843c0a8aSMike Christie conn->tmf_timer.data = (unsigned long)conn; 1843843c0a8aSMike Christie add_timer(&conn->tmf_timer); 1844bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf set timeout\n"); 1845843c0a8aSMike Christie 1846659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 18476724add1SMike Christie mutex_unlock(&session->eh_mutex); 18487996a778SMike Christie 18497996a778SMike Christie /* 18507996a778SMike Christie * block eh thread until: 18517996a778SMike Christie * 1852843c0a8aSMike Christie * 1) tmf response 1853843c0a8aSMike Christie * 2) tmf timeout 18547996a778SMike Christie * 3) session is terminated or restarted or userspace has 18557996a778SMike Christie * given up on recovery 18567996a778SMike Christie */ 1857843c0a8aSMike Christie wait_event_interruptible(conn->ehwait, age != session->age || 18587996a778SMike Christie session->state != ISCSI_STATE_LOGGED_IN || 1859843c0a8aSMike Christie conn->tmf_state != TMF_QUEUED); 18607996a778SMike Christie if (signal_pending(current)) 18617996a778SMike Christie flush_signals(current); 1862843c0a8aSMike Christie del_timer_sync(&conn->tmf_timer); 1863843c0a8aSMike Christie 18646724add1SMike Christie mutex_lock(&session->eh_mutex); 1865659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 18669c19a7d0SMike Christie /* if the session drops it will clean up the task */ 1867843c0a8aSMike Christie if (age != session->age || 1868843c0a8aSMike Christie session->state != ISCSI_STATE_LOGGED_IN) 1869843c0a8aSMike Christie return -ENOTCONN; 18707996a778SMike Christie return 0; 18717996a778SMike Christie } 18727996a778SMike Christie 18737996a778SMike Christie /* 1874843c0a8aSMike Christie * Fail commands. session lock held and recv side suspended and xmit 1875843c0a8aSMike Christie * thread flushed 1876843c0a8aSMike Christie */ 18779cb78c16SHannes Reinecke static void fail_scsi_tasks(struct iscsi_conn *conn, u64 lun, int error) 1878843c0a8aSMike Christie { 18793bbaaad9SMike Christie struct iscsi_task *task; 18803bbaaad9SMike Christie int i; 1881843c0a8aSMike Christie 18823bbaaad9SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 18833bbaaad9SMike Christie task = conn->session->cmds[i]; 18843bbaaad9SMike Christie if (!task->sc || task->state == ISCSI_TASK_FREE) 18853bbaaad9SMike Christie continue; 1886843c0a8aSMike Christie 18873bbaaad9SMike Christie if (lun != -1 && lun != task->sc->device->lun) 18883bbaaad9SMike Christie continue; 18893bbaaad9SMike Christie 18901b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, 18913bbaaad9SMike Christie "failing sc %p itt 0x%x state %d\n", 18923bbaaad9SMike Christie task->sc, task->itt, task->state); 1893b3cd5050SMike Christie fail_scsi_task(task, error); 1894843c0a8aSMike Christie } 1895843c0a8aSMike Christie } 1896843c0a8aSMike Christie 1897661134adSMike Christie /** 1898661134adSMike Christie * iscsi_suspend_queue - suspend iscsi_queuecommand 1899661134adSMike Christie * @conn: iscsi conn to stop queueing IO on 1900661134adSMike Christie * 1901659743b0SShlomo Pongratz * This grabs the session frwd_lock to make sure no one is in 1902661134adSMike Christie * xmit_task/queuecommand, and then sets suspend to prevent 1903661134adSMike Christie * new commands from being queued. This only needs to be called 1904661134adSMike Christie * by offload drivers that need to sync a path like ep disconnect 1905661134adSMike Christie * with the iscsi_queuecommand/xmit_task. To start IO again libiscsi 1906661134adSMike Christie * will call iscsi_start_tx and iscsi_unblock_session when in FFP. 1907661134adSMike Christie */ 1908661134adSMike Christie void iscsi_suspend_queue(struct iscsi_conn *conn) 1909661134adSMike Christie { 1910659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 1911661134adSMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1912659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 1913661134adSMike Christie } 1914661134adSMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_queue); 1915661134adSMike Christie 1916661134adSMike Christie /** 1917661134adSMike Christie * iscsi_suspend_tx - suspend iscsi_data_xmit 1918661134adSMike Christie * @conn: iscsi conn tp stop processing IO on. 1919661134adSMike Christie * 1920661134adSMike Christie * This function sets the suspend bit to prevent iscsi_data_xmit 1921661134adSMike Christie * from sending new IO, and if work is queued on the xmit thread 1922661134adSMike Christie * it will wait for it to be completed. 1923661134adSMike Christie */ 1924b40977d9SMike Christie void iscsi_suspend_tx(struct iscsi_conn *conn) 19256724add1SMike Christie { 192632ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 192732ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 192832ae763eSMike Christie 19296724add1SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 19301336aed1SMike Christie if (ihost->workq) 193132ae763eSMike Christie flush_workqueue(ihost->workq); 19326724add1SMike Christie } 1933b40977d9SMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_tx); 19346724add1SMike Christie 19356724add1SMike Christie static void iscsi_start_tx(struct iscsi_conn *conn) 19366724add1SMike Christie { 19376724add1SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 193832ae763eSMike Christie iscsi_conn_queue_work(conn); 19396724add1SMike Christie } 19406724add1SMike Christie 19414c48a829SMike Christie /* 19424c48a829SMike Christie * We want to make sure a ping is in flight. It has timed out. 19434c48a829SMike Christie * And we are not busy processing a pdu that is making 19444c48a829SMike Christie * progress but got started before the ping and is taking a while 19454c48a829SMike Christie * to complete so the ping is just stuck behind it in a queue. 19464c48a829SMike Christie */ 19474c48a829SMike Christie static int iscsi_has_ping_timed_out(struct iscsi_conn *conn) 19484c48a829SMike Christie { 19494c48a829SMike Christie if (conn->ping_task && 19504c48a829SMike Christie time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) + 19514c48a829SMike Christie (conn->ping_timeout * HZ), jiffies)) 19524c48a829SMike Christie return 1; 19534c48a829SMike Christie else 19544c48a829SMike Christie return 0; 19554c48a829SMike Christie } 19564c48a829SMike Christie 1957b6a05c82SChristoph Hellwig enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc) 1958f6d5180cSMike Christie { 1959d355e57dSMike Christie enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED; 196092ed4d69SMike Christie struct iscsi_task *task = NULL, *running_task; 1961f6d5180cSMike Christie struct iscsi_cls_session *cls_session; 1962f6d5180cSMike Christie struct iscsi_session *session; 1963f6d5180cSMike Christie struct iscsi_conn *conn; 196492ed4d69SMike Christie int i; 1965f6d5180cSMike Christie 1966d355e57dSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 196775613521SMike Christie session = cls_session->dd_data; 1968f6d5180cSMike Christie 1969bd2199d4SErez Zilber ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc); 1970f6d5180cSMike Christie 1971659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 1972e3d338a5SMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 1973e3d338a5SMike Christie if (!task) { 1974e3d338a5SMike Christie /* 1975e3d338a5SMike Christie * Raced with completion. Blk layer has taken ownership 1976e3d338a5SMike Christie * so let timeout code complete it now. 1977e3d338a5SMike Christie */ 1978e3d338a5SMike Christie rc = BLK_EH_HANDLED; 1979e3d338a5SMike Christie goto done; 1980e3d338a5SMike Christie } 1981e3d338a5SMike Christie 1982f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1983f6d5180cSMike Christie /* 1984f6d5180cSMike Christie * We are probably in the middle of iscsi recovery so let 1985f6d5180cSMike Christie * that complete and handle the error. 1986f6d5180cSMike Christie */ 1987242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1988f6d5180cSMike Christie goto done; 1989f6d5180cSMike Christie } 1990f6d5180cSMike Christie 1991f6d5180cSMike Christie conn = session->leadconn; 1992f6d5180cSMike Christie if (!conn) { 1993f6d5180cSMike Christie /* In the middle of shuting down */ 1994242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1995f6d5180cSMike Christie goto done; 1996f6d5180cSMike Christie } 1997f6d5180cSMike Christie 1998d355e57dSMike Christie /* 1999d355e57dSMike Christie * If we have sent (at least queued to the network layer) a pdu or 2000d355e57dSMike Christie * recvd one for the task since the last timeout ask for 2001d355e57dSMike Christie * more time. If on the next timeout we have not made progress 2002d355e57dSMike Christie * we can check if it is the task or connection when we send the 2003d355e57dSMike Christie * nop as a ping. 2004d355e57dSMike Christie */ 200592ed4d69SMike Christie if (time_after(task->last_xfer, task->last_timeout)) { 2006bd2199d4SErez Zilber ISCSI_DBG_EH(session, "Command making progress. Asking " 2007d355e57dSMike Christie "scsi-ml for more time to complete. " 200892ed4d69SMike Christie "Last data xfer at %lu. Last timeout was at " 2009d355e57dSMike Christie "%lu\n.", task->last_xfer, task->last_timeout); 2010d355e57dSMike Christie task->have_checked_conn = false; 2011d355e57dSMike Christie rc = BLK_EH_RESET_TIMER; 2012d355e57dSMike Christie goto done; 2013d355e57dSMike Christie } 2014d355e57dSMike Christie 2015f6d5180cSMike Christie if (!conn->recv_timeout && !conn->ping_timeout) 2016f6d5180cSMike Christie goto done; 2017f6d5180cSMike Christie /* 2018f6d5180cSMike Christie * if the ping timedout then we are in the middle of cleaning up 2019f6d5180cSMike Christie * and can let the iscsi eh handle it 2020f6d5180cSMike Christie */ 20214c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 2022242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 20234c48a829SMike Christie goto done; 20244c48a829SMike Christie } 2025d355e57dSMike Christie 202692ed4d69SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 202792ed4d69SMike Christie running_task = conn->session->cmds[i]; 202892ed4d69SMike Christie if (!running_task->sc || running_task == task || 202992ed4d69SMike Christie running_task->state != ISCSI_TASK_RUNNING) 203092ed4d69SMike Christie continue; 203192ed4d69SMike Christie 203292ed4d69SMike Christie /* 203392ed4d69SMike Christie * Only check if cmds started before this one have made 203492ed4d69SMike Christie * progress, or this could never fail 203592ed4d69SMike Christie */ 203692ed4d69SMike Christie if (time_after(running_task->sc->jiffies_at_alloc, 203792ed4d69SMike Christie task->sc->jiffies_at_alloc)) 203892ed4d69SMike Christie continue; 203992ed4d69SMike Christie 204092ed4d69SMike Christie if (time_after(running_task->last_xfer, task->last_timeout)) { 204192ed4d69SMike Christie /* 204292ed4d69SMike Christie * This task has not made progress, but a task 204392ed4d69SMike Christie * started before us has transferred data since 204492ed4d69SMike Christie * we started/last-checked. We could be queueing 204592ed4d69SMike Christie * too many tasks or the LU is bad. 204692ed4d69SMike Christie * 204792ed4d69SMike Christie * If the device is bad the cmds ahead of us on 204892ed4d69SMike Christie * other devs will complete, and this loop will 204992ed4d69SMike Christie * eventually fail starting the scsi eh. 205092ed4d69SMike Christie */ 205192ed4d69SMike Christie ISCSI_DBG_EH(session, "Command has not made progress " 205292ed4d69SMike Christie "but commands ahead of it have. " 205392ed4d69SMike Christie "Asking scsi-ml for more time to " 205492ed4d69SMike Christie "complete. Our last xfer vs running task " 205592ed4d69SMike Christie "last xfer %lu/%lu. Last check %lu.\n", 205692ed4d69SMike Christie task->last_xfer, running_task->last_xfer, 205792ed4d69SMike Christie task->last_timeout); 205892ed4d69SMike Christie rc = BLK_EH_RESET_TIMER; 205992ed4d69SMike Christie goto done; 206092ed4d69SMike Christie } 206192ed4d69SMike Christie } 206292ed4d69SMike Christie 2063d355e57dSMike Christie /* Assumes nop timeout is shorter than scsi cmd timeout */ 2064d355e57dSMike Christie if (task->have_checked_conn) 2065d355e57dSMike Christie goto done; 2066d355e57dSMike Christie 2067f6d5180cSMike Christie /* 2068d355e57dSMike Christie * Checking the transport already or nop from a cmd timeout still 2069d355e57dSMike Christie * running 2070f6d5180cSMike Christie */ 2071d355e57dSMike Christie if (conn->ping_task) { 2072d355e57dSMike Christie task->have_checked_conn = true; 2073242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 20744c48a829SMike Christie goto done; 20754c48a829SMike Christie } 20764c48a829SMike Christie 2077d355e57dSMike Christie /* Make sure there is a transport check done */ 2078d355e57dSMike Christie iscsi_send_nopout(conn, NULL); 2079d355e57dSMike Christie task->have_checked_conn = true; 2080242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 2081d355e57dSMike Christie 2082f6d5180cSMike Christie done: 2083d355e57dSMike Christie if (task) 2084d355e57dSMike Christie task->last_timeout = jiffies; 2085659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 2086bd2199d4SErez Zilber ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ? 2087242f9dcbSJens Axboe "timer reset" : "nh"); 2088f6d5180cSMike Christie return rc; 2089f6d5180cSMike Christie } 2090b6a05c82SChristoph Hellwig EXPORT_SYMBOL_GPL(iscsi_eh_cmd_timed_out); 2091f6d5180cSMike Christie 2092f6d5180cSMike Christie static void iscsi_check_transport_timeouts(unsigned long data) 2093f6d5180cSMike Christie { 2094f6d5180cSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 2095f6d5180cSMike Christie struct iscsi_session *session = conn->session; 20964cf10435SMike Christie unsigned long recv_timeout, next_timeout = 0, last_recv; 2097f6d5180cSMike Christie 2098659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 2099f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 2100f6d5180cSMike Christie goto done; 2101f6d5180cSMike Christie 21024cf10435SMike Christie recv_timeout = conn->recv_timeout; 21034cf10435SMike Christie if (!recv_timeout) 2104f6d5180cSMike Christie goto done; 2105f6d5180cSMike Christie 21064cf10435SMike Christie recv_timeout *= HZ; 2107f6d5180cSMike Christie last_recv = conn->last_recv; 21084c48a829SMike Christie 21094c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 2110322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs " 21114c48a829SMike Christie "expired, recv timeout %d, last rx %lu, " 21124c48a829SMike Christie "last ping %lu, now %lu\n", 21134c48a829SMike Christie conn->ping_timeout, conn->recv_timeout, 21144c48a829SMike Christie last_recv, conn->last_ping, jiffies); 2115659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 211609ff742cSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_NOP_TIMEDOUT); 2117f6d5180cSMike Christie return; 2118f6d5180cSMike Christie } 2119f6d5180cSMike Christie 21204cf10435SMike Christie if (time_before_eq(last_recv + recv_timeout, jiffies)) { 2121f6d5180cSMike Christie /* send a ping to try to provoke some traffic */ 21221b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Sending nopout as ping\n"); 212352f5664aSAriel Nahum if (iscsi_send_nopout(conn, NULL)) 212452f5664aSAriel Nahum next_timeout = jiffies + (1 * HZ); 212552f5664aSAriel Nahum else 21264cf10435SMike Christie next_timeout = conn->last_ping + (conn->ping_timeout * HZ); 2127ad294e9cSMike Christie } else 21284cf10435SMike Christie next_timeout = last_recv + recv_timeout; 2129f6d5180cSMike Christie 21301b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout); 2131f6d5180cSMike Christie mod_timer(&conn->transport_timer, next_timeout); 2132f6d5180cSMike Christie done: 2133659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 2134f6d5180cSMike Christie } 2135f6d5180cSMike Christie 21369c19a7d0SMike Christie static void iscsi_prep_abort_task_pdu(struct iscsi_task *task, 2137843c0a8aSMike Christie struct iscsi_tm *hdr) 2138843c0a8aSMike Christie { 2139843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2140843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2141843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK; 2142843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 214355bdabdfSAndy Grover hdr->lun = task->lun; 2144577577daSMike Christie hdr->rtt = task->hdr_itt; 2145577577daSMike Christie hdr->refcmdsn = task->cmdsn; 2146843c0a8aSMike Christie } 2147843c0a8aSMike Christie 21487996a778SMike Christie int iscsi_eh_abort(struct scsi_cmnd *sc) 21497996a778SMike Christie { 215075613521SMike Christie struct iscsi_cls_session *cls_session; 215175613521SMike Christie struct iscsi_session *session; 2152f47f2cf5SMike Christie struct iscsi_conn *conn; 21539c19a7d0SMike Christie struct iscsi_task *task; 2154843c0a8aSMike Christie struct iscsi_tm *hdr; 2155e9e410e8SBart Van Assche int age; 21567996a778SMike Christie 215775613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 215875613521SMike Christie session = cls_session->dd_data; 215975613521SMike Christie 2160bd2199d4SErez Zilber ISCSI_DBG_EH(session, "aborting sc %p\n", sc); 21614421c9ebSMike Christie 21626724add1SMike Christie mutex_lock(&session->eh_mutex); 2163659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2164f47f2cf5SMike Christie /* 2165f47f2cf5SMike Christie * if session was ISCSI_STATE_IN_RECOVERY then we may not have 2166f47f2cf5SMike Christie * got the command. 2167f47f2cf5SMike Christie */ 2168f47f2cf5SMike Christie if (!sc->SCp.ptr) { 2169bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc never reached iscsi layer or " 21701b2c7af8SMike Christie "it completed.\n"); 2171659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 21726724add1SMike Christie mutex_unlock(&session->eh_mutex); 2173f47f2cf5SMike Christie return SUCCESS; 2174f47f2cf5SMike Christie } 2175f47f2cf5SMike Christie 21767996a778SMike Christie /* 21777996a778SMike Christie * If we are not logged in or we have started a new session 21787996a778SMike Christie * then let the host reset code handle this 21797996a778SMike Christie */ 2180843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN || 2181843c0a8aSMike Christie sc->SCp.phase != session->age) { 2182659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2183843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2184bd2199d4SErez Zilber ISCSI_DBG_EH(session, "failing abort due to dropped " 21854421c9ebSMike Christie "session.\n"); 2186843c0a8aSMike Christie return FAILED; 2187843c0a8aSMike Christie } 2188843c0a8aSMike Christie 2189843c0a8aSMike Christie conn = session->leadconn; 2190843c0a8aSMike Christie conn->eh_abort_cnt++; 2191843c0a8aSMike Christie age = session->age; 2192843c0a8aSMike Christie 21939c19a7d0SMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 2194bd2199d4SErez Zilber ISCSI_DBG_EH(session, "aborting [sc %p itt 0x%x]\n", 21951b2c7af8SMike Christie sc, task->itt); 21967996a778SMike Christie 21979c19a7d0SMike Christie /* task completed before time out */ 21989c19a7d0SMike Christie if (!task->sc) { 2199bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in progress\n"); 220077a23c21SMike Christie goto success; 22017ea8b828SMike Christie } 22027996a778SMike Christie 22039c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) { 2204b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 220577a23c21SMike Christie goto success; 220677a23c21SMike Christie } 22077996a778SMike Christie 2208843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2209843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 22107996a778SMike Christie goto failed; 2211843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 22127996a778SMike Christie 2213843c0a8aSMike Christie hdr = &conn->tmhdr; 22149c19a7d0SMike Christie iscsi_prep_abort_task_pdu(task, hdr); 2215843c0a8aSMike Christie 2216e9e410e8SBart Van Assche if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) 2217843c0a8aSMike Christie goto failed; 2218843c0a8aSMike Christie 2219843c0a8aSMike Christie switch (conn->tmf_state) { 2220843c0a8aSMike Christie case TMF_SUCCESS: 2221659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2222913e5bf4SMike Christie /* 2223913e5bf4SMike Christie * stop tx side incase the target had sent a abort rsp but 2224913e5bf4SMike Christie * the initiator was still writing out data. 2225913e5bf4SMike Christie */ 22266724add1SMike Christie iscsi_suspend_tx(conn); 22277996a778SMike Christie /* 2228913e5bf4SMike Christie * we do not stop the recv side because targets have been 2229913e5bf4SMike Christie * good and have never sent us a successful tmf response 2230913e5bf4SMike Christie * then sent more data for the cmd. 22317996a778SMike Christie */ 2232659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2233b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 2234843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 22355d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 2236659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 22376724add1SMike Christie iscsi_start_tx(conn); 223877a23c21SMike Christie goto success_unlocked; 2239843c0a8aSMike Christie case TMF_TIMEDOUT: 2240659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2241df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2242843c0a8aSMike Christie goto failed_unlocked; 2243843c0a8aSMike Christie case TMF_NOT_FOUND: 2244843c0a8aSMike Christie if (!sc->SCp.ptr) { 2245843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 22465d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 22479c19a7d0SMike Christie /* task completed before tmf abort response */ 2248bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in " 2249bd2199d4SErez Zilber "progress\n"); 225077a23c21SMike Christie goto success; 225177a23c21SMike Christie } 225277a23c21SMike Christie /* fall through */ 225377a23c21SMike Christie default: 2254843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2255843c0a8aSMike Christie goto failed; 225677a23c21SMike Christie } 22577996a778SMike Christie 225877a23c21SMike Christie success: 2259659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 226077a23c21SMike Christie success_unlocked: 2261bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n", 22621b2c7af8SMike Christie sc, task->itt); 22636724add1SMike Christie mutex_unlock(&session->eh_mutex); 22647996a778SMike Christie return SUCCESS; 22657996a778SMike Christie 22667996a778SMike Christie failed: 2267659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 226877a23c21SMike Christie failed_unlocked: 2269bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc, 22709c19a7d0SMike Christie task ? task->itt : 0); 22716724add1SMike Christie mutex_unlock(&session->eh_mutex); 22727996a778SMike Christie return FAILED; 22737996a778SMike Christie } 22747996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_abort); 22757996a778SMike Christie 2276843c0a8aSMike Christie static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 2277843c0a8aSMike Christie { 2278843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2279843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2280843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK; 2281843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 228255bdabdfSAndy Grover int_to_scsilun(sc->device->lun, &hdr->lun); 2283f6d5180cSMike Christie hdr->rtt = RESERVED_ITT; 2284843c0a8aSMike Christie } 2285843c0a8aSMike Christie 2286843c0a8aSMike Christie int iscsi_eh_device_reset(struct scsi_cmnd *sc) 2287843c0a8aSMike Christie { 228875613521SMike Christie struct iscsi_cls_session *cls_session; 228975613521SMike Christie struct iscsi_session *session; 2290843c0a8aSMike Christie struct iscsi_conn *conn; 2291843c0a8aSMike Christie struct iscsi_tm *hdr; 2292843c0a8aSMike Christie int rc = FAILED; 2293843c0a8aSMike Christie 229475613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 229575613521SMike Christie session = cls_session->dd_data; 229675613521SMike Christie 22979cb78c16SHannes Reinecke ISCSI_DBG_EH(session, "LU Reset [sc %p lun %llu]\n", sc, 22989cb78c16SHannes Reinecke sc->device->lun); 2299843c0a8aSMike Christie 2300843c0a8aSMike Christie mutex_lock(&session->eh_mutex); 2301659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2302843c0a8aSMike Christie /* 2303843c0a8aSMike Christie * Just check if we are not logged in. We cannot check for 2304843c0a8aSMike Christie * the phase because the reset could come from a ioctl. 2305843c0a8aSMike Christie */ 2306843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 2307843c0a8aSMike Christie goto unlock; 2308843c0a8aSMike Christie conn = session->leadconn; 2309843c0a8aSMike Christie 2310843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2311843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 2312843c0a8aSMike Christie goto unlock; 2313843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 2314843c0a8aSMike Christie 2315843c0a8aSMike Christie hdr = &conn->tmhdr; 2316843c0a8aSMike Christie iscsi_prep_lun_reset_pdu(sc, hdr); 2317843c0a8aSMike Christie 23189c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 2319f6d5180cSMike Christie session->lu_reset_timeout)) { 2320843c0a8aSMike Christie rc = FAILED; 2321843c0a8aSMike Christie goto unlock; 2322843c0a8aSMike Christie } 2323843c0a8aSMike Christie 2324843c0a8aSMike Christie switch (conn->tmf_state) { 2325843c0a8aSMike Christie case TMF_SUCCESS: 2326843c0a8aSMike Christie break; 2327843c0a8aSMike Christie case TMF_TIMEDOUT: 2328659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2329df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2330843c0a8aSMike Christie goto done; 2331843c0a8aSMike Christie default: 2332843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2333843c0a8aSMike Christie goto unlock; 2334843c0a8aSMike Christie } 2335843c0a8aSMike Christie 2336843c0a8aSMike Christie rc = SUCCESS; 2337659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2338843c0a8aSMike Christie 2339843c0a8aSMike Christie iscsi_suspend_tx(conn); 2340913e5bf4SMike Christie 2341659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 23425d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 23433bbaaad9SMike Christie fail_scsi_tasks(conn, sc->device->lun, DID_ERROR); 2344843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2345659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2346843c0a8aSMike Christie 2347843c0a8aSMike Christie iscsi_start_tx(conn); 2348843c0a8aSMike Christie goto done; 2349843c0a8aSMike Christie 2350843c0a8aSMike Christie unlock: 2351659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2352843c0a8aSMike Christie done: 2353bd2199d4SErez Zilber ISCSI_DBG_EH(session, "dev reset result = %s\n", 2354843c0a8aSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 2355843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2356843c0a8aSMike Christie return rc; 2357843c0a8aSMike Christie } 2358843c0a8aSMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_device_reset); 2359843c0a8aSMike Christie 23603fe5ae8bSMike Christie void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) 23613fe5ae8bSMike Christie { 23623fe5ae8bSMike Christie struct iscsi_session *session = cls_session->dd_data; 23633fe5ae8bSMike Christie 2364659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 23653fe5ae8bSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 23663fe5ae8bSMike Christie session->state = ISCSI_STATE_RECOVERY_FAILED; 23673fe5ae8bSMike Christie if (session->leadconn) 23683fe5ae8bSMike Christie wake_up(&session->leadconn->ehwait); 23693fe5ae8bSMike Christie } 2370659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 23713fe5ae8bSMike Christie } 23723fe5ae8bSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout); 23733fe5ae8bSMike Christie 23743fe5ae8bSMike Christie /** 23753fe5ae8bSMike Christie * iscsi_eh_session_reset - drop session and attempt relogin 23763fe5ae8bSMike Christie * @sc: scsi command 23773fe5ae8bSMike Christie * 23783fe5ae8bSMike Christie * This function will wait for a relogin, session termination from 23793fe5ae8bSMike Christie * userspace, or a recovery/replacement timeout. 23803fe5ae8bSMike Christie */ 2381309ce156SJayamohan Kallickal int iscsi_eh_session_reset(struct scsi_cmnd *sc) 23823fe5ae8bSMike Christie { 23833fe5ae8bSMike Christie struct iscsi_cls_session *cls_session; 23843fe5ae8bSMike Christie struct iscsi_session *session; 23853fe5ae8bSMike Christie struct iscsi_conn *conn; 23863fe5ae8bSMike Christie 23873fe5ae8bSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 23883fe5ae8bSMike Christie session = cls_session->dd_data; 23893fe5ae8bSMike Christie conn = session->leadconn; 23903fe5ae8bSMike Christie 23913fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2392659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 23933fe5ae8bSMike Christie if (session->state == ISCSI_STATE_TERMINATE) { 23943fe5ae8bSMike Christie failed: 23953fe5ae8bSMike Christie ISCSI_DBG_EH(session, 23963fe5ae8bSMike Christie "failing session reset: Could not log back into " 23973fe5ae8bSMike Christie "%s, %s [age %d]\n", session->targetname, 23983fe5ae8bSMike Christie conn->persistent_address, session->age); 2399659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 24003fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 24013fe5ae8bSMike Christie return FAILED; 24023fe5ae8bSMike Christie } 24033fe5ae8bSMike Christie 2404659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 24053fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 24063fe5ae8bSMike Christie /* 24073fe5ae8bSMike Christie * we drop the lock here but the leadconn cannot be destoyed while 24083fe5ae8bSMike Christie * we are in the scsi eh 24093fe5ae8bSMike Christie */ 2410df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 24113fe5ae8bSMike Christie 24123fe5ae8bSMike Christie ISCSI_DBG_EH(session, "wait for relogin\n"); 24133fe5ae8bSMike Christie wait_event_interruptible(conn->ehwait, 24143fe5ae8bSMike Christie session->state == ISCSI_STATE_TERMINATE || 24153fe5ae8bSMike Christie session->state == ISCSI_STATE_LOGGED_IN || 24163fe5ae8bSMike Christie session->state == ISCSI_STATE_RECOVERY_FAILED); 24173fe5ae8bSMike Christie if (signal_pending(current)) 24183fe5ae8bSMike Christie flush_signals(current); 24193fe5ae8bSMike Christie 24203fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2421659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 24223fe5ae8bSMike Christie if (session->state == ISCSI_STATE_LOGGED_IN) { 24233fe5ae8bSMike Christie ISCSI_DBG_EH(session, 24243fe5ae8bSMike Christie "session reset succeeded for %s,%s\n", 24253fe5ae8bSMike Christie session->targetname, conn->persistent_address); 24263fe5ae8bSMike Christie } else 24273fe5ae8bSMike Christie goto failed; 2428659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 24293fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 24303fe5ae8bSMike Christie return SUCCESS; 24313fe5ae8bSMike Christie } 2432309ce156SJayamohan Kallickal EXPORT_SYMBOL_GPL(iscsi_eh_session_reset); 24333fe5ae8bSMike Christie 24343fe5ae8bSMike Christie static void iscsi_prep_tgt_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 24353fe5ae8bSMike Christie { 24363fe5ae8bSMike Christie memset(hdr, 0, sizeof(*hdr)); 24373fe5ae8bSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 24383fe5ae8bSMike Christie hdr->flags = ISCSI_TM_FUNC_TARGET_WARM_RESET & ISCSI_FLAG_TM_FUNC_MASK; 24393fe5ae8bSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 24403fe5ae8bSMike Christie hdr->rtt = RESERVED_ITT; 24413fe5ae8bSMike Christie } 24423fe5ae8bSMike Christie 24433fe5ae8bSMike Christie /** 24443fe5ae8bSMike Christie * iscsi_eh_target_reset - reset target 24453fe5ae8bSMike Christie * @sc: scsi command 24463fe5ae8bSMike Christie * 2447309ce156SJayamohan Kallickal * This will attempt to send a warm target reset. 24483fe5ae8bSMike Christie */ 24493907adf6SBart Van Assche static int iscsi_eh_target_reset(struct scsi_cmnd *sc) 24503fe5ae8bSMike Christie { 24513fe5ae8bSMike Christie struct iscsi_cls_session *cls_session; 24523fe5ae8bSMike Christie struct iscsi_session *session; 24533fe5ae8bSMike Christie struct iscsi_conn *conn; 24543fe5ae8bSMike Christie struct iscsi_tm *hdr; 24553fe5ae8bSMike Christie int rc = FAILED; 24563fe5ae8bSMike Christie 24573fe5ae8bSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 24583fe5ae8bSMike Christie session = cls_session->dd_data; 24593fe5ae8bSMike Christie 24603fe5ae8bSMike Christie ISCSI_DBG_EH(session, "tgt Reset [sc %p tgt %s]\n", sc, 24613fe5ae8bSMike Christie session->targetname); 24623fe5ae8bSMike Christie 24633fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2464659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 24653fe5ae8bSMike Christie /* 24663fe5ae8bSMike Christie * Just check if we are not logged in. We cannot check for 24673fe5ae8bSMike Christie * the phase because the reset could come from a ioctl. 24683fe5ae8bSMike Christie */ 24693fe5ae8bSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 24703fe5ae8bSMike Christie goto unlock; 24713fe5ae8bSMike Christie conn = session->leadconn; 24723fe5ae8bSMike Christie 24733fe5ae8bSMike Christie /* only have one tmf outstanding at a time */ 24743fe5ae8bSMike Christie if (conn->tmf_state != TMF_INITIAL) 24753fe5ae8bSMike Christie goto unlock; 24763fe5ae8bSMike Christie conn->tmf_state = TMF_QUEUED; 24773fe5ae8bSMike Christie 24783fe5ae8bSMike Christie hdr = &conn->tmhdr; 24793fe5ae8bSMike Christie iscsi_prep_tgt_reset_pdu(sc, hdr); 24803fe5ae8bSMike Christie 24813fe5ae8bSMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 24823fe5ae8bSMike Christie session->tgt_reset_timeout)) { 24833fe5ae8bSMike Christie rc = FAILED; 24843fe5ae8bSMike Christie goto unlock; 24853fe5ae8bSMike Christie } 24863fe5ae8bSMike Christie 24873fe5ae8bSMike Christie switch (conn->tmf_state) { 24883fe5ae8bSMike Christie case TMF_SUCCESS: 24893fe5ae8bSMike Christie break; 24903fe5ae8bSMike Christie case TMF_TIMEDOUT: 2491659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2492df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 24933fe5ae8bSMike Christie goto done; 24943fe5ae8bSMike Christie default: 24953fe5ae8bSMike Christie conn->tmf_state = TMF_INITIAL; 24963fe5ae8bSMike Christie goto unlock; 24973fe5ae8bSMike Christie } 24983fe5ae8bSMike Christie 24993fe5ae8bSMike Christie rc = SUCCESS; 2500659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 25013fe5ae8bSMike Christie 25023fe5ae8bSMike Christie iscsi_suspend_tx(conn); 25033fe5ae8bSMike Christie 2504659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 25053fe5ae8bSMike Christie memset(hdr, 0, sizeof(*hdr)); 25063fe5ae8bSMike Christie fail_scsi_tasks(conn, -1, DID_ERROR); 25073fe5ae8bSMike Christie conn->tmf_state = TMF_INITIAL; 2508659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 25093fe5ae8bSMike Christie 25103fe5ae8bSMike Christie iscsi_start_tx(conn); 25113fe5ae8bSMike Christie goto done; 25123fe5ae8bSMike Christie 25133fe5ae8bSMike Christie unlock: 2514659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 25153fe5ae8bSMike Christie done: 25163fe5ae8bSMike Christie ISCSI_DBG_EH(session, "tgt %s reset result = %s\n", session->targetname, 25173fe5ae8bSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 25183fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 2519309ce156SJayamohan Kallickal return rc; 2520309ce156SJayamohan Kallickal } 25213fe5ae8bSMike Christie 2522309ce156SJayamohan Kallickal /** 2523309ce156SJayamohan Kallickal * iscsi_eh_recover_target - reset target and possibly the session 2524309ce156SJayamohan Kallickal * @sc: scsi command 2525309ce156SJayamohan Kallickal * 2526309ce156SJayamohan Kallickal * This will attempt to send a warm target reset. If that fails, 2527309ce156SJayamohan Kallickal * we will escalate to ERL0 session recovery. 2528309ce156SJayamohan Kallickal */ 2529309ce156SJayamohan Kallickal int iscsi_eh_recover_target(struct scsi_cmnd *sc) 2530309ce156SJayamohan Kallickal { 2531309ce156SJayamohan Kallickal int rc; 2532309ce156SJayamohan Kallickal 2533309ce156SJayamohan Kallickal rc = iscsi_eh_target_reset(sc); 25343fe5ae8bSMike Christie if (rc == FAILED) 25353fe5ae8bSMike Christie rc = iscsi_eh_session_reset(sc); 25363fe5ae8bSMike Christie return rc; 25373fe5ae8bSMike Christie } 2538309ce156SJayamohan Kallickal EXPORT_SYMBOL_GPL(iscsi_eh_recover_target); 25393fe5ae8bSMike Christie 25406320377fSOlaf Kirch /* 25416320377fSOlaf Kirch * Pre-allocate a pool of @max items of @item_size. By default, the pool 25426320377fSOlaf Kirch * should be accessed via kfifo_{get,put} on q->queue. 25436320377fSOlaf Kirch * Optionally, the caller can obtain the array of object pointers 25446320377fSOlaf Kirch * by passing in a non-NULL @items pointer 25456320377fSOlaf Kirch */ 25467996a778SMike Christie int 25476320377fSOlaf Kirch iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size) 25487996a778SMike Christie { 25496320377fSOlaf Kirch int i, num_arrays = 1; 25507996a778SMike Christie 25516320377fSOlaf Kirch memset(q, 0, sizeof(*q)); 25527996a778SMike Christie 25537996a778SMike Christie q->max = max; 25546320377fSOlaf Kirch 25556320377fSOlaf Kirch /* If the user passed an items pointer, he wants a copy of 25566320377fSOlaf Kirch * the array. */ 25576320377fSOlaf Kirch if (items) 25586320377fSOlaf Kirch num_arrays++; 2559bfcc62edSKyle Fortin q->pool = kvzalloc(num_arrays * max * sizeof(void*), GFP_KERNEL); 25606320377fSOlaf Kirch if (q->pool == NULL) 2561f474a37bSJean Delvare return -ENOMEM; 25627996a778SMike Christie 2563c1e13f25SStefani Seibold kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*)); 25647996a778SMike Christie 25657996a778SMike Christie for (i = 0; i < max; i++) { 25666320377fSOlaf Kirch q->pool[i] = kzalloc(item_size, GFP_KERNEL); 25677996a778SMike Christie if (q->pool[i] == NULL) { 25686320377fSOlaf Kirch q->max = i; 25696320377fSOlaf Kirch goto enomem; 25707996a778SMike Christie } 25717acd72ebSStefani Seibold kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*)); 25727996a778SMike Christie } 25736320377fSOlaf Kirch 25746320377fSOlaf Kirch if (items) { 25756320377fSOlaf Kirch *items = q->pool + max; 25766320377fSOlaf Kirch memcpy(*items, q->pool, max * sizeof(void *)); 25776320377fSOlaf Kirch } 25786320377fSOlaf Kirch 25797996a778SMike Christie return 0; 25806320377fSOlaf Kirch 25816320377fSOlaf Kirch enomem: 25826320377fSOlaf Kirch iscsi_pool_free(q); 25836320377fSOlaf Kirch return -ENOMEM; 25847996a778SMike Christie } 25857996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_init); 25867996a778SMike Christie 25876320377fSOlaf Kirch void iscsi_pool_free(struct iscsi_pool *q) 25887996a778SMike Christie { 25897996a778SMike Christie int i; 25907996a778SMike Christie 25917996a778SMike Christie for (i = 0; i < q->max; i++) 25926320377fSOlaf Kirch kfree(q->pool[i]); 2593bfcc62edSKyle Fortin kvfree(q->pool); 25947996a778SMike Christie } 25957996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_free); 25967996a778SMike Christie 2597a4804cd6SMike Christie /** 2598a4804cd6SMike Christie * iscsi_host_add - add host to system 2599a4804cd6SMike Christie * @shost: scsi host 2600a4804cd6SMike Christie * @pdev: parent device 2601a4804cd6SMike Christie * 2602a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers 2603a4804cd6SMike Christie * to add a host to the system. 2604a4804cd6SMike Christie */ 2605a4804cd6SMike Christie int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev) 26067996a778SMike Christie { 26078e9a20ceSMike Christie if (!shost->can_queue) 26088e9a20ceSMike Christie shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX; 26098e9a20ceSMike Christie 26104d108350SMike Christie if (!shost->cmd_per_lun) 26114d108350SMike Christie shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN; 26124d108350SMike Christie 2613a4804cd6SMike Christie return scsi_add_host(shost, pdev); 2614a4804cd6SMike Christie } 2615a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_add); 2616a4804cd6SMike Christie 2617a4804cd6SMike Christie /** 2618a4804cd6SMike Christie * iscsi_host_alloc - allocate a host and driver data 2619a4804cd6SMike Christie * @sht: scsi host template 2620a4804cd6SMike Christie * @dd_data_size: driver host data size 262132ae763eSMike Christie * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue 2622a4804cd6SMike Christie * 2623a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers. 2624a4804cd6SMike Christie * To access the driver specific memory use the iscsi_host_priv() macro. 2625a4804cd6SMike Christie */ 2626a4804cd6SMike Christie struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht, 26274d108350SMike Christie int dd_data_size, bool xmit_can_sleep) 2628a4804cd6SMike Christie { 2629a4804cd6SMike Christie struct Scsi_Host *shost; 2630e5bd7b54SMike Christie struct iscsi_host *ihost; 2631a4804cd6SMike Christie 2632a4804cd6SMike Christie shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size); 2633a4804cd6SMike Christie if (!shost) 2634a4804cd6SMike Christie return NULL; 2635e5bd7b54SMike Christie ihost = shost_priv(shost); 263632ae763eSMike Christie 263732ae763eSMike Christie if (xmit_can_sleep) { 263832ae763eSMike Christie snprintf(ihost->workq_name, sizeof(ihost->workq_name), 263932ae763eSMike Christie "iscsi_q_%d", shost->host_no); 264032ae763eSMike Christie ihost->workq = create_singlethread_workqueue(ihost->workq_name); 264132ae763eSMike Christie if (!ihost->workq) 264232ae763eSMike Christie goto free_host; 264332ae763eSMike Christie } 264432ae763eSMike Christie 2645e5bd7b54SMike Christie spin_lock_init(&ihost->lock); 2646e5bd7b54SMike Christie ihost->state = ISCSI_HOST_SETUP; 2647e5bd7b54SMike Christie ihost->num_sessions = 0; 2648e5bd7b54SMike Christie init_waitqueue_head(&ihost->session_removal_wq); 2649a4804cd6SMike Christie return shost; 265032ae763eSMike Christie 265132ae763eSMike Christie free_host: 265232ae763eSMike Christie scsi_host_put(shost); 265332ae763eSMike Christie return NULL; 265475613521SMike Christie } 2655a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_alloc); 265675613521SMike Christie 2657e5bd7b54SMike Christie static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session) 2658e5bd7b54SMike Christie { 265940a06e75SMike Christie iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST); 2660e5bd7b54SMike Christie } 2661e5bd7b54SMike Christie 2662a4804cd6SMike Christie /** 2663a4804cd6SMike Christie * iscsi_host_remove - remove host and sessions 2664a4804cd6SMike Christie * @shost: scsi host 2665a4804cd6SMike Christie * 2666e5bd7b54SMike Christie * If there are any sessions left, this will initiate the removal and wait 2667e5bd7b54SMike Christie * for the completion. 2668a4804cd6SMike Christie */ 2669a4804cd6SMike Christie void iscsi_host_remove(struct Scsi_Host *shost) 2670a4804cd6SMike Christie { 2671e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2672e5bd7b54SMike Christie unsigned long flags; 2673e5bd7b54SMike Christie 2674e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2675e5bd7b54SMike Christie ihost->state = ISCSI_HOST_REMOVED; 2676e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2677e5bd7b54SMike Christie 2678e5bd7b54SMike Christie iscsi_host_for_each_session(shost, iscsi_notify_host_removed); 2679e5bd7b54SMike Christie wait_event_interruptible(ihost->session_removal_wq, 2680e5bd7b54SMike Christie ihost->num_sessions == 0); 2681e5bd7b54SMike Christie if (signal_pending(current)) 2682e5bd7b54SMike Christie flush_signals(current); 2683e5bd7b54SMike Christie 2684a4804cd6SMike Christie scsi_remove_host(shost); 268532ae763eSMike Christie if (ihost->workq) 268632ae763eSMike Christie destroy_workqueue(ihost->workq); 2687a4804cd6SMike Christie } 2688a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_remove); 2689a4804cd6SMike Christie 2690a4804cd6SMike Christie void iscsi_host_free(struct Scsi_Host *shost) 269175613521SMike Christie { 269275613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 269375613521SMike Christie 269475613521SMike Christie kfree(ihost->netdev); 269575613521SMike Christie kfree(ihost->hwaddress); 269675613521SMike Christie kfree(ihost->initiatorname); 2697a4804cd6SMike Christie scsi_host_put(shost); 269875613521SMike Christie } 2699a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_free); 270075613521SMike Christie 2701e5bd7b54SMike Christie static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost) 2702e5bd7b54SMike Christie { 2703e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2704e5bd7b54SMike Christie unsigned long flags; 2705e5bd7b54SMike Christie 2706e5bd7b54SMike Christie shost = scsi_host_get(shost); 2707e5bd7b54SMike Christie if (!shost) { 2708e5bd7b54SMike Christie printk(KERN_ERR "Invalid state. Cannot notify host removal " 2709e5bd7b54SMike Christie "of session teardown event because host already " 2710e5bd7b54SMike Christie "removed.\n"); 2711e5bd7b54SMike Christie return; 2712e5bd7b54SMike Christie } 2713e5bd7b54SMike Christie 2714e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2715e5bd7b54SMike Christie ihost->num_sessions--; 2716e5bd7b54SMike Christie if (ihost->num_sessions == 0) 2717e5bd7b54SMike Christie wake_up(&ihost->session_removal_wq); 2718e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2719e5bd7b54SMike Christie scsi_host_put(shost); 2720e5bd7b54SMike Christie } 2721e5bd7b54SMike Christie 272275613521SMike Christie /** 272375613521SMike Christie * iscsi_session_setup - create iscsi cls session and host and session 272475613521SMike Christie * @iscsit: iscsi transport template 272575613521SMike Christie * @shost: scsi host 272675613521SMike Christie * @cmds_max: session can queue 27279c19a7d0SMike Christie * @cmd_task_size: LLD task private data size 272875613521SMike Christie * @initial_cmdsn: initial CmdSN 272975613521SMike Christie * 273075613521SMike Christie * This can be used by software iscsi_transports that allocate 273175613521SMike Christie * a session per scsi host. 27323cf7b233SMike Christie * 27333cf7b233SMike Christie * Callers should set cmds_max to the largest total numer (mgmt + scsi) of 27343cf7b233SMike Christie * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks 27353cf7b233SMike Christie * for nop handling and login/logout requests. 273675613521SMike Christie */ 273775613521SMike Christie struct iscsi_cls_session * 273875613521SMike Christie iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, 2739b8b9e1b8SJayamohan Kallickal uint16_t cmds_max, int dd_size, int cmd_task_size, 27407970634bSMike Christie uint32_t initial_cmdsn, unsigned int id) 274175613521SMike Christie { 2742e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 274375613521SMike Christie struct iscsi_session *session; 274475613521SMike Christie struct iscsi_cls_session *cls_session; 27453cf7b233SMike Christie int cmd_i, scsi_cmds, total_cmds = cmds_max; 2746e5bd7b54SMike Christie unsigned long flags; 2747e5bd7b54SMike Christie 2748e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2749e5bd7b54SMike Christie if (ihost->state == ISCSI_HOST_REMOVED) { 2750e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2751e5bd7b54SMike Christie return NULL; 2752e5bd7b54SMike Christie } 2753e5bd7b54SMike Christie ihost->num_sessions++; 2754e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 27558e9a20ceSMike Christie 27568e9a20ceSMike Christie if (!total_cmds) 27578e9a20ceSMike Christie total_cmds = ISCSI_DEF_XMIT_CMDS_MAX; 27583e5c28adSMike Christie /* 27593cf7b233SMike Christie * The iscsi layer needs some tasks for nop handling and tmfs, 27603cf7b233SMike Christie * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX 27613cf7b233SMike Christie * + 1 command for scsi IO. 27623e5c28adSMike Christie */ 27633cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 27643cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 27653cf7b233SMike Christie "must be a power of two that is at least %d.\n", 27663cf7b233SMike Christie total_cmds, ISCSI_TOTAL_CMDS_MIN); 2767e5bd7b54SMike Christie goto dec_session_count; 27681548271eSMike Christie } 27693cf7b233SMike Christie 27703cf7b233SMike Christie if (total_cmds > ISCSI_TOTAL_CMDS_MAX) { 27713cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 27723cf7b233SMike Christie "must be a power of 2 less than or equal to %d.\n", 27733cf7b233SMike Christie cmds_max, ISCSI_TOTAL_CMDS_MAX); 27743cf7b233SMike Christie total_cmds = ISCSI_TOTAL_CMDS_MAX; 27753cf7b233SMike Christie } 27763cf7b233SMike Christie 27773cf7b233SMike Christie if (!is_power_of_2(total_cmds)) { 27783cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 27793cf7b233SMike Christie "must be a power of 2.\n", total_cmds); 27803cf7b233SMike Christie total_cmds = rounddown_pow_of_two(total_cmds); 27813cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) 27823cf7b233SMike Christie return NULL; 27833cf7b233SMike Christie printk(KERN_INFO "iscsi: Rounding can_queue to %d.\n", 27843cf7b233SMike Christie total_cmds); 27853cf7b233SMike Christie } 27863cf7b233SMike Christie scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX; 27871548271eSMike Christie 27885d91e209SMike Christie cls_session = iscsi_alloc_session(shost, iscsit, 2789b8b9e1b8SJayamohan Kallickal sizeof(struct iscsi_session) + 2790b8b9e1b8SJayamohan Kallickal dd_size); 279175613521SMike Christie if (!cls_session) 2792e5bd7b54SMike Christie goto dec_session_count; 279375613521SMike Christie session = cls_session->dd_data; 279475613521SMike Christie session->cls_session = cls_session; 27957996a778SMike Christie session->host = shost; 27967996a778SMike Christie session->state = ISCSI_STATE_FREE; 2797f6d5180cSMike Christie session->fast_abort = 1; 27983fe5ae8bSMike Christie session->tgt_reset_timeout = 30; 27994cd49ea1SMike Christie session->lu_reset_timeout = 15; 28004cd49ea1SMike Christie session->abort_timeout = 10; 28013cf7b233SMike Christie session->scsi_cmds_max = scsi_cmds; 28023cf7b233SMike Christie session->cmds_max = total_cmds; 2803e0726407SMike Christie session->queued_cmdsn = session->cmdsn = initial_cmdsn; 28047996a778SMike Christie session->exp_cmdsn = initial_cmdsn + 1; 28057996a778SMike Christie session->max_cmdsn = initial_cmdsn + 1; 28067996a778SMike Christie session->max_r2t = 1; 28077996a778SMike Christie session->tt = iscsit; 2808b8b9e1b8SJayamohan Kallickal session->dd_data = cls_session->dd_data + sizeof(*session); 2809659743b0SShlomo Pongratz 28106724add1SMike Christie mutex_init(&session->eh_mutex); 2811659743b0SShlomo Pongratz spin_lock_init(&session->frwd_lock); 2812659743b0SShlomo Pongratz spin_lock_init(&session->back_lock); 28137996a778SMike Christie 28147996a778SMike Christie /* initialize SCSI PDU commands pool */ 28157996a778SMike Christie if (iscsi_pool_init(&session->cmdpool, session->cmds_max, 28167996a778SMike Christie (void***)&session->cmds, 28179c19a7d0SMike Christie cmd_task_size + sizeof(struct iscsi_task))) 28187996a778SMike Christie goto cmdpool_alloc_fail; 28197996a778SMike Christie 28207996a778SMike Christie /* pre-format cmds pool with ITT */ 28217996a778SMike Christie for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) { 28229c19a7d0SMike Christie struct iscsi_task *task = session->cmds[cmd_i]; 28237996a778SMike Christie 28249c19a7d0SMike Christie if (cmd_task_size) 28259c19a7d0SMike Christie task->dd_data = &task[1]; 28269c19a7d0SMike Christie task->itt = cmd_i; 28273bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 28289c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 28297996a778SMike Christie } 28307996a778SMike Christie 2831f53a88daSMike Christie if (!try_module_get(iscsit->owner)) 283275613521SMike Christie goto module_get_fail; 283375613521SMike Christie 28347970634bSMike Christie if (iscsi_add_session(cls_session, id)) 2835f53a88daSMike Christie goto cls_session_fail; 2836e5bd7b54SMike Christie 28377996a778SMike Christie return cls_session; 28387996a778SMike Christie 28397996a778SMike Christie cls_session_fail: 284075613521SMike Christie module_put(iscsit->owner); 284175613521SMike Christie module_get_fail: 28426320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 28437996a778SMike Christie cmdpool_alloc_fail: 284475613521SMike Christie iscsi_free_session(cls_session); 2845e5bd7b54SMike Christie dec_session_count: 2846e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 28477996a778SMike Christie return NULL; 28487996a778SMike Christie } 28497996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_setup); 28507996a778SMike Christie 28517996a778SMike Christie /** 28527996a778SMike Christie * iscsi_session_teardown - destroy session, host, and cls_session 285375613521SMike Christie * @cls_session: iscsi session 285475613521SMike Christie */ 28557996a778SMike Christie void iscsi_session_teardown(struct iscsi_cls_session *cls_session) 28567996a778SMike Christie { 285775613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 285863f75cc8SMike Christie struct module *owner = cls_session->transport->owner; 2859e5bd7b54SMike Christie struct Scsi_Host *shost = session->host; 28607996a778SMike Christie 28616320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 28627996a778SMike Christie 28639e10b512SKhazhismel Kumykov iscsi_remove_session(cls_session); 28649e10b512SKhazhismel Kumykov 2865b2c64167SMike Christie kfree(session->password); 2866b2c64167SMike Christie kfree(session->password_in); 2867b2c64167SMike Christie kfree(session->username); 2868b2c64167SMike Christie kfree(session->username_in); 2869f3ff0c36SMike Christie kfree(session->targetname); 28703c5c4801SVikas Chaudhary kfree(session->targetalias); 287188dfd340SMike Christie kfree(session->initiatorname); 28723b9373e9SEddie Wai kfree(session->boot_root); 28733b9373e9SEddie Wai kfree(session->boot_nic); 28743b9373e9SEddie Wai kfree(session->boot_target); 287588dfd340SMike Christie kfree(session->ifacename); 2876f8525eb4SAdheer Chandravanshi kfree(session->portal_type); 2877f8525eb4SAdheer Chandravanshi kfree(session->discovery_parent_type); 2878f3ff0c36SMike Christie 28799e10b512SKhazhismel Kumykov iscsi_free_session(cls_session); 28809e10b512SKhazhismel Kumykov 2881e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 288263f75cc8SMike Christie module_put(owner); 28837996a778SMike Christie } 28847996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_teardown); 28857996a778SMike Christie 28867996a778SMike Christie /** 28877996a778SMike Christie * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn 28887996a778SMike Christie * @cls_session: iscsi_cls_session 28895d91e209SMike Christie * @dd_size: private driver data size 28907996a778SMike Christie * @conn_idx: cid 28915d91e209SMike Christie */ 28927996a778SMike Christie struct iscsi_cls_conn * 28935d91e209SMike Christie iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, 28945d91e209SMike Christie uint32_t conn_idx) 28957996a778SMike Christie { 289675613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 28977996a778SMike Christie struct iscsi_conn *conn; 28987996a778SMike Christie struct iscsi_cls_conn *cls_conn; 2899d36ab6f3SMike Christie char *data; 29007996a778SMike Christie 29015d91e209SMike Christie cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size, 29025d91e209SMike Christie conn_idx); 29037996a778SMike Christie if (!cls_conn) 29047996a778SMike Christie return NULL; 29057996a778SMike Christie conn = cls_conn->dd_data; 29065d91e209SMike Christie memset(conn, 0, sizeof(*conn) + dd_size); 29077996a778SMike Christie 29085d91e209SMike Christie conn->dd_data = cls_conn->dd_data + sizeof(*conn); 29097996a778SMike Christie conn->session = session; 29107996a778SMike Christie conn->cls_conn = cls_conn; 29117996a778SMike Christie conn->c_stage = ISCSI_CONN_INITIAL_STAGE; 29127996a778SMike Christie conn->id = conn_idx; 29137996a778SMike Christie conn->exp_statsn = 0; 2914843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2915f6d5180cSMike Christie 2916f6d5180cSMike Christie init_timer(&conn->transport_timer); 2917f6d5180cSMike Christie conn->transport_timer.data = (unsigned long)conn; 2918f6d5180cSMike Christie conn->transport_timer.function = iscsi_check_transport_timeouts; 2919f6d5180cSMike Christie 2920843c0a8aSMike Christie INIT_LIST_HEAD(&conn->mgmtqueue); 29213bbaaad9SMike Christie INIT_LIST_HEAD(&conn->cmdqueue); 2922843c0a8aSMike Christie INIT_LIST_HEAD(&conn->requeue); 29236f8830f5SChris Leech spin_lock_init(&conn->taskqueuelock); 2924c4028958SDavid Howells INIT_WORK(&conn->xmitwork, iscsi_xmitworker); 29257996a778SMike Christie 29269c19a7d0SMike Christie /* allocate login_task used for the login/text sequences */ 2927659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 29287acd72ebSStefani Seibold if (!kfifo_out(&session->cmdpool.queue, 29299c19a7d0SMike Christie (void*)&conn->login_task, 29307996a778SMike Christie sizeof(void*))) { 2931659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 29329c19a7d0SMike Christie goto login_task_alloc_fail; 29337996a778SMike Christie } 2934659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 29357996a778SMike Christie 2936cfeb2cf9SMike Christie data = (char *) __get_free_pages(GFP_KERNEL, 2937cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2938d36ab6f3SMike Christie if (!data) 29399c19a7d0SMike Christie goto login_task_data_alloc_fail; 29409c19a7d0SMike Christie conn->login_task->data = conn->data = data; 2941d36ab6f3SMike Christie 2942843c0a8aSMike Christie init_timer(&conn->tmf_timer); 29437996a778SMike Christie init_waitqueue_head(&conn->ehwait); 29447996a778SMike Christie 29457996a778SMike Christie return cls_conn; 29467996a778SMike Christie 29479c19a7d0SMike Christie login_task_data_alloc_fail: 29487acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 2949d36ab6f3SMike Christie sizeof(void*)); 29509c19a7d0SMike Christie login_task_alloc_fail: 29517996a778SMike Christie iscsi_destroy_conn(cls_conn); 29527996a778SMike Christie return NULL; 29537996a778SMike Christie } 29547996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_setup); 29557996a778SMike Christie 29567996a778SMike Christie /** 29577996a778SMike Christie * iscsi_conn_teardown - teardown iscsi connection 29587996a778SMike Christie * cls_conn: iscsi class connection 29597996a778SMike Christie * 29607996a778SMike Christie * TODO: we may need to make this into a two step process 29617996a778SMike Christie * like scsi-mls remove + put host 29627996a778SMike Christie */ 29637996a778SMike Christie void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) 29647996a778SMike Christie { 29657996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 29667996a778SMike Christie struct iscsi_session *session = conn->session; 29677996a778SMike Christie 2968f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 2969f6d5180cSMike Christie 2970660d0831SJohn Soni Jose mutex_lock(&session->eh_mutex); 2971659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 29727996a778SMike Christie conn->c_stage = ISCSI_CONN_CLEANUP_WAIT; 29737996a778SMike Christie if (session->leadconn == conn) { 29747996a778SMike Christie /* 29757996a778SMike Christie * leading connection? then give up on recovery. 29767996a778SMike Christie */ 29777996a778SMike Christie session->state = ISCSI_STATE_TERMINATE; 29787996a778SMike Christie wake_up(&conn->ehwait); 29797996a778SMike Christie } 2980659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 29817996a778SMike Christie 2982779ea120SMike Christie /* flush queued up work because we free the connection below */ 2983843c0a8aSMike Christie iscsi_suspend_tx(conn); 2984779ea120SMike Christie 2985659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2986cfeb2cf9SMike Christie free_pages((unsigned long) conn->data, 2987cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2988f3ff0c36SMike Christie kfree(conn->persistent_address); 2989ae56ff40SAdheer Chandravanshi kfree(conn->local_ipaddr); 2990659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 2991659743b0SShlomo Pongratz spin_lock_bh(&session->back_lock); 29927acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 29937996a778SMike Christie sizeof(void*)); 2994659743b0SShlomo Pongratz spin_unlock_bh(&session->back_lock); 2995e0726407SMike Christie if (session->leadconn == conn) 29967996a778SMike Christie session->leadconn = NULL; 2997659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2998660d0831SJohn Soni Jose mutex_unlock(&session->eh_mutex); 29997996a778SMike Christie 30007996a778SMike Christie iscsi_destroy_conn(cls_conn); 30017996a778SMike Christie } 30027996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_teardown); 30037996a778SMike Christie 30047996a778SMike Christie int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 30057996a778SMike Christie { 30067996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 30077996a778SMike Christie struct iscsi_session *session = conn->session; 30087996a778SMike Christie 3009ffd0436eSMike Christie if (!session) { 3010322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 3011322d739dSMike Christie "can't start unbound connection\n"); 30127996a778SMike Christie return -EPERM; 30137996a778SMike Christie } 30147996a778SMike Christie 3015db98ccdeSMike Christie if ((session->imm_data_en || !session->initial_r2t_en) && 3016db98ccdeSMike Christie session->first_burst > session->max_burst) { 3017322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: " 3018ffd0436eSMike Christie "first_burst %d max_burst %d\n", 3019ffd0436eSMike Christie session->first_burst, session->max_burst); 3020ffd0436eSMike Christie return -EINVAL; 3021ffd0436eSMike Christie } 3022ffd0436eSMike Christie 3023f6d5180cSMike Christie if (conn->ping_timeout && !conn->recv_timeout) { 3024322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of " 3025322d739dSMike Christie "zero. Using 5 seconds\n."); 3026f6d5180cSMike Christie conn->recv_timeout = 5; 3027f6d5180cSMike Christie } 3028f6d5180cSMike Christie 3029f6d5180cSMike Christie if (conn->recv_timeout && !conn->ping_timeout) { 3030322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of " 3031322d739dSMike Christie "zero. Using 5 seconds.\n"); 3032f6d5180cSMike Christie conn->ping_timeout = 5; 3033f6d5180cSMike Christie } 3034f6d5180cSMike Christie 3035659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 30367996a778SMike Christie conn->c_stage = ISCSI_CONN_STARTED; 30377996a778SMike Christie session->state = ISCSI_STATE_LOGGED_IN; 3038e0726407SMike Christie session->queued_cmdsn = session->cmdsn; 30397996a778SMike Christie 3040f6d5180cSMike Christie conn->last_recv = jiffies; 3041f6d5180cSMike Christie conn->last_ping = jiffies; 3042f6d5180cSMike Christie if (conn->recv_timeout && conn->ping_timeout) 3043f6d5180cSMike Christie mod_timer(&conn->transport_timer, 3044f6d5180cSMike Christie jiffies + (conn->recv_timeout * HZ)); 3045f6d5180cSMike Christie 30467996a778SMike Christie switch(conn->stop_stage) { 30477996a778SMike Christie case STOP_CONN_RECOVER: 30487996a778SMike Christie /* 30497996a778SMike Christie * unblock eh_abort() if it is blocked. re-try all 30507996a778SMike Christie * commands after successful recovery 30517996a778SMike Christie */ 30527996a778SMike Christie conn->stop_stage = 0; 3053843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 30547996a778SMike Christie session->age++; 30558b1d0343SMike Christie if (session->age == 16) 30568b1d0343SMike Christie session->age = 0; 30576eabafbeSMike Christie break; 30587996a778SMike Christie case STOP_CONN_TERM: 30597996a778SMike Christie conn->stop_stage = 0; 30607996a778SMike Christie break; 30617996a778SMike Christie default: 30627996a778SMike Christie break; 30637996a778SMike Christie } 3064659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 30657996a778SMike Christie 306675613521SMike Christie iscsi_unblock_session(session->cls_session); 30676eabafbeSMike Christie wake_up(&conn->ehwait); 30687996a778SMike Christie return 0; 30697996a778SMike Christie } 30707996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_start); 30717996a778SMike Christie 30727996a778SMike Christie static void 30733bbaaad9SMike Christie fail_mgmt_tasks(struct iscsi_session *session, struct iscsi_conn *conn) 30747996a778SMike Christie { 30753bbaaad9SMike Christie struct iscsi_task *task; 3076b3cd5050SMike Christie int i, state; 30777996a778SMike Christie 30783bbaaad9SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 30793bbaaad9SMike Christie task = conn->session->cmds[i]; 30803bbaaad9SMike Christie if (task->sc) 30813bbaaad9SMike Christie continue; 30823bbaaad9SMike Christie 30833bbaaad9SMike Christie if (task->state == ISCSI_TASK_FREE) 30843bbaaad9SMike Christie continue; 30853bbaaad9SMike Christie 30863bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, 30873bbaaad9SMike Christie "failing mgmt itt 0x%x state %d\n", 30883bbaaad9SMike Christie task->itt, task->state); 3089b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 3090b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) 3091b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 3092b3cd5050SMike Christie iscsi_complete_task(task, state); 3093b3cd5050SMike Christie 30947996a778SMike Christie } 30957996a778SMike Christie } 30967996a778SMike Christie 3097656cffc9SMike Christie static void iscsi_start_session_recovery(struct iscsi_session *session, 30987996a778SMike Christie struct iscsi_conn *conn, int flag) 30997996a778SMike Christie { 3100ed2abc7fSMike Christie int old_stop_stage; 3101ed2abc7fSMike Christie 31026724add1SMike Christie mutex_lock(&session->eh_mutex); 3103659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 3104ed2abc7fSMike Christie if (conn->stop_stage == STOP_CONN_TERM) { 3105659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31066724add1SMike Christie mutex_unlock(&session->eh_mutex); 31076724add1SMike Christie return; 31086724add1SMike Christie } 31096724add1SMike Christie 31106724add1SMike Christie /* 3111ed2abc7fSMike Christie * When this is called for the in_login state, we only want to clean 31129c19a7d0SMike Christie * up the login task and connection. We do not need to block and set 311367a61114SMike Christie * the recovery state again 3114ed2abc7fSMike Christie */ 311567a61114SMike Christie if (flag == STOP_CONN_TERM) 311667a61114SMike Christie session->state = ISCSI_STATE_TERMINATE; 311767a61114SMike Christie else if (conn->stop_stage != STOP_CONN_RECOVER) 311867a61114SMike Christie session->state = ISCSI_STATE_IN_RECOVERY; 31194ae0a6c1SMike Christie 31204ae0a6c1SMike Christie old_stop_stage = conn->stop_stage; 31214ae0a6c1SMike Christie conn->stop_stage = flag; 3122659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 3123ed2abc7fSMike Christie 312426013ad4SMike Christie del_timer_sync(&conn->transport_timer); 312526013ad4SMike Christie iscsi_suspend_tx(conn); 312626013ad4SMike Christie 3127659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 312867a61114SMike Christie conn->c_stage = ISCSI_CONN_STOPPED; 3129659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31306724add1SMike Christie 31317996a778SMike Christie /* 31327996a778SMike Christie * for connection level recovery we should not calculate 31337996a778SMike Christie * header digest. conn->hdr_size used for optimization 31347996a778SMike Christie * in hdr_extract() and will be re-negotiated at 31357996a778SMike Christie * set_param() time. 31367996a778SMike Christie */ 31377996a778SMike Christie if (flag == STOP_CONN_RECOVER) { 31387996a778SMike Christie conn->hdrdgst_en = 0; 31397996a778SMike Christie conn->datadgst_en = 0; 3140656cffc9SMike Christie if (session->state == ISCSI_STATE_IN_RECOVERY && 314167a61114SMike Christie old_stop_stage != STOP_CONN_RECOVER) { 31421b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "blocking session\n"); 314375613521SMike Christie iscsi_block_session(session->cls_session); 31447996a778SMike Christie } 314567a61114SMike Christie } 3146656cffc9SMike Christie 3147656cffc9SMike Christie /* 3148656cffc9SMike Christie * flush queues. 3149656cffc9SMike Christie */ 3150659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 31513bbaaad9SMike Christie fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED); 31523bbaaad9SMike Christie fail_mgmt_tasks(session, conn); 31535d12c05eSMike Christie memset(&conn->tmhdr, 0, sizeof(conn->tmhdr)); 3154659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31556724add1SMike Christie mutex_unlock(&session->eh_mutex); 31567996a778SMike Christie } 31577996a778SMike Christie 31587996a778SMike Christie void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 31597996a778SMike Christie { 31607996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 31617996a778SMike Christie struct iscsi_session *session = conn->session; 31627996a778SMike Christie 31637996a778SMike Christie switch (flag) { 31647996a778SMike Christie case STOP_CONN_RECOVER: 31657996a778SMike Christie case STOP_CONN_TERM: 31667996a778SMike Christie iscsi_start_session_recovery(session, conn, flag); 31678d2860b3SMike Christie break; 31687996a778SMike Christie default: 3169322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 3170322d739dSMike Christie "invalid stop flag %d\n", flag); 31717996a778SMike Christie } 31727996a778SMike Christie } 31737996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_stop); 31747996a778SMike Christie 31757996a778SMike Christie int iscsi_conn_bind(struct iscsi_cls_session *cls_session, 31767996a778SMike Christie struct iscsi_cls_conn *cls_conn, int is_leading) 31777996a778SMike Christie { 317875613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 317998644047SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 31807996a778SMike Christie 3181659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 31827996a778SMike Christie if (is_leading) 31837996a778SMike Christie session->leadconn = conn; 3184659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31857996a778SMike Christie 31867996a778SMike Christie /* 31877996a778SMike Christie * Unblock xmitworker(), Login Phase will pass through. 31887996a778SMike Christie */ 31897996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 31907996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 31917996a778SMike Christie return 0; 31927996a778SMike Christie } 31937996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_bind); 31947996a778SMike Christie 3195adaf6990SAdheer Chandravanshi int iscsi_switch_str_param(char **param, char *new_val_buf) 31965700b1afSMike Christie { 31975700b1afSMike Christie char *new_val; 31985700b1afSMike Christie 31995700b1afSMike Christie if (*param) { 32005700b1afSMike Christie if (!strcmp(*param, new_val_buf)) 32015700b1afSMike Christie return 0; 32025700b1afSMike Christie } 32035700b1afSMike Christie 32045700b1afSMike Christie new_val = kstrdup(new_val_buf, GFP_NOIO); 32055700b1afSMike Christie if (!new_val) 32065700b1afSMike Christie return -ENOMEM; 32075700b1afSMike Christie 32085700b1afSMike Christie kfree(*param); 32095700b1afSMike Christie *param = new_val; 32105700b1afSMike Christie return 0; 32115700b1afSMike Christie } 3212adaf6990SAdheer Chandravanshi EXPORT_SYMBOL_GPL(iscsi_switch_str_param); 3213a54a52caSMike Christie 3214a54a52caSMike Christie int iscsi_set_param(struct iscsi_cls_conn *cls_conn, 3215a54a52caSMike Christie enum iscsi_param param, char *buf, int buflen) 3216a54a52caSMike Christie { 3217a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 3218a54a52caSMike Christie struct iscsi_session *session = conn->session; 32196a06a4b8SOr Gerlitz int val; 3220a54a52caSMike Christie 3221a54a52caSMike Christie switch(param) { 3222843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 3223843c0a8aSMike Christie sscanf(buf, "%d", &session->fast_abort); 3224843c0a8aSMike Christie break; 3225f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 3226f6d5180cSMike Christie sscanf(buf, "%d", &session->abort_timeout); 3227f6d5180cSMike Christie break; 3228f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 3229f6d5180cSMike Christie sscanf(buf, "%d", &session->lu_reset_timeout); 3230f6d5180cSMike Christie break; 32313fe5ae8bSMike Christie case ISCSI_PARAM_TGT_RESET_TMO: 32323fe5ae8bSMike Christie sscanf(buf, "%d", &session->tgt_reset_timeout); 32333fe5ae8bSMike Christie break; 3234f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 3235f6d5180cSMike Christie sscanf(buf, "%d", &conn->ping_timeout); 3236f6d5180cSMike Christie break; 3237f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 3238f6d5180cSMike Christie sscanf(buf, "%d", &conn->recv_timeout); 3239f6d5180cSMike Christie break; 3240a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 3241a54a52caSMike Christie sscanf(buf, "%d", &conn->max_recv_dlength); 3242a54a52caSMike Christie break; 3243a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3244a54a52caSMike Christie sscanf(buf, "%d", &conn->max_xmit_dlength); 3245a54a52caSMike Christie break; 3246a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 3247a54a52caSMike Christie sscanf(buf, "%d", &conn->hdrdgst_en); 3248a54a52caSMike Christie break; 3249a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 3250a54a52caSMike Christie sscanf(buf, "%d", &conn->datadgst_en); 3251a54a52caSMike Christie break; 3252a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 3253a54a52caSMike Christie sscanf(buf, "%d", &session->initial_r2t_en); 3254a54a52caSMike Christie break; 3255a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 32561304be5fSMike Christie sscanf(buf, "%hu", &session->max_r2t); 3257a54a52caSMike Christie break; 3258a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 3259a54a52caSMike Christie sscanf(buf, "%d", &session->imm_data_en); 3260a54a52caSMike Christie break; 3261a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 3262a54a52caSMike Christie sscanf(buf, "%d", &session->first_burst); 3263a54a52caSMike Christie break; 3264a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 3265a54a52caSMike Christie sscanf(buf, "%d", &session->max_burst); 3266a54a52caSMike Christie break; 3267a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 3268a54a52caSMike Christie sscanf(buf, "%d", &session->pdu_inorder_en); 3269a54a52caSMike Christie break; 3270a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 3271a54a52caSMike Christie sscanf(buf, "%d", &session->dataseq_inorder_en); 3272a54a52caSMike Christie break; 3273a54a52caSMike Christie case ISCSI_PARAM_ERL: 3274a54a52caSMike Christie sscanf(buf, "%d", &session->erl); 3275a54a52caSMike Christie break; 3276a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 3277a54a52caSMike Christie sscanf(buf, "%u", &conn->exp_statsn); 3278a54a52caSMike Christie break; 3279b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 32805700b1afSMike Christie return iscsi_switch_str_param(&session->username, buf); 3281b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 32825700b1afSMike Christie return iscsi_switch_str_param(&session->username_in, buf); 3283b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 32845700b1afSMike Christie return iscsi_switch_str_param(&session->password, buf); 3285b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 32865700b1afSMike Christie return iscsi_switch_str_param(&session->password_in, buf); 3287a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 32885700b1afSMike Christie return iscsi_switch_str_param(&session->targetname, buf); 32893c5c4801SVikas Chaudhary case ISCSI_PARAM_TARGET_ALIAS: 32903c5c4801SVikas Chaudhary return iscsi_switch_str_param(&session->targetalias, buf); 3291a54a52caSMike Christie case ISCSI_PARAM_TPGT: 3292a54a52caSMike Christie sscanf(buf, "%d", &session->tpgt); 3293a54a52caSMike Christie break; 3294a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3295a54a52caSMike Christie sscanf(buf, "%d", &conn->persistent_port); 3296a54a52caSMike Christie break; 3297a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 32985700b1afSMike Christie return iscsi_switch_str_param(&conn->persistent_address, buf); 329988dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 33005700b1afSMike Christie return iscsi_switch_str_param(&session->ifacename, buf); 330188dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 33025700b1afSMike Christie return iscsi_switch_str_param(&session->initiatorname, buf); 33033b9373e9SEddie Wai case ISCSI_PARAM_BOOT_ROOT: 33043b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_root, buf); 33053b9373e9SEddie Wai case ISCSI_PARAM_BOOT_NIC: 33063b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_nic, buf); 33073b9373e9SEddie Wai case ISCSI_PARAM_BOOT_TARGET: 33083b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_target, buf); 3309f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_PORTAL_TYPE: 3310f8525eb4SAdheer Chandravanshi return iscsi_switch_str_param(&session->portal_type, buf); 3311f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_TYPE: 3312f8525eb4SAdheer Chandravanshi return iscsi_switch_str_param(&session->discovery_parent_type, 3313f8525eb4SAdheer Chandravanshi buf); 33146a06a4b8SOr Gerlitz case ISCSI_PARAM_DISCOVERY_SESS: 33156a06a4b8SOr Gerlitz sscanf(buf, "%d", &val); 33166a06a4b8SOr Gerlitz session->discovery_sess = !!val; 33176a06a4b8SOr Gerlitz break; 3318ae56ff40SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_IPADDR: 3319ae56ff40SAdheer Chandravanshi return iscsi_switch_str_param(&conn->local_ipaddr, buf); 3320a54a52caSMike Christie default: 3321a54a52caSMike Christie return -ENOSYS; 3322a54a52caSMike Christie } 3323a54a52caSMike Christie 3324a54a52caSMike Christie return 0; 3325a54a52caSMike Christie } 3326a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_set_param); 3327a54a52caSMike Christie 3328a54a52caSMike Christie int iscsi_session_get_param(struct iscsi_cls_session *cls_session, 3329a54a52caSMike Christie enum iscsi_param param, char *buf) 3330a54a52caSMike Christie { 333175613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 3332a54a52caSMike Christie int len; 3333a54a52caSMike Christie 3334a54a52caSMike Christie switch(param) { 3335843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 3336843c0a8aSMike Christie len = sprintf(buf, "%d\n", session->fast_abort); 3337843c0a8aSMike Christie break; 3338f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 3339f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->abort_timeout); 3340f6d5180cSMike Christie break; 3341f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 3342f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->lu_reset_timeout); 3343f6d5180cSMike Christie break; 33443fe5ae8bSMike Christie case ISCSI_PARAM_TGT_RESET_TMO: 33453fe5ae8bSMike Christie len = sprintf(buf, "%d\n", session->tgt_reset_timeout); 33463fe5ae8bSMike Christie break; 3347a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 3348a54a52caSMike Christie len = sprintf(buf, "%d\n", session->initial_r2t_en); 3349a54a52caSMike Christie break; 3350a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 3351a54a52caSMike Christie len = sprintf(buf, "%hu\n", session->max_r2t); 3352a54a52caSMike Christie break; 3353a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 3354a54a52caSMike Christie len = sprintf(buf, "%d\n", session->imm_data_en); 3355a54a52caSMike Christie break; 3356a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 3357a54a52caSMike Christie len = sprintf(buf, "%u\n", session->first_burst); 3358a54a52caSMike Christie break; 3359a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 3360a54a52caSMike Christie len = sprintf(buf, "%u\n", session->max_burst); 3361a54a52caSMike Christie break; 3362a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 3363a54a52caSMike Christie len = sprintf(buf, "%d\n", session->pdu_inorder_en); 3364a54a52caSMike Christie break; 3365a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 3366a54a52caSMike Christie len = sprintf(buf, "%d\n", session->dataseq_inorder_en); 3367a54a52caSMike Christie break; 33685f09e1f3SAdheer Chandravanshi case ISCSI_PARAM_DEF_TASKMGMT_TMO: 33695f09e1f3SAdheer Chandravanshi len = sprintf(buf, "%d\n", session->def_taskmgmt_tmo); 33705f09e1f3SAdheer Chandravanshi break; 3371a54a52caSMike Christie case ISCSI_PARAM_ERL: 3372a54a52caSMike Christie len = sprintf(buf, "%d\n", session->erl); 3373a54a52caSMike Christie break; 3374a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 3375a54a52caSMike Christie len = sprintf(buf, "%s\n", session->targetname); 3376a54a52caSMike Christie break; 33773c5c4801SVikas Chaudhary case ISCSI_PARAM_TARGET_ALIAS: 33783c5c4801SVikas Chaudhary len = sprintf(buf, "%s\n", session->targetalias); 33793c5c4801SVikas Chaudhary break; 3380a54a52caSMike Christie case ISCSI_PARAM_TPGT: 3381a54a52caSMike Christie len = sprintf(buf, "%d\n", session->tpgt); 3382a54a52caSMike Christie break; 3383b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 3384b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username); 3385b2c64167SMike Christie break; 3386b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 3387b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username_in); 3388b2c64167SMike Christie break; 3389b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 3390b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password); 3391b2c64167SMike Christie break; 3392b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 3393b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password_in); 3394b2c64167SMike Christie break; 339588dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 339688dfd340SMike Christie len = sprintf(buf, "%s\n", session->ifacename); 339788dfd340SMike Christie break; 339888dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 339988dfd340SMike Christie len = sprintf(buf, "%s\n", session->initiatorname); 340088dfd340SMike Christie break; 34013b9373e9SEddie Wai case ISCSI_PARAM_BOOT_ROOT: 34023b9373e9SEddie Wai len = sprintf(buf, "%s\n", session->boot_root); 34033b9373e9SEddie Wai break; 34043b9373e9SEddie Wai case ISCSI_PARAM_BOOT_NIC: 34053b9373e9SEddie Wai len = sprintf(buf, "%s\n", session->boot_nic); 34063b9373e9SEddie Wai break; 34073b9373e9SEddie Wai case ISCSI_PARAM_BOOT_TARGET: 34083b9373e9SEddie Wai len = sprintf(buf, "%s\n", session->boot_target); 34099a2307b1SAdheer Chandravanshi break; 3410f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_AUTO_SND_TGT_DISABLE: 3411f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->auto_snd_tgt_disable); 3412f8525eb4SAdheer Chandravanshi break; 3413f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_SESS: 3414f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->discovery_sess); 3415f8525eb4SAdheer Chandravanshi break; 3416f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_PORTAL_TYPE: 3417f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%s\n", session->portal_type); 3418f8525eb4SAdheer Chandravanshi break; 3419f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_CHAP_AUTH_EN: 3420f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->chap_auth_en); 3421f8525eb4SAdheer Chandravanshi break; 3422f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_LOGOUT_EN: 3423f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->discovery_logout_en); 3424f8525eb4SAdheer Chandravanshi break; 3425f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_BIDI_CHAP_EN: 3426f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->bidi_chap_en); 3427f8525eb4SAdheer Chandravanshi break; 3428f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL: 3429f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->discovery_auth_optional); 3430f8525eb4SAdheer Chandravanshi break; 3431f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DEF_TIME2WAIT: 3432f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%d\n", session->time2wait); 3433f8525eb4SAdheer Chandravanshi break; 3434f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DEF_TIME2RETAIN: 3435f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%d\n", session->time2retain); 3436f8525eb4SAdheer Chandravanshi break; 3437f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TSID: 3438f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->tsid); 3439f8525eb4SAdheer Chandravanshi break; 3440f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_ISID: 3441f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%02x%02x%02x%02x%02x%02x\n", 3442f8525eb4SAdheer Chandravanshi session->isid[0], session->isid[1], 3443f8525eb4SAdheer Chandravanshi session->isid[2], session->isid[3], 3444f8525eb4SAdheer Chandravanshi session->isid[4], session->isid[5]); 3445f8525eb4SAdheer Chandravanshi break; 3446f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_IDX: 3447f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->discovery_parent_idx); 3448f8525eb4SAdheer Chandravanshi break; 3449f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_TYPE: 3450f8525eb4SAdheer Chandravanshi if (session->discovery_parent_type) 3451f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%s\n", 3452f8525eb4SAdheer Chandravanshi session->discovery_parent_type); 3453f8525eb4SAdheer Chandravanshi else 3454f8525eb4SAdheer Chandravanshi len = sprintf(buf, "\n"); 34553b9373e9SEddie Wai break; 3456a54a52caSMike Christie default: 3457a54a52caSMike Christie return -ENOSYS; 3458a54a52caSMike Christie } 3459a54a52caSMike Christie 3460a54a52caSMike Christie return len; 3461a54a52caSMike Christie } 3462a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_get_param); 3463a54a52caSMike Christie 346400f3708eSMike Christie int iscsi_conn_get_addr_param(struct sockaddr_storage *addr, 346500f3708eSMike Christie enum iscsi_param param, char *buf) 346600f3708eSMike Christie { 346700f3708eSMike Christie struct sockaddr_in6 *sin6 = NULL; 346800f3708eSMike Christie struct sockaddr_in *sin = NULL; 346900f3708eSMike Christie int len; 347000f3708eSMike Christie 347100f3708eSMike Christie switch (addr->ss_family) { 347200f3708eSMike Christie case AF_INET: 347300f3708eSMike Christie sin = (struct sockaddr_in *)addr; 347400f3708eSMike Christie break; 347500f3708eSMike Christie case AF_INET6: 347600f3708eSMike Christie sin6 = (struct sockaddr_in6 *)addr; 347700f3708eSMike Christie break; 347800f3708eSMike Christie default: 347900f3708eSMike Christie return -EINVAL; 348000f3708eSMike Christie } 348100f3708eSMike Christie 348200f3708eSMike Christie switch (param) { 348300f3708eSMike Christie case ISCSI_PARAM_CONN_ADDRESS: 348400f3708eSMike Christie case ISCSI_HOST_PARAM_IPADDRESS: 348500f3708eSMike Christie if (sin) 348600f3708eSMike Christie len = sprintf(buf, "%pI4\n", &sin->sin_addr.s_addr); 348700f3708eSMike Christie else 348800f3708eSMike Christie len = sprintf(buf, "%pI6\n", &sin6->sin6_addr); 348900f3708eSMike Christie break; 349000f3708eSMike Christie case ISCSI_PARAM_CONN_PORT: 34914bfb8ebfSMike Christie case ISCSI_PARAM_LOCAL_PORT: 349200f3708eSMike Christie if (sin) 349300f3708eSMike Christie len = sprintf(buf, "%hu\n", be16_to_cpu(sin->sin_port)); 349400f3708eSMike Christie else 349500f3708eSMike Christie len = sprintf(buf, "%hu\n", 349600f3708eSMike Christie be16_to_cpu(sin6->sin6_port)); 349700f3708eSMike Christie break; 349800f3708eSMike Christie default: 349900f3708eSMike Christie return -EINVAL; 350000f3708eSMike Christie } 350100f3708eSMike Christie 350200f3708eSMike Christie return len; 350300f3708eSMike Christie } 350400f3708eSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_addr_param); 350500f3708eSMike Christie 3506a54a52caSMike Christie int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, 3507a54a52caSMike Christie enum iscsi_param param, char *buf) 3508a54a52caSMike Christie { 3509a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 3510a54a52caSMike Christie int len; 3511a54a52caSMike Christie 3512a54a52caSMike Christie switch(param) { 3513f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 3514f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->ping_timeout); 3515f6d5180cSMike Christie break; 3516f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 3517f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->recv_timeout); 3518f6d5180cSMike Christie break; 3519a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 3520a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_recv_dlength); 3521a54a52caSMike Christie break; 3522a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3523a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_xmit_dlength); 3524a54a52caSMike Christie break; 3525a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 3526a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->hdrdgst_en); 3527a54a52caSMike Christie break; 3528a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 3529a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->datadgst_en); 3530a54a52caSMike Christie break; 3531a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 3532a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ifmarker_en); 3533a54a52caSMike Christie break; 3534a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 3535a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ofmarker_en); 3536a54a52caSMike Christie break; 3537a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 3538a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->exp_statsn); 3539a54a52caSMike Christie break; 3540a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3541a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->persistent_port); 3542a54a52caSMike Christie break; 3543a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 3544a54a52caSMike Christie len = sprintf(buf, "%s\n", conn->persistent_address); 3545a54a52caSMike Christie break; 3546f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_STATSN: 3547f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->statsn); 3548f8525eb4SAdheer Chandravanshi break; 3549f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_MAX_SEGMENT_SIZE: 3550f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->max_segment_size); 3551f8525eb4SAdheer Chandravanshi break; 3552f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_KEEPALIVE_TMO: 3553f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->keepalive_tmo); 3554f8525eb4SAdheer Chandravanshi break; 3555f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_PORT: 3556f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->local_port); 3557f8525eb4SAdheer Chandravanshi break; 3558f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMESTAMP_STAT: 3559f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_timestamp_stat); 3560f8525eb4SAdheer Chandravanshi break; 3561f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_NAGLE_DISABLE: 3562f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_nagle_disable); 3563f8525eb4SAdheer Chandravanshi break; 3564f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_WSF_DISABLE: 3565f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_wsf_disable); 3566f8525eb4SAdheer Chandravanshi break; 3567f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMER_SCALE: 3568f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_timer_scale); 3569f8525eb4SAdheer Chandravanshi break; 3570f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMESTAMP_EN: 3571f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_timestamp_en); 3572f8525eb4SAdheer Chandravanshi break; 3573f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IP_FRAGMENT_DISABLE: 3574f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->fragment_disable); 3575f8525eb4SAdheer Chandravanshi break; 3576f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IPV4_TOS: 3577f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->ipv4_tos); 3578f8525eb4SAdheer Chandravanshi break; 3579f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IPV6_TC: 3580f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->ipv6_traffic_class); 3581f8525eb4SAdheer Chandravanshi break; 35825f09e1f3SAdheer Chandravanshi case ISCSI_PARAM_IPV6_FLOW_LABEL: 35835f09e1f3SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->ipv6_flow_label); 35845f09e1f3SAdheer Chandravanshi break; 3585f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IS_FW_ASSIGNED_IPV6: 3586f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->is_fw_assigned_ipv6); 3587f8525eb4SAdheer Chandravanshi break; 3588f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_XMIT_WSF: 3589f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_xmit_wsf); 3590f8525eb4SAdheer Chandravanshi break; 3591f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_RECV_WSF: 3592f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_recv_wsf); 3593f8525eb4SAdheer Chandravanshi break; 3594ae56ff40SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_IPADDR: 3595ae56ff40SAdheer Chandravanshi len = sprintf(buf, "%s\n", conn->local_ipaddr); 3596ae56ff40SAdheer Chandravanshi break; 3597a54a52caSMike Christie default: 3598a54a52caSMike Christie return -ENOSYS; 3599a54a52caSMike Christie } 3600a54a52caSMike Christie 3601a54a52caSMike Christie return len; 3602a54a52caSMike Christie } 3603a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_param); 3604a54a52caSMike Christie 36050801c242SMike Christie int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param, 36060801c242SMike Christie char *buf) 36070801c242SMike Christie { 360875613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 36090801c242SMike Christie int len; 36100801c242SMike Christie 36110801c242SMike Christie switch (param) { 3612d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 361375613521SMike Christie len = sprintf(buf, "%s\n", ihost->netdev); 3614d8196ed2SMike Christie break; 36150801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 361675613521SMike Christie len = sprintf(buf, "%s\n", ihost->hwaddress); 36170801c242SMike Christie break; 36188ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 361975613521SMike Christie len = sprintf(buf, "%s\n", ihost->initiatorname); 36208ad5781aSMike Christie break; 36210801c242SMike Christie default: 36220801c242SMike Christie return -ENOSYS; 36230801c242SMike Christie } 36240801c242SMike Christie 36250801c242SMike Christie return len; 36260801c242SMike Christie } 36270801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_param); 36280801c242SMike Christie 36290801c242SMike Christie int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param, 36300801c242SMike Christie char *buf, int buflen) 36310801c242SMike Christie { 363275613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 36330801c242SMike Christie 36340801c242SMike Christie switch (param) { 3635d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 36365700b1afSMike Christie return iscsi_switch_str_param(&ihost->netdev, buf); 36370801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 36385700b1afSMike Christie return iscsi_switch_str_param(&ihost->hwaddress, buf); 36398ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 36405700b1afSMike Christie return iscsi_switch_str_param(&ihost->initiatorname, buf); 36410801c242SMike Christie default: 36420801c242SMike Christie return -ENOSYS; 36430801c242SMike Christie } 36440801c242SMike Christie 36450801c242SMike Christie return 0; 36460801c242SMike Christie } 36470801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_set_param); 36480801c242SMike Christie 36497996a778SMike Christie MODULE_AUTHOR("Mike Christie"); 36507996a778SMike Christie MODULE_DESCRIPTION("iSCSI library functions"); 36517996a778SMike Christie MODULE_LICENSE("GPL"); 3652