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