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