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 */
core_clear_initiator_node_from_tpg(struct se_node_acl * nacl,struct se_portal_group * tpg)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 */
__core_tpg_get_initiator_node_acl(struct se_portal_group * tpg,const char * initiatorname)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 */
core_tpg_get_initiator_node_acl(struct se_portal_group * tpg,unsigned char * initiatorname)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 acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname);
118 spin_unlock_irq(&tpg->acl_node_lock);
119
120 return acl;
121 }
122
123 /* core_tpg_add_node_to_devs():
124 *
125 *
126 */
core_tpg_add_node_to_devs(struct se_node_acl * acl,struct se_portal_group * tpg)127 void core_tpg_add_node_to_devs(
128 struct se_node_acl *acl,
129 struct se_portal_group *tpg)
130 {
131 int i = 0;
132 u32 lun_access = 0;
133 struct se_lun *lun;
134 struct se_device *dev;
135
136 spin_lock(&tpg->tpg_lun_lock);
137 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
138 lun = tpg->tpg_lun_list[i];
139 if (lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE)
140 continue;
141
142 spin_unlock(&tpg->tpg_lun_lock);
143
144 dev = lun->lun_se_dev;
145 /*
146 * By default in LIO-Target $FABRIC_MOD,
147 * demo_mode_write_protect is ON, or READ_ONLY;
148 */
149 if (!tpg->se_tpg_tfo->tpg_check_demo_mode_write_protect(tpg)) {
150 if (dev->dev_flags & DF_READ_ONLY)
151 lun_access = TRANSPORT_LUNFLAGS_READ_ONLY;
152 else
153 lun_access = TRANSPORT_LUNFLAGS_READ_WRITE;
154 } else {
155 /*
156 * Allow only optical drives to issue R/W in default RO
157 * demo mode.
158 */
159 if (dev->transport->get_device_type(dev) == TYPE_DISK)
160 lun_access = TRANSPORT_LUNFLAGS_READ_ONLY;
161 else
162 lun_access = TRANSPORT_LUNFLAGS_READ_WRITE;
163 }
164
165 pr_debug("TARGET_CORE[%s]->TPG[%u]_LUN[%u] - Adding %s"
166 " access for LUN in Demo Mode\n",
167 tpg->se_tpg_tfo->get_fabric_name(),
168 tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
169 (lun_access == TRANSPORT_LUNFLAGS_READ_WRITE) ?
170 "READ-WRITE" : "READ-ONLY");
171
172 core_update_device_list_for_node(lun, NULL, lun->unpacked_lun,
173 lun_access, acl, tpg, 1);
174 spin_lock(&tpg->tpg_lun_lock);
175 }
176 spin_unlock(&tpg->tpg_lun_lock);
177 }
178
179 /* core_set_queue_depth_for_node():
180 *
181 *
182 */
core_set_queue_depth_for_node(struct se_portal_group * tpg,struct se_node_acl * acl)183 static int core_set_queue_depth_for_node(
184 struct se_portal_group *tpg,
185 struct se_node_acl *acl)
186 {
187 if (!acl->queue_depth) {
188 pr_err("Queue depth for %s Initiator Node: %s is 0,"
189 "defaulting to 1.\n", tpg->se_tpg_tfo->get_fabric_name(),
190 acl->initiatorname);
191 acl->queue_depth = 1;
192 }
193
194 return 0;
195 }
196
array_free(void * array,int n)197 void array_free(void *array, int n)
198 {
199 void **a = array;
200 int i;
201
202 for (i = 0; i < n; i++)
203 kfree(a[i]);
204 kfree(a);
205 }
206
array_zalloc(int n,size_t size,gfp_t flags)207 static void *array_zalloc(int n, size_t size, gfp_t flags)
208 {
209 void **a;
210 int i;
211
212 a = kzalloc(n * sizeof(void*), flags);
213 if (!a)
214 return NULL;
215 for (i = 0; i < n; i++) {
216 a[i] = kzalloc(size, flags);
217 if (!a[i]) {
218 array_free(a, n);
219 return NULL;
220 }
221 }
222 return a;
223 }
224
225 /* core_create_device_list_for_node():
226 *
227 *
228 */
core_create_device_list_for_node(struct se_node_acl * nacl)229 static int core_create_device_list_for_node(struct se_node_acl *nacl)
230 {
231 struct se_dev_entry *deve;
232 int i;
233
234 nacl->device_list = array_zalloc(TRANSPORT_MAX_LUNS_PER_TPG,
235 sizeof(struct se_dev_entry), GFP_KERNEL);
236 if (!nacl->device_list) {
237 pr_err("Unable to allocate memory for"
238 " struct se_node_acl->device_list\n");
239 return -ENOMEM;
240 }
241 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
242 deve = nacl->device_list[i];
243
244 atomic_set(&deve->ua_count, 0);
245 atomic_set(&deve->pr_ref_count, 0);
246 spin_lock_init(&deve->ua_lock);
247 INIT_LIST_HEAD(&deve->alua_port_list);
248 INIT_LIST_HEAD(&deve->ua_list);
249 }
250
251 return 0;
252 }
253
254 /* core_tpg_check_initiator_node_acl()
255 *
256 *
257 */
core_tpg_check_initiator_node_acl(struct se_portal_group * tpg,unsigned char * initiatorname)258 struct se_node_acl *core_tpg_check_initiator_node_acl(
259 struct se_portal_group *tpg,
260 unsigned char *initiatorname)
261 {
262 struct se_node_acl *acl;
263
264 acl = core_tpg_get_initiator_node_acl(tpg, initiatorname);
265 if (acl)
266 return acl;
267
268 if (!tpg->se_tpg_tfo->tpg_check_demo_mode(tpg))
269 return NULL;
270
271 acl = tpg->se_tpg_tfo->tpg_alloc_fabric_acl(tpg);
272 if (!acl)
273 return NULL;
274
275 INIT_LIST_HEAD(&acl->acl_list);
276 INIT_LIST_HEAD(&acl->acl_sess_list);
277 kref_init(&acl->acl_kref);
278 init_completion(&acl->acl_free_comp);
279 spin_lock_init(&acl->device_list_lock);
280 spin_lock_init(&acl->nacl_sess_lock);
281 atomic_set(&acl->acl_pr_ref_count, 0);
282 acl->queue_depth = tpg->se_tpg_tfo->tpg_get_default_depth(tpg);
283 snprintf(acl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname);
284 acl->se_tpg = tpg;
285 acl->acl_index = scsi_get_new_index(SCSI_AUTH_INTR_INDEX);
286 spin_lock_init(&acl->stats_lock);
287 acl->dynamic_node_acl = 1;
288
289 tpg->se_tpg_tfo->set_default_node_attributes(acl);
290
291 if (core_create_device_list_for_node(acl) < 0) {
292 tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl);
293 return NULL;
294 }
295
296 if (core_set_queue_depth_for_node(tpg, acl) < 0) {
297 core_free_device_list_for_node(acl, tpg);
298 tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl);
299 return NULL;
300 }
301 /*
302 * Here we only create demo-mode MappedLUNs from the active
303 * TPG LUNs if the fabric is not explictly asking for
304 * tpg_check_demo_mode_login_only() == 1.
305 */
306 if ((tpg->se_tpg_tfo->tpg_check_demo_mode_login_only != NULL) &&
307 (tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg) == 1))
308 do { ; } while (0);
309 else
310 core_tpg_add_node_to_devs(acl, tpg);
311
312 spin_lock_irq(&tpg->acl_node_lock);
313 list_add_tail(&acl->acl_list, &tpg->acl_node_list);
314 tpg->num_node_acls++;
315 spin_unlock_irq(&tpg->acl_node_lock);
316
317 pr_debug("%s_TPG[%u] - Added DYNAMIC ACL with TCQ Depth: %d for %s"
318 " Initiator Node: %s\n", tpg->se_tpg_tfo->get_fabric_name(),
319 tpg->se_tpg_tfo->tpg_get_tag(tpg), acl->queue_depth,
320 tpg->se_tpg_tfo->get_fabric_name(), initiatorname);
321
322 return acl;
323 }
324 EXPORT_SYMBOL(core_tpg_check_initiator_node_acl);
325
core_tpg_wait_for_nacl_pr_ref(struct se_node_acl * nacl)326 void core_tpg_wait_for_nacl_pr_ref(struct se_node_acl *nacl)
327 {
328 while (atomic_read(&nacl->acl_pr_ref_count) != 0)
329 cpu_relax();
330 }
331
core_tpg_clear_object_luns(struct se_portal_group * tpg)332 void core_tpg_clear_object_luns(struct se_portal_group *tpg)
333 {
334 int i;
335 struct se_lun *lun;
336
337 spin_lock(&tpg->tpg_lun_lock);
338 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
339 lun = tpg->tpg_lun_list[i];
340
341 if ((lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE) ||
342 (lun->lun_se_dev == NULL))
343 continue;
344
345 spin_unlock(&tpg->tpg_lun_lock);
346 core_dev_del_lun(tpg, lun->unpacked_lun);
347 spin_lock(&tpg->tpg_lun_lock);
348 }
349 spin_unlock(&tpg->tpg_lun_lock);
350 }
351 EXPORT_SYMBOL(core_tpg_clear_object_luns);
352
353 /* core_tpg_add_initiator_node_acl():
354 *
355 *
356 */
core_tpg_add_initiator_node_acl(struct se_portal_group * tpg,struct se_node_acl * se_nacl,const char * initiatorname,u32 queue_depth)357 struct se_node_acl *core_tpg_add_initiator_node_acl(
358 struct se_portal_group *tpg,
359 struct se_node_acl *se_nacl,
360 const char *initiatorname,
361 u32 queue_depth)
362 {
363 struct se_node_acl *acl = NULL;
364
365 spin_lock_irq(&tpg->acl_node_lock);
366 acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname);
367 if (acl) {
368 if (acl->dynamic_node_acl) {
369 acl->dynamic_node_acl = 0;
370 pr_debug("%s_TPG[%u] - Replacing dynamic ACL"
371 " for %s\n", tpg->se_tpg_tfo->get_fabric_name(),
372 tpg->se_tpg_tfo->tpg_get_tag(tpg), initiatorname);
373 spin_unlock_irq(&tpg->acl_node_lock);
374 /*
375 * Release the locally allocated struct se_node_acl
376 * because * core_tpg_add_initiator_node_acl() returned
377 * a pointer to an existing demo mode node ACL.
378 */
379 if (se_nacl)
380 tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg,
381 se_nacl);
382 goto done;
383 }
384
385 pr_err("ACL entry for %s Initiator"
386 " Node %s already exists for TPG %u, ignoring"
387 " request.\n", tpg->se_tpg_tfo->get_fabric_name(),
388 initiatorname, tpg->se_tpg_tfo->tpg_get_tag(tpg));
389 spin_unlock_irq(&tpg->acl_node_lock);
390 return ERR_PTR(-EEXIST);
391 }
392 spin_unlock_irq(&tpg->acl_node_lock);
393
394 if (!se_nacl) {
395 pr_err("struct se_node_acl pointer is NULL\n");
396 return ERR_PTR(-EINVAL);
397 }
398 /*
399 * For v4.x logic the se_node_acl_s is hanging off a fabric
400 * dependent structure allocated via
401 * struct target_core_fabric_ops->fabric_make_nodeacl()
402 */
403 acl = se_nacl;
404
405 INIT_LIST_HEAD(&acl->acl_list);
406 INIT_LIST_HEAD(&acl->acl_sess_list);
407 kref_init(&acl->acl_kref);
408 init_completion(&acl->acl_free_comp);
409 spin_lock_init(&acl->device_list_lock);
410 spin_lock_init(&acl->nacl_sess_lock);
411 atomic_set(&acl->acl_pr_ref_count, 0);
412 acl->queue_depth = queue_depth;
413 snprintf(acl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname);
414 acl->se_tpg = tpg;
415 acl->acl_index = scsi_get_new_index(SCSI_AUTH_INTR_INDEX);
416 spin_lock_init(&acl->stats_lock);
417
418 tpg->se_tpg_tfo->set_default_node_attributes(acl);
419
420 if (core_create_device_list_for_node(acl) < 0) {
421 tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl);
422 return ERR_PTR(-ENOMEM);
423 }
424
425 if (core_set_queue_depth_for_node(tpg, acl) < 0) {
426 core_free_device_list_for_node(acl, tpg);
427 tpg->se_tpg_tfo->tpg_release_fabric_acl(tpg, acl);
428 return ERR_PTR(-EINVAL);
429 }
430
431 spin_lock_irq(&tpg->acl_node_lock);
432 list_add_tail(&acl->acl_list, &tpg->acl_node_list);
433 tpg->num_node_acls++;
434 spin_unlock_irq(&tpg->acl_node_lock);
435
436 done:
437 pr_debug("%s_TPG[%hu] - Added ACL with TCQ Depth: %d for %s"
438 " Initiator Node: %s\n", tpg->se_tpg_tfo->get_fabric_name(),
439 tpg->se_tpg_tfo->tpg_get_tag(tpg), acl->queue_depth,
440 tpg->se_tpg_tfo->get_fabric_name(), initiatorname);
441
442 return acl;
443 }
444 EXPORT_SYMBOL(core_tpg_add_initiator_node_acl);
445
446 /* core_tpg_del_initiator_node_acl():
447 *
448 *
449 */
core_tpg_del_initiator_node_acl(struct se_portal_group * tpg,struct se_node_acl * acl,int force)450 int core_tpg_del_initiator_node_acl(
451 struct se_portal_group *tpg,
452 struct se_node_acl *acl,
453 int force)
454 {
455 LIST_HEAD(sess_list);
456 struct se_session *sess, *sess_tmp;
457 unsigned long flags;
458 int rc;
459
460 spin_lock_irq(&tpg->acl_node_lock);
461 if (acl->dynamic_node_acl) {
462 acl->dynamic_node_acl = 0;
463 }
464 list_del(&acl->acl_list);
465 tpg->num_node_acls--;
466 spin_unlock_irq(&tpg->acl_node_lock);
467
468 spin_lock_irqsave(&acl->nacl_sess_lock, flags);
469 acl->acl_stop = 1;
470
471 list_for_each_entry_safe(sess, sess_tmp, &acl->acl_sess_list,
472 sess_acl_list) {
473 if (sess->sess_tearing_down != 0)
474 continue;
475
476 target_get_session(sess);
477 list_move(&sess->sess_acl_list, &sess_list);
478 }
479 spin_unlock_irqrestore(&acl->nacl_sess_lock, flags);
480
481 list_for_each_entry_safe(sess, sess_tmp, &sess_list, sess_acl_list) {
482 list_del(&sess->sess_acl_list);
483
484 rc = tpg->se_tpg_tfo->shutdown_session(sess);
485 target_put_session(sess);
486 if (!rc)
487 continue;
488 target_put_session(sess);
489 }
490 target_put_nacl(acl);
491 /*
492 * Wait for last target_put_nacl() to complete in target_complete_nacl()
493 * for active fabric session transport_deregister_session() callbacks.
494 */
495 wait_for_completion(&acl->acl_free_comp);
496
497 core_tpg_wait_for_nacl_pr_ref(acl);
498 core_clear_initiator_node_from_tpg(acl, tpg);
499 core_free_device_list_for_node(acl, tpg);
500
501 pr_debug("%s_TPG[%hu] - Deleted ACL with TCQ Depth: %d for %s"
502 " Initiator Node: %s\n", tpg->se_tpg_tfo->get_fabric_name(),
503 tpg->se_tpg_tfo->tpg_get_tag(tpg), acl->queue_depth,
504 tpg->se_tpg_tfo->get_fabric_name(), acl->initiatorname);
505
506 return 0;
507 }
508 EXPORT_SYMBOL(core_tpg_del_initiator_node_acl);
509
510 /* core_tpg_set_initiator_node_queue_depth():
511 *
512 *
513 */
core_tpg_set_initiator_node_queue_depth(struct se_portal_group * tpg,unsigned char * initiatorname,u32 queue_depth,int force)514 int core_tpg_set_initiator_node_queue_depth(
515 struct se_portal_group *tpg,
516 unsigned char *initiatorname,
517 u32 queue_depth,
518 int force)
519 {
520 struct se_session *sess, *init_sess = NULL;
521 struct se_node_acl *acl;
522 unsigned long flags;
523 int dynamic_acl = 0;
524
525 spin_lock_irq(&tpg->acl_node_lock);
526 acl = __core_tpg_get_initiator_node_acl(tpg, initiatorname);
527 if (!acl) {
528 pr_err("Access Control List entry for %s Initiator"
529 " Node %s does not exists for TPG %hu, ignoring"
530 " request.\n", tpg->se_tpg_tfo->get_fabric_name(),
531 initiatorname, tpg->se_tpg_tfo->tpg_get_tag(tpg));
532 spin_unlock_irq(&tpg->acl_node_lock);
533 return -ENODEV;
534 }
535 if (acl->dynamic_node_acl) {
536 acl->dynamic_node_acl = 0;
537 dynamic_acl = 1;
538 }
539 spin_unlock_irq(&tpg->acl_node_lock);
540
541 spin_lock_irqsave(&tpg->session_lock, flags);
542 list_for_each_entry(sess, &tpg->tpg_sess_list, sess_list) {
543 if (sess->se_node_acl != acl)
544 continue;
545
546 if (!force) {
547 pr_err("Unable to change queue depth for %s"
548 " Initiator Node: %s while session is"
549 " operational. To forcefully change the queue"
550 " depth and force session reinstatement"
551 " use the \"force=1\" parameter.\n",
552 tpg->se_tpg_tfo->get_fabric_name(), initiatorname);
553 spin_unlock_irqrestore(&tpg->session_lock, flags);
554
555 spin_lock_irq(&tpg->acl_node_lock);
556 if (dynamic_acl)
557 acl->dynamic_node_acl = 1;
558 spin_unlock_irq(&tpg->acl_node_lock);
559 return -EEXIST;
560 }
561 /*
562 * Determine if the session needs to be closed by our context.
563 */
564 if (!tpg->se_tpg_tfo->shutdown_session(sess))
565 continue;
566
567 init_sess = sess;
568 break;
569 }
570
571 /*
572 * User has requested to change the queue depth for a Initiator Node.
573 * Change the value in the Node's struct se_node_acl, and call
574 * core_set_queue_depth_for_node() to add the requested queue depth.
575 *
576 * Finally call tpg->se_tpg_tfo->close_session() to force session
577 * reinstatement to occur if there is an active session for the
578 * $FABRIC_MOD Initiator Node in question.
579 */
580 acl->queue_depth = queue_depth;
581
582 if (core_set_queue_depth_for_node(tpg, acl) < 0) {
583 spin_unlock_irqrestore(&tpg->session_lock, flags);
584 /*
585 * Force session reinstatement if
586 * core_set_queue_depth_for_node() failed, because we assume
587 * the $FABRIC_MOD has already the set session reinstatement
588 * bit from tpg->se_tpg_tfo->shutdown_session() called above.
589 */
590 if (init_sess)
591 tpg->se_tpg_tfo->close_session(init_sess);
592
593 spin_lock_irq(&tpg->acl_node_lock);
594 if (dynamic_acl)
595 acl->dynamic_node_acl = 1;
596 spin_unlock_irq(&tpg->acl_node_lock);
597 return -EINVAL;
598 }
599 spin_unlock_irqrestore(&tpg->session_lock, flags);
600 /*
601 * If the $FABRIC_MOD session for the Initiator Node ACL exists,
602 * forcefully shutdown the $FABRIC_MOD session/nexus.
603 */
604 if (init_sess)
605 tpg->se_tpg_tfo->close_session(init_sess);
606
607 pr_debug("Successfully changed queue depth to: %d for Initiator"
608 " Node: %s on %s Target Portal Group: %u\n", queue_depth,
609 initiatorname, tpg->se_tpg_tfo->get_fabric_name(),
610 tpg->se_tpg_tfo->tpg_get_tag(tpg));
611
612 spin_lock_irq(&tpg->acl_node_lock);
613 if (dynamic_acl)
614 acl->dynamic_node_acl = 1;
615 spin_unlock_irq(&tpg->acl_node_lock);
616
617 return 0;
618 }
619 EXPORT_SYMBOL(core_tpg_set_initiator_node_queue_depth);
620
core_tpg_setup_virtual_lun0(struct se_portal_group * se_tpg)621 static int core_tpg_setup_virtual_lun0(struct se_portal_group *se_tpg)
622 {
623 /* Set in core_dev_setup_virtual_lun0() */
624 struct se_device *dev = g_lun0_dev;
625 struct se_lun *lun = &se_tpg->tpg_virt_lun0;
626 u32 lun_access = TRANSPORT_LUNFLAGS_READ_ONLY;
627 int ret;
628
629 lun->unpacked_lun = 0;
630 lun->lun_status = TRANSPORT_LUN_STATUS_FREE;
631 atomic_set(&lun->lun_acl_count, 0);
632 init_completion(&lun->lun_shutdown_comp);
633 INIT_LIST_HEAD(&lun->lun_acl_list);
634 INIT_LIST_HEAD(&lun->lun_cmd_list);
635 spin_lock_init(&lun->lun_acl_lock);
636 spin_lock_init(&lun->lun_cmd_lock);
637 spin_lock_init(&lun->lun_sep_lock);
638
639 ret = core_tpg_post_addlun(se_tpg, lun, lun_access, dev);
640 if (ret < 0)
641 return ret;
642
643 return 0;
644 }
645
core_tpg_release_virtual_lun0(struct se_portal_group * se_tpg)646 static void core_tpg_release_virtual_lun0(struct se_portal_group *se_tpg)
647 {
648 struct se_lun *lun = &se_tpg->tpg_virt_lun0;
649
650 core_tpg_post_dellun(se_tpg, lun);
651 }
652
core_tpg_register(struct target_core_fabric_ops * tfo,struct se_wwn * se_wwn,struct se_portal_group * se_tpg,void * tpg_fabric_ptr,int se_tpg_type)653 int core_tpg_register(
654 struct target_core_fabric_ops *tfo,
655 struct se_wwn *se_wwn,
656 struct se_portal_group *se_tpg,
657 void *tpg_fabric_ptr,
658 int se_tpg_type)
659 {
660 struct se_lun *lun;
661 u32 i;
662
663 se_tpg->tpg_lun_list = array_zalloc(TRANSPORT_MAX_LUNS_PER_TPG,
664 sizeof(struct se_lun), GFP_KERNEL);
665 if (!se_tpg->tpg_lun_list) {
666 pr_err("Unable to allocate struct se_portal_group->"
667 "tpg_lun_list\n");
668 return -ENOMEM;
669 }
670
671 for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
672 lun = se_tpg->tpg_lun_list[i];
673 lun->unpacked_lun = i;
674 lun->lun_link_magic = SE_LUN_LINK_MAGIC;
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 }
716 EXPORT_SYMBOL(core_tpg_register);
717
core_tpg_deregister(struct se_portal_group * se_tpg)718 int 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 * Release any remaining demo-mode generated se_node_acl that have
737 * not been released because of TFO->tpg_check_demo_mode_cache() == 1
738 * in transport_deregister_session().
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 }
762 EXPORT_SYMBOL(core_tpg_deregister);
763
core_tpg_pre_addlun(struct se_portal_group * tpg,u32 unpacked_lun)764 struct 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
core_tpg_post_addlun(struct se_portal_group * tpg,struct se_lun * lun,u32 lun_access,void * lun_ptr)794 int 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
core_tpg_shutdown_lun(struct se_portal_group * tpg,struct se_lun * lun)814 static 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
core_tpg_pre_dellun(struct se_portal_group * tpg,u32 unpacked_lun)822 struct 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
core_tpg_post_dellun(struct se_portal_group * tpg,struct se_lun * lun)852 int 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