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