1 /******************************************************************************* 2 * Filename: target_core_tpg.c 3 * 4 * This file contains generic Target Portal Group related functions. 5 * 6 * (c) Copyright 2002-2013 Datera, Inc. 7 * 8 * Nicholas A. Bellinger <nab@kernel.org> 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program; if not, write to the Free Software 22 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 23 * 24 ******************************************************************************/ 25 26 #include <linux/net.h> 27 #include <linux/string.h> 28 #include <linux/timer.h> 29 #include <linux/slab.h> 30 #include <linux/spinlock.h> 31 #include <linux/in.h> 32 #include <linux/export.h> 33 #include <net/sock.h> 34 #include <net/tcp.h> 35 #include <scsi/scsi.h> 36 #include <scsi/scsi_cmnd.h> 37 38 #include <target/target_core_base.h> 39 #include <target/target_core_backend.h> 40 #include <target/target_core_fabric.h> 41 42 #include "target_core_internal.h" 43 44 extern struct se_device *g_lun0_dev; 45 46 static DEFINE_SPINLOCK(tpg_lock); 47 static LIST_HEAD(tpg_list); 48 49 /* core_clear_initiator_node_from_tpg(): 50 * 51 * 52 */ 53 static void core_clear_initiator_node_from_tpg( 54 struct se_node_acl *nacl, 55 struct se_portal_group *tpg) 56 { 57 int i; 58 struct se_dev_entry *deve; 59 struct se_lun *lun; 60 61 spin_lock_irq(&nacl->device_list_lock); 62 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) { 63 deve = nacl->device_list[i]; 64 65 if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS)) 66 continue; 67 68 if (!deve->se_lun) { 69 pr_err("%s device entries device pointer is" 70 " NULL, but Initiator has access.\n", 71 tpg->se_tpg_tfo->get_fabric_name()); 72 continue; 73 } 74 75 lun = deve->se_lun; 76 spin_unlock_irq(&nacl->device_list_lock); 77 core_disable_device_list_for_node(lun, NULL, deve->mapped_lun, 78 TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg); 79 80 spin_lock_irq(&nacl->device_list_lock); 81 } 82 spin_unlock_irq(&nacl->device_list_lock); 83 } 84 85 /* __core_tpg_get_initiator_node_acl(): 86 * 87 * spin_lock_bh(&tpg->acl_node_lock); must be held when calling 88 */ 89 struct se_node_acl *__core_tpg_get_initiator_node_acl( 90 struct se_portal_group *tpg, 91 const char *initiatorname) 92 { 93 struct se_node_acl *acl; 94 95 list_for_each_entry(acl, &tpg->acl_node_list, acl_list) { 96 if (!strcmp(acl->initiatorname, initiatorname)) 97 return acl; 98 } 99 100 return NULL; 101 } 102 103 /* core_tpg_get_initiator_node_acl(): 104 * 105 * 106 */ 107 struct se_node_acl *core_tpg_get_initiator_node_acl( 108 struct se_portal_group *tpg, 109 unsigned char *initiatorname) 110 { 111 struct se_node_acl *acl; 112 113 spin_lock_irq(&tpg->acl_node_lock); 114 acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname); 115 spin_unlock_irq(&tpg->acl_node_lock); 116 117 return acl; 118 } 119 EXPORT_SYMBOL(core_tpg_get_initiator_node_acl); 120 121 /* core_tpg_add_node_to_devs(): 122 * 123 * 124 */ 125 void core_tpg_add_node_to_devs( 126 struct se_node_acl *acl, 127 struct se_portal_group *tpg) 128 { 129 int i = 0; 130 u32 lun_access = 0; 131 struct se_lun *lun; 132 struct se_device *dev; 133 134 spin_lock(&tpg->tpg_lun_lock); 135 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) { 136 lun = tpg->tpg_lun_list[i]; 137 if (lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE) 138 continue; 139 140 spin_unlock(&tpg->tpg_lun_lock); 141 142 dev = lun->lun_se_dev; 143 /* 144 * By default in LIO-Target $FABRIC_MOD, 145 * demo_mode_write_protect is ON, or READ_ONLY; 146 */ 147 if (!tpg->se_tpg_tfo->tpg_check_demo_mode_write_protect(tpg)) { 148 lun_access = TRANSPORT_LUNFLAGS_READ_WRITE; 149 } else { 150 /* 151 * Allow only optical drives to issue R/W in default RO 152 * demo mode. 153 */ 154 if (dev->transport->get_device_type(dev) == TYPE_DISK) 155 lun_access = TRANSPORT_LUNFLAGS_READ_ONLY; 156 else 157 lun_access = TRANSPORT_LUNFLAGS_READ_WRITE; 158 } 159 160 pr_debug("TARGET_CORE[%s]->TPG[%u]_LUN[%u] - Adding %s" 161 " access for LUN in Demo Mode\n", 162 tpg->se_tpg_tfo->get_fabric_name(), 163 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun, 164 (lun_access == TRANSPORT_LUNFLAGS_READ_WRITE) ? 165 "READ-WRITE" : "READ-ONLY"); 166 167 core_enable_device_list_for_node(lun, NULL, lun->unpacked_lun, 168 lun_access, acl, tpg); 169 spin_lock(&tpg->tpg_lun_lock); 170 } 171 spin_unlock(&tpg->tpg_lun_lock); 172 } 173 174 /* core_set_queue_depth_for_node(): 175 * 176 * 177 */ 178 static int core_set_queue_depth_for_node( 179 struct se_portal_group *tpg, 180 struct se_node_acl *acl) 181 { 182 if (!acl->queue_depth) { 183 pr_err("Queue depth for %s Initiator Node: %s is 0," 184 "defaulting to 1.\n", tpg->se_tpg_tfo->get_fabric_name(), 185 acl->initiatorname); 186 acl->queue_depth = 1; 187 } 188 189 return 0; 190 } 191 192 void array_free(void *array, int n) 193 { 194 void **a = array; 195 int i; 196 197 for (i = 0; i < n; i++) 198 kfree(a[i]); 199 kfree(a); 200 } 201 202 static void *array_zalloc(int n, size_t size, gfp_t flags) 203 { 204 void **a; 205 int i; 206 207 a = kzalloc(n * sizeof(void*), flags); 208 if (!a) 209 return NULL; 210 for (i = 0; i < n; i++) { 211 a[i] = kzalloc(size, flags); 212 if (!a[i]) { 213 array_free(a, n); 214 return NULL; 215 } 216 } 217 return a; 218 } 219 220 /* core_create_device_list_for_node(): 221 * 222 * 223 */ 224 static int core_create_device_list_for_node(struct se_node_acl *nacl) 225 { 226 struct se_dev_entry *deve; 227 int i; 228 229 nacl->device_list = array_zalloc(TRANSPORT_MAX_LUNS_PER_TPG, 230 sizeof(struct se_dev_entry), GFP_KERNEL); 231 if (!nacl->device_list) { 232 pr_err("Unable to allocate memory for" 233 " struct se_node_acl->device_list\n"); 234 return -ENOMEM; 235 } 236 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) { 237 deve = nacl->device_list[i]; 238 239 atomic_set(&deve->ua_count, 0); 240 atomic_set(&deve->pr_ref_count, 0); 241 spin_lock_init(&deve->ua_lock); 242 INIT_LIST_HEAD(&deve->alua_port_list); 243 INIT_LIST_HEAD(&deve->ua_list); 244 } 245 246 return 0; 247 } 248 249 /* core_tpg_check_initiator_node_acl() 250 * 251 * 252 */ 253 struct se_node_acl *core_tpg_check_initiator_node_acl( 254 struct se_portal_group *tpg, 255 unsigned char *initiatorname) 256 { 257 struct se_node_acl *acl; 258 259 acl = core_tpg_get_initiator_node_acl(tpg, initiatorname); 260 if (acl) 261 return acl; 262 263 if (!tpg->se_tpg_tfo->tpg_check_demo_mode(tpg)) 264 return NULL; 265 266 acl = tpg->se_tpg_tfo->tpg_alloc_fabric_acl(tpg); 267 if (!acl) 268 return NULL; 269 270 INIT_LIST_HEAD(&acl->acl_list); 271 INIT_LIST_HEAD(&acl->acl_sess_list); 272 kref_init(&acl->acl_kref); 273 init_completion(&acl->acl_free_comp); 274 spin_lock_init(&acl->device_list_lock); 275 spin_lock_init(&acl->nacl_sess_lock); 276 atomic_set(&acl->acl_pr_ref_count, 0); 277 acl->queue_depth = tpg->se_tpg_tfo->tpg_get_default_depth(tpg); 278 snprintf(acl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname); 279 acl->se_tpg = tpg; 280 acl->acl_index = scsi_get_new_index(SCSI_AUTH_INTR_INDEX); 281 spin_lock_init(&acl->stats_lock); 282 acl->dynamic_node_acl = 1; 283 284 tpg->se_tpg_tfo->set_default_node_attributes(acl); 285 286 if (core_create_device_list_for_node(acl) < 0) { 287 tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl); 288 return NULL; 289 } 290 291 if (core_set_queue_depth_for_node(tpg, acl) < 0) { 292 core_free_device_list_for_node(acl, tpg); 293 tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl); 294 return NULL; 295 } 296 /* 297 * Here we only create demo-mode MappedLUNs from the active 298 * TPG LUNs if the fabric is not explicitly asking for 299 * tpg_check_demo_mode_login_only() == 1. 300 */ 301 if ((tpg->se_tpg_tfo->tpg_check_demo_mode_login_only == NULL) || 302 (tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg) != 1)) 303 core_tpg_add_node_to_devs(acl, tpg); 304 305 spin_lock_irq(&tpg->acl_node_lock); 306 list_add_tail(&acl->acl_list, &tpg->acl_node_list); 307 tpg->num_node_acls++; 308 spin_unlock_irq(&tpg->acl_node_lock); 309 310 pr_debug("%s_TPG[%u] - Added DYNAMIC ACL with TCQ Depth: %d for %s" 311 " Initiator Node: %s\n", tpg->se_tpg_tfo->get_fabric_name(), 312 tpg->se_tpg_tfo->tpg_get_tag(tpg), acl->queue_depth, 313 tpg->se_tpg_tfo->get_fabric_name(), initiatorname); 314 315 return acl; 316 } 317 EXPORT_SYMBOL(core_tpg_check_initiator_node_acl); 318 319 void core_tpg_wait_for_nacl_pr_ref(struct se_node_acl *nacl) 320 { 321 while (atomic_read(&nacl->acl_pr_ref_count) != 0) 322 cpu_relax(); 323 } 324 325 void core_tpg_clear_object_luns(struct se_portal_group *tpg) 326 { 327 int i; 328 struct se_lun *lun; 329 330 spin_lock(&tpg->tpg_lun_lock); 331 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) { 332 lun = tpg->tpg_lun_list[i]; 333 334 if ((lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE) || 335 (lun->lun_se_dev == NULL)) 336 continue; 337 338 spin_unlock(&tpg->tpg_lun_lock); 339 core_dev_del_lun(tpg, lun->unpacked_lun); 340 spin_lock(&tpg->tpg_lun_lock); 341 } 342 spin_unlock(&tpg->tpg_lun_lock); 343 } 344 EXPORT_SYMBOL(core_tpg_clear_object_luns); 345 346 /* core_tpg_add_initiator_node_acl(): 347 * 348 * 349 */ 350 struct se_node_acl *core_tpg_add_initiator_node_acl( 351 struct se_portal_group *tpg, 352 struct se_node_acl *se_nacl, 353 const char *initiatorname, 354 u32 queue_depth) 355 { 356 struct se_node_acl *acl = NULL; 357 358 spin_lock_irq(&tpg->acl_node_lock); 359 acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname); 360 if (acl) { 361 if (acl->dynamic_node_acl) { 362 acl->dynamic_node_acl = 0; 363 pr_debug("%s_TPG[%u] - Replacing dynamic ACL" 364 " for %s\n", tpg->se_tpg_tfo->get_fabric_name(), 365 tpg->se_tpg_tfo->tpg_get_tag(tpg), initiatorname); 366 spin_unlock_irq(&tpg->acl_node_lock); 367 /* 368 * Release the locally allocated struct se_node_acl 369 * because * core_tpg_add_initiator_node_acl() returned 370 * a pointer to an existing demo mode node ACL. 371 */ 372 if (se_nacl) 373 tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, 374 se_nacl); 375 goto done; 376 } 377 378 pr_err("ACL entry for %s Initiator" 379 " Node %s already exists for TPG %u, ignoring" 380 " request.\n", tpg->se_tpg_tfo->get_fabric_name(), 381 initiatorname, tpg->se_tpg_tfo->tpg_get_tag(tpg)); 382 spin_unlock_irq(&tpg->acl_node_lock); 383 return ERR_PTR(-EEXIST); 384 } 385 spin_unlock_irq(&tpg->acl_node_lock); 386 387 if (!se_nacl) { 388 pr_err("struct se_node_acl pointer is NULL\n"); 389 return ERR_PTR(-EINVAL); 390 } 391 /* 392 * For v4.x logic the se_node_acl_s is hanging off a fabric 393 * dependent structure allocated via 394 * struct target_core_fabric_ops->fabric_make_nodeacl() 395 */ 396 acl = se_nacl; 397 398 INIT_LIST_HEAD(&acl->acl_list); 399 INIT_LIST_HEAD(&acl->acl_sess_list); 400 kref_init(&acl->acl_kref); 401 init_completion(&acl->acl_free_comp); 402 spin_lock_init(&acl->device_list_lock); 403 spin_lock_init(&acl->nacl_sess_lock); 404 atomic_set(&acl->acl_pr_ref_count, 0); 405 acl->queue_depth = queue_depth; 406 snprintf(acl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname); 407 acl->se_tpg = tpg; 408 acl->acl_index = scsi_get_new_index(SCSI_AUTH_INTR_INDEX); 409 spin_lock_init(&acl->stats_lock); 410 411 tpg->se_tpg_tfo->set_default_node_attributes(acl); 412 413 if (core_create_device_list_for_node(acl) < 0) { 414 tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl); 415 return ERR_PTR(-ENOMEM); 416 } 417 418 if (core_set_queue_depth_for_node(tpg, acl) < 0) { 419 core_free_device_list_for_node(acl, tpg); 420 tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl); 421 return ERR_PTR(-EINVAL); 422 } 423 424 spin_lock_irq(&tpg->acl_node_lock); 425 list_add_tail(&acl->acl_list, &tpg->acl_node_list); 426 tpg->num_node_acls++; 427 spin_unlock_irq(&tpg->acl_node_lock); 428 429 done: 430 pr_debug("%s_TPG[%hu] - Added ACL with TCQ Depth: %d for %s" 431 " Initiator Node: %s\n", tpg->se_tpg_tfo->get_fabric_name(), 432 tpg->se_tpg_tfo->tpg_get_tag(tpg), acl->queue_depth, 433 tpg->se_tpg_tfo->get_fabric_name(), initiatorname); 434 435 return acl; 436 } 437 EXPORT_SYMBOL(core_tpg_add_initiator_node_acl); 438 439 /* core_tpg_del_initiator_node_acl(): 440 * 441 * 442 */ 443 int core_tpg_del_initiator_node_acl( 444 struct se_portal_group *tpg, 445 struct se_node_acl *acl, 446 int force) 447 { 448 LIST_HEAD(sess_list); 449 struct se_session *sess, *sess_tmp; 450 unsigned long flags; 451 int rc; 452 453 spin_lock_irq(&tpg->acl_node_lock); 454 if (acl->dynamic_node_acl) { 455 acl->dynamic_node_acl = 0; 456 } 457 list_del(&acl->acl_list); 458 tpg->num_node_acls--; 459 spin_unlock_irq(&tpg->acl_node_lock); 460 461 spin_lock_irqsave(&acl->nacl_sess_lock, flags); 462 acl->acl_stop = 1; 463 464 list_for_each_entry_safe(sess, sess_tmp, &acl->acl_sess_list, 465 sess_acl_list) { 466 if (sess->sess_tearing_down != 0) 467 continue; 468 469 target_get_session(sess); 470 list_move(&sess->sess_acl_list, &sess_list); 471 } 472 spin_unlock_irqrestore(&acl->nacl_sess_lock, flags); 473 474 list_for_each_entry_safe(sess, sess_tmp, &sess_list, sess_acl_list) { 475 list_del(&sess->sess_acl_list); 476 477 rc = tpg->se_tpg_tfo->shutdown_session(sess); 478 target_put_session(sess); 479 if (!rc) 480 continue; 481 target_put_session(sess); 482 } 483 target_put_nacl(acl); 484 /* 485 * Wait for last target_put_nacl() to complete in target_complete_nacl() 486 * for active fabric session transport_deregister_session() callbacks. 487 */ 488 wait_for_completion(&acl->acl_free_comp); 489 490 core_tpg_wait_for_nacl_pr_ref(acl); 491 core_clear_initiator_node_from_tpg(acl, tpg); 492 core_free_device_list_for_node(acl, tpg); 493 494 pr_debug("%s_TPG[%hu] - Deleted ACL with TCQ Depth: %d for %s" 495 " Initiator Node: %s\n", tpg->se_tpg_tfo->get_fabric_name(), 496 tpg->se_tpg_tfo->tpg_get_tag(tpg), acl->queue_depth, 497 tpg->se_tpg_tfo->get_fabric_name(), acl->initiatorname); 498 499 return 0; 500 } 501 EXPORT_SYMBOL(core_tpg_del_initiator_node_acl); 502 503 /* core_tpg_set_initiator_node_queue_depth(): 504 * 505 * 506 */ 507 int core_tpg_set_initiator_node_queue_depth( 508 struct se_portal_group *tpg, 509 unsigned char *initiatorname, 510 u32 queue_depth, 511 int force) 512 { 513 struct se_session *sess, *init_sess = NULL; 514 struct se_node_acl *acl; 515 unsigned long flags; 516 int dynamic_acl = 0; 517 518 spin_lock_irq(&tpg->acl_node_lock); 519 acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname); 520 if (!acl) { 521 pr_err("Access Control List entry for %s Initiator" 522 " Node %s does not exists for TPG %hu, ignoring" 523 " request.\n", tpg->se_tpg_tfo->get_fabric_name(), 524 initiatorname, tpg->se_tpg_tfo->tpg_get_tag(tpg)); 525 spin_unlock_irq(&tpg->acl_node_lock); 526 return -ENODEV; 527 } 528 if (acl->dynamic_node_acl) { 529 acl->dynamic_node_acl = 0; 530 dynamic_acl = 1; 531 } 532 spin_unlock_irq(&tpg->acl_node_lock); 533 534 spin_lock_irqsave(&tpg->session_lock, flags); 535 list_for_each_entry(sess, &tpg->tpg_sess_list, sess_list) { 536 if (sess->se_node_acl != acl) 537 continue; 538 539 if (!force) { 540 pr_err("Unable to change queue depth for %s" 541 " Initiator Node: %s while session is" 542 " operational. To forcefully change the queue" 543 " depth and force session reinstatement" 544 " use the \"force=1\" parameter.\n", 545 tpg->se_tpg_tfo->get_fabric_name(), initiatorname); 546 spin_unlock_irqrestore(&tpg->session_lock, flags); 547 548 spin_lock_irq(&tpg->acl_node_lock); 549 if (dynamic_acl) 550 acl->dynamic_node_acl = 1; 551 spin_unlock_irq(&tpg->acl_node_lock); 552 return -EEXIST; 553 } 554 /* 555 * Determine if the session needs to be closed by our context. 556 */ 557 if (!tpg->se_tpg_tfo->shutdown_session(sess)) 558 continue; 559 560 init_sess = sess; 561 break; 562 } 563 564 /* 565 * User has requested to change the queue depth for a Initiator Node. 566 * Change the value in the Node's struct se_node_acl, and call 567 * core_set_queue_depth_for_node() to add the requested queue depth. 568 * 569 * Finally call tpg->se_tpg_tfo->close_session() to force session 570 * reinstatement to occur if there is an active session for the 571 * $FABRIC_MOD Initiator Node in question. 572 */ 573 acl->queue_depth = queue_depth; 574 575 if (core_set_queue_depth_for_node(tpg, acl) < 0) { 576 spin_unlock_irqrestore(&tpg->session_lock, flags); 577 /* 578 * Force session reinstatement if 579 * core_set_queue_depth_for_node() failed, because we assume 580 * the $FABRIC_MOD has already the set session reinstatement 581 * bit from tpg->se_tpg_tfo->shutdown_session() called above. 582 */ 583 if (init_sess) 584 tpg->se_tpg_tfo->close_session(init_sess); 585 586 spin_lock_irq(&tpg->acl_node_lock); 587 if (dynamic_acl) 588 acl->dynamic_node_acl = 1; 589 spin_unlock_irq(&tpg->acl_node_lock); 590 return -EINVAL; 591 } 592 spin_unlock_irqrestore(&tpg->session_lock, flags); 593 /* 594 * If the $FABRIC_MOD session for the Initiator Node ACL exists, 595 * forcefully shutdown the $FABRIC_MOD session/nexus. 596 */ 597 if (init_sess) 598 tpg->se_tpg_tfo->close_session(init_sess); 599 600 pr_debug("Successfully changed queue depth to: %d for Initiator" 601 " Node: %s on %s Target Portal Group: %u\n", queue_depth, 602 initiatorname, tpg->se_tpg_tfo->get_fabric_name(), 603 tpg->se_tpg_tfo->tpg_get_tag(tpg)); 604 605 spin_lock_irq(&tpg->acl_node_lock); 606 if (dynamic_acl) 607 acl->dynamic_node_acl = 1; 608 spin_unlock_irq(&tpg->acl_node_lock); 609 610 return 0; 611 } 612 EXPORT_SYMBOL(core_tpg_set_initiator_node_queue_depth); 613 614 /* core_tpg_set_initiator_node_tag(): 615 * 616 * Initiator nodeacl tags are not used internally, but may be used by 617 * userspace to emulate aliases or groups. 618 * Returns length of newly-set tag or -EINVAL. 619 */ 620 int core_tpg_set_initiator_node_tag( 621 struct se_portal_group *tpg, 622 struct se_node_acl *acl, 623 const char *new_tag) 624 { 625 if (strlen(new_tag) >= MAX_ACL_TAG_SIZE) 626 return -EINVAL; 627 628 if (!strncmp("NULL", new_tag, 4)) { 629 acl->acl_tag[0] = '\0'; 630 return 0; 631 } 632 633 return snprintf(acl->acl_tag, MAX_ACL_TAG_SIZE, "%s", new_tag); 634 } 635 EXPORT_SYMBOL(core_tpg_set_initiator_node_tag); 636 637 static void core_tpg_lun_ref_release(struct percpu_ref *ref) 638 { 639 struct se_lun *lun = container_of(ref, struct se_lun, lun_ref); 640 641 complete(&lun->lun_ref_comp); 642 } 643 644 static int core_tpg_setup_virtual_lun0(struct se_portal_group *se_tpg) 645 { 646 /* Set in core_dev_setup_virtual_lun0() */ 647 struct se_device *dev = g_lun0_dev; 648 struct se_lun *lun = &se_tpg->tpg_virt_lun0; 649 u32 lun_access = TRANSPORT_LUNFLAGS_READ_ONLY; 650 int ret; 651 652 lun->unpacked_lun = 0; 653 lun->lun_status = TRANSPORT_LUN_STATUS_FREE; 654 atomic_set(&lun->lun_acl_count, 0); 655 init_completion(&lun->lun_shutdown_comp); 656 INIT_LIST_HEAD(&lun->lun_acl_list); 657 spin_lock_init(&lun->lun_acl_lock); 658 spin_lock_init(&lun->lun_sep_lock); 659 init_completion(&lun->lun_ref_comp); 660 661 ret = percpu_ref_init(&lun->lun_ref, core_tpg_lun_ref_release); 662 if (ret < 0) 663 return ret; 664 665 ret = core_tpg_post_addlun(se_tpg, lun, lun_access, dev); 666 if (ret < 0) { 667 percpu_ref_cancel_init(&lun->lun_ref); 668 return ret; 669 } 670 671 return 0; 672 } 673 674 static void core_tpg_release_virtual_lun0(struct se_portal_group *se_tpg) 675 { 676 struct se_lun *lun = &se_tpg->tpg_virt_lun0; 677 678 core_tpg_post_dellun(se_tpg, lun); 679 } 680 681 int core_tpg_register( 682 struct target_core_fabric_ops *tfo, 683 struct se_wwn *se_wwn, 684 struct se_portal_group *se_tpg, 685 void *tpg_fabric_ptr, 686 int se_tpg_type) 687 { 688 struct se_lun *lun; 689 u32 i; 690 691 se_tpg->tpg_lun_list = array_zalloc(TRANSPORT_MAX_LUNS_PER_TPG, 692 sizeof(struct se_lun), GFP_KERNEL); 693 if (!se_tpg->tpg_lun_list) { 694 pr_err("Unable to allocate struct se_portal_group->" 695 "tpg_lun_list\n"); 696 return -ENOMEM; 697 } 698 699 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) { 700 lun = se_tpg->tpg_lun_list[i]; 701 lun->unpacked_lun = i; 702 lun->lun_link_magic = SE_LUN_LINK_MAGIC; 703 lun->lun_status = TRANSPORT_LUN_STATUS_FREE; 704 atomic_set(&lun->lun_acl_count, 0); 705 init_completion(&lun->lun_shutdown_comp); 706 INIT_LIST_HEAD(&lun->lun_acl_list); 707 spin_lock_init(&lun->lun_acl_lock); 708 spin_lock_init(&lun->lun_sep_lock); 709 init_completion(&lun->lun_ref_comp); 710 } 711 712 se_tpg->se_tpg_type = se_tpg_type; 713 se_tpg->se_tpg_fabric_ptr = tpg_fabric_ptr; 714 se_tpg->se_tpg_tfo = tfo; 715 se_tpg->se_tpg_wwn = se_wwn; 716 atomic_set(&se_tpg->tpg_pr_ref_count, 0); 717 INIT_LIST_HEAD(&se_tpg->acl_node_list); 718 INIT_LIST_HEAD(&se_tpg->se_tpg_node); 719 INIT_LIST_HEAD(&se_tpg->tpg_sess_list); 720 spin_lock_init(&se_tpg->acl_node_lock); 721 spin_lock_init(&se_tpg->session_lock); 722 spin_lock_init(&se_tpg->tpg_lun_lock); 723 724 if (se_tpg->se_tpg_type == TRANSPORT_TPG_TYPE_NORMAL) { 725 if (core_tpg_setup_virtual_lun0(se_tpg) < 0) { 726 array_free(se_tpg->tpg_lun_list, 727 TRANSPORT_MAX_LUNS_PER_TPG); 728 return -ENOMEM; 729 } 730 } 731 732 spin_lock_bh(&tpg_lock); 733 list_add_tail(&se_tpg->se_tpg_node, &tpg_list); 734 spin_unlock_bh(&tpg_lock); 735 736 pr_debug("TARGET_CORE[%s]: Allocated %s struct se_portal_group for" 737 " endpoint: %s, Portal Tag: %u\n", tfo->get_fabric_name(), 738 (se_tpg->se_tpg_type == TRANSPORT_TPG_TYPE_NORMAL) ? 739 "Normal" : "Discovery", (tfo->tpg_get_wwn(se_tpg) == NULL) ? 740 "None" : tfo->tpg_get_wwn(se_tpg), tfo->tpg_get_tag(se_tpg)); 741 742 return 0; 743 } 744 EXPORT_SYMBOL(core_tpg_register); 745 746 int core_tpg_deregister(struct se_portal_group *se_tpg) 747 { 748 struct se_node_acl *nacl, *nacl_tmp; 749 750 pr_debug("TARGET_CORE[%s]: Deallocating %s struct se_portal_group" 751 " for endpoint: %s Portal Tag %u\n", 752 (se_tpg->se_tpg_type == TRANSPORT_TPG_TYPE_NORMAL) ? 753 "Normal" : "Discovery", se_tpg->se_tpg_tfo->get_fabric_name(), 754 se_tpg->se_tpg_tfo->tpg_get_wwn(se_tpg), 755 se_tpg->se_tpg_tfo->tpg_get_tag(se_tpg)); 756 757 spin_lock_bh(&tpg_lock); 758 list_del(&se_tpg->se_tpg_node); 759 spin_unlock_bh(&tpg_lock); 760 761 while (atomic_read(&se_tpg->tpg_pr_ref_count) != 0) 762 cpu_relax(); 763 /* 764 * Release any remaining demo-mode generated se_node_acl that have 765 * not been released because of TFO->tpg_check_demo_mode_cache() == 1 766 * in transport_deregister_session(). 767 */ 768 spin_lock_irq(&se_tpg->acl_node_lock); 769 list_for_each_entry_safe(nacl, nacl_tmp, &se_tpg->acl_node_list, 770 acl_list) { 771 list_del(&nacl->acl_list); 772 se_tpg->num_node_acls--; 773 spin_unlock_irq(&se_tpg->acl_node_lock); 774 775 core_tpg_wait_for_nacl_pr_ref(nacl); 776 core_free_device_list_for_node(nacl, se_tpg); 777 se_tpg->se_tpg_tfo->tpg_release_fabric_acl(se_tpg, nacl); 778 779 spin_lock_irq(&se_tpg->acl_node_lock); 780 } 781 spin_unlock_irq(&se_tpg->acl_node_lock); 782 783 if (se_tpg->se_tpg_type == TRANSPORT_TPG_TYPE_NORMAL) 784 core_tpg_release_virtual_lun0(se_tpg); 785 786 se_tpg->se_tpg_fabric_ptr = NULL; 787 array_free(se_tpg->tpg_lun_list, TRANSPORT_MAX_LUNS_PER_TPG); 788 return 0; 789 } 790 EXPORT_SYMBOL(core_tpg_deregister); 791 792 struct se_lun *core_tpg_pre_addlun( 793 struct se_portal_group *tpg, 794 u32 unpacked_lun) 795 { 796 struct se_lun *lun; 797 798 if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) { 799 pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS_PER_TPG" 800 "-1: %u for Target Portal Group: %u\n", 801 tpg->se_tpg_tfo->get_fabric_name(), 802 unpacked_lun, TRANSPORT_MAX_LUNS_PER_TPG-1, 803 tpg->se_tpg_tfo->tpg_get_tag(tpg)); 804 return ERR_PTR(-EOVERFLOW); 805 } 806 807 spin_lock(&tpg->tpg_lun_lock); 808 lun = tpg->tpg_lun_list[unpacked_lun]; 809 if (lun->lun_status == TRANSPORT_LUN_STATUS_ACTIVE) { 810 pr_err("TPG Logical Unit Number: %u is already active" 811 " on %s Target Portal Group: %u, ignoring request.\n", 812 unpacked_lun, tpg->se_tpg_tfo->get_fabric_name(), 813 tpg->se_tpg_tfo->tpg_get_tag(tpg)); 814 spin_unlock(&tpg->tpg_lun_lock); 815 return ERR_PTR(-EINVAL); 816 } 817 spin_unlock(&tpg->tpg_lun_lock); 818 819 return lun; 820 } 821 822 int core_tpg_post_addlun( 823 struct se_portal_group *tpg, 824 struct se_lun *lun, 825 u32 lun_access, 826 void *lun_ptr) 827 { 828 int ret; 829 830 ret = percpu_ref_init(&lun->lun_ref, core_tpg_lun_ref_release); 831 if (ret < 0) 832 return ret; 833 834 ret = core_dev_export(lun_ptr, tpg, lun); 835 if (ret < 0) { 836 percpu_ref_cancel_init(&lun->lun_ref); 837 return ret; 838 } 839 840 spin_lock(&tpg->tpg_lun_lock); 841 lun->lun_access = lun_access; 842 lun->lun_status = TRANSPORT_LUN_STATUS_ACTIVE; 843 spin_unlock(&tpg->tpg_lun_lock); 844 845 return 0; 846 } 847 848 struct se_lun *core_tpg_pre_dellun( 849 struct se_portal_group *tpg, 850 u32 unpacked_lun) 851 { 852 struct se_lun *lun; 853 854 if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) { 855 pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS_PER_TPG" 856 "-1: %u for Target Portal Group: %u\n", 857 tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun, 858 TRANSPORT_MAX_LUNS_PER_TPG-1, 859 tpg->se_tpg_tfo->tpg_get_tag(tpg)); 860 return ERR_PTR(-EOVERFLOW); 861 } 862 863 spin_lock(&tpg->tpg_lun_lock); 864 lun = tpg->tpg_lun_list[unpacked_lun]; 865 if (lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE) { 866 pr_err("%s Logical Unit Number: %u is not active on" 867 " Target Portal Group: %u, ignoring request.\n", 868 tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun, 869 tpg->se_tpg_tfo->tpg_get_tag(tpg)); 870 spin_unlock(&tpg->tpg_lun_lock); 871 return ERR_PTR(-ENODEV); 872 } 873 spin_unlock(&tpg->tpg_lun_lock); 874 875 return lun; 876 } 877 878 int core_tpg_post_dellun( 879 struct se_portal_group *tpg, 880 struct se_lun *lun) 881 { 882 core_clear_lun_from_tpg(lun, tpg); 883 transport_clear_lun_ref(lun); 884 885 core_dev_unexport(lun->lun_se_dev, tpg, lun); 886 887 spin_lock(&tpg->tpg_lun_lock); 888 lun->lun_status = TRANSPORT_LUN_STATUS_FREE; 889 spin_unlock(&tpg->tpg_lun_lock); 890 891 return 0; 892 } 893