1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*******************************************************************************
3  * Filename:  target_core_device.c (based on iscsi_target_device.c)
4  *
5  * This file contains the TCM Virtual Device and Disk Transport
6  * agnostic related functions.
7  *
8  * (c) Copyright 2003-2013 Datera, Inc.
9  *
10  * Nicholas A. Bellinger <nab@kernel.org>
11  *
12  ******************************************************************************/
13 
14 #include <linux/net.h>
15 #include <linux/string.h>
16 #include <linux/delay.h>
17 #include <linux/timer.h>
18 #include <linux/slab.h>
19 #include <linux/spinlock.h>
20 #include <linux/kthread.h>
21 #include <linux/in.h>
22 #include <linux/export.h>
23 #include <linux/t10-pi.h>
24 #include <asm/unaligned.h>
25 #include <net/sock.h>
26 #include <net/tcp.h>
27 #include <scsi/scsi_common.h>
28 #include <scsi/scsi_proto.h>
29 
30 #include <target/target_core_base.h>
31 #include <target/target_core_backend.h>
32 #include <target/target_core_fabric.h>
33 
34 #include "target_core_internal.h"
35 #include "target_core_alua.h"
36 #include "target_core_pr.h"
37 #include "target_core_ua.h"
38 
39 static DEFINE_MUTEX(device_mutex);
40 static LIST_HEAD(device_list);
41 static DEFINE_IDR(devices_idr);
42 
43 static struct se_hba *lun0_hba;
44 /* not static, needed by tpg.c */
45 struct se_device *g_lun0_dev;
46 
47 sense_reason_t
48 transport_lookup_cmd_lun(struct se_cmd *se_cmd)
49 {
50 	struct se_lun *se_lun = NULL;
51 	struct se_session *se_sess = se_cmd->se_sess;
52 	struct se_node_acl *nacl = se_sess->se_node_acl;
53 	struct se_dev_entry *deve;
54 	sense_reason_t ret = TCM_NO_SENSE;
55 
56 	rcu_read_lock();
57 	deve = target_nacl_find_deve(nacl, se_cmd->orig_fe_lun);
58 	if (deve) {
59 		atomic_long_inc(&deve->total_cmds);
60 
61 		if (se_cmd->data_direction == DMA_TO_DEVICE)
62 			atomic_long_add(se_cmd->data_length,
63 					&deve->write_bytes);
64 		else if (se_cmd->data_direction == DMA_FROM_DEVICE)
65 			atomic_long_add(se_cmd->data_length,
66 					&deve->read_bytes);
67 
68 		if ((se_cmd->data_direction == DMA_TO_DEVICE) &&
69 		    deve->lun_access_ro) {
70 			pr_err("TARGET_CORE[%s]: Detected WRITE_PROTECTED LUN"
71 				" Access for 0x%08llx\n",
72 				se_cmd->se_tfo->fabric_name,
73 				se_cmd->orig_fe_lun);
74 			rcu_read_unlock();
75 			return TCM_WRITE_PROTECTED;
76 		}
77 
78 		se_lun = deve->se_lun;
79 
80 		if (!percpu_ref_tryget_live(&se_lun->lun_ref)) {
81 			se_lun = NULL;
82 			goto out_unlock;
83 		}
84 
85 		se_cmd->se_lun = se_lun;
86 		se_cmd->pr_res_key = deve->pr_res_key;
87 		se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;
88 		se_cmd->lun_ref_active = true;
89 	}
90 out_unlock:
91 	rcu_read_unlock();
92 
93 	if (!se_lun) {
94 		/*
95 		 * Use the se_portal_group->tpg_virt_lun0 to allow for
96 		 * REPORT_LUNS, et al to be returned when no active
97 		 * MappedLUN=0 exists for this Initiator Port.
98 		 */
99 		if (se_cmd->orig_fe_lun != 0) {
100 			pr_err("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
101 				" Access for 0x%08llx from %s\n",
102 				se_cmd->se_tfo->fabric_name,
103 				se_cmd->orig_fe_lun,
104 				nacl->initiatorname);
105 			return TCM_NON_EXISTENT_LUN;
106 		}
107 
108 		/*
109 		 * Force WRITE PROTECT for virtual LUN 0
110 		 */
111 		if ((se_cmd->data_direction != DMA_FROM_DEVICE) &&
112 		    (se_cmd->data_direction != DMA_NONE))
113 			return TCM_WRITE_PROTECTED;
114 
115 		se_lun = se_sess->se_tpg->tpg_virt_lun0;
116 		if (!percpu_ref_tryget_live(&se_lun->lun_ref))
117 			return TCM_NON_EXISTENT_LUN;
118 
119 		se_cmd->se_lun = se_sess->se_tpg->tpg_virt_lun0;
120 		se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;
121 		se_cmd->lun_ref_active = true;
122 	}
123 	/*
124 	 * RCU reference protected by percpu se_lun->lun_ref taken above that
125 	 * must drop to zero (including initial reference) before this se_lun
126 	 * pointer can be kfree_rcu() by the final se_lun->lun_group put via
127 	 * target_core_fabric_configfs.c:target_fabric_port_release
128 	 */
129 	se_cmd->se_dev = rcu_dereference_raw(se_lun->lun_se_dev);
130 	atomic_long_inc(&se_cmd->se_dev->num_cmds);
131 
132 	if (se_cmd->data_direction == DMA_TO_DEVICE)
133 		atomic_long_add(se_cmd->data_length,
134 				&se_cmd->se_dev->write_bytes);
135 	else if (se_cmd->data_direction == DMA_FROM_DEVICE)
136 		atomic_long_add(se_cmd->data_length,
137 				&se_cmd->se_dev->read_bytes);
138 
139 	return ret;
140 }
141 EXPORT_SYMBOL(transport_lookup_cmd_lun);
142 
143 int transport_lookup_tmr_lun(struct se_cmd *se_cmd)
144 {
145 	struct se_dev_entry *deve;
146 	struct se_lun *se_lun = NULL;
147 	struct se_session *se_sess = se_cmd->se_sess;
148 	struct se_node_acl *nacl = se_sess->se_node_acl;
149 	struct se_tmr_req *se_tmr = se_cmd->se_tmr_req;
150 
151 	rcu_read_lock();
152 	deve = target_nacl_find_deve(nacl, se_cmd->orig_fe_lun);
153 	if (deve) {
154 		se_lun = deve->se_lun;
155 
156 		if (!percpu_ref_tryget_live(&se_lun->lun_ref)) {
157 			se_lun = NULL;
158 			goto out_unlock;
159 		}
160 
161 		se_cmd->se_lun = se_lun;
162 		se_cmd->pr_res_key = deve->pr_res_key;
163 		se_cmd->se_cmd_flags |= SCF_SE_LUN_CMD;
164 		se_cmd->lun_ref_active = true;
165 	}
166 out_unlock:
167 	rcu_read_unlock();
168 
169 	if (!se_lun) {
170 		pr_debug("TARGET_CORE[%s]: Detected NON_EXISTENT_LUN"
171 			" Access for 0x%08llx for %s\n",
172 			se_cmd->se_tfo->fabric_name,
173 			se_cmd->orig_fe_lun,
174 			nacl->initiatorname);
175 		return -ENODEV;
176 	}
177 	se_cmd->se_dev = rcu_dereference_raw(se_lun->lun_se_dev);
178 	se_tmr->tmr_dev = rcu_dereference_raw(se_lun->lun_se_dev);
179 
180 	return 0;
181 }
182 EXPORT_SYMBOL(transport_lookup_tmr_lun);
183 
184 bool target_lun_is_rdonly(struct se_cmd *cmd)
185 {
186 	struct se_session *se_sess = cmd->se_sess;
187 	struct se_dev_entry *deve;
188 	bool ret;
189 
190 	rcu_read_lock();
191 	deve = target_nacl_find_deve(se_sess->se_node_acl, cmd->orig_fe_lun);
192 	ret = deve && deve->lun_access_ro;
193 	rcu_read_unlock();
194 
195 	return ret;
196 }
197 EXPORT_SYMBOL(target_lun_is_rdonly);
198 
199 /*
200  * This function is called from core_scsi3_emulate_pro_register_and_move()
201  * and core_scsi3_decode_spec_i_port(), and will increment &deve->pr_kref
202  * when a matching rtpi is found.
203  */
204 struct se_dev_entry *core_get_se_deve_from_rtpi(
205 	struct se_node_acl *nacl,
206 	u16 rtpi)
207 {
208 	struct se_dev_entry *deve;
209 	struct se_lun *lun;
210 	struct se_portal_group *tpg = nacl->se_tpg;
211 
212 	rcu_read_lock();
213 	hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) {
214 		lun = deve->se_lun;
215 		if (!lun) {
216 			pr_err("%s device entries device pointer is"
217 				" NULL, but Initiator has access.\n",
218 				tpg->se_tpg_tfo->fabric_name);
219 			continue;
220 		}
221 		if (lun->lun_tpg->tpg_rtpi != rtpi)
222 			continue;
223 
224 		kref_get(&deve->pr_kref);
225 		rcu_read_unlock();
226 
227 		return deve;
228 	}
229 	rcu_read_unlock();
230 
231 	return NULL;
232 }
233 
234 void core_free_device_list_for_node(
235 	struct se_node_acl *nacl,
236 	struct se_portal_group *tpg)
237 {
238 	struct se_dev_entry *deve;
239 
240 	mutex_lock(&nacl->lun_entry_mutex);
241 	hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link)
242 		core_disable_device_list_for_node(deve->se_lun, deve, nacl, tpg);
243 	mutex_unlock(&nacl->lun_entry_mutex);
244 }
245 
246 void core_update_device_list_access(
247 	u64 mapped_lun,
248 	bool lun_access_ro,
249 	struct se_node_acl *nacl)
250 {
251 	struct se_dev_entry *deve;
252 
253 	mutex_lock(&nacl->lun_entry_mutex);
254 	deve = target_nacl_find_deve(nacl, mapped_lun);
255 	if (deve)
256 		deve->lun_access_ro = lun_access_ro;
257 	mutex_unlock(&nacl->lun_entry_mutex);
258 }
259 
260 /*
261  * Called with rcu_read_lock or nacl->device_list_lock held.
262  */
263 struct se_dev_entry *target_nacl_find_deve(struct se_node_acl *nacl, u64 mapped_lun)
264 {
265 	struct se_dev_entry *deve;
266 
267 	hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link)
268 		if (deve->mapped_lun == mapped_lun)
269 			return deve;
270 
271 	return NULL;
272 }
273 EXPORT_SYMBOL(target_nacl_find_deve);
274 
275 void target_pr_kref_release(struct kref *kref)
276 {
277 	struct se_dev_entry *deve = container_of(kref, struct se_dev_entry,
278 						 pr_kref);
279 	complete(&deve->pr_comp);
280 }
281 
282 /*
283  * Establish UA condition on SCSI device - all LUNs
284  */
285 void target_dev_ua_allocate(struct se_device *dev, u8 asc, u8 ascq)
286 {
287 	struct se_dev_entry *se_deve;
288 	struct se_lun *lun;
289 
290 	spin_lock(&dev->se_port_lock);
291 	list_for_each_entry(lun, &dev->dev_sep_list, lun_dev_link) {
292 
293 		spin_lock(&lun->lun_deve_lock);
294 		list_for_each_entry(se_deve, &lun->lun_deve_list, lun_link)
295 			core_scsi3_ua_allocate(se_deve, asc, ascq);
296 		spin_unlock(&lun->lun_deve_lock);
297 	}
298 	spin_unlock(&dev->se_port_lock);
299 }
300 
301 static void
302 target_luns_data_has_changed(struct se_node_acl *nacl, struct se_dev_entry *new,
303 			     bool skip_new)
304 {
305 	struct se_dev_entry *tmp;
306 
307 	rcu_read_lock();
308 	hlist_for_each_entry_rcu(tmp, &nacl->lun_entry_hlist, link) {
309 		if (skip_new && tmp == new)
310 			continue;
311 		core_scsi3_ua_allocate(tmp, 0x3F,
312 				       ASCQ_3FH_REPORTED_LUNS_DATA_HAS_CHANGED);
313 	}
314 	rcu_read_unlock();
315 }
316 
317 int core_enable_device_list_for_node(
318 	struct se_lun *lun,
319 	struct se_lun_acl *lun_acl,
320 	u64 mapped_lun,
321 	bool lun_access_ro,
322 	struct se_node_acl *nacl,
323 	struct se_portal_group *tpg)
324 {
325 	struct se_dev_entry *orig, *new;
326 
327 	new = kzalloc(sizeof(*new), GFP_KERNEL);
328 	if (!new) {
329 		pr_err("Unable to allocate se_dev_entry memory\n");
330 		return -ENOMEM;
331 	}
332 
333 	spin_lock_init(&new->ua_lock);
334 	INIT_LIST_HEAD(&new->ua_list);
335 	INIT_LIST_HEAD(&new->lun_link);
336 
337 	new->mapped_lun = mapped_lun;
338 	kref_init(&new->pr_kref);
339 	init_completion(&new->pr_comp);
340 
341 	new->lun_access_ro = lun_access_ro;
342 	new->creation_time = get_jiffies_64();
343 	new->attach_count++;
344 
345 	mutex_lock(&nacl->lun_entry_mutex);
346 	orig = target_nacl_find_deve(nacl, mapped_lun);
347 	if (orig && orig->se_lun) {
348 		struct se_lun *orig_lun = orig->se_lun;
349 
350 		if (orig_lun != lun) {
351 			pr_err("Existing orig->se_lun doesn't match new lun"
352 			       " for dynamic -> explicit NodeACL conversion:"
353 				" %s\n", nacl->initiatorname);
354 			mutex_unlock(&nacl->lun_entry_mutex);
355 			kfree(new);
356 			return -EINVAL;
357 		}
358 		if (orig->se_lun_acl != NULL) {
359 			pr_warn_ratelimited("Detected existing explicit"
360 				" se_lun_acl->se_lun_group reference for %s"
361 				" mapped_lun: %llu, failing\n",
362 				 nacl->initiatorname, mapped_lun);
363 			mutex_unlock(&nacl->lun_entry_mutex);
364 			kfree(new);
365 			return -EINVAL;
366 		}
367 
368 		new->se_lun = lun;
369 		new->se_lun_acl = lun_acl;
370 		hlist_del_rcu(&orig->link);
371 		hlist_add_head_rcu(&new->link, &nacl->lun_entry_hlist);
372 		mutex_unlock(&nacl->lun_entry_mutex);
373 
374 		spin_lock(&lun->lun_deve_lock);
375 		list_del(&orig->lun_link);
376 		list_add_tail(&new->lun_link, &lun->lun_deve_list);
377 		spin_unlock(&lun->lun_deve_lock);
378 
379 		kref_put(&orig->pr_kref, target_pr_kref_release);
380 		wait_for_completion(&orig->pr_comp);
381 
382 		target_luns_data_has_changed(nacl, new, true);
383 		kfree_rcu(orig, rcu_head);
384 		return 0;
385 	}
386 
387 	new->se_lun = lun;
388 	new->se_lun_acl = lun_acl;
389 	hlist_add_head_rcu(&new->link, &nacl->lun_entry_hlist);
390 	mutex_unlock(&nacl->lun_entry_mutex);
391 
392 	spin_lock(&lun->lun_deve_lock);
393 	list_add_tail(&new->lun_link, &lun->lun_deve_list);
394 	spin_unlock(&lun->lun_deve_lock);
395 
396 	target_luns_data_has_changed(nacl, new, true);
397 	return 0;
398 }
399 
400 void core_disable_device_list_for_node(
401 	struct se_lun *lun,
402 	struct se_dev_entry *orig,
403 	struct se_node_acl *nacl,
404 	struct se_portal_group *tpg)
405 {
406 	/*
407 	 * rcu_dereference_raw protected by se_lun->lun_group symlink
408 	 * reference to se_device->dev_group.
409 	 */
410 	struct se_device *dev = rcu_dereference_raw(lun->lun_se_dev);
411 
412 	lockdep_assert_held(&nacl->lun_entry_mutex);
413 
414 	/*
415 	 * If the MappedLUN entry is being disabled, the entry in
416 	 * lun->lun_deve_list must be removed now before clearing the
417 	 * struct se_dev_entry pointers below as logic in
418 	 * core_alua_do_transition_tg_pt() depends on these being present.
419 	 *
420 	 * deve->se_lun_acl will be NULL for demo-mode created LUNs
421 	 * that have not been explicitly converted to MappedLUNs ->
422 	 * struct se_lun_acl, but we remove deve->lun_link from
423 	 * lun->lun_deve_list. This also means that active UAs and
424 	 * NodeACL context specific PR metadata for demo-mode
425 	 * MappedLUN *deve will be released below..
426 	 */
427 	spin_lock(&lun->lun_deve_lock);
428 	list_del(&orig->lun_link);
429 	spin_unlock(&lun->lun_deve_lock);
430 	/*
431 	 * Disable struct se_dev_entry LUN ACL mapping
432 	 */
433 	core_scsi3_ua_release_all(orig);
434 
435 	hlist_del_rcu(&orig->link);
436 	clear_bit(DEF_PR_REG_ACTIVE, &orig->deve_flags);
437 	orig->lun_access_ro = false;
438 	orig->creation_time = 0;
439 	orig->attach_count--;
440 	/*
441 	 * Before firing off RCU callback, wait for any in process SPEC_I_PT=1
442 	 * or REGISTER_AND_MOVE PR operation to complete.
443 	 */
444 	kref_put(&orig->pr_kref, target_pr_kref_release);
445 	wait_for_completion(&orig->pr_comp);
446 
447 	kfree_rcu(orig, rcu_head);
448 
449 	core_scsi3_free_pr_reg_from_nacl(dev, nacl);
450 	target_luns_data_has_changed(nacl, NULL, false);
451 }
452 
453 /*      core_clear_lun_from_tpg():
454  *
455  *
456  */
457 void core_clear_lun_from_tpg(struct se_lun *lun, struct se_portal_group *tpg)
458 {
459 	struct se_node_acl *nacl;
460 	struct se_dev_entry *deve;
461 
462 	mutex_lock(&tpg->acl_node_mutex);
463 	list_for_each_entry(nacl, &tpg->acl_node_list, acl_list) {
464 
465 		mutex_lock(&nacl->lun_entry_mutex);
466 		hlist_for_each_entry_rcu(deve, &nacl->lun_entry_hlist, link) {
467 			if (lun != deve->se_lun)
468 				continue;
469 
470 			core_disable_device_list_for_node(lun, deve, nacl, tpg);
471 		}
472 		mutex_unlock(&nacl->lun_entry_mutex);
473 	}
474 	mutex_unlock(&tpg->acl_node_mutex);
475 }
476 
477 static void se_release_vpd_for_dev(struct se_device *dev)
478 {
479 	struct t10_vpd *vpd, *vpd_tmp;
480 
481 	spin_lock(&dev->t10_wwn.t10_vpd_lock);
482 	list_for_each_entry_safe(vpd, vpd_tmp,
483 			&dev->t10_wwn.t10_vpd_list, vpd_list) {
484 		list_del(&vpd->vpd_list);
485 		kfree(vpd);
486 	}
487 	spin_unlock(&dev->t10_wwn.t10_vpd_lock);
488 }
489 
490 static u32 se_dev_align_max_sectors(u32 max_sectors, u32 block_size)
491 {
492 	u32 aligned_max_sectors;
493 	u32 alignment;
494 	/*
495 	 * Limit max_sectors to a PAGE_SIZE aligned value for modern
496 	 * transport_allocate_data_tasks() operation.
497 	 */
498 	alignment = max(1ul, PAGE_SIZE / block_size);
499 	aligned_max_sectors = rounddown(max_sectors, alignment);
500 
501 	if (max_sectors != aligned_max_sectors)
502 		pr_info("Rounding down aligned max_sectors from %u to %u\n",
503 			max_sectors, aligned_max_sectors);
504 
505 	return aligned_max_sectors;
506 }
507 
508 int core_dev_add_lun(
509 	struct se_portal_group *tpg,
510 	struct se_device *dev,
511 	struct se_lun *lun)
512 {
513 	int rc;
514 
515 	rc = core_tpg_add_lun(tpg, lun, false, dev);
516 	if (rc < 0)
517 		return rc;
518 
519 	pr_debug("%s_TPG[%u]_LUN[%llu] - Activated %s Logical Unit from"
520 		" CORE HBA: %u\n", tpg->se_tpg_tfo->fabric_name,
521 		tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
522 		tpg->se_tpg_tfo->fabric_name, dev->se_hba->hba_id);
523 	/*
524 	 * Update LUN maps for dynamically added initiators when
525 	 * generate_node_acl is enabled.
526 	 */
527 	if (tpg->se_tpg_tfo->tpg_check_demo_mode(tpg)) {
528 		struct se_node_acl *acl;
529 
530 		mutex_lock(&tpg->acl_node_mutex);
531 		list_for_each_entry(acl, &tpg->acl_node_list, acl_list) {
532 			if (acl->dynamic_node_acl &&
533 			    (!tpg->se_tpg_tfo->tpg_check_demo_mode_login_only ||
534 			     !tpg->se_tpg_tfo->tpg_check_demo_mode_login_only(tpg))) {
535 				core_tpg_add_node_to_devs(acl, tpg, lun);
536 			}
537 		}
538 		mutex_unlock(&tpg->acl_node_mutex);
539 	}
540 
541 	return 0;
542 }
543 
544 /*      core_dev_del_lun():
545  *
546  *
547  */
548 void core_dev_del_lun(
549 	struct se_portal_group *tpg,
550 	struct se_lun *lun)
551 {
552 	pr_debug("%s_TPG[%u]_LUN[%llu] - Deactivating %s Logical Unit from"
553 		" device object\n", tpg->se_tpg_tfo->fabric_name,
554 		tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
555 		tpg->se_tpg_tfo->fabric_name);
556 
557 	core_tpg_remove_lun(tpg, lun);
558 }
559 
560 struct se_lun_acl *core_dev_init_initiator_node_lun_acl(
561 	struct se_portal_group *tpg,
562 	struct se_node_acl *nacl,
563 	u64 mapped_lun,
564 	int *ret)
565 {
566 	struct se_lun_acl *lacl;
567 
568 	if (strlen(nacl->initiatorname) >= TRANSPORT_IQN_LEN) {
569 		pr_err("%s InitiatorName exceeds maximum size.\n",
570 			tpg->se_tpg_tfo->fabric_name);
571 		*ret = -EOVERFLOW;
572 		return NULL;
573 	}
574 	lacl = kzalloc(sizeof(struct se_lun_acl), GFP_KERNEL);
575 	if (!lacl) {
576 		pr_err("Unable to allocate memory for struct se_lun_acl.\n");
577 		*ret = -ENOMEM;
578 		return NULL;
579 	}
580 
581 	lacl->mapped_lun = mapped_lun;
582 	lacl->se_lun_nacl = nacl;
583 
584 	return lacl;
585 }
586 
587 int core_dev_add_initiator_node_lun_acl(
588 	struct se_portal_group *tpg,
589 	struct se_lun_acl *lacl,
590 	struct se_lun *lun,
591 	bool lun_access_ro)
592 {
593 	struct se_node_acl *nacl = lacl->se_lun_nacl;
594 	/*
595 	 * rcu_dereference_raw protected by se_lun->lun_group symlink
596 	 * reference to se_device->dev_group.
597 	 */
598 	struct se_device *dev = rcu_dereference_raw(lun->lun_se_dev);
599 
600 	if (!nacl)
601 		return -EINVAL;
602 
603 	if (lun->lun_access_ro)
604 		lun_access_ro = true;
605 
606 	lacl->se_lun = lun;
607 
608 	if (core_enable_device_list_for_node(lun, lacl, lacl->mapped_lun,
609 			lun_access_ro, nacl, tpg) < 0)
610 		return -EINVAL;
611 
612 	pr_debug("%s_TPG[%hu]_LUN[%llu->%llu] - Added %s ACL for "
613 		" InitiatorNode: %s\n", tpg->se_tpg_tfo->fabric_name,
614 		tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun, lacl->mapped_lun,
615 		lun_access_ro ? "RO" : "RW",
616 		nacl->initiatorname);
617 	/*
618 	 * Check to see if there are any existing persistent reservation APTPL
619 	 * pre-registrations that need to be enabled for this LUN ACL..
620 	 */
621 	core_scsi3_check_aptpl_registration(dev, tpg, lun, nacl,
622 					    lacl->mapped_lun);
623 	return 0;
624 }
625 
626 int core_dev_del_initiator_node_lun_acl(
627 	struct se_lun *lun,
628 	struct se_lun_acl *lacl)
629 {
630 	struct se_portal_group *tpg = lun->lun_tpg;
631 	struct se_node_acl *nacl;
632 	struct se_dev_entry *deve;
633 
634 	nacl = lacl->se_lun_nacl;
635 	if (!nacl)
636 		return -EINVAL;
637 
638 	mutex_lock(&nacl->lun_entry_mutex);
639 	deve = target_nacl_find_deve(nacl, lacl->mapped_lun);
640 	if (deve)
641 		core_disable_device_list_for_node(lun, deve, nacl, tpg);
642 	mutex_unlock(&nacl->lun_entry_mutex);
643 
644 	pr_debug("%s_TPG[%hu]_LUN[%llu] - Removed ACL for"
645 		" InitiatorNode: %s Mapped LUN: %llu\n",
646 		tpg->se_tpg_tfo->fabric_name,
647 		tpg->se_tpg_tfo->tpg_get_tag(tpg), lun->unpacked_lun,
648 		nacl->initiatorname, lacl->mapped_lun);
649 
650 	return 0;
651 }
652 
653 void core_dev_free_initiator_node_lun_acl(
654 	struct se_portal_group *tpg,
655 	struct se_lun_acl *lacl)
656 {
657 	pr_debug("%s_TPG[%hu] - Freeing ACL for %s InitiatorNode: %s"
658 		" Mapped LUN: %llu\n", tpg->se_tpg_tfo->fabric_name,
659 		tpg->se_tpg_tfo->tpg_get_tag(tpg),
660 		tpg->se_tpg_tfo->fabric_name,
661 		lacl->se_lun_nacl->initiatorname, lacl->mapped_lun);
662 
663 	kfree(lacl);
664 }
665 
666 static void scsi_dump_inquiry(struct se_device *dev)
667 {
668 	struct t10_wwn *wwn = &dev->t10_wwn;
669 	int device_type = dev->transport->get_device_type(dev);
670 
671 	/*
672 	 * Print Linux/SCSI style INQUIRY formatting to the kernel ring buffer
673 	 */
674 	pr_debug("  Vendor: %-" __stringify(INQUIRY_VENDOR_LEN) "s\n",
675 		wwn->vendor);
676 	pr_debug("  Model: %-" __stringify(INQUIRY_MODEL_LEN) "s\n",
677 		wwn->model);
678 	pr_debug("  Revision: %-" __stringify(INQUIRY_REVISION_LEN) "s\n",
679 		wwn->revision);
680 	pr_debug("  Type:   %s ", scsi_device_type(device_type));
681 }
682 
683 struct se_device *target_alloc_device(struct se_hba *hba, const char *name)
684 {
685 	struct se_device *dev;
686 	struct se_lun *xcopy_lun;
687 	int i;
688 
689 	dev = hba->backend->ops->alloc_device(hba, name);
690 	if (!dev)
691 		return NULL;
692 
693 	dev->queues = kcalloc(nr_cpu_ids, sizeof(*dev->queues), GFP_KERNEL);
694 	if (!dev->queues) {
695 		dev->transport->free_device(dev);
696 		return NULL;
697 	}
698 
699 	dev->queue_cnt = nr_cpu_ids;
700 	for (i = 0; i < dev->queue_cnt; i++) {
701 		struct se_device_queue *q;
702 
703 		q = &dev->queues[i];
704 		INIT_LIST_HEAD(&q->state_list);
705 		spin_lock_init(&q->lock);
706 
707 		init_llist_head(&q->sq.cmd_list);
708 		INIT_WORK(&q->sq.work, target_queued_submit_work);
709 	}
710 
711 	dev->se_hba = hba;
712 	dev->transport = hba->backend->ops;
713 	dev->transport_flags = dev->transport->transport_flags_default;
714 	dev->prot_length = sizeof(struct t10_pi_tuple);
715 	dev->hba_index = hba->hba_index;
716 
717 	INIT_LIST_HEAD(&dev->dev_sep_list);
718 	INIT_LIST_HEAD(&dev->dev_tmr_list);
719 	INIT_LIST_HEAD(&dev->delayed_cmd_list);
720 	INIT_LIST_HEAD(&dev->qf_cmd_list);
721 	spin_lock_init(&dev->delayed_cmd_lock);
722 	spin_lock_init(&dev->dev_reservation_lock);
723 	spin_lock_init(&dev->se_port_lock);
724 	spin_lock_init(&dev->se_tmr_lock);
725 	spin_lock_init(&dev->qf_cmd_lock);
726 	sema_init(&dev->caw_sem, 1);
727 	INIT_LIST_HEAD(&dev->t10_wwn.t10_vpd_list);
728 	spin_lock_init(&dev->t10_wwn.t10_vpd_lock);
729 	INIT_LIST_HEAD(&dev->t10_pr.registration_list);
730 	INIT_LIST_HEAD(&dev->t10_pr.aptpl_reg_list);
731 	spin_lock_init(&dev->t10_pr.registration_lock);
732 	spin_lock_init(&dev->t10_pr.aptpl_reg_lock);
733 	INIT_LIST_HEAD(&dev->t10_alua.tg_pt_gps_list);
734 	spin_lock_init(&dev->t10_alua.tg_pt_gps_lock);
735 	INIT_LIST_HEAD(&dev->t10_alua.lba_map_list);
736 	spin_lock_init(&dev->t10_alua.lba_map_lock);
737 
738 	INIT_WORK(&dev->delayed_cmd_work, target_do_delayed_work);
739 	mutex_init(&dev->lun_reset_mutex);
740 
741 	dev->t10_wwn.t10_dev = dev;
742 	/*
743 	 * Use OpenFabrics IEEE Company ID: 00 14 05
744 	 */
745 	dev->t10_wwn.company_id = 0x001405;
746 
747 	dev->t10_alua.t10_dev = dev;
748 
749 	dev->dev_attrib.da_dev = dev;
750 	dev->dev_attrib.emulate_model_alias = DA_EMULATE_MODEL_ALIAS;
751 	dev->dev_attrib.emulate_dpo = 1;
752 	dev->dev_attrib.emulate_fua_write = 1;
753 	dev->dev_attrib.emulate_fua_read = 1;
754 	dev->dev_attrib.emulate_write_cache = DA_EMULATE_WRITE_CACHE;
755 	dev->dev_attrib.emulate_ua_intlck_ctrl = TARGET_UA_INTLCK_CTRL_CLEAR;
756 	dev->dev_attrib.emulate_tas = DA_EMULATE_TAS;
757 	dev->dev_attrib.emulate_tpu = DA_EMULATE_TPU;
758 	dev->dev_attrib.emulate_tpws = DA_EMULATE_TPWS;
759 	dev->dev_attrib.emulate_caw = DA_EMULATE_CAW;
760 	dev->dev_attrib.emulate_3pc = DA_EMULATE_3PC;
761 	dev->dev_attrib.emulate_pr = DA_EMULATE_PR;
762 	dev->dev_attrib.emulate_rsoc = DA_EMULATE_RSOC;
763 	dev->dev_attrib.pi_prot_type = TARGET_DIF_TYPE0_PROT;
764 	dev->dev_attrib.enforce_pr_isids = DA_ENFORCE_PR_ISIDS;
765 	dev->dev_attrib.force_pr_aptpl = DA_FORCE_PR_APTPL;
766 	dev->dev_attrib.is_nonrot = DA_IS_NONROT;
767 	dev->dev_attrib.emulate_rest_reord = DA_EMULATE_REST_REORD;
768 	dev->dev_attrib.max_unmap_lba_count = DA_MAX_UNMAP_LBA_COUNT;
769 	dev->dev_attrib.max_unmap_block_desc_count =
770 		DA_MAX_UNMAP_BLOCK_DESC_COUNT;
771 	dev->dev_attrib.unmap_granularity = DA_UNMAP_GRANULARITY_DEFAULT;
772 	dev->dev_attrib.unmap_granularity_alignment =
773 				DA_UNMAP_GRANULARITY_ALIGNMENT_DEFAULT;
774 	dev->dev_attrib.unmap_zeroes_data =
775 				DA_UNMAP_ZEROES_DATA_DEFAULT;
776 	dev->dev_attrib.max_write_same_len = DA_MAX_WRITE_SAME_LEN;
777 
778 	xcopy_lun = &dev->xcopy_lun;
779 	rcu_assign_pointer(xcopy_lun->lun_se_dev, dev);
780 	init_completion(&xcopy_lun->lun_shutdown_comp);
781 	INIT_LIST_HEAD(&xcopy_lun->lun_deve_list);
782 	INIT_LIST_HEAD(&xcopy_lun->lun_dev_link);
783 	mutex_init(&xcopy_lun->lun_tg_pt_md_mutex);
784 	xcopy_lun->lun_tpg = &xcopy_pt_tpg;
785 
786 	/* Preload the default INQUIRY const values */
787 	strscpy(dev->t10_wwn.vendor, "LIO-ORG", sizeof(dev->t10_wwn.vendor));
788 	strscpy(dev->t10_wwn.model, dev->transport->inquiry_prod,
789 		sizeof(dev->t10_wwn.model));
790 	strscpy(dev->t10_wwn.revision, dev->transport->inquiry_rev,
791 		sizeof(dev->t10_wwn.revision));
792 
793 	return dev;
794 }
795 
796 /*
797  * Check if the underlying struct block_device supports discard and if yes
798  * configure the UNMAP parameters.
799  */
800 bool target_configure_unmap_from_queue(struct se_dev_attrib *attrib,
801 				       struct block_device *bdev)
802 {
803 	int block_size = bdev_logical_block_size(bdev);
804 
805 	if (!bdev_max_discard_sectors(bdev))
806 		return false;
807 
808 	attrib->max_unmap_lba_count =
809 		bdev_max_discard_sectors(bdev) >> (ilog2(block_size) - 9);
810 	/*
811 	 * Currently hardcoded to 1 in Linux/SCSI code..
812 	 */
813 	attrib->max_unmap_block_desc_count = 1;
814 	attrib->unmap_granularity = bdev_discard_granularity(bdev) / block_size;
815 	attrib->unmap_granularity_alignment =
816 		bdev_discard_alignment(bdev) / block_size;
817 	return true;
818 }
819 EXPORT_SYMBOL(target_configure_unmap_from_queue);
820 
821 /*
822  * Convert from blocksize advertised to the initiator to the 512 byte
823  * units unconditionally used by the Linux block layer.
824  */
825 sector_t target_to_linux_sector(struct se_device *dev, sector_t lb)
826 {
827 	switch (dev->dev_attrib.block_size) {
828 	case 4096:
829 		return lb << 3;
830 	case 2048:
831 		return lb << 2;
832 	case 1024:
833 		return lb << 1;
834 	default:
835 		return lb;
836 	}
837 }
838 EXPORT_SYMBOL(target_to_linux_sector);
839 
840 struct devices_idr_iter {
841 	int (*fn)(struct se_device *dev, void *data);
842 	void *data;
843 };
844 
845 static int target_devices_idr_iter(int id, void *p, void *data)
846 	 __must_hold(&device_mutex)
847 {
848 	struct devices_idr_iter *iter = data;
849 	struct se_device *dev = p;
850 	struct config_item *item;
851 	int ret;
852 
853 	/*
854 	 * We add the device early to the idr, so it can be used
855 	 * by backend modules during configuration. We do not want
856 	 * to allow other callers to access partially setup devices,
857 	 * so we skip them here.
858 	 */
859 	if (!target_dev_configured(dev))
860 		return 0;
861 
862 	item = config_item_get_unless_zero(&dev->dev_group.cg_item);
863 	if (!item)
864 		return 0;
865 	mutex_unlock(&device_mutex);
866 
867 	ret = iter->fn(dev, iter->data);
868 	config_item_put(item);
869 
870 	mutex_lock(&device_mutex);
871 	return ret;
872 }
873 
874 /**
875  * target_for_each_device - iterate over configured devices
876  * @fn: iterator function
877  * @data: pointer to data that will be passed to fn
878  *
879  * fn must return 0 to continue looping over devices. non-zero will break
880  * from the loop and return that value to the caller.
881  */
882 int target_for_each_device(int (*fn)(struct se_device *dev, void *data),
883 			   void *data)
884 {
885 	struct devices_idr_iter iter = { .fn = fn, .data = data };
886 	int ret;
887 
888 	mutex_lock(&device_mutex);
889 	ret = idr_for_each(&devices_idr, target_devices_idr_iter, &iter);
890 	mutex_unlock(&device_mutex);
891 	return ret;
892 }
893 
894 int target_configure_device(struct se_device *dev)
895 {
896 	struct se_hba *hba = dev->se_hba;
897 	int ret, id;
898 
899 	if (target_dev_configured(dev)) {
900 		pr_err("se_dev->se_dev_ptr already set for storage"
901 				" object\n");
902 		return -EEXIST;
903 	}
904 
905 	/*
906 	 * Add early so modules like tcmu can use during its
907 	 * configuration.
908 	 */
909 	mutex_lock(&device_mutex);
910 	/*
911 	 * Use cyclic to try and avoid collisions with devices
912 	 * that were recently removed.
913 	 */
914 	id = idr_alloc_cyclic(&devices_idr, dev, 0, INT_MAX, GFP_KERNEL);
915 	mutex_unlock(&device_mutex);
916 	if (id < 0) {
917 		ret = -ENOMEM;
918 		goto out;
919 	}
920 	dev->dev_index = id;
921 
922 	ret = dev->transport->configure_device(dev);
923 	if (ret)
924 		goto out_free_index;
925 
926 	if (dev->transport->configure_unmap &&
927 	    dev->transport->configure_unmap(dev)) {
928 		pr_debug("Discard support available, but disabled by default.\n");
929 	}
930 
931 	/*
932 	 * XXX: there is not much point to have two different values here..
933 	 */
934 	dev->dev_attrib.block_size = dev->dev_attrib.hw_block_size;
935 	dev->dev_attrib.queue_depth = dev->dev_attrib.hw_queue_depth;
936 
937 	/*
938 	 * Align max_hw_sectors down to PAGE_SIZE I/O transfers
939 	 */
940 	dev->dev_attrib.hw_max_sectors =
941 		se_dev_align_max_sectors(dev->dev_attrib.hw_max_sectors,
942 					 dev->dev_attrib.hw_block_size);
943 	dev->dev_attrib.optimal_sectors = dev->dev_attrib.hw_max_sectors;
944 
945 	dev->creation_time = get_jiffies_64();
946 
947 	ret = core_setup_alua(dev);
948 	if (ret)
949 		goto out_destroy_device;
950 
951 	/*
952 	 * Setup work_queue for QUEUE_FULL
953 	 */
954 	INIT_WORK(&dev->qf_work_queue, target_qf_do_work);
955 
956 	scsi_dump_inquiry(dev);
957 
958 	spin_lock(&hba->device_lock);
959 	hba->dev_count++;
960 	spin_unlock(&hba->device_lock);
961 
962 	dev->dev_flags |= DF_CONFIGURED;
963 
964 	return 0;
965 
966 out_destroy_device:
967 	dev->transport->destroy_device(dev);
968 out_free_index:
969 	mutex_lock(&device_mutex);
970 	idr_remove(&devices_idr, dev->dev_index);
971 	mutex_unlock(&device_mutex);
972 out:
973 	se_release_vpd_for_dev(dev);
974 	return ret;
975 }
976 
977 void target_free_device(struct se_device *dev)
978 {
979 	struct se_hba *hba = dev->se_hba;
980 
981 	WARN_ON(!list_empty(&dev->dev_sep_list));
982 
983 	if (target_dev_configured(dev)) {
984 		dev->transport->destroy_device(dev);
985 
986 		mutex_lock(&device_mutex);
987 		idr_remove(&devices_idr, dev->dev_index);
988 		mutex_unlock(&device_mutex);
989 
990 		spin_lock(&hba->device_lock);
991 		hba->dev_count--;
992 		spin_unlock(&hba->device_lock);
993 	}
994 
995 	core_alua_free_lu_gp_mem(dev);
996 	core_alua_set_lba_map(dev, NULL, 0, 0);
997 	core_scsi3_free_all_registrations(dev);
998 	se_release_vpd_for_dev(dev);
999 
1000 	if (dev->transport->free_prot)
1001 		dev->transport->free_prot(dev);
1002 
1003 	kfree(dev->queues);
1004 	dev->transport->free_device(dev);
1005 }
1006 
1007 int core_dev_setup_virtual_lun0(void)
1008 {
1009 	struct se_hba *hba;
1010 	struct se_device *dev;
1011 	char buf[] = "rd_pages=8,rd_nullio=1,rd_dummy=1";
1012 	int ret;
1013 
1014 	hba = core_alloc_hba("rd_mcp", 0, HBA_FLAGS_INTERNAL_USE);
1015 	if (IS_ERR(hba))
1016 		return PTR_ERR(hba);
1017 
1018 	dev = target_alloc_device(hba, "virt_lun0");
1019 	if (!dev) {
1020 		ret = -ENOMEM;
1021 		goto out_free_hba;
1022 	}
1023 
1024 	hba->backend->ops->set_configfs_dev_params(dev, buf, sizeof(buf));
1025 
1026 	ret = target_configure_device(dev);
1027 	if (ret)
1028 		goto out_free_se_dev;
1029 
1030 	lun0_hba = hba;
1031 	g_lun0_dev = dev;
1032 	return 0;
1033 
1034 out_free_se_dev:
1035 	target_free_device(dev);
1036 out_free_hba:
1037 	core_delete_hba(hba);
1038 	return ret;
1039 }
1040 
1041 
1042 void core_dev_release_virtual_lun0(void)
1043 {
1044 	struct se_hba *hba = lun0_hba;
1045 
1046 	if (!hba)
1047 		return;
1048 
1049 	if (g_lun0_dev)
1050 		target_free_device(g_lun0_dev);
1051 	core_delete_hba(hba);
1052 }
1053 
1054 /*
1055  * Common CDB parsing for kernel and user passthrough.
1056  */
1057 sense_reason_t
1058 passthrough_parse_cdb(struct se_cmd *cmd,
1059 	sense_reason_t (*exec_cmd)(struct se_cmd *cmd))
1060 {
1061 	unsigned char *cdb = cmd->t_task_cdb;
1062 	struct se_device *dev = cmd->se_dev;
1063 	unsigned int size;
1064 
1065 	/*
1066 	 * For REPORT LUNS we always need to emulate the response, for everything
1067 	 * else, pass it up.
1068 	 */
1069 	if (cdb[0] == REPORT_LUNS) {
1070 		cmd->execute_cmd = spc_emulate_report_luns;
1071 		return TCM_NO_SENSE;
1072 	}
1073 
1074 	/*
1075 	 * With emulate_pr disabled, all reservation requests should fail,
1076 	 * regardless of whether or not TRANSPORT_FLAG_PASSTHROUGH_PGR is set.
1077 	 */
1078 	if (!dev->dev_attrib.emulate_pr &&
1079 	    ((cdb[0] == PERSISTENT_RESERVE_IN) ||
1080 	     (cdb[0] == PERSISTENT_RESERVE_OUT) ||
1081 	     (cdb[0] == RELEASE || cdb[0] == RELEASE_10) ||
1082 	     (cdb[0] == RESERVE || cdb[0] == RESERVE_10))) {
1083 		return TCM_UNSUPPORTED_SCSI_OPCODE;
1084 	}
1085 
1086 	/*
1087 	 * For PERSISTENT RESERVE IN/OUT, RELEASE, and RESERVE we need to
1088 	 * emulate the response, since tcmu does not have the information
1089 	 * required to process these commands.
1090 	 */
1091 	if (!(dev->transport_flags &
1092 	      TRANSPORT_FLAG_PASSTHROUGH_PGR)) {
1093 		if (cdb[0] == PERSISTENT_RESERVE_IN) {
1094 			cmd->execute_cmd = target_scsi3_emulate_pr_in;
1095 			size = get_unaligned_be16(&cdb[7]);
1096 			return target_cmd_size_check(cmd, size);
1097 		}
1098 		if (cdb[0] == PERSISTENT_RESERVE_OUT) {
1099 			cmd->execute_cmd = target_scsi3_emulate_pr_out;
1100 			size = get_unaligned_be32(&cdb[5]);
1101 			return target_cmd_size_check(cmd, size);
1102 		}
1103 
1104 		if (cdb[0] == RELEASE || cdb[0] == RELEASE_10) {
1105 			cmd->execute_cmd = target_scsi2_reservation_release;
1106 			if (cdb[0] == RELEASE_10)
1107 				size = get_unaligned_be16(&cdb[7]);
1108 			else
1109 				size = cmd->data_length;
1110 			return target_cmd_size_check(cmd, size);
1111 		}
1112 		if (cdb[0] == RESERVE || cdb[0] == RESERVE_10) {
1113 			cmd->execute_cmd = target_scsi2_reservation_reserve;
1114 			if (cdb[0] == RESERVE_10)
1115 				size = get_unaligned_be16(&cdb[7]);
1116 			else
1117 				size = cmd->data_length;
1118 			return target_cmd_size_check(cmd, size);
1119 		}
1120 	}
1121 
1122 	/* Set DATA_CDB flag for ops that should have it */
1123 	switch (cdb[0]) {
1124 	case READ_6:
1125 	case READ_10:
1126 	case READ_12:
1127 	case READ_16:
1128 	case WRITE_6:
1129 	case WRITE_10:
1130 	case WRITE_12:
1131 	case WRITE_16:
1132 	case WRITE_VERIFY:
1133 	case WRITE_VERIFY_12:
1134 	case WRITE_VERIFY_16:
1135 	case COMPARE_AND_WRITE:
1136 	case XDWRITEREAD_10:
1137 		cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
1138 		break;
1139 	case VARIABLE_LENGTH_CMD:
1140 		switch (get_unaligned_be16(&cdb[8])) {
1141 		case READ_32:
1142 		case WRITE_32:
1143 		case WRITE_VERIFY_32:
1144 		case XDWRITEREAD_32:
1145 			cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB;
1146 			break;
1147 		}
1148 	}
1149 
1150 	cmd->execute_cmd = exec_cmd;
1151 
1152 	return TCM_NO_SENSE;
1153 }
1154 EXPORT_SYMBOL(passthrough_parse_cdb);
1155