17996a778SMike Christie /* 27996a778SMike Christie * iSCSI lib functions 37996a778SMike Christie * 47996a778SMike Christie * Copyright (C) 2006 Red Hat, Inc. All rights reserved. 57996a778SMike Christie * Copyright (C) 2004 - 2006 Mike Christie 67996a778SMike Christie * Copyright (C) 2004 - 2005 Dmitry Yusupov 77996a778SMike Christie * Copyright (C) 2004 - 2005 Alex Aizman 87996a778SMike Christie * maintained by open-iscsi@googlegroups.com 97996a778SMike Christie * 107996a778SMike Christie * This program is free software; you can redistribute it and/or modify 117996a778SMike Christie * it under the terms of the GNU General Public License as published by 127996a778SMike Christie * the Free Software Foundation; either version 2 of the License, or 137996a778SMike Christie * (at your option) any later version. 147996a778SMike Christie * 157996a778SMike Christie * This program is distributed in the hope that it will be useful, 167996a778SMike Christie * but WITHOUT ANY WARRANTY; without even the implied warranty of 177996a778SMike Christie * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 187996a778SMike Christie * GNU General Public License for more details. 197996a778SMike Christie * 207996a778SMike Christie * You should have received a copy of the GNU General Public License 217996a778SMike Christie * along with this program; if not, write to the Free Software 227996a778SMike Christie * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 237996a778SMike Christie */ 247996a778SMike Christie #include <linux/types.h> 257996a778SMike Christie #include <linux/kfifo.h> 267996a778SMike Christie #include <linux/delay.h> 2711836572Svignesh babu #include <linux/log2.h> 288eb00539SMike Christie #include <asm/unaligned.h> 297996a778SMike Christie #include <net/tcp.h> 307996a778SMike Christie #include <scsi/scsi_cmnd.h> 317996a778SMike Christie #include <scsi/scsi_device.h> 327996a778SMike Christie #include <scsi/scsi_eh.h> 337996a778SMike Christie #include <scsi/scsi_tcq.h> 347996a778SMike Christie #include <scsi/scsi_host.h> 357996a778SMike Christie #include <scsi/scsi.h> 367996a778SMike Christie #include <scsi/iscsi_proto.h> 377996a778SMike Christie #include <scsi/scsi_transport.h> 387996a778SMike Christie #include <scsi/scsi_transport_iscsi.h> 397996a778SMike Christie #include <scsi/libiscsi.h> 407996a778SMike Christie 41bd2199d4SErez Zilber static int iscsi_dbg_lib_conn; 42bd2199d4SErez Zilber module_param_named(debug_libiscsi_conn, iscsi_dbg_lib_conn, int, 43bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 44bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_conn, 45bd2199d4SErez Zilber "Turn on debugging for connections in libiscsi module. " 46bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 47bd2199d4SErez Zilber 48bd2199d4SErez Zilber static int iscsi_dbg_lib_session; 49bd2199d4SErez Zilber module_param_named(debug_libiscsi_session, iscsi_dbg_lib_session, int, 50bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 51bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_session, 52bd2199d4SErez Zilber "Turn on debugging for sessions in libiscsi module. " 53bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 54bd2199d4SErez Zilber 55bd2199d4SErez Zilber static int iscsi_dbg_lib_eh; 56bd2199d4SErez Zilber module_param_named(debug_libiscsi_eh, iscsi_dbg_lib_eh, int, 57bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 58bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_eh, 59bd2199d4SErez Zilber "Turn on debugging for error handling in libiscsi module. " 60bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 611b2c7af8SMike Christie 621b2c7af8SMike Christie #define ISCSI_DBG_CONN(_conn, dbg_fmt, arg...) \ 631b2c7af8SMike Christie do { \ 64bd2199d4SErez Zilber if (iscsi_dbg_lib_conn) \ 651b2c7af8SMike Christie iscsi_conn_printk(KERN_INFO, _conn, \ 661b2c7af8SMike Christie "%s " dbg_fmt, \ 671b2c7af8SMike Christie __func__, ##arg); \ 681b2c7af8SMike Christie } while (0); 691b2c7af8SMike Christie 701b2c7af8SMike Christie #define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...) \ 711b2c7af8SMike Christie do { \ 72bd2199d4SErez Zilber if (iscsi_dbg_lib_session) \ 73bd2199d4SErez Zilber iscsi_session_printk(KERN_INFO, _session, \ 74bd2199d4SErez Zilber "%s " dbg_fmt, \ 75bd2199d4SErez Zilber __func__, ##arg); \ 76bd2199d4SErez Zilber } while (0); 77bd2199d4SErez Zilber 78bd2199d4SErez Zilber #define ISCSI_DBG_EH(_session, dbg_fmt, arg...) \ 79bd2199d4SErez Zilber do { \ 80bd2199d4SErez Zilber if (iscsi_dbg_lib_eh) \ 811b2c7af8SMike Christie iscsi_session_printk(KERN_INFO, _session, \ 821b2c7af8SMike Christie "%s " dbg_fmt, \ 831b2c7af8SMike Christie __func__, ##arg); \ 841b2c7af8SMike Christie } while (0); 851b2c7af8SMike Christie 8677a23c21SMike Christie /* Serial Number Arithmetic, 32 bits, less than, RFC1982 */ 8777a23c21SMike Christie #define SNA32_CHECK 2147483648UL 887996a778SMike Christie 8977a23c21SMike Christie static int iscsi_sna_lt(u32 n1, u32 n2) 9077a23c21SMike Christie { 9177a23c21SMike Christie return n1 != n2 && ((n1 < n2 && (n2 - n1 < SNA32_CHECK)) || 9277a23c21SMike Christie (n1 > n2 && (n2 - n1 < SNA32_CHECK))); 9377a23c21SMike Christie } 9477a23c21SMike Christie 9577a23c21SMike Christie /* Serial Number Arithmetic, 32 bits, less than, RFC1982 */ 9677a23c21SMike Christie static int iscsi_sna_lte(u32 n1, u32 n2) 9777a23c21SMike Christie { 9877a23c21SMike Christie return n1 == n2 || ((n1 < n2 && (n2 - n1 < SNA32_CHECK)) || 9977a23c21SMike Christie (n1 > n2 && (n2 - n1 < SNA32_CHECK))); 10077a23c21SMike Christie } 10177a23c21SMike Christie 10232ae763eSMike Christie inline void iscsi_conn_queue_work(struct iscsi_conn *conn) 10332ae763eSMike Christie { 10432ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 10532ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 10632ae763eSMike Christie 1071336aed1SMike Christie if (ihost->workq) 10832ae763eSMike Christie queue_work(ihost->workq, &conn->xmitwork); 10932ae763eSMike Christie } 11032ae763eSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_queue_work); 11132ae763eSMike Christie 1124c0ba5d2SMike Christie static void __iscsi_update_cmdsn(struct iscsi_session *session, 1134c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 1147996a778SMike Christie { 11577a23c21SMike Christie /* 11677a23c21SMike Christie * standard specifies this check for when to update expected and 11777a23c21SMike Christie * max sequence numbers 11877a23c21SMike Christie */ 11977a23c21SMike Christie if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1)) 12077a23c21SMike Christie return; 12177a23c21SMike Christie 12277a23c21SMike Christie if (exp_cmdsn != session->exp_cmdsn && 12377a23c21SMike Christie !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn)) 1247996a778SMike Christie session->exp_cmdsn = exp_cmdsn; 1257996a778SMike Christie 12677a23c21SMike Christie if (max_cmdsn != session->max_cmdsn && 12777a23c21SMike Christie !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) { 12877a23c21SMike Christie session->max_cmdsn = max_cmdsn; 12977a23c21SMike Christie /* 13077a23c21SMike Christie * if the window closed with IO queued, then kick the 13177a23c21SMike Christie * xmit thread 13277a23c21SMike Christie */ 1333bbaaad9SMike Christie if (!list_empty(&session->leadconn->cmdqueue) || 1341336aed1SMike Christie !list_empty(&session->leadconn->mgmtqueue)) 13532ae763eSMike Christie iscsi_conn_queue_work(session->leadconn); 1367996a778SMike Christie } 13777a23c21SMike Christie } 1384c0ba5d2SMike Christie 1394c0ba5d2SMike Christie void iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr) 1404c0ba5d2SMike Christie { 1414c0ba5d2SMike Christie __iscsi_update_cmdsn(session, be32_to_cpu(hdr->exp_cmdsn), 1424c0ba5d2SMike Christie be32_to_cpu(hdr->max_cmdsn)); 1434c0ba5d2SMike Christie } 14477a23c21SMike Christie EXPORT_SYMBOL_GPL(iscsi_update_cmdsn); 1457996a778SMike Christie 146577577daSMike Christie /** 147577577daSMike Christie * iscsi_prep_data_out_pdu - initialize Data-Out 148577577daSMike Christie * @task: scsi command task 149577577daSMike Christie * @r2t: R2T info 150577577daSMike Christie * @hdr: iscsi data in pdu 151577577daSMike Christie * 152577577daSMike Christie * Notes: 153577577daSMike Christie * Initialize Data-Out within this R2T sequence and finds 154577577daSMike Christie * proper data_offset within this SCSI command. 155577577daSMike Christie * 156577577daSMike Christie * This function is called with connection lock taken. 157577577daSMike Christie **/ 158577577daSMike Christie void iscsi_prep_data_out_pdu(struct iscsi_task *task, struct iscsi_r2t_info *r2t, 159ffd0436eSMike Christie struct iscsi_data *hdr) 1607996a778SMike Christie { 1619c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 162577577daSMike Christie unsigned int left = r2t->data_length - r2t->sent; 163577577daSMike Christie 164577577daSMike Christie task->hdr_len = sizeof(struct iscsi_data); 1657996a778SMike Christie 1667996a778SMike Christie memset(hdr, 0, sizeof(struct iscsi_data)); 167577577daSMike Christie hdr->ttt = r2t->ttt; 168577577daSMike Christie hdr->datasn = cpu_to_be32(r2t->datasn); 169577577daSMike Christie r2t->datasn++; 1707996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_DATA_OUT; 171577577daSMike Christie memcpy(hdr->lun, task->lun, sizeof(hdr->lun)); 172577577daSMike Christie hdr->itt = task->hdr_itt; 173577577daSMike Christie hdr->exp_statsn = r2t->exp_statsn; 174577577daSMike Christie hdr->offset = cpu_to_be32(r2t->data_offset + r2t->sent); 175577577daSMike Christie if (left > conn->max_xmit_dlength) { 1767996a778SMike Christie hton24(hdr->dlength, conn->max_xmit_dlength); 177577577daSMike Christie r2t->data_count = conn->max_xmit_dlength; 1787996a778SMike Christie hdr->flags = 0; 1797996a778SMike Christie } else { 180577577daSMike Christie hton24(hdr->dlength, left); 181577577daSMike Christie r2t->data_count = left; 1827996a778SMike Christie hdr->flags = ISCSI_FLAG_CMD_FINAL; 1837996a778SMike Christie } 184577577daSMike Christie conn->dataout_pdus_cnt++; 1857996a778SMike Christie } 186577577daSMike Christie EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu); 1877996a778SMike Christie 1889c19a7d0SMike Christie static int iscsi_add_hdr(struct iscsi_task *task, unsigned len) 189004d6530SBoaz Harrosh { 1909c19a7d0SMike Christie unsigned exp_len = task->hdr_len + len; 191004d6530SBoaz Harrosh 1929c19a7d0SMike Christie if (exp_len > task->hdr_max) { 193004d6530SBoaz Harrosh WARN_ON(1); 194004d6530SBoaz Harrosh return -EINVAL; 195004d6530SBoaz Harrosh } 196004d6530SBoaz Harrosh 197004d6530SBoaz Harrosh WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */ 1989c19a7d0SMike Christie task->hdr_len = exp_len; 199004d6530SBoaz Harrosh return 0; 200004d6530SBoaz Harrosh } 201004d6530SBoaz Harrosh 20238d1c069SBoaz Harrosh /* 20338d1c069SBoaz Harrosh * make an extended cdb AHS 20438d1c069SBoaz Harrosh */ 2059c19a7d0SMike Christie static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) 20638d1c069SBoaz Harrosh { 2079c19a7d0SMike Christie struct scsi_cmnd *cmd = task->sc; 20838d1c069SBoaz Harrosh unsigned rlen, pad_len; 20938d1c069SBoaz Harrosh unsigned short ahslength; 21038d1c069SBoaz Harrosh struct iscsi_ecdb_ahdr *ecdb_ahdr; 21138d1c069SBoaz Harrosh int rc; 21238d1c069SBoaz Harrosh 2139c19a7d0SMike Christie ecdb_ahdr = iscsi_next_hdr(task); 21438d1c069SBoaz Harrosh rlen = cmd->cmd_len - ISCSI_CDB_SIZE; 21538d1c069SBoaz Harrosh 21638d1c069SBoaz Harrosh BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb)); 21738d1c069SBoaz Harrosh ahslength = rlen + sizeof(ecdb_ahdr->reserved); 21838d1c069SBoaz Harrosh 21938d1c069SBoaz Harrosh pad_len = iscsi_padding(rlen); 22038d1c069SBoaz Harrosh 2219c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) + 22238d1c069SBoaz Harrosh sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len); 22338d1c069SBoaz Harrosh if (rc) 22438d1c069SBoaz Harrosh return rc; 22538d1c069SBoaz Harrosh 22638d1c069SBoaz Harrosh if (pad_len) 22738d1c069SBoaz Harrosh memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len); 22838d1c069SBoaz Harrosh 22938d1c069SBoaz Harrosh ecdb_ahdr->ahslength = cpu_to_be16(ahslength); 23038d1c069SBoaz Harrosh ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB; 23138d1c069SBoaz Harrosh ecdb_ahdr->reserved = 0; 23238d1c069SBoaz Harrosh memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen); 23338d1c069SBoaz Harrosh 2341b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2351b2c7af8SMike Christie "iscsi_prep_ecdb_ahs: varlen_cdb_len %d " 2361b2c7af8SMike Christie "rlen %d pad_len %d ahs_length %d iscsi_headers_size " 2371b2c7af8SMike Christie "%u\n", cmd->cmd_len, rlen, pad_len, ahslength, 2381b2c7af8SMike Christie task->hdr_len); 23938d1c069SBoaz Harrosh return 0; 24038d1c069SBoaz Harrosh } 24138d1c069SBoaz Harrosh 2429c19a7d0SMike Christie static int iscsi_prep_bidi_ahs(struct iscsi_task *task) 243c07d4444SBoaz Harrosh { 2449c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 245c07d4444SBoaz Harrosh struct iscsi_rlength_ahdr *rlen_ahdr; 246c07d4444SBoaz Harrosh int rc; 247c07d4444SBoaz Harrosh 2489c19a7d0SMike Christie rlen_ahdr = iscsi_next_hdr(task); 2499c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*rlen_ahdr)); 250c07d4444SBoaz Harrosh if (rc) 251c07d4444SBoaz Harrosh return rc; 252c07d4444SBoaz Harrosh 253c07d4444SBoaz Harrosh rlen_ahdr->ahslength = 254c07d4444SBoaz Harrosh cpu_to_be16(sizeof(rlen_ahdr->read_length) + 255c07d4444SBoaz Harrosh sizeof(rlen_ahdr->reserved)); 256c07d4444SBoaz Harrosh rlen_ahdr->ahstype = ISCSI_AHSTYPE_RLENGTH; 257c07d4444SBoaz Harrosh rlen_ahdr->reserved = 0; 258c07d4444SBoaz Harrosh rlen_ahdr->read_length = cpu_to_be32(scsi_in(sc)->length); 259c07d4444SBoaz Harrosh 2601b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2611b2c7af8SMike Christie "bidi-in rlen_ahdr->read_length(%d) " 262c07d4444SBoaz Harrosh "rlen_ahdr->ahslength(%d)\n", 263c07d4444SBoaz Harrosh be32_to_cpu(rlen_ahdr->read_length), 264c07d4444SBoaz Harrosh be16_to_cpu(rlen_ahdr->ahslength)); 265c07d4444SBoaz Harrosh return 0; 266c07d4444SBoaz Harrosh } 267c07d4444SBoaz Harrosh 2687996a778SMike Christie /** 2697996a778SMike Christie * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu 2709c19a7d0SMike Christie * @task: iscsi task 2717996a778SMike Christie * 2727996a778SMike Christie * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set 2737996a778SMike Christie * fields like dlength or final based on how much data it sends 2747996a778SMike Christie */ 2759c19a7d0SMike Christie static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task) 2767996a778SMike Christie { 2779c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 2787996a778SMike Christie struct iscsi_session *session = conn->session; 2799c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 280577577daSMike Christie struct iscsi_cmd *hdr; 28138d1c069SBoaz Harrosh unsigned hdrlength, cmd_len; 282262ef636SMike Christie itt_t itt; 283004d6530SBoaz Harrosh int rc; 2847996a778SMike Christie 285184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 2862ff79d52SMike Christie rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD); 287577577daSMike Christie if (rc) 288577577daSMike Christie return rc; 289184b57c6SMike Christie } 290577577daSMike Christie hdr = (struct iscsi_cmd *) task->hdr; 291262ef636SMike Christie itt = hdr->itt; 292577577daSMike Christie memset(hdr, 0, sizeof(*hdr)); 293577577daSMike Christie 2942ff79d52SMike Christie if (session->tt->parse_pdu_itt) 2952ff79d52SMike Christie hdr->itt = task->hdr_itt = itt; 2962ff79d52SMike Christie else 2972ff79d52SMike Christie hdr->itt = task->hdr_itt = build_itt(task->itt, 2982ff79d52SMike Christie task->conn->session->age); 2999c19a7d0SMike Christie task->hdr_len = 0; 3009c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*hdr)); 301004d6530SBoaz Harrosh if (rc) 302004d6530SBoaz Harrosh return rc; 3037996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_CMD; 3047996a778SMike Christie hdr->flags = ISCSI_ATTR_SIMPLE; 3057996a778SMike Christie int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun); 306577577daSMike Christie memcpy(task->lun, hdr->lun, sizeof(task->lun)); 3077996a778SMike Christie hdr->exp_statsn = cpu_to_be32(conn->exp_statsn); 30838d1c069SBoaz Harrosh cmd_len = sc->cmd_len; 30938d1c069SBoaz Harrosh if (cmd_len < ISCSI_CDB_SIZE) 31038d1c069SBoaz Harrosh memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len); 31138d1c069SBoaz Harrosh else if (cmd_len > ISCSI_CDB_SIZE) { 3129c19a7d0SMike Christie rc = iscsi_prep_ecdb_ahs(task); 31338d1c069SBoaz Harrosh if (rc) 31438d1c069SBoaz Harrosh return rc; 31538d1c069SBoaz Harrosh cmd_len = ISCSI_CDB_SIZE; 31638d1c069SBoaz Harrosh } 31738d1c069SBoaz Harrosh memcpy(hdr->cdb, sc->cmnd, cmd_len); 3187996a778SMike Christie 3199c19a7d0SMike Christie task->imm_count = 0; 320c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc)) { 321c07d4444SBoaz Harrosh hdr->flags |= ISCSI_FLAG_CMD_READ; 3229c19a7d0SMike Christie rc = iscsi_prep_bidi_ahs(task); 323c07d4444SBoaz Harrosh if (rc) 324c07d4444SBoaz Harrosh return rc; 325c07d4444SBoaz Harrosh } 3267996a778SMike Christie if (sc->sc_data_direction == DMA_TO_DEVICE) { 327c07d4444SBoaz Harrosh unsigned out_len = scsi_out(sc)->length; 328577577daSMike Christie struct iscsi_r2t_info *r2t = &task->unsol_r2t; 329577577daSMike Christie 330c07d4444SBoaz Harrosh hdr->data_length = cpu_to_be32(out_len); 3317996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_WRITE; 3327996a778SMike Christie /* 3337996a778SMike Christie * Write counters: 3347996a778SMike Christie * 3357996a778SMike Christie * imm_count bytes to be sent right after 3367996a778SMike Christie * SCSI PDU Header 3377996a778SMike Christie * 3387996a778SMike Christie * unsol_count bytes(as Data-Out) to be sent 3397996a778SMike Christie * without R2T ack right after 3407996a778SMike Christie * immediate data 3417996a778SMike Christie * 342577577daSMike Christie * r2t data_length bytes to be sent via R2T ack's 3437996a778SMike Christie * 3447996a778SMike Christie * pad_count bytes to be sent as zero-padding 3457996a778SMike Christie */ 346577577daSMike Christie memset(r2t, 0, sizeof(*r2t)); 3477996a778SMike Christie 3487996a778SMike Christie if (session->imm_data_en) { 349c07d4444SBoaz Harrosh if (out_len >= session->first_burst) 3509c19a7d0SMike Christie task->imm_count = min(session->first_burst, 3517996a778SMike Christie conn->max_xmit_dlength); 3527996a778SMike Christie else 3539c19a7d0SMike Christie task->imm_count = min(out_len, 3547996a778SMike Christie conn->max_xmit_dlength); 3559c19a7d0SMike Christie hton24(hdr->dlength, task->imm_count); 3567996a778SMike Christie } else 357a8ac6311SOlaf Kirch zero_data(hdr->dlength); 3587996a778SMike Christie 359ffd0436eSMike Christie if (!session->initial_r2t_en) { 360577577daSMike Christie r2t->data_length = min(session->first_burst, out_len) - 361577577daSMike Christie task->imm_count; 362577577daSMike Christie r2t->data_offset = task->imm_count; 363577577daSMike Christie r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG); 364577577daSMike Christie r2t->exp_statsn = cpu_to_be32(conn->exp_statsn); 365ffd0436eSMike Christie } 366ffd0436eSMike Christie 367577577daSMike Christie if (!task->unsol_r2t.data_length) 3687996a778SMike Christie /* No unsolicit Data-Out's */ 369a8ac6311SOlaf Kirch hdr->flags |= ISCSI_FLAG_CMD_FINAL; 3707996a778SMike Christie } else { 3717996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 3727996a778SMike Christie zero_data(hdr->dlength); 373c07d4444SBoaz Harrosh hdr->data_length = cpu_to_be32(scsi_in(sc)->length); 3747996a778SMike Christie 3757996a778SMike Christie if (sc->sc_data_direction == DMA_FROM_DEVICE) 3767996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_READ; 3777996a778SMike Christie } 3787996a778SMike Christie 379004d6530SBoaz Harrosh /* calculate size of additional header segments (AHSs) */ 3809c19a7d0SMike Christie hdrlength = task->hdr_len - sizeof(*hdr); 381004d6530SBoaz Harrosh 382004d6530SBoaz Harrosh WARN_ON(hdrlength & (ISCSI_PAD_LEN-1)); 383004d6530SBoaz Harrosh hdrlength /= ISCSI_PAD_LEN; 384004d6530SBoaz Harrosh 385004d6530SBoaz Harrosh WARN_ON(hdrlength >= 256); 386004d6530SBoaz Harrosh hdr->hlength = hdrlength & 0xFF; 387004d6530SBoaz Harrosh 388577577daSMike Christie if (session->tt->init_task && session->tt->init_task(task)) 389052d0144SMike Christie return -EIO; 390052d0144SMike Christie 3919c19a7d0SMike Christie task->state = ISCSI_TASK_RUNNING; 392d3305f34SMike Christie hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn); 393d3305f34SMike Christie session->cmdsn++; 39477a23c21SMike Christie 395a8ac6311SOlaf Kirch conn->scsicmd_pdus_cnt++; 3961b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi prep [%s cid %d sc %p cdb 0x%x " 3971b2c7af8SMike Christie "itt 0x%x len %d bidi_len %d cmdsn %d win %d]\n", 3981b2c7af8SMike Christie scsi_bidi_cmnd(sc) ? "bidirectional" : 3991b2c7af8SMike Christie sc->sc_data_direction == DMA_TO_DEVICE ? 4001b2c7af8SMike Christie "write" : "read", conn->id, sc, sc->cmnd[0], 4011b2c7af8SMike Christie task->itt, scsi_bufflen(sc), 4023e5c28adSMike Christie scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0, 4031b2c7af8SMike Christie session->cmdsn, 4041b2c7af8SMike Christie session->max_cmdsn - session->exp_cmdsn + 1); 405004d6530SBoaz Harrosh return 0; 4067996a778SMike Christie } 4077996a778SMike Christie 4087996a778SMike Christie /** 4093bbaaad9SMike Christie * iscsi_free_task - free a task 4109c19a7d0SMike Christie * @task: iscsi cmd task 4117996a778SMike Christie * 4127996a778SMike Christie * Must be called with session lock. 4133e5c28adSMike Christie * This function returns the scsi command to scsi-ml or cleans 4143e5c28adSMike Christie * up mgmt tasks then returns the task to the pool. 4157996a778SMike Christie */ 4163bbaaad9SMike Christie static void iscsi_free_task(struct iscsi_task *task) 4177996a778SMike Christie { 4189c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 419c1635cb7SMike Christie struct iscsi_session *session = conn->session; 4209c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 4217996a778SMike Christie 4224421c9ebSMike Christie ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n", 4234421c9ebSMike Christie task->itt, task->state, task->sc); 4244421c9ebSMike Christie 425577577daSMike Christie session->tt->cleanup_task(task); 4263bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 4279c19a7d0SMike Christie task->sc = NULL; 4283e5c28adSMike Christie /* 4299c19a7d0SMike Christie * login task is preallocated so do not free 4303e5c28adSMike Christie */ 4319c19a7d0SMike Christie if (conn->login_task == task) 4323e5c28adSMike Christie return; 4333e5c28adSMike Christie 4349c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&task, sizeof(void*)); 4353e5c28adSMike Christie 4363e5c28adSMike Christie if (sc) { 4379c19a7d0SMike Christie task->sc = NULL; 438f47f2cf5SMike Christie /* SCSI eh reuses commands to verify us */ 439f47f2cf5SMike Christie sc->SCp.ptr = NULL; 4403e5c28adSMike Christie /* 4413e5c28adSMike Christie * queue command may call this to free the task, but 4423e5c28adSMike Christie * not have setup the sc callback 4433e5c28adSMike Christie */ 444052d0144SMike Christie if (sc->scsi_done) 4457996a778SMike Christie sc->scsi_done(sc); 4467996a778SMike Christie } 4473e5c28adSMike Christie } 4487996a778SMike Christie 449913e5bf4SMike Christie void __iscsi_get_task(struct iscsi_task *task) 45060ecebf5SMike Christie { 4519c19a7d0SMike Christie atomic_inc(&task->refcount); 45260ecebf5SMike Christie } 453913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_get_task); 45460ecebf5SMike Christie 4559c19a7d0SMike Christie static void __iscsi_put_task(struct iscsi_task *task) 45660ecebf5SMike Christie { 4579c19a7d0SMike Christie if (atomic_dec_and_test(&task->refcount)) 4583bbaaad9SMike Christie iscsi_free_task(task); 45960ecebf5SMike Christie } 46060ecebf5SMike Christie 4619c19a7d0SMike Christie void iscsi_put_task(struct iscsi_task *task) 4623e5c28adSMike Christie { 4639c19a7d0SMike Christie struct iscsi_session *session = task->conn->session; 4643e5c28adSMike Christie 4653e5c28adSMike Christie spin_lock_bh(&session->lock); 4669c19a7d0SMike Christie __iscsi_put_task(task); 4673e5c28adSMike Christie spin_unlock_bh(&session->lock); 4683e5c28adSMike Christie } 4699c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_put_task); 4703e5c28adSMike Christie 4713bbaaad9SMike Christie /** 4723bbaaad9SMike Christie * iscsi_complete_task - finish a task 4733bbaaad9SMike Christie * @task: iscsi cmd task 474b3cd5050SMike Christie * @state: state to complete task with 4753bbaaad9SMike Christie * 4763bbaaad9SMike Christie * Must be called with session lock. 477b3a7ea8dSMike Christie */ 478b3cd5050SMike Christie static void iscsi_complete_task(struct iscsi_task *task, int state) 479b3a7ea8dSMike Christie { 4803bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 4813bbaaad9SMike Christie 4824421c9ebSMike Christie ISCSI_DBG_SESSION(conn->session, 4834421c9ebSMike Christie "complete task itt 0x%x state %d sc %p\n", 4844421c9ebSMike Christie task->itt, task->state, task->sc); 485b3cd5050SMike Christie if (task->state == ISCSI_TASK_COMPLETED || 486b3cd5050SMike Christie task->state == ISCSI_TASK_ABRT_TMF || 487b3cd5050SMike Christie task->state == ISCSI_TASK_ABRT_SESS_RECOV) 4883bbaaad9SMike Christie return; 4893bbaaad9SMike Christie WARN_ON_ONCE(task->state == ISCSI_TASK_FREE); 490b3cd5050SMike Christie task->state = state; 4913bbaaad9SMike Christie 4923bbaaad9SMike Christie if (!list_empty(&task->running)) 4933bbaaad9SMike Christie list_del_init(&task->running); 4943bbaaad9SMike Christie 4953bbaaad9SMike Christie if (conn->task == task) 4963bbaaad9SMike Christie conn->task = NULL; 4973bbaaad9SMike Christie 4983bbaaad9SMike Christie if (conn->ping_task == task) 4993bbaaad9SMike Christie conn->ping_task = NULL; 5003bbaaad9SMike Christie 5013bbaaad9SMike Christie /* release get from queueing */ 5023bbaaad9SMike Christie __iscsi_put_task(task); 5033bbaaad9SMike Christie } 5043bbaaad9SMike Christie 5054c0ba5d2SMike Christie /** 5064c0ba5d2SMike Christie * iscsi_complete_scsi_task - finish scsi task normally 5074c0ba5d2SMike Christie * @task: iscsi task for scsi cmd 5084c0ba5d2SMike Christie * @exp_cmdsn: expected cmd sn in cpu format 5094c0ba5d2SMike Christie * @max_cmdsn: max cmd sn in cpu format 5104c0ba5d2SMike Christie * 5114c0ba5d2SMike Christie * This is used when drivers do not need or cannot perform 5124c0ba5d2SMike Christie * lower level pdu processing. 5134c0ba5d2SMike Christie * 5144c0ba5d2SMike Christie * Called with session lock 5154c0ba5d2SMike Christie */ 5164c0ba5d2SMike Christie void iscsi_complete_scsi_task(struct iscsi_task *task, 5174c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 5184c0ba5d2SMike Christie { 5194c0ba5d2SMike Christie struct iscsi_conn *conn = task->conn; 5204c0ba5d2SMike Christie 5214c0ba5d2SMike Christie ISCSI_DBG_SESSION(conn->session, "[itt 0x%x]\n", task->itt); 5224c0ba5d2SMike Christie 5234c0ba5d2SMike Christie conn->last_recv = jiffies; 5244c0ba5d2SMike Christie __iscsi_update_cmdsn(conn->session, exp_cmdsn, max_cmdsn); 5254c0ba5d2SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 5264c0ba5d2SMike Christie } 5274c0ba5d2SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_scsi_task); 5284c0ba5d2SMike Christie 5294c0ba5d2SMike Christie 5303bbaaad9SMike Christie /* 5313bbaaad9SMike Christie * session lock must be held and if not called for a task that is 5323bbaaad9SMike Christie * still pending or from the xmit thread, then xmit thread must 5333bbaaad9SMike Christie * be suspended. 5343bbaaad9SMike Christie */ 5353bbaaad9SMike Christie static void fail_scsi_task(struct iscsi_task *task, int err) 5363bbaaad9SMike Christie { 5373bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 538b3a7ea8dSMike Christie struct scsi_cmnd *sc; 539b3cd5050SMike Christie int state; 540b3a7ea8dSMike Christie 5413bbaaad9SMike Christie /* 5423bbaaad9SMike Christie * if a command completes and we get a successful tmf response 5433bbaaad9SMike Christie * we will hit this because the scsi eh abort code does not take 5443bbaaad9SMike Christie * a ref to the task. 5453bbaaad9SMike Christie */ 5469c19a7d0SMike Christie sc = task->sc; 547b3a7ea8dSMike Christie if (!sc) 548b3a7ea8dSMike Christie return; 549b3a7ea8dSMike Christie 550b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) { 551b3a7ea8dSMike Christie /* 552b3a7ea8dSMike Christie * cmd never made it to the xmit thread, so we should not count 553b3a7ea8dSMike Christie * the cmd in the sequencing 554b3a7ea8dSMike Christie */ 555b3a7ea8dSMike Christie conn->session->queued_cmdsn--; 556b3cd5050SMike Christie /* it was never sent so just complete like normal */ 557b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 558b3cd5050SMike Christie } else if (err == DID_TRANSPORT_DISRUPTED) 559b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 560b3cd5050SMike Christie else 561b3cd5050SMike Christie state = ISCSI_TASK_ABRT_TMF; 562b3a7ea8dSMike Christie 563b3cd5050SMike Christie sc->result = err << 16; 564c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 565b3a7ea8dSMike Christie scsi_set_resid(sc, scsi_bufflen(sc)); 566c07d4444SBoaz Harrosh else { 567c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 568c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 569c07d4444SBoaz Harrosh } 5703e5c28adSMike Christie 571b3cd5050SMike Christie iscsi_complete_task(task, state); 572b3a7ea8dSMike Christie } 573b3a7ea8dSMike Christie 5743e5c28adSMike Christie static int iscsi_prep_mgmt_task(struct iscsi_conn *conn, 5759c19a7d0SMike Christie struct iscsi_task *task) 576052d0144SMike Christie { 577052d0144SMike Christie struct iscsi_session *session = conn->session; 578577577daSMike Christie struct iscsi_hdr *hdr = task->hdr; 579052d0144SMike Christie struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr; 580052d0144SMike Christie 581052d0144SMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 582052d0144SMike Christie return -ENOTCONN; 583052d0144SMike Christie 584052d0144SMike Christie if (hdr->opcode != (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) && 585052d0144SMike Christie hdr->opcode != (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE)) 586052d0144SMike Christie nop->exp_statsn = cpu_to_be32(conn->exp_statsn); 587052d0144SMike Christie /* 588052d0144SMike Christie * pre-format CmdSN for outgoing PDU. 589052d0144SMike Christie */ 590052d0144SMike Christie nop->cmdsn = cpu_to_be32(session->cmdsn); 591052d0144SMike Christie if (hdr->itt != RESERVED_ITT) { 592052d0144SMike Christie /* 593052d0144SMike Christie * TODO: We always use immediate, so we never hit this. 594052d0144SMike Christie * If we start to send tmfs or nops as non-immediate then 595052d0144SMike Christie * we should start checking the cmdsn numbers for mgmt tasks. 596052d0144SMike Christie */ 597052d0144SMike Christie if (conn->c_stage == ISCSI_CONN_STARTED && 598052d0144SMike Christie !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 599052d0144SMike Christie session->queued_cmdsn++; 600052d0144SMike Christie session->cmdsn++; 601052d0144SMike Christie } 602052d0144SMike Christie } 603052d0144SMike Christie 604ae15f801SMike Christie if (session->tt->init_task && session->tt->init_task(task)) 605ae15f801SMike Christie return -EIO; 606052d0144SMike Christie 607052d0144SMike Christie if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT) 608052d0144SMike Christie session->state = ISCSI_STATE_LOGGING_OUT; 609052d0144SMike Christie 610577577daSMike Christie task->state = ISCSI_TASK_RUNNING; 6111b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "mgmtpdu [op 0x%x hdr->itt 0x%x " 6121b2c7af8SMike Christie "datalen %d]\n", hdr->opcode & ISCSI_OPCODE_MASK, 6131b2c7af8SMike Christie hdr->itt, task->data_count); 614052d0144SMike Christie return 0; 615052d0144SMike Christie } 616052d0144SMike Christie 6179c19a7d0SMike Christie static struct iscsi_task * 618f6d5180cSMike Christie __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 619f6d5180cSMike Christie char *data, uint32_t data_size) 620f6d5180cSMike Christie { 621f6d5180cSMike Christie struct iscsi_session *session = conn->session; 6221336aed1SMike Christie struct iscsi_host *ihost = shost_priv(session->host); 6239c19a7d0SMike Christie struct iscsi_task *task; 624262ef636SMike Christie itt_t itt; 625f6d5180cSMike Christie 626f6d5180cSMike Christie if (session->state == ISCSI_STATE_TERMINATE) 627f6d5180cSMike Christie return NULL; 628f6d5180cSMike Christie 629f6d5180cSMike Christie if (hdr->opcode == (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) || 630f6d5180cSMike Christie hdr->opcode == (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE)) 631f6d5180cSMike Christie /* 632f6d5180cSMike Christie * Login and Text are sent serially, in 633f6d5180cSMike Christie * request-followed-by-response sequence. 6343e5c28adSMike Christie * Same task can be used. Same ITT must be used. 6353e5c28adSMike Christie * Note that login_task is preallocated at conn_create(). 636f6d5180cSMike Christie */ 6379c19a7d0SMike Christie task = conn->login_task; 638f6d5180cSMike Christie else { 63926013ad4SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 64026013ad4SMike Christie return NULL; 64126013ad4SMike Christie 642f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE); 643f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED); 644f6d5180cSMike Christie 6453e5c28adSMike Christie if (!__kfifo_get(session->cmdpool.queue, 6469c19a7d0SMike Christie (void*)&task, sizeof(void*))) 647f6d5180cSMike Christie return NULL; 648f6d5180cSMike Christie } 6493e5c28adSMike Christie /* 6503e5c28adSMike Christie * released in complete pdu for task we expect a response for, and 6513e5c28adSMike Christie * released by the lld when it has transmitted the task for 6523e5c28adSMike Christie * pdus we do not expect a response for. 6533e5c28adSMike Christie */ 6549c19a7d0SMike Christie atomic_set(&task->refcount, 1); 6559c19a7d0SMike Christie task->conn = conn; 6569c19a7d0SMike Christie task->sc = NULL; 6573bbaaad9SMike Christie INIT_LIST_HEAD(&task->running); 6583bbaaad9SMike Christie task->state = ISCSI_TASK_PENDING; 659f6d5180cSMike Christie 660f6d5180cSMike Christie if (data_size) { 6619c19a7d0SMike Christie memcpy(task->data, data, data_size); 6629c19a7d0SMike Christie task->data_count = data_size; 663f6d5180cSMike Christie } else 6649c19a7d0SMike Christie task->data_count = 0; 665f6d5180cSMike Christie 666184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 6672ff79d52SMike Christie if (conn->session->tt->alloc_pdu(task, hdr->opcode)) { 668577577daSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not allocate " 669577577daSMike Christie "pdu for mgmt task.\n"); 6703bbaaad9SMike Christie goto free_task; 671577577daSMike Christie } 672184b57c6SMike Christie } 673184b57c6SMike Christie 674262ef636SMike Christie itt = task->hdr->itt; 675577577daSMike Christie task->hdr_len = sizeof(struct iscsi_hdr); 6769c19a7d0SMike Christie memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr)); 677262ef636SMike Christie 678262ef636SMike Christie if (hdr->itt != RESERVED_ITT) { 679262ef636SMike Christie if (session->tt->parse_pdu_itt) 680262ef636SMike Christie task->hdr->itt = itt; 681262ef636SMike Christie else 682262ef636SMike Christie task->hdr->itt = build_itt(task->itt, 683262ef636SMike Christie task->conn->session->age); 684262ef636SMike Christie } 685262ef636SMike Christie 6861336aed1SMike Christie if (!ihost->workq) { 687577577daSMike Christie if (iscsi_prep_mgmt_task(conn, task)) 688577577daSMike Christie goto free_task; 689052d0144SMike Christie 6909c19a7d0SMike Christie if (session->tt->xmit_task(task)) 691577577daSMike Christie goto free_task; 6923bbaaad9SMike Christie } else { 6933bbaaad9SMike Christie list_add_tail(&task->running, &conn->mgmtqueue); 69432ae763eSMike Christie iscsi_conn_queue_work(conn); 6953bbaaad9SMike Christie } 696052d0144SMike Christie 6979c19a7d0SMike Christie return task; 698577577daSMike Christie 699577577daSMike Christie free_task: 700577577daSMike Christie __iscsi_put_task(task); 701577577daSMike Christie return NULL; 702f6d5180cSMike Christie } 703f6d5180cSMike Christie 704f6d5180cSMike Christie int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr, 705f6d5180cSMike Christie char *data, uint32_t data_size) 706f6d5180cSMike Christie { 707f6d5180cSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 708f6d5180cSMike Christie struct iscsi_session *session = conn->session; 709f6d5180cSMike Christie int err = 0; 710f6d5180cSMike Christie 711f6d5180cSMike Christie spin_lock_bh(&session->lock); 712f6d5180cSMike Christie if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size)) 713f6d5180cSMike Christie err = -EPERM; 714f6d5180cSMike Christie spin_unlock_bh(&session->lock); 715f6d5180cSMike Christie return err; 716f6d5180cSMike Christie } 717f6d5180cSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu); 718f6d5180cSMike Christie 7197996a778SMike Christie /** 7207996a778SMike Christie * iscsi_cmd_rsp - SCSI Command Response processing 7217996a778SMike Christie * @conn: iscsi connection 7227996a778SMike Christie * @hdr: iscsi header 7239c19a7d0SMike Christie * @task: scsi command task 7247996a778SMike Christie * @data: cmd data buffer 7257996a778SMike Christie * @datalen: len of buffer 7267996a778SMike Christie * 7277996a778SMike Christie * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and 7289c19a7d0SMike Christie * then completes the command and task. 7297996a778SMike Christie **/ 73077a23c21SMike Christie static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 7319c19a7d0SMike Christie struct iscsi_task *task, char *data, 7327996a778SMike Christie int datalen) 7337996a778SMike Christie { 7347996a778SMike Christie struct iscsi_cmd_rsp *rhdr = (struct iscsi_cmd_rsp *)hdr; 7357996a778SMike Christie struct iscsi_session *session = conn->session; 7369c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 7377996a778SMike Christie 73877a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr); 7397996a778SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 7407996a778SMike Christie 7417996a778SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 7427996a778SMike Christie 7437996a778SMike Christie if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) { 7447996a778SMike Christie sc->result = DID_ERROR << 16; 7457996a778SMike Christie goto out; 7467996a778SMike Christie } 7477996a778SMike Christie 7487996a778SMike Christie if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) { 7499b80cb4bSMike Christie uint16_t senselen; 7507996a778SMike Christie 7517996a778SMike Christie if (datalen < 2) { 7527996a778SMike Christie invalid_datalen: 753322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 754322d739dSMike Christie "Got CHECK_CONDITION but invalid data " 755322d739dSMike Christie "buffer size of %d\n", datalen); 7567996a778SMike Christie sc->result = DID_BAD_TARGET << 16; 7577996a778SMike Christie goto out; 7587996a778SMike Christie } 7597996a778SMike Christie 7608f333991SHarvey Harrison senselen = get_unaligned_be16(data); 7617996a778SMike Christie if (datalen < senselen) 7627996a778SMike Christie goto invalid_datalen; 7637996a778SMike Christie 7647996a778SMike Christie memcpy(sc->sense_buffer, data + 2, 7659b80cb4bSMike Christie min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 7661b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n", 7671b2c7af8SMike Christie min_t(uint16_t, senselen, 7681b2c7af8SMike Christie SCSI_SENSE_BUFFERSIZE)); 7697996a778SMike Christie } 7707996a778SMike Christie 771c07d4444SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW | 772c07d4444SBoaz Harrosh ISCSI_FLAG_CMD_BIDI_OVERFLOW)) { 773c07d4444SBoaz Harrosh int res_count = be32_to_cpu(rhdr->bi_residual_count); 774c07d4444SBoaz Harrosh 775c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc) && res_count > 0 && 776c07d4444SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_BIDI_OVERFLOW || 777c07d4444SBoaz Harrosh res_count <= scsi_in(sc)->length)) 778c07d4444SBoaz Harrosh scsi_in(sc)->resid = res_count; 779c07d4444SBoaz Harrosh else 780c07d4444SBoaz Harrosh sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 781c07d4444SBoaz Harrosh } 782c07d4444SBoaz Harrosh 7837207fea4SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW | 7847207fea4SBoaz Harrosh ISCSI_FLAG_CMD_OVERFLOW)) { 7857996a778SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 7867996a778SMike Christie 7877207fea4SBoaz Harrosh if (res_count > 0 && 7887207fea4SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 7897207fea4SBoaz Harrosh res_count <= scsi_bufflen(sc))) 790c07d4444SBoaz Harrosh /* write side for bidi or uni-io set_resid */ 7911c138991SFUJITA Tomonori scsi_set_resid(sc, res_count); 7927996a778SMike Christie else 7937996a778SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 794c07d4444SBoaz Harrosh } 7957996a778SMike Christie out: 7963bbaaad9SMike Christie ISCSI_DBG_SESSION(session, "cmd rsp done [sc %p res %d itt 0x%x]\n", 7971b2c7af8SMike Christie sc, sc->result, task->itt); 7987996a778SMike Christie conn->scsirsp_pdus_cnt++; 799b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 8007996a778SMike Christie } 8017996a778SMike Christie 8021d9edf02SMike Christie /** 8031d9edf02SMike Christie * iscsi_data_in_rsp - SCSI Data-In Response processing 8041d9edf02SMike Christie * @conn: iscsi connection 8051d9edf02SMike Christie * @hdr: iscsi pdu 8061d9edf02SMike Christie * @task: scsi command task 8071d9edf02SMike Christie **/ 8081d9edf02SMike Christie static void 8091d9edf02SMike Christie iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 8101d9edf02SMike Christie struct iscsi_task *task) 8111d9edf02SMike Christie { 8121d9edf02SMike Christie struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr; 8131d9edf02SMike Christie struct scsi_cmnd *sc = task->sc; 8141d9edf02SMike Christie 8151d9edf02SMike Christie if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS)) 8161d9edf02SMike Christie return; 8171d9edf02SMike Christie 818edbc9aa0SMike Christie iscsi_update_cmdsn(conn->session, (struct iscsi_nopin *)hdr); 8191d9edf02SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 8201d9edf02SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 8211d9edf02SMike Christie if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW | 8221d9edf02SMike Christie ISCSI_FLAG_DATA_OVERFLOW)) { 8231d9edf02SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 8241d9edf02SMike Christie 8251d9edf02SMike Christie if (res_count > 0 && 8261d9edf02SMike Christie (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 8271d9edf02SMike Christie res_count <= scsi_in(sc)->length)) 8281d9edf02SMike Christie scsi_in(sc)->resid = res_count; 8291d9edf02SMike Christie else 8301d9edf02SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 8311d9edf02SMike Christie } 8321d9edf02SMike Christie 8333bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, "data in with status done " 8343bbaaad9SMike Christie "[sc %p res %d itt 0x%x]\n", 8353bbaaad9SMike Christie sc, sc->result, task->itt); 8361d9edf02SMike Christie conn->scsirsp_pdus_cnt++; 837b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 8381d9edf02SMike Christie } 8391d9edf02SMike Christie 8407ea8b828SMike Christie static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) 8417ea8b828SMike Christie { 8427ea8b828SMike Christie struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; 8437ea8b828SMike Christie 8447ea8b828SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 8457ea8b828SMike Christie conn->tmfrsp_pdus_cnt++; 8467ea8b828SMike Christie 847843c0a8aSMike Christie if (conn->tmf_state != TMF_QUEUED) 8487ea8b828SMike Christie return; 8497ea8b828SMike Christie 8507ea8b828SMike Christie if (tmf->response == ISCSI_TMF_RSP_COMPLETE) 851843c0a8aSMike Christie conn->tmf_state = TMF_SUCCESS; 8527ea8b828SMike Christie else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) 853843c0a8aSMike Christie conn->tmf_state = TMF_NOT_FOUND; 8547ea8b828SMike Christie else 855843c0a8aSMike Christie conn->tmf_state = TMF_FAILED; 8567ea8b828SMike Christie wake_up(&conn->ehwait); 8577ea8b828SMike Christie } 8587ea8b828SMike Christie 859f6d5180cSMike Christie static void iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) 860f6d5180cSMike Christie { 861f6d5180cSMike Christie struct iscsi_nopout hdr; 8629c19a7d0SMike Christie struct iscsi_task *task; 863f6d5180cSMike Christie 8649c19a7d0SMike Christie if (!rhdr && conn->ping_task) 865f6d5180cSMike Christie return; 866f6d5180cSMike Christie 867f6d5180cSMike Christie memset(&hdr, 0, sizeof(struct iscsi_nopout)); 868f6d5180cSMike Christie hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE; 869f6d5180cSMike Christie hdr.flags = ISCSI_FLAG_CMD_FINAL; 870f6d5180cSMike Christie 871f6d5180cSMike Christie if (rhdr) { 872f6d5180cSMike Christie memcpy(hdr.lun, rhdr->lun, 8); 873f6d5180cSMike Christie hdr.ttt = rhdr->ttt; 874f6d5180cSMike Christie hdr.itt = RESERVED_ITT; 875f6d5180cSMike Christie } else 876f6d5180cSMike Christie hdr.ttt = RESERVED_ITT; 877f6d5180cSMike Christie 8789c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0); 8799c19a7d0SMike Christie if (!task) 880322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n"); 881d3acf022SMike Christie else if (!rhdr) { 882d3acf022SMike Christie /* only track our nops */ 883d3acf022SMike Christie conn->ping_task = task; 884d3acf022SMike Christie conn->last_ping = jiffies; 885d3acf022SMike Christie } 886f6d5180cSMike Christie } 887f6d5180cSMike Christie 8888afa1439SMike Christie static int iscsi_nop_out_rsp(struct iscsi_task *task, 8898afa1439SMike Christie struct iscsi_nopin *nop, char *data, int datalen) 8908afa1439SMike Christie { 8918afa1439SMike Christie struct iscsi_conn *conn = task->conn; 8928afa1439SMike Christie int rc = 0; 8938afa1439SMike Christie 8948afa1439SMike Christie if (conn->ping_task != task) { 8958afa1439SMike Christie /* 8968afa1439SMike Christie * If this is not in response to one of our 8978afa1439SMike Christie * nops then it must be from userspace. 8988afa1439SMike Christie */ 8998afa1439SMike Christie if (iscsi_recv_pdu(conn->cls_conn, (struct iscsi_hdr *)nop, 9008afa1439SMike Christie data, datalen)) 9018afa1439SMike Christie rc = ISCSI_ERR_CONN_FAILED; 9028afa1439SMike Christie } else 9038afa1439SMike Christie mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout); 9048afa1439SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 9058afa1439SMike Christie return rc; 9068afa1439SMike Christie } 9078afa1439SMike Christie 90862f38300SMike Christie static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 90962f38300SMike Christie char *data, int datalen) 91062f38300SMike Christie { 91162f38300SMike Christie struct iscsi_reject *reject = (struct iscsi_reject *)hdr; 91262f38300SMike Christie struct iscsi_hdr rejected_pdu; 9138afa1439SMike Christie int opcode, rc = 0; 91462f38300SMike Christie 91562f38300SMike Christie conn->exp_statsn = be32_to_cpu(reject->statsn) + 1; 91662f38300SMike Christie 9178afa1439SMike Christie if (ntoh24(reject->dlength) > datalen || 9188afa1439SMike Christie ntoh24(reject->dlength) < sizeof(struct iscsi_hdr)) { 9198afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Cannot handle rejected " 9208afa1439SMike Christie "pdu. Invalid data length (pdu dlength " 9218afa1439SMike Christie "%u, datalen %d\n", ntoh24(reject->dlength), 9228afa1439SMike Christie datalen); 92362f38300SMike Christie return ISCSI_ERR_PROTO; 9248afa1439SMike Christie } 92562f38300SMike Christie memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr)); 9268afa1439SMike Christie opcode = rejected_pdu.opcode & ISCSI_OPCODE_MASK; 9278afa1439SMike Christie 9288afa1439SMike Christie switch (reject->reason) { 9298afa1439SMike Christie case ISCSI_REASON_DATA_DIGEST_ERROR: 930322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 9318afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected " 932262ef636SMike Christie "due to DataDigest error.\n", 9338afa1439SMike Christie rejected_pdu.itt, opcode); 9348afa1439SMike Christie break; 9358afa1439SMike Christie case ISCSI_REASON_IMM_CMD_REJECT: 9368afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 9378afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Too many " 9388afa1439SMike Christie "immediate commands.\n", 9398afa1439SMike Christie rejected_pdu.itt, opcode); 9408afa1439SMike Christie /* 9418afa1439SMike Christie * We only send one TMF at a time so if the target could not 9428afa1439SMike Christie * handle it, then it should get fixed (RFC mandates that 9438afa1439SMike Christie * a target can handle one immediate TMF per conn). 9448afa1439SMike Christie * 9458afa1439SMike Christie * For nops-outs, we could have sent more than one if 9468afa1439SMike Christie * the target is sending us lots of nop-ins 9478afa1439SMike Christie */ 9488afa1439SMike Christie if (opcode != ISCSI_OP_NOOP_OUT) 94962f38300SMike Christie return 0; 9508afa1439SMike Christie 9518afa1439SMike Christie if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG)) 9528afa1439SMike Christie /* 9538afa1439SMike Christie * nop-out in response to target's nop-out rejected. 9548afa1439SMike Christie * Just resend. 9558afa1439SMike Christie */ 9568afa1439SMike Christie iscsi_send_nopout(conn, 9578afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu); 9588afa1439SMike Christie else { 9598afa1439SMike Christie struct iscsi_task *task; 9608afa1439SMike Christie /* 9618afa1439SMike Christie * Our nop as ping got dropped. We know the target 9628afa1439SMike Christie * and transport are ok so just clean up 9638afa1439SMike Christie */ 9648afa1439SMike Christie task = iscsi_itt_to_task(conn, rejected_pdu.itt); 9658afa1439SMike Christie if (!task) { 9668afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 9678afa1439SMike Christie "Invalid pdu reject. Could " 9688afa1439SMike Christie "not lookup rejected task.\n"); 9698afa1439SMike Christie rc = ISCSI_ERR_BAD_ITT; 9708afa1439SMike Christie } else 9718afa1439SMike Christie rc = iscsi_nop_out_rsp(task, 9728afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu, 9738afa1439SMike Christie NULL, 0); 9748afa1439SMike Christie } 9758afa1439SMike Christie break; 9768afa1439SMike Christie default: 9778afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 9788afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Reason " 9798afa1439SMike Christie "code 0x%x\n", rejected_pdu.itt, 9808afa1439SMike Christie rejected_pdu.opcode, reject->reason); 9818afa1439SMike Christie break; 9828afa1439SMike Christie } 9838afa1439SMike Christie return rc; 98462f38300SMike Christie } 98562f38300SMike Christie 9867996a778SMike Christie /** 987913e5bf4SMike Christie * iscsi_itt_to_task - look up task by itt 988913e5bf4SMike Christie * @conn: iscsi connection 989913e5bf4SMike Christie * @itt: itt 990913e5bf4SMike Christie * 991913e5bf4SMike Christie * This should be used for mgmt tasks like login and nops, or if 992913e5bf4SMike Christie * the LDD's itt space does not include the session age. 993913e5bf4SMike Christie * 994913e5bf4SMike Christie * The session lock must be held. 995913e5bf4SMike Christie */ 9968f9256ceSMike Christie struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt) 997913e5bf4SMike Christie { 998913e5bf4SMike Christie struct iscsi_session *session = conn->session; 999262ef636SMike Christie int i; 1000913e5bf4SMike Christie 1001913e5bf4SMike Christie if (itt == RESERVED_ITT) 1002913e5bf4SMike Christie return NULL; 1003913e5bf4SMike Christie 1004262ef636SMike Christie if (session->tt->parse_pdu_itt) 1005262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, NULL); 1006262ef636SMike Christie else 1007913e5bf4SMike Christie i = get_itt(itt); 1008913e5bf4SMike Christie if (i >= session->cmds_max) 1009913e5bf4SMike Christie return NULL; 1010913e5bf4SMike Christie 1011913e5bf4SMike Christie return session->cmds[i]; 1012913e5bf4SMike Christie } 10138f9256ceSMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_task); 1014913e5bf4SMike Christie 1015913e5bf4SMike Christie /** 10167996a778SMike Christie * __iscsi_complete_pdu - complete pdu 10177996a778SMike Christie * @conn: iscsi conn 10187996a778SMike Christie * @hdr: iscsi header 10197996a778SMike Christie * @data: data buffer 10207996a778SMike Christie * @datalen: len of data buffer 10217996a778SMike Christie * 10227996a778SMike Christie * Completes pdu processing by freeing any resources allocated at 10237996a778SMike Christie * queuecommand or send generic. session lock must be held and verify 10247996a778SMike Christie * itt must have been called. 10257996a778SMike Christie */ 1026913e5bf4SMike Christie int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 10277996a778SMike Christie char *data, int datalen) 10287996a778SMike Christie { 10297996a778SMike Christie struct iscsi_session *session = conn->session; 10307996a778SMike Christie int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0; 10319c19a7d0SMike Christie struct iscsi_task *task; 10327996a778SMike Christie uint32_t itt; 10337996a778SMike Christie 1034f6d5180cSMike Christie conn->last_recv = jiffies; 10350af967f5SMike Christie rc = iscsi_verify_itt(conn, hdr->itt); 10360af967f5SMike Christie if (rc) 10370af967f5SMike Christie return rc; 10380af967f5SMike Christie 1039b4377356SAl Viro if (hdr->itt != RESERVED_ITT) 1040b4377356SAl Viro itt = get_itt(hdr->itt); 10417996a778SMike Christie else 1042b4377356SAl Viro itt = ~0U; 10437996a778SMike Christie 10441b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "[op 0x%x cid %d itt 0x%x len %d]\n", 10453e5c28adSMike Christie opcode, conn->id, itt, datalen); 10467996a778SMike Christie 10473e5c28adSMike Christie if (itt == ~0U) { 104877a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 104962f38300SMike Christie 10507996a778SMike Christie switch(opcode) { 10517996a778SMike Christie case ISCSI_OP_NOOP_IN: 105240527afeSMike Christie if (datalen) { 105340527afeSMike Christie rc = ISCSI_ERR_PROTO; 105440527afeSMike Christie break; 105540527afeSMike Christie } 105640527afeSMike Christie 1057b4377356SAl Viro if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) 105840527afeSMike Christie break; 105940527afeSMike Christie 1060f6d5180cSMike Christie iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr); 10617996a778SMike Christie break; 10627996a778SMike Christie case ISCSI_OP_REJECT: 106362f38300SMike Christie rc = iscsi_handle_reject(conn, hdr, data, datalen); 106462f38300SMike Christie break; 10657996a778SMike Christie case ISCSI_OP_ASYNC_EVENT: 10668d2860b3SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 10675831c737SMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 10685831c737SMike Christie rc = ISCSI_ERR_CONN_FAILED; 10697996a778SMike Christie break; 10707996a778SMike Christie default: 10717996a778SMike Christie rc = ISCSI_ERR_BAD_OPCODE; 10727996a778SMike Christie break; 10737996a778SMike Christie } 10743e5c28adSMike Christie goto out; 10753e5c28adSMike Christie } 10767996a778SMike Christie 10773e5c28adSMike Christie switch(opcode) { 10783e5c28adSMike Christie case ISCSI_OP_SCSI_CMD_RSP: 1079913e5bf4SMike Christie case ISCSI_OP_SCSI_DATA_IN: 1080913e5bf4SMike Christie task = iscsi_itt_to_ctask(conn, hdr->itt); 1081913e5bf4SMike Christie if (!task) 1082913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1083d355e57dSMike Christie task->last_xfer = jiffies; 10843e5c28adSMike Christie break; 1085913e5bf4SMike Christie case ISCSI_OP_R2T: 1086913e5bf4SMike Christie /* 1087913e5bf4SMike Christie * LLD handles R2Ts if they need to. 1088913e5bf4SMike Christie */ 1089913e5bf4SMike Christie return 0; 1090913e5bf4SMike Christie case ISCSI_OP_LOGOUT_RSP: 1091913e5bf4SMike Christie case ISCSI_OP_LOGIN_RSP: 1092913e5bf4SMike Christie case ISCSI_OP_TEXT_RSP: 1093913e5bf4SMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 1094913e5bf4SMike Christie case ISCSI_OP_NOOP_IN: 1095913e5bf4SMike Christie task = iscsi_itt_to_task(conn, hdr->itt); 1096913e5bf4SMike Christie if (!task) 1097913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1098913e5bf4SMike Christie break; 1099913e5bf4SMike Christie default: 1100913e5bf4SMike Christie return ISCSI_ERR_BAD_OPCODE; 11013e5c28adSMike Christie } 1102913e5bf4SMike Christie 1103913e5bf4SMike Christie switch(opcode) { 1104913e5bf4SMike Christie case ISCSI_OP_SCSI_CMD_RSP: 11059c19a7d0SMike Christie iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen); 11063e5c28adSMike Christie break; 11073e5c28adSMike Christie case ISCSI_OP_SCSI_DATA_IN: 11081d9edf02SMike Christie iscsi_data_in_rsp(conn, hdr, task); 11093e5c28adSMike Christie break; 11103e5c28adSMike Christie case ISCSI_OP_LOGOUT_RSP: 11113e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 11123e5c28adSMike Christie if (datalen) { 11133e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 11143e5c28adSMike Christie break; 11153e5c28adSMike Christie } 11163e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 11173e5c28adSMike Christie goto recv_pdu; 11183e5c28adSMike Christie case ISCSI_OP_LOGIN_RSP: 11193e5c28adSMike Christie case ISCSI_OP_TEXT_RSP: 11203e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 11213e5c28adSMike Christie /* 11223e5c28adSMike Christie * login related PDU's exp_statsn is handled in 11233e5c28adSMike Christie * userspace 11243e5c28adSMike Christie */ 11253e5c28adSMike Christie goto recv_pdu; 11263e5c28adSMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 11273e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 11283e5c28adSMike Christie if (datalen) { 11293e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 11303e5c28adSMike Christie break; 11313e5c28adSMike Christie } 11323e5c28adSMike Christie 11333e5c28adSMike Christie iscsi_tmf_rsp(conn, hdr); 1134b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 11353e5c28adSMike Christie break; 11363e5c28adSMike Christie case ISCSI_OP_NOOP_IN: 11373e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 11383e5c28adSMike Christie if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) { 11393e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 11403e5c28adSMike Christie break; 11413e5c28adSMike Christie } 11423e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 11433e5c28adSMike Christie 11448afa1439SMike Christie rc = iscsi_nop_out_rsp(task, (struct iscsi_nopin*)hdr, 11458afa1439SMike Christie data, datalen); 11463e5c28adSMike Christie break; 11473e5c28adSMike Christie default: 11483e5c28adSMike Christie rc = ISCSI_ERR_BAD_OPCODE; 11493e5c28adSMike Christie break; 11503e5c28adSMike Christie } 11513e5c28adSMike Christie 11523e5c28adSMike Christie out: 11533e5c28adSMike Christie return rc; 11543e5c28adSMike Christie recv_pdu: 11553e5c28adSMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 11563e5c28adSMike Christie rc = ISCSI_ERR_CONN_FAILED; 1157b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 11587996a778SMike Christie return rc; 11597996a778SMike Christie } 1160913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_complete_pdu); 11617996a778SMike Christie 11627996a778SMike Christie int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 11637996a778SMike Christie char *data, int datalen) 11647996a778SMike Christie { 11657996a778SMike Christie int rc; 11667996a778SMike Christie 11677996a778SMike Christie spin_lock(&conn->session->lock); 11687996a778SMike Christie rc = __iscsi_complete_pdu(conn, hdr, data, datalen); 11697996a778SMike Christie spin_unlock(&conn->session->lock); 11707996a778SMike Christie return rc; 11717996a778SMike Christie } 11727996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_pdu); 11737996a778SMike Christie 11740af967f5SMike Christie int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt) 11757996a778SMike Christie { 11767996a778SMike Christie struct iscsi_session *session = conn->session; 1177262ef636SMike Christie int age = 0, i = 0; 11787996a778SMike Christie 11790af967f5SMike Christie if (itt == RESERVED_ITT) 11800af967f5SMike Christie return 0; 11810af967f5SMike Christie 1182262ef636SMike Christie if (session->tt->parse_pdu_itt) 1183262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, &age); 1184262ef636SMike Christie else { 1185262ef636SMike Christie i = get_itt(itt); 1186262ef636SMike Christie age = ((__force u32)itt >> ISCSI_AGE_SHIFT) & ISCSI_AGE_MASK; 1187262ef636SMike Christie } 1188262ef636SMike Christie 1189262ef636SMike Christie if (age != session->age) { 1190322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 11910af967f5SMike Christie "received itt %x expected session age (%x)\n", 1192913e5bf4SMike Christie (__force u32)itt, session->age); 11937996a778SMike Christie return ISCSI_ERR_BAD_ITT; 11947996a778SMike Christie } 11957996a778SMike Christie 11963e5c28adSMike Christie if (i >= session->cmds_max) { 11973e5c28adSMike Christie iscsi_conn_printk(KERN_ERR, conn, 11983e5c28adSMike Christie "received invalid itt index %u (max cmds " 11993e5c28adSMike Christie "%u.\n", i, session->cmds_max); 12003e5c28adSMike Christie return ISCSI_ERR_BAD_ITT; 12017996a778SMike Christie } 12027996a778SMike Christie return 0; 12037996a778SMike Christie } 12047996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_verify_itt); 12057996a778SMike Christie 1206913e5bf4SMike Christie /** 1207913e5bf4SMike Christie * iscsi_itt_to_ctask - look up ctask by itt 1208913e5bf4SMike Christie * @conn: iscsi connection 1209913e5bf4SMike Christie * @itt: itt 1210913e5bf4SMike Christie * 1211913e5bf4SMike Christie * This should be used for cmd tasks. 1212913e5bf4SMike Christie * 1213913e5bf4SMike Christie * The session lock must be held. 1214913e5bf4SMike Christie */ 1215913e5bf4SMike Christie struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt) 12160af967f5SMike Christie { 12179c19a7d0SMike Christie struct iscsi_task *task; 12180af967f5SMike Christie 12190af967f5SMike Christie if (iscsi_verify_itt(conn, itt)) 12200af967f5SMike Christie return NULL; 12210af967f5SMike Christie 1222913e5bf4SMike Christie task = iscsi_itt_to_task(conn, itt); 1223913e5bf4SMike Christie if (!task || !task->sc) 12240af967f5SMike Christie return NULL; 12250af967f5SMike Christie 1226913e5bf4SMike Christie if (task->sc->SCp.phase != conn->session->age) { 1227913e5bf4SMike Christie iscsi_session_printk(KERN_ERR, conn->session, 1228913e5bf4SMike Christie "task's session age %d, expected %d\n", 1229913e5bf4SMike Christie task->sc->SCp.phase, conn->session->age); 12300af967f5SMike Christie return NULL; 1231913e5bf4SMike Christie } 12320af967f5SMike Christie 12339c19a7d0SMike Christie return task; 12340af967f5SMike Christie } 12350af967f5SMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask); 12360af967f5SMike Christie 123740a06e75SMike Christie void iscsi_session_failure(struct iscsi_session *session, 1238e5bd7b54SMike Christie enum iscsi_err err) 1239e5bd7b54SMike Christie { 1240e5bd7b54SMike Christie struct iscsi_conn *conn; 1241e5bd7b54SMike Christie struct device *dev; 1242e5bd7b54SMike Christie unsigned long flags; 1243e5bd7b54SMike Christie 1244e5bd7b54SMike Christie spin_lock_irqsave(&session->lock, flags); 1245e5bd7b54SMike Christie conn = session->leadconn; 1246e5bd7b54SMike Christie if (session->state == ISCSI_STATE_TERMINATE || !conn) { 1247e5bd7b54SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1248e5bd7b54SMike Christie return; 1249e5bd7b54SMike Christie } 1250e5bd7b54SMike Christie 1251e5bd7b54SMike Christie dev = get_device(&conn->cls_conn->dev); 1252e5bd7b54SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1253e5bd7b54SMike Christie if (!dev) 1254e5bd7b54SMike Christie return; 1255e5bd7b54SMike Christie /* 1256e5bd7b54SMike Christie * if the host is being removed bypass the connection 1257e5bd7b54SMike Christie * recovery initialization because we are going to kill 1258e5bd7b54SMike Christie * the session. 1259e5bd7b54SMike Christie */ 1260e5bd7b54SMike Christie if (err == ISCSI_ERR_INVALID_HOST) 1261e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 1262e5bd7b54SMike Christie else 1263e5bd7b54SMike Christie iscsi_conn_failure(conn, err); 1264e5bd7b54SMike Christie put_device(dev); 1265e5bd7b54SMike Christie } 1266e5bd7b54SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_failure); 1267e5bd7b54SMike Christie 12687996a778SMike Christie void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err) 12697996a778SMike Christie { 12707996a778SMike Christie struct iscsi_session *session = conn->session; 12717996a778SMike Christie unsigned long flags; 12727996a778SMike Christie 12737996a778SMike Christie spin_lock_irqsave(&session->lock, flags); 1274656cffc9SMike Christie if (session->state == ISCSI_STATE_FAILED) { 1275656cffc9SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1276656cffc9SMike Christie return; 1277656cffc9SMike Christie } 1278656cffc9SMike Christie 127967a61114SMike Christie if (conn->stop_stage == 0) 12807996a778SMike Christie session->state = ISCSI_STATE_FAILED; 12817996a778SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1282e5bd7b54SMike Christie 12837996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 12847996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 1285e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 12867996a778SMike Christie } 12877996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_failure); 12887996a778SMike Christie 128977a23c21SMike Christie static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn) 129077a23c21SMike Christie { 129177a23c21SMike Christie struct iscsi_session *session = conn->session; 129277a23c21SMike Christie 129377a23c21SMike Christie /* 129477a23c21SMike Christie * Check for iSCSI window and take care of CmdSN wrap-around 129577a23c21SMike Christie */ 1296e0726407SMike Christie if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) { 12971b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iSCSI CmdSN closed. ExpCmdSn " 12981b2c7af8SMike Christie "%u MaxCmdSN %u CmdSN %u/%u\n", 12991b2c7af8SMike Christie session->exp_cmdsn, session->max_cmdsn, 13001b2c7af8SMike Christie session->cmdsn, session->queued_cmdsn); 130177a23c21SMike Christie return -ENOSPC; 130277a23c21SMike Christie } 130377a23c21SMike Christie return 0; 130477a23c21SMike Christie } 130577a23c21SMike Christie 13069c19a7d0SMike Christie static int iscsi_xmit_task(struct iscsi_conn *conn) 130777a23c21SMike Christie { 13089c19a7d0SMike Christie struct iscsi_task *task = conn->task; 1309843c0a8aSMike Christie int rc; 131077a23c21SMike Christie 131170b31c15SMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) 131270b31c15SMike Christie return -ENODATA; 131370b31c15SMike Christie 13149c19a7d0SMike Christie __iscsi_get_task(task); 131577a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 13169c19a7d0SMike Christie rc = conn->session->tt->xmit_task(task); 131777a23c21SMike Christie spin_lock_bh(&conn->session->lock); 1318d355e57dSMike Christie if (!rc) { 13199c19a7d0SMike Christie /* done with this task */ 1320d355e57dSMike Christie task->last_xfer = jiffies; 13219c19a7d0SMike Christie conn->task = NULL; 1322d355e57dSMike Christie } 1323d355e57dSMike Christie __iscsi_put_task(task); 132477a23c21SMike Christie return rc; 132577a23c21SMike Christie } 132677a23c21SMike Christie 13277996a778SMike Christie /** 13289c19a7d0SMike Christie * iscsi_requeue_task - requeue task to run from session workqueue 13299c19a7d0SMike Christie * @task: task to requeue 1330843c0a8aSMike Christie * 13319c19a7d0SMike Christie * LLDs that need to run a task from the session workqueue should call 1332052d0144SMike Christie * this. The session lock must be held. This should only be called 1333052d0144SMike Christie * by software drivers. 1334843c0a8aSMike Christie */ 13359c19a7d0SMike Christie void iscsi_requeue_task(struct iscsi_task *task) 1336843c0a8aSMike Christie { 13379c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 1338843c0a8aSMike Christie 13393bbaaad9SMike Christie /* 13403bbaaad9SMike Christie * this may be on the requeue list already if the xmit_task callout 13413bbaaad9SMike Christie * is handling the r2ts while we are adding new ones 13423bbaaad9SMike Christie */ 13433bbaaad9SMike Christie if (list_empty(&task->running)) 13443bbaaad9SMike Christie list_add_tail(&task->running, &conn->requeue); 134532ae763eSMike Christie iscsi_conn_queue_work(conn); 1346843c0a8aSMike Christie } 13479c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_requeue_task); 1348843c0a8aSMike Christie 1349843c0a8aSMike Christie /** 13507996a778SMike Christie * iscsi_data_xmit - xmit any command into the scheduled connection 13517996a778SMike Christie * @conn: iscsi connection 13527996a778SMike Christie * 13537996a778SMike Christie * Notes: 13547996a778SMike Christie * The function can return -EAGAIN in which case the caller must 13557996a778SMike Christie * re-schedule it again later or recover. '0' return code means 13567996a778SMike Christie * successful xmit. 13577996a778SMike Christie **/ 13587996a778SMike Christie static int iscsi_data_xmit(struct iscsi_conn *conn) 13597996a778SMike Christie { 13603219e529SMike Christie int rc = 0; 13617996a778SMike Christie 136277a23c21SMike Christie spin_lock_bh(&conn->session->lock); 136370b31c15SMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) { 13641b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n"); 136577a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 13663219e529SMike Christie return -ENODATA; 13677996a778SMike Christie } 13687996a778SMike Christie 13699c19a7d0SMike Christie if (conn->task) { 13709c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 13713219e529SMike Christie if (rc) 137270b31c15SMike Christie goto done; 13737996a778SMike Christie } 137477a23c21SMike Christie 137577a23c21SMike Christie /* 137677a23c21SMike Christie * process mgmt pdus like nops before commands since we should 137777a23c21SMike Christie * only have one nop-out as a ping from us and targets should not 137877a23c21SMike Christie * overflow us with nop-ins 137977a23c21SMike Christie */ 138077a23c21SMike Christie check_mgmt: 1381843c0a8aSMike Christie while (!list_empty(&conn->mgmtqueue)) { 13829c19a7d0SMike Christie conn->task = list_entry(conn->mgmtqueue.next, 13839c19a7d0SMike Christie struct iscsi_task, running); 13843bbaaad9SMike Christie list_del_init(&conn->task->running); 13859c19a7d0SMike Christie if (iscsi_prep_mgmt_task(conn, conn->task)) { 13869c19a7d0SMike Christie __iscsi_put_task(conn->task); 13879c19a7d0SMike Christie conn->task = NULL; 1388b3a7ea8dSMike Christie continue; 1389b3a7ea8dSMike Christie } 13909c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 13913219e529SMike Christie if (rc) 139270b31c15SMike Christie goto done; 13937996a778SMike Christie } 13947996a778SMike Christie 1395843c0a8aSMike Christie /* process pending command queue */ 13963bbaaad9SMike Christie while (!list_empty(&conn->cmdqueue)) { 1397843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) 1398843c0a8aSMike Christie break; 1399843c0a8aSMike Christie 14003bbaaad9SMike Christie conn->task = list_entry(conn->cmdqueue.next, 14019c19a7d0SMike Christie struct iscsi_task, running); 14023bbaaad9SMike Christie list_del_init(&conn->task->running); 1403b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) { 1404b3cd5050SMike Christie fail_scsi_task(conn->task, DID_IMM_RETRY); 1405b3a7ea8dSMike Christie continue; 1406b3a7ea8dSMike Christie } 1407577577daSMike Christie rc = iscsi_prep_scsi_cmd_pdu(conn->task); 1408577577daSMike Christie if (rc) { 1409577577daSMike Christie if (rc == -ENOMEM) { 14103bbaaad9SMike Christie list_add_tail(&conn->task->running, 14113bbaaad9SMike Christie &conn->cmdqueue); 1412577577daSMike Christie conn->task = NULL; 141370b31c15SMike Christie goto done; 1414577577daSMike Christie } else 1415b3cd5050SMike Christie fail_scsi_task(conn->task, DID_ABORT); 1416004d6530SBoaz Harrosh continue; 1417004d6530SBoaz Harrosh } 14189c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 14193219e529SMike Christie if (rc) 142070b31c15SMike Christie goto done; 142177a23c21SMike Christie /* 14229c19a7d0SMike Christie * we could continuously get new task requests so 142377a23c21SMike Christie * we need to check the mgmt queue for nops that need to 142477a23c21SMike Christie * be sent to aviod starvation 142577a23c21SMike Christie */ 1426843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 1427843c0a8aSMike Christie goto check_mgmt; 1428843c0a8aSMike Christie } 1429843c0a8aSMike Christie 1430843c0a8aSMike Christie while (!list_empty(&conn->requeue)) { 1431843c0a8aSMike Christie if (conn->session->fast_abort && conn->tmf_state != TMF_INITIAL) 1432843c0a8aSMike Christie break; 1433843c0a8aSMike Christie 1434b3a7ea8dSMike Christie /* 1435b3a7ea8dSMike Christie * we always do fastlogout - conn stop code will clean up. 1436b3a7ea8dSMike Christie */ 1437b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 1438b3a7ea8dSMike Christie break; 1439b3a7ea8dSMike Christie 14409c19a7d0SMike Christie conn->task = list_entry(conn->requeue.next, 14419c19a7d0SMike Christie struct iscsi_task, running); 14423bbaaad9SMike Christie list_del_init(&conn->task->running); 14439c19a7d0SMike Christie conn->task->state = ISCSI_TASK_RUNNING; 14449c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 1445843c0a8aSMike Christie if (rc) 144670b31c15SMike Christie goto done; 1447843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 144877a23c21SMike Christie goto check_mgmt; 14497996a778SMike Christie } 145077a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 14513219e529SMike Christie return -ENODATA; 14527996a778SMike Christie 145370b31c15SMike Christie done: 145477a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 14553219e529SMike Christie return rc; 14567996a778SMike Christie } 14577996a778SMike Christie 1458c4028958SDavid Howells static void iscsi_xmitworker(struct work_struct *work) 14597996a778SMike Christie { 1460c4028958SDavid Howells struct iscsi_conn *conn = 1461c4028958SDavid Howells container_of(work, struct iscsi_conn, xmitwork); 14623219e529SMike Christie int rc; 14637996a778SMike Christie /* 14647996a778SMike Christie * serialize Xmit worker on a per-connection basis. 14657996a778SMike Christie */ 14663219e529SMike Christie do { 14673219e529SMike Christie rc = iscsi_data_xmit(conn); 14683219e529SMike Christie } while (rc >= 0 || rc == -EAGAIN); 14697996a778SMike Christie } 14707996a778SMike Christie 1471577577daSMike Christie static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn, 1472577577daSMike Christie struct scsi_cmnd *sc) 1473577577daSMike Christie { 1474577577daSMike Christie struct iscsi_task *task; 1475577577daSMike Christie 1476577577daSMike Christie if (!__kfifo_get(conn->session->cmdpool.queue, 1477577577daSMike Christie (void *) &task, sizeof(void *))) 1478577577daSMike Christie return NULL; 1479577577daSMike Christie 1480577577daSMike Christie sc->SCp.phase = conn->session->age; 1481577577daSMike Christie sc->SCp.ptr = (char *) task; 1482577577daSMike Christie 1483577577daSMike Christie atomic_set(&task->refcount, 1); 1484577577daSMike Christie task->state = ISCSI_TASK_PENDING; 1485577577daSMike Christie task->conn = conn; 1486577577daSMike Christie task->sc = sc; 1487d355e57dSMike Christie task->have_checked_conn = false; 1488d355e57dSMike Christie task->last_timeout = jiffies; 1489d355e57dSMike Christie task->last_xfer = jiffies; 1490577577daSMike Christie INIT_LIST_HEAD(&task->running); 1491577577daSMike Christie return task; 1492577577daSMike Christie } 1493577577daSMike Christie 14947996a778SMike Christie enum { 14957996a778SMike Christie FAILURE_BAD_HOST = 1, 14967996a778SMike Christie FAILURE_SESSION_FAILED, 14977996a778SMike Christie FAILURE_SESSION_FREED, 14987996a778SMike Christie FAILURE_WINDOW_CLOSED, 149960ecebf5SMike Christie FAILURE_OOM, 15007996a778SMike Christie FAILURE_SESSION_TERMINATE, 1501656cffc9SMike Christie FAILURE_SESSION_IN_RECOVERY, 15027996a778SMike Christie FAILURE_SESSION_RECOVERY_TIMEOUT, 1503b3a7ea8dSMike Christie FAILURE_SESSION_LOGGING_OUT, 15046eabafbeSMike Christie FAILURE_SESSION_NOT_READY, 15057996a778SMike Christie }; 15067996a778SMike Christie 15077996a778SMike Christie int iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *)) 15087996a778SMike Christie { 150975613521SMike Christie struct iscsi_cls_session *cls_session; 15107996a778SMike Christie struct Scsi_Host *host; 15111336aed1SMike Christie struct iscsi_host *ihost; 15127996a778SMike Christie int reason = 0; 15137996a778SMike Christie struct iscsi_session *session; 15147996a778SMike Christie struct iscsi_conn *conn; 15159c19a7d0SMike Christie struct iscsi_task *task = NULL; 15167996a778SMike Christie 15177996a778SMike Christie sc->scsi_done = done; 15187996a778SMike Christie sc->result = 0; 1519f47f2cf5SMike Christie sc->SCp.ptr = NULL; 15207996a778SMike Christie 15217996a778SMike Christie host = sc->device->host; 15221336aed1SMike Christie ihost = shost_priv(host); 15231040c99dSMike Christie spin_unlock(host->host_lock); 15247996a778SMike Christie 152575613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 152675613521SMike Christie session = cls_session->dd_data; 15277996a778SMike Christie spin_lock(&session->lock); 15287996a778SMike Christie 152975613521SMike Christie reason = iscsi_session_chkready(cls_session); 15306eabafbeSMike Christie if (reason) { 15316eabafbeSMike Christie sc->result = reason; 15326eabafbeSMike Christie goto fault; 15336eabafbeSMike Christie } 15346eabafbeSMike Christie 1535301e0f7eSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1536656cffc9SMike Christie /* 1537656cffc9SMike Christie * to handle the race between when we set the recovery state 1538656cffc9SMike Christie * and block the session we requeue here (commands could 1539656cffc9SMike Christie * be entering our queuecommand while a block is starting 1540656cffc9SMike Christie * up because the block code is not locked) 1541656cffc9SMike Christie */ 15429000bcd6SMike Christie switch (session->state) { 1543301e0f7eSMike Christie case ISCSI_STATE_FAILED: 15449000bcd6SMike Christie case ISCSI_STATE_IN_RECOVERY: 1545656cffc9SMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1546301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1547301e0f7eSMike Christie break; 15489000bcd6SMike Christie case ISCSI_STATE_LOGGING_OUT: 15499000bcd6SMike Christie reason = FAILURE_SESSION_LOGGING_OUT; 1550301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1551301e0f7eSMike Christie break; 1552b3a7ea8dSMike Christie case ISCSI_STATE_RECOVERY_FAILED: 1553656cffc9SMike Christie reason = FAILURE_SESSION_RECOVERY_TIMEOUT; 155456d7fcfaSMike Christie sc->result = DID_TRANSPORT_FAILFAST << 16; 1555b3a7ea8dSMike Christie break; 1556b3a7ea8dSMike Christie case ISCSI_STATE_TERMINATE: 1557656cffc9SMike Christie reason = FAILURE_SESSION_TERMINATE; 15586eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1559b3a7ea8dSMike Christie break; 1560b3a7ea8dSMike Christie default: 15617996a778SMike Christie reason = FAILURE_SESSION_FREED; 15626eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1563b3a7ea8dSMike Christie } 15647996a778SMike Christie goto fault; 15657996a778SMike Christie } 15667996a778SMike Christie 15677996a778SMike Christie conn = session->leadconn; 156898644047SMike Christie if (!conn) { 156998644047SMike Christie reason = FAILURE_SESSION_FREED; 15706eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 157198644047SMike Christie goto fault; 157298644047SMike Christie } 15737996a778SMike Christie 1574661134adSMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) { 1575661134adSMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1576661134adSMike Christie sc->result = DID_REQUEUE; 1577661134adSMike Christie goto fault; 1578661134adSMike Christie } 1579661134adSMike Christie 158077a23c21SMike Christie if (iscsi_check_cmdsn_window_closed(conn)) { 158177a23c21SMike Christie reason = FAILURE_WINDOW_CLOSED; 158277a23c21SMike Christie goto reject; 158377a23c21SMike Christie } 158477a23c21SMike Christie 1585577577daSMike Christie task = iscsi_alloc_task(conn, sc); 1586577577daSMike Christie if (!task) { 158760ecebf5SMike Christie reason = FAILURE_OOM; 158860ecebf5SMike Christie goto reject; 158960ecebf5SMike Christie } 15907996a778SMike Christie 15911336aed1SMike Christie if (!ihost->workq) { 1592577577daSMike Christie reason = iscsi_prep_scsi_cmd_pdu(task); 1593577577daSMike Christie if (reason) { 1594577577daSMike Christie if (reason == -ENOMEM) { 1595577577daSMike Christie reason = FAILURE_OOM; 1596577577daSMike Christie goto prepd_reject; 1597577577daSMike Christie } else { 1598052d0144SMike Christie sc->result = DID_ABORT << 16; 1599577577daSMike Christie goto prepd_fault; 1600577577daSMike Christie } 1601052d0144SMike Christie } 16029c19a7d0SMike Christie if (session->tt->xmit_task(task)) { 1603d3305f34SMike Christie session->cmdsn--; 1604052d0144SMike Christie reason = FAILURE_SESSION_NOT_READY; 1605577577daSMike Christie goto prepd_reject; 1606052d0144SMike Christie } 16073bbaaad9SMike Christie } else { 16083bbaaad9SMike Christie list_add_tail(&task->running, &conn->cmdqueue); 160932ae763eSMike Christie iscsi_conn_queue_work(conn); 16103bbaaad9SMike Christie } 1611052d0144SMike Christie 1612052d0144SMike Christie session->queued_cmdsn++; 1613052d0144SMike Christie spin_unlock(&session->lock); 16141040c99dSMike Christie spin_lock(host->host_lock); 16157996a778SMike Christie return 0; 16167996a778SMike Christie 1617577577daSMike Christie prepd_reject: 1618577577daSMike Christie sc->scsi_done = NULL; 1619b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 16207996a778SMike Christie reject: 16217996a778SMike Christie spin_unlock(&session->lock); 16221b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n", 16231b2c7af8SMike Christie sc->cmnd[0], reason); 16241040c99dSMike Christie spin_lock(host->host_lock); 1625d6d13ee1SMike Christie return SCSI_MLQUEUE_TARGET_BUSY; 16267996a778SMike Christie 1627577577daSMike Christie prepd_fault: 1628577577daSMike Christie sc->scsi_done = NULL; 1629b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 16307996a778SMike Christie fault: 16317996a778SMike Christie spin_unlock(&session->lock); 16321b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n", 16331b2c7af8SMike Christie sc->cmnd[0], reason); 1634c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 16351c138991SFUJITA Tomonori scsi_set_resid(sc, scsi_bufflen(sc)); 1636c07d4444SBoaz Harrosh else { 1637c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 1638c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 1639c07d4444SBoaz Harrosh } 1640052d0144SMike Christie done(sc); 16411040c99dSMike Christie spin_lock(host->host_lock); 16427996a778SMike Christie return 0; 16437996a778SMike Christie } 16447996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_queuecommand); 16457996a778SMike Christie 16467996a778SMike Christie int iscsi_change_queue_depth(struct scsi_device *sdev, int depth) 16477996a778SMike Christie { 16487996a778SMike Christie scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); 16497996a778SMike Christie return sdev->queue_depth; 16507996a778SMike Christie } 16517996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_change_queue_depth); 16527996a778SMike Christie 16536b5d6c44SMike Christie int iscsi_target_alloc(struct scsi_target *starget) 16546b5d6c44SMike Christie { 16556b5d6c44SMike Christie struct iscsi_cls_session *cls_session = starget_to_session(starget); 16566b5d6c44SMike Christie struct iscsi_session *session = cls_session->dd_data; 16576b5d6c44SMike Christie 16586b5d6c44SMike Christie starget->can_queue = session->scsi_cmds_max; 16596b5d6c44SMike Christie return 0; 16606b5d6c44SMike Christie } 16616b5d6c44SMike Christie EXPORT_SYMBOL_GPL(iscsi_target_alloc); 16626b5d6c44SMike Christie 16637996a778SMike Christie void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) 16647996a778SMike Christie { 166575613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 16667996a778SMike Christie 16677996a778SMike Christie spin_lock_bh(&session->lock); 16687996a778SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1669656cffc9SMike Christie session->state = ISCSI_STATE_RECOVERY_FAILED; 1670843c0a8aSMike Christie if (session->leadconn) 1671843c0a8aSMike Christie wake_up(&session->leadconn->ehwait); 16727996a778SMike Christie } 16737996a778SMike Christie spin_unlock_bh(&session->lock); 16747996a778SMike Christie } 16757996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout); 16767996a778SMike Christie 16778e124525SMike Christie int iscsi_eh_target_reset(struct scsi_cmnd *sc) 16787996a778SMike Christie { 167975613521SMike Christie struct iscsi_cls_session *cls_session; 168075613521SMike Christie struct iscsi_session *session; 168175613521SMike Christie struct iscsi_conn *conn; 168275613521SMike Christie 168375613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 168475613521SMike Christie session = cls_session->dd_data; 168575613521SMike Christie conn = session->leadconn; 16867996a778SMike Christie 1687bc436b27SMike Christie mutex_lock(&session->eh_mutex); 16887996a778SMike Christie spin_lock_bh(&session->lock); 16897996a778SMike Christie if (session->state == ISCSI_STATE_TERMINATE) { 16907996a778SMike Christie failed: 1691bd2199d4SErez Zilber ISCSI_DBG_EH(session, 1692bd2199d4SErez Zilber "failing target reset: Could not log back into " 1693bd2199d4SErez Zilber "target [age %d]\n", 16941b2c7af8SMike Christie session->age); 16957996a778SMike Christie spin_unlock_bh(&session->lock); 1696bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 16977996a778SMike Christie return FAILED; 16987996a778SMike Christie } 16997996a778SMike Christie 17007996a778SMike Christie spin_unlock_bh(&session->lock); 1701bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 17027996a778SMike Christie /* 17037996a778SMike Christie * we drop the lock here but the leadconn cannot be destoyed while 17047996a778SMike Christie * we are in the scsi eh 17057996a778SMike Christie */ 17067996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 17077996a778SMike Christie 1708bd2199d4SErez Zilber ISCSI_DBG_EH(session, "wait for relogin\n"); 17097996a778SMike Christie wait_event_interruptible(conn->ehwait, 17107996a778SMike Christie session->state == ISCSI_STATE_TERMINATE || 17117996a778SMike Christie session->state == ISCSI_STATE_LOGGED_IN || 1712656cffc9SMike Christie session->state == ISCSI_STATE_RECOVERY_FAILED); 17137996a778SMike Christie if (signal_pending(current)) 17147996a778SMike Christie flush_signals(current); 17157996a778SMike Christie 1716bc436b27SMike Christie mutex_lock(&session->eh_mutex); 17177996a778SMike Christie spin_lock_bh(&session->lock); 1718bd2199d4SErez Zilber if (session->state == ISCSI_STATE_LOGGED_IN) { 1719bd2199d4SErez Zilber ISCSI_DBG_EH(session, 17208e124525SMike Christie "target reset succeeded\n"); 1721bd2199d4SErez Zilber } else 17227996a778SMike Christie goto failed; 17237996a778SMike Christie spin_unlock_bh(&session->lock); 1724bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 17257996a778SMike Christie return SUCCESS; 17267996a778SMike Christie } 17278e124525SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_target_reset); 17287996a778SMike Christie 1729843c0a8aSMike Christie static void iscsi_tmf_timedout(unsigned long data) 17307996a778SMike Christie { 1731843c0a8aSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 17327996a778SMike Christie struct iscsi_session *session = conn->session; 17337996a778SMike Christie 17347996a778SMike Christie spin_lock(&session->lock); 1735843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) { 1736843c0a8aSMike Christie conn->tmf_state = TMF_TIMEDOUT; 1737bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf timedout\n"); 17387996a778SMike Christie /* unblock eh_abort() */ 17397996a778SMike Christie wake_up(&conn->ehwait); 17407996a778SMike Christie } 17417996a778SMike Christie spin_unlock(&session->lock); 17427996a778SMike Christie } 17437996a778SMike Christie 17449c19a7d0SMike Christie static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, 1745f6d5180cSMike Christie struct iscsi_tm *hdr, int age, 1746f6d5180cSMike Christie int timeout) 17477996a778SMike Christie { 17487996a778SMike Christie struct iscsi_session *session = conn->session; 17499c19a7d0SMike Christie struct iscsi_task *task; 17507996a778SMike Christie 17519c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr, 17527996a778SMike Christie NULL, 0); 17539c19a7d0SMike Christie if (!task) { 17546724add1SMike Christie spin_unlock_bh(&session->lock); 17557996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1756843c0a8aSMike Christie spin_lock_bh(&session->lock); 1757bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf exec failure\n"); 175877a23c21SMike Christie return -EPERM; 17597996a778SMike Christie } 17607996a778SMike Christie conn->tmfcmd_pdus_cnt++; 1761f6d5180cSMike Christie conn->tmf_timer.expires = timeout * HZ + jiffies; 1762843c0a8aSMike Christie conn->tmf_timer.function = iscsi_tmf_timedout; 1763843c0a8aSMike Christie conn->tmf_timer.data = (unsigned long)conn; 1764843c0a8aSMike Christie add_timer(&conn->tmf_timer); 1765bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf set timeout\n"); 1766843c0a8aSMike Christie 17677996a778SMike Christie spin_unlock_bh(&session->lock); 17686724add1SMike Christie mutex_unlock(&session->eh_mutex); 17697996a778SMike Christie 17707996a778SMike Christie /* 17717996a778SMike Christie * block eh thread until: 17727996a778SMike Christie * 1773843c0a8aSMike Christie * 1) tmf response 1774843c0a8aSMike Christie * 2) tmf timeout 17757996a778SMike Christie * 3) session is terminated or restarted or userspace has 17767996a778SMike Christie * given up on recovery 17777996a778SMike Christie */ 1778843c0a8aSMike Christie wait_event_interruptible(conn->ehwait, age != session->age || 17797996a778SMike Christie session->state != ISCSI_STATE_LOGGED_IN || 1780843c0a8aSMike Christie conn->tmf_state != TMF_QUEUED); 17817996a778SMike Christie if (signal_pending(current)) 17827996a778SMike Christie flush_signals(current); 1783843c0a8aSMike Christie del_timer_sync(&conn->tmf_timer); 1784843c0a8aSMike Christie 17856724add1SMike Christie mutex_lock(&session->eh_mutex); 178677a23c21SMike Christie spin_lock_bh(&session->lock); 17879c19a7d0SMike Christie /* if the session drops it will clean up the task */ 1788843c0a8aSMike Christie if (age != session->age || 1789843c0a8aSMike Christie session->state != ISCSI_STATE_LOGGED_IN) 1790843c0a8aSMike Christie return -ENOTCONN; 17917996a778SMike Christie return 0; 17927996a778SMike Christie } 17937996a778SMike Christie 17947996a778SMike Christie /* 1795843c0a8aSMike Christie * Fail commands. session lock held and recv side suspended and xmit 1796843c0a8aSMike Christie * thread flushed 1797843c0a8aSMike Christie */ 17983bbaaad9SMike Christie static void fail_scsi_tasks(struct iscsi_conn *conn, unsigned lun, 17996eabafbeSMike Christie int error) 1800843c0a8aSMike Christie { 18013bbaaad9SMike Christie struct iscsi_task *task; 18023bbaaad9SMike Christie int i; 1803843c0a8aSMike Christie 18043bbaaad9SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 18053bbaaad9SMike Christie task = conn->session->cmds[i]; 18063bbaaad9SMike Christie if (!task->sc || task->state == ISCSI_TASK_FREE) 18073bbaaad9SMike Christie continue; 1808843c0a8aSMike Christie 18093bbaaad9SMike Christie if (lun != -1 && lun != task->sc->device->lun) 18103bbaaad9SMike Christie continue; 18113bbaaad9SMike Christie 18121b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, 18133bbaaad9SMike Christie "failing sc %p itt 0x%x state %d\n", 18143bbaaad9SMike Christie task->sc, task->itt, task->state); 1815b3cd5050SMike Christie fail_scsi_task(task, error); 1816843c0a8aSMike Christie } 1817843c0a8aSMike Christie } 1818843c0a8aSMike Christie 1819661134adSMike Christie /** 1820661134adSMike Christie * iscsi_suspend_queue - suspend iscsi_queuecommand 1821661134adSMike Christie * @conn: iscsi conn to stop queueing IO on 1822661134adSMike Christie * 1823661134adSMike Christie * This grabs the session lock to make sure no one is in 1824661134adSMike Christie * xmit_task/queuecommand, and then sets suspend to prevent 1825661134adSMike Christie * new commands from being queued. This only needs to be called 1826661134adSMike Christie * by offload drivers that need to sync a path like ep disconnect 1827661134adSMike Christie * with the iscsi_queuecommand/xmit_task. To start IO again libiscsi 1828661134adSMike Christie * will call iscsi_start_tx and iscsi_unblock_session when in FFP. 1829661134adSMike Christie */ 1830661134adSMike Christie void iscsi_suspend_queue(struct iscsi_conn *conn) 1831661134adSMike Christie { 1832661134adSMike Christie spin_lock_bh(&conn->session->lock); 1833661134adSMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1834661134adSMike Christie spin_unlock_bh(&conn->session->lock); 1835661134adSMike Christie } 1836661134adSMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_queue); 1837661134adSMike Christie 1838661134adSMike Christie /** 1839661134adSMike Christie * iscsi_suspend_tx - suspend iscsi_data_xmit 1840661134adSMike Christie * @conn: iscsi conn tp stop processing IO on. 1841661134adSMike Christie * 1842661134adSMike Christie * This function sets the suspend bit to prevent iscsi_data_xmit 1843661134adSMike Christie * from sending new IO, and if work is queued on the xmit thread 1844661134adSMike Christie * it will wait for it to be completed. 1845661134adSMike Christie */ 1846b40977d9SMike Christie void iscsi_suspend_tx(struct iscsi_conn *conn) 18476724add1SMike Christie { 184832ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 184932ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 185032ae763eSMike Christie 18516724add1SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 18521336aed1SMike Christie if (ihost->workq) 185332ae763eSMike Christie flush_workqueue(ihost->workq); 18546724add1SMike Christie } 1855b40977d9SMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_tx); 18566724add1SMike Christie 18576724add1SMike Christie static void iscsi_start_tx(struct iscsi_conn *conn) 18586724add1SMike Christie { 18596724add1SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 186032ae763eSMike Christie iscsi_conn_queue_work(conn); 18616724add1SMike Christie } 18626724add1SMike Christie 18634c48a829SMike Christie /* 18644c48a829SMike Christie * We want to make sure a ping is in flight. It has timed out. 18654c48a829SMike Christie * And we are not busy processing a pdu that is making 18664c48a829SMike Christie * progress but got started before the ping and is taking a while 18674c48a829SMike Christie * to complete so the ping is just stuck behind it in a queue. 18684c48a829SMike Christie */ 18694c48a829SMike Christie static int iscsi_has_ping_timed_out(struct iscsi_conn *conn) 18704c48a829SMike Christie { 18714c48a829SMike Christie if (conn->ping_task && 18724c48a829SMike Christie time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) + 18734c48a829SMike Christie (conn->ping_timeout * HZ), jiffies)) 18744c48a829SMike Christie return 1; 18754c48a829SMike Christie else 18764c48a829SMike Christie return 0; 18774c48a829SMike Christie } 18784c48a829SMike Christie 1879d355e57dSMike Christie static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc) 1880f6d5180cSMike Christie { 1881d355e57dSMike Christie enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED; 1882d355e57dSMike Christie struct iscsi_task *task = NULL; 1883f6d5180cSMike Christie struct iscsi_cls_session *cls_session; 1884f6d5180cSMike Christie struct iscsi_session *session; 1885f6d5180cSMike Christie struct iscsi_conn *conn; 1886f6d5180cSMike Christie 1887d355e57dSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 188875613521SMike Christie session = cls_session->dd_data; 1889f6d5180cSMike Christie 1890bd2199d4SErez Zilber ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc); 1891f6d5180cSMike Christie 1892f6d5180cSMike Christie spin_lock(&session->lock); 1893f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1894f6d5180cSMike Christie /* 1895f6d5180cSMike Christie * We are probably in the middle of iscsi recovery so let 1896f6d5180cSMike Christie * that complete and handle the error. 1897f6d5180cSMike Christie */ 1898242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1899f6d5180cSMike Christie goto done; 1900f6d5180cSMike Christie } 1901f6d5180cSMike Christie 1902f6d5180cSMike Christie conn = session->leadconn; 1903f6d5180cSMike Christie if (!conn) { 1904f6d5180cSMike Christie /* In the middle of shuting down */ 1905242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1906f6d5180cSMike Christie goto done; 1907f6d5180cSMike Christie } 1908f6d5180cSMike Christie 1909d355e57dSMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 1910d355e57dSMike Christie if (!task) 1911d355e57dSMike Christie goto done; 1912d355e57dSMike Christie /* 1913d355e57dSMike Christie * If we have sent (at least queued to the network layer) a pdu or 1914d355e57dSMike Christie * recvd one for the task since the last timeout ask for 1915d355e57dSMike Christie * more time. If on the next timeout we have not made progress 1916d355e57dSMike Christie * we can check if it is the task or connection when we send the 1917d355e57dSMike Christie * nop as a ping. 1918d355e57dSMike Christie */ 1919d355e57dSMike Christie if (time_after_eq(task->last_xfer, task->last_timeout)) { 1920bd2199d4SErez Zilber ISCSI_DBG_EH(session, "Command making progress. Asking " 1921d355e57dSMike Christie "scsi-ml for more time to complete. " 1922d355e57dSMike Christie "Last data recv at %lu. Last timeout was at " 1923d355e57dSMike Christie "%lu\n.", task->last_xfer, task->last_timeout); 1924d355e57dSMike Christie task->have_checked_conn = false; 1925d355e57dSMike Christie rc = BLK_EH_RESET_TIMER; 1926d355e57dSMike Christie goto done; 1927d355e57dSMike Christie } 1928d355e57dSMike Christie 1929f6d5180cSMike Christie if (!conn->recv_timeout && !conn->ping_timeout) 1930f6d5180cSMike Christie goto done; 1931f6d5180cSMike Christie /* 1932f6d5180cSMike Christie * if the ping timedout then we are in the middle of cleaning up 1933f6d5180cSMike Christie * and can let the iscsi eh handle it 1934f6d5180cSMike Christie */ 19354c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 1936242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 19374c48a829SMike Christie goto done; 19384c48a829SMike Christie } 1939d355e57dSMike Christie 1940d355e57dSMike Christie /* Assumes nop timeout is shorter than scsi cmd timeout */ 1941d355e57dSMike Christie if (task->have_checked_conn) 1942d355e57dSMike Christie goto done; 1943d355e57dSMike Christie 1944f6d5180cSMike Christie /* 1945d355e57dSMike Christie * Checking the transport already or nop from a cmd timeout still 1946d355e57dSMike Christie * running 1947f6d5180cSMike Christie */ 1948d355e57dSMike Christie if (conn->ping_task) { 1949d355e57dSMike Christie task->have_checked_conn = true; 1950242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 19514c48a829SMike Christie goto done; 19524c48a829SMike Christie } 19534c48a829SMike Christie 1954d355e57dSMike Christie /* Make sure there is a transport check done */ 1955d355e57dSMike Christie iscsi_send_nopout(conn, NULL); 1956d355e57dSMike Christie task->have_checked_conn = true; 1957242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1958d355e57dSMike Christie 1959f6d5180cSMike Christie done: 1960d355e57dSMike Christie if (task) 1961d355e57dSMike Christie task->last_timeout = jiffies; 1962f6d5180cSMike Christie spin_unlock(&session->lock); 1963bd2199d4SErez Zilber ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ? 1964242f9dcbSJens Axboe "timer reset" : "nh"); 1965f6d5180cSMike Christie return rc; 1966f6d5180cSMike Christie } 1967f6d5180cSMike Christie 1968f6d5180cSMike Christie static void iscsi_check_transport_timeouts(unsigned long data) 1969f6d5180cSMike Christie { 1970f6d5180cSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 1971f6d5180cSMike Christie struct iscsi_session *session = conn->session; 19724cf10435SMike Christie unsigned long recv_timeout, next_timeout = 0, last_recv; 1973f6d5180cSMike Christie 1974f6d5180cSMike Christie spin_lock(&session->lock); 1975f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 1976f6d5180cSMike Christie goto done; 1977f6d5180cSMike Christie 19784cf10435SMike Christie recv_timeout = conn->recv_timeout; 19794cf10435SMike Christie if (!recv_timeout) 1980f6d5180cSMike Christie goto done; 1981f6d5180cSMike Christie 19824cf10435SMike Christie recv_timeout *= HZ; 1983f6d5180cSMike Christie last_recv = conn->last_recv; 19844c48a829SMike Christie 19854c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 1986322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs " 19874c48a829SMike Christie "expired, recv timeout %d, last rx %lu, " 19884c48a829SMike Christie "last ping %lu, now %lu\n", 19894c48a829SMike Christie conn->ping_timeout, conn->recv_timeout, 19904c48a829SMike Christie last_recv, conn->last_ping, jiffies); 1991f6d5180cSMike Christie spin_unlock(&session->lock); 1992f6d5180cSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1993f6d5180cSMike Christie return; 1994f6d5180cSMike Christie } 1995f6d5180cSMike Christie 19964cf10435SMike Christie if (time_before_eq(last_recv + recv_timeout, jiffies)) { 1997f6d5180cSMike Christie /* send a ping to try to provoke some traffic */ 19981b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Sending nopout as ping\n"); 1999f6d5180cSMike Christie iscsi_send_nopout(conn, NULL); 20004cf10435SMike Christie next_timeout = conn->last_ping + (conn->ping_timeout * HZ); 2001ad294e9cSMike Christie } else 20024cf10435SMike Christie next_timeout = last_recv + recv_timeout; 2003f6d5180cSMike Christie 20041b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout); 2005f6d5180cSMike Christie mod_timer(&conn->transport_timer, next_timeout); 2006f6d5180cSMike Christie done: 2007f6d5180cSMike Christie spin_unlock(&session->lock); 2008f6d5180cSMike Christie } 2009f6d5180cSMike Christie 20109c19a7d0SMike Christie static void iscsi_prep_abort_task_pdu(struct iscsi_task *task, 2011843c0a8aSMike Christie struct iscsi_tm *hdr) 2012843c0a8aSMike Christie { 2013843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2014843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2015843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK; 2016843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 2017577577daSMike Christie memcpy(hdr->lun, task->lun, sizeof(hdr->lun)); 2018577577daSMike Christie hdr->rtt = task->hdr_itt; 2019577577daSMike Christie hdr->refcmdsn = task->cmdsn; 2020843c0a8aSMike Christie } 2021843c0a8aSMike Christie 20227996a778SMike Christie int iscsi_eh_abort(struct scsi_cmnd *sc) 20237996a778SMike Christie { 202475613521SMike Christie struct iscsi_cls_session *cls_session; 202575613521SMike Christie struct iscsi_session *session; 2026f47f2cf5SMike Christie struct iscsi_conn *conn; 20279c19a7d0SMike Christie struct iscsi_task *task; 2028843c0a8aSMike Christie struct iscsi_tm *hdr; 2029843c0a8aSMike Christie int rc, age; 20307996a778SMike Christie 203175613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 203275613521SMike Christie session = cls_session->dd_data; 203375613521SMike Christie 2034bd2199d4SErez Zilber ISCSI_DBG_EH(session, "aborting sc %p\n", sc); 20354421c9ebSMike Christie 20366724add1SMike Christie mutex_lock(&session->eh_mutex); 20376724add1SMike Christie spin_lock_bh(&session->lock); 2038f47f2cf5SMike Christie /* 2039f47f2cf5SMike Christie * if session was ISCSI_STATE_IN_RECOVERY then we may not have 2040f47f2cf5SMike Christie * got the command. 2041f47f2cf5SMike Christie */ 2042f47f2cf5SMike Christie if (!sc->SCp.ptr) { 2043bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc never reached iscsi layer or " 20441b2c7af8SMike Christie "it completed.\n"); 20456724add1SMike Christie spin_unlock_bh(&session->lock); 20466724add1SMike Christie mutex_unlock(&session->eh_mutex); 2047f47f2cf5SMike Christie return SUCCESS; 2048f47f2cf5SMike Christie } 2049f47f2cf5SMike Christie 20507996a778SMike Christie /* 20517996a778SMike Christie * If we are not logged in or we have started a new session 20527996a778SMike Christie * then let the host reset code handle this 20537996a778SMike Christie */ 2054843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN || 2055843c0a8aSMike Christie sc->SCp.phase != session->age) { 2056843c0a8aSMike Christie spin_unlock_bh(&session->lock); 2057843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2058bd2199d4SErez Zilber ISCSI_DBG_EH(session, "failing abort due to dropped " 20594421c9ebSMike Christie "session.\n"); 2060843c0a8aSMike Christie return FAILED; 2061843c0a8aSMike Christie } 2062843c0a8aSMike Christie 2063843c0a8aSMike Christie conn = session->leadconn; 2064843c0a8aSMike Christie conn->eh_abort_cnt++; 2065843c0a8aSMike Christie age = session->age; 2066843c0a8aSMike Christie 20679c19a7d0SMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 2068bd2199d4SErez Zilber ISCSI_DBG_EH(session, "aborting [sc %p itt 0x%x]\n", 20691b2c7af8SMike Christie sc, task->itt); 20707996a778SMike Christie 20719c19a7d0SMike Christie /* task completed before time out */ 20729c19a7d0SMike Christie if (!task->sc) { 2073bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in progress\n"); 207477a23c21SMike Christie goto success; 20757ea8b828SMike Christie } 20767996a778SMike Christie 20779c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) { 2078b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 207977a23c21SMike Christie goto success; 208077a23c21SMike Christie } 20817996a778SMike Christie 2082843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2083843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 20847996a778SMike Christie goto failed; 2085843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 20867996a778SMike Christie 2087843c0a8aSMike Christie hdr = &conn->tmhdr; 20889c19a7d0SMike Christie iscsi_prep_abort_task_pdu(task, hdr); 2089843c0a8aSMike Christie 20909c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) { 2091843c0a8aSMike Christie rc = FAILED; 2092843c0a8aSMike Christie goto failed; 2093843c0a8aSMike Christie } 2094843c0a8aSMike Christie 2095843c0a8aSMike Christie switch (conn->tmf_state) { 2096843c0a8aSMike Christie case TMF_SUCCESS: 20977ea8b828SMike Christie spin_unlock_bh(&session->lock); 2098913e5bf4SMike Christie /* 2099913e5bf4SMike Christie * stop tx side incase the target had sent a abort rsp but 2100913e5bf4SMike Christie * the initiator was still writing out data. 2101913e5bf4SMike Christie */ 21026724add1SMike Christie iscsi_suspend_tx(conn); 21037996a778SMike Christie /* 2104913e5bf4SMike Christie * we do not stop the recv side because targets have been 2105913e5bf4SMike Christie * good and have never sent us a successful tmf response 2106913e5bf4SMike Christie * then sent more data for the cmd. 21077996a778SMike Christie */ 21086187c242SMike Christie spin_lock_bh(&session->lock); 2109b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 2110843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 21116187c242SMike Christie spin_unlock_bh(&session->lock); 21126724add1SMike Christie iscsi_start_tx(conn); 211377a23c21SMike Christie goto success_unlocked; 2114843c0a8aSMike Christie case TMF_TIMEDOUT: 2115843c0a8aSMike Christie spin_unlock_bh(&session->lock); 2116843c0a8aSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 2117843c0a8aSMike Christie goto failed_unlocked; 2118843c0a8aSMike Christie case TMF_NOT_FOUND: 2119843c0a8aSMike Christie if (!sc->SCp.ptr) { 2120843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 21219c19a7d0SMike Christie /* task completed before tmf abort response */ 2122bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in " 2123bd2199d4SErez Zilber "progress\n"); 212477a23c21SMike Christie goto success; 212577a23c21SMike Christie } 212677a23c21SMike Christie /* fall through */ 212777a23c21SMike Christie default: 2128843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2129843c0a8aSMike Christie goto failed; 213077a23c21SMike Christie } 21317996a778SMike Christie 213277a23c21SMike Christie success: 213377a23c21SMike Christie spin_unlock_bh(&session->lock); 213477a23c21SMike Christie success_unlocked: 2135bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n", 21361b2c7af8SMike Christie sc, task->itt); 21376724add1SMike Christie mutex_unlock(&session->eh_mutex); 21387996a778SMike Christie return SUCCESS; 21397996a778SMike Christie 21407996a778SMike Christie failed: 21417996a778SMike Christie spin_unlock_bh(&session->lock); 214277a23c21SMike Christie failed_unlocked: 2143bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc, 21449c19a7d0SMike Christie task ? task->itt : 0); 21456724add1SMike Christie mutex_unlock(&session->eh_mutex); 21467996a778SMike Christie return FAILED; 21477996a778SMike Christie } 21487996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_abort); 21497996a778SMike Christie 2150843c0a8aSMike Christie static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 2151843c0a8aSMike Christie { 2152843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2153843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2154843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK; 2155843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 2156843c0a8aSMike Christie int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun); 2157f6d5180cSMike Christie hdr->rtt = RESERVED_ITT; 2158843c0a8aSMike Christie } 2159843c0a8aSMike Christie 2160843c0a8aSMike Christie int iscsi_eh_device_reset(struct scsi_cmnd *sc) 2161843c0a8aSMike Christie { 216275613521SMike Christie struct iscsi_cls_session *cls_session; 216375613521SMike Christie struct iscsi_session *session; 2164843c0a8aSMike Christie struct iscsi_conn *conn; 2165843c0a8aSMike Christie struct iscsi_tm *hdr; 2166843c0a8aSMike Christie int rc = FAILED; 2167843c0a8aSMike Christie 216875613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 216975613521SMike Christie session = cls_session->dd_data; 217075613521SMike Christie 2171bd2199d4SErez Zilber ISCSI_DBG_EH(session, "LU Reset [sc %p lun %u]\n", sc, sc->device->lun); 2172843c0a8aSMike Christie 2173843c0a8aSMike Christie mutex_lock(&session->eh_mutex); 2174843c0a8aSMike Christie spin_lock_bh(&session->lock); 2175843c0a8aSMike Christie /* 2176843c0a8aSMike Christie * Just check if we are not logged in. We cannot check for 2177843c0a8aSMike Christie * the phase because the reset could come from a ioctl. 2178843c0a8aSMike Christie */ 2179843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 2180843c0a8aSMike Christie goto unlock; 2181843c0a8aSMike Christie conn = session->leadconn; 2182843c0a8aSMike Christie 2183843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2184843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 2185843c0a8aSMike Christie goto unlock; 2186843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 2187843c0a8aSMike Christie 2188843c0a8aSMike Christie hdr = &conn->tmhdr; 2189843c0a8aSMike Christie iscsi_prep_lun_reset_pdu(sc, hdr); 2190843c0a8aSMike Christie 21919c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 2192f6d5180cSMike Christie session->lu_reset_timeout)) { 2193843c0a8aSMike Christie rc = FAILED; 2194843c0a8aSMike Christie goto unlock; 2195843c0a8aSMike Christie } 2196843c0a8aSMike Christie 2197843c0a8aSMike Christie switch (conn->tmf_state) { 2198843c0a8aSMike Christie case TMF_SUCCESS: 2199843c0a8aSMike Christie break; 2200843c0a8aSMike Christie case TMF_TIMEDOUT: 2201843c0a8aSMike Christie spin_unlock_bh(&session->lock); 2202843c0a8aSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 2203843c0a8aSMike Christie goto done; 2204843c0a8aSMike Christie default: 2205843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2206843c0a8aSMike Christie goto unlock; 2207843c0a8aSMike Christie } 2208843c0a8aSMike Christie 2209843c0a8aSMike Christie rc = SUCCESS; 2210843c0a8aSMike Christie spin_unlock_bh(&session->lock); 2211843c0a8aSMike Christie 2212843c0a8aSMike Christie iscsi_suspend_tx(conn); 2213913e5bf4SMike Christie 2214a3439148SMike Christie spin_lock_bh(&session->lock); 22153bbaaad9SMike Christie fail_scsi_tasks(conn, sc->device->lun, DID_ERROR); 2216843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2217a3439148SMike Christie spin_unlock_bh(&session->lock); 2218843c0a8aSMike Christie 2219843c0a8aSMike Christie iscsi_start_tx(conn); 2220843c0a8aSMike Christie goto done; 2221843c0a8aSMike Christie 2222843c0a8aSMike Christie unlock: 2223843c0a8aSMike Christie spin_unlock_bh(&session->lock); 2224843c0a8aSMike Christie done: 2225bd2199d4SErez Zilber ISCSI_DBG_EH(session, "dev reset result = %s\n", 2226843c0a8aSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 2227843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2228843c0a8aSMike Christie return rc; 2229843c0a8aSMike Christie } 2230843c0a8aSMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_device_reset); 2231843c0a8aSMike Christie 22326320377fSOlaf Kirch /* 22336320377fSOlaf Kirch * Pre-allocate a pool of @max items of @item_size. By default, the pool 22346320377fSOlaf Kirch * should be accessed via kfifo_{get,put} on q->queue. 22356320377fSOlaf Kirch * Optionally, the caller can obtain the array of object pointers 22366320377fSOlaf Kirch * by passing in a non-NULL @items pointer 22376320377fSOlaf Kirch */ 22387996a778SMike Christie int 22396320377fSOlaf Kirch iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size) 22407996a778SMike Christie { 22416320377fSOlaf Kirch int i, num_arrays = 1; 22427996a778SMike Christie 22436320377fSOlaf Kirch memset(q, 0, sizeof(*q)); 22447996a778SMike Christie 22457996a778SMike Christie q->max = max; 22466320377fSOlaf Kirch 22476320377fSOlaf Kirch /* If the user passed an items pointer, he wants a copy of 22486320377fSOlaf Kirch * the array. */ 22496320377fSOlaf Kirch if (items) 22506320377fSOlaf Kirch num_arrays++; 22516320377fSOlaf Kirch q->pool = kzalloc(num_arrays * max * sizeof(void*), GFP_KERNEL); 22526320377fSOlaf Kirch if (q->pool == NULL) 2253f474a37bSJean Delvare return -ENOMEM; 22547996a778SMike Christie 22557996a778SMike Christie q->queue = kfifo_init((void*)q->pool, max * sizeof(void*), 22567996a778SMike Christie GFP_KERNEL, NULL); 2257fd6e1c14SJean Delvare if (IS_ERR(q->queue)) { 2258fd6e1c14SJean Delvare q->queue = NULL; 22596320377fSOlaf Kirch goto enomem; 2260fd6e1c14SJean Delvare } 22617996a778SMike Christie 22627996a778SMike Christie for (i = 0; i < max; i++) { 22636320377fSOlaf Kirch q->pool[i] = kzalloc(item_size, GFP_KERNEL); 22647996a778SMike Christie if (q->pool[i] == NULL) { 22656320377fSOlaf Kirch q->max = i; 22666320377fSOlaf Kirch goto enomem; 22677996a778SMike Christie } 22687996a778SMike Christie __kfifo_put(q->queue, (void*)&q->pool[i], sizeof(void*)); 22697996a778SMike Christie } 22706320377fSOlaf Kirch 22716320377fSOlaf Kirch if (items) { 22726320377fSOlaf Kirch *items = q->pool + max; 22736320377fSOlaf Kirch memcpy(*items, q->pool, max * sizeof(void *)); 22746320377fSOlaf Kirch } 22756320377fSOlaf Kirch 22767996a778SMike Christie return 0; 22776320377fSOlaf Kirch 22786320377fSOlaf Kirch enomem: 22796320377fSOlaf Kirch iscsi_pool_free(q); 22806320377fSOlaf Kirch return -ENOMEM; 22817996a778SMike Christie } 22827996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_init); 22837996a778SMike Christie 22846320377fSOlaf Kirch void iscsi_pool_free(struct iscsi_pool *q) 22857996a778SMike Christie { 22867996a778SMike Christie int i; 22877996a778SMike Christie 22887996a778SMike Christie for (i = 0; i < q->max; i++) 22896320377fSOlaf Kirch kfree(q->pool[i]); 22907996a778SMike Christie kfree(q->pool); 22912f5899a3SMike Christie kfree(q->queue); 22927996a778SMike Christie } 22937996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_free); 22947996a778SMike Christie 2295a4804cd6SMike Christie /** 2296a4804cd6SMike Christie * iscsi_host_add - add host to system 2297a4804cd6SMike Christie * @shost: scsi host 2298a4804cd6SMike Christie * @pdev: parent device 2299a4804cd6SMike Christie * 2300a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers 2301a4804cd6SMike Christie * to add a host to the system. 2302a4804cd6SMike Christie */ 2303a4804cd6SMike Christie int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev) 23047996a778SMike Christie { 23058e9a20ceSMike Christie if (!shost->can_queue) 23068e9a20ceSMike Christie shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX; 23078e9a20ceSMike Christie 23084d108350SMike Christie if (!shost->cmd_per_lun) 23094d108350SMike Christie shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN; 23104d108350SMike Christie 2311308cec14SMike Christie if (!shost->transportt->eh_timed_out) 2312308cec14SMike Christie shost->transportt->eh_timed_out = iscsi_eh_cmd_timed_out; 2313a4804cd6SMike Christie return scsi_add_host(shost, pdev); 2314a4804cd6SMike Christie } 2315a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_add); 2316a4804cd6SMike Christie 2317a4804cd6SMike Christie /** 2318a4804cd6SMike Christie * iscsi_host_alloc - allocate a host and driver data 2319a4804cd6SMike Christie * @sht: scsi host template 2320a4804cd6SMike Christie * @dd_data_size: driver host data size 232132ae763eSMike Christie * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue 2322a4804cd6SMike Christie * 2323a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers. 2324a4804cd6SMike Christie * To access the driver specific memory use the iscsi_host_priv() macro. 2325a4804cd6SMike Christie */ 2326a4804cd6SMike Christie struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht, 23274d108350SMike Christie int dd_data_size, bool xmit_can_sleep) 2328a4804cd6SMike Christie { 2329a4804cd6SMike Christie struct Scsi_Host *shost; 2330e5bd7b54SMike Christie struct iscsi_host *ihost; 2331a4804cd6SMike Christie 2332a4804cd6SMike Christie shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size); 2333a4804cd6SMike Christie if (!shost) 2334a4804cd6SMike Christie return NULL; 2335e5bd7b54SMike Christie ihost = shost_priv(shost); 233632ae763eSMike Christie 233732ae763eSMike Christie if (xmit_can_sleep) { 233832ae763eSMike Christie snprintf(ihost->workq_name, sizeof(ihost->workq_name), 233932ae763eSMike Christie "iscsi_q_%d", shost->host_no); 234032ae763eSMike Christie ihost->workq = create_singlethread_workqueue(ihost->workq_name); 234132ae763eSMike Christie if (!ihost->workq) 234232ae763eSMike Christie goto free_host; 234332ae763eSMike Christie } 234432ae763eSMike Christie 2345e5bd7b54SMike Christie spin_lock_init(&ihost->lock); 2346e5bd7b54SMike Christie ihost->state = ISCSI_HOST_SETUP; 2347e5bd7b54SMike Christie ihost->num_sessions = 0; 2348e5bd7b54SMike Christie init_waitqueue_head(&ihost->session_removal_wq); 2349a4804cd6SMike Christie return shost; 235032ae763eSMike Christie 235132ae763eSMike Christie free_host: 235232ae763eSMike Christie scsi_host_put(shost); 235332ae763eSMike Christie return NULL; 235475613521SMike Christie } 2355a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_alloc); 235675613521SMike Christie 2357e5bd7b54SMike Christie static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session) 2358e5bd7b54SMike Christie { 235940a06e75SMike Christie iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST); 2360e5bd7b54SMike Christie } 2361e5bd7b54SMike Christie 2362a4804cd6SMike Christie /** 2363a4804cd6SMike Christie * iscsi_host_remove - remove host and sessions 2364a4804cd6SMike Christie * @shost: scsi host 2365a4804cd6SMike Christie * 2366e5bd7b54SMike Christie * If there are any sessions left, this will initiate the removal and wait 2367e5bd7b54SMike Christie * for the completion. 2368a4804cd6SMike Christie */ 2369a4804cd6SMike Christie void iscsi_host_remove(struct Scsi_Host *shost) 2370a4804cd6SMike Christie { 2371e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2372e5bd7b54SMike Christie unsigned long flags; 2373e5bd7b54SMike Christie 2374e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2375e5bd7b54SMike Christie ihost->state = ISCSI_HOST_REMOVED; 2376e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2377e5bd7b54SMike Christie 2378e5bd7b54SMike Christie iscsi_host_for_each_session(shost, iscsi_notify_host_removed); 2379e5bd7b54SMike Christie wait_event_interruptible(ihost->session_removal_wq, 2380e5bd7b54SMike Christie ihost->num_sessions == 0); 2381e5bd7b54SMike Christie if (signal_pending(current)) 2382e5bd7b54SMike Christie flush_signals(current); 2383e5bd7b54SMike Christie 2384a4804cd6SMike Christie scsi_remove_host(shost); 238532ae763eSMike Christie if (ihost->workq) 238632ae763eSMike Christie destroy_workqueue(ihost->workq); 2387a4804cd6SMike Christie } 2388a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_remove); 2389a4804cd6SMike Christie 2390a4804cd6SMike Christie void iscsi_host_free(struct Scsi_Host *shost) 239175613521SMike Christie { 239275613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 239375613521SMike Christie 239475613521SMike Christie kfree(ihost->netdev); 239575613521SMike Christie kfree(ihost->hwaddress); 239675613521SMike Christie kfree(ihost->initiatorname); 2397a4804cd6SMike Christie scsi_host_put(shost); 239875613521SMike Christie } 2399a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_free); 240075613521SMike Christie 2401e5bd7b54SMike Christie static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost) 2402e5bd7b54SMike Christie { 2403e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2404e5bd7b54SMike Christie unsigned long flags; 2405e5bd7b54SMike Christie 2406e5bd7b54SMike Christie shost = scsi_host_get(shost); 2407e5bd7b54SMike Christie if (!shost) { 2408e5bd7b54SMike Christie printk(KERN_ERR "Invalid state. Cannot notify host removal " 2409e5bd7b54SMike Christie "of session teardown event because host already " 2410e5bd7b54SMike Christie "removed.\n"); 2411e5bd7b54SMike Christie return; 2412e5bd7b54SMike Christie } 2413e5bd7b54SMike Christie 2414e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2415e5bd7b54SMike Christie ihost->num_sessions--; 2416e5bd7b54SMike Christie if (ihost->num_sessions == 0) 2417e5bd7b54SMike Christie wake_up(&ihost->session_removal_wq); 2418e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2419e5bd7b54SMike Christie scsi_host_put(shost); 2420e5bd7b54SMike Christie } 2421e5bd7b54SMike Christie 242275613521SMike Christie /** 242375613521SMike Christie * iscsi_session_setup - create iscsi cls session and host and session 242475613521SMike Christie * @iscsit: iscsi transport template 242575613521SMike Christie * @shost: scsi host 242675613521SMike Christie * @cmds_max: session can queue 24279c19a7d0SMike Christie * @cmd_task_size: LLD task private data size 242875613521SMike Christie * @initial_cmdsn: initial CmdSN 242975613521SMike Christie * 243075613521SMike Christie * This can be used by software iscsi_transports that allocate 243175613521SMike Christie * a session per scsi host. 24323cf7b233SMike Christie * 24333cf7b233SMike Christie * Callers should set cmds_max to the largest total numer (mgmt + scsi) of 24343cf7b233SMike Christie * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks 24353cf7b233SMike Christie * for nop handling and login/logout requests. 243675613521SMike Christie */ 243775613521SMike Christie struct iscsi_cls_session * 243875613521SMike Christie iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, 2439*b8b9e1b8SJayamohan Kallickal uint16_t cmds_max, int dd_size, int cmd_task_size, 24407970634bSMike Christie uint32_t initial_cmdsn, unsigned int id) 244175613521SMike Christie { 2442e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 244375613521SMike Christie struct iscsi_session *session; 244475613521SMike Christie struct iscsi_cls_session *cls_session; 24453cf7b233SMike Christie int cmd_i, scsi_cmds, total_cmds = cmds_max; 2446e5bd7b54SMike Christie unsigned long flags; 2447e5bd7b54SMike Christie 2448e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2449e5bd7b54SMike Christie if (ihost->state == ISCSI_HOST_REMOVED) { 2450e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2451e5bd7b54SMike Christie return NULL; 2452e5bd7b54SMike Christie } 2453e5bd7b54SMike Christie ihost->num_sessions++; 2454e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 24558e9a20ceSMike Christie 24568e9a20ceSMike Christie if (!total_cmds) 24578e9a20ceSMike Christie total_cmds = ISCSI_DEF_XMIT_CMDS_MAX; 24583e5c28adSMike Christie /* 24593cf7b233SMike Christie * The iscsi layer needs some tasks for nop handling and tmfs, 24603cf7b233SMike Christie * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX 24613cf7b233SMike Christie * + 1 command for scsi IO. 24623e5c28adSMike Christie */ 24633cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 24643cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 24653cf7b233SMike Christie "must be a power of two that is at least %d.\n", 24663cf7b233SMike Christie total_cmds, ISCSI_TOTAL_CMDS_MIN); 2467e5bd7b54SMike Christie goto dec_session_count; 24681548271eSMike Christie } 24693cf7b233SMike Christie 24703cf7b233SMike Christie if (total_cmds > ISCSI_TOTAL_CMDS_MAX) { 24713cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 24723cf7b233SMike Christie "must be a power of 2 less than or equal to %d.\n", 24733cf7b233SMike Christie cmds_max, ISCSI_TOTAL_CMDS_MAX); 24743cf7b233SMike Christie total_cmds = ISCSI_TOTAL_CMDS_MAX; 24753cf7b233SMike Christie } 24763cf7b233SMike Christie 24773cf7b233SMike Christie if (!is_power_of_2(total_cmds)) { 24783cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 24793cf7b233SMike Christie "must be a power of 2.\n", total_cmds); 24803cf7b233SMike Christie total_cmds = rounddown_pow_of_two(total_cmds); 24813cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) 24823cf7b233SMike Christie return NULL; 24833cf7b233SMike Christie printk(KERN_INFO "iscsi: Rounding can_queue to %d.\n", 24843cf7b233SMike Christie total_cmds); 24853cf7b233SMike Christie } 24863cf7b233SMike Christie scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX; 24871548271eSMike Christie 24885d91e209SMike Christie cls_session = iscsi_alloc_session(shost, iscsit, 2489*b8b9e1b8SJayamohan Kallickal sizeof(struct iscsi_session) + 2490*b8b9e1b8SJayamohan Kallickal dd_size); 249175613521SMike Christie if (!cls_session) 2492e5bd7b54SMike Christie goto dec_session_count; 249375613521SMike Christie session = cls_session->dd_data; 249475613521SMike Christie session->cls_session = cls_session; 24957996a778SMike Christie session->host = shost; 24967996a778SMike Christie session->state = ISCSI_STATE_FREE; 2497f6d5180cSMike Christie session->fast_abort = 1; 24984cd49ea1SMike Christie session->lu_reset_timeout = 15; 24994cd49ea1SMike Christie session->abort_timeout = 10; 25003cf7b233SMike Christie session->scsi_cmds_max = scsi_cmds; 25013cf7b233SMike Christie session->cmds_max = total_cmds; 2502e0726407SMike Christie session->queued_cmdsn = session->cmdsn = initial_cmdsn; 25037996a778SMike Christie session->exp_cmdsn = initial_cmdsn + 1; 25047996a778SMike Christie session->max_cmdsn = initial_cmdsn + 1; 25057996a778SMike Christie session->max_r2t = 1; 25067996a778SMike Christie session->tt = iscsit; 2507*b8b9e1b8SJayamohan Kallickal session->dd_data = cls_session->dd_data + sizeof(*session); 25086724add1SMike Christie mutex_init(&session->eh_mutex); 250975613521SMike Christie spin_lock_init(&session->lock); 25107996a778SMike Christie 25117996a778SMike Christie /* initialize SCSI PDU commands pool */ 25127996a778SMike Christie if (iscsi_pool_init(&session->cmdpool, session->cmds_max, 25137996a778SMike Christie (void***)&session->cmds, 25149c19a7d0SMike Christie cmd_task_size + sizeof(struct iscsi_task))) 25157996a778SMike Christie goto cmdpool_alloc_fail; 25167996a778SMike Christie 25177996a778SMike Christie /* pre-format cmds pool with ITT */ 25187996a778SMike Christie for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) { 25199c19a7d0SMike Christie struct iscsi_task *task = session->cmds[cmd_i]; 25207996a778SMike Christie 25219c19a7d0SMike Christie if (cmd_task_size) 25229c19a7d0SMike Christie task->dd_data = &task[1]; 25239c19a7d0SMike Christie task->itt = cmd_i; 25243bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 25259c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 25267996a778SMike Christie } 25277996a778SMike Christie 2528f53a88daSMike Christie if (!try_module_get(iscsit->owner)) 252975613521SMike Christie goto module_get_fail; 253075613521SMike Christie 25317970634bSMike Christie if (iscsi_add_session(cls_session, id)) 2532f53a88daSMike Christie goto cls_session_fail; 2533e5bd7b54SMike Christie 25347996a778SMike Christie return cls_session; 25357996a778SMike Christie 25367996a778SMike Christie cls_session_fail: 253775613521SMike Christie module_put(iscsit->owner); 253875613521SMike Christie module_get_fail: 25396320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 25407996a778SMike Christie cmdpool_alloc_fail: 254175613521SMike Christie iscsi_free_session(cls_session); 2542e5bd7b54SMike Christie dec_session_count: 2543e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 25447996a778SMike Christie return NULL; 25457996a778SMike Christie } 25467996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_setup); 25477996a778SMike Christie 25487996a778SMike Christie /** 25497996a778SMike Christie * iscsi_session_teardown - destroy session, host, and cls_session 255075613521SMike Christie * @cls_session: iscsi session 25517996a778SMike Christie * 255275613521SMike Christie * The driver must have called iscsi_remove_session before 255375613521SMike Christie * calling this. 255475613521SMike Christie */ 25557996a778SMike Christie void iscsi_session_teardown(struct iscsi_cls_session *cls_session) 25567996a778SMike Christie { 255775613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 255863f75cc8SMike Christie struct module *owner = cls_session->transport->owner; 2559e5bd7b54SMike Christie struct Scsi_Host *shost = session->host; 25607996a778SMike Christie 25616320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 25627996a778SMike Christie 2563b2c64167SMike Christie kfree(session->password); 2564b2c64167SMike Christie kfree(session->password_in); 2565b2c64167SMike Christie kfree(session->username); 2566b2c64167SMike Christie kfree(session->username_in); 2567f3ff0c36SMike Christie kfree(session->targetname); 256888dfd340SMike Christie kfree(session->initiatorname); 256988dfd340SMike Christie kfree(session->ifacename); 2570f3ff0c36SMike Christie 257175613521SMike Christie iscsi_destroy_session(cls_session); 2572e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 257363f75cc8SMike Christie module_put(owner); 25747996a778SMike Christie } 25757996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_teardown); 25767996a778SMike Christie 25777996a778SMike Christie /** 25787996a778SMike Christie * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn 25797996a778SMike Christie * @cls_session: iscsi_cls_session 25805d91e209SMike Christie * @dd_size: private driver data size 25817996a778SMike Christie * @conn_idx: cid 25825d91e209SMike Christie */ 25837996a778SMike Christie struct iscsi_cls_conn * 25845d91e209SMike Christie iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, 25855d91e209SMike Christie uint32_t conn_idx) 25867996a778SMike Christie { 258775613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 25887996a778SMike Christie struct iscsi_conn *conn; 25897996a778SMike Christie struct iscsi_cls_conn *cls_conn; 2590d36ab6f3SMike Christie char *data; 25917996a778SMike Christie 25925d91e209SMike Christie cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size, 25935d91e209SMike Christie conn_idx); 25947996a778SMike Christie if (!cls_conn) 25957996a778SMike Christie return NULL; 25967996a778SMike Christie conn = cls_conn->dd_data; 25975d91e209SMike Christie memset(conn, 0, sizeof(*conn) + dd_size); 25987996a778SMike Christie 25995d91e209SMike Christie conn->dd_data = cls_conn->dd_data + sizeof(*conn); 26007996a778SMike Christie conn->session = session; 26017996a778SMike Christie conn->cls_conn = cls_conn; 26027996a778SMike Christie conn->c_stage = ISCSI_CONN_INITIAL_STAGE; 26037996a778SMike Christie conn->id = conn_idx; 26047996a778SMike Christie conn->exp_statsn = 0; 2605843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2606f6d5180cSMike Christie 2607f6d5180cSMike Christie init_timer(&conn->transport_timer); 2608f6d5180cSMike Christie conn->transport_timer.data = (unsigned long)conn; 2609f6d5180cSMike Christie conn->transport_timer.function = iscsi_check_transport_timeouts; 2610f6d5180cSMike Christie 2611843c0a8aSMike Christie INIT_LIST_HEAD(&conn->mgmtqueue); 26123bbaaad9SMike Christie INIT_LIST_HEAD(&conn->cmdqueue); 2613843c0a8aSMike Christie INIT_LIST_HEAD(&conn->requeue); 2614c4028958SDavid Howells INIT_WORK(&conn->xmitwork, iscsi_xmitworker); 26157996a778SMike Christie 26169c19a7d0SMike Christie /* allocate login_task used for the login/text sequences */ 26177996a778SMike Christie spin_lock_bh(&session->lock); 26183e5c28adSMike Christie if (!__kfifo_get(session->cmdpool.queue, 26199c19a7d0SMike Christie (void*)&conn->login_task, 26207996a778SMike Christie sizeof(void*))) { 26217996a778SMike Christie spin_unlock_bh(&session->lock); 26229c19a7d0SMike Christie goto login_task_alloc_fail; 26237996a778SMike Christie } 26247996a778SMike Christie spin_unlock_bh(&session->lock); 26257996a778SMike Christie 2626cfeb2cf9SMike Christie data = (char *) __get_free_pages(GFP_KERNEL, 2627cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2628d36ab6f3SMike Christie if (!data) 26299c19a7d0SMike Christie goto login_task_data_alloc_fail; 26309c19a7d0SMike Christie conn->login_task->data = conn->data = data; 2631d36ab6f3SMike Christie 2632843c0a8aSMike Christie init_timer(&conn->tmf_timer); 26337996a778SMike Christie init_waitqueue_head(&conn->ehwait); 26347996a778SMike Christie 26357996a778SMike Christie return cls_conn; 26367996a778SMike Christie 26379c19a7d0SMike Christie login_task_data_alloc_fail: 26389c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task, 2639d36ab6f3SMike Christie sizeof(void*)); 26409c19a7d0SMike Christie login_task_alloc_fail: 26417996a778SMike Christie iscsi_destroy_conn(cls_conn); 26427996a778SMike Christie return NULL; 26437996a778SMike Christie } 26447996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_setup); 26457996a778SMike Christie 26467996a778SMike Christie /** 26477996a778SMike Christie * iscsi_conn_teardown - teardown iscsi connection 26487996a778SMike Christie * cls_conn: iscsi class connection 26497996a778SMike Christie * 26507996a778SMike Christie * TODO: we may need to make this into a two step process 26517996a778SMike Christie * like scsi-mls remove + put host 26527996a778SMike Christie */ 26537996a778SMike Christie void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) 26547996a778SMike Christie { 26557996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 26567996a778SMike Christie struct iscsi_session *session = conn->session; 26577996a778SMike Christie unsigned long flags; 26587996a778SMike Christie 2659f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 2660f6d5180cSMike Christie 26617996a778SMike Christie spin_lock_bh(&session->lock); 26627996a778SMike Christie conn->c_stage = ISCSI_CONN_CLEANUP_WAIT; 26637996a778SMike Christie if (session->leadconn == conn) { 26647996a778SMike Christie /* 26657996a778SMike Christie * leading connection? then give up on recovery. 26667996a778SMike Christie */ 26677996a778SMike Christie session->state = ISCSI_STATE_TERMINATE; 26687996a778SMike Christie wake_up(&conn->ehwait); 26697996a778SMike Christie } 26707996a778SMike Christie spin_unlock_bh(&session->lock); 26717996a778SMike Christie 26727996a778SMike Christie /* 26737996a778SMike Christie * Block until all in-progress commands for this connection 26747996a778SMike Christie * time out or fail. 26757996a778SMike Christie */ 26767996a778SMike Christie for (;;) { 26777996a778SMike Christie spin_lock_irqsave(session->host->host_lock, flags); 26787996a778SMike Christie if (!session->host->host_busy) { /* OK for ERL == 0 */ 26797996a778SMike Christie spin_unlock_irqrestore(session->host->host_lock, flags); 26807996a778SMike Christie break; 26817996a778SMike Christie } 26827996a778SMike Christie spin_unlock_irqrestore(session->host->host_lock, flags); 26837996a778SMike Christie msleep_interruptible(500); 2684322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "iscsi conn_destroy(): " 2685322d739dSMike Christie "host_busy %d host_failed %d\n", 2686322d739dSMike Christie session->host->host_busy, 2687be2df72eSOr Gerlitz session->host->host_failed); 26887996a778SMike Christie /* 26897996a778SMike Christie * force eh_abort() to unblock 26907996a778SMike Christie */ 26917996a778SMike Christie wake_up(&conn->ehwait); 26927996a778SMike Christie } 26937996a778SMike Christie 2694779ea120SMike Christie /* flush queued up work because we free the connection below */ 2695843c0a8aSMike Christie iscsi_suspend_tx(conn); 2696779ea120SMike Christie 26977996a778SMike Christie spin_lock_bh(&session->lock); 2698cfeb2cf9SMike Christie free_pages((unsigned long) conn->data, 2699cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2700f3ff0c36SMike Christie kfree(conn->persistent_address); 27019c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task, 27027996a778SMike Christie sizeof(void*)); 2703e0726407SMike Christie if (session->leadconn == conn) 27047996a778SMike Christie session->leadconn = NULL; 27057996a778SMike Christie spin_unlock_bh(&session->lock); 27067996a778SMike Christie 27077996a778SMike Christie iscsi_destroy_conn(cls_conn); 27087996a778SMike Christie } 27097996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_teardown); 27107996a778SMike Christie 27117996a778SMike Christie int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 27127996a778SMike Christie { 27137996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 27147996a778SMike Christie struct iscsi_session *session = conn->session; 27157996a778SMike Christie 2716ffd0436eSMike Christie if (!session) { 2717322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 2718322d739dSMike Christie "can't start unbound connection\n"); 27197996a778SMike Christie return -EPERM; 27207996a778SMike Christie } 27217996a778SMike Christie 2722db98ccdeSMike Christie if ((session->imm_data_en || !session->initial_r2t_en) && 2723db98ccdeSMike Christie session->first_burst > session->max_burst) { 2724322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: " 2725ffd0436eSMike Christie "first_burst %d max_burst %d\n", 2726ffd0436eSMike Christie session->first_burst, session->max_burst); 2727ffd0436eSMike Christie return -EINVAL; 2728ffd0436eSMike Christie } 2729ffd0436eSMike Christie 2730f6d5180cSMike Christie if (conn->ping_timeout && !conn->recv_timeout) { 2731322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of " 2732322d739dSMike Christie "zero. Using 5 seconds\n."); 2733f6d5180cSMike Christie conn->recv_timeout = 5; 2734f6d5180cSMike Christie } 2735f6d5180cSMike Christie 2736f6d5180cSMike Christie if (conn->recv_timeout && !conn->ping_timeout) { 2737322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of " 2738322d739dSMike Christie "zero. Using 5 seconds.\n"); 2739f6d5180cSMike Christie conn->ping_timeout = 5; 2740f6d5180cSMike Christie } 2741f6d5180cSMike Christie 27427996a778SMike Christie spin_lock_bh(&session->lock); 27437996a778SMike Christie conn->c_stage = ISCSI_CONN_STARTED; 27447996a778SMike Christie session->state = ISCSI_STATE_LOGGED_IN; 2745e0726407SMike Christie session->queued_cmdsn = session->cmdsn; 27467996a778SMike Christie 2747f6d5180cSMike Christie conn->last_recv = jiffies; 2748f6d5180cSMike Christie conn->last_ping = jiffies; 2749f6d5180cSMike Christie if (conn->recv_timeout && conn->ping_timeout) 2750f6d5180cSMike Christie mod_timer(&conn->transport_timer, 2751f6d5180cSMike Christie jiffies + (conn->recv_timeout * HZ)); 2752f6d5180cSMike Christie 27537996a778SMike Christie switch(conn->stop_stage) { 27547996a778SMike Christie case STOP_CONN_RECOVER: 27557996a778SMike Christie /* 27567996a778SMike Christie * unblock eh_abort() if it is blocked. re-try all 27577996a778SMike Christie * commands after successful recovery 27587996a778SMike Christie */ 27597996a778SMike Christie conn->stop_stage = 0; 2760843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 27617996a778SMike Christie session->age++; 27628b1d0343SMike Christie if (session->age == 16) 27638b1d0343SMike Christie session->age = 0; 27646eabafbeSMike Christie break; 27657996a778SMike Christie case STOP_CONN_TERM: 27667996a778SMike Christie conn->stop_stage = 0; 27677996a778SMike Christie break; 27687996a778SMike Christie default: 27697996a778SMike Christie break; 27707996a778SMike Christie } 27717996a778SMike Christie spin_unlock_bh(&session->lock); 27727996a778SMike Christie 277375613521SMike Christie iscsi_unblock_session(session->cls_session); 27746eabafbeSMike Christie wake_up(&conn->ehwait); 27757996a778SMike Christie return 0; 27767996a778SMike Christie } 27777996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_start); 27787996a778SMike Christie 27797996a778SMike Christie static void 27803bbaaad9SMike Christie fail_mgmt_tasks(struct iscsi_session *session, struct iscsi_conn *conn) 27817996a778SMike Christie { 27823bbaaad9SMike Christie struct iscsi_task *task; 2783b3cd5050SMike Christie int i, state; 27847996a778SMike Christie 27853bbaaad9SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 27863bbaaad9SMike Christie task = conn->session->cmds[i]; 27873bbaaad9SMike Christie if (task->sc) 27883bbaaad9SMike Christie continue; 27893bbaaad9SMike Christie 27903bbaaad9SMike Christie if (task->state == ISCSI_TASK_FREE) 27913bbaaad9SMike Christie continue; 27923bbaaad9SMike Christie 27933bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, 27943bbaaad9SMike Christie "failing mgmt itt 0x%x state %d\n", 27953bbaaad9SMike Christie task->itt, task->state); 2796b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 2797b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) 2798b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 2799b3cd5050SMike Christie iscsi_complete_task(task, state); 2800b3cd5050SMike Christie 28017996a778SMike Christie } 28027996a778SMike Christie } 28037996a778SMike Christie 2804656cffc9SMike Christie static void iscsi_start_session_recovery(struct iscsi_session *session, 28057996a778SMike Christie struct iscsi_conn *conn, int flag) 28067996a778SMike Christie { 2807ed2abc7fSMike Christie int old_stop_stage; 2808ed2abc7fSMike Christie 28096724add1SMike Christie mutex_lock(&session->eh_mutex); 28107996a778SMike Christie spin_lock_bh(&session->lock); 2811ed2abc7fSMike Christie if (conn->stop_stage == STOP_CONN_TERM) { 28127996a778SMike Christie spin_unlock_bh(&session->lock); 28136724add1SMike Christie mutex_unlock(&session->eh_mutex); 28146724add1SMike Christie return; 28156724add1SMike Christie } 28166724add1SMike Christie 28176724add1SMike Christie /* 2818ed2abc7fSMike Christie * When this is called for the in_login state, we only want to clean 28199c19a7d0SMike Christie * up the login task and connection. We do not need to block and set 282067a61114SMike Christie * the recovery state again 2821ed2abc7fSMike Christie */ 282267a61114SMike Christie if (flag == STOP_CONN_TERM) 282367a61114SMike Christie session->state = ISCSI_STATE_TERMINATE; 282467a61114SMike Christie else if (conn->stop_stage != STOP_CONN_RECOVER) 282567a61114SMike Christie session->state = ISCSI_STATE_IN_RECOVERY; 282626013ad4SMike Christie spin_unlock_bh(&session->lock); 2827ed2abc7fSMike Christie 282826013ad4SMike Christie del_timer_sync(&conn->transport_timer); 282926013ad4SMike Christie iscsi_suspend_tx(conn); 283026013ad4SMike Christie 283126013ad4SMike Christie spin_lock_bh(&session->lock); 2832ed2abc7fSMike Christie old_stop_stage = conn->stop_stage; 28337996a778SMike Christie conn->stop_stage = flag; 283467a61114SMike Christie conn->c_stage = ISCSI_CONN_STOPPED; 28357996a778SMike Christie spin_unlock_bh(&session->lock); 28366724add1SMike Christie 28377996a778SMike Christie /* 28387996a778SMike Christie * for connection level recovery we should not calculate 28397996a778SMike Christie * header digest. conn->hdr_size used for optimization 28407996a778SMike Christie * in hdr_extract() and will be re-negotiated at 28417996a778SMike Christie * set_param() time. 28427996a778SMike Christie */ 28437996a778SMike Christie if (flag == STOP_CONN_RECOVER) { 28447996a778SMike Christie conn->hdrdgst_en = 0; 28457996a778SMike Christie conn->datadgst_en = 0; 2846656cffc9SMike Christie if (session->state == ISCSI_STATE_IN_RECOVERY && 284767a61114SMike Christie old_stop_stage != STOP_CONN_RECOVER) { 28481b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "blocking session\n"); 284975613521SMike Christie iscsi_block_session(session->cls_session); 28507996a778SMike Christie } 285167a61114SMike Christie } 2852656cffc9SMike Christie 2853656cffc9SMike Christie /* 2854656cffc9SMike Christie * flush queues. 2855656cffc9SMike Christie */ 2856656cffc9SMike Christie spin_lock_bh(&session->lock); 28573bbaaad9SMike Christie fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED); 28583bbaaad9SMike Christie fail_mgmt_tasks(session, conn); 2859656cffc9SMike Christie spin_unlock_bh(&session->lock); 28606724add1SMike Christie mutex_unlock(&session->eh_mutex); 28617996a778SMike Christie } 28627996a778SMike Christie 28637996a778SMike Christie void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 28647996a778SMike Christie { 28657996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 28667996a778SMike Christie struct iscsi_session *session = conn->session; 28677996a778SMike Christie 28687996a778SMike Christie switch (flag) { 28697996a778SMike Christie case STOP_CONN_RECOVER: 28707996a778SMike Christie case STOP_CONN_TERM: 28717996a778SMike Christie iscsi_start_session_recovery(session, conn, flag); 28728d2860b3SMike Christie break; 28737996a778SMike Christie default: 2874322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 2875322d739dSMike Christie "invalid stop flag %d\n", flag); 28767996a778SMike Christie } 28777996a778SMike Christie } 28787996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_stop); 28797996a778SMike Christie 28807996a778SMike Christie int iscsi_conn_bind(struct iscsi_cls_session *cls_session, 28817996a778SMike Christie struct iscsi_cls_conn *cls_conn, int is_leading) 28827996a778SMike Christie { 288375613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 288498644047SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 28857996a778SMike Christie 28867996a778SMike Christie spin_lock_bh(&session->lock); 28877996a778SMike Christie if (is_leading) 28887996a778SMike Christie session->leadconn = conn; 288998644047SMike Christie spin_unlock_bh(&session->lock); 28907996a778SMike Christie 28917996a778SMike Christie /* 28927996a778SMike Christie * Unblock xmitworker(), Login Phase will pass through. 28937996a778SMike Christie */ 28947996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 28957996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 28967996a778SMike Christie return 0; 28977996a778SMike Christie } 28987996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_bind); 28997996a778SMike Christie 29005700b1afSMike Christie static int iscsi_switch_str_param(char **param, char *new_val_buf) 29015700b1afSMike Christie { 29025700b1afSMike Christie char *new_val; 29035700b1afSMike Christie 29045700b1afSMike Christie if (*param) { 29055700b1afSMike Christie if (!strcmp(*param, new_val_buf)) 29065700b1afSMike Christie return 0; 29075700b1afSMike Christie } 29085700b1afSMike Christie 29095700b1afSMike Christie new_val = kstrdup(new_val_buf, GFP_NOIO); 29105700b1afSMike Christie if (!new_val) 29115700b1afSMike Christie return -ENOMEM; 29125700b1afSMike Christie 29135700b1afSMike Christie kfree(*param); 29145700b1afSMike Christie *param = new_val; 29155700b1afSMike Christie return 0; 29165700b1afSMike Christie } 2917a54a52caSMike Christie 2918a54a52caSMike Christie int iscsi_set_param(struct iscsi_cls_conn *cls_conn, 2919a54a52caSMike Christie enum iscsi_param param, char *buf, int buflen) 2920a54a52caSMike Christie { 2921a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 2922a54a52caSMike Christie struct iscsi_session *session = conn->session; 2923a54a52caSMike Christie uint32_t value; 2924a54a52caSMike Christie 2925a54a52caSMike Christie switch(param) { 2926843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 2927843c0a8aSMike Christie sscanf(buf, "%d", &session->fast_abort); 2928843c0a8aSMike Christie break; 2929f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 2930f6d5180cSMike Christie sscanf(buf, "%d", &session->abort_timeout); 2931f6d5180cSMike Christie break; 2932f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 2933f6d5180cSMike Christie sscanf(buf, "%d", &session->lu_reset_timeout); 2934f6d5180cSMike Christie break; 2935f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 2936f6d5180cSMike Christie sscanf(buf, "%d", &conn->ping_timeout); 2937f6d5180cSMike Christie break; 2938f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 2939f6d5180cSMike Christie sscanf(buf, "%d", &conn->recv_timeout); 2940f6d5180cSMike Christie break; 2941a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 2942a54a52caSMike Christie sscanf(buf, "%d", &conn->max_recv_dlength); 2943a54a52caSMike Christie break; 2944a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 2945a54a52caSMike Christie sscanf(buf, "%d", &conn->max_xmit_dlength); 2946a54a52caSMike Christie break; 2947a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 2948a54a52caSMike Christie sscanf(buf, "%d", &conn->hdrdgst_en); 2949a54a52caSMike Christie break; 2950a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 2951a54a52caSMike Christie sscanf(buf, "%d", &conn->datadgst_en); 2952a54a52caSMike Christie break; 2953a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 2954a54a52caSMike Christie sscanf(buf, "%d", &session->initial_r2t_en); 2955a54a52caSMike Christie break; 2956a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 2957a54a52caSMike Christie sscanf(buf, "%d", &session->max_r2t); 2958a54a52caSMike Christie break; 2959a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 2960a54a52caSMike Christie sscanf(buf, "%d", &session->imm_data_en); 2961a54a52caSMike Christie break; 2962a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 2963a54a52caSMike Christie sscanf(buf, "%d", &session->first_burst); 2964a54a52caSMike Christie break; 2965a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 2966a54a52caSMike Christie sscanf(buf, "%d", &session->max_burst); 2967a54a52caSMike Christie break; 2968a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 2969a54a52caSMike Christie sscanf(buf, "%d", &session->pdu_inorder_en); 2970a54a52caSMike Christie break; 2971a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 2972a54a52caSMike Christie sscanf(buf, "%d", &session->dataseq_inorder_en); 2973a54a52caSMike Christie break; 2974a54a52caSMike Christie case ISCSI_PARAM_ERL: 2975a54a52caSMike Christie sscanf(buf, "%d", &session->erl); 2976a54a52caSMike Christie break; 2977a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 2978a54a52caSMike Christie sscanf(buf, "%d", &value); 2979a54a52caSMike Christie BUG_ON(value); 2980a54a52caSMike Christie break; 2981a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 2982a54a52caSMike Christie sscanf(buf, "%d", &value); 2983a54a52caSMike Christie BUG_ON(value); 2984a54a52caSMike Christie break; 2985a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 2986a54a52caSMike Christie sscanf(buf, "%u", &conn->exp_statsn); 2987a54a52caSMike Christie break; 2988b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 29895700b1afSMike Christie return iscsi_switch_str_param(&session->username, buf); 2990b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 29915700b1afSMike Christie return iscsi_switch_str_param(&session->username_in, buf); 2992b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 29935700b1afSMike Christie return iscsi_switch_str_param(&session->password, buf); 2994b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 29955700b1afSMike Christie return iscsi_switch_str_param(&session->password_in, buf); 2996a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 29975700b1afSMike Christie return iscsi_switch_str_param(&session->targetname, buf); 2998a54a52caSMike Christie case ISCSI_PARAM_TPGT: 2999a54a52caSMike Christie sscanf(buf, "%d", &session->tpgt); 3000a54a52caSMike Christie break; 3001a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3002a54a52caSMike Christie sscanf(buf, "%d", &conn->persistent_port); 3003a54a52caSMike Christie break; 3004a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 30055700b1afSMike Christie return iscsi_switch_str_param(&conn->persistent_address, buf); 300688dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 30075700b1afSMike Christie return iscsi_switch_str_param(&session->ifacename, buf); 300888dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 30095700b1afSMike Christie return iscsi_switch_str_param(&session->initiatorname, buf); 3010a54a52caSMike Christie default: 3011a54a52caSMike Christie return -ENOSYS; 3012a54a52caSMike Christie } 3013a54a52caSMike Christie 3014a54a52caSMike Christie return 0; 3015a54a52caSMike Christie } 3016a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_set_param); 3017a54a52caSMike Christie 3018a54a52caSMike Christie int iscsi_session_get_param(struct iscsi_cls_session *cls_session, 3019a54a52caSMike Christie enum iscsi_param param, char *buf) 3020a54a52caSMike Christie { 302175613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 3022a54a52caSMike Christie int len; 3023a54a52caSMike Christie 3024a54a52caSMike Christie switch(param) { 3025843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 3026843c0a8aSMike Christie len = sprintf(buf, "%d\n", session->fast_abort); 3027843c0a8aSMike Christie break; 3028f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 3029f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->abort_timeout); 3030f6d5180cSMike Christie break; 3031f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 3032f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->lu_reset_timeout); 3033f6d5180cSMike Christie break; 3034a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 3035a54a52caSMike Christie len = sprintf(buf, "%d\n", session->initial_r2t_en); 3036a54a52caSMike Christie break; 3037a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 3038a54a52caSMike Christie len = sprintf(buf, "%hu\n", session->max_r2t); 3039a54a52caSMike Christie break; 3040a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 3041a54a52caSMike Christie len = sprintf(buf, "%d\n", session->imm_data_en); 3042a54a52caSMike Christie break; 3043a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 3044a54a52caSMike Christie len = sprintf(buf, "%u\n", session->first_burst); 3045a54a52caSMike Christie break; 3046a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 3047a54a52caSMike Christie len = sprintf(buf, "%u\n", session->max_burst); 3048a54a52caSMike Christie break; 3049a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 3050a54a52caSMike Christie len = sprintf(buf, "%d\n", session->pdu_inorder_en); 3051a54a52caSMike Christie break; 3052a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 3053a54a52caSMike Christie len = sprintf(buf, "%d\n", session->dataseq_inorder_en); 3054a54a52caSMike Christie break; 3055a54a52caSMike Christie case ISCSI_PARAM_ERL: 3056a54a52caSMike Christie len = sprintf(buf, "%d\n", session->erl); 3057a54a52caSMike Christie break; 3058a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 3059a54a52caSMike Christie len = sprintf(buf, "%s\n", session->targetname); 3060a54a52caSMike Christie break; 3061a54a52caSMike Christie case ISCSI_PARAM_TPGT: 3062a54a52caSMike Christie len = sprintf(buf, "%d\n", session->tpgt); 3063a54a52caSMike Christie break; 3064b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 3065b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username); 3066b2c64167SMike Christie break; 3067b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 3068b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username_in); 3069b2c64167SMike Christie break; 3070b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 3071b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password); 3072b2c64167SMike Christie break; 3073b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 3074b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password_in); 3075b2c64167SMike Christie break; 307688dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 307788dfd340SMike Christie len = sprintf(buf, "%s\n", session->ifacename); 307888dfd340SMike Christie break; 307988dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 308088dfd340SMike Christie len = sprintf(buf, "%s\n", session->initiatorname); 308188dfd340SMike Christie break; 3082a54a52caSMike Christie default: 3083a54a52caSMike Christie return -ENOSYS; 3084a54a52caSMike Christie } 3085a54a52caSMike Christie 3086a54a52caSMike Christie return len; 3087a54a52caSMike Christie } 3088a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_get_param); 3089a54a52caSMike Christie 3090a54a52caSMike Christie int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, 3091a54a52caSMike Christie enum iscsi_param param, char *buf) 3092a54a52caSMike Christie { 3093a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 3094a54a52caSMike Christie int len; 3095a54a52caSMike Christie 3096a54a52caSMike Christie switch(param) { 3097f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 3098f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->ping_timeout); 3099f6d5180cSMike Christie break; 3100f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 3101f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->recv_timeout); 3102f6d5180cSMike Christie break; 3103a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 3104a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_recv_dlength); 3105a54a52caSMike Christie break; 3106a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3107a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_xmit_dlength); 3108a54a52caSMike Christie break; 3109a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 3110a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->hdrdgst_en); 3111a54a52caSMike Christie break; 3112a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 3113a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->datadgst_en); 3114a54a52caSMike Christie break; 3115a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 3116a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ifmarker_en); 3117a54a52caSMike Christie break; 3118a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 3119a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ofmarker_en); 3120a54a52caSMike Christie break; 3121a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 3122a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->exp_statsn); 3123a54a52caSMike Christie break; 3124a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3125a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->persistent_port); 3126a54a52caSMike Christie break; 3127a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 3128a54a52caSMike Christie len = sprintf(buf, "%s\n", conn->persistent_address); 3129a54a52caSMike Christie break; 3130a54a52caSMike Christie default: 3131a54a52caSMike Christie return -ENOSYS; 3132a54a52caSMike Christie } 3133a54a52caSMike Christie 3134a54a52caSMike Christie return len; 3135a54a52caSMike Christie } 3136a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_param); 3137a54a52caSMike Christie 31380801c242SMike Christie int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param, 31390801c242SMike Christie char *buf) 31400801c242SMike Christie { 314175613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 31420801c242SMike Christie int len; 31430801c242SMike Christie 31440801c242SMike Christie switch (param) { 3145d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 314675613521SMike Christie len = sprintf(buf, "%s\n", ihost->netdev); 3147d8196ed2SMike Christie break; 31480801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 314975613521SMike Christie len = sprintf(buf, "%s\n", ihost->hwaddress); 31500801c242SMike Christie break; 31518ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 315275613521SMike Christie len = sprintf(buf, "%s\n", ihost->initiatorname); 31538ad5781aSMike Christie break; 315475613521SMike Christie case ISCSI_HOST_PARAM_IPADDRESS: 31555700b1afSMike Christie len = sprintf(buf, "%s\n", ihost->local_address); 315688dfd340SMike Christie break; 31570801c242SMike Christie default: 31580801c242SMike Christie return -ENOSYS; 31590801c242SMike Christie } 31600801c242SMike Christie 31610801c242SMike Christie return len; 31620801c242SMike Christie } 31630801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_param); 31640801c242SMike Christie 31650801c242SMike Christie int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param, 31660801c242SMike Christie char *buf, int buflen) 31670801c242SMike Christie { 316875613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 31690801c242SMike Christie 31700801c242SMike Christie switch (param) { 3171d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 31725700b1afSMike Christie return iscsi_switch_str_param(&ihost->netdev, buf); 31730801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 31745700b1afSMike Christie return iscsi_switch_str_param(&ihost->hwaddress, buf); 31758ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 31765700b1afSMike Christie return iscsi_switch_str_param(&ihost->initiatorname, buf); 31770801c242SMike Christie default: 31780801c242SMike Christie return -ENOSYS; 31790801c242SMike Christie } 31800801c242SMike Christie 31810801c242SMike Christie return 0; 31820801c242SMike Christie } 31830801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_set_param); 31840801c242SMike Christie 31857996a778SMike Christie MODULE_AUTHOR("Mike Christie"); 31867996a778SMike Christie MODULE_DESCRIPTION("iSCSI library functions"); 31877996a778SMike Christie MODULE_LICENSE("GPL"); 3188