1a6d42e7dSPeter Dunlap /* 2a6d42e7dSPeter Dunlap * CDDL HEADER START 3a6d42e7dSPeter Dunlap * 4a6d42e7dSPeter Dunlap * The contents of this file are subject to the terms of the 5a6d42e7dSPeter Dunlap * Common Development and Distribution License (the "License"). 6a6d42e7dSPeter Dunlap * You may not use this file except in compliance with the License. 7a6d42e7dSPeter Dunlap * 8a6d42e7dSPeter Dunlap * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9a6d42e7dSPeter Dunlap * or http://www.opensolaris.org/os/licensing. 10a6d42e7dSPeter Dunlap * See the License for the specific language governing permissions 11a6d42e7dSPeter Dunlap * and limitations under the License. 12a6d42e7dSPeter Dunlap * 13a6d42e7dSPeter Dunlap * When distributing Covered Code, include this CDDL HEADER in each 14a6d42e7dSPeter Dunlap * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15a6d42e7dSPeter Dunlap * If applicable, add the following below this CDDL HEADER, with the 16a6d42e7dSPeter Dunlap * fields enclosed by brackets "[]" replaced with your own identifying 17a6d42e7dSPeter Dunlap * information: Portions Copyright [yyyy] [name of copyright owner] 18a6d42e7dSPeter Dunlap * 19a6d42e7dSPeter Dunlap * CDDL HEADER END 20a6d42e7dSPeter Dunlap */ 21a6d42e7dSPeter Dunlap /* 2263528ae4SJames Moore * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23a6d42e7dSPeter Dunlap * Use is subject to license terms. 24a6d42e7dSPeter Dunlap */ 25a6d42e7dSPeter Dunlap 26a6d42e7dSPeter Dunlap #include <sys/cpuvar.h> 27a6d42e7dSPeter Dunlap #include <sys/types.h> 28a6d42e7dSPeter Dunlap #include <sys/conf.h> 29a6d42e7dSPeter Dunlap #include <sys/stat.h> 30a6d42e7dSPeter Dunlap #include <sys/file.h> 31a6d42e7dSPeter Dunlap #include <sys/ddi.h> 32a6d42e7dSPeter Dunlap #include <sys/sunddi.h> 33a6d42e7dSPeter Dunlap #include <sys/modctl.h> 34a6d42e7dSPeter Dunlap #include <sys/sysmacros.h> 35a6d42e7dSPeter Dunlap #include <sys/socket.h> 36a6d42e7dSPeter Dunlap #include <sys/strsubr.h> 37a6d42e7dSPeter Dunlap #include <sys/nvpair.h> 38a6d42e7dSPeter Dunlap 39a6d42e7dSPeter Dunlap #include <sys/stmf.h> 40a6d42e7dSPeter Dunlap #include <sys/stmf_ioctl.h> 41a6d42e7dSPeter Dunlap #include <sys/portif.h> 42a6d42e7dSPeter Dunlap #include <sys/idm/idm.h> 43a6d42e7dSPeter Dunlap #include <sys/idm/idm_conn_sm.h> 44a6d42e7dSPeter Dunlap #include <iscsit_isns.h> 45a6d42e7dSPeter Dunlap #include <iscsit.h> 46a6d42e7dSPeter Dunlap 47a6d42e7dSPeter Dunlap #define ISCSIT_VERSION BUILD_DATE "-1.18dev" 48a6d42e7dSPeter Dunlap #define ISCSIT_NAME_VERSION "COMSTAR ISCSIT v" ISCSIT_VERSION 49a6d42e7dSPeter Dunlap 50a6d42e7dSPeter Dunlap /* 51a6d42e7dSPeter Dunlap * DDI entry points. 52a6d42e7dSPeter Dunlap */ 53a6d42e7dSPeter Dunlap static int iscsit_drv_attach(dev_info_t *, ddi_attach_cmd_t); 54a6d42e7dSPeter Dunlap static int iscsit_drv_detach(dev_info_t *, ddi_detach_cmd_t); 55a6d42e7dSPeter Dunlap static int iscsit_drv_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **); 56a6d42e7dSPeter Dunlap static int iscsit_drv_open(dev_t *, int, int, cred_t *); 57a6d42e7dSPeter Dunlap static int iscsit_drv_close(dev_t, int, int, cred_t *); 58a6d42e7dSPeter Dunlap static boolean_t iscsit_drv_busy(void); 59a6d42e7dSPeter Dunlap static int iscsit_drv_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 60a6d42e7dSPeter Dunlap 61a6d42e7dSPeter Dunlap extern struct mod_ops mod_miscops; 62a6d42e7dSPeter Dunlap 63a6d42e7dSPeter Dunlap 64a6d42e7dSPeter Dunlap static struct cb_ops iscsit_cb_ops = { 65a6d42e7dSPeter Dunlap iscsit_drv_open, /* cb_open */ 66a6d42e7dSPeter Dunlap iscsit_drv_close, /* cb_close */ 67a6d42e7dSPeter Dunlap nodev, /* cb_strategy */ 68a6d42e7dSPeter Dunlap nodev, /* cb_print */ 69a6d42e7dSPeter Dunlap nodev, /* cb_dump */ 70a6d42e7dSPeter Dunlap nodev, /* cb_read */ 71a6d42e7dSPeter Dunlap nodev, /* cb_write */ 72a6d42e7dSPeter Dunlap iscsit_drv_ioctl, /* cb_ioctl */ 73a6d42e7dSPeter Dunlap nodev, /* cb_devmap */ 74a6d42e7dSPeter Dunlap nodev, /* cb_mmap */ 75a6d42e7dSPeter Dunlap nodev, /* cb_segmap */ 76a6d42e7dSPeter Dunlap nochpoll, /* cb_chpoll */ 77a6d42e7dSPeter Dunlap ddi_prop_op, /* cb_prop_op */ 78a6d42e7dSPeter Dunlap NULL, /* cb_streamtab */ 79a6d42e7dSPeter Dunlap D_MP, /* cb_flag */ 80a6d42e7dSPeter Dunlap CB_REV, /* cb_rev */ 81a6d42e7dSPeter Dunlap nodev, /* cb_aread */ 82a6d42e7dSPeter Dunlap nodev, /* cb_awrite */ 83a6d42e7dSPeter Dunlap }; 84a6d42e7dSPeter Dunlap 85a6d42e7dSPeter Dunlap static struct dev_ops iscsit_dev_ops = { 86a6d42e7dSPeter Dunlap DEVO_REV, /* devo_rev */ 87a6d42e7dSPeter Dunlap 0, /* devo_refcnt */ 88a6d42e7dSPeter Dunlap iscsit_drv_getinfo, /* devo_getinfo */ 89a6d42e7dSPeter Dunlap nulldev, /* devo_identify */ 90a6d42e7dSPeter Dunlap nulldev, /* devo_probe */ 91a6d42e7dSPeter Dunlap iscsit_drv_attach, /* devo_attach */ 92a6d42e7dSPeter Dunlap iscsit_drv_detach, /* devo_detach */ 93a6d42e7dSPeter Dunlap nodev, /* devo_reset */ 94a6d42e7dSPeter Dunlap &iscsit_cb_ops, /* devo_cb_ops */ 95a6d42e7dSPeter Dunlap NULL, /* devo_bus_ops */ 96a6d42e7dSPeter Dunlap NULL, /* devo_power */ 9763528ae4SJames Moore ddi_quiesce_not_needed, /* quiesce */ 98a6d42e7dSPeter Dunlap }; 99a6d42e7dSPeter Dunlap 100a6d42e7dSPeter Dunlap static struct modldrv modldrv = { 101a6d42e7dSPeter Dunlap &mod_driverops, 102a6d42e7dSPeter Dunlap "iSCSI Target", 103a6d42e7dSPeter Dunlap &iscsit_dev_ops, 104a6d42e7dSPeter Dunlap }; 105a6d42e7dSPeter Dunlap 106a6d42e7dSPeter Dunlap static struct modlinkage modlinkage = { 107a6d42e7dSPeter Dunlap MODREV_1, 108a6d42e7dSPeter Dunlap &modldrv, 109a6d42e7dSPeter Dunlap NULL, 110a6d42e7dSPeter Dunlap }; 111a6d42e7dSPeter Dunlap 112a6d42e7dSPeter Dunlap 113a6d42e7dSPeter Dunlap iscsit_global_t iscsit_global; 114a6d42e7dSPeter Dunlap 115a6d42e7dSPeter Dunlap kmem_cache_t *iscsit_status_pdu_cache; 116a6d42e7dSPeter Dunlap 117a6d42e7dSPeter Dunlap boolean_t iscsit_sm_logging = B_FALSE; 118a6d42e7dSPeter Dunlap 119a6d42e7dSPeter Dunlap static idm_status_t iscsit_init(dev_info_t *dip); 120a6d42e7dSPeter Dunlap static idm_status_t iscsit_enable_svc(iscsit_hostinfo_t *hostinfo); 121a6d42e7dSPeter Dunlap static void iscsit_disable_svc(void); 122a6d42e7dSPeter Dunlap 123a6d42e7dSPeter Dunlap static void 124a6d42e7dSPeter Dunlap iscsit_op_scsi_task_mgmt(iscsit_conn_t *ict, idm_pdu_t *rx_pdu); 125a6d42e7dSPeter Dunlap 126a6d42e7dSPeter Dunlap static void 127a6d42e7dSPeter Dunlap iscsit_pdu_op_noop(iscsit_conn_t *ict, idm_pdu_t *rx_pdu); 128a6d42e7dSPeter Dunlap 129a6d42e7dSPeter Dunlap static void 130a6d42e7dSPeter Dunlap iscsit_pdu_op_login_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu); 131a6d42e7dSPeter Dunlap 132a6d42e7dSPeter Dunlap void 133a6d42e7dSPeter Dunlap iscsit_pdu_op_text_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu); 134a6d42e7dSPeter Dunlap 135a6d42e7dSPeter Dunlap static void 136a6d42e7dSPeter Dunlap iscsit_pdu_op_logout_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu); 137a6d42e7dSPeter Dunlap 138a6d42e7dSPeter Dunlap int iscsit_cmd_window(); 139a6d42e7dSPeter Dunlap 140a6d42e7dSPeter Dunlap void 141a6d42e7dSPeter Dunlap iscsit_set_cmdsn(iscsit_conn_t *ict, idm_pdu_t *rx_pdu); 142a6d42e7dSPeter Dunlap 143a6d42e7dSPeter Dunlap static void 144a6d42e7dSPeter Dunlap iscsit_calc_rspsn(iscsit_conn_t *ict, idm_pdu_t *resp); 145a6d42e7dSPeter Dunlap 146a6d42e7dSPeter Dunlap static void 147a6d42e7dSPeter Dunlap iscsit_deferred_dispatch(idm_pdu_t *rx_pdu); 148a6d42e7dSPeter Dunlap 149a6d42e7dSPeter Dunlap static void 150a6d42e7dSPeter Dunlap iscsit_deferred(void *rx_pdu_void); 151a6d42e7dSPeter Dunlap 152a6d42e7dSPeter Dunlap static idm_status_t 153a6d42e7dSPeter Dunlap iscsit_conn_accept(idm_conn_t *ic); 154a6d42e7dSPeter Dunlap 155a6d42e7dSPeter Dunlap static idm_status_t 156a6d42e7dSPeter Dunlap iscsit_ffp_enabled(idm_conn_t *ic); 157a6d42e7dSPeter Dunlap 158a6d42e7dSPeter Dunlap static idm_status_t 159a6d42e7dSPeter Dunlap iscsit_ffp_disabled(idm_conn_t *ic, idm_ffp_disable_t disable_class); 160a6d42e7dSPeter Dunlap 161a6d42e7dSPeter Dunlap static idm_status_t 162a6d42e7dSPeter Dunlap iscsit_conn_lost(idm_conn_t *ic); 163a6d42e7dSPeter Dunlap 164a6d42e7dSPeter Dunlap static idm_status_t 165a6d42e7dSPeter Dunlap iscsit_conn_destroy(idm_conn_t *ic); 166a6d42e7dSPeter Dunlap 167a6d42e7dSPeter Dunlap static stmf_data_buf_t * 168a6d42e7dSPeter Dunlap iscsit_dbuf_alloc(scsi_task_t *task, uint32_t size, uint32_t *pminsize, 169a6d42e7dSPeter Dunlap uint32_t flags); 170a6d42e7dSPeter Dunlap 171a6d42e7dSPeter Dunlap static void 172a6d42e7dSPeter Dunlap iscsit_dbuf_free(stmf_dbuf_store_t *ds, stmf_data_buf_t *dbuf); 173a6d42e7dSPeter Dunlap 174a6d42e7dSPeter Dunlap static void 175a6d42e7dSPeter Dunlap iscsit_buf_xfer_cb(idm_buf_t *idb, idm_status_t status); 176a6d42e7dSPeter Dunlap 177a6d42e7dSPeter Dunlap static void 178a6d42e7dSPeter Dunlap iscsit_send_good_status_done(idm_pdu_t *pdu, idm_status_t status); 179a6d42e7dSPeter Dunlap 180a6d42e7dSPeter Dunlap static void 181a6d42e7dSPeter Dunlap iscsit_send_status_done(idm_pdu_t *pdu, idm_status_t status); 182a6d42e7dSPeter Dunlap 183a6d42e7dSPeter Dunlap static stmf_status_t 184a6d42e7dSPeter Dunlap iscsit_idm_to_stmf(idm_status_t idmrc); 185a6d42e7dSPeter Dunlap 186a6d42e7dSPeter Dunlap static iscsit_task_t * 187a6d42e7dSPeter Dunlap iscsit_task_alloc(iscsit_conn_t *ict); 188a6d42e7dSPeter Dunlap 189a6d42e7dSPeter Dunlap static void 190a6d42e7dSPeter Dunlap iscsit_task_free(iscsit_task_t *itask); 191a6d42e7dSPeter Dunlap 192a6d42e7dSPeter Dunlap static iscsit_task_t * 193a6d42e7dSPeter Dunlap iscsit_tm_task_alloc(iscsit_conn_t *ict); 194a6d42e7dSPeter Dunlap 195a6d42e7dSPeter Dunlap static void 196a6d42e7dSPeter Dunlap iscsit_tm_task_free(iscsit_task_t *itask); 197a6d42e7dSPeter Dunlap 19872cf3143Speter dunlap static idm_status_t 19972cf3143Speter dunlap iscsit_task_start(iscsit_task_t *itask); 20072cf3143Speter dunlap 20172cf3143Speter dunlap static void 20272cf3143Speter dunlap iscsit_task_done(iscsit_task_t *itask); 20372cf3143Speter dunlap 204a6d42e7dSPeter Dunlap static int 205a6d42e7dSPeter Dunlap iscsit_status_pdu_constructor(void *pdu_void, void *arg, int flags); 206a6d42e7dSPeter Dunlap 207a6d42e7dSPeter Dunlap static void 208a6d42e7dSPeter Dunlap iscsit_pp_cb(struct stmf_port_provider *pp, int cmd, void *arg, uint32_t flags); 209a6d42e7dSPeter Dunlap 210a6d42e7dSPeter Dunlap static it_cfg_status_t 211a6d42e7dSPeter Dunlap iscsit_config_merge(it_config_t *cfg); 212a6d42e7dSPeter Dunlap 213a6d42e7dSPeter Dunlap static idm_status_t 214a6d42e7dSPeter Dunlap iscsit_login_fail(idm_conn_t *ic); 215a6d42e7dSPeter Dunlap 21672cf3143Speter dunlap static boolean_t iscsit_cmdsn_in_window(iscsit_conn_t *ict, uint32_t cmdsn); 21772cf3143Speter dunlap static void iscsit_send_direct_scsi_resp(iscsit_conn_t *ict, idm_pdu_t *rx_pdu, 21872cf3143Speter dunlap uint8_t response, uint8_t cmd_status); 21972cf3143Speter dunlap static void iscsit_send_task_mgmt_resp(idm_pdu_t *tm_resp_pdu, 22072cf3143Speter dunlap uint8_t tm_status); 22172cf3143Speter dunlap 222a6d42e7dSPeter Dunlap int 223a6d42e7dSPeter Dunlap _init(void) 224a6d42e7dSPeter Dunlap { 225a6d42e7dSPeter Dunlap int rc; 226a6d42e7dSPeter Dunlap 227a6d42e7dSPeter Dunlap rw_init(&iscsit_global.global_rwlock, NULL, RW_DRIVER, NULL); 228a6d42e7dSPeter Dunlap iscsit_global.global_svc_state = ISE_DETACHED; 229a6d42e7dSPeter Dunlap 230a6d42e7dSPeter Dunlap if ((rc = mod_install(&modlinkage)) != 0) { 231a6d42e7dSPeter Dunlap rw_destroy(&iscsit_global.global_rwlock); 232a6d42e7dSPeter Dunlap return (rc); 233a6d42e7dSPeter Dunlap } 234a6d42e7dSPeter Dunlap 235a6d42e7dSPeter Dunlap return (rc); 236a6d42e7dSPeter Dunlap } 237a6d42e7dSPeter Dunlap 238a6d42e7dSPeter Dunlap int 239a6d42e7dSPeter Dunlap _info(struct modinfo *modinfop) 240a6d42e7dSPeter Dunlap { 241a6d42e7dSPeter Dunlap return (mod_info(&modlinkage, modinfop)); 242a6d42e7dSPeter Dunlap } 243a6d42e7dSPeter Dunlap 244a6d42e7dSPeter Dunlap int 245a6d42e7dSPeter Dunlap _fini(void) 246a6d42e7dSPeter Dunlap { 247a6d42e7dSPeter Dunlap int rc; 248a6d42e7dSPeter Dunlap 249a6d42e7dSPeter Dunlap rc = mod_remove(&modlinkage); 250a6d42e7dSPeter Dunlap 251a6d42e7dSPeter Dunlap if (rc == 0) { 252a6d42e7dSPeter Dunlap rw_destroy(&iscsit_global.global_rwlock); 253a6d42e7dSPeter Dunlap } 254a6d42e7dSPeter Dunlap 255a6d42e7dSPeter Dunlap return (rc); 256a6d42e7dSPeter Dunlap } 257a6d42e7dSPeter Dunlap 258a6d42e7dSPeter Dunlap /* 259a6d42e7dSPeter Dunlap * DDI entry points. 260a6d42e7dSPeter Dunlap */ 261a6d42e7dSPeter Dunlap 262a6d42e7dSPeter Dunlap /* ARGSUSED */ 263a6d42e7dSPeter Dunlap static int 264a6d42e7dSPeter Dunlap iscsit_drv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, 265a6d42e7dSPeter Dunlap void **result) 266a6d42e7dSPeter Dunlap { 267a6d42e7dSPeter Dunlap ulong_t instance = getminor((dev_t)arg); 268a6d42e7dSPeter Dunlap 269a6d42e7dSPeter Dunlap switch (cmd) { 270a6d42e7dSPeter Dunlap case DDI_INFO_DEVT2DEVINFO: 271a6d42e7dSPeter Dunlap *result = iscsit_global.global_dip; 272a6d42e7dSPeter Dunlap return (DDI_SUCCESS); 273a6d42e7dSPeter Dunlap 274a6d42e7dSPeter Dunlap case DDI_INFO_DEVT2INSTANCE: 275a6d42e7dSPeter Dunlap *result = (void *)instance; 276a6d42e7dSPeter Dunlap return (DDI_SUCCESS); 277a6d42e7dSPeter Dunlap 278a6d42e7dSPeter Dunlap default: 279a6d42e7dSPeter Dunlap break; 280a6d42e7dSPeter Dunlap } 281a6d42e7dSPeter Dunlap 282a6d42e7dSPeter Dunlap return (DDI_FAILURE); 283a6d42e7dSPeter Dunlap } 284a6d42e7dSPeter Dunlap 285a6d42e7dSPeter Dunlap static int 286a6d42e7dSPeter Dunlap iscsit_drv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 287a6d42e7dSPeter Dunlap { 288a6d42e7dSPeter Dunlap if (cmd != DDI_ATTACH) { 289a6d42e7dSPeter Dunlap return (DDI_FAILURE); 290a6d42e7dSPeter Dunlap } 291a6d42e7dSPeter Dunlap 292a6d42e7dSPeter Dunlap if (ddi_get_instance(dip) != 0) { 293a6d42e7dSPeter Dunlap /* we only allow instance 0 to attach */ 294a6d42e7dSPeter Dunlap return (DDI_FAILURE); 295a6d42e7dSPeter Dunlap } 296a6d42e7dSPeter Dunlap 297a6d42e7dSPeter Dunlap /* create the minor node */ 298a6d42e7dSPeter Dunlap if (ddi_create_minor_node(dip, ISCSIT_MODNAME, S_IFCHR, 0, 299a6d42e7dSPeter Dunlap DDI_PSEUDO, 0) != DDI_SUCCESS) { 300a6d42e7dSPeter Dunlap cmn_err(CE_WARN, "iscsit_drv_attach: " 301a6d42e7dSPeter Dunlap "failed creating minor node"); 302a6d42e7dSPeter Dunlap return (DDI_FAILURE); 303a6d42e7dSPeter Dunlap } 304a6d42e7dSPeter Dunlap 305a6d42e7dSPeter Dunlap if (iscsit_init(dip) != IDM_STATUS_SUCCESS) { 306a6d42e7dSPeter Dunlap cmn_err(CE_WARN, "iscsit_drv_attach: " 307a6d42e7dSPeter Dunlap "failed to initialize"); 308a6d42e7dSPeter Dunlap ddi_remove_minor_node(dip, NULL); 309a6d42e7dSPeter Dunlap return (DDI_FAILURE); 310a6d42e7dSPeter Dunlap } 311a6d42e7dSPeter Dunlap 312a6d42e7dSPeter Dunlap iscsit_global.global_svc_state = ISE_DISABLED; 313a6d42e7dSPeter Dunlap iscsit_global.global_dip = dip; 314a6d42e7dSPeter Dunlap 315a6d42e7dSPeter Dunlap return (DDI_SUCCESS); 316a6d42e7dSPeter Dunlap } 317a6d42e7dSPeter Dunlap 318a6d42e7dSPeter Dunlap /*ARGSUSED*/ 319a6d42e7dSPeter Dunlap static int 320a6d42e7dSPeter Dunlap iscsit_drv_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 321a6d42e7dSPeter Dunlap { 322a6d42e7dSPeter Dunlap if (cmd != DDI_DETACH) 323a6d42e7dSPeter Dunlap return (DDI_FAILURE); 324a6d42e7dSPeter Dunlap 325a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_LOCK(RW_WRITER); 326a6d42e7dSPeter Dunlap if (iscsit_drv_busy()) { 327a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_UNLOCK(); 328a6d42e7dSPeter Dunlap return (EBUSY); 329a6d42e7dSPeter Dunlap } 330a6d42e7dSPeter Dunlap 331a6d42e7dSPeter Dunlap iscsit_global.global_dip = NULL; 332a6d42e7dSPeter Dunlap ddi_remove_minor_node(dip, NULL); 333a6d42e7dSPeter Dunlap 334a6d42e7dSPeter Dunlap ldi_ident_release(iscsit_global.global_li); 335a6d42e7dSPeter Dunlap iscsit_global.global_svc_state = ISE_DETACHED; 336a6d42e7dSPeter Dunlap 337a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_UNLOCK(); 338a6d42e7dSPeter Dunlap 339a6d42e7dSPeter Dunlap return (DDI_SUCCESS); 340a6d42e7dSPeter Dunlap } 341a6d42e7dSPeter Dunlap 342a6d42e7dSPeter Dunlap /*ARGSUSED*/ 343a6d42e7dSPeter Dunlap static int 344a6d42e7dSPeter Dunlap iscsit_drv_open(dev_t *devp, int flag, int otyp, cred_t *credp) 345a6d42e7dSPeter Dunlap { 346a6d42e7dSPeter Dunlap return (0); 347a6d42e7dSPeter Dunlap } 348a6d42e7dSPeter Dunlap 349a6d42e7dSPeter Dunlap /* ARGSUSED */ 350a6d42e7dSPeter Dunlap static int 351a6d42e7dSPeter Dunlap iscsit_drv_close(dev_t dev, int flag, int otyp, cred_t *credp) 352a6d42e7dSPeter Dunlap { 353a6d42e7dSPeter Dunlap return (0); 354a6d42e7dSPeter Dunlap } 355a6d42e7dSPeter Dunlap 356a6d42e7dSPeter Dunlap static boolean_t 357a6d42e7dSPeter Dunlap iscsit_drv_busy(void) 358a6d42e7dSPeter Dunlap { 359a6d42e7dSPeter Dunlap switch (iscsit_global.global_svc_state) { 360a6d42e7dSPeter Dunlap case ISE_DISABLED: 361a6d42e7dSPeter Dunlap case ISE_DETACHED: 362a6d42e7dSPeter Dunlap return (B_FALSE); 363a6d42e7dSPeter Dunlap default: 364a6d42e7dSPeter Dunlap return (B_TRUE); 365a6d42e7dSPeter Dunlap } 366a6d42e7dSPeter Dunlap /* NOTREACHED */ 367a6d42e7dSPeter Dunlap } 368a6d42e7dSPeter Dunlap 369a6d42e7dSPeter Dunlap /* ARGSUSED */ 370a6d42e7dSPeter Dunlap static int 371a6d42e7dSPeter Dunlap iscsit_drv_ioctl(dev_t drv, int cmd, intptr_t argp, int flag, cred_t *cred, 372a6d42e7dSPeter Dunlap int *retval) 373a6d42e7dSPeter Dunlap { 374a6d42e7dSPeter Dunlap iscsit_ioc_set_config_t setcfg; 375a6d42e7dSPeter Dunlap iscsit_ioc_set_config32_t setcfg32; 37607a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States char *cfg_pnvlist = NULL; 37707a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States nvlist_t *cfg_nvlist = NULL; 37807a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States it_config_t *cfg = NULL; 379a6d42e7dSPeter Dunlap idm_status_t idmrc; 380a6d42e7dSPeter Dunlap int rc = 0; 381a6d42e7dSPeter Dunlap 382a6d42e7dSPeter Dunlap if (drv_priv(cred) != 0) { 383a6d42e7dSPeter Dunlap return (EPERM); 384a6d42e7dSPeter Dunlap } 385a6d42e7dSPeter Dunlap 386a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_LOCK(RW_WRITER); 387a6d42e7dSPeter Dunlap 388a6d42e7dSPeter Dunlap /* 389a6d42e7dSPeter Dunlap * Validate ioctl requests against global service state 390a6d42e7dSPeter Dunlap */ 391a6d42e7dSPeter Dunlap switch (iscsit_global.global_svc_state) { 392a6d42e7dSPeter Dunlap case ISE_ENABLED: 393a6d42e7dSPeter Dunlap if (cmd == ISCSIT_IOC_DISABLE_SVC) { 394a6d42e7dSPeter Dunlap iscsit_global.global_svc_state = ISE_DISABLING; 395a6d42e7dSPeter Dunlap } else if (cmd == ISCSIT_IOC_ENABLE_SVC) { 396a6d42e7dSPeter Dunlap /* Already enabled */ 397a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_UNLOCK(); 398a6d42e7dSPeter Dunlap return (0); 399a6d42e7dSPeter Dunlap } else { 400a6d42e7dSPeter Dunlap iscsit_global.global_svc_state = ISE_BUSY; 401a6d42e7dSPeter Dunlap } 402a6d42e7dSPeter Dunlap break; 403a6d42e7dSPeter Dunlap case ISE_DISABLED: 404a6d42e7dSPeter Dunlap if (cmd == ISCSIT_IOC_ENABLE_SVC) { 405a6d42e7dSPeter Dunlap iscsit_global.global_svc_state = ISE_ENABLING; 406a6d42e7dSPeter Dunlap } else if (cmd == ISCSIT_IOC_DISABLE_SVC) { 407a6d42e7dSPeter Dunlap /* Already disabled */ 408a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_UNLOCK(); 409a6d42e7dSPeter Dunlap return (0); 410a6d42e7dSPeter Dunlap } else { 411a6d42e7dSPeter Dunlap rc = EFAULT; 412a6d42e7dSPeter Dunlap } 413a6d42e7dSPeter Dunlap break; 414a6d42e7dSPeter Dunlap case ISE_ENABLING: 415a6d42e7dSPeter Dunlap case ISE_DISABLING: 416a6d42e7dSPeter Dunlap rc = EAGAIN; 417a6d42e7dSPeter Dunlap break; 418a6d42e7dSPeter Dunlap case ISE_DETACHED: 419a6d42e7dSPeter Dunlap default: 420a6d42e7dSPeter Dunlap rc = EFAULT; 421a6d42e7dSPeter Dunlap break; 422a6d42e7dSPeter Dunlap } 423a6d42e7dSPeter Dunlap 424a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_UNLOCK(); 425a6d42e7dSPeter Dunlap if (rc != 0) 426a6d42e7dSPeter Dunlap return (rc); 427a6d42e7dSPeter Dunlap 428a6d42e7dSPeter Dunlap /* Handle ioctl request (enable/disable have already been handled) */ 429a6d42e7dSPeter Dunlap switch (cmd) { 430a6d42e7dSPeter Dunlap case ISCSIT_IOC_SET_CONFIG: 43107a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States /* Any errors must set state back to ISE_ENABLED */ 432a6d42e7dSPeter Dunlap switch (ddi_model_convert_from(flag & FMODELS)) { 433a6d42e7dSPeter Dunlap case DDI_MODEL_ILP32: 434a6d42e7dSPeter Dunlap if (ddi_copyin((void *)argp, &setcfg32, 43507a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States sizeof (iscsit_ioc_set_config32_t), flag) != 0) { 43607a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States rc = EFAULT; 43707a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States goto cleanup; 43807a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States } 439a6d42e7dSPeter Dunlap 440a6d42e7dSPeter Dunlap setcfg.set_cfg_pnvlist = 441a6d42e7dSPeter Dunlap (char *)((uintptr_t)setcfg32.set_cfg_pnvlist); 442a6d42e7dSPeter Dunlap setcfg.set_cfg_vers = setcfg32.set_cfg_vers; 443a6d42e7dSPeter Dunlap setcfg.set_cfg_pnvlist_len = 444a6d42e7dSPeter Dunlap setcfg32.set_cfg_pnvlist_len; 445a6d42e7dSPeter Dunlap break; 446a6d42e7dSPeter Dunlap case DDI_MODEL_NONE: 447a6d42e7dSPeter Dunlap if (ddi_copyin((void *)argp, &setcfg, 44807a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States sizeof (iscsit_ioc_set_config_t), flag) != 0) { 44907a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States rc = EFAULT; 45007a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States goto cleanup; 45107a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States } 452a6d42e7dSPeter Dunlap break; 453*fcc214c3SCharles Ting default: 454*fcc214c3SCharles Ting rc = EFAULT; 455*fcc214c3SCharles Ting goto cleanup; 456a6d42e7dSPeter Dunlap } 457a6d42e7dSPeter Dunlap 458a6d42e7dSPeter Dunlap /* Check API version */ 459a6d42e7dSPeter Dunlap if (setcfg.set_cfg_vers != ISCSIT_API_VERS0) { 46007a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States rc = EINVAL; 46107a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States goto cleanup; 462a6d42e7dSPeter Dunlap } 463a6d42e7dSPeter Dunlap 464a6d42e7dSPeter Dunlap /* Config is in packed nvlist format so unpack it */ 465a6d42e7dSPeter Dunlap cfg_pnvlist = kmem_alloc(setcfg.set_cfg_pnvlist_len, 466a6d42e7dSPeter Dunlap KM_SLEEP); 467a6d42e7dSPeter Dunlap ASSERT(cfg_pnvlist != NULL); 468a6d42e7dSPeter Dunlap 469a6d42e7dSPeter Dunlap if (ddi_copyin(setcfg.set_cfg_pnvlist, cfg_pnvlist, 470a6d42e7dSPeter Dunlap setcfg.set_cfg_pnvlist_len, flag) != 0) { 47107a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States rc = EFAULT; 47207a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States goto cleanup; 473a6d42e7dSPeter Dunlap } 474a6d42e7dSPeter Dunlap 47507a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States rc = nvlist_unpack(cfg_pnvlist, setcfg.set_cfg_pnvlist_len, 47607a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States &cfg_nvlist, KM_SLEEP); 47707a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States if (rc != 0) { 47807a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States goto cleanup; 479a6d42e7dSPeter Dunlap } 480a6d42e7dSPeter Dunlap 481a6d42e7dSPeter Dunlap /* Translate nvlist */ 48207a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States rc = it_nv_to_config(cfg_nvlist, &cfg); 48307a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States if (rc != 0) { 484a6d42e7dSPeter Dunlap cmn_err(CE_WARN, "Configuration is invalid"); 48507a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States goto cleanup; 486a6d42e7dSPeter Dunlap } 487a6d42e7dSPeter Dunlap 488a6d42e7dSPeter Dunlap /* Update config */ 48907a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States rc = iscsit_config_merge(cfg); 49007a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States /* FALLTHROUGH */ 49107a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 49207a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States cleanup: 49307a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States if (cfg) 49407a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States it_config_free_cmn(cfg); 49507a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States if (cfg_pnvlist) 496a6d42e7dSPeter Dunlap kmem_free(cfg_pnvlist, setcfg.set_cfg_pnvlist_len); 49707a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States if (cfg_nvlist) 498a6d42e7dSPeter Dunlap nvlist_free(cfg_nvlist); 499a6d42e7dSPeter Dunlap 500a6d42e7dSPeter Dunlap /* 501a6d42e7dSPeter Dunlap * Now that the reconfig is complete set our state back to 502a6d42e7dSPeter Dunlap * enabled. 503a6d42e7dSPeter Dunlap */ 504a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_LOCK(RW_WRITER); 505a6d42e7dSPeter Dunlap iscsit_global.global_svc_state = ISE_ENABLED; 506a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_UNLOCK(); 507a6d42e7dSPeter Dunlap break; 508a6d42e7dSPeter Dunlap case ISCSIT_IOC_ENABLE_SVC: { 509a6d42e7dSPeter Dunlap iscsit_hostinfo_t hostinfo; 510a6d42e7dSPeter Dunlap 511a6d42e7dSPeter Dunlap if (ddi_copyin((void *)argp, &hostinfo.length, 512a6d42e7dSPeter Dunlap sizeof (hostinfo.length), flag) != 0) { 513a6d42e7dSPeter Dunlap iscsit_global.global_svc_state = ISE_DISABLED; 514a6d42e7dSPeter Dunlap return (EFAULT); 515a6d42e7dSPeter Dunlap } 516a6d42e7dSPeter Dunlap 517a6d42e7dSPeter Dunlap if (hostinfo.length > sizeof (hostinfo.fqhn)) 518a6d42e7dSPeter Dunlap hostinfo.length = sizeof (hostinfo.fqhn); 519a6d42e7dSPeter Dunlap 520a6d42e7dSPeter Dunlap if (ddi_copyin((void *)((caddr_t)argp + 521a6d42e7dSPeter Dunlap sizeof (hostinfo.length)), &hostinfo.fqhn, 522a6d42e7dSPeter Dunlap hostinfo.length, flag) != 0) { 523a6d42e7dSPeter Dunlap iscsit_global.global_svc_state = ISE_DISABLED; 524a6d42e7dSPeter Dunlap return (EFAULT); 525a6d42e7dSPeter Dunlap } 526a6d42e7dSPeter Dunlap 527a6d42e7dSPeter Dunlap idmrc = iscsit_enable_svc(&hostinfo); 528a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_LOCK(RW_WRITER); 529a6d42e7dSPeter Dunlap if (idmrc == IDM_STATUS_SUCCESS) { 530a6d42e7dSPeter Dunlap iscsit_global.global_svc_state = ISE_ENABLED; 531a6d42e7dSPeter Dunlap } else { 532a6d42e7dSPeter Dunlap rc = EIO; 533a6d42e7dSPeter Dunlap iscsit_global.global_svc_state = ISE_DISABLED; 534a6d42e7dSPeter Dunlap } 535a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_UNLOCK(); 536a6d42e7dSPeter Dunlap break; 537a6d42e7dSPeter Dunlap } 538a6d42e7dSPeter Dunlap case ISCSIT_IOC_DISABLE_SVC: 539a6d42e7dSPeter Dunlap iscsit_disable_svc(); 540a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_LOCK(RW_WRITER); 541a6d42e7dSPeter Dunlap iscsit_global.global_svc_state = ISE_DISABLED; 542a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_UNLOCK(); 543a6d42e7dSPeter Dunlap break; 54407a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States 545a6d42e7dSPeter Dunlap default: 546a6d42e7dSPeter Dunlap rc = EINVAL; 54707a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States ISCSIT_GLOBAL_LOCK(RW_WRITER); 54807a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States iscsit_global.global_svc_state = ISE_ENABLED; 54907a2bfd1SPeter Cudhea - Sun Microsystems - Burlington, MA United States ISCSIT_GLOBAL_UNLOCK(); 550a6d42e7dSPeter Dunlap } 551a6d42e7dSPeter Dunlap 552a6d42e7dSPeter Dunlap return (rc); 553a6d42e7dSPeter Dunlap } 554a6d42e7dSPeter Dunlap 555a6d42e7dSPeter Dunlap static idm_status_t 556a6d42e7dSPeter Dunlap iscsit_init(dev_info_t *dip) 557a6d42e7dSPeter Dunlap { 558a6d42e7dSPeter Dunlap int rc; 559a6d42e7dSPeter Dunlap 560a6d42e7dSPeter Dunlap rc = ldi_ident_from_dip(dip, &iscsit_global.global_li); 561a6d42e7dSPeter Dunlap ASSERT(rc == 0); /* Failure indicates invalid argument */ 562a6d42e7dSPeter Dunlap 563a6d42e7dSPeter Dunlap iscsit_global.global_svc_state = ISE_DISABLED; 564a6d42e7dSPeter Dunlap 565a6d42e7dSPeter Dunlap return (IDM_STATUS_SUCCESS); 566a6d42e7dSPeter Dunlap } 567a6d42e7dSPeter Dunlap 568a6d42e7dSPeter Dunlap /* 569a6d42e7dSPeter Dunlap * iscsit_enable_svc 570a6d42e7dSPeter Dunlap * 571a6d42e7dSPeter Dunlap * registers all the configured targets and target portals with STMF 572a6d42e7dSPeter Dunlap */ 573a6d42e7dSPeter Dunlap static idm_status_t 574a6d42e7dSPeter Dunlap iscsit_enable_svc(iscsit_hostinfo_t *hostinfo) 575a6d42e7dSPeter Dunlap { 576a6d42e7dSPeter Dunlap stmf_port_provider_t *pp; 577a6d42e7dSPeter Dunlap stmf_dbuf_store_t *dbuf_store; 578a6d42e7dSPeter Dunlap boolean_t did_iscsit_isns_init; 579a6d42e7dSPeter Dunlap idm_status_t retval = IDM_STATUS_SUCCESS; 580a6d42e7dSPeter Dunlap 581a6d42e7dSPeter Dunlap ASSERT(iscsit_global.global_svc_state == ISE_ENABLING); 582a6d42e7dSPeter Dunlap 583a6d42e7dSPeter Dunlap /* 584a6d42e7dSPeter Dunlap * Make sure that can tell if we have partially allocated 585a6d42e7dSPeter Dunlap * in case we need to exit and tear down anything allocated. 586a6d42e7dSPeter Dunlap */ 587a6d42e7dSPeter Dunlap iscsit_global.global_tsih_pool = NULL; 588a6d42e7dSPeter Dunlap iscsit_global.global_dbuf_store = NULL; 589a6d42e7dSPeter Dunlap iscsit_status_pdu_cache = NULL; 590a6d42e7dSPeter Dunlap pp = NULL; 591a6d42e7dSPeter Dunlap iscsit_global.global_pp = NULL; 592a6d42e7dSPeter Dunlap iscsit_global.global_default_tpg = NULL; 593a6d42e7dSPeter Dunlap did_iscsit_isns_init = B_FALSE; 594a6d42e7dSPeter Dunlap iscsit_global.global_dispatch_taskq = NULL; 595a6d42e7dSPeter Dunlap 596a6d42e7dSPeter Dunlap /* Setup remaining fields in iscsit_global_t */ 597a6d42e7dSPeter Dunlap idm_refcnt_init(&iscsit_global.global_refcnt, 598a6d42e7dSPeter Dunlap &iscsit_global); 599a6d42e7dSPeter Dunlap 600a6d42e7dSPeter Dunlap avl_create(&iscsit_global.global_discovery_sessions, 601a6d42e7dSPeter Dunlap iscsit_sess_avl_compare, sizeof (iscsit_sess_t), 602a6d42e7dSPeter Dunlap offsetof(iscsit_sess_t, ist_tgt_ln)); 603a6d42e7dSPeter Dunlap 604a6d42e7dSPeter Dunlap avl_create(&iscsit_global.global_target_list, 605a6d42e7dSPeter Dunlap iscsit_tgt_avl_compare, sizeof (iscsit_tgt_t), 606a6d42e7dSPeter Dunlap offsetof(iscsit_tgt_t, target_global_ln)); 607a6d42e7dSPeter Dunlap 608a6d42e7dSPeter Dunlap list_create(&iscsit_global.global_deleted_target_list, 609a6d42e7dSPeter Dunlap sizeof (iscsit_tgt_t), 610a6d42e7dSPeter Dunlap offsetof(iscsit_tgt_t, target_global_deleted_ln)); 611a6d42e7dSPeter Dunlap 612a6d42e7dSPeter Dunlap avl_create(&iscsit_global.global_tpg_list, 613a6d42e7dSPeter Dunlap iscsit_tpg_avl_compare, sizeof (iscsit_tpg_t), 614a6d42e7dSPeter Dunlap offsetof(iscsit_tpg_t, tpg_global_ln)); 615a6d42e7dSPeter Dunlap 616a6d42e7dSPeter Dunlap avl_create(&iscsit_global.global_ini_list, 617a6d42e7dSPeter Dunlap iscsit_ini_avl_compare, sizeof (iscsit_ini_t), 618a6d42e7dSPeter Dunlap offsetof(iscsit_ini_t, ini_global_ln)); 619a6d42e7dSPeter Dunlap 620a6d42e7dSPeter Dunlap iscsit_global.global_tsih_pool = vmem_create("iscsit_tsih_pool", 621a6d42e7dSPeter Dunlap (void *)1, ISCSI_MAX_TSIH, 1, NULL, NULL, NULL, 0, 622a6d42e7dSPeter Dunlap VM_SLEEP | VMC_IDENTIFIER); 623a6d42e7dSPeter Dunlap 624a6d42e7dSPeter Dunlap /* 625a6d42e7dSPeter Dunlap * Setup STMF dbuf store. Our buffers are bound to a specific 626a6d42e7dSPeter Dunlap * connection so we really can't let STMF cache buffers for us. 627a6d42e7dSPeter Dunlap * Consequently we'll just allocate one global buffer store. 628a6d42e7dSPeter Dunlap */ 629a6d42e7dSPeter Dunlap dbuf_store = stmf_alloc(STMF_STRUCT_DBUF_STORE, 0, 0); 630a6d42e7dSPeter Dunlap if (dbuf_store == NULL) { 631a6d42e7dSPeter Dunlap retval = IDM_STATUS_FAIL; 632a6d42e7dSPeter Dunlap goto tear_down_and_return; 633a6d42e7dSPeter Dunlap } 634a6d42e7dSPeter Dunlap dbuf_store->ds_alloc_data_buf = iscsit_dbuf_alloc; 635a6d42e7dSPeter Dunlap dbuf_store->ds_free_data_buf = iscsit_dbuf_free; 636a6d42e7dSPeter Dunlap dbuf_store->ds_port_private = NULL; 637a6d42e7dSPeter Dunlap iscsit_global.global_dbuf_store = dbuf_store; 638a6d42e7dSPeter Dunlap 639a6d42e7dSPeter Dunlap /* Status PDU cache */ 640a6d42e7dSPeter Dunlap iscsit_status_pdu_cache = kmem_cache_create("iscsit_status_pdu_cache", 641a6d42e7dSPeter Dunlap sizeof (idm_pdu_t) + sizeof (iscsi_scsi_rsp_hdr_t), 8, 642a6d42e7dSPeter Dunlap &iscsit_status_pdu_constructor, 643a6d42e7dSPeter Dunlap NULL, NULL, NULL, NULL, KM_SLEEP); 644a6d42e7dSPeter Dunlap 645a6d42e7dSPeter Dunlap /* Default TPG and portal */ 646a6d42e7dSPeter Dunlap iscsit_global.global_default_tpg = iscsit_tpg_createdefault(); 647a6d42e7dSPeter Dunlap if (iscsit_global.global_default_tpg == NULL) { 648a6d42e7dSPeter Dunlap retval = IDM_STATUS_FAIL; 649a6d42e7dSPeter Dunlap goto tear_down_and_return; 650a6d42e7dSPeter Dunlap } 651a6d42e7dSPeter Dunlap 652a6d42e7dSPeter Dunlap /* initialize isns client */ 653a6d42e7dSPeter Dunlap (void) iscsit_isns_init(hostinfo); 654a6d42e7dSPeter Dunlap did_iscsit_isns_init = B_TRUE; 655a6d42e7dSPeter Dunlap 656a6d42e7dSPeter Dunlap /* Register port provider */ 657a6d42e7dSPeter Dunlap pp = stmf_alloc(STMF_STRUCT_PORT_PROVIDER, 0, 0); 658a6d42e7dSPeter Dunlap if (pp == NULL) { 659a6d42e7dSPeter Dunlap retval = IDM_STATUS_FAIL; 660a6d42e7dSPeter Dunlap goto tear_down_and_return; 661a6d42e7dSPeter Dunlap } 662a6d42e7dSPeter Dunlap 663a6d42e7dSPeter Dunlap pp->pp_portif_rev = PORTIF_REV_1; 664a6d42e7dSPeter Dunlap pp->pp_instance = 0; 665a6d42e7dSPeter Dunlap pp->pp_name = ISCSIT_MODNAME; 666a6d42e7dSPeter Dunlap pp->pp_cb = iscsit_pp_cb; 667a6d42e7dSPeter Dunlap 668a6d42e7dSPeter Dunlap iscsit_global.global_pp = pp; 669a6d42e7dSPeter Dunlap 670a6d42e7dSPeter Dunlap 671a6d42e7dSPeter Dunlap if (stmf_register_port_provider(pp) != STMF_SUCCESS) { 672a6d42e7dSPeter Dunlap retval = IDM_STATUS_FAIL; 673a6d42e7dSPeter Dunlap goto tear_down_and_return; 674a6d42e7dSPeter Dunlap } 675a6d42e7dSPeter Dunlap 676a6d42e7dSPeter Dunlap iscsit_global.global_dispatch_taskq = taskq_create("iscsit_dispatch", 677a6d42e7dSPeter Dunlap 1, minclsyspri, 16, 16, TASKQ_PREPOPULATE); 678a6d42e7dSPeter Dunlap 679a6d42e7dSPeter Dunlap return (IDM_STATUS_SUCCESS); 680a6d42e7dSPeter Dunlap 681a6d42e7dSPeter Dunlap tear_down_and_return: 682a6d42e7dSPeter Dunlap 683a6d42e7dSPeter Dunlap if (iscsit_global.global_dispatch_taskq) { 684a6d42e7dSPeter Dunlap taskq_destroy(iscsit_global.global_dispatch_taskq); 685a6d42e7dSPeter Dunlap iscsit_global.global_dispatch_taskq = NULL; 686a6d42e7dSPeter Dunlap } 687a6d42e7dSPeter Dunlap 688a6d42e7dSPeter Dunlap if (did_iscsit_isns_init) 689a6d42e7dSPeter Dunlap iscsit_isns_fini(); 690a6d42e7dSPeter Dunlap 691a6d42e7dSPeter Dunlap if (iscsit_global.global_default_tpg) { 692a6d42e7dSPeter Dunlap iscsit_tpg_destroydefault(iscsit_global.global_default_tpg); 693a6d42e7dSPeter Dunlap iscsit_global.global_default_tpg = NULL; 694a6d42e7dSPeter Dunlap } 695a6d42e7dSPeter Dunlap 696a6d42e7dSPeter Dunlap if (iscsit_global.global_pp) 697a6d42e7dSPeter Dunlap iscsit_global.global_pp = NULL; 698a6d42e7dSPeter Dunlap 699a6d42e7dSPeter Dunlap if (pp) 700a6d42e7dSPeter Dunlap stmf_free(pp); 701a6d42e7dSPeter Dunlap 702a6d42e7dSPeter Dunlap if (iscsit_status_pdu_cache) { 703a6d42e7dSPeter Dunlap kmem_cache_destroy(iscsit_status_pdu_cache); 704a6d42e7dSPeter Dunlap iscsit_status_pdu_cache = NULL; 705a6d42e7dSPeter Dunlap } 706a6d42e7dSPeter Dunlap 707a6d42e7dSPeter Dunlap if (iscsit_global.global_dbuf_store) { 708a6d42e7dSPeter Dunlap stmf_free(iscsit_global.global_dbuf_store); 709a6d42e7dSPeter Dunlap iscsit_global.global_dbuf_store = NULL; 710a6d42e7dSPeter Dunlap } 711a6d42e7dSPeter Dunlap 712a6d42e7dSPeter Dunlap if (iscsit_global.global_tsih_pool) { 713a6d42e7dSPeter Dunlap vmem_destroy(iscsit_global.global_tsih_pool); 714a6d42e7dSPeter Dunlap iscsit_global.global_tsih_pool = NULL; 715a6d42e7dSPeter Dunlap } 716a6d42e7dSPeter Dunlap 717a6d42e7dSPeter Dunlap avl_destroy(&iscsit_global.global_ini_list); 718a6d42e7dSPeter Dunlap avl_destroy(&iscsit_global.global_tpg_list); 719a6d42e7dSPeter Dunlap list_destroy(&iscsit_global.global_deleted_target_list); 720a6d42e7dSPeter Dunlap avl_destroy(&iscsit_global.global_target_list); 721a6d42e7dSPeter Dunlap avl_destroy(&iscsit_global.global_discovery_sessions); 722a6d42e7dSPeter Dunlap 723a6d42e7dSPeter Dunlap idm_refcnt_destroy(&iscsit_global.global_refcnt); 724a6d42e7dSPeter Dunlap 725a6d42e7dSPeter Dunlap return (retval); 726a6d42e7dSPeter Dunlap } 727a6d42e7dSPeter Dunlap 728a6d42e7dSPeter Dunlap /* 729a6d42e7dSPeter Dunlap * iscsit_disable_svc 730a6d42e7dSPeter Dunlap * 731a6d42e7dSPeter Dunlap * clean up all existing connections and deregister targets from STMF 732a6d42e7dSPeter Dunlap */ 733a6d42e7dSPeter Dunlap static void 734a6d42e7dSPeter Dunlap iscsit_disable_svc(void) 735a6d42e7dSPeter Dunlap { 736a6d42e7dSPeter Dunlap iscsit_sess_t *sess; 737a6d42e7dSPeter Dunlap 738a6d42e7dSPeter Dunlap ASSERT(iscsit_global.global_svc_state == ISE_DISABLING); 739a6d42e7dSPeter Dunlap 740a6d42e7dSPeter Dunlap /* tear down discovery sessions */ 741a6d42e7dSPeter Dunlap for (sess = avl_first(&iscsit_global.global_discovery_sessions); 742a6d42e7dSPeter Dunlap sess != NULL; 743a6d42e7dSPeter Dunlap sess = AVL_NEXT(&iscsit_global.global_discovery_sessions, sess)) 744a6d42e7dSPeter Dunlap iscsit_sess_close(sess); 745a6d42e7dSPeter Dunlap 746a6d42e7dSPeter Dunlap /* 747a6d42e7dSPeter Dunlap * Passing NULL to iscsit_config_merge tells it to go to an empty 748a6d42e7dSPeter Dunlap * config. 749a6d42e7dSPeter Dunlap */ 750a6d42e7dSPeter Dunlap (void) iscsit_config_merge(NULL); 751a6d42e7dSPeter Dunlap 752a6d42e7dSPeter Dunlap /* 753a6d42e7dSPeter Dunlap * Wait until there are no more global references 754a6d42e7dSPeter Dunlap */ 755a6d42e7dSPeter Dunlap idm_refcnt_wait_ref(&iscsit_global.global_refcnt); 756a6d42e7dSPeter Dunlap idm_refcnt_destroy(&iscsit_global.global_refcnt); 757a6d42e7dSPeter Dunlap 758a6d42e7dSPeter Dunlap /* 759a6d42e7dSPeter Dunlap * Default TPG must be destroyed after global_refcnt is 0. 760a6d42e7dSPeter Dunlap */ 761a6d42e7dSPeter Dunlap iscsit_tpg_destroydefault(iscsit_global.global_default_tpg); 762a6d42e7dSPeter Dunlap 763a6d42e7dSPeter Dunlap avl_destroy(&iscsit_global.global_discovery_sessions); 764a6d42e7dSPeter Dunlap list_destroy(&iscsit_global.global_deleted_target_list); 765a6d42e7dSPeter Dunlap avl_destroy(&iscsit_global.global_target_list); 766a6d42e7dSPeter Dunlap avl_destroy(&iscsit_global.global_tpg_list); 767a6d42e7dSPeter Dunlap avl_destroy(&iscsit_global.global_ini_list); 768a6d42e7dSPeter Dunlap 769a6d42e7dSPeter Dunlap taskq_destroy(iscsit_global.global_dispatch_taskq); 770a6d42e7dSPeter Dunlap 771a6d42e7dSPeter Dunlap iscsit_isns_fini(); 772a6d42e7dSPeter Dunlap 773a6d42e7dSPeter Dunlap stmf_free(iscsit_global.global_dbuf_store); 774a6d42e7dSPeter Dunlap iscsit_global.global_dbuf_store = NULL; 775a6d42e7dSPeter Dunlap 776a6d42e7dSPeter Dunlap (void) stmf_deregister_port_provider(iscsit_global.global_pp); 777a6d42e7dSPeter Dunlap stmf_free(iscsit_global.global_pp); 778a6d42e7dSPeter Dunlap iscsit_global.global_pp = NULL; 779a6d42e7dSPeter Dunlap 780a6d42e7dSPeter Dunlap kmem_cache_destroy(iscsit_status_pdu_cache); 781a6d42e7dSPeter Dunlap iscsit_status_pdu_cache = NULL; 782a6d42e7dSPeter Dunlap 783a6d42e7dSPeter Dunlap vmem_destroy(iscsit_global.global_tsih_pool); 784a6d42e7dSPeter Dunlap iscsit_global.global_tsih_pool = NULL; 785a6d42e7dSPeter Dunlap } 786a6d42e7dSPeter Dunlap 787a6d42e7dSPeter Dunlap void 788a6d42e7dSPeter Dunlap iscsit_global_hold() 789a6d42e7dSPeter Dunlap { 790a6d42e7dSPeter Dunlap idm_refcnt_hold(&iscsit_global.global_refcnt); 791a6d42e7dSPeter Dunlap } 792a6d42e7dSPeter Dunlap 793a6d42e7dSPeter Dunlap void 794a6d42e7dSPeter Dunlap iscsit_global_rele() 795a6d42e7dSPeter Dunlap { 796a6d42e7dSPeter Dunlap idm_refcnt_rele(&iscsit_global.global_refcnt); 797a6d42e7dSPeter Dunlap } 798a6d42e7dSPeter Dunlap 799a6d42e7dSPeter Dunlap void 800a6d42e7dSPeter Dunlap iscsit_global_wait_ref() 801a6d42e7dSPeter Dunlap { 802a6d42e7dSPeter Dunlap idm_refcnt_wait_ref(&iscsit_global.global_refcnt); 803a6d42e7dSPeter Dunlap } 804a6d42e7dSPeter Dunlap 805a6d42e7dSPeter Dunlap /* 806a6d42e7dSPeter Dunlap * IDM callbacks 807a6d42e7dSPeter Dunlap */ 808a6d42e7dSPeter Dunlap 809a6d42e7dSPeter Dunlap /*ARGSUSED*/ 810a6d42e7dSPeter Dunlap void 811a6d42e7dSPeter Dunlap iscsit_rx_pdu(idm_conn_t *ic, idm_pdu_t *rx_pdu) 812a6d42e7dSPeter Dunlap { 813a6d42e7dSPeter Dunlap iscsit_conn_t *ict = ic->ic_handle; 814a6d42e7dSPeter Dunlap switch (IDM_PDU_OPCODE(rx_pdu)) { 815a6d42e7dSPeter Dunlap case ISCSI_OP_SCSI_CMD: 816a6d42e7dSPeter Dunlap ASSERT(0); /* Shouldn't happen */ 817a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 818a6d42e7dSPeter Dunlap break; 819a6d42e7dSPeter Dunlap case ISCSI_OP_SNACK_CMD: 820a6d42e7dSPeter Dunlap /* 821a6d42e7dSPeter Dunlap * We'll need to handle this when we support ERL1/2. For 822a6d42e7dSPeter Dunlap * now we treat it as a protocol error. 823a6d42e7dSPeter Dunlap */ 824a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 825a6d42e7dSPeter Dunlap idm_conn_event(ic, CE_TRANSPORT_FAIL, NULL); 826a6d42e7dSPeter Dunlap break; 827a6d42e7dSPeter Dunlap case ISCSI_OP_SCSI_TASK_MGT_MSG: 828a6d42e7dSPeter Dunlap iscsit_set_cmdsn(ict, rx_pdu); 829a6d42e7dSPeter Dunlap iscsit_op_scsi_task_mgmt(ict, rx_pdu); 830a6d42e7dSPeter Dunlap break; 831a6d42e7dSPeter Dunlap case ISCSI_OP_NOOP_OUT: 832a6d42e7dSPeter Dunlap case ISCSI_OP_LOGIN_CMD: 833a6d42e7dSPeter Dunlap case ISCSI_OP_TEXT_CMD: 834a6d42e7dSPeter Dunlap case ISCSI_OP_LOGOUT_CMD: 835a6d42e7dSPeter Dunlap /* 836a6d42e7dSPeter Dunlap * If/when we switch to userland processing these PDU's 837a6d42e7dSPeter Dunlap * will be handled by iscsitd. 838a6d42e7dSPeter Dunlap */ 839a6d42e7dSPeter Dunlap iscsit_deferred_dispatch(rx_pdu); 840a6d42e7dSPeter Dunlap break; 841a6d42e7dSPeter Dunlap default: 842a6d42e7dSPeter Dunlap /* Protocol error */ 843a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 844a6d42e7dSPeter Dunlap idm_conn_event(ic, CE_TRANSPORT_FAIL, NULL); 845a6d42e7dSPeter Dunlap break; 846a6d42e7dSPeter Dunlap } 847a6d42e7dSPeter Dunlap } 848a6d42e7dSPeter Dunlap 849a6d42e7dSPeter Dunlap /*ARGSUSED*/ 850a6d42e7dSPeter Dunlap void 851a6d42e7dSPeter Dunlap iscsit_rx_pdu_error(idm_conn_t *ic, idm_pdu_t *rx_pdu, idm_status_t status) 852a6d42e7dSPeter Dunlap { 853a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 854a6d42e7dSPeter Dunlap } 855a6d42e7dSPeter Dunlap 856a6d42e7dSPeter Dunlap void 857a6d42e7dSPeter Dunlap iscsit_task_aborted(idm_task_t *idt, idm_status_t status) 858a6d42e7dSPeter Dunlap { 859a6d42e7dSPeter Dunlap iscsit_task_t *itask = idt->idt_private; 860a6d42e7dSPeter Dunlap 861a6d42e7dSPeter Dunlap switch (status) { 862a6d42e7dSPeter Dunlap case IDM_STATUS_SUSPENDED: 863a6d42e7dSPeter Dunlap break; 864a6d42e7dSPeter Dunlap case IDM_STATUS_ABORTED: 865a6d42e7dSPeter Dunlap mutex_enter(&itask->it_mutex); 866a6d42e7dSPeter Dunlap itask->it_aborted = B_TRUE; 867bf604c64SPeter Dunlap /* 868bf604c64SPeter Dunlap * We rely on the fact that STMF tracks outstanding 869bf604c64SPeter Dunlap * buffer transfers and will free all of our buffers 870bf604c64SPeter Dunlap * before freeing the task so we don't need to 871bf604c64SPeter Dunlap * explicitly free the buffers from iscsit/idm 872bf604c64SPeter Dunlap */ 873a6d42e7dSPeter Dunlap if (itask->it_stmf_abort) { 874a6d42e7dSPeter Dunlap mutex_exit(&itask->it_mutex); 87572cf3143Speter dunlap /* 87672cf3143Speter dunlap * Task is no longer active 87772cf3143Speter dunlap */ 87872cf3143Speter dunlap iscsit_task_done(itask); 87972cf3143Speter dunlap 880a6d42e7dSPeter Dunlap /* 881bf604c64SPeter Dunlap * STMF has already asked for this task to be aborted 882bf604c64SPeter Dunlap * 883a6d42e7dSPeter Dunlap * STMF specification is wrong... says to return 884a6d42e7dSPeter Dunlap * STMF_ABORTED, the code actually looks for 885a6d42e7dSPeter Dunlap * STMF_ABORT_SUCCESS. 886a6d42e7dSPeter Dunlap */ 887a6d42e7dSPeter Dunlap stmf_task_lport_aborted(itask->it_stmf_task, 888a6d42e7dSPeter Dunlap STMF_ABORT_SUCCESS, STMF_IOF_LPORT_DONE); 889a6d42e7dSPeter Dunlap return; 890a6d42e7dSPeter Dunlap } else { 891a6d42e7dSPeter Dunlap mutex_exit(&itask->it_mutex); 892a6d42e7dSPeter Dunlap /* 893bf604c64SPeter Dunlap * Tell STMF to stop processing the task. 894a6d42e7dSPeter Dunlap */ 895a6d42e7dSPeter Dunlap stmf_abort(STMF_QUEUE_TASK_ABORT, itask->it_stmf_task, 896a6d42e7dSPeter Dunlap STMF_ABORTED, NULL); 897a6d42e7dSPeter Dunlap return; 898a6d42e7dSPeter Dunlap } 899a6d42e7dSPeter Dunlap /*NOTREACHED*/ 900a6d42e7dSPeter Dunlap default: 901a6d42e7dSPeter Dunlap ASSERT(0); 902a6d42e7dSPeter Dunlap } 903a6d42e7dSPeter Dunlap } 904a6d42e7dSPeter Dunlap 905a6d42e7dSPeter Dunlap /*ARGSUSED*/ 906a6d42e7dSPeter Dunlap idm_status_t 907a6d42e7dSPeter Dunlap iscsit_client_notify(idm_conn_t *ic, idm_client_notify_t icn, 908a6d42e7dSPeter Dunlap uintptr_t data) 909a6d42e7dSPeter Dunlap { 910a6d42e7dSPeter Dunlap idm_status_t rc = IDM_STATUS_SUCCESS; 911a6d42e7dSPeter Dunlap 912a6d42e7dSPeter Dunlap /* 913a6d42e7dSPeter Dunlap * IDM client notifications will never occur at interrupt level 914a6d42e7dSPeter Dunlap * since they are generated from the connection state machine which 915a6d42e7dSPeter Dunlap * running on taskq threads. 916a6d42e7dSPeter Dunlap * 917a6d42e7dSPeter Dunlap */ 918a6d42e7dSPeter Dunlap switch (icn) { 919a6d42e7dSPeter Dunlap case CN_CONNECT_ACCEPT: 920a6d42e7dSPeter Dunlap rc = iscsit_conn_accept(ic); /* No data */ 921a6d42e7dSPeter Dunlap break; 922a6d42e7dSPeter Dunlap case CN_FFP_ENABLED: 923a6d42e7dSPeter Dunlap rc = iscsit_ffp_enabled(ic); /* No data */ 924a6d42e7dSPeter Dunlap break; 925a6d42e7dSPeter Dunlap case CN_FFP_DISABLED: 926a6d42e7dSPeter Dunlap /* 927a6d42e7dSPeter Dunlap * Data indicates whether this was the result of an 928a6d42e7dSPeter Dunlap * explicit logout request. 929a6d42e7dSPeter Dunlap */ 930a6d42e7dSPeter Dunlap rc = iscsit_ffp_disabled(ic, (idm_ffp_disable_t)data); 931a6d42e7dSPeter Dunlap break; 932a6d42e7dSPeter Dunlap case CN_CONNECT_LOST: 933a6d42e7dSPeter Dunlap rc = iscsit_conn_lost(ic); 934a6d42e7dSPeter Dunlap break; 935a6d42e7dSPeter Dunlap case CN_CONNECT_DESTROY: 936a6d42e7dSPeter Dunlap rc = iscsit_conn_destroy(ic); 937a6d42e7dSPeter Dunlap break; 938a6d42e7dSPeter Dunlap case CN_LOGIN_FAIL: 939a6d42e7dSPeter Dunlap /* 940a6d42e7dSPeter Dunlap * Force the login state machine to completion 941a6d42e7dSPeter Dunlap */ 942a6d42e7dSPeter Dunlap rc = iscsit_login_fail(ic); 943a6d42e7dSPeter Dunlap break; 944a6d42e7dSPeter Dunlap default: 945a6d42e7dSPeter Dunlap rc = IDM_STATUS_REJECT; 946a6d42e7dSPeter Dunlap break; 947a6d42e7dSPeter Dunlap } 948a6d42e7dSPeter Dunlap 949a6d42e7dSPeter Dunlap return (rc); 950a6d42e7dSPeter Dunlap } 951a6d42e7dSPeter Dunlap 952a6d42e7dSPeter Dunlap 953a6d42e7dSPeter Dunlap void 954a6d42e7dSPeter Dunlap iscsit_build_hdr(idm_task_t *idm_task, idm_pdu_t *pdu, uint8_t opcode) 955a6d42e7dSPeter Dunlap { 956a6d42e7dSPeter Dunlap iscsit_task_t *itask = idm_task->idt_private; 957a6d42e7dSPeter Dunlap iscsi_data_rsp_hdr_t *dh = (iscsi_data_rsp_hdr_t *)pdu->isp_hdr; 958a6d42e7dSPeter Dunlap 959a6d42e7dSPeter Dunlap /* 960a6d42e7dSPeter Dunlap * We acquired iscsit_sess_t.ist_sn_rwlock in iscsit_xfer_scsi_data 961a6d42e7dSPeter Dunlap * in reader mode so we expect to be locked here 962a6d42e7dSPeter Dunlap */ 963a6d42e7dSPeter Dunlap 964a6d42e7dSPeter Dunlap /* 965a6d42e7dSPeter Dunlap * Lun is only required if the opcode == ISCSI_OP_SCSI_DATA_RSP 966a6d42e7dSPeter Dunlap * and the 'A' bit is to be set 967a6d42e7dSPeter Dunlap */ 968a6d42e7dSPeter Dunlap dh->opcode = opcode; 969a6d42e7dSPeter Dunlap dh->itt = itask->it_itt; 970a6d42e7dSPeter Dunlap dh->ttt = itask->it_ttt; 9711050fd6dSJames Moore /* Maintain current statsn for RTT responses */ 9721050fd6dSJames Moore dh->statsn = (opcode == ISCSI_OP_RTT_RSP) ? 9731050fd6dSJames Moore htonl(itask->it_ict->ict_statsn) : 0; 974a6d42e7dSPeter Dunlap dh->expcmdsn = htonl(itask->it_ict->ict_sess->ist_expcmdsn); 975a6d42e7dSPeter Dunlap dh->maxcmdsn = htonl(itask->it_ict->ict_sess->ist_maxcmdsn); 976a6d42e7dSPeter Dunlap 977a6d42e7dSPeter Dunlap /* 978a6d42e7dSPeter Dunlap * IDM must set: 979a6d42e7dSPeter Dunlap * 980a6d42e7dSPeter Dunlap * data.flags and rtt.flags 981a6d42e7dSPeter Dunlap * data.dlength 982a6d42e7dSPeter Dunlap * data.datasn 983a6d42e7dSPeter Dunlap * data.offset 984a6d42e7dSPeter Dunlap * residual_count and cmd_status (if we ever implement phase collapse) 985a6d42e7dSPeter Dunlap * rtt.rttsn 986a6d42e7dSPeter Dunlap * rtt.data_offset 987a6d42e7dSPeter Dunlap * rtt.data_length 988a6d42e7dSPeter Dunlap */ 989a6d42e7dSPeter Dunlap } 990a6d42e7dSPeter Dunlap 99172cf3143Speter dunlap void 99272cf3143Speter dunlap iscsit_keepalive(idm_conn_t *ic) 99372cf3143Speter dunlap { 99472cf3143Speter dunlap idm_pdu_t *nop_in_pdu; 99572cf3143Speter dunlap iscsi_nop_in_hdr_t *nop_in; 99672cf3143Speter dunlap iscsit_conn_t *ict = ic->ic_handle; 99772cf3143Speter dunlap 99872cf3143Speter dunlap /* 99972cf3143Speter dunlap * IDM noticed the connection has been idle for too long so it's 100072cf3143Speter dunlap * time to provoke some activity. Build and transmit an iSCSI 100172cf3143Speter dunlap * nop-in PDU -- when the initiator responds it will be counted 100272cf3143Speter dunlap * as "activity" and keep the connection alive. 100372cf3143Speter dunlap * 100472cf3143Speter dunlap * We don't actually care about the response here at the iscsit level 100572cf3143Speter dunlap * so we will just throw it away without looking at it when it arrives. 100672cf3143Speter dunlap */ 100772cf3143Speter dunlap nop_in_pdu = idm_pdu_alloc(sizeof (*nop_in), 0); 100872cf3143Speter dunlap idm_pdu_init(nop_in_pdu, ic, NULL, NULL); 100972cf3143Speter dunlap 101072cf3143Speter dunlap nop_in = (iscsi_nop_in_hdr_t *)nop_in_pdu->isp_hdr; 101172cf3143Speter dunlap bzero(nop_in, sizeof (*nop_in)); 101272cf3143Speter dunlap nop_in->opcode = ISCSI_OP_NOOP_IN; 101372cf3143Speter dunlap nop_in->flags = ISCSI_FLAG_FINAL; 101472cf3143Speter dunlap nop_in->itt = ISCSI_RSVD_TASK_TAG; 101572cf3143Speter dunlap /* 101672cf3143Speter dunlap * This works because we don't currently allocate ttt's anywhere else 101772cf3143Speter dunlap * in iscsit so as long as we stay out of IDM's range we are safe. 101872cf3143Speter dunlap * If we need to allocate ttt's for other PDU's in the future this will 101972cf3143Speter dunlap * need to be improved. 102072cf3143Speter dunlap */ 102172cf3143Speter dunlap mutex_enter(&ict->ict_mutex); 102272cf3143Speter dunlap nop_in->ttt = ict->ict_keepalive_ttt; 102372cf3143Speter dunlap ict->ict_keepalive_ttt++; 102472cf3143Speter dunlap if (ict->ict_keepalive_ttt == ISCSI_RSVD_TASK_TAG) 102572cf3143Speter dunlap ict->ict_keepalive_ttt = IDM_TASKIDS_MAX; 102672cf3143Speter dunlap mutex_exit(&ict->ict_mutex); 102772cf3143Speter dunlap 102872cf3143Speter dunlap iscsit_pdu_tx(nop_in_pdu); 102972cf3143Speter dunlap } 103072cf3143Speter dunlap 1031a6d42e7dSPeter Dunlap static idm_status_t 1032a6d42e7dSPeter Dunlap iscsit_conn_accept(idm_conn_t *ic) 1033a6d42e7dSPeter Dunlap { 1034a6d42e7dSPeter Dunlap iscsit_conn_t *ict; 1035a6d42e7dSPeter Dunlap 103630e7468fSPeter Dunlap /* 103730e7468fSPeter Dunlap * We need to get a global hold here to ensure that the service 103830e7468fSPeter Dunlap * doesn't get shutdown prior to establishing a session. This 103930e7468fSPeter Dunlap * gets released in iscsit_conn_destroy(). 104030e7468fSPeter Dunlap */ 1041e42a0851Speter dunlap ISCSIT_GLOBAL_LOCK(RW_READER); 1042e42a0851Speter dunlap if (iscsit_global.global_svc_state != ISE_ENABLED) { 1043e42a0851Speter dunlap ISCSIT_GLOBAL_UNLOCK(); 1044e42a0851Speter dunlap return (IDM_STATUS_FAIL); 1045e42a0851Speter dunlap } 104630e7468fSPeter Dunlap iscsit_global_hold(); 1047e42a0851Speter dunlap ISCSIT_GLOBAL_UNLOCK(); 104830e7468fSPeter Dunlap 1049a6d42e7dSPeter Dunlap /* 1050a6d42e7dSPeter Dunlap * Allocate an associated iscsit structure to represent this 1051a6d42e7dSPeter Dunlap * connection. We shouldn't really create a session until we 1052a6d42e7dSPeter Dunlap * get the first login PDU. 1053a6d42e7dSPeter Dunlap */ 1054a6d42e7dSPeter Dunlap ict = kmem_zalloc(sizeof (*ict), KM_SLEEP); 1055a6d42e7dSPeter Dunlap 1056a6d42e7dSPeter Dunlap ict->ict_ic = ic; 1057a6d42e7dSPeter Dunlap ict->ict_statsn = 1; 105872cf3143Speter dunlap ict->ict_keepalive_ttt = IDM_TASKIDS_MAX; /* Avoid IDM TT range */ 1059a6d42e7dSPeter Dunlap ic->ic_handle = ict; 1060a6d42e7dSPeter Dunlap mutex_init(&ict->ict_mutex, NULL, MUTEX_DRIVER, NULL); 1061a6d42e7dSPeter Dunlap idm_refcnt_init(&ict->ict_refcnt, ict); 1062a6d42e7dSPeter Dunlap 1063a6d42e7dSPeter Dunlap /* 1064a6d42e7dSPeter Dunlap * Initialize login state machine 1065a6d42e7dSPeter Dunlap */ 1066a6d42e7dSPeter Dunlap if (iscsit_login_sm_init(ict) != IDM_STATUS_SUCCESS) { 1067e42a0851Speter dunlap iscsit_global_rele(); 10684142b486SJames Moore /* 10694142b486SJames Moore * Cleanup the ict after idm notifies us about this failure 10704142b486SJames Moore */ 1071a6d42e7dSPeter Dunlap return (IDM_STATUS_FAIL); 1072a6d42e7dSPeter Dunlap } 1073a6d42e7dSPeter Dunlap 1074a6d42e7dSPeter Dunlap return (IDM_STATUS_SUCCESS); 1075a6d42e7dSPeter Dunlap } 1076a6d42e7dSPeter Dunlap 1077a6d42e7dSPeter Dunlap idm_status_t 1078a6d42e7dSPeter Dunlap iscsit_conn_reinstate(iscsit_conn_t *reinstate_ict, iscsit_conn_t *new_ict) 1079a6d42e7dSPeter Dunlap { 1080a6d42e7dSPeter Dunlap idm_status_t result; 1081a6d42e7dSPeter Dunlap 1082a6d42e7dSPeter Dunlap /* 1083a6d42e7dSPeter Dunlap * Note in new connection state that this connection is 1084a6d42e7dSPeter Dunlap * reinstating an existing connection. 1085a6d42e7dSPeter Dunlap */ 1086a6d42e7dSPeter Dunlap new_ict->ict_reinstating = B_TRUE; 1087a6d42e7dSPeter Dunlap new_ict->ict_reinstate_conn = reinstate_ict; 1088a6d42e7dSPeter Dunlap new_ict->ict_statsn = reinstate_ict->ict_statsn; 1089a6d42e7dSPeter Dunlap 1090a6d42e7dSPeter Dunlap /* 1091a6d42e7dSPeter Dunlap * Now generate connection state machine event to existing connection 1092a6d42e7dSPeter Dunlap * so that it starts the cleanup process. 1093a6d42e7dSPeter Dunlap */ 1094a6d42e7dSPeter Dunlap result = idm_conn_reinstate_event(reinstate_ict->ict_ic, 1095a6d42e7dSPeter Dunlap new_ict->ict_ic); 1096a6d42e7dSPeter Dunlap 1097a6d42e7dSPeter Dunlap return (result); 1098a6d42e7dSPeter Dunlap } 1099a6d42e7dSPeter Dunlap 1100a6d42e7dSPeter Dunlap void 1101a6d42e7dSPeter Dunlap iscsit_conn_hold(iscsit_conn_t *ict) 1102a6d42e7dSPeter Dunlap { 1103a6d42e7dSPeter Dunlap idm_refcnt_hold(&ict->ict_refcnt); 1104a6d42e7dSPeter Dunlap } 1105a6d42e7dSPeter Dunlap 1106a6d42e7dSPeter Dunlap void 1107a6d42e7dSPeter Dunlap iscsit_conn_rele(iscsit_conn_t *ict) 1108a6d42e7dSPeter Dunlap { 1109a6d42e7dSPeter Dunlap idm_refcnt_rele(&ict->ict_refcnt); 1110a6d42e7dSPeter Dunlap } 1111a6d42e7dSPeter Dunlap 1112a6d42e7dSPeter Dunlap void 1113a6d42e7dSPeter Dunlap iscsit_conn_dispatch_hold(iscsit_conn_t *ict) 1114a6d42e7dSPeter Dunlap { 1115a6d42e7dSPeter Dunlap idm_refcnt_hold(&ict->ict_dispatch_refcnt); 1116a6d42e7dSPeter Dunlap } 1117a6d42e7dSPeter Dunlap 1118a6d42e7dSPeter Dunlap void 1119a6d42e7dSPeter Dunlap iscsit_conn_dispatch_rele(iscsit_conn_t *ict) 1120a6d42e7dSPeter Dunlap { 1121a6d42e7dSPeter Dunlap idm_refcnt_rele(&ict->ict_dispatch_refcnt); 1122a6d42e7dSPeter Dunlap } 1123a6d42e7dSPeter Dunlap 1124a6d42e7dSPeter Dunlap static idm_status_t 1125a6d42e7dSPeter Dunlap iscsit_login_fail(idm_conn_t *ic) 1126a6d42e7dSPeter Dunlap { 1127a6d42e7dSPeter Dunlap iscsit_conn_t *ict = ic->ic_handle; 1128a6d42e7dSPeter Dunlap 1129a6d42e7dSPeter Dunlap /* Generate login state machine event */ 1130a6d42e7dSPeter Dunlap iscsit_login_sm_event(ict, ILE_LOGIN_CONN_ERROR, NULL); 1131a6d42e7dSPeter Dunlap 1132a6d42e7dSPeter Dunlap return (IDM_STATUS_SUCCESS); 1133a6d42e7dSPeter Dunlap } 1134a6d42e7dSPeter Dunlap 1135a6d42e7dSPeter Dunlap static idm_status_t 1136a6d42e7dSPeter Dunlap iscsit_ffp_enabled(idm_conn_t *ic) 1137a6d42e7dSPeter Dunlap { 1138a6d42e7dSPeter Dunlap iscsit_conn_t *ict = ic->ic_handle; 1139a6d42e7dSPeter Dunlap 1140a6d42e7dSPeter Dunlap /* Generate session state machine event */ 1141a6d42e7dSPeter Dunlap iscsit_sess_sm_event(ict->ict_sess, SE_CONN_LOGGED_IN, ict); 1142a6d42e7dSPeter Dunlap 1143a6d42e7dSPeter Dunlap return (IDM_STATUS_SUCCESS); 1144a6d42e7dSPeter Dunlap } 1145a6d42e7dSPeter Dunlap 1146a6d42e7dSPeter Dunlap static idm_status_t 1147a6d42e7dSPeter Dunlap iscsit_ffp_disabled(idm_conn_t *ic, idm_ffp_disable_t disable_class) 1148a6d42e7dSPeter Dunlap { 1149a6d42e7dSPeter Dunlap iscsit_conn_t *ict = ic->ic_handle; 1150a6d42e7dSPeter Dunlap 1151a6d42e7dSPeter Dunlap /* Generate session state machine event */ 1152a6d42e7dSPeter Dunlap switch (disable_class) { 1153a6d42e7dSPeter Dunlap case FD_CONN_FAIL: 1154a6d42e7dSPeter Dunlap iscsit_sess_sm_event(ict->ict_sess, SE_CONN_FFP_FAIL, ict); 1155a6d42e7dSPeter Dunlap break; 1156a6d42e7dSPeter Dunlap case FD_CONN_LOGOUT: 1157a6d42e7dSPeter Dunlap iscsit_sess_sm_event(ict->ict_sess, SE_CONN_FFP_DISABLE, ict); 1158a6d42e7dSPeter Dunlap break; 1159a6d42e7dSPeter Dunlap case FD_SESS_LOGOUT: 1160a6d42e7dSPeter Dunlap iscsit_sess_sm_event(ict->ict_sess, SE_SESSION_CLOSE, ict); 1161a6d42e7dSPeter Dunlap break; 1162a6d42e7dSPeter Dunlap default: 1163a6d42e7dSPeter Dunlap ASSERT(0); 1164a6d42e7dSPeter Dunlap } 1165a6d42e7dSPeter Dunlap 1166a6d42e7dSPeter Dunlap return (IDM_STATUS_SUCCESS); 1167a6d42e7dSPeter Dunlap } 1168a6d42e7dSPeter Dunlap 1169a6d42e7dSPeter Dunlap static idm_status_t 1170a6d42e7dSPeter Dunlap iscsit_conn_lost(idm_conn_t *ic) 1171a6d42e7dSPeter Dunlap { 1172a6d42e7dSPeter Dunlap iscsit_conn_t *ict = ic->ic_handle; 1173a6d42e7dSPeter Dunlap 1174a6d42e7dSPeter Dunlap mutex_enter(&ict->ict_mutex); 1175a6d42e7dSPeter Dunlap ict->ict_lost = B_TRUE; 1176a6d42e7dSPeter Dunlap mutex_exit(&ict->ict_mutex); 1177a6d42e7dSPeter Dunlap 1178a6d42e7dSPeter Dunlap /* 1179a6d42e7dSPeter Dunlap * Make sure there aren't any PDU's transitioning from the receive 1180a6d42e7dSPeter Dunlap * handler to the dispatch taskq. 1181a6d42e7dSPeter Dunlap */ 1182a6d42e7dSPeter Dunlap idm_refcnt_wait_ref(&ict->ict_dispatch_refcnt); 1183a6d42e7dSPeter Dunlap 1184a6d42e7dSPeter Dunlap return (IDM_STATUS_SUCCESS); 1185a6d42e7dSPeter Dunlap } 1186a6d42e7dSPeter Dunlap 1187a6d42e7dSPeter Dunlap static idm_status_t 1188a6d42e7dSPeter Dunlap iscsit_conn_destroy(idm_conn_t *ic) 1189a6d42e7dSPeter Dunlap { 1190a6d42e7dSPeter Dunlap iscsit_conn_t *ict = ic->ic_handle; 1191a6d42e7dSPeter Dunlap 1192a6d42e7dSPeter Dunlap mutex_enter(&ict->ict_mutex); 1193a6d42e7dSPeter Dunlap ict->ict_destroyed = B_TRUE; 1194a6d42e7dSPeter Dunlap mutex_exit(&ict->ict_mutex); 1195a6d42e7dSPeter Dunlap 1196a6d42e7dSPeter Dunlap /* Generate session state machine event */ 1197a6d42e7dSPeter Dunlap if (ict->ict_sess != NULL) { 1198a6d42e7dSPeter Dunlap /* 1199a6d42e7dSPeter Dunlap * Session state machine will call iscsit_conn_destroy_done() 1200a6d42e7dSPeter Dunlap * when it has removed references to this connection. 1201a6d42e7dSPeter Dunlap */ 1202a6d42e7dSPeter Dunlap iscsit_sess_sm_event(ict->ict_sess, SE_CONN_FAIL, ict); 1203a6d42e7dSPeter Dunlap } 1204a6d42e7dSPeter Dunlap 1205a6d42e7dSPeter Dunlap ict->ict_ic = NULL; 1206a6d42e7dSPeter Dunlap 1207a6d42e7dSPeter Dunlap idm_refcnt_wait_ref(&ict->ict_refcnt); 1208a6d42e7dSPeter Dunlap 12094142b486SJames Moore /* Reap the login state machine */ 12104142b486SJames Moore iscsit_login_sm_fini(ict); 12114142b486SJames Moore 12124142b486SJames Moore /* Clean up any text command remnants */ 12134142b486SJames Moore iscsit_text_cmd_fini(ict); 12144142b486SJames Moore 1215a6d42e7dSPeter Dunlap mutex_destroy(&ict->ict_mutex); 1216a6d42e7dSPeter Dunlap idm_refcnt_destroy(&ict->ict_refcnt); 1217a6d42e7dSPeter Dunlap kmem_free(ict, sizeof (*ict)); 1218a6d42e7dSPeter Dunlap 121930e7468fSPeter Dunlap iscsit_global_rele(); 122030e7468fSPeter Dunlap 1221a6d42e7dSPeter Dunlap return (IDM_STATUS_SUCCESS); 1222a6d42e7dSPeter Dunlap } 1223a6d42e7dSPeter Dunlap 1224a6d42e7dSPeter Dunlap /* 1225a6d42e7dSPeter Dunlap * STMF-related functions 1226a6d42e7dSPeter Dunlap * 1227a6d42e7dSPeter Dunlap * iSCSI to STMF mapping 1228a6d42e7dSPeter Dunlap * 1229a6d42e7dSPeter Dunlap * Session == ? 1230a6d42e7dSPeter Dunlap * Connection == bound to local port but not itself a local port 1231a6d42e7dSPeter Dunlap * Target 1232a6d42e7dSPeter Dunlap * Target portal (group?) == local port (really but we're not going to do this) 1233a6d42e7dSPeter Dunlap * iscsit needs to map connections to local ports (whatever we decide 1234a6d42e7dSPeter Dunlap * they are) 1235a6d42e7dSPeter Dunlap * Target == ? 1236a6d42e7dSPeter Dunlap */ 1237a6d42e7dSPeter Dunlap 1238a6d42e7dSPeter Dunlap /*ARGSUSED*/ 1239a6d42e7dSPeter Dunlap static stmf_data_buf_t * 1240a6d42e7dSPeter Dunlap iscsit_dbuf_alloc(scsi_task_t *task, uint32_t size, uint32_t *pminsize, 1241a6d42e7dSPeter Dunlap uint32_t flags) 1242a6d42e7dSPeter Dunlap { 1243a6d42e7dSPeter Dunlap iscsit_task_t *itask = task->task_port_private; 1244a6d42e7dSPeter Dunlap idm_buf_t *idm_buffer; 1245a6d42e7dSPeter Dunlap iscsit_buf_t *ibuf; 1246a6d42e7dSPeter Dunlap stmf_data_buf_t *result; 124726ec4a22SPriya Krishnan uint32_t bsize; 1248a6d42e7dSPeter Dunlap 1249a6d42e7dSPeter Dunlap /* 125001c0a610SPriya Krishnan * If the requested size is larger than MaxBurstLength and the 125101c0a610SPriya Krishnan * given pminsize is also larger than MaxBurstLength, then the 125201c0a610SPriya Krishnan * allocation fails (dbuf = NULL) and pminsize is modified to 125301c0a610SPriya Krishnan * be equal to MaxBurstLength. stmf/sbd then should re-invoke 125401c0a610SPriya Krishnan * this function with the corrected values for transfer. 1255a6d42e7dSPeter Dunlap */ 125626ec4a22SPriya Krishnan ASSERT(pminsize); 125701c0a610SPriya Krishnan if (size <= itask->it_ict->ict_op.op_max_burst_length) { 125801c0a610SPriya Krishnan bsize = size; 125901c0a610SPriya Krishnan } else if (*pminsize <= itask->it_ict->ict_op.op_max_burst_length) { 126001c0a610SPriya Krishnan bsize = itask->it_ict->ict_op.op_max_burst_length; 126101c0a610SPriya Krishnan } else { 1262a6d42e7dSPeter Dunlap *pminsize = itask->it_ict->ict_op.op_max_burst_length; 1263a6d42e7dSPeter Dunlap return (NULL); 1264a6d42e7dSPeter Dunlap } 1265a6d42e7dSPeter Dunlap 1266a6d42e7dSPeter Dunlap /* Alloc buffer */ 126726ec4a22SPriya Krishnan idm_buffer = idm_buf_alloc(itask->it_ict->ict_ic, NULL, bsize); 1268a6d42e7dSPeter Dunlap if (idm_buffer != NULL) { 1269a6d42e7dSPeter Dunlap result = stmf_alloc(STMF_STRUCT_DATA_BUF, 1270a6d42e7dSPeter Dunlap sizeof (iscsit_buf_t), 0); 1271a6d42e7dSPeter Dunlap if (result != NULL) { 1272a6d42e7dSPeter Dunlap /* Fill in stmf_data_buf_t */ 1273a6d42e7dSPeter Dunlap ibuf = result->db_port_private; 1274a6d42e7dSPeter Dunlap ibuf->ibuf_idm_buf = idm_buffer; 1275a6d42e7dSPeter Dunlap ibuf->ibuf_stmf_buf = result; 1276a6d42e7dSPeter Dunlap ibuf->ibuf_is_immed = B_FALSE; 1277a6d42e7dSPeter Dunlap result->db_flags = DB_DONT_CACHE; 127826ec4a22SPriya Krishnan result->db_buf_size = bsize; 127926ec4a22SPriya Krishnan result->db_data_size = bsize; 1280a6d42e7dSPeter Dunlap result->db_sglist_length = 1; 1281a6d42e7dSPeter Dunlap result->db_sglist[0].seg_addr = idm_buffer->idb_buf; 1282a6d42e7dSPeter Dunlap result->db_sglist[0].seg_length = 1283a6d42e7dSPeter Dunlap idm_buffer->idb_buflen; 1284a6d42e7dSPeter Dunlap return (result); 1285a6d42e7dSPeter Dunlap } 1286a6d42e7dSPeter Dunlap 1287a6d42e7dSPeter Dunlap /* Couldn't get the stmf_data_buf_t so free the buffer */ 1288a6d42e7dSPeter Dunlap idm_buf_free(idm_buffer); 1289a6d42e7dSPeter Dunlap } 1290a6d42e7dSPeter Dunlap 1291a6d42e7dSPeter Dunlap return (NULL); 1292a6d42e7dSPeter Dunlap } 1293a6d42e7dSPeter Dunlap 1294a6d42e7dSPeter Dunlap /*ARGSUSED*/ 1295a6d42e7dSPeter Dunlap static void 1296a6d42e7dSPeter Dunlap iscsit_dbuf_free(stmf_dbuf_store_t *ds, stmf_data_buf_t *dbuf) 1297a6d42e7dSPeter Dunlap { 1298a6d42e7dSPeter Dunlap iscsit_buf_t *ibuf = dbuf->db_port_private; 1299a6d42e7dSPeter Dunlap 1300a6d42e7dSPeter Dunlap if (ibuf->ibuf_is_immed) { 1301a6d42e7dSPeter Dunlap /* 1302a6d42e7dSPeter Dunlap * The iscsit_buf_t structure itself will be freed with its 1303a6d42e7dSPeter Dunlap * associated task. Here we just need to free the PDU that 1304a6d42e7dSPeter Dunlap * held the immediate data. 1305a6d42e7dSPeter Dunlap */ 1306a6d42e7dSPeter Dunlap idm_pdu_complete(ibuf->ibuf_immed_data_pdu, IDM_STATUS_SUCCESS); 1307a6d42e7dSPeter Dunlap ibuf->ibuf_immed_data_pdu = 0; 1308a6d42e7dSPeter Dunlap } else { 1309a6d42e7dSPeter Dunlap idm_buf_free(ibuf->ibuf_idm_buf); 1310a6d42e7dSPeter Dunlap stmf_free(dbuf); 1311a6d42e7dSPeter Dunlap } 1312a6d42e7dSPeter Dunlap } 1313a6d42e7dSPeter Dunlap 1314a6d42e7dSPeter Dunlap /*ARGSUSED*/ 1315a6d42e7dSPeter Dunlap stmf_status_t 1316a6d42e7dSPeter Dunlap iscsit_xfer_scsi_data(scsi_task_t *task, stmf_data_buf_t *dbuf, 1317a6d42e7dSPeter Dunlap uint32_t ioflags) 1318a6d42e7dSPeter Dunlap { 1319a6d42e7dSPeter Dunlap iscsit_task_t *iscsit_task = task->task_port_private; 1320a6d42e7dSPeter Dunlap iscsit_buf_t *ibuf = dbuf->db_port_private; 1321a6d42e7dSPeter Dunlap int idm_rc; 1322a6d42e7dSPeter Dunlap 1323bf604c64SPeter Dunlap /* 1324bf604c64SPeter Dunlap * If we are aborting then we can ignore this request 1325bf604c64SPeter Dunlap */ 1326bf604c64SPeter Dunlap if (iscsit_task->it_stmf_abort) { 1327bf604c64SPeter Dunlap return (STMF_SUCCESS); 1328bf604c64SPeter Dunlap } 1329bf604c64SPeter Dunlap 1330a6d42e7dSPeter Dunlap /* 1331a6d42e7dSPeter Dunlap * If it's not immediate data then start the transfer 1332a6d42e7dSPeter Dunlap */ 1333a6d42e7dSPeter Dunlap ASSERT(ibuf->ibuf_is_immed == B_FALSE); 1334a6d42e7dSPeter Dunlap if (dbuf->db_flags & DB_DIRECTION_TO_RPORT) { 1335a6d42e7dSPeter Dunlap /* 1336a6d42e7dSPeter Dunlap * IDM will call iscsit_build_hdr so lock now to serialize 1337a6d42e7dSPeter Dunlap * access to the SN values. We need to lock here to enforce 1338a6d42e7dSPeter Dunlap * lock ordering 1339a6d42e7dSPeter Dunlap */ 1340a6d42e7dSPeter Dunlap rw_enter(&iscsit_task->it_ict->ict_sess->ist_sn_rwlock, 1341a6d42e7dSPeter Dunlap RW_READER); 1342a6d42e7dSPeter Dunlap idm_rc = idm_buf_tx_to_ini(iscsit_task->it_idm_task, 1343a6d42e7dSPeter Dunlap ibuf->ibuf_idm_buf, dbuf->db_relative_offset, 1344a6d42e7dSPeter Dunlap dbuf->db_data_size, &iscsit_buf_xfer_cb, dbuf); 1345a6d42e7dSPeter Dunlap rw_exit(&iscsit_task->it_ict->ict_sess->ist_sn_rwlock); 1346a6d42e7dSPeter Dunlap 1347a6d42e7dSPeter Dunlap return (iscsit_idm_to_stmf(idm_rc)); 1348a6d42e7dSPeter Dunlap } else if (dbuf->db_flags & DB_DIRECTION_FROM_RPORT) { 1349a6d42e7dSPeter Dunlap /* Grab the SN lock (see comment above) */ 1350a6d42e7dSPeter Dunlap rw_enter(&iscsit_task->it_ict->ict_sess->ist_sn_rwlock, 1351a6d42e7dSPeter Dunlap RW_READER); 1352a6d42e7dSPeter Dunlap idm_rc = idm_buf_rx_from_ini(iscsit_task->it_idm_task, 1353a6d42e7dSPeter Dunlap ibuf->ibuf_idm_buf, dbuf->db_relative_offset, 1354a6d42e7dSPeter Dunlap dbuf->db_data_size, &iscsit_buf_xfer_cb, dbuf); 1355a6d42e7dSPeter Dunlap rw_exit(&iscsit_task->it_ict->ict_sess->ist_sn_rwlock); 1356a6d42e7dSPeter Dunlap 1357a6d42e7dSPeter Dunlap return (iscsit_idm_to_stmf(idm_rc)); 1358a6d42e7dSPeter Dunlap } 1359a6d42e7dSPeter Dunlap 1360a6d42e7dSPeter Dunlap /* What are we supposed to do if there is no direction? */ 1361a6d42e7dSPeter Dunlap return (STMF_INVALID_ARG); 1362a6d42e7dSPeter Dunlap } 1363a6d42e7dSPeter Dunlap 1364a6d42e7dSPeter Dunlap static void 1365a6d42e7dSPeter Dunlap iscsit_buf_xfer_cb(idm_buf_t *idb, idm_status_t status) 1366a6d42e7dSPeter Dunlap { 1367a6d42e7dSPeter Dunlap iscsit_task_t *itask = idb->idb_task_binding->idt_private; 1368a6d42e7dSPeter Dunlap stmf_data_buf_t *dbuf = idb->idb_cb_arg; 1369a6d42e7dSPeter Dunlap 1370a6d42e7dSPeter Dunlap dbuf->db_xfer_status = iscsit_idm_to_stmf(status); 1371a6d42e7dSPeter Dunlap 1372bf604c64SPeter Dunlap /* 1373bf604c64SPeter Dunlap * If the task has been aborted then we don't need to call STMF 1374bf604c64SPeter Dunlap */ 1375bf604c64SPeter Dunlap if (itask->it_stmf_abort) { 1376bf604c64SPeter Dunlap return; 1377bf604c64SPeter Dunlap } 1378bf604c64SPeter Dunlap 1379a6d42e7dSPeter Dunlap /* 1380a6d42e7dSPeter Dunlap * COMSTAR currently requires port providers to support 1381a6d42e7dSPeter Dunlap * the DB_SEND_STATUS_GOOD flag even if phase collapse is 1382a6d42e7dSPeter Dunlap * not supported. So we will roll our own... pretend we are 1383a6d42e7dSPeter Dunlap * COMSTAR and ask for a status PDU. 1384a6d42e7dSPeter Dunlap */ 1385a6d42e7dSPeter Dunlap if ((dbuf->db_flags & DB_SEND_STATUS_GOOD) && 1386a6d42e7dSPeter Dunlap status == IDM_STATUS_SUCCESS) { 1387a6d42e7dSPeter Dunlap /* 1388a6d42e7dSPeter Dunlap * If iscsit_send_scsi_status succeeds then the TX PDU 1389a6d42e7dSPeter Dunlap * callback will call stmf_send_status_done and set 1390a6d42e7dSPeter Dunlap * STMF_IOF_LPORT_DONE. Consequently we don't need 1391a6d42e7dSPeter Dunlap * to call stmf_data_xfer_done in that case. We 1392a6d42e7dSPeter Dunlap * still need to call it if we get a failure. 1393a6d42e7dSPeter Dunlap * 1394bf604c64SPeter Dunlap * To elaborate on this some more, upon successful 1395bf604c64SPeter Dunlap * return from iscsit_send_scsi_status it's possible 1396bf604c64SPeter Dunlap * that itask and idb have been freed and are no 1397bf604c64SPeter Dunlap * longer valid. 1398a6d42e7dSPeter Dunlap */ 1399a6d42e7dSPeter Dunlap if (iscsit_send_scsi_status(itask->it_stmf_task, 0) 140063528ae4SJames Moore != STMF_SUCCESS) { 1401a6d42e7dSPeter Dunlap /* Failed to send status */ 1402a6d42e7dSPeter Dunlap dbuf->db_xfer_status = STMF_FAILURE; 1403a6d42e7dSPeter Dunlap stmf_data_xfer_done(itask->it_stmf_task, dbuf, 1404a6d42e7dSPeter Dunlap STMF_IOF_LPORT_DONE); 1405a6d42e7dSPeter Dunlap } 1406a6d42e7dSPeter Dunlap } else { 1407a6d42e7dSPeter Dunlap stmf_data_xfer_done(itask->it_stmf_task, dbuf, 0); 1408a6d42e7dSPeter Dunlap } 1409a6d42e7dSPeter Dunlap } 1410a6d42e7dSPeter Dunlap 1411bf604c64SPeter Dunlap 1412a6d42e7dSPeter Dunlap /*ARGSUSED*/ 1413a6d42e7dSPeter Dunlap stmf_status_t 1414a6d42e7dSPeter Dunlap iscsit_send_scsi_status(scsi_task_t *task, uint32_t ioflags) 1415a6d42e7dSPeter Dunlap { 1416a6d42e7dSPeter Dunlap iscsit_task_t *itask = task->task_port_private; 1417a6d42e7dSPeter Dunlap iscsi_scsi_rsp_hdr_t *rsp; 1418a6d42e7dSPeter Dunlap idm_pdu_t *pdu; 1419a6d42e7dSPeter Dunlap int resp_datalen; 1420a6d42e7dSPeter Dunlap 1421a6d42e7dSPeter Dunlap /* 1422a6d42e7dSPeter Dunlap * If this task is aborted then we don't need to respond. 1423a6d42e7dSPeter Dunlap */ 1424a6d42e7dSPeter Dunlap if (itask->it_stmf_abort) { 1425a6d42e7dSPeter Dunlap return (STMF_SUCCESS); 1426a6d42e7dSPeter Dunlap } 1427a6d42e7dSPeter Dunlap 1428a6d42e7dSPeter Dunlap /* 1429a6d42e7dSPeter Dunlap * If this is a task management status, handle it elsewhere. 1430a6d42e7dSPeter Dunlap */ 1431a6d42e7dSPeter Dunlap if (task->task_mgmt_function != TM_NONE) { 1432a6d42e7dSPeter Dunlap /* 1433a6d42e7dSPeter Dunlap * Don't wait for the PDU completion to tell STMF 1434a6d42e7dSPeter Dunlap * the task is done -- it doesn't really matter and 1435a6d42e7dSPeter Dunlap * it makes life complicated if STMF later asks us to 1436a6d42e7dSPeter Dunlap * abort the request and we don't know whether the 1437a6d42e7dSPeter Dunlap * status has been sent or not. 1438a6d42e7dSPeter Dunlap */ 1439a6d42e7dSPeter Dunlap itask->it_tm_responded = B_TRUE; 1440a6d42e7dSPeter Dunlap iscsit_send_task_mgmt_resp(itask->it_tm_pdu, 1441a6d42e7dSPeter Dunlap (task->task_completion_status == STMF_SUCCESS) ? 1442a6d42e7dSPeter Dunlap SCSI_TCP_TM_RESP_COMPLETE : SCSI_TCP_TM_RESP_FUNC_NOT_SUPP); 1443a6d42e7dSPeter Dunlap stmf_send_status_done(task, STMF_SUCCESS, 1444a6d42e7dSPeter Dunlap STMF_IOF_LPORT_DONE); 1445a6d42e7dSPeter Dunlap return (STMF_SUCCESS); 1446a6d42e7dSPeter Dunlap } 1447a6d42e7dSPeter Dunlap 144872cf3143Speter dunlap /* 144972cf3143Speter dunlap * Remove the task from the session task list 145072cf3143Speter dunlap */ 145172cf3143Speter dunlap iscsit_task_done(itask); 145272cf3143Speter dunlap 145372cf3143Speter dunlap /* 145472cf3143Speter dunlap * Send status 145572cf3143Speter dunlap */ 1456a6d42e7dSPeter Dunlap mutex_enter(&itask->it_idm_task->idt_mutex); 1457a6d42e7dSPeter Dunlap if ((itask->it_idm_task->idt_state == TASK_ACTIVE) && 1458a6d42e7dSPeter Dunlap (task->task_completion_status == STMF_SUCCESS) && 1459a6d42e7dSPeter Dunlap (task->task_sense_length == 0) && 1460a6d42e7dSPeter Dunlap (task->task_resid == 0)) { 1461a6d42e7dSPeter Dunlap itask->it_idm_task->idt_state = TASK_COMPLETE; 1462a6d42e7dSPeter Dunlap /* PDU callback releases task hold */ 1463a6d42e7dSPeter Dunlap idm_task_hold(itask->it_idm_task); 1464a6d42e7dSPeter Dunlap mutex_exit(&itask->it_idm_task->idt_mutex); 1465a6d42e7dSPeter Dunlap /* 1466a6d42e7dSPeter Dunlap * Fast path. Cached status PDU's are already 1467a6d42e7dSPeter Dunlap * initialized. We just need to fill in 1468a6d42e7dSPeter Dunlap * connection and task information. 1469a6d42e7dSPeter Dunlap */ 1470a6d42e7dSPeter Dunlap pdu = kmem_cache_alloc(iscsit_status_pdu_cache, KM_SLEEP); 1471a6d42e7dSPeter Dunlap pdu->isp_ic = itask->it_ict->ict_ic; 1472a6d42e7dSPeter Dunlap pdu->isp_private = itask; 1473a6d42e7dSPeter Dunlap 1474a6d42e7dSPeter Dunlap rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr; 1475a6d42e7dSPeter Dunlap rsp->itt = itask->it_itt; 1476a6d42e7dSPeter Dunlap rsp->cmd_status = task->task_scsi_status; 1477a6d42e7dSPeter Dunlap iscsit_pdu_tx(pdu); 1478a6d42e7dSPeter Dunlap return (STMF_SUCCESS); 1479a6d42e7dSPeter Dunlap } else { 1480a6d42e7dSPeter Dunlap if (itask->it_idm_task->idt_state != TASK_ACTIVE) { 1481a6d42e7dSPeter Dunlap mutex_exit(&itask->it_idm_task->idt_mutex); 148263528ae4SJames Moore return (STMF_FAILURE); 1483a6d42e7dSPeter Dunlap } 1484a6d42e7dSPeter Dunlap itask->it_idm_task->idt_state = TASK_COMPLETE; 1485a6d42e7dSPeter Dunlap /* PDU callback releases task hold */ 1486a6d42e7dSPeter Dunlap idm_task_hold(itask->it_idm_task); 1487a6d42e7dSPeter Dunlap mutex_exit(&itask->it_idm_task->idt_mutex); 1488a6d42e7dSPeter Dunlap 1489a6d42e7dSPeter Dunlap resp_datalen = (task->task_sense_length == 0) ? 0 : 1490a6d42e7dSPeter Dunlap (task->task_sense_length + sizeof (uint16_t)); 1491a6d42e7dSPeter Dunlap 1492a6d42e7dSPeter Dunlap pdu = idm_pdu_alloc(sizeof (iscsi_hdr_t), resp_datalen); 1493a6d42e7dSPeter Dunlap idm_pdu_init(pdu, itask->it_ict->ict_ic, itask, 1494a6d42e7dSPeter Dunlap iscsit_send_status_done); 1495a6d42e7dSPeter Dunlap 1496a6d42e7dSPeter Dunlap rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr; 1497a6d42e7dSPeter Dunlap bzero(rsp, sizeof (*rsp)); 1498a6d42e7dSPeter Dunlap rsp->opcode = ISCSI_OP_SCSI_RSP; 1499a6d42e7dSPeter Dunlap 1500a6d42e7dSPeter Dunlap rsp->flags = ISCSI_FLAG_FINAL; 1501a6d42e7dSPeter Dunlap if (task->task_status_ctrl & TASK_SCTRL_OVER) { 1502a6d42e7dSPeter Dunlap rsp->flags |= ISCSI_FLAG_CMD_OVERFLOW; 1503a6d42e7dSPeter Dunlap } else if (task->task_status_ctrl & TASK_SCTRL_UNDER) { 1504a6d42e7dSPeter Dunlap rsp->flags |= ISCSI_FLAG_CMD_UNDERFLOW; 1505a6d42e7dSPeter Dunlap } 1506a6d42e7dSPeter Dunlap 1507a6d42e7dSPeter Dunlap rsp->bi_residual_count = 0; 1508a6d42e7dSPeter Dunlap rsp->residual_count = htonl(task->task_resid); 1509a6d42e7dSPeter Dunlap rsp->itt = itask->it_itt; 1510a6d42e7dSPeter Dunlap rsp->response = ISCSI_STATUS_CMD_COMPLETED; 1511a6d42e7dSPeter Dunlap rsp->cmd_status = task->task_scsi_status; 1512a6d42e7dSPeter Dunlap if (task->task_sense_length != 0) { 1513a6d42e7dSPeter Dunlap /* 1514a6d42e7dSPeter Dunlap * Add a byte to provide the sense length in 1515a6d42e7dSPeter Dunlap * the response 1516a6d42e7dSPeter Dunlap */ 1517a6d42e7dSPeter Dunlap *(uint16_t *)((void *)pdu->isp_data) = 1518a6d42e7dSPeter Dunlap htons(task->task_sense_length); 1519a6d42e7dSPeter Dunlap bcopy(task->task_sense_data, 1520a6d42e7dSPeter Dunlap (uint8_t *)pdu->isp_data + 1521a6d42e7dSPeter Dunlap sizeof (uint16_t), 1522a6d42e7dSPeter Dunlap task->task_sense_length); 1523a6d42e7dSPeter Dunlap hton24(rsp->dlength, resp_datalen); 1524a6d42e7dSPeter Dunlap } 1525a6d42e7dSPeter Dunlap 152630e7468fSPeter Dunlap DTRACE_PROBE5(iscsi__scsi__response, 152730e7468fSPeter Dunlap iscsit_conn_t *, itask->it_ict, 152830e7468fSPeter Dunlap uint8_t, rsp->response, 152930e7468fSPeter Dunlap uint8_t, rsp->cmd_status, 153030e7468fSPeter Dunlap idm_pdu_t *, pdu, 153130e7468fSPeter Dunlap scsi_task_t *, task); 153230e7468fSPeter Dunlap 1533a6d42e7dSPeter Dunlap iscsit_pdu_tx(pdu); 1534a6d42e7dSPeter Dunlap 1535a6d42e7dSPeter Dunlap return (STMF_SUCCESS); 1536a6d42e7dSPeter Dunlap } 1537a6d42e7dSPeter Dunlap } 1538a6d42e7dSPeter Dunlap 1539a6d42e7dSPeter Dunlap /*ARGSUSED*/ 1540a6d42e7dSPeter Dunlap static void 1541a6d42e7dSPeter Dunlap iscsit_send_good_status_done(idm_pdu_t *pdu, idm_status_t status) 1542a6d42e7dSPeter Dunlap { 1543bf604c64SPeter Dunlap iscsit_task_t *itask; 1544bf604c64SPeter Dunlap boolean_t aborted; 1545a6d42e7dSPeter Dunlap 1546a6d42e7dSPeter Dunlap itask = pdu->isp_private; 1547bf604c64SPeter Dunlap aborted = itask->it_stmf_abort; 1548bf604c64SPeter Dunlap 1549bf604c64SPeter Dunlap /* 1550bf604c64SPeter Dunlap * After releasing the hold the task may be freed at any time so 1551bf604c64SPeter Dunlap * don't touch it. 1552bf604c64SPeter Dunlap */ 1553a6d42e7dSPeter Dunlap idm_task_rele(itask->it_idm_task); 1554bf604c64SPeter Dunlap if (!aborted) { 1555bf604c64SPeter Dunlap stmf_send_status_done(itask->it_stmf_task, 1556bf604c64SPeter Dunlap iscsit_idm_to_stmf(pdu->isp_status), STMF_IOF_LPORT_DONE); 1557bf604c64SPeter Dunlap } 1558a6d42e7dSPeter Dunlap kmem_cache_free(iscsit_status_pdu_cache, pdu); 1559a6d42e7dSPeter Dunlap } 1560a6d42e7dSPeter Dunlap 1561a6d42e7dSPeter Dunlap /*ARGSUSED*/ 1562a6d42e7dSPeter Dunlap static void 1563a6d42e7dSPeter Dunlap iscsit_send_status_done(idm_pdu_t *pdu, idm_status_t status) 1564a6d42e7dSPeter Dunlap { 1565a6d42e7dSPeter Dunlap iscsit_task_t *itask; 1566bf604c64SPeter Dunlap boolean_t aborted; 1567a6d42e7dSPeter Dunlap 1568a6d42e7dSPeter Dunlap itask = pdu->isp_private; 1569bf604c64SPeter Dunlap aborted = itask->it_stmf_abort; 1570bf604c64SPeter Dunlap 1571bf604c64SPeter Dunlap /* 1572bf604c64SPeter Dunlap * After releasing the hold the task may be freed at any time so 1573bf604c64SPeter Dunlap * don't touch it. 1574bf604c64SPeter Dunlap */ 1575a6d42e7dSPeter Dunlap idm_task_rele(itask->it_idm_task); 1576bf604c64SPeter Dunlap if (!aborted) { 1577bf604c64SPeter Dunlap stmf_send_status_done(itask->it_stmf_task, 1578bf604c64SPeter Dunlap iscsit_idm_to_stmf(pdu->isp_status), STMF_IOF_LPORT_DONE); 1579bf604c64SPeter Dunlap } 1580a6d42e7dSPeter Dunlap idm_pdu_free(pdu); 1581a6d42e7dSPeter Dunlap } 1582a6d42e7dSPeter Dunlap 1583a6d42e7dSPeter Dunlap 1584a6d42e7dSPeter Dunlap void 1585a6d42e7dSPeter Dunlap iscsit_lport_task_free(scsi_task_t *task) 1586a6d42e7dSPeter Dunlap { 1587a6d42e7dSPeter Dunlap iscsit_task_t *itask = task->task_port_private; 1588a6d42e7dSPeter Dunlap 1589a6d42e7dSPeter Dunlap /* We only call idm_task_start for regular tasks, not task management */ 1590a6d42e7dSPeter Dunlap if (task->task_mgmt_function == TM_NONE) { 1591a6d42e7dSPeter Dunlap idm_task_done(itask->it_idm_task); 1592a6d42e7dSPeter Dunlap iscsit_task_free(itask); 1593a6d42e7dSPeter Dunlap return; 1594a6d42e7dSPeter Dunlap } else { 1595a6d42e7dSPeter Dunlap iscsit_tm_task_free(itask); 1596a6d42e7dSPeter Dunlap } 1597a6d42e7dSPeter Dunlap } 1598a6d42e7dSPeter Dunlap 1599a6d42e7dSPeter Dunlap /*ARGSUSED*/ 1600a6d42e7dSPeter Dunlap stmf_status_t 1601a6d42e7dSPeter Dunlap iscsit_abort(stmf_local_port_t *lport, int abort_cmd, void *arg, uint32_t flags) 1602a6d42e7dSPeter Dunlap { 1603a6d42e7dSPeter Dunlap scsi_task_t *st = (scsi_task_t *)arg; 1604a6d42e7dSPeter Dunlap iscsit_task_t *iscsit_task; 1605a6d42e7dSPeter Dunlap idm_task_t *idt; 1606a6d42e7dSPeter Dunlap 1607a6d42e7dSPeter Dunlap /* 1608a6d42e7dSPeter Dunlap * If this is a task management request then there's really not much to 1609a6d42e7dSPeter Dunlap * do. 1610a6d42e7dSPeter Dunlap */ 1611a6d42e7dSPeter Dunlap if (st->task_mgmt_function != TM_NONE) { 1612a6d42e7dSPeter Dunlap return (STMF_ABORT_SUCCESS); 1613a6d42e7dSPeter Dunlap } 1614a6d42e7dSPeter Dunlap 1615a6d42e7dSPeter Dunlap /* 1616a6d42e7dSPeter Dunlap * Regular task, start cleaning up 1617a6d42e7dSPeter Dunlap */ 1618a6d42e7dSPeter Dunlap iscsit_task = st->task_port_private; 1619a6d42e7dSPeter Dunlap idt = iscsit_task->it_idm_task; 1620a6d42e7dSPeter Dunlap mutex_enter(&iscsit_task->it_mutex); 1621a6d42e7dSPeter Dunlap iscsit_task->it_stmf_abort = B_TRUE; 1622a6d42e7dSPeter Dunlap if (iscsit_task->it_aborted) { 1623a6d42e7dSPeter Dunlap mutex_exit(&iscsit_task->it_mutex); 162472cf3143Speter dunlap /* 162572cf3143Speter dunlap * Task is no longer active 162672cf3143Speter dunlap */ 162772cf3143Speter dunlap iscsit_task_done(iscsit_task); 162872cf3143Speter dunlap 1629a6d42e7dSPeter Dunlap /* 1630a6d42e7dSPeter Dunlap * STMF specification is wrong... says to return 1631a6d42e7dSPeter Dunlap * STMF_ABORTED, the code actually looks for 1632a6d42e7dSPeter Dunlap * STMF_ABORT_SUCCESS. 1633a6d42e7dSPeter Dunlap */ 1634a6d42e7dSPeter Dunlap return (STMF_ABORT_SUCCESS); 1635a6d42e7dSPeter Dunlap } else { 1636a6d42e7dSPeter Dunlap mutex_exit(&iscsit_task->it_mutex); 1637a6d42e7dSPeter Dunlap /* 1638a6d42e7dSPeter Dunlap * Call IDM to abort the task. Due to a variety of 1639a6d42e7dSPeter Dunlap * circumstances the task may already be in the process of 1640a6d42e7dSPeter Dunlap * aborting. 1641a6d42e7dSPeter Dunlap * We'll let IDM worry about rationalizing all that except 1642a6d42e7dSPeter Dunlap * for one particular instance. If the state of the task 1643a6d42e7dSPeter Dunlap * is TASK_COMPLETE, we need to indicate to the framework 1644a6d42e7dSPeter Dunlap * that we are in fact done. This typically happens with 1645a6d42e7dSPeter Dunlap * framework-initiated task management type requests 1646a6d42e7dSPeter Dunlap * (e.g. abort task). 1647a6d42e7dSPeter Dunlap */ 1648a6d42e7dSPeter Dunlap if (idt->idt_state == TASK_COMPLETE) { 1649a6d42e7dSPeter Dunlap idm_refcnt_wait_ref(&idt->idt_refcnt); 1650a6d42e7dSPeter Dunlap return (STMF_ABORT_SUCCESS); 1651a6d42e7dSPeter Dunlap } else { 1652a6d42e7dSPeter Dunlap idm_task_abort(idt->idt_ic, idt, AT_TASK_MGMT_ABORT); 1653a6d42e7dSPeter Dunlap return (STMF_SUCCESS); 1654a6d42e7dSPeter Dunlap } 1655a6d42e7dSPeter Dunlap } 1656a6d42e7dSPeter Dunlap 1657a6d42e7dSPeter Dunlap /*NOTREACHED*/ 1658a6d42e7dSPeter Dunlap } 1659a6d42e7dSPeter Dunlap 1660a6d42e7dSPeter Dunlap /*ARGSUSED*/ 1661a6d42e7dSPeter Dunlap void 1662a6d42e7dSPeter Dunlap iscsit_ctl(stmf_local_port_t *lport, int cmd, void *arg) 1663a6d42e7dSPeter Dunlap { 1664a6d42e7dSPeter Dunlap iscsit_tgt_t *iscsit_tgt; 1665a6d42e7dSPeter Dunlap 1666a6d42e7dSPeter Dunlap ASSERT((cmd == STMF_CMD_LPORT_ONLINE) || 1667a6d42e7dSPeter Dunlap (cmd == STMF_ACK_LPORT_ONLINE_COMPLETE) || 1668a6d42e7dSPeter Dunlap (cmd == STMF_CMD_LPORT_OFFLINE) || 1669a6d42e7dSPeter Dunlap (cmd == STMF_ACK_LPORT_OFFLINE_COMPLETE)); 1670a6d42e7dSPeter Dunlap 1671a6d42e7dSPeter Dunlap iscsit_tgt = (iscsit_tgt_t *)lport->lport_port_private; 1672a6d42e7dSPeter Dunlap 1673a6d42e7dSPeter Dunlap switch (cmd) { 1674a6d42e7dSPeter Dunlap case STMF_CMD_LPORT_ONLINE: 1675a6d42e7dSPeter Dunlap iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_ONLINE_REQ); 1676a6d42e7dSPeter Dunlap break; 1677a6d42e7dSPeter Dunlap case STMF_CMD_LPORT_OFFLINE: 1678a6d42e7dSPeter Dunlap iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_OFFLINE_REQ); 1679a6d42e7dSPeter Dunlap break; 1680a6d42e7dSPeter Dunlap case STMF_ACK_LPORT_ONLINE_COMPLETE: 1681a6d42e7dSPeter Dunlap iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_ONLINE_COMPLETE_ACK); 1682a6d42e7dSPeter Dunlap break; 1683a6d42e7dSPeter Dunlap case STMF_ACK_LPORT_OFFLINE_COMPLETE: 1684a6d42e7dSPeter Dunlap iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_OFFLINE_COMPLETE_ACK); 1685a6d42e7dSPeter Dunlap break; 1686a6d42e7dSPeter Dunlap 1687a6d42e7dSPeter Dunlap default: 1688a6d42e7dSPeter Dunlap break; 1689a6d42e7dSPeter Dunlap } 1690a6d42e7dSPeter Dunlap } 1691a6d42e7dSPeter Dunlap 1692a6d42e7dSPeter Dunlap static stmf_status_t 1693a6d42e7dSPeter Dunlap iscsit_idm_to_stmf(idm_status_t idmrc) 1694a6d42e7dSPeter Dunlap { 1695a6d42e7dSPeter Dunlap switch (idmrc) { 1696a6d42e7dSPeter Dunlap case IDM_STATUS_SUCCESS: 1697a6d42e7dSPeter Dunlap return (STMF_SUCCESS); 1698a6d42e7dSPeter Dunlap default: 1699a6d42e7dSPeter Dunlap return (STMF_FAILURE); 1700a6d42e7dSPeter Dunlap } 1701a6d42e7dSPeter Dunlap /*NOTREACHED*/ 1702a6d42e7dSPeter Dunlap } 1703a6d42e7dSPeter Dunlap 1704a6d42e7dSPeter Dunlap 1705a6d42e7dSPeter Dunlap /* 1706a6d42e7dSPeter Dunlap * ISCSI protocol 1707a6d42e7dSPeter Dunlap */ 1708a6d42e7dSPeter Dunlap 1709a6d42e7dSPeter Dunlap void 1710a6d42e7dSPeter Dunlap iscsit_op_scsi_cmd(idm_conn_t *ic, idm_pdu_t *rx_pdu) 1711a6d42e7dSPeter Dunlap { 1712a6d42e7dSPeter Dunlap iscsit_conn_t *ict; 1713a6d42e7dSPeter Dunlap iscsit_task_t *itask; 1714a6d42e7dSPeter Dunlap scsi_task_t *task; 1715a6d42e7dSPeter Dunlap iscsit_buf_t *ibuf; 1716a6d42e7dSPeter Dunlap iscsi_scsi_cmd_hdr_t *iscsi_scsi = 1717a6d42e7dSPeter Dunlap (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr; 1718a6d42e7dSPeter Dunlap iscsi_addl_hdr_t *ahs_hdr; 1719a6d42e7dSPeter Dunlap uint16_t addl_cdb_len = 0; 1720a6d42e7dSPeter Dunlap 1721a6d42e7dSPeter Dunlap ict = ic->ic_handle; 1722a6d42e7dSPeter Dunlap 1723a6d42e7dSPeter Dunlap itask = iscsit_task_alloc(ict); 1724a6d42e7dSPeter Dunlap if (itask == NULL) { 172572cf3143Speter dunlap /* Finish processing request */ 172672cf3143Speter dunlap iscsit_set_cmdsn(ict, rx_pdu); 172772cf3143Speter dunlap 1728a6d42e7dSPeter Dunlap iscsit_send_direct_scsi_resp(ict, rx_pdu, 1729a6d42e7dSPeter Dunlap ISCSI_STATUS_CMD_COMPLETED, STATUS_BUSY); 1730a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 1731a6d42e7dSPeter Dunlap return; 1732a6d42e7dSPeter Dunlap } 1733a6d42e7dSPeter Dunlap 1734a6d42e7dSPeter Dunlap 1735a6d42e7dSPeter Dunlap /* 1736a6d42e7dSPeter Dunlap * Note CmdSN and ITT in task. IDM will have already validated this 1737a6d42e7dSPeter Dunlap * request against the connection state so we don't need to check 1738a6d42e7dSPeter Dunlap * that (the connection may have changed state in the meantime but 1739a6d42e7dSPeter Dunlap * we will catch that when we try to send a response) 1740a6d42e7dSPeter Dunlap */ 1741a6d42e7dSPeter Dunlap itask->it_cmdsn = ntohl(iscsi_scsi->cmdsn); 1742a6d42e7dSPeter Dunlap itask->it_itt = iscsi_scsi->itt; 1743a6d42e7dSPeter Dunlap 1744a6d42e7dSPeter Dunlap /* 1745a6d42e7dSPeter Dunlap * Check for extended CDB AHS 1746a6d42e7dSPeter Dunlap */ 1747a6d42e7dSPeter Dunlap if (iscsi_scsi->hlength > 0) { 1748a6d42e7dSPeter Dunlap ahs_hdr = (iscsi_addl_hdr_t *)iscsi_scsi; 1749a6d42e7dSPeter Dunlap addl_cdb_len = ((ahs_hdr->ahs_hlen_hi << 8) | 1750a6d42e7dSPeter Dunlap ahs_hdr->ahs_hlen_lo) - 1; /* Adjust for reserved byte */ 1751a6d42e7dSPeter Dunlap if (((addl_cdb_len + 4) / sizeof (uint32_t)) > 1752a6d42e7dSPeter Dunlap iscsi_scsi->hlength) { 1753a6d42e7dSPeter Dunlap /* Mangled header info, drop it */ 1754a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 1755a6d42e7dSPeter Dunlap return; 1756a6d42e7dSPeter Dunlap } 1757a6d42e7dSPeter Dunlap } 1758a6d42e7dSPeter Dunlap 1759a6d42e7dSPeter Dunlap ict = rx_pdu->isp_ic->ic_handle; /* IDM client private */ 1760a6d42e7dSPeter Dunlap 176172cf3143Speter dunlap /* 176272cf3143Speter dunlap * Add task to session list. This function will also check to 176372cf3143Speter dunlap * ensure that the task does not already exist. 176472cf3143Speter dunlap */ 176572cf3143Speter dunlap if (iscsit_task_start(itask) != IDM_STATUS_SUCCESS) { 176672cf3143Speter dunlap /* 176772cf3143Speter dunlap * Task exists, free all resources and reject. Don't 176872cf3143Speter dunlap * update expcmdsn in this case because RFC 3720 says 176972cf3143Speter dunlap * "The CmdSN of the rejected command PDU (if it is a 177072cf3143Speter dunlap * non-immediate command) MUST NOT be considered received 177172cf3143Speter dunlap * by the target (i.e., a command sequence gap must be 177272cf3143Speter dunlap * assumed for the CmdSN), even though the CmdSN of the 177372cf3143Speter dunlap * rejected command PDU may be reliably ascertained. Upon 177472cf3143Speter dunlap * receiving the Reject, the initiator MUST plug the CmdSN 177572cf3143Speter dunlap * gap in order to continue to use the session. The gap 177672cf3143Speter dunlap * may be plugged either by transmitting a command PDU 177772cf3143Speter dunlap * with the same CmdSN, or by aborting the task (see section 177872cf3143Speter dunlap * 6.9 on how an abort may plug a CmdSN gap)." (Section 6.3) 177972cf3143Speter dunlap */ 178072cf3143Speter dunlap iscsit_task_free(itask); 178172cf3143Speter dunlap iscsit_send_reject(ict, rx_pdu, ISCSI_REJECT_TASK_IN_PROGRESS); 178272cf3143Speter dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 178372cf3143Speter dunlap return; 178472cf3143Speter dunlap } 178572cf3143Speter dunlap 178672cf3143Speter dunlap /* Update sequence numbers */ 178772cf3143Speter dunlap iscsit_set_cmdsn(ict, rx_pdu); 178872cf3143Speter dunlap 178972cf3143Speter dunlap /* 179072cf3143Speter dunlap * Allocate STMF task 179172cf3143Speter dunlap */ 1792a6d42e7dSPeter Dunlap itask->it_stmf_task = stmf_task_alloc( 1793a6d42e7dSPeter Dunlap itask->it_ict->ict_sess->ist_lport, 1794a6d42e7dSPeter Dunlap itask->it_ict->ict_sess->ist_stmf_sess, iscsi_scsi->lun, 1795a6d42e7dSPeter Dunlap 16 + addl_cdb_len, 0); 1796a6d42e7dSPeter Dunlap if (itask->it_stmf_task == NULL) { 1797a6d42e7dSPeter Dunlap /* 1798a6d42e7dSPeter Dunlap * Either stmf really couldn't get memory for a task or, 1799a6d42e7dSPeter Dunlap * more likely, the LU is currently in reset. Either way 1800a6d42e7dSPeter Dunlap * we have no choice but to fail the request. 1801a6d42e7dSPeter Dunlap */ 180272cf3143Speter dunlap iscsit_task_done(itask); 1803a6d42e7dSPeter Dunlap iscsit_task_free(itask); 1804a6d42e7dSPeter Dunlap iscsit_send_direct_scsi_resp(ict, rx_pdu, 1805a6d42e7dSPeter Dunlap ISCSI_STATUS_CMD_COMPLETED, STATUS_BUSY); 180672cf3143Speter dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 1807a6d42e7dSPeter Dunlap return; 1808a6d42e7dSPeter Dunlap } 1809a6d42e7dSPeter Dunlap 1810a6d42e7dSPeter Dunlap task = itask->it_stmf_task; 1811a6d42e7dSPeter Dunlap task->task_port_private = itask; 1812a6d42e7dSPeter Dunlap 1813a6d42e7dSPeter Dunlap bcopy(iscsi_scsi->lun, task->task_lun_no, sizeof (task->task_lun_no)); 1814a6d42e7dSPeter Dunlap 1815a6d42e7dSPeter Dunlap /* 1816a6d42e7dSPeter Dunlap * iSCSI and Comstar use the same values. Should we rely on this 1817a6d42e7dSPeter Dunlap * or translate them bit-wise? 1818a6d42e7dSPeter Dunlap */ 1819a6d42e7dSPeter Dunlap 1820a6d42e7dSPeter Dunlap task->task_flags = 1821a6d42e7dSPeter Dunlap (((iscsi_scsi->flags & ISCSI_FLAG_CMD_READ) ? TF_READ_DATA : 0) | 1822a6d42e7dSPeter Dunlap ((iscsi_scsi->flags & ISCSI_FLAG_CMD_WRITE) ? TF_WRITE_DATA : 0) | 1823a6d42e7dSPeter Dunlap ((rx_pdu->isp_datalen == 0) ? 0 : TF_INITIAL_BURST)); 1824a6d42e7dSPeter Dunlap 1825a6d42e7dSPeter Dunlap switch (iscsi_scsi->flags & ISCSI_FLAG_CMD_ATTR_MASK) { 1826a6d42e7dSPeter Dunlap case ISCSI_ATTR_UNTAGGED: 1827a6d42e7dSPeter Dunlap break; 1828a6d42e7dSPeter Dunlap case ISCSI_ATTR_SIMPLE: 1829a6d42e7dSPeter Dunlap task->task_additional_flags |= TF_ATTR_SIMPLE_QUEUE; 1830a6d42e7dSPeter Dunlap break; 1831a6d42e7dSPeter Dunlap case ISCSI_ATTR_ORDERED: 1832a6d42e7dSPeter Dunlap task->task_additional_flags |= TF_ATTR_ORDERED_QUEUE; 1833a6d42e7dSPeter Dunlap break; 1834a6d42e7dSPeter Dunlap case ISCSI_ATTR_HEAD_OF_QUEUE: 1835a6d42e7dSPeter Dunlap task->task_additional_flags |= TF_ATTR_HEAD_OF_QUEUE; 1836a6d42e7dSPeter Dunlap break; 1837a6d42e7dSPeter Dunlap case ISCSI_ATTR_ACA: 1838a6d42e7dSPeter Dunlap task->task_additional_flags |= TF_ATTR_ACA; 1839a6d42e7dSPeter Dunlap break; 1840a6d42e7dSPeter Dunlap default: 1841a6d42e7dSPeter Dunlap /* Protocol error but just take it, treat as untagged */ 1842a6d42e7dSPeter Dunlap break; 1843a6d42e7dSPeter Dunlap } 1844a6d42e7dSPeter Dunlap 1845a6d42e7dSPeter Dunlap 1846a6d42e7dSPeter Dunlap task->task_additional_flags = 0; 1847a6d42e7dSPeter Dunlap task->task_priority = 0; 1848a6d42e7dSPeter Dunlap task->task_mgmt_function = TM_NONE; 1849a6d42e7dSPeter Dunlap 1850a6d42e7dSPeter Dunlap /* 1851a6d42e7dSPeter Dunlap * This "task_max_nbufs" doesn't map well to BIDI. We probably need 1852a6d42e7dSPeter Dunlap * parameter for each direction. "MaxOutstandingR2T" may very well 1853a6d42e7dSPeter Dunlap * be set to one which could prevent us from doing simultaneous 1854a6d42e7dSPeter Dunlap * transfers in each direction. 1855a6d42e7dSPeter Dunlap */ 1856a6d42e7dSPeter Dunlap task->task_max_nbufs = (iscsi_scsi->flags & ISCSI_FLAG_CMD_WRITE) ? 1857a6d42e7dSPeter Dunlap ict->ict_op.op_max_outstanding_r2t : STMF_BUFS_MAX; 1858a6d42e7dSPeter Dunlap task->task_cmd_seq_no = ntohl(iscsi_scsi->itt); 1859a6d42e7dSPeter Dunlap task->task_expected_xfer_length = ntohl(iscsi_scsi->data_length); 1860a6d42e7dSPeter Dunlap 1861a6d42e7dSPeter Dunlap /* Copy CDB */ 1862a6d42e7dSPeter Dunlap bcopy(iscsi_scsi->scb, task->task_cdb, 16); 1863a6d42e7dSPeter Dunlap if (addl_cdb_len > 0) { 1864a6d42e7dSPeter Dunlap bcopy(ahs_hdr->ahs_extscb, task->task_cdb + 16, addl_cdb_len); 1865a6d42e7dSPeter Dunlap } 1866a6d42e7dSPeter Dunlap 1867a668b114SPriya Krishnan DTRACE_ISCSI_3(scsi__command, idm_conn_t *, ic, 1868a668b114SPriya Krishnan iscsi_scsi_cmd_hdr_t *, (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr, 1869a668b114SPriya Krishnan scsi_task_t *, task); 1870a668b114SPriya Krishnan 1871a6d42e7dSPeter Dunlap /* 1872a6d42e7dSPeter Dunlap * Copy the transport header into the task handle from the PDU 1873a6d42e7dSPeter Dunlap * handle. The transport header describes this task's remote tagged 1874a6d42e7dSPeter Dunlap * buffer. 1875a6d42e7dSPeter Dunlap */ 1876a6d42e7dSPeter Dunlap if (rx_pdu->isp_transport_hdrlen != 0) { 1877a6d42e7dSPeter Dunlap bcopy(rx_pdu->isp_transport_hdr, 1878a6d42e7dSPeter Dunlap itask->it_idm_task->idt_transport_hdr, 1879a6d42e7dSPeter Dunlap rx_pdu->isp_transport_hdrlen); 1880a6d42e7dSPeter Dunlap } 1881a6d42e7dSPeter Dunlap 1882a6d42e7dSPeter Dunlap /* 1883a6d42e7dSPeter Dunlap * Tell IDM about our new active task 1884a6d42e7dSPeter Dunlap */ 1885a6d42e7dSPeter Dunlap idm_task_start(itask->it_idm_task, (uintptr_t)itask->it_itt); 1886a6d42e7dSPeter Dunlap 1887a6d42e7dSPeter Dunlap /* 1888a6d42e7dSPeter Dunlap * If we have any immediate data then setup the immediate buffer 1889a6d42e7dSPeter Dunlap * context that comes with the task 1890a6d42e7dSPeter Dunlap */ 1891a6d42e7dSPeter Dunlap if (rx_pdu->isp_datalen) { 1892a6d42e7dSPeter Dunlap ibuf = itask->it_immed_data; 1893a6d42e7dSPeter Dunlap ibuf->ibuf_immed_data_pdu = rx_pdu; 1894a6d42e7dSPeter Dunlap ibuf->ibuf_stmf_buf->db_data_size = rx_pdu->isp_datalen; 1895a6d42e7dSPeter Dunlap ibuf->ibuf_stmf_buf->db_buf_size = rx_pdu->isp_datalen; 1896a6d42e7dSPeter Dunlap ibuf->ibuf_stmf_buf->db_relative_offset = 0; 1897a6d42e7dSPeter Dunlap ibuf->ibuf_stmf_buf->db_sglist[0].seg_length = 1898a6d42e7dSPeter Dunlap rx_pdu->isp_datalen; 1899a6d42e7dSPeter Dunlap ibuf->ibuf_stmf_buf->db_sglist[0].seg_addr = rx_pdu->isp_data; 1900a6d42e7dSPeter Dunlap 1901a668b114SPriya Krishnan DTRACE_ISCSI_8(xfer__start, idm_conn_t *, ic, 1902a668b114SPriya Krishnan uintptr_t, ibuf->ibuf_stmf_buf->db_sglist[0].seg_addr, 1903a668b114SPriya Krishnan uint32_t, ibuf->ibuf_stmf_buf->db_relative_offset, 1904a668b114SPriya Krishnan uint64_t, 0, uint32_t, 0, uint32_t, 0, /* no raddr */ 1905a668b114SPriya Krishnan uint32_t, rx_pdu->isp_datalen, int, XFER_BUF_TX_TO_INI); 1906a668b114SPriya Krishnan 19073badd853SPriya Krishnan /* 19083badd853SPriya Krishnan * For immediate data transfer, there is no callback from 19093badd853SPriya Krishnan * stmf to indicate that the initial burst of data is 19103badd853SPriya Krishnan * transferred successfully. In some cases, the task can 19113badd853SPriya Krishnan * get freed before execution returns from stmf_post_task. 19123badd853SPriya Krishnan * Although this xfer-start/done probe accurately tracks 19133badd853SPriya Krishnan * the size of the transfer, it does only provide a best 19143badd853SPriya Krishnan * effort on the timing of the transfer. 19153badd853SPriya Krishnan */ 1916a668b114SPriya Krishnan DTRACE_ISCSI_8(xfer__done, idm_conn_t *, ic, 1917a668b114SPriya Krishnan uintptr_t, ibuf->ibuf_stmf_buf->db_sglist[0].seg_addr, 1918a668b114SPriya Krishnan uint32_t, ibuf->ibuf_stmf_buf->db_relative_offset, 1919a668b114SPriya Krishnan uint64_t, 0, uint32_t, 0, uint32_t, 0, /* no raddr */ 1920a668b114SPriya Krishnan uint32_t, rx_pdu->isp_datalen, int, XFER_BUF_TX_TO_INI); 19213badd853SPriya Krishnan 19223badd853SPriya Krishnan stmf_post_task(task, ibuf->ibuf_stmf_buf); 1923a6d42e7dSPeter Dunlap } else { 19243badd853SPriya Krishnan 1925a6d42e7dSPeter Dunlap stmf_post_task(task, NULL); 1926a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 1927a6d42e7dSPeter Dunlap } 1928a6d42e7dSPeter Dunlap } 1929a6d42e7dSPeter Dunlap 1930a6d42e7dSPeter Dunlap /*ARGSUSED*/ 1931a6d42e7dSPeter Dunlap void 1932a6d42e7dSPeter Dunlap iscsit_deferred_dispatch(idm_pdu_t *rx_pdu) 1933a6d42e7dSPeter Dunlap { 1934a6d42e7dSPeter Dunlap iscsit_conn_t *ict = rx_pdu->isp_ic->ic_handle; 1935a6d42e7dSPeter Dunlap 1936a6d42e7dSPeter Dunlap /* 1937a6d42e7dSPeter Dunlap * If the connection has been lost then ignore new PDU's 1938a6d42e7dSPeter Dunlap */ 1939a6d42e7dSPeter Dunlap mutex_enter(&ict->ict_mutex); 1940a6d42e7dSPeter Dunlap if (ict->ict_lost) { 1941a6d42e7dSPeter Dunlap mutex_exit(&ict->ict_mutex); 1942a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL); 1943a6d42e7dSPeter Dunlap return; 1944a6d42e7dSPeter Dunlap } 1945a6d42e7dSPeter Dunlap 1946a6d42e7dSPeter Dunlap /* 1947a6d42e7dSPeter Dunlap * Grab a hold on the connection to prevent it from going away 1948a6d42e7dSPeter Dunlap * between now and when the taskq function is called. 1949a6d42e7dSPeter Dunlap */ 1950a6d42e7dSPeter Dunlap iscsit_conn_dispatch_hold(ict); 1951a6d42e7dSPeter Dunlap mutex_exit(&ict->ict_mutex); 1952a6d42e7dSPeter Dunlap 1953a6d42e7dSPeter Dunlap if (taskq_dispatch(iscsit_global.global_dispatch_taskq, 1954a6d42e7dSPeter Dunlap iscsit_deferred, rx_pdu, DDI_NOSLEEP) == NULL) { 1955a6d42e7dSPeter Dunlap /* 1956a6d42e7dSPeter Dunlap * In the unlikely scenario that we couldn't get the resources 1957a6d42e7dSPeter Dunlap * to dispatch the PDU then just drop it. 1958a6d42e7dSPeter Dunlap */ 1959a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL); 1960a6d42e7dSPeter Dunlap idm_conn_event(ict->ict_ic, CE_TRANSPORT_FAIL, NULL); 1961a6d42e7dSPeter Dunlap iscsit_conn_dispatch_rele(ict); 1962a6d42e7dSPeter Dunlap } 1963a6d42e7dSPeter Dunlap } 1964a6d42e7dSPeter Dunlap 1965a6d42e7dSPeter Dunlap static void 1966a6d42e7dSPeter Dunlap iscsit_deferred(void *rx_pdu_void) 1967a6d42e7dSPeter Dunlap { 1968a6d42e7dSPeter Dunlap idm_pdu_t *rx_pdu = rx_pdu_void; 1969a6d42e7dSPeter Dunlap idm_conn_t *ic = rx_pdu->isp_ic; 1970a6d42e7dSPeter Dunlap iscsit_conn_t *ict = ic->ic_handle; 1971a6d42e7dSPeter Dunlap 1972a6d42e7dSPeter Dunlap switch (IDM_PDU_OPCODE(rx_pdu)) { 1973a6d42e7dSPeter Dunlap case ISCSI_OP_NOOP_OUT: 1974a6d42e7dSPeter Dunlap iscsit_set_cmdsn(ict, rx_pdu); 1975a6d42e7dSPeter Dunlap iscsit_pdu_op_noop(ict, rx_pdu); 1976a6d42e7dSPeter Dunlap break; 1977a6d42e7dSPeter Dunlap case ISCSI_OP_LOGIN_CMD: 1978a6d42e7dSPeter Dunlap iscsit_pdu_op_login_cmd(ict, rx_pdu); 1979a6d42e7dSPeter Dunlap break; 1980a6d42e7dSPeter Dunlap case ISCSI_OP_TEXT_CMD: 1981a6d42e7dSPeter Dunlap iscsit_set_cmdsn(ict, rx_pdu); 1982a6d42e7dSPeter Dunlap iscsit_pdu_op_text_cmd(ict, rx_pdu); 1983a6d42e7dSPeter Dunlap break; 1984a6d42e7dSPeter Dunlap case ISCSI_OP_LOGOUT_CMD: 1985a6d42e7dSPeter Dunlap iscsit_set_cmdsn(ict, rx_pdu); 1986a6d42e7dSPeter Dunlap iscsit_pdu_op_logout_cmd(ict, rx_pdu); 1987a6d42e7dSPeter Dunlap break; 1988a6d42e7dSPeter Dunlap default: 1989a6d42e7dSPeter Dunlap /* Protocol error. IDM should have caught this */ 1990a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL); 1991a6d42e7dSPeter Dunlap ASSERT(0); 1992a6d42e7dSPeter Dunlap break; 1993a6d42e7dSPeter Dunlap } 1994a6d42e7dSPeter Dunlap 1995a6d42e7dSPeter Dunlap iscsit_conn_dispatch_rele(ict); 1996a6d42e7dSPeter Dunlap } 1997a6d42e7dSPeter Dunlap 1998a6d42e7dSPeter Dunlap static void 1999a6d42e7dSPeter Dunlap iscsit_send_direct_scsi_resp(iscsit_conn_t *ict, idm_pdu_t *rx_pdu, 2000a6d42e7dSPeter Dunlap uint8_t response, uint8_t cmd_status) 2001a6d42e7dSPeter Dunlap { 2002a6d42e7dSPeter Dunlap idm_pdu_t *rsp_pdu; 2003a6d42e7dSPeter Dunlap idm_conn_t *ic; 2004a6d42e7dSPeter Dunlap iscsi_scsi_rsp_hdr_t *resp; 200530e7468fSPeter Dunlap iscsi_scsi_cmd_hdr_t *req = 200630e7468fSPeter Dunlap (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr; 2007a6d42e7dSPeter Dunlap 2008a6d42e7dSPeter Dunlap ic = ict->ict_ic; 2009a6d42e7dSPeter Dunlap 2010a6d42e7dSPeter Dunlap rsp_pdu = idm_pdu_alloc(sizeof (iscsi_scsi_rsp_hdr_t), 0); 2011a6d42e7dSPeter Dunlap idm_pdu_init(rsp_pdu, ic, NULL, NULL); 2012a6d42e7dSPeter Dunlap resp = (iscsi_scsi_rsp_hdr_t *)rsp_pdu->isp_hdr; 2013a6d42e7dSPeter Dunlap 2014a6d42e7dSPeter Dunlap resp->opcode = ISCSI_OP_SCSI_RSP; 2015a6d42e7dSPeter Dunlap resp->flags = ISCSI_FLAG_FINAL; 2016a6d42e7dSPeter Dunlap resp->response = response; 2017a6d42e7dSPeter Dunlap resp->cmd_status = cmd_status; 201830e7468fSPeter Dunlap resp->itt = req->itt; 201930e7468fSPeter Dunlap if ((response == ISCSI_STATUS_CMD_COMPLETED) && 202030e7468fSPeter Dunlap (req->data_length != 0) && 202130e7468fSPeter Dunlap ((req->flags & ISCSI_FLAG_CMD_READ) || 202230e7468fSPeter Dunlap (req->flags & ISCSI_FLAG_CMD_WRITE))) { 202330e7468fSPeter Dunlap resp->flags |= ISCSI_FLAG_CMD_UNDERFLOW; 202430e7468fSPeter Dunlap resp->residual_count = req->data_length; 202530e7468fSPeter Dunlap } 202630e7468fSPeter Dunlap 202730e7468fSPeter Dunlap DTRACE_PROBE4(iscsi__scsi__direct__response, 202830e7468fSPeter Dunlap iscsit_conn_t *, ict, 202930e7468fSPeter Dunlap uint8_t, resp->response, 203030e7468fSPeter Dunlap uint8_t, resp->cmd_status, 203130e7468fSPeter Dunlap idm_pdu_t *, rsp_pdu); 2032a6d42e7dSPeter Dunlap 2033a6d42e7dSPeter Dunlap iscsit_pdu_tx(rsp_pdu); 2034a6d42e7dSPeter Dunlap } 2035a6d42e7dSPeter Dunlap 2036a6d42e7dSPeter Dunlap void 2037a6d42e7dSPeter Dunlap iscsit_send_task_mgmt_resp(idm_pdu_t *tm_resp_pdu, uint8_t tm_status) 2038a6d42e7dSPeter Dunlap { 2039a6d42e7dSPeter Dunlap iscsi_scsi_task_mgt_rsp_hdr_t *tm_resp; 2040a6d42e7dSPeter Dunlap 2041a6d42e7dSPeter Dunlap tm_resp = (iscsi_scsi_task_mgt_rsp_hdr_t *)tm_resp_pdu->isp_hdr; 2042a6d42e7dSPeter Dunlap tm_resp->response = tm_status; 204330e7468fSPeter Dunlap 204430e7468fSPeter Dunlap DTRACE_PROBE3(iscsi__scsi__tm__response, 204530e7468fSPeter Dunlap iscsit_conn_t *, tm_resp_pdu->isp_ic->ic_handle, 204630e7468fSPeter Dunlap uint8_t, tm_resp->response, 204730e7468fSPeter Dunlap idm_pdu_t *, tm_resp_pdu); 2048a6d42e7dSPeter Dunlap iscsit_pdu_tx(tm_resp_pdu); 2049a6d42e7dSPeter Dunlap } 2050a6d42e7dSPeter Dunlap 2051a6d42e7dSPeter Dunlap void 2052a6d42e7dSPeter Dunlap iscsit_op_scsi_task_mgmt(iscsit_conn_t *ict, idm_pdu_t *rx_pdu) 2053a6d42e7dSPeter Dunlap { 2054a6d42e7dSPeter Dunlap idm_pdu_t *tm_resp_pdu; 2055a6d42e7dSPeter Dunlap iscsit_task_t *itask; 2056a6d42e7dSPeter Dunlap iscsit_task_t *tm_itask; 2057a6d42e7dSPeter Dunlap scsi_task_t *task; 2058a6d42e7dSPeter Dunlap iscsi_scsi_task_mgt_hdr_t *iscsi_tm = 2059a6d42e7dSPeter Dunlap (iscsi_scsi_task_mgt_hdr_t *)rx_pdu->isp_hdr; 2060a6d42e7dSPeter Dunlap iscsi_scsi_task_mgt_rsp_hdr_t *iscsi_tm_rsp = 2061a6d42e7dSPeter Dunlap (iscsi_scsi_task_mgt_rsp_hdr_t *)rx_pdu->isp_hdr; 2062a6d42e7dSPeter Dunlap uint32_t rtt, cmdsn, refcmdsn; 2063a6d42e7dSPeter Dunlap uint8_t tm_func; 2064a6d42e7dSPeter Dunlap 2065a6d42e7dSPeter Dunlap /* 2066a6d42e7dSPeter Dunlap * Setup response PDU (response field will get filled in later) 2067a6d42e7dSPeter Dunlap */ 2068a6d42e7dSPeter Dunlap tm_resp_pdu = idm_pdu_alloc(sizeof (iscsi_scsi_task_mgt_rsp_hdr_t), 0); 2069a6d42e7dSPeter Dunlap if (tm_resp_pdu == NULL) { 2070a6d42e7dSPeter Dunlap /* Can't respond, just drop it */ 2071a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2072a6d42e7dSPeter Dunlap return; 2073a6d42e7dSPeter Dunlap } 2074a6d42e7dSPeter Dunlap idm_pdu_init(tm_resp_pdu, ict->ict_ic, NULL, NULL); 2075a6d42e7dSPeter Dunlap iscsi_tm_rsp = (iscsi_scsi_task_mgt_rsp_hdr_t *)tm_resp_pdu->isp_hdr; 2076a6d42e7dSPeter Dunlap bzero(iscsi_tm_rsp, sizeof (iscsi_scsi_task_mgt_rsp_hdr_t)); 2077a6d42e7dSPeter Dunlap iscsi_tm_rsp->opcode = ISCSI_OP_SCSI_TASK_MGT_RSP; 2078a6d42e7dSPeter Dunlap iscsi_tm_rsp->flags = ISCSI_FLAG_FINAL; 2079a6d42e7dSPeter Dunlap iscsi_tm_rsp->itt = rx_pdu->isp_hdr->itt; 2080a6d42e7dSPeter Dunlap 2081a6d42e7dSPeter Dunlap /* 2082a6d42e7dSPeter Dunlap * Figure out what we're being asked to do. 2083a6d42e7dSPeter Dunlap */ 208430e7468fSPeter Dunlap DTRACE_PROBE4(iscsi__scsi__tm__request, 208530e7468fSPeter Dunlap iscsit_conn_t *, ict, 208630e7468fSPeter Dunlap uint8_t, (iscsi_tm->function & ISCSI_FLAG_TASK_MGMT_FUNCTION_MASK), 208730e7468fSPeter Dunlap uint32_t, iscsi_tm->rtt, 208830e7468fSPeter Dunlap idm_pdu_t *, rx_pdu); 2089a6d42e7dSPeter Dunlap switch (iscsi_tm->function & ISCSI_FLAG_TASK_MGMT_FUNCTION_MASK) { 2090a6d42e7dSPeter Dunlap case ISCSI_TM_FUNC_ABORT_TASK: 2091a6d42e7dSPeter Dunlap /* 2092a6d42e7dSPeter Dunlap * STMF doesn't currently support the "abort task" task 2093a6d42e7dSPeter Dunlap * management command although it does support aborting 2094a6d42e7dSPeter Dunlap * an individual task. We'll get STMF to abort the task 2095a6d42e7dSPeter Dunlap * for us but handle the details of the task management 2096a6d42e7dSPeter Dunlap * command ourselves. 2097a6d42e7dSPeter Dunlap * 2098a6d42e7dSPeter Dunlap * Find the task associated with the referenced task tag. 2099a6d42e7dSPeter Dunlap */ 2100a6d42e7dSPeter Dunlap rtt = iscsi_tm->rtt; 2101a6d42e7dSPeter Dunlap itask = (iscsit_task_t *)idm_task_find_by_handle(ict->ict_ic, 2102a6d42e7dSPeter Dunlap (uintptr_t)rtt); 2103a6d42e7dSPeter Dunlap 2104a6d42e7dSPeter Dunlap if (itask == NULL) { 2105a6d42e7dSPeter Dunlap cmdsn = ntohl(iscsi_tm->cmdsn); 2106a6d42e7dSPeter Dunlap refcmdsn = ntohl(iscsi_tm->refcmdsn); 2107a6d42e7dSPeter Dunlap 2108a6d42e7dSPeter Dunlap /* 2109a6d42e7dSPeter Dunlap * Task was not found. If RefCmdSN is within the CmdSN 2110a6d42e7dSPeter Dunlap * window and less than CmdSN of the TM function, return 2111a6d42e7dSPeter Dunlap * "Function Complete". Otherwise, return 2112a6d42e7dSPeter Dunlap * "Task Does Not Exist". 2113a6d42e7dSPeter Dunlap */ 2114a6d42e7dSPeter Dunlap 2115a6d42e7dSPeter Dunlap if (iscsit_cmdsn_in_window(ict, refcmdsn) && 2116a6d42e7dSPeter Dunlap (refcmdsn < cmdsn)) { 2117a6d42e7dSPeter Dunlap iscsit_send_task_mgmt_resp(tm_resp_pdu, 2118a6d42e7dSPeter Dunlap SCSI_TCP_TM_RESP_COMPLETE); 2119a6d42e7dSPeter Dunlap } else { 2120a6d42e7dSPeter Dunlap iscsit_send_task_mgmt_resp(tm_resp_pdu, 2121a6d42e7dSPeter Dunlap SCSI_TCP_TM_RESP_NO_TASK); 2122a6d42e7dSPeter Dunlap } 2123a6d42e7dSPeter Dunlap } else { 2124a6d42e7dSPeter Dunlap 2125a6d42e7dSPeter Dunlap /* 2126a6d42e7dSPeter Dunlap * Tell STMF to abort the task. This will do no harm 2127a6d42e7dSPeter Dunlap * if the task is already complete. 2128a6d42e7dSPeter Dunlap */ 2129a6d42e7dSPeter Dunlap stmf_abort(STMF_QUEUE_TASK_ABORT, itask->it_stmf_task, 2130a6d42e7dSPeter Dunlap STMF_ABORTED, NULL); 2131a6d42e7dSPeter Dunlap 2132a6d42e7dSPeter Dunlap /* 2133a6d42e7dSPeter Dunlap * Make sure the task hasn't already completed 2134a6d42e7dSPeter Dunlap */ 2135a6d42e7dSPeter Dunlap mutex_enter(&itask->it_idm_task->idt_mutex); 2136a6d42e7dSPeter Dunlap if ((itask->it_idm_task->idt_state == TASK_COMPLETE) || 2137a6d42e7dSPeter Dunlap (itask->it_idm_task->idt_state == TASK_IDLE)) { 2138a6d42e7dSPeter Dunlap /* 2139a6d42e7dSPeter Dunlap * Task is complete, return "Task Does Not 2140a6d42e7dSPeter Dunlap * Exist" 2141a6d42e7dSPeter Dunlap */ 2142a6d42e7dSPeter Dunlap mutex_exit(&itask->it_idm_task->idt_mutex); 2143a6d42e7dSPeter Dunlap iscsit_send_task_mgmt_resp(tm_resp_pdu, 2144a6d42e7dSPeter Dunlap SCSI_TCP_TM_RESP_NO_TASK); 2145a6d42e7dSPeter Dunlap } else { 2146a6d42e7dSPeter Dunlap /* 2147a6d42e7dSPeter Dunlap * STMF is now aborting the task, return 2148a6d42e7dSPeter Dunlap * "Function Complete" 2149a6d42e7dSPeter Dunlap */ 2150a6d42e7dSPeter Dunlap mutex_exit(&itask->it_idm_task->idt_mutex); 2151a6d42e7dSPeter Dunlap iscsit_send_task_mgmt_resp(tm_resp_pdu, 2152a6d42e7dSPeter Dunlap SCSI_TCP_TM_RESP_COMPLETE); 2153a6d42e7dSPeter Dunlap } 2154a6d42e7dSPeter Dunlap idm_task_rele(itask->it_idm_task); 2155a6d42e7dSPeter Dunlap } 2156a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2157a6d42e7dSPeter Dunlap return; 2158a6d42e7dSPeter Dunlap 2159a6d42e7dSPeter Dunlap case ISCSI_TM_FUNC_ABORT_TASK_SET: 2160a6d42e7dSPeter Dunlap tm_func = TM_ABORT_TASK_SET; 2161a6d42e7dSPeter Dunlap break; 2162a6d42e7dSPeter Dunlap 2163a6d42e7dSPeter Dunlap case ISCSI_TM_FUNC_CLEAR_ACA: 2164a6d42e7dSPeter Dunlap tm_func = TM_CLEAR_ACA; 2165a6d42e7dSPeter Dunlap break; 2166a6d42e7dSPeter Dunlap 2167a6d42e7dSPeter Dunlap case ISCSI_TM_FUNC_CLEAR_TASK_SET: 2168a6d42e7dSPeter Dunlap tm_func = TM_CLEAR_TASK_SET; 2169a6d42e7dSPeter Dunlap break; 2170a6d42e7dSPeter Dunlap 2171a6d42e7dSPeter Dunlap case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET: 2172a6d42e7dSPeter Dunlap tm_func = TM_LUN_RESET; 2173a6d42e7dSPeter Dunlap break; 2174a6d42e7dSPeter Dunlap 2175a6d42e7dSPeter Dunlap case ISCSI_TM_FUNC_TARGET_WARM_RESET: 2176a6d42e7dSPeter Dunlap tm_func = TM_TARGET_WARM_RESET; 2177a6d42e7dSPeter Dunlap break; 2178a6d42e7dSPeter Dunlap 2179a6d42e7dSPeter Dunlap case ISCSI_TM_FUNC_TARGET_COLD_RESET: 2180a6d42e7dSPeter Dunlap tm_func = TM_TARGET_COLD_RESET; 2181a6d42e7dSPeter Dunlap break; 2182a6d42e7dSPeter Dunlap 2183a6d42e7dSPeter Dunlap case ISCSI_TM_FUNC_TASK_REASSIGN: 2184a6d42e7dSPeter Dunlap /* 2185a6d42e7dSPeter Dunlap * We do not currently support allegiance reassignment. When 2186a6d42e7dSPeter Dunlap * we start supporting ERL1+, we will need to. 2187a6d42e7dSPeter Dunlap */ 2188a6d42e7dSPeter Dunlap iscsit_send_task_mgmt_resp(tm_resp_pdu, 2189a6d42e7dSPeter Dunlap SCSI_TCP_TM_RESP_NO_ALLG_REASSN); 2190a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2191a6d42e7dSPeter Dunlap return; 2192a6d42e7dSPeter Dunlap 2193a6d42e7dSPeter Dunlap default: 2194a6d42e7dSPeter Dunlap iscsit_send_task_mgmt_resp(tm_resp_pdu, 2195a6d42e7dSPeter Dunlap SCSI_TCP_TM_RESP_REJECTED); 2196a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2197a6d42e7dSPeter Dunlap return; 2198a6d42e7dSPeter Dunlap } 2199a6d42e7dSPeter Dunlap 2200a6d42e7dSPeter Dunlap tm_itask = iscsit_tm_task_alloc(ict); 2201a6d42e7dSPeter Dunlap if (tm_itask == NULL) { 2202a6d42e7dSPeter Dunlap iscsit_send_task_mgmt_resp(tm_resp_pdu, 2203a6d42e7dSPeter Dunlap SCSI_TCP_TM_RESP_REJECTED); 2204a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2205a6d42e7dSPeter Dunlap return; 2206a6d42e7dSPeter Dunlap } 2207a6d42e7dSPeter Dunlap 2208a6d42e7dSPeter Dunlap 2209a6d42e7dSPeter Dunlap task = stmf_task_alloc(ict->ict_sess->ist_lport, 2210a6d42e7dSPeter Dunlap ict->ict_sess->ist_stmf_sess, iscsi_tm->lun, 2211a6d42e7dSPeter Dunlap 0, STMF_TASK_EXT_NONE); 2212a6d42e7dSPeter Dunlap if (task == NULL) { 2213a6d42e7dSPeter Dunlap /* 2214a6d42e7dSPeter Dunlap * If this happens, either the LU is in reset, couldn't 2215a6d42e7dSPeter Dunlap * get memory, or some other condition in which we simply 2216a6d42e7dSPeter Dunlap * can't complete this request. It would be nice to return 2217a6d42e7dSPeter Dunlap * an error code like "busy" but the closest we have is 2218a6d42e7dSPeter Dunlap * "rejected". 2219a6d42e7dSPeter Dunlap */ 2220a6d42e7dSPeter Dunlap iscsit_send_task_mgmt_resp(tm_resp_pdu, 2221a6d42e7dSPeter Dunlap SCSI_TCP_TM_RESP_REJECTED); 2222a6d42e7dSPeter Dunlap iscsit_tm_task_free(tm_itask); 2223a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2224a6d42e7dSPeter Dunlap return; 2225a6d42e7dSPeter Dunlap } 2226a6d42e7dSPeter Dunlap 2227a6d42e7dSPeter Dunlap tm_itask->it_tm_pdu = tm_resp_pdu; 2228a6d42e7dSPeter Dunlap tm_itask->it_stmf_task = task; 2229a6d42e7dSPeter Dunlap task->task_port_private = tm_itask; 2230a6d42e7dSPeter Dunlap task->task_mgmt_function = tm_func; 2231a6d42e7dSPeter Dunlap task->task_additional_flags = TASK_AF_NO_EXPECTED_XFER_LENGTH; 2232a6d42e7dSPeter Dunlap task->task_priority = 0; 2233a6d42e7dSPeter Dunlap task->task_max_nbufs = STMF_BUFS_MAX; 2234a6d42e7dSPeter Dunlap task->task_cmd_seq_no = iscsi_tm->itt; 2235a6d42e7dSPeter Dunlap task->task_expected_xfer_length = 0; 2236a6d42e7dSPeter Dunlap 2237a6d42e7dSPeter Dunlap stmf_post_task(task, NULL); 2238a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2239a6d42e7dSPeter Dunlap } 2240a6d42e7dSPeter Dunlap 2241a6d42e7dSPeter Dunlap static void 2242a6d42e7dSPeter Dunlap iscsit_pdu_op_noop(iscsit_conn_t *ict, idm_pdu_t *rx_pdu) 2243a6d42e7dSPeter Dunlap { 2244a6d42e7dSPeter Dunlap iscsi_nop_out_hdr_t *out = (iscsi_nop_out_hdr_t *)rx_pdu->isp_hdr; 2245a6d42e7dSPeter Dunlap iscsi_nop_in_hdr_t *in; 2246a6d42e7dSPeter Dunlap int resp_datalen; 2247a6d42e7dSPeter Dunlap idm_pdu_t *resp; 2248a6d42e7dSPeter Dunlap 2249a6d42e7dSPeter Dunlap /* Ignore the response from initiator */ 225072cf3143Speter dunlap if ((out->itt == ISCSI_RSVD_TASK_TAG) || 225172cf3143Speter dunlap (out->ttt != ISCSI_RSVD_TASK_TAG)) { 225272cf3143Speter dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2253a6d42e7dSPeter Dunlap return; 225472cf3143Speter dunlap } 2255a6d42e7dSPeter Dunlap 2256a6d42e7dSPeter Dunlap /* Allocate a PDU to respond */ 2257a6d42e7dSPeter Dunlap resp_datalen = ntoh24(out->dlength); 2258a6d42e7dSPeter Dunlap resp = idm_pdu_alloc(sizeof (iscsi_hdr_t), resp_datalen); 2259a6d42e7dSPeter Dunlap idm_pdu_init(resp, ict->ict_ic, NULL, NULL); 2260a6d42e7dSPeter Dunlap if (resp_datalen > 0) { 2261a6d42e7dSPeter Dunlap bcopy(rx_pdu->isp_data, resp->isp_data, resp_datalen); 2262a6d42e7dSPeter Dunlap } 2263a6d42e7dSPeter Dunlap 2264a6d42e7dSPeter Dunlap in = (iscsi_nop_in_hdr_t *)resp->isp_hdr; 2265a6d42e7dSPeter Dunlap bzero(in, sizeof (*in)); 2266a6d42e7dSPeter Dunlap in->opcode = ISCSI_OP_NOOP_IN; 2267a6d42e7dSPeter Dunlap in->flags = ISCSI_FLAG_FINAL; 2268a6d42e7dSPeter Dunlap bcopy(out->lun, in->lun, 8); 2269a6d42e7dSPeter Dunlap in->itt = out->itt; 2270a6d42e7dSPeter Dunlap in->ttt = ISCSI_RSVD_TASK_TAG; 2271a6d42e7dSPeter Dunlap hton24(in->dlength, resp_datalen); 2272a6d42e7dSPeter Dunlap 2273a6d42e7dSPeter Dunlap /* Any other field in resp to be set? */ 2274a6d42e7dSPeter Dunlap iscsit_pdu_tx(resp); 2275a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2276a6d42e7dSPeter Dunlap } 2277a6d42e7dSPeter Dunlap 2278a6d42e7dSPeter Dunlap static void 2279a6d42e7dSPeter Dunlap iscsit_pdu_op_login_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu) 2280a6d42e7dSPeter Dunlap { 2281a6d42e7dSPeter Dunlap 2282a6d42e7dSPeter Dunlap /* 2283a6d42e7dSPeter Dunlap * Submit PDU to login state machine. State machine will free the 2284a6d42e7dSPeter Dunlap * PDU. 2285a6d42e7dSPeter Dunlap */ 2286a6d42e7dSPeter Dunlap iscsit_login_sm_event(ict, ILE_LOGIN_RCV, rx_pdu); 2287a6d42e7dSPeter Dunlap } 2288a6d42e7dSPeter Dunlap 2289a6d42e7dSPeter Dunlap void 2290a6d42e7dSPeter Dunlap iscsit_pdu_op_logout_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu) 2291a6d42e7dSPeter Dunlap { 2292a6d42e7dSPeter Dunlap iscsi_logout_hdr_t *logout_req = 2293a6d42e7dSPeter Dunlap (iscsi_logout_hdr_t *)rx_pdu->isp_hdr; 2294a6d42e7dSPeter Dunlap iscsi_logout_rsp_hdr_t *logout_rsp; 2295a6d42e7dSPeter Dunlap idm_pdu_t *resp; 2296a6d42e7dSPeter Dunlap 2297a6d42e7dSPeter Dunlap /* Allocate a PDU to respond */ 2298a6d42e7dSPeter Dunlap resp = idm_pdu_alloc(sizeof (iscsi_hdr_t), 0); 2299a6d42e7dSPeter Dunlap idm_pdu_init(resp, ict->ict_ic, NULL, NULL); 2300a6d42e7dSPeter Dunlap 2301a6d42e7dSPeter Dunlap /* 2302a6d42e7dSPeter Dunlap * Logout results in the immediate termination of all tasks except 2303a6d42e7dSPeter Dunlap * if the logout reason is ISCSI_LOGOUT_REASON_RECOVERY. The 2304a6d42e7dSPeter Dunlap * connection state machine will drive this task cleanup automatically 2305a6d42e7dSPeter Dunlap * so we don't need to handle that here. 2306a6d42e7dSPeter Dunlap */ 2307a6d42e7dSPeter Dunlap logout_rsp = (iscsi_logout_rsp_hdr_t *)resp->isp_hdr; 2308a6d42e7dSPeter Dunlap bzero(logout_rsp, sizeof (*logout_rsp)); 2309a6d42e7dSPeter Dunlap logout_rsp->opcode = ISCSI_OP_LOGOUT_RSP; 2310a6d42e7dSPeter Dunlap logout_rsp->flags = ISCSI_FLAG_FINAL; 2311a6d42e7dSPeter Dunlap logout_rsp->itt = logout_req->itt; 2312a6d42e7dSPeter Dunlap if ((logout_req->flags & ISCSI_FLAG_LOGOUT_REASON_MASK) > 2313a6d42e7dSPeter Dunlap ISCSI_LOGOUT_REASON_RECOVERY) { 2314a6d42e7dSPeter Dunlap logout_rsp->response = ISCSI_LOGOUT_RECOVERY_UNSUPPORTED; 2315a6d42e7dSPeter Dunlap } else { 2316a6d42e7dSPeter Dunlap logout_rsp->response = ISCSI_LOGOUT_SUCCESS; 2317a6d42e7dSPeter Dunlap } 2318a6d42e7dSPeter Dunlap 2319a6d42e7dSPeter Dunlap iscsit_pdu_tx(resp); 2320a6d42e7dSPeter Dunlap idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2321a6d42e7dSPeter Dunlap } 2322a6d42e7dSPeter Dunlap 2323a6d42e7dSPeter Dunlap /* 2324a6d42e7dSPeter Dunlap * Calculate the number of outstanding commands we can process 2325a6d42e7dSPeter Dunlap */ 2326a6d42e7dSPeter Dunlap int 2327a6d42e7dSPeter Dunlap iscsit_cmd_window() 2328a6d42e7dSPeter Dunlap { 2329a6d42e7dSPeter Dunlap /* Will be better later */ 2330a6d42e7dSPeter Dunlap return (1024); 2331a6d42e7dSPeter Dunlap } 2332a6d42e7dSPeter Dunlap 2333a6d42e7dSPeter Dunlap /* 2334a6d42e7dSPeter Dunlap * Set local registers based on incoming PDU 2335a6d42e7dSPeter Dunlap */ 2336a6d42e7dSPeter Dunlap void 2337a6d42e7dSPeter Dunlap iscsit_set_cmdsn(iscsit_conn_t *ict, idm_pdu_t *rx_pdu) 2338a6d42e7dSPeter Dunlap { 2339a6d42e7dSPeter Dunlap iscsit_sess_t *ist; 2340a6d42e7dSPeter Dunlap iscsi_scsi_cmd_hdr_t *req; 2341a6d42e7dSPeter Dunlap 2342a6d42e7dSPeter Dunlap ist = ict->ict_sess; 2343a6d42e7dSPeter Dunlap 2344a6d42e7dSPeter Dunlap req = (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr; 2345a6d42e7dSPeter Dunlap 2346a6d42e7dSPeter Dunlap rw_enter(&ist->ist_sn_rwlock, RW_WRITER); 2347a6d42e7dSPeter Dunlap ist->ist_expcmdsn = ntohl(req->cmdsn) + 1; 2348a6d42e7dSPeter Dunlap ist->ist_maxcmdsn = ntohl(req->cmdsn) + iscsit_cmd_window(); 2349a6d42e7dSPeter Dunlap rw_exit(&ist->ist_sn_rwlock); 2350a6d42e7dSPeter Dunlap } 2351a6d42e7dSPeter Dunlap 2352a6d42e7dSPeter Dunlap /* 2353a6d42e7dSPeter Dunlap * Update local StatSN and set SNs in response 2354a6d42e7dSPeter Dunlap */ 2355a6d42e7dSPeter Dunlap static void 2356a6d42e7dSPeter Dunlap iscsit_calc_rspsn(iscsit_conn_t *ict, idm_pdu_t *resp) 2357a6d42e7dSPeter Dunlap { 2358a6d42e7dSPeter Dunlap iscsit_sess_t *ist; 2359a6d42e7dSPeter Dunlap iscsi_scsi_rsp_hdr_t *rsp; 2360a6d42e7dSPeter Dunlap 2361a6d42e7dSPeter Dunlap /* Get iSCSI session handle */ 2362a6d42e7dSPeter Dunlap ist = ict->ict_sess; 2363a6d42e7dSPeter Dunlap 2364a6d42e7dSPeter Dunlap rsp = (iscsi_scsi_rsp_hdr_t *)resp->isp_hdr; 2365a6d42e7dSPeter Dunlap 2366a6d42e7dSPeter Dunlap /* Update StatSN */ 2367a6d42e7dSPeter Dunlap rsp->statsn = htonl(ict->ict_statsn); 2368a6d42e7dSPeter Dunlap switch (IDM_PDU_OPCODE(resp)) { 2369a6d42e7dSPeter Dunlap case ISCSI_OP_RTT_RSP: 2370a6d42e7dSPeter Dunlap /* Do nothing */ 2371a6d42e7dSPeter Dunlap break; 2372a6d42e7dSPeter Dunlap case ISCSI_OP_NOOP_IN: 2373a6d42e7dSPeter Dunlap /* 2374a6d42e7dSPeter Dunlap * Refer to section 10.19.1, RFC3720. 2375a6d42e7dSPeter Dunlap * Advance only if target is responding initiator 2376a6d42e7dSPeter Dunlap */ 2377a6d42e7dSPeter Dunlap if (((iscsi_nop_in_hdr_t *)rsp)->ttt == ISCSI_RSVD_TASK_TAG) 2378a6d42e7dSPeter Dunlap ict->ict_statsn++; 2379a6d42e7dSPeter Dunlap break; 2380a6d42e7dSPeter Dunlap case ISCSI_OP_SCSI_DATA_RSP: 2381a6d42e7dSPeter Dunlap if (rsp->flags & ISCSI_FLAG_DATA_STATUS) 2382a6d42e7dSPeter Dunlap ict->ict_statsn++; 2383a6d42e7dSPeter Dunlap else 2384a6d42e7dSPeter Dunlap rsp->statsn = 0; 2385a6d42e7dSPeter Dunlap break; 2386a6d42e7dSPeter Dunlap default: 2387a6d42e7dSPeter Dunlap ict->ict_statsn++; 2388a6d42e7dSPeter Dunlap break; 2389a6d42e7dSPeter Dunlap } 2390a6d42e7dSPeter Dunlap 2391a6d42e7dSPeter Dunlap /* Set ExpCmdSN and MaxCmdSN */ 2392a6d42e7dSPeter Dunlap rsp->maxcmdsn = htonl(ist->ist_maxcmdsn); 2393a6d42e7dSPeter Dunlap rsp->expcmdsn = htonl(ist->ist_expcmdsn); 2394a6d42e7dSPeter Dunlap } 2395a6d42e7dSPeter Dunlap 2396a6d42e7dSPeter Dunlap /* 2397a6d42e7dSPeter Dunlap * Wrapper funtion, calls iscsi_calc_rspsn and idm_pdu_tx 2398a6d42e7dSPeter Dunlap */ 2399a6d42e7dSPeter Dunlap void 2400a6d42e7dSPeter Dunlap iscsit_pdu_tx(idm_pdu_t *pdu) 2401a6d42e7dSPeter Dunlap { 2402a6d42e7dSPeter Dunlap iscsit_conn_t *ict = pdu->isp_ic->ic_handle; 2403a6d42e7dSPeter Dunlap 2404a6d42e7dSPeter Dunlap /* 2405a6d42e7dSPeter Dunlap * Protect ict->ict_statsn, ist->ist_maxcmdsn, and ist->ist_expcmdsn 2406a6d42e7dSPeter Dunlap * (which are used by iscsit_calc_rspsn) with the session mutex 2407a6d42e7dSPeter Dunlap * (ist->ist_sn_mutex). 2408a6d42e7dSPeter Dunlap */ 2409a6d42e7dSPeter Dunlap rw_enter(&ict->ict_sess->ist_sn_rwlock, RW_WRITER); 2410a6d42e7dSPeter Dunlap iscsit_calc_rspsn(ict, pdu); 2411a6d42e7dSPeter Dunlap idm_pdu_tx(pdu); 2412a6d42e7dSPeter Dunlap rw_exit(&ict->ict_sess->ist_sn_rwlock); 2413a6d42e7dSPeter Dunlap } 2414a6d42e7dSPeter Dunlap 2415a6d42e7dSPeter Dunlap /* 2416a6d42e7dSPeter Dunlap * Internal functions 2417a6d42e7dSPeter Dunlap */ 2418a6d42e7dSPeter Dunlap 2419a6d42e7dSPeter Dunlap void 2420a6d42e7dSPeter Dunlap iscsit_send_async_event(iscsit_conn_t *ict, uint8_t event) 2421a6d42e7dSPeter Dunlap { 2422a6d42e7dSPeter Dunlap idm_pdu_t *abt; 2423a6d42e7dSPeter Dunlap iscsi_async_evt_hdr_t *async_abt; 2424a6d42e7dSPeter Dunlap 2425a6d42e7dSPeter Dunlap /* 2426a6d42e7dSPeter Dunlap * Get a PDU to build the abort request. 2427a6d42e7dSPeter Dunlap */ 2428a6d42e7dSPeter Dunlap abt = idm_pdu_alloc(sizeof (iscsi_hdr_t), 0); 2429a6d42e7dSPeter Dunlap if (abt == NULL) { 2430a6d42e7dSPeter Dunlap idm_conn_event(ict->ict_ic, CE_TRANSPORT_FAIL, NULL); 2431a6d42e7dSPeter Dunlap return; 2432a6d42e7dSPeter Dunlap } 2433a6d42e7dSPeter Dunlap 243472cf3143Speter dunlap idm_pdu_init(abt, ict->ict_ic, NULL, NULL); 2435a6d42e7dSPeter Dunlap abt->isp_datalen = 0; 2436a6d42e7dSPeter Dunlap 2437a6d42e7dSPeter Dunlap async_abt = (iscsi_async_evt_hdr_t *)abt->isp_hdr; 2438a6d42e7dSPeter Dunlap bzero(async_abt, sizeof (*async_abt)); 2439a6d42e7dSPeter Dunlap async_abt->opcode = ISCSI_OP_ASYNC_EVENT; 2440a6d42e7dSPeter Dunlap async_abt->async_event = event; 2441a6d42e7dSPeter Dunlap async_abt->flags = ISCSI_FLAG_FINAL; 2442a6d42e7dSPeter Dunlap async_abt->rsvd4[0] = 0xff; 2443a6d42e7dSPeter Dunlap async_abt->rsvd4[1] = 0xff; 2444a6d42e7dSPeter Dunlap async_abt->rsvd4[2] = 0xff; 2445a6d42e7dSPeter Dunlap async_abt->rsvd4[3] = 0xff; 2446a6d42e7dSPeter Dunlap 2447a6d42e7dSPeter Dunlap switch (event) { 2448a6d42e7dSPeter Dunlap case ISCSI_ASYNC_EVENT_REQUEST_LOGOUT: 2449a6d42e7dSPeter Dunlap async_abt->param3 = htons(IDM_LOGOUT_SECONDS); 2450a6d42e7dSPeter Dunlap break; 2451a6d42e7dSPeter Dunlap case ISCSI_ASYNC_EVENT_SCSI_EVENT: 2452a6d42e7dSPeter Dunlap case ISCSI_ASYNC_EVENT_DROPPING_CONNECTION: 2453a6d42e7dSPeter Dunlap case ISCSI_ASYNC_EVENT_DROPPING_ALL_CONNECTIONS: 2454a6d42e7dSPeter Dunlap case ISCSI_ASYNC_EVENT_PARAM_NEGOTIATION: 2455a6d42e7dSPeter Dunlap default: 2456a6d42e7dSPeter Dunlap ASSERT(0); 2457a6d42e7dSPeter Dunlap } 2458a6d42e7dSPeter Dunlap 2459a6d42e7dSPeter Dunlap iscsit_pdu_tx(abt); 2460a6d42e7dSPeter Dunlap } 2461a6d42e7dSPeter Dunlap 246272cf3143Speter dunlap void 246372cf3143Speter dunlap iscsit_send_reject(iscsit_conn_t *ict, idm_pdu_t *rejected_pdu, uint8_t reason) 246472cf3143Speter dunlap { 246572cf3143Speter dunlap idm_pdu_t *reject_pdu; 246672cf3143Speter dunlap iscsi_reject_rsp_hdr_t *reject; 246772cf3143Speter dunlap 246872cf3143Speter dunlap /* 246972cf3143Speter dunlap * Get a PDU to build the abort request. 247072cf3143Speter dunlap */ 247172cf3143Speter dunlap reject_pdu = idm_pdu_alloc(sizeof (iscsi_hdr_t), 247272cf3143Speter dunlap rejected_pdu->isp_hdrlen); 247372cf3143Speter dunlap if (reject_pdu == NULL) { 247472cf3143Speter dunlap idm_conn_event(ict->ict_ic, CE_TRANSPORT_FAIL, NULL); 247572cf3143Speter dunlap return; 247672cf3143Speter dunlap } 247772cf3143Speter dunlap idm_pdu_init(reject_pdu, ict->ict_ic, NULL, NULL); 247872cf3143Speter dunlap 247972cf3143Speter dunlap reject_pdu->isp_datalen = rejected_pdu->isp_hdrlen; 248072cf3143Speter dunlap bcopy(rejected_pdu->isp_hdr, reject_pdu->isp_data, 248172cf3143Speter dunlap rejected_pdu->isp_hdrlen); 248272cf3143Speter dunlap 248372cf3143Speter dunlap reject = (iscsi_reject_rsp_hdr_t *)reject_pdu->isp_hdr; 248472cf3143Speter dunlap bzero(reject, sizeof (*reject)); 248572cf3143Speter dunlap reject->opcode = ISCSI_OP_REJECT_MSG; 248672cf3143Speter dunlap reject->reason = reason; 248772cf3143Speter dunlap reject->flags = ISCSI_FLAG_FINAL; 248872cf3143Speter dunlap hton24(reject->dlength, rejected_pdu->isp_hdrlen); 248972cf3143Speter dunlap reject->must_be_ff[0] = 0xff; 249072cf3143Speter dunlap reject->must_be_ff[1] = 0xff; 249172cf3143Speter dunlap reject->must_be_ff[2] = 0xff; 249272cf3143Speter dunlap reject->must_be_ff[3] = 0xff; 249372cf3143Speter dunlap 249472cf3143Speter dunlap iscsit_pdu_tx(reject_pdu); 249572cf3143Speter dunlap } 249672cf3143Speter dunlap 2497a6d42e7dSPeter Dunlap 2498a6d42e7dSPeter Dunlap static iscsit_task_t * 2499a6d42e7dSPeter Dunlap iscsit_task_alloc(iscsit_conn_t *ict) 2500a6d42e7dSPeter Dunlap { 2501a6d42e7dSPeter Dunlap iscsit_task_t *itask; 2502a6d42e7dSPeter Dunlap iscsit_buf_t *immed_ibuf; 2503a6d42e7dSPeter Dunlap 2504a6d42e7dSPeter Dunlap /* 2505a6d42e7dSPeter Dunlap * Possible items to pre-alloc if we cache iscsit_task_t's: 2506a6d42e7dSPeter Dunlap * 2507a6d42e7dSPeter Dunlap * Status PDU w/ sense buffer 2508a6d42e7dSPeter Dunlap * stmf_data_buf_t for immediate data 2509a6d42e7dSPeter Dunlap */ 2510a6d42e7dSPeter Dunlap itask = kmem_alloc(sizeof (iscsit_task_t) + sizeof (iscsit_buf_t) + 2511a6d42e7dSPeter Dunlap sizeof (stmf_data_buf_t), KM_NOSLEEP); 2512a6d42e7dSPeter Dunlap if (itask != NULL) { 2513a6d42e7dSPeter Dunlap mutex_init(&itask->it_mutex, NULL, MUTEX_DRIVER, NULL); 2514a6d42e7dSPeter Dunlap itask->it_aborted = itask->it_stmf_abort = 2515a6d42e7dSPeter Dunlap itask->it_tm_task = 0; 2516a6d42e7dSPeter Dunlap 2517a6d42e7dSPeter Dunlap immed_ibuf = (iscsit_buf_t *)(itask + 1); 2518a6d42e7dSPeter Dunlap bzero(immed_ibuf, sizeof (*immed_ibuf)); 2519a6d42e7dSPeter Dunlap immed_ibuf->ibuf_is_immed = B_TRUE; 2520a6d42e7dSPeter Dunlap immed_ibuf->ibuf_stmf_buf = (stmf_data_buf_t *)(immed_ibuf + 1); 2521a6d42e7dSPeter Dunlap 2522a6d42e7dSPeter Dunlap bzero(immed_ibuf->ibuf_stmf_buf, sizeof (stmf_data_buf_t)); 2523a6d42e7dSPeter Dunlap immed_ibuf->ibuf_stmf_buf->db_port_private = immed_ibuf; 2524a6d42e7dSPeter Dunlap immed_ibuf->ibuf_stmf_buf->db_sglist_length = 1; 2525a6d42e7dSPeter Dunlap immed_ibuf->ibuf_stmf_buf->db_flags = DB_DIRECTION_FROM_RPORT | 2526a6d42e7dSPeter Dunlap DB_DONT_CACHE; 2527a6d42e7dSPeter Dunlap itask->it_immed_data = immed_ibuf; 2528a6d42e7dSPeter Dunlap itask->it_idm_task = idm_task_alloc(ict->ict_ic); 2529a6d42e7dSPeter Dunlap if (itask->it_idm_task != NULL) { 2530a6d42e7dSPeter Dunlap itask->it_idm_task->idt_private = itask; 2531a6d42e7dSPeter Dunlap itask->it_ict = ict; 2532a6d42e7dSPeter Dunlap itask->it_ttt = itask->it_idm_task->idt_tt; 2533a6d42e7dSPeter Dunlap return (itask); 2534a6d42e7dSPeter Dunlap } else { 2535a6d42e7dSPeter Dunlap kmem_free(itask, sizeof (iscsit_task_t) + 2536a6d42e7dSPeter Dunlap sizeof (iscsit_buf_t) + sizeof (stmf_data_buf_t)); 2537a6d42e7dSPeter Dunlap } 2538a6d42e7dSPeter Dunlap } 2539a6d42e7dSPeter Dunlap 2540a6d42e7dSPeter Dunlap return (NULL); 2541a6d42e7dSPeter Dunlap } 2542a6d42e7dSPeter Dunlap 2543a6d42e7dSPeter Dunlap static void 2544a6d42e7dSPeter Dunlap iscsit_task_free(iscsit_task_t *itask) 2545a6d42e7dSPeter Dunlap { 2546a6d42e7dSPeter Dunlap idm_task_free(itask->it_idm_task); 2547a6d42e7dSPeter Dunlap mutex_destroy(&itask->it_mutex); 2548a6d42e7dSPeter Dunlap kmem_free(itask, sizeof (iscsit_task_t) + 2549a6d42e7dSPeter Dunlap sizeof (iscsit_buf_t) + sizeof (stmf_data_buf_t)); 2550a6d42e7dSPeter Dunlap } 2551a6d42e7dSPeter Dunlap 2552a6d42e7dSPeter Dunlap static iscsit_task_t * 2553a6d42e7dSPeter Dunlap iscsit_tm_task_alloc(iscsit_conn_t *ict) 2554a6d42e7dSPeter Dunlap { 2555a6d42e7dSPeter Dunlap iscsit_task_t *itask; 2556a6d42e7dSPeter Dunlap 2557a6d42e7dSPeter Dunlap itask = kmem_zalloc(sizeof (iscsit_task_t), KM_NOSLEEP); 2558a6d42e7dSPeter Dunlap if (itask != NULL) { 2559a6d42e7dSPeter Dunlap idm_conn_hold(ict->ict_ic); 2560a6d42e7dSPeter Dunlap mutex_init(&itask->it_mutex, NULL, MUTEX_DRIVER, NULL); 2561a6d42e7dSPeter Dunlap itask->it_aborted = itask->it_stmf_abort = 2562a6d42e7dSPeter Dunlap itask->it_tm_responded = 0; 2563a6d42e7dSPeter Dunlap itask->it_tm_pdu = NULL; 2564a6d42e7dSPeter Dunlap itask->it_tm_task = 1; 2565a6d42e7dSPeter Dunlap itask->it_ict = ict; 2566a6d42e7dSPeter Dunlap } 2567a6d42e7dSPeter Dunlap 2568a6d42e7dSPeter Dunlap return (itask); 2569a6d42e7dSPeter Dunlap } 2570a6d42e7dSPeter Dunlap 2571a6d42e7dSPeter Dunlap static void 2572a6d42e7dSPeter Dunlap iscsit_tm_task_free(iscsit_task_t *itask) 2573a6d42e7dSPeter Dunlap { 2574a6d42e7dSPeter Dunlap /* 2575a6d42e7dSPeter Dunlap * If we responded then the call to idm_pdu_complete will free the 2576a6d42e7dSPeter Dunlap * PDU. Otherwise we got aborted before the TM function could 2577a6d42e7dSPeter Dunlap * complete and we need to free the PDU explicitly. 2578a6d42e7dSPeter Dunlap */ 2579a6d42e7dSPeter Dunlap if (itask->it_tm_pdu != NULL && !itask->it_tm_responded) 2580a6d42e7dSPeter Dunlap idm_pdu_free(itask->it_tm_pdu); 2581a6d42e7dSPeter Dunlap idm_conn_rele(itask->it_ict->ict_ic); 2582a6d42e7dSPeter Dunlap mutex_destroy(&itask->it_mutex); 2583a6d42e7dSPeter Dunlap kmem_free(itask, sizeof (iscsit_task_t)); 2584a6d42e7dSPeter Dunlap } 2585a6d42e7dSPeter Dunlap 258672cf3143Speter dunlap static idm_status_t 258772cf3143Speter dunlap iscsit_task_start(iscsit_task_t *itask) 258872cf3143Speter dunlap { 258972cf3143Speter dunlap iscsit_sess_t *ist = itask->it_ict->ict_sess; 259072cf3143Speter dunlap avl_index_t where; 259172cf3143Speter dunlap 259272cf3143Speter dunlap /* 259372cf3143Speter dunlap * Sanity check the ITT and ensure that this task does not already 259472cf3143Speter dunlap * exist. If not then add the task to the session task list. 259572cf3143Speter dunlap */ 259672cf3143Speter dunlap mutex_enter(&ist->ist_mutex); 259772cf3143Speter dunlap mutex_enter(&itask->it_mutex); 259872cf3143Speter dunlap itask->it_active = 1; 259972cf3143Speter dunlap if (avl_find(&ist->ist_task_list, itask, &where) == NULL) { 260072cf3143Speter dunlap /* New task, add to AVL */ 260172cf3143Speter dunlap avl_insert(&ist->ist_task_list, itask, where); 260272cf3143Speter dunlap mutex_exit(&itask->it_mutex); 260372cf3143Speter dunlap mutex_exit(&ist->ist_mutex); 260472cf3143Speter dunlap return (IDM_STATUS_SUCCESS); 260572cf3143Speter dunlap } 260672cf3143Speter dunlap mutex_exit(&itask->it_mutex); 260772cf3143Speter dunlap mutex_exit(&ist->ist_mutex); 260872cf3143Speter dunlap 260972cf3143Speter dunlap return (IDM_STATUS_REJECT); 261072cf3143Speter dunlap } 261172cf3143Speter dunlap 261272cf3143Speter dunlap static void 261372cf3143Speter dunlap iscsit_task_done(iscsit_task_t *itask) 261472cf3143Speter dunlap { 261572cf3143Speter dunlap iscsit_sess_t *ist = itask->it_ict->ict_sess; 261672cf3143Speter dunlap 261772cf3143Speter dunlap mutex_enter(&ist->ist_mutex); 261872cf3143Speter dunlap mutex_enter(&itask->it_mutex); 261972cf3143Speter dunlap if (itask->it_active) { 262072cf3143Speter dunlap avl_remove(&ist->ist_task_list, itask); 262172cf3143Speter dunlap itask->it_active = 0; 262272cf3143Speter dunlap } 262372cf3143Speter dunlap mutex_exit(&itask->it_mutex); 262472cf3143Speter dunlap mutex_exit(&ist->ist_mutex); 262572cf3143Speter dunlap } 262672cf3143Speter dunlap 2627a6d42e7dSPeter Dunlap /* 2628a6d42e7dSPeter Dunlap * iscsit status PDU cache 2629a6d42e7dSPeter Dunlap */ 2630a6d42e7dSPeter Dunlap 2631a6d42e7dSPeter Dunlap /*ARGSUSED*/ 2632a6d42e7dSPeter Dunlap static int 2633a6d42e7dSPeter Dunlap iscsit_status_pdu_constructor(void *pdu_void, void *arg, int flags) 2634a6d42e7dSPeter Dunlap { 2635a6d42e7dSPeter Dunlap idm_pdu_t *pdu = pdu_void; 2636a6d42e7dSPeter Dunlap iscsi_scsi_rsp_hdr_t *rsp; 2637a6d42e7dSPeter Dunlap 2638a6d42e7dSPeter Dunlap bzero(pdu, sizeof (idm_pdu_t)); 2639a6d42e7dSPeter Dunlap pdu->isp_callback = iscsit_send_good_status_done; 2640a6d42e7dSPeter Dunlap pdu->isp_magic = IDM_PDU_MAGIC; 2641a6d42e7dSPeter Dunlap pdu->isp_hdr = (iscsi_hdr_t *)(pdu + 1); /* Ptr arithmetic */ 2642a6d42e7dSPeter Dunlap pdu->isp_hdrlen = sizeof (iscsi_hdr_t); 2643a6d42e7dSPeter Dunlap 2644a6d42e7dSPeter Dunlap /* Setup status response */ 2645a6d42e7dSPeter Dunlap rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr; 2646a6d42e7dSPeter Dunlap bzero(rsp, sizeof (*rsp)); 2647a6d42e7dSPeter Dunlap rsp->opcode = ISCSI_OP_SCSI_RSP; 2648a6d42e7dSPeter Dunlap rsp->flags = ISCSI_FLAG_FINAL; 2649a6d42e7dSPeter Dunlap rsp->response = ISCSI_STATUS_CMD_COMPLETED; 2650a6d42e7dSPeter Dunlap 2651a6d42e7dSPeter Dunlap return (0); 2652a6d42e7dSPeter Dunlap } 2653a6d42e7dSPeter Dunlap 2654a6d42e7dSPeter Dunlap /* 2655a6d42e7dSPeter Dunlap * iscsit private data handler 2656a6d42e7dSPeter Dunlap */ 2657a6d42e7dSPeter Dunlap 2658a6d42e7dSPeter Dunlap /*ARGSUSED*/ 2659a6d42e7dSPeter Dunlap static void 2660a6d42e7dSPeter Dunlap iscsit_pp_cb(struct stmf_port_provider *pp, int cmd, void *arg, uint32_t flags) 2661a6d42e7dSPeter Dunlap { 2662a6d42e7dSPeter Dunlap it_config_t *cfg; 2663a6d42e7dSPeter Dunlap nvlist_t *nvl; 2664a6d42e7dSPeter Dunlap 2665a6d42e7dSPeter Dunlap if ((cmd != STMF_PROVIDER_DATA_UPDATED) || (arg == NULL)) { 2666a6d42e7dSPeter Dunlap return; 2667a6d42e7dSPeter Dunlap } 2668a6d42e7dSPeter Dunlap 2669a6d42e7dSPeter Dunlap nvl = (nvlist_t *)arg; 2670a6d42e7dSPeter Dunlap 2671a6d42e7dSPeter Dunlap /* Translate nvlist */ 2672a6d42e7dSPeter Dunlap if (it_nv_to_config(nvl, &cfg) != 0) { 2673a6d42e7dSPeter Dunlap cmn_err(CE_WARN, "Configuration is invalid"); 2674a6d42e7dSPeter Dunlap return; 2675a6d42e7dSPeter Dunlap } 2676a6d42e7dSPeter Dunlap 2677a6d42e7dSPeter Dunlap /* Update config */ 2678a6d42e7dSPeter Dunlap (void) iscsit_config_merge(cfg); 2679a6d42e7dSPeter Dunlap 2680a6d42e7dSPeter Dunlap it_config_free_cmn(cfg); 2681a6d42e7dSPeter Dunlap } 2682a6d42e7dSPeter Dunlap 2683a6d42e7dSPeter Dunlap 2684a6d42e7dSPeter Dunlap static it_cfg_status_t 2685a6d42e7dSPeter Dunlap iscsit_config_merge(it_config_t *in_cfg) 2686a6d42e7dSPeter Dunlap { 2687a6d42e7dSPeter Dunlap it_cfg_status_t status; 2688a6d42e7dSPeter Dunlap it_config_t *cfg; 2689a6d42e7dSPeter Dunlap it_config_t tmp_cfg; 2690a6d42e7dSPeter Dunlap list_t tpg_del_list; 2691a6d42e7dSPeter Dunlap 2692a6d42e7dSPeter Dunlap if (in_cfg) { 2693a6d42e7dSPeter Dunlap cfg = in_cfg; 2694a6d42e7dSPeter Dunlap } else { 2695a6d42e7dSPeter Dunlap /* Make empty config */ 2696a6d42e7dSPeter Dunlap bzero(&tmp_cfg, sizeof (tmp_cfg)); 2697a6d42e7dSPeter Dunlap cfg = &tmp_cfg; 2698a6d42e7dSPeter Dunlap } 2699a6d42e7dSPeter Dunlap 2700a6d42e7dSPeter Dunlap list_create(&tpg_del_list, sizeof (iscsit_tpg_t), 2701a6d42e7dSPeter Dunlap offsetof(iscsit_tpg_t, tpg_delete_ln)); 2702a6d42e7dSPeter Dunlap 2703a6d42e7dSPeter Dunlap /* 2704a6d42e7dSPeter Dunlap * Update targets, initiator contexts, target portal groups, 2705a6d42e7dSPeter Dunlap * and iSNS client 2706a6d42e7dSPeter Dunlap */ 2707a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_LOCK(RW_WRITER); 2708a6d42e7dSPeter Dunlap if (((status = iscsit_config_merge_tpg(cfg, &tpg_del_list)) 2709a6d42e7dSPeter Dunlap != 0) || 2710a6d42e7dSPeter Dunlap ((status = iscsit_config_merge_tgt(cfg)) != 0) || 2711a6d42e7dSPeter Dunlap ((status = iscsit_config_merge_ini(cfg)) != 0) || 2712a6d42e7dSPeter Dunlap ((status = isnst_config_merge(cfg)) != 0)) { 2713a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_UNLOCK(); 2714a6d42e7dSPeter Dunlap return (status); 2715a6d42e7dSPeter Dunlap } 2716a6d42e7dSPeter Dunlap 2717a6d42e7dSPeter Dunlap /* Update other global config parameters */ 2718a6d42e7dSPeter Dunlap if (iscsit_global.global_props) { 2719a6d42e7dSPeter Dunlap nvlist_free(iscsit_global.global_props); 2720a6d42e7dSPeter Dunlap iscsit_global.global_props = NULL; 2721a6d42e7dSPeter Dunlap } 2722a6d42e7dSPeter Dunlap if (in_cfg) { 2723a6d42e7dSPeter Dunlap (void) nvlist_dup(cfg->config_global_properties, 2724a6d42e7dSPeter Dunlap &iscsit_global.global_props, KM_SLEEP); 2725a6d42e7dSPeter Dunlap } 2726a6d42e7dSPeter Dunlap ISCSIT_GLOBAL_UNLOCK(); 2727a6d42e7dSPeter Dunlap 2728a6d42e7dSPeter Dunlap iscsit_config_destroy_tpgs(&tpg_del_list); 2729a6d42e7dSPeter Dunlap 2730a6d42e7dSPeter Dunlap list_destroy(&tpg_del_list); 2731a6d42e7dSPeter Dunlap 2732a6d42e7dSPeter Dunlap return (ITCFG_SUCCESS); 2733a6d42e7dSPeter Dunlap } 2734a6d42e7dSPeter Dunlap 2735a6d42e7dSPeter Dunlap /* 2736a6d42e7dSPeter Dunlap * iscsit_sna_lt[e] 2737a6d42e7dSPeter Dunlap * 2738a6d42e7dSPeter Dunlap * Compare serial numbers using serial number arithmetic as defined in 2739a6d42e7dSPeter Dunlap * RFC 1982. 2740a6d42e7dSPeter Dunlap * 2741a6d42e7dSPeter Dunlap * NOTE: This code is duplicated in the isns server as well as iscsitgtd. It 2742a6d42e7dSPeter Dunlap * ought to be common. 2743a6d42e7dSPeter Dunlap */ 2744a6d42e7dSPeter Dunlap 2745a6d42e7dSPeter Dunlap static int 2746a6d42e7dSPeter Dunlap iscsit_sna_lt(uint32_t sn1, uint32_t sn2) 2747a6d42e7dSPeter Dunlap { 2748a6d42e7dSPeter Dunlap return ((sn1 != sn2) && 2749a6d42e7dSPeter Dunlap (((sn1 < sn2) && ((sn2 - sn1) < ISCSIT_SNA32_CHECK)) || 2750a6d42e7dSPeter Dunlap ((sn1 > sn2) && ((sn1 - sn2) > ISCSIT_SNA32_CHECK)))); 2751a6d42e7dSPeter Dunlap } 2752a6d42e7dSPeter Dunlap 2753a6d42e7dSPeter Dunlap static int 2754a6d42e7dSPeter Dunlap iscsit_sna_lte(uint32_t sn1, uint32_t sn2) 2755a6d42e7dSPeter Dunlap { 2756a6d42e7dSPeter Dunlap return ((sn1 == sn2) || 2757a6d42e7dSPeter Dunlap (((sn1 < sn2) && ((sn2 - sn1) < ISCSIT_SNA32_CHECK)) || 2758a6d42e7dSPeter Dunlap ((sn1 > sn2) && ((sn1 - sn2) > ISCSIT_SNA32_CHECK)))); 2759a6d42e7dSPeter Dunlap } 2760a6d42e7dSPeter Dunlap 2761a6d42e7dSPeter Dunlap 2762a6d42e7dSPeter Dunlap static boolean_t 2763a6d42e7dSPeter Dunlap iscsit_cmdsn_in_window(iscsit_conn_t *ict, uint32_t cmdsn) 2764a6d42e7dSPeter Dunlap { 2765a6d42e7dSPeter Dunlap iscsit_sess_t *ist = ict->ict_sess; 2766a6d42e7dSPeter Dunlap int rval = B_TRUE; 2767a6d42e7dSPeter Dunlap 2768a6d42e7dSPeter Dunlap ist = ict->ict_sess; 2769a6d42e7dSPeter Dunlap 2770a6d42e7dSPeter Dunlap rw_enter(&ist->ist_sn_rwlock, RW_READER); 2771a6d42e7dSPeter Dunlap 2772a6d42e7dSPeter Dunlap /* 2773a6d42e7dSPeter Dunlap * If cmdsn is less than ist_expcmdsn - iscsit_cmd_window() or 2774a6d42e7dSPeter Dunlap * greater than ist_expcmdsn, it's not in the window. 2775a6d42e7dSPeter Dunlap */ 2776a6d42e7dSPeter Dunlap 2777a6d42e7dSPeter Dunlap if (iscsit_sna_lt(cmdsn, (ist->ist_expcmdsn - iscsit_cmd_window())) || 2778a6d42e7dSPeter Dunlap !iscsit_sna_lte(cmdsn, ist->ist_expcmdsn)) { 2779a6d42e7dSPeter Dunlap rval = B_FALSE; 2780a6d42e7dSPeter Dunlap } 2781a6d42e7dSPeter Dunlap 2782a6d42e7dSPeter Dunlap rw_exit(&ist->ist_sn_rwlock); 2783a6d42e7dSPeter Dunlap 2784a6d42e7dSPeter Dunlap return (rval); 2785a6d42e7dSPeter Dunlap } 2786