drivers/target/target_core_tpg.c

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