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 864b9f8ce4SMike Christie inline void iscsi_conn_queue_xmit(struct iscsi_conn *conn) 8732ae763eSMike Christie { 8832ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 8932ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 9032ae763eSMike Christie 911336aed1SMike Christie if (ihost->workq) 9232ae763eSMike Christie queue_work(ihost->workq, &conn->xmitwork); 9332ae763eSMike Christie } 944b9f8ce4SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_queue_xmit); 9532ae763eSMike Christie 96*8af80996SMike Christie inline void iscsi_conn_queue_recv(struct iscsi_conn *conn) 97*8af80996SMike Christie { 98*8af80996SMike Christie struct Scsi_Host *shost = conn->session->host; 99*8af80996SMike Christie struct iscsi_host *ihost = shost_priv(shost); 100*8af80996SMike Christie 101*8af80996SMike Christie if (ihost->workq && !test_bit(ISCSI_CONN_FLAG_SUSPEND_RX, &conn->flags)) 102*8af80996SMike Christie queue_work(ihost->workq, &conn->recvwork); 103*8af80996SMike Christie } 104*8af80996SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_queue_recv); 105*8af80996SMike Christie 1064c0ba5d2SMike Christie static void __iscsi_update_cmdsn(struct iscsi_session *session, 1074c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 1087996a778SMike Christie { 10977a23c21SMike Christie /* 11077a23c21SMike Christie * standard specifies this check for when to update expected and 11177a23c21SMike Christie * max sequence numbers 11277a23c21SMike Christie */ 11377a23c21SMike Christie if (iscsi_sna_lt(max_cmdsn, exp_cmdsn - 1)) 11477a23c21SMike Christie return; 11577a23c21SMike Christie 11677a23c21SMike Christie if (exp_cmdsn != session->exp_cmdsn && 11777a23c21SMike Christie !iscsi_sna_lt(exp_cmdsn, session->exp_cmdsn)) 1187996a778SMike Christie session->exp_cmdsn = exp_cmdsn; 1197996a778SMike Christie 12077a23c21SMike Christie if (max_cmdsn != session->max_cmdsn && 12146a84c65SMike Christie !iscsi_sna_lt(max_cmdsn, session->max_cmdsn)) 12277a23c21SMike Christie session->max_cmdsn = max_cmdsn; 12377a23c21SMike Christie } 1244c0ba5d2SMike Christie 1254c0ba5d2SMike Christie void iscsi_update_cmdsn(struct iscsi_session *session, struct iscsi_nopin *hdr) 1264c0ba5d2SMike Christie { 1274c0ba5d2SMike Christie __iscsi_update_cmdsn(session, be32_to_cpu(hdr->exp_cmdsn), 1284c0ba5d2SMike Christie be32_to_cpu(hdr->max_cmdsn)); 1294c0ba5d2SMike Christie } 13077a23c21SMike Christie EXPORT_SYMBOL_GPL(iscsi_update_cmdsn); 1317996a778SMike Christie 132577577daSMike Christie /** 133577577daSMike Christie * iscsi_prep_data_out_pdu - initialize Data-Out 134577577daSMike Christie * @task: scsi command task 135577577daSMike Christie * @r2t: R2T info 136577577daSMike Christie * @hdr: iscsi data in pdu 137577577daSMike Christie * 138577577daSMike Christie * Notes: 139577577daSMike Christie * Initialize Data-Out within this R2T sequence and finds 140577577daSMike Christie * proper data_offset within this SCSI command. 141577577daSMike Christie * 142577577daSMike Christie * This function is called with connection lock taken. 143577577daSMike Christie **/ 144577577daSMike Christie void iscsi_prep_data_out_pdu(struct iscsi_task *task, struct iscsi_r2t_info *r2t, 145ffd0436eSMike Christie struct iscsi_data *hdr) 1467996a778SMike Christie { 1479c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 148577577daSMike Christie unsigned int left = r2t->data_length - r2t->sent; 149577577daSMike Christie 150577577daSMike Christie task->hdr_len = sizeof(struct iscsi_data); 1517996a778SMike Christie 1527996a778SMike Christie memset(hdr, 0, sizeof(struct iscsi_data)); 153577577daSMike Christie hdr->ttt = r2t->ttt; 154577577daSMike Christie hdr->datasn = cpu_to_be32(r2t->datasn); 155577577daSMike Christie r2t->datasn++; 1567996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_DATA_OUT; 15755bdabdfSAndy Grover hdr->lun = task->lun; 158577577daSMike Christie hdr->itt = task->hdr_itt; 159577577daSMike Christie hdr->exp_statsn = r2t->exp_statsn; 160577577daSMike Christie hdr->offset = cpu_to_be32(r2t->data_offset + r2t->sent); 161577577daSMike Christie if (left > conn->max_xmit_dlength) { 1627996a778SMike Christie hton24(hdr->dlength, conn->max_xmit_dlength); 163577577daSMike Christie r2t->data_count = conn->max_xmit_dlength; 1647996a778SMike Christie hdr->flags = 0; 1657996a778SMike Christie } else { 166577577daSMike Christie hton24(hdr->dlength, left); 167577577daSMike Christie r2t->data_count = left; 1687996a778SMike Christie hdr->flags = ISCSI_FLAG_CMD_FINAL; 1697996a778SMike Christie } 170577577daSMike Christie conn->dataout_pdus_cnt++; 1717996a778SMike Christie } 172577577daSMike Christie EXPORT_SYMBOL_GPL(iscsi_prep_data_out_pdu); 1737996a778SMike Christie 1749c19a7d0SMike Christie static int iscsi_add_hdr(struct iscsi_task *task, unsigned len) 175004d6530SBoaz Harrosh { 1769c19a7d0SMike Christie unsigned exp_len = task->hdr_len + len; 177004d6530SBoaz Harrosh 1789c19a7d0SMike Christie if (exp_len > task->hdr_max) { 179004d6530SBoaz Harrosh WARN_ON(1); 180004d6530SBoaz Harrosh return -EINVAL; 181004d6530SBoaz Harrosh } 182004d6530SBoaz Harrosh 183004d6530SBoaz Harrosh WARN_ON(len & (ISCSI_PAD_LEN - 1)); /* caller must pad the AHS */ 1849c19a7d0SMike Christie task->hdr_len = exp_len; 185004d6530SBoaz Harrosh return 0; 186004d6530SBoaz Harrosh } 187004d6530SBoaz Harrosh 18838d1c069SBoaz Harrosh /* 18938d1c069SBoaz Harrosh * make an extended cdb AHS 19038d1c069SBoaz Harrosh */ 1919c19a7d0SMike Christie static int iscsi_prep_ecdb_ahs(struct iscsi_task *task) 19238d1c069SBoaz Harrosh { 1939c19a7d0SMike Christie struct scsi_cmnd *cmd = task->sc; 19438d1c069SBoaz Harrosh unsigned rlen, pad_len; 19538d1c069SBoaz Harrosh unsigned short ahslength; 19638d1c069SBoaz Harrosh struct iscsi_ecdb_ahdr *ecdb_ahdr; 19738d1c069SBoaz Harrosh int rc; 19838d1c069SBoaz Harrosh 1999c19a7d0SMike Christie ecdb_ahdr = iscsi_next_hdr(task); 20038d1c069SBoaz Harrosh rlen = cmd->cmd_len - ISCSI_CDB_SIZE; 20138d1c069SBoaz Harrosh 20238d1c069SBoaz Harrosh BUG_ON(rlen > sizeof(ecdb_ahdr->ecdb)); 20338d1c069SBoaz Harrosh ahslength = rlen + sizeof(ecdb_ahdr->reserved); 20438d1c069SBoaz Harrosh 20538d1c069SBoaz Harrosh pad_len = iscsi_padding(rlen); 20638d1c069SBoaz Harrosh 2079c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(ecdb_ahdr->ahslength) + 20838d1c069SBoaz Harrosh sizeof(ecdb_ahdr->ahstype) + ahslength + pad_len); 20938d1c069SBoaz Harrosh if (rc) 21038d1c069SBoaz Harrosh return rc; 21138d1c069SBoaz Harrosh 21238d1c069SBoaz Harrosh if (pad_len) 21338d1c069SBoaz Harrosh memset(&ecdb_ahdr->ecdb[rlen], 0, pad_len); 21438d1c069SBoaz Harrosh 21538d1c069SBoaz Harrosh ecdb_ahdr->ahslength = cpu_to_be16(ahslength); 21638d1c069SBoaz Harrosh ecdb_ahdr->ahstype = ISCSI_AHSTYPE_CDB; 21738d1c069SBoaz Harrosh ecdb_ahdr->reserved = 0; 21838d1c069SBoaz Harrosh memcpy(ecdb_ahdr->ecdb, cmd->cmnd + ISCSI_CDB_SIZE, rlen); 21938d1c069SBoaz Harrosh 2201b2c7af8SMike Christie ISCSI_DBG_SESSION(task->conn->session, 2211b2c7af8SMike Christie "iscsi_prep_ecdb_ahs: varlen_cdb_len %d " 2221b2c7af8SMike Christie "rlen %d pad_len %d ahs_length %d iscsi_headers_size " 2231b2c7af8SMike Christie "%u\n", cmd->cmd_len, rlen, pad_len, ahslength, 2241b2c7af8SMike Christie task->hdr_len); 22538d1c069SBoaz Harrosh return 0; 22638d1c069SBoaz Harrosh } 22738d1c069SBoaz Harrosh 2287996a778SMike Christie /** 2295d12c05eSMike Christie * iscsi_check_tmf_restrictions - check if a task is affected by TMF 2305d12c05eSMike Christie * @task: iscsi task 2315d12c05eSMike Christie * @opcode: opcode to check for 2325d12c05eSMike Christie * 2335d12c05eSMike Christie * During TMF a task has to be checked if it's affected. 2345d12c05eSMike Christie * All unrelated I/O can be passed through, but I/O to the 2355d12c05eSMike Christie * affected LUN should be restricted. 2365d12c05eSMike Christie * If 'fast_abort' is set we won't be sending any I/O to the 2375d12c05eSMike Christie * affected LUN. 2385d12c05eSMike Christie * Otherwise the target is waiting for all TTTs to be completed, 2395d12c05eSMike Christie * so we have to send all outstanding Data-Out PDUs to the target. 2405d12c05eSMike Christie */ 2415d12c05eSMike Christie static int iscsi_check_tmf_restrictions(struct iscsi_task *task, int opcode) 2425d12c05eSMike Christie { 243ec29d0acSMike Christie struct iscsi_session *session = task->conn->session; 244ec29d0acSMike Christie struct iscsi_tm *tmf = &session->tmhdr; 2459cb78c16SHannes Reinecke u64 hdr_lun; 2465d12c05eSMike Christie 247ec29d0acSMike Christie if (session->tmf_state == TMF_INITIAL) 2485d12c05eSMike Christie return 0; 2495d12c05eSMike Christie 2505d12c05eSMike Christie if ((tmf->opcode & ISCSI_OPCODE_MASK) != ISCSI_OP_SCSI_TMFUNC) 2515d12c05eSMike Christie return 0; 2525d12c05eSMike Christie 2535d12c05eSMike Christie switch (ISCSI_TM_FUNC_VALUE(tmf)) { 2545d12c05eSMike Christie case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET: 2555d12c05eSMike Christie /* 2565d12c05eSMike Christie * Allow PDUs for unrelated LUNs 2575d12c05eSMike Christie */ 25855bdabdfSAndy Grover hdr_lun = scsilun_to_int(&tmf->lun); 2595d12c05eSMike Christie if (hdr_lun != task->sc->device->lun) 2605d12c05eSMike Christie return 0; 261df561f66SGustavo A. R. Silva fallthrough; 2623fe5ae8bSMike Christie case ISCSI_TM_FUNC_TARGET_WARM_RESET: 2635d12c05eSMike Christie /* 2645d12c05eSMike Christie * Fail all SCSI cmd PDUs 2655d12c05eSMike Christie */ 2665d12c05eSMike Christie if (opcode != ISCSI_OP_SCSI_DATA_OUT) { 267ec29d0acSMike Christie iscsi_session_printk(KERN_INFO, session, 268ec29d0acSMike Christie "task [op %x itt 0x%x/0x%x] rejected.\n", 269ec29d0acSMike Christie opcode, task->itt, task->hdr_itt); 2705d12c05eSMike Christie return -EACCES; 2715d12c05eSMike Christie } 2725d12c05eSMike Christie /* 2735d12c05eSMike Christie * And also all data-out PDUs in response to R2T 2745d12c05eSMike Christie * if fast_abort is set. 2755d12c05eSMike Christie */ 276ec29d0acSMike Christie if (session->fast_abort) { 277ec29d0acSMike Christie iscsi_session_printk(KERN_INFO, session, 278ec29d0acSMike Christie "task [op %x itt 0x%x/0x%x] fast abort.\n", 279ec29d0acSMike Christie opcode, task->itt, task->hdr_itt); 2805d12c05eSMike Christie return -EACCES; 2815d12c05eSMike Christie } 2825d12c05eSMike Christie break; 2835d12c05eSMike Christie case ISCSI_TM_FUNC_ABORT_TASK: 2845d12c05eSMike Christie /* 2855d12c05eSMike Christie * the caller has already checked if the task 2865d12c05eSMike Christie * they want to abort was in the pending queue so if 2875d12c05eSMike Christie * we are here the cmd pdu has gone out already, and 2885d12c05eSMike Christie * we will only hit this for data-outs 2895d12c05eSMike Christie */ 2905d12c05eSMike Christie if (opcode == ISCSI_OP_SCSI_DATA_OUT && 2915d12c05eSMike Christie task->hdr_itt == tmf->rtt) { 292ec29d0acSMike Christie ISCSI_DBG_SESSION(session, 2935d12c05eSMike Christie "Preventing task %x/%x from sending " 2945d12c05eSMike Christie "data-out due to abort task in " 2955d12c05eSMike Christie "progress\n", task->itt, 2965d12c05eSMike Christie task->hdr_itt); 2975d12c05eSMike Christie return -EACCES; 2985d12c05eSMike Christie } 2995d12c05eSMike Christie break; 3005d12c05eSMike Christie } 3015d12c05eSMike Christie 3025d12c05eSMike Christie return 0; 3035d12c05eSMike Christie } 3045d12c05eSMike Christie 3055d12c05eSMike Christie /** 3067996a778SMike Christie * iscsi_prep_scsi_cmd_pdu - prep iscsi scsi cmd pdu 3079c19a7d0SMike Christie * @task: iscsi task 3087996a778SMike Christie * 3097996a778SMike Christie * Prep basic iSCSI PDU fields for a scsi cmd pdu. The LLD should set 3107996a778SMike Christie * fields like dlength or final based on how much data it sends 3117996a778SMike Christie */ 3129c19a7d0SMike Christie static int iscsi_prep_scsi_cmd_pdu(struct iscsi_task *task) 3137996a778SMike Christie { 3149c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 3157996a778SMike Christie struct iscsi_session *session = conn->session; 3169c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 31712352183SNicholas Bellinger struct iscsi_scsi_req *hdr; 318d77e6535SSagi Grimberg unsigned hdrlength, cmd_len, transfer_length; 319262ef636SMike Christie itt_t itt; 320004d6530SBoaz Harrosh int rc; 3217996a778SMike Christie 3225d12c05eSMike Christie rc = iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_CMD); 3235d12c05eSMike Christie if (rc) 3245d12c05eSMike Christie return rc; 3255d12c05eSMike Christie 326184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 3272ff79d52SMike Christie rc = conn->session->tt->alloc_pdu(task, ISCSI_OP_SCSI_CMD); 328577577daSMike Christie if (rc) 329577577daSMike Christie return rc; 330184b57c6SMike Christie } 33112352183SNicholas Bellinger hdr = (struct iscsi_scsi_req *)task->hdr; 332262ef636SMike Christie itt = hdr->itt; 333577577daSMike Christie memset(hdr, 0, sizeof(*hdr)); 334577577daSMike Christie 3352ff79d52SMike Christie if (session->tt->parse_pdu_itt) 3362ff79d52SMike Christie hdr->itt = task->hdr_itt = itt; 3372ff79d52SMike Christie else 3382ff79d52SMike Christie hdr->itt = task->hdr_itt = build_itt(task->itt, 3392ff79d52SMike Christie task->conn->session->age); 3409c19a7d0SMike Christie task->hdr_len = 0; 3419c19a7d0SMike Christie rc = iscsi_add_hdr(task, sizeof(*hdr)); 342004d6530SBoaz Harrosh if (rc) 343004d6530SBoaz Harrosh return rc; 3447996a778SMike Christie hdr->opcode = ISCSI_OP_SCSI_CMD; 3457996a778SMike Christie hdr->flags = ISCSI_ATTR_SIMPLE; 34655bdabdfSAndy Grover int_to_scsilun(sc->device->lun, &hdr->lun); 34755bdabdfSAndy Grover task->lun = hdr->lun; 3487996a778SMike Christie hdr->exp_statsn = cpu_to_be32(conn->exp_statsn); 34938d1c069SBoaz Harrosh cmd_len = sc->cmd_len; 35038d1c069SBoaz Harrosh if (cmd_len < ISCSI_CDB_SIZE) 35138d1c069SBoaz Harrosh memset(&hdr->cdb[cmd_len], 0, ISCSI_CDB_SIZE - cmd_len); 35238d1c069SBoaz Harrosh else if (cmd_len > ISCSI_CDB_SIZE) { 3539c19a7d0SMike Christie rc = iscsi_prep_ecdb_ahs(task); 35438d1c069SBoaz Harrosh if (rc) 35538d1c069SBoaz Harrosh return rc; 35638d1c069SBoaz Harrosh cmd_len = ISCSI_CDB_SIZE; 35738d1c069SBoaz Harrosh } 35838d1c069SBoaz Harrosh memcpy(hdr->cdb, sc->cmnd, cmd_len); 3597996a778SMike Christie 3609c19a7d0SMike Christie task->imm_count = 0; 36155e51edaSSagi Grimberg if (scsi_get_prot_op(sc) != SCSI_PROT_NORMAL) 36255e51edaSSagi Grimberg task->protected = true; 36355e51edaSSagi Grimberg 364d77e6535SSagi Grimberg transfer_length = scsi_transfer_length(sc); 365d77e6535SSagi Grimberg hdr->data_length = cpu_to_be32(transfer_length); 3667996a778SMike Christie if (sc->sc_data_direction == DMA_TO_DEVICE) { 367577577daSMike Christie struct iscsi_r2t_info *r2t = &task->unsol_r2t; 368577577daSMike Christie 3697996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_WRITE; 3707996a778SMike Christie /* 3717996a778SMike Christie * Write counters: 3727996a778SMike Christie * 3737996a778SMike Christie * imm_count bytes to be sent right after 3747996a778SMike Christie * SCSI PDU Header 3757996a778SMike Christie * 3767996a778SMike Christie * unsol_count bytes(as Data-Out) to be sent 3777996a778SMike Christie * without R2T ack right after 3787996a778SMike Christie * immediate data 3797996a778SMike Christie * 380577577daSMike Christie * r2t data_length bytes to be sent via R2T ack's 3817996a778SMike Christie * 3827996a778SMike Christie * pad_count bytes to be sent as zero-padding 3837996a778SMike Christie */ 384577577daSMike Christie memset(r2t, 0, sizeof(*r2t)); 3857996a778SMike Christie 3867996a778SMike Christie if (session->imm_data_en) { 387d77e6535SSagi Grimberg if (transfer_length >= session->first_burst) 3889c19a7d0SMike Christie task->imm_count = min(session->first_burst, 3897996a778SMike Christie conn->max_xmit_dlength); 3907996a778SMike Christie else 391d77e6535SSagi Grimberg task->imm_count = min(transfer_length, 3927996a778SMike Christie conn->max_xmit_dlength); 3939c19a7d0SMike Christie hton24(hdr->dlength, task->imm_count); 3947996a778SMike Christie } else 395a8ac6311SOlaf Kirch zero_data(hdr->dlength); 3967996a778SMike Christie 397ffd0436eSMike Christie if (!session->initial_r2t_en) { 398d77e6535SSagi Grimberg r2t->data_length = min(session->first_burst, 399d77e6535SSagi Grimberg transfer_length) - 400577577daSMike Christie task->imm_count; 401577577daSMike Christie r2t->data_offset = task->imm_count; 402577577daSMike Christie r2t->ttt = cpu_to_be32(ISCSI_RESERVED_TAG); 403577577daSMike Christie r2t->exp_statsn = cpu_to_be32(conn->exp_statsn); 404ffd0436eSMike Christie } 405ffd0436eSMike Christie 406577577daSMike Christie if (!task->unsol_r2t.data_length) 4077996a778SMike Christie /* No unsolicit Data-Out's */ 408a8ac6311SOlaf Kirch hdr->flags |= ISCSI_FLAG_CMD_FINAL; 4097996a778SMike Christie } else { 4107996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 4117996a778SMike Christie zero_data(hdr->dlength); 4127996a778SMike Christie 4137996a778SMike Christie if (sc->sc_data_direction == DMA_FROM_DEVICE) 4147996a778SMike Christie hdr->flags |= ISCSI_FLAG_CMD_READ; 4157996a778SMike Christie } 4167996a778SMike Christie 417004d6530SBoaz Harrosh /* calculate size of additional header segments (AHSs) */ 4189c19a7d0SMike Christie hdrlength = task->hdr_len - sizeof(*hdr); 419004d6530SBoaz Harrosh 420004d6530SBoaz Harrosh WARN_ON(hdrlength & (ISCSI_PAD_LEN-1)); 421004d6530SBoaz Harrosh hdrlength /= ISCSI_PAD_LEN; 422004d6530SBoaz Harrosh 423004d6530SBoaz Harrosh WARN_ON(hdrlength >= 256); 424004d6530SBoaz Harrosh hdr->hlength = hdrlength & 0xFF; 42596b1f96dSMike Christie hdr->cmdsn = task->cmdsn = cpu_to_be32(session->cmdsn); 426004d6530SBoaz Harrosh 427577577daSMike Christie if (session->tt->init_task && session->tt->init_task(task)) 428052d0144SMike Christie return -EIO; 429052d0144SMike Christie 4309c19a7d0SMike Christie task->state = ISCSI_TASK_RUNNING; 431d3305f34SMike Christie session->cmdsn++; 43277a23c21SMike Christie 433a8ac6311SOlaf Kirch conn->scsicmd_pdus_cnt++; 4341b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi prep [%s cid %d sc %p cdb 0x%x " 435ae3d56d8SChristoph Hellwig "itt 0x%x len %d cmdsn %d win %d]\n", 4361b2c7af8SMike Christie sc->sc_data_direction == DMA_TO_DEVICE ? 4371b2c7af8SMike Christie "write" : "read", conn->id, sc, sc->cmnd[0], 438d77e6535SSagi Grimberg task->itt, transfer_length, 4391b2c7af8SMike Christie session->cmdsn, 4401b2c7af8SMike Christie session->max_cmdsn - session->exp_cmdsn + 1); 441004d6530SBoaz Harrosh return 0; 4427996a778SMike Christie } 4437996a778SMike Christie 4447996a778SMike Christie /** 4453bbaaad9SMike Christie * iscsi_free_task - free a task 4469c19a7d0SMike Christie * @task: iscsi cmd task 4477996a778SMike Christie * 448659743b0SShlomo Pongratz * Must be called with session back_lock. 4493e5c28adSMike Christie * This function returns the scsi command to scsi-ml or cleans 4503e5c28adSMike Christie * up mgmt tasks then returns the task to the pool. 4517996a778SMike Christie */ 4523bbaaad9SMike Christie static void iscsi_free_task(struct iscsi_task *task) 4537996a778SMike Christie { 4549c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 455c1635cb7SMike Christie struct iscsi_session *session = conn->session; 4569c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 457f41d4721SMike Christie int oldstate = task->state; 4587996a778SMike Christie 4594421c9ebSMike Christie ISCSI_DBG_SESSION(session, "freeing task itt 0x%x state %d sc %p\n", 4604421c9ebSMike Christie task->itt, task->state, task->sc); 4614421c9ebSMike Christie 462577577daSMike Christie session->tt->cleanup_task(task); 4633bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 4649c19a7d0SMike Christie task->sc = NULL; 4653e5c28adSMike Christie /* 4669c19a7d0SMike Christie * login task is preallocated so do not free 4673e5c28adSMike Christie */ 4689c19a7d0SMike Christie if (conn->login_task == task) 4693e5c28adSMike Christie return; 4703e5c28adSMike Christie 4717acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&task, sizeof(void*)); 4723e5c28adSMike Christie 4733e5c28adSMike Christie if (sc) { 474f47f2cf5SMike Christie /* SCSI eh reuses commands to verify us */ 475db22de3eSBart Van Assche iscsi_cmd(sc)->task = NULL; 4763e5c28adSMike Christie /* 477f41d4721SMike Christie * queue command may call this to free the task, so 478f41d4721SMike Christie * it will decide how to return sc to scsi-ml. 4793e5c28adSMike Christie */ 480f41d4721SMike Christie if (oldstate != ISCSI_TASK_REQUEUE_SCSIQ) 481b4b84edcSBart Van Assche scsi_done(sc); 4827996a778SMike Christie } 4833e5c28adSMike Christie } 4847996a778SMike Christie 485913e5bf4SMike Christie void __iscsi_get_task(struct iscsi_task *task) 48660ecebf5SMike Christie { 4876dc618cdSElena Reshetova refcount_inc(&task->refcount); 48860ecebf5SMike Christie } 489913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_get_task); 49060ecebf5SMike Christie 4918eea2f55SEddie Wai void __iscsi_put_task(struct iscsi_task *task) 49260ecebf5SMike Christie { 4936dc618cdSElena Reshetova if (refcount_dec_and_test(&task->refcount)) 4943bbaaad9SMike Christie iscsi_free_task(task); 49560ecebf5SMike Christie } 4968eea2f55SEddie Wai EXPORT_SYMBOL_GPL(__iscsi_put_task); 49760ecebf5SMike Christie 4989c19a7d0SMike Christie void iscsi_put_task(struct iscsi_task *task) 4993e5c28adSMike Christie { 5009c19a7d0SMike Christie struct iscsi_session *session = task->conn->session; 5013e5c28adSMike Christie 502659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 503659743b0SShlomo Pongratz spin_lock_bh(&session->back_lock); 5049c19a7d0SMike Christie __iscsi_put_task(task); 505659743b0SShlomo Pongratz spin_unlock_bh(&session->back_lock); 5063e5c28adSMike Christie } 5079c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_put_task); 5083e5c28adSMike Christie 5093bbaaad9SMike Christie /** 5103bbaaad9SMike Christie * iscsi_complete_task - finish a task 5113bbaaad9SMike Christie * @task: iscsi cmd task 512b3cd5050SMike Christie * @state: state to complete task with 5133bbaaad9SMike Christie * 514659743b0SShlomo Pongratz * Must be called with session back_lock. 515b3a7ea8dSMike Christie */ 516b3cd5050SMike Christie static void iscsi_complete_task(struct iscsi_task *task, int state) 517b3a7ea8dSMike Christie { 5183bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 5193bbaaad9SMike Christie 5204421c9ebSMike Christie ISCSI_DBG_SESSION(conn->session, 5214421c9ebSMike Christie "complete task itt 0x%x state %d sc %p\n", 5224421c9ebSMike Christie task->itt, task->state, task->sc); 523b3cd5050SMike Christie if (task->state == ISCSI_TASK_COMPLETED || 524b3cd5050SMike Christie task->state == ISCSI_TASK_ABRT_TMF || 525f41d4721SMike Christie task->state == ISCSI_TASK_ABRT_SESS_RECOV || 526f41d4721SMike Christie task->state == ISCSI_TASK_REQUEUE_SCSIQ) 5273bbaaad9SMike Christie return; 5283bbaaad9SMike Christie WARN_ON_ONCE(task->state == ISCSI_TASK_FREE); 529b3cd5050SMike Christie task->state = state; 5303bbaaad9SMike Christie 531fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task) == task) 532fe0a8a95SLee Duncan WRITE_ONCE(conn->ping_task, NULL); 5333bbaaad9SMike Christie 5343bbaaad9SMike Christie /* release get from queueing */ 5353bbaaad9SMike Christie __iscsi_put_task(task); 5363bbaaad9SMike Christie } 5373bbaaad9SMike Christie 5384c0ba5d2SMike Christie /** 5394c0ba5d2SMike Christie * iscsi_complete_scsi_task - finish scsi task normally 5404c0ba5d2SMike Christie * @task: iscsi task for scsi cmd 5414c0ba5d2SMike Christie * @exp_cmdsn: expected cmd sn in cpu format 5424c0ba5d2SMike Christie * @max_cmdsn: max cmd sn in cpu format 5434c0ba5d2SMike Christie * 5444c0ba5d2SMike Christie * This is used when drivers do not need or cannot perform 5454c0ba5d2SMike Christie * lower level pdu processing. 5464c0ba5d2SMike Christie * 547659743b0SShlomo Pongratz * Called with session back_lock 5484c0ba5d2SMike Christie */ 5494c0ba5d2SMike Christie void iscsi_complete_scsi_task(struct iscsi_task *task, 5504c0ba5d2SMike Christie uint32_t exp_cmdsn, uint32_t max_cmdsn) 5514c0ba5d2SMike Christie { 5524c0ba5d2SMike Christie struct iscsi_conn *conn = task->conn; 5534c0ba5d2SMike Christie 5544c0ba5d2SMike Christie ISCSI_DBG_SESSION(conn->session, "[itt 0x%x]\n", task->itt); 5554c0ba5d2SMike Christie 5564c0ba5d2SMike Christie conn->last_recv = jiffies; 5574c0ba5d2SMike Christie __iscsi_update_cmdsn(conn->session, exp_cmdsn, max_cmdsn); 5584c0ba5d2SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 5594c0ba5d2SMike Christie } 5604c0ba5d2SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_scsi_task); 5614c0ba5d2SMike Christie 5625923d64bSMike Christie /* 5635923d64bSMike Christie * Must be called with back and frwd lock 5645923d64bSMike Christie */ 5655923d64bSMike Christie static bool cleanup_queued_task(struct iscsi_task *task) 5665923d64bSMike Christie { 5675923d64bSMike Christie struct iscsi_conn *conn = task->conn; 5685923d64bSMike Christie bool early_complete = false; 5695923d64bSMike Christie 5705923d64bSMike Christie /* Bad target might have completed task while it was still running */ 5715923d64bSMike Christie if (task->state == ISCSI_TASK_COMPLETED) 5725923d64bSMike Christie early_complete = true; 5735923d64bSMike Christie 5745923d64bSMike Christie if (!list_empty(&task->running)) { 5755923d64bSMike Christie list_del_init(&task->running); 5765923d64bSMike Christie /* 5775923d64bSMike Christie * If it's on a list but still running, this could be from 5785923d64bSMike Christie * a bad target sending a rsp early, cleanup from a TMF, or 5795923d64bSMike Christie * session recovery. 5805923d64bSMike Christie */ 5815923d64bSMike Christie if (task->state == ISCSI_TASK_RUNNING || 5825923d64bSMike Christie task->state == ISCSI_TASK_COMPLETED) 5835923d64bSMike Christie __iscsi_put_task(task); 5845923d64bSMike Christie } 5855923d64bSMike Christie 58699b06033SMike Christie if (conn->session->running_aborted_task == task) { 58799b06033SMike Christie conn->session->running_aborted_task = NULL; 58899b06033SMike Christie __iscsi_put_task(task); 58999b06033SMike Christie } 59099b06033SMike Christie 5915923d64bSMike Christie if (conn->task == task) { 5925923d64bSMike Christie conn->task = NULL; 5935923d64bSMike Christie __iscsi_put_task(task); 5945923d64bSMike Christie } 5955923d64bSMike Christie 5965923d64bSMike Christie return early_complete; 5975923d64bSMike Christie } 5984c0ba5d2SMike Christie 5993bbaaad9SMike Christie /* 60014936b1eSMike Christie * session frwd lock must be held and if not called for a task that is still 60114936b1eSMike Christie * pending or from the xmit thread, then xmit thread must be suspended 6023bbaaad9SMike Christie */ 6033bbaaad9SMike Christie static void fail_scsi_task(struct iscsi_task *task, int err) 6043bbaaad9SMike Christie { 6053bbaaad9SMike Christie struct iscsi_conn *conn = task->conn; 606b3a7ea8dSMike Christie struct scsi_cmnd *sc; 607b3cd5050SMike Christie int state; 608b3a7ea8dSMike Christie 6095923d64bSMike Christie spin_lock_bh(&conn->session->back_lock); 6105923d64bSMike Christie if (cleanup_queued_task(task)) { 6115923d64bSMike Christie spin_unlock_bh(&conn->session->back_lock); 6125923d64bSMike Christie return; 6135923d64bSMike Christie } 6145923d64bSMike Christie 615b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) { 616b3a7ea8dSMike Christie /* 617b3a7ea8dSMike Christie * cmd never made it to the xmit thread, so we should not count 618b3a7ea8dSMike Christie * the cmd in the sequencing 619b3a7ea8dSMike Christie */ 620b3a7ea8dSMike Christie conn->session->queued_cmdsn--; 621b3cd5050SMike Christie /* it was never sent so just complete like normal */ 622b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 623b3cd5050SMike Christie } else if (err == DID_TRANSPORT_DISRUPTED) 624b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 625b3cd5050SMike Christie else 626b3cd5050SMike Christie state = ISCSI_TASK_ABRT_TMF; 627b3a7ea8dSMike Christie 62814936b1eSMike Christie sc = task->sc; 629b3cd5050SMike Christie sc->result = err << 16; 630b3a7ea8dSMike Christie scsi_set_resid(sc, scsi_bufflen(sc)); 631b3cd5050SMike Christie iscsi_complete_task(task, state); 632659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->back_lock); 633b3a7ea8dSMike Christie } 634b3a7ea8dSMike Christie 6353e5c28adSMike Christie static int iscsi_prep_mgmt_task(struct iscsi_conn *conn, 6369c19a7d0SMike Christie struct iscsi_task *task) 637052d0144SMike Christie { 638052d0144SMike Christie struct iscsi_session *session = conn->session; 639577577daSMike Christie struct iscsi_hdr *hdr = task->hdr; 640052d0144SMike Christie struct iscsi_nopout *nop = (struct iscsi_nopout *)hdr; 6414f704dc0SMike Christie uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 642052d0144SMike Christie 643052d0144SMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 644052d0144SMike Christie return -ENOTCONN; 645052d0144SMike Christie 6464f704dc0SMike Christie if (opcode != ISCSI_OP_LOGIN && opcode != ISCSI_OP_TEXT) 647052d0144SMike Christie nop->exp_statsn = cpu_to_be32(conn->exp_statsn); 648052d0144SMike Christie /* 649052d0144SMike Christie * pre-format CmdSN for outgoing PDU. 650052d0144SMike Christie */ 651052d0144SMike Christie nop->cmdsn = cpu_to_be32(session->cmdsn); 652052d0144SMike Christie if (hdr->itt != RESERVED_ITT) { 653052d0144SMike Christie /* 6544f704dc0SMike Christie * TODO: We always use immediate for normal session pdus. 655052d0144SMike Christie * If we start to send tmfs or nops as non-immediate then 656052d0144SMike Christie * we should start checking the cmdsn numbers for mgmt tasks. 6574f704dc0SMike Christie * 6584f704dc0SMike Christie * During discovery sessions iscsid sends TEXT as non immediate, 6594f704dc0SMike Christie * but we always only send one PDU at a time. 660052d0144SMike Christie */ 661052d0144SMike Christie if (conn->c_stage == ISCSI_CONN_STARTED && 662052d0144SMike Christie !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 663052d0144SMike Christie session->queued_cmdsn++; 664052d0144SMike Christie session->cmdsn++; 665052d0144SMike Christie } 666052d0144SMike Christie } 667052d0144SMike Christie 668ae15f801SMike Christie if (session->tt->init_task && session->tt->init_task(task)) 669ae15f801SMike Christie return -EIO; 670052d0144SMike Christie 671052d0144SMike Christie if ((hdr->opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_LOGOUT) 672052d0144SMike Christie session->state = ISCSI_STATE_LOGGING_OUT; 673052d0144SMike Christie 674577577daSMike Christie task->state = ISCSI_TASK_RUNNING; 6751b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "mgmtpdu [op 0x%x hdr->itt 0x%x " 6761b2c7af8SMike Christie "datalen %d]\n", hdr->opcode & ISCSI_OPCODE_MASK, 6771b2c7af8SMike Christie hdr->itt, task->data_count); 678052d0144SMike Christie return 0; 679052d0144SMike Christie } 680052d0144SMike Christie 6819c19a7d0SMike Christie static struct iscsi_task * 682f6d5180cSMike Christie __iscsi_conn_send_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 683f6d5180cSMike Christie char *data, uint32_t data_size) 684f6d5180cSMike Christie { 685f6d5180cSMike Christie struct iscsi_session *session = conn->session; 6861336aed1SMike Christie struct iscsi_host *ihost = shost_priv(session->host); 6874f704dc0SMike Christie uint8_t opcode = hdr->opcode & ISCSI_OPCODE_MASK; 6889c19a7d0SMike Christie struct iscsi_task *task; 689262ef636SMike Christie itt_t itt; 690f6d5180cSMike Christie 69144ac9710SMike Christie if (session->state == ISCSI_STATE_TERMINATE || 69244ac9710SMike Christie !test_bit(ISCSI_CONN_FLAG_BOUND, &conn->flags)) 693f6d5180cSMike Christie return NULL; 694f6d5180cSMike Christie 6954f704dc0SMike Christie if (opcode == ISCSI_OP_LOGIN || opcode == ISCSI_OP_TEXT) { 696f6d5180cSMike Christie /* 697f6d5180cSMike Christie * Login and Text are sent serially, in 698f6d5180cSMike Christie * request-followed-by-response sequence. 6993e5c28adSMike Christie * Same task can be used. Same ITT must be used. 7003e5c28adSMike Christie * Note that login_task is preallocated at conn_create(). 701f6d5180cSMike Christie */ 7024f704dc0SMike Christie if (conn->login_task->state != ISCSI_TASK_FREE) { 7034f704dc0SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Login/Text in " 7044f704dc0SMike Christie "progress. Cannot start new task.\n"); 7054f704dc0SMike Christie return NULL; 7064f704dc0SMike Christie } 7074f704dc0SMike Christie 708cbaa4221SMike Christie if (data_size > ISCSI_DEF_MAX_RECV_SEG_LEN) { 709cbaa4221SMike 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); 710cbaa4221SMike Christie return NULL; 711cbaa4221SMike Christie } 712cbaa4221SMike Christie 7139c19a7d0SMike Christie task = conn->login_task; 7144f704dc0SMike Christie } else { 71526013ad4SMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 71626013ad4SMike Christie return NULL; 71726013ad4SMike Christie 718cbaa4221SMike Christie if (data_size != 0) { 719cbaa4221SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Can not send data buffer of len %u for op 0x%x\n", data_size, opcode); 720cbaa4221SMike Christie return NULL; 721cbaa4221SMike Christie } 722cbaa4221SMike Christie 723f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_INITIAL_STAGE); 724f6d5180cSMike Christie BUG_ON(conn->c_stage == ISCSI_CONN_STOPPED); 725f6d5180cSMike Christie 7267acd72ebSStefani Seibold if (!kfifo_out(&session->cmdpool.queue, 7279c19a7d0SMike Christie (void*)&task, sizeof(void*))) 728f6d5180cSMike Christie return NULL; 729f6d5180cSMike Christie } 7303e5c28adSMike Christie /* 7313e5c28adSMike Christie * released in complete pdu for task we expect a response for, and 7323e5c28adSMike Christie * released by the lld when it has transmitted the task for 7333e5c28adSMike Christie * pdus we do not expect a response for. 7343e5c28adSMike Christie */ 7356dc618cdSElena Reshetova refcount_set(&task->refcount, 1); 7369c19a7d0SMike Christie task->conn = conn; 7379c19a7d0SMike Christie task->sc = NULL; 7383bbaaad9SMike Christie INIT_LIST_HEAD(&task->running); 7393bbaaad9SMike Christie task->state = ISCSI_TASK_PENDING; 740f6d5180cSMike Christie 741f6d5180cSMike Christie if (data_size) { 7429c19a7d0SMike Christie memcpy(task->data, data, data_size); 7439c19a7d0SMike Christie task->data_count = data_size; 744f6d5180cSMike Christie } else 7459c19a7d0SMike Christie task->data_count = 0; 746f6d5180cSMike Christie 747184b57c6SMike Christie if (conn->session->tt->alloc_pdu) { 7482ff79d52SMike Christie if (conn->session->tt->alloc_pdu(task, hdr->opcode)) { 749577577daSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not allocate " 750577577daSMike Christie "pdu for mgmt task.\n"); 7513bbaaad9SMike Christie goto free_task; 752577577daSMike Christie } 753184b57c6SMike Christie } 754184b57c6SMike Christie 755262ef636SMike Christie itt = task->hdr->itt; 756577577daSMike Christie task->hdr_len = sizeof(struct iscsi_hdr); 7579c19a7d0SMike Christie memcpy(task->hdr, hdr, sizeof(struct iscsi_hdr)); 758262ef636SMike Christie 759262ef636SMike Christie if (hdr->itt != RESERVED_ITT) { 760262ef636SMike Christie if (session->tt->parse_pdu_itt) 761262ef636SMike Christie task->hdr->itt = itt; 762262ef636SMike Christie else 763262ef636SMike Christie task->hdr->itt = build_itt(task->itt, 764262ef636SMike Christie task->conn->session->age); 765262ef636SMike Christie } 766262ef636SMike Christie 767fe0a8a95SLee Duncan if (unlikely(READ_ONCE(conn->ping_task) == INVALID_SCSI_TASK)) 768fe0a8a95SLee Duncan WRITE_ONCE(conn->ping_task, task); 769fe0a8a95SLee Duncan 7701336aed1SMike Christie if (!ihost->workq) { 771577577daSMike Christie if (iscsi_prep_mgmt_task(conn, task)) 772577577daSMike Christie goto free_task; 773052d0144SMike Christie 7749c19a7d0SMike Christie if (session->tt->xmit_task(task)) 775577577daSMike Christie goto free_task; 7763bbaaad9SMike Christie } else { 7773bbaaad9SMike Christie list_add_tail(&task->running, &conn->mgmtqueue); 7784b9f8ce4SMike Christie iscsi_conn_queue_xmit(conn); 7793bbaaad9SMike Christie } 780052d0144SMike Christie 7819c19a7d0SMike Christie return task; 782577577daSMike Christie 783577577daSMike Christie free_task: 784659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 7854fa50799SJitendra Bhivare spin_lock(&session->back_lock); 786577577daSMike Christie __iscsi_put_task(task); 7874fa50799SJitendra Bhivare spin_unlock(&session->back_lock); 788577577daSMike Christie return NULL; 789f6d5180cSMike Christie } 790f6d5180cSMike Christie 791f6d5180cSMike Christie int iscsi_conn_send_pdu(struct iscsi_cls_conn *cls_conn, struct iscsi_hdr *hdr, 792f6d5180cSMike Christie char *data, uint32_t data_size) 793f6d5180cSMike Christie { 794f6d5180cSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 795f6d5180cSMike Christie struct iscsi_session *session = conn->session; 796f6d5180cSMike Christie int err = 0; 797f6d5180cSMike Christie 798659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 799f6d5180cSMike Christie if (!__iscsi_conn_send_pdu(conn, hdr, data, data_size)) 800f6d5180cSMike Christie err = -EPERM; 801659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 802f6d5180cSMike Christie return err; 803f6d5180cSMike Christie } 804f6d5180cSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_send_pdu); 805f6d5180cSMike Christie 8067996a778SMike Christie /** 807ae6b4e69SMauro Carvalho Chehab * iscsi_scsi_cmd_rsp - SCSI Command Response processing 8087996a778SMike Christie * @conn: iscsi connection 8097996a778SMike Christie * @hdr: iscsi header 8109c19a7d0SMike Christie * @task: scsi command task 8117996a778SMike Christie * @data: cmd data buffer 8127996a778SMike Christie * @datalen: len of buffer 8137996a778SMike Christie * 8147996a778SMike Christie * iscsi_cmd_rsp sets up the scsi_cmnd fields based on the PDU and 815a656183eSLee Duncan * then completes the command and task. called under back_lock 8167996a778SMike Christie **/ 81777a23c21SMike Christie static void iscsi_scsi_cmd_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 8189c19a7d0SMike Christie struct iscsi_task *task, char *data, 8197996a778SMike Christie int datalen) 8207996a778SMike Christie { 82112352183SNicholas Bellinger struct iscsi_scsi_rsp *rhdr = (struct iscsi_scsi_rsp *)hdr; 8227996a778SMike Christie struct iscsi_session *session = conn->session; 8239c19a7d0SMike Christie struct scsi_cmnd *sc = task->sc; 8247996a778SMike Christie 82577a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)rhdr); 8267996a778SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 8277996a778SMike Christie 8287996a778SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 8297996a778SMike Christie 83055e51edaSSagi Grimberg if (task->protected) { 83155e51edaSSagi Grimberg sector_t sector; 83255e51edaSSagi Grimberg u8 ascq; 83355e51edaSSagi Grimberg 83455e51edaSSagi Grimberg /** 83555e51edaSSagi Grimberg * Transports that didn't implement check_protection 83655e51edaSSagi Grimberg * callback but still published T10-PI support to scsi-mid 83755e51edaSSagi Grimberg * deserve this BUG_ON. 83855e51edaSSagi Grimberg **/ 83955e51edaSSagi Grimberg BUG_ON(!session->tt->check_protection); 84055e51edaSSagi Grimberg 84155e51edaSSagi Grimberg ascq = session->tt->check_protection(task, §or); 84255e51edaSSagi Grimberg if (ascq) { 843f2b1e9c6SHannes Reinecke scsi_build_sense(sc, 1, ILLEGAL_REQUEST, 0x10, ascq); 844a73c2a2fSSagi Grimberg scsi_set_sense_information(sc->sense_buffer, 845a73c2a2fSSagi Grimberg SCSI_SENSE_BUFFERSIZE, 846a73c2a2fSSagi Grimberg sector); 84755e51edaSSagi Grimberg goto out; 84855e51edaSSagi Grimberg } 84955e51edaSSagi Grimberg } 85055e51edaSSagi Grimberg 8517996a778SMike Christie if (rhdr->response != ISCSI_STATUS_CMD_COMPLETED) { 8527996a778SMike Christie sc->result = DID_ERROR << 16; 8537996a778SMike Christie goto out; 8547996a778SMike Christie } 8557996a778SMike Christie 8567996a778SMike Christie if (rhdr->cmd_status == SAM_STAT_CHECK_CONDITION) { 8579b80cb4bSMike Christie uint16_t senselen; 8587996a778SMike Christie 8597996a778SMike Christie if (datalen < 2) { 8607996a778SMike Christie invalid_datalen: 861322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 862322d739dSMike Christie "Got CHECK_CONDITION but invalid data " 863322d739dSMike Christie "buffer size of %d\n", datalen); 8647996a778SMike Christie sc->result = DID_BAD_TARGET << 16; 8657996a778SMike Christie goto out; 8667996a778SMike Christie } 8677996a778SMike Christie 8688f333991SHarvey Harrison senselen = get_unaligned_be16(data); 8697996a778SMike Christie if (datalen < senselen) 8707996a778SMike Christie goto invalid_datalen; 8717996a778SMike Christie 8727996a778SMike Christie memcpy(sc->sense_buffer, data + 2, 8739b80cb4bSMike Christie min_t(uint16_t, senselen, SCSI_SENSE_BUFFERSIZE)); 8741b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "copied %d bytes of sense\n", 8751b2c7af8SMike Christie min_t(uint16_t, senselen, 8761b2c7af8SMike Christie SCSI_SENSE_BUFFERSIZE)); 8777996a778SMike Christie } 8787996a778SMike Christie 879c07d4444SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_BIDI_UNDERFLOW | 880c07d4444SBoaz Harrosh ISCSI_FLAG_CMD_BIDI_OVERFLOW)) { 881c07d4444SBoaz Harrosh sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 882c07d4444SBoaz Harrosh } 883c07d4444SBoaz Harrosh 8847207fea4SBoaz Harrosh if (rhdr->flags & (ISCSI_FLAG_CMD_UNDERFLOW | 8857207fea4SBoaz Harrosh ISCSI_FLAG_CMD_OVERFLOW)) { 8867996a778SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 8877996a778SMike Christie 8887207fea4SBoaz Harrosh if (res_count > 0 && 8897207fea4SBoaz Harrosh (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 8907207fea4SBoaz Harrosh res_count <= scsi_bufflen(sc))) 891c07d4444SBoaz Harrosh /* write side for bidi or uni-io set_resid */ 8921c138991SFUJITA Tomonori scsi_set_resid(sc, res_count); 8937996a778SMike Christie else 8947996a778SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 895c07d4444SBoaz Harrosh } 8967996a778SMike Christie out: 8973bbaaad9SMike Christie ISCSI_DBG_SESSION(session, "cmd rsp done [sc %p res %d itt 0x%x]\n", 8981b2c7af8SMike Christie sc, sc->result, task->itt); 8997996a778SMike Christie conn->scsirsp_pdus_cnt++; 900b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 9017996a778SMike Christie } 9027996a778SMike Christie 9031d9edf02SMike Christie /** 9041d9edf02SMike Christie * iscsi_data_in_rsp - SCSI Data-In Response processing 9051d9edf02SMike Christie * @conn: iscsi connection 9061d9edf02SMike Christie * @hdr: iscsi pdu 9071d9edf02SMike Christie * @task: scsi command task 908a656183eSLee Duncan * 909a656183eSLee Duncan * iscsi_data_in_rsp sets up the scsi_cmnd fields based on the data received 910a656183eSLee Duncan * then completes the command and task. called under back_lock 9111d9edf02SMike Christie **/ 9121d9edf02SMike Christie static void 9131d9edf02SMike Christie iscsi_data_in_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 9141d9edf02SMike Christie struct iscsi_task *task) 9151d9edf02SMike Christie { 9161d9edf02SMike Christie struct iscsi_data_rsp *rhdr = (struct iscsi_data_rsp *)hdr; 9171d9edf02SMike Christie struct scsi_cmnd *sc = task->sc; 9181d9edf02SMike Christie 9191d9edf02SMike Christie if (!(rhdr->flags & ISCSI_FLAG_DATA_STATUS)) 9201d9edf02SMike Christie return; 9211d9edf02SMike Christie 922edbc9aa0SMike Christie iscsi_update_cmdsn(conn->session, (struct iscsi_nopin *)hdr); 9231d9edf02SMike Christie sc->result = (DID_OK << 16) | rhdr->cmd_status; 9241d9edf02SMike Christie conn->exp_statsn = be32_to_cpu(rhdr->statsn) + 1; 9251d9edf02SMike Christie if (rhdr->flags & (ISCSI_FLAG_DATA_UNDERFLOW | 9261d9edf02SMike Christie ISCSI_FLAG_DATA_OVERFLOW)) { 9271d9edf02SMike Christie int res_count = be32_to_cpu(rhdr->residual_count); 9281d9edf02SMike Christie 9291d9edf02SMike Christie if (res_count > 0 && 9301d9edf02SMike Christie (rhdr->flags & ISCSI_FLAG_CMD_OVERFLOW || 931ae3d56d8SChristoph Hellwig res_count <= sc->sdb.length)) 932960bf87aSBart Van Assche scsi_set_resid(sc, res_count); 9331d9edf02SMike Christie else 9341d9edf02SMike Christie sc->result = (DID_BAD_TARGET << 16) | rhdr->cmd_status; 9351d9edf02SMike Christie } 9361d9edf02SMike Christie 9373bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, "data in with status done " 9383bbaaad9SMike Christie "[sc %p res %d itt 0x%x]\n", 9393bbaaad9SMike Christie sc, sc->result, task->itt); 9401d9edf02SMike Christie conn->scsirsp_pdus_cnt++; 941b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 9421d9edf02SMike Christie } 9431d9edf02SMike Christie 9447ea8b828SMike Christie static void iscsi_tmf_rsp(struct iscsi_conn *conn, struct iscsi_hdr *hdr) 9457ea8b828SMike Christie { 9467ea8b828SMike Christie struct iscsi_tm_rsp *tmf = (struct iscsi_tm_rsp *)hdr; 947ec29d0acSMike Christie struct iscsi_session *session = conn->session; 9487ea8b828SMike Christie 9497ea8b828SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 9507ea8b828SMike Christie conn->tmfrsp_pdus_cnt++; 9517ea8b828SMike Christie 952ec29d0acSMike Christie if (session->tmf_state != TMF_QUEUED) 9537ea8b828SMike Christie return; 9547ea8b828SMike Christie 9557ea8b828SMike Christie if (tmf->response == ISCSI_TMF_RSP_COMPLETE) 956ec29d0acSMike Christie session->tmf_state = TMF_SUCCESS; 9577ea8b828SMike Christie else if (tmf->response == ISCSI_TMF_RSP_NO_TASK) 958ec29d0acSMike Christie session->tmf_state = TMF_NOT_FOUND; 9597ea8b828SMike Christie else 960ec29d0acSMike Christie session->tmf_state = TMF_FAILED; 961ec29d0acSMike Christie wake_up(&session->ehwait); 9627ea8b828SMike Christie } 9637ea8b828SMike Christie 96452f5664aSAriel Nahum static int iscsi_send_nopout(struct iscsi_conn *conn, struct iscsi_nopin *rhdr) 965f6d5180cSMike Christie { 966f6d5180cSMike Christie struct iscsi_nopout hdr; 9679c19a7d0SMike Christie struct iscsi_task *task; 968f6d5180cSMike Christie 969fe0a8a95SLee Duncan if (!rhdr) { 970fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task)) 97152f5664aSAriel Nahum return -EINVAL; 972fe0a8a95SLee Duncan WRITE_ONCE(conn->ping_task, INVALID_SCSI_TASK); 973fe0a8a95SLee Duncan } 974f6d5180cSMike Christie 975f6d5180cSMike Christie memset(&hdr, 0, sizeof(struct iscsi_nopout)); 976f6d5180cSMike Christie hdr.opcode = ISCSI_OP_NOOP_OUT | ISCSI_OP_IMMEDIATE; 977f6d5180cSMike Christie hdr.flags = ISCSI_FLAG_CMD_FINAL; 978f6d5180cSMike Christie 979f6d5180cSMike Christie if (rhdr) { 98055bdabdfSAndy Grover hdr.lun = rhdr->lun; 981f6d5180cSMike Christie hdr.ttt = rhdr->ttt; 982f6d5180cSMike Christie hdr.itt = RESERVED_ITT; 983f6d5180cSMike Christie } else 984f6d5180cSMike Christie hdr.ttt = RESERVED_ITT; 985f6d5180cSMike Christie 9869c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)&hdr, NULL, 0); 98752f5664aSAriel Nahum if (!task) { 988fe0a8a95SLee Duncan if (!rhdr) 989fe0a8a95SLee Duncan WRITE_ONCE(conn->ping_task, NULL); 990322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send nopout\n"); 99152f5664aSAriel Nahum return -EIO; 99252f5664aSAriel Nahum } else if (!rhdr) { 993d3acf022SMike Christie /* only track our nops */ 994d3acf022SMike Christie conn->last_ping = jiffies; 995d3acf022SMike Christie } 99652f5664aSAriel Nahum 99752f5664aSAriel Nahum return 0; 998f6d5180cSMike Christie } 999f6d5180cSMike Christie 1000a656183eSLee Duncan /** 1001a656183eSLee Duncan * iscsi_nop_out_rsp - SCSI NOP Response processing 1002a656183eSLee Duncan * @task: scsi command task 1003a656183eSLee Duncan * @nop: the nop structure 1004a656183eSLee Duncan * @data: where to put the data 1005a656183eSLee Duncan * @datalen: length of data 1006a656183eSLee Duncan * 1007a656183eSLee Duncan * iscsi_nop_out_rsp handles nop response from use or 1008a656183eSLee Duncan * from user space. called under back_lock 1009a656183eSLee Duncan **/ 10108afa1439SMike Christie static int iscsi_nop_out_rsp(struct iscsi_task *task, 10118afa1439SMike Christie struct iscsi_nopin *nop, char *data, int datalen) 10128afa1439SMike Christie { 10138afa1439SMike Christie struct iscsi_conn *conn = task->conn; 10148afa1439SMike Christie int rc = 0; 10158afa1439SMike Christie 1016fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task) != task) { 10178afa1439SMike Christie /* 10188afa1439SMike Christie * If this is not in response to one of our 10198afa1439SMike Christie * nops then it must be from userspace. 10208afa1439SMike Christie */ 10218afa1439SMike Christie if (iscsi_recv_pdu(conn->cls_conn, (struct iscsi_hdr *)nop, 10228afa1439SMike Christie data, datalen)) 10238afa1439SMike Christie rc = ISCSI_ERR_CONN_FAILED; 10248afa1439SMike Christie } else 10258afa1439SMike Christie mod_timer(&conn->transport_timer, jiffies + conn->recv_timeout); 10268afa1439SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 10278afa1439SMike Christie return rc; 10288afa1439SMike Christie } 10298afa1439SMike Christie 103062f38300SMike Christie static int iscsi_handle_reject(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 103162f38300SMike Christie char *data, int datalen) 103262f38300SMike Christie { 103362f38300SMike Christie struct iscsi_reject *reject = (struct iscsi_reject *)hdr; 103462f38300SMike Christie struct iscsi_hdr rejected_pdu; 10358afa1439SMike Christie int opcode, rc = 0; 103662f38300SMike Christie 103762f38300SMike Christie conn->exp_statsn = be32_to_cpu(reject->statsn) + 1; 103862f38300SMike Christie 10398afa1439SMike Christie if (ntoh24(reject->dlength) > datalen || 10408afa1439SMike Christie ntoh24(reject->dlength) < sizeof(struct iscsi_hdr)) { 10418afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, "Cannot handle rejected " 10428afa1439SMike Christie "pdu. Invalid data length (pdu dlength " 10438afa1439SMike Christie "%u, datalen %d\n", ntoh24(reject->dlength), 10448afa1439SMike Christie datalen); 104562f38300SMike Christie return ISCSI_ERR_PROTO; 10468afa1439SMike Christie } 104762f38300SMike Christie memcpy(&rejected_pdu, data, sizeof(struct iscsi_hdr)); 10488afa1439SMike Christie opcode = rejected_pdu.opcode & ISCSI_OPCODE_MASK; 10498afa1439SMike Christie 10508afa1439SMike Christie switch (reject->reason) { 10518afa1439SMike Christie case ISCSI_REASON_DATA_DIGEST_ERROR: 1052322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 10538afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected " 1054262ef636SMike Christie "due to DataDigest error.\n", 1055e5dbbe27SVaughan Cao opcode, rejected_pdu.itt); 10568afa1439SMike Christie break; 10578afa1439SMike Christie case ISCSI_REASON_IMM_CMD_REJECT: 10588afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 10598afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Too many " 10608afa1439SMike Christie "immediate commands.\n", 1061e5dbbe27SVaughan Cao opcode, rejected_pdu.itt); 10628afa1439SMike Christie /* 10638afa1439SMike Christie * We only send one TMF at a time so if the target could not 10648afa1439SMike Christie * handle it, then it should get fixed (RFC mandates that 10658afa1439SMike Christie * a target can handle one immediate TMF per conn). 10668afa1439SMike Christie * 10678afa1439SMike Christie * For nops-outs, we could have sent more than one if 10688afa1439SMike Christie * the target is sending us lots of nop-ins 10698afa1439SMike Christie */ 10708afa1439SMike Christie if (opcode != ISCSI_OP_NOOP_OUT) 107162f38300SMike Christie return 0; 10728afa1439SMike Christie 1073659743b0SShlomo Pongratz if (rejected_pdu.itt == cpu_to_be32(ISCSI_RESERVED_TAG)) { 10748afa1439SMike Christie /* 10758afa1439SMike Christie * nop-out in response to target's nop-out rejected. 10768afa1439SMike Christie * Just resend. 10778afa1439SMike Christie */ 1078659743b0SShlomo Pongratz /* In RX path we are under back lock */ 1079659743b0SShlomo Pongratz spin_unlock(&conn->session->back_lock); 1080659743b0SShlomo Pongratz spin_lock(&conn->session->frwd_lock); 10818afa1439SMike Christie iscsi_send_nopout(conn, 10828afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu); 1083659743b0SShlomo Pongratz spin_unlock(&conn->session->frwd_lock); 1084659743b0SShlomo Pongratz spin_lock(&conn->session->back_lock); 1085659743b0SShlomo Pongratz } else { 10868afa1439SMike Christie struct iscsi_task *task; 10878afa1439SMike Christie /* 10888afa1439SMike Christie * Our nop as ping got dropped. We know the target 10898afa1439SMike Christie * and transport are ok so just clean up 10908afa1439SMike Christie */ 10918afa1439SMike Christie task = iscsi_itt_to_task(conn, rejected_pdu.itt); 10928afa1439SMike Christie if (!task) { 10938afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 10948afa1439SMike Christie "Invalid pdu reject. Could " 10958afa1439SMike Christie "not lookup rejected task.\n"); 10968afa1439SMike Christie rc = ISCSI_ERR_BAD_ITT; 10978afa1439SMike Christie } else 10988afa1439SMike Christie rc = iscsi_nop_out_rsp(task, 10998afa1439SMike Christie (struct iscsi_nopin*)&rejected_pdu, 11008afa1439SMike Christie NULL, 0); 11018afa1439SMike Christie } 11028afa1439SMike Christie break; 11038afa1439SMike Christie default: 11048afa1439SMike Christie iscsi_conn_printk(KERN_ERR, conn, 11058afa1439SMike Christie "pdu (op 0x%x itt 0x%x) rejected. Reason " 1106e5dbbe27SVaughan Cao "code 0x%x\n", rejected_pdu.opcode, 1107e5dbbe27SVaughan Cao rejected_pdu.itt, reject->reason); 11088afa1439SMike Christie break; 11098afa1439SMike Christie } 11108afa1439SMike Christie return rc; 111162f38300SMike Christie } 111262f38300SMike Christie 11137996a778SMike Christie /** 1114913e5bf4SMike Christie * iscsi_itt_to_task - look up task by itt 1115913e5bf4SMike Christie * @conn: iscsi connection 1116913e5bf4SMike Christie * @itt: itt 1117913e5bf4SMike Christie * 1118913e5bf4SMike Christie * This should be used for mgmt tasks like login and nops, or if 1119913e5bf4SMike Christie * the LDD's itt space does not include the session age. 1120913e5bf4SMike Christie * 1121659743b0SShlomo Pongratz * The session back_lock must be held. 1122913e5bf4SMike Christie */ 11238f9256ceSMike Christie struct iscsi_task *iscsi_itt_to_task(struct iscsi_conn *conn, itt_t itt) 1124913e5bf4SMike Christie { 1125913e5bf4SMike Christie struct iscsi_session *session = conn->session; 1126262ef636SMike Christie int i; 1127913e5bf4SMike Christie 1128913e5bf4SMike Christie if (itt == RESERVED_ITT) 1129913e5bf4SMike Christie return NULL; 1130913e5bf4SMike Christie 1131262ef636SMike Christie if (session->tt->parse_pdu_itt) 1132262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, NULL); 1133262ef636SMike Christie else 1134913e5bf4SMike Christie i = get_itt(itt); 1135913e5bf4SMike Christie if (i >= session->cmds_max) 1136913e5bf4SMike Christie return NULL; 1137913e5bf4SMike Christie 1138913e5bf4SMike Christie return session->cmds[i]; 1139913e5bf4SMike Christie } 11408f9256ceSMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_task); 1141913e5bf4SMike Christie 1142913e5bf4SMike Christie /** 11437996a778SMike Christie * __iscsi_complete_pdu - complete pdu 11447996a778SMike Christie * @conn: iscsi conn 11457996a778SMike Christie * @hdr: iscsi header 11467996a778SMike Christie * @data: data buffer 11477996a778SMike Christie * @datalen: len of data buffer 11487996a778SMike Christie * 11497996a778SMike Christie * Completes pdu processing by freeing any resources allocated at 1150659743b0SShlomo Pongratz * queuecommand or send generic. session back_lock must be held and verify 11517996a778SMike Christie * itt must have been called. 11527996a778SMike Christie */ 1153913e5bf4SMike Christie int __iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 11547996a778SMike Christie char *data, int datalen) 11557996a778SMike Christie { 11567996a778SMike Christie struct iscsi_session *session = conn->session; 11577996a778SMike Christie int opcode = hdr->opcode & ISCSI_OPCODE_MASK, rc = 0; 11589c19a7d0SMike Christie struct iscsi_task *task; 11597996a778SMike Christie uint32_t itt; 11607996a778SMike Christie 1161f6d5180cSMike Christie conn->last_recv = jiffies; 11620af967f5SMike Christie rc = iscsi_verify_itt(conn, hdr->itt); 11630af967f5SMike Christie if (rc) 11640af967f5SMike Christie return rc; 11650af967f5SMike Christie 1166b4377356SAl Viro if (hdr->itt != RESERVED_ITT) 1167b4377356SAl Viro itt = get_itt(hdr->itt); 11687996a778SMike Christie else 1169b4377356SAl Viro itt = ~0U; 11707996a778SMike Christie 11711b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "[op 0x%x cid %d itt 0x%x len %d]\n", 11723e5c28adSMike Christie opcode, conn->id, itt, datalen); 11737996a778SMike Christie 11743e5c28adSMike Christie if (itt == ~0U) { 117577a23c21SMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 117662f38300SMike Christie 11777996a778SMike Christie switch(opcode) { 11787996a778SMike Christie case ISCSI_OP_NOOP_IN: 117940527afeSMike Christie if (datalen) { 118040527afeSMike Christie rc = ISCSI_ERR_PROTO; 118140527afeSMike Christie break; 118240527afeSMike Christie } 118340527afeSMike Christie 1184b4377356SAl Viro if (hdr->ttt == cpu_to_be32(ISCSI_RESERVED_TAG)) 118540527afeSMike Christie break; 118640527afeSMike Christie 1187659743b0SShlomo Pongratz /* In RX path we are under back lock */ 1188659743b0SShlomo Pongratz spin_unlock(&session->back_lock); 1189659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 1190f6d5180cSMike Christie iscsi_send_nopout(conn, (struct iscsi_nopin*)hdr); 1191659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 1192659743b0SShlomo Pongratz spin_lock(&session->back_lock); 11937996a778SMike Christie break; 11947996a778SMike Christie case ISCSI_OP_REJECT: 119562f38300SMike Christie rc = iscsi_handle_reject(conn, hdr, data, datalen); 119662f38300SMike Christie break; 11977996a778SMike Christie case ISCSI_OP_ASYNC_EVENT: 11988d2860b3SMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 11995831c737SMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 12005831c737SMike Christie rc = ISCSI_ERR_CONN_FAILED; 12017996a778SMike Christie break; 12027996a778SMike Christie default: 12037996a778SMike Christie rc = ISCSI_ERR_BAD_OPCODE; 12047996a778SMike Christie break; 12057996a778SMike Christie } 12063e5c28adSMike Christie goto out; 12073e5c28adSMike Christie } 12087996a778SMike Christie 12093e5c28adSMike Christie switch(opcode) { 12103e5c28adSMike Christie case ISCSI_OP_SCSI_CMD_RSP: 1211913e5bf4SMike Christie case ISCSI_OP_SCSI_DATA_IN: 1212913e5bf4SMike Christie task = iscsi_itt_to_ctask(conn, hdr->itt); 1213913e5bf4SMike Christie if (!task) 1214913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1215d355e57dSMike Christie task->last_xfer = jiffies; 12163e5c28adSMike Christie break; 1217913e5bf4SMike Christie case ISCSI_OP_R2T: 1218913e5bf4SMike Christie /* 1219913e5bf4SMike Christie * LLD handles R2Ts if they need to. 1220913e5bf4SMike Christie */ 1221913e5bf4SMike Christie return 0; 1222913e5bf4SMike Christie case ISCSI_OP_LOGOUT_RSP: 1223913e5bf4SMike Christie case ISCSI_OP_LOGIN_RSP: 1224913e5bf4SMike Christie case ISCSI_OP_TEXT_RSP: 1225913e5bf4SMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 1226913e5bf4SMike Christie case ISCSI_OP_NOOP_IN: 1227913e5bf4SMike Christie task = iscsi_itt_to_task(conn, hdr->itt); 1228913e5bf4SMike Christie if (!task) 1229913e5bf4SMike Christie return ISCSI_ERR_BAD_ITT; 1230913e5bf4SMike Christie break; 1231913e5bf4SMike Christie default: 1232913e5bf4SMike Christie return ISCSI_ERR_BAD_OPCODE; 12333e5c28adSMike Christie } 1234913e5bf4SMike Christie 1235913e5bf4SMike Christie switch(opcode) { 1236913e5bf4SMike Christie case ISCSI_OP_SCSI_CMD_RSP: 12379c19a7d0SMike Christie iscsi_scsi_cmd_rsp(conn, hdr, task, data, datalen); 12383e5c28adSMike Christie break; 12393e5c28adSMike Christie case ISCSI_OP_SCSI_DATA_IN: 12401d9edf02SMike Christie iscsi_data_in_rsp(conn, hdr, task); 12413e5c28adSMike Christie break; 12423e5c28adSMike Christie case ISCSI_OP_LOGOUT_RSP: 12433e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12443e5c28adSMike Christie if (datalen) { 12453e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12463e5c28adSMike Christie break; 12473e5c28adSMike Christie } 12483e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 12493e5c28adSMike Christie goto recv_pdu; 12503e5c28adSMike Christie case ISCSI_OP_LOGIN_RSP: 12513e5c28adSMike Christie case ISCSI_OP_TEXT_RSP: 12523e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12533e5c28adSMike Christie /* 12543e5c28adSMike Christie * login related PDU's exp_statsn is handled in 12553e5c28adSMike Christie * userspace 12563e5c28adSMike Christie */ 12573e5c28adSMike Christie goto recv_pdu; 12583e5c28adSMike Christie case ISCSI_OP_SCSI_TMFUNC_RSP: 12593e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12603e5c28adSMike Christie if (datalen) { 12613e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12623e5c28adSMike Christie break; 12633e5c28adSMike Christie } 12643e5c28adSMike Christie 12653e5c28adSMike Christie iscsi_tmf_rsp(conn, hdr); 1266b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 12673e5c28adSMike Christie break; 12683e5c28adSMike Christie case ISCSI_OP_NOOP_IN: 12693e5c28adSMike Christie iscsi_update_cmdsn(session, (struct iscsi_nopin*)hdr); 12703e5c28adSMike Christie if (hdr->ttt != cpu_to_be32(ISCSI_RESERVED_TAG) || datalen) { 12713e5c28adSMike Christie rc = ISCSI_ERR_PROTO; 12723e5c28adSMike Christie break; 12733e5c28adSMike Christie } 12743e5c28adSMike Christie conn->exp_statsn = be32_to_cpu(hdr->statsn) + 1; 12753e5c28adSMike Christie 12768afa1439SMike Christie rc = iscsi_nop_out_rsp(task, (struct iscsi_nopin*)hdr, 12778afa1439SMike Christie data, datalen); 12783e5c28adSMike Christie break; 12793e5c28adSMike Christie default: 12803e5c28adSMike Christie rc = ISCSI_ERR_BAD_OPCODE; 12813e5c28adSMike Christie break; 12823e5c28adSMike Christie } 12833e5c28adSMike Christie 12843e5c28adSMike Christie out: 12853e5c28adSMike Christie return rc; 12863e5c28adSMike Christie recv_pdu: 12873e5c28adSMike Christie if (iscsi_recv_pdu(conn->cls_conn, hdr, data, datalen)) 12883e5c28adSMike Christie rc = ISCSI_ERR_CONN_FAILED; 1289b3cd5050SMike Christie iscsi_complete_task(task, ISCSI_TASK_COMPLETED); 12907996a778SMike Christie return rc; 12917996a778SMike Christie } 1292913e5bf4SMike Christie EXPORT_SYMBOL_GPL(__iscsi_complete_pdu); 12937996a778SMike Christie 12947996a778SMike Christie int iscsi_complete_pdu(struct iscsi_conn *conn, struct iscsi_hdr *hdr, 12957996a778SMike Christie char *data, int datalen) 12967996a778SMike Christie { 12977996a778SMike Christie int rc; 12987996a778SMike Christie 1299659743b0SShlomo Pongratz spin_lock(&conn->session->back_lock); 13007996a778SMike Christie rc = __iscsi_complete_pdu(conn, hdr, data, datalen); 1301659743b0SShlomo Pongratz spin_unlock(&conn->session->back_lock); 13027996a778SMike Christie return rc; 13037996a778SMike Christie } 13047996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_complete_pdu); 13057996a778SMike Christie 13060af967f5SMike Christie int iscsi_verify_itt(struct iscsi_conn *conn, itt_t itt) 13077996a778SMike Christie { 13087996a778SMike Christie struct iscsi_session *session = conn->session; 1309262ef636SMike Christie int age = 0, i = 0; 13107996a778SMike Christie 13110af967f5SMike Christie if (itt == RESERVED_ITT) 13120af967f5SMike Christie return 0; 13130af967f5SMike Christie 1314262ef636SMike Christie if (session->tt->parse_pdu_itt) 1315262ef636SMike Christie session->tt->parse_pdu_itt(conn, itt, &i, &age); 1316262ef636SMike Christie else { 1317262ef636SMike Christie i = get_itt(itt); 1318262ef636SMike Christie age = ((__force u32)itt >> ISCSI_AGE_SHIFT) & ISCSI_AGE_MASK; 1319262ef636SMike Christie } 1320262ef636SMike Christie 1321262ef636SMike Christie if (age != session->age) { 1322322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 13230af967f5SMike Christie "received itt %x expected session age (%x)\n", 1324913e5bf4SMike Christie (__force u32)itt, session->age); 13257996a778SMike Christie return ISCSI_ERR_BAD_ITT; 13267996a778SMike Christie } 13277996a778SMike Christie 13283e5c28adSMike Christie if (i >= session->cmds_max) { 13293e5c28adSMike Christie iscsi_conn_printk(KERN_ERR, conn, 13303e5c28adSMike Christie "received invalid itt index %u (max cmds " 13313e5c28adSMike Christie "%u.\n", i, session->cmds_max); 13323e5c28adSMike Christie return ISCSI_ERR_BAD_ITT; 13337996a778SMike Christie } 13347996a778SMike Christie return 0; 13357996a778SMike Christie } 13367996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_verify_itt); 13377996a778SMike Christie 1338913e5bf4SMike Christie /** 1339913e5bf4SMike Christie * iscsi_itt_to_ctask - look up ctask by itt 1340913e5bf4SMike Christie * @conn: iscsi connection 1341913e5bf4SMike Christie * @itt: itt 1342913e5bf4SMike Christie * 1343913e5bf4SMike Christie * This should be used for cmd tasks. 1344913e5bf4SMike Christie * 1345659743b0SShlomo Pongratz * The session back_lock must be held. 1346913e5bf4SMike Christie */ 1347913e5bf4SMike Christie struct iscsi_task *iscsi_itt_to_ctask(struct iscsi_conn *conn, itt_t itt) 13480af967f5SMike Christie { 13499c19a7d0SMike Christie struct iscsi_task *task; 13500af967f5SMike Christie 13510af967f5SMike Christie if (iscsi_verify_itt(conn, itt)) 13520af967f5SMike Christie return NULL; 13530af967f5SMike Christie 1354913e5bf4SMike Christie task = iscsi_itt_to_task(conn, itt); 1355913e5bf4SMike Christie if (!task || !task->sc) 13560af967f5SMike Christie return NULL; 13570af967f5SMike Christie 1358db22de3eSBart Van Assche if (iscsi_cmd(task->sc)->age != conn->session->age) { 1359913e5bf4SMike Christie iscsi_session_printk(KERN_ERR, conn->session, 1360913e5bf4SMike Christie "task's session age %d, expected %d\n", 1361db22de3eSBart Van Assche iscsi_cmd(task->sc)->age, conn->session->age); 13620af967f5SMike Christie return NULL; 1363913e5bf4SMike Christie } 13640af967f5SMike Christie 13659c19a7d0SMike Christie return task; 13660af967f5SMike Christie } 13670af967f5SMike Christie EXPORT_SYMBOL_GPL(iscsi_itt_to_ctask); 13680af967f5SMike Christie 136940a06e75SMike Christie void iscsi_session_failure(struct iscsi_session *session, 1370e5bd7b54SMike Christie enum iscsi_err err) 1371e5bd7b54SMike Christie { 1372e5bd7b54SMike Christie struct iscsi_conn *conn; 1373e5bd7b54SMike Christie 1374659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 1375e5bd7b54SMike Christie conn = session->leadconn; 1376e5bd7b54SMike Christie if (session->state == ISCSI_STATE_TERMINATE || !conn) { 1377659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1378e5bd7b54SMike Christie return; 1379e5bd7b54SMike Christie } 1380e5bd7b54SMike Christie 1381b1d19e8cSMike Christie iscsi_get_conn(conn->cls_conn); 1382659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1383e5bd7b54SMike Christie /* 1384e5bd7b54SMike Christie * if the host is being removed bypass the connection 1385e5bd7b54SMike Christie * recovery initialization because we are going to kill 1386e5bd7b54SMike Christie * the session. 1387e5bd7b54SMike Christie */ 1388e5bd7b54SMike Christie if (err == ISCSI_ERR_INVALID_HOST) 1389e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 1390e5bd7b54SMike Christie else 1391e5bd7b54SMike Christie iscsi_conn_failure(conn, err); 1392b1d19e8cSMike Christie iscsi_put_conn(conn->cls_conn); 1393e5bd7b54SMike Christie } 1394e5bd7b54SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_failure); 1395e5bd7b54SMike Christie 1396891e2639SMike Christie static bool iscsi_set_conn_failed(struct iscsi_conn *conn) 13977996a778SMike Christie { 13987996a778SMike Christie struct iscsi_session *session = conn->session; 13997996a778SMike Christie 1400891e2639SMike Christie if (session->state == ISCSI_STATE_FAILED) 1401891e2639SMike Christie return false; 1402656cffc9SMike Christie 140367a61114SMike Christie if (conn->stop_stage == 0) 14047996a778SMike Christie session->state = ISCSI_STATE_FAILED; 1405e5bd7b54SMike Christie 14065bd85625SMike Christie set_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags); 14075bd85625SMike Christie set_bit(ISCSI_CONN_FLAG_SUSPEND_RX, &conn->flags); 1408891e2639SMike Christie return true; 1409891e2639SMike Christie } 1410891e2639SMike Christie 1411891e2639SMike Christie void iscsi_conn_failure(struct iscsi_conn *conn, enum iscsi_err err) 1412891e2639SMike Christie { 1413891e2639SMike Christie struct iscsi_session *session = conn->session; 1414891e2639SMike Christie bool needs_evt; 1415891e2639SMike Christie 1416891e2639SMike Christie spin_lock_bh(&session->frwd_lock); 1417891e2639SMike Christie needs_evt = iscsi_set_conn_failed(conn); 1418891e2639SMike Christie spin_unlock_bh(&session->frwd_lock); 1419891e2639SMike Christie 1420891e2639SMike Christie if (needs_evt) 1421e5bd7b54SMike Christie iscsi_conn_error_event(conn->cls_conn, err); 14227996a778SMike Christie } 14237996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_failure); 14247996a778SMike Christie 142577a23c21SMike Christie static int iscsi_check_cmdsn_window_closed(struct iscsi_conn *conn) 142677a23c21SMike Christie { 142777a23c21SMike Christie struct iscsi_session *session = conn->session; 142877a23c21SMike Christie 142977a23c21SMike Christie /* 143077a23c21SMike Christie * Check for iSCSI window and take care of CmdSN wrap-around 143177a23c21SMike Christie */ 1432e0726407SMike Christie if (!iscsi_sna_lte(session->queued_cmdsn, session->max_cmdsn)) { 14331b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iSCSI CmdSN closed. ExpCmdSn " 14341b2c7af8SMike Christie "%u MaxCmdSN %u CmdSN %u/%u\n", 14351b2c7af8SMike Christie session->exp_cmdsn, session->max_cmdsn, 14361b2c7af8SMike Christie session->cmdsn, session->queued_cmdsn); 143777a23c21SMike Christie return -ENOSPC; 143877a23c21SMike Christie } 143977a23c21SMike Christie return 0; 144077a23c21SMike Christie } 144177a23c21SMike Christie 14425923d64bSMike Christie static int iscsi_xmit_task(struct iscsi_conn *conn, struct iscsi_task *task, 14435923d64bSMike Christie bool was_requeue) 144477a23c21SMike Christie { 1445843c0a8aSMike Christie int rc; 144677a23c21SMike Christie 144779edd00dSAnoob Soman spin_lock_bh(&conn->session->back_lock); 14485923d64bSMike Christie 14495923d64bSMike Christie if (!conn->task) { 14505923d64bSMike Christie /* Take a ref so we can access it after xmit_task() */ 14515923d64bSMike Christie __iscsi_get_task(task); 14525923d64bSMike Christie } else { 14535923d64bSMike Christie /* Already have a ref from when we failed to send it last call */ 14545923d64bSMike Christie conn->task = NULL; 14555923d64bSMike Christie } 14565923d64bSMike Christie 14575923d64bSMike Christie /* 14585923d64bSMike Christie * If this was a requeue for a R2T we have an extra ref on the task in 14595923d64bSMike Christie * case a bad target sends a cmd rsp before we have handled the task. 14605923d64bSMike Christie */ 14615923d64bSMike Christie if (was_requeue) 14625923d64bSMike Christie __iscsi_put_task(task); 14635923d64bSMike Christie 14645923d64bSMike Christie /* 14655923d64bSMike Christie * Do this after dropping the extra ref because if this was a requeue 14665923d64bSMike Christie * it's removed from that list and cleanup_queued_task would miss it. 14675923d64bSMike Christie */ 14685bd85625SMike Christie if (test_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags)) { 14695923d64bSMike Christie /* 14705923d64bSMike Christie * Save the task and ref in case we weren't cleaning up this 14715923d64bSMike Christie * task and get woken up again. 14725923d64bSMike Christie */ 14735923d64bSMike Christie conn->task = task; 147479edd00dSAnoob Soman spin_unlock_bh(&conn->session->back_lock); 147579edd00dSAnoob Soman return -ENODATA; 147679edd00dSAnoob Soman } 147779edd00dSAnoob Soman spin_unlock_bh(&conn->session->back_lock); 14785923d64bSMike Christie 1479659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 14809c19a7d0SMike Christie rc = conn->session->tt->xmit_task(task); 1481659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 1482d355e57dSMike Christie if (!rc) { 14839c19a7d0SMike Christie /* done with this task */ 1484d355e57dSMike Christie task->last_xfer = jiffies; 1485d355e57dSMike Christie } 1486659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 148772b97402SShlomo Pongratz spin_lock(&conn->session->back_lock); 14885923d64bSMike Christie if (rc && task->state == ISCSI_TASK_RUNNING) { 14895923d64bSMike Christie /* 14905923d64bSMike Christie * get an extra ref that is released next time we access it 14915923d64bSMike Christie * as conn->task above. 14925923d64bSMike Christie */ 14935923d64bSMike Christie __iscsi_get_task(task); 14945923d64bSMike Christie conn->task = task; 14955923d64bSMike Christie } 14965923d64bSMike Christie 1497d355e57dSMike Christie __iscsi_put_task(task); 149872b97402SShlomo Pongratz spin_unlock(&conn->session->back_lock); 149977a23c21SMike Christie return rc; 150077a23c21SMike Christie } 150177a23c21SMike Christie 15027996a778SMike Christie /** 15039c19a7d0SMike Christie * iscsi_requeue_task - requeue task to run from session workqueue 15049c19a7d0SMike Christie * @task: task to requeue 1505843c0a8aSMike Christie * 15065923d64bSMike Christie * Callers must have taken a ref to the task that is going to be requeued. 1507843c0a8aSMike Christie */ 15089c19a7d0SMike Christie void iscsi_requeue_task(struct iscsi_task *task) 1509843c0a8aSMike Christie { 15109c19a7d0SMike Christie struct iscsi_conn *conn = task->conn; 1511843c0a8aSMike Christie 15123bbaaad9SMike Christie /* 15133bbaaad9SMike Christie * this may be on the requeue list already if the xmit_task callout 15143bbaaad9SMike Christie * is handling the r2ts while we are adding new ones 15153bbaaad9SMike Christie */ 15165923d64bSMike Christie spin_lock_bh(&conn->session->frwd_lock); 15175923d64bSMike Christie if (list_empty(&task->running)) { 15183bbaaad9SMike Christie list_add_tail(&task->running, &conn->requeue); 15195923d64bSMike Christie } else { 15205923d64bSMike Christie /* 15215923d64bSMike Christie * Don't need the extra ref since it's already requeued and 15225923d64bSMike Christie * has a ref. 15235923d64bSMike Christie */ 15245923d64bSMike Christie iscsi_put_task(task); 15255923d64bSMike Christie } 15264b9f8ce4SMike Christie iscsi_conn_queue_xmit(conn); 15275923d64bSMike Christie spin_unlock_bh(&conn->session->frwd_lock); 1528843c0a8aSMike Christie } 15299c19a7d0SMike Christie EXPORT_SYMBOL_GPL(iscsi_requeue_task); 1530843c0a8aSMike Christie 1531843c0a8aSMike Christie /** 15327996a778SMike Christie * iscsi_data_xmit - xmit any command into the scheduled connection 15337996a778SMike Christie * @conn: iscsi connection 15347996a778SMike Christie * 15357996a778SMike Christie * Notes: 15367996a778SMike Christie * The function can return -EAGAIN in which case the caller must 15377996a778SMike Christie * re-schedule it again later or recover. '0' return code means 15387996a778SMike Christie * successful xmit. 15397996a778SMike Christie **/ 15407996a778SMike Christie static int iscsi_data_xmit(struct iscsi_conn *conn) 15417996a778SMike Christie { 15425d12c05eSMike Christie struct iscsi_task *task; 15433219e529SMike Christie int rc = 0; 15447996a778SMike Christie 1545659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 15465bd85625SMike Christie if (test_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags)) { 15471b2c7af8SMike Christie ISCSI_DBG_SESSION(conn->session, "Tx suspended!\n"); 1548659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 15493219e529SMike Christie return -ENODATA; 15507996a778SMike Christie } 15517996a778SMike Christie 15529c19a7d0SMike Christie if (conn->task) { 15535923d64bSMike Christie rc = iscsi_xmit_task(conn, conn->task, false); 15543219e529SMike Christie if (rc) 155570b31c15SMike Christie goto done; 15567996a778SMike Christie } 155777a23c21SMike Christie 155877a23c21SMike Christie /* 155977a23c21SMike Christie * process mgmt pdus like nops before commands since we should 156077a23c21SMike Christie * only have one nop-out as a ping from us and targets should not 156177a23c21SMike Christie * overflow us with nop-ins 156277a23c21SMike Christie */ 156377a23c21SMike Christie check_mgmt: 1564843c0a8aSMike Christie while (!list_empty(&conn->mgmtqueue)) { 15655923d64bSMike Christie task = list_entry(conn->mgmtqueue.next, struct iscsi_task, 15665923d64bSMike Christie running); 15675923d64bSMike Christie list_del_init(&task->running); 15685923d64bSMike Christie if (iscsi_prep_mgmt_task(conn, task)) { 1569659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 1570659743b0SShlomo Pongratz spin_lock_bh(&conn->session->back_lock); 15715923d64bSMike Christie __iscsi_put_task(task); 1572659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->back_lock); 1573b3a7ea8dSMike Christie continue; 1574b3a7ea8dSMike Christie } 15755923d64bSMike Christie rc = iscsi_xmit_task(conn, task, false); 15763219e529SMike Christie if (rc) 157770b31c15SMike Christie goto done; 15787996a778SMike Christie } 15797996a778SMike Christie 158065080c51SDmitry Bogdanov check_requeue: 158165080c51SDmitry Bogdanov while (!list_empty(&conn->requeue)) { 158265080c51SDmitry Bogdanov /* 158365080c51SDmitry Bogdanov * we always do fastlogout - conn stop code will clean up. 158465080c51SDmitry Bogdanov */ 158565080c51SDmitry Bogdanov if (conn->session->state == ISCSI_STATE_LOGGING_OUT) 158665080c51SDmitry Bogdanov break; 158765080c51SDmitry Bogdanov 158865080c51SDmitry Bogdanov task = list_entry(conn->requeue.next, struct iscsi_task, 158965080c51SDmitry Bogdanov running); 159065080c51SDmitry Bogdanov 159165080c51SDmitry Bogdanov if (iscsi_check_tmf_restrictions(task, ISCSI_OP_SCSI_DATA_OUT)) 159265080c51SDmitry Bogdanov break; 159365080c51SDmitry Bogdanov 159465080c51SDmitry Bogdanov list_del_init(&task->running); 159565080c51SDmitry Bogdanov rc = iscsi_xmit_task(conn, task, true); 159665080c51SDmitry Bogdanov if (rc) 159765080c51SDmitry Bogdanov goto done; 159865080c51SDmitry Bogdanov if (!list_empty(&conn->mgmtqueue)) 159965080c51SDmitry Bogdanov goto check_mgmt; 160065080c51SDmitry Bogdanov } 160165080c51SDmitry Bogdanov 1602843c0a8aSMike Christie /* process pending command queue */ 16033bbaaad9SMike Christie while (!list_empty(&conn->cmdqueue)) { 16045923d64bSMike Christie task = list_entry(conn->cmdqueue.next, struct iscsi_task, 16055d12c05eSMike Christie running); 16065923d64bSMike Christie list_del_init(&task->running); 1607b3a7ea8dSMike Christie if (conn->session->state == ISCSI_STATE_LOGGING_OUT) { 16085923d64bSMike Christie fail_scsi_task(task, DID_IMM_RETRY); 1609b3a7ea8dSMike Christie continue; 1610b3a7ea8dSMike Christie } 16115923d64bSMike Christie rc = iscsi_prep_scsi_cmd_pdu(task); 1612577577daSMike Christie if (rc) { 1613d28d48c6SMike Christie if (rc == -ENOMEM || rc == -EACCES) 16145923d64bSMike Christie fail_scsi_task(task, DID_IMM_RETRY); 1615d28d48c6SMike Christie else 16165923d64bSMike Christie fail_scsi_task(task, DID_ABORT); 1617004d6530SBoaz Harrosh continue; 1618004d6530SBoaz Harrosh } 16195923d64bSMike Christie rc = iscsi_xmit_task(conn, task, false); 16203219e529SMike Christie if (rc) 162170b31c15SMike Christie goto done; 162277a23c21SMike Christie /* 16239c19a7d0SMike Christie * we could continuously get new task requests so 162477a23c21SMike Christie * we need to check the mgmt queue for nops that need to 162577a23c21SMike Christie * be sent to aviod starvation 162677a23c21SMike Christie */ 1627843c0a8aSMike Christie if (!list_empty(&conn->mgmtqueue)) 1628843c0a8aSMike Christie goto check_mgmt; 162965080c51SDmitry Bogdanov if (!list_empty(&conn->requeue)) 163065080c51SDmitry Bogdanov goto check_requeue; 1631843c0a8aSMike Christie } 1632843c0a8aSMike Christie 1633659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 16343219e529SMike Christie return -ENODATA; 16357996a778SMike Christie 163670b31c15SMike Christie done: 1637659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 16383219e529SMike Christie return rc; 16397996a778SMike Christie } 16407996a778SMike Christie 1641c4028958SDavid Howells static void iscsi_xmitworker(struct work_struct *work) 16427996a778SMike Christie { 1643c4028958SDavid Howells struct iscsi_conn *conn = 1644c4028958SDavid Howells container_of(work, struct iscsi_conn, xmitwork); 16453219e529SMike Christie int rc; 16467996a778SMike Christie /* 16477996a778SMike Christie * serialize Xmit worker on a per-connection basis. 16487996a778SMike Christie */ 16493219e529SMike Christie do { 16503219e529SMike Christie rc = iscsi_data_xmit(conn); 16513219e529SMike Christie } while (rc >= 0 || rc == -EAGAIN); 16527996a778SMike Christie } 16537996a778SMike Christie 1654577577daSMike Christie static inline struct iscsi_task *iscsi_alloc_task(struct iscsi_conn *conn, 1655577577daSMike Christie struct scsi_cmnd *sc) 1656577577daSMike Christie { 1657577577daSMike Christie struct iscsi_task *task; 1658577577daSMike Christie 16597acd72ebSStefani Seibold if (!kfifo_out(&conn->session->cmdpool.queue, 1660577577daSMike Christie (void *) &task, sizeof(void *))) 1661577577daSMike Christie return NULL; 1662577577daSMike Christie 1663db22de3eSBart Van Assche iscsi_cmd(sc)->age = conn->session->age; 1664db22de3eSBart Van Assche iscsi_cmd(sc)->task = task; 1665577577daSMike Christie 16666dc618cdSElena Reshetova refcount_set(&task->refcount, 1); 1667577577daSMike Christie task->state = ISCSI_TASK_PENDING; 1668577577daSMike Christie task->conn = conn; 1669577577daSMike Christie task->sc = sc; 1670d355e57dSMike Christie task->have_checked_conn = false; 1671d355e57dSMike Christie task->last_timeout = jiffies; 1672d355e57dSMike Christie task->last_xfer = jiffies; 167355e51edaSSagi Grimberg task->protected = false; 1674577577daSMike Christie INIT_LIST_HEAD(&task->running); 1675577577daSMike Christie return task; 1676577577daSMike Christie } 1677577577daSMike Christie 16787996a778SMike Christie enum { 16797996a778SMike Christie FAILURE_BAD_HOST = 1, 16807996a778SMike Christie FAILURE_SESSION_FAILED, 16817996a778SMike Christie FAILURE_SESSION_FREED, 16827996a778SMike Christie FAILURE_WINDOW_CLOSED, 168360ecebf5SMike Christie FAILURE_OOM, 16847996a778SMike Christie FAILURE_SESSION_TERMINATE, 1685656cffc9SMike Christie FAILURE_SESSION_IN_RECOVERY, 16867996a778SMike Christie FAILURE_SESSION_RECOVERY_TIMEOUT, 1687b3a7ea8dSMike Christie FAILURE_SESSION_LOGGING_OUT, 16886eabafbeSMike Christie FAILURE_SESSION_NOT_READY, 16897996a778SMike Christie }; 16907996a778SMike Christie 1691f41d4721SMike Christie int iscsi_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *sc) 16927996a778SMike Christie { 169375613521SMike Christie struct iscsi_cls_session *cls_session; 16941336aed1SMike Christie struct iscsi_host *ihost; 16957996a778SMike Christie int reason = 0; 16967996a778SMike Christie struct iscsi_session *session; 16977996a778SMike Christie struct iscsi_conn *conn; 16989c19a7d0SMike Christie struct iscsi_task *task = NULL; 16997996a778SMike Christie 17007996a778SMike Christie sc->result = 0; 1701db22de3eSBart Van Assche iscsi_cmd(sc)->task = NULL; 17027996a778SMike Christie 17031336aed1SMike Christie ihost = shost_priv(host); 17047996a778SMike Christie 170575613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 170675613521SMike Christie session = cls_session->dd_data; 1707659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 17087996a778SMike Christie 170975613521SMike Christie reason = iscsi_session_chkready(cls_session); 17106eabafbeSMike Christie if (reason) { 17116eabafbeSMike Christie sc->result = reason; 17126eabafbeSMike Christie goto fault; 17136eabafbeSMike Christie } 17146eabafbeSMike Christie 1715301e0f7eSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 1716656cffc9SMike Christie /* 1717656cffc9SMike Christie * to handle the race between when we set the recovery state 1718656cffc9SMike Christie * and block the session we requeue here (commands could 1719656cffc9SMike Christie * be entering our queuecommand while a block is starting 1720656cffc9SMike Christie * up because the block code is not locked) 1721656cffc9SMike Christie */ 17229000bcd6SMike Christie switch (session->state) { 1723301e0f7eSMike Christie case ISCSI_STATE_FAILED: 1724d7549412SRafael David Tinoco /* 1725d7549412SRafael David Tinoco * cmds should fail during shutdown, if the session 1726d7549412SRafael David Tinoco * state is bad, allowing completion to happen 1727d7549412SRafael David Tinoco */ 1728d7549412SRafael David Tinoco if (unlikely(system_state != SYSTEM_RUNNING)) { 1729d7549412SRafael David Tinoco reason = FAILURE_SESSION_FAILED; 1730d7549412SRafael David Tinoco sc->result = DID_NO_CONNECT << 16; 1731d7549412SRafael David Tinoco break; 1732d7549412SRafael David Tinoco } 1733df561f66SGustavo A. R. Silva fallthrough; 17349000bcd6SMike Christie case ISCSI_STATE_IN_RECOVERY: 1735656cffc9SMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1736301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1737301e0f7eSMike Christie break; 17389000bcd6SMike Christie case ISCSI_STATE_LOGGING_OUT: 17399000bcd6SMike Christie reason = FAILURE_SESSION_LOGGING_OUT; 1740301e0f7eSMike Christie sc->result = DID_IMM_RETRY << 16; 1741301e0f7eSMike Christie break; 1742b3a7ea8dSMike Christie case ISCSI_STATE_RECOVERY_FAILED: 1743656cffc9SMike Christie reason = FAILURE_SESSION_RECOVERY_TIMEOUT; 174456d7fcfaSMike Christie sc->result = DID_TRANSPORT_FAILFAST << 16; 1745b3a7ea8dSMike Christie break; 1746b3a7ea8dSMike Christie case ISCSI_STATE_TERMINATE: 1747656cffc9SMike Christie reason = FAILURE_SESSION_TERMINATE; 17486eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1749b3a7ea8dSMike Christie break; 1750b3a7ea8dSMike Christie default: 17517996a778SMike Christie reason = FAILURE_SESSION_FREED; 17526eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 1753b3a7ea8dSMike Christie } 17547996a778SMike Christie goto fault; 17557996a778SMike Christie } 17567996a778SMike Christie 17577996a778SMike Christie conn = session->leadconn; 175898644047SMike Christie if (!conn) { 175998644047SMike Christie reason = FAILURE_SESSION_FREED; 17606eabafbeSMike Christie sc->result = DID_NO_CONNECT << 16; 176198644047SMike Christie goto fault; 176298644047SMike Christie } 17637996a778SMike Christie 17645bd85625SMike Christie if (test_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags)) { 1765661134adSMike Christie reason = FAILURE_SESSION_IN_RECOVERY; 1766eef9ffdfSJohannes Thumshirn sc->result = DID_REQUEUE << 16; 1767661134adSMike Christie goto fault; 1768661134adSMike Christie } 1769661134adSMike Christie 177077a23c21SMike Christie if (iscsi_check_cmdsn_window_closed(conn)) { 177177a23c21SMike Christie reason = FAILURE_WINDOW_CLOSED; 177277a23c21SMike Christie goto reject; 177377a23c21SMike Christie } 177477a23c21SMike Christie 1775577577daSMike Christie task = iscsi_alloc_task(conn, sc); 1776577577daSMike Christie if (!task) { 177760ecebf5SMike Christie reason = FAILURE_OOM; 177860ecebf5SMike Christie goto reject; 177960ecebf5SMike Christie } 17807996a778SMike Christie 17811336aed1SMike Christie if (!ihost->workq) { 1782577577daSMike Christie reason = iscsi_prep_scsi_cmd_pdu(task); 1783577577daSMike Christie if (reason) { 17845d12c05eSMike Christie if (reason == -ENOMEM || reason == -EACCES) { 1785577577daSMike Christie reason = FAILURE_OOM; 1786577577daSMike Christie goto prepd_reject; 1787577577daSMike Christie } else { 1788052d0144SMike Christie sc->result = DID_ABORT << 16; 1789577577daSMike Christie goto prepd_fault; 1790577577daSMike Christie } 1791052d0144SMike Christie } 17929c19a7d0SMike Christie if (session->tt->xmit_task(task)) { 1793d3305f34SMike Christie session->cmdsn--; 1794052d0144SMike Christie reason = FAILURE_SESSION_NOT_READY; 1795577577daSMike Christie goto prepd_reject; 1796052d0144SMike Christie } 17973bbaaad9SMike Christie } else { 17983bbaaad9SMike Christie list_add_tail(&task->running, &conn->cmdqueue); 17994b9f8ce4SMike Christie iscsi_conn_queue_xmit(conn); 18003bbaaad9SMike Christie } 1801052d0144SMike Christie 1802052d0144SMike Christie session->queued_cmdsn++; 1803659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 18047996a778SMike Christie return 0; 18057996a778SMike Christie 1806577577daSMike Christie prepd_reject: 1807a656183eSLee Duncan spin_lock_bh(&session->back_lock); 1808f41d4721SMike Christie iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 1809a656183eSLee Duncan spin_unlock_bh(&session->back_lock); 18107996a778SMike Christie reject: 1811659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 18121b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "cmd 0x%x rejected (%d)\n", 18131b2c7af8SMike Christie sc->cmnd[0], reason); 1814d6d13ee1SMike Christie return SCSI_MLQUEUE_TARGET_BUSY; 18157996a778SMike Christie 1816577577daSMike Christie prepd_fault: 1817a656183eSLee Duncan spin_lock_bh(&session->back_lock); 1818f41d4721SMike Christie iscsi_complete_task(task, ISCSI_TASK_REQUEUE_SCSIQ); 1819a656183eSLee Duncan spin_unlock_bh(&session->back_lock); 18207996a778SMike Christie fault: 1821659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 18221b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "iscsi: cmd 0x%x is not queued (%d)\n", 18231b2c7af8SMike Christie sc->cmnd[0], reason); 18241c138991SFUJITA Tomonori scsi_set_resid(sc, scsi_bufflen(sc)); 1825b4b84edcSBart Van Assche scsi_done(sc); 18267996a778SMike Christie return 0; 18277996a778SMike Christie } 18287996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_queuecommand); 18297996a778SMike Christie 18306b5d6c44SMike Christie int iscsi_target_alloc(struct scsi_target *starget) 18316b5d6c44SMike Christie { 18326b5d6c44SMike Christie struct iscsi_cls_session *cls_session = starget_to_session(starget); 18336b5d6c44SMike Christie struct iscsi_session *session = cls_session->dd_data; 18346b5d6c44SMike Christie 18356b5d6c44SMike Christie starget->can_queue = session->scsi_cmds_max; 18366b5d6c44SMike Christie return 0; 18376b5d6c44SMike Christie } 18386b5d6c44SMike Christie EXPORT_SYMBOL_GPL(iscsi_target_alloc); 18396b5d6c44SMike Christie 18402c4b9637SKees Cook static void iscsi_tmf_timedout(struct timer_list *t) 18417996a778SMike Christie { 1842ec29d0acSMike Christie struct iscsi_session *session = from_timer(session, t, tmf_timer); 18437996a778SMike Christie 1844659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 1845ec29d0acSMike Christie if (session->tmf_state == TMF_QUEUED) { 1846ec29d0acSMike Christie session->tmf_state = TMF_TIMEDOUT; 1847bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf timedout\n"); 18487996a778SMike Christie /* unblock eh_abort() */ 1849ec29d0acSMike Christie wake_up(&session->ehwait); 18507996a778SMike Christie } 1851659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 18527996a778SMike Christie } 18537996a778SMike Christie 18549c19a7d0SMike Christie static int iscsi_exec_task_mgmt_fn(struct iscsi_conn *conn, 1855f6d5180cSMike Christie struct iscsi_tm *hdr, int age, 1856f6d5180cSMike Christie int timeout) 18571360c58aSBart Van Assche __must_hold(&session->frwd_lock) 18587996a778SMike Christie { 18597996a778SMike Christie struct iscsi_session *session = conn->session; 18609c19a7d0SMike Christie struct iscsi_task *task; 18617996a778SMike Christie 18629c19a7d0SMike Christie task = __iscsi_conn_send_pdu(conn, (struct iscsi_hdr *)hdr, 18637996a778SMike Christie NULL, 0); 18649c19a7d0SMike Christie if (!task) { 1865659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 1866df4da5cdSMike Christie iscsi_conn_printk(KERN_ERR, conn, "Could not send TMF.\n"); 18677996a778SMike Christie iscsi_conn_failure(conn, ISCSI_ERR_CONN_FAILED); 1868659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 186977a23c21SMike Christie return -EPERM; 18707996a778SMike Christie } 18717996a778SMike Christie conn->tmfcmd_pdus_cnt++; 1872ec29d0acSMike Christie session->tmf_timer.expires = timeout * HZ + jiffies; 1873ec29d0acSMike Christie add_timer(&session->tmf_timer); 1874bd2199d4SErez Zilber ISCSI_DBG_EH(session, "tmf set timeout\n"); 1875843c0a8aSMike Christie 1876659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 18776724add1SMike Christie mutex_unlock(&session->eh_mutex); 18787996a778SMike Christie 18797996a778SMike Christie /* 18807996a778SMike Christie * block eh thread until: 18817996a778SMike Christie * 1882843c0a8aSMike Christie * 1) tmf response 1883843c0a8aSMike Christie * 2) tmf timeout 18847996a778SMike Christie * 3) session is terminated or restarted or userspace has 18857996a778SMike Christie * given up on recovery 18867996a778SMike Christie */ 1887ec29d0acSMike Christie wait_event_interruptible(session->ehwait, age != session->age || 18887996a778SMike Christie session->state != ISCSI_STATE_LOGGED_IN || 1889ec29d0acSMike Christie session->tmf_state != TMF_QUEUED); 18907996a778SMike Christie if (signal_pending(current)) 18917996a778SMike Christie flush_signals(current); 1892ec29d0acSMike Christie del_timer_sync(&session->tmf_timer); 1893843c0a8aSMike Christie 18946724add1SMike Christie mutex_lock(&session->eh_mutex); 1895659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 18969c19a7d0SMike Christie /* if the session drops it will clean up the task */ 1897843c0a8aSMike Christie if (age != session->age || 1898843c0a8aSMike Christie session->state != ISCSI_STATE_LOGGED_IN) 1899843c0a8aSMike Christie return -ENOTCONN; 19007996a778SMike Christie return 0; 19017996a778SMike Christie } 19027996a778SMike Christie 19037996a778SMike Christie /* 190414936b1eSMike Christie * Fail commands. session frwd lock held and xmit thread flushed. 1905843c0a8aSMike Christie */ 19069cb78c16SHannes Reinecke static void fail_scsi_tasks(struct iscsi_conn *conn, u64 lun, int error) 1907843c0a8aSMike Christie { 190814936b1eSMike Christie struct iscsi_session *session = conn->session; 19093bbaaad9SMike Christie struct iscsi_task *task; 19103bbaaad9SMike Christie int i; 1911843c0a8aSMike Christie 191214936b1eSMike Christie spin_lock_bh(&session->back_lock); 191314936b1eSMike Christie for (i = 0; i < session->cmds_max; i++) { 191414936b1eSMike Christie task = session->cmds[i]; 19153bbaaad9SMike Christie if (!task->sc || task->state == ISCSI_TASK_FREE) 19163bbaaad9SMike Christie continue; 1917843c0a8aSMike Christie 19183bbaaad9SMike Christie if (lun != -1 && lun != task->sc->device->lun) 19193bbaaad9SMike Christie continue; 19203bbaaad9SMike Christie 192114936b1eSMike Christie __iscsi_get_task(task); 192214936b1eSMike Christie spin_unlock_bh(&session->back_lock); 192314936b1eSMike Christie 192414936b1eSMike Christie ISCSI_DBG_SESSION(session, 19253bbaaad9SMike Christie "failing sc %p itt 0x%x state %d\n", 19263bbaaad9SMike Christie task->sc, task->itt, task->state); 1927b3cd5050SMike Christie fail_scsi_task(task, error); 192814936b1eSMike Christie 192914936b1eSMike Christie spin_unlock_bh(&session->frwd_lock); 193014936b1eSMike Christie iscsi_put_task(task); 193114936b1eSMike Christie spin_lock_bh(&session->frwd_lock); 193214936b1eSMike Christie 193314936b1eSMike Christie spin_lock_bh(&session->back_lock); 1934843c0a8aSMike Christie } 193514936b1eSMike Christie 193614936b1eSMike Christie spin_unlock_bh(&session->back_lock); 1937843c0a8aSMike Christie } 1938843c0a8aSMike Christie 1939661134adSMike Christie /** 1940661134adSMike Christie * iscsi_suspend_queue - suspend iscsi_queuecommand 1941661134adSMike Christie * @conn: iscsi conn to stop queueing IO on 1942661134adSMike Christie * 1943659743b0SShlomo Pongratz * This grabs the session frwd_lock to make sure no one is in 1944661134adSMike Christie * xmit_task/queuecommand, and then sets suspend to prevent 1945661134adSMike Christie * new commands from being queued. This only needs to be called 1946661134adSMike Christie * by offload drivers that need to sync a path like ep disconnect 1947661134adSMike Christie * with the iscsi_queuecommand/xmit_task. To start IO again libiscsi 1948661134adSMike Christie * will call iscsi_start_tx and iscsi_unblock_session when in FFP. 1949661134adSMike Christie */ 1950661134adSMike Christie void iscsi_suspend_queue(struct iscsi_conn *conn) 1951661134adSMike Christie { 1952659743b0SShlomo Pongratz spin_lock_bh(&conn->session->frwd_lock); 19535bd85625SMike Christie set_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags); 1954659743b0SShlomo Pongratz spin_unlock_bh(&conn->session->frwd_lock); 1955661134adSMike Christie } 1956661134adSMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_queue); 1957661134adSMike Christie 1958661134adSMike Christie /** 1959661134adSMike Christie * iscsi_suspend_tx - suspend iscsi_data_xmit 1960*8af80996SMike Christie * @conn: iscsi conn to stop processing IO on. 1961661134adSMike Christie * 1962661134adSMike Christie * This function sets the suspend bit to prevent iscsi_data_xmit 1963661134adSMike Christie * from sending new IO, and if work is queued on the xmit thread 1964661134adSMike Christie * it will wait for it to be completed. 1965661134adSMike Christie */ 1966b40977d9SMike Christie void iscsi_suspend_tx(struct iscsi_conn *conn) 19676724add1SMike Christie { 196832ae763eSMike Christie struct Scsi_Host *shost = conn->session->host; 196932ae763eSMike Christie struct iscsi_host *ihost = shost_priv(shost); 197032ae763eSMike Christie 19715bd85625SMike Christie set_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags); 19721336aed1SMike Christie if (ihost->workq) 1973*8af80996SMike Christie flush_work(&conn->xmitwork); 19746724add1SMike Christie } 1975b40977d9SMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_tx); 19766724add1SMike Christie 19776724add1SMike Christie static void iscsi_start_tx(struct iscsi_conn *conn) 19786724add1SMike Christie { 19795bd85625SMike Christie clear_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags); 19804b9f8ce4SMike Christie iscsi_conn_queue_xmit(conn); 19816724add1SMike Christie } 19826724add1SMike Christie 1983*8af80996SMike Christie /** 1984*8af80996SMike Christie * iscsi_suspend_rx - Prevent recvwork from running again. 1985*8af80996SMike Christie * @conn: iscsi conn to stop. 1986*8af80996SMike Christie */ 1987*8af80996SMike Christie void iscsi_suspend_rx(struct iscsi_conn *conn) 1988*8af80996SMike Christie { 1989*8af80996SMike Christie struct Scsi_Host *shost = conn->session->host; 1990*8af80996SMike Christie struct iscsi_host *ihost = shost_priv(shost); 1991*8af80996SMike Christie 1992*8af80996SMike Christie set_bit(ISCSI_CONN_FLAG_SUSPEND_RX, &conn->flags); 1993*8af80996SMike Christie if (ihost->workq) 1994*8af80996SMike Christie flush_work(&conn->recvwork); 1995*8af80996SMike Christie } 1996*8af80996SMike Christie EXPORT_SYMBOL_GPL(iscsi_suspend_rx); 1997*8af80996SMike Christie 19984c48a829SMike Christie /* 19994c48a829SMike Christie * We want to make sure a ping is in flight. It has timed out. 20004c48a829SMike Christie * And we are not busy processing a pdu that is making 20014c48a829SMike Christie * progress but got started before the ping and is taking a while 20024c48a829SMike Christie * to complete so the ping is just stuck behind it in a queue. 20034c48a829SMike Christie */ 20044c48a829SMike Christie static int iscsi_has_ping_timed_out(struct iscsi_conn *conn) 20054c48a829SMike Christie { 2006fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task) && 20074c48a829SMike Christie time_before_eq(conn->last_recv + (conn->recv_timeout * HZ) + 20084c48a829SMike Christie (conn->ping_timeout * HZ), jiffies)) 20094c48a829SMike Christie return 1; 20104c48a829SMike Christie else 20114c48a829SMike Christie return 0; 20124c48a829SMike Christie } 20134c48a829SMike Christie 2014b6a05c82SChristoph Hellwig enum blk_eh_timer_return iscsi_eh_cmd_timed_out(struct scsi_cmnd *sc) 2015f6d5180cSMike Christie { 20166600593cSChristoph Hellwig enum blk_eh_timer_return rc = BLK_EH_DONE; 201792ed4d69SMike Christie struct iscsi_task *task = NULL, *running_task; 2018f6d5180cSMike Christie struct iscsi_cls_session *cls_session; 2019f6d5180cSMike Christie struct iscsi_session *session; 2020f6d5180cSMike Christie struct iscsi_conn *conn; 202192ed4d69SMike Christie int i; 2022f6d5180cSMike Christie 2023d355e57dSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 202475613521SMike Christie session = cls_session->dd_data; 2025f6d5180cSMike Christie 2026bd2199d4SErez Zilber ISCSI_DBG_EH(session, "scsi cmd %p timedout\n", sc); 2027f6d5180cSMike Christie 20285480e299SBart Van Assche spin_lock_bh(&session->frwd_lock); 202914936b1eSMike Christie spin_lock(&session->back_lock); 2030db22de3eSBart Van Assche task = iscsi_cmd(sc)->task; 2031e3d338a5SMike Christie if (!task) { 2032e3d338a5SMike Christie /* 2033e3d338a5SMike Christie * Raced with completion. Blk layer has taken ownership 2034e3d338a5SMike Christie * so let timeout code complete it now. 2035e3d338a5SMike Christie */ 2036adb2b769SChristoph Hellwig rc = BLK_EH_DONE; 203714936b1eSMike Christie spin_unlock(&session->back_lock); 2038e3d338a5SMike Christie goto done; 2039e3d338a5SMike Christie } 204014936b1eSMike Christie __iscsi_get_task(task); 204114936b1eSMike Christie spin_unlock(&session->back_lock); 2042e3d338a5SMike Christie 2043f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 2044f6d5180cSMike Christie /* 2045d7549412SRafael David Tinoco * During shutdown, if session is prematurely disconnected, 2046d7549412SRafael David Tinoco * recovery won't happen and there will be hung cmds. Not 2047d7549412SRafael David Tinoco * handling cmds would trigger EH, also bad in this case. 2048d7549412SRafael David Tinoco * Instead, handle cmd, allow completion to happen and let 2049d7549412SRafael David Tinoco * upper layer to deal with the result. 2050d7549412SRafael David Tinoco */ 2051d7549412SRafael David Tinoco if (unlikely(system_state != SYSTEM_RUNNING)) { 2052d7549412SRafael David Tinoco sc->result = DID_NO_CONNECT << 16; 2053d7549412SRafael David Tinoco ISCSI_DBG_EH(session, "sc on shutdown, handled\n"); 2054adb2b769SChristoph Hellwig rc = BLK_EH_DONE; 2055d7549412SRafael David Tinoco goto done; 2056d7549412SRafael David Tinoco } 2057d7549412SRafael David Tinoco /* 2058f6d5180cSMike Christie * We are probably in the middle of iscsi recovery so let 2059f6d5180cSMike Christie * that complete and handle the error. 2060f6d5180cSMike Christie */ 2061242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 2062f6d5180cSMike Christie goto done; 2063f6d5180cSMike Christie } 2064f6d5180cSMike Christie 2065f6d5180cSMike Christie conn = session->leadconn; 2066f6d5180cSMike Christie if (!conn) { 2067f6d5180cSMike Christie /* In the middle of shuting down */ 2068242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 2069f6d5180cSMike Christie goto done; 2070f6d5180cSMike Christie } 2071f6d5180cSMike Christie 2072d355e57dSMike Christie /* 2073d355e57dSMike Christie * If we have sent (at least queued to the network layer) a pdu or 2074d355e57dSMike Christie * recvd one for the task since the last timeout ask for 2075d355e57dSMike Christie * more time. If on the next timeout we have not made progress 2076d355e57dSMike Christie * we can check if it is the task or connection when we send the 2077d355e57dSMike Christie * nop as a ping. 2078d355e57dSMike Christie */ 207992ed4d69SMike Christie if (time_after(task->last_xfer, task->last_timeout)) { 2080bd2199d4SErez Zilber ISCSI_DBG_EH(session, "Command making progress. Asking " 2081d355e57dSMike Christie "scsi-ml for more time to complete. " 208292ed4d69SMike Christie "Last data xfer at %lu. Last timeout was at " 2083d355e57dSMike Christie "%lu\n.", task->last_xfer, task->last_timeout); 2084d355e57dSMike Christie task->have_checked_conn = false; 2085d355e57dSMike Christie rc = BLK_EH_RESET_TIMER; 2086d355e57dSMike Christie goto done; 2087d355e57dSMike Christie } 2088d355e57dSMike Christie 2089f6d5180cSMike Christie if (!conn->recv_timeout && !conn->ping_timeout) 2090f6d5180cSMike Christie goto done; 2091f6d5180cSMike Christie /* 2092f6d5180cSMike Christie * if the ping timedout then we are in the middle of cleaning up 2093f6d5180cSMike Christie * and can let the iscsi eh handle it 2094f6d5180cSMike Christie */ 20954c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 2096242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 20974c48a829SMike Christie goto done; 20984c48a829SMike Christie } 2099d355e57dSMike Christie 210014936b1eSMike Christie spin_lock(&session->back_lock); 210192ed4d69SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 210292ed4d69SMike Christie running_task = conn->session->cmds[i]; 210392ed4d69SMike Christie if (!running_task->sc || running_task == task || 210492ed4d69SMike Christie running_task->state != ISCSI_TASK_RUNNING) 210592ed4d69SMike Christie continue; 210692ed4d69SMike Christie 210792ed4d69SMike Christie /* 210892ed4d69SMike Christie * Only check if cmds started before this one have made 210992ed4d69SMike Christie * progress, or this could never fail 211092ed4d69SMike Christie */ 211192ed4d69SMike Christie if (time_after(running_task->sc->jiffies_at_alloc, 211292ed4d69SMike Christie task->sc->jiffies_at_alloc)) 211392ed4d69SMike Christie continue; 211492ed4d69SMike Christie 211592ed4d69SMike Christie if (time_after(running_task->last_xfer, task->last_timeout)) { 211692ed4d69SMike Christie /* 211792ed4d69SMike Christie * This task has not made progress, but a task 211892ed4d69SMike Christie * started before us has transferred data since 211992ed4d69SMike Christie * we started/last-checked. We could be queueing 212092ed4d69SMike Christie * too many tasks or the LU is bad. 212192ed4d69SMike Christie * 212292ed4d69SMike Christie * If the device is bad the cmds ahead of us on 212392ed4d69SMike Christie * other devs will complete, and this loop will 212492ed4d69SMike Christie * eventually fail starting the scsi eh. 212592ed4d69SMike Christie */ 212692ed4d69SMike Christie ISCSI_DBG_EH(session, "Command has not made progress " 212792ed4d69SMike Christie "but commands ahead of it have. " 212892ed4d69SMike Christie "Asking scsi-ml for more time to " 212992ed4d69SMike Christie "complete. Our last xfer vs running task " 213092ed4d69SMike Christie "last xfer %lu/%lu. Last check %lu.\n", 213192ed4d69SMike Christie task->last_xfer, running_task->last_xfer, 213292ed4d69SMike Christie task->last_timeout); 213314936b1eSMike Christie spin_unlock(&session->back_lock); 213492ed4d69SMike Christie rc = BLK_EH_RESET_TIMER; 213592ed4d69SMike Christie goto done; 213692ed4d69SMike Christie } 213792ed4d69SMike Christie } 213814936b1eSMike Christie spin_unlock(&session->back_lock); 213992ed4d69SMike Christie 2140d355e57dSMike Christie /* Assumes nop timeout is shorter than scsi cmd timeout */ 2141d355e57dSMike Christie if (task->have_checked_conn) 2142d355e57dSMike Christie goto done; 2143d355e57dSMike Christie 2144f6d5180cSMike Christie /* 2145d355e57dSMike Christie * Checking the transport already or nop from a cmd timeout still 2146d355e57dSMike Christie * running 2147f6d5180cSMike Christie */ 2148fe0a8a95SLee Duncan if (READ_ONCE(conn->ping_task)) { 2149d355e57dSMike Christie task->have_checked_conn = true; 2150242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 21514c48a829SMike Christie goto done; 21524c48a829SMike Christie } 21534c48a829SMike Christie 2154d355e57dSMike Christie /* Make sure there is a transport check done */ 2155d355e57dSMike Christie iscsi_send_nopout(conn, NULL); 2156d355e57dSMike Christie task->have_checked_conn = true; 2157242f9dcbSJens Axboe rc = BLK_EH_RESET_TIMER; 2158d355e57dSMike Christie 2159f6d5180cSMike Christie done: 21605480e299SBart Van Assche spin_unlock_bh(&session->frwd_lock); 216114936b1eSMike Christie 216214936b1eSMike Christie if (task) { 216314936b1eSMike Christie task->last_timeout = jiffies; 216414936b1eSMike Christie iscsi_put_task(task); 216514936b1eSMike Christie } 2166bd2199d4SErez Zilber ISCSI_DBG_EH(session, "return %s\n", rc == BLK_EH_RESET_TIMER ? 2167d7549412SRafael David Tinoco "timer reset" : "shutdown or nh"); 2168f6d5180cSMike Christie return rc; 2169f6d5180cSMike Christie } 2170b6a05c82SChristoph Hellwig EXPORT_SYMBOL_GPL(iscsi_eh_cmd_timed_out); 2171f6d5180cSMike Christie 21722c4b9637SKees Cook static void iscsi_check_transport_timeouts(struct timer_list *t) 2173f6d5180cSMike Christie { 21742c4b9637SKees Cook struct iscsi_conn *conn = from_timer(conn, t, transport_timer); 2175f6d5180cSMike Christie struct iscsi_session *session = conn->session; 21764cf10435SMike Christie unsigned long recv_timeout, next_timeout = 0, last_recv; 2177f6d5180cSMike Christie 2178659743b0SShlomo Pongratz spin_lock(&session->frwd_lock); 2179f6d5180cSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) 2180f6d5180cSMike Christie goto done; 2181f6d5180cSMike Christie 21824cf10435SMike Christie recv_timeout = conn->recv_timeout; 21834cf10435SMike Christie if (!recv_timeout) 2184f6d5180cSMike Christie goto done; 2185f6d5180cSMike Christie 21864cf10435SMike Christie recv_timeout *= HZ; 2187f6d5180cSMike Christie last_recv = conn->last_recv; 21884c48a829SMike Christie 21894c48a829SMike Christie if (iscsi_has_ping_timed_out(conn)) { 2190322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "ping timeout of %d secs " 21914c48a829SMike Christie "expired, recv timeout %d, last rx %lu, " 21924c48a829SMike Christie "last ping %lu, now %lu\n", 21934c48a829SMike Christie conn->ping_timeout, conn->recv_timeout, 21944c48a829SMike Christie last_recv, conn->last_ping, jiffies); 2195659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 219609ff742cSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_NOP_TIMEDOUT); 2197f6d5180cSMike Christie return; 2198f6d5180cSMike Christie } 2199f6d5180cSMike Christie 22004cf10435SMike Christie if (time_before_eq(last_recv + recv_timeout, jiffies)) { 2201f6d5180cSMike Christie /* send a ping to try to provoke some traffic */ 22021b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Sending nopout as ping\n"); 220352f5664aSAriel Nahum if (iscsi_send_nopout(conn, NULL)) 220452f5664aSAriel Nahum next_timeout = jiffies + (1 * HZ); 220552f5664aSAriel Nahum else 22064cf10435SMike Christie next_timeout = conn->last_ping + (conn->ping_timeout * HZ); 2207ad294e9cSMike Christie } else 22084cf10435SMike Christie next_timeout = last_recv + recv_timeout; 2209f6d5180cSMike Christie 22101b2c7af8SMike Christie ISCSI_DBG_CONN(conn, "Setting next tmo %lu\n", next_timeout); 2211f6d5180cSMike Christie mod_timer(&conn->transport_timer, next_timeout); 2212f6d5180cSMike Christie done: 2213659743b0SShlomo Pongratz spin_unlock(&session->frwd_lock); 2214f6d5180cSMike Christie } 2215f6d5180cSMike Christie 2216891e2639SMike Christie /** 2217891e2639SMike Christie * iscsi_conn_unbind - prevent queueing to conn. 2218891e2639SMike Christie * @cls_conn: iscsi conn ep is bound to. 2219891e2639SMike Christie * @is_active: is the conn in use for boot or is this for EH/termination 2220891e2639SMike Christie * 2221891e2639SMike Christie * This must be called by drivers implementing the ep_disconnect callout. 2222891e2639SMike Christie * It disables queueing to the connection from libiscsi in preparation for 2223891e2639SMike Christie * an ep_disconnect call. 2224891e2639SMike Christie */ 2225891e2639SMike Christie void iscsi_conn_unbind(struct iscsi_cls_conn *cls_conn, bool is_active) 2226891e2639SMike Christie { 2227891e2639SMike Christie struct iscsi_session *session; 2228891e2639SMike Christie struct iscsi_conn *conn; 2229891e2639SMike Christie 2230891e2639SMike Christie if (!cls_conn) 2231891e2639SMike Christie return; 2232891e2639SMike Christie 2233891e2639SMike Christie conn = cls_conn->dd_data; 2234891e2639SMike Christie session = conn->session; 2235891e2639SMike Christie /* 2236891e2639SMike Christie * Wait for iscsi_eh calls to exit. We don't wait for the tmf to 2237891e2639SMike Christie * complete or timeout. The caller just wants to know what's running 2238891e2639SMike Christie * is everything that needs to be cleaned up, and no cmds will be 2239891e2639SMike Christie * queued. 2240891e2639SMike Christie */ 2241891e2639SMike Christie mutex_lock(&session->eh_mutex); 2242891e2639SMike Christie 2243891e2639SMike Christie iscsi_suspend_queue(conn); 2244891e2639SMike Christie iscsi_suspend_tx(conn); 2245891e2639SMike Christie 2246891e2639SMike Christie spin_lock_bh(&session->frwd_lock); 224744ac9710SMike Christie clear_bit(ISCSI_CONN_FLAG_BOUND, &conn->flags); 224844ac9710SMike Christie 2249891e2639SMike Christie if (!is_active) { 2250891e2639SMike Christie /* 2251891e2639SMike Christie * if logout timed out before userspace could even send a PDU 2252891e2639SMike Christie * the state might still be in ISCSI_STATE_LOGGED_IN and 2253891e2639SMike Christie * allowing new cmds and TMFs. 2254891e2639SMike Christie */ 2255891e2639SMike Christie if (session->state == ISCSI_STATE_LOGGED_IN) 2256891e2639SMike Christie iscsi_set_conn_failed(conn); 2257891e2639SMike Christie } 2258891e2639SMike Christie spin_unlock_bh(&session->frwd_lock); 2259891e2639SMike Christie mutex_unlock(&session->eh_mutex); 2260891e2639SMike Christie } 2261891e2639SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_unbind); 2262891e2639SMike Christie 22639c19a7d0SMike Christie static void iscsi_prep_abort_task_pdu(struct iscsi_task *task, 2264843c0a8aSMike Christie struct iscsi_tm *hdr) 2265843c0a8aSMike Christie { 2266843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2267843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2268843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_ABORT_TASK & ISCSI_FLAG_TM_FUNC_MASK; 2269843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 227055bdabdfSAndy Grover hdr->lun = task->lun; 2271577577daSMike Christie hdr->rtt = task->hdr_itt; 2272577577daSMike Christie hdr->refcmdsn = task->cmdsn; 2273843c0a8aSMike Christie } 2274843c0a8aSMike Christie 22757996a778SMike Christie int iscsi_eh_abort(struct scsi_cmnd *sc) 22767996a778SMike Christie { 227775613521SMike Christie struct iscsi_cls_session *cls_session; 227875613521SMike Christie struct iscsi_session *session; 2279f47f2cf5SMike Christie struct iscsi_conn *conn; 22809c19a7d0SMike Christie struct iscsi_task *task; 2281843c0a8aSMike Christie struct iscsi_tm *hdr; 2282e9e410e8SBart Van Assche int age; 22837996a778SMike Christie 228475613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 228575613521SMike Christie session = cls_session->dd_data; 228675613521SMike Christie 2287bd2199d4SErez Zilber ISCSI_DBG_EH(session, "aborting sc %p\n", sc); 22884421c9ebSMike Christie 22896724add1SMike Christie mutex_lock(&session->eh_mutex); 2290659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2291f47f2cf5SMike Christie /* 2292f47f2cf5SMike Christie * if session was ISCSI_STATE_IN_RECOVERY then we may not have 2293f47f2cf5SMike Christie * got the command. 2294f47f2cf5SMike Christie */ 2295db22de3eSBart Van Assche if (!iscsi_cmd(sc)->task) { 2296bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc never reached iscsi layer or " 22971b2c7af8SMike Christie "it completed.\n"); 2298659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 22996724add1SMike Christie mutex_unlock(&session->eh_mutex); 2300f47f2cf5SMike Christie return SUCCESS; 2301f47f2cf5SMike Christie } 2302f47f2cf5SMike Christie 23037996a778SMike Christie /* 23047996a778SMike Christie * If we are not logged in or we have started a new session 23057996a778SMike Christie * then let the host reset code handle this 23067996a778SMike Christie */ 2307843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN || 2308db22de3eSBart Van Assche iscsi_cmd(sc)->age != session->age) { 2309659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2310843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2311bd2199d4SErez Zilber ISCSI_DBG_EH(session, "failing abort due to dropped " 23124421c9ebSMike Christie "session.\n"); 2313843c0a8aSMike Christie return FAILED; 2314843c0a8aSMike Christie } 2315843c0a8aSMike Christie 231614936b1eSMike Christie spin_lock(&session->back_lock); 2317db22de3eSBart Van Assche task = iscsi_cmd(sc)->task; 231814936b1eSMike Christie if (!task || !task->sc) { 23199c19a7d0SMike Christie /* task completed before time out */ 2320bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in progress\n"); 232114936b1eSMike Christie 232214936b1eSMike Christie spin_unlock(&session->back_lock); 2323258aad75SMike Christie spin_unlock_bh(&session->frwd_lock); 2324258aad75SMike Christie mutex_unlock(&session->eh_mutex); 2325258aad75SMike Christie return SUCCESS; 23267ea8b828SMike Christie } 2327258aad75SMike Christie 2328258aad75SMike Christie conn = session->leadconn; 2329258aad75SMike Christie iscsi_get_conn(conn->cls_conn); 2330258aad75SMike Christie conn->eh_abort_cnt++; 2331258aad75SMike Christie age = session->age; 2332258aad75SMike Christie 233314936b1eSMike Christie ISCSI_DBG_EH(session, "aborting [sc %p itt 0x%x]\n", sc, task->itt); 233414936b1eSMike Christie __iscsi_get_task(task); 233514936b1eSMike Christie spin_unlock(&session->back_lock); 23367996a778SMike Christie 23379c19a7d0SMike Christie if (task->state == ISCSI_TASK_PENDING) { 2338b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 233977a23c21SMike Christie goto success; 234077a23c21SMike Christie } 23417996a778SMike Christie 2342843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2343ec29d0acSMike Christie if (session->tmf_state != TMF_INITIAL) 23447996a778SMike Christie goto failed; 2345ec29d0acSMike Christie session->tmf_state = TMF_QUEUED; 23467996a778SMike Christie 2347ec29d0acSMike Christie hdr = &session->tmhdr; 23489c19a7d0SMike Christie iscsi_prep_abort_task_pdu(task, hdr); 2349843c0a8aSMike Christie 2350e9e410e8SBart Van Assche if (iscsi_exec_task_mgmt_fn(conn, hdr, age, session->abort_timeout)) 2351843c0a8aSMike Christie goto failed; 2352843c0a8aSMike Christie 2353ec29d0acSMike Christie switch (session->tmf_state) { 2354843c0a8aSMike Christie case TMF_SUCCESS: 2355659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2356913e5bf4SMike Christie /* 2357913e5bf4SMike Christie * stop tx side incase the target had sent a abort rsp but 2358913e5bf4SMike Christie * the initiator was still writing out data. 2359913e5bf4SMike Christie */ 23606724add1SMike Christie iscsi_suspend_tx(conn); 23617996a778SMike Christie /* 2362913e5bf4SMike Christie * we do not stop the recv side because targets have been 2363913e5bf4SMike Christie * good and have never sent us a successful tmf response 2364913e5bf4SMike Christie * then sent more data for the cmd. 23657996a778SMike Christie */ 2366659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2367b3cd5050SMike Christie fail_scsi_task(task, DID_ABORT); 2368ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 23695d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 2370659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 23716724add1SMike Christie iscsi_start_tx(conn); 237277a23c21SMike Christie goto success_unlocked; 2373843c0a8aSMike Christie case TMF_TIMEDOUT: 237499b06033SMike Christie session->running_aborted_task = task; 2375659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2376df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2377843c0a8aSMike Christie goto failed_unlocked; 2378843c0a8aSMike Christie case TMF_NOT_FOUND: 2379f6f96457SMike Christie if (iscsi_task_is_completed(task)) { 2380ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 23815d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 23829c19a7d0SMike Christie /* task completed before tmf abort response */ 2383bd2199d4SErez Zilber ISCSI_DBG_EH(session, "sc completed while abort in " 2384bd2199d4SErez Zilber "progress\n"); 238577a23c21SMike Christie goto success; 238677a23c21SMike Christie } 2387df561f66SGustavo A. R. Silva fallthrough; 238877a23c21SMike Christie default: 2389ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 2390843c0a8aSMike Christie goto failed; 239177a23c21SMike Christie } 23927996a778SMike Christie 239377a23c21SMike Christie success: 2394659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 239577a23c21SMike Christie success_unlocked: 2396bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort success [sc %p itt 0x%x]\n", 23971b2c7af8SMike Christie sc, task->itt); 239814936b1eSMike Christie iscsi_put_task(task); 2399d39df158SMike Christie iscsi_put_conn(conn->cls_conn); 24006724add1SMike Christie mutex_unlock(&session->eh_mutex); 24017996a778SMike Christie return SUCCESS; 24027996a778SMike Christie 24037996a778SMike Christie failed: 2404659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 240577a23c21SMike Christie failed_unlocked: 2406bd2199d4SErez Zilber ISCSI_DBG_EH(session, "abort failed [sc %p itt 0x%x]\n", sc, 24079c19a7d0SMike Christie task ? task->itt : 0); 240899b06033SMike Christie /* 240999b06033SMike Christie * The driver might be accessing the task so hold the ref. The conn 241099b06033SMike Christie * stop cleanup will drop the ref after ep_disconnect so we know the 241199b06033SMike Christie * driver's no longer touching the task. 241299b06033SMike Christie */ 241399b06033SMike Christie if (!session->running_aborted_task) 241414936b1eSMike Christie iscsi_put_task(task); 241599b06033SMike Christie 2416d39df158SMike Christie iscsi_put_conn(conn->cls_conn); 24176724add1SMike Christie mutex_unlock(&session->eh_mutex); 24187996a778SMike Christie return FAILED; 24197996a778SMike Christie } 24207996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_abort); 24217996a778SMike Christie 2422843c0a8aSMike Christie static void iscsi_prep_lun_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 2423843c0a8aSMike Christie { 2424843c0a8aSMike Christie memset(hdr, 0, sizeof(*hdr)); 2425843c0a8aSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 2426843c0a8aSMike Christie hdr->flags = ISCSI_TM_FUNC_LOGICAL_UNIT_RESET & ISCSI_FLAG_TM_FUNC_MASK; 2427843c0a8aSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 242855bdabdfSAndy Grover int_to_scsilun(sc->device->lun, &hdr->lun); 2429f6d5180cSMike Christie hdr->rtt = RESERVED_ITT; 2430843c0a8aSMike Christie } 2431843c0a8aSMike Christie 2432843c0a8aSMike Christie int iscsi_eh_device_reset(struct scsi_cmnd *sc) 2433843c0a8aSMike Christie { 243475613521SMike Christie struct iscsi_cls_session *cls_session; 243575613521SMike Christie struct iscsi_session *session; 2436843c0a8aSMike Christie struct iscsi_conn *conn; 2437843c0a8aSMike Christie struct iscsi_tm *hdr; 2438843c0a8aSMike Christie int rc = FAILED; 2439843c0a8aSMike Christie 244075613521SMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 244175613521SMike Christie session = cls_session->dd_data; 244275613521SMike Christie 24439cb78c16SHannes Reinecke ISCSI_DBG_EH(session, "LU Reset [sc %p lun %llu]\n", sc, 24449cb78c16SHannes Reinecke sc->device->lun); 2445843c0a8aSMike Christie 2446843c0a8aSMike Christie mutex_lock(&session->eh_mutex); 2447659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 2448843c0a8aSMike Christie /* 2449843c0a8aSMike Christie * Just check if we are not logged in. We cannot check for 2450843c0a8aSMike Christie * the phase because the reset could come from a ioctl. 2451843c0a8aSMike Christie */ 2452843c0a8aSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 2453843c0a8aSMike Christie goto unlock; 2454843c0a8aSMike Christie conn = session->leadconn; 2455843c0a8aSMike Christie 2456843c0a8aSMike Christie /* only have one tmf outstanding at a time */ 2457ec29d0acSMike Christie if (session->tmf_state != TMF_INITIAL) 2458843c0a8aSMike Christie goto unlock; 2459ec29d0acSMike Christie session->tmf_state = TMF_QUEUED; 2460843c0a8aSMike Christie 2461ec29d0acSMike Christie hdr = &session->tmhdr; 2462843c0a8aSMike Christie iscsi_prep_lun_reset_pdu(sc, hdr); 2463843c0a8aSMike Christie 24649c19a7d0SMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 2465f6d5180cSMike Christie session->lu_reset_timeout)) { 2466843c0a8aSMike Christie rc = FAILED; 2467843c0a8aSMike Christie goto unlock; 2468843c0a8aSMike Christie } 2469843c0a8aSMike Christie 2470ec29d0acSMike Christie switch (session->tmf_state) { 2471843c0a8aSMike Christie case TMF_SUCCESS: 2472843c0a8aSMike Christie break; 2473843c0a8aSMike Christie case TMF_TIMEDOUT: 2474659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2475df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2476843c0a8aSMike Christie goto done; 2477843c0a8aSMike Christie default: 2478ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 2479843c0a8aSMike Christie goto unlock; 2480843c0a8aSMike Christie } 2481843c0a8aSMike Christie 2482843c0a8aSMike Christie rc = SUCCESS; 2483659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2484843c0a8aSMike Christie 2485843c0a8aSMike Christie iscsi_suspend_tx(conn); 2486913e5bf4SMike Christie 2487659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 24885d12c05eSMike Christie memset(hdr, 0, sizeof(*hdr)); 24893bbaaad9SMike Christie fail_scsi_tasks(conn, sc->device->lun, DID_ERROR); 2490ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 2491659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2492843c0a8aSMike Christie 2493843c0a8aSMike Christie iscsi_start_tx(conn); 2494843c0a8aSMike Christie goto done; 2495843c0a8aSMike Christie 2496843c0a8aSMike Christie unlock: 2497659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2498843c0a8aSMike Christie done: 2499bd2199d4SErez Zilber ISCSI_DBG_EH(session, "dev reset result = %s\n", 2500843c0a8aSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 2501843c0a8aSMike Christie mutex_unlock(&session->eh_mutex); 2502843c0a8aSMike Christie return rc; 2503843c0a8aSMike Christie } 2504843c0a8aSMike Christie EXPORT_SYMBOL_GPL(iscsi_eh_device_reset); 2505843c0a8aSMike Christie 25063fe5ae8bSMike Christie void iscsi_session_recovery_timedout(struct iscsi_cls_session *cls_session) 25073fe5ae8bSMike Christie { 25083fe5ae8bSMike Christie struct iscsi_session *session = cls_session->dd_data; 25093fe5ae8bSMike Christie 2510659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 25113fe5ae8bSMike Christie if (session->state != ISCSI_STATE_LOGGED_IN) { 25123fe5ae8bSMike Christie session->state = ISCSI_STATE_RECOVERY_FAILED; 2513ec29d0acSMike Christie wake_up(&session->ehwait); 25143fe5ae8bSMike Christie } 2515659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 25163fe5ae8bSMike Christie } 25173fe5ae8bSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_recovery_timedout); 25183fe5ae8bSMike Christie 25193fe5ae8bSMike Christie /** 25203fe5ae8bSMike Christie * iscsi_eh_session_reset - drop session and attempt relogin 25213fe5ae8bSMike Christie * @sc: scsi command 25223fe5ae8bSMike Christie * 25233fe5ae8bSMike Christie * This function will wait for a relogin, session termination from 25243fe5ae8bSMike Christie * userspace, or a recovery/replacement timeout. 25253fe5ae8bSMike Christie */ 2526309ce156SJayamohan Kallickal int iscsi_eh_session_reset(struct scsi_cmnd *sc) 25273fe5ae8bSMike Christie { 25283fe5ae8bSMike Christie struct iscsi_cls_session *cls_session; 25293fe5ae8bSMike Christie struct iscsi_session *session; 25303fe5ae8bSMike Christie struct iscsi_conn *conn; 25313fe5ae8bSMike Christie 25323fe5ae8bSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 25333fe5ae8bSMike Christie session = cls_session->dd_data; 25343fe5ae8bSMike Christie 25353fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2536659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 25373fe5ae8bSMike Christie if (session->state == ISCSI_STATE_TERMINATE) { 25383fe5ae8bSMike Christie failed: 25393fe5ae8bSMike Christie ISCSI_DBG_EH(session, 25403fe5ae8bSMike Christie "failing session reset: Could not log back into " 25415db6dd14SFred Herard "%s [age %d]\n", session->targetname, 25425db6dd14SFred Herard session->age); 2543659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 25443fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 25453fe5ae8bSMike Christie return FAILED; 25463fe5ae8bSMike Christie } 25473fe5ae8bSMike Christie 2548fda290c5SMike Christie conn = session->leadconn; 2549fda290c5SMike Christie iscsi_get_conn(conn->cls_conn); 2550fda290c5SMike Christie 2551659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 25523fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 2553fda290c5SMike Christie 2554df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 2555fda290c5SMike Christie iscsi_put_conn(conn->cls_conn); 25563fe5ae8bSMike Christie 25573fe5ae8bSMike Christie ISCSI_DBG_EH(session, "wait for relogin\n"); 2558ec29d0acSMike Christie wait_event_interruptible(session->ehwait, 25593fe5ae8bSMike Christie session->state == ISCSI_STATE_TERMINATE || 25603fe5ae8bSMike Christie session->state == ISCSI_STATE_LOGGED_IN || 25613fe5ae8bSMike Christie session->state == ISCSI_STATE_RECOVERY_FAILED); 25623fe5ae8bSMike Christie if (signal_pending(current)) 25633fe5ae8bSMike Christie flush_signals(current); 25643fe5ae8bSMike Christie 25653fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2566659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 25673fe5ae8bSMike Christie if (session->state == ISCSI_STATE_LOGGED_IN) { 25683fe5ae8bSMike Christie ISCSI_DBG_EH(session, 25693fe5ae8bSMike Christie "session reset succeeded for %s,%s\n", 25703fe5ae8bSMike Christie session->targetname, conn->persistent_address); 25713fe5ae8bSMike Christie } else 25723fe5ae8bSMike Christie goto failed; 2573659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 25743fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 25753fe5ae8bSMike Christie return SUCCESS; 25763fe5ae8bSMike Christie } 2577309ce156SJayamohan Kallickal EXPORT_SYMBOL_GPL(iscsi_eh_session_reset); 25783fe5ae8bSMike Christie 25793fe5ae8bSMike Christie static void iscsi_prep_tgt_reset_pdu(struct scsi_cmnd *sc, struct iscsi_tm *hdr) 25803fe5ae8bSMike Christie { 25813fe5ae8bSMike Christie memset(hdr, 0, sizeof(*hdr)); 25823fe5ae8bSMike Christie hdr->opcode = ISCSI_OP_SCSI_TMFUNC | ISCSI_OP_IMMEDIATE; 25833fe5ae8bSMike Christie hdr->flags = ISCSI_TM_FUNC_TARGET_WARM_RESET & ISCSI_FLAG_TM_FUNC_MASK; 25843fe5ae8bSMike Christie hdr->flags |= ISCSI_FLAG_CMD_FINAL; 25853fe5ae8bSMike Christie hdr->rtt = RESERVED_ITT; 25863fe5ae8bSMike Christie } 25873fe5ae8bSMike Christie 25883fe5ae8bSMike Christie /** 25893fe5ae8bSMike Christie * iscsi_eh_target_reset - reset target 25903fe5ae8bSMike Christie * @sc: scsi command 25913fe5ae8bSMike Christie * 2592309ce156SJayamohan Kallickal * This will attempt to send a warm target reset. 25933fe5ae8bSMike Christie */ 25943907adf6SBart Van Assche static int iscsi_eh_target_reset(struct scsi_cmnd *sc) 25953fe5ae8bSMike Christie { 25963fe5ae8bSMike Christie struct iscsi_cls_session *cls_session; 25973fe5ae8bSMike Christie struct iscsi_session *session; 25983fe5ae8bSMike Christie struct iscsi_conn *conn; 25993fe5ae8bSMike Christie struct iscsi_tm *hdr; 26003fe5ae8bSMike Christie int rc = FAILED; 26013fe5ae8bSMike Christie 26023fe5ae8bSMike Christie cls_session = starget_to_session(scsi_target(sc->device)); 26033fe5ae8bSMike Christie session = cls_session->dd_data; 26043fe5ae8bSMike Christie 26053fe5ae8bSMike Christie ISCSI_DBG_EH(session, "tgt Reset [sc %p tgt %s]\n", sc, 26063fe5ae8bSMike Christie session->targetname); 26073fe5ae8bSMike Christie 26083fe5ae8bSMike Christie mutex_lock(&session->eh_mutex); 2609659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 26103fe5ae8bSMike Christie /* 26113fe5ae8bSMike Christie * Just check if we are not logged in. We cannot check for 26123fe5ae8bSMike Christie * the phase because the reset could come from a ioctl. 26133fe5ae8bSMike Christie */ 26143fe5ae8bSMike Christie if (!session->leadconn || session->state != ISCSI_STATE_LOGGED_IN) 26153fe5ae8bSMike Christie goto unlock; 26163fe5ae8bSMike Christie conn = session->leadconn; 26173fe5ae8bSMike Christie 26183fe5ae8bSMike Christie /* only have one tmf outstanding at a time */ 2619ec29d0acSMike Christie if (session->tmf_state != TMF_INITIAL) 26203fe5ae8bSMike Christie goto unlock; 2621ec29d0acSMike Christie session->tmf_state = TMF_QUEUED; 26223fe5ae8bSMike Christie 2623ec29d0acSMike Christie hdr = &session->tmhdr; 26243fe5ae8bSMike Christie iscsi_prep_tgt_reset_pdu(sc, hdr); 26253fe5ae8bSMike Christie 26263fe5ae8bSMike Christie if (iscsi_exec_task_mgmt_fn(conn, hdr, session->age, 26273fe5ae8bSMike Christie session->tgt_reset_timeout)) { 26283fe5ae8bSMike Christie rc = FAILED; 26293fe5ae8bSMike Christie goto unlock; 26303fe5ae8bSMike Christie } 26313fe5ae8bSMike Christie 2632ec29d0acSMike Christie switch (session->tmf_state) { 26333fe5ae8bSMike Christie case TMF_SUCCESS: 26343fe5ae8bSMike Christie break; 26353fe5ae8bSMike Christie case TMF_TIMEDOUT: 2636659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 2637df4da5cdSMike Christie iscsi_conn_failure(conn, ISCSI_ERR_SCSI_EH_SESSION_RST); 26383fe5ae8bSMike Christie goto done; 26393fe5ae8bSMike Christie default: 2640ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 26413fe5ae8bSMike Christie goto unlock; 26423fe5ae8bSMike Christie } 26433fe5ae8bSMike Christie 26443fe5ae8bSMike Christie rc = SUCCESS; 2645659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 26463fe5ae8bSMike Christie 26473fe5ae8bSMike Christie iscsi_suspend_tx(conn); 26483fe5ae8bSMike Christie 2649659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 26503fe5ae8bSMike Christie memset(hdr, 0, sizeof(*hdr)); 26513fe5ae8bSMike Christie fail_scsi_tasks(conn, -1, DID_ERROR); 2652ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 2653659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 26543fe5ae8bSMike Christie 26553fe5ae8bSMike Christie iscsi_start_tx(conn); 26563fe5ae8bSMike Christie goto done; 26573fe5ae8bSMike Christie 26583fe5ae8bSMike Christie unlock: 2659659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 26603fe5ae8bSMike Christie done: 26613fe5ae8bSMike Christie ISCSI_DBG_EH(session, "tgt %s reset result = %s\n", session->targetname, 26623fe5ae8bSMike Christie rc == SUCCESS ? "SUCCESS" : "FAILED"); 26633fe5ae8bSMike Christie mutex_unlock(&session->eh_mutex); 2664309ce156SJayamohan Kallickal return rc; 2665309ce156SJayamohan Kallickal } 26663fe5ae8bSMike Christie 2667309ce156SJayamohan Kallickal /** 2668309ce156SJayamohan Kallickal * iscsi_eh_recover_target - reset target and possibly the session 2669309ce156SJayamohan Kallickal * @sc: scsi command 2670309ce156SJayamohan Kallickal * 2671309ce156SJayamohan Kallickal * This will attempt to send a warm target reset. If that fails, 2672309ce156SJayamohan Kallickal * we will escalate to ERL0 session recovery. 2673309ce156SJayamohan Kallickal */ 2674309ce156SJayamohan Kallickal int iscsi_eh_recover_target(struct scsi_cmnd *sc) 2675309ce156SJayamohan Kallickal { 2676309ce156SJayamohan Kallickal int rc; 2677309ce156SJayamohan Kallickal 2678309ce156SJayamohan Kallickal rc = iscsi_eh_target_reset(sc); 26793fe5ae8bSMike Christie if (rc == FAILED) 26803fe5ae8bSMike Christie rc = iscsi_eh_session_reset(sc); 26813fe5ae8bSMike Christie return rc; 26823fe5ae8bSMike Christie } 2683309ce156SJayamohan Kallickal EXPORT_SYMBOL_GPL(iscsi_eh_recover_target); 26843fe5ae8bSMike Christie 26856320377fSOlaf Kirch /* 26866320377fSOlaf Kirch * Pre-allocate a pool of @max items of @item_size. By default, the pool 26876320377fSOlaf Kirch * should be accessed via kfifo_{get,put} on q->queue. 26886320377fSOlaf Kirch * Optionally, the caller can obtain the array of object pointers 26896320377fSOlaf Kirch * by passing in a non-NULL @items pointer 26906320377fSOlaf Kirch */ 26917996a778SMike Christie int 26926320377fSOlaf Kirch iscsi_pool_init(struct iscsi_pool *q, int max, void ***items, int item_size) 26937996a778SMike Christie { 26946320377fSOlaf Kirch int i, num_arrays = 1; 26957996a778SMike Christie 26966320377fSOlaf Kirch memset(q, 0, sizeof(*q)); 26977996a778SMike Christie 26987996a778SMike Christie q->max = max; 26996320377fSOlaf Kirch 27006320377fSOlaf Kirch /* If the user passed an items pointer, he wants a copy of 27016320377fSOlaf Kirch * the array. */ 27026320377fSOlaf Kirch if (items) 27036320377fSOlaf Kirch num_arrays++; 2704778e1cddSKees Cook q->pool = kvcalloc(num_arrays * max, sizeof(void *), GFP_KERNEL); 27056320377fSOlaf Kirch if (q->pool == NULL) 2706f474a37bSJean Delvare return -ENOMEM; 27077996a778SMike Christie 2708c1e13f25SStefani Seibold kfifo_init(&q->queue, (void*)q->pool, max * sizeof(void*)); 27097996a778SMike Christie 27107996a778SMike Christie for (i = 0; i < max; i++) { 27116320377fSOlaf Kirch q->pool[i] = kzalloc(item_size, GFP_KERNEL); 27127996a778SMike Christie if (q->pool[i] == NULL) { 27136320377fSOlaf Kirch q->max = i; 27146320377fSOlaf Kirch goto enomem; 27157996a778SMike Christie } 27167acd72ebSStefani Seibold kfifo_in(&q->queue, (void*)&q->pool[i], sizeof(void*)); 27177996a778SMike Christie } 27186320377fSOlaf Kirch 27196320377fSOlaf Kirch if (items) { 27206320377fSOlaf Kirch *items = q->pool + max; 27216320377fSOlaf Kirch memcpy(*items, q->pool, max * sizeof(void *)); 27226320377fSOlaf Kirch } 27236320377fSOlaf Kirch 27247996a778SMike Christie return 0; 27256320377fSOlaf Kirch 27266320377fSOlaf Kirch enomem: 27276320377fSOlaf Kirch iscsi_pool_free(q); 27286320377fSOlaf Kirch return -ENOMEM; 27297996a778SMike Christie } 27307996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_init); 27317996a778SMike Christie 27326320377fSOlaf Kirch void iscsi_pool_free(struct iscsi_pool *q) 27337996a778SMike Christie { 27347996a778SMike Christie int i; 27357996a778SMike Christie 27367996a778SMike Christie for (i = 0; i < q->max; i++) 27376320377fSOlaf Kirch kfree(q->pool[i]); 2738bfcc62edSKyle Fortin kvfree(q->pool); 27397996a778SMike Christie } 27407996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_pool_free); 27417996a778SMike Christie 2742b4046922SMike Christie int iscsi_host_get_max_scsi_cmds(struct Scsi_Host *shost, 2743b4046922SMike Christie uint16_t requested_cmds_max) 2744b4046922SMike Christie { 2745b4046922SMike Christie int scsi_cmds, total_cmds = requested_cmds_max; 2746b4046922SMike Christie 2747b4046922SMike Christie check: 2748b4046922SMike Christie if (!total_cmds) 2749b4046922SMike Christie total_cmds = ISCSI_DEF_XMIT_CMDS_MAX; 2750b4046922SMike Christie /* 2751b4046922SMike Christie * The iscsi layer needs some tasks for nop handling and tmfs, 2752b4046922SMike Christie * so the cmds_max must at least be greater than ISCSI_MGMT_CMDS_MAX 2753b4046922SMike Christie * + 1 command for scsi IO. 2754b4046922SMike Christie */ 2755b4046922SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 2756b4046922SMike Christie printk(KERN_ERR "iscsi: invalid max cmds of %d. Must be a power of two that is at least %d.\n", 2757b4046922SMike Christie total_cmds, ISCSI_TOTAL_CMDS_MIN); 2758b4046922SMike Christie return -EINVAL; 2759b4046922SMike Christie } 2760b4046922SMike Christie 2761b4046922SMike Christie if (total_cmds > ISCSI_TOTAL_CMDS_MAX) { 2762b4046922SMike 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", 2763b4046922SMike Christie requested_cmds_max, ISCSI_TOTAL_CMDS_MAX, 2764b4046922SMike Christie ISCSI_TOTAL_CMDS_MAX); 2765b4046922SMike Christie total_cmds = ISCSI_TOTAL_CMDS_MAX; 2766b4046922SMike Christie } 2767b4046922SMike Christie 2768b4046922SMike Christie if (!is_power_of_2(total_cmds)) { 2769b4046922SMike Christie total_cmds = rounddown_pow_of_two(total_cmds); 2770b4046922SMike Christie if (total_cmds < ISCSI_TOTAL_CMDS_MIN) { 2771b4046922SMike 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); 2772b4046922SMike Christie return -EINVAL; 2773b4046922SMike Christie } 2774b4046922SMike Christie 2775b4046922SMike Christie printk(KERN_INFO "iscsi: invalid max cmds %d. Must be a power of 2. Rounding max cmds down to %d.\n", 2776b4046922SMike Christie requested_cmds_max, total_cmds); 2777b4046922SMike Christie } 2778b4046922SMike Christie 2779b4046922SMike Christie scsi_cmds = total_cmds - ISCSI_MGMT_CMDS_MAX; 2780b4046922SMike Christie if (shost->can_queue && scsi_cmds > shost->can_queue) { 2781b4046922SMike Christie total_cmds = shost->can_queue; 2782b4046922SMike Christie 2783b4046922SMike Christie printk(KERN_INFO "iscsi: requested max cmds %u is higher than driver limit. Using driver limit %u\n", 2784b4046922SMike Christie requested_cmds_max, shost->can_queue); 2785b4046922SMike Christie goto check; 2786b4046922SMike Christie } 2787b4046922SMike Christie 2788b4046922SMike Christie return scsi_cmds; 2789b4046922SMike Christie } 2790b4046922SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_max_scsi_cmds); 2791b4046922SMike Christie 2792a4804cd6SMike Christie /** 2793a4804cd6SMike Christie * iscsi_host_add - add host to system 2794a4804cd6SMike Christie * @shost: scsi host 2795a4804cd6SMike Christie * @pdev: parent device 2796a4804cd6SMike Christie * 2797a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers 2798a4804cd6SMike Christie * to add a host to the system. 2799a4804cd6SMike Christie */ 2800a4804cd6SMike Christie int iscsi_host_add(struct Scsi_Host *shost, struct device *pdev) 28017996a778SMike Christie { 28028e9a20ceSMike Christie if (!shost->can_queue) 28038e9a20ceSMike Christie shost->can_queue = ISCSI_DEF_XMIT_CMDS_MAX; 28048e9a20ceSMike Christie 28054d108350SMike Christie if (!shost->cmd_per_lun) 28064d108350SMike Christie shost->cmd_per_lun = ISCSI_DEF_CMD_PER_LUN; 28074d108350SMike Christie 2808a4804cd6SMike Christie return scsi_add_host(shost, pdev); 2809a4804cd6SMike Christie } 2810a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_add); 2811a4804cd6SMike Christie 2812a4804cd6SMike Christie /** 2813a4804cd6SMike Christie * iscsi_host_alloc - allocate a host and driver data 2814a4804cd6SMike Christie * @sht: scsi host template 2815a4804cd6SMike Christie * @dd_data_size: driver host data size 281632ae763eSMike Christie * @xmit_can_sleep: bool indicating if LLD will queue IO from a work queue 2817a4804cd6SMike Christie * 2818a4804cd6SMike Christie * This should be called by partial offload and software iscsi drivers. 2819a4804cd6SMike Christie * To access the driver specific memory use the iscsi_host_priv() macro. 2820a4804cd6SMike Christie */ 2821a4804cd6SMike Christie struct Scsi_Host *iscsi_host_alloc(struct scsi_host_template *sht, 28224d108350SMike Christie int dd_data_size, bool xmit_can_sleep) 2823a4804cd6SMike Christie { 2824a4804cd6SMike Christie struct Scsi_Host *shost; 2825e5bd7b54SMike Christie struct iscsi_host *ihost; 2826a4804cd6SMike Christie 2827a4804cd6SMike Christie shost = scsi_host_alloc(sht, sizeof(struct iscsi_host) + dd_data_size); 2828a4804cd6SMike Christie if (!shost) 2829a4804cd6SMike Christie return NULL; 2830e5bd7b54SMike Christie ihost = shost_priv(shost); 283132ae763eSMike Christie 283232ae763eSMike Christie if (xmit_can_sleep) { 283369af1c95SMike Christie ihost->workq = alloc_workqueue("iscsi_q_%d", 28343ce41966SBob Liu WQ_SYSFS | __WQ_LEGACY | WQ_MEM_RECLAIM | WQ_UNBOUND, 283569af1c95SMike Christie 1, shost->host_no); 283632ae763eSMike Christie if (!ihost->workq) 283732ae763eSMike Christie goto free_host; 283832ae763eSMike Christie } 283932ae763eSMike Christie 2840e5bd7b54SMike Christie spin_lock_init(&ihost->lock); 2841e5bd7b54SMike Christie ihost->state = ISCSI_HOST_SETUP; 2842e5bd7b54SMike Christie ihost->num_sessions = 0; 2843e5bd7b54SMike Christie init_waitqueue_head(&ihost->session_removal_wq); 2844a4804cd6SMike Christie return shost; 284532ae763eSMike Christie 284632ae763eSMike Christie free_host: 284732ae763eSMike Christie scsi_host_put(shost); 284832ae763eSMike Christie return NULL; 284975613521SMike Christie } 2850a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_alloc); 285175613521SMike Christie 2852e5bd7b54SMike Christie static void iscsi_notify_host_removed(struct iscsi_cls_session *cls_session) 2853e5bd7b54SMike Christie { 285440a06e75SMike Christie iscsi_session_failure(cls_session->dd_data, ISCSI_ERR_INVALID_HOST); 2855e5bd7b54SMike Christie } 2856e5bd7b54SMike Christie 2857a4804cd6SMike Christie /** 2858a4804cd6SMike Christie * iscsi_host_remove - remove host and sessions 2859a4804cd6SMike Christie * @shost: scsi host 286031500e90SMike Christie * @is_shutdown: true if called from a driver shutdown callout 2861a4804cd6SMike Christie * 2862e5bd7b54SMike Christie * If there are any sessions left, this will initiate the removal and wait 2863e5bd7b54SMike Christie * for the completion. 2864a4804cd6SMike Christie */ 286531500e90SMike Christie void iscsi_host_remove(struct Scsi_Host *shost, bool is_shutdown) 2866a4804cd6SMike Christie { 2867e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2868e5bd7b54SMike Christie unsigned long flags; 2869e5bd7b54SMike Christie 2870e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2871e5bd7b54SMike Christie ihost->state = ISCSI_HOST_REMOVED; 2872e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2873e5bd7b54SMike Christie 287431500e90SMike Christie if (!is_shutdown) 2875e5bd7b54SMike Christie iscsi_host_for_each_session(shost, iscsi_notify_host_removed); 287631500e90SMike Christie else 287731500e90SMike Christie iscsi_host_for_each_session(shost, iscsi_force_destroy_session); 287831500e90SMike Christie 2879e5bd7b54SMike Christie wait_event_interruptible(ihost->session_removal_wq, 2880e5bd7b54SMike Christie ihost->num_sessions == 0); 2881e5bd7b54SMike Christie if (signal_pending(current)) 2882e5bd7b54SMike Christie flush_signals(current); 2883e5bd7b54SMike Christie 2884a4804cd6SMike Christie scsi_remove_host(shost); 2885a4804cd6SMike Christie } 2886a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_remove); 2887a4804cd6SMike Christie 2888a4804cd6SMike Christie void iscsi_host_free(struct Scsi_Host *shost) 288975613521SMike Christie { 289075613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 289175613521SMike Christie 2892c435f0a9SMike Christie if (ihost->workq) 2893c435f0a9SMike Christie destroy_workqueue(ihost->workq); 2894c435f0a9SMike Christie 289575613521SMike Christie kfree(ihost->netdev); 289675613521SMike Christie kfree(ihost->hwaddress); 289775613521SMike Christie kfree(ihost->initiatorname); 2898a4804cd6SMike Christie scsi_host_put(shost); 289975613521SMike Christie } 2900a4804cd6SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_free); 290175613521SMike Christie 2902e5bd7b54SMike Christie static void iscsi_host_dec_session_cnt(struct Scsi_Host *shost) 2903e5bd7b54SMike Christie { 2904e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 2905e5bd7b54SMike Christie unsigned long flags; 2906e5bd7b54SMike Christie 2907e5bd7b54SMike Christie shost = scsi_host_get(shost); 2908e5bd7b54SMike Christie if (!shost) { 2909e5bd7b54SMike Christie printk(KERN_ERR "Invalid state. Cannot notify host removal " 2910e5bd7b54SMike Christie "of session teardown event because host already " 2911e5bd7b54SMike Christie "removed.\n"); 2912e5bd7b54SMike Christie return; 2913e5bd7b54SMike Christie } 2914e5bd7b54SMike Christie 2915e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2916e5bd7b54SMike Christie ihost->num_sessions--; 2917e5bd7b54SMike Christie if (ihost->num_sessions == 0) 2918e5bd7b54SMike Christie wake_up(&ihost->session_removal_wq); 2919e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2920e5bd7b54SMike Christie scsi_host_put(shost); 2921e5bd7b54SMike Christie } 2922e5bd7b54SMike Christie 292375613521SMike Christie /** 292475613521SMike Christie * iscsi_session_setup - create iscsi cls session and host and session 292575613521SMike Christie * @iscsit: iscsi transport template 292675613521SMike Christie * @shost: scsi host 292775613521SMike Christie * @cmds_max: session can queue 2928ccd4a430SRandy Dunlap * @dd_size: private driver data size, added to session allocation size 29299c19a7d0SMike Christie * @cmd_task_size: LLD task private data size 293075613521SMike Christie * @initial_cmdsn: initial CmdSN 2931ccd4a430SRandy Dunlap * @id: target ID to add to this session 293275613521SMike Christie * 293375613521SMike Christie * This can be used by software iscsi_transports that allocate 293475613521SMike Christie * a session per scsi host. 29353cf7b233SMike Christie * 29363cf7b233SMike Christie * Callers should set cmds_max to the largest total numer (mgmt + scsi) of 29373cf7b233SMike Christie * tasks they support. The iscsi layer reserves ISCSI_MGMT_CMDS_MAX tasks 29383cf7b233SMike Christie * for nop handling and login/logout requests. 293975613521SMike Christie */ 294075613521SMike Christie struct iscsi_cls_session * 294175613521SMike Christie iscsi_session_setup(struct iscsi_transport *iscsit, struct Scsi_Host *shost, 2942b8b9e1b8SJayamohan Kallickal uint16_t cmds_max, int dd_size, int cmd_task_size, 29437970634bSMike Christie uint32_t initial_cmdsn, unsigned int id) 294475613521SMike Christie { 2945e5bd7b54SMike Christie struct iscsi_host *ihost = shost_priv(shost); 294675613521SMike Christie struct iscsi_session *session; 294775613521SMike Christie struct iscsi_cls_session *cls_session; 2948b4046922SMike Christie int cmd_i, scsi_cmds; 2949e5bd7b54SMike Christie unsigned long flags; 2950e5bd7b54SMike Christie 2951e5bd7b54SMike Christie spin_lock_irqsave(&ihost->lock, flags); 2952e5bd7b54SMike Christie if (ihost->state == ISCSI_HOST_REMOVED) { 2953e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 2954e5bd7b54SMike Christie return NULL; 2955e5bd7b54SMike Christie } 2956e5bd7b54SMike Christie ihost->num_sessions++; 2957e5bd7b54SMike Christie spin_unlock_irqrestore(&ihost->lock, flags); 29588e9a20ceSMike Christie 2959b4046922SMike Christie scsi_cmds = iscsi_host_get_max_scsi_cmds(shost, cmds_max); 2960b4046922SMike Christie if (scsi_cmds < 0) 2961e5bd7b54SMike Christie goto dec_session_count; 29621548271eSMike Christie 29635d91e209SMike Christie cls_session = iscsi_alloc_session(shost, iscsit, 2964b8b9e1b8SJayamohan Kallickal sizeof(struct iscsi_session) + 2965b8b9e1b8SJayamohan Kallickal dd_size); 296675613521SMike Christie if (!cls_session) 2967e5bd7b54SMike Christie goto dec_session_count; 296875613521SMike Christie session = cls_session->dd_data; 296975613521SMike Christie session->cls_session = cls_session; 29707996a778SMike Christie session->host = shost; 29717996a778SMike Christie session->state = ISCSI_STATE_FREE; 2972f6d5180cSMike Christie session->fast_abort = 1; 29733fe5ae8bSMike Christie session->tgt_reset_timeout = 30; 29744cd49ea1SMike Christie session->lu_reset_timeout = 15; 29754cd49ea1SMike Christie session->abort_timeout = 10; 29763cf7b233SMike Christie session->scsi_cmds_max = scsi_cmds; 2977b4046922SMike Christie session->cmds_max = scsi_cmds + ISCSI_MGMT_CMDS_MAX; 2978e0726407SMike Christie session->queued_cmdsn = session->cmdsn = initial_cmdsn; 29797996a778SMike Christie session->exp_cmdsn = initial_cmdsn + 1; 29807996a778SMike Christie session->max_cmdsn = initial_cmdsn + 1; 29817996a778SMike Christie session->max_r2t = 1; 29827996a778SMike Christie session->tt = iscsit; 2983b8b9e1b8SJayamohan Kallickal session->dd_data = cls_session->dd_data + sizeof(*session); 2984659743b0SShlomo Pongratz 2985ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 2986ec29d0acSMike Christie timer_setup(&session->tmf_timer, iscsi_tmf_timedout, 0); 29876724add1SMike Christie mutex_init(&session->eh_mutex); 2988e018f03dSDing Hui init_waitqueue_head(&session->ehwait); 2989ec29d0acSMike Christie 2990659743b0SShlomo Pongratz spin_lock_init(&session->frwd_lock); 2991659743b0SShlomo Pongratz spin_lock_init(&session->back_lock); 29927996a778SMike Christie 29937996a778SMike Christie /* initialize SCSI PDU commands pool */ 29947996a778SMike Christie if (iscsi_pool_init(&session->cmdpool, session->cmds_max, 29957996a778SMike Christie (void***)&session->cmds, 29969c19a7d0SMike Christie cmd_task_size + sizeof(struct iscsi_task))) 29977996a778SMike Christie goto cmdpool_alloc_fail; 29987996a778SMike Christie 29997996a778SMike Christie /* pre-format cmds pool with ITT */ 30007996a778SMike Christie for (cmd_i = 0; cmd_i < session->cmds_max; cmd_i++) { 30019c19a7d0SMike Christie struct iscsi_task *task = session->cmds[cmd_i]; 30027996a778SMike Christie 30039c19a7d0SMike Christie if (cmd_task_size) 30049c19a7d0SMike Christie task->dd_data = &task[1]; 30059c19a7d0SMike Christie task->itt = cmd_i; 30063bbaaad9SMike Christie task->state = ISCSI_TASK_FREE; 30079c19a7d0SMike Christie INIT_LIST_HEAD(&task->running); 30087996a778SMike Christie } 30097996a778SMike Christie 3010f53a88daSMike Christie if (!try_module_get(iscsit->owner)) 301175613521SMike Christie goto module_get_fail; 301275613521SMike Christie 30137970634bSMike Christie if (iscsi_add_session(cls_session, id)) 3014f53a88daSMike Christie goto cls_session_fail; 3015e5bd7b54SMike Christie 30167996a778SMike Christie return cls_session; 30177996a778SMike Christie 30187996a778SMike Christie cls_session_fail: 301975613521SMike Christie module_put(iscsit->owner); 302075613521SMike Christie module_get_fail: 30216320377fSOlaf Kirch iscsi_pool_free(&session->cmdpool); 30227996a778SMike Christie cmdpool_alloc_fail: 302375613521SMike Christie iscsi_free_session(cls_session); 3024e5bd7b54SMike Christie dec_session_count: 3025e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 30267996a778SMike Christie return NULL; 30277996a778SMike Christie } 30287996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_setup); 30297996a778SMike Christie 30307996a778SMike Christie /** 30317996a778SMike Christie * iscsi_session_teardown - destroy session, host, and cls_session 303275613521SMike Christie * @cls_session: iscsi session 303375613521SMike Christie */ 30347996a778SMike Christie void iscsi_session_teardown(struct iscsi_cls_session *cls_session) 30357996a778SMike Christie { 303675613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 303763f75cc8SMike Christie struct module *owner = cls_session->transport->owner; 3038e5bd7b54SMike Christie struct Scsi_Host *shost = session->host; 30397996a778SMike Christie 30409e10b512SKhazhismel Kumykov iscsi_remove_session(cls_session); 30419e10b512SKhazhismel Kumykov 3042a1f3486bSMike Christie iscsi_pool_free(&session->cmdpool); 3043b2c64167SMike Christie kfree(session->password); 3044b2c64167SMike Christie kfree(session->password_in); 3045b2c64167SMike Christie kfree(session->username); 3046b2c64167SMike Christie kfree(session->username_in); 3047f3ff0c36SMike Christie kfree(session->targetname); 30483c5c4801SVikas Chaudhary kfree(session->targetalias); 304988dfd340SMike Christie kfree(session->initiatorname); 30503b9373e9SEddie Wai kfree(session->boot_root); 30513b9373e9SEddie Wai kfree(session->boot_nic); 30523b9373e9SEddie Wai kfree(session->boot_target); 305388dfd340SMike Christie kfree(session->ifacename); 3054f8525eb4SAdheer Chandravanshi kfree(session->portal_type); 3055f8525eb4SAdheer Chandravanshi kfree(session->discovery_parent_type); 3056f3ff0c36SMike Christie 30579e10b512SKhazhismel Kumykov iscsi_free_session(cls_session); 30589e10b512SKhazhismel Kumykov 3059e5bd7b54SMike Christie iscsi_host_dec_session_cnt(shost); 306063f75cc8SMike Christie module_put(owner); 30617996a778SMike Christie } 30627996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_session_teardown); 30637996a778SMike Christie 30647996a778SMike Christie /** 30657996a778SMike Christie * iscsi_conn_setup - create iscsi_cls_conn and iscsi_conn 30667996a778SMike Christie * @cls_session: iscsi_cls_session 30675d91e209SMike Christie * @dd_size: private driver data size 30687996a778SMike Christie * @conn_idx: cid 30695d91e209SMike Christie */ 30707996a778SMike Christie struct iscsi_cls_conn * 30715d91e209SMike Christie iscsi_conn_setup(struct iscsi_cls_session *cls_session, int dd_size, 30725d91e209SMike Christie uint32_t conn_idx) 30737996a778SMike Christie { 307475613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 30757996a778SMike Christie struct iscsi_conn *conn; 30767996a778SMike Christie struct iscsi_cls_conn *cls_conn; 3077d36ab6f3SMike Christie char *data; 30787dae459fSWenchao Hao int err; 30797996a778SMike Christie 30807dae459fSWenchao Hao cls_conn = iscsi_alloc_conn(cls_session, sizeof(*conn) + dd_size, 30815d91e209SMike Christie conn_idx); 30827996a778SMike Christie if (!cls_conn) 30837996a778SMike Christie return NULL; 30847996a778SMike Christie conn = cls_conn->dd_data; 30857996a778SMike Christie 30865d91e209SMike Christie conn->dd_data = cls_conn->dd_data + sizeof(*conn); 30877996a778SMike Christie conn->session = session; 30887996a778SMike Christie conn->cls_conn = cls_conn; 30897996a778SMike Christie conn->c_stage = ISCSI_CONN_INITIAL_STAGE; 30907996a778SMike Christie conn->id = conn_idx; 30917996a778SMike Christie conn->exp_statsn = 0; 3092f6d5180cSMike Christie 30932c4b9637SKees Cook timer_setup(&conn->transport_timer, iscsi_check_transport_timeouts, 0); 3094f6d5180cSMike Christie 3095843c0a8aSMike Christie INIT_LIST_HEAD(&conn->mgmtqueue); 30963bbaaad9SMike Christie INIT_LIST_HEAD(&conn->cmdqueue); 3097843c0a8aSMike Christie INIT_LIST_HEAD(&conn->requeue); 3098c4028958SDavid Howells INIT_WORK(&conn->xmitwork, iscsi_xmitworker); 30997996a778SMike Christie 31009c19a7d0SMike Christie /* allocate login_task used for the login/text sequences */ 3101659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 31027acd72ebSStefani Seibold if (!kfifo_out(&session->cmdpool.queue, 31039c19a7d0SMike Christie (void*)&conn->login_task, 31047996a778SMike Christie sizeof(void*))) { 3105659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31069c19a7d0SMike Christie goto login_task_alloc_fail; 31077996a778SMike Christie } 3108659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31097996a778SMike Christie 3110cfeb2cf9SMike Christie data = (char *) __get_free_pages(GFP_KERNEL, 3111cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 3112d36ab6f3SMike Christie if (!data) 31139c19a7d0SMike Christie goto login_task_data_alloc_fail; 31149c19a7d0SMike Christie conn->login_task->data = conn->data = data; 3115d36ab6f3SMike Christie 31167dae459fSWenchao Hao err = iscsi_add_conn(cls_conn); 31177dae459fSWenchao Hao if (err) 31187dae459fSWenchao Hao goto login_task_add_dev_fail; 31197dae459fSWenchao Hao 31207996a778SMike Christie return cls_conn; 31217996a778SMike Christie 31227dae459fSWenchao Hao login_task_add_dev_fail: 31237dae459fSWenchao Hao free_pages((unsigned long) conn->data, 31247dae459fSWenchao Hao get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 31257dae459fSWenchao Hao 31269c19a7d0SMike Christie login_task_data_alloc_fail: 31277acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 3128d36ab6f3SMike Christie sizeof(void*)); 31299c19a7d0SMike Christie login_task_alloc_fail: 31307dae459fSWenchao Hao iscsi_put_conn(cls_conn); 31317996a778SMike Christie return NULL; 31327996a778SMike Christie } 31337996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_setup); 31347996a778SMike Christie 31357996a778SMike Christie /** 31367996a778SMike Christie * iscsi_conn_teardown - teardown iscsi connection 3137ccd4a430SRandy Dunlap * @cls_conn: iscsi class connection 31387996a778SMike Christie * 31397996a778SMike Christie * TODO: we may need to make this into a two step process 31407996a778SMike Christie * like scsi-mls remove + put host 31417996a778SMike Christie */ 31427996a778SMike Christie void iscsi_conn_teardown(struct iscsi_cls_conn *cls_conn) 31437996a778SMike Christie { 31447996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 31457996a778SMike Christie struct iscsi_session *session = conn->session; 31468709c323SWenchao Hao 31478709c323SWenchao Hao iscsi_remove_conn(cls_conn); 31487996a778SMike Christie 3149f6d5180cSMike Christie del_timer_sync(&conn->transport_timer); 3150f6d5180cSMike Christie 3151660d0831SJohn Soni Jose mutex_lock(&session->eh_mutex); 3152659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 31537996a778SMike Christie conn->c_stage = ISCSI_CONN_CLEANUP_WAIT; 31547996a778SMike Christie if (session->leadconn == conn) { 31557996a778SMike Christie /* 31567996a778SMike Christie * leading connection? then give up on recovery. 31577996a778SMike Christie */ 31587996a778SMike Christie session->state = ISCSI_STATE_TERMINATE; 3159ec29d0acSMike Christie wake_up(&session->ehwait); 31607996a778SMike Christie } 3161659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 31627996a778SMike Christie 3163779ea120SMike Christie /* flush queued up work because we free the connection below */ 3164843c0a8aSMike Christie iscsi_suspend_tx(conn); 3165779ea120SMike Christie 3166659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 3167cfeb2cf9SMike Christie free_pages((unsigned long) conn->data, 3168cfeb2cf9SMike Christie get_order(ISCSI_DEF_MAX_RECV_SEG_LEN)); 31698709c323SWenchao Hao kfree(conn->persistent_address); 31708709c323SWenchao Hao kfree(conn->local_ipaddr); 3171659743b0SShlomo Pongratz /* regular RX path uses back_lock */ 3172659743b0SShlomo Pongratz spin_lock_bh(&session->back_lock); 31737acd72ebSStefani Seibold kfifo_in(&session->cmdpool.queue, (void*)&conn->login_task, 31747996a778SMike Christie sizeof(void*)); 3175659743b0SShlomo Pongratz spin_unlock_bh(&session->back_lock); 3176e0726407SMike Christie if (session->leadconn == conn) 31777996a778SMike Christie session->leadconn = NULL; 3178659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 3179660d0831SJohn Soni Jose mutex_unlock(&session->eh_mutex); 31807996a778SMike Christie 31818709c323SWenchao Hao iscsi_put_conn(cls_conn); 31827996a778SMike Christie } 31837996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_teardown); 31847996a778SMike Christie 31857996a778SMike Christie int iscsi_conn_start(struct iscsi_cls_conn *cls_conn) 31867996a778SMike Christie { 31877996a778SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 31887996a778SMike Christie struct iscsi_session *session = conn->session; 31897996a778SMike Christie 3190ffd0436eSMike Christie if (!session) { 3191322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, 3192322d739dSMike Christie "can't start unbound connection\n"); 31937996a778SMike Christie return -EPERM; 31947996a778SMike Christie } 31957996a778SMike Christie 3196db98ccdeSMike Christie if ((session->imm_data_en || !session->initial_r2t_en) && 3197db98ccdeSMike Christie session->first_burst > session->max_burst) { 3198322d739dSMike Christie iscsi_conn_printk(KERN_INFO, conn, "invalid burst lengths: " 3199ffd0436eSMike Christie "first_burst %d max_burst %d\n", 3200ffd0436eSMike Christie session->first_burst, session->max_burst); 3201ffd0436eSMike Christie return -EINVAL; 3202ffd0436eSMike Christie } 3203ffd0436eSMike Christie 3204f6d5180cSMike Christie if (conn->ping_timeout && !conn->recv_timeout) { 3205322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid recv timeout of " 3206322d739dSMike Christie "zero. Using 5 seconds\n."); 3207f6d5180cSMike Christie conn->recv_timeout = 5; 3208f6d5180cSMike Christie } 3209f6d5180cSMike Christie 3210f6d5180cSMike Christie if (conn->recv_timeout && !conn->ping_timeout) { 3211322d739dSMike Christie iscsi_conn_printk(KERN_ERR, conn, "invalid ping timeout of " 3212322d739dSMike Christie "zero. Using 5 seconds.\n"); 3213f6d5180cSMike Christie conn->ping_timeout = 5; 3214f6d5180cSMike Christie } 3215f6d5180cSMike Christie 3216659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 32177996a778SMike Christie conn->c_stage = ISCSI_CONN_STARTED; 32187996a778SMike Christie session->state = ISCSI_STATE_LOGGED_IN; 3219e0726407SMike Christie session->queued_cmdsn = session->cmdsn; 32207996a778SMike Christie 3221f6d5180cSMike Christie conn->last_recv = jiffies; 3222f6d5180cSMike Christie conn->last_ping = jiffies; 3223f6d5180cSMike Christie if (conn->recv_timeout && conn->ping_timeout) 3224f6d5180cSMike Christie mod_timer(&conn->transport_timer, 3225f6d5180cSMike Christie jiffies + (conn->recv_timeout * HZ)); 3226f6d5180cSMike Christie 32277996a778SMike Christie switch(conn->stop_stage) { 32287996a778SMike Christie case STOP_CONN_RECOVER: 32297996a778SMike Christie /* 32307996a778SMike Christie * unblock eh_abort() if it is blocked. re-try all 32317996a778SMike Christie * commands after successful recovery 32327996a778SMike Christie */ 32337996a778SMike Christie conn->stop_stage = 0; 3234ec29d0acSMike Christie session->tmf_state = TMF_INITIAL; 32357996a778SMike Christie session->age++; 32368b1d0343SMike Christie if (session->age == 16) 32378b1d0343SMike Christie session->age = 0; 32386eabafbeSMike Christie break; 32397996a778SMike Christie case STOP_CONN_TERM: 32407996a778SMike Christie conn->stop_stage = 0; 32417996a778SMike Christie break; 32427996a778SMike Christie default: 32437996a778SMike Christie break; 32447996a778SMike Christie } 3245659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 32467996a778SMike Christie 324775613521SMike Christie iscsi_unblock_session(session->cls_session); 3248ec29d0acSMike Christie wake_up(&session->ehwait); 32497996a778SMike Christie return 0; 32507996a778SMike Christie } 32517996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_start); 32527996a778SMike Christie 32537996a778SMike Christie static void 32543bbaaad9SMike Christie fail_mgmt_tasks(struct iscsi_session *session, struct iscsi_conn *conn) 32557996a778SMike Christie { 32563bbaaad9SMike Christie struct iscsi_task *task; 3257b3cd5050SMike Christie int i, state; 32587996a778SMike Christie 32593bbaaad9SMike Christie for (i = 0; i < conn->session->cmds_max; i++) { 32603bbaaad9SMike Christie task = conn->session->cmds[i]; 32613bbaaad9SMike Christie if (task->sc) 32623bbaaad9SMike Christie continue; 32633bbaaad9SMike Christie 32643bbaaad9SMike Christie if (task->state == ISCSI_TASK_FREE) 32653bbaaad9SMike Christie continue; 32663bbaaad9SMike Christie 32673bbaaad9SMike Christie ISCSI_DBG_SESSION(conn->session, 32683bbaaad9SMike Christie "failing mgmt itt 0x%x state %d\n", 32693bbaaad9SMike Christie task->itt, task->state); 32705923d64bSMike Christie 32715923d64bSMike Christie spin_lock_bh(&session->back_lock); 32725923d64bSMike Christie if (cleanup_queued_task(task)) { 32735923d64bSMike Christie spin_unlock_bh(&session->back_lock); 32745923d64bSMike Christie continue; 32755923d64bSMike Christie } 32765923d64bSMike Christie 3277b3cd5050SMike Christie state = ISCSI_TASK_ABRT_SESS_RECOV; 3278b3cd5050SMike Christie if (task->state == ISCSI_TASK_PENDING) 3279b3cd5050SMike Christie state = ISCSI_TASK_COMPLETED; 3280b3cd5050SMike Christie iscsi_complete_task(task, state); 3281a656183eSLee Duncan spin_unlock_bh(&session->back_lock); 32827996a778SMike Christie } 32837996a778SMike Christie } 32847996a778SMike Christie 32850dcf8febSMike Christie void iscsi_conn_stop(struct iscsi_cls_conn *cls_conn, int flag) 32867996a778SMike Christie { 32870dcf8febSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 32880dcf8febSMike Christie struct iscsi_session *session = conn->session; 3289ed2abc7fSMike Christie int old_stop_stage; 3290ed2abc7fSMike Christie 32916724add1SMike Christie mutex_lock(&session->eh_mutex); 3292659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 3293ed2abc7fSMike Christie if (conn->stop_stage == STOP_CONN_TERM) { 3294659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 32956724add1SMike Christie mutex_unlock(&session->eh_mutex); 32966724add1SMike Christie return; 32976724add1SMike Christie } 32986724add1SMike Christie 32996724add1SMike Christie /* 3300ed2abc7fSMike Christie * When this is called for the in_login state, we only want to clean 33019c19a7d0SMike Christie * up the login task and connection. We do not need to block and set 330267a61114SMike Christie * the recovery state again 3303ed2abc7fSMike Christie */ 330467a61114SMike Christie if (flag == STOP_CONN_TERM) 330567a61114SMike Christie session->state = ISCSI_STATE_TERMINATE; 330667a61114SMike Christie else if (conn->stop_stage != STOP_CONN_RECOVER) 330767a61114SMike Christie session->state = ISCSI_STATE_IN_RECOVERY; 33084ae0a6c1SMike Christie 33094ae0a6c1SMike Christie old_stop_stage = conn->stop_stage; 33104ae0a6c1SMike Christie conn->stop_stage = flag; 3311659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 3312ed2abc7fSMike Christie 331326013ad4SMike Christie del_timer_sync(&conn->transport_timer); 331426013ad4SMike Christie iscsi_suspend_tx(conn); 331526013ad4SMike Christie 3316659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 331767a61114SMike Christie conn->c_stage = ISCSI_CONN_STOPPED; 3318659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 33196724add1SMike Christie 33207996a778SMike Christie /* 33217996a778SMike Christie * for connection level recovery we should not calculate 33227996a778SMike Christie * header digest. conn->hdr_size used for optimization 33237996a778SMike Christie * in hdr_extract() and will be re-negotiated at 33247996a778SMike Christie * set_param() time. 33257996a778SMike Christie */ 33267996a778SMike Christie if (flag == STOP_CONN_RECOVER) { 33277996a778SMike Christie conn->hdrdgst_en = 0; 33287996a778SMike Christie conn->datadgst_en = 0; 3329656cffc9SMike Christie if (session->state == ISCSI_STATE_IN_RECOVERY && 333067a61114SMike Christie old_stop_stage != STOP_CONN_RECOVER) { 33311b2c7af8SMike Christie ISCSI_DBG_SESSION(session, "blocking session\n"); 333275613521SMike Christie iscsi_block_session(session->cls_session); 33337996a778SMike Christie } 333467a61114SMike Christie } 3335656cffc9SMike Christie 3336656cffc9SMike Christie /* 3337656cffc9SMike Christie * flush queues. 3338656cffc9SMike Christie */ 3339659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 33403bbaaad9SMike Christie fail_scsi_tasks(conn, -1, DID_TRANSPORT_DISRUPTED); 33413bbaaad9SMike Christie fail_mgmt_tasks(session, conn); 3342ec29d0acSMike Christie memset(&session->tmhdr, 0, sizeof(session->tmhdr)); 3343659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 33446724add1SMike Christie mutex_unlock(&session->eh_mutex); 33457996a778SMike Christie } 33467996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_stop); 33477996a778SMike Christie 33487996a778SMike Christie int iscsi_conn_bind(struct iscsi_cls_session *cls_session, 33497996a778SMike Christie struct iscsi_cls_conn *cls_conn, int is_leading) 33507996a778SMike Christie { 335175613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 335298644047SMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 33537996a778SMike Christie 3354659743b0SShlomo Pongratz spin_lock_bh(&session->frwd_lock); 33557996a778SMike Christie if (is_leading) 33567996a778SMike Christie session->leadconn = conn; 335744ac9710SMike Christie 335844ac9710SMike Christie set_bit(ISCSI_CONN_FLAG_BOUND, &conn->flags); 3359659743b0SShlomo Pongratz spin_unlock_bh(&session->frwd_lock); 33607996a778SMike Christie 33617996a778SMike Christie /* 3362c8447e4cSMike Christie * The target could have reduced it's window size between logins, so 3363c8447e4cSMike Christie * we have to reset max/exp cmdsn so we can see the new values. 3364c8447e4cSMike Christie */ 3365c8447e4cSMike Christie spin_lock_bh(&session->back_lock); 3366c8447e4cSMike Christie session->max_cmdsn = session->exp_cmdsn = session->cmdsn + 1; 3367c8447e4cSMike Christie spin_unlock_bh(&session->back_lock); 3368c8447e4cSMike Christie /* 33697996a778SMike Christie * Unblock xmitworker(), Login Phase will pass through. 33707996a778SMike Christie */ 33715bd85625SMike Christie clear_bit(ISCSI_CONN_FLAG_SUSPEND_RX, &conn->flags); 33725bd85625SMike Christie clear_bit(ISCSI_CONN_FLAG_SUSPEND_TX, &conn->flags); 33737996a778SMike Christie return 0; 33747996a778SMike Christie } 33757996a778SMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_bind); 33767996a778SMike Christie 3377adaf6990SAdheer Chandravanshi int iscsi_switch_str_param(char **param, char *new_val_buf) 33785700b1afSMike Christie { 33795700b1afSMike Christie char *new_val; 33805700b1afSMike Christie 33815700b1afSMike Christie if (*param) { 33825700b1afSMike Christie if (!strcmp(*param, new_val_buf)) 33835700b1afSMike Christie return 0; 33845700b1afSMike Christie } 33855700b1afSMike Christie 33865700b1afSMike Christie new_val = kstrdup(new_val_buf, GFP_NOIO); 33875700b1afSMike Christie if (!new_val) 33885700b1afSMike Christie return -ENOMEM; 33895700b1afSMike Christie 33905700b1afSMike Christie kfree(*param); 33915700b1afSMike Christie *param = new_val; 33925700b1afSMike Christie return 0; 33935700b1afSMike Christie } 3394adaf6990SAdheer Chandravanshi EXPORT_SYMBOL_GPL(iscsi_switch_str_param); 3395a54a52caSMike Christie 3396a54a52caSMike Christie int iscsi_set_param(struct iscsi_cls_conn *cls_conn, 3397a54a52caSMike Christie enum iscsi_param param, char *buf, int buflen) 3398a54a52caSMike Christie { 3399a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 3400a54a52caSMike Christie struct iscsi_session *session = conn->session; 34016a06a4b8SOr Gerlitz int val; 3402a54a52caSMike Christie 3403a54a52caSMike Christie switch(param) { 3404843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 3405843c0a8aSMike Christie sscanf(buf, "%d", &session->fast_abort); 3406843c0a8aSMike Christie break; 3407f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 3408f6d5180cSMike Christie sscanf(buf, "%d", &session->abort_timeout); 3409f6d5180cSMike Christie break; 3410f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 3411f6d5180cSMike Christie sscanf(buf, "%d", &session->lu_reset_timeout); 3412f6d5180cSMike Christie break; 34133fe5ae8bSMike Christie case ISCSI_PARAM_TGT_RESET_TMO: 34143fe5ae8bSMike Christie sscanf(buf, "%d", &session->tgt_reset_timeout); 34153fe5ae8bSMike Christie break; 3416f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 3417f6d5180cSMike Christie sscanf(buf, "%d", &conn->ping_timeout); 3418f6d5180cSMike Christie break; 3419f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 3420f6d5180cSMike Christie sscanf(buf, "%d", &conn->recv_timeout); 3421f6d5180cSMike Christie break; 3422a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 3423a54a52caSMike Christie sscanf(buf, "%d", &conn->max_recv_dlength); 3424a54a52caSMike Christie break; 3425a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3426a54a52caSMike Christie sscanf(buf, "%d", &conn->max_xmit_dlength); 3427a54a52caSMike Christie break; 3428a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 3429a54a52caSMike Christie sscanf(buf, "%d", &conn->hdrdgst_en); 3430a54a52caSMike Christie break; 3431a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 3432a54a52caSMike Christie sscanf(buf, "%d", &conn->datadgst_en); 3433a54a52caSMike Christie break; 3434a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 3435a54a52caSMike Christie sscanf(buf, "%d", &session->initial_r2t_en); 3436a54a52caSMike Christie break; 3437a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 34381304be5fSMike Christie sscanf(buf, "%hu", &session->max_r2t); 3439a54a52caSMike Christie break; 3440a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 3441a54a52caSMike Christie sscanf(buf, "%d", &session->imm_data_en); 3442a54a52caSMike Christie break; 3443a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 3444a54a52caSMike Christie sscanf(buf, "%d", &session->first_burst); 3445a54a52caSMike Christie break; 3446a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 3447a54a52caSMike Christie sscanf(buf, "%d", &session->max_burst); 3448a54a52caSMike Christie break; 3449a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 3450a54a52caSMike Christie sscanf(buf, "%d", &session->pdu_inorder_en); 3451a54a52caSMike Christie break; 3452a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 3453a54a52caSMike Christie sscanf(buf, "%d", &session->dataseq_inorder_en); 3454a54a52caSMike Christie break; 3455a54a52caSMike Christie case ISCSI_PARAM_ERL: 3456a54a52caSMike Christie sscanf(buf, "%d", &session->erl); 3457a54a52caSMike Christie break; 3458a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 3459a54a52caSMike Christie sscanf(buf, "%u", &conn->exp_statsn); 3460a54a52caSMike Christie break; 3461b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 34625700b1afSMike Christie return iscsi_switch_str_param(&session->username, buf); 3463b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 34645700b1afSMike Christie return iscsi_switch_str_param(&session->username_in, buf); 3465b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 34665700b1afSMike Christie return iscsi_switch_str_param(&session->password, buf); 3467b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 34685700b1afSMike Christie return iscsi_switch_str_param(&session->password_in, buf); 3469a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 34705700b1afSMike Christie return iscsi_switch_str_param(&session->targetname, buf); 34713c5c4801SVikas Chaudhary case ISCSI_PARAM_TARGET_ALIAS: 34723c5c4801SVikas Chaudhary return iscsi_switch_str_param(&session->targetalias, buf); 3473a54a52caSMike Christie case ISCSI_PARAM_TPGT: 3474a54a52caSMike Christie sscanf(buf, "%d", &session->tpgt); 3475a54a52caSMike Christie break; 3476a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3477a54a52caSMike Christie sscanf(buf, "%d", &conn->persistent_port); 3478a54a52caSMike Christie break; 3479a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 34805700b1afSMike Christie return iscsi_switch_str_param(&conn->persistent_address, buf); 348188dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 34825700b1afSMike Christie return iscsi_switch_str_param(&session->ifacename, buf); 348388dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 34845700b1afSMike Christie return iscsi_switch_str_param(&session->initiatorname, buf); 34853b9373e9SEddie Wai case ISCSI_PARAM_BOOT_ROOT: 34863b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_root, buf); 34873b9373e9SEddie Wai case ISCSI_PARAM_BOOT_NIC: 34883b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_nic, buf); 34893b9373e9SEddie Wai case ISCSI_PARAM_BOOT_TARGET: 34903b9373e9SEddie Wai return iscsi_switch_str_param(&session->boot_target, buf); 3491f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_PORTAL_TYPE: 3492f8525eb4SAdheer Chandravanshi return iscsi_switch_str_param(&session->portal_type, buf); 3493f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_TYPE: 3494f8525eb4SAdheer Chandravanshi return iscsi_switch_str_param(&session->discovery_parent_type, 3495f8525eb4SAdheer Chandravanshi buf); 34966a06a4b8SOr Gerlitz case ISCSI_PARAM_DISCOVERY_SESS: 34976a06a4b8SOr Gerlitz sscanf(buf, "%d", &val); 34986a06a4b8SOr Gerlitz session->discovery_sess = !!val; 34996a06a4b8SOr Gerlitz break; 3500ae56ff40SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_IPADDR: 3501ae56ff40SAdheer Chandravanshi return iscsi_switch_str_param(&conn->local_ipaddr, buf); 3502a54a52caSMike Christie default: 3503a54a52caSMike Christie return -ENOSYS; 3504a54a52caSMike Christie } 3505a54a52caSMike Christie 3506a54a52caSMike Christie return 0; 3507a54a52caSMike Christie } 3508a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_set_param); 3509a54a52caSMike Christie 3510a54a52caSMike Christie int iscsi_session_get_param(struct iscsi_cls_session *cls_session, 3511a54a52caSMike Christie enum iscsi_param param, char *buf) 3512a54a52caSMike Christie { 351375613521SMike Christie struct iscsi_session *session = cls_session->dd_data; 3514a54a52caSMike Christie int len; 3515a54a52caSMike Christie 3516a54a52caSMike Christie switch(param) { 3517843c0a8aSMike Christie case ISCSI_PARAM_FAST_ABORT: 3518ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->fast_abort); 3519843c0a8aSMike Christie break; 3520f6d5180cSMike Christie case ISCSI_PARAM_ABORT_TMO: 3521ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->abort_timeout); 3522f6d5180cSMike Christie break; 3523f6d5180cSMike Christie case ISCSI_PARAM_LU_RESET_TMO: 3524ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->lu_reset_timeout); 3525f6d5180cSMike Christie break; 35263fe5ae8bSMike Christie case ISCSI_PARAM_TGT_RESET_TMO: 3527ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->tgt_reset_timeout); 35283fe5ae8bSMike Christie break; 3529a54a52caSMike Christie case ISCSI_PARAM_INITIAL_R2T_EN: 3530ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->initial_r2t_en); 3531a54a52caSMike Christie break; 3532a54a52caSMike Christie case ISCSI_PARAM_MAX_R2T: 3533ec98ea70SChris Leech len = sysfs_emit(buf, "%hu\n", session->max_r2t); 3534a54a52caSMike Christie break; 3535a54a52caSMike Christie case ISCSI_PARAM_IMM_DATA_EN: 3536ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->imm_data_en); 3537a54a52caSMike Christie break; 3538a54a52caSMike Christie case ISCSI_PARAM_FIRST_BURST: 3539ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->first_burst); 3540a54a52caSMike Christie break; 3541a54a52caSMike Christie case ISCSI_PARAM_MAX_BURST: 3542ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->max_burst); 3543a54a52caSMike Christie break; 3544a54a52caSMike Christie case ISCSI_PARAM_PDU_INORDER_EN: 3545ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->pdu_inorder_en); 3546a54a52caSMike Christie break; 3547a54a52caSMike Christie case ISCSI_PARAM_DATASEQ_INORDER_EN: 3548ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->dataseq_inorder_en); 3549a54a52caSMike Christie break; 35505f09e1f3SAdheer Chandravanshi case ISCSI_PARAM_DEF_TASKMGMT_TMO: 3551ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->def_taskmgmt_tmo); 35525f09e1f3SAdheer Chandravanshi break; 3553a54a52caSMike Christie case ISCSI_PARAM_ERL: 3554ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->erl); 3555a54a52caSMike Christie break; 3556a54a52caSMike Christie case ISCSI_PARAM_TARGET_NAME: 3557ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->targetname); 3558a54a52caSMike Christie break; 35593c5c4801SVikas Chaudhary case ISCSI_PARAM_TARGET_ALIAS: 3560ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->targetalias); 35613c5c4801SVikas Chaudhary break; 3562a54a52caSMike Christie case ISCSI_PARAM_TPGT: 3563ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->tpgt); 3564a54a52caSMike Christie break; 3565b2c64167SMike Christie case ISCSI_PARAM_USERNAME: 3566ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->username); 3567b2c64167SMike Christie break; 3568b2c64167SMike Christie case ISCSI_PARAM_USERNAME_IN: 3569ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->username_in); 3570b2c64167SMike Christie break; 3571b2c64167SMike Christie case ISCSI_PARAM_PASSWORD: 3572ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->password); 3573b2c64167SMike Christie break; 3574b2c64167SMike Christie case ISCSI_PARAM_PASSWORD_IN: 3575ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->password_in); 3576b2c64167SMike Christie break; 357788dfd340SMike Christie case ISCSI_PARAM_IFACE_NAME: 3578ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->ifacename); 357988dfd340SMike Christie break; 358088dfd340SMike Christie case ISCSI_PARAM_INITIATOR_NAME: 3581ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->initiatorname); 358288dfd340SMike Christie break; 35833b9373e9SEddie Wai case ISCSI_PARAM_BOOT_ROOT: 3584ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->boot_root); 35853b9373e9SEddie Wai break; 35863b9373e9SEddie Wai case ISCSI_PARAM_BOOT_NIC: 3587ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->boot_nic); 35883b9373e9SEddie Wai break; 35893b9373e9SEddie Wai case ISCSI_PARAM_BOOT_TARGET: 3590ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->boot_target); 35919a2307b1SAdheer Chandravanshi break; 3592f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_AUTO_SND_TGT_DISABLE: 3593ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->auto_snd_tgt_disable); 3594f8525eb4SAdheer Chandravanshi break; 3595f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_SESS: 3596ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->discovery_sess); 3597f8525eb4SAdheer Chandravanshi break; 3598f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_PORTAL_TYPE: 3599ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", session->portal_type); 3600f8525eb4SAdheer Chandravanshi break; 3601f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_CHAP_AUTH_EN: 3602ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->chap_auth_en); 3603f8525eb4SAdheer Chandravanshi break; 3604f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_LOGOUT_EN: 3605ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->discovery_logout_en); 3606f8525eb4SAdheer Chandravanshi break; 3607f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_BIDI_CHAP_EN: 3608ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->bidi_chap_en); 3609f8525eb4SAdheer Chandravanshi break; 3610f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_AUTH_OPTIONAL: 3611ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->discovery_auth_optional); 3612f8525eb4SAdheer Chandravanshi break; 3613f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DEF_TIME2WAIT: 3614ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->time2wait); 3615f8525eb4SAdheer Chandravanshi break; 3616f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DEF_TIME2RETAIN: 3617ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", session->time2retain); 3618f8525eb4SAdheer Chandravanshi break; 3619f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TSID: 3620ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->tsid); 3621f8525eb4SAdheer Chandravanshi break; 3622f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_ISID: 3623ec98ea70SChris Leech len = sysfs_emit(buf, "%02x%02x%02x%02x%02x%02x\n", 3624f8525eb4SAdheer Chandravanshi session->isid[0], session->isid[1], 3625f8525eb4SAdheer Chandravanshi session->isid[2], session->isid[3], 3626f8525eb4SAdheer Chandravanshi session->isid[4], session->isid[5]); 3627f8525eb4SAdheer Chandravanshi break; 3628f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_IDX: 3629ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", session->discovery_parent_idx); 3630f8525eb4SAdheer Chandravanshi break; 3631f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_DISCOVERY_PARENT_TYPE: 3632f8525eb4SAdheer Chandravanshi if (session->discovery_parent_type) 3633ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", 3634f8525eb4SAdheer Chandravanshi session->discovery_parent_type); 3635f8525eb4SAdheer Chandravanshi else 3636ec98ea70SChris Leech len = sysfs_emit(buf, "\n"); 36373b9373e9SEddie Wai break; 3638a54a52caSMike Christie default: 3639a54a52caSMike Christie return -ENOSYS; 3640a54a52caSMike Christie } 3641a54a52caSMike Christie 3642a54a52caSMike Christie return len; 3643a54a52caSMike Christie } 3644a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_session_get_param); 3645a54a52caSMike Christie 364600f3708eSMike Christie int iscsi_conn_get_addr_param(struct sockaddr_storage *addr, 364700f3708eSMike Christie enum iscsi_param param, char *buf) 364800f3708eSMike Christie { 364900f3708eSMike Christie struct sockaddr_in6 *sin6 = NULL; 365000f3708eSMike Christie struct sockaddr_in *sin = NULL; 365100f3708eSMike Christie int len; 365200f3708eSMike Christie 365300f3708eSMike Christie switch (addr->ss_family) { 365400f3708eSMike Christie case AF_INET: 365500f3708eSMike Christie sin = (struct sockaddr_in *)addr; 365600f3708eSMike Christie break; 365700f3708eSMike Christie case AF_INET6: 365800f3708eSMike Christie sin6 = (struct sockaddr_in6 *)addr; 365900f3708eSMike Christie break; 366000f3708eSMike Christie default: 366100f3708eSMike Christie return -EINVAL; 366200f3708eSMike Christie } 366300f3708eSMike Christie 366400f3708eSMike Christie switch (param) { 366500f3708eSMike Christie case ISCSI_PARAM_CONN_ADDRESS: 366600f3708eSMike Christie case ISCSI_HOST_PARAM_IPADDRESS: 366700f3708eSMike Christie if (sin) 3668ec98ea70SChris Leech len = sysfs_emit(buf, "%pI4\n", &sin->sin_addr.s_addr); 366900f3708eSMike Christie else 3670ec98ea70SChris Leech len = sysfs_emit(buf, "%pI6\n", &sin6->sin6_addr); 367100f3708eSMike Christie break; 367200f3708eSMike Christie case ISCSI_PARAM_CONN_PORT: 36734bfb8ebfSMike Christie case ISCSI_PARAM_LOCAL_PORT: 367400f3708eSMike Christie if (sin) 3675ec98ea70SChris Leech len = sysfs_emit(buf, "%hu\n", be16_to_cpu(sin->sin_port)); 367600f3708eSMike Christie else 3677ec98ea70SChris Leech len = sysfs_emit(buf, "%hu\n", 367800f3708eSMike Christie be16_to_cpu(sin6->sin6_port)); 367900f3708eSMike Christie break; 368000f3708eSMike Christie default: 368100f3708eSMike Christie return -EINVAL; 368200f3708eSMike Christie } 368300f3708eSMike Christie 368400f3708eSMike Christie return len; 368500f3708eSMike Christie } 368600f3708eSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_addr_param); 368700f3708eSMike Christie 3688a54a52caSMike Christie int iscsi_conn_get_param(struct iscsi_cls_conn *cls_conn, 3689a54a52caSMike Christie enum iscsi_param param, char *buf) 3690a54a52caSMike Christie { 3691a54a52caSMike Christie struct iscsi_conn *conn = cls_conn->dd_data; 3692a54a52caSMike Christie int len; 3693a54a52caSMike Christie 3694a54a52caSMike Christie switch(param) { 3695f6d5180cSMike Christie case ISCSI_PARAM_PING_TMO: 3696ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->ping_timeout); 3697f6d5180cSMike Christie break; 3698f6d5180cSMike Christie case ISCSI_PARAM_RECV_TMO: 3699ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->recv_timeout); 3700f6d5180cSMike Christie break; 3701a54a52caSMike Christie case ISCSI_PARAM_MAX_RECV_DLENGTH: 3702ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->max_recv_dlength); 3703a54a52caSMike Christie break; 3704a54a52caSMike Christie case ISCSI_PARAM_MAX_XMIT_DLENGTH: 3705ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->max_xmit_dlength); 3706a54a52caSMike Christie break; 3707a54a52caSMike Christie case ISCSI_PARAM_HDRDGST_EN: 3708ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->hdrdgst_en); 3709a54a52caSMike Christie break; 3710a54a52caSMike Christie case ISCSI_PARAM_DATADGST_EN: 3711ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->datadgst_en); 3712a54a52caSMike Christie break; 3713a54a52caSMike Christie case ISCSI_PARAM_IFMARKER_EN: 3714ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->ifmarker_en); 3715a54a52caSMike Christie break; 3716a54a52caSMike Christie case ISCSI_PARAM_OFMARKER_EN: 3717ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->ofmarker_en); 3718a54a52caSMike Christie break; 3719a54a52caSMike Christie case ISCSI_PARAM_EXP_STATSN: 3720ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->exp_statsn); 3721a54a52caSMike Christie break; 3722a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_PORT: 3723ec98ea70SChris Leech len = sysfs_emit(buf, "%d\n", conn->persistent_port); 3724a54a52caSMike Christie break; 3725a54a52caSMike Christie case ISCSI_PARAM_PERSISTENT_ADDRESS: 3726ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", conn->persistent_address); 3727a54a52caSMike Christie break; 3728f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_STATSN: 3729ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->statsn); 3730f8525eb4SAdheer Chandravanshi break; 3731f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_MAX_SEGMENT_SIZE: 3732ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->max_segment_size); 3733f8525eb4SAdheer Chandravanshi break; 3734f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_KEEPALIVE_TMO: 3735ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->keepalive_tmo); 3736f8525eb4SAdheer Chandravanshi break; 3737f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_PORT: 3738ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->local_port); 3739f8525eb4SAdheer Chandravanshi break; 3740f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMESTAMP_STAT: 3741ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_timestamp_stat); 3742f8525eb4SAdheer Chandravanshi break; 3743f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_NAGLE_DISABLE: 3744ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_nagle_disable); 3745f8525eb4SAdheer Chandravanshi break; 3746f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_WSF_DISABLE: 3747ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_wsf_disable); 3748f8525eb4SAdheer Chandravanshi break; 3749f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMER_SCALE: 3750ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_timer_scale); 3751f8525eb4SAdheer Chandravanshi break; 3752f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_TIMESTAMP_EN: 3753ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_timestamp_en); 3754f8525eb4SAdheer Chandravanshi break; 3755f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IP_FRAGMENT_DISABLE: 3756ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->fragment_disable); 3757f8525eb4SAdheer Chandravanshi break; 3758f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IPV4_TOS: 3759ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->ipv4_tos); 3760f8525eb4SAdheer Chandravanshi break; 3761f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IPV6_TC: 3762ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->ipv6_traffic_class); 3763f8525eb4SAdheer Chandravanshi break; 37645f09e1f3SAdheer Chandravanshi case ISCSI_PARAM_IPV6_FLOW_LABEL: 3765ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->ipv6_flow_label); 37665f09e1f3SAdheer Chandravanshi break; 3767f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_IS_FW_ASSIGNED_IPV6: 3768ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->is_fw_assigned_ipv6); 3769f8525eb4SAdheer Chandravanshi break; 3770f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_XMIT_WSF: 3771ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_xmit_wsf); 3772f8525eb4SAdheer Chandravanshi break; 3773f8525eb4SAdheer Chandravanshi case ISCSI_PARAM_TCP_RECV_WSF: 3774ec98ea70SChris Leech len = sysfs_emit(buf, "%u\n", conn->tcp_recv_wsf); 3775f8525eb4SAdheer Chandravanshi break; 3776ae56ff40SAdheer Chandravanshi case ISCSI_PARAM_LOCAL_IPADDR: 3777ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", conn->local_ipaddr); 3778ae56ff40SAdheer Chandravanshi break; 3779a54a52caSMike Christie default: 3780a54a52caSMike Christie return -ENOSYS; 3781a54a52caSMike Christie } 3782a54a52caSMike Christie 3783a54a52caSMike Christie return len; 3784a54a52caSMike Christie } 3785a54a52caSMike Christie EXPORT_SYMBOL_GPL(iscsi_conn_get_param); 3786a54a52caSMike Christie 37870801c242SMike Christie int iscsi_host_get_param(struct Scsi_Host *shost, enum iscsi_host_param param, 37880801c242SMike Christie char *buf) 37890801c242SMike Christie { 379075613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 37910801c242SMike Christie int len; 37920801c242SMike Christie 37930801c242SMike Christie switch (param) { 3794d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 3795ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", ihost->netdev); 3796d8196ed2SMike Christie break; 37970801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 3798ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", ihost->hwaddress); 37990801c242SMike Christie break; 38008ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 3801ec98ea70SChris Leech len = sysfs_emit(buf, "%s\n", ihost->initiatorname); 38028ad5781aSMike Christie break; 38030801c242SMike Christie default: 38040801c242SMike Christie return -ENOSYS; 38050801c242SMike Christie } 38060801c242SMike Christie 38070801c242SMike Christie return len; 38080801c242SMike Christie } 38090801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_get_param); 38100801c242SMike Christie 38110801c242SMike Christie int iscsi_host_set_param(struct Scsi_Host *shost, enum iscsi_host_param param, 38120801c242SMike Christie char *buf, int buflen) 38130801c242SMike Christie { 381475613521SMike Christie struct iscsi_host *ihost = shost_priv(shost); 38150801c242SMike Christie 38160801c242SMike Christie switch (param) { 3817d8196ed2SMike Christie case ISCSI_HOST_PARAM_NETDEV_NAME: 38185700b1afSMike Christie return iscsi_switch_str_param(&ihost->netdev, buf); 38190801c242SMike Christie case ISCSI_HOST_PARAM_HWADDRESS: 38205700b1afSMike Christie return iscsi_switch_str_param(&ihost->hwaddress, buf); 38218ad5781aSMike Christie case ISCSI_HOST_PARAM_INITIATOR_NAME: 38225700b1afSMike Christie return iscsi_switch_str_param(&ihost->initiatorname, buf); 38230801c242SMike Christie default: 38240801c242SMike Christie return -ENOSYS; 38250801c242SMike Christie } 38260801c242SMike Christie 38270801c242SMike Christie return 0; 38280801c242SMike Christie } 38290801c242SMike Christie EXPORT_SYMBOL_GPL(iscsi_host_set_param); 38300801c242SMike Christie 38317996a778SMike Christie MODULE_AUTHOR("Mike Christie"); 38327996a778SMike Christie MODULE_DESCRIPTION("iSCSI library functions"); 38337996a778SMike Christie MODULE_LICENSE("GPL"); 3834