Kernel

Kernel Git Source Tree

Root/drivers/target/target_core_device.c

1	/*******************************************************************************
2	* Filename: target_core_device.c (based on iscsi_target_device.c)
3	*
4	* This file contains the TCM Virtual Device and Disk Transport
5	* agnostic related functions.
6	*
7	* Copyright (c) 2003, 2004, 2005 PyX Technologies, Inc.
8	* Copyright (c) 2005-2006 SBE, Inc. All Rights Reserved.
9	* Copyright (c) 2007-2010 Rising Tide Systems
10	* Copyright (c) 2008-2010 Linux-iSCSI.org
11	*
12	* Nicholas A. Bellinger <nab@kernel.org>
13	*
14	* This program is free software; you can redistribute it and/or modify
15	* it under the terms of the GNU General Public License as published by
16	* the Free Software Foundation; either version 2 of the License, or
17	* (at your option) any later version.
18	*
19	* This program is distributed in the hope that it will be useful,
20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22	* GNU General Public License for more details.
23	*
24	* You should have received a copy of the GNU General Public License
25	* along with this program; if not, write to the Free Software
26	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27	*
28	******************************************************************************/
29
30	#include <linux/net.h>
31	#include <linux/string.h>
32	#include <linux/delay.h>
33	#include <linux/timer.h>
34	#include <linux/slab.h>
35	#include <linux/spinlock.h>
36	#include <linux/kthread.h>
37	#include <linux/in.h>
38	#include <linux/export.h>
39	#include <net/sock.h>
40	#include <net/tcp.h>
41	#include <scsi/scsi.h>
42	#include <scsi/scsi_device.h>
43
44	#include <target/target_core_base.h>
45	#include <target/target_core_backend.h>
46	#include <target/target_core_fabric.h>
47
48	#include "target_core_internal.h"
49	#include "target_core_alua.h"
50	#include "target_core_pr.h"
51	#include "target_core_ua.h"
52
53	static void se_dev_start(struct se_device *dev);
54	static void se_dev_stop(struct se_device *dev);
55
56	static struct se_hba *lun0_hba;
57	static struct se_subsystem_dev *lun0_su_dev;
58	/* not static, needed by tpg.c */
59	struct se_device *g_lun0_dev;
60
61	int transport_lookup_cmd_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
62	{
63	struct se_lun *se_lun = NULL;
64	struct se_session *se_sess = se_cmd->se_sess;
65	struct se_device *dev;
66	unsigned long flags;
67
68	if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG) {
69	se_cmd->scsi_sense_reason = TCM_NON_EXISTENT_LUN;
70	se_cmd->se_cmd_flags \|= SCF_SCSI_CDB_EXCEPTION;
71	return -ENODEV;
72	}
73
74	spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);
75	se_cmd->se_deve = se_sess->se_node_acl->device_list[unpacked_lun];
76	if (se_cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
77	struct se_dev_entry *deve = se_cmd->se_deve;
78
79	deve->total_cmds++;
80	deve->total_bytes += se_cmd->data_length;
81
82	if ((se_cmd->data_direction == DMA_TO_DEVICE) &&
83	(deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY)) {
84	se_cmd->scsi_sense_reason = TCM_WRITE_PROTECTED;
85	se_cmd->se_cmd_flags \|= SCF_SCSI_CDB_EXCEPTION;
86	pr_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN"
87	" Access for 0x%08x\n",
88	se_cmd->se_tfo->get_fabric_name(),
89	unpacked_lun);
90	spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
91	return -EACCES;
92	}
93
94	if (se_cmd->data_direction == DMA_TO_DEVICE)
95	deve->write_bytes += se_cmd->data_length;
96	else if (se_cmd->data_direction == DMA_FROM_DEVICE)
97	deve->read_bytes += se_cmd->data_length;
98
99	deve->deve_cmds++;
100
101	se_lun = deve->se_lun;
102	se_cmd->se_lun = deve->se_lun;
103	se_cmd->pr_res_key = deve->pr_res_key;
104	se_cmd->orig_fe_lun = unpacked_lun;
105	se_cmd->se_cmd_flags \|= SCF_SE_LUN_CMD;
106	}
107	spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
108
109	if (!se_lun) {
110	/*
111	* Use the se_portal_group->tpg_virt_lun0 to allow for
112	* REPORT_LUNS, et al to be returned when no active
113	* MappedLUN=0 exists for this Initiator Port.
114	*/
115	if (unpacked_lun != 0) {
116	se_cmd->scsi_sense_reason = TCM_NON_EXISTENT_LUN;
117	se_cmd->se_cmd_flags \|= SCF_SCSI_CDB_EXCEPTION;
118	pr_err("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
119	" Access for 0x%08x\n",
120	se_cmd->se_tfo->get_fabric_name(),
121	unpacked_lun);
122	return -ENODEV;
123	}
124	/*
125	* Force WRITE PROTECT for virtual LUN 0
126	*/
127	if ((se_cmd->data_direction != DMA_FROM_DEVICE) &&
128	(se_cmd->data_direction != DMA_NONE)) {
129	se_cmd->scsi_sense_reason = TCM_WRITE_PROTECTED;
130	se_cmd->se_cmd_flags \|= SCF_SCSI_CDB_EXCEPTION;
131	return -EACCES;
132	}
133
134	se_lun = &se_sess->se_tpg->tpg_virt_lun0;
135	se_cmd->se_lun = &se_sess->se_tpg->tpg_virt_lun0;
136	se_cmd->orig_fe_lun = 0;
137	se_cmd->se_cmd_flags \|= SCF_SE_LUN_CMD;
138	}
139	/*
140	* Determine if the struct se_lun is online.
141	* FIXME: Check for LUN_RESET + UNIT Attention
142	*/
143	if (se_dev_check_online(se_lun->lun_se_dev) != 0) {
144	se_cmd->scsi_sense_reason = TCM_NON_EXISTENT_LUN;
145	se_cmd->se_cmd_flags \|= SCF_SCSI_CDB_EXCEPTION;
146	return -ENODEV;
147	}
148
149	/* Directly associate cmd with se_dev */
150	se_cmd->se_dev = se_lun->lun_se_dev;
151
152	/* TODO: get rid of this and use atomics for stats */
153	dev = se_lun->lun_se_dev;
154	spin_lock_irqsave(&dev->stats_lock, flags);
155	dev->num_cmds++;
156	if (se_cmd->data_direction == DMA_TO_DEVICE)
157	dev->write_bytes += se_cmd->data_length;
158	else if (se_cmd->data_direction == DMA_FROM_DEVICE)
159	dev->read_bytes += se_cmd->data_length;
160	spin_unlock_irqrestore(&dev->stats_lock, flags);
161
162	spin_lock_irqsave(&se_lun->lun_cmd_lock, flags);
163	list_add_tail(&se_cmd->se_lun_node, &se_lun->lun_cmd_list);
164	spin_unlock_irqrestore(&se_lun->lun_cmd_lock, flags);
165
166	return 0;
167	}
168	EXPORT_SYMBOL(transport_lookup_cmd_lun);
169
170	int transport_lookup_tmr_lun(struct se_cmd *se_cmd, u32 unpacked_lun)
171	{
172	struct se_dev_entry *deve;
173	struct se_lun *se_lun = NULL;
174	struct se_session *se_sess = se_cmd->se_sess;
175	struct se_tmr_req *se_tmr = se_cmd->se_tmr_req;
176	unsigned long flags;
177
178	if (unpacked_lun >= TRANSPORT_MAX_LUNS_PER_TPG) {
179	se_cmd->scsi_sense_reason = TCM_NON_EXISTENT_LUN;
180	se_cmd->se_cmd_flags \|= SCF_SCSI_CDB_EXCEPTION;
181	return -ENODEV;
182	}
183
184	spin_lock_irqsave(&se_sess->se_node_acl->device_list_lock, flags);
185	se_cmd->se_deve = se_sess->se_node_acl->device_list[unpacked_lun];
186	deve = se_cmd->se_deve;
187
188	if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
189	se_tmr->tmr_lun = deve->se_lun;
190	se_cmd->se_lun = deve->se_lun;
191	se_lun = deve->se_lun;
192	se_cmd->pr_res_key = deve->pr_res_key;
193	se_cmd->orig_fe_lun = unpacked_lun;
194	}
195	spin_unlock_irqrestore(&se_sess->se_node_acl->device_list_lock, flags);
196
197	if (!se_lun) {
198	pr_debug("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
199	" Access for 0x%08x\n",
200	se_cmd->se_tfo->get_fabric_name(),
201	unpacked_lun);
202	se_cmd->se_cmd_flags \|= SCF_SCSI_CDB_EXCEPTION;
203	return -ENODEV;
204	}
205	/*
206	* Determine if the struct se_lun is online.
207	* FIXME: Check for LUN_RESET + UNIT Attention
208	*/
209	if (se_dev_check_online(se_lun->lun_se_dev) != 0) {
210	se_cmd->se_cmd_flags \|= SCF_SCSI_CDB_EXCEPTION;
211	return -ENODEV;
212	}
213
214	/* Directly associate cmd with se_dev */
215	se_cmd->se_dev = se_lun->lun_se_dev;
216	se_tmr->tmr_dev = se_lun->lun_se_dev;
217
218	spin_lock_irqsave(&se_tmr->tmr_dev->se_tmr_lock, flags);
219	list_add_tail(&se_tmr->tmr_list, &se_tmr->tmr_dev->dev_tmr_list);
220	spin_unlock_irqrestore(&se_tmr->tmr_dev->se_tmr_lock, flags);
221
222	return 0;
223	}
224	EXPORT_SYMBOL(transport_lookup_tmr_lun);
225
226	/*
227	* This function is called from core_scsi3_emulate_pro_register_and_move()
228	* and core_scsi3_decode_spec_i_port(), and will increment &deve->pr_ref_count
229	* when a matching rtpi is found.
230	*/
231	struct se_dev_entry *core_get_se_deve_from_rtpi(
232	struct se_node_acl *nacl,
233	u16 rtpi)
234	{
235	struct se_dev_entry *deve;
236	struct se_lun *lun;
237	struct se_port *port;
238	struct se_portal_group *tpg = nacl->se_tpg;
239	u32 i;
240
241	spin_lock_irq(&nacl->device_list_lock);
242	for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
243	deve = nacl->device_list[i];
244
245	if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS))
246	continue;
247
248	lun = deve->se_lun;
249	if (!lun) {
250	pr_err("%s device entries device pointer is"
251	" NULL, but Initiator has access.\n",
252	tpg->se_tpg_tfo->get_fabric_name());
253	continue;
254	}
255	port = lun->lun_sep;
256	if (!port) {
257	pr_err("%s device entries device pointer is"
258	" NULL, but Initiator has access.\n",
259	tpg->se_tpg_tfo->get_fabric_name());
260	continue;
261	}
262	if (port->sep_rtpi != rtpi)
263	continue;
264
265	atomic_inc(&deve->pr_ref_count);
266	smp_mb__after_atomic_inc();
267	spin_unlock_irq(&nacl->device_list_lock);
268
269	return deve;
270	}
271	spin_unlock_irq(&nacl->device_list_lock);
272
273	return NULL;
274	}
275
276	int core_free_device_list_for_node(
277	struct se_node_acl *nacl,
278	struct se_portal_group *tpg)
279	{
280	struct se_dev_entry *deve;
281	struct se_lun *lun;
282	u32 i;
283
284	if (!nacl->device_list)
285	return 0;
286
287	spin_lock_irq(&nacl->device_list_lock);
288	for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
289	deve = nacl->device_list[i];
290
291	if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS))
292	continue;
293
294	if (!deve->se_lun) {
295	pr_err("%s device entries device pointer is"
296	" NULL, but Initiator has access.\n",
297	tpg->se_tpg_tfo->get_fabric_name());
298	continue;
299	}
300	lun = deve->se_lun;
301
302	spin_unlock_irq(&nacl->device_list_lock);
303	core_disable_device_list_for_node(lun, NULL, deve->mapped_lun,
304	TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);
305	spin_lock_irq(&nacl->device_list_lock);
306	}
307	spin_unlock_irq(&nacl->device_list_lock);
308
309	array_free(nacl->device_list, TRANSPORT_MAX_LUNS_PER_TPG);
310	nacl->device_list = NULL;
311
312	return 0;
313	}
314
315	void core_dec_lacl_count(struct se_node_acl se_nacl, struct se_cmd se_cmd)
316	{
317	struct se_dev_entry *deve;
318	unsigned long flags;
319
320	spin_lock_irqsave(&se_nacl->device_list_lock, flags);
321	deve = se_nacl->device_list[se_cmd->orig_fe_lun];
322	deve->deve_cmds--;
323	spin_unlock_irqrestore(&se_nacl->device_list_lock, flags);
324	}
325
326	void core_update_device_list_access(
327	u32 mapped_lun,
328	u32 lun_access,
329	struct se_node_acl *nacl)
330	{
331	struct se_dev_entry *deve;
332
333	spin_lock_irq(&nacl->device_list_lock);
334	deve = nacl->device_list[mapped_lun];
335	if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
336	deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
337	deve->lun_flags \|= TRANSPORT_LUNFLAGS_READ_WRITE;
338	} else {
339	deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;
340	deve->lun_flags \|= TRANSPORT_LUNFLAGS_READ_ONLY;
341	}
342	spin_unlock_irq(&nacl->device_list_lock);
343	}
344
345	/* core_enable_device_list_for_node():
346	*
347	*
348	*/
349	int core_enable_device_list_for_node(
350	struct se_lun *lun,
351	struct se_lun_acl *lun_acl,
352	u32 mapped_lun,
353	u32 lun_access,
354	struct se_node_acl *nacl,
355	struct se_portal_group *tpg)
356	{
357	struct se_port *port = lun->lun_sep;
358	struct se_dev_entry *deve;
359
360	spin_lock_irq(&nacl->device_list_lock);
361
362	deve = nacl->device_list[mapped_lun];
363
364	/*
365	* Check if the call is handling demo mode -> explict LUN ACL
366	* transition. This transition must be for the same struct se_lun
367	* + mapped_lun that was setup in demo mode..
368	*/
369	if (deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS) {
370	if (deve->se_lun_acl != NULL) {
371	pr_err("struct se_dev_entry->se_lun_acl"
372	" already set for demo mode -> explict"
373	" LUN ACL transition\n");
374	spin_unlock_irq(&nacl->device_list_lock);
375	return -EINVAL;
376	}
377	if (deve->se_lun != lun) {
378	pr_err("struct se_dev_entry->se_lun does"
379	" match passed struct se_lun for demo mode"
380	" -> explict LUN ACL transition\n");
381	spin_unlock_irq(&nacl->device_list_lock);
382	return -EINVAL;
383	}
384	deve->se_lun_acl = lun_acl;
385
386	if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
387	deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
388	deve->lun_flags \|= TRANSPORT_LUNFLAGS_READ_WRITE;
389	} else {
390	deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;
391	deve->lun_flags \|= TRANSPORT_LUNFLAGS_READ_ONLY;
392	}
393
394	spin_unlock_irq(&nacl->device_list_lock);
395	return 0;
396	}
397
398	deve->se_lun = lun;
399	deve->se_lun_acl = lun_acl;
400	deve->mapped_lun = mapped_lun;
401	deve->lun_flags \|= TRANSPORT_LUNFLAGS_INITIATOR_ACCESS;
402
403	if (lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) {
404	deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_ONLY;
405	deve->lun_flags \|= TRANSPORT_LUNFLAGS_READ_WRITE;
406	} else {
407	deve->lun_flags &= ~TRANSPORT_LUNFLAGS_READ_WRITE;
408	deve->lun_flags \|= TRANSPORT_LUNFLAGS_READ_ONLY;
409	}
410
411	deve->creation_time = get_jiffies_64();
412	deve->attach_count++;
413	spin_unlock_irq(&nacl->device_list_lock);
414
415	spin_lock_bh(&port->sep_alua_lock);
416	list_add_tail(&deve->alua_port_list, &port->sep_alua_list);
417	spin_unlock_bh(&port->sep_alua_lock);
418
419	return 0;
420	}
421
422	/* core_disable_device_list_for_node():
423	*
424	*
425	*/
426	int core_disable_device_list_for_node(
427	struct se_lun *lun,
428	struct se_lun_acl *lun_acl,
429	u32 mapped_lun,
430	u32 lun_access,
431	struct se_node_acl *nacl,
432	struct se_portal_group *tpg)
433	{
434	struct se_port *port = lun->lun_sep;
435	struct se_dev_entry *deve = nacl->device_list[mapped_lun];
436
437	/*
438	* If the MappedLUN entry is being disabled, the entry in
439	* port->sep_alua_list must be removed now before clearing the
440	* struct se_dev_entry pointers below as logic in
441	* core_alua_do_transition_tg_pt() depends on these being present.
442	*
443	* deve->se_lun_acl will be NULL for demo-mode created LUNs
444	* that have not been explicitly converted to MappedLUNs ->
445	* struct se_lun_acl, but we remove deve->alua_port_list from
446	* port->sep_alua_list. This also means that active UAs and
447	* NodeACL context specific PR metadata for demo-mode
448	* MappedLUN *deve will be released below..
449	*/
450	spin_lock_bh(&port->sep_alua_lock);
451	list_del(&deve->alua_port_list);
452	spin_unlock_bh(&port->sep_alua_lock);
453	/*
454	* Wait for any in process SPEC_I_PT=1 or REGISTER_AND_MOVE
455	* PR operation to complete.
456	*/
457	while (atomic_read(&deve->pr_ref_count) != 0)
458	cpu_relax();
459
460	spin_lock_irq(&nacl->device_list_lock);
461	/*
462	* Disable struct se_dev_entry LUN ACL mapping
463	*/
464	core_scsi3_ua_release_all(deve);
465	deve->se_lun = NULL;
466	deve->se_lun_acl = NULL;
467	deve->lun_flags = 0;
468	deve->creation_time = 0;
469	deve->attach_count--;
470	spin_unlock_irq(&nacl->device_list_lock);
471
472	core_scsi3_free_pr_reg_from_nacl(lun->lun_se_dev, nacl);
473	return 0;
474	}
475
476	/* core_clear_lun_from_tpg():
477	*
478	*
479	*/
480	void core_clear_lun_from_tpg(struct se_lun lun, struct se_portal_group tpg)
481	{
482	struct se_node_acl *nacl;
483	struct se_dev_entry *deve;
484	u32 i;
485
486	spin_lock_irq(&tpg->acl_node_lock);
487	list_for_each_entry(nacl, &tpg->acl_node_list, acl_list) {
488	spin_unlock_irq(&tpg->acl_node_lock);
489
490	spin_lock_irq(&nacl->device_list_lock);
491	for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
492	deve = nacl->device_list[i];
493	if (lun != deve->se_lun)
494	continue;
495	spin_unlock_irq(&nacl->device_list_lock);
496
497	core_disable_device_list_for_node(lun, NULL,
498	deve->mapped_lun, TRANSPORT_LUNFLAGS_NO_ACCESS,
499	nacl, tpg);
500
501	spin_lock_irq(&nacl->device_list_lock);
502	}
503	spin_unlock_irq(&nacl->device_list_lock);
504
505	spin_lock_irq(&tpg->acl_node_lock);
506	}
507	spin_unlock_irq(&tpg->acl_node_lock);
508	}
509
510	static struct se_port core_alloc_port(struct se_device dev)
511	{
512	struct se_port port, port_tmp;
513
514	port = kzalloc(sizeof(struct se_port), GFP_KERNEL);
515	if (!port) {
516	pr_err("Unable to allocate struct se_port\n");
517	return ERR_PTR(-ENOMEM);
518	}
519	INIT_LIST_HEAD(&port->sep_alua_list);
520	INIT_LIST_HEAD(&port->sep_list);
521	atomic_set(&port->sep_tg_pt_secondary_offline, 0);
522	spin_lock_init(&port->sep_alua_lock);
523	mutex_init(&port->sep_tg_pt_md_mutex);
524
525	spin_lock(&dev->se_port_lock);
526	if (dev->dev_port_count == 0x0000ffff) {
527	pr_warn("Reached dev->dev_port_count =="
528	" 0x0000ffff\n");
529	spin_unlock(&dev->se_port_lock);
530	return ERR_PTR(-ENOSPC);
531	}
532	again:
533	/*
534	* Allocate the next RELATIVE TARGET PORT IDENTIFER for this struct se_device
535	* Here is the table from spc4r17 section 7.7.3.8.
536	*
537	* Table 473 -- RELATIVE TARGET PORT IDENTIFIER field
538	*
539	* Code Description
540	* 0h Reserved
541	* 1h Relative port 1, historically known as port A
542	* 2h Relative port 2, historically known as port B
543	* 3h to FFFFh Relative port 3 through 65 535
544	*/
545	port->sep_rtpi = dev->dev_rpti_counter++;
546	if (!port->sep_rtpi)
547	goto again;
548
549	list_for_each_entry(port_tmp, &dev->dev_sep_list, sep_list) {
550	/*
551	* Make sure RELATIVE TARGET PORT IDENTIFER is unique
552	* for 16-bit wrap..
553	*/
554	if (port->sep_rtpi == port_tmp->sep_rtpi)
555	goto again;
556	}
557	spin_unlock(&dev->se_port_lock);
558
559	return port;
560	}
561
562	static void core_export_port(
563	struct se_device *dev,
564	struct se_portal_group *tpg,
565	struct se_port *port,
566	struct se_lun *lun)
567	{
568	struct se_subsystem_dev *su_dev = dev->se_sub_dev;
569	struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem = NULL;
570
571	spin_lock(&dev->se_port_lock);
572	spin_lock(&lun->lun_sep_lock);
573	port->sep_tpg = tpg;
574	port->sep_lun = lun;
575	lun->lun_sep = port;
576	spin_unlock(&lun->lun_sep_lock);
577
578	list_add_tail(&port->sep_list, &dev->dev_sep_list);
579	spin_unlock(&dev->se_port_lock);
580
581	if (su_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) {
582	tg_pt_gp_mem = core_alua_allocate_tg_pt_gp_mem(port);
583	if (IS_ERR(tg_pt_gp_mem) \|\| !tg_pt_gp_mem) {
584	pr_err("Unable to allocate t10_alua_tg_pt"
585	"_gp_member_t\n");
586	return;
587	}
588	spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
589	__core_alua_attach_tg_pt_gp_mem(tg_pt_gp_mem,
590	su_dev->t10_alua.default_tg_pt_gp);
591	spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
592	pr_debug("%s/%s: Adding to default ALUA Target Port"
593	" Group: alua/default_tg_pt_gp\n",
594	dev->transport->name, tpg->se_tpg_tfo->get_fabric_name());
595	}
596
597	dev->dev_port_count++;
598	port->sep_index = port->sep_rtpi; /* RELATIVE TARGET PORT IDENTIFER */
599	}
600
601	/*
602	* Called with struct se_device->se_port_lock spinlock held.
603	*/
604	static void core_release_port(struct se_device dev, struct se_port port)
605	__releases(&dev->se_port_lock) __acquires(&dev->se_port_lock)
606	{
607	/*
608	* Wait for any port reference for PR ALL_TG_PT=1 operation
609	* to complete in __core_scsi3_alloc_registration()
610	*/
611	spin_unlock(&dev->se_port_lock);
612	if (atomic_read(&port->sep_tg_pt_ref_cnt))
613	cpu_relax();
614	spin_lock(&dev->se_port_lock);
615
616	core_alua_free_tg_pt_gp_mem(port);
617
618	list_del(&port->sep_list);
619	dev->dev_port_count--;
620	kfree(port);
621	}
622
623	int core_dev_export(
624	struct se_device *dev,
625	struct se_portal_group *tpg,
626	struct se_lun *lun)
627	{
628	struct se_port *port;
629
630	port = core_alloc_port(dev);
631	if (IS_ERR(port))
632	return PTR_ERR(port);
633
634	lun->lun_se_dev = dev;
635	se_dev_start(dev);
636
637	atomic_inc(&dev->dev_export_obj.obj_access_count);
638	core_export_port(dev, tpg, port, lun);
639	return 0;
640	}
641
642	void core_dev_unexport(
643	struct se_device *dev,
644	struct se_portal_group *tpg,
645	struct se_lun *lun)
646	{
647	struct se_port *port = lun->lun_sep;
648
649	spin_lock(&lun->lun_sep_lock);
650	if (lun->lun_se_dev == NULL) {
651	spin_unlock(&lun->lun_sep_lock);
652	return;
653	}
654	spin_unlock(&lun->lun_sep_lock);
655
656	spin_lock(&dev->se_port_lock);
657	atomic_dec(&dev->dev_export_obj.obj_access_count);
658	core_release_port(dev, port);
659	spin_unlock(&dev->se_port_lock);
660
661	se_dev_stop(dev);
662	lun->lun_se_dev = NULL;
663	}
664
665	int target_report_luns(struct se_cmd *se_cmd)
666	{
667	struct se_dev_entry *deve;
668	struct se_session *se_sess = se_cmd->se_sess;
669	unsigned char *buf;
670	u32 lun_count = 0, offset = 8, i;
671
672	if (se_cmd->data_length < 16) {
673	pr_warn("REPORT LUNS allocation length %u too small\n",
674	se_cmd->data_length);
675	se_cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD;
676	return -EINVAL;
677	}
678
679	buf = transport_kmap_data_sg(se_cmd);
680	if (!buf)
681	return -ENOMEM;
682
683	/*
684	* If no struct se_session pointer is present, this struct se_cmd is
685	* coming via a target_core_mod PASSTHROUGH op, and not through
686	* a $FABRIC_MOD. In that case, report LUN=0 only.
687	*/
688	if (!se_sess) {
689	int_to_scsilun(0, (struct scsi_lun *)&buf[offset]);
690	lun_count = 1;
691	goto done;
692	}
693
694	spin_lock_irq(&se_sess->se_node_acl->device_list_lock);
695	for (i = 0; i < TRANSPORT_MAX_LUNS_PER_TPG; i++) {
696	deve = se_sess->se_node_acl->device_list[i];
697	if (!(deve->lun_flags & TRANSPORT_LUNFLAGS_INITIATOR_ACCESS))
698	continue;
699	/*
700	* We determine the correct LUN LIST LENGTH even once we
701	* have reached the initial allocation length.
702	* See SPC2-R20 7.19.
703	*/
704	lun_count++;
705	if ((offset + 8) > se_cmd->data_length)
706	continue;
707
708	int_to_scsilun(deve->mapped_lun, (struct scsi_lun *)&buf[offset]);
709	offset += 8;
710	}
711	spin_unlock_irq(&se_sess->se_node_acl->device_list_lock);
712
713	/*
714	* See SPC3 r07, page 159.
715	*/
716	done:
717	lun_count *= 8;
718	buf[0] = ((lun_count >> 24) & 0xff);
719	buf[1] = ((lun_count >> 16) & 0xff);
720	buf[2] = ((lun_count >> 8) & 0xff);
721	buf[3] = (lun_count & 0xff);
722	transport_kunmap_data_sg(se_cmd);
723
724	target_complete_cmd(se_cmd, GOOD);
725	return 0;
726	}
727
728	/* se_release_device_for_hba():
729	*
730	*
731	*/
732	void se_release_device_for_hba(struct se_device *dev)
733	{
734	struct se_hba *hba = dev->se_hba;
735
736	if ((dev->dev_status & TRANSPORT_DEVICE_ACTIVATED) \|\|
737	(dev->dev_status & TRANSPORT_DEVICE_DEACTIVATED) \|\|
738	(dev->dev_status & TRANSPORT_DEVICE_SHUTDOWN) \|\|
739	(dev->dev_status & TRANSPORT_DEVICE_OFFLINE_ACTIVATED) \|\|
740	(dev->dev_status & TRANSPORT_DEVICE_OFFLINE_DEACTIVATED))
741	se_dev_stop(dev);
742
743	if (dev->dev_ptr) {
744	destroy_workqueue(dev->tmr_wq);
745	if (dev->transport->free_device)
746	dev->transport->free_device(dev->dev_ptr);
747	}
748
749	spin_lock(&hba->device_lock);
750	list_del(&dev->dev_list);
751	hba->dev_count--;
752	spin_unlock(&hba->device_lock);
753
754	core_scsi3_free_all_registrations(dev);
755	se_release_vpd_for_dev(dev);
756
757	kfree(dev);
758	}
759
760	void se_release_vpd_for_dev(struct se_device *dev)
761	{
762	struct t10_vpd vpd, vpd_tmp;
763
764	spin_lock(&dev->se_sub_dev->t10_wwn.t10_vpd_lock);
765	list_for_each_entry_safe(vpd, vpd_tmp,
766	&dev->se_sub_dev->t10_wwn.t10_vpd_list, vpd_list) {
767	list_del(&vpd->vpd_list);
768	kfree(vpd);
769	}
770	spin_unlock(&dev->se_sub_dev->t10_wwn.t10_vpd_lock);
771	}
772
773	/* se_free_virtual_device():
774	*
775	* Used for IBLOCK, RAMDISK, and FILEIO Transport Drivers.
776	*/
777	int se_free_virtual_device(struct se_device dev, struct se_hba hba)
778	{
779	if (!list_empty(&dev->dev_sep_list))
780	dump_stack();
781
782	core_alua_free_lu_gp_mem(dev);
783	se_release_device_for_hba(dev);
784
785	return 0;
786	}
787
788	static void se_dev_start(struct se_device *dev)
789	{
790	struct se_hba *hba = dev->se_hba;
791
792	spin_lock(&hba->device_lock);
793	atomic_inc(&dev->dev_obj.obj_access_count);
794	if (atomic_read(&dev->dev_obj.obj_access_count) == 1) {
795	if (dev->dev_status & TRANSPORT_DEVICE_DEACTIVATED) {
796	dev->dev_status &= ~TRANSPORT_DEVICE_DEACTIVATED;
797	dev->dev_status \|= TRANSPORT_DEVICE_ACTIVATED;
798	} else if (dev->dev_status &
799	TRANSPORT_DEVICE_OFFLINE_DEACTIVATED) {
800	dev->dev_status &=
801	~TRANSPORT_DEVICE_OFFLINE_DEACTIVATED;
802	dev->dev_status \|= TRANSPORT_DEVICE_OFFLINE_ACTIVATED;
803	}
804	}
805	spin_unlock(&hba->device_lock);
806	}
807
808	static void se_dev_stop(struct se_device *dev)
809	{
810	struct se_hba *hba = dev->se_hba;
811
812	spin_lock(&hba->device_lock);
813	atomic_dec(&dev->dev_obj.obj_access_count);
814	if (atomic_read(&dev->dev_obj.obj_access_count) == 0) {
815	if (dev->dev_status & TRANSPORT_DEVICE_ACTIVATED) {
816	dev->dev_status &= ~TRANSPORT_DEVICE_ACTIVATED;
817	dev->dev_status \|= TRANSPORT_DEVICE_DEACTIVATED;
818	} else if (dev->dev_status &
819	TRANSPORT_DEVICE_OFFLINE_ACTIVATED) {
820	dev->dev_status &= ~TRANSPORT_DEVICE_OFFLINE_ACTIVATED;
821	dev->dev_status \|= TRANSPORT_DEVICE_OFFLINE_DEACTIVATED;
822	}
823	}
824	spin_unlock(&hba->device_lock);
825	}
826
827	int se_dev_check_online(struct se_device *dev)
828	{
829	unsigned long flags;
830	int ret;
831
832	spin_lock_irqsave(&dev->dev_status_lock, flags);
833	ret = ((dev->dev_status & TRANSPORT_DEVICE_ACTIVATED) \|\|
834	(dev->dev_status & TRANSPORT_DEVICE_DEACTIVATED)) ? 0 : 1;
835	spin_unlock_irqrestore(&dev->dev_status_lock, flags);
836
837	return ret;
838	}
839
840	int se_dev_check_shutdown(struct se_device *dev)
841	{
842	int ret;
843
844	spin_lock_irq(&dev->dev_status_lock);
845	ret = (dev->dev_status & TRANSPORT_DEVICE_SHUTDOWN);
846	spin_unlock_irq(&dev->dev_status_lock);
847
848	return ret;
849	}
850
851	static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size)
852	{
853	u32 tmp, aligned_max_sectors;
854	/*
855	* Limit max_sectors to a PAGE_SIZE aligned value for modern
856	* transport_allocate_data_tasks() operation.
857	*/
858	tmp = rounddown((max_sectors * block_size), PAGE_SIZE);
859	aligned_max_sectors = (tmp / block_size);
860	if (max_sectors != aligned_max_sectors) {
861	printk(KERN_INFO "Rounding down aligned max_sectors from %u"
862	" to %u\n", max_sectors, aligned_max_sectors);
863	return aligned_max_sectors;
864	}
865
866	return max_sectors;
867	}
868
869	void se_dev_set_default_attribs(
870	struct se_device *dev,
871	struct se_dev_limits *dev_limits)
872	{
873	struct queue_limits *limits = &dev_limits->limits;
874
875	dev->se_sub_dev->se_dev_attrib.emulate_dpo = DA_EMULATE_DPO;
876	dev->se_sub_dev->se_dev_attrib.emulate_fua_write = DA_EMULATE_FUA_WRITE;
877	dev->se_sub_dev->se_dev_attrib.emulate_fua_read = DA_EMULATE_FUA_READ;
878	dev->se_sub_dev->se_dev_attrib.emulate_write_cache = DA_EMULATE_WRITE_CACHE;
879	dev->se_sub_dev->se_dev_attrib.emulate_ua_intlck_ctrl = DA_EMULATE_UA_INTLLCK_CTRL;
880	dev->se_sub_dev->se_dev_attrib.emulate_tas = DA_EMULATE_TAS;
881	dev->se_sub_dev->se_dev_attrib.emulate_tpu = DA_EMULATE_TPU;
882	dev->se_sub_dev->se_dev_attrib.emulate_tpws = DA_EMULATE_TPWS;
883	dev->se_sub_dev->se_dev_attrib.emulate_reservations = DA_EMULATE_RESERVATIONS;
884	dev->se_sub_dev->se_dev_attrib.emulate_alua = DA_EMULATE_ALUA;
885	dev->se_sub_dev->se_dev_attrib.enforce_pr_isids = DA_ENFORCE_PR_ISIDS;
886	dev->se_sub_dev->se_dev_attrib.is_nonrot = DA_IS_NONROT;
887	dev->se_sub_dev->se_dev_attrib.emulate_rest_reord = DA_EMULATE_REST_REORD;
888	/*
889	* The TPU=1 and TPWS=1 settings will be set in TCM/IBLOCK
890	* iblock_create_virtdevice() from struct queue_limits values
891	* if blk_queue_discard()==1
892	*/
893	dev->se_sub_dev->se_dev_attrib.max_unmap_lba_count = DA_MAX_UNMAP_LBA_COUNT;
894	dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count =
895	DA_MAX_UNMAP_BLOCK_DESC_COUNT;
896	dev->se_sub_dev->se_dev_attrib.unmap_granularity = DA_UNMAP_GRANULARITY_DEFAULT;
897	dev->se_sub_dev->se_dev_attrib.unmap_granularity_alignment =
898	DA_UNMAP_GRANULARITY_ALIGNMENT_DEFAULT;
899	/*
900	* block_size is based on subsystem plugin dependent requirements.
901	*/
902	dev->se_sub_dev->se_dev_attrib.hw_block_size = limits->logical_block_size;
903	dev->se_sub_dev->se_dev_attrib.block_size = limits->logical_block_size;
904	/*
905	* Align max_hw_sectors down to PAGE_SIZE I/O transfers
906	*/
907	limits->max_hw_sectors = se_dev_align_max_sectors(limits->max_hw_sectors,
908	limits->logical_block_size);
909	dev->se_sub_dev->se_dev_attrib.hw_max_sectors = limits->max_hw_sectors;
910
911	/*
912	* Set fabric_max_sectors, which is reported in block limits
913	* VPD page (B0h).
914	*/
915	dev->se_sub_dev->se_dev_attrib.fabric_max_sectors = DA_FABRIC_MAX_SECTORS;
916	/*
917	* Set optimal_sectors from fabric_max_sectors, which can be
918	* lowered via configfs.
919	*/
920	dev->se_sub_dev->se_dev_attrib.optimal_sectors = DA_FABRIC_MAX_SECTORS;
921	/*
922	* queue_depth is based on subsystem plugin dependent requirements.
923	*/
924	dev->se_sub_dev->se_dev_attrib.hw_queue_depth = dev_limits->hw_queue_depth;
925	dev->se_sub_dev->se_dev_attrib.queue_depth = dev_limits->queue_depth;
926	}
927
928	int se_dev_set_max_unmap_lba_count(
929	struct se_device *dev,
930	u32 max_unmap_lba_count)
931	{
932	dev->se_sub_dev->se_dev_attrib.max_unmap_lba_count = max_unmap_lba_count;
933	pr_debug("dev[%p]: Set max_unmap_lba_count: %u\n",
934	dev, dev->se_sub_dev->se_dev_attrib.max_unmap_lba_count);
935	return 0;
936	}
937
938	int se_dev_set_max_unmap_block_desc_count(
939	struct se_device *dev,
940	u32 max_unmap_block_desc_count)
941	{
942	dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count =
943	max_unmap_block_desc_count;
944	pr_debug("dev[%p]: Set max_unmap_block_desc_count: %u\n",
945	dev, dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count);
946	return 0;
947	}
948
949	int se_dev_set_unmap_granularity(
950	struct se_device *dev,
951	u32 unmap_granularity)
952	{
953	dev->se_sub_dev->se_dev_attrib.unmap_granularity = unmap_granularity;
954	pr_debug("dev[%p]: Set unmap_granularity: %u\n",
955	dev, dev->se_sub_dev->se_dev_attrib.unmap_granularity);
956	return 0;
957	}
958
959	int se_dev_set_unmap_granularity_alignment(
960	struct se_device *dev,
961	u32 unmap_granularity_alignment)
962	{
963	dev->se_sub_dev->se_dev_attrib.unmap_granularity_alignment = unmap_granularity_alignment;
964	pr_debug("dev[%p]: Set unmap_granularity_alignment: %u\n",
965	dev, dev->se_sub_dev->se_dev_attrib.unmap_granularity_alignment);
966	return 0;
967	}
968
969	int se_dev_set_emulate_dpo(struct se_device *dev, int flag)
970	{
971	if (flag != 0 && flag != 1) {
972	pr_err("Illegal value %d\n", flag);
973	return -EINVAL;
974	}
975
976	if (flag) {
977	pr_err("dpo_emulated not supported\n");
978	return -EINVAL;
979	}
980
981	return 0;
982	}
983
984	int se_dev_set_emulate_fua_write(struct se_device *dev, int flag)
985	{
986	if (flag != 0 && flag != 1) {
987	pr_err("Illegal value %d\n", flag);
988	return -EINVAL;
989	}
990
991	if (flag && dev->transport->fua_write_emulated == 0) {
992	pr_err("fua_write_emulated not supported\n");
993	return -EINVAL;
994	}
995	dev->se_sub_dev->se_dev_attrib.emulate_fua_write = flag;
996	pr_debug("dev[%p]: SE Device Forced Unit Access WRITEs: %d\n",
997	dev, dev->se_sub_dev->se_dev_attrib.emulate_fua_write);
998	return 0;
999	}
1000
1001	int se_dev_set_emulate_fua_read(struct se_device *dev, int flag)
1002	{
1003	if (flag != 0 && flag != 1) {
1004	pr_err("Illegal value %d\n", flag);
1005	return -EINVAL;
1006	}
1007
1008	if (flag) {
1009	pr_err("ua read emulated not supported\n");
1010	return -EINVAL;
1011	}
1012
1013	return 0;
1014	}
1015
1016	int se_dev_set_emulate_write_cache(struct se_device *dev, int flag)
1017	{
1018	if (flag != 0 && flag != 1) {
1019	pr_err("Illegal value %d\n", flag);
1020	return -EINVAL;
1021	}
1022	if (flag && dev->transport->write_cache_emulated == 0) {
1023	pr_err("write_cache_emulated not supported\n");
1024	return -EINVAL;
1025	}
1026	dev->se_sub_dev->se_dev_attrib.emulate_write_cache = flag;
1027	pr_debug("dev[%p]: SE Device WRITE_CACHE_EMULATION flag: %d\n",
1028	dev, dev->se_sub_dev->se_dev_attrib.emulate_write_cache);
1029	return 0;
1030	}
1031
1032	int se_dev_set_emulate_ua_intlck_ctrl(struct se_device *dev, int flag)
1033	{
1034	if ((flag != 0) && (flag != 1) && (flag != 2)) {
1035	pr_err("Illegal value %d\n", flag);
1036	return -EINVAL;
1037	}
1038
1039	if (atomic_read(&dev->dev_export_obj.obj_access_count)) {
1040	pr_err("dev[%p]: Unable to change SE Device"
1041	" UA_INTRLCK_CTRL while dev_export_obj: %d count"
1042	" exists\n", dev,
1043	atomic_read(&dev->dev_export_obj.obj_access_count));
1044	return -EINVAL;
1045	}
1046	dev->se_sub_dev->se_dev_attrib.emulate_ua_intlck_ctrl = flag;
1047	pr_debug("dev[%p]: SE Device UA_INTRLCK_CTRL flag: %d\n",
1048	dev, dev->se_sub_dev->se_dev_attrib.emulate_ua_intlck_ctrl);
1049
1050	return 0;
1051	}
1052
1053	int se_dev_set_emulate_tas(struct se_device *dev, int flag)
1054	{
1055	if ((flag != 0) && (flag != 1)) {
1056	pr_err("Illegal value %d\n", flag);
1057	return -EINVAL;
1058	}
1059
1060	if (atomic_read(&dev->dev_export_obj.obj_access_count)) {
1061	pr_err("dev[%p]: Unable to change SE Device TAS while"
1062	" dev_export_obj: %d count exists\n", dev,
1063	atomic_read(&dev->dev_export_obj.obj_access_count));
1064	return -EINVAL;
1065	}
1066	dev->se_sub_dev->se_dev_attrib.emulate_tas = flag;
1067	pr_debug("dev[%p]: SE Device TASK_ABORTED status bit: %s\n",
1068	dev, (dev->se_sub_dev->se_dev_attrib.emulate_tas) ? "Enabled" : "Disabled");
1069
1070	return 0;
1071	}
1072
1073	int se_dev_set_emulate_tpu(struct se_device *dev, int flag)
1074	{
1075	if ((flag != 0) && (flag != 1)) {
1076	pr_err("Illegal value %d\n", flag);
1077	return -EINVAL;
1078	}
1079	/*
1080	* We expect this value to be non-zero when generic Block Layer
1081	* Discard supported is detected iblock_create_virtdevice().
1082	*/
1083	if (flag && !dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count) {
1084	pr_err("Generic Block Discard not supported\n");
1085	return -ENOSYS;
1086	}
1087
1088	dev->se_sub_dev->se_dev_attrib.emulate_tpu = flag;
1089	pr_debug("dev[%p]: SE Device Thin Provisioning UNMAP bit: %d\n",
1090	dev, flag);
1091	return 0;
1092	}
1093
1094	int se_dev_set_emulate_tpws(struct se_device *dev, int flag)
1095	{
1096	if ((flag != 0) && (flag != 1)) {
1097	pr_err("Illegal value %d\n", flag);
1098	return -EINVAL;
1099	}
1100	/*
1101	* We expect this value to be non-zero when generic Block Layer
1102	* Discard supported is detected iblock_create_virtdevice().
1103	*/
1104	if (flag && !dev->se_sub_dev->se_dev_attrib.max_unmap_block_desc_count) {
1105	pr_err("Generic Block Discard not supported\n");
1106	return -ENOSYS;
1107	}
1108
1109	dev->se_sub_dev->se_dev_attrib.emulate_tpws = flag;
1110	pr_debug("dev[%p]: SE Device Thin Provisioning WRITE_SAME: %d\n",
1111	dev, flag);
1112	return 0;
1113	}
1114
1115	int se_dev_set_enforce_pr_isids(struct se_device *dev, int flag)
1116	{
1117	if ((flag != 0) && (flag != 1)) {
1118	pr_err("Illegal value %d\n", flag);
1119	return -EINVAL;
1120	}
1121	dev->se_sub_dev->se_dev_attrib.enforce_pr_isids = flag;
1122	pr_debug("dev[%p]: SE Device enforce_pr_isids bit: %s\n", dev,
1123	(dev->se_sub_dev->se_dev_attrib.enforce_pr_isids) ? "Enabled" : "Disabled");
1124	return 0;
1125	}
1126
1127	int se_dev_set_is_nonrot(struct se_device *dev, int flag)
1128	{
1129	if ((flag != 0) && (flag != 1)) {
1130	printk(KERN_ERR "Illegal value %d\n", flag);
1131	return -EINVAL;
1132	}
1133	dev->se_sub_dev->se_dev_attrib.is_nonrot = flag;
1134	pr_debug("dev[%p]: SE Device is_nonrot bit: %d\n",
1135	dev, flag);
1136	return 0;
1137	}
1138
1139	int se_dev_set_emulate_rest_reord(struct se_device *dev, int flag)
1140	{
1141	if (flag != 0) {
1142	printk(KERN_ERR "dev[%p]: SE Device emulatation of restricted"
1143	" reordering not implemented\n", dev);
1144	return -ENOSYS;
1145	}
1146	dev->se_sub_dev->se_dev_attrib.emulate_rest_reord = flag;
1147	pr_debug("dev[%p]: SE Device emulate_rest_reord: %d\n", dev, flag);
1148	return 0;
1149	}
1150
1151	/*
1152	* Note, this can only be called on unexported SE Device Object.
1153	*/
1154	int se_dev_set_queue_depth(struct se_device *dev, u32 queue_depth)
1155	{
1156	if (atomic_read(&dev->dev_export_obj.obj_access_count)) {
1157	pr_err("dev[%p]: Unable to change SE Device TCQ while"
1158	" dev_export_obj: %d count exists\n", dev,
1159	atomic_read(&dev->dev_export_obj.obj_access_count));
1160	return -EINVAL;
1161	}
1162	if (!queue_depth) {
1163	pr_err("dev[%p]: Illegal ZERO value for queue"
1164	"_depth\n", dev);
1165	return -EINVAL;
1166	}
1167
1168	if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
1169	if (queue_depth > dev->se_sub_dev->se_dev_attrib.hw_queue_depth) {
1170	pr_err("dev[%p]: Passed queue_depth: %u"
1171	" exceeds TCM/SE_Device TCQ: %u\n",
1172	dev, queue_depth,
1173	dev->se_sub_dev->se_dev_attrib.hw_queue_depth);
1174	return -EINVAL;
1175	}
1176	} else {
1177	if (queue_depth > dev->se_sub_dev->se_dev_attrib.queue_depth) {
1178	if (queue_depth > dev->se_sub_dev->se_dev_attrib.hw_queue_depth) {
1179	pr_err("dev[%p]: Passed queue_depth:"
1180	" %u exceeds TCM/SE_Device MAX"
1181	" TCQ: %u\n", dev, queue_depth,
1182	dev->se_sub_dev->se_dev_attrib.hw_queue_depth);
1183	return -EINVAL;
1184	}
1185	}
1186	}
1187
1188	dev->se_sub_dev->se_dev_attrib.queue_depth = dev->queue_depth = queue_depth;
1189	pr_debug("dev[%p]: SE Device TCQ Depth changed to: %u\n",
1190	dev, queue_depth);
1191	return 0;
1192	}
1193
1194	int se_dev_set_fabric_max_sectors(struct se_device *dev, u32 fabric_max_sectors)
1195	{
1196	if (atomic_read(&dev->dev_export_obj.obj_access_count)) {
1197	pr_err("dev[%p]: Unable to change SE Device"
1198	" fabric_max_sectors while dev_export_obj: %d count exists\n",
1199	dev, atomic_read(&dev->dev_export_obj.obj_access_count));
1200	return -EINVAL;
1201	}
1202	if (!fabric_max_sectors) {
1203	pr_err("dev[%p]: Illegal ZERO value for"
1204	" fabric_max_sectors\n", dev);
1205	return -EINVAL;
1206	}
1207	if (fabric_max_sectors < DA_STATUS_MAX_SECTORS_MIN) {
1208	pr_err("dev[%p]: Passed fabric_max_sectors: %u less than"
1209	" DA_STATUS_MAX_SECTORS_MIN: %u\n", dev, fabric_max_sectors,
1210	DA_STATUS_MAX_SECTORS_MIN);
1211	return -EINVAL;
1212	}
1213	if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
1214	if (fabric_max_sectors > dev->se_sub_dev->se_dev_attrib.hw_max_sectors) {
1215	pr_err("dev[%p]: Passed fabric_max_sectors: %u"
1216	" greater than TCM/SE_Device max_sectors:"
1217	" %u\n", dev, fabric_max_sectors,
1218	dev->se_sub_dev->se_dev_attrib.hw_max_sectors);
1219	return -EINVAL;
1220	}
1221	} else {
1222	if (fabric_max_sectors > DA_STATUS_MAX_SECTORS_MAX) {
1223	pr_err("dev[%p]: Passed fabric_max_sectors: %u"
1224	" greater than DA_STATUS_MAX_SECTORS_MAX:"
1225	" %u\n", dev, fabric_max_sectors,
1226	DA_STATUS_MAX_SECTORS_MAX);
1227	return -EINVAL;
1228	}
1229	}
1230	/*
1231	* Align max_sectors down to PAGE_SIZE to follow transport_allocate_data_tasks()
1232	*/
1233	fabric_max_sectors = se_dev_align_max_sectors(fabric_max_sectors,
1234	dev->se_sub_dev->se_dev_attrib.block_size);
1235
1236	dev->se_sub_dev->se_dev_attrib.fabric_max_sectors = fabric_max_sectors;
1237	pr_debug("dev[%p]: SE Device max_sectors changed to %u\n",
1238	dev, fabric_max_sectors);
1239	return 0;
1240	}
1241
1242	int se_dev_set_optimal_sectors(struct se_device *dev, u32 optimal_sectors)
1243	{
1244	if (atomic_read(&dev->dev_export_obj.obj_access_count)) {
1245	pr_err("dev[%p]: Unable to change SE Device"
1246	" optimal_sectors while dev_export_obj: %d count exists\n",
1247	dev, atomic_read(&dev->dev_export_obj.obj_access_count));
1248	return -EINVAL;
1249	}
1250	if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
1251	pr_err("dev[%p]: Passed optimal_sectors cannot be"
1252	" changed for TCM/pSCSI\n", dev);
1253	return -EINVAL;
1254	}
1255	if (optimal_sectors > dev->se_sub_dev->se_dev_attrib.fabric_max_sectors) {
1256	pr_err("dev[%p]: Passed optimal_sectors %u cannot be"
1257	" greater than fabric_max_sectors: %u\n", dev,
1258	optimal_sectors, dev->se_sub_dev->se_dev_attrib.fabric_max_sectors);
1259	return -EINVAL;
1260	}
1261
1262	dev->se_sub_dev->se_dev_attrib.optimal_sectors = optimal_sectors;
1263	pr_debug("dev[%p]: SE Device optimal_sectors changed to %u\n",
1264	dev, optimal_sectors);
1265	return 0;
1266	}
1267
1268	int se_dev_set_block_size(struct se_device *dev, u32 block_size)
1269	{
1270	if (atomic_read(&dev->dev_export_obj.obj_access_count)) {
1271	pr_err("dev[%p]: Unable to change SE Device block_size"
1272	" while dev_export_obj: %d count exists\n", dev,
1273	atomic_read(&dev->dev_export_obj.obj_access_count));
1274	return -EINVAL;
1275	}
1276
1277	if ((block_size != 512) &&
1278	(block_size != 1024) &&
1279	(block_size != 2048) &&
1280	(block_size != 4096)) {
1281	pr_err("dev[%p]: Illegal value for block_device: %u"
1282	" for SE device, must be 512, 1024, 2048 or 4096\n",
1283	dev, block_size);
1284	return -EINVAL;
1285	}
1286
1287	if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
1288	pr_err("dev[%p]: Not allowed to change block_size for"
1289	" Physical Device, use for Linux/SCSI to change"
1290	" block_size for underlying hardware\n", dev);
1291	return -EINVAL;
1292	}
1293
1294	dev->se_sub_dev->se_dev_attrib.block_size = block_size;
1295	pr_debug("dev[%p]: SE Device block_size changed to %u\n",
1296	dev, block_size);
1297	return 0;
1298	}
1299
1300	struct se_lun *core_dev_add_lun(
1301	struct se_portal_group *tpg,
1302	struct se_device *dev,
1303	u32 lun)
1304	{
1305	struct se_lun *lun_p;
1306	int rc;
1307
1308	if (atomic_read(&dev->dev_access_obj.obj_access_count) != 0) {
1309	pr_err("Unable to export struct se_device while dev_access_obj: %d\n",
1310	atomic_read(&dev->dev_access_obj.obj_access_count));
1311	return ERR_PTR(-EACCES);
1312	}
1313
1314	lun_p = core_tpg_pre_addlun(tpg, lun);
1315	if (IS_ERR(lun_p))
1316	return lun_p;
1317
1318	rc = core_tpg_post_addlun(tpg, lun_p,
1319	TRANSPORT_LUNFLAGS_READ_WRITE, dev);
1320	if (rc < 0)
1321	return ERR_PTR(rc);
1322
1323	pr_debug("%s_TPG[%u]_LUN[%u] - Activated %s Logical Unit from"
1324	" CORE HBA: %u\n", tpg->se_tpg_tfo->get_fabric_name(),
1325	tpg->se_tpg_tfo->tpg_get_tag(tpg), lun_p->unpacked_lun,
1326	tpg->se_tpg_tfo->get_fabric_name(), dev->se_hba->hba_id);
1327	/*
1328	* Update LUN maps for dynamically added initiators when
1329	* generate_node_acl is enabled.
1330	*/
1331	if (tpg->se_tpg_tfo->tpg_check_demo_mode(tpg)) {
1332	struct se_node_acl *acl;
1333	spin_lock_irq(&tpg->acl_node_lock);
1334	list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {
1335	if (acl->dynamic_node_acl &&
1336	(!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only \|\|
1337	!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg))) {
1338	spin_unlock_irq(&tpg->acl_node_lock);
1339	core_tpg_add_node_to_devs(acl, tpg);
1340	spin_lock_irq(&tpg->acl_node_lock);
1341	}
1342	}
1343	spin_unlock_irq(&tpg->acl_node_lock);
1344	}
1345
1346	return lun_p;
1347	}
1348
1349	/* core_dev_del_lun():
1350	*
1351	*
1352	*/
1353	int core_dev_del_lun(
1354	struct se_portal_group *tpg,
1355	u32 unpacked_lun)
1356	{
1357	struct se_lun *lun;
1358
1359	lun = core_tpg_pre_dellun(tpg, unpacked_lun);
1360	if (IS_ERR(lun))
1361	return PTR_ERR(lun);
1362
1363	core_tpg_post_dellun(tpg, lun);
1364
1365	pr_debug("%s_TPG[%u]_LUN[%u] - Deactivated %s Logical Unit from"
1366	" device object\n", tpg->se_tpg_tfo->get_fabric_name(),
1367	tpg->se_tpg_tfo->tpg_get_tag(tpg), unpacked_lun,
1368	tpg->se_tpg_tfo->get_fabric_name());
1369
1370	return 0;
1371	}
1372
1373	struct se_lun core_get_lun_from_tpg(struct se_portal_group tpg, u32 unpacked_lun)
1374	{
1375	struct se_lun *lun;
1376
1377	spin_lock(&tpg->tpg_lun_lock);
1378	if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {
1379	pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS"
1380	"_PER_TPG-1: %u for Target Portal Group: %hu\n",
1381	tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
1382	TRANSPORT_MAX_LUNS_PER_TPG-1,
1383	tpg->se_tpg_tfo->tpg_get_tag(tpg));
1384	spin_unlock(&tpg->tpg_lun_lock);
1385	return NULL;
1386	}
1387	lun = tpg->tpg_lun_list[unpacked_lun];
1388
1389	if (lun->lun_status != TRANSPORT_LUN_STATUS_FREE) {
1390	pr_err("%s Logical Unit Number: %u is not free on"
1391	" Target Portal Group: %hu, ignoring request.\n",
1392	tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
1393	tpg->se_tpg_tfo->tpg_get_tag(tpg));
1394	spin_unlock(&tpg->tpg_lun_lock);
1395	return NULL;
1396	}
1397	spin_unlock(&tpg->tpg_lun_lock);
1398
1399	return lun;
1400	}
1401
1402	/* core_dev_get_lun():
1403	*
1404	*
1405	*/
1406	static struct se_lun core_dev_get_lun(struct se_portal_group tpg, u32 unpacked_lun)
1407	{
1408	struct se_lun *lun;
1409
1410	spin_lock(&tpg->tpg_lun_lock);
1411	if (unpacked_lun > (TRANSPORT_MAX_LUNS_PER_TPG-1)) {
1412	pr_err("%s LUN: %u exceeds TRANSPORT_MAX_LUNS_PER"
1413	"_TPG-1: %u for Target Portal Group: %hu\n",
1414	tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
1415	TRANSPORT_MAX_LUNS_PER_TPG-1,
1416	tpg->se_tpg_tfo->tpg_get_tag(tpg));
1417	spin_unlock(&tpg->tpg_lun_lock);
1418	return NULL;
1419	}
1420	lun = tpg->tpg_lun_list[unpacked_lun];
1421
1422	if (lun->lun_status != TRANSPORT_LUN_STATUS_ACTIVE) {
1423	pr_err("%s Logical Unit Number: %u is not active on"
1424	" Target Portal Group: %hu, ignoring request.\n",
1425	tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
1426	tpg->se_tpg_tfo->tpg_get_tag(tpg));
1427	spin_unlock(&tpg->tpg_lun_lock);
1428	return NULL;
1429	}
1430	spin_unlock(&tpg->tpg_lun_lock);
1431
1432	return lun;
1433	}
1434
1435	struct se_lun_acl *core_dev_init_initiator_node_lun_acl(
1436	struct se_portal_group *tpg,
1437	u32 mapped_lun,
1438	char *initiatorname,
1439	int *ret)
1440	{
1441	struct se_lun_acl *lacl;
1442	struct se_node_acl *nacl;
1443
1444	if (strlen(initiatorname) >= TRANSPORT_IQN_LEN) {
1445	pr_err("%s InitiatorName exceeds maximum size.\n",
1446	tpg->se_tpg_tfo->get_fabric_name());
1447	*ret = -EOVERFLOW;
1448	return NULL;
1449	}
1450	nacl = core_tpg_get_initiator_node_acl(tpg, initiatorname);
1451	if (!nacl) {
1452	*ret = -EINVAL;
1453	return NULL;
1454	}
1455	lacl = kzalloc(sizeof(struct se_lun_acl), GFP_KERNEL);
1456	if (!lacl) {
1457	pr_err("Unable to allocate memory for struct se_lun_acl.\n");
1458	*ret = -ENOMEM;
1459	return NULL;
1460	}
1461
1462	INIT_LIST_HEAD(&lacl->lacl_list);
1463	lacl->mapped_lun = mapped_lun;
1464	lacl->se_lun_nacl = nacl;
1465	snprintf(lacl->initiatorname, TRANSPORT_IQN_LEN, "%s", initiatorname);
1466
1467	return lacl;
1468	}
1469
1470	int core_dev_add_initiator_node_lun_acl(
1471	struct se_portal_group *tpg,
1472	struct se_lun_acl *lacl,
1473	u32 unpacked_lun,
1474	u32 lun_access)
1475	{
1476	struct se_lun *lun;
1477	struct se_node_acl *nacl;
1478
1479	lun = core_dev_get_lun(tpg, unpacked_lun);
1480	if (!lun) {
1481	pr_err("%s Logical Unit Number: %u is not active on"
1482	" Target Portal Group: %hu, ignoring request.\n",
1483	tpg->se_tpg_tfo->get_fabric_name(), unpacked_lun,
1484	tpg->se_tpg_tfo->tpg_get_tag(tpg));
1485	return -EINVAL;
1486	}
1487
1488	nacl = lacl->se_lun_nacl;
1489	if (!nacl)
1490	return -EINVAL;
1491
1492	if ((lun->lun_access & TRANSPORT_LUNFLAGS_READ_ONLY) &&
1493	(lun_access & TRANSPORT_LUNFLAGS_READ_WRITE))
1494	lun_access = TRANSPORT_LUNFLAGS_READ_ONLY;
1495
1496	lacl->se_lun = lun;
1497
1498	if (core_enable_device_list_for_node(lun, lacl, lacl->mapped_lun,
1499	lun_access, nacl, tpg) < 0)
1500	return -EINVAL;
1501
1502	spin_lock(&lun->lun_acl_lock);
1503	list_add_tail(&lacl->lacl_list, &lun->lun_acl_list);
1504	atomic_inc(&lun->lun_acl_count);
1505	smp_mb__after_atomic_inc();
1506	spin_unlock(&lun->lun_acl_lock);
1507
1508	pr_debug("%s_TPG[%hu]_LUN[%u->%u] - Added %s ACL for "
1509	" InitiatorNode: %s\n", tpg->se_tpg_tfo->get_fabric_name(),
1510	tpg->se_tpg_tfo->tpg_get_tag(tpg), unpacked_lun, lacl->mapped_lun,
1511	(lun_access & TRANSPORT_LUNFLAGS_READ_WRITE) ? "RW" : "RO",
1512	lacl->initiatorname);
1513	/*
1514	* Check to see if there are any existing persistent reservation APTPL
1515	* pre-registrations that need to be enabled for this LUN ACL..
1516	*/
1517	core_scsi3_check_aptpl_registration(lun->lun_se_dev, tpg, lun, lacl);
1518	return 0;
1519	}
1520
1521	/* core_dev_del_initiator_node_lun_acl():
1522	*
1523	*
1524	*/
1525	int core_dev_del_initiator_node_lun_acl(
1526	struct se_portal_group *tpg,
1527	struct se_lun *lun,
1528	struct se_lun_acl *lacl)
1529	{
1530	struct se_node_acl *nacl;
1531
1532	nacl = lacl->se_lun_nacl;
1533	if (!nacl)
1534	return -EINVAL;
1535
1536	spin_lock(&lun->lun_acl_lock);
1537	list_del(&lacl->lacl_list);
1538	atomic_dec(&lun->lun_acl_count);
1539	smp_mb__after_atomic_dec();
1540	spin_unlock(&lun->lun_acl_lock);
1541
1542	core_disable_device_list_for_node(lun, NULL, lacl->mapped_lun,
1543	TRANSPORT_LUNFLAGS_NO_ACCESS, nacl, tpg);
1544
1545	lacl->se_lun = NULL;
1546
1547	pr_debug("%s_TPG[%hu]_LUN[%u] - Removed ACL for"
1548	" InitiatorNode: %s Mapped LUN: %u\n",
1549	tpg->se_tpg_tfo->get_fabric_name(),
1550	tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
1551	lacl->initiatorname, lacl->mapped_lun);
1552
1553	return 0;
1554	}
1555
1556	void core_dev_free_initiator_node_lun_acl(
1557	struct se_portal_group *tpg,
1558	struct se_lun_acl *lacl)
1559	{
1560	pr_debug("%s_TPG[%hu] - Freeing ACL for %s InitiatorNode: %s"
1561	" Mapped LUN: %u\n", tpg->se_tpg_tfo->get_fabric_name(),
1562	tpg->se_tpg_tfo->tpg_get_tag(tpg),
1563	tpg->se_tpg_tfo->get_fabric_name(),
1564	lacl->initiatorname, lacl->mapped_lun);
1565
1566	kfree(lacl);
1567	}
1568
1569	int core_dev_setup_virtual_lun0(void)
1570	{
1571	struct se_hba *hba;
1572	struct se_device *dev;
1573	struct se_subsystem_dev *se_dev = NULL;
1574	struct se_subsystem_api *t;
1575	char buf[16];
1576	int ret;
1577
1578	hba = core_alloc_hba("rd_mcp", 0, HBA_FLAGS_INTERNAL_USE);
1579	if (IS_ERR(hba))
1580	return PTR_ERR(hba);
1581
1582	lun0_hba = hba;
1583	t = hba->transport;
1584
1585	se_dev = kzalloc(sizeof(struct se_subsystem_dev), GFP_KERNEL);
1586	if (!se_dev) {
1587	pr_err("Unable to allocate memory for"
1588	" struct se_subsystem_dev\n");
1589	ret = -ENOMEM;
1590	goto out;
1591	}
1592	INIT_LIST_HEAD(&se_dev->t10_wwn.t10_vpd_list);
1593	spin_lock_init(&se_dev->t10_wwn.t10_vpd_lock);
1594	INIT_LIST_HEAD(&se_dev->t10_pr.registration_list);
1595	INIT_LIST_HEAD(&se_dev->t10_pr.aptpl_reg_list);
1596	spin_lock_init(&se_dev->t10_pr.registration_lock);
1597	spin_lock_init(&se_dev->t10_pr.aptpl_reg_lock);
1598	INIT_LIST_HEAD(&se_dev->t10_alua.tg_pt_gps_list);
1599	spin_lock_init(&se_dev->t10_alua.tg_pt_gps_lock);
1600	spin_lock_init(&se_dev->se_dev_lock);
1601	se_dev->t10_pr.pr_aptpl_buf_len = PR_APTPL_BUF_LEN;
1602	se_dev->t10_wwn.t10_sub_dev = se_dev;
1603	se_dev->t10_alua.t10_sub_dev = se_dev;
1604	se_dev->se_dev_attrib.da_sub_dev = se_dev;
1605	se_dev->se_dev_hba = hba;
1606
1607	se_dev->se_dev_su_ptr = t->allocate_virtdevice(hba, "virt_lun0");
1608	if (!se_dev->se_dev_su_ptr) {
1609	pr_err("Unable to locate subsystem dependent pointer"
1610	" from allocate_virtdevice()\n");
1611	ret = -ENOMEM;
1612	goto out;
1613	}
1614	lun0_su_dev = se_dev;
1615
1616	memset(buf, 0, 16);
1617	sprintf(buf, "rd_pages=8");
1618	t->set_configfs_dev_params(hba, se_dev, buf, sizeof(buf));
1619
1620	dev = t->create_virtdevice(hba, se_dev, se_dev->se_dev_su_ptr);
1621	if (IS_ERR(dev)) {
1622	ret = PTR_ERR(dev);
1623	goto out;
1624	}
1625	se_dev->se_dev_ptr = dev;
1626	g_lun0_dev = dev;
1627
1628	return 0;
1629	out:
1630	lun0_su_dev = NULL;
1631	kfree(se_dev);
1632	if (lun0_hba) {
1633	core_delete_hba(lun0_hba);
1634	lun0_hba = NULL;
1635	}
1636	return ret;
1637	}
1638
1639
1640	void core_dev_release_virtual_lun0(void)
1641	{
1642	struct se_hba *hba = lun0_hba;
1643	struct se_subsystem_dev *su_dev = lun0_su_dev;
1644
1645	if (!hba)
1646	return;
1647
1648	if (g_lun0_dev)
1649	se_free_virtual_device(g_lun0_dev, hba);
1650
1651	kfree(su_dev);
1652	core_delete_hba(hba);
1653	}
1654

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/target/target_core_device.c

interactive