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 411b2c7af8SMike Christie static int iscsi_dbg_lib; 421b2c7af8SMike Christie module_param_named(debug_libiscsi, iscsi_dbg_lib, int, S_IRUGO | S_IWUSR); 431b2c7af8SMike Christie MODULE_PARM_DESC(debug_libiscsi, "Turn on debugging for libiscsi module. " 441b2c7af8SMike Christie "Set to 1 to turn on, and zero to turn off. Default " 451b2c7af8SMike Christie "is off."); 461b2c7af8SMike Christie 471b2c7af8SMike Christie #define ISCSI_DBG_CONN(_conn, dbg_fmt, arg...) \ 481b2c7af8SMike Christie do { \ 491b2c7af8SMike Christie if (iscsi_dbg_lib) \ 501b2c7af8SMike Christie iscsi_conn_printk(KERN_INFO, _conn, \ 511b2c7af8SMike Christie "%s " dbg_fmt, \ 521b2c7af8SMike Christie __func__, ##arg); \ 531b2c7af8SMike Christie } while (0); 541b2c7af8SMike Christie 551b2c7af8SMike Christie #define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...) \ 561b2c7af8SMike Christie do { \ 571b2c7af8SMike Christie if (iscsi_dbg_lib) \ 581b2c7af8SMike Christie iscsi_session_printk(KERN_INFO, _session, \ 591b2c7af8SMike Christie "%s " dbg_fmt, \ 601b2c7af8SMike Christie __func__, ##arg); \ 611b2c7af8SMike Christie } while (0); 621b2c7af8SMike Christie 6377a23c21SMike Christie /* Serial Number Arithmetic, 32 bits, less than, RFC1982 */ 6477a23c21SMike Christie #define SNA32_CHECK 2147483648UL 657996a778SMike Christie 6677a23c21SMike Christie static int iscsi_sna_lt(u32 n1, u32 n2) 6777a23c21SMike Christie { 6877a23c21SMike Christie return n1 != n2 && ((n1 < n2 && (n2 - n1 < SNA32_CHECK)) || 6977a23c21SMike Christie (n1 > n2 && (n2 - n1 < SNA32_CHECK))); 7077a23c21SMike Christie } 7177a23c21SMike Christie 7277a23c21SMike Christie /* Serial Number Arithmetic, 32 bits, less than, RFC1982 */ 7377a23c21SMike Christie static int iscsi_sna_lte(u32 n1, u32 n2) 7477a23c21SMike Christie { 7577a23c21SMike Christie return n1 == n2 || ((n1 < n2 && (n2 - n1 < SNA32_CHECK)) || 7677a23c21SMike Christie (n1 > n2 && (n2 - n1 < SNA32_CHECK))); 7777a23c21SMike Christie } 7877a23c21SMike Christie 7932ae763eSMike Christie inline void iscsi_conn_queue_work(struct iscsi_conn *conn) 8032ae763eSMike Christie { 8132ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 8232ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 8332ae763eSMike Christie 841336aed1SMike Christie if (ihost->workq) 8532ae763eSMike Christie queue_work(ihost->workq, &conn->xmitwork); 8632ae763eSMike Christie } 8732ae763eSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_queue_work); 8832ae763eSMike Christie 8977a23c21SMike Christie void 9077a23c21SMike Christie iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr) 917996a778SMike Christie { 927996a778SMike Christie uint32_t max_cmdsn = be32_to_cpu(hdr->max_cmdsn); 937996a778SMike Christie uint32_t exp_cmdsn = be32_to_cpu(hdr->exp_cmdsn); 947996a778SMike Christie 9577a23c21SMike Christie /* 9677a23c21SMike Christie * standard specifies this check for when to update expected and 9777a23c21SMike Christie * max sequence numbers 9877a23c21SMike Christie */ 9977a23c21SMike Christie if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1)) 10077a23c21SMike Christie return; 10177a23c21SMike Christie 10277a23c21SMike Christie if (exp_cmdsn != session->exp_cmdsn && 10377a23c21SMike Christie !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn)) 1047996a778SMike Christie session->exp_cmdsn = exp_cmdsn; 1057996a778SMike Christie 10677a23c21SMike Christie if (max_cmdsn != session->max_cmdsn && 10777a23c21SMike Christie !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) { 10877a23c21SMike Christie session->max_cmdsn = max_cmdsn; 10977a23c21SMike Christie /* 11077a23c21SMike Christie * if the window closed with IO queued, then kick the 11177a23c21SMike Christie * xmit thread 11277a23c21SMike Christie */ 1133bbaaad9SMike Christie if (!list_empty(&session->leadconn->cmdqueue) || 1141336aed1SMike Christie !list_empty(&session->leadconn->mgmtqueue)) 11532ae763eSMike Christie iscsi_conn_queue_work(session->leadconn); 1167996a778SMike Christie } 11777a23c21SMike Christie } 11877a23c21SMike Christie EXPORT_SYMBOL_GPL(iscsi_update_cmdsn); 1197996a778SMike Christie 120577577daSMike Christie /** 121577577daSMike Christie * iscsi_prep_data_out_pdu - initialize Data-Out 122577577daSMike Christie * @task: scsi command task 123577577daSMike Christie * @r2t: R2T info 124577577daSMike Christie * @hdr: iscsi data in pdu 125577577daSMike Christie * 126577577daSMike Christie * Notes: 127577577daSMike Christie * Initialize Data-Out within this R2T sequence and finds 128577577daSMike Christie * proper data_offset within this SCSI command. 129577577daSMike Christie * 130577577daSMike Christie * This function is called with connection lock taken. 131577577daSMike Christie **/ 132577577daSMike Christie void iscsi_prep_data_out_pdu(struct iscsi_task *task, struct iscsi_r2t_info *r2t, 133ffd0436eSMike Christie struct iscsi_data *hdr) 1347996a778SMike Christie { 1359c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 136577577daSMike Christie unsigned int left = r2t->data_length - r2t->sent; 137577577daSMike Christie 138577577daSMike Christie task->hdr_len = sizeof(struct iscsi_data); 1397996a778SMike Christie 1407996a778SMike Christie memset(hdr, 0, sizeof(struct iscsi_data)); 141577577daSMike Christie hdr->ttt = r2t->ttt; 142577577daSMike Christie hdr->datasn = cpu_to_be32(r2t->datasn); 143577577daSMike Christie r2t->datasn++; 1447996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_DATA_OUT; 145577577daSMike Christie memcpy(hdr->lun, task->lun, sizeof(hdr->lun)); 146577577daSMike Christie hdr->itt = task->hdr_itt; 147577577daSMike Christie hdr->exp_statsn = r2t->exp_statsn; 148577577daSMike Christie hdr->offset = cpu_to_be32(r2t->data_offset + r2t->sent); 149577577daSMike Christie if (left > conn->max_xmit_dlength) { 1507996a778SMike Christie hton24(hdr->dlength, conn->max_xmit_dlength); 151577577daSMike Christie r2t->data_count = conn->max_xmit_dlength; 1527996a778SMike Christie hdr->flags = 0; 1537996a778SMike Christie } else { 154577577daSMike Christie hton24(hdr->dlength, left); 155577577daSMike Christie r2t->data_count = left; 1567996a778SMike Christie hdr->flags = ISCSI_FLAG_CMD_FINAL; 1577996a778SMike Christie } 158577577daSMike Christie conn->dataout_pdus_cnt++; 1597996a778SMike Christie } 160577577daSMike Christie EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu); 1617996a778SMike Christie 1629c19a7d0SMike Christie static int iscsi_add_hdr(struct iscsi_task *task, unsigned len) 163004d6530SBoaz Harrosh { 1649c19a7d0SMike Christie unsigned exp_len = task->hdr_len + len; 165004d6530SBoaz Harrosh 1669c19a7d0SMike Christie if (exp_len > task->hdr_max) { 167004d6530SBoaz Harrosh WARN_ON(1); 168004d6530SBoaz Harrosh return -EINVAL; 169004d6530SBoaz Harrosh } 170004d6530SBoaz Harrosh 171004d6530SBoaz Harrosh WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */ 1729c19a7d0SMike Christie task->hdr_len = exp_len; 173004d6530SBoaz Harrosh return 0; 174004d6530SBoaz Harrosh } 175004d6530SBoaz Harrosh 17638d1c069SBoaz Harrosh /* 17738d1c069SBoaz Harrosh * make an extended cdb AHS 17838d1c069SBoaz Harrosh */ 1799c19a7d0SMike Christie static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) 18038d1c069SBoaz Harrosh { 1819c19a7d0SMike Christie struct scsi_cmnd *cmd = task->sc; 18238d1c069SBoaz Harrosh unsigned rlen, pad_len; 18338d1c069SBoaz Harrosh unsigned short ahslength; 18438d1c069SBoaz Harrosh struct iscsi_ecdb_ahdr *ecdb_ahdr; 18538d1c069SBoaz Harrosh int rc; 18638d1c069SBoaz Harrosh 1879c19a7d0SMike Christie ecdb_ahdr = iscsi_next_hdr(task); 18838d1c069SBoaz Harrosh rlen = cmd->cmd_len - ISCSI_CDB_SIZE; 18938d1c069SBoaz Harrosh 19038d1c069SBoaz Harrosh BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb)); 19138d1c069SBoaz Harrosh ahslength = rlen + sizeof(ecdb_ahdr->reserved); 19238d1c069SBoaz Harrosh 19338d1c069SBoaz Harrosh pad_len = iscsi_padding(rlen); 19438d1c069SBoaz Harrosh 1959c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) + 19638d1c069SBoaz Harrosh sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len); 19738d1c069SBoaz Harrosh if (rc) 19838d1c069SBoaz Harrosh return rc; 19938d1c069SBoaz Harrosh 20038d1c069SBoaz Harrosh if (pad_len) 20138d1c069SBoaz Harrosh memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len); 20238d1c069SBoaz Harrosh 20338d1c069SBoaz Harrosh ecdb_ahdr->ahslength = cpu_to_be16(ahslength); 20438d1c069SBoaz Harrosh ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB; 20538d1c069SBoaz Harrosh ecdb_ahdr->reserved = 0; 20638d1c069SBoaz Harrosh memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen); 20738d1c069SBoaz Harrosh 2081b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2091b2c7af8SMike Christie "iscsi_prep_ecdb_ahs: varlen_cdb_len %d " 2101b2c7af8SMike Christie "rlen %d pad_len %d ahs_length %d iscsi_headers_size " 2111b2c7af8SMike Christie "%u\n", cmd->cmd_len, rlen, pad_len, ahslength, 2121b2c7af8SMike Christie task->hdr_len); 21338d1c069SBoaz Harrosh return 0; 21438d1c069SBoaz Harrosh } 21538d1c069SBoaz Harrosh 2169c19a7d0SMike Christie static int iscsi_prep_bidi_ahs(struct iscsi_task *task) 217c07d4444SBoaz Harrosh { 2189c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 219c07d4444SBoaz Harrosh struct iscsi_rlength_ahdr *rlen_ahdr; 220c07d4444SBoaz Harrosh int rc; 221c07d4444SBoaz Harrosh 2229c19a7d0SMike Christie rlen_ahdr = iscsi_next_hdr(task); 2239c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*rlen_ahdr)); 224c07d4444SBoaz Harrosh if (rc) 225c07d4444SBoaz Harrosh return rc; 226c07d4444SBoaz Harrosh 227c07d4444SBoaz Harrosh rlen_ahdr->ahslength = 228c07d4444SBoaz Harrosh cpu_to_be16(sizeof(rlen_ahdr->read_length) + 229c07d4444SBoaz Harrosh sizeof(rlen_ahdr->reserved)); 230c07d4444SBoaz Harrosh rlen_ahdr->ahstype = ISCSI_AHSTYPE_RLENGTH; 231c07d4444SBoaz Harrosh rlen_ahdr->reserved = 0; 232c07d4444SBoaz Harrosh rlen_ahdr->read_length = cpu_to_be32(scsi_in(sc)->length); 233c07d4444SBoaz Harrosh 2341b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2351b2c7af8SMike Christie "bidi-in rlen_ahdr->read_length(%d) " 236c07d4444SBoaz Harrosh "rlen_ahdr->ahslength(%d)\n", 237c07d4444SBoaz Harrosh be32_to_cpu(rlen_ahdr->read_length), 238c07d4444SBoaz Harrosh be16_to_cpu(rlen_ahdr->ahslength)); 239c07d4444SBoaz Harrosh return 0; 240c07d4444SBoaz Harrosh } 241c07d4444SBoaz Harrosh 2427996a778SMike Christie /** 2437996a778SMike Christie * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu 2449c19a7d0SMike Christie * @task: iscsi task 2457996a778SMike Christie * 2467996a778SMike Christie * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set 2477996a778SMike Christie * fields like dlength or final based on how much data it sends 2487996a778SMike Christie */ 2499c19a7d0SMike Christie static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task) 2507996a778SMike Christie { 2519c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 2527996a778SMike Christie struct iscsi_session *session = conn->session; 2539c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 254577577daSMike Christie struct iscsi_cmd *hdr; 25538d1c069SBoaz Harrosh unsigned hdrlength, cmd_len; 256262ef636SMike Christie itt_t itt; 257004d6530SBoaz Harrosh int rc; 2587996a778SMike Christie 259184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 2602ff79d52SMike Christie rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD); 261577577daSMike Christie if (rc) 262577577daSMike Christie return rc; 263184b57c6SMike Christie } 264577577daSMike Christie hdr = (struct iscsi_cmd *) task->hdr; 265262ef636SMike Christie itt = hdr->itt; 266577577daSMike Christie memset(hdr, 0, sizeof(*hdr)); 267577577daSMike Christie 2682ff79d52SMike Christie if (session->tt->parse_pdu_itt) 2692ff79d52SMike Christie hdr->itt = task->hdr_itt = itt; 2702ff79d52SMike Christie else 2712ff79d52SMike Christie hdr->itt = task->hdr_itt = build_itt(task->itt, 2722ff79d52SMike Christie task->conn->session->age); 2739c19a7d0SMike Christie task->hdr_len = 0; 2749c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*hdr)); 275004d6530SBoaz Harrosh if (rc) 276004d6530SBoaz Harrosh return rc; 2777996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_CMD; 2787996a778SMike Christie hdr->flags = ISCSI_ATTR_SIMPLE; 2797996a778SMike Christie int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun); 280577577daSMike Christie memcpy(task->lun, hdr->lun, sizeof(task->lun)); 281577577daSMike Christie hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn); 2827996a778SMike Christie session->cmdsn++; 2837996a778SMike Christie hdr->exp_statsn = cpu_to_be32(conn->exp_statsn); 28438d1c069SBoaz Harrosh cmd_len = sc->cmd_len; 28538d1c069SBoaz Harrosh if (cmd_len < ISCSI_CDB_SIZE) 28638d1c069SBoaz Harrosh memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len); 28738d1c069SBoaz Harrosh else if (cmd_len > ISCSI_CDB_SIZE) { 2889c19a7d0SMike Christie rc = iscsi_prep_ecdb_ahs(task); 28938d1c069SBoaz Harrosh if (rc) 29038d1c069SBoaz Harrosh return rc; 29138d1c069SBoaz Harrosh cmd_len = ISCSI_CDB_SIZE; 29238d1c069SBoaz Harrosh } 29338d1c069SBoaz Harrosh memcpy(hdr->cdb, sc->cmnd, cmd_len); 2947996a778SMike Christie 2959c19a7d0SMike Christie task->imm_count = 0; 296c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc)) { 297c07d4444SBoaz Harrosh hdr->flags |= ISCSI_FLAG_CMD_READ; 2989c19a7d0SMike Christie rc = iscsi_prep_bidi_ahs(task); 299c07d4444SBoaz Harrosh if (rc) 300c07d4444SBoaz Harrosh return rc; 301c07d4444SBoaz Harrosh } 3027996a778SMike Christie if (sc->sc_data_direction == DMA_TO_DEVICE) { 303c07d4444SBoaz Harrosh unsigned out_len = scsi_out(sc)->length; 304577577daSMike Christie struct iscsi_r2t_info *r2t = &task->unsol_r2t; 305577577daSMike Christie 306c07d4444SBoaz Harrosh hdr->data_length = cpu_to_be32(out_len); 3077996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_WRITE; 3087996a778SMike Christie /* 3097996a778SMike Christie * Write counters: 3107996a778SMike Christie * 3117996a778SMike Christie * imm_count bytes to be sent right after 3127996a778SMike Christie * SCSI PDU Header 3137996a778SMike Christie * 3147996a778SMike Christie * unsol_count bytes(as Data-Out) to be sent 3157996a778SMike Christie * without R2T ack right after 3167996a778SMike Christie * immediate data 3177996a778SMike Christie * 318577577daSMike Christie * r2t data_length bytes to be sent via R2T ack's 3197996a778SMike Christie * 3207996a778SMike Christie * pad_count bytes to be sent as zero-padding 3217996a778SMike Christie */ 322577577daSMike Christie memset(r2t, 0, sizeof(*r2t)); 3237996a778SMike Christie 3247996a778SMike Christie if (session->imm_data_en) { 325c07d4444SBoaz Harrosh if (out_len >= session->first_burst) 3269c19a7d0SMike Christie task->imm_count = min(session->first_burst, 3277996a778SMike Christie conn->max_xmit_dlength); 3287996a778SMike Christie else 3299c19a7d0SMike Christie task->imm_count = min(out_len, 3307996a778SMike Christie conn->max_xmit_dlength); 3319c19a7d0SMike Christie hton24(hdr->dlength, task->imm_count); 3327996a778SMike Christie } else 333a8ac6311SOlaf Kirch zero_data(hdr->dlength); 3347996a778SMike Christie 335ffd0436eSMike Christie if (!session->initial_r2t_en) { 336577577daSMike Christie r2t->data_length = min(session->first_burst, out_len) - 337577577daSMike Christie task->imm_count; 338577577daSMike Christie r2t->data_offset = task->imm_count; 339577577daSMike Christie r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG); 340577577daSMike Christie r2t->exp_statsn = cpu_to_be32(conn->exp_statsn); 341ffd0436eSMike Christie } 342ffd0436eSMike Christie 343577577daSMike Christie if (!task->unsol_r2t.data_length) 3447996a778SMike Christie /* No unsolicit Data-Out's */ 345a8ac6311SOlaf Kirch hdr->flags |= ISCSI_FLAG_CMD_FINAL; 3467996a778SMike Christie } else { 3477996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 3487996a778SMike Christie zero_data(hdr->dlength); 349c07d4444SBoaz Harrosh hdr->data_length = cpu_to_be32(scsi_in(sc)->length); 3507996a778SMike Christie 3517996a778SMike Christie if (sc->sc_data_direction == DMA_FROM_DEVICE) 3527996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_READ; 3537996a778SMike Christie } 3547996a778SMike Christie 355004d6530SBoaz Harrosh /* calculate size of additional header segments (AHSs) */ 3569c19a7d0SMike Christie hdrlength = task->hdr_len - sizeof(*hdr); 357004d6530SBoaz Harrosh 358004d6530SBoaz Harrosh WARN_ON(hdrlength & (ISCSI_PAD_LEN-1)); 359004d6530SBoaz Harrosh hdrlength /= ISCSI_PAD_LEN; 360004d6530SBoaz Harrosh 361004d6530SBoaz Harrosh WARN_ON(hdrlength >= 256); 362004d6530SBoaz Harrosh hdr->hlength = hdrlength & 0xFF; 363004d6530SBoaz Harrosh 364577577daSMike Christie if (session->tt->init_task && session->tt->init_task(task)) 365052d0144SMike Christie return -EIO; 366052d0144SMike Christie 3679c19a7d0SMike Christie task->state = ISCSI_TASK_RUNNING; 36877a23c21SMike Christie 369a8ac6311SOlaf Kirch conn->scsicmd_pdus_cnt++; 3701b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi prep [%s cid %d sc %p cdb 0x%x " 3711b2c7af8SMike Christie "itt 0x%x len %d bidi_len %d cmdsn %d win %d]\n", 3721b2c7af8SMike Christie scsi_bidi_cmnd(sc) ? "bidirectional" : 3731b2c7af8SMike Christie sc->sc_data_direction == DMA_TO_DEVICE ? 3741b2c7af8SMike Christie "write" : "read", conn->id, sc, sc->cmnd[0], 3751b2c7af8SMike Christie task->itt, scsi_bufflen(sc), 3763e5c28adSMike Christie scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0, 3771b2c7af8SMike Christie session->cmdsn, 3781b2c7af8SMike Christie session->max_cmdsn - session->exp_cmdsn + 1); 379004d6530SBoaz Harrosh return 0; 3807996a778SMike Christie } 3817996a778SMike Christie 3827996a778SMike Christie /** 3833bbaaad9SMike Christie * iscsi_free_task - free a task 3849c19a7d0SMike Christie * @task: iscsi cmd task 3857996a778SMike Christie * 3867996a778SMike Christie * Must be called with session lock. 3873e5c28adSMike Christie * This function returns the scsi command to scsi-ml or cleans 3883e5c28adSMike Christie * up mgmt tasks then returns the task to the pool. 3897996a778SMike Christie */ 3903bbaaad9SMike Christie static void iscsi_free_task(struct iscsi_task *task) 3917996a778SMike Christie { 3929c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 393c1635cb7SMike Christie struct iscsi_session *session = conn->session; 3949c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 3957996a778SMike Christie 3964421c9ebSMike Christie ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n", 3974421c9ebSMike Christie task->itt, task->state, task->sc); 3984421c9ebSMike Christie 399577577daSMike Christie session->tt->cleanup_task(task); 4003bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 4019c19a7d0SMike Christie task->sc = NULL; 4023e5c28adSMike Christie /* 4039c19a7d0SMike Christie * login task is preallocated so do not free 4043e5c28adSMike Christie */ 4059c19a7d0SMike Christie if (conn->login_task == task) 4063e5c28adSMike Christie return; 4073e5c28adSMike Christie 4089c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&task, sizeof(void*)); 4093e5c28adSMike Christie 4103e5c28adSMike Christie if (sc) { 4119c19a7d0SMike Christie task->sc = NULL; 412f47f2cf5SMike Christie /* SCSI eh reuses commands to verify us */ 413f47f2cf5SMike Christie sc->SCp.ptr = NULL; 4143e5c28adSMike Christie /* 4153e5c28adSMike Christie * queue command may call this to free the task, but 4163e5c28adSMike Christie * not have setup the sc callback 4173e5c28adSMike Christie */ 418052d0144SMike Christie if (sc->scsi_done) 4197996a778SMike Christie sc->scsi_done(sc); 4207996a778SMike Christie } 4213e5c28adSMike Christie } 4227996a778SMike Christie 423913e5bf4SMike Christie void __iscsi_get_task(struct iscsi_task *task) 42460ecebf5SMike Christie { 4259c19a7d0SMike Christie atomic_inc(&task->refcount); 42660ecebf5SMike Christie } 427913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_get_task); 42860ecebf5SMike Christie 4299c19a7d0SMike Christie static void __iscsi_put_task(struct iscsi_task *task) 43060ecebf5SMike Christie { 4319c19a7d0SMike Christie if (atomic_dec_and_test(&task->refcount)) 4323bbaaad9SMike Christie iscsi_free_task(task); 43360ecebf5SMike Christie } 43460ecebf5SMike Christie 4359c19a7d0SMike Christie void iscsi_put_task(struct iscsi_task *task) 4363e5c28adSMike Christie { 4379c19a7d0SMike Christie struct iscsi_session *session = task->conn->session; 4383e5c28adSMike Christie 4393e5c28adSMike Christie spin_lock_bh(&session->lock); 4409c19a7d0SMike Christie __iscsi_put_task(task); 4413e5c28adSMike Christie spin_unlock_bh(&session->lock); 4423e5c28adSMike Christie } 4439c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_put_task); 4443e5c28adSMike Christie 4453bbaaad9SMike Christie /** 4463bbaaad9SMike Christie * iscsi_complete_task - finish a task 4473bbaaad9SMike Christie * @task: iscsi cmd task 448b3cd5050SMike Christie * @state: state to complete task with 4493bbaaad9SMike Christie * 4503bbaaad9SMike Christie * Must be called with session lock. 451b3a7ea8dSMike Christie */ 452b3cd5050SMike Christie static void iscsi_complete_task(struct iscsi_task *task, int state) 453b3a7ea8dSMike Christie { 4543bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 4553bbaaad9SMike Christie 4564421c9ebSMike Christie ISCSI_DBG_SESSION(conn->session, 4574421c9ebSMike Christie "complete task itt 0x%x state %d sc %p\n", 4584421c9ebSMike Christie task->itt, task->state, task->sc); 459b3cd5050SMike Christie if (task->state == ISCSI_TASK_COMPLETED || 460b3cd5050SMike Christie task->state == ISCSI_TASK_ABRT_TMF || 461b3cd5050SMike Christie task->state == ISCSI_TASK_ABRT_SESS_RECOV) 4623bbaaad9SMike Christie return; 4633bbaaad9SMike Christie WARN_ON_ONCE(task->state == ISCSI_TASK_FREE); 464b3cd5050SMike Christie task->state = state; 4653bbaaad9SMike Christie 4663bbaaad9SMike Christie if (!list_empty(&task->running)) 4673bbaaad9SMike Christie list_del_init(&task->running); 4683bbaaad9SMike Christie 4693bbaaad9SMike Christie if (conn->task == task) 4703bbaaad9SMike Christie conn->task = NULL; 4713bbaaad9SMike Christie 4723bbaaad9SMike Christie if (conn->ping_task == task) 4733bbaaad9SMike Christie conn->ping_task = NULL; 4743bbaaad9SMike Christie 4753bbaaad9SMike Christie /* release get from queueing */ 4763bbaaad9SMike Christie __iscsi_put_task(task); 4773bbaaad9SMike Christie } 4783bbaaad9SMike Christie 4793bbaaad9SMike Christie /* 4803bbaaad9SMike Christie * session lock must be held and if not called for a task that is 4813bbaaad9SMike Christie * still pending or from the xmit thread, then xmit thread must 4823bbaaad9SMike Christie * be suspended. 4833bbaaad9SMike Christie */ 4843bbaaad9SMike Christie static void fail_scsi_task(struct iscsi_task *task, int err) 4853bbaaad9SMike Christie { 4863bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 487b3a7ea8dSMike Christie struct scsi_cmnd *sc; 488b3cd5050SMike Christie int state; 489b3a7ea8dSMike Christie 4903bbaaad9SMike Christie /* 4913bbaaad9SMike Christie * if a command completes and we get a successful tmf response 4923bbaaad9SMike Christie * we will hit this because the scsi eh abort code does not take 4933bbaaad9SMike Christie * a ref to the task. 4943bbaaad9SMike Christie */ 4959c19a7d0SMike Christie sc = task->sc; 496b3a7ea8dSMike Christie if (!sc) 497b3a7ea8dSMike Christie return; 498b3a7ea8dSMike Christie 499b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) { 500b3a7ea8dSMike Christie /* 501b3a7ea8dSMike Christie * cmd never made it to the xmit thread, so we should not count 502b3a7ea8dSMike Christie * the cmd in the sequencing 503b3a7ea8dSMike Christie */ 504b3a7ea8dSMike Christie conn->session->queued_cmdsn--; 505b3cd5050SMike Christie /* it was never sent so just complete like normal */ 506b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 507b3cd5050SMike Christie } else if (err == DID_TRANSPORT_DISRUPTED) 508b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 509b3cd5050SMike Christie else 510b3cd5050SMike Christie state = ISCSI_TASK_ABRT_TMF; 511b3a7ea8dSMike Christie 512b3cd5050SMike Christie sc->result = err << 16; 513c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 514b3a7ea8dSMike Christie scsi_set_resid(sc, scsi_bufflen(sc)); 515c07d4444SBoaz Harrosh else { 516c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 517c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 518c07d4444SBoaz Harrosh } 5193e5c28adSMike Christie 520b3cd5050SMike Christie iscsi_complete_task(task, state); 521b3a7ea8dSMike Christie } 522b3a7ea8dSMike Christie 5233e5c28adSMike Christie static int iscsi_prep_mgmt_task(struct iscsi_conn *conn, 5249c19a7d0SMike Christie struct iscsi_task *task) 525052d0144SMike Christie { 526052d0144SMike Christie struct iscsi_session *session = conn->session; 527577577daSMike Christie struct iscsi_hdr *hdr = task->hdr; 528052d0144SMike Christie struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr; 529052d0144SMike Christie 530052d0144SMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 531052d0144SMike Christie return -ENOTCONN; 532052d0144SMike Christie 533052d0144SMike Christie if (hdr->opcode != (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) && 534052d0144SMike Christie hdr->opcode != (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE)) 535052d0144SMike Christie nop->exp_statsn = cpu_to_be32(conn->exp_statsn); 536052d0144SMike Christie /* 537052d0144SMike Christie * pre-format CmdSN for outgoing PDU. 538052d0144SMike Christie */ 539052d0144SMike Christie nop->cmdsn = cpu_to_be32(session->cmdsn); 540052d0144SMike Christie if (hdr->itt != RESERVED_ITT) { 541052d0144SMike Christie /* 542052d0144SMike Christie * TODO: We always use immediate, so we never hit this. 543052d0144SMike Christie * If we start to send tmfs or nops as non-immediate then 544052d0144SMike Christie * we should start checking the cmdsn numbers for mgmt tasks. 545052d0144SMike Christie */ 546052d0144SMike Christie if (conn->c_stage == ISCSI_CONN_STARTED && 547052d0144SMike Christie !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 548052d0144SMike Christie session->queued_cmdsn++; 549052d0144SMike Christie session->cmdsn++; 550052d0144SMike Christie } 551052d0144SMike Christie } 552052d0144SMike Christie 553ae15f801SMike Christie if (session->tt->init_task && session->tt->init_task(task)) 554ae15f801SMike Christie return -EIO; 555052d0144SMike Christie 556052d0144SMike Christie if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT) 557052d0144SMike Christie session->state = ISCSI_STATE_LOGGING_OUT; 558052d0144SMike Christie 559577577daSMike Christie task->state = ISCSI_TASK_RUNNING; 5601b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "mgmtpdu [op 0x%x hdr->itt 0x%x " 5611b2c7af8SMike Christie "datalen %d]\n", hdr->opcode & ISCSI_OPCODE_MASK, 5621b2c7af8SMike Christie hdr->itt, task->data_count); 563052d0144SMike Christie return 0; 564052d0144SMike Christie } 565052d0144SMike Christie 5669c19a7d0SMike Christie static struct iscsi_task * 567f6d5180cSMike Christie __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 568f6d5180cSMike Christie char *data, uint32_t data_size) 569f6d5180cSMike Christie { 570f6d5180cSMike Christie struct iscsi_session *session = conn->session; 5711336aed1SMike Christie struct iscsi_host *ihost = shost_priv(session->host); 5729c19a7d0SMike Christie struct iscsi_task *task; 573262ef636SMike Christie itt_t itt; 574f6d5180cSMike Christie 575f6d5180cSMike Christie if (session->state == ISCSI_STATE_TERMINATE) 576f6d5180cSMike Christie return NULL; 577f6d5180cSMike Christie 578f6d5180cSMike Christie if (hdr->opcode == (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) || 579f6d5180cSMike Christie hdr->opcode == (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE)) 580f6d5180cSMike Christie /* 581f6d5180cSMike Christie * Login and Text are sent serially, in 582f6d5180cSMike Christie * request-followed-by-response sequence. 5833e5c28adSMike Christie * Same task can be used. Same ITT must be used. 5843e5c28adSMike Christie * Note that login_task is preallocated at conn_create(). 585f6d5180cSMike Christie */ 5869c19a7d0SMike Christie task = conn->login_task; 587f6d5180cSMike Christie else { 58826013ad4SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 58926013ad4SMike Christie return NULL; 59026013ad4SMike Christie 591f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE); 592f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED); 593f6d5180cSMike Christie 5943e5c28adSMike Christie if (!__kfifo_get(session->cmdpool.queue, 5959c19a7d0SMike Christie (void*)&task, sizeof(void*))) 596f6d5180cSMike Christie return NULL; 597f6d5180cSMike Christie } 5983e5c28adSMike Christie /* 5993e5c28adSMike Christie * released in complete pdu for task we expect a response for, and 6003e5c28adSMike Christie * released by the lld when it has transmitted the task for 6013e5c28adSMike Christie * pdus we do not expect a response for. 6023e5c28adSMike Christie */ 6039c19a7d0SMike Christie atomic_set(&task->refcount, 1); 6049c19a7d0SMike Christie task->conn = conn; 6059c19a7d0SMike Christie task->sc = NULL; 6063bbaaad9SMike Christie INIT_LIST_HEAD(&task->running); 6073bbaaad9SMike Christie task->state = ISCSI_TASK_PENDING; 608f6d5180cSMike Christie 609f6d5180cSMike Christie if (data_size) { 6109c19a7d0SMike Christie memcpy(task->data, data, data_size); 6119c19a7d0SMike Christie task->data_count = data_size; 612f6d5180cSMike Christie } else 6139c19a7d0SMike Christie task->data_count = 0; 614f6d5180cSMike Christie 615184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 6162ff79d52SMike Christie if (conn->session->tt->alloc_pdu(task, hdr->opcode)) { 617577577daSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not allocate " 618577577daSMike Christie "pdu for mgmt task.\n"); 6193bbaaad9SMike Christie goto free_task; 620577577daSMike Christie } 621184b57c6SMike Christie } 622184b57c6SMike Christie 623262ef636SMike Christie itt = task->hdr->itt; 624577577daSMike Christie task->hdr_len = sizeof(struct iscsi_hdr); 6259c19a7d0SMike Christie memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr)); 626262ef636SMike Christie 627262ef636SMike Christie if (hdr->itt != RESERVED_ITT) { 628262ef636SMike Christie if (session->tt->parse_pdu_itt) 629262ef636SMike Christie task->hdr->itt = itt; 630262ef636SMike Christie else 631262ef636SMike Christie task->hdr->itt = build_itt(task->itt, 632262ef636SMike Christie task->conn->session->age); 633262ef636SMike Christie } 634262ef636SMike Christie 6351336aed1SMike Christie if (!ihost->workq) { 636577577daSMike Christie if (iscsi_prep_mgmt_task(conn, task)) 637577577daSMike Christie goto free_task; 638052d0144SMike Christie 6399c19a7d0SMike Christie if (session->tt->xmit_task(task)) 640577577daSMike Christie goto free_task; 6413bbaaad9SMike Christie } else { 6423bbaaad9SMike Christie list_add_tail(&task->running, &conn->mgmtqueue); 64332ae763eSMike Christie iscsi_conn_queue_work(conn); 6443bbaaad9SMike Christie } 645052d0144SMike Christie 6469c19a7d0SMike Christie return task; 647577577daSMike Christie 648577577daSMike Christie free_task: 649577577daSMike Christie __iscsi_put_task(task); 650577577daSMike Christie return NULL; 651f6d5180cSMike Christie } 652f6d5180cSMike Christie 653f6d5180cSMike Christie int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr, 654f6d5180cSMike Christie char *data, uint32_t data_size) 655f6d5180cSMike Christie { 656f6d5180cSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 657f6d5180cSMike Christie struct iscsi_session *session = conn->session; 658f6d5180cSMike Christie int err = 0; 659f6d5180cSMike Christie 660f6d5180cSMike Christie spin_lock_bh(&session->lock); 661f6d5180cSMike Christie if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size)) 662f6d5180cSMike Christie err = -EPERM; 663f6d5180cSMike Christie spin_unlock_bh(&session->lock); 664f6d5180cSMike Christie return err; 665f6d5180cSMike Christie } 666f6d5180cSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu); 667f6d5180cSMike Christie 6687996a778SMike Christie /** 6697996a778SMike Christie * iscsi_cmd_rsp - SCSI Command Response processing 6707996a778SMike Christie * @conn: iscsi connection 6717996a778SMike Christie * @hdr: iscsi header 6729c19a7d0SMike Christie * @task: scsi command task 6737996a778SMike Christie * @data: cmd data buffer 6747996a778SMike Christie * @datalen: len of buffer 6757996a778SMike Christie * 6767996a778SMike Christie * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and 6779c19a7d0SMike Christie * then completes the command and task. 6787996a778SMike Christie **/ 67977a23c21SMike Christie static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 6809c19a7d0SMike Christie struct iscsi_task *task, char *data, 6817996a778SMike Christie int datalen) 6827996a778SMike Christie { 6837996a778SMike Christie struct iscsi_cmd_rsp *rhdr = (struct iscsi_cmd_rsp *)hdr; 6847996a778SMike Christie struct iscsi_session *session = conn->session; 6859c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 6867996a778SMike Christie 68777a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr); 6887996a778SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 6897996a778SMike Christie 6907996a778SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 6917996a778SMike Christie 6927996a778SMike Christie if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) { 6937996a778SMike Christie sc->result = DID_ERROR << 16; 6947996a778SMike Christie goto out; 6957996a778SMike Christie } 6967996a778SMike Christie 6977996a778SMike Christie if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) { 6989b80cb4bSMike Christie uint16_t senselen; 6997996a778SMike Christie 7007996a778SMike Christie if (datalen < 2) { 7017996a778SMike Christie invalid_datalen: 702322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 703322d739dSMike Christie "Got CHECK_CONDITION but invalid data " 704322d739dSMike Christie "buffer size of %d\n", datalen); 7057996a778SMike Christie sc->result = DID_BAD_TARGET << 16; 7067996a778SMike Christie goto out; 7077996a778SMike Christie } 7087996a778SMike Christie 7098f333991SHarvey Harrison senselen = get_unaligned_be16(data); 7107996a778SMike Christie if (datalen < senselen) 7117996a778SMike Christie goto invalid_datalen; 7127996a778SMike Christie 7137996a778SMike Christie memcpy(sc->sense_buffer, data + 2, 7149b80cb4bSMike Christie min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 7151b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n", 7161b2c7af8SMike Christie min_t(uint16_t, senselen, 7171b2c7af8SMike Christie SCSI_SENSE_BUFFERSIZE)); 7187996a778SMike Christie } 7197996a778SMike Christie 720c07d4444SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW | 721c07d4444SBoaz Harrosh ISCSI_FLAG_CMD_BIDI_OVERFLOW)) { 722c07d4444SBoaz Harrosh int res_count = be32_to_cpu(rhdr->bi_residual_count); 723c07d4444SBoaz Harrosh 724c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc) && res_count > 0 && 725c07d4444SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_BIDI_OVERFLOW || 726c07d4444SBoaz Harrosh res_count <= scsi_in(sc)->length)) 727c07d4444SBoaz Harrosh scsi_in(sc)->resid = res_count; 728c07d4444SBoaz Harrosh else 729c07d4444SBoaz Harrosh sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 730c07d4444SBoaz Harrosh } 731c07d4444SBoaz Harrosh 7327207fea4SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW | 7337207fea4SBoaz Harrosh ISCSI_FLAG_CMD_OVERFLOW)) { 7347996a778SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 7357996a778SMike Christie 7367207fea4SBoaz Harrosh if (res_count > 0 && 7377207fea4SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 7387207fea4SBoaz Harrosh res_count <= scsi_bufflen(sc))) 739c07d4444SBoaz Harrosh /* write side for bidi or uni-io set_resid */ 7401c138991SFUJITA Tomonori scsi_set_resid(sc, res_count); 7417996a778SMike Christie else 7427996a778SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 743c07d4444SBoaz Harrosh } 7447996a778SMike Christie out: 7453bbaaad9SMike Christie ISCSI_DBG_SESSION(session, "cmd rsp done [sc %p res %d itt 0x%x]\n", 7461b2c7af8SMike Christie sc, sc->result, task->itt); 7477996a778SMike Christie conn->scsirsp_pdus_cnt++; 748b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 7497996a778SMike Christie } 7507996a778SMike Christie 7511d9edf02SMike Christie /** 7521d9edf02SMike Christie * iscsi_data_in_rsp - SCSI Data-In Response processing 7531d9edf02SMike Christie * @conn: iscsi connection 7541d9edf02SMike Christie * @hdr: iscsi pdu 7551d9edf02SMike Christie * @task: scsi command task 7561d9edf02SMike Christie **/ 7571d9edf02SMike Christie static void 7581d9edf02SMike Christie iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 7591d9edf02SMike Christie struct iscsi_task *task) 7601d9edf02SMike Christie { 7611d9edf02SMike Christie struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr; 7621d9edf02SMike Christie struct scsi_cmnd *sc = task->sc; 7631d9edf02SMike Christie 7641d9edf02SMike Christie if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS)) 7651d9edf02SMike Christie return; 7661d9edf02SMike Christie 767edbc9aa0SMike Christie iscsi_update_cmdsn(conn->session, (struct iscsi_nopin *)hdr); 7681d9edf02SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 7691d9edf02SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 7701d9edf02SMike Christie if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW | 7711d9edf02SMike Christie ISCSI_FLAG_DATA_OVERFLOW)) { 7721d9edf02SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 7731d9edf02SMike Christie 7741d9edf02SMike Christie if (res_count > 0 && 7751d9edf02SMike Christie (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 7761d9edf02SMike Christie res_count <= scsi_in(sc)->length)) 7771d9edf02SMike Christie scsi_in(sc)->resid = res_count; 7781d9edf02SMike Christie else 7791d9edf02SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 7801d9edf02SMike Christie } 7811d9edf02SMike Christie 7823bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, "data in with status done " 7833bbaaad9SMike Christie "[sc %p res %d itt 0x%x]\n", 7843bbaaad9SMike Christie sc, sc->result, task->itt); 7851d9edf02SMike Christie conn->scsirsp_pdus_cnt++; 786b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 7871d9edf02SMike Christie } 7881d9edf02SMike Christie 7897ea8b828SMike Christie static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) 7907ea8b828SMike Christie { 7917ea8b828SMike Christie struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; 7927ea8b828SMike Christie 7937ea8b828SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 7947ea8b828SMike Christie conn->tmfrsp_pdus_cnt++; 7957ea8b828SMike Christie 796843c0a8aSMike Christie if (conn->tmf_state != TMF_QUEUED) 7977ea8b828SMike Christie return; 7987ea8b828SMike Christie 7997ea8b828SMike Christie if (tmf->response == ISCSI_TMF_RSP_COMPLETE) 800843c0a8aSMike Christie conn->tmf_state = TMF_SUCCESS; 8017ea8b828SMike Christie else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) 802843c0a8aSMike Christie conn->tmf_state = TMF_NOT_FOUND; 8037ea8b828SMike Christie else 804843c0a8aSMike Christie conn->tmf_state = TMF_FAILED; 8057ea8b828SMike Christie wake_up(&conn->ehwait); 8067ea8b828SMike Christie } 8077ea8b828SMike Christie 808f6d5180cSMike Christie static void iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) 809f6d5180cSMike Christie { 810f6d5180cSMike Christie struct iscsi_nopout hdr; 8119c19a7d0SMike Christie struct iscsi_task *task; 812f6d5180cSMike Christie 8139c19a7d0SMike Christie if (!rhdr && conn->ping_task) 814f6d5180cSMike Christie return; 815f6d5180cSMike Christie 816f6d5180cSMike Christie memset(&hdr, 0, sizeof(struct iscsi_nopout)); 817f6d5180cSMike Christie hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE; 818f6d5180cSMike Christie hdr.flags = ISCSI_FLAG_CMD_FINAL; 819f6d5180cSMike Christie 820f6d5180cSMike Christie if (rhdr) { 821f6d5180cSMike Christie memcpy(hdr.lun, rhdr->lun, 8); 822f6d5180cSMike Christie hdr.ttt = rhdr->ttt; 823f6d5180cSMike Christie hdr.itt = RESERVED_ITT; 824f6d5180cSMike Christie } else 825f6d5180cSMike Christie hdr.ttt = RESERVED_ITT; 826f6d5180cSMike Christie 8279c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0); 8289c19a7d0SMike Christie if (!task) 829322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n"); 830d3acf022SMike Christie else if (!rhdr) { 831d3acf022SMike Christie /* only track our nops */ 832d3acf022SMike Christie conn->ping_task = task; 833d3acf022SMike Christie conn->last_ping = jiffies; 834d3acf022SMike Christie } 835f6d5180cSMike Christie } 836f6d5180cSMike Christie 83762f38300SMike Christie static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 83862f38300SMike Christie char *data, int datalen) 83962f38300SMike Christie { 84062f38300SMike Christie struct iscsi_reject *reject = (struct iscsi_reject *)hdr; 84162f38300SMike Christie struct iscsi_hdr rejected_pdu; 84262f38300SMike Christie 84362f38300SMike Christie conn->exp_statsn = be32_to_cpu(reject->statsn) + 1; 84462f38300SMike Christie 84562f38300SMike Christie if (reject->reason == ISCSI_REASON_DATA_DIGEST_ERROR) { 84662f38300SMike Christie if (ntoh24(reject->dlength) > datalen) 84762f38300SMike Christie return ISCSI_ERR_PROTO; 84862f38300SMike Christie 84962f38300SMike Christie if (ntoh24(reject->dlength) >= sizeof(struct iscsi_hdr)) { 85062f38300SMike Christie memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr)); 851322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 852262ef636SMike Christie "pdu (op 0x%x) rejected " 853262ef636SMike Christie "due to DataDigest error.\n", 85462f38300SMike Christie rejected_pdu.opcode); 85562f38300SMike Christie } 85662f38300SMike Christie } 85762f38300SMike Christie return 0; 85862f38300SMike Christie } 85962f38300SMike Christie 8607996a778SMike Christie /** 861913e5bf4SMike Christie * iscsi_itt_to_task - look up task by itt 862913e5bf4SMike Christie * @conn: iscsi connection 863913e5bf4SMike Christie * @itt: itt 864913e5bf4SMike Christie * 865913e5bf4SMike Christie * This should be used for mgmt tasks like login and nops, or if 866913e5bf4SMike Christie * the LDD's itt space does not include the session age. 867913e5bf4SMike Christie * 868913e5bf4SMike Christie * The session lock must be held. 869913e5bf4SMike Christie */ 8708f9256ceSMike Christie struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt) 871913e5bf4SMike Christie { 872913e5bf4SMike Christie struct iscsi_session *session = conn->session; 873262ef636SMike Christie int i; 874913e5bf4SMike Christie 875913e5bf4SMike Christie if (itt == RESERVED_ITT) 876913e5bf4SMike Christie return NULL; 877913e5bf4SMike Christie 878262ef636SMike Christie if (session->tt->parse_pdu_itt) 879262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, NULL); 880262ef636SMike Christie else 881913e5bf4SMike Christie i = get_itt(itt); 882913e5bf4SMike Christie if (i >= session->cmds_max) 883913e5bf4SMike Christie return NULL; 884913e5bf4SMike Christie 885913e5bf4SMike Christie return session->cmds[i]; 886913e5bf4SMike Christie } 8878f9256ceSMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_task); 888913e5bf4SMike Christie 889913e5bf4SMike Christie /** 8907996a778SMike Christie * __iscsi_complete_pdu - complete pdu 8917996a778SMike Christie * @conn: iscsi conn 8927996a778SMike Christie * @hdr: iscsi header 8937996a778SMike Christie * @data: data buffer 8947996a778SMike Christie * @datalen: len of data buffer 8957996a778SMike Christie * 8967996a778SMike Christie * Completes pdu processing by freeing any resources allocated at 8977996a778SMike Christie * queuecommand or send generic. session lock must be held and verify 8987996a778SMike Christie * itt must have been called. 8997996a778SMike Christie */ 900913e5bf4SMike Christie int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 9017996a778SMike Christie char *data, int datalen) 9027996a778SMike Christie { 9037996a778SMike Christie struct iscsi_session *session = conn->session; 9047996a778SMike Christie int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0; 9059c19a7d0SMike Christie struct iscsi_task *task; 9067996a778SMike Christie uint32_t itt; 9077996a778SMike Christie 908f6d5180cSMike Christie conn->last_recv = jiffies; 9090af967f5SMike Christie rc = iscsi_verify_itt(conn, hdr->itt); 9100af967f5SMike Christie if (rc) 9110af967f5SMike Christie return rc; 9120af967f5SMike Christie 913b4377356SAl Viro if (hdr->itt != RESERVED_ITT) 914b4377356SAl Viro itt = get_itt(hdr->itt); 9157996a778SMike Christie else 916b4377356SAl Viro itt = ~0U; 9177996a778SMike Christie 9181b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "[op 0x%x cid %d itt 0x%x len %d]\n", 9193e5c28adSMike Christie opcode, conn->id, itt, datalen); 9207996a778SMike Christie 9213e5c28adSMike Christie if (itt == ~0U) { 92277a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 92362f38300SMike Christie 9247996a778SMike Christie switch(opcode) { 9257996a778SMike Christie case ISCSI_OP_NOOP_IN: 92640527afeSMike Christie if (datalen) { 92740527afeSMike Christie rc = ISCSI_ERR_PROTO; 92840527afeSMike Christie break; 92940527afeSMike Christie } 93040527afeSMike Christie 931b4377356SAl Viro if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) 93240527afeSMike Christie break; 93340527afeSMike Christie 934f6d5180cSMike Christie iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr); 9357996a778SMike Christie break; 9367996a778SMike Christie case ISCSI_OP_REJECT: 93762f38300SMike Christie rc = iscsi_handle_reject(conn, hdr, data, datalen); 93862f38300SMike Christie break; 9397996a778SMike Christie case ISCSI_OP_ASYNC_EVENT: 9408d2860b3SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 9415831c737SMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 9425831c737SMike Christie rc = ISCSI_ERR_CONN_FAILED; 9437996a778SMike Christie break; 9447996a778SMike Christie default: 9457996a778SMike Christie rc = ISCSI_ERR_BAD_OPCODE; 9467996a778SMike Christie break; 9477996a778SMike Christie } 9483e5c28adSMike Christie goto out; 9493e5c28adSMike Christie } 9507996a778SMike Christie 9513e5c28adSMike Christie switch(opcode) { 9523e5c28adSMike Christie case ISCSI_OP_SCSI_CMD_RSP: 953913e5bf4SMike Christie case ISCSI_OP_SCSI_DATA_IN: 954913e5bf4SMike Christie task = iscsi_itt_to_ctask(conn, hdr->itt); 955913e5bf4SMike Christie if (!task) 956913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 957d355e57dSMike Christie task->last_xfer = jiffies; 9583e5c28adSMike Christie break; 959913e5bf4SMike Christie case ISCSI_OP_R2T: 960913e5bf4SMike Christie /* 961913e5bf4SMike Christie * LLD handles R2Ts if they need to. 962913e5bf4SMike Christie */ 963913e5bf4SMike Christie return 0; 964913e5bf4SMike Christie case ISCSI_OP_LOGOUT_RSP: 965913e5bf4SMike Christie case ISCSI_OP_LOGIN_RSP: 966913e5bf4SMike Christie case ISCSI_OP_TEXT_RSP: 967913e5bf4SMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 968913e5bf4SMike Christie case ISCSI_OP_NOOP_IN: 969913e5bf4SMike Christie task = iscsi_itt_to_task(conn, hdr->itt); 970913e5bf4SMike Christie if (!task) 971913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 972913e5bf4SMike Christie break; 973913e5bf4SMike Christie default: 974913e5bf4SMike Christie return ISCSI_ERR_BAD_OPCODE; 9753e5c28adSMike Christie } 976913e5bf4SMike Christie 977913e5bf4SMike Christie switch(opcode) { 978913e5bf4SMike Christie case ISCSI_OP_SCSI_CMD_RSP: 9799c19a7d0SMike Christie iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen); 9803e5c28adSMike Christie break; 9813e5c28adSMike Christie case ISCSI_OP_SCSI_DATA_IN: 9821d9edf02SMike Christie iscsi_data_in_rsp(conn, hdr, task); 9833e5c28adSMike Christie break; 9843e5c28adSMike Christie case ISCSI_OP_LOGOUT_RSP: 9853e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 9863e5c28adSMike Christie if (datalen) { 9873e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 9883e5c28adSMike Christie break; 9893e5c28adSMike Christie } 9903e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 9913e5c28adSMike Christie goto recv_pdu; 9923e5c28adSMike Christie case ISCSI_OP_LOGIN_RSP: 9933e5c28adSMike Christie case ISCSI_OP_TEXT_RSP: 9943e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 9953e5c28adSMike Christie /* 9963e5c28adSMike Christie * login related PDU's exp_statsn is handled in 9973e5c28adSMike Christie * userspace 9983e5c28adSMike Christie */ 9993e5c28adSMike Christie goto recv_pdu; 10003e5c28adSMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 10013e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 10023e5c28adSMike Christie if (datalen) { 10033e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 10043e5c28adSMike Christie break; 10053e5c28adSMike Christie } 10063e5c28adSMike Christie 10073e5c28adSMike Christie iscsi_tmf_rsp(conn, hdr); 1008b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 10093e5c28adSMike Christie break; 10103e5c28adSMike Christie case ISCSI_OP_NOOP_IN: 10113e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 10123e5c28adSMike Christie if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) { 10133e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 10143e5c28adSMike Christie break; 10153e5c28adSMike Christie } 10163e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 10173e5c28adSMike Christie 10189c19a7d0SMike Christie if (conn->ping_task != task) 10193e5c28adSMike Christie /* 10203e5c28adSMike Christie * If this is not in response to one of our 10213e5c28adSMike Christie * nops then it must be from userspace. 10223e5c28adSMike Christie */ 10233e5c28adSMike Christie goto recv_pdu; 10249c19a7d0SMike Christie 10259c19a7d0SMike Christie mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout); 1026b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 10273e5c28adSMike Christie break; 10283e5c28adSMike Christie default: 10293e5c28adSMike Christie rc = ISCSI_ERR_BAD_OPCODE; 10303e5c28adSMike Christie break; 10313e5c28adSMike Christie } 10323e5c28adSMike Christie 10333e5c28adSMike Christie out: 10343e5c28adSMike Christie return rc; 10353e5c28adSMike Christie recv_pdu: 10363e5c28adSMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 10373e5c28adSMike Christie rc = ISCSI_ERR_CONN_FAILED; 1038b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 10397996a778SMike Christie return rc; 10407996a778SMike Christie } 1041913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_complete_pdu); 10427996a778SMike Christie 10437996a778SMike Christie int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 10447996a778SMike Christie char *data, int datalen) 10457996a778SMike Christie { 10467996a778SMike Christie int rc; 10477996a778SMike Christie 10487996a778SMike Christie spin_lock(&conn->session->lock); 10497996a778SMike Christie rc = __iscsi_complete_pdu(conn, hdr, data, datalen); 10507996a778SMike Christie spin_unlock(&conn->session->lock); 10517996a778SMike Christie return rc; 10527996a778SMike Christie } 10537996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_pdu); 10547996a778SMike Christie 10550af967f5SMike Christie int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt) 10567996a778SMike Christie { 10577996a778SMike Christie struct iscsi_session *session = conn->session; 1058262ef636SMike Christie int age = 0, i = 0; 10597996a778SMike Christie 10600af967f5SMike Christie if (itt == RESERVED_ITT) 10610af967f5SMike Christie return 0; 10620af967f5SMike Christie 1063262ef636SMike Christie if (session->tt->parse_pdu_itt) 1064262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, &age); 1065262ef636SMike Christie else { 1066262ef636SMike Christie i = get_itt(itt); 1067262ef636SMike Christie age = ((__force u32)itt >> ISCSI_AGE_SHIFT) & ISCSI_AGE_MASK; 1068262ef636SMike Christie } 1069262ef636SMike Christie 1070262ef636SMike Christie if (age != session->age) { 1071322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 10720af967f5SMike Christie "received itt %x expected session age (%x)\n", 1073913e5bf4SMike Christie (__force u32)itt, session->age); 10747996a778SMike Christie return ISCSI_ERR_BAD_ITT; 10757996a778SMike Christie } 10767996a778SMike Christie 10773e5c28adSMike Christie if (i >= session->cmds_max) { 10783e5c28adSMike Christie iscsi_conn_printk(KERN_ERR, conn, 10793e5c28adSMike Christie "received invalid itt index %u (max cmds " 10803e5c28adSMike Christie "%u.\n", i, session->cmds_max); 10813e5c28adSMike Christie return ISCSI_ERR_BAD_ITT; 10827996a778SMike Christie } 10837996a778SMike Christie return 0; 10847996a778SMike Christie } 10857996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_verify_itt); 10867996a778SMike Christie 1087913e5bf4SMike Christie /** 1088913e5bf4SMike Christie * iscsi_itt_to_ctask - look up ctask by itt 1089913e5bf4SMike Christie * @conn: iscsi connection 1090913e5bf4SMike Christie * @itt: itt 1091913e5bf4SMike Christie * 1092913e5bf4SMike Christie * This should be used for cmd tasks. 1093913e5bf4SMike Christie * 1094913e5bf4SMike Christie * The session lock must be held. 1095913e5bf4SMike Christie */ 1096913e5bf4SMike Christie struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt) 10970af967f5SMike Christie { 10989c19a7d0SMike Christie struct iscsi_task *task; 10990af967f5SMike Christie 11000af967f5SMike Christie if (iscsi_verify_itt(conn, itt)) 11010af967f5SMike Christie return NULL; 11020af967f5SMike Christie 1103913e5bf4SMike Christie task = iscsi_itt_to_task(conn, itt); 1104913e5bf4SMike Christie if (!task || !task->sc) 11050af967f5SMike Christie return NULL; 11060af967f5SMike Christie 1107913e5bf4SMike Christie if (task->sc->SCp.phase != conn->session->age) { 1108913e5bf4SMike Christie iscsi_session_printk(KERN_ERR, conn->session, 1109913e5bf4SMike Christie "task's session age %d, expected %d\n", 1110913e5bf4SMike Christie task->sc->SCp.phase, conn->session->age); 11110af967f5SMike Christie return NULL; 1112913e5bf4SMike Christie } 11130af967f5SMike Christie 11149c19a7d0SMike Christie return task; 11150af967f5SMike Christie } 11160af967f5SMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask); 11170af967f5SMike Christie 111840a06e75SMike Christie void iscsi_session_failure(struct iscsi_session *session, 1119e5bd7b54SMike Christie enum iscsi_err err) 1120e5bd7b54SMike Christie { 1121e5bd7b54SMike Christie struct iscsi_conn *conn; 1122e5bd7b54SMike Christie struct device *dev; 1123e5bd7b54SMike Christie unsigned long flags; 1124e5bd7b54SMike Christie 1125e5bd7b54SMike Christie spin_lock_irqsave(&session->lock, flags); 1126e5bd7b54SMike Christie conn = session->leadconn; 1127e5bd7b54SMike Christie if (session->state == ISCSI_STATE_TERMINATE || !conn) { 1128e5bd7b54SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1129e5bd7b54SMike Christie return; 1130e5bd7b54SMike Christie } 1131e5bd7b54SMike Christie 1132e5bd7b54SMike Christie dev = get_device(&conn->cls_conn->dev); 1133e5bd7b54SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1134e5bd7b54SMike Christie if (!dev) 1135e5bd7b54SMike Christie return; 1136e5bd7b54SMike Christie /* 1137e5bd7b54SMike Christie * if the host is being removed bypass the connection 1138e5bd7b54SMike Christie * recovery initialization because we are going to kill 1139e5bd7b54SMike Christie * the session. 1140e5bd7b54SMike Christie */ 1141e5bd7b54SMike Christie if (err == ISCSI_ERR_INVALID_HOST) 1142e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 1143e5bd7b54SMike Christie else 1144e5bd7b54SMike Christie iscsi_conn_failure(conn, err); 1145e5bd7b54SMike Christie put_device(dev); 1146e5bd7b54SMike Christie } 1147e5bd7b54SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_failure); 1148e5bd7b54SMike Christie 11497996a778SMike Christie void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err) 11507996a778SMike Christie { 11517996a778SMike Christie struct iscsi_session *session = conn->session; 11527996a778SMike Christie unsigned long flags; 11537996a778SMike Christie 11547996a778SMike Christie spin_lock_irqsave(&session->lock, flags); 1155656cffc9SMike Christie if (session->state == ISCSI_STATE_FAILED) { 1156656cffc9SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1157656cffc9SMike Christie return; 1158656cffc9SMike Christie } 1159656cffc9SMike Christie 116067a61114SMike Christie if (conn->stop_stage == 0) 11617996a778SMike Christie session->state = ISCSI_STATE_FAILED; 11627996a778SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1163e5bd7b54SMike Christie 11647996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 11657996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 1166e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 11677996a778SMike Christie } 11687996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_failure); 11697996a778SMike Christie 117077a23c21SMike Christie static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn) 117177a23c21SMike Christie { 117277a23c21SMike Christie struct iscsi_session *session = conn->session; 117377a23c21SMike Christie 117477a23c21SMike Christie /* 117577a23c21SMike Christie * Check for iSCSI window and take care of CmdSN wrap-around 117677a23c21SMike Christie */ 1177e0726407SMike Christie if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) { 11781b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iSCSI CmdSN closed. ExpCmdSn " 11791b2c7af8SMike Christie "%u MaxCmdSN %u CmdSN %u/%u\n", 11801b2c7af8SMike Christie session->exp_cmdsn, session->max_cmdsn, 11811b2c7af8SMike Christie session->cmdsn, session->queued_cmdsn); 118277a23c21SMike Christie return -ENOSPC; 118377a23c21SMike Christie } 118477a23c21SMike Christie return 0; 118577a23c21SMike Christie } 118677a23c21SMike Christie 11879c19a7d0SMike Christie static int iscsi_xmit_task(struct iscsi_conn *conn) 118877a23c21SMike Christie { 11899c19a7d0SMike Christie struct iscsi_task *task = conn->task; 1190843c0a8aSMike Christie int rc; 119177a23c21SMike Christie 11929c19a7d0SMike Christie __iscsi_get_task(task); 119377a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 11949c19a7d0SMike Christie rc = conn->session->tt->xmit_task(task); 119577a23c21SMike Christie spin_lock_bh(&conn->session->lock); 1196d355e57dSMike Christie if (!rc) { 11979c19a7d0SMike Christie /* done with this task */ 1198d355e57dSMike Christie task->last_xfer = jiffies; 11999c19a7d0SMike Christie conn->task = NULL; 1200d355e57dSMike Christie } 1201d355e57dSMike Christie __iscsi_put_task(task); 120277a23c21SMike Christie return rc; 120377a23c21SMike Christie } 120477a23c21SMike Christie 12057996a778SMike Christie /** 12069c19a7d0SMike Christie * iscsi_requeue_task - requeue task to run from session workqueue 12079c19a7d0SMike Christie * @task: task to requeue 1208843c0a8aSMike Christie * 12099c19a7d0SMike Christie * LLDs that need to run a task from the session workqueue should call 1210052d0144SMike Christie * this. The session lock must be held. This should only be called 1211052d0144SMike Christie * by software drivers. 1212843c0a8aSMike Christie */ 12139c19a7d0SMike Christie void iscsi_requeue_task(struct iscsi_task *task) 1214843c0a8aSMike Christie { 12159c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 1216843c0a8aSMike Christie 12173bbaaad9SMike Christie /* 12183bbaaad9SMike Christie * this may be on the requeue list already if the xmit_task callout 12193bbaaad9SMike Christie * is handling the r2ts while we are adding new ones 12203bbaaad9SMike Christie */ 12213bbaaad9SMike Christie if (list_empty(&task->running)) 12223bbaaad9SMike Christie list_add_tail(&task->running, &conn->requeue); 122332ae763eSMike Christie iscsi_conn_queue_work(conn); 1224843c0a8aSMike Christie } 12259c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_requeue_task); 1226843c0a8aSMike Christie 1227843c0a8aSMike Christie /** 12287996a778SMike Christie * iscsi_data_xmit - xmit any command into the scheduled connection 12297996a778SMike Christie * @conn: iscsi connection 12307996a778SMike Christie * 12317996a778SMike Christie * Notes: 12327996a778SMike Christie * The function can return -EAGAIN in which case the caller must 12337996a778SMike Christie * re-schedule it again later or recover. '0' return code means 12347996a778SMike Christie * successful xmit. 12357996a778SMike Christie **/ 12367996a778SMike Christie static int iscsi_data_xmit(struct iscsi_conn *conn) 12377996a778SMike Christie { 12383219e529SMike Christie int rc = 0; 12397996a778SMike Christie 124077a23c21SMike Christie spin_lock_bh(&conn->session->lock); 12417996a778SMike Christie if (unlikely(conn->suspend_tx)) { 12421b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n"); 124377a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 12443219e529SMike Christie return -ENODATA; 12457996a778SMike Christie } 12467996a778SMike Christie 12479c19a7d0SMike Christie if (conn->task) { 12489c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 12493219e529SMike Christie if (rc) 12507996a778SMike Christie goto again; 12517996a778SMike Christie } 125277a23c21SMike Christie 125377a23c21SMike Christie /* 125477a23c21SMike Christie * process mgmt pdus like nops before commands since we should 125577a23c21SMike Christie * only have one nop-out as a ping from us and targets should not 125677a23c21SMike Christie * overflow us with nop-ins 125777a23c21SMike Christie */ 125877a23c21SMike Christie check_mgmt: 1259843c0a8aSMike Christie while (!list_empty(&conn->mgmtqueue)) { 12609c19a7d0SMike Christie conn->task = list_entry(conn->mgmtqueue.next, 12619c19a7d0SMike Christie struct iscsi_task, running); 12623bbaaad9SMike Christie list_del_init(&conn->task->running); 12639c19a7d0SMike Christie if (iscsi_prep_mgmt_task(conn, conn->task)) { 12649c19a7d0SMike Christie __iscsi_put_task(conn->task); 12659c19a7d0SMike Christie conn->task = NULL; 1266b3a7ea8dSMike Christie continue; 1267b3a7ea8dSMike Christie } 12689c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 12693219e529SMike Christie if (rc) 12707996a778SMike Christie goto again; 12717996a778SMike Christie } 12727996a778SMike Christie 1273843c0a8aSMike Christie /* process pending command queue */ 12743bbaaad9SMike Christie while (!list_empty(&conn->cmdqueue)) { 1275843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) 1276843c0a8aSMike Christie break; 1277843c0a8aSMike Christie 12783bbaaad9SMike Christie conn->task = list_entry(conn->cmdqueue.next, 12799c19a7d0SMike Christie struct iscsi_task, running); 12803bbaaad9SMike Christie list_del_init(&conn->task->running); 1281b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) { 1282b3cd5050SMike Christie fail_scsi_task(conn->task, DID_IMM_RETRY); 1283b3a7ea8dSMike Christie continue; 1284b3a7ea8dSMike Christie } 1285577577daSMike Christie rc = iscsi_prep_scsi_cmd_pdu(conn->task); 1286577577daSMike Christie if (rc) { 1287577577daSMike Christie if (rc == -ENOMEM) { 12883bbaaad9SMike Christie list_add_tail(&conn->task->running, 12893bbaaad9SMike Christie &conn->cmdqueue); 1290577577daSMike Christie conn->task = NULL; 1291577577daSMike Christie goto again; 1292577577daSMike Christie } else 1293b3cd5050SMike Christie fail_scsi_task(conn->task, DID_ABORT); 1294004d6530SBoaz Harrosh continue; 1295004d6530SBoaz Harrosh } 12969c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 12973219e529SMike Christie if (rc) 12987996a778SMike Christie goto again; 129977a23c21SMike Christie /* 13009c19a7d0SMike Christie * we could continuously get new task requests so 130177a23c21SMike Christie * we need to check the mgmt queue for nops that need to 130277a23c21SMike Christie * be sent to aviod starvation 130377a23c21SMike Christie */ 1304843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 1305843c0a8aSMike Christie goto check_mgmt; 1306843c0a8aSMike Christie } 1307843c0a8aSMike Christie 1308843c0a8aSMike Christie while (!list_empty(&conn->requeue)) { 1309843c0a8aSMike Christie if (conn->session->fast_abort && conn->tmf_state != TMF_INITIAL) 1310843c0a8aSMike Christie break; 1311843c0a8aSMike Christie 1312b3a7ea8dSMike Christie /* 1313b3a7ea8dSMike Christie * we always do fastlogout - conn stop code will clean up. 1314b3a7ea8dSMike Christie */ 1315b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 1316b3a7ea8dSMike Christie break; 1317b3a7ea8dSMike Christie 13189c19a7d0SMike Christie conn->task = list_entry(conn->requeue.next, 13199c19a7d0SMike Christie struct iscsi_task, running); 13203bbaaad9SMike Christie list_del_init(&conn->task->running); 13219c19a7d0SMike Christie conn->task->state = ISCSI_TASK_RUNNING; 13229c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 1323843c0a8aSMike Christie if (rc) 1324843c0a8aSMike Christie goto again; 1325843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 132677a23c21SMike Christie goto check_mgmt; 13277996a778SMike Christie } 132877a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 13293219e529SMike Christie return -ENODATA; 13307996a778SMike Christie 13317996a778SMike Christie again: 13327996a778SMike Christie if (unlikely(conn->suspend_tx)) 133377a23c21SMike Christie rc = -ENODATA; 133477a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 13353219e529SMike Christie return rc; 13367996a778SMike Christie } 13377996a778SMike Christie 1338c4028958SDavid Howells static void iscsi_xmitworker(struct work_struct *work) 13397996a778SMike Christie { 1340c4028958SDavid Howells struct iscsi_conn *conn = 1341c4028958SDavid Howells container_of(work, struct iscsi_conn, xmitwork); 13423219e529SMike Christie int rc; 13437996a778SMike Christie /* 13447996a778SMike Christie * serialize Xmit worker on a per-connection basis. 13457996a778SMike Christie */ 13463219e529SMike Christie do { 13473219e529SMike Christie rc = iscsi_data_xmit(conn); 13483219e529SMike Christie } while (rc >= 0 || rc == -EAGAIN); 13497996a778SMike Christie } 13507996a778SMike Christie 1351577577daSMike Christie static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn, 1352577577daSMike Christie struct scsi_cmnd *sc) 1353577577daSMike Christie { 1354577577daSMike Christie struct iscsi_task *task; 1355577577daSMike Christie 1356577577daSMike Christie if (!__kfifo_get(conn->session->cmdpool.queue, 1357577577daSMike Christie (void *) &task, sizeof(void *))) 1358577577daSMike Christie return NULL; 1359577577daSMike Christie 1360577577daSMike Christie sc->SCp.phase = conn->session->age; 1361577577daSMike Christie sc->SCp.ptr = (char *) task; 1362577577daSMike Christie 1363577577daSMike Christie atomic_set(&task->refcount, 1); 1364577577daSMike Christie task->state = ISCSI_TASK_PENDING; 1365577577daSMike Christie task->conn = conn; 1366577577daSMike Christie task->sc = sc; 1367d355e57dSMike Christie task->have_checked_conn = false; 1368d355e57dSMike Christie task->last_timeout = jiffies; 1369d355e57dSMike Christie task->last_xfer = jiffies; 1370577577daSMike Christie INIT_LIST_HEAD(&task->running); 1371577577daSMike Christie return task; 1372577577daSMike Christie } 1373577577daSMike Christie 13747996a778SMike Christie enum { 13757996a778SMike Christie FAILURE_BAD_HOST = 1, 13767996a778SMike Christie FAILURE_SESSION_FAILED, 13777996a778SMike Christie FAILURE_SESSION_FREED, 13787996a778SMike Christie FAILURE_WINDOW_CLOSED, 137960ecebf5SMike Christie FAILURE_OOM, 13807996a778SMike Christie FAILURE_SESSION_TERMINATE, 1381656cffc9SMike Christie FAILURE_SESSION_IN_RECOVERY, 13827996a778SMike Christie FAILURE_SESSION_RECOVERY_TIMEOUT, 1383b3a7ea8dSMike Christie FAILURE_SESSION_LOGGING_OUT, 13846eabafbeSMike Christie FAILURE_SESSION_NOT_READY, 13857996a778SMike Christie }; 13867996a778SMike Christie 13877996a778SMike Christie int iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *)) 13887996a778SMike Christie { 138975613521SMike Christie struct iscsi_cls_session *cls_session; 13907996a778SMike Christie struct Scsi_Host *host; 13911336aed1SMike Christie struct iscsi_host *ihost; 13927996a778SMike Christie int reason = 0; 13937996a778SMike Christie struct iscsi_session *session; 13947996a778SMike Christie struct iscsi_conn *conn; 13959c19a7d0SMike Christie struct iscsi_task *task = NULL; 13967996a778SMike Christie 13977996a778SMike Christie sc->scsi_done = done; 13987996a778SMike Christie sc->result = 0; 1399f47f2cf5SMike Christie sc->SCp.ptr = NULL; 14007996a778SMike Christie 14017996a778SMike Christie host = sc->device->host; 14021336aed1SMike Christie ihost = shost_priv(host); 14031040c99dSMike Christie spin_unlock(host->host_lock); 14047996a778SMike Christie 140575613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 140675613521SMike Christie session = cls_session->dd_data; 14077996a778SMike Christie spin_lock(&session->lock); 14087996a778SMike Christie 140975613521SMike Christie reason = iscsi_session_chkready(cls_session); 14106eabafbeSMike Christie if (reason) { 14116eabafbeSMike Christie sc->result = reason; 14126eabafbeSMike Christie goto fault; 14136eabafbeSMike Christie } 14146eabafbeSMike Christie 1415301e0f7eSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1416656cffc9SMike Christie /* 1417656cffc9SMike Christie * to handle the race between when we set the recovery state 1418656cffc9SMike Christie * and block the session we requeue here (commands could 1419656cffc9SMike Christie * be entering our queuecommand while a block is starting 1420656cffc9SMike Christie * up because the block code is not locked) 1421656cffc9SMike Christie */ 14229000bcd6SMike Christie switch (session->state) { 1423301e0f7eSMike Christie case ISCSI_STATE_FAILED: 14249000bcd6SMike Christie case ISCSI_STATE_IN_RECOVERY: 1425656cffc9SMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1426301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1427301e0f7eSMike Christie break; 14289000bcd6SMike Christie case ISCSI_STATE_LOGGING_OUT: 14299000bcd6SMike Christie reason = FAILURE_SESSION_LOGGING_OUT; 1430301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1431301e0f7eSMike Christie break; 1432b3a7ea8dSMike Christie case ISCSI_STATE_RECOVERY_FAILED: 1433656cffc9SMike Christie reason = FAILURE_SESSION_RECOVERY_TIMEOUT; 143456d7fcfaSMike Christie sc->result = DID_TRANSPORT_FAILFAST << 16; 1435b3a7ea8dSMike Christie break; 1436b3a7ea8dSMike Christie case ISCSI_STATE_TERMINATE: 1437656cffc9SMike Christie reason = FAILURE_SESSION_TERMINATE; 14386eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1439b3a7ea8dSMike Christie break; 1440b3a7ea8dSMike Christie default: 14417996a778SMike Christie reason = FAILURE_SESSION_FREED; 14426eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1443b3a7ea8dSMike Christie } 14447996a778SMike Christie goto fault; 14457996a778SMike Christie } 14467996a778SMike Christie 14477996a778SMike Christie conn = session->leadconn; 144898644047SMike Christie if (!conn) { 144998644047SMike Christie reason = FAILURE_SESSION_FREED; 14506eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 145198644047SMike Christie goto fault; 145298644047SMike Christie } 14537996a778SMike Christie 145477a23c21SMike Christie if (iscsi_check_cmdsn_window_closed(conn)) { 145577a23c21SMike Christie reason = FAILURE_WINDOW_CLOSED; 145677a23c21SMike Christie goto reject; 145777a23c21SMike Christie } 145877a23c21SMike Christie 1459577577daSMike Christie task = iscsi_alloc_task(conn, sc); 1460577577daSMike Christie if (!task) { 146160ecebf5SMike Christie reason = FAILURE_OOM; 146260ecebf5SMike Christie goto reject; 146360ecebf5SMike Christie } 14647996a778SMike Christie 14651336aed1SMike Christie if (!ihost->workq) { 1466577577daSMike Christie reason = iscsi_prep_scsi_cmd_pdu(task); 1467577577daSMike Christie if (reason) { 1468577577daSMike Christie if (reason == -ENOMEM) { 1469577577daSMike Christie reason = FAILURE_OOM; 1470577577daSMike Christie goto prepd_reject; 1471577577daSMike Christie } else { 1472052d0144SMike Christie sc->result = DID_ABORT << 16; 1473577577daSMike Christie goto prepd_fault; 1474577577daSMike Christie } 1475052d0144SMike Christie } 14769c19a7d0SMike Christie if (session->tt->xmit_task(task)) { 1477052d0144SMike Christie reason = FAILURE_SESSION_NOT_READY; 1478577577daSMike Christie goto prepd_reject; 1479052d0144SMike Christie } 14803bbaaad9SMike Christie } else { 14813bbaaad9SMike Christie list_add_tail(&task->running, &conn->cmdqueue); 148232ae763eSMike Christie iscsi_conn_queue_work(conn); 14833bbaaad9SMike Christie } 1484052d0144SMike Christie 1485052d0144SMike Christie session->queued_cmdsn++; 1486052d0144SMike Christie spin_unlock(&session->lock); 14871040c99dSMike Christie spin_lock(host->host_lock); 14887996a778SMike Christie return 0; 14897996a778SMike Christie 1490577577daSMike Christie prepd_reject: 1491577577daSMike Christie sc->scsi_done = NULL; 1492b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 14937996a778SMike Christie reject: 14947996a778SMike Christie spin_unlock(&session->lock); 14951b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n", 14961b2c7af8SMike Christie sc->cmnd[0], reason); 14971040c99dSMike Christie spin_lock(host->host_lock); 1498d6d13ee1SMike Christie return SCSI_MLQUEUE_TARGET_BUSY; 14997996a778SMike Christie 1500577577daSMike Christie prepd_fault: 1501577577daSMike Christie sc->scsi_done = NULL; 1502b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 15037996a778SMike Christie fault: 15047996a778SMike Christie spin_unlock(&session->lock); 15051b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n", 15061b2c7af8SMike Christie sc->cmnd[0], reason); 1507c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 15081c138991SFUJITA Tomonori scsi_set_resid(sc, scsi_bufflen(sc)); 1509c07d4444SBoaz Harrosh else { 1510c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 1511c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 1512c07d4444SBoaz Harrosh } 1513052d0144SMike Christie done(sc); 15141040c99dSMike Christie spin_lock(host->host_lock); 15157996a778SMike Christie return 0; 15167996a778SMike Christie } 15177996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_queuecommand); 15187996a778SMike Christie 15197996a778SMike Christie int iscsi_change_queue_depth(struct scsi_device *sdev, int depth) 15207996a778SMike Christie { 15217996a778SMike Christie scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); 15227996a778SMike Christie return sdev->queue_depth; 15237996a778SMike Christie } 15247996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_change_queue_depth); 15257996a778SMike Christie 15266b5d6c44SMike Christie int iscsi_target_alloc(struct scsi_target *starget) 15276b5d6c44SMike Christie { 15286b5d6c44SMike Christie struct iscsi_cls_session *cls_session = starget_to_session(starget); 15296b5d6c44SMike Christie struct iscsi_session *session = cls_session->dd_data; 15306b5d6c44SMike Christie 15316b5d6c44SMike Christie starget->can_queue = session->scsi_cmds_max; 15326b5d6c44SMike Christie return 0; 15336b5d6c44SMike Christie } 15346b5d6c44SMike Christie EXPORT_SYMBOL_GPL(iscsi_target_alloc); 15356b5d6c44SMike Christie 15367996a778SMike Christie void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) 15377996a778SMike Christie { 153875613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 15397996a778SMike Christie 15407996a778SMike Christie spin_lock_bh(&session->lock); 15417996a778SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1542656cffc9SMike Christie session->state = ISCSI_STATE_RECOVERY_FAILED; 1543843c0a8aSMike Christie if (session->leadconn) 1544843c0a8aSMike Christie wake_up(&session->leadconn->ehwait); 15457996a778SMike Christie } 15467996a778SMike Christie spin_unlock_bh(&session->lock); 15477996a778SMike Christie } 15487996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout); 15497996a778SMike Christie 15508e124525SMike Christie int iscsi_eh_target_reset(struct scsi_cmnd *sc) 15517996a778SMike Christie { 155275613521SMike Christie struct iscsi_cls_session *cls_session; 155375613521SMike Christie struct iscsi_session *session; 155475613521SMike Christie struct iscsi_conn *conn; 155575613521SMike Christie 155675613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 155775613521SMike Christie session = cls_session->dd_data; 155875613521SMike Christie conn = session->leadconn; 15597996a778SMike Christie 1560bc436b27SMike Christie mutex_lock(&session->eh_mutex); 15617996a778SMike Christie spin_lock_bh(&session->lock); 15627996a778SMike Christie if (session->state == ISCSI_STATE_TERMINATE) { 15637996a778SMike Christie failed: 15641b2c7af8SMike Christie iscsi_session_printk(KERN_INFO, session, 15651b2c7af8SMike Christie "failing target reset: Could not log " 15661b2c7af8SMike Christie "back into target [age %d]\n", 15671b2c7af8SMike Christie session->age); 15687996a778SMike Christie spin_unlock_bh(&session->lock); 1569bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 15707996a778SMike Christie return FAILED; 15717996a778SMike Christie } 15727996a778SMike Christie 15737996a778SMike Christie spin_unlock_bh(&session->lock); 1574bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 15757996a778SMike Christie /* 15767996a778SMike Christie * we drop the lock here but the leadconn cannot be destoyed while 15777996a778SMike Christie * we are in the scsi eh 15787996a778SMike Christie */ 15797996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 15807996a778SMike Christie 15811b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "wait for relogin\n"); 15827996a778SMike Christie wait_event_interruptible(conn->ehwait, 15837996a778SMike Christie session->state == ISCSI_STATE_TERMINATE || 15847996a778SMike Christie session->state == ISCSI_STATE_LOGGED_IN || 1585656cffc9SMike Christie session->state == ISCSI_STATE_RECOVERY_FAILED); 15867996a778SMike Christie if (signal_pending(current)) 15877996a778SMike Christie flush_signals(current); 15887996a778SMike Christie 1589bc436b27SMike Christie mutex_lock(&session->eh_mutex); 15907996a778SMike Christie spin_lock_bh(&session->lock); 15917996a778SMike Christie if (session->state == ISCSI_STATE_LOGGED_IN) 1592322d739dSMike Christie iscsi_session_printk(KERN_INFO, session, 15938e124525SMike Christie "target reset succeeded\n"); 15947996a778SMike Christie else 15957996a778SMike Christie goto failed; 15967996a778SMike Christie spin_unlock_bh(&session->lock); 1597bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 15987996a778SMike Christie return SUCCESS; 15997996a778SMike Christie } 16008e124525SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_target_reset); 16017996a778SMike Christie 1602843c0a8aSMike Christie static void iscsi_tmf_timedout(unsigned long data) 16037996a778SMike Christie { 1604843c0a8aSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 16057996a778SMike Christie struct iscsi_session *session = conn->session; 16067996a778SMike Christie 16077996a778SMike Christie spin_lock(&session->lock); 1608843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) { 1609843c0a8aSMike Christie conn->tmf_state = TMF_TIMEDOUT; 16101b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "tmf timedout\n"); 16117996a778SMike Christie /* unblock eh_abort() */ 16127996a778SMike Christie wake_up(&conn->ehwait); 16137996a778SMike Christie } 16147996a778SMike Christie spin_unlock(&session->lock); 16157996a778SMike Christie } 16167996a778SMike Christie 16179c19a7d0SMike Christie static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, 1618f6d5180cSMike Christie struct iscsi_tm *hdr, int age, 1619f6d5180cSMike Christie int timeout) 16207996a778SMike Christie { 16217996a778SMike Christie struct iscsi_session *session = conn->session; 16229c19a7d0SMike Christie struct iscsi_task *task; 16237996a778SMike Christie 16249c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr, 16257996a778SMike Christie NULL, 0); 16269c19a7d0SMike Christie if (!task) { 16276724add1SMike Christie spin_unlock_bh(&session->lock); 16287996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1629843c0a8aSMike Christie spin_lock_bh(&session->lock); 16301b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "tmf exec failure\n"); 163177a23c21SMike Christie return -EPERM; 16327996a778SMike Christie } 16337996a778SMike Christie conn->tmfcmd_pdus_cnt++; 1634f6d5180cSMike Christie conn->tmf_timer.expires = timeout * HZ + jiffies; 1635843c0a8aSMike Christie conn->tmf_timer.function = iscsi_tmf_timedout; 1636843c0a8aSMike Christie conn->tmf_timer.data = (unsigned long)conn; 1637843c0a8aSMike Christie add_timer(&conn->tmf_timer); 16381b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "tmf set timeout\n"); 1639843c0a8aSMike Christie 16407996a778SMike Christie spin_unlock_bh(&session->lock); 16416724add1SMike Christie mutex_unlock(&session->eh_mutex); 16427996a778SMike Christie 16437996a778SMike Christie /* 16447996a778SMike Christie * block eh thread until: 16457996a778SMike Christie * 1646843c0a8aSMike Christie * 1) tmf response 1647843c0a8aSMike Christie * 2) tmf timeout 16487996a778SMike Christie * 3) session is terminated or restarted or userspace has 16497996a778SMike Christie * given up on recovery 16507996a778SMike Christie */ 1651843c0a8aSMike Christie wait_event_interruptible(conn->ehwait, age != session->age || 16527996a778SMike Christie session->state != ISCSI_STATE_LOGGED_IN || 1653843c0a8aSMike Christie conn->tmf_state != TMF_QUEUED); 16547996a778SMike Christie if (signal_pending(current)) 16557996a778SMike Christie flush_signals(current); 1656843c0a8aSMike Christie del_timer_sync(&conn->tmf_timer); 1657843c0a8aSMike Christie 16586724add1SMike Christie mutex_lock(&session->eh_mutex); 165977a23c21SMike Christie spin_lock_bh(&session->lock); 16609c19a7d0SMike Christie /* if the session drops it will clean up the task */ 1661843c0a8aSMike Christie if (age != session->age || 1662843c0a8aSMike Christie session->state != ISCSI_STATE_LOGGED_IN) 1663843c0a8aSMike Christie return -ENOTCONN; 16647996a778SMike Christie return 0; 16657996a778SMike Christie } 16667996a778SMike Christie 16677996a778SMike Christie /* 1668843c0a8aSMike Christie * Fail commands. session lock held and recv side suspended and xmit 1669843c0a8aSMike Christie * thread flushed 1670843c0a8aSMike Christie */ 16713bbaaad9SMike Christie static void fail_scsi_tasks(struct iscsi_conn *conn, unsigned lun, 16726eabafbeSMike Christie int error) 1673843c0a8aSMike Christie { 16743bbaaad9SMike Christie struct iscsi_task *task; 16753bbaaad9SMike Christie int i; 1676843c0a8aSMike Christie 16773bbaaad9SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 16783bbaaad9SMike Christie task = conn->session->cmds[i]; 16793bbaaad9SMike Christie if (!task->sc || task->state == ISCSI_TASK_FREE) 16803bbaaad9SMike Christie continue; 1681843c0a8aSMike Christie 16823bbaaad9SMike Christie if (lun != -1 && lun != task->sc->device->lun) 16833bbaaad9SMike Christie continue; 16843bbaaad9SMike Christie 16851b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, 16863bbaaad9SMike Christie "failing sc %p itt 0x%x state %d\n", 16873bbaaad9SMike Christie task->sc, task->itt, task->state); 1688b3cd5050SMike Christie fail_scsi_task(task, error); 1689843c0a8aSMike Christie } 1690843c0a8aSMike Christie } 1691843c0a8aSMike Christie 1692b40977d9SMike Christie void iscsi_suspend_tx(struct iscsi_conn *conn) 16936724add1SMike Christie { 169432ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 169532ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 169632ae763eSMike Christie 16976724add1SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 16981336aed1SMike Christie if (ihost->workq) 169932ae763eSMike Christie flush_workqueue(ihost->workq); 17006724add1SMike Christie } 1701b40977d9SMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_tx); 17026724add1SMike Christie 17036724add1SMike Christie static void iscsi_start_tx(struct iscsi_conn *conn) 17046724add1SMike Christie { 17056724add1SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 170632ae763eSMike Christie iscsi_conn_queue_work(conn); 17076724add1SMike Christie } 17086724add1SMike Christie 17094c48a829SMike Christie /* 17104c48a829SMike Christie * We want to make sure a ping is in flight. It has timed out. 17114c48a829SMike Christie * And we are not busy processing a pdu that is making 17124c48a829SMike Christie * progress but got started before the ping and is taking a while 17134c48a829SMike Christie * to complete so the ping is just stuck behind it in a queue. 17144c48a829SMike Christie */ 17154c48a829SMike Christie static int iscsi_has_ping_timed_out(struct iscsi_conn *conn) 17164c48a829SMike Christie { 17174c48a829SMike Christie if (conn->ping_task && 17184c48a829SMike Christie time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) + 17194c48a829SMike Christie (conn->ping_timeout * HZ), jiffies)) 17204c48a829SMike Christie return 1; 17214c48a829SMike Christie else 17224c48a829SMike Christie return 0; 17234c48a829SMike Christie } 17244c48a829SMike Christie 1725d355e57dSMike Christie static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc) 1726f6d5180cSMike Christie { 1727d355e57dSMike Christie enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED; 1728d355e57dSMike Christie struct iscsi_task *task = NULL; 1729f6d5180cSMike Christie struct iscsi_cls_session *cls_session; 1730f6d5180cSMike Christie struct iscsi_session *session; 1731f6d5180cSMike Christie struct iscsi_conn *conn; 1732f6d5180cSMike Christie 1733d355e57dSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 173475613521SMike Christie session = cls_session->dd_data; 1735f6d5180cSMike Christie 1736d355e57dSMike Christie ISCSI_DBG_SESSION(session, "scsi cmd %p timedout\n", sc); 1737f6d5180cSMike Christie 1738f6d5180cSMike Christie spin_lock(&session->lock); 1739f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1740f6d5180cSMike Christie /* 1741f6d5180cSMike Christie * We are probably in the middle of iscsi recovery so let 1742f6d5180cSMike Christie * that complete and handle the error. 1743f6d5180cSMike Christie */ 1744242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1745f6d5180cSMike Christie goto done; 1746f6d5180cSMike Christie } 1747f6d5180cSMike Christie 1748f6d5180cSMike Christie conn = session->leadconn; 1749f6d5180cSMike Christie if (!conn) { 1750f6d5180cSMike Christie /* In the middle of shuting down */ 1751242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1752f6d5180cSMike Christie goto done; 1753f6d5180cSMike Christie } 1754f6d5180cSMike Christie 1755d355e57dSMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 1756d355e57dSMike Christie if (!task) 1757d355e57dSMike Christie goto done; 1758d355e57dSMike Christie /* 1759d355e57dSMike Christie * If we have sent (at least queued to the network layer) a pdu or 1760d355e57dSMike Christie * recvd one for the task since the last timeout ask for 1761d355e57dSMike Christie * more time. If on the next timeout we have not made progress 1762d355e57dSMike Christie * we can check if it is the task or connection when we send the 1763d355e57dSMike Christie * nop as a ping. 1764d355e57dSMike Christie */ 1765d355e57dSMike Christie if (time_after_eq(task->last_xfer, task->last_timeout)) { 1766d355e57dSMike Christie ISCSI_DBG_CONN(conn, "Command making progress. Asking " 1767d355e57dSMike Christie "scsi-ml for more time to complete. " 1768d355e57dSMike Christie "Last data recv at %lu. Last timeout was at " 1769d355e57dSMike Christie "%lu\n.", task->last_xfer, task->last_timeout); 1770d355e57dSMike Christie task->have_checked_conn = false; 1771d355e57dSMike Christie rc = BLK_EH_RESET_TIMER; 1772d355e57dSMike Christie goto done; 1773d355e57dSMike Christie } 1774d355e57dSMike Christie 1775f6d5180cSMike Christie if (!conn->recv_timeout && !conn->ping_timeout) 1776f6d5180cSMike Christie goto done; 1777f6d5180cSMike Christie /* 1778f6d5180cSMike Christie * if the ping timedout then we are in the middle of cleaning up 1779f6d5180cSMike Christie * and can let the iscsi eh handle it 1780f6d5180cSMike Christie */ 17814c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 1782242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 17834c48a829SMike Christie goto done; 17844c48a829SMike Christie } 1785d355e57dSMike Christie 1786d355e57dSMike Christie /* Assumes nop timeout is shorter than scsi cmd timeout */ 1787d355e57dSMike Christie if (task->have_checked_conn) 1788d355e57dSMike Christie goto done; 1789d355e57dSMike Christie 1790f6d5180cSMike Christie /* 1791d355e57dSMike Christie * Checking the transport already or nop from a cmd timeout still 1792d355e57dSMike Christie * running 1793f6d5180cSMike Christie */ 1794d355e57dSMike Christie if (conn->ping_task) { 1795d355e57dSMike Christie task->have_checked_conn = true; 1796242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 17974c48a829SMike Christie goto done; 17984c48a829SMike Christie } 17994c48a829SMike Christie 1800d355e57dSMike Christie /* Make sure there is a transport check done */ 1801d355e57dSMike Christie iscsi_send_nopout(conn, NULL); 1802d355e57dSMike Christie task->have_checked_conn = true; 1803242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1804d355e57dSMike Christie 1805f6d5180cSMike Christie done: 1806d355e57dSMike Christie if (task) 1807d355e57dSMike Christie task->last_timeout = jiffies; 1808f6d5180cSMike Christie spin_unlock(&session->lock); 18091b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "return %s\n", rc == BLK_EH_RESET_TIMER ? 1810242f9dcbSJens Axboe "timer reset" : "nh"); 1811f6d5180cSMike Christie return rc; 1812f6d5180cSMike Christie } 1813f6d5180cSMike Christie 1814f6d5180cSMike Christie static void iscsi_check_transport_timeouts(unsigned long data) 1815f6d5180cSMike Christie { 1816f6d5180cSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 1817f6d5180cSMike Christie struct iscsi_session *session = conn->session; 18184cf10435SMike Christie unsigned long recv_timeout, next_timeout = 0, last_recv; 1819f6d5180cSMike Christie 1820f6d5180cSMike Christie spin_lock(&session->lock); 1821f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 1822f6d5180cSMike Christie goto done; 1823f6d5180cSMike Christie 18244cf10435SMike Christie recv_timeout = conn->recv_timeout; 18254cf10435SMike Christie if (!recv_timeout) 1826f6d5180cSMike Christie goto done; 1827f6d5180cSMike Christie 18284cf10435SMike Christie recv_timeout *= HZ; 1829f6d5180cSMike Christie last_recv = conn->last_recv; 18304c48a829SMike Christie 18314c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 1832322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs " 18334c48a829SMike Christie "expired, recv timeout %d, last rx %lu, " 18344c48a829SMike Christie "last ping %lu, now %lu\n", 18354c48a829SMike Christie conn->ping_timeout, conn->recv_timeout, 18364c48a829SMike Christie last_recv, conn->last_ping, jiffies); 1837f6d5180cSMike Christie spin_unlock(&session->lock); 1838f6d5180cSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1839f6d5180cSMike Christie return; 1840f6d5180cSMike Christie } 1841f6d5180cSMike Christie 18424cf10435SMike Christie if (time_before_eq(last_recv + recv_timeout, jiffies)) { 1843f6d5180cSMike Christie /* send a ping to try to provoke some traffic */ 18441b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Sending nopout as ping\n"); 1845f6d5180cSMike Christie iscsi_send_nopout(conn, NULL); 18464cf10435SMike Christie next_timeout = conn->last_ping + (conn->ping_timeout * HZ); 1847ad294e9cSMike Christie } else 18484cf10435SMike Christie next_timeout = last_recv + recv_timeout; 1849f6d5180cSMike Christie 18501b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout); 1851f6d5180cSMike Christie mod_timer(&conn->transport_timer, next_timeout); 1852f6d5180cSMike Christie done: 1853f6d5180cSMike Christie spin_unlock(&session->lock); 1854f6d5180cSMike Christie } 1855f6d5180cSMike Christie 18569c19a7d0SMike Christie static void iscsi_prep_abort_task_pdu(struct iscsi_task *task, 1857843c0a8aSMike Christie struct iscsi_tm *hdr) 1858843c0a8aSMike Christie { 1859843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 1860843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 1861843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK; 1862843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 1863577577daSMike Christie memcpy(hdr->lun, task->lun, sizeof(hdr->lun)); 1864577577daSMike Christie hdr->rtt = task->hdr_itt; 1865577577daSMike Christie hdr->refcmdsn = task->cmdsn; 1866843c0a8aSMike Christie } 1867843c0a8aSMike Christie 18687996a778SMike Christie int iscsi_eh_abort(struct scsi_cmnd *sc) 18697996a778SMike Christie { 187075613521SMike Christie struct iscsi_cls_session *cls_session; 187175613521SMike Christie struct iscsi_session *session; 1872f47f2cf5SMike Christie struct iscsi_conn *conn; 18739c19a7d0SMike Christie struct iscsi_task *task; 1874843c0a8aSMike Christie struct iscsi_tm *hdr; 1875843c0a8aSMike Christie int rc, age; 18767996a778SMike Christie 187775613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 187875613521SMike Christie session = cls_session->dd_data; 187975613521SMike Christie 18804421c9ebSMike Christie ISCSI_DBG_SESSION(session, "aborting sc %p\n", sc); 18814421c9ebSMike Christie 18826724add1SMike Christie mutex_lock(&session->eh_mutex); 18836724add1SMike Christie spin_lock_bh(&session->lock); 1884f47f2cf5SMike Christie /* 1885f47f2cf5SMike Christie * if session was ISCSI_STATE_IN_RECOVERY then we may not have 1886f47f2cf5SMike Christie * got the command. 1887f47f2cf5SMike Christie */ 1888f47f2cf5SMike Christie if (!sc->SCp.ptr) { 18891b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "sc never reached iscsi layer or " 18901b2c7af8SMike Christie "it completed.\n"); 18916724add1SMike Christie spin_unlock_bh(&session->lock); 18926724add1SMike Christie mutex_unlock(&session->eh_mutex); 1893f47f2cf5SMike Christie return SUCCESS; 1894f47f2cf5SMike Christie } 1895f47f2cf5SMike Christie 18967996a778SMike Christie /* 18977996a778SMike Christie * If we are not logged in or we have started a new session 18987996a778SMike Christie * then let the host reset code handle this 18997996a778SMike Christie */ 1900843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN || 1901843c0a8aSMike Christie sc->SCp.phase != session->age) { 1902843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1903843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 19044421c9ebSMike Christie ISCSI_DBG_SESSION(session, "failing abort due to dropped " 19054421c9ebSMike Christie "session.\n"); 1906843c0a8aSMike Christie return FAILED; 1907843c0a8aSMike Christie } 1908843c0a8aSMike Christie 1909843c0a8aSMike Christie conn = session->leadconn; 1910843c0a8aSMike Christie conn->eh_abort_cnt++; 1911843c0a8aSMike Christie age = session->age; 1912843c0a8aSMike Christie 19139c19a7d0SMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 19141b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "aborting [sc %p itt 0x%x]\n", 19151b2c7af8SMike Christie sc, task->itt); 19167996a778SMike Christie 19179c19a7d0SMike Christie /* task completed before time out */ 19189c19a7d0SMike Christie if (!task->sc) { 19191b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "sc completed while abort in " 19201b2c7af8SMike Christie "progress\n"); 192177a23c21SMike Christie goto success; 19227ea8b828SMike Christie } 19237996a778SMike Christie 19249c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) { 1925b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 192677a23c21SMike Christie goto success; 192777a23c21SMike Christie } 19287996a778SMike Christie 1929843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 1930843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 19317996a778SMike Christie goto failed; 1932843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 19337996a778SMike Christie 1934843c0a8aSMike Christie hdr = &conn->tmhdr; 19359c19a7d0SMike Christie iscsi_prep_abort_task_pdu(task, hdr); 1936843c0a8aSMike Christie 19379c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) { 1938843c0a8aSMike Christie rc = FAILED; 1939843c0a8aSMike Christie goto failed; 1940843c0a8aSMike Christie } 1941843c0a8aSMike Christie 1942843c0a8aSMike Christie switch (conn->tmf_state) { 1943843c0a8aSMike Christie case TMF_SUCCESS: 19447ea8b828SMike Christie spin_unlock_bh(&session->lock); 1945913e5bf4SMike Christie /* 1946913e5bf4SMike Christie * stop tx side incase the target had sent a abort rsp but 1947913e5bf4SMike Christie * the initiator was still writing out data. 1948913e5bf4SMike Christie */ 19496724add1SMike Christie iscsi_suspend_tx(conn); 19507996a778SMike Christie /* 1951913e5bf4SMike Christie * we do not stop the recv side because targets have been 1952913e5bf4SMike Christie * good and have never sent us a successful tmf response 1953913e5bf4SMike Christie * then sent more data for the cmd. 19547996a778SMike Christie */ 19557996a778SMike Christie spin_lock(&session->lock); 1956b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 1957843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 19587996a778SMike Christie spin_unlock(&session->lock); 19596724add1SMike Christie iscsi_start_tx(conn); 196077a23c21SMike Christie goto success_unlocked; 1961843c0a8aSMike Christie case TMF_TIMEDOUT: 1962843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1963843c0a8aSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1964843c0a8aSMike Christie goto failed_unlocked; 1965843c0a8aSMike Christie case TMF_NOT_FOUND: 1966843c0a8aSMike Christie if (!sc->SCp.ptr) { 1967843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 19689c19a7d0SMike Christie /* task completed before tmf abort response */ 19691b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "sc completed while abort " 19701b2c7af8SMike Christie "in progress\n"); 197177a23c21SMike Christie goto success; 197277a23c21SMike Christie } 197377a23c21SMike Christie /* fall through */ 197477a23c21SMike Christie default: 1975843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 1976843c0a8aSMike Christie goto failed; 197777a23c21SMike Christie } 19787996a778SMike Christie 197977a23c21SMike Christie success: 198077a23c21SMike Christie spin_unlock_bh(&session->lock); 198177a23c21SMike Christie success_unlocked: 19821b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "abort success [sc %p itt 0x%x]\n", 19831b2c7af8SMike Christie sc, task->itt); 19846724add1SMike Christie mutex_unlock(&session->eh_mutex); 19857996a778SMike Christie return SUCCESS; 19867996a778SMike Christie 19877996a778SMike Christie failed: 19887996a778SMike Christie spin_unlock_bh(&session->lock); 198977a23c21SMike Christie failed_unlocked: 19901b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "abort failed [sc %p itt 0x%x]\n", sc, 19919c19a7d0SMike Christie task ? task->itt : 0); 19926724add1SMike Christie mutex_unlock(&session->eh_mutex); 19937996a778SMike Christie return FAILED; 19947996a778SMike Christie } 19957996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_abort); 19967996a778SMike Christie 1997843c0a8aSMike Christie static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 1998843c0a8aSMike Christie { 1999843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2000843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2001843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK; 2002843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 2003843c0a8aSMike Christie int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun); 2004f6d5180cSMike Christie hdr->rtt = RESERVED_ITT; 2005843c0a8aSMike Christie } 2006843c0a8aSMike Christie 2007843c0a8aSMike Christie int iscsi_eh_device_reset(struct scsi_cmnd *sc) 2008843c0a8aSMike Christie { 200975613521SMike Christie struct iscsi_cls_session *cls_session; 201075613521SMike Christie struct iscsi_session *session; 2011843c0a8aSMike Christie struct iscsi_conn *conn; 2012843c0a8aSMike Christie struct iscsi_tm *hdr; 2013843c0a8aSMike Christie int rc = FAILED; 2014843c0a8aSMike Christie 201575613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 201675613521SMike Christie session = cls_session->dd_data; 201775613521SMike Christie 20181b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "LU Reset [sc %p lun %u]\n", 20191b2c7af8SMike Christie sc, sc->device->lun); 2020843c0a8aSMike Christie 2021843c0a8aSMike Christie mutex_lock(&session->eh_mutex); 2022843c0a8aSMike Christie spin_lock_bh(&session->lock); 2023843c0a8aSMike Christie /* 2024843c0a8aSMike Christie * Just check if we are not logged in. We cannot check for 2025843c0a8aSMike Christie * the phase because the reset could come from a ioctl. 2026843c0a8aSMike Christie */ 2027843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 2028843c0a8aSMike Christie goto unlock; 2029843c0a8aSMike Christie conn = session->leadconn; 2030843c0a8aSMike Christie 2031843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2032843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 2033843c0a8aSMike Christie goto unlock; 2034843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 2035843c0a8aSMike Christie 2036843c0a8aSMike Christie hdr = &conn->tmhdr; 2037843c0a8aSMike Christie iscsi_prep_lun_reset_pdu(sc, hdr); 2038843c0a8aSMike Christie 20399c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 2040f6d5180cSMike Christie session->lu_reset_timeout)) { 2041843c0a8aSMike Christie rc = FAILED; 2042843c0a8aSMike Christie goto unlock; 2043843c0a8aSMike Christie } 2044843c0a8aSMike Christie 2045843c0a8aSMike Christie switch (conn->tmf_state) { 2046843c0a8aSMike Christie case TMF_SUCCESS: 2047843c0a8aSMike Christie break; 2048843c0a8aSMike Christie case TMF_TIMEDOUT: 2049843c0a8aSMike Christie spin_unlock_bh(&session->lock); 2050843c0a8aSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 2051843c0a8aSMike Christie goto done; 2052843c0a8aSMike Christie default: 2053843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2054843c0a8aSMike Christie goto unlock; 2055843c0a8aSMike Christie } 2056843c0a8aSMike Christie 2057843c0a8aSMike Christie rc = SUCCESS; 2058843c0a8aSMike Christie spin_unlock_bh(&session->lock); 2059843c0a8aSMike Christie 2060843c0a8aSMike Christie iscsi_suspend_tx(conn); 2061913e5bf4SMike Christie 2062a3439148SMike Christie spin_lock_bh(&session->lock); 20633bbaaad9SMike Christie fail_scsi_tasks(conn, sc->device->lun, DID_ERROR); 2064843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2065a3439148SMike Christie spin_unlock_bh(&session->lock); 2066843c0a8aSMike Christie 2067843c0a8aSMike Christie iscsi_start_tx(conn); 2068843c0a8aSMike Christie goto done; 2069843c0a8aSMike Christie 2070843c0a8aSMike Christie unlock: 2071843c0a8aSMike Christie spin_unlock_bh(&session->lock); 2072843c0a8aSMike Christie done: 20731b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "dev reset result = %s\n", 2074843c0a8aSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 2075843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2076843c0a8aSMike Christie return rc; 2077843c0a8aSMike Christie } 2078843c0a8aSMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_device_reset); 2079843c0a8aSMike Christie 20806320377fSOlaf Kirch /* 20816320377fSOlaf Kirch * Pre-allocate a pool of @max items of @item_size. By default, the pool 20826320377fSOlaf Kirch * should be accessed via kfifo_{get,put} on q->queue. 20836320377fSOlaf Kirch * Optionally, the caller can obtain the array of object pointers 20846320377fSOlaf Kirch * by passing in a non-NULL @items pointer 20856320377fSOlaf Kirch */ 20867996a778SMike Christie int 20876320377fSOlaf Kirch iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size) 20887996a778SMike Christie { 20896320377fSOlaf Kirch int i, num_arrays = 1; 20907996a778SMike Christie 20916320377fSOlaf Kirch memset(q, 0, sizeof(*q)); 20927996a778SMike Christie 20937996a778SMike Christie q->max = max; 20946320377fSOlaf Kirch 20956320377fSOlaf Kirch /* If the user passed an items pointer, he wants a copy of 20966320377fSOlaf Kirch * the array. */ 20976320377fSOlaf Kirch if (items) 20986320377fSOlaf Kirch num_arrays++; 20996320377fSOlaf Kirch q->pool = kzalloc(num_arrays * max * sizeof(void*), GFP_KERNEL); 21006320377fSOlaf Kirch if (q->pool == NULL) 2101f474a37bSJean Delvare return -ENOMEM; 21027996a778SMike Christie 21037996a778SMike Christie q->queue = kfifo_init((void*)q->pool, max * sizeof(void*), 21047996a778SMike Christie GFP_KERNEL, NULL); 2105fd6e1c14SJean Delvare if (IS_ERR(q->queue)) { 2106fd6e1c14SJean Delvare q->queue = NULL; 21076320377fSOlaf Kirch goto enomem; 2108fd6e1c14SJean Delvare } 21097996a778SMike Christie 21107996a778SMike Christie for (i = 0; i < max; i++) { 21116320377fSOlaf Kirch q->pool[i] = kzalloc(item_size, GFP_KERNEL); 21127996a778SMike Christie if (q->pool[i] == NULL) { 21136320377fSOlaf Kirch q->max = i; 21146320377fSOlaf Kirch goto enomem; 21157996a778SMike Christie } 21167996a778SMike Christie __kfifo_put(q->queue, (void*)&q->pool[i], sizeof(void*)); 21177996a778SMike Christie } 21186320377fSOlaf Kirch 21196320377fSOlaf Kirch if (items) { 21206320377fSOlaf Kirch *items = q->pool + max; 21216320377fSOlaf Kirch memcpy(*items, q->pool, max * sizeof(void *)); 21226320377fSOlaf Kirch } 21236320377fSOlaf Kirch 21247996a778SMike Christie return 0; 21256320377fSOlaf Kirch 21266320377fSOlaf Kirch enomem: 21276320377fSOlaf Kirch iscsi_pool_free(q); 21286320377fSOlaf Kirch return -ENOMEM; 21297996a778SMike Christie } 21307996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_init); 21317996a778SMike Christie 21326320377fSOlaf Kirch void iscsi_pool_free(struct iscsi_pool *q) 21337996a778SMike Christie { 21347996a778SMike Christie int i; 21357996a778SMike Christie 21367996a778SMike Christie for (i = 0; i < q->max; i++) 21376320377fSOlaf Kirch kfree(q->pool[i]); 21387996a778SMike Christie kfree(q->pool); 21392f5899a3SMike Christie kfree(q->queue); 21407996a778SMike Christie } 21417996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_free); 21427996a778SMike Christie 2143a4804cd6SMike Christie /** 2144a4804cd6SMike Christie * iscsi_host_add - add host to system 2145a4804cd6SMike Christie * @shost: scsi host 2146a4804cd6SMike Christie * @pdev: parent device 2147a4804cd6SMike Christie * 2148a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers 2149a4804cd6SMike Christie * to add a host to the system. 2150a4804cd6SMike Christie */ 2151a4804cd6SMike Christie int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev) 21527996a778SMike Christie { 21538e9a20ceSMike Christie if (!shost->can_queue) 21548e9a20ceSMike Christie shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX; 21558e9a20ceSMike Christie 21564d108350SMike Christie if (!shost->cmd_per_lun) 21574d108350SMike Christie shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN; 21584d108350SMike Christie 2159308cec14SMike Christie if (!shost->transportt->eh_timed_out) 2160308cec14SMike Christie shost->transportt->eh_timed_out = iscsi_eh_cmd_timed_out; 2161a4804cd6SMike Christie return scsi_add_host(shost, pdev); 2162a4804cd6SMike Christie } 2163a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_add); 2164a4804cd6SMike Christie 2165a4804cd6SMike Christie /** 2166a4804cd6SMike Christie * iscsi_host_alloc - allocate a host and driver data 2167a4804cd6SMike Christie * @sht: scsi host template 2168a4804cd6SMike Christie * @dd_data_size: driver host data size 216932ae763eSMike Christie * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue 2170a4804cd6SMike Christie * 2171a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers. 2172a4804cd6SMike Christie * To access the driver specific memory use the iscsi_host_priv() macro. 2173a4804cd6SMike Christie */ 2174a4804cd6SMike Christie struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht, 21754d108350SMike Christie int dd_data_size, bool xmit_can_sleep) 2176a4804cd6SMike Christie { 2177a4804cd6SMike Christie struct Scsi_Host *shost; 2178e5bd7b54SMike Christie struct iscsi_host *ihost; 2179a4804cd6SMike Christie 2180a4804cd6SMike Christie shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size); 2181a4804cd6SMike Christie if (!shost) 2182a4804cd6SMike Christie return NULL; 2183e5bd7b54SMike Christie ihost = shost_priv(shost); 218432ae763eSMike Christie 218532ae763eSMike Christie if (xmit_can_sleep) { 218632ae763eSMike Christie snprintf(ihost->workq_name, sizeof(ihost->workq_name), 218732ae763eSMike Christie "iscsi_q_%d", shost->host_no); 218832ae763eSMike Christie ihost->workq = create_singlethread_workqueue(ihost->workq_name); 218932ae763eSMike Christie if (!ihost->workq) 219032ae763eSMike Christie goto free_host; 219132ae763eSMike Christie } 219232ae763eSMike Christie 2193e5bd7b54SMike Christie spin_lock_init(&ihost->lock); 2194e5bd7b54SMike Christie ihost->state = ISCSI_HOST_SETUP; 2195e5bd7b54SMike Christie ihost->num_sessions = 0; 2196e5bd7b54SMike Christie init_waitqueue_head(&ihost->session_removal_wq); 2197a4804cd6SMike Christie return shost; 219832ae763eSMike Christie 219932ae763eSMike Christie free_host: 220032ae763eSMike Christie scsi_host_put(shost); 220132ae763eSMike Christie return NULL; 220275613521SMike Christie } 2203a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_alloc); 220475613521SMike Christie 2205e5bd7b54SMike Christie static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session) 2206e5bd7b54SMike Christie { 220740a06e75SMike Christie iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST); 2208e5bd7b54SMike Christie } 2209e5bd7b54SMike Christie 2210a4804cd6SMike Christie /** 2211a4804cd6SMike Christie * iscsi_host_remove - remove host and sessions 2212a4804cd6SMike Christie * @shost: scsi host 2213a4804cd6SMike Christie * 2214e5bd7b54SMike Christie * If there are any sessions left, this will initiate the removal and wait 2215e5bd7b54SMike Christie * for the completion. 2216a4804cd6SMike Christie */ 2217a4804cd6SMike Christie void iscsi_host_remove(struct Scsi_Host *shost) 2218a4804cd6SMike Christie { 2219e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2220e5bd7b54SMike Christie unsigned long flags; 2221e5bd7b54SMike Christie 2222e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2223e5bd7b54SMike Christie ihost->state = ISCSI_HOST_REMOVED; 2224e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2225e5bd7b54SMike Christie 2226e5bd7b54SMike Christie iscsi_host_for_each_session(shost, iscsi_notify_host_removed); 2227e5bd7b54SMike Christie wait_event_interruptible(ihost->session_removal_wq, 2228e5bd7b54SMike Christie ihost->num_sessions == 0); 2229e5bd7b54SMike Christie if (signal_pending(current)) 2230e5bd7b54SMike Christie flush_signals(current); 2231e5bd7b54SMike Christie 2232a4804cd6SMike Christie scsi_remove_host(shost); 223332ae763eSMike Christie if (ihost->workq) 223432ae763eSMike Christie destroy_workqueue(ihost->workq); 2235a4804cd6SMike Christie } 2236a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_remove); 2237a4804cd6SMike Christie 2238a4804cd6SMike Christie void iscsi_host_free(struct Scsi_Host *shost) 223975613521SMike Christie { 224075613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 224175613521SMike Christie 224275613521SMike Christie kfree(ihost->netdev); 224375613521SMike Christie kfree(ihost->hwaddress); 224475613521SMike Christie kfree(ihost->initiatorname); 2245a4804cd6SMike Christie scsi_host_put(shost); 224675613521SMike Christie } 2247a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_free); 224875613521SMike Christie 2249e5bd7b54SMike Christie static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost) 2250e5bd7b54SMike Christie { 2251e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2252e5bd7b54SMike Christie unsigned long flags; 2253e5bd7b54SMike Christie 2254e5bd7b54SMike Christie shost = scsi_host_get(shost); 2255e5bd7b54SMike Christie if (!shost) { 2256e5bd7b54SMike Christie printk(KERN_ERR "Invalid state. Cannot notify host removal " 2257e5bd7b54SMike Christie "of session teardown event because host already " 2258e5bd7b54SMike Christie "removed.\n"); 2259e5bd7b54SMike Christie return; 2260e5bd7b54SMike Christie } 2261e5bd7b54SMike Christie 2262e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2263e5bd7b54SMike Christie ihost->num_sessions--; 2264e5bd7b54SMike Christie if (ihost->num_sessions == 0) 2265e5bd7b54SMike Christie wake_up(&ihost->session_removal_wq); 2266e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2267e5bd7b54SMike Christie scsi_host_put(shost); 2268e5bd7b54SMike Christie } 2269e5bd7b54SMike Christie 227075613521SMike Christie /** 227175613521SMike Christie * iscsi_session_setup - create iscsi cls session and host and session 227275613521SMike Christie * @iscsit: iscsi transport template 227375613521SMike Christie * @shost: scsi host 227475613521SMike Christie * @cmds_max: session can queue 22759c19a7d0SMike Christie * @cmd_task_size: LLD task private data size 227675613521SMike Christie * @initial_cmdsn: initial CmdSN 227775613521SMike Christie * 227875613521SMike Christie * This can be used by software iscsi_transports that allocate 227975613521SMike Christie * a session per scsi host. 22803cf7b233SMike Christie * 22813cf7b233SMike Christie * Callers should set cmds_max to the largest total numer (mgmt + scsi) of 22823cf7b233SMike Christie * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks 22833cf7b233SMike Christie * for nop handling and login/logout requests. 228475613521SMike Christie */ 228575613521SMike Christie struct iscsi_cls_session * 228675613521SMike Christie iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, 22873cf7b233SMike Christie uint16_t cmds_max, int cmd_task_size, 22887970634bSMike Christie uint32_t initial_cmdsn, unsigned int id) 228975613521SMike Christie { 2290e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 229175613521SMike Christie struct iscsi_session *session; 229275613521SMike Christie struct iscsi_cls_session *cls_session; 22933cf7b233SMike Christie int cmd_i, scsi_cmds, total_cmds = cmds_max; 2294e5bd7b54SMike Christie unsigned long flags; 2295e5bd7b54SMike Christie 2296e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2297e5bd7b54SMike Christie if (ihost->state == ISCSI_HOST_REMOVED) { 2298e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2299e5bd7b54SMike Christie return NULL; 2300e5bd7b54SMike Christie } 2301e5bd7b54SMike Christie ihost->num_sessions++; 2302e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 23038e9a20ceSMike Christie 23048e9a20ceSMike Christie if (!total_cmds) 23058e9a20ceSMike Christie total_cmds = ISCSI_DEF_XMIT_CMDS_MAX; 23063e5c28adSMike Christie /* 23073cf7b233SMike Christie * The iscsi layer needs some tasks for nop handling and tmfs, 23083cf7b233SMike Christie * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX 23093cf7b233SMike Christie * + 1 command for scsi IO. 23103e5c28adSMike Christie */ 23113cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 23123cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 23133cf7b233SMike Christie "must be a power of two that is at least %d.\n", 23143cf7b233SMike Christie total_cmds, ISCSI_TOTAL_CMDS_MIN); 2315e5bd7b54SMike Christie goto dec_session_count; 23161548271eSMike Christie } 23173cf7b233SMike Christie 23183cf7b233SMike Christie if (total_cmds > ISCSI_TOTAL_CMDS_MAX) { 23193cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 23203cf7b233SMike Christie "must be a power of 2 less than or equal to %d.\n", 23213cf7b233SMike Christie cmds_max, ISCSI_TOTAL_CMDS_MAX); 23223cf7b233SMike Christie total_cmds = ISCSI_TOTAL_CMDS_MAX; 23233cf7b233SMike Christie } 23243cf7b233SMike Christie 23253cf7b233SMike Christie if (!is_power_of_2(total_cmds)) { 23263cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 23273cf7b233SMike Christie "must be a power of 2.\n", total_cmds); 23283cf7b233SMike Christie total_cmds = rounddown_pow_of_two(total_cmds); 23293cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) 23303cf7b233SMike Christie return NULL; 23313cf7b233SMike Christie printk(KERN_INFO "iscsi: Rounding can_queue to %d.\n", 23323cf7b233SMike Christie total_cmds); 23333cf7b233SMike Christie } 23343cf7b233SMike Christie scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX; 23351548271eSMike Christie 23365d91e209SMike Christie cls_session = iscsi_alloc_session(shost, iscsit, 23375d91e209SMike Christie sizeof(struct iscsi_session)); 233875613521SMike Christie if (!cls_session) 2339e5bd7b54SMike Christie goto dec_session_count; 234075613521SMike Christie session = cls_session->dd_data; 234175613521SMike Christie session->cls_session = cls_session; 23427996a778SMike Christie session->host = shost; 23437996a778SMike Christie session->state = ISCSI_STATE_FREE; 2344f6d5180cSMike Christie session->fast_abort = 1; 23454cd49ea1SMike Christie session->lu_reset_timeout = 15; 23464cd49ea1SMike Christie session->abort_timeout = 10; 23473cf7b233SMike Christie session->scsi_cmds_max = scsi_cmds; 23483cf7b233SMike Christie session->cmds_max = total_cmds; 2349e0726407SMike Christie session->queued_cmdsn = session->cmdsn = initial_cmdsn; 23507996a778SMike Christie session->exp_cmdsn = initial_cmdsn + 1; 23517996a778SMike Christie session->max_cmdsn = initial_cmdsn + 1; 23527996a778SMike Christie session->max_r2t = 1; 23537996a778SMike Christie session->tt = iscsit; 23546724add1SMike Christie mutex_init(&session->eh_mutex); 235575613521SMike Christie spin_lock_init(&session->lock); 23567996a778SMike Christie 23577996a778SMike Christie /* initialize SCSI PDU commands pool */ 23587996a778SMike Christie if (iscsi_pool_init(&session->cmdpool, session->cmds_max, 23597996a778SMike Christie (void***)&session->cmds, 23609c19a7d0SMike Christie cmd_task_size + sizeof(struct iscsi_task))) 23617996a778SMike Christie goto cmdpool_alloc_fail; 23627996a778SMike Christie 23637996a778SMike Christie /* pre-format cmds pool with ITT */ 23647996a778SMike Christie for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) { 23659c19a7d0SMike Christie struct iscsi_task *task = session->cmds[cmd_i]; 23667996a778SMike Christie 23679c19a7d0SMike Christie if (cmd_task_size) 23689c19a7d0SMike Christie task->dd_data = &task[1]; 23699c19a7d0SMike Christie task->itt = cmd_i; 23703bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 23719c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 23727996a778SMike Christie } 23737996a778SMike Christie 2374f53a88daSMike Christie if (!try_module_get(iscsit->owner)) 237575613521SMike Christie goto module_get_fail; 237675613521SMike Christie 23777970634bSMike Christie if (iscsi_add_session(cls_session, id)) 2378f53a88daSMike Christie goto cls_session_fail; 2379e5bd7b54SMike Christie 23807996a778SMike Christie return cls_session; 23817996a778SMike Christie 23827996a778SMike Christie cls_session_fail: 238375613521SMike Christie module_put(iscsit->owner); 238475613521SMike Christie module_get_fail: 23856320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 23867996a778SMike Christie cmdpool_alloc_fail: 238775613521SMike Christie iscsi_free_session(cls_session); 2388e5bd7b54SMike Christie dec_session_count: 2389e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 23907996a778SMike Christie return NULL; 23917996a778SMike Christie } 23927996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_setup); 23937996a778SMike Christie 23947996a778SMike Christie /** 23957996a778SMike Christie * iscsi_session_teardown - destroy session, host, and cls_session 239675613521SMike Christie * @cls_session: iscsi session 23977996a778SMike Christie * 239875613521SMike Christie * The driver must have called iscsi_remove_session before 239975613521SMike Christie * calling this. 240075613521SMike Christie */ 24017996a778SMike Christie void iscsi_session_teardown(struct iscsi_cls_session *cls_session) 24027996a778SMike Christie { 240375613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 240463f75cc8SMike Christie struct module *owner = cls_session->transport->owner; 2405e5bd7b54SMike Christie struct Scsi_Host *shost = session->host; 24067996a778SMike Christie 24076320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 24087996a778SMike Christie 2409b2c64167SMike Christie kfree(session->password); 2410b2c64167SMike Christie kfree(session->password_in); 2411b2c64167SMike Christie kfree(session->username); 2412b2c64167SMike Christie kfree(session->username_in); 2413f3ff0c36SMike Christie kfree(session->targetname); 241488dfd340SMike Christie kfree(session->initiatorname); 241588dfd340SMike Christie kfree(session->ifacename); 2416f3ff0c36SMike Christie 241775613521SMike Christie iscsi_destroy_session(cls_session); 2418e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 241963f75cc8SMike Christie module_put(owner); 24207996a778SMike Christie } 24217996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_teardown); 24227996a778SMike Christie 24237996a778SMike Christie /** 24247996a778SMike Christie * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn 24257996a778SMike Christie * @cls_session: iscsi_cls_session 24265d91e209SMike Christie * @dd_size: private driver data size 24277996a778SMike Christie * @conn_idx: cid 24285d91e209SMike Christie */ 24297996a778SMike Christie struct iscsi_cls_conn * 24305d91e209SMike Christie iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, 24315d91e209SMike Christie uint32_t conn_idx) 24327996a778SMike Christie { 243375613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 24347996a778SMike Christie struct iscsi_conn *conn; 24357996a778SMike Christie struct iscsi_cls_conn *cls_conn; 2436d36ab6f3SMike Christie char *data; 24377996a778SMike Christie 24385d91e209SMike Christie cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size, 24395d91e209SMike Christie conn_idx); 24407996a778SMike Christie if (!cls_conn) 24417996a778SMike Christie return NULL; 24427996a778SMike Christie conn = cls_conn->dd_data; 24435d91e209SMike Christie memset(conn, 0, sizeof(*conn) + dd_size); 24447996a778SMike Christie 24455d91e209SMike Christie conn->dd_data = cls_conn->dd_data + sizeof(*conn); 24467996a778SMike Christie conn->session = session; 24477996a778SMike Christie conn->cls_conn = cls_conn; 24487996a778SMike Christie conn->c_stage = ISCSI_CONN_INITIAL_STAGE; 24497996a778SMike Christie conn->id = conn_idx; 24507996a778SMike Christie conn->exp_statsn = 0; 2451843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2452f6d5180cSMike Christie 2453f6d5180cSMike Christie init_timer(&conn->transport_timer); 2454f6d5180cSMike Christie conn->transport_timer.data = (unsigned long)conn; 2455f6d5180cSMike Christie conn->transport_timer.function = iscsi_check_transport_timeouts; 2456f6d5180cSMike Christie 2457843c0a8aSMike Christie INIT_LIST_HEAD(&conn->mgmtqueue); 24583bbaaad9SMike Christie INIT_LIST_HEAD(&conn->cmdqueue); 2459843c0a8aSMike Christie INIT_LIST_HEAD(&conn->requeue); 2460c4028958SDavid Howells INIT_WORK(&conn->xmitwork, iscsi_xmitworker); 24617996a778SMike Christie 24629c19a7d0SMike Christie /* allocate login_task used for the login/text sequences */ 24637996a778SMike Christie spin_lock_bh(&session->lock); 24643e5c28adSMike Christie if (!__kfifo_get(session->cmdpool.queue, 24659c19a7d0SMike Christie (void*)&conn->login_task, 24667996a778SMike Christie sizeof(void*))) { 24677996a778SMike Christie spin_unlock_bh(&session->lock); 24689c19a7d0SMike Christie goto login_task_alloc_fail; 24697996a778SMike Christie } 24707996a778SMike Christie spin_unlock_bh(&session->lock); 24717996a778SMike Christie 2472cfeb2cf9SMike Christie data = (char *) __get_free_pages(GFP_KERNEL, 2473cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2474d36ab6f3SMike Christie if (!data) 24759c19a7d0SMike Christie goto login_task_data_alloc_fail; 24769c19a7d0SMike Christie conn->login_task->data = conn->data = data; 2477d36ab6f3SMike Christie 2478843c0a8aSMike Christie init_timer(&conn->tmf_timer); 24797996a778SMike Christie init_waitqueue_head(&conn->ehwait); 24807996a778SMike Christie 24817996a778SMike Christie return cls_conn; 24827996a778SMike Christie 24839c19a7d0SMike Christie login_task_data_alloc_fail: 24849c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task, 2485d36ab6f3SMike Christie sizeof(void*)); 24869c19a7d0SMike Christie login_task_alloc_fail: 24877996a778SMike Christie iscsi_destroy_conn(cls_conn); 24887996a778SMike Christie return NULL; 24897996a778SMike Christie } 24907996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_setup); 24917996a778SMike Christie 24927996a778SMike Christie /** 24937996a778SMike Christie * iscsi_conn_teardown - teardown iscsi connection 24947996a778SMike Christie * cls_conn: iscsi class connection 24957996a778SMike Christie * 24967996a778SMike Christie * TODO: we may need to make this into a two step process 24977996a778SMike Christie * like scsi-mls remove + put host 24987996a778SMike Christie */ 24997996a778SMike Christie void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) 25007996a778SMike Christie { 25017996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 25027996a778SMike Christie struct iscsi_session *session = conn->session; 25037996a778SMike Christie unsigned long flags; 25047996a778SMike Christie 2505f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 2506f6d5180cSMike Christie 25077996a778SMike Christie spin_lock_bh(&session->lock); 25087996a778SMike Christie conn->c_stage = ISCSI_CONN_CLEANUP_WAIT; 25097996a778SMike Christie if (session->leadconn == conn) { 25107996a778SMike Christie /* 25117996a778SMike Christie * leading connection? then give up on recovery. 25127996a778SMike Christie */ 25137996a778SMike Christie session->state = ISCSI_STATE_TERMINATE; 25147996a778SMike Christie wake_up(&conn->ehwait); 25157996a778SMike Christie } 25167996a778SMike Christie spin_unlock_bh(&session->lock); 25177996a778SMike Christie 25187996a778SMike Christie /* 25197996a778SMike Christie * Block until all in-progress commands for this connection 25207996a778SMike Christie * time out or fail. 25217996a778SMike Christie */ 25227996a778SMike Christie for (;;) { 25237996a778SMike Christie spin_lock_irqsave(session->host->host_lock, flags); 25247996a778SMike Christie if (!session->host->host_busy) { /* OK for ERL == 0 */ 25257996a778SMike Christie spin_unlock_irqrestore(session->host->host_lock, flags); 25267996a778SMike Christie break; 25277996a778SMike Christie } 25287996a778SMike Christie spin_unlock_irqrestore(session->host->host_lock, flags); 25297996a778SMike Christie msleep_interruptible(500); 2530322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "iscsi conn_destroy(): " 2531322d739dSMike Christie "host_busy %d host_failed %d\n", 2532322d739dSMike Christie session->host->host_busy, 2533be2df72eSOr Gerlitz session->host->host_failed); 25347996a778SMike Christie /* 25357996a778SMike Christie * force eh_abort() to unblock 25367996a778SMike Christie */ 25377996a778SMike Christie wake_up(&conn->ehwait); 25387996a778SMike Christie } 25397996a778SMike Christie 2540779ea120SMike Christie /* flush queued up work because we free the connection below */ 2541843c0a8aSMike Christie iscsi_suspend_tx(conn); 2542779ea120SMike Christie 25437996a778SMike Christie spin_lock_bh(&session->lock); 2544cfeb2cf9SMike Christie free_pages((unsigned long) conn->data, 2545cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2546f3ff0c36SMike Christie kfree(conn->persistent_address); 25479c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task, 25487996a778SMike Christie sizeof(void*)); 2549e0726407SMike Christie if (session->leadconn == conn) 25507996a778SMike Christie session->leadconn = NULL; 25517996a778SMike Christie spin_unlock_bh(&session->lock); 25527996a778SMike Christie 25537996a778SMike Christie iscsi_destroy_conn(cls_conn); 25547996a778SMike Christie } 25557996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_teardown); 25567996a778SMike Christie 25577996a778SMike Christie int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 25587996a778SMike Christie { 25597996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 25607996a778SMike Christie struct iscsi_session *session = conn->session; 25617996a778SMike Christie 2562ffd0436eSMike Christie if (!session) { 2563322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 2564322d739dSMike Christie "can't start unbound connection\n"); 25657996a778SMike Christie return -EPERM; 25667996a778SMike Christie } 25677996a778SMike Christie 2568db98ccdeSMike Christie if ((session->imm_data_en || !session->initial_r2t_en) && 2569db98ccdeSMike Christie session->first_burst > session->max_burst) { 2570322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: " 2571ffd0436eSMike Christie "first_burst %d max_burst %d\n", 2572ffd0436eSMike Christie session->first_burst, session->max_burst); 2573ffd0436eSMike Christie return -EINVAL; 2574ffd0436eSMike Christie } 2575ffd0436eSMike Christie 2576f6d5180cSMike Christie if (conn->ping_timeout && !conn->recv_timeout) { 2577322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of " 2578322d739dSMike Christie "zero. Using 5 seconds\n."); 2579f6d5180cSMike Christie conn->recv_timeout = 5; 2580f6d5180cSMike Christie } 2581f6d5180cSMike Christie 2582f6d5180cSMike Christie if (conn->recv_timeout && !conn->ping_timeout) { 2583322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of " 2584322d739dSMike Christie "zero. Using 5 seconds.\n"); 2585f6d5180cSMike Christie conn->ping_timeout = 5; 2586f6d5180cSMike Christie } 2587f6d5180cSMike Christie 25887996a778SMike Christie spin_lock_bh(&session->lock); 25897996a778SMike Christie conn->c_stage = ISCSI_CONN_STARTED; 25907996a778SMike Christie session->state = ISCSI_STATE_LOGGED_IN; 2591e0726407SMike Christie session->queued_cmdsn = session->cmdsn; 25927996a778SMike Christie 2593f6d5180cSMike Christie conn->last_recv = jiffies; 2594f6d5180cSMike Christie conn->last_ping = jiffies; 2595f6d5180cSMike Christie if (conn->recv_timeout && conn->ping_timeout) 2596f6d5180cSMike Christie mod_timer(&conn->transport_timer, 2597f6d5180cSMike Christie jiffies + (conn->recv_timeout * HZ)); 2598f6d5180cSMike Christie 25997996a778SMike Christie switch(conn->stop_stage) { 26007996a778SMike Christie case STOP_CONN_RECOVER: 26017996a778SMike Christie /* 26027996a778SMike Christie * unblock eh_abort() if it is blocked. re-try all 26037996a778SMike Christie * commands after successful recovery 26047996a778SMike Christie */ 26057996a778SMike Christie conn->stop_stage = 0; 2606843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 26077996a778SMike Christie session->age++; 26088b1d0343SMike Christie if (session->age == 16) 26098b1d0343SMike Christie session->age = 0; 26106eabafbeSMike Christie break; 26117996a778SMike Christie case STOP_CONN_TERM: 26127996a778SMike Christie conn->stop_stage = 0; 26137996a778SMike Christie break; 26147996a778SMike Christie default: 26157996a778SMike Christie break; 26167996a778SMike Christie } 26177996a778SMike Christie spin_unlock_bh(&session->lock); 26187996a778SMike Christie 261975613521SMike Christie iscsi_unblock_session(session->cls_session); 26206eabafbeSMike Christie wake_up(&conn->ehwait); 26217996a778SMike Christie return 0; 26227996a778SMike Christie } 26237996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_start); 26247996a778SMike Christie 26257996a778SMike Christie static void 26263bbaaad9SMike Christie fail_mgmt_tasks(struct iscsi_session *session, struct iscsi_conn *conn) 26277996a778SMike Christie { 26283bbaaad9SMike Christie struct iscsi_task *task; 2629b3cd5050SMike Christie int i, state; 26307996a778SMike Christie 26313bbaaad9SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 26323bbaaad9SMike Christie task = conn->session->cmds[i]; 26333bbaaad9SMike Christie if (task->sc) 26343bbaaad9SMike Christie continue; 26353bbaaad9SMike Christie 26363bbaaad9SMike Christie if (task->state == ISCSI_TASK_FREE) 26373bbaaad9SMike Christie continue; 26383bbaaad9SMike Christie 26393bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, 26403bbaaad9SMike Christie "failing mgmt itt 0x%x state %d\n", 26413bbaaad9SMike Christie task->itt, task->state); 2642b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 2643b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) 2644b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 2645b3cd5050SMike Christie iscsi_complete_task(task, state); 2646b3cd5050SMike Christie 26477996a778SMike Christie } 26487996a778SMike Christie } 26497996a778SMike Christie 2650656cffc9SMike Christie static void iscsi_start_session_recovery(struct iscsi_session *session, 26517996a778SMike Christie struct iscsi_conn *conn, int flag) 26527996a778SMike Christie { 2653ed2abc7fSMike Christie int old_stop_stage; 2654ed2abc7fSMike Christie 26556724add1SMike Christie mutex_lock(&session->eh_mutex); 26567996a778SMike Christie spin_lock_bh(&session->lock); 2657ed2abc7fSMike Christie if (conn->stop_stage == STOP_CONN_TERM) { 26587996a778SMike Christie spin_unlock_bh(&session->lock); 26596724add1SMike Christie mutex_unlock(&session->eh_mutex); 26606724add1SMike Christie return; 26616724add1SMike Christie } 26626724add1SMike Christie 26636724add1SMike Christie /* 2664ed2abc7fSMike Christie * When this is called for the in_login state, we only want to clean 26659c19a7d0SMike Christie * up the login task and connection. We do not need to block and set 266667a61114SMike Christie * the recovery state again 2667ed2abc7fSMike Christie */ 266867a61114SMike Christie if (flag == STOP_CONN_TERM) 266967a61114SMike Christie session->state = ISCSI_STATE_TERMINATE; 267067a61114SMike Christie else if (conn->stop_stage != STOP_CONN_RECOVER) 267167a61114SMike Christie session->state = ISCSI_STATE_IN_RECOVERY; 267226013ad4SMike Christie spin_unlock_bh(&session->lock); 2673ed2abc7fSMike Christie 267426013ad4SMike Christie del_timer_sync(&conn->transport_timer); 267526013ad4SMike Christie iscsi_suspend_tx(conn); 267626013ad4SMike Christie 267726013ad4SMike Christie spin_lock_bh(&session->lock); 2678ed2abc7fSMike Christie old_stop_stage = conn->stop_stage; 26797996a778SMike Christie conn->stop_stage = flag; 268067a61114SMike Christie conn->c_stage = ISCSI_CONN_STOPPED; 26817996a778SMike Christie spin_unlock_bh(&session->lock); 26826724add1SMike Christie 26837996a778SMike Christie /* 26847996a778SMike Christie * for connection level recovery we should not calculate 26857996a778SMike Christie * header digest. conn->hdr_size used for optimization 26867996a778SMike Christie * in hdr_extract() and will be re-negotiated at 26877996a778SMike Christie * set_param() time. 26887996a778SMike Christie */ 26897996a778SMike Christie if (flag == STOP_CONN_RECOVER) { 26907996a778SMike Christie conn->hdrdgst_en = 0; 26917996a778SMike Christie conn->datadgst_en = 0; 2692656cffc9SMike Christie if (session->state == ISCSI_STATE_IN_RECOVERY && 269367a61114SMike Christie old_stop_stage != STOP_CONN_RECOVER) { 26941b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "blocking session\n"); 269575613521SMike Christie iscsi_block_session(session->cls_session); 26967996a778SMike Christie } 269767a61114SMike Christie } 2698656cffc9SMike Christie 2699656cffc9SMike Christie /* 2700656cffc9SMike Christie * flush queues. 2701656cffc9SMike Christie */ 2702656cffc9SMike Christie spin_lock_bh(&session->lock); 27033bbaaad9SMike Christie fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED); 27043bbaaad9SMike Christie fail_mgmt_tasks(session, conn); 2705656cffc9SMike Christie spin_unlock_bh(&session->lock); 27066724add1SMike Christie mutex_unlock(&session->eh_mutex); 27077996a778SMike Christie } 27087996a778SMike Christie 27097996a778SMike Christie void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 27107996a778SMike Christie { 27117996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 27127996a778SMike Christie struct iscsi_session *session = conn->session; 27137996a778SMike Christie 27147996a778SMike Christie switch (flag) { 27157996a778SMike Christie case STOP_CONN_RECOVER: 27167996a778SMike Christie case STOP_CONN_TERM: 27177996a778SMike Christie iscsi_start_session_recovery(session, conn, flag); 27188d2860b3SMike Christie break; 27197996a778SMike Christie default: 2720322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 2721322d739dSMike Christie "invalid stop flag %d\n", flag); 27227996a778SMike Christie } 27237996a778SMike Christie } 27247996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_stop); 27257996a778SMike Christie 27267996a778SMike Christie int iscsi_conn_bind(struct iscsi_cls_session *cls_session, 27277996a778SMike Christie struct iscsi_cls_conn *cls_conn, int is_leading) 27287996a778SMike Christie { 272975613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 273098644047SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 27317996a778SMike Christie 27327996a778SMike Christie spin_lock_bh(&session->lock); 27337996a778SMike Christie if (is_leading) 27347996a778SMike Christie session->leadconn = conn; 273598644047SMike Christie spin_unlock_bh(&session->lock); 27367996a778SMike Christie 27377996a778SMike Christie /* 27387996a778SMike Christie * Unblock xmitworker(), Login Phase will pass through. 27397996a778SMike Christie */ 27407996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 27417996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 27427996a778SMike Christie return 0; 27437996a778SMike Christie } 27447996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_bind); 27457996a778SMike Christie 27465700b1afSMike Christie static int iscsi_switch_str_param(char **param, char *new_val_buf) 27475700b1afSMike Christie { 27485700b1afSMike Christie char *new_val; 27495700b1afSMike Christie 27505700b1afSMike Christie if (*param) { 27515700b1afSMike Christie if (!strcmp(*param, new_val_buf)) 27525700b1afSMike Christie return 0; 27535700b1afSMike Christie } 27545700b1afSMike Christie 27555700b1afSMike Christie new_val = kstrdup(new_val_buf, GFP_NOIO); 27565700b1afSMike Christie if (!new_val) 27575700b1afSMike Christie return -ENOMEM; 27585700b1afSMike Christie 27595700b1afSMike Christie kfree(*param); 27605700b1afSMike Christie *param = new_val; 27615700b1afSMike Christie return 0; 27625700b1afSMike Christie } 2763a54a52caSMike Christie 2764a54a52caSMike Christie int iscsi_set_param(struct iscsi_cls_conn *cls_conn, 2765a54a52caSMike Christie enum iscsi_param param, char *buf, int buflen) 2766a54a52caSMike Christie { 2767a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 2768a54a52caSMike Christie struct iscsi_session *session = conn->session; 2769a54a52caSMike Christie uint32_t value; 2770a54a52caSMike Christie 2771a54a52caSMike Christie switch(param) { 2772843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 2773843c0a8aSMike Christie sscanf(buf, "%d", &session->fast_abort); 2774843c0a8aSMike Christie break; 2775f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 2776f6d5180cSMike Christie sscanf(buf, "%d", &session->abort_timeout); 2777f6d5180cSMike Christie break; 2778f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 2779f6d5180cSMike Christie sscanf(buf, "%d", &session->lu_reset_timeout); 2780f6d5180cSMike Christie break; 2781f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 2782f6d5180cSMike Christie sscanf(buf, "%d", &conn->ping_timeout); 2783f6d5180cSMike Christie break; 2784f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 2785f6d5180cSMike Christie sscanf(buf, "%d", &conn->recv_timeout); 2786f6d5180cSMike Christie break; 2787a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 2788a54a52caSMike Christie sscanf(buf, "%d", &conn->max_recv_dlength); 2789a54a52caSMike Christie break; 2790a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 2791a54a52caSMike Christie sscanf(buf, "%d", &conn->max_xmit_dlength); 2792a54a52caSMike Christie break; 2793a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 2794a54a52caSMike Christie sscanf(buf, "%d", &conn->hdrdgst_en); 2795a54a52caSMike Christie break; 2796a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 2797a54a52caSMike Christie sscanf(buf, "%d", &conn->datadgst_en); 2798a54a52caSMike Christie break; 2799a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 2800a54a52caSMike Christie sscanf(buf, "%d", &session->initial_r2t_en); 2801a54a52caSMike Christie break; 2802a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 2803a54a52caSMike Christie sscanf(buf, "%d", &session->max_r2t); 2804a54a52caSMike Christie break; 2805a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 2806a54a52caSMike Christie sscanf(buf, "%d", &session->imm_data_en); 2807a54a52caSMike Christie break; 2808a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 2809a54a52caSMike Christie sscanf(buf, "%d", &session->first_burst); 2810a54a52caSMike Christie break; 2811a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 2812a54a52caSMike Christie sscanf(buf, "%d", &session->max_burst); 2813a54a52caSMike Christie break; 2814a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 2815a54a52caSMike Christie sscanf(buf, "%d", &session->pdu_inorder_en); 2816a54a52caSMike Christie break; 2817a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 2818a54a52caSMike Christie sscanf(buf, "%d", &session->dataseq_inorder_en); 2819a54a52caSMike Christie break; 2820a54a52caSMike Christie case ISCSI_PARAM_ERL: 2821a54a52caSMike Christie sscanf(buf, "%d", &session->erl); 2822a54a52caSMike Christie break; 2823a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 2824a54a52caSMike Christie sscanf(buf, "%d", &value); 2825a54a52caSMike Christie BUG_ON(value); 2826a54a52caSMike Christie break; 2827a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 2828a54a52caSMike Christie sscanf(buf, "%d", &value); 2829a54a52caSMike Christie BUG_ON(value); 2830a54a52caSMike Christie break; 2831a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 2832a54a52caSMike Christie sscanf(buf, "%u", &conn->exp_statsn); 2833a54a52caSMike Christie break; 2834b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 28355700b1afSMike Christie return iscsi_switch_str_param(&session->username, buf); 2836b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 28375700b1afSMike Christie return iscsi_switch_str_param(&session->username_in, buf); 2838b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 28395700b1afSMike Christie return iscsi_switch_str_param(&session->password, buf); 2840b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 28415700b1afSMike Christie return iscsi_switch_str_param(&session->password_in, buf); 2842a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 28435700b1afSMike Christie return iscsi_switch_str_param(&session->targetname, buf); 2844a54a52caSMike Christie case ISCSI_PARAM_TPGT: 2845a54a52caSMike Christie sscanf(buf, "%d", &session->tpgt); 2846a54a52caSMike Christie break; 2847a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 2848a54a52caSMike Christie sscanf(buf, "%d", &conn->persistent_port); 2849a54a52caSMike Christie break; 2850a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 28515700b1afSMike Christie return iscsi_switch_str_param(&conn->persistent_address, buf); 285288dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 28535700b1afSMike Christie return iscsi_switch_str_param(&session->ifacename, buf); 285488dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 28555700b1afSMike Christie return iscsi_switch_str_param(&session->initiatorname, buf); 2856a54a52caSMike Christie default: 2857a54a52caSMike Christie return -ENOSYS; 2858a54a52caSMike Christie } 2859a54a52caSMike Christie 2860a54a52caSMike Christie return 0; 2861a54a52caSMike Christie } 2862a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_set_param); 2863a54a52caSMike Christie 2864a54a52caSMike Christie int iscsi_session_get_param(struct iscsi_cls_session *cls_session, 2865a54a52caSMike Christie enum iscsi_param param, char *buf) 2866a54a52caSMike Christie { 286775613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 2868a54a52caSMike Christie int len; 2869a54a52caSMike Christie 2870a54a52caSMike Christie switch(param) { 2871843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 2872843c0a8aSMike Christie len = sprintf(buf, "%d\n", session->fast_abort); 2873843c0a8aSMike Christie break; 2874f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 2875f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->abort_timeout); 2876f6d5180cSMike Christie break; 2877f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 2878f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->lu_reset_timeout); 2879f6d5180cSMike Christie break; 2880a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 2881a54a52caSMike Christie len = sprintf(buf, "%d\n", session->initial_r2t_en); 2882a54a52caSMike Christie break; 2883a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 2884a54a52caSMike Christie len = sprintf(buf, "%hu\n", session->max_r2t); 2885a54a52caSMike Christie break; 2886a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 2887a54a52caSMike Christie len = sprintf(buf, "%d\n", session->imm_data_en); 2888a54a52caSMike Christie break; 2889a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 2890a54a52caSMike Christie len = sprintf(buf, "%u\n", session->first_burst); 2891a54a52caSMike Christie break; 2892a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 2893a54a52caSMike Christie len = sprintf(buf, "%u\n", session->max_burst); 2894a54a52caSMike Christie break; 2895a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 2896a54a52caSMike Christie len = sprintf(buf, "%d\n", session->pdu_inorder_en); 2897a54a52caSMike Christie break; 2898a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 2899a54a52caSMike Christie len = sprintf(buf, "%d\n", session->dataseq_inorder_en); 2900a54a52caSMike Christie break; 2901a54a52caSMike Christie case ISCSI_PARAM_ERL: 2902a54a52caSMike Christie len = sprintf(buf, "%d\n", session->erl); 2903a54a52caSMike Christie break; 2904a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 2905a54a52caSMike Christie len = sprintf(buf, "%s\n", session->targetname); 2906a54a52caSMike Christie break; 2907a54a52caSMike Christie case ISCSI_PARAM_TPGT: 2908a54a52caSMike Christie len = sprintf(buf, "%d\n", session->tpgt); 2909a54a52caSMike Christie break; 2910b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 2911b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username); 2912b2c64167SMike Christie break; 2913b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 2914b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username_in); 2915b2c64167SMike Christie break; 2916b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 2917b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password); 2918b2c64167SMike Christie break; 2919b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 2920b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password_in); 2921b2c64167SMike Christie break; 292288dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 292388dfd340SMike Christie len = sprintf(buf, "%s\n", session->ifacename); 292488dfd340SMike Christie break; 292588dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 292688dfd340SMike Christie len = sprintf(buf, "%s\n", session->initiatorname); 292788dfd340SMike Christie break; 2928a54a52caSMike Christie default: 2929a54a52caSMike Christie return -ENOSYS; 2930a54a52caSMike Christie } 2931a54a52caSMike Christie 2932a54a52caSMike Christie return len; 2933a54a52caSMike Christie } 2934a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_get_param); 2935a54a52caSMike Christie 2936a54a52caSMike Christie int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, 2937a54a52caSMike Christie enum iscsi_param param, char *buf) 2938a54a52caSMike Christie { 2939a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 2940a54a52caSMike Christie int len; 2941a54a52caSMike Christie 2942a54a52caSMike Christie switch(param) { 2943f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 2944f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->ping_timeout); 2945f6d5180cSMike Christie break; 2946f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 2947f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->recv_timeout); 2948f6d5180cSMike Christie break; 2949a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 2950a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_recv_dlength); 2951a54a52caSMike Christie break; 2952a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 2953a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_xmit_dlength); 2954a54a52caSMike Christie break; 2955a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 2956a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->hdrdgst_en); 2957a54a52caSMike Christie break; 2958a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 2959a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->datadgst_en); 2960a54a52caSMike Christie break; 2961a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 2962a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ifmarker_en); 2963a54a52caSMike Christie break; 2964a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 2965a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ofmarker_en); 2966a54a52caSMike Christie break; 2967a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 2968a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->exp_statsn); 2969a54a52caSMike Christie break; 2970a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 2971a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->persistent_port); 2972a54a52caSMike Christie break; 2973a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 2974a54a52caSMike Christie len = sprintf(buf, "%s\n", conn->persistent_address); 2975a54a52caSMike Christie break; 2976a54a52caSMike Christie default: 2977a54a52caSMike Christie return -ENOSYS; 2978a54a52caSMike Christie } 2979a54a52caSMike Christie 2980a54a52caSMike Christie return len; 2981a54a52caSMike Christie } 2982a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_param); 2983a54a52caSMike Christie 29840801c242SMike Christie int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param, 29850801c242SMike Christie char *buf) 29860801c242SMike Christie { 298775613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 29880801c242SMike Christie int len; 29890801c242SMike Christie 29900801c242SMike Christie switch (param) { 2991d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 299275613521SMike Christie len = sprintf(buf, "%s\n", ihost->netdev); 2993d8196ed2SMike Christie break; 29940801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 299575613521SMike Christie len = sprintf(buf, "%s\n", ihost->hwaddress); 29960801c242SMike Christie break; 29978ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 299875613521SMike Christie len = sprintf(buf, "%s\n", ihost->initiatorname); 29998ad5781aSMike Christie break; 300075613521SMike Christie case ISCSI_HOST_PARAM_IPADDRESS: 30015700b1afSMike Christie len = sprintf(buf, "%s\n", ihost->local_address); 300288dfd340SMike Christie break; 30030801c242SMike Christie default: 30040801c242SMike Christie return -ENOSYS; 30050801c242SMike Christie } 30060801c242SMike Christie 30070801c242SMike Christie return len; 30080801c242SMike Christie } 30090801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_param); 30100801c242SMike Christie 30110801c242SMike Christie int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param, 30120801c242SMike Christie char *buf, int buflen) 30130801c242SMike Christie { 301475613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 30150801c242SMike Christie 30160801c242SMike Christie switch (param) { 3017d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 30185700b1afSMike Christie return iscsi_switch_str_param(&ihost->netdev, buf); 30190801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 30205700b1afSMike Christie return iscsi_switch_str_param(&ihost->hwaddress, buf); 30218ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 30225700b1afSMike Christie return iscsi_switch_str_param(&ihost->initiatorname, buf); 30230801c242SMike Christie default: 30240801c242SMike Christie return -ENOSYS; 30250801c242SMike Christie } 30260801c242SMike Christie 30270801c242SMike Christie return 0; 30280801c242SMike Christie } 30290801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_set_param); 30300801c242SMike Christie 30317996a778SMike Christie MODULE_AUTHOR("Mike Christie"); 30327996a778SMike Christie MODULE_DESCRIPTION("iSCSI library functions"); 30337996a778SMike Christie MODULE_LICENSE("GPL"); 3034