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