drivers/target/target_core_tpg.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*******************************************************************************
   3  * Filename:  target_core_tpg.c
   4  *
   5  * This file contains generic Target Portal Group related functions.
   6  *
   7  * (c) Copyright 2002-2013 Datera, Inc.
   8  *
   9  * Nicholas A. Bellinger <nab@kernel.org>
  10  *
  11  ******************************************************************************/
  12
  13 #include <linux/net.h>
  14 #include <linux/string.h>
  15 #include <linux/timer.h>
  16 #include <linux/slab.h>
  17 #include <linux/spinlock.h>
  18 #include <linux/in.h>
  19 #include <linux/export.h>
  20 #include <net/sock.h>
  21 #include <net/tcp.h>
  22 #include <scsi/scsi_proto.h>
  23
  24 #include <target/target_core_base.h>
  25 #include <target/target_core_backend.h>
  26 #include <target/target_core_fabric.h>
  27
  28 #include "target_core_internal.h"
  29 #include "target_core_alua.h"
  30 #include "target_core_pr.h"
  31 #include "target_core_ua.h"
  32
  33 extern struct se_device *g_lun0_dev;
  34
  35 /*      __core_tpg_get_initiator_node_acl():
  36  *
  37  *      mutex_lock(&tpg->acl_node_mutex); must be held when calling
  38  */
  39 struct se_node_acl *__core_tpg_get_initiator_node_acl(
  40         struct se_portal_group *tpg,
  41         const char *initiatorname)
  42 {
  43         struct se_node_acl *acl;
  44
  45         list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {
  46                 if (!strcmp(acl->initiatorname, initiatorname))
  47                         return acl;
  48         }
  49
  50         return NULL;
  51 }
  52
  53 /*      core_tpg_get_initiator_node_acl():
  54  *
  55  *
  56  */
  57 struct se_node_acl *core_tpg_get_initiator_node_acl(
  58         struct se_portal_group *tpg,
  59         unsigned char *initiatorname)
  60 {
  61         struct se_node_acl *acl;
  62         /*
  63          * Obtain se_node_acl->acl_kref using fabric driver provided
  64          * initiatorname[] during node acl endpoint lookup driven by
  65          * new se_session login.
  66          *
  67          * The reference is held until se_session shutdown -> release
  68          * occurs via fabric driver invoked transport_deregister_session()
  69          * or transport_free_session() code.
  70          */
  71         mutex_lock(&tpg->acl_node_mutex);
  72         acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname);
  73         if (acl) {
  74                 if (!kref_get_unless_zero(&acl->acl_kref))
  75                         acl = NULL;
  76         }
  77         mutex_unlock(&tpg->acl_node_mutex);
  78
  79         return acl;
  80 }
  81 EXPORT_SYMBOL(core_tpg_get_initiator_node_acl);
  82
  83 void core_allocate_nexus_loss_ua(
  84         struct se_node_acl *nacl)
  85 {
  86         struct se_dev_entry *deve;
  87
  88         if (!nacl)
  89                 return;
  90
  91         rcu_read_lock();
  92         hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link)
  93                 core_scsi3_ua_allocate(deve, 0x29,
  94                         ASCQ_29H_NEXUS_LOSS_OCCURRED);
  95         rcu_read_unlock();
  96 }
  97 EXPORT_SYMBOL(core_allocate_nexus_loss_ua);
  98
  99 /*      core_tpg_add_node_to_devs():
 100  *
 101  *
 102  */
 103 void core_tpg_add_node_to_devs(
 104         struct se_node_acl *acl,
 105         struct se_portal_group *tpg,
 106         struct se_lun *lun_orig)
 107 {
 108         bool lun_access_ro = true;
 109         struct se_lun *lun;
 110         struct se_device *dev;
 111
 112         mutex_lock(&tpg->tpg_lun_mutex);
 113         hlist_for_each_entry_rcu(lun, &tpg->tpg_lun_hlist, link) {
 114                 if (lun_orig && lun != lun_orig)
 115                         continue;
 116
 117                 dev = rcu_dereference_check(lun->lun_se_dev,
 118                                             lockdep_is_held(&tpg->tpg_lun_mutex));
 119                 /*
 120                  * By default in LIO-Target $FABRIC_MOD,
 121                  * demo_mode_write_protect is ON, or READ_ONLY;
 122                  */
 123                 if (!tpg->se_tpg_tfo->tpg_check_demo_mode_write_protect(tpg)) {
 124                         lun_access_ro = false;
 125                 } else {
 126                         /*
 127                          * Allow only optical drives to issue R/W in default RO
 128                          * demo mode.
 129                          */
 130                         if (dev->transport->get_device_type(dev) == TYPE_DISK)
 131                                 lun_access_ro = true;
 132                         else
 133                                 lun_access_ro = false;
 134                 }
 135
 136                 pr_debug("TARGET_CORE[%s]->TPG[%u]_LUN[%llu] - Adding %s"
 137                         " access for LUN in Demo Mode\n",
 138                         tpg->se_tpg_tfo->fabric_name,
 139                         tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
 140                         lun_access_ro ? "READ-ONLY" : "READ-WRITE");
 141
 142                 core_enable_device_list_for_node(lun, NULL, lun->unpacked_lun,
 143                                                  lun_access_ro, acl, tpg);
 144                 /*
 145                  * Check to see if there are any existing persistent reservation
 146                  * APTPL pre-registrations that need to be enabled for this dynamic
 147                  * LUN ACL now..
 148                  */
 149                 core_scsi3_check_aptpl_registration(dev, tpg, lun, acl,
 150                                                     lun->unpacked_lun);
 151         }
 152         mutex_unlock(&tpg->tpg_lun_mutex);
 153 }
 154
 155 static void
 156 target_set_nacl_queue_depth(struct se_portal_group *tpg,
 157                             struct se_node_acl *acl, u32 queue_depth)
 158 {
 159         acl->queue_depth = queue_depth;
 160
 161         if (!acl->queue_depth) {
 162                 pr_warn("Queue depth for %s Initiator Node: %s is 0,"
 163                         "defaulting to 1.\n", tpg->se_tpg_tfo->fabric_name,
 164                         acl->initiatorname);
 165                 acl->queue_depth = 1;
 166         }
 167 }
 168
 169 static struct se_node_acl *target_alloc_node_acl(struct se_portal_group *tpg,
 170                 const unsigned char *initiatorname)
 171 {
 172         struct se_node_acl *acl;
 173         u32 queue_depth;
 174
 175         acl = kzalloc(max(sizeof(*acl), tpg->se_tpg_tfo->node_acl_size),
 176                         GFP_KERNEL);
 177         if (!acl)
 178                 return NULL;
 179
 180         INIT_LIST_HEAD(&acl->acl_list);
 181         INIT_LIST_HEAD(&acl->acl_sess_list);
 182         INIT_HLIST_HEAD(&acl->lun_entry_hlist);
 183         kref_init(&acl->acl_kref);
 184         init_completion(&acl->acl_free_comp);
 185         spin_lock_init(&acl->nacl_sess_lock);
 186         mutex_init(&acl->lun_entry_mutex);
 187         atomic_set(&acl->acl_pr_ref_count, 0);
 188
 189         if (tpg->se_tpg_tfo->tpg_get_default_depth)
 190                 queue_depth = tpg->se_tpg_tfo->tpg_get_default_depth(tpg);
 191         else
 192                 queue_depth = 1;
 193         target_set_nacl_queue_depth(tpg, acl, queue_depth);
 194
 195         snprintf(acl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname);
 196         acl->se_tpg = tpg;
 197         acl->acl_index = scsi_get_new_index(SCSI_AUTH_INTR_INDEX);
 198
 199         tpg->se_tpg_tfo->set_default_node_attributes(acl);
 200
 201         return acl;
 202 }
 203
 204 static void target_add_node_acl(struct se_node_acl *acl)
 205 {
 206         struct se_portal_group *tpg = acl->se_tpg;
 207
 208         mutex_lock(&tpg->acl_node_mutex);
 209         list_add_tail(&acl->acl_list, &tpg->acl_node_list);
 210         mutex_unlock(&tpg->acl_node_mutex);
 211
 212         pr_debug("%s_TPG[%hu] - Added %s ACL with TCQ Depth: %d for %s"
 213                 " Initiator Node: %s\n",
 214                 tpg->se_tpg_tfo->fabric_name,
 215                 tpg->se_tpg_tfo->tpg_get_tag(tpg),
 216                 acl->dynamic_node_acl ? "DYNAMIC" : "",
 217                 acl->queue_depth,
 218                 tpg->se_tpg_tfo->fabric_name,
 219                 acl->initiatorname);
 220 }
 221
 222 bool target_tpg_has_node_acl(struct se_portal_group *tpg,
 223                              const char *initiatorname)
 224 {
 225         struct se_node_acl *acl;
 226         bool found = false;
 227
 228         mutex_lock(&tpg->acl_node_mutex);
 229         list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {
 230                 if (!strcmp(acl->initiatorname, initiatorname)) {
 231                         found = true;
 232                         break;
 233                 }
 234         }
 235         mutex_unlock(&tpg->acl_node_mutex);
 236
 237         return found;
 238 }
 239 EXPORT_SYMBOL(target_tpg_has_node_acl);
 240
 241 struct se_node_acl *core_tpg_check_initiator_node_acl(
 242         struct se_portal_group *tpg,
 243         unsigned char *initiatorname)
 244 {
 245         struct se_node_acl *acl;
 246
 247         acl = core_tpg_get_initiator_node_acl(tpg, initiatorname);
 248         if (acl)
 249                 return acl;
 250
 251         if (!tpg->se_tpg_tfo->tpg_check_demo_mode(tpg))
 252                 return NULL;
 253
 254         acl = target_alloc_node_acl(tpg, initiatorname);
 255         if (!acl)
 256                 return NULL;
 257         /*
 258          * When allocating a dynamically generated node_acl, go ahead
 259          * and take the extra kref now before returning to the fabric
 260          * driver caller.
 261          *
 262          * Note this reference will be released at session shutdown
 263          * time within transport_free_session() code.
 264          */
 265         kref_get(&acl->acl_kref);
 266         acl->dynamic_node_acl = 1;
 267
 268         /*
 269          * Here we only create demo-mode MappedLUNs from the active
 270          * TPG LUNs if the fabric is not explicitly asking for
 271          * tpg_check_demo_mode_login_only() == 1.
 272          */
 273         if ((tpg->se_tpg_tfo->tpg_check_demo_mode_login_only == NULL) ||
 274             (tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg) != 1))
 275                 core_tpg_add_node_to_devs(acl, tpg, NULL);
 276
 277         target_add_node_acl(acl);
 278         return acl;
 279 }
 280 EXPORT_SYMBOL(core_tpg_check_initiator_node_acl);
 281
 282 void core_tpg_wait_for_nacl_pr_ref(struct se_node_acl *nacl)
 283 {
 284         while (atomic_read(&nacl->acl_pr_ref_count) != 0)
 285                 cpu_relax();
 286 }
 287
 288 struct se_node_acl *core_tpg_add_initiator_node_acl(
 289         struct se_portal_group *tpg,
 290         const char *initiatorname)
 291 {
 292         struct se_node_acl *acl;
 293
 294         mutex_lock(&tpg->acl_node_mutex);
 295         acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname);
 296         if (acl) {
 297                 if (acl->dynamic_node_acl) {
 298                         acl->dynamic_node_acl = 0;
 299                         pr_debug("%s_TPG[%u] - Replacing dynamic ACL"
 300                                 " for %s\n", tpg->se_tpg_tfo->fabric_name,
 301                                 tpg->se_tpg_tfo->tpg_get_tag(tpg), initiatorname);
 302                         mutex_unlock(&tpg->acl_node_mutex);
 303                         return acl;
 304                 }
 305
 306                 pr_err("ACL entry for %s Initiator"
 307                         " Node %s already exists for TPG %u, ignoring"
 308                         " request.\n",  tpg->se_tpg_tfo->fabric_name,
 309                         initiatorname, tpg->se_tpg_tfo->tpg_get_tag(tpg));
 310                 mutex_unlock(&tpg->acl_node_mutex);
 311                 return ERR_PTR(-EEXIST);
 312         }
 313         mutex_unlock(&tpg->acl_node_mutex);
 314
 315         acl = target_alloc_node_acl(tpg, initiatorname);
 316         if (!acl)
 317                 return ERR_PTR(-ENOMEM);
 318
 319         target_add_node_acl(acl);
 320         return acl;
 321 }
 322
 323 static void target_shutdown_sessions(struct se_node_acl *acl)
 324 {
 325         struct se_session *sess;
 326         unsigned long flags;
 327
 328 restart:
 329         spin_lock_irqsave(&acl->nacl_sess_lock, flags);
 330         list_for_each_entry(sess, &acl->acl_sess_list, sess_acl_list) {
 331                 if (atomic_read(&sess->stopped))
 332                         continue;
 333
 334                 list_del_init(&sess->sess_acl_list);
 335                 spin_unlock_irqrestore(&acl->nacl_sess_lock, flags);
 336
 337                 if (acl->se_tpg->se_tpg_tfo->close_session)
 338                         acl->se_tpg->se_tpg_tfo->close_session(sess);
 339                 goto restart;
 340         }
 341         spin_unlock_irqrestore(&acl->nacl_sess_lock, flags);
 342 }
 343
 344 void core_tpg_del_initiator_node_acl(struct se_node_acl *acl)
 345 {
 346         struct se_portal_group *tpg = acl->se_tpg;
 347
 348         mutex_lock(&tpg->acl_node_mutex);
 349         if (acl->dynamic_node_acl)
 350                 acl->dynamic_node_acl = 0;
 351         list_del_init(&acl->acl_list);
 352         mutex_unlock(&tpg->acl_node_mutex);
 353
 354         target_shutdown_sessions(acl);
 355
 356         target_put_nacl(acl);
 357         /*
 358          * Wait for last target_put_nacl() to complete in target_complete_nacl()
 359          * for active fabric session transport_deregister_session() callbacks.
 360          */
 361         wait_for_completion(&acl->acl_free_comp);
 362
 363         core_tpg_wait_for_nacl_pr_ref(acl);
 364         core_free_device_list_for_node(acl, tpg);
 365
 366         pr_debug("%s_TPG[%hu] - Deleted ACL with TCQ Depth: %d for %s"
 367                 " Initiator Node: %s\n", tpg->se_tpg_tfo->fabric_name,
 368                 tpg->se_tpg_tfo->tpg_get_tag(tpg), acl->queue_depth,
 369                 tpg->se_tpg_tfo->fabric_name, acl->initiatorname);
 370
 371         kfree(acl);
 372 }
 373
 374 /*      core_tpg_set_initiator_node_queue_depth():
 375  *
 376  *
 377  */
 378 int core_tpg_set_initiator_node_queue_depth(
 379         struct se_node_acl *acl,
 380         u32 queue_depth)
 381 {
 382         struct se_portal_group *tpg = acl->se_tpg;
 383
 384         /*
 385          * Allow the setting of se_node_acl queue_depth to be idempotent,
 386          * and not force a session shutdown event if the value is not
 387          * changing.
 388          */
 389         if (acl->queue_depth == queue_depth)
 390                 return 0;
 391         /*
 392          * User has requested to change the queue depth for a Initiator Node.
 393          * Change the value in the Node's struct se_node_acl, and call
 394          * target_set_nacl_queue_depth() to set the new queue depth.
 395          */
 396         target_set_nacl_queue_depth(tpg, acl, queue_depth);
 397
 398         /*
 399          * Shutdown all pending sessions to force session reinstatement.
 400          */
 401         target_shutdown_sessions(acl);
 402
 403         pr_debug("Successfully changed queue depth to: %d for Initiator"
 404                 " Node: %s on %s Target Portal Group: %u\n", acl->queue_depth,
 405                 acl->initiatorname, tpg->se_tpg_tfo->fabric_name,
 406                 tpg->se_tpg_tfo->tpg_get_tag(tpg));
 407
 408         return 0;
 409 }
 410 EXPORT_SYMBOL(core_tpg_set_initiator_node_queue_depth);
 411
 412 /*      core_tpg_set_initiator_node_tag():
 413  *
 414  *      Initiator nodeacl tags are not used internally, but may be used by
 415  *      userspace to emulate aliases or groups.
 416  *      Returns length of newly-set tag or -EINVAL.
 417  */
 418 int core_tpg_set_initiator_node_tag(
 419         struct se_portal_group *tpg,
 420         struct se_node_acl *acl,
 421         const char *new_tag)
 422 {
 423         if (strlen(new_tag) >= MAX_ACL_TAG_SIZE)
 424                 return -EINVAL;
 425
 426         if (!strncmp("NULL", new_tag, 4)) {
 427                 acl->acl_tag[0] = '\0';
 428                 return 0;
 429         }
 430
 431         return snprintf(acl->acl_tag, MAX_ACL_TAG_SIZE, "%s", new_tag);
 432 }
 433 EXPORT_SYMBOL(core_tpg_set_initiator_node_tag);
 434
 435 static void core_tpg_lun_ref_release(struct percpu_ref *ref)
 436 {
 437         struct se_lun *lun = container_of(ref, struct se_lun, lun_ref);
 438
 439         complete(&lun->lun_shutdown_comp);
 440 }
 441
 442 /* Does not change se_wwn->priv. */
 443 int core_tpg_register(
 444         struct se_wwn *se_wwn,
 445         struct se_portal_group *se_tpg,
 446         int proto_id)
 447 {
 448         int ret;
 449
 450         if (!se_tpg)
 451                 return -EINVAL;
 452         /*
 453          * For the typical case where core_tpg_register() is called by a
 454          * fabric driver from target_core_fabric_ops->fabric_make_tpg()
 455          * configfs context, use the original tf_ops pointer already saved
 456          * by target-core in target_fabric_make_wwn().
 457          *
 458          * Otherwise, for special cases like iscsi-target discovery TPGs
 459          * the caller is responsible for setting ->se_tpg_tfo ahead of
 460          * calling core_tpg_register().
 461          */
 462         if (se_wwn)
 463                 se_tpg->se_tpg_tfo = se_wwn->wwn_tf->tf_ops;
 464
 465         if (!se_tpg->se_tpg_tfo) {
 466                 pr_err("Unable to locate se_tpg->se_tpg_tfo pointer\n");
 467                 return -EINVAL;
 468         }
 469
 470         INIT_HLIST_HEAD(&se_tpg->tpg_lun_hlist);
 471         se_tpg->proto_id = proto_id;
 472         se_tpg->se_tpg_wwn = se_wwn;
 473         atomic_set(&se_tpg->tpg_pr_ref_count, 0);
 474         INIT_LIST_HEAD(&se_tpg->acl_node_list);
 475         INIT_LIST_HEAD(&se_tpg->tpg_sess_list);
 476         spin_lock_init(&se_tpg->session_lock);
 477         mutex_init(&se_tpg->tpg_lun_mutex);
 478         mutex_init(&se_tpg->acl_node_mutex);
 479
 480         if (se_tpg->proto_id >= 0) {
 481                 se_tpg->tpg_virt_lun0 = core_tpg_alloc_lun(se_tpg, 0);
 482                 if (IS_ERR(se_tpg->tpg_virt_lun0))
 483                         return PTR_ERR(se_tpg->tpg_virt_lun0);
 484
 485                 ret = core_tpg_add_lun(se_tpg, se_tpg->tpg_virt_lun0,
 486                                 true, g_lun0_dev);
 487                 if (ret < 0) {
 488                         kfree(se_tpg->tpg_virt_lun0);
 489                         return ret;
 490                 }
 491         }
 492
 493         pr_debug("TARGET_CORE[%s]: Allocated portal_group for endpoint: %s, "
 494                  "Proto: %d, Portal Tag: %u\n", se_tpg->se_tpg_tfo->fabric_name,
 495                 se_tpg->se_tpg_tfo->tpg_get_wwn(se_tpg) ?
 496                 se_tpg->se_tpg_tfo->tpg_get_wwn(se_tpg) : NULL,
 497                 se_tpg->proto_id, se_tpg->se_tpg_tfo->tpg_get_tag(se_tpg));
 498
 499         return 0;
 500 }
 501 EXPORT_SYMBOL(core_tpg_register);
 502
 503 int core_tpg_deregister(struct se_portal_group *se_tpg)
 504 {
 505         const struct target_core_fabric_ops *tfo = se_tpg->se_tpg_tfo;
 506         struct se_node_acl *nacl, *nacl_tmp;
 507         LIST_HEAD(node_list);
 508
 509         pr_debug("TARGET_CORE[%s]: Deallocating portal_group for endpoint: %s, "
 510                  "Proto: %d, Portal Tag: %u\n", tfo->fabric_name,
 511                 tfo->tpg_get_wwn(se_tpg) ? tfo->tpg_get_wwn(se_tpg) : NULL,
 512                 se_tpg->proto_id, tfo->tpg_get_tag(se_tpg));
 513
 514         while (atomic_read(&se_tpg->tpg_pr_ref_count) != 0)
 515                 cpu_relax();
 516
 517         mutex_lock(&se_tpg->acl_node_mutex);
 518         list_splice_init(&se_tpg->acl_node_list, &node_list);
 519         mutex_unlock(&se_tpg->acl_node_mutex);
 520         /*
 521          * Release any remaining demo-mode generated se_node_acl that have
 522          * not been released because of TFO->tpg_check_demo_mode_cache() == 1
 523          * in transport_deregister_session().
 524          */
 525         list_for_each_entry_safe(nacl, nacl_tmp, &node_list, acl_list) {
 526                 list_del_init(&nacl->acl_list);
 527
 528                 core_tpg_wait_for_nacl_pr_ref(nacl);
 529                 core_free_device_list_for_node(nacl, se_tpg);
 530                 kfree(nacl);
 531         }
 532
 533         if (se_tpg->proto_id >= 0) {
 534                 core_tpg_remove_lun(se_tpg, se_tpg->tpg_virt_lun0);
 535                 kfree_rcu(se_tpg->tpg_virt_lun0, rcu_head);
 536         }
 537
 538         return 0;
 539 }
 540 EXPORT_SYMBOL(core_tpg_deregister);
 541
 542 struct se_lun *core_tpg_alloc_lun(
 543         struct se_portal_group *tpg,
 544         u64 unpacked_lun)
 545 {
 546         struct se_lun *lun;
 547
 548         lun = kzalloc(sizeof(*lun), GFP_KERNEL);
 549         if (!lun) {
 550                 pr_err("Unable to allocate se_lun memory\n");
 551                 return ERR_PTR(-ENOMEM);
 552         }
 553         lun->unpacked_lun = unpacked_lun;
 554         atomic_set(&lun->lun_acl_count, 0);
 555         init_completion(&lun->lun_shutdown_comp);
 556         INIT_LIST_HEAD(&lun->lun_deve_list);
 557         INIT_LIST_HEAD(&lun->lun_dev_link);
 558         atomic_set(&lun->lun_tg_pt_secondary_offline, 0);
 559         spin_lock_init(&lun->lun_deve_lock);
 560         mutex_init(&lun->lun_tg_pt_md_mutex);
 561         INIT_LIST_HEAD(&lun->lun_tg_pt_gp_link);
 562         spin_lock_init(&lun->lun_tg_pt_gp_lock);
 563         lun->lun_tpg = tpg;
 564
 565         return lun;
 566 }
 567
 568 int core_tpg_add_lun(
 569         struct se_portal_group *tpg,
 570         struct se_lun *lun,
 571         bool lun_access_ro,
 572         struct se_device *dev)
 573 {
 574         int ret;
 575
 576         ret = percpu_ref_init(&lun->lun_ref, core_tpg_lun_ref_release, 0,
 577                               GFP_KERNEL);
 578         if (ret < 0)
 579                 goto out;
 580
 581         ret = core_alloc_rtpi(lun, dev);
 582         if (ret)
 583                 goto out_kill_ref;
 584
 585         if (!(dev->transport_flags & TRANSPORT_FLAG_PASSTHROUGH_ALUA) &&
 586             !(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE))
 587                 target_attach_tg_pt_gp(lun, dev->t10_alua.default_tg_pt_gp);
 588
 589         mutex_lock(&tpg->tpg_lun_mutex);
 590
 591         spin_lock(&dev->se_port_lock);
 592         lun->lun_index = dev->dev_index;
 593         rcu_assign_pointer(lun->lun_se_dev, dev);
 594         dev->export_count++;
 595         list_add_tail(&lun->lun_dev_link, &dev->dev_sep_list);
 596         spin_unlock(&dev->se_port_lock);
 597
 598         if (dev->dev_flags & DF_READ_ONLY)
 599                 lun->lun_access_ro = true;
 600         else
 601                 lun->lun_access_ro = lun_access_ro;
 602         if (!(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE))
 603                 hlist_add_head_rcu(&lun->link, &tpg->tpg_lun_hlist);
 604         mutex_unlock(&tpg->tpg_lun_mutex);
 605
 606         return 0;
 607
 608 out_kill_ref:
 609         percpu_ref_exit(&lun->lun_ref);
 610 out:
 611         return ret;
 612 }
 613
 614 void core_tpg_remove_lun(
 615         struct se_portal_group *tpg,
 616         struct se_lun *lun)
 617 {
 618         /*
 619          * rcu_dereference_raw protected by se_lun->lun_group symlink
 620          * reference to se_device->dev_group.
 621          */
 622         struct se_device *dev = rcu_dereference_raw(lun->lun_se_dev);
 623
 624         lun->lun_shutdown = true;
 625
 626         core_clear_lun_from_tpg(lun, tpg);
 627         /*
 628          * Wait for any active I/O references to percpu se_lun->lun_ref to
 629          * be released.  Also, se_lun->lun_ref is now used by PR and ALUA
 630          * logic when referencing a remote target port during ALL_TGT_PT=1
 631          * and generating UNIT_ATTENTIONs for ALUA access state transition.
 632          */
 633         transport_clear_lun_ref(lun);
 634
 635         mutex_lock(&tpg->tpg_lun_mutex);
 636         if (lun->lun_se_dev) {
 637                 target_detach_tg_pt_gp(lun);
 638
 639                 spin_lock(&dev->se_port_lock);
 640                 list_del(&lun->lun_dev_link);
 641                 dev->export_count--;
 642                 rcu_assign_pointer(lun->lun_se_dev, NULL);
 643                 spin_unlock(&dev->se_port_lock);
 644         }
 645         if (!(dev->se_hba->hba_flags & HBA_FLAGS_INTERNAL_USE))
 646                 hlist_del_rcu(&lun->link);
 647
 648         lun->lun_shutdown = false;
 649         mutex_unlock(&tpg->tpg_lun_mutex);
 650
 651         percpu_ref_exit(&lun->lun_ref);
 652 }