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 2000 by Cisco Systems, Inc. All rights reserved. 23 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 24 * 25 * iSCSI Software Initiator 26 */ 27 28 /* 29 * Framework interface routines for iSCSI 30 */ 31 32 #include "iscsi.h" /* main header */ 33 #include <sys/iscsi_protocol.h> /* protocol structs */ 34 #include <sys/scsi/adapters/iscsi_if.h> /* ioctl interfaces */ 35 #include "iscsi_targetparam.h" 36 #include "persistent.h" 37 #include <sys/scsi/adapters/iscsi_door.h> 38 #include <sys/dlpi.h> 39 #include <sys/utsname.h> 40 #include "isns_client.h" 41 #include "isns_protocol.h" 42 #include <sys/bootprops.h> 43 #include <sys/types.h> 44 #include <sys/bootconf.h> 45 46 #define ISCSI_NAME_VERSION "iSCSI Initiator v-1.55" 47 48 #define MAX_GET_NAME_SIZE 1024 49 #define MAX_NAME_PROP_SIZE 256 50 #define UNDEFINED -1 51 #define ISCSI_DISC_DELAY 2 /* seconds */ 52 53 /* 54 * +--------------------------------------------------------------------+ 55 * | iscsi globals | 56 * +--------------------------------------------------------------------+ 57 */ 58 void *iscsi_state; 59 kmutex_t iscsi_oid_mutex; 60 uint32_t iscsi_oid; 61 int iscsi_nop_delay = ISCSI_DEFAULT_NOP_DELAY; 62 int iscsi_rx_window = ISCSI_DEFAULT_RX_WINDOW; 63 int iscsi_rx_max_window = ISCSI_DEFAULT_RX_MAX_WINDOW; 64 boolean_t iscsi_logging = B_FALSE; 65 66 extern ib_boot_prop_t *iscsiboot_prop; 67 extern int modrootloaded; 68 extern struct bootobj rootfs; 69 70 /* 71 * +--------------------------------------------------------------------+ 72 * | iscsi.c prototypes | 73 * +--------------------------------------------------------------------+ 74 */ 75 static int iscsi_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, 76 void *arg, void **result); 77 static int iscsi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd); 78 static int iscsi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd); 79 80 /* scsi_tran prototypes */ 81 static int iscsi_tran_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip, 82 scsi_hba_tran_t *hba_tran, struct scsi_device *sd); 83 static int iscsi_tran_lun_probe(struct scsi_device *sd, int (*callback) ()); 84 static struct scsi_pkt *iscsi_tran_init_pkt(struct scsi_address *ap, 85 struct scsi_pkt *pkt, struct buf *bp, int cmdlen, int statuslen, 86 int tgtlen, int flags, int (*callback) (), caddr_t arg); 87 static void iscsi_tran_lun_free(dev_info_t *hba_dip, dev_info_t *lun_dip, 88 scsi_hba_tran_t *hba_tran, struct scsi_device *sd); 89 static int iscsi_tran_start(struct scsi_address *ap, struct scsi_pkt *pkt); 90 static int iscsi_tran_abort(struct scsi_address *ap, struct scsi_pkt *pkt); 91 static int iscsi_tran_reset(struct scsi_address *ap, int level); 92 static int iscsi_tran_getcap(struct scsi_address *ap, char *cap, int whom); 93 static int iscsi_tran_setcap(struct scsi_address *ap, char *cap, 94 int value, int whom); 95 static void iscsi_tran_destroy_pkt(struct scsi_address *ap, 96 struct scsi_pkt *pkt); 97 static void iscsi_tran_dmafree(struct scsi_address *ap, 98 struct scsi_pkt *pkt); 99 static void iscsi_tran_sync_pkt(struct scsi_address *ap, 100 struct scsi_pkt *pkt); 101 static void iscsi_tran_sync_pkt(struct scsi_address *ap, 102 struct scsi_pkt *pkt); 103 static int iscsi_tran_reset_notify(struct scsi_address *ap, int flag, 104 void (*callback) (caddr_t), caddr_t arg); 105 static int iscsi_tran_bus_config(dev_info_t *parent, uint_t flags, 106 ddi_bus_config_op_t op, void *arg, dev_info_t **childp); 107 static int iscsi_tran_bus_unconfig(dev_info_t *parent, uint_t flags, 108 ddi_bus_config_op_t op, void *arg); 109 static int iscsi_tran_get_name(struct scsi_device *sd, char *name, int len); 110 static int iscsi_tran_get_bus_addr(struct scsi_device *sd, char *name, int len); 111 112 /* bus_ops prototypes */ 113 /* LINTED E_STATIC_UNUSED */ 114 static ddi_intrspec_t iscsi_get_intrspec(dev_info_t *dip, dev_info_t *rdip, 115 uint_t inumber); 116 /* LINTED E_STATIC_UNUSED */ 117 static int iscsi_add_intrspec(dev_info_t *dip, dev_info_t *rdip, 118 ddi_intrspec_t intrspec, ddi_iblock_cookie_t *iblock_cookiep, 119 ddi_idevice_cookie_t *idevice_cookiep, uint_t (*int_handler)(caddr_t 120 int_handler_arg), caddr_t int_handler_arg, int kind); 121 /* LINTED E_STATIC_UNUSED */ 122 static void iscsi_remove_intrspec(dev_info_t *dip, dev_info_t *rdip, 123 ddi_intrspec_t intrspec, ddi_iblock_cookie_t iblock_cookie); 124 /* LINTED E_STATIC_UNUSED */ 125 static int iscsi_ctl(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t ctlop, 126 void *arg, void *result); 127 128 /* cb_ops prototypes */ 129 static int iscsi_open(dev_t *devp, int flags, int otyp, cred_t *credp); 130 static int iscsi_close(dev_t dev, int flag, int otyp, cred_t *credp); 131 static int iscsi_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, 132 cred_t *credp, int *rvalp); 133 134 int iscsi_get_persisted_param(uchar_t *name, 135 iscsi_param_get_t *ipgp, 136 iscsi_login_params_t *params); 137 static void iscsi_override_target_default(iscsi_hba_t *ihp, 138 iscsi_param_get_t *ipg); 139 140 /* scsi_tran helpers */ 141 static int iscsi_virt_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip, 142 scsi_hba_tran_t *hba_tran, struct scsi_device *sd); 143 static int iscsi_phys_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip, 144 scsi_hba_tran_t *hba_tran, struct scsi_device *sd); 145 static int iscsi_i_commoncap(struct scsi_address *ap, char *cap, 146 int val, int lunonly, int doset); 147 static void iscsi_get_name_to_iqn(char *name, int name_max_len); 148 static void iscsi_get_name_from_iqn(char *name, int name_max_len); 149 static boolean_t iscsi_cmp_boot_sess_oid(iscsi_hba_t *ihp, uint32_t oid); 150 151 /* iscsi initiator service helpers */ 152 static boolean_t iscsi_enter_service_zone(iscsi_hba_t *ihp, uint32_t status); 153 static void iscsi_exit_service_zone(iscsi_hba_t *ihp, uint32_t status); 154 static void iscsi_check_miniroot(iscsi_hba_t *ihp); 155 static void iscsi_get_tunable_default(iscsi_tunable_object_t *param); 156 static int iscsi_get_persisted_tunable_param(uchar_t *name, 157 iscsi_tunable_object_t *tpsg); 158 static void iscsi_set_default_tunable_params(iscsi_tunable_params_t *params); 159 160 /* struct helpers prototypes */ 161 162 /* 163 * At this point this driver doesn't need this structure because nothing 164 * is done during the open, close or ioctl. Code put in place because 165 * some admin related work might be done in the ioctl routine. 166 */ 167 static struct cb_ops iscsi_cb_ops = { 168 iscsi_open, /* open */ 169 iscsi_close, /* close */ 170 nodev, /* strategy */ 171 nodev, /* print */ 172 nodev, /* dump */ 173 nodev, /* read */ 174 nodev, /* write */ 175 iscsi_ioctl, /* ioctl */ 176 nodev, /* devmap */ 177 nodev, /* mmap */ 178 nodev, /* segmap */ 179 nochpoll, /* poll */ 180 ddi_prop_op, /* prop_op */ 181 NULL, /* streamtab */ 182 D_NEW | D_MP | D_HOTPLUG, /* flags */ 183 CB_REV, /* cb_rev */ 184 nodev, /* aread */ 185 nodev, /* awrite */ 186 }; 187 188 static struct dev_ops iscsi_dev_ops = { 189 DEVO_REV, /* devo_rev */ 190 0, /* refcnt */ 191 iscsi_getinfo, /* getinfo */ 192 nulldev, /* identify */ 193 nulldev, /* probe */ 194 iscsi_attach, /* attach */ 195 iscsi_detach, /* detach */ 196 nodev, /* reset */ 197 &iscsi_cb_ops, /* driver operations */ 198 NULL, /* bus ops */ 199 NULL, /* power management */ 200 ddi_quiesce_not_needed, /* quiesce */ 201 }; 202 203 static struct modldrv modldrv = { 204 &mod_driverops, /* drv_modops */ 205 ISCSI_NAME_VERSION, /* drv_linkinfo */ 206 &iscsi_dev_ops /* drv_dev_ops */ 207 }; 208 209 static struct modlinkage modlinkage = { 210 MODREV_1, /* ml_rev */ 211 &modldrv, /* ml_linkage[] */ 212 NULL /* NULL termination */ 213 }; 214 215 /* 216 * This structure is bogus. scsi_hba_attach_setup() requires, as in the kernel 217 * will panic if you don't pass this in to the routine, this information. 218 * Need to determine what the actual impact to the system is by providing 219 * this information if any. Since dma allocation is done in pkt_init it may 220 * not have any impact. These values are straight from the Writing Device 221 * Driver manual. 222 */ 223 static ddi_dma_attr_t iscsi_dma_attr = { 224 DMA_ATTR_V0, /* ddi_dma_attr version */ 225 0, /* low address */ 226 0xffffffff, /* high address */ 227 0x00ffffff, /* counter upper bound */ 228 1, /* alignment requirements */ 229 0x3f, /* burst sizes */ 230 1, /* minimum DMA access */ 231 0xffffffff, /* maximum DMA access */ 232 (1 << 24) - 1, /* segment boundary restrictions */ 233 1, /* scater/gather list length */ 234 512, /* device granularity */ 235 0 /* DMA flags */ 236 }; 237 238 /* 239 * _init - General driver init entry 240 */ 241 int 242 _init(void) 243 { 244 int rval = 0; 245 246 iscsi_net_init(); 247 248 mutex_init(&iscsi_oid_mutex, NULL, MUTEX_DRIVER, NULL); 249 iscsi_oid = ISCSI_INITIATOR_OID; 250 251 /* 252 * Set up the soft state structures. If this driver is actually 253 * being attached to the system then we'll have at least one 254 * HBA/NIC used. 255 */ 256 rval = ddi_soft_state_init(&iscsi_state, 257 sizeof (iscsi_hba_t), 1); 258 if (rval != 0) { 259 iscsi_net_fini(); 260 goto init_done; 261 } 262 263 rval = scsi_hba_init(&modlinkage); 264 if (rval != 0) { 265 ddi_soft_state_fini(&iscsi_state); 266 iscsi_net_fini(); 267 goto init_done; 268 } 269 270 rval = mod_install(&modlinkage); 271 if (rval != 0) { 272 ddi_soft_state_fini(&iscsi_state); 273 scsi_hba_fini(&modlinkage); 274 iscsi_net_fini(); 275 goto init_done; 276 } 277 (void) iscsi_door_ini(); 278 279 init_done: 280 return (rval); 281 } 282 283 /* 284 * _fini - General driver destructor entry 285 */ 286 int 287 _fini(void) 288 { 289 int rval = 0; 290 291 rval = mod_remove(&modlinkage); 292 if (rval == 0) { 293 scsi_hba_fini(&modlinkage); 294 ddi_soft_state_fini(&iscsi_state); 295 mutex_destroy(&iscsi_oid_mutex); 296 (void) iscsi_door_term(); 297 iscsi_net_fini(); 298 } 299 return (rval); 300 } 301 302 /* 303 * _info - General driver info entry 304 */ 305 int 306 _info(struct modinfo *mp) 307 { 308 int rval = 0; 309 310 rval = mod_info(&modlinkage, mp); 311 312 return (rval); 313 } 314 315 316 /* 317 * +--------------------------------------------------------------------+ 318 * | Start of dev_ops routines | 319 * +--------------------------------------------------------------------+ 320 */ 321 322 /* 323 * iscsi_getinfo - returns general driver information 324 */ 325 /* ARGSUSED */ 326 static int 327 iscsi_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, 328 void *arg, void **result) 329 { 330 int rval = DDI_SUCCESS; 331 int instance = getminor((dev_t)arg); 332 iscsi_hba_t *ip; 333 334 switch (infocmd) { 335 case DDI_INFO_DEVT2DEVINFO: 336 if ((ip = ddi_get_soft_state(iscsi_state, instance)) == NULL) { 337 return (DDI_FAILURE); 338 } 339 *result = ip->hba_dip; 340 if (ip->hba_dip == NULL) 341 rval = DDI_FAILURE; 342 else 343 rval = DDI_SUCCESS; 344 break; 345 346 case DDI_INFO_DEVT2INSTANCE: 347 *result = (void *)(uintptr_t)instance; 348 rval = DDI_SUCCESS; 349 break; 350 351 default: 352 rval = DDI_FAILURE; 353 break; 354 } 355 return (rval); 356 } 357 358 359 /* 360 * iscsi_attach -- Attach instance of an iSCSI HBA. We 361 * will attempt to create our HBA and register it with 362 * scsi_vhci. If it's not possible to create the HBA 363 * or register with vhci we will fail the attach. 364 */ 365 static int 366 iscsi_attach(dev_info_t *dip, ddi_attach_cmd_t cmd) 367 { 368 int rval = DDI_SUCCESS; 369 int instance = ddi_get_instance(dip); 370 iscsi_hba_t *ihp = NULL; 371 scsi_hba_tran_t *tran = NULL; 372 char init_port_name[MAX_NAME_PROP_SIZE]; 373 374 switch (cmd) { 375 case DDI_ATTACH: 376 /* create iSCSH HBA devctl device node */ 377 if (ddi_create_minor_node(dip, ISCSI_DEVCTL, S_IFCHR, 0, 378 DDI_PSEUDO, 0) == DDI_SUCCESS) { 379 380 /* allocate HBA soft state */ 381 if (ddi_soft_state_zalloc(iscsi_state, instance) != 382 DDI_SUCCESS) { 383 ddi_remove_minor_node(dip, NULL); 384 rval = DDI_FAILURE; 385 break; 386 } 387 388 /* get reference to soft state */ 389 if ((ihp = (iscsi_hba_t *)ddi_get_soft_state( 390 iscsi_state, instance)) == NULL) { 391 ddi_remove_minor_node(dip, NULL); 392 ddi_soft_state_free(iscsi_state, instance); 393 rval = DDI_FAILURE; 394 break; 395 } 396 397 /* init HBA mutex used to protect discovery events */ 398 mutex_init(&ihp->hba_discovery_events_mutex, NULL, 399 MUTEX_DRIVER, NULL); 400 401 /* Get LDI ident */ 402 rval = ldi_ident_from_dip(dip, &ihp->hba_li); 403 ASSERT(rval == 0); /* Failure indicates invalid arg */ 404 405 /* init HBA mutex used to protect service status */ 406 mutex_init(&ihp->hba_service_lock, NULL, 407 MUTEX_DRIVER, NULL); 408 cv_init(&ihp->hba_service_cv, NULL, CV_DRIVER, NULL); 409 410 /* 411 * init SendTargets semaphore that is used to allow 412 * only one operation at a time 413 */ 414 sema_init(&ihp->hba_sendtgts_semaphore, 1, NULL, 415 SEMA_DRIVER, NULL); 416 417 ihp->hba_sess_list = NULL; 418 rw_init(&ihp->hba_sess_list_rwlock, NULL, 419 RW_DRIVER, NULL); 420 421 /* allocate scsi_hba_tran */ 422 if ((tran = scsi_hba_tran_alloc(dip, SCSI_HBA_CANSLEEP)) 423 == NULL) { 424 ddi_remove_minor_node(dip, NULL); 425 goto iscsi_attach_failed2; 426 } 427 428 /* soft state setup */ 429 ihp->hba_sig = ISCSI_SIG_HBA; 430 ihp->hba_tran = tran; 431 ihp->hba_dip = dip; 432 if (iscsiboot_prop == NULL) { 433 ihp->hba_service_status = 434 ISCSI_SERVICE_DISABLED; 435 ihp->hba_service_status_overwrite = B_FALSE; 436 } else { 437 ihp->hba_service_status = 438 ISCSI_SERVICE_ENABLED; 439 ihp->hba_service_status_overwrite = B_TRUE; 440 } 441 ihp->hba_service_client_count = 0; 442 443 mutex_enter(&iscsi_oid_mutex); 444 ihp->hba_oid = iscsi_oid++; 445 mutex_exit(&iscsi_oid_mutex); 446 447 ihp->hba_name[0] = '\0'; 448 ihp->hba_name_length = 0; 449 ihp->hba_alias_length = 0; 450 ihp->hba_alias[0] = '\0'; 451 452 iscsi_net->tweaks.rcvbuf = ddi_prop_get_int( 453 DDI_DEV_T_ANY, ihp->hba_dip, 0, "so-rcvbuf", 454 ISCSI_SOCKET_RCVBUF_SIZE); 455 456 iscsi_net->tweaks.sndbuf = ddi_prop_get_int( 457 DDI_DEV_T_ANY, ihp->hba_dip, 0, "so-sndbuf", 458 ISCSI_SOCKET_SNDBUF_SIZE); 459 460 iscsi_net->tweaks.nodelay = ddi_prop_get_int( 461 DDI_DEV_T_ANY, ihp->hba_dip, 0, "tcp-nodelay", 462 ISCSI_TCP_NODELAY_DEFAULT); 463 464 iscsi_net->tweaks.conn_notify_threshold = 465 ddi_prop_get_int(DDI_DEV_T_ANY, 466 ihp->hba_dip, 0, "tcp-conn-notify-threshold", 467 ISCSI_TCP_CNOTIFY_THRESHOLD_DEFAULT); 468 469 iscsi_net->tweaks.conn_abort_threshold = 470 ddi_prop_get_int(DDI_DEV_T_ANY, ihp->hba_dip, 471 0, "tcp-conn-abort-threshold", 472 ISCSI_TCP_CABORT_THRESHOLD_DEFAULT); 473 474 iscsi_net->tweaks.abort_threshold = ddi_prop_get_int( 475 DDI_DEV_T_ANY, ihp->hba_dip, 0, 476 "tcp-abort-threshold", 477 ISCSI_TCP_ABORT_THRESHOLD_DEFAULT); 478 479 ihp->hba_config_storm_delay = ddi_prop_get_int( 480 DDI_DEV_T_ANY, ihp->hba_dip, 0, 481 "config-storm-delay", 482 ISCSI_CONFIG_STORM_DELAY_DEFAULT); 483 484 (void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip, 485 "so-rcvbuf", iscsi_net->tweaks.rcvbuf); 486 487 (void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip, 488 "so-sndbuf", iscsi_net->tweaks.sndbuf); 489 490 (void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip, 491 "tcp-nodelay", iscsi_net->tweaks.nodelay); 492 493 (void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip, 494 "tcp-conn-notify-threshold", 495 iscsi_net->tweaks.conn_notify_threshold); 496 497 (void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip, 498 "tcp-conn-abort-threshold", 499 iscsi_net->tweaks.conn_abort_threshold); 500 501 (void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip, 502 "tcp-abort-threshold", 503 iscsi_net->tweaks.abort_threshold); 504 505 (void) ddi_prop_update_int(DDI_DEV_T_NONE, ihp->hba_dip, 506 "config-storm-delay", 507 ihp->hba_config_storm_delay); 508 509 /* setup hba defaults */ 510 iscsi_set_default_login_params(&ihp->hba_params); 511 iscsi_set_default_tunable_params( 512 &ihp->hba_tunable_params); 513 514 /* setup minimal initiator params */ 515 iscsid_set_default_initiator_node_settings(ihp, B_TRUE); 516 517 /* hba set up */ 518 tran->tran_hba_private = ihp; 519 tran->tran_tgt_private = NULL; 520 tran->tran_tgt_init = iscsi_tran_lun_init; 521 tran->tran_tgt_probe = iscsi_tran_lun_probe; 522 tran->tran_tgt_free = iscsi_tran_lun_free; 523 tran->tran_start = iscsi_tran_start; 524 tran->tran_abort = iscsi_tran_abort; 525 tran->tran_reset = iscsi_tran_reset; 526 tran->tran_getcap = iscsi_tran_getcap; 527 tran->tran_setcap = iscsi_tran_setcap; 528 tran->tran_init_pkt = iscsi_tran_init_pkt; 529 tran->tran_destroy_pkt = iscsi_tran_destroy_pkt; 530 tran->tran_dmafree = iscsi_tran_dmafree; 531 tran->tran_sync_pkt = iscsi_tran_sync_pkt; 532 tran->tran_reset_notify = iscsi_tran_reset_notify; 533 tran->tran_bus_config = iscsi_tran_bus_config; 534 tran->tran_bus_unconfig = iscsi_tran_bus_unconfig; 535 536 tran->tran_get_name = iscsi_tran_get_name; 537 tran->tran_get_bus_addr = iscsi_tran_get_bus_addr; 538 tran->tran_interconnect_type = INTERCONNECT_ISCSI; 539 540 /* register scsi hba with scsa */ 541 if (scsi_hba_attach_setup(dip, &iscsi_dma_attr, 542 tran, SCSI_HBA_TRAN_CLONE) != DDI_SUCCESS) { 543 goto iscsi_attach_failed1; 544 } 545 546 /* register scsi hba with mdi (MPxIO/vhci) */ 547 if (mdi_phci_register(MDI_HCI_CLASS_SCSI, dip, 0) != 548 MDI_SUCCESS) { 549 ihp->hba_mpxio_enabled = B_FALSE; 550 } else { 551 ihp->hba_mpxio_enabled = B_TRUE; 552 } 553 554 (void) iscsi_hba_kstat_init(ihp); 555 556 /* Initialize targetparam list */ 557 iscsi_targetparam_init(); 558 559 /* Initialize ISID */ 560 ihp->hba_isid[0] = ISCSI_SUN_ISID_0; 561 ihp->hba_isid[1] = ISCSI_SUN_ISID_1; 562 ihp->hba_isid[2] = ISCSI_SUN_ISID_2; 563 ihp->hba_isid[3] = ISCSI_SUN_ISID_3; 564 ihp->hba_isid[4] = ISCSI_SUN_ISID_4; 565 ihp->hba_isid[5] = ISCSI_SUN_ISID_5; 566 567 /* Setup iSNS transport services and client */ 568 isns_client_init(); 569 570 /* 571 * initialize persistent store, 572 * or boot target info in case of iscsi boot 573 */ 574 ihp->hba_persistent_loaded = B_FALSE; 575 if (iscsid_init(ihp) == B_FALSE) { 576 goto iscsi_attach_failed0; 577 } 578 579 /* Setup init_port_name for MPAPI */ 580 (void) snprintf(init_port_name, MAX_NAME_PROP_SIZE, 581 "%s,%02x%02x%02x%02x%02x%02x", 582 (char *)ihp->hba_name, ihp->hba_isid[0], 583 ihp->hba_isid[1], ihp->hba_isid[2], 584 ihp->hba_isid[3], ihp->hba_isid[4], 585 ihp->hba_isid[5]); 586 587 if (ddi_prop_update_string(DDI_DEV_T_NONE, dip, 588 SCSI_ADDR_PROP_INITIATOR_PORT, init_port_name) != 589 DDI_PROP_SUCCESS) { 590 cmn_err(CE_WARN, "iscsi_attach: Creating " 591 SCSI_ADDR_PROP_INITIATOR_PORT 592 " property on iSCSI " 593 "HBA(%s) with dip(%d) Failed", 594 (char *)ihp->hba_name, 595 ddi_get_instance(dip)); 596 } 597 598 ddi_report_dev(dip); 599 } else { 600 rval = DDI_FAILURE; 601 } 602 break; 603 604 iscsi_attach_failed0: 605 isns_client_cleanup(); 606 if (ihp->stats.ks) { 607 (void) iscsi_hba_kstat_term(ihp); 608 } 609 if (ihp->hba_mpxio_enabled == B_TRUE) { 610 (void) mdi_phci_unregister(dip, 0); 611 } 612 (void) scsi_hba_detach(ihp->hba_dip); 613 iscsi_attach_failed1: 614 ddi_remove_minor_node(dip, NULL); 615 ddi_prop_remove_all(ihp->hba_dip); 616 scsi_hba_tran_free(tran); 617 iscsi_attach_failed2: 618 cv_destroy(&ihp->hba_service_cv); 619 mutex_destroy(&ihp->hba_service_lock); 620 mutex_destroy(&ihp->hba_discovery_events_mutex); 621 sema_destroy(&ihp->hba_sendtgts_semaphore); 622 rw_destroy(&ihp->hba_sess_list_rwlock); 623 ddi_soft_state_free(iscsi_state, instance); 624 rval = DDI_FAILURE; 625 break; 626 627 case DDI_RESUME: 628 break; 629 630 default: 631 rval = DDI_FAILURE; 632 } 633 634 if (rval != DDI_SUCCESS) { 635 cmn_err(CE_WARN, "iscsi driver unable to attach " 636 "hba instance %d", instance); 637 } 638 639 return (rval); 640 } 641 642 /* 643 * iscsi_detach - called on unload of hba instance 644 */ 645 static int 646 iscsi_detach(dev_info_t *dip, ddi_detach_cmd_t cmd) 647 { 648 int rval = DDI_SUCCESS; 649 scsi_hba_tran_t *tran = NULL; 650 iscsi_hba_t *ihp = NULL; 651 iscsi_hba_t *ihp_check = NULL; 652 int instance; 653 char *init_node_name; 654 655 instance = ddi_get_instance(dip); 656 657 switch (cmd) { 658 case DDI_DETACH: 659 if (!(tran = (scsi_hba_tran_t *)ddi_get_driver_private(dip))) { 660 rval = DDI_SUCCESS; 661 break; 662 } 663 664 if ((ihp = (iscsi_hba_t *)tran->tran_hba_private) == NULL) { 665 rval = DDI_FAILURE; 666 break; 667 } 668 669 /* 670 * Validate that what is stored by the DDI framework is still 671 * the same state structure referenced by the SCSI framework 672 */ 673 ihp_check = ddi_get_soft_state(iscsi_state, instance); 674 if (ihp_check != ihp) { 675 rval = DDI_FAILURE; 676 break; 677 } 678 679 /* If a session exists we can't safely detach */ 680 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 681 if (ihp->hba_sess_list != NULL) { 682 rw_exit(&ihp->hba_sess_list_rwlock); 683 rval = DDI_FAILURE; 684 break; 685 } 686 rw_exit(&ihp->hba_sess_list_rwlock); 687 688 /* Disable all discovery services */ 689 if (iscsid_disable_discovery(ihp, 690 ISCSI_ALL_DISCOVERY_METHODS) == B_FALSE) { 691 /* Disable failed. Fail detach */ 692 rval = DDI_FAILURE; 693 break; 694 } 695 696 /* Deregister from iSNS server(s). */ 697 init_node_name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP); 698 if (persistent_initiator_name_get(init_node_name, 699 ISCSI_MAX_NAME_LEN) == B_TRUE) { 700 if (strlen(init_node_name) > 0) { 701 (void) isns_dereg(ihp->hba_isid, 702 (uint8_t *)init_node_name); 703 } 704 } 705 kmem_free(init_node_name, ISCSI_MAX_NAME_LEN); 706 init_node_name = NULL; 707 708 /* Cleanup iSNS Client */ 709 isns_client_cleanup(); 710 711 iscsi_targetparam_cleanup(); 712 713 /* Cleanup iscsid resources */ 714 iscsid_fini(); 715 716 if (rval != DDI_SUCCESS) { 717 break; 718 } 719 /* kstat hba. destroy */ 720 KSTAT_DEC_HBA_CNTR_SESS(ihp); 721 722 if (ihp->hba_mpxio_enabled == B_TRUE) { 723 (void) mdi_phci_unregister(dip, 0); 724 } 725 ddi_remove_minor_node(dip, NULL); 726 727 ddi_prop_remove_all(ihp->hba_dip); 728 729 ldi_ident_release(ihp->hba_li); 730 731 cv_destroy(&ihp->hba_service_cv); 732 mutex_destroy(&ihp->hba_service_lock); 733 mutex_destroy(&ihp->hba_discovery_events_mutex); 734 rw_destroy(&ihp->hba_sess_list_rwlock); 735 (void) iscsi_hba_kstat_term(ihp); 736 737 (void) scsi_hba_detach(dip); 738 if (tran != NULL) { 739 scsi_hba_tran_free(tran); 740 } 741 ddi_soft_state_free(iscsi_state, instance); 742 break; 743 default: 744 break; 745 } 746 747 if (rval != DDI_SUCCESS) { 748 cmn_err(CE_WARN, "iscsi driver unable to " 749 "detach hba instance %d", instance); 750 } 751 752 return (rval); 753 } 754 755 /* 756 * +--------------------------------------------------------------------+ 757 * | End of dev_ops routines | 758 * +--------------------------------------------------------------------+ 759 */ 760 761 /* 762 * +--------------------------------------------------------------------+ 763 * | scsi_tran(9E) routines | 764 * +--------------------------------------------------------------------+ 765 */ 766 767 /* 768 * iscsi_tran_lun_init - Find target device based on SCSI device 769 * Based on the information given (SCSI device, target dev_info) find 770 * the target iSCSI device and put a pointer to that information in 771 * the scsi_hba_tran_t structure. 772 */ 773 static int 774 iscsi_tran_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip, 775 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 776 { 777 int rval = 0; 778 int type = 0; 779 780 ASSERT(hba_tran->tran_hba_private != NULL); 781 782 /* 783 * Child node is getting initialized. Look at the mpxio component 784 * type on the child device to see if this device is mpxio managed 785 * or not. 786 */ 787 type = mdi_get_component_type(lun_dip); 788 if (type != MDI_COMPONENT_CLIENT) { 789 rval = iscsi_phys_lun_init(hba_dip, lun_dip, hba_tran, sd); 790 } else { 791 rval = iscsi_virt_lun_init(hba_dip, lun_dip, hba_tran, sd); 792 } 793 794 return (rval); 795 } 796 797 /* 798 * iscsi_tran_lun_probe - This function didn't need to be implemented. 799 * We could have left NULL in the tran table. Since this isn't a 800 * performance path this seems safe. We are just wrappering the 801 * function so we can see the call go through if we have debugging 802 * enabled. 803 */ 804 static int 805 iscsi_tran_lun_probe(struct scsi_device *sd, int (*callback) ()) 806 { 807 int rval = 0; 808 809 rval = scsi_hba_probe(sd, callback); 810 811 return (rval); 812 } 813 814 /* 815 * iscsi_init_pkt - Allocate SCSI packet and fill in required info. 816 */ 817 /* ARGSUSED */ 818 static struct scsi_pkt * 819 iscsi_tran_init_pkt(struct scsi_address *ap, struct scsi_pkt *pkt, 820 struct buf *bp, int cmdlen, int statuslen, int tgtlen, int flags, 821 int (*callback) (), caddr_t arg) 822 { 823 iscsi_lun_t *ilp; 824 iscsi_cmd_t *icmdp; 825 826 ASSERT(ap != NULL); 827 ASSERT(callback == NULL_FUNC || callback == SLEEP_FUNC); 828 829 /* 830 * The software stack doesn't have DMA which means the iSCSI 831 * protocol layer will be doing a bcopy from bp to outgoing 832 * streams buffers. Make sure that the buffer is mapped in 833 * so that the copy won't panic the system. 834 */ 835 if (bp && (bp->b_bcount != 0) && 836 bp_mapin_common(bp, (callback == NULL_FUNC) ? 837 VM_NOSLEEP : VM_SLEEP) == NULL) { 838 return (NULL); 839 } 840 841 ilp = (iscsi_lun_t *)ap->a_hba_tran->tran_tgt_private; 842 ASSERT(ilp != NULL); 843 844 if (pkt == NULL) { 845 pkt = scsi_hba_pkt_alloc(ilp->lun_sess->sess_hba->hba_dip, 846 ap, cmdlen, statuslen, tgtlen, sizeof (iscsi_cmd_t), 847 callback, arg); 848 if (pkt == NULL) { 849 return (NULL); 850 } 851 icmdp = (iscsi_cmd_t *)pkt->pkt_ha_private; 852 icmdp->cmd_sig = ISCSI_SIG_CMD; 853 icmdp->cmd_state = ISCSI_CMD_STATE_FREE; 854 icmdp->cmd_lun = ilp; 855 icmdp->cmd_type = ISCSI_CMD_TYPE_SCSI; 856 /* add the report lun addressing type on to the lun */ 857 icmdp->cmd_un.scsi.lun = ilp->lun_addr_type << 14; 858 icmdp->cmd_un.scsi.lun = icmdp->cmd_un.scsi.lun | 859 ilp->lun_num; 860 icmdp->cmd_un.scsi.pkt = pkt; 861 icmdp->cmd_un.scsi.bp = bp; 862 icmdp->cmd_un.scsi.cmdlen = cmdlen; 863 icmdp->cmd_un.scsi.statuslen = statuslen; 864 icmdp->cmd_crc_error_seen = B_FALSE; 865 icmdp->cmd_misc_flags = 0; 866 if (flags & PKT_XARQ) { 867 icmdp->cmd_misc_flags |= ISCSI_CMD_MISCFLAG_XARQ; 868 } 869 870 871 idm_sm_audit_init(&icmdp->cmd_state_audit); 872 873 mutex_init(&icmdp->cmd_mutex, NULL, MUTEX_DRIVER, NULL); 874 cv_init(&icmdp->cmd_completion, NULL, CV_DRIVER, NULL); 875 876 pkt->pkt_address = *ap; 877 pkt->pkt_comp = (void (*)())NULL; 878 pkt->pkt_flags = 0; 879 pkt->pkt_time = 0; 880 pkt->pkt_resid = 0; 881 pkt->pkt_statistics = 0; 882 pkt->pkt_reason = 0; 883 } 884 return (pkt); 885 } 886 887 /* 888 * iscsi_tran_lun_free - Free a SCSI LUN 889 */ 890 static void 891 iscsi_tran_lun_free(dev_info_t *hba_dip, dev_info_t *lun_dip, 892 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 893 { 894 iscsi_lun_t *ilp = NULL; 895 896 ASSERT(hba_dip != NULL); 897 ASSERT(lun_dip != NULL); 898 ASSERT(hba_tran != NULL); 899 ASSERT(sd != NULL); 900 ilp = (iscsi_lun_t *)hba_tran->tran_tgt_private; 901 ASSERT(ilp != NULL); 902 903 (void) mdi_prop_remove(ilp->lun_pip, NULL); 904 } 905 906 /* 907 * iscsi_start -- Start a SCSI transaction based on the packet 908 * This will attempt to add the icmdp to the pending queue 909 * for the connection and kick the queue. If the enqueue 910 * fails that means the queue is full. 911 */ 912 static int 913 iscsi_tran_start(struct scsi_address *ap, struct scsi_pkt *pkt) 914 { 915 iscsi_lun_t *ilp = NULL; 916 iscsi_sess_t *isp = NULL; 917 iscsi_cmd_t *icmdp = NULL; 918 uint_t flags; 919 920 ASSERT(ap != NULL); 921 ASSERT(pkt != NULL); 922 ilp = (iscsi_lun_t *)ap->a_hba_tran->tran_tgt_private; 923 isp = (iscsi_sess_t *)ilp->lun_sess; 924 icmdp = (iscsi_cmd_t *)pkt->pkt_ha_private; 925 flags = pkt->pkt_flags; 926 ASSERT(ilp != NULL); 927 ASSERT(isp != NULL); 928 ASSERT(icmdp != NULL); 929 930 /* 931 * If the session is in the FREE state then 932 * all connections are down and retries have 933 * been exhausted. Fail command with fatal error. 934 */ 935 rw_enter(&isp->sess_state_rwlock, RW_READER); 936 if (isp->sess_state == ISCSI_SESS_STATE_FREE) { 937 rw_exit(&isp->sess_state_rwlock); 938 return (TRAN_FATAL_ERROR); 939 } 940 941 /* 942 * If we haven't received data from the target in the 943 * max specified period something is wrong with the 944 * transport. Fail IO with FATAL_ERROR. 945 */ 946 if (isp->sess_rx_lbolt + SEC_TO_TICK(iscsi_rx_max_window) < 947 ddi_get_lbolt()) { 948 rw_exit(&isp->sess_state_rwlock); 949 return (TRAN_FATAL_ERROR); 950 } 951 952 /* 953 * If the session is not in LOGGED_IN then we have 954 * no connections LOGGED_IN, but we haven't exhuasted 955 * our retries. Fail the command with busy so the 956 * caller might try again later. Once retries are 957 * exhausted the state machine will move us to FREE. 958 */ 959 if (isp->sess_state != ISCSI_SESS_STATE_LOGGED_IN) { 960 rw_exit(&isp->sess_state_rwlock); 961 return (TRAN_BUSY); 962 } 963 964 /* 965 * If we haven't received data from the target in the 966 * specified period something is probably wrong with 967 * the transport. Just return back BUSY until either 968 * the problem is resolved of the transport fails. 969 */ 970 if (isp->sess_rx_lbolt + SEC_TO_TICK(iscsi_rx_window) < 971 ddi_get_lbolt()) { 972 rw_exit(&isp->sess_state_rwlock); 973 return (TRAN_BUSY); 974 } 975 976 977 /* reset cmd values in case upper level driver is retrying cmd */ 978 icmdp->cmd_prev = icmdp->cmd_next = NULL; 979 icmdp->cmd_crc_error_seen = B_FALSE; 980 icmdp->cmd_lbolt_pending = icmdp->cmd_lbolt_active = 981 icmdp->cmd_lbolt_aborting = icmdp->cmd_lbolt_timeout = 982 (clock_t)NULL; 983 icmdp->cmd_itt = icmdp->cmd_ttt = 0; 984 icmdp->cmd_un.scsi.abort_icmdp = NULL; 985 986 mutex_enter(&isp->sess_queue_pending.mutex); 987 iscsi_cmd_state_machine(icmdp, ISCSI_CMD_EVENT_E1, isp); 988 mutex_exit(&isp->sess_queue_pending.mutex); 989 rw_exit(&isp->sess_state_rwlock); 990 991 /* 992 * If this packet doesn't have FLAG_NOINTR set, it could have 993 * already run to completion (and the memory freed) at this 994 * point, so check our local copy of pkt_flags. Otherwise we 995 * have to wait for completion before returning to the caller. 996 */ 997 if (flags & FLAG_NOINTR) { 998 mutex_enter(&icmdp->cmd_mutex); 999 while ((icmdp->cmd_state != ISCSI_CMD_STATE_COMPLETED) || 1000 (icmdp->cmd_un.scsi.r2t_icmdp != NULL) || 1001 (icmdp->cmd_un.scsi.abort_icmdp != NULL) || 1002 (icmdp->cmd_un.scsi.r2t_more == B_TRUE)) { 1003 cv_wait(&icmdp->cmd_completion, &icmdp->cmd_mutex); 1004 } 1005 icmdp->cmd_state = ISCSI_CMD_STATE_FREE; 1006 mutex_exit(&icmdp->cmd_mutex); 1007 } 1008 1009 return (TRAN_ACCEPT); 1010 } 1011 1012 /* 1013 * iscsi_tran_abort - Called when an upper level application 1014 * or driver wants to kill a scsi_pkt that was already sent to 1015 * this driver. 1016 */ 1017 /* ARGSUSED */ 1018 static int 1019 iscsi_tran_abort(struct scsi_address *ap, struct scsi_pkt *pkt) 1020 { 1021 return (0); 1022 } 1023 1024 /* 1025 * iscsi_tran_reset - Reset target at either BUS, TARGET, or LUN 1026 * level. This will require the issuing of a task management 1027 * command down to the target/lun. 1028 */ 1029 static int 1030 iscsi_tran_reset(struct scsi_address *ap, int level) 1031 { 1032 int rval = ISCSI_STATUS_INTERNAL_ERROR; 1033 iscsi_sess_t *isp = NULL; 1034 iscsi_lun_t *ilp = NULL; 1035 1036 ilp = (iscsi_lun_t *)ap->a_hba_tran->tran_tgt_private; 1037 ASSERT(ilp != NULL); 1038 isp = ilp->lun_sess; 1039 ASSERT(isp != NULL); 1040 1041 switch (level) { 1042 case RESET_LUN: 1043 /* reset attempt will block until attempt is complete */ 1044 rval = iscsi_handle_reset(isp, level, ilp); 1045 break; 1046 case RESET_BUS: 1047 /* 1048 * What are we going to realy reset the ethernet 1049 * network!? Just fall through to a target reset. 1050 */ 1051 case RESET_TARGET: 1052 /* reset attempt will block until attempt is complete */ 1053 rval = iscsi_handle_reset(isp, level, NULL); 1054 break; 1055 case RESET_ALL: 1056 default: 1057 break; 1058 } 1059 1060 return (ISCSI_SUCCESS(rval) ? 1 : 0); 1061 } 1062 1063 /* 1064 * iscsi_tran_getcap - Get target/lun capabilities. 1065 */ 1066 static int 1067 iscsi_tran_getcap(struct scsi_address *ap, char *cap, int whom) 1068 { 1069 return (iscsi_i_commoncap(ap, cap, 0, whom, 0)); 1070 } 1071 1072 1073 /* 1074 * iscsi_tran_setcap - Set target/lun capabilities. 1075 */ 1076 /* ARGSUSED */ 1077 static int 1078 iscsi_tran_setcap(struct scsi_address *ap, char *cap, int value, int whom) 1079 { 1080 return (iscsi_i_commoncap(ap, cap, value, whom, 1)); 1081 } 1082 1083 1084 /* 1085 * iscsi_tran_destroy_pkt - Clean up packet 1086 */ 1087 static void 1088 iscsi_tran_destroy_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 1089 { 1090 iscsi_cmd_t *icmdp; 1091 1092 icmdp = (iscsi_cmd_t *)pkt->pkt_ha_private; 1093 1094 ASSERT(icmdp != NULL); 1095 ASSERT(icmdp->cmd_sig == ISCSI_SIG_CMD); 1096 ASSERT(icmdp->cmd_state == ISCSI_CMD_STATE_FREE); 1097 1098 mutex_destroy(&icmdp->cmd_mutex); 1099 cv_destroy(&icmdp->cmd_completion); 1100 scsi_hba_pkt_free(ap, pkt); 1101 } 1102 1103 /* 1104 * iscsi_tran_dmafree - This is a software driver, NO DMA 1105 */ 1106 /* ARGSUSED */ 1107 static void 1108 iscsi_tran_dmafree(struct scsi_address *ap, struct scsi_pkt *pkt) 1109 { 1110 /* 1111 * The iSCSI interface doesn't deal with DMA 1112 */ 1113 } 1114 1115 /* 1116 * iscsi_tran_sync_pkt - This is a software driver, NO DMA 1117 */ 1118 /* ARGSUSED */ 1119 static void 1120 iscsi_tran_sync_pkt(struct scsi_address *ap, struct scsi_pkt *pkt) 1121 { 1122 /* 1123 * The iSCSI interface doesn't deal with DMA 1124 */ 1125 } 1126 1127 /* 1128 * iscsi_tran_reset_notify - We don't support BUS_RESET so there 1129 * is no point in support callback. 1130 */ 1131 /* ARGSUSED */ 1132 static int 1133 iscsi_tran_reset_notify(struct scsi_address *ap, int flag, 1134 void (*callback) (caddr_t), caddr_t arg) 1135 { 1136 1137 /* 1138 * We never do BUS_RESETS so allowing this call 1139 * back to register has no point? 1140 */ 1141 return (DDI_SUCCESS); 1142 } 1143 1144 1145 /* 1146 * iscsi_tran_bus_config - on demand device configuration 1147 * 1148 * iscsi_tran_bus_config is called by the NDI layer at the completion 1149 * of a dev_node creation. There are two primary cases defined in this 1150 * function. The first is BUS_CONFIG_ALL. In this case the NDI is trying 1151 * to identify that targets/luns are available configured at that point 1152 * in time. It is safe to just complete the process succcessfully. The 1153 * second case is a new case that was defined in S10 for devfs. BUS_CONFIG_ONE 1154 * this is to help driver the top down discovery instead of bottom up. If 1155 * we receive a BUS_CONFIG_ONE we should check to see if the <addr> exists 1156 * if so complete successfull processing. Otherwise we should call the 1157 * deamon and see if we can plumb the <addr>. If it is possible to plumb the 1158 * <addr> block until plumbing is complete. In both cases of being able to 1159 * plumb <addr> or not continue with successfull processing. 1160 */ 1161 static int 1162 iscsi_tran_bus_config(dev_info_t *parent, uint_t flags, 1163 ddi_bus_config_op_t op, void *arg, dev_info_t **childp) 1164 { 1165 int rval = NDI_SUCCESS; 1166 iscsi_hba_t *ihp = NULL; 1167 int iflags = flags; 1168 char *name = NULL; 1169 char *ptr = NULL; 1170 boolean_t config_root = B_FALSE; 1171 1172 /* get reference to soft state */ 1173 ihp = (iscsi_hba_t *)ddi_get_soft_state(iscsi_state, 1174 ddi_get_instance(parent)); 1175 if (ihp == NULL) { 1176 return (NDI_FAILURE); 1177 } 1178 1179 iscsi_check_miniroot(ihp); 1180 if ((modrootloaded == 0) && (iscsiboot_prop != NULL)) { 1181 config_root = B_TRUE; 1182 } 1183 1184 if (config_root == B_FALSE) { 1185 if (iscsi_client_request_service(ihp) == B_FALSE) { 1186 return (NDI_FAILURE); 1187 } 1188 } 1189 1190 /* lock so only one config operation occrs */ 1191 sema_p(&iscsid_config_semaphore); 1192 1193 switch (op) { 1194 case BUS_CONFIG_ONE: 1195 /* parse target name out of name given */ 1196 if ((ptr = strchr((char *)arg, '@')) == NULL) { 1197 rval = NDI_FAILURE; 1198 break; 1199 } 1200 ptr++; /* move past '@' */ 1201 name = kmem_zalloc(MAX_GET_NAME_SIZE, KM_SLEEP); 1202 (void) strncpy(name, ptr, MAX_GET_NAME_SIZE); 1203 /* We need to strip the LUN */ 1204 if ((ptr = strchr(name, ',')) == NULL) { 1205 rval = NDI_FAILURE; 1206 kmem_free(name, MAX_GET_NAME_SIZE); 1207 name = NULL; 1208 break; 1209 } 1210 /* We also need to strip the 4 bytes of hex TPGT */ 1211 ptr -= 4; 1212 if (ptr <= name) { 1213 rval = NDI_FAILURE; 1214 kmem_free(name, MAX_GET_NAME_SIZE); 1215 name = NULL; 1216 break; 1217 } 1218 *ptr = '\0'; /* NULL terminate */ 1219 1220 /* translate name back to original iSCSI name */ 1221 iscsi_get_name_to_iqn(name, MAX_GET_NAME_SIZE); 1222 1223 /* configure target, skip 4 byte ISID */ 1224 iscsid_config_one(ihp, (name+4), B_TRUE); 1225 1226 kmem_free(name, MAX_GET_NAME_SIZE); 1227 name = NULL; 1228 1229 /* 1230 * DDI group instructed us to use this flag. 1231 */ 1232 iflags |= NDI_MDI_FALLBACK; 1233 break; 1234 case BUS_CONFIG_DRIVER: 1235 /* FALLTHRU */ 1236 case BUS_CONFIG_ALL: 1237 iscsid_config_all(ihp, B_TRUE); 1238 break; 1239 default: 1240 rval = NDI_FAILURE; 1241 break; 1242 } 1243 1244 if (rval == NDI_SUCCESS) { 1245 rval = ndi_busop_bus_config(parent, iflags, 1246 op, arg, childp, 0); 1247 } 1248 sema_v(&iscsid_config_semaphore); 1249 1250 if (config_root == B_FALSE) { 1251 iscsi_client_release_service(ihp); 1252 } 1253 1254 return (rval); 1255 } 1256 1257 /* 1258 * iscsi_tran_bus_unconfig - on demand device unconfiguration 1259 * 1260 * Called by the os framework under low resource situations. 1261 * It will attempt to unload our minor nodes (logical units 1262 * ndi/mdi nodes). 1263 */ 1264 static int 1265 iscsi_tran_bus_unconfig(dev_info_t *parent, uint_t flag, 1266 ddi_bus_config_op_t op, void *arg) 1267 { 1268 int rval = NDI_SUCCESS; 1269 iscsi_hba_t *ihp = NULL; 1270 1271 /* get reference to soft state */ 1272 ihp = (iscsi_hba_t *)ddi_get_soft_state(iscsi_state, 1273 ddi_get_instance(parent)); 1274 if (ihp == NULL) { 1275 return (NDI_FAILURE); 1276 } 1277 1278 if (iscsi_client_request_service(ihp) == B_FALSE) { 1279 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 1280 if (ihp->hba_sess_list != NULL) { 1281 rval = NDI_FAILURE; 1282 } 1283 rw_exit(&ihp->hba_sess_list_rwlock); 1284 return (rval); 1285 } 1286 1287 rval = ndi_busop_bus_unconfig(parent, flag, op, arg); 1288 1289 iscsi_client_release_service(ihp); 1290 1291 return (rval); 1292 } 1293 1294 1295 /* 1296 * iscsi_tran_get_name - create private /devices name for LUN 1297 * 1298 * This creates the <addr> in /devices/iscsi/<driver>@<addr> 1299 * path. For this <addr> we return the <session/target_name>,<lun num> 1300 * Where <target_name> is an <iqn/eui/...> as defined by the iSCSI 1301 * specification. We do modify the name slightly so that it still 1302 * complies with the IEEE <addr> naming scheme. This means that we 1303 * will substitute out the ':', '@', ... and other reserved characters 1304 * defined in the IEEE definition with '%<hex value of special char>' 1305 * This routine is indirectly called by iscsi_lun_create_xxx. These 1306 * calling routines must prevent the session and lun lists from changing 1307 * during this routine. 1308 */ 1309 static int 1310 iscsi_tran_get_name(struct scsi_device *sd, char *name, int len) 1311 { 1312 int target = 0; 1313 int lun = 0; 1314 iscsi_hba_t *ihp = NULL; 1315 iscsi_sess_t *isp = NULL; 1316 iscsi_lun_t *ilp = NULL; 1317 dev_info_t *lun_dip = NULL; 1318 1319 ASSERT(sd != NULL); 1320 ASSERT(name != NULL); 1321 lun_dip = sd->sd_dev; 1322 ASSERT(lun_dip != NULL); 1323 1324 /* get reference to soft state */ 1325 ihp = (iscsi_hba_t *)ddi_get_soft_state(iscsi_state, 1326 ddi_get_instance(ddi_get_parent(lun_dip))); 1327 if (ihp == NULL) { 1328 name[0] = '\0'; 1329 return (0); 1330 } 1331 1332 /* Get the target num */ 1333 target = ddi_prop_get_int(DDI_DEV_T_ANY, sd->sd_dev, 1334 DDI_PROP_DONTPASS, TARGET_PROP, 0); 1335 1336 /* Get the target num */ 1337 lun = ddi_prop_get_int(DDI_DEV_T_ANY, sd->sd_dev, 1338 DDI_PROP_DONTPASS, LUN_PROP, 0); 1339 1340 /* 1341 * Now we need to find our ilp by walking the lists 1342 * off the ihp and isp. 1343 */ 1344 /* See if we already created this session */ 1345 1346 /* Walk the HBA's session list */ 1347 for (isp = ihp->hba_sess_list; isp; isp = isp->sess_next) { 1348 /* compare target name as the unique identifier */ 1349 if (target == isp->sess_oid) { 1350 /* found match */ 1351 break; 1352 } 1353 } 1354 1355 /* If we found matching session continue searching for tgt */ 1356 if (isp == NULL) { 1357 /* sess not found */ 1358 name[0] = '\0'; 1359 return (0); 1360 } 1361 1362 /* 1363 * Search for the matching iscsi lun structure. We don't 1364 * need to hold the READER for the lun list at this point. 1365 * because the tran_get_name is being called from the online 1366 * function which is already holding a reader on the lun 1367 * list. 1368 */ 1369 for (ilp = isp->sess_lun_list; ilp; ilp = ilp->lun_next) { 1370 if (lun == ilp->lun_num) { 1371 /* found match */ 1372 break; 1373 } 1374 } 1375 1376 if (ilp == NULL) { 1377 /* tgt not found */ 1378 name[0] = '\0'; 1379 return (0); 1380 } 1381 1382 /* Ensure enough space for lun_addr is available */ 1383 ASSERT(ilp->lun_addr != NULL); 1384 if ((strlen(ilp->lun_addr) + 1) > len) { 1385 return (0); 1386 } 1387 1388 /* copy lun_addr name */ 1389 (void) strcpy(name, ilp->lun_addr); 1390 1391 /* 1392 * Based on IEEE-1275 we can't have any ':', ' ', '@', or '/' 1393 * characters in our naming. So replace all those characters 1394 * with '-' 1395 */ 1396 iscsi_get_name_from_iqn(name, len); 1397 1398 return (1); 1399 } 1400 1401 /* 1402 * iscsi_tran_get_bus_addr - This returns a human readable string 1403 * for the bus address. Examining most other drivers fcp, etc. They 1404 * all just return the same string as tran_get_name. In our case 1405 * our tran get name is already some what usable so leave alone. 1406 */ 1407 static int 1408 iscsi_tran_get_bus_addr(struct scsi_device *sd, char *name, int len) 1409 { 1410 return (iscsi_tran_get_name(sd, name, len)); 1411 } 1412 1413 1414 /* 1415 * +--------------------------------------------------------------------+ 1416 * | End of scsi_tran routines | 1417 * +--------------------------------------------------------------------+ 1418 */ 1419 1420 /* 1421 * +--------------------------------------------------------------------+ 1422 * | Start of cb_ops routines | 1423 * +--------------------------------------------------------------------+ 1424 */ 1425 1426 /* 1427 * iscsi_open - Driver should be made IOCTL MT safe. Otherwise 1428 * this function needs updated. 1429 */ 1430 /* ARGSUSED */ 1431 static int 1432 iscsi_open(dev_t *devp, int flags, int otyp, cred_t *credp) 1433 { 1434 return (0); 1435 } 1436 1437 /* 1438 * iscsi_close - 1439 */ 1440 /* ARGSUSED */ 1441 static int 1442 iscsi_close(dev_t dev, int flags, int otyp, cred_t *credp) 1443 { 1444 return (0); 1445 } 1446 1447 /* 1448 * iscsi_ioctl - 1449 */ 1450 /* ARGSUSED */ 1451 static int 1452 iscsi_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, 1453 cred_t *credp, int *rvalp) 1454 { 1455 int rtn = 0; 1456 int instance = 0; 1457 int list_space = 0; 1458 int lun_sz = 0; 1459 int did; 1460 int retry; 1461 iscsi_hba_t *ihp = NULL; 1462 iscsi_sess_t *isp = NULL; 1463 iscsi_conn_t *icp = NULL; 1464 iscsi_login_params_t *params = NULL; 1465 iscsi_login_params_t *tmpParams = NULL; 1466 uchar_t *name = NULL; 1467 dev_info_t *lun_dip = NULL; 1468 1469 entry_t e; 1470 iscsi_oid_t oid; 1471 iscsi_property_t *ipp; 1472 iscsi_static_property_t *ispp; 1473 iscsi_param_get_t *ilg; 1474 iscsi_param_set_t *ils; 1475 iscsi_target_list_t idl, *idlp = NULL; 1476 iscsi_addr_list_t ial, *ialp = NULL; 1477 iscsi_chap_props_t *chap = NULL; 1478 iscsi_radius_props_t *radius = NULL; 1479 iscsi_auth_props_t *auth = NULL; 1480 iscsi_lun_list_t *ll, *llp = NULL; 1481 iscsi_lun_props_t *lun = NULL; 1482 iscsi_lun_t *ilp = NULL; 1483 iSCSIDiscoveryMethod_t method; 1484 iSCSIDiscoveryProperties_t discovery_props; 1485 iscsi_uscsi_t iu; 1486 iscsi_uscsi_t iu_caller; 1487 #ifdef _MULTI_DATAMODEL 1488 /* For use when a 32 bit app makes a call into a 64 bit ioctl */ 1489 iscsi_uscsi32_t iu32_caller; 1490 model_t model; 1491 #endif /* _MULTI_DATAMODEL */ 1492 void *void_p; 1493 iscsi_sendtgts_list_t *stl_hdr; 1494 iscsi_sendtgts_list_t *istl; 1495 int stl_sz; 1496 iscsi_target_entry_t *target; 1497 uint32_t old_oid; 1498 uint32_t target_oid; 1499 iscsi_targetparam_entry_t *curr_entry; 1500 char *initiator_node_name; 1501 char *initiator_node_alias; 1502 isns_portal_group_list_t *pg_list = NULL; 1503 isns_server_portal_group_list_t *server_pg_list_hdr = NULL; 1504 isns_server_portal_group_list_t *server_pg_list = NULL; 1505 int pg_list_sz, pg_sz_copy_out, server_pg_list_sz; 1506 iscsi_config_sess_t *ics; 1507 int size; 1508 boolean_t rval; 1509 char init_port_name[MAX_NAME_PROP_SIZE]; 1510 iscsi_sockaddr_t addr_dsc; 1511 iscsi_boot_property_t *bootProp; 1512 boolean_t discovered = B_TRUE; 1513 iscsi_tunable_object_t *tpsg; 1514 iscsi_tunable_object_t *tpss; 1515 iscsi_reen_t *reenum; 1516 1517 instance = getminor(dev); 1518 ihp = (iscsi_hba_t *)ddi_get_soft_state(iscsi_state, instance); 1519 if (ihp == NULL) 1520 return (EFAULT); 1521 1522 iscsi_check_miniroot(ihp); 1523 if ((cmd != ISCSI_SMF_ONLINE) && (cmd != ISCSI_SMF_OFFLINE) && 1524 (cmd != ISCSI_SMF_GET)) { 1525 /* other cmd needs to acquire the service */ 1526 if (iscsi_client_request_service(ihp) == B_FALSE) { 1527 return (EFAULT); 1528 } 1529 } 1530 1531 switch (cmd) { 1532 /* 1533 * ISCSI_CREATE_OID - Create a Object IDentifier for a TargetName 1534 */ 1535 case ISCSI_CREATE_OID: 1536 if (ddi_copyin((caddr_t)arg, &oid, sizeof (oid), mode)) { 1537 rtn = EFAULT; 1538 break; 1539 } 1540 if (oid.o_vers != ISCSI_INTERFACE_VERSION) { 1541 rtn = EINVAL; 1542 break; 1543 } 1544 1545 /* Set the target that this session is associated with */ 1546 oid.o_oid = iscsi_targetparam_get_oid(oid.o_name); 1547 1548 if (ddi_copyout(&oid, (caddr_t)arg, sizeof (oid), mode)) { 1549 rtn = EFAULT; 1550 break; 1551 } 1552 break; 1553 /* 1554 * ISCSI_PARAM_GET - Get param for specified 1555 * connection/session. 1556 */ 1557 case ISCSI_PARAM_GET: 1558 /* copyin user args */ 1559 ilg = (iscsi_param_get_t *)kmem_alloc(sizeof (*ilg), KM_SLEEP); 1560 if (ddi_copyin((caddr_t)arg, ilg, sizeof (*ilg), mode)) { 1561 rtn = EFAULT; 1562 kmem_free(ilg, sizeof (*ilg)); 1563 break; 1564 } 1565 1566 if (ilg->g_vers != ISCSI_INTERFACE_VERSION) { 1567 rtn = EINVAL; 1568 kmem_free(ilg, sizeof (*ilg)); 1569 break; 1570 } 1571 1572 /* handle special case for Initiator name */ 1573 if (ilg->g_param == ISCSI_LOGIN_PARAM_INITIATOR_NAME) { 1574 (void) strlcpy((char *)ilg->g_value.v_name, 1575 (char *)ihp->hba_name, ISCSI_MAX_NAME_LEN); 1576 } else if (ilg->g_param == ISCSI_LOGIN_PARAM_INITIATOR_ALIAS) { 1577 if (ihp->hba_alias_length == 0) { 1578 rtn = EINVAL; 1579 } else { 1580 (void) strlcpy((char *)ilg->g_value.v_name, 1581 (char *)ihp->hba_alias, ISCSI_MAX_NAME_LEN); 1582 } 1583 } else { 1584 /* To describe the validity of the requested param */ 1585 boolean_t valid_flag = B_TRUE; 1586 1587 name = NULL; 1588 1589 /* 1590 * switch login based if looking for initiator 1591 * params 1592 */ 1593 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 1594 if (ilg->g_oid == ihp->hba_oid) { 1595 /* initiator */ 1596 params = &ihp->hba_params; 1597 name = ihp->hba_name; 1598 if (iscsi_get_persisted_param(name, 1599 ilg, params) != 0) { 1600 valid_flag = B_FALSE; 1601 } 1602 } else { 1603 /* 1604 * If the oid does represent a session check 1605 * to see if it is a target oid. If so, 1606 * return the target's associated session. 1607 */ 1608 rtn = iscsi_sess_get(ilg->g_oid, ihp, &isp); 1609 if (rtn != 0) { 1610 rtn = iscsi_sess_get_by_target( 1611 ilg->g_oid, ihp, &isp); 1612 } 1613 1614 /* 1615 * If rtn is zero then we have found an 1616 * existing session. Use the session name to 1617 * do param lookup. If rtn is non-zero then 1618 * create a targetparam object and use its name 1619 * for param lookup. 1620 */ 1621 if (rtn == 0) { 1622 name = isp->sess_name; 1623 params = &isp->sess_params; 1624 } else { 1625 name = 1626 iscsi_targetparam_get_name( 1627 ilg->g_oid); 1628 if (ilg->g_param_type == 1629 ISCSI_SESS_PARAM) { 1630 tmpParams = 1631 (iscsi_login_params_t *) 1632 kmem_alloc( 1633 sizeof (*tmpParams), 1634 KM_SLEEP); 1635 params = tmpParams; 1636 } 1637 rtn = 0; 1638 } 1639 1640 if (name == NULL) { 1641 rw_exit( 1642 &ihp->hba_sess_list_rwlock); 1643 rtn = EFAULT; 1644 kmem_free(ilg, sizeof (*ilg)); 1645 if (tmpParams != NULL) 1646 kmem_free(tmpParams, 1647 sizeof (*tmpParams)); 1648 1649 break; 1650 } 1651 1652 if (ilg->g_param_type == ISCSI_SESS_PARAM) { 1653 /* session */ 1654 /* 1655 * Update sess_params with the 1656 * latest params from the 1657 * persistent store. 1658 */ 1659 if (iscsi_get_persisted_param(name, 1660 ilg, params) != 0) { 1661 /* 1662 * If the parameter in 1663 * question is not 1664 * overriden, no effect 1665 * on existing session 1666 * parameters. However, 1667 * the parameter is 1668 * marked invalid 1669 * (from the standpoint 1670 * of whether it is 1671 * overriden). 1672 */ 1673 valid_flag = B_FALSE; 1674 } 1675 } else if (ilg->g_param_type == 1676 ISCSI_CONN_PARAM && isp != NULL) { 1677 /* connection */ 1678 rw_enter(&isp->sess_conn_list_rwlock, 1679 RW_READER); 1680 /* Assuming 1 conn per sess. */ 1681 /* 1682 * MC/S - Need to be modified to 1683 * take g_conn_cid into account when 1684 * we go multi-connection. 1685 */ 1686 if ((isp->sess_conn_act != NULL) && 1687 (isp->sess_conn_act->conn_state == 1688 ISCSI_CONN_STATE_LOGGED_IN)) { 1689 params = &(isp-> 1690 sess_conn_act-> 1691 conn_params); 1692 } else { 1693 valid_flag = B_FALSE; 1694 } 1695 rw_exit(&isp->sess_conn_list_rwlock); 1696 } 1697 } 1698 1699 /* make sure we have params to get info from */ 1700 if (params) { 1701 rtn = iscsi_get_param(params, valid_flag, ilg); 1702 1703 /* 1704 * for target parameters, check if any 1705 * parameters were overridden at the initiator 1706 * level. If so, then change the default value 1707 * to the initiator's overridden value 1708 */ 1709 if ((rtn == 0) && 1710 (ilg->g_oid != ihp->hba_oid)) { 1711 iscsi_override_target_default(ihp, 1712 ilg); 1713 } 1714 } 1715 rw_exit(&ihp->hba_sess_list_rwlock); 1716 } 1717 1718 if (rtn == 0) { 1719 rtn = ddi_copyout(ilg, (caddr_t)arg, 1720 sizeof (iscsi_param_get_t), mode); 1721 } 1722 kmem_free(ilg, sizeof (*ilg)); 1723 if (tmpParams != NULL) 1724 kmem_free(tmpParams, sizeof (*tmpParams)); 1725 break; 1726 1727 /* 1728 * ISCSI_INIT_NODE_NAME_SET - Change the initiator-node name for 1729 * the specified connection/session. 1730 */ 1731 case ISCSI_INIT_NODE_NAME_SET: 1732 /* copyin user args */ 1733 ils = (iscsi_param_set_t *)kmem_alloc(sizeof (*ils), KM_SLEEP); 1734 if (ddi_copyin((caddr_t)arg, ils, sizeof (*ils), mode)) { 1735 rtn = EFAULT; 1736 kmem_free(ils, sizeof (*ils)); 1737 break; 1738 } 1739 1740 if (ils->s_vers != ISCSI_INTERFACE_VERSION) { 1741 rtn = EINVAL; 1742 kmem_free(ils, sizeof (*ils)); 1743 break; 1744 } 1745 1746 /* saving off the old initiator-node name */ 1747 initiator_node_name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP); 1748 rval = persistent_initiator_name_get(initiator_node_name, 1749 ISCSI_MAX_NAME_LEN); 1750 1751 rtn = iscsi_set_params(ils, ihp, B_TRUE); 1752 kmem_free(ils, sizeof (*ils)); 1753 if (rtn != 0) { 1754 kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN); 1755 initiator_node_name = NULL; 1756 break; 1757 } 1758 1759 (void) snprintf(init_port_name, MAX_NAME_PROP_SIZE, 1760 "%s,%02x%02x%02x%02x%02x%02x", 1761 (char *)ihp->hba_name, ihp->hba_isid[0], 1762 ihp->hba_isid[1], ihp->hba_isid[2], 1763 ihp->hba_isid[3], ihp->hba_isid[4], 1764 ihp->hba_isid[5]); 1765 1766 if (ddi_prop_update_string(DDI_DEV_T_NONE, 1767 ihp->hba_dip, SCSI_ADDR_PROP_INITIATOR_PORT, 1768 init_port_name) != DDI_PROP_SUCCESS) { 1769 cmn_err(CE_WARN, "iscsi_ioctl: Updating " 1770 SCSI_ADDR_PROP_INITIATOR_PORT " property on iSCSI " 1771 "HBA(%s) with dip(%d) Failed", 1772 (char *)ihp->hba_name, 1773 ddi_get_instance(ihp->hba_dip)); 1774 } 1775 1776 /* 1777 * Deregister the old initiator-node name from the iSNS 1778 * server 1779 * Register the new initiator-node name with the iSNS server 1780 */ 1781 method = persistent_disc_meth_get(); 1782 if (method & iSCSIDiscoveryMethodISNS) { 1783 if (rval == B_TRUE) { 1784 if (strlen(initiator_node_name) > 0) { 1785 /* 1786 * we will attempt to offline the targets. 1787 * if logouts fail, we will still continue 1788 */ 1789 #define STRING_INNO "initiator-node name - Offline " 1790 #define STRING_FFOMD "failed for one or more devices" 1791 if ((iscsid_del( 1792 ihp, NULL, method, NULL)) 1793 != B_TRUE) { 1794 cmn_err(CE_NOTE, 1795 "Attempting to change " 1796 STRING_INNO 1797 STRING_FFOMD); 1798 } 1799 (void) isns_dereg(ihp->hba_isid, 1800 (uint8_t *)initiator_node_name); 1801 #undef STRING_INNO 1802 #undef STRING_FFOMD 1803 } 1804 } 1805 if (persistent_initiator_name_get(initiator_node_name, 1806 ISCSI_MAX_NAME_LEN) != B_TRUE) { 1807 kmem_free(initiator_node_name, 1808 ISCSI_MAX_NAME_LEN); 1809 initiator_node_name = NULL; 1810 rtn = EIO; 1811 break; 1812 } 1813 if (strlen(initiator_node_name) == 0) { 1814 kmem_free(initiator_node_name, 1815 ISCSI_MAX_NAME_LEN); 1816 initiator_node_name = NULL; 1817 rtn = EIO; 1818 break; 1819 } 1820 1821 initiator_node_alias = kmem_zalloc(ISCSI_MAX_NAME_LEN, 1822 KM_SLEEP); 1823 if (persistent_alias_name_get(initiator_node_alias, 1824 ISCSI_MAX_NAME_LEN) != B_TRUE) { 1825 initiator_node_alias[0] = '\0'; 1826 } 1827 1828 (void) isns_reg(ihp->hba_isid, 1829 (uint8_t *)initiator_node_name, 1830 ISCSI_MAX_NAME_LEN, 1831 (uint8_t *)initiator_node_alias, 1832 ISCSI_MAX_NAME_LEN, 1833 ISNS_INITIATOR_NODE_TYPE, 1834 isns_scn_callback); 1835 iscsid_do_isns_query(ihp); 1836 1837 kmem_free(initiator_node_alias, ISCSI_MAX_NAME_LEN); 1838 initiator_node_alias = NULL; 1839 } 1840 1841 kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN); 1842 initiator_node_name = NULL; 1843 break; 1844 1845 /* 1846 * ISCSI_PARAM_SET - Set param for specified connection/session. 1847 */ 1848 case ISCSI_PARAM_SET: 1849 /* copyin user args */ 1850 ils = (iscsi_param_set_t *)kmem_alloc(sizeof (*ils), KM_SLEEP); 1851 if (ddi_copyin((caddr_t)arg, ils, sizeof (*ils), mode)) { 1852 rtn = EFAULT; 1853 kmem_free(ils, sizeof (*ils)); 1854 break; 1855 } 1856 1857 if (ils->s_vers != ISCSI_INTERFACE_VERSION) { 1858 rtn = EINVAL; 1859 kmem_free(ils, sizeof (*ils)); 1860 break; 1861 } 1862 rtn = iscsi_set_params(ils, ihp, B_TRUE); 1863 if (iscsiboot_prop) { 1864 if (iscsi_cmp_boot_sess_oid(ihp, ils->s_oid)) { 1865 /* 1866 * found active session for this object 1867 * or this is initiator's object 1868 * with mpxio enabled 1869 */ 1870 if (!iscsi_reconfig_boot_sess(ihp)) { 1871 rtn = EINVAL; 1872 kmem_free(ils, sizeof (*ils)); 1873 break; 1874 } 1875 } 1876 } 1877 kmem_free(ils, sizeof (*ils)); 1878 break; 1879 1880 /* 1881 * ISCSI_TARGET_PARAM_CLEAR 1882 * - remove custom parameter settings for a target. 1883 */ 1884 case ISCSI_TARGET_PARAM_CLEAR: 1885 if (ddi_copyin((caddr_t)arg, &e, sizeof (e), mode)) { 1886 rtn = EFAULT; 1887 break; 1888 } else if (e.e_vers != ISCSI_INTERFACE_VERSION) { 1889 rtn = EINVAL; 1890 break; 1891 } 1892 1893 if ((e.e_oid != ihp->hba_oid) && 1894 (e.e_oid != ISCSI_OID_NOTSET)) { 1895 boolean_t rval1, rval2, rval3; 1896 uchar_t *t_name; 1897 iscsi_sess_t *t_isp; 1898 boolean_t t_rtn = B_TRUE; 1899 persistent_param_t t_param; 1900 iscsi_config_sess_t t_ics; 1901 persistent_tunable_param_t t_tpsg; 1902 1903 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 1904 /* 1905 * If the oid does represent a session check to see 1906 * if it is a target oid. If so, return the target's 1907 * associated session. 1908 */ 1909 rtn = iscsi_sess_get(e.e_oid, ihp, &isp); 1910 if (rtn != 0) { 1911 rtn = iscsi_sess_get_by_target(e.e_oid, ihp, 1912 &isp); 1913 } 1914 1915 /* 1916 * If rtn is zero then we have found an 1917 * existing session. Use the session name to 1918 * do param lookup. If rtn is non-zero then 1919 * create a targetparam object and use its name 1920 * for param lookup. 1921 */ 1922 if (rtn == 0) { 1923 t_name = isp->sess_name; 1924 } else { 1925 t_name = iscsi_targetparam_get_name(e.e_oid); 1926 rtn = 0; 1927 } 1928 1929 if (t_name == NULL) { 1930 rw_exit(&ihp->hba_sess_list_rwlock); 1931 rtn = EFAULT; 1932 break; 1933 } 1934 1935 name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP); 1936 (void) strncpy((char *)name, (char *)t_name, 1937 ISCSI_MAX_NAME_LEN); 1938 1939 t_ics.ics_in = 1; 1940 rval1 = persistent_param_get((char *)name, &t_param); 1941 rval2 = persistent_get_config_session((char *)name, 1942 &t_ics); 1943 rval3 = persistent_get_tunable_param((char *)name, 1944 &t_tpsg); 1945 1946 if ((rval1 == B_FALSE) && (rval2 == B_FALSE) && 1947 (rval3 == B_FALSE)) { 1948 /* no any target parameters get */ 1949 kmem_free(name, ISCSI_MAX_NAME_LEN); 1950 rw_exit(&ihp->hba_sess_list_rwlock); 1951 rtn = EIO; 1952 break; 1953 } 1954 1955 if (persistent_param_clear((char *)name) == B_FALSE) { 1956 kmem_free(name, ISCSI_MAX_NAME_LEN); 1957 rw_exit(&ihp->hba_sess_list_rwlock); 1958 rtn = EIO; 1959 break; 1960 } 1961 1962 ics = kmem_zalloc(sizeof (*ics), KM_SLEEP); 1963 ics->ics_ver = ISCSI_INTERFACE_VERSION; 1964 ics->ics_oid = ISCSI_INITIATOR_OID; 1965 ics->ics_in = 1; 1966 1967 /* 1968 * We may have multiple sessions with different 1969 * tpgt values. So we need to loop through 1970 * the sessions and update all sessions. 1971 */ 1972 for (isp = ihp->hba_sess_list; isp; 1973 isp = t_isp) { 1974 t_isp = isp->sess_next; 1975 1976 if (strncmp((char *)isp->sess_name, 1977 (char *)name, ISCSI_MAX_NAME_LEN) == 0) { 1978 /* 1979 * When removing target-params we need 1980 * slightly different actions depending 1981 * on if the session should still exist. 1982 * Get the initiator-node value for 1983 * MS/T. If there is no initiator 1984 * value then assume the default value 1985 * of 1. If the initiator value is 1986 * less than this ISID then we need to 1987 * destroy the session. Otherwise 1988 * update the session information and 1989 * resync (N7 event). 1990 */ 1991 rtn = iscsi_ioctl_get_config_sess( 1992 ihp, ics); 1993 if (((rtn != 0) && 1994 (isp->sess_isid[5] > 0)) || 1995 ((rtn == 0) && 1996 (ics->ics_out <= 1997 isp->sess_isid[5]))) { 1998 1999 /* 2000 * This session should no 2001 * longer exist. Remove 2002 * session. 2003 */ 2004 if (!ISCSI_SUCCESS( 2005 iscsi_sess_destroy(isp))) { 2006 t_rtn = B_FALSE; 2007 continue; 2008 } 2009 isp = ihp->hba_sess_list; 2010 } else { 2011 uint32_t event_count; 2012 /* 2013 * Reset the session 2014 * parameters. 2015 */ 2016 bcopy(&(isp->sess_hba-> 2017 hba_params), 2018 &(isp->sess_params), 2019 sizeof (isp->sess_params)); 2020 if (iscsiboot_prop && 2021 isp->sess_boot) { 2022 /* 2023 * reconfig boot 2024 * session later 2025 */ 2026 continue; 2027 } 2028 /* 2029 * Notify the session that the 2030 * login parameters have 2031 * changed. 2032 */ 2033 event_count = atomic_inc_32_nv( 2034 &isp-> 2035 sess_state_event_count); 2036 iscsi_sess_enter_state_zone( 2037 isp); 2038 2039 iscsi_sess_state_machine(isp, 2040 ISCSI_SESS_EVENT_N7, 2041 event_count); 2042 2043 iscsi_sess_exit_state_zone( 2044 isp); 2045 } 2046 } 2047 } 2048 if (t_rtn == B_FALSE) { 2049 boolean_t t_rval = B_TRUE; 2050 /* Failure!, restore target's parameters */ 2051 if (rval1 == B_TRUE) { 2052 rval1 = persistent_param_set( 2053 (char *)name, &t_param); 2054 if (rval1 == B_FALSE) { 2055 t_rval = B_FALSE; 2056 } 2057 } 2058 if (rval2 == B_TRUE) { 2059 rval2 = persistent_set_config_session( 2060 (char *)name, &t_ics); 2061 if (rval2 == B_FALSE) { 2062 t_rval = B_FALSE; 2063 } 2064 } 2065 if (rval3 == B_TRUE) { 2066 rval3 = persistent_set_tunable_param( 2067 (char *)name, &t_tpsg); 2068 if (rval3 == B_FALSE) { 2069 t_rval = B_FALSE; 2070 } 2071 } 2072 if (t_rval == B_FALSE) { 2073 cmn_err(CE_WARN, "Failed to restore " 2074 "target's parameters after remove " 2075 "session related to target " 2076 "parameters failure."); 2077 } 2078 rtn = EBUSY; 2079 } 2080 kmem_free(ics, sizeof (*ics)); 2081 kmem_free(name, ISCSI_MAX_NAME_LEN); 2082 rw_exit(&ihp->hba_sess_list_rwlock); 2083 if (iscsiboot_prop) { 2084 if (iscsi_cmp_boot_sess_oid(ihp, e.e_oid)) { 2085 /* 2086 * found active session for this object 2087 * or this is initiator object 2088 * with mpxio enabled 2089 */ 2090 if (!iscsi_reconfig_boot_sess(ihp)) { 2091 rtn = EINVAL; 2092 break; 2093 } 2094 } 2095 } 2096 } 2097 break; 2098 2099 /* 2100 * ISCSI_TARGET_OID_LIST_GET - 2101 */ 2102 case ISCSI_TARGET_OID_LIST_GET: 2103 /* copyin user args */ 2104 if (ddi_copyin((caddr_t)arg, &idl, 2105 sizeof (idl), mode)) { 2106 rtn = EFAULT; 2107 break; 2108 } 2109 2110 if (idl.tl_vers != ISCSI_INTERFACE_VERSION) { 2111 rtn = EINVAL; 2112 break; 2113 } 2114 2115 list_space = sizeof (iscsi_target_list_t); 2116 if (idl.tl_in_cnt != 0) 2117 list_space += (sizeof (uint32_t) * 2118 (idl.tl_in_cnt - 1)); 2119 2120 idlp = kmem_zalloc(list_space, KM_SLEEP); 2121 bcopy(&idl, idlp, sizeof (idl)); 2122 idlp->tl_out_cnt = 0; 2123 2124 /* 2125 * If target list type is ISCSI_TGT_OID_LIST and discovery 2126 * has not been completed or in progress, poke the discovery 2127 * methods so target information is returned 2128 */ 2129 mutex_enter(&ihp->hba_discovery_events_mutex); 2130 method = ihp->hba_discovery_events; 2131 if ((idl.tl_tgt_list_type == ISCSI_TGT_OID_LIST) && 2132 (method != ISCSI_ALL_DISCOVERY_METHODS) && 2133 (ihp->hba_discovery_in_progress == B_FALSE)) { 2134 ihp->hba_discovery_in_progress = B_TRUE; 2135 mutex_exit(&ihp->hba_discovery_events_mutex); 2136 iscsid_poke_discovery(ihp, iSCSIDiscoveryMethodUnknown); 2137 mutex_enter(&ihp->hba_discovery_events_mutex); 2138 ihp->hba_discovery_in_progress = B_FALSE; 2139 } 2140 mutex_exit(&ihp->hba_discovery_events_mutex); 2141 2142 /* 2143 * Return the correct list information based on the type 2144 */ 2145 switch (idl.tl_tgt_list_type) { 2146 /* ISCSI_TGT_PARAM_OID_LIST - iscsiadm list target-params */ 2147 case ISCSI_TGT_PARAM_OID_LIST: 2148 /* get params from persistent store */ 2149 iscsi_targetparam_lock_list(RW_READER); 2150 curr_entry = iscsi_targetparam_get_next_entry(NULL); 2151 while (curr_entry != NULL) { 2152 if (idlp->tl_out_cnt < idlp->tl_in_cnt) { 2153 idlp->tl_oid_list[idlp->tl_out_cnt] = 2154 curr_entry->target_oid; 2155 } 2156 idlp->tl_out_cnt++; 2157 curr_entry = iscsi_targetparam_get_next_entry( 2158 curr_entry); 2159 } 2160 iscsi_targetparam_unlock_list(); 2161 break; 2162 2163 /* ISCSI_STATIC_TGT_OID_LIST - iscsiadm list static-config */ 2164 case ISCSI_STATIC_TGT_OID_LIST: 2165 { 2166 char *target_name = NULL; 2167 void *v = NULL; 2168 2169 /* get static-config from persistent store */ 2170 target_name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP); 2171 persistent_static_addr_lock(); 2172 while (persistent_static_addr_next(&v, 2173 (char *)target_name, &e) == B_TRUE) { 2174 2175 if (idlp->tl_out_cnt < idlp->tl_in_cnt) { 2176 idlp->tl_oid_list[idlp->tl_out_cnt] = 2177 e.e_oid; 2178 } 2179 idlp->tl_out_cnt++; 2180 2181 } 2182 2183 persistent_static_addr_unlock(); 2184 kmem_free(target_name, ISCSI_MAX_NAME_LEN); 2185 break; 2186 } 2187 2188 /* ISCSI_TGT_OID_LIST - iscsiadm list target */ 2189 case ISCSI_TGT_OID_LIST: 2190 2191 /* get sessions from hba's session list */ 2192 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 2193 for (isp = ihp->hba_sess_list; isp; 2194 isp = isp->sess_next) { 2195 2196 if (((isp->sess_state != 2197 ISCSI_SESS_STATE_FREE) || 2198 (isp->sess_discovered_by != 2199 iSCSIDiscoveryMethodUnknown)) && 2200 (isp->sess_type == 2201 ISCSI_SESS_TYPE_NORMAL)) { 2202 if (idlp->tl_out_cnt < 2203 idlp->tl_in_cnt) { 2204 idlp->tl_oid_list[ 2205 idlp->tl_out_cnt] = 2206 isp->sess_oid; 2207 } 2208 idlp->tl_out_cnt++; 2209 } 2210 2211 } 2212 rw_exit(&ihp->hba_sess_list_rwlock); 2213 break; 2214 2215 default: 2216 ASSERT(FALSE); 2217 } 2218 2219 rtn = ddi_copyout(idlp, (caddr_t)arg, list_space, mode); 2220 kmem_free(idlp, list_space); 2221 break; 2222 2223 /* 2224 * ISCSI_TARGET_PROPS_GET - 2225 */ 2226 case ISCSI_TARGET_PROPS_GET: 2227 /* ---- fall through sense the code is almost the same ---- */ 2228 2229 /* 2230 * ISCSI_TARGET_PROPS_SET - 2231 */ 2232 case ISCSI_TARGET_PROPS_SET: 2233 /* copyin user args */ 2234 ipp = (iscsi_property_t *)kmem_alloc(sizeof (*ipp), 2235 KM_SLEEP); 2236 if (ddi_copyin((caddr_t)arg, ipp, sizeof (*ipp), mode)) { 2237 rtn = EFAULT; 2238 kmem_free(ipp, sizeof (*ipp)); 2239 break; 2240 } 2241 2242 if (ipp->p_vers != ISCSI_INTERFACE_VERSION) { 2243 rtn = EINVAL; 2244 kmem_free(ipp, sizeof (*ipp)); 2245 break; 2246 } 2247 2248 rtn = iscsi_target_prop_mod(ihp, ipp, cmd); 2249 if (rtn == 0) 2250 rtn = ddi_copyout(ipp, (caddr_t)arg, 2251 sizeof (*ipp), mode); 2252 kmem_free(ipp, sizeof (*ipp)); 2253 break; 2254 2255 /* 2256 * ISCSI_TARGET_ADDRESS_GET - 2257 */ 2258 case ISCSI_TARGET_ADDRESS_GET: 2259 if (ddi_copyin((caddr_t)arg, &ial, sizeof (ial), mode)) { 2260 rtn = EFAULT; 2261 break; 2262 } 2263 2264 if (ial.al_vers != ISCSI_INTERFACE_VERSION) { 2265 rtn = EINVAL; 2266 break; 2267 } 2268 2269 /* 2270 * Find out how much space we need to malloc for the users 2271 * request. 2272 */ 2273 list_space = sizeof (iscsi_addr_list_t); 2274 if (ial.al_in_cnt != 0) { 2275 list_space += (sizeof (iscsi_addr_t) * 2276 (ial.al_in_cnt - 1)); 2277 } 2278 ialp = (iscsi_addr_list_t *)kmem_zalloc(list_space, KM_SLEEP); 2279 2280 /* Copy in the header portion */ 2281 bcopy(&ial, ialp, sizeof (ial)); 2282 2283 /* session */ 2284 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 2285 rtn = iscsi_sess_get(ialp->al_oid, ihp, &isp); 2286 if (rtn != 0) { 2287 rw_exit(&ihp->hba_sess_list_rwlock); 2288 rtn = EFAULT; 2289 break; 2290 } 2291 2292 ialp->al_out_cnt = 0; 2293 ialp->al_tpgt = isp->sess_tpgt_conf; 2294 rw_enter(&isp->sess_conn_list_rwlock, RW_READER); 2295 for (icp = isp->sess_conn_list; icp; icp = icp->conn_next) { 2296 if (icp->conn_state != ISCSI_CONN_STATE_LOGGED_IN) { 2297 continue; 2298 } 2299 if (ialp->al_out_cnt < ialp->al_in_cnt) { 2300 iscsi_addr_t *ap; 2301 2302 ap = &ialp->al_addrs[ialp->al_out_cnt]; 2303 if (icp->conn_base_addr.sin.sa_family 2304 == AF_INET) { 2305 2306 struct sockaddr_in *addr_in = 2307 (struct sockaddr_in *)&icp-> 2308 conn_base_addr.sin4; 2309 ap->a_addr.i_insize = 2310 sizeof (struct in_addr); 2311 bcopy(&addr_in->sin_addr.s_addr, 2312 &ap->a_addr.i_addr.in4.s_addr, 2313 sizeof (struct in_addr)); 2314 ap->a_port = addr_in->sin_port; 2315 2316 } else { 2317 2318 struct sockaddr_in6 *addr_in6 = 2319 (struct sockaddr_in6 *)&icp-> 2320 conn_base_addr.sin6; 2321 ap->a_addr.i_insize = 2322 sizeof (struct in6_addr); 2323 bcopy(&addr_in6->sin6_addr.s6_addr, 2324 &ap->a_addr.i_addr.in6.s6_addr, 2325 sizeof (struct in6_addr)); 2326 ap->a_port = addr_in6->sin6_port; 2327 2328 } 2329 } 2330 ialp->al_out_cnt++; 2331 } 2332 rw_exit(&isp->sess_conn_list_rwlock); 2333 rw_exit(&ihp->hba_sess_list_rwlock); 2334 2335 rtn = ddi_copyout(ialp, (caddr_t)arg, list_space, mode); 2336 kmem_free(ialp, list_space); 2337 break; 2338 2339 /* 2340 * ISCSI_CHAP_SET - 2341 */ 2342 case ISCSI_CHAP_SET: 2343 chap = (iscsi_chap_props_t *)kmem_zalloc(sizeof (*chap), 2344 KM_SLEEP); 2345 if (ddi_copyin((caddr_t)arg, chap, sizeof (*chap), mode)) { 2346 rtn = EFAULT; 2347 kmem_free(chap, sizeof (*chap)); 2348 break; 2349 } else if (chap->c_vers != ISCSI_INTERFACE_VERSION) { 2350 rtn = EINVAL; 2351 kmem_free(chap, sizeof (*chap)); 2352 break; 2353 } 2354 2355 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 2356 if (chap->c_oid == ihp->hba_oid) 2357 name = ihp->hba_name; 2358 else { 2359 rtn = iscsi_sess_get(chap->c_oid, ihp, &isp); 2360 if (rtn != 0) { 2361 rtn = iscsi_sess_get_by_target( 2362 chap->c_oid, ihp, &isp); 2363 } 2364 2365 /* 2366 * If rtn is zero then we have found an 2367 * existing session. Use the session name to 2368 * do param lookup. If rtn is non-zero then 2369 * create a targetparam object and use its name 2370 * for param lookup. 2371 */ 2372 if (rtn == 0) { 2373 name = isp->sess_name; 2374 } else { 2375 name = 2376 iscsi_targetparam_get_name(chap->c_oid); 2377 rtn = 0; 2378 } 2379 } 2380 2381 if (name == NULL) { 2382 rw_exit( 2383 &ihp->hba_sess_list_rwlock); 2384 rtn = EFAULT; 2385 kmem_free(chap, sizeof (*chap)); 2386 break; 2387 } 2388 2389 if (persistent_chap_set((char *)name, chap) == 2390 B_FALSE) { 2391 rtn = EIO; 2392 } 2393 rw_exit(&ihp->hba_sess_list_rwlock); 2394 kmem_free(chap, sizeof (*chap)); 2395 break; 2396 2397 /* 2398 * ISCSI_CHAP_GET - 2399 */ 2400 case ISCSI_CHAP_GET: 2401 chap = (iscsi_chap_props_t *)kmem_zalloc(sizeof (*chap), 2402 KM_SLEEP); 2403 if (ddi_copyin((caddr_t)arg, chap, sizeof (*chap), mode)) { 2404 kmem_free(chap, sizeof (*chap)); 2405 rtn = EFAULT; 2406 break; 2407 } else if (chap->c_vers != ISCSI_INTERFACE_VERSION) { 2408 kmem_free(chap, sizeof (*chap)); 2409 rtn = EINVAL; 2410 break; 2411 } 2412 2413 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 2414 if (chap->c_oid == ihp->hba_oid) 2415 name = ihp->hba_name; 2416 else { 2417 rtn = iscsi_sess_get(chap->c_oid, ihp, &isp); 2418 if (rtn != 0) { 2419 rtn = iscsi_sess_get_by_target( 2420 chap->c_oid, ihp, &isp); 2421 } 2422 2423 /* 2424 * If rtn is zero then we have found an 2425 * existing session. Use the session name to 2426 * do param lookup. If rtn is non-zero then 2427 * create a targetparam object and use its name 2428 * for param lookup. 2429 */ 2430 if (rtn == 0) { 2431 name = isp->sess_name; 2432 } else { 2433 rtn = 0; 2434 name = 2435 iscsi_targetparam_get_name(chap->c_oid); 2436 } 2437 2438 if (name == NULL) { 2439 rw_exit(&ihp->hba_sess_list_rwlock); 2440 rtn = EFAULT; 2441 break; 2442 } 2443 /* 2444 * Initialize the target-side chap name to the 2445 * session name if no chap settings have been 2446 * saved for the current session. 2447 */ 2448 if (persistent_chap_get((char *)name, 2449 chap) == B_FALSE) { 2450 int name_len = strlen((char *)name); 2451 iscsi_chap_props_t *chap = NULL; 2452 chap = (iscsi_chap_props_t *)kmem_zalloc 2453 (sizeof (iscsi_chap_props_t), KM_SLEEP); 2454 bcopy((char *)name, chap->c_user, name_len); 2455 chap->c_user_len = name_len; 2456 (void) (persistent_chap_set((char *)name, 2457 chap)); 2458 kmem_free(chap, sizeof (*chap)); 2459 } 2460 } 2461 2462 if (name == NULL) { 2463 rw_exit( 2464 &ihp->hba_sess_list_rwlock); 2465 rtn = EFAULT; 2466 break; 2467 } 2468 2469 if (persistent_chap_get((char *)name, chap) == B_FALSE) { 2470 rw_exit(&ihp->hba_sess_list_rwlock); 2471 rtn = EIO; 2472 break; 2473 } 2474 rw_exit(&ihp->hba_sess_list_rwlock); 2475 2476 rtn = ddi_copyout(chap, (caddr_t)arg, sizeof (*chap), mode); 2477 kmem_free(chap, sizeof (*chap)); 2478 break; 2479 2480 /* 2481 * ISCSI_CHAP_CLEAR - 2482 */ 2483 case ISCSI_CHAP_CLEAR: 2484 chap = (iscsi_chap_props_t *)kmem_zalloc(sizeof (*chap), 2485 KM_SLEEP); 2486 if (ddi_copyin((caddr_t)arg, chap, sizeof (*chap), mode)) { 2487 rtn = EFAULT; 2488 kmem_free(chap, sizeof (*chap)); 2489 break; 2490 } else if (chap->c_vers != ISCSI_INTERFACE_VERSION) { 2491 rtn = EINVAL; 2492 kmem_free(chap, sizeof (*chap)); 2493 break; 2494 } 2495 2496 if (chap->c_oid == ihp->hba_oid) { 2497 iscsi_sess_t *sessp; 2498 2499 name = ihp->hba_name; 2500 2501 if (persistent_chap_clear( 2502 (char *)name) == B_FALSE) { 2503 rtn = EIO; 2504 } 2505 2506 /* 2507 * Loop through all sessions and memset their 2508 * (initiator's) passwords 2509 */ 2510 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 2511 for (sessp = ihp->hba_sess_list; sessp; 2512 sessp = sessp->sess_next) { 2513 (void) memset(sessp->sess_auth.password, 2514 0, iscsiAuthStringMaxLength); 2515 sessp->sess_auth.password_length = 0; 2516 } 2517 rw_exit(&ihp->hba_sess_list_rwlock); 2518 2519 } else { 2520 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 2521 /* 2522 * If the oid does represent a session check to see 2523 * if it is a target oid. If so, return the target's 2524 * associated session. 2525 */ 2526 rtn = iscsi_sess_get(chap->c_oid, ihp, &isp); 2527 if (rtn != 0) { 2528 rtn = iscsi_sess_get_by_target(chap->c_oid, 2529 ihp, &isp); 2530 } 2531 2532 rw_exit(&ihp->hba_sess_list_rwlock); 2533 2534 /* 2535 * If rtn is zero then we have found an 2536 * existing session. Use the session name to 2537 * do param lookup. If rtn is non-zero then 2538 * create a targetparam object and use its name 2539 * for param lookup. 2540 */ 2541 if (rtn == 0) { 2542 name = isp->sess_name; 2543 } else { 2544 name = 2545 iscsi_targetparam_get_name(chap->c_oid); 2546 rtn = 0; 2547 } 2548 2549 if (name == NULL) { 2550 rtn = EFAULT; 2551 break; 2552 } 2553 2554 if (persistent_chap_clear( 2555 (char *)name) == B_FALSE) { 2556 rtn = EIO; 2557 } 2558 2559 /* 2560 * Clear out session chap password if we found a 2561 * session above. 2562 */ 2563 if (isp != NULL) { 2564 (void) memset(isp->sess_auth.password_in, 2565 0, iscsiAuthStringMaxLength); 2566 isp->sess_auth.password_length_in = 0; 2567 } 2568 2569 } 2570 2571 kmem_free(chap, sizeof (*chap)); 2572 break; 2573 2574 /* 2575 * ISCSI_STATIC_GET - 2576 */ 2577 case ISCSI_STATIC_GET: 2578 ispp = (iscsi_static_property_t *)kmem_alloc( 2579 sizeof (*ispp), KM_SLEEP); 2580 2581 if (ddi_copyin((caddr_t)arg, ispp, sizeof (*ispp), mode)) { 2582 rtn = EFAULT; 2583 kmem_free(ispp, sizeof (*ispp)); 2584 break; 2585 } 2586 2587 if (ispp->p_vers != ISCSI_INTERFACE_VERSION) { 2588 rtn = EINVAL; 2589 kmem_free(ispp, sizeof (*ispp)); 2590 break; 2591 } 2592 2593 { 2594 void *v = NULL; 2595 boolean_t found = B_FALSE; 2596 2597 persistent_static_addr_lock(); 2598 while (persistent_static_addr_next(&v, 2599 (char *)ispp->p_name, &e) == B_TRUE) { 2600 2601 if (ispp->p_oid == e.e_oid) { 2602 /* 2603 * In case there are multiple 2604 * addresses associated with the 2605 * given target OID, pick the first 2606 * one. 2607 */ 2608 iscsi_addr_t *ap; 2609 2610 ap = &(ispp->p_addr_list.al_addrs[0]); 2611 ap->a_port = e.e_port; 2612 ap->a_addr.i_insize = e.e_insize; 2613 bcopy(e.e_u.u_in6.s6_addr, 2614 ap->a_addr.i_addr.in6.s6_addr, 2615 e.e_insize); 2616 ispp->p_name_len = 2617 strlen((char *)ispp->p_name); 2618 ispp->p_addr_list.al_tpgt = e.e_tpgt; 2619 ispp->p_addr_list.al_out_cnt = 1; 2620 2621 found = B_TRUE; 2622 break; 2623 } 2624 } 2625 persistent_static_addr_unlock(); 2626 2627 if (found == B_TRUE) { 2628 rtn = ddi_copyout(ispp, (caddr_t)arg, 2629 sizeof (*ispp), mode); 2630 } else { 2631 rtn = ENOENT; 2632 } 2633 } 2634 kmem_free(ispp, sizeof (*ispp)); 2635 2636 break; 2637 2638 /* 2639 * ISCSI_STATIC_SET - 2640 */ 2641 case ISCSI_STATIC_SET: 2642 target = iscsi_ioctl_copyin((caddr_t)arg, mode, 2643 sizeof (*target)); 2644 if (target == NULL) { 2645 rtn = EFAULT; 2646 break; 2647 } 2648 2649 if ((target->te_entry.e_vers != ISCSI_INTERFACE_VERSION) || 2650 (target->te_entry.e_insize == 0)) { 2651 kmem_free(target, sizeof (*target)); 2652 rtn = EINVAL; 2653 break; 2654 } 2655 2656 /* Check if the target's already been added */ 2657 { 2658 boolean_t static_target_found = B_FALSE; 2659 void *v = NULL; 2660 2661 name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP); 2662 persistent_static_addr_lock(); 2663 while (persistent_static_addr_next(&v, (char *)name, 2664 &e) == B_TRUE) { 2665 /* 2666 * MC/S - Need to check IP address and port 2667 * number as well when we support MC/S. 2668 */ 2669 if ((strncmp((char *)name, 2670 (char *)target->te_name, 2671 ISCSI_MAX_NAME_LEN) == 0) && 2672 (target->te_entry.e_tpgt == e.e_tpgt) && 2673 (target->te_entry.e_insize == e.e_insize) && 2674 (bcmp(&target->te_entry.e_u, &e.e_u, 2675 e.e_insize) == 0)) { 2676 /* 2677 * We don't allow MC/S for now but 2678 * we do allow adding the same target 2679 * with different TPGTs (hence, 2680 * different sessions). 2681 */ 2682 static_target_found = B_TRUE; 2683 break; 2684 } 2685 } 2686 persistent_static_addr_unlock(); 2687 kmem_free(name, ISCSI_MAX_NAME_LEN); 2688 2689 if (static_target_found == B_TRUE) { 2690 /* Duplicate entry */ 2691 kmem_free(target, sizeof (*target)); 2692 rtn = EEXIST; 2693 break; 2694 } 2695 } 2696 2697 if (target->te_entry.e_oid == ISCSI_OID_NOTSET) { 2698 mutex_enter(&iscsi_oid_mutex); 2699 target->te_entry.e_oid = iscsi_oid++; 2700 mutex_exit(&iscsi_oid_mutex); 2701 } 2702 2703 persistent_static_addr_lock(); 2704 if (persistent_static_addr_set((char *)target->te_name, 2705 &target->te_entry) == B_FALSE) { 2706 persistent_static_addr_unlock(); 2707 kmem_free(target, sizeof (*target)); 2708 rtn = EIO; 2709 break; 2710 } 2711 persistent_static_addr_unlock(); 2712 2713 /* 2714 * If Static Targets discovery is enabled, then add 2715 * target to discovery queue. Otherwise, just create 2716 * the session for potential future use. 2717 */ 2718 method = persistent_disc_meth_get(); 2719 if (method & iSCSIDiscoveryMethodStatic) { 2720 iscsid_poke_discovery(ihp, iSCSIDiscoveryMethodStatic); 2721 (void) iscsid_login_tgt(ihp, (char *)target->te_name, 2722 iSCSIDiscoveryMethodStatic, NULL); 2723 } 2724 2725 rtn = iscsi_ioctl_copyout(target, sizeof (*target), 2726 (caddr_t)arg, mode); 2727 break; 2728 2729 /* 2730 * ISCSI_STATIC_CLEAR - 2731 */ 2732 case ISCSI_STATIC_CLEAR: 2733 if (ddi_copyin((caddr_t)arg, &e, sizeof (e), mode)) { 2734 rtn = EFAULT; 2735 break; 2736 } else if (e.e_vers != ISCSI_INTERFACE_VERSION) { 2737 rtn = EINVAL; 2738 break; 2739 } 2740 2741 { 2742 boolean_t found = B_FALSE; 2743 void *v = NULL; 2744 entry_t tmp_e; 2745 char *name = NULL; 2746 2747 name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP); 2748 2749 /* Find name for matching static_tgt oid */ 2750 persistent_static_addr_lock(); 2751 while (persistent_static_addr_next(&v, 2752 (char *)name, &tmp_e) == B_TRUE) { 2753 if (e.e_oid == tmp_e.e_oid) { 2754 found = B_TRUE; 2755 break; 2756 } 2757 } 2758 2759 /* If static_tgt found logout and remove it */ 2760 if (found == B_TRUE) { 2761 2762 iscsid_addr_to_sockaddr(tmp_e.e_insize, 2763 &tmp_e.e_u, tmp_e.e_port, &addr_dsc.sin); 2764 2765 persistent_static_addr_unlock(); 2766 2767 /* 2768 * If discovery in progress, try few times 2769 * before return busy 2770 */ 2771 retry = 0; 2772 mutex_enter(&ihp->hba_discovery_events_mutex); 2773 while (ihp->hba_discovery_in_progress == 2774 B_TRUE) { 2775 if (++retry == 5) { 2776 rtn = EBUSY; 2777 break; 2778 } 2779 mutex_exit( 2780 &ihp->hba_discovery_events_mutex); 2781 delay(SEC_TO_TICK( 2782 ISCSI_DISC_DELAY)); 2783 mutex_enter( 2784 &ihp->hba_discovery_events_mutex); 2785 } 2786 /* remove from persistent store */ 2787 if (rtn == 0 && persistent_static_addr_clear( 2788 e.e_oid) == B_FALSE) { 2789 rtn = EIO; 2790 } 2791 mutex_exit(&ihp->hba_discovery_events_mutex); 2792 2793 if (rtn != 0) { 2794 kmem_free(name, ISCSI_MAX_NAME_LEN); 2795 break; 2796 } 2797 2798 /* Attempt to logout of target */ 2799 if (iscsid_del(ihp, (char *)name, 2800 iSCSIDiscoveryMethodStatic, &addr_dsc.sin) 2801 == B_FALSE) { 2802 persistent_static_addr_lock(); 2803 2804 /* 2805 * Restore static_tgt to 2806 * persistent store 2807 */ 2808 if (persistent_static_addr_set( 2809 (char *)name, 2810 &tmp_e) == B_FALSE) { 2811 cmn_err(CE_WARN, "Failed to " 2812 "restore static target " 2813 "address after logout " 2814 "target failure."); 2815 } 2816 persistent_static_addr_unlock(); 2817 rtn = EBUSY; 2818 } else { 2819 iscsid_poke_discovery(ihp, 2820 iSCSIDiscoveryMethodStatic); 2821 (void) iscsid_login_tgt(ihp, 2822 (char *)name, 2823 iSCSIDiscoveryMethodStatic, 2824 NULL); 2825 2826 } 2827 } else { 2828 persistent_static_addr_unlock(); 2829 rtn = EIO; 2830 } 2831 kmem_free(name, ISCSI_MAX_NAME_LEN); 2832 } 2833 break; 2834 2835 /* 2836 * ISCSI_ISNS_SERVER_ADDR_SET: 2837 */ 2838 case ISCSI_ISNS_SERVER_ADDR_SET: 2839 if (ddi_copyin((caddr_t)arg, &e, sizeof (e), mode)) { 2840 rtn = EFAULT; 2841 break; 2842 } else if (e.e_vers != ISCSI_INTERFACE_VERSION) { 2843 rtn = EINVAL; 2844 break; 2845 } 2846 2847 if (persistent_isns_addr_set(&e) == B_FALSE) { 2848 rtn = EIO; 2849 break; 2850 } 2851 2852 /* 2853 * If iSNS server discovery is enabled, then kickoff 2854 * discovery of the targets advertised by the recently 2855 * added iSNS server address. 2856 */ 2857 method = persistent_disc_meth_get(); 2858 if (method & iSCSIDiscoveryMethodISNS) { 2859 initiator_node_name = kmem_zalloc(ISCSI_MAX_NAME_LEN, 2860 KM_SLEEP); 2861 if (persistent_initiator_name_get(initiator_node_name, 2862 ISCSI_MAX_NAME_LEN) != B_TRUE) { 2863 kmem_free(initiator_node_name, 2864 ISCSI_MAX_NAME_LEN); 2865 initiator_node_name = NULL; 2866 rtn = EIO; 2867 break; 2868 } 2869 if (strlen(initiator_node_name) == 0) { 2870 kmem_free(initiator_node_name, 2871 ISCSI_MAX_NAME_LEN); 2872 initiator_node_name = NULL; 2873 rtn = EIO; 2874 break; 2875 } 2876 2877 initiator_node_alias = kmem_zalloc(ISCSI_MAX_NAME_LEN, 2878 KM_SLEEP); 2879 if (persistent_alias_name_get(initiator_node_alias, 2880 ISCSI_MAX_NAME_LEN) != B_TRUE) { 2881 initiator_node_alias[0] = '\0'; 2882 } 2883 2884 /* 2885 * Register this initiator node against this iSNS 2886 * server. 2887 */ 2888 (void) isns_reg_one_server(&e, ihp->hba_isid, 2889 (uint8_t *)initiator_node_name, 2890 ISCSI_MAX_NAME_LEN, 2891 (uint8_t *)initiator_node_alias, 2892 ISCSI_MAX_NAME_LEN, 2893 ISNS_INITIATOR_NODE_TYPE, 2894 isns_scn_callback); 2895 2896 iscsid_do_isns_query_one_server(ihp, &e); 2897 2898 iscsid_addr_to_sockaddr(e.e_insize, 2899 &e.e_u, e.e_port, &addr_dsc.sin); 2900 2901 (void) iscsid_login_tgt(ihp, NULL, 2902 iSCSIDiscoveryMethodISNS, 2903 &addr_dsc.sin); 2904 2905 /* Done using the name and alias - free them. */ 2906 kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN); 2907 initiator_node_name = NULL; 2908 kmem_free(initiator_node_alias, ISCSI_MAX_NAME_LEN); 2909 initiator_node_alias = NULL; 2910 } 2911 break; 2912 2913 /* 2914 * ISCSI_DISCOVERY_ADDR_SET: 2915 */ 2916 case ISCSI_DISCOVERY_ADDR_SET: 2917 if (ddi_copyin((caddr_t)arg, &e, sizeof (e), mode)) { 2918 rtn = EFAULT; 2919 break; 2920 } else if (e.e_vers != ISCSI_INTERFACE_VERSION) { 2921 rtn = EINVAL; 2922 break; 2923 } 2924 2925 if (e.e_oid == ISCSI_OID_NOTSET) { 2926 mutex_enter(&iscsi_oid_mutex); 2927 e.e_oid = iscsi_oid++; 2928 mutex_exit(&iscsi_oid_mutex); 2929 } 2930 2931 if (persistent_disc_addr_set(&e) == B_FALSE) { 2932 rtn = EIO; 2933 break; 2934 } 2935 2936 /* 2937 * If Send Targets discovery is enabled, then kickoff 2938 * discovery of the targets advertised by the recently 2939 * added discovery address. 2940 */ 2941 method = persistent_disc_meth_get(); 2942 if (method & iSCSIDiscoveryMethodSendTargets) { 2943 2944 iscsid_addr_to_sockaddr(e.e_insize, 2945 &e.e_u, e.e_port, &addr_dsc.sin); 2946 iscsid_do_sendtgts(&e); 2947 (void) iscsid_login_tgt(ihp, NULL, 2948 iSCSIDiscoveryMethodSendTargets, 2949 &addr_dsc.sin); 2950 2951 } 2952 break; 2953 2954 /* 2955 * ISCSI_DISCOVERY_ADDR_LIST_GET 2956 */ 2957 case ISCSI_DISCOVERY_ADDR_LIST_GET: 2958 /* copyin user args */ 2959 if (ddi_copyin((caddr_t)arg, &ial, sizeof (ial), mode)) { 2960 rtn = EFAULT; 2961 break; 2962 } 2963 2964 if (ial.al_vers != ISCSI_INTERFACE_VERSION) { 2965 rtn = EINVAL; 2966 break; 2967 } 2968 2969 list_space = sizeof (iscsi_addr_list_t); 2970 if (ial.al_in_cnt != 0) { 2971 list_space += (sizeof (iscsi_addr_t) * 2972 (ial.al_in_cnt - 1)); 2973 } 2974 2975 ialp = kmem_zalloc(list_space, KM_SLEEP); 2976 bcopy(&ial, ialp, sizeof (iscsi_addr_list_t)); 2977 2978 void_p = NULL; 2979 ialp->al_out_cnt = 0; 2980 persistent_disc_addr_lock(); 2981 while (persistent_disc_addr_next(&void_p, &e) == B_TRUE) { 2982 if (ialp->al_out_cnt < ialp->al_in_cnt) { 2983 int i = ialp->al_out_cnt; 2984 iscsi_addr_t *addr = &ialp->al_addrs[i]; 2985 2986 addr->a_port = e.e_port; 2987 addr->a_addr.i_insize = e.e_insize; 2988 addr->a_oid = e.e_oid; 2989 2990 if (e.e_insize == sizeof (struct in_addr)) { 2991 /* IPv4 */ 2992 addr->a_addr.i_addr.in4.s_addr = 2993 e.e_u.u_in4.s_addr; 2994 } else if (e.e_insize == 2995 sizeof (struct in6_addr)) { 2996 /* IPv6 */ 2997 bcopy(e.e_u.u_in6.s6_addr, 2998 addr->a_addr.i_addr.in6.s6_addr, 2999 16); 3000 } 3001 } 3002 ialp->al_out_cnt++; 3003 } 3004 persistent_disc_addr_unlock(); 3005 3006 rtn = ddi_copyout(ialp, (caddr_t)arg, list_space, mode); 3007 kmem_free(ialp, list_space); 3008 break; 3009 3010 /* 3011 * ISCSI_ISNS_SERVER_ADDR_LIST_GET 3012 */ 3013 case ISCSI_ISNS_SERVER_ADDR_LIST_GET: 3014 /* copyin user args */ 3015 if (ddi_copyin((caddr_t)arg, &ial, sizeof (ial), mode)) { 3016 rtn = EFAULT; 3017 break; 3018 } 3019 3020 if (ial.al_vers != ISCSI_INTERFACE_VERSION) { 3021 rtn = EINVAL; 3022 break; 3023 } 3024 3025 list_space = sizeof (iscsi_addr_list_t); 3026 if (ial.al_in_cnt != 0) { 3027 list_space += (sizeof (iscsi_addr_t) * 3028 (ial.al_in_cnt - 1)); 3029 } 3030 3031 ialp = kmem_zalloc(list_space, KM_SLEEP); 3032 bcopy(&ial, ialp, sizeof (iscsi_addr_list_t)); 3033 3034 void_p = NULL; 3035 ialp->al_out_cnt = 0; 3036 persistent_isns_addr_lock(); 3037 while (persistent_isns_addr_next(&void_p, &e) == B_TRUE) { 3038 if (ialp->al_out_cnt < ialp->al_in_cnt) { 3039 int i = ialp->al_out_cnt; 3040 iscsi_addr_t *addr = &ialp->al_addrs[i]; 3041 3042 addr->a_port = e.e_port; 3043 addr->a_addr.i_insize = e.e_insize; 3044 if (e.e_insize == sizeof (struct in_addr)) { 3045 /* IPv4 */ 3046 addr->a_addr.i_addr.in4.s_addr = 3047 e.e_u.u_in4.s_addr; 3048 } else if (e.e_insize == 3049 sizeof (struct in6_addr)) { 3050 /* IPv6 */ 3051 bcopy(e.e_u.u_in6.s6_addr, 3052 addr->a_addr.i_addr.in6.s6_addr, 3053 16); 3054 } 3055 } 3056 ialp->al_out_cnt++; 3057 } 3058 persistent_isns_addr_unlock(); 3059 3060 rtn = ddi_copyout(ialp, (caddr_t)arg, list_space, mode); 3061 kmem_free(ialp, list_space); 3062 break; 3063 3064 /* 3065 * ISCSI_DISCOVERY_ADDR_CLEAR: 3066 */ 3067 case ISCSI_DISCOVERY_ADDR_CLEAR: 3068 if (ddi_copyin((caddr_t)arg, &e, sizeof (e), mode)) { 3069 rtn = EFAULT; 3070 break; 3071 } else if (e.e_vers != ISCSI_INTERFACE_VERSION) { 3072 rtn = EINVAL; 3073 break; 3074 } 3075 3076 iscsid_addr_to_sockaddr(e.e_insize, 3077 &e.e_u, e.e_port, &addr_dsc.sin); 3078 3079 /* If discovery in progress, try few times before return busy */ 3080 retry = 0; 3081 mutex_enter(&ihp->hba_discovery_events_mutex); 3082 while (ihp->hba_discovery_in_progress == B_TRUE) { 3083 if (++retry == 5) { 3084 rtn = EBUSY; 3085 break; 3086 } 3087 mutex_exit(&ihp->hba_discovery_events_mutex); 3088 delay(SEC_TO_TICK(ISCSI_DISC_DELAY)); 3089 mutex_enter(&ihp->hba_discovery_events_mutex); 3090 } 3091 3092 /* 3093 * Clear discovery address first, so that any bus config 3094 * will ignore this discovery address 3095 */ 3096 if (rtn == 0 && persistent_disc_addr_clear(&e) == B_FALSE) { 3097 rtn = EIO; 3098 } 3099 mutex_exit(&ihp->hba_discovery_events_mutex); 3100 3101 if (rtn != 0) { 3102 break; 3103 } 3104 /* Attempt to logout of associated targets */ 3105 if (iscsid_del(ihp, NULL, 3106 iSCSIDiscoveryMethodSendTargets, &addr_dsc.sin) == 3107 B_FALSE) { 3108 /* Failure!, restore the discovery addr. */ 3109 if (persistent_disc_addr_set(&e) == B_FALSE) { 3110 cmn_err(CE_WARN, "Failed to restore sendtgt " 3111 "discovery address after logout associated " 3112 "targets failures."); 3113 } 3114 rtn = EBUSY; 3115 } 3116 break; 3117 3118 /* 3119 * ISCSI_ISNS_SERVER_CLEAR: 3120 */ 3121 case ISCSI_ISNS_SERVER_ADDR_CLEAR: 3122 if (ddi_copyin((caddr_t)arg, &e, sizeof (e), mode)) { 3123 rtn = EFAULT; 3124 break; 3125 } else if (e.e_vers != ISCSI_INTERFACE_VERSION) { 3126 rtn = EINVAL; 3127 break; 3128 } 3129 3130 iscsid_addr_to_sockaddr(e.e_insize, 3131 &e.e_u, e.e_port, &addr_dsc.sin); 3132 3133 /* If discovery in progress, try few times before return busy */ 3134 retry = 0; 3135 mutex_enter(&ihp->hba_discovery_events_mutex); 3136 while (ihp->hba_discovery_in_progress == B_TRUE) { 3137 if (++retry == 5) { 3138 rtn = EBUSY; 3139 break; 3140 } 3141 mutex_exit(&ihp->hba_discovery_events_mutex); 3142 delay(SEC_TO_TICK(ISCSI_DISC_DELAY)); 3143 mutex_enter(&ihp->hba_discovery_events_mutex); 3144 } 3145 3146 /* 3147 * Clear isns server address first, so that any bus config 3148 * will ignore any target registerd on this isns server 3149 */ 3150 if (rtn == 0 && persistent_isns_addr_clear(&e) == B_FALSE) { 3151 rtn = EIO; 3152 } 3153 mutex_exit(&ihp->hba_discovery_events_mutex); 3154 3155 if (rtn != 0) { 3156 break; 3157 } 3158 3159 /* Attempt logout of associated targets */ 3160 if (iscsid_del(ihp, NULL, iSCSIDiscoveryMethodISNS, 3161 &addr_dsc.sin) == B_FALSE) { 3162 /* Failure!, restore the isns server addr. */ 3163 3164 if (persistent_isns_addr_set(&e) == B_FALSE) { 3165 cmn_err(CE_WARN, "Failed to restore isns server" 3166 " address after logout associated targets" 3167 " failures."); 3168 } 3169 rtn = EBUSY; 3170 } else { 3171 method = persistent_disc_meth_get(); 3172 if (method & iSCSIDiscoveryMethodISNS) { 3173 boolean_t is_last_isns_server_b = 3174 B_FALSE; 3175 int isns_server_count = 0; 3176 void *void_p = NULL; 3177 3178 /* 3179 * Check if the last iSNS server's been 3180 * removed. 3181 */ 3182 { 3183 entry_t tmp_e; 3184 persistent_isns_addr_lock(); 3185 while (persistent_isns_addr_next( 3186 &void_p, &tmp_e) == B_TRUE) { 3187 isns_server_count++; 3188 } 3189 } 3190 persistent_isns_addr_unlock(); 3191 if (isns_server_count == 0) { 3192 is_last_isns_server_b = B_TRUE; 3193 } 3194 3195 /* 3196 * Deregister this node from this iSNS 3197 * server. 3198 */ 3199 initiator_node_name = kmem_zalloc( 3200 ISCSI_MAX_NAME_LEN, KM_SLEEP); 3201 if (persistent_initiator_name_get( 3202 initiator_node_name, 3203 ISCSI_MAX_NAME_LEN) == B_TRUE) { 3204 3205 if (strlen(initiator_node_name) > 0) { 3206 (void) isns_dereg_one_server( 3207 &e, (uint8_t *) 3208 initiator_node_name, 3209 is_last_isns_server_b); 3210 } 3211 } 3212 kmem_free(initiator_node_name, 3213 ISCSI_MAX_NAME_LEN); 3214 initiator_node_name = NULL; 3215 } 3216 } 3217 break; 3218 3219 /* 3220 * ISCSI_DISCOVERY_SET - 3221 */ 3222 case ISCSI_DISCOVERY_SET: 3223 if (ddi_copyin((caddr_t)arg, &method, sizeof (method), mode)) { 3224 rtn = EFAULT; 3225 break; 3226 } 3227 3228 if (persistent_disc_meth_set(method) == B_FALSE) { 3229 rtn = EIO; 3230 } else { 3231 (void) iscsid_enable_discovery(ihp, method, B_FALSE); 3232 iscsid_poke_discovery(ihp, method); 3233 (void) iscsid_login_tgt(ihp, NULL, method, NULL); 3234 } 3235 break; 3236 3237 /* 3238 * ISCSI_DISCOVERY_GET - 3239 */ 3240 case ISCSI_DISCOVERY_GET: 3241 method = persistent_disc_meth_get(); 3242 rtn = ddi_copyout(&method, (caddr_t)arg, 3243 sizeof (method), mode); 3244 break; 3245 3246 /* 3247 * ISCSI_DISCOVERY_CLEAR - 3248 */ 3249 case ISCSI_DISCOVERY_CLEAR: 3250 if (ddi_copyin((caddr_t)arg, &method, sizeof (method), mode)) { 3251 rtn = EFAULT; 3252 break; 3253 } 3254 3255 /* If discovery in progress, try few times before return busy */ 3256 retry = 0; 3257 mutex_enter(&ihp->hba_discovery_events_mutex); 3258 while (ihp->hba_discovery_in_progress == B_TRUE) { 3259 if (++retry == 5) { 3260 rtn = EBUSY; 3261 break; 3262 } 3263 mutex_exit(&ihp->hba_discovery_events_mutex); 3264 delay(SEC_TO_TICK(ISCSI_DISC_DELAY)); 3265 mutex_enter(&ihp->hba_discovery_events_mutex); 3266 } 3267 3268 /* 3269 * Clear discovery first, so that any bus config or 3270 * discovery requests will ignore this discovery method 3271 */ 3272 if (rtn == 0 && persistent_disc_meth_clear(method) == B_FALSE) { 3273 rtn = EIO; 3274 } 3275 mutex_exit(&ihp->hba_discovery_events_mutex); 3276 3277 if (rtn != 0) { 3278 break; 3279 } 3280 3281 /* Attempt to logout from all associated targets */ 3282 if (iscsid_disable_discovery(ihp, method) == B_FALSE) { 3283 /* Failure!, reset the discovery */ 3284 if (persistent_disc_meth_set(method) == B_FALSE) { 3285 cmn_err(CE_WARN, "Failed to reset discovery " 3286 "method after discovery disable failure."); 3287 } 3288 rtn = EBUSY; 3289 } 3290 break; 3291 3292 /* 3293 * ISCSI_DISCOVERY_PROPS - 3294 */ 3295 case ISCSI_DISCOVERY_PROPS: 3296 iscsid_props(&discovery_props); 3297 if (ddi_copyout(&discovery_props, (caddr_t)arg, 3298 sizeof (discovery_props), mode)) 3299 rtn = EFAULT; 3300 break; 3301 3302 /* 3303 * ISCSI_LUN_OID_LIST -- 3304 */ 3305 case ISCSI_LUN_OID_LIST_GET: 3306 ll = (iscsi_lun_list_t *)kmem_alloc(sizeof (*ll), KM_SLEEP); 3307 if (ddi_copyin((caddr_t)arg, ll, sizeof (*ll), mode)) { 3308 rtn = EFAULT; 3309 kmem_free(ll, sizeof (*ll)); 3310 break; 3311 } 3312 3313 if (ll->ll_vers != ISCSI_INTERFACE_VERSION) { 3314 rtn = EINVAL; 3315 kmem_free(ll, sizeof (*ll)); 3316 break; 3317 } 3318 3319 /* 3320 * Find out how much space the user has allocated in their 3321 * structure. Match the same space for our structure. 3322 */ 3323 lun_sz = sizeof (iscsi_lun_list_t); 3324 if (ll->ll_in_cnt > 0) { 3325 lun_sz += (ll->ll_in_cnt - 1) * sizeof (iscsi_if_lun_t); 3326 } 3327 3328 llp = kmem_zalloc(lun_sz, KM_SLEEP); 3329 bcopy(ll, llp, sizeof (*ll)); 3330 kmem_free(ll, sizeof (*ll)); 3331 3332 /* 3333 * Check to see if oid references a target-param oid. If so, 3334 * find the associated session oid before getting lu list. 3335 */ 3336 if (iscsi_targetparam_get_name(llp->ll_tgt_oid) != NULL) { 3337 for (isp = ihp->hba_sess_list; isp; 3338 isp = isp->sess_next) { 3339 if (isp->sess_target_oid == llp->ll_tgt_oid) { 3340 target_oid = isp->sess_oid; 3341 break; 3342 } 3343 } 3344 } else { 3345 target_oid = llp->ll_tgt_oid; 3346 } 3347 3348 3349 /* 3350 * Look at the LUNs attached to the specified target. If there 3351 * is space in the user structure save that information locally. 3352 * Always add up the count to the total. By always adding 3353 * the count this code can be used if ll_in_cnt == 0 and 3354 * the user just wishes to know the appropriate size to 3355 * allocate. 3356 */ 3357 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 3358 for (isp = ihp->hba_sess_list; isp; isp = isp->sess_next) { 3359 if ((llp->ll_all_tgts == B_FALSE) && 3360 (isp->sess_oid != target_oid)) { 3361 continue; 3362 } 3363 rw_enter(&isp->sess_lun_list_rwlock, RW_READER); 3364 for (ilp = isp->sess_lun_list; ilp; 3365 ilp = ilp->lun_next) { 3366 if ((ilp->lun_state & 3367 ISCSI_LUN_STATE_ONLINE) && 3368 !(ilp->lun_state & 3369 ISCSI_LUN_STATE_INVALID)) { 3370 if (llp->ll_out_cnt < 3371 llp->ll_in_cnt) { 3372 iscsi_if_lun_t *lp; 3373 lp = &llp->ll_luns[ 3374 llp->ll_out_cnt]; 3375 3376 lp->l_tgt_oid = 3377 isp->sess_oid; 3378 lp->l_oid = ilp->lun_oid; 3379 lp->l_num = ilp->lun_num; 3380 } 3381 llp->ll_out_cnt++; 3382 } 3383 } 3384 rw_exit(&isp->sess_lun_list_rwlock); 3385 } 3386 rw_exit(&ihp->hba_sess_list_rwlock); 3387 3388 if (ddi_copyout(llp, (caddr_t)arg, lun_sz, mode)) { 3389 rtn = EFAULT; 3390 } 3391 3392 kmem_free(llp, lun_sz); 3393 break; 3394 3395 /* 3396 * ISCSI_LUN_PROPS_GET -- 3397 */ 3398 case ISCSI_LUN_PROPS_GET: 3399 lun = (iscsi_lun_props_t *)kmem_zalloc(sizeof (*lun), KM_SLEEP); 3400 if (ddi_copyin((caddr_t)arg, lun, sizeof (*lun), mode)) { 3401 rtn = EFAULT; 3402 kmem_free(lun, sizeof (*lun)); 3403 break; 3404 } 3405 3406 if (lun->lp_vers != ISCSI_INTERFACE_VERSION) { 3407 rtn = EINVAL; 3408 kmem_free(lun, sizeof (*lun)); 3409 break; 3410 } 3411 3412 /* 3413 * For the target specified, find the LUN specified and 3414 * return its properties 3415 */ 3416 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 3417 rtn = iscsi_sess_get(lun->lp_tgt_oid, ihp, &isp); 3418 if (rtn != 0) { 3419 rw_exit(&ihp->hba_sess_list_rwlock); 3420 rtn = EFAULT; 3421 kmem_free(lun, sizeof (*lun)); 3422 break; 3423 } 3424 rtn = EINVAL; /* Set bad rtn, correct only if found */ 3425 rw_enter(&isp->sess_lun_list_rwlock, RW_READER); 3426 for (ilp = isp->sess_lun_list; ilp; ilp = ilp->lun_next) { 3427 if (ilp->lun_oid == lun->lp_oid) { 3428 lun->lp_num = ilp->lun_num; 3429 lun->lp_status = LunValid; 3430 lun->lp_time_online = ilp->lun_time_online; 3431 3432 if (ilp->lun_pip != NULL) { 3433 lun_dip = mdi_pi_get_client( 3434 ilp->lun_pip); 3435 } else { 3436 lun_dip = ilp->lun_dip; 3437 } 3438 3439 if (lun_dip != NULL && 3440 ((i_ddi_devi_attached(lun_dip)) || 3441 (ddi_get_devstate(lun_dip) == 3442 DDI_DEVSTATE_UP))) { 3443 (void) ddi_pathname(lun_dip, 3444 lun->lp_pathname); 3445 } else { 3446 /* 3447 * The LUN is not exported to the 3448 * OS yet. It is in the process 3449 * of being added. 3450 */ 3451 lun->lp_status = LunDoesNotExist; 3452 } 3453 bcopy(ilp->lun_vid, lun->lp_vid, 3454 sizeof (lun->lp_vid)); 3455 bcopy(ilp->lun_pid, lun->lp_pid, 3456 sizeof (lun->lp_pid)); 3457 rtn = ddi_copyout(lun, (caddr_t)arg, 3458 sizeof (*lun), mode); 3459 if (rtn == -1) { 3460 rtn = EFAULT; 3461 } 3462 break; 3463 } 3464 } 3465 rw_exit(&isp->sess_lun_list_rwlock); 3466 rw_exit(&ihp->hba_sess_list_rwlock); 3467 3468 kmem_free(lun, sizeof (*lun)); 3469 break; 3470 3471 /* 3472 * ISCSI_CONN_OID_LIST_GET -- 3473 */ 3474 #define ISCSIIOCOLGC iscsi_ioctl_conn_oid_list_get_copyout 3475 case ISCSI_CONN_OID_LIST_GET: 3476 { 3477 iscsi_conn_list_t *cl; 3478 3479 /* Asuume the worst */ 3480 rtn = EFAULT; 3481 3482 /* Copy the input argument into kernel world. */ 3483 cl = iscsi_ioctl_conn_oid_list_get_copyin( 3484 (caddr_t)arg, 3485 mode); 3486 if (cl != NULL) { 3487 if (iscsi_ioctl_conn_oid_list_get(ihp, cl) == 3488 B_TRUE) { 3489 rtn = 3490 ISCSIIOCOLGC( 3491 cl, (caddr_t)arg, mode); 3492 } 3493 } 3494 break; 3495 } 3496 #undef ISCSIIOCOLGC 3497 /* 3498 * ISCSI_CONN_OID_LIST_GET -- 3499 */ 3500 case ISCSI_CONN_PROPS_GET: 3501 { 3502 iscsi_conn_props_t *cp; 3503 3504 /* Asuume the worst */ 3505 rtn = EFAULT; 3506 3507 /* Copy the input argument into kernel world. */ 3508 cp = iscsi_ioctl_copyin( 3509 (caddr_t)arg, 3510 mode, 3511 sizeof (iscsi_conn_props_t)); 3512 3513 if (cp != NULL) { 3514 /* Get the propereties. */ 3515 if (iscsi_ioctl_conn_props_get(ihp, cp) == 3516 B_TRUE) { 3517 rtn = 3518 iscsi_ioctl_copyout( 3519 cp, 3520 sizeof (*cp), 3521 (caddr_t)arg, 3522 mode); 3523 } else { 3524 kmem_free(cp, sizeof (*cp)); 3525 cp = NULL; 3526 } 3527 } 3528 break; 3529 } 3530 3531 /* 3532 * ISCSI_RADIUS_GET - 3533 */ 3534 case ISCSI_RADIUS_GET: 3535 { 3536 iscsi_nvfile_status_t status; 3537 3538 radius = (iscsi_radius_props_t *)kmem_zalloc(sizeof (*radius), 3539 KM_SLEEP); 3540 if (ddi_copyin((caddr_t)arg, radius, sizeof (*radius), mode)) { 3541 kmem_free(radius, sizeof (*radius)); 3542 rtn = EFAULT; 3543 break; 3544 } else if (radius->r_vers != ISCSI_INTERFACE_VERSION) { 3545 kmem_free(radius, sizeof (*radius)); 3546 rtn = EINVAL; 3547 break; 3548 } 3549 3550 old_oid = radius->r_oid; 3551 3552 if (radius->r_oid == ihp->hba_oid) { 3553 name = ihp->hba_name; 3554 } else { 3555 /* 3556 * RADIUS configuration should be done on a per 3557 * initiator basis. 3558 */ 3559 kmem_free(radius, sizeof (*radius)); 3560 rtn = EINVAL; 3561 break; 3562 } 3563 3564 status = persistent_radius_get(radius); 3565 if (status == ISCSI_NVFILE_SUCCESS) { 3566 /* 3567 * Restore the value for overridden (and bogus) oid. 3568 */ 3569 radius->r_oid = old_oid; 3570 rtn = ddi_copyout(radius, (caddr_t)arg, 3571 sizeof (*radius), mode); 3572 } else if (status == ISCSI_NVFILE_NAMEVAL_NOT_FOUND) { 3573 rtn = ENOENT; 3574 } else { 3575 rtn = EIO; 3576 } 3577 kmem_free(radius, sizeof (*radius)); 3578 break; 3579 } 3580 3581 /* 3582 * ISCSI_RADIUS_SET - 3583 */ 3584 case ISCSI_RADIUS_SET: 3585 radius = (iscsi_radius_props_t *)kmem_zalloc(sizeof (*radius), 3586 KM_SLEEP); 3587 if (ddi_copyin((caddr_t)arg, radius, sizeof (*radius), mode)) { 3588 rtn = EFAULT; 3589 kmem_free(radius, sizeof (*radius)); 3590 break; 3591 } else if (radius->r_vers != ISCSI_INTERFACE_VERSION) { 3592 rtn = EINVAL; 3593 kmem_free(radius, sizeof (*radius)); 3594 break; 3595 } 3596 3597 if (radius->r_oid == ihp->hba_oid) { 3598 name = ihp->hba_name; 3599 } else { 3600 /* 3601 * RADIUS configuration should be done on a per 3602 * initiator basis. 3603 */ 3604 kmem_free(radius, sizeof (*radius)); 3605 rtn = EINVAL; 3606 break; 3607 } 3608 3609 if (persistent_radius_set(radius) == B_FALSE) { 3610 rtn = EIO; 3611 } 3612 3613 kmem_free(radius, sizeof (*radius)); 3614 break; 3615 3616 /* 3617 * ISCSI_AUTH_GET - 3618 */ 3619 case ISCSI_AUTH_GET: 3620 auth = (iscsi_auth_props_t *)kmem_zalloc(sizeof (*auth), 3621 KM_SLEEP); 3622 if (ddi_copyin((caddr_t)arg, auth, sizeof (*auth), mode)) { 3623 kmem_free(auth, sizeof (*auth)); 3624 rtn = EFAULT; 3625 break; 3626 } else if (auth->a_vers != ISCSI_INTERFACE_VERSION) { 3627 kmem_free(auth, sizeof (*auth)); 3628 rtn = EINVAL; 3629 break; 3630 } 3631 3632 old_oid = auth->a_oid; 3633 3634 if (auth->a_oid == ihp->hba_oid) { 3635 name = ihp->hba_name; 3636 } else { 3637 3638 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 3639 /* 3640 * If the oid does represent a session check to see 3641 * if it is a target oid. If so, return the target's 3642 * associated session. 3643 */ 3644 rtn = iscsi_sess_get(auth->a_oid, ihp, &isp); 3645 if (rtn != 0) { 3646 rtn = iscsi_sess_get_by_target(auth->a_oid, 3647 ihp, &isp); 3648 } 3649 rw_exit(&ihp->hba_sess_list_rwlock); 3650 3651 /* 3652 * If rtn is zero then we have found an 3653 * existing session. Use the session name to 3654 * do param lookup. If rtn is non-zero then 3655 * create a targetparam object and use its name 3656 * for param lookup. 3657 */ 3658 if (rtn == 0) { 3659 name = isp->sess_name; 3660 } else { 3661 name = 3662 iscsi_targetparam_get_name(auth->a_oid); 3663 } 3664 } 3665 3666 if (name == NULL) { 3667 rtn = EFAULT; 3668 break; 3669 } 3670 3671 if (persistent_auth_get((char *)name, auth) == B_TRUE) { 3672 /* 3673 * Restore the value for overridden (and bogus) oid. 3674 */ 3675 auth->a_oid = old_oid; 3676 rtn = ddi_copyout(auth, (caddr_t)arg, 3677 sizeof (*auth), mode); 3678 } else { 3679 rtn = EIO; 3680 } 3681 3682 kmem_free(auth, sizeof (*auth)); 3683 break; 3684 3685 /* 3686 * ISCSI_AUTH_SET - 3687 */ 3688 case ISCSI_AUTH_SET: 3689 auth = (iscsi_auth_props_t *)kmem_zalloc(sizeof (*auth), 3690 KM_SLEEP); 3691 if (ddi_copyin((caddr_t)arg, auth, sizeof (*auth), mode)) { 3692 kmem_free(auth, sizeof (*auth)); 3693 rtn = EFAULT; 3694 break; 3695 } else if (auth->a_vers != ISCSI_INTERFACE_VERSION) { 3696 kmem_free(auth, sizeof (*auth)); 3697 rtn = EINVAL; 3698 break; 3699 } 3700 3701 if (auth->a_oid == ihp->hba_oid) { 3702 name = ihp->hba_name; 3703 } else { 3704 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 3705 /* 3706 * If the oid does represent a session check to see 3707 * if it is a target oid. If so, return the target's 3708 * associated session. 3709 */ 3710 rtn = iscsi_sess_get(auth->a_oid, ihp, &isp); 3711 if (rtn != 0) { 3712 rtn = iscsi_sess_get_by_target(auth->a_oid, 3713 ihp, &isp); 3714 } 3715 rw_exit(&ihp->hba_sess_list_rwlock); 3716 3717 /* 3718 * If rtn is zero then we have found an 3719 * existing session. Use the session name to 3720 * do param lookup. If rtn is non-zero then 3721 * create a targetparam object and use its name 3722 * for param lookup. 3723 */ 3724 if (rtn == 0) { 3725 name = isp->sess_name; 3726 } else { 3727 name = 3728 iscsi_targetparam_get_name(auth->a_oid); 3729 rtn = 0; 3730 } 3731 } 3732 3733 if (name == NULL) { 3734 rtn = EFAULT; 3735 } else if (persistent_auth_set((char *)name, auth) 3736 == B_FALSE) { 3737 rtn = EIO; 3738 } 3739 3740 kmem_free(auth, sizeof (*auth)); 3741 break; 3742 3743 /* 3744 * ISCSI_AUTH_CLEAR - 3745 */ 3746 case ISCSI_AUTH_CLEAR: 3747 auth = (iscsi_auth_props_t *)kmem_alloc(sizeof (*auth), 3748 KM_SLEEP); 3749 if (ddi_copyin((caddr_t)arg, auth, sizeof (*auth), mode)) { 3750 kmem_free(auth, sizeof (*auth)); 3751 rtn = EFAULT; 3752 break; 3753 } else if (auth->a_vers != ISCSI_INTERFACE_VERSION) { 3754 kmem_free(auth, sizeof (*auth)); 3755 rtn = EINVAL; 3756 break; 3757 } 3758 3759 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 3760 /* 3761 * If the oid does represent a session check to see 3762 * if it is a target oid. If so, return the target's 3763 * associated session. 3764 */ 3765 rtn = iscsi_sess_get(auth->a_oid, ihp, &isp); 3766 if (rtn != 0) { 3767 rtn = iscsi_sess_get_by_target(auth->a_oid, ihp, &isp); 3768 } 3769 rw_exit(&ihp->hba_sess_list_rwlock); 3770 3771 /* 3772 * If rtn is zero then we have found an 3773 * existing session. Use the session name to 3774 * do param lookup. If rtn is non-zero then 3775 * create a targetparam object and use its name 3776 * for param lookup. 3777 */ 3778 if (rtn == 0) { 3779 name = isp->sess_name; 3780 } else { 3781 name = 3782 iscsi_targetparam_get_name(auth->a_oid); 3783 rtn = 0; 3784 discovered = B_FALSE; 3785 } 3786 3787 if (name == NULL) { 3788 rtn = EFAULT; 3789 break; 3790 } 3791 3792 if (persistent_auth_clear((char *)name) == B_FALSE) { 3793 rtn = EIO; 3794 } 3795 3796 /* 3797 * ISCSI_TARGET_PARAM_CLEAR, ISCSI_CHAP_CLEAR and 3798 * ISCSI_AUTH_CLEAR ioctl are called sequentially to remove 3799 * target parameters. Here, the target that is not discovered 3800 * by initiator should be removed from the iscsi_targets list 3801 * residing in the memory. 3802 */ 3803 if (discovered == B_FALSE) { 3804 (void) iscsi_targetparam_remove_target(auth->a_oid); 3805 } 3806 3807 kmem_free(auth, sizeof (*auth)); 3808 break; 3809 3810 /* 3811 * ISCSI_DB_DUMP - 3812 */ 3813 case ISCSI_DB_DUMP: 3814 persistent_dump_data(); 3815 break; 3816 3817 case ISCSI_USCSI: 3818 3819 #ifdef _MULTI_DATAMODEL 3820 model = ddi_model_convert_from(mode & FMODELS); 3821 switch (model) { 3822 case DDI_MODEL_ILP32: 3823 3824 if (ddi_copyin((caddr_t)arg, &iu32_caller, 3825 sizeof (iscsi_uscsi32_t), mode)) { 3826 rtn = EFAULT; 3827 break; 3828 } 3829 3830 /* perform conversion from 32 -> 64 */ 3831 iu_caller.iu_vers = iu32_caller.iu_vers; 3832 iu_caller.iu_oid = iu32_caller.iu_oid; 3833 iu_caller.iu_tpgt = iu32_caller.iu_tpgt; 3834 iu_caller.iu_len = iu32_caller.iu_len; 3835 iu_caller.iu_lun = iu32_caller.iu_lun; 3836 uscsi_cmd32touscsi_cmd((&iu32_caller.iu_ucmd), 3837 (&iu_caller.iu_ucmd)); 3838 3839 break; 3840 case DDI_MODEL_NONE: 3841 if (ddi_copyin((caddr_t)arg, &iu_caller, 3842 sizeof (iscsi_uscsi_t), mode)) { 3843 rtn = EFAULT; 3844 break; 3845 } 3846 break; 3847 default: 3848 ASSERT(FALSE); 3849 rtn = EINVAL; 3850 break; 3851 } 3852 #endif /* _MULTI_DATAMODEL */ 3853 3854 /* If failures earlier break */ 3855 if (rtn != 0) { 3856 break; 3857 } 3858 3859 /* copy from caller to internel cmd */ 3860 bcopy(&iu_caller, &iu, sizeof (iu)); 3861 3862 if (iu.iu_vers != ISCSI_INTERFACE_VERSION) { 3863 rtn = EINVAL; 3864 break; 3865 } 3866 /* 3867 * Check to see if oid references a target-param oid. If so, 3868 * find the associated session oid before getting lu list. 3869 */ 3870 if (iscsi_targetparam_get_name(iu.iu_oid) != NULL) { 3871 for (isp = ihp->hba_sess_list; isp; isp = 3872 isp->sess_next) { 3873 if (isp->sess_target_oid == iu.iu_oid) { 3874 target_oid = isp->sess_oid; 3875 break; 3876 } 3877 } 3878 } else { 3879 target_oid = iu.iu_oid; 3880 } 3881 3882 /* make sure we have a matching session for this command */ 3883 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 3884 rtn = iscsi_sess_get(target_oid, ihp, &isp); 3885 if (rtn != 0) { 3886 rtn = iscsi_sess_get_by_target(target_oid, ihp, 3887 &isp); 3888 if (rtn != 0) { 3889 rw_exit(&ihp->hba_sess_list_rwlock); 3890 rtn = EFAULT; 3891 break; 3892 } 3893 } 3894 /* 3895 * If a caller buffer is present allocate duplicate 3896 * kernel space and copyin caller memory. 3897 */ 3898 if (iu.iu_ucmd.uscsi_buflen > 0) { 3899 iu.iu_ucmd.uscsi_bufaddr = (caddr_t)kmem_alloc( 3900 iu.iu_ucmd.uscsi_buflen, KM_SLEEP); 3901 if (ddi_copyin(iu_caller.iu_ucmd.uscsi_bufaddr, 3902 iu.iu_ucmd.uscsi_bufaddr, 3903 iu.iu_ucmd.uscsi_buflen, mode)) { 3904 rw_exit(&ihp->hba_sess_list_rwlock); 3905 rtn = EFAULT; 3906 break; 3907 } 3908 } 3909 3910 /* 3911 * If a caller cdb is present allocate duplicate 3912 * kernel space and copyin caller memory. 3913 */ 3914 if (iu.iu_ucmd.uscsi_cdblen > 0) { 3915 iu.iu_ucmd.uscsi_cdb = (caddr_t)kmem_alloc( 3916 iu_caller.iu_ucmd.uscsi_cdblen, KM_SLEEP); 3917 if (ddi_copyin(iu_caller.iu_ucmd.uscsi_cdb, 3918 iu.iu_ucmd.uscsi_cdb, 3919 iu.iu_ucmd.uscsi_cdblen, mode)) { 3920 if (iu.iu_ucmd.uscsi_buflen > 0) { 3921 kmem_free(iu.iu_ucmd.uscsi_bufaddr, 3922 iu_caller.iu_ucmd.uscsi_buflen); 3923 } 3924 rw_exit(&ihp->hba_sess_list_rwlock); 3925 rtn = EFAULT; 3926 break; 3927 } 3928 } 3929 3930 /* 3931 * If a caller request sense is present allocate 3932 * duplicate kernel space. No need to copyin. 3933 */ 3934 if (iu.iu_ucmd.uscsi_rqlen > 0) { 3935 iu.iu_ucmd.uscsi_rqbuf = (caddr_t)kmem_alloc( 3936 iu.iu_ucmd.uscsi_rqlen, KM_SLEEP); 3937 } 3938 3939 /* issue passthru to io path handler */ 3940 rtn = iscsi_handle_passthru(isp, iu.iu_lun, &iu.iu_ucmd); 3941 if (rtn != 0) { 3942 rtn = EFAULT; 3943 } 3944 3945 /* 3946 * If the caller had a buf we need to do a copyout 3947 * and free the kernel memory 3948 */ 3949 if (iu.iu_ucmd.uscsi_buflen > 0) { 3950 if (ddi_copyout(iu.iu_ucmd.uscsi_bufaddr, 3951 iu_caller.iu_ucmd.uscsi_bufaddr, 3952 iu.iu_ucmd.uscsi_buflen, mode) != 0) { 3953 rtn = EFAULT; 3954 } 3955 kmem_free(iu.iu_ucmd.uscsi_bufaddr, 3956 iu.iu_ucmd.uscsi_buflen); 3957 } 3958 3959 /* We need to free kernel cdb, no need to copyout */ 3960 if (iu.iu_ucmd.uscsi_cdblen > 0) { 3961 kmem_free(iu.iu_ucmd.uscsi_cdb, 3962 iu.iu_ucmd.uscsi_cdblen); 3963 } 3964 3965 /* 3966 * If the caller had a request sense we need to 3967 * do a copyout and free the kernel memory 3968 */ 3969 if (iu.iu_ucmd.uscsi_rqlen > 0) { 3970 if (ddi_copyout(iu.iu_ucmd.uscsi_rqbuf, 3971 iu_caller.iu_ucmd.uscsi_rqbuf, 3972 iu.iu_ucmd.uscsi_rqlen - iu.iu_ucmd.uscsi_rqresid, 3973 mode) != 0) { 3974 rtn = EFAULT; 3975 } 3976 kmem_free(iu.iu_ucmd.uscsi_rqbuf, 3977 iu.iu_ucmd.uscsi_rqlen); 3978 } 3979 3980 #ifdef _MULTI_DATAMODEL 3981 switch (model = ddi_model_convert_from(mode & FMODELS)) { 3982 case DDI_MODEL_ILP32: 3983 if (iu.iu_ucmd.uscsi_status != 0) { 3984 iu32_caller.iu_ucmd.uscsi_status = 3985 iu.iu_ucmd.uscsi_status; 3986 iu32_caller.iu_ucmd.uscsi_rqresid = 3987 iu.iu_ucmd.uscsi_rqresid; 3988 } 3989 iu32_caller.iu_ucmd.uscsi_resid = 3990 iu.iu_ucmd.uscsi_resid; 3991 if (ddi_copyout((void *)&iu32_caller, (caddr_t)arg, 3992 sizeof (iscsi_uscsi32_t), mode) != 0) { 3993 rtn = EFAULT; 3994 } 3995 break; 3996 case DDI_MODEL_NONE: 3997 if (iu.iu_ucmd.uscsi_status != 0) { 3998 iu_caller.iu_ucmd.uscsi_status = 3999 iu.iu_ucmd.uscsi_status; 4000 iu_caller.iu_ucmd.uscsi_rqresid = 4001 iu.iu_ucmd.uscsi_rqresid; 4002 } 4003 iu_caller.iu_ucmd.uscsi_resid = iu.iu_ucmd.uscsi_resid; 4004 if (ddi_copyout((void *)&iu_caller, (caddr_t)arg, 4005 sizeof (iscsi_uscsi_t), mode) != 0) { 4006 rtn = EFAULT; 4007 } 4008 break; 4009 default: 4010 ASSERT(FALSE); 4011 } 4012 #endif /* _MULTI_DATAMODEL */ 4013 rw_exit(&ihp->hba_sess_list_rwlock); 4014 break; 4015 4016 case ISCSI_SMF_ONLINE: 4017 if (ddi_copyin((caddr_t)arg, &did, sizeof (int), mode) != 0) { 4018 rtn = EFAULT; 4019 break; 4020 } 4021 /* just a theoretical case */ 4022 if (ihp->hba_persistent_loaded == B_FALSE) { 4023 rtn = EFAULT; 4024 break; 4025 } 4026 4027 /* doesn't need to overwrite the status anymore */ 4028 mutex_enter(&ihp->hba_service_lock); 4029 if (ihp->hba_service_status_overwrite == B_TRUE) { 4030 ihp->hba_service_status = ISCSI_SERVICE_DISABLED; 4031 ihp->hba_service_status_overwrite = B_FALSE; 4032 } 4033 mutex_exit(&ihp->hba_service_lock); 4034 4035 if (iscsi_enter_service_zone(ihp, ISCSI_SERVICE_ENABLED) == 4036 B_FALSE) { 4037 break; 4038 } 4039 4040 rval = iscsi_door_bind(did); 4041 if (rval == B_TRUE) { 4042 rval = iscsid_start(ihp); 4043 if (rval == B_FALSE) { 4044 iscsi_door_unbind(); 4045 } 4046 } 4047 4048 if (rval == B_TRUE) { 4049 iscsi_exit_service_zone(ihp, ISCSI_SERVICE_ENABLED); 4050 } else { 4051 iscsi_exit_service_zone(ihp, ISCSI_SERVICE_DISABLED); 4052 rtn = EFAULT; 4053 } 4054 4055 break; 4056 4057 case ISCSI_SMF_OFFLINE: 4058 if (iscsi_enter_service_zone(ihp, ISCSI_SERVICE_DISABLED) 4059 == B_FALSE) { 4060 break; 4061 } 4062 4063 rval = iscsid_stop(ihp); 4064 iscsi_door_unbind(); 4065 4066 iscsi_exit_service_zone(ihp, ISCSI_SERVICE_DISABLED); 4067 4068 if (ddi_copyout((void *)&rval, (caddr_t)arg, 4069 sizeof (boolean_t), mode) != 0) { 4070 rtn = EFAULT; 4071 } 4072 4073 break; 4074 4075 case ISCSI_SMF_GET: 4076 mutex_enter(&ihp->hba_service_lock); 4077 while (ihp->hba_service_status == 4078 ISCSI_SERVICE_TRANSITION) { 4079 cv_wait(&ihp->hba_service_cv, 4080 &ihp->hba_service_lock); 4081 } 4082 if (ddi_copyout((void *)&ihp->hba_service_status, 4083 (caddr_t)arg, sizeof (boolean_t), mode) != 0) { 4084 rtn = EFAULT; 4085 } 4086 mutex_exit(&ihp->hba_service_lock); 4087 break; 4088 4089 case ISCSI_DISCOVERY_EVENTS: 4090 /* 4091 * If discovery has not been completed and not in progress, 4092 * poke the discovery methods 4093 */ 4094 mutex_enter(&ihp->hba_discovery_events_mutex); 4095 method = ihp->hba_discovery_events; 4096 if ((method != ISCSI_ALL_DISCOVERY_METHODS) && 4097 (ihp->hba_discovery_in_progress == B_FALSE)) { 4098 ihp->hba_discovery_in_progress = B_TRUE; 4099 mutex_exit(&ihp->hba_discovery_events_mutex); 4100 iscsid_poke_discovery(ihp, iSCSIDiscoveryMethodUnknown); 4101 mutex_enter(&ihp->hba_discovery_events_mutex); 4102 ihp->hba_discovery_in_progress = B_FALSE; 4103 method = ihp->hba_discovery_events; 4104 } 4105 mutex_exit(&ihp->hba_discovery_events_mutex); 4106 4107 if (ddi_copyout((void *)&method, (caddr_t)arg, 4108 sizeof (method), mode) != 0) 4109 rtn = EFAULT; 4110 break; 4111 4112 /* 4113 * ISCSI_SENDTGTS_GET -- 4114 */ 4115 case ISCSI_SENDTGTS_GET: 4116 stl_hdr = iscsi_ioctl_copyin((caddr_t)arg, mode, 4117 sizeof (*stl_hdr)); 4118 if (stl_hdr == NULL) { 4119 rtn = EFAULT; 4120 break; 4121 } 4122 4123 if (stl_hdr->stl_entry.e_vers != ISCSI_INTERFACE_VERSION) { 4124 rtn = EINVAL; 4125 kmem_free(stl_hdr, sizeof (*stl_hdr)); 4126 break; 4127 } 4128 4129 /* calculate how much memory user allocated for SendTgts */ 4130 stl_sz = sizeof (*stl_hdr); 4131 if (stl_hdr->stl_in_cnt > 0) { 4132 stl_sz += ((stl_hdr->stl_in_cnt - 1) * 4133 sizeof (iscsi_sendtgts_entry_t)); 4134 } 4135 4136 /* allocate local SendTgts list of the same size */ 4137 istl = kmem_zalloc(stl_sz, KM_SLEEP); 4138 bcopy(stl_hdr, istl, sizeof (*stl_hdr)); 4139 kmem_free(stl_hdr, sizeof (*stl_hdr)); 4140 4141 /* lock interface so only one SendTargets operation occurs */ 4142 sema_p(&ihp->hba_sendtgts_semaphore); 4143 4144 rtn = iscsi_ioctl_sendtgts_get(ihp, istl); 4145 4146 if (rtn == 0) { 4147 rtn = iscsi_ioctl_copyout(istl, stl_sz, 4148 (caddr_t)arg, mode); 4149 } 4150 4151 /* release lock to allow another SendTargets discovery */ 4152 sema_v(&ihp->hba_sendtgts_semaphore); 4153 4154 break; 4155 4156 /* 4157 * ISCSI_ISNS_SERVER_GET -- 4158 */ 4159 case ISCSI_ISNS_SERVER_GET: 4160 server_pg_list_hdr = iscsi_ioctl_copyin((caddr_t)arg, mode, 4161 sizeof (*server_pg_list_hdr)); 4162 if (server_pg_list_hdr == NULL) { 4163 rtn = EFAULT; 4164 break; 4165 } 4166 4167 /* If iSNS discovery mode is not set, return with zero entry */ 4168 method = persistent_disc_meth_get(); 4169 if ((method & iSCSIDiscoveryMethodISNS) == 0) { 4170 kmem_free(server_pg_list_hdr, 4171 sizeof (*server_pg_list_hdr)); 4172 server_pg_list_hdr = NULL; 4173 rtn = EACCES; 4174 break; 4175 } 4176 4177 initiator_node_name = kmem_zalloc(ISCSI_MAX_NAME_LEN, KM_SLEEP); 4178 if (persistent_initiator_name_get(initiator_node_name, 4179 ISCSI_MAX_NAME_LEN) != B_TRUE) { 4180 kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN); 4181 initiator_node_name = NULL; 4182 kmem_free(server_pg_list_hdr, 4183 sizeof (*server_pg_list_hdr)); 4184 server_pg_list_hdr = NULL; 4185 rtn = EIO; 4186 break; 4187 } 4188 if (strlen(initiator_node_name) == 0) { 4189 kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN); 4190 initiator_node_name = NULL; 4191 kmem_free(server_pg_list_hdr, 4192 sizeof (*server_pg_list_hdr)); 4193 server_pg_list_hdr = NULL; 4194 rtn = EIO; 4195 break; 4196 } 4197 4198 initiator_node_alias = kmem_zalloc( 4199 ISCSI_MAX_NAME_LEN, KM_SLEEP); 4200 if (persistent_alias_name_get(initiator_node_alias, 4201 ISCSI_MAX_NAME_LEN) != B_TRUE) { 4202 initiator_node_alias[0] = '\0'; 4203 } 4204 rtn = isns_query_one_server(&(server_pg_list_hdr->addr), 4205 ihp->hba_isid, 4206 (uint8_t *)initiator_node_name, 4207 (uint8_t *)initiator_node_alias, 4208 ISNS_INITIATOR_NODE_TYPE, 4209 &pg_list); 4210 if (rtn != isns_ok || pg_list == NULL) { 4211 kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN); 4212 initiator_node_name = NULL; 4213 kmem_free(initiator_node_alias, ISCSI_MAX_NAME_LEN); 4214 initiator_node_alias = NULL; 4215 kmem_free(server_pg_list_hdr, 4216 sizeof (*server_pg_list_hdr)); 4217 server_pg_list_hdr = NULL; 4218 rtn = EIO; 4219 break; 4220 } 4221 4222 /* 4223 * pg_list_sz is the size of the pg_list returned from the 4224 * isns_query_all 4225 * 4226 * pg_sz_copy_out is the size of the pg_list we are going to 4227 * return back to the caller 4228 * 4229 * server_pg_list_sz is total amount of data we are returning 4230 * back to the caller 4231 */ 4232 pg_list->pg_in_cnt = 4233 server_pg_list_hdr->addr_port_list.pg_in_cnt; 4234 pg_list_sz = sizeof (isns_portal_group_list_t); 4235 if (pg_list->pg_out_cnt > 0) { 4236 pg_list_sz += (pg_list->pg_out_cnt - 1) * 4237 sizeof (isns_portal_group_t); 4238 } 4239 /* 4240 * check if caller passed in a buffer with enough space 4241 * if there isn't enough space, fill the caller's buffer with 4242 * as much information as possible. 4243 * 4244 * if pg_out_cnt > pg_in_cnt, pg_out_cnt will be returned with 4245 * the total number of targets found 4246 * 4247 * if pg_out_cnt < pg_in_cnt, pg_out_cnt will be the number 4248 * of targets returned 4249 */ 4250 if (pg_list->pg_in_cnt < pg_list->pg_out_cnt) { 4251 pg_sz_copy_out = sizeof (isns_portal_group_list_t); 4252 if (pg_list->pg_in_cnt > 0) { 4253 pg_sz_copy_out += (pg_list->pg_in_cnt - 1) * 4254 sizeof (isns_portal_group_t); 4255 } 4256 server_pg_list_sz = 4257 sizeof (isns_server_portal_group_list_t); 4258 if (pg_list->pg_in_cnt > 0) { 4259 server_pg_list_sz += (pg_list->pg_in_cnt - 1) * 4260 sizeof (isns_portal_group_t); 4261 } 4262 } else { 4263 pg_sz_copy_out = pg_list_sz; 4264 server_pg_list_sz = 4265 sizeof (isns_server_portal_group_list_t); 4266 if (pg_list->pg_out_cnt > 0) { 4267 server_pg_list_sz += (pg_list->pg_out_cnt - 1) * 4268 sizeof (isns_portal_group_t); 4269 } 4270 } 4271 4272 server_pg_list = (isns_server_portal_group_list_t *)kmem_zalloc( 4273 server_pg_list_sz, KM_SLEEP); 4274 4275 bcopy(&(server_pg_list_hdr->addr), &(server_pg_list->addr), 4276 sizeof (server_pg_list->addr)); 4277 bcopy(pg_list, &server_pg_list->addr_port_list, pg_sz_copy_out); 4278 4279 if (ddi_copyout(server_pg_list, (caddr_t)arg, server_pg_list_sz, 4280 mode) != 0) { 4281 rtn = EFAULT; 4282 } 4283 DTRACE_PROBE1(iscsi_ioctl_iscsi_isns_server_get_pg_sz, 4284 int, pg_list_sz); 4285 kmem_free(initiator_node_name, ISCSI_MAX_NAME_LEN); 4286 initiator_node_name = NULL; 4287 kmem_free(initiator_node_alias, ISCSI_MAX_NAME_LEN); 4288 initiator_node_alias = NULL; 4289 kmem_free(pg_list, pg_list_sz); 4290 pg_list = NULL; 4291 kmem_free(server_pg_list, server_pg_list_sz); 4292 server_pg_list = NULL; 4293 kmem_free(server_pg_list_hdr, sizeof (*server_pg_list_hdr)); 4294 server_pg_list_hdr = NULL; 4295 break; 4296 4297 /* 4298 * ISCSI_GET_CONFIG_SESSIONS -- 4299 */ 4300 case ISCSI_GET_CONFIG_SESSIONS: 4301 /* FALLTHRU */ 4302 4303 case ISCSI_SET_CONFIG_SESSIONS: 4304 size = sizeof (*ics); 4305 ics = iscsi_ioctl_copyin((caddr_t)arg, mode, size); 4306 if (ics == NULL) { 4307 rtn = EFAULT; 4308 break; 4309 } 4310 4311 /* verify version infomration */ 4312 if (ics->ics_ver != ISCSI_INTERFACE_VERSION) { 4313 rtn = EINVAL; 4314 kmem_free(ics, size); 4315 ics = NULL; 4316 break; 4317 } 4318 4319 /* Check to see if we need to copy in more memory */ 4320 if (ics->ics_in > 1) { 4321 /* record correct size */ 4322 size = ISCSI_SESSION_CONFIG_SIZE(ics->ics_in); 4323 /* free old buffer */ 4324 kmem_free(ics, sizeof (*ics)); 4325 4326 /* copy in complete buffer size */ 4327 ics = iscsi_ioctl_copyin((caddr_t)arg, mode, size); 4328 if (ics == NULL) { 4329 rtn = EFAULT; 4330 break; 4331 } 4332 } 4333 4334 /* switch action based on get or set */ 4335 if (cmd == ISCSI_GET_CONFIG_SESSIONS) { 4336 /* get */ 4337 rtn = iscsi_ioctl_get_config_sess(ihp, ics); 4338 if (rtn == 0) { 4339 /* copyout data for gets */ 4340 rtn = iscsi_ioctl_copyout(ics, size, 4341 (caddr_t)arg, mode); 4342 } else { 4343 kmem_free(ics, size); 4344 ics = NULL; 4345 } 4346 } else { 4347 /* set */ 4348 rtn = iscsi_ioctl_set_config_sess(ihp, ics); 4349 if (iscsiboot_prop) { 4350 if (iscsi_cmp_boot_sess_oid(ihp, 4351 ics->ics_oid)) { 4352 /* 4353 * found active session for this object 4354 * or this is initiator object 4355 * with mpxio enabled 4356 */ 4357 if (!iscsi_reconfig_boot_sess(ihp)) { 4358 kmem_free(ics, size); 4359 ics = NULL; 4360 rtn = EINVAL; 4361 break; 4362 } 4363 } 4364 } 4365 kmem_free(ics, size); 4366 ics = NULL; 4367 } 4368 break; 4369 4370 case ISCSI_IS_ACTIVE: 4371 /* 4372 * dhcpagent calls here to check if there are 4373 * active iSCSI sessions 4374 */ 4375 instance = 0; 4376 if (iscsiboot_prop) { 4377 instance = 1; 4378 } 4379 if (!instance) { 4380 rw_enter(&ihp->hba_sess_list_rwlock, 4381 RW_READER); 4382 for (isp = ihp->hba_sess_list; isp; 4383 isp = isp->sess_next) { 4384 if ((isp->sess_state == 4385 ISCSI_SESS_STATE_LOGGED_IN) && 4386 (isp->sess_lun_list != 4387 NULL)) { 4388 instance = 1; 4389 break; 4390 } 4391 } 4392 rw_exit(&ihp->hba_sess_list_rwlock); 4393 } 4394 size = sizeof (instance); 4395 if (ddi_copyout(&instance, (caddr_t)arg, size, 4396 mode) != 0) { 4397 rtn = EFAULT; 4398 } 4399 break; 4400 4401 case ISCSI_BOOTPROP_GET: 4402 size = sizeof (*bootProp); 4403 bootProp = iscsi_ioctl_copyin((caddr_t)arg, mode, size); 4404 if (bootProp == NULL) { 4405 rtn = EFAULT; 4406 break; 4407 } 4408 bootProp->hba_mpxio_enabled = 4409 iscsi_chk_bootlun_mpxio(ihp); 4410 if (iscsiboot_prop == NULL) { 4411 bootProp->iscsiboot = 0; 4412 rtn = iscsi_ioctl_copyout(bootProp, size, 4413 (caddr_t)arg, mode); 4414 break; 4415 } else { 4416 bootProp->iscsiboot = 1; 4417 } 4418 4419 if (iscsiboot_prop->boot_init.ini_name != NULL) { 4420 (void) strncpy((char *)bootProp->ini_name.n_name, 4421 (char *)iscsiboot_prop->boot_init.ini_name, 4422 ISCSI_MAX_NAME_LEN); 4423 } 4424 if (iscsiboot_prop->boot_init.ini_chap_name != NULL) { 4425 bootProp->auth.a_auth_method = authMethodCHAP; 4426 (void) strncpy((char *)bootProp->ini_chap.c_user, 4427 (char *)iscsiboot_prop->boot_init.ini_chap_name, 4428 ISCSI_MAX_NAME_LEN); 4429 (void) strncpy((char *)bootProp->ini_chap.c_secret, 4430 (char *)iscsiboot_prop->boot_init.ini_chap_sec, 4431 ISCSI_CHAP_SECRET_LEN); 4432 if (iscsiboot_prop->boot_tgt.tgt_chap_name != 4433 NULL) { 4434 bootProp->auth.a_bi_auth = B_TRUE; 4435 } else { 4436 bootProp->auth.a_bi_auth = B_FALSE; 4437 } 4438 } 4439 if (iscsiboot_prop->boot_tgt.tgt_name != NULL) { 4440 (void) strncpy((char *)bootProp->tgt_name.n_name, 4441 (char *)iscsiboot_prop->boot_tgt.tgt_name, 4442 ISCSI_MAX_NAME_LEN); 4443 } 4444 if (iscsiboot_prop->boot_tgt.tgt_chap_name != NULL) { 4445 (void) strncpy((char *)bootProp->tgt_chap.c_user, 4446 (char *)iscsiboot_prop->boot_tgt.tgt_chap_name, 4447 ISCSI_MAX_NAME_LEN); 4448 (void) strncpy((char *)bootProp->tgt_chap.c_secret, 4449 (char *)iscsiboot_prop->boot_tgt.tgt_chap_sec, 4450 ISCSI_CHAP_SECRET_LEN); 4451 } 4452 4453 rtn = iscsi_ioctl_copyout(bootProp, size, (caddr_t)arg, mode); 4454 break; 4455 4456 case ISCSI_TARGET_REENUM: 4457 size = sizeof (iscsi_reen_t); 4458 reenum = (iscsi_reen_t *)kmem_alloc(size, KM_SLEEP); 4459 4460 if (ddi_copyin((caddr_t)arg, reenum, size, mode) != 0) { 4461 rtn = EFAULT; 4462 kmem_free(reenum, size); 4463 break; 4464 } 4465 if (reenum->re_ver != ISCSI_INTERFACE_VERSION) { 4466 rtn = EINVAL; 4467 kmem_free(reenum, size); 4468 break; 4469 } 4470 rw_enter(&ihp->hba_sess_list_rwlock, RW_READER); 4471 rtn = iscsi_sess_get(reenum->re_oid, ihp, &isp); 4472 if (rtn != 0) { 4473 rtn = iscsi_sess_get_by_target( 4474 reenum->re_oid, ihp, &isp); 4475 } 4476 4477 if (rtn != 0) { 4478 rw_exit(&ihp->hba_sess_list_rwlock); 4479 kmem_free(reenum, size); 4480 break; 4481 } 4482 kmem_free(reenum, size); 4483 if (isp->sess_type == ISCSI_SESS_TYPE_NORMAL) { 4484 rw_enter(&isp->sess_state_rwlock, RW_READER); 4485 if ((isp->sess_state == 4486 ISCSI_SESS_STATE_LOGGED_IN) && 4487 (iscsi_sess_enum_request(isp, B_TRUE, 4488 isp->sess_state_event_count) 4489 == ISCSI_SESS_ENUM_SUBMITTED)) { 4490 (void) iscsi_sess_enum_query(isp); 4491 } 4492 rw_exit(&isp->sess_state_rwlock); 4493 } 4494 rw_exit(&ihp->hba_sess_list_rwlock); 4495 break; 4496 4497 case ISCSI_TUNABLE_PARAM_SET: 4498 tpss = (iscsi_tunable_object_t *)kmem_alloc(sizeof (*tpss), 4499 KM_SLEEP); 4500 if (ddi_copyin((caddr_t)arg, tpss, sizeof (*tpss), mode)) { 4501 rtn = EFAULT; 4502 kmem_free(tpss, sizeof (*tpss)); 4503 break; 4504 } 4505 rtn = iscsi_ioctl_set_tunable_param(ihp, tpss); 4506 kmem_free(tpss, sizeof (*tpss)); 4507 break; 4508 4509 case ISCSI_TUNABLE_PARAM_GET: 4510 tpsg = (iscsi_tunable_object_t *)kmem_alloc(sizeof (*tpsg), 4511 KM_SLEEP); 4512 if (ddi_copyin((caddr_t)arg, tpsg, sizeof (*tpsg), mode)) { 4513 rtn = EFAULT; 4514 kmem_free(tpsg, sizeof (*tpsg)); 4515 break; 4516 } 4517 if (tpsg->t_oid == ihp->hba_oid) { 4518 /* initiator */ 4519 name = ihp->hba_name; 4520 if (iscsi_get_persisted_tunable_param((uchar_t *)name, 4521 tpsg) == 1) { 4522 /* 4523 * no persisted tunable parameters found 4524 * for iscsi initiator, use default tunable 4525 * params for initiator node. 4526 */ 4527 iscsi_get_tunable_default(tpsg); 4528 } 4529 } else { 4530 /* check whether it is a target oid */ 4531 name = iscsi_targetparam_get_name(tpsg->t_oid); 4532 if (name == NULL) { 4533 /* invalid node name */ 4534 rtn = EINVAL; 4535 kmem_free(tpsg, sizeof (*tpsg)); 4536 break; 4537 } 4538 if (iscsi_get_persisted_tunable_param((uchar_t *)name, 4539 tpsg) == 1) { 4540 /* 4541 * no persisted tunable parameters found for 4542 * iscsi target, use initiator's configure. 4543 */ 4544 if (iscsi_get_persisted_tunable_param( 4545 (uchar_t *)ihp->hba_name, tpsg) == -1) { 4546 /* 4547 * No initiator tunable parameters set 4548 * use default value for target 4549 */ 4550 iscsi_get_tunable_default(tpsg); 4551 } 4552 } 4553 } 4554 4555 if (ddi_copyout(tpsg, (caddr_t)arg, 4556 sizeof (iscsi_tunable_object_t), mode) != 0) { 4557 rtn = EFAULT; 4558 } 4559 kmem_free(tpsg, sizeof (*tpsg)); 4560 break; 4561 4562 default: 4563 rtn = ENOTTY; 4564 cmn_err(CE_NOTE, "unrecognized ioctl 0x%x", cmd); 4565 } /* end of ioctl type switch/cases */ 4566 4567 if ((cmd != ISCSI_SMF_ONLINE) && (cmd != ISCSI_SMF_OFFLINE) && 4568 (cmd != ISCSI_SMF_GET)) { 4569 /* other cmds need to release the service */ 4570 iscsi_client_release_service(ihp); 4571 } 4572 4573 return (rtn); 4574 } 4575 4576 /* 4577 * +--------------------------------------------------------------------+ 4578 * | End of cb_ops routines | 4579 * +--------------------------------------------------------------------+ 4580 */ 4581 4582 4583 /* 4584 * +--------------------------------------------------------------------+ 4585 * | Common scsi_tran support routines | 4586 * +--------------------------------------------------------------------+ 4587 */ 4588 4589 /* 4590 * iscsi_i_commoncap -- SCSA host adapter get/set capability routines. 4591 * 4592 * Need to determine if any of these can be determined through the iSCSI 4593 * protocol. For now just return error on most. 4594 */ 4595 /* ARGSUSED */ 4596 static int 4597 iscsi_i_commoncap(struct scsi_address *ap, char *cap, int val, 4598 int tgtonly, int doset) 4599 { 4600 int rtn; 4601 int cidx; 4602 iscsi_lun_t *ilp; 4603 4604 ASSERT((ap)->a_hba_tran->tran_hba_private != NULL); 4605 ilp = (iscsi_lun_t *)((ap)->a_hba_tran->tran_tgt_private); 4606 ASSERT(ilp != NULL); 4607 4608 if (cap == (char *)0) { 4609 return (FALSE); 4610 } 4611 4612 cidx = scsi_hba_lookup_capstr(cap); 4613 if (cidx == -1) { 4614 return (cidx); 4615 } 4616 4617 /* 4618 * Process setcap request. 4619 */ 4620 if (doset) { 4621 /* 4622 * At present, we can only set binary (0/1) values 4623 */ 4624 switch (cidx) { 4625 case SCSI_CAP_LUN_RESET: 4626 if (val) { 4627 ilp->lun_cap |= ISCSI_LUN_CAP_RESET; 4628 } else { 4629 ilp->lun_cap &= ~ISCSI_LUN_CAP_RESET; 4630 } 4631 rtn = TRUE; 4632 break; 4633 default: 4634 /* 4635 * None of these are settable via 4636 * the capability interface. 4637 */ 4638 rtn = FALSE; 4639 break; 4640 } 4641 4642 /* 4643 * Process getcap request. 4644 */ 4645 } else { 4646 switch (cidx) { 4647 case SCSI_CAP_DMA_MAX: 4648 /* no DMA, Psuedo value */ 4649 rtn = INT32_MAX; 4650 break; 4651 case SCSI_CAP_INITIATOR_ID: 4652 rtn = 7; 4653 break; 4654 case SCSI_CAP_ARQ: 4655 case SCSI_CAP_RESET_NOTIFICATION: 4656 case SCSI_CAP_TAGGED_QING: 4657 rtn = TRUE; 4658 break; 4659 case SCSI_CAP_SCSI_VERSION: 4660 rtn = SCSI_VERSION_3; 4661 break; 4662 case SCSI_CAP_INTERCONNECT_TYPE: 4663 rtn = INTERCONNECT_FABRIC; 4664 break; 4665 case SCSI_CAP_LUN_RESET: 4666 rtn = ((ilp->lun_cap & ISCSI_LUN_CAP_RESET) != 0) ? 4667 TRUE : FALSE; 4668 break; 4669 case SCSI_CAP_CDB_LEN: 4670 /* 4671 * iSCSI RFC 3720 defines a default 16 byte 4672 * CDB as part of the Basic Header Segment 4673 * (BHS) (10.2.1) and allows for an Additional 4674 * Header Segment (AHS) Length of 255 * 4 4675 * (10.2.1.5). The AHS length can be used 4676 * for different purposes two of which are 4677 * Extended CDB ADS (10.2.2.3) and Bidirectional 4678 * Expected Read-Data Length AHS (10.2.2.4). 4679 * The largest header of these consumes is 4680 * 32 bytes. So the total Max CDB Length is 4681 * 16 + ((255 * 4 ) - 32) = 1004. 4682 */ 4683 rtn = 1004; 4684 break; 4685 default: 4686 rtn = UNDEFINED; 4687 break; 4688 } 4689 } 4690 return (rtn); 4691 } 4692 4693 /* 4694 * iscsi_virt_lun_init - attempts to complete a mdi/scsi_vhci binding 4695 * 4696 * This routine is used to associate the tran_tgt_private to our ilp 4697 * structure. This function is indirectly called from our 4698 * iscsi_lun_create_xxx routines. These routines must prevent 4699 * the session and lun lists from changing during this call. 4700 */ 4701 /* ARGSUSED */ 4702 static int 4703 iscsi_virt_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip, 4704 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 4705 { 4706 iscsi_lun_t *ilp = NULL; 4707 iscsi_lun_t *ilp_check = NULL; 4708 iscsi_sess_t *isp = NULL; 4709 char *lun_guid = NULL; 4710 mdi_pathinfo_t *pip = NULL; 4711 iscsi_hba_t *ihp = (iscsi_hba_t *)hba_tran->tran_hba_private; 4712 char target_port_name[MAX_NAME_PROP_SIZE]; 4713 4714 /* 4715 * Here's a nice little piece of undocumented stuff. 4716 */ 4717 if ((pip = (mdi_pathinfo_t *)sd->sd_private) == NULL) { 4718 /* 4719 * Very bad news if this occurs. Somehow SCSI_vhci has 4720 * lost the pathinfo node for this target. 4721 */ 4722 return (DDI_NOT_WELL_FORMED); 4723 } 4724 4725 ilp = (iscsi_lun_t *)mdi_pi_get_phci_private(pip); 4726 4727 /* 4728 * +----------------------------------------------------+ 4729 * | Looking to find the target device via the property | 4730 * | is not required since the driver can easily get | 4731 * | this information from the mdi_phci_get_private() | 4732 * | call above. This is just a consistency check | 4733 * | which can be removed. | 4734 */ 4735 if (mdi_prop_lookup_string(pip, MDI_GUID, &lun_guid) != 4736 DDI_PROP_SUCCESS) { 4737 return (DDI_NOT_WELL_FORMED); 4738 } 4739 4740 for (isp = ihp->hba_sess_list; isp; isp = isp->sess_next) { 4741 4742 /* If this isn't the matching session continue */ 4743 if (ilp->lun_sess != isp) { 4744 continue; 4745 } 4746 4747 /* 4748 * We are already holding the lun list rwlock 4749 * for this thread on the callers side of mdi_pi_online 4750 * or ndi_devi_online. Which lead to this functions 4751 * call. 4752 */ 4753 for (ilp_check = isp->sess_lun_list; ilp_check; 4754 ilp_check = ilp_check->lun_next) { 4755 4756 /* 4757 * If this is the matching LUN and contains 4758 * the same LUN GUID then break we found our 4759 * match. 4760 */ 4761 if ((ilp == ilp_check) && 4762 (strcmp(lun_guid, ilp_check->lun_guid) == 0)) { 4763 break; 4764 } 4765 } 4766 if (ilp_check != NULL) { 4767 break; 4768 } 4769 } 4770 4771 /* 4772 * Free resource that's no longer required. 4773 */ 4774 if (lun_guid != NULL) 4775 (void) mdi_prop_free(lun_guid); 4776 4777 if (ilp_check == NULL) { 4778 /* 4779 * Failed to find iSCSI LUN in HBA chain based 4780 * on the GUID that was stored as a property on 4781 * the pathinfo node. 4782 */ 4783 return (DDI_NOT_WELL_FORMED); 4784 } 4785 4786 if (ilp != ilp_check) { 4787 /* 4788 * The iSCSI target that we found on the HBA link is 4789 * different than the iSCSI target that was stored as 4790 * private data on the pathinfo node. 4791 */ 4792 return (DDI_NOT_WELL_FORMED); 4793 } 4794 /* 4795 * | End of consistency check | 4796 * +----------------------------------------------------+ 4797 */ 4798 4799 hba_tran->tran_tgt_private = ilp; 4800 4801 target_port_name[0] = '\0'; 4802 if (ilp->lun_sess->sess_tpgt_conf == ISCSI_DEFAULT_TPGT) { 4803 (void) snprintf(target_port_name, MAX_NAME_PROP_SIZE, 4804 "%02x%02x%02x%02x%02x%02x,%s", 4805 ilp->lun_sess->sess_isid[0], ilp->lun_sess->sess_isid[1], 4806 ilp->lun_sess->sess_isid[2], ilp->lun_sess->sess_isid[3], 4807 ilp->lun_sess->sess_isid[4], ilp->lun_sess->sess_isid[5], 4808 ilp->lun_sess->sess_name); 4809 } else { 4810 (void) snprintf(target_port_name, MAX_NAME_PROP_SIZE, 4811 "%02x%02x%02x%02x%02x%02x,%s,%d", 4812 ilp->lun_sess->sess_isid[0], ilp->lun_sess->sess_isid[1], 4813 ilp->lun_sess->sess_isid[2], ilp->lun_sess->sess_isid[3], 4814 ilp->lun_sess->sess_isid[4], ilp->lun_sess->sess_isid[5], 4815 ilp->lun_sess->sess_name, ilp->lun_sess->sess_tpgt_conf); 4816 } 4817 4818 if (mdi_prop_update_string(pip, 4819 SCSI_ADDR_PROP_TARGET_PORT, target_port_name) != DDI_PROP_SUCCESS) { 4820 cmn_err(CE_WARN, "iscsi_virt_lun_init: Creating '" 4821 SCSI_ADDR_PROP_TARGET_PORT "' property on Path(%p) " 4822 "for Target(%s), Lun(%d) Failed", 4823 (void *)pip, ilp->lun_sess->sess_name, ilp->lun_num); 4824 } 4825 4826 return (DDI_SUCCESS); 4827 } 4828 4829 /* 4830 * iscsi_phys_lun_init - attempts to complete a ndi binding 4831 * 4832 * This routine is used to associate the tran_tgt_private to our 4833 * ilp structure. This function is indirectly called from our 4834 * iscsi_lun_create_xxx routines. These routines must prevent 4835 * the session and lun lists from changing during this call. 4836 */ 4837 static int 4838 iscsi_phys_lun_init(dev_info_t *hba_dip, dev_info_t *lun_dip, 4839 scsi_hba_tran_t *hba_tran, struct scsi_device *sd) 4840 { 4841 int rtn = DDI_SUCCESS; 4842 iscsi_hba_t *ihp = NULL; 4843 iscsi_sess_t *isp = NULL; 4844 iscsi_lun_t *ilp = NULL; 4845 char target_port_name[MAX_NAME_PROP_SIZE]; 4846 int *words = NULL; 4847 uint_t nwords = 0; 4848 4849 ASSERT(hba_dip); 4850 ASSERT(lun_dip); 4851 ASSERT(hba_tran); 4852 ASSERT(sd); 4853 ihp = (iscsi_hba_t *)hba_tran->tran_hba_private; 4854 ASSERT(ihp); 4855 4856 if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, lun_dip, 4857 DDI_PROP_DONTPASS, LUN_PROP, &words, &nwords) != DDI_PROP_SUCCESS) { 4858 cmn_err(CE_WARN, "iscsi_phys_lun_init: Returning DDI_FAILURE:" 4859 "lun for %s (instance %d)", ddi_get_name(lun_dip), 4860 ddi_get_instance(lun_dip)); 4861 return (DDI_FAILURE); 4862 } 4863 4864 if (nwords == 0) { 4865 ddi_prop_free(words); 4866 return (DDI_FAILURE); 4867 } 4868 4869 ASSERT(words != NULL); 4870 4871 /* See if we already created this session */ 4872 4873 /* Walk the HBA's session list */ 4874 for (isp = ihp->hba_sess_list; isp; isp = isp->sess_next) { 4875 /* compare target name as the unique identifier */ 4876 if (sd->sd_address.a_target == isp->sess_oid) { 4877 /* found match */ 4878 break; 4879 } 4880 } 4881 4882 /* If we found matching session continue searching for tgt */ 4883 if (isp != NULL) { 4884 /* 4885 * Search for the matching iscsi lun structure. We don't 4886 * need to hold the READER for the lun list at this point. 4887 * because the tran_get_name is being called from the online 4888 * function which is already holding a reader on the lun 4889 * list. 4890 */ 4891 for (ilp = isp->sess_lun_list; ilp; ilp = ilp->lun_next) { 4892 if (*words == ilp->lun_num) { 4893 /* found match */ 4894 break; 4895 } 4896 } 4897 4898 if (ilp != NULL) { 4899 /* 4900 * tgt found path it to the tran_lun_private 4901 * this is used later for fast access on 4902 * init_pkt and start 4903 */ 4904 hba_tran->tran_tgt_private = ilp; 4905 } else { 4906 /* tgt not found */ 4907 ddi_prop_free(words); 4908 return (DDI_FAILURE); 4909 } 4910 } else { 4911 /* sess not found */ 4912 ddi_prop_free(words); 4913 return (DDI_FAILURE); 4914 } 4915 ddi_prop_free(words); 4916 4917 target_port_name[0] = '\0'; 4918 if (ilp->lun_sess->sess_tpgt_conf == ISCSI_DEFAULT_TPGT) { 4919 (void) snprintf(target_port_name, MAX_NAME_PROP_SIZE, 4920 "%02x%02x%02x%02x%02x%02x,%s", 4921 ilp->lun_sess->sess_isid[0], ilp->lun_sess->sess_isid[1], 4922 ilp->lun_sess->sess_isid[2], ilp->lun_sess->sess_isid[3], 4923 ilp->lun_sess->sess_isid[4], ilp->lun_sess->sess_isid[5], 4924 ilp->lun_sess->sess_name); 4925 } else { 4926 (void) snprintf(target_port_name, MAX_NAME_PROP_SIZE, 4927 "%02x%02x%02x%02x%02x%02x,%s,%d", 4928 ilp->lun_sess->sess_isid[0], ilp->lun_sess->sess_isid[1], 4929 ilp->lun_sess->sess_isid[2], ilp->lun_sess->sess_isid[3], 4930 ilp->lun_sess->sess_isid[4], ilp->lun_sess->sess_isid[5], 4931 ilp->lun_sess->sess_name, ilp->lun_sess->sess_tpgt_conf); 4932 } 4933 4934 if (ddi_prop_update_string(DDI_DEV_T_NONE, lun_dip, 4935 SCSI_ADDR_PROP_TARGET_PORT, target_port_name) != DDI_PROP_SUCCESS) { 4936 cmn_err(CE_WARN, "iscsi_phys_lun_init: Creating '" 4937 SCSI_ADDR_PROP_TARGET_PORT "' property on Target(%s), " 4938 "Lun(%d) Failed", ilp->lun_sess->sess_name, ilp->lun_num); 4939 } 4940 4941 return (rtn); 4942 } 4943 4944 /* 4945 * +--------------------------------------------------------------------+ 4946 * | End of scsi_tran support routines | 4947 * +--------------------------------------------------------------------+ 4948 */ 4949 4950 /* 4951 * +--------------------------------------------------------------------+ 4952 * | Begin of struct utility routines | 4953 * +--------------------------------------------------------------------+ 4954 */ 4955 4956 4957 /* 4958 * iscsi_set_default_login_params - This function sets the 4959 * driver default login params. This is using during the 4960 * creation of our iSCSI HBA structure initialization by 4961 * could be used at other times to reset back to the defaults. 4962 */ 4963 void 4964 iscsi_set_default_login_params(iscsi_login_params_t *params) 4965 { 4966 params->immediate_data = ISCSI_DEFAULT_IMMEDIATE_DATA; 4967 params->initial_r2t = ISCSI_DEFAULT_INITIALR2T; 4968 params->first_burst_length = ISCSI_DEFAULT_FIRST_BURST_LENGTH; 4969 params->max_burst_length = ISCSI_DEFAULT_MAX_BURST_LENGTH; 4970 params->data_pdu_in_order = ISCSI_DEFAULT_DATA_PDU_IN_ORDER; 4971 params->data_sequence_in_order = ISCSI_DEFAULT_DATA_SEQUENCE_IN_ORDER; 4972 params->default_time_to_wait = ISCSI_DEFAULT_TIME_TO_WAIT; 4973 params->default_time_to_retain = ISCSI_DEFAULT_TIME_TO_RETAIN; 4974 params->header_digest = ISCSI_DEFAULT_HEADER_DIGEST; 4975 params->data_digest = ISCSI_DEFAULT_DATA_DIGEST; 4976 params->max_recv_data_seg_len = ISCSI_DEFAULT_MAX_RECV_SEG_LEN; 4977 params->max_xmit_data_seg_len = ISCSI_DEFAULT_MAX_XMIT_SEG_LEN; 4978 params->max_connections = ISCSI_DEFAULT_MAX_CONNECTIONS; 4979 params->max_outstanding_r2t = ISCSI_DEFAULT_MAX_OUT_R2T; 4980 params->error_recovery_level = ISCSI_DEFAULT_ERROR_RECOVERY_LEVEL; 4981 params->ifmarker = ISCSI_DEFAULT_IFMARKER; 4982 params->ofmarker = ISCSI_DEFAULT_OFMARKER; 4983 } 4984 4985 /* Helper function to sets the driver default tunable parameters */ 4986 static void 4987 iscsi_set_default_tunable_params(iscsi_tunable_params_t *params) 4988 { 4989 params->recv_login_rsp_timeout = ISCSI_DEFAULT_RX_TIMEOUT_VALUE; 4990 params->conn_login_max = ISCSI_DEFAULT_CONN_DEFAULT_LOGIN_MAX; 4991 params->polling_login_delay = ISCSI_DEFAULT_LOGIN_POLLING_DELAY; 4992 } 4993 4994 /* 4995 * +--------------------------------------------------------------------+ 4996 * | End of struct utility routines | 4997 * +--------------------------------------------------------------------+ 4998 */ 4999 5000 /* 5001 * +--------------------------------------------------------------------+ 5002 * | Begin of ioctl utility routines | 5003 * +--------------------------------------------------------------------+ 5004 */ 5005 5006 /* 5007 * iscsi_get_param - This function is a helper to ISCSI_GET_PARAM 5008 * IOCTL 5009 */ 5010 int 5011 iscsi_get_param(iscsi_login_params_t *params, boolean_t valid_flag, 5012 iscsi_param_get_t *ipgp) { 5013 int rtn = 0; 5014 5015 /* ---- Default to settable, possibly changed later ---- */ 5016 ipgp->g_value.v_valid = valid_flag; 5017 ipgp->g_value.v_settable = B_TRUE; 5018 5019 switch (ipgp->g_param) { 5020 /* 5021 * Boolean parameters 5022 */ 5023 case ISCSI_LOGIN_PARAM_DATA_SEQUENCE_IN_ORDER: 5024 ipgp->g_value.v_bool.b_current = 5025 params->data_sequence_in_order; 5026 ipgp->g_value.v_bool.b_default = 5027 ISCSI_DEFAULT_DATA_SEQUENCE_IN_ORDER; 5028 break; 5029 case ISCSI_LOGIN_PARAM_IMMEDIATE_DATA: 5030 ipgp->g_value.v_bool.b_current = 5031 params->immediate_data; 5032 ipgp->g_value.v_bool.b_default = 5033 ISCSI_DEFAULT_IMMEDIATE_DATA; 5034 break; 5035 case ISCSI_LOGIN_PARAM_INITIAL_R2T: 5036 ipgp->g_value.v_bool.b_current = 5037 params->initial_r2t; 5038 ipgp->g_value.v_bool.b_default = 5039 ISCSI_DEFAULT_IMMEDIATE_DATA; 5040 break; 5041 case ISCSI_LOGIN_PARAM_DATA_PDU_IN_ORDER: 5042 ipgp->g_value.v_bool.b_current = 5043 params->data_pdu_in_order; 5044 ipgp->g_value.v_bool.b_default = 5045 ISCSI_DEFAULT_DATA_PDU_IN_ORDER; 5046 break; 5047 5048 /* 5049 * Integer parameters 5050 */ 5051 case ISCSI_LOGIN_PARAM_HEADER_DIGEST: 5052 ipgp->g_value.v_integer.i_current = params->header_digest; 5053 ipgp->g_value.v_integer.i_default = ISCSI_DEFAULT_HEADER_DIGEST; 5054 ipgp->g_value.v_integer.i_min = 0; 5055 ipgp->g_value.v_integer.i_max = ISCSI_MAX_HEADER_DIGEST; 5056 ipgp->g_value.v_integer.i_incr = 1; 5057 break; 5058 case ISCSI_LOGIN_PARAM_DATA_DIGEST: 5059 ipgp->g_value.v_integer.i_current = params->data_digest; 5060 ipgp->g_value.v_integer.i_default = ISCSI_DEFAULT_DATA_DIGEST; 5061 ipgp->g_value.v_integer.i_min = 0; 5062 ipgp->g_value.v_integer.i_max = ISCSI_MAX_DATA_DIGEST; 5063 ipgp->g_value.v_integer.i_incr = 1; 5064 break; 5065 case ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_RETAIN: 5066 ipgp->g_value.v_integer.i_current = 5067 params->default_time_to_retain; 5068 ipgp->g_value.v_integer.i_default = 5069 ISCSI_DEFAULT_TIME_TO_RETAIN; 5070 ipgp->g_value.v_integer.i_min = 0; 5071 ipgp->g_value.v_integer.i_max = ISCSI_MAX_TIME2RETAIN; 5072 ipgp->g_value.v_integer.i_incr = 1; 5073 break; 5074 case ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_WAIT: 5075 ipgp->g_value.v_integer.i_current = 5076 params->default_time_to_wait; 5077 ipgp->g_value.v_integer.i_default = 5078 ISCSI_DEFAULT_TIME_TO_WAIT; 5079 ipgp->g_value.v_integer.i_min = 0; 5080 ipgp->g_value.v_integer.i_max = ISCSI_MAX_TIME2WAIT; 5081 ipgp->g_value.v_integer.i_incr = 1; 5082 break; 5083 case ISCSI_LOGIN_PARAM_ERROR_RECOVERY_LEVEL: 5084 ipgp->g_value.v_integer.i_current = 5085 params->error_recovery_level; 5086 ipgp->g_value.v_integer.i_default = 5087 ISCSI_DEFAULT_ERROR_RECOVERY_LEVEL; 5088 ipgp->g_value.v_integer.i_min = 0; 5089 ipgp->g_value.v_integer.i_max = ISCSI_MAX_ERROR_RECOVERY_LEVEL; 5090 ipgp->g_value.v_integer.i_incr = 1; 5091 ipgp->g_value.v_settable = B_FALSE; 5092 break; 5093 case ISCSI_LOGIN_PARAM_FIRST_BURST_LENGTH: 5094 ipgp->g_value.v_integer.i_current = 5095 params->first_burst_length; 5096 ipgp->g_value.v_integer.i_default = 5097 ISCSI_DEFAULT_FIRST_BURST_LENGTH; 5098 ipgp->g_value.v_integer.i_min = 512; 5099 ipgp->g_value.v_integer.i_max = ISCSI_MAX_FIRST_BURST_LENGTH; 5100 ipgp->g_value.v_integer.i_incr = 1; 5101 break; 5102 case ISCSI_LOGIN_PARAM_MAX_BURST_LENGTH: 5103 ipgp->g_value.v_integer.i_current = 5104 params->max_burst_length; 5105 ipgp->g_value.v_integer.i_default = 5106 ISCSI_DEFAULT_MAX_BURST_LENGTH; 5107 ipgp->g_value.v_integer.i_min = 512; 5108 ipgp->g_value.v_integer.i_max = ISCSI_MAX_BURST_LENGTH; 5109 ipgp->g_value.v_integer.i_incr = 1; 5110 break; 5111 case ISCSI_LOGIN_PARAM_MAX_CONNECTIONS: 5112 ipgp->g_value.v_integer.i_current = 5113 params->max_connections; 5114 ipgp->g_value.v_settable = B_FALSE; 5115 ipgp->g_value.v_integer.i_default = 5116 ISCSI_DEFAULT_MAX_CONNECTIONS; 5117 ipgp->g_value.v_integer.i_min = 1; 5118 ipgp->g_value.v_integer.i_max = ISCSI_MAX_CONNECTIONS; 5119 ipgp->g_value.v_integer.i_incr = 1; 5120 break; 5121 case ISCSI_LOGIN_PARAM_OUTSTANDING_R2T: 5122 ipgp->g_value.v_integer.i_current = 5123 params->max_outstanding_r2t; 5124 ipgp->g_value.v_settable = B_FALSE; 5125 ipgp->g_value.v_integer.i_default = 5126 ISCSI_DEFAULT_MAX_OUT_R2T; 5127 ipgp->g_value.v_integer.i_min = 1; 5128 ipgp->g_value.v_integer.i_max = ISCSI_MAX_OUTSTANDING_R2T; 5129 ipgp->g_value.v_integer.i_incr = 1; 5130 break; 5131 case ISCSI_LOGIN_PARAM_MAX_RECV_DATA_SEGMENT_LENGTH: 5132 ipgp->g_value.v_integer.i_current = 5133 params->max_recv_data_seg_len; 5134 ipgp->g_value.v_integer.i_default = 5135 ISCSI_DEFAULT_MAX_RECV_SEG_LEN; 5136 ipgp->g_value.v_integer.i_min = 512; 5137 ipgp->g_value.v_integer.i_max = 5138 ISCSI_MAX_RECV_DATA_SEGMENT_LENGTH; 5139 ipgp->g_value.v_integer.i_incr = 1; 5140 break; 5141 default: 5142 rtn = EINVAL; 5143 } 5144 5145 return (rtn); 5146 } 5147 5148 /* 5149 * +--------------------------------------------------------------------+ 5150 * | End of ioctl utility routines | 5151 * +--------------------------------------------------------------------+ 5152 */ 5153 5154 /* 5155 * iscsi_get_name_from_iqn - Translates a normal iqn/eui into a 5156 * IEEE safe address. IEEE addresses have a number of characters 5157 * set aside as reserved. 5158 */ 5159 static void 5160 iscsi_get_name_from_iqn(char *name, int name_max_len) 5161 { 5162 char *tmp = NULL; 5163 char *oldch = NULL; 5164 char *newch = NULL; 5165 5166 tmp = kmem_zalloc(MAX_GET_NAME_SIZE, KM_SLEEP); 5167 5168 for (oldch = &name[0], newch = &tmp[0]; *oldch != '\0'; 5169 oldch++, newch++) { 5170 switch (*oldch) { 5171 case ':': 5172 *newch++ = '%'; 5173 *newch++ = '3'; 5174 *newch = 'A'; 5175 break; 5176 case ' ': 5177 *newch++ = '%'; 5178 *newch++ = '2'; 5179 *newch = '0'; 5180 break; 5181 case '@': 5182 *newch++ = '%'; 5183 *newch++ = '4'; 5184 *newch = '0'; 5185 break; 5186 case '/': 5187 *newch++ = '%'; 5188 *newch++ = '2'; 5189 *newch = 'F'; 5190 break; 5191 default: 5192 *newch = *oldch; 5193 } 5194 } 5195 (void) strncpy(name, tmp, name_max_len); 5196 kmem_free(tmp, MAX_GET_NAME_SIZE); 5197 } 5198 5199 /* 5200 * iscsi_get_name_to_iqn - Converts IEEE safe address back 5201 * into a iscsi iqn/eui. 5202 */ 5203 static void 5204 iscsi_get_name_to_iqn(char *name, int name_max_len) 5205 { 5206 char *tmp = NULL; 5207 char *oldch = NULL; 5208 char *newch = NULL; 5209 5210 tmp = kmem_zalloc(MAX_GET_NAME_SIZE, KM_SLEEP); 5211 5212 for (oldch = &name[0], newch = &tmp[0]; *oldch != '\0'; 5213 oldch++, newch++) { 5214 if (*oldch == '%') { 5215 switch (*(oldch+1)) { 5216 case '2': 5217 if (*(oldch+2) == '0') { 5218 *newch = ' '; 5219 oldch += 2; 5220 } else if (*(oldch+2) == 'F') { 5221 *newch = '/'; 5222 oldch += 2; 5223 } else { 5224 *newch = *oldch; 5225 } 5226 break; 5227 case '3': 5228 if (*(oldch+2) == 'A') { 5229 *newch = ':'; 5230 oldch += 2; 5231 } else { 5232 *newch = *oldch; 5233 } 5234 break; 5235 case '4': 5236 if (*(oldch+2) == '0') { 5237 *newch = '@'; 5238 oldch += 2; 5239 } else { 5240 *newch = *oldch; 5241 } 5242 break; 5243 default: 5244 *newch = *oldch; 5245 } 5246 } else { 5247 *newch = *oldch; 5248 } 5249 } 5250 (void) strncpy(name, tmp, name_max_len); 5251 kmem_free(tmp, MAX_GET_NAME_SIZE); 5252 } 5253 5254 /* 5255 * iscsi_get_persisted_param * - a helper to ISCSI_GET_PARAM ioctl 5256 * 5257 * On return 0 means persisted parameter found 5258 */ 5259 int 5260 iscsi_get_persisted_param(uchar_t *name, iscsi_param_get_t *ipgp, 5261 iscsi_login_params_t *params) 5262 { 5263 int rtn = 1; 5264 persistent_param_t *pparam; 5265 5266 if (name == NULL || strlen((char *)name) == 0) { 5267 return (rtn); 5268 } 5269 5270 pparam = (persistent_param_t *)kmem_zalloc(sizeof (*pparam), KM_SLEEP); 5271 5272 if (persistent_param_get((char *)name, pparam) == B_TRUE) { 5273 if (pparam->p_bitmap & (1 << ipgp->g_param)) { 5274 /* Found configured parameter. */ 5275 bcopy(&pparam->p_params, params, sizeof (*params)); 5276 rtn = 0; 5277 } 5278 } 5279 5280 kmem_free(pparam, sizeof (*pparam)); 5281 5282 return (rtn); 5283 } 5284 5285 /* 5286 * iscsi_override_target_default - helper function set the target's default 5287 * login parameter if there is a configured initiator parameter. 5288 * 5289 */ 5290 static void 5291 iscsi_override_target_default(iscsi_hba_t *ihp, iscsi_param_get_t *ipg) 5292 { 5293 persistent_param_t *pp; 5294 iscsi_login_params_t *params; 5295 5296 pp = (persistent_param_t *)kmem_zalloc(sizeof (*pp), KM_SLEEP); 5297 if (persistent_param_get((char *)ihp->hba_name, pp) == B_TRUE) { 5298 if (pp->p_bitmap & (1 << ipg->g_param)) { 5299 params = &pp->p_params; 5300 switch (ipg->g_param) { 5301 case ISCSI_LOGIN_PARAM_DATA_SEQUENCE_IN_ORDER: 5302 ipg->g_value.v_bool.b_default = 5303 params->data_sequence_in_order; 5304 break; 5305 case ISCSI_LOGIN_PARAM_IMMEDIATE_DATA: 5306 ipg->g_value.v_bool.b_default = 5307 params->immediate_data; 5308 break; 5309 case ISCSI_LOGIN_PARAM_INITIAL_R2T: 5310 ipg->g_value.v_bool.b_default = 5311 params->initial_r2t; 5312 break; 5313 case ISCSI_LOGIN_PARAM_DATA_PDU_IN_ORDER: 5314 ipg->g_value.v_bool.b_default = 5315 params->data_pdu_in_order; 5316 break; 5317 case ISCSI_LOGIN_PARAM_HEADER_DIGEST: 5318 ipg->g_value.v_integer.i_default = 5319 params->header_digest; 5320 break; 5321 case ISCSI_LOGIN_PARAM_DATA_DIGEST: 5322 ipg->g_value.v_integer.i_default = 5323 params->data_digest; 5324 break; 5325 case ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_RETAIN: 5326 ipg->g_value.v_integer.i_default = 5327 params->default_time_to_retain; 5328 break; 5329 case ISCSI_LOGIN_PARAM_DEFAULT_TIME_2_WAIT: 5330 ipg->g_value.v_integer.i_default = 5331 params->default_time_to_wait; 5332 break; 5333 case ISCSI_LOGIN_PARAM_ERROR_RECOVERY_LEVEL: 5334 ipg->g_value.v_integer.i_default = 5335 params->error_recovery_level; 5336 break; 5337 case ISCSI_LOGIN_PARAM_FIRST_BURST_LENGTH: 5338 ipg->g_value.v_integer.i_default = 5339 params->first_burst_length; 5340 break; 5341 case ISCSI_LOGIN_PARAM_MAX_BURST_LENGTH: 5342 ipg->g_value.v_integer.i_default = 5343 params->max_burst_length; 5344 break; 5345 case ISCSI_LOGIN_PARAM_MAX_CONNECTIONS: 5346 ipg->g_value.v_integer.i_default = 5347 params->max_connections; 5348 break; 5349 case ISCSI_LOGIN_PARAM_OUTSTANDING_R2T: 5350 ipg->g_value.v_integer.i_default = 5351 params->max_outstanding_r2t; 5352 break; 5353 case ISCSI_LOGIN_PARAM_MAX_RECV_DATA_SEGMENT_LENGTH: 5354 ipg->g_value.v_integer.i_default = 5355 params->max_xmit_data_seg_len; 5356 break; 5357 default: 5358 break; 5359 } 5360 } 5361 } 5362 kmem_free(pp, sizeof (*pp)); 5363 } 5364 5365 static boolean_t 5366 iscsi_cmp_boot_sess_oid(iscsi_hba_t *ihp, uint32_t oid) 5367 { 5368 iscsi_sess_t *isp = NULL; 5369 5370 if (iscsi_chk_bootlun_mpxio(ihp)) { 5371 for (isp = ihp->hba_sess_list; isp; isp = isp->sess_next) { 5372 if ((isp->sess_oid == oid) && isp->sess_boot) { 5373 /* oid is session object */ 5374 break; 5375 } 5376 if ((isp->sess_target_oid == oid) && isp->sess_boot) { 5377 /* 5378 * oid is target object while 5379 * this session is boot session 5380 */ 5381 break; 5382 } 5383 } 5384 if (oid == ihp->hba_oid) { 5385 /* oid is initiator object id */ 5386 return (B_TRUE); 5387 } else if ((isp != NULL) && (isp->sess_boot)) { 5388 /* oid is boot session object id */ 5389 return (B_TRUE); 5390 } 5391 } 5392 return (B_FALSE); 5393 } 5394 5395 /* 5396 * iscsi_client_request_service - request the iSCSI service 5397 * returns true if the service is enabled and increases the count 5398 * returns false if the service is disabled 5399 * blocks until the service status is either enabled or disabled 5400 */ 5401 boolean_t 5402 iscsi_client_request_service(iscsi_hba_t *ihp) { 5403 boolean_t rval = B_TRUE; 5404 5405 mutex_enter(&ihp->hba_service_lock); 5406 while ((ihp->hba_service_status == ISCSI_SERVICE_TRANSITION) || 5407 (ihp->hba_service_client_count == UINT_MAX)) { 5408 cv_wait(&ihp->hba_service_cv, &ihp->hba_service_lock); 5409 } 5410 if (ihp->hba_service_status == ISCSI_SERVICE_ENABLED) { 5411 ihp->hba_service_client_count++; 5412 } else { 5413 rval = B_FALSE; 5414 } 5415 mutex_exit(&ihp->hba_service_lock); 5416 5417 return (rval); 5418 } 5419 5420 /* 5421 * iscsi_client_release_service - decrease the count and wake up 5422 * blocking threads if the count reaches zero 5423 */ 5424 void 5425 iscsi_client_release_service(iscsi_hba_t *ihp) { 5426 mutex_enter(&ihp->hba_service_lock); 5427 ASSERT(ihp->hba_service_client_count > 0); 5428 ihp->hba_service_client_count--; 5429 if (ihp->hba_service_client_count == 0) { 5430 cv_broadcast(&ihp->hba_service_cv); 5431 } 5432 mutex_exit(&ihp->hba_service_lock); 5433 } 5434 5435 /* 5436 * iscsi_enter_service_zone - enter the service zone, should be called 5437 * before doing any modifications to the service status 5438 * return TRUE if the zone is entered 5439 * FALSE if no need to enter the zone 5440 */ 5441 static boolean_t 5442 iscsi_enter_service_zone(iscsi_hba_t *ihp, uint32_t status) { 5443 if ((status != ISCSI_SERVICE_ENABLED) && 5444 (status != ISCSI_SERVICE_DISABLED)) { 5445 return (B_FALSE); 5446 } 5447 5448 mutex_enter(&ihp->hba_service_lock); 5449 while (ihp->hba_service_status == ISCSI_SERVICE_TRANSITION) { 5450 cv_wait(&ihp->hba_service_cv, &ihp->hba_service_lock); 5451 } 5452 if (ihp->hba_service_status == status) { 5453 mutex_exit(&ihp->hba_service_lock); 5454 return (B_FALSE); 5455 } 5456 ihp->hba_service_status = ISCSI_SERVICE_TRANSITION; 5457 while (ihp->hba_service_client_count > 0) { 5458 cv_wait(&ihp->hba_service_cv, &ihp->hba_service_lock); 5459 } 5460 mutex_exit(&ihp->hba_service_lock); 5461 return (B_TRUE); 5462 } 5463 5464 /* 5465 * iscsi_exit_service_zone - exits the service zone and wakes up waiters 5466 */ 5467 static void 5468 iscsi_exit_service_zone(iscsi_hba_t *ihp, uint32_t status) { 5469 if ((status != ISCSI_SERVICE_ENABLED) && 5470 (status != ISCSI_SERVICE_DISABLED)) { 5471 return; 5472 } 5473 5474 mutex_enter(&ihp->hba_service_lock); 5475 ASSERT(ihp->hba_service_status == ISCSI_SERVICE_TRANSITION); 5476 ihp->hba_service_status = status; 5477 cv_broadcast(&ihp->hba_service_cv); 5478 mutex_exit(&ihp->hba_service_lock); 5479 } 5480 5481 static void 5482 iscsi_check_miniroot(iscsi_hba_t *ihp) { 5483 if (strncmp(rootfs.bo_name, "/ramdisk", 8) == 0) { 5484 /* 5485 * in miniroot we don't have the persistent store 5486 * so just to need to ensure an enabled status 5487 */ 5488 ihp->hba_service_status = ISCSI_SERVICE_ENABLED; 5489 } 5490 } 5491 5492 static void 5493 iscsi_get_tunable_default(iscsi_tunable_object_t *param) { 5494 int param_id = 0; 5495 5496 param_id = 1 << (param->t_param - 1); 5497 param->t_set = B_FALSE; 5498 switch (param_id) { 5499 case ISCSI_TUNABLE_PARAM_RX_TIMEOUT_VALUE: 5500 param->t_value.v_integer = ISCSI_DEFAULT_RX_TIMEOUT_VALUE; 5501 break; 5502 case ISCSI_TUNABLE_PARAM_LOGIN_POLLING_DELAY: 5503 param->t_value.v_integer = ISCSI_DEFAULT_LOGIN_POLLING_DELAY; 5504 break; 5505 case ISCSI_TUNABLE_PARAM_CONN_LOGIN_MAX: 5506 param->t_value.v_integer = ISCSI_DEFAULT_CONN_DEFAULT_LOGIN_MAX; 5507 break; 5508 default: 5509 break; 5510 } 5511 } 5512 5513 /* 5514 * iscsi_get_persisted_tunable_param * - a helper to ISCSI_TUNABLE_PARAM_GET 5515 * ioctl 5516 * return: 5517 * 0 persisted tunable parameter found 5518 * 1 persisted tunable parameter not found 5519 */ 5520 static int 5521 iscsi_get_persisted_tunable_param(uchar_t *name, iscsi_tunable_object_t *tpsg) 5522 { 5523 int rtn = 1; 5524 int param_id = 0; 5525 persistent_tunable_param_t *pparam; 5526 5527 if ((name == NULL) || strlen((char *)name) == 0) { 5528 return (rtn); 5529 } 5530 5531 tpsg->t_set = B_FALSE; 5532 pparam = (persistent_tunable_param_t *)kmem_zalloc(sizeof (*pparam), 5533 KM_SLEEP); 5534 if (persistent_get_tunable_param((char *)name, pparam) == B_TRUE) { 5535 if (pparam->p_bitmap & (1 << (tpsg->t_param - 1))) { 5536 tpsg->t_set = B_TRUE; 5537 param_id = 1 << (tpsg->t_param - 1); 5538 switch (param_id) { 5539 case ISCSI_TUNABLE_PARAM_RX_TIMEOUT_VALUE: 5540 tpsg->t_value.v_integer = 5541 pparam->p_params.recv_login_rsp_timeout; 5542 break; 5543 case ISCSI_TUNABLE_PARAM_LOGIN_POLLING_DELAY: 5544 tpsg->t_value.v_integer = 5545 pparam->p_params.polling_login_delay; 5546 break; 5547 case ISCSI_TUNABLE_PARAM_CONN_LOGIN_MAX: 5548 tpsg->t_value.v_integer = 5549 pparam->p_params.conn_login_max; 5550 break; 5551 default: 5552 break; 5553 } 5554 rtn = 0; 5555 } 5556 } 5557 5558 kmem_free(pparam, sizeof (*pparam)); 5559 5560 return (rtn); 5561 } 5562