1 /*******************************************************************************
2 * Filename: target_core_xcopy.c
4 * This file contains support for SPC-4 Extended-Copy offload with generic
7 * Copyright (c) 2011-2013 Datera, Inc. All rights reserved.
10 * Nicholas A. Bellinger <nab@daterainc.com>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 ******************************************************************************/
24 #include <linux/slab.h>
25 #include <linux/spinlock.h>
26 #include <linux/list.h>
27 #include <linux/configfs.h>
28 #include <scsi/scsi.h>
29 #include <scsi/scsi_cmnd.h>
30 #include <asm/unaligned.h>
32 #include <target/target_core_base.h>
33 #include <target/target_core_backend.h>
34 #include <target/target_core_fabric.h>
35 #include <target/target_core_configfs.h>
37 #include "target_core_pr.h"
38 #include "target_core_ua.h"
39 #include "target_core_xcopy.h"
41 static struct workqueue_struct
*xcopy_wq
= NULL
;
43 * From target_core_spc.c
45 extern void spc_parse_naa_6h_vendor_specific(struct se_device
*, unsigned char *);
47 * From target_core_device.c
49 extern struct mutex g_device_mutex
;
50 extern struct list_head g_device_list
;
52 * From target_core_configfs.c
54 extern struct configfs_subsystem
*target_core_subsystem
[];
56 static int target_xcopy_gen_naa_ieee(struct se_device
*dev
, unsigned char *buf
)
60 buf
[off
++] = (0x6 << 4);
63 buf
[off
] = (0x5 << 4);
65 spc_parse_naa_6h_vendor_specific(dev
, &buf
[off
]);
69 static int target_xcopy_locate_se_dev_e4(struct se_cmd
*se_cmd
, struct xcopy_op
*xop
,
72 struct se_device
*se_dev
;
73 struct configfs_subsystem
*subsys
= target_core_subsystem
[0];
74 unsigned char tmp_dev_wwn
[XCOPY_NAA_IEEE_REGEX_LEN
], *dev_wwn
;
78 dev_wwn
= &xop
->dst_tid_wwn
[0];
80 dev_wwn
= &xop
->src_tid_wwn
[0];
82 mutex_lock(&g_device_mutex
);
83 list_for_each_entry(se_dev
, &g_device_list
, g_dev_node
) {
85 memset(&tmp_dev_wwn
[0], 0, XCOPY_NAA_IEEE_REGEX_LEN
);
86 target_xcopy_gen_naa_ieee(se_dev
, &tmp_dev_wwn
[0]);
88 rc
= memcmp(&tmp_dev_wwn
[0], dev_wwn
, XCOPY_NAA_IEEE_REGEX_LEN
);
93 xop
->dst_dev
= se_dev
;
94 pr_debug("XCOPY 0xe4: Setting xop->dst_dev: %p from located"
95 " se_dev\n", xop
->dst_dev
);
97 xop
->src_dev
= se_dev
;
98 pr_debug("XCOPY 0xe4: Setting xop->src_dev: %p from located"
99 " se_dev\n", xop
->src_dev
);
102 rc
= configfs_depend_item(subsys
,
103 &se_dev
->dev_group
.cg_item
);
105 pr_err("configfs_depend_item attempt failed:"
106 " %d for se_dev: %p\n", rc
, se_dev
);
107 mutex_unlock(&g_device_mutex
);
111 pr_debug("Called configfs_depend_item for subsys: %p se_dev: %p"
112 " se_dev->se_dev_group: %p\n", subsys
, se_dev
,
115 mutex_unlock(&g_device_mutex
);
118 mutex_unlock(&g_device_mutex
);
120 pr_err("Unable to locate 0xe4 descriptor for EXTENDED_COPY\n");
124 static int target_xcopy_parse_tiddesc_e4(struct se_cmd
*se_cmd
, struct xcopy_op
*xop
,
125 unsigned char *p
, bool src
)
127 unsigned char *desc
= p
;
131 * Extract RELATIVE INITIATOR PORT IDENTIFIER
133 ript
= get_unaligned_be16(&desc
[2]);
134 pr_debug("XCOPY 0xe4: RELATIVE INITIATOR PORT IDENTIFIER: %hu\n", ript
);
136 * Check for supported code set, association, and designator type
138 if ((desc
[4] & 0x0f) != 0x1) {
139 pr_err("XCOPY 0xe4: code set of non binary type not supported\n");
142 if ((desc
[5] & 0x30) != 0x00) {
143 pr_err("XCOPY 0xe4: association other than LUN not supported\n");
146 if ((desc
[5] & 0x0f) != 0x3) {
147 pr_err("XCOPY 0xe4: designator type unsupported: 0x%02x\n",
152 * Check for matching 16 byte length for NAA IEEE Registered Extended
153 * Assigned designator
156 if (desig_len
!= 16) {
157 pr_err("XCOPY 0xe4: invalid desig_len: %d\n", (int)desig_len
);
160 pr_debug("XCOPY 0xe4: desig_len: %d\n", (int)desig_len
);
162 * Check for NAA IEEE Registered Extended Assigned header..
164 if ((desc
[8] & 0xf0) != 0x60) {
165 pr_err("XCOPY 0xe4: Unsupported DESIGNATOR TYPE: 0x%02x\n",
171 memcpy(&xop
->src_tid_wwn
[0], &desc
[8], XCOPY_NAA_IEEE_REGEX_LEN
);
173 * Determine if the source designator matches the local device
175 if (!memcmp(&xop
->local_dev_wwn
[0], &xop
->src_tid_wwn
[0],
176 XCOPY_NAA_IEEE_REGEX_LEN
)) {
177 xop
->op_origin
= XCOL_SOURCE_RECV_OP
;
178 xop
->src_dev
= se_cmd
->se_dev
;
179 pr_debug("XCOPY 0xe4: Set xop->src_dev %p from source"
180 " received xop\n", xop
->src_dev
);
183 memcpy(&xop
->dst_tid_wwn
[0], &desc
[8], XCOPY_NAA_IEEE_REGEX_LEN
);
185 * Determine if the destination designator matches the local device
187 if (!memcmp(&xop
->local_dev_wwn
[0], &xop
->dst_tid_wwn
[0],
188 XCOPY_NAA_IEEE_REGEX_LEN
)) {
189 xop
->op_origin
= XCOL_DEST_RECV_OP
;
190 xop
->dst_dev
= se_cmd
->se_dev
;
191 pr_debug("XCOPY 0xe4: Set xop->dst_dev: %p from destination"
192 " received xop\n", xop
->dst_dev
);
199 static int target_xcopy_parse_target_descriptors(struct se_cmd
*se_cmd
,
200 struct xcopy_op
*xop
, unsigned char *p
,
203 struct se_device
*local_dev
= se_cmd
->se_dev
;
204 unsigned char *desc
= p
;
205 int offset
= tdll
% XCOPY_TARGET_DESC_LEN
, rc
, ret
= 0;
206 unsigned short start
= 0;
210 pr_err("XCOPY target descriptor list length is not"
211 " multiple of %d\n", XCOPY_TARGET_DESC_LEN
);
215 pr_err("XCOPY target descriptor supports a maximum"
216 " two src/dest descriptors, tdll: %hu too large..\n", tdll
);
220 * Generate an IEEE Registered Extended designator based upon the
221 * se_device the XCOPY was received upon..
223 memset(&xop
->local_dev_wwn
[0], 0, XCOPY_NAA_IEEE_REGEX_LEN
);
224 target_xcopy_gen_naa_ieee(local_dev
, &xop
->local_dev_wwn
[0]);
226 while (start
< tdll
) {
228 * Check target descriptor identification with 0xE4 type with
229 * use VPD 0x83 WWPN matching ..
233 rc
= target_xcopy_parse_tiddesc_e4(se_cmd
, xop
,
238 * Assume target descriptors are in source -> destination order..
244 start
+= XCOPY_TARGET_DESC_LEN
;
245 desc
+= XCOPY_TARGET_DESC_LEN
;
249 pr_err("XCOPY unsupported descriptor type code:"
250 " 0x%02x\n", desc
[0]);
255 if (xop
->op_origin
== XCOL_SOURCE_RECV_OP
)
256 rc
= target_xcopy_locate_se_dev_e4(se_cmd
, xop
, true);
258 rc
= target_xcopy_locate_se_dev_e4(se_cmd
, xop
, false);
263 pr_debug("XCOPY TGT desc: Source dev: %p NAA IEEE WWN: 0x%16phN\n",
264 xop
->src_dev
, &xop
->src_tid_wwn
[0]);
265 pr_debug("XCOPY TGT desc: Dest dev: %p NAA IEEE WWN: 0x%16phN\n",
266 xop
->dst_dev
, &xop
->dst_tid_wwn
[0]);
274 static int target_xcopy_parse_segdesc_02(struct se_cmd
*se_cmd
, struct xcopy_op
*xop
,
277 unsigned char *desc
= p
;
278 int dc
= (desc
[1] & 0x02);
279 unsigned short desc_len
;
281 desc_len
= get_unaligned_be16(&desc
[2]);
282 if (desc_len
!= 0x18) {
283 pr_err("XCOPY segment desc 0x02: Illegal desc_len:"
288 xop
->stdi
= get_unaligned_be16(&desc
[4]);
289 xop
->dtdi
= get_unaligned_be16(&desc
[6]);
290 pr_debug("XCOPY seg desc 0x02: desc_len: %hu stdi: %hu dtdi: %hu, DC: %d\n",
291 desc_len
, xop
->stdi
, xop
->dtdi
, dc
);
293 xop
->nolb
= get_unaligned_be16(&desc
[10]);
294 xop
->src_lba
= get_unaligned_be64(&desc
[12]);
295 xop
->dst_lba
= get_unaligned_be64(&desc
[20]);
296 pr_debug("XCOPY seg desc 0x02: nolb: %hu src_lba: %llu dst_lba: %llu\n",
297 xop
->nolb
, (unsigned long long)xop
->src_lba
,
298 (unsigned long long)xop
->dst_lba
);
301 xop
->dbl
= (desc
[29] << 16) & 0xff;
302 xop
->dbl
|= (desc
[30] << 8) & 0xff;
303 xop
->dbl
|= desc
[31] & 0xff;
305 pr_debug("XCOPY seg desc 0x02: DC=1 w/ dbl: %u\n", xop
->dbl
);
310 static int target_xcopy_parse_segment_descriptors(struct se_cmd
*se_cmd
,
311 struct xcopy_op
*xop
, unsigned char *p
,
314 unsigned char *desc
= p
;
315 unsigned int start
= 0;
316 int offset
= sdll
% XCOPY_SEGMENT_DESC_LEN
, rc
, ret
= 0;
319 pr_err("XCOPY segment descriptor list length is not"
320 " multiple of %d\n", XCOPY_SEGMENT_DESC_LEN
);
324 while (start
< sdll
) {
326 * Check segment descriptor type code for block -> block
330 rc
= target_xcopy_parse_segdesc_02(se_cmd
, xop
, desc
);
335 start
+= XCOPY_SEGMENT_DESC_LEN
;
336 desc
+= XCOPY_SEGMENT_DESC_LEN
;
339 pr_err("XCOPY unspported segment descriptor"
340 "type: 0x%02x\n", desc
[0]);
355 struct xcopy_pt_cmd
{
357 struct se_cmd se_cmd
;
358 struct xcopy_op
*xcopy_op
;
359 struct completion xpt_passthrough_sem
;
362 static struct se_port xcopy_pt_port
;
363 static struct se_portal_group xcopy_pt_tpg
;
364 static struct se_session xcopy_pt_sess
;
365 static struct se_node_acl xcopy_pt_nacl
;
367 static char *xcopy_pt_get_fabric_name(void)
372 static u32
xcopy_pt_get_tag(struct se_cmd
*se_cmd
)
377 static int xcopy_pt_get_cmd_state(struct se_cmd
*se_cmd
)
382 static void xcopy_pt_undepend_remotedev(struct xcopy_op
*xop
)
384 struct configfs_subsystem
*subsys
= target_core_subsystem
[0];
385 struct se_device
*remote_dev
;
387 if (xop
->op_origin
== XCOL_SOURCE_RECV_OP
)
388 remote_dev
= xop
->dst_dev
;
390 remote_dev
= xop
->src_dev
;
392 pr_debug("Calling configfs_undepend_item for subsys: %p"
393 " remote_dev: %p remote_dev->dev_group: %p\n",
394 subsys
, remote_dev
, &remote_dev
->dev_group
.cg_item
);
396 configfs_undepend_item(subsys
, &remote_dev
->dev_group
.cg_item
);
399 static void xcopy_pt_release_cmd(struct se_cmd
*se_cmd
)
401 struct xcopy_pt_cmd
*xpt_cmd
= container_of(se_cmd
,
402 struct xcopy_pt_cmd
, se_cmd
);
404 if (xpt_cmd
->remote_port
)
405 kfree(se_cmd
->se_lun
);
410 static int xcopy_pt_check_stop_free(struct se_cmd
*se_cmd
)
412 struct xcopy_pt_cmd
*xpt_cmd
= container_of(se_cmd
,
413 struct xcopy_pt_cmd
, se_cmd
);
415 complete(&xpt_cmd
->xpt_passthrough_sem
);
419 static int xcopy_pt_write_pending(struct se_cmd
*se_cmd
)
424 static int xcopy_pt_write_pending_status(struct se_cmd
*se_cmd
)
429 static int xcopy_pt_queue_data_in(struct se_cmd
*se_cmd
)
434 static int xcopy_pt_queue_status(struct se_cmd
*se_cmd
)
439 static struct target_core_fabric_ops xcopy_pt_tfo
= {
440 .get_fabric_name
= xcopy_pt_get_fabric_name
,
441 .get_task_tag
= xcopy_pt_get_tag
,
442 .get_cmd_state
= xcopy_pt_get_cmd_state
,
443 .release_cmd
= xcopy_pt_release_cmd
,
444 .check_stop_free
= xcopy_pt_check_stop_free
,
445 .write_pending
= xcopy_pt_write_pending
,
446 .write_pending_status
= xcopy_pt_write_pending_status
,
447 .queue_data_in
= xcopy_pt_queue_data_in
,
448 .queue_status
= xcopy_pt_queue_status
,
455 int target_xcopy_setup_pt(void)
457 xcopy_wq
= alloc_workqueue("xcopy_wq", WQ_MEM_RECLAIM
, 0);
459 pr_err("Unable to allocate xcopy_wq\n");
463 memset(&xcopy_pt_port
, 0, sizeof(struct se_port
));
464 INIT_LIST_HEAD(&xcopy_pt_port
.sep_alua_list
);
465 INIT_LIST_HEAD(&xcopy_pt_port
.sep_list
);
466 mutex_init(&xcopy_pt_port
.sep_tg_pt_md_mutex
);
468 memset(&xcopy_pt_tpg
, 0, sizeof(struct se_portal_group
));
469 INIT_LIST_HEAD(&xcopy_pt_tpg
.se_tpg_node
);
470 INIT_LIST_HEAD(&xcopy_pt_tpg
.acl_node_list
);
471 INIT_LIST_HEAD(&xcopy_pt_tpg
.tpg_sess_list
);
473 xcopy_pt_port
.sep_tpg
= &xcopy_pt_tpg
;
474 xcopy_pt_tpg
.se_tpg_tfo
= &xcopy_pt_tfo
;
476 memset(&xcopy_pt_nacl
, 0, sizeof(struct se_node_acl
));
477 INIT_LIST_HEAD(&xcopy_pt_nacl
.acl_list
);
478 INIT_LIST_HEAD(&xcopy_pt_nacl
.acl_sess_list
);
479 memset(&xcopy_pt_sess
, 0, sizeof(struct se_session
));
480 INIT_LIST_HEAD(&xcopy_pt_sess
.sess_list
);
481 INIT_LIST_HEAD(&xcopy_pt_sess
.sess_acl_list
);
483 xcopy_pt_nacl
.se_tpg
= &xcopy_pt_tpg
;
484 xcopy_pt_nacl
.nacl_sess
= &xcopy_pt_sess
;
486 xcopy_pt_sess
.se_tpg
= &xcopy_pt_tpg
;
487 xcopy_pt_sess
.se_node_acl
= &xcopy_pt_nacl
;
492 void target_xcopy_release_pt(void)
495 destroy_workqueue(xcopy_wq
);
498 static void target_xcopy_setup_pt_port(
499 struct xcopy_pt_cmd
*xpt_cmd
,
500 struct xcopy_op
*xop
,
503 struct se_cmd
*ec_cmd
= xop
->xop_se_cmd
;
504 struct se_cmd
*pt_cmd
= &xpt_cmd
->se_cmd
;
506 if (xop
->op_origin
== XCOL_SOURCE_RECV_OP
) {
508 * Honor destination port reservations for X-COPY PUSH emulation
509 * when CDB is received on local source port, and READs blocks to
510 * WRITE on remote destination port.
513 xpt_cmd
->remote_port
= remote_port
;
514 pt_cmd
->se_lun
->lun_sep
= &xcopy_pt_port
;
515 pr_debug("Setup emulated remote DEST xcopy_pt_port: %p to"
516 " cmd->se_lun->lun_sep for X-COPY data PUSH\n",
517 pt_cmd
->se_lun
->lun_sep
);
519 pt_cmd
->se_lun
= ec_cmd
->se_lun
;
520 pt_cmd
->se_dev
= ec_cmd
->se_dev
;
522 pr_debug("Honoring local SRC port from ec_cmd->se_dev:"
523 " %p\n", pt_cmd
->se_dev
);
524 pt_cmd
->se_lun
= ec_cmd
->se_lun
;
525 pr_debug("Honoring local SRC port from ec_cmd->se_lun: %p\n",
530 * Honor source port reservation for X-COPY PULL emulation
531 * when CDB is received on local desintation port, and READs
532 * blocks from the remote source port to WRITE on local
536 xpt_cmd
->remote_port
= remote_port
;
537 pt_cmd
->se_lun
->lun_sep
= &xcopy_pt_port
;
538 pr_debug("Setup emulated remote SRC xcopy_pt_port: %p to"
539 " cmd->se_lun->lun_sep for X-COPY data PULL\n",
540 pt_cmd
->se_lun
->lun_sep
);
542 pt_cmd
->se_lun
= ec_cmd
->se_lun
;
543 pt_cmd
->se_dev
= ec_cmd
->se_dev
;
545 pr_debug("Honoring local DST port from ec_cmd->se_dev:"
546 " %p\n", pt_cmd
->se_dev
);
547 pt_cmd
->se_lun
= ec_cmd
->se_lun
;
548 pr_debug("Honoring local DST port from ec_cmd->se_lun: %p\n",
554 static int target_xcopy_init_pt_lun(
555 struct xcopy_pt_cmd
*xpt_cmd
,
556 struct xcopy_op
*xop
,
557 struct se_device
*se_dev
,
558 struct se_cmd
*pt_cmd
,
562 * Don't allocate + init an pt_cmd->se_lun if honoring local port for
563 * reservations. The pt_cmd->se_lun pointer will be setup from within
564 * target_xcopy_setup_pt_port()
566 if (remote_port
== false) {
567 pt_cmd
->se_cmd_flags
|= SCF_SE_LUN_CMD
| SCF_CMD_XCOPY_PASSTHROUGH
;
571 pt_cmd
->se_lun
= kzalloc(sizeof(struct se_lun
), GFP_KERNEL
);
572 if (!pt_cmd
->se_lun
) {
573 pr_err("Unable to allocate pt_cmd->se_lun\n");
576 init_completion(&pt_cmd
->se_lun
->lun_shutdown_comp
);
577 INIT_LIST_HEAD(&pt_cmd
->se_lun
->lun_cmd_list
);
578 INIT_LIST_HEAD(&pt_cmd
->se_lun
->lun_acl_list
);
579 spin_lock_init(&pt_cmd
->se_lun
->lun_acl_lock
);
580 spin_lock_init(&pt_cmd
->se_lun
->lun_cmd_lock
);
581 spin_lock_init(&pt_cmd
->se_lun
->lun_sep_lock
);
582 init_completion(&pt_cmd
->se_lun
->lun_ref_comp
);
584 pt_cmd
->se_dev
= se_dev
;
586 pr_debug("Setup emulated se_dev: %p from se_dev\n", pt_cmd
->se_dev
);
587 pt_cmd
->se_lun
->lun_se_dev
= se_dev
;
588 pt_cmd
->se_cmd_flags
|= SCF_SE_LUN_CMD
| SCF_CMD_XCOPY_PASSTHROUGH
;
590 pr_debug("Setup emulated se_dev: %p to pt_cmd->se_lun->lun_se_dev\n",
591 pt_cmd
->se_lun
->lun_se_dev
);
596 static int target_xcopy_setup_pt_cmd(
597 struct xcopy_pt_cmd
*xpt_cmd
,
598 struct xcopy_op
*xop
,
599 struct se_device
*se_dev
,
604 struct se_cmd
*cmd
= &xpt_cmd
->se_cmd
;
605 sense_reason_t sense_rc
;
608 * Setup LUN+port to honor reservations based upon xop->op_origin for
609 * X-COPY PUSH or X-COPY PULL based upon where the CDB was received.
611 rc
= target_xcopy_init_pt_lun(xpt_cmd
, xop
, se_dev
, cmd
, remote_port
);
616 xpt_cmd
->xcopy_op
= xop
;
617 target_xcopy_setup_pt_port(xpt_cmd
, xop
, remote_port
);
619 sense_rc
= target_setup_cmd_from_cdb(cmd
, cdb
);
626 rc
= target_alloc_sgl(&cmd
->t_data_sg
, &cmd
->t_data_nents
,
627 cmd
->data_length
, false);
633 * Set this bit so that transport_free_pages() allows the
634 * caller to release SGLs + physical memory allocated by
635 * transport_generic_get_mem()..
637 cmd
->se_cmd_flags
|= SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC
;
640 * Here the previously allocated SGLs for the internal READ
641 * are mapped zero-copy to the internal WRITE.
643 sense_rc
= transport_generic_map_mem_to_cmd(cmd
,
644 xop
->xop_data_sg
, xop
->xop_data_nents
,
651 pr_debug("Setup PASSTHROUGH_NOALLOC t_data_sg: %p t_data_nents:"
652 " %u\n", cmd
->t_data_sg
, cmd
->t_data_nents
);
658 if (remote_port
== true)
663 static int target_xcopy_issue_pt_cmd(struct xcopy_pt_cmd
*xpt_cmd
)
665 struct se_cmd
*se_cmd
= &xpt_cmd
->se_cmd
;
666 sense_reason_t sense_rc
;
668 sense_rc
= transport_generic_new_cmd(se_cmd
);
672 if (se_cmd
->data_direction
== DMA_TO_DEVICE
)
673 target_execute_cmd(se_cmd
);
675 wait_for_completion_interruptible(&xpt_cmd
->xpt_passthrough_sem
);
677 pr_debug("target_xcopy_issue_pt_cmd(): SCSI status: 0x%02x\n",
678 se_cmd
->scsi_status
);
682 static int target_xcopy_read_source(
683 struct se_cmd
*ec_cmd
,
684 struct xcopy_op
*xop
,
685 struct se_device
*src_dev
,
689 struct xcopy_pt_cmd
*xpt_cmd
;
690 struct se_cmd
*se_cmd
;
691 u32 length
= (src_sectors
* src_dev
->dev_attrib
.block_size
);
693 unsigned char cdb
[16];
694 bool remote_port
= (xop
->op_origin
== XCOL_DEST_RECV_OP
);
696 xpt_cmd
= kzalloc(sizeof(struct xcopy_pt_cmd
), GFP_KERNEL
);
698 pr_err("Unable to allocate xcopy_pt_cmd\n");
701 init_completion(&xpt_cmd
->xpt_passthrough_sem
);
702 se_cmd
= &xpt_cmd
->se_cmd
;
704 memset(&cdb
[0], 0, 16);
706 put_unaligned_be64(src_lba
, &cdb
[2]);
707 put_unaligned_be32(src_sectors
, &cdb
[10]);
708 pr_debug("XCOPY: Built READ_16: LBA: %llu Sectors: %u Length: %u\n",
709 (unsigned long long)src_lba
, src_sectors
, length
);
711 transport_init_se_cmd(se_cmd
, &xcopy_pt_tfo
, NULL
, length
,
712 DMA_FROM_DEVICE
, 0, NULL
);
713 xop
->src_pt_cmd
= xpt_cmd
;
715 rc
= target_xcopy_setup_pt_cmd(xpt_cmd
, xop
, src_dev
, &cdb
[0],
718 transport_generic_free_cmd(se_cmd
, 0);
722 xop
->xop_data_sg
= se_cmd
->t_data_sg
;
723 xop
->xop_data_nents
= se_cmd
->t_data_nents
;
724 pr_debug("XCOPY-READ: Saved xop->xop_data_sg: %p, num: %u for READ"
725 " memory\n", xop
->xop_data_sg
, xop
->xop_data_nents
);
727 rc
= target_xcopy_issue_pt_cmd(xpt_cmd
);
729 transport_generic_free_cmd(se_cmd
, 0);
733 * Clear off the allocated t_data_sg, that has been saved for
734 * zero-copy WRITE submission reuse in struct xcopy_op..
736 se_cmd
->t_data_sg
= NULL
;
737 se_cmd
->t_data_nents
= 0;
742 static int target_xcopy_write_destination(
743 struct se_cmd
*ec_cmd
,
744 struct xcopy_op
*xop
,
745 struct se_device
*dst_dev
,
749 struct xcopy_pt_cmd
*xpt_cmd
;
750 struct se_cmd
*se_cmd
;
751 u32 length
= (dst_sectors
* dst_dev
->dev_attrib
.block_size
);
753 unsigned char cdb
[16];
754 bool remote_port
= (xop
->op_origin
== XCOL_SOURCE_RECV_OP
);
756 xpt_cmd
= kzalloc(sizeof(struct xcopy_pt_cmd
), GFP_KERNEL
);
758 pr_err("Unable to allocate xcopy_pt_cmd\n");
761 init_completion(&xpt_cmd
->xpt_passthrough_sem
);
762 se_cmd
= &xpt_cmd
->se_cmd
;
764 memset(&cdb
[0], 0, 16);
766 put_unaligned_be64(dst_lba
, &cdb
[2]);
767 put_unaligned_be32(dst_sectors
, &cdb
[10]);
768 pr_debug("XCOPY: Built WRITE_16: LBA: %llu Sectors: %u Length: %u\n",
769 (unsigned long long)dst_lba
, dst_sectors
, length
);
771 transport_init_se_cmd(se_cmd
, &xcopy_pt_tfo
, NULL
, length
,
772 DMA_TO_DEVICE
, 0, NULL
);
773 xop
->dst_pt_cmd
= xpt_cmd
;
775 rc
= target_xcopy_setup_pt_cmd(xpt_cmd
, xop
, dst_dev
, &cdb
[0],
778 struct se_cmd
*src_cmd
= &xop
->src_pt_cmd
->se_cmd
;
780 * If the failure happened before the t_mem_list hand-off in
781 * target_xcopy_setup_pt_cmd(), Reset memory + clear flag so that
782 * core releases this memory on error during X-COPY WRITE I/O.
784 src_cmd
->se_cmd_flags
&= ~SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC
;
785 src_cmd
->t_data_sg
= xop
->xop_data_sg
;
786 src_cmd
->t_data_nents
= xop
->xop_data_nents
;
788 transport_generic_free_cmd(se_cmd
, 0);
792 rc
= target_xcopy_issue_pt_cmd(xpt_cmd
);
794 se_cmd
->se_cmd_flags
&= ~SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC
;
795 transport_generic_free_cmd(se_cmd
, 0);
802 static void target_xcopy_do_work(struct work_struct
*work
)
804 struct xcopy_op
*xop
= container_of(work
, struct xcopy_op
, xop_work
);
805 struct se_device
*src_dev
= xop
->src_dev
, *dst_dev
= xop
->dst_dev
;
806 struct se_cmd
*ec_cmd
= xop
->xop_se_cmd
;
807 sector_t src_lba
= xop
->src_lba
, dst_lba
= xop
->dst_lba
, end_lba
;
808 unsigned int max_sectors
;
810 unsigned short nolb
= xop
->nolb
, cur_nolb
, max_nolb
, copied_nolb
= 0;
812 end_lba
= src_lba
+ nolb
;
814 * Break up XCOPY I/O into hw_max_sectors sized I/O based on the
815 * smallest max_sectors between src_dev + dev_dev, or
817 max_sectors
= min(src_dev
->dev_attrib
.hw_max_sectors
,
818 dst_dev
->dev_attrib
.hw_max_sectors
);
819 max_sectors
= min_t(u32
, max_sectors
, XCOPY_MAX_SECTORS
);
821 max_nolb
= min_t(u16
, max_sectors
, ((u16
)(~0U)));
823 pr_debug("target_xcopy_do_work: nolb: %hu, max_nolb: %hu end_lba: %llu\n",
824 nolb
, max_nolb
, (unsigned long long)end_lba
);
825 pr_debug("target_xcopy_do_work: Starting src_lba: %llu, dst_lba: %llu\n",
826 (unsigned long long)src_lba
, (unsigned long long)dst_lba
);
828 while (src_lba
< end_lba
) {
829 cur_nolb
= min(nolb
, max_nolb
);
831 pr_debug("target_xcopy_do_work: Calling read src_dev: %p src_lba: %llu,"
832 " cur_nolb: %hu\n", src_dev
, (unsigned long long)src_lba
, cur_nolb
);
834 rc
= target_xcopy_read_source(ec_cmd
, xop
, src_dev
, src_lba
, cur_nolb
);
839 pr_debug("target_xcopy_do_work: Incremented READ src_lba to %llu\n",
840 (unsigned long long)src_lba
);
842 pr_debug("target_xcopy_do_work: Calling write dst_dev: %p dst_lba: %llu,"
843 " cur_nolb: %hu\n", dst_dev
, (unsigned long long)dst_lba
, cur_nolb
);
845 rc
= target_xcopy_write_destination(ec_cmd
, xop
, dst_dev
,
848 transport_generic_free_cmd(&xop
->src_pt_cmd
->se_cmd
, 0);
853 pr_debug("target_xcopy_do_work: Incremented WRITE dst_lba to %llu\n",
854 (unsigned long long)dst_lba
);
856 copied_nolb
+= cur_nolb
;
859 transport_generic_free_cmd(&xop
->src_pt_cmd
->se_cmd
, 0);
860 xop
->dst_pt_cmd
->se_cmd
.se_cmd_flags
&= ~SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC
;
862 transport_generic_free_cmd(&xop
->dst_pt_cmd
->se_cmd
, 0);
865 xcopy_pt_undepend_remotedev(xop
);
868 pr_debug("target_xcopy_do_work: Final src_lba: %llu, dst_lba: %llu\n",
869 (unsigned long long)src_lba
, (unsigned long long)dst_lba
);
870 pr_debug("target_xcopy_do_work: Blocks copied: %hu, Bytes Copied: %u\n",
871 copied_nolb
, copied_nolb
* dst_dev
->dev_attrib
.block_size
);
873 pr_debug("target_xcopy_do_work: Setting X-COPY GOOD status -> sending response\n");
874 target_complete_cmd(ec_cmd
, SAM_STAT_GOOD
);
878 xcopy_pt_undepend_remotedev(xop
);
881 pr_warn("target_xcopy_do_work: Setting X-COPY CHECK_CONDITION -> sending response\n");
882 ec_cmd
->scsi_status
= SAM_STAT_CHECK_CONDITION
;
883 target_complete_cmd(ec_cmd
, SAM_STAT_CHECK_CONDITION
);
886 sense_reason_t
target_do_xcopy(struct se_cmd
*se_cmd
)
888 struct xcopy_op
*xop
= NULL
;
889 unsigned char *p
= NULL
, *seg_desc
;
890 unsigned int list_id
, list_id_usage
, sdll
, inline_dl
, sa
;
894 sa
= se_cmd
->t_task_cdb
[1] & 0x1f;
896 pr_err("EXTENDED_COPY(LID4) not supported\n");
897 return TCM_UNSUPPORTED_SCSI_OPCODE
;
900 p
= transport_kmap_data_sg(se_cmd
);
902 pr_err("transport_kmap_data_sg() failed in target_do_xcopy\n");
903 return TCM_OUT_OF_RESOURCES
;
907 if (list_id
!= 0x00) {
908 pr_err("XCOPY with non zero list_id: 0x%02x\n", list_id
);
911 list_id_usage
= (p
[1] & 0x18);
913 * Determine TARGET DESCRIPTOR LIST LENGTH + SEGMENT DESCRIPTOR LIST LENGTH
915 tdll
= get_unaligned_be16(&p
[2]);
916 sdll
= get_unaligned_be32(&p
[8]);
918 inline_dl
= get_unaligned_be32(&p
[12]);
919 if (inline_dl
!= 0) {
920 pr_err("XCOPY with non zero inline data length\n");
924 xop
= kzalloc(sizeof(struct xcopy_op
), GFP_KERNEL
);
926 pr_err("Unable to allocate xcopy_op\n");
929 xop
->xop_se_cmd
= se_cmd
;
931 pr_debug("Processing XCOPY with list_id: 0x%02x list_id_usage: 0x%02x"
932 " tdll: %hu sdll: %u inline_dl: %u\n", list_id
, list_id_usage
,
933 tdll
, sdll
, inline_dl
);
935 rc
= target_xcopy_parse_target_descriptors(se_cmd
, xop
, &p
[16], tdll
);
939 pr_debug("XCOPY: Processed %d target descriptors, length: %u\n", rc
,
940 rc
* XCOPY_TARGET_DESC_LEN
);
942 seg_desc
+= (rc
* XCOPY_TARGET_DESC_LEN
);
944 rc
= target_xcopy_parse_segment_descriptors(se_cmd
, xop
, seg_desc
, sdll
);
946 xcopy_pt_undepend_remotedev(xop
);
949 transport_kunmap_data_sg(se_cmd
);
951 pr_debug("XCOPY: Processed %d segment descriptors, length: %u\n", rc
,
952 rc
* XCOPY_SEGMENT_DESC_LEN
);
953 INIT_WORK(&xop
->xop_work
, target_xcopy_do_work
);
954 queue_work(xcopy_wq
, &xop
->xop_work
);
959 transport_kunmap_data_sg(se_cmd
);
961 return TCM_INVALID_CDB_FIELD
;
964 static sense_reason_t
target_rcr_operating_parameters(struct se_cmd
*se_cmd
)
968 p
= transport_kmap_data_sg(se_cmd
);
970 pr_err("transport_kmap_data_sg failed in"
971 " target_rcr_operating_parameters\n");
972 return TCM_OUT_OF_RESOURCES
;
975 if (se_cmd
->data_length
< 54) {
976 pr_err("Receive Copy Results Op Parameters length"
977 " too small: %u\n", se_cmd
->data_length
);
978 transport_kunmap_data_sg(se_cmd
);
979 return TCM_INVALID_CDB_FIELD
;
982 * Set SNLID=1 (Supports no List ID)
986 * MAXIMUM TARGET DESCRIPTOR COUNT
988 put_unaligned_be16(RCR_OP_MAX_TARGET_DESC_COUNT
, &p
[8]);
990 * MAXIMUM SEGMENT DESCRIPTOR COUNT
992 put_unaligned_be16(RCR_OP_MAX_SG_DESC_COUNT
, &p
[10]);
994 * MAXIMUM DESCRIPTOR LIST LENGTH
996 put_unaligned_be32(RCR_OP_MAX_DESC_LIST_LEN
, &p
[12]);
998 * MAXIMUM SEGMENT LENGTH
1000 put_unaligned_be32(RCR_OP_MAX_SEGMENT_LEN
, &p
[16]);
1002 * MAXIMUM INLINE DATA LENGTH for SA 0x04 (NOT SUPPORTED)
1004 put_unaligned_be32(0x0, &p
[20]);
1008 put_unaligned_be32(0x0, &p
[24]);
1010 * MAXIMUM STREAM DEVICE TRANSFER SIZE
1012 put_unaligned_be32(0x0, &p
[28]);
1014 * TOTAL CONCURRENT COPIES
1016 put_unaligned_be16(RCR_OP_TOTAL_CONCURR_COPIES
, &p
[34]);
1018 * MAXIMUM CONCURRENT COPIES
1020 p
[36] = RCR_OP_MAX_CONCURR_COPIES
;
1022 * DATA SEGMENT GRANULARITY (log 2)
1024 p
[37] = RCR_OP_DATA_SEG_GRAN_LOG2
;
1026 * INLINE DATA GRANULARITY log 2)
1028 p
[38] = RCR_OP_INLINE_DATA_GRAN_LOG2
;
1030 * HELD DATA GRANULARITY
1032 p
[39] = RCR_OP_HELD_DATA_GRAN_LOG2
;
1034 * IMPLEMENTED DESCRIPTOR LIST LENGTH
1038 * List of implemented descriptor type codes (ordered)
1040 p
[44] = 0x02; /* Copy Block to Block device */
1041 p
[45] = 0xe4; /* Identification descriptor target descriptor */
1044 * AVAILABLE DATA (n-3)
1046 put_unaligned_be32(42, &p
[0]);
1048 transport_kunmap_data_sg(se_cmd
);
1049 target_complete_cmd(se_cmd
, GOOD
);
1051 return TCM_NO_SENSE
;
1054 sense_reason_t
target_do_receive_copy_results(struct se_cmd
*se_cmd
)
1056 unsigned char *cdb
= &se_cmd
->t_task_cdb
[0];
1057 int sa
= (cdb
[1] & 0x1f), list_id
= cdb
[2];
1058 sense_reason_t rc
= TCM_NO_SENSE
;
1060 pr_debug("Entering target_do_receive_copy_results: SA: 0x%02x, List ID:"
1061 " 0x%02x, AL: %u\n", sa
, list_id
, se_cmd
->data_length
);
1064 pr_err("Receive Copy Results with non zero list identifier"
1065 " not supported\n");
1066 return TCM_INVALID_CDB_FIELD
;
1070 case RCR_SA_OPERATING_PARAMETERS
:
1071 rc
= target_rcr_operating_parameters(se_cmd
);
1073 case RCR_SA_COPY_STATUS
:
1074 case RCR_SA_RECEIVE_DATA
:
1075 case RCR_SA_FAILED_SEGMENT_DETAILS
:
1077 pr_err("Unsupported SA for receive copy results: 0x%02x\n", sa
);
1078 return TCM_INVALID_CDB_FIELD
;