1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved. 23 * Copyright 2011 Nexenta Systems, Inc. All rights reserved. 24 */ 25 26 #include <sys/cpuvar.h> 27 #include <sys/types.h> 28 #include <sys/conf.h> 29 #include <sys/file.h> 30 #include <sys/ddi.h> 31 #include <sys/sunddi.h> 32 #include <sys/modctl.h> 33 #include <sys/sysmacros.h> 34 #include <sys/sdt.h> 35 36 #include <sys/socket.h> 37 #include <sys/strsubr.h> 38 39 #include <sys/stmf.h> 40 #include <sys/stmf_ioctl.h> 41 #include <sys/portif.h> 42 #include <sys/idm/idm.h> 43 44 #define ISCSIT_TGT_SM_STRINGS 45 #include "iscsit.h" 46 #include "iscsit_isns.h" 47 48 typedef struct { 49 list_node_t te_ctx_node; 50 iscsit_tgt_event_t te_ctx_event; 51 } tgt_event_ctx_t; 52 53 static void 54 tgt_sm_event_dispatch(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx); 55 56 static void 57 tgt_sm_created(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx); 58 59 static void 60 tgt_sm_onlining(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx); 61 62 static void 63 tgt_sm_online(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx); 64 65 static void 66 tgt_sm_stmf_online(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx); 67 68 static void 69 tgt_sm_deleting_need_offline(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx); 70 71 static void 72 tgt_sm_offlining(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx); 73 74 static void 75 tgt_sm_offline(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx); 76 77 static void 78 tgt_sm_stmf_offline(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx); 79 80 static void 81 tgt_sm_deleting_stmf_dereg(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx); 82 83 static void 84 tgt_sm_deleting_stmf_dereg_fail(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx); 85 86 static void 87 tgt_sm_deleting(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx); 88 89 static void 90 iscsit_tgt_dereg_retry(void *arg); 91 92 static void 93 iscsit_tgt_dereg_task(void *arg); 94 95 static void 96 tgt_sm_new_state(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx, 97 iscsit_tgt_state_t new_state); 98 99 100 static iscsit_tgt_t * 101 iscsit_tgt_create(it_tgt_t *cfg_tgt); 102 103 static void 104 iscsit_tgt_unref(void *tgt); 105 106 static void 107 iscsit_tgt_async_wait_ref(iscsit_tgt_t *tgt, idm_refcnt_cb_t *cb_func); 108 109 static void 110 iscsit_tgt_destroy(iscsit_tgt_t *tgt); 111 112 static iscsit_tpgt_t * 113 iscsit_tgt_lookup_tpgt_locked(iscsit_tgt_t *tgt, uint16_t tag); 114 115 static iscsit_tpg_t * 116 iscsit_tpg_lookup_locked(char *tpg_name); 117 118 static iscsit_portal_t * 119 iscsit_tpg_portal_lookup_locked(iscsit_tpg_t *tpg, 120 struct sockaddr_storage *sa); 121 122 static idm_status_t 123 iscsit_tgt_online(iscsit_tgt_t *tgt); 124 125 static void 126 iscsit_tgt_offline(iscsit_tgt_t *tgt); 127 128 static idm_status_t 129 iscsit_tgt_modify(iscsit_tgt_t *tgt, it_tgt_t *cfg_tgt); 130 131 static idm_status_t 132 iscsit_tgt_merge_tpgt(iscsit_tgt_t *tgt, it_tgt_t *cfg_tgt, 133 list_t *tpgt_del_list); 134 135 static iscsit_tpgt_t * 136 iscsit_tpgt_create(it_tpgt_t *cfg_tpgt); 137 138 static iscsit_tpgt_t * 139 iscsit_tpgt_create_default(); 140 141 static void 142 iscsit_tpgt_destroy(iscsit_tpgt_t *tpgt); 143 144 static iscsit_tpg_t * 145 iscsit_tpg_create(it_tpg_t *tpg); 146 147 static void 148 iscsit_tpg_modify(iscsit_tpg_t *tpg, it_tpg_t *cfg_tpg); 149 150 static void 151 iscsit_tpg_destroy(iscsit_tpg_t *tpg); 152 153 static iscsit_portal_t * 154 iscsit_portal_create(iscsit_tpg_t *tpg, struct sockaddr_storage *sa); 155 156 static void 157 iscsit_portal_delete(iscsit_portal_t *portal); 158 159 static idm_status_t 160 iscsit_portal_online(iscsit_portal_t *portal); 161 162 static void 163 iscsit_portal_offline(iscsit_portal_t *portal); 164 165 166 167 /* 168 * Target state machine 169 */ 170 171 void 172 iscsit_tgt_sm_event(iscsit_tgt_t *tgt, iscsit_tgt_event_t event) 173 { 174 mutex_enter(&tgt->target_mutex); 175 tgt_sm_event_locked(tgt, event); 176 mutex_exit(&tgt->target_mutex); 177 } 178 179 void 180 tgt_sm_event_locked(iscsit_tgt_t *tgt, iscsit_tgt_event_t event) 181 { 182 tgt_event_ctx_t *ctx; 183 184 iscsit_tgt_hold(tgt); 185 186 ctx = kmem_zalloc(sizeof (*ctx), KM_SLEEP); 187 188 ctx->te_ctx_event = event; 189 190 list_insert_tail(&tgt->target_events, ctx); 191 /* 192 * Use the target_sm_busy flag to keep the state machine single 193 * threaded. This also serves as recursion avoidance since this 194 * flag will always be set if we call iscsit_tgt_sm_event from 195 * within the state machine code. 196 */ 197 if (!tgt->target_sm_busy) { 198 tgt->target_sm_busy = B_TRUE; 199 while (!list_is_empty(&tgt->target_events)) { 200 ctx = list_head(&tgt->target_events); 201 list_remove(&tgt->target_events, ctx); 202 idm_sm_audit_event(&tgt->target_state_audit, 203 SAS_ISCSIT_TGT, (int)tgt->target_state, 204 (int)ctx->te_ctx_event, 0); 205 mutex_exit(&tgt->target_mutex); 206 tgt_sm_event_dispatch(tgt, ctx); 207 mutex_enter(&tgt->target_mutex); 208 } 209 tgt->target_sm_busy = B_FALSE; 210 211 } 212 213 iscsit_tgt_rele(tgt); 214 } 215 216 static void 217 tgt_sm_event_dispatch(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx) 218 { 219 DTRACE_PROBE2(tgt__event, iscsit_tgt_t *, tgt, 220 tgt_event_ctx_t *, ctx); 221 222 IDM_SM_LOG(CE_NOTE, "tgt_sm_event_dispatch: tgt %p event %s(%d)", 223 (void *)tgt, iscsit_te_name[ctx->te_ctx_event], ctx->te_ctx_event); 224 225 /* State independent actions */ 226 switch (ctx->te_ctx_event) { 227 case TE_DELETE: 228 tgt->target_deleting = B_TRUE; 229 break; 230 } 231 232 /* State dependent actions */ 233 switch (tgt->target_state) { 234 case TS_CREATED: 235 tgt_sm_created(tgt, ctx); 236 break; 237 case TS_ONLINING: 238 tgt_sm_onlining(tgt, ctx); 239 break; 240 case TS_ONLINE: 241 tgt_sm_online(tgt, ctx); 242 break; 243 case TS_STMF_ONLINE: 244 tgt_sm_stmf_online(tgt, ctx); 245 break; 246 case TS_DELETING_NEED_OFFLINE: 247 tgt_sm_deleting_need_offline(tgt, ctx); 248 break; 249 case TS_OFFLINING: 250 tgt_sm_offlining(tgt, ctx); 251 break; 252 case TS_OFFLINE: 253 tgt_sm_offline(tgt, ctx); 254 break; 255 case TS_STMF_OFFLINE: 256 tgt_sm_stmf_offline(tgt, ctx); 257 break; 258 case TS_DELETING_STMF_DEREG: 259 tgt_sm_deleting_stmf_dereg(tgt, ctx); 260 break; 261 case TS_DELETING_STMF_DEREG_FAIL: 262 tgt_sm_deleting_stmf_dereg_fail(tgt, ctx); 263 break; 264 case TS_DELETING: 265 tgt_sm_deleting(tgt, ctx); 266 break; 267 default: 268 ASSERT(0); 269 } 270 271 kmem_free(ctx, sizeof (*ctx)); 272 } 273 274 static void 275 tgt_sm_created(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx) 276 { 277 stmf_change_status_t scs; 278 279 switch (ctx->te_ctx_event) { 280 case TE_STMF_ONLINE_REQ: 281 tgt_sm_new_state(tgt, ctx, TS_ONLINING); 282 break; 283 case TE_DELETE: 284 tgt_sm_new_state(tgt, ctx, TS_DELETING_STMF_DEREG); 285 break; 286 case TE_STMF_OFFLINE_REQ: 287 /* 288 * We're already offline but update to an equivelant 289 * state just to note that STMF talked to us. 290 */ 291 scs.st_completion_status = STMF_SUCCESS; 292 scs.st_additional_info = NULL; 293 tgt_sm_new_state(tgt, ctx, TS_OFFLINE); 294 (void) stmf_ctl(STMF_CMD_LPORT_OFFLINE_COMPLETE, 295 tgt->target_stmf_lport, &scs); 296 break; 297 case TE_STMF_ONLINE_COMPLETE_ACK: 298 case TE_STMF_OFFLINE_COMPLETE_ACK: 299 /* Ignore */ 300 break; 301 default: 302 ASSERT(0); 303 } 304 } 305 306 static void 307 tgt_sm_onlining(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx) 308 { 309 stmf_change_status_t scs; 310 311 switch (ctx->te_ctx_event) { 312 case TE_ONLINE_SUCCESS: 313 tgt_sm_new_state(tgt, ctx, TS_ONLINE); 314 break; 315 case TE_ONLINE_FAIL: 316 tgt_sm_new_state(tgt, ctx, TS_STMF_OFFLINE); 317 break; 318 case TE_DELETE: 319 /* TE_DELETE is handled in tgt_sm_event_dispatch() */ 320 break; 321 case TE_STMF_ONLINE_REQ: 322 case TE_STMF_OFFLINE_REQ: 323 /* 324 * We can't complete STMF's request since we are busy going 325 * online. 326 */ 327 scs.st_completion_status = STMF_INVALID_ARG; 328 scs.st_additional_info = NULL; 329 (void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ? 330 STMF_CMD_LPORT_ONLINE_COMPLETE : 331 STMF_CMD_LPORT_OFFLINE_COMPLETE, 332 tgt->target_stmf_lport, &scs); 333 break; 334 case TE_STMF_ONLINE_COMPLETE_ACK: 335 case TE_STMF_OFFLINE_COMPLETE_ACK: 336 /* Ignore */ 337 break; 338 default: 339 ASSERT(0); 340 } 341 } 342 343 static void 344 tgt_sm_online(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx) 345 { 346 stmf_change_status_t scs; 347 348 switch (ctx->te_ctx_event) { 349 case TE_STMF_ONLINE_COMPLETE_ACK: 350 if (tgt->target_deleting) { 351 tgt_sm_new_state(tgt, ctx, TS_DELETING_NEED_OFFLINE); 352 } else { 353 tgt_sm_new_state(tgt, ctx, TS_STMF_ONLINE); 354 } 355 break; 356 case TE_DELETE: 357 /* TE_DELETE is handled in tgt_sm_event_dispatch() */ 358 break; 359 case TE_STMF_ONLINE_REQ: 360 case TE_STMF_OFFLINE_REQ: 361 /* 362 * We can't complete STMF's request since we are busy going 363 * online (waiting for acknowlegement from STMF) 364 */ 365 scs.st_completion_status = STMF_INVALID_ARG; 366 scs.st_additional_info = NULL; 367 (void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ? 368 STMF_CMD_LPORT_ONLINE_COMPLETE : 369 STMF_CMD_LPORT_OFFLINE_COMPLETE, 370 tgt->target_stmf_lport, &scs); 371 break; 372 case TE_STMF_OFFLINE_COMPLETE_ACK: 373 /* Ignore */ 374 break; 375 default: 376 ASSERT(0); 377 } 378 } 379 380 381 static void 382 tgt_sm_stmf_online(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx) 383 { 384 stmf_change_status_t scs; 385 386 /* Deregister target with iSNS whenever we leave this state */ 387 388 switch (ctx->te_ctx_event) { 389 case TE_DELETE: 390 (void) iscsit_isns_deregister(tgt); 391 tgt_sm_new_state(tgt, ctx, TS_DELETING_NEED_OFFLINE); 392 break; 393 case TE_STMF_OFFLINE_REQ: 394 (void) iscsit_isns_deregister(tgt); 395 tgt_sm_new_state(tgt, ctx, TS_OFFLINING); 396 break; 397 case TE_STMF_ONLINE_REQ: 398 /* Already online */ 399 scs.st_completion_status = STMF_ALREADY; 400 scs.st_additional_info = NULL; 401 (void) stmf_ctl(STMF_CMD_LPORT_ONLINE_COMPLETE, 402 tgt->target_stmf_lport, &scs); 403 break; 404 case TE_STMF_ONLINE_COMPLETE_ACK: 405 case TE_STMF_OFFLINE_COMPLETE_ACK: 406 /* Ignore */ 407 break; 408 default: 409 ASSERT(0); 410 } 411 } 412 413 414 static void 415 tgt_sm_deleting_need_offline(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx) 416 { 417 stmf_change_status_t scs; 418 419 switch (ctx->te_ctx_event) { 420 case TE_STMF_OFFLINE_REQ: 421 tgt_sm_new_state(tgt, ctx, TS_OFFLINING); 422 break; 423 case TE_DELETE: 424 /* TE_DELETE is handled in tgt_sm_event_dispatch() */ 425 break; 426 case TE_STMF_ONLINE_REQ: 427 /* 428 * We can't complete STMF's request since we need to be offlined 429 */ 430 scs.st_completion_status = STMF_INVALID_ARG; 431 scs.st_additional_info = NULL; 432 (void) stmf_ctl(STMF_CMD_LPORT_ONLINE_COMPLETE, 433 tgt->target_stmf_lport, &scs); 434 break; 435 case TE_STMF_ONLINE_COMPLETE_ACK: 436 case TE_STMF_OFFLINE_COMPLETE_ACK: 437 /* Ignore */ 438 break; 439 default: 440 ASSERT(0); 441 } 442 } 443 444 445 static void 446 tgt_sm_offlining(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx) 447 { 448 stmf_change_status_t scs; 449 450 switch (ctx->te_ctx_event) { 451 case TE_OFFLINE_COMPLETE: 452 tgt_sm_new_state(tgt, ctx, TS_OFFLINE); 453 break; 454 case TE_DELETE: 455 /* TE_DELETE is handled in tgt_sm_event_dispatch() */ 456 break; 457 case TE_STMF_ONLINE_REQ: 458 case TE_STMF_OFFLINE_REQ: 459 /* 460 * We can't complete STMF's request since we are busy going 461 * offline. 462 */ 463 scs.st_completion_status = STMF_INVALID_ARG; 464 scs.st_additional_info = NULL; 465 (void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ? 466 STMF_CMD_LPORT_ONLINE_COMPLETE : 467 STMF_CMD_LPORT_OFFLINE_COMPLETE, 468 tgt->target_stmf_lport, &scs); 469 break; 470 case TE_STMF_ONLINE_COMPLETE_ACK: 471 case TE_STMF_OFFLINE_COMPLETE_ACK: 472 /* Ignore */ 473 break; 474 default: 475 ASSERT(0); 476 } 477 } 478 479 480 static void 481 tgt_sm_offline(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx) 482 { 483 stmf_change_status_t scs; 484 485 switch (ctx->te_ctx_event) { 486 case TE_STMF_OFFLINE_COMPLETE_ACK: 487 if (tgt->target_deleting) { 488 tgt_sm_new_state(tgt, ctx, TS_DELETING_STMF_DEREG); 489 } else { 490 tgt_sm_new_state(tgt, ctx, TS_STMF_OFFLINE); 491 } 492 break; 493 case TE_DELETE: 494 /* TE_DELETE is handled in tgt_sm_event_dispatch() */ 495 break; 496 case TE_STMF_ONLINE_REQ: 497 case TE_STMF_OFFLINE_REQ: 498 /* 499 * We can't complete STMF's request since we are busy going 500 * offline. 501 */ 502 scs.st_completion_status = STMF_INVALID_ARG; 503 scs.st_additional_info = NULL; 504 (void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ? 505 STMF_CMD_LPORT_ONLINE_COMPLETE : 506 STMF_CMD_LPORT_OFFLINE_COMPLETE, 507 tgt->target_stmf_lport, &scs); 508 break; 509 case TE_STMF_ONLINE_COMPLETE_ACK: 510 /* Ignore */ 511 break; 512 default: 513 ASSERT(0); 514 } 515 } 516 517 518 static void 519 tgt_sm_stmf_offline(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx) 520 { 521 stmf_change_status_t scs; 522 523 switch (ctx->te_ctx_event) { 524 case TE_STMF_ONLINE_REQ: 525 tgt_sm_new_state(tgt, ctx, TS_ONLINING); 526 break; 527 case TE_DELETE: 528 tgt_sm_new_state(tgt, ctx, TS_DELETING_STMF_DEREG); 529 break; 530 case TE_STMF_OFFLINE_REQ: 531 /* Already offline */ 532 scs.st_completion_status = STMF_ALREADY; 533 scs.st_additional_info = NULL; 534 (void) stmf_ctl(STMF_CMD_LPORT_OFFLINE_COMPLETE, 535 tgt->target_stmf_lport, &scs); 536 break; 537 case TE_STMF_ONLINE_COMPLETE_ACK: 538 case TE_STMF_OFFLINE_COMPLETE_ACK: 539 /* Ignore */ 540 break; 541 default: 542 ASSERT(0); 543 } 544 } 545 546 547 static void 548 tgt_sm_deleting_stmf_dereg(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx) 549 { 550 stmf_change_status_t scs; 551 552 /* Terminal state, no events */ 553 switch (ctx->te_ctx_event) { 554 case TE_STMF_ONLINE_REQ: 555 case TE_STMF_OFFLINE_REQ: 556 /* 557 * We can't complete STMF's request since we are being deleted 558 */ 559 scs.st_completion_status = STMF_INVALID_ARG; 560 scs.st_additional_info = NULL; 561 (void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ? 562 STMF_CMD_LPORT_ONLINE_COMPLETE : 563 STMF_CMD_LPORT_OFFLINE_COMPLETE, 564 tgt->target_stmf_lport, &scs); 565 break; 566 case TE_STMF_ONLINE_COMPLETE_ACK: 567 case TE_STMF_OFFLINE_COMPLETE_ACK: 568 /* Ignore */ 569 break; 570 case TE_STMF_DEREG_SUCCESS: 571 tgt_sm_new_state(tgt, ctx, TS_DELETING); 572 break; 573 case TE_STMF_DEREG_FAIL: 574 tgt_sm_new_state(tgt, ctx, TS_DELETING_STMF_DEREG_FAIL); 575 break; 576 default: 577 ASSERT(0); 578 } 579 } 580 581 static void 582 tgt_sm_deleting_stmf_dereg_fail(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx) 583 { 584 stmf_change_status_t scs; 585 586 /* Terminal state, no events */ 587 switch (ctx->te_ctx_event) { 588 case TE_STMF_ONLINE_REQ: 589 case TE_STMF_OFFLINE_REQ: 590 /* 591 * We can't complete STMF's request since we are being deleted 592 */ 593 scs.st_completion_status = STMF_INVALID_ARG; 594 scs.st_additional_info = NULL; 595 (void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ? 596 STMF_CMD_LPORT_ONLINE_COMPLETE : 597 STMF_CMD_LPORT_OFFLINE_COMPLETE, 598 tgt->target_stmf_lport, &scs); 599 break; 600 case TE_STMF_ONLINE_COMPLETE_ACK: 601 case TE_STMF_OFFLINE_COMPLETE_ACK: 602 /* Ignore */ 603 break; 604 case TE_STMF_DEREG_RETRY: 605 tgt_sm_new_state(tgt, ctx, TS_DELETING_STMF_DEREG); 606 break; 607 default: 608 ASSERT(0); 609 } 610 } 611 612 static void 613 tgt_sm_deleting(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx) 614 { 615 stmf_change_status_t scs; 616 617 /* Terminal state, no events */ 618 switch (ctx->te_ctx_event) { 619 case TE_STMF_ONLINE_REQ: 620 case TE_STMF_OFFLINE_REQ: 621 /* 622 * We can't complete STMF's request since we are being deleted 623 */ 624 scs.st_completion_status = STMF_INVALID_ARG; 625 scs.st_additional_info = NULL; 626 (void) stmf_ctl((ctx->te_ctx_event == TE_STMF_ONLINE_REQ) ? 627 STMF_CMD_LPORT_ONLINE_COMPLETE : 628 STMF_CMD_LPORT_OFFLINE_COMPLETE, 629 tgt->target_stmf_lport, &scs); 630 break; 631 case TE_STMF_ONLINE_COMPLETE_ACK: 632 case TE_STMF_OFFLINE_COMPLETE_ACK: 633 /* Ignore */ 634 break; 635 default: 636 ASSERT(0); 637 } 638 } 639 640 641 static void 642 iscsit_tgt_dereg_retry(void *arg) 643 { 644 iscsit_tgt_t *tgt = arg; 645 646 /* 647 * Rather than guaranteeing the target state machine code will not 648 * block for long periods of time (tying up this callout thread) 649 * we will queue a task on the taskq to send the retry event. 650 * If it fails we'll setup another timeout and try again later. 651 */ 652 if (taskq_dispatch(iscsit_global.global_dispatch_taskq, 653 iscsit_tgt_dereg_task, tgt, DDI_NOSLEEP) == NULL) { 654 /* Dispatch failed, try again later */ 655 (void) timeout(iscsit_tgt_dereg_retry, tgt, 656 drv_usectohz(TGT_DEREG_RETRY_SECONDS * 1000000)); 657 } 658 } 659 660 static void 661 iscsit_tgt_dereg_task(void *arg) 662 { 663 iscsit_tgt_t *tgt = arg; 664 665 iscsit_tgt_sm_event(tgt, TE_STMF_DEREG_RETRY); 666 } 667 668 static void 669 tgt_sm_new_state(iscsit_tgt_t *tgt, tgt_event_ctx_t *ctx, 670 iscsit_tgt_state_t new_state) 671 { 672 stmf_local_port_t *lport = tgt->target_stmf_lport; 673 stmf_change_status_t scs; 674 stmf_state_change_info_t sci; 675 idm_status_t idmrc; 676 stmf_status_t stmfrc; 677 678 scs.st_completion_status = STMF_SUCCESS; 679 scs.st_additional_info = NULL; 680 681 /* 682 * Validate new state 683 */ 684 ASSERT(new_state != TS_UNDEFINED); 685 ASSERT3U(new_state, <, TS_MAX_STATE); 686 687 new_state = (new_state < TS_MAX_STATE) ? 688 new_state : TS_UNDEFINED; 689 690 IDM_SM_LOG(CE_NOTE, "tgt_sm_new_state: tgt %p, %s(%d) --> %s(%d)\n", 691 (void *) tgt, iscsit_ts_name[tgt->target_state], tgt->target_state, 692 iscsit_ts_name[new_state], new_state); 693 DTRACE_PROBE3(target__state__change, 694 iscsit_tgt_t *, tgt, tgt_event_ctx_t *, ctx, 695 iscsit_tgt_state_t, new_state); 696 697 mutex_enter(&tgt->target_mutex); 698 idm_sm_audit_state_change(&tgt->target_state_audit, SAS_ISCSIT_TGT, 699 (int)tgt->target_state, (int)new_state); 700 tgt->target_last_state = tgt->target_state; 701 tgt->target_state = new_state; 702 mutex_exit(&tgt->target_mutex); 703 704 switch (tgt->target_state) { 705 case TS_ONLINING: 706 idmrc = iscsit_tgt_online(tgt); 707 if (idmrc != IDM_STATUS_SUCCESS) { 708 scs.st_completion_status = STMF_TARGET_FAILURE; 709 iscsit_tgt_sm_event(tgt, TE_ONLINE_FAIL); 710 } else { 711 iscsit_tgt_sm_event(tgt, TE_ONLINE_SUCCESS); 712 } 713 /* 714 * Let STMF know the how the online operation completed. 715 * STMF will respond with an acknowlege later 716 */ 717 (void) stmf_ctl(STMF_CMD_LPORT_ONLINE_COMPLETE, lport, &scs); 718 break; 719 case TS_ONLINE: 720 break; 721 case TS_STMF_ONLINE: 722 (void) iscsit_isns_register(tgt); 723 break; 724 case TS_DELETING_NEED_OFFLINE: 725 sci.st_rflags = STMF_RFLAG_STAY_OFFLINED; 726 sci.st_additional_info = "Offline for delete"; 727 (void) stmf_ctl(STMF_CMD_LPORT_OFFLINE, lport, &sci); 728 break; 729 case TS_OFFLINING: 730 /* Async callback generates completion event */ 731 iscsit_tgt_offline(tgt); 732 break; 733 case TS_OFFLINE: 734 break; 735 case TS_STMF_OFFLINE: 736 break; 737 case TS_DELETING_STMF_DEREG: 738 stmfrc = stmf_deregister_local_port(tgt->target_stmf_lport); 739 if (stmfrc == STMF_SUCCESS) { 740 iscsit_tgt_sm_event(tgt, TE_STMF_DEREG_SUCCESS); 741 } else { 742 iscsit_tgt_sm_event(tgt, TE_STMF_DEREG_FAIL); 743 } 744 break; 745 case TS_DELETING_STMF_DEREG_FAIL: 746 /* Retry dereg in 1 second */ 747 (void) timeout(iscsit_tgt_dereg_retry, tgt, 748 drv_usectohz(TGT_DEREG_RETRY_SECONDS * 1000000)); 749 break; 750 case TS_DELETING: 751 iscsit_tgt_async_wait_ref(tgt, iscsit_tgt_unref); 752 break; 753 default: 754 ASSERT(0); 755 } 756 } 757 758 759 /* 760 * Target, TPGT, TPG utility functions 761 */ 762 763 it_cfg_status_t 764 iscsit_config_merge_tgt(it_config_t *cfg) 765 { 766 it_tgt_t *cfg_tgt; 767 iscsit_tgt_t *tgt, *next_tgt; 768 it_cfg_status_t itrc = ITCFG_SUCCESS; 769 770 771 /* 772 * 1. >> Lock << 773 * 2. Removing deleted objects 774 * 3. Add deleted targets to global delete list 775 * 4. "delete" event to target state machine 776 * 5. >> Unlock << 777 * 6. Create new targets, update modified targets 778 */ 779 for (tgt = avl_first(&iscsit_global.global_target_list); 780 tgt != NULL; 781 tgt = next_tgt) { 782 next_tgt = AVL_NEXT(&iscsit_global.global_target_list, tgt); 783 784 if (it_tgt_lookup(cfg, tgt->target_name) == NULL) { 785 avl_remove(&iscsit_global.global_target_list, tgt); 786 list_insert_tail( 787 &iscsit_global.global_deleted_target_list, tgt); 788 iscsit_tgt_sm_event(tgt, TE_DELETE); 789 } 790 } 791 792 /* Now walk through the list of configured targets */ 793 for (cfg_tgt = cfg->config_tgt_list; 794 cfg_tgt != NULL; 795 cfg_tgt = cfg_tgt->tgt_next) { 796 /* See if we have an existing target */ 797 tgt = iscsit_tgt_lookup_locked(cfg_tgt->tgt_name); 798 799 if (tgt == NULL) { 800 tgt = iscsit_tgt_create(cfg_tgt); 801 if (tgt == NULL) 802 return (ITCFG_TGT_CREATE_ERR); 803 avl_add(&iscsit_global.global_target_list, tgt); 804 } else { 805 if (iscsit_tgt_modify(tgt, cfg_tgt) != 806 IDM_STATUS_SUCCESS) 807 itrc = ITCFG_MISC_ERR; 808 iscsit_tgt_rele(tgt); 809 } 810 } 811 812 /* 813 * Targets on the iscsit_global.global_deleted_target_list will remove 814 * and destroy themselves when their associated state machines reach 815 * the TS_DELETED state and all references are released. 816 */ 817 return (itrc); 818 } 819 820 iscsit_tgt_t * 821 iscsit_tgt_lookup(char *target_name) 822 { 823 iscsit_tgt_t *result; 824 825 ISCSIT_GLOBAL_LOCK(RW_READER); 826 result = iscsit_tgt_lookup_locked(target_name); 827 ISCSIT_GLOBAL_UNLOCK(); 828 829 return (result); 830 } 831 832 iscsit_tgt_t * 833 iscsit_tgt_lookup_locked(char *target_name) 834 { 835 iscsit_tgt_t tmp_tgt; 836 iscsit_tgt_t *result; 837 838 /* 839 * Use a dummy target for lookup, filling in all fields used in AVL 840 * comparison. 841 */ 842 tmp_tgt.target_name = target_name; 843 if ((result = avl_find(&iscsit_global.global_target_list, 844 &tmp_tgt, NULL)) != NULL) { 845 iscsit_tgt_hold(result); 846 } 847 848 return (result); 849 } 850 851 iscsit_tgt_t * 852 iscsit_tgt_create(it_tgt_t *cfg_tgt) 853 { 854 iscsit_tgt_t *result; 855 stmf_local_port_t *lport; 856 char *alias; 857 858 /* 859 * Each target is an STMF local port. 860 */ 861 lport = stmf_alloc(STMF_STRUCT_STMF_LOCAL_PORT, 862 sizeof (iscsit_tgt_t) + sizeof (scsi_devid_desc_t) + 863 strnlen(cfg_tgt->tgt_name, MAX_ISCSI_NODENAMELEN) + 1, 0); 864 if (lport == NULL) { 865 return (NULL); 866 } 867 868 result = lport->lport_port_private; 869 result->target_state = TS_CREATED; 870 result->target_stmf_lport_registered = 0; 871 /* Use pointer arithmetic to find scsi_devid_desc_t */ 872 result->target_devid = (scsi_devid_desc_t *)(result + 1); 873 (void) strcpy((char *)result->target_devid->ident, cfg_tgt->tgt_name); 874 result->target_devid->ident_length = 875 strnlen(cfg_tgt->tgt_name, MAX_ISCSI_NODENAMELEN); 876 result->target_devid->protocol_id = PROTOCOL_iSCSI; 877 result->target_devid->piv = 1; 878 result->target_devid->code_set = CODE_SET_ASCII; 879 result->target_devid->association = ID_IS_TARGET_PORT; 880 881 /* Store a shortcut to the target name */ 882 result->target_name = (char *)result->target_devid->ident; 883 idm_sm_audit_init(&result->target_state_audit); 884 mutex_init(&result->target_mutex, NULL, MUTEX_DEFAULT, NULL); 885 avl_create(&result->target_sess_list, iscsit_sess_avl_compare, 886 sizeof (iscsit_sess_t), offsetof(iscsit_sess_t, ist_tgt_ln)); 887 avl_create(&result->target_tpgt_list, iscsit_tpgt_avl_compare, 888 sizeof (iscsit_tpgt_t), offsetof(iscsit_tpgt_t, tpgt_tgt_ln)); 889 list_create(&result->target_events, sizeof (tgt_event_ctx_t), 890 offsetof(tgt_event_ctx_t, te_ctx_node)); 891 idm_refcnt_init(&result->target_refcnt, result); 892 idm_refcnt_init(&result->target_sess_refcnt, result); 893 894 /* Set target alias */ 895 if (nvlist_lookup_string(cfg_tgt->tgt_properties, "alias", &alias) == 0) 896 lport->lport_alias = strdup(alias); 897 898 /* Finish initializing local port */ 899 /* 900 * Would like infinite timeout, but this is about as long as can 901 * be specified to stmf on a 32 bit kernel. 902 */ 903 lport->lport_abort_timeout = 2000; /* seconds */ 904 lport->lport_id = result->target_devid; 905 lport->lport_pp = iscsit_global.global_pp; 906 lport->lport_ds = iscsit_global.global_dbuf_store; 907 lport->lport_xfer_data = &iscsit_xfer_scsi_data; 908 lport->lport_send_status = &iscsit_send_scsi_status; 909 lport->lport_task_free = &iscsit_lport_task_free; 910 lport->lport_abort = &iscsit_abort; 911 lport->lport_ctl = &iscsit_ctl; 912 result->target_stmf_lport = lport; 913 914 /* 915 * We need a global hold until the STMF-ONLINE state machine 916 * completes. Acquire that hold now, in case we need to call 917 * iscsit_tgt_destroy, which will also release the hold. 918 */ 919 iscsit_global_hold(); 920 921 /* 922 * Additional target modifications from config 923 */ 924 if (iscsit_tgt_modify(result, cfg_tgt) != IDM_STATUS_SUCCESS) { 925 iscsit_tgt_destroy(result); 926 return (NULL); 927 } 928 929 /* 930 * Register the target with STMF but not until we have all the 931 * TPGT bindings and any other additional config setup. STMF 932 * may immediately ask us to go online. 933 */ 934 if (stmf_register_local_port(lport) != STMF_SUCCESS) { 935 iscsit_tgt_destroy(result); 936 return (NULL); 937 } 938 result->target_stmf_lport_registered = 1; 939 940 return (result); 941 } 942 943 static idm_status_t 944 iscsit_tgt_modify(iscsit_tgt_t *tgt, it_tgt_t *cfg_tgt) 945 { 946 idm_status_t idmrc = IDM_STATUS_SUCCESS; 947 list_t tpgt_del_list; 948 char *alias; 949 950 /* Merge TPGT */ 951 list_create(&tpgt_del_list, sizeof (iscsit_tpgt_t), 952 offsetof(iscsit_tpgt_t, tpgt_delete_ln)); 953 954 mutex_enter(&tgt->target_mutex); 955 if (tgt->target_props) { 956 nvlist_free(tgt->target_props); 957 tgt->target_props = NULL; 958 } 959 (void) nvlist_dup(cfg_tgt->tgt_properties, &tgt->target_props, 960 KM_SLEEP); 961 962 /* Update alias */ 963 if (tgt->target_stmf_lport->lport_alias) { 964 strfree(tgt->target_stmf_lport->lport_alias); 965 tgt->target_stmf_lport->lport_alias = NULL; 966 } 967 if (nvlist_lookup_string(tgt->target_props, "alias", &alias) == 0) 968 tgt->target_stmf_lport->lport_alias = strdup(alias); 969 970 if ((idmrc = iscsit_tgt_merge_tpgt(tgt, cfg_tgt, &tpgt_del_list)) != 971 IDM_STATUS_SUCCESS) { 972 /* This should never happen */ 973 cmn_err(CE_WARN, "Fail to configure TPGTs for " 974 "target %s, the target modification could not be " 975 "completed.", tgt->target_name); 976 } 977 978 mutex_exit(&tgt->target_mutex); 979 980 iscsit_config_destroy_tpgts(&tpgt_del_list); 981 982 /* 983 * If the target is truly modified (not newly created), 984 * inform iSNS to update the target registration. 985 */ 986 if ((tgt->target_generation > 0) && 987 (cfg_tgt->tgt_generation > tgt->target_generation)) { 988 iscsit_isns_target_update(tgt); 989 } 990 991 tgt->target_generation = cfg_tgt->tgt_generation; 992 993 return (idmrc); 994 } 995 996 void 997 iscsit_config_destroy_tpgts(list_t *tpgt_del_list) 998 { 999 iscsit_tpgt_t *tpgt, *next_tpgt; 1000 1001 for (tpgt = list_head(tpgt_del_list); 1002 tpgt != NULL; 1003 tpgt = next_tpgt) { 1004 next_tpgt = list_next(tpgt_del_list, tpgt); 1005 1006 list_remove(tpgt_del_list, tpgt); 1007 idm_refcnt_wait_ref(&tpgt->tpgt_refcnt); 1008 iscsit_tpgt_destroy(tpgt); 1009 } 1010 } 1011 1012 void 1013 iscsit_tgt_unref(void *tgt_void) 1014 { 1015 iscsit_tgt_t *tgt = tgt_void; 1016 1017 ISCSIT_GLOBAL_LOCK(RW_WRITER); 1018 list_remove(&iscsit_global.global_deleted_target_list, tgt); 1019 ISCSIT_GLOBAL_UNLOCK(); 1020 iscsit_tgt_destroy(tgt); 1021 } 1022 1023 void 1024 iscsit_tgt_async_wait_ref(iscsit_tgt_t *tgt, idm_refcnt_cb_t *cb_func) 1025 { 1026 idm_refcnt_async_wait_ref(&tgt->target_refcnt, cb_func); 1027 } 1028 1029 static void 1030 iscsit_tgt_destroy(iscsit_tgt_t *tgt) 1031 { 1032 iscsit_tpgt_t *tpgt, *next_tpgt; 1033 1034 ASSERT(tgt->target_state == TS_DELETING || 1035 (tgt->target_state == TS_CREATED && 1036 tgt->target_stmf_lport_registered == 0)); 1037 1038 /* 1039 * Destroy all target portal group tags 1040 */ 1041 mutex_enter(&tgt->target_mutex); 1042 for (tpgt = avl_first(&tgt->target_tpgt_list); 1043 tpgt != NULL; 1044 tpgt = next_tpgt) { 1045 next_tpgt = AVL_NEXT(&tgt->target_tpgt_list, tpgt); 1046 avl_remove(&tgt->target_tpgt_list, tpgt); 1047 iscsit_tpgt_destroy(tpgt); 1048 } 1049 1050 if (tgt->target_props) { 1051 nvlist_free(tgt->target_props); 1052 } 1053 mutex_exit(&tgt->target_mutex); 1054 1055 /* 1056 * Destroy target 1057 */ 1058 idm_refcnt_destroy(&tgt->target_sess_refcnt); 1059 idm_refcnt_destroy(&tgt->target_refcnt); 1060 list_destroy(&tgt->target_events); 1061 avl_destroy(&tgt->target_tpgt_list); 1062 avl_destroy(&tgt->target_sess_list); 1063 mutex_destroy(&tgt->target_mutex); 1064 if (tgt->target_stmf_lport->lport_alias) 1065 strfree(tgt->target_stmf_lport->lport_alias); 1066 stmf_free(tgt->target_stmf_lport); /* Also frees "tgt' */ 1067 iscsit_global_rele(); 1068 } 1069 1070 void 1071 iscsit_tgt_hold(iscsit_tgt_t *tgt) 1072 { 1073 idm_refcnt_hold(&tgt->target_refcnt); 1074 } 1075 1076 void 1077 iscsit_tgt_rele(iscsit_tgt_t *tgt) 1078 { 1079 idm_refcnt_rele(&tgt->target_refcnt); 1080 } 1081 1082 int 1083 iscsit_tgt_avl_compare(const void *void_tgt1, const void *void_tgt2) 1084 { 1085 const iscsit_tgt_t *tgt1 = void_tgt1; 1086 const iscsit_tgt_t *tgt2 = void_tgt2; 1087 int result; 1088 1089 /* 1090 * Sort by ISID first then TSIH 1091 */ 1092 result = strcmp(tgt1->target_name, tgt2->target_name); 1093 if (result < 0) { 1094 return (-1); 1095 } else if (result > 0) { 1096 return (1); 1097 } 1098 1099 return (0); 1100 } 1101 1102 1103 iscsit_tpgt_t * 1104 iscsit_tgt_lookup_tpgt(iscsit_tgt_t *tgt, uint16_t tag) 1105 { 1106 iscsit_tpgt_t *result; 1107 1108 mutex_enter(&tgt->target_mutex); 1109 result = iscsit_tgt_lookup_tpgt_locked(tgt, tag); 1110 mutex_exit(&tgt->target_mutex); 1111 1112 return (result); 1113 } 1114 1115 static iscsit_tpgt_t * 1116 iscsit_tgt_lookup_tpgt_locked(iscsit_tgt_t *tgt, uint16_t tag) 1117 { 1118 iscsit_tpgt_t tmp_tpgt; 1119 iscsit_tpgt_t *result; 1120 1121 /* Caller holds tgt->target_mutex */ 1122 tmp_tpgt.tpgt_tag = tag; 1123 if ((result = avl_find(&tgt->target_tpgt_list, &tmp_tpgt, NULL)) != 1124 NULL) { 1125 iscsit_tpgt_hold(result); 1126 } 1127 1128 return (result); 1129 } 1130 1131 iscsit_portal_t * 1132 iscsit_tgt_lookup_portal(iscsit_tgt_t *tgt, struct sockaddr_storage *sa, 1133 iscsit_tpgt_t **output_tpgt) 1134 { 1135 iscsit_tpgt_t *tpgt; 1136 iscsit_portal_t *portal; 1137 1138 /* Caller holds tgt->target_mutex */ 1139 ASSERT(mutex_owned(&tgt->target_mutex)); 1140 for (tpgt = avl_first(&tgt->target_tpgt_list); 1141 tpgt != NULL; 1142 tpgt = AVL_NEXT(&tgt->target_tpgt_list, tpgt)) { 1143 portal = iscsit_tpg_portal_lookup(tpgt->tpgt_tpg, sa); 1144 if (portal) { 1145 iscsit_tpgt_hold(tpgt); 1146 *output_tpgt = tpgt; 1147 return (portal); 1148 } 1149 } 1150 1151 return (NULL); 1152 } 1153 1154 1155 void 1156 iscsit_tgt_bind_sess(iscsit_tgt_t *tgt, iscsit_sess_t *sess) 1157 { 1158 if (tgt) { 1159 sess->ist_lport = tgt->target_stmf_lport; 1160 iscsit_tgt_hold(tgt); 1161 idm_refcnt_hold(&tgt->target_sess_refcnt); 1162 mutex_enter(&tgt->target_mutex); 1163 avl_add(&tgt->target_sess_list, sess); 1164 mutex_exit(&tgt->target_mutex); 1165 } else { 1166 /* Discovery session */ 1167 sess->ist_lport = NULL; 1168 ISCSIT_GLOBAL_LOCK(RW_WRITER); 1169 avl_add(&iscsit_global.global_discovery_sessions, sess); 1170 ISCSIT_GLOBAL_UNLOCK(); 1171 } 1172 } 1173 1174 void 1175 iscsit_tgt_unbind_sess(iscsit_tgt_t *tgt, iscsit_sess_t *sess) 1176 { 1177 if (tgt) { 1178 mutex_enter(&tgt->target_mutex); 1179 avl_remove(&tgt->target_sess_list, sess); 1180 mutex_exit(&tgt->target_mutex); 1181 sess->ist_tgt = (iscsit_tgt_t *)SESS_UNBOUND_FROM_TGT; 1182 idm_refcnt_rele(&tgt->target_sess_refcnt); 1183 iscsit_tgt_rele(tgt); 1184 } else { 1185 /* Discovery session */ 1186 ISCSIT_GLOBAL_LOCK(RW_WRITER); 1187 avl_remove(&iscsit_global.global_discovery_sessions, sess); 1188 ISCSIT_GLOBAL_UNLOCK(); 1189 } 1190 } 1191 1192 #define LOCK_FOR_SESS_LOOKUP(lookup_tgt) { \ 1193 if ((lookup_tgt) == NULL) { \ 1194 ISCSIT_GLOBAL_LOCK(RW_READER); \ 1195 } else { \ 1196 mutex_enter(&(lookup_tgt)->target_mutex); \ 1197 } \ 1198 } 1199 1200 #define UNLOCK_FOR_SESS_LOOKUP(lookup_tgt) { \ 1201 if ((lookup_tgt) == NULL) { \ 1202 ISCSIT_GLOBAL_UNLOCK(); \ 1203 } else { \ 1204 mutex_exit(&(lookup_tgt)->target_mutex); \ 1205 } \ 1206 } 1207 1208 iscsit_sess_t * 1209 iscsit_tgt_lookup_sess(iscsit_tgt_t *tgt, char *initiator_name, 1210 uint8_t *isid, uint16_t tsih, uint16_t tag) 1211 { 1212 iscsit_sess_t tmp_sess; 1213 avl_tree_t *sess_avl; 1214 avl_index_t where; 1215 iscsit_sess_t *result; 1216 1217 /* 1218 * If tgt is NULL then we are looking for a discovery session 1219 */ 1220 if (tgt == NULL) { 1221 sess_avl = &iscsit_global.global_discovery_sessions; 1222 } else { 1223 sess_avl = &tgt->target_sess_list; 1224 } 1225 1226 LOCK_FOR_SESS_LOOKUP(tgt); 1227 if (avl_numnodes(sess_avl) == NULL) { 1228 UNLOCK_FOR_SESS_LOOKUP(tgt); 1229 return (NULL); 1230 } 1231 1232 /* 1233 * We'll try to find a session matching ISID + TSIH first. If we 1234 * can't find one then we will return the closest match. If the 1235 * caller needs an exact match it must compare the TSIH after 1236 * the session is returned. 1237 * 1238 * The reason we do this "fuzzy matching" is to allow matching 1239 * sessions with different TSIH values on the same AVL list. This 1240 * makes session reinstatement much easier since the new session can 1241 * live on the list at the same time as the old session is cleaning up. 1242 */ 1243 bcopy(isid, tmp_sess.ist_isid, ISCSI_ISID_LEN); 1244 tmp_sess.ist_initiator_name = initiator_name; 1245 tmp_sess.ist_tsih = tsih; 1246 tmp_sess.ist_tpgt_tag = tag; 1247 1248 result = avl_find(sess_avl, &tmp_sess, &where); 1249 if (result != NULL) { 1250 goto found_result; 1251 } 1252 1253 /* 1254 * avl_find_nearest() may return a result with a different ISID so 1255 * we should only return a result if the name and ISID match 1256 */ 1257 result = avl_nearest(sess_avl, where, AVL_BEFORE); 1258 if ((result != NULL) && 1259 (strcmp(result->ist_initiator_name, initiator_name) == 0) && 1260 (memcmp(result->ist_isid, isid, ISCSI_ISID_LEN) == 0) && 1261 (result->ist_tpgt_tag == tag)) { 1262 goto found_result; 1263 } 1264 1265 result = avl_nearest(sess_avl, where, AVL_AFTER); 1266 if ((result != NULL) && 1267 (strcmp(result->ist_initiator_name, initiator_name) == 0) && 1268 (memcmp(result->ist_isid, isid, ISCSI_ISID_LEN) == 0) && 1269 (result->ist_tpgt_tag == tag)) { 1270 goto found_result; 1271 } 1272 1273 result = NULL; 1274 1275 found_result: 1276 if ((result != NULL) && 1277 (iscsit_sess_check_hold(result) != IDM_STATUS_SUCCESS)) { 1278 result = NULL; 1279 } 1280 UNLOCK_FOR_SESS_LOOKUP(tgt); 1281 return (result); 1282 } 1283 1284 static idm_status_t 1285 iscsit_tgt_merge_tpgt(iscsit_tgt_t *tgt, it_tgt_t *cfg_tgt, 1286 list_t *tpgt_del_list) 1287 { 1288 iscsit_tpgt_t *tpgt, *next_tpgt; 1289 it_tpgt_t *cfg_tpgt; 1290 idm_status_t status = IDM_STATUS_SUCCESS; 1291 1292 /* 1293 * 1. >> Lock << 1294 * 2. Removing all objects and place on a temp list 1295 * 3. Add new objects 1296 * 4. >> Unlock << 1297 * 5. tpgt_del_list contains deleted objects 1298 */ 1299 ASSERT(avl_is_empty(&tgt->target_tpgt_list) || 1300 (tpgt_del_list != NULL)); 1301 1302 if (tpgt_del_list) { 1303 for (tpgt = avl_first(&tgt->target_tpgt_list); 1304 tpgt != NULL; tpgt = next_tpgt) { 1305 next_tpgt = AVL_NEXT(&tgt->target_tpgt_list, tpgt); 1306 avl_remove(&tgt->target_tpgt_list, tpgt); 1307 if (tgt->target_state == TS_STMF_ONLINE) { 1308 tpgt->tpgt_needs_tpg_offline = B_TRUE; 1309 } 1310 list_insert_tail(tpgt_del_list, tpgt); 1311 } 1312 } 1313 1314 if (cfg_tgt->tgt_tpgt_list != NULL) { 1315 /* Add currently defined TPGTs */ 1316 for (cfg_tpgt = cfg_tgt->tgt_tpgt_list; 1317 cfg_tpgt != NULL; 1318 cfg_tpgt = cfg_tpgt->tpgt_next) { 1319 tpgt = iscsit_tpgt_create(cfg_tpgt); 1320 if (tpgt == NULL) { 1321 /* 1322 * There is a problem in the configuration we 1323 * received from the ioctl -- a missing tpg. 1324 * All the unbind operations have already 1325 * taken place. To leave the system in a 1326 * non-panic'd state, use the default tpgt. 1327 */ 1328 status = IDM_STATUS_FAIL; 1329 continue; 1330 } 1331 if (tgt->target_state == TS_STMF_ONLINE) { 1332 (void) iscsit_tpg_online(tpgt->tpgt_tpg); 1333 } 1334 avl_add(&tgt->target_tpgt_list, tpgt); 1335 } 1336 } 1337 1338 /* If no TPGTs defined, add the default TPGT */ 1339 if (avl_numnodes(&tgt->target_tpgt_list) == 0) { 1340 tpgt = iscsit_tpgt_create_default(); 1341 if (tgt->target_state == TS_STMF_ONLINE) { 1342 (void) iscsit_tpg_online(tpgt->tpgt_tpg); 1343 } 1344 avl_add(&tgt->target_tpgt_list, tpgt); 1345 } 1346 1347 return (status); 1348 } 1349 1350 static iscsit_tpgt_t * 1351 iscsit_tpgt_create(it_tpgt_t *cfg_tpgt) 1352 { 1353 iscsit_tpg_t *tpg; 1354 iscsit_tpgt_t *result; 1355 1356 /* This takes a reference on the TPG */ 1357 tpg = iscsit_tpg_lookup_locked(cfg_tpgt->tpgt_tpg_name); 1358 if (tpg == NULL) 1359 return (NULL); 1360 1361 result = kmem_zalloc(sizeof (*result), KM_SLEEP); 1362 1363 result->tpgt_tpg = tpg; 1364 result->tpgt_tag = cfg_tpgt->tpgt_tag; 1365 1366 return (result); 1367 } 1368 1369 iscsit_tpgt_t * 1370 iscsit_tpgt_create_default() 1371 { 1372 iscsit_tpgt_t *result; 1373 1374 result = kmem_zalloc(sizeof (*result), KM_SLEEP); 1375 1376 result->tpgt_tpg = iscsit_global.global_default_tpg; 1377 iscsit_tpg_hold(result->tpgt_tpg); 1378 result->tpgt_tag = ISCSIT_DEFAULT_TPGT; 1379 1380 return (result); 1381 } 1382 1383 void 1384 iscsit_tpgt_destroy(iscsit_tpgt_t *tpgt) 1385 { 1386 if (tpgt->tpgt_needs_tpg_offline) { 1387 iscsit_tpg_offline(tpgt->tpgt_tpg); 1388 } 1389 iscsit_tpg_rele(tpgt->tpgt_tpg); 1390 kmem_free(tpgt, sizeof (*tpgt)); 1391 } 1392 1393 void 1394 iscsit_tpgt_hold(iscsit_tpgt_t *tpgt) 1395 { 1396 idm_refcnt_hold(&tpgt->tpgt_refcnt); 1397 } 1398 1399 void 1400 iscsit_tpgt_rele(iscsit_tpgt_t *tpgt) 1401 { 1402 idm_refcnt_rele(&tpgt->tpgt_refcnt); 1403 } 1404 1405 int 1406 iscsit_tpgt_avl_compare(const void *void_tpgt1, const void *void_tpgt2) 1407 { 1408 const iscsit_tpgt_t *tpgt1 = void_tpgt1; 1409 const iscsit_tpgt_t *tpgt2 = void_tpgt2; 1410 1411 if (tpgt1->tpgt_tag < tpgt2->tpgt_tag) 1412 return (-1); 1413 else if (tpgt1->tpgt_tag > tpgt2->tpgt_tag) 1414 return (1); 1415 1416 return (0); 1417 } 1418 1419 static idm_status_t 1420 iscsit_tgt_online(iscsit_tgt_t *tgt) 1421 { 1422 iscsit_tpgt_t *tpgt, *tpgt_fail; 1423 idm_status_t rc; 1424 1425 mutex_enter(&tgt->target_mutex); 1426 1427 ASSERT(tgt->target_sess_list.avl_numnodes == 0); 1428 idm_refcnt_reset(&tgt->target_sess_refcnt); 1429 for (tpgt = avl_first(&tgt->target_tpgt_list); 1430 tpgt != NULL; 1431 tpgt = AVL_NEXT(&tgt->target_tpgt_list, tpgt)) { 1432 rc = iscsit_tpg_online(tpgt->tpgt_tpg); 1433 if (rc != IDM_STATUS_SUCCESS) { 1434 tpgt_fail = tpgt; 1435 goto tgt_online_fail; 1436 } 1437 } 1438 1439 mutex_exit(&tgt->target_mutex); 1440 1441 return (IDM_STATUS_SUCCESS); 1442 1443 tgt_online_fail: 1444 /* Offline all the tpgs we successfully onlined up to the failure */ 1445 for (tpgt = avl_first(&tgt->target_tpgt_list); 1446 tpgt != tpgt_fail; 1447 tpgt = AVL_NEXT(&tgt->target_tpgt_list, tpgt)) { 1448 iscsit_tpg_offline(tpgt->tpgt_tpg); 1449 } 1450 mutex_exit(&tgt->target_mutex); 1451 return (rc); 1452 } 1453 1454 static void 1455 iscsit_tgt_offline_cb(void *tgt_void) 1456 { 1457 iscsit_tgt_t *tgt = tgt_void; 1458 stmf_change_status_t scs; 1459 1460 iscsit_tgt_sm_event(tgt, TE_OFFLINE_COMPLETE); 1461 1462 scs.st_completion_status = STMF_SUCCESS; 1463 scs.st_additional_info = NULL; 1464 (void) stmf_ctl(STMF_CMD_LPORT_OFFLINE_COMPLETE, 1465 tgt->target_stmf_lport, &scs); 1466 } 1467 1468 static void 1469 iscsit_tgt_offline(iscsit_tgt_t *tgt) 1470 { 1471 iscsit_tpgt_t *tpgt; 1472 iscsit_sess_t *ist; 1473 1474 mutex_enter(&tgt->target_mutex); 1475 1476 /* Offline target portal groups */ 1477 for (tpgt = avl_first(&tgt->target_tpgt_list); 1478 tpgt != NULL; 1479 tpgt = AVL_NEXT(&tgt->target_tpgt_list, tpgt)) { 1480 iscsit_tpg_offline(tpgt->tpgt_tpg); 1481 } 1482 1483 /* Close any active sessions */ 1484 for (ist = avl_first(&tgt->target_sess_list); 1485 ist != NULL; 1486 ist = AVL_NEXT(&tgt->target_sess_list, ist)) { 1487 /* 1488 * This is not a synchronous operation but after all 1489 * sessions have been cleaned up there will be no 1490 * more session-related holds on the target. 1491 */ 1492 iscsit_sess_close(ist); 1493 } 1494 1495 mutex_exit(&tgt->target_mutex); 1496 1497 /* 1498 * Wait for all the sessions to quiesce. 1499 */ 1500 idm_refcnt_async_wait_ref(&tgt->target_sess_refcnt, 1501 &iscsit_tgt_offline_cb); 1502 } 1503 1504 it_cfg_status_t 1505 iscsit_config_merge_tpg(it_config_t *cfg, list_t *tpg_del_list) 1506 { 1507 it_tpg_t *cfg_tpg; 1508 iscsit_tpg_t *tpg, *next_tpg; 1509 1510 /* 1511 * 1. >> Lock << 1512 * 2. Removing deleted objects and place on a temp list 1513 * 3. Add new objects 1514 * 4. >> Unlock << 1515 * 5. tpg_del_list contains objects to destroy 1516 */ 1517 for (tpg = avl_first(&iscsit_global.global_tpg_list); 1518 tpg != NULL; 1519 tpg = next_tpg) { 1520 next_tpg = AVL_NEXT(&iscsit_global.global_tpg_list, tpg); 1521 1522 if (it_tpg_lookup(cfg, tpg->tpg_name) == NULL) { 1523 /* 1524 * The policy around when to allow a target portal 1525 * group to be deleted is implemented in libiscsit. 1526 * By the time the request gets to the kernel module 1527 * we expect that it conforms to policy so we will 1528 * cleanup all references to TPG and destroy it if it 1529 * is possible to do so. 1530 * 1531 */ 1532 avl_remove(&iscsit_global.global_tpg_list, tpg); 1533 list_insert_tail(tpg_del_list, tpg); 1534 } 1535 } 1536 1537 /* Now walk through the list of configured target portal groups */ 1538 for (cfg_tpg = cfg->config_tpg_list; 1539 cfg_tpg != NULL; 1540 cfg_tpg = cfg_tpg->tpg_next) { 1541 /* See if we have an existing target portal group */ 1542 tpg = iscsit_tpg_lookup_locked(cfg_tpg->tpg_name); 1543 1544 if (tpg == NULL) { 1545 tpg = iscsit_tpg_create(cfg_tpg); 1546 ASSERT(tpg != NULL); 1547 avl_add(&iscsit_global.global_tpg_list, tpg); 1548 } else { 1549 mutex_enter(&tpg->tpg_mutex); 1550 iscsit_tpg_modify(tpg, cfg_tpg); 1551 mutex_exit(&tpg->tpg_mutex); 1552 iscsit_tpg_rele(tpg); 1553 } 1554 } 1555 1556 return (ITCFG_SUCCESS); 1557 } 1558 1559 1560 void 1561 iscsit_config_destroy_tpgs(list_t *tpg_del_list) 1562 { 1563 iscsit_tpg_t *tpg, *next_tpg; 1564 1565 /* Now finish destroying the target portal groups */ 1566 for (tpg = list_head(tpg_del_list); 1567 tpg != NULL; 1568 tpg = next_tpg) { 1569 next_tpg = list_next(tpg_del_list, tpg); 1570 list_remove(tpg_del_list, tpg); 1571 idm_refcnt_wait_ref(&tpg->tpg_refcnt); 1572 1573 /* Kill it */ 1574 iscsit_tpg_destroy(tpg); 1575 } 1576 } 1577 1578 iscsit_tpg_t * 1579 iscsit_tpg_lookup(char *tpg_name) 1580 { 1581 iscsit_tpg_t *result; 1582 1583 ISCSIT_GLOBAL_LOCK(RW_READER); 1584 result = iscsit_tpg_lookup_locked(tpg_name); 1585 ISCSIT_GLOBAL_UNLOCK(); 1586 1587 return (result); 1588 } 1589 1590 static iscsit_tpg_t * 1591 iscsit_tpg_lookup_locked(char *tpg_name) 1592 { 1593 iscsit_tpg_t tmp_tpg; 1594 iscsit_tpg_t *result; 1595 1596 (void) strlcpy(tmp_tpg.tpg_name, tpg_name, MAX_ISCSI_NODENAMELEN); 1597 if ((result = avl_find(&iscsit_global.global_tpg_list, 1598 &tmp_tpg, NULL)) != NULL) { 1599 iscsit_tpg_hold(result); 1600 } 1601 1602 return (result); 1603 } 1604 1605 iscsit_tpg_t * 1606 iscsit_tpg_create(it_tpg_t *cfg_tpg) 1607 { 1608 iscsit_tpg_t *tpg; 1609 1610 tpg = kmem_zalloc(sizeof (*tpg), KM_SLEEP); 1611 1612 mutex_init(&tpg->tpg_mutex, NULL, MUTEX_DEFAULT, NULL); 1613 (void) strlcpy(tpg->tpg_name, cfg_tpg->tpg_name, MAX_TPG_NAMELEN); 1614 avl_create(&tpg->tpg_portal_list, iscsit_portal_avl_compare, 1615 sizeof (iscsit_portal_t), offsetof(iscsit_portal_t, portal_tpg_ln)); 1616 idm_refcnt_init(&tpg->tpg_refcnt, tpg); 1617 1618 mutex_enter(&tpg->tpg_mutex); 1619 iscsit_tpg_modify(tpg, cfg_tpg); 1620 mutex_exit(&tpg->tpg_mutex); 1621 iscsit_global_hold(); 1622 1623 return (tpg); 1624 } 1625 1626 static void 1627 iscsit_tpg_modify(iscsit_tpg_t *tpg, it_tpg_t *cfg_tpg) 1628 { 1629 iscsit_portal_t *portal, *next_portal; 1630 it_portal_t *cfg_portal; 1631 1632 /* Update portals */ 1633 for (portal = avl_first(&tpg->tpg_portal_list); 1634 portal != NULL; 1635 portal = next_portal) { 1636 next_portal = AVL_NEXT(&tpg->tpg_portal_list, portal); 1637 if (it_portal_lookup(cfg_tpg, &portal->portal_addr) == NULL) { 1638 avl_remove(&tpg->tpg_portal_list, portal); 1639 iscsit_portal_delete(portal); 1640 /* 1641 * If the last portal is deleted from the target 1642 * portal group, then the tpg->tpg_online count 1643 * must be decremented. The other two callers of 1644 * iscsit_portal_delete() destroy the target portal 1645 * after deleting the portal so it is not necessary 1646 * to decrement the tpg->tpg_online count. 1647 */ 1648 if (avl_is_empty(&tpg->tpg_portal_list)) { 1649 tpg->tpg_online--; 1650 } 1651 } 1652 } 1653 1654 for (cfg_portal = cfg_tpg->tpg_portal_list; 1655 cfg_portal != NULL; 1656 cfg_portal = cfg_portal->portal_next) { 1657 if ((portal = iscsit_tpg_portal_lookup_locked(tpg, 1658 &cfg_portal->portal_addr)) == NULL) { 1659 (void) iscsit_portal_create(tpg, 1660 &cfg_portal->portal_addr); 1661 } else { 1662 iscsit_portal_rele(portal); 1663 } 1664 } 1665 } 1666 1667 void 1668 iscsit_tpg_destroy(iscsit_tpg_t *tpg) 1669 { 1670 iscsit_portal_t *portal, *next_portal; 1671 1672 for (portal = avl_first(&tpg->tpg_portal_list); 1673 portal != NULL; 1674 portal = next_portal) { 1675 next_portal = AVL_NEXT(&tpg->tpg_portal_list, portal); 1676 avl_remove(&tpg->tpg_portal_list, portal); 1677 iscsit_portal_delete(portal); 1678 } 1679 1680 idm_refcnt_wait_ref(&tpg->tpg_refcnt); 1681 idm_refcnt_destroy(&tpg->tpg_refcnt); 1682 avl_destroy(&tpg->tpg_portal_list); 1683 mutex_destroy(&tpg->tpg_mutex); 1684 kmem_free(tpg, sizeof (*tpg)); 1685 iscsit_global_rele(); 1686 } 1687 1688 void 1689 iscsit_tpg_hold(iscsit_tpg_t *tpg) 1690 { 1691 idm_refcnt_hold(&tpg->tpg_refcnt); 1692 } 1693 1694 void 1695 iscsit_tpg_rele(iscsit_tpg_t *tpg) 1696 { 1697 idm_refcnt_rele(&tpg->tpg_refcnt); 1698 } 1699 1700 iscsit_tpg_t * 1701 iscsit_tpg_createdefault() 1702 { 1703 iscsit_tpg_t *tpg; 1704 1705 tpg = kmem_zalloc(sizeof (*tpg), KM_SLEEP); 1706 1707 mutex_init(&tpg->tpg_mutex, NULL, MUTEX_DEFAULT, NULL); 1708 (void) strlcpy(tpg->tpg_name, ISCSIT_DEFAULT_TPG, MAX_TPG_NAMELEN); 1709 avl_create(&tpg->tpg_portal_list, iscsit_portal_avl_compare, 1710 sizeof (iscsit_portal_t), offsetof(iscsit_portal_t, portal_tpg_ln)); 1711 idm_refcnt_init(&tpg->tpg_refcnt, tpg); 1712 1713 /* Now create default portal */ 1714 if (iscsit_portal_create(tpg, NULL) == NULL) { 1715 iscsit_tpg_destroy(tpg); 1716 return (NULL); 1717 } 1718 1719 return (tpg); 1720 } 1721 1722 void 1723 iscsit_tpg_destroydefault(iscsit_tpg_t *tpg) 1724 { 1725 iscsit_portal_t *portal; 1726 1727 portal = avl_first(&tpg->tpg_portal_list); 1728 ASSERT(portal != NULL); 1729 avl_remove(&tpg->tpg_portal_list, portal); 1730 iscsit_portal_delete(portal); 1731 1732 idm_refcnt_wait_ref(&tpg->tpg_refcnt); 1733 idm_refcnt_destroy(&tpg->tpg_refcnt); 1734 avl_destroy(&tpg->tpg_portal_list); 1735 mutex_destroy(&tpg->tpg_mutex); 1736 kmem_free(tpg, sizeof (*tpg)); 1737 } 1738 1739 int 1740 iscsit_tpg_avl_compare(const void *void_tpg1, const void *void_tpg2) 1741 { 1742 const iscsit_tpg_t *tpg1 = void_tpg1; 1743 const iscsit_tpg_t *tpg2 = void_tpg2; 1744 int result; 1745 1746 /* 1747 * Sort by ISID first then TSIH 1748 */ 1749 result = strcmp(tpg1->tpg_name, tpg2->tpg_name); 1750 if (result < 0) { 1751 return (-1); 1752 } else if (result > 0) { 1753 return (1); 1754 } 1755 1756 return (0); 1757 } 1758 1759 idm_status_t 1760 iscsit_tpg_online(iscsit_tpg_t *tpg) 1761 { 1762 iscsit_portal_t *portal, *portal_fail; 1763 idm_status_t rc; 1764 1765 mutex_enter(&tpg->tpg_mutex); 1766 if (tpg->tpg_online == 0) { 1767 for (portal = avl_first(&tpg->tpg_portal_list); 1768 portal != NULL; 1769 portal = AVL_NEXT(&tpg->tpg_portal_list, portal)) { 1770 rc = iscsit_portal_online(portal); 1771 if (rc != IDM_STATUS_SUCCESS) { 1772 portal_fail = portal; 1773 goto tpg_online_fail; 1774 } 1775 } 1776 } 1777 tpg->tpg_online++; 1778 1779 mutex_exit(&tpg->tpg_mutex); 1780 return (IDM_STATUS_SUCCESS); 1781 1782 tpg_online_fail: 1783 /* Offline all the portals we successfully onlined up to the failure */ 1784 for (portal = avl_first(&tpg->tpg_portal_list); 1785 portal != portal_fail; 1786 portal = AVL_NEXT(&tpg->tpg_portal_list, portal)) { 1787 iscsit_portal_offline(portal); 1788 } 1789 mutex_exit(&tpg->tpg_mutex); 1790 return (rc); 1791 } 1792 1793 void 1794 iscsit_tpg_offline(iscsit_tpg_t *tpg) 1795 { 1796 iscsit_portal_t *portal; 1797 1798 mutex_enter(&tpg->tpg_mutex); 1799 tpg->tpg_online--; 1800 if (tpg->tpg_online == 0) { 1801 for (portal = avl_first(&tpg->tpg_portal_list); 1802 portal != NULL; 1803 portal = AVL_NEXT(&tpg->tpg_portal_list, portal)) { 1804 iscsit_portal_offline(portal); 1805 } 1806 } 1807 mutex_exit(&tpg->tpg_mutex); 1808 } 1809 1810 iscsit_portal_t * 1811 iscsit_tpg_portal_lookup(iscsit_tpg_t *tpg, struct sockaddr_storage *sa) 1812 { 1813 iscsit_portal_t *result; 1814 1815 mutex_enter(&tpg->tpg_mutex); 1816 result = iscsit_tpg_portal_lookup_locked(tpg, sa); 1817 mutex_exit(&tpg->tpg_mutex); 1818 1819 return (result); 1820 } 1821 1822 static iscsit_portal_t * 1823 iscsit_tpg_portal_lookup_locked(iscsit_tpg_t *tpg, 1824 struct sockaddr_storage *sa) 1825 { 1826 iscsit_portal_t tmp_portal; 1827 iscsit_portal_t *result; 1828 1829 /* Caller holds tpg->tpg_mutex */ 1830 bcopy(sa, &tmp_portal.portal_addr, sizeof (*sa)); 1831 if ((result = avl_find(&tpg->tpg_portal_list, &tmp_portal, NULL)) != 1832 NULL) { 1833 iscsit_portal_hold(result); 1834 } 1835 1836 return (result); 1837 } 1838 1839 iscsit_portal_t * 1840 iscsit_portal_create(iscsit_tpg_t *tpg, struct sockaddr_storage *sa) 1841 { 1842 iscsit_portal_t *portal; 1843 1844 portal = kmem_zalloc(sizeof (*portal), KM_SLEEP); 1845 /* 1846 * If (sa == NULL) then we are being asked to create the default 1847 * portal -- targets will use this portal when no portals are 1848 * explicitly configured. 1849 */ 1850 if (sa == NULL) { 1851 portal->portal_default = B_TRUE; 1852 } else { 1853 portal->portal_default = B_FALSE; 1854 bcopy(sa, &portal->portal_addr, sizeof (*sa)); 1855 } 1856 1857 idm_refcnt_init(&portal->portal_refcnt, portal); 1858 1859 /* 1860 * Add this portal to the list 1861 */ 1862 avl_add(&tpg->tpg_portal_list, portal); 1863 1864 return (portal); 1865 } 1866 1867 void 1868 iscsit_portal_delete(iscsit_portal_t *portal) 1869 { 1870 if (portal->portal_online > 0) { 1871 iscsit_portal_offline(portal); 1872 } 1873 1874 if (portal->portal_online == 0) { 1875 ASSERT(portal->portal_svc == NULL); 1876 idm_refcnt_destroy(&portal->portal_refcnt); 1877 kmem_free(portal, sizeof (*portal)); 1878 } 1879 } 1880 1881 void 1882 iscsit_portal_hold(iscsit_portal_t *portal) 1883 { 1884 idm_refcnt_hold(&portal->portal_refcnt); 1885 } 1886 1887 void 1888 iscsit_portal_rele(iscsit_portal_t *portal) 1889 { 1890 idm_refcnt_rele(&portal->portal_refcnt); 1891 } 1892 1893 int 1894 iscsit_portal_avl_compare(const void *void_portal1, const void *void_portal2) 1895 { 1896 const iscsit_portal_t *portal1 = void_portal1; 1897 const iscsit_portal_t *portal2 = void_portal2; 1898 const struct sockaddr_storage *ss1, *ss2; 1899 const struct in_addr *in1, *in2; 1900 const struct in6_addr *in61, *in62; 1901 int i; 1902 1903 /* 1904 * Compare ports, then address family, then ip address 1905 */ 1906 ss1 = &portal1->portal_addr; 1907 ss2 = &portal2->portal_addr; 1908 if (((struct sockaddr_in *)ss1)->sin_port != 1909 ((struct sockaddr_in *)ss2)->sin_port) { 1910 if (((struct sockaddr_in *)ss1)->sin_port > 1911 ((struct sockaddr_in *)ss2)->sin_port) 1912 return (1); 1913 else 1914 return (-1); 1915 } 1916 1917 /* 1918 * ports are the same 1919 */ 1920 if (ss1->ss_family != ss2->ss_family) { 1921 if (ss1->ss_family == AF_INET) 1922 return (1); 1923 else 1924 return (-1); 1925 } 1926 /* 1927 * address families are the same 1928 */ 1929 if (ss1->ss_family == AF_INET) { 1930 in1 = &((struct sockaddr_in *)ss1)->sin_addr; 1931 in2 = &((struct sockaddr_in *)ss2)->sin_addr; 1932 1933 if (in1->s_addr > in2->s_addr) 1934 return (1); 1935 else if (in1->s_addr < in2->s_addr) 1936 return (-1); 1937 else 1938 return (0); 1939 } else if (ss1->ss_family == AF_INET6) { 1940 in61 = &((struct sockaddr_in6 *)ss1)->sin6_addr; 1941 in62 = &((struct sockaddr_in6 *)ss2)->sin6_addr; 1942 1943 for (i = 0; i < 4; i++) { 1944 if (in61->s6_addr32[i] > in62->s6_addr32[i]) 1945 return (1); 1946 else if (in61->s6_addr32[i] < in62->s6_addr32[i]) 1947 return (-1); 1948 } 1949 return (0); 1950 } else 1951 cmn_err(CE_WARN, 1952 "iscsit_portal_avl_compare: unknown ss_family %d", 1953 ss1->ss_family); 1954 1955 return (1); 1956 } 1957 1958 1959 idm_status_t 1960 iscsit_portal_online(iscsit_portal_t *portal) 1961 { 1962 idm_status_t rc = 0; 1963 idm_svc_t *svc; 1964 idm_svc_req_t sr; 1965 uint16_t port; 1966 struct sockaddr_in *sin; 1967 1968 /* Caller holds parent TPG mutex */ 1969 if (portal->portal_online == 0) { 1970 /* 1971 * If there is no existing IDM service instance for this port, 1972 * create one. If the service exists, then the lookup, 1973 * creates a reference on the existing service. 1974 */ 1975 sin = (struct sockaddr_in *)&portal->portal_addr; 1976 port = ntohs(sin->sin_port); 1977 if (port == 0) 1978 port = ISCSI_LISTEN_PORT; 1979 ASSERT(portal->portal_svc == NULL); 1980 if ((svc = idm_tgt_svc_lookup(port)) == NULL) { 1981 sr.sr_port = port; 1982 sr.sr_li = iscsit_global.global_li; 1983 sr.sr_conn_ops.icb_rx_scsi_cmd = &iscsit_op_scsi_cmd; 1984 sr.sr_conn_ops.icb_rx_scsi_rsp = NULL; 1985 sr.sr_conn_ops.icb_rx_misc = &iscsit_rx_pdu; 1986 sr.sr_conn_ops.icb_rx_error = &iscsit_rx_pdu_error; 1987 sr.sr_conn_ops.icb_task_aborted = &iscsit_task_aborted; 1988 sr.sr_conn_ops.icb_client_notify = 1989 &iscsit_client_notify; 1990 sr.sr_conn_ops.icb_build_hdr = &iscsit_build_hdr; 1991 sr.sr_conn_ops.icb_update_statsn = 1992 &iscsit_update_statsn; 1993 sr.sr_conn_ops.icb_keepalive = &iscsit_keepalive; 1994 1995 if (idm_tgt_svc_create(&sr, &svc) != 1996 IDM_STATUS_SUCCESS) { 1997 return (IDM_STATUS_FAIL); 1998 } 1999 2000 /* Get reference on the service we just created */ 2001 idm_tgt_svc_hold(svc); 2002 } 2003 if ((rc = idm_tgt_svc_online(svc)) != IDM_STATUS_SUCCESS) { 2004 idm_tgt_svc_rele_and_destroy(svc); 2005 return (IDM_STATUS_FAIL); 2006 } 2007 portal->portal_svc = svc; 2008 2009 /* 2010 * Only call iSNS for first online 2011 */ 2012 iscsit_isns_portal_online(portal); 2013 } 2014 2015 portal->portal_online++; 2016 2017 return (rc); 2018 } 2019 2020 void 2021 iscsit_portal_offline(iscsit_portal_t *portal) 2022 { 2023 portal->portal_online--; 2024 2025 if (portal->portal_online == 0) { 2026 /* 2027 * Only call iSNS for last offline 2028 */ 2029 iscsit_isns_portal_offline(portal); 2030 idm_tgt_svc_offline(portal->portal_svc); 2031 /* If service is unreferenced, destroy it too */ 2032 idm_tgt_svc_rele_and_destroy(portal->portal_svc); 2033 portal->portal_svc = NULL; 2034 } 2035 2036 } 2037 2038 it_cfg_status_t 2039 iscsit_config_merge_ini(it_config_t *cfg) 2040 { 2041 iscsit_ini_t *ini, *next_ini; 2042 it_ini_t *cfg_ini; 2043 2044 /* 2045 * Initiator objects are so simple we will just destroy all the current 2046 * objects and build new ones. Nothing should ever reference an 2047 * initator object.. instead just lookup the initiator object and 2048 * grab the properties while holding the global config lock. 2049 */ 2050 for (ini = avl_first(&iscsit_global.global_ini_list); 2051 ini != NULL; 2052 ini = next_ini) { 2053 next_ini = AVL_NEXT(&iscsit_global.global_ini_list, ini); 2054 avl_remove(&iscsit_global.global_ini_list, ini); 2055 nvlist_free(ini->ini_props); 2056 kmem_free(ini, sizeof (*ini)); 2057 iscsit_global_rele(); 2058 } 2059 2060 for (cfg_ini = cfg->config_ini_list; 2061 cfg_ini != NULL; 2062 cfg_ini = cfg_ini->ini_next) { 2063 ini = kmem_zalloc(sizeof (iscsit_ini_t), KM_SLEEP); 2064 (void) strlcpy(ini->ini_name, cfg_ini->ini_name, 2065 MAX_ISCSI_NODENAMELEN); 2066 (void) nvlist_dup(cfg_ini->ini_properties, &ini->ini_props, 2067 KM_SLEEP); 2068 avl_add(&iscsit_global.global_ini_list, ini); 2069 iscsit_global_hold(); 2070 } 2071 2072 return (ITCFG_SUCCESS); 2073 } 2074 2075 int 2076 iscsit_ini_avl_compare(const void *void_ini1, const void *void_ini2) 2077 { 2078 const iscsit_ini_t *ini1 = void_ini1; 2079 const iscsit_ini_t *ini2 = void_ini2; 2080 int result; 2081 2082 /* 2083 * Sort by ISID first then TSIH 2084 */ 2085 result = strcmp(ini1->ini_name, ini2->ini_name); 2086 if (result < 0) { 2087 return (-1); 2088 } else if (result > 0) { 2089 return (1); 2090 } 2091 2092 return (0); 2093 } 2094 2095 iscsit_ini_t * 2096 iscsit_ini_lookup_locked(char *ini_name) 2097 { 2098 iscsit_ini_t tmp_ini; 2099 iscsit_ini_t *result; 2100 2101 /* 2102 * Use a dummy target for lookup, filling in all fields used in AVL 2103 * comparison. 2104 */ 2105 (void) strlcpy(tmp_ini.ini_name, ini_name, MAX_ISCSI_NODENAMELEN); 2106 result = avl_find(&iscsit_global.global_ini_list, &tmp_ini, NULL); 2107 2108 return (result); 2109 }