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/version.h>
25 #include <linux/slab.h>
26 #include <linux/spinlock.h>
27 #include <linux/list.h>
28 #include <linux/configfs.h>
29 #include <scsi/scsi.h>
30 #include <scsi/scsi_cmnd.h>
31 #include <asm/unaligned.h>
33 #include <target/target_core_base.h>
34 #include <target/target_core_backend.h>
35 #include <target/target_core_fabric.h>
36 #include <target/target_core_configfs.h>
38 #include "target_core_pr.h"
39 #include "target_core_ua.h"
40 #include "target_core_xcopy.h"
42 static struct workqueue_struct
*xcopy_wq
= NULL
;
44 * From target_core_spc.c
46 extern void spc_parse_naa_6h_vendor_specific(struct se_device
*, unsigned char *);
48 * From target_core_device.c
50 extern struct mutex g_device_mutex
;
51 extern struct list_head g_device_list
;
53 * From target_core_configfs.c
55 extern struct configfs_subsystem
*target_core_subsystem
[];
57 static int target_xcopy_gen_naa_ieee(struct se_device
*dev
, unsigned char *buf
)
61 buf
[off
++] = (0x6 << 4);
64 buf
[off
] = (0x5 << 4);
66 spc_parse_naa_6h_vendor_specific(dev
, &buf
[off
]);
70 static int target_xcopy_locate_se_dev_e4(struct se_cmd
*se_cmd
, struct xcopy_op
*xop
,
73 struct se_device
*se_dev
;
74 struct configfs_subsystem
*subsys
= target_core_subsystem
[0];
75 unsigned char tmp_dev_wwn
[XCOPY_NAA_IEEE_REGEX_LEN
], *dev_wwn
;
79 dev_wwn
= &xop
->dst_tid_wwn
[0];
81 dev_wwn
= &xop
->src_tid_wwn
[0];
83 mutex_lock(&g_device_mutex
);
84 list_for_each_entry(se_dev
, &g_device_list
, g_dev_node
) {
86 memset(&tmp_dev_wwn
[0], 0, XCOPY_NAA_IEEE_REGEX_LEN
);
87 target_xcopy_gen_naa_ieee(se_dev
, &tmp_dev_wwn
[0]);
89 rc
= memcmp(&tmp_dev_wwn
[0], dev_wwn
, XCOPY_NAA_IEEE_REGEX_LEN
);
94 xop
->dst_dev
= se_dev
;
95 pr_debug("XCOPY 0xe4: Setting xop->dst_dev: %p from located"
96 " se_dev\n", xop
->dst_dev
);
98 xop
->src_dev
= se_dev
;
99 pr_debug("XCOPY 0xe4: Setting xop->src_dev: %p from located"
100 " se_dev\n", xop
->src_dev
);
103 rc
= configfs_depend_item(subsys
,
104 &se_dev
->dev_group
.cg_item
);
106 pr_err("configfs_depend_item attempt failed:"
107 " %d for se_dev: %p\n", rc
, se_dev
);
108 mutex_unlock(&g_device_mutex
);
112 pr_debug("Called configfs_depend_item for subsys: %p se_dev: %p"
113 " se_dev->se_dev_group: %p\n", subsys
, se_dev
,
116 mutex_unlock(&g_device_mutex
);
119 mutex_unlock(&g_device_mutex
);
121 pr_err("Unable to locate 0xe4 descriptor for EXTENDED_COPY\n");
125 static int target_xcopy_parse_tiddesc_e4(struct se_cmd
*se_cmd
, struct xcopy_op
*xop
,
126 unsigned char *p
, bool src
)
128 unsigned char *desc
= p
;
132 * Extract RELATIVE INITIATOR PORT IDENTIFIER
134 ript
= get_unaligned_be16(&desc
[2]);
135 pr_debug("XCOPY 0xe4: RELATIVE INITIATOR PORT IDENTIFIER: %hu\n", ript
);
137 * Check for supported code set, association, and designator type
139 if ((desc
[4] & 0x0f) != 0x1) {
140 pr_err("XCOPY 0xe4: code set of non binary type not supported\n");
143 if ((desc
[5] & 0x30) != 0x00) {
144 pr_err("XCOPY 0xe4: association other than LUN not supported\n");
147 if ((desc
[5] & 0x0f) != 0x3) {
148 pr_err("XCOPY 0xe4: designator type unsupported: 0x%02x\n",
153 * Check for matching 16 byte length for NAA IEEE Registered Extended
154 * Assigned designator
157 if (desig_len
!= 16) {
158 pr_err("XCOPY 0xe4: invalid desig_len: %d\n", (int)desig_len
);
161 pr_debug("XCOPY 0xe4: desig_len: %d\n", (int)desig_len
);
163 * Check for NAA IEEE Registered Extended Assigned header..
165 if ((desc
[8] & 0xf0) != 0x60) {
166 pr_err("XCOPY 0xe4: Unsupported DESIGNATOR TYPE: 0x%02x\n",
172 memcpy(&xop
->src_tid_wwn
[0], &desc
[8], XCOPY_NAA_IEEE_REGEX_LEN
);
174 * Determine if the source designator matches the local device
176 if (!memcmp(&xop
->local_dev_wwn
[0], &xop
->src_tid_wwn
[0],
177 XCOPY_NAA_IEEE_REGEX_LEN
)) {
178 xop
->op_origin
= XCOL_SOURCE_RECV_OP
;
179 xop
->src_dev
= se_cmd
->se_dev
;
180 pr_debug("XCOPY 0xe4: Set xop->src_dev %p from source"
181 " received xop\n", xop
->src_dev
);
184 memcpy(&xop
->dst_tid_wwn
[0], &desc
[8], XCOPY_NAA_IEEE_REGEX_LEN
);
186 * Determine if the destination designator matches the local device
188 if (!memcmp(&xop
->local_dev_wwn
[0], &xop
->dst_tid_wwn
[0],
189 XCOPY_NAA_IEEE_REGEX_LEN
)) {
190 xop
->op_origin
= XCOL_DEST_RECV_OP
;
191 xop
->dst_dev
= se_cmd
->se_dev
;
192 pr_debug("XCOPY 0xe4: Set xop->dst_dev: %p from destination"
193 " received xop\n", xop
->dst_dev
);
200 static int target_xcopy_parse_target_descriptors(struct se_cmd
*se_cmd
,
201 struct xcopy_op
*xop
, unsigned char *p
,
204 struct se_device
*local_dev
= se_cmd
->se_dev
;
205 unsigned char *desc
= p
;
206 int offset
= tdll
% XCOPY_TARGET_DESC_LEN
, rc
, ret
= 0;
207 unsigned short start
= 0;
211 pr_err("XCOPY target descriptor list length is not"
212 " multiple of %d\n", XCOPY_TARGET_DESC_LEN
);
216 pr_err("XCOPY target descriptor supports a maximum"
217 " two src/dest descriptors, tdll: %hu too large..\n", tdll
);
221 * Generate an IEEE Registered Extended designator based upon the
222 * se_device the XCOPY was received upon..
224 memset(&xop
->local_dev_wwn
[0], 0, XCOPY_NAA_IEEE_REGEX_LEN
);
225 target_xcopy_gen_naa_ieee(local_dev
, &xop
->local_dev_wwn
[0]);
227 while (start
< tdll
) {
229 * Check target descriptor identification with 0xE4 type with
230 * use VPD 0x83 WWPN matching ..
234 rc
= target_xcopy_parse_tiddesc_e4(se_cmd
, xop
,
239 * Assume target descriptors are in source -> destination order..
245 start
+= XCOPY_TARGET_DESC_LEN
;
246 desc
+= XCOPY_TARGET_DESC_LEN
;
250 pr_err("XCOPY unsupported descriptor type code:"
251 " 0x%02x\n", desc
[0]);
256 if (xop
->op_origin
== XCOL_SOURCE_RECV_OP
)
257 rc
= target_xcopy_locate_se_dev_e4(se_cmd
, xop
, true);
259 rc
= target_xcopy_locate_se_dev_e4(se_cmd
, xop
, false);
264 pr_debug("XCOPY TGT desc: Source dev: %p NAA IEEE WWN: 0x%16phN\n",
265 xop
->src_dev
, &xop
->src_tid_wwn
[0]);
266 pr_debug("XCOPY TGT desc: Dest dev: %p NAA IEEE WWN: 0x%16phN\n",
267 xop
->dst_dev
, &xop
->dst_tid_wwn
[0]);
275 static int target_xcopy_parse_segdesc_02(struct se_cmd
*se_cmd
, struct xcopy_op
*xop
,
278 unsigned char *desc
= p
;
279 int dc
= (desc
[1] & 0x02);
280 unsigned short desc_len
;
282 desc_len
= get_unaligned_be16(&desc
[2]);
283 if (desc_len
!= 0x18) {
284 pr_err("XCOPY segment desc 0x02: Illegal desc_len:"
289 xop
->stdi
= get_unaligned_be16(&desc
[4]);
290 xop
->dtdi
= get_unaligned_be16(&desc
[6]);
291 pr_debug("XCOPY seg desc 0x02: desc_len: %hu stdi: %hu dtdi: %hu, DC: %d\n",
292 desc_len
, xop
->stdi
, xop
->dtdi
, dc
);
294 xop
->nolb
= get_unaligned_be16(&desc
[10]);
295 xop
->src_lba
= get_unaligned_be64(&desc
[12]);
296 xop
->dst_lba
= get_unaligned_be64(&desc
[20]);
297 pr_debug("XCOPY seg desc 0x02: nolb: %hu src_lba: %llu dst_lba: %llu\n",
298 xop
->nolb
, (unsigned long long)xop
->src_lba
,
299 (unsigned long long)xop
->dst_lba
);
302 xop
->dbl
= (desc
[29] << 16) & 0xff;
303 xop
->dbl
|= (desc
[30] << 8) & 0xff;
304 xop
->dbl
|= desc
[31] & 0xff;
306 pr_debug("XCOPY seg desc 0x02: DC=1 w/ dbl: %u\n", xop
->dbl
);
311 static int target_xcopy_parse_segment_descriptors(struct se_cmd
*se_cmd
,
312 struct xcopy_op
*xop
, unsigned char *p
,
315 unsigned char *desc
= p
;
316 unsigned int start
= 0;
317 int offset
= sdll
% XCOPY_SEGMENT_DESC_LEN
, rc
, ret
= 0;
320 pr_err("XCOPY segment descriptor list length is not"
321 " multiple of %d\n", XCOPY_SEGMENT_DESC_LEN
);
325 while (start
< sdll
) {
327 * Check segment descriptor type code for block -> block
331 rc
= target_xcopy_parse_segdesc_02(se_cmd
, xop
, desc
);
336 start
+= XCOPY_SEGMENT_DESC_LEN
;
337 desc
+= XCOPY_SEGMENT_DESC_LEN
;
340 pr_err("XCOPY unspported segment descriptor"
341 "type: 0x%02x\n", desc
[0]);
356 struct xcopy_pt_cmd
{
358 struct se_cmd se_cmd
;
359 struct xcopy_op
*xcopy_op
;
360 struct completion xpt_passthrough_sem
;
363 static struct se_port xcopy_pt_port
;
364 static struct se_portal_group xcopy_pt_tpg
;
365 static struct se_session xcopy_pt_sess
;
366 static struct se_node_acl xcopy_pt_nacl
;
368 static char *xcopy_pt_get_fabric_name(void)
373 static u32
xcopy_pt_get_tag(struct se_cmd
*se_cmd
)
378 static int xcopy_pt_get_cmd_state(struct se_cmd
*se_cmd
)
383 static void xcopy_pt_undepend_remotedev(struct xcopy_op
*xop
)
385 struct configfs_subsystem
*subsys
= target_core_subsystem
[0];
386 struct se_device
*remote_dev
;
388 if (xop
->op_origin
== XCOL_SOURCE_RECV_OP
)
389 remote_dev
= xop
->dst_dev
;
391 remote_dev
= xop
->src_dev
;
393 pr_debug("Calling configfs_undepend_item for subsys: %p"
394 " remote_dev: %p remote_dev->dev_group: %p\n",
395 subsys
, remote_dev
, &remote_dev
->dev_group
.cg_item
);
397 configfs_undepend_item(subsys
, &remote_dev
->dev_group
.cg_item
);
400 static void xcopy_pt_release_cmd(struct se_cmd
*se_cmd
)
402 struct xcopy_pt_cmd
*xpt_cmd
= container_of(se_cmd
,
403 struct xcopy_pt_cmd
, se_cmd
);
405 if (xpt_cmd
->remote_port
)
406 kfree(se_cmd
->se_lun
);
411 static int xcopy_pt_check_stop_free(struct se_cmd
*se_cmd
)
413 struct xcopy_pt_cmd
*xpt_cmd
= container_of(se_cmd
,
414 struct xcopy_pt_cmd
, se_cmd
);
416 complete(&xpt_cmd
->xpt_passthrough_sem
);
420 static int xcopy_pt_write_pending(struct se_cmd
*se_cmd
)
425 static int xcopy_pt_write_pending_status(struct se_cmd
*se_cmd
)
430 static int xcopy_pt_queue_data_in(struct se_cmd
*se_cmd
)
435 static int xcopy_pt_queue_status(struct se_cmd
*se_cmd
)
440 static struct target_core_fabric_ops xcopy_pt_tfo
= {
441 .get_fabric_name
= xcopy_pt_get_fabric_name
,
442 .get_task_tag
= xcopy_pt_get_tag
,
443 .get_cmd_state
= xcopy_pt_get_cmd_state
,
444 .release_cmd
= xcopy_pt_release_cmd
,
445 .check_stop_free
= xcopy_pt_check_stop_free
,
446 .write_pending
= xcopy_pt_write_pending
,
447 .write_pending_status
= xcopy_pt_write_pending_status
,
448 .queue_data_in
= xcopy_pt_queue_data_in
,
449 .queue_status
= xcopy_pt_queue_status
,
456 int target_xcopy_setup_pt(void)
458 xcopy_wq
= alloc_workqueue("xcopy_wq", WQ_MEM_RECLAIM
, 0);
460 pr_err("Unable to allocate xcopy_wq\n");
464 memset(&xcopy_pt_port
, 0, sizeof(struct se_port
));
465 INIT_LIST_HEAD(&xcopy_pt_port
.sep_alua_list
);
466 INIT_LIST_HEAD(&xcopy_pt_port
.sep_list
);
467 mutex_init(&xcopy_pt_port
.sep_tg_pt_md_mutex
);
469 memset(&xcopy_pt_tpg
, 0, sizeof(struct se_portal_group
));
470 INIT_LIST_HEAD(&xcopy_pt_tpg
.se_tpg_node
);
471 INIT_LIST_HEAD(&xcopy_pt_tpg
.acl_node_list
);
472 INIT_LIST_HEAD(&xcopy_pt_tpg
.tpg_sess_list
);
474 xcopy_pt_port
.sep_tpg
= &xcopy_pt_tpg
;
475 xcopy_pt_tpg
.se_tpg_tfo
= &xcopy_pt_tfo
;
477 memset(&xcopy_pt_nacl
, 0, sizeof(struct se_node_acl
));
478 INIT_LIST_HEAD(&xcopy_pt_nacl
.acl_list
);
479 INIT_LIST_HEAD(&xcopy_pt_nacl
.acl_sess_list
);
480 memset(&xcopy_pt_sess
, 0, sizeof(struct se_session
));
481 INIT_LIST_HEAD(&xcopy_pt_sess
.sess_list
);
482 INIT_LIST_HEAD(&xcopy_pt_sess
.sess_acl_list
);
484 xcopy_pt_nacl
.se_tpg
= &xcopy_pt_tpg
;
485 xcopy_pt_nacl
.nacl_sess
= &xcopy_pt_sess
;
487 xcopy_pt_sess
.se_tpg
= &xcopy_pt_tpg
;
488 xcopy_pt_sess
.se_node_acl
= &xcopy_pt_nacl
;
493 void target_xcopy_release_pt(void)
496 destroy_workqueue(xcopy_wq
);
499 static void target_xcopy_setup_pt_port(
500 struct xcopy_pt_cmd
*xpt_cmd
,
501 struct xcopy_op
*xop
,
504 struct se_cmd
*ec_cmd
= xop
->xop_se_cmd
;
505 struct se_cmd
*pt_cmd
= &xpt_cmd
->se_cmd
;
507 if (xop
->op_origin
== XCOL_SOURCE_RECV_OP
) {
509 * Honor destination port reservations for X-COPY PUSH emulation
510 * when CDB is received on local source port, and READs blocks to
511 * WRITE on remote destination port.
514 xpt_cmd
->remote_port
= remote_port
;
515 pt_cmd
->se_lun
->lun_sep
= &xcopy_pt_port
;
516 pr_debug("Setup emulated remote DEST xcopy_pt_port: %p to"
517 " cmd->se_lun->lun_sep for X-COPY data PUSH\n",
518 pt_cmd
->se_lun
->lun_sep
);
520 pt_cmd
->se_lun
= ec_cmd
->se_lun
;
521 pt_cmd
->se_dev
= ec_cmd
->se_dev
;
523 pr_debug("Honoring local SRC port from ec_cmd->se_dev:"
524 " %p\n", pt_cmd
->se_dev
);
525 pt_cmd
->se_lun
= ec_cmd
->se_lun
;
526 pr_debug("Honoring local SRC port from ec_cmd->se_lun: %p\n",
531 * Honor source port reservation for X-COPY PULL emulation
532 * when CDB is received on local desintation port, and READs
533 * blocks from the remote source port to WRITE on local
537 xpt_cmd
->remote_port
= remote_port
;
538 pt_cmd
->se_lun
->lun_sep
= &xcopy_pt_port
;
539 pr_debug("Setup emulated remote SRC xcopy_pt_port: %p to"
540 " cmd->se_lun->lun_sep for X-COPY data PULL\n",
541 pt_cmd
->se_lun
->lun_sep
);
543 pt_cmd
->se_lun
= ec_cmd
->se_lun
;
544 pt_cmd
->se_dev
= ec_cmd
->se_dev
;
546 pr_debug("Honoring local DST port from ec_cmd->se_dev:"
547 " %p\n", pt_cmd
->se_dev
);
548 pt_cmd
->se_lun
= ec_cmd
->se_lun
;
549 pr_debug("Honoring local DST port from ec_cmd->se_lun: %p\n",
555 static int target_xcopy_init_pt_lun(
556 struct xcopy_pt_cmd
*xpt_cmd
,
557 struct xcopy_op
*xop
,
558 struct se_device
*se_dev
,
559 struct se_cmd
*pt_cmd
,
563 * Don't allocate + init an pt_cmd->se_lun if honoring local port for
564 * reservations. The pt_cmd->se_lun pointer will be setup from within
565 * target_xcopy_setup_pt_port()
567 if (remote_port
== false) {
568 pt_cmd
->se_cmd_flags
|= SCF_SE_LUN_CMD
| SCF_CMD_XCOPY_PASSTHROUGH
;
572 pt_cmd
->se_lun
= kzalloc(sizeof(struct se_lun
), GFP_KERNEL
);
573 if (!pt_cmd
->se_lun
) {
574 pr_err("Unable to allocate pt_cmd->se_lun\n");
577 init_completion(&pt_cmd
->se_lun
->lun_shutdown_comp
);
578 INIT_LIST_HEAD(&pt_cmd
->se_lun
->lun_cmd_list
);
579 INIT_LIST_HEAD(&pt_cmd
->se_lun
->lun_acl_list
);
580 spin_lock_init(&pt_cmd
->se_lun
->lun_acl_lock
);
581 spin_lock_init(&pt_cmd
->se_lun
->lun_cmd_lock
);
582 spin_lock_init(&pt_cmd
->se_lun
->lun_sep_lock
);
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
;