1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 23 * 24 * Copyright 2014 Nexenta Systems, Inc. All rights reserved. 25 */ 26 27 #include <sys/cpuvar.h> 28 #include <sys/types.h> 29 #include <sys/conf.h> 30 #include <sys/stat.h> 31 #include <sys/file.h> 32 #include <sys/ddi.h> 33 #include <sys/sunddi.h> 34 #include <sys/modctl.h> 35 #include <sys/sysmacros.h> 36 #include <sys/socket.h> 37 #include <sys/strsubr.h> 38 #include <sys/nvpair.h> 39 40 #include <sys/stmf.h> 41 #include <sys/stmf_ioctl.h> 42 #include <sys/portif.h> 43 #include <sys/idm/idm.h> 44 #include <sys/idm/idm_conn_sm.h> 45 46 #include "iscsit_isns.h" 47 #include "iscsit.h" 48 49 #define ISCSIT_VERSION BUILD_DATE "-1.18dev" 50 #define ISCSIT_NAME_VERSION "COMSTAR ISCSIT v" ISCSIT_VERSION 51 52 /* 53 * DDI entry points. 54 */ 55 static int iscsit_drv_attach(dev_info_t *, ddi_attach_cmd_t); 56 static int iscsit_drv_detach(dev_info_t *, ddi_detach_cmd_t); 57 static int iscsit_drv_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **); 58 static int iscsit_drv_open(dev_t *, int, int, cred_t *); 59 static int iscsit_drv_close(dev_t, int, int, cred_t *); 60 static boolean_t iscsit_drv_busy(void); 61 static int iscsit_drv_ioctl(dev_t, int, intptr_t, int, cred_t *, int *); 62 63 extern struct mod_ops mod_miscops; 64 65 66 static struct cb_ops iscsit_cb_ops = { 67 iscsit_drv_open, /* cb_open */ 68 iscsit_drv_close, /* cb_close */ 69 nodev, /* cb_strategy */ 70 nodev, /* cb_print */ 71 nodev, /* cb_dump */ 72 nodev, /* cb_read */ 73 nodev, /* cb_write */ 74 iscsit_drv_ioctl, /* cb_ioctl */ 75 nodev, /* cb_devmap */ 76 nodev, /* cb_mmap */ 77 nodev, /* cb_segmap */ 78 nochpoll, /* cb_chpoll */ 79 ddi_prop_op, /* cb_prop_op */ 80 NULL, /* cb_streamtab */ 81 D_MP, /* cb_flag */ 82 CB_REV, /* cb_rev */ 83 nodev, /* cb_aread */ 84 nodev, /* cb_awrite */ 85 }; 86 87 static struct dev_ops iscsit_dev_ops = { 88 DEVO_REV, /* devo_rev */ 89 0, /* devo_refcnt */ 90 iscsit_drv_getinfo, /* devo_getinfo */ 91 nulldev, /* devo_identify */ 92 nulldev, /* devo_probe */ 93 iscsit_drv_attach, /* devo_attach */ 94 iscsit_drv_detach, /* devo_detach */ 95 nodev, /* devo_reset */ 96 &iscsit_cb_ops, /* devo_cb_ops */ 97 NULL, /* devo_bus_ops */ 98 NULL, /* devo_power */ 99 ddi_quiesce_not_needed, /* quiesce */ 100 }; 101 102 static struct modldrv modldrv = { 103 &mod_driverops, 104 "iSCSI Target", 105 &iscsit_dev_ops, 106 }; 107 108 static struct modlinkage modlinkage = { 109 MODREV_1, 110 &modldrv, 111 NULL, 112 }; 113 114 115 iscsit_global_t iscsit_global; 116 117 kmem_cache_t *iscsit_status_pdu_cache; 118 119 boolean_t iscsit_sm_logging = B_FALSE; 120 121 kmutex_t login_sm_session_mutex; 122 123 static idm_status_t iscsit_init(dev_info_t *dip); 124 static idm_status_t iscsit_enable_svc(iscsit_hostinfo_t *hostinfo); 125 static void iscsit_disable_svc(void); 126 127 static int 128 iscsit_check_cmdsn_and_queue(idm_pdu_t *rx_pdu); 129 130 static void 131 iscsit_add_pdu_to_queue(iscsit_sess_t *ist, idm_pdu_t *rx_pdu); 132 133 static idm_pdu_t * 134 iscsit_remove_pdu_from_queue(iscsit_sess_t *ist, uint32_t cmdsn); 135 136 static void 137 iscsit_process_pdu_in_queue(iscsit_sess_t *ist); 138 139 static void 140 iscsit_rxpdu_queue_monitor_session(iscsit_sess_t *ist); 141 142 static void 143 iscsit_rxpdu_queue_monitor(void *arg); 144 145 static void 146 iscsit_post_staged_pdu(idm_pdu_t *rx_pdu); 147 148 static void 149 iscsit_post_scsi_cmd(idm_conn_t *ic, idm_pdu_t *rx_pdu); 150 151 static void 152 iscsit_op_scsi_task_mgmt(iscsit_conn_t *ict, idm_pdu_t *rx_pdu); 153 154 static void 155 iscsit_pdu_op_noop(iscsit_conn_t *ict, idm_pdu_t *rx_pdu); 156 157 static void 158 iscsit_pdu_op_login_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu); 159 160 void 161 iscsit_pdu_op_text_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu); 162 163 static void 164 iscsit_pdu_op_logout_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu); 165 166 int iscsit_cmd_window(); 167 168 static int 169 iscsit_sna_lt(uint32_t sn1, uint32_t sn2); 170 171 void 172 iscsit_set_cmdsn(iscsit_conn_t *ict, idm_pdu_t *rx_pdu); 173 174 static void 175 iscsit_deferred_dispatch(idm_pdu_t *rx_pdu); 176 177 static void 178 iscsit_deferred(void *rx_pdu_void); 179 180 static idm_status_t 181 iscsit_conn_accept(idm_conn_t *ic); 182 183 static idm_status_t 184 iscsit_ffp_enabled(idm_conn_t *ic); 185 186 static idm_status_t 187 iscsit_ffp_disabled(idm_conn_t *ic, idm_ffp_disable_t disable_class); 188 189 static idm_status_t 190 iscsit_conn_lost(idm_conn_t *ic); 191 192 static idm_status_t 193 iscsit_conn_destroy(idm_conn_t *ic); 194 195 static stmf_data_buf_t * 196 iscsit_dbuf_alloc(scsi_task_t *task, uint32_t size, uint32_t *pminsize, 197 uint32_t flags); 198 199 static void 200 iscsit_dbuf_free(stmf_dbuf_store_t *ds, stmf_data_buf_t *dbuf); 201 202 static void 203 iscsit_buf_xfer_cb(idm_buf_t *idb, idm_status_t status); 204 205 static void 206 iscsit_send_good_status_done(idm_pdu_t *pdu, idm_status_t status); 207 208 static void 209 iscsit_send_status_done(idm_pdu_t *pdu, idm_status_t status); 210 211 static stmf_status_t 212 iscsit_idm_to_stmf(idm_status_t idmrc); 213 214 static iscsit_task_t * 215 iscsit_task_alloc(iscsit_conn_t *ict); 216 217 static void 218 iscsit_task_free(iscsit_task_t *itask); 219 220 static iscsit_task_t * 221 iscsit_tm_task_alloc(iscsit_conn_t *ict); 222 223 static void 224 iscsit_tm_task_free(iscsit_task_t *itask); 225 226 static idm_status_t 227 iscsit_task_start(iscsit_task_t *itask); 228 229 static void 230 iscsit_task_done(iscsit_task_t *itask); 231 232 static int 233 iscsit_status_pdu_constructor(void *pdu_void, void *arg, int flags); 234 235 static void 236 iscsit_pp_cb(struct stmf_port_provider *pp, int cmd, void *arg, uint32_t flags); 237 238 static it_cfg_status_t 239 iscsit_config_merge(it_config_t *cfg); 240 241 static idm_status_t 242 iscsit_login_fail(idm_conn_t *ic); 243 244 static boolean_t iscsit_cmdsn_in_window(iscsit_conn_t *ict, uint32_t cmdsn); 245 static void iscsit_send_direct_scsi_resp(iscsit_conn_t *ict, idm_pdu_t *rx_pdu, 246 uint8_t response, uint8_t cmd_status); 247 static void iscsit_send_task_mgmt_resp(idm_pdu_t *tm_resp_pdu, 248 uint8_t tm_status); 249 250 /* 251 * MC/S: Out-of-order commands are staged on a session-wide wait 252 * queue until a system-tunable threshold is reached. A separate 253 * thread is used to scan the staging queue on all the session, 254 * If a delayed PDU does not arrive within a timeout, the target 255 * will advance to the staged PDU that is next in sequence, skipping 256 * over the missing PDU(s) to go past a hole in the sequence. 257 */ 258 volatile int rxpdu_queue_threshold = ISCSIT_RXPDU_QUEUE_THRESHOLD; 259 260 static kmutex_t iscsit_rxpdu_queue_monitor_mutex; 261 kthread_t *iscsit_rxpdu_queue_monitor_thr_id; 262 static kt_did_t iscsit_rxpdu_queue_monitor_thr_did; 263 static boolean_t iscsit_rxpdu_queue_monitor_thr_running; 264 static kcondvar_t iscsit_rxpdu_queue_monitor_cv; 265 266 int 267 _init(void) 268 { 269 int rc; 270 271 rw_init(&iscsit_global.global_rwlock, NULL, RW_DRIVER, NULL); 272 mutex_init(&iscsit_global.global_state_mutex, NULL, 273 MUTEX_DRIVER, NULL); 274 iscsit_global.global_svc_state = ISE_DETACHED; 275 276 mutex_init(&iscsit_rxpdu_queue_monitor_mutex, NULL, 277 MUTEX_DRIVER, NULL); 278 mutex_init(&login_sm_session_mutex, NULL, MUTEX_DRIVER, NULL); 279 iscsit_rxpdu_queue_monitor_thr_id = NULL; 280 iscsit_rxpdu_queue_monitor_thr_running = B_FALSE; 281 cv_init(&iscsit_rxpdu_queue_monitor_cv, NULL, CV_DEFAULT, NULL); 282 283 if ((rc = mod_install(&modlinkage)) != 0) { 284 mutex_destroy(&iscsit_global.global_state_mutex); 285 rw_destroy(&iscsit_global.global_rwlock); 286 return (rc); 287 } 288 289 return (rc); 290 } 291 292 int 293 _info(struct modinfo *modinfop) 294 { 295 return (mod_info(&modlinkage, modinfop)); 296 } 297 298 int 299 _fini(void) 300 { 301 int rc; 302 303 rc = mod_remove(&modlinkage); 304 305 if (rc == 0) { 306 mutex_destroy(&iscsit_rxpdu_queue_monitor_mutex); 307 mutex_destroy(&login_sm_session_mutex); 308 cv_destroy(&iscsit_rxpdu_queue_monitor_cv); 309 mutex_destroy(&iscsit_global.global_state_mutex); 310 rw_destroy(&iscsit_global.global_rwlock); 311 } 312 313 return (rc); 314 } 315 316 /* 317 * DDI entry points. 318 */ 319 320 /* ARGSUSED */ 321 static int 322 iscsit_drv_getinfo(dev_info_t *dip, ddi_info_cmd_t cmd, void *arg, 323 void **result) 324 { 325 ulong_t instance = getminor((dev_t)arg); 326 327 switch (cmd) { 328 case DDI_INFO_DEVT2DEVINFO: 329 *result = iscsit_global.global_dip; 330 return (DDI_SUCCESS); 331 332 case DDI_INFO_DEVT2INSTANCE: 333 *result = (void *)instance; 334 return (DDI_SUCCESS); 335 336 default: 337 break; 338 } 339 340 return (DDI_FAILURE); 341 } 342 343 static int 344 iscsit_drv_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 345 { 346 if (cmd != DDI_ATTACH) { 347 return (DDI_FAILURE); 348 } 349 350 if (ddi_get_instance(dip) != 0) { 351 /* we only allow instance 0 to attach */ 352 return (DDI_FAILURE); 353 } 354 355 /* create the minor node */ 356 if (ddi_create_minor_node(dip, ISCSIT_MODNAME, S_IFCHR, 0, 357 DDI_PSEUDO, 0) != DDI_SUCCESS) { 358 cmn_err(CE_WARN, "iscsit_drv_attach: " 359 "failed creating minor node"); 360 return (DDI_FAILURE); 361 } 362 363 if (iscsit_init(dip) != IDM_STATUS_SUCCESS) { 364 cmn_err(CE_WARN, "iscsit_drv_attach: " 365 "failed to initialize"); 366 ddi_remove_minor_node(dip, NULL); 367 return (DDI_FAILURE); 368 } 369 370 iscsit_global.global_svc_state = ISE_DISABLED; 371 iscsit_global.global_dip = dip; 372 373 return (DDI_SUCCESS); 374 } 375 376 /*ARGSUSED*/ 377 static int 378 iscsit_drv_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 379 { 380 if (cmd != DDI_DETACH) 381 return (DDI_FAILURE); 382 383 /* 384 * drv_detach is called in a context that owns the 385 * device node for the /dev/pseudo device. If this thread blocks 386 * for any resource, other threads that need the /dev/pseudo device 387 * may end up in a deadlock with this thread.Hence, we use a 388 * separate lock just for the structures that drv_detach needs 389 * to access. 390 */ 391 mutex_enter(&iscsit_global.global_state_mutex); 392 if (iscsit_drv_busy()) { 393 mutex_exit(&iscsit_global.global_state_mutex); 394 return (EBUSY); 395 } 396 397 iscsit_global.global_dip = NULL; 398 ddi_remove_minor_node(dip, NULL); 399 400 ldi_ident_release(iscsit_global.global_li); 401 iscsit_global.global_svc_state = ISE_DETACHED; 402 403 mutex_exit(&iscsit_global.global_state_mutex); 404 405 return (DDI_SUCCESS); 406 } 407 408 /*ARGSUSED*/ 409 static int 410 iscsit_drv_open(dev_t *devp, int flag, int otyp, cred_t *credp) 411 { 412 return (0); 413 } 414 415 /* ARGSUSED */ 416 static int 417 iscsit_drv_close(dev_t dev, int flag, int otyp, cred_t *credp) 418 { 419 return (0); 420 } 421 422 static boolean_t 423 iscsit_drv_busy(void) 424 { 425 ASSERT(MUTEX_HELD(&iscsit_global.global_state_mutex)); 426 427 switch (iscsit_global.global_svc_state) { 428 case ISE_DISABLED: 429 case ISE_DETACHED: 430 return (B_FALSE); 431 default: 432 return (B_TRUE); 433 } 434 /* NOTREACHED */ 435 } 436 437 /* ARGSUSED */ 438 static int 439 iscsit_drv_ioctl(dev_t drv, int cmd, intptr_t argp, int flag, cred_t *cred, 440 int *retval) 441 { 442 iscsit_ioc_set_config_t setcfg; 443 iscsit_ioc_set_config32_t setcfg32; 444 char *cfg_pnvlist = NULL; 445 nvlist_t *cfg_nvlist = NULL; 446 it_config_t *cfg = NULL; 447 idm_status_t idmrc; 448 int rc = 0; 449 450 if (drv_priv(cred) != 0) { 451 return (EPERM); 452 } 453 454 mutex_enter(&iscsit_global.global_state_mutex); 455 456 /* 457 * Validate ioctl requests against global service state 458 */ 459 switch (iscsit_global.global_svc_state) { 460 case ISE_ENABLED: 461 if (cmd == ISCSIT_IOC_DISABLE_SVC) { 462 iscsit_global.global_svc_state = ISE_DISABLING; 463 } else if (cmd == ISCSIT_IOC_ENABLE_SVC) { 464 /* Already enabled */ 465 mutex_exit(&iscsit_global.global_state_mutex); 466 return (0); 467 } else { 468 iscsit_global.global_svc_state = ISE_BUSY; 469 } 470 break; 471 case ISE_DISABLED: 472 if (cmd == ISCSIT_IOC_ENABLE_SVC) { 473 iscsit_global.global_svc_state = ISE_ENABLING; 474 } else if (cmd == ISCSIT_IOC_DISABLE_SVC) { 475 /* Already disabled */ 476 mutex_exit(&iscsit_global.global_state_mutex); 477 return (0); 478 } else { 479 rc = EFAULT; 480 } 481 break; 482 case ISE_BUSY: 483 case ISE_ENABLING: 484 case ISE_DISABLING: 485 rc = EAGAIN; 486 break; 487 case ISE_DETACHED: 488 default: 489 rc = EFAULT; 490 break; 491 } 492 493 mutex_exit(&iscsit_global.global_state_mutex); 494 if (rc != 0) 495 return (rc); 496 497 /* Handle ioctl request (enable/disable have already been handled) */ 498 switch (cmd) { 499 case ISCSIT_IOC_SET_CONFIG: 500 /* Any errors must set state back to ISE_ENABLED */ 501 switch (ddi_model_convert_from(flag & FMODELS)) { 502 case DDI_MODEL_ILP32: 503 if (ddi_copyin((void *)argp, &setcfg32, 504 sizeof (iscsit_ioc_set_config32_t), flag) != 0) { 505 rc = EFAULT; 506 goto cleanup; 507 } 508 509 setcfg.set_cfg_pnvlist = 510 (char *)((uintptr_t)setcfg32.set_cfg_pnvlist); 511 setcfg.set_cfg_vers = setcfg32.set_cfg_vers; 512 setcfg.set_cfg_pnvlist_len = 513 setcfg32.set_cfg_pnvlist_len; 514 break; 515 case DDI_MODEL_NONE: 516 if (ddi_copyin((void *)argp, &setcfg, 517 sizeof (iscsit_ioc_set_config_t), flag) != 0) { 518 rc = EFAULT; 519 goto cleanup; 520 } 521 break; 522 default: 523 rc = EFAULT; 524 goto cleanup; 525 } 526 527 /* Check API version */ 528 if (setcfg.set_cfg_vers != ISCSIT_API_VERS0) { 529 rc = EINVAL; 530 goto cleanup; 531 } 532 533 /* Config is in packed nvlist format so unpack it */ 534 cfg_pnvlist = kmem_alloc(setcfg.set_cfg_pnvlist_len, 535 KM_SLEEP); 536 ASSERT(cfg_pnvlist != NULL); 537 538 if (ddi_copyin(setcfg.set_cfg_pnvlist, cfg_pnvlist, 539 setcfg.set_cfg_pnvlist_len, flag) != 0) { 540 rc = EFAULT; 541 goto cleanup; 542 } 543 544 rc = nvlist_unpack(cfg_pnvlist, setcfg.set_cfg_pnvlist_len, 545 &cfg_nvlist, KM_SLEEP); 546 if (rc != 0) { 547 goto cleanup; 548 } 549 550 /* Translate nvlist */ 551 rc = it_nv_to_config(cfg_nvlist, &cfg); 552 if (rc != 0) { 553 cmn_err(CE_WARN, "Configuration is invalid"); 554 goto cleanup; 555 } 556 557 /* Update config */ 558 rc = iscsit_config_merge(cfg); 559 /* FALLTHROUGH */ 560 561 cleanup: 562 if (cfg) 563 it_config_free_cmn(cfg); 564 if (cfg_pnvlist) 565 kmem_free(cfg_pnvlist, setcfg.set_cfg_pnvlist_len); 566 if (cfg_nvlist) 567 nvlist_free(cfg_nvlist); 568 569 /* 570 * Now that the reconfig is complete set our state back to 571 * enabled. 572 */ 573 mutex_enter(&iscsit_global.global_state_mutex); 574 iscsit_global.global_svc_state = ISE_ENABLED; 575 mutex_exit(&iscsit_global.global_state_mutex); 576 break; 577 case ISCSIT_IOC_ENABLE_SVC: { 578 iscsit_hostinfo_t hostinfo; 579 580 if (ddi_copyin((void *)argp, &hostinfo.length, 581 sizeof (hostinfo.length), flag) != 0) { 582 mutex_enter(&iscsit_global.global_state_mutex); 583 iscsit_global.global_svc_state = ISE_DISABLED; 584 mutex_exit(&iscsit_global.global_state_mutex); 585 return (EFAULT); 586 } 587 588 if (hostinfo.length > sizeof (hostinfo.fqhn)) 589 hostinfo.length = sizeof (hostinfo.fqhn); 590 591 if (ddi_copyin((void *)((caddr_t)argp + 592 sizeof (hostinfo.length)), &hostinfo.fqhn, 593 hostinfo.length, flag) != 0) { 594 mutex_enter(&iscsit_global.global_state_mutex); 595 iscsit_global.global_svc_state = ISE_DISABLED; 596 mutex_exit(&iscsit_global.global_state_mutex); 597 return (EFAULT); 598 } 599 600 idmrc = iscsit_enable_svc(&hostinfo); 601 mutex_enter(&iscsit_global.global_state_mutex); 602 if (idmrc == IDM_STATUS_SUCCESS) { 603 iscsit_global.global_svc_state = ISE_ENABLED; 604 } else { 605 rc = EIO; 606 iscsit_global.global_svc_state = ISE_DISABLED; 607 } 608 mutex_exit(&iscsit_global.global_state_mutex); 609 break; 610 } 611 case ISCSIT_IOC_DISABLE_SVC: 612 iscsit_disable_svc(); 613 mutex_enter(&iscsit_global.global_state_mutex); 614 iscsit_global.global_svc_state = ISE_DISABLED; 615 mutex_exit(&iscsit_global.global_state_mutex); 616 break; 617 618 default: 619 rc = EINVAL; 620 mutex_enter(&iscsit_global.global_state_mutex); 621 iscsit_global.global_svc_state = ISE_ENABLED; 622 mutex_exit(&iscsit_global.global_state_mutex); 623 } 624 625 return (rc); 626 } 627 628 static idm_status_t 629 iscsit_init(dev_info_t *dip) 630 { 631 int rc; 632 633 rc = ldi_ident_from_dip(dip, &iscsit_global.global_li); 634 ASSERT(rc == 0); /* Failure indicates invalid argument */ 635 636 iscsit_global.global_svc_state = ISE_DISABLED; 637 638 return (IDM_STATUS_SUCCESS); 639 } 640 641 /* 642 * iscsit_enable_svc 643 * 644 * registers all the configured targets and target portals with STMF 645 */ 646 static idm_status_t 647 iscsit_enable_svc(iscsit_hostinfo_t *hostinfo) 648 { 649 stmf_port_provider_t *pp; 650 stmf_dbuf_store_t *dbuf_store; 651 boolean_t did_iscsit_isns_init; 652 idm_status_t retval = IDM_STATUS_SUCCESS; 653 654 ASSERT(iscsit_global.global_svc_state == ISE_ENABLING); 655 656 /* 657 * Make sure that can tell if we have partially allocated 658 * in case we need to exit and tear down anything allocated. 659 */ 660 iscsit_global.global_tsih_pool = NULL; 661 iscsit_global.global_dbuf_store = NULL; 662 iscsit_status_pdu_cache = NULL; 663 pp = NULL; 664 iscsit_global.global_pp = NULL; 665 iscsit_global.global_default_tpg = NULL; 666 did_iscsit_isns_init = B_FALSE; 667 iscsit_global.global_dispatch_taskq = NULL; 668 669 /* Setup remaining fields in iscsit_global_t */ 670 idm_refcnt_init(&iscsit_global.global_refcnt, 671 &iscsit_global); 672 673 avl_create(&iscsit_global.global_discovery_sessions, 674 iscsit_sess_avl_compare, sizeof (iscsit_sess_t), 675 offsetof(iscsit_sess_t, ist_tgt_ln)); 676 677 avl_create(&iscsit_global.global_target_list, 678 iscsit_tgt_avl_compare, sizeof (iscsit_tgt_t), 679 offsetof(iscsit_tgt_t, target_global_ln)); 680 681 list_create(&iscsit_global.global_deleted_target_list, 682 sizeof (iscsit_tgt_t), 683 offsetof(iscsit_tgt_t, target_global_deleted_ln)); 684 685 avl_create(&iscsit_global.global_tpg_list, 686 iscsit_tpg_avl_compare, sizeof (iscsit_tpg_t), 687 offsetof(iscsit_tpg_t, tpg_global_ln)); 688 689 avl_create(&iscsit_global.global_ini_list, 690 iscsit_ini_avl_compare, sizeof (iscsit_ini_t), 691 offsetof(iscsit_ini_t, ini_global_ln)); 692 693 iscsit_global.global_tsih_pool = vmem_create("iscsit_tsih_pool", 694 (void *)1, ISCSI_MAX_TSIH, 1, NULL, NULL, NULL, 0, 695 VM_SLEEP | VMC_IDENTIFIER); 696 697 /* 698 * Setup STMF dbuf store. Our buffers are bound to a specific 699 * connection so we really can't let STMF cache buffers for us. 700 * Consequently we'll just allocate one global buffer store. 701 */ 702 dbuf_store = stmf_alloc(STMF_STRUCT_DBUF_STORE, 0, 0); 703 if (dbuf_store == NULL) { 704 retval = IDM_STATUS_FAIL; 705 goto tear_down_and_return; 706 } 707 dbuf_store->ds_alloc_data_buf = iscsit_dbuf_alloc; 708 dbuf_store->ds_free_data_buf = iscsit_dbuf_free; 709 dbuf_store->ds_port_private = NULL; 710 iscsit_global.global_dbuf_store = dbuf_store; 711 712 /* Status PDU cache */ 713 iscsit_status_pdu_cache = kmem_cache_create("iscsit_status_pdu_cache", 714 sizeof (idm_pdu_t) + sizeof (iscsi_scsi_rsp_hdr_t), 8, 715 &iscsit_status_pdu_constructor, 716 NULL, NULL, NULL, NULL, KM_SLEEP); 717 718 /* Default TPG and portal */ 719 iscsit_global.global_default_tpg = iscsit_tpg_createdefault(); 720 if (iscsit_global.global_default_tpg == NULL) { 721 retval = IDM_STATUS_FAIL; 722 goto tear_down_and_return; 723 } 724 725 /* initialize isns client */ 726 (void) iscsit_isns_init(hostinfo); 727 did_iscsit_isns_init = B_TRUE; 728 729 /* Register port provider */ 730 pp = stmf_alloc(STMF_STRUCT_PORT_PROVIDER, 0, 0); 731 if (pp == NULL) { 732 retval = IDM_STATUS_FAIL; 733 goto tear_down_and_return; 734 } 735 736 pp->pp_portif_rev = PORTIF_REV_1; 737 pp->pp_instance = 0; 738 pp->pp_name = ISCSIT_MODNAME; 739 pp->pp_cb = iscsit_pp_cb; 740 741 iscsit_global.global_pp = pp; 742 743 744 if (stmf_register_port_provider(pp) != STMF_SUCCESS) { 745 retval = IDM_STATUS_FAIL; 746 goto tear_down_and_return; 747 } 748 749 iscsit_global.global_dispatch_taskq = taskq_create("iscsit_dispatch", 750 1, minclsyspri, 16, 16, TASKQ_PREPOPULATE); 751 752 /* Scan staged PDUs, meaningful in MC/S situations */ 753 iscsit_rxpdu_queue_monitor_start(); 754 755 return (IDM_STATUS_SUCCESS); 756 757 tear_down_and_return: 758 759 if (iscsit_global.global_dispatch_taskq) { 760 taskq_destroy(iscsit_global.global_dispatch_taskq); 761 iscsit_global.global_dispatch_taskq = NULL; 762 } 763 764 if (did_iscsit_isns_init) 765 iscsit_isns_fini(); 766 767 if (iscsit_global.global_default_tpg) { 768 iscsit_tpg_destroydefault(iscsit_global.global_default_tpg); 769 iscsit_global.global_default_tpg = NULL; 770 } 771 772 if (iscsit_global.global_pp) 773 iscsit_global.global_pp = NULL; 774 775 if (pp) 776 stmf_free(pp); 777 778 if (iscsit_status_pdu_cache) { 779 kmem_cache_destroy(iscsit_status_pdu_cache); 780 iscsit_status_pdu_cache = NULL; 781 } 782 783 if (iscsit_global.global_dbuf_store) { 784 stmf_free(iscsit_global.global_dbuf_store); 785 iscsit_global.global_dbuf_store = NULL; 786 } 787 788 if (iscsit_global.global_tsih_pool) { 789 vmem_destroy(iscsit_global.global_tsih_pool); 790 iscsit_global.global_tsih_pool = NULL; 791 } 792 793 avl_destroy(&iscsit_global.global_ini_list); 794 avl_destroy(&iscsit_global.global_tpg_list); 795 list_destroy(&iscsit_global.global_deleted_target_list); 796 avl_destroy(&iscsit_global.global_target_list); 797 avl_destroy(&iscsit_global.global_discovery_sessions); 798 799 idm_refcnt_destroy(&iscsit_global.global_refcnt); 800 801 return (retval); 802 } 803 804 /* 805 * iscsit_disable_svc 806 * 807 * clean up all existing connections and deregister targets from STMF 808 */ 809 static void 810 iscsit_disable_svc(void) 811 { 812 iscsit_sess_t *sess; 813 814 ASSERT(iscsit_global.global_svc_state == ISE_DISABLING); 815 816 iscsit_rxpdu_queue_monitor_stop(); 817 818 /* tear down discovery sessions */ 819 for (sess = avl_first(&iscsit_global.global_discovery_sessions); 820 sess != NULL; 821 sess = AVL_NEXT(&iscsit_global.global_discovery_sessions, sess)) 822 iscsit_sess_close(sess); 823 824 /* 825 * Passing NULL to iscsit_config_merge tells it to go to an empty 826 * config. 827 */ 828 (void) iscsit_config_merge(NULL); 829 830 /* 831 * Wait until there are no more global references 832 */ 833 idm_refcnt_wait_ref(&iscsit_global.global_refcnt); 834 idm_refcnt_destroy(&iscsit_global.global_refcnt); 835 836 /* 837 * Default TPG must be destroyed after global_refcnt is 0. 838 */ 839 iscsit_tpg_destroydefault(iscsit_global.global_default_tpg); 840 841 avl_destroy(&iscsit_global.global_discovery_sessions); 842 list_destroy(&iscsit_global.global_deleted_target_list); 843 avl_destroy(&iscsit_global.global_target_list); 844 avl_destroy(&iscsit_global.global_tpg_list); 845 avl_destroy(&iscsit_global.global_ini_list); 846 847 taskq_destroy(iscsit_global.global_dispatch_taskq); 848 849 iscsit_isns_fini(); 850 851 stmf_free(iscsit_global.global_dbuf_store); 852 iscsit_global.global_dbuf_store = NULL; 853 854 (void) stmf_deregister_port_provider(iscsit_global.global_pp); 855 stmf_free(iscsit_global.global_pp); 856 iscsit_global.global_pp = NULL; 857 858 kmem_cache_destroy(iscsit_status_pdu_cache); 859 iscsit_status_pdu_cache = NULL; 860 861 vmem_destroy(iscsit_global.global_tsih_pool); 862 iscsit_global.global_tsih_pool = NULL; 863 } 864 865 void 866 iscsit_global_hold() 867 { 868 /* 869 * To take out a global hold, we must either own the global 870 * state mutex or we must be running inside of an ioctl that 871 * has set the global state to ISE_BUSY, ISE_DISABLING, or 872 * ISE_ENABLING. We don't track the "owner" for these flags, 873 * so just checking if they are set is enough for now. 874 */ 875 ASSERT((iscsit_global.global_svc_state == ISE_ENABLING) || 876 (iscsit_global.global_svc_state == ISE_DISABLING) || 877 (iscsit_global.global_svc_state == ISE_BUSY) || 878 MUTEX_HELD(&iscsit_global.global_state_mutex)); 879 880 idm_refcnt_hold(&iscsit_global.global_refcnt); 881 } 882 883 void 884 iscsit_global_rele() 885 { 886 idm_refcnt_rele(&iscsit_global.global_refcnt); 887 } 888 889 void 890 iscsit_global_wait_ref() 891 { 892 idm_refcnt_wait_ref(&iscsit_global.global_refcnt); 893 } 894 895 /* 896 * IDM callbacks 897 */ 898 899 /*ARGSUSED*/ 900 void 901 iscsit_rx_pdu(idm_conn_t *ic, idm_pdu_t *rx_pdu) 902 { 903 iscsit_conn_t *ict = ic->ic_handle; 904 switch (IDM_PDU_OPCODE(rx_pdu)) { 905 case ISCSI_OP_SCSI_CMD: 906 ASSERT(0); /* Shouldn't happen */ 907 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 908 break; 909 case ISCSI_OP_SNACK_CMD: 910 /* 911 * We'll need to handle this when we support ERL1/2. For 912 * now we treat it as a protocol error. 913 */ 914 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 915 idm_conn_event(ic, CE_TRANSPORT_FAIL, NULL); 916 break; 917 case ISCSI_OP_SCSI_TASK_MGT_MSG: 918 if (iscsit_check_cmdsn_and_queue(rx_pdu)) { 919 iscsit_set_cmdsn(ict, rx_pdu); 920 iscsit_op_scsi_task_mgmt(ict, rx_pdu); 921 } 922 break; 923 case ISCSI_OP_NOOP_OUT: 924 case ISCSI_OP_LOGIN_CMD: 925 case ISCSI_OP_TEXT_CMD: 926 case ISCSI_OP_LOGOUT_CMD: 927 /* 928 * If/when we switch to userland processing these PDU's 929 * will be handled by iscsitd. 930 */ 931 iscsit_deferred_dispatch(rx_pdu); 932 break; 933 default: 934 /* Protocol error */ 935 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 936 idm_conn_event(ic, CE_TRANSPORT_FAIL, NULL); 937 break; 938 } 939 } 940 941 /*ARGSUSED*/ 942 void 943 iscsit_rx_pdu_error(idm_conn_t *ic, idm_pdu_t *rx_pdu, idm_status_t status) 944 { 945 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 946 } 947 948 void 949 iscsit_task_aborted(idm_task_t *idt, idm_status_t status) 950 { 951 iscsit_task_t *itask = idt->idt_private; 952 953 switch (status) { 954 case IDM_STATUS_SUSPENDED: 955 break; 956 case IDM_STATUS_ABORTED: 957 mutex_enter(&itask->it_mutex); 958 itask->it_aborted = B_TRUE; 959 /* 960 * We rely on the fact that STMF tracks outstanding 961 * buffer transfers and will free all of our buffers 962 * before freeing the task so we don't need to 963 * explicitly free the buffers from iscsit/idm 964 */ 965 if (itask->it_stmf_abort) { 966 mutex_exit(&itask->it_mutex); 967 /* 968 * Task is no longer active 969 */ 970 iscsit_task_done(itask); 971 972 /* 973 * STMF has already asked for this task to be aborted 974 * 975 * STMF specification is wrong... says to return 976 * STMF_ABORTED, the code actually looks for 977 * STMF_ABORT_SUCCESS. 978 */ 979 stmf_task_lport_aborted(itask->it_stmf_task, 980 STMF_ABORT_SUCCESS, STMF_IOF_LPORT_DONE); 981 return; 982 } else { 983 mutex_exit(&itask->it_mutex); 984 /* 985 * Tell STMF to stop processing the task. 986 */ 987 stmf_abort(STMF_QUEUE_TASK_ABORT, itask->it_stmf_task, 988 STMF_ABORTED, NULL); 989 return; 990 } 991 /*NOTREACHED*/ 992 default: 993 ASSERT(0); 994 } 995 } 996 997 /*ARGSUSED*/ 998 idm_status_t 999 iscsit_client_notify(idm_conn_t *ic, idm_client_notify_t icn, 1000 uintptr_t data) 1001 { 1002 idm_status_t rc = IDM_STATUS_SUCCESS; 1003 1004 /* 1005 * IDM client notifications will never occur at interrupt level 1006 * since they are generated from the connection state machine which 1007 * running on taskq threads. 1008 * 1009 */ 1010 switch (icn) { 1011 case CN_CONNECT_ACCEPT: 1012 rc = iscsit_conn_accept(ic); /* No data */ 1013 break; 1014 case CN_FFP_ENABLED: 1015 rc = iscsit_ffp_enabled(ic); /* No data */ 1016 break; 1017 case CN_FFP_DISABLED: 1018 /* 1019 * Data indicates whether this was the result of an 1020 * explicit logout request. 1021 */ 1022 rc = iscsit_ffp_disabled(ic, (idm_ffp_disable_t)data); 1023 break; 1024 case CN_CONNECT_LOST: 1025 rc = iscsit_conn_lost(ic); 1026 break; 1027 case CN_CONNECT_DESTROY: 1028 rc = iscsit_conn_destroy(ic); 1029 break; 1030 case CN_LOGIN_FAIL: 1031 /* 1032 * Force the login state machine to completion 1033 */ 1034 rc = iscsit_login_fail(ic); 1035 break; 1036 default: 1037 rc = IDM_STATUS_REJECT; 1038 break; 1039 } 1040 1041 return (rc); 1042 } 1043 1044 /* 1045 * iscsit_update_statsn is invoked for all the PDUs which have the StatSN 1046 * field in the header. The StatSN is incremented if the IDM_PDU_ADVANCE_STATSN 1047 * flag is set in the pdu flags field. The StatSN is connection-wide and is 1048 * protected by the mutex ict_statsn_mutex. For Data-In PDUs, if the flag 1049 * IDM_TASK_PHASECOLLAPSE_REQ is set, the status (phase-collapse) is also filled 1050 */ 1051 void 1052 iscsit_update_statsn(idm_task_t *idm_task, idm_pdu_t *pdu) 1053 { 1054 iscsi_scsi_rsp_hdr_t *rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr; 1055 iscsit_conn_t *ict = (iscsit_conn_t *)pdu->isp_ic->ic_handle; 1056 iscsit_task_t *itask = NULL; 1057 scsi_task_t *task = NULL; 1058 1059 mutex_enter(&ict->ict_statsn_mutex); 1060 rsp->statsn = htonl(ict->ict_statsn); 1061 if (pdu->isp_flags & IDM_PDU_ADVANCE_STATSN) 1062 ict->ict_statsn++; 1063 mutex_exit(&ict->ict_statsn_mutex); 1064 1065 /* 1066 * The last SCSI Data PDU passed for a command may also contain the 1067 * status if the status indicates termination with no expections, i.e. 1068 * no sense data or response involved. If the command completes with 1069 * an error, then the response and sense data will be sent in a 1070 * separate iSCSI Response PDU. 1071 */ 1072 if ((idm_task) && (idm_task->idt_flags & IDM_TASK_PHASECOLLAPSE_REQ)) { 1073 itask = idm_task->idt_private; 1074 task = itask->it_stmf_task; 1075 1076 rsp->cmd_status = task->task_scsi_status; 1077 rsp->flags |= ISCSI_FLAG_DATA_STATUS; 1078 if (task->task_status_ctrl & TASK_SCTRL_OVER) { 1079 rsp->flags |= ISCSI_FLAG_CMD_OVERFLOW; 1080 } else if (task->task_status_ctrl & TASK_SCTRL_UNDER) { 1081 rsp->flags |= ISCSI_FLAG_CMD_UNDERFLOW; 1082 } 1083 rsp->residual_count = htonl(task->task_resid); 1084 1085 /* 1086 * Removing the task from the session task list 1087 * just before the status is sent in the last 1088 * Data PDU transfer 1089 */ 1090 iscsit_task_done(itask); 1091 } 1092 } 1093 1094 void 1095 iscsit_build_hdr(idm_task_t *idm_task, idm_pdu_t *pdu, uint8_t opcode) 1096 { 1097 iscsit_task_t *itask = idm_task->idt_private; 1098 iscsi_data_rsp_hdr_t *dh = (iscsi_data_rsp_hdr_t *)pdu->isp_hdr; 1099 1100 /* 1101 * We acquired iscsit_sess_t.ist_sn_mutex in iscsit_xfer_scsi_data 1102 */ 1103 ASSERT(MUTEX_HELD(&itask->it_ict->ict_sess->ist_sn_mutex)); 1104 /* 1105 * On incoming data, the target transfer tag and Lun is only 1106 * provided by the target if the A bit is set, Since the target 1107 * does not currently support Error Recovery Level 1, the A 1108 * bit is never set. 1109 */ 1110 dh->opcode = opcode; 1111 dh->itt = itask->it_itt; 1112 dh->ttt = ((opcode & ISCSI_OPCODE_MASK) == ISCSI_OP_SCSI_DATA_RSP) ? 1113 ISCSI_RSVD_TASK_TAG : itask->it_ttt; 1114 1115 dh->expcmdsn = htonl(itask->it_ict->ict_sess->ist_expcmdsn); 1116 dh->maxcmdsn = htonl(itask->it_ict->ict_sess->ist_maxcmdsn); 1117 1118 /* 1119 * IDM must set: 1120 * 1121 * data.flags and rtt.flags 1122 * data.dlength 1123 * data.datasn 1124 * data.offset 1125 * statsn, residual_count and cmd_status (for phase collapse) 1126 * rtt.rttsn 1127 * rtt.data_offset 1128 * rtt.data_length 1129 */ 1130 } 1131 1132 void 1133 iscsit_keepalive(idm_conn_t *ic) 1134 { 1135 idm_pdu_t *nop_in_pdu; 1136 iscsi_nop_in_hdr_t *nop_in; 1137 iscsit_conn_t *ict = ic->ic_handle; 1138 1139 /* 1140 * IDM noticed the connection has been idle for too long so it's 1141 * time to provoke some activity. Build and transmit an iSCSI 1142 * nop-in PDU -- when the initiator responds it will be counted 1143 * as "activity" and keep the connection alive. 1144 * 1145 * We don't actually care about the response here at the iscsit level 1146 * so we will just throw it away without looking at it when it arrives. 1147 */ 1148 nop_in_pdu = idm_pdu_alloc(sizeof (*nop_in), 0); 1149 idm_pdu_init(nop_in_pdu, ic, NULL, NULL); 1150 nop_in = (iscsi_nop_in_hdr_t *)nop_in_pdu->isp_hdr; 1151 bzero(nop_in, sizeof (*nop_in)); 1152 nop_in->opcode = ISCSI_OP_NOOP_IN; 1153 nop_in->flags = ISCSI_FLAG_FINAL; 1154 nop_in->itt = ISCSI_RSVD_TASK_TAG; 1155 /* 1156 * When the target sends a NOP-In as a Ping, the target transfer tag 1157 * is set to a valid (not reserved) value and the initiator task tag 1158 * is set to ISCSI_RSVD_TASK_TAG (0xffffffff). In this case the StatSN 1159 * will always contain the next sequence number but the StatSN for the 1160 * connection is not advanced after this PDU is sent. 1161 */ 1162 nop_in_pdu->isp_flags |= IDM_PDU_SET_STATSN; 1163 /* 1164 * This works because we don't currently allocate ttt's anywhere else 1165 * in iscsit so as long as we stay out of IDM's range we are safe. 1166 * If we need to allocate ttt's for other PDU's in the future this will 1167 * need to be improved. 1168 */ 1169 mutex_enter(&ict->ict_mutex); 1170 nop_in->ttt = ict->ict_keepalive_ttt; 1171 ict->ict_keepalive_ttt++; 1172 if (ict->ict_keepalive_ttt == ISCSI_RSVD_TASK_TAG) 1173 ict->ict_keepalive_ttt = IDM_TASKIDS_MAX; 1174 mutex_exit(&ict->ict_mutex); 1175 1176 iscsit_pdu_tx(nop_in_pdu); 1177 } 1178 1179 static idm_status_t 1180 iscsit_conn_accept(idm_conn_t *ic) 1181 { 1182 iscsit_conn_t *ict; 1183 1184 /* 1185 * We need to get a global hold here to ensure that the service 1186 * doesn't get shutdown prior to establishing a session. This 1187 * gets released in iscsit_conn_destroy(). 1188 */ 1189 mutex_enter(&iscsit_global.global_state_mutex); 1190 if (iscsit_global.global_svc_state != ISE_ENABLED) { 1191 mutex_exit(&iscsit_global.global_state_mutex); 1192 return (IDM_STATUS_FAIL); 1193 } 1194 iscsit_global_hold(); 1195 mutex_exit(&iscsit_global.global_state_mutex); 1196 1197 /* 1198 * Allocate an associated iscsit structure to represent this 1199 * connection. We shouldn't really create a session until we 1200 * get the first login PDU. 1201 */ 1202 ict = kmem_zalloc(sizeof (*ict), KM_SLEEP); 1203 1204 ict->ict_ic = ic; 1205 ict->ict_statsn = 1; 1206 ict->ict_keepalive_ttt = IDM_TASKIDS_MAX; /* Avoid IDM TT range */ 1207 ic->ic_handle = ict; 1208 mutex_init(&ict->ict_mutex, NULL, MUTEX_DRIVER, NULL); 1209 mutex_init(&ict->ict_statsn_mutex, NULL, MUTEX_DRIVER, NULL); 1210 idm_refcnt_init(&ict->ict_refcnt, ict); 1211 1212 /* 1213 * Initialize login state machine 1214 */ 1215 if (iscsit_login_sm_init(ict) != IDM_STATUS_SUCCESS) { 1216 iscsit_global_rele(); 1217 /* 1218 * Cleanup the ict after idm notifies us about this failure 1219 */ 1220 return (IDM_STATUS_FAIL); 1221 } 1222 1223 return (IDM_STATUS_SUCCESS); 1224 } 1225 1226 idm_status_t 1227 iscsit_conn_reinstate(iscsit_conn_t *reinstate_ict, iscsit_conn_t *new_ict) 1228 { 1229 idm_status_t result; 1230 1231 /* 1232 * Note in new connection state that this connection is 1233 * reinstating an existing connection. 1234 */ 1235 new_ict->ict_reinstating = B_TRUE; 1236 new_ict->ict_reinstate_conn = reinstate_ict; 1237 new_ict->ict_statsn = reinstate_ict->ict_statsn; 1238 1239 /* 1240 * Now generate connection state machine event to existing connection 1241 * so that it starts the cleanup process. 1242 */ 1243 result = idm_conn_reinstate_event(reinstate_ict->ict_ic, 1244 new_ict->ict_ic); 1245 1246 return (result); 1247 } 1248 1249 void 1250 iscsit_conn_hold(iscsit_conn_t *ict) 1251 { 1252 idm_refcnt_hold(&ict->ict_refcnt); 1253 } 1254 1255 void 1256 iscsit_conn_rele(iscsit_conn_t *ict) 1257 { 1258 idm_refcnt_rele(&ict->ict_refcnt); 1259 } 1260 1261 void 1262 iscsit_conn_dispatch_hold(iscsit_conn_t *ict) 1263 { 1264 idm_refcnt_hold(&ict->ict_dispatch_refcnt); 1265 } 1266 1267 void 1268 iscsit_conn_dispatch_rele(iscsit_conn_t *ict) 1269 { 1270 idm_refcnt_rele(&ict->ict_dispatch_refcnt); 1271 } 1272 1273 static idm_status_t 1274 iscsit_login_fail(idm_conn_t *ic) 1275 { 1276 iscsit_conn_t *ict = ic->ic_handle; 1277 1278 /* Generate login state machine event */ 1279 iscsit_login_sm_event(ict, ILE_LOGIN_CONN_ERROR, NULL); 1280 1281 return (IDM_STATUS_SUCCESS); 1282 } 1283 1284 static idm_status_t 1285 iscsit_ffp_enabled(idm_conn_t *ic) 1286 { 1287 iscsit_conn_t *ict = ic->ic_handle; 1288 1289 /* Generate session state machine event */ 1290 iscsit_sess_sm_event(ict->ict_sess, SE_CONN_LOGGED_IN, ict); 1291 1292 return (IDM_STATUS_SUCCESS); 1293 } 1294 1295 static idm_status_t 1296 iscsit_ffp_disabled(idm_conn_t *ic, idm_ffp_disable_t disable_class) 1297 { 1298 iscsit_conn_t *ict = ic->ic_handle; 1299 1300 /* Generate session state machine event */ 1301 switch (disable_class) { 1302 case FD_CONN_FAIL: 1303 iscsit_sess_sm_event(ict->ict_sess, SE_CONN_FFP_FAIL, ict); 1304 break; 1305 case FD_CONN_LOGOUT: 1306 iscsit_sess_sm_event(ict->ict_sess, SE_CONN_FFP_DISABLE, ict); 1307 break; 1308 case FD_SESS_LOGOUT: 1309 iscsit_sess_sm_event(ict->ict_sess, SE_SESSION_CLOSE, ict); 1310 break; 1311 default: 1312 ASSERT(0); 1313 } 1314 1315 return (IDM_STATUS_SUCCESS); 1316 } 1317 1318 static idm_status_t 1319 iscsit_conn_lost(idm_conn_t *ic) 1320 { 1321 iscsit_conn_t *ict = ic->ic_handle; 1322 iscsit_sess_t *ist = ict->ict_sess; 1323 iscsit_cbuf_t *cbuf; 1324 idm_pdu_t *rx_pdu; 1325 int i; 1326 1327 mutex_enter(&ict->ict_mutex); 1328 ict->ict_lost = B_TRUE; 1329 mutex_exit(&ict->ict_mutex); 1330 /* 1331 * scrub the staging queue for all PDUs on this connection 1332 */ 1333 if (ist != NULL) { 1334 mutex_enter(&ist->ist_sn_mutex); 1335 for (cbuf = ist->ist_rxpdu_queue, i = 0; 1336 ((cbuf->cb_num_elems > 0) && (i < ISCSIT_RXPDU_QUEUE_LEN)); 1337 i++) { 1338 if (((rx_pdu = cbuf->cb_buffer[i]) != NULL) && 1339 (rx_pdu->isp_ic == ic)) { 1340 /* conn is lost, drop the pdu */ 1341 DTRACE_PROBE3(scrubbing__staging__queue, 1342 iscsit_sess_t *, ist, idm_conn_t *, ic, 1343 idm_pdu_t *, rx_pdu); 1344 idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL); 1345 cbuf->cb_buffer[i] = NULL; 1346 cbuf->cb_num_elems--; 1347 iscsit_conn_dispatch_rele(ict); 1348 } 1349 } 1350 mutex_exit(&ist->ist_sn_mutex); 1351 } 1352 /* 1353 * Make sure there aren't any PDU's transitioning from the receive 1354 * handler to the dispatch taskq. 1355 */ 1356 idm_refcnt_wait_ref(&ict->ict_dispatch_refcnt); 1357 1358 return (IDM_STATUS_SUCCESS); 1359 } 1360 1361 static idm_status_t 1362 iscsit_conn_destroy(idm_conn_t *ic) 1363 { 1364 iscsit_conn_t *ict = ic->ic_handle; 1365 1366 mutex_enter(&ict->ict_mutex); 1367 ict->ict_destroyed = B_TRUE; 1368 mutex_exit(&ict->ict_mutex); 1369 1370 /* Generate session state machine event */ 1371 if (ict->ict_sess != NULL) { 1372 /* 1373 * Session state machine will call iscsit_conn_destroy_done() 1374 * when it has removed references to this connection. 1375 */ 1376 iscsit_sess_sm_event(ict->ict_sess, SE_CONN_FAIL, ict); 1377 } 1378 1379 idm_refcnt_wait_ref(&ict->ict_refcnt); 1380 /* 1381 * The session state machine does not need to post 1382 * events to IDM any longer, so it is safe to set 1383 * the idm connection reference to NULL 1384 */ 1385 ict->ict_ic = NULL; 1386 1387 /* Reap the login state machine */ 1388 iscsit_login_sm_fini(ict); 1389 1390 /* Clean up any text command remnants */ 1391 iscsit_text_cmd_fini(ict); 1392 1393 mutex_destroy(&ict->ict_mutex); 1394 idm_refcnt_destroy(&ict->ict_refcnt); 1395 kmem_free(ict, sizeof (*ict)); 1396 1397 iscsit_global_rele(); 1398 1399 return (IDM_STATUS_SUCCESS); 1400 } 1401 1402 void 1403 iscsit_conn_logout(iscsit_conn_t *ict) 1404 { 1405 /* 1406 * If the iscsi connection is active, then 1407 * logout the IDM connection by sending a 1408 * CE_LOGOUT_SESSION_SUCCESS, else, no action 1409 * needs to be taken because the connection 1410 * is already in the teardown process. 1411 */ 1412 mutex_enter(&ict->ict_mutex); 1413 if (ict->ict_lost == B_FALSE && ict->ict_destroyed == B_FALSE) { 1414 idm_conn_event(ict->ict_ic, CE_LOGOUT_SESSION_SUCCESS, NULL); 1415 } 1416 mutex_exit(&ict->ict_mutex); 1417 } 1418 1419 /* 1420 * STMF-related functions 1421 * 1422 * iSCSI to STMF mapping 1423 * 1424 * Session == ? 1425 * Connection == bound to local port but not itself a local port 1426 * Target 1427 * Target portal (group?) == local port (really but we're not going to do this) 1428 * iscsit needs to map connections to local ports (whatever we decide 1429 * they are) 1430 * Target == ? 1431 */ 1432 1433 /*ARGSUSED*/ 1434 static stmf_data_buf_t * 1435 iscsit_dbuf_alloc(scsi_task_t *task, uint32_t size, uint32_t *pminsize, 1436 uint32_t flags) 1437 { 1438 iscsit_task_t *itask = task->task_port_private; 1439 idm_buf_t *idm_buffer; 1440 iscsit_buf_t *ibuf; 1441 stmf_data_buf_t *result; 1442 uint32_t bsize; 1443 1444 /* 1445 * If the requested size is larger than MaxBurstLength and the 1446 * given pminsize is also larger than MaxBurstLength, then the 1447 * allocation fails (dbuf = NULL) and pminsize is modified to 1448 * be equal to MaxBurstLength. stmf/sbd then should re-invoke 1449 * this function with the corrected values for transfer. 1450 */ 1451 ASSERT(pminsize); 1452 if (size <= itask->it_ict->ict_op.op_max_burst_length) { 1453 bsize = size; 1454 } else if (*pminsize <= itask->it_ict->ict_op.op_max_burst_length) { 1455 bsize = itask->it_ict->ict_op.op_max_burst_length; 1456 } else { 1457 *pminsize = itask->it_ict->ict_op.op_max_burst_length; 1458 return (NULL); 1459 } 1460 1461 /* Alloc buffer */ 1462 idm_buffer = idm_buf_alloc(itask->it_ict->ict_ic, NULL, bsize); 1463 if (idm_buffer != NULL) { 1464 result = stmf_alloc(STMF_STRUCT_DATA_BUF, 1465 sizeof (iscsit_buf_t), 0); 1466 if (result != NULL) { 1467 /* Fill in stmf_data_buf_t */ 1468 ibuf = result->db_port_private; 1469 ibuf->ibuf_idm_buf = idm_buffer; 1470 ibuf->ibuf_stmf_buf = result; 1471 ibuf->ibuf_is_immed = B_FALSE; 1472 result->db_flags = DB_DONT_CACHE; 1473 result->db_buf_size = bsize; 1474 result->db_data_size = bsize; 1475 result->db_sglist_length = 1; 1476 result->db_sglist[0].seg_addr = idm_buffer->idb_buf; 1477 result->db_sglist[0].seg_length = 1478 idm_buffer->idb_buflen; 1479 return (result); 1480 } 1481 1482 /* Couldn't get the stmf_data_buf_t so free the buffer */ 1483 idm_buf_free(idm_buffer); 1484 } 1485 1486 return (NULL); 1487 } 1488 1489 /*ARGSUSED*/ 1490 static void 1491 iscsit_dbuf_free(stmf_dbuf_store_t *ds, stmf_data_buf_t *dbuf) 1492 { 1493 iscsit_buf_t *ibuf = dbuf->db_port_private; 1494 1495 if (ibuf->ibuf_is_immed) { 1496 /* 1497 * The iscsit_buf_t structure itself will be freed with its 1498 * associated task. Here we just need to free the PDU that 1499 * held the immediate data. 1500 */ 1501 idm_pdu_complete(ibuf->ibuf_immed_data_pdu, IDM_STATUS_SUCCESS); 1502 ibuf->ibuf_immed_data_pdu = 0; 1503 } else { 1504 idm_buf_free(ibuf->ibuf_idm_buf); 1505 stmf_free(dbuf); 1506 } 1507 } 1508 1509 /*ARGSUSED*/ 1510 stmf_status_t 1511 iscsit_xfer_scsi_data(scsi_task_t *task, stmf_data_buf_t *dbuf, 1512 uint32_t ioflags) 1513 { 1514 iscsit_task_t *iscsit_task = task->task_port_private; 1515 iscsit_sess_t *ict_sess = iscsit_task->it_ict->ict_sess; 1516 iscsit_buf_t *ibuf = dbuf->db_port_private; 1517 int idm_rc; 1518 1519 /* 1520 * If we are aborting then we can ignore this request 1521 */ 1522 if (iscsit_task->it_stmf_abort) { 1523 return (STMF_SUCCESS); 1524 } 1525 1526 /* 1527 * If it's not immediate data then start the transfer 1528 */ 1529 ASSERT(ibuf->ibuf_is_immed == B_FALSE); 1530 if (dbuf->db_flags & DB_DIRECTION_TO_RPORT) { 1531 /* 1532 * The DB_SEND_STATUS_GOOD flag in the STMF data buffer allows 1533 * the port provider to phase-collapse, i.e. send the status 1534 * along with the final data PDU for the command. The port 1535 * provider passes this request to the transport layer by 1536 * setting a flag IDM_TASK_PHASECOLLAPSE_REQ in the task. 1537 */ 1538 if (dbuf->db_flags & DB_SEND_STATUS_GOOD) 1539 iscsit_task->it_idm_task->idt_flags |= 1540 IDM_TASK_PHASECOLLAPSE_REQ; 1541 /* 1542 * IDM will call iscsit_build_hdr so lock now to serialize 1543 * access to the SN values. We need to lock here to enforce 1544 * lock ordering 1545 */ 1546 mutex_enter(&ict_sess->ist_sn_mutex); 1547 idm_rc = idm_buf_tx_to_ini(iscsit_task->it_idm_task, 1548 ibuf->ibuf_idm_buf, dbuf->db_relative_offset, 1549 dbuf->db_data_size, &iscsit_buf_xfer_cb, dbuf); 1550 mutex_exit(&ict_sess->ist_sn_mutex); 1551 1552 return (iscsit_idm_to_stmf(idm_rc)); 1553 } else if (dbuf->db_flags & DB_DIRECTION_FROM_RPORT) { 1554 /* Grab the SN lock (see comment above) */ 1555 mutex_enter(&ict_sess->ist_sn_mutex); 1556 idm_rc = idm_buf_rx_from_ini(iscsit_task->it_idm_task, 1557 ibuf->ibuf_idm_buf, dbuf->db_relative_offset, 1558 dbuf->db_data_size, &iscsit_buf_xfer_cb, dbuf); 1559 mutex_exit(&ict_sess->ist_sn_mutex); 1560 1561 return (iscsit_idm_to_stmf(idm_rc)); 1562 } 1563 1564 /* What are we supposed to do if there is no direction? */ 1565 return (STMF_INVALID_ARG); 1566 } 1567 1568 static void 1569 iscsit_buf_xfer_cb(idm_buf_t *idb, idm_status_t status) 1570 { 1571 iscsit_task_t *itask = idb->idb_task_binding->idt_private; 1572 stmf_data_buf_t *dbuf = idb->idb_cb_arg; 1573 1574 dbuf->db_xfer_status = iscsit_idm_to_stmf(status); 1575 1576 /* 1577 * If the task has been aborted then we don't need to call STMF 1578 */ 1579 if (itask->it_stmf_abort) { 1580 return; 1581 } 1582 1583 /* 1584 * For ISCSI over TCP (not iSER), the last SCSI Data PDU passed 1585 * for a successful command contains the status as requested by 1586 * by COMSTAR (via the DB_SEND_STATUS_GOOD flag). But the iSER 1587 * transport does not support phase-collapse. So pretend we are 1588 * COMSTAR and send the status in a separate PDU now. 1589 */ 1590 if (idb->idb_task_binding->idt_flags & IDM_TASK_PHASECOLLAPSE_SUCCESS) { 1591 /* 1592 * Mark task complete and notify COMSTAR 1593 * that the status has been sent. 1594 */ 1595 itask->it_idm_task->idt_state = TASK_COMPLETE; 1596 stmf_send_status_done(itask->it_stmf_task, 1597 iscsit_idm_to_stmf(status), STMF_IOF_LPORT_DONE); 1598 } else if ((dbuf->db_flags & DB_SEND_STATUS_GOOD) && 1599 status == IDM_STATUS_SUCCESS) { 1600 1601 /* 1602 * The iscsi target port provider - for iSER, emulates the 1603 * DB_SEND_STATUS_GOOD optimization if requested by STMF; 1604 * it sends the status in a separate PDU after the data 1605 * transfer. In this case the port provider should first 1606 * call stmf_data_xfer_done() to mark the transfer complete 1607 * and then send the status. Although STMF will free the 1608 * buffer at the time the task is freed, even if the transfer 1609 * is not marked complete, this behavior makes statistics 1610 * gathering and task state tracking more difficult than it 1611 * needs to be. 1612 */ 1613 stmf_data_xfer_done(itask->it_stmf_task, dbuf, 0); 1614 if (iscsit_send_scsi_status(itask->it_stmf_task, 0) 1615 != STMF_SUCCESS) { 1616 stmf_send_status_done(itask->it_stmf_task, 1617 STMF_FAILURE, STMF_IOF_LPORT_DONE); 1618 } 1619 } else { 1620 stmf_data_xfer_done(itask->it_stmf_task, dbuf, 0); 1621 /* don't touch dbuf after stmf_data_xfer_done */ 1622 } 1623 } 1624 1625 1626 /*ARGSUSED*/ 1627 stmf_status_t 1628 iscsit_send_scsi_status(scsi_task_t *task, uint32_t ioflags) 1629 { 1630 iscsit_task_t *itask = task->task_port_private; 1631 iscsi_scsi_rsp_hdr_t *rsp; 1632 idm_pdu_t *pdu; 1633 int resp_datalen; 1634 1635 /* 1636 * If this task is aborted then we don't need to respond. 1637 */ 1638 if (itask->it_stmf_abort) { 1639 return (STMF_SUCCESS); 1640 } 1641 1642 /* 1643 * If this is a task management status, handle it elsewhere. 1644 */ 1645 if (task->task_mgmt_function != TM_NONE) { 1646 /* 1647 * Don't wait for the PDU completion to tell STMF 1648 * the task is done -- it doesn't really matter and 1649 * it makes life complicated if STMF later asks us to 1650 * abort the request and we don't know whether the 1651 * status has been sent or not. 1652 */ 1653 itask->it_tm_responded = B_TRUE; 1654 iscsit_send_task_mgmt_resp(itask->it_tm_pdu, 1655 (task->task_completion_status == STMF_SUCCESS) ? 1656 SCSI_TCP_TM_RESP_COMPLETE : SCSI_TCP_TM_RESP_FUNC_NOT_SUPP); 1657 stmf_send_status_done(task, STMF_SUCCESS, 1658 STMF_IOF_LPORT_DONE); 1659 return (STMF_SUCCESS); 1660 } 1661 1662 /* 1663 * Remove the task from the session task list 1664 */ 1665 iscsit_task_done(itask); 1666 1667 /* 1668 * Send status 1669 */ 1670 mutex_enter(&itask->it_idm_task->idt_mutex); 1671 if ((itask->it_idm_task->idt_state == TASK_ACTIVE) && 1672 (task->task_completion_status == STMF_SUCCESS) && 1673 (task->task_sense_length == 0) && 1674 (task->task_resid == 0)) { 1675 itask->it_idm_task->idt_state = TASK_COMPLETE; 1676 /* PDU callback releases task hold */ 1677 idm_task_hold(itask->it_idm_task); 1678 mutex_exit(&itask->it_idm_task->idt_mutex); 1679 /* 1680 * Fast path. Cached status PDU's are already 1681 * initialized. We just need to fill in 1682 * connection and task information. StatSN is 1683 * incremented by 1 for every status sent a 1684 * connection. 1685 */ 1686 pdu = kmem_cache_alloc(iscsit_status_pdu_cache, KM_SLEEP); 1687 pdu->isp_ic = itask->it_ict->ict_ic; 1688 pdu->isp_private = itask; 1689 pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN; 1690 1691 rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr; 1692 rsp->itt = itask->it_itt; 1693 /* 1694 * ExpDataSN is the number of R2T and Data-In (read) 1695 * PDUs the target has sent for the SCSI command. 1696 * 1697 * Since there is no support for bidirectional transfer 1698 * yet, either idt_exp_datasn or idt_exp_rttsn, but not 1699 * both is valid at any time 1700 */ 1701 rsp->expdatasn = (itask->it_idm_task->idt_exp_datasn != 0) ? 1702 htonl(itask->it_idm_task->idt_exp_datasn): 1703 htonl(itask->it_idm_task->idt_exp_rttsn); 1704 rsp->cmd_status = task->task_scsi_status; 1705 iscsit_pdu_tx(pdu); 1706 return (STMF_SUCCESS); 1707 } else { 1708 if (itask->it_idm_task->idt_state != TASK_ACTIVE) { 1709 mutex_exit(&itask->it_idm_task->idt_mutex); 1710 return (STMF_FAILURE); 1711 } 1712 itask->it_idm_task->idt_state = TASK_COMPLETE; 1713 /* PDU callback releases task hold */ 1714 idm_task_hold(itask->it_idm_task); 1715 mutex_exit(&itask->it_idm_task->idt_mutex); 1716 1717 resp_datalen = (task->task_sense_length == 0) ? 0 : 1718 (task->task_sense_length + sizeof (uint16_t)); 1719 1720 pdu = idm_pdu_alloc(sizeof (iscsi_hdr_t), resp_datalen); 1721 idm_pdu_init(pdu, itask->it_ict->ict_ic, itask, 1722 iscsit_send_status_done); 1723 pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN; 1724 1725 rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr; 1726 bzero(rsp, sizeof (*rsp)); 1727 rsp->opcode = ISCSI_OP_SCSI_RSP; 1728 1729 rsp->flags = ISCSI_FLAG_FINAL; 1730 if (task->task_status_ctrl & TASK_SCTRL_OVER) { 1731 rsp->flags |= ISCSI_FLAG_CMD_OVERFLOW; 1732 } else if (task->task_status_ctrl & TASK_SCTRL_UNDER) { 1733 rsp->flags |= ISCSI_FLAG_CMD_UNDERFLOW; 1734 } 1735 1736 rsp->bi_residual_count = 0; 1737 rsp->residual_count = htonl(task->task_resid); 1738 rsp->itt = itask->it_itt; 1739 rsp->response = ISCSI_STATUS_CMD_COMPLETED; 1740 rsp->expdatasn = (itask->it_idm_task->idt_exp_datasn != 0) ? 1741 htonl(itask->it_idm_task->idt_exp_datasn): 1742 htonl(itask->it_idm_task->idt_exp_rttsn); 1743 rsp->cmd_status = task->task_scsi_status; 1744 if (task->task_sense_length != 0) { 1745 /* 1746 * Add a byte to provide the sense length in 1747 * the response 1748 */ 1749 *(uint16_t *)((void *)pdu->isp_data) = 1750 htons(task->task_sense_length); 1751 bcopy(task->task_sense_data, 1752 (uint8_t *)pdu->isp_data + 1753 sizeof (uint16_t), 1754 task->task_sense_length); 1755 hton24(rsp->dlength, resp_datalen); 1756 } 1757 1758 DTRACE_PROBE5(iscsi__scsi__response, 1759 iscsit_conn_t *, itask->it_ict, 1760 uint8_t, rsp->response, 1761 uint8_t, rsp->cmd_status, 1762 idm_pdu_t *, pdu, 1763 scsi_task_t *, task); 1764 1765 iscsit_pdu_tx(pdu); 1766 1767 return (STMF_SUCCESS); 1768 } 1769 } 1770 1771 /*ARGSUSED*/ 1772 static void 1773 iscsit_send_good_status_done(idm_pdu_t *pdu, idm_status_t status) 1774 { 1775 iscsit_task_t *itask; 1776 boolean_t aborted; 1777 1778 itask = pdu->isp_private; 1779 aborted = itask->it_stmf_abort; 1780 1781 /* 1782 * After releasing the hold the task may be freed at any time so 1783 * don't touch it. 1784 */ 1785 idm_task_rele(itask->it_idm_task); 1786 if (!aborted) { 1787 stmf_send_status_done(itask->it_stmf_task, 1788 iscsit_idm_to_stmf(pdu->isp_status), STMF_IOF_LPORT_DONE); 1789 } 1790 kmem_cache_free(iscsit_status_pdu_cache, pdu); 1791 } 1792 1793 /*ARGSUSED*/ 1794 static void 1795 iscsit_send_status_done(idm_pdu_t *pdu, idm_status_t status) 1796 { 1797 iscsit_task_t *itask; 1798 boolean_t aborted; 1799 1800 itask = pdu->isp_private; 1801 aborted = itask->it_stmf_abort; 1802 1803 /* 1804 * After releasing the hold the task may be freed at any time so 1805 * don't touch it. 1806 */ 1807 idm_task_rele(itask->it_idm_task); 1808 if (!aborted) { 1809 stmf_send_status_done(itask->it_stmf_task, 1810 iscsit_idm_to_stmf(pdu->isp_status), STMF_IOF_LPORT_DONE); 1811 } 1812 idm_pdu_free(pdu); 1813 } 1814 1815 1816 void 1817 iscsit_lport_task_free(scsi_task_t *task) 1818 { 1819 iscsit_task_t *itask = task->task_port_private; 1820 1821 /* We only call idm_task_start for regular tasks, not task management */ 1822 if (task->task_mgmt_function == TM_NONE) { 1823 idm_task_done(itask->it_idm_task); 1824 iscsit_task_free(itask); 1825 return; 1826 } else { 1827 iscsit_tm_task_free(itask); 1828 } 1829 } 1830 1831 /*ARGSUSED*/ 1832 stmf_status_t 1833 iscsit_abort(stmf_local_port_t *lport, int abort_cmd, void *arg, uint32_t flags) 1834 { 1835 scsi_task_t *st = (scsi_task_t *)arg; 1836 iscsit_task_t *iscsit_task; 1837 idm_task_t *idt; 1838 1839 /* 1840 * If this is a task management request then there's really not much to 1841 * do. 1842 */ 1843 if (st->task_mgmt_function != TM_NONE) { 1844 return (STMF_ABORT_SUCCESS); 1845 } 1846 1847 /* 1848 * Regular task, start cleaning up 1849 */ 1850 iscsit_task = st->task_port_private; 1851 idt = iscsit_task->it_idm_task; 1852 mutex_enter(&iscsit_task->it_mutex); 1853 iscsit_task->it_stmf_abort = B_TRUE; 1854 if (iscsit_task->it_aborted) { 1855 mutex_exit(&iscsit_task->it_mutex); 1856 /* 1857 * Task is no longer active 1858 */ 1859 iscsit_task_done(iscsit_task); 1860 1861 /* 1862 * STMF specification is wrong... says to return 1863 * STMF_ABORTED, the code actually looks for 1864 * STMF_ABORT_SUCCESS. 1865 */ 1866 return (STMF_ABORT_SUCCESS); 1867 } else { 1868 mutex_exit(&iscsit_task->it_mutex); 1869 /* 1870 * Call IDM to abort the task. Due to a variety of 1871 * circumstances the task may already be in the process of 1872 * aborting. 1873 * We'll let IDM worry about rationalizing all that except 1874 * for one particular instance. If the state of the task 1875 * is TASK_COMPLETE, we need to indicate to the framework 1876 * that we are in fact done. This typically happens with 1877 * framework-initiated task management type requests 1878 * (e.g. abort task). 1879 */ 1880 if (idt->idt_state == TASK_COMPLETE) { 1881 idm_refcnt_wait_ref(&idt->idt_refcnt); 1882 return (STMF_ABORT_SUCCESS); 1883 } else { 1884 idm_task_abort(idt->idt_ic, idt, AT_TASK_MGMT_ABORT); 1885 return (STMF_SUCCESS); 1886 } 1887 } 1888 1889 /*NOTREACHED*/ 1890 } 1891 1892 /*ARGSUSED*/ 1893 void 1894 iscsit_ctl(stmf_local_port_t *lport, int cmd, void *arg) 1895 { 1896 iscsit_tgt_t *iscsit_tgt; 1897 1898 ASSERT((cmd == STMF_CMD_LPORT_ONLINE) || 1899 (cmd == STMF_ACK_LPORT_ONLINE_COMPLETE) || 1900 (cmd == STMF_CMD_LPORT_OFFLINE) || 1901 (cmd == STMF_ACK_LPORT_OFFLINE_COMPLETE)); 1902 1903 iscsit_tgt = (iscsit_tgt_t *)lport->lport_port_private; 1904 1905 switch (cmd) { 1906 case STMF_CMD_LPORT_ONLINE: 1907 iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_ONLINE_REQ); 1908 break; 1909 case STMF_CMD_LPORT_OFFLINE: 1910 iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_OFFLINE_REQ); 1911 break; 1912 case STMF_ACK_LPORT_ONLINE_COMPLETE: 1913 iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_ONLINE_COMPLETE_ACK); 1914 break; 1915 case STMF_ACK_LPORT_OFFLINE_COMPLETE: 1916 iscsit_tgt_sm_event(iscsit_tgt, TE_STMF_OFFLINE_COMPLETE_ACK); 1917 break; 1918 1919 default: 1920 break; 1921 } 1922 } 1923 1924 static stmf_status_t 1925 iscsit_idm_to_stmf(idm_status_t idmrc) 1926 { 1927 switch (idmrc) { 1928 case IDM_STATUS_SUCCESS: 1929 return (STMF_SUCCESS); 1930 default: 1931 return (STMF_FAILURE); 1932 } 1933 /*NOTREACHED*/ 1934 } 1935 1936 void 1937 iscsit_op_scsi_cmd(idm_conn_t *ic, idm_pdu_t *rx_pdu) 1938 { 1939 iscsit_conn_t *ict = ic->ic_handle; 1940 1941 if (iscsit_check_cmdsn_and_queue(rx_pdu)) { 1942 iscsit_post_scsi_cmd(ic, rx_pdu); 1943 } 1944 iscsit_process_pdu_in_queue(ict->ict_sess); 1945 } 1946 1947 /* 1948 * ISCSI protocol 1949 */ 1950 1951 void 1952 iscsit_post_scsi_cmd(idm_conn_t *ic, idm_pdu_t *rx_pdu) 1953 { 1954 iscsit_conn_t *ict; 1955 iscsit_task_t *itask; 1956 scsi_task_t *task; 1957 iscsit_buf_t *ibuf; 1958 iscsi_scsi_cmd_hdr_t *iscsi_scsi = 1959 (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr; 1960 iscsi_addl_hdr_t *ahs_hdr; 1961 uint16_t addl_cdb_len = 0; 1962 1963 ict = ic->ic_handle; 1964 1965 itask = iscsit_task_alloc(ict); 1966 if (itask == NULL) { 1967 /* Finish processing request */ 1968 iscsit_set_cmdsn(ict, rx_pdu); 1969 1970 iscsit_send_direct_scsi_resp(ict, rx_pdu, 1971 ISCSI_STATUS_CMD_COMPLETED, STATUS_BUSY); 1972 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 1973 return; 1974 } 1975 1976 /* 1977 * Note CmdSN and ITT in task. IDM will have already validated this 1978 * request against the connection state so we don't need to check 1979 * that (the connection may have changed state in the meantime but 1980 * we will catch that when we try to send a response) 1981 */ 1982 itask->it_cmdsn = ntohl(iscsi_scsi->cmdsn); 1983 itask->it_itt = iscsi_scsi->itt; 1984 1985 /* 1986 * Check for extended CDB AHS 1987 */ 1988 if (iscsi_scsi->hlength > 0) { 1989 ahs_hdr = (iscsi_addl_hdr_t *)iscsi_scsi; 1990 addl_cdb_len = ((ahs_hdr->ahs_hlen_hi << 8) | 1991 ahs_hdr->ahs_hlen_lo) - 1; /* Adjust for reserved byte */ 1992 if (((addl_cdb_len + 4) / sizeof (uint32_t)) > 1993 iscsi_scsi->hlength) { 1994 /* Mangled header info, drop it */ 1995 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 1996 return; 1997 } 1998 } 1999 2000 ict = rx_pdu->isp_ic->ic_handle; /* IDM client private */ 2001 2002 /* 2003 * Add task to session list. This function will also check to 2004 * ensure that the task does not already exist. 2005 */ 2006 if (iscsit_task_start(itask) != IDM_STATUS_SUCCESS) { 2007 /* 2008 * Task exists, free all resources and reject. Don't 2009 * update expcmdsn in this case because RFC 3720 says 2010 * "The CmdSN of the rejected command PDU (if it is a 2011 * non-immediate command) MUST NOT be considered received 2012 * by the target (i.e., a command sequence gap must be 2013 * assumed for the CmdSN), even though the CmdSN of the 2014 * rejected command PDU may be reliably ascertained. Upon 2015 * receiving the Reject, the initiator MUST plug the CmdSN 2016 * gap in order to continue to use the session. The gap 2017 * may be plugged either by transmitting a command PDU 2018 * with the same CmdSN, or by aborting the task (see section 2019 * 6.9 on how an abort may plug a CmdSN gap)." (Section 6.3) 2020 */ 2021 iscsit_task_free(itask); 2022 iscsit_send_reject(ict, rx_pdu, ISCSI_REJECT_TASK_IN_PROGRESS); 2023 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2024 return; 2025 } 2026 2027 /* Update sequence numbers */ 2028 iscsit_set_cmdsn(ict, rx_pdu); 2029 2030 /* 2031 * Allocate STMF task 2032 */ 2033 itask->it_stmf_task = stmf_task_alloc( 2034 itask->it_ict->ict_sess->ist_lport, 2035 itask->it_ict->ict_sess->ist_stmf_sess, iscsi_scsi->lun, 2036 16 + addl_cdb_len, 0); 2037 if (itask->it_stmf_task == NULL) { 2038 /* 2039 * Either stmf really couldn't get memory for a task or, 2040 * more likely, the LU is currently in reset. Either way 2041 * we have no choice but to fail the request. 2042 */ 2043 iscsit_task_done(itask); 2044 iscsit_task_free(itask); 2045 iscsit_send_direct_scsi_resp(ict, rx_pdu, 2046 ISCSI_STATUS_CMD_COMPLETED, STATUS_BUSY); 2047 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2048 return; 2049 } 2050 2051 task = itask->it_stmf_task; 2052 task->task_port_private = itask; 2053 2054 bcopy(iscsi_scsi->lun, task->task_lun_no, sizeof (task->task_lun_no)); 2055 2056 /* 2057 * iSCSI and Comstar use the same values. Should we rely on this 2058 * or translate them bit-wise? 2059 */ 2060 2061 task->task_flags = 2062 (((iscsi_scsi->flags & ISCSI_FLAG_CMD_READ) ? TF_READ_DATA : 0) | 2063 ((iscsi_scsi->flags & ISCSI_FLAG_CMD_WRITE) ? TF_WRITE_DATA : 0) | 2064 ((rx_pdu->isp_datalen == 0) ? 0 : TF_INITIAL_BURST)); 2065 2066 switch (iscsi_scsi->flags & ISCSI_FLAG_CMD_ATTR_MASK) { 2067 case ISCSI_ATTR_UNTAGGED: 2068 break; 2069 case ISCSI_ATTR_SIMPLE: 2070 task->task_additional_flags |= TF_ATTR_SIMPLE_QUEUE; 2071 break; 2072 case ISCSI_ATTR_ORDERED: 2073 task->task_additional_flags |= TF_ATTR_ORDERED_QUEUE; 2074 break; 2075 case ISCSI_ATTR_HEAD_OF_QUEUE: 2076 task->task_additional_flags |= TF_ATTR_HEAD_OF_QUEUE; 2077 break; 2078 case ISCSI_ATTR_ACA: 2079 task->task_additional_flags |= TF_ATTR_ACA; 2080 break; 2081 default: 2082 /* Protocol error but just take it, treat as untagged */ 2083 break; 2084 } 2085 2086 2087 task->task_additional_flags = 0; 2088 task->task_priority = 0; 2089 task->task_mgmt_function = TM_NONE; 2090 2091 /* 2092 * This "task_max_nbufs" doesn't map well to BIDI. We probably need 2093 * parameter for each direction. "MaxOutstandingR2T" may very well 2094 * be set to one which could prevent us from doing simultaneous 2095 * transfers in each direction. 2096 */ 2097 task->task_max_nbufs = (iscsi_scsi->flags & ISCSI_FLAG_CMD_WRITE) ? 2098 ict->ict_op.op_max_outstanding_r2t : STMF_BUFS_MAX; 2099 task->task_cmd_seq_no = ntohl(iscsi_scsi->itt); 2100 task->task_expected_xfer_length = ntohl(iscsi_scsi->data_length); 2101 2102 /* Copy CDB */ 2103 bcopy(iscsi_scsi->scb, task->task_cdb, 16); 2104 if (addl_cdb_len > 0) { 2105 bcopy(ahs_hdr->ahs_extscb, task->task_cdb + 16, addl_cdb_len); 2106 } 2107 2108 DTRACE_ISCSI_3(scsi__command, idm_conn_t *, ic, 2109 iscsi_scsi_cmd_hdr_t *, (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr, 2110 scsi_task_t *, task); 2111 2112 /* 2113 * Copy the transport header into the task handle from the PDU 2114 * handle. The transport header describes this task's remote tagged 2115 * buffer. 2116 */ 2117 if (rx_pdu->isp_transport_hdrlen != 0) { 2118 bcopy(rx_pdu->isp_transport_hdr, 2119 itask->it_idm_task->idt_transport_hdr, 2120 rx_pdu->isp_transport_hdrlen); 2121 } 2122 2123 /* 2124 * Tell IDM about our new active task 2125 */ 2126 idm_task_start(itask->it_idm_task, (uintptr_t)itask->it_itt); 2127 2128 /* 2129 * If we have any immediate data then setup the immediate buffer 2130 * context that comes with the task 2131 */ 2132 if (rx_pdu->isp_datalen) { 2133 ibuf = itask->it_immed_data; 2134 ibuf->ibuf_immed_data_pdu = rx_pdu; 2135 ibuf->ibuf_stmf_buf->db_data_size = rx_pdu->isp_datalen; 2136 ibuf->ibuf_stmf_buf->db_buf_size = rx_pdu->isp_datalen; 2137 ibuf->ibuf_stmf_buf->db_relative_offset = 0; 2138 ibuf->ibuf_stmf_buf->db_sglist[0].seg_length = 2139 rx_pdu->isp_datalen; 2140 ibuf->ibuf_stmf_buf->db_sglist[0].seg_addr = rx_pdu->isp_data; 2141 2142 DTRACE_ISCSI_8(xfer__start, idm_conn_t *, ic, 2143 uintptr_t, ibuf->ibuf_stmf_buf->db_sglist[0].seg_addr, 2144 uint32_t, ibuf->ibuf_stmf_buf->db_relative_offset, 2145 uint64_t, 0, uint32_t, 0, uint32_t, 0, /* no raddr */ 2146 uint32_t, rx_pdu->isp_datalen, int, XFER_BUF_TX_TO_INI); 2147 2148 /* 2149 * For immediate data transfer, there is no callback from 2150 * stmf to indicate that the initial burst of data is 2151 * transferred successfully. In some cases, the task can 2152 * get freed before execution returns from stmf_post_task. 2153 * Although this xfer-start/done probe accurately tracks 2154 * the size of the transfer, it does only provide a best 2155 * effort on the timing of the transfer. 2156 */ 2157 DTRACE_ISCSI_8(xfer__done, idm_conn_t *, ic, 2158 uintptr_t, ibuf->ibuf_stmf_buf->db_sglist[0].seg_addr, 2159 uint32_t, ibuf->ibuf_stmf_buf->db_relative_offset, 2160 uint64_t, 0, uint32_t, 0, uint32_t, 0, /* no raddr */ 2161 uint32_t, rx_pdu->isp_datalen, int, XFER_BUF_TX_TO_INI); 2162 stmf_post_task(task, ibuf->ibuf_stmf_buf); 2163 } else { 2164 2165 stmf_post_task(task, NULL); 2166 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2167 } 2168 } 2169 2170 void 2171 iscsit_deferred_dispatch(idm_pdu_t *rx_pdu) 2172 { 2173 iscsit_conn_t *ict = rx_pdu->isp_ic->ic_handle; 2174 2175 /* 2176 * If this isn't a login packet, we need a session. Otherwise 2177 * this is a protocol error (perhaps one IDM should've caught?). 2178 */ 2179 if (IDM_PDU_OPCODE(rx_pdu) != ISCSI_OP_LOGIN_CMD && 2180 ict->ict_sess == NULL) { 2181 DTRACE_PROBE2(iscsi__idm__deferred__no__session, 2182 iscsit_conn_t *, ict, idm_pdu_t *, rx_pdu); 2183 idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL); 2184 return; 2185 } 2186 2187 /* 2188 * If the connection has been lost then ignore new PDU's 2189 */ 2190 mutex_enter(&ict->ict_mutex); 2191 if (ict->ict_lost) { 2192 mutex_exit(&ict->ict_mutex); 2193 idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL); 2194 return; 2195 } 2196 2197 /* 2198 * Grab a hold on the connection to prevent it from going away 2199 * between now and when the taskq function is called. 2200 */ 2201 iscsit_conn_dispatch_hold(ict); 2202 mutex_exit(&ict->ict_mutex); 2203 2204 taskq_dispatch_ent(iscsit_global.global_dispatch_taskq, 2205 iscsit_deferred, rx_pdu, 0, &rx_pdu->isp_tqent); 2206 } 2207 2208 static void 2209 iscsit_deferred(void *rx_pdu_void) 2210 { 2211 idm_pdu_t *rx_pdu = rx_pdu_void; 2212 idm_conn_t *ic = rx_pdu->isp_ic; 2213 iscsit_conn_t *ict = ic->ic_handle; 2214 2215 /* 2216 * NOP and Task Management Commands can be marked for immediate 2217 * delivery. Commands marked as 'Immediate' are to be considered 2218 * for execution as soon as they arrive on the target. So these 2219 * should not be checked for sequence order and put in a queue. 2220 * The CmdSN is not advanced for Immediate Commands. 2221 */ 2222 switch (IDM_PDU_OPCODE(rx_pdu)) { 2223 case ISCSI_OP_NOOP_OUT: 2224 if (iscsit_check_cmdsn_and_queue(rx_pdu)) { 2225 iscsit_set_cmdsn(ict, rx_pdu); 2226 iscsit_pdu_op_noop(ict, rx_pdu); 2227 } 2228 break; 2229 case ISCSI_OP_LOGIN_CMD: 2230 iscsit_pdu_op_login_cmd(ict, rx_pdu); 2231 iscsit_conn_dispatch_rele(ict); 2232 return; 2233 case ISCSI_OP_TEXT_CMD: 2234 if (iscsit_check_cmdsn_and_queue(rx_pdu)) { 2235 iscsit_set_cmdsn(ict, rx_pdu); 2236 iscsit_pdu_op_text_cmd(ict, rx_pdu); 2237 } 2238 break; 2239 case ISCSI_OP_LOGOUT_CMD: 2240 if (iscsit_check_cmdsn_and_queue(rx_pdu)) { 2241 iscsit_set_cmdsn(ict, rx_pdu); 2242 iscsit_pdu_op_logout_cmd(ict, rx_pdu); 2243 } 2244 break; 2245 default: 2246 /* Protocol error. IDM should have caught this */ 2247 idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL); 2248 ASSERT(0); 2249 break; 2250 } 2251 /* 2252 * Check if there are other PDUs in the session staging queue 2253 * waiting to be posted to SCSI layer. 2254 */ 2255 iscsit_process_pdu_in_queue(ict->ict_sess); 2256 2257 iscsit_conn_dispatch_rele(ict); 2258 } 2259 2260 static void 2261 iscsit_send_direct_scsi_resp(iscsit_conn_t *ict, idm_pdu_t *rx_pdu, 2262 uint8_t response, uint8_t cmd_status) 2263 { 2264 idm_pdu_t *rsp_pdu; 2265 idm_conn_t *ic; 2266 iscsi_scsi_rsp_hdr_t *resp; 2267 iscsi_scsi_cmd_hdr_t *req = 2268 (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr; 2269 2270 ic = ict->ict_ic; 2271 2272 rsp_pdu = idm_pdu_alloc(sizeof (iscsi_scsi_rsp_hdr_t), 0); 2273 idm_pdu_init(rsp_pdu, ic, NULL, NULL); 2274 /* 2275 * StatSN is incremented by 1 for every response sent on 2276 * a connection except for responses sent as a result of 2277 * a retry or SNACK 2278 */ 2279 rsp_pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN; 2280 2281 resp = (iscsi_scsi_rsp_hdr_t *)rsp_pdu->isp_hdr; 2282 2283 resp->opcode = ISCSI_OP_SCSI_RSP; 2284 resp->flags = ISCSI_FLAG_FINAL; 2285 resp->response = response; 2286 resp->cmd_status = cmd_status; 2287 resp->itt = req->itt; 2288 if ((response == ISCSI_STATUS_CMD_COMPLETED) && 2289 (req->data_length != 0) && 2290 ((req->flags & ISCSI_FLAG_CMD_READ) || 2291 (req->flags & ISCSI_FLAG_CMD_WRITE))) { 2292 resp->flags |= ISCSI_FLAG_CMD_UNDERFLOW; 2293 resp->residual_count = req->data_length; 2294 } 2295 2296 DTRACE_PROBE4(iscsi__scsi__direct__response, 2297 iscsit_conn_t *, ict, 2298 uint8_t, resp->response, 2299 uint8_t, resp->cmd_status, 2300 idm_pdu_t *, rsp_pdu); 2301 2302 iscsit_pdu_tx(rsp_pdu); 2303 } 2304 2305 void 2306 iscsit_send_task_mgmt_resp(idm_pdu_t *tm_resp_pdu, uint8_t tm_status) 2307 { 2308 iscsi_scsi_task_mgt_rsp_hdr_t *tm_resp; 2309 2310 /* 2311 * The target must take note of the last-sent StatSN. 2312 * The StatSN is to be incremented after sending a 2313 * task management response. Digest recovery can only 2314 * work if StatSN is incremented. 2315 */ 2316 tm_resp_pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN; 2317 tm_resp = (iscsi_scsi_task_mgt_rsp_hdr_t *)tm_resp_pdu->isp_hdr; 2318 tm_resp->response = tm_status; 2319 2320 DTRACE_PROBE3(iscsi__scsi__tm__response, 2321 iscsit_conn_t *, tm_resp_pdu->isp_ic->ic_handle, 2322 uint8_t, tm_resp->response, 2323 idm_pdu_t *, tm_resp_pdu); 2324 iscsit_pdu_tx(tm_resp_pdu); 2325 } 2326 2327 void 2328 iscsit_op_scsi_task_mgmt(iscsit_conn_t *ict, idm_pdu_t *rx_pdu) 2329 { 2330 idm_pdu_t *tm_resp_pdu; 2331 iscsit_task_t *itask; 2332 iscsit_task_t *tm_itask; 2333 scsi_task_t *task; 2334 iscsi_scsi_task_mgt_hdr_t *iscsi_tm = 2335 (iscsi_scsi_task_mgt_hdr_t *)rx_pdu->isp_hdr; 2336 iscsi_scsi_task_mgt_rsp_hdr_t *iscsi_tm_rsp = 2337 (iscsi_scsi_task_mgt_rsp_hdr_t *)rx_pdu->isp_hdr; 2338 uint32_t rtt, cmdsn, refcmdsn; 2339 uint8_t tm_func; 2340 2341 /* 2342 * Setup response PDU (response field will get filled in later) 2343 */ 2344 tm_resp_pdu = idm_pdu_alloc(sizeof (iscsi_scsi_task_mgt_rsp_hdr_t), 0); 2345 if (tm_resp_pdu == NULL) { 2346 /* Can't respond, just drop it */ 2347 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2348 return; 2349 } 2350 idm_pdu_init(tm_resp_pdu, ict->ict_ic, NULL, NULL); 2351 iscsi_tm_rsp = (iscsi_scsi_task_mgt_rsp_hdr_t *)tm_resp_pdu->isp_hdr; 2352 bzero(iscsi_tm_rsp, sizeof (iscsi_scsi_task_mgt_rsp_hdr_t)); 2353 iscsi_tm_rsp->opcode = ISCSI_OP_SCSI_TASK_MGT_RSP; 2354 iscsi_tm_rsp->flags = ISCSI_FLAG_FINAL; 2355 iscsi_tm_rsp->itt = rx_pdu->isp_hdr->itt; 2356 2357 /* 2358 * Figure out what we're being asked to do. 2359 */ 2360 DTRACE_PROBE4(iscsi__scsi__tm__request, 2361 iscsit_conn_t *, ict, 2362 uint8_t, (iscsi_tm->function & ISCSI_FLAG_TASK_MGMT_FUNCTION_MASK), 2363 uint32_t, iscsi_tm->rtt, 2364 idm_pdu_t *, rx_pdu); 2365 switch (iscsi_tm->function & ISCSI_FLAG_TASK_MGMT_FUNCTION_MASK) { 2366 case ISCSI_TM_FUNC_ABORT_TASK: 2367 /* 2368 * STMF doesn't currently support the "abort task" task 2369 * management command although it does support aborting 2370 * an individual task. We'll get STMF to abort the task 2371 * for us but handle the details of the task management 2372 * command ourselves. 2373 * 2374 * Find the task associated with the referenced task tag. 2375 */ 2376 rtt = iscsi_tm->rtt; 2377 itask = (iscsit_task_t *)idm_task_find_by_handle(ict->ict_ic, 2378 (uintptr_t)rtt); 2379 2380 if (itask == NULL) { 2381 cmdsn = ntohl(iscsi_tm->cmdsn); 2382 refcmdsn = ntohl(iscsi_tm->refcmdsn); 2383 2384 /* 2385 * Task was not found. But the SCSI command could be 2386 * on the rxpdu wait queue. If RefCmdSN is within 2387 * the CmdSN window and less than CmdSN of the TM 2388 * function, return "Function Complete". Otherwise, 2389 * return "Task Does Not Exist". 2390 */ 2391 2392 if (iscsit_cmdsn_in_window(ict, refcmdsn) && 2393 iscsit_sna_lt(refcmdsn, cmdsn)) { 2394 mutex_enter(&ict->ict_sess->ist_sn_mutex); 2395 (void) iscsit_remove_pdu_from_queue( 2396 ict->ict_sess, refcmdsn); 2397 iscsit_conn_dispatch_rele(ict); 2398 mutex_exit(&ict->ict_sess->ist_sn_mutex); 2399 iscsit_send_task_mgmt_resp(tm_resp_pdu, 2400 SCSI_TCP_TM_RESP_COMPLETE); 2401 } else { 2402 iscsit_send_task_mgmt_resp(tm_resp_pdu, 2403 SCSI_TCP_TM_RESP_NO_TASK); 2404 } 2405 } else { 2406 2407 /* 2408 * Tell STMF to abort the task. This will do no harm 2409 * if the task is already complete. 2410 */ 2411 stmf_abort(STMF_QUEUE_TASK_ABORT, itask->it_stmf_task, 2412 STMF_ABORTED, NULL); 2413 2414 /* 2415 * Make sure the task hasn't already completed 2416 */ 2417 mutex_enter(&itask->it_idm_task->idt_mutex); 2418 if ((itask->it_idm_task->idt_state == TASK_COMPLETE) || 2419 (itask->it_idm_task->idt_state == TASK_IDLE)) { 2420 /* 2421 * Task is complete, return "Task Does Not 2422 * Exist" 2423 */ 2424 mutex_exit(&itask->it_idm_task->idt_mutex); 2425 iscsit_send_task_mgmt_resp(tm_resp_pdu, 2426 SCSI_TCP_TM_RESP_NO_TASK); 2427 } else { 2428 /* 2429 * STMF is now aborting the task, return 2430 * "Function Complete" 2431 */ 2432 mutex_exit(&itask->it_idm_task->idt_mutex); 2433 iscsit_send_task_mgmt_resp(tm_resp_pdu, 2434 SCSI_TCP_TM_RESP_COMPLETE); 2435 } 2436 idm_task_rele(itask->it_idm_task); 2437 } 2438 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2439 return; 2440 2441 case ISCSI_TM_FUNC_ABORT_TASK_SET: 2442 tm_func = TM_ABORT_TASK_SET; 2443 break; 2444 2445 case ISCSI_TM_FUNC_CLEAR_ACA: 2446 tm_func = TM_CLEAR_ACA; 2447 break; 2448 2449 case ISCSI_TM_FUNC_CLEAR_TASK_SET: 2450 tm_func = TM_CLEAR_TASK_SET; 2451 break; 2452 2453 case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET: 2454 tm_func = TM_LUN_RESET; 2455 break; 2456 2457 case ISCSI_TM_FUNC_TARGET_WARM_RESET: 2458 tm_func = TM_TARGET_WARM_RESET; 2459 break; 2460 2461 case ISCSI_TM_FUNC_TARGET_COLD_RESET: 2462 tm_func = TM_TARGET_COLD_RESET; 2463 break; 2464 2465 case ISCSI_TM_FUNC_TASK_REASSIGN: 2466 /* 2467 * We do not currently support allegiance reassignment. When 2468 * we start supporting ERL1+, we will need to. 2469 */ 2470 iscsit_send_task_mgmt_resp(tm_resp_pdu, 2471 SCSI_TCP_TM_RESP_NO_ALLG_REASSN); 2472 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2473 return; 2474 2475 default: 2476 iscsit_send_task_mgmt_resp(tm_resp_pdu, 2477 SCSI_TCP_TM_RESP_REJECTED); 2478 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2479 return; 2480 } 2481 2482 tm_itask = iscsit_tm_task_alloc(ict); 2483 if (tm_itask == NULL) { 2484 iscsit_send_task_mgmt_resp(tm_resp_pdu, 2485 SCSI_TCP_TM_RESP_REJECTED); 2486 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2487 return; 2488 } 2489 2490 2491 task = stmf_task_alloc(ict->ict_sess->ist_lport, 2492 ict->ict_sess->ist_stmf_sess, iscsi_tm->lun, 2493 0, STMF_TASK_EXT_NONE); 2494 if (task == NULL) { 2495 /* 2496 * If this happens, either the LU is in reset, couldn't 2497 * get memory, or some other condition in which we simply 2498 * can't complete this request. It would be nice to return 2499 * an error code like "busy" but the closest we have is 2500 * "rejected". 2501 */ 2502 iscsit_send_task_mgmt_resp(tm_resp_pdu, 2503 SCSI_TCP_TM_RESP_REJECTED); 2504 iscsit_tm_task_free(tm_itask); 2505 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2506 return; 2507 } 2508 2509 tm_itask->it_tm_pdu = tm_resp_pdu; 2510 tm_itask->it_stmf_task = task; 2511 task->task_port_private = tm_itask; 2512 task->task_mgmt_function = tm_func; 2513 task->task_additional_flags = TASK_AF_NO_EXPECTED_XFER_LENGTH; 2514 task->task_priority = 0; 2515 task->task_max_nbufs = STMF_BUFS_MAX; 2516 task->task_cmd_seq_no = iscsi_tm->itt; 2517 task->task_expected_xfer_length = 0; 2518 2519 stmf_post_task(task, NULL); 2520 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2521 } 2522 2523 static void 2524 iscsit_pdu_op_noop(iscsit_conn_t *ict, idm_pdu_t *rx_pdu) 2525 { 2526 iscsi_nop_out_hdr_t *out = (iscsi_nop_out_hdr_t *)rx_pdu->isp_hdr; 2527 iscsi_nop_in_hdr_t *in; 2528 int resp_datalen; 2529 idm_pdu_t *resp; 2530 2531 /* Ignore the response from initiator */ 2532 if ((out->itt == ISCSI_RSVD_TASK_TAG) || 2533 (out->ttt != ISCSI_RSVD_TASK_TAG)) { 2534 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2535 return; 2536 } 2537 2538 /* Allocate a PDU to respond */ 2539 resp_datalen = ntoh24(out->dlength); 2540 resp = idm_pdu_alloc(sizeof (iscsi_hdr_t), resp_datalen); 2541 idm_pdu_init(resp, ict->ict_ic, NULL, NULL); 2542 if (resp_datalen > 0) { 2543 bcopy(rx_pdu->isp_data, resp->isp_data, resp_datalen); 2544 } 2545 2546 /* 2547 * When sending a NOP-In as a response to a NOP-Out from the initiator, 2548 * the target must respond with the same initiator task tag that was 2549 * provided in the NOP-Out request, the target transfer tag must be 2550 * ISCSI_RSVD_TASK_TAG (0xffffffff) and StatSN will contain the next 2551 * status sequence number. The StatSN for the connection is advanced 2552 * after this PDU is sent. 2553 */ 2554 in = (iscsi_nop_in_hdr_t *)resp->isp_hdr; 2555 bzero(in, sizeof (*in)); 2556 in->opcode = ISCSI_OP_NOOP_IN; 2557 in->flags = ISCSI_FLAG_FINAL; 2558 bcopy(out->lun, in->lun, 8); 2559 in->itt = out->itt; 2560 in->ttt = ISCSI_RSVD_TASK_TAG; 2561 hton24(in->dlength, resp_datalen); 2562 resp->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN; 2563 /* Any other field in resp to be set? */ 2564 iscsit_pdu_tx(resp); 2565 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2566 } 2567 2568 static void 2569 iscsit_pdu_op_login_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu) 2570 { 2571 2572 /* 2573 * Submit PDU to login state machine. State machine will free the 2574 * PDU. 2575 */ 2576 iscsit_login_sm_event(ict, ILE_LOGIN_RCV, rx_pdu); 2577 } 2578 2579 void 2580 iscsit_pdu_op_logout_cmd(iscsit_conn_t *ict, idm_pdu_t *rx_pdu) 2581 { 2582 iscsi_logout_hdr_t *logout_req = 2583 (iscsi_logout_hdr_t *)rx_pdu->isp_hdr; 2584 iscsi_logout_rsp_hdr_t *logout_rsp; 2585 idm_pdu_t *resp; 2586 2587 /* Allocate a PDU to respond */ 2588 resp = idm_pdu_alloc(sizeof (iscsi_hdr_t), 0); 2589 idm_pdu_init(resp, ict->ict_ic, NULL, NULL); 2590 /* 2591 * The StatSN is to be sent to the initiator, 2592 * it is not required to increment the number 2593 * as the connection is terminating. 2594 */ 2595 resp->isp_flags |= IDM_PDU_SET_STATSN; 2596 /* 2597 * Logout results in the immediate termination of all tasks except 2598 * if the logout reason is ISCSI_LOGOUT_REASON_RECOVERY. The 2599 * connection state machine will drive this task cleanup automatically 2600 * so we don't need to handle that here. 2601 */ 2602 logout_rsp = (iscsi_logout_rsp_hdr_t *)resp->isp_hdr; 2603 bzero(logout_rsp, sizeof (*logout_rsp)); 2604 logout_rsp->opcode = ISCSI_OP_LOGOUT_RSP; 2605 logout_rsp->flags = ISCSI_FLAG_FINAL; 2606 logout_rsp->itt = logout_req->itt; 2607 if ((logout_req->flags & ISCSI_FLAG_LOGOUT_REASON_MASK) > 2608 ISCSI_LOGOUT_REASON_RECOVERY) { 2609 logout_rsp->response = ISCSI_LOGOUT_RECOVERY_UNSUPPORTED; 2610 } else { 2611 logout_rsp->response = ISCSI_LOGOUT_SUCCESS; 2612 } 2613 2614 iscsit_pdu_tx(resp); 2615 idm_pdu_complete(rx_pdu, IDM_STATUS_SUCCESS); 2616 } 2617 2618 /* 2619 * Calculate the number of outstanding commands we can process 2620 */ 2621 int 2622 iscsit_cmd_window() 2623 { 2624 /* 2625 * Instead of using a pre-defined constant for the command window, 2626 * it should be made confiurable and dynamic. With MC/S, sequence 2627 * numbers will be used up at a much faster rate than with SC/S. 2628 */ 2629 return (ISCSIT_MAX_WINDOW); 2630 } 2631 2632 /* 2633 * Set local registers based on incoming PDU 2634 */ 2635 void 2636 iscsit_set_cmdsn(iscsit_conn_t *ict, idm_pdu_t *rx_pdu) 2637 { 2638 iscsit_sess_t *ist; 2639 iscsi_scsi_cmd_hdr_t *req; 2640 2641 ist = ict->ict_sess; 2642 2643 req = (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr; 2644 if (req->opcode & ISCSI_OP_IMMEDIATE) { 2645 /* no cmdsn increment for immediate PDUs */ 2646 return; 2647 } 2648 2649 /* Ensure that the ExpCmdSN advances in an orderly manner */ 2650 mutex_enter(&ist->ist_sn_mutex); 2651 ist->ist_expcmdsn = ntohl(req->cmdsn) + 1; 2652 ist->ist_maxcmdsn = ntohl(req->cmdsn) + iscsit_cmd_window(); 2653 mutex_exit(&ist->ist_sn_mutex); 2654 } 2655 2656 /* 2657 * Wrapper funtion, calls iscsi_calc_rspsn and idm_pdu_tx 2658 */ 2659 void 2660 iscsit_pdu_tx(idm_pdu_t *pdu) 2661 { 2662 iscsit_conn_t *ict = pdu->isp_ic->ic_handle; 2663 iscsi_scsi_rsp_hdr_t *rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr; 2664 iscsit_sess_t *ist = ict->ict_sess; 2665 2666 /* 2667 * The command sequence numbers are session-wide and must stay 2668 * consistent across the transfer, so protect the cmdsn with a 2669 * mutex lock on the session. The status sequence number will 2670 * be updated just before the transport layer transmits the PDU. 2671 */ 2672 2673 mutex_enter(&ict->ict_sess->ist_sn_mutex); 2674 /* Set ExpCmdSN and MaxCmdSN */ 2675 rsp->maxcmdsn = htonl(ist->ist_maxcmdsn); 2676 rsp->expcmdsn = htonl(ist->ist_expcmdsn); 2677 idm_pdu_tx(pdu); 2678 mutex_exit(&ict->ict_sess->ist_sn_mutex); 2679 } 2680 2681 /* 2682 * Internal functions 2683 */ 2684 2685 void 2686 iscsit_send_async_event(iscsit_conn_t *ict, uint8_t event) 2687 { 2688 idm_pdu_t *abt; 2689 iscsi_async_evt_hdr_t *async_abt; 2690 2691 /* 2692 * Get a PDU to build the abort request. 2693 */ 2694 abt = idm_pdu_alloc(sizeof (iscsi_hdr_t), 0); 2695 if (abt == NULL) { 2696 idm_conn_event(ict->ict_ic, CE_TRANSPORT_FAIL, NULL); 2697 return; 2698 } 2699 2700 /* 2701 * A asynchronous message is sent by the target to request a logout. 2702 * The StatSN for the connection is advanced after the PDU is sent 2703 * to allow for initiator and target state synchronization. 2704 */ 2705 idm_pdu_init(abt, ict->ict_ic, NULL, NULL); 2706 abt->isp_datalen = 0; 2707 abt->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN; 2708 2709 async_abt = (iscsi_async_evt_hdr_t *)abt->isp_hdr; 2710 bzero(async_abt, sizeof (*async_abt)); 2711 async_abt->opcode = ISCSI_OP_ASYNC_EVENT; 2712 async_abt->async_event = event; 2713 async_abt->flags = ISCSI_FLAG_FINAL; 2714 async_abt->rsvd4[0] = 0xff; 2715 async_abt->rsvd4[1] = 0xff; 2716 async_abt->rsvd4[2] = 0xff; 2717 async_abt->rsvd4[3] = 0xff; 2718 2719 switch (event) { 2720 case ISCSI_ASYNC_EVENT_REQUEST_LOGOUT: 2721 async_abt->param3 = htons(IDM_LOGOUT_SECONDS); 2722 break; 2723 case ISCSI_ASYNC_EVENT_SCSI_EVENT: 2724 case ISCSI_ASYNC_EVENT_DROPPING_CONNECTION: 2725 case ISCSI_ASYNC_EVENT_DROPPING_ALL_CONNECTIONS: 2726 case ISCSI_ASYNC_EVENT_PARAM_NEGOTIATION: 2727 default: 2728 ASSERT(0); 2729 } 2730 2731 iscsit_pdu_tx(abt); 2732 } 2733 2734 void 2735 iscsit_send_reject(iscsit_conn_t *ict, idm_pdu_t *rejected_pdu, uint8_t reason) 2736 { 2737 idm_pdu_t *reject_pdu; 2738 iscsi_reject_rsp_hdr_t *reject; 2739 2740 /* 2741 * Get a PDU to build the abort request. 2742 */ 2743 reject_pdu = idm_pdu_alloc(sizeof (iscsi_hdr_t), 2744 rejected_pdu->isp_hdrlen); 2745 if (reject_pdu == NULL) { 2746 idm_conn_event(ict->ict_ic, CE_TRANSPORT_FAIL, NULL); 2747 return; 2748 } 2749 idm_pdu_init(reject_pdu, ict->ict_ic, NULL, NULL); 2750 /* StatSN is advanced after a Reject PDU */ 2751 reject_pdu->isp_flags |= IDM_PDU_SET_STATSN | IDM_PDU_ADVANCE_STATSN; 2752 reject_pdu->isp_datalen = rejected_pdu->isp_hdrlen; 2753 bcopy(rejected_pdu->isp_hdr, reject_pdu->isp_data, 2754 rejected_pdu->isp_hdrlen); 2755 2756 reject = (iscsi_reject_rsp_hdr_t *)reject_pdu->isp_hdr; 2757 bzero(reject, sizeof (*reject)); 2758 reject->opcode = ISCSI_OP_REJECT_MSG; 2759 reject->reason = reason; 2760 reject->flags = ISCSI_FLAG_FINAL; 2761 hton24(reject->dlength, rejected_pdu->isp_hdrlen); 2762 reject->must_be_ff[0] = 0xff; 2763 reject->must_be_ff[1] = 0xff; 2764 reject->must_be_ff[2] = 0xff; 2765 reject->must_be_ff[3] = 0xff; 2766 2767 iscsit_pdu_tx(reject_pdu); 2768 } 2769 2770 2771 static iscsit_task_t * 2772 iscsit_task_alloc(iscsit_conn_t *ict) 2773 { 2774 iscsit_task_t *itask; 2775 iscsit_buf_t *immed_ibuf; 2776 2777 /* 2778 * Possible items to pre-alloc if we cache iscsit_task_t's: 2779 * 2780 * Status PDU w/ sense buffer 2781 * stmf_data_buf_t for immediate data 2782 */ 2783 itask = kmem_alloc(sizeof (iscsit_task_t) + sizeof (iscsit_buf_t) + 2784 sizeof (stmf_data_buf_t), KM_NOSLEEP); 2785 if (itask != NULL) { 2786 mutex_init(&itask->it_mutex, NULL, MUTEX_DRIVER, NULL); 2787 itask->it_aborted = itask->it_stmf_abort = 2788 itask->it_tm_task = 0; 2789 2790 immed_ibuf = (iscsit_buf_t *)(itask + 1); 2791 bzero(immed_ibuf, sizeof (*immed_ibuf)); 2792 immed_ibuf->ibuf_is_immed = B_TRUE; 2793 immed_ibuf->ibuf_stmf_buf = (stmf_data_buf_t *)(immed_ibuf + 1); 2794 2795 bzero(immed_ibuf->ibuf_stmf_buf, sizeof (stmf_data_buf_t)); 2796 immed_ibuf->ibuf_stmf_buf->db_port_private = immed_ibuf; 2797 immed_ibuf->ibuf_stmf_buf->db_sglist_length = 1; 2798 immed_ibuf->ibuf_stmf_buf->db_flags = DB_DIRECTION_FROM_RPORT | 2799 DB_DONT_CACHE; 2800 itask->it_immed_data = immed_ibuf; 2801 itask->it_idm_task = idm_task_alloc(ict->ict_ic); 2802 if (itask->it_idm_task != NULL) { 2803 itask->it_idm_task->idt_private = itask; 2804 itask->it_ict = ict; 2805 itask->it_ttt = itask->it_idm_task->idt_tt; 2806 return (itask); 2807 } else { 2808 kmem_free(itask, sizeof (iscsit_task_t) + 2809 sizeof (iscsit_buf_t) + sizeof (stmf_data_buf_t)); 2810 } 2811 } 2812 2813 return (NULL); 2814 } 2815 2816 static void 2817 iscsit_task_free(iscsit_task_t *itask) 2818 { 2819 idm_task_free(itask->it_idm_task); 2820 mutex_destroy(&itask->it_mutex); 2821 kmem_free(itask, sizeof (iscsit_task_t) + 2822 sizeof (iscsit_buf_t) + sizeof (stmf_data_buf_t)); 2823 } 2824 2825 static iscsit_task_t * 2826 iscsit_tm_task_alloc(iscsit_conn_t *ict) 2827 { 2828 iscsit_task_t *itask; 2829 2830 itask = kmem_zalloc(sizeof (iscsit_task_t), KM_NOSLEEP); 2831 if (itask != NULL) { 2832 idm_conn_hold(ict->ict_ic); 2833 mutex_init(&itask->it_mutex, NULL, MUTEX_DRIVER, NULL); 2834 itask->it_aborted = itask->it_stmf_abort = 2835 itask->it_tm_responded = 0; 2836 itask->it_tm_pdu = NULL; 2837 itask->it_tm_task = 1; 2838 itask->it_ict = ict; 2839 } 2840 2841 return (itask); 2842 } 2843 2844 static void 2845 iscsit_tm_task_free(iscsit_task_t *itask) 2846 { 2847 /* 2848 * If we responded then the call to idm_pdu_complete will free the 2849 * PDU. Otherwise we got aborted before the TM function could 2850 * complete and we need to free the PDU explicitly. 2851 */ 2852 if (itask->it_tm_pdu != NULL && !itask->it_tm_responded) 2853 idm_pdu_free(itask->it_tm_pdu); 2854 idm_conn_rele(itask->it_ict->ict_ic); 2855 mutex_destroy(&itask->it_mutex); 2856 kmem_free(itask, sizeof (iscsit_task_t)); 2857 } 2858 2859 static idm_status_t 2860 iscsit_task_start(iscsit_task_t *itask) 2861 { 2862 iscsit_sess_t *ist = itask->it_ict->ict_sess; 2863 avl_index_t where; 2864 2865 /* 2866 * Sanity check the ITT and ensure that this task does not already 2867 * exist. If not then add the task to the session task list. 2868 */ 2869 mutex_enter(&ist->ist_mutex); 2870 mutex_enter(&itask->it_mutex); 2871 itask->it_active = 1; 2872 if (avl_find(&ist->ist_task_list, itask, &where) == NULL) { 2873 /* New task, add to AVL */ 2874 avl_insert(&ist->ist_task_list, itask, where); 2875 mutex_exit(&itask->it_mutex); 2876 mutex_exit(&ist->ist_mutex); 2877 return (IDM_STATUS_SUCCESS); 2878 } 2879 mutex_exit(&itask->it_mutex); 2880 mutex_exit(&ist->ist_mutex); 2881 2882 return (IDM_STATUS_REJECT); 2883 } 2884 2885 static void 2886 iscsit_task_done(iscsit_task_t *itask) 2887 { 2888 iscsit_sess_t *ist = itask->it_ict->ict_sess; 2889 2890 mutex_enter(&ist->ist_mutex); 2891 mutex_enter(&itask->it_mutex); 2892 if (itask->it_active) { 2893 avl_remove(&ist->ist_task_list, itask); 2894 itask->it_active = 0; 2895 } 2896 mutex_exit(&itask->it_mutex); 2897 mutex_exit(&ist->ist_mutex); 2898 } 2899 2900 /* 2901 * iscsit status PDU cache 2902 */ 2903 2904 /*ARGSUSED*/ 2905 static int 2906 iscsit_status_pdu_constructor(void *pdu_void, void *arg, int flags) 2907 { 2908 idm_pdu_t *pdu = pdu_void; 2909 iscsi_scsi_rsp_hdr_t *rsp; 2910 2911 bzero(pdu, sizeof (idm_pdu_t)); 2912 pdu->isp_callback = iscsit_send_good_status_done; 2913 pdu->isp_magic = IDM_PDU_MAGIC; 2914 pdu->isp_hdr = (iscsi_hdr_t *)(pdu + 1); /* Ptr arithmetic */ 2915 pdu->isp_hdrlen = sizeof (iscsi_hdr_t); 2916 2917 /* Setup status response */ 2918 rsp = (iscsi_scsi_rsp_hdr_t *)pdu->isp_hdr; 2919 bzero(rsp, sizeof (*rsp)); 2920 rsp->opcode = ISCSI_OP_SCSI_RSP; 2921 rsp->flags = ISCSI_FLAG_FINAL; 2922 rsp->response = ISCSI_STATUS_CMD_COMPLETED; 2923 2924 return (0); 2925 } 2926 2927 /* 2928 * iscsit private data handler 2929 */ 2930 2931 /*ARGSUSED*/ 2932 static void 2933 iscsit_pp_cb(struct stmf_port_provider *pp, int cmd, void *arg, uint32_t flags) 2934 { 2935 it_config_t *cfg; 2936 nvlist_t *nvl; 2937 iscsit_service_enabled_t old_state; 2938 2939 if ((cmd != STMF_PROVIDER_DATA_UPDATED) || (arg == NULL)) { 2940 return; 2941 } 2942 2943 nvl = (nvlist_t *)arg; 2944 2945 /* Translate nvlist */ 2946 if (it_nv_to_config(nvl, &cfg) != 0) { 2947 cmn_err(CE_WARN, "Configuration is invalid"); 2948 return; 2949 } 2950 2951 /* Check that no iSCSI ioctl is currently running */ 2952 mutex_enter(&iscsit_global.global_state_mutex); 2953 old_state = iscsit_global.global_svc_state; 2954 switch (iscsit_global.global_svc_state) { 2955 case ISE_ENABLED: 2956 case ISE_DISABLED: 2957 iscsit_global.global_svc_state = ISE_BUSY; 2958 break; 2959 case ISE_ENABLING: 2960 /* 2961 * It is OK for the iscsit_pp_cb to be called from inside of 2962 * an iSCSI ioctl only if we are currently executing inside 2963 * of stmf_register_port_provider. 2964 */ 2965 ASSERT((flags & STMF_PCB_PREG_COMPLETE) != 0); 2966 break; 2967 default: 2968 cmn_err(CE_WARN, "iscsit_pp_cb called when global_svc_state" 2969 " is not ENABLED(0x%x) -- ignoring", 2970 iscsit_global.global_svc_state); 2971 mutex_exit(&iscsit_global.global_state_mutex); 2972 it_config_free_cmn(cfg); 2973 return; 2974 } 2975 mutex_exit(&iscsit_global.global_state_mutex); 2976 2977 /* Update config */ 2978 (void) iscsit_config_merge(cfg); 2979 2980 it_config_free_cmn(cfg); 2981 2982 /* Restore old iSCSI driver global state */ 2983 mutex_enter(&iscsit_global.global_state_mutex); 2984 ASSERT(iscsit_global.global_svc_state == ISE_BUSY || 2985 iscsit_global.global_svc_state == ISE_ENABLING); 2986 iscsit_global.global_svc_state = old_state; 2987 mutex_exit(&iscsit_global.global_state_mutex); 2988 } 2989 2990 2991 static it_cfg_status_t 2992 iscsit_config_merge(it_config_t *in_cfg) 2993 { 2994 it_cfg_status_t status; 2995 it_config_t *cfg; 2996 it_config_t tmp_cfg; 2997 list_t tpg_del_list; 2998 2999 if (in_cfg) { 3000 cfg = in_cfg; 3001 } else { 3002 /* Make empty config */ 3003 bzero(&tmp_cfg, sizeof (tmp_cfg)); 3004 cfg = &tmp_cfg; 3005 } 3006 3007 list_create(&tpg_del_list, sizeof (iscsit_tpg_t), 3008 offsetof(iscsit_tpg_t, tpg_delete_ln)); 3009 3010 /* 3011 * Update targets, initiator contexts, target portal groups, 3012 * and iSNS client 3013 */ 3014 ISCSIT_GLOBAL_LOCK(RW_WRITER); 3015 if (((status = iscsit_config_merge_tpg(cfg, &tpg_del_list)) 3016 != 0) || 3017 ((status = iscsit_config_merge_tgt(cfg)) != 0) || 3018 ((status = iscsit_config_merge_ini(cfg)) != 0) || 3019 ((status = isnst_config_merge(cfg)) != 0)) { 3020 ISCSIT_GLOBAL_UNLOCK(); 3021 return (status); 3022 } 3023 3024 /* Update other global config parameters */ 3025 if (iscsit_global.global_props) { 3026 nvlist_free(iscsit_global.global_props); 3027 iscsit_global.global_props = NULL; 3028 } 3029 if (in_cfg) { 3030 (void) nvlist_dup(cfg->config_global_properties, 3031 &iscsit_global.global_props, KM_SLEEP); 3032 } 3033 ISCSIT_GLOBAL_UNLOCK(); 3034 3035 iscsit_config_destroy_tpgs(&tpg_del_list); 3036 3037 list_destroy(&tpg_del_list); 3038 3039 return (ITCFG_SUCCESS); 3040 } 3041 3042 /* 3043 * iscsit_sna_lt[e] 3044 * 3045 * Compare serial numbers using serial number arithmetic as defined in 3046 * RFC 1982. 3047 * 3048 * NOTE: This code is duplicated in the isns server. It ought to be common. 3049 */ 3050 3051 static int 3052 iscsit_sna_lt(uint32_t sn1, uint32_t sn2) 3053 { 3054 return ((sn1 != sn2) && 3055 (((sn1 < sn2) && ((sn2 - sn1) < ISCSIT_SNA32_CHECK)) || 3056 ((sn1 > sn2) && ((sn1 - sn2) > ISCSIT_SNA32_CHECK)))); 3057 } 3058 3059 static int 3060 iscsit_sna_lte(uint32_t sn1, uint32_t sn2) 3061 { 3062 return ((sn1 == sn2) || 3063 (((sn1 < sn2) && ((sn2 - sn1) < ISCSIT_SNA32_CHECK)) || 3064 ((sn1 > sn2) && ((sn1 - sn2) > ISCSIT_SNA32_CHECK)))); 3065 } 3066 3067 3068 static boolean_t 3069 iscsit_cmdsn_in_window(iscsit_conn_t *ict, uint32_t cmdsn) 3070 { 3071 iscsit_sess_t *ist = ict->ict_sess; 3072 int rval = B_TRUE; 3073 3074 ist = ict->ict_sess; 3075 3076 mutex_enter(&ist->ist_sn_mutex); 3077 3078 /* 3079 * If cmdsn is less than ist_expcmdsn - iscsit_cmd_window() or 3080 * greater than ist_expcmdsn, it's not in the window. 3081 */ 3082 3083 if (iscsit_sna_lt(cmdsn, (ist->ist_expcmdsn - iscsit_cmd_window())) || 3084 !iscsit_sna_lte(cmdsn, ist->ist_expcmdsn)) { 3085 rval = B_FALSE; 3086 } 3087 3088 mutex_exit(&ist->ist_sn_mutex); 3089 3090 return (rval); 3091 } 3092 3093 /* 3094 * iscsit_check_cmdsn_and_queue 3095 * 3096 * Independent of the order in which the iSCSI target receives non-immediate 3097 * command PDU across the entire session and any multiple connections within 3098 * the session, the target must deliver the commands to the SCSI layer in 3099 * CmdSN order. So out-of-order non-immediate commands are queued up on a 3100 * session-wide wait queue. Duplicate commands are ignored. 3101 * 3102 */ 3103 static int 3104 iscsit_check_cmdsn_and_queue(idm_pdu_t *rx_pdu) 3105 { 3106 idm_conn_t *ic = rx_pdu->isp_ic; 3107 iscsit_conn_t *ict = ic->ic_handle; 3108 iscsit_sess_t *ist = ict->ict_sess; 3109 iscsi_scsi_cmd_hdr_t *hdr = (iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr; 3110 3111 mutex_enter(&ist->ist_sn_mutex); 3112 if (hdr->opcode & ISCSI_OP_IMMEDIATE) { 3113 /* do not queue, handle it immediately */ 3114 DTRACE_PROBE2(immediate__cmd, iscsit_sess_t *, ist, 3115 idm_pdu_t *, rx_pdu); 3116 mutex_exit(&ist->ist_sn_mutex); 3117 return (ISCSIT_CMDSN_EQ_EXPCMDSN); 3118 } 3119 if (iscsit_sna_lt(ist->ist_expcmdsn, ntohl(hdr->cmdsn))) { 3120 /* 3121 * Out-of-order commands (cmdSN higher than ExpCmdSN) 3122 * are staged on a fixed-size circular buffer until 3123 * the missing command is delivered to the SCSI layer. 3124 * Irrespective of the order of insertion into the 3125 * staging queue, the commands are processed out of the 3126 * queue in cmdSN order only. 3127 */ 3128 rx_pdu->isp_queue_time = gethrtime(); 3129 iscsit_add_pdu_to_queue(ist, rx_pdu); 3130 mutex_exit(&ist->ist_sn_mutex); 3131 return (ISCSIT_CMDSN_GT_EXPCMDSN); 3132 } else if (iscsit_sna_lt(ntohl(hdr->cmdsn), ist->ist_expcmdsn)) { 3133 DTRACE_PROBE3(cmdsn__lt__expcmdsn, iscsit_sess_t *, ist, 3134 iscsit_conn_t *, ict, idm_pdu_t *, rx_pdu); 3135 mutex_exit(&ist->ist_sn_mutex); 3136 return (ISCSIT_CMDSN_LT_EXPCMDSN); 3137 } else { 3138 mutex_exit(&ist->ist_sn_mutex); 3139 return (ISCSIT_CMDSN_EQ_EXPCMDSN); 3140 } 3141 } 3142 3143 /* 3144 * iscsit_add_pdu_to_queue() adds PDUs into the array indexed by 3145 * their cmdsn value. The length of the array is kept above the 3146 * maximum window size. The window keeps the cmdsn within a range 3147 * such that there are no collisons. e.g. the assumption is that 3148 * the windowing checks make it impossible to receive PDUs that 3149 * index into the same location in the array. 3150 */ 3151 static void 3152 iscsit_add_pdu_to_queue(iscsit_sess_t *ist, idm_pdu_t *rx_pdu) 3153 { 3154 iscsit_cbuf_t *cbuf = ist->ist_rxpdu_queue; 3155 iscsit_conn_t *ict = rx_pdu->isp_ic->ic_handle; 3156 uint32_t cmdsn = 3157 ((iscsi_scsi_cmd_hdr_t *)rx_pdu->isp_hdr)->cmdsn; 3158 uint32_t index; 3159 3160 ASSERT(MUTEX_HELD(&ist->ist_sn_mutex)); 3161 /* 3162 * If the connection is being torn down, then 3163 * don't add the PDU to the staging queue 3164 */ 3165 mutex_enter(&ict->ict_mutex); 3166 if (ict->ict_lost) { 3167 mutex_exit(&ict->ict_mutex); 3168 idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL); 3169 return; 3170 } 3171 iscsit_conn_dispatch_hold(ict); 3172 mutex_exit(&ict->ict_mutex); 3173 3174 index = ntohl(cmdsn) % ISCSIT_RXPDU_QUEUE_LEN; 3175 /* 3176 * In the normal case, assuming that the Initiator is not 3177 * buggy and that we don't have packet duplication occuring, 3178 * the entry in the array will be NULL. However, we may have 3179 * received a duplicate PDU with cmdsn > expsn , and in that 3180 * case we just ignore this PDU -- the previously received one 3181 * remains queued for processing. We need to be careful not 3182 * to leak this one however. 3183 */ 3184 if (cbuf->cb_buffer[index] != NULL) { 3185 idm_pdu_complete(rx_pdu, IDM_STATUS_FAIL); 3186 } else { 3187 cbuf->cb_buffer[index] = rx_pdu; 3188 cbuf->cb_num_elems++; 3189 } 3190 } 3191 3192 static idm_pdu_t * 3193 iscsit_remove_pdu_from_queue(iscsit_sess_t *ist, uint32_t cmdsn) 3194 { 3195 iscsit_cbuf_t *cbuf = ist->ist_rxpdu_queue; 3196 idm_pdu_t *pdu = NULL; 3197 uint32_t index; 3198 3199 ASSERT(MUTEX_HELD(&ist->ist_sn_mutex)); 3200 index = cmdsn % ISCSIT_RXPDU_QUEUE_LEN; 3201 if ((pdu = cbuf->cb_buffer[index]) != NULL) { 3202 ASSERT(cmdsn == 3203 ntohl(((iscsi_scsi_cmd_hdr_t *)pdu->isp_hdr)->cmdsn)); 3204 cbuf->cb_buffer[index] = NULL; 3205 cbuf->cb_num_elems--; 3206 return (pdu); 3207 } 3208 return (NULL); 3209 } 3210 3211 /* 3212 * iscsit_process_pdu_in_queue() finds the next pdu in sequence 3213 * and posts it to the SCSI layer 3214 */ 3215 static void 3216 iscsit_process_pdu_in_queue(iscsit_sess_t *ist) 3217 { 3218 iscsit_cbuf_t *cbuf = ist->ist_rxpdu_queue; 3219 idm_pdu_t *pdu = NULL; 3220 uint32_t expcmdsn; 3221 3222 for (;;) { 3223 mutex_enter(&ist->ist_sn_mutex); 3224 if (cbuf->cb_num_elems == 0) { 3225 mutex_exit(&ist->ist_sn_mutex); 3226 break; 3227 } 3228 expcmdsn = ist->ist_expcmdsn; 3229 if ((pdu = iscsit_remove_pdu_from_queue(ist, expcmdsn)) 3230 == NULL) { 3231 mutex_exit(&ist->ist_sn_mutex); 3232 break; 3233 } 3234 mutex_exit(&ist->ist_sn_mutex); 3235 iscsit_post_staged_pdu(pdu); 3236 } 3237 } 3238 3239 static void 3240 iscsit_post_staged_pdu(idm_pdu_t *rx_pdu) 3241 { 3242 iscsit_conn_t *ict = rx_pdu->isp_ic->ic_handle; 3243 3244 /* Post the PDU to the SCSI layer */ 3245 switch (IDM_PDU_OPCODE(rx_pdu)) { 3246 case ISCSI_OP_NOOP_OUT: 3247 iscsit_set_cmdsn(ict, rx_pdu); 3248 iscsit_pdu_op_noop(ict, rx_pdu); 3249 break; 3250 case ISCSI_OP_TEXT_CMD: 3251 iscsit_set_cmdsn(ict, rx_pdu); 3252 iscsit_pdu_op_text_cmd(ict, rx_pdu); 3253 break; 3254 case ISCSI_OP_SCSI_TASK_MGT_MSG: 3255 iscsit_set_cmdsn(ict, rx_pdu); 3256 iscsit_op_scsi_task_mgmt(ict, rx_pdu); 3257 break; 3258 case ISCSI_OP_SCSI_CMD: 3259 /* cmdSN will be incremented after creating itask */ 3260 iscsit_post_scsi_cmd(rx_pdu->isp_ic, rx_pdu); 3261 break; 3262 case ISCSI_OP_LOGOUT_CMD: 3263 iscsit_set_cmdsn(ict, rx_pdu); 3264 iscsit_pdu_op_logout_cmd(ict, rx_pdu); 3265 break; 3266 default: 3267 /* No other PDUs should be placed on the queue */ 3268 ASSERT(0); 3269 } 3270 iscsit_conn_dispatch_rele(ict); /* release hold on the conn */ 3271 } 3272 3273 /* ARGSUSED */ 3274 void 3275 iscsit_rxpdu_queue_monitor_start(void) 3276 { 3277 mutex_enter(&iscsit_rxpdu_queue_monitor_mutex); 3278 if (iscsit_rxpdu_queue_monitor_thr_running) { 3279 mutex_exit(&iscsit_rxpdu_queue_monitor_mutex); 3280 return; 3281 } 3282 iscsit_rxpdu_queue_monitor_thr_id = 3283 thread_create(NULL, 0, iscsit_rxpdu_queue_monitor, NULL, 3284 0, &p0, TS_RUN, minclsyspri); 3285 while (!iscsit_rxpdu_queue_monitor_thr_running) { 3286 cv_wait(&iscsit_rxpdu_queue_monitor_cv, 3287 &iscsit_rxpdu_queue_monitor_mutex); 3288 } 3289 mutex_exit(&iscsit_rxpdu_queue_monitor_mutex); 3290 3291 } 3292 3293 /* ARGSUSED */ 3294 void 3295 iscsit_rxpdu_queue_monitor_stop(void) 3296 { 3297 mutex_enter(&iscsit_rxpdu_queue_monitor_mutex); 3298 if (iscsit_rxpdu_queue_monitor_thr_running) { 3299 iscsit_rxpdu_queue_monitor_thr_running = B_FALSE; 3300 cv_signal(&iscsit_rxpdu_queue_monitor_cv); 3301 mutex_exit(&iscsit_rxpdu_queue_monitor_mutex); 3302 3303 thread_join(iscsit_rxpdu_queue_monitor_thr_did); 3304 return; 3305 } 3306 mutex_exit(&iscsit_rxpdu_queue_monitor_mutex); 3307 } 3308 3309 /* 3310 * A separate thread is used to scan the staging queue on all the 3311 * sessions, If a delayed PDU does not arrive within a timeout, the 3312 * target will advance to the staged PDU that is next in sequence 3313 * and exceeded the threshold wait time. It is up to the initiator 3314 * to note that the target has not acknowledged a particular cmdsn 3315 * and take appropriate action. 3316 */ 3317 /* ARGSUSED */ 3318 static void 3319 iscsit_rxpdu_queue_monitor(void *arg) 3320 { 3321 iscsit_tgt_t *tgt; 3322 iscsit_sess_t *ist; 3323 3324 mutex_enter(&iscsit_rxpdu_queue_monitor_mutex); 3325 iscsit_rxpdu_queue_monitor_thr_did = curthread->t_did; 3326 iscsit_rxpdu_queue_monitor_thr_running = B_TRUE; 3327 cv_signal(&iscsit_rxpdu_queue_monitor_cv); 3328 3329 while (iscsit_rxpdu_queue_monitor_thr_running) { 3330 ISCSIT_GLOBAL_LOCK(RW_READER); 3331 for (tgt = avl_first(&iscsit_global.global_target_list); 3332 tgt != NULL; 3333 tgt = AVL_NEXT(&iscsit_global.global_target_list, tgt)) { 3334 mutex_enter(&tgt->target_mutex); 3335 for (ist = avl_first(&tgt->target_sess_list); 3336 ist != NULL; 3337 ist = AVL_NEXT(&tgt->target_sess_list, ist)) { 3338 3339 iscsit_rxpdu_queue_monitor_session(ist); 3340 } 3341 mutex_exit(&tgt->target_mutex); 3342 } 3343 ISCSIT_GLOBAL_UNLOCK(); 3344 if (iscsit_rxpdu_queue_monitor_thr_running == B_FALSE) { 3345 break; 3346 } 3347 (void) cv_reltimedwait(&iscsit_rxpdu_queue_monitor_cv, 3348 &iscsit_rxpdu_queue_monitor_mutex, 3349 drv_sectohz(ISCSIT_RXPDU_QUEUE_MONITOR_INTERVAL), 3350 TR_CLOCK_TICK); 3351 } 3352 mutex_exit(&iscsit_rxpdu_queue_monitor_mutex); 3353 thread_exit(); 3354 } 3355 3356 static void 3357 iscsit_rxpdu_queue_monitor_session(iscsit_sess_t *ist) 3358 { 3359 iscsit_cbuf_t *cbuf = ist->ist_rxpdu_queue; 3360 idm_pdu_t *next_pdu = NULL; 3361 uint32_t index, next_cmdsn, i; 3362 3363 /* 3364 * Assume that all PDUs in the staging queue have a cmdsn >= expcmdsn. 3365 * Starting with the expcmdsn, iterate over the staged PDUs to find 3366 * the next PDU with a wait time greater than the threshold. If found 3367 * advance the staged PDU to the SCSI layer, skipping over the missing 3368 * PDU(s) to get past the hole in the command sequence. It is up to 3369 * the initiator to note that the target has not acknowledged a cmdsn 3370 * and take appropriate action. 3371 * 3372 * Since the PDU(s) arrive in any random order, it is possible that 3373 * that the actual wait time for a particular PDU is much longer than 3374 * the defined threshold. e.g. Consider a case where commands are sent 3375 * over 4 different connections, and cmdsn = 1004 arrives first, then 3376 * 1003, and 1002 and 1001 are lost due to a connection failure. 3377 * So now 1003 is waiting for 1002 to be delivered, and although the 3378 * wait time of 1004 > wait time of 1003, only 1003 will be considered 3379 * by the monitor thread. 1004 will be automatically processed by 3380 * iscsit_process_pdu_in_queue() once the scan is complete and the 3381 * expcmdsn becomes current. 3382 */ 3383 mutex_enter(&ist->ist_sn_mutex); 3384 cbuf = ist->ist_rxpdu_queue; 3385 if (cbuf->cb_num_elems == 0) { 3386 mutex_exit(&ist->ist_sn_mutex); 3387 return; 3388 } 3389 for (next_pdu = NULL, i = 0; ; i++) { 3390 next_cmdsn = ist->ist_expcmdsn + i; /* start at expcmdsn */ 3391 index = next_cmdsn % ISCSIT_RXPDU_QUEUE_LEN; 3392 if ((next_pdu = cbuf->cb_buffer[index]) != NULL) { 3393 /* 3394 * If the PDU wait time has not exceeded threshold 3395 * stop scanning the staging queue until the timer 3396 * fires again 3397 */ 3398 if ((gethrtime() - next_pdu->isp_queue_time) 3399 < (rxpdu_queue_threshold * NANOSEC)) { 3400 mutex_exit(&ist->ist_sn_mutex); 3401 return; 3402 } 3403 /* 3404 * Remove the next PDU from the queue and post it 3405 * to the SCSI layer, skipping over the missing 3406 * PDU. Stop scanning the staging queue until 3407 * the monitor timer fires again 3408 */ 3409 (void) iscsit_remove_pdu_from_queue(ist, next_cmdsn); 3410 mutex_exit(&ist->ist_sn_mutex); 3411 DTRACE_PROBE3(advanced__to__blocked__cmdsn, 3412 iscsit_sess_t *, ist, idm_pdu_t *, next_pdu, 3413 uint32_t, next_cmdsn); 3414 iscsit_post_staged_pdu(next_pdu); 3415 /* Deliver any subsequent PDUs immediately */ 3416 iscsit_process_pdu_in_queue(ist); 3417 return; 3418 } 3419 /* 3420 * Skipping over i PDUs, e.g. a case where commands 1001 and 3421 * 1002 are lost in the network, skip over both and post 1003 3422 * expcmdsn then becomes 1004 at the end of the scan. 3423 */ 3424 DTRACE_PROBE2(skipping__over__cmdsn, iscsit_sess_t *, ist, 3425 uint32_t, next_cmdsn); 3426 } 3427 /* 3428 * following the assumption, staged cmdsn >= expcmdsn, this statement 3429 * is never reached. 3430 */ 3431 }