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 86e1c6a7ecSMike Christie #define ISCSI_CMD_COMPL_WAIT 5 87e1c6a7ecSMike Christie 884b9f8ce4SMike Christie inline void iscsi_conn_queue_xmit(struct iscsi_conn *conn) 8932ae763eSMike Christie { 9032ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 9132ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 9232ae763eSMike Christie 931336aed1SMike Christie if (ihost->workq) 9432ae763eSMike Christie queue_work(ihost->workq, &conn->xmitwork); 9532ae763eSMike Christie } 964b9f8ce4SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_queue_xmit); 9732ae763eSMike Christie 988af80996SMike Christie inline void iscsi_conn_queue_recv(struct iscsi_conn *conn) 998af80996SMike Christie { 1008af80996SMike Christie struct Scsi_Host *shost = conn->session->host; 1018af80996SMike Christie struct iscsi_host *ihost = shost_priv(shost); 1028af80996SMike Christie 1038af80996SMike Christie if (ihost->workq && !test_bit(ISCSI_CONN_FLAG_SUSPEND_RX, &conn->flags)) 1048af80996SMike Christie queue_work(ihost->workq, &conn->recvwork); 1058af80996SMike Christie } 1068af80996SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_queue_recv); 1078af80996SMike Christie 1084c0ba5d2SMike Christie static void __iscsi_update_cmdsn(struct iscsi_session *session, 1094c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 1107996a778SMike Christie { 11177a23c21SMike Christie /* 11277a23c21SMike Christie * standard specifies this check for when to update expected and 11377a23c21SMike Christie * max sequence numbers 11477a23c21SMike Christie */ 11577a23c21SMike Christie if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1)) 11677a23c21SMike Christie return; 11777a23c21SMike Christie 11877a23c21SMike Christie if (exp_cmdsn != session->exp_cmdsn && 11977a23c21SMike Christie !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn)) 1207996a778SMike Christie session->exp_cmdsn = exp_cmdsn; 1217996a778SMike Christie 12277a23c21SMike Christie if (max_cmdsn != session->max_cmdsn && 12346a84c65SMike Christie !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) 12477a23c21SMike Christie session->max_cmdsn = max_cmdsn; 12577a23c21SMike Christie } 1264c0ba5d2SMike Christie 1274c0ba5d2SMike Christie void iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr) 1284c0ba5d2SMike Christie { 1294c0ba5d2SMike Christie __iscsi_update_cmdsn(session, be32_to_cpu(hdr->exp_cmdsn), 1304c0ba5d2SMike Christie be32_to_cpu(hdr->max_cmdsn)); 1314c0ba5d2SMike Christie } 13277a23c21SMike Christie EXPORT_SYMBOL_GPL(iscsi_update_cmdsn); 1337996a778SMike Christie 134577577daSMike Christie /** 135577577daSMike Christie * iscsi_prep_data_out_pdu - initialize Data-Out 136577577daSMike Christie * @task: scsi command task 137577577daSMike Christie * @r2t: R2T info 138577577daSMike Christie * @hdr: iscsi data in pdu 139577577daSMike Christie * 140577577daSMike Christie * Notes: 141577577daSMike Christie * Initialize Data-Out within this R2T sequence and finds 142577577daSMike Christie * proper data_offset within this SCSI command. 143577577daSMike Christie * 144577577daSMike Christie * This function is called with connection lock taken. 145577577daSMike Christie **/ 146577577daSMike Christie void iscsi_prep_data_out_pdu(struct iscsi_task *task, struct iscsi_r2t_info *r2t, 147ffd0436eSMike Christie struct iscsi_data *hdr) 1487996a778SMike Christie { 1499c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 150577577daSMike Christie unsigned int left = r2t->data_length - r2t->sent; 151577577daSMike Christie 152577577daSMike Christie task->hdr_len = sizeof(struct iscsi_data); 1537996a778SMike Christie 1547996a778SMike Christie memset(hdr, 0, sizeof(struct iscsi_data)); 155577577daSMike Christie hdr->ttt = r2t->ttt; 156577577daSMike Christie hdr->datasn = cpu_to_be32(r2t->datasn); 157577577daSMike Christie r2t->datasn++; 1587996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_DATA_OUT; 15955bdabdfSAndy Grover hdr->lun = task->lun; 160577577daSMike Christie hdr->itt = task->hdr_itt; 161577577daSMike Christie hdr->exp_statsn = r2t->exp_statsn; 162577577daSMike Christie hdr->offset = cpu_to_be32(r2t->data_offset + r2t->sent); 163577577daSMike Christie if (left > conn->max_xmit_dlength) { 1647996a778SMike Christie hton24(hdr->dlength, conn->max_xmit_dlength); 165577577daSMike Christie r2t->data_count = conn->max_xmit_dlength; 1667996a778SMike Christie hdr->flags = 0; 1677996a778SMike Christie } else { 168577577daSMike Christie hton24(hdr->dlength, left); 169577577daSMike Christie r2t->data_count = left; 1707996a778SMike Christie hdr->flags = ISCSI_FLAG_CMD_FINAL; 1717996a778SMike Christie } 172577577daSMike Christie conn->dataout_pdus_cnt++; 1737996a778SMike Christie } 174577577daSMike Christie EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu); 1757996a778SMike Christie 1769c19a7d0SMike Christie static int iscsi_add_hdr(struct iscsi_task *task, unsigned len) 177004d6530SBoaz Harrosh { 1789c19a7d0SMike Christie unsigned exp_len = task->hdr_len + len; 179004d6530SBoaz Harrosh 1809c19a7d0SMike Christie if (exp_len > task->hdr_max) { 181004d6530SBoaz Harrosh WARN_ON(1); 182004d6530SBoaz Harrosh return -EINVAL; 183004d6530SBoaz Harrosh } 184004d6530SBoaz Harrosh 185004d6530SBoaz Harrosh WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */ 1869c19a7d0SMike Christie task->hdr_len = exp_len; 187004d6530SBoaz Harrosh return 0; 188004d6530SBoaz Harrosh } 189004d6530SBoaz Harrosh 19038d1c069SBoaz Harrosh /* 19138d1c069SBoaz Harrosh * make an extended cdb AHS 19238d1c069SBoaz Harrosh */ 1939c19a7d0SMike Christie static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) 19438d1c069SBoaz Harrosh { 1959c19a7d0SMike Christie struct scsi_cmnd *cmd = task->sc; 19638d1c069SBoaz Harrosh unsigned rlen, pad_len; 19738d1c069SBoaz Harrosh unsigned short ahslength; 19838d1c069SBoaz Harrosh struct iscsi_ecdb_ahdr *ecdb_ahdr; 19938d1c069SBoaz Harrosh int rc; 20038d1c069SBoaz Harrosh 2019c19a7d0SMike Christie ecdb_ahdr = iscsi_next_hdr(task); 20238d1c069SBoaz Harrosh rlen = cmd->cmd_len - ISCSI_CDB_SIZE; 20338d1c069SBoaz Harrosh 20438d1c069SBoaz Harrosh BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb)); 20538d1c069SBoaz Harrosh ahslength = rlen + sizeof(ecdb_ahdr->reserved); 20638d1c069SBoaz Harrosh 20738d1c069SBoaz Harrosh pad_len = iscsi_padding(rlen); 20838d1c069SBoaz Harrosh 2099c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) + 21038d1c069SBoaz Harrosh sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len); 21138d1c069SBoaz Harrosh if (rc) 21238d1c069SBoaz Harrosh return rc; 21338d1c069SBoaz Harrosh 21438d1c069SBoaz Harrosh if (pad_len) 21538d1c069SBoaz Harrosh memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len); 21638d1c069SBoaz Harrosh 21738d1c069SBoaz Harrosh ecdb_ahdr->ahslength = cpu_to_be16(ahslength); 21838d1c069SBoaz Harrosh ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB; 21938d1c069SBoaz Harrosh ecdb_ahdr->reserved = 0; 22038d1c069SBoaz Harrosh memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen); 22138d1c069SBoaz Harrosh 2221b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2231b2c7af8SMike Christie "iscsi_prep_ecdb_ahs: varlen_cdb_len %d " 2241b2c7af8SMike Christie "rlen %d pad_len %d ahs_length %d iscsi_headers_size " 2251b2c7af8SMike Christie "%u\n", cmd->cmd_len, rlen, pad_len, ahslength, 2261b2c7af8SMike Christie task->hdr_len); 22738d1c069SBoaz Harrosh return 0; 22838d1c069SBoaz Harrosh } 22938d1c069SBoaz Harrosh 2307996a778SMike Christie /** 2315d12c05eSMike Christie * iscsi_check_tmf_restrictions - check if a task is affected by TMF 2325d12c05eSMike Christie * @task: iscsi task 2335d12c05eSMike Christie * @opcode: opcode to check for 2345d12c05eSMike Christie * 2355d12c05eSMike Christie * During TMF a task has to be checked if it's affected. 2365d12c05eSMike Christie * All unrelated I/O can be passed through, but I/O to the 2375d12c05eSMike Christie * affected LUN should be restricted. 2385d12c05eSMike Christie * If 'fast_abort' is set we won't be sending any I/O to the 2395d12c05eSMike Christie * affected LUN. 2405d12c05eSMike Christie * Otherwise the target is waiting for all TTTs to be completed, 2415d12c05eSMike Christie * so we have to send all outstanding Data-Out PDUs to the target. 2425d12c05eSMike Christie */ 2435d12c05eSMike Christie static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode) 2445d12c05eSMike Christie { 245ec29d0acSMike Christie struct iscsi_session *session = task->conn->session; 246ec29d0acSMike Christie struct iscsi_tm *tmf = &session->tmhdr; 2479cb78c16SHannes Reinecke u64 hdr_lun; 2485d12c05eSMike Christie 249ec29d0acSMike Christie if (session->tmf_state == TMF_INITIAL) 2505d12c05eSMike Christie return 0; 2515d12c05eSMike Christie 2525d12c05eSMike Christie if ((tmf->opcode & ISCSI_OPCODE_MASK) != ISCSI_OP_SCSI_TMFUNC) 2535d12c05eSMike Christie return 0; 2545d12c05eSMike Christie 2555d12c05eSMike Christie switch (ISCSI_TM_FUNC_VALUE(tmf)) { 2565d12c05eSMike Christie case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET: 2575d12c05eSMike Christie /* 2585d12c05eSMike Christie * Allow PDUs for unrelated LUNs 2595d12c05eSMike Christie */ 26055bdabdfSAndy Grover hdr_lun = scsilun_to_int(&tmf->lun); 2615d12c05eSMike Christie if (hdr_lun != task->sc->device->lun) 2625d12c05eSMike Christie return 0; 263df561f66SGustavo A. R. Silva fallthrough; 2643fe5ae8bSMike Christie case ISCSI_TM_FUNC_TARGET_WARM_RESET: 2655d12c05eSMike Christie /* 2665d12c05eSMike Christie * Fail all SCSI cmd PDUs 2675d12c05eSMike Christie */ 2685d12c05eSMike Christie if (opcode != ISCSI_OP_SCSI_DATA_OUT) { 269ec29d0acSMike Christie iscsi_session_printk(KERN_INFO, session, 270ec29d0acSMike Christie "task [op %x itt 0x%x/0x%x] rejected.\n", 271ec29d0acSMike Christie opcode, task->itt, task->hdr_itt); 2725d12c05eSMike Christie return -EACCES; 2735d12c05eSMike Christie } 2745d12c05eSMike Christie /* 2755d12c05eSMike Christie * And also all data-out PDUs in response to R2T 2765d12c05eSMike Christie * if fast_abort is set. 2775d12c05eSMike Christie */ 278ec29d0acSMike Christie if (session->fast_abort) { 279ec29d0acSMike Christie iscsi_session_printk(KERN_INFO, session, 280ec29d0acSMike Christie "task [op %x itt 0x%x/0x%x] fast abort.\n", 281ec29d0acSMike Christie opcode, task->itt, task->hdr_itt); 2825d12c05eSMike Christie return -EACCES; 2835d12c05eSMike Christie } 2845d12c05eSMike Christie break; 2855d12c05eSMike Christie case ISCSI_TM_FUNC_ABORT_TASK: 2865d12c05eSMike Christie /* 2875d12c05eSMike Christie * the caller has already checked if the task 2885d12c05eSMike Christie * they want to abort was in the pending queue so if 2895d12c05eSMike Christie * we are here the cmd pdu has gone out already, and 2905d12c05eSMike Christie * we will only hit this for data-outs 2915d12c05eSMike Christie */ 2925d12c05eSMike Christie if (opcode == ISCSI_OP_SCSI_DATA_OUT && 2935d12c05eSMike Christie task->hdr_itt == tmf->rtt) { 294ec29d0acSMike Christie ISCSI_DBG_SESSION(session, 2955d12c05eSMike Christie "Preventing task %x/%x from sending " 2965d12c05eSMike Christie "data-out due to abort task in " 2975d12c05eSMike Christie "progress\n", task->itt, 2985d12c05eSMike Christie task->hdr_itt); 2995d12c05eSMike Christie return -EACCES; 3005d12c05eSMike Christie } 3015d12c05eSMike Christie break; 3025d12c05eSMike Christie } 3035d12c05eSMike Christie 3045d12c05eSMike Christie return 0; 3055d12c05eSMike Christie } 3065d12c05eSMike Christie 3075d12c05eSMike Christie /** 3087996a778SMike Christie * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu 3099c19a7d0SMike Christie * @task: iscsi task 3107996a778SMike Christie * 3117996a778SMike Christie * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set 3127996a778SMike Christie * fields like dlength or final based on how much data it sends 3137996a778SMike Christie */ 3149c19a7d0SMike Christie static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task) 3157996a778SMike Christie { 3169c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 3177996a778SMike Christie struct iscsi_session *session = conn->session; 3189c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 31912352183SNicholas Bellinger struct iscsi_scsi_req *hdr; 320d77e6535SSagi Grimberg unsigned hdrlength, cmd_len, transfer_length; 321262ef636SMike Christie itt_t itt; 322004d6530SBoaz Harrosh int rc; 3237996a778SMike Christie 3245d12c05eSMike Christie rc = iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_CMD); 3255d12c05eSMike Christie if (rc) 3265d12c05eSMike Christie return rc; 3275d12c05eSMike Christie 328184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 3292ff79d52SMike Christie rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD); 330577577daSMike Christie if (rc) 331577577daSMike Christie return rc; 332184b57c6SMike Christie } 33312352183SNicholas Bellinger hdr = (struct iscsi_scsi_req *)task->hdr; 334262ef636SMike Christie itt = hdr->itt; 335577577daSMike Christie memset(hdr, 0, sizeof(*hdr)); 336577577daSMike Christie 3372ff79d52SMike Christie if (session->tt->parse_pdu_itt) 3382ff79d52SMike Christie hdr->itt = task->hdr_itt = itt; 3392ff79d52SMike Christie else 3402ff79d52SMike Christie hdr->itt = task->hdr_itt = build_itt(task->itt, 3412ff79d52SMike Christie task->conn->session->age); 3429c19a7d0SMike Christie task->hdr_len = 0; 3439c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*hdr)); 344004d6530SBoaz Harrosh if (rc) 345004d6530SBoaz Harrosh return rc; 3467996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_CMD; 3477996a778SMike Christie hdr->flags = ISCSI_ATTR_SIMPLE; 34855bdabdfSAndy Grover int_to_scsilun(sc->device->lun, &hdr->lun); 34955bdabdfSAndy Grover task->lun = hdr->lun; 3507996a778SMike Christie hdr->exp_statsn = cpu_to_be32(conn->exp_statsn); 35138d1c069SBoaz Harrosh cmd_len = sc->cmd_len; 35238d1c069SBoaz Harrosh if (cmd_len < ISCSI_CDB_SIZE) 35338d1c069SBoaz Harrosh memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len); 35438d1c069SBoaz Harrosh else if (cmd_len > ISCSI_CDB_SIZE) { 3559c19a7d0SMike Christie rc = iscsi_prep_ecdb_ahs(task); 35638d1c069SBoaz Harrosh if (rc) 35738d1c069SBoaz Harrosh return rc; 35838d1c069SBoaz Harrosh cmd_len = ISCSI_CDB_SIZE; 35938d1c069SBoaz Harrosh } 36038d1c069SBoaz Harrosh memcpy(hdr->cdb, sc->cmnd, cmd_len); 3617996a778SMike Christie 3629c19a7d0SMike Christie task->imm_count = 0; 36355e51edaSSagi Grimberg if (scsi_get_prot_op(sc) != SCSI_PROT_NORMAL) 36455e51edaSSagi Grimberg task->protected = true; 36555e51edaSSagi Grimberg 366d77e6535SSagi Grimberg transfer_length = scsi_transfer_length(sc); 367d77e6535SSagi Grimberg hdr->data_length = cpu_to_be32(transfer_length); 3687996a778SMike Christie if (sc->sc_data_direction == DMA_TO_DEVICE) { 369577577daSMike Christie struct iscsi_r2t_info *r2t = &task->unsol_r2t; 370577577daSMike Christie 3717996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_WRITE; 3727996a778SMike Christie /* 3737996a778SMike Christie * Write counters: 3747996a778SMike Christie * 3757996a778SMike Christie * imm_count bytes to be sent right after 3767996a778SMike Christie * SCSI PDU Header 3777996a778SMike Christie * 3787996a778SMike Christie * unsol_count bytes(as Data-Out) to be sent 3797996a778SMike Christie * without R2T ack right after 3807996a778SMike Christie * immediate data 3817996a778SMike Christie * 382577577daSMike Christie * r2t data_length bytes to be sent via R2T ack's 3837996a778SMike Christie * 3847996a778SMike Christie * pad_count bytes to be sent as zero-padding 3857996a778SMike Christie */ 386577577daSMike Christie memset(r2t, 0, sizeof(*r2t)); 3877996a778SMike Christie 3887996a778SMike Christie if (session->imm_data_en) { 389d77e6535SSagi Grimberg if (transfer_length >= session->first_burst) 3909c19a7d0SMike Christie task->imm_count = min(session->first_burst, 3917996a778SMike Christie conn->max_xmit_dlength); 3927996a778SMike Christie else 393d77e6535SSagi Grimberg task->imm_count = min(transfer_length, 3947996a778SMike Christie conn->max_xmit_dlength); 3959c19a7d0SMike Christie hton24(hdr->dlength, task->imm_count); 3967996a778SMike Christie } else 397a8ac6311SOlaf Kirch zero_data(hdr->dlength); 3987996a778SMike Christie 399ffd0436eSMike Christie if (!session->initial_r2t_en) { 400d77e6535SSagi Grimberg r2t->data_length = min(session->first_burst, 401d77e6535SSagi Grimberg transfer_length) - 402577577daSMike Christie task->imm_count; 403577577daSMike Christie r2t->data_offset = task->imm_count; 404577577daSMike Christie r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG); 405577577daSMike Christie r2t->exp_statsn = cpu_to_be32(conn->exp_statsn); 406ffd0436eSMike Christie } 407ffd0436eSMike Christie 408577577daSMike Christie if (!task->unsol_r2t.data_length) 4097996a778SMike Christie /* No unsolicit Data-Out's */ 410a8ac6311SOlaf Kirch hdr->flags |= ISCSI_FLAG_CMD_FINAL; 4117996a778SMike Christie } else { 4127996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 4137996a778SMike Christie zero_data(hdr->dlength); 4147996a778SMike Christie 4157996a778SMike Christie if (sc->sc_data_direction == DMA_FROM_DEVICE) 4167996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_READ; 4177996a778SMike Christie } 4187996a778SMike Christie 419004d6530SBoaz Harrosh /* calculate size of additional header segments (AHSs) */ 4209c19a7d0SMike Christie hdrlength = task->hdr_len - sizeof(*hdr); 421004d6530SBoaz Harrosh 422004d6530SBoaz Harrosh WARN_ON(hdrlength & (ISCSI_PAD_LEN-1)); 423004d6530SBoaz Harrosh hdrlength /= ISCSI_PAD_LEN; 424004d6530SBoaz Harrosh 425004d6530SBoaz Harrosh WARN_ON(hdrlength >= 256); 426004d6530SBoaz Harrosh hdr->hlength = hdrlength & 0xFF; 42796b1f96dSMike Christie hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn); 428004d6530SBoaz Harrosh 429577577daSMike Christie if (session->tt->init_task && session->tt->init_task(task)) 430052d0144SMike Christie return -EIO; 431052d0144SMike Christie 4329c19a7d0SMike Christie task->state = ISCSI_TASK_RUNNING; 433d3305f34SMike Christie session->cmdsn++; 43477a23c21SMike Christie 435a8ac6311SOlaf Kirch conn->scsicmd_pdus_cnt++; 4361b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi prep [%s cid %d sc %p cdb 0x%x " 437ae3d56d8SChristoph Hellwig "itt 0x%x len %d cmdsn %d win %d]\n", 4381b2c7af8SMike Christie sc->sc_data_direction == DMA_TO_DEVICE ? 4391b2c7af8SMike Christie "write" : "read", conn->id, sc, sc->cmnd[0], 440d77e6535SSagi Grimberg task->itt, transfer_length, 4411b2c7af8SMike Christie session->cmdsn, 4421b2c7af8SMike Christie session->max_cmdsn - session->exp_cmdsn + 1); 443004d6530SBoaz Harrosh return 0; 4447996a778SMike Christie } 4457996a778SMike Christie 4467996a778SMike Christie /** 4473bbaaad9SMike Christie * iscsi_free_task - free a task 4489c19a7d0SMike Christie * @task: iscsi cmd task 4497996a778SMike Christie * 450659743b0SShlomo Pongratz * Must be called with session back_lock. 4513e5c28adSMike Christie * This function returns the scsi command to scsi-ml or cleans 4523e5c28adSMike Christie * up mgmt tasks then returns the task to the pool. 4537996a778SMike Christie */ 4543bbaaad9SMike Christie static void iscsi_free_task(struct iscsi_task *task) 4557996a778SMike Christie { 4569c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 457c1635cb7SMike Christie struct iscsi_session *session = conn->session; 4589c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 459f41d4721SMike Christie int oldstate = task->state; 4607996a778SMike Christie 4614421c9ebSMike Christie ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n", 4624421c9ebSMike Christie task->itt, task->state, task->sc); 4634421c9ebSMike Christie 464577577daSMike Christie session->tt->cleanup_task(task); 4653bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 4669c19a7d0SMike Christie task->sc = NULL; 4673e5c28adSMike Christie /* 4689c19a7d0SMike Christie * login task is preallocated so do not free 4693e5c28adSMike Christie */ 4709c19a7d0SMike Christie if (conn->login_task == task) 4713e5c28adSMike Christie return; 4723e5c28adSMike Christie 4737acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&task, sizeof(void*)); 4743e5c28adSMike Christie 4753e5c28adSMike Christie if (sc) { 476f47f2cf5SMike Christie /* SCSI eh reuses commands to verify us */ 477db22de3eSBart Van Assche iscsi_cmd(sc)->task = NULL; 4783e5c28adSMike Christie /* 479f41d4721SMike Christie * queue command may call this to free the task, so 480f41d4721SMike Christie * it will decide how to return sc to scsi-ml. 4813e5c28adSMike Christie */ 482f41d4721SMike Christie if (oldstate != ISCSI_TASK_REQUEUE_SCSIQ) 483b4b84edcSBart Van Assche scsi_done(sc); 4847996a778SMike Christie } 4853e5c28adSMike Christie } 4867996a778SMike Christie 487e1c6a7ecSMike Christie bool iscsi_get_task(struct iscsi_task *task) 48860ecebf5SMike Christie { 489e1c6a7ecSMike Christie return refcount_inc_not_zero(&task->refcount); 49060ecebf5SMike Christie } 491e1c6a7ecSMike Christie EXPORT_SYMBOL_GPL(iscsi_get_task); 49260ecebf5SMike Christie 493*6d626150SMike Christie /** 494*6d626150SMike Christie * __iscsi_put_task - drop the refcount on a task 495*6d626150SMike Christie * @task: iscsi_task to drop the refcount on 496*6d626150SMike Christie * 497*6d626150SMike Christie * The back_lock must be held when calling in case it frees the task. 498*6d626150SMike Christie */ 4998eea2f55SEddie Wai void __iscsi_put_task(struct iscsi_task *task) 50060ecebf5SMike Christie { 5016dc618cdSElena Reshetova if (refcount_dec_and_test(&task->refcount)) 5023bbaaad9SMike Christie iscsi_free_task(task); 50360ecebf5SMike Christie } 5048eea2f55SEddie Wai EXPORT_SYMBOL_GPL(__iscsi_put_task); 50560ecebf5SMike Christie 5069c19a7d0SMike Christie void iscsi_put_task(struct iscsi_task *task) 5073e5c28adSMike Christie { 5089c19a7d0SMike Christie struct iscsi_session *session = task->conn->session; 5093e5c28adSMike Christie 510*6d626150SMike Christie if (refcount_dec_and_test(&task->refcount)) { 511659743b0SShlomo Pongratz spin_lock_bh(&session->back_lock); 512*6d626150SMike Christie iscsi_free_task(task); 513659743b0SShlomo Pongratz spin_unlock_bh(&session->back_lock); 5143e5c28adSMike Christie } 515*6d626150SMike Christie } 5169c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_put_task); 5173e5c28adSMike Christie 5183bbaaad9SMike Christie /** 5193bbaaad9SMike Christie * iscsi_complete_task - finish a task 5203bbaaad9SMike Christie * @task: iscsi cmd task 521b3cd5050SMike Christie * @state: state to complete task with 5223bbaaad9SMike Christie * 523659743b0SShlomo Pongratz * Must be called with session back_lock. 524b3a7ea8dSMike Christie */ 525b3cd5050SMike Christie static void iscsi_complete_task(struct iscsi_task *task, int state) 526b3a7ea8dSMike Christie { 5273bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 5283bbaaad9SMike Christie 5294421c9ebSMike Christie ISCSI_DBG_SESSION(conn->session, 5304421c9ebSMike Christie "complete task itt 0x%x state %d sc %p\n", 5314421c9ebSMike Christie task->itt, task->state, task->sc); 532b3cd5050SMike Christie if (task->state == ISCSI_TASK_COMPLETED || 533b3cd5050SMike Christie task->state == ISCSI_TASK_ABRT_TMF || 534f41d4721SMike Christie task->state == ISCSI_TASK_ABRT_SESS_RECOV || 535f41d4721SMike Christie task->state == ISCSI_TASK_REQUEUE_SCSIQ) 5363bbaaad9SMike Christie return; 5373bbaaad9SMike Christie WARN_ON_ONCE(task->state == ISCSI_TASK_FREE); 538b3cd5050SMike Christie task->state = state; 5393bbaaad9SMike Christie 540fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task) == task) 541fe0a8a95SLee Duncan WRITE_ONCE(conn->ping_task, NULL); 5423bbaaad9SMike Christie 5433bbaaad9SMike Christie /* release get from queueing */ 5443bbaaad9SMike Christie __iscsi_put_task(task); 5453bbaaad9SMike Christie } 5463bbaaad9SMike Christie 5474c0ba5d2SMike Christie /** 5484c0ba5d2SMike Christie * iscsi_complete_scsi_task - finish scsi task normally 5494c0ba5d2SMike Christie * @task: iscsi task for scsi cmd 5504c0ba5d2SMike Christie * @exp_cmdsn: expected cmd sn in cpu format 5514c0ba5d2SMike Christie * @max_cmdsn: max cmd sn in cpu format 5524c0ba5d2SMike Christie * 5534c0ba5d2SMike Christie * This is used when drivers do not need or cannot perform 5544c0ba5d2SMike Christie * lower level pdu processing. 5554c0ba5d2SMike Christie * 556659743b0SShlomo Pongratz * Called with session back_lock 5574c0ba5d2SMike Christie */ 5584c0ba5d2SMike Christie void iscsi_complete_scsi_task(struct iscsi_task *task, 5594c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 5604c0ba5d2SMike Christie { 5614c0ba5d2SMike Christie struct iscsi_conn *conn = task->conn; 5624c0ba5d2SMike Christie 5634c0ba5d2SMike Christie ISCSI_DBG_SESSION(conn->session, "[itt 0x%x]\n", task->itt); 5644c0ba5d2SMike Christie 5654c0ba5d2SMike Christie conn->last_recv = jiffies; 5664c0ba5d2SMike Christie __iscsi_update_cmdsn(conn->session, exp_cmdsn, max_cmdsn); 5674c0ba5d2SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 5684c0ba5d2SMike Christie } 5694c0ba5d2SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_scsi_task); 5704c0ba5d2SMike Christie 5715923d64bSMike Christie /* 5725923d64bSMike Christie * Must be called with back and frwd lock 5735923d64bSMike Christie */ 5745923d64bSMike Christie static bool cleanup_queued_task(struct iscsi_task *task) 5755923d64bSMike Christie { 5765923d64bSMike Christie struct iscsi_conn *conn = task->conn; 5775923d64bSMike Christie bool early_complete = false; 5785923d64bSMike Christie 579533ac412SMike Christie /* 580533ac412SMike Christie * We might have raced where we handled a R2T early and got a response 581533ac412SMike Christie * but have not yet taken the task off the requeue list, then a TMF or 582533ac412SMike Christie * recovery happened and so we can still see it here. 583533ac412SMike Christie */ 5845923d64bSMike Christie if (task->state == ISCSI_TASK_COMPLETED) 5855923d64bSMike Christie early_complete = true; 5865923d64bSMike Christie 5875923d64bSMike Christie if (!list_empty(&task->running)) { 5885923d64bSMike Christie list_del_init(&task->running); 5895923d64bSMike Christie /* 590533ac412SMike Christie * If it's on a list but still running this could be cleanup 591533ac412SMike Christie * from a TMF or session recovery. 5925923d64bSMike Christie */ 5935923d64bSMike Christie if (task->state == ISCSI_TASK_RUNNING || 5945923d64bSMike Christie task->state == ISCSI_TASK_COMPLETED) 5955923d64bSMike Christie __iscsi_put_task(task); 5965923d64bSMike Christie } 5975923d64bSMike Christie 59899b06033SMike Christie if (conn->session->running_aborted_task == task) { 59999b06033SMike Christie conn->session->running_aborted_task = NULL; 60099b06033SMike Christie __iscsi_put_task(task); 60199b06033SMike Christie } 60299b06033SMike Christie 6035923d64bSMike Christie if (conn->task == task) { 6045923d64bSMike Christie conn->task = NULL; 6055923d64bSMike Christie __iscsi_put_task(task); 6065923d64bSMike Christie } 6075923d64bSMike Christie 6085923d64bSMike Christie return early_complete; 6095923d64bSMike Christie } 6104c0ba5d2SMike Christie 6113bbaaad9SMike Christie /* 612e1c6a7ecSMike Christie * session back and frwd lock must be held and if not called for a task that 613e1c6a7ecSMike Christie * is still pending or from the xmit thread, then xmit thread must be suspended 6143bbaaad9SMike Christie */ 615e1c6a7ecSMike Christie static void __fail_scsi_task(struct iscsi_task *task, int err) 6163bbaaad9SMike Christie { 6173bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 618b3a7ea8dSMike Christie struct scsi_cmnd *sc; 619b3cd5050SMike Christie int state; 620b3a7ea8dSMike Christie 621e1c6a7ecSMike Christie if (cleanup_queued_task(task)) 6225923d64bSMike Christie return; 6235923d64bSMike Christie 624b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) { 625b3a7ea8dSMike Christie /* 626b3a7ea8dSMike Christie * cmd never made it to the xmit thread, so we should not count 627b3a7ea8dSMike Christie * the cmd in the sequencing 628b3a7ea8dSMike Christie */ 629b3a7ea8dSMike Christie conn->session->queued_cmdsn--; 630b3cd5050SMike Christie /* it was never sent so just complete like normal */ 631b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 632b3cd5050SMike Christie } else if (err == DID_TRANSPORT_DISRUPTED) 633b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 634b3cd5050SMike Christie else 635b3cd5050SMike Christie state = ISCSI_TASK_ABRT_TMF; 636b3a7ea8dSMike Christie 63714936b1eSMike Christie sc = task->sc; 638b3cd5050SMike Christie sc->result = err << 16; 639b3a7ea8dSMike Christie scsi_set_resid(sc, scsi_bufflen(sc)); 640b3cd5050SMike Christie iscsi_complete_task(task, state); 641e1c6a7ecSMike Christie } 642e1c6a7ecSMike Christie 643e1c6a7ecSMike Christie static void fail_scsi_task(struct iscsi_task *task, int err) 644e1c6a7ecSMike Christie { 645e1c6a7ecSMike Christie struct iscsi_session *session = task->conn->session; 646e1c6a7ecSMike Christie 647e1c6a7ecSMike Christie spin_lock_bh(&session->back_lock); 648e1c6a7ecSMike Christie __fail_scsi_task(task, err); 649e1c6a7ecSMike Christie spin_unlock_bh(&session->back_lock); 650b3a7ea8dSMike Christie } 651b3a7ea8dSMike Christie 6523e5c28adSMike Christie static int iscsi_prep_mgmt_task(struct iscsi_conn *conn, 6539c19a7d0SMike Christie struct iscsi_task *task) 654052d0144SMike Christie { 655052d0144SMike Christie struct iscsi_session *session = conn->session; 656577577daSMike Christie struct iscsi_hdr *hdr = task->hdr; 657052d0144SMike Christie struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr; 6584f704dc0SMike Christie uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 659052d0144SMike Christie 660052d0144SMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 661052d0144SMike Christie return -ENOTCONN; 662052d0144SMike Christie 6634f704dc0SMike Christie if (opcode != ISCSI_OP_LOGIN && opcode != ISCSI_OP_TEXT) 664052d0144SMike Christie nop->exp_statsn = cpu_to_be32(conn->exp_statsn); 665052d0144SMike Christie /* 666052d0144SMike Christie * pre-format CmdSN for outgoing PDU. 667052d0144SMike Christie */ 668052d0144SMike Christie nop->cmdsn = cpu_to_be32(session->cmdsn); 669052d0144SMike Christie if (hdr->itt != RESERVED_ITT) { 670052d0144SMike Christie /* 6714f704dc0SMike Christie * TODO: We always use immediate for normal session pdus. 672052d0144SMike Christie * If we start to send tmfs or nops as non-immediate then 673052d0144SMike Christie * we should start checking the cmdsn numbers for mgmt tasks. 6744f704dc0SMike Christie * 6754f704dc0SMike Christie * During discovery sessions iscsid sends TEXT as non immediate, 6764f704dc0SMike Christie * but we always only send one PDU at a time. 677052d0144SMike Christie */ 678052d0144SMike Christie if (conn->c_stage == ISCSI_CONN_STARTED && 679052d0144SMike Christie !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 680052d0144SMike Christie session->queued_cmdsn++; 681052d0144SMike Christie session->cmdsn++; 682052d0144SMike Christie } 683052d0144SMike Christie } 684052d0144SMike Christie 685ae15f801SMike Christie if (session->tt->init_task && session->tt->init_task(task)) 686ae15f801SMike Christie return -EIO; 687052d0144SMike Christie 688052d0144SMike Christie if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT) 689052d0144SMike Christie session->state = ISCSI_STATE_LOGGING_OUT; 690052d0144SMike Christie 691577577daSMike Christie task->state = ISCSI_TASK_RUNNING; 6921b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "mgmtpdu [op 0x%x hdr->itt 0x%x " 6931b2c7af8SMike Christie "datalen %d]\n", hdr->opcode & ISCSI_OPCODE_MASK, 6941b2c7af8SMike Christie hdr->itt, task->data_count); 695052d0144SMike Christie return 0; 696052d0144SMike Christie } 697052d0144SMike Christie 6989c19a7d0SMike Christie static struct iscsi_task * 699f6d5180cSMike Christie __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 700f6d5180cSMike Christie char *data, uint32_t data_size) 701f6d5180cSMike Christie { 702f6d5180cSMike Christie struct iscsi_session *session = conn->session; 7031336aed1SMike Christie struct iscsi_host *ihost = shost_priv(session->host); 7044f704dc0SMike Christie uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 7059c19a7d0SMike Christie struct iscsi_task *task; 706262ef636SMike Christie itt_t itt; 707f6d5180cSMike Christie 70844ac9710SMike Christie if (session->state == ISCSI_STATE_TERMINATE || 70944ac9710SMike Christie !test_bit(ISCSI_CONN_FLAG_BOUND, &conn->flags)) 710f6d5180cSMike Christie return NULL; 711f6d5180cSMike Christie 7124f704dc0SMike Christie if (opcode == ISCSI_OP_LOGIN || opcode == ISCSI_OP_TEXT) { 713f6d5180cSMike Christie /* 714f6d5180cSMike Christie * Login and Text are sent serially, in 715f6d5180cSMike Christie * request-followed-by-response sequence. 7163e5c28adSMike Christie * Same task can be used. Same ITT must be used. 7173e5c28adSMike Christie * Note that login_task is preallocated at conn_create(). 718f6d5180cSMike Christie */ 7194f704dc0SMike Christie if (conn->login_task->state != ISCSI_TASK_FREE) { 7204f704dc0SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Login/Text in " 7214f704dc0SMike Christie "progress. Cannot start new task.\n"); 7224f704dc0SMike Christie return NULL; 7234f704dc0SMike Christie } 7244f704dc0SMike Christie 725cbaa4221SMike Christie if (data_size > ISCSI_DEF_MAX_RECV_SEG_LEN) { 726cbaa4221SMike 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); 727cbaa4221SMike Christie return NULL; 728cbaa4221SMike Christie } 729cbaa4221SMike Christie 7309c19a7d0SMike Christie task = conn->login_task; 7314f704dc0SMike Christie } else { 73226013ad4SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 73326013ad4SMike Christie return NULL; 73426013ad4SMike Christie 735cbaa4221SMike Christie if (data_size != 0) { 736cbaa4221SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Can not send data buffer of len %u for op 0x%x\n", data_size, opcode); 737cbaa4221SMike Christie return NULL; 738cbaa4221SMike Christie } 739cbaa4221SMike Christie 740f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE); 741f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED); 742f6d5180cSMike Christie 7437acd72ebSStefani Seibold if (!kfifo_out(&session->cmdpool.queue, 7449c19a7d0SMike Christie (void*)&task, sizeof(void*))) 745f6d5180cSMike Christie return NULL; 746f6d5180cSMike Christie } 7473e5c28adSMike Christie /* 7483e5c28adSMike Christie * released in complete pdu for task we expect a response for, and 7493e5c28adSMike Christie * released by the lld when it has transmitted the task for 7503e5c28adSMike Christie * pdus we do not expect a response for. 7513e5c28adSMike Christie */ 7526dc618cdSElena Reshetova refcount_set(&task->refcount, 1); 7539c19a7d0SMike Christie task->conn = conn; 7549c19a7d0SMike Christie task->sc = NULL; 7553bbaaad9SMike Christie INIT_LIST_HEAD(&task->running); 7563bbaaad9SMike Christie task->state = ISCSI_TASK_PENDING; 757f6d5180cSMike Christie 758f6d5180cSMike Christie if (data_size) { 7599c19a7d0SMike Christie memcpy(task->data, data, data_size); 7609c19a7d0SMike Christie task->data_count = data_size; 761f6d5180cSMike Christie } else 7629c19a7d0SMike Christie task->data_count = 0; 763f6d5180cSMike Christie 764184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 7652ff79d52SMike Christie if (conn->session->tt->alloc_pdu(task, hdr->opcode)) { 766577577daSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not allocate " 767577577daSMike Christie "pdu for mgmt task.\n"); 7683bbaaad9SMike Christie goto free_task; 769577577daSMike Christie } 770184b57c6SMike Christie } 771184b57c6SMike Christie 772262ef636SMike Christie itt = task->hdr->itt; 773577577daSMike Christie task->hdr_len = sizeof(struct iscsi_hdr); 7749c19a7d0SMike Christie memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr)); 775262ef636SMike Christie 776262ef636SMike Christie if (hdr->itt != RESERVED_ITT) { 777262ef636SMike Christie if (session->tt->parse_pdu_itt) 778262ef636SMike Christie task->hdr->itt = itt; 779262ef636SMike Christie else 780262ef636SMike Christie task->hdr->itt = build_itt(task->itt, 781262ef636SMike Christie task->conn->session->age); 782262ef636SMike Christie } 783262ef636SMike Christie 784fe0a8a95SLee Duncan if (unlikely(READ_ONCE(conn->ping_task) == INVALID_SCSI_TASK)) 785fe0a8a95SLee Duncan WRITE_ONCE(conn->ping_task, task); 786fe0a8a95SLee Duncan 7871336aed1SMike Christie if (!ihost->workq) { 788577577daSMike Christie if (iscsi_prep_mgmt_task(conn, task)) 789577577daSMike Christie goto free_task; 790052d0144SMike Christie 7919c19a7d0SMike Christie if (session->tt->xmit_task(task)) 792577577daSMike Christie goto free_task; 7933bbaaad9SMike Christie } else { 7943bbaaad9SMike Christie list_add_tail(&task->running, &conn->mgmtqueue); 7954b9f8ce4SMike Christie iscsi_conn_queue_xmit(conn); 7963bbaaad9SMike Christie } 797052d0144SMike Christie 7989c19a7d0SMike Christie return task; 799577577daSMike Christie 800577577daSMike Christie free_task: 801659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 8024fa50799SJitendra Bhivare spin_lock(&session->back_lock); 803577577daSMike Christie __iscsi_put_task(task); 8044fa50799SJitendra Bhivare spin_unlock(&session->back_lock); 805577577daSMike Christie return NULL; 806f6d5180cSMike Christie } 807f6d5180cSMike Christie 808f6d5180cSMike Christie int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr, 809f6d5180cSMike Christie char *data, uint32_t data_size) 810f6d5180cSMike Christie { 811f6d5180cSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 812f6d5180cSMike Christie struct iscsi_session *session = conn->session; 813f6d5180cSMike Christie int err = 0; 814f6d5180cSMike Christie 815659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 816f6d5180cSMike Christie if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size)) 817f6d5180cSMike Christie err = -EPERM; 818659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 819f6d5180cSMike Christie return err; 820f6d5180cSMike Christie } 821f6d5180cSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu); 822f6d5180cSMike Christie 8237996a778SMike Christie /** 824ae6b4e69SMauro Carvalho Chehab * iscsi_scsi_cmd_rsp - SCSI Command Response processing 8257996a778SMike Christie * @conn: iscsi connection 8267996a778SMike Christie * @hdr: iscsi header 8279c19a7d0SMike Christie * @task: scsi command task 8287996a778SMike Christie * @data: cmd data buffer 8297996a778SMike Christie * @datalen: len of buffer 8307996a778SMike Christie * 8317996a778SMike Christie * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and 832a656183eSLee Duncan * then completes the command and task. called under back_lock 8337996a778SMike Christie **/ 83477a23c21SMike Christie static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 8359c19a7d0SMike Christie struct iscsi_task *task, char *data, 8367996a778SMike Christie int datalen) 8377996a778SMike Christie { 83812352183SNicholas Bellinger struct iscsi_scsi_rsp *rhdr = (struct iscsi_scsi_rsp *)hdr; 8397996a778SMike Christie struct iscsi_session *session = conn->session; 8409c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 8417996a778SMike Christie 84277a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr); 8437996a778SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 8447996a778SMike Christie 8457996a778SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 8467996a778SMike Christie 84755e51edaSSagi Grimberg if (task->protected) { 84855e51edaSSagi Grimberg sector_t sector; 84955e51edaSSagi Grimberg u8 ascq; 85055e51edaSSagi Grimberg 85155e51edaSSagi Grimberg /** 85255e51edaSSagi Grimberg * Transports that didn't implement check_protection 85355e51edaSSagi Grimberg * callback but still published T10-PI support to scsi-mid 85455e51edaSSagi Grimberg * deserve this BUG_ON. 85555e51edaSSagi Grimberg **/ 85655e51edaSSagi Grimberg BUG_ON(!session->tt->check_protection); 85755e51edaSSagi Grimberg 85855e51edaSSagi Grimberg ascq = session->tt->check_protection(task, §or); 85955e51edaSSagi Grimberg if (ascq) { 860f2b1e9c6SHannes Reinecke scsi_build_sense(sc, 1, ILLEGAL_REQUEST, 0x10, ascq); 861a73c2a2fSSagi Grimberg scsi_set_sense_information(sc->sense_buffer, 862a73c2a2fSSagi Grimberg SCSI_SENSE_BUFFERSIZE, 863a73c2a2fSSagi Grimberg sector); 86455e51edaSSagi Grimberg goto out; 86555e51edaSSagi Grimberg } 86655e51edaSSagi Grimberg } 86755e51edaSSagi Grimberg 8687996a778SMike Christie if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) { 8697996a778SMike Christie sc->result = DID_ERROR << 16; 8707996a778SMike Christie goto out; 8717996a778SMike Christie } 8727996a778SMike Christie 8737996a778SMike Christie if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) { 8749b80cb4bSMike Christie uint16_t senselen; 8757996a778SMike Christie 8767996a778SMike Christie if (datalen < 2) { 8777996a778SMike Christie invalid_datalen: 878322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 879322d739dSMike Christie "Got CHECK_CONDITION but invalid data " 880322d739dSMike Christie "buffer size of %d\n", datalen); 8817996a778SMike Christie sc->result = DID_BAD_TARGET << 16; 8827996a778SMike Christie goto out; 8837996a778SMike Christie } 8847996a778SMike Christie 8858f333991SHarvey Harrison senselen = get_unaligned_be16(data); 8867996a778SMike Christie if (datalen < senselen) 8877996a778SMike Christie goto invalid_datalen; 8887996a778SMike Christie 8897996a778SMike Christie memcpy(sc->sense_buffer, data + 2, 8909b80cb4bSMike Christie min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 8911b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n", 8921b2c7af8SMike Christie min_t(uint16_t, senselen, 8931b2c7af8SMike Christie SCSI_SENSE_BUFFERSIZE)); 8947996a778SMike Christie } 8957996a778SMike Christie 896c07d4444SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW | 897c07d4444SBoaz Harrosh ISCSI_FLAG_CMD_BIDI_OVERFLOW)) { 898c07d4444SBoaz Harrosh sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 899c07d4444SBoaz Harrosh } 900c07d4444SBoaz Harrosh 9017207fea4SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW | 9027207fea4SBoaz Harrosh ISCSI_FLAG_CMD_OVERFLOW)) { 9037996a778SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 9047996a778SMike Christie 9057207fea4SBoaz Harrosh if (res_count > 0 && 9067207fea4SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 9077207fea4SBoaz Harrosh res_count <= scsi_bufflen(sc))) 908c07d4444SBoaz Harrosh /* write side for bidi or uni-io set_resid */ 9091c138991SFUJITA Tomonori scsi_set_resid(sc, res_count); 9107996a778SMike Christie else 9117996a778SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 912c07d4444SBoaz Harrosh } 9137996a778SMike Christie out: 9143bbaaad9SMike Christie ISCSI_DBG_SESSION(session, "cmd rsp done [sc %p res %d itt 0x%x]\n", 9151b2c7af8SMike Christie sc, sc->result, task->itt); 9167996a778SMike Christie conn->scsirsp_pdus_cnt++; 917b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 9187996a778SMike Christie } 9197996a778SMike Christie 9201d9edf02SMike Christie /** 9211d9edf02SMike Christie * iscsi_data_in_rsp - SCSI Data-In Response processing 9221d9edf02SMike Christie * @conn: iscsi connection 9231d9edf02SMike Christie * @hdr: iscsi pdu 9241d9edf02SMike Christie * @task: scsi command task 925a656183eSLee Duncan * 926a656183eSLee Duncan * iscsi_data_in_rsp sets up the scsi_cmnd fields based on the data received 927a656183eSLee Duncan * then completes the command and task. called under back_lock 9281d9edf02SMike Christie **/ 9291d9edf02SMike Christie static void 9301d9edf02SMike Christie iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 9311d9edf02SMike Christie struct iscsi_task *task) 9321d9edf02SMike Christie { 9331d9edf02SMike Christie struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr; 9341d9edf02SMike Christie struct scsi_cmnd *sc = task->sc; 9351d9edf02SMike Christie 9361d9edf02SMike Christie if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS)) 9371d9edf02SMike Christie return; 9381d9edf02SMike Christie 939edbc9aa0SMike Christie iscsi_update_cmdsn(conn->session, (struct iscsi_nopin *)hdr); 9401d9edf02SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 9411d9edf02SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 9421d9edf02SMike Christie if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW | 9431d9edf02SMike Christie ISCSI_FLAG_DATA_OVERFLOW)) { 9441d9edf02SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 9451d9edf02SMike Christie 9461d9edf02SMike Christie if (res_count > 0 && 9471d9edf02SMike Christie (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 948ae3d56d8SChristoph Hellwig res_count <= sc->sdb.length)) 949960bf87aSBart Van Assche scsi_set_resid(sc, res_count); 9501d9edf02SMike Christie else 9511d9edf02SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 9521d9edf02SMike Christie } 9531d9edf02SMike Christie 9543bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, "data in with status done " 9553bbaaad9SMike Christie "[sc %p res %d itt 0x%x]\n", 9563bbaaad9SMike Christie sc, sc->result, task->itt); 9571d9edf02SMike Christie conn->scsirsp_pdus_cnt++; 958b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 9591d9edf02SMike Christie } 9601d9edf02SMike Christie 9617ea8b828SMike Christie static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) 9627ea8b828SMike Christie { 9637ea8b828SMike Christie struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; 964ec29d0acSMike Christie struct iscsi_session *session = conn->session; 9657ea8b828SMike Christie 9667ea8b828SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 9677ea8b828SMike Christie conn->tmfrsp_pdus_cnt++; 9687ea8b828SMike Christie 969ec29d0acSMike Christie if (session->tmf_state != TMF_QUEUED) 9707ea8b828SMike Christie return; 9717ea8b828SMike Christie 9727ea8b828SMike Christie if (tmf->response == ISCSI_TMF_RSP_COMPLETE) 973ec29d0acSMike Christie session->tmf_state = TMF_SUCCESS; 9747ea8b828SMike Christie else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) 975ec29d0acSMike Christie session->tmf_state = TMF_NOT_FOUND; 9767ea8b828SMike Christie else 977ec29d0acSMike Christie session->tmf_state = TMF_FAILED; 978ec29d0acSMike Christie wake_up(&session->ehwait); 9797ea8b828SMike Christie } 9807ea8b828SMike Christie 98152f5664aSAriel Nahum static int iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) 982f6d5180cSMike Christie { 983f6d5180cSMike Christie struct iscsi_nopout hdr; 9849c19a7d0SMike Christie struct iscsi_task *task; 985f6d5180cSMike Christie 986fe0a8a95SLee Duncan if (!rhdr) { 987fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task)) 98852f5664aSAriel Nahum return -EINVAL; 989fe0a8a95SLee Duncan WRITE_ONCE(conn->ping_task, INVALID_SCSI_TASK); 990fe0a8a95SLee Duncan } 991f6d5180cSMike Christie 992f6d5180cSMike Christie memset(&hdr, 0, sizeof(struct iscsi_nopout)); 993f6d5180cSMike Christie hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE; 994f6d5180cSMike Christie hdr.flags = ISCSI_FLAG_CMD_FINAL; 995f6d5180cSMike Christie 996f6d5180cSMike Christie if (rhdr) { 99755bdabdfSAndy Grover hdr.lun = rhdr->lun; 998f6d5180cSMike Christie hdr.ttt = rhdr->ttt; 999f6d5180cSMike Christie hdr.itt = RESERVED_ITT; 1000f6d5180cSMike Christie } else 1001f6d5180cSMike Christie hdr.ttt = RESERVED_ITT; 1002f6d5180cSMike Christie 10039c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0); 100452f5664aSAriel Nahum if (!task) { 1005fe0a8a95SLee Duncan if (!rhdr) 1006fe0a8a95SLee Duncan WRITE_ONCE(conn->ping_task, NULL); 1007322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n"); 100852f5664aSAriel Nahum return -EIO; 100952f5664aSAriel Nahum } else if (!rhdr) { 1010d3acf022SMike Christie /* only track our nops */ 1011d3acf022SMike Christie conn->last_ping = jiffies; 1012d3acf022SMike Christie } 101352f5664aSAriel Nahum 101452f5664aSAriel Nahum return 0; 1015f6d5180cSMike Christie } 1016f6d5180cSMike Christie 1017a656183eSLee Duncan /** 1018a656183eSLee Duncan * iscsi_nop_out_rsp - SCSI NOP Response processing 1019a656183eSLee Duncan * @task: scsi command task 1020a656183eSLee Duncan * @nop: the nop structure 1021a656183eSLee Duncan * @data: where to put the data 1022a656183eSLee Duncan * @datalen: length of data 1023a656183eSLee Duncan * 1024a656183eSLee Duncan * iscsi_nop_out_rsp handles nop response from use or 1025a656183eSLee Duncan * from user space. called under back_lock 1026a656183eSLee Duncan **/ 10278afa1439SMike Christie static int iscsi_nop_out_rsp(struct iscsi_task *task, 10288afa1439SMike Christie struct iscsi_nopin *nop, char *data, int datalen) 10298afa1439SMike Christie { 10308afa1439SMike Christie struct iscsi_conn *conn = task->conn; 10318afa1439SMike Christie int rc = 0; 10328afa1439SMike Christie 1033fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task) != task) { 10348afa1439SMike Christie /* 10358afa1439SMike Christie * If this is not in response to one of our 10368afa1439SMike Christie * nops then it must be from userspace. 10378afa1439SMike Christie */ 10388afa1439SMike Christie if (iscsi_recv_pdu(conn->cls_conn, (struct iscsi_hdr *)nop, 10398afa1439SMike Christie data, datalen)) 10408afa1439SMike Christie rc = ISCSI_ERR_CONN_FAILED; 10418afa1439SMike Christie } else 10428afa1439SMike Christie mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout); 10438afa1439SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 10448afa1439SMike Christie return rc; 10458afa1439SMike Christie } 10468afa1439SMike Christie 104762f38300SMike Christie static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 104862f38300SMike Christie char *data, int datalen) 104962f38300SMike Christie { 105062f38300SMike Christie struct iscsi_reject *reject = (struct iscsi_reject *)hdr; 105162f38300SMike Christie struct iscsi_hdr rejected_pdu; 10528afa1439SMike Christie int opcode, rc = 0; 105362f38300SMike Christie 105462f38300SMike Christie conn->exp_statsn = be32_to_cpu(reject->statsn) + 1; 105562f38300SMike Christie 10568afa1439SMike Christie if (ntoh24(reject->dlength) > datalen || 10578afa1439SMike Christie ntoh24(reject->dlength) < sizeof(struct iscsi_hdr)) { 10588afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Cannot handle rejected " 10598afa1439SMike Christie "pdu. Invalid data length (pdu dlength " 10608afa1439SMike Christie "%u, datalen %d\n", ntoh24(reject->dlength), 10618afa1439SMike Christie datalen); 106262f38300SMike Christie return ISCSI_ERR_PROTO; 10638afa1439SMike Christie } 106462f38300SMike Christie memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr)); 10658afa1439SMike Christie opcode = rejected_pdu.opcode & ISCSI_OPCODE_MASK; 10668afa1439SMike Christie 10678afa1439SMike Christie switch (reject->reason) { 10688afa1439SMike Christie case ISCSI_REASON_DATA_DIGEST_ERROR: 1069322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 10708afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected " 1071262ef636SMike Christie "due to DataDigest error.\n", 1072e5dbbe27SVaughan Cao opcode, rejected_pdu.itt); 10738afa1439SMike Christie break; 10748afa1439SMike Christie case ISCSI_REASON_IMM_CMD_REJECT: 10758afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 10768afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Too many " 10778afa1439SMike Christie "immediate commands.\n", 1078e5dbbe27SVaughan Cao opcode, rejected_pdu.itt); 10798afa1439SMike Christie /* 10808afa1439SMike Christie * We only send one TMF at a time so if the target could not 10818afa1439SMike Christie * handle it, then it should get fixed (RFC mandates that 10828afa1439SMike Christie * a target can handle one immediate TMF per conn). 10838afa1439SMike Christie * 10848afa1439SMike Christie * For nops-outs, we could have sent more than one if 10858afa1439SMike Christie * the target is sending us lots of nop-ins 10868afa1439SMike Christie */ 10878afa1439SMike Christie if (opcode != ISCSI_OP_NOOP_OUT) 108862f38300SMike Christie return 0; 10898afa1439SMike Christie 1090659743b0SShlomo Pongratz if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG)) { 10918afa1439SMike Christie /* 10928afa1439SMike Christie * nop-out in response to target's nop-out rejected. 10938afa1439SMike Christie * Just resend. 10948afa1439SMike Christie */ 1095659743b0SShlomo Pongratz /* In RX path we are under back lock */ 1096659743b0SShlomo Pongratz spin_unlock(&conn->session->back_lock); 1097659743b0SShlomo Pongratz spin_lock(&conn->session->frwd_lock); 10988afa1439SMike Christie iscsi_send_nopout(conn, 10998afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu); 1100659743b0SShlomo Pongratz spin_unlock(&conn->session->frwd_lock); 1101659743b0SShlomo Pongratz spin_lock(&conn->session->back_lock); 1102659743b0SShlomo Pongratz } else { 11038afa1439SMike Christie struct iscsi_task *task; 11048afa1439SMike Christie /* 11058afa1439SMike Christie * Our nop as ping got dropped. We know the target 11068afa1439SMike Christie * and transport are ok so just clean up 11078afa1439SMike Christie */ 11088afa1439SMike Christie task = iscsi_itt_to_task(conn, rejected_pdu.itt); 11098afa1439SMike Christie if (!task) { 11108afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 11118afa1439SMike Christie "Invalid pdu reject. Could " 11128afa1439SMike Christie "not lookup rejected task.\n"); 11138afa1439SMike Christie rc = ISCSI_ERR_BAD_ITT; 11148afa1439SMike Christie } else 11158afa1439SMike Christie rc = iscsi_nop_out_rsp(task, 11168afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu, 11178afa1439SMike Christie NULL, 0); 11188afa1439SMike Christie } 11198afa1439SMike Christie break; 11208afa1439SMike Christie default: 11218afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 11228afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Reason " 1123e5dbbe27SVaughan Cao "code 0x%x\n", rejected_pdu.opcode, 1124e5dbbe27SVaughan Cao rejected_pdu.itt, reject->reason); 11258afa1439SMike Christie break; 11268afa1439SMike Christie } 11278afa1439SMike Christie return rc; 112862f38300SMike Christie } 112962f38300SMike Christie 11307996a778SMike Christie /** 1131913e5bf4SMike Christie * iscsi_itt_to_task - look up task by itt 1132913e5bf4SMike Christie * @conn: iscsi connection 1133913e5bf4SMike Christie * @itt: itt 1134913e5bf4SMike Christie * 1135913e5bf4SMike Christie * This should be used for mgmt tasks like login and nops, or if 1136913e5bf4SMike Christie * the LDD's itt space does not include the session age. 1137913e5bf4SMike Christie * 1138659743b0SShlomo Pongratz * The session back_lock must be held. 1139913e5bf4SMike Christie */ 11408f9256ceSMike Christie struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt) 1141913e5bf4SMike Christie { 1142913e5bf4SMike Christie struct iscsi_session *session = conn->session; 1143262ef636SMike Christie int i; 1144913e5bf4SMike Christie 1145913e5bf4SMike Christie if (itt == RESERVED_ITT) 1146913e5bf4SMike Christie return NULL; 1147913e5bf4SMike Christie 1148262ef636SMike Christie if (session->tt->parse_pdu_itt) 1149262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, NULL); 1150262ef636SMike Christie else 1151913e5bf4SMike Christie i = get_itt(itt); 1152913e5bf4SMike Christie if (i >= session->cmds_max) 1153913e5bf4SMike Christie return NULL; 1154913e5bf4SMike Christie 1155913e5bf4SMike Christie return session->cmds[i]; 1156913e5bf4SMike Christie } 11578f9256ceSMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_task); 1158913e5bf4SMike Christie 1159913e5bf4SMike Christie /** 11607996a778SMike Christie * __iscsi_complete_pdu - complete pdu 11617996a778SMike Christie * @conn: iscsi conn 11627996a778SMike Christie * @hdr: iscsi header 11637996a778SMike Christie * @data: data buffer 11647996a778SMike Christie * @datalen: len of data buffer 11657996a778SMike Christie * 11667996a778SMike Christie * Completes pdu processing by freeing any resources allocated at 1167659743b0SShlomo Pongratz * queuecommand or send generic. session back_lock must be held and verify 11687996a778SMike Christie * itt must have been called. 11697996a778SMike Christie */ 1170913e5bf4SMike Christie int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 11717996a778SMike Christie char *data, int datalen) 11727996a778SMike Christie { 11737996a778SMike Christie struct iscsi_session *session = conn->session; 11747996a778SMike Christie int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0; 11759c19a7d0SMike Christie struct iscsi_task *task; 11767996a778SMike Christie uint32_t itt; 11777996a778SMike Christie 1178f6d5180cSMike Christie conn->last_recv = jiffies; 11790af967f5SMike Christie rc = iscsi_verify_itt(conn, hdr->itt); 11800af967f5SMike Christie if (rc) 11810af967f5SMike Christie return rc; 11820af967f5SMike Christie 1183b4377356SAl Viro if (hdr->itt != RESERVED_ITT) 1184b4377356SAl Viro itt = get_itt(hdr->itt); 11857996a778SMike Christie else 1186b4377356SAl Viro itt = ~0U; 11877996a778SMike Christie 11881b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "[op 0x%x cid %d itt 0x%x len %d]\n", 11893e5c28adSMike Christie opcode, conn->id, itt, datalen); 11907996a778SMike Christie 11913e5c28adSMike Christie if (itt == ~0U) { 119277a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 119362f38300SMike Christie 11947996a778SMike Christie switch(opcode) { 11957996a778SMike Christie case ISCSI_OP_NOOP_IN: 119640527afeSMike Christie if (datalen) { 119740527afeSMike Christie rc = ISCSI_ERR_PROTO; 119840527afeSMike Christie break; 119940527afeSMike Christie } 120040527afeSMike Christie 1201b4377356SAl Viro if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) 120240527afeSMike Christie break; 120340527afeSMike Christie 1204659743b0SShlomo Pongratz /* In RX path we are under back lock */ 1205659743b0SShlomo Pongratz spin_unlock(&session->back_lock); 1206659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 1207f6d5180cSMike Christie iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr); 1208659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 1209659743b0SShlomo Pongratz spin_lock(&session->back_lock); 12107996a778SMike Christie break; 12117996a778SMike Christie case ISCSI_OP_REJECT: 121262f38300SMike Christie rc = iscsi_handle_reject(conn, hdr, data, datalen); 121362f38300SMike Christie break; 12147996a778SMike Christie case ISCSI_OP_ASYNC_EVENT: 12158d2860b3SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 12165831c737SMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 12175831c737SMike Christie rc = ISCSI_ERR_CONN_FAILED; 12187996a778SMike Christie break; 12197996a778SMike Christie default: 12207996a778SMike Christie rc = ISCSI_ERR_BAD_OPCODE; 12217996a778SMike Christie break; 12227996a778SMike Christie } 12233e5c28adSMike Christie goto out; 12243e5c28adSMike Christie } 12257996a778SMike Christie 12263e5c28adSMike Christie switch(opcode) { 12273e5c28adSMike Christie case ISCSI_OP_SCSI_CMD_RSP: 1228913e5bf4SMike Christie case ISCSI_OP_SCSI_DATA_IN: 1229913e5bf4SMike Christie task = iscsi_itt_to_ctask(conn, hdr->itt); 1230913e5bf4SMike Christie if (!task) 1231913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1232d355e57dSMike Christie task->last_xfer = jiffies; 12333e5c28adSMike Christie break; 1234913e5bf4SMike Christie case ISCSI_OP_R2T: 1235913e5bf4SMike Christie /* 1236913e5bf4SMike Christie * LLD handles R2Ts if they need to. 1237913e5bf4SMike Christie */ 1238913e5bf4SMike Christie return 0; 1239913e5bf4SMike Christie case ISCSI_OP_LOGOUT_RSP: 1240913e5bf4SMike Christie case ISCSI_OP_LOGIN_RSP: 1241913e5bf4SMike Christie case ISCSI_OP_TEXT_RSP: 1242913e5bf4SMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 1243913e5bf4SMike Christie case ISCSI_OP_NOOP_IN: 1244913e5bf4SMike Christie task = iscsi_itt_to_task(conn, hdr->itt); 1245913e5bf4SMike Christie if (!task) 1246913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1247913e5bf4SMike Christie break; 1248913e5bf4SMike Christie default: 1249913e5bf4SMike Christie return ISCSI_ERR_BAD_OPCODE; 12503e5c28adSMike Christie } 1251913e5bf4SMike Christie 1252913e5bf4SMike Christie switch(opcode) { 1253913e5bf4SMike Christie case ISCSI_OP_SCSI_CMD_RSP: 12549c19a7d0SMike Christie iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen); 12553e5c28adSMike Christie break; 12563e5c28adSMike Christie case ISCSI_OP_SCSI_DATA_IN: 12571d9edf02SMike Christie iscsi_data_in_rsp(conn, hdr, task); 12583e5c28adSMike Christie break; 12593e5c28adSMike Christie case ISCSI_OP_LOGOUT_RSP: 12603e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12613e5c28adSMike Christie if (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 goto recv_pdu; 12673e5c28adSMike Christie case ISCSI_OP_LOGIN_RSP: 12683e5c28adSMike Christie case ISCSI_OP_TEXT_RSP: 12693e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12703e5c28adSMike Christie /* 12713e5c28adSMike Christie * login related PDU's exp_statsn is handled in 12723e5c28adSMike Christie * userspace 12733e5c28adSMike Christie */ 12743e5c28adSMike Christie goto recv_pdu; 12753e5c28adSMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 12763e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12773e5c28adSMike Christie if (datalen) { 12783e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12793e5c28adSMike Christie break; 12803e5c28adSMike Christie } 12813e5c28adSMike Christie 12823e5c28adSMike Christie iscsi_tmf_rsp(conn, hdr); 1283b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 12843e5c28adSMike Christie break; 12853e5c28adSMike Christie case ISCSI_OP_NOOP_IN: 12863e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12873e5c28adSMike Christie if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) { 12883e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12893e5c28adSMike Christie break; 12903e5c28adSMike Christie } 12913e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 12923e5c28adSMike Christie 12938afa1439SMike Christie rc = iscsi_nop_out_rsp(task, (struct iscsi_nopin*)hdr, 12948afa1439SMike Christie data, datalen); 12953e5c28adSMike Christie break; 12963e5c28adSMike Christie default: 12973e5c28adSMike Christie rc = ISCSI_ERR_BAD_OPCODE; 12983e5c28adSMike Christie break; 12993e5c28adSMike Christie } 13003e5c28adSMike Christie 13013e5c28adSMike Christie out: 13023e5c28adSMike Christie return rc; 13033e5c28adSMike Christie recv_pdu: 13043e5c28adSMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 13053e5c28adSMike Christie rc = ISCSI_ERR_CONN_FAILED; 1306b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 13077996a778SMike Christie return rc; 13087996a778SMike Christie } 1309913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_complete_pdu); 13107996a778SMike Christie 13117996a778SMike Christie int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 13127996a778SMike Christie char *data, int datalen) 13137996a778SMike Christie { 13147996a778SMike Christie int rc; 13157996a778SMike Christie 1316659743b0SShlomo Pongratz spin_lock(&conn->session->back_lock); 13177996a778SMike Christie rc = __iscsi_complete_pdu(conn, hdr, data, datalen); 1318659743b0SShlomo Pongratz spin_unlock(&conn->session->back_lock); 13197996a778SMike Christie return rc; 13207996a778SMike Christie } 13217996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_pdu); 13227996a778SMike Christie 13230af967f5SMike Christie int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt) 13247996a778SMike Christie { 13257996a778SMike Christie struct iscsi_session *session = conn->session; 1326262ef636SMike Christie int age = 0, i = 0; 13277996a778SMike Christie 13280af967f5SMike Christie if (itt == RESERVED_ITT) 13290af967f5SMike Christie return 0; 13300af967f5SMike Christie 1331262ef636SMike Christie if (session->tt->parse_pdu_itt) 1332262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, &age); 1333262ef636SMike Christie else { 1334262ef636SMike Christie i = get_itt(itt); 1335262ef636SMike Christie age = ((__force u32)itt >> ISCSI_AGE_SHIFT) & ISCSI_AGE_MASK; 1336262ef636SMike Christie } 1337262ef636SMike Christie 1338262ef636SMike Christie if (age != session->age) { 1339322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 13400af967f5SMike Christie "received itt %x expected session age (%x)\n", 1341913e5bf4SMike Christie (__force u32)itt, session->age); 13427996a778SMike Christie return ISCSI_ERR_BAD_ITT; 13437996a778SMike Christie } 13447996a778SMike Christie 13453e5c28adSMike Christie if (i >= session->cmds_max) { 13463e5c28adSMike Christie iscsi_conn_printk(KERN_ERR, conn, 13473e5c28adSMike Christie "received invalid itt index %u (max cmds " 13483e5c28adSMike Christie "%u.\n", i, session->cmds_max); 13493e5c28adSMike Christie return ISCSI_ERR_BAD_ITT; 13507996a778SMike Christie } 13517996a778SMike Christie return 0; 13527996a778SMike Christie } 13537996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_verify_itt); 13547996a778SMike Christie 1355913e5bf4SMike Christie /** 1356913e5bf4SMike Christie * iscsi_itt_to_ctask - look up ctask by itt 1357913e5bf4SMike Christie * @conn: iscsi connection 1358913e5bf4SMike Christie * @itt: itt 1359913e5bf4SMike Christie * 1360913e5bf4SMike Christie * This should be used for cmd tasks. 1361913e5bf4SMike Christie * 1362659743b0SShlomo Pongratz * The session back_lock must be held. 1363913e5bf4SMike Christie */ 1364913e5bf4SMike Christie struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt) 13650af967f5SMike Christie { 13669c19a7d0SMike Christie struct iscsi_task *task; 13670af967f5SMike Christie 13680af967f5SMike Christie if (iscsi_verify_itt(conn, itt)) 13690af967f5SMike Christie return NULL; 13700af967f5SMike Christie 1371913e5bf4SMike Christie task = iscsi_itt_to_task(conn, itt); 1372913e5bf4SMike Christie if (!task || !task->sc) 13730af967f5SMike Christie return NULL; 13740af967f5SMike Christie 1375db22de3eSBart Van Assche if (iscsi_cmd(task->sc)->age != conn->session->age) { 1376913e5bf4SMike Christie iscsi_session_printk(KERN_ERR, conn->session, 1377913e5bf4SMike Christie "task's session age %d, expected %d\n", 1378db22de3eSBart Van Assche iscsi_cmd(task->sc)->age, conn->session->age); 13790af967f5SMike Christie return NULL; 1380913e5bf4SMike Christie } 13810af967f5SMike Christie 13829c19a7d0SMike Christie return task; 13830af967f5SMike Christie } 13840af967f5SMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask); 13850af967f5SMike Christie 138640a06e75SMike Christie void iscsi_session_failure(struct iscsi_session *session, 1387e5bd7b54SMike Christie enum iscsi_err err) 1388e5bd7b54SMike Christie { 1389e5bd7b54SMike Christie struct iscsi_conn *conn; 1390e5bd7b54SMike Christie 1391659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 1392e5bd7b54SMike Christie conn = session->leadconn; 1393e5bd7b54SMike Christie if (session->state == ISCSI_STATE_TERMINATE || !conn) { 1394659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1395e5bd7b54SMike Christie return; 1396e5bd7b54SMike Christie } 1397e5bd7b54SMike Christie 1398b1d19e8cSMike Christie iscsi_get_conn(conn->cls_conn); 1399659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1400e5bd7b54SMike Christie /* 1401e5bd7b54SMike Christie * if the host is being removed bypass the connection 1402e5bd7b54SMike Christie * recovery initialization because we are going to kill 1403e5bd7b54SMike Christie * the session. 1404e5bd7b54SMike Christie */ 1405e5bd7b54SMike Christie if (err == ISCSI_ERR_INVALID_HOST) 1406e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 1407e5bd7b54SMike Christie else 1408e5bd7b54SMike Christie iscsi_conn_failure(conn, err); 1409b1d19e8cSMike Christie iscsi_put_conn(conn->cls_conn); 1410e5bd7b54SMike Christie } 1411e5bd7b54SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_failure); 1412e5bd7b54SMike Christie 1413891e2639SMike Christie static bool iscsi_set_conn_failed(struct iscsi_conn *conn) 14147996a778SMike Christie { 14157996a778SMike Christie struct iscsi_session *session = conn->session; 14167996a778SMike Christie 1417891e2639SMike Christie if (session->state == ISCSI_STATE_FAILED) 1418891e2639SMike Christie return false; 1419656cffc9SMike Christie 142067a61114SMike Christie if (conn->stop_stage == 0) 14217996a778SMike Christie session->state = ISCSI_STATE_FAILED; 1422e5bd7b54SMike Christie 14235bd85625SMike Christie set_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags); 14245bd85625SMike Christie set_bit(ISCSI_CONN_FLAG_SUSPEND_RX, &conn->flags); 1425891e2639SMike Christie return true; 1426891e2639SMike Christie } 1427891e2639SMike Christie 1428891e2639SMike Christie void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err) 1429891e2639SMike Christie { 1430891e2639SMike Christie struct iscsi_session *session = conn->session; 1431891e2639SMike Christie bool needs_evt; 1432891e2639SMike Christie 1433891e2639SMike Christie spin_lock_bh(&session->frwd_lock); 1434891e2639SMike Christie needs_evt = iscsi_set_conn_failed(conn); 1435891e2639SMike Christie spin_unlock_bh(&session->frwd_lock); 1436891e2639SMike Christie 1437891e2639SMike Christie if (needs_evt) 1438e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 14397996a778SMike Christie } 14407996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_failure); 14417996a778SMike Christie 144277a23c21SMike Christie static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn) 144377a23c21SMike Christie { 144477a23c21SMike Christie struct iscsi_session *session = conn->session; 144577a23c21SMike Christie 144677a23c21SMike Christie /* 144777a23c21SMike Christie * Check for iSCSI window and take care of CmdSN wrap-around 144877a23c21SMike Christie */ 1449e0726407SMike Christie if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) { 14501b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iSCSI CmdSN closed. ExpCmdSn " 14511b2c7af8SMike Christie "%u MaxCmdSN %u CmdSN %u/%u\n", 14521b2c7af8SMike Christie session->exp_cmdsn, session->max_cmdsn, 14531b2c7af8SMike Christie session->cmdsn, session->queued_cmdsn); 145477a23c21SMike Christie return -ENOSPC; 145577a23c21SMike Christie } 145677a23c21SMike Christie return 0; 145777a23c21SMike Christie } 145877a23c21SMike Christie 14595923d64bSMike Christie static int iscsi_xmit_task(struct iscsi_conn *conn, struct iscsi_task *task, 14605923d64bSMike Christie bool was_requeue) 146177a23c21SMike Christie { 1462843c0a8aSMike Christie int rc; 146377a23c21SMike Christie 14645923d64bSMike Christie if (!conn->task) { 1465e1c6a7ecSMike Christie /* 1466e1c6a7ecSMike Christie * Take a ref so we can access it after xmit_task(). 1467e1c6a7ecSMike Christie * 1468e1c6a7ecSMike Christie * This should never fail because the failure paths will have 1469e1c6a7ecSMike Christie * stopped the xmit thread. 1470e1c6a7ecSMike Christie */ 1471e1c6a7ecSMike Christie if (!iscsi_get_task(task)) { 1472e1c6a7ecSMike Christie WARN_ON_ONCE(1); 1473e1c6a7ecSMike Christie return 0; 1474e1c6a7ecSMike Christie } 14755923d64bSMike Christie } else { 14765923d64bSMike Christie /* Already have a ref from when we failed to send it last call */ 14775923d64bSMike Christie conn->task = NULL; 14785923d64bSMike Christie } 14795923d64bSMike Christie 14805923d64bSMike Christie /* 14815923d64bSMike Christie * If this was a requeue for a R2T we have an extra ref on the task in 14825923d64bSMike Christie * case a bad target sends a cmd rsp before we have handled the task. 14835923d64bSMike Christie */ 14845923d64bSMike Christie if (was_requeue) 1485*6d626150SMike Christie iscsi_put_task(task); 14865923d64bSMike Christie 14875923d64bSMike Christie /* 14885923d64bSMike Christie * Do this after dropping the extra ref because if this was a requeue 14895923d64bSMike Christie * it's removed from that list and cleanup_queued_task would miss it. 14905923d64bSMike Christie */ 14915bd85625SMike Christie if (test_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags)) { 14925923d64bSMike Christie /* 14935923d64bSMike Christie * Save the task and ref in case we weren't cleaning up this 14945923d64bSMike Christie * task and get woken up again. 14955923d64bSMike Christie */ 14965923d64bSMike Christie conn->task = task; 149779edd00dSAnoob Soman return -ENODATA; 149879edd00dSAnoob Soman } 14995923d64bSMike Christie 1500659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 15019c19a7d0SMike Christie rc = conn->session->tt->xmit_task(task); 1502659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 1503d355e57dSMike Christie if (!rc) { 15049c19a7d0SMike Christie /* done with this task */ 1505d355e57dSMike Christie task->last_xfer = jiffies; 1506*6d626150SMike Christie } else { 15075923d64bSMike Christie /* 15085923d64bSMike Christie * get an extra ref that is released next time we access it 15095923d64bSMike Christie * as conn->task above. 15105923d64bSMike Christie */ 1511e1c6a7ecSMike Christie iscsi_get_task(task); 15125923d64bSMike Christie conn->task = task; 15135923d64bSMike Christie } 15145923d64bSMike Christie 1515*6d626150SMike Christie iscsi_put_task(task); 151677a23c21SMike Christie return rc; 151777a23c21SMike Christie } 151877a23c21SMike Christie 15197996a778SMike Christie /** 15209c19a7d0SMike Christie * iscsi_requeue_task - requeue task to run from session workqueue 15219c19a7d0SMike Christie * @task: task to requeue 1522843c0a8aSMike Christie * 15235923d64bSMike Christie * Callers must have taken a ref to the task that is going to be requeued. 1524843c0a8aSMike Christie */ 15259c19a7d0SMike Christie void iscsi_requeue_task(struct iscsi_task *task) 1526843c0a8aSMike Christie { 15279c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 1528843c0a8aSMike Christie 15293bbaaad9SMike Christie /* 15303bbaaad9SMike Christie * this may be on the requeue list already if the xmit_task callout 15313bbaaad9SMike Christie * is handling the r2ts while we are adding new ones 15323bbaaad9SMike Christie */ 15335923d64bSMike Christie spin_lock_bh(&conn->session->frwd_lock); 15345923d64bSMike Christie if (list_empty(&task->running)) { 15353bbaaad9SMike Christie list_add_tail(&task->running, &conn->requeue); 15365923d64bSMike Christie } else { 15375923d64bSMike Christie /* 15385923d64bSMike Christie * Don't need the extra ref since it's already requeued and 15395923d64bSMike Christie * has a ref. 15405923d64bSMike Christie */ 15415923d64bSMike Christie iscsi_put_task(task); 15425923d64bSMike Christie } 15434b9f8ce4SMike Christie iscsi_conn_queue_xmit(conn); 15445923d64bSMike Christie spin_unlock_bh(&conn->session->frwd_lock); 1545843c0a8aSMike Christie } 15469c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_requeue_task); 1547843c0a8aSMike Christie 1548843c0a8aSMike Christie /** 15497996a778SMike Christie * iscsi_data_xmit - xmit any command into the scheduled connection 15507996a778SMike Christie * @conn: iscsi connection 15517996a778SMike Christie * 15527996a778SMike Christie * Notes: 15537996a778SMike Christie * The function can return -EAGAIN in which case the caller must 15547996a778SMike Christie * re-schedule it again later or recover. '0' return code means 15557996a778SMike Christie * successful xmit. 15567996a778SMike Christie **/ 15577996a778SMike Christie static int iscsi_data_xmit(struct iscsi_conn *conn) 15587996a778SMike Christie { 15595d12c05eSMike Christie struct iscsi_task *task; 15603219e529SMike Christie int rc = 0; 15617996a778SMike Christie 1562659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 15635bd85625SMike Christie if (test_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags)) { 15641b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n"); 1565659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 15663219e529SMike Christie return -ENODATA; 15677996a778SMike Christie } 15687996a778SMike Christie 15699c19a7d0SMike Christie if (conn->task) { 15705923d64bSMike Christie rc = iscsi_xmit_task(conn, conn->task, false); 15713219e529SMike Christie if (rc) 157270b31c15SMike Christie goto done; 15737996a778SMike Christie } 157477a23c21SMike Christie 157577a23c21SMike Christie /* 157677a23c21SMike Christie * process mgmt pdus like nops before commands since we should 157777a23c21SMike Christie * only have one nop-out as a ping from us and targets should not 157877a23c21SMike Christie * overflow us with nop-ins 157977a23c21SMike Christie */ 158077a23c21SMike Christie check_mgmt: 1581843c0a8aSMike Christie while (!list_empty(&conn->mgmtqueue)) { 15825923d64bSMike Christie task = list_entry(conn->mgmtqueue.next, struct iscsi_task, 15835923d64bSMike Christie running); 15845923d64bSMike Christie list_del_init(&task->running); 15855923d64bSMike Christie if (iscsi_prep_mgmt_task(conn, task)) { 1586659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 1587659743b0SShlomo Pongratz spin_lock_bh(&conn->session->back_lock); 15885923d64bSMike Christie __iscsi_put_task(task); 1589659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->back_lock); 1590b3a7ea8dSMike Christie continue; 1591b3a7ea8dSMike Christie } 15925923d64bSMike Christie rc = iscsi_xmit_task(conn, task, false); 15933219e529SMike Christie if (rc) 159470b31c15SMike Christie goto done; 15957996a778SMike Christie } 15967996a778SMike Christie 159765080c51SDmitry Bogdanov check_requeue: 159865080c51SDmitry Bogdanov while (!list_empty(&conn->requeue)) { 159965080c51SDmitry Bogdanov /* 160065080c51SDmitry Bogdanov * we always do fastlogout - conn stop code will clean up. 160165080c51SDmitry Bogdanov */ 160265080c51SDmitry Bogdanov if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 160365080c51SDmitry Bogdanov break; 160465080c51SDmitry Bogdanov 160565080c51SDmitry Bogdanov task = list_entry(conn->requeue.next, struct iscsi_task, 160665080c51SDmitry Bogdanov running); 160765080c51SDmitry Bogdanov 160865080c51SDmitry Bogdanov if (iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_DATA_OUT)) 160965080c51SDmitry Bogdanov break; 161065080c51SDmitry Bogdanov 161165080c51SDmitry Bogdanov list_del_init(&task->running); 161265080c51SDmitry Bogdanov rc = iscsi_xmit_task(conn, task, true); 161365080c51SDmitry Bogdanov if (rc) 161465080c51SDmitry Bogdanov goto done; 161565080c51SDmitry Bogdanov if (!list_empty(&conn->mgmtqueue)) 161665080c51SDmitry Bogdanov goto check_mgmt; 161765080c51SDmitry Bogdanov } 161865080c51SDmitry Bogdanov 1619843c0a8aSMike Christie /* process pending command queue */ 16203bbaaad9SMike Christie while (!list_empty(&conn->cmdqueue)) { 16215923d64bSMike Christie task = list_entry(conn->cmdqueue.next, struct iscsi_task, 16225d12c05eSMike Christie running); 16235923d64bSMike Christie list_del_init(&task->running); 1624b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) { 16255923d64bSMike Christie fail_scsi_task(task, DID_IMM_RETRY); 1626b3a7ea8dSMike Christie continue; 1627b3a7ea8dSMike Christie } 16285923d64bSMike Christie rc = iscsi_prep_scsi_cmd_pdu(task); 1629577577daSMike Christie if (rc) { 1630d28d48c6SMike Christie if (rc == -ENOMEM || rc == -EACCES) 16315923d64bSMike Christie fail_scsi_task(task, DID_IMM_RETRY); 1632d28d48c6SMike Christie else 16335923d64bSMike Christie fail_scsi_task(task, DID_ABORT); 1634004d6530SBoaz Harrosh continue; 1635004d6530SBoaz Harrosh } 16365923d64bSMike Christie rc = iscsi_xmit_task(conn, task, false); 16373219e529SMike Christie if (rc) 163870b31c15SMike Christie goto done; 163977a23c21SMike Christie /* 16409c19a7d0SMike Christie * we could continuously get new task requests so 164177a23c21SMike Christie * we need to check the mgmt queue for nops that need to 164277a23c21SMike Christie * be sent to aviod starvation 164377a23c21SMike Christie */ 1644843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 1645843c0a8aSMike Christie goto check_mgmt; 164665080c51SDmitry Bogdanov if (!list_empty(&conn->requeue)) 164765080c51SDmitry Bogdanov goto check_requeue; 1648843c0a8aSMike Christie } 1649843c0a8aSMike Christie 1650659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 16513219e529SMike Christie return -ENODATA; 16527996a778SMike Christie 165370b31c15SMike Christie done: 1654659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 16553219e529SMike Christie return rc; 16567996a778SMike Christie } 16577996a778SMike Christie 1658c4028958SDavid Howells static void iscsi_xmitworker(struct work_struct *work) 16597996a778SMike Christie { 1660c4028958SDavid Howells struct iscsi_conn *conn = 1661c4028958SDavid Howells container_of(work, struct iscsi_conn, xmitwork); 16623219e529SMike Christie int rc; 16637996a778SMike Christie /* 16647996a778SMike Christie * serialize Xmit worker on a per-connection basis. 16657996a778SMike Christie */ 16663219e529SMike Christie do { 16673219e529SMike Christie rc = iscsi_data_xmit(conn); 16683219e529SMike Christie } while (rc >= 0 || rc == -EAGAIN); 16697996a778SMike Christie } 16707996a778SMike Christie 1671577577daSMike Christie static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn, 1672577577daSMike Christie struct scsi_cmnd *sc) 1673577577daSMike Christie { 1674577577daSMike Christie struct iscsi_task *task; 1675577577daSMike Christie 16767acd72ebSStefani Seibold if (!kfifo_out(&conn->session->cmdpool.queue, 1677577577daSMike Christie (void *) &task, sizeof(void *))) 1678577577daSMike Christie return NULL; 1679577577daSMike Christie 1680db22de3eSBart Van Assche iscsi_cmd(sc)->age = conn->session->age; 1681db22de3eSBart Van Assche iscsi_cmd(sc)->task = task; 1682577577daSMike Christie 16836dc618cdSElena Reshetova refcount_set(&task->refcount, 1); 1684577577daSMike Christie task->state = ISCSI_TASK_PENDING; 1685577577daSMike Christie task->conn = conn; 1686577577daSMike Christie task->sc = sc; 1687d355e57dSMike Christie task->have_checked_conn = false; 1688d355e57dSMike Christie task->last_timeout = jiffies; 1689d355e57dSMike Christie task->last_xfer = jiffies; 169055e51edaSSagi Grimberg task->protected = false; 1691577577daSMike Christie INIT_LIST_HEAD(&task->running); 1692577577daSMike Christie return task; 1693577577daSMike Christie } 1694577577daSMike Christie 16957996a778SMike Christie enum { 16967996a778SMike Christie FAILURE_BAD_HOST = 1, 16977996a778SMike Christie FAILURE_SESSION_FAILED, 16987996a778SMike Christie FAILURE_SESSION_FREED, 16997996a778SMike Christie FAILURE_WINDOW_CLOSED, 170060ecebf5SMike Christie FAILURE_OOM, 17017996a778SMike Christie FAILURE_SESSION_TERMINATE, 1702656cffc9SMike Christie FAILURE_SESSION_IN_RECOVERY, 17037996a778SMike Christie FAILURE_SESSION_RECOVERY_TIMEOUT, 1704b3a7ea8dSMike Christie FAILURE_SESSION_LOGGING_OUT, 17056eabafbeSMike Christie FAILURE_SESSION_NOT_READY, 17067996a778SMike Christie }; 17077996a778SMike Christie 1708f41d4721SMike Christie int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc) 17097996a778SMike Christie { 171075613521SMike Christie struct iscsi_cls_session *cls_session; 17111336aed1SMike Christie struct iscsi_host *ihost; 17127996a778SMike Christie int reason = 0; 17137996a778SMike Christie struct iscsi_session *session; 17147996a778SMike Christie struct iscsi_conn *conn; 17159c19a7d0SMike Christie struct iscsi_task *task = NULL; 17167996a778SMike Christie 17177996a778SMike Christie sc->result = 0; 1718db22de3eSBart Van Assche iscsi_cmd(sc)->task = NULL; 17197996a778SMike Christie 17201336aed1SMike Christie ihost = shost_priv(host); 17217996a778SMike Christie 172275613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 172375613521SMike Christie session = cls_session->dd_data; 1724659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 17257996a778SMike Christie 172675613521SMike Christie reason = iscsi_session_chkready(cls_session); 17276eabafbeSMike Christie if (reason) { 17286eabafbeSMike Christie sc->result = reason; 17296eabafbeSMike Christie goto fault; 17306eabafbeSMike Christie } 17316eabafbeSMike Christie 1732301e0f7eSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1733656cffc9SMike Christie /* 1734656cffc9SMike Christie * to handle the race between when we set the recovery state 1735656cffc9SMike Christie * and block the session we requeue here (commands could 1736656cffc9SMike Christie * be entering our queuecommand while a block is starting 1737656cffc9SMike Christie * up because the block code is not locked) 1738656cffc9SMike Christie */ 17399000bcd6SMike Christie switch (session->state) { 1740301e0f7eSMike Christie case ISCSI_STATE_FAILED: 1741d7549412SRafael David Tinoco /* 1742d7549412SRafael David Tinoco * cmds should fail during shutdown, if the session 1743d7549412SRafael David Tinoco * state is bad, allowing completion to happen 1744d7549412SRafael David Tinoco */ 1745d7549412SRafael David Tinoco if (unlikely(system_state != SYSTEM_RUNNING)) { 1746d7549412SRafael David Tinoco reason = FAILURE_SESSION_FAILED; 1747d7549412SRafael David Tinoco sc->result = DID_NO_CONNECT << 16; 1748d7549412SRafael David Tinoco break; 1749d7549412SRafael David Tinoco } 1750df561f66SGustavo A. R. Silva fallthrough; 17519000bcd6SMike Christie case ISCSI_STATE_IN_RECOVERY: 1752656cffc9SMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1753301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1754301e0f7eSMike Christie break; 17559000bcd6SMike Christie case ISCSI_STATE_LOGGING_OUT: 17569000bcd6SMike Christie reason = FAILURE_SESSION_LOGGING_OUT; 1757301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1758301e0f7eSMike Christie break; 1759b3a7ea8dSMike Christie case ISCSI_STATE_RECOVERY_FAILED: 1760656cffc9SMike Christie reason = FAILURE_SESSION_RECOVERY_TIMEOUT; 176156d7fcfaSMike Christie sc->result = DID_TRANSPORT_FAILFAST << 16; 1762b3a7ea8dSMike Christie break; 1763b3a7ea8dSMike Christie case ISCSI_STATE_TERMINATE: 1764656cffc9SMike Christie reason = FAILURE_SESSION_TERMINATE; 17656eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1766b3a7ea8dSMike Christie break; 1767b3a7ea8dSMike Christie default: 17687996a778SMike Christie reason = FAILURE_SESSION_FREED; 17696eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1770b3a7ea8dSMike Christie } 17717996a778SMike Christie goto fault; 17727996a778SMike Christie } 17737996a778SMike Christie 17747996a778SMike Christie conn = session->leadconn; 177598644047SMike Christie if (!conn) { 177698644047SMike Christie reason = FAILURE_SESSION_FREED; 17776eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 177898644047SMike Christie goto fault; 177998644047SMike Christie } 17807996a778SMike Christie 17815bd85625SMike Christie if (test_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags)) { 1782661134adSMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1783eef9ffdfSJohannes Thumshirn sc->result = DID_REQUEUE << 16; 1784661134adSMike Christie goto fault; 1785661134adSMike Christie } 1786661134adSMike Christie 178777a23c21SMike Christie if (iscsi_check_cmdsn_window_closed(conn)) { 178877a23c21SMike Christie reason = FAILURE_WINDOW_CLOSED; 178977a23c21SMike Christie goto reject; 179077a23c21SMike Christie } 179177a23c21SMike Christie 1792577577daSMike Christie task = iscsi_alloc_task(conn, sc); 1793577577daSMike Christie if (!task) { 179460ecebf5SMike Christie reason = FAILURE_OOM; 179560ecebf5SMike Christie goto reject; 179660ecebf5SMike Christie } 17977996a778SMike Christie 17981336aed1SMike Christie if (!ihost->workq) { 1799577577daSMike Christie reason = iscsi_prep_scsi_cmd_pdu(task); 1800577577daSMike Christie if (reason) { 18015d12c05eSMike Christie if (reason == -ENOMEM || reason == -EACCES) { 1802577577daSMike Christie reason = FAILURE_OOM; 1803577577daSMike Christie goto prepd_reject; 1804577577daSMike Christie } else { 1805052d0144SMike Christie sc->result = DID_ABORT << 16; 1806577577daSMike Christie goto prepd_fault; 1807577577daSMike Christie } 1808052d0144SMike Christie } 18099c19a7d0SMike Christie if (session->tt->xmit_task(task)) { 1810d3305f34SMike Christie session->cmdsn--; 1811052d0144SMike Christie reason = FAILURE_SESSION_NOT_READY; 1812577577daSMike Christie goto prepd_reject; 1813052d0144SMike Christie } 18143bbaaad9SMike Christie } else { 18153bbaaad9SMike Christie list_add_tail(&task->running, &conn->cmdqueue); 18164b9f8ce4SMike Christie iscsi_conn_queue_xmit(conn); 18173bbaaad9SMike Christie } 1818052d0144SMike Christie 1819052d0144SMike Christie session->queued_cmdsn++; 1820659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 18217996a778SMike Christie return 0; 18227996a778SMike Christie 1823577577daSMike Christie prepd_reject: 1824a656183eSLee Duncan spin_lock_bh(&session->back_lock); 1825f41d4721SMike Christie iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 1826a656183eSLee Duncan spin_unlock_bh(&session->back_lock); 18277996a778SMike Christie reject: 1828659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 18291b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n", 18301b2c7af8SMike Christie sc->cmnd[0], reason); 1831d6d13ee1SMike Christie return SCSI_MLQUEUE_TARGET_BUSY; 18327996a778SMike Christie 1833577577daSMike Christie prepd_fault: 1834a656183eSLee Duncan spin_lock_bh(&session->back_lock); 1835f41d4721SMike Christie iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 1836a656183eSLee Duncan spin_unlock_bh(&session->back_lock); 18377996a778SMike Christie fault: 1838659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 18391b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n", 18401b2c7af8SMike Christie sc->cmnd[0], reason); 18411c138991SFUJITA Tomonori scsi_set_resid(sc, scsi_bufflen(sc)); 1842b4b84edcSBart Van Assche scsi_done(sc); 18437996a778SMike Christie return 0; 18447996a778SMike Christie } 18457996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_queuecommand); 18467996a778SMike Christie 18476b5d6c44SMike Christie int iscsi_target_alloc(struct scsi_target *starget) 18486b5d6c44SMike Christie { 18496b5d6c44SMike Christie struct iscsi_cls_session *cls_session = starget_to_session(starget); 18506b5d6c44SMike Christie struct iscsi_session *session = cls_session->dd_data; 18516b5d6c44SMike Christie 18526b5d6c44SMike Christie starget->can_queue = session->scsi_cmds_max; 18536b5d6c44SMike Christie return 0; 18546b5d6c44SMike Christie } 18556b5d6c44SMike Christie EXPORT_SYMBOL_GPL(iscsi_target_alloc); 18566b5d6c44SMike Christie 18572c4b9637SKees Cook static void iscsi_tmf_timedout(struct timer_list *t) 18587996a778SMike Christie { 1859ec29d0acSMike Christie struct iscsi_session *session = from_timer(session, t, tmf_timer); 18607996a778SMike Christie 1861659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 1862ec29d0acSMike Christie if (session->tmf_state == TMF_QUEUED) { 1863ec29d0acSMike Christie session->tmf_state = TMF_TIMEDOUT; 1864bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf timedout\n"); 18657996a778SMike Christie /* unblock eh_abort() */ 1866ec29d0acSMike Christie wake_up(&session->ehwait); 18677996a778SMike Christie } 1868659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 18697996a778SMike Christie } 18707996a778SMike Christie 18719c19a7d0SMike Christie static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, 1872f6d5180cSMike Christie struct iscsi_tm *hdr, int age, 1873f6d5180cSMike Christie int timeout) 18741360c58aSBart Van Assche __must_hold(&session->frwd_lock) 18757996a778SMike Christie { 18767996a778SMike Christie struct iscsi_session *session = conn->session; 18779c19a7d0SMike Christie struct iscsi_task *task; 18787996a778SMike Christie 18799c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr, 18807996a778SMike Christie NULL, 0); 18819c19a7d0SMike Christie if (!task) { 1882659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1883df4da5cdSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send TMF.\n"); 18847996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1885659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 188677a23c21SMike Christie return -EPERM; 18877996a778SMike Christie } 18887996a778SMike Christie conn->tmfcmd_pdus_cnt++; 1889ec29d0acSMike Christie session->tmf_timer.expires = timeout * HZ + jiffies; 1890ec29d0acSMike Christie add_timer(&session->tmf_timer); 1891bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf set timeout\n"); 1892843c0a8aSMike Christie 1893659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 18946724add1SMike Christie mutex_unlock(&session->eh_mutex); 18957996a778SMike Christie 18967996a778SMike Christie /* 18977996a778SMike Christie * block eh thread until: 18987996a778SMike Christie * 1899843c0a8aSMike Christie * 1) tmf response 1900843c0a8aSMike Christie * 2) tmf timeout 19017996a778SMike Christie * 3) session is terminated or restarted or userspace has 19027996a778SMike Christie * given up on recovery 19037996a778SMike Christie */ 1904ec29d0acSMike Christie wait_event_interruptible(session->ehwait, age != session->age || 19057996a778SMike Christie session->state != ISCSI_STATE_LOGGED_IN || 1906ec29d0acSMike Christie session->tmf_state != TMF_QUEUED); 19077996a778SMike Christie if (signal_pending(current)) 19087996a778SMike Christie flush_signals(current); 1909ec29d0acSMike Christie del_timer_sync(&session->tmf_timer); 1910843c0a8aSMike Christie 19116724add1SMike Christie mutex_lock(&session->eh_mutex); 1912659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 19139c19a7d0SMike Christie /* if the session drops it will clean up the task */ 1914843c0a8aSMike Christie if (age != session->age || 1915843c0a8aSMike Christie session->state != ISCSI_STATE_LOGGED_IN) 1916843c0a8aSMike Christie return -ENOTCONN; 19177996a778SMike Christie return 0; 19187996a778SMike Christie } 19197996a778SMike Christie 19207996a778SMike Christie /* 192114936b1eSMike Christie * Fail commands. session frwd lock held and xmit thread flushed. 1922843c0a8aSMike Christie */ 19239cb78c16SHannes Reinecke static void fail_scsi_tasks(struct iscsi_conn *conn, u64 lun, int error) 1924843c0a8aSMike Christie { 192514936b1eSMike Christie struct iscsi_session *session = conn->session; 19263bbaaad9SMike Christie struct iscsi_task *task; 19273bbaaad9SMike Christie int i; 1928843c0a8aSMike Christie 1929e1c6a7ecSMike Christie restart_cmd_loop: 193014936b1eSMike Christie spin_lock_bh(&session->back_lock); 193114936b1eSMike Christie for (i = 0; i < session->cmds_max; i++) { 193214936b1eSMike Christie task = session->cmds[i]; 19333bbaaad9SMike Christie if (!task->sc || task->state == ISCSI_TASK_FREE) 19343bbaaad9SMike Christie continue; 1935843c0a8aSMike Christie 19363bbaaad9SMike Christie if (lun != -1 && lun != task->sc->device->lun) 19373bbaaad9SMike Christie continue; 1938e1c6a7ecSMike Christie /* 1939e1c6a7ecSMike Christie * The cmd is completing but if this is called from an eh 1940e1c6a7ecSMike Christie * callout path then when we return scsi-ml owns the cmd. Wait 1941e1c6a7ecSMike Christie * for the completion path to finish freeing the cmd. 1942e1c6a7ecSMike Christie */ 1943e1c6a7ecSMike Christie if (!iscsi_get_task(task)) { 194414936b1eSMike Christie spin_unlock_bh(&session->back_lock); 1945e1c6a7ecSMike Christie spin_unlock_bh(&session->frwd_lock); 1946e1c6a7ecSMike Christie udelay(ISCSI_CMD_COMPL_WAIT); 1947e1c6a7ecSMike Christie spin_lock_bh(&session->frwd_lock); 1948e1c6a7ecSMike Christie goto restart_cmd_loop; 1949e1c6a7ecSMike Christie } 195014936b1eSMike Christie 195114936b1eSMike Christie ISCSI_DBG_SESSION(session, 19523bbaaad9SMike Christie "failing sc %p itt 0x%x state %d\n", 19533bbaaad9SMike Christie task->sc, task->itt, task->state); 1954e1c6a7ecSMike Christie __fail_scsi_task(task, error); 1955e1c6a7ecSMike Christie __iscsi_put_task(task); 1956843c0a8aSMike Christie } 195714936b1eSMike Christie spin_unlock_bh(&session->back_lock); 1958843c0a8aSMike Christie } 1959843c0a8aSMike Christie 1960661134adSMike Christie /** 1961661134adSMike Christie * iscsi_suspend_queue - suspend iscsi_queuecommand 1962661134adSMike Christie * @conn: iscsi conn to stop queueing IO on 1963661134adSMike Christie * 1964659743b0SShlomo Pongratz * This grabs the session frwd_lock to make sure no one is in 1965661134adSMike Christie * xmit_task/queuecommand, and then sets suspend to prevent 1966661134adSMike Christie * new commands from being queued. This only needs to be called 1967661134adSMike Christie * by offload drivers that need to sync a path like ep disconnect 1968661134adSMike Christie * with the iscsi_queuecommand/xmit_task. To start IO again libiscsi 1969661134adSMike Christie * will call iscsi_start_tx and iscsi_unblock_session when in FFP. 1970661134adSMike Christie */ 1971661134adSMike Christie void iscsi_suspend_queue(struct iscsi_conn *conn) 1972661134adSMike Christie { 1973659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 19745bd85625SMike Christie set_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags); 1975659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 1976661134adSMike Christie } 1977661134adSMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_queue); 1978661134adSMike Christie 1979661134adSMike Christie /** 1980661134adSMike Christie * iscsi_suspend_tx - suspend iscsi_data_xmit 19818af80996SMike Christie * @conn: iscsi conn to stop processing IO on. 1982661134adSMike Christie * 1983661134adSMike Christie * This function sets the suspend bit to prevent iscsi_data_xmit 1984661134adSMike Christie * from sending new IO, and if work is queued on the xmit thread 1985661134adSMike Christie * it will wait for it to be completed. 1986661134adSMike Christie */ 1987b40977d9SMike Christie void iscsi_suspend_tx(struct iscsi_conn *conn) 19886724add1SMike Christie { 198932ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 199032ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 199132ae763eSMike Christie 19925bd85625SMike Christie set_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags); 19931336aed1SMike Christie if (ihost->workq) 19948af80996SMike Christie flush_work(&conn->xmitwork); 19956724add1SMike Christie } 1996b40977d9SMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_tx); 19976724add1SMike Christie 19986724add1SMike Christie static void iscsi_start_tx(struct iscsi_conn *conn) 19996724add1SMike Christie { 20005bd85625SMike Christie clear_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags); 20014b9f8ce4SMike Christie iscsi_conn_queue_xmit(conn); 20026724add1SMike Christie } 20036724add1SMike Christie 20048af80996SMike Christie /** 20058af80996SMike Christie * iscsi_suspend_rx - Prevent recvwork from running again. 20068af80996SMike Christie * @conn: iscsi conn to stop. 20078af80996SMike Christie */ 20088af80996SMike Christie void iscsi_suspend_rx(struct iscsi_conn *conn) 20098af80996SMike Christie { 20108af80996SMike Christie struct Scsi_Host *shost = conn->session->host; 20118af80996SMike Christie struct iscsi_host *ihost = shost_priv(shost); 20128af80996SMike Christie 20138af80996SMike Christie set_bit(ISCSI_CONN_FLAG_SUSPEND_RX, &conn->flags); 20148af80996SMike Christie if (ihost->workq) 20158af80996SMike Christie flush_work(&conn->recvwork); 20168af80996SMike Christie } 20178af80996SMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_rx); 20188af80996SMike Christie 20194c48a829SMike Christie /* 20204c48a829SMike Christie * We want to make sure a ping is in flight. It has timed out. 20214c48a829SMike Christie * And we are not busy processing a pdu that is making 20224c48a829SMike Christie * progress but got started before the ping and is taking a while 20234c48a829SMike Christie * to complete so the ping is just stuck behind it in a queue. 20244c48a829SMike Christie */ 20254c48a829SMike Christie static int iscsi_has_ping_timed_out(struct iscsi_conn *conn) 20264c48a829SMike Christie { 2027fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task) && 20284c48a829SMike Christie time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) + 20294c48a829SMike Christie (conn->ping_timeout * HZ), jiffies)) 20304c48a829SMike Christie return 1; 20314c48a829SMike Christie else 20324c48a829SMike Christie return 0; 20334c48a829SMike Christie } 20344c48a829SMike Christie 2035b6a05c82SChristoph Hellwig enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc) 2036f6d5180cSMike Christie { 20376600593cSChristoph Hellwig enum blk_eh_timer_return rc = BLK_EH_DONE; 203892ed4d69SMike Christie struct iscsi_task *task = NULL, *running_task; 2039f6d5180cSMike Christie struct iscsi_cls_session *cls_session; 2040f6d5180cSMike Christie struct iscsi_session *session; 2041f6d5180cSMike Christie struct iscsi_conn *conn; 204292ed4d69SMike Christie int i; 2043f6d5180cSMike Christie 2044d355e57dSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 204575613521SMike Christie session = cls_session->dd_data; 2046f6d5180cSMike Christie 2047bd2199d4SErez Zilber ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc); 2048f6d5180cSMike Christie 20495480e299SBart Van Assche spin_lock_bh(&session->frwd_lock); 205014936b1eSMike Christie spin_lock(&session->back_lock); 2051db22de3eSBart Van Assche task = iscsi_cmd(sc)->task; 2052e3d338a5SMike Christie if (!task) { 2053e3d338a5SMike Christie /* 2054e3d338a5SMike Christie * Raced with completion. Blk layer has taken ownership 2055e3d338a5SMike Christie * so let timeout code complete it now. 2056e3d338a5SMike Christie */ 2057adb2b769SChristoph Hellwig rc = BLK_EH_DONE; 205814936b1eSMike Christie spin_unlock(&session->back_lock); 2059e3d338a5SMike Christie goto done; 2060e3d338a5SMike Christie } 2061e1c6a7ecSMike Christie if (!iscsi_get_task(task)) { 2062e1c6a7ecSMike Christie /* 2063e1c6a7ecSMike Christie * Racing with the completion path right now, so give it more 2064e1c6a7ecSMike Christie * time so that path can complete it like normal. 2065e1c6a7ecSMike Christie */ 2066e1c6a7ecSMike Christie rc = BLK_EH_RESET_TIMER; 2067e1c6a7ecSMike Christie task = NULL; 2068e1c6a7ecSMike Christie spin_unlock(&session->back_lock); 2069e1c6a7ecSMike Christie goto done; 2070e1c6a7ecSMike Christie } 207114936b1eSMike Christie spin_unlock(&session->back_lock); 2072e3d338a5SMike Christie 2073f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 2074f6d5180cSMike Christie /* 2075d7549412SRafael David Tinoco * During shutdown, if session is prematurely disconnected, 2076d7549412SRafael David Tinoco * recovery won't happen and there will be hung cmds. Not 2077d7549412SRafael David Tinoco * handling cmds would trigger EH, also bad in this case. 2078d7549412SRafael David Tinoco * Instead, handle cmd, allow completion to happen and let 2079d7549412SRafael David Tinoco * upper layer to deal with the result. 2080d7549412SRafael David Tinoco */ 2081d7549412SRafael David Tinoco if (unlikely(system_state != SYSTEM_RUNNING)) { 2082d7549412SRafael David Tinoco sc->result = DID_NO_CONNECT << 16; 2083d7549412SRafael David Tinoco ISCSI_DBG_EH(session, "sc on shutdown, handled\n"); 2084adb2b769SChristoph Hellwig rc = BLK_EH_DONE; 2085d7549412SRafael David Tinoco goto done; 2086d7549412SRafael David Tinoco } 2087d7549412SRafael David Tinoco /* 2088f6d5180cSMike Christie * We are probably in the middle of iscsi recovery so let 2089f6d5180cSMike Christie * that complete and handle the error. 2090f6d5180cSMike Christie */ 2091242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 2092f6d5180cSMike Christie goto done; 2093f6d5180cSMike Christie } 2094f6d5180cSMike Christie 2095f6d5180cSMike Christie conn = session->leadconn; 2096f6d5180cSMike Christie if (!conn) { 2097f6d5180cSMike Christie /* In the middle of shuting down */ 2098242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 2099f6d5180cSMike Christie goto done; 2100f6d5180cSMike Christie } 2101f6d5180cSMike Christie 2102d355e57dSMike Christie /* 2103d355e57dSMike Christie * If we have sent (at least queued to the network layer) a pdu or 2104d355e57dSMike Christie * recvd one for the task since the last timeout ask for 2105d355e57dSMike Christie * more time. If on the next timeout we have not made progress 2106d355e57dSMike Christie * we can check if it is the task or connection when we send the 2107d355e57dSMike Christie * nop as a ping. 2108d355e57dSMike Christie */ 210992ed4d69SMike Christie if (time_after(task->last_xfer, task->last_timeout)) { 2110bd2199d4SErez Zilber ISCSI_DBG_EH(session, "Command making progress. Asking " 2111d355e57dSMike Christie "scsi-ml for more time to complete. " 211292ed4d69SMike Christie "Last data xfer at %lu. Last timeout was at " 2113d355e57dSMike Christie "%lu\n.", task->last_xfer, task->last_timeout); 2114d355e57dSMike Christie task->have_checked_conn = false; 2115d355e57dSMike Christie rc = BLK_EH_RESET_TIMER; 2116d355e57dSMike Christie goto done; 2117d355e57dSMike Christie } 2118d355e57dSMike Christie 2119f6d5180cSMike Christie if (!conn->recv_timeout && !conn->ping_timeout) 2120f6d5180cSMike Christie goto done; 2121f6d5180cSMike Christie /* 2122f6d5180cSMike Christie * if the ping timedout then we are in the middle of cleaning up 2123f6d5180cSMike Christie * and can let the iscsi eh handle it 2124f6d5180cSMike Christie */ 21254c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 2126242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 21274c48a829SMike Christie goto done; 21284c48a829SMike Christie } 2129d355e57dSMike Christie 213014936b1eSMike Christie spin_lock(&session->back_lock); 213192ed4d69SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 213292ed4d69SMike Christie running_task = conn->session->cmds[i]; 213392ed4d69SMike Christie if (!running_task->sc || running_task == task || 213492ed4d69SMike Christie running_task->state != ISCSI_TASK_RUNNING) 213592ed4d69SMike Christie continue; 213692ed4d69SMike Christie 213792ed4d69SMike Christie /* 213892ed4d69SMike Christie * Only check if cmds started before this one have made 213992ed4d69SMike Christie * progress, or this could never fail 214092ed4d69SMike Christie */ 214192ed4d69SMike Christie if (time_after(running_task->sc->jiffies_at_alloc, 214292ed4d69SMike Christie task->sc->jiffies_at_alloc)) 214392ed4d69SMike Christie continue; 214492ed4d69SMike Christie 214592ed4d69SMike Christie if (time_after(running_task->last_xfer, task->last_timeout)) { 214692ed4d69SMike Christie /* 214792ed4d69SMike Christie * This task has not made progress, but a task 214892ed4d69SMike Christie * started before us has transferred data since 214992ed4d69SMike Christie * we started/last-checked. We could be queueing 215092ed4d69SMike Christie * too many tasks or the LU is bad. 215192ed4d69SMike Christie * 215292ed4d69SMike Christie * If the device is bad the cmds ahead of us on 215392ed4d69SMike Christie * other devs will complete, and this loop will 215492ed4d69SMike Christie * eventually fail starting the scsi eh. 215592ed4d69SMike Christie */ 215692ed4d69SMike Christie ISCSI_DBG_EH(session, "Command has not made progress " 215792ed4d69SMike Christie "but commands ahead of it have. " 215892ed4d69SMike Christie "Asking scsi-ml for more time to " 215992ed4d69SMike Christie "complete. Our last xfer vs running task " 216092ed4d69SMike Christie "last xfer %lu/%lu. Last check %lu.\n", 216192ed4d69SMike Christie task->last_xfer, running_task->last_xfer, 216292ed4d69SMike Christie task->last_timeout); 216314936b1eSMike Christie spin_unlock(&session->back_lock); 216492ed4d69SMike Christie rc = BLK_EH_RESET_TIMER; 216592ed4d69SMike Christie goto done; 216692ed4d69SMike Christie } 216792ed4d69SMike Christie } 216814936b1eSMike Christie spin_unlock(&session->back_lock); 216992ed4d69SMike Christie 2170d355e57dSMike Christie /* Assumes nop timeout is shorter than scsi cmd timeout */ 2171d355e57dSMike Christie if (task->have_checked_conn) 2172d355e57dSMike Christie goto done; 2173d355e57dSMike Christie 2174f6d5180cSMike Christie /* 2175d355e57dSMike Christie * Checking the transport already or nop from a cmd timeout still 2176d355e57dSMike Christie * running 2177f6d5180cSMike Christie */ 2178fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task)) { 2179d355e57dSMike Christie task->have_checked_conn = true; 2180242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 21814c48a829SMike Christie goto done; 21824c48a829SMike Christie } 21834c48a829SMike Christie 2184d355e57dSMike Christie /* Make sure there is a transport check done */ 2185d355e57dSMike Christie iscsi_send_nopout(conn, NULL); 2186d355e57dSMike Christie task->have_checked_conn = true; 2187242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 2188d355e57dSMike Christie 2189f6d5180cSMike Christie done: 21905480e299SBart Van Assche spin_unlock_bh(&session->frwd_lock); 219114936b1eSMike Christie 219214936b1eSMike Christie if (task) { 219314936b1eSMike Christie task->last_timeout = jiffies; 219414936b1eSMike Christie iscsi_put_task(task); 219514936b1eSMike Christie } 2196bd2199d4SErez Zilber ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ? 2197d7549412SRafael David Tinoco "timer reset" : "shutdown or nh"); 2198f6d5180cSMike Christie return rc; 2199f6d5180cSMike Christie } 2200b6a05c82SChristoph Hellwig EXPORT_SYMBOL_GPL(iscsi_eh_cmd_timed_out); 2201f6d5180cSMike Christie 22022c4b9637SKees Cook static void iscsi_check_transport_timeouts(struct timer_list *t) 2203f6d5180cSMike Christie { 22042c4b9637SKees Cook struct iscsi_conn *conn = from_timer(conn, t, transport_timer); 2205f6d5180cSMike Christie struct iscsi_session *session = conn->session; 22064cf10435SMike Christie unsigned long recv_timeout, next_timeout = 0, last_recv; 2207f6d5180cSMike Christie 2208659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 2209f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 2210f6d5180cSMike Christie goto done; 2211f6d5180cSMike Christie 22124cf10435SMike Christie recv_timeout = conn->recv_timeout; 22134cf10435SMike Christie if (!recv_timeout) 2214f6d5180cSMike Christie goto done; 2215f6d5180cSMike Christie 22164cf10435SMike Christie recv_timeout *= HZ; 2217f6d5180cSMike Christie last_recv = conn->last_recv; 22184c48a829SMike Christie 22194c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 2220322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs " 22214c48a829SMike Christie "expired, recv timeout %d, last rx %lu, " 22224c48a829SMike Christie "last ping %lu, now %lu\n", 22234c48a829SMike Christie conn->ping_timeout, conn->recv_timeout, 22244c48a829SMike Christie last_recv, conn->last_ping, jiffies); 2225659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 222609ff742cSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_NOP_TIMEDOUT); 2227f6d5180cSMike Christie return; 2228f6d5180cSMike Christie } 2229f6d5180cSMike Christie 22304cf10435SMike Christie if (time_before_eq(last_recv + recv_timeout, jiffies)) { 2231f6d5180cSMike Christie /* send a ping to try to provoke some traffic */ 22321b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Sending nopout as ping\n"); 223352f5664aSAriel Nahum if (iscsi_send_nopout(conn, NULL)) 223452f5664aSAriel Nahum next_timeout = jiffies + (1 * HZ); 223552f5664aSAriel Nahum else 22364cf10435SMike Christie next_timeout = conn->last_ping + (conn->ping_timeout * HZ); 2237ad294e9cSMike Christie } else 22384cf10435SMike Christie next_timeout = last_recv + recv_timeout; 2239f6d5180cSMike Christie 22401b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout); 2241f6d5180cSMike Christie mod_timer(&conn->transport_timer, next_timeout); 2242f6d5180cSMike Christie done: 2243659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 2244f6d5180cSMike Christie } 2245f6d5180cSMike Christie 2246891e2639SMike Christie /** 2247891e2639SMike Christie * iscsi_conn_unbind - prevent queueing to conn. 2248891e2639SMike Christie * @cls_conn: iscsi conn ep is bound to. 2249891e2639SMike Christie * @is_active: is the conn in use for boot or is this for EH/termination 2250891e2639SMike Christie * 2251891e2639SMike Christie * This must be called by drivers implementing the ep_disconnect callout. 2252891e2639SMike Christie * It disables queueing to the connection from libiscsi in preparation for 2253891e2639SMike Christie * an ep_disconnect call. 2254891e2639SMike Christie */ 2255891e2639SMike Christie void iscsi_conn_unbind(struct iscsi_cls_conn *cls_conn, bool is_active) 2256891e2639SMike Christie { 2257891e2639SMike Christie struct iscsi_session *session; 2258891e2639SMike Christie struct iscsi_conn *conn; 2259891e2639SMike Christie 2260891e2639SMike Christie if (!cls_conn) 2261891e2639SMike Christie return; 2262891e2639SMike Christie 2263891e2639SMike Christie conn = cls_conn->dd_data; 2264891e2639SMike Christie session = conn->session; 2265891e2639SMike Christie /* 2266891e2639SMike Christie * Wait for iscsi_eh calls to exit. We don't wait for the tmf to 2267891e2639SMike Christie * complete or timeout. The caller just wants to know what's running 2268891e2639SMike Christie * is everything that needs to be cleaned up, and no cmds will be 2269891e2639SMike Christie * queued. 2270891e2639SMike Christie */ 2271891e2639SMike Christie mutex_lock(&session->eh_mutex); 2272891e2639SMike Christie 2273891e2639SMike Christie iscsi_suspend_queue(conn); 2274891e2639SMike Christie iscsi_suspend_tx(conn); 2275891e2639SMike Christie 2276891e2639SMike Christie spin_lock_bh(&session->frwd_lock); 227744ac9710SMike Christie clear_bit(ISCSI_CONN_FLAG_BOUND, &conn->flags); 227844ac9710SMike Christie 2279891e2639SMike Christie if (!is_active) { 2280891e2639SMike Christie /* 2281891e2639SMike Christie * if logout timed out before userspace could even send a PDU 2282891e2639SMike Christie * the state might still be in ISCSI_STATE_LOGGED_IN and 2283891e2639SMike Christie * allowing new cmds and TMFs. 2284891e2639SMike Christie */ 2285891e2639SMike Christie if (session->state == ISCSI_STATE_LOGGED_IN) 2286891e2639SMike Christie iscsi_set_conn_failed(conn); 2287891e2639SMike Christie } 2288891e2639SMike Christie spin_unlock_bh(&session->frwd_lock); 2289891e2639SMike Christie mutex_unlock(&session->eh_mutex); 2290891e2639SMike Christie } 2291891e2639SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_unbind); 2292891e2639SMike Christie 22939c19a7d0SMike Christie static void iscsi_prep_abort_task_pdu(struct iscsi_task *task, 2294843c0a8aSMike Christie struct iscsi_tm *hdr) 2295843c0a8aSMike Christie { 2296843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2297843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2298843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK; 2299843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 230055bdabdfSAndy Grover hdr->lun = task->lun; 2301577577daSMike Christie hdr->rtt = task->hdr_itt; 2302577577daSMike Christie hdr->refcmdsn = task->cmdsn; 2303843c0a8aSMike Christie } 2304843c0a8aSMike Christie 23057996a778SMike Christie int iscsi_eh_abort(struct scsi_cmnd *sc) 23067996a778SMike Christie { 230775613521SMike Christie struct iscsi_cls_session *cls_session; 230875613521SMike Christie struct iscsi_session *session; 2309f47f2cf5SMike Christie struct iscsi_conn *conn; 23109c19a7d0SMike Christie struct iscsi_task *task; 2311843c0a8aSMike Christie struct iscsi_tm *hdr; 2312e9e410e8SBart Van Assche int age; 23137996a778SMike Christie 231475613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 231575613521SMike Christie session = cls_session->dd_data; 231675613521SMike Christie 2317bd2199d4SErez Zilber ISCSI_DBG_EH(session, "aborting sc %p\n", sc); 23184421c9ebSMike Christie 2319e1c6a7ecSMike Christie completion_check: 23206724add1SMike Christie mutex_lock(&session->eh_mutex); 2321659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2322f47f2cf5SMike Christie /* 2323f47f2cf5SMike Christie * if session was ISCSI_STATE_IN_RECOVERY then we may not have 2324f47f2cf5SMike Christie * got the command. 2325f47f2cf5SMike Christie */ 2326db22de3eSBart Van Assche if (!iscsi_cmd(sc)->task) { 2327bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc never reached iscsi layer or " 23281b2c7af8SMike Christie "it completed.\n"); 2329659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 23306724add1SMike Christie mutex_unlock(&session->eh_mutex); 2331f47f2cf5SMike Christie return SUCCESS; 2332f47f2cf5SMike Christie } 2333f47f2cf5SMike Christie 23347996a778SMike Christie /* 23357996a778SMike Christie * If we are not logged in or we have started a new session 23367996a778SMike Christie * then let the host reset code handle this 23377996a778SMike Christie */ 2338843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN || 2339db22de3eSBart Van Assche iscsi_cmd(sc)->age != session->age) { 2340659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2341843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2342bd2199d4SErez Zilber ISCSI_DBG_EH(session, "failing abort due to dropped " 23434421c9ebSMike Christie "session.\n"); 2344843c0a8aSMike Christie return FAILED; 2345843c0a8aSMike Christie } 2346843c0a8aSMike Christie 234714936b1eSMike Christie spin_lock(&session->back_lock); 2348db22de3eSBart Van Assche task = iscsi_cmd(sc)->task; 234914936b1eSMike Christie if (!task || !task->sc) { 23509c19a7d0SMike Christie /* task completed before time out */ 2351bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in progress\n"); 235214936b1eSMike Christie 235314936b1eSMike Christie spin_unlock(&session->back_lock); 2354258aad75SMike Christie spin_unlock_bh(&session->frwd_lock); 2355258aad75SMike Christie mutex_unlock(&session->eh_mutex); 2356258aad75SMike Christie return SUCCESS; 23577ea8b828SMike Christie } 2358258aad75SMike Christie 2359e1c6a7ecSMike Christie if (!iscsi_get_task(task)) { 2360e1c6a7ecSMike Christie spin_unlock(&session->back_lock); 2361e1c6a7ecSMike Christie spin_unlock_bh(&session->frwd_lock); 2362e1c6a7ecSMike Christie mutex_unlock(&session->eh_mutex); 2363e1c6a7ecSMike Christie /* We are just about to call iscsi_free_task so wait for it. */ 2364e1c6a7ecSMike Christie udelay(ISCSI_CMD_COMPL_WAIT); 2365e1c6a7ecSMike Christie goto completion_check; 2366e1c6a7ecSMike Christie } 2367e1c6a7ecSMike Christie 2368e1c6a7ecSMike Christie ISCSI_DBG_EH(session, "aborting [sc %p itt 0x%x]\n", sc, task->itt); 2369258aad75SMike Christie conn = session->leadconn; 2370258aad75SMike Christie iscsi_get_conn(conn->cls_conn); 2371258aad75SMike Christie conn->eh_abort_cnt++; 2372258aad75SMike Christie age = session->age; 237314936b1eSMike Christie spin_unlock(&session->back_lock); 23747996a778SMike Christie 23759c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) { 2376b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 237777a23c21SMike Christie goto success; 237877a23c21SMike Christie } 23797996a778SMike Christie 2380843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2381ec29d0acSMike Christie if (session->tmf_state != TMF_INITIAL) 23827996a778SMike Christie goto failed; 2383ec29d0acSMike Christie session->tmf_state = TMF_QUEUED; 23847996a778SMike Christie 2385ec29d0acSMike Christie hdr = &session->tmhdr; 23869c19a7d0SMike Christie iscsi_prep_abort_task_pdu(task, hdr); 2387843c0a8aSMike Christie 2388e9e410e8SBart Van Assche if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) 2389843c0a8aSMike Christie goto failed; 2390843c0a8aSMike Christie 2391ec29d0acSMike Christie switch (session->tmf_state) { 2392843c0a8aSMike Christie case TMF_SUCCESS: 2393659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2394913e5bf4SMike Christie /* 2395913e5bf4SMike Christie * stop tx side incase the target had sent a abort rsp but 2396913e5bf4SMike Christie * the initiator was still writing out data. 2397913e5bf4SMike Christie */ 23986724add1SMike Christie iscsi_suspend_tx(conn); 23997996a778SMike Christie /* 2400913e5bf4SMike Christie * we do not stop the recv side because targets have been 2401913e5bf4SMike Christie * good and have never sent us a successful tmf response 2402913e5bf4SMike Christie * then sent more data for the cmd. 24037996a778SMike Christie */ 2404659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2405b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 2406ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 24075d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 2408659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 24096724add1SMike Christie iscsi_start_tx(conn); 241077a23c21SMike Christie goto success_unlocked; 2411843c0a8aSMike Christie case TMF_TIMEDOUT: 241299b06033SMike Christie session->running_aborted_task = task; 2413659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2414df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2415843c0a8aSMike Christie goto failed_unlocked; 2416843c0a8aSMike Christie case TMF_NOT_FOUND: 2417f6f96457SMike Christie if (iscsi_task_is_completed(task)) { 2418ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 24195d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 24209c19a7d0SMike Christie /* task completed before tmf abort response */ 2421bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in " 2422bd2199d4SErez Zilber "progress\n"); 242377a23c21SMike Christie goto success; 242477a23c21SMike Christie } 2425df561f66SGustavo A. R. Silva fallthrough; 242677a23c21SMike Christie default: 2427ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 2428843c0a8aSMike Christie goto failed; 242977a23c21SMike Christie } 24307996a778SMike Christie 243177a23c21SMike Christie success: 2432659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 243377a23c21SMike Christie success_unlocked: 2434bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n", 24351b2c7af8SMike Christie sc, task->itt); 243614936b1eSMike Christie iscsi_put_task(task); 2437d39df158SMike Christie iscsi_put_conn(conn->cls_conn); 24386724add1SMike Christie mutex_unlock(&session->eh_mutex); 24397996a778SMike Christie return SUCCESS; 24407996a778SMike Christie 24417996a778SMike Christie failed: 2442659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 244377a23c21SMike Christie failed_unlocked: 2444bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc, 24459c19a7d0SMike Christie task ? task->itt : 0); 244699b06033SMike Christie /* 244799b06033SMike Christie * The driver might be accessing the task so hold the ref. The conn 244899b06033SMike Christie * stop cleanup will drop the ref after ep_disconnect so we know the 244999b06033SMike Christie * driver's no longer touching the task. 245099b06033SMike Christie */ 245199b06033SMike Christie if (!session->running_aborted_task) 245214936b1eSMike Christie iscsi_put_task(task); 245399b06033SMike Christie 2454d39df158SMike Christie iscsi_put_conn(conn->cls_conn); 24556724add1SMike Christie mutex_unlock(&session->eh_mutex); 24567996a778SMike Christie return FAILED; 24577996a778SMike Christie } 24587996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_abort); 24597996a778SMike Christie 2460843c0a8aSMike Christie static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 2461843c0a8aSMike Christie { 2462843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2463843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2464843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK; 2465843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 246655bdabdfSAndy Grover int_to_scsilun(sc->device->lun, &hdr->lun); 2467f6d5180cSMike Christie hdr->rtt = RESERVED_ITT; 2468843c0a8aSMike Christie } 2469843c0a8aSMike Christie 2470843c0a8aSMike Christie int iscsi_eh_device_reset(struct scsi_cmnd *sc) 2471843c0a8aSMike Christie { 247275613521SMike Christie struct iscsi_cls_session *cls_session; 247375613521SMike Christie struct iscsi_session *session; 2474843c0a8aSMike Christie struct iscsi_conn *conn; 2475843c0a8aSMike Christie struct iscsi_tm *hdr; 2476843c0a8aSMike Christie int rc = FAILED; 2477843c0a8aSMike Christie 247875613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 247975613521SMike Christie session = cls_session->dd_data; 248075613521SMike Christie 24819cb78c16SHannes Reinecke ISCSI_DBG_EH(session, "LU Reset [sc %p lun %llu]\n", sc, 24829cb78c16SHannes Reinecke sc->device->lun); 2483843c0a8aSMike Christie 2484843c0a8aSMike Christie mutex_lock(&session->eh_mutex); 2485659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2486843c0a8aSMike Christie /* 2487843c0a8aSMike Christie * Just check if we are not logged in. We cannot check for 2488843c0a8aSMike Christie * the phase because the reset could come from a ioctl. 2489843c0a8aSMike Christie */ 2490843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 2491843c0a8aSMike Christie goto unlock; 2492843c0a8aSMike Christie conn = session->leadconn; 2493843c0a8aSMike Christie 2494843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2495ec29d0acSMike Christie if (session->tmf_state != TMF_INITIAL) 2496843c0a8aSMike Christie goto unlock; 2497ec29d0acSMike Christie session->tmf_state = TMF_QUEUED; 2498843c0a8aSMike Christie 2499ec29d0acSMike Christie hdr = &session->tmhdr; 2500843c0a8aSMike Christie iscsi_prep_lun_reset_pdu(sc, hdr); 2501843c0a8aSMike Christie 25029c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 2503f6d5180cSMike Christie session->lu_reset_timeout)) { 2504843c0a8aSMike Christie rc = FAILED; 2505843c0a8aSMike Christie goto unlock; 2506843c0a8aSMike Christie } 2507843c0a8aSMike Christie 2508ec29d0acSMike Christie switch (session->tmf_state) { 2509843c0a8aSMike Christie case TMF_SUCCESS: 2510843c0a8aSMike Christie break; 2511843c0a8aSMike Christie case TMF_TIMEDOUT: 2512659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2513df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2514843c0a8aSMike Christie goto done; 2515843c0a8aSMike Christie default: 2516ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 2517843c0a8aSMike Christie goto unlock; 2518843c0a8aSMike Christie } 2519843c0a8aSMike Christie 2520843c0a8aSMike Christie rc = SUCCESS; 2521659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2522843c0a8aSMike Christie 2523843c0a8aSMike Christie iscsi_suspend_tx(conn); 2524913e5bf4SMike Christie 2525659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 25265d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 25273bbaaad9SMike Christie fail_scsi_tasks(conn, sc->device->lun, DID_ERROR); 2528ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 2529659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2530843c0a8aSMike Christie 2531843c0a8aSMike Christie iscsi_start_tx(conn); 2532843c0a8aSMike Christie goto done; 2533843c0a8aSMike Christie 2534843c0a8aSMike Christie unlock: 2535659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2536843c0a8aSMike Christie done: 2537bd2199d4SErez Zilber ISCSI_DBG_EH(session, "dev reset result = %s\n", 2538843c0a8aSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 2539843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2540843c0a8aSMike Christie return rc; 2541843c0a8aSMike Christie } 2542843c0a8aSMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_device_reset); 2543843c0a8aSMike Christie 25443fe5ae8bSMike Christie void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) 25453fe5ae8bSMike Christie { 25463fe5ae8bSMike Christie struct iscsi_session *session = cls_session->dd_data; 25473fe5ae8bSMike Christie 2548659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 25493fe5ae8bSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 25503fe5ae8bSMike Christie session->state = ISCSI_STATE_RECOVERY_FAILED; 2551ec29d0acSMike Christie wake_up(&session->ehwait); 25523fe5ae8bSMike Christie } 2553659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 25543fe5ae8bSMike Christie } 25553fe5ae8bSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout); 25563fe5ae8bSMike Christie 25573fe5ae8bSMike Christie /** 25583fe5ae8bSMike Christie * iscsi_eh_session_reset - drop session and attempt relogin 25593fe5ae8bSMike Christie * @sc: scsi command 25603fe5ae8bSMike Christie * 25613fe5ae8bSMike Christie * This function will wait for a relogin, session termination from 25623fe5ae8bSMike Christie * userspace, or a recovery/replacement timeout. 25633fe5ae8bSMike Christie */ 2564309ce156SJayamohan Kallickal int iscsi_eh_session_reset(struct scsi_cmnd *sc) 25653fe5ae8bSMike Christie { 25663fe5ae8bSMike Christie struct iscsi_cls_session *cls_session; 25673fe5ae8bSMike Christie struct iscsi_session *session; 25683fe5ae8bSMike Christie struct iscsi_conn *conn; 25693fe5ae8bSMike Christie 25703fe5ae8bSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 25713fe5ae8bSMike Christie session = cls_session->dd_data; 25723fe5ae8bSMike Christie 25733fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2574659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 25753fe5ae8bSMike Christie if (session->state == ISCSI_STATE_TERMINATE) { 25763fe5ae8bSMike Christie failed: 25773fe5ae8bSMike Christie ISCSI_DBG_EH(session, 25783fe5ae8bSMike Christie "failing session reset: Could not log back into " 25795db6dd14SFred Herard "%s [age %d]\n", session->targetname, 25805db6dd14SFred Herard session->age); 2581659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 25823fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 25833fe5ae8bSMike Christie return FAILED; 25843fe5ae8bSMike Christie } 25853fe5ae8bSMike Christie 2586fda290c5SMike Christie conn = session->leadconn; 2587fda290c5SMike Christie iscsi_get_conn(conn->cls_conn); 2588fda290c5SMike Christie 2589659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 25903fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 2591fda290c5SMike Christie 2592df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2593fda290c5SMike Christie iscsi_put_conn(conn->cls_conn); 25943fe5ae8bSMike Christie 25953fe5ae8bSMike Christie ISCSI_DBG_EH(session, "wait for relogin\n"); 2596ec29d0acSMike Christie wait_event_interruptible(session->ehwait, 25973fe5ae8bSMike Christie session->state == ISCSI_STATE_TERMINATE || 25983fe5ae8bSMike Christie session->state == ISCSI_STATE_LOGGED_IN || 25993fe5ae8bSMike Christie session->state == ISCSI_STATE_RECOVERY_FAILED); 26003fe5ae8bSMike Christie if (signal_pending(current)) 26013fe5ae8bSMike Christie flush_signals(current); 26023fe5ae8bSMike Christie 26033fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2604659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 26053fe5ae8bSMike Christie if (session->state == ISCSI_STATE_LOGGED_IN) { 26063fe5ae8bSMike Christie ISCSI_DBG_EH(session, 26073fe5ae8bSMike Christie "session reset succeeded for %s,%s\n", 26083fe5ae8bSMike Christie session->targetname, conn->persistent_address); 26093fe5ae8bSMike Christie } else 26103fe5ae8bSMike Christie goto failed; 2611659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 26123fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 26133fe5ae8bSMike Christie return SUCCESS; 26143fe5ae8bSMike Christie } 2615309ce156SJayamohan Kallickal EXPORT_SYMBOL_GPL(iscsi_eh_session_reset); 26163fe5ae8bSMike Christie 26173fe5ae8bSMike Christie static void iscsi_prep_tgt_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 26183fe5ae8bSMike Christie { 26193fe5ae8bSMike Christie memset(hdr, 0, sizeof(*hdr)); 26203fe5ae8bSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 26213fe5ae8bSMike Christie hdr->flags = ISCSI_TM_FUNC_TARGET_WARM_RESET & ISCSI_FLAG_TM_FUNC_MASK; 26223fe5ae8bSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 26233fe5ae8bSMike Christie hdr->rtt = RESERVED_ITT; 26243fe5ae8bSMike Christie } 26253fe5ae8bSMike Christie 26263fe5ae8bSMike Christie /** 26273fe5ae8bSMike Christie * iscsi_eh_target_reset - reset target 26283fe5ae8bSMike Christie * @sc: scsi command 26293fe5ae8bSMike Christie * 2630309ce156SJayamohan Kallickal * This will attempt to send a warm target reset. 26313fe5ae8bSMike Christie */ 26323907adf6SBart Van Assche static int iscsi_eh_target_reset(struct scsi_cmnd *sc) 26333fe5ae8bSMike Christie { 26343fe5ae8bSMike Christie struct iscsi_cls_session *cls_session; 26353fe5ae8bSMike Christie struct iscsi_session *session; 26363fe5ae8bSMike Christie struct iscsi_conn *conn; 26373fe5ae8bSMike Christie struct iscsi_tm *hdr; 26383fe5ae8bSMike Christie int rc = FAILED; 26393fe5ae8bSMike Christie 26403fe5ae8bSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 26413fe5ae8bSMike Christie session = cls_session->dd_data; 26423fe5ae8bSMike Christie 26433fe5ae8bSMike Christie ISCSI_DBG_EH(session, "tgt Reset [sc %p tgt %s]\n", sc, 26443fe5ae8bSMike Christie session->targetname); 26453fe5ae8bSMike Christie 26463fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2647659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 26483fe5ae8bSMike Christie /* 26493fe5ae8bSMike Christie * Just check if we are not logged in. We cannot check for 26503fe5ae8bSMike Christie * the phase because the reset could come from a ioctl. 26513fe5ae8bSMike Christie */ 26523fe5ae8bSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 26533fe5ae8bSMike Christie goto unlock; 26543fe5ae8bSMike Christie conn = session->leadconn; 26553fe5ae8bSMike Christie 26563fe5ae8bSMike Christie /* only have one tmf outstanding at a time */ 2657ec29d0acSMike Christie if (session->tmf_state != TMF_INITIAL) 26583fe5ae8bSMike Christie goto unlock; 2659ec29d0acSMike Christie session->tmf_state = TMF_QUEUED; 26603fe5ae8bSMike Christie 2661ec29d0acSMike Christie hdr = &session->tmhdr; 26623fe5ae8bSMike Christie iscsi_prep_tgt_reset_pdu(sc, hdr); 26633fe5ae8bSMike Christie 26643fe5ae8bSMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 26653fe5ae8bSMike Christie session->tgt_reset_timeout)) { 26663fe5ae8bSMike Christie rc = FAILED; 26673fe5ae8bSMike Christie goto unlock; 26683fe5ae8bSMike Christie } 26693fe5ae8bSMike Christie 2670ec29d0acSMike Christie switch (session->tmf_state) { 26713fe5ae8bSMike Christie case TMF_SUCCESS: 26723fe5ae8bSMike Christie break; 26733fe5ae8bSMike Christie case TMF_TIMEDOUT: 2674659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2675df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 26763fe5ae8bSMike Christie goto done; 26773fe5ae8bSMike Christie default: 2678ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 26793fe5ae8bSMike Christie goto unlock; 26803fe5ae8bSMike Christie } 26813fe5ae8bSMike Christie 26823fe5ae8bSMike Christie rc = SUCCESS; 2683659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 26843fe5ae8bSMike Christie 26853fe5ae8bSMike Christie iscsi_suspend_tx(conn); 26863fe5ae8bSMike Christie 2687659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 26883fe5ae8bSMike Christie memset(hdr, 0, sizeof(*hdr)); 26893fe5ae8bSMike Christie fail_scsi_tasks(conn, -1, DID_ERROR); 2690ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 2691659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 26923fe5ae8bSMike Christie 26933fe5ae8bSMike Christie iscsi_start_tx(conn); 26943fe5ae8bSMike Christie goto done; 26953fe5ae8bSMike Christie 26963fe5ae8bSMike Christie unlock: 2697659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 26983fe5ae8bSMike Christie done: 26993fe5ae8bSMike Christie ISCSI_DBG_EH(session, "tgt %s reset result = %s\n", session->targetname, 27003fe5ae8bSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 27013fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 2702309ce156SJayamohan Kallickal return rc; 2703309ce156SJayamohan Kallickal } 27043fe5ae8bSMike Christie 2705309ce156SJayamohan Kallickal /** 2706309ce156SJayamohan Kallickal * iscsi_eh_recover_target - reset target and possibly the session 2707309ce156SJayamohan Kallickal * @sc: scsi command 2708309ce156SJayamohan Kallickal * 2709309ce156SJayamohan Kallickal * This will attempt to send a warm target reset. If that fails, 2710309ce156SJayamohan Kallickal * we will escalate to ERL0 session recovery. 2711309ce156SJayamohan Kallickal */ 2712309ce156SJayamohan Kallickal int iscsi_eh_recover_target(struct scsi_cmnd *sc) 2713309ce156SJayamohan Kallickal { 2714309ce156SJayamohan Kallickal int rc; 2715309ce156SJayamohan Kallickal 2716309ce156SJayamohan Kallickal rc = iscsi_eh_target_reset(sc); 27173fe5ae8bSMike Christie if (rc == FAILED) 27183fe5ae8bSMike Christie rc = iscsi_eh_session_reset(sc); 27193fe5ae8bSMike Christie return rc; 27203fe5ae8bSMike Christie } 2721309ce156SJayamohan Kallickal EXPORT_SYMBOL_GPL(iscsi_eh_recover_target); 27223fe5ae8bSMike Christie 27236320377fSOlaf Kirch /* 27246320377fSOlaf Kirch * Pre-allocate a pool of @max items of @item_size. By default, the pool 27256320377fSOlaf Kirch * should be accessed via kfifo_{get,put} on q->queue. 27266320377fSOlaf Kirch * Optionally, the caller can obtain the array of object pointers 27276320377fSOlaf Kirch * by passing in a non-NULL @items pointer 27286320377fSOlaf Kirch */ 27297996a778SMike Christie int 27306320377fSOlaf Kirch iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size) 27317996a778SMike Christie { 27326320377fSOlaf Kirch int i, num_arrays = 1; 27337996a778SMike Christie 27346320377fSOlaf Kirch memset(q, 0, sizeof(*q)); 27357996a778SMike Christie 27367996a778SMike Christie q->max = max; 27376320377fSOlaf Kirch 27386320377fSOlaf Kirch /* If the user passed an items pointer, he wants a copy of 27396320377fSOlaf Kirch * the array. */ 27406320377fSOlaf Kirch if (items) 27416320377fSOlaf Kirch num_arrays++; 2742778e1cddSKees Cook q->pool = kvcalloc(num_arrays * max, sizeof(void *), GFP_KERNEL); 27436320377fSOlaf Kirch if (q->pool == NULL) 2744f474a37bSJean Delvare return -ENOMEM; 27457996a778SMike Christie 2746c1e13f25SStefani Seibold kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*)); 27477996a778SMike Christie 27487996a778SMike Christie for (i = 0; i < max; i++) { 27496320377fSOlaf Kirch q->pool[i] = kzalloc(item_size, GFP_KERNEL); 27507996a778SMike Christie if (q->pool[i] == NULL) { 27516320377fSOlaf Kirch q->max = i; 27526320377fSOlaf Kirch goto enomem; 27537996a778SMike Christie } 27547acd72ebSStefani Seibold kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*)); 27557996a778SMike Christie } 27566320377fSOlaf Kirch 27576320377fSOlaf Kirch if (items) { 27586320377fSOlaf Kirch *items = q->pool + max; 27596320377fSOlaf Kirch memcpy(*items, q->pool, max * sizeof(void *)); 27606320377fSOlaf Kirch } 27616320377fSOlaf Kirch 27627996a778SMike Christie return 0; 27636320377fSOlaf Kirch 27646320377fSOlaf Kirch enomem: 27656320377fSOlaf Kirch iscsi_pool_free(q); 27666320377fSOlaf Kirch return -ENOMEM; 27677996a778SMike Christie } 27687996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_init); 27697996a778SMike Christie 27706320377fSOlaf Kirch void iscsi_pool_free(struct iscsi_pool *q) 27717996a778SMike Christie { 27727996a778SMike Christie int i; 27737996a778SMike Christie 27747996a778SMike Christie for (i = 0; i < q->max; i++) 27756320377fSOlaf Kirch kfree(q->pool[i]); 2776bfcc62edSKyle Fortin kvfree(q->pool); 27777996a778SMike Christie } 27787996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_free); 27797996a778SMike Christie 2780b4046922SMike Christie int iscsi_host_get_max_scsi_cmds(struct Scsi_Host *shost, 2781b4046922SMike Christie uint16_t requested_cmds_max) 2782b4046922SMike Christie { 2783b4046922SMike Christie int scsi_cmds, total_cmds = requested_cmds_max; 2784b4046922SMike Christie 2785b4046922SMike Christie check: 2786b4046922SMike Christie if (!total_cmds) 2787b4046922SMike Christie total_cmds = ISCSI_DEF_XMIT_CMDS_MAX; 2788b4046922SMike Christie /* 2789b4046922SMike Christie * The iscsi layer needs some tasks for nop handling and tmfs, 2790b4046922SMike Christie * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX 2791b4046922SMike Christie * + 1 command for scsi IO. 2792b4046922SMike Christie */ 2793b4046922SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 2794b4046922SMike Christie printk(KERN_ERR "iscsi: invalid max cmds of %d. Must be a power of two that is at least %d.\n", 2795b4046922SMike Christie total_cmds, ISCSI_TOTAL_CMDS_MIN); 2796b4046922SMike Christie return -EINVAL; 2797b4046922SMike Christie } 2798b4046922SMike Christie 2799b4046922SMike Christie if (total_cmds > ISCSI_TOTAL_CMDS_MAX) { 2800b4046922SMike 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", 2801b4046922SMike Christie requested_cmds_max, ISCSI_TOTAL_CMDS_MAX, 2802b4046922SMike Christie ISCSI_TOTAL_CMDS_MAX); 2803b4046922SMike Christie total_cmds = ISCSI_TOTAL_CMDS_MAX; 2804b4046922SMike Christie } 2805b4046922SMike Christie 2806b4046922SMike Christie if (!is_power_of_2(total_cmds)) { 2807b4046922SMike Christie total_cmds = rounddown_pow_of_two(total_cmds); 2808b4046922SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 2809b4046922SMike 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); 2810b4046922SMike Christie return -EINVAL; 2811b4046922SMike Christie } 2812b4046922SMike Christie 2813b4046922SMike Christie printk(KERN_INFO "iscsi: invalid max cmds %d. Must be a power of 2. Rounding max cmds down to %d.\n", 2814b4046922SMike Christie requested_cmds_max, total_cmds); 2815b4046922SMike Christie } 2816b4046922SMike Christie 2817b4046922SMike Christie scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX; 2818b4046922SMike Christie if (shost->can_queue && scsi_cmds > shost->can_queue) { 2819b4046922SMike Christie total_cmds = shost->can_queue; 2820b4046922SMike Christie 2821b4046922SMike Christie printk(KERN_INFO "iscsi: requested max cmds %u is higher than driver limit. Using driver limit %u\n", 2822b4046922SMike Christie requested_cmds_max, shost->can_queue); 2823b4046922SMike Christie goto check; 2824b4046922SMike Christie } 2825b4046922SMike Christie 2826b4046922SMike Christie return scsi_cmds; 2827b4046922SMike Christie } 2828b4046922SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_max_scsi_cmds); 2829b4046922SMike Christie 2830a4804cd6SMike Christie /** 2831a4804cd6SMike Christie * iscsi_host_add - add host to system 2832a4804cd6SMike Christie * @shost: scsi host 2833a4804cd6SMike Christie * @pdev: parent device 2834a4804cd6SMike Christie * 2835a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers 2836a4804cd6SMike Christie * to add a host to the system. 2837a4804cd6SMike Christie */ 2838a4804cd6SMike Christie int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev) 28397996a778SMike Christie { 28408e9a20ceSMike Christie if (!shost->can_queue) 28418e9a20ceSMike Christie shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX; 28428e9a20ceSMike Christie 28434d108350SMike Christie if (!shost->cmd_per_lun) 28444d108350SMike Christie shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN; 28454d108350SMike Christie 2846a4804cd6SMike Christie return scsi_add_host(shost, pdev); 2847a4804cd6SMike Christie } 2848a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_add); 2849a4804cd6SMike Christie 2850a4804cd6SMike Christie /** 2851a4804cd6SMike Christie * iscsi_host_alloc - allocate a host and driver data 2852a4804cd6SMike Christie * @sht: scsi host template 2853a4804cd6SMike Christie * @dd_data_size: driver host data size 285432ae763eSMike Christie * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue 2855a4804cd6SMike Christie * 2856a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers. 2857a4804cd6SMike Christie * To access the driver specific memory use the iscsi_host_priv() macro. 2858a4804cd6SMike Christie */ 2859a4804cd6SMike Christie struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht, 28604d108350SMike Christie int dd_data_size, bool xmit_can_sleep) 2861a4804cd6SMike Christie { 2862a4804cd6SMike Christie struct Scsi_Host *shost; 2863e5bd7b54SMike Christie struct iscsi_host *ihost; 2864a4804cd6SMike Christie 2865a4804cd6SMike Christie shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size); 2866a4804cd6SMike Christie if (!shost) 2867a4804cd6SMike Christie return NULL; 2868e5bd7b54SMike Christie ihost = shost_priv(shost); 286932ae763eSMike Christie 287032ae763eSMike Christie if (xmit_can_sleep) { 287169af1c95SMike Christie ihost->workq = alloc_workqueue("iscsi_q_%d", 28723ce41966SBob Liu WQ_SYSFS | __WQ_LEGACY | WQ_MEM_RECLAIM | WQ_UNBOUND, 287369af1c95SMike Christie 1, shost->host_no); 287432ae763eSMike Christie if (!ihost->workq) 287532ae763eSMike Christie goto free_host; 287632ae763eSMike Christie } 287732ae763eSMike Christie 2878e5bd7b54SMike Christie spin_lock_init(&ihost->lock); 2879e5bd7b54SMike Christie ihost->state = ISCSI_HOST_SETUP; 2880e5bd7b54SMike Christie ihost->num_sessions = 0; 2881e5bd7b54SMike Christie init_waitqueue_head(&ihost->session_removal_wq); 2882a4804cd6SMike Christie return shost; 288332ae763eSMike Christie 288432ae763eSMike Christie free_host: 288532ae763eSMike Christie scsi_host_put(shost); 288632ae763eSMike Christie return NULL; 288775613521SMike Christie } 2888a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_alloc); 288975613521SMike Christie 2890e5bd7b54SMike Christie static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session) 2891e5bd7b54SMike Christie { 289240a06e75SMike Christie iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST); 2893e5bd7b54SMike Christie } 2894e5bd7b54SMike Christie 2895a4804cd6SMike Christie /** 2896a4804cd6SMike Christie * iscsi_host_remove - remove host and sessions 2897a4804cd6SMike Christie * @shost: scsi host 289831500e90SMike Christie * @is_shutdown: true if called from a driver shutdown callout 2899a4804cd6SMike Christie * 2900e5bd7b54SMike Christie * If there are any sessions left, this will initiate the removal and wait 2901e5bd7b54SMike Christie * for the completion. 2902a4804cd6SMike Christie */ 290331500e90SMike Christie void iscsi_host_remove(struct Scsi_Host *shost, bool is_shutdown) 2904a4804cd6SMike Christie { 2905e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2906e5bd7b54SMike Christie unsigned long flags; 2907e5bd7b54SMike Christie 2908e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2909e5bd7b54SMike Christie ihost->state = ISCSI_HOST_REMOVED; 2910e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2911e5bd7b54SMike Christie 291231500e90SMike Christie if (!is_shutdown) 2913e5bd7b54SMike Christie iscsi_host_for_each_session(shost, iscsi_notify_host_removed); 291431500e90SMike Christie else 291531500e90SMike Christie iscsi_host_for_each_session(shost, iscsi_force_destroy_session); 291631500e90SMike Christie 2917e5bd7b54SMike Christie wait_event_interruptible(ihost->session_removal_wq, 2918e5bd7b54SMike Christie ihost->num_sessions == 0); 2919e5bd7b54SMike Christie if (signal_pending(current)) 2920e5bd7b54SMike Christie flush_signals(current); 2921e5bd7b54SMike Christie 2922a4804cd6SMike Christie scsi_remove_host(shost); 2923a4804cd6SMike Christie } 2924a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_remove); 2925a4804cd6SMike Christie 2926a4804cd6SMike Christie void iscsi_host_free(struct Scsi_Host *shost) 292775613521SMike Christie { 292875613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 292975613521SMike Christie 2930c435f0a9SMike Christie if (ihost->workq) 2931c435f0a9SMike Christie destroy_workqueue(ihost->workq); 2932c435f0a9SMike Christie 293375613521SMike Christie kfree(ihost->netdev); 293475613521SMike Christie kfree(ihost->hwaddress); 293575613521SMike Christie kfree(ihost->initiatorname); 2936a4804cd6SMike Christie scsi_host_put(shost); 293775613521SMike Christie } 2938a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_free); 293975613521SMike Christie 2940e5bd7b54SMike Christie static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost) 2941e5bd7b54SMike Christie { 2942e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2943e5bd7b54SMike Christie unsigned long flags; 2944e5bd7b54SMike Christie 2945e5bd7b54SMike Christie shost = scsi_host_get(shost); 2946e5bd7b54SMike Christie if (!shost) { 2947e5bd7b54SMike Christie printk(KERN_ERR "Invalid state. Cannot notify host removal " 2948e5bd7b54SMike Christie "of session teardown event because host already " 2949e5bd7b54SMike Christie "removed.\n"); 2950e5bd7b54SMike Christie return; 2951e5bd7b54SMike Christie } 2952e5bd7b54SMike Christie 2953e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2954e5bd7b54SMike Christie ihost->num_sessions--; 2955e5bd7b54SMike Christie if (ihost->num_sessions == 0) 2956e5bd7b54SMike Christie wake_up(&ihost->session_removal_wq); 2957e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2958e5bd7b54SMike Christie scsi_host_put(shost); 2959e5bd7b54SMike Christie } 2960e5bd7b54SMike Christie 296175613521SMike Christie /** 296275613521SMike Christie * iscsi_session_setup - create iscsi cls session and host and session 296375613521SMike Christie * @iscsit: iscsi transport template 296475613521SMike Christie * @shost: scsi host 296575613521SMike Christie * @cmds_max: session can queue 2966ccd4a430SRandy Dunlap * @dd_size: private driver data size, added to session allocation size 29679c19a7d0SMike Christie * @cmd_task_size: LLD task private data size 296875613521SMike Christie * @initial_cmdsn: initial CmdSN 2969ccd4a430SRandy Dunlap * @id: target ID to add to this session 297075613521SMike Christie * 297175613521SMike Christie * This can be used by software iscsi_transports that allocate 297275613521SMike Christie * a session per scsi host. 29733cf7b233SMike Christie * 29743cf7b233SMike Christie * Callers should set cmds_max to the largest total numer (mgmt + scsi) of 29753cf7b233SMike Christie * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks 29763cf7b233SMike Christie * for nop handling and login/logout requests. 297775613521SMike Christie */ 297875613521SMike Christie struct iscsi_cls_session * 297975613521SMike Christie iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, 2980b8b9e1b8SJayamohan Kallickal uint16_t cmds_max, int dd_size, int cmd_task_size, 29817970634bSMike Christie uint32_t initial_cmdsn, unsigned int id) 298275613521SMike Christie { 2983e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 298475613521SMike Christie struct iscsi_session *session; 298575613521SMike Christie struct iscsi_cls_session *cls_session; 2986b4046922SMike Christie int cmd_i, scsi_cmds; 2987e5bd7b54SMike Christie unsigned long flags; 2988e5bd7b54SMike Christie 2989e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2990e5bd7b54SMike Christie if (ihost->state == ISCSI_HOST_REMOVED) { 2991e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2992e5bd7b54SMike Christie return NULL; 2993e5bd7b54SMike Christie } 2994e5bd7b54SMike Christie ihost->num_sessions++; 2995e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 29968e9a20ceSMike Christie 2997b4046922SMike Christie scsi_cmds = iscsi_host_get_max_scsi_cmds(shost, cmds_max); 2998b4046922SMike Christie if (scsi_cmds < 0) 2999e5bd7b54SMike Christie goto dec_session_count; 30001548271eSMike Christie 30015d91e209SMike Christie cls_session = iscsi_alloc_session(shost, iscsit, 3002b8b9e1b8SJayamohan Kallickal sizeof(struct iscsi_session) + 3003b8b9e1b8SJayamohan Kallickal dd_size); 300475613521SMike Christie if (!cls_session) 3005e5bd7b54SMike Christie goto dec_session_count; 300675613521SMike Christie session = cls_session->dd_data; 300775613521SMike Christie session->cls_session = cls_session; 30087996a778SMike Christie session->host = shost; 30097996a778SMike Christie session->state = ISCSI_STATE_FREE; 3010f6d5180cSMike Christie session->fast_abort = 1; 30113fe5ae8bSMike Christie session->tgt_reset_timeout = 30; 30124cd49ea1SMike Christie session->lu_reset_timeout = 15; 30134cd49ea1SMike Christie session->abort_timeout = 10; 30143cf7b233SMike Christie session->scsi_cmds_max = scsi_cmds; 3015b4046922SMike Christie session->cmds_max = scsi_cmds + ISCSI_MGMT_CMDS_MAX; 3016e0726407SMike Christie session->queued_cmdsn = session->cmdsn = initial_cmdsn; 30177996a778SMike Christie session->exp_cmdsn = initial_cmdsn + 1; 30187996a778SMike Christie session->max_cmdsn = initial_cmdsn + 1; 30197996a778SMike Christie session->max_r2t = 1; 30207996a778SMike Christie session->tt = iscsit; 3021b8b9e1b8SJayamohan Kallickal session->dd_data = cls_session->dd_data + sizeof(*session); 3022659743b0SShlomo Pongratz 3023ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 3024ec29d0acSMike Christie timer_setup(&session->tmf_timer, iscsi_tmf_timedout, 0); 30256724add1SMike Christie mutex_init(&session->eh_mutex); 3026e018f03dSDing Hui init_waitqueue_head(&session->ehwait); 3027ec29d0acSMike Christie 3028659743b0SShlomo Pongratz spin_lock_init(&session->frwd_lock); 3029659743b0SShlomo Pongratz spin_lock_init(&session->back_lock); 30307996a778SMike Christie 30317996a778SMike Christie /* initialize SCSI PDU commands pool */ 30327996a778SMike Christie if (iscsi_pool_init(&session->cmdpool, session->cmds_max, 30337996a778SMike Christie (void***)&session->cmds, 30349c19a7d0SMike Christie cmd_task_size + sizeof(struct iscsi_task))) 30357996a778SMike Christie goto cmdpool_alloc_fail; 30367996a778SMike Christie 30377996a778SMike Christie /* pre-format cmds pool with ITT */ 30387996a778SMike Christie for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) { 30399c19a7d0SMike Christie struct iscsi_task *task = session->cmds[cmd_i]; 30407996a778SMike Christie 30419c19a7d0SMike Christie if (cmd_task_size) 30429c19a7d0SMike Christie task->dd_data = &task[1]; 30439c19a7d0SMike Christie task->itt = cmd_i; 30443bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 30459c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 30467996a778SMike Christie } 30477996a778SMike Christie 3048f53a88daSMike Christie if (!try_module_get(iscsit->owner)) 304975613521SMike Christie goto module_get_fail; 305075613521SMike Christie 30517970634bSMike Christie if (iscsi_add_session(cls_session, id)) 3052f53a88daSMike Christie goto cls_session_fail; 3053e5bd7b54SMike Christie 30547996a778SMike Christie return cls_session; 30557996a778SMike Christie 30567996a778SMike Christie cls_session_fail: 305775613521SMike Christie module_put(iscsit->owner); 305875613521SMike Christie module_get_fail: 30596320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 30607996a778SMike Christie cmdpool_alloc_fail: 306175613521SMike Christie iscsi_free_session(cls_session); 3062e5bd7b54SMike Christie dec_session_count: 3063e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 30647996a778SMike Christie return NULL; 30657996a778SMike Christie } 30667996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_setup); 30677996a778SMike Christie 30687996a778SMike Christie /** 30697996a778SMike Christie * iscsi_session_teardown - destroy session, host, and cls_session 307075613521SMike Christie * @cls_session: iscsi session 307175613521SMike Christie */ 30727996a778SMike Christie void iscsi_session_teardown(struct iscsi_cls_session *cls_session) 30737996a778SMike Christie { 307475613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 307563f75cc8SMike Christie struct module *owner = cls_session->transport->owner; 3076e5bd7b54SMike Christie struct Scsi_Host *shost = session->host; 30777996a778SMike Christie 30789e10b512SKhazhismel Kumykov iscsi_remove_session(cls_session); 30799e10b512SKhazhismel Kumykov 3080a1f3486bSMike Christie iscsi_pool_free(&session->cmdpool); 3081b2c64167SMike Christie kfree(session->password); 3082b2c64167SMike Christie kfree(session->password_in); 3083b2c64167SMike Christie kfree(session->username); 3084b2c64167SMike Christie kfree(session->username_in); 3085f3ff0c36SMike Christie kfree(session->targetname); 30863c5c4801SVikas Chaudhary kfree(session->targetalias); 308788dfd340SMike Christie kfree(session->initiatorname); 30883b9373e9SEddie Wai kfree(session->boot_root); 30893b9373e9SEddie Wai kfree(session->boot_nic); 30903b9373e9SEddie Wai kfree(session->boot_target); 309188dfd340SMike Christie kfree(session->ifacename); 3092f8525eb4SAdheer Chandravanshi kfree(session->portal_type); 3093f8525eb4SAdheer Chandravanshi kfree(session->discovery_parent_type); 3094f3ff0c36SMike Christie 30959e10b512SKhazhismel Kumykov iscsi_free_session(cls_session); 30969e10b512SKhazhismel Kumykov 3097e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 309863f75cc8SMike Christie module_put(owner); 30997996a778SMike Christie } 31007996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_teardown); 31017996a778SMike Christie 31027996a778SMike Christie /** 31037996a778SMike Christie * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn 31047996a778SMike Christie * @cls_session: iscsi_cls_session 31055d91e209SMike Christie * @dd_size: private driver data size 31067996a778SMike Christie * @conn_idx: cid 31075d91e209SMike Christie */ 31087996a778SMike Christie struct iscsi_cls_conn * 31095d91e209SMike Christie iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, 31105d91e209SMike Christie uint32_t conn_idx) 31117996a778SMike Christie { 311275613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 31137996a778SMike Christie struct iscsi_conn *conn; 31147996a778SMike Christie struct iscsi_cls_conn *cls_conn; 3115d36ab6f3SMike Christie char *data; 31167dae459fSWenchao Hao int err; 31177996a778SMike Christie 31187dae459fSWenchao Hao cls_conn = iscsi_alloc_conn(cls_session, sizeof(*conn) + dd_size, 31195d91e209SMike Christie conn_idx); 31207996a778SMike Christie if (!cls_conn) 31217996a778SMike Christie return NULL; 31227996a778SMike Christie conn = cls_conn->dd_data; 31237996a778SMike Christie 31245d91e209SMike Christie conn->dd_data = cls_conn->dd_data + sizeof(*conn); 31257996a778SMike Christie conn->session = session; 31267996a778SMike Christie conn->cls_conn = cls_conn; 31277996a778SMike Christie conn->c_stage = ISCSI_CONN_INITIAL_STAGE; 31287996a778SMike Christie conn->id = conn_idx; 31297996a778SMike Christie conn->exp_statsn = 0; 3130f6d5180cSMike Christie 31312c4b9637SKees Cook timer_setup(&conn->transport_timer, iscsi_check_transport_timeouts, 0); 3132f6d5180cSMike Christie 3133843c0a8aSMike Christie INIT_LIST_HEAD(&conn->mgmtqueue); 31343bbaaad9SMike Christie INIT_LIST_HEAD(&conn->cmdqueue); 3135843c0a8aSMike Christie INIT_LIST_HEAD(&conn->requeue); 3136c4028958SDavid Howells INIT_WORK(&conn->xmitwork, iscsi_xmitworker); 31377996a778SMike Christie 31389c19a7d0SMike Christie /* allocate login_task used for the login/text sequences */ 3139659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 31407acd72ebSStefani Seibold if (!kfifo_out(&session->cmdpool.queue, 31419c19a7d0SMike Christie (void*)&conn->login_task, 31427996a778SMike Christie sizeof(void*))) { 3143659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31449c19a7d0SMike Christie goto login_task_alloc_fail; 31457996a778SMike Christie } 3146659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31477996a778SMike Christie 3148cfeb2cf9SMike Christie data = (char *) __get_free_pages(GFP_KERNEL, 3149cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 3150d36ab6f3SMike Christie if (!data) 31519c19a7d0SMike Christie goto login_task_data_alloc_fail; 31529c19a7d0SMike Christie conn->login_task->data = conn->data = data; 3153d36ab6f3SMike Christie 31547dae459fSWenchao Hao err = iscsi_add_conn(cls_conn); 31557dae459fSWenchao Hao if (err) 31567dae459fSWenchao Hao goto login_task_add_dev_fail; 31577dae459fSWenchao Hao 31587996a778SMike Christie return cls_conn; 31597996a778SMike Christie 31607dae459fSWenchao Hao login_task_add_dev_fail: 31617dae459fSWenchao Hao free_pages((unsigned long) conn->data, 31627dae459fSWenchao Hao get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 31637dae459fSWenchao Hao 31649c19a7d0SMike Christie login_task_data_alloc_fail: 31657acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 3166d36ab6f3SMike Christie sizeof(void*)); 31679c19a7d0SMike Christie login_task_alloc_fail: 31687dae459fSWenchao Hao iscsi_put_conn(cls_conn); 31697996a778SMike Christie return NULL; 31707996a778SMike Christie } 31717996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_setup); 31727996a778SMike Christie 31737996a778SMike Christie /** 31747996a778SMike Christie * iscsi_conn_teardown - teardown iscsi connection 3175ccd4a430SRandy Dunlap * @cls_conn: iscsi class connection 31767996a778SMike Christie * 31777996a778SMike Christie * TODO: we may need to make this into a two step process 31787996a778SMike Christie * like scsi-mls remove + put host 31797996a778SMike Christie */ 31807996a778SMike Christie void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) 31817996a778SMike Christie { 31827996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 31837996a778SMike Christie struct iscsi_session *session = conn->session; 31848709c323SWenchao Hao 31858709c323SWenchao Hao iscsi_remove_conn(cls_conn); 31867996a778SMike Christie 3187f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 3188f6d5180cSMike Christie 3189660d0831SJohn Soni Jose mutex_lock(&session->eh_mutex); 3190659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 31917996a778SMike Christie conn->c_stage = ISCSI_CONN_CLEANUP_WAIT; 31927996a778SMike Christie if (session->leadconn == conn) { 31937996a778SMike Christie /* 31947996a778SMike Christie * leading connection? then give up on recovery. 31957996a778SMike Christie */ 31967996a778SMike Christie session->state = ISCSI_STATE_TERMINATE; 3197ec29d0acSMike Christie wake_up(&session->ehwait); 31987996a778SMike Christie } 3199659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 32007996a778SMike Christie 3201779ea120SMike Christie /* flush queued up work because we free the connection below */ 3202843c0a8aSMike Christie iscsi_suspend_tx(conn); 3203779ea120SMike Christie 3204659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 3205cfeb2cf9SMike Christie free_pages((unsigned long) conn->data, 3206cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 32078709c323SWenchao Hao kfree(conn->persistent_address); 32088709c323SWenchao Hao kfree(conn->local_ipaddr); 3209659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 3210659743b0SShlomo Pongratz spin_lock_bh(&session->back_lock); 32117acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 32127996a778SMike Christie sizeof(void*)); 3213659743b0SShlomo Pongratz spin_unlock_bh(&session->back_lock); 3214e0726407SMike Christie if (session->leadconn == conn) 32157996a778SMike Christie session->leadconn = NULL; 3216659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 3217660d0831SJohn Soni Jose mutex_unlock(&session->eh_mutex); 32187996a778SMike Christie 32198709c323SWenchao Hao iscsi_put_conn(cls_conn); 32207996a778SMike Christie } 32217996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_teardown); 32227996a778SMike Christie 32237996a778SMike Christie int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 32247996a778SMike Christie { 32257996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 32267996a778SMike Christie struct iscsi_session *session = conn->session; 32277996a778SMike Christie 3228ffd0436eSMike Christie if (!session) { 3229322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 3230322d739dSMike Christie "can't start unbound connection\n"); 32317996a778SMike Christie return -EPERM; 32327996a778SMike Christie } 32337996a778SMike Christie 3234db98ccdeSMike Christie if ((session->imm_data_en || !session->initial_r2t_en) && 3235db98ccdeSMike Christie session->first_burst > session->max_burst) { 3236322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: " 3237ffd0436eSMike Christie "first_burst %d max_burst %d\n", 3238ffd0436eSMike Christie session->first_burst, session->max_burst); 3239ffd0436eSMike Christie return -EINVAL; 3240ffd0436eSMike Christie } 3241ffd0436eSMike Christie 3242f6d5180cSMike Christie if (conn->ping_timeout && !conn->recv_timeout) { 3243322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of " 3244322d739dSMike Christie "zero. Using 5 seconds\n."); 3245f6d5180cSMike Christie conn->recv_timeout = 5; 3246f6d5180cSMike Christie } 3247f6d5180cSMike Christie 3248f6d5180cSMike Christie if (conn->recv_timeout && !conn->ping_timeout) { 3249322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of " 3250322d739dSMike Christie "zero. Using 5 seconds.\n"); 3251f6d5180cSMike Christie conn->ping_timeout = 5; 3252f6d5180cSMike Christie } 3253f6d5180cSMike Christie 3254659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 32557996a778SMike Christie conn->c_stage = ISCSI_CONN_STARTED; 32567996a778SMike Christie session->state = ISCSI_STATE_LOGGED_IN; 3257e0726407SMike Christie session->queued_cmdsn = session->cmdsn; 32587996a778SMike Christie 3259f6d5180cSMike Christie conn->last_recv = jiffies; 3260f6d5180cSMike Christie conn->last_ping = jiffies; 3261f6d5180cSMike Christie if (conn->recv_timeout && conn->ping_timeout) 3262f6d5180cSMike Christie mod_timer(&conn->transport_timer, 3263f6d5180cSMike Christie jiffies + (conn->recv_timeout * HZ)); 3264f6d5180cSMike Christie 32657996a778SMike Christie switch(conn->stop_stage) { 32667996a778SMike Christie case STOP_CONN_RECOVER: 32677996a778SMike Christie /* 32687996a778SMike Christie * unblock eh_abort() if it is blocked. re-try all 32697996a778SMike Christie * commands after successful recovery 32707996a778SMike Christie */ 32717996a778SMike Christie conn->stop_stage = 0; 3272ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 32737996a778SMike Christie session->age++; 32748b1d0343SMike Christie if (session->age == 16) 32758b1d0343SMike Christie session->age = 0; 32766eabafbeSMike Christie break; 32777996a778SMike Christie case STOP_CONN_TERM: 32787996a778SMike Christie conn->stop_stage = 0; 32797996a778SMike Christie break; 32807996a778SMike Christie default: 32817996a778SMike Christie break; 32827996a778SMike Christie } 3283659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 32847996a778SMike Christie 328575613521SMike Christie iscsi_unblock_session(session->cls_session); 3286ec29d0acSMike Christie wake_up(&session->ehwait); 32877996a778SMike Christie return 0; 32887996a778SMike Christie } 32897996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_start); 32907996a778SMike Christie 32917996a778SMike Christie static void 32923bbaaad9SMike Christie fail_mgmt_tasks(struct iscsi_session *session, struct iscsi_conn *conn) 32937996a778SMike Christie { 32943bbaaad9SMike Christie struct iscsi_task *task; 3295b3cd5050SMike Christie int i, state; 32967996a778SMike Christie 32973bbaaad9SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 32983bbaaad9SMike Christie task = conn->session->cmds[i]; 32993bbaaad9SMike Christie if (task->sc) 33003bbaaad9SMike Christie continue; 33013bbaaad9SMike Christie 33023bbaaad9SMike Christie if (task->state == ISCSI_TASK_FREE) 33033bbaaad9SMike Christie continue; 33043bbaaad9SMike Christie 33053bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, 33063bbaaad9SMike Christie "failing mgmt itt 0x%x state %d\n", 33073bbaaad9SMike Christie task->itt, task->state); 33085923d64bSMike Christie 33095923d64bSMike Christie spin_lock_bh(&session->back_lock); 33105923d64bSMike Christie if (cleanup_queued_task(task)) { 33115923d64bSMike Christie spin_unlock_bh(&session->back_lock); 33125923d64bSMike Christie continue; 33135923d64bSMike Christie } 33145923d64bSMike Christie 3315b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 3316b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) 3317b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 3318b3cd5050SMike Christie iscsi_complete_task(task, state); 3319a656183eSLee Duncan spin_unlock_bh(&session->back_lock); 33207996a778SMike Christie } 33217996a778SMike Christie } 33227996a778SMike Christie 33230dcf8febSMike Christie void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 33247996a778SMike Christie { 33250dcf8febSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 33260dcf8febSMike Christie struct iscsi_session *session = conn->session; 3327ed2abc7fSMike Christie int old_stop_stage; 3328ed2abc7fSMike Christie 33296724add1SMike Christie mutex_lock(&session->eh_mutex); 3330659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 3331ed2abc7fSMike Christie if (conn->stop_stage == STOP_CONN_TERM) { 3332659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 33336724add1SMike Christie mutex_unlock(&session->eh_mutex); 33346724add1SMike Christie return; 33356724add1SMike Christie } 33366724add1SMike Christie 33376724add1SMike Christie /* 3338ed2abc7fSMike Christie * When this is called for the in_login state, we only want to clean 33399c19a7d0SMike Christie * up the login task and connection. We do not need to block and set 334067a61114SMike Christie * the recovery state again 3341ed2abc7fSMike Christie */ 334267a61114SMike Christie if (flag == STOP_CONN_TERM) 334367a61114SMike Christie session->state = ISCSI_STATE_TERMINATE; 334467a61114SMike Christie else if (conn->stop_stage != STOP_CONN_RECOVER) 334567a61114SMike Christie session->state = ISCSI_STATE_IN_RECOVERY; 33464ae0a6c1SMike Christie 33474ae0a6c1SMike Christie old_stop_stage = conn->stop_stage; 33484ae0a6c1SMike Christie conn->stop_stage = flag; 3349659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 3350ed2abc7fSMike Christie 335126013ad4SMike Christie del_timer_sync(&conn->transport_timer); 335226013ad4SMike Christie iscsi_suspend_tx(conn); 335326013ad4SMike Christie 3354659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 335567a61114SMike Christie conn->c_stage = ISCSI_CONN_STOPPED; 3356659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 33576724add1SMike Christie 33587996a778SMike Christie /* 33597996a778SMike Christie * for connection level recovery we should not calculate 33607996a778SMike Christie * header digest. conn->hdr_size used for optimization 33617996a778SMike Christie * in hdr_extract() and will be re-negotiated at 33627996a778SMike Christie * set_param() time. 33637996a778SMike Christie */ 33647996a778SMike Christie if (flag == STOP_CONN_RECOVER) { 33657996a778SMike Christie conn->hdrdgst_en = 0; 33667996a778SMike Christie conn->datadgst_en = 0; 3367656cffc9SMike Christie if (session->state == ISCSI_STATE_IN_RECOVERY && 336867a61114SMike Christie old_stop_stage != STOP_CONN_RECOVER) { 33691b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "blocking session\n"); 337075613521SMike Christie iscsi_block_session(session->cls_session); 33717996a778SMike Christie } 337267a61114SMike Christie } 3373656cffc9SMike Christie 3374656cffc9SMike Christie /* 3375656cffc9SMike Christie * flush queues. 3376656cffc9SMike Christie */ 3377659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 33783bbaaad9SMike Christie fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED); 33793bbaaad9SMike Christie fail_mgmt_tasks(session, conn); 3380ec29d0acSMike Christie memset(&session->tmhdr, 0, sizeof(session->tmhdr)); 3381659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 33826724add1SMike Christie mutex_unlock(&session->eh_mutex); 33837996a778SMike Christie } 33847996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_stop); 33857996a778SMike Christie 33867996a778SMike Christie int iscsi_conn_bind(struct iscsi_cls_session *cls_session, 33877996a778SMike Christie struct iscsi_cls_conn *cls_conn, int is_leading) 33887996a778SMike Christie { 338975613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 339098644047SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 33917996a778SMike Christie 3392659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 33937996a778SMike Christie if (is_leading) 33947996a778SMike Christie session->leadconn = conn; 339544ac9710SMike Christie 339644ac9710SMike Christie set_bit(ISCSI_CONN_FLAG_BOUND, &conn->flags); 3397659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 33987996a778SMike Christie 33997996a778SMike Christie /* 3400c8447e4cSMike Christie * The target could have reduced it's window size between logins, so 3401c8447e4cSMike Christie * we have to reset max/exp cmdsn so we can see the new values. 3402c8447e4cSMike Christie */ 3403c8447e4cSMike Christie spin_lock_bh(&session->back_lock); 3404c8447e4cSMike Christie session->max_cmdsn = session->exp_cmdsn = session->cmdsn + 1; 3405c8447e4cSMike Christie spin_unlock_bh(&session->back_lock); 3406c8447e4cSMike Christie /* 34077996a778SMike Christie * Unblock xmitworker(), Login Phase will pass through. 34087996a778SMike Christie */ 34095bd85625SMike Christie clear_bit(ISCSI_CONN_FLAG_SUSPEND_RX, &conn->flags); 34105bd85625SMike Christie clear_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags); 34117996a778SMike Christie return 0; 34127996a778SMike Christie } 34137996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_bind); 34147996a778SMike Christie 3415adaf6990SAdheer Chandravanshi int iscsi_switch_str_param(char **param, char *new_val_buf) 34165700b1afSMike Christie { 34175700b1afSMike Christie char *new_val; 34185700b1afSMike Christie 34195700b1afSMike Christie if (*param) { 34205700b1afSMike Christie if (!strcmp(*param, new_val_buf)) 34215700b1afSMike Christie return 0; 34225700b1afSMike Christie } 34235700b1afSMike Christie 34245700b1afSMike Christie new_val = kstrdup(new_val_buf, GFP_NOIO); 34255700b1afSMike Christie if (!new_val) 34265700b1afSMike Christie return -ENOMEM; 34275700b1afSMike Christie 34285700b1afSMike Christie kfree(*param); 34295700b1afSMike Christie *param = new_val; 34305700b1afSMike Christie return 0; 34315700b1afSMike Christie } 3432adaf6990SAdheer Chandravanshi EXPORT_SYMBOL_GPL(iscsi_switch_str_param); 3433a54a52caSMike Christie 3434a54a52caSMike Christie int iscsi_set_param(struct iscsi_cls_conn *cls_conn, 3435a54a52caSMike Christie enum iscsi_param param, char *buf, int buflen) 3436a54a52caSMike Christie { 3437a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 3438a54a52caSMike Christie struct iscsi_session *session = conn->session; 34396a06a4b8SOr Gerlitz int val; 3440a54a52caSMike Christie 3441a54a52caSMike Christie switch(param) { 3442843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 3443843c0a8aSMike Christie sscanf(buf, "%d", &session->fast_abort); 3444843c0a8aSMike Christie break; 3445f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 3446f6d5180cSMike Christie sscanf(buf, "%d", &session->abort_timeout); 3447f6d5180cSMike Christie break; 3448f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 3449f6d5180cSMike Christie sscanf(buf, "%d", &session->lu_reset_timeout); 3450f6d5180cSMike Christie break; 34513fe5ae8bSMike Christie case ISCSI_PARAM_TGT_RESET_TMO: 34523fe5ae8bSMike Christie sscanf(buf, "%d", &session->tgt_reset_timeout); 34533fe5ae8bSMike Christie break; 3454f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 3455f6d5180cSMike Christie sscanf(buf, "%d", &conn->ping_timeout); 3456f6d5180cSMike Christie break; 3457f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 3458f6d5180cSMike Christie sscanf(buf, "%d", &conn->recv_timeout); 3459f6d5180cSMike Christie break; 3460a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 3461a54a52caSMike Christie sscanf(buf, "%d", &conn->max_recv_dlength); 3462a54a52caSMike Christie break; 3463a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3464a54a52caSMike Christie sscanf(buf, "%d", &conn->max_xmit_dlength); 3465a54a52caSMike Christie break; 3466a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 3467a54a52caSMike Christie sscanf(buf, "%d", &conn->hdrdgst_en); 3468a54a52caSMike Christie break; 3469a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 3470a54a52caSMike Christie sscanf(buf, "%d", &conn->datadgst_en); 3471a54a52caSMike Christie break; 3472a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 3473a54a52caSMike Christie sscanf(buf, "%d", &session->initial_r2t_en); 3474a54a52caSMike Christie break; 3475a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 34761304be5fSMike Christie sscanf(buf, "%hu", &session->max_r2t); 3477a54a52caSMike Christie break; 3478a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 3479a54a52caSMike Christie sscanf(buf, "%d", &session->imm_data_en); 3480a54a52caSMike Christie break; 3481a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 3482a54a52caSMike Christie sscanf(buf, "%d", &session->first_burst); 3483a54a52caSMike Christie break; 3484a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 3485a54a52caSMike Christie sscanf(buf, "%d", &session->max_burst); 3486a54a52caSMike Christie break; 3487a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 3488a54a52caSMike Christie sscanf(buf, "%d", &session->pdu_inorder_en); 3489a54a52caSMike Christie break; 3490a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 3491a54a52caSMike Christie sscanf(buf, "%d", &session->dataseq_inorder_en); 3492a54a52caSMike Christie break; 3493a54a52caSMike Christie case ISCSI_PARAM_ERL: 3494a54a52caSMike Christie sscanf(buf, "%d", &session->erl); 3495a54a52caSMike Christie break; 3496a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 3497a54a52caSMike Christie sscanf(buf, "%u", &conn->exp_statsn); 3498a54a52caSMike Christie break; 3499b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 35005700b1afSMike Christie return iscsi_switch_str_param(&session->username, buf); 3501b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 35025700b1afSMike Christie return iscsi_switch_str_param(&session->username_in, buf); 3503b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 35045700b1afSMike Christie return iscsi_switch_str_param(&session->password, buf); 3505b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 35065700b1afSMike Christie return iscsi_switch_str_param(&session->password_in, buf); 3507a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 35085700b1afSMike Christie return iscsi_switch_str_param(&session->targetname, buf); 35093c5c4801SVikas Chaudhary case ISCSI_PARAM_TARGET_ALIAS: 35103c5c4801SVikas Chaudhary return iscsi_switch_str_param(&session->targetalias, buf); 3511a54a52caSMike Christie case ISCSI_PARAM_TPGT: 3512a54a52caSMike Christie sscanf(buf, "%d", &session->tpgt); 3513a54a52caSMike Christie break; 3514a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3515a54a52caSMike Christie sscanf(buf, "%d", &conn->persistent_port); 3516a54a52caSMike Christie break; 3517a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 35185700b1afSMike Christie return iscsi_switch_str_param(&conn->persistent_address, buf); 351988dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 35205700b1afSMike Christie return iscsi_switch_str_param(&session->ifacename, buf); 352188dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 35225700b1afSMike Christie return iscsi_switch_str_param(&session->initiatorname, buf); 35233b9373e9SEddie Wai case ISCSI_PARAM_BOOT_ROOT: 35243b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_root, buf); 35253b9373e9SEddie Wai case ISCSI_PARAM_BOOT_NIC: 35263b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_nic, buf); 35273b9373e9SEddie Wai case ISCSI_PARAM_BOOT_TARGET: 35283b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_target, buf); 3529f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_PORTAL_TYPE: 3530f8525eb4SAdheer Chandravanshi return iscsi_switch_str_param(&session->portal_type, buf); 3531f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_TYPE: 3532f8525eb4SAdheer Chandravanshi return iscsi_switch_str_param(&session->discovery_parent_type, 3533f8525eb4SAdheer Chandravanshi buf); 35346a06a4b8SOr Gerlitz case ISCSI_PARAM_DISCOVERY_SESS: 35356a06a4b8SOr Gerlitz sscanf(buf, "%d", &val); 35366a06a4b8SOr Gerlitz session->discovery_sess = !!val; 35376a06a4b8SOr Gerlitz break; 3538ae56ff40SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_IPADDR: 3539ae56ff40SAdheer Chandravanshi return iscsi_switch_str_param(&conn->local_ipaddr, buf); 3540a54a52caSMike Christie default: 3541a54a52caSMike Christie return -ENOSYS; 3542a54a52caSMike Christie } 3543a54a52caSMike Christie 3544a54a52caSMike Christie return 0; 3545a54a52caSMike Christie } 3546a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_set_param); 3547a54a52caSMike Christie 3548a54a52caSMike Christie int iscsi_session_get_param(struct iscsi_cls_session *cls_session, 3549a54a52caSMike Christie enum iscsi_param param, char *buf) 3550a54a52caSMike Christie { 355175613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 3552a54a52caSMike Christie int len; 3553a54a52caSMike Christie 3554a54a52caSMike Christie switch(param) { 3555843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 3556ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->fast_abort); 3557843c0a8aSMike Christie break; 3558f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 3559ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->abort_timeout); 3560f6d5180cSMike Christie break; 3561f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 3562ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->lu_reset_timeout); 3563f6d5180cSMike Christie break; 35643fe5ae8bSMike Christie case ISCSI_PARAM_TGT_RESET_TMO: 3565ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->tgt_reset_timeout); 35663fe5ae8bSMike Christie break; 3567a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 3568ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->initial_r2t_en); 3569a54a52caSMike Christie break; 3570a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 3571ec98ea70SChris Leech len = sysfs_emit(buf, "%hu\n", session->max_r2t); 3572a54a52caSMike Christie break; 3573a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 3574ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->imm_data_en); 3575a54a52caSMike Christie break; 3576a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 3577ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->first_burst); 3578a54a52caSMike Christie break; 3579a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 3580ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->max_burst); 3581a54a52caSMike Christie break; 3582a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 3583ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->pdu_inorder_en); 3584a54a52caSMike Christie break; 3585a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 3586ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->dataseq_inorder_en); 3587a54a52caSMike Christie break; 35885f09e1f3SAdheer Chandravanshi case ISCSI_PARAM_DEF_TASKMGMT_TMO: 3589ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->def_taskmgmt_tmo); 35905f09e1f3SAdheer Chandravanshi break; 3591a54a52caSMike Christie case ISCSI_PARAM_ERL: 3592ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->erl); 3593a54a52caSMike Christie break; 3594a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 3595ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->targetname); 3596a54a52caSMike Christie break; 35973c5c4801SVikas Chaudhary case ISCSI_PARAM_TARGET_ALIAS: 3598ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->targetalias); 35993c5c4801SVikas Chaudhary break; 3600a54a52caSMike Christie case ISCSI_PARAM_TPGT: 3601ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->tpgt); 3602a54a52caSMike Christie break; 3603b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 3604ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->username); 3605b2c64167SMike Christie break; 3606b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 3607ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->username_in); 3608b2c64167SMike Christie break; 3609b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 3610ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->password); 3611b2c64167SMike Christie break; 3612b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 3613ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->password_in); 3614b2c64167SMike Christie break; 361588dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 3616ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->ifacename); 361788dfd340SMike Christie break; 361888dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 3619ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->initiatorname); 362088dfd340SMike Christie break; 36213b9373e9SEddie Wai case ISCSI_PARAM_BOOT_ROOT: 3622ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->boot_root); 36233b9373e9SEddie Wai break; 36243b9373e9SEddie Wai case ISCSI_PARAM_BOOT_NIC: 3625ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->boot_nic); 36263b9373e9SEddie Wai break; 36273b9373e9SEddie Wai case ISCSI_PARAM_BOOT_TARGET: 3628ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->boot_target); 36299a2307b1SAdheer Chandravanshi break; 3630f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_AUTO_SND_TGT_DISABLE: 3631ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->auto_snd_tgt_disable); 3632f8525eb4SAdheer Chandravanshi break; 3633f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_SESS: 3634ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->discovery_sess); 3635f8525eb4SAdheer Chandravanshi break; 3636f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_PORTAL_TYPE: 3637ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->portal_type); 3638f8525eb4SAdheer Chandravanshi break; 3639f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_CHAP_AUTH_EN: 3640ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->chap_auth_en); 3641f8525eb4SAdheer Chandravanshi break; 3642f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_LOGOUT_EN: 3643ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->discovery_logout_en); 3644f8525eb4SAdheer Chandravanshi break; 3645f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_BIDI_CHAP_EN: 3646ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->bidi_chap_en); 3647f8525eb4SAdheer Chandravanshi break; 3648f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL: 3649ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->discovery_auth_optional); 3650f8525eb4SAdheer Chandravanshi break; 3651f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DEF_TIME2WAIT: 3652ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->time2wait); 3653f8525eb4SAdheer Chandravanshi break; 3654f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DEF_TIME2RETAIN: 3655ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->time2retain); 3656f8525eb4SAdheer Chandravanshi break; 3657f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TSID: 3658ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->tsid); 3659f8525eb4SAdheer Chandravanshi break; 3660f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_ISID: 3661ec98ea70SChris Leech len = sysfs_emit(buf, "%02x%02x%02x%02x%02x%02x\n", 3662f8525eb4SAdheer Chandravanshi session->isid[0], session->isid[1], 3663f8525eb4SAdheer Chandravanshi session->isid[2], session->isid[3], 3664f8525eb4SAdheer Chandravanshi session->isid[4], session->isid[5]); 3665f8525eb4SAdheer Chandravanshi break; 3666f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_IDX: 3667ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->discovery_parent_idx); 3668f8525eb4SAdheer Chandravanshi break; 3669f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_TYPE: 3670f8525eb4SAdheer Chandravanshi if (session->discovery_parent_type) 3671ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", 3672f8525eb4SAdheer Chandravanshi session->discovery_parent_type); 3673f8525eb4SAdheer Chandravanshi else 3674ec98ea70SChris Leech len = sysfs_emit(buf, "\n"); 36753b9373e9SEddie Wai break; 3676a54a52caSMike Christie default: 3677a54a52caSMike Christie return -ENOSYS; 3678a54a52caSMike Christie } 3679a54a52caSMike Christie 3680a54a52caSMike Christie return len; 3681a54a52caSMike Christie } 3682a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_get_param); 3683a54a52caSMike Christie 368400f3708eSMike Christie int iscsi_conn_get_addr_param(struct sockaddr_storage *addr, 368500f3708eSMike Christie enum iscsi_param param, char *buf) 368600f3708eSMike Christie { 368700f3708eSMike Christie struct sockaddr_in6 *sin6 = NULL; 368800f3708eSMike Christie struct sockaddr_in *sin = NULL; 368900f3708eSMike Christie int len; 369000f3708eSMike Christie 369100f3708eSMike Christie switch (addr->ss_family) { 369200f3708eSMike Christie case AF_INET: 369300f3708eSMike Christie sin = (struct sockaddr_in *)addr; 369400f3708eSMike Christie break; 369500f3708eSMike Christie case AF_INET6: 369600f3708eSMike Christie sin6 = (struct sockaddr_in6 *)addr; 369700f3708eSMike Christie break; 369800f3708eSMike Christie default: 369900f3708eSMike Christie return -EINVAL; 370000f3708eSMike Christie } 370100f3708eSMike Christie 370200f3708eSMike Christie switch (param) { 370300f3708eSMike Christie case ISCSI_PARAM_CONN_ADDRESS: 370400f3708eSMike Christie case ISCSI_HOST_PARAM_IPADDRESS: 370500f3708eSMike Christie if (sin) 3706ec98ea70SChris Leech len = sysfs_emit(buf, "%pI4\n", &sin->sin_addr.s_addr); 370700f3708eSMike Christie else 3708ec98ea70SChris Leech len = sysfs_emit(buf, "%pI6\n", &sin6->sin6_addr); 370900f3708eSMike Christie break; 371000f3708eSMike Christie case ISCSI_PARAM_CONN_PORT: 37114bfb8ebfSMike Christie case ISCSI_PARAM_LOCAL_PORT: 371200f3708eSMike Christie if (sin) 3713ec98ea70SChris Leech len = sysfs_emit(buf, "%hu\n", be16_to_cpu(sin->sin_port)); 371400f3708eSMike Christie else 3715ec98ea70SChris Leech len = sysfs_emit(buf, "%hu\n", 371600f3708eSMike Christie be16_to_cpu(sin6->sin6_port)); 371700f3708eSMike Christie break; 371800f3708eSMike Christie default: 371900f3708eSMike Christie return -EINVAL; 372000f3708eSMike Christie } 372100f3708eSMike Christie 372200f3708eSMike Christie return len; 372300f3708eSMike Christie } 372400f3708eSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_addr_param); 372500f3708eSMike Christie 3726a54a52caSMike Christie int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, 3727a54a52caSMike Christie enum iscsi_param param, char *buf) 3728a54a52caSMike Christie { 3729a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 3730a54a52caSMike Christie int len; 3731a54a52caSMike Christie 3732a54a52caSMike Christie switch(param) { 3733f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 3734ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->ping_timeout); 3735f6d5180cSMike Christie break; 3736f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 3737ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->recv_timeout); 3738f6d5180cSMike Christie break; 3739a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 3740ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->max_recv_dlength); 3741a54a52caSMike Christie break; 3742a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3743ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->max_xmit_dlength); 3744a54a52caSMike Christie break; 3745a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 3746ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->hdrdgst_en); 3747a54a52caSMike Christie break; 3748a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 3749ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->datadgst_en); 3750a54a52caSMike Christie break; 3751a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 3752ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->ifmarker_en); 3753a54a52caSMike Christie break; 3754a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 3755ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->ofmarker_en); 3756a54a52caSMike Christie break; 3757a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 3758ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->exp_statsn); 3759a54a52caSMike Christie break; 3760a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3761ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->persistent_port); 3762a54a52caSMike Christie break; 3763a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 3764ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", conn->persistent_address); 3765a54a52caSMike Christie break; 3766f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_STATSN: 3767ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->statsn); 3768f8525eb4SAdheer Chandravanshi break; 3769f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_MAX_SEGMENT_SIZE: 3770ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->max_segment_size); 3771f8525eb4SAdheer Chandravanshi break; 3772f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_KEEPALIVE_TMO: 3773ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->keepalive_tmo); 3774f8525eb4SAdheer Chandravanshi break; 3775f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_PORT: 3776ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->local_port); 3777f8525eb4SAdheer Chandravanshi break; 3778f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMESTAMP_STAT: 3779ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_timestamp_stat); 3780f8525eb4SAdheer Chandravanshi break; 3781f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_NAGLE_DISABLE: 3782ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_nagle_disable); 3783f8525eb4SAdheer Chandravanshi break; 3784f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_WSF_DISABLE: 3785ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_wsf_disable); 3786f8525eb4SAdheer Chandravanshi break; 3787f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMER_SCALE: 3788ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_timer_scale); 3789f8525eb4SAdheer Chandravanshi break; 3790f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMESTAMP_EN: 3791ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_timestamp_en); 3792f8525eb4SAdheer Chandravanshi break; 3793f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IP_FRAGMENT_DISABLE: 3794ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->fragment_disable); 3795f8525eb4SAdheer Chandravanshi break; 3796f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IPV4_TOS: 3797ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->ipv4_tos); 3798f8525eb4SAdheer Chandravanshi break; 3799f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IPV6_TC: 3800ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->ipv6_traffic_class); 3801f8525eb4SAdheer Chandravanshi break; 38025f09e1f3SAdheer Chandravanshi case ISCSI_PARAM_IPV6_FLOW_LABEL: 3803ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->ipv6_flow_label); 38045f09e1f3SAdheer Chandravanshi break; 3805f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IS_FW_ASSIGNED_IPV6: 3806ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->is_fw_assigned_ipv6); 3807f8525eb4SAdheer Chandravanshi break; 3808f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_XMIT_WSF: 3809ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_xmit_wsf); 3810f8525eb4SAdheer Chandravanshi break; 3811f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_RECV_WSF: 3812ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_recv_wsf); 3813f8525eb4SAdheer Chandravanshi break; 3814ae56ff40SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_IPADDR: 3815ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", conn->local_ipaddr); 3816ae56ff40SAdheer Chandravanshi break; 3817a54a52caSMike Christie default: 3818a54a52caSMike Christie return -ENOSYS; 3819a54a52caSMike Christie } 3820a54a52caSMike Christie 3821a54a52caSMike Christie return len; 3822a54a52caSMike Christie } 3823a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_param); 3824a54a52caSMike Christie 38250801c242SMike Christie int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param, 38260801c242SMike Christie char *buf) 38270801c242SMike Christie { 382875613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 38290801c242SMike Christie int len; 38300801c242SMike Christie 38310801c242SMike Christie switch (param) { 3832d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 3833ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", ihost->netdev); 3834d8196ed2SMike Christie break; 38350801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 3836ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", ihost->hwaddress); 38370801c242SMike Christie break; 38388ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 3839ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", ihost->initiatorname); 38408ad5781aSMike Christie break; 38410801c242SMike Christie default: 38420801c242SMike Christie return -ENOSYS; 38430801c242SMike Christie } 38440801c242SMike Christie 38450801c242SMike Christie return len; 38460801c242SMike Christie } 38470801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_param); 38480801c242SMike Christie 38490801c242SMike Christie int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param, 38500801c242SMike Christie char *buf, int buflen) 38510801c242SMike Christie { 385275613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 38530801c242SMike Christie 38540801c242SMike Christie switch (param) { 3855d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 38565700b1afSMike Christie return iscsi_switch_str_param(&ihost->netdev, buf); 38570801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 38585700b1afSMike Christie return iscsi_switch_str_param(&ihost->hwaddress, buf); 38598ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 38605700b1afSMike Christie return iscsi_switch_str_param(&ihost->initiatorname, buf); 38610801c242SMike Christie default: 38620801c242SMike Christie return -ENOSYS; 38630801c242SMike Christie } 38640801c242SMike Christie 38650801c242SMike Christie return 0; 38660801c242SMike Christie } 38670801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_set_param); 38680801c242SMike Christie 38697996a778SMike Christie MODULE_AUTHOR("Mike Christie"); 38707996a778SMike Christie MODULE_DESCRIPTION("iSCSI library functions"); 38717996a778SMike Christie MODULE_LICENSE("GPL"); 3872