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 8432ae763eSMike Christie queue_work(ihost->workq, &conn->xmitwork); 8532ae763eSMike Christie } 8632ae763eSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_queue_work); 8732ae763eSMike Christie 8877a23c21SMike Christie void 8977a23c21SMike Christie iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr) 907996a778SMike Christie { 917996a778SMike Christie uint32_t max_cmdsn = be32_to_cpu(hdr->max_cmdsn); 927996a778SMike Christie uint32_t exp_cmdsn = be32_to_cpu(hdr->exp_cmdsn); 937996a778SMike Christie 9477a23c21SMike Christie /* 9577a23c21SMike Christie * standard specifies this check for when to update expected and 9677a23c21SMike Christie * max sequence numbers 9777a23c21SMike Christie */ 9877a23c21SMike Christie if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1)) 9977a23c21SMike Christie return; 10077a23c21SMike Christie 10177a23c21SMike Christie if (exp_cmdsn != session->exp_cmdsn && 10277a23c21SMike Christie !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn)) 1037996a778SMike Christie session->exp_cmdsn = exp_cmdsn; 1047996a778SMike Christie 10577a23c21SMike Christie if (max_cmdsn != session->max_cmdsn && 10677a23c21SMike Christie !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) { 10777a23c21SMike Christie session->max_cmdsn = max_cmdsn; 10877a23c21SMike Christie /* 10977a23c21SMike Christie * if the window closed with IO queued, then kick the 11077a23c21SMike Christie * xmit thread 11177a23c21SMike Christie */ 11277a23c21SMike Christie if (!list_empty(&session->leadconn->xmitqueue) || 113052d0144SMike Christie !list_empty(&session->leadconn->mgmtqueue)) { 114052d0144SMike Christie if (!(session->tt->caps & CAP_DATA_PATH_OFFLOAD)) 11532ae763eSMike Christie iscsi_conn_queue_work(session->leadconn); 1167996a778SMike Christie } 11777a23c21SMike Christie } 118052d0144SMike Christie } 11977a23c21SMike Christie EXPORT_SYMBOL_GPL(iscsi_update_cmdsn); 1207996a778SMike Christie 121577577daSMike Christie /** 122577577daSMike Christie * iscsi_prep_data_out_pdu - initialize Data-Out 123577577daSMike Christie * @task: scsi command task 124577577daSMike Christie * @r2t: R2T info 125577577daSMike Christie * @hdr: iscsi data in pdu 126577577daSMike Christie * 127577577daSMike Christie * Notes: 128577577daSMike Christie * Initialize Data-Out within this R2T sequence and finds 129577577daSMike Christie * proper data_offset within this SCSI command. 130577577daSMike Christie * 131577577daSMike Christie * This function is called with connection lock taken. 132577577daSMike Christie **/ 133577577daSMike Christie void iscsi_prep_data_out_pdu(struct iscsi_task *task, struct iscsi_r2t_info *r2t, 134ffd0436eSMike Christie struct iscsi_data *hdr) 1357996a778SMike Christie { 1369c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 137577577daSMike Christie unsigned int left = r2t->data_length - r2t->sent; 138577577daSMike Christie 139577577daSMike Christie task->hdr_len = sizeof(struct iscsi_data); 1407996a778SMike Christie 1417996a778SMike Christie memset(hdr, 0, sizeof(struct iscsi_data)); 142577577daSMike Christie hdr->ttt = r2t->ttt; 143577577daSMike Christie hdr->datasn = cpu_to_be32(r2t->datasn); 144577577daSMike Christie r2t->datasn++; 1457996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_DATA_OUT; 146577577daSMike Christie memcpy(hdr->lun, task->lun, sizeof(hdr->lun)); 147577577daSMike Christie hdr->itt = task->hdr_itt; 148577577daSMike Christie hdr->exp_statsn = r2t->exp_statsn; 149577577daSMike Christie hdr->offset = cpu_to_be32(r2t->data_offset + r2t->sent); 150577577daSMike Christie if (left > conn->max_xmit_dlength) { 1517996a778SMike Christie hton24(hdr->dlength, conn->max_xmit_dlength); 152577577daSMike Christie r2t->data_count = conn->max_xmit_dlength; 1537996a778SMike Christie hdr->flags = 0; 1547996a778SMike Christie } else { 155577577daSMike Christie hton24(hdr->dlength, left); 156577577daSMike Christie r2t->data_count = left; 1577996a778SMike Christie hdr->flags = ISCSI_FLAG_CMD_FINAL; 1587996a778SMike Christie } 159577577daSMike Christie conn->dataout_pdus_cnt++; 1607996a778SMike Christie } 161577577daSMike Christie EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu); 1627996a778SMike Christie 1639c19a7d0SMike Christie static int iscsi_add_hdr(struct iscsi_task *task, unsigned len) 164004d6530SBoaz Harrosh { 1659c19a7d0SMike Christie unsigned exp_len = task->hdr_len + len; 166004d6530SBoaz Harrosh 1679c19a7d0SMike Christie if (exp_len > task->hdr_max) { 168004d6530SBoaz Harrosh WARN_ON(1); 169004d6530SBoaz Harrosh return -EINVAL; 170004d6530SBoaz Harrosh } 171004d6530SBoaz Harrosh 172004d6530SBoaz Harrosh WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */ 1739c19a7d0SMike Christie task->hdr_len = exp_len; 174004d6530SBoaz Harrosh return 0; 175004d6530SBoaz Harrosh } 176004d6530SBoaz Harrosh 17738d1c069SBoaz Harrosh /* 17838d1c069SBoaz Harrosh * make an extended cdb AHS 17938d1c069SBoaz Harrosh */ 1809c19a7d0SMike Christie static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) 18138d1c069SBoaz Harrosh { 1829c19a7d0SMike Christie struct scsi_cmnd *cmd = task->sc; 18338d1c069SBoaz Harrosh unsigned rlen, pad_len; 18438d1c069SBoaz Harrosh unsigned short ahslength; 18538d1c069SBoaz Harrosh struct iscsi_ecdb_ahdr *ecdb_ahdr; 18638d1c069SBoaz Harrosh int rc; 18738d1c069SBoaz Harrosh 1889c19a7d0SMike Christie ecdb_ahdr = iscsi_next_hdr(task); 18938d1c069SBoaz Harrosh rlen = cmd->cmd_len - ISCSI_CDB_SIZE; 19038d1c069SBoaz Harrosh 19138d1c069SBoaz Harrosh BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb)); 19238d1c069SBoaz Harrosh ahslength = rlen + sizeof(ecdb_ahdr->reserved); 19338d1c069SBoaz Harrosh 19438d1c069SBoaz Harrosh pad_len = iscsi_padding(rlen); 19538d1c069SBoaz Harrosh 1969c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) + 19738d1c069SBoaz Harrosh sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len); 19838d1c069SBoaz Harrosh if (rc) 19938d1c069SBoaz Harrosh return rc; 20038d1c069SBoaz Harrosh 20138d1c069SBoaz Harrosh if (pad_len) 20238d1c069SBoaz Harrosh memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len); 20338d1c069SBoaz Harrosh 20438d1c069SBoaz Harrosh ecdb_ahdr->ahslength = cpu_to_be16(ahslength); 20538d1c069SBoaz Harrosh ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB; 20638d1c069SBoaz Harrosh ecdb_ahdr->reserved = 0; 20738d1c069SBoaz Harrosh memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen); 20838d1c069SBoaz Harrosh 2091b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2101b2c7af8SMike Christie "iscsi_prep_ecdb_ahs: varlen_cdb_len %d " 2111b2c7af8SMike Christie "rlen %d pad_len %d ahs_length %d iscsi_headers_size " 2121b2c7af8SMike Christie "%u\n", cmd->cmd_len, rlen, pad_len, ahslength, 2131b2c7af8SMike Christie task->hdr_len); 21438d1c069SBoaz Harrosh return 0; 21538d1c069SBoaz Harrosh } 21638d1c069SBoaz Harrosh 2179c19a7d0SMike Christie static int iscsi_prep_bidi_ahs(struct iscsi_task *task) 218c07d4444SBoaz Harrosh { 2199c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 220c07d4444SBoaz Harrosh struct iscsi_rlength_ahdr *rlen_ahdr; 221c07d4444SBoaz Harrosh int rc; 222c07d4444SBoaz Harrosh 2239c19a7d0SMike Christie rlen_ahdr = iscsi_next_hdr(task); 2249c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*rlen_ahdr)); 225c07d4444SBoaz Harrosh if (rc) 226c07d4444SBoaz Harrosh return rc; 227c07d4444SBoaz Harrosh 228c07d4444SBoaz Harrosh rlen_ahdr->ahslength = 229c07d4444SBoaz Harrosh cpu_to_be16(sizeof(rlen_ahdr->read_length) + 230c07d4444SBoaz Harrosh sizeof(rlen_ahdr->reserved)); 231c07d4444SBoaz Harrosh rlen_ahdr->ahstype = ISCSI_AHSTYPE_RLENGTH; 232c07d4444SBoaz Harrosh rlen_ahdr->reserved = 0; 233c07d4444SBoaz Harrosh rlen_ahdr->read_length = cpu_to_be32(scsi_in(sc)->length); 234c07d4444SBoaz Harrosh 2351b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2361b2c7af8SMike Christie "bidi-in rlen_ahdr->read_length(%d) " 237c07d4444SBoaz Harrosh "rlen_ahdr->ahslength(%d)\n", 238c07d4444SBoaz Harrosh be32_to_cpu(rlen_ahdr->read_length), 239c07d4444SBoaz Harrosh be16_to_cpu(rlen_ahdr->ahslength)); 240c07d4444SBoaz Harrosh return 0; 241c07d4444SBoaz Harrosh } 242c07d4444SBoaz Harrosh 2437996a778SMike Christie /** 2447996a778SMike Christie * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu 2459c19a7d0SMike Christie * @task: iscsi task 2467996a778SMike Christie * 2477996a778SMike Christie * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set 2487996a778SMike Christie * fields like dlength or final based on how much data it sends 2497996a778SMike Christie */ 2509c19a7d0SMike Christie static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task) 2517996a778SMike Christie { 2529c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 2537996a778SMike Christie struct iscsi_session *session = conn->session; 2549c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 255577577daSMike Christie struct iscsi_cmd *hdr; 25638d1c069SBoaz Harrosh unsigned hdrlength, cmd_len; 257262ef636SMike Christie itt_t itt; 258004d6530SBoaz Harrosh int rc; 2597996a778SMike Christie 260184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 2612ff79d52SMike Christie rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD); 262577577daSMike Christie if (rc) 263577577daSMike Christie return rc; 264184b57c6SMike Christie } 265577577daSMike Christie hdr = (struct iscsi_cmd *) task->hdr; 266262ef636SMike Christie itt = hdr->itt; 267577577daSMike Christie memset(hdr, 0, sizeof(*hdr)); 268577577daSMike Christie 2692ff79d52SMike Christie if (session->tt->parse_pdu_itt) 2702ff79d52SMike Christie hdr->itt = task->hdr_itt = itt; 2712ff79d52SMike Christie else 2722ff79d52SMike Christie hdr->itt = task->hdr_itt = build_itt(task->itt, 2732ff79d52SMike Christie task->conn->session->age); 2749c19a7d0SMike Christie task->hdr_len = 0; 2759c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*hdr)); 276004d6530SBoaz Harrosh if (rc) 277004d6530SBoaz Harrosh return rc; 2787996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_CMD; 2797996a778SMike Christie hdr->flags = ISCSI_ATTR_SIMPLE; 2807996a778SMike Christie int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun); 281577577daSMike Christie memcpy(task->lun, hdr->lun, sizeof(task->lun)); 282577577daSMike Christie hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn); 2837996a778SMike Christie session->cmdsn++; 2847996a778SMike Christie hdr->exp_statsn = cpu_to_be32(conn->exp_statsn); 28538d1c069SBoaz Harrosh cmd_len = sc->cmd_len; 28638d1c069SBoaz Harrosh if (cmd_len < ISCSI_CDB_SIZE) 28738d1c069SBoaz Harrosh memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len); 28838d1c069SBoaz Harrosh else if (cmd_len > ISCSI_CDB_SIZE) { 2899c19a7d0SMike Christie rc = iscsi_prep_ecdb_ahs(task); 29038d1c069SBoaz Harrosh if (rc) 29138d1c069SBoaz Harrosh return rc; 29238d1c069SBoaz Harrosh cmd_len = ISCSI_CDB_SIZE; 29338d1c069SBoaz Harrosh } 29438d1c069SBoaz Harrosh memcpy(hdr->cdb, sc->cmnd, cmd_len); 2957996a778SMike Christie 2969c19a7d0SMike Christie task->imm_count = 0; 297c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc)) { 298c07d4444SBoaz Harrosh hdr->flags |= ISCSI_FLAG_CMD_READ; 2999c19a7d0SMike Christie rc = iscsi_prep_bidi_ahs(task); 300c07d4444SBoaz Harrosh if (rc) 301c07d4444SBoaz Harrosh return rc; 302c07d4444SBoaz Harrosh } 3037996a778SMike Christie if (sc->sc_data_direction == DMA_TO_DEVICE) { 304c07d4444SBoaz Harrosh unsigned out_len = scsi_out(sc)->length; 305577577daSMike Christie struct iscsi_r2t_info *r2t = &task->unsol_r2t; 306577577daSMike Christie 307c07d4444SBoaz Harrosh hdr->data_length = cpu_to_be32(out_len); 3087996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_WRITE; 3097996a778SMike Christie /* 3107996a778SMike Christie * Write counters: 3117996a778SMike Christie * 3127996a778SMike Christie * imm_count bytes to be sent right after 3137996a778SMike Christie * SCSI PDU Header 3147996a778SMike Christie * 3157996a778SMike Christie * unsol_count bytes(as Data-Out) to be sent 3167996a778SMike Christie * without R2T ack right after 3177996a778SMike Christie * immediate data 3187996a778SMike Christie * 319577577daSMike Christie * r2t data_length bytes to be sent via R2T ack's 3207996a778SMike Christie * 3217996a778SMike Christie * pad_count bytes to be sent as zero-padding 3227996a778SMike Christie */ 323577577daSMike Christie memset(r2t, 0, sizeof(*r2t)); 3247996a778SMike Christie 3257996a778SMike Christie if (session->imm_data_en) { 326c07d4444SBoaz Harrosh if (out_len >= session->first_burst) 3279c19a7d0SMike Christie task->imm_count = min(session->first_burst, 3287996a778SMike Christie conn->max_xmit_dlength); 3297996a778SMike Christie else 3309c19a7d0SMike Christie task->imm_count = min(out_len, 3317996a778SMike Christie conn->max_xmit_dlength); 3329c19a7d0SMike Christie hton24(hdr->dlength, task->imm_count); 3337996a778SMike Christie } else 334a8ac6311SOlaf Kirch zero_data(hdr->dlength); 3357996a778SMike Christie 336ffd0436eSMike Christie if (!session->initial_r2t_en) { 337577577daSMike Christie r2t->data_length = min(session->first_burst, out_len) - 338577577daSMike Christie task->imm_count; 339577577daSMike Christie r2t->data_offset = task->imm_count; 340577577daSMike Christie r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG); 341577577daSMike Christie r2t->exp_statsn = cpu_to_be32(conn->exp_statsn); 342ffd0436eSMike Christie } 343ffd0436eSMike Christie 344577577daSMike Christie if (!task->unsol_r2t.data_length) 3457996a778SMike Christie /* No unsolicit Data-Out's */ 346a8ac6311SOlaf Kirch hdr->flags |= ISCSI_FLAG_CMD_FINAL; 3477996a778SMike Christie } else { 3487996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 3497996a778SMike Christie zero_data(hdr->dlength); 350c07d4444SBoaz Harrosh hdr->data_length = cpu_to_be32(scsi_in(sc)->length); 3517996a778SMike Christie 3527996a778SMike Christie if (sc->sc_data_direction == DMA_FROM_DEVICE) 3537996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_READ; 3547996a778SMike Christie } 3557996a778SMike Christie 356004d6530SBoaz Harrosh /* calculate size of additional header segments (AHSs) */ 3579c19a7d0SMike Christie hdrlength = task->hdr_len - sizeof(*hdr); 358004d6530SBoaz Harrosh 359004d6530SBoaz Harrosh WARN_ON(hdrlength & (ISCSI_PAD_LEN-1)); 360004d6530SBoaz Harrosh hdrlength /= ISCSI_PAD_LEN; 361004d6530SBoaz Harrosh 362004d6530SBoaz Harrosh WARN_ON(hdrlength >= 256); 363004d6530SBoaz Harrosh hdr->hlength = hdrlength & 0xFF; 364004d6530SBoaz Harrosh 365577577daSMike Christie if (session->tt->init_task && session->tt->init_task(task)) 366052d0144SMike Christie return -EIO; 367052d0144SMike Christie 3689c19a7d0SMike Christie task->state = ISCSI_TASK_RUNNING; 3699c19a7d0SMike Christie list_move_tail(&task->running, &conn->run_list); 37077a23c21SMike Christie 371a8ac6311SOlaf Kirch conn->scsicmd_pdus_cnt++; 3721b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi prep [%s cid %d sc %p cdb 0x%x " 3731b2c7af8SMike Christie "itt 0x%x len %d bidi_len %d cmdsn %d win %d]\n", 3741b2c7af8SMike Christie scsi_bidi_cmnd(sc) ? "bidirectional" : 3751b2c7af8SMike Christie sc->sc_data_direction == DMA_TO_DEVICE ? 3761b2c7af8SMike Christie "write" : "read", conn->id, sc, sc->cmnd[0], 3771b2c7af8SMike Christie task->itt, scsi_bufflen(sc), 3783e5c28adSMike Christie scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0, 3791b2c7af8SMike Christie session->cmdsn, 3801b2c7af8SMike Christie session->max_cmdsn - session->exp_cmdsn + 1); 381004d6530SBoaz Harrosh return 0; 3827996a778SMike Christie } 3837996a778SMike Christie 3847996a778SMike Christie /** 3853e5c28adSMike Christie * iscsi_complete_command - finish a task 3869c19a7d0SMike Christie * @task: iscsi cmd task 3877996a778SMike Christie * 3887996a778SMike Christie * Must be called with session lock. 3893e5c28adSMike Christie * This function returns the scsi command to scsi-ml or cleans 3903e5c28adSMike Christie * up mgmt tasks then returns the task to the pool. 3917996a778SMike Christie */ 3929c19a7d0SMike Christie static void iscsi_complete_command(struct iscsi_task *task) 3937996a778SMike Christie { 3949c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 395c1635cb7SMike Christie struct iscsi_session *session = conn->session; 3969c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 3977996a778SMike Christie 398577577daSMike Christie session->tt->cleanup_task(task); 3999c19a7d0SMike Christie list_del_init(&task->running); 4009c19a7d0SMike Christie task->state = ISCSI_TASK_COMPLETED; 4019c19a7d0SMike Christie task->sc = NULL; 4023e5c28adSMike Christie 4039c19a7d0SMike Christie if (conn->task == task) 4049c19a7d0SMike Christie conn->task = NULL; 4053e5c28adSMike Christie /* 4069c19a7d0SMike Christie * login task is preallocated so do not free 4073e5c28adSMike Christie */ 4089c19a7d0SMike Christie if (conn->login_task == task) 4093e5c28adSMike Christie return; 4103e5c28adSMike Christie 4119c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&task, sizeof(void*)); 4123e5c28adSMike Christie 4139c19a7d0SMike Christie if (conn->ping_task == task) 4149c19a7d0SMike Christie conn->ping_task = NULL; 4153e5c28adSMike Christie 4163e5c28adSMike Christie if (sc) { 4179c19a7d0SMike Christie task->sc = NULL; 418f47f2cf5SMike Christie /* SCSI eh reuses commands to verify us */ 419f47f2cf5SMike Christie sc->SCp.ptr = NULL; 4203e5c28adSMike Christie /* 4213e5c28adSMike Christie * queue command may call this to free the task, but 4223e5c28adSMike Christie * not have setup the sc callback 4233e5c28adSMike Christie */ 424052d0144SMike Christie if (sc->scsi_done) 4257996a778SMike Christie sc->scsi_done(sc); 4267996a778SMike Christie } 4273e5c28adSMike Christie } 4287996a778SMike Christie 429913e5bf4SMike Christie void __iscsi_get_task(struct iscsi_task *task) 43060ecebf5SMike Christie { 4319c19a7d0SMike Christie atomic_inc(&task->refcount); 43260ecebf5SMike Christie } 433913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_get_task); 43460ecebf5SMike Christie 4359c19a7d0SMike Christie static void __iscsi_put_task(struct iscsi_task *task) 43660ecebf5SMike Christie { 4379c19a7d0SMike Christie if (atomic_dec_and_test(&task->refcount)) 4389c19a7d0SMike Christie iscsi_complete_command(task); 43960ecebf5SMike Christie } 44060ecebf5SMike Christie 4419c19a7d0SMike Christie void iscsi_put_task(struct iscsi_task *task) 4423e5c28adSMike Christie { 4439c19a7d0SMike Christie struct iscsi_session *session = task->conn->session; 4443e5c28adSMike Christie 4453e5c28adSMike Christie spin_lock_bh(&session->lock); 4469c19a7d0SMike Christie __iscsi_put_task(task); 4473e5c28adSMike Christie spin_unlock_bh(&session->lock); 4483e5c28adSMike Christie } 4499c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_put_task); 4503e5c28adSMike Christie 451b3a7ea8dSMike Christie /* 452b3a7ea8dSMike Christie * session lock must be held 453b3a7ea8dSMike Christie */ 4549c19a7d0SMike Christie static void fail_command(struct iscsi_conn *conn, struct iscsi_task *task, 455b3a7ea8dSMike Christie int err) 456b3a7ea8dSMike Christie { 457b3a7ea8dSMike Christie struct scsi_cmnd *sc; 458b3a7ea8dSMike Christie 4599c19a7d0SMike Christie sc = task->sc; 460b3a7ea8dSMike Christie if (!sc) 461b3a7ea8dSMike Christie return; 462b3a7ea8dSMike Christie 4639c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) 464b3a7ea8dSMike Christie /* 465b3a7ea8dSMike Christie * cmd never made it to the xmit thread, so we should not count 466b3a7ea8dSMike Christie * the cmd in the sequencing 467b3a7ea8dSMike Christie */ 468b3a7ea8dSMike Christie conn->session->queued_cmdsn--; 469b3a7ea8dSMike Christie 470b3a7ea8dSMike Christie sc->result = err; 471c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 472b3a7ea8dSMike Christie scsi_set_resid(sc, scsi_bufflen(sc)); 473c07d4444SBoaz Harrosh else { 474c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 475c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 476c07d4444SBoaz Harrosh } 4773e5c28adSMike Christie 4789c19a7d0SMike Christie if (conn->task == task) 4799c19a7d0SMike Christie conn->task = NULL; 480b3a7ea8dSMike Christie /* release ref from queuecommand */ 4819c19a7d0SMike Christie __iscsi_put_task(task); 482b3a7ea8dSMike Christie } 483b3a7ea8dSMike Christie 4843e5c28adSMike Christie static int iscsi_prep_mgmt_task(struct iscsi_conn *conn, 4859c19a7d0SMike Christie struct iscsi_task *task) 486052d0144SMike Christie { 487052d0144SMike Christie struct iscsi_session *session = conn->session; 488577577daSMike Christie struct iscsi_hdr *hdr = task->hdr; 489052d0144SMike Christie struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr; 490052d0144SMike Christie 491052d0144SMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 492052d0144SMike Christie return -ENOTCONN; 493052d0144SMike Christie 494052d0144SMike Christie if (hdr->opcode != (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) && 495052d0144SMike Christie hdr->opcode != (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE)) 496052d0144SMike Christie nop->exp_statsn = cpu_to_be32(conn->exp_statsn); 497052d0144SMike Christie /* 498052d0144SMike Christie * pre-format CmdSN for outgoing PDU. 499052d0144SMike Christie */ 500052d0144SMike Christie nop->cmdsn = cpu_to_be32(session->cmdsn); 501052d0144SMike Christie if (hdr->itt != RESERVED_ITT) { 502052d0144SMike Christie /* 503052d0144SMike Christie * TODO: We always use immediate, so we never hit this. 504052d0144SMike Christie * If we start to send tmfs or nops as non-immediate then 505052d0144SMike Christie * we should start checking the cmdsn numbers for mgmt tasks. 506052d0144SMike Christie */ 507052d0144SMike Christie if (conn->c_stage == ISCSI_CONN_STARTED && 508052d0144SMike Christie !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 509052d0144SMike Christie session->queued_cmdsn++; 510052d0144SMike Christie session->cmdsn++; 511052d0144SMike Christie } 512052d0144SMike Christie } 513052d0144SMike Christie 514ae15f801SMike Christie if (session->tt->init_task && session->tt->init_task(task)) 515ae15f801SMike Christie return -EIO; 516052d0144SMike Christie 517052d0144SMike Christie if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT) 518052d0144SMike Christie session->state = ISCSI_STATE_LOGGING_OUT; 519052d0144SMike Christie 520577577daSMike Christie task->state = ISCSI_TASK_RUNNING; 5219c19a7d0SMike Christie list_move_tail(&task->running, &conn->mgmt_run_list); 5221b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "mgmtpdu [op 0x%x hdr->itt 0x%x " 5231b2c7af8SMike Christie "datalen %d]\n", hdr->opcode & ISCSI_OPCODE_MASK, 5241b2c7af8SMike Christie hdr->itt, task->data_count); 525052d0144SMike Christie return 0; 526052d0144SMike Christie } 527052d0144SMike Christie 5289c19a7d0SMike Christie static struct iscsi_task * 529f6d5180cSMike Christie __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 530f6d5180cSMike Christie char *data, uint32_t data_size) 531f6d5180cSMike Christie { 532f6d5180cSMike Christie struct iscsi_session *session = conn->session; 5339c19a7d0SMike Christie struct iscsi_task *task; 534262ef636SMike Christie itt_t itt; 535f6d5180cSMike Christie 536f6d5180cSMike Christie if (session->state == ISCSI_STATE_TERMINATE) 537f6d5180cSMike Christie return NULL; 538f6d5180cSMike Christie 539f6d5180cSMike Christie if (hdr->opcode == (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) || 540f6d5180cSMike Christie hdr->opcode == (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE)) 541f6d5180cSMike Christie /* 542f6d5180cSMike Christie * Login and Text are sent serially, in 543f6d5180cSMike Christie * request-followed-by-response sequence. 5443e5c28adSMike Christie * Same task can be used. Same ITT must be used. 5453e5c28adSMike Christie * Note that login_task is preallocated at conn_create(). 546f6d5180cSMike Christie */ 5479c19a7d0SMike Christie task = conn->login_task; 548f6d5180cSMike Christie else { 549f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE); 550f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED); 551f6d5180cSMike Christie 5523e5c28adSMike Christie if (!__kfifo_get(session->cmdpool.queue, 5539c19a7d0SMike Christie (void*)&task, sizeof(void*))) 554f6d5180cSMike Christie return NULL; 555f6d5180cSMike Christie } 5563e5c28adSMike Christie /* 5573e5c28adSMike Christie * released in complete pdu for task we expect a response for, and 5583e5c28adSMike Christie * released by the lld when it has transmitted the task for 5593e5c28adSMike Christie * pdus we do not expect a response for. 5603e5c28adSMike Christie */ 5619c19a7d0SMike Christie atomic_set(&task->refcount, 1); 5629c19a7d0SMike Christie task->conn = conn; 5639c19a7d0SMike Christie task->sc = NULL; 564f6d5180cSMike Christie 565f6d5180cSMike Christie if (data_size) { 5669c19a7d0SMike Christie memcpy(task->data, data, data_size); 5679c19a7d0SMike Christie task->data_count = data_size; 568f6d5180cSMike Christie } else 5699c19a7d0SMike Christie task->data_count = 0; 570f6d5180cSMike Christie 571184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 5722ff79d52SMike Christie if (conn->session->tt->alloc_pdu(task, hdr->opcode)) { 573577577daSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not allocate " 574577577daSMike Christie "pdu for mgmt task.\n"); 575577577daSMike Christie goto requeue_task; 576577577daSMike Christie } 577184b57c6SMike Christie } 578184b57c6SMike Christie 579262ef636SMike Christie itt = task->hdr->itt; 580577577daSMike Christie task->hdr_len = sizeof(struct iscsi_hdr); 5819c19a7d0SMike Christie memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr)); 582262ef636SMike Christie 583262ef636SMike Christie if (hdr->itt != RESERVED_ITT) { 584262ef636SMike Christie if (session->tt->parse_pdu_itt) 585262ef636SMike Christie task->hdr->itt = itt; 586262ef636SMike Christie else 587262ef636SMike Christie task->hdr->itt = build_itt(task->itt, 588262ef636SMike Christie task->conn->session->age); 589262ef636SMike Christie } 590262ef636SMike Christie 5919c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 5929c19a7d0SMike Christie list_add_tail(&task->running, &conn->mgmtqueue); 593052d0144SMike Christie 594052d0144SMike Christie if (session->tt->caps & CAP_DATA_PATH_OFFLOAD) { 595577577daSMike Christie if (iscsi_prep_mgmt_task(conn, task)) 596577577daSMike Christie goto free_task; 597052d0144SMike Christie 5989c19a7d0SMike Christie if (session->tt->xmit_task(task)) 599577577daSMike Christie goto free_task; 600052d0144SMike Christie 601052d0144SMike Christie } else 60232ae763eSMike Christie iscsi_conn_queue_work(conn); 603052d0144SMike Christie 6049c19a7d0SMike Christie return task; 605577577daSMike Christie 606577577daSMike Christie free_task: 607577577daSMike Christie __iscsi_put_task(task); 608577577daSMike Christie return NULL; 609577577daSMike Christie 610577577daSMike Christie requeue_task: 611577577daSMike Christie if (task != conn->login_task) 612577577daSMike Christie __kfifo_put(session->cmdpool.queue, (void*)&task, 613577577daSMike Christie sizeof(void*)); 614577577daSMike Christie return NULL; 615f6d5180cSMike Christie } 616f6d5180cSMike Christie 617f6d5180cSMike Christie int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr, 618f6d5180cSMike Christie char *data, uint32_t data_size) 619f6d5180cSMike Christie { 620f6d5180cSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 621f6d5180cSMike Christie struct iscsi_session *session = conn->session; 622f6d5180cSMike Christie int err = 0; 623f6d5180cSMike Christie 624f6d5180cSMike Christie spin_lock_bh(&session->lock); 625f6d5180cSMike Christie if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size)) 626f6d5180cSMike Christie err = -EPERM; 627f6d5180cSMike Christie spin_unlock_bh(&session->lock); 628f6d5180cSMike Christie return err; 629f6d5180cSMike Christie } 630f6d5180cSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu); 631f6d5180cSMike Christie 6327996a778SMike Christie /** 6337996a778SMike Christie * iscsi_cmd_rsp - SCSI Command Response processing 6347996a778SMike Christie * @conn: iscsi connection 6357996a778SMike Christie * @hdr: iscsi header 6369c19a7d0SMike Christie * @task: scsi command task 6377996a778SMike Christie * @data: cmd data buffer 6387996a778SMike Christie * @datalen: len of buffer 6397996a778SMike Christie * 6407996a778SMike Christie * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and 6419c19a7d0SMike Christie * then completes the command and task. 6427996a778SMike Christie **/ 64377a23c21SMike Christie static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 6449c19a7d0SMike Christie struct iscsi_task *task, char *data, 6457996a778SMike Christie int datalen) 6467996a778SMike Christie { 6477996a778SMike Christie struct iscsi_cmd_rsp *rhdr = (struct iscsi_cmd_rsp *)hdr; 6487996a778SMike Christie struct iscsi_session *session = conn->session; 6499c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 6507996a778SMike Christie 65177a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr); 6527996a778SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 6537996a778SMike Christie 6547996a778SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 6557996a778SMike Christie 6567996a778SMike Christie if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) { 6577996a778SMike Christie sc->result = DID_ERROR << 16; 6587996a778SMike Christie goto out; 6597996a778SMike Christie } 6607996a778SMike Christie 6617996a778SMike Christie if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) { 6629b80cb4bSMike Christie uint16_t senselen; 6637996a778SMike Christie 6647996a778SMike Christie if (datalen < 2) { 6657996a778SMike Christie invalid_datalen: 666322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 667322d739dSMike Christie "Got CHECK_CONDITION but invalid data " 668322d739dSMike Christie "buffer size of %d\n", datalen); 6697996a778SMike Christie sc->result = DID_BAD_TARGET << 16; 6707996a778SMike Christie goto out; 6717996a778SMike Christie } 6727996a778SMike Christie 6738f333991SHarvey Harrison senselen = get_unaligned_be16(data); 6747996a778SMike Christie if (datalen < senselen) 6757996a778SMike Christie goto invalid_datalen; 6767996a778SMike Christie 6777996a778SMike Christie memcpy(sc->sense_buffer, data + 2, 6789b80cb4bSMike Christie min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 6791b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n", 6801b2c7af8SMike Christie min_t(uint16_t, senselen, 6811b2c7af8SMike Christie SCSI_SENSE_BUFFERSIZE)); 6827996a778SMike Christie } 6837996a778SMike Christie 684c07d4444SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW | 685c07d4444SBoaz Harrosh ISCSI_FLAG_CMD_BIDI_OVERFLOW)) { 686c07d4444SBoaz Harrosh int res_count = be32_to_cpu(rhdr->bi_residual_count); 687c07d4444SBoaz Harrosh 688c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc) && res_count > 0 && 689c07d4444SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_BIDI_OVERFLOW || 690c07d4444SBoaz Harrosh res_count <= scsi_in(sc)->length)) 691c07d4444SBoaz Harrosh scsi_in(sc)->resid = res_count; 692c07d4444SBoaz Harrosh else 693c07d4444SBoaz Harrosh sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 694c07d4444SBoaz Harrosh } 695c07d4444SBoaz Harrosh 6967207fea4SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW | 6977207fea4SBoaz Harrosh ISCSI_FLAG_CMD_OVERFLOW)) { 6987996a778SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 6997996a778SMike Christie 7007207fea4SBoaz Harrosh if (res_count > 0 && 7017207fea4SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 7027207fea4SBoaz Harrosh res_count <= scsi_bufflen(sc))) 703c07d4444SBoaz Harrosh /* write side for bidi or uni-io set_resid */ 7041c138991SFUJITA Tomonori scsi_set_resid(sc, res_count); 7057996a778SMike Christie else 7067996a778SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 707c07d4444SBoaz Harrosh } 7087996a778SMike Christie out: 7091b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "done [sc %p res %d itt 0x%x]\n", 7101b2c7af8SMike Christie sc, sc->result, task->itt); 7117996a778SMike Christie conn->scsirsp_pdus_cnt++; 7127996a778SMike Christie 7139c19a7d0SMike Christie __iscsi_put_task(task); 7147996a778SMike Christie } 7157996a778SMike Christie 7161d9edf02SMike Christie /** 7171d9edf02SMike Christie * iscsi_data_in_rsp - SCSI Data-In Response processing 7181d9edf02SMike Christie * @conn: iscsi connection 7191d9edf02SMike Christie * @hdr: iscsi pdu 7201d9edf02SMike Christie * @task: scsi command task 7211d9edf02SMike Christie **/ 7221d9edf02SMike Christie static void 7231d9edf02SMike Christie iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 7241d9edf02SMike Christie struct iscsi_task *task) 7251d9edf02SMike Christie { 7261d9edf02SMike Christie struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr; 7271d9edf02SMike Christie struct scsi_cmnd *sc = task->sc; 7281d9edf02SMike Christie 7291d9edf02SMike Christie if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS)) 7301d9edf02SMike Christie return; 7311d9edf02SMike Christie 7321d9edf02SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 7331d9edf02SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 7341d9edf02SMike Christie if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW | 7351d9edf02SMike Christie ISCSI_FLAG_DATA_OVERFLOW)) { 7361d9edf02SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 7371d9edf02SMike Christie 7381d9edf02SMike Christie if (res_count > 0 && 7391d9edf02SMike Christie (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 7401d9edf02SMike Christie res_count <= scsi_in(sc)->length)) 7411d9edf02SMike Christie scsi_in(sc)->resid = res_count; 7421d9edf02SMike Christie else 7431d9edf02SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 7441d9edf02SMike Christie } 7451d9edf02SMike Christie 7461d9edf02SMike Christie conn->scsirsp_pdus_cnt++; 7471d9edf02SMike Christie __iscsi_put_task(task); 7481d9edf02SMike Christie } 7491d9edf02SMike Christie 7507ea8b828SMike Christie static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) 7517ea8b828SMike Christie { 7527ea8b828SMike Christie struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; 7537ea8b828SMike Christie 7547ea8b828SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 7557ea8b828SMike Christie conn->tmfrsp_pdus_cnt++; 7567ea8b828SMike Christie 757843c0a8aSMike Christie if (conn->tmf_state != TMF_QUEUED) 7587ea8b828SMike Christie return; 7597ea8b828SMike Christie 7607ea8b828SMike Christie if (tmf->response == ISCSI_TMF_RSP_COMPLETE) 761843c0a8aSMike Christie conn->tmf_state = TMF_SUCCESS; 7627ea8b828SMike Christie else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) 763843c0a8aSMike Christie conn->tmf_state = TMF_NOT_FOUND; 7647ea8b828SMike Christie else 765843c0a8aSMike Christie conn->tmf_state = TMF_FAILED; 7667ea8b828SMike Christie wake_up(&conn->ehwait); 7677ea8b828SMike Christie } 7687ea8b828SMike Christie 769f6d5180cSMike Christie static void iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) 770f6d5180cSMike Christie { 771f6d5180cSMike Christie struct iscsi_nopout hdr; 7729c19a7d0SMike Christie struct iscsi_task *task; 773f6d5180cSMike Christie 7749c19a7d0SMike Christie if (!rhdr && conn->ping_task) 775f6d5180cSMike Christie return; 776f6d5180cSMike Christie 777f6d5180cSMike Christie memset(&hdr, 0, sizeof(struct iscsi_nopout)); 778f6d5180cSMike Christie hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE; 779f6d5180cSMike Christie hdr.flags = ISCSI_FLAG_CMD_FINAL; 780f6d5180cSMike Christie 781f6d5180cSMike Christie if (rhdr) { 782f6d5180cSMike Christie memcpy(hdr.lun, rhdr->lun, 8); 783f6d5180cSMike Christie hdr.ttt = rhdr->ttt; 784f6d5180cSMike Christie hdr.itt = RESERVED_ITT; 785f6d5180cSMike Christie } else 786f6d5180cSMike Christie hdr.ttt = RESERVED_ITT; 787f6d5180cSMike Christie 7889c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0); 7899c19a7d0SMike Christie if (!task) 790322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n"); 791d3acf022SMike Christie else if (!rhdr) { 792d3acf022SMike Christie /* only track our nops */ 793d3acf022SMike Christie conn->ping_task = task; 794d3acf022SMike Christie conn->last_ping = jiffies; 795d3acf022SMike Christie } 796f6d5180cSMike Christie } 797f6d5180cSMike Christie 79862f38300SMike Christie static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 79962f38300SMike Christie char *data, int datalen) 80062f38300SMike Christie { 80162f38300SMike Christie struct iscsi_reject *reject = (struct iscsi_reject *)hdr; 80262f38300SMike Christie struct iscsi_hdr rejected_pdu; 80362f38300SMike Christie 80462f38300SMike Christie conn->exp_statsn = be32_to_cpu(reject->statsn) + 1; 80562f38300SMike Christie 80662f38300SMike Christie if (reject->reason == ISCSI_REASON_DATA_DIGEST_ERROR) { 80762f38300SMike Christie if (ntoh24(reject->dlength) > datalen) 80862f38300SMike Christie return ISCSI_ERR_PROTO; 80962f38300SMike Christie 81062f38300SMike Christie if (ntoh24(reject->dlength) >= sizeof(struct iscsi_hdr)) { 81162f38300SMike Christie memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr)); 812322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 813262ef636SMike Christie "pdu (op 0x%x) rejected " 814262ef636SMike Christie "due to DataDigest error.\n", 81562f38300SMike Christie rejected_pdu.opcode); 81662f38300SMike Christie } 81762f38300SMike Christie } 81862f38300SMike Christie return 0; 81962f38300SMike Christie } 82062f38300SMike Christie 8217996a778SMike Christie /** 822913e5bf4SMike Christie * iscsi_itt_to_task - look up task by itt 823913e5bf4SMike Christie * @conn: iscsi connection 824913e5bf4SMike Christie * @itt: itt 825913e5bf4SMike Christie * 826913e5bf4SMike Christie * This should be used for mgmt tasks like login and nops, or if 827913e5bf4SMike Christie * the LDD's itt space does not include the session age. 828913e5bf4SMike Christie * 829913e5bf4SMike Christie * The session lock must be held. 830913e5bf4SMike Christie */ 8318f9256ceSMike Christie struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt) 832913e5bf4SMike Christie { 833913e5bf4SMike Christie struct iscsi_session *session = conn->session; 834262ef636SMike Christie int i; 835913e5bf4SMike Christie 836913e5bf4SMike Christie if (itt == RESERVED_ITT) 837913e5bf4SMike Christie return NULL; 838913e5bf4SMike Christie 839262ef636SMike Christie if (session->tt->parse_pdu_itt) 840262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, NULL); 841262ef636SMike Christie else 842913e5bf4SMike Christie i = get_itt(itt); 843913e5bf4SMike Christie if (i >= session->cmds_max) 844913e5bf4SMike Christie return NULL; 845913e5bf4SMike Christie 846913e5bf4SMike Christie return session->cmds[i]; 847913e5bf4SMike Christie } 8488f9256ceSMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_task); 849913e5bf4SMike Christie 850913e5bf4SMike Christie /** 8517996a778SMike Christie * __iscsi_complete_pdu - complete pdu 8527996a778SMike Christie * @conn: iscsi conn 8537996a778SMike Christie * @hdr: iscsi header 8547996a778SMike Christie * @data: data buffer 8557996a778SMike Christie * @datalen: len of data buffer 8567996a778SMike Christie * 8577996a778SMike Christie * Completes pdu processing by freeing any resources allocated at 8587996a778SMike Christie * queuecommand or send generic. session lock must be held and verify 8597996a778SMike Christie * itt must have been called. 8607996a778SMike Christie */ 861913e5bf4SMike Christie int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 8627996a778SMike Christie char *data, int datalen) 8637996a778SMike Christie { 8647996a778SMike Christie struct iscsi_session *session = conn->session; 8657996a778SMike Christie int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0; 8669c19a7d0SMike Christie struct iscsi_task *task; 8677996a778SMike Christie uint32_t itt; 8687996a778SMike Christie 869f6d5180cSMike Christie conn->last_recv = jiffies; 8700af967f5SMike Christie rc = iscsi_verify_itt(conn, hdr->itt); 8710af967f5SMike Christie if (rc) 8720af967f5SMike Christie return rc; 8730af967f5SMike Christie 874b4377356SAl Viro if (hdr->itt != RESERVED_ITT) 875b4377356SAl Viro itt = get_itt(hdr->itt); 8767996a778SMike Christie else 877b4377356SAl Viro itt = ~0U; 8787996a778SMike Christie 8791b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "[op 0x%x cid %d itt 0x%x len %d]\n", 8803e5c28adSMike Christie opcode, conn->id, itt, datalen); 8817996a778SMike Christie 8823e5c28adSMike Christie if (itt == ~0U) { 88377a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 88462f38300SMike Christie 8857996a778SMike Christie switch(opcode) { 8867996a778SMike Christie case ISCSI_OP_NOOP_IN: 88740527afeSMike Christie if (datalen) { 88840527afeSMike Christie rc = ISCSI_ERR_PROTO; 88940527afeSMike Christie break; 89040527afeSMike Christie } 89140527afeSMike Christie 892b4377356SAl Viro if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) 89340527afeSMike Christie break; 89440527afeSMike Christie 895f6d5180cSMike Christie iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr); 8967996a778SMike Christie break; 8977996a778SMike Christie case ISCSI_OP_REJECT: 89862f38300SMike Christie rc = iscsi_handle_reject(conn, hdr, data, datalen); 89962f38300SMike Christie break; 9007996a778SMike Christie case ISCSI_OP_ASYNC_EVENT: 9018d2860b3SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 9025831c737SMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 9035831c737SMike Christie rc = ISCSI_ERR_CONN_FAILED; 9047996a778SMike Christie break; 9057996a778SMike Christie default: 9067996a778SMike Christie rc = ISCSI_ERR_BAD_OPCODE; 9077996a778SMike Christie break; 9087996a778SMike Christie } 9093e5c28adSMike Christie goto out; 9103e5c28adSMike Christie } 9117996a778SMike Christie 9123e5c28adSMike Christie switch(opcode) { 9133e5c28adSMike Christie case ISCSI_OP_SCSI_CMD_RSP: 914913e5bf4SMike Christie case ISCSI_OP_SCSI_DATA_IN: 915913e5bf4SMike Christie task = iscsi_itt_to_ctask(conn, hdr->itt); 916913e5bf4SMike Christie if (!task) 917913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 9183e5c28adSMike Christie break; 919913e5bf4SMike Christie case ISCSI_OP_R2T: 920913e5bf4SMike Christie /* 921913e5bf4SMike Christie * LLD handles R2Ts if they need to. 922913e5bf4SMike Christie */ 923913e5bf4SMike Christie return 0; 924913e5bf4SMike Christie case ISCSI_OP_LOGOUT_RSP: 925913e5bf4SMike Christie case ISCSI_OP_LOGIN_RSP: 926913e5bf4SMike Christie case ISCSI_OP_TEXT_RSP: 927913e5bf4SMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 928913e5bf4SMike Christie case ISCSI_OP_NOOP_IN: 929913e5bf4SMike Christie task = iscsi_itt_to_task(conn, hdr->itt); 930913e5bf4SMike Christie if (!task) 931913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 932913e5bf4SMike Christie break; 933913e5bf4SMike Christie default: 934913e5bf4SMike Christie return ISCSI_ERR_BAD_OPCODE; 9353e5c28adSMike Christie } 936913e5bf4SMike Christie 937913e5bf4SMike Christie switch(opcode) { 938913e5bf4SMike Christie case ISCSI_OP_SCSI_CMD_RSP: 9399c19a7d0SMike Christie iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen); 9403e5c28adSMike Christie break; 9413e5c28adSMike Christie case ISCSI_OP_SCSI_DATA_IN: 9421d9edf02SMike Christie iscsi_data_in_rsp(conn, hdr, task); 9433e5c28adSMike Christie break; 9443e5c28adSMike Christie case ISCSI_OP_LOGOUT_RSP: 9453e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 9463e5c28adSMike Christie if (datalen) { 9473e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 9483e5c28adSMike Christie break; 9493e5c28adSMike Christie } 9503e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 9513e5c28adSMike Christie goto recv_pdu; 9523e5c28adSMike Christie case ISCSI_OP_LOGIN_RSP: 9533e5c28adSMike Christie case ISCSI_OP_TEXT_RSP: 9543e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 9553e5c28adSMike Christie /* 9563e5c28adSMike Christie * login related PDU's exp_statsn is handled in 9573e5c28adSMike Christie * userspace 9583e5c28adSMike Christie */ 9593e5c28adSMike Christie goto recv_pdu; 9603e5c28adSMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 9613e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 9623e5c28adSMike Christie if (datalen) { 9633e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 9643e5c28adSMike Christie break; 9653e5c28adSMike Christie } 9663e5c28adSMike Christie 9673e5c28adSMike Christie iscsi_tmf_rsp(conn, hdr); 9689c19a7d0SMike Christie __iscsi_put_task(task); 9693e5c28adSMike Christie break; 9703e5c28adSMike Christie case ISCSI_OP_NOOP_IN: 9713e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 9723e5c28adSMike Christie if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) { 9733e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 9743e5c28adSMike Christie break; 9753e5c28adSMike Christie } 9763e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 9773e5c28adSMike Christie 9789c19a7d0SMike Christie if (conn->ping_task != task) 9793e5c28adSMike Christie /* 9803e5c28adSMike Christie * If this is not in response to one of our 9813e5c28adSMike Christie * nops then it must be from userspace. 9823e5c28adSMike Christie */ 9833e5c28adSMike Christie goto recv_pdu; 9849c19a7d0SMike Christie 9859c19a7d0SMike Christie mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout); 9869c19a7d0SMike Christie __iscsi_put_task(task); 9873e5c28adSMike Christie break; 9883e5c28adSMike Christie default: 9893e5c28adSMike Christie rc = ISCSI_ERR_BAD_OPCODE; 9903e5c28adSMike Christie break; 9913e5c28adSMike Christie } 9923e5c28adSMike Christie 9933e5c28adSMike Christie out: 9943e5c28adSMike Christie return rc; 9953e5c28adSMike Christie recv_pdu: 9963e5c28adSMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 9973e5c28adSMike Christie rc = ISCSI_ERR_CONN_FAILED; 9989c19a7d0SMike Christie __iscsi_put_task(task); 9997996a778SMike Christie return rc; 10007996a778SMike Christie } 1001913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_complete_pdu); 10027996a778SMike Christie 10037996a778SMike Christie int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 10047996a778SMike Christie char *data, int datalen) 10057996a778SMike Christie { 10067996a778SMike Christie int rc; 10077996a778SMike Christie 10087996a778SMike Christie spin_lock(&conn->session->lock); 10097996a778SMike Christie rc = __iscsi_complete_pdu(conn, hdr, data, datalen); 10107996a778SMike Christie spin_unlock(&conn->session->lock); 10117996a778SMike Christie return rc; 10127996a778SMike Christie } 10137996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_pdu); 10147996a778SMike Christie 10150af967f5SMike Christie int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt) 10167996a778SMike Christie { 10177996a778SMike Christie struct iscsi_session *session = conn->session; 1018262ef636SMike Christie int age = 0, i = 0; 10197996a778SMike Christie 10200af967f5SMike Christie if (itt == RESERVED_ITT) 10210af967f5SMike Christie return 0; 10220af967f5SMike Christie 1023262ef636SMike Christie if (session->tt->parse_pdu_itt) 1024262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, &age); 1025262ef636SMike Christie else { 1026262ef636SMike Christie i = get_itt(itt); 1027262ef636SMike Christie age = ((__force u32)itt >> ISCSI_AGE_SHIFT) & ISCSI_AGE_MASK; 1028262ef636SMike Christie } 1029262ef636SMike Christie 1030262ef636SMike Christie if (age != session->age) { 1031322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 10320af967f5SMike Christie "received itt %x expected session age (%x)\n", 1033913e5bf4SMike Christie (__force u32)itt, session->age); 10347996a778SMike Christie return ISCSI_ERR_BAD_ITT; 10357996a778SMike Christie } 10367996a778SMike Christie 10373e5c28adSMike Christie if (i >= session->cmds_max) { 10383e5c28adSMike Christie iscsi_conn_printk(KERN_ERR, conn, 10393e5c28adSMike Christie "received invalid itt index %u (max cmds " 10403e5c28adSMike Christie "%u.\n", i, session->cmds_max); 10413e5c28adSMike Christie return ISCSI_ERR_BAD_ITT; 10427996a778SMike Christie } 10437996a778SMike Christie return 0; 10447996a778SMike Christie } 10457996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_verify_itt); 10467996a778SMike Christie 1047913e5bf4SMike Christie /** 1048913e5bf4SMike Christie * iscsi_itt_to_ctask - look up ctask by itt 1049913e5bf4SMike Christie * @conn: iscsi connection 1050913e5bf4SMike Christie * @itt: itt 1051913e5bf4SMike Christie * 1052913e5bf4SMike Christie * This should be used for cmd tasks. 1053913e5bf4SMike Christie * 1054913e5bf4SMike Christie * The session lock must be held. 1055913e5bf4SMike Christie */ 1056913e5bf4SMike Christie struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt) 10570af967f5SMike Christie { 10589c19a7d0SMike Christie struct iscsi_task *task; 10590af967f5SMike Christie 10600af967f5SMike Christie if (iscsi_verify_itt(conn, itt)) 10610af967f5SMike Christie return NULL; 10620af967f5SMike Christie 1063913e5bf4SMike Christie task = iscsi_itt_to_task(conn, itt); 1064913e5bf4SMike Christie if (!task || !task->sc) 10650af967f5SMike Christie return NULL; 10660af967f5SMike Christie 1067913e5bf4SMike Christie if (task->sc->SCp.phase != conn->session->age) { 1068913e5bf4SMike Christie iscsi_session_printk(KERN_ERR, conn->session, 1069913e5bf4SMike Christie "task's session age %d, expected %d\n", 1070913e5bf4SMike Christie task->sc->SCp.phase, conn->session->age); 10710af967f5SMike Christie return NULL; 1072913e5bf4SMike Christie } 10730af967f5SMike Christie 10749c19a7d0SMike Christie return task; 10750af967f5SMike Christie } 10760af967f5SMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask); 10770af967f5SMike Christie 107840a06e75SMike Christie void iscsi_session_failure(struct iscsi_session *session, 1079e5bd7b54SMike Christie enum iscsi_err err) 1080e5bd7b54SMike Christie { 1081e5bd7b54SMike Christie struct iscsi_conn *conn; 1082e5bd7b54SMike Christie struct device *dev; 1083e5bd7b54SMike Christie unsigned long flags; 1084e5bd7b54SMike Christie 1085e5bd7b54SMike Christie spin_lock_irqsave(&session->lock, flags); 1086e5bd7b54SMike Christie conn = session->leadconn; 1087e5bd7b54SMike Christie if (session->state == ISCSI_STATE_TERMINATE || !conn) { 1088e5bd7b54SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1089e5bd7b54SMike Christie return; 1090e5bd7b54SMike Christie } 1091e5bd7b54SMike Christie 1092e5bd7b54SMike Christie dev = get_device(&conn->cls_conn->dev); 1093e5bd7b54SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1094e5bd7b54SMike Christie if (!dev) 1095e5bd7b54SMike Christie return; 1096e5bd7b54SMike Christie /* 1097e5bd7b54SMike Christie * if the host is being removed bypass the connection 1098e5bd7b54SMike Christie * recovery initialization because we are going to kill 1099e5bd7b54SMike Christie * the session. 1100e5bd7b54SMike Christie */ 1101e5bd7b54SMike Christie if (err == ISCSI_ERR_INVALID_HOST) 1102e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 1103e5bd7b54SMike Christie else 1104e5bd7b54SMike Christie iscsi_conn_failure(conn, err); 1105e5bd7b54SMike Christie put_device(dev); 1106e5bd7b54SMike Christie } 1107e5bd7b54SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_failure); 1108e5bd7b54SMike Christie 11097996a778SMike Christie void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err) 11107996a778SMike Christie { 11117996a778SMike Christie struct iscsi_session *session = conn->session; 11127996a778SMike Christie unsigned long flags; 11137996a778SMike Christie 11147996a778SMike Christie spin_lock_irqsave(&session->lock, flags); 1115656cffc9SMike Christie if (session->state == ISCSI_STATE_FAILED) { 1116656cffc9SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1117656cffc9SMike Christie return; 1118656cffc9SMike Christie } 1119656cffc9SMike Christie 112067a61114SMike Christie if (conn->stop_stage == 0) 11217996a778SMike Christie session->state = ISCSI_STATE_FAILED; 11227996a778SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1123e5bd7b54SMike Christie 11247996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 11257996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 1126e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 11277996a778SMike Christie } 11287996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_failure); 11297996a778SMike Christie 113077a23c21SMike Christie static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn) 113177a23c21SMike Christie { 113277a23c21SMike Christie struct iscsi_session *session = conn->session; 113377a23c21SMike Christie 113477a23c21SMike Christie /* 113577a23c21SMike Christie * Check for iSCSI window and take care of CmdSN wrap-around 113677a23c21SMike Christie */ 1137e0726407SMike Christie if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) { 11381b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iSCSI CmdSN closed. ExpCmdSn " 11391b2c7af8SMike Christie "%u MaxCmdSN %u CmdSN %u/%u\n", 11401b2c7af8SMike Christie session->exp_cmdsn, session->max_cmdsn, 11411b2c7af8SMike Christie session->cmdsn, session->queued_cmdsn); 114277a23c21SMike Christie return -ENOSPC; 114377a23c21SMike Christie } 114477a23c21SMike Christie return 0; 114577a23c21SMike Christie } 114677a23c21SMike Christie 11479c19a7d0SMike Christie static int iscsi_xmit_task(struct iscsi_conn *conn) 114877a23c21SMike Christie { 11499c19a7d0SMike Christie struct iscsi_task *task = conn->task; 1150843c0a8aSMike Christie int rc; 115177a23c21SMike Christie 11529c19a7d0SMike Christie __iscsi_get_task(task); 115377a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 11549c19a7d0SMike Christie rc = conn->session->tt->xmit_task(task); 115577a23c21SMike Christie spin_lock_bh(&conn->session->lock); 11569c19a7d0SMike Christie __iscsi_put_task(task); 115777a23c21SMike Christie if (!rc) 11589c19a7d0SMike Christie /* done with this task */ 11599c19a7d0SMike Christie conn->task = NULL; 116077a23c21SMike Christie return rc; 116177a23c21SMike Christie } 116277a23c21SMike Christie 11637996a778SMike Christie /** 11649c19a7d0SMike Christie * iscsi_requeue_task - requeue task to run from session workqueue 11659c19a7d0SMike Christie * @task: task to requeue 1166843c0a8aSMike Christie * 11679c19a7d0SMike Christie * LLDs that need to run a task from the session workqueue should call 1168052d0144SMike Christie * this. The session lock must be held. This should only be called 1169052d0144SMike Christie * by software drivers. 1170843c0a8aSMike Christie */ 11719c19a7d0SMike Christie void iscsi_requeue_task(struct iscsi_task *task) 1172843c0a8aSMike Christie { 11739c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 1174843c0a8aSMike Christie 11759c19a7d0SMike Christie list_move_tail(&task->running, &conn->requeue); 117632ae763eSMike Christie iscsi_conn_queue_work(conn); 1177843c0a8aSMike Christie } 11789c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_requeue_task); 1179843c0a8aSMike Christie 1180843c0a8aSMike Christie /** 11817996a778SMike Christie * iscsi_data_xmit - xmit any command into the scheduled connection 11827996a778SMike Christie * @conn: iscsi connection 11837996a778SMike Christie * 11847996a778SMike Christie * Notes: 11857996a778SMike Christie * The function can return -EAGAIN in which case the caller must 11867996a778SMike Christie * re-schedule it again later or recover. '0' return code means 11877996a778SMike Christie * successful xmit. 11887996a778SMike Christie **/ 11897996a778SMike Christie static int iscsi_data_xmit(struct iscsi_conn *conn) 11907996a778SMike Christie { 11913219e529SMike Christie int rc = 0; 11927996a778SMike Christie 119377a23c21SMike Christie spin_lock_bh(&conn->session->lock); 11947996a778SMike Christie if (unlikely(conn->suspend_tx)) { 11951b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n"); 119677a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 11973219e529SMike Christie return -ENODATA; 11987996a778SMike Christie } 11997996a778SMike Christie 12009c19a7d0SMike Christie if (conn->task) { 12019c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 12023219e529SMike Christie if (rc) 12037996a778SMike Christie goto again; 12047996a778SMike Christie } 120577a23c21SMike Christie 120677a23c21SMike Christie /* 120777a23c21SMike Christie * process mgmt pdus like nops before commands since we should 120877a23c21SMike Christie * only have one nop-out as a ping from us and targets should not 120977a23c21SMike Christie * overflow us with nop-ins 121077a23c21SMike Christie */ 121177a23c21SMike Christie check_mgmt: 1212843c0a8aSMike Christie while (!list_empty(&conn->mgmtqueue)) { 12139c19a7d0SMike Christie conn->task = list_entry(conn->mgmtqueue.next, 12149c19a7d0SMike Christie struct iscsi_task, running); 12159c19a7d0SMike Christie if (iscsi_prep_mgmt_task(conn, conn->task)) { 12169c19a7d0SMike Christie __iscsi_put_task(conn->task); 12179c19a7d0SMike Christie conn->task = NULL; 1218b3a7ea8dSMike Christie continue; 1219b3a7ea8dSMike Christie } 12209c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 12213219e529SMike Christie if (rc) 12227996a778SMike Christie goto again; 12237996a778SMike Christie } 12247996a778SMike Christie 1225843c0a8aSMike Christie /* process pending command queue */ 1226b6c395edSMike Christie while (!list_empty(&conn->xmitqueue)) { 1227843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) 1228843c0a8aSMike Christie break; 1229843c0a8aSMike Christie 12309c19a7d0SMike Christie conn->task = list_entry(conn->xmitqueue.next, 12319c19a7d0SMike Christie struct iscsi_task, running); 1232b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) { 12339c19a7d0SMike Christie fail_command(conn, conn->task, DID_IMM_RETRY << 16); 1234b3a7ea8dSMike Christie continue; 1235b3a7ea8dSMike Christie } 1236577577daSMike Christie rc = iscsi_prep_scsi_cmd_pdu(conn->task); 1237577577daSMike Christie if (rc) { 1238577577daSMike Christie if (rc == -ENOMEM) { 1239577577daSMike Christie conn->task = NULL; 1240577577daSMike Christie goto again; 1241577577daSMike Christie } else 12429c19a7d0SMike Christie fail_command(conn, conn->task, DID_ABORT << 16); 1243004d6530SBoaz Harrosh continue; 1244004d6530SBoaz Harrosh } 12459c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 12463219e529SMike Christie if (rc) 12477996a778SMike Christie goto again; 124877a23c21SMike Christie /* 12499c19a7d0SMike Christie * we could continuously get new task requests so 125077a23c21SMike Christie * we need to check the mgmt queue for nops that need to 125177a23c21SMike Christie * be sent to aviod starvation 125277a23c21SMike Christie */ 1253843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 1254843c0a8aSMike Christie goto check_mgmt; 1255843c0a8aSMike Christie } 1256843c0a8aSMike Christie 1257843c0a8aSMike Christie while (!list_empty(&conn->requeue)) { 1258843c0a8aSMike Christie if (conn->session->fast_abort && conn->tmf_state != TMF_INITIAL) 1259843c0a8aSMike Christie break; 1260843c0a8aSMike Christie 1261b3a7ea8dSMike Christie /* 1262b3a7ea8dSMike Christie * we always do fastlogout - conn stop code will clean up. 1263b3a7ea8dSMike Christie */ 1264b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 1265b3a7ea8dSMike Christie break; 1266b3a7ea8dSMike Christie 12679c19a7d0SMike Christie conn->task = list_entry(conn->requeue.next, 12689c19a7d0SMike Christie struct iscsi_task, running); 12699c19a7d0SMike Christie conn->task->state = ISCSI_TASK_RUNNING; 1270843c0a8aSMike Christie list_move_tail(conn->requeue.next, &conn->run_list); 12719c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 1272843c0a8aSMike Christie if (rc) 1273843c0a8aSMike Christie goto again; 1274843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 127577a23c21SMike Christie goto check_mgmt; 12767996a778SMike Christie } 127777a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 12783219e529SMike Christie return -ENODATA; 12797996a778SMike Christie 12807996a778SMike Christie again: 12817996a778SMike Christie if (unlikely(conn->suspend_tx)) 128277a23c21SMike Christie rc = -ENODATA; 128377a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 12843219e529SMike Christie return rc; 12857996a778SMike Christie } 12867996a778SMike Christie 1287c4028958SDavid Howells static void iscsi_xmitworker(struct work_struct *work) 12887996a778SMike Christie { 1289c4028958SDavid Howells struct iscsi_conn *conn = 1290c4028958SDavid Howells container_of(work, struct iscsi_conn, xmitwork); 12913219e529SMike Christie int rc; 12927996a778SMike Christie /* 12937996a778SMike Christie * serialize Xmit worker on a per-connection basis. 12947996a778SMike Christie */ 12953219e529SMike Christie do { 12963219e529SMike Christie rc = iscsi_data_xmit(conn); 12973219e529SMike Christie } while (rc >= 0 || rc == -EAGAIN); 12987996a778SMike Christie } 12997996a778SMike Christie 1300577577daSMike Christie static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn, 1301577577daSMike Christie struct scsi_cmnd *sc) 1302577577daSMike Christie { 1303577577daSMike Christie struct iscsi_task *task; 1304577577daSMike Christie 1305577577daSMike Christie if (!__kfifo_get(conn->session->cmdpool.queue, 1306577577daSMike Christie (void *) &task, sizeof(void *))) 1307577577daSMike Christie return NULL; 1308577577daSMike Christie 1309577577daSMike Christie sc->SCp.phase = conn->session->age; 1310577577daSMike Christie sc->SCp.ptr = (char *) task; 1311577577daSMike Christie 1312577577daSMike Christie atomic_set(&task->refcount, 1); 1313577577daSMike Christie task->state = ISCSI_TASK_PENDING; 1314577577daSMike Christie task->conn = conn; 1315577577daSMike Christie task->sc = sc; 1316577577daSMike Christie INIT_LIST_HEAD(&task->running); 1317577577daSMike Christie return task; 1318577577daSMike Christie } 1319577577daSMike Christie 13207996a778SMike Christie enum { 13217996a778SMike Christie FAILURE_BAD_HOST = 1, 13227996a778SMike Christie FAILURE_SESSION_FAILED, 13237996a778SMike Christie FAILURE_SESSION_FREED, 13247996a778SMike Christie FAILURE_WINDOW_CLOSED, 132560ecebf5SMike Christie FAILURE_OOM, 13267996a778SMike Christie FAILURE_SESSION_TERMINATE, 1327656cffc9SMike Christie FAILURE_SESSION_IN_RECOVERY, 13287996a778SMike Christie FAILURE_SESSION_RECOVERY_TIMEOUT, 1329b3a7ea8dSMike Christie FAILURE_SESSION_LOGGING_OUT, 13306eabafbeSMike Christie FAILURE_SESSION_NOT_READY, 13317996a778SMike Christie }; 13327996a778SMike Christie 13337996a778SMike Christie int iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *)) 13347996a778SMike Christie { 133575613521SMike Christie struct iscsi_cls_session *cls_session; 13367996a778SMike Christie struct Scsi_Host *host; 13377996a778SMike Christie int reason = 0; 13387996a778SMike Christie struct iscsi_session *session; 13397996a778SMike Christie struct iscsi_conn *conn; 13409c19a7d0SMike Christie struct iscsi_task *task = NULL; 13417996a778SMike Christie 13427996a778SMike Christie sc->scsi_done = done; 13437996a778SMike Christie sc->result = 0; 1344f47f2cf5SMike Christie sc->SCp.ptr = NULL; 13457996a778SMike Christie 13467996a778SMike Christie host = sc->device->host; 13471040c99dSMike Christie spin_unlock(host->host_lock); 13487996a778SMike Christie 134975613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 135075613521SMike Christie session = cls_session->dd_data; 13517996a778SMike Christie spin_lock(&session->lock); 13527996a778SMike Christie 135375613521SMike Christie reason = iscsi_session_chkready(cls_session); 13546eabafbeSMike Christie if (reason) { 13556eabafbeSMike Christie sc->result = reason; 13566eabafbeSMike Christie goto fault; 13576eabafbeSMike Christie } 13586eabafbeSMike Christie 1359656cffc9SMike Christie /* 1360656cffc9SMike Christie * ISCSI_STATE_FAILED is a temp. state. The recovery 1361656cffc9SMike Christie * code will decide what is best to do with command queued 1362656cffc9SMike Christie * during this time 1363656cffc9SMike Christie */ 1364656cffc9SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN && 1365656cffc9SMike Christie session->state != ISCSI_STATE_FAILED) { 1366656cffc9SMike Christie /* 1367656cffc9SMike Christie * to handle the race between when we set the recovery state 1368656cffc9SMike Christie * and block the session we requeue here (commands could 1369656cffc9SMike Christie * be entering our queuecommand while a block is starting 1370656cffc9SMike Christie * up because the block code is not locked) 1371656cffc9SMike Christie */ 13729000bcd6SMike Christie switch (session->state) { 13739000bcd6SMike Christie case ISCSI_STATE_IN_RECOVERY: 1374656cffc9SMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1375d6d13ee1SMike Christie goto reject; 13769000bcd6SMike Christie case ISCSI_STATE_LOGGING_OUT: 13779000bcd6SMike Christie reason = FAILURE_SESSION_LOGGING_OUT; 1378d6d13ee1SMike Christie goto reject; 1379b3a7ea8dSMike Christie case ISCSI_STATE_RECOVERY_FAILED: 1380656cffc9SMike Christie reason = FAILURE_SESSION_RECOVERY_TIMEOUT; 138156d7fcfaSMike Christie sc->result = DID_TRANSPORT_FAILFAST << 16; 1382b3a7ea8dSMike Christie break; 1383b3a7ea8dSMike Christie case ISCSI_STATE_TERMINATE: 1384656cffc9SMike Christie reason = FAILURE_SESSION_TERMINATE; 13856eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1386b3a7ea8dSMike Christie break; 1387b3a7ea8dSMike Christie default: 13887996a778SMike Christie reason = FAILURE_SESSION_FREED; 13896eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1390b3a7ea8dSMike Christie } 13917996a778SMike Christie goto fault; 13927996a778SMike Christie } 13937996a778SMike Christie 13947996a778SMike Christie conn = session->leadconn; 139598644047SMike Christie if (!conn) { 139698644047SMike Christie reason = FAILURE_SESSION_FREED; 13976eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 139898644047SMike Christie goto fault; 139998644047SMike Christie } 14007996a778SMike Christie 140177a23c21SMike Christie if (iscsi_check_cmdsn_window_closed(conn)) { 140277a23c21SMike Christie reason = FAILURE_WINDOW_CLOSED; 140377a23c21SMike Christie goto reject; 140477a23c21SMike Christie } 140577a23c21SMike Christie 1406577577daSMike Christie task = iscsi_alloc_task(conn, sc); 1407577577daSMike Christie if (!task) { 140860ecebf5SMike Christie reason = FAILURE_OOM; 140960ecebf5SMike Christie goto reject; 141060ecebf5SMike Christie } 14119c19a7d0SMike Christie list_add_tail(&task->running, &conn->xmitqueue); 14127996a778SMike Christie 1413052d0144SMike Christie if (session->tt->caps & CAP_DATA_PATH_OFFLOAD) { 1414577577daSMike Christie reason = iscsi_prep_scsi_cmd_pdu(task); 1415577577daSMike Christie if (reason) { 1416577577daSMike Christie if (reason == -ENOMEM) { 1417577577daSMike Christie reason = FAILURE_OOM; 1418577577daSMike Christie goto prepd_reject; 1419577577daSMike Christie } else { 1420052d0144SMike Christie sc->result = DID_ABORT << 16; 1421577577daSMike Christie goto prepd_fault; 1422577577daSMike Christie } 1423052d0144SMike Christie } 14249c19a7d0SMike Christie if (session->tt->xmit_task(task)) { 1425052d0144SMike Christie reason = FAILURE_SESSION_NOT_READY; 1426577577daSMike Christie goto prepd_reject; 1427052d0144SMike Christie } 1428052d0144SMike Christie } else 142932ae763eSMike Christie iscsi_conn_queue_work(conn); 1430052d0144SMike Christie 1431052d0144SMike Christie session->queued_cmdsn++; 1432052d0144SMike Christie spin_unlock(&session->lock); 14331040c99dSMike Christie spin_lock(host->host_lock); 14347996a778SMike Christie return 0; 14357996a778SMike Christie 1436577577daSMike Christie prepd_reject: 1437577577daSMike Christie sc->scsi_done = NULL; 1438577577daSMike Christie iscsi_complete_command(task); 14397996a778SMike Christie reject: 14407996a778SMike Christie spin_unlock(&session->lock); 14411b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n", 14421b2c7af8SMike Christie sc->cmnd[0], reason); 14431040c99dSMike Christie spin_lock(host->host_lock); 1444d6d13ee1SMike Christie return SCSI_MLQUEUE_TARGET_BUSY; 14457996a778SMike Christie 1446577577daSMike Christie prepd_fault: 1447577577daSMike Christie sc->scsi_done = NULL; 1448577577daSMike Christie iscsi_complete_command(task); 14497996a778SMike Christie fault: 14507996a778SMike Christie spin_unlock(&session->lock); 14511b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n", 14521b2c7af8SMike Christie sc->cmnd[0], reason); 1453c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 14541c138991SFUJITA Tomonori scsi_set_resid(sc, scsi_bufflen(sc)); 1455c07d4444SBoaz Harrosh else { 1456c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 1457c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 1458c07d4444SBoaz Harrosh } 1459052d0144SMike Christie done(sc); 14601040c99dSMike Christie spin_lock(host->host_lock); 14617996a778SMike Christie return 0; 14627996a778SMike Christie } 14637996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_queuecommand); 14647996a778SMike Christie 14657996a778SMike Christie int iscsi_change_queue_depth(struct scsi_device *sdev, int depth) 14667996a778SMike Christie { 14677996a778SMike Christie scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); 14687996a778SMike Christie return sdev->queue_depth; 14697996a778SMike Christie } 14707996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_change_queue_depth); 14717996a778SMike Christie 14726b5d6c44SMike Christie int iscsi_target_alloc(struct scsi_target *starget) 14736b5d6c44SMike Christie { 14746b5d6c44SMike Christie struct iscsi_cls_session *cls_session = starget_to_session(starget); 14756b5d6c44SMike Christie struct iscsi_session *session = cls_session->dd_data; 14766b5d6c44SMike Christie 14776b5d6c44SMike Christie starget->can_queue = session->scsi_cmds_max; 14786b5d6c44SMike Christie return 0; 14796b5d6c44SMike Christie } 14806b5d6c44SMike Christie EXPORT_SYMBOL_GPL(iscsi_target_alloc); 14816b5d6c44SMike Christie 14827996a778SMike Christie void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) 14837996a778SMike Christie { 148475613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 14857996a778SMike Christie 14867996a778SMike Christie spin_lock_bh(&session->lock); 14877996a778SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1488656cffc9SMike Christie session->state = ISCSI_STATE_RECOVERY_FAILED; 1489843c0a8aSMike Christie if (session->leadconn) 1490843c0a8aSMike Christie wake_up(&session->leadconn->ehwait); 14917996a778SMike Christie } 14927996a778SMike Christie spin_unlock_bh(&session->lock); 14937996a778SMike Christie } 14947996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout); 14957996a778SMike Christie 14968e124525SMike Christie int iscsi_eh_target_reset(struct scsi_cmnd *sc) 14977996a778SMike Christie { 149875613521SMike Christie struct iscsi_cls_session *cls_session; 149975613521SMike Christie struct iscsi_session *session; 150075613521SMike Christie struct iscsi_conn *conn; 150175613521SMike Christie 150275613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 150375613521SMike Christie session = cls_session->dd_data; 150475613521SMike Christie conn = session->leadconn; 15057996a778SMike Christie 1506bc436b27SMike Christie mutex_lock(&session->eh_mutex); 15077996a778SMike Christie spin_lock_bh(&session->lock); 15087996a778SMike Christie if (session->state == ISCSI_STATE_TERMINATE) { 15097996a778SMike Christie failed: 15101b2c7af8SMike Christie iscsi_session_printk(KERN_INFO, session, 15111b2c7af8SMike Christie "failing target reset: Could not log " 15121b2c7af8SMike Christie "back into target [age %d]\n", 15131b2c7af8SMike Christie session->age); 15147996a778SMike Christie spin_unlock_bh(&session->lock); 1515bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 15167996a778SMike Christie return FAILED; 15177996a778SMike Christie } 15187996a778SMike Christie 15197996a778SMike Christie spin_unlock_bh(&session->lock); 1520bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 15217996a778SMike Christie /* 15227996a778SMike Christie * we drop the lock here but the leadconn cannot be destoyed while 15237996a778SMike Christie * we are in the scsi eh 15247996a778SMike Christie */ 15257996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 15267996a778SMike Christie 15271b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "wait for relogin\n"); 15287996a778SMike Christie wait_event_interruptible(conn->ehwait, 15297996a778SMike Christie session->state == ISCSI_STATE_TERMINATE || 15307996a778SMike Christie session->state == ISCSI_STATE_LOGGED_IN || 1531656cffc9SMike Christie session->state == ISCSI_STATE_RECOVERY_FAILED); 15327996a778SMike Christie if (signal_pending(current)) 15337996a778SMike Christie flush_signals(current); 15347996a778SMike Christie 1535bc436b27SMike Christie mutex_lock(&session->eh_mutex); 15367996a778SMike Christie spin_lock_bh(&session->lock); 15377996a778SMike Christie if (session->state == ISCSI_STATE_LOGGED_IN) 1538322d739dSMike Christie iscsi_session_printk(KERN_INFO, session, 15398e124525SMike Christie "target reset succeeded\n"); 15407996a778SMike Christie else 15417996a778SMike Christie goto failed; 15427996a778SMike Christie spin_unlock_bh(&session->lock); 1543bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 15447996a778SMike Christie return SUCCESS; 15457996a778SMike Christie } 15468e124525SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_target_reset); 15477996a778SMike Christie 1548843c0a8aSMike Christie static void iscsi_tmf_timedout(unsigned long data) 15497996a778SMike Christie { 1550843c0a8aSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 15517996a778SMike Christie struct iscsi_session *session = conn->session; 15527996a778SMike Christie 15537996a778SMike Christie spin_lock(&session->lock); 1554843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) { 1555843c0a8aSMike Christie conn->tmf_state = TMF_TIMEDOUT; 15561b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "tmf timedout\n"); 15577996a778SMike Christie /* unblock eh_abort() */ 15587996a778SMike Christie wake_up(&conn->ehwait); 15597996a778SMike Christie } 15607996a778SMike Christie spin_unlock(&session->lock); 15617996a778SMike Christie } 15627996a778SMike Christie 15639c19a7d0SMike Christie static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, 1564f6d5180cSMike Christie struct iscsi_tm *hdr, int age, 1565f6d5180cSMike Christie int timeout) 15667996a778SMike Christie { 15677996a778SMike Christie struct iscsi_session *session = conn->session; 15689c19a7d0SMike Christie struct iscsi_task *task; 15697996a778SMike Christie 15709c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr, 15717996a778SMike Christie NULL, 0); 15729c19a7d0SMike Christie if (!task) { 15736724add1SMike Christie spin_unlock_bh(&session->lock); 15747996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1575843c0a8aSMike Christie spin_lock_bh(&session->lock); 15761b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "tmf exec failure\n"); 157777a23c21SMike Christie return -EPERM; 15787996a778SMike Christie } 15797996a778SMike Christie conn->tmfcmd_pdus_cnt++; 1580f6d5180cSMike Christie conn->tmf_timer.expires = timeout * HZ + jiffies; 1581843c0a8aSMike Christie conn->tmf_timer.function = iscsi_tmf_timedout; 1582843c0a8aSMike Christie conn->tmf_timer.data = (unsigned long)conn; 1583843c0a8aSMike Christie add_timer(&conn->tmf_timer); 15841b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "tmf set timeout\n"); 1585843c0a8aSMike Christie 15867996a778SMike Christie spin_unlock_bh(&session->lock); 15876724add1SMike Christie mutex_unlock(&session->eh_mutex); 15887996a778SMike Christie 15897996a778SMike Christie /* 15907996a778SMike Christie * block eh thread until: 15917996a778SMike Christie * 1592843c0a8aSMike Christie * 1) tmf response 1593843c0a8aSMike Christie * 2) tmf timeout 15947996a778SMike Christie * 3) session is terminated or restarted or userspace has 15957996a778SMike Christie * given up on recovery 15967996a778SMike Christie */ 1597843c0a8aSMike Christie wait_event_interruptible(conn->ehwait, age != session->age || 15987996a778SMike Christie session->state != ISCSI_STATE_LOGGED_IN || 1599843c0a8aSMike Christie conn->tmf_state != TMF_QUEUED); 16007996a778SMike Christie if (signal_pending(current)) 16017996a778SMike Christie flush_signals(current); 1602843c0a8aSMike Christie del_timer_sync(&conn->tmf_timer); 1603843c0a8aSMike Christie 16046724add1SMike Christie mutex_lock(&session->eh_mutex); 160577a23c21SMike Christie spin_lock_bh(&session->lock); 16069c19a7d0SMike Christie /* if the session drops it will clean up the task */ 1607843c0a8aSMike Christie if (age != session->age || 1608843c0a8aSMike Christie session->state != ISCSI_STATE_LOGGED_IN) 1609843c0a8aSMike Christie return -ENOTCONN; 16107996a778SMike Christie return 0; 16117996a778SMike Christie } 16127996a778SMike Christie 16137996a778SMike Christie /* 1614843c0a8aSMike Christie * Fail commands. session lock held and recv side suspended and xmit 1615843c0a8aSMike Christie * thread flushed 1616843c0a8aSMike Christie */ 16176eabafbeSMike Christie static void fail_all_commands(struct iscsi_conn *conn, unsigned lun, 16186eabafbeSMike Christie int error) 1619843c0a8aSMike Christie { 16209c19a7d0SMike Christie struct iscsi_task *task, *tmp; 1621843c0a8aSMike Christie 162272899682SMike Christie if (conn->task) { 162372899682SMike Christie if (lun == -1 || 162472899682SMike Christie (conn->task->sc && conn->task->sc->device->lun == lun)) 16259c19a7d0SMike Christie conn->task = NULL; 162672899682SMike Christie } 1627843c0a8aSMike Christie 1628843c0a8aSMike Christie /* flush pending */ 16299c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->xmitqueue, running) { 16309c19a7d0SMike Christie if (lun == task->sc->device->lun || lun == -1) { 16311b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, 16321b2c7af8SMike Christie "failing pending sc %p itt 0x%x\n", 16339c19a7d0SMike Christie task->sc, task->itt); 16349c19a7d0SMike Christie fail_command(conn, task, error << 16); 1635843c0a8aSMike Christie } 1636843c0a8aSMike Christie } 1637843c0a8aSMike Christie 16389c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->requeue, running) { 16399c19a7d0SMike Christie if (lun == task->sc->device->lun || lun == -1) { 16401b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, 16411b2c7af8SMike Christie "failing requeued sc %p itt 0x%x\n", 16429c19a7d0SMike Christie task->sc, task->itt); 16439c19a7d0SMike Christie fail_command(conn, task, error << 16); 1644843c0a8aSMike Christie } 1645843c0a8aSMike Christie } 1646843c0a8aSMike Christie 1647843c0a8aSMike Christie /* fail all other running */ 16489c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->run_list, running) { 16499c19a7d0SMike Christie if (lun == task->sc->device->lun || lun == -1) { 16501b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, 16511b2c7af8SMike Christie "failing in progress sc %p itt 0x%x\n", 16529c19a7d0SMike Christie task->sc, task->itt); 1653ac26d41dSMike Christie fail_command(conn, task, error << 16); 1654843c0a8aSMike Christie } 1655843c0a8aSMike Christie } 1656843c0a8aSMike Christie } 1657843c0a8aSMike Christie 1658b40977d9SMike Christie void iscsi_suspend_tx(struct iscsi_conn *conn) 16596724add1SMike Christie { 166032ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 166132ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 166232ae763eSMike Christie 16636724add1SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1664052d0144SMike Christie if (!(conn->session->tt->caps & CAP_DATA_PATH_OFFLOAD)) 166532ae763eSMike Christie flush_workqueue(ihost->workq); 16666724add1SMike Christie } 1667b40977d9SMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_tx); 16686724add1SMike Christie 16696724add1SMike Christie static void iscsi_start_tx(struct iscsi_conn *conn) 16706724add1SMike Christie { 16716724add1SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1672052d0144SMike Christie if (!(conn->session->tt->caps & CAP_DATA_PATH_OFFLOAD)) 167332ae763eSMike Christie iscsi_conn_queue_work(conn); 16746724add1SMike Christie } 16756724add1SMike Christie 1676242f9dcbSJens Axboe static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *scmd) 1677f6d5180cSMike Christie { 1678f6d5180cSMike Christie struct iscsi_cls_session *cls_session; 1679f6d5180cSMike Christie struct iscsi_session *session; 1680f6d5180cSMike Christie struct iscsi_conn *conn; 1681242f9dcbSJens Axboe enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED; 1682f6d5180cSMike Christie 1683f6d5180cSMike Christie cls_session = starget_to_session(scsi_target(scmd->device)); 168475613521SMike Christie session = cls_session->dd_data; 1685f6d5180cSMike Christie 16861b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "scsi cmd %p timedout\n", scmd); 1687f6d5180cSMike Christie 1688f6d5180cSMike Christie spin_lock(&session->lock); 1689f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1690f6d5180cSMike Christie /* 1691f6d5180cSMike Christie * We are probably in the middle of iscsi recovery so let 1692f6d5180cSMike Christie * that complete and handle the error. 1693f6d5180cSMike Christie */ 1694242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1695f6d5180cSMike Christie goto done; 1696f6d5180cSMike Christie } 1697f6d5180cSMike Christie 1698f6d5180cSMike Christie conn = session->leadconn; 1699f6d5180cSMike Christie if (!conn) { 1700f6d5180cSMike Christie /* In the middle of shuting down */ 1701242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1702f6d5180cSMike Christie goto done; 1703f6d5180cSMike Christie } 1704f6d5180cSMike Christie 1705f6d5180cSMike Christie if (!conn->recv_timeout && !conn->ping_timeout) 1706f6d5180cSMike Christie goto done; 1707f6d5180cSMike Christie /* 1708f6d5180cSMike Christie * if the ping timedout then we are in the middle of cleaning up 1709f6d5180cSMike Christie * and can let the iscsi eh handle it 1710f6d5180cSMike Christie */ 1711f6d5180cSMike Christie if (time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) + 1712f6d5180cSMike Christie (conn->ping_timeout * HZ), jiffies)) 1713242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1714f6d5180cSMike Christie /* 1715f6d5180cSMike Christie * if we are about to check the transport then give the command 1716f6d5180cSMike Christie * more time 1717f6d5180cSMike Christie */ 1718f6d5180cSMike Christie if (time_before_eq(conn->last_recv + (conn->recv_timeout * HZ), 1719f6d5180cSMike Christie jiffies)) 1720242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1721f6d5180cSMike Christie /* if in the middle of checking the transport then give us more time */ 17229c19a7d0SMike Christie if (conn->ping_task) 1723242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1724f6d5180cSMike Christie done: 1725f6d5180cSMike Christie spin_unlock(&session->lock); 17261b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "return %s\n", rc == BLK_EH_RESET_TIMER ? 1727242f9dcbSJens Axboe "timer reset" : "nh"); 1728f6d5180cSMike Christie return rc; 1729f6d5180cSMike Christie } 1730f6d5180cSMike Christie 1731f6d5180cSMike Christie static void iscsi_check_transport_timeouts(unsigned long data) 1732f6d5180cSMike Christie { 1733f6d5180cSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 1734f6d5180cSMike Christie struct iscsi_session *session = conn->session; 17354cf10435SMike Christie unsigned long recv_timeout, next_timeout = 0, last_recv; 1736f6d5180cSMike Christie 1737f6d5180cSMike Christie spin_lock(&session->lock); 1738f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 1739f6d5180cSMike Christie goto done; 1740f6d5180cSMike Christie 17414cf10435SMike Christie recv_timeout = conn->recv_timeout; 17424cf10435SMike Christie if (!recv_timeout) 1743f6d5180cSMike Christie goto done; 1744f6d5180cSMike Christie 17454cf10435SMike Christie recv_timeout *= HZ; 1746f6d5180cSMike Christie last_recv = conn->last_recv; 17479c19a7d0SMike Christie if (conn->ping_task && 17484cf10435SMike Christie time_before_eq(conn->last_ping + (conn->ping_timeout * HZ), 1749f6d5180cSMike Christie jiffies)) { 1750322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs " 1751322d739dSMike Christie "expired, last rx %lu, last ping %lu, " 1752322d739dSMike Christie "now %lu\n", conn->ping_timeout, last_recv, 1753f6d5180cSMike Christie conn->last_ping, jiffies); 1754f6d5180cSMike Christie spin_unlock(&session->lock); 1755f6d5180cSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1756f6d5180cSMike Christie return; 1757f6d5180cSMike Christie } 1758f6d5180cSMike Christie 17594cf10435SMike Christie if (time_before_eq(last_recv + recv_timeout, jiffies)) { 1760f6d5180cSMike Christie /* send a ping to try to provoke some traffic */ 17611b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Sending nopout as ping\n"); 1762f6d5180cSMike Christie iscsi_send_nopout(conn, NULL); 17634cf10435SMike Christie next_timeout = conn->last_ping + (conn->ping_timeout * HZ); 1764ad294e9cSMike Christie } else 17654cf10435SMike Christie next_timeout = last_recv + recv_timeout; 1766f6d5180cSMike Christie 17671b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout); 1768f6d5180cSMike Christie mod_timer(&conn->transport_timer, next_timeout); 1769f6d5180cSMike Christie done: 1770f6d5180cSMike Christie spin_unlock(&session->lock); 1771f6d5180cSMike Christie } 1772f6d5180cSMike Christie 17739c19a7d0SMike Christie static void iscsi_prep_abort_task_pdu(struct iscsi_task *task, 1774843c0a8aSMike Christie struct iscsi_tm *hdr) 1775843c0a8aSMike Christie { 1776843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 1777843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 1778843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK; 1779843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 1780577577daSMike Christie memcpy(hdr->lun, task->lun, sizeof(hdr->lun)); 1781577577daSMike Christie hdr->rtt = task->hdr_itt; 1782577577daSMike Christie hdr->refcmdsn = task->cmdsn; 1783843c0a8aSMike Christie } 1784843c0a8aSMike Christie 17857996a778SMike Christie int iscsi_eh_abort(struct scsi_cmnd *sc) 17867996a778SMike Christie { 178775613521SMike Christie struct iscsi_cls_session *cls_session; 178875613521SMike Christie struct iscsi_session *session; 1789f47f2cf5SMike Christie struct iscsi_conn *conn; 17909c19a7d0SMike Christie struct iscsi_task *task; 1791843c0a8aSMike Christie struct iscsi_tm *hdr; 1792843c0a8aSMike Christie int rc, age; 17937996a778SMike Christie 179475613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 179575613521SMike Christie session = cls_session->dd_data; 179675613521SMike Christie 17976724add1SMike Christie mutex_lock(&session->eh_mutex); 17986724add1SMike Christie spin_lock_bh(&session->lock); 1799f47f2cf5SMike Christie /* 1800f47f2cf5SMike Christie * if session was ISCSI_STATE_IN_RECOVERY then we may not have 1801f47f2cf5SMike Christie * got the command. 1802f47f2cf5SMike Christie */ 1803f47f2cf5SMike Christie if (!sc->SCp.ptr) { 18041b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "sc never reached iscsi layer or " 18051b2c7af8SMike Christie "it completed.\n"); 18066724add1SMike Christie spin_unlock_bh(&session->lock); 18076724add1SMike Christie mutex_unlock(&session->eh_mutex); 1808f47f2cf5SMike Christie return SUCCESS; 1809f47f2cf5SMike Christie } 1810f47f2cf5SMike Christie 18117996a778SMike Christie /* 18127996a778SMike Christie * If we are not logged in or we have started a new session 18137996a778SMike Christie * then let the host reset code handle this 18147996a778SMike Christie */ 1815843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN || 1816843c0a8aSMike Christie sc->SCp.phase != session->age) { 1817843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1818843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 1819843c0a8aSMike Christie return FAILED; 1820843c0a8aSMike Christie } 1821843c0a8aSMike Christie 1822843c0a8aSMike Christie conn = session->leadconn; 1823843c0a8aSMike Christie conn->eh_abort_cnt++; 1824843c0a8aSMike Christie age = session->age; 1825843c0a8aSMike Christie 18269c19a7d0SMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 18271b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "aborting [sc %p itt 0x%x]\n", 18281b2c7af8SMike Christie sc, task->itt); 18297996a778SMike Christie 18309c19a7d0SMike Christie /* task completed before time out */ 18319c19a7d0SMike Christie if (!task->sc) { 18321b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "sc completed while abort in " 18331b2c7af8SMike Christie "progress\n"); 183477a23c21SMike Christie goto success; 18357ea8b828SMike Christie } 18367996a778SMike Christie 18379c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) { 18389c19a7d0SMike Christie fail_command(conn, task, DID_ABORT << 16); 183977a23c21SMike Christie goto success; 184077a23c21SMike Christie } 18417996a778SMike Christie 1842843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 1843843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 18447996a778SMike Christie goto failed; 1845843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 18467996a778SMike Christie 1847843c0a8aSMike Christie hdr = &conn->tmhdr; 18489c19a7d0SMike Christie iscsi_prep_abort_task_pdu(task, hdr); 1849843c0a8aSMike Christie 18509c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) { 1851843c0a8aSMike Christie rc = FAILED; 1852843c0a8aSMike Christie goto failed; 1853843c0a8aSMike Christie } 1854843c0a8aSMike Christie 1855843c0a8aSMike Christie switch (conn->tmf_state) { 1856843c0a8aSMike Christie case TMF_SUCCESS: 18577ea8b828SMike Christie spin_unlock_bh(&session->lock); 1858913e5bf4SMike Christie /* 1859913e5bf4SMike Christie * stop tx side incase the target had sent a abort rsp but 1860913e5bf4SMike Christie * the initiator was still writing out data. 1861913e5bf4SMike Christie */ 18626724add1SMike Christie iscsi_suspend_tx(conn); 18637996a778SMike Christie /* 1864913e5bf4SMike Christie * we do not stop the recv side because targets have been 1865913e5bf4SMike Christie * good and have never sent us a successful tmf response 1866913e5bf4SMike Christie * then sent more data for the cmd. 18677996a778SMike Christie */ 18687996a778SMike Christie spin_lock(&session->lock); 18699c19a7d0SMike Christie fail_command(conn, task, DID_ABORT << 16); 1870843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 18717996a778SMike Christie spin_unlock(&session->lock); 18726724add1SMike Christie iscsi_start_tx(conn); 187377a23c21SMike Christie goto success_unlocked; 1874843c0a8aSMike Christie case TMF_TIMEDOUT: 1875843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1876843c0a8aSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1877843c0a8aSMike Christie goto failed_unlocked; 1878843c0a8aSMike Christie case TMF_NOT_FOUND: 1879843c0a8aSMike Christie if (!sc->SCp.ptr) { 1880843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 18819c19a7d0SMike Christie /* task completed before tmf abort response */ 18821b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "sc completed while abort " 18831b2c7af8SMike Christie "in progress\n"); 188477a23c21SMike Christie goto success; 188577a23c21SMike Christie } 188677a23c21SMike Christie /* fall through */ 188777a23c21SMike Christie default: 1888843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 1889843c0a8aSMike Christie goto failed; 189077a23c21SMike Christie } 18917996a778SMike Christie 189277a23c21SMike Christie success: 189377a23c21SMike Christie spin_unlock_bh(&session->lock); 189477a23c21SMike Christie success_unlocked: 18951b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "abort success [sc %p itt 0x%x]\n", 18961b2c7af8SMike Christie sc, task->itt); 18976724add1SMike Christie mutex_unlock(&session->eh_mutex); 18987996a778SMike Christie return SUCCESS; 18997996a778SMike Christie 19007996a778SMike Christie failed: 19017996a778SMike Christie spin_unlock_bh(&session->lock); 190277a23c21SMike Christie failed_unlocked: 19031b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "abort failed [sc %p itt 0x%x]\n", sc, 19049c19a7d0SMike Christie task ? task->itt : 0); 19056724add1SMike Christie mutex_unlock(&session->eh_mutex); 19067996a778SMike Christie return FAILED; 19077996a778SMike Christie } 19087996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_abort); 19097996a778SMike Christie 1910843c0a8aSMike Christie static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 1911843c0a8aSMike Christie { 1912843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 1913843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 1914843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK; 1915843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 1916843c0a8aSMike Christie int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun); 1917f6d5180cSMike Christie hdr->rtt = RESERVED_ITT; 1918843c0a8aSMike Christie } 1919843c0a8aSMike Christie 1920843c0a8aSMike Christie int iscsi_eh_device_reset(struct scsi_cmnd *sc) 1921843c0a8aSMike Christie { 192275613521SMike Christie struct iscsi_cls_session *cls_session; 192375613521SMike Christie struct iscsi_session *session; 1924843c0a8aSMike Christie struct iscsi_conn *conn; 1925843c0a8aSMike Christie struct iscsi_tm *hdr; 1926843c0a8aSMike Christie int rc = FAILED; 1927843c0a8aSMike Christie 192875613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 192975613521SMike Christie session = cls_session->dd_data; 193075613521SMike Christie 19311b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "LU Reset [sc %p lun %u]\n", 19321b2c7af8SMike Christie sc, sc->device->lun); 1933843c0a8aSMike Christie 1934843c0a8aSMike Christie mutex_lock(&session->eh_mutex); 1935843c0a8aSMike Christie spin_lock_bh(&session->lock); 1936843c0a8aSMike Christie /* 1937843c0a8aSMike Christie * Just check if we are not logged in. We cannot check for 1938843c0a8aSMike Christie * the phase because the reset could come from a ioctl. 1939843c0a8aSMike Christie */ 1940843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 1941843c0a8aSMike Christie goto unlock; 1942843c0a8aSMike Christie conn = session->leadconn; 1943843c0a8aSMike Christie 1944843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 1945843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 1946843c0a8aSMike Christie goto unlock; 1947843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 1948843c0a8aSMike Christie 1949843c0a8aSMike Christie hdr = &conn->tmhdr; 1950843c0a8aSMike Christie iscsi_prep_lun_reset_pdu(sc, hdr); 1951843c0a8aSMike Christie 19529c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 1953f6d5180cSMike Christie session->lu_reset_timeout)) { 1954843c0a8aSMike Christie rc = FAILED; 1955843c0a8aSMike Christie goto unlock; 1956843c0a8aSMike Christie } 1957843c0a8aSMike Christie 1958843c0a8aSMike Christie switch (conn->tmf_state) { 1959843c0a8aSMike Christie case TMF_SUCCESS: 1960843c0a8aSMike Christie break; 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 done; 1965843c0a8aSMike Christie default: 1966843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 1967843c0a8aSMike Christie goto unlock; 1968843c0a8aSMike Christie } 1969843c0a8aSMike Christie 1970843c0a8aSMike Christie rc = SUCCESS; 1971843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1972843c0a8aSMike Christie 1973843c0a8aSMike Christie iscsi_suspend_tx(conn); 1974913e5bf4SMike Christie 1975a3439148SMike Christie spin_lock_bh(&session->lock); 19766eabafbeSMike Christie fail_all_commands(conn, sc->device->lun, DID_ERROR); 1977843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 1978a3439148SMike Christie spin_unlock_bh(&session->lock); 1979843c0a8aSMike Christie 1980843c0a8aSMike Christie iscsi_start_tx(conn); 1981843c0a8aSMike Christie goto done; 1982843c0a8aSMike Christie 1983843c0a8aSMike Christie unlock: 1984843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1985843c0a8aSMike Christie done: 19861b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "dev reset result = %s\n", 1987843c0a8aSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 1988843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 1989843c0a8aSMike Christie return rc; 1990843c0a8aSMike Christie } 1991843c0a8aSMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_device_reset); 1992843c0a8aSMike Christie 19936320377fSOlaf Kirch /* 19946320377fSOlaf Kirch * Pre-allocate a pool of @max items of @item_size. By default, the pool 19956320377fSOlaf Kirch * should be accessed via kfifo_{get,put} on q->queue. 19966320377fSOlaf Kirch * Optionally, the caller can obtain the array of object pointers 19976320377fSOlaf Kirch * by passing in a non-NULL @items pointer 19986320377fSOlaf Kirch */ 19997996a778SMike Christie int 20006320377fSOlaf Kirch iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size) 20017996a778SMike Christie { 20026320377fSOlaf Kirch int i, num_arrays = 1; 20037996a778SMike Christie 20046320377fSOlaf Kirch memset(q, 0, sizeof(*q)); 20057996a778SMike Christie 20067996a778SMike Christie q->max = max; 20076320377fSOlaf Kirch 20086320377fSOlaf Kirch /* If the user passed an items pointer, he wants a copy of 20096320377fSOlaf Kirch * the array. */ 20106320377fSOlaf Kirch if (items) 20116320377fSOlaf Kirch num_arrays++; 20126320377fSOlaf Kirch q->pool = kzalloc(num_arrays * max * sizeof(void*), GFP_KERNEL); 20136320377fSOlaf Kirch if (q->pool == NULL) 2014f474a37bSJean Delvare return -ENOMEM; 20157996a778SMike Christie 20167996a778SMike Christie q->queue = kfifo_init((void*)q->pool, max * sizeof(void*), 20177996a778SMike Christie GFP_KERNEL, NULL); 2018fd6e1c14SJean Delvare if (IS_ERR(q->queue)) { 2019fd6e1c14SJean Delvare q->queue = NULL; 20206320377fSOlaf Kirch goto enomem; 2021fd6e1c14SJean Delvare } 20227996a778SMike Christie 20237996a778SMike Christie for (i = 0; i < max; i++) { 20246320377fSOlaf Kirch q->pool[i] = kzalloc(item_size, GFP_KERNEL); 20257996a778SMike Christie if (q->pool[i] == NULL) { 20266320377fSOlaf Kirch q->max = i; 20276320377fSOlaf Kirch goto enomem; 20287996a778SMike Christie } 20297996a778SMike Christie __kfifo_put(q->queue, (void*)&q->pool[i], sizeof(void*)); 20307996a778SMike Christie } 20316320377fSOlaf Kirch 20326320377fSOlaf Kirch if (items) { 20336320377fSOlaf Kirch *items = q->pool + max; 20346320377fSOlaf Kirch memcpy(*items, q->pool, max * sizeof(void *)); 20356320377fSOlaf Kirch } 20366320377fSOlaf Kirch 20377996a778SMike Christie return 0; 20386320377fSOlaf Kirch 20396320377fSOlaf Kirch enomem: 20406320377fSOlaf Kirch iscsi_pool_free(q); 20416320377fSOlaf Kirch return -ENOMEM; 20427996a778SMike Christie } 20437996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_init); 20447996a778SMike Christie 20456320377fSOlaf Kirch void iscsi_pool_free(struct iscsi_pool *q) 20467996a778SMike Christie { 20477996a778SMike Christie int i; 20487996a778SMike Christie 20497996a778SMike Christie for (i = 0; i < q->max; i++) 20506320377fSOlaf Kirch kfree(q->pool[i]); 20517996a778SMike Christie kfree(q->pool); 20522f5899a3SMike Christie kfree(q->queue); 20537996a778SMike Christie } 20547996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_free); 20557996a778SMike Christie 2056a4804cd6SMike Christie /** 2057a4804cd6SMike Christie * iscsi_host_add - add host to system 2058a4804cd6SMike Christie * @shost: scsi host 2059a4804cd6SMike Christie * @pdev: parent device 2060a4804cd6SMike Christie * 2061a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers 2062a4804cd6SMike Christie * to add a host to the system. 2063a4804cd6SMike Christie */ 2064a4804cd6SMike Christie int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev) 20657996a778SMike Christie { 20668e9a20ceSMike Christie if (!shost->can_queue) 20678e9a20ceSMike Christie shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX; 20688e9a20ceSMike Christie 20694d108350SMike Christie if (!shost->cmd_per_lun) 20704d108350SMike Christie shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN; 20714d108350SMike Christie 2072308cec14SMike Christie if (!shost->transportt->eh_timed_out) 2073308cec14SMike Christie shost->transportt->eh_timed_out = iscsi_eh_cmd_timed_out; 2074a4804cd6SMike Christie return scsi_add_host(shost, pdev); 2075a4804cd6SMike Christie } 2076a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_add); 2077a4804cd6SMike Christie 2078a4804cd6SMike Christie /** 2079a4804cd6SMike Christie * iscsi_host_alloc - allocate a host and driver data 2080a4804cd6SMike Christie * @sht: scsi host template 2081a4804cd6SMike Christie * @dd_data_size: driver host data size 208232ae763eSMike Christie * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue 2083a4804cd6SMike Christie * 2084a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers. 2085a4804cd6SMike Christie * To access the driver specific memory use the iscsi_host_priv() macro. 2086a4804cd6SMike Christie */ 2087a4804cd6SMike Christie struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht, 20884d108350SMike Christie int dd_data_size, bool xmit_can_sleep) 2089a4804cd6SMike Christie { 2090a4804cd6SMike Christie struct Scsi_Host *shost; 2091e5bd7b54SMike Christie struct iscsi_host *ihost; 2092a4804cd6SMike Christie 2093a4804cd6SMike Christie shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size); 2094a4804cd6SMike Christie if (!shost) 2095a4804cd6SMike Christie return NULL; 2096e5bd7b54SMike Christie ihost = shost_priv(shost); 209732ae763eSMike Christie 209832ae763eSMike Christie if (xmit_can_sleep) { 209932ae763eSMike Christie snprintf(ihost->workq_name, sizeof(ihost->workq_name), 210032ae763eSMike Christie "iscsi_q_%d", shost->host_no); 210132ae763eSMike Christie ihost->workq = create_singlethread_workqueue(ihost->workq_name); 210232ae763eSMike Christie if (!ihost->workq) 210332ae763eSMike Christie goto free_host; 210432ae763eSMike Christie } 210532ae763eSMike Christie 2106e5bd7b54SMike Christie spin_lock_init(&ihost->lock); 2107e5bd7b54SMike Christie ihost->state = ISCSI_HOST_SETUP; 2108e5bd7b54SMike Christie ihost->num_sessions = 0; 2109e5bd7b54SMike Christie init_waitqueue_head(&ihost->session_removal_wq); 2110a4804cd6SMike Christie return shost; 211132ae763eSMike Christie 211232ae763eSMike Christie free_host: 211332ae763eSMike Christie scsi_host_put(shost); 211432ae763eSMike Christie return NULL; 211575613521SMike Christie } 2116a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_alloc); 211775613521SMike Christie 2118e5bd7b54SMike Christie static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session) 2119e5bd7b54SMike Christie { 212040a06e75SMike Christie iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST); 2121e5bd7b54SMike Christie } 2122e5bd7b54SMike Christie 2123a4804cd6SMike Christie /** 2124a4804cd6SMike Christie * iscsi_host_remove - remove host and sessions 2125a4804cd6SMike Christie * @shost: scsi host 2126a4804cd6SMike Christie * 2127e5bd7b54SMike Christie * If there are any sessions left, this will initiate the removal and wait 2128e5bd7b54SMike Christie * for the completion. 2129a4804cd6SMike Christie */ 2130a4804cd6SMike Christie void iscsi_host_remove(struct Scsi_Host *shost) 2131a4804cd6SMike Christie { 2132e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2133e5bd7b54SMike Christie unsigned long flags; 2134e5bd7b54SMike Christie 2135e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2136e5bd7b54SMike Christie ihost->state = ISCSI_HOST_REMOVED; 2137e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2138e5bd7b54SMike Christie 2139e5bd7b54SMike Christie iscsi_host_for_each_session(shost, iscsi_notify_host_removed); 2140e5bd7b54SMike Christie wait_event_interruptible(ihost->session_removal_wq, 2141e5bd7b54SMike Christie ihost->num_sessions == 0); 2142e5bd7b54SMike Christie if (signal_pending(current)) 2143e5bd7b54SMike Christie flush_signals(current); 2144e5bd7b54SMike Christie 2145a4804cd6SMike Christie scsi_remove_host(shost); 214632ae763eSMike Christie if (ihost->workq) 214732ae763eSMike Christie destroy_workqueue(ihost->workq); 2148a4804cd6SMike Christie } 2149a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_remove); 2150a4804cd6SMike Christie 2151a4804cd6SMike Christie void iscsi_host_free(struct Scsi_Host *shost) 215275613521SMike Christie { 215375613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 215475613521SMike Christie 215575613521SMike Christie kfree(ihost->netdev); 215675613521SMike Christie kfree(ihost->hwaddress); 215775613521SMike Christie kfree(ihost->initiatorname); 2158a4804cd6SMike Christie scsi_host_put(shost); 215975613521SMike Christie } 2160a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_free); 216175613521SMike Christie 2162e5bd7b54SMike Christie static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost) 2163e5bd7b54SMike Christie { 2164e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2165e5bd7b54SMike Christie unsigned long flags; 2166e5bd7b54SMike Christie 2167e5bd7b54SMike Christie shost = scsi_host_get(shost); 2168e5bd7b54SMike Christie if (!shost) { 2169e5bd7b54SMike Christie printk(KERN_ERR "Invalid state. Cannot notify host removal " 2170e5bd7b54SMike Christie "of session teardown event because host already " 2171e5bd7b54SMike Christie "removed.\n"); 2172e5bd7b54SMike Christie return; 2173e5bd7b54SMike Christie } 2174e5bd7b54SMike Christie 2175e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2176e5bd7b54SMike Christie ihost->num_sessions--; 2177e5bd7b54SMike Christie if (ihost->num_sessions == 0) 2178e5bd7b54SMike Christie wake_up(&ihost->session_removal_wq); 2179e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2180e5bd7b54SMike Christie scsi_host_put(shost); 2181e5bd7b54SMike Christie } 2182e5bd7b54SMike Christie 218375613521SMike Christie /** 218475613521SMike Christie * iscsi_session_setup - create iscsi cls session and host and session 218575613521SMike Christie * @iscsit: iscsi transport template 218675613521SMike Christie * @shost: scsi host 218775613521SMike Christie * @cmds_max: session can queue 21889c19a7d0SMike Christie * @cmd_task_size: LLD task private data size 218975613521SMike Christie * @initial_cmdsn: initial CmdSN 219075613521SMike Christie * 219175613521SMike Christie * This can be used by software iscsi_transports that allocate 219275613521SMike Christie * a session per scsi host. 21933cf7b233SMike Christie * 21943cf7b233SMike Christie * Callers should set cmds_max to the largest total numer (mgmt + scsi) of 21953cf7b233SMike Christie * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks 21963cf7b233SMike Christie * for nop handling and login/logout requests. 219775613521SMike Christie */ 219875613521SMike Christie struct iscsi_cls_session * 219975613521SMike Christie iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, 22003cf7b233SMike Christie uint16_t cmds_max, int cmd_task_size, 22017970634bSMike Christie uint32_t initial_cmdsn, unsigned int id) 220275613521SMike Christie { 2203e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 220475613521SMike Christie struct iscsi_session *session; 220575613521SMike Christie struct iscsi_cls_session *cls_session; 22063cf7b233SMike Christie int cmd_i, scsi_cmds, total_cmds = cmds_max; 2207e5bd7b54SMike Christie unsigned long flags; 2208e5bd7b54SMike Christie 2209e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2210e5bd7b54SMike Christie if (ihost->state == ISCSI_HOST_REMOVED) { 2211e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2212e5bd7b54SMike Christie return NULL; 2213e5bd7b54SMike Christie } 2214e5bd7b54SMike Christie ihost->num_sessions++; 2215e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 22168e9a20ceSMike Christie 22178e9a20ceSMike Christie if (!total_cmds) 22188e9a20ceSMike Christie total_cmds = ISCSI_DEF_XMIT_CMDS_MAX; 22193e5c28adSMike Christie /* 22203cf7b233SMike Christie * The iscsi layer needs some tasks for nop handling and tmfs, 22213cf7b233SMike Christie * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX 22223cf7b233SMike Christie * + 1 command for scsi IO. 22233e5c28adSMike Christie */ 22243cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 22253cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 22263cf7b233SMike Christie "must be a power of two that is at least %d.\n", 22273cf7b233SMike Christie total_cmds, ISCSI_TOTAL_CMDS_MIN); 2228e5bd7b54SMike Christie goto dec_session_count; 22291548271eSMike Christie } 22303cf7b233SMike Christie 22313cf7b233SMike Christie if (total_cmds > ISCSI_TOTAL_CMDS_MAX) { 22323cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 22333cf7b233SMike Christie "must be a power of 2 less than or equal to %d.\n", 22343cf7b233SMike Christie cmds_max, ISCSI_TOTAL_CMDS_MAX); 22353cf7b233SMike Christie total_cmds = ISCSI_TOTAL_CMDS_MAX; 22363cf7b233SMike Christie } 22373cf7b233SMike Christie 22383cf7b233SMike Christie if (!is_power_of_2(total_cmds)) { 22393cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 22403cf7b233SMike Christie "must be a power of 2.\n", total_cmds); 22413cf7b233SMike Christie total_cmds = rounddown_pow_of_two(total_cmds); 22423cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) 22433cf7b233SMike Christie return NULL; 22443cf7b233SMike Christie printk(KERN_INFO "iscsi: Rounding can_queue to %d.\n", 22453cf7b233SMike Christie total_cmds); 22463cf7b233SMike Christie } 22473cf7b233SMike Christie scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX; 22481548271eSMike Christie 22495d91e209SMike Christie cls_session = iscsi_alloc_session(shost, iscsit, 22505d91e209SMike Christie sizeof(struct iscsi_session)); 225175613521SMike Christie if (!cls_session) 2252e5bd7b54SMike Christie goto dec_session_count; 225375613521SMike Christie session = cls_session->dd_data; 225475613521SMike Christie session->cls_session = cls_session; 22557996a778SMike Christie session->host = shost; 22567996a778SMike Christie session->state = ISCSI_STATE_FREE; 2257f6d5180cSMike Christie session->fast_abort = 1; 22584cd49ea1SMike Christie session->lu_reset_timeout = 15; 22594cd49ea1SMike Christie session->abort_timeout = 10; 22603cf7b233SMike Christie session->scsi_cmds_max = scsi_cmds; 22613cf7b233SMike Christie session->cmds_max = total_cmds; 2262e0726407SMike Christie session->queued_cmdsn = session->cmdsn = initial_cmdsn; 22637996a778SMike Christie session->exp_cmdsn = initial_cmdsn + 1; 22647996a778SMike Christie session->max_cmdsn = initial_cmdsn + 1; 22657996a778SMike Christie session->max_r2t = 1; 22667996a778SMike Christie session->tt = iscsit; 22676724add1SMike Christie mutex_init(&session->eh_mutex); 226875613521SMike Christie spin_lock_init(&session->lock); 22697996a778SMike Christie 22707996a778SMike Christie /* initialize SCSI PDU commands pool */ 22717996a778SMike Christie if (iscsi_pool_init(&session->cmdpool, session->cmds_max, 22727996a778SMike Christie (void***)&session->cmds, 22739c19a7d0SMike Christie cmd_task_size + sizeof(struct iscsi_task))) 22747996a778SMike Christie goto cmdpool_alloc_fail; 22757996a778SMike Christie 22767996a778SMike Christie /* pre-format cmds pool with ITT */ 22777996a778SMike Christie for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) { 22789c19a7d0SMike Christie struct iscsi_task *task = session->cmds[cmd_i]; 22797996a778SMike Christie 22809c19a7d0SMike Christie if (cmd_task_size) 22819c19a7d0SMike Christie task->dd_data = &task[1]; 22829c19a7d0SMike Christie task->itt = cmd_i; 22839c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 22847996a778SMike Christie } 22857996a778SMike Christie 2286f53a88daSMike Christie if (!try_module_get(iscsit->owner)) 228775613521SMike Christie goto module_get_fail; 228875613521SMike Christie 22897970634bSMike Christie if (iscsi_add_session(cls_session, id)) 2290f53a88daSMike Christie goto cls_session_fail; 2291e5bd7b54SMike Christie 22927996a778SMike Christie return cls_session; 22937996a778SMike Christie 22947996a778SMike Christie cls_session_fail: 229575613521SMike Christie module_put(iscsit->owner); 229675613521SMike Christie module_get_fail: 22976320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 22987996a778SMike Christie cmdpool_alloc_fail: 229975613521SMike Christie iscsi_free_session(cls_session); 2300e5bd7b54SMike Christie dec_session_count: 2301e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 23027996a778SMike Christie return NULL; 23037996a778SMike Christie } 23047996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_setup); 23057996a778SMike Christie 23067996a778SMike Christie /** 23077996a778SMike Christie * iscsi_session_teardown - destroy session, host, and cls_session 230875613521SMike Christie * @cls_session: iscsi session 23097996a778SMike Christie * 231075613521SMike Christie * The driver must have called iscsi_remove_session before 231175613521SMike Christie * calling this. 231275613521SMike Christie */ 23137996a778SMike Christie void iscsi_session_teardown(struct iscsi_cls_session *cls_session) 23147996a778SMike Christie { 231575613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 231663f75cc8SMike Christie struct module *owner = cls_session->transport->owner; 2317e5bd7b54SMike Christie struct Scsi_Host *shost = session->host; 23187996a778SMike Christie 23196320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 23207996a778SMike Christie 2321b2c64167SMike Christie kfree(session->password); 2322b2c64167SMike Christie kfree(session->password_in); 2323b2c64167SMike Christie kfree(session->username); 2324b2c64167SMike Christie kfree(session->username_in); 2325f3ff0c36SMike Christie kfree(session->targetname); 232688dfd340SMike Christie kfree(session->initiatorname); 232788dfd340SMike Christie kfree(session->ifacename); 2328f3ff0c36SMike Christie 232975613521SMike Christie iscsi_destroy_session(cls_session); 2330e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 233163f75cc8SMike Christie module_put(owner); 23327996a778SMike Christie } 23337996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_teardown); 23347996a778SMike Christie 23357996a778SMike Christie /** 23367996a778SMike Christie * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn 23377996a778SMike Christie * @cls_session: iscsi_cls_session 23385d91e209SMike Christie * @dd_size: private driver data size 23397996a778SMike Christie * @conn_idx: cid 23405d91e209SMike Christie */ 23417996a778SMike Christie struct iscsi_cls_conn * 23425d91e209SMike Christie iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, 23435d91e209SMike Christie uint32_t conn_idx) 23447996a778SMike Christie { 234575613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 23467996a778SMike Christie struct iscsi_conn *conn; 23477996a778SMike Christie struct iscsi_cls_conn *cls_conn; 2348d36ab6f3SMike Christie char *data; 23497996a778SMike Christie 23505d91e209SMike Christie cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size, 23515d91e209SMike Christie conn_idx); 23527996a778SMike Christie if (!cls_conn) 23537996a778SMike Christie return NULL; 23547996a778SMike Christie conn = cls_conn->dd_data; 23555d91e209SMike Christie memset(conn, 0, sizeof(*conn) + dd_size); 23567996a778SMike Christie 23575d91e209SMike Christie conn->dd_data = cls_conn->dd_data + sizeof(*conn); 23587996a778SMike Christie conn->session = session; 23597996a778SMike Christie conn->cls_conn = cls_conn; 23607996a778SMike Christie conn->c_stage = ISCSI_CONN_INITIAL_STAGE; 23617996a778SMike Christie conn->id = conn_idx; 23627996a778SMike Christie conn->exp_statsn = 0; 2363843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2364f6d5180cSMike Christie 2365f6d5180cSMike Christie init_timer(&conn->transport_timer); 2366f6d5180cSMike Christie conn->transport_timer.data = (unsigned long)conn; 2367f6d5180cSMike Christie conn->transport_timer.function = iscsi_check_transport_timeouts; 2368f6d5180cSMike Christie 23697996a778SMike Christie INIT_LIST_HEAD(&conn->run_list); 23707996a778SMike Christie INIT_LIST_HEAD(&conn->mgmt_run_list); 2371843c0a8aSMike Christie INIT_LIST_HEAD(&conn->mgmtqueue); 2372b6c395edSMike Christie INIT_LIST_HEAD(&conn->xmitqueue); 2373843c0a8aSMike Christie INIT_LIST_HEAD(&conn->requeue); 2374c4028958SDavid Howells INIT_WORK(&conn->xmitwork, iscsi_xmitworker); 23757996a778SMike Christie 23769c19a7d0SMike Christie /* allocate login_task used for the login/text sequences */ 23777996a778SMike Christie spin_lock_bh(&session->lock); 23783e5c28adSMike Christie if (!__kfifo_get(session->cmdpool.queue, 23799c19a7d0SMike Christie (void*)&conn->login_task, 23807996a778SMike Christie sizeof(void*))) { 23817996a778SMike Christie spin_unlock_bh(&session->lock); 23829c19a7d0SMike Christie goto login_task_alloc_fail; 23837996a778SMike Christie } 23847996a778SMike Christie spin_unlock_bh(&session->lock); 23857996a778SMike Christie 2386cfeb2cf9SMike Christie data = (char *) __get_free_pages(GFP_KERNEL, 2387cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2388d36ab6f3SMike Christie if (!data) 23899c19a7d0SMike Christie goto login_task_data_alloc_fail; 23909c19a7d0SMike Christie conn->login_task->data = conn->data = data; 2391d36ab6f3SMike Christie 2392843c0a8aSMike Christie init_timer(&conn->tmf_timer); 23937996a778SMike Christie init_waitqueue_head(&conn->ehwait); 23947996a778SMike Christie 23957996a778SMike Christie return cls_conn; 23967996a778SMike Christie 23979c19a7d0SMike Christie login_task_data_alloc_fail: 23989c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task, 2399d36ab6f3SMike Christie sizeof(void*)); 24009c19a7d0SMike Christie login_task_alloc_fail: 24017996a778SMike Christie iscsi_destroy_conn(cls_conn); 24027996a778SMike Christie return NULL; 24037996a778SMike Christie } 24047996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_setup); 24057996a778SMike Christie 24067996a778SMike Christie /** 24077996a778SMike Christie * iscsi_conn_teardown - teardown iscsi connection 24087996a778SMike Christie * cls_conn: iscsi class connection 24097996a778SMike Christie * 24107996a778SMike Christie * TODO: we may need to make this into a two step process 24117996a778SMike Christie * like scsi-mls remove + put host 24127996a778SMike Christie */ 24137996a778SMike Christie void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) 24147996a778SMike Christie { 24157996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 24167996a778SMike Christie struct iscsi_session *session = conn->session; 24177996a778SMike Christie unsigned long flags; 24187996a778SMike Christie 2419f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 2420f6d5180cSMike Christie 24217996a778SMike Christie spin_lock_bh(&session->lock); 24227996a778SMike Christie conn->c_stage = ISCSI_CONN_CLEANUP_WAIT; 24237996a778SMike Christie if (session->leadconn == conn) { 24247996a778SMike Christie /* 24257996a778SMike Christie * leading connection? then give up on recovery. 24267996a778SMike Christie */ 24277996a778SMike Christie session->state = ISCSI_STATE_TERMINATE; 24287996a778SMike Christie wake_up(&conn->ehwait); 24297996a778SMike Christie } 24307996a778SMike Christie spin_unlock_bh(&session->lock); 24317996a778SMike Christie 24327996a778SMike Christie /* 24337996a778SMike Christie * Block until all in-progress commands for this connection 24347996a778SMike Christie * time out or fail. 24357996a778SMike Christie */ 24367996a778SMike Christie for (;;) { 24377996a778SMike Christie spin_lock_irqsave(session->host->host_lock, flags); 24387996a778SMike Christie if (!session->host->host_busy) { /* OK for ERL == 0 */ 24397996a778SMike Christie spin_unlock_irqrestore(session->host->host_lock, flags); 24407996a778SMike Christie break; 24417996a778SMike Christie } 24427996a778SMike Christie spin_unlock_irqrestore(session->host->host_lock, flags); 24437996a778SMike Christie msleep_interruptible(500); 2444322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "iscsi conn_destroy(): " 2445322d739dSMike Christie "host_busy %d host_failed %d\n", 2446322d739dSMike Christie session->host->host_busy, 2447be2df72eSOr Gerlitz session->host->host_failed); 24487996a778SMike Christie /* 24497996a778SMike Christie * force eh_abort() to unblock 24507996a778SMike Christie */ 24517996a778SMike Christie wake_up(&conn->ehwait); 24527996a778SMike Christie } 24537996a778SMike Christie 2454779ea120SMike Christie /* flush queued up work because we free the connection below */ 2455843c0a8aSMike Christie iscsi_suspend_tx(conn); 2456779ea120SMike Christie 24577996a778SMike Christie spin_lock_bh(&session->lock); 2458cfeb2cf9SMike Christie free_pages((unsigned long) conn->data, 2459cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2460f3ff0c36SMike Christie kfree(conn->persistent_address); 24619c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task, 24627996a778SMike Christie sizeof(void*)); 2463e0726407SMike Christie if (session->leadconn == conn) 24647996a778SMike Christie session->leadconn = NULL; 24657996a778SMike Christie spin_unlock_bh(&session->lock); 24667996a778SMike Christie 24677996a778SMike Christie iscsi_destroy_conn(cls_conn); 24687996a778SMike Christie } 24697996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_teardown); 24707996a778SMike Christie 24717996a778SMike Christie int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 24727996a778SMike Christie { 24737996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 24747996a778SMike Christie struct iscsi_session *session = conn->session; 24757996a778SMike Christie 2476ffd0436eSMike Christie if (!session) { 2477322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 2478322d739dSMike Christie "can't start unbound connection\n"); 24797996a778SMike Christie return -EPERM; 24807996a778SMike Christie } 24817996a778SMike Christie 2482db98ccdeSMike Christie if ((session->imm_data_en || !session->initial_r2t_en) && 2483db98ccdeSMike Christie session->first_burst > session->max_burst) { 2484322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: " 2485ffd0436eSMike Christie "first_burst %d max_burst %d\n", 2486ffd0436eSMike Christie session->first_burst, session->max_burst); 2487ffd0436eSMike Christie return -EINVAL; 2488ffd0436eSMike Christie } 2489ffd0436eSMike Christie 2490f6d5180cSMike Christie if (conn->ping_timeout && !conn->recv_timeout) { 2491322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of " 2492322d739dSMike Christie "zero. Using 5 seconds\n."); 2493f6d5180cSMike Christie conn->recv_timeout = 5; 2494f6d5180cSMike Christie } 2495f6d5180cSMike Christie 2496f6d5180cSMike Christie if (conn->recv_timeout && !conn->ping_timeout) { 2497322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of " 2498322d739dSMike Christie "zero. Using 5 seconds.\n"); 2499f6d5180cSMike Christie conn->ping_timeout = 5; 2500f6d5180cSMike Christie } 2501f6d5180cSMike Christie 25027996a778SMike Christie spin_lock_bh(&session->lock); 25037996a778SMike Christie conn->c_stage = ISCSI_CONN_STARTED; 25047996a778SMike Christie session->state = ISCSI_STATE_LOGGED_IN; 2505e0726407SMike Christie session->queued_cmdsn = session->cmdsn; 25067996a778SMike Christie 2507f6d5180cSMike Christie conn->last_recv = jiffies; 2508f6d5180cSMike Christie conn->last_ping = jiffies; 2509f6d5180cSMike Christie if (conn->recv_timeout && conn->ping_timeout) 2510f6d5180cSMike Christie mod_timer(&conn->transport_timer, 2511f6d5180cSMike Christie jiffies + (conn->recv_timeout * HZ)); 2512f6d5180cSMike Christie 25137996a778SMike Christie switch(conn->stop_stage) { 25147996a778SMike Christie case STOP_CONN_RECOVER: 25157996a778SMike Christie /* 25167996a778SMike Christie * unblock eh_abort() if it is blocked. re-try all 25177996a778SMike Christie * commands after successful recovery 25187996a778SMike Christie */ 25197996a778SMike Christie conn->stop_stage = 0; 2520843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 25217996a778SMike Christie session->age++; 25228b1d0343SMike Christie if (session->age == 16) 25238b1d0343SMike Christie session->age = 0; 25246eabafbeSMike Christie break; 25257996a778SMike Christie case STOP_CONN_TERM: 25267996a778SMike Christie conn->stop_stage = 0; 25277996a778SMike Christie break; 25287996a778SMike Christie default: 25297996a778SMike Christie break; 25307996a778SMike Christie } 25317996a778SMike Christie spin_unlock_bh(&session->lock); 25327996a778SMike Christie 253375613521SMike Christie iscsi_unblock_session(session->cls_session); 25346eabafbeSMike Christie wake_up(&conn->ehwait); 25357996a778SMike Christie return 0; 25367996a778SMike Christie } 25377996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_start); 25387996a778SMike Christie 25397996a778SMike Christie static void 25407996a778SMike Christie flush_control_queues(struct iscsi_session *session, struct iscsi_conn *conn) 25417996a778SMike Christie { 25429c19a7d0SMike Christie struct iscsi_task *task, *tmp; 25437996a778SMike Christie 25447996a778SMike Christie /* handle pending */ 25459c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->mgmtqueue, running) { 25461b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "flushing pending mgmt task " 25471b2c7af8SMike Christie "itt 0x%x\n", task->itt); 25489c19a7d0SMike Christie /* release ref from prep task */ 25499c19a7d0SMike Christie __iscsi_put_task(task); 25507996a778SMike Christie } 25517996a778SMike Christie 25527996a778SMike Christie /* handle running */ 25539c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->mgmt_run_list, running) { 25541b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "flushing running mgmt task " 25551b2c7af8SMike Christie "itt 0x%x\n", task->itt); 25569c19a7d0SMike Christie /* release ref from prep task */ 25579c19a7d0SMike Christie __iscsi_put_task(task); 25587996a778SMike Christie } 25597996a778SMike Christie 25609c19a7d0SMike Christie conn->task = NULL; 25617996a778SMike Christie } 25627996a778SMike Christie 2563656cffc9SMike Christie static void iscsi_start_session_recovery(struct iscsi_session *session, 25647996a778SMike Christie struct iscsi_conn *conn, int flag) 25657996a778SMike Christie { 2566ed2abc7fSMike Christie int old_stop_stage; 2567ed2abc7fSMike Christie 2568f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 2569f6d5180cSMike Christie 25706724add1SMike Christie mutex_lock(&session->eh_mutex); 25717996a778SMike Christie spin_lock_bh(&session->lock); 2572ed2abc7fSMike Christie if (conn->stop_stage == STOP_CONN_TERM) { 25737996a778SMike Christie spin_unlock_bh(&session->lock); 25746724add1SMike Christie mutex_unlock(&session->eh_mutex); 25756724add1SMike Christie return; 25766724add1SMike Christie } 25776724add1SMike Christie 25786724add1SMike Christie /* 2579ed2abc7fSMike Christie * When this is called for the in_login state, we only want to clean 25809c19a7d0SMike Christie * up the login task and connection. We do not need to block and set 258167a61114SMike Christie * the recovery state again 2582ed2abc7fSMike Christie */ 258367a61114SMike Christie if (flag == STOP_CONN_TERM) 258467a61114SMike Christie session->state = ISCSI_STATE_TERMINATE; 258567a61114SMike Christie else if (conn->stop_stage != STOP_CONN_RECOVER) 258667a61114SMike Christie session->state = ISCSI_STATE_IN_RECOVERY; 2587ed2abc7fSMike Christie 2588ed2abc7fSMike Christie old_stop_stage = conn->stop_stage; 25897996a778SMike Christie conn->stop_stage = flag; 259067a61114SMike Christie conn->c_stage = ISCSI_CONN_STOPPED; 25917996a778SMike Christie spin_unlock_bh(&session->lock); 25926724add1SMike Christie 25936724add1SMike Christie iscsi_suspend_tx(conn); 25947996a778SMike Christie /* 25957996a778SMike Christie * for connection level recovery we should not calculate 25967996a778SMike Christie * header digest. conn->hdr_size used for optimization 25977996a778SMike Christie * in hdr_extract() and will be re-negotiated at 25987996a778SMike Christie * set_param() time. 25997996a778SMike Christie */ 26007996a778SMike Christie if (flag == STOP_CONN_RECOVER) { 26017996a778SMike Christie conn->hdrdgst_en = 0; 26027996a778SMike Christie conn->datadgst_en = 0; 2603656cffc9SMike Christie if (session->state == ISCSI_STATE_IN_RECOVERY && 260467a61114SMike Christie old_stop_stage != STOP_CONN_RECOVER) { 26051b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "blocking session\n"); 260675613521SMike Christie iscsi_block_session(session->cls_session); 26077996a778SMike Christie } 260867a61114SMike Christie } 2609656cffc9SMike Christie 2610656cffc9SMike Christie /* 2611656cffc9SMike Christie * flush queues. 2612656cffc9SMike Christie */ 2613656cffc9SMike Christie spin_lock_bh(&session->lock); 261487cd9eabSMike Christie if (flag == STOP_CONN_RECOVER) 261556d7fcfaSMike Christie fail_all_commands(conn, -1, DID_TRANSPORT_DISRUPTED); 261656d7fcfaSMike Christie else 261756d7fcfaSMike Christie fail_all_commands(conn, -1, DID_ERROR); 2618656cffc9SMike Christie flush_control_queues(session, conn); 2619656cffc9SMike Christie spin_unlock_bh(&session->lock); 26206724add1SMike Christie mutex_unlock(&session->eh_mutex); 26217996a778SMike Christie } 26227996a778SMike Christie 26237996a778SMike Christie void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 26247996a778SMike Christie { 26257996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 26267996a778SMike Christie struct iscsi_session *session = conn->session; 26277996a778SMike Christie 26287996a778SMike Christie switch (flag) { 26297996a778SMike Christie case STOP_CONN_RECOVER: 26307996a778SMike Christie case STOP_CONN_TERM: 26317996a778SMike Christie iscsi_start_session_recovery(session, conn, flag); 26328d2860b3SMike Christie break; 26337996a778SMike Christie default: 2634322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 2635322d739dSMike Christie "invalid stop flag %d\n", flag); 26367996a778SMike Christie } 26377996a778SMike Christie } 26387996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_stop); 26397996a778SMike Christie 26407996a778SMike Christie int iscsi_conn_bind(struct iscsi_cls_session *cls_session, 26417996a778SMike Christie struct iscsi_cls_conn *cls_conn, int is_leading) 26427996a778SMike Christie { 264375613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 264498644047SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 26457996a778SMike Christie 26467996a778SMike Christie spin_lock_bh(&session->lock); 26477996a778SMike Christie if (is_leading) 26487996a778SMike Christie session->leadconn = conn; 264998644047SMike Christie spin_unlock_bh(&session->lock); 26507996a778SMike Christie 26517996a778SMike Christie /* 26527996a778SMike Christie * Unblock xmitworker(), Login Phase will pass through. 26537996a778SMike Christie */ 26547996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 26557996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 26567996a778SMike Christie return 0; 26577996a778SMike Christie } 26587996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_bind); 26597996a778SMike Christie 26605700b1afSMike Christie static int iscsi_switch_str_param(char **param, char *new_val_buf) 26615700b1afSMike Christie { 26625700b1afSMike Christie char *new_val; 26635700b1afSMike Christie 26645700b1afSMike Christie if (*param) { 26655700b1afSMike Christie if (!strcmp(*param, new_val_buf)) 26665700b1afSMike Christie return 0; 26675700b1afSMike Christie } 26685700b1afSMike Christie 26695700b1afSMike Christie new_val = kstrdup(new_val_buf, GFP_NOIO); 26705700b1afSMike Christie if (!new_val) 26715700b1afSMike Christie return -ENOMEM; 26725700b1afSMike Christie 26735700b1afSMike Christie kfree(*param); 26745700b1afSMike Christie *param = new_val; 26755700b1afSMike Christie return 0; 26765700b1afSMike Christie } 2677a54a52caSMike Christie 2678a54a52caSMike Christie int iscsi_set_param(struct iscsi_cls_conn *cls_conn, 2679a54a52caSMike Christie enum iscsi_param param, char *buf, int buflen) 2680a54a52caSMike Christie { 2681a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 2682a54a52caSMike Christie struct iscsi_session *session = conn->session; 2683a54a52caSMike Christie uint32_t value; 2684a54a52caSMike Christie 2685a54a52caSMike Christie switch(param) { 2686843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 2687843c0a8aSMike Christie sscanf(buf, "%d", &session->fast_abort); 2688843c0a8aSMike Christie break; 2689f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 2690f6d5180cSMike Christie sscanf(buf, "%d", &session->abort_timeout); 2691f6d5180cSMike Christie break; 2692f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 2693f6d5180cSMike Christie sscanf(buf, "%d", &session->lu_reset_timeout); 2694f6d5180cSMike Christie break; 2695f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 2696f6d5180cSMike Christie sscanf(buf, "%d", &conn->ping_timeout); 2697f6d5180cSMike Christie break; 2698f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 2699f6d5180cSMike Christie sscanf(buf, "%d", &conn->recv_timeout); 2700f6d5180cSMike Christie break; 2701a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 2702a54a52caSMike Christie sscanf(buf, "%d", &conn->max_recv_dlength); 2703a54a52caSMike Christie break; 2704a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 2705a54a52caSMike Christie sscanf(buf, "%d", &conn->max_xmit_dlength); 2706a54a52caSMike Christie break; 2707a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 2708a54a52caSMike Christie sscanf(buf, "%d", &conn->hdrdgst_en); 2709a54a52caSMike Christie break; 2710a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 2711a54a52caSMike Christie sscanf(buf, "%d", &conn->datadgst_en); 2712a54a52caSMike Christie break; 2713a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 2714a54a52caSMike Christie sscanf(buf, "%d", &session->initial_r2t_en); 2715a54a52caSMike Christie break; 2716a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 2717a54a52caSMike Christie sscanf(buf, "%d", &session->max_r2t); 2718a54a52caSMike Christie break; 2719a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 2720a54a52caSMike Christie sscanf(buf, "%d", &session->imm_data_en); 2721a54a52caSMike Christie break; 2722a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 2723a54a52caSMike Christie sscanf(buf, "%d", &session->first_burst); 2724a54a52caSMike Christie break; 2725a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 2726a54a52caSMike Christie sscanf(buf, "%d", &session->max_burst); 2727a54a52caSMike Christie break; 2728a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 2729a54a52caSMike Christie sscanf(buf, "%d", &session->pdu_inorder_en); 2730a54a52caSMike Christie break; 2731a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 2732a54a52caSMike Christie sscanf(buf, "%d", &session->dataseq_inorder_en); 2733a54a52caSMike Christie break; 2734a54a52caSMike Christie case ISCSI_PARAM_ERL: 2735a54a52caSMike Christie sscanf(buf, "%d", &session->erl); 2736a54a52caSMike Christie break; 2737a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 2738a54a52caSMike Christie sscanf(buf, "%d", &value); 2739a54a52caSMike Christie BUG_ON(value); 2740a54a52caSMike Christie break; 2741a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 2742a54a52caSMike Christie sscanf(buf, "%d", &value); 2743a54a52caSMike Christie BUG_ON(value); 2744a54a52caSMike Christie break; 2745a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 2746a54a52caSMike Christie sscanf(buf, "%u", &conn->exp_statsn); 2747a54a52caSMike Christie break; 2748b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 27495700b1afSMike Christie return iscsi_switch_str_param(&session->username, buf); 2750b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 27515700b1afSMike Christie return iscsi_switch_str_param(&session->username_in, buf); 2752b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 27535700b1afSMike Christie return iscsi_switch_str_param(&session->password, buf); 2754b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 27555700b1afSMike Christie return iscsi_switch_str_param(&session->password_in, buf); 2756a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 27575700b1afSMike Christie return iscsi_switch_str_param(&session->targetname, buf); 2758a54a52caSMike Christie case ISCSI_PARAM_TPGT: 2759a54a52caSMike Christie sscanf(buf, "%d", &session->tpgt); 2760a54a52caSMike Christie break; 2761a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 2762a54a52caSMike Christie sscanf(buf, "%d", &conn->persistent_port); 2763a54a52caSMike Christie break; 2764a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 27655700b1afSMike Christie return iscsi_switch_str_param(&conn->persistent_address, buf); 276688dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 27675700b1afSMike Christie return iscsi_switch_str_param(&session->ifacename, buf); 276888dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 27695700b1afSMike Christie return iscsi_switch_str_param(&session->initiatorname, buf); 2770a54a52caSMike Christie default: 2771a54a52caSMike Christie return -ENOSYS; 2772a54a52caSMike Christie } 2773a54a52caSMike Christie 2774a54a52caSMike Christie return 0; 2775a54a52caSMike Christie } 2776a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_set_param); 2777a54a52caSMike Christie 2778a54a52caSMike Christie int iscsi_session_get_param(struct iscsi_cls_session *cls_session, 2779a54a52caSMike Christie enum iscsi_param param, char *buf) 2780a54a52caSMike Christie { 278175613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 2782a54a52caSMike Christie int len; 2783a54a52caSMike Christie 2784a54a52caSMike Christie switch(param) { 2785843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 2786843c0a8aSMike Christie len = sprintf(buf, "%d\n", session->fast_abort); 2787843c0a8aSMike Christie break; 2788f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 2789f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->abort_timeout); 2790f6d5180cSMike Christie break; 2791f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 2792f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->lu_reset_timeout); 2793f6d5180cSMike Christie break; 2794a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 2795a54a52caSMike Christie len = sprintf(buf, "%d\n", session->initial_r2t_en); 2796a54a52caSMike Christie break; 2797a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 2798a54a52caSMike Christie len = sprintf(buf, "%hu\n", session->max_r2t); 2799a54a52caSMike Christie break; 2800a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 2801a54a52caSMike Christie len = sprintf(buf, "%d\n", session->imm_data_en); 2802a54a52caSMike Christie break; 2803a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 2804a54a52caSMike Christie len = sprintf(buf, "%u\n", session->first_burst); 2805a54a52caSMike Christie break; 2806a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 2807a54a52caSMike Christie len = sprintf(buf, "%u\n", session->max_burst); 2808a54a52caSMike Christie break; 2809a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 2810a54a52caSMike Christie len = sprintf(buf, "%d\n", session->pdu_inorder_en); 2811a54a52caSMike Christie break; 2812a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 2813a54a52caSMike Christie len = sprintf(buf, "%d\n", session->dataseq_inorder_en); 2814a54a52caSMike Christie break; 2815a54a52caSMike Christie case ISCSI_PARAM_ERL: 2816a54a52caSMike Christie len = sprintf(buf, "%d\n", session->erl); 2817a54a52caSMike Christie break; 2818a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 2819a54a52caSMike Christie len = sprintf(buf, "%s\n", session->targetname); 2820a54a52caSMike Christie break; 2821a54a52caSMike Christie case ISCSI_PARAM_TPGT: 2822a54a52caSMike Christie len = sprintf(buf, "%d\n", session->tpgt); 2823a54a52caSMike Christie break; 2824b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 2825b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username); 2826b2c64167SMike Christie break; 2827b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 2828b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username_in); 2829b2c64167SMike Christie break; 2830b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 2831b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password); 2832b2c64167SMike Christie break; 2833b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 2834b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password_in); 2835b2c64167SMike Christie break; 283688dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 283788dfd340SMike Christie len = sprintf(buf, "%s\n", session->ifacename); 283888dfd340SMike Christie break; 283988dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 284088dfd340SMike Christie len = sprintf(buf, "%s\n", session->initiatorname); 284188dfd340SMike Christie break; 2842a54a52caSMike Christie default: 2843a54a52caSMike Christie return -ENOSYS; 2844a54a52caSMike Christie } 2845a54a52caSMike Christie 2846a54a52caSMike Christie return len; 2847a54a52caSMike Christie } 2848a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_get_param); 2849a54a52caSMike Christie 2850a54a52caSMike Christie int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, 2851a54a52caSMike Christie enum iscsi_param param, char *buf) 2852a54a52caSMike Christie { 2853a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 2854a54a52caSMike Christie int len; 2855a54a52caSMike Christie 2856a54a52caSMike Christie switch(param) { 2857f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 2858f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->ping_timeout); 2859f6d5180cSMike Christie break; 2860f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 2861f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->recv_timeout); 2862f6d5180cSMike Christie break; 2863a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 2864a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_recv_dlength); 2865a54a52caSMike Christie break; 2866a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 2867a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_xmit_dlength); 2868a54a52caSMike Christie break; 2869a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 2870a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->hdrdgst_en); 2871a54a52caSMike Christie break; 2872a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 2873a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->datadgst_en); 2874a54a52caSMike Christie break; 2875a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 2876a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ifmarker_en); 2877a54a52caSMike Christie break; 2878a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 2879a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ofmarker_en); 2880a54a52caSMike Christie break; 2881a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 2882a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->exp_statsn); 2883a54a52caSMike Christie break; 2884a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 2885a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->persistent_port); 2886a54a52caSMike Christie break; 2887a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 2888a54a52caSMike Christie len = sprintf(buf, "%s\n", conn->persistent_address); 2889a54a52caSMike Christie break; 2890a54a52caSMike Christie default: 2891a54a52caSMike Christie return -ENOSYS; 2892a54a52caSMike Christie } 2893a54a52caSMike Christie 2894a54a52caSMike Christie return len; 2895a54a52caSMike Christie } 2896a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_param); 2897a54a52caSMike Christie 28980801c242SMike Christie int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param, 28990801c242SMike Christie char *buf) 29000801c242SMike Christie { 290175613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 29020801c242SMike Christie int len; 29030801c242SMike Christie 29040801c242SMike Christie switch (param) { 2905d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 290675613521SMike Christie len = sprintf(buf, "%s\n", ihost->netdev); 2907d8196ed2SMike Christie break; 29080801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 290975613521SMike Christie len = sprintf(buf, "%s\n", ihost->hwaddress); 29100801c242SMike Christie break; 29118ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 291275613521SMike Christie len = sprintf(buf, "%s\n", ihost->initiatorname); 29138ad5781aSMike Christie break; 291475613521SMike Christie case ISCSI_HOST_PARAM_IPADDRESS: 29155700b1afSMike Christie len = sprintf(buf, "%s\n", ihost->local_address); 291688dfd340SMike Christie break; 29170801c242SMike Christie default: 29180801c242SMike Christie return -ENOSYS; 29190801c242SMike Christie } 29200801c242SMike Christie 29210801c242SMike Christie return len; 29220801c242SMike Christie } 29230801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_param); 29240801c242SMike Christie 29250801c242SMike Christie int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param, 29260801c242SMike Christie char *buf, int buflen) 29270801c242SMike Christie { 292875613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 29290801c242SMike Christie 29300801c242SMike Christie switch (param) { 2931d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 29325700b1afSMike Christie return iscsi_switch_str_param(&ihost->netdev, buf); 29330801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 29345700b1afSMike Christie return iscsi_switch_str_param(&ihost->hwaddress, buf); 29358ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 29365700b1afSMike Christie return iscsi_switch_str_param(&ihost->initiatorname, buf); 29370801c242SMike Christie default: 29380801c242SMike Christie return -ENOSYS; 29390801c242SMike Christie } 29400801c242SMike Christie 29410801c242SMike Christie return 0; 29420801c242SMike Christie } 29430801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_set_param); 29440801c242SMike Christie 29457996a778SMike Christie MODULE_AUTHOR("Mike Christie"); 29467996a778SMike Christie MODULE_DESCRIPTION("iSCSI library functions"); 29477996a778SMike Christie MODULE_LICENSE("GPL"); 2948