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> 43c2332b00SFred Herard #include <trace/events/iscsi.h> 447996a778SMike Christie 45bd2199d4SErez Zilber static int iscsi_dbg_lib_conn; 46bd2199d4SErez Zilber module_param_named(debug_libiscsi_conn, iscsi_dbg_lib_conn, int, 47bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 48bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_conn, 49bd2199d4SErez Zilber "Turn on debugging for connections in libiscsi module. " 50bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 51bd2199d4SErez Zilber 52bd2199d4SErez Zilber static int iscsi_dbg_lib_session; 53bd2199d4SErez Zilber module_param_named(debug_libiscsi_session, iscsi_dbg_lib_session, int, 54bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 55bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_session, 56bd2199d4SErez Zilber "Turn on debugging for sessions in libiscsi module. " 57bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 58bd2199d4SErez Zilber 59bd2199d4SErez Zilber static int iscsi_dbg_lib_eh; 60bd2199d4SErez Zilber module_param_named(debug_libiscsi_eh, iscsi_dbg_lib_eh, int, 61bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 62bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_eh, 63bd2199d4SErez Zilber "Turn on debugging for error handling in libiscsi module. " 64bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 651b2c7af8SMike Christie 661b2c7af8SMike Christie #define ISCSI_DBG_CONN(_conn, dbg_fmt, arg...) \ 671b2c7af8SMike Christie do { \ 68bd2199d4SErez Zilber if (iscsi_dbg_lib_conn) \ 691b2c7af8SMike Christie iscsi_conn_printk(KERN_INFO, _conn, \ 701b2c7af8SMike Christie "%s " dbg_fmt, \ 711b2c7af8SMike Christie __func__, ##arg); \ 72c2332b00SFred Herard iscsi_dbg_trace(trace_iscsi_dbg_conn, \ 73c2332b00SFred Herard &(_conn)->cls_conn->dev, \ 74c2332b00SFred Herard "%s " dbg_fmt, __func__, ##arg);\ 751b2c7af8SMike Christie } while (0); 761b2c7af8SMike Christie 771b2c7af8SMike Christie #define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...) \ 781b2c7af8SMike Christie do { \ 79bd2199d4SErez Zilber if (iscsi_dbg_lib_session) \ 80bd2199d4SErez Zilber iscsi_session_printk(KERN_INFO, _session, \ 81bd2199d4SErez Zilber "%s " dbg_fmt, \ 82bd2199d4SErez Zilber __func__, ##arg); \ 83c2332b00SFred Herard iscsi_dbg_trace(trace_iscsi_dbg_session, \ 84c2332b00SFred Herard &(_session)->cls_session->dev, \ 85c2332b00SFred Herard "%s " dbg_fmt, __func__, ##arg); \ 86bd2199d4SErez Zilber } while (0); 87bd2199d4SErez Zilber 88bd2199d4SErez Zilber #define ISCSI_DBG_EH(_session, dbg_fmt, arg...) \ 89bd2199d4SErez Zilber do { \ 90bd2199d4SErez Zilber if (iscsi_dbg_lib_eh) \ 911b2c7af8SMike Christie iscsi_session_printk(KERN_INFO, _session, \ 921b2c7af8SMike Christie "%s " dbg_fmt, \ 931b2c7af8SMike Christie __func__, ##arg); \ 94c2332b00SFred Herard iscsi_dbg_trace(trace_iscsi_dbg_eh, \ 95c2332b00SFred Herard &(_session)->cls_session->dev, \ 96c2332b00SFred Herard "%s " dbg_fmt, __func__, ##arg); \ 971b2c7af8SMike Christie } while (0); 981b2c7af8SMike Christie 9932ae763eSMike Christie inline void iscsi_conn_queue_work(struct iscsi_conn *conn) 10032ae763eSMike Christie { 10132ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 10232ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 10332ae763eSMike Christie 1041336aed1SMike Christie if (ihost->workq) 10532ae763eSMike Christie queue_work(ihost->workq, &conn->xmitwork); 10632ae763eSMike Christie } 10732ae763eSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_queue_work); 10832ae763eSMike Christie 1094c0ba5d2SMike Christie static void __iscsi_update_cmdsn(struct iscsi_session *session, 1104c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 1117996a778SMike Christie { 11277a23c21SMike Christie /* 11377a23c21SMike Christie * standard specifies this check for when to update expected and 11477a23c21SMike Christie * max sequence numbers 11577a23c21SMike Christie */ 11677a23c21SMike Christie if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1)) 11777a23c21SMike Christie return; 11877a23c21SMike Christie 11977a23c21SMike Christie if (exp_cmdsn != session->exp_cmdsn && 12077a23c21SMike Christie !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn)) 1217996a778SMike Christie session->exp_cmdsn = exp_cmdsn; 1227996a778SMike Christie 12377a23c21SMike Christie if (max_cmdsn != session->max_cmdsn && 12446a84c65SMike Christie !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) 12577a23c21SMike Christie session->max_cmdsn = max_cmdsn; 12677a23c21SMike Christie } 1274c0ba5d2SMike Christie 1284c0ba5d2SMike Christie void iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr) 1294c0ba5d2SMike Christie { 1304c0ba5d2SMike Christie __iscsi_update_cmdsn(session, be32_to_cpu(hdr->exp_cmdsn), 1314c0ba5d2SMike Christie be32_to_cpu(hdr->max_cmdsn)); 1324c0ba5d2SMike Christie } 13377a23c21SMike Christie EXPORT_SYMBOL_GPL(iscsi_update_cmdsn); 1347996a778SMike Christie 135577577daSMike Christie /** 136577577daSMike Christie * iscsi_prep_data_out_pdu - initialize Data-Out 137577577daSMike Christie * @task: scsi command task 138577577daSMike Christie * @r2t: R2T info 139577577daSMike Christie * @hdr: iscsi data in pdu 140577577daSMike Christie * 141577577daSMike Christie * Notes: 142577577daSMike Christie * Initialize Data-Out within this R2T sequence and finds 143577577daSMike Christie * proper data_offset within this SCSI command. 144577577daSMike Christie * 145577577daSMike Christie * This function is called with connection lock taken. 146577577daSMike Christie **/ 147577577daSMike Christie void iscsi_prep_data_out_pdu(struct iscsi_task *task, struct iscsi_r2t_info *r2t, 148ffd0436eSMike Christie struct iscsi_data *hdr) 1497996a778SMike Christie { 1509c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 151577577daSMike Christie unsigned int left = r2t->data_length - r2t->sent; 152577577daSMike Christie 153577577daSMike Christie task->hdr_len = sizeof(struct iscsi_data); 1547996a778SMike Christie 1557996a778SMike Christie memset(hdr, 0, sizeof(struct iscsi_data)); 156577577daSMike Christie hdr->ttt = r2t->ttt; 157577577daSMike Christie hdr->datasn = cpu_to_be32(r2t->datasn); 158577577daSMike Christie r2t->datasn++; 1597996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_DATA_OUT; 16055bdabdfSAndy Grover hdr->lun = task->lun; 161577577daSMike Christie hdr->itt = task->hdr_itt; 162577577daSMike Christie hdr->exp_statsn = r2t->exp_statsn; 163577577daSMike Christie hdr->offset = cpu_to_be32(r2t->data_offset + r2t->sent); 164577577daSMike Christie if (left > conn->max_xmit_dlength) { 1657996a778SMike Christie hton24(hdr->dlength, conn->max_xmit_dlength); 166577577daSMike Christie r2t->data_count = conn->max_xmit_dlength; 1677996a778SMike Christie hdr->flags = 0; 1687996a778SMike Christie } else { 169577577daSMike Christie hton24(hdr->dlength, left); 170577577daSMike Christie r2t->data_count = left; 1717996a778SMike Christie hdr->flags = ISCSI_FLAG_CMD_FINAL; 1727996a778SMike Christie } 173577577daSMike Christie conn->dataout_pdus_cnt++; 1747996a778SMike Christie } 175577577daSMike Christie EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu); 1767996a778SMike Christie 1779c19a7d0SMike Christie static int iscsi_add_hdr(struct iscsi_task *task, unsigned len) 178004d6530SBoaz Harrosh { 1799c19a7d0SMike Christie unsigned exp_len = task->hdr_len + len; 180004d6530SBoaz Harrosh 1819c19a7d0SMike Christie if (exp_len > task->hdr_max) { 182004d6530SBoaz Harrosh WARN_ON(1); 183004d6530SBoaz Harrosh return -EINVAL; 184004d6530SBoaz Harrosh } 185004d6530SBoaz Harrosh 186004d6530SBoaz Harrosh WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */ 1879c19a7d0SMike Christie task->hdr_len = exp_len; 188004d6530SBoaz Harrosh return 0; 189004d6530SBoaz Harrosh } 190004d6530SBoaz Harrosh 19138d1c069SBoaz Harrosh /* 19238d1c069SBoaz Harrosh * make an extended cdb AHS 19338d1c069SBoaz Harrosh */ 1949c19a7d0SMike Christie static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) 19538d1c069SBoaz Harrosh { 1969c19a7d0SMike Christie struct scsi_cmnd *cmd = task->sc; 19738d1c069SBoaz Harrosh unsigned rlen, pad_len; 19838d1c069SBoaz Harrosh unsigned short ahslength; 19938d1c069SBoaz Harrosh struct iscsi_ecdb_ahdr *ecdb_ahdr; 20038d1c069SBoaz Harrosh int rc; 20138d1c069SBoaz Harrosh 2029c19a7d0SMike Christie ecdb_ahdr = iscsi_next_hdr(task); 20338d1c069SBoaz Harrosh rlen = cmd->cmd_len - ISCSI_CDB_SIZE; 20438d1c069SBoaz Harrosh 20538d1c069SBoaz Harrosh BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb)); 20638d1c069SBoaz Harrosh ahslength = rlen + sizeof(ecdb_ahdr->reserved); 20738d1c069SBoaz Harrosh 20838d1c069SBoaz Harrosh pad_len = iscsi_padding(rlen); 20938d1c069SBoaz Harrosh 2109c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) + 21138d1c069SBoaz Harrosh sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len); 21238d1c069SBoaz Harrosh if (rc) 21338d1c069SBoaz Harrosh return rc; 21438d1c069SBoaz Harrosh 21538d1c069SBoaz Harrosh if (pad_len) 21638d1c069SBoaz Harrosh memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len); 21738d1c069SBoaz Harrosh 21838d1c069SBoaz Harrosh ecdb_ahdr->ahslength = cpu_to_be16(ahslength); 21938d1c069SBoaz Harrosh ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB; 22038d1c069SBoaz Harrosh ecdb_ahdr->reserved = 0; 22138d1c069SBoaz Harrosh memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen); 22238d1c069SBoaz Harrosh 2231b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2241b2c7af8SMike Christie "iscsi_prep_ecdb_ahs: varlen_cdb_len %d " 2251b2c7af8SMike Christie "rlen %d pad_len %d ahs_length %d iscsi_headers_size " 2261b2c7af8SMike Christie "%u\n", cmd->cmd_len, rlen, pad_len, ahslength, 2271b2c7af8SMike Christie task->hdr_len); 22838d1c069SBoaz Harrosh return 0; 22938d1c069SBoaz Harrosh } 23038d1c069SBoaz Harrosh 2317996a778SMike Christie /** 2325d12c05eSMike Christie * iscsi_check_tmf_restrictions - check if a task is affected by TMF 2335d12c05eSMike Christie * @task: iscsi task 2345d12c05eSMike Christie * @opcode: opcode to check for 2355d12c05eSMike Christie * 2365d12c05eSMike Christie * During TMF a task has to be checked if it's affected. 2375d12c05eSMike Christie * All unrelated I/O can be passed through, but I/O to the 2385d12c05eSMike Christie * affected LUN should be restricted. 2395d12c05eSMike Christie * If 'fast_abort' is set we won't be sending any I/O to the 2405d12c05eSMike Christie * affected LUN. 2415d12c05eSMike Christie * Otherwise the target is waiting for all TTTs to be completed, 2425d12c05eSMike Christie * so we have to send all outstanding Data-Out PDUs to the target. 2435d12c05eSMike Christie */ 2445d12c05eSMike Christie static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode) 2455d12c05eSMike Christie { 2465d12c05eSMike Christie struct iscsi_conn *conn = task->conn; 2475d12c05eSMike Christie struct iscsi_tm *tmf = &conn->tmhdr; 2489cb78c16SHannes Reinecke u64 hdr_lun; 2495d12c05eSMike Christie 2505d12c05eSMike Christie if (conn->tmf_state == TMF_INITIAL) 2515d12c05eSMike Christie return 0; 2525d12c05eSMike Christie 2535d12c05eSMike Christie if ((tmf->opcode & ISCSI_OPCODE_MASK) != ISCSI_OP_SCSI_TMFUNC) 2545d12c05eSMike Christie return 0; 2555d12c05eSMike Christie 2565d12c05eSMike Christie switch (ISCSI_TM_FUNC_VALUE(tmf)) { 2575d12c05eSMike Christie case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET: 2585d12c05eSMike Christie /* 2595d12c05eSMike Christie * Allow PDUs for unrelated LUNs 2605d12c05eSMike Christie */ 26155bdabdfSAndy Grover hdr_lun = scsilun_to_int(&tmf->lun); 2625d12c05eSMike Christie if (hdr_lun != task->sc->device->lun) 2635d12c05eSMike Christie return 0; 2643fe5ae8bSMike Christie /* fall through */ 2653fe5ae8bSMike Christie case ISCSI_TM_FUNC_TARGET_WARM_RESET: 2665d12c05eSMike Christie /* 2675d12c05eSMike Christie * Fail all SCSI cmd PDUs 2685d12c05eSMike Christie */ 2695d12c05eSMike Christie if (opcode != ISCSI_OP_SCSI_DATA_OUT) { 2705d12c05eSMike Christie iscsi_conn_printk(KERN_INFO, conn, 271a17037e7SVarun Prakash "task [op %x itt " 2723fe5ae8bSMike Christie "0x%x/0x%x] " 2735d12c05eSMike Christie "rejected.\n", 274a17037e7SVarun Prakash opcode, task->itt, 275a17037e7SVarun Prakash task->hdr_itt); 2765d12c05eSMike Christie return -EACCES; 2775d12c05eSMike Christie } 2785d12c05eSMike Christie /* 2795d12c05eSMike Christie * And also all data-out PDUs in response to R2T 2805d12c05eSMike Christie * if fast_abort is set. 2815d12c05eSMike Christie */ 2825d12c05eSMike Christie if (conn->session->fast_abort) { 2835d12c05eSMike Christie iscsi_conn_printk(KERN_INFO, conn, 284a17037e7SVarun Prakash "task [op %x itt " 2853fe5ae8bSMike Christie "0x%x/0x%x] fast abort.\n", 286a17037e7SVarun Prakash opcode, task->itt, 287a17037e7SVarun Prakash task->hdr_itt); 2885d12c05eSMike Christie return -EACCES; 2895d12c05eSMike Christie } 2905d12c05eSMike Christie break; 2915d12c05eSMike Christie case ISCSI_TM_FUNC_ABORT_TASK: 2925d12c05eSMike Christie /* 2935d12c05eSMike Christie * the caller has already checked if the task 2945d12c05eSMike Christie * they want to abort was in the pending queue so if 2955d12c05eSMike Christie * we are here the cmd pdu has gone out already, and 2965d12c05eSMike Christie * we will only hit this for data-outs 2975d12c05eSMike Christie */ 2985d12c05eSMike Christie if (opcode == ISCSI_OP_SCSI_DATA_OUT && 2995d12c05eSMike Christie task->hdr_itt == tmf->rtt) { 3005d12c05eSMike Christie ISCSI_DBG_SESSION(conn->session, 3015d12c05eSMike Christie "Preventing task %x/%x from sending " 3025d12c05eSMike Christie "data-out due to abort task in " 3035d12c05eSMike Christie "progress\n", task->itt, 3045d12c05eSMike Christie task->hdr_itt); 3055d12c05eSMike Christie return -EACCES; 3065d12c05eSMike Christie } 3075d12c05eSMike Christie break; 3085d12c05eSMike Christie } 3095d12c05eSMike Christie 3105d12c05eSMike Christie return 0; 3115d12c05eSMike Christie } 3125d12c05eSMike Christie 3135d12c05eSMike Christie /** 3147996a778SMike Christie * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu 3159c19a7d0SMike Christie * @task: iscsi task 3167996a778SMike Christie * 3177996a778SMike Christie * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set 3187996a778SMike Christie * fields like dlength or final based on how much data it sends 3197996a778SMike Christie */ 3209c19a7d0SMike Christie static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task) 3217996a778SMike Christie { 3229c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 3237996a778SMike Christie struct iscsi_session *session = conn->session; 3249c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 32512352183SNicholas Bellinger struct iscsi_scsi_req *hdr; 326d77e6535SSagi Grimberg unsigned hdrlength, cmd_len, transfer_length; 327262ef636SMike Christie itt_t itt; 328004d6530SBoaz Harrosh int rc; 3297996a778SMike Christie 3305d12c05eSMike Christie rc = iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_CMD); 3315d12c05eSMike Christie if (rc) 3325d12c05eSMike Christie return rc; 3335d12c05eSMike Christie 334184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 3352ff79d52SMike Christie rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD); 336577577daSMike Christie if (rc) 337577577daSMike Christie return rc; 338184b57c6SMike Christie } 33912352183SNicholas Bellinger hdr = (struct iscsi_scsi_req *)task->hdr; 340262ef636SMike Christie itt = hdr->itt; 341577577daSMike Christie memset(hdr, 0, sizeof(*hdr)); 342577577daSMike Christie 3432ff79d52SMike Christie if (session->tt->parse_pdu_itt) 3442ff79d52SMike Christie hdr->itt = task->hdr_itt = itt; 3452ff79d52SMike Christie else 3462ff79d52SMike Christie hdr->itt = task->hdr_itt = build_itt(task->itt, 3472ff79d52SMike Christie task->conn->session->age); 3489c19a7d0SMike Christie task->hdr_len = 0; 3499c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*hdr)); 350004d6530SBoaz Harrosh if (rc) 351004d6530SBoaz Harrosh return rc; 3527996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_CMD; 3537996a778SMike Christie hdr->flags = ISCSI_ATTR_SIMPLE; 35455bdabdfSAndy Grover int_to_scsilun(sc->device->lun, &hdr->lun); 35555bdabdfSAndy Grover task->lun = hdr->lun; 3567996a778SMike Christie hdr->exp_statsn = cpu_to_be32(conn->exp_statsn); 35738d1c069SBoaz Harrosh cmd_len = sc->cmd_len; 35838d1c069SBoaz Harrosh if (cmd_len < ISCSI_CDB_SIZE) 35938d1c069SBoaz Harrosh memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len); 36038d1c069SBoaz Harrosh else if (cmd_len > ISCSI_CDB_SIZE) { 3619c19a7d0SMike Christie rc = iscsi_prep_ecdb_ahs(task); 36238d1c069SBoaz Harrosh if (rc) 36338d1c069SBoaz Harrosh return rc; 36438d1c069SBoaz Harrosh cmd_len = ISCSI_CDB_SIZE; 36538d1c069SBoaz Harrosh } 36638d1c069SBoaz Harrosh memcpy(hdr->cdb, sc->cmnd, cmd_len); 3677996a778SMike Christie 3689c19a7d0SMike Christie task->imm_count = 0; 36955e51edaSSagi Grimberg if (scsi_get_prot_op(sc) != SCSI_PROT_NORMAL) 37055e51edaSSagi Grimberg task->protected = true; 37155e51edaSSagi Grimberg 372d77e6535SSagi Grimberg transfer_length = scsi_transfer_length(sc); 373d77e6535SSagi Grimberg hdr->data_length = cpu_to_be32(transfer_length); 3747996a778SMike Christie if (sc->sc_data_direction == DMA_TO_DEVICE) { 375577577daSMike Christie struct iscsi_r2t_info *r2t = &task->unsol_r2t; 376577577daSMike Christie 3777996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_WRITE; 3787996a778SMike Christie /* 3797996a778SMike Christie * Write counters: 3807996a778SMike Christie * 3817996a778SMike Christie * imm_count bytes to be sent right after 3827996a778SMike Christie * SCSI PDU Header 3837996a778SMike Christie * 3847996a778SMike Christie * unsol_count bytes(as Data-Out) to be sent 3857996a778SMike Christie * without R2T ack right after 3867996a778SMike Christie * immediate data 3877996a778SMike Christie * 388577577daSMike Christie * r2t data_length bytes to be sent via R2T ack's 3897996a778SMike Christie * 3907996a778SMike Christie * pad_count bytes to be sent as zero-padding 3917996a778SMike Christie */ 392577577daSMike Christie memset(r2t, 0, sizeof(*r2t)); 3937996a778SMike Christie 3947996a778SMike Christie if (session->imm_data_en) { 395d77e6535SSagi Grimberg if (transfer_length >= session->first_burst) 3969c19a7d0SMike Christie task->imm_count = min(session->first_burst, 3977996a778SMike Christie conn->max_xmit_dlength); 3987996a778SMike Christie else 399d77e6535SSagi Grimberg task->imm_count = min(transfer_length, 4007996a778SMike Christie conn->max_xmit_dlength); 4019c19a7d0SMike Christie hton24(hdr->dlength, task->imm_count); 4027996a778SMike Christie } else 403a8ac6311SOlaf Kirch zero_data(hdr->dlength); 4047996a778SMike Christie 405ffd0436eSMike Christie if (!session->initial_r2t_en) { 406d77e6535SSagi Grimberg r2t->data_length = min(session->first_burst, 407d77e6535SSagi Grimberg transfer_length) - 408577577daSMike Christie task->imm_count; 409577577daSMike Christie r2t->data_offset = task->imm_count; 410577577daSMike Christie r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG); 411577577daSMike Christie r2t->exp_statsn = cpu_to_be32(conn->exp_statsn); 412ffd0436eSMike Christie } 413ffd0436eSMike Christie 414577577daSMike Christie if (!task->unsol_r2t.data_length) 4157996a778SMike Christie /* No unsolicit Data-Out's */ 416a8ac6311SOlaf Kirch hdr->flags |= ISCSI_FLAG_CMD_FINAL; 4177996a778SMike Christie } else { 4187996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 4197996a778SMike Christie zero_data(hdr->dlength); 4207996a778SMike Christie 4217996a778SMike Christie if (sc->sc_data_direction == DMA_FROM_DEVICE) 4227996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_READ; 4237996a778SMike Christie } 4247996a778SMike Christie 425004d6530SBoaz Harrosh /* calculate size of additional header segments (AHSs) */ 4269c19a7d0SMike Christie hdrlength = task->hdr_len - sizeof(*hdr); 427004d6530SBoaz Harrosh 428004d6530SBoaz Harrosh WARN_ON(hdrlength & (ISCSI_PAD_LEN-1)); 429004d6530SBoaz Harrosh hdrlength /= ISCSI_PAD_LEN; 430004d6530SBoaz Harrosh 431004d6530SBoaz Harrosh WARN_ON(hdrlength >= 256); 432004d6530SBoaz Harrosh hdr->hlength = hdrlength & 0xFF; 43396b1f96dSMike Christie hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn); 434004d6530SBoaz Harrosh 435577577daSMike Christie if (session->tt->init_task && session->tt->init_task(task)) 436052d0144SMike Christie return -EIO; 437052d0144SMike Christie 4389c19a7d0SMike Christie task->state = ISCSI_TASK_RUNNING; 439d3305f34SMike Christie session->cmdsn++; 44077a23c21SMike Christie 441a8ac6311SOlaf Kirch conn->scsicmd_pdus_cnt++; 4421b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi prep [%s cid %d sc %p cdb 0x%x " 443*ae3d56d8SChristoph Hellwig "itt 0x%x len %d cmdsn %d win %d]\n", 4441b2c7af8SMike Christie sc->sc_data_direction == DMA_TO_DEVICE ? 4451b2c7af8SMike Christie "write" : "read", conn->id, sc, sc->cmnd[0], 446d77e6535SSagi Grimberg task->itt, transfer_length, 4471b2c7af8SMike Christie session->cmdsn, 4481b2c7af8SMike Christie session->max_cmdsn - session->exp_cmdsn + 1); 449004d6530SBoaz Harrosh return 0; 4507996a778SMike Christie } 4517996a778SMike Christie 4527996a778SMike Christie /** 4533bbaaad9SMike Christie * iscsi_free_task - free a task 4549c19a7d0SMike Christie * @task: iscsi cmd task 4557996a778SMike Christie * 456659743b0SShlomo Pongratz * Must be called with session back_lock. 4573e5c28adSMike Christie * This function returns the scsi command to scsi-ml or cleans 4583e5c28adSMike Christie * up mgmt tasks then returns the task to the pool. 4597996a778SMike Christie */ 4603bbaaad9SMike Christie static void iscsi_free_task(struct iscsi_task *task) 4617996a778SMike Christie { 4629c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 463c1635cb7SMike Christie struct iscsi_session *session = conn->session; 4649c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 465f41d4721SMike Christie int oldstate = task->state; 4667996a778SMike Christie 4674421c9ebSMike Christie ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n", 4684421c9ebSMike Christie task->itt, task->state, task->sc); 4694421c9ebSMike Christie 470577577daSMike Christie session->tt->cleanup_task(task); 4713bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 4729c19a7d0SMike Christie task->sc = NULL; 4733e5c28adSMike Christie /* 4749c19a7d0SMike Christie * login task is preallocated so do not free 4753e5c28adSMike Christie */ 4769c19a7d0SMike Christie if (conn->login_task == task) 4773e5c28adSMike Christie return; 4783e5c28adSMike Christie 4797acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&task, sizeof(void*)); 4803e5c28adSMike Christie 4813e5c28adSMike Christie if (sc) { 482f47f2cf5SMike Christie /* SCSI eh reuses commands to verify us */ 483f47f2cf5SMike Christie sc->SCp.ptr = NULL; 4843e5c28adSMike Christie /* 485f41d4721SMike Christie * queue command may call this to free the task, so 486f41d4721SMike Christie * it will decide how to return sc to scsi-ml. 4873e5c28adSMike Christie */ 488f41d4721SMike Christie if (oldstate != ISCSI_TASK_REQUEUE_SCSIQ) 4897996a778SMike Christie sc->scsi_done(sc); 4907996a778SMike Christie } 4913e5c28adSMike Christie } 4927996a778SMike Christie 493913e5bf4SMike Christie void __iscsi_get_task(struct iscsi_task *task) 49460ecebf5SMike Christie { 4956dc618cdSElena Reshetova refcount_inc(&task->refcount); 49660ecebf5SMike Christie } 497913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_get_task); 49860ecebf5SMike Christie 4998eea2f55SEddie Wai void __iscsi_put_task(struct iscsi_task *task) 50060ecebf5SMike Christie { 5016dc618cdSElena Reshetova if (refcount_dec_and_test(&task->refcount)) 5023bbaaad9SMike Christie iscsi_free_task(task); 50360ecebf5SMike Christie } 5048eea2f55SEddie Wai EXPORT_SYMBOL_GPL(__iscsi_put_task); 50560ecebf5SMike Christie 5069c19a7d0SMike Christie void iscsi_put_task(struct iscsi_task *task) 5073e5c28adSMike Christie { 5089c19a7d0SMike Christie struct iscsi_session *session = task->conn->session; 5093e5c28adSMike Christie 510659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 511659743b0SShlomo Pongratz spin_lock_bh(&session->back_lock); 5129c19a7d0SMike Christie __iscsi_put_task(task); 513659743b0SShlomo Pongratz spin_unlock_bh(&session->back_lock); 5143e5c28adSMike Christie } 5159c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_put_task); 5163e5c28adSMike Christie 5173bbaaad9SMike Christie /** 5183bbaaad9SMike Christie * iscsi_complete_task - finish a task 5193bbaaad9SMike Christie * @task: iscsi cmd task 520b3cd5050SMike Christie * @state: state to complete task with 5213bbaaad9SMike Christie * 522659743b0SShlomo Pongratz * Must be called with session back_lock. 523b3a7ea8dSMike Christie */ 524b3cd5050SMike Christie static void iscsi_complete_task(struct iscsi_task *task, int state) 525b3a7ea8dSMike Christie { 5263bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 5273bbaaad9SMike Christie 5284421c9ebSMike Christie ISCSI_DBG_SESSION(conn->session, 5294421c9ebSMike Christie "complete task itt 0x%x state %d sc %p\n", 5304421c9ebSMike Christie task->itt, task->state, task->sc); 531b3cd5050SMike Christie if (task->state == ISCSI_TASK_COMPLETED || 532b3cd5050SMike Christie task->state == ISCSI_TASK_ABRT_TMF || 533f41d4721SMike Christie task->state == ISCSI_TASK_ABRT_SESS_RECOV || 534f41d4721SMike Christie task->state == ISCSI_TASK_REQUEUE_SCSIQ) 5353bbaaad9SMike Christie return; 5363bbaaad9SMike Christie WARN_ON_ONCE(task->state == ISCSI_TASK_FREE); 537b3cd5050SMike Christie task->state = state; 5383bbaaad9SMike Christie 5396f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 5406f8830f5SChris Leech if (!list_empty(&task->running)) { 5416f8830f5SChris Leech pr_debug_once("%s while task on list", __func__); 5423bbaaad9SMike Christie list_del_init(&task->running); 5436f8830f5SChris Leech } 5446f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 5453bbaaad9SMike Christie 5463bbaaad9SMike Christie if (conn->task == task) 5473bbaaad9SMike Christie conn->task = NULL; 5483bbaaad9SMike Christie 5493bbaaad9SMike Christie if (conn->ping_task == task) 5503bbaaad9SMike Christie conn->ping_task = NULL; 5513bbaaad9SMike Christie 5523bbaaad9SMike Christie /* release get from queueing */ 5533bbaaad9SMike Christie __iscsi_put_task(task); 5543bbaaad9SMike Christie } 5553bbaaad9SMike Christie 5564c0ba5d2SMike Christie /** 5574c0ba5d2SMike Christie * iscsi_complete_scsi_task - finish scsi task normally 5584c0ba5d2SMike Christie * @task: iscsi task for scsi cmd 5594c0ba5d2SMike Christie * @exp_cmdsn: expected cmd sn in cpu format 5604c0ba5d2SMike Christie * @max_cmdsn: max cmd sn in cpu format 5614c0ba5d2SMike Christie * 5624c0ba5d2SMike Christie * This is used when drivers do not need or cannot perform 5634c0ba5d2SMike Christie * lower level pdu processing. 5644c0ba5d2SMike Christie * 565659743b0SShlomo Pongratz * Called with session back_lock 5664c0ba5d2SMike Christie */ 5674c0ba5d2SMike Christie void iscsi_complete_scsi_task(struct iscsi_task *task, 5684c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 5694c0ba5d2SMike Christie { 5704c0ba5d2SMike Christie struct iscsi_conn *conn = task->conn; 5714c0ba5d2SMike Christie 5724c0ba5d2SMike Christie ISCSI_DBG_SESSION(conn->session, "[itt 0x%x]\n", task->itt); 5734c0ba5d2SMike Christie 5744c0ba5d2SMike Christie conn->last_recv = jiffies; 5754c0ba5d2SMike Christie __iscsi_update_cmdsn(conn->session, exp_cmdsn, max_cmdsn); 5764c0ba5d2SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 5774c0ba5d2SMike Christie } 5784c0ba5d2SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_scsi_task); 5794c0ba5d2SMike Christie 5804c0ba5d2SMike Christie 5813bbaaad9SMike Christie /* 582659743b0SShlomo Pongratz * session back_lock must be held and if not called for a task that is 5833bbaaad9SMike Christie * still pending or from the xmit thread, then xmit thread must 5843bbaaad9SMike Christie * be suspended. 5853bbaaad9SMike Christie */ 5863bbaaad9SMike Christie static void fail_scsi_task(struct iscsi_task *task, int err) 5873bbaaad9SMike Christie { 5883bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 589b3a7ea8dSMike Christie struct scsi_cmnd *sc; 590b3cd5050SMike Christie int state; 591b3a7ea8dSMike Christie 5923bbaaad9SMike Christie /* 5933bbaaad9SMike Christie * if a command completes and we get a successful tmf response 5943bbaaad9SMike Christie * we will hit this because the scsi eh abort code does not take 5953bbaaad9SMike Christie * a ref to the task. 5963bbaaad9SMike Christie */ 5979c19a7d0SMike Christie sc = task->sc; 598b3a7ea8dSMike Christie if (!sc) 599b3a7ea8dSMike Christie return; 600b3a7ea8dSMike Christie 601b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) { 602b3a7ea8dSMike Christie /* 603b3a7ea8dSMike Christie * cmd never made it to the xmit thread, so we should not count 604b3a7ea8dSMike Christie * the cmd in the sequencing 605b3a7ea8dSMike Christie */ 606b3a7ea8dSMike Christie conn->session->queued_cmdsn--; 607b3cd5050SMike Christie /* it was never sent so just complete like normal */ 608b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 609b3cd5050SMike Christie } else if (err == DID_TRANSPORT_DISRUPTED) 610b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 611b3cd5050SMike Christie else 612b3cd5050SMike Christie state = ISCSI_TASK_ABRT_TMF; 613b3a7ea8dSMike Christie 614b3cd5050SMike Christie sc->result = err << 16; 615b3a7ea8dSMike Christie scsi_set_resid(sc, scsi_bufflen(sc)); 6163e5c28adSMike Christie 617659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 618659743b0SShlomo Pongratz spin_lock_bh(&conn->session->back_lock); 619b3cd5050SMike Christie iscsi_complete_task(task, state); 620659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->back_lock); 621b3a7ea8dSMike Christie } 622b3a7ea8dSMike Christie 6233e5c28adSMike Christie static int iscsi_prep_mgmt_task(struct iscsi_conn *conn, 6249c19a7d0SMike Christie struct iscsi_task *task) 625052d0144SMike Christie { 626052d0144SMike Christie struct iscsi_session *session = conn->session; 627577577daSMike Christie struct iscsi_hdr *hdr = task->hdr; 628052d0144SMike Christie struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr; 6294f704dc0SMike Christie uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 630052d0144SMike Christie 631052d0144SMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 632052d0144SMike Christie return -ENOTCONN; 633052d0144SMike Christie 6344f704dc0SMike Christie if (opcode != ISCSI_OP_LOGIN && opcode != ISCSI_OP_TEXT) 635052d0144SMike Christie nop->exp_statsn = cpu_to_be32(conn->exp_statsn); 636052d0144SMike Christie /* 637052d0144SMike Christie * pre-format CmdSN for outgoing PDU. 638052d0144SMike Christie */ 639052d0144SMike Christie nop->cmdsn = cpu_to_be32(session->cmdsn); 640052d0144SMike Christie if (hdr->itt != RESERVED_ITT) { 641052d0144SMike Christie /* 6424f704dc0SMike Christie * TODO: We always use immediate for normal session pdus. 643052d0144SMike Christie * If we start to send tmfs or nops as non-immediate then 644052d0144SMike Christie * we should start checking the cmdsn numbers for mgmt tasks. 6454f704dc0SMike Christie * 6464f704dc0SMike Christie * During discovery sessions iscsid sends TEXT as non immediate, 6474f704dc0SMike Christie * but we always only send one PDU at a time. 648052d0144SMike Christie */ 649052d0144SMike Christie if (conn->c_stage == ISCSI_CONN_STARTED && 650052d0144SMike Christie !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 651052d0144SMike Christie session->queued_cmdsn++; 652052d0144SMike Christie session->cmdsn++; 653052d0144SMike Christie } 654052d0144SMike Christie } 655052d0144SMike Christie 656ae15f801SMike Christie if (session->tt->init_task && session->tt->init_task(task)) 657ae15f801SMike Christie return -EIO; 658052d0144SMike Christie 659052d0144SMike Christie if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT) 660052d0144SMike Christie session->state = ISCSI_STATE_LOGGING_OUT; 661052d0144SMike Christie 662577577daSMike Christie task->state = ISCSI_TASK_RUNNING; 6631b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "mgmtpdu [op 0x%x hdr->itt 0x%x " 6641b2c7af8SMike Christie "datalen %d]\n", hdr->opcode & ISCSI_OPCODE_MASK, 6651b2c7af8SMike Christie hdr->itt, task->data_count); 666052d0144SMike Christie return 0; 667052d0144SMike Christie } 668052d0144SMike Christie 6699c19a7d0SMike Christie static struct iscsi_task * 670f6d5180cSMike Christie __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 671f6d5180cSMike Christie char *data, uint32_t data_size) 672f6d5180cSMike Christie { 673f6d5180cSMike Christie struct iscsi_session *session = conn->session; 6741336aed1SMike Christie struct iscsi_host *ihost = shost_priv(session->host); 6754f704dc0SMike Christie uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 6769c19a7d0SMike Christie struct iscsi_task *task; 677262ef636SMike Christie itt_t itt; 678f6d5180cSMike Christie 679f6d5180cSMike Christie if (session->state == ISCSI_STATE_TERMINATE) 680f6d5180cSMike Christie return NULL; 681f6d5180cSMike Christie 6824f704dc0SMike Christie if (opcode == ISCSI_OP_LOGIN || opcode == ISCSI_OP_TEXT) { 683f6d5180cSMike Christie /* 684f6d5180cSMike Christie * Login and Text are sent serially, in 685f6d5180cSMike Christie * request-followed-by-response sequence. 6863e5c28adSMike Christie * Same task can be used. Same ITT must be used. 6873e5c28adSMike Christie * Note that login_task is preallocated at conn_create(). 688f6d5180cSMike Christie */ 6894f704dc0SMike Christie if (conn->login_task->state != ISCSI_TASK_FREE) { 6904f704dc0SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Login/Text in " 6914f704dc0SMike Christie "progress. Cannot start new task.\n"); 6924f704dc0SMike Christie return NULL; 6934f704dc0SMike Christie } 6944f704dc0SMike Christie 695cbaa4221SMike Christie if (data_size > ISCSI_DEF_MAX_RECV_SEG_LEN) { 696cbaa4221SMike 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); 697cbaa4221SMike Christie return NULL; 698cbaa4221SMike Christie } 699cbaa4221SMike Christie 7009c19a7d0SMike Christie task = conn->login_task; 7014f704dc0SMike Christie } else { 70226013ad4SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 70326013ad4SMike Christie return NULL; 70426013ad4SMike Christie 705cbaa4221SMike Christie if (data_size != 0) { 706cbaa4221SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Can not send data buffer of len %u for op 0x%x\n", data_size, opcode); 707cbaa4221SMike Christie return NULL; 708cbaa4221SMike Christie } 709cbaa4221SMike Christie 710f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE); 711f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED); 712f6d5180cSMike Christie 7137acd72ebSStefani Seibold if (!kfifo_out(&session->cmdpool.queue, 7149c19a7d0SMike Christie (void*)&task, sizeof(void*))) 715f6d5180cSMike Christie return NULL; 716f6d5180cSMike Christie } 7173e5c28adSMike Christie /* 7183e5c28adSMike Christie * released in complete pdu for task we expect a response for, and 7193e5c28adSMike Christie * released by the lld when it has transmitted the task for 7203e5c28adSMike Christie * pdus we do not expect a response for. 7213e5c28adSMike Christie */ 7226dc618cdSElena Reshetova refcount_set(&task->refcount, 1); 7239c19a7d0SMike Christie task->conn = conn; 7249c19a7d0SMike Christie task->sc = NULL; 7253bbaaad9SMike Christie INIT_LIST_HEAD(&task->running); 7263bbaaad9SMike Christie task->state = ISCSI_TASK_PENDING; 727f6d5180cSMike Christie 728f6d5180cSMike Christie if (data_size) { 7299c19a7d0SMike Christie memcpy(task->data, data, data_size); 7309c19a7d0SMike Christie task->data_count = data_size; 731f6d5180cSMike Christie } else 7329c19a7d0SMike Christie task->data_count = 0; 733f6d5180cSMike Christie 734184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 7352ff79d52SMike Christie if (conn->session->tt->alloc_pdu(task, hdr->opcode)) { 736577577daSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not allocate " 737577577daSMike Christie "pdu for mgmt task.\n"); 7383bbaaad9SMike Christie goto free_task; 739577577daSMike Christie } 740184b57c6SMike Christie } 741184b57c6SMike Christie 742262ef636SMike Christie itt = task->hdr->itt; 743577577daSMike Christie task->hdr_len = sizeof(struct iscsi_hdr); 7449c19a7d0SMike Christie memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr)); 745262ef636SMike Christie 746262ef636SMike Christie if (hdr->itt != RESERVED_ITT) { 747262ef636SMike Christie if (session->tt->parse_pdu_itt) 748262ef636SMike Christie task->hdr->itt = itt; 749262ef636SMike Christie else 750262ef636SMike Christie task->hdr->itt = build_itt(task->itt, 751262ef636SMike Christie task->conn->session->age); 752262ef636SMike Christie } 753262ef636SMike Christie 7541336aed1SMike Christie if (!ihost->workq) { 755577577daSMike Christie if (iscsi_prep_mgmt_task(conn, task)) 756577577daSMike Christie goto free_task; 757052d0144SMike Christie 7589c19a7d0SMike Christie if (session->tt->xmit_task(task)) 759577577daSMike Christie goto free_task; 7603bbaaad9SMike Christie } else { 7616f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 7623bbaaad9SMike Christie list_add_tail(&task->running, &conn->mgmtqueue); 7636f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 76432ae763eSMike Christie iscsi_conn_queue_work(conn); 7653bbaaad9SMike Christie } 766052d0144SMike Christie 7679c19a7d0SMike Christie return task; 768577577daSMike Christie 769577577daSMike Christie free_task: 770659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 7714fa50799SJitendra Bhivare spin_lock(&session->back_lock); 772577577daSMike Christie __iscsi_put_task(task); 7734fa50799SJitendra Bhivare spin_unlock(&session->back_lock); 774577577daSMike Christie return NULL; 775f6d5180cSMike Christie } 776f6d5180cSMike Christie 777f6d5180cSMike Christie int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr, 778f6d5180cSMike Christie char *data, uint32_t data_size) 779f6d5180cSMike Christie { 780f6d5180cSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 781f6d5180cSMike Christie struct iscsi_session *session = conn->session; 782f6d5180cSMike Christie int err = 0; 783f6d5180cSMike Christie 784659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 785f6d5180cSMike Christie if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size)) 786f6d5180cSMike Christie err = -EPERM; 787659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 788f6d5180cSMike Christie return err; 789f6d5180cSMike Christie } 790f6d5180cSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu); 791f6d5180cSMike Christie 7927996a778SMike Christie /** 7937996a778SMike Christie * iscsi_cmd_rsp - SCSI Command Response processing 7947996a778SMike Christie * @conn: iscsi connection 7957996a778SMike Christie * @hdr: iscsi header 7969c19a7d0SMike Christie * @task: scsi command task 7977996a778SMike Christie * @data: cmd data buffer 7987996a778SMike Christie * @datalen: len of buffer 7997996a778SMike Christie * 8007996a778SMike Christie * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and 8019c19a7d0SMike Christie * then completes the command and task. 8027996a778SMike Christie **/ 80377a23c21SMike Christie static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 8049c19a7d0SMike Christie struct iscsi_task *task, char *data, 8057996a778SMike Christie int datalen) 8067996a778SMike Christie { 80712352183SNicholas Bellinger struct iscsi_scsi_rsp *rhdr = (struct iscsi_scsi_rsp *)hdr; 8087996a778SMike Christie struct iscsi_session *session = conn->session; 8099c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 8107996a778SMike Christie 81177a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr); 8127996a778SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 8137996a778SMike Christie 8147996a778SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 8157996a778SMike Christie 81655e51edaSSagi Grimberg if (task->protected) { 81755e51edaSSagi Grimberg sector_t sector; 81855e51edaSSagi Grimberg u8 ascq; 81955e51edaSSagi Grimberg 82055e51edaSSagi Grimberg /** 82155e51edaSSagi Grimberg * Transports that didn't implement check_protection 82255e51edaSSagi Grimberg * callback but still published T10-PI support to scsi-mid 82355e51edaSSagi Grimberg * deserve this BUG_ON. 82455e51edaSSagi Grimberg **/ 82555e51edaSSagi Grimberg BUG_ON(!session->tt->check_protection); 82655e51edaSSagi Grimberg 82755e51edaSSagi Grimberg ascq = session->tt->check_protection(task, §or); 82855e51edaSSagi Grimberg if (ascq) { 82955e51edaSSagi Grimberg sc->result = DRIVER_SENSE << 24 | 83055e51edaSSagi Grimberg SAM_STAT_CHECK_CONDITION; 83155e51edaSSagi Grimberg scsi_build_sense_buffer(1, sc->sense_buffer, 83255e51edaSSagi Grimberg ILLEGAL_REQUEST, 0x10, ascq); 833a73c2a2fSSagi Grimberg scsi_set_sense_information(sc->sense_buffer, 834a73c2a2fSSagi Grimberg SCSI_SENSE_BUFFERSIZE, 835a73c2a2fSSagi Grimberg sector); 83655e51edaSSagi Grimberg goto out; 83755e51edaSSagi Grimberg } 83855e51edaSSagi Grimberg } 83955e51edaSSagi Grimberg 8407996a778SMike Christie if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) { 8417996a778SMike Christie sc->result = DID_ERROR << 16; 8427996a778SMike Christie goto out; 8437996a778SMike Christie } 8447996a778SMike Christie 8457996a778SMike Christie if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) { 8469b80cb4bSMike Christie uint16_t senselen; 8477996a778SMike Christie 8487996a778SMike Christie if (datalen < 2) { 8497996a778SMike Christie invalid_datalen: 850322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 851322d739dSMike Christie "Got CHECK_CONDITION but invalid data " 852322d739dSMike Christie "buffer size of %d\n", datalen); 8537996a778SMike Christie sc->result = DID_BAD_TARGET << 16; 8547996a778SMike Christie goto out; 8557996a778SMike Christie } 8567996a778SMike Christie 8578f333991SHarvey Harrison senselen = get_unaligned_be16(data); 8587996a778SMike Christie if (datalen < senselen) 8597996a778SMike Christie goto invalid_datalen; 8607996a778SMike Christie 8617996a778SMike Christie memcpy(sc->sense_buffer, data + 2, 8629b80cb4bSMike Christie min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 8631b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n", 8641b2c7af8SMike Christie min_t(uint16_t, senselen, 8651b2c7af8SMike Christie SCSI_SENSE_BUFFERSIZE)); 8667996a778SMike Christie } 8677996a778SMike Christie 868c07d4444SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW | 869c07d4444SBoaz Harrosh ISCSI_FLAG_CMD_BIDI_OVERFLOW)) { 870c07d4444SBoaz Harrosh sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 871c07d4444SBoaz Harrosh } 872c07d4444SBoaz Harrosh 8737207fea4SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW | 8747207fea4SBoaz Harrosh ISCSI_FLAG_CMD_OVERFLOW)) { 8757996a778SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 8767996a778SMike Christie 8777207fea4SBoaz Harrosh if (res_count > 0 && 8787207fea4SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 8797207fea4SBoaz Harrosh res_count <= scsi_bufflen(sc))) 880c07d4444SBoaz Harrosh /* write side for bidi or uni-io set_resid */ 8811c138991SFUJITA Tomonori scsi_set_resid(sc, res_count); 8827996a778SMike Christie else 8837996a778SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 884c07d4444SBoaz Harrosh } 8857996a778SMike Christie out: 8863bbaaad9SMike Christie ISCSI_DBG_SESSION(session, "cmd rsp done [sc %p res %d itt 0x%x]\n", 8871b2c7af8SMike Christie sc, sc->result, task->itt); 8887996a778SMike Christie conn->scsirsp_pdus_cnt++; 889b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 8907996a778SMike Christie } 8917996a778SMike Christie 8921d9edf02SMike Christie /** 8931d9edf02SMike Christie * iscsi_data_in_rsp - SCSI Data-In Response processing 8941d9edf02SMike Christie * @conn: iscsi connection 8951d9edf02SMike Christie * @hdr: iscsi pdu 8961d9edf02SMike Christie * @task: scsi command task 8971d9edf02SMike Christie **/ 8981d9edf02SMike Christie static void 8991d9edf02SMike Christie iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 9001d9edf02SMike Christie struct iscsi_task *task) 9011d9edf02SMike Christie { 9021d9edf02SMike Christie struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr; 9031d9edf02SMike Christie struct scsi_cmnd *sc = task->sc; 9041d9edf02SMike Christie 9051d9edf02SMike Christie if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS)) 9061d9edf02SMike Christie return; 9071d9edf02SMike Christie 908edbc9aa0SMike Christie iscsi_update_cmdsn(conn->session, (struct iscsi_nopin *)hdr); 9091d9edf02SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 9101d9edf02SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 9111d9edf02SMike Christie if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW | 9121d9edf02SMike Christie ISCSI_FLAG_DATA_OVERFLOW)) { 9131d9edf02SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 9141d9edf02SMike Christie 9151d9edf02SMike Christie if (res_count > 0 && 9161d9edf02SMike Christie (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 917*ae3d56d8SChristoph Hellwig res_count <= sc->sdb.length)) 918*ae3d56d8SChristoph Hellwig sc->sdb.resid = res_count; 9191d9edf02SMike Christie else 9201d9edf02SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 9211d9edf02SMike Christie } 9221d9edf02SMike Christie 9233bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, "data in with status done " 9243bbaaad9SMike Christie "[sc %p res %d itt 0x%x]\n", 9253bbaaad9SMike Christie sc, sc->result, task->itt); 9261d9edf02SMike Christie conn->scsirsp_pdus_cnt++; 927b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 9281d9edf02SMike Christie } 9291d9edf02SMike Christie 9307ea8b828SMike Christie static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) 9317ea8b828SMike Christie { 9327ea8b828SMike Christie struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; 9337ea8b828SMike Christie 9347ea8b828SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 9357ea8b828SMike Christie conn->tmfrsp_pdus_cnt++; 9367ea8b828SMike Christie 937843c0a8aSMike Christie if (conn->tmf_state != TMF_QUEUED) 9387ea8b828SMike Christie return; 9397ea8b828SMike Christie 9407ea8b828SMike Christie if (tmf->response == ISCSI_TMF_RSP_COMPLETE) 941843c0a8aSMike Christie conn->tmf_state = TMF_SUCCESS; 9427ea8b828SMike Christie else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) 943843c0a8aSMike Christie conn->tmf_state = TMF_NOT_FOUND; 9447ea8b828SMike Christie else 945843c0a8aSMike Christie conn->tmf_state = TMF_FAILED; 9467ea8b828SMike Christie wake_up(&conn->ehwait); 9477ea8b828SMike Christie } 9487ea8b828SMike Christie 94952f5664aSAriel Nahum static int iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) 950f6d5180cSMike Christie { 951f6d5180cSMike Christie struct iscsi_nopout hdr; 9529c19a7d0SMike Christie struct iscsi_task *task; 953f6d5180cSMike Christie 9549c19a7d0SMike Christie if (!rhdr && conn->ping_task) 95552f5664aSAriel Nahum return -EINVAL; 956f6d5180cSMike Christie 957f6d5180cSMike Christie memset(&hdr, 0, sizeof(struct iscsi_nopout)); 958f6d5180cSMike Christie hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE; 959f6d5180cSMike Christie hdr.flags = ISCSI_FLAG_CMD_FINAL; 960f6d5180cSMike Christie 961f6d5180cSMike Christie if (rhdr) { 96255bdabdfSAndy Grover hdr.lun = rhdr->lun; 963f6d5180cSMike Christie hdr.ttt = rhdr->ttt; 964f6d5180cSMike Christie hdr.itt = RESERVED_ITT; 965f6d5180cSMike Christie } else 966f6d5180cSMike Christie hdr.ttt = RESERVED_ITT; 967f6d5180cSMike Christie 9689c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0); 96952f5664aSAriel Nahum if (!task) { 970322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n"); 97152f5664aSAriel Nahum return -EIO; 97252f5664aSAriel Nahum } else if (!rhdr) { 973d3acf022SMike Christie /* only track our nops */ 974d3acf022SMike Christie conn->ping_task = task; 975d3acf022SMike Christie conn->last_ping = jiffies; 976d3acf022SMike Christie } 97752f5664aSAriel Nahum 97852f5664aSAriel Nahum return 0; 979f6d5180cSMike Christie } 980f6d5180cSMike Christie 9818afa1439SMike Christie static int iscsi_nop_out_rsp(struct iscsi_task *task, 9828afa1439SMike Christie struct iscsi_nopin *nop, char *data, int datalen) 9838afa1439SMike Christie { 9848afa1439SMike Christie struct iscsi_conn *conn = task->conn; 9858afa1439SMike Christie int rc = 0; 9868afa1439SMike Christie 9878afa1439SMike Christie if (conn->ping_task != task) { 9888afa1439SMike Christie /* 9898afa1439SMike Christie * If this is not in response to one of our 9908afa1439SMike Christie * nops then it must be from userspace. 9918afa1439SMike Christie */ 9928afa1439SMike Christie if (iscsi_recv_pdu(conn->cls_conn, (struct iscsi_hdr *)nop, 9938afa1439SMike Christie data, datalen)) 9948afa1439SMike Christie rc = ISCSI_ERR_CONN_FAILED; 9958afa1439SMike Christie } else 9968afa1439SMike Christie mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout); 9978afa1439SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 9988afa1439SMike Christie return rc; 9998afa1439SMike Christie } 10008afa1439SMike Christie 100162f38300SMike Christie static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 100262f38300SMike Christie char *data, int datalen) 100362f38300SMike Christie { 100462f38300SMike Christie struct iscsi_reject *reject = (struct iscsi_reject *)hdr; 100562f38300SMike Christie struct iscsi_hdr rejected_pdu; 10068afa1439SMike Christie int opcode, rc = 0; 100762f38300SMike Christie 100862f38300SMike Christie conn->exp_statsn = be32_to_cpu(reject->statsn) + 1; 100962f38300SMike Christie 10108afa1439SMike Christie if (ntoh24(reject->dlength) > datalen || 10118afa1439SMike Christie ntoh24(reject->dlength) < sizeof(struct iscsi_hdr)) { 10128afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Cannot handle rejected " 10138afa1439SMike Christie "pdu. Invalid data length (pdu dlength " 10148afa1439SMike Christie "%u, datalen %d\n", ntoh24(reject->dlength), 10158afa1439SMike Christie datalen); 101662f38300SMike Christie return ISCSI_ERR_PROTO; 10178afa1439SMike Christie } 101862f38300SMike Christie memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr)); 10198afa1439SMike Christie opcode = rejected_pdu.opcode & ISCSI_OPCODE_MASK; 10208afa1439SMike Christie 10218afa1439SMike Christie switch (reject->reason) { 10228afa1439SMike Christie case ISCSI_REASON_DATA_DIGEST_ERROR: 1023322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 10248afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected " 1025262ef636SMike Christie "due to DataDigest error.\n", 1026e5dbbe27SVaughan Cao opcode, rejected_pdu.itt); 10278afa1439SMike Christie break; 10288afa1439SMike Christie case ISCSI_REASON_IMM_CMD_REJECT: 10298afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 10308afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Too many " 10318afa1439SMike Christie "immediate commands.\n", 1032e5dbbe27SVaughan Cao opcode, rejected_pdu.itt); 10338afa1439SMike Christie /* 10348afa1439SMike Christie * We only send one TMF at a time so if the target could not 10358afa1439SMike Christie * handle it, then it should get fixed (RFC mandates that 10368afa1439SMike Christie * a target can handle one immediate TMF per conn). 10378afa1439SMike Christie * 10388afa1439SMike Christie * For nops-outs, we could have sent more than one if 10398afa1439SMike Christie * the target is sending us lots of nop-ins 10408afa1439SMike Christie */ 10418afa1439SMike Christie if (opcode != ISCSI_OP_NOOP_OUT) 104262f38300SMike Christie return 0; 10438afa1439SMike Christie 1044659743b0SShlomo Pongratz if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG)) { 10458afa1439SMike Christie /* 10468afa1439SMike Christie * nop-out in response to target's nop-out rejected. 10478afa1439SMike Christie * Just resend. 10488afa1439SMike Christie */ 1049659743b0SShlomo Pongratz /* In RX path we are under back lock */ 1050659743b0SShlomo Pongratz spin_unlock(&conn->session->back_lock); 1051659743b0SShlomo Pongratz spin_lock(&conn->session->frwd_lock); 10528afa1439SMike Christie iscsi_send_nopout(conn, 10538afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu); 1054659743b0SShlomo Pongratz spin_unlock(&conn->session->frwd_lock); 1055659743b0SShlomo Pongratz spin_lock(&conn->session->back_lock); 1056659743b0SShlomo Pongratz } else { 10578afa1439SMike Christie struct iscsi_task *task; 10588afa1439SMike Christie /* 10598afa1439SMike Christie * Our nop as ping got dropped. We know the target 10608afa1439SMike Christie * and transport are ok so just clean up 10618afa1439SMike Christie */ 10628afa1439SMike Christie task = iscsi_itt_to_task(conn, rejected_pdu.itt); 10638afa1439SMike Christie if (!task) { 10648afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 10658afa1439SMike Christie "Invalid pdu reject. Could " 10668afa1439SMike Christie "not lookup rejected task.\n"); 10678afa1439SMike Christie rc = ISCSI_ERR_BAD_ITT; 10688afa1439SMike Christie } else 10698afa1439SMike Christie rc = iscsi_nop_out_rsp(task, 10708afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu, 10718afa1439SMike Christie NULL, 0); 10728afa1439SMike Christie } 10738afa1439SMike Christie break; 10748afa1439SMike Christie default: 10758afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 10768afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Reason " 1077e5dbbe27SVaughan Cao "code 0x%x\n", rejected_pdu.opcode, 1078e5dbbe27SVaughan Cao rejected_pdu.itt, reject->reason); 10798afa1439SMike Christie break; 10808afa1439SMike Christie } 10818afa1439SMike Christie return rc; 108262f38300SMike Christie } 108362f38300SMike Christie 10847996a778SMike Christie /** 1085913e5bf4SMike Christie * iscsi_itt_to_task - look up task by itt 1086913e5bf4SMike Christie * @conn: iscsi connection 1087913e5bf4SMike Christie * @itt: itt 1088913e5bf4SMike Christie * 1089913e5bf4SMike Christie * This should be used for mgmt tasks like login and nops, or if 1090913e5bf4SMike Christie * the LDD's itt space does not include the session age. 1091913e5bf4SMike Christie * 1092659743b0SShlomo Pongratz * The session back_lock must be held. 1093913e5bf4SMike Christie */ 10948f9256ceSMike Christie struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt) 1095913e5bf4SMike Christie { 1096913e5bf4SMike Christie struct iscsi_session *session = conn->session; 1097262ef636SMike Christie int i; 1098913e5bf4SMike Christie 1099913e5bf4SMike Christie if (itt == RESERVED_ITT) 1100913e5bf4SMike Christie return NULL; 1101913e5bf4SMike Christie 1102262ef636SMike Christie if (session->tt->parse_pdu_itt) 1103262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, NULL); 1104262ef636SMike Christie else 1105913e5bf4SMike Christie i = get_itt(itt); 1106913e5bf4SMike Christie if (i >= session->cmds_max) 1107913e5bf4SMike Christie return NULL; 1108913e5bf4SMike Christie 1109913e5bf4SMike Christie return session->cmds[i]; 1110913e5bf4SMike Christie } 11118f9256ceSMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_task); 1112913e5bf4SMike Christie 1113913e5bf4SMike Christie /** 11147996a778SMike Christie * __iscsi_complete_pdu - complete pdu 11157996a778SMike Christie * @conn: iscsi conn 11167996a778SMike Christie * @hdr: iscsi header 11177996a778SMike Christie * @data: data buffer 11187996a778SMike Christie * @datalen: len of data buffer 11197996a778SMike Christie * 11207996a778SMike Christie * Completes pdu processing by freeing any resources allocated at 1121659743b0SShlomo Pongratz * queuecommand or send generic. session back_lock must be held and verify 11227996a778SMike Christie * itt must have been called. 11237996a778SMike Christie */ 1124913e5bf4SMike Christie int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 11257996a778SMike Christie char *data, int datalen) 11267996a778SMike Christie { 11277996a778SMike Christie struct iscsi_session *session = conn->session; 11287996a778SMike Christie int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0; 11299c19a7d0SMike Christie struct iscsi_task *task; 11307996a778SMike Christie uint32_t itt; 11317996a778SMike Christie 1132f6d5180cSMike Christie conn->last_recv = jiffies; 11330af967f5SMike Christie rc = iscsi_verify_itt(conn, hdr->itt); 11340af967f5SMike Christie if (rc) 11350af967f5SMike Christie return rc; 11360af967f5SMike Christie 1137b4377356SAl Viro if (hdr->itt != RESERVED_ITT) 1138b4377356SAl Viro itt = get_itt(hdr->itt); 11397996a778SMike Christie else 1140b4377356SAl Viro itt = ~0U; 11417996a778SMike Christie 11421b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "[op 0x%x cid %d itt 0x%x len %d]\n", 11433e5c28adSMike Christie opcode, conn->id, itt, datalen); 11447996a778SMike Christie 11453e5c28adSMike Christie if (itt == ~0U) { 114677a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 114762f38300SMike Christie 11487996a778SMike Christie switch(opcode) { 11497996a778SMike Christie case ISCSI_OP_NOOP_IN: 115040527afeSMike Christie if (datalen) { 115140527afeSMike Christie rc = ISCSI_ERR_PROTO; 115240527afeSMike Christie break; 115340527afeSMike Christie } 115440527afeSMike Christie 1155b4377356SAl Viro if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) 115640527afeSMike Christie break; 115740527afeSMike Christie 1158659743b0SShlomo Pongratz /* In RX path we are under back lock */ 1159659743b0SShlomo Pongratz spin_unlock(&session->back_lock); 1160659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 1161f6d5180cSMike Christie iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr); 1162659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 1163659743b0SShlomo Pongratz spin_lock(&session->back_lock); 11647996a778SMike Christie break; 11657996a778SMike Christie case ISCSI_OP_REJECT: 116662f38300SMike Christie rc = iscsi_handle_reject(conn, hdr, data, datalen); 116762f38300SMike Christie break; 11687996a778SMike Christie case ISCSI_OP_ASYNC_EVENT: 11698d2860b3SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 11705831c737SMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 11715831c737SMike Christie rc = ISCSI_ERR_CONN_FAILED; 11727996a778SMike Christie break; 11737996a778SMike Christie default: 11747996a778SMike Christie rc = ISCSI_ERR_BAD_OPCODE; 11757996a778SMike Christie break; 11767996a778SMike Christie } 11773e5c28adSMike Christie goto out; 11783e5c28adSMike Christie } 11797996a778SMike Christie 11803e5c28adSMike Christie switch(opcode) { 11813e5c28adSMike Christie case ISCSI_OP_SCSI_CMD_RSP: 1182913e5bf4SMike Christie case ISCSI_OP_SCSI_DATA_IN: 1183913e5bf4SMike Christie task = iscsi_itt_to_ctask(conn, hdr->itt); 1184913e5bf4SMike Christie if (!task) 1185913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1186d355e57dSMike Christie task->last_xfer = jiffies; 11873e5c28adSMike Christie break; 1188913e5bf4SMike Christie case ISCSI_OP_R2T: 1189913e5bf4SMike Christie /* 1190913e5bf4SMike Christie * LLD handles R2Ts if they need to. 1191913e5bf4SMike Christie */ 1192913e5bf4SMike Christie return 0; 1193913e5bf4SMike Christie case ISCSI_OP_LOGOUT_RSP: 1194913e5bf4SMike Christie case ISCSI_OP_LOGIN_RSP: 1195913e5bf4SMike Christie case ISCSI_OP_TEXT_RSP: 1196913e5bf4SMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 1197913e5bf4SMike Christie case ISCSI_OP_NOOP_IN: 1198913e5bf4SMike Christie task = iscsi_itt_to_task(conn, hdr->itt); 1199913e5bf4SMike Christie if (!task) 1200913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1201913e5bf4SMike Christie break; 1202913e5bf4SMike Christie default: 1203913e5bf4SMike Christie return ISCSI_ERR_BAD_OPCODE; 12043e5c28adSMike Christie } 1205913e5bf4SMike Christie 1206913e5bf4SMike Christie switch(opcode) { 1207913e5bf4SMike Christie case ISCSI_OP_SCSI_CMD_RSP: 12089c19a7d0SMike Christie iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen); 12093e5c28adSMike Christie break; 12103e5c28adSMike Christie case ISCSI_OP_SCSI_DATA_IN: 12111d9edf02SMike Christie iscsi_data_in_rsp(conn, hdr, task); 12123e5c28adSMike Christie break; 12133e5c28adSMike Christie case ISCSI_OP_LOGOUT_RSP: 12143e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12153e5c28adSMike Christie if (datalen) { 12163e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12173e5c28adSMike Christie break; 12183e5c28adSMike Christie } 12193e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 12203e5c28adSMike Christie goto recv_pdu; 12213e5c28adSMike Christie case ISCSI_OP_LOGIN_RSP: 12223e5c28adSMike Christie case ISCSI_OP_TEXT_RSP: 12233e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12243e5c28adSMike Christie /* 12253e5c28adSMike Christie * login related PDU's exp_statsn is handled in 12263e5c28adSMike Christie * userspace 12273e5c28adSMike Christie */ 12283e5c28adSMike Christie goto recv_pdu; 12293e5c28adSMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 12303e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12313e5c28adSMike Christie if (datalen) { 12323e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12333e5c28adSMike Christie break; 12343e5c28adSMike Christie } 12353e5c28adSMike Christie 12363e5c28adSMike Christie iscsi_tmf_rsp(conn, hdr); 1237b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 12383e5c28adSMike Christie break; 12393e5c28adSMike Christie case ISCSI_OP_NOOP_IN: 12403e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12413e5c28adSMike Christie if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) { 12423e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12433e5c28adSMike Christie break; 12443e5c28adSMike Christie } 12453e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 12463e5c28adSMike Christie 12478afa1439SMike Christie rc = iscsi_nop_out_rsp(task, (struct iscsi_nopin*)hdr, 12488afa1439SMike Christie data, datalen); 12493e5c28adSMike Christie break; 12503e5c28adSMike Christie default: 12513e5c28adSMike Christie rc = ISCSI_ERR_BAD_OPCODE; 12523e5c28adSMike Christie break; 12533e5c28adSMike Christie } 12543e5c28adSMike Christie 12553e5c28adSMike Christie out: 12563e5c28adSMike Christie return rc; 12573e5c28adSMike Christie recv_pdu: 12583e5c28adSMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 12593e5c28adSMike Christie rc = ISCSI_ERR_CONN_FAILED; 1260b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 12617996a778SMike Christie return rc; 12627996a778SMike Christie } 1263913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_complete_pdu); 12647996a778SMike Christie 12657996a778SMike Christie int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 12667996a778SMike Christie char *data, int datalen) 12677996a778SMike Christie { 12687996a778SMike Christie int rc; 12697996a778SMike Christie 1270659743b0SShlomo Pongratz spin_lock(&conn->session->back_lock); 12717996a778SMike Christie rc = __iscsi_complete_pdu(conn, hdr, data, datalen); 1272659743b0SShlomo Pongratz spin_unlock(&conn->session->back_lock); 12737996a778SMike Christie return rc; 12747996a778SMike Christie } 12757996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_pdu); 12767996a778SMike Christie 12770af967f5SMike Christie int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt) 12787996a778SMike Christie { 12797996a778SMike Christie struct iscsi_session *session = conn->session; 1280262ef636SMike Christie int age = 0, i = 0; 12817996a778SMike Christie 12820af967f5SMike Christie if (itt == RESERVED_ITT) 12830af967f5SMike Christie return 0; 12840af967f5SMike Christie 1285262ef636SMike Christie if (session->tt->parse_pdu_itt) 1286262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, &age); 1287262ef636SMike Christie else { 1288262ef636SMike Christie i = get_itt(itt); 1289262ef636SMike Christie age = ((__force u32)itt >> ISCSI_AGE_SHIFT) & ISCSI_AGE_MASK; 1290262ef636SMike Christie } 1291262ef636SMike Christie 1292262ef636SMike Christie if (age != session->age) { 1293322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 12940af967f5SMike Christie "received itt %x expected session age (%x)\n", 1295913e5bf4SMike Christie (__force u32)itt, session->age); 12967996a778SMike Christie return ISCSI_ERR_BAD_ITT; 12977996a778SMike Christie } 12987996a778SMike Christie 12993e5c28adSMike Christie if (i >= session->cmds_max) { 13003e5c28adSMike Christie iscsi_conn_printk(KERN_ERR, conn, 13013e5c28adSMike Christie "received invalid itt index %u (max cmds " 13023e5c28adSMike Christie "%u.\n", i, session->cmds_max); 13033e5c28adSMike Christie return ISCSI_ERR_BAD_ITT; 13047996a778SMike Christie } 13057996a778SMike Christie return 0; 13067996a778SMike Christie } 13077996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_verify_itt); 13087996a778SMike Christie 1309913e5bf4SMike Christie /** 1310913e5bf4SMike Christie * iscsi_itt_to_ctask - look up ctask by itt 1311913e5bf4SMike Christie * @conn: iscsi connection 1312913e5bf4SMike Christie * @itt: itt 1313913e5bf4SMike Christie * 1314913e5bf4SMike Christie * This should be used for cmd tasks. 1315913e5bf4SMike Christie * 1316659743b0SShlomo Pongratz * The session back_lock must be held. 1317913e5bf4SMike Christie */ 1318913e5bf4SMike Christie struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt) 13190af967f5SMike Christie { 13209c19a7d0SMike Christie struct iscsi_task *task; 13210af967f5SMike Christie 13220af967f5SMike Christie if (iscsi_verify_itt(conn, itt)) 13230af967f5SMike Christie return NULL; 13240af967f5SMike Christie 1325913e5bf4SMike Christie task = iscsi_itt_to_task(conn, itt); 1326913e5bf4SMike Christie if (!task || !task->sc) 13270af967f5SMike Christie return NULL; 13280af967f5SMike Christie 1329913e5bf4SMike Christie if (task->sc->SCp.phase != conn->session->age) { 1330913e5bf4SMike Christie iscsi_session_printk(KERN_ERR, conn->session, 1331913e5bf4SMike Christie "task's session age %d, expected %d\n", 1332913e5bf4SMike Christie task->sc->SCp.phase, conn->session->age); 13330af967f5SMike Christie return NULL; 1334913e5bf4SMike Christie } 13350af967f5SMike Christie 13369c19a7d0SMike Christie return task; 13370af967f5SMike Christie } 13380af967f5SMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask); 13390af967f5SMike Christie 134040a06e75SMike Christie void iscsi_session_failure(struct iscsi_session *session, 1341e5bd7b54SMike Christie enum iscsi_err err) 1342e5bd7b54SMike Christie { 1343e5bd7b54SMike Christie struct iscsi_conn *conn; 1344e5bd7b54SMike Christie struct device *dev; 1345e5bd7b54SMike Christie 1346659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 1347e5bd7b54SMike Christie conn = session->leadconn; 1348e5bd7b54SMike Christie if (session->state == ISCSI_STATE_TERMINATE || !conn) { 1349659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1350e5bd7b54SMike Christie return; 1351e5bd7b54SMike Christie } 1352e5bd7b54SMike Christie 1353e5bd7b54SMike Christie dev = get_device(&conn->cls_conn->dev); 1354659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1355e5bd7b54SMike Christie if (!dev) 1356e5bd7b54SMike Christie return; 1357e5bd7b54SMike Christie /* 1358e5bd7b54SMike Christie * if the host is being removed bypass the connection 1359e5bd7b54SMike Christie * recovery initialization because we are going to kill 1360e5bd7b54SMike Christie * the session. 1361e5bd7b54SMike Christie */ 1362e5bd7b54SMike Christie if (err == ISCSI_ERR_INVALID_HOST) 1363e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 1364e5bd7b54SMike Christie else 1365e5bd7b54SMike Christie iscsi_conn_failure(conn, err); 1366e5bd7b54SMike Christie put_device(dev); 1367e5bd7b54SMike Christie } 1368e5bd7b54SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_failure); 1369e5bd7b54SMike Christie 13707996a778SMike Christie void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err) 13717996a778SMike Christie { 13727996a778SMike Christie struct iscsi_session *session = conn->session; 13737996a778SMike Christie 1374659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 1375656cffc9SMike Christie if (session->state == ISCSI_STATE_FAILED) { 1376659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1377656cffc9SMike Christie return; 1378656cffc9SMike Christie } 1379656cffc9SMike Christie 138067a61114SMike Christie if (conn->stop_stage == 0) 13817996a778SMike Christie session->state = ISCSI_STATE_FAILED; 1382659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1383e5bd7b54SMike Christie 13847996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 13857996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 1386e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 13877996a778SMike Christie } 13887996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_failure); 13897996a778SMike Christie 139077a23c21SMike Christie static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn) 139177a23c21SMike Christie { 139277a23c21SMike Christie struct iscsi_session *session = conn->session; 139377a23c21SMike Christie 139477a23c21SMike Christie /* 139577a23c21SMike Christie * Check for iSCSI window and take care of CmdSN wrap-around 139677a23c21SMike Christie */ 1397e0726407SMike Christie if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) { 13981b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iSCSI CmdSN closed. ExpCmdSn " 13991b2c7af8SMike Christie "%u MaxCmdSN %u CmdSN %u/%u\n", 14001b2c7af8SMike Christie session->exp_cmdsn, session->max_cmdsn, 14011b2c7af8SMike Christie session->cmdsn, session->queued_cmdsn); 140277a23c21SMike Christie return -ENOSPC; 140377a23c21SMike Christie } 140477a23c21SMike Christie return 0; 140577a23c21SMike Christie } 140677a23c21SMike Christie 14079c19a7d0SMike Christie static int iscsi_xmit_task(struct iscsi_conn *conn) 140877a23c21SMike Christie { 14099c19a7d0SMike Christie struct iscsi_task *task = conn->task; 1410843c0a8aSMike Christie int rc; 141177a23c21SMike Christie 141270b31c15SMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) 141370b31c15SMike Christie return -ENODATA; 141470b31c15SMike Christie 14159c19a7d0SMike Christie __iscsi_get_task(task); 1416659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 14179c19a7d0SMike Christie rc = conn->session->tt->xmit_task(task); 1418659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 1419d355e57dSMike Christie if (!rc) { 14209c19a7d0SMike Christie /* done with this task */ 1421d355e57dSMike Christie task->last_xfer = jiffies; 14229c19a7d0SMike Christie conn->task = NULL; 1423d355e57dSMike Christie } 1424659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 142572b97402SShlomo Pongratz spin_lock(&conn->session->back_lock); 1426d355e57dSMike Christie __iscsi_put_task(task); 142772b97402SShlomo Pongratz spin_unlock(&conn->session->back_lock); 142877a23c21SMike Christie return rc; 142977a23c21SMike Christie } 143077a23c21SMike Christie 14317996a778SMike Christie /** 14329c19a7d0SMike Christie * iscsi_requeue_task - requeue task to run from session workqueue 14339c19a7d0SMike Christie * @task: task to requeue 1434843c0a8aSMike Christie * 14359c19a7d0SMike Christie * LLDs that need to run a task from the session workqueue should call 1436659743b0SShlomo Pongratz * this. The session frwd_lock must be held. This should only be called 1437052d0144SMike Christie * by software drivers. 1438843c0a8aSMike Christie */ 14399c19a7d0SMike Christie void iscsi_requeue_task(struct iscsi_task *task) 1440843c0a8aSMike Christie { 14419c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 1442843c0a8aSMike Christie 14433bbaaad9SMike Christie /* 14443bbaaad9SMike Christie * this may be on the requeue list already if the xmit_task callout 14453bbaaad9SMike Christie * is handling the r2ts while we are adding new ones 14463bbaaad9SMike Christie */ 14476f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 14483bbaaad9SMike Christie if (list_empty(&task->running)) 14493bbaaad9SMike Christie list_add_tail(&task->running, &conn->requeue); 14506f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 145132ae763eSMike Christie iscsi_conn_queue_work(conn); 1452843c0a8aSMike Christie } 14539c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_requeue_task); 1454843c0a8aSMike Christie 1455843c0a8aSMike Christie /** 14567996a778SMike Christie * iscsi_data_xmit - xmit any command into the scheduled connection 14577996a778SMike Christie * @conn: iscsi connection 14587996a778SMike Christie * 14597996a778SMike Christie * Notes: 14607996a778SMike Christie * The function can return -EAGAIN in which case the caller must 14617996a778SMike Christie * re-schedule it again later or recover. '0' return code means 14627996a778SMike Christie * successful xmit. 14637996a778SMike Christie **/ 14647996a778SMike Christie static int iscsi_data_xmit(struct iscsi_conn *conn) 14657996a778SMike Christie { 14665d12c05eSMike Christie struct iscsi_task *task; 14673219e529SMike Christie int rc = 0; 14687996a778SMike Christie 1469659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 147070b31c15SMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) { 14711b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n"); 1472659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 14733219e529SMike Christie return -ENODATA; 14747996a778SMike Christie } 14757996a778SMike Christie 14769c19a7d0SMike Christie if (conn->task) { 14779c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 14783219e529SMike Christie if (rc) 147970b31c15SMike Christie goto done; 14807996a778SMike Christie } 148177a23c21SMike Christie 148277a23c21SMike Christie /* 148377a23c21SMike Christie * process mgmt pdus like nops before commands since we should 148477a23c21SMike Christie * only have one nop-out as a ping from us and targets should not 148577a23c21SMike Christie * overflow us with nop-ins 148677a23c21SMike Christie */ 14876f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 148877a23c21SMike Christie check_mgmt: 1489843c0a8aSMike Christie while (!list_empty(&conn->mgmtqueue)) { 14909c19a7d0SMike Christie conn->task = list_entry(conn->mgmtqueue.next, 14919c19a7d0SMike Christie struct iscsi_task, running); 14923bbaaad9SMike Christie list_del_init(&conn->task->running); 14936f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 14949c19a7d0SMike Christie if (iscsi_prep_mgmt_task(conn, conn->task)) { 1495659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 1496659743b0SShlomo Pongratz spin_lock_bh(&conn->session->back_lock); 14979c19a7d0SMike Christie __iscsi_put_task(conn->task); 1498659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->back_lock); 14999c19a7d0SMike Christie conn->task = NULL; 15006f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 1501b3a7ea8dSMike Christie continue; 1502b3a7ea8dSMike Christie } 15039c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 15043219e529SMike Christie if (rc) 150570b31c15SMike Christie goto done; 15066f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 15077996a778SMike Christie } 15087996a778SMike Christie 1509843c0a8aSMike Christie /* process pending command queue */ 15103bbaaad9SMike Christie while (!list_empty(&conn->cmdqueue)) { 15115d12c05eSMike Christie conn->task = list_entry(conn->cmdqueue.next, struct iscsi_task, 15125d12c05eSMike Christie running); 15133bbaaad9SMike Christie list_del_init(&conn->task->running); 15146f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 1515b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) { 1516b3cd5050SMike Christie fail_scsi_task(conn->task, DID_IMM_RETRY); 15176f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 1518b3a7ea8dSMike Christie continue; 1519b3a7ea8dSMike Christie } 1520577577daSMike Christie rc = iscsi_prep_scsi_cmd_pdu(conn->task); 1521577577daSMike Christie if (rc) { 15225d12c05eSMike Christie if (rc == -ENOMEM || rc == -EACCES) { 15236f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 15243bbaaad9SMike Christie list_add_tail(&conn->task->running, 15253bbaaad9SMike Christie &conn->cmdqueue); 1526577577daSMike Christie conn->task = NULL; 15276f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 152870b31c15SMike Christie goto done; 1529577577daSMike Christie } else 1530b3cd5050SMike Christie fail_scsi_task(conn->task, DID_ABORT); 15316f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 1532004d6530SBoaz Harrosh continue; 1533004d6530SBoaz Harrosh } 15349c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 15353219e529SMike Christie if (rc) 153670b31c15SMike Christie goto done; 153777a23c21SMike Christie /* 15389c19a7d0SMike Christie * we could continuously get new task requests so 153977a23c21SMike Christie * we need to check the mgmt queue for nops that need to 154077a23c21SMike Christie * be sent to aviod starvation 154177a23c21SMike Christie */ 15426f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 1543843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 1544843c0a8aSMike Christie goto check_mgmt; 1545843c0a8aSMike Christie } 1546843c0a8aSMike Christie 1547843c0a8aSMike Christie while (!list_empty(&conn->requeue)) { 1548b3a7ea8dSMike Christie /* 1549b3a7ea8dSMike Christie * we always do fastlogout - conn stop code will clean up. 1550b3a7ea8dSMike Christie */ 1551b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 1552b3a7ea8dSMike Christie break; 1553b3a7ea8dSMike Christie 15545d12c05eSMike Christie task = list_entry(conn->requeue.next, struct iscsi_task, 15555d12c05eSMike Christie running); 15565d12c05eSMike Christie if (iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_DATA_OUT)) 15575d12c05eSMike Christie break; 15585d12c05eSMike Christie 15595d12c05eSMike Christie conn->task = task; 15603bbaaad9SMike Christie list_del_init(&conn->task->running); 15619c19a7d0SMike Christie conn->task->state = ISCSI_TASK_RUNNING; 15626f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 15639c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 1564843c0a8aSMike Christie if (rc) 156570b31c15SMike Christie goto done; 15666f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 1567843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 156877a23c21SMike Christie goto check_mgmt; 15697996a778SMike Christie } 15706f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 1571659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 15723219e529SMike Christie return -ENODATA; 15737996a778SMike Christie 157470b31c15SMike Christie done: 1575659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 15763219e529SMike Christie return rc; 15777996a778SMike Christie } 15787996a778SMike Christie 1579c4028958SDavid Howells static void iscsi_xmitworker(struct work_struct *work) 15807996a778SMike Christie { 1581c4028958SDavid Howells struct iscsi_conn *conn = 1582c4028958SDavid Howells container_of(work, struct iscsi_conn, xmitwork); 15833219e529SMike Christie int rc; 15847996a778SMike Christie /* 15857996a778SMike Christie * serialize Xmit worker on a per-connection basis. 15867996a778SMike Christie */ 15873219e529SMike Christie do { 15883219e529SMike Christie rc = iscsi_data_xmit(conn); 15893219e529SMike Christie } while (rc >= 0 || rc == -EAGAIN); 15907996a778SMike Christie } 15917996a778SMike Christie 1592577577daSMike Christie static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn, 1593577577daSMike Christie struct scsi_cmnd *sc) 1594577577daSMike Christie { 1595577577daSMike Christie struct iscsi_task *task; 1596577577daSMike Christie 15977acd72ebSStefani Seibold if (!kfifo_out(&conn->session->cmdpool.queue, 1598577577daSMike Christie (void *) &task, sizeof(void *))) 1599577577daSMike Christie return NULL; 1600577577daSMike Christie 1601577577daSMike Christie sc->SCp.phase = conn->session->age; 1602577577daSMike Christie sc->SCp.ptr = (char *) task; 1603577577daSMike Christie 16046dc618cdSElena Reshetova refcount_set(&task->refcount, 1); 1605577577daSMike Christie task->state = ISCSI_TASK_PENDING; 1606577577daSMike Christie task->conn = conn; 1607577577daSMike Christie task->sc = sc; 1608d355e57dSMike Christie task->have_checked_conn = false; 1609d355e57dSMike Christie task->last_timeout = jiffies; 1610d355e57dSMike Christie task->last_xfer = jiffies; 161155e51edaSSagi Grimberg task->protected = false; 1612577577daSMike Christie INIT_LIST_HEAD(&task->running); 1613577577daSMike Christie return task; 1614577577daSMike Christie } 1615577577daSMike Christie 16167996a778SMike Christie enum { 16177996a778SMike Christie FAILURE_BAD_HOST = 1, 16187996a778SMike Christie FAILURE_SESSION_FAILED, 16197996a778SMike Christie FAILURE_SESSION_FREED, 16207996a778SMike Christie FAILURE_WINDOW_CLOSED, 162160ecebf5SMike Christie FAILURE_OOM, 16227996a778SMike Christie FAILURE_SESSION_TERMINATE, 1623656cffc9SMike Christie FAILURE_SESSION_IN_RECOVERY, 16247996a778SMike Christie FAILURE_SESSION_RECOVERY_TIMEOUT, 1625b3a7ea8dSMike Christie FAILURE_SESSION_LOGGING_OUT, 16266eabafbeSMike Christie FAILURE_SESSION_NOT_READY, 16277996a778SMike Christie }; 16287996a778SMike Christie 1629f41d4721SMike Christie int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc) 16307996a778SMike Christie { 163175613521SMike Christie struct iscsi_cls_session *cls_session; 16321336aed1SMike Christie struct iscsi_host *ihost; 16337996a778SMike Christie int reason = 0; 16347996a778SMike Christie struct iscsi_session *session; 16357996a778SMike Christie struct iscsi_conn *conn; 16369c19a7d0SMike Christie struct iscsi_task *task = NULL; 16377996a778SMike Christie 16387996a778SMike Christie sc->result = 0; 1639f47f2cf5SMike Christie sc->SCp.ptr = NULL; 16407996a778SMike Christie 16411336aed1SMike Christie ihost = shost_priv(host); 16427996a778SMike Christie 164375613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 164475613521SMike Christie session = cls_session->dd_data; 1645659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 16467996a778SMike Christie 164775613521SMike Christie reason = iscsi_session_chkready(cls_session); 16486eabafbeSMike Christie if (reason) { 16496eabafbeSMike Christie sc->result = reason; 16506eabafbeSMike Christie goto fault; 16516eabafbeSMike Christie } 16526eabafbeSMike Christie 1653301e0f7eSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1654656cffc9SMike Christie /* 1655656cffc9SMike Christie * to handle the race between when we set the recovery state 1656656cffc9SMike Christie * and block the session we requeue here (commands could 1657656cffc9SMike Christie * be entering our queuecommand while a block is starting 1658656cffc9SMike Christie * up because the block code is not locked) 1659656cffc9SMike Christie */ 16609000bcd6SMike Christie switch (session->state) { 1661301e0f7eSMike Christie case ISCSI_STATE_FAILED: 1662d7549412SRafael David Tinoco /* 1663d7549412SRafael David Tinoco * cmds should fail during shutdown, if the session 1664d7549412SRafael David Tinoco * state is bad, allowing completion to happen 1665d7549412SRafael David Tinoco */ 1666d7549412SRafael David Tinoco if (unlikely(system_state != SYSTEM_RUNNING)) { 1667d7549412SRafael David Tinoco reason = FAILURE_SESSION_FAILED; 1668d7549412SRafael David Tinoco sc->result = DID_NO_CONNECT << 16; 1669d7549412SRafael David Tinoco break; 1670d7549412SRafael David Tinoco } 1671807cf197SBart Van Assche /* fall through */ 16729000bcd6SMike Christie case ISCSI_STATE_IN_RECOVERY: 1673656cffc9SMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1674301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1675301e0f7eSMike Christie break; 16769000bcd6SMike Christie case ISCSI_STATE_LOGGING_OUT: 16779000bcd6SMike Christie reason = FAILURE_SESSION_LOGGING_OUT; 1678301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1679301e0f7eSMike Christie break; 1680b3a7ea8dSMike Christie case ISCSI_STATE_RECOVERY_FAILED: 1681656cffc9SMike Christie reason = FAILURE_SESSION_RECOVERY_TIMEOUT; 168256d7fcfaSMike Christie sc->result = DID_TRANSPORT_FAILFAST << 16; 1683b3a7ea8dSMike Christie break; 1684b3a7ea8dSMike Christie case ISCSI_STATE_TERMINATE: 1685656cffc9SMike Christie reason = FAILURE_SESSION_TERMINATE; 16866eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1687b3a7ea8dSMike Christie break; 1688b3a7ea8dSMike Christie default: 16897996a778SMike Christie reason = FAILURE_SESSION_FREED; 16906eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1691b3a7ea8dSMike Christie } 16927996a778SMike Christie goto fault; 16937996a778SMike Christie } 16947996a778SMike Christie 16957996a778SMike Christie conn = session->leadconn; 169698644047SMike Christie if (!conn) { 169798644047SMike Christie reason = FAILURE_SESSION_FREED; 16986eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 169998644047SMike Christie goto fault; 170098644047SMike Christie } 17017996a778SMike Christie 1702661134adSMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) { 1703661134adSMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1704eef9ffdfSJohannes Thumshirn sc->result = DID_REQUEUE << 16; 1705661134adSMike Christie goto fault; 1706661134adSMike Christie } 1707661134adSMike Christie 170877a23c21SMike Christie if (iscsi_check_cmdsn_window_closed(conn)) { 170977a23c21SMike Christie reason = FAILURE_WINDOW_CLOSED; 171077a23c21SMike Christie goto reject; 171177a23c21SMike Christie } 171277a23c21SMike Christie 1713577577daSMike Christie task = iscsi_alloc_task(conn, sc); 1714577577daSMike Christie if (!task) { 171560ecebf5SMike Christie reason = FAILURE_OOM; 171660ecebf5SMike Christie goto reject; 171760ecebf5SMike Christie } 17187996a778SMike Christie 17191336aed1SMike Christie if (!ihost->workq) { 1720577577daSMike Christie reason = iscsi_prep_scsi_cmd_pdu(task); 1721577577daSMike Christie if (reason) { 17225d12c05eSMike Christie if (reason == -ENOMEM || reason == -EACCES) { 1723577577daSMike Christie reason = FAILURE_OOM; 1724577577daSMike Christie goto prepd_reject; 1725577577daSMike Christie } else { 1726052d0144SMike Christie sc->result = DID_ABORT << 16; 1727577577daSMike Christie goto prepd_fault; 1728577577daSMike Christie } 1729052d0144SMike Christie } 17309c19a7d0SMike Christie if (session->tt->xmit_task(task)) { 1731d3305f34SMike Christie session->cmdsn--; 1732052d0144SMike Christie reason = FAILURE_SESSION_NOT_READY; 1733577577daSMike Christie goto prepd_reject; 1734052d0144SMike Christie } 17353bbaaad9SMike Christie } else { 17366f8830f5SChris Leech spin_lock_bh(&conn->taskqueuelock); 17373bbaaad9SMike Christie list_add_tail(&task->running, &conn->cmdqueue); 17386f8830f5SChris Leech spin_unlock_bh(&conn->taskqueuelock); 173932ae763eSMike Christie iscsi_conn_queue_work(conn); 17403bbaaad9SMike Christie } 1741052d0144SMike Christie 1742052d0144SMike Christie session->queued_cmdsn++; 1743659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 17447996a778SMike Christie return 0; 17457996a778SMike Christie 1746577577daSMike Christie prepd_reject: 1747f41d4721SMike Christie iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 17487996a778SMike Christie reject: 1749659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 17501b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n", 17511b2c7af8SMike Christie sc->cmnd[0], reason); 1752d6d13ee1SMike Christie return SCSI_MLQUEUE_TARGET_BUSY; 17537996a778SMike Christie 1754577577daSMike Christie prepd_fault: 1755f41d4721SMike Christie iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 17567996a778SMike Christie fault: 1757659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 17581b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n", 17591b2c7af8SMike Christie sc->cmnd[0], reason); 17601c138991SFUJITA Tomonori scsi_set_resid(sc, scsi_bufflen(sc)); 1761f41d4721SMike Christie sc->scsi_done(sc); 17627996a778SMike Christie return 0; 17637996a778SMike Christie } 17647996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_queuecommand); 17657996a778SMike Christie 17666b5d6c44SMike Christie int iscsi_target_alloc(struct scsi_target *starget) 17676b5d6c44SMike Christie { 17686b5d6c44SMike Christie struct iscsi_cls_session *cls_session = starget_to_session(starget); 17696b5d6c44SMike Christie struct iscsi_session *session = cls_session->dd_data; 17706b5d6c44SMike Christie 17716b5d6c44SMike Christie starget->can_queue = session->scsi_cmds_max; 17726b5d6c44SMike Christie return 0; 17736b5d6c44SMike Christie } 17746b5d6c44SMike Christie EXPORT_SYMBOL_GPL(iscsi_target_alloc); 17756b5d6c44SMike Christie 17762c4b9637SKees Cook static void iscsi_tmf_timedout(struct timer_list *t) 17777996a778SMike Christie { 17782c4b9637SKees Cook struct iscsi_conn *conn = from_timer(conn, t, tmf_timer); 17797996a778SMike Christie struct iscsi_session *session = conn->session; 17807996a778SMike Christie 1781659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 1782843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) { 1783843c0a8aSMike Christie conn->tmf_state = TMF_TIMEDOUT; 1784bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf timedout\n"); 17857996a778SMike Christie /* unblock eh_abort() */ 17867996a778SMike Christie wake_up(&conn->ehwait); 17877996a778SMike Christie } 1788659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 17897996a778SMike Christie } 17907996a778SMike Christie 17919c19a7d0SMike Christie static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, 1792f6d5180cSMike Christie struct iscsi_tm *hdr, int age, 1793f6d5180cSMike Christie int timeout) 17941360c58aSBart Van Assche __must_hold(&session->frwd_lock) 17957996a778SMike Christie { 17967996a778SMike Christie struct iscsi_session *session = conn->session; 17979c19a7d0SMike Christie struct iscsi_task *task; 17987996a778SMike Christie 17999c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr, 18007996a778SMike Christie NULL, 0); 18019c19a7d0SMike Christie if (!task) { 1802659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1803df4da5cdSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send TMF.\n"); 18047996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1805659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 180677a23c21SMike Christie return -EPERM; 18077996a778SMike Christie } 18087996a778SMike Christie conn->tmfcmd_pdus_cnt++; 1809f6d5180cSMike Christie conn->tmf_timer.expires = timeout * HZ + jiffies; 1810843c0a8aSMike Christie add_timer(&conn->tmf_timer); 1811bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf set timeout\n"); 1812843c0a8aSMike Christie 1813659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 18146724add1SMike Christie mutex_unlock(&session->eh_mutex); 18157996a778SMike Christie 18167996a778SMike Christie /* 18177996a778SMike Christie * block eh thread until: 18187996a778SMike Christie * 1819843c0a8aSMike Christie * 1) tmf response 1820843c0a8aSMike Christie * 2) tmf timeout 18217996a778SMike Christie * 3) session is terminated or restarted or userspace has 18227996a778SMike Christie * given up on recovery 18237996a778SMike Christie */ 1824843c0a8aSMike Christie wait_event_interruptible(conn->ehwait, age != session->age || 18257996a778SMike Christie session->state != ISCSI_STATE_LOGGED_IN || 1826843c0a8aSMike Christie conn->tmf_state != TMF_QUEUED); 18277996a778SMike Christie if (signal_pending(current)) 18287996a778SMike Christie flush_signals(current); 1829843c0a8aSMike Christie del_timer_sync(&conn->tmf_timer); 1830843c0a8aSMike Christie 18316724add1SMike Christie mutex_lock(&session->eh_mutex); 1832659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 18339c19a7d0SMike Christie /* if the session drops it will clean up the task */ 1834843c0a8aSMike Christie if (age != session->age || 1835843c0a8aSMike Christie session->state != ISCSI_STATE_LOGGED_IN) 1836843c0a8aSMike Christie return -ENOTCONN; 18377996a778SMike Christie return 0; 18387996a778SMike Christie } 18397996a778SMike Christie 18407996a778SMike Christie /* 1841843c0a8aSMike Christie * Fail commands. session lock held and recv side suspended and xmit 1842843c0a8aSMike Christie * thread flushed 1843843c0a8aSMike Christie */ 18449cb78c16SHannes Reinecke static void fail_scsi_tasks(struct iscsi_conn *conn, u64 lun, int error) 1845843c0a8aSMike Christie { 18463bbaaad9SMike Christie struct iscsi_task *task; 18473bbaaad9SMike Christie int i; 1848843c0a8aSMike Christie 18493bbaaad9SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 18503bbaaad9SMike Christie task = conn->session->cmds[i]; 18513bbaaad9SMike Christie if (!task->sc || task->state == ISCSI_TASK_FREE) 18523bbaaad9SMike Christie continue; 1853843c0a8aSMike Christie 18543bbaaad9SMike Christie if (lun != -1 && lun != task->sc->device->lun) 18553bbaaad9SMike Christie continue; 18563bbaaad9SMike Christie 18571b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, 18583bbaaad9SMike Christie "failing sc %p itt 0x%x state %d\n", 18593bbaaad9SMike Christie task->sc, task->itt, task->state); 1860b3cd5050SMike Christie fail_scsi_task(task, error); 1861843c0a8aSMike Christie } 1862843c0a8aSMike Christie } 1863843c0a8aSMike Christie 1864661134adSMike Christie /** 1865661134adSMike Christie * iscsi_suspend_queue - suspend iscsi_queuecommand 1866661134adSMike Christie * @conn: iscsi conn to stop queueing IO on 1867661134adSMike Christie * 1868659743b0SShlomo Pongratz * This grabs the session frwd_lock to make sure no one is in 1869661134adSMike Christie * xmit_task/queuecommand, and then sets suspend to prevent 1870661134adSMike Christie * new commands from being queued. This only needs to be called 1871661134adSMike Christie * by offload drivers that need to sync a path like ep disconnect 1872661134adSMike Christie * with the iscsi_queuecommand/xmit_task. To start IO again libiscsi 1873661134adSMike Christie * will call iscsi_start_tx and iscsi_unblock_session when in FFP. 1874661134adSMike Christie */ 1875661134adSMike Christie void iscsi_suspend_queue(struct iscsi_conn *conn) 1876661134adSMike Christie { 1877659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 1878661134adSMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1879659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 1880661134adSMike Christie } 1881661134adSMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_queue); 1882661134adSMike Christie 1883661134adSMike Christie /** 1884661134adSMike Christie * iscsi_suspend_tx - suspend iscsi_data_xmit 1885661134adSMike Christie * @conn: iscsi conn tp stop processing IO on. 1886661134adSMike Christie * 1887661134adSMike Christie * This function sets the suspend bit to prevent iscsi_data_xmit 1888661134adSMike Christie * from sending new IO, and if work is queued on the xmit thread 1889661134adSMike Christie * it will wait for it to be completed. 1890661134adSMike Christie */ 1891b40977d9SMike Christie void iscsi_suspend_tx(struct iscsi_conn *conn) 18926724add1SMike Christie { 189332ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 189432ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 189532ae763eSMike Christie 18966724add1SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 18971336aed1SMike Christie if (ihost->workq) 189832ae763eSMike Christie flush_workqueue(ihost->workq); 18996724add1SMike Christie } 1900b40977d9SMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_tx); 19016724add1SMike Christie 19026724add1SMike Christie static void iscsi_start_tx(struct iscsi_conn *conn) 19036724add1SMike Christie { 19046724add1SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 190532ae763eSMike Christie iscsi_conn_queue_work(conn); 19066724add1SMike Christie } 19076724add1SMike Christie 19084c48a829SMike Christie /* 19094c48a829SMike Christie * We want to make sure a ping is in flight. It has timed out. 19104c48a829SMike Christie * And we are not busy processing a pdu that is making 19114c48a829SMike Christie * progress but got started before the ping and is taking a while 19124c48a829SMike Christie * to complete so the ping is just stuck behind it in a queue. 19134c48a829SMike Christie */ 19144c48a829SMike Christie static int iscsi_has_ping_timed_out(struct iscsi_conn *conn) 19154c48a829SMike Christie { 19164c48a829SMike Christie if (conn->ping_task && 19174c48a829SMike Christie time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) + 19184c48a829SMike Christie (conn->ping_timeout * HZ), jiffies)) 19194c48a829SMike Christie return 1; 19204c48a829SMike Christie else 19214c48a829SMike Christie return 0; 19224c48a829SMike Christie } 19234c48a829SMike Christie 1924b6a05c82SChristoph Hellwig enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc) 1925f6d5180cSMike Christie { 19266600593cSChristoph Hellwig enum blk_eh_timer_return rc = BLK_EH_DONE; 192792ed4d69SMike Christie struct iscsi_task *task = NULL, *running_task; 1928f6d5180cSMike Christie struct iscsi_cls_session *cls_session; 1929f6d5180cSMike Christie struct iscsi_session *session; 1930f6d5180cSMike Christie struct iscsi_conn *conn; 193192ed4d69SMike Christie int i; 1932f6d5180cSMike Christie 1933d355e57dSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 193475613521SMike Christie session = cls_session->dd_data; 1935f6d5180cSMike Christie 1936bd2199d4SErez Zilber ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc); 1937f6d5180cSMike Christie 1938659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 1939e3d338a5SMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 1940e3d338a5SMike Christie if (!task) { 1941e3d338a5SMike Christie /* 1942e3d338a5SMike Christie * Raced with completion. Blk layer has taken ownership 1943e3d338a5SMike Christie * so let timeout code complete it now. 1944e3d338a5SMike Christie */ 1945adb2b769SChristoph Hellwig rc = BLK_EH_DONE; 1946e3d338a5SMike Christie goto done; 1947e3d338a5SMike Christie } 1948e3d338a5SMike Christie 1949f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1950f6d5180cSMike Christie /* 1951d7549412SRafael David Tinoco * During shutdown, if session is prematurely disconnected, 1952d7549412SRafael David Tinoco * recovery won't happen and there will be hung cmds. Not 1953d7549412SRafael David Tinoco * handling cmds would trigger EH, also bad in this case. 1954d7549412SRafael David Tinoco * Instead, handle cmd, allow completion to happen and let 1955d7549412SRafael David Tinoco * upper layer to deal with the result. 1956d7549412SRafael David Tinoco */ 1957d7549412SRafael David Tinoco if (unlikely(system_state != SYSTEM_RUNNING)) { 1958d7549412SRafael David Tinoco sc->result = DID_NO_CONNECT << 16; 1959d7549412SRafael David Tinoco ISCSI_DBG_EH(session, "sc on shutdown, handled\n"); 1960adb2b769SChristoph Hellwig rc = BLK_EH_DONE; 1961d7549412SRafael David Tinoco goto done; 1962d7549412SRafael David Tinoco } 1963d7549412SRafael David Tinoco /* 1964f6d5180cSMike Christie * We are probably in the middle of iscsi recovery so let 1965f6d5180cSMike Christie * that complete and handle the error. 1966f6d5180cSMike Christie */ 1967242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1968f6d5180cSMike Christie goto done; 1969f6d5180cSMike Christie } 1970f6d5180cSMike Christie 1971f6d5180cSMike Christie conn = session->leadconn; 1972f6d5180cSMike Christie if (!conn) { 1973f6d5180cSMike Christie /* In the middle of shuting down */ 1974242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1975f6d5180cSMike Christie goto done; 1976f6d5180cSMike Christie } 1977f6d5180cSMike Christie 1978d355e57dSMike Christie /* 1979d355e57dSMike Christie * If we have sent (at least queued to the network layer) a pdu or 1980d355e57dSMike Christie * recvd one for the task since the last timeout ask for 1981d355e57dSMike Christie * more time. If on the next timeout we have not made progress 1982d355e57dSMike Christie * we can check if it is the task or connection when we send the 1983d355e57dSMike Christie * nop as a ping. 1984d355e57dSMike Christie */ 198592ed4d69SMike Christie if (time_after(task->last_xfer, task->last_timeout)) { 1986bd2199d4SErez Zilber ISCSI_DBG_EH(session, "Command making progress. Asking " 1987d355e57dSMike Christie "scsi-ml for more time to complete. " 198892ed4d69SMike Christie "Last data xfer at %lu. Last timeout was at " 1989d355e57dSMike Christie "%lu\n.", task->last_xfer, task->last_timeout); 1990d355e57dSMike Christie task->have_checked_conn = false; 1991d355e57dSMike Christie rc = BLK_EH_RESET_TIMER; 1992d355e57dSMike Christie goto done; 1993d355e57dSMike Christie } 1994d355e57dSMike Christie 1995f6d5180cSMike Christie if (!conn->recv_timeout && !conn->ping_timeout) 1996f6d5180cSMike Christie goto done; 1997f6d5180cSMike Christie /* 1998f6d5180cSMike Christie * if the ping timedout then we are in the middle of cleaning up 1999f6d5180cSMike Christie * and can let the iscsi eh handle it 2000f6d5180cSMike Christie */ 20014c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 2002242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 20034c48a829SMike Christie goto done; 20044c48a829SMike Christie } 2005d355e57dSMike Christie 200692ed4d69SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 200792ed4d69SMike Christie running_task = conn->session->cmds[i]; 200892ed4d69SMike Christie if (!running_task->sc || running_task == task || 200992ed4d69SMike Christie running_task->state != ISCSI_TASK_RUNNING) 201092ed4d69SMike Christie continue; 201192ed4d69SMike Christie 201292ed4d69SMike Christie /* 201392ed4d69SMike Christie * Only check if cmds started before this one have made 201492ed4d69SMike Christie * progress, or this could never fail 201592ed4d69SMike Christie */ 201692ed4d69SMike Christie if (time_after(running_task->sc->jiffies_at_alloc, 201792ed4d69SMike Christie task->sc->jiffies_at_alloc)) 201892ed4d69SMike Christie continue; 201992ed4d69SMike Christie 202092ed4d69SMike Christie if (time_after(running_task->last_xfer, task->last_timeout)) { 202192ed4d69SMike Christie /* 202292ed4d69SMike Christie * This task has not made progress, but a task 202392ed4d69SMike Christie * started before us has transferred data since 202492ed4d69SMike Christie * we started/last-checked. We could be queueing 202592ed4d69SMike Christie * too many tasks or the LU is bad. 202692ed4d69SMike Christie * 202792ed4d69SMike Christie * If the device is bad the cmds ahead of us on 202892ed4d69SMike Christie * other devs will complete, and this loop will 202992ed4d69SMike Christie * eventually fail starting the scsi eh. 203092ed4d69SMike Christie */ 203192ed4d69SMike Christie ISCSI_DBG_EH(session, "Command has not made progress " 203292ed4d69SMike Christie "but commands ahead of it have. " 203392ed4d69SMike Christie "Asking scsi-ml for more time to " 203492ed4d69SMike Christie "complete. Our last xfer vs running task " 203592ed4d69SMike Christie "last xfer %lu/%lu. Last check %lu.\n", 203692ed4d69SMike Christie task->last_xfer, running_task->last_xfer, 203792ed4d69SMike Christie task->last_timeout); 203892ed4d69SMike Christie rc = BLK_EH_RESET_TIMER; 203992ed4d69SMike Christie goto done; 204092ed4d69SMike Christie } 204192ed4d69SMike Christie } 204292ed4d69SMike Christie 2043d355e57dSMike Christie /* Assumes nop timeout is shorter than scsi cmd timeout */ 2044d355e57dSMike Christie if (task->have_checked_conn) 2045d355e57dSMike Christie goto done; 2046d355e57dSMike Christie 2047f6d5180cSMike Christie /* 2048d355e57dSMike Christie * Checking the transport already or nop from a cmd timeout still 2049d355e57dSMike Christie * running 2050f6d5180cSMike Christie */ 2051d355e57dSMike Christie if (conn->ping_task) { 2052d355e57dSMike Christie task->have_checked_conn = true; 2053242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 20544c48a829SMike Christie goto done; 20554c48a829SMike Christie } 20564c48a829SMike Christie 2057d355e57dSMike Christie /* Make sure there is a transport check done */ 2058d355e57dSMike Christie iscsi_send_nopout(conn, NULL); 2059d355e57dSMike Christie task->have_checked_conn = true; 2060242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 2061d355e57dSMike Christie 2062f6d5180cSMike Christie done: 2063d355e57dSMike Christie if (task) 2064d355e57dSMike Christie task->last_timeout = jiffies; 2065659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 2066bd2199d4SErez Zilber ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ? 2067d7549412SRafael David Tinoco "timer reset" : "shutdown or nh"); 2068f6d5180cSMike Christie return rc; 2069f6d5180cSMike Christie } 2070b6a05c82SChristoph Hellwig EXPORT_SYMBOL_GPL(iscsi_eh_cmd_timed_out); 2071f6d5180cSMike Christie 20722c4b9637SKees Cook static void iscsi_check_transport_timeouts(struct timer_list *t) 2073f6d5180cSMike Christie { 20742c4b9637SKees Cook struct iscsi_conn *conn = from_timer(conn, t, transport_timer); 2075f6d5180cSMike Christie struct iscsi_session *session = conn->session; 20764cf10435SMike Christie unsigned long recv_timeout, next_timeout = 0, last_recv; 2077f6d5180cSMike Christie 2078659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 2079f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 2080f6d5180cSMike Christie goto done; 2081f6d5180cSMike Christie 20824cf10435SMike Christie recv_timeout = conn->recv_timeout; 20834cf10435SMike Christie if (!recv_timeout) 2084f6d5180cSMike Christie goto done; 2085f6d5180cSMike Christie 20864cf10435SMike Christie recv_timeout *= HZ; 2087f6d5180cSMike Christie last_recv = conn->last_recv; 20884c48a829SMike Christie 20894c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 2090322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs " 20914c48a829SMike Christie "expired, recv timeout %d, last rx %lu, " 20924c48a829SMike Christie "last ping %lu, now %lu\n", 20934c48a829SMike Christie conn->ping_timeout, conn->recv_timeout, 20944c48a829SMike Christie last_recv, conn->last_ping, jiffies); 2095659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 209609ff742cSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_NOP_TIMEDOUT); 2097f6d5180cSMike Christie return; 2098f6d5180cSMike Christie } 2099f6d5180cSMike Christie 21004cf10435SMike Christie if (time_before_eq(last_recv + recv_timeout, jiffies)) { 2101f6d5180cSMike Christie /* send a ping to try to provoke some traffic */ 21021b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Sending nopout as ping\n"); 210352f5664aSAriel Nahum if (iscsi_send_nopout(conn, NULL)) 210452f5664aSAriel Nahum next_timeout = jiffies + (1 * HZ); 210552f5664aSAriel Nahum else 21064cf10435SMike Christie next_timeout = conn->last_ping + (conn->ping_timeout * HZ); 2107ad294e9cSMike Christie } else 21084cf10435SMike Christie next_timeout = last_recv + recv_timeout; 2109f6d5180cSMike Christie 21101b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout); 2111f6d5180cSMike Christie mod_timer(&conn->transport_timer, next_timeout); 2112f6d5180cSMike Christie done: 2113659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 2114f6d5180cSMike Christie } 2115f6d5180cSMike Christie 21169c19a7d0SMike Christie static void iscsi_prep_abort_task_pdu(struct iscsi_task *task, 2117843c0a8aSMike Christie struct iscsi_tm *hdr) 2118843c0a8aSMike Christie { 2119843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2120843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2121843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK; 2122843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 212355bdabdfSAndy Grover hdr->lun = task->lun; 2124577577daSMike Christie hdr->rtt = task->hdr_itt; 2125577577daSMike Christie hdr->refcmdsn = task->cmdsn; 2126843c0a8aSMike Christie } 2127843c0a8aSMike Christie 21287996a778SMike Christie int iscsi_eh_abort(struct scsi_cmnd *sc) 21297996a778SMike Christie { 213075613521SMike Christie struct iscsi_cls_session *cls_session; 213175613521SMike Christie struct iscsi_session *session; 2132f47f2cf5SMike Christie struct iscsi_conn *conn; 21339c19a7d0SMike Christie struct iscsi_task *task; 2134843c0a8aSMike Christie struct iscsi_tm *hdr; 2135e9e410e8SBart Van Assche int age; 21367996a778SMike Christie 213775613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 213875613521SMike Christie session = cls_session->dd_data; 213975613521SMike Christie 2140bd2199d4SErez Zilber ISCSI_DBG_EH(session, "aborting sc %p\n", sc); 21414421c9ebSMike Christie 21426724add1SMike Christie mutex_lock(&session->eh_mutex); 2143659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2144f47f2cf5SMike Christie /* 2145f47f2cf5SMike Christie * if session was ISCSI_STATE_IN_RECOVERY then we may not have 2146f47f2cf5SMike Christie * got the command. 2147f47f2cf5SMike Christie */ 2148f47f2cf5SMike Christie if (!sc->SCp.ptr) { 2149bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc never reached iscsi layer or " 21501b2c7af8SMike Christie "it completed.\n"); 2151659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 21526724add1SMike Christie mutex_unlock(&session->eh_mutex); 2153f47f2cf5SMike Christie return SUCCESS; 2154f47f2cf5SMike Christie } 2155f47f2cf5SMike Christie 21567996a778SMike Christie /* 21577996a778SMike Christie * If we are not logged in or we have started a new session 21587996a778SMike Christie * then let the host reset code handle this 21597996a778SMike Christie */ 2160843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN || 2161843c0a8aSMike Christie sc->SCp.phase != session->age) { 2162659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2163843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2164bd2199d4SErez Zilber ISCSI_DBG_EH(session, "failing abort due to dropped " 21654421c9ebSMike Christie "session.\n"); 2166843c0a8aSMike Christie return FAILED; 2167843c0a8aSMike Christie } 2168843c0a8aSMike Christie 2169843c0a8aSMike Christie conn = session->leadconn; 2170843c0a8aSMike Christie conn->eh_abort_cnt++; 2171843c0a8aSMike Christie age = session->age; 2172843c0a8aSMike Christie 21739c19a7d0SMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 2174bd2199d4SErez Zilber ISCSI_DBG_EH(session, "aborting [sc %p itt 0x%x]\n", 21751b2c7af8SMike Christie sc, task->itt); 21767996a778SMike Christie 21779c19a7d0SMike Christie /* task completed before time out */ 21789c19a7d0SMike Christie if (!task->sc) { 2179bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in progress\n"); 218077a23c21SMike Christie goto success; 21817ea8b828SMike Christie } 21827996a778SMike Christie 21839c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) { 2184b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 218577a23c21SMike Christie goto success; 218677a23c21SMike Christie } 21877996a778SMike Christie 2188843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2189843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 21907996a778SMike Christie goto failed; 2191843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 21927996a778SMike Christie 2193843c0a8aSMike Christie hdr = &conn->tmhdr; 21949c19a7d0SMike Christie iscsi_prep_abort_task_pdu(task, hdr); 2195843c0a8aSMike Christie 2196e9e410e8SBart Van Assche if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) 2197843c0a8aSMike Christie goto failed; 2198843c0a8aSMike Christie 2199843c0a8aSMike Christie switch (conn->tmf_state) { 2200843c0a8aSMike Christie case TMF_SUCCESS: 2201659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2202913e5bf4SMike Christie /* 2203913e5bf4SMike Christie * stop tx side incase the target had sent a abort rsp but 2204913e5bf4SMike Christie * the initiator was still writing out data. 2205913e5bf4SMike Christie */ 22066724add1SMike Christie iscsi_suspend_tx(conn); 22077996a778SMike Christie /* 2208913e5bf4SMike Christie * we do not stop the recv side because targets have been 2209913e5bf4SMike Christie * good and have never sent us a successful tmf response 2210913e5bf4SMike Christie * then sent more data for the cmd. 22117996a778SMike Christie */ 2212659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2213b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 2214843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 22155d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 2216659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 22176724add1SMike Christie iscsi_start_tx(conn); 221877a23c21SMike Christie goto success_unlocked; 2219843c0a8aSMike Christie case TMF_TIMEDOUT: 2220659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2221df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2222843c0a8aSMike Christie goto failed_unlocked; 2223843c0a8aSMike Christie case TMF_NOT_FOUND: 2224843c0a8aSMike Christie if (!sc->SCp.ptr) { 2225843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 22265d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 22279c19a7d0SMike Christie /* task completed before tmf abort response */ 2228bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in " 2229bd2199d4SErez Zilber "progress\n"); 223077a23c21SMike Christie goto success; 223177a23c21SMike Christie } 223277a23c21SMike Christie /* fall through */ 223377a23c21SMike Christie default: 2234843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2235843c0a8aSMike Christie goto failed; 223677a23c21SMike Christie } 22377996a778SMike Christie 223877a23c21SMike Christie success: 2239659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 224077a23c21SMike Christie success_unlocked: 2241bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n", 22421b2c7af8SMike Christie sc, task->itt); 22436724add1SMike Christie mutex_unlock(&session->eh_mutex); 22447996a778SMike Christie return SUCCESS; 22457996a778SMike Christie 22467996a778SMike Christie failed: 2247659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 224877a23c21SMike Christie failed_unlocked: 2249bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc, 22509c19a7d0SMike Christie task ? task->itt : 0); 22516724add1SMike Christie mutex_unlock(&session->eh_mutex); 22527996a778SMike Christie return FAILED; 22537996a778SMike Christie } 22547996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_abort); 22557996a778SMike Christie 2256843c0a8aSMike Christie static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 2257843c0a8aSMike Christie { 2258843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2259843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2260843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK; 2261843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 226255bdabdfSAndy Grover int_to_scsilun(sc->device->lun, &hdr->lun); 2263f6d5180cSMike Christie hdr->rtt = RESERVED_ITT; 2264843c0a8aSMike Christie } 2265843c0a8aSMike Christie 2266843c0a8aSMike Christie int iscsi_eh_device_reset(struct scsi_cmnd *sc) 2267843c0a8aSMike Christie { 226875613521SMike Christie struct iscsi_cls_session *cls_session; 226975613521SMike Christie struct iscsi_session *session; 2270843c0a8aSMike Christie struct iscsi_conn *conn; 2271843c0a8aSMike Christie struct iscsi_tm *hdr; 2272843c0a8aSMike Christie int rc = FAILED; 2273843c0a8aSMike Christie 227475613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 227575613521SMike Christie session = cls_session->dd_data; 227675613521SMike Christie 22779cb78c16SHannes Reinecke ISCSI_DBG_EH(session, "LU Reset [sc %p lun %llu]\n", sc, 22789cb78c16SHannes Reinecke sc->device->lun); 2279843c0a8aSMike Christie 2280843c0a8aSMike Christie mutex_lock(&session->eh_mutex); 2281659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2282843c0a8aSMike Christie /* 2283843c0a8aSMike Christie * Just check if we are not logged in. We cannot check for 2284843c0a8aSMike Christie * the phase because the reset could come from a ioctl. 2285843c0a8aSMike Christie */ 2286843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 2287843c0a8aSMike Christie goto unlock; 2288843c0a8aSMike Christie conn = session->leadconn; 2289843c0a8aSMike Christie 2290843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2291843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 2292843c0a8aSMike Christie goto unlock; 2293843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 2294843c0a8aSMike Christie 2295843c0a8aSMike Christie hdr = &conn->tmhdr; 2296843c0a8aSMike Christie iscsi_prep_lun_reset_pdu(sc, hdr); 2297843c0a8aSMike Christie 22989c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 2299f6d5180cSMike Christie session->lu_reset_timeout)) { 2300843c0a8aSMike Christie rc = FAILED; 2301843c0a8aSMike Christie goto unlock; 2302843c0a8aSMike Christie } 2303843c0a8aSMike Christie 2304843c0a8aSMike Christie switch (conn->tmf_state) { 2305843c0a8aSMike Christie case TMF_SUCCESS: 2306843c0a8aSMike Christie break; 2307843c0a8aSMike Christie case TMF_TIMEDOUT: 2308659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2309df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2310843c0a8aSMike Christie goto done; 2311843c0a8aSMike Christie default: 2312843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2313843c0a8aSMike Christie goto unlock; 2314843c0a8aSMike Christie } 2315843c0a8aSMike Christie 2316843c0a8aSMike Christie rc = SUCCESS; 2317659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2318843c0a8aSMike Christie 2319843c0a8aSMike Christie iscsi_suspend_tx(conn); 2320913e5bf4SMike Christie 2321659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 23225d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 23233bbaaad9SMike Christie fail_scsi_tasks(conn, sc->device->lun, DID_ERROR); 2324843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2325659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2326843c0a8aSMike Christie 2327843c0a8aSMike Christie iscsi_start_tx(conn); 2328843c0a8aSMike Christie goto done; 2329843c0a8aSMike Christie 2330843c0a8aSMike Christie unlock: 2331659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2332843c0a8aSMike Christie done: 2333bd2199d4SErez Zilber ISCSI_DBG_EH(session, "dev reset result = %s\n", 2334843c0a8aSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 2335843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2336843c0a8aSMike Christie return rc; 2337843c0a8aSMike Christie } 2338843c0a8aSMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_device_reset); 2339843c0a8aSMike Christie 23403fe5ae8bSMike Christie void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) 23413fe5ae8bSMike Christie { 23423fe5ae8bSMike Christie struct iscsi_session *session = cls_session->dd_data; 23433fe5ae8bSMike Christie 2344659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 23453fe5ae8bSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 23463fe5ae8bSMike Christie session->state = ISCSI_STATE_RECOVERY_FAILED; 23473fe5ae8bSMike Christie if (session->leadconn) 23483fe5ae8bSMike Christie wake_up(&session->leadconn->ehwait); 23493fe5ae8bSMike Christie } 2350659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 23513fe5ae8bSMike Christie } 23523fe5ae8bSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout); 23533fe5ae8bSMike Christie 23543fe5ae8bSMike Christie /** 23553fe5ae8bSMike Christie * iscsi_eh_session_reset - drop session and attempt relogin 23563fe5ae8bSMike Christie * @sc: scsi command 23573fe5ae8bSMike Christie * 23583fe5ae8bSMike Christie * This function will wait for a relogin, session termination from 23593fe5ae8bSMike Christie * userspace, or a recovery/replacement timeout. 23603fe5ae8bSMike Christie */ 2361309ce156SJayamohan Kallickal int iscsi_eh_session_reset(struct scsi_cmnd *sc) 23623fe5ae8bSMike Christie { 23633fe5ae8bSMike Christie struct iscsi_cls_session *cls_session; 23643fe5ae8bSMike Christie struct iscsi_session *session; 23653fe5ae8bSMike Christie struct iscsi_conn *conn; 23663fe5ae8bSMike Christie 23673fe5ae8bSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 23683fe5ae8bSMike Christie session = cls_session->dd_data; 23693fe5ae8bSMike Christie conn = session->leadconn; 23703fe5ae8bSMike Christie 23713fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2372659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 23733fe5ae8bSMike Christie if (session->state == ISCSI_STATE_TERMINATE) { 23743fe5ae8bSMike Christie failed: 23753fe5ae8bSMike Christie ISCSI_DBG_EH(session, 23763fe5ae8bSMike Christie "failing session reset: Could not log back into " 23775db6dd14SFred Herard "%s [age %d]\n", session->targetname, 23785db6dd14SFred Herard session->age); 2379659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 23803fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 23813fe5ae8bSMike Christie return FAILED; 23823fe5ae8bSMike Christie } 23833fe5ae8bSMike Christie 2384659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 23853fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 23863fe5ae8bSMike Christie /* 23873fe5ae8bSMike Christie * we drop the lock here but the leadconn cannot be destoyed while 23883fe5ae8bSMike Christie * we are in the scsi eh 23893fe5ae8bSMike Christie */ 2390df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 23913fe5ae8bSMike Christie 23923fe5ae8bSMike Christie ISCSI_DBG_EH(session, "wait for relogin\n"); 23933fe5ae8bSMike Christie wait_event_interruptible(conn->ehwait, 23943fe5ae8bSMike Christie session->state == ISCSI_STATE_TERMINATE || 23953fe5ae8bSMike Christie session->state == ISCSI_STATE_LOGGED_IN || 23963fe5ae8bSMike Christie session->state == ISCSI_STATE_RECOVERY_FAILED); 23973fe5ae8bSMike Christie if (signal_pending(current)) 23983fe5ae8bSMike Christie flush_signals(current); 23993fe5ae8bSMike Christie 24003fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2401659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 24023fe5ae8bSMike Christie if (session->state == ISCSI_STATE_LOGGED_IN) { 24033fe5ae8bSMike Christie ISCSI_DBG_EH(session, 24043fe5ae8bSMike Christie "session reset succeeded for %s,%s\n", 24053fe5ae8bSMike Christie session->targetname, conn->persistent_address); 24063fe5ae8bSMike Christie } else 24073fe5ae8bSMike Christie goto failed; 2408659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 24093fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 24103fe5ae8bSMike Christie return SUCCESS; 24113fe5ae8bSMike Christie } 2412309ce156SJayamohan Kallickal EXPORT_SYMBOL_GPL(iscsi_eh_session_reset); 24133fe5ae8bSMike Christie 24143fe5ae8bSMike Christie static void iscsi_prep_tgt_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 24153fe5ae8bSMike Christie { 24163fe5ae8bSMike Christie memset(hdr, 0, sizeof(*hdr)); 24173fe5ae8bSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 24183fe5ae8bSMike Christie hdr->flags = ISCSI_TM_FUNC_TARGET_WARM_RESET & ISCSI_FLAG_TM_FUNC_MASK; 24193fe5ae8bSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 24203fe5ae8bSMike Christie hdr->rtt = RESERVED_ITT; 24213fe5ae8bSMike Christie } 24223fe5ae8bSMike Christie 24233fe5ae8bSMike Christie /** 24243fe5ae8bSMike Christie * iscsi_eh_target_reset - reset target 24253fe5ae8bSMike Christie * @sc: scsi command 24263fe5ae8bSMike Christie * 2427309ce156SJayamohan Kallickal * This will attempt to send a warm target reset. 24283fe5ae8bSMike Christie */ 24293907adf6SBart Van Assche static int iscsi_eh_target_reset(struct scsi_cmnd *sc) 24303fe5ae8bSMike Christie { 24313fe5ae8bSMike Christie struct iscsi_cls_session *cls_session; 24323fe5ae8bSMike Christie struct iscsi_session *session; 24333fe5ae8bSMike Christie struct iscsi_conn *conn; 24343fe5ae8bSMike Christie struct iscsi_tm *hdr; 24353fe5ae8bSMike Christie int rc = FAILED; 24363fe5ae8bSMike Christie 24373fe5ae8bSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 24383fe5ae8bSMike Christie session = cls_session->dd_data; 24393fe5ae8bSMike Christie 24403fe5ae8bSMike Christie ISCSI_DBG_EH(session, "tgt Reset [sc %p tgt %s]\n", sc, 24413fe5ae8bSMike Christie session->targetname); 24423fe5ae8bSMike Christie 24433fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2444659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 24453fe5ae8bSMike Christie /* 24463fe5ae8bSMike Christie * Just check if we are not logged in. We cannot check for 24473fe5ae8bSMike Christie * the phase because the reset could come from a ioctl. 24483fe5ae8bSMike Christie */ 24493fe5ae8bSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 24503fe5ae8bSMike Christie goto unlock; 24513fe5ae8bSMike Christie conn = session->leadconn; 24523fe5ae8bSMike Christie 24533fe5ae8bSMike Christie /* only have one tmf outstanding at a time */ 24543fe5ae8bSMike Christie if (conn->tmf_state != TMF_INITIAL) 24553fe5ae8bSMike Christie goto unlock; 24563fe5ae8bSMike Christie conn->tmf_state = TMF_QUEUED; 24573fe5ae8bSMike Christie 24583fe5ae8bSMike Christie hdr = &conn->tmhdr; 24593fe5ae8bSMike Christie iscsi_prep_tgt_reset_pdu(sc, hdr); 24603fe5ae8bSMike Christie 24613fe5ae8bSMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 24623fe5ae8bSMike Christie session->tgt_reset_timeout)) { 24633fe5ae8bSMike Christie rc = FAILED; 24643fe5ae8bSMike Christie goto unlock; 24653fe5ae8bSMike Christie } 24663fe5ae8bSMike Christie 24673fe5ae8bSMike Christie switch (conn->tmf_state) { 24683fe5ae8bSMike Christie case TMF_SUCCESS: 24693fe5ae8bSMike Christie break; 24703fe5ae8bSMike Christie case TMF_TIMEDOUT: 2471659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2472df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 24733fe5ae8bSMike Christie goto done; 24743fe5ae8bSMike Christie default: 24753fe5ae8bSMike Christie conn->tmf_state = TMF_INITIAL; 24763fe5ae8bSMike Christie goto unlock; 24773fe5ae8bSMike Christie } 24783fe5ae8bSMike Christie 24793fe5ae8bSMike Christie rc = SUCCESS; 2480659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 24813fe5ae8bSMike Christie 24823fe5ae8bSMike Christie iscsi_suspend_tx(conn); 24833fe5ae8bSMike Christie 2484659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 24853fe5ae8bSMike Christie memset(hdr, 0, sizeof(*hdr)); 24863fe5ae8bSMike Christie fail_scsi_tasks(conn, -1, DID_ERROR); 24873fe5ae8bSMike Christie conn->tmf_state = TMF_INITIAL; 2488659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 24893fe5ae8bSMike Christie 24903fe5ae8bSMike Christie iscsi_start_tx(conn); 24913fe5ae8bSMike Christie goto done; 24923fe5ae8bSMike Christie 24933fe5ae8bSMike Christie unlock: 2494659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 24953fe5ae8bSMike Christie done: 24963fe5ae8bSMike Christie ISCSI_DBG_EH(session, "tgt %s reset result = %s\n", session->targetname, 24973fe5ae8bSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 24983fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 2499309ce156SJayamohan Kallickal return rc; 2500309ce156SJayamohan Kallickal } 25013fe5ae8bSMike Christie 2502309ce156SJayamohan Kallickal /** 2503309ce156SJayamohan Kallickal * iscsi_eh_recover_target - reset target and possibly the session 2504309ce156SJayamohan Kallickal * @sc: scsi command 2505309ce156SJayamohan Kallickal * 2506309ce156SJayamohan Kallickal * This will attempt to send a warm target reset. If that fails, 2507309ce156SJayamohan Kallickal * we will escalate to ERL0 session recovery. 2508309ce156SJayamohan Kallickal */ 2509309ce156SJayamohan Kallickal int iscsi_eh_recover_target(struct scsi_cmnd *sc) 2510309ce156SJayamohan Kallickal { 2511309ce156SJayamohan Kallickal int rc; 2512309ce156SJayamohan Kallickal 2513309ce156SJayamohan Kallickal rc = iscsi_eh_target_reset(sc); 25143fe5ae8bSMike Christie if (rc == FAILED) 25153fe5ae8bSMike Christie rc = iscsi_eh_session_reset(sc); 25163fe5ae8bSMike Christie return rc; 25173fe5ae8bSMike Christie } 2518309ce156SJayamohan Kallickal EXPORT_SYMBOL_GPL(iscsi_eh_recover_target); 25193fe5ae8bSMike Christie 25206320377fSOlaf Kirch /* 25216320377fSOlaf Kirch * Pre-allocate a pool of @max items of @item_size. By default, the pool 25226320377fSOlaf Kirch * should be accessed via kfifo_{get,put} on q->queue. 25236320377fSOlaf Kirch * Optionally, the caller can obtain the array of object pointers 25246320377fSOlaf Kirch * by passing in a non-NULL @items pointer 25256320377fSOlaf Kirch */ 25267996a778SMike Christie int 25276320377fSOlaf Kirch iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size) 25287996a778SMike Christie { 25296320377fSOlaf Kirch int i, num_arrays = 1; 25307996a778SMike Christie 25316320377fSOlaf Kirch memset(q, 0, sizeof(*q)); 25327996a778SMike Christie 25337996a778SMike Christie q->max = max; 25346320377fSOlaf Kirch 25356320377fSOlaf Kirch /* If the user passed an items pointer, he wants a copy of 25366320377fSOlaf Kirch * the array. */ 25376320377fSOlaf Kirch if (items) 25386320377fSOlaf Kirch num_arrays++; 2539778e1cddSKees Cook q->pool = kvcalloc(num_arrays * max, sizeof(void *), GFP_KERNEL); 25406320377fSOlaf Kirch if (q->pool == NULL) 2541f474a37bSJean Delvare return -ENOMEM; 25427996a778SMike Christie 2543c1e13f25SStefani Seibold kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*)); 25447996a778SMike Christie 25457996a778SMike Christie for (i = 0; i < max; i++) { 25466320377fSOlaf Kirch q->pool[i] = kzalloc(item_size, GFP_KERNEL); 25477996a778SMike Christie if (q->pool[i] == NULL) { 25486320377fSOlaf Kirch q->max = i; 25496320377fSOlaf Kirch goto enomem; 25507996a778SMike Christie } 25517acd72ebSStefani Seibold kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*)); 25527996a778SMike Christie } 25536320377fSOlaf Kirch 25546320377fSOlaf Kirch if (items) { 25556320377fSOlaf Kirch *items = q->pool + max; 25566320377fSOlaf Kirch memcpy(*items, q->pool, max * sizeof(void *)); 25576320377fSOlaf Kirch } 25586320377fSOlaf Kirch 25597996a778SMike Christie return 0; 25606320377fSOlaf Kirch 25616320377fSOlaf Kirch enomem: 25626320377fSOlaf Kirch iscsi_pool_free(q); 25636320377fSOlaf Kirch return -ENOMEM; 25647996a778SMike Christie } 25657996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_init); 25667996a778SMike Christie 25676320377fSOlaf Kirch void iscsi_pool_free(struct iscsi_pool *q) 25687996a778SMike Christie { 25697996a778SMike Christie int i; 25707996a778SMike Christie 25717996a778SMike Christie for (i = 0; i < q->max; i++) 25726320377fSOlaf Kirch kfree(q->pool[i]); 2573bfcc62edSKyle Fortin kvfree(q->pool); 25747996a778SMike Christie } 25757996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_free); 25767996a778SMike Christie 2577a4804cd6SMike Christie /** 2578a4804cd6SMike Christie * iscsi_host_add - add host to system 2579a4804cd6SMike Christie * @shost: scsi host 2580a4804cd6SMike Christie * @pdev: parent device 2581a4804cd6SMike Christie * 2582a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers 2583a4804cd6SMike Christie * to add a host to the system. 2584a4804cd6SMike Christie */ 2585a4804cd6SMike Christie int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev) 25867996a778SMike Christie { 25878e9a20ceSMike Christie if (!shost->can_queue) 25888e9a20ceSMike Christie shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX; 25898e9a20ceSMike Christie 25904d108350SMike Christie if (!shost->cmd_per_lun) 25914d108350SMike Christie shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN; 25924d108350SMike Christie 2593a4804cd6SMike Christie return scsi_add_host(shost, pdev); 2594a4804cd6SMike Christie } 2595a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_add); 2596a4804cd6SMike Christie 2597a4804cd6SMike Christie /** 2598a4804cd6SMike Christie * iscsi_host_alloc - allocate a host and driver data 2599a4804cd6SMike Christie * @sht: scsi host template 2600a4804cd6SMike Christie * @dd_data_size: driver host data size 260132ae763eSMike Christie * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue 2602a4804cd6SMike Christie * 2603a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers. 2604a4804cd6SMike Christie * To access the driver specific memory use the iscsi_host_priv() macro. 2605a4804cd6SMike Christie */ 2606a4804cd6SMike Christie struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht, 26074d108350SMike Christie int dd_data_size, bool xmit_can_sleep) 2608a4804cd6SMike Christie { 2609a4804cd6SMike Christie struct Scsi_Host *shost; 2610e5bd7b54SMike Christie struct iscsi_host *ihost; 2611a4804cd6SMike Christie 2612a4804cd6SMike Christie shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size); 2613a4804cd6SMike Christie if (!shost) 2614a4804cd6SMike Christie return NULL; 2615e5bd7b54SMike Christie ihost = shost_priv(shost); 261632ae763eSMike Christie 261732ae763eSMike Christie if (xmit_can_sleep) { 261832ae763eSMike Christie snprintf(ihost->workq_name, sizeof(ihost->workq_name), 261932ae763eSMike Christie "iscsi_q_%d", shost->host_no); 262032ae763eSMike Christie ihost->workq = create_singlethread_workqueue(ihost->workq_name); 262132ae763eSMike Christie if (!ihost->workq) 262232ae763eSMike Christie goto free_host; 262332ae763eSMike Christie } 262432ae763eSMike Christie 2625e5bd7b54SMike Christie spin_lock_init(&ihost->lock); 2626e5bd7b54SMike Christie ihost->state = ISCSI_HOST_SETUP; 2627e5bd7b54SMike Christie ihost->num_sessions = 0; 2628e5bd7b54SMike Christie init_waitqueue_head(&ihost->session_removal_wq); 2629a4804cd6SMike Christie return shost; 263032ae763eSMike Christie 263132ae763eSMike Christie free_host: 263232ae763eSMike Christie scsi_host_put(shost); 263332ae763eSMike Christie return NULL; 263475613521SMike Christie } 2635a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_alloc); 263675613521SMike Christie 2637e5bd7b54SMike Christie static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session) 2638e5bd7b54SMike Christie { 263940a06e75SMike Christie iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST); 2640e5bd7b54SMike Christie } 2641e5bd7b54SMike Christie 2642a4804cd6SMike Christie /** 2643a4804cd6SMike Christie * iscsi_host_remove - remove host and sessions 2644a4804cd6SMike Christie * @shost: scsi host 2645a4804cd6SMike Christie * 2646e5bd7b54SMike Christie * If there are any sessions left, this will initiate the removal and wait 2647e5bd7b54SMike Christie * for the completion. 2648a4804cd6SMike Christie */ 2649a4804cd6SMike Christie void iscsi_host_remove(struct Scsi_Host *shost) 2650a4804cd6SMike Christie { 2651e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2652e5bd7b54SMike Christie unsigned long flags; 2653e5bd7b54SMike Christie 2654e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2655e5bd7b54SMike Christie ihost->state = ISCSI_HOST_REMOVED; 2656e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2657e5bd7b54SMike Christie 2658e5bd7b54SMike Christie iscsi_host_for_each_session(shost, iscsi_notify_host_removed); 2659e5bd7b54SMike Christie wait_event_interruptible(ihost->session_removal_wq, 2660e5bd7b54SMike Christie ihost->num_sessions == 0); 2661e5bd7b54SMike Christie if (signal_pending(current)) 2662e5bd7b54SMike Christie flush_signals(current); 2663e5bd7b54SMike Christie 2664a4804cd6SMike Christie scsi_remove_host(shost); 266532ae763eSMike Christie if (ihost->workq) 266632ae763eSMike Christie destroy_workqueue(ihost->workq); 2667a4804cd6SMike Christie } 2668a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_remove); 2669a4804cd6SMike Christie 2670a4804cd6SMike Christie void iscsi_host_free(struct Scsi_Host *shost) 267175613521SMike Christie { 267275613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 267375613521SMike Christie 267475613521SMike Christie kfree(ihost->netdev); 267575613521SMike Christie kfree(ihost->hwaddress); 267675613521SMike Christie kfree(ihost->initiatorname); 2677a4804cd6SMike Christie scsi_host_put(shost); 267875613521SMike Christie } 2679a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_free); 268075613521SMike Christie 2681e5bd7b54SMike Christie static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost) 2682e5bd7b54SMike Christie { 2683e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2684e5bd7b54SMike Christie unsigned long flags; 2685e5bd7b54SMike Christie 2686e5bd7b54SMike Christie shost = scsi_host_get(shost); 2687e5bd7b54SMike Christie if (!shost) { 2688e5bd7b54SMike Christie printk(KERN_ERR "Invalid state. Cannot notify host removal " 2689e5bd7b54SMike Christie "of session teardown event because host already " 2690e5bd7b54SMike Christie "removed.\n"); 2691e5bd7b54SMike Christie return; 2692e5bd7b54SMike Christie } 2693e5bd7b54SMike Christie 2694e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2695e5bd7b54SMike Christie ihost->num_sessions--; 2696e5bd7b54SMike Christie if (ihost->num_sessions == 0) 2697e5bd7b54SMike Christie wake_up(&ihost->session_removal_wq); 2698e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2699e5bd7b54SMike Christie scsi_host_put(shost); 2700e5bd7b54SMike Christie } 2701e5bd7b54SMike Christie 270275613521SMike Christie /** 270375613521SMike Christie * iscsi_session_setup - create iscsi cls session and host and session 270475613521SMike Christie * @iscsit: iscsi transport template 270575613521SMike Christie * @shost: scsi host 270675613521SMike Christie * @cmds_max: session can queue 2707ccd4a430SRandy Dunlap * @dd_size: private driver data size, added to session allocation size 27089c19a7d0SMike Christie * @cmd_task_size: LLD task private data size 270975613521SMike Christie * @initial_cmdsn: initial CmdSN 2710ccd4a430SRandy Dunlap * @id: target ID to add to this session 271175613521SMike Christie * 271275613521SMike Christie * This can be used by software iscsi_transports that allocate 271375613521SMike Christie * a session per scsi host. 27143cf7b233SMike Christie * 27153cf7b233SMike Christie * Callers should set cmds_max to the largest total numer (mgmt + scsi) of 27163cf7b233SMike Christie * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks 27173cf7b233SMike Christie * for nop handling and login/logout requests. 271875613521SMike Christie */ 271975613521SMike Christie struct iscsi_cls_session * 272075613521SMike Christie iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, 2721b8b9e1b8SJayamohan Kallickal uint16_t cmds_max, int dd_size, int cmd_task_size, 27227970634bSMike Christie uint32_t initial_cmdsn, unsigned int id) 272375613521SMike Christie { 2724e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 272575613521SMike Christie struct iscsi_session *session; 272675613521SMike Christie struct iscsi_cls_session *cls_session; 27273cf7b233SMike Christie int cmd_i, scsi_cmds, total_cmds = cmds_max; 2728e5bd7b54SMike Christie unsigned long flags; 2729e5bd7b54SMike Christie 2730e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2731e5bd7b54SMike Christie if (ihost->state == ISCSI_HOST_REMOVED) { 2732e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2733e5bd7b54SMike Christie return NULL; 2734e5bd7b54SMike Christie } 2735e5bd7b54SMike Christie ihost->num_sessions++; 2736e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 27378e9a20ceSMike Christie 27388e9a20ceSMike Christie if (!total_cmds) 27398e9a20ceSMike Christie total_cmds = ISCSI_DEF_XMIT_CMDS_MAX; 27403e5c28adSMike Christie /* 27413cf7b233SMike Christie * The iscsi layer needs some tasks for nop handling and tmfs, 27423cf7b233SMike Christie * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX 27433cf7b233SMike Christie * + 1 command for scsi IO. 27443e5c28adSMike Christie */ 27453cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 27463cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 27473cf7b233SMike Christie "must be a power of two that is at least %d.\n", 27483cf7b233SMike Christie total_cmds, ISCSI_TOTAL_CMDS_MIN); 2749e5bd7b54SMike Christie goto dec_session_count; 27501548271eSMike Christie } 27513cf7b233SMike Christie 27523cf7b233SMike Christie if (total_cmds > ISCSI_TOTAL_CMDS_MAX) { 27533cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 27543cf7b233SMike Christie "must be a power of 2 less than or equal to %d.\n", 27553cf7b233SMike Christie cmds_max, ISCSI_TOTAL_CMDS_MAX); 27563cf7b233SMike Christie total_cmds = ISCSI_TOTAL_CMDS_MAX; 27573cf7b233SMike Christie } 27583cf7b233SMike Christie 27593cf7b233SMike Christie if (!is_power_of_2(total_cmds)) { 27603cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 27613cf7b233SMike Christie "must be a power of 2.\n", total_cmds); 27623cf7b233SMike Christie total_cmds = rounddown_pow_of_two(total_cmds); 27633cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) 27643cf7b233SMike Christie return NULL; 27653cf7b233SMike Christie printk(KERN_INFO "iscsi: Rounding can_queue to %d.\n", 27663cf7b233SMike Christie total_cmds); 27673cf7b233SMike Christie } 27683cf7b233SMike Christie scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX; 27691548271eSMike Christie 27705d91e209SMike Christie cls_session = iscsi_alloc_session(shost, iscsit, 2771b8b9e1b8SJayamohan Kallickal sizeof(struct iscsi_session) + 2772b8b9e1b8SJayamohan Kallickal dd_size); 277375613521SMike Christie if (!cls_session) 2774e5bd7b54SMike Christie goto dec_session_count; 277575613521SMike Christie session = cls_session->dd_data; 277675613521SMike Christie session->cls_session = cls_session; 27777996a778SMike Christie session->host = shost; 27787996a778SMike Christie session->state = ISCSI_STATE_FREE; 2779f6d5180cSMike Christie session->fast_abort = 1; 27803fe5ae8bSMike Christie session->tgt_reset_timeout = 30; 27814cd49ea1SMike Christie session->lu_reset_timeout = 15; 27824cd49ea1SMike Christie session->abort_timeout = 10; 27833cf7b233SMike Christie session->scsi_cmds_max = scsi_cmds; 27843cf7b233SMike Christie session->cmds_max = total_cmds; 2785e0726407SMike Christie session->queued_cmdsn = session->cmdsn = initial_cmdsn; 27867996a778SMike Christie session->exp_cmdsn = initial_cmdsn + 1; 27877996a778SMike Christie session->max_cmdsn = initial_cmdsn + 1; 27887996a778SMike Christie session->max_r2t = 1; 27897996a778SMike Christie session->tt = iscsit; 2790b8b9e1b8SJayamohan Kallickal session->dd_data = cls_session->dd_data + sizeof(*session); 2791659743b0SShlomo Pongratz 27926724add1SMike Christie mutex_init(&session->eh_mutex); 2793659743b0SShlomo Pongratz spin_lock_init(&session->frwd_lock); 2794659743b0SShlomo Pongratz spin_lock_init(&session->back_lock); 27957996a778SMike Christie 27967996a778SMike Christie /* initialize SCSI PDU commands pool */ 27977996a778SMike Christie if (iscsi_pool_init(&session->cmdpool, session->cmds_max, 27987996a778SMike Christie (void***)&session->cmds, 27999c19a7d0SMike Christie cmd_task_size + sizeof(struct iscsi_task))) 28007996a778SMike Christie goto cmdpool_alloc_fail; 28017996a778SMike Christie 28027996a778SMike Christie /* pre-format cmds pool with ITT */ 28037996a778SMike Christie for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) { 28049c19a7d0SMike Christie struct iscsi_task *task = session->cmds[cmd_i]; 28057996a778SMike Christie 28069c19a7d0SMike Christie if (cmd_task_size) 28079c19a7d0SMike Christie task->dd_data = &task[1]; 28089c19a7d0SMike Christie task->itt = cmd_i; 28093bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 28109c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 28117996a778SMike Christie } 28127996a778SMike Christie 2813f53a88daSMike Christie if (!try_module_get(iscsit->owner)) 281475613521SMike Christie goto module_get_fail; 281575613521SMike Christie 28167970634bSMike Christie if (iscsi_add_session(cls_session, id)) 2817f53a88daSMike Christie goto cls_session_fail; 2818e5bd7b54SMike Christie 28197996a778SMike Christie return cls_session; 28207996a778SMike Christie 28217996a778SMike Christie cls_session_fail: 282275613521SMike Christie module_put(iscsit->owner); 282375613521SMike Christie module_get_fail: 28246320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 28257996a778SMike Christie cmdpool_alloc_fail: 282675613521SMike Christie iscsi_free_session(cls_session); 2827e5bd7b54SMike Christie dec_session_count: 2828e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 28297996a778SMike Christie return NULL; 28307996a778SMike Christie } 28317996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_setup); 28327996a778SMike Christie 28337996a778SMike Christie /** 28347996a778SMike Christie * iscsi_session_teardown - destroy session, host, and cls_session 283575613521SMike Christie * @cls_session: iscsi session 283675613521SMike Christie */ 28377996a778SMike Christie void iscsi_session_teardown(struct iscsi_cls_session *cls_session) 28387996a778SMike Christie { 283975613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 284063f75cc8SMike Christie struct module *owner = cls_session->transport->owner; 2841e5bd7b54SMike Christie struct Scsi_Host *shost = session->host; 28427996a778SMike Christie 28436320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 28447996a778SMike Christie 28459e10b512SKhazhismel Kumykov iscsi_remove_session(cls_session); 28469e10b512SKhazhismel Kumykov 2847b2c64167SMike Christie kfree(session->password); 2848b2c64167SMike Christie kfree(session->password_in); 2849b2c64167SMike Christie kfree(session->username); 2850b2c64167SMike Christie kfree(session->username_in); 2851f3ff0c36SMike Christie kfree(session->targetname); 28523c5c4801SVikas Chaudhary kfree(session->targetalias); 285388dfd340SMike Christie kfree(session->initiatorname); 28543b9373e9SEddie Wai kfree(session->boot_root); 28553b9373e9SEddie Wai kfree(session->boot_nic); 28563b9373e9SEddie Wai kfree(session->boot_target); 285788dfd340SMike Christie kfree(session->ifacename); 2858f8525eb4SAdheer Chandravanshi kfree(session->portal_type); 2859f8525eb4SAdheer Chandravanshi kfree(session->discovery_parent_type); 2860f3ff0c36SMike Christie 28619e10b512SKhazhismel Kumykov iscsi_free_session(cls_session); 28629e10b512SKhazhismel Kumykov 2863e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 286463f75cc8SMike Christie module_put(owner); 28657996a778SMike Christie } 28667996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_teardown); 28677996a778SMike Christie 28687996a778SMike Christie /** 28697996a778SMike Christie * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn 28707996a778SMike Christie * @cls_session: iscsi_cls_session 28715d91e209SMike Christie * @dd_size: private driver data size 28727996a778SMike Christie * @conn_idx: cid 28735d91e209SMike Christie */ 28747996a778SMike Christie struct iscsi_cls_conn * 28755d91e209SMike Christie iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, 28765d91e209SMike Christie uint32_t conn_idx) 28777996a778SMike Christie { 287875613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 28797996a778SMike Christie struct iscsi_conn *conn; 28807996a778SMike Christie struct iscsi_cls_conn *cls_conn; 2881d36ab6f3SMike Christie char *data; 28827996a778SMike Christie 28835d91e209SMike Christie cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size, 28845d91e209SMike Christie conn_idx); 28857996a778SMike Christie if (!cls_conn) 28867996a778SMike Christie return NULL; 28877996a778SMike Christie conn = cls_conn->dd_data; 28885d91e209SMike Christie memset(conn, 0, sizeof(*conn) + dd_size); 28897996a778SMike Christie 28905d91e209SMike Christie conn->dd_data = cls_conn->dd_data + sizeof(*conn); 28917996a778SMike Christie conn->session = session; 28927996a778SMike Christie conn->cls_conn = cls_conn; 28937996a778SMike Christie conn->c_stage = ISCSI_CONN_INITIAL_STAGE; 28947996a778SMike Christie conn->id = conn_idx; 28957996a778SMike Christie conn->exp_statsn = 0; 2896843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2897f6d5180cSMike Christie 28982c4b9637SKees Cook timer_setup(&conn->transport_timer, iscsi_check_transport_timeouts, 0); 2899f6d5180cSMike Christie 2900843c0a8aSMike Christie INIT_LIST_HEAD(&conn->mgmtqueue); 29013bbaaad9SMike Christie INIT_LIST_HEAD(&conn->cmdqueue); 2902843c0a8aSMike Christie INIT_LIST_HEAD(&conn->requeue); 29036f8830f5SChris Leech spin_lock_init(&conn->taskqueuelock); 2904c4028958SDavid Howells INIT_WORK(&conn->xmitwork, iscsi_xmitworker); 29057996a778SMike Christie 29069c19a7d0SMike Christie /* allocate login_task used for the login/text sequences */ 2907659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 29087acd72ebSStefani Seibold if (!kfifo_out(&session->cmdpool.queue, 29099c19a7d0SMike Christie (void*)&conn->login_task, 29107996a778SMike Christie sizeof(void*))) { 2911659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 29129c19a7d0SMike Christie goto login_task_alloc_fail; 29137996a778SMike Christie } 2914659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 29157996a778SMike Christie 2916cfeb2cf9SMike Christie data = (char *) __get_free_pages(GFP_KERNEL, 2917cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2918d36ab6f3SMike Christie if (!data) 29199c19a7d0SMike Christie goto login_task_data_alloc_fail; 29209c19a7d0SMike Christie conn->login_task->data = conn->data = data; 2921d36ab6f3SMike Christie 29222c4b9637SKees Cook timer_setup(&conn->tmf_timer, iscsi_tmf_timedout, 0); 29237996a778SMike Christie init_waitqueue_head(&conn->ehwait); 29247996a778SMike Christie 29257996a778SMike Christie return cls_conn; 29267996a778SMike Christie 29279c19a7d0SMike Christie login_task_data_alloc_fail: 29287acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 2929d36ab6f3SMike Christie sizeof(void*)); 29309c19a7d0SMike Christie login_task_alloc_fail: 29317996a778SMike Christie iscsi_destroy_conn(cls_conn); 29327996a778SMike Christie return NULL; 29337996a778SMike Christie } 29347996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_setup); 29357996a778SMike Christie 29367996a778SMike Christie /** 29377996a778SMike Christie * iscsi_conn_teardown - teardown iscsi connection 2938ccd4a430SRandy Dunlap * @cls_conn: iscsi class connection 29397996a778SMike Christie * 29407996a778SMike Christie * TODO: we may need to make this into a two step process 29417996a778SMike Christie * like scsi-mls remove + put host 29427996a778SMike Christie */ 29437996a778SMike Christie void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) 29447996a778SMike Christie { 29457996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 29467996a778SMike Christie struct iscsi_session *session = conn->session; 29477996a778SMike Christie 2948f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 2949f6d5180cSMike Christie 2950660d0831SJohn Soni Jose mutex_lock(&session->eh_mutex); 2951659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 29527996a778SMike Christie conn->c_stage = ISCSI_CONN_CLEANUP_WAIT; 29537996a778SMike Christie if (session->leadconn == conn) { 29547996a778SMike Christie /* 29557996a778SMike Christie * leading connection? then give up on recovery. 29567996a778SMike Christie */ 29577996a778SMike Christie session->state = ISCSI_STATE_TERMINATE; 29587996a778SMike Christie wake_up(&conn->ehwait); 29597996a778SMike Christie } 2960659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 29617996a778SMike Christie 2962779ea120SMike Christie /* flush queued up work because we free the connection below */ 2963843c0a8aSMike Christie iscsi_suspend_tx(conn); 2964779ea120SMike Christie 2965659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2966cfeb2cf9SMike Christie free_pages((unsigned long) conn->data, 2967cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2968f3ff0c36SMike Christie kfree(conn->persistent_address); 2969ae56ff40SAdheer Chandravanshi kfree(conn->local_ipaddr); 2970659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 2971659743b0SShlomo Pongratz spin_lock_bh(&session->back_lock); 29727acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 29737996a778SMike Christie sizeof(void*)); 2974659743b0SShlomo Pongratz spin_unlock_bh(&session->back_lock); 2975e0726407SMike Christie if (session->leadconn == conn) 29767996a778SMike Christie session->leadconn = NULL; 2977659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2978660d0831SJohn Soni Jose mutex_unlock(&session->eh_mutex); 29797996a778SMike Christie 29807996a778SMike Christie iscsi_destroy_conn(cls_conn); 29817996a778SMike Christie } 29827996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_teardown); 29837996a778SMike Christie 29847996a778SMike Christie int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 29857996a778SMike Christie { 29867996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 29877996a778SMike Christie struct iscsi_session *session = conn->session; 29887996a778SMike Christie 2989ffd0436eSMike Christie if (!session) { 2990322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 2991322d739dSMike Christie "can't start unbound connection\n"); 29927996a778SMike Christie return -EPERM; 29937996a778SMike Christie } 29947996a778SMike Christie 2995db98ccdeSMike Christie if ((session->imm_data_en || !session->initial_r2t_en) && 2996db98ccdeSMike Christie session->first_burst > session->max_burst) { 2997322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: " 2998ffd0436eSMike Christie "first_burst %d max_burst %d\n", 2999ffd0436eSMike Christie session->first_burst, session->max_burst); 3000ffd0436eSMike Christie return -EINVAL; 3001ffd0436eSMike Christie } 3002ffd0436eSMike Christie 3003f6d5180cSMike Christie if (conn->ping_timeout && !conn->recv_timeout) { 3004322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of " 3005322d739dSMike Christie "zero. Using 5 seconds\n."); 3006f6d5180cSMike Christie conn->recv_timeout = 5; 3007f6d5180cSMike Christie } 3008f6d5180cSMike Christie 3009f6d5180cSMike Christie if (conn->recv_timeout && !conn->ping_timeout) { 3010322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of " 3011322d739dSMike Christie "zero. Using 5 seconds.\n"); 3012f6d5180cSMike Christie conn->ping_timeout = 5; 3013f6d5180cSMike Christie } 3014f6d5180cSMike Christie 3015659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 30167996a778SMike Christie conn->c_stage = ISCSI_CONN_STARTED; 30177996a778SMike Christie session->state = ISCSI_STATE_LOGGED_IN; 3018e0726407SMike Christie session->queued_cmdsn = session->cmdsn; 30197996a778SMike Christie 3020f6d5180cSMike Christie conn->last_recv = jiffies; 3021f6d5180cSMike Christie conn->last_ping = jiffies; 3022f6d5180cSMike Christie if (conn->recv_timeout && conn->ping_timeout) 3023f6d5180cSMike Christie mod_timer(&conn->transport_timer, 3024f6d5180cSMike Christie jiffies + (conn->recv_timeout * HZ)); 3025f6d5180cSMike Christie 30267996a778SMike Christie switch(conn->stop_stage) { 30277996a778SMike Christie case STOP_CONN_RECOVER: 30287996a778SMike Christie /* 30297996a778SMike Christie * unblock eh_abort() if it is blocked. re-try all 30307996a778SMike Christie * commands after successful recovery 30317996a778SMike Christie */ 30327996a778SMike Christie conn->stop_stage = 0; 3033843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 30347996a778SMike Christie session->age++; 30358b1d0343SMike Christie if (session->age == 16) 30368b1d0343SMike Christie session->age = 0; 30376eabafbeSMike Christie break; 30387996a778SMike Christie case STOP_CONN_TERM: 30397996a778SMike Christie conn->stop_stage = 0; 30407996a778SMike Christie break; 30417996a778SMike Christie default: 30427996a778SMike Christie break; 30437996a778SMike Christie } 3044659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 30457996a778SMike Christie 304675613521SMike Christie iscsi_unblock_session(session->cls_session); 30476eabafbeSMike Christie wake_up(&conn->ehwait); 30487996a778SMike Christie return 0; 30497996a778SMike Christie } 30507996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_start); 30517996a778SMike Christie 30527996a778SMike Christie static void 30533bbaaad9SMike Christie fail_mgmt_tasks(struct iscsi_session *session, struct iscsi_conn *conn) 30547996a778SMike Christie { 30553bbaaad9SMike Christie struct iscsi_task *task; 3056b3cd5050SMike Christie int i, state; 30577996a778SMike Christie 30583bbaaad9SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 30593bbaaad9SMike Christie task = conn->session->cmds[i]; 30603bbaaad9SMike Christie if (task->sc) 30613bbaaad9SMike Christie continue; 30623bbaaad9SMike Christie 30633bbaaad9SMike Christie if (task->state == ISCSI_TASK_FREE) 30643bbaaad9SMike Christie continue; 30653bbaaad9SMike Christie 30663bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, 30673bbaaad9SMike Christie "failing mgmt itt 0x%x state %d\n", 30683bbaaad9SMike Christie task->itt, task->state); 3069b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 3070b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) 3071b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 3072b3cd5050SMike Christie iscsi_complete_task(task, state); 3073b3cd5050SMike Christie 30747996a778SMike Christie } 30757996a778SMike Christie } 30767996a778SMike Christie 3077656cffc9SMike Christie static void iscsi_start_session_recovery(struct iscsi_session *session, 30787996a778SMike Christie struct iscsi_conn *conn, int flag) 30797996a778SMike Christie { 3080ed2abc7fSMike Christie int old_stop_stage; 3081ed2abc7fSMike Christie 30826724add1SMike Christie mutex_lock(&session->eh_mutex); 3083659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 3084ed2abc7fSMike Christie if (conn->stop_stage == STOP_CONN_TERM) { 3085659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 30866724add1SMike Christie mutex_unlock(&session->eh_mutex); 30876724add1SMike Christie return; 30886724add1SMike Christie } 30896724add1SMike Christie 30906724add1SMike Christie /* 3091ed2abc7fSMike Christie * When this is called for the in_login state, we only want to clean 30929c19a7d0SMike Christie * up the login task and connection. We do not need to block and set 309367a61114SMike Christie * the recovery state again 3094ed2abc7fSMike Christie */ 309567a61114SMike Christie if (flag == STOP_CONN_TERM) 309667a61114SMike Christie session->state = ISCSI_STATE_TERMINATE; 309767a61114SMike Christie else if (conn->stop_stage != STOP_CONN_RECOVER) 309867a61114SMike Christie session->state = ISCSI_STATE_IN_RECOVERY; 30994ae0a6c1SMike Christie 31004ae0a6c1SMike Christie old_stop_stage = conn->stop_stage; 31014ae0a6c1SMike Christie conn->stop_stage = flag; 3102659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 3103ed2abc7fSMike Christie 310426013ad4SMike Christie del_timer_sync(&conn->transport_timer); 310526013ad4SMike Christie iscsi_suspend_tx(conn); 310626013ad4SMike Christie 3107659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 310867a61114SMike Christie conn->c_stage = ISCSI_CONN_STOPPED; 3109659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31106724add1SMike Christie 31117996a778SMike Christie /* 31127996a778SMike Christie * for connection level recovery we should not calculate 31137996a778SMike Christie * header digest. conn->hdr_size used for optimization 31147996a778SMike Christie * in hdr_extract() and will be re-negotiated at 31157996a778SMike Christie * set_param() time. 31167996a778SMike Christie */ 31177996a778SMike Christie if (flag == STOP_CONN_RECOVER) { 31187996a778SMike Christie conn->hdrdgst_en = 0; 31197996a778SMike Christie conn->datadgst_en = 0; 3120656cffc9SMike Christie if (session->state == ISCSI_STATE_IN_RECOVERY && 312167a61114SMike Christie old_stop_stage != STOP_CONN_RECOVER) { 31221b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "blocking session\n"); 312375613521SMike Christie iscsi_block_session(session->cls_session); 31247996a778SMike Christie } 312567a61114SMike Christie } 3126656cffc9SMike Christie 3127656cffc9SMike Christie /* 3128656cffc9SMike Christie * flush queues. 3129656cffc9SMike Christie */ 3130659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 31313bbaaad9SMike Christie fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED); 31323bbaaad9SMike Christie fail_mgmt_tasks(session, conn); 31335d12c05eSMike Christie memset(&conn->tmhdr, 0, sizeof(conn->tmhdr)); 3134659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31356724add1SMike Christie mutex_unlock(&session->eh_mutex); 31367996a778SMike Christie } 31377996a778SMike Christie 31387996a778SMike Christie void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 31397996a778SMike Christie { 31407996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 31417996a778SMike Christie struct iscsi_session *session = conn->session; 31427996a778SMike Christie 31437996a778SMike Christie switch (flag) { 31447996a778SMike Christie case STOP_CONN_RECOVER: 31457996a778SMike Christie case STOP_CONN_TERM: 31467996a778SMike Christie iscsi_start_session_recovery(session, conn, flag); 31478d2860b3SMike Christie break; 31487996a778SMike Christie default: 3149322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 3150322d739dSMike Christie "invalid stop flag %d\n", flag); 31517996a778SMike Christie } 31527996a778SMike Christie } 31537996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_stop); 31547996a778SMike Christie 31557996a778SMike Christie int iscsi_conn_bind(struct iscsi_cls_session *cls_session, 31567996a778SMike Christie struct iscsi_cls_conn *cls_conn, int is_leading) 31577996a778SMike Christie { 315875613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 315998644047SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 31607996a778SMike Christie 3161659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 31627996a778SMike Christie if (is_leading) 31637996a778SMike Christie session->leadconn = conn; 3164659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31657996a778SMike Christie 31667996a778SMike Christie /* 31677996a778SMike Christie * Unblock xmitworker(), Login Phase will pass through. 31687996a778SMike Christie */ 31697996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 31707996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 31717996a778SMike Christie return 0; 31727996a778SMike Christie } 31737996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_bind); 31747996a778SMike Christie 3175adaf6990SAdheer Chandravanshi int iscsi_switch_str_param(char **param, char *new_val_buf) 31765700b1afSMike Christie { 31775700b1afSMike Christie char *new_val; 31785700b1afSMike Christie 31795700b1afSMike Christie if (*param) { 31805700b1afSMike Christie if (!strcmp(*param, new_val_buf)) 31815700b1afSMike Christie return 0; 31825700b1afSMike Christie } 31835700b1afSMike Christie 31845700b1afSMike Christie new_val = kstrdup(new_val_buf, GFP_NOIO); 31855700b1afSMike Christie if (!new_val) 31865700b1afSMike Christie return -ENOMEM; 31875700b1afSMike Christie 31885700b1afSMike Christie kfree(*param); 31895700b1afSMike Christie *param = new_val; 31905700b1afSMike Christie return 0; 31915700b1afSMike Christie } 3192adaf6990SAdheer Chandravanshi EXPORT_SYMBOL_GPL(iscsi_switch_str_param); 3193a54a52caSMike Christie 3194a54a52caSMike Christie int iscsi_set_param(struct iscsi_cls_conn *cls_conn, 3195a54a52caSMike Christie enum iscsi_param param, char *buf, int buflen) 3196a54a52caSMike Christie { 3197a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 3198a54a52caSMike Christie struct iscsi_session *session = conn->session; 31996a06a4b8SOr Gerlitz int val; 3200a54a52caSMike Christie 3201a54a52caSMike Christie switch(param) { 3202843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 3203843c0a8aSMike Christie sscanf(buf, "%d", &session->fast_abort); 3204843c0a8aSMike Christie break; 3205f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 3206f6d5180cSMike Christie sscanf(buf, "%d", &session->abort_timeout); 3207f6d5180cSMike Christie break; 3208f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 3209f6d5180cSMike Christie sscanf(buf, "%d", &session->lu_reset_timeout); 3210f6d5180cSMike Christie break; 32113fe5ae8bSMike Christie case ISCSI_PARAM_TGT_RESET_TMO: 32123fe5ae8bSMike Christie sscanf(buf, "%d", &session->tgt_reset_timeout); 32133fe5ae8bSMike Christie break; 3214f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 3215f6d5180cSMike Christie sscanf(buf, "%d", &conn->ping_timeout); 3216f6d5180cSMike Christie break; 3217f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 3218f6d5180cSMike Christie sscanf(buf, "%d", &conn->recv_timeout); 3219f6d5180cSMike Christie break; 3220a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 3221a54a52caSMike Christie sscanf(buf, "%d", &conn->max_recv_dlength); 3222a54a52caSMike Christie break; 3223a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3224a54a52caSMike Christie sscanf(buf, "%d", &conn->max_xmit_dlength); 3225a54a52caSMike Christie break; 3226a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 3227a54a52caSMike Christie sscanf(buf, "%d", &conn->hdrdgst_en); 3228a54a52caSMike Christie break; 3229a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 3230a54a52caSMike Christie sscanf(buf, "%d", &conn->datadgst_en); 3231a54a52caSMike Christie break; 3232a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 3233a54a52caSMike Christie sscanf(buf, "%d", &session->initial_r2t_en); 3234a54a52caSMike Christie break; 3235a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 32361304be5fSMike Christie sscanf(buf, "%hu", &session->max_r2t); 3237a54a52caSMike Christie break; 3238a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 3239a54a52caSMike Christie sscanf(buf, "%d", &session->imm_data_en); 3240a54a52caSMike Christie break; 3241a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 3242a54a52caSMike Christie sscanf(buf, "%d", &session->first_burst); 3243a54a52caSMike Christie break; 3244a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 3245a54a52caSMike Christie sscanf(buf, "%d", &session->max_burst); 3246a54a52caSMike Christie break; 3247a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 3248a54a52caSMike Christie sscanf(buf, "%d", &session->pdu_inorder_en); 3249a54a52caSMike Christie break; 3250a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 3251a54a52caSMike Christie sscanf(buf, "%d", &session->dataseq_inorder_en); 3252a54a52caSMike Christie break; 3253a54a52caSMike Christie case ISCSI_PARAM_ERL: 3254a54a52caSMike Christie sscanf(buf, "%d", &session->erl); 3255a54a52caSMike Christie break; 3256a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 3257a54a52caSMike Christie sscanf(buf, "%u", &conn->exp_statsn); 3258a54a52caSMike Christie break; 3259b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 32605700b1afSMike Christie return iscsi_switch_str_param(&session->username, buf); 3261b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 32625700b1afSMike Christie return iscsi_switch_str_param(&session->username_in, buf); 3263b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 32645700b1afSMike Christie return iscsi_switch_str_param(&session->password, buf); 3265b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 32665700b1afSMike Christie return iscsi_switch_str_param(&session->password_in, buf); 3267a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 32685700b1afSMike Christie return iscsi_switch_str_param(&session->targetname, buf); 32693c5c4801SVikas Chaudhary case ISCSI_PARAM_TARGET_ALIAS: 32703c5c4801SVikas Chaudhary return iscsi_switch_str_param(&session->targetalias, buf); 3271a54a52caSMike Christie case ISCSI_PARAM_TPGT: 3272a54a52caSMike Christie sscanf(buf, "%d", &session->tpgt); 3273a54a52caSMike Christie break; 3274a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3275a54a52caSMike Christie sscanf(buf, "%d", &conn->persistent_port); 3276a54a52caSMike Christie break; 3277a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 32785700b1afSMike Christie return iscsi_switch_str_param(&conn->persistent_address, buf); 327988dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 32805700b1afSMike Christie return iscsi_switch_str_param(&session->ifacename, buf); 328188dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 32825700b1afSMike Christie return iscsi_switch_str_param(&session->initiatorname, buf); 32833b9373e9SEddie Wai case ISCSI_PARAM_BOOT_ROOT: 32843b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_root, buf); 32853b9373e9SEddie Wai case ISCSI_PARAM_BOOT_NIC: 32863b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_nic, buf); 32873b9373e9SEddie Wai case ISCSI_PARAM_BOOT_TARGET: 32883b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_target, buf); 3289f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_PORTAL_TYPE: 3290f8525eb4SAdheer Chandravanshi return iscsi_switch_str_param(&session->portal_type, buf); 3291f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_TYPE: 3292f8525eb4SAdheer Chandravanshi return iscsi_switch_str_param(&session->discovery_parent_type, 3293f8525eb4SAdheer Chandravanshi buf); 32946a06a4b8SOr Gerlitz case ISCSI_PARAM_DISCOVERY_SESS: 32956a06a4b8SOr Gerlitz sscanf(buf, "%d", &val); 32966a06a4b8SOr Gerlitz session->discovery_sess = !!val; 32976a06a4b8SOr Gerlitz break; 3298ae56ff40SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_IPADDR: 3299ae56ff40SAdheer Chandravanshi return iscsi_switch_str_param(&conn->local_ipaddr, buf); 3300a54a52caSMike Christie default: 3301a54a52caSMike Christie return -ENOSYS; 3302a54a52caSMike Christie } 3303a54a52caSMike Christie 3304a54a52caSMike Christie return 0; 3305a54a52caSMike Christie } 3306a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_set_param); 3307a54a52caSMike Christie 3308a54a52caSMike Christie int iscsi_session_get_param(struct iscsi_cls_session *cls_session, 3309a54a52caSMike Christie enum iscsi_param param, char *buf) 3310a54a52caSMike Christie { 331175613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 3312a54a52caSMike Christie int len; 3313a54a52caSMike Christie 3314a54a52caSMike Christie switch(param) { 3315843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 3316843c0a8aSMike Christie len = sprintf(buf, "%d\n", session->fast_abort); 3317843c0a8aSMike Christie break; 3318f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 3319f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->abort_timeout); 3320f6d5180cSMike Christie break; 3321f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 3322f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->lu_reset_timeout); 3323f6d5180cSMike Christie break; 33243fe5ae8bSMike Christie case ISCSI_PARAM_TGT_RESET_TMO: 33253fe5ae8bSMike Christie len = sprintf(buf, "%d\n", session->tgt_reset_timeout); 33263fe5ae8bSMike Christie break; 3327a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 3328a54a52caSMike Christie len = sprintf(buf, "%d\n", session->initial_r2t_en); 3329a54a52caSMike Christie break; 3330a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 3331a54a52caSMike Christie len = sprintf(buf, "%hu\n", session->max_r2t); 3332a54a52caSMike Christie break; 3333a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 3334a54a52caSMike Christie len = sprintf(buf, "%d\n", session->imm_data_en); 3335a54a52caSMike Christie break; 3336a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 3337a54a52caSMike Christie len = sprintf(buf, "%u\n", session->first_burst); 3338a54a52caSMike Christie break; 3339a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 3340a54a52caSMike Christie len = sprintf(buf, "%u\n", session->max_burst); 3341a54a52caSMike Christie break; 3342a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 3343a54a52caSMike Christie len = sprintf(buf, "%d\n", session->pdu_inorder_en); 3344a54a52caSMike Christie break; 3345a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 3346a54a52caSMike Christie len = sprintf(buf, "%d\n", session->dataseq_inorder_en); 3347a54a52caSMike Christie break; 33485f09e1f3SAdheer Chandravanshi case ISCSI_PARAM_DEF_TASKMGMT_TMO: 33495f09e1f3SAdheer Chandravanshi len = sprintf(buf, "%d\n", session->def_taskmgmt_tmo); 33505f09e1f3SAdheer Chandravanshi break; 3351a54a52caSMike Christie case ISCSI_PARAM_ERL: 3352a54a52caSMike Christie len = sprintf(buf, "%d\n", session->erl); 3353a54a52caSMike Christie break; 3354a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 3355a54a52caSMike Christie len = sprintf(buf, "%s\n", session->targetname); 3356a54a52caSMike Christie break; 33573c5c4801SVikas Chaudhary case ISCSI_PARAM_TARGET_ALIAS: 33583c5c4801SVikas Chaudhary len = sprintf(buf, "%s\n", session->targetalias); 33593c5c4801SVikas Chaudhary break; 3360a54a52caSMike Christie case ISCSI_PARAM_TPGT: 3361a54a52caSMike Christie len = sprintf(buf, "%d\n", session->tpgt); 3362a54a52caSMike Christie break; 3363b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 3364b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username); 3365b2c64167SMike Christie break; 3366b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 3367b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username_in); 3368b2c64167SMike Christie break; 3369b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 3370b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password); 3371b2c64167SMike Christie break; 3372b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 3373b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password_in); 3374b2c64167SMike Christie break; 337588dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 337688dfd340SMike Christie len = sprintf(buf, "%s\n", session->ifacename); 337788dfd340SMike Christie break; 337888dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 337988dfd340SMike Christie len = sprintf(buf, "%s\n", session->initiatorname); 338088dfd340SMike Christie break; 33813b9373e9SEddie Wai case ISCSI_PARAM_BOOT_ROOT: 33823b9373e9SEddie Wai len = sprintf(buf, "%s\n", session->boot_root); 33833b9373e9SEddie Wai break; 33843b9373e9SEddie Wai case ISCSI_PARAM_BOOT_NIC: 33853b9373e9SEddie Wai len = sprintf(buf, "%s\n", session->boot_nic); 33863b9373e9SEddie Wai break; 33873b9373e9SEddie Wai case ISCSI_PARAM_BOOT_TARGET: 33883b9373e9SEddie Wai len = sprintf(buf, "%s\n", session->boot_target); 33899a2307b1SAdheer Chandravanshi break; 3390f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_AUTO_SND_TGT_DISABLE: 3391f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->auto_snd_tgt_disable); 3392f8525eb4SAdheer Chandravanshi break; 3393f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_SESS: 3394f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->discovery_sess); 3395f8525eb4SAdheer Chandravanshi break; 3396f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_PORTAL_TYPE: 3397f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%s\n", session->portal_type); 3398f8525eb4SAdheer Chandravanshi break; 3399f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_CHAP_AUTH_EN: 3400f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->chap_auth_en); 3401f8525eb4SAdheer Chandravanshi break; 3402f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_LOGOUT_EN: 3403f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->discovery_logout_en); 3404f8525eb4SAdheer Chandravanshi break; 3405f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_BIDI_CHAP_EN: 3406f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->bidi_chap_en); 3407f8525eb4SAdheer Chandravanshi break; 3408f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL: 3409f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->discovery_auth_optional); 3410f8525eb4SAdheer Chandravanshi break; 3411f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DEF_TIME2WAIT: 3412f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%d\n", session->time2wait); 3413f8525eb4SAdheer Chandravanshi break; 3414f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DEF_TIME2RETAIN: 3415f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%d\n", session->time2retain); 3416f8525eb4SAdheer Chandravanshi break; 3417f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TSID: 3418f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->tsid); 3419f8525eb4SAdheer Chandravanshi break; 3420f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_ISID: 3421f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%02x%02x%02x%02x%02x%02x\n", 3422f8525eb4SAdheer Chandravanshi session->isid[0], session->isid[1], 3423f8525eb4SAdheer Chandravanshi session->isid[2], session->isid[3], 3424f8525eb4SAdheer Chandravanshi session->isid[4], session->isid[5]); 3425f8525eb4SAdheer Chandravanshi break; 3426f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_IDX: 3427f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", session->discovery_parent_idx); 3428f8525eb4SAdheer Chandravanshi break; 3429f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_TYPE: 3430f8525eb4SAdheer Chandravanshi if (session->discovery_parent_type) 3431f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%s\n", 3432f8525eb4SAdheer Chandravanshi session->discovery_parent_type); 3433f8525eb4SAdheer Chandravanshi else 3434f8525eb4SAdheer Chandravanshi len = sprintf(buf, "\n"); 34353b9373e9SEddie Wai break; 3436a54a52caSMike Christie default: 3437a54a52caSMike Christie return -ENOSYS; 3438a54a52caSMike Christie } 3439a54a52caSMike Christie 3440a54a52caSMike Christie return len; 3441a54a52caSMike Christie } 3442a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_get_param); 3443a54a52caSMike Christie 344400f3708eSMike Christie int iscsi_conn_get_addr_param(struct sockaddr_storage *addr, 344500f3708eSMike Christie enum iscsi_param param, char *buf) 344600f3708eSMike Christie { 344700f3708eSMike Christie struct sockaddr_in6 *sin6 = NULL; 344800f3708eSMike Christie struct sockaddr_in *sin = NULL; 344900f3708eSMike Christie int len; 345000f3708eSMike Christie 345100f3708eSMike Christie switch (addr->ss_family) { 345200f3708eSMike Christie case AF_INET: 345300f3708eSMike Christie sin = (struct sockaddr_in *)addr; 345400f3708eSMike Christie break; 345500f3708eSMike Christie case AF_INET6: 345600f3708eSMike Christie sin6 = (struct sockaddr_in6 *)addr; 345700f3708eSMike Christie break; 345800f3708eSMike Christie default: 345900f3708eSMike Christie return -EINVAL; 346000f3708eSMike Christie } 346100f3708eSMike Christie 346200f3708eSMike Christie switch (param) { 346300f3708eSMike Christie case ISCSI_PARAM_CONN_ADDRESS: 346400f3708eSMike Christie case ISCSI_HOST_PARAM_IPADDRESS: 346500f3708eSMike Christie if (sin) 346600f3708eSMike Christie len = sprintf(buf, "%pI4\n", &sin->sin_addr.s_addr); 346700f3708eSMike Christie else 346800f3708eSMike Christie len = sprintf(buf, "%pI6\n", &sin6->sin6_addr); 346900f3708eSMike Christie break; 347000f3708eSMike Christie case ISCSI_PARAM_CONN_PORT: 34714bfb8ebfSMike Christie case ISCSI_PARAM_LOCAL_PORT: 347200f3708eSMike Christie if (sin) 347300f3708eSMike Christie len = sprintf(buf, "%hu\n", be16_to_cpu(sin->sin_port)); 347400f3708eSMike Christie else 347500f3708eSMike Christie len = sprintf(buf, "%hu\n", 347600f3708eSMike Christie be16_to_cpu(sin6->sin6_port)); 347700f3708eSMike Christie break; 347800f3708eSMike Christie default: 347900f3708eSMike Christie return -EINVAL; 348000f3708eSMike Christie } 348100f3708eSMike Christie 348200f3708eSMike Christie return len; 348300f3708eSMike Christie } 348400f3708eSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_addr_param); 348500f3708eSMike Christie 3486a54a52caSMike Christie int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, 3487a54a52caSMike Christie enum iscsi_param param, char *buf) 3488a54a52caSMike Christie { 3489a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 3490a54a52caSMike Christie int len; 3491a54a52caSMike Christie 3492a54a52caSMike Christie switch(param) { 3493f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 3494f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->ping_timeout); 3495f6d5180cSMike Christie break; 3496f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 3497f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->recv_timeout); 3498f6d5180cSMike Christie break; 3499a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 3500a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_recv_dlength); 3501a54a52caSMike Christie break; 3502a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3503a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_xmit_dlength); 3504a54a52caSMike Christie break; 3505a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 3506a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->hdrdgst_en); 3507a54a52caSMike Christie break; 3508a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 3509a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->datadgst_en); 3510a54a52caSMike Christie break; 3511a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 3512a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ifmarker_en); 3513a54a52caSMike Christie break; 3514a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 3515a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ofmarker_en); 3516a54a52caSMike Christie break; 3517a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 3518a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->exp_statsn); 3519a54a52caSMike Christie break; 3520a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3521a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->persistent_port); 3522a54a52caSMike Christie break; 3523a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 3524a54a52caSMike Christie len = sprintf(buf, "%s\n", conn->persistent_address); 3525a54a52caSMike Christie break; 3526f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_STATSN: 3527f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->statsn); 3528f8525eb4SAdheer Chandravanshi break; 3529f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_MAX_SEGMENT_SIZE: 3530f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->max_segment_size); 3531f8525eb4SAdheer Chandravanshi break; 3532f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_KEEPALIVE_TMO: 3533f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->keepalive_tmo); 3534f8525eb4SAdheer Chandravanshi break; 3535f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_PORT: 3536f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->local_port); 3537f8525eb4SAdheer Chandravanshi break; 3538f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMESTAMP_STAT: 3539f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_timestamp_stat); 3540f8525eb4SAdheer Chandravanshi break; 3541f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_NAGLE_DISABLE: 3542f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_nagle_disable); 3543f8525eb4SAdheer Chandravanshi break; 3544f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_WSF_DISABLE: 3545f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_wsf_disable); 3546f8525eb4SAdheer Chandravanshi break; 3547f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMER_SCALE: 3548f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_timer_scale); 3549f8525eb4SAdheer Chandravanshi break; 3550f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMESTAMP_EN: 3551f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_timestamp_en); 3552f8525eb4SAdheer Chandravanshi break; 3553f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IP_FRAGMENT_DISABLE: 3554f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->fragment_disable); 3555f8525eb4SAdheer Chandravanshi break; 3556f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IPV4_TOS: 3557f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->ipv4_tos); 3558f8525eb4SAdheer Chandravanshi break; 3559f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IPV6_TC: 3560f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->ipv6_traffic_class); 3561f8525eb4SAdheer Chandravanshi break; 35625f09e1f3SAdheer Chandravanshi case ISCSI_PARAM_IPV6_FLOW_LABEL: 35635f09e1f3SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->ipv6_flow_label); 35645f09e1f3SAdheer Chandravanshi break; 3565f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IS_FW_ASSIGNED_IPV6: 3566f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->is_fw_assigned_ipv6); 3567f8525eb4SAdheer Chandravanshi break; 3568f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_XMIT_WSF: 3569f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_xmit_wsf); 3570f8525eb4SAdheer Chandravanshi break; 3571f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_RECV_WSF: 3572f8525eb4SAdheer Chandravanshi len = sprintf(buf, "%u\n", conn->tcp_recv_wsf); 3573f8525eb4SAdheer Chandravanshi break; 3574ae56ff40SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_IPADDR: 3575ae56ff40SAdheer Chandravanshi len = sprintf(buf, "%s\n", conn->local_ipaddr); 3576ae56ff40SAdheer Chandravanshi break; 3577a54a52caSMike Christie default: 3578a54a52caSMike Christie return -ENOSYS; 3579a54a52caSMike Christie } 3580a54a52caSMike Christie 3581a54a52caSMike Christie return len; 3582a54a52caSMike Christie } 3583a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_param); 3584a54a52caSMike Christie 35850801c242SMike Christie int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param, 35860801c242SMike Christie char *buf) 35870801c242SMike Christie { 358875613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 35890801c242SMike Christie int len; 35900801c242SMike Christie 35910801c242SMike Christie switch (param) { 3592d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 359375613521SMike Christie len = sprintf(buf, "%s\n", ihost->netdev); 3594d8196ed2SMike Christie break; 35950801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 359675613521SMike Christie len = sprintf(buf, "%s\n", ihost->hwaddress); 35970801c242SMike Christie break; 35988ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 359975613521SMike Christie len = sprintf(buf, "%s\n", ihost->initiatorname); 36008ad5781aSMike Christie break; 36010801c242SMike Christie default: 36020801c242SMike Christie return -ENOSYS; 36030801c242SMike Christie } 36040801c242SMike Christie 36050801c242SMike Christie return len; 36060801c242SMike Christie } 36070801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_param); 36080801c242SMike Christie 36090801c242SMike Christie int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param, 36100801c242SMike Christie char *buf, int buflen) 36110801c242SMike Christie { 361275613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 36130801c242SMike Christie 36140801c242SMike Christie switch (param) { 3615d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 36165700b1afSMike Christie return iscsi_switch_str_param(&ihost->netdev, buf); 36170801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 36185700b1afSMike Christie return iscsi_switch_str_param(&ihost->hwaddress, buf); 36198ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 36205700b1afSMike Christie return iscsi_switch_str_param(&ihost->initiatorname, buf); 36210801c242SMike Christie default: 36220801c242SMike Christie return -ENOSYS; 36230801c242SMike Christie } 36240801c242SMike Christie 36250801c242SMike Christie return 0; 36260801c242SMike Christie } 36270801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_set_param); 36280801c242SMike Christie 36297996a778SMike Christie MODULE_AUTHOR("Mike Christie"); 36307996a778SMike Christie MODULE_DESCRIPTION("iSCSI library functions"); 36317996a778SMike Christie MODULE_LICENSE("GPL"); 3632