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(v: &deve->total_cmds); |
60 | |
61 | if (se_cmd->data_direction == DMA_TO_DEVICE) |
62 | atomic_long_add(i: se_cmd->data_length, |
63 | v: &deve->write_bytes); |
64 | else if (se_cmd->data_direction == DMA_FROM_DEVICE) |
65 | atomic_long_add(i: se_cmd->data_length, |
66 | v: &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(ref: &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(ref: &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(v: &se_cmd->se_dev->num_cmds); |
131 | |
132 | if (se_cmd->data_direction == DMA_TO_DEVICE) |
133 | atomic_long_add(i: se_cmd->data_length, |
134 | v: &se_cmd->se_dev->write_bytes); |
135 | else if (se_cmd->data_direction == DMA_FROM_DEVICE) |
136 | atomic_long_add(i: se_cmd->data_length, |
137 | v: &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(ref: &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(kref: &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(lock: &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(lock: &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(lock: &dev->se_port_lock); |
291 | list_for_each_entry(lun, &dev->dev_sep_list, lun_dev_link) { |
292 | |
293 | spin_lock(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(lock: &lun->lun_deve_lock); |
297 | } |
298 | spin_unlock(lock: &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(size: 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(list: &new->ua_list); |
335 | INIT_LIST_HEAD(list: &new->lun_link); |
336 | |
337 | new->mapped_lun = mapped_lun; |
338 | kref_init(kref: &new->pr_kref); |
339 | init_completion(x: &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(lock: &nacl->lun_entry_mutex); |
355 | kfree(objp: 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(lock: &nacl->lun_entry_mutex); |
364 | kfree(objp: new); |
365 | return -EINVAL; |
366 | } |
367 | |
368 | new->se_lun = lun; |
369 | new->se_lun_acl = lun_acl; |
370 | hlist_del_rcu(n: &orig->link); |
371 | hlist_add_head_rcu(n: &new->link, h: &nacl->lun_entry_hlist); |
372 | mutex_unlock(lock: &nacl->lun_entry_mutex); |
373 | |
374 | spin_lock(lock: &lun->lun_deve_lock); |
375 | list_del(entry: &orig->lun_link); |
376 | list_add_tail(new: &new->lun_link, head: &lun->lun_deve_list); |
377 | spin_unlock(lock: &lun->lun_deve_lock); |
378 | |
379 | kref_put(kref: &orig->pr_kref, release: target_pr_kref_release); |
380 | wait_for_completion(&orig->pr_comp); |
381 | |
382 | target_luns_data_has_changed(nacl, new, skip_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(n: &new->link, h: &nacl->lun_entry_hlist); |
390 | mutex_unlock(lock: &nacl->lun_entry_mutex); |
391 | |
392 | spin_lock(lock: &lun->lun_deve_lock); |
393 | list_add_tail(new: &new->lun_link, head: &lun->lun_deve_list); |
394 | spin_unlock(lock: &lun->lun_deve_lock); |
395 | |
396 | target_luns_data_has_changed(nacl, new, skip_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(lock: &lun->lun_deve_lock); |
428 | list_del(entry: &orig->lun_link); |
429 | spin_unlock(lock: &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(n: &orig->link); |
436 | clear_bit(DEF_PR_REG_ACTIVE, addr: &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(kref: &orig->pr_kref, release: 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, skip_new: 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, orig: deve, nacl, tpg); |
471 | } |
472 | mutex_unlock(lock: &nacl->lun_entry_mutex); |
473 | } |
474 | mutex_unlock(lock: &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(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(entry: &vpd->vpd_list); |
485 | kfree(objp: vpd); |
486 | } |
487 | spin_unlock(lock: &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(lock: &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(size: 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, lun_acl: lacl, mapped_lun: 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, orig: deve, nacl, tpg); |
642 | mutex_unlock(lock: &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(objp: 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(n: nr_cpu_ids, size: 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(list: &q->state_list); |
705 | spin_lock_init(&q->lock); |
706 | |
707 | init_llist_head(list: &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(list: &dev->dev_sep_list); |
718 | INIT_LIST_HEAD(list: &dev->dev_tmr_list); |
719 | INIT_LIST_HEAD(list: &dev->delayed_cmd_list); |
720 | INIT_LIST_HEAD(list: &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(sem: &dev->caw_sem, val: 1); |
727 | INIT_LIST_HEAD(list: &dev->t10_wwn.t10_vpd_list); |
728 | spin_lock_init(&dev->t10_wwn.t10_vpd_lock); |
729 | INIT_LIST_HEAD(list: &dev->t10_pr.registration_list); |
730 | INIT_LIST_HEAD(list: &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(list: &dev->t10_alua.tg_pt_gps_list); |
734 | spin_lock_init(&dev->t10_alua.tg_pt_gps_lock); |
735 | INIT_LIST_HEAD(list: &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 | dev->dev_attrib.submit_type = TARGET_FABRIC_DEFAULT_SUBMIT; |
778 | |
779 | xcopy_lun = &dev->xcopy_lun; |
780 | rcu_assign_pointer(xcopy_lun->lun_se_dev, dev); |
781 | init_completion(x: &xcopy_lun->lun_shutdown_comp); |
782 | INIT_LIST_HEAD(list: &xcopy_lun->lun_deve_list); |
783 | INIT_LIST_HEAD(list: &xcopy_lun->lun_dev_link); |
784 | mutex_init(&xcopy_lun->lun_tg_pt_md_mutex); |
785 | xcopy_lun->lun_tpg = &xcopy_pt_tpg; |
786 | |
787 | /* Preload the default INQUIRY const values */ |
788 | strscpy(dev->t10_wwn.vendor, "LIO-ORG" , sizeof(dev->t10_wwn.vendor)); |
789 | strscpy(dev->t10_wwn.model, dev->transport->inquiry_prod, |
790 | sizeof(dev->t10_wwn.model)); |
791 | strscpy(dev->t10_wwn.revision, dev->transport->inquiry_rev, |
792 | sizeof(dev->t10_wwn.revision)); |
793 | |
794 | return dev; |
795 | } |
796 | |
797 | /* |
798 | * Check if the underlying struct block_device supports discard and if yes |
799 | * configure the UNMAP parameters. |
800 | */ |
801 | bool target_configure_unmap_from_queue(struct se_dev_attrib *attrib, |
802 | struct block_device *bdev) |
803 | { |
804 | int block_size = bdev_logical_block_size(bdev); |
805 | |
806 | if (!bdev_max_discard_sectors(bdev)) |
807 | return false; |
808 | |
809 | attrib->max_unmap_lba_count = |
810 | bdev_max_discard_sectors(bdev) >> (ilog2(block_size) - 9); |
811 | /* |
812 | * Currently hardcoded to 1 in Linux/SCSI code.. |
813 | */ |
814 | attrib->max_unmap_block_desc_count = 1; |
815 | attrib->unmap_granularity = bdev_discard_granularity(bdev) / block_size; |
816 | attrib->unmap_granularity_alignment = |
817 | bdev_discard_alignment(bdev) / block_size; |
818 | return true; |
819 | } |
820 | EXPORT_SYMBOL(target_configure_unmap_from_queue); |
821 | |
822 | /* |
823 | * Convert from blocksize advertised to the initiator to the 512 byte |
824 | * units unconditionally used by the Linux block layer. |
825 | */ |
826 | sector_t target_to_linux_sector(struct se_device *dev, sector_t lb) |
827 | { |
828 | switch (dev->dev_attrib.block_size) { |
829 | case 4096: |
830 | return lb << 3; |
831 | case 2048: |
832 | return lb << 2; |
833 | case 1024: |
834 | return lb << 1; |
835 | default: |
836 | return lb; |
837 | } |
838 | } |
839 | EXPORT_SYMBOL(target_to_linux_sector); |
840 | |
841 | struct devices_idr_iter { |
842 | int (*fn)(struct se_device *dev, void *data); |
843 | void *data; |
844 | }; |
845 | |
846 | static int target_devices_idr_iter(int id, void *p, void *data) |
847 | __must_hold(&device_mutex) |
848 | { |
849 | struct devices_idr_iter *iter = data; |
850 | struct se_device *dev = p; |
851 | struct config_item *item; |
852 | int ret; |
853 | |
854 | /* |
855 | * We add the device early to the idr, so it can be used |
856 | * by backend modules during configuration. We do not want |
857 | * to allow other callers to access partially setup devices, |
858 | * so we skip them here. |
859 | */ |
860 | if (!target_dev_configured(se_dev: dev)) |
861 | return 0; |
862 | |
863 | item = config_item_get_unless_zero(&dev->dev_group.cg_item); |
864 | if (!item) |
865 | return 0; |
866 | mutex_unlock(lock: &device_mutex); |
867 | |
868 | ret = iter->fn(dev, iter->data); |
869 | config_item_put(item); |
870 | |
871 | mutex_lock(&device_mutex); |
872 | return ret; |
873 | } |
874 | |
875 | /** |
876 | * target_for_each_device - iterate over configured devices |
877 | * @fn: iterator function |
878 | * @data: pointer to data that will be passed to fn |
879 | * |
880 | * fn must return 0 to continue looping over devices. non-zero will break |
881 | * from the loop and return that value to the caller. |
882 | */ |
883 | int target_for_each_device(int (*fn)(struct se_device *dev, void *data), |
884 | void *data) |
885 | { |
886 | struct devices_idr_iter iter = { .fn = fn, .data = data }; |
887 | int ret; |
888 | |
889 | mutex_lock(&device_mutex); |
890 | ret = idr_for_each(&devices_idr, fn: target_devices_idr_iter, data: &iter); |
891 | mutex_unlock(lock: &device_mutex); |
892 | return ret; |
893 | } |
894 | |
895 | int target_configure_device(struct se_device *dev) |
896 | { |
897 | struct se_hba *hba = dev->se_hba; |
898 | int ret, id; |
899 | |
900 | if (target_dev_configured(se_dev: dev)) { |
901 | pr_err("se_dev->se_dev_ptr already set for storage" |
902 | " object\n" ); |
903 | return -EEXIST; |
904 | } |
905 | |
906 | /* |
907 | * Add early so modules like tcmu can use during its |
908 | * configuration. |
909 | */ |
910 | mutex_lock(&device_mutex); |
911 | /* |
912 | * Use cyclic to try and avoid collisions with devices |
913 | * that were recently removed. |
914 | */ |
915 | id = idr_alloc_cyclic(&devices_idr, ptr: dev, start: 0, INT_MAX, GFP_KERNEL); |
916 | mutex_unlock(lock: &device_mutex); |
917 | if (id < 0) { |
918 | ret = -ENOMEM; |
919 | goto out; |
920 | } |
921 | dev->dev_index = id; |
922 | |
923 | ret = dev->transport->configure_device(dev); |
924 | if (ret) |
925 | goto out_free_index; |
926 | |
927 | if (dev->transport->configure_unmap && |
928 | dev->transport->configure_unmap(dev)) { |
929 | pr_debug("Discard support available, but disabled by default.\n" ); |
930 | } |
931 | |
932 | /* |
933 | * XXX: there is not much point to have two different values here.. |
934 | */ |
935 | dev->dev_attrib.block_size = dev->dev_attrib.hw_block_size; |
936 | dev->dev_attrib.queue_depth = dev->dev_attrib.hw_queue_depth; |
937 | |
938 | /* |
939 | * Align max_hw_sectors down to PAGE_SIZE I/O transfers |
940 | */ |
941 | dev->dev_attrib.hw_max_sectors = |
942 | se_dev_align_max_sectors(max_sectors: dev->dev_attrib.hw_max_sectors, |
943 | block_size: dev->dev_attrib.hw_block_size); |
944 | dev->dev_attrib.optimal_sectors = dev->dev_attrib.hw_max_sectors; |
945 | |
946 | dev->creation_time = get_jiffies_64(); |
947 | |
948 | ret = core_setup_alua(dev); |
949 | if (ret) |
950 | goto out_destroy_device; |
951 | |
952 | /* |
953 | * Setup work_queue for QUEUE_FULL |
954 | */ |
955 | INIT_WORK(&dev->qf_work_queue, target_qf_do_work); |
956 | |
957 | scsi_dump_inquiry(dev); |
958 | |
959 | spin_lock(lock: &hba->device_lock); |
960 | hba->dev_count++; |
961 | spin_unlock(lock: &hba->device_lock); |
962 | |
963 | dev->dev_flags |= DF_CONFIGURED; |
964 | |
965 | return 0; |
966 | |
967 | out_destroy_device: |
968 | dev->transport->destroy_device(dev); |
969 | out_free_index: |
970 | mutex_lock(&device_mutex); |
971 | idr_remove(&devices_idr, id: dev->dev_index); |
972 | mutex_unlock(lock: &device_mutex); |
973 | out: |
974 | se_release_vpd_for_dev(dev); |
975 | return ret; |
976 | } |
977 | |
978 | void target_free_device(struct se_device *dev) |
979 | { |
980 | struct se_hba *hba = dev->se_hba; |
981 | |
982 | WARN_ON(!list_empty(&dev->dev_sep_list)); |
983 | |
984 | if (target_dev_configured(se_dev: dev)) { |
985 | dev->transport->destroy_device(dev); |
986 | |
987 | mutex_lock(&device_mutex); |
988 | idr_remove(&devices_idr, id: dev->dev_index); |
989 | mutex_unlock(lock: &device_mutex); |
990 | |
991 | spin_lock(lock: &hba->device_lock); |
992 | hba->dev_count--; |
993 | spin_unlock(lock: &hba->device_lock); |
994 | } |
995 | |
996 | core_alua_free_lu_gp_mem(dev); |
997 | core_alua_set_lba_map(dev, NULL, 0, 0); |
998 | core_scsi3_free_all_registrations(dev); |
999 | se_release_vpd_for_dev(dev); |
1000 | |
1001 | if (dev->transport->free_prot) |
1002 | dev->transport->free_prot(dev); |
1003 | |
1004 | kfree(objp: dev->queues); |
1005 | dev->transport->free_device(dev); |
1006 | } |
1007 | |
1008 | int core_dev_setup_virtual_lun0(void) |
1009 | { |
1010 | struct se_hba *hba; |
1011 | struct se_device *dev; |
1012 | char buf[] = "rd_pages=8,rd_nullio=1,rd_dummy=1" ; |
1013 | int ret; |
1014 | |
1015 | hba = core_alloc_hba("rd_mcp" , 0, HBA_FLAGS_INTERNAL_USE); |
1016 | if (IS_ERR(ptr: hba)) |
1017 | return PTR_ERR(ptr: hba); |
1018 | |
1019 | dev = target_alloc_device(hba, name: "virt_lun0" ); |
1020 | if (!dev) { |
1021 | ret = -ENOMEM; |
1022 | goto out_free_hba; |
1023 | } |
1024 | |
1025 | hba->backend->ops->set_configfs_dev_params(dev, buf, sizeof(buf)); |
1026 | |
1027 | ret = target_configure_device(dev); |
1028 | if (ret) |
1029 | goto out_free_se_dev; |
1030 | |
1031 | lun0_hba = hba; |
1032 | g_lun0_dev = dev; |
1033 | return 0; |
1034 | |
1035 | out_free_se_dev: |
1036 | target_free_device(dev); |
1037 | out_free_hba: |
1038 | core_delete_hba(hba); |
1039 | return ret; |
1040 | } |
1041 | |
1042 | |
1043 | void core_dev_release_virtual_lun0(void) |
1044 | { |
1045 | struct se_hba *hba = lun0_hba; |
1046 | |
1047 | if (!hba) |
1048 | return; |
1049 | |
1050 | if (g_lun0_dev) |
1051 | target_free_device(dev: g_lun0_dev); |
1052 | core_delete_hba(hba); |
1053 | } |
1054 | |
1055 | /* |
1056 | * Common CDB parsing for kernel and user passthrough. |
1057 | */ |
1058 | sense_reason_t |
1059 | passthrough_parse_cdb(struct se_cmd *cmd, |
1060 | sense_reason_t (*exec_cmd)(struct se_cmd *cmd)) |
1061 | { |
1062 | unsigned char *cdb = cmd->t_task_cdb; |
1063 | struct se_device *dev = cmd->se_dev; |
1064 | unsigned int size; |
1065 | |
1066 | /* |
1067 | * For REPORT LUNS we always need to emulate the response, for everything |
1068 | * else, pass it up. |
1069 | */ |
1070 | if (cdb[0] == REPORT_LUNS) { |
1071 | cmd->execute_cmd = spc_emulate_report_luns; |
1072 | return TCM_NO_SENSE; |
1073 | } |
1074 | |
1075 | /* |
1076 | * With emulate_pr disabled, all reservation requests should fail, |
1077 | * regardless of whether or not TRANSPORT_FLAG_PASSTHROUGH_PGR is set. |
1078 | */ |
1079 | if (!dev->dev_attrib.emulate_pr && |
1080 | ((cdb[0] == PERSISTENT_RESERVE_IN) || |
1081 | (cdb[0] == PERSISTENT_RESERVE_OUT) || |
1082 | (cdb[0] == RELEASE || cdb[0] == RELEASE_10) || |
1083 | (cdb[0] == RESERVE || cdb[0] == RESERVE_10))) { |
1084 | return TCM_UNSUPPORTED_SCSI_OPCODE; |
1085 | } |
1086 | |
1087 | /* |
1088 | * For PERSISTENT RESERVE IN/OUT, RELEASE, and RESERVE we need to |
1089 | * emulate the response, since tcmu does not have the information |
1090 | * required to process these commands. |
1091 | */ |
1092 | if (!(dev->transport_flags & |
1093 | TRANSPORT_FLAG_PASSTHROUGH_PGR)) { |
1094 | if (cdb[0] == PERSISTENT_RESERVE_IN) { |
1095 | cmd->execute_cmd = target_scsi3_emulate_pr_in; |
1096 | size = get_unaligned_be16(p: &cdb[7]); |
1097 | return target_cmd_size_check(cmd, size); |
1098 | } |
1099 | if (cdb[0] == PERSISTENT_RESERVE_OUT) { |
1100 | cmd->execute_cmd = target_scsi3_emulate_pr_out; |
1101 | size = get_unaligned_be32(p: &cdb[5]); |
1102 | return target_cmd_size_check(cmd, size); |
1103 | } |
1104 | |
1105 | if (cdb[0] == RELEASE || cdb[0] == RELEASE_10) { |
1106 | cmd->execute_cmd = target_scsi2_reservation_release; |
1107 | if (cdb[0] == RELEASE_10) |
1108 | size = get_unaligned_be16(p: &cdb[7]); |
1109 | else |
1110 | size = cmd->data_length; |
1111 | return target_cmd_size_check(cmd, size); |
1112 | } |
1113 | if (cdb[0] == RESERVE || cdb[0] == RESERVE_10) { |
1114 | cmd->execute_cmd = target_scsi2_reservation_reserve; |
1115 | if (cdb[0] == RESERVE_10) |
1116 | size = get_unaligned_be16(p: &cdb[7]); |
1117 | else |
1118 | size = cmd->data_length; |
1119 | return target_cmd_size_check(cmd, size); |
1120 | } |
1121 | } |
1122 | |
1123 | /* Set DATA_CDB flag for ops that should have it */ |
1124 | switch (cdb[0]) { |
1125 | case READ_6: |
1126 | case READ_10: |
1127 | case READ_12: |
1128 | case READ_16: |
1129 | case WRITE_6: |
1130 | case WRITE_10: |
1131 | case WRITE_12: |
1132 | case WRITE_16: |
1133 | case WRITE_VERIFY: |
1134 | case WRITE_VERIFY_12: |
1135 | case WRITE_VERIFY_16: |
1136 | case COMPARE_AND_WRITE: |
1137 | case XDWRITEREAD_10: |
1138 | cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; |
1139 | break; |
1140 | case VARIABLE_LENGTH_CMD: |
1141 | switch (get_unaligned_be16(p: &cdb[8])) { |
1142 | case READ_32: |
1143 | case WRITE_32: |
1144 | case WRITE_VERIFY_32: |
1145 | case XDWRITEREAD_32: |
1146 | cmd->se_cmd_flags |= SCF_SCSI_DATA_CDB; |
1147 | break; |
1148 | } |
1149 | } |
1150 | |
1151 | cmd->execute_cmd = exec_cmd; |
1152 | |
1153 | return TCM_NO_SENSE; |
1154 | } |
1155 | EXPORT_SYMBOL(passthrough_parse_cdb); |
1156 | |