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 4177a23c21SMike Christie /* Serial Number Arithmetic, 32 bits, less than, RFC1982 */ 4277a23c21SMike Christie #define SNA32_CHECK 2147483648UL 437996a778SMike Christie 4477a23c21SMike Christie static int iscsi_sna_lt(u32 n1, u32 n2) 4577a23c21SMike Christie { 4677a23c21SMike Christie return n1 != n2 && ((n1 < n2 && (n2 - n1 < SNA32_CHECK)) || 4777a23c21SMike Christie (n1 > n2 && (n2 - n1 < SNA32_CHECK))); 4877a23c21SMike Christie } 4977a23c21SMike Christie 5077a23c21SMike Christie /* Serial Number Arithmetic, 32 bits, less than, RFC1982 */ 5177a23c21SMike Christie static int iscsi_sna_lte(u32 n1, u32 n2) 5277a23c21SMike Christie { 5377a23c21SMike Christie return n1 == n2 || ((n1 < n2 && (n2 - n1 < SNA32_CHECK)) || 5477a23c21SMike Christie (n1 > n2 && (n2 - n1 < SNA32_CHECK))); 5577a23c21SMike Christie } 5677a23c21SMike Christie 5777a23c21SMike Christie void 5877a23c21SMike Christie iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr) 597996a778SMike Christie { 607996a778SMike Christie uint32_t max_cmdsn = be32_to_cpu(hdr->max_cmdsn); 617996a778SMike Christie uint32_t exp_cmdsn = be32_to_cpu(hdr->exp_cmdsn); 627996a778SMike Christie 6377a23c21SMike Christie /* 6477a23c21SMike Christie * standard specifies this check for when to update expected and 6577a23c21SMike Christie * max sequence numbers 6677a23c21SMike Christie */ 6777a23c21SMike Christie if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1)) 6877a23c21SMike Christie return; 6977a23c21SMike Christie 7077a23c21SMike Christie if (exp_cmdsn != session->exp_cmdsn && 7177a23c21SMike Christie !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn)) 727996a778SMike Christie session->exp_cmdsn = exp_cmdsn; 737996a778SMike Christie 7477a23c21SMike Christie if (max_cmdsn != session->max_cmdsn && 7577a23c21SMike Christie !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) { 7677a23c21SMike Christie session->max_cmdsn = max_cmdsn; 7777a23c21SMike Christie /* 7877a23c21SMike Christie * if the window closed with IO queued, then kick the 7977a23c21SMike Christie * xmit thread 8077a23c21SMike Christie */ 8177a23c21SMike Christie if (!list_empty(&session->leadconn->xmitqueue) || 82052d0144SMike Christie !list_empty(&session->leadconn->mgmtqueue)) { 83052d0144SMike Christie if (!(session->tt->caps & CAP_DATA_PATH_OFFLOAD)) 8477a23c21SMike Christie scsi_queue_work(session->host, 8577a23c21SMike Christie &session->leadconn->xmitwork); 867996a778SMike Christie } 8777a23c21SMike Christie } 88052d0144SMike Christie } 8977a23c21SMike Christie EXPORT_SYMBOL_GPL(iscsi_update_cmdsn); 907996a778SMike Christie 91577577daSMike Christie /** 92577577daSMike Christie * iscsi_prep_data_out_pdu - initialize Data-Out 93577577daSMike Christie * @task: scsi command task 94577577daSMike Christie * @r2t: R2T info 95577577daSMike Christie * @hdr: iscsi data in pdu 96577577daSMike Christie * 97577577daSMike Christie * Notes: 98577577daSMike Christie * Initialize Data-Out within this R2T sequence and finds 99577577daSMike Christie * proper data_offset within this SCSI command. 100577577daSMike Christie * 101577577daSMike Christie * This function is called with connection lock taken. 102577577daSMike Christie **/ 103577577daSMike Christie void iscsi_prep_data_out_pdu(struct iscsi_task *task, struct iscsi_r2t_info *r2t, 104ffd0436eSMike Christie struct iscsi_data *hdr) 1057996a778SMike Christie { 1069c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 107577577daSMike Christie unsigned int left = r2t->data_length - r2t->sent; 108577577daSMike Christie 109577577daSMike Christie task->hdr_len = sizeof(struct iscsi_data); 1107996a778SMike Christie 1117996a778SMike Christie memset(hdr, 0, sizeof(struct iscsi_data)); 112577577daSMike Christie hdr->ttt = r2t->ttt; 113577577daSMike Christie hdr->datasn = cpu_to_be32(r2t->datasn); 114577577daSMike Christie r2t->datasn++; 1157996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_DATA_OUT; 116577577daSMike Christie memcpy(hdr->lun, task->lun, sizeof(hdr->lun)); 117577577daSMike Christie hdr->itt = task->hdr_itt; 118577577daSMike Christie hdr->exp_statsn = r2t->exp_statsn; 119577577daSMike Christie hdr->offset = cpu_to_be32(r2t->data_offset + r2t->sent); 120577577daSMike Christie if (left > conn->max_xmit_dlength) { 1217996a778SMike Christie hton24(hdr->dlength, conn->max_xmit_dlength); 122577577daSMike Christie r2t->data_count = conn->max_xmit_dlength; 1237996a778SMike Christie hdr->flags = 0; 1247996a778SMike Christie } else { 125577577daSMike Christie hton24(hdr->dlength, left); 126577577daSMike Christie r2t->data_count = left; 1277996a778SMike Christie hdr->flags = ISCSI_FLAG_CMD_FINAL; 1287996a778SMike Christie } 129577577daSMike Christie conn->dataout_pdus_cnt++; 1307996a778SMike Christie } 131577577daSMike Christie EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu); 1327996a778SMike Christie 1339c19a7d0SMike Christie static int iscsi_add_hdr(struct iscsi_task *task, unsigned len) 134004d6530SBoaz Harrosh { 1359c19a7d0SMike Christie unsigned exp_len = task->hdr_len + len; 136004d6530SBoaz Harrosh 1379c19a7d0SMike Christie if (exp_len > task->hdr_max) { 138004d6530SBoaz Harrosh WARN_ON(1); 139004d6530SBoaz Harrosh return -EINVAL; 140004d6530SBoaz Harrosh } 141004d6530SBoaz Harrosh 142004d6530SBoaz Harrosh WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */ 1439c19a7d0SMike Christie task->hdr_len = exp_len; 144004d6530SBoaz Harrosh return 0; 145004d6530SBoaz Harrosh } 146004d6530SBoaz Harrosh 14738d1c069SBoaz Harrosh /* 14838d1c069SBoaz Harrosh * make an extended cdb AHS 14938d1c069SBoaz Harrosh */ 1509c19a7d0SMike Christie static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) 15138d1c069SBoaz Harrosh { 1529c19a7d0SMike Christie struct scsi_cmnd *cmd = task->sc; 15338d1c069SBoaz Harrosh unsigned rlen, pad_len; 15438d1c069SBoaz Harrosh unsigned short ahslength; 15538d1c069SBoaz Harrosh struct iscsi_ecdb_ahdr *ecdb_ahdr; 15638d1c069SBoaz Harrosh int rc; 15738d1c069SBoaz Harrosh 1589c19a7d0SMike Christie ecdb_ahdr = iscsi_next_hdr(task); 15938d1c069SBoaz Harrosh rlen = cmd->cmd_len - ISCSI_CDB_SIZE; 16038d1c069SBoaz Harrosh 16138d1c069SBoaz Harrosh BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb)); 16238d1c069SBoaz Harrosh ahslength = rlen + sizeof(ecdb_ahdr->reserved); 16338d1c069SBoaz Harrosh 16438d1c069SBoaz Harrosh pad_len = iscsi_padding(rlen); 16538d1c069SBoaz Harrosh 1669c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) + 16738d1c069SBoaz Harrosh sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len); 16838d1c069SBoaz Harrosh if (rc) 16938d1c069SBoaz Harrosh return rc; 17038d1c069SBoaz Harrosh 17138d1c069SBoaz Harrosh if (pad_len) 17238d1c069SBoaz Harrosh memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len); 17338d1c069SBoaz Harrosh 17438d1c069SBoaz Harrosh ecdb_ahdr->ahslength = cpu_to_be16(ahslength); 17538d1c069SBoaz Harrosh ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB; 17638d1c069SBoaz Harrosh ecdb_ahdr->reserved = 0; 17738d1c069SBoaz Harrosh memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen); 17838d1c069SBoaz Harrosh 17938d1c069SBoaz Harrosh debug_scsi("iscsi_prep_ecdb_ahs: varlen_cdb_len %d " 18038d1c069SBoaz Harrosh "rlen %d pad_len %d ahs_length %d iscsi_headers_size %u\n", 1819c19a7d0SMike Christie cmd->cmd_len, rlen, pad_len, ahslength, task->hdr_len); 18238d1c069SBoaz Harrosh 18338d1c069SBoaz Harrosh return 0; 18438d1c069SBoaz Harrosh } 18538d1c069SBoaz Harrosh 1869c19a7d0SMike Christie static int iscsi_prep_bidi_ahs(struct iscsi_task *task) 187c07d4444SBoaz Harrosh { 1889c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 189c07d4444SBoaz Harrosh struct iscsi_rlength_ahdr *rlen_ahdr; 190c07d4444SBoaz Harrosh int rc; 191c07d4444SBoaz Harrosh 1929c19a7d0SMike Christie rlen_ahdr = iscsi_next_hdr(task); 1939c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*rlen_ahdr)); 194c07d4444SBoaz Harrosh if (rc) 195c07d4444SBoaz Harrosh return rc; 196c07d4444SBoaz Harrosh 197c07d4444SBoaz Harrosh rlen_ahdr->ahslength = 198c07d4444SBoaz Harrosh cpu_to_be16(sizeof(rlen_ahdr->read_length) + 199c07d4444SBoaz Harrosh sizeof(rlen_ahdr->reserved)); 200c07d4444SBoaz Harrosh rlen_ahdr->ahstype = ISCSI_AHSTYPE_RLENGTH; 201c07d4444SBoaz Harrosh rlen_ahdr->reserved = 0; 202c07d4444SBoaz Harrosh rlen_ahdr->read_length = cpu_to_be32(scsi_in(sc)->length); 203c07d4444SBoaz Harrosh 204c07d4444SBoaz Harrosh debug_scsi("bidi-in rlen_ahdr->read_length(%d) " 205c07d4444SBoaz Harrosh "rlen_ahdr->ahslength(%d)\n", 206c07d4444SBoaz Harrosh be32_to_cpu(rlen_ahdr->read_length), 207c07d4444SBoaz Harrosh be16_to_cpu(rlen_ahdr->ahslength)); 208c07d4444SBoaz Harrosh return 0; 209c07d4444SBoaz Harrosh } 210c07d4444SBoaz Harrosh 2117996a778SMike Christie /** 2127996a778SMike Christie * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu 2139c19a7d0SMike Christie * @task: iscsi task 2147996a778SMike Christie * 2157996a778SMike Christie * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set 2167996a778SMike Christie * fields like dlength or final based on how much data it sends 2177996a778SMike Christie */ 2189c19a7d0SMike Christie static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task) 2197996a778SMike Christie { 2209c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 2217996a778SMike Christie struct iscsi_session *session = conn->session; 2229c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 223577577daSMike Christie struct iscsi_cmd *hdr; 22438d1c069SBoaz Harrosh unsigned hdrlength, cmd_len; 225004d6530SBoaz Harrosh int rc; 2267996a778SMike Christie 227577577daSMike Christie rc = conn->session->tt->alloc_pdu(task); 228577577daSMike Christie if (rc) 229577577daSMike Christie return rc; 230577577daSMike Christie hdr = (struct iscsi_cmd *) task->hdr; 231577577daSMike Christie memset(hdr, 0, sizeof(*hdr)); 232577577daSMike Christie 2339c19a7d0SMike Christie task->hdr_len = 0; 2349c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*hdr)); 235004d6530SBoaz Harrosh if (rc) 236004d6530SBoaz Harrosh return rc; 2377996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_CMD; 2387996a778SMike Christie hdr->flags = ISCSI_ATTR_SIMPLE; 2397996a778SMike Christie int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun); 240577577daSMike Christie memcpy(task->lun, hdr->lun, sizeof(task->lun)); 241577577daSMike Christie hdr->itt = task->hdr_itt = build_itt(task->itt, session->age); 242577577daSMike Christie hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn); 2437996a778SMike Christie session->cmdsn++; 2447996a778SMike Christie hdr->exp_statsn = cpu_to_be32(conn->exp_statsn); 24538d1c069SBoaz Harrosh cmd_len = sc->cmd_len; 24638d1c069SBoaz Harrosh if (cmd_len < ISCSI_CDB_SIZE) 24738d1c069SBoaz Harrosh memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len); 24838d1c069SBoaz Harrosh else if (cmd_len > ISCSI_CDB_SIZE) { 2499c19a7d0SMike Christie rc = iscsi_prep_ecdb_ahs(task); 25038d1c069SBoaz Harrosh if (rc) 25138d1c069SBoaz Harrosh return rc; 25238d1c069SBoaz Harrosh cmd_len = ISCSI_CDB_SIZE; 25338d1c069SBoaz Harrosh } 25438d1c069SBoaz Harrosh memcpy(hdr->cdb, sc->cmnd, cmd_len); 2557996a778SMike Christie 2569c19a7d0SMike Christie task->imm_count = 0; 257c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc)) { 258c07d4444SBoaz Harrosh hdr->flags |= ISCSI_FLAG_CMD_READ; 2599c19a7d0SMike Christie rc = iscsi_prep_bidi_ahs(task); 260c07d4444SBoaz Harrosh if (rc) 261c07d4444SBoaz Harrosh return rc; 262c07d4444SBoaz Harrosh } 2637996a778SMike Christie if (sc->sc_data_direction == DMA_TO_DEVICE) { 264c07d4444SBoaz Harrosh unsigned out_len = scsi_out(sc)->length; 265577577daSMike Christie struct iscsi_r2t_info *r2t = &task->unsol_r2t; 266577577daSMike Christie 267c07d4444SBoaz Harrosh hdr->data_length = cpu_to_be32(out_len); 2687996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_WRITE; 2697996a778SMike Christie /* 2707996a778SMike Christie * Write counters: 2717996a778SMike Christie * 2727996a778SMike Christie * imm_count bytes to be sent right after 2737996a778SMike Christie * SCSI PDU Header 2747996a778SMike Christie * 2757996a778SMike Christie * unsol_count bytes(as Data-Out) to be sent 2767996a778SMike Christie * without R2T ack right after 2777996a778SMike Christie * immediate data 2787996a778SMike Christie * 279577577daSMike Christie * r2t data_length bytes to be sent via R2T ack's 2807996a778SMike Christie * 2817996a778SMike Christie * pad_count bytes to be sent as zero-padding 2827996a778SMike Christie */ 283577577daSMike Christie memset(r2t, 0, sizeof(*r2t)); 2847996a778SMike Christie 2857996a778SMike Christie if (session->imm_data_en) { 286c07d4444SBoaz Harrosh if (out_len >= session->first_burst) 2879c19a7d0SMike Christie task->imm_count = min(session->first_burst, 2887996a778SMike Christie conn->max_xmit_dlength); 2897996a778SMike Christie else 2909c19a7d0SMike Christie task->imm_count = min(out_len, 2917996a778SMike Christie conn->max_xmit_dlength); 2929c19a7d0SMike Christie hton24(hdr->dlength, task->imm_count); 2937996a778SMike Christie } else 294a8ac6311SOlaf Kirch zero_data(hdr->dlength); 2957996a778SMike Christie 296ffd0436eSMike Christie if (!session->initial_r2t_en) { 297577577daSMike Christie r2t->data_length = min(session->first_burst, out_len) - 298577577daSMike Christie task->imm_count; 299577577daSMike Christie r2t->data_offset = task->imm_count; 300577577daSMike Christie r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG); 301577577daSMike Christie r2t->exp_statsn = cpu_to_be32(conn->exp_statsn); 302ffd0436eSMike Christie } 303ffd0436eSMike Christie 304577577daSMike Christie if (!task->unsol_r2t.data_length) 3057996a778SMike Christie /* No unsolicit Data-Out's */ 306a8ac6311SOlaf Kirch hdr->flags |= ISCSI_FLAG_CMD_FINAL; 3077996a778SMike Christie } else { 3087996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 3097996a778SMike Christie zero_data(hdr->dlength); 310c07d4444SBoaz Harrosh hdr->data_length = cpu_to_be32(scsi_in(sc)->length); 3117996a778SMike Christie 3127996a778SMike Christie if (sc->sc_data_direction == DMA_FROM_DEVICE) 3137996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_READ; 3147996a778SMike Christie } 3157996a778SMike Christie 316004d6530SBoaz Harrosh /* calculate size of additional header segments (AHSs) */ 3179c19a7d0SMike Christie hdrlength = task->hdr_len - sizeof(*hdr); 318004d6530SBoaz Harrosh 319004d6530SBoaz Harrosh WARN_ON(hdrlength & (ISCSI_PAD_LEN-1)); 320004d6530SBoaz Harrosh hdrlength /= ISCSI_PAD_LEN; 321004d6530SBoaz Harrosh 322004d6530SBoaz Harrosh WARN_ON(hdrlength >= 256); 323004d6530SBoaz Harrosh hdr->hlength = hdrlength & 0xFF; 324004d6530SBoaz Harrosh 325577577daSMike Christie if (session->tt->init_task && session->tt->init_task(task)) 326052d0144SMike Christie return -EIO; 327052d0144SMike Christie 3289c19a7d0SMike Christie task->state = ISCSI_TASK_RUNNING; 3299c19a7d0SMike Christie list_move_tail(&task->running, &conn->run_list); 33077a23c21SMike Christie 331a8ac6311SOlaf Kirch conn->scsicmd_pdus_cnt++; 3323e5c28adSMike Christie debug_scsi("iscsi prep [%s cid %d sc %p cdb 0x%x itt 0x%x len %d " 3333e5c28adSMike Christie "bidi_len %d cmdsn %d win %d]\n", scsi_bidi_cmnd(sc) ? 3343e5c28adSMike Christie "bidirectional" : sc->sc_data_direction == DMA_TO_DEVICE ? 3359c19a7d0SMike Christie "write" : "read", conn->id, sc, sc->cmnd[0], task->itt, 3363e5c28adSMike Christie scsi_bufflen(sc), 3373e5c28adSMike Christie scsi_bidi_cmnd(sc) ? scsi_in(sc)->length : 0, 33877a23c21SMike Christie session->cmdsn, session->max_cmdsn - session->exp_cmdsn + 1); 339004d6530SBoaz Harrosh return 0; 3407996a778SMike Christie } 3417996a778SMike Christie 3427996a778SMike Christie /** 3433e5c28adSMike Christie * iscsi_complete_command - finish a task 3449c19a7d0SMike Christie * @task: iscsi cmd task 3457996a778SMike Christie * 3467996a778SMike Christie * Must be called with session lock. 3473e5c28adSMike Christie * This function returns the scsi command to scsi-ml or cleans 3483e5c28adSMike Christie * up mgmt tasks then returns the task to the pool. 3497996a778SMike Christie */ 3509c19a7d0SMike Christie static void iscsi_complete_command(struct iscsi_task *task) 3517996a778SMike Christie { 3529c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 353c1635cb7SMike Christie struct iscsi_session *session = conn->session; 3549c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 3557996a778SMike Christie 356577577daSMike Christie session->tt->cleanup_task(task); 3579c19a7d0SMike Christie list_del_init(&task->running); 3589c19a7d0SMike Christie task->state = ISCSI_TASK_COMPLETED; 3599c19a7d0SMike Christie task->sc = NULL; 3603e5c28adSMike Christie 3619c19a7d0SMike Christie if (conn->task == task) 3629c19a7d0SMike Christie conn->task = NULL; 3633e5c28adSMike Christie /* 3649c19a7d0SMike Christie * login task is preallocated so do not free 3653e5c28adSMike Christie */ 3669c19a7d0SMike Christie if (conn->login_task == task) 3673e5c28adSMike Christie return; 3683e5c28adSMike Christie 3699c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&task, sizeof(void*)); 3703e5c28adSMike Christie 3719c19a7d0SMike Christie if (conn->ping_task == task) 3729c19a7d0SMike Christie conn->ping_task = NULL; 3733e5c28adSMike Christie 3743e5c28adSMike Christie if (sc) { 3759c19a7d0SMike Christie task->sc = NULL; 376f47f2cf5SMike Christie /* SCSI eh reuses commands to verify us */ 377f47f2cf5SMike Christie sc->SCp.ptr = NULL; 3783e5c28adSMike Christie /* 3793e5c28adSMike Christie * queue command may call this to free the task, but 3803e5c28adSMike Christie * not have setup the sc callback 3813e5c28adSMike Christie */ 382052d0144SMike Christie if (sc->scsi_done) 3837996a778SMike Christie sc->scsi_done(sc); 3847996a778SMike Christie } 3853e5c28adSMike Christie } 3867996a778SMike Christie 387913e5bf4SMike Christie void __iscsi_get_task(struct iscsi_task *task) 38860ecebf5SMike Christie { 3899c19a7d0SMike Christie atomic_inc(&task->refcount); 39060ecebf5SMike Christie } 391913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_get_task); 39260ecebf5SMike Christie 3939c19a7d0SMike Christie static void __iscsi_put_task(struct iscsi_task *task) 39460ecebf5SMike Christie { 3959c19a7d0SMike Christie if (atomic_dec_and_test(&task->refcount)) 3969c19a7d0SMike Christie iscsi_complete_command(task); 39760ecebf5SMike Christie } 39860ecebf5SMike Christie 3999c19a7d0SMike Christie void iscsi_put_task(struct iscsi_task *task) 4003e5c28adSMike Christie { 4019c19a7d0SMike Christie struct iscsi_session *session = task->conn->session; 4023e5c28adSMike Christie 4033e5c28adSMike Christie spin_lock_bh(&session->lock); 4049c19a7d0SMike Christie __iscsi_put_task(task); 4053e5c28adSMike Christie spin_unlock_bh(&session->lock); 4063e5c28adSMike Christie } 4079c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_put_task); 4083e5c28adSMike Christie 409b3a7ea8dSMike Christie /* 410b3a7ea8dSMike Christie * session lock must be held 411b3a7ea8dSMike Christie */ 4129c19a7d0SMike Christie static void fail_command(struct iscsi_conn *conn, struct iscsi_task *task, 413b3a7ea8dSMike Christie int err) 414b3a7ea8dSMike Christie { 415b3a7ea8dSMike Christie struct scsi_cmnd *sc; 416b3a7ea8dSMike Christie 4179c19a7d0SMike Christie sc = task->sc; 418b3a7ea8dSMike Christie if (!sc) 419b3a7ea8dSMike Christie return; 420b3a7ea8dSMike Christie 4219c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) 422b3a7ea8dSMike Christie /* 423b3a7ea8dSMike Christie * cmd never made it to the xmit thread, so we should not count 424b3a7ea8dSMike Christie * the cmd in the sequencing 425b3a7ea8dSMike Christie */ 426b3a7ea8dSMike Christie conn->session->queued_cmdsn--; 427b3a7ea8dSMike Christie 428b3a7ea8dSMike Christie sc->result = err; 429c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 430b3a7ea8dSMike Christie scsi_set_resid(sc, scsi_bufflen(sc)); 431c07d4444SBoaz Harrosh else { 432c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 433c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 434c07d4444SBoaz Harrosh } 4353e5c28adSMike Christie 4369c19a7d0SMike Christie if (conn->task == task) 4379c19a7d0SMike Christie conn->task = NULL; 438b3a7ea8dSMike Christie /* release ref from queuecommand */ 4399c19a7d0SMike Christie __iscsi_put_task(task); 440b3a7ea8dSMike Christie } 441b3a7ea8dSMike Christie 4423e5c28adSMike Christie static int iscsi_prep_mgmt_task(struct iscsi_conn *conn, 4439c19a7d0SMike Christie struct iscsi_task *task) 444052d0144SMike Christie { 445052d0144SMike Christie struct iscsi_session *session = conn->session; 446577577daSMike Christie struct iscsi_hdr *hdr = task->hdr; 447052d0144SMike Christie struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr; 448052d0144SMike Christie 449052d0144SMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 450052d0144SMike Christie return -ENOTCONN; 451052d0144SMike Christie 452052d0144SMike Christie if (hdr->opcode != (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) && 453052d0144SMike Christie hdr->opcode != (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE)) 454052d0144SMike Christie nop->exp_statsn = cpu_to_be32(conn->exp_statsn); 455052d0144SMike Christie /* 456052d0144SMike Christie * pre-format CmdSN for outgoing PDU. 457052d0144SMike Christie */ 458052d0144SMike Christie nop->cmdsn = cpu_to_be32(session->cmdsn); 459052d0144SMike Christie if (hdr->itt != RESERVED_ITT) { 4609c19a7d0SMike Christie hdr->itt = build_itt(task->itt, session->age); 461052d0144SMike Christie /* 462052d0144SMike Christie * TODO: We always use immediate, so we never hit this. 463052d0144SMike Christie * If we start to send tmfs or nops as non-immediate then 464052d0144SMike Christie * we should start checking the cmdsn numbers for mgmt tasks. 465052d0144SMike Christie */ 466052d0144SMike Christie if (conn->c_stage == ISCSI_CONN_STARTED && 467052d0144SMike Christie !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 468052d0144SMike Christie session->queued_cmdsn++; 469052d0144SMike Christie session->cmdsn++; 470052d0144SMike Christie } 471052d0144SMike Christie } 472052d0144SMike Christie 4733e5c28adSMike Christie if (session->tt->init_task) 4749c19a7d0SMike Christie session->tt->init_task(task); 475052d0144SMike Christie 476052d0144SMike Christie if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT) 477052d0144SMike Christie session->state = ISCSI_STATE_LOGGING_OUT; 478052d0144SMike Christie 479577577daSMike Christie task->state = ISCSI_TASK_RUNNING; 4809c19a7d0SMike Christie list_move_tail(&task->running, &conn->mgmt_run_list); 481052d0144SMike Christie debug_scsi("mgmtpdu [op 0x%x hdr->itt 0x%x datalen %d]\n", 482052d0144SMike Christie hdr->opcode & ISCSI_OPCODE_MASK, hdr->itt, 4839c19a7d0SMike Christie task->data_count); 484052d0144SMike Christie return 0; 485052d0144SMike Christie } 486052d0144SMike Christie 4879c19a7d0SMike Christie static struct iscsi_task * 488f6d5180cSMike Christie __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 489f6d5180cSMike Christie char *data, uint32_t data_size) 490f6d5180cSMike Christie { 491f6d5180cSMike Christie struct iscsi_session *session = conn->session; 4929c19a7d0SMike Christie struct iscsi_task *task; 493f6d5180cSMike Christie 494f6d5180cSMike Christie if (session->state == ISCSI_STATE_TERMINATE) 495f6d5180cSMike Christie return NULL; 496f6d5180cSMike Christie 497f6d5180cSMike Christie if (hdr->opcode == (ISCSI_OP_LOGIN | ISCSI_OP_IMMEDIATE) || 498f6d5180cSMike Christie hdr->opcode == (ISCSI_OP_TEXT | ISCSI_OP_IMMEDIATE)) 499f6d5180cSMike Christie /* 500f6d5180cSMike Christie * Login and Text are sent serially, in 501f6d5180cSMike Christie * request-followed-by-response sequence. 5023e5c28adSMike Christie * Same task can be used. Same ITT must be used. 5033e5c28adSMike Christie * Note that login_task is preallocated at conn_create(). 504f6d5180cSMike Christie */ 5059c19a7d0SMike Christie task = conn->login_task; 506f6d5180cSMike Christie else { 507f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE); 508f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED); 509f6d5180cSMike Christie 5103e5c28adSMike Christie if (!__kfifo_get(session->cmdpool.queue, 5119c19a7d0SMike Christie (void*)&task, sizeof(void*))) 512f6d5180cSMike Christie return NULL; 513f6d5180cSMike Christie } 5143e5c28adSMike Christie /* 5153e5c28adSMike Christie * released in complete pdu for task we expect a response for, and 5163e5c28adSMike Christie * released by the lld when it has transmitted the task for 5173e5c28adSMike Christie * pdus we do not expect a response for. 5183e5c28adSMike Christie */ 5199c19a7d0SMike Christie atomic_set(&task->refcount, 1); 5209c19a7d0SMike Christie task->conn = conn; 5219c19a7d0SMike Christie task->sc = NULL; 522f6d5180cSMike Christie 523f6d5180cSMike Christie if (data_size) { 5249c19a7d0SMike Christie memcpy(task->data, data, data_size); 5259c19a7d0SMike Christie task->data_count = data_size; 526f6d5180cSMike Christie } else 5279c19a7d0SMike Christie task->data_count = 0; 528f6d5180cSMike Christie 529577577daSMike Christie if (conn->session->tt->alloc_pdu(task)) { 530577577daSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not allocate " 531577577daSMike Christie "pdu for mgmt task.\n"); 532577577daSMike Christie goto requeue_task; 533577577daSMike Christie } 534577577daSMike Christie task->hdr_len = sizeof(struct iscsi_hdr); 535577577daSMike Christie 5369c19a7d0SMike Christie memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr)); 5379c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 5389c19a7d0SMike Christie list_add_tail(&task->running, &conn->mgmtqueue); 539052d0144SMike Christie 540052d0144SMike Christie if (session->tt->caps & CAP_DATA_PATH_OFFLOAD) { 541577577daSMike Christie if (iscsi_prep_mgmt_task(conn, task)) 542577577daSMike Christie goto free_task; 543052d0144SMike Christie 5449c19a7d0SMike Christie if (session->tt->xmit_task(task)) 545577577daSMike Christie goto free_task; 546052d0144SMike Christie 547052d0144SMike Christie } else 548052d0144SMike Christie scsi_queue_work(conn->session->host, &conn->xmitwork); 549052d0144SMike Christie 5509c19a7d0SMike Christie return task; 551577577daSMike Christie 552577577daSMike Christie free_task: 553577577daSMike Christie __iscsi_put_task(task); 554577577daSMike Christie return NULL; 555577577daSMike Christie 556577577daSMike Christie requeue_task: 557577577daSMike Christie if (task != conn->login_task) 558577577daSMike Christie __kfifo_put(session->cmdpool.queue, (void*)&task, 559577577daSMike Christie sizeof(void*)); 560577577daSMike Christie return NULL; 561f6d5180cSMike Christie } 562f6d5180cSMike Christie 563f6d5180cSMike Christie int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr, 564f6d5180cSMike Christie char *data, uint32_t data_size) 565f6d5180cSMike Christie { 566f6d5180cSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 567f6d5180cSMike Christie struct iscsi_session *session = conn->session; 568f6d5180cSMike Christie int err = 0; 569f6d5180cSMike Christie 570f6d5180cSMike Christie spin_lock_bh(&session->lock); 571f6d5180cSMike Christie if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size)) 572f6d5180cSMike Christie err = -EPERM; 573f6d5180cSMike Christie spin_unlock_bh(&session->lock); 574f6d5180cSMike Christie return err; 575f6d5180cSMike Christie } 576f6d5180cSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu); 577f6d5180cSMike Christie 5787996a778SMike Christie /** 5797996a778SMike Christie * iscsi_cmd_rsp - SCSI Command Response processing 5807996a778SMike Christie * @conn: iscsi connection 5817996a778SMike Christie * @hdr: iscsi header 5829c19a7d0SMike Christie * @task: scsi command task 5837996a778SMike Christie * @data: cmd data buffer 5847996a778SMike Christie * @datalen: len of buffer 5857996a778SMike Christie * 5867996a778SMike Christie * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and 5879c19a7d0SMike Christie * then completes the command and task. 5887996a778SMike Christie **/ 58977a23c21SMike Christie static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 5909c19a7d0SMike Christie struct iscsi_task *task, char *data, 5917996a778SMike Christie int datalen) 5927996a778SMike Christie { 5937996a778SMike Christie struct iscsi_cmd_rsp *rhdr = (struct iscsi_cmd_rsp *)hdr; 5947996a778SMike Christie struct iscsi_session *session = conn->session; 5959c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 5967996a778SMike Christie 59777a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr); 5987996a778SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 5997996a778SMike Christie 6007996a778SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 6017996a778SMike Christie 6027996a778SMike Christie if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) { 6037996a778SMike Christie sc->result = DID_ERROR << 16; 6047996a778SMike Christie goto out; 6057996a778SMike Christie } 6067996a778SMike Christie 6077996a778SMike Christie if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) { 6089b80cb4bSMike Christie uint16_t senselen; 6097996a778SMike Christie 6107996a778SMike Christie if (datalen < 2) { 6117996a778SMike Christie invalid_datalen: 612322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 613322d739dSMike Christie "Got CHECK_CONDITION but invalid data " 614322d739dSMike Christie "buffer size of %d\n", datalen); 6157996a778SMike Christie sc->result = DID_BAD_TARGET << 16; 6167996a778SMike Christie goto out; 6177996a778SMike Christie } 6187996a778SMike Christie 6198f333991SHarvey Harrison senselen = get_unaligned_be16(data); 6207996a778SMike Christie if (datalen < senselen) 6217996a778SMike Christie goto invalid_datalen; 6227996a778SMike Christie 6237996a778SMike Christie memcpy(sc->sense_buffer, data + 2, 6249b80cb4bSMike Christie min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 6257996a778SMike Christie debug_scsi("copied %d bytes of sense\n", 6268eb00539SMike Christie min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 6277996a778SMike Christie } 6287996a778SMike Christie 629c07d4444SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW | 630c07d4444SBoaz Harrosh ISCSI_FLAG_CMD_BIDI_OVERFLOW)) { 631c07d4444SBoaz Harrosh int res_count = be32_to_cpu(rhdr->bi_residual_count); 632c07d4444SBoaz Harrosh 633c07d4444SBoaz Harrosh if (scsi_bidi_cmnd(sc) && res_count > 0 && 634c07d4444SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_BIDI_OVERFLOW || 635c07d4444SBoaz Harrosh res_count <= scsi_in(sc)->length)) 636c07d4444SBoaz Harrosh scsi_in(sc)->resid = res_count; 637c07d4444SBoaz Harrosh else 638c07d4444SBoaz Harrosh sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 639c07d4444SBoaz Harrosh } 640c07d4444SBoaz Harrosh 6417207fea4SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW | 6427207fea4SBoaz Harrosh ISCSI_FLAG_CMD_OVERFLOW)) { 6437996a778SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 6447996a778SMike Christie 6457207fea4SBoaz Harrosh if (res_count > 0 && 6467207fea4SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 6477207fea4SBoaz Harrosh res_count <= scsi_bufflen(sc))) 648c07d4444SBoaz Harrosh /* write side for bidi or uni-io set_resid */ 6491c138991SFUJITA Tomonori scsi_set_resid(sc, res_count); 6507996a778SMike Christie else 6517996a778SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 652c07d4444SBoaz Harrosh } 6537996a778SMike Christie out: 6547996a778SMike Christie debug_scsi("done [sc %lx res %d itt 0x%x]\n", 6559c19a7d0SMike Christie (long)sc, sc->result, task->itt); 6567996a778SMike Christie conn->scsirsp_pdus_cnt++; 6577996a778SMike Christie 6589c19a7d0SMike Christie __iscsi_put_task(task); 6597996a778SMike Christie } 6607996a778SMike Christie 6611d9edf02SMike Christie /** 6621d9edf02SMike Christie * iscsi_data_in_rsp - SCSI Data-In Response processing 6631d9edf02SMike Christie * @conn: iscsi connection 6641d9edf02SMike Christie * @hdr: iscsi pdu 6651d9edf02SMike Christie * @task: scsi command task 6661d9edf02SMike Christie **/ 6671d9edf02SMike Christie static void 6681d9edf02SMike Christie iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 6691d9edf02SMike Christie struct iscsi_task *task) 6701d9edf02SMike Christie { 6711d9edf02SMike Christie struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr; 6721d9edf02SMike Christie struct scsi_cmnd *sc = task->sc; 6731d9edf02SMike Christie 6741d9edf02SMike Christie if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS)) 6751d9edf02SMike Christie return; 6761d9edf02SMike Christie 6771d9edf02SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 6781d9edf02SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 6791d9edf02SMike Christie if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW | 6801d9edf02SMike Christie ISCSI_FLAG_DATA_OVERFLOW)) { 6811d9edf02SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 6821d9edf02SMike Christie 6831d9edf02SMike Christie if (res_count > 0 && 6841d9edf02SMike Christie (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 6851d9edf02SMike Christie res_count <= scsi_in(sc)->length)) 6861d9edf02SMike Christie scsi_in(sc)->resid = res_count; 6871d9edf02SMike Christie else 6881d9edf02SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 6891d9edf02SMike Christie } 6901d9edf02SMike Christie 6911d9edf02SMike Christie conn->scsirsp_pdus_cnt++; 6921d9edf02SMike Christie __iscsi_put_task(task); 6931d9edf02SMike Christie } 6941d9edf02SMike Christie 6957ea8b828SMike Christie static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) 6967ea8b828SMike Christie { 6977ea8b828SMike Christie struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; 6987ea8b828SMike Christie 6997ea8b828SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 7007ea8b828SMike Christie conn->tmfrsp_pdus_cnt++; 7017ea8b828SMike Christie 702843c0a8aSMike Christie if (conn->tmf_state != TMF_QUEUED) 7037ea8b828SMike Christie return; 7047ea8b828SMike Christie 7057ea8b828SMike Christie if (tmf->response == ISCSI_TMF_RSP_COMPLETE) 706843c0a8aSMike Christie conn->tmf_state = TMF_SUCCESS; 7077ea8b828SMike Christie else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) 708843c0a8aSMike Christie conn->tmf_state = TMF_NOT_FOUND; 7097ea8b828SMike Christie else 710843c0a8aSMike Christie conn->tmf_state = TMF_FAILED; 7117ea8b828SMike Christie wake_up(&conn->ehwait); 7127ea8b828SMike Christie } 7137ea8b828SMike Christie 714f6d5180cSMike Christie static void iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) 715f6d5180cSMike Christie { 716f6d5180cSMike Christie struct iscsi_nopout hdr; 7179c19a7d0SMike Christie struct iscsi_task *task; 718f6d5180cSMike Christie 7199c19a7d0SMike Christie if (!rhdr && conn->ping_task) 720f6d5180cSMike Christie return; 721f6d5180cSMike Christie 722f6d5180cSMike Christie memset(&hdr, 0, sizeof(struct iscsi_nopout)); 723f6d5180cSMike Christie hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE; 724f6d5180cSMike Christie hdr.flags = ISCSI_FLAG_CMD_FINAL; 725f6d5180cSMike Christie 726f6d5180cSMike Christie if (rhdr) { 727f6d5180cSMike Christie memcpy(hdr.lun, rhdr->lun, 8); 728f6d5180cSMike Christie hdr.ttt = rhdr->ttt; 729f6d5180cSMike Christie hdr.itt = RESERVED_ITT; 730f6d5180cSMike Christie } else 731f6d5180cSMike Christie hdr.ttt = RESERVED_ITT; 732f6d5180cSMike Christie 7339c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0); 7349c19a7d0SMike Christie if (!task) 735322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n"); 736d3acf022SMike Christie else if (!rhdr) { 737d3acf022SMike Christie /* only track our nops */ 738d3acf022SMike Christie conn->ping_task = task; 739d3acf022SMike Christie conn->last_ping = jiffies; 740d3acf022SMike Christie } 741f6d5180cSMike Christie } 742f6d5180cSMike Christie 74362f38300SMike Christie static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 74462f38300SMike Christie char *data, int datalen) 74562f38300SMike Christie { 74662f38300SMike Christie struct iscsi_reject *reject = (struct iscsi_reject *)hdr; 74762f38300SMike Christie struct iscsi_hdr rejected_pdu; 74862f38300SMike Christie uint32_t itt; 74962f38300SMike Christie 75062f38300SMike Christie conn->exp_statsn = be32_to_cpu(reject->statsn) + 1; 75162f38300SMike Christie 75262f38300SMike Christie if (reject->reason == ISCSI_REASON_DATA_DIGEST_ERROR) { 75362f38300SMike Christie if (ntoh24(reject->dlength) > datalen) 75462f38300SMike Christie return ISCSI_ERR_PROTO; 75562f38300SMike Christie 75662f38300SMike Christie if (ntoh24(reject->dlength) >= sizeof(struct iscsi_hdr)) { 75762f38300SMike Christie memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr)); 758b4377356SAl Viro itt = get_itt(rejected_pdu.itt); 759322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 760322d739dSMike Christie "itt 0x%x had pdu (op 0x%x) rejected " 76162f38300SMike Christie "due to DataDigest error.\n", itt, 76262f38300SMike Christie rejected_pdu.opcode); 76362f38300SMike Christie } 76462f38300SMike Christie } 76562f38300SMike Christie return 0; 76662f38300SMike Christie } 76762f38300SMike Christie 7687996a778SMike Christie /** 769913e5bf4SMike Christie * iscsi_itt_to_task - look up task by itt 770913e5bf4SMike Christie * @conn: iscsi connection 771913e5bf4SMike Christie * @itt: itt 772913e5bf4SMike Christie * 773913e5bf4SMike Christie * This should be used for mgmt tasks like login and nops, or if 774913e5bf4SMike Christie * the LDD's itt space does not include the session age. 775913e5bf4SMike Christie * 776913e5bf4SMike Christie * The session lock must be held. 777913e5bf4SMike Christie */ 778913e5bf4SMike Christie static struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt) 779913e5bf4SMike Christie { 780913e5bf4SMike Christie struct iscsi_session *session = conn->session; 781913e5bf4SMike Christie uint32_t i; 782913e5bf4SMike Christie 783913e5bf4SMike Christie if (itt == RESERVED_ITT) 784913e5bf4SMike Christie return NULL; 785913e5bf4SMike Christie 786913e5bf4SMike Christie i = get_itt(itt); 787913e5bf4SMike Christie if (i >= session->cmds_max) 788913e5bf4SMike Christie return NULL; 789913e5bf4SMike Christie 790913e5bf4SMike Christie return session->cmds[i]; 791913e5bf4SMike Christie } 792913e5bf4SMike Christie 793913e5bf4SMike Christie /** 7947996a778SMike Christie * __iscsi_complete_pdu - complete pdu 7957996a778SMike Christie * @conn: iscsi conn 7967996a778SMike Christie * @hdr: iscsi header 7977996a778SMike Christie * @data: data buffer 7987996a778SMike Christie * @datalen: len of data buffer 7997996a778SMike Christie * 8007996a778SMike Christie * Completes pdu processing by freeing any resources allocated at 8017996a778SMike Christie * queuecommand or send generic. session lock must be held and verify 8027996a778SMike Christie * itt must have been called. 8037996a778SMike Christie */ 804913e5bf4SMike Christie int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 8057996a778SMike Christie char *data, int datalen) 8067996a778SMike Christie { 8077996a778SMike Christie struct iscsi_session *session = conn->session; 8087996a778SMike Christie int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0; 8099c19a7d0SMike Christie struct iscsi_task *task; 8107996a778SMike Christie uint32_t itt; 8117996a778SMike Christie 812f6d5180cSMike Christie conn->last_recv = jiffies; 8130af967f5SMike Christie rc = iscsi_verify_itt(conn, hdr->itt); 8140af967f5SMike Christie if (rc) 8150af967f5SMike Christie return rc; 8160af967f5SMike Christie 817b4377356SAl Viro if (hdr->itt != RESERVED_ITT) 818b4377356SAl Viro itt = get_itt(hdr->itt); 8197996a778SMike Christie else 820b4377356SAl Viro itt = ~0U; 8217996a778SMike Christie 8223e5c28adSMike Christie debug_scsi("[op 0x%x cid %d itt 0x%x len %d]\n", 8233e5c28adSMike Christie opcode, conn->id, itt, datalen); 8247996a778SMike Christie 8253e5c28adSMike Christie if (itt == ~0U) { 82677a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 82762f38300SMike Christie 8287996a778SMike Christie switch(opcode) { 8297996a778SMike Christie case ISCSI_OP_NOOP_IN: 83040527afeSMike Christie if (datalen) { 83140527afeSMike Christie rc = ISCSI_ERR_PROTO; 83240527afeSMike Christie break; 83340527afeSMike Christie } 83440527afeSMike Christie 835b4377356SAl Viro if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) 83640527afeSMike Christie break; 83740527afeSMike Christie 838f6d5180cSMike Christie iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr); 8397996a778SMike Christie break; 8407996a778SMike Christie case ISCSI_OP_REJECT: 84162f38300SMike Christie rc = iscsi_handle_reject(conn, hdr, data, datalen); 84262f38300SMike Christie break; 8437996a778SMike Christie case ISCSI_OP_ASYNC_EVENT: 8448d2860b3SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 8455831c737SMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 8465831c737SMike Christie rc = ISCSI_ERR_CONN_FAILED; 8477996a778SMike Christie break; 8487996a778SMike Christie default: 8497996a778SMike Christie rc = ISCSI_ERR_BAD_OPCODE; 8507996a778SMike Christie break; 8517996a778SMike Christie } 8523e5c28adSMike Christie goto out; 8533e5c28adSMike Christie } 8547996a778SMike Christie 8553e5c28adSMike Christie switch(opcode) { 8563e5c28adSMike Christie case ISCSI_OP_SCSI_CMD_RSP: 857913e5bf4SMike Christie case ISCSI_OP_SCSI_DATA_IN: 858913e5bf4SMike Christie task = iscsi_itt_to_ctask(conn, hdr->itt); 859913e5bf4SMike Christie if (!task) 860913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 8613e5c28adSMike Christie break; 862913e5bf4SMike Christie case ISCSI_OP_R2T: 863913e5bf4SMike Christie /* 864913e5bf4SMike Christie * LLD handles R2Ts if they need to. 865913e5bf4SMike Christie */ 866913e5bf4SMike Christie return 0; 867913e5bf4SMike Christie case ISCSI_OP_LOGOUT_RSP: 868913e5bf4SMike Christie case ISCSI_OP_LOGIN_RSP: 869913e5bf4SMike Christie case ISCSI_OP_TEXT_RSP: 870913e5bf4SMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 871913e5bf4SMike Christie case ISCSI_OP_NOOP_IN: 872913e5bf4SMike Christie task = iscsi_itt_to_task(conn, hdr->itt); 873913e5bf4SMike Christie if (!task) 874913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 875913e5bf4SMike Christie break; 876913e5bf4SMike Christie default: 877913e5bf4SMike Christie return ISCSI_ERR_BAD_OPCODE; 8783e5c28adSMike Christie } 879913e5bf4SMike Christie 880913e5bf4SMike Christie switch(opcode) { 881913e5bf4SMike Christie case ISCSI_OP_SCSI_CMD_RSP: 8829c19a7d0SMike Christie iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen); 8833e5c28adSMike Christie break; 8843e5c28adSMike Christie case ISCSI_OP_SCSI_DATA_IN: 8851d9edf02SMike Christie iscsi_data_in_rsp(conn, hdr, task); 8863e5c28adSMike Christie break; 8873e5c28adSMike Christie case ISCSI_OP_LOGOUT_RSP: 8883e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 8893e5c28adSMike Christie if (datalen) { 8903e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 8913e5c28adSMike Christie break; 8923e5c28adSMike Christie } 8933e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 8943e5c28adSMike Christie goto recv_pdu; 8953e5c28adSMike Christie case ISCSI_OP_LOGIN_RSP: 8963e5c28adSMike Christie case ISCSI_OP_TEXT_RSP: 8973e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 8983e5c28adSMike Christie /* 8993e5c28adSMike Christie * login related PDU's exp_statsn is handled in 9003e5c28adSMike Christie * userspace 9013e5c28adSMike Christie */ 9023e5c28adSMike Christie goto recv_pdu; 9033e5c28adSMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 9043e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 9053e5c28adSMike Christie if (datalen) { 9063e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 9073e5c28adSMike Christie break; 9083e5c28adSMike Christie } 9093e5c28adSMike Christie 9103e5c28adSMike Christie iscsi_tmf_rsp(conn, hdr); 9119c19a7d0SMike Christie __iscsi_put_task(task); 9123e5c28adSMike Christie break; 9133e5c28adSMike Christie case ISCSI_OP_NOOP_IN: 9143e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 9153e5c28adSMike Christie if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) { 9163e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 9173e5c28adSMike Christie break; 9183e5c28adSMike Christie } 9193e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 9203e5c28adSMike Christie 9219c19a7d0SMike Christie if (conn->ping_task != task) 9223e5c28adSMike Christie /* 9233e5c28adSMike Christie * If this is not in response to one of our 9243e5c28adSMike Christie * nops then it must be from userspace. 9253e5c28adSMike Christie */ 9263e5c28adSMike Christie goto recv_pdu; 9279c19a7d0SMike Christie 9289c19a7d0SMike Christie mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout); 9299c19a7d0SMike Christie __iscsi_put_task(task); 9303e5c28adSMike Christie break; 9313e5c28adSMike Christie default: 9323e5c28adSMike Christie rc = ISCSI_ERR_BAD_OPCODE; 9333e5c28adSMike Christie break; 9343e5c28adSMike Christie } 9353e5c28adSMike Christie 9363e5c28adSMike Christie out: 9373e5c28adSMike Christie return rc; 9383e5c28adSMike Christie recv_pdu: 9393e5c28adSMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 9403e5c28adSMike Christie rc = ISCSI_ERR_CONN_FAILED; 9419c19a7d0SMike Christie __iscsi_put_task(task); 9427996a778SMike Christie return rc; 9437996a778SMike Christie } 944913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_complete_pdu); 9457996a778SMike Christie 9467996a778SMike Christie int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 9477996a778SMike Christie char *data, int datalen) 9487996a778SMike Christie { 9497996a778SMike Christie int rc; 9507996a778SMike Christie 9517996a778SMike Christie spin_lock(&conn->session->lock); 9527996a778SMike Christie rc = __iscsi_complete_pdu(conn, hdr, data, datalen); 9537996a778SMike Christie spin_unlock(&conn->session->lock); 9547996a778SMike Christie return rc; 9557996a778SMike Christie } 9567996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_pdu); 9577996a778SMike Christie 9580af967f5SMike Christie int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt) 9597996a778SMike Christie { 9607996a778SMike Christie struct iscsi_session *session = conn->session; 9613e5c28adSMike Christie uint32_t i; 9627996a778SMike Christie 9630af967f5SMike Christie if (itt == RESERVED_ITT) 9640af967f5SMike Christie return 0; 9650af967f5SMike Christie 9660af967f5SMike Christie if (((__force u32)itt & ISCSI_AGE_MASK) != 9677996a778SMike Christie (session->age << ISCSI_AGE_SHIFT)) { 968322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 9690af967f5SMike Christie "received itt %x expected session age (%x)\n", 970913e5bf4SMike Christie (__force u32)itt, session->age); 9717996a778SMike Christie return ISCSI_ERR_BAD_ITT; 9727996a778SMike Christie } 9737996a778SMike Christie 9743e5c28adSMike Christie i = get_itt(itt); 9753e5c28adSMike Christie if (i >= session->cmds_max) { 9763e5c28adSMike Christie iscsi_conn_printk(KERN_ERR, conn, 9773e5c28adSMike Christie "received invalid itt index %u (max cmds " 9783e5c28adSMike Christie "%u.\n", i, session->cmds_max); 9793e5c28adSMike Christie return ISCSI_ERR_BAD_ITT; 9807996a778SMike Christie } 9817996a778SMike Christie return 0; 9827996a778SMike Christie } 9837996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_verify_itt); 9847996a778SMike Christie 985913e5bf4SMike Christie /** 986913e5bf4SMike Christie * iscsi_itt_to_ctask - look up ctask by itt 987913e5bf4SMike Christie * @conn: iscsi connection 988913e5bf4SMike Christie * @itt: itt 989913e5bf4SMike Christie * 990913e5bf4SMike Christie * This should be used for cmd tasks. 991913e5bf4SMike Christie * 992913e5bf4SMike Christie * The session lock must be held. 993913e5bf4SMike Christie */ 994913e5bf4SMike Christie struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt) 9950af967f5SMike Christie { 9969c19a7d0SMike Christie struct iscsi_task *task; 9970af967f5SMike Christie 9980af967f5SMike Christie if (iscsi_verify_itt(conn, itt)) 9990af967f5SMike Christie return NULL; 10000af967f5SMike Christie 1001913e5bf4SMike Christie task = iscsi_itt_to_task(conn, itt); 1002913e5bf4SMike Christie if (!task || !task->sc) 10030af967f5SMike Christie return NULL; 10040af967f5SMike Christie 1005913e5bf4SMike Christie if (task->sc->SCp.phase != conn->session->age) { 1006913e5bf4SMike Christie iscsi_session_printk(KERN_ERR, conn->session, 1007913e5bf4SMike Christie "task's session age %d, expected %d\n", 1008913e5bf4SMike Christie task->sc->SCp.phase, conn->session->age); 10090af967f5SMike Christie return NULL; 1010913e5bf4SMike Christie } 10110af967f5SMike Christie 10129c19a7d0SMike Christie return task; 10130af967f5SMike Christie } 10140af967f5SMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask); 10150af967f5SMike Christie 1016e5bd7b54SMike Christie void iscsi_session_failure(struct iscsi_cls_session *cls_session, 1017e5bd7b54SMike Christie enum iscsi_err err) 1018e5bd7b54SMike Christie { 1019e5bd7b54SMike Christie struct iscsi_session *session = cls_session->dd_data; 1020e5bd7b54SMike Christie struct iscsi_conn *conn; 1021e5bd7b54SMike Christie struct device *dev; 1022e5bd7b54SMike Christie unsigned long flags; 1023e5bd7b54SMike Christie 1024e5bd7b54SMike Christie spin_lock_irqsave(&session->lock, flags); 1025e5bd7b54SMike Christie conn = session->leadconn; 1026e5bd7b54SMike Christie if (session->state == ISCSI_STATE_TERMINATE || !conn) { 1027e5bd7b54SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1028e5bd7b54SMike Christie return; 1029e5bd7b54SMike Christie } 1030e5bd7b54SMike Christie 1031e5bd7b54SMike Christie dev = get_device(&conn->cls_conn->dev); 1032e5bd7b54SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1033e5bd7b54SMike Christie if (!dev) 1034e5bd7b54SMike Christie return; 1035e5bd7b54SMike Christie /* 1036e5bd7b54SMike Christie * if the host is being removed bypass the connection 1037e5bd7b54SMike Christie * recovery initialization because we are going to kill 1038e5bd7b54SMike Christie * the session. 1039e5bd7b54SMike Christie */ 1040e5bd7b54SMike Christie if (err == ISCSI_ERR_INVALID_HOST) 1041e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 1042e5bd7b54SMike Christie else 1043e5bd7b54SMike Christie iscsi_conn_failure(conn, err); 1044e5bd7b54SMike Christie put_device(dev); 1045e5bd7b54SMike Christie } 1046e5bd7b54SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_failure); 1047e5bd7b54SMike Christie 10487996a778SMike Christie void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err) 10497996a778SMike Christie { 10507996a778SMike Christie struct iscsi_session *session = conn->session; 10517996a778SMike Christie unsigned long flags; 10527996a778SMike Christie 10537996a778SMike Christie spin_lock_irqsave(&session->lock, flags); 1054656cffc9SMike Christie if (session->state == ISCSI_STATE_FAILED) { 1055656cffc9SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1056656cffc9SMike Christie return; 1057656cffc9SMike Christie } 1058656cffc9SMike Christie 105967a61114SMike Christie if (conn->stop_stage == 0) 10607996a778SMike Christie session->state = ISCSI_STATE_FAILED; 10617996a778SMike Christie spin_unlock_irqrestore(&session->lock, flags); 1062e5bd7b54SMike Christie 10637996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 10647996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 1065e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 10667996a778SMike Christie } 10677996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_failure); 10687996a778SMike Christie 106977a23c21SMike Christie static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn) 107077a23c21SMike Christie { 107177a23c21SMike Christie struct iscsi_session *session = conn->session; 107277a23c21SMike Christie 107377a23c21SMike Christie /* 107477a23c21SMike Christie * Check for iSCSI window and take care of CmdSN wrap-around 107577a23c21SMike Christie */ 1076e0726407SMike Christie if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) { 1077e0726407SMike Christie debug_scsi("iSCSI CmdSN closed. ExpCmdSn %u MaxCmdSN %u " 1078e0726407SMike Christie "CmdSN %u/%u\n", session->exp_cmdsn, 1079e0726407SMike Christie session->max_cmdsn, session->cmdsn, 1080e0726407SMike Christie session->queued_cmdsn); 108177a23c21SMike Christie return -ENOSPC; 108277a23c21SMike Christie } 108377a23c21SMike Christie return 0; 108477a23c21SMike Christie } 108577a23c21SMike Christie 10869c19a7d0SMike Christie static int iscsi_xmit_task(struct iscsi_conn *conn) 108777a23c21SMike Christie { 10889c19a7d0SMike Christie struct iscsi_task *task = conn->task; 1089843c0a8aSMike Christie int rc; 109077a23c21SMike Christie 10919c19a7d0SMike Christie __iscsi_get_task(task); 109277a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 10939c19a7d0SMike Christie rc = conn->session->tt->xmit_task(task); 109477a23c21SMike Christie spin_lock_bh(&conn->session->lock); 10959c19a7d0SMike Christie __iscsi_put_task(task); 109677a23c21SMike Christie if (!rc) 10979c19a7d0SMike Christie /* done with this task */ 10989c19a7d0SMike Christie conn->task = NULL; 109977a23c21SMike Christie return rc; 110077a23c21SMike Christie } 110177a23c21SMike Christie 11027996a778SMike Christie /** 11039c19a7d0SMike Christie * iscsi_requeue_task - requeue task to run from session workqueue 11049c19a7d0SMike Christie * @task: task to requeue 1105843c0a8aSMike Christie * 11069c19a7d0SMike Christie * LLDs that need to run a task from the session workqueue should call 1107052d0144SMike Christie * this. The session lock must be held. This should only be called 1108052d0144SMike Christie * by software drivers. 1109843c0a8aSMike Christie */ 11109c19a7d0SMike Christie void iscsi_requeue_task(struct iscsi_task *task) 1111843c0a8aSMike Christie { 11129c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 1113843c0a8aSMike Christie 11149c19a7d0SMike Christie list_move_tail(&task->running, &conn->requeue); 1115843c0a8aSMike Christie scsi_queue_work(conn->session->host, &conn->xmitwork); 1116843c0a8aSMike Christie } 11179c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_requeue_task); 1118843c0a8aSMike Christie 1119843c0a8aSMike Christie /** 11207996a778SMike Christie * iscsi_data_xmit - xmit any command into the scheduled connection 11217996a778SMike Christie * @conn: iscsi connection 11227996a778SMike Christie * 11237996a778SMike Christie * Notes: 11247996a778SMike Christie * The function can return -EAGAIN in which case the caller must 11257996a778SMike Christie * re-schedule it again later or recover. '0' return code means 11267996a778SMike Christie * successful xmit. 11277996a778SMike Christie **/ 11287996a778SMike Christie static int iscsi_data_xmit(struct iscsi_conn *conn) 11297996a778SMike Christie { 11303219e529SMike Christie int rc = 0; 11317996a778SMike Christie 113277a23c21SMike Christie spin_lock_bh(&conn->session->lock); 11337996a778SMike Christie if (unlikely(conn->suspend_tx)) { 11347996a778SMike Christie debug_scsi("conn %d Tx suspended!\n", conn->id); 113577a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 11363219e529SMike Christie return -ENODATA; 11377996a778SMike Christie } 11387996a778SMike Christie 11399c19a7d0SMike Christie if (conn->task) { 11409c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 11413219e529SMike Christie if (rc) 11427996a778SMike Christie goto again; 11437996a778SMike Christie } 114477a23c21SMike Christie 114577a23c21SMike Christie /* 114677a23c21SMike Christie * process mgmt pdus like nops before commands since we should 114777a23c21SMike Christie * only have one nop-out as a ping from us and targets should not 114877a23c21SMike Christie * overflow us with nop-ins 114977a23c21SMike Christie */ 115077a23c21SMike Christie check_mgmt: 1151843c0a8aSMike Christie while (!list_empty(&conn->mgmtqueue)) { 11529c19a7d0SMike Christie conn->task = list_entry(conn->mgmtqueue.next, 11539c19a7d0SMike Christie struct iscsi_task, running); 11549c19a7d0SMike Christie if (iscsi_prep_mgmt_task(conn, conn->task)) { 11559c19a7d0SMike Christie __iscsi_put_task(conn->task); 11569c19a7d0SMike Christie conn->task = NULL; 1157b3a7ea8dSMike Christie continue; 1158b3a7ea8dSMike Christie } 11599c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 11603219e529SMike Christie if (rc) 11617996a778SMike Christie goto again; 11627996a778SMike Christie } 11637996a778SMike Christie 1164843c0a8aSMike Christie /* process pending command queue */ 1165b6c395edSMike Christie while (!list_empty(&conn->xmitqueue)) { 1166843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) 1167843c0a8aSMike Christie break; 1168843c0a8aSMike Christie 11699c19a7d0SMike Christie conn->task = list_entry(conn->xmitqueue.next, 11709c19a7d0SMike Christie struct iscsi_task, running); 1171b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) { 11729c19a7d0SMike Christie fail_command(conn, conn->task, DID_IMM_RETRY << 16); 1173b3a7ea8dSMike Christie continue; 1174b3a7ea8dSMike Christie } 1175577577daSMike Christie rc = iscsi_prep_scsi_cmd_pdu(conn->task); 1176577577daSMike Christie if (rc) { 1177577577daSMike Christie if (rc == -ENOMEM) { 1178577577daSMike Christie conn->task = NULL; 1179577577daSMike Christie goto again; 1180577577daSMike Christie } else 11819c19a7d0SMike Christie fail_command(conn, conn->task, DID_ABORT << 16); 1182004d6530SBoaz Harrosh continue; 1183004d6530SBoaz Harrosh } 11849c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 11853219e529SMike Christie if (rc) 11867996a778SMike Christie goto again; 118777a23c21SMike Christie /* 11889c19a7d0SMike Christie * we could continuously get new task requests so 118977a23c21SMike Christie * we need to check the mgmt queue for nops that need to 119077a23c21SMike Christie * be sent to aviod starvation 119177a23c21SMike Christie */ 1192843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 1193843c0a8aSMike Christie goto check_mgmt; 1194843c0a8aSMike Christie } 1195843c0a8aSMike Christie 1196843c0a8aSMike Christie while (!list_empty(&conn->requeue)) { 1197843c0a8aSMike Christie if (conn->session->fast_abort && conn->tmf_state != TMF_INITIAL) 1198843c0a8aSMike Christie break; 1199843c0a8aSMike Christie 1200b3a7ea8dSMike Christie /* 1201b3a7ea8dSMike Christie * we always do fastlogout - conn stop code will clean up. 1202b3a7ea8dSMike Christie */ 1203b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 1204b3a7ea8dSMike Christie break; 1205b3a7ea8dSMike Christie 12069c19a7d0SMike Christie conn->task = list_entry(conn->requeue.next, 12079c19a7d0SMike Christie struct iscsi_task, running); 12089c19a7d0SMike Christie conn->task->state = ISCSI_TASK_RUNNING; 1209843c0a8aSMike Christie list_move_tail(conn->requeue.next, &conn->run_list); 12109c19a7d0SMike Christie rc = iscsi_xmit_task(conn); 1211843c0a8aSMike Christie if (rc) 1212843c0a8aSMike Christie goto again; 1213843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 121477a23c21SMike Christie goto check_mgmt; 12157996a778SMike Christie } 121677a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 12173219e529SMike Christie return -ENODATA; 12187996a778SMike Christie 12197996a778SMike Christie again: 12207996a778SMike Christie if (unlikely(conn->suspend_tx)) 122177a23c21SMike Christie rc = -ENODATA; 122277a23c21SMike Christie spin_unlock_bh(&conn->session->lock); 12233219e529SMike Christie return rc; 12247996a778SMike Christie } 12257996a778SMike Christie 1226c4028958SDavid Howells static void iscsi_xmitworker(struct work_struct *work) 12277996a778SMike Christie { 1228c4028958SDavid Howells struct iscsi_conn *conn = 1229c4028958SDavid Howells container_of(work, struct iscsi_conn, xmitwork); 12303219e529SMike Christie int rc; 12317996a778SMike Christie /* 12327996a778SMike Christie * serialize Xmit worker on a per-connection basis. 12337996a778SMike Christie */ 12343219e529SMike Christie do { 12353219e529SMike Christie rc = iscsi_data_xmit(conn); 12363219e529SMike Christie } while (rc >= 0 || rc == -EAGAIN); 12377996a778SMike Christie } 12387996a778SMike Christie 1239577577daSMike Christie static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn, 1240577577daSMike Christie struct scsi_cmnd *sc) 1241577577daSMike Christie { 1242577577daSMike Christie struct iscsi_task *task; 1243577577daSMike Christie 1244577577daSMike Christie if (!__kfifo_get(conn->session->cmdpool.queue, 1245577577daSMike Christie (void *) &task, sizeof(void *))) 1246577577daSMike Christie return NULL; 1247577577daSMike Christie 1248577577daSMike Christie sc->SCp.phase = conn->session->age; 1249577577daSMike Christie sc->SCp.ptr = (char *) task; 1250577577daSMike Christie 1251577577daSMike Christie atomic_set(&task->refcount, 1); 1252577577daSMike Christie task->state = ISCSI_TASK_PENDING; 1253577577daSMike Christie task->conn = conn; 1254577577daSMike Christie task->sc = sc; 1255577577daSMike Christie INIT_LIST_HEAD(&task->running); 1256577577daSMike Christie return task; 1257577577daSMike Christie } 1258577577daSMike Christie 12597996a778SMike Christie enum { 12607996a778SMike Christie FAILURE_BAD_HOST = 1, 12617996a778SMike Christie FAILURE_SESSION_FAILED, 12627996a778SMike Christie FAILURE_SESSION_FREED, 12637996a778SMike Christie FAILURE_WINDOW_CLOSED, 126460ecebf5SMike Christie FAILURE_OOM, 12657996a778SMike Christie FAILURE_SESSION_TERMINATE, 1266656cffc9SMike Christie FAILURE_SESSION_IN_RECOVERY, 12677996a778SMike Christie FAILURE_SESSION_RECOVERY_TIMEOUT, 1268b3a7ea8dSMike Christie FAILURE_SESSION_LOGGING_OUT, 12696eabafbeSMike Christie FAILURE_SESSION_NOT_READY, 12707996a778SMike Christie }; 12717996a778SMike Christie 12727996a778SMike Christie int iscsi_queuecommand(struct scsi_cmnd *sc, void (*done)(struct scsi_cmnd *)) 12737996a778SMike Christie { 127475613521SMike Christie struct iscsi_cls_session *cls_session; 12757996a778SMike Christie struct Scsi_Host *host; 12767996a778SMike Christie int reason = 0; 12777996a778SMike Christie struct iscsi_session *session; 12787996a778SMike Christie struct iscsi_conn *conn; 12799c19a7d0SMike Christie struct iscsi_task *task = NULL; 12807996a778SMike Christie 12817996a778SMike Christie sc->scsi_done = done; 12827996a778SMike Christie sc->result = 0; 1283f47f2cf5SMike Christie sc->SCp.ptr = NULL; 12847996a778SMike Christie 12857996a778SMike Christie host = sc->device->host; 12861040c99dSMike Christie spin_unlock(host->host_lock); 12877996a778SMike Christie 128875613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 128975613521SMike Christie session = cls_session->dd_data; 12907996a778SMike Christie spin_lock(&session->lock); 12917996a778SMike Christie 129275613521SMike Christie reason = iscsi_session_chkready(cls_session); 12936eabafbeSMike Christie if (reason) { 12946eabafbeSMike Christie sc->result = reason; 12956eabafbeSMike Christie goto fault; 12966eabafbeSMike Christie } 12976eabafbeSMike Christie 1298656cffc9SMike Christie /* 1299656cffc9SMike Christie * ISCSI_STATE_FAILED is a temp. state. The recovery 1300656cffc9SMike Christie * code will decide what is best to do with command queued 1301656cffc9SMike Christie * during this time 1302656cffc9SMike Christie */ 1303656cffc9SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN && 1304656cffc9SMike Christie session->state != ISCSI_STATE_FAILED) { 1305656cffc9SMike Christie /* 1306656cffc9SMike Christie * to handle the race between when we set the recovery state 1307656cffc9SMike Christie * and block the session we requeue here (commands could 1308656cffc9SMike Christie * be entering our queuecommand while a block is starting 1309656cffc9SMike Christie * up because the block code is not locked) 1310656cffc9SMike Christie */ 13119000bcd6SMike Christie switch (session->state) { 13129000bcd6SMike Christie case ISCSI_STATE_IN_RECOVERY: 1313656cffc9SMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1314d6d13ee1SMike Christie goto reject; 13159000bcd6SMike Christie case ISCSI_STATE_LOGGING_OUT: 13169000bcd6SMike Christie reason = FAILURE_SESSION_LOGGING_OUT; 1317d6d13ee1SMike Christie goto reject; 1318b3a7ea8dSMike Christie case ISCSI_STATE_RECOVERY_FAILED: 1319656cffc9SMike Christie reason = FAILURE_SESSION_RECOVERY_TIMEOUT; 132056d7fcfaSMike Christie sc->result = DID_TRANSPORT_FAILFAST << 16; 1321b3a7ea8dSMike Christie break; 1322b3a7ea8dSMike Christie case ISCSI_STATE_TERMINATE: 1323656cffc9SMike Christie reason = FAILURE_SESSION_TERMINATE; 13246eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1325b3a7ea8dSMike Christie break; 1326b3a7ea8dSMike Christie default: 13277996a778SMike Christie reason = FAILURE_SESSION_FREED; 13286eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1329b3a7ea8dSMike Christie } 13307996a778SMike Christie goto fault; 13317996a778SMike Christie } 13327996a778SMike Christie 13337996a778SMike Christie conn = session->leadconn; 133498644047SMike Christie if (!conn) { 133598644047SMike Christie reason = FAILURE_SESSION_FREED; 13366eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 133798644047SMike Christie goto fault; 133898644047SMike Christie } 13397996a778SMike Christie 134077a23c21SMike Christie if (iscsi_check_cmdsn_window_closed(conn)) { 134177a23c21SMike Christie reason = FAILURE_WINDOW_CLOSED; 134277a23c21SMike Christie goto reject; 134377a23c21SMike Christie } 134477a23c21SMike Christie 1345577577daSMike Christie task = iscsi_alloc_task(conn, sc); 1346577577daSMike Christie if (!task) { 134760ecebf5SMike Christie reason = FAILURE_OOM; 134860ecebf5SMike Christie goto reject; 134960ecebf5SMike Christie } 13509c19a7d0SMike Christie list_add_tail(&task->running, &conn->xmitqueue); 13517996a778SMike Christie 1352052d0144SMike Christie if (session->tt->caps & CAP_DATA_PATH_OFFLOAD) { 1353577577daSMike Christie reason = iscsi_prep_scsi_cmd_pdu(task); 1354577577daSMike Christie if (reason) { 1355577577daSMike Christie if (reason == -ENOMEM) { 1356577577daSMike Christie reason = FAILURE_OOM; 1357577577daSMike Christie goto prepd_reject; 1358577577daSMike Christie } else { 1359052d0144SMike Christie sc->result = DID_ABORT << 16; 1360577577daSMike Christie goto prepd_fault; 1361577577daSMike Christie } 1362052d0144SMike Christie } 13639c19a7d0SMike Christie if (session->tt->xmit_task(task)) { 1364052d0144SMike Christie reason = FAILURE_SESSION_NOT_READY; 1365577577daSMike Christie goto prepd_reject; 1366052d0144SMike Christie } 1367052d0144SMike Christie } else 1368052d0144SMike Christie scsi_queue_work(session->host, &conn->xmitwork); 1369052d0144SMike Christie 1370052d0144SMike Christie session->queued_cmdsn++; 1371052d0144SMike Christie spin_unlock(&session->lock); 13721040c99dSMike Christie spin_lock(host->host_lock); 13737996a778SMike Christie return 0; 13747996a778SMike Christie 1375577577daSMike Christie prepd_reject: 1376577577daSMike Christie sc->scsi_done = NULL; 1377577577daSMike Christie iscsi_complete_command(task); 13787996a778SMike Christie reject: 13797996a778SMike Christie spin_unlock(&session->lock); 13807996a778SMike Christie debug_scsi("cmd 0x%x rejected (%d)\n", sc->cmnd[0], reason); 13811040c99dSMike Christie spin_lock(host->host_lock); 1382d6d13ee1SMike Christie return SCSI_MLQUEUE_TARGET_BUSY; 13837996a778SMike Christie 1384577577daSMike Christie prepd_fault: 1385577577daSMike Christie sc->scsi_done = NULL; 1386577577daSMike Christie iscsi_complete_command(task); 13877996a778SMike Christie fault: 13887996a778SMike Christie spin_unlock(&session->lock); 13896eabafbeSMike Christie debug_scsi("iscsi: cmd 0x%x is not queued (%d)\n", sc->cmnd[0], reason); 1390c07d4444SBoaz Harrosh if (!scsi_bidi_cmnd(sc)) 13911c138991SFUJITA Tomonori scsi_set_resid(sc, scsi_bufflen(sc)); 1392c07d4444SBoaz Harrosh else { 1393c07d4444SBoaz Harrosh scsi_out(sc)->resid = scsi_out(sc)->length; 1394c07d4444SBoaz Harrosh scsi_in(sc)->resid = scsi_in(sc)->length; 1395c07d4444SBoaz Harrosh } 1396052d0144SMike Christie done(sc); 13971040c99dSMike Christie spin_lock(host->host_lock); 13987996a778SMike Christie return 0; 13997996a778SMike Christie } 14007996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_queuecommand); 14017996a778SMike Christie 14027996a778SMike Christie int iscsi_change_queue_depth(struct scsi_device *sdev, int depth) 14037996a778SMike Christie { 14047996a778SMike Christie if (depth > ISCSI_MAX_CMD_PER_LUN) 14057996a778SMike Christie depth = ISCSI_MAX_CMD_PER_LUN; 14067996a778SMike Christie scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), depth); 14077996a778SMike Christie return sdev->queue_depth; 14087996a778SMike Christie } 14097996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_change_queue_depth); 14107996a778SMike Christie 14117996a778SMike Christie void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) 14127996a778SMike Christie { 141375613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 14147996a778SMike Christie 14157996a778SMike Christie spin_lock_bh(&session->lock); 14167996a778SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1417656cffc9SMike Christie session->state = ISCSI_STATE_RECOVERY_FAILED; 1418843c0a8aSMike Christie if (session->leadconn) 1419843c0a8aSMike Christie wake_up(&session->leadconn->ehwait); 14207996a778SMike Christie } 14217996a778SMike Christie spin_unlock_bh(&session->lock); 14227996a778SMike Christie } 14237996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout); 14247996a778SMike Christie 14258e124525SMike Christie int iscsi_eh_target_reset(struct scsi_cmnd *sc) 14267996a778SMike Christie { 142775613521SMike Christie struct iscsi_cls_session *cls_session; 142875613521SMike Christie struct iscsi_session *session; 142975613521SMike Christie struct iscsi_conn *conn; 143075613521SMike Christie 143175613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 143275613521SMike Christie session = cls_session->dd_data; 143375613521SMike Christie conn = session->leadconn; 14347996a778SMike Christie 1435bc436b27SMike Christie mutex_lock(&session->eh_mutex); 14367996a778SMike Christie spin_lock_bh(&session->lock); 14377996a778SMike Christie if (session->state == ISCSI_STATE_TERMINATE) { 14387996a778SMike Christie failed: 14398e124525SMike Christie debug_scsi("failing target reset: session terminated " 1440d6e24d1cSPete Wyckoff "[CID %d age %d]\n", conn->id, session->age); 14417996a778SMike Christie spin_unlock_bh(&session->lock); 1442bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 14437996a778SMike Christie return FAILED; 14447996a778SMike Christie } 14457996a778SMike Christie 14467996a778SMike Christie spin_unlock_bh(&session->lock); 1447bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 14487996a778SMike Christie /* 14497996a778SMike Christie * we drop the lock here but the leadconn cannot be destoyed while 14507996a778SMike Christie * we are in the scsi eh 14517996a778SMike Christie */ 14527996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 14537996a778SMike Christie 14548e124525SMike Christie debug_scsi("iscsi_eh_target_reset wait for relogin\n"); 14557996a778SMike Christie wait_event_interruptible(conn->ehwait, 14567996a778SMike Christie session->state == ISCSI_STATE_TERMINATE || 14577996a778SMike Christie session->state == ISCSI_STATE_LOGGED_IN || 1458656cffc9SMike Christie session->state == ISCSI_STATE_RECOVERY_FAILED); 14597996a778SMike Christie if (signal_pending(current)) 14607996a778SMike Christie flush_signals(current); 14617996a778SMike Christie 1462bc436b27SMike Christie mutex_lock(&session->eh_mutex); 14637996a778SMike Christie spin_lock_bh(&session->lock); 14647996a778SMike Christie if (session->state == ISCSI_STATE_LOGGED_IN) 1465322d739dSMike Christie iscsi_session_printk(KERN_INFO, session, 14668e124525SMike Christie "target reset succeeded\n"); 14677996a778SMike Christie else 14687996a778SMike Christie goto failed; 14697996a778SMike Christie spin_unlock_bh(&session->lock); 1470bc436b27SMike Christie mutex_unlock(&session->eh_mutex); 14717996a778SMike Christie return SUCCESS; 14727996a778SMike Christie } 14738e124525SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_target_reset); 14747996a778SMike Christie 1475843c0a8aSMike Christie static void iscsi_tmf_timedout(unsigned long data) 14767996a778SMike Christie { 1477843c0a8aSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 14787996a778SMike Christie struct iscsi_session *session = conn->session; 14797996a778SMike Christie 14807996a778SMike Christie spin_lock(&session->lock); 1481843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) { 1482843c0a8aSMike Christie conn->tmf_state = TMF_TIMEDOUT; 1483843c0a8aSMike Christie debug_scsi("tmf timedout\n"); 14847996a778SMike Christie /* unblock eh_abort() */ 14857996a778SMike Christie wake_up(&conn->ehwait); 14867996a778SMike Christie } 14877996a778SMike Christie spin_unlock(&session->lock); 14887996a778SMike Christie } 14897996a778SMike Christie 14909c19a7d0SMike Christie static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, 1491f6d5180cSMike Christie struct iscsi_tm *hdr, int age, 1492f6d5180cSMike Christie int timeout) 14937996a778SMike Christie { 14947996a778SMike Christie struct iscsi_session *session = conn->session; 14959c19a7d0SMike Christie struct iscsi_task *task; 14967996a778SMike Christie 14979c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr, 14987996a778SMike Christie NULL, 0); 14999c19a7d0SMike Christie if (!task) { 15006724add1SMike Christie spin_unlock_bh(&session->lock); 15017996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1502843c0a8aSMike Christie spin_lock_bh(&session->lock); 1503843c0a8aSMike Christie debug_scsi("tmf exec failure\n"); 150477a23c21SMike Christie return -EPERM; 15057996a778SMike Christie } 15067996a778SMike Christie conn->tmfcmd_pdus_cnt++; 1507f6d5180cSMike Christie conn->tmf_timer.expires = timeout * HZ + jiffies; 1508843c0a8aSMike Christie conn->tmf_timer.function = iscsi_tmf_timedout; 1509843c0a8aSMike Christie conn->tmf_timer.data = (unsigned long)conn; 1510843c0a8aSMike Christie add_timer(&conn->tmf_timer); 1511843c0a8aSMike Christie debug_scsi("tmf set timeout\n"); 1512843c0a8aSMike Christie 15137996a778SMike Christie spin_unlock_bh(&session->lock); 15146724add1SMike Christie mutex_unlock(&session->eh_mutex); 15157996a778SMike Christie 15167996a778SMike Christie /* 15177996a778SMike Christie * block eh thread until: 15187996a778SMike Christie * 1519843c0a8aSMike Christie * 1) tmf response 1520843c0a8aSMike Christie * 2) tmf timeout 15217996a778SMike Christie * 3) session is terminated or restarted or userspace has 15227996a778SMike Christie * given up on recovery 15237996a778SMike Christie */ 1524843c0a8aSMike Christie wait_event_interruptible(conn->ehwait, age != session->age || 15257996a778SMike Christie session->state != ISCSI_STATE_LOGGED_IN || 1526843c0a8aSMike Christie conn->tmf_state != TMF_QUEUED); 15277996a778SMike Christie if (signal_pending(current)) 15287996a778SMike Christie flush_signals(current); 1529843c0a8aSMike Christie del_timer_sync(&conn->tmf_timer); 1530843c0a8aSMike Christie 15316724add1SMike Christie mutex_lock(&session->eh_mutex); 153277a23c21SMike Christie spin_lock_bh(&session->lock); 15339c19a7d0SMike Christie /* if the session drops it will clean up the task */ 1534843c0a8aSMike Christie if (age != session->age || 1535843c0a8aSMike Christie session->state != ISCSI_STATE_LOGGED_IN) 1536843c0a8aSMike Christie return -ENOTCONN; 15377996a778SMike Christie return 0; 15387996a778SMike Christie } 15397996a778SMike Christie 15407996a778SMike Christie /* 1541843c0a8aSMike Christie * Fail commands. session lock held and recv side suspended and xmit 1542843c0a8aSMike Christie * thread flushed 1543843c0a8aSMike Christie */ 15446eabafbeSMike Christie static void fail_all_commands(struct iscsi_conn *conn, unsigned lun, 15456eabafbeSMike Christie int error) 1546843c0a8aSMike Christie { 15479c19a7d0SMike Christie struct iscsi_task *task, *tmp; 1548843c0a8aSMike Christie 15499c19a7d0SMike Christie if (conn->task && (conn->task->sc->device->lun == lun || lun == -1)) 15509c19a7d0SMike Christie conn->task = NULL; 1551843c0a8aSMike Christie 1552843c0a8aSMike Christie /* flush pending */ 15539c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->xmitqueue, running) { 15549c19a7d0SMike Christie if (lun == task->sc->device->lun || lun == -1) { 1555843c0a8aSMike Christie debug_scsi("failing pending sc %p itt 0x%x\n", 15569c19a7d0SMike Christie task->sc, task->itt); 15579c19a7d0SMike Christie fail_command(conn, task, error << 16); 1558843c0a8aSMike Christie } 1559843c0a8aSMike Christie } 1560843c0a8aSMike Christie 15619c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->requeue, running) { 15629c19a7d0SMike Christie if (lun == task->sc->device->lun || lun == -1) { 1563843c0a8aSMike Christie debug_scsi("failing requeued sc %p itt 0x%x\n", 15649c19a7d0SMike Christie task->sc, task->itt); 15659c19a7d0SMike Christie fail_command(conn, task, error << 16); 1566843c0a8aSMike Christie } 1567843c0a8aSMike Christie } 1568843c0a8aSMike Christie 1569843c0a8aSMike Christie /* fail all other running */ 15709c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->run_list, running) { 15719c19a7d0SMike Christie if (lun == task->sc->device->lun || lun == -1) { 1572843c0a8aSMike Christie debug_scsi("failing in progress sc %p itt 0x%x\n", 15739c19a7d0SMike Christie task->sc, task->itt); 1574ac26d41dSMike Christie fail_command(conn, task, error << 16); 1575843c0a8aSMike Christie } 1576843c0a8aSMike Christie } 1577843c0a8aSMike Christie } 1578843c0a8aSMike Christie 1579b40977d9SMike Christie void iscsi_suspend_tx(struct iscsi_conn *conn) 15806724add1SMike Christie { 15816724add1SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1582052d0144SMike Christie if (!(conn->session->tt->caps & CAP_DATA_PATH_OFFLOAD)) 15836724add1SMike Christie scsi_flush_work(conn->session->host); 15846724add1SMike Christie } 1585b40977d9SMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_tx); 15866724add1SMike Christie 15876724add1SMike Christie static void iscsi_start_tx(struct iscsi_conn *conn) 15886724add1SMike Christie { 15896724add1SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1590052d0144SMike Christie if (!(conn->session->tt->caps & CAP_DATA_PATH_OFFLOAD)) 15916724add1SMike Christie scsi_queue_work(conn->session->host, &conn->xmitwork); 15926724add1SMike Christie } 15936724add1SMike Christie 1594242f9dcbSJens Axboe static enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *scmd) 1595f6d5180cSMike Christie { 1596f6d5180cSMike Christie struct iscsi_cls_session *cls_session; 1597f6d5180cSMike Christie struct iscsi_session *session; 1598f6d5180cSMike Christie struct iscsi_conn *conn; 1599242f9dcbSJens Axboe enum blk_eh_timer_return rc = BLK_EH_NOT_HANDLED; 1600f6d5180cSMike Christie 1601f6d5180cSMike Christie cls_session = starget_to_session(scsi_target(scmd->device)); 160275613521SMike Christie session = cls_session->dd_data; 1603f6d5180cSMike Christie 1604f6d5180cSMike Christie debug_scsi("scsi cmd %p timedout\n", scmd); 1605f6d5180cSMike Christie 1606f6d5180cSMike Christie spin_lock(&session->lock); 1607f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1608f6d5180cSMike Christie /* 1609f6d5180cSMike Christie * We are probably in the middle of iscsi recovery so let 1610f6d5180cSMike Christie * that complete and handle the error. 1611f6d5180cSMike Christie */ 1612242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1613f6d5180cSMike Christie goto done; 1614f6d5180cSMike Christie } 1615f6d5180cSMike Christie 1616f6d5180cSMike Christie conn = session->leadconn; 1617f6d5180cSMike Christie if (!conn) { 1618f6d5180cSMike Christie /* In the middle of shuting down */ 1619242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1620f6d5180cSMike Christie goto done; 1621f6d5180cSMike Christie } 1622f6d5180cSMike Christie 1623f6d5180cSMike Christie if (!conn->recv_timeout && !conn->ping_timeout) 1624f6d5180cSMike Christie goto done; 1625f6d5180cSMike Christie /* 1626f6d5180cSMike Christie * if the ping timedout then we are in the middle of cleaning up 1627f6d5180cSMike Christie * and can let the iscsi eh handle it 1628f6d5180cSMike Christie */ 1629f6d5180cSMike Christie if (time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) + 1630f6d5180cSMike Christie (conn->ping_timeout * HZ), jiffies)) 1631242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1632f6d5180cSMike Christie /* 1633f6d5180cSMike Christie * if we are about to check the transport then give the command 1634f6d5180cSMike Christie * more time 1635f6d5180cSMike Christie */ 1636f6d5180cSMike Christie if (time_before_eq(conn->last_recv + (conn->recv_timeout * HZ), 1637f6d5180cSMike Christie jiffies)) 1638242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1639f6d5180cSMike Christie /* if in the middle of checking the transport then give us more time */ 16409c19a7d0SMike Christie if (conn->ping_task) 1641242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 1642f6d5180cSMike Christie done: 1643f6d5180cSMike Christie spin_unlock(&session->lock); 1644242f9dcbSJens Axboe debug_scsi("return %s\n", rc == BLK_EH_RESET_TIMER ? 1645242f9dcbSJens Axboe "timer reset" : "nh"); 1646f6d5180cSMike Christie return rc; 1647f6d5180cSMike Christie } 1648f6d5180cSMike Christie 1649f6d5180cSMike Christie static void iscsi_check_transport_timeouts(unsigned long data) 1650f6d5180cSMike Christie { 1651f6d5180cSMike Christie struct iscsi_conn *conn = (struct iscsi_conn *)data; 1652f6d5180cSMike Christie struct iscsi_session *session = conn->session; 16534cf10435SMike Christie unsigned long recv_timeout, next_timeout = 0, last_recv; 1654f6d5180cSMike Christie 1655f6d5180cSMike Christie spin_lock(&session->lock); 1656f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 1657f6d5180cSMike Christie goto done; 1658f6d5180cSMike Christie 16594cf10435SMike Christie recv_timeout = conn->recv_timeout; 16604cf10435SMike Christie if (!recv_timeout) 1661f6d5180cSMike Christie goto done; 1662f6d5180cSMike Christie 16634cf10435SMike Christie recv_timeout *= HZ; 1664f6d5180cSMike Christie last_recv = conn->last_recv; 16659c19a7d0SMike Christie if (conn->ping_task && 16664cf10435SMike Christie time_before_eq(conn->last_ping + (conn->ping_timeout * HZ), 1667f6d5180cSMike Christie jiffies)) { 1668322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs " 1669322d739dSMike Christie "expired, last rx %lu, last ping %lu, " 1670322d739dSMike Christie "now %lu\n", conn->ping_timeout, last_recv, 1671f6d5180cSMike Christie conn->last_ping, jiffies); 1672f6d5180cSMike Christie spin_unlock(&session->lock); 1673f6d5180cSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1674f6d5180cSMike Christie return; 1675f6d5180cSMike Christie } 1676f6d5180cSMike Christie 16774cf10435SMike Christie if (time_before_eq(last_recv + recv_timeout, jiffies)) { 1678f6d5180cSMike Christie /* send a ping to try to provoke some traffic */ 1679f6d5180cSMike Christie debug_scsi("Sending nopout as ping on conn %p\n", conn); 1680f6d5180cSMike Christie iscsi_send_nopout(conn, NULL); 16814cf10435SMike Christie next_timeout = conn->last_ping + (conn->ping_timeout * HZ); 1682ad294e9cSMike Christie } else 16834cf10435SMike Christie next_timeout = last_recv + recv_timeout; 1684f6d5180cSMike Christie 1685f6d5180cSMike Christie debug_scsi("Setting next tmo %lu\n", next_timeout); 1686f6d5180cSMike Christie mod_timer(&conn->transport_timer, next_timeout); 1687f6d5180cSMike Christie done: 1688f6d5180cSMike Christie spin_unlock(&session->lock); 1689f6d5180cSMike Christie } 1690f6d5180cSMike Christie 16919c19a7d0SMike Christie static void iscsi_prep_abort_task_pdu(struct iscsi_task *task, 1692843c0a8aSMike Christie struct iscsi_tm *hdr) 1693843c0a8aSMike Christie { 1694843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 1695843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 1696843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK; 1697843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 1698577577daSMike Christie memcpy(hdr->lun, task->lun, sizeof(hdr->lun)); 1699577577daSMike Christie hdr->rtt = task->hdr_itt; 1700577577daSMike Christie hdr->refcmdsn = task->cmdsn; 1701843c0a8aSMike Christie } 1702843c0a8aSMike Christie 17037996a778SMike Christie int iscsi_eh_abort(struct scsi_cmnd *sc) 17047996a778SMike Christie { 170575613521SMike Christie struct iscsi_cls_session *cls_session; 170675613521SMike Christie struct iscsi_session *session; 1707f47f2cf5SMike Christie struct iscsi_conn *conn; 17089c19a7d0SMike Christie struct iscsi_task *task; 1709843c0a8aSMike Christie struct iscsi_tm *hdr; 1710843c0a8aSMike Christie int rc, age; 17117996a778SMike Christie 171275613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 171375613521SMike Christie session = cls_session->dd_data; 171475613521SMike Christie 17156724add1SMike Christie mutex_lock(&session->eh_mutex); 17166724add1SMike Christie spin_lock_bh(&session->lock); 1717f47f2cf5SMike Christie /* 1718f47f2cf5SMike Christie * if session was ISCSI_STATE_IN_RECOVERY then we may not have 1719f47f2cf5SMike Christie * got the command. 1720f47f2cf5SMike Christie */ 1721f47f2cf5SMike Christie if (!sc->SCp.ptr) { 1722f47f2cf5SMike Christie debug_scsi("sc never reached iscsi layer or it completed.\n"); 17236724add1SMike Christie spin_unlock_bh(&session->lock); 17246724add1SMike Christie mutex_unlock(&session->eh_mutex); 1725f47f2cf5SMike Christie return SUCCESS; 1726f47f2cf5SMike Christie } 1727f47f2cf5SMike Christie 17287996a778SMike Christie /* 17297996a778SMike Christie * If we are not logged in or we have started a new session 17307996a778SMike Christie * then let the host reset code handle this 17317996a778SMike Christie */ 1732843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN || 1733843c0a8aSMike Christie sc->SCp.phase != session->age) { 1734843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1735843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 1736843c0a8aSMike Christie return FAILED; 1737843c0a8aSMike Christie } 1738843c0a8aSMike Christie 1739843c0a8aSMike Christie conn = session->leadconn; 1740843c0a8aSMike Christie conn->eh_abort_cnt++; 1741843c0a8aSMike Christie age = session->age; 1742843c0a8aSMike Christie 17439c19a7d0SMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 17449c19a7d0SMike Christie debug_scsi("aborting [sc %p itt 0x%x]\n", sc, task->itt); 17457996a778SMike Christie 17469c19a7d0SMike Christie /* task completed before time out */ 17479c19a7d0SMike Christie if (!task->sc) { 17487ea8b828SMike Christie debug_scsi("sc completed while abort in progress\n"); 174977a23c21SMike Christie goto success; 17507ea8b828SMike Christie } 17517996a778SMike Christie 17529c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) { 17539c19a7d0SMike Christie fail_command(conn, task, DID_ABORT << 16); 175477a23c21SMike Christie goto success; 175577a23c21SMike Christie } 17567996a778SMike Christie 1757843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 1758843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 17597996a778SMike Christie goto failed; 1760843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 17617996a778SMike Christie 1762843c0a8aSMike Christie hdr = &conn->tmhdr; 17639c19a7d0SMike Christie iscsi_prep_abort_task_pdu(task, hdr); 1764843c0a8aSMike Christie 17659c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) { 1766843c0a8aSMike Christie rc = FAILED; 1767843c0a8aSMike Christie goto failed; 1768843c0a8aSMike Christie } 1769843c0a8aSMike Christie 1770843c0a8aSMike Christie switch (conn->tmf_state) { 1771843c0a8aSMike Christie case TMF_SUCCESS: 17727ea8b828SMike Christie spin_unlock_bh(&session->lock); 1773913e5bf4SMike Christie /* 1774913e5bf4SMike Christie * stop tx side incase the target had sent a abort rsp but 1775913e5bf4SMike Christie * the initiator was still writing out data. 1776913e5bf4SMike Christie */ 17776724add1SMike Christie iscsi_suspend_tx(conn); 17787996a778SMike Christie /* 1779913e5bf4SMike Christie * we do not stop the recv side because targets have been 1780913e5bf4SMike Christie * good and have never sent us a successful tmf response 1781913e5bf4SMike Christie * then sent more data for the cmd. 17827996a778SMike Christie */ 17837996a778SMike Christie spin_lock(&session->lock); 17849c19a7d0SMike Christie fail_command(conn, task, DID_ABORT << 16); 1785843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 17867996a778SMike Christie spin_unlock(&session->lock); 17876724add1SMike Christie iscsi_start_tx(conn); 178877a23c21SMike Christie goto success_unlocked; 1789843c0a8aSMike Christie case TMF_TIMEDOUT: 1790843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1791843c0a8aSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1792843c0a8aSMike Christie goto failed_unlocked; 1793843c0a8aSMike Christie case TMF_NOT_FOUND: 1794843c0a8aSMike Christie if (!sc->SCp.ptr) { 1795843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 17969c19a7d0SMike Christie /* task completed before tmf abort response */ 179777a23c21SMike Christie debug_scsi("sc completed while abort in progress\n"); 179877a23c21SMike Christie goto success; 179977a23c21SMike Christie } 180077a23c21SMike Christie /* fall through */ 180177a23c21SMike Christie default: 1802843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 1803843c0a8aSMike Christie goto failed; 180477a23c21SMike Christie } 18057996a778SMike Christie 180677a23c21SMike Christie success: 180777a23c21SMike Christie spin_unlock_bh(&session->lock); 180877a23c21SMike Christie success_unlocked: 18099c19a7d0SMike Christie debug_scsi("abort success [sc %lx itt 0x%x]\n", (long)sc, task->itt); 18106724add1SMike Christie mutex_unlock(&session->eh_mutex); 18117996a778SMike Christie return SUCCESS; 18127996a778SMike Christie 18137996a778SMike Christie failed: 18147996a778SMike Christie spin_unlock_bh(&session->lock); 181577a23c21SMike Christie failed_unlocked: 1816843c0a8aSMike Christie debug_scsi("abort failed [sc %p itt 0x%x]\n", sc, 18179c19a7d0SMike Christie task ? task->itt : 0); 18186724add1SMike Christie mutex_unlock(&session->eh_mutex); 18197996a778SMike Christie return FAILED; 18207996a778SMike Christie } 18217996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_abort); 18227996a778SMike Christie 1823843c0a8aSMike Christie static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 1824843c0a8aSMike Christie { 1825843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 1826843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 1827843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK; 1828843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 1829843c0a8aSMike Christie int_to_scsilun(sc->device->lun, (struct scsi_lun *)hdr->lun); 1830f6d5180cSMike Christie hdr->rtt = RESERVED_ITT; 1831843c0a8aSMike Christie } 1832843c0a8aSMike Christie 1833843c0a8aSMike Christie int iscsi_eh_device_reset(struct scsi_cmnd *sc) 1834843c0a8aSMike Christie { 183575613521SMike Christie struct iscsi_cls_session *cls_session; 183675613521SMike Christie struct iscsi_session *session; 1837843c0a8aSMike Christie struct iscsi_conn *conn; 1838843c0a8aSMike Christie struct iscsi_tm *hdr; 1839843c0a8aSMike Christie int rc = FAILED; 1840843c0a8aSMike Christie 184175613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 184275613521SMike Christie session = cls_session->dd_data; 184375613521SMike Christie 1844843c0a8aSMike Christie debug_scsi("LU Reset [sc %p lun %u]\n", sc, sc->device->lun); 1845843c0a8aSMike Christie 1846843c0a8aSMike Christie mutex_lock(&session->eh_mutex); 1847843c0a8aSMike Christie spin_lock_bh(&session->lock); 1848843c0a8aSMike Christie /* 1849843c0a8aSMike Christie * Just check if we are not logged in. We cannot check for 1850843c0a8aSMike Christie * the phase because the reset could come from a ioctl. 1851843c0a8aSMike Christie */ 1852843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 1853843c0a8aSMike Christie goto unlock; 1854843c0a8aSMike Christie conn = session->leadconn; 1855843c0a8aSMike Christie 1856843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 1857843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 1858843c0a8aSMike Christie goto unlock; 1859843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 1860843c0a8aSMike Christie 1861843c0a8aSMike Christie hdr = &conn->tmhdr; 1862843c0a8aSMike Christie iscsi_prep_lun_reset_pdu(sc, hdr); 1863843c0a8aSMike Christie 18649c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 1865f6d5180cSMike Christie session->lu_reset_timeout)) { 1866843c0a8aSMike Christie rc = FAILED; 1867843c0a8aSMike Christie goto unlock; 1868843c0a8aSMike Christie } 1869843c0a8aSMike Christie 1870843c0a8aSMike Christie switch (conn->tmf_state) { 1871843c0a8aSMike Christie case TMF_SUCCESS: 1872843c0a8aSMike Christie break; 1873843c0a8aSMike Christie case TMF_TIMEDOUT: 1874843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1875843c0a8aSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1876843c0a8aSMike Christie goto done; 1877843c0a8aSMike Christie default: 1878843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 1879843c0a8aSMike Christie goto unlock; 1880843c0a8aSMike Christie } 1881843c0a8aSMike Christie 1882843c0a8aSMike Christie rc = SUCCESS; 1883843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1884843c0a8aSMike Christie 1885843c0a8aSMike Christie iscsi_suspend_tx(conn); 1886913e5bf4SMike Christie 1887a3439148SMike Christie spin_lock_bh(&session->lock); 18886eabafbeSMike Christie fail_all_commands(conn, sc->device->lun, DID_ERROR); 1889843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 1890a3439148SMike Christie spin_unlock_bh(&session->lock); 1891843c0a8aSMike Christie 1892843c0a8aSMike Christie iscsi_start_tx(conn); 1893843c0a8aSMike Christie goto done; 1894843c0a8aSMike Christie 1895843c0a8aSMike Christie unlock: 1896843c0a8aSMike Christie spin_unlock_bh(&session->lock); 1897843c0a8aSMike Christie done: 1898843c0a8aSMike Christie debug_scsi("iscsi_eh_device_reset %s\n", 1899843c0a8aSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 1900843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 1901843c0a8aSMike Christie return rc; 1902843c0a8aSMike Christie } 1903843c0a8aSMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_device_reset); 1904843c0a8aSMike Christie 19056320377fSOlaf Kirch /* 19066320377fSOlaf Kirch * Pre-allocate a pool of @max items of @item_size. By default, the pool 19076320377fSOlaf Kirch * should be accessed via kfifo_{get,put} on q->queue. 19086320377fSOlaf Kirch * Optionally, the caller can obtain the array of object pointers 19096320377fSOlaf Kirch * by passing in a non-NULL @items pointer 19106320377fSOlaf Kirch */ 19117996a778SMike Christie int 19126320377fSOlaf Kirch iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size) 19137996a778SMike Christie { 19146320377fSOlaf Kirch int i, num_arrays = 1; 19157996a778SMike Christie 19166320377fSOlaf Kirch memset(q, 0, sizeof(*q)); 19177996a778SMike Christie 19187996a778SMike Christie q->max = max; 19196320377fSOlaf Kirch 19206320377fSOlaf Kirch /* If the user passed an items pointer, he wants a copy of 19216320377fSOlaf Kirch * the array. */ 19226320377fSOlaf Kirch if (items) 19236320377fSOlaf Kirch num_arrays++; 19246320377fSOlaf Kirch q->pool = kzalloc(num_arrays * max * sizeof(void*), GFP_KERNEL); 19256320377fSOlaf Kirch if (q->pool == NULL) 19266320377fSOlaf Kirch goto enomem; 19277996a778SMike Christie 19287996a778SMike Christie q->queue = kfifo_init((void*)q->pool, max * sizeof(void*), 19297996a778SMike Christie GFP_KERNEL, NULL); 19306320377fSOlaf Kirch if (q->queue == ERR_PTR(-ENOMEM)) 19316320377fSOlaf Kirch goto enomem; 19327996a778SMike Christie 19337996a778SMike Christie for (i = 0; i < max; i++) { 19346320377fSOlaf Kirch q->pool[i] = kzalloc(item_size, GFP_KERNEL); 19357996a778SMike Christie if (q->pool[i] == NULL) { 19366320377fSOlaf Kirch q->max = i; 19376320377fSOlaf Kirch goto enomem; 19387996a778SMike Christie } 19397996a778SMike Christie __kfifo_put(q->queue, (void*)&q->pool[i], sizeof(void*)); 19407996a778SMike Christie } 19416320377fSOlaf Kirch 19426320377fSOlaf Kirch if (items) { 19436320377fSOlaf Kirch *items = q->pool + max; 19446320377fSOlaf Kirch memcpy(*items, q->pool, max * sizeof(void *)); 19456320377fSOlaf Kirch } 19466320377fSOlaf Kirch 19477996a778SMike Christie return 0; 19486320377fSOlaf Kirch 19496320377fSOlaf Kirch enomem: 19506320377fSOlaf Kirch iscsi_pool_free(q); 19516320377fSOlaf Kirch return -ENOMEM; 19527996a778SMike Christie } 19537996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_init); 19547996a778SMike Christie 19556320377fSOlaf Kirch void iscsi_pool_free(struct iscsi_pool *q) 19567996a778SMike Christie { 19577996a778SMike Christie int i; 19587996a778SMike Christie 19597996a778SMike Christie for (i = 0; i < q->max; i++) 19606320377fSOlaf Kirch kfree(q->pool[i]); 19616320377fSOlaf Kirch if (q->pool) 19627996a778SMike Christie kfree(q->pool); 19637996a778SMike Christie } 19647996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_free); 19657996a778SMike Christie 1966a4804cd6SMike Christie /** 1967a4804cd6SMike Christie * iscsi_host_add - add host to system 1968a4804cd6SMike Christie * @shost: scsi host 1969a4804cd6SMike Christie * @pdev: parent device 1970a4804cd6SMike Christie * 1971a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers 1972a4804cd6SMike Christie * to add a host to the system. 1973a4804cd6SMike Christie */ 1974a4804cd6SMike Christie int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev) 19757996a778SMike Christie { 19768e9a20ceSMike Christie if (!shost->can_queue) 19778e9a20ceSMike Christie shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX; 19788e9a20ceSMike Christie 1979a4804cd6SMike Christie return scsi_add_host(shost, pdev); 1980a4804cd6SMike Christie } 1981a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_add); 1982a4804cd6SMike Christie 1983a4804cd6SMike Christie /** 1984a4804cd6SMike Christie * iscsi_host_alloc - allocate a host and driver data 1985a4804cd6SMike Christie * @sht: scsi host template 1986a4804cd6SMike Christie * @dd_data_size: driver host data size 1987a4804cd6SMike Christie * @qdepth: default device queue depth 1988a4804cd6SMike Christie * 1989a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers. 1990a4804cd6SMike Christie * To access the driver specific memory use the iscsi_host_priv() macro. 1991a4804cd6SMike Christie */ 1992a4804cd6SMike Christie struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht, 1993a4804cd6SMike Christie int dd_data_size, uint16_t qdepth) 1994a4804cd6SMike Christie { 1995a4804cd6SMike Christie struct Scsi_Host *shost; 1996e5bd7b54SMike Christie struct iscsi_host *ihost; 1997a4804cd6SMike Christie 1998a4804cd6SMike Christie shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size); 1999a4804cd6SMike Christie if (!shost) 2000a4804cd6SMike Christie return NULL; 2001a4804cd6SMike Christie shost->transportt->eh_timed_out = iscsi_eh_cmd_timed_out; 2002a4804cd6SMike Christie 20031548271eSMike Christie if (qdepth > ISCSI_MAX_CMD_PER_LUN || qdepth < 1) { 20041548271eSMike Christie if (qdepth != 0) 20051548271eSMike Christie printk(KERN_ERR "iscsi: invalid queue depth of %d. " 20061548271eSMike Christie "Queue depth must be between 1 and %d.\n", 20071548271eSMike Christie qdepth, ISCSI_MAX_CMD_PER_LUN); 20081548271eSMike Christie qdepth = ISCSI_DEF_CMD_PER_LUN; 20091548271eSMike Christie } 201075613521SMike Christie shost->cmd_per_lun = qdepth; 2011e5bd7b54SMike Christie 2012e5bd7b54SMike Christie ihost = shost_priv(shost); 2013e5bd7b54SMike Christie spin_lock_init(&ihost->lock); 2014e5bd7b54SMike Christie ihost->state = ISCSI_HOST_SETUP; 2015e5bd7b54SMike Christie ihost->num_sessions = 0; 2016e5bd7b54SMike Christie init_waitqueue_head(&ihost->session_removal_wq); 2017a4804cd6SMike Christie return shost; 201875613521SMike Christie } 2019a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_alloc); 202075613521SMike Christie 2021e5bd7b54SMike Christie static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session) 2022e5bd7b54SMike Christie { 2023e5bd7b54SMike Christie iscsi_session_failure(cls_session, ISCSI_ERR_INVALID_HOST); 2024e5bd7b54SMike Christie } 2025e5bd7b54SMike Christie 2026a4804cd6SMike Christie /** 2027a4804cd6SMike Christie * iscsi_host_remove - remove host and sessions 2028a4804cd6SMike Christie * @shost: scsi host 2029a4804cd6SMike Christie * 2030e5bd7b54SMike Christie * If there are any sessions left, this will initiate the removal and wait 2031e5bd7b54SMike Christie * for the completion. 2032a4804cd6SMike Christie */ 2033a4804cd6SMike Christie void iscsi_host_remove(struct Scsi_Host *shost) 2034a4804cd6SMike Christie { 2035e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2036e5bd7b54SMike Christie unsigned long flags; 2037e5bd7b54SMike Christie 2038e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2039e5bd7b54SMike Christie ihost->state = ISCSI_HOST_REMOVED; 2040e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2041e5bd7b54SMike Christie 2042e5bd7b54SMike Christie iscsi_host_for_each_session(shost, iscsi_notify_host_removed); 2043e5bd7b54SMike Christie wait_event_interruptible(ihost->session_removal_wq, 2044e5bd7b54SMike Christie ihost->num_sessions == 0); 2045e5bd7b54SMike Christie if (signal_pending(current)) 2046e5bd7b54SMike Christie flush_signals(current); 2047e5bd7b54SMike Christie 2048a4804cd6SMike Christie scsi_remove_host(shost); 2049a4804cd6SMike Christie } 2050a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_remove); 2051a4804cd6SMike Christie 2052a4804cd6SMike Christie void iscsi_host_free(struct Scsi_Host *shost) 205375613521SMike Christie { 205475613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 205575613521SMike Christie 205675613521SMike Christie kfree(ihost->netdev); 205775613521SMike Christie kfree(ihost->hwaddress); 205875613521SMike Christie kfree(ihost->initiatorname); 2059a4804cd6SMike Christie scsi_host_put(shost); 206075613521SMike Christie } 2061a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_free); 206275613521SMike Christie 2063e5bd7b54SMike Christie static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost) 2064e5bd7b54SMike Christie { 2065e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2066e5bd7b54SMike Christie unsigned long flags; 2067e5bd7b54SMike Christie 2068e5bd7b54SMike Christie shost = scsi_host_get(shost); 2069e5bd7b54SMike Christie if (!shost) { 2070e5bd7b54SMike Christie printk(KERN_ERR "Invalid state. Cannot notify host removal " 2071e5bd7b54SMike Christie "of session teardown event because host already " 2072e5bd7b54SMike Christie "removed.\n"); 2073e5bd7b54SMike Christie return; 2074e5bd7b54SMike Christie } 2075e5bd7b54SMike Christie 2076e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2077e5bd7b54SMike Christie ihost->num_sessions--; 2078e5bd7b54SMike Christie if (ihost->num_sessions == 0) 2079e5bd7b54SMike Christie wake_up(&ihost->session_removal_wq); 2080e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2081e5bd7b54SMike Christie scsi_host_put(shost); 2082e5bd7b54SMike Christie } 2083e5bd7b54SMike Christie 208475613521SMike Christie /** 208575613521SMike Christie * iscsi_session_setup - create iscsi cls session and host and session 208675613521SMike Christie * @iscsit: iscsi transport template 208775613521SMike Christie * @shost: scsi host 208875613521SMike Christie * @cmds_max: session can queue 20899c19a7d0SMike Christie * @cmd_task_size: LLD task private data size 209075613521SMike Christie * @initial_cmdsn: initial CmdSN 209175613521SMike Christie * 209275613521SMike Christie * This can be used by software iscsi_transports that allocate 209375613521SMike Christie * a session per scsi host. 20943cf7b233SMike Christie * 20953cf7b233SMike Christie * Callers should set cmds_max to the largest total numer (mgmt + scsi) of 20963cf7b233SMike Christie * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks 20973cf7b233SMike Christie * for nop handling and login/logout requests. 209875613521SMike Christie */ 209975613521SMike Christie struct iscsi_cls_session * 210075613521SMike Christie iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, 21013cf7b233SMike Christie uint16_t cmds_max, int cmd_task_size, 21027970634bSMike Christie uint32_t initial_cmdsn, unsigned int id) 210375613521SMike Christie { 2104e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 210575613521SMike Christie struct iscsi_session *session; 210675613521SMike Christie struct iscsi_cls_session *cls_session; 21073cf7b233SMike Christie int cmd_i, scsi_cmds, total_cmds = cmds_max; 2108e5bd7b54SMike Christie unsigned long flags; 2109e5bd7b54SMike Christie 2110e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2111e5bd7b54SMike Christie if (ihost->state == ISCSI_HOST_REMOVED) { 2112e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2113e5bd7b54SMike Christie return NULL; 2114e5bd7b54SMike Christie } 2115e5bd7b54SMike Christie ihost->num_sessions++; 2116e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 21178e9a20ceSMike Christie 21188e9a20ceSMike Christie if (!total_cmds) 21198e9a20ceSMike Christie total_cmds = ISCSI_DEF_XMIT_CMDS_MAX; 21203e5c28adSMike Christie /* 21213cf7b233SMike Christie * The iscsi layer needs some tasks for nop handling and tmfs, 21223cf7b233SMike Christie * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX 21233cf7b233SMike Christie * + 1 command for scsi IO. 21243e5c28adSMike Christie */ 21253cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 21263cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 21273cf7b233SMike Christie "must be a power of two that is at least %d.\n", 21283cf7b233SMike Christie total_cmds, ISCSI_TOTAL_CMDS_MIN); 2129e5bd7b54SMike Christie goto dec_session_count; 21301548271eSMike Christie } 21313cf7b233SMike Christie 21323cf7b233SMike Christie if (total_cmds > ISCSI_TOTAL_CMDS_MAX) { 21333cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 21343cf7b233SMike Christie "must be a power of 2 less than or equal to %d.\n", 21353cf7b233SMike Christie cmds_max, ISCSI_TOTAL_CMDS_MAX); 21363cf7b233SMike Christie total_cmds = ISCSI_TOTAL_CMDS_MAX; 21373cf7b233SMike Christie } 21383cf7b233SMike Christie 21393cf7b233SMike Christie if (!is_power_of_2(total_cmds)) { 21403cf7b233SMike Christie printk(KERN_ERR "iscsi: invalid can_queue of %d. can_queue " 21413cf7b233SMike Christie "must be a power of 2.\n", total_cmds); 21423cf7b233SMike Christie total_cmds = rounddown_pow_of_two(total_cmds); 21433cf7b233SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) 21443cf7b233SMike Christie return NULL; 21453cf7b233SMike Christie printk(KERN_INFO "iscsi: Rounding can_queue to %d.\n", 21463cf7b233SMike Christie total_cmds); 21473cf7b233SMike Christie } 21483cf7b233SMike Christie scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX; 21491548271eSMike Christie 21505d91e209SMike Christie cls_session = iscsi_alloc_session(shost, iscsit, 21515d91e209SMike Christie sizeof(struct iscsi_session)); 215275613521SMike Christie if (!cls_session) 2153e5bd7b54SMike Christie goto dec_session_count; 215475613521SMike Christie session = cls_session->dd_data; 215575613521SMike Christie session->cls_session = cls_session; 21567996a778SMike Christie session->host = shost; 21577996a778SMike Christie session->state = ISCSI_STATE_FREE; 2158f6d5180cSMike Christie session->fast_abort = 1; 21594cd49ea1SMike Christie session->lu_reset_timeout = 15; 21604cd49ea1SMike Christie session->abort_timeout = 10; 21613cf7b233SMike Christie session->scsi_cmds_max = scsi_cmds; 21623cf7b233SMike Christie session->cmds_max = total_cmds; 2163e0726407SMike Christie session->queued_cmdsn = session->cmdsn = initial_cmdsn; 21647996a778SMike Christie session->exp_cmdsn = initial_cmdsn + 1; 21657996a778SMike Christie session->max_cmdsn = initial_cmdsn + 1; 21667996a778SMike Christie session->max_r2t = 1; 21677996a778SMike Christie session->tt = iscsit; 21686724add1SMike Christie mutex_init(&session->eh_mutex); 216975613521SMike Christie spin_lock_init(&session->lock); 21707996a778SMike Christie 21717996a778SMike Christie /* initialize SCSI PDU commands pool */ 21727996a778SMike Christie if (iscsi_pool_init(&session->cmdpool, session->cmds_max, 21737996a778SMike Christie (void***)&session->cmds, 21749c19a7d0SMike Christie cmd_task_size + sizeof(struct iscsi_task))) 21757996a778SMike Christie goto cmdpool_alloc_fail; 21767996a778SMike Christie 21777996a778SMike Christie /* pre-format cmds pool with ITT */ 21787996a778SMike Christie for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) { 21799c19a7d0SMike Christie struct iscsi_task *task = session->cmds[cmd_i]; 21807996a778SMike Christie 21819c19a7d0SMike Christie if (cmd_task_size) 21829c19a7d0SMike Christie task->dd_data = &task[1]; 21839c19a7d0SMike Christie task->itt = cmd_i; 21849c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 21857996a778SMike Christie } 21867996a778SMike Christie 2187f53a88daSMike Christie if (!try_module_get(iscsit->owner)) 218875613521SMike Christie goto module_get_fail; 218975613521SMike Christie 21907970634bSMike Christie if (iscsi_add_session(cls_session, id)) 2191f53a88daSMike Christie goto cls_session_fail; 2192e5bd7b54SMike Christie 21937996a778SMike Christie return cls_session; 21947996a778SMike Christie 21957996a778SMike Christie cls_session_fail: 219675613521SMike Christie module_put(iscsit->owner); 219775613521SMike Christie module_get_fail: 21986320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 21997996a778SMike Christie cmdpool_alloc_fail: 220075613521SMike Christie iscsi_free_session(cls_session); 2201e5bd7b54SMike Christie dec_session_count: 2202e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 22037996a778SMike Christie return NULL; 22047996a778SMike Christie } 22057996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_setup); 22067996a778SMike Christie 22077996a778SMike Christie /** 22087996a778SMike Christie * iscsi_session_teardown - destroy session, host, and cls_session 220975613521SMike Christie * @cls_session: iscsi session 22107996a778SMike Christie * 221175613521SMike Christie * The driver must have called iscsi_remove_session before 221275613521SMike Christie * calling this. 221375613521SMike Christie */ 22147996a778SMike Christie void iscsi_session_teardown(struct iscsi_cls_session *cls_session) 22157996a778SMike Christie { 221675613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 221763f75cc8SMike Christie struct module *owner = cls_session->transport->owner; 2218e5bd7b54SMike Christie struct Scsi_Host *shost = session->host; 22197996a778SMike Christie 22206320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 22217996a778SMike Christie 2222b2c64167SMike Christie kfree(session->password); 2223b2c64167SMike Christie kfree(session->password_in); 2224b2c64167SMike Christie kfree(session->username); 2225b2c64167SMike Christie kfree(session->username_in); 2226f3ff0c36SMike Christie kfree(session->targetname); 222788dfd340SMike Christie kfree(session->initiatorname); 222888dfd340SMike Christie kfree(session->ifacename); 2229f3ff0c36SMike Christie 223075613521SMike Christie iscsi_destroy_session(cls_session); 2231e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 223263f75cc8SMike Christie module_put(owner); 22337996a778SMike Christie } 22347996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_teardown); 22357996a778SMike Christie 22367996a778SMike Christie /** 22377996a778SMike Christie * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn 22387996a778SMike Christie * @cls_session: iscsi_cls_session 22395d91e209SMike Christie * @dd_size: private driver data size 22407996a778SMike Christie * @conn_idx: cid 22415d91e209SMike Christie */ 22427996a778SMike Christie struct iscsi_cls_conn * 22435d91e209SMike Christie iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, 22445d91e209SMike Christie uint32_t conn_idx) 22457996a778SMike Christie { 224675613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 22477996a778SMike Christie struct iscsi_conn *conn; 22487996a778SMike Christie struct iscsi_cls_conn *cls_conn; 2249d36ab6f3SMike Christie char *data; 22507996a778SMike Christie 22515d91e209SMike Christie cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size, 22525d91e209SMike Christie conn_idx); 22537996a778SMike Christie if (!cls_conn) 22547996a778SMike Christie return NULL; 22557996a778SMike Christie conn = cls_conn->dd_data; 22565d91e209SMike Christie memset(conn, 0, sizeof(*conn) + dd_size); 22577996a778SMike Christie 22585d91e209SMike Christie conn->dd_data = cls_conn->dd_data + sizeof(*conn); 22597996a778SMike Christie conn->session = session; 22607996a778SMike Christie conn->cls_conn = cls_conn; 22617996a778SMike Christie conn->c_stage = ISCSI_CONN_INITIAL_STAGE; 22627996a778SMike Christie conn->id = conn_idx; 22637996a778SMike Christie conn->exp_statsn = 0; 2264843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2265f6d5180cSMike Christie 2266f6d5180cSMike Christie init_timer(&conn->transport_timer); 2267f6d5180cSMike Christie conn->transport_timer.data = (unsigned long)conn; 2268f6d5180cSMike Christie conn->transport_timer.function = iscsi_check_transport_timeouts; 2269f6d5180cSMike Christie 22707996a778SMike Christie INIT_LIST_HEAD(&conn->run_list); 22717996a778SMike Christie INIT_LIST_HEAD(&conn->mgmt_run_list); 2272843c0a8aSMike Christie INIT_LIST_HEAD(&conn->mgmtqueue); 2273b6c395edSMike Christie INIT_LIST_HEAD(&conn->xmitqueue); 2274843c0a8aSMike Christie INIT_LIST_HEAD(&conn->requeue); 2275c4028958SDavid Howells INIT_WORK(&conn->xmitwork, iscsi_xmitworker); 22767996a778SMike Christie 22779c19a7d0SMike Christie /* allocate login_task used for the login/text sequences */ 22787996a778SMike Christie spin_lock_bh(&session->lock); 22793e5c28adSMike Christie if (!__kfifo_get(session->cmdpool.queue, 22809c19a7d0SMike Christie (void*)&conn->login_task, 22817996a778SMike Christie sizeof(void*))) { 22827996a778SMike Christie spin_unlock_bh(&session->lock); 22839c19a7d0SMike Christie goto login_task_alloc_fail; 22847996a778SMike Christie } 22857996a778SMike Christie spin_unlock_bh(&session->lock); 22867996a778SMike Christie 2287cfeb2cf9SMike Christie data = (char *) __get_free_pages(GFP_KERNEL, 2288cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2289d36ab6f3SMike Christie if (!data) 22909c19a7d0SMike Christie goto login_task_data_alloc_fail; 22919c19a7d0SMike Christie conn->login_task->data = conn->data = data; 2292d36ab6f3SMike Christie 2293843c0a8aSMike Christie init_timer(&conn->tmf_timer); 22947996a778SMike Christie init_waitqueue_head(&conn->ehwait); 22957996a778SMike Christie 22967996a778SMike Christie return cls_conn; 22977996a778SMike Christie 22989c19a7d0SMike Christie login_task_data_alloc_fail: 22999c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task, 2300d36ab6f3SMike Christie sizeof(void*)); 23019c19a7d0SMike Christie login_task_alloc_fail: 23027996a778SMike Christie iscsi_destroy_conn(cls_conn); 23037996a778SMike Christie return NULL; 23047996a778SMike Christie } 23057996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_setup); 23067996a778SMike Christie 23077996a778SMike Christie /** 23087996a778SMike Christie * iscsi_conn_teardown - teardown iscsi connection 23097996a778SMike Christie * cls_conn: iscsi class connection 23107996a778SMike Christie * 23117996a778SMike Christie * TODO: we may need to make this into a two step process 23127996a778SMike Christie * like scsi-mls remove + put host 23137996a778SMike Christie */ 23147996a778SMike Christie void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) 23157996a778SMike Christie { 23167996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 23177996a778SMike Christie struct iscsi_session *session = conn->session; 23187996a778SMike Christie unsigned long flags; 23197996a778SMike Christie 2320f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 2321f6d5180cSMike Christie 23227996a778SMike Christie spin_lock_bh(&session->lock); 23237996a778SMike Christie conn->c_stage = ISCSI_CONN_CLEANUP_WAIT; 23247996a778SMike Christie if (session->leadconn == conn) { 23257996a778SMike Christie /* 23267996a778SMike Christie * leading connection? then give up on recovery. 23277996a778SMike Christie */ 23287996a778SMike Christie session->state = ISCSI_STATE_TERMINATE; 23297996a778SMike Christie wake_up(&conn->ehwait); 23307996a778SMike Christie } 23317996a778SMike Christie spin_unlock_bh(&session->lock); 23327996a778SMike Christie 23337996a778SMike Christie /* 23347996a778SMike Christie * Block until all in-progress commands for this connection 23357996a778SMike Christie * time out or fail. 23367996a778SMike Christie */ 23377996a778SMike Christie for (;;) { 23387996a778SMike Christie spin_lock_irqsave(session->host->host_lock, flags); 23397996a778SMike Christie if (!session->host->host_busy) { /* OK for ERL == 0 */ 23407996a778SMike Christie spin_unlock_irqrestore(session->host->host_lock, flags); 23417996a778SMike Christie break; 23427996a778SMike Christie } 23437996a778SMike Christie spin_unlock_irqrestore(session->host->host_lock, flags); 23447996a778SMike Christie msleep_interruptible(500); 2345322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "iscsi conn_destroy(): " 2346322d739dSMike Christie "host_busy %d host_failed %d\n", 2347322d739dSMike Christie session->host->host_busy, 2348be2df72eSOr Gerlitz session->host->host_failed); 23497996a778SMike Christie /* 23507996a778SMike Christie * force eh_abort() to unblock 23517996a778SMike Christie */ 23527996a778SMike Christie wake_up(&conn->ehwait); 23537996a778SMike Christie } 23547996a778SMike Christie 2355779ea120SMike Christie /* flush queued up work because we free the connection below */ 2356843c0a8aSMike Christie iscsi_suspend_tx(conn); 2357779ea120SMike Christie 23587996a778SMike Christie spin_lock_bh(&session->lock); 2359cfeb2cf9SMike Christie free_pages((unsigned long) conn->data, 2360cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 2361f3ff0c36SMike Christie kfree(conn->persistent_address); 23629c19a7d0SMike Christie __kfifo_put(session->cmdpool.queue, (void*)&conn->login_task, 23637996a778SMike Christie sizeof(void*)); 2364e0726407SMike Christie if (session->leadconn == conn) 23657996a778SMike Christie session->leadconn = NULL; 23667996a778SMike Christie spin_unlock_bh(&session->lock); 23677996a778SMike Christie 23687996a778SMike Christie iscsi_destroy_conn(cls_conn); 23697996a778SMike Christie } 23707996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_teardown); 23717996a778SMike Christie 23727996a778SMike Christie int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 23737996a778SMike Christie { 23747996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 23757996a778SMike Christie struct iscsi_session *session = conn->session; 23767996a778SMike Christie 2377ffd0436eSMike Christie if (!session) { 2378322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 2379322d739dSMike Christie "can't start unbound connection\n"); 23807996a778SMike Christie return -EPERM; 23817996a778SMike Christie } 23827996a778SMike Christie 2383db98ccdeSMike Christie if ((session->imm_data_en || !session->initial_r2t_en) && 2384db98ccdeSMike Christie session->first_burst > session->max_burst) { 2385322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: " 2386ffd0436eSMike Christie "first_burst %d max_burst %d\n", 2387ffd0436eSMike Christie session->first_burst, session->max_burst); 2388ffd0436eSMike Christie return -EINVAL; 2389ffd0436eSMike Christie } 2390ffd0436eSMike Christie 2391f6d5180cSMike Christie if (conn->ping_timeout && !conn->recv_timeout) { 2392322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of " 2393322d739dSMike Christie "zero. Using 5 seconds\n."); 2394f6d5180cSMike Christie conn->recv_timeout = 5; 2395f6d5180cSMike Christie } 2396f6d5180cSMike Christie 2397f6d5180cSMike Christie if (conn->recv_timeout && !conn->ping_timeout) { 2398322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of " 2399322d739dSMike Christie "zero. Using 5 seconds.\n"); 2400f6d5180cSMike Christie conn->ping_timeout = 5; 2401f6d5180cSMike Christie } 2402f6d5180cSMike Christie 24037996a778SMike Christie spin_lock_bh(&session->lock); 24047996a778SMike Christie conn->c_stage = ISCSI_CONN_STARTED; 24057996a778SMike Christie session->state = ISCSI_STATE_LOGGED_IN; 2406e0726407SMike Christie session->queued_cmdsn = session->cmdsn; 24077996a778SMike Christie 2408f6d5180cSMike Christie conn->last_recv = jiffies; 2409f6d5180cSMike Christie conn->last_ping = jiffies; 2410f6d5180cSMike Christie if (conn->recv_timeout && conn->ping_timeout) 2411f6d5180cSMike Christie mod_timer(&conn->transport_timer, 2412f6d5180cSMike Christie jiffies + (conn->recv_timeout * HZ)); 2413f6d5180cSMike Christie 24147996a778SMike Christie switch(conn->stop_stage) { 24157996a778SMike Christie case STOP_CONN_RECOVER: 24167996a778SMike Christie /* 24177996a778SMike Christie * unblock eh_abort() if it is blocked. re-try all 24187996a778SMike Christie * commands after successful recovery 24197996a778SMike Christie */ 24207996a778SMike Christie conn->stop_stage = 0; 2421843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 24227996a778SMike Christie session->age++; 24238b1d0343SMike Christie if (session->age == 16) 24248b1d0343SMike Christie session->age = 0; 24256eabafbeSMike Christie break; 24267996a778SMike Christie case STOP_CONN_TERM: 24277996a778SMike Christie conn->stop_stage = 0; 24287996a778SMike Christie break; 24297996a778SMike Christie default: 24307996a778SMike Christie break; 24317996a778SMike Christie } 24327996a778SMike Christie spin_unlock_bh(&session->lock); 24337996a778SMike Christie 243475613521SMike Christie iscsi_unblock_session(session->cls_session); 24356eabafbeSMike Christie wake_up(&conn->ehwait); 24367996a778SMike Christie return 0; 24377996a778SMike Christie } 24387996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_start); 24397996a778SMike Christie 24407996a778SMike Christie static void 24417996a778SMike Christie flush_control_queues(struct iscsi_session *session, struct iscsi_conn *conn) 24427996a778SMike Christie { 24439c19a7d0SMike Christie struct iscsi_task *task, *tmp; 24447996a778SMike Christie 24457996a778SMike Christie /* handle pending */ 24469c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->mgmtqueue, running) { 24479c19a7d0SMike Christie debug_scsi("flushing pending mgmt task itt 0x%x\n", task->itt); 24489c19a7d0SMike Christie /* release ref from prep task */ 24499c19a7d0SMike Christie __iscsi_put_task(task); 24507996a778SMike Christie } 24517996a778SMike Christie 24527996a778SMike Christie /* handle running */ 24539c19a7d0SMike Christie list_for_each_entry_safe(task, tmp, &conn->mgmt_run_list, running) { 24549c19a7d0SMike Christie debug_scsi("flushing running mgmt task itt 0x%x\n", task->itt); 24559c19a7d0SMike Christie /* release ref from prep task */ 24569c19a7d0SMike Christie __iscsi_put_task(task); 24577996a778SMike Christie } 24587996a778SMike Christie 24599c19a7d0SMike Christie conn->task = NULL; 24607996a778SMike Christie } 24617996a778SMike Christie 2462656cffc9SMike Christie static void iscsi_start_session_recovery(struct iscsi_session *session, 24637996a778SMike Christie struct iscsi_conn *conn, int flag) 24647996a778SMike Christie { 2465ed2abc7fSMike Christie int old_stop_stage; 2466ed2abc7fSMike Christie 2467f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 2468f6d5180cSMike Christie 24696724add1SMike Christie mutex_lock(&session->eh_mutex); 24707996a778SMike Christie spin_lock_bh(&session->lock); 2471ed2abc7fSMike Christie if (conn->stop_stage == STOP_CONN_TERM) { 24727996a778SMike Christie spin_unlock_bh(&session->lock); 24736724add1SMike Christie mutex_unlock(&session->eh_mutex); 24746724add1SMike Christie return; 24756724add1SMike Christie } 24766724add1SMike Christie 24776724add1SMike Christie /* 2478ed2abc7fSMike Christie * When this is called for the in_login state, we only want to clean 24799c19a7d0SMike Christie * up the login task and connection. We do not need to block and set 248067a61114SMike Christie * the recovery state again 2481ed2abc7fSMike Christie */ 248267a61114SMike Christie if (flag == STOP_CONN_TERM) 248367a61114SMike Christie session->state = ISCSI_STATE_TERMINATE; 248467a61114SMike Christie else if (conn->stop_stage != STOP_CONN_RECOVER) 248567a61114SMike Christie session->state = ISCSI_STATE_IN_RECOVERY; 2486ed2abc7fSMike Christie 2487ed2abc7fSMike Christie old_stop_stage = conn->stop_stage; 24887996a778SMike Christie conn->stop_stage = flag; 248967a61114SMike Christie conn->c_stage = ISCSI_CONN_STOPPED; 24907996a778SMike Christie spin_unlock_bh(&session->lock); 24916724add1SMike Christie 24926724add1SMike Christie iscsi_suspend_tx(conn); 24937996a778SMike Christie /* 24947996a778SMike Christie * for connection level recovery we should not calculate 24957996a778SMike Christie * header digest. conn->hdr_size used for optimization 24967996a778SMike Christie * in hdr_extract() and will be re-negotiated at 24977996a778SMike Christie * set_param() time. 24987996a778SMike Christie */ 24997996a778SMike Christie if (flag == STOP_CONN_RECOVER) { 25007996a778SMike Christie conn->hdrdgst_en = 0; 25017996a778SMike Christie conn->datadgst_en = 0; 2502656cffc9SMike Christie if (session->state == ISCSI_STATE_IN_RECOVERY && 250367a61114SMike Christie old_stop_stage != STOP_CONN_RECOVER) { 250467a61114SMike Christie debug_scsi("blocking session\n"); 250575613521SMike Christie iscsi_block_session(session->cls_session); 25067996a778SMike Christie } 250767a61114SMike Christie } 2508656cffc9SMike Christie 2509656cffc9SMike Christie /* 2510656cffc9SMike Christie * flush queues. 2511656cffc9SMike Christie */ 2512656cffc9SMike Christie spin_lock_bh(&session->lock); 251387cd9eabSMike Christie if (flag == STOP_CONN_RECOVER) 251456d7fcfaSMike Christie fail_all_commands(conn, -1, DID_TRANSPORT_DISRUPTED); 251556d7fcfaSMike Christie else 251656d7fcfaSMike Christie fail_all_commands(conn, -1, DID_ERROR); 2517656cffc9SMike Christie flush_control_queues(session, conn); 2518656cffc9SMike Christie spin_unlock_bh(&session->lock); 25196724add1SMike Christie mutex_unlock(&session->eh_mutex); 25207996a778SMike Christie } 25217996a778SMike Christie 25227996a778SMike Christie void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 25237996a778SMike Christie { 25247996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 25257996a778SMike Christie struct iscsi_session *session = conn->session; 25267996a778SMike Christie 25277996a778SMike Christie switch (flag) { 25287996a778SMike Christie case STOP_CONN_RECOVER: 25297996a778SMike Christie case STOP_CONN_TERM: 25307996a778SMike Christie iscsi_start_session_recovery(session, conn, flag); 25318d2860b3SMike Christie break; 25327996a778SMike Christie default: 2533322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 2534322d739dSMike Christie "invalid stop flag %d\n", flag); 25357996a778SMike Christie } 25367996a778SMike Christie } 25377996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_stop); 25387996a778SMike Christie 25397996a778SMike Christie int iscsi_conn_bind(struct iscsi_cls_session *cls_session, 25407996a778SMike Christie struct iscsi_cls_conn *cls_conn, int is_leading) 25417996a778SMike Christie { 254275613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 254398644047SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 25447996a778SMike Christie 25457996a778SMike Christie spin_lock_bh(&session->lock); 25467996a778SMike Christie if (is_leading) 25477996a778SMike Christie session->leadconn = conn; 254898644047SMike Christie spin_unlock_bh(&session->lock); 25497996a778SMike Christie 25507996a778SMike Christie /* 25517996a778SMike Christie * Unblock xmitworker(), Login Phase will pass through. 25527996a778SMike Christie */ 25537996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 25547996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 25557996a778SMike Christie return 0; 25567996a778SMike Christie } 25577996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_bind); 25587996a778SMike Christie 2559a54a52caSMike Christie 2560a54a52caSMike Christie int iscsi_set_param(struct iscsi_cls_conn *cls_conn, 2561a54a52caSMike Christie enum iscsi_param param, char *buf, int buflen) 2562a54a52caSMike Christie { 2563a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 2564a54a52caSMike Christie struct iscsi_session *session = conn->session; 2565a54a52caSMike Christie uint32_t value; 2566a54a52caSMike Christie 2567a54a52caSMike Christie switch(param) { 2568843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 2569843c0a8aSMike Christie sscanf(buf, "%d", &session->fast_abort); 2570843c0a8aSMike Christie break; 2571f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 2572f6d5180cSMike Christie sscanf(buf, "%d", &session->abort_timeout); 2573f6d5180cSMike Christie break; 2574f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 2575f6d5180cSMike Christie sscanf(buf, "%d", &session->lu_reset_timeout); 2576f6d5180cSMike Christie break; 2577f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 2578f6d5180cSMike Christie sscanf(buf, "%d", &conn->ping_timeout); 2579f6d5180cSMike Christie break; 2580f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 2581f6d5180cSMike Christie sscanf(buf, "%d", &conn->recv_timeout); 2582f6d5180cSMike Christie break; 2583a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 2584a54a52caSMike Christie sscanf(buf, "%d", &conn->max_recv_dlength); 2585a54a52caSMike Christie break; 2586a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 2587a54a52caSMike Christie sscanf(buf, "%d", &conn->max_xmit_dlength); 2588a54a52caSMike Christie break; 2589a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 2590a54a52caSMike Christie sscanf(buf, "%d", &conn->hdrdgst_en); 2591a54a52caSMike Christie break; 2592a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 2593a54a52caSMike Christie sscanf(buf, "%d", &conn->datadgst_en); 2594a54a52caSMike Christie break; 2595a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 2596a54a52caSMike Christie sscanf(buf, "%d", &session->initial_r2t_en); 2597a54a52caSMike Christie break; 2598a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 2599a54a52caSMike Christie sscanf(buf, "%d", &session->max_r2t); 2600a54a52caSMike Christie break; 2601a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 2602a54a52caSMike Christie sscanf(buf, "%d", &session->imm_data_en); 2603a54a52caSMike Christie break; 2604a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 2605a54a52caSMike Christie sscanf(buf, "%d", &session->first_burst); 2606a54a52caSMike Christie break; 2607a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 2608a54a52caSMike Christie sscanf(buf, "%d", &session->max_burst); 2609a54a52caSMike Christie break; 2610a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 2611a54a52caSMike Christie sscanf(buf, "%d", &session->pdu_inorder_en); 2612a54a52caSMike Christie break; 2613a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 2614a54a52caSMike Christie sscanf(buf, "%d", &session->dataseq_inorder_en); 2615a54a52caSMike Christie break; 2616a54a52caSMike Christie case ISCSI_PARAM_ERL: 2617a54a52caSMike Christie sscanf(buf, "%d", &session->erl); 2618a54a52caSMike Christie break; 2619a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 2620a54a52caSMike Christie sscanf(buf, "%d", &value); 2621a54a52caSMike Christie BUG_ON(value); 2622a54a52caSMike Christie break; 2623a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 2624a54a52caSMike Christie sscanf(buf, "%d", &value); 2625a54a52caSMike Christie BUG_ON(value); 2626a54a52caSMike Christie break; 2627a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 2628a54a52caSMike Christie sscanf(buf, "%u", &conn->exp_statsn); 2629a54a52caSMike Christie break; 2630b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 2631b2c64167SMike Christie kfree(session->username); 2632b2c64167SMike Christie session->username = kstrdup(buf, GFP_KERNEL); 2633b2c64167SMike Christie if (!session->username) 2634b2c64167SMike Christie return -ENOMEM; 2635b2c64167SMike Christie break; 2636b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 2637b2c64167SMike Christie kfree(session->username_in); 2638b2c64167SMike Christie session->username_in = kstrdup(buf, GFP_KERNEL); 2639b2c64167SMike Christie if (!session->username_in) 2640b2c64167SMike Christie return -ENOMEM; 2641b2c64167SMike Christie break; 2642b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 2643b2c64167SMike Christie kfree(session->password); 2644b2c64167SMike Christie session->password = kstrdup(buf, GFP_KERNEL); 2645b2c64167SMike Christie if (!session->password) 2646b2c64167SMike Christie return -ENOMEM; 2647b2c64167SMike Christie break; 2648b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 2649b2c64167SMike Christie kfree(session->password_in); 2650b2c64167SMike Christie session->password_in = kstrdup(buf, GFP_KERNEL); 2651b2c64167SMike Christie if (!session->password_in) 2652b2c64167SMike Christie return -ENOMEM; 2653b2c64167SMike Christie break; 2654a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 2655a54a52caSMike Christie /* this should not change between logins */ 2656a54a52caSMike Christie if (session->targetname) 2657a54a52caSMike Christie break; 2658a54a52caSMike Christie 2659a54a52caSMike Christie session->targetname = kstrdup(buf, GFP_KERNEL); 2660a54a52caSMike Christie if (!session->targetname) 2661a54a52caSMike Christie return -ENOMEM; 2662a54a52caSMike Christie break; 2663a54a52caSMike Christie case ISCSI_PARAM_TPGT: 2664a54a52caSMike Christie sscanf(buf, "%d", &session->tpgt); 2665a54a52caSMike Christie break; 2666a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 2667a54a52caSMike Christie sscanf(buf, "%d", &conn->persistent_port); 2668a54a52caSMike Christie break; 2669a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 2670a54a52caSMike Christie /* 2671a54a52caSMike Christie * this is the address returned in discovery so it should 2672a54a52caSMike Christie * not change between logins. 2673a54a52caSMike Christie */ 2674a54a52caSMike Christie if (conn->persistent_address) 2675a54a52caSMike Christie break; 2676a54a52caSMike Christie 2677a54a52caSMike Christie conn->persistent_address = kstrdup(buf, GFP_KERNEL); 2678a54a52caSMike Christie if (!conn->persistent_address) 2679a54a52caSMike Christie return -ENOMEM; 2680a54a52caSMike Christie break; 268188dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 268288dfd340SMike Christie if (!session->ifacename) 268388dfd340SMike Christie session->ifacename = kstrdup(buf, GFP_KERNEL); 268488dfd340SMike Christie break; 268588dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 268688dfd340SMike Christie if (!session->initiatorname) 268788dfd340SMike Christie session->initiatorname = kstrdup(buf, GFP_KERNEL); 268888dfd340SMike Christie break; 2689a54a52caSMike Christie default: 2690a54a52caSMike Christie return -ENOSYS; 2691a54a52caSMike Christie } 2692a54a52caSMike Christie 2693a54a52caSMike Christie return 0; 2694a54a52caSMike Christie } 2695a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_set_param); 2696a54a52caSMike Christie 2697a54a52caSMike Christie int iscsi_session_get_param(struct iscsi_cls_session *cls_session, 2698a54a52caSMike Christie enum iscsi_param param, char *buf) 2699a54a52caSMike Christie { 270075613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 2701a54a52caSMike Christie int len; 2702a54a52caSMike Christie 2703a54a52caSMike Christie switch(param) { 2704843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 2705843c0a8aSMike Christie len = sprintf(buf, "%d\n", session->fast_abort); 2706843c0a8aSMike Christie break; 2707f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 2708f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->abort_timeout); 2709f6d5180cSMike Christie break; 2710f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 2711f6d5180cSMike Christie len = sprintf(buf, "%d\n", session->lu_reset_timeout); 2712f6d5180cSMike Christie break; 2713a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 2714a54a52caSMike Christie len = sprintf(buf, "%d\n", session->initial_r2t_en); 2715a54a52caSMike Christie break; 2716a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 2717a54a52caSMike Christie len = sprintf(buf, "%hu\n", session->max_r2t); 2718a54a52caSMike Christie break; 2719a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 2720a54a52caSMike Christie len = sprintf(buf, "%d\n", session->imm_data_en); 2721a54a52caSMike Christie break; 2722a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 2723a54a52caSMike Christie len = sprintf(buf, "%u\n", session->first_burst); 2724a54a52caSMike Christie break; 2725a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 2726a54a52caSMike Christie len = sprintf(buf, "%u\n", session->max_burst); 2727a54a52caSMike Christie break; 2728a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 2729a54a52caSMike Christie len = sprintf(buf, "%d\n", session->pdu_inorder_en); 2730a54a52caSMike Christie break; 2731a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 2732a54a52caSMike Christie len = sprintf(buf, "%d\n", session->dataseq_inorder_en); 2733a54a52caSMike Christie break; 2734a54a52caSMike Christie case ISCSI_PARAM_ERL: 2735a54a52caSMike Christie len = sprintf(buf, "%d\n", session->erl); 2736a54a52caSMike Christie break; 2737a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 2738a54a52caSMike Christie len = sprintf(buf, "%s\n", session->targetname); 2739a54a52caSMike Christie break; 2740a54a52caSMike Christie case ISCSI_PARAM_TPGT: 2741a54a52caSMike Christie len = sprintf(buf, "%d\n", session->tpgt); 2742a54a52caSMike Christie break; 2743b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 2744b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username); 2745b2c64167SMike Christie break; 2746b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 2747b2c64167SMike Christie len = sprintf(buf, "%s\n", session->username_in); 2748b2c64167SMike Christie break; 2749b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 2750b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password); 2751b2c64167SMike Christie break; 2752b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 2753b2c64167SMike Christie len = sprintf(buf, "%s\n", session->password_in); 2754b2c64167SMike Christie break; 275588dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 275688dfd340SMike Christie len = sprintf(buf, "%s\n", session->ifacename); 275788dfd340SMike Christie break; 275888dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 275988dfd340SMike Christie if (!session->initiatorname) 276088dfd340SMike Christie len = sprintf(buf, "%s\n", "unknown"); 276188dfd340SMike Christie else 276288dfd340SMike Christie len = sprintf(buf, "%s\n", session->initiatorname); 276388dfd340SMike Christie break; 2764a54a52caSMike Christie default: 2765a54a52caSMike Christie return -ENOSYS; 2766a54a52caSMike Christie } 2767a54a52caSMike Christie 2768a54a52caSMike Christie return len; 2769a54a52caSMike Christie } 2770a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_get_param); 2771a54a52caSMike Christie 2772a54a52caSMike Christie int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, 2773a54a52caSMike Christie enum iscsi_param param, char *buf) 2774a54a52caSMike Christie { 2775a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 2776a54a52caSMike Christie int len; 2777a54a52caSMike Christie 2778a54a52caSMike Christie switch(param) { 2779f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 2780f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->ping_timeout); 2781f6d5180cSMike Christie break; 2782f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 2783f6d5180cSMike Christie len = sprintf(buf, "%u\n", conn->recv_timeout); 2784f6d5180cSMike Christie break; 2785a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 2786a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_recv_dlength); 2787a54a52caSMike Christie break; 2788a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 2789a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->max_xmit_dlength); 2790a54a52caSMike Christie break; 2791a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 2792a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->hdrdgst_en); 2793a54a52caSMike Christie break; 2794a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 2795a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->datadgst_en); 2796a54a52caSMike Christie break; 2797a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 2798a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ifmarker_en); 2799a54a52caSMike Christie break; 2800a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 2801a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->ofmarker_en); 2802a54a52caSMike Christie break; 2803a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 2804a54a52caSMike Christie len = sprintf(buf, "%u\n", conn->exp_statsn); 2805a54a52caSMike Christie break; 2806a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 2807a54a52caSMike Christie len = sprintf(buf, "%d\n", conn->persistent_port); 2808a54a52caSMike Christie break; 2809a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 2810a54a52caSMike Christie len = sprintf(buf, "%s\n", conn->persistent_address); 2811a54a52caSMike Christie break; 2812a54a52caSMike Christie default: 2813a54a52caSMike Christie return -ENOSYS; 2814a54a52caSMike Christie } 2815a54a52caSMike Christie 2816a54a52caSMike Christie return len; 2817a54a52caSMike Christie } 2818a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_param); 2819a54a52caSMike Christie 28200801c242SMike Christie int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param, 28210801c242SMike Christie char *buf) 28220801c242SMike Christie { 282375613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 28240801c242SMike Christie int len; 28250801c242SMike Christie 28260801c242SMike Christie switch (param) { 2827d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 282875613521SMike Christie if (!ihost->netdev) 2829d8196ed2SMike Christie len = sprintf(buf, "%s\n", "default"); 2830d8196ed2SMike Christie else 283175613521SMike Christie len = sprintf(buf, "%s\n", ihost->netdev); 2832d8196ed2SMike Christie break; 28330801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 283475613521SMike Christie if (!ihost->hwaddress) 28350801c242SMike Christie len = sprintf(buf, "%s\n", "default"); 28360801c242SMike Christie else 283775613521SMike Christie len = sprintf(buf, "%s\n", ihost->hwaddress); 28380801c242SMike Christie break; 28398ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 284075613521SMike Christie if (!ihost->initiatorname) 28418ad5781aSMike Christie len = sprintf(buf, "%s\n", "unknown"); 28428ad5781aSMike Christie else 284375613521SMike Christie len = sprintf(buf, "%s\n", ihost->initiatorname); 28448ad5781aSMike Christie break; 284575613521SMike Christie case ISCSI_HOST_PARAM_IPADDRESS: 284675613521SMike Christie if (!strlen(ihost->local_address)) 284775613521SMike Christie len = sprintf(buf, "%s\n", "unknown"); 284875613521SMike Christie else 284975613521SMike Christie len = sprintf(buf, "%s\n", 285075613521SMike Christie ihost->local_address); 285188dfd340SMike Christie break; 28520801c242SMike Christie default: 28530801c242SMike Christie return -ENOSYS; 28540801c242SMike Christie } 28550801c242SMike Christie 28560801c242SMike Christie return len; 28570801c242SMike Christie } 28580801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_param); 28590801c242SMike Christie 28600801c242SMike Christie int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param, 28610801c242SMike Christie char *buf, int buflen) 28620801c242SMike Christie { 286375613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 28640801c242SMike Christie 28650801c242SMike Christie switch (param) { 2866d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 286775613521SMike Christie if (!ihost->netdev) 286875613521SMike Christie ihost->netdev = kstrdup(buf, GFP_KERNEL); 2869d8196ed2SMike Christie break; 28700801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 287175613521SMike Christie if (!ihost->hwaddress) 287275613521SMike Christie ihost->hwaddress = kstrdup(buf, GFP_KERNEL); 28730801c242SMike Christie break; 28748ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 287575613521SMike Christie if (!ihost->initiatorname) 287675613521SMike Christie ihost->initiatorname = kstrdup(buf, GFP_KERNEL); 28778ad5781aSMike Christie break; 28780801c242SMike Christie default: 28790801c242SMike Christie return -ENOSYS; 28800801c242SMike Christie } 28810801c242SMike Christie 28820801c242SMike Christie return 0; 28830801c242SMike Christie } 28840801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_set_param); 28850801c242SMike Christie 28867996a778SMike Christie MODULE_AUTHOR("Mike Christie"); 28877996a778SMike Christie MODULE_DESCRIPTION("iSCSI library functions"); 28887996a778SMike Christie MODULE_LICENSE("GPL"); 2889