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