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