11a59d1b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later 27996a778SMike Christie /* 37996a778SMike Christie * iSCSI lib functions 47996a778SMike Christie * 57996a778SMike Christie * Copyright (C) 2006 Red Hat, Inc. All rights reserved. 67996a778SMike Christie * Copyright (C) 2004 - 2006 Mike Christie 77996a778SMike Christie * Copyright (C) 2004 - 2005 Dmitry Yusupov 87996a778SMike Christie * Copyright (C) 2004 - 2005 Alex Aizman 97996a778SMike Christie * maintained by open-iscsi@googlegroups.com 107996a778SMike Christie */ 117996a778SMike Christie #include <linux/types.h> 127996a778SMike Christie #include <linux/kfifo.h> 137996a778SMike Christie #include <linux/delay.h> 1411836572Svignesh babu #include <linux/log2.h> 155a0e3ad6STejun Heo #include <linux/slab.h> 163f07c014SIngo Molnar #include <linux/sched/signal.h> 17acf3368fSPaul Gortmaker #include <linux/module.h> 188eb00539SMike Christie #include <asm/unaligned.h> 197996a778SMike Christie #include <net/tcp.h> 207996a778SMike Christie #include <scsi/scsi_cmnd.h> 217996a778SMike Christie #include <scsi/scsi_device.h> 227996a778SMike Christie #include <scsi/scsi_eh.h> 237996a778SMike Christie #include <scsi/scsi_tcq.h> 247996a778SMike Christie #include <scsi/scsi_host.h> 257996a778SMike Christie #include <scsi/scsi.h> 267996a778SMike Christie #include <scsi/iscsi_proto.h> 277996a778SMike Christie #include <scsi/scsi_transport.h> 287996a778SMike Christie #include <scsi/scsi_transport_iscsi.h> 297996a778SMike Christie #include <scsi/libiscsi.h> 30c2332b00SFred Herard #include <trace/events/iscsi.h> 317996a778SMike Christie 32bd2199d4SErez Zilber static int iscsi_dbg_lib_conn; 33bd2199d4SErez Zilber module_param_named(debug_libiscsi_conn, iscsi_dbg_lib_conn, int, 34bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 35bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_conn, 36bd2199d4SErez Zilber "Turn on debugging for connections in libiscsi module. " 37bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 38bd2199d4SErez Zilber 39bd2199d4SErez Zilber static int iscsi_dbg_lib_session; 40bd2199d4SErez Zilber module_param_named(debug_libiscsi_session, iscsi_dbg_lib_session, int, 41bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 42bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_session, 43bd2199d4SErez Zilber "Turn on debugging for sessions in libiscsi module. " 44bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 45bd2199d4SErez Zilber 46bd2199d4SErez Zilber static int iscsi_dbg_lib_eh; 47bd2199d4SErez Zilber module_param_named(debug_libiscsi_eh, iscsi_dbg_lib_eh, int, 48bd2199d4SErez Zilber S_IRUGO | S_IWUSR); 49bd2199d4SErez Zilber MODULE_PARM_DESC(debug_libiscsi_eh, 50bd2199d4SErez Zilber "Turn on debugging for error handling in libiscsi module. " 51bd2199d4SErez Zilber "Set to 1 to turn on, and zero to turn off. Default is off."); 521b2c7af8SMike Christie 531b2c7af8SMike Christie #define ISCSI_DBG_CONN(_conn, dbg_fmt, arg...) \ 541b2c7af8SMike Christie do { \ 55bd2199d4SErez Zilber if (iscsi_dbg_lib_conn) \ 561b2c7af8SMike Christie iscsi_conn_printk(KERN_INFO, _conn, \ 571b2c7af8SMike Christie "%s " dbg_fmt, \ 581b2c7af8SMike Christie __func__, ##arg); \ 59c2332b00SFred Herard iscsi_dbg_trace(trace_iscsi_dbg_conn, \ 60c2332b00SFred Herard &(_conn)->cls_conn->dev, \ 61c2332b00SFred Herard "%s " dbg_fmt, __func__, ##arg);\ 621b2c7af8SMike Christie } while (0); 631b2c7af8SMike Christie 641b2c7af8SMike Christie #define ISCSI_DBG_SESSION(_session, dbg_fmt, arg...) \ 651b2c7af8SMike Christie do { \ 66bd2199d4SErez Zilber if (iscsi_dbg_lib_session) \ 67bd2199d4SErez Zilber iscsi_session_printk(KERN_INFO, _session, \ 68bd2199d4SErez Zilber "%s " dbg_fmt, \ 69bd2199d4SErez Zilber __func__, ##arg); \ 70c2332b00SFred Herard iscsi_dbg_trace(trace_iscsi_dbg_session, \ 71c2332b00SFred Herard &(_session)->cls_session->dev, \ 72c2332b00SFred Herard "%s " dbg_fmt, __func__, ##arg); \ 73bd2199d4SErez Zilber } while (0); 74bd2199d4SErez Zilber 75bd2199d4SErez Zilber #define ISCSI_DBG_EH(_session, dbg_fmt, arg...) \ 76bd2199d4SErez Zilber do { \ 77bd2199d4SErez Zilber if (iscsi_dbg_lib_eh) \ 781b2c7af8SMike Christie iscsi_session_printk(KERN_INFO, _session, \ 791b2c7af8SMike Christie "%s " dbg_fmt, \ 801b2c7af8SMike Christie __func__, ##arg); \ 81c2332b00SFred Herard iscsi_dbg_trace(trace_iscsi_dbg_eh, \ 82c2332b00SFred Herard &(_session)->cls_session->dev, \ 83c2332b00SFred Herard "%s " dbg_fmt, __func__, ##arg); \ 841b2c7af8SMike Christie } while (0); 851b2c7af8SMike Christie 8632ae763eSMike Christie inline void iscsi_conn_queue_work(struct iscsi_conn *conn) 8732ae763eSMike Christie { 8832ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 8932ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 9032ae763eSMike Christie 911336aed1SMike Christie if (ihost->workq) 9232ae763eSMike Christie queue_work(ihost->workq, &conn->xmitwork); 9332ae763eSMike Christie } 9432ae763eSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_queue_work); 9532ae763eSMike Christie 964c0ba5d2SMike Christie static void __iscsi_update_cmdsn(struct iscsi_session *session, 974c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 987996a778SMike Christie { 9977a23c21SMike Christie /* 10077a23c21SMike Christie * standard specifies this check for when to update expected and 10177a23c21SMike Christie * max sequence numbers 10277a23c21SMike Christie */ 10377a23c21SMike Christie if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1)) 10477a23c21SMike Christie return; 10577a23c21SMike Christie 10677a23c21SMike Christie if (exp_cmdsn != session->exp_cmdsn && 10777a23c21SMike Christie !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn)) 1087996a778SMike Christie session->exp_cmdsn = exp_cmdsn; 1097996a778SMike Christie 11077a23c21SMike Christie if (max_cmdsn != session->max_cmdsn && 11146a84c65SMike Christie !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) 11277a23c21SMike Christie session->max_cmdsn = max_cmdsn; 11377a23c21SMike Christie } 1144c0ba5d2SMike Christie 1154c0ba5d2SMike Christie void iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr) 1164c0ba5d2SMike Christie { 1174c0ba5d2SMike Christie __iscsi_update_cmdsn(session, be32_to_cpu(hdr->exp_cmdsn), 1184c0ba5d2SMike Christie be32_to_cpu(hdr->max_cmdsn)); 1194c0ba5d2SMike Christie } 12077a23c21SMike Christie EXPORT_SYMBOL_GPL(iscsi_update_cmdsn); 1217996a778SMike Christie 122577577daSMike Christie /** 123577577daSMike Christie * iscsi_prep_data_out_pdu - initialize Data-Out 124577577daSMike Christie * @task: scsi command task 125577577daSMike Christie * @r2t: R2T info 126577577daSMike Christie * @hdr: iscsi data in pdu 127577577daSMike Christie * 128577577daSMike Christie * Notes: 129577577daSMike Christie * Initialize Data-Out within this R2T sequence and finds 130577577daSMike Christie * proper data_offset within this SCSI command. 131577577daSMike Christie * 132577577daSMike Christie * This function is called with connection lock taken. 133577577daSMike Christie **/ 134577577daSMike Christie void iscsi_prep_data_out_pdu(struct iscsi_task *task, struct iscsi_r2t_info *r2t, 135ffd0436eSMike Christie struct iscsi_data *hdr) 1367996a778SMike Christie { 1379c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 138577577daSMike Christie unsigned int left = r2t->data_length - r2t->sent; 139577577daSMike Christie 140577577daSMike Christie task->hdr_len = sizeof(struct iscsi_data); 1417996a778SMike Christie 1427996a778SMike Christie memset(hdr, 0, sizeof(struct iscsi_data)); 143577577daSMike Christie hdr->ttt = r2t->ttt; 144577577daSMike Christie hdr->datasn = cpu_to_be32(r2t->datasn); 145577577daSMike Christie r2t->datasn++; 1467996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_DATA_OUT; 14755bdabdfSAndy Grover hdr->lun = task->lun; 148577577daSMike Christie hdr->itt = task->hdr_itt; 149577577daSMike Christie hdr->exp_statsn = r2t->exp_statsn; 150577577daSMike Christie hdr->offset = cpu_to_be32(r2t->data_offset + r2t->sent); 151577577daSMike Christie if (left > conn->max_xmit_dlength) { 1527996a778SMike Christie hton24(hdr->dlength, conn->max_xmit_dlength); 153577577daSMike Christie r2t->data_count = conn->max_xmit_dlength; 1547996a778SMike Christie hdr->flags = 0; 1557996a778SMike Christie } else { 156577577daSMike Christie hton24(hdr->dlength, left); 157577577daSMike Christie r2t->data_count = left; 1587996a778SMike Christie hdr->flags = ISCSI_FLAG_CMD_FINAL; 1597996a778SMike Christie } 160577577daSMike Christie conn->dataout_pdus_cnt++; 1617996a778SMike Christie } 162577577daSMike Christie EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu); 1637996a778SMike Christie 1649c19a7d0SMike Christie static int iscsi_add_hdr(struct iscsi_task *task, unsigned len) 165004d6530SBoaz Harrosh { 1669c19a7d0SMike Christie unsigned exp_len = task->hdr_len + len; 167004d6530SBoaz Harrosh 1689c19a7d0SMike Christie if (exp_len > task->hdr_max) { 169004d6530SBoaz Harrosh WARN_ON(1); 170004d6530SBoaz Harrosh return -EINVAL; 171004d6530SBoaz Harrosh } 172004d6530SBoaz Harrosh 173004d6530SBoaz Harrosh WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */ 1749c19a7d0SMike Christie task->hdr_len = exp_len; 175004d6530SBoaz Harrosh return 0; 176004d6530SBoaz Harrosh } 177004d6530SBoaz Harrosh 17838d1c069SBoaz Harrosh /* 17938d1c069SBoaz Harrosh * make an extended cdb AHS 18038d1c069SBoaz Harrosh */ 1819c19a7d0SMike Christie static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) 18238d1c069SBoaz Harrosh { 1839c19a7d0SMike Christie struct scsi_cmnd *cmd = task->sc; 18438d1c069SBoaz Harrosh unsigned rlen, pad_len; 18538d1c069SBoaz Harrosh unsigned short ahslength; 18638d1c069SBoaz Harrosh struct iscsi_ecdb_ahdr *ecdb_ahdr; 18738d1c069SBoaz Harrosh int rc; 18838d1c069SBoaz Harrosh 1899c19a7d0SMike Christie ecdb_ahdr = iscsi_next_hdr(task); 19038d1c069SBoaz Harrosh rlen = cmd->cmd_len - ISCSI_CDB_SIZE; 19138d1c069SBoaz Harrosh 19238d1c069SBoaz Harrosh BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb)); 19338d1c069SBoaz Harrosh ahslength = rlen + sizeof(ecdb_ahdr->reserved); 19438d1c069SBoaz Harrosh 19538d1c069SBoaz Harrosh pad_len = iscsi_padding(rlen); 19638d1c069SBoaz Harrosh 1979c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) + 19838d1c069SBoaz Harrosh sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len); 19938d1c069SBoaz Harrosh if (rc) 20038d1c069SBoaz Harrosh return rc; 20138d1c069SBoaz Harrosh 20238d1c069SBoaz Harrosh if (pad_len) 20338d1c069SBoaz Harrosh memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len); 20438d1c069SBoaz Harrosh 20538d1c069SBoaz Harrosh ecdb_ahdr->ahslength = cpu_to_be16(ahslength); 20638d1c069SBoaz Harrosh ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB; 20738d1c069SBoaz Harrosh ecdb_ahdr->reserved = 0; 20838d1c069SBoaz Harrosh memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen); 20938d1c069SBoaz Harrosh 2101b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2111b2c7af8SMike Christie "iscsi_prep_ecdb_ahs: varlen_cdb_len %d " 2121b2c7af8SMike Christie "rlen %d pad_len %d ahs_length %d iscsi_headers_size " 2131b2c7af8SMike Christie "%u\n", cmd->cmd_len, rlen, pad_len, ahslength, 2141b2c7af8SMike Christie task->hdr_len); 21538d1c069SBoaz Harrosh return 0; 21638d1c069SBoaz Harrosh } 21738d1c069SBoaz Harrosh 2187996a778SMike Christie /** 2195d12c05eSMike Christie * iscsi_check_tmf_restrictions - check if a task is affected by TMF 2205d12c05eSMike Christie * @task: iscsi task 2215d12c05eSMike Christie * @opcode: opcode to check for 2225d12c05eSMike Christie * 2235d12c05eSMike Christie * During TMF a task has to be checked if it's affected. 2245d12c05eSMike Christie * All unrelated I/O can be passed through, but I/O to the 2255d12c05eSMike Christie * affected LUN should be restricted. 2265d12c05eSMike Christie * If 'fast_abort' is set we won't be sending any I/O to the 2275d12c05eSMike Christie * affected LUN. 2285d12c05eSMike Christie * Otherwise the target is waiting for all TTTs to be completed, 2295d12c05eSMike Christie * so we have to send all outstanding Data-Out PDUs to the target. 2305d12c05eSMike Christie */ 2315d12c05eSMike Christie static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode) 2325d12c05eSMike Christie { 2335d12c05eSMike Christie struct iscsi_conn *conn = task->conn; 2345d12c05eSMike Christie struct iscsi_tm *tmf = &conn->tmhdr; 2359cb78c16SHannes Reinecke u64 hdr_lun; 2365d12c05eSMike Christie 2375d12c05eSMike Christie if (conn->tmf_state == TMF_INITIAL) 2385d12c05eSMike Christie return 0; 2395d12c05eSMike Christie 2405d12c05eSMike Christie if ((tmf->opcode & ISCSI_OPCODE_MASK) != ISCSI_OP_SCSI_TMFUNC) 2415d12c05eSMike Christie return 0; 2425d12c05eSMike Christie 2435d12c05eSMike Christie switch (ISCSI_TM_FUNC_VALUE(tmf)) { 2445d12c05eSMike Christie case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET: 2455d12c05eSMike Christie /* 2465d12c05eSMike Christie * Allow PDUs for unrelated LUNs 2475d12c05eSMike Christie */ 24855bdabdfSAndy Grover hdr_lun = scsilun_to_int(&tmf->lun); 2495d12c05eSMike Christie if (hdr_lun != task->sc->device->lun) 2505d12c05eSMike Christie return 0; 251df561f66SGustavo A. R. Silva fallthrough; 2523fe5ae8bSMike Christie case ISCSI_TM_FUNC_TARGET_WARM_RESET: 2535d12c05eSMike Christie /* 2545d12c05eSMike Christie * Fail all SCSI cmd PDUs 2555d12c05eSMike Christie */ 2565d12c05eSMike Christie if (opcode != ISCSI_OP_SCSI_DATA_OUT) { 2575d12c05eSMike Christie iscsi_conn_printk(KERN_INFO, conn, 258a17037e7SVarun Prakash "task [op %x itt " 2593fe5ae8bSMike Christie "0x%x/0x%x] " 2605d12c05eSMike Christie "rejected.\n", 261a17037e7SVarun Prakash opcode, task->itt, 262a17037e7SVarun Prakash task->hdr_itt); 2635d12c05eSMike Christie return -EACCES; 2645d12c05eSMike Christie } 2655d12c05eSMike Christie /* 2665d12c05eSMike Christie * And also all data-out PDUs in response to R2T 2675d12c05eSMike Christie * if fast_abort is set. 2685d12c05eSMike Christie */ 2695d12c05eSMike Christie if (conn->session->fast_abort) { 2705d12c05eSMike Christie iscsi_conn_printk(KERN_INFO, conn, 271a17037e7SVarun Prakash "task [op %x itt " 2723fe5ae8bSMike Christie "0x%x/0x%x] fast abort.\n", 273a17037e7SVarun Prakash opcode, task->itt, 274a17037e7SVarun Prakash task->hdr_itt); 2755d12c05eSMike Christie return -EACCES; 2765d12c05eSMike Christie } 2775d12c05eSMike Christie break; 2785d12c05eSMike Christie case ISCSI_TM_FUNC_ABORT_TASK: 2795d12c05eSMike Christie /* 2805d12c05eSMike Christie * the caller has already checked if the task 2815d12c05eSMike Christie * they want to abort was in the pending queue so if 2825d12c05eSMike Christie * we are here the cmd pdu has gone out already, and 2835d12c05eSMike Christie * we will only hit this for data-outs 2845d12c05eSMike Christie */ 2855d12c05eSMike Christie if (opcode == ISCSI_OP_SCSI_DATA_OUT && 2865d12c05eSMike Christie task->hdr_itt == tmf->rtt) { 2875d12c05eSMike Christie ISCSI_DBG_SESSION(conn->session, 2885d12c05eSMike Christie "Preventing task %x/%x from sending " 2895d12c05eSMike Christie "data-out due to abort task in " 2905d12c05eSMike Christie "progress\n", task->itt, 2915d12c05eSMike Christie task->hdr_itt); 2925d12c05eSMike Christie return -EACCES; 2935d12c05eSMike Christie } 2945d12c05eSMike Christie break; 2955d12c05eSMike Christie } 2965d12c05eSMike Christie 2975d12c05eSMike Christie return 0; 2985d12c05eSMike Christie } 2995d12c05eSMike Christie 3005d12c05eSMike Christie /** 3017996a778SMike Christie * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu 3029c19a7d0SMike Christie * @task: iscsi task 3037996a778SMike Christie * 3047996a778SMike Christie * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set 3057996a778SMike Christie * fields like dlength or final based on how much data it sends 3067996a778SMike Christie */ 3079c19a7d0SMike Christie static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task) 3087996a778SMike Christie { 3099c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 3107996a778SMike Christie struct iscsi_session *session = conn->session; 3119c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 31212352183SNicholas Bellinger struct iscsi_scsi_req *hdr; 313d77e6535SSagi Grimberg unsigned hdrlength, cmd_len, transfer_length; 314262ef636SMike Christie itt_t itt; 315004d6530SBoaz Harrosh int rc; 3167996a778SMike Christie 3175d12c05eSMike Christie rc = iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_CMD); 3185d12c05eSMike Christie if (rc) 3195d12c05eSMike Christie return rc; 3205d12c05eSMike Christie 321184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 3222ff79d52SMike Christie rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD); 323577577daSMike Christie if (rc) 324577577daSMike Christie return rc; 325184b57c6SMike Christie } 32612352183SNicholas Bellinger hdr = (struct iscsi_scsi_req *)task->hdr; 327262ef636SMike Christie itt = hdr->itt; 328577577daSMike Christie memset(hdr, 0, sizeof(*hdr)); 329577577daSMike Christie 3302ff79d52SMike Christie if (session->tt->parse_pdu_itt) 3312ff79d52SMike Christie hdr->itt = task->hdr_itt = itt; 3322ff79d52SMike Christie else 3332ff79d52SMike Christie hdr->itt = task->hdr_itt = build_itt(task->itt, 3342ff79d52SMike Christie task->conn->session->age); 3359c19a7d0SMike Christie task->hdr_len = 0; 3369c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*hdr)); 337004d6530SBoaz Harrosh if (rc) 338004d6530SBoaz Harrosh return rc; 3397996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_CMD; 3407996a778SMike Christie hdr->flags = ISCSI_ATTR_SIMPLE; 34155bdabdfSAndy Grover int_to_scsilun(sc->device->lun, &hdr->lun); 34255bdabdfSAndy Grover task->lun = hdr->lun; 3437996a778SMike Christie hdr->exp_statsn = cpu_to_be32(conn->exp_statsn); 34438d1c069SBoaz Harrosh cmd_len = sc->cmd_len; 34538d1c069SBoaz Harrosh if (cmd_len < ISCSI_CDB_SIZE) 34638d1c069SBoaz Harrosh memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len); 34738d1c069SBoaz Harrosh else if (cmd_len > ISCSI_CDB_SIZE) { 3489c19a7d0SMike Christie rc = iscsi_prep_ecdb_ahs(task); 34938d1c069SBoaz Harrosh if (rc) 35038d1c069SBoaz Harrosh return rc; 35138d1c069SBoaz Harrosh cmd_len = ISCSI_CDB_SIZE; 35238d1c069SBoaz Harrosh } 35338d1c069SBoaz Harrosh memcpy(hdr->cdb, sc->cmnd, cmd_len); 3547996a778SMike Christie 3559c19a7d0SMike Christie task->imm_count = 0; 35655e51edaSSagi Grimberg if (scsi_get_prot_op(sc) != SCSI_PROT_NORMAL) 35755e51edaSSagi Grimberg task->protected = true; 35855e51edaSSagi Grimberg 359d77e6535SSagi Grimberg transfer_length = scsi_transfer_length(sc); 360d77e6535SSagi Grimberg hdr->data_length = cpu_to_be32(transfer_length); 3617996a778SMike Christie if (sc->sc_data_direction == DMA_TO_DEVICE) { 362577577daSMike Christie struct iscsi_r2t_info *r2t = &task->unsol_r2t; 363577577daSMike Christie 3647996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_WRITE; 3657996a778SMike Christie /* 3667996a778SMike Christie * Write counters: 3677996a778SMike Christie * 3687996a778SMike Christie * imm_count bytes to be sent right after 3697996a778SMike Christie * SCSI PDU Header 3707996a778SMike Christie * 3717996a778SMike Christie * unsol_count bytes(as Data-Out) to be sent 3727996a778SMike Christie * without R2T ack right after 3737996a778SMike Christie * immediate data 3747996a778SMike Christie * 375577577daSMike Christie * r2t data_length bytes to be sent via R2T ack's 3767996a778SMike Christie * 3777996a778SMike Christie * pad_count bytes to be sent as zero-padding 3787996a778SMike Christie */ 379577577daSMike Christie memset(r2t, 0, sizeof(*r2t)); 3807996a778SMike Christie 3817996a778SMike Christie if (session->imm_data_en) { 382d77e6535SSagi Grimberg if (transfer_length >= session->first_burst) 3839c19a7d0SMike Christie task->imm_count = min(session->first_burst, 3847996a778SMike Christie conn->max_xmit_dlength); 3857996a778SMike Christie else 386d77e6535SSagi Grimberg task->imm_count = min(transfer_length, 3877996a778SMike Christie conn->max_xmit_dlength); 3889c19a7d0SMike Christie hton24(hdr->dlength, task->imm_count); 3897996a778SMike Christie } else 390a8ac6311SOlaf Kirch zero_data(hdr->dlength); 3917996a778SMike Christie 392ffd0436eSMike Christie if (!session->initial_r2t_en) { 393d77e6535SSagi Grimberg r2t->data_length = min(session->first_burst, 394d77e6535SSagi Grimberg transfer_length) - 395577577daSMike Christie task->imm_count; 396577577daSMike Christie r2t->data_offset = task->imm_count; 397577577daSMike Christie r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG); 398577577daSMike Christie r2t->exp_statsn = cpu_to_be32(conn->exp_statsn); 399ffd0436eSMike Christie } 400ffd0436eSMike Christie 401577577daSMike Christie if (!task->unsol_r2t.data_length) 4027996a778SMike Christie /* No unsolicit Data-Out's */ 403a8ac6311SOlaf Kirch hdr->flags |= ISCSI_FLAG_CMD_FINAL; 4047996a778SMike Christie } else { 4057996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 4067996a778SMike Christie zero_data(hdr->dlength); 4077996a778SMike Christie 4087996a778SMike Christie if (sc->sc_data_direction == DMA_FROM_DEVICE) 4097996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_READ; 4107996a778SMike Christie } 4117996a778SMike Christie 412004d6530SBoaz Harrosh /* calculate size of additional header segments (AHSs) */ 4139c19a7d0SMike Christie hdrlength = task->hdr_len - sizeof(*hdr); 414004d6530SBoaz Harrosh 415004d6530SBoaz Harrosh WARN_ON(hdrlength & (ISCSI_PAD_LEN-1)); 416004d6530SBoaz Harrosh hdrlength /= ISCSI_PAD_LEN; 417004d6530SBoaz Harrosh 418004d6530SBoaz Harrosh WARN_ON(hdrlength >= 256); 419004d6530SBoaz Harrosh hdr->hlength = hdrlength & 0xFF; 42096b1f96dSMike Christie hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn); 421004d6530SBoaz Harrosh 422577577daSMike Christie if (session->tt->init_task && session->tt->init_task(task)) 423052d0144SMike Christie return -EIO; 424052d0144SMike Christie 4259c19a7d0SMike Christie task->state = ISCSI_TASK_RUNNING; 426d3305f34SMike Christie session->cmdsn++; 42777a23c21SMike Christie 428a8ac6311SOlaf Kirch conn->scsicmd_pdus_cnt++; 4291b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi prep [%s cid %d sc %p cdb 0x%x " 430ae3d56d8SChristoph Hellwig "itt 0x%x len %d cmdsn %d win %d]\n", 4311b2c7af8SMike Christie sc->sc_data_direction == DMA_TO_DEVICE ? 4321b2c7af8SMike Christie "write" : "read", conn->id, sc, sc->cmnd[0], 433d77e6535SSagi Grimberg task->itt, transfer_length, 4341b2c7af8SMike Christie session->cmdsn, 4351b2c7af8SMike Christie session->max_cmdsn - session->exp_cmdsn + 1); 436004d6530SBoaz Harrosh return 0; 4377996a778SMike Christie } 4387996a778SMike Christie 4397996a778SMike Christie /** 4403bbaaad9SMike Christie * iscsi_free_task - free a task 4419c19a7d0SMike Christie * @task: iscsi cmd task 4427996a778SMike Christie * 443659743b0SShlomo Pongratz * Must be called with session back_lock. 4443e5c28adSMike Christie * This function returns the scsi command to scsi-ml or cleans 4453e5c28adSMike Christie * up mgmt tasks then returns the task to the pool. 4467996a778SMike Christie */ 4473bbaaad9SMike Christie static void iscsi_free_task(struct iscsi_task *task) 4487996a778SMike Christie { 4499c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 450c1635cb7SMike Christie struct iscsi_session *session = conn->session; 4519c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 452f41d4721SMike Christie int oldstate = task->state; 4537996a778SMike Christie 4544421c9ebSMike Christie ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n", 4554421c9ebSMike Christie task->itt, task->state, task->sc); 4564421c9ebSMike Christie 457577577daSMike Christie session->tt->cleanup_task(task); 4583bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 4599c19a7d0SMike Christie task->sc = NULL; 4603e5c28adSMike Christie /* 4619c19a7d0SMike Christie * login task is preallocated so do not free 4623e5c28adSMike Christie */ 4639c19a7d0SMike Christie if (conn->login_task == task) 4643e5c28adSMike Christie return; 4653e5c28adSMike Christie 4667acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&task, sizeof(void*)); 4673e5c28adSMike Christie 4683e5c28adSMike Christie if (sc) { 469f47f2cf5SMike Christie /* SCSI eh reuses commands to verify us */ 470f47f2cf5SMike Christie sc->SCp.ptr = NULL; 4713e5c28adSMike Christie /* 472f41d4721SMike Christie * queue command may call this to free the task, so 473f41d4721SMike Christie * it will decide how to return sc to scsi-ml. 4743e5c28adSMike Christie */ 475f41d4721SMike Christie if (oldstate != ISCSI_TASK_REQUEUE_SCSIQ) 4767996a778SMike Christie sc->scsi_done(sc); 4777996a778SMike Christie } 4783e5c28adSMike Christie } 4797996a778SMike Christie 480913e5bf4SMike Christie void __iscsi_get_task(struct iscsi_task *task) 48160ecebf5SMike Christie { 4826dc618cdSElena Reshetova refcount_inc(&task->refcount); 48360ecebf5SMike Christie } 484913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_get_task); 48560ecebf5SMike Christie 4868eea2f55SEddie Wai void __iscsi_put_task(struct iscsi_task *task) 48760ecebf5SMike Christie { 4886dc618cdSElena Reshetova if (refcount_dec_and_test(&task->refcount)) 4893bbaaad9SMike Christie iscsi_free_task(task); 49060ecebf5SMike Christie } 4918eea2f55SEddie Wai EXPORT_SYMBOL_GPL(__iscsi_put_task); 49260ecebf5SMike Christie 4939c19a7d0SMike Christie void iscsi_put_task(struct iscsi_task *task) 4943e5c28adSMike Christie { 4959c19a7d0SMike Christie struct iscsi_session *session = task->conn->session; 4963e5c28adSMike Christie 497659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 498659743b0SShlomo Pongratz spin_lock_bh(&session->back_lock); 4999c19a7d0SMike Christie __iscsi_put_task(task); 500659743b0SShlomo Pongratz spin_unlock_bh(&session->back_lock); 5013e5c28adSMike Christie } 5029c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_put_task); 5033e5c28adSMike Christie 5043bbaaad9SMike Christie /** 5053bbaaad9SMike Christie * iscsi_complete_task - finish a task 5063bbaaad9SMike Christie * @task: iscsi cmd task 507b3cd5050SMike Christie * @state: state to complete task with 5083bbaaad9SMike Christie * 509659743b0SShlomo Pongratz * Must be called with session back_lock. 510b3a7ea8dSMike Christie */ 511b3cd5050SMike Christie static void iscsi_complete_task(struct iscsi_task *task, int state) 512b3a7ea8dSMike Christie { 5133bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 5143bbaaad9SMike Christie 5154421c9ebSMike Christie ISCSI_DBG_SESSION(conn->session, 5164421c9ebSMike Christie "complete task itt 0x%x state %d sc %p\n", 5174421c9ebSMike Christie task->itt, task->state, task->sc); 518b3cd5050SMike Christie if (task->state == ISCSI_TASK_COMPLETED || 519b3cd5050SMike Christie task->state == ISCSI_TASK_ABRT_TMF || 520f41d4721SMike Christie task->state == ISCSI_TASK_ABRT_SESS_RECOV || 521f41d4721SMike Christie task->state == ISCSI_TASK_REQUEUE_SCSIQ) 5223bbaaad9SMike Christie return; 5233bbaaad9SMike Christie WARN_ON_ONCE(task->state == ISCSI_TASK_FREE); 524b3cd5050SMike Christie task->state = state; 5253bbaaad9SMike Christie 526fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task) == task) 527fe0a8a95SLee Duncan WRITE_ONCE(conn->ping_task, NULL); 5283bbaaad9SMike Christie 5293bbaaad9SMike Christie /* release get from queueing */ 5303bbaaad9SMike Christie __iscsi_put_task(task); 5313bbaaad9SMike Christie } 5323bbaaad9SMike Christie 5334c0ba5d2SMike Christie /** 5344c0ba5d2SMike Christie * iscsi_complete_scsi_task - finish scsi task normally 5354c0ba5d2SMike Christie * @task: iscsi task for scsi cmd 5364c0ba5d2SMike Christie * @exp_cmdsn: expected cmd sn in cpu format 5374c0ba5d2SMike Christie * @max_cmdsn: max cmd sn in cpu format 5384c0ba5d2SMike Christie * 5394c0ba5d2SMike Christie * This is used when drivers do not need or cannot perform 5404c0ba5d2SMike Christie * lower level pdu processing. 5414c0ba5d2SMike Christie * 542659743b0SShlomo Pongratz * Called with session back_lock 5434c0ba5d2SMike Christie */ 5444c0ba5d2SMike Christie void iscsi_complete_scsi_task(struct iscsi_task *task, 5454c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 5464c0ba5d2SMike Christie { 5474c0ba5d2SMike Christie struct iscsi_conn *conn = task->conn; 5484c0ba5d2SMike Christie 5494c0ba5d2SMike Christie ISCSI_DBG_SESSION(conn->session, "[itt 0x%x]\n", task->itt); 5504c0ba5d2SMike Christie 5514c0ba5d2SMike Christie conn->last_recv = jiffies; 5524c0ba5d2SMike Christie __iscsi_update_cmdsn(conn->session, exp_cmdsn, max_cmdsn); 5534c0ba5d2SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 5544c0ba5d2SMike Christie } 5554c0ba5d2SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_scsi_task); 5564c0ba5d2SMike Christie 5575923d64bSMike Christie /* 5585923d64bSMike Christie * Must be called with back and frwd lock 5595923d64bSMike Christie */ 5605923d64bSMike Christie static bool cleanup_queued_task(struct iscsi_task *task) 5615923d64bSMike Christie { 5625923d64bSMike Christie struct iscsi_conn *conn = task->conn; 5635923d64bSMike Christie bool early_complete = false; 5645923d64bSMike Christie 5655923d64bSMike Christie /* Bad target might have completed task while it was still running */ 5665923d64bSMike Christie if (task->state == ISCSI_TASK_COMPLETED) 5675923d64bSMike Christie early_complete = true; 5685923d64bSMike Christie 5695923d64bSMike Christie if (!list_empty(&task->running)) { 5705923d64bSMike Christie list_del_init(&task->running); 5715923d64bSMike Christie /* 5725923d64bSMike Christie * If it's on a list but still running, this could be from 5735923d64bSMike Christie * a bad target sending a rsp early, cleanup from a TMF, or 5745923d64bSMike Christie * session recovery. 5755923d64bSMike Christie */ 5765923d64bSMike Christie if (task->state == ISCSI_TASK_RUNNING || 5775923d64bSMike Christie task->state == ISCSI_TASK_COMPLETED) 5785923d64bSMike Christie __iscsi_put_task(task); 5795923d64bSMike Christie } 5805923d64bSMike Christie 5815923d64bSMike Christie if (conn->task == task) { 5825923d64bSMike Christie conn->task = NULL; 5835923d64bSMike Christie __iscsi_put_task(task); 5845923d64bSMike Christie } 5855923d64bSMike Christie 5865923d64bSMike Christie return early_complete; 5875923d64bSMike Christie } 5884c0ba5d2SMike Christie 5893bbaaad9SMike Christie /* 59014936b1eSMike Christie * session frwd lock must be held and if not called for a task that is still 59114936b1eSMike Christie * pending or from the xmit thread, then xmit thread must be suspended 5923bbaaad9SMike Christie */ 5933bbaaad9SMike Christie static void fail_scsi_task(struct iscsi_task *task, int err) 5943bbaaad9SMike Christie { 5953bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 596b3a7ea8dSMike Christie struct scsi_cmnd *sc; 597b3cd5050SMike Christie int state; 598b3a7ea8dSMike Christie 5995923d64bSMike Christie spin_lock_bh(&conn->session->back_lock); 6005923d64bSMike Christie if (cleanup_queued_task(task)) { 6015923d64bSMike Christie spin_unlock_bh(&conn->session->back_lock); 6025923d64bSMike Christie return; 6035923d64bSMike Christie } 6045923d64bSMike Christie 605b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) { 606b3a7ea8dSMike Christie /* 607b3a7ea8dSMike Christie * cmd never made it to the xmit thread, so we should not count 608b3a7ea8dSMike Christie * the cmd in the sequencing 609b3a7ea8dSMike Christie */ 610b3a7ea8dSMike Christie conn->session->queued_cmdsn--; 611b3cd5050SMike Christie /* it was never sent so just complete like normal */ 612b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 613b3cd5050SMike Christie } else if (err == DID_TRANSPORT_DISRUPTED) 614b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 615b3cd5050SMike Christie else 616b3cd5050SMike Christie state = ISCSI_TASK_ABRT_TMF; 617b3a7ea8dSMike Christie 61814936b1eSMike Christie sc = task->sc; 619b3cd5050SMike Christie sc->result = err << 16; 620b3a7ea8dSMike Christie scsi_set_resid(sc, scsi_bufflen(sc)); 621b3cd5050SMike Christie iscsi_complete_task(task, state); 622659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->back_lock); 623b3a7ea8dSMike Christie } 624b3a7ea8dSMike Christie 6253e5c28adSMike Christie static int iscsi_prep_mgmt_task(struct iscsi_conn *conn, 6269c19a7d0SMike Christie struct iscsi_task *task) 627052d0144SMike Christie { 628052d0144SMike Christie struct iscsi_session *session = conn->session; 629577577daSMike Christie struct iscsi_hdr *hdr = task->hdr; 630052d0144SMike Christie struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr; 6314f704dc0SMike Christie uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 632052d0144SMike Christie 633052d0144SMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 634052d0144SMike Christie return -ENOTCONN; 635052d0144SMike Christie 6364f704dc0SMike Christie if (opcode != ISCSI_OP_LOGIN && opcode != ISCSI_OP_TEXT) 637052d0144SMike Christie nop->exp_statsn = cpu_to_be32(conn->exp_statsn); 638052d0144SMike Christie /* 639052d0144SMike Christie * pre-format CmdSN for outgoing PDU. 640052d0144SMike Christie */ 641052d0144SMike Christie nop->cmdsn = cpu_to_be32(session->cmdsn); 642052d0144SMike Christie if (hdr->itt != RESERVED_ITT) { 643052d0144SMike Christie /* 6444f704dc0SMike Christie * TODO: We always use immediate for normal session pdus. 645052d0144SMike Christie * If we start to send tmfs or nops as non-immediate then 646052d0144SMike Christie * we should start checking the cmdsn numbers for mgmt tasks. 6474f704dc0SMike Christie * 6484f704dc0SMike Christie * During discovery sessions iscsid sends TEXT as non immediate, 6494f704dc0SMike Christie * but we always only send one PDU at a time. 650052d0144SMike Christie */ 651052d0144SMike Christie if (conn->c_stage == ISCSI_CONN_STARTED && 652052d0144SMike Christie !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 653052d0144SMike Christie session->queued_cmdsn++; 654052d0144SMike Christie session->cmdsn++; 655052d0144SMike Christie } 656052d0144SMike Christie } 657052d0144SMike Christie 658ae15f801SMike Christie if (session->tt->init_task && session->tt->init_task(task)) 659ae15f801SMike Christie return -EIO; 660052d0144SMike Christie 661052d0144SMike Christie if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT) 662052d0144SMike Christie session->state = ISCSI_STATE_LOGGING_OUT; 663052d0144SMike Christie 664577577daSMike Christie task->state = ISCSI_TASK_RUNNING; 6651b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "mgmtpdu [op 0x%x hdr->itt 0x%x " 6661b2c7af8SMike Christie "datalen %d]\n", hdr->opcode & ISCSI_OPCODE_MASK, 6671b2c7af8SMike Christie hdr->itt, task->data_count); 668052d0144SMike Christie return 0; 669052d0144SMike Christie } 670052d0144SMike Christie 6719c19a7d0SMike Christie static struct iscsi_task * 672f6d5180cSMike Christie __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 673f6d5180cSMike Christie char *data, uint32_t data_size) 674f6d5180cSMike Christie { 675f6d5180cSMike Christie struct iscsi_session *session = conn->session; 6761336aed1SMike Christie struct iscsi_host *ihost = shost_priv(session->host); 6774f704dc0SMike Christie uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 6789c19a7d0SMike Christie struct iscsi_task *task; 679262ef636SMike Christie itt_t itt; 680f6d5180cSMike Christie 681f6d5180cSMike Christie if (session->state == ISCSI_STATE_TERMINATE) 682f6d5180cSMike Christie return NULL; 683f6d5180cSMike Christie 6844f704dc0SMike Christie if (opcode == ISCSI_OP_LOGIN || opcode == ISCSI_OP_TEXT) { 685f6d5180cSMike Christie /* 686f6d5180cSMike Christie * Login and Text are sent serially, in 687f6d5180cSMike Christie * request-followed-by-response sequence. 6883e5c28adSMike Christie * Same task can be used. Same ITT must be used. 6893e5c28adSMike Christie * Note that login_task is preallocated at conn_create(). 690f6d5180cSMike Christie */ 6914f704dc0SMike Christie if (conn->login_task->state != ISCSI_TASK_FREE) { 6924f704dc0SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Login/Text in " 6934f704dc0SMike Christie "progress. Cannot start new task.\n"); 6944f704dc0SMike Christie return NULL; 6954f704dc0SMike Christie } 6964f704dc0SMike Christie 697cbaa4221SMike Christie if (data_size > ISCSI_DEF_MAX_RECV_SEG_LEN) { 698cbaa4221SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Invalid buffer len of %u for login task. Max len is %u\n", data_size, ISCSI_DEF_MAX_RECV_SEG_LEN); 699cbaa4221SMike Christie return NULL; 700cbaa4221SMike Christie } 701cbaa4221SMike Christie 7029c19a7d0SMike Christie task = conn->login_task; 7034f704dc0SMike Christie } else { 70426013ad4SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 70526013ad4SMike Christie return NULL; 70626013ad4SMike Christie 707cbaa4221SMike Christie if (data_size != 0) { 708cbaa4221SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Can not send data buffer of len %u for op 0x%x\n", data_size, opcode); 709cbaa4221SMike Christie return NULL; 710cbaa4221SMike Christie } 711cbaa4221SMike Christie 712f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE); 713f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED); 714f6d5180cSMike Christie 7157acd72ebSStefani Seibold if (!kfifo_out(&session->cmdpool.queue, 7169c19a7d0SMike Christie (void*)&task, sizeof(void*))) 717f6d5180cSMike Christie return NULL; 718f6d5180cSMike Christie } 7193e5c28adSMike Christie /* 7203e5c28adSMike Christie * released in complete pdu for task we expect a response for, and 7213e5c28adSMike Christie * released by the lld when it has transmitted the task for 7223e5c28adSMike Christie * pdus we do not expect a response for. 7233e5c28adSMike Christie */ 7246dc618cdSElena Reshetova refcount_set(&task->refcount, 1); 7259c19a7d0SMike Christie task->conn = conn; 7269c19a7d0SMike Christie task->sc = NULL; 7273bbaaad9SMike Christie INIT_LIST_HEAD(&task->running); 7283bbaaad9SMike Christie task->state = ISCSI_TASK_PENDING; 729f6d5180cSMike Christie 730f6d5180cSMike Christie if (data_size) { 7319c19a7d0SMike Christie memcpy(task->data, data, data_size); 7329c19a7d0SMike Christie task->data_count = data_size; 733f6d5180cSMike Christie } else 7349c19a7d0SMike Christie task->data_count = 0; 735f6d5180cSMike Christie 736184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 7372ff79d52SMike Christie if (conn->session->tt->alloc_pdu(task, hdr->opcode)) { 738577577daSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not allocate " 739577577daSMike Christie "pdu for mgmt task.\n"); 7403bbaaad9SMike Christie goto free_task; 741577577daSMike Christie } 742184b57c6SMike Christie } 743184b57c6SMike Christie 744262ef636SMike Christie itt = task->hdr->itt; 745577577daSMike Christie task->hdr_len = sizeof(struct iscsi_hdr); 7469c19a7d0SMike Christie memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr)); 747262ef636SMike Christie 748262ef636SMike Christie if (hdr->itt != RESERVED_ITT) { 749262ef636SMike Christie if (session->tt->parse_pdu_itt) 750262ef636SMike Christie task->hdr->itt = itt; 751262ef636SMike Christie else 752262ef636SMike Christie task->hdr->itt = build_itt(task->itt, 753262ef636SMike Christie task->conn->session->age); 754262ef636SMike Christie } 755262ef636SMike Christie 756fe0a8a95SLee Duncan if (unlikely(READ_ONCE(conn->ping_task) == INVALID_SCSI_TASK)) 757fe0a8a95SLee Duncan WRITE_ONCE(conn->ping_task, task); 758fe0a8a95SLee Duncan 7591336aed1SMike Christie if (!ihost->workq) { 760577577daSMike Christie if (iscsi_prep_mgmt_task(conn, task)) 761577577daSMike Christie goto free_task; 762052d0144SMike Christie 7639c19a7d0SMike Christie if (session->tt->xmit_task(task)) 764577577daSMike Christie goto free_task; 7653bbaaad9SMike Christie } else { 7663bbaaad9SMike Christie list_add_tail(&task->running, &conn->mgmtqueue); 76732ae763eSMike Christie iscsi_conn_queue_work(conn); 7683bbaaad9SMike Christie } 769052d0144SMike Christie 7709c19a7d0SMike Christie return task; 771577577daSMike Christie 772577577daSMike Christie free_task: 773659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 7744fa50799SJitendra Bhivare spin_lock(&session->back_lock); 775577577daSMike Christie __iscsi_put_task(task); 7764fa50799SJitendra Bhivare spin_unlock(&session->back_lock); 777577577daSMike Christie return NULL; 778f6d5180cSMike Christie } 779f6d5180cSMike Christie 780f6d5180cSMike Christie int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr, 781f6d5180cSMike Christie char *data, uint32_t data_size) 782f6d5180cSMike Christie { 783f6d5180cSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 784f6d5180cSMike Christie struct iscsi_session *session = conn->session; 785f6d5180cSMike Christie int err = 0; 786f6d5180cSMike Christie 787659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 788f6d5180cSMike Christie if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size)) 789f6d5180cSMike Christie err = -EPERM; 790659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 791f6d5180cSMike Christie return err; 792f6d5180cSMike Christie } 793f6d5180cSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu); 794f6d5180cSMike Christie 7957996a778SMike Christie /** 796ae6b4e69SMauro Carvalho Chehab * iscsi_scsi_cmd_rsp - SCSI Command Response processing 7977996a778SMike Christie * @conn: iscsi connection 7987996a778SMike Christie * @hdr: iscsi header 7999c19a7d0SMike Christie * @task: scsi command task 8007996a778SMike Christie * @data: cmd data buffer 8017996a778SMike Christie * @datalen: len of buffer 8027996a778SMike Christie * 8037996a778SMike Christie * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and 804a656183eSLee Duncan * then completes the command and task. called under back_lock 8057996a778SMike Christie **/ 80677a23c21SMike Christie static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 8079c19a7d0SMike Christie struct iscsi_task *task, char *data, 8087996a778SMike Christie int datalen) 8097996a778SMike Christie { 81012352183SNicholas Bellinger struct iscsi_scsi_rsp *rhdr = (struct iscsi_scsi_rsp *)hdr; 8117996a778SMike Christie struct iscsi_session *session = conn->session; 8129c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 8137996a778SMike Christie 81477a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr); 8157996a778SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 8167996a778SMike Christie 8177996a778SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 8187996a778SMike Christie 81955e51edaSSagi Grimberg if (task->protected) { 82055e51edaSSagi Grimberg sector_t sector; 82155e51edaSSagi Grimberg u8 ascq; 82255e51edaSSagi Grimberg 82355e51edaSSagi Grimberg /** 82455e51edaSSagi Grimberg * Transports that didn't implement check_protection 82555e51edaSSagi Grimberg * callback but still published T10-PI support to scsi-mid 82655e51edaSSagi Grimberg * deserve this BUG_ON. 82755e51edaSSagi Grimberg **/ 82855e51edaSSagi Grimberg BUG_ON(!session->tt->check_protection); 82955e51edaSSagi Grimberg 83055e51edaSSagi Grimberg ascq = session->tt->check_protection(task, §or); 83155e51edaSSagi Grimberg if (ascq) { 83255e51edaSSagi Grimberg sc->result = DRIVER_SENSE << 24 | 83355e51edaSSagi Grimberg SAM_STAT_CHECK_CONDITION; 83455e51edaSSagi Grimberg scsi_build_sense_buffer(1, sc->sense_buffer, 83555e51edaSSagi Grimberg ILLEGAL_REQUEST, 0x10, ascq); 836a73c2a2fSSagi Grimberg scsi_set_sense_information(sc->sense_buffer, 837a73c2a2fSSagi Grimberg SCSI_SENSE_BUFFERSIZE, 838a73c2a2fSSagi Grimberg sector); 83955e51edaSSagi Grimberg goto out; 84055e51edaSSagi Grimberg } 84155e51edaSSagi Grimberg } 84255e51edaSSagi Grimberg 8437996a778SMike Christie if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) { 8447996a778SMike Christie sc->result = DID_ERROR << 16; 8457996a778SMike Christie goto out; 8467996a778SMike Christie } 8477996a778SMike Christie 8487996a778SMike Christie if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) { 8499b80cb4bSMike Christie uint16_t senselen; 8507996a778SMike Christie 8517996a778SMike Christie if (datalen < 2) { 8527996a778SMike Christie invalid_datalen: 853322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 854322d739dSMike Christie "Got CHECK_CONDITION but invalid data " 855322d739dSMike Christie "buffer size of %d\n", datalen); 8567996a778SMike Christie sc->result = DID_BAD_TARGET << 16; 8577996a778SMike Christie goto out; 8587996a778SMike Christie } 8597996a778SMike Christie 8608f333991SHarvey Harrison senselen = get_unaligned_be16(data); 8617996a778SMike Christie if (datalen < senselen) 8627996a778SMike Christie goto invalid_datalen; 8637996a778SMike Christie 8647996a778SMike Christie memcpy(sc->sense_buffer, data + 2, 8659b80cb4bSMike Christie min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 8661b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n", 8671b2c7af8SMike Christie min_t(uint16_t, senselen, 8681b2c7af8SMike Christie SCSI_SENSE_BUFFERSIZE)); 8697996a778SMike Christie } 8707996a778SMike Christie 871c07d4444SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW | 872c07d4444SBoaz Harrosh ISCSI_FLAG_CMD_BIDI_OVERFLOW)) { 873c07d4444SBoaz Harrosh sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 874c07d4444SBoaz Harrosh } 875c07d4444SBoaz Harrosh 8767207fea4SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW | 8777207fea4SBoaz Harrosh ISCSI_FLAG_CMD_OVERFLOW)) { 8787996a778SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 8797996a778SMike Christie 8807207fea4SBoaz Harrosh if (res_count > 0 && 8817207fea4SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 8827207fea4SBoaz Harrosh res_count <= scsi_bufflen(sc))) 883c07d4444SBoaz Harrosh /* write side for bidi or uni-io set_resid */ 8841c138991SFUJITA Tomonori scsi_set_resid(sc, res_count); 8857996a778SMike Christie else 8867996a778SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 887c07d4444SBoaz Harrosh } 8887996a778SMike Christie out: 8893bbaaad9SMike Christie ISCSI_DBG_SESSION(session, "cmd rsp done [sc %p res %d itt 0x%x]\n", 8901b2c7af8SMike Christie sc, sc->result, task->itt); 8917996a778SMike Christie conn->scsirsp_pdus_cnt++; 892b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 8937996a778SMike Christie } 8947996a778SMike Christie 8951d9edf02SMike Christie /** 8961d9edf02SMike Christie * iscsi_data_in_rsp - SCSI Data-In Response processing 8971d9edf02SMike Christie * @conn: iscsi connection 8981d9edf02SMike Christie * @hdr: iscsi pdu 8991d9edf02SMike Christie * @task: scsi command task 900a656183eSLee Duncan * 901a656183eSLee Duncan * iscsi_data_in_rsp sets up the scsi_cmnd fields based on the data received 902a656183eSLee Duncan * then completes the command and task. called under back_lock 9031d9edf02SMike Christie **/ 9041d9edf02SMike Christie static void 9051d9edf02SMike Christie iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 9061d9edf02SMike Christie struct iscsi_task *task) 9071d9edf02SMike Christie { 9081d9edf02SMike Christie struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr; 9091d9edf02SMike Christie struct scsi_cmnd *sc = task->sc; 9101d9edf02SMike Christie 9111d9edf02SMike Christie if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS)) 9121d9edf02SMike Christie return; 9131d9edf02SMike Christie 914edbc9aa0SMike Christie iscsi_update_cmdsn(conn->session, (struct iscsi_nopin *)hdr); 9151d9edf02SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 9161d9edf02SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 9171d9edf02SMike Christie if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW | 9181d9edf02SMike Christie ISCSI_FLAG_DATA_OVERFLOW)) { 9191d9edf02SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 9201d9edf02SMike Christie 9211d9edf02SMike Christie if (res_count > 0 && 9221d9edf02SMike Christie (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 923ae3d56d8SChristoph Hellwig res_count <= sc->sdb.length)) 924960bf87aSBart Van Assche scsi_set_resid(sc, res_count); 9251d9edf02SMike Christie else 9261d9edf02SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 9271d9edf02SMike Christie } 9281d9edf02SMike Christie 9293bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, "data in with status done " 9303bbaaad9SMike Christie "[sc %p res %d itt 0x%x]\n", 9313bbaaad9SMike Christie sc, sc->result, task->itt); 9321d9edf02SMike Christie conn->scsirsp_pdus_cnt++; 933b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 9341d9edf02SMike Christie } 9351d9edf02SMike Christie 9367ea8b828SMike Christie static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) 9377ea8b828SMike Christie { 9387ea8b828SMike Christie struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; 9397ea8b828SMike Christie 9407ea8b828SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 9417ea8b828SMike Christie conn->tmfrsp_pdus_cnt++; 9427ea8b828SMike Christie 943843c0a8aSMike Christie if (conn->tmf_state != TMF_QUEUED) 9447ea8b828SMike Christie return; 9457ea8b828SMike Christie 9467ea8b828SMike Christie if (tmf->response == ISCSI_TMF_RSP_COMPLETE) 947843c0a8aSMike Christie conn->tmf_state = TMF_SUCCESS; 9487ea8b828SMike Christie else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) 949843c0a8aSMike Christie conn->tmf_state = TMF_NOT_FOUND; 9507ea8b828SMike Christie else 951843c0a8aSMike Christie conn->tmf_state = TMF_FAILED; 9527ea8b828SMike Christie wake_up(&conn->ehwait); 9537ea8b828SMike Christie } 9547ea8b828SMike Christie 95552f5664aSAriel Nahum static int iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) 956f6d5180cSMike Christie { 957f6d5180cSMike Christie struct iscsi_nopout hdr; 9589c19a7d0SMike Christie struct iscsi_task *task; 959f6d5180cSMike Christie 960fe0a8a95SLee Duncan if (!rhdr) { 961fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task)) 96252f5664aSAriel Nahum return -EINVAL; 963fe0a8a95SLee Duncan WRITE_ONCE(conn->ping_task, INVALID_SCSI_TASK); 964fe0a8a95SLee Duncan } 965f6d5180cSMike Christie 966f6d5180cSMike Christie memset(&hdr, 0, sizeof(struct iscsi_nopout)); 967f6d5180cSMike Christie hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE; 968f6d5180cSMike Christie hdr.flags = ISCSI_FLAG_CMD_FINAL; 969f6d5180cSMike Christie 970f6d5180cSMike Christie if (rhdr) { 97155bdabdfSAndy Grover hdr.lun = rhdr->lun; 972f6d5180cSMike Christie hdr.ttt = rhdr->ttt; 973f6d5180cSMike Christie hdr.itt = RESERVED_ITT; 974f6d5180cSMike Christie } else 975f6d5180cSMike Christie hdr.ttt = RESERVED_ITT; 976f6d5180cSMike Christie 9779c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0); 97852f5664aSAriel Nahum if (!task) { 979fe0a8a95SLee Duncan if (!rhdr) 980fe0a8a95SLee Duncan WRITE_ONCE(conn->ping_task, NULL); 981322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n"); 98252f5664aSAriel Nahum return -EIO; 98352f5664aSAriel Nahum } else if (!rhdr) { 984d3acf022SMike Christie /* only track our nops */ 985d3acf022SMike Christie conn->last_ping = jiffies; 986d3acf022SMike Christie } 98752f5664aSAriel Nahum 98852f5664aSAriel Nahum return 0; 989f6d5180cSMike Christie } 990f6d5180cSMike Christie 991a656183eSLee Duncan /** 992a656183eSLee Duncan * iscsi_nop_out_rsp - SCSI NOP Response processing 993a656183eSLee Duncan * @task: scsi command task 994a656183eSLee Duncan * @nop: the nop structure 995a656183eSLee Duncan * @data: where to put the data 996a656183eSLee Duncan * @datalen: length of data 997a656183eSLee Duncan * 998a656183eSLee Duncan * iscsi_nop_out_rsp handles nop response from use or 999a656183eSLee Duncan * from user space. called under back_lock 1000a656183eSLee Duncan **/ 10018afa1439SMike Christie static int iscsi_nop_out_rsp(struct iscsi_task *task, 10028afa1439SMike Christie struct iscsi_nopin *nop, char *data, int datalen) 10038afa1439SMike Christie { 10048afa1439SMike Christie struct iscsi_conn *conn = task->conn; 10058afa1439SMike Christie int rc = 0; 10068afa1439SMike Christie 1007fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task) != task) { 10088afa1439SMike Christie /* 10098afa1439SMike Christie * If this is not in response to one of our 10108afa1439SMike Christie * nops then it must be from userspace. 10118afa1439SMike Christie */ 10128afa1439SMike Christie if (iscsi_recv_pdu(conn->cls_conn, (struct iscsi_hdr *)nop, 10138afa1439SMike Christie data, datalen)) 10148afa1439SMike Christie rc = ISCSI_ERR_CONN_FAILED; 10158afa1439SMike Christie } else 10168afa1439SMike Christie mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout); 10178afa1439SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 10188afa1439SMike Christie return rc; 10198afa1439SMike Christie } 10208afa1439SMike Christie 102162f38300SMike Christie static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 102262f38300SMike Christie char *data, int datalen) 102362f38300SMike Christie { 102462f38300SMike Christie struct iscsi_reject *reject = (struct iscsi_reject *)hdr; 102562f38300SMike Christie struct iscsi_hdr rejected_pdu; 10268afa1439SMike Christie int opcode, rc = 0; 102762f38300SMike Christie 102862f38300SMike Christie conn->exp_statsn = be32_to_cpu(reject->statsn) + 1; 102962f38300SMike Christie 10308afa1439SMike Christie if (ntoh24(reject->dlength) > datalen || 10318afa1439SMike Christie ntoh24(reject->dlength) < sizeof(struct iscsi_hdr)) { 10328afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Cannot handle rejected " 10338afa1439SMike Christie "pdu. Invalid data length (pdu dlength " 10348afa1439SMike Christie "%u, datalen %d\n", ntoh24(reject->dlength), 10358afa1439SMike Christie datalen); 103662f38300SMike Christie return ISCSI_ERR_PROTO; 10378afa1439SMike Christie } 103862f38300SMike Christie memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr)); 10398afa1439SMike Christie opcode = rejected_pdu.opcode & ISCSI_OPCODE_MASK; 10408afa1439SMike Christie 10418afa1439SMike Christie switch (reject->reason) { 10428afa1439SMike Christie case ISCSI_REASON_DATA_DIGEST_ERROR: 1043322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 10448afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected " 1045262ef636SMike Christie "due to DataDigest error.\n", 1046e5dbbe27SVaughan Cao opcode, rejected_pdu.itt); 10478afa1439SMike Christie break; 10488afa1439SMike Christie case ISCSI_REASON_IMM_CMD_REJECT: 10498afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 10508afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Too many " 10518afa1439SMike Christie "immediate commands.\n", 1052e5dbbe27SVaughan Cao opcode, rejected_pdu.itt); 10538afa1439SMike Christie /* 10548afa1439SMike Christie * We only send one TMF at a time so if the target could not 10558afa1439SMike Christie * handle it, then it should get fixed (RFC mandates that 10568afa1439SMike Christie * a target can handle one immediate TMF per conn). 10578afa1439SMike Christie * 10588afa1439SMike Christie * For nops-outs, we could have sent more than one if 10598afa1439SMike Christie * the target is sending us lots of nop-ins 10608afa1439SMike Christie */ 10618afa1439SMike Christie if (opcode != ISCSI_OP_NOOP_OUT) 106262f38300SMike Christie return 0; 10638afa1439SMike Christie 1064659743b0SShlomo Pongratz if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG)) { 10658afa1439SMike Christie /* 10668afa1439SMike Christie * nop-out in response to target's nop-out rejected. 10678afa1439SMike Christie * Just resend. 10688afa1439SMike Christie */ 1069659743b0SShlomo Pongratz /* In RX path we are under back lock */ 1070659743b0SShlomo Pongratz spin_unlock(&conn->session->back_lock); 1071659743b0SShlomo Pongratz spin_lock(&conn->session->frwd_lock); 10728afa1439SMike Christie iscsi_send_nopout(conn, 10738afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu); 1074659743b0SShlomo Pongratz spin_unlock(&conn->session->frwd_lock); 1075659743b0SShlomo Pongratz spin_lock(&conn->session->back_lock); 1076659743b0SShlomo Pongratz } else { 10778afa1439SMike Christie struct iscsi_task *task; 10788afa1439SMike Christie /* 10798afa1439SMike Christie * Our nop as ping got dropped. We know the target 10808afa1439SMike Christie * and transport are ok so just clean up 10818afa1439SMike Christie */ 10828afa1439SMike Christie task = iscsi_itt_to_task(conn, rejected_pdu.itt); 10838afa1439SMike Christie if (!task) { 10848afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 10858afa1439SMike Christie "Invalid pdu reject. Could " 10868afa1439SMike Christie "not lookup rejected task.\n"); 10878afa1439SMike Christie rc = ISCSI_ERR_BAD_ITT; 10888afa1439SMike Christie } else 10898afa1439SMike Christie rc = iscsi_nop_out_rsp(task, 10908afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu, 10918afa1439SMike Christie NULL, 0); 10928afa1439SMike Christie } 10938afa1439SMike Christie break; 10948afa1439SMike Christie default: 10958afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 10968afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Reason " 1097e5dbbe27SVaughan Cao "code 0x%x\n", rejected_pdu.opcode, 1098e5dbbe27SVaughan Cao rejected_pdu.itt, reject->reason); 10998afa1439SMike Christie break; 11008afa1439SMike Christie } 11018afa1439SMike Christie return rc; 110262f38300SMike Christie } 110362f38300SMike Christie 11047996a778SMike Christie /** 1105913e5bf4SMike Christie * iscsi_itt_to_task - look up task by itt 1106913e5bf4SMike Christie * @conn: iscsi connection 1107913e5bf4SMike Christie * @itt: itt 1108913e5bf4SMike Christie * 1109913e5bf4SMike Christie * This should be used for mgmt tasks like login and nops, or if 1110913e5bf4SMike Christie * the LDD's itt space does not include the session age. 1111913e5bf4SMike Christie * 1112659743b0SShlomo Pongratz * The session back_lock must be held. 1113913e5bf4SMike Christie */ 11148f9256ceSMike Christie struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt) 1115913e5bf4SMike Christie { 1116913e5bf4SMike Christie struct iscsi_session *session = conn->session; 1117262ef636SMike Christie int i; 1118913e5bf4SMike Christie 1119913e5bf4SMike Christie if (itt == RESERVED_ITT) 1120913e5bf4SMike Christie return NULL; 1121913e5bf4SMike Christie 1122262ef636SMike Christie if (session->tt->parse_pdu_itt) 1123262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, NULL); 1124262ef636SMike Christie else 1125913e5bf4SMike Christie i = get_itt(itt); 1126913e5bf4SMike Christie if (i >= session->cmds_max) 1127913e5bf4SMike Christie return NULL; 1128913e5bf4SMike Christie 1129913e5bf4SMike Christie return session->cmds[i]; 1130913e5bf4SMike Christie } 11318f9256ceSMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_task); 1132913e5bf4SMike Christie 1133913e5bf4SMike Christie /** 11347996a778SMike Christie * __iscsi_complete_pdu - complete pdu 11357996a778SMike Christie * @conn: iscsi conn 11367996a778SMike Christie * @hdr: iscsi header 11377996a778SMike Christie * @data: data buffer 11387996a778SMike Christie * @datalen: len of data buffer 11397996a778SMike Christie * 11407996a778SMike Christie * Completes pdu processing by freeing any resources allocated at 1141659743b0SShlomo Pongratz * queuecommand or send generic. session back_lock must be held and verify 11427996a778SMike Christie * itt must have been called. 11437996a778SMike Christie */ 1144913e5bf4SMike Christie int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 11457996a778SMike Christie char *data, int datalen) 11467996a778SMike Christie { 11477996a778SMike Christie struct iscsi_session *session = conn->session; 11487996a778SMike Christie int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0; 11499c19a7d0SMike Christie struct iscsi_task *task; 11507996a778SMike Christie uint32_t itt; 11517996a778SMike Christie 1152f6d5180cSMike Christie conn->last_recv = jiffies; 11530af967f5SMike Christie rc = iscsi_verify_itt(conn, hdr->itt); 11540af967f5SMike Christie if (rc) 11550af967f5SMike Christie return rc; 11560af967f5SMike Christie 1157b4377356SAl Viro if (hdr->itt != RESERVED_ITT) 1158b4377356SAl Viro itt = get_itt(hdr->itt); 11597996a778SMike Christie else 1160b4377356SAl Viro itt = ~0U; 11617996a778SMike Christie 11621b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "[op 0x%x cid %d itt 0x%x len %d]\n", 11633e5c28adSMike Christie opcode, conn->id, itt, datalen); 11647996a778SMike Christie 11653e5c28adSMike Christie if (itt == ~0U) { 116677a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 116762f38300SMike Christie 11687996a778SMike Christie switch(opcode) { 11697996a778SMike Christie case ISCSI_OP_NOOP_IN: 117040527afeSMike Christie if (datalen) { 117140527afeSMike Christie rc = ISCSI_ERR_PROTO; 117240527afeSMike Christie break; 117340527afeSMike Christie } 117440527afeSMike Christie 1175b4377356SAl Viro if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) 117640527afeSMike Christie break; 117740527afeSMike Christie 1178659743b0SShlomo Pongratz /* In RX path we are under back lock */ 1179659743b0SShlomo Pongratz spin_unlock(&session->back_lock); 1180659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 1181f6d5180cSMike Christie iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr); 1182659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 1183659743b0SShlomo Pongratz spin_lock(&session->back_lock); 11847996a778SMike Christie break; 11857996a778SMike Christie case ISCSI_OP_REJECT: 118662f38300SMike Christie rc = iscsi_handle_reject(conn, hdr, data, datalen); 118762f38300SMike Christie break; 11887996a778SMike Christie case ISCSI_OP_ASYNC_EVENT: 11898d2860b3SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 11905831c737SMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 11915831c737SMike Christie rc = ISCSI_ERR_CONN_FAILED; 11927996a778SMike Christie break; 11937996a778SMike Christie default: 11947996a778SMike Christie rc = ISCSI_ERR_BAD_OPCODE; 11957996a778SMike Christie break; 11967996a778SMike Christie } 11973e5c28adSMike Christie goto out; 11983e5c28adSMike Christie } 11997996a778SMike Christie 12003e5c28adSMike Christie switch(opcode) { 12013e5c28adSMike Christie case ISCSI_OP_SCSI_CMD_RSP: 1202913e5bf4SMike Christie case ISCSI_OP_SCSI_DATA_IN: 1203913e5bf4SMike Christie task = iscsi_itt_to_ctask(conn, hdr->itt); 1204913e5bf4SMike Christie if (!task) 1205913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1206d355e57dSMike Christie task->last_xfer = jiffies; 12073e5c28adSMike Christie break; 1208913e5bf4SMike Christie case ISCSI_OP_R2T: 1209913e5bf4SMike Christie /* 1210913e5bf4SMike Christie * LLD handles R2Ts if they need to. 1211913e5bf4SMike Christie */ 1212913e5bf4SMike Christie return 0; 1213913e5bf4SMike Christie case ISCSI_OP_LOGOUT_RSP: 1214913e5bf4SMike Christie case ISCSI_OP_LOGIN_RSP: 1215913e5bf4SMike Christie case ISCSI_OP_TEXT_RSP: 1216913e5bf4SMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 1217913e5bf4SMike Christie case ISCSI_OP_NOOP_IN: 1218913e5bf4SMike Christie task = iscsi_itt_to_task(conn, hdr->itt); 1219913e5bf4SMike Christie if (!task) 1220913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1221913e5bf4SMike Christie break; 1222913e5bf4SMike Christie default: 1223913e5bf4SMike Christie return ISCSI_ERR_BAD_OPCODE; 12243e5c28adSMike Christie } 1225913e5bf4SMike Christie 1226913e5bf4SMike Christie switch(opcode) { 1227913e5bf4SMike Christie case ISCSI_OP_SCSI_CMD_RSP: 12289c19a7d0SMike Christie iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen); 12293e5c28adSMike Christie break; 12303e5c28adSMike Christie case ISCSI_OP_SCSI_DATA_IN: 12311d9edf02SMike Christie iscsi_data_in_rsp(conn, hdr, task); 12323e5c28adSMike Christie break; 12333e5c28adSMike Christie case ISCSI_OP_LOGOUT_RSP: 12343e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12353e5c28adSMike Christie if (datalen) { 12363e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12373e5c28adSMike Christie break; 12383e5c28adSMike Christie } 12393e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 12403e5c28adSMike Christie goto recv_pdu; 12413e5c28adSMike Christie case ISCSI_OP_LOGIN_RSP: 12423e5c28adSMike Christie case ISCSI_OP_TEXT_RSP: 12433e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12443e5c28adSMike Christie /* 12453e5c28adSMike Christie * login related PDU's exp_statsn is handled in 12463e5c28adSMike Christie * userspace 12473e5c28adSMike Christie */ 12483e5c28adSMike Christie goto recv_pdu; 12493e5c28adSMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 12503e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12513e5c28adSMike Christie if (datalen) { 12523e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12533e5c28adSMike Christie break; 12543e5c28adSMike Christie } 12553e5c28adSMike Christie 12563e5c28adSMike Christie iscsi_tmf_rsp(conn, hdr); 1257b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 12583e5c28adSMike Christie break; 12593e5c28adSMike Christie case ISCSI_OP_NOOP_IN: 12603e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12613e5c28adSMike Christie if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) { 12623e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12633e5c28adSMike Christie break; 12643e5c28adSMike Christie } 12653e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 12663e5c28adSMike Christie 12678afa1439SMike Christie rc = iscsi_nop_out_rsp(task, (struct iscsi_nopin*)hdr, 12688afa1439SMike Christie data, datalen); 12693e5c28adSMike Christie break; 12703e5c28adSMike Christie default: 12713e5c28adSMike Christie rc = ISCSI_ERR_BAD_OPCODE; 12723e5c28adSMike Christie break; 12733e5c28adSMike Christie } 12743e5c28adSMike Christie 12753e5c28adSMike Christie out: 12763e5c28adSMike Christie return rc; 12773e5c28adSMike Christie recv_pdu: 12783e5c28adSMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 12793e5c28adSMike Christie rc = ISCSI_ERR_CONN_FAILED; 1280b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 12817996a778SMike Christie return rc; 12827996a778SMike Christie } 1283913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_complete_pdu); 12847996a778SMike Christie 12857996a778SMike Christie int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 12867996a778SMike Christie char *data, int datalen) 12877996a778SMike Christie { 12887996a778SMike Christie int rc; 12897996a778SMike Christie 1290659743b0SShlomo Pongratz spin_lock(&conn->session->back_lock); 12917996a778SMike Christie rc = __iscsi_complete_pdu(conn, hdr, data, datalen); 1292659743b0SShlomo Pongratz spin_unlock(&conn->session->back_lock); 12937996a778SMike Christie return rc; 12947996a778SMike Christie } 12957996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_pdu); 12967996a778SMike Christie 12970af967f5SMike Christie int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt) 12987996a778SMike Christie { 12997996a778SMike Christie struct iscsi_session *session = conn->session; 1300262ef636SMike Christie int age = 0, i = 0; 13017996a778SMike Christie 13020af967f5SMike Christie if (itt == RESERVED_ITT) 13030af967f5SMike Christie return 0; 13040af967f5SMike Christie 1305262ef636SMike Christie if (session->tt->parse_pdu_itt) 1306262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, &age); 1307262ef636SMike Christie else { 1308262ef636SMike Christie i = get_itt(itt); 1309262ef636SMike Christie age = ((__force u32)itt >> ISCSI_AGE_SHIFT) & ISCSI_AGE_MASK; 1310262ef636SMike Christie } 1311262ef636SMike Christie 1312262ef636SMike Christie if (age != session->age) { 1313322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 13140af967f5SMike Christie "received itt %x expected session age (%x)\n", 1315913e5bf4SMike Christie (__force u32)itt, session->age); 13167996a778SMike Christie return ISCSI_ERR_BAD_ITT; 13177996a778SMike Christie } 13187996a778SMike Christie 13193e5c28adSMike Christie if (i >= session->cmds_max) { 13203e5c28adSMike Christie iscsi_conn_printk(KERN_ERR, conn, 13213e5c28adSMike Christie "received invalid itt index %u (max cmds " 13223e5c28adSMike Christie "%u.\n", i, session->cmds_max); 13233e5c28adSMike Christie return ISCSI_ERR_BAD_ITT; 13247996a778SMike Christie } 13257996a778SMike Christie return 0; 13267996a778SMike Christie } 13277996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_verify_itt); 13287996a778SMike Christie 1329913e5bf4SMike Christie /** 1330913e5bf4SMike Christie * iscsi_itt_to_ctask - look up ctask by itt 1331913e5bf4SMike Christie * @conn: iscsi connection 1332913e5bf4SMike Christie * @itt: itt 1333913e5bf4SMike Christie * 1334913e5bf4SMike Christie * This should be used for cmd tasks. 1335913e5bf4SMike Christie * 1336659743b0SShlomo Pongratz * The session back_lock must be held. 1337913e5bf4SMike Christie */ 1338913e5bf4SMike Christie struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt) 13390af967f5SMike Christie { 13409c19a7d0SMike Christie struct iscsi_task *task; 13410af967f5SMike Christie 13420af967f5SMike Christie if (iscsi_verify_itt(conn, itt)) 13430af967f5SMike Christie return NULL; 13440af967f5SMike Christie 1345913e5bf4SMike Christie task = iscsi_itt_to_task(conn, itt); 1346913e5bf4SMike Christie if (!task || !task->sc) 13470af967f5SMike Christie return NULL; 13480af967f5SMike Christie 1349913e5bf4SMike Christie if (task->sc->SCp.phase != conn->session->age) { 1350913e5bf4SMike Christie iscsi_session_printk(KERN_ERR, conn->session, 1351913e5bf4SMike Christie "task's session age %d, expected %d\n", 1352913e5bf4SMike Christie task->sc->SCp.phase, conn->session->age); 13530af967f5SMike Christie return NULL; 1354913e5bf4SMike Christie } 13550af967f5SMike Christie 13569c19a7d0SMike Christie return task; 13570af967f5SMike Christie } 13580af967f5SMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask); 13590af967f5SMike Christie 136040a06e75SMike Christie void iscsi_session_failure(struct iscsi_session *session, 1361e5bd7b54SMike Christie enum iscsi_err err) 1362e5bd7b54SMike Christie { 1363e5bd7b54SMike Christie struct iscsi_conn *conn; 1364e5bd7b54SMike Christie struct device *dev; 1365e5bd7b54SMike Christie 1366659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 1367e5bd7b54SMike Christie conn = session->leadconn; 1368e5bd7b54SMike Christie if (session->state == ISCSI_STATE_TERMINATE || !conn) { 1369659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1370e5bd7b54SMike Christie return; 1371e5bd7b54SMike Christie } 1372e5bd7b54SMike Christie 1373e5bd7b54SMike Christie dev = get_device(&conn->cls_conn->dev); 1374659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1375e5bd7b54SMike Christie if (!dev) 1376e5bd7b54SMike Christie return; 1377e5bd7b54SMike Christie /* 1378e5bd7b54SMike Christie * if the host is being removed bypass the connection 1379e5bd7b54SMike Christie * recovery initialization because we are going to kill 1380e5bd7b54SMike Christie * the session. 1381e5bd7b54SMike Christie */ 1382e5bd7b54SMike Christie if (err == ISCSI_ERR_INVALID_HOST) 1383e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 1384e5bd7b54SMike Christie else 1385e5bd7b54SMike Christie iscsi_conn_failure(conn, err); 1386e5bd7b54SMike Christie put_device(dev); 1387e5bd7b54SMike Christie } 1388e5bd7b54SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_failure); 1389e5bd7b54SMike Christie 1390*891e2639SMike Christie static bool iscsi_set_conn_failed(struct iscsi_conn *conn) 13917996a778SMike Christie { 13927996a778SMike Christie struct iscsi_session *session = conn->session; 13937996a778SMike Christie 1394*891e2639SMike Christie if (session->state == ISCSI_STATE_FAILED) 1395*891e2639SMike Christie return false; 1396656cffc9SMike Christie 139767a61114SMike Christie if (conn->stop_stage == 0) 13987996a778SMike Christie session->state = ISCSI_STATE_FAILED; 1399e5bd7b54SMike Christie 14007996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 14017996a778SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 1402*891e2639SMike Christie return true; 1403*891e2639SMike Christie } 1404*891e2639SMike Christie 1405*891e2639SMike Christie void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err) 1406*891e2639SMike Christie { 1407*891e2639SMike Christie struct iscsi_session *session = conn->session; 1408*891e2639SMike Christie bool needs_evt; 1409*891e2639SMike Christie 1410*891e2639SMike Christie spin_lock_bh(&session->frwd_lock); 1411*891e2639SMike Christie needs_evt = iscsi_set_conn_failed(conn); 1412*891e2639SMike Christie spin_unlock_bh(&session->frwd_lock); 1413*891e2639SMike Christie 1414*891e2639SMike Christie if (needs_evt) 1415e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 14167996a778SMike Christie } 14177996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_failure); 14187996a778SMike Christie 141977a23c21SMike Christie static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn) 142077a23c21SMike Christie { 142177a23c21SMike Christie struct iscsi_session *session = conn->session; 142277a23c21SMike Christie 142377a23c21SMike Christie /* 142477a23c21SMike Christie * Check for iSCSI window and take care of CmdSN wrap-around 142577a23c21SMike Christie */ 1426e0726407SMike Christie if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) { 14271b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iSCSI CmdSN closed. ExpCmdSn " 14281b2c7af8SMike Christie "%u MaxCmdSN %u CmdSN %u/%u\n", 14291b2c7af8SMike Christie session->exp_cmdsn, session->max_cmdsn, 14301b2c7af8SMike Christie session->cmdsn, session->queued_cmdsn); 143177a23c21SMike Christie return -ENOSPC; 143277a23c21SMike Christie } 143377a23c21SMike Christie return 0; 143477a23c21SMike Christie } 143577a23c21SMike Christie 14365923d64bSMike Christie static int iscsi_xmit_task(struct iscsi_conn *conn, struct iscsi_task *task, 14375923d64bSMike Christie bool was_requeue) 143877a23c21SMike Christie { 1439843c0a8aSMike Christie int rc; 144077a23c21SMike Christie 144179edd00dSAnoob Soman spin_lock_bh(&conn->session->back_lock); 14425923d64bSMike Christie 14435923d64bSMike Christie if (!conn->task) { 14445923d64bSMike Christie /* Take a ref so we can access it after xmit_task() */ 14455923d64bSMike Christie __iscsi_get_task(task); 14465923d64bSMike Christie } else { 14475923d64bSMike Christie /* Already have a ref from when we failed to send it last call */ 14485923d64bSMike Christie conn->task = NULL; 14495923d64bSMike Christie } 14505923d64bSMike Christie 14515923d64bSMike Christie /* 14525923d64bSMike Christie * If this was a requeue for a R2T we have an extra ref on the task in 14535923d64bSMike Christie * case a bad target sends a cmd rsp before we have handled the task. 14545923d64bSMike Christie */ 14555923d64bSMike Christie if (was_requeue) 14565923d64bSMike Christie __iscsi_put_task(task); 14575923d64bSMike Christie 14585923d64bSMike Christie /* 14595923d64bSMike Christie * Do this after dropping the extra ref because if this was a requeue 14605923d64bSMike Christie * it's removed from that list and cleanup_queued_task would miss it. 14615923d64bSMike Christie */ 14625923d64bSMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) { 14635923d64bSMike Christie /* 14645923d64bSMike Christie * Save the task and ref in case we weren't cleaning up this 14655923d64bSMike Christie * task and get woken up again. 14665923d64bSMike Christie */ 14675923d64bSMike Christie conn->task = task; 146879edd00dSAnoob Soman spin_unlock_bh(&conn->session->back_lock); 146979edd00dSAnoob Soman return -ENODATA; 147079edd00dSAnoob Soman } 147179edd00dSAnoob Soman spin_unlock_bh(&conn->session->back_lock); 14725923d64bSMike Christie 1473659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 14749c19a7d0SMike Christie rc = conn->session->tt->xmit_task(task); 1475659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 1476d355e57dSMike Christie if (!rc) { 14779c19a7d0SMike Christie /* done with this task */ 1478d355e57dSMike Christie task->last_xfer = jiffies; 1479d355e57dSMike Christie } 1480659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 148172b97402SShlomo Pongratz spin_lock(&conn->session->back_lock); 14825923d64bSMike Christie if (rc && task->state == ISCSI_TASK_RUNNING) { 14835923d64bSMike Christie /* 14845923d64bSMike Christie * get an extra ref that is released next time we access it 14855923d64bSMike Christie * as conn->task above. 14865923d64bSMike Christie */ 14875923d64bSMike Christie __iscsi_get_task(task); 14885923d64bSMike Christie conn->task = task; 14895923d64bSMike Christie } 14905923d64bSMike Christie 1491d355e57dSMike Christie __iscsi_put_task(task); 149272b97402SShlomo Pongratz spin_unlock(&conn->session->back_lock); 149377a23c21SMike Christie return rc; 149477a23c21SMike Christie } 149577a23c21SMike Christie 14967996a778SMike Christie /** 14979c19a7d0SMike Christie * iscsi_requeue_task - requeue task to run from session workqueue 14989c19a7d0SMike Christie * @task: task to requeue 1499843c0a8aSMike Christie * 15005923d64bSMike Christie * Callers must have taken a ref to the task that is going to be requeued. 1501843c0a8aSMike Christie */ 15029c19a7d0SMike Christie void iscsi_requeue_task(struct iscsi_task *task) 1503843c0a8aSMike Christie { 15049c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 1505843c0a8aSMike Christie 15063bbaaad9SMike Christie /* 15073bbaaad9SMike Christie * this may be on the requeue list already if the xmit_task callout 15083bbaaad9SMike Christie * is handling the r2ts while we are adding new ones 15093bbaaad9SMike Christie */ 15105923d64bSMike Christie spin_lock_bh(&conn->session->frwd_lock); 15115923d64bSMike Christie if (list_empty(&task->running)) { 15123bbaaad9SMike Christie list_add_tail(&task->running, &conn->requeue); 15135923d64bSMike Christie } else { 15145923d64bSMike Christie /* 15155923d64bSMike Christie * Don't need the extra ref since it's already requeued and 15165923d64bSMike Christie * has a ref. 15175923d64bSMike Christie */ 15185923d64bSMike Christie iscsi_put_task(task); 15195923d64bSMike Christie } 152032ae763eSMike Christie iscsi_conn_queue_work(conn); 15215923d64bSMike Christie spin_unlock_bh(&conn->session->frwd_lock); 1522843c0a8aSMike Christie } 15239c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_requeue_task); 1524843c0a8aSMike Christie 1525843c0a8aSMike Christie /** 15267996a778SMike Christie * iscsi_data_xmit - xmit any command into the scheduled connection 15277996a778SMike Christie * @conn: iscsi connection 15287996a778SMike Christie * 15297996a778SMike Christie * Notes: 15307996a778SMike Christie * The function can return -EAGAIN in which case the caller must 15317996a778SMike Christie * re-schedule it again later or recover. '0' return code means 15327996a778SMike Christie * successful xmit. 15337996a778SMike Christie **/ 15347996a778SMike Christie static int iscsi_data_xmit(struct iscsi_conn *conn) 15357996a778SMike Christie { 15365d12c05eSMike Christie struct iscsi_task *task; 15373219e529SMike Christie int rc = 0; 15387996a778SMike Christie 1539659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 154070b31c15SMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) { 15411b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n"); 1542659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 15433219e529SMike Christie return -ENODATA; 15447996a778SMike Christie } 15457996a778SMike Christie 15469c19a7d0SMike Christie if (conn->task) { 15475923d64bSMike Christie rc = iscsi_xmit_task(conn, conn->task, false); 15483219e529SMike Christie if (rc) 154970b31c15SMike Christie goto done; 15507996a778SMike Christie } 155177a23c21SMike Christie 155277a23c21SMike Christie /* 155377a23c21SMike Christie * process mgmt pdus like nops before commands since we should 155477a23c21SMike Christie * only have one nop-out as a ping from us and targets should not 155577a23c21SMike Christie * overflow us with nop-ins 155677a23c21SMike Christie */ 155777a23c21SMike Christie check_mgmt: 1558843c0a8aSMike Christie while (!list_empty(&conn->mgmtqueue)) { 15595923d64bSMike Christie task = list_entry(conn->mgmtqueue.next, struct iscsi_task, 15605923d64bSMike Christie running); 15615923d64bSMike Christie list_del_init(&task->running); 15625923d64bSMike Christie if (iscsi_prep_mgmt_task(conn, task)) { 1563659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 1564659743b0SShlomo Pongratz spin_lock_bh(&conn->session->back_lock); 15655923d64bSMike Christie __iscsi_put_task(task); 1566659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->back_lock); 1567b3a7ea8dSMike Christie continue; 1568b3a7ea8dSMike Christie } 15695923d64bSMike Christie rc = iscsi_xmit_task(conn, task, false); 15703219e529SMike Christie if (rc) 157170b31c15SMike Christie goto done; 15727996a778SMike Christie } 15737996a778SMike Christie 1574843c0a8aSMike Christie /* process pending command queue */ 15753bbaaad9SMike Christie while (!list_empty(&conn->cmdqueue)) { 15765923d64bSMike Christie task = list_entry(conn->cmdqueue.next, struct iscsi_task, 15775d12c05eSMike Christie running); 15785923d64bSMike Christie list_del_init(&task->running); 1579b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) { 15805923d64bSMike Christie fail_scsi_task(task, DID_IMM_RETRY); 1581b3a7ea8dSMike Christie continue; 1582b3a7ea8dSMike Christie } 15835923d64bSMike Christie rc = iscsi_prep_scsi_cmd_pdu(task); 1584577577daSMike Christie if (rc) { 1585d28d48c6SMike Christie if (rc == -ENOMEM || rc == -EACCES) 15865923d64bSMike Christie fail_scsi_task(task, DID_IMM_RETRY); 1587d28d48c6SMike Christie else 15885923d64bSMike Christie fail_scsi_task(task, DID_ABORT); 1589004d6530SBoaz Harrosh continue; 1590004d6530SBoaz Harrosh } 15915923d64bSMike Christie rc = iscsi_xmit_task(conn, task, false); 15923219e529SMike Christie if (rc) 159370b31c15SMike Christie goto done; 159477a23c21SMike Christie /* 15959c19a7d0SMike Christie * we could continuously get new task requests so 159677a23c21SMike Christie * we need to check the mgmt queue for nops that need to 159777a23c21SMike Christie * be sent to aviod starvation 159877a23c21SMike Christie */ 1599843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 1600843c0a8aSMike Christie goto check_mgmt; 1601843c0a8aSMike Christie } 1602843c0a8aSMike Christie 1603843c0a8aSMike Christie while (!list_empty(&conn->requeue)) { 1604b3a7ea8dSMike Christie /* 1605b3a7ea8dSMike Christie * we always do fastlogout - conn stop code will clean up. 1606b3a7ea8dSMike Christie */ 1607b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 1608b3a7ea8dSMike Christie break; 1609b3a7ea8dSMike Christie 16105d12c05eSMike Christie task = list_entry(conn->requeue.next, struct iscsi_task, 16115d12c05eSMike Christie running); 16125923d64bSMike Christie 16135d12c05eSMike Christie if (iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_DATA_OUT)) 16145d12c05eSMike Christie break; 16155d12c05eSMike Christie 16165923d64bSMike Christie list_del_init(&task->running); 16175923d64bSMike Christie rc = iscsi_xmit_task(conn, task, true); 1618843c0a8aSMike Christie if (rc) 161970b31c15SMike Christie goto done; 1620843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 162177a23c21SMike Christie goto check_mgmt; 16227996a778SMike Christie } 1623659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 16243219e529SMike Christie return -ENODATA; 16257996a778SMike Christie 162670b31c15SMike Christie done: 1627659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 16283219e529SMike Christie return rc; 16297996a778SMike Christie } 16307996a778SMike Christie 1631c4028958SDavid Howells static void iscsi_xmitworker(struct work_struct *work) 16327996a778SMike Christie { 1633c4028958SDavid Howells struct iscsi_conn *conn = 1634c4028958SDavid Howells container_of(work, struct iscsi_conn, xmitwork); 16353219e529SMike Christie int rc; 16367996a778SMike Christie /* 16377996a778SMike Christie * serialize Xmit worker on a per-connection basis. 16387996a778SMike Christie */ 16393219e529SMike Christie do { 16403219e529SMike Christie rc = iscsi_data_xmit(conn); 16413219e529SMike Christie } while (rc >= 0 || rc == -EAGAIN); 16427996a778SMike Christie } 16437996a778SMike Christie 1644577577daSMike Christie static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn, 1645577577daSMike Christie struct scsi_cmnd *sc) 1646577577daSMike Christie { 1647577577daSMike Christie struct iscsi_task *task; 1648577577daSMike Christie 16497acd72ebSStefani Seibold if (!kfifo_out(&conn->session->cmdpool.queue, 1650577577daSMike Christie (void *) &task, sizeof(void *))) 1651577577daSMike Christie return NULL; 1652577577daSMike Christie 1653577577daSMike Christie sc->SCp.phase = conn->session->age; 1654577577daSMike Christie sc->SCp.ptr = (char *) task; 1655577577daSMike Christie 16566dc618cdSElena Reshetova refcount_set(&task->refcount, 1); 1657577577daSMike Christie task->state = ISCSI_TASK_PENDING; 1658577577daSMike Christie task->conn = conn; 1659577577daSMike Christie task->sc = sc; 1660d355e57dSMike Christie task->have_checked_conn = false; 1661d355e57dSMike Christie task->last_timeout = jiffies; 1662d355e57dSMike Christie task->last_xfer = jiffies; 166355e51edaSSagi Grimberg task->protected = false; 1664577577daSMike Christie INIT_LIST_HEAD(&task->running); 1665577577daSMike Christie return task; 1666577577daSMike Christie } 1667577577daSMike Christie 16687996a778SMike Christie enum { 16697996a778SMike Christie FAILURE_BAD_HOST = 1, 16707996a778SMike Christie FAILURE_SESSION_FAILED, 16717996a778SMike Christie FAILURE_SESSION_FREED, 16727996a778SMike Christie FAILURE_WINDOW_CLOSED, 167360ecebf5SMike Christie FAILURE_OOM, 16747996a778SMike Christie FAILURE_SESSION_TERMINATE, 1675656cffc9SMike Christie FAILURE_SESSION_IN_RECOVERY, 16767996a778SMike Christie FAILURE_SESSION_RECOVERY_TIMEOUT, 1677b3a7ea8dSMike Christie FAILURE_SESSION_LOGGING_OUT, 16786eabafbeSMike Christie FAILURE_SESSION_NOT_READY, 16797996a778SMike Christie }; 16807996a778SMike Christie 1681f41d4721SMike Christie int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc) 16827996a778SMike Christie { 168375613521SMike Christie struct iscsi_cls_session *cls_session; 16841336aed1SMike Christie struct iscsi_host *ihost; 16857996a778SMike Christie int reason = 0; 16867996a778SMike Christie struct iscsi_session *session; 16877996a778SMike Christie struct iscsi_conn *conn; 16889c19a7d0SMike Christie struct iscsi_task *task = NULL; 16897996a778SMike Christie 16907996a778SMike Christie sc->result = 0; 1691f47f2cf5SMike Christie sc->SCp.ptr = NULL; 16927996a778SMike Christie 16931336aed1SMike Christie ihost = shost_priv(host); 16947996a778SMike Christie 169575613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 169675613521SMike Christie session = cls_session->dd_data; 1697659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 16987996a778SMike Christie 169975613521SMike Christie reason = iscsi_session_chkready(cls_session); 17006eabafbeSMike Christie if (reason) { 17016eabafbeSMike Christie sc->result = reason; 17026eabafbeSMike Christie goto fault; 17036eabafbeSMike Christie } 17046eabafbeSMike Christie 1705301e0f7eSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1706656cffc9SMike Christie /* 1707656cffc9SMike Christie * to handle the race between when we set the recovery state 1708656cffc9SMike Christie * and block the session we requeue here (commands could 1709656cffc9SMike Christie * be entering our queuecommand while a block is starting 1710656cffc9SMike Christie * up because the block code is not locked) 1711656cffc9SMike Christie */ 17129000bcd6SMike Christie switch (session->state) { 1713301e0f7eSMike Christie case ISCSI_STATE_FAILED: 1714d7549412SRafael David Tinoco /* 1715d7549412SRafael David Tinoco * cmds should fail during shutdown, if the session 1716d7549412SRafael David Tinoco * state is bad, allowing completion to happen 1717d7549412SRafael David Tinoco */ 1718d7549412SRafael David Tinoco if (unlikely(system_state != SYSTEM_RUNNING)) { 1719d7549412SRafael David Tinoco reason = FAILURE_SESSION_FAILED; 1720d7549412SRafael David Tinoco sc->result = DID_NO_CONNECT << 16; 1721d7549412SRafael David Tinoco break; 1722d7549412SRafael David Tinoco } 1723df561f66SGustavo A. R. Silva fallthrough; 17249000bcd6SMike Christie case ISCSI_STATE_IN_RECOVERY: 1725656cffc9SMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1726301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1727301e0f7eSMike Christie break; 17289000bcd6SMike Christie case ISCSI_STATE_LOGGING_OUT: 17299000bcd6SMike Christie reason = FAILURE_SESSION_LOGGING_OUT; 1730301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1731301e0f7eSMike Christie break; 1732b3a7ea8dSMike Christie case ISCSI_STATE_RECOVERY_FAILED: 1733656cffc9SMike Christie reason = FAILURE_SESSION_RECOVERY_TIMEOUT; 173456d7fcfaSMike Christie sc->result = DID_TRANSPORT_FAILFAST << 16; 1735b3a7ea8dSMike Christie break; 1736b3a7ea8dSMike Christie case ISCSI_STATE_TERMINATE: 1737656cffc9SMike Christie reason = FAILURE_SESSION_TERMINATE; 17386eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1739b3a7ea8dSMike Christie break; 1740b3a7ea8dSMike Christie default: 17417996a778SMike Christie reason = FAILURE_SESSION_FREED; 17426eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1743b3a7ea8dSMike Christie } 17447996a778SMike Christie goto fault; 17457996a778SMike Christie } 17467996a778SMike Christie 17477996a778SMike Christie conn = session->leadconn; 174898644047SMike Christie if (!conn) { 174998644047SMike Christie reason = FAILURE_SESSION_FREED; 17506eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 175198644047SMike Christie goto fault; 175298644047SMike Christie } 17537996a778SMike Christie 1754661134adSMike Christie if (test_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx)) { 1755661134adSMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1756eef9ffdfSJohannes Thumshirn sc->result = DID_REQUEUE << 16; 1757661134adSMike Christie goto fault; 1758661134adSMike Christie } 1759661134adSMike Christie 176077a23c21SMike Christie if (iscsi_check_cmdsn_window_closed(conn)) { 176177a23c21SMike Christie reason = FAILURE_WINDOW_CLOSED; 176277a23c21SMike Christie goto reject; 176377a23c21SMike Christie } 176477a23c21SMike Christie 1765577577daSMike Christie task = iscsi_alloc_task(conn, sc); 1766577577daSMike Christie if (!task) { 176760ecebf5SMike Christie reason = FAILURE_OOM; 176860ecebf5SMike Christie goto reject; 176960ecebf5SMike Christie } 17707996a778SMike Christie 17711336aed1SMike Christie if (!ihost->workq) { 1772577577daSMike Christie reason = iscsi_prep_scsi_cmd_pdu(task); 1773577577daSMike Christie if (reason) { 17745d12c05eSMike Christie if (reason == -ENOMEM || reason == -EACCES) { 1775577577daSMike Christie reason = FAILURE_OOM; 1776577577daSMike Christie goto prepd_reject; 1777577577daSMike Christie } else { 1778052d0144SMike Christie sc->result = DID_ABORT << 16; 1779577577daSMike Christie goto prepd_fault; 1780577577daSMike Christie } 1781052d0144SMike Christie } 17829c19a7d0SMike Christie if (session->tt->xmit_task(task)) { 1783d3305f34SMike Christie session->cmdsn--; 1784052d0144SMike Christie reason = FAILURE_SESSION_NOT_READY; 1785577577daSMike Christie goto prepd_reject; 1786052d0144SMike Christie } 17873bbaaad9SMike Christie } else { 17883bbaaad9SMike Christie list_add_tail(&task->running, &conn->cmdqueue); 178932ae763eSMike Christie iscsi_conn_queue_work(conn); 17903bbaaad9SMike Christie } 1791052d0144SMike Christie 1792052d0144SMike Christie session->queued_cmdsn++; 1793659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 17947996a778SMike Christie return 0; 17957996a778SMike Christie 1796577577daSMike Christie prepd_reject: 1797a656183eSLee Duncan spin_lock_bh(&session->back_lock); 1798f41d4721SMike Christie iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 1799a656183eSLee Duncan spin_unlock_bh(&session->back_lock); 18007996a778SMike Christie reject: 1801659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 18021b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n", 18031b2c7af8SMike Christie sc->cmnd[0], reason); 1804d6d13ee1SMike Christie return SCSI_MLQUEUE_TARGET_BUSY; 18057996a778SMike Christie 1806577577daSMike Christie prepd_fault: 1807a656183eSLee Duncan spin_lock_bh(&session->back_lock); 1808f41d4721SMike Christie iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 1809a656183eSLee Duncan spin_unlock_bh(&session->back_lock); 18107996a778SMike Christie fault: 1811659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 18121b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n", 18131b2c7af8SMike Christie sc->cmnd[0], reason); 18141c138991SFUJITA Tomonori scsi_set_resid(sc, scsi_bufflen(sc)); 1815f41d4721SMike Christie sc->scsi_done(sc); 18167996a778SMike Christie return 0; 18177996a778SMike Christie } 18187996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_queuecommand); 18197996a778SMike Christie 18206b5d6c44SMike Christie int iscsi_target_alloc(struct scsi_target *starget) 18216b5d6c44SMike Christie { 18226b5d6c44SMike Christie struct iscsi_cls_session *cls_session = starget_to_session(starget); 18236b5d6c44SMike Christie struct iscsi_session *session = cls_session->dd_data; 18246b5d6c44SMike Christie 18256b5d6c44SMike Christie starget->can_queue = session->scsi_cmds_max; 18266b5d6c44SMike Christie return 0; 18276b5d6c44SMike Christie } 18286b5d6c44SMike Christie EXPORT_SYMBOL_GPL(iscsi_target_alloc); 18296b5d6c44SMike Christie 18302c4b9637SKees Cook static void iscsi_tmf_timedout(struct timer_list *t) 18317996a778SMike Christie { 18322c4b9637SKees Cook struct iscsi_conn *conn = from_timer(conn, t, tmf_timer); 18337996a778SMike Christie struct iscsi_session *session = conn->session; 18347996a778SMike Christie 1835659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 1836843c0a8aSMike Christie if (conn->tmf_state == TMF_QUEUED) { 1837843c0a8aSMike Christie conn->tmf_state = TMF_TIMEDOUT; 1838bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf timedout\n"); 18397996a778SMike Christie /* unblock eh_abort() */ 18407996a778SMike Christie wake_up(&conn->ehwait); 18417996a778SMike Christie } 1842659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 18437996a778SMike Christie } 18447996a778SMike Christie 18459c19a7d0SMike Christie static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, 1846f6d5180cSMike Christie struct iscsi_tm *hdr, int age, 1847f6d5180cSMike Christie int timeout) 18481360c58aSBart Van Assche __must_hold(&session->frwd_lock) 18497996a778SMike Christie { 18507996a778SMike Christie struct iscsi_session *session = conn->session; 18519c19a7d0SMike Christie struct iscsi_task *task; 18527996a778SMike Christie 18539c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr, 18547996a778SMike Christie NULL, 0); 18559c19a7d0SMike Christie if (!task) { 1856659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1857df4da5cdSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send TMF.\n"); 18587996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1859659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 186077a23c21SMike Christie return -EPERM; 18617996a778SMike Christie } 18627996a778SMike Christie conn->tmfcmd_pdus_cnt++; 1863f6d5180cSMike Christie conn->tmf_timer.expires = timeout * HZ + jiffies; 1864843c0a8aSMike Christie add_timer(&conn->tmf_timer); 1865bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf set timeout\n"); 1866843c0a8aSMike Christie 1867659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 18686724add1SMike Christie mutex_unlock(&session->eh_mutex); 18697996a778SMike Christie 18707996a778SMike Christie /* 18717996a778SMike Christie * block eh thread until: 18727996a778SMike Christie * 1873843c0a8aSMike Christie * 1) tmf response 1874843c0a8aSMike Christie * 2) tmf timeout 18757996a778SMike Christie * 3) session is terminated or restarted or userspace has 18767996a778SMike Christie * given up on recovery 18777996a778SMike Christie */ 1878843c0a8aSMike Christie wait_event_interruptible(conn->ehwait, age != session->age || 18797996a778SMike Christie session->state != ISCSI_STATE_LOGGED_IN || 1880843c0a8aSMike Christie conn->tmf_state != TMF_QUEUED); 18817996a778SMike Christie if (signal_pending(current)) 18827996a778SMike Christie flush_signals(current); 1883843c0a8aSMike Christie del_timer_sync(&conn->tmf_timer); 1884843c0a8aSMike Christie 18856724add1SMike Christie mutex_lock(&session->eh_mutex); 1886659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 18879c19a7d0SMike Christie /* if the session drops it will clean up the task */ 1888843c0a8aSMike Christie if (age != session->age || 1889843c0a8aSMike Christie session->state != ISCSI_STATE_LOGGED_IN) 1890843c0a8aSMike Christie return -ENOTCONN; 18917996a778SMike Christie return 0; 18927996a778SMike Christie } 18937996a778SMike Christie 18947996a778SMike Christie /* 189514936b1eSMike Christie * Fail commands. session frwd lock held and xmit thread flushed. 1896843c0a8aSMike Christie */ 18979cb78c16SHannes Reinecke static void fail_scsi_tasks(struct iscsi_conn *conn, u64 lun, int error) 1898843c0a8aSMike Christie { 189914936b1eSMike Christie struct iscsi_session *session = conn->session; 19003bbaaad9SMike Christie struct iscsi_task *task; 19013bbaaad9SMike Christie int i; 1902843c0a8aSMike Christie 190314936b1eSMike Christie spin_lock_bh(&session->back_lock); 190414936b1eSMike Christie for (i = 0; i < session->cmds_max; i++) { 190514936b1eSMike Christie task = session->cmds[i]; 19063bbaaad9SMike Christie if (!task->sc || task->state == ISCSI_TASK_FREE) 19073bbaaad9SMike Christie continue; 1908843c0a8aSMike Christie 19093bbaaad9SMike Christie if (lun != -1 && lun != task->sc->device->lun) 19103bbaaad9SMike Christie continue; 19113bbaaad9SMike Christie 191214936b1eSMike Christie __iscsi_get_task(task); 191314936b1eSMike Christie spin_unlock_bh(&session->back_lock); 191414936b1eSMike Christie 191514936b1eSMike Christie ISCSI_DBG_SESSION(session, 19163bbaaad9SMike Christie "failing sc %p itt 0x%x state %d\n", 19173bbaaad9SMike Christie task->sc, task->itt, task->state); 1918b3cd5050SMike Christie fail_scsi_task(task, error); 191914936b1eSMike Christie 192014936b1eSMike Christie spin_unlock_bh(&session->frwd_lock); 192114936b1eSMike Christie iscsi_put_task(task); 192214936b1eSMike Christie spin_lock_bh(&session->frwd_lock); 192314936b1eSMike Christie 192414936b1eSMike Christie spin_lock_bh(&session->back_lock); 1925843c0a8aSMike Christie } 192614936b1eSMike Christie 192714936b1eSMike Christie spin_unlock_bh(&session->back_lock); 1928843c0a8aSMike Christie } 1929843c0a8aSMike Christie 1930661134adSMike Christie /** 1931661134adSMike Christie * iscsi_suspend_queue - suspend iscsi_queuecommand 1932661134adSMike Christie * @conn: iscsi conn to stop queueing IO on 1933661134adSMike Christie * 1934659743b0SShlomo Pongratz * This grabs the session frwd_lock to make sure no one is in 1935661134adSMike Christie * xmit_task/queuecommand, and then sets suspend to prevent 1936661134adSMike Christie * new commands from being queued. This only needs to be called 1937661134adSMike Christie * by offload drivers that need to sync a path like ep disconnect 1938661134adSMike Christie * with the iscsi_queuecommand/xmit_task. To start IO again libiscsi 1939661134adSMike Christie * will call iscsi_start_tx and iscsi_unblock_session when in FFP. 1940661134adSMike Christie */ 1941661134adSMike Christie void iscsi_suspend_queue(struct iscsi_conn *conn) 1942661134adSMike Christie { 1943659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 1944661134adSMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 1945659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 1946661134adSMike Christie } 1947661134adSMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_queue); 1948661134adSMike Christie 1949661134adSMike Christie /** 1950661134adSMike Christie * iscsi_suspend_tx - suspend iscsi_data_xmit 1951661134adSMike Christie * @conn: iscsi conn tp stop processing IO on. 1952661134adSMike Christie * 1953661134adSMike Christie * This function sets the suspend bit to prevent iscsi_data_xmit 1954661134adSMike Christie * from sending new IO, and if work is queued on the xmit thread 1955661134adSMike Christie * it will wait for it to be completed. 1956661134adSMike Christie */ 1957b40977d9SMike Christie void iscsi_suspend_tx(struct iscsi_conn *conn) 19586724add1SMike Christie { 195932ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 196032ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 196132ae763eSMike Christie 19626724add1SMike Christie set_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 19631336aed1SMike Christie if (ihost->workq) 196432ae763eSMike Christie flush_workqueue(ihost->workq); 19656724add1SMike Christie } 1966b40977d9SMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_tx); 19676724add1SMike Christie 19686724add1SMike Christie static void iscsi_start_tx(struct iscsi_conn *conn) 19696724add1SMike Christie { 19706724add1SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 197132ae763eSMike Christie iscsi_conn_queue_work(conn); 19726724add1SMike Christie } 19736724add1SMike Christie 19744c48a829SMike Christie /* 19754c48a829SMike Christie * We want to make sure a ping is in flight. It has timed out. 19764c48a829SMike Christie * And we are not busy processing a pdu that is making 19774c48a829SMike Christie * progress but got started before the ping and is taking a while 19784c48a829SMike Christie * to complete so the ping is just stuck behind it in a queue. 19794c48a829SMike Christie */ 19804c48a829SMike Christie static int iscsi_has_ping_timed_out(struct iscsi_conn *conn) 19814c48a829SMike Christie { 1982fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task) && 19834c48a829SMike Christie time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) + 19844c48a829SMike Christie (conn->ping_timeout * HZ), jiffies)) 19854c48a829SMike Christie return 1; 19864c48a829SMike Christie else 19874c48a829SMike Christie return 0; 19884c48a829SMike Christie } 19894c48a829SMike Christie 1990b6a05c82SChristoph Hellwig enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc) 1991f6d5180cSMike Christie { 19926600593cSChristoph Hellwig enum blk_eh_timer_return rc = BLK_EH_DONE; 199392ed4d69SMike Christie struct iscsi_task *task = NULL, *running_task; 1994f6d5180cSMike Christie struct iscsi_cls_session *cls_session; 1995f6d5180cSMike Christie struct iscsi_session *session; 1996f6d5180cSMike Christie struct iscsi_conn *conn; 199792ed4d69SMike Christie int i; 1998f6d5180cSMike Christie 1999d355e57dSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 200075613521SMike Christie session = cls_session->dd_data; 2001f6d5180cSMike Christie 2002bd2199d4SErez Zilber ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc); 2003f6d5180cSMike Christie 20045480e299SBart Van Assche spin_lock_bh(&session->frwd_lock); 200514936b1eSMike Christie spin_lock(&session->back_lock); 2006e3d338a5SMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 2007e3d338a5SMike Christie if (!task) { 2008e3d338a5SMike Christie /* 2009e3d338a5SMike Christie * Raced with completion. Blk layer has taken ownership 2010e3d338a5SMike Christie * so let timeout code complete it now. 2011e3d338a5SMike Christie */ 2012adb2b769SChristoph Hellwig rc = BLK_EH_DONE; 201314936b1eSMike Christie spin_unlock(&session->back_lock); 2014e3d338a5SMike Christie goto done; 2015e3d338a5SMike Christie } 201614936b1eSMike Christie __iscsi_get_task(task); 201714936b1eSMike Christie spin_unlock(&session->back_lock); 2018e3d338a5SMike Christie 2019f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 2020f6d5180cSMike Christie /* 2021d7549412SRafael David Tinoco * During shutdown, if session is prematurely disconnected, 2022d7549412SRafael David Tinoco * recovery won't happen and there will be hung cmds. Not 2023d7549412SRafael David Tinoco * handling cmds would trigger EH, also bad in this case. 2024d7549412SRafael David Tinoco * Instead, handle cmd, allow completion to happen and let 2025d7549412SRafael David Tinoco * upper layer to deal with the result. 2026d7549412SRafael David Tinoco */ 2027d7549412SRafael David Tinoco if (unlikely(system_state != SYSTEM_RUNNING)) { 2028d7549412SRafael David Tinoco sc->result = DID_NO_CONNECT << 16; 2029d7549412SRafael David Tinoco ISCSI_DBG_EH(session, "sc on shutdown, handled\n"); 2030adb2b769SChristoph Hellwig rc = BLK_EH_DONE; 2031d7549412SRafael David Tinoco goto done; 2032d7549412SRafael David Tinoco } 2033d7549412SRafael David Tinoco /* 2034f6d5180cSMike Christie * We are probably in the middle of iscsi recovery so let 2035f6d5180cSMike Christie * that complete and handle the error. 2036f6d5180cSMike Christie */ 2037242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 2038f6d5180cSMike Christie goto done; 2039f6d5180cSMike Christie } 2040f6d5180cSMike Christie 2041f6d5180cSMike Christie conn = session->leadconn; 2042f6d5180cSMike Christie if (!conn) { 2043f6d5180cSMike Christie /* In the middle of shuting down */ 2044242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 2045f6d5180cSMike Christie goto done; 2046f6d5180cSMike Christie } 2047f6d5180cSMike Christie 2048d355e57dSMike Christie /* 2049d355e57dSMike Christie * If we have sent (at least queued to the network layer) a pdu or 2050d355e57dSMike Christie * recvd one for the task since the last timeout ask for 2051d355e57dSMike Christie * more time. If on the next timeout we have not made progress 2052d355e57dSMike Christie * we can check if it is the task or connection when we send the 2053d355e57dSMike Christie * nop as a ping. 2054d355e57dSMike Christie */ 205592ed4d69SMike Christie if (time_after(task->last_xfer, task->last_timeout)) { 2056bd2199d4SErez Zilber ISCSI_DBG_EH(session, "Command making progress. Asking " 2057d355e57dSMike Christie "scsi-ml for more time to complete. " 205892ed4d69SMike Christie "Last data xfer at %lu. Last timeout was at " 2059d355e57dSMike Christie "%lu\n.", task->last_xfer, task->last_timeout); 2060d355e57dSMike Christie task->have_checked_conn = false; 2061d355e57dSMike Christie rc = BLK_EH_RESET_TIMER; 2062d355e57dSMike Christie goto done; 2063d355e57dSMike Christie } 2064d355e57dSMike Christie 2065f6d5180cSMike Christie if (!conn->recv_timeout && !conn->ping_timeout) 2066f6d5180cSMike Christie goto done; 2067f6d5180cSMike Christie /* 2068f6d5180cSMike Christie * if the ping timedout then we are in the middle of cleaning up 2069f6d5180cSMike Christie * and can let the iscsi eh handle it 2070f6d5180cSMike Christie */ 20714c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 2072242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 20734c48a829SMike Christie goto done; 20744c48a829SMike Christie } 2075d355e57dSMike Christie 207614936b1eSMike Christie spin_lock(&session->back_lock); 207792ed4d69SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 207892ed4d69SMike Christie running_task = conn->session->cmds[i]; 207992ed4d69SMike Christie if (!running_task->sc || running_task == task || 208092ed4d69SMike Christie running_task->state != ISCSI_TASK_RUNNING) 208192ed4d69SMike Christie continue; 208292ed4d69SMike Christie 208392ed4d69SMike Christie /* 208492ed4d69SMike Christie * Only check if cmds started before this one have made 208592ed4d69SMike Christie * progress, or this could never fail 208692ed4d69SMike Christie */ 208792ed4d69SMike Christie if (time_after(running_task->sc->jiffies_at_alloc, 208892ed4d69SMike Christie task->sc->jiffies_at_alloc)) 208992ed4d69SMike Christie continue; 209092ed4d69SMike Christie 209192ed4d69SMike Christie if (time_after(running_task->last_xfer, task->last_timeout)) { 209292ed4d69SMike Christie /* 209392ed4d69SMike Christie * This task has not made progress, but a task 209492ed4d69SMike Christie * started before us has transferred data since 209592ed4d69SMike Christie * we started/last-checked. We could be queueing 209692ed4d69SMike Christie * too many tasks or the LU is bad. 209792ed4d69SMike Christie * 209892ed4d69SMike Christie * If the device is bad the cmds ahead of us on 209992ed4d69SMike Christie * other devs will complete, and this loop will 210092ed4d69SMike Christie * eventually fail starting the scsi eh. 210192ed4d69SMike Christie */ 210292ed4d69SMike Christie ISCSI_DBG_EH(session, "Command has not made progress " 210392ed4d69SMike Christie "but commands ahead of it have. " 210492ed4d69SMike Christie "Asking scsi-ml for more time to " 210592ed4d69SMike Christie "complete. Our last xfer vs running task " 210692ed4d69SMike Christie "last xfer %lu/%lu. Last check %lu.\n", 210792ed4d69SMike Christie task->last_xfer, running_task->last_xfer, 210892ed4d69SMike Christie task->last_timeout); 210914936b1eSMike Christie spin_unlock(&session->back_lock); 211092ed4d69SMike Christie rc = BLK_EH_RESET_TIMER; 211192ed4d69SMike Christie goto done; 211292ed4d69SMike Christie } 211392ed4d69SMike Christie } 211414936b1eSMike Christie spin_unlock(&session->back_lock); 211592ed4d69SMike Christie 2116d355e57dSMike Christie /* Assumes nop timeout is shorter than scsi cmd timeout */ 2117d355e57dSMike Christie if (task->have_checked_conn) 2118d355e57dSMike Christie goto done; 2119d355e57dSMike Christie 2120f6d5180cSMike Christie /* 2121d355e57dSMike Christie * Checking the transport already or nop from a cmd timeout still 2122d355e57dSMike Christie * running 2123f6d5180cSMike Christie */ 2124fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task)) { 2125d355e57dSMike Christie task->have_checked_conn = true; 2126242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 21274c48a829SMike Christie goto done; 21284c48a829SMike Christie } 21294c48a829SMike Christie 2130d355e57dSMike Christie /* Make sure there is a transport check done */ 2131d355e57dSMike Christie iscsi_send_nopout(conn, NULL); 2132d355e57dSMike Christie task->have_checked_conn = true; 2133242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 2134d355e57dSMike Christie 2135f6d5180cSMike Christie done: 21365480e299SBart Van Assche spin_unlock_bh(&session->frwd_lock); 213714936b1eSMike Christie 213814936b1eSMike Christie if (task) { 213914936b1eSMike Christie task->last_timeout = jiffies; 214014936b1eSMike Christie iscsi_put_task(task); 214114936b1eSMike Christie } 2142bd2199d4SErez Zilber ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ? 2143d7549412SRafael David Tinoco "timer reset" : "shutdown or nh"); 2144f6d5180cSMike Christie return rc; 2145f6d5180cSMike Christie } 2146b6a05c82SChristoph Hellwig EXPORT_SYMBOL_GPL(iscsi_eh_cmd_timed_out); 2147f6d5180cSMike Christie 21482c4b9637SKees Cook static void iscsi_check_transport_timeouts(struct timer_list *t) 2149f6d5180cSMike Christie { 21502c4b9637SKees Cook struct iscsi_conn *conn = from_timer(conn, t, transport_timer); 2151f6d5180cSMike Christie struct iscsi_session *session = conn->session; 21524cf10435SMike Christie unsigned long recv_timeout, next_timeout = 0, last_recv; 2153f6d5180cSMike Christie 2154659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 2155f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 2156f6d5180cSMike Christie goto done; 2157f6d5180cSMike Christie 21584cf10435SMike Christie recv_timeout = conn->recv_timeout; 21594cf10435SMike Christie if (!recv_timeout) 2160f6d5180cSMike Christie goto done; 2161f6d5180cSMike Christie 21624cf10435SMike Christie recv_timeout *= HZ; 2163f6d5180cSMike Christie last_recv = conn->last_recv; 21644c48a829SMike Christie 21654c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 2166322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs " 21674c48a829SMike Christie "expired, recv timeout %d, last rx %lu, " 21684c48a829SMike Christie "last ping %lu, now %lu\n", 21694c48a829SMike Christie conn->ping_timeout, conn->recv_timeout, 21704c48a829SMike Christie last_recv, conn->last_ping, jiffies); 2171659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 217209ff742cSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_NOP_TIMEDOUT); 2173f6d5180cSMike Christie return; 2174f6d5180cSMike Christie } 2175f6d5180cSMike Christie 21764cf10435SMike Christie if (time_before_eq(last_recv + recv_timeout, jiffies)) { 2177f6d5180cSMike Christie /* send a ping to try to provoke some traffic */ 21781b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Sending nopout as ping\n"); 217952f5664aSAriel Nahum if (iscsi_send_nopout(conn, NULL)) 218052f5664aSAriel Nahum next_timeout = jiffies + (1 * HZ); 218152f5664aSAriel Nahum else 21824cf10435SMike Christie next_timeout = conn->last_ping + (conn->ping_timeout * HZ); 2183ad294e9cSMike Christie } else 21844cf10435SMike Christie next_timeout = last_recv + recv_timeout; 2185f6d5180cSMike Christie 21861b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout); 2187f6d5180cSMike Christie mod_timer(&conn->transport_timer, next_timeout); 2188f6d5180cSMike Christie done: 2189659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 2190f6d5180cSMike Christie } 2191f6d5180cSMike Christie 2192*891e2639SMike Christie /** 2193*891e2639SMike Christie * iscsi_conn_unbind - prevent queueing to conn. 2194*891e2639SMike Christie * @cls_conn: iscsi conn ep is bound to. 2195*891e2639SMike Christie * @is_active: is the conn in use for boot or is this for EH/termination 2196*891e2639SMike Christie * 2197*891e2639SMike Christie * This must be called by drivers implementing the ep_disconnect callout. 2198*891e2639SMike Christie * It disables queueing to the connection from libiscsi in preparation for 2199*891e2639SMike Christie * an ep_disconnect call. 2200*891e2639SMike Christie */ 2201*891e2639SMike Christie void iscsi_conn_unbind(struct iscsi_cls_conn *cls_conn, bool is_active) 2202*891e2639SMike Christie { 2203*891e2639SMike Christie struct iscsi_session *session; 2204*891e2639SMike Christie struct iscsi_conn *conn; 2205*891e2639SMike Christie 2206*891e2639SMike Christie if (!cls_conn) 2207*891e2639SMike Christie return; 2208*891e2639SMike Christie 2209*891e2639SMike Christie conn = cls_conn->dd_data; 2210*891e2639SMike Christie session = conn->session; 2211*891e2639SMike Christie /* 2212*891e2639SMike Christie * Wait for iscsi_eh calls to exit. We don't wait for the tmf to 2213*891e2639SMike Christie * complete or timeout. The caller just wants to know what's running 2214*891e2639SMike Christie * is everything that needs to be cleaned up, and no cmds will be 2215*891e2639SMike Christie * queued. 2216*891e2639SMike Christie */ 2217*891e2639SMike Christie mutex_lock(&session->eh_mutex); 2218*891e2639SMike Christie 2219*891e2639SMike Christie iscsi_suspend_queue(conn); 2220*891e2639SMike Christie iscsi_suspend_tx(conn); 2221*891e2639SMike Christie 2222*891e2639SMike Christie spin_lock_bh(&session->frwd_lock); 2223*891e2639SMike Christie if (!is_active) { 2224*891e2639SMike Christie /* 2225*891e2639SMike Christie * if logout timed out before userspace could even send a PDU 2226*891e2639SMike Christie * the state might still be in ISCSI_STATE_LOGGED_IN and 2227*891e2639SMike Christie * allowing new cmds and TMFs. 2228*891e2639SMike Christie */ 2229*891e2639SMike Christie if (session->state == ISCSI_STATE_LOGGED_IN) 2230*891e2639SMike Christie iscsi_set_conn_failed(conn); 2231*891e2639SMike Christie } 2232*891e2639SMike Christie spin_unlock_bh(&session->frwd_lock); 2233*891e2639SMike Christie mutex_unlock(&session->eh_mutex); 2234*891e2639SMike Christie } 2235*891e2639SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_unbind); 2236*891e2639SMike Christie 22379c19a7d0SMike Christie static void iscsi_prep_abort_task_pdu(struct iscsi_task *task, 2238843c0a8aSMike Christie struct iscsi_tm *hdr) 2239843c0a8aSMike Christie { 2240843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2241843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2242843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK; 2243843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 224455bdabdfSAndy Grover hdr->lun = task->lun; 2245577577daSMike Christie hdr->rtt = task->hdr_itt; 2246577577daSMike Christie hdr->refcmdsn = task->cmdsn; 2247843c0a8aSMike Christie } 2248843c0a8aSMike Christie 22497996a778SMike Christie int iscsi_eh_abort(struct scsi_cmnd *sc) 22507996a778SMike Christie { 225175613521SMike Christie struct iscsi_cls_session *cls_session; 225275613521SMike Christie struct iscsi_session *session; 2253f47f2cf5SMike Christie struct iscsi_conn *conn; 22549c19a7d0SMike Christie struct iscsi_task *task; 2255843c0a8aSMike Christie struct iscsi_tm *hdr; 2256e9e410e8SBart Van Assche int age; 22577996a778SMike Christie 225875613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 225975613521SMike Christie session = cls_session->dd_data; 226075613521SMike Christie 2261bd2199d4SErez Zilber ISCSI_DBG_EH(session, "aborting sc %p\n", sc); 22624421c9ebSMike Christie 22636724add1SMike Christie mutex_lock(&session->eh_mutex); 2264659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2265f47f2cf5SMike Christie /* 2266f47f2cf5SMike Christie * if session was ISCSI_STATE_IN_RECOVERY then we may not have 2267f47f2cf5SMike Christie * got the command. 2268f47f2cf5SMike Christie */ 2269f47f2cf5SMike Christie if (!sc->SCp.ptr) { 2270bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc never reached iscsi layer or " 22711b2c7af8SMike Christie "it completed.\n"); 2272659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 22736724add1SMike Christie mutex_unlock(&session->eh_mutex); 2274f47f2cf5SMike Christie return SUCCESS; 2275f47f2cf5SMike Christie } 2276f47f2cf5SMike Christie 22777996a778SMike Christie /* 22787996a778SMike Christie * If we are not logged in or we have started a new session 22797996a778SMike Christie * then let the host reset code handle this 22807996a778SMike Christie */ 2281843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN || 2282843c0a8aSMike Christie sc->SCp.phase != session->age) { 2283659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2284843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2285bd2199d4SErez Zilber ISCSI_DBG_EH(session, "failing abort due to dropped " 22864421c9ebSMike Christie "session.\n"); 2287843c0a8aSMike Christie return FAILED; 2288843c0a8aSMike Christie } 2289843c0a8aSMike Christie 2290843c0a8aSMike Christie conn = session->leadconn; 2291843c0a8aSMike Christie conn->eh_abort_cnt++; 2292843c0a8aSMike Christie age = session->age; 2293843c0a8aSMike Christie 229414936b1eSMike Christie spin_lock(&session->back_lock); 22959c19a7d0SMike Christie task = (struct iscsi_task *)sc->SCp.ptr; 229614936b1eSMike Christie if (!task || !task->sc) { 22979c19a7d0SMike Christie /* task completed before time out */ 2298bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in progress\n"); 229914936b1eSMike Christie 230014936b1eSMike Christie spin_unlock(&session->back_lock); 230114936b1eSMike Christie spin_unlock_bh(&session->frwd_lock); 230214936b1eSMike Christie mutex_unlock(&session->eh_mutex); 230314936b1eSMike Christie return SUCCESS; 23047ea8b828SMike Christie } 230514936b1eSMike Christie ISCSI_DBG_EH(session, "aborting [sc %p itt 0x%x]\n", sc, task->itt); 230614936b1eSMike Christie __iscsi_get_task(task); 230714936b1eSMike Christie spin_unlock(&session->back_lock); 23087996a778SMike Christie 23099c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) { 2310b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 231177a23c21SMike Christie goto success; 231277a23c21SMike Christie } 23137996a778SMike Christie 2314843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2315843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 23167996a778SMike Christie goto failed; 2317843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 23187996a778SMike Christie 2319843c0a8aSMike Christie hdr = &conn->tmhdr; 23209c19a7d0SMike Christie iscsi_prep_abort_task_pdu(task, hdr); 2321843c0a8aSMike Christie 2322e9e410e8SBart Van Assche if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) 2323843c0a8aSMike Christie goto failed; 2324843c0a8aSMike Christie 2325843c0a8aSMike Christie switch (conn->tmf_state) { 2326843c0a8aSMike Christie case TMF_SUCCESS: 2327659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2328913e5bf4SMike Christie /* 2329913e5bf4SMike Christie * stop tx side incase the target had sent a abort rsp but 2330913e5bf4SMike Christie * the initiator was still writing out data. 2331913e5bf4SMike Christie */ 23326724add1SMike Christie iscsi_suspend_tx(conn); 23337996a778SMike Christie /* 2334913e5bf4SMike Christie * we do not stop the recv side because targets have been 2335913e5bf4SMike Christie * good and have never sent us a successful tmf response 2336913e5bf4SMike Christie * then sent more data for the cmd. 23377996a778SMike Christie */ 2338659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2339b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 2340843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 23415d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 2342659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 23436724add1SMike Christie iscsi_start_tx(conn); 234477a23c21SMike Christie goto success_unlocked; 2345843c0a8aSMike Christie case TMF_TIMEDOUT: 2346659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2347df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2348843c0a8aSMike Christie goto failed_unlocked; 2349843c0a8aSMike Christie case TMF_NOT_FOUND: 2350843c0a8aSMike Christie if (!sc->SCp.ptr) { 2351843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 23525d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 23539c19a7d0SMike Christie /* task completed before tmf abort response */ 2354bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in " 2355bd2199d4SErez Zilber "progress\n"); 235677a23c21SMike Christie goto success; 235777a23c21SMike Christie } 2358df561f66SGustavo A. R. Silva fallthrough; 235977a23c21SMike Christie default: 2360843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2361843c0a8aSMike Christie goto failed; 236277a23c21SMike Christie } 23637996a778SMike Christie 236477a23c21SMike Christie success: 2365659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 236677a23c21SMike Christie success_unlocked: 2367bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n", 23681b2c7af8SMike Christie sc, task->itt); 236914936b1eSMike Christie iscsi_put_task(task); 23706724add1SMike Christie mutex_unlock(&session->eh_mutex); 23717996a778SMike Christie return SUCCESS; 23727996a778SMike Christie 23737996a778SMike Christie failed: 2374659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 237577a23c21SMike Christie failed_unlocked: 2376bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc, 23779c19a7d0SMike Christie task ? task->itt : 0); 237814936b1eSMike Christie iscsi_put_task(task); 23796724add1SMike Christie mutex_unlock(&session->eh_mutex); 23807996a778SMike Christie return FAILED; 23817996a778SMike Christie } 23827996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_abort); 23837996a778SMike Christie 2384843c0a8aSMike Christie static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 2385843c0a8aSMike Christie { 2386843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2387843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2388843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK; 2389843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 239055bdabdfSAndy Grover int_to_scsilun(sc->device->lun, &hdr->lun); 2391f6d5180cSMike Christie hdr->rtt = RESERVED_ITT; 2392843c0a8aSMike Christie } 2393843c0a8aSMike Christie 2394843c0a8aSMike Christie int iscsi_eh_device_reset(struct scsi_cmnd *sc) 2395843c0a8aSMike Christie { 239675613521SMike Christie struct iscsi_cls_session *cls_session; 239775613521SMike Christie struct iscsi_session *session; 2398843c0a8aSMike Christie struct iscsi_conn *conn; 2399843c0a8aSMike Christie struct iscsi_tm *hdr; 2400843c0a8aSMike Christie int rc = FAILED; 2401843c0a8aSMike Christie 240275613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 240375613521SMike Christie session = cls_session->dd_data; 240475613521SMike Christie 24059cb78c16SHannes Reinecke ISCSI_DBG_EH(session, "LU Reset [sc %p lun %llu]\n", sc, 24069cb78c16SHannes Reinecke sc->device->lun); 2407843c0a8aSMike Christie 2408843c0a8aSMike Christie mutex_lock(&session->eh_mutex); 2409659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2410843c0a8aSMike Christie /* 2411843c0a8aSMike Christie * Just check if we are not logged in. We cannot check for 2412843c0a8aSMike Christie * the phase because the reset could come from a ioctl. 2413843c0a8aSMike Christie */ 2414843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 2415843c0a8aSMike Christie goto unlock; 2416843c0a8aSMike Christie conn = session->leadconn; 2417843c0a8aSMike Christie 2418843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2419843c0a8aSMike Christie if (conn->tmf_state != TMF_INITIAL) 2420843c0a8aSMike Christie goto unlock; 2421843c0a8aSMike Christie conn->tmf_state = TMF_QUEUED; 2422843c0a8aSMike Christie 2423843c0a8aSMike Christie hdr = &conn->tmhdr; 2424843c0a8aSMike Christie iscsi_prep_lun_reset_pdu(sc, hdr); 2425843c0a8aSMike Christie 24269c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 2427f6d5180cSMike Christie session->lu_reset_timeout)) { 2428843c0a8aSMike Christie rc = FAILED; 2429843c0a8aSMike Christie goto unlock; 2430843c0a8aSMike Christie } 2431843c0a8aSMike Christie 2432843c0a8aSMike Christie switch (conn->tmf_state) { 2433843c0a8aSMike Christie case TMF_SUCCESS: 2434843c0a8aSMike Christie break; 2435843c0a8aSMike Christie case TMF_TIMEDOUT: 2436659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2437df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2438843c0a8aSMike Christie goto done; 2439843c0a8aSMike Christie default: 2440843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2441843c0a8aSMike Christie goto unlock; 2442843c0a8aSMike Christie } 2443843c0a8aSMike Christie 2444843c0a8aSMike Christie rc = SUCCESS; 2445659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2446843c0a8aSMike Christie 2447843c0a8aSMike Christie iscsi_suspend_tx(conn); 2448913e5bf4SMike Christie 2449659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 24505d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 24513bbaaad9SMike Christie fail_scsi_tasks(conn, sc->device->lun, DID_ERROR); 2452843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 2453659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2454843c0a8aSMike Christie 2455843c0a8aSMike Christie iscsi_start_tx(conn); 2456843c0a8aSMike Christie goto done; 2457843c0a8aSMike Christie 2458843c0a8aSMike Christie unlock: 2459659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2460843c0a8aSMike Christie done: 2461bd2199d4SErez Zilber ISCSI_DBG_EH(session, "dev reset result = %s\n", 2462843c0a8aSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 2463843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2464843c0a8aSMike Christie return rc; 2465843c0a8aSMike Christie } 2466843c0a8aSMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_device_reset); 2467843c0a8aSMike Christie 24683fe5ae8bSMike Christie void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) 24693fe5ae8bSMike Christie { 24703fe5ae8bSMike Christie struct iscsi_session *session = cls_session->dd_data; 24713fe5ae8bSMike Christie 2472659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 24733fe5ae8bSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 24743fe5ae8bSMike Christie session->state = ISCSI_STATE_RECOVERY_FAILED; 24753fe5ae8bSMike Christie if (session->leadconn) 24763fe5ae8bSMike Christie wake_up(&session->leadconn->ehwait); 24773fe5ae8bSMike Christie } 2478659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 24793fe5ae8bSMike Christie } 24803fe5ae8bSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout); 24813fe5ae8bSMike Christie 24823fe5ae8bSMike Christie /** 24833fe5ae8bSMike Christie * iscsi_eh_session_reset - drop session and attempt relogin 24843fe5ae8bSMike Christie * @sc: scsi command 24853fe5ae8bSMike Christie * 24863fe5ae8bSMike Christie * This function will wait for a relogin, session termination from 24873fe5ae8bSMike Christie * userspace, or a recovery/replacement timeout. 24883fe5ae8bSMike Christie */ 2489309ce156SJayamohan Kallickal int iscsi_eh_session_reset(struct scsi_cmnd *sc) 24903fe5ae8bSMike Christie { 24913fe5ae8bSMike Christie struct iscsi_cls_session *cls_session; 24923fe5ae8bSMike Christie struct iscsi_session *session; 24933fe5ae8bSMike Christie struct iscsi_conn *conn; 24943fe5ae8bSMike Christie 24953fe5ae8bSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 24963fe5ae8bSMike Christie session = cls_session->dd_data; 24973fe5ae8bSMike Christie conn = session->leadconn; 24983fe5ae8bSMike Christie 24993fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2500659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 25013fe5ae8bSMike Christie if (session->state == ISCSI_STATE_TERMINATE) { 25023fe5ae8bSMike Christie failed: 25033fe5ae8bSMike Christie ISCSI_DBG_EH(session, 25043fe5ae8bSMike Christie "failing session reset: Could not log back into " 25055db6dd14SFred Herard "%s [age %d]\n", session->targetname, 25065db6dd14SFred Herard session->age); 2507659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 25083fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 25093fe5ae8bSMike Christie return FAILED; 25103fe5ae8bSMike Christie } 25113fe5ae8bSMike Christie 2512659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 25133fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 25143fe5ae8bSMike Christie /* 25153fe5ae8bSMike Christie * we drop the lock here but the leadconn cannot be destoyed while 25163fe5ae8bSMike Christie * we are in the scsi eh 25173fe5ae8bSMike Christie */ 2518df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 25193fe5ae8bSMike Christie 25203fe5ae8bSMike Christie ISCSI_DBG_EH(session, "wait for relogin\n"); 25213fe5ae8bSMike Christie wait_event_interruptible(conn->ehwait, 25223fe5ae8bSMike Christie session->state == ISCSI_STATE_TERMINATE || 25233fe5ae8bSMike Christie session->state == ISCSI_STATE_LOGGED_IN || 25243fe5ae8bSMike Christie session->state == ISCSI_STATE_RECOVERY_FAILED); 25253fe5ae8bSMike Christie if (signal_pending(current)) 25263fe5ae8bSMike Christie flush_signals(current); 25273fe5ae8bSMike Christie 25283fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2529659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 25303fe5ae8bSMike Christie if (session->state == ISCSI_STATE_LOGGED_IN) { 25313fe5ae8bSMike Christie ISCSI_DBG_EH(session, 25323fe5ae8bSMike Christie "session reset succeeded for %s,%s\n", 25333fe5ae8bSMike Christie session->targetname, conn->persistent_address); 25343fe5ae8bSMike Christie } else 25353fe5ae8bSMike Christie goto failed; 2536659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 25373fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 25383fe5ae8bSMike Christie return SUCCESS; 25393fe5ae8bSMike Christie } 2540309ce156SJayamohan Kallickal EXPORT_SYMBOL_GPL(iscsi_eh_session_reset); 25413fe5ae8bSMike Christie 25423fe5ae8bSMike Christie static void iscsi_prep_tgt_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 25433fe5ae8bSMike Christie { 25443fe5ae8bSMike Christie memset(hdr, 0, sizeof(*hdr)); 25453fe5ae8bSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 25463fe5ae8bSMike Christie hdr->flags = ISCSI_TM_FUNC_TARGET_WARM_RESET & ISCSI_FLAG_TM_FUNC_MASK; 25473fe5ae8bSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 25483fe5ae8bSMike Christie hdr->rtt = RESERVED_ITT; 25493fe5ae8bSMike Christie } 25503fe5ae8bSMike Christie 25513fe5ae8bSMike Christie /** 25523fe5ae8bSMike Christie * iscsi_eh_target_reset - reset target 25533fe5ae8bSMike Christie * @sc: scsi command 25543fe5ae8bSMike Christie * 2555309ce156SJayamohan Kallickal * This will attempt to send a warm target reset. 25563fe5ae8bSMike Christie */ 25573907adf6SBart Van Assche static int iscsi_eh_target_reset(struct scsi_cmnd *sc) 25583fe5ae8bSMike Christie { 25593fe5ae8bSMike Christie struct iscsi_cls_session *cls_session; 25603fe5ae8bSMike Christie struct iscsi_session *session; 25613fe5ae8bSMike Christie struct iscsi_conn *conn; 25623fe5ae8bSMike Christie struct iscsi_tm *hdr; 25633fe5ae8bSMike Christie int rc = FAILED; 25643fe5ae8bSMike Christie 25653fe5ae8bSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 25663fe5ae8bSMike Christie session = cls_session->dd_data; 25673fe5ae8bSMike Christie 25683fe5ae8bSMike Christie ISCSI_DBG_EH(session, "tgt Reset [sc %p tgt %s]\n", sc, 25693fe5ae8bSMike Christie session->targetname); 25703fe5ae8bSMike Christie 25713fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2572659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 25733fe5ae8bSMike Christie /* 25743fe5ae8bSMike Christie * Just check if we are not logged in. We cannot check for 25753fe5ae8bSMike Christie * the phase because the reset could come from a ioctl. 25763fe5ae8bSMike Christie */ 25773fe5ae8bSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 25783fe5ae8bSMike Christie goto unlock; 25793fe5ae8bSMike Christie conn = session->leadconn; 25803fe5ae8bSMike Christie 25813fe5ae8bSMike Christie /* only have one tmf outstanding at a time */ 25823fe5ae8bSMike Christie if (conn->tmf_state != TMF_INITIAL) 25833fe5ae8bSMike Christie goto unlock; 25843fe5ae8bSMike Christie conn->tmf_state = TMF_QUEUED; 25853fe5ae8bSMike Christie 25863fe5ae8bSMike Christie hdr = &conn->tmhdr; 25873fe5ae8bSMike Christie iscsi_prep_tgt_reset_pdu(sc, hdr); 25883fe5ae8bSMike Christie 25893fe5ae8bSMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 25903fe5ae8bSMike Christie session->tgt_reset_timeout)) { 25913fe5ae8bSMike Christie rc = FAILED; 25923fe5ae8bSMike Christie goto unlock; 25933fe5ae8bSMike Christie } 25943fe5ae8bSMike Christie 25953fe5ae8bSMike Christie switch (conn->tmf_state) { 25963fe5ae8bSMike Christie case TMF_SUCCESS: 25973fe5ae8bSMike Christie break; 25983fe5ae8bSMike Christie case TMF_TIMEDOUT: 2599659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2600df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 26013fe5ae8bSMike Christie goto done; 26023fe5ae8bSMike Christie default: 26033fe5ae8bSMike Christie conn->tmf_state = TMF_INITIAL; 26043fe5ae8bSMike Christie goto unlock; 26053fe5ae8bSMike Christie } 26063fe5ae8bSMike Christie 26073fe5ae8bSMike Christie rc = SUCCESS; 2608659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 26093fe5ae8bSMike Christie 26103fe5ae8bSMike Christie iscsi_suspend_tx(conn); 26113fe5ae8bSMike Christie 2612659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 26133fe5ae8bSMike Christie memset(hdr, 0, sizeof(*hdr)); 26143fe5ae8bSMike Christie fail_scsi_tasks(conn, -1, DID_ERROR); 26153fe5ae8bSMike Christie conn->tmf_state = TMF_INITIAL; 2616659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 26173fe5ae8bSMike Christie 26183fe5ae8bSMike Christie iscsi_start_tx(conn); 26193fe5ae8bSMike Christie goto done; 26203fe5ae8bSMike Christie 26213fe5ae8bSMike Christie unlock: 2622659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 26233fe5ae8bSMike Christie done: 26243fe5ae8bSMike Christie ISCSI_DBG_EH(session, "tgt %s reset result = %s\n", session->targetname, 26253fe5ae8bSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 26263fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 2627309ce156SJayamohan Kallickal return rc; 2628309ce156SJayamohan Kallickal } 26293fe5ae8bSMike Christie 2630309ce156SJayamohan Kallickal /** 2631309ce156SJayamohan Kallickal * iscsi_eh_recover_target - reset target and possibly the session 2632309ce156SJayamohan Kallickal * @sc: scsi command 2633309ce156SJayamohan Kallickal * 2634309ce156SJayamohan Kallickal * This will attempt to send a warm target reset. If that fails, 2635309ce156SJayamohan Kallickal * we will escalate to ERL0 session recovery. 2636309ce156SJayamohan Kallickal */ 2637309ce156SJayamohan Kallickal int iscsi_eh_recover_target(struct scsi_cmnd *sc) 2638309ce156SJayamohan Kallickal { 2639309ce156SJayamohan Kallickal int rc; 2640309ce156SJayamohan Kallickal 2641309ce156SJayamohan Kallickal rc = iscsi_eh_target_reset(sc); 26423fe5ae8bSMike Christie if (rc == FAILED) 26433fe5ae8bSMike Christie rc = iscsi_eh_session_reset(sc); 26443fe5ae8bSMike Christie return rc; 26453fe5ae8bSMike Christie } 2646309ce156SJayamohan Kallickal EXPORT_SYMBOL_GPL(iscsi_eh_recover_target); 26473fe5ae8bSMike Christie 26486320377fSOlaf Kirch /* 26496320377fSOlaf Kirch * Pre-allocate a pool of @max items of @item_size. By default, the pool 26506320377fSOlaf Kirch * should be accessed via kfifo_{get,put} on q->queue. 26516320377fSOlaf Kirch * Optionally, the caller can obtain the array of object pointers 26526320377fSOlaf Kirch * by passing in a non-NULL @items pointer 26536320377fSOlaf Kirch */ 26547996a778SMike Christie int 26556320377fSOlaf Kirch iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size) 26567996a778SMike Christie { 26576320377fSOlaf Kirch int i, num_arrays = 1; 26587996a778SMike Christie 26596320377fSOlaf Kirch memset(q, 0, sizeof(*q)); 26607996a778SMike Christie 26617996a778SMike Christie q->max = max; 26626320377fSOlaf Kirch 26636320377fSOlaf Kirch /* If the user passed an items pointer, he wants a copy of 26646320377fSOlaf Kirch * the array. */ 26656320377fSOlaf Kirch if (items) 26666320377fSOlaf Kirch num_arrays++; 2667778e1cddSKees Cook q->pool = kvcalloc(num_arrays * max, sizeof(void *), GFP_KERNEL); 26686320377fSOlaf Kirch if (q->pool == NULL) 2669f474a37bSJean Delvare return -ENOMEM; 26707996a778SMike Christie 2671c1e13f25SStefani Seibold kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*)); 26727996a778SMike Christie 26737996a778SMike Christie for (i = 0; i < max; i++) { 26746320377fSOlaf Kirch q->pool[i] = kzalloc(item_size, GFP_KERNEL); 26757996a778SMike Christie if (q->pool[i] == NULL) { 26766320377fSOlaf Kirch q->max = i; 26776320377fSOlaf Kirch goto enomem; 26787996a778SMike Christie } 26797acd72ebSStefani Seibold kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*)); 26807996a778SMike Christie } 26816320377fSOlaf Kirch 26826320377fSOlaf Kirch if (items) { 26836320377fSOlaf Kirch *items = q->pool + max; 26846320377fSOlaf Kirch memcpy(*items, q->pool, max * sizeof(void *)); 26856320377fSOlaf Kirch } 26866320377fSOlaf Kirch 26877996a778SMike Christie return 0; 26886320377fSOlaf Kirch 26896320377fSOlaf Kirch enomem: 26906320377fSOlaf Kirch iscsi_pool_free(q); 26916320377fSOlaf Kirch return -ENOMEM; 26927996a778SMike Christie } 26937996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_init); 26947996a778SMike Christie 26956320377fSOlaf Kirch void iscsi_pool_free(struct iscsi_pool *q) 26967996a778SMike Christie { 26977996a778SMike Christie int i; 26987996a778SMike Christie 26997996a778SMike Christie for (i = 0; i < q->max; i++) 27006320377fSOlaf Kirch kfree(q->pool[i]); 2701bfcc62edSKyle Fortin kvfree(q->pool); 27027996a778SMike Christie } 27037996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_free); 27047996a778SMike Christie 2705b4046922SMike Christie int iscsi_host_get_max_scsi_cmds(struct Scsi_Host *shost, 2706b4046922SMike Christie uint16_t requested_cmds_max) 2707b4046922SMike Christie { 2708b4046922SMike Christie int scsi_cmds, total_cmds = requested_cmds_max; 2709b4046922SMike Christie 2710b4046922SMike Christie check: 2711b4046922SMike Christie if (!total_cmds) 2712b4046922SMike Christie total_cmds = ISCSI_DEF_XMIT_CMDS_MAX; 2713b4046922SMike Christie /* 2714b4046922SMike Christie * The iscsi layer needs some tasks for nop handling and tmfs, 2715b4046922SMike Christie * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX 2716b4046922SMike Christie * + 1 command for scsi IO. 2717b4046922SMike Christie */ 2718b4046922SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 2719b4046922SMike Christie printk(KERN_ERR "iscsi: invalid max cmds of %d. Must be a power of two that is at least %d.\n", 2720b4046922SMike Christie total_cmds, ISCSI_TOTAL_CMDS_MIN); 2721b4046922SMike Christie return -EINVAL; 2722b4046922SMike Christie } 2723b4046922SMike Christie 2724b4046922SMike Christie if (total_cmds > ISCSI_TOTAL_CMDS_MAX) { 2725b4046922SMike Christie printk(KERN_INFO "iscsi: invalid max cmds of %d. Must be a power of 2 less than or equal to %d. Using %d.\n", 2726b4046922SMike Christie requested_cmds_max, ISCSI_TOTAL_CMDS_MAX, 2727b4046922SMike Christie ISCSI_TOTAL_CMDS_MAX); 2728b4046922SMike Christie total_cmds = ISCSI_TOTAL_CMDS_MAX; 2729b4046922SMike Christie } 2730b4046922SMike Christie 2731b4046922SMike Christie if (!is_power_of_2(total_cmds)) { 2732b4046922SMike Christie total_cmds = rounddown_pow_of_two(total_cmds); 2733b4046922SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 2734b4046922SMike Christie printk(KERN_ERR "iscsi: invalid max cmds of %d. Must be a power of 2 greater than %d.\n", requested_cmds_max, ISCSI_TOTAL_CMDS_MIN); 2735b4046922SMike Christie return -EINVAL; 2736b4046922SMike Christie } 2737b4046922SMike Christie 2738b4046922SMike Christie printk(KERN_INFO "iscsi: invalid max cmds %d. Must be a power of 2. Rounding max cmds down to %d.\n", 2739b4046922SMike Christie requested_cmds_max, total_cmds); 2740b4046922SMike Christie } 2741b4046922SMike Christie 2742b4046922SMike Christie scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX; 2743b4046922SMike Christie if (shost->can_queue && scsi_cmds > shost->can_queue) { 2744b4046922SMike Christie total_cmds = shost->can_queue; 2745b4046922SMike Christie 2746b4046922SMike Christie printk(KERN_INFO "iscsi: requested max cmds %u is higher than driver limit. Using driver limit %u\n", 2747b4046922SMike Christie requested_cmds_max, shost->can_queue); 2748b4046922SMike Christie goto check; 2749b4046922SMike Christie } 2750b4046922SMike Christie 2751b4046922SMike Christie return scsi_cmds; 2752b4046922SMike Christie } 2753b4046922SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_max_scsi_cmds); 2754b4046922SMike Christie 2755a4804cd6SMike Christie /** 2756a4804cd6SMike Christie * iscsi_host_add - add host to system 2757a4804cd6SMike Christie * @shost: scsi host 2758a4804cd6SMike Christie * @pdev: parent device 2759a4804cd6SMike Christie * 2760a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers 2761a4804cd6SMike Christie * to add a host to the system. 2762a4804cd6SMike Christie */ 2763a4804cd6SMike Christie int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev) 27647996a778SMike Christie { 27658e9a20ceSMike Christie if (!shost->can_queue) 27668e9a20ceSMike Christie shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX; 27678e9a20ceSMike Christie 27684d108350SMike Christie if (!shost->cmd_per_lun) 27694d108350SMike Christie shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN; 27704d108350SMike Christie 2771a4804cd6SMike Christie return scsi_add_host(shost, pdev); 2772a4804cd6SMike Christie } 2773a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_add); 2774a4804cd6SMike Christie 2775a4804cd6SMike Christie /** 2776a4804cd6SMike Christie * iscsi_host_alloc - allocate a host and driver data 2777a4804cd6SMike Christie * @sht: scsi host template 2778a4804cd6SMike Christie * @dd_data_size: driver host data size 277932ae763eSMike Christie * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue 2780a4804cd6SMike Christie * 2781a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers. 2782a4804cd6SMike Christie * To access the driver specific memory use the iscsi_host_priv() macro. 2783a4804cd6SMike Christie */ 2784a4804cd6SMike Christie struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht, 27854d108350SMike Christie int dd_data_size, bool xmit_can_sleep) 2786a4804cd6SMike Christie { 2787a4804cd6SMike Christie struct Scsi_Host *shost; 2788e5bd7b54SMike Christie struct iscsi_host *ihost; 2789a4804cd6SMike Christie 2790a4804cd6SMike Christie shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size); 2791a4804cd6SMike Christie if (!shost) 2792a4804cd6SMike Christie return NULL; 2793e5bd7b54SMike Christie ihost = shost_priv(shost); 279432ae763eSMike Christie 279532ae763eSMike Christie if (xmit_can_sleep) { 279632ae763eSMike Christie snprintf(ihost->workq_name, sizeof(ihost->workq_name), 279732ae763eSMike Christie "iscsi_q_%d", shost->host_no); 27983ce41966SBob Liu ihost->workq = alloc_workqueue("%s", 27993ce41966SBob Liu WQ_SYSFS | __WQ_LEGACY | WQ_MEM_RECLAIM | WQ_UNBOUND, 28001a982620SBob Liu 1, ihost->workq_name); 280132ae763eSMike Christie if (!ihost->workq) 280232ae763eSMike Christie goto free_host; 280332ae763eSMike Christie } 280432ae763eSMike Christie 2805e5bd7b54SMike Christie spin_lock_init(&ihost->lock); 2806e5bd7b54SMike Christie ihost->state = ISCSI_HOST_SETUP; 2807e5bd7b54SMike Christie ihost->num_sessions = 0; 2808e5bd7b54SMike Christie init_waitqueue_head(&ihost->session_removal_wq); 2809a4804cd6SMike Christie return shost; 281032ae763eSMike Christie 281132ae763eSMike Christie free_host: 281232ae763eSMike Christie scsi_host_put(shost); 281332ae763eSMike Christie return NULL; 281475613521SMike Christie } 2815a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_alloc); 281675613521SMike Christie 2817e5bd7b54SMike Christie static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session) 2818e5bd7b54SMike Christie { 281940a06e75SMike Christie iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST); 2820e5bd7b54SMike Christie } 2821e5bd7b54SMike Christie 2822a4804cd6SMike Christie /** 2823a4804cd6SMike Christie * iscsi_host_remove - remove host and sessions 2824a4804cd6SMike Christie * @shost: scsi host 2825a4804cd6SMike Christie * 2826e5bd7b54SMike Christie * If there are any sessions left, this will initiate the removal and wait 2827e5bd7b54SMike Christie * for the completion. 2828a4804cd6SMike Christie */ 2829a4804cd6SMike Christie void iscsi_host_remove(struct Scsi_Host *shost) 2830a4804cd6SMike Christie { 2831e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2832e5bd7b54SMike Christie unsigned long flags; 2833e5bd7b54SMike Christie 2834e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2835e5bd7b54SMike Christie ihost->state = ISCSI_HOST_REMOVED; 2836e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2837e5bd7b54SMike Christie 2838e5bd7b54SMike Christie iscsi_host_for_each_session(shost, iscsi_notify_host_removed); 2839e5bd7b54SMike Christie wait_event_interruptible(ihost->session_removal_wq, 2840e5bd7b54SMike Christie ihost->num_sessions == 0); 2841e5bd7b54SMike Christie if (signal_pending(current)) 2842e5bd7b54SMike Christie flush_signals(current); 2843e5bd7b54SMike Christie 2844a4804cd6SMike Christie scsi_remove_host(shost); 2845a4804cd6SMike Christie } 2846a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_remove); 2847a4804cd6SMike Christie 2848a4804cd6SMike Christie void iscsi_host_free(struct Scsi_Host *shost) 284975613521SMike Christie { 285075613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 285175613521SMike Christie 2852c435f0a9SMike Christie if (ihost->workq) 2853c435f0a9SMike Christie destroy_workqueue(ihost->workq); 2854c435f0a9SMike Christie 285575613521SMike Christie kfree(ihost->netdev); 285675613521SMike Christie kfree(ihost->hwaddress); 285775613521SMike Christie kfree(ihost->initiatorname); 2858a4804cd6SMike Christie scsi_host_put(shost); 285975613521SMike Christie } 2860a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_free); 286175613521SMike Christie 2862e5bd7b54SMike Christie static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost) 2863e5bd7b54SMike Christie { 2864e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2865e5bd7b54SMike Christie unsigned long flags; 2866e5bd7b54SMike Christie 2867e5bd7b54SMike Christie shost = scsi_host_get(shost); 2868e5bd7b54SMike Christie if (!shost) { 2869e5bd7b54SMike Christie printk(KERN_ERR "Invalid state. Cannot notify host removal " 2870e5bd7b54SMike Christie "of session teardown event because host already " 2871e5bd7b54SMike Christie "removed.\n"); 2872e5bd7b54SMike Christie return; 2873e5bd7b54SMike Christie } 2874e5bd7b54SMike Christie 2875e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2876e5bd7b54SMike Christie ihost->num_sessions--; 2877e5bd7b54SMike Christie if (ihost->num_sessions == 0) 2878e5bd7b54SMike Christie wake_up(&ihost->session_removal_wq); 2879e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2880e5bd7b54SMike Christie scsi_host_put(shost); 2881e5bd7b54SMike Christie } 2882e5bd7b54SMike Christie 288375613521SMike Christie /** 288475613521SMike Christie * iscsi_session_setup - create iscsi cls session and host and session 288575613521SMike Christie * @iscsit: iscsi transport template 288675613521SMike Christie * @shost: scsi host 288775613521SMike Christie * @cmds_max: session can queue 2888ccd4a430SRandy Dunlap * @dd_size: private driver data size, added to session allocation size 28899c19a7d0SMike Christie * @cmd_task_size: LLD task private data size 289075613521SMike Christie * @initial_cmdsn: initial CmdSN 2891ccd4a430SRandy Dunlap * @id: target ID to add to this session 289275613521SMike Christie * 289375613521SMike Christie * This can be used by software iscsi_transports that allocate 289475613521SMike Christie * a session per scsi host. 28953cf7b233SMike Christie * 28963cf7b233SMike Christie * Callers should set cmds_max to the largest total numer (mgmt + scsi) of 28973cf7b233SMike Christie * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks 28983cf7b233SMike Christie * for nop handling and login/logout requests. 289975613521SMike Christie */ 290075613521SMike Christie struct iscsi_cls_session * 290175613521SMike Christie iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, 2902b8b9e1b8SJayamohan Kallickal uint16_t cmds_max, int dd_size, int cmd_task_size, 29037970634bSMike Christie uint32_t initial_cmdsn, unsigned int id) 290475613521SMike Christie { 2905e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 290675613521SMike Christie struct iscsi_session *session; 290775613521SMike Christie struct iscsi_cls_session *cls_session; 2908b4046922SMike Christie int cmd_i, scsi_cmds; 2909e5bd7b54SMike Christie unsigned long flags; 2910e5bd7b54SMike Christie 2911e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2912e5bd7b54SMike Christie if (ihost->state == ISCSI_HOST_REMOVED) { 2913e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2914e5bd7b54SMike Christie return NULL; 2915e5bd7b54SMike Christie } 2916e5bd7b54SMike Christie ihost->num_sessions++; 2917e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 29188e9a20ceSMike Christie 2919b4046922SMike Christie scsi_cmds = iscsi_host_get_max_scsi_cmds(shost, cmds_max); 2920b4046922SMike Christie if (scsi_cmds < 0) 2921e5bd7b54SMike Christie goto dec_session_count; 29221548271eSMike Christie 29235d91e209SMike Christie cls_session = iscsi_alloc_session(shost, iscsit, 2924b8b9e1b8SJayamohan Kallickal sizeof(struct iscsi_session) + 2925b8b9e1b8SJayamohan Kallickal dd_size); 292675613521SMike Christie if (!cls_session) 2927e5bd7b54SMike Christie goto dec_session_count; 292875613521SMike Christie session = cls_session->dd_data; 292975613521SMike Christie session->cls_session = cls_session; 29307996a778SMike Christie session->host = shost; 29317996a778SMike Christie session->state = ISCSI_STATE_FREE; 2932f6d5180cSMike Christie session->fast_abort = 1; 29333fe5ae8bSMike Christie session->tgt_reset_timeout = 30; 29344cd49ea1SMike Christie session->lu_reset_timeout = 15; 29354cd49ea1SMike Christie session->abort_timeout = 10; 29363cf7b233SMike Christie session->scsi_cmds_max = scsi_cmds; 2937b4046922SMike Christie session->cmds_max = scsi_cmds + ISCSI_MGMT_CMDS_MAX; 2938e0726407SMike Christie session->queued_cmdsn = session->cmdsn = initial_cmdsn; 29397996a778SMike Christie session->exp_cmdsn = initial_cmdsn + 1; 29407996a778SMike Christie session->max_cmdsn = initial_cmdsn + 1; 29417996a778SMike Christie session->max_r2t = 1; 29427996a778SMike Christie session->tt = iscsit; 2943b8b9e1b8SJayamohan Kallickal session->dd_data = cls_session->dd_data + sizeof(*session); 2944659743b0SShlomo Pongratz 29456724add1SMike Christie mutex_init(&session->eh_mutex); 2946659743b0SShlomo Pongratz spin_lock_init(&session->frwd_lock); 2947659743b0SShlomo Pongratz spin_lock_init(&session->back_lock); 29487996a778SMike Christie 29497996a778SMike Christie /* initialize SCSI PDU commands pool */ 29507996a778SMike Christie if (iscsi_pool_init(&session->cmdpool, session->cmds_max, 29517996a778SMike Christie (void***)&session->cmds, 29529c19a7d0SMike Christie cmd_task_size + sizeof(struct iscsi_task))) 29537996a778SMike Christie goto cmdpool_alloc_fail; 29547996a778SMike Christie 29557996a778SMike Christie /* pre-format cmds pool with ITT */ 29567996a778SMike Christie for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) { 29579c19a7d0SMike Christie struct iscsi_task *task = session->cmds[cmd_i]; 29587996a778SMike Christie 29599c19a7d0SMike Christie if (cmd_task_size) 29609c19a7d0SMike Christie task->dd_data = &task[1]; 29619c19a7d0SMike Christie task->itt = cmd_i; 29623bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 29639c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 29647996a778SMike Christie } 29657996a778SMike Christie 2966f53a88daSMike Christie if (!try_module_get(iscsit->owner)) 296775613521SMike Christie goto module_get_fail; 296875613521SMike Christie 29697970634bSMike Christie if (iscsi_add_session(cls_session, id)) 2970f53a88daSMike Christie goto cls_session_fail; 2971e5bd7b54SMike Christie 29727996a778SMike Christie return cls_session; 29737996a778SMike Christie 29747996a778SMike Christie cls_session_fail: 297575613521SMike Christie module_put(iscsit->owner); 297675613521SMike Christie module_get_fail: 29776320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 29787996a778SMike Christie cmdpool_alloc_fail: 297975613521SMike Christie iscsi_free_session(cls_session); 2980e5bd7b54SMike Christie dec_session_count: 2981e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 29827996a778SMike Christie return NULL; 29837996a778SMike Christie } 29847996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_setup); 29857996a778SMike Christie 29867996a778SMike Christie /** 29877996a778SMike Christie * iscsi_session_teardown - destroy session, host, and cls_session 298875613521SMike Christie * @cls_session: iscsi session 298975613521SMike Christie */ 29907996a778SMike Christie void iscsi_session_teardown(struct iscsi_cls_session *cls_session) 29917996a778SMike Christie { 299275613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 299363f75cc8SMike Christie struct module *owner = cls_session->transport->owner; 2994e5bd7b54SMike Christie struct Scsi_Host *shost = session->host; 29957996a778SMike Christie 29966320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 29977996a778SMike Christie 29989e10b512SKhazhismel Kumykov iscsi_remove_session(cls_session); 29999e10b512SKhazhismel Kumykov 3000b2c64167SMike Christie kfree(session->password); 3001b2c64167SMike Christie kfree(session->password_in); 3002b2c64167SMike Christie kfree(session->username); 3003b2c64167SMike Christie kfree(session->username_in); 3004f3ff0c36SMike Christie kfree(session->targetname); 30053c5c4801SVikas Chaudhary kfree(session->targetalias); 300688dfd340SMike Christie kfree(session->initiatorname); 30073b9373e9SEddie Wai kfree(session->boot_root); 30083b9373e9SEddie Wai kfree(session->boot_nic); 30093b9373e9SEddie Wai kfree(session->boot_target); 301088dfd340SMike Christie kfree(session->ifacename); 3011f8525eb4SAdheer Chandravanshi kfree(session->portal_type); 3012f8525eb4SAdheer Chandravanshi kfree(session->discovery_parent_type); 3013f3ff0c36SMike Christie 30149e10b512SKhazhismel Kumykov iscsi_free_session(cls_session); 30159e10b512SKhazhismel Kumykov 3016e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 301763f75cc8SMike Christie module_put(owner); 30187996a778SMike Christie } 30197996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_teardown); 30207996a778SMike Christie 30217996a778SMike Christie /** 30227996a778SMike Christie * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn 30237996a778SMike Christie * @cls_session: iscsi_cls_session 30245d91e209SMike Christie * @dd_size: private driver data size 30257996a778SMike Christie * @conn_idx: cid 30265d91e209SMike Christie */ 30277996a778SMike Christie struct iscsi_cls_conn * 30285d91e209SMike Christie iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, 30295d91e209SMike Christie uint32_t conn_idx) 30307996a778SMike Christie { 303175613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 30327996a778SMike Christie struct iscsi_conn *conn; 30337996a778SMike Christie struct iscsi_cls_conn *cls_conn; 3034d36ab6f3SMike Christie char *data; 30357996a778SMike Christie 30365d91e209SMike Christie cls_conn = iscsi_create_conn(cls_session, sizeof(*conn) + dd_size, 30375d91e209SMike Christie conn_idx); 30387996a778SMike Christie if (!cls_conn) 30397996a778SMike Christie return NULL; 30407996a778SMike Christie conn = cls_conn->dd_data; 30415d91e209SMike Christie memset(conn, 0, sizeof(*conn) + dd_size); 30427996a778SMike Christie 30435d91e209SMike Christie conn->dd_data = cls_conn->dd_data + sizeof(*conn); 30447996a778SMike Christie conn->session = session; 30457996a778SMike Christie conn->cls_conn = cls_conn; 30467996a778SMike Christie conn->c_stage = ISCSI_CONN_INITIAL_STAGE; 30477996a778SMike Christie conn->id = conn_idx; 30487996a778SMike Christie conn->exp_statsn = 0; 3049843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 3050f6d5180cSMike Christie 30512c4b9637SKees Cook timer_setup(&conn->transport_timer, iscsi_check_transport_timeouts, 0); 3052f6d5180cSMike Christie 3053843c0a8aSMike Christie INIT_LIST_HEAD(&conn->mgmtqueue); 30543bbaaad9SMike Christie INIT_LIST_HEAD(&conn->cmdqueue); 3055843c0a8aSMike Christie INIT_LIST_HEAD(&conn->requeue); 3056c4028958SDavid Howells INIT_WORK(&conn->xmitwork, iscsi_xmitworker); 30577996a778SMike Christie 30589c19a7d0SMike Christie /* allocate login_task used for the login/text sequences */ 3059659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 30607acd72ebSStefani Seibold if (!kfifo_out(&session->cmdpool.queue, 30619c19a7d0SMike Christie (void*)&conn->login_task, 30627996a778SMike Christie sizeof(void*))) { 3063659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 30649c19a7d0SMike Christie goto login_task_alloc_fail; 30657996a778SMike Christie } 3066659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 30677996a778SMike Christie 3068cfeb2cf9SMike Christie data = (char *) __get_free_pages(GFP_KERNEL, 3069cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 3070d36ab6f3SMike Christie if (!data) 30719c19a7d0SMike Christie goto login_task_data_alloc_fail; 30729c19a7d0SMike Christie conn->login_task->data = conn->data = data; 3073d36ab6f3SMike Christie 30742c4b9637SKees Cook timer_setup(&conn->tmf_timer, iscsi_tmf_timedout, 0); 30757996a778SMike Christie init_waitqueue_head(&conn->ehwait); 30767996a778SMike Christie 30777996a778SMike Christie return cls_conn; 30787996a778SMike Christie 30799c19a7d0SMike Christie login_task_data_alloc_fail: 30807acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 3081d36ab6f3SMike Christie sizeof(void*)); 30829c19a7d0SMike Christie login_task_alloc_fail: 30837996a778SMike Christie iscsi_destroy_conn(cls_conn); 30847996a778SMike Christie return NULL; 30857996a778SMike Christie } 30867996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_setup); 30877996a778SMike Christie 30887996a778SMike Christie /** 30897996a778SMike Christie * iscsi_conn_teardown - teardown iscsi connection 3090ccd4a430SRandy Dunlap * @cls_conn: iscsi class connection 30917996a778SMike Christie * 30927996a778SMike Christie * TODO: we may need to make this into a two step process 30937996a778SMike Christie * like scsi-mls remove + put host 30947996a778SMike Christie */ 30957996a778SMike Christie void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) 30967996a778SMike Christie { 30977996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 30987996a778SMike Christie struct iscsi_session *session = conn->session; 30997996a778SMike Christie 3100f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 3101f6d5180cSMike Christie 3102660d0831SJohn Soni Jose mutex_lock(&session->eh_mutex); 3103659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 31047996a778SMike Christie conn->c_stage = ISCSI_CONN_CLEANUP_WAIT; 31057996a778SMike Christie if (session->leadconn == conn) { 31067996a778SMike Christie /* 31077996a778SMike Christie * leading connection? then give up on recovery. 31087996a778SMike Christie */ 31097996a778SMike Christie session->state = ISCSI_STATE_TERMINATE; 31107996a778SMike Christie wake_up(&conn->ehwait); 31117996a778SMike Christie } 3112659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31137996a778SMike Christie 3114779ea120SMike Christie /* flush queued up work because we free the connection below */ 3115843c0a8aSMike Christie iscsi_suspend_tx(conn); 3116779ea120SMike Christie 3117659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 3118cfeb2cf9SMike Christie free_pages((unsigned long) conn->data, 3119cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 3120f3ff0c36SMike Christie kfree(conn->persistent_address); 3121ae56ff40SAdheer Chandravanshi kfree(conn->local_ipaddr); 3122659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 3123659743b0SShlomo Pongratz spin_lock_bh(&session->back_lock); 31247acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 31257996a778SMike Christie sizeof(void*)); 3126659743b0SShlomo Pongratz spin_unlock_bh(&session->back_lock); 3127e0726407SMike Christie if (session->leadconn == conn) 31287996a778SMike Christie session->leadconn = NULL; 3129659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 3130660d0831SJohn Soni Jose mutex_unlock(&session->eh_mutex); 31317996a778SMike Christie 31327996a778SMike Christie iscsi_destroy_conn(cls_conn); 31337996a778SMike Christie } 31347996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_teardown); 31357996a778SMike Christie 31367996a778SMike Christie int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 31377996a778SMike Christie { 31387996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 31397996a778SMike Christie struct iscsi_session *session = conn->session; 31407996a778SMike Christie 3141ffd0436eSMike Christie if (!session) { 3142322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 3143322d739dSMike Christie "can't start unbound connection\n"); 31447996a778SMike Christie return -EPERM; 31457996a778SMike Christie } 31467996a778SMike Christie 3147db98ccdeSMike Christie if ((session->imm_data_en || !session->initial_r2t_en) && 3148db98ccdeSMike Christie session->first_burst > session->max_burst) { 3149322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: " 3150ffd0436eSMike Christie "first_burst %d max_burst %d\n", 3151ffd0436eSMike Christie session->first_burst, session->max_burst); 3152ffd0436eSMike Christie return -EINVAL; 3153ffd0436eSMike Christie } 3154ffd0436eSMike Christie 3155f6d5180cSMike Christie if (conn->ping_timeout && !conn->recv_timeout) { 3156322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of " 3157322d739dSMike Christie "zero. Using 5 seconds\n."); 3158f6d5180cSMike Christie conn->recv_timeout = 5; 3159f6d5180cSMike Christie } 3160f6d5180cSMike Christie 3161f6d5180cSMike Christie if (conn->recv_timeout && !conn->ping_timeout) { 3162322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of " 3163322d739dSMike Christie "zero. Using 5 seconds.\n"); 3164f6d5180cSMike Christie conn->ping_timeout = 5; 3165f6d5180cSMike Christie } 3166f6d5180cSMike Christie 3167659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 31687996a778SMike Christie conn->c_stage = ISCSI_CONN_STARTED; 31697996a778SMike Christie session->state = ISCSI_STATE_LOGGED_IN; 3170e0726407SMike Christie session->queued_cmdsn = session->cmdsn; 31717996a778SMike Christie 3172f6d5180cSMike Christie conn->last_recv = jiffies; 3173f6d5180cSMike Christie conn->last_ping = jiffies; 3174f6d5180cSMike Christie if (conn->recv_timeout && conn->ping_timeout) 3175f6d5180cSMike Christie mod_timer(&conn->transport_timer, 3176f6d5180cSMike Christie jiffies + (conn->recv_timeout * HZ)); 3177f6d5180cSMike Christie 31787996a778SMike Christie switch(conn->stop_stage) { 31797996a778SMike Christie case STOP_CONN_RECOVER: 31807996a778SMike Christie /* 31817996a778SMike Christie * unblock eh_abort() if it is blocked. re-try all 31827996a778SMike Christie * commands after successful recovery 31837996a778SMike Christie */ 31847996a778SMike Christie conn->stop_stage = 0; 3185843c0a8aSMike Christie conn->tmf_state = TMF_INITIAL; 31867996a778SMike Christie session->age++; 31878b1d0343SMike Christie if (session->age == 16) 31888b1d0343SMike Christie session->age = 0; 31896eabafbeSMike Christie break; 31907996a778SMike Christie case STOP_CONN_TERM: 31917996a778SMike Christie conn->stop_stage = 0; 31927996a778SMike Christie break; 31937996a778SMike Christie default: 31947996a778SMike Christie break; 31957996a778SMike Christie } 3196659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31977996a778SMike Christie 319875613521SMike Christie iscsi_unblock_session(session->cls_session); 31996eabafbeSMike Christie wake_up(&conn->ehwait); 32007996a778SMike Christie return 0; 32017996a778SMike Christie } 32027996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_start); 32037996a778SMike Christie 32047996a778SMike Christie static void 32053bbaaad9SMike Christie fail_mgmt_tasks(struct iscsi_session *session, struct iscsi_conn *conn) 32067996a778SMike Christie { 32073bbaaad9SMike Christie struct iscsi_task *task; 3208b3cd5050SMike Christie int i, state; 32097996a778SMike Christie 32103bbaaad9SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 32113bbaaad9SMike Christie task = conn->session->cmds[i]; 32123bbaaad9SMike Christie if (task->sc) 32133bbaaad9SMike Christie continue; 32143bbaaad9SMike Christie 32153bbaaad9SMike Christie if (task->state == ISCSI_TASK_FREE) 32163bbaaad9SMike Christie continue; 32173bbaaad9SMike Christie 32183bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, 32193bbaaad9SMike Christie "failing mgmt itt 0x%x state %d\n", 32203bbaaad9SMike Christie task->itt, task->state); 32215923d64bSMike Christie 32225923d64bSMike Christie spin_lock_bh(&session->back_lock); 32235923d64bSMike Christie if (cleanup_queued_task(task)) { 32245923d64bSMike Christie spin_unlock_bh(&session->back_lock); 32255923d64bSMike Christie continue; 32265923d64bSMike Christie } 32275923d64bSMike Christie 3228b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 3229b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) 3230b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 3231b3cd5050SMike Christie iscsi_complete_task(task, state); 3232a656183eSLee Duncan spin_unlock_bh(&session->back_lock); 32337996a778SMike Christie } 32347996a778SMike Christie } 32357996a778SMike Christie 32360dcf8febSMike Christie void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 32377996a778SMike Christie { 32380dcf8febSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 32390dcf8febSMike Christie struct iscsi_session *session = conn->session; 3240ed2abc7fSMike Christie int old_stop_stage; 3241ed2abc7fSMike Christie 32426724add1SMike Christie mutex_lock(&session->eh_mutex); 3243659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 3244ed2abc7fSMike Christie if (conn->stop_stage == STOP_CONN_TERM) { 3245659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 32466724add1SMike Christie mutex_unlock(&session->eh_mutex); 32476724add1SMike Christie return; 32486724add1SMike Christie } 32496724add1SMike Christie 32506724add1SMike Christie /* 3251ed2abc7fSMike Christie * When this is called for the in_login state, we only want to clean 32529c19a7d0SMike Christie * up the login task and connection. We do not need to block and set 325367a61114SMike Christie * the recovery state again 3254ed2abc7fSMike Christie */ 325567a61114SMike Christie if (flag == STOP_CONN_TERM) 325667a61114SMike Christie session->state = ISCSI_STATE_TERMINATE; 325767a61114SMike Christie else if (conn->stop_stage != STOP_CONN_RECOVER) 325867a61114SMike Christie session->state = ISCSI_STATE_IN_RECOVERY; 32594ae0a6c1SMike Christie 32604ae0a6c1SMike Christie old_stop_stage = conn->stop_stage; 32614ae0a6c1SMike Christie conn->stop_stage = flag; 3262659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 3263ed2abc7fSMike Christie 326426013ad4SMike Christie del_timer_sync(&conn->transport_timer); 326526013ad4SMike Christie iscsi_suspend_tx(conn); 326626013ad4SMike Christie 3267659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 326867a61114SMike Christie conn->c_stage = ISCSI_CONN_STOPPED; 3269659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 32706724add1SMike Christie 32717996a778SMike Christie /* 32727996a778SMike Christie * for connection level recovery we should not calculate 32737996a778SMike Christie * header digest. conn->hdr_size used for optimization 32747996a778SMike Christie * in hdr_extract() and will be re-negotiated at 32757996a778SMike Christie * set_param() time. 32767996a778SMike Christie */ 32777996a778SMike Christie if (flag == STOP_CONN_RECOVER) { 32787996a778SMike Christie conn->hdrdgst_en = 0; 32797996a778SMike Christie conn->datadgst_en = 0; 3280656cffc9SMike Christie if (session->state == ISCSI_STATE_IN_RECOVERY && 328167a61114SMike Christie old_stop_stage != STOP_CONN_RECOVER) { 32821b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "blocking session\n"); 328375613521SMike Christie iscsi_block_session(session->cls_session); 32847996a778SMike Christie } 328567a61114SMike Christie } 3286656cffc9SMike Christie 3287656cffc9SMike Christie /* 3288656cffc9SMike Christie * flush queues. 3289656cffc9SMike Christie */ 3290659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 32913bbaaad9SMike Christie fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED); 32923bbaaad9SMike Christie fail_mgmt_tasks(session, conn); 32935d12c05eSMike Christie memset(&conn->tmhdr, 0, sizeof(conn->tmhdr)); 3294659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 32956724add1SMike Christie mutex_unlock(&session->eh_mutex); 32967996a778SMike Christie } 32977996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_stop); 32987996a778SMike Christie 32997996a778SMike Christie int iscsi_conn_bind(struct iscsi_cls_session *cls_session, 33007996a778SMike Christie struct iscsi_cls_conn *cls_conn, int is_leading) 33017996a778SMike Christie { 330275613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 330398644047SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 33047996a778SMike Christie 3305659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 33067996a778SMike Christie if (is_leading) 33077996a778SMike Christie session->leadconn = conn; 3308659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 33097996a778SMike Christie 33107996a778SMike Christie /* 3311c8447e4cSMike Christie * The target could have reduced it's window size between logins, so 3312c8447e4cSMike Christie * we have to reset max/exp cmdsn so we can see the new values. 3313c8447e4cSMike Christie */ 3314c8447e4cSMike Christie spin_lock_bh(&session->back_lock); 3315c8447e4cSMike Christie session->max_cmdsn = session->exp_cmdsn = session->cmdsn + 1; 3316c8447e4cSMike Christie spin_unlock_bh(&session->back_lock); 3317c8447e4cSMike Christie /* 33187996a778SMike Christie * Unblock xmitworker(), Login Phase will pass through. 33197996a778SMike Christie */ 33207996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_rx); 33217996a778SMike Christie clear_bit(ISCSI_SUSPEND_BIT, &conn->suspend_tx); 33227996a778SMike Christie return 0; 33237996a778SMike Christie } 33247996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_bind); 33257996a778SMike Christie 3326adaf6990SAdheer Chandravanshi int iscsi_switch_str_param(char **param, char *new_val_buf) 33275700b1afSMike Christie { 33285700b1afSMike Christie char *new_val; 33295700b1afSMike Christie 33305700b1afSMike Christie if (*param) { 33315700b1afSMike Christie if (!strcmp(*param, new_val_buf)) 33325700b1afSMike Christie return 0; 33335700b1afSMike Christie } 33345700b1afSMike Christie 33355700b1afSMike Christie new_val = kstrdup(new_val_buf, GFP_NOIO); 33365700b1afSMike Christie if (!new_val) 33375700b1afSMike Christie return -ENOMEM; 33385700b1afSMike Christie 33395700b1afSMike Christie kfree(*param); 33405700b1afSMike Christie *param = new_val; 33415700b1afSMike Christie return 0; 33425700b1afSMike Christie } 3343adaf6990SAdheer Chandravanshi EXPORT_SYMBOL_GPL(iscsi_switch_str_param); 3344a54a52caSMike Christie 3345a54a52caSMike Christie int iscsi_set_param(struct iscsi_cls_conn *cls_conn, 3346a54a52caSMike Christie enum iscsi_param param, char *buf, int buflen) 3347a54a52caSMike Christie { 3348a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 3349a54a52caSMike Christie struct iscsi_session *session = conn->session; 33506a06a4b8SOr Gerlitz int val; 3351a54a52caSMike Christie 3352a54a52caSMike Christie switch(param) { 3353843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 3354843c0a8aSMike Christie sscanf(buf, "%d", &session->fast_abort); 3355843c0a8aSMike Christie break; 3356f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 3357f6d5180cSMike Christie sscanf(buf, "%d", &session->abort_timeout); 3358f6d5180cSMike Christie break; 3359f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 3360f6d5180cSMike Christie sscanf(buf, "%d", &session->lu_reset_timeout); 3361f6d5180cSMike Christie break; 33623fe5ae8bSMike Christie case ISCSI_PARAM_TGT_RESET_TMO: 33633fe5ae8bSMike Christie sscanf(buf, "%d", &session->tgt_reset_timeout); 33643fe5ae8bSMike Christie break; 3365f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 3366f6d5180cSMike Christie sscanf(buf, "%d", &conn->ping_timeout); 3367f6d5180cSMike Christie break; 3368f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 3369f6d5180cSMike Christie sscanf(buf, "%d", &conn->recv_timeout); 3370f6d5180cSMike Christie break; 3371a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 3372a54a52caSMike Christie sscanf(buf, "%d", &conn->max_recv_dlength); 3373a54a52caSMike Christie break; 3374a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3375a54a52caSMike Christie sscanf(buf, "%d", &conn->max_xmit_dlength); 3376a54a52caSMike Christie break; 3377a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 3378a54a52caSMike Christie sscanf(buf, "%d", &conn->hdrdgst_en); 3379a54a52caSMike Christie break; 3380a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 3381a54a52caSMike Christie sscanf(buf, "%d", &conn->datadgst_en); 3382a54a52caSMike Christie break; 3383a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 3384a54a52caSMike Christie sscanf(buf, "%d", &session->initial_r2t_en); 3385a54a52caSMike Christie break; 3386a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 33871304be5fSMike Christie sscanf(buf, "%hu", &session->max_r2t); 3388a54a52caSMike Christie break; 3389a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 3390a54a52caSMike Christie sscanf(buf, "%d", &session->imm_data_en); 3391a54a52caSMike Christie break; 3392a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 3393a54a52caSMike Christie sscanf(buf, "%d", &session->first_burst); 3394a54a52caSMike Christie break; 3395a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 3396a54a52caSMike Christie sscanf(buf, "%d", &session->max_burst); 3397a54a52caSMike Christie break; 3398a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 3399a54a52caSMike Christie sscanf(buf, "%d", &session->pdu_inorder_en); 3400a54a52caSMike Christie break; 3401a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 3402a54a52caSMike Christie sscanf(buf, "%d", &session->dataseq_inorder_en); 3403a54a52caSMike Christie break; 3404a54a52caSMike Christie case ISCSI_PARAM_ERL: 3405a54a52caSMike Christie sscanf(buf, "%d", &session->erl); 3406a54a52caSMike Christie break; 3407a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 3408a54a52caSMike Christie sscanf(buf, "%u", &conn->exp_statsn); 3409a54a52caSMike Christie break; 3410b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 34115700b1afSMike Christie return iscsi_switch_str_param(&session->username, buf); 3412b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 34135700b1afSMike Christie return iscsi_switch_str_param(&session->username_in, buf); 3414b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 34155700b1afSMike Christie return iscsi_switch_str_param(&session->password, buf); 3416b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 34175700b1afSMike Christie return iscsi_switch_str_param(&session->password_in, buf); 3418a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 34195700b1afSMike Christie return iscsi_switch_str_param(&session->targetname, buf); 34203c5c4801SVikas Chaudhary case ISCSI_PARAM_TARGET_ALIAS: 34213c5c4801SVikas Chaudhary return iscsi_switch_str_param(&session->targetalias, buf); 3422a54a52caSMike Christie case ISCSI_PARAM_TPGT: 3423a54a52caSMike Christie sscanf(buf, "%d", &session->tpgt); 3424a54a52caSMike Christie break; 3425a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3426a54a52caSMike Christie sscanf(buf, "%d", &conn->persistent_port); 3427a54a52caSMike Christie break; 3428a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 34295700b1afSMike Christie return iscsi_switch_str_param(&conn->persistent_address, buf); 343088dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 34315700b1afSMike Christie return iscsi_switch_str_param(&session->ifacename, buf); 343288dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 34335700b1afSMike Christie return iscsi_switch_str_param(&session->initiatorname, buf); 34343b9373e9SEddie Wai case ISCSI_PARAM_BOOT_ROOT: 34353b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_root, buf); 34363b9373e9SEddie Wai case ISCSI_PARAM_BOOT_NIC: 34373b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_nic, buf); 34383b9373e9SEddie Wai case ISCSI_PARAM_BOOT_TARGET: 34393b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_target, buf); 3440f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_PORTAL_TYPE: 3441f8525eb4SAdheer Chandravanshi return iscsi_switch_str_param(&session->portal_type, buf); 3442f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_TYPE: 3443f8525eb4SAdheer Chandravanshi return iscsi_switch_str_param(&session->discovery_parent_type, 3444f8525eb4SAdheer Chandravanshi buf); 34456a06a4b8SOr Gerlitz case ISCSI_PARAM_DISCOVERY_SESS: 34466a06a4b8SOr Gerlitz sscanf(buf, "%d", &val); 34476a06a4b8SOr Gerlitz session->discovery_sess = !!val; 34486a06a4b8SOr Gerlitz break; 3449ae56ff40SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_IPADDR: 3450ae56ff40SAdheer Chandravanshi return iscsi_switch_str_param(&conn->local_ipaddr, buf); 3451a54a52caSMike Christie default: 3452a54a52caSMike Christie return -ENOSYS; 3453a54a52caSMike Christie } 3454a54a52caSMike Christie 3455a54a52caSMike Christie return 0; 3456a54a52caSMike Christie } 3457a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_set_param); 3458a54a52caSMike Christie 3459a54a52caSMike Christie int iscsi_session_get_param(struct iscsi_cls_session *cls_session, 3460a54a52caSMike Christie enum iscsi_param param, char *buf) 3461a54a52caSMike Christie { 346275613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 3463a54a52caSMike Christie int len; 3464a54a52caSMike Christie 3465a54a52caSMike Christie switch(param) { 3466843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 3467ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->fast_abort); 3468843c0a8aSMike Christie break; 3469f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 3470ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->abort_timeout); 3471f6d5180cSMike Christie break; 3472f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 3473ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->lu_reset_timeout); 3474f6d5180cSMike Christie break; 34753fe5ae8bSMike Christie case ISCSI_PARAM_TGT_RESET_TMO: 3476ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->tgt_reset_timeout); 34773fe5ae8bSMike Christie break; 3478a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 3479ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->initial_r2t_en); 3480a54a52caSMike Christie break; 3481a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 3482ec98ea70SChris Leech len = sysfs_emit(buf, "%hu\n", session->max_r2t); 3483a54a52caSMike Christie break; 3484a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 3485ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->imm_data_en); 3486a54a52caSMike Christie break; 3487a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 3488ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->first_burst); 3489a54a52caSMike Christie break; 3490a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 3491ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->max_burst); 3492a54a52caSMike Christie break; 3493a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 3494ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->pdu_inorder_en); 3495a54a52caSMike Christie break; 3496a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 3497ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->dataseq_inorder_en); 3498a54a52caSMike Christie break; 34995f09e1f3SAdheer Chandravanshi case ISCSI_PARAM_DEF_TASKMGMT_TMO: 3500ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->def_taskmgmt_tmo); 35015f09e1f3SAdheer Chandravanshi break; 3502a54a52caSMike Christie case ISCSI_PARAM_ERL: 3503ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->erl); 3504a54a52caSMike Christie break; 3505a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 3506ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->targetname); 3507a54a52caSMike Christie break; 35083c5c4801SVikas Chaudhary case ISCSI_PARAM_TARGET_ALIAS: 3509ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->targetalias); 35103c5c4801SVikas Chaudhary break; 3511a54a52caSMike Christie case ISCSI_PARAM_TPGT: 3512ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->tpgt); 3513a54a52caSMike Christie break; 3514b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 3515ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->username); 3516b2c64167SMike Christie break; 3517b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 3518ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->username_in); 3519b2c64167SMike Christie break; 3520b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 3521ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->password); 3522b2c64167SMike Christie break; 3523b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 3524ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->password_in); 3525b2c64167SMike Christie break; 352688dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 3527ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->ifacename); 352888dfd340SMike Christie break; 352988dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 3530ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->initiatorname); 353188dfd340SMike Christie break; 35323b9373e9SEddie Wai case ISCSI_PARAM_BOOT_ROOT: 3533ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->boot_root); 35343b9373e9SEddie Wai break; 35353b9373e9SEddie Wai case ISCSI_PARAM_BOOT_NIC: 3536ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->boot_nic); 35373b9373e9SEddie Wai break; 35383b9373e9SEddie Wai case ISCSI_PARAM_BOOT_TARGET: 3539ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->boot_target); 35409a2307b1SAdheer Chandravanshi break; 3541f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_AUTO_SND_TGT_DISABLE: 3542ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->auto_snd_tgt_disable); 3543f8525eb4SAdheer Chandravanshi break; 3544f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_SESS: 3545ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->discovery_sess); 3546f8525eb4SAdheer Chandravanshi break; 3547f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_PORTAL_TYPE: 3548ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->portal_type); 3549f8525eb4SAdheer Chandravanshi break; 3550f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_CHAP_AUTH_EN: 3551ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->chap_auth_en); 3552f8525eb4SAdheer Chandravanshi break; 3553f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_LOGOUT_EN: 3554ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->discovery_logout_en); 3555f8525eb4SAdheer Chandravanshi break; 3556f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_BIDI_CHAP_EN: 3557ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->bidi_chap_en); 3558f8525eb4SAdheer Chandravanshi break; 3559f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL: 3560ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->discovery_auth_optional); 3561f8525eb4SAdheer Chandravanshi break; 3562f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DEF_TIME2WAIT: 3563ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->time2wait); 3564f8525eb4SAdheer Chandravanshi break; 3565f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DEF_TIME2RETAIN: 3566ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->time2retain); 3567f8525eb4SAdheer Chandravanshi break; 3568f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TSID: 3569ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->tsid); 3570f8525eb4SAdheer Chandravanshi break; 3571f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_ISID: 3572ec98ea70SChris Leech len = sysfs_emit(buf, "%02x%02x%02x%02x%02x%02x\n", 3573f8525eb4SAdheer Chandravanshi session->isid[0], session->isid[1], 3574f8525eb4SAdheer Chandravanshi session->isid[2], session->isid[3], 3575f8525eb4SAdheer Chandravanshi session->isid[4], session->isid[5]); 3576f8525eb4SAdheer Chandravanshi break; 3577f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_IDX: 3578ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->discovery_parent_idx); 3579f8525eb4SAdheer Chandravanshi break; 3580f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_TYPE: 3581f8525eb4SAdheer Chandravanshi if (session->discovery_parent_type) 3582ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", 3583f8525eb4SAdheer Chandravanshi session->discovery_parent_type); 3584f8525eb4SAdheer Chandravanshi else 3585ec98ea70SChris Leech len = sysfs_emit(buf, "\n"); 35863b9373e9SEddie Wai break; 3587a54a52caSMike Christie default: 3588a54a52caSMike Christie return -ENOSYS; 3589a54a52caSMike Christie } 3590a54a52caSMike Christie 3591a54a52caSMike Christie return len; 3592a54a52caSMike Christie } 3593a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_get_param); 3594a54a52caSMike Christie 359500f3708eSMike Christie int iscsi_conn_get_addr_param(struct sockaddr_storage *addr, 359600f3708eSMike Christie enum iscsi_param param, char *buf) 359700f3708eSMike Christie { 359800f3708eSMike Christie struct sockaddr_in6 *sin6 = NULL; 359900f3708eSMike Christie struct sockaddr_in *sin = NULL; 360000f3708eSMike Christie int len; 360100f3708eSMike Christie 360200f3708eSMike Christie switch (addr->ss_family) { 360300f3708eSMike Christie case AF_INET: 360400f3708eSMike Christie sin = (struct sockaddr_in *)addr; 360500f3708eSMike Christie break; 360600f3708eSMike Christie case AF_INET6: 360700f3708eSMike Christie sin6 = (struct sockaddr_in6 *)addr; 360800f3708eSMike Christie break; 360900f3708eSMike Christie default: 361000f3708eSMike Christie return -EINVAL; 361100f3708eSMike Christie } 361200f3708eSMike Christie 361300f3708eSMike Christie switch (param) { 361400f3708eSMike Christie case ISCSI_PARAM_CONN_ADDRESS: 361500f3708eSMike Christie case ISCSI_HOST_PARAM_IPADDRESS: 361600f3708eSMike Christie if (sin) 3617ec98ea70SChris Leech len = sysfs_emit(buf, "%pI4\n", &sin->sin_addr.s_addr); 361800f3708eSMike Christie else 3619ec98ea70SChris Leech len = sysfs_emit(buf, "%pI6\n", &sin6->sin6_addr); 362000f3708eSMike Christie break; 362100f3708eSMike Christie case ISCSI_PARAM_CONN_PORT: 36224bfb8ebfSMike Christie case ISCSI_PARAM_LOCAL_PORT: 362300f3708eSMike Christie if (sin) 3624ec98ea70SChris Leech len = sysfs_emit(buf, "%hu\n", be16_to_cpu(sin->sin_port)); 362500f3708eSMike Christie else 3626ec98ea70SChris Leech len = sysfs_emit(buf, "%hu\n", 362700f3708eSMike Christie be16_to_cpu(sin6->sin6_port)); 362800f3708eSMike Christie break; 362900f3708eSMike Christie default: 363000f3708eSMike Christie return -EINVAL; 363100f3708eSMike Christie } 363200f3708eSMike Christie 363300f3708eSMike Christie return len; 363400f3708eSMike Christie } 363500f3708eSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_addr_param); 363600f3708eSMike Christie 3637a54a52caSMike Christie int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, 3638a54a52caSMike Christie enum iscsi_param param, char *buf) 3639a54a52caSMike Christie { 3640a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 3641a54a52caSMike Christie int len; 3642a54a52caSMike Christie 3643a54a52caSMike Christie switch(param) { 3644f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 3645ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->ping_timeout); 3646f6d5180cSMike Christie break; 3647f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 3648ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->recv_timeout); 3649f6d5180cSMike Christie break; 3650a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 3651ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->max_recv_dlength); 3652a54a52caSMike Christie break; 3653a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3654ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->max_xmit_dlength); 3655a54a52caSMike Christie break; 3656a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 3657ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->hdrdgst_en); 3658a54a52caSMike Christie break; 3659a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 3660ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->datadgst_en); 3661a54a52caSMike Christie break; 3662a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 3663ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->ifmarker_en); 3664a54a52caSMike Christie break; 3665a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 3666ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->ofmarker_en); 3667a54a52caSMike Christie break; 3668a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 3669ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->exp_statsn); 3670a54a52caSMike Christie break; 3671a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3672ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->persistent_port); 3673a54a52caSMike Christie break; 3674a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 3675ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", conn->persistent_address); 3676a54a52caSMike Christie break; 3677f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_STATSN: 3678ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->statsn); 3679f8525eb4SAdheer Chandravanshi break; 3680f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_MAX_SEGMENT_SIZE: 3681ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->max_segment_size); 3682f8525eb4SAdheer Chandravanshi break; 3683f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_KEEPALIVE_TMO: 3684ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->keepalive_tmo); 3685f8525eb4SAdheer Chandravanshi break; 3686f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_PORT: 3687ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->local_port); 3688f8525eb4SAdheer Chandravanshi break; 3689f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMESTAMP_STAT: 3690ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_timestamp_stat); 3691f8525eb4SAdheer Chandravanshi break; 3692f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_NAGLE_DISABLE: 3693ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_nagle_disable); 3694f8525eb4SAdheer Chandravanshi break; 3695f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_WSF_DISABLE: 3696ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_wsf_disable); 3697f8525eb4SAdheer Chandravanshi break; 3698f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMER_SCALE: 3699ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_timer_scale); 3700f8525eb4SAdheer Chandravanshi break; 3701f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMESTAMP_EN: 3702ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_timestamp_en); 3703f8525eb4SAdheer Chandravanshi break; 3704f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IP_FRAGMENT_DISABLE: 3705ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->fragment_disable); 3706f8525eb4SAdheer Chandravanshi break; 3707f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IPV4_TOS: 3708ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->ipv4_tos); 3709f8525eb4SAdheer Chandravanshi break; 3710f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IPV6_TC: 3711ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->ipv6_traffic_class); 3712f8525eb4SAdheer Chandravanshi break; 37135f09e1f3SAdheer Chandravanshi case ISCSI_PARAM_IPV6_FLOW_LABEL: 3714ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->ipv6_flow_label); 37155f09e1f3SAdheer Chandravanshi break; 3716f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IS_FW_ASSIGNED_IPV6: 3717ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->is_fw_assigned_ipv6); 3718f8525eb4SAdheer Chandravanshi break; 3719f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_XMIT_WSF: 3720ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_xmit_wsf); 3721f8525eb4SAdheer Chandravanshi break; 3722f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_RECV_WSF: 3723ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_recv_wsf); 3724f8525eb4SAdheer Chandravanshi break; 3725ae56ff40SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_IPADDR: 3726ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", conn->local_ipaddr); 3727ae56ff40SAdheer Chandravanshi break; 3728a54a52caSMike Christie default: 3729a54a52caSMike Christie return -ENOSYS; 3730a54a52caSMike Christie } 3731a54a52caSMike Christie 3732a54a52caSMike Christie return len; 3733a54a52caSMike Christie } 3734a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_param); 3735a54a52caSMike Christie 37360801c242SMike Christie int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param, 37370801c242SMike Christie char *buf) 37380801c242SMike Christie { 373975613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 37400801c242SMike Christie int len; 37410801c242SMike Christie 37420801c242SMike Christie switch (param) { 3743d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 3744ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", ihost->netdev); 3745d8196ed2SMike Christie break; 37460801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 3747ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", ihost->hwaddress); 37480801c242SMike Christie break; 37498ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 3750ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", ihost->initiatorname); 37518ad5781aSMike Christie break; 37520801c242SMike Christie default: 37530801c242SMike Christie return -ENOSYS; 37540801c242SMike Christie } 37550801c242SMike Christie 37560801c242SMike Christie return len; 37570801c242SMike Christie } 37580801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_param); 37590801c242SMike Christie 37600801c242SMike Christie int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param, 37610801c242SMike Christie char *buf, int buflen) 37620801c242SMike Christie { 376375613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 37640801c242SMike Christie 37650801c242SMike Christie switch (param) { 3766d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 37675700b1afSMike Christie return iscsi_switch_str_param(&ihost->netdev, buf); 37680801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 37695700b1afSMike Christie return iscsi_switch_str_param(&ihost->hwaddress, buf); 37708ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 37715700b1afSMike Christie return iscsi_switch_str_param(&ihost->initiatorname, buf); 37720801c242SMike Christie default: 37730801c242SMike Christie return -ENOSYS; 37740801c242SMike Christie } 37750801c242SMike Christie 37760801c242SMike Christie return 0; 37770801c242SMike Christie } 37780801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_set_param); 37790801c242SMike Christie 37807996a778SMike Christie MODULE_AUTHOR("Mike Christie"); 37817996a778SMike Christie MODULE_DESCRIPTION("iSCSI library functions"); 37827996a778SMike Christie MODULE_LICENSE("GPL"); 3783