aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2012-05-21 20:37:09 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2012-05-21 20:37:09 -0400
commitc9bfa7d75ba7269c97595f03c3152372e8b37823 (patch)
tree18ff08a09721a21fda585c716574344220a50518
parentf4c16c581766a230c02bec4d513b09fe36264ae2 (diff)
parentf80e8ed3951455272c12693e35b259be8eb60b30 (diff)
Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending
Pull scsi-target changes from Nicholas Bellinger: "There has been lots of work in existing code in a number of areas this past cycle. The major highlights have been: * Removal of transport_do_task_sg_chain() from core + fabrics (Roland) * target-core: Removal of se_task abstraction from target-core and enforce hw_max_sectors for pSCSI backends (hch) * Re-factoring of iscsi-target tx immediate/response queues (agrover) * Conversion of iscsi-target back to using target core memory allocation logic (agrover) We've had one last minute iscsi-target patch go into for-next to address a nasty regression bug related to the target core allocation logic conversion from agrover that is not included in friday's linux-next build, but has been included in this series. On the new fabric module code front for-3.5, here is a brief status update for the three currently in flight this round: * usb-gadget target driver: Sebastian Siewior's driver for supporting usb-gadget target mode operation. This will be going out as a separate PULL request from target-pending/usb-target-merge with subsystem maintainer ACKs. There is one minor target-core patch in this series required to function. * sbp ieee-1394/firewire target driver: Chris Boot's driver for supportting the Serial Block Protocol (SBP) across IEEE-1394 Firewire hardware. This will be going out as a separate PULL request from target-pending/sbp-target-merge with two additional drivers/firewire/ patches w/ subsystem maintainer ACKs. * qla2xxx LLD target mode infrastructure changes + tcm_qla2xxx: The Qlogic >= 24xx series HW target mode LLD infrastructure patch-set and tcm_qla2xxx fabric driver. Support for FC target mode using qla2xxx LLD code has been officially submitted by Qlogic to James below, and is currently outstanding but not yet merged into scsi.git/for-next.. [PATCH 00/22] qla2xxx: Updates for scsi "misc" branch http://www.spinics.net/lists/linux-scsi/msg59350.html Note there are *zero* direct dependencies upon this for-next series for the qla2xxx LLD target + tcm_qla2xxx patches submitted above, and over the last days the target mode team has been tracking down an tcm_qla2xxx specific active I/O shutdown bug that appears to now be almost squashed for 3.5-rc-fixes." * 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending: (47 commits) iscsi-target: Fix iov_count calculation bug in iscsit_allocate_iovecs iscsi-target: remove dead code in iscsi_check_valuelist_for_support target: Handle ATA_16 passthrough for pSCSI backend devices target: Add MI_REPORT_TARGET_PGS ext. header + implict_trans_secs attribute target: Fix MAINTENANCE_IN service action CDB checks to use lower 5 bits target: add support for the WRITE_VERIFY command target: make target_put_session void target: cleanup transport_execute_tasks() target: Remove max_sectors device attribute for modern se_task less code target: lock => unlock typo in transport_lun_wait_for_tasks target: Enforce hw_max_sectors for SCF_SCSI_DATA_SG_IO_CDB target: remove the t_se_count field in struct se_cmd target: remove the t_task_cdbs_ex_left field in struct se_cmd target: remove the t_task_cdbs_left field in struct se_cmd target: remove struct se_task target: move the state and execute lists to the command target: simplify command to task linkage target: always allocate a single task target: replace ->execute_task with ->execute_cmd target: remove the task_sectors field in struct se_task ...
Diffstat
-rw-r--r--drivers/infiniband/ulp/srpt/ib_srpt.c10
-rw-r--r--drivers/target/iscsi/iscsi_target.c821
-rw-r--r--drivers/target/iscsi/iscsi_target.h3
-rw-r--r--drivers/target/iscsi/iscsi_target_configfs.c2
-rw-r--r--drivers/target/iscsi/iscsi_target_core.h12
-rw-r--r--drivers/target/iscsi/iscsi_target_datain_values.c35
-rw-r--r--drivers/target/iscsi/iscsi_target_erl0.c31
-rw-r--r--drivers/target/iscsi/iscsi_target_erl1.c23
-rw-r--r--drivers/target/iscsi/iscsi_target_erl2.c28
-rw-r--r--drivers/target/iscsi/iscsi_target_parameters.c17
-rw-r--r--drivers/target/iscsi/iscsi_target_seq_pdu_list.c145
-rw-r--r--drivers/target/iscsi/iscsi_target_seq_pdu_list.h2
-rw-r--r--drivers/target/iscsi/iscsi_target_tmr.c15
-rw-r--r--drivers/target/iscsi/iscsi_target_util.c192
-rw-r--r--drivers/target/iscsi/iscsi_target_util.h3
-rw-r--r--drivers/target/loopback/tcm_loop.c4
-rw-r--r--drivers/target/target_core_alua.c100
-rw-r--r--drivers/target/target_core_alua.h14
-rw-r--r--drivers/target/target_core_cdb.c118
-rw-r--r--drivers/target/target_core_configfs.c25
-rw-r--r--drivers/target/target_core_device.c84
-rw-r--r--drivers/target/target_core_file.c131
-rw-r--r--drivers/target/target_core_file.h4
-rw-r--r--drivers/target/target_core_iblock.c152
-rw-r--r--drivers/target/target_core_iblock.h1
-rw-r--r--drivers/target/target_core_internal.h25
-rw-r--r--drivers/target/target_core_pr.c67
-rw-r--r--drivers/target/target_core_pr.h8
-rw-r--r--drivers/target/target_core_pscsi.c179
-rw-r--r--drivers/target/target_core_pscsi.h1
-rw-r--r--drivers/target/target_core_rd.c168
-rw-r--r--drivers/target/target_core_rd.h20
-rw-r--r--drivers/target/target_core_tmr.c71
-rw-r--r--drivers/target/target_core_tpg.c5
-rw-r--r--drivers/target/target_core_transport.c994
-rw-r--r--drivers/target/tcm_fc/tfc_cmd.c18
-rw-r--r--drivers/target/tcm_fc/tfc_conf.c3
-rw-r--r--drivers/target/tcm_fc/tfc_io.c2
-rw-r--r--include/target/target_core_backend.h16
-rw-r--r--include/target/target_core_base.h59
-rw-r--r--include/target/target_core_fabric.h11
41 files changed, 1315 insertions, 2304 deletions
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.c b/drivers/infiniband/ulp/srpt/ib_srpt.c
index daf21b899999..5f6b7f63cdef 100644
--- a/drivers/infiniband/ulp/srpt/ib_srpt.c
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.c
@@ -1099,9 +1099,8 @@ static int srpt_map_sg_to_ib_sge(struct srpt_rdma_ch *ch,
1099 dir = cmd->data_direction; 1099 dir = cmd->data_direction;
1100 BUG_ON(dir == DMA_NONE); 1100 BUG_ON(dir == DMA_NONE);
1101 1101
1102 transport_do_task_sg_chain(cmd); 1102 ioctx->sg = sg = sg_orig = cmd->t_data_sg;
1103 ioctx->sg = sg = sg_orig = cmd->t_tasks_sg_chained; 1103 ioctx->sg_cnt = sg_cnt = cmd->t_data_nents;
1104 ioctx->sg_cnt = sg_cnt = cmd->t_tasks_sg_chained_no;
1105 1104
1106 count = ib_dma_map_sg(ch->sport->sdev->device, sg, sg_cnt, 1105 count = ib_dma_map_sg(ch->sport->sdev->device, sg, sg_cnt,
1107 opposite_dma_dir(dir)); 1106 opposite_dma_dir(dir));
@@ -1769,7 +1768,7 @@ static int srpt_handle_cmd(struct srpt_rdma_ch *ch,
1769 kref_put(&send_ioctx->kref, srpt_put_send_ioctx_kref); 1768 kref_put(&send_ioctx->kref, srpt_put_send_ioctx_kref);
1770 goto send_sense; 1769 goto send_sense;
1771 } 1770 }
1772 ret = transport_generic_allocate_tasks(cmd, srp_cmd->cdb); 1771 ret = target_setup_cmd_from_cdb(cmd, srp_cmd->cdb);
1773 if (ret < 0) { 1772 if (ret < 0) {
1774 kref_put(&send_ioctx->kref, srpt_put_send_ioctx_kref); 1773 kref_put(&send_ioctx->kref, srpt_put_send_ioctx_kref);
1775 if (cmd->se_cmd_flags & SCF_SCSI_RESERVATION_CONFLICT) { 1774 if (cmd->se_cmd_flags & SCF_SCSI_RESERVATION_CONFLICT) {
@@ -4004,9 +4003,6 @@ static int __init srpt_init_module(void)
4004 4003
4005 srpt_target->tf_ops = srpt_template; 4004 srpt_target->tf_ops = srpt_template;
4006 4005
4007 /* Enable SG chaining */
4008 srpt_target->tf_ops.task_sg_chaining = true;
4009
4010 /* 4006 /*
4011 * Set up default attribute lists. 4007 * Set up default attribute lists.
4012 */ 4008 */
diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index 8b1d5e62ed40..d57d10cb2e47 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -27,8 +27,10 @@
27#include <asm/unaligned.h> 27#include <asm/unaligned.h>
28#include <scsi/scsi_device.h> 28#include <scsi/scsi_device.h>
29#include <scsi/iscsi_proto.h> 29#include <scsi/iscsi_proto.h>
30#include <scsi/scsi_tcq.h>
30#include <target/target_core_base.h> 31#include <target/target_core_base.h>
31#include <target/target_core_fabric.h> 32#include <target/target_core_fabric.h>
33#include <target/target_core_configfs.h>
32 34
33#include "iscsi_target_core.h" 35#include "iscsi_target_core.h"
34#include "iscsi_target_parameters.h" 36#include "iscsi_target_parameters.h"
@@ -593,7 +595,7 @@ static void __exit iscsi_target_cleanup_module(void)
593 kfree(iscsit_global); 595 kfree(iscsit_global);
594} 596}
595 597
596int iscsit_add_reject( 598static int iscsit_add_reject(
597 u8 reason, 599 u8 reason,
598 int fail_conn, 600 int fail_conn,
599 unsigned char *buf, 601 unsigned char *buf,
@@ -622,7 +624,7 @@ int iscsit_add_reject(
622 } 624 }
623 625
624 spin_lock_bh(&conn->cmd_lock); 626 spin_lock_bh(&conn->cmd_lock);
625 list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 627 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
626 spin_unlock_bh(&conn->cmd_lock); 628 spin_unlock_bh(&conn->cmd_lock);
627 629
628 cmd->i_state = ISTATE_SEND_REJECT; 630 cmd->i_state = ISTATE_SEND_REJECT;
@@ -669,7 +671,7 @@ int iscsit_add_reject_from_cmd(
669 671
670 if (add_to_conn) { 672 if (add_to_conn) {
671 spin_lock_bh(&conn->cmd_lock); 673 spin_lock_bh(&conn->cmd_lock);
672 list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 674 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
673 spin_unlock_bh(&conn->cmd_lock); 675 spin_unlock_bh(&conn->cmd_lock);
674 } 676 }
675 677
@@ -685,9 +687,7 @@ int iscsit_add_reject_from_cmd(
685 687
686/* 688/*
687 * Map some portion of the allocated scatterlist to an iovec, suitable for 689 * Map some portion of the allocated scatterlist to an iovec, suitable for
688 * kernel sockets to copy data in/out. This handles both pages and slab-allocated 690 * kernel sockets to copy data in/out.
689 * buffers, since we have been tricky and mapped t_mem_sg to the buffer in
690 * either case (see iscsit_alloc_buffs)
691 */ 691 */
692static int iscsit_map_iovec( 692static int iscsit_map_iovec(
693 struct iscsi_cmd *cmd, 693 struct iscsi_cmd *cmd,
@@ -700,10 +700,9 @@ static int iscsit_map_iovec(
700 unsigned int page_off; 700 unsigned int page_off;
701 701
702 /* 702 /*
703 * We have a private mapping of the allocated pages in t_mem_sg. 703 * We know each entry in t_data_sg contains a page.
704 * At this point, we also know each contains a page.
705 */ 704 */
706 sg = &cmd->t_mem_sg[data_offset / PAGE_SIZE]; 705 sg = &cmd->se_cmd.t_data_sg[data_offset / PAGE_SIZE];
707 page_off = (data_offset % PAGE_SIZE); 706 page_off = (data_offset % PAGE_SIZE);
708 707
709 cmd->first_data_sg = sg; 708 cmd->first_data_sg = sg;
@@ -744,7 +743,7 @@ static void iscsit_ack_from_expstatsn(struct iscsi_conn *conn, u32 exp_statsn)
744 conn->exp_statsn = exp_statsn; 743 conn->exp_statsn = exp_statsn;
745 744
746 spin_lock_bh(&conn->cmd_lock); 745 spin_lock_bh(&conn->cmd_lock);
747 list_for_each_entry(cmd, &conn->conn_cmd_list, i_list) { 746 list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
748 spin_lock(&cmd->istate_lock); 747 spin_lock(&cmd->istate_lock);
749 if ((cmd->i_state == ISTATE_SENT_STATUS) && 748 if ((cmd->i_state == ISTATE_SENT_STATUS) &&
750 (cmd->stat_sn < exp_statsn)) { 749 (cmd->stat_sn < exp_statsn)) {
@@ -761,8 +760,7 @@ static void iscsit_ack_from_expstatsn(struct iscsi_conn *conn, u32 exp_statsn)
761 760
762static int iscsit_allocate_iovecs(struct iscsi_cmd *cmd) 761static int iscsit_allocate_iovecs(struct iscsi_cmd *cmd)
763{ 762{
764 u32 iov_count = (cmd->se_cmd.t_data_nents == 0) ? 1 : 763 u32 iov_count = max(1UL, DIV_ROUND_UP(cmd->se_cmd.data_length, PAGE_SIZE));
765 cmd->se_cmd.t_data_nents;
766 764
767 iov_count += ISCSI_IOV_DATA_BUFFER; 765 iov_count += ISCSI_IOV_DATA_BUFFER;
768 766
@@ -776,64 +774,6 @@ static int iscsit_allocate_iovecs(struct iscsi_cmd *cmd)
776 return 0; 774 return 0;
777} 775}
778 776
779static int iscsit_alloc_buffs(struct iscsi_cmd *cmd)
780{
781 struct scatterlist *sgl;
782 u32 length = cmd->se_cmd.data_length;
783 int nents = DIV_ROUND_UP(length, PAGE_SIZE);
784 int i = 0, j = 0, ret;
785 /*
786 * If no SCSI payload is present, allocate the default iovecs used for
787 * iSCSI PDU Header
788 */
789 if (!length)
790 return iscsit_allocate_iovecs(cmd);
791
792 sgl = kzalloc(sizeof(*sgl) * nents, GFP_KERNEL);
793 if (!sgl)
794 return -ENOMEM;
795
796 sg_init_table(sgl, nents);
797
798 while (length) {
799 int buf_size = min_t(int, length, PAGE_SIZE);
800 struct page *page;
801
802 page = alloc_page(GFP_KERNEL | __GFP_ZERO);
803 if (!page)
804 goto page_alloc_failed;
805
806 sg_set_page(&sgl[i], page, buf_size, 0);
807
808 length -= buf_size;
809 i++;
810 }
811
812 cmd->t_mem_sg = sgl;
813 cmd->t_mem_sg_nents = nents;
814
815 /* BIDI ops not supported */
816
817 /* Tell the core about our preallocated memory */
818 transport_generic_map_mem_to_cmd(&cmd->se_cmd, sgl, nents, NULL, 0);
819 /*
820 * Allocate iovecs for SCSI payload after transport_generic_map_mem_to_cmd
821 * so that cmd->se_cmd.t_tasks_se_num has been set.
822 */
823 ret = iscsit_allocate_iovecs(cmd);
824 if (ret < 0)
825 return -ENOMEM;
826
827 return 0;
828
829page_alloc_failed:
830 while (j < i)
831 __free_page(sg_page(&sgl[j++]));
832
833 kfree(sgl);
834 return -ENOMEM;
835}
836
837static int iscsit_handle_scsi_cmd( 777static int iscsit_handle_scsi_cmd(
838 struct iscsi_conn *conn, 778 struct iscsi_conn *conn,
839 unsigned char *buf) 779 unsigned char *buf)
@@ -842,6 +782,8 @@ static int iscsit_handle_scsi_cmd(
842 int dump_immediate_data = 0, send_check_condition = 0, payload_length; 782 int dump_immediate_data = 0, send_check_condition = 0, payload_length;
843 struct iscsi_cmd *cmd = NULL; 783 struct iscsi_cmd *cmd = NULL;
844 struct iscsi_scsi_req *hdr; 784 struct iscsi_scsi_req *hdr;
785 int iscsi_task_attr;
786 int sam_task_attr;
845 787
846 spin_lock_bh(&conn->sess->session_stats_lock); 788 spin_lock_bh(&conn->sess->session_stats_lock);
847 conn->sess->cmd_pdus++; 789 conn->sess->cmd_pdus++;
@@ -958,15 +900,30 @@ done:
958 (hdr->flags & ISCSI_FLAG_CMD_READ) ? DMA_FROM_DEVICE : 900 (hdr->flags & ISCSI_FLAG_CMD_READ) ? DMA_FROM_DEVICE :
959 DMA_NONE; 901 DMA_NONE;
960 902
961 cmd = iscsit_allocate_se_cmd(conn, hdr->data_length, data_direction, 903 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL);
962 (hdr->flags & ISCSI_FLAG_CMD_ATTR_MASK));
963 if (!cmd) 904 if (!cmd)
964 return iscsit_add_reject(ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1, 905 return iscsit_add_reject(ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1,
965 buf, conn); 906 buf, conn);
966 907
967 pr_debug("Got SCSI Command, ITT: 0x%08x, CmdSN: 0x%08x," 908 cmd->data_direction = data_direction;
968 " ExpXferLen: %u, Length: %u, CID: %hu\n", hdr->itt, 909 iscsi_task_attr = hdr->flags & ISCSI_FLAG_CMD_ATTR_MASK;
969 hdr->cmdsn, hdr->data_length, payload_length, conn->cid); 910 /*
911 * Figure out the SAM Task Attribute for the incoming SCSI CDB
912 */
913 if ((iscsi_task_attr == ISCSI_ATTR_UNTAGGED) ||
914 (iscsi_task_attr == ISCSI_ATTR_SIMPLE))
915 sam_task_attr = MSG_SIMPLE_TAG;
916 else if (iscsi_task_attr == ISCSI_ATTR_ORDERED)
917 sam_task_attr = MSG_ORDERED_TAG;
918 else if (iscsi_task_attr == ISCSI_ATTR_HEAD_OF_QUEUE)
919 sam_task_attr = MSG_HEAD_TAG;
920 else if (iscsi_task_attr == ISCSI_ATTR_ACA)
921 sam_task_attr = MSG_ACA_TAG;
922 else {
923 pr_debug("Unknown iSCSI Task Attribute: 0x%02x, using"
924 " MSG_SIMPLE_TAG\n", iscsi_task_attr);
925 sam_task_attr = MSG_SIMPLE_TAG;
926 }
970 927
971 cmd->iscsi_opcode = ISCSI_OP_SCSI_CMD; 928 cmd->iscsi_opcode = ISCSI_OP_SCSI_CMD;
972 cmd->i_state = ISTATE_NEW_CMD; 929 cmd->i_state = ISTATE_NEW_CMD;
@@ -1003,6 +960,17 @@ done:
1003 } 960 }
1004 961
1005 /* 962 /*
963 * Initialize struct se_cmd descriptor from target_core_mod infrastructure
964 */
965 transport_init_se_cmd(&cmd->se_cmd, &lio_target_fabric_configfs->tf_ops,
966 conn->sess->se_sess, hdr->data_length, cmd->data_direction,
967 sam_task_attr, &cmd->sense_buffer[0]);
968
969 pr_debug("Got SCSI Command, ITT: 0x%08x, CmdSN: 0x%08x,"
970 " ExpXferLen: %u, Length: %u, CID: %hu\n", hdr->itt,
971 hdr->cmdsn, hdr->data_length, payload_length, conn->cid);
972
973 /*
1006 * The CDB is going to an se_device_t. 974 * The CDB is going to an se_device_t.
1007 */ 975 */
1008 ret = transport_lookup_cmd_lun(&cmd->se_cmd, 976 ret = transport_lookup_cmd_lun(&cmd->se_cmd,
@@ -1016,13 +984,8 @@ done:
1016 send_check_condition = 1; 984 send_check_condition = 1;
1017 goto attach_cmd; 985 goto attach_cmd;
1018 } 986 }
1019 /* 987
1020 * The Initiator Node has access to the LUN (the addressing method 988 transport_ret = target_setup_cmd_from_cdb(&cmd->se_cmd, hdr->cdb);
1021 * is handled inside of iscsit_get_lun_for_cmd()). Now it's time to
1022 * allocate 1->N transport tasks (depending on sector count and
1023 * maximum request size the physical HBA(s) can handle.
1024 */
1025 transport_ret = transport_generic_allocate_tasks(&cmd->se_cmd, hdr->cdb);
1026 if (transport_ret == -ENOMEM) { 989 if (transport_ret == -ENOMEM) {
1027 return iscsit_add_reject_from_cmd( 990 return iscsit_add_reject_from_cmd(
1028 ISCSI_REASON_BOOKMARK_NO_RESOURCES, 991 ISCSI_REASON_BOOKMARK_NO_RESOURCES,
@@ -1035,9 +998,7 @@ done:
1035 */ 998 */
1036 send_check_condition = 1; 999 send_check_condition = 1;
1037 } else { 1000 } else {
1038 cmd->data_length = cmd->se_cmd.data_length; 1001 if (iscsit_build_pdu_and_seq_lists(cmd, payload_length) < 0)
1039
1040 if (iscsit_decide_list_to_build(cmd, payload_length) < 0)
1041 return iscsit_add_reject_from_cmd( 1002 return iscsit_add_reject_from_cmd(
1042 ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1003 ISCSI_REASON_BOOKMARK_NO_RESOURCES,
1043 1, 1, buf, cmd); 1004 1, 1, buf, cmd);
@@ -1045,18 +1006,15 @@ done:
1045 1006
1046attach_cmd: 1007attach_cmd:
1047 spin_lock_bh(&conn->cmd_lock); 1008 spin_lock_bh(&conn->cmd_lock);
1048 list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 1009 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
1049 spin_unlock_bh(&conn->cmd_lock); 1010 spin_unlock_bh(&conn->cmd_lock);
1050 /* 1011 /*
1051 * Check if we need to delay processing because of ALUA 1012 * Check if we need to delay processing because of ALUA
1052 * Active/NonOptimized primary access state.. 1013 * Active/NonOptimized primary access state..
1053 */ 1014 */
1054 core_alua_check_nonop_delay(&cmd->se_cmd); 1015 core_alua_check_nonop_delay(&cmd->se_cmd);
1055 /* 1016
1056 * Allocate and setup SGL used with transport_generic_map_mem_to_cmd(). 1017 ret = iscsit_allocate_iovecs(cmd);
1057 * also call iscsit_allocate_iovecs()
1058 */
1059 ret = iscsit_alloc_buffs(cmd);
1060 if (ret < 0) 1018 if (ret < 0)
1061 return iscsit_add_reject_from_cmd( 1019 return iscsit_add_reject_from_cmd(
1062 ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1020 ISCSI_REASON_BOOKMARK_NO_RESOURCES,
@@ -1303,10 +1261,10 @@ static int iscsit_handle_data_out(struct iscsi_conn *conn, unsigned char *buf)
1303 se_cmd = &cmd->se_cmd; 1261 se_cmd = &cmd->se_cmd;
1304 iscsit_mod_dataout_timer(cmd); 1262 iscsit_mod_dataout_timer(cmd);
1305 1263
1306 if ((hdr->offset + payload_length) > cmd->data_length) { 1264 if ((hdr->offset + payload_length) > cmd->se_cmd.data_length) {
1307 pr_err("DataOut Offset: %u, Length %u greater than" 1265 pr_err("DataOut Offset: %u, Length %u greater than"
1308 " iSCSI Command EDTL %u, protocol error.\n", 1266 " iSCSI Command EDTL %u, protocol error.\n",
1309 hdr->offset, payload_length, cmd->data_length); 1267 hdr->offset, payload_length, cmd->se_cmd.data_length);
1310 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID, 1268 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID,
1311 1, 0, buf, cmd); 1269 1, 0, buf, cmd);
1312 } 1270 }
@@ -1442,7 +1400,7 @@ static int iscsit_handle_data_out(struct iscsi_conn *conn, unsigned char *buf)
1442 return 0; 1400 return 0;
1443 else if (ret == DATAOUT_SEND_R2T) { 1401 else if (ret == DATAOUT_SEND_R2T) {
1444 iscsit_set_dataout_sequence_values(cmd); 1402 iscsit_set_dataout_sequence_values(cmd);
1445 iscsit_build_r2ts_for_cmd(cmd, conn, 0); 1403 iscsit_build_r2ts_for_cmd(cmd, conn, false);
1446 } else if (ret == DATAOUT_SEND_TO_TRANSPORT) { 1404 } else if (ret == DATAOUT_SEND_TO_TRANSPORT) {
1447 /* 1405 /*
1448 * Handle extra special case for out of order 1406 * Handle extra special case for out of order
@@ -1617,7 +1575,7 @@ static int iscsit_handle_nop_out(
1617 * Initiator is expecting a NopIN ping reply, 1575 * Initiator is expecting a NopIN ping reply,
1618 */ 1576 */
1619 spin_lock_bh(&conn->cmd_lock); 1577 spin_lock_bh(&conn->cmd_lock);
1620 list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 1578 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
1621 spin_unlock_bh(&conn->cmd_lock); 1579 spin_unlock_bh(&conn->cmd_lock);
1622 1580
1623 iscsit_ack_from_expstatsn(conn, hdr->exp_statsn); 1581 iscsit_ack_from_expstatsn(conn, hdr->exp_statsn);
@@ -1723,10 +1681,75 @@ static int iscsit_handle_task_mgt_cmd(
1723 (hdr->refcmdsn != ISCSI_RESERVED_TAG)) 1681 (hdr->refcmdsn != ISCSI_RESERVED_TAG))
1724 hdr->refcmdsn = ISCSI_RESERVED_TAG; 1682 hdr->refcmdsn = ISCSI_RESERVED_TAG;
1725 1683
1726 cmd = iscsit_allocate_se_cmd_for_tmr(conn, function); 1684 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL);
1727 if (!cmd) 1685 if (!cmd)
1728 return iscsit_add_reject(ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1686 return iscsit_add_reject(ISCSI_REASON_BOOKMARK_NO_RESOURCES,
1729 1, buf, conn); 1687 1, buf, conn);
1688
1689 cmd->data_direction = DMA_NONE;
1690
1691 cmd->tmr_req = kzalloc(sizeof(struct iscsi_tmr_req), GFP_KERNEL);
1692 if (!cmd->tmr_req) {
1693 pr_err("Unable to allocate memory for"
1694 " Task Management command!\n");
1695 return iscsit_add_reject_from_cmd(
1696 ISCSI_REASON_BOOKMARK_NO_RESOURCES,
1697 1, 1, buf, cmd);
1698 }
1699
1700 /*
1701 * TASK_REASSIGN for ERL=2 / connection stays inside of
1702 * LIO-Target $FABRIC_MOD
1703 */
1704 if (function != ISCSI_TM_FUNC_TASK_REASSIGN) {
1705
1706 u8 tcm_function;
1707 int ret;
1708
1709 transport_init_se_cmd(&cmd->se_cmd,
1710 &lio_target_fabric_configfs->tf_ops,
1711 conn->sess->se_sess, 0, DMA_NONE,
1712 MSG_SIMPLE_TAG, &cmd->sense_buffer[0]);
1713
1714 switch (function) {
1715 case ISCSI_TM_FUNC_ABORT_TASK:
1716 tcm_function = TMR_ABORT_TASK;
1717 break;
1718 case ISCSI_TM_FUNC_ABORT_TASK_SET:
1719 tcm_function = TMR_ABORT_TASK_SET;
1720 break;
1721 case ISCSI_TM_FUNC_CLEAR_ACA:
1722 tcm_function = TMR_CLEAR_ACA;
1723 break;
1724 case ISCSI_TM_FUNC_CLEAR_TASK_SET:
1725 tcm_function = TMR_CLEAR_TASK_SET;
1726 break;
1727 case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET:
1728 tcm_function = TMR_LUN_RESET;
1729 break;
1730 case ISCSI_TM_FUNC_TARGET_WARM_RESET:
1731 tcm_function = TMR_TARGET_WARM_RESET;
1732 break;
1733 case ISCSI_TM_FUNC_TARGET_COLD_RESET:
1734 tcm_function = TMR_TARGET_COLD_RESET;
1735 break;
1736 default:
1737 pr_err("Unknown iSCSI TMR Function:"
1738 " 0x%02x\n", function);
1739 return iscsit_add_reject_from_cmd(
1740 ISCSI_REASON_BOOKMARK_NO_RESOURCES,
1741 1, 1, buf, cmd);
1742 }
1743
1744 ret = core_tmr_alloc_req(&cmd->se_cmd, cmd->tmr_req,
1745 tcm_function, GFP_KERNEL);
1746 if (ret < 0)
1747 return iscsit_add_reject_from_cmd(
1748 ISCSI_REASON_BOOKMARK_NO_RESOURCES,
1749 1, 1, buf, cmd);
1750
1751 cmd->tmr_req->se_tmr_req = cmd->se_cmd.se_tmr_req;
1752 }
1730 1753
1731 cmd->iscsi_opcode = ISCSI_OP_SCSI_TMFUNC; 1754 cmd->iscsi_opcode = ISCSI_OP_SCSI_TMFUNC;
1732 cmd->i_state = ISTATE_SEND_TASKMGTRSP; 1755 cmd->i_state = ISTATE_SEND_TASKMGTRSP;
@@ -1804,7 +1827,7 @@ static int iscsit_handle_task_mgt_cmd(
1804 se_tmr->call_transport = 1; 1827 se_tmr->call_transport = 1;
1805attach: 1828attach:
1806 spin_lock_bh(&conn->cmd_lock); 1829 spin_lock_bh(&conn->cmd_lock);
1807 list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 1830 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
1808 spin_unlock_bh(&conn->cmd_lock); 1831 spin_unlock_bh(&conn->cmd_lock);
1809 1832
1810 if (!(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 1833 if (!(hdr->opcode & ISCSI_OP_IMMEDIATE)) {
@@ -1980,7 +2003,7 @@ static int iscsit_handle_text_cmd(
1980 cmd->data_direction = DMA_NONE; 2003 cmd->data_direction = DMA_NONE;
1981 2004
1982 spin_lock_bh(&conn->cmd_lock); 2005 spin_lock_bh(&conn->cmd_lock);
1983 list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 2006 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
1984 spin_unlock_bh(&conn->cmd_lock); 2007 spin_unlock_bh(&conn->cmd_lock);
1985 2008
1986 iscsit_ack_from_expstatsn(conn, hdr->exp_statsn); 2009 iscsit_ack_from_expstatsn(conn, hdr->exp_statsn);
@@ -2168,7 +2191,7 @@ static int iscsit_handle_logout_cmd(
2168 logout_remove = 1; 2191 logout_remove = 1;
2169 2192
2170 spin_lock_bh(&conn->cmd_lock); 2193 spin_lock_bh(&conn->cmd_lock);
2171 list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 2194 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
2172 spin_unlock_bh(&conn->cmd_lock); 2195 spin_unlock_bh(&conn->cmd_lock);
2173 2196
2174 if (reason_code != ISCSI_LOGOUT_REASON_RECOVERY) 2197 if (reason_code != ISCSI_LOGOUT_REASON_RECOVERY)
@@ -2178,7 +2201,7 @@ static int iscsit_handle_logout_cmd(
2178 * Immediate commands are executed, well, immediately. 2201 * Immediate commands are executed, well, immediately.
2179 * Non-Immediate Logout Commands are executed in CmdSN order. 2202 * Non-Immediate Logout Commands are executed in CmdSN order.
2180 */ 2203 */
2181 if (hdr->opcode & ISCSI_OP_IMMEDIATE) { 2204 if (cmd->immediate_cmd) {
2182 int ret = iscsit_execute_cmd(cmd, 0); 2205 int ret = iscsit_execute_cmd(cmd, 0);
2183 2206
2184 if (ret < 0) 2207 if (ret < 0)
@@ -2336,7 +2359,7 @@ static int iscsit_handle_immediate_data(
2336 2359
2337 cmd->write_data_done += length; 2360 cmd->write_data_done += length;
2338 2361
2339 if (cmd->write_data_done == cmd->data_length) { 2362 if (cmd->write_data_done == cmd->se_cmd.data_length) {
2340 spin_lock_bh(&cmd->istate_lock); 2363 spin_lock_bh(&cmd->istate_lock);
2341 cmd->cmd_flags |= ICF_GOT_LAST_DATAOUT; 2364 cmd->cmd_flags |= ICF_GOT_LAST_DATAOUT;
2342 cmd->i_state = ISTATE_RECEIVED_LAST_DATAOUT; 2365 cmd->i_state = ISTATE_RECEIVED_LAST_DATAOUT;
@@ -2381,7 +2404,7 @@ static void iscsit_build_conn_drop_async_message(struct iscsi_conn *conn)
2381 cmd->i_state = ISTATE_SEND_ASYNCMSG; 2404 cmd->i_state = ISTATE_SEND_ASYNCMSG;
2382 2405
2383 spin_lock_bh(&conn_p->cmd_lock); 2406 spin_lock_bh(&conn_p->cmd_lock);
2384 list_add_tail(&cmd->i_list, &conn_p->conn_cmd_list); 2407 list_add_tail(&cmd->i_conn_node, &conn_p->conn_cmd_list);
2385 spin_unlock_bh(&conn_p->cmd_lock); 2408 spin_unlock_bh(&conn_p->cmd_lock);
2386 2409
2387 iscsit_add_cmd_to_response_queue(cmd, conn_p, cmd->i_state); 2410 iscsit_add_cmd_to_response_queue(cmd, conn_p, cmd->i_state);
@@ -2434,10 +2457,19 @@ static int iscsit_send_conn_drop_async_message(
2434 return 0; 2457 return 0;
2435} 2458}
2436 2459
2460static void iscsit_tx_thread_wait_for_tcp(struct iscsi_conn *conn)
2461{
2462 if ((conn->sock->sk->sk_shutdown & SEND_SHUTDOWN) ||
2463 (conn->sock->sk->sk_shutdown & RCV_SHUTDOWN)) {
2464 wait_for_completion_interruptible_timeout(
2465 &conn->tx_half_close_comp,
2466 ISCSI_TX_THREAD_TCP_TIMEOUT * HZ);
2467 }
2468}
2469
2437static int iscsit_send_data_in( 2470static int iscsit_send_data_in(
2438 struct iscsi_cmd *cmd, 2471 struct iscsi_cmd *cmd,
2439 struct iscsi_conn *conn, 2472 struct iscsi_conn *conn)
2440 int *eodr)
2441{ 2473{
2442 int iov_ret = 0, set_statsn = 0; 2474 int iov_ret = 0, set_statsn = 0;
2443 u32 iov_count = 0, tx_size = 0; 2475 u32 iov_count = 0, tx_size = 0;
@@ -2445,6 +2477,8 @@ static int iscsit_send_data_in(
2445 struct iscsi_datain_req *dr; 2477 struct iscsi_datain_req *dr;
2446 struct iscsi_data_rsp *hdr; 2478 struct iscsi_data_rsp *hdr;
2447 struct kvec *iov; 2479 struct kvec *iov;
2480 int eodr = 0;
2481 int ret;
2448 2482
2449 memset(&datain, 0, sizeof(struct iscsi_datain)); 2483 memset(&datain, 0, sizeof(struct iscsi_datain));
2450 dr = iscsit_get_datain_values(cmd, &datain); 2484 dr = iscsit_get_datain_values(cmd, &datain);
@@ -2457,11 +2491,11 @@ static int iscsit_send_data_in(
2457 /* 2491 /*
2458 * Be paranoid and double check the logic for now. 2492 * Be paranoid and double check the logic for now.
2459 */ 2493 */
2460 if ((datain.offset + datain.length) > cmd->data_length) { 2494 if ((datain.offset + datain.length) > cmd->se_cmd.data_length) {
2461 pr_err("Command ITT: 0x%08x, datain.offset: %u and" 2495 pr_err("Command ITT: 0x%08x, datain.offset: %u and"
2462 " datain.length: %u exceeds cmd->data_length: %u\n", 2496 " datain.length: %u exceeds cmd->data_length: %u\n",
2463 cmd->init_task_tag, datain.offset, datain.length, 2497 cmd->init_task_tag, datain.offset, datain.length,
2464 cmd->data_length); 2498 cmd->se_cmd.data_length);
2465 return -1; 2499 return -1;
2466 } 2500 }
2467 2501
@@ -2577,13 +2611,26 @@ static int iscsit_send_data_in(
2577 cmd->init_task_tag, ntohl(hdr->statsn), ntohl(hdr->datasn), 2611 cmd->init_task_tag, ntohl(hdr->statsn), ntohl(hdr->datasn),
2578 ntohl(hdr->offset), datain.length, conn->cid); 2612 ntohl(hdr->offset), datain.length, conn->cid);
2579 2613
2614 /* sendpage is preferred but can't insert markers */
2615 if (!conn->conn_ops->IFMarker)
2616 ret = iscsit_fe_sendpage_sg(cmd, conn);
2617 else
2618 ret = iscsit_send_tx_data(cmd, conn, 0);
2619
2620 iscsit_unmap_iovec(cmd);
2621
2622 if (ret < 0) {
2623 iscsit_tx_thread_wait_for_tcp(conn);
2624 return ret;
2625 }
2626
2580 if (dr->dr_complete) { 2627 if (dr->dr_complete) {
2581 *eodr = (cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ? 2628 eodr = (cmd->se_cmd.se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) ?
2582 2 : 1; 2629 2 : 1;
2583 iscsit_free_datain_req(cmd, dr); 2630 iscsit_free_datain_req(cmd, dr);
2584 } 2631 }
2585 2632
2586 return 0; 2633 return eodr;
2587} 2634}
2588 2635
2589static int iscsit_send_logout_response( 2636static int iscsit_send_logout_response(
@@ -2715,6 +2762,7 @@ static int iscsit_send_unsolicited_nopin(
2715{ 2762{
2716 int tx_size = ISCSI_HDR_LEN; 2763 int tx_size = ISCSI_HDR_LEN;
2717 struct iscsi_nopin *hdr; 2764 struct iscsi_nopin *hdr;
2765 int ret;
2718 2766
2719 hdr = (struct iscsi_nopin *) cmd->pdu; 2767 hdr = (struct iscsi_nopin *) cmd->pdu;
2720 memset(hdr, 0, ISCSI_HDR_LEN); 2768 memset(hdr, 0, ISCSI_HDR_LEN);
@@ -2747,6 +2795,17 @@ static int iscsit_send_unsolicited_nopin(
2747 pr_debug("Sending Unsolicited NOPIN TTT: 0x%08x StatSN:" 2795 pr_debug("Sending Unsolicited NOPIN TTT: 0x%08x StatSN:"
2748 " 0x%08x CID: %hu\n", hdr->ttt, cmd->stat_sn, conn->cid); 2796 " 0x%08x CID: %hu\n", hdr->ttt, cmd->stat_sn, conn->cid);
2749 2797
2798 ret = iscsit_send_tx_data(cmd, conn, 1);
2799 if (ret < 0) {
2800 iscsit_tx_thread_wait_for_tcp(conn);
2801 return ret;
2802 }
2803
2804 spin_lock_bh(&cmd->istate_lock);
2805 cmd->i_state = want_response ?
2806 ISTATE_SENT_NOPIN_WANT_RESPONSE : ISTATE_SENT_STATUS;
2807 spin_unlock_bh(&cmd->istate_lock);
2808
2750 return 0; 2809 return 0;
2751} 2810}
2752 2811
@@ -2837,13 +2896,14 @@ static int iscsit_send_nopin_response(
2837 return 0; 2896 return 0;
2838} 2897}
2839 2898
2840int iscsit_send_r2t( 2899static int iscsit_send_r2t(
2841 struct iscsi_cmd *cmd, 2900 struct iscsi_cmd *cmd,
2842 struct iscsi_conn *conn) 2901 struct iscsi_conn *conn)
2843{ 2902{
2844 int tx_size = 0; 2903 int tx_size = 0;
2845 struct iscsi_r2t *r2t; 2904 struct iscsi_r2t *r2t;
2846 struct iscsi_r2t_rsp *hdr; 2905 struct iscsi_r2t_rsp *hdr;
2906 int ret;
2847 2907
2848 r2t = iscsit_get_r2t_from_list(cmd); 2908 r2t = iscsit_get_r2t_from_list(cmd);
2849 if (!r2t) 2909 if (!r2t)
@@ -2899,19 +2959,27 @@ int iscsit_send_r2t(
2899 r2t->sent_r2t = 1; 2959 r2t->sent_r2t = 1;
2900 spin_unlock_bh(&cmd->r2t_lock); 2960 spin_unlock_bh(&cmd->r2t_lock);
2901 2961
2962 ret = iscsit_send_tx_data(cmd, conn, 1);
2963 if (ret < 0) {
2964 iscsit_tx_thread_wait_for_tcp(conn);
2965 return ret;
2966 }
2967
2968 spin_lock_bh(&cmd->dataout_timeout_lock);
2969 iscsit_start_dataout_timer(cmd, conn);
2970 spin_unlock_bh(&cmd->dataout_timeout_lock);
2971
2902 return 0; 2972 return 0;
2903} 2973}
2904 2974
2905/* 2975/*
2906 * type 0: Normal Operation. 2976 * @recovery: If called from iscsi_task_reassign_complete_write() for
2907 * type 1: Called from Storage Transport. 2977 * connection recovery.
2908 * type 2: Called from iscsi_task_reassign_complete_write() for
2909 * connection recovery.
2910 */ 2978 */
2911int iscsit_build_r2ts_for_cmd( 2979int iscsit_build_r2ts_for_cmd(
2912 struct iscsi_cmd *cmd, 2980 struct iscsi_cmd *cmd,
2913 struct iscsi_conn *conn, 2981 struct iscsi_conn *conn,
2914 int type) 2982 bool recovery)
2915{ 2983{
2916 int first_r2t = 1; 2984 int first_r2t = 1;
2917 u32 offset = 0, xfer_len = 0; 2985 u32 offset = 0, xfer_len = 0;
@@ -2922,32 +2990,37 @@ int iscsit_build_r2ts_for_cmd(
2922 return 0; 2990 return 0;
2923 } 2991 }
2924 2992
2925 if (conn->sess->sess_ops->DataSequenceInOrder && (type != 2)) 2993 if (conn->sess->sess_ops->DataSequenceInOrder &&
2926 if (cmd->r2t_offset < cmd->write_data_done) 2994 !recovery)
2927 cmd->r2t_offset = cmd->write_data_done; 2995 cmd->r2t_offset = max(cmd->r2t_offset, cmd->write_data_done);
2928 2996
2929 while (cmd->outstanding_r2ts < conn->sess->sess_ops->MaxOutstandingR2T) { 2997 while (cmd->outstanding_r2ts < conn->sess->sess_ops->MaxOutstandingR2T) {
2930 if (conn->sess->sess_ops->DataSequenceInOrder) { 2998 if (conn->sess->sess_ops->DataSequenceInOrder) {
2931 offset = cmd->r2t_offset; 2999 offset = cmd->r2t_offset;
2932 3000
2933 if (first_r2t && (type == 2)) { 3001 if (first_r2t && recovery) {
2934 xfer_len = ((offset + 3002 int new_data_end = offset +
2935 (conn->sess->sess_ops->MaxBurstLength - 3003 conn->sess->sess_ops->MaxBurstLength -
2936 cmd->next_burst_len) > 3004 cmd->next_burst_len;
2937 cmd->data_length) ? 3005
2938 (cmd->data_length - offset) : 3006 if (new_data_end > cmd->se_cmd.data_length)
2939 (conn->sess->sess_ops->MaxBurstLength - 3007 xfer_len = cmd->se_cmd.data_length - offset;
2940 cmd->next_burst_len)); 3008 else
3009 xfer_len =
3010 conn->sess->sess_ops->MaxBurstLength -
3011 cmd->next_burst_len;
2941 } else { 3012 } else {
2942 xfer_len = ((offset + 3013 int new_data_end = offset +
2943 conn->sess->sess_ops->MaxBurstLength) > 3014 conn->sess->sess_ops->MaxBurstLength;
2944 cmd->data_length) ? 3015
2945 (cmd->data_length - offset) : 3016 if (new_data_end > cmd->se_cmd.data_length)
2946 conn->sess->sess_ops->MaxBurstLength; 3017 xfer_len = cmd->se_cmd.data_length - offset;
3018 else
3019 xfer_len = conn->sess->sess_ops->MaxBurstLength;
2947 } 3020 }
2948 cmd->r2t_offset += xfer_len; 3021 cmd->r2t_offset += xfer_len;
2949 3022
2950 if (cmd->r2t_offset == cmd->data_length) 3023 if (cmd->r2t_offset == cmd->se_cmd.data_length)
2951 cmd->cmd_flags |= ICF_SENT_LAST_R2T; 3024 cmd->cmd_flags |= ICF_SENT_LAST_R2T;
2952 } else { 3025 } else {
2953 struct iscsi_seq *seq; 3026 struct iscsi_seq *seq;
@@ -3179,6 +3252,8 @@ static bool iscsit_check_inaddr_any(struct iscsi_np *np)
3179 return ret; 3252 return ret;
3180} 3253}
3181 3254
3255#define SENDTARGETS_BUF_LIMIT 32768U
3256
3182static int iscsit_build_sendtargets_response(struct iscsi_cmd *cmd) 3257static int iscsit_build_sendtargets_response(struct iscsi_cmd *cmd)
3183{ 3258{
3184 char *payload = NULL; 3259 char *payload = NULL;
@@ -3187,12 +3262,10 @@ static int iscsit_build_sendtargets_response(struct iscsi_cmd *cmd)
3187 struct iscsi_tiqn *tiqn; 3262 struct iscsi_tiqn *tiqn;
3188 struct iscsi_tpg_np *tpg_np; 3263 struct iscsi_tpg_np *tpg_np;
3189 int buffer_len, end_of_buf = 0, len = 0, payload_len = 0; 3264 int buffer_len, end_of_buf = 0, len = 0, payload_len = 0;
3190 unsigned char buf[256]; 3265 unsigned char buf[ISCSI_IQN_LEN+12]; /* iqn + "TargetName=" + \0 */
3191 3266
3192 buffer_len = (conn->conn_ops->MaxRecvDataSegmentLength > 32768) ? 3267 buffer_len = max(conn->conn_ops->MaxRecvDataSegmentLength,
3193 32768 : conn->conn_ops->MaxRecvDataSegmentLength; 3268 SENDTARGETS_BUF_LIMIT);
3194
3195 memset(buf, 0, 256);
3196 3269
3197 payload = kzalloc(buffer_len, GFP_KERNEL); 3270 payload = kzalloc(buffer_len, GFP_KERNEL);
3198 if (!payload) { 3271 if (!payload) {
@@ -3408,18 +3481,6 @@ static int iscsit_send_reject(
3408 return 0; 3481 return 0;
3409} 3482}
3410 3483
3411static void iscsit_tx_thread_wait_for_tcp(struct iscsi_conn *conn)
3412{
3413 if ((conn->sock->sk->sk_shutdown & SEND_SHUTDOWN) ||
3414 (conn->sock->sk->sk_shutdown & RCV_SHUTDOWN)) {
3415 wait_for_completion_interruptible_timeout(
3416 &conn->tx_half_close_comp,
3417 ISCSI_TX_THREAD_TCP_TIMEOUT * HZ);
3418 }
3419}
3420
3421#ifdef CONFIG_SMP
3422
3423void iscsit_thread_get_cpumask(struct iscsi_conn *conn) 3484void iscsit_thread_get_cpumask(struct iscsi_conn *conn)
3424{ 3485{
3425 struct iscsi_thread_set *ts = conn->thread_set; 3486 struct iscsi_thread_set *ts = conn->thread_set;
@@ -3433,10 +3494,6 @@ void iscsit_thread_get_cpumask(struct iscsi_conn *conn)
3433 * execute upon. 3494 * execute upon.
3434 */ 3495 */
3435 ord = ts->thread_id % cpumask_weight(cpu_online_mask); 3496 ord = ts->thread_id % cpumask_weight(cpu_online_mask);
3436#if 0
3437 pr_debug(">>>>>>>>>>>>>>>>>>>> Generated ord: %d from"
3438 " thread_id: %d\n", ord, ts->thread_id);
3439#endif
3440 for_each_online_cpu(cpu) { 3497 for_each_online_cpu(cpu) {
3441 if (ord-- == 0) { 3498 if (ord-- == 0) {
3442 cpumask_set_cpu(cpu, conn->conn_cpumask); 3499 cpumask_set_cpu(cpu, conn->conn_cpumask);
@@ -3476,34 +3533,196 @@ static inline void iscsit_thread_check_cpumask(
3476 */ 3533 */
3477 memset(buf, 0, 128); 3534 memset(buf, 0, 128);
3478 cpumask_scnprintf(buf, 128, conn->conn_cpumask); 3535 cpumask_scnprintf(buf, 128, conn->conn_cpumask);
3479#if 0
3480 pr_debug(">>>>>>>>>>>>>> Calling set_cpus_allowed_ptr():"
3481 " %s for %s\n", buf, p->comm);
3482#endif
3483 set_cpus_allowed_ptr(p, conn->conn_cpumask); 3536 set_cpus_allowed_ptr(p, conn->conn_cpumask);
3484} 3537}
3485 3538
3486#else 3539static int handle_immediate_queue(struct iscsi_conn *conn)
3487
3488void iscsit_thread_get_cpumask(struct iscsi_conn *conn)
3489{ 3540{
3490 return; 3541 struct iscsi_queue_req *qr;
3542 struct iscsi_cmd *cmd;
3543 u8 state;
3544 int ret;
3545
3546 while ((qr = iscsit_get_cmd_from_immediate_queue(conn))) {
3547 atomic_set(&conn->check_immediate_queue, 0);
3548 cmd = qr->cmd;
3549 state = qr->state;
3550 kmem_cache_free(lio_qr_cache, qr);
3551
3552 switch (state) {
3553 case ISTATE_SEND_R2T:
3554 ret = iscsit_send_r2t(cmd, conn);
3555 if (ret < 0)
3556 goto err;
3557 break;
3558 case ISTATE_REMOVE:
3559 if (cmd->data_direction == DMA_TO_DEVICE)
3560 iscsit_stop_dataout_timer(cmd);
3561
3562 spin_lock_bh(&conn->cmd_lock);
3563 list_del(&cmd->i_conn_node);
3564 spin_unlock_bh(&conn->cmd_lock);
3565
3566 iscsit_free_cmd(cmd);
3567 continue;
3568 case ISTATE_SEND_NOPIN_WANT_RESPONSE:
3569 iscsit_mod_nopin_response_timer(conn);
3570 ret = iscsit_send_unsolicited_nopin(cmd,
3571 conn, 1);
3572 if (ret < 0)
3573 goto err;
3574 break;
3575 case ISTATE_SEND_NOPIN_NO_RESPONSE:
3576 ret = iscsit_send_unsolicited_nopin(cmd,
3577 conn, 0);
3578 if (ret < 0)
3579 goto err;
3580 break;
3581 default:
3582 pr_err("Unknown Opcode: 0x%02x ITT:"
3583 " 0x%08x, i_state: %d on CID: %hu\n",
3584 cmd->iscsi_opcode, cmd->init_task_tag, state,
3585 conn->cid);
3586 goto err;
3587 }
3588 }
3589
3590 return 0;
3591
3592err:
3593 return -1;
3491} 3594}
3492 3595
3493#define iscsit_thread_check_cpumask(X, Y, Z) ({}) 3596static int handle_response_queue(struct iscsi_conn *conn)
3494#endif /* CONFIG_SMP */ 3597{
3598 struct iscsi_queue_req *qr;
3599 struct iscsi_cmd *cmd;
3600 u8 state;
3601 int ret;
3602
3603 while ((qr = iscsit_get_cmd_from_response_queue(conn))) {
3604 cmd = qr->cmd;
3605 state = qr->state;
3606 kmem_cache_free(lio_qr_cache, qr);
3607
3608check_rsp_state:
3609 switch (state) {
3610 case ISTATE_SEND_DATAIN:
3611 ret = iscsit_send_data_in(cmd, conn);
3612 if (ret < 0)
3613 goto err;
3614 else if (!ret)
3615 /* more drs */
3616 goto check_rsp_state;
3617 else if (ret == 1) {
3618 /* all done */
3619 spin_lock_bh(&cmd->istate_lock);
3620 cmd->i_state = ISTATE_SENT_STATUS;
3621 spin_unlock_bh(&cmd->istate_lock);
3622 continue;
3623 } else if (ret == 2) {
3624 /* Still must send status,
3625 SCF_TRANSPORT_TASK_SENSE was set */
3626 spin_lock_bh(&cmd->istate_lock);
3627 cmd->i_state = ISTATE_SEND_STATUS;
3628 spin_unlock_bh(&cmd->istate_lock);
3629 state = ISTATE_SEND_STATUS;
3630 goto check_rsp_state;
3631 }
3632
3633 break;
3634 case ISTATE_SEND_STATUS:
3635 case ISTATE_SEND_STATUS_RECOVERY:
3636 ret = iscsit_send_status(cmd, conn);
3637 break;
3638 case ISTATE_SEND_LOGOUTRSP:
3639 ret = iscsit_send_logout_response(cmd, conn);
3640 break;
3641 case ISTATE_SEND_ASYNCMSG:
3642 ret = iscsit_send_conn_drop_async_message(
3643 cmd, conn);
3644 break;
3645 case ISTATE_SEND_NOPIN:
3646 ret = iscsit_send_nopin_response(cmd, conn);
3647 break;
3648 case ISTATE_SEND_REJECT:
3649 ret = iscsit_send_reject(cmd, conn);
3650 break;
3651 case ISTATE_SEND_TASKMGTRSP:
3652 ret = iscsit_send_task_mgt_rsp(cmd, conn);
3653 if (ret != 0)
3654 break;
3655 ret = iscsit_tmr_post_handler(cmd, conn);
3656 if (ret != 0)
3657 iscsit_fall_back_to_erl0(conn->sess);
3658 break;
3659 case ISTATE_SEND_TEXTRSP:
3660 ret = iscsit_send_text_rsp(cmd, conn);
3661 break;
3662 default:
3663 pr_err("Unknown Opcode: 0x%02x ITT:"
3664 " 0x%08x, i_state: %d on CID: %hu\n",
3665 cmd->iscsi_opcode, cmd->init_task_tag,
3666 state, conn->cid);
3667 goto err;
3668 }
3669 if (ret < 0)
3670 goto err;
3671
3672 if (iscsit_send_tx_data(cmd, conn, 1) < 0) {
3673 iscsit_tx_thread_wait_for_tcp(conn);
3674 iscsit_unmap_iovec(cmd);
3675 goto err;
3676 }
3677 iscsit_unmap_iovec(cmd);
3678
3679 switch (state) {
3680 case ISTATE_SEND_LOGOUTRSP:
3681 if (!iscsit_logout_post_handler(cmd, conn))
3682 goto restart;
3683 /* fall through */
3684 case ISTATE_SEND_STATUS:
3685 case ISTATE_SEND_ASYNCMSG:
3686 case ISTATE_SEND_NOPIN:
3687 case ISTATE_SEND_STATUS_RECOVERY:
3688 case ISTATE_SEND_TEXTRSP:
3689 case ISTATE_SEND_TASKMGTRSP:
3690 spin_lock_bh(&cmd->istate_lock);
3691 cmd->i_state = ISTATE_SENT_STATUS;
3692 spin_unlock_bh(&cmd->istate_lock);
3693 break;
3694 case ISTATE_SEND_REJECT:
3695 if (cmd->cmd_flags & ICF_REJECT_FAIL_CONN) {
3696 cmd->cmd_flags &= ~ICF_REJECT_FAIL_CONN;
3697 complete(&cmd->reject_comp);
3698 goto err;
3699 }
3700 complete(&cmd->reject_comp);
3701 break;
3702 default:
3703 pr_err("Unknown Opcode: 0x%02x ITT:"
3704 " 0x%08x, i_state: %d on CID: %hu\n",
3705 cmd->iscsi_opcode, cmd->init_task_tag,
3706 cmd->i_state, conn->cid);
3707 goto err;
3708 }
3709
3710 if (atomic_read(&conn->check_immediate_queue))
3711 break;
3712 }
3713
3714 return 0;
3715
3716err:
3717 return -1;
3718restart:
3719 return -EAGAIN;
3720}
3495 3721
3496int iscsi_target_tx_thread(void *arg) 3722int iscsi_target_tx_thread(void *arg)
3497{ 3723{
3498 u8 state;
3499 int eodr = 0;
3500 int ret = 0; 3724 int ret = 0;
3501 int sent_status = 0;
3502 int use_misc = 0;
3503 int map_sg = 0;
3504 struct iscsi_cmd *cmd = NULL;
3505 struct iscsi_conn *conn; 3725 struct iscsi_conn *conn;
3506 struct iscsi_queue_req *qr = NULL;
3507 struct iscsi_thread_set *ts = arg; 3726 struct iscsi_thread_set *ts = arg;
3508 /* 3727 /*
3509 * Allow ourselves to be interrupted by SIGINT so that a 3728 * Allow ourselves to be interrupted by SIGINT so that a
@@ -3516,7 +3735,7 @@ restart:
3516 if (!conn) 3735 if (!conn)
3517 goto out; 3736 goto out;
3518 3737
3519 eodr = map_sg = ret = sent_status = use_misc = 0; 3738 ret = 0;
3520 3739
3521 while (!kthread_should_stop()) { 3740 while (!kthread_should_stop()) {
3522 /* 3741 /*
@@ -3531,251 +3750,15 @@ restart:
3531 signal_pending(current)) 3750 signal_pending(current))
3532 goto transport_err; 3751 goto transport_err;
3533 3752
3534get_immediate: 3753 ret = handle_immediate_queue(conn);
3535 qr = iscsit_get_cmd_from_immediate_queue(conn); 3754 if (ret < 0)
3536 if (qr) { 3755 goto transport_err;
3537 atomic_set(&conn->check_immediate_queue, 0);
3538 cmd = qr->cmd;
3539 state = qr->state;
3540 kmem_cache_free(lio_qr_cache, qr);
3541
3542 spin_lock_bh(&cmd->istate_lock);
3543 switch (state) {
3544 case ISTATE_SEND_R2T:
3545 spin_unlock_bh(&cmd->istate_lock);
3546 ret = iscsit_send_r2t(cmd, conn);
3547 break;
3548 case ISTATE_REMOVE:
3549 spin_unlock_bh(&cmd->istate_lock);
3550
3551 if (cmd->data_direction == DMA_TO_DEVICE)
3552 iscsit_stop_dataout_timer(cmd);
3553
3554 spin_lock_bh(&conn->cmd_lock);
3555 list_del(&cmd->i_list);
3556 spin_unlock_bh(&conn->cmd_lock);
3557
3558 iscsit_free_cmd(cmd);
3559 goto get_immediate;
3560 case ISTATE_SEND_NOPIN_WANT_RESPONSE:
3561 spin_unlock_bh(&cmd->istate_lock);
3562 iscsit_mod_nopin_response_timer(conn);
3563 ret = iscsit_send_unsolicited_nopin(cmd,
3564 conn, 1);
3565 break;
3566 case ISTATE_SEND_NOPIN_NO_RESPONSE:
3567 spin_unlock_bh(&cmd->istate_lock);
3568 ret = iscsit_send_unsolicited_nopin(cmd,
3569 conn, 0);
3570 break;
3571 default:
3572 pr_err("Unknown Opcode: 0x%02x ITT:"
3573 " 0x%08x, i_state: %d on CID: %hu\n",
3574 cmd->iscsi_opcode, cmd->init_task_tag, state,
3575 conn->cid);
3576 spin_unlock_bh(&cmd->istate_lock);
3577 goto transport_err;
3578 }
3579 if (ret < 0) {
3580 conn->tx_immediate_queue = 0;
3581 goto transport_err;
3582 }
3583
3584 if (iscsit_send_tx_data(cmd, conn, 1) < 0) {
3585 conn->tx_immediate_queue = 0;
3586 iscsit_tx_thread_wait_for_tcp(conn);
3587 goto transport_err;
3588 }
3589
3590 spin_lock_bh(&cmd->istate_lock);
3591 switch (state) {
3592 case ISTATE_SEND_R2T:
3593 spin_unlock_bh(&cmd->istate_lock);
3594 spin_lock_bh(&cmd->dataout_timeout_lock);
3595 iscsit_start_dataout_timer(cmd, conn);
3596 spin_unlock_bh(&cmd->dataout_timeout_lock);
3597 break;
3598 case ISTATE_SEND_NOPIN_WANT_RESPONSE:
3599 cmd->i_state = ISTATE_SENT_NOPIN_WANT_RESPONSE;
3600 spin_unlock_bh(&cmd->istate_lock);
3601 break;
3602 case ISTATE_SEND_NOPIN_NO_RESPONSE:
3603 cmd->i_state = ISTATE_SENT_STATUS;
3604 spin_unlock_bh(&cmd->istate_lock);
3605 break;
3606 default:
3607 pr_err("Unknown Opcode: 0x%02x ITT:"
3608 " 0x%08x, i_state: %d on CID: %hu\n",
3609 cmd->iscsi_opcode, cmd->init_task_tag,
3610 state, conn->cid);
3611 spin_unlock_bh(&cmd->istate_lock);
3612 goto transport_err;
3613 }
3614 goto get_immediate;
3615 } else
3616 conn->tx_immediate_queue = 0;
3617
3618get_response:
3619 qr = iscsit_get_cmd_from_response_queue(conn);
3620 if (qr) {
3621 cmd = qr->cmd;
3622 state = qr->state;
3623 kmem_cache_free(lio_qr_cache, qr);
3624
3625 spin_lock_bh(&cmd->istate_lock);
3626check_rsp_state:
3627 switch (state) {
3628 case ISTATE_SEND_DATAIN:
3629 spin_unlock_bh(&cmd->istate_lock);
3630 ret = iscsit_send_data_in(cmd, conn,
3631 &eodr);
3632 map_sg = 1;
3633 break;
3634 case ISTATE_SEND_STATUS:
3635 case ISTATE_SEND_STATUS_RECOVERY:
3636 spin_unlock_bh(&cmd->istate_lock);
3637 use_misc = 1;
3638 ret = iscsit_send_status(cmd, conn);
3639 break;
3640 case ISTATE_SEND_LOGOUTRSP:
3641 spin_unlock_bh(&cmd->istate_lock);
3642 use_misc = 1;
3643 ret = iscsit_send_logout_response(cmd, conn);
3644 break;
3645 case ISTATE_SEND_ASYNCMSG:
3646 spin_unlock_bh(&cmd->istate_lock);
3647 use_misc = 1;
3648 ret = iscsit_send_conn_drop_async_message(
3649 cmd, conn);
3650 break;
3651 case ISTATE_SEND_NOPIN:
3652 spin_unlock_bh(&cmd->istate_lock);
3653 use_misc = 1;
3654 ret = iscsit_send_nopin_response(cmd, conn);
3655 break;
3656 case ISTATE_SEND_REJECT:
3657 spin_unlock_bh(&cmd->istate_lock);
3658 use_misc = 1;
3659 ret = iscsit_send_reject(cmd, conn);
3660 break;
3661 case ISTATE_SEND_TASKMGTRSP:
3662 spin_unlock_bh(&cmd->istate_lock);
3663 use_misc = 1;
3664 ret = iscsit_send_task_mgt_rsp(cmd, conn);
3665 if (ret != 0)
3666 break;
3667 ret = iscsit_tmr_post_handler(cmd, conn);
3668 if (ret != 0)
3669 iscsit_fall_back_to_erl0(conn->sess);
3670 break;
3671 case ISTATE_SEND_TEXTRSP:
3672 spin_unlock_bh(&cmd->istate_lock);
3673 use_misc = 1;
3674 ret = iscsit_send_text_rsp(cmd, conn);
3675 break;
3676 default:
3677 pr_err("Unknown Opcode: 0x%02x ITT:"
3678 " 0x%08x, i_state: %d on CID: %hu\n",
3679 cmd->iscsi_opcode, cmd->init_task_tag,
3680 state, conn->cid);
3681 spin_unlock_bh(&cmd->istate_lock);
3682 goto transport_err;
3683 }
3684 if (ret < 0) {
3685 conn->tx_response_queue = 0;
3686 goto transport_err;
3687 }
3688
3689 if (map_sg && !conn->conn_ops->IFMarker) {
3690 if (iscsit_fe_sendpage_sg(cmd, conn) < 0) {
3691 conn->tx_response_queue = 0;
3692 iscsit_tx_thread_wait_for_tcp(conn);
3693 iscsit_unmap_iovec(cmd);
3694 goto transport_err;
3695 }
3696 } else {
3697 if (iscsit_send_tx_data(cmd, conn, use_misc) < 0) {
3698 conn->tx_response_queue = 0;
3699 iscsit_tx_thread_wait_for_tcp(conn);
3700 iscsit_unmap_iovec(cmd);
3701 goto transport_err;
3702 }
3703 }
3704 map_sg = 0;
3705 iscsit_unmap_iovec(cmd);
3706
3707 spin_lock_bh(&cmd->istate_lock);
3708 switch (state) {
3709 case ISTATE_SEND_DATAIN:
3710 if (!eodr)
3711 goto check_rsp_state;
3712
3713 if (eodr == 1) {
3714 cmd->i_state = ISTATE_SENT_LAST_DATAIN;
3715 sent_status = 1;
3716 eodr = use_misc = 0;
3717 } else if (eodr == 2) {
3718 cmd->i_state = state =
3719 ISTATE_SEND_STATUS;
3720 sent_status = 0;
3721 eodr = use_misc = 0;
3722 goto check_rsp_state;
3723 }
3724 break;
3725 case ISTATE_SEND_STATUS:
3726 use_misc = 0;
3727 sent_status = 1;
3728 break;
3729 case ISTATE_SEND_ASYNCMSG:
3730 case ISTATE_SEND_NOPIN:
3731 case ISTATE_SEND_STATUS_RECOVERY:
3732 case ISTATE_SEND_TEXTRSP:
3733 use_misc = 0;
3734 sent_status = 1;
3735 break;
3736 case ISTATE_SEND_REJECT:
3737 use_misc = 0;
3738 if (cmd->cmd_flags & ICF_REJECT_FAIL_CONN) {
3739 cmd->cmd_flags &= ~ICF_REJECT_FAIL_CONN;
3740 spin_unlock_bh(&cmd->istate_lock);
3741 complete(&cmd->reject_comp);
3742 goto transport_err;
3743 }
3744 complete(&cmd->reject_comp);
3745 break;
3746 case ISTATE_SEND_TASKMGTRSP:
3747 use_misc = 0;
3748 sent_status = 1;
3749 break;
3750 case ISTATE_SEND_LOGOUTRSP:
3751 spin_unlock_bh(&cmd->istate_lock);
3752 if (!iscsit_logout_post_handler(cmd, conn))
3753 goto restart;
3754 spin_lock_bh(&cmd->istate_lock);
3755 use_misc = 0;
3756 sent_status = 1;
3757 break;
3758 default:
3759 pr_err("Unknown Opcode: 0x%02x ITT:"
3760 " 0x%08x, i_state: %d on CID: %hu\n",
3761 cmd->iscsi_opcode, cmd->init_task_tag,
3762 cmd->i_state, conn->cid);
3763 spin_unlock_bh(&cmd->istate_lock);
3764 goto transport_err;
3765 }
3766
3767 if (sent_status) {
3768 cmd->i_state = ISTATE_SENT_STATUS;
3769 sent_status = 0;
3770 }
3771 spin_unlock_bh(&cmd->istate_lock);
3772
3773 if (atomic_read(&conn->check_immediate_queue))
3774 goto get_immediate;
3775 3756
3776 goto get_response; 3757 ret = handle_response_queue(conn);
3777 } else 3758 if (ret == -EAGAIN)
3778 conn->tx_response_queue = 0; 3759 goto restart;
3760 else if (ret < 0)
3761 goto transport_err;
3779 } 3762 }
3780 3763
3781transport_err: 3764transport_err:
@@ -3952,9 +3935,9 @@ static void iscsit_release_commands_from_conn(struct iscsi_conn *conn)
3952 * has been reset -> returned sleeping pre-handler state. 3935 * has been reset -> returned sleeping pre-handler state.
3953 */ 3936 */
3954 spin_lock_bh(&conn->cmd_lock); 3937 spin_lock_bh(&conn->cmd_lock);
3955 list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_list) { 3938 list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_conn_node) {
3956 3939
3957 list_del(&cmd->i_list); 3940 list_del(&cmd->i_conn_node);
3958 spin_unlock_bh(&conn->cmd_lock); 3941 spin_unlock_bh(&conn->cmd_lock);
3959 3942
3960 iscsit_increment_maxcmdsn(cmd, sess); 3943 iscsit_increment_maxcmdsn(cmd, sess);
@@ -3972,7 +3955,7 @@ static void iscsit_stop_timers_for_cmds(
3972 struct iscsi_cmd *cmd; 3955 struct iscsi_cmd *cmd;
3973 3956
3974 spin_lock_bh(&conn->cmd_lock); 3957 spin_lock_bh(&conn->cmd_lock);
3975 list_for_each_entry(cmd, &conn->conn_cmd_list, i_list) { 3958 list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
3976 if (cmd->data_direction == DMA_TO_DEVICE) 3959 if (cmd->data_direction == DMA_TO_DEVICE)
3977 iscsit_stop_dataout_timer(cmd); 3960 iscsit_stop_dataout_timer(cmd);
3978 } 3961 }
diff --git a/drivers/target/iscsi/iscsi_target.h b/drivers/target/iscsi/iscsi_target.h
index 5db2ddeed5eb..12abb4c9e34e 100644
--- a/drivers/target/iscsi/iscsi_target.h
+++ b/drivers/target/iscsi/iscsi_target.h
@@ -18,8 +18,7 @@ extern int iscsit_logout_closesession(struct iscsi_cmd *, struct iscsi_conn *);
18extern int iscsit_logout_closeconnection(struct iscsi_cmd *, struct iscsi_conn *); 18extern int iscsit_logout_closeconnection(struct iscsi_cmd *, struct iscsi_conn *);
19extern int iscsit_logout_removeconnforrecovery(struct iscsi_cmd *, struct iscsi_conn *); 19extern int iscsit_logout_removeconnforrecovery(struct iscsi_cmd *, struct iscsi_conn *);
20extern int iscsit_send_async_msg(struct iscsi_conn *, u16, u8, u8); 20extern int iscsit_send_async_msg(struct iscsi_conn *, u16, u8, u8);
21extern int iscsit_send_r2t(struct iscsi_cmd *, struct iscsi_conn *); 21extern int iscsit_build_r2ts_for_cmd(struct iscsi_cmd *, struct iscsi_conn *, bool recovery);
22extern int iscsit_build_r2ts_for_cmd(struct iscsi_cmd *, struct iscsi_conn *, int);
23extern void iscsit_thread_get_cpumask(struct iscsi_conn *); 22extern void iscsit_thread_get_cpumask(struct iscsi_conn *);
24extern int iscsi_target_tx_thread(void *); 23extern int iscsi_target_tx_thread(void *);
25extern int iscsi_target_rx_thread(void *); 24extern int iscsi_target_rx_thread(void *);
diff --git a/drivers/target/iscsi/iscsi_target_configfs.c b/drivers/target/iscsi/iscsi_target_configfs.c
index 00c58cc82c85..69dc8e35c03a 100644
--- a/drivers/target/iscsi/iscsi_target_configfs.c
+++ b/drivers/target/iscsi/iscsi_target_configfs.c
@@ -1538,7 +1538,7 @@ static int lio_write_pending(struct se_cmd *se_cmd)
1538 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd); 1538 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1539 1539
1540 if (!cmd->immediate_data && !cmd->unsolicited_data) 1540 if (!cmd->immediate_data && !cmd->unsolicited_data)
1541 return iscsit_build_r2ts_for_cmd(cmd, cmd->conn, 1); 1541 return iscsit_build_r2ts_for_cmd(cmd, cmd->conn, false);
1542 1542
1543 return 0; 1543 return 0;
1544} 1544}
diff --git a/drivers/target/iscsi/iscsi_target_core.h b/drivers/target/iscsi/iscsi_target_core.h
index 2aaee7efa683..1c70144cdaf1 100644
--- a/drivers/target/iscsi/iscsi_target_core.h
+++ b/drivers/target/iscsi/iscsi_target_core.h
@@ -296,12 +296,11 @@ struct iscsi_datain_req {
296 u32 runlength; 296 u32 runlength;
297 u32 data_length; 297 u32 data_length;
298 u32 data_offset; 298 u32 data_offset;
299 u32 data_offset_end;
300 u32 data_sn; 299 u32 data_sn;
301 u32 next_burst_len; 300 u32 next_burst_len;
302 u32 read_data_done; 301 u32 read_data_done;
303 u32 seq_send_order; 302 u32 seq_send_order;
304 struct list_head dr_list; 303 struct list_head cmd_datain_node;
305} ____cacheline_aligned; 304} ____cacheline_aligned;
306 305
307struct iscsi_ooo_cmdsn { 306struct iscsi_ooo_cmdsn {
@@ -381,8 +380,6 @@ struct iscsi_cmd {
381 u32 buf_ptr_size; 380 u32 buf_ptr_size;
382 /* Used to store DataDigest */ 381 /* Used to store DataDigest */
383 u32 data_crc; 382 u32 data_crc;
384 /* Total size in bytes associated with command */
385 u32 data_length;
386 /* Counter for MaxOutstandingR2T */ 383 /* Counter for MaxOutstandingR2T */
387 u32 outstanding_r2ts; 384 u32 outstanding_r2ts;
388 /* Next R2T Offset when DataSequenceInOrder=Yes */ 385 /* Next R2T Offset when DataSequenceInOrder=Yes */
@@ -464,16 +461,13 @@ struct iscsi_cmd {
464 /* Session the command is part of, used for connection recovery */ 461 /* Session the command is part of, used for connection recovery */
465 struct iscsi_session *sess; 462 struct iscsi_session *sess;
466 /* list_head for connection list */ 463 /* list_head for connection list */
467 struct list_head i_list; 464 struct list_head i_conn_node;
468 /* The TCM I/O descriptor that is accessed via container_of() */ 465 /* The TCM I/O descriptor that is accessed via container_of() */
469 struct se_cmd se_cmd; 466 struct se_cmd se_cmd;
470 /* Sense buffer that will be mapped into outgoing status */ 467 /* Sense buffer that will be mapped into outgoing status */
471#define ISCSI_SENSE_BUFFER_LEN (TRANSPORT_SENSE_BUFFER + 2) 468#define ISCSI_SENSE_BUFFER_LEN (TRANSPORT_SENSE_BUFFER + 2)
472 unsigned char sense_buffer[ISCSI_SENSE_BUFFER_LEN]; 469 unsigned char sense_buffer[ISCSI_SENSE_BUFFER_LEN];
473 470
474 struct scatterlist *t_mem_sg;
475 u32 t_mem_sg_nents;
476
477 u32 padding; 471 u32 padding;
478 u8 pad_bytes[4]; 472 u8 pad_bytes[4];
479 473
@@ -500,8 +494,6 @@ struct iscsi_conn {
500 u8 network_transport; 494 u8 network_transport;
501 enum iscsi_timer_flags_table nopin_timer_flags; 495 enum iscsi_timer_flags_table nopin_timer_flags;
502 enum iscsi_timer_flags_table nopin_response_timer_flags; 496 enum iscsi_timer_flags_table nopin_response_timer_flags;
503 u8 tx_immediate_queue;
504 u8 tx_response_queue;
505 /* Used to know what thread encountered a transport failure */ 497 /* Used to know what thread encountered a transport failure */
506 u8 which_thread; 498 u8 which_thread;
507 /* connection id assigned by the Initiator */ 499 /* connection id assigned by the Initiator */
diff --git a/drivers/target/iscsi/iscsi_target_datain_values.c b/drivers/target/iscsi/iscsi_target_datain_values.c
index 8c0495129513..848fee768948 100644
--- a/drivers/target/iscsi/iscsi_target_datain_values.c
+++ b/drivers/target/iscsi/iscsi_target_datain_values.c
@@ -37,7 +37,7 @@ struct iscsi_datain_req *iscsit_allocate_datain_req(void)
37 " struct iscsi_datain_req\n"); 37 " struct iscsi_datain_req\n");
38 return NULL; 38 return NULL;
39 } 39 }
40 INIT_LIST_HEAD(&dr->dr_list); 40 INIT_LIST_HEAD(&dr->cmd_datain_node);
41 41
42 return dr; 42 return dr;
43} 43}
@@ -45,14 +45,14 @@ struct iscsi_datain_req *iscsit_allocate_datain_req(void)
45void iscsit_attach_datain_req(struct iscsi_cmd *cmd, struct iscsi_datain_req *dr) 45void iscsit_attach_datain_req(struct iscsi_cmd *cmd, struct iscsi_datain_req *dr)
46{ 46{
47 spin_lock(&cmd->datain_lock); 47 spin_lock(&cmd->datain_lock);
48 list_add_tail(&dr->dr_list, &cmd->datain_list); 48 list_add_tail(&dr->cmd_datain_node, &cmd->datain_list);
49 spin_unlock(&cmd->datain_lock); 49 spin_unlock(&cmd->datain_lock);
50} 50}
51 51
52void iscsit_free_datain_req(struct iscsi_cmd *cmd, struct iscsi_datain_req *dr) 52void iscsit_free_datain_req(struct iscsi_cmd *cmd, struct iscsi_datain_req *dr)
53{ 53{
54 spin_lock(&cmd->datain_lock); 54 spin_lock(&cmd->datain_lock);
55 list_del(&dr->dr_list); 55 list_del(&dr->cmd_datain_node);
56 spin_unlock(&cmd->datain_lock); 56 spin_unlock(&cmd->datain_lock);
57 57
58 kmem_cache_free(lio_dr_cache, dr); 58 kmem_cache_free(lio_dr_cache, dr);
@@ -63,8 +63,8 @@ void iscsit_free_all_datain_reqs(struct iscsi_cmd *cmd)
63 struct iscsi_datain_req *dr, *dr_tmp; 63 struct iscsi_datain_req *dr, *dr_tmp;
64 64
65 spin_lock(&cmd->datain_lock); 65 spin_lock(&cmd->datain_lock);
66 list_for_each_entry_safe(dr, dr_tmp, &cmd->datain_list, dr_list) { 66 list_for_each_entry_safe(dr, dr_tmp, &cmd->datain_list, cmd_datain_node) {
67 list_del(&dr->dr_list); 67 list_del(&dr->cmd_datain_node);
68 kmem_cache_free(lio_dr_cache, dr); 68 kmem_cache_free(lio_dr_cache, dr);
69 } 69 }
70 spin_unlock(&cmd->datain_lock); 70 spin_unlock(&cmd->datain_lock);
@@ -72,17 +72,14 @@ void iscsit_free_all_datain_reqs(struct iscsi_cmd *cmd)
72 72
73struct iscsi_datain_req *iscsit_get_datain_req(struct iscsi_cmd *cmd) 73struct iscsi_datain_req *iscsit_get_datain_req(struct iscsi_cmd *cmd)
74{ 74{
75 struct iscsi_datain_req *dr;
76
77 if (list_empty(&cmd->datain_list)) { 75 if (list_empty(&cmd->datain_list)) {
78 pr_err("cmd->datain_list is empty for ITT:" 76 pr_err("cmd->datain_list is empty for ITT:"
79 " 0x%08x\n", cmd->init_task_tag); 77 " 0x%08x\n", cmd->init_task_tag);
80 return NULL; 78 return NULL;
81 } 79 }
82 list_for_each_entry(dr, &cmd->datain_list, dr_list)
83 break;
84 80
85 return dr; 81 return list_first_entry(&cmd->datain_list, struct iscsi_datain_req,
82 cmd_datain_node);
86} 83}
87 84
88/* 85/*
@@ -113,7 +110,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_yes_and_yes(
113 read_data_done = (!dr->recovery) ? 110 read_data_done = (!dr->recovery) ?
114 cmd->read_data_done : dr->read_data_done; 111 cmd->read_data_done : dr->read_data_done;
115 112
116 read_data_left = (cmd->data_length - read_data_done); 113 read_data_left = (cmd->se_cmd.data_length - read_data_done);
117 if (!read_data_left) { 114 if (!read_data_left) {
118 pr_err("ITT: 0x%08x read_data_left is zero!\n", 115 pr_err("ITT: 0x%08x read_data_left is zero!\n",
119 cmd->init_task_tag); 116 cmd->init_task_tag);
@@ -212,7 +209,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_no_and_yes(
212 seq_send_order = (!dr->recovery) ? 209 seq_send_order = (!dr->recovery) ?
213 cmd->seq_send_order : dr->seq_send_order; 210 cmd->seq_send_order : dr->seq_send_order;
214 211
215 read_data_left = (cmd->data_length - read_data_done); 212 read_data_left = (cmd->se_cmd.data_length - read_data_done);
216 if (!read_data_left) { 213 if (!read_data_left) {
217 pr_err("ITT: 0x%08x read_data_left is zero!\n", 214 pr_err("ITT: 0x%08x read_data_left is zero!\n",
218 cmd->init_task_tag); 215 cmd->init_task_tag);
@@ -231,8 +228,8 @@ static struct iscsi_datain_req *iscsit_set_datain_values_no_and_yes(
231 offset = (seq->offset + seq->next_burst_len); 228 offset = (seq->offset + seq->next_burst_len);
232 229
233 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >= 230 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >=
234 cmd->data_length) { 231 cmd->se_cmd.data_length) {
235 datain->length = (cmd->data_length - offset); 232 datain->length = (cmd->se_cmd.data_length - offset);
236 datain->offset = offset; 233 datain->offset = offset;
237 234
238 datain->flags |= ISCSI_FLAG_CMD_FINAL; 235 datain->flags |= ISCSI_FLAG_CMD_FINAL;
@@ -264,7 +261,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_no_and_yes(
264 } 261 }
265 } 262 }
266 263
267 if ((read_data_done + datain->length) == cmd->data_length) 264 if ((read_data_done + datain->length) == cmd->se_cmd.data_length)
268 datain->flags |= ISCSI_FLAG_DATA_STATUS; 265 datain->flags |= ISCSI_FLAG_DATA_STATUS;
269 266
270 datain->data_sn = (!dr->recovery) ? cmd->data_sn++ : dr->data_sn++; 267 datain->data_sn = (!dr->recovery) ? cmd->data_sn++ : dr->data_sn++;
@@ -333,7 +330,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_yes_and_no(
333 read_data_done = (!dr->recovery) ? 330 read_data_done = (!dr->recovery) ?
334 cmd->read_data_done : dr->read_data_done; 331 cmd->read_data_done : dr->read_data_done;
335 332
336 read_data_left = (cmd->data_length - read_data_done); 333 read_data_left = (cmd->se_cmd.data_length - read_data_done);
337 if (!read_data_left) { 334 if (!read_data_left) {
338 pr_err("ITT: 0x%08x read_data_left is zero!\n", 335 pr_err("ITT: 0x%08x read_data_left is zero!\n",
339 cmd->init_task_tag); 336 cmd->init_task_tag);
@@ -344,7 +341,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_yes_and_no(
344 if (!pdu) 341 if (!pdu)
345 return dr; 342 return dr;
346 343
347 if ((read_data_done + pdu->length) == cmd->data_length) { 344 if ((read_data_done + pdu->length) == cmd->se_cmd.data_length) {
348 pdu->flags |= (ISCSI_FLAG_CMD_FINAL | ISCSI_FLAG_DATA_STATUS); 345 pdu->flags |= (ISCSI_FLAG_CMD_FINAL | ISCSI_FLAG_DATA_STATUS);
349 if (conn->sess->sess_ops->ErrorRecoveryLevel > 0) 346 if (conn->sess->sess_ops->ErrorRecoveryLevel > 0)
350 pdu->flags |= ISCSI_FLAG_DATA_ACK; 347 pdu->flags |= ISCSI_FLAG_DATA_ACK;
@@ -433,7 +430,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_no_and_no(
433 seq_send_order = (!dr->recovery) ? 430 seq_send_order = (!dr->recovery) ?
434 cmd->seq_send_order : dr->seq_send_order; 431 cmd->seq_send_order : dr->seq_send_order;
435 432
436 read_data_left = (cmd->data_length - read_data_done); 433 read_data_left = (cmd->se_cmd.data_length - read_data_done);
437 if (!read_data_left) { 434 if (!read_data_left) {
438 pr_err("ITT: 0x%08x read_data_left is zero!\n", 435 pr_err("ITT: 0x%08x read_data_left is zero!\n",
439 cmd->init_task_tag); 436 cmd->init_task_tag);
@@ -463,7 +460,7 @@ static struct iscsi_datain_req *iscsit_set_datain_values_no_and_no(
463 } else 460 } else
464 seq->next_burst_len += pdu->length; 461 seq->next_burst_len += pdu->length;
465 462
466 if ((read_data_done + pdu->length) == cmd->data_length) 463 if ((read_data_done + pdu->length) == cmd->se_cmd.data_length)
467 pdu->flags |= ISCSI_FLAG_DATA_STATUS; 464 pdu->flags |= ISCSI_FLAG_DATA_STATUS;
468 465
469 pdu->data_sn = (!dr->recovery) ? cmd->data_sn++ : dr->data_sn++; 466 pdu->data_sn = (!dr->recovery) ? cmd->data_sn++ : dr->data_sn++;
diff --git a/drivers/target/iscsi/iscsi_target_erl0.c b/drivers/target/iscsi/iscsi_target_erl0.c
index 1ab0560b0924..1a02016ecdab 100644
--- a/drivers/target/iscsi/iscsi_target_erl0.c
+++ b/drivers/target/iscsi/iscsi_target_erl0.c
@@ -48,9 +48,9 @@ void iscsit_set_dataout_sequence_values(
48 if (cmd->unsolicited_data) { 48 if (cmd->unsolicited_data) {
49 cmd->seq_start_offset = cmd->write_data_done; 49 cmd->seq_start_offset = cmd->write_data_done;
50 cmd->seq_end_offset = (cmd->write_data_done + 50 cmd->seq_end_offset = (cmd->write_data_done +
51 (cmd->data_length > 51 (cmd->se_cmd.data_length >
52 conn->sess->sess_ops->FirstBurstLength) ? 52 conn->sess->sess_ops->FirstBurstLength) ?
53 conn->sess->sess_ops->FirstBurstLength : cmd->data_length); 53 conn->sess->sess_ops->FirstBurstLength : cmd->se_cmd.data_length);
54 return; 54 return;
55 } 55 }
56 56
@@ -59,15 +59,15 @@ void iscsit_set_dataout_sequence_values(
59 59
60 if (!cmd->seq_start_offset && !cmd->seq_end_offset) { 60 if (!cmd->seq_start_offset && !cmd->seq_end_offset) {
61 cmd->seq_start_offset = cmd->write_data_done; 61 cmd->seq_start_offset = cmd->write_data_done;
62 cmd->seq_end_offset = (cmd->data_length > 62 cmd->seq_end_offset = (cmd->se_cmd.data_length >
63 conn->sess->sess_ops->MaxBurstLength) ? 63 conn->sess->sess_ops->MaxBurstLength) ?
64 (cmd->write_data_done + 64 (cmd->write_data_done +
65 conn->sess->sess_ops->MaxBurstLength) : cmd->data_length; 65 conn->sess->sess_ops->MaxBurstLength) : cmd->se_cmd.data_length;
66 } else { 66 } else {
67 cmd->seq_start_offset = cmd->seq_end_offset; 67 cmd->seq_start_offset = cmd->seq_end_offset;
68 cmd->seq_end_offset = ((cmd->seq_end_offset + 68 cmd->seq_end_offset = ((cmd->seq_end_offset +
69 conn->sess->sess_ops->MaxBurstLength) >= 69 conn->sess->sess_ops->MaxBurstLength) >=
70 cmd->data_length) ? cmd->data_length : 70 cmd->se_cmd.data_length) ? cmd->se_cmd.data_length :
71 (cmd->seq_end_offset + 71 (cmd->seq_end_offset +
72 conn->sess->sess_ops->MaxBurstLength); 72 conn->sess->sess_ops->MaxBurstLength);
73 } 73 }
@@ -182,13 +182,13 @@ static int iscsit_dataout_check_unsolicited_sequence(
182 if (!conn->sess->sess_ops->DataPDUInOrder) 182 if (!conn->sess->sess_ops->DataPDUInOrder)
183 goto out; 183 goto out;
184 184
185 if ((first_burst_len != cmd->data_length) && 185 if ((first_burst_len != cmd->se_cmd.data_length) &&
186 (first_burst_len != conn->sess->sess_ops->FirstBurstLength)) { 186 (first_burst_len != conn->sess->sess_ops->FirstBurstLength)) {
187 pr_err("Unsolicited non-immediate data" 187 pr_err("Unsolicited non-immediate data"
188 " received %u does not equal FirstBurstLength: %u, and" 188 " received %u does not equal FirstBurstLength: %u, and"
189 " does not equal ExpXferLen %u.\n", first_burst_len, 189 " does not equal ExpXferLen %u.\n", first_burst_len,
190 conn->sess->sess_ops->FirstBurstLength, 190 conn->sess->sess_ops->FirstBurstLength,
191 cmd->data_length); 191 cmd->se_cmd.data_length);
192 transport_send_check_condition_and_sense(&cmd->se_cmd, 192 transport_send_check_condition_and_sense(&cmd->se_cmd,
193 TCM_INCORRECT_AMOUNT_OF_DATA, 0); 193 TCM_INCORRECT_AMOUNT_OF_DATA, 0);
194 return DATAOUT_CANNOT_RECOVER; 194 return DATAOUT_CANNOT_RECOVER;
@@ -201,10 +201,10 @@ static int iscsit_dataout_check_unsolicited_sequence(
201 conn->sess->sess_ops->FirstBurstLength); 201 conn->sess->sess_ops->FirstBurstLength);
202 return DATAOUT_CANNOT_RECOVER; 202 return DATAOUT_CANNOT_RECOVER;
203 } 203 }
204 if (first_burst_len == cmd->data_length) { 204 if (first_burst_len == cmd->se_cmd.data_length) {
205 pr_err("Command ITT: 0x%08x reached" 205 pr_err("Command ITT: 0x%08x reached"
206 " ExpXferLen: %u, but ISCSI_FLAG_CMD_FINAL is not set. protocol" 206 " ExpXferLen: %u, but ISCSI_FLAG_CMD_FINAL is not set. protocol"
207 " error.\n", cmd->init_task_tag, cmd->data_length); 207 " error.\n", cmd->init_task_tag, cmd->se_cmd.data_length);
208 return DATAOUT_CANNOT_RECOVER; 208 return DATAOUT_CANNOT_RECOVER;
209 } 209 }
210 } 210 }
@@ -294,7 +294,7 @@ static int iscsit_dataout_check_sequence(
294 if ((next_burst_len < 294 if ((next_burst_len <
295 conn->sess->sess_ops->MaxBurstLength) && 295 conn->sess->sess_ops->MaxBurstLength) &&
296 ((cmd->write_data_done + payload_length) < 296 ((cmd->write_data_done + payload_length) <
297 cmd->data_length)) { 297 cmd->se_cmd.data_length)) {
298 pr_err("Command ITT: 0x%08x set ISCSI_FLAG_CMD_FINAL" 298 pr_err("Command ITT: 0x%08x set ISCSI_FLAG_CMD_FINAL"
299 " before end of DataOUT sequence, protocol" 299 " before end of DataOUT sequence, protocol"
300 " error.\n", cmd->init_task_tag); 300 " error.\n", cmd->init_task_tag);
@@ -319,7 +319,7 @@ static int iscsit_dataout_check_sequence(
319 return DATAOUT_CANNOT_RECOVER; 319 return DATAOUT_CANNOT_RECOVER;
320 } 320 }
321 if ((cmd->write_data_done + payload_length) == 321 if ((cmd->write_data_done + payload_length) ==
322 cmd->data_length) { 322 cmd->se_cmd.data_length) {
323 pr_err("Command ITT: 0x%08x reached" 323 pr_err("Command ITT: 0x%08x reached"
324 " last DataOUT PDU in sequence but ISCSI_FLAG_" 324 " last DataOUT PDU in sequence but ISCSI_FLAG_"
325 "CMD_FINAL is not set, protocol error.\n", 325 "CMD_FINAL is not set, protocol error.\n",
@@ -640,9 +640,12 @@ static int iscsit_dataout_post_crc_passed(
640 640
641 cmd->write_data_done += payload_length; 641 cmd->write_data_done += payload_length;
642 642
643 return (cmd->write_data_done == cmd->data_length) ? 643 if (cmd->write_data_done == cmd->se_cmd.data_length)
644 DATAOUT_SEND_TO_TRANSPORT : (send_r2t) ? 644 return DATAOUT_SEND_TO_TRANSPORT;
645 DATAOUT_SEND_R2T : DATAOUT_NORMAL; 645 else if (send_r2t)
646 return DATAOUT_SEND_R2T;
647 else
648 return DATAOUT_NORMAL;
646} 649}
647 650
648static int iscsit_dataout_post_crc_failed( 651static int iscsit_dataout_post_crc_failed(
diff --git a/drivers/target/iscsi/iscsi_target_erl1.c b/drivers/target/iscsi/iscsi_target_erl1.c
index 006f605edb08..ecdd46deedda 100644
--- a/drivers/target/iscsi/iscsi_target_erl1.c
+++ b/drivers/target/iscsi/iscsi_target_erl1.c
@@ -279,11 +279,9 @@ int iscsit_create_recovery_datain_values_datasequenceinorder_no(
279 * seq->first_datasn and seq->last_datasn have not been set. 279 * seq->first_datasn and seq->last_datasn have not been set.
280 */ 280 */
281 if (!seq->sent) { 281 if (!seq->sent) {
282#if 0
283 pr_err("Ignoring non-sent sequence 0x%08x ->" 282 pr_err("Ignoring non-sent sequence 0x%08x ->"
284 " 0x%08x\n\n", seq->first_datasn, 283 " 0x%08x\n\n", seq->first_datasn,
285 seq->last_datasn); 284 seq->last_datasn);
286#endif
287 continue; 285 continue;
288 } 286 }
289 287
@@ -294,11 +292,10 @@ int iscsit_create_recovery_datain_values_datasequenceinorder_no(
294 */ 292 */
295 if ((seq->first_datasn < begrun) && 293 if ((seq->first_datasn < begrun) &&
296 (seq->last_datasn < begrun)) { 294 (seq->last_datasn < begrun)) {
297#if 0
298 pr_err("Pre BegRun sequence 0x%08x ->" 295 pr_err("Pre BegRun sequence 0x%08x ->"
299 " 0x%08x\n", seq->first_datasn, 296 " 0x%08x\n", seq->first_datasn,
300 seq->last_datasn); 297 seq->last_datasn);
301#endif 298
302 read_data_done += cmd->seq_list[i].xfer_len; 299 read_data_done += cmd->seq_list[i].xfer_len;
303 seq->next_burst_len = seq->pdu_send_order = 0; 300 seq->next_burst_len = seq->pdu_send_order = 0;
304 continue; 301 continue;
@@ -309,11 +306,10 @@ int iscsit_create_recovery_datain_values_datasequenceinorder_no(
309 */ 306 */
310 if ((seq->first_datasn <= begrun) && 307 if ((seq->first_datasn <= begrun) &&
311 (seq->last_datasn >= begrun)) { 308 (seq->last_datasn >= begrun)) {
312#if 0
313 pr_err("Found sequence begrun: 0x%08x in" 309 pr_err("Found sequence begrun: 0x%08x in"
314 " 0x%08x -> 0x%08x\n", begrun, 310 " 0x%08x -> 0x%08x\n", begrun,
315 seq->first_datasn, seq->last_datasn); 311 seq->first_datasn, seq->last_datasn);
316#endif 312
317 seq_send_order = seq->seq_send_order; 313 seq_send_order = seq->seq_send_order;
318 data_sn = seq->first_datasn; 314 data_sn = seq->first_datasn;
319 seq->next_burst_len = seq->pdu_send_order = 0; 315 seq->next_burst_len = seq->pdu_send_order = 0;
@@ -369,10 +365,9 @@ int iscsit_create_recovery_datain_values_datasequenceinorder_no(
369 */ 365 */
370 if ((seq->first_datasn > begrun) || 366 if ((seq->first_datasn > begrun) ||
371 (seq->last_datasn > begrun)) { 367 (seq->last_datasn > begrun)) {
372#if 0
373 pr_err("Post BegRun sequence 0x%08x -> 0x%08x\n", 368 pr_err("Post BegRun sequence 0x%08x -> 0x%08x\n",
374 seq->first_datasn, seq->last_datasn); 369 seq->first_datasn, seq->last_datasn);
375#endif 370
376 seq->next_burst_len = seq->pdu_send_order = 0; 371 seq->next_burst_len = seq->pdu_send_order = 0;
377 continue; 372 continue;
378 } 373 }
@@ -526,7 +521,7 @@ int iscsit_handle_status_snack(
526 found_cmd = 0; 521 found_cmd = 0;
527 522
528 spin_lock_bh(&conn->cmd_lock); 523 spin_lock_bh(&conn->cmd_lock);
529 list_for_each_entry(cmd, &conn->conn_cmd_list, i_list) { 524 list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
530 if (cmd->stat_sn == begrun) { 525 if (cmd->stat_sn == begrun) {
531 found_cmd = 1; 526 found_cmd = 1;
532 break; 527 break;
@@ -987,7 +982,7 @@ int iscsit_execute_cmd(struct iscsi_cmd *cmd, int ooo)
987 return 0; 982 return 0;
988 983
989 iscsit_set_dataout_sequence_values(cmd); 984 iscsit_set_dataout_sequence_values(cmd);
990 iscsit_build_r2ts_for_cmd(cmd, cmd->conn, 0); 985 iscsit_build_r2ts_for_cmd(cmd, cmd->conn, false);
991 } 986 }
992 return 0; 987 return 0;
993 } 988 }
@@ -1121,8 +1116,8 @@ static int iscsit_set_dataout_timeout_values(
1121 if (cmd->unsolicited_data) { 1116 if (cmd->unsolicited_data) {
1122 *offset = 0; 1117 *offset = 0;
1123 *length = (conn->sess->sess_ops->FirstBurstLength > 1118 *length = (conn->sess->sess_ops->FirstBurstLength >
1124 cmd->data_length) ? 1119 cmd->se_cmd.data_length) ?
1125 cmd->data_length : 1120 cmd->se_cmd.data_length :
1126 conn->sess->sess_ops->FirstBurstLength; 1121 conn->sess->sess_ops->FirstBurstLength;
1127 return 0; 1122 return 0;
1128 } 1123 }
@@ -1193,8 +1188,8 @@ static void iscsit_handle_dataout_timeout(unsigned long data)
1193 if (conn->sess->sess_ops->DataPDUInOrder) { 1188 if (conn->sess->sess_ops->DataPDUInOrder) {
1194 pdu_offset = cmd->write_data_done; 1189 pdu_offset = cmd->write_data_done;
1195 if ((pdu_offset + (conn->sess->sess_ops->MaxBurstLength - 1190 if ((pdu_offset + (conn->sess->sess_ops->MaxBurstLength -
1196 cmd->next_burst_len)) > cmd->data_length) 1191 cmd->next_burst_len)) > cmd->se_cmd.data_length)
1197 pdu_length = (cmd->data_length - 1192 pdu_length = (cmd->se_cmd.data_length -
1198 cmd->write_data_done); 1193 cmd->write_data_done);
1199 else 1194 else
1200 pdu_length = (conn->sess->sess_ops->MaxBurstLength - 1195 pdu_length = (conn->sess->sess_ops->MaxBurstLength -
diff --git a/drivers/target/iscsi/iscsi_target_erl2.c b/drivers/target/iscsi/iscsi_target_erl2.c
index 1af1f21af21f..65aac14fd831 100644
--- a/drivers/target/iscsi/iscsi_target_erl2.c
+++ b/drivers/target/iscsi/iscsi_target_erl2.c
@@ -138,9 +138,9 @@ void iscsit_free_connection_recovery_entires(struct iscsi_session *sess)
138 138
139 spin_lock(&cr->conn_recovery_cmd_lock); 139 spin_lock(&cr->conn_recovery_cmd_lock);
140 list_for_each_entry_safe(cmd, cmd_tmp, 140 list_for_each_entry_safe(cmd, cmd_tmp,
141 &cr->conn_recovery_cmd_list, i_list) { 141 &cr->conn_recovery_cmd_list, i_conn_node) {
142 142
143 list_del(&cmd->i_list); 143 list_del(&cmd->i_conn_node);
144 cmd->conn = NULL; 144 cmd->conn = NULL;
145 spin_unlock(&cr->conn_recovery_cmd_lock); 145 spin_unlock(&cr->conn_recovery_cmd_lock);
146 iscsit_free_cmd(cmd); 146 iscsit_free_cmd(cmd);
@@ -160,9 +160,9 @@ void iscsit_free_connection_recovery_entires(struct iscsi_session *sess)
160 160
161 spin_lock(&cr->conn_recovery_cmd_lock); 161 spin_lock(&cr->conn_recovery_cmd_lock);
162 list_for_each_entry_safe(cmd, cmd_tmp, 162 list_for_each_entry_safe(cmd, cmd_tmp,
163 &cr->conn_recovery_cmd_list, i_list) { 163 &cr->conn_recovery_cmd_list, i_conn_node) {
164 164
165 list_del(&cmd->i_list); 165 list_del(&cmd->i_conn_node);
166 cmd->conn = NULL; 166 cmd->conn = NULL;
167 spin_unlock(&cr->conn_recovery_cmd_lock); 167 spin_unlock(&cr->conn_recovery_cmd_lock);
168 iscsit_free_cmd(cmd); 168 iscsit_free_cmd(cmd);
@@ -220,7 +220,7 @@ int iscsit_remove_cmd_from_connection_recovery(
220 } 220 }
221 cr = cmd->cr; 221 cr = cmd->cr;
222 222
223 list_del(&cmd->i_list); 223 list_del(&cmd->i_conn_node);
224 return --cr->cmd_count; 224 return --cr->cmd_count;
225} 225}
226 226
@@ -234,7 +234,7 @@ void iscsit_discard_cr_cmds_by_expstatsn(
234 234
235 spin_lock(&cr->conn_recovery_cmd_lock); 235 spin_lock(&cr->conn_recovery_cmd_lock);
236 list_for_each_entry_safe(cmd, cmd_tmp, 236 list_for_each_entry_safe(cmd, cmd_tmp,
237 &cr->conn_recovery_cmd_list, i_list) { 237 &cr->conn_recovery_cmd_list, i_conn_node) {
238 238
239 if (((cmd->deferred_i_state != ISTATE_SENT_STATUS) && 239 if (((cmd->deferred_i_state != ISTATE_SENT_STATUS) &&
240 (cmd->deferred_i_state != ISTATE_REMOVE)) || 240 (cmd->deferred_i_state != ISTATE_REMOVE)) ||
@@ -297,11 +297,11 @@ int iscsit_discard_unacknowledged_ooo_cmdsns_for_conn(struct iscsi_conn *conn)
297 mutex_unlock(&sess->cmdsn_mutex); 297 mutex_unlock(&sess->cmdsn_mutex);
298 298
299 spin_lock_bh(&conn->cmd_lock); 299 spin_lock_bh(&conn->cmd_lock);
300 list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_list) { 300 list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_conn_node) {
301 if (!(cmd->cmd_flags & ICF_OOO_CMDSN)) 301 if (!(cmd->cmd_flags & ICF_OOO_CMDSN))
302 continue; 302 continue;
303 303
304 list_del(&cmd->i_list); 304 list_del(&cmd->i_conn_node);
305 305
306 spin_unlock_bh(&conn->cmd_lock); 306 spin_unlock_bh(&conn->cmd_lock);
307 iscsit_free_cmd(cmd); 307 iscsit_free_cmd(cmd);
@@ -339,14 +339,14 @@ int iscsit_prepare_cmds_for_realligance(struct iscsi_conn *conn)
339 /* 339 /*
340 * Only perform connection recovery on ISCSI_OP_SCSI_CMD or 340 * Only perform connection recovery on ISCSI_OP_SCSI_CMD or
341 * ISCSI_OP_NOOP_OUT opcodes. For all other opcodes call 341 * ISCSI_OP_NOOP_OUT opcodes. For all other opcodes call
342 * list_del(&cmd->i_list); to release the command to the 342 * list_del(&cmd->i_conn_node); to release the command to the
343 * session pool and remove it from the connection's list. 343 * session pool and remove it from the connection's list.
344 * 344 *
345 * Also stop the DataOUT timer, which will be restarted after 345 * Also stop the DataOUT timer, which will be restarted after
346 * sending the TMR response. 346 * sending the TMR response.
347 */ 347 */
348 spin_lock_bh(&conn->cmd_lock); 348 spin_lock_bh(&conn->cmd_lock);
349 list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_list) { 349 list_for_each_entry_safe(cmd, cmd_tmp, &conn->conn_cmd_list, i_conn_node) {
350 350
351 if ((cmd->iscsi_opcode != ISCSI_OP_SCSI_CMD) && 351 if ((cmd->iscsi_opcode != ISCSI_OP_SCSI_CMD) &&
352 (cmd->iscsi_opcode != ISCSI_OP_NOOP_OUT)) { 352 (cmd->iscsi_opcode != ISCSI_OP_NOOP_OUT)) {
@@ -355,7 +355,7 @@ int iscsit_prepare_cmds_for_realligance(struct iscsi_conn *conn)
355 " CID: %hu\n", cmd->iscsi_opcode, 355 " CID: %hu\n", cmd->iscsi_opcode,
356 cmd->init_task_tag, cmd->cmd_sn, conn->cid); 356 cmd->init_task_tag, cmd->cmd_sn, conn->cid);
357 357
358 list_del(&cmd->i_list); 358 list_del(&cmd->i_conn_node);
359 spin_unlock_bh(&conn->cmd_lock); 359 spin_unlock_bh(&conn->cmd_lock);
360 iscsit_free_cmd(cmd); 360 iscsit_free_cmd(cmd);
361 spin_lock_bh(&conn->cmd_lock); 361 spin_lock_bh(&conn->cmd_lock);
@@ -375,7 +375,7 @@ int iscsit_prepare_cmds_for_realligance(struct iscsi_conn *conn)
375 */ 375 */
376 if (!(cmd->cmd_flags & ICF_OOO_CMDSN) && !cmd->immediate_cmd && 376 if (!(cmd->cmd_flags & ICF_OOO_CMDSN) && !cmd->immediate_cmd &&
377 (cmd->cmd_sn >= conn->sess->exp_cmd_sn)) { 377 (cmd->cmd_sn >= conn->sess->exp_cmd_sn)) {
378 list_del(&cmd->i_list); 378 list_del(&cmd->i_conn_node);
379 spin_unlock_bh(&conn->cmd_lock); 379 spin_unlock_bh(&conn->cmd_lock);
380 iscsit_free_cmd(cmd); 380 iscsit_free_cmd(cmd);
381 spin_lock_bh(&conn->cmd_lock); 381 spin_lock_bh(&conn->cmd_lock);
@@ -397,7 +397,7 @@ int iscsit_prepare_cmds_for_realligance(struct iscsi_conn *conn)
397 397
398 cmd->sess = conn->sess; 398 cmd->sess = conn->sess;
399 399
400 list_del(&cmd->i_list); 400 list_del(&cmd->i_conn_node);
401 spin_unlock_bh(&conn->cmd_lock); 401 spin_unlock_bh(&conn->cmd_lock);
402 402
403 iscsit_free_all_datain_reqs(cmd); 403 iscsit_free_all_datain_reqs(cmd);
@@ -407,7 +407,7 @@ int iscsit_prepare_cmds_for_realligance(struct iscsi_conn *conn)
407 * Add the struct iscsi_cmd to the connection recovery cmd list 407 * Add the struct iscsi_cmd to the connection recovery cmd list
408 */ 408 */
409 spin_lock(&cr->conn_recovery_cmd_lock); 409 spin_lock(&cr->conn_recovery_cmd_lock);
410 list_add_tail(&cmd->i_list, &cr->conn_recovery_cmd_list); 410 list_add_tail(&cmd->i_conn_node, &cr->conn_recovery_cmd_list);
411 spin_unlock(&cr->conn_recovery_cmd_lock); 411 spin_unlock(&cr->conn_recovery_cmd_lock);
412 412
413 spin_lock_bh(&conn->cmd_lock); 413 spin_lock_bh(&conn->cmd_lock);
diff --git a/drivers/target/iscsi/iscsi_target_parameters.c b/drivers/target/iscsi/iscsi_target_parameters.c
index eb05c9d751ea..ed5241e7f12a 100644
--- a/drivers/target/iscsi/iscsi_target_parameters.c
+++ b/drivers/target/iscsi/iscsi_target_parameters.c
@@ -803,14 +803,6 @@ static int iscsi_check_numerical_value(struct iscsi_param *param, char *value_pt
803 803
804 value = simple_strtoul(value_ptr, &tmpptr, 0); 804 value = simple_strtoul(value_ptr, &tmpptr, 0);
805 805
806/* #warning FIXME: Fix this */
807#if 0
808 if (strspn(endptr, WHITE_SPACE) != strlen(endptr)) {
809 pr_err("Illegal value \"%s\" for \"%s\".\n",
810 value, param->name);
811 return -1;
812 }
813#endif
814 if (IS_TYPERANGE_0_TO_2(param)) { 806 if (IS_TYPERANGE_0_TO_2(param)) {
815 if ((value < 0) || (value > 2)) { 807 if ((value < 0) || (value > 2)) {
816 pr_err("Illegal value for \"%s\", must be" 808 pr_err("Illegal value for \"%s\", must be"
@@ -1045,13 +1037,6 @@ static char *iscsi_check_valuelist_for_support(
1045 tmp2 = strchr(acceptor_values, ','); 1037 tmp2 = strchr(acceptor_values, ',');
1046 if (tmp2) 1038 if (tmp2)
1047 *tmp2 = '\0'; 1039 *tmp2 = '\0';
1048 if (!acceptor_values || !proposer_values) {
1049 if (tmp1)
1050 *tmp1 = ',';
1051 if (tmp2)
1052 *tmp2 = ',';
1053 return NULL;
1054 }
1055 if (!strcmp(acceptor_values, proposer_values)) { 1040 if (!strcmp(acceptor_values, proposer_values)) {
1056 if (tmp2) 1041 if (tmp2)
1057 *tmp2 = ','; 1042 *tmp2 = ',';
@@ -1061,8 +1046,6 @@ static char *iscsi_check_valuelist_for_support(
1061 *tmp2++ = ','; 1046 *tmp2++ = ',';
1062 1047
1063 acceptor_values = tmp2; 1048 acceptor_values = tmp2;
1064 if (!acceptor_values)
1065 break;
1066 } while (acceptor_values); 1049 } while (acceptor_values);
1067 if (tmp1) 1050 if (tmp1)
1068 *tmp1++ = ','; 1051 *tmp1++ = ',';
diff --git a/drivers/target/iscsi/iscsi_target_seq_pdu_list.c b/drivers/target/iscsi/iscsi_target_seq_pdu_list.c
index fc694082bfc0..85a306e067ba 100644
--- a/drivers/target/iscsi/iscsi_target_seq_pdu_list.c
+++ b/drivers/target/iscsi/iscsi_target_seq_pdu_list.c
@@ -24,11 +24,13 @@
24 24
25#include "iscsi_target_core.h" 25#include "iscsi_target_core.h"
26#include "iscsi_target_util.h" 26#include "iscsi_target_util.h"
27#include "iscsi_target_tpg.h"
27#include "iscsi_target_seq_pdu_list.h" 28#include "iscsi_target_seq_pdu_list.h"
28 29
29#define OFFLOAD_BUF_SIZE 32768 30#define OFFLOAD_BUF_SIZE 32768
30 31
31void iscsit_dump_seq_list(struct iscsi_cmd *cmd) 32#ifdef DEBUG
33static void iscsit_dump_seq_list(struct iscsi_cmd *cmd)
32{ 34{
33 int i; 35 int i;
34 struct iscsi_seq *seq; 36 struct iscsi_seq *seq;
@@ -46,7 +48,7 @@ void iscsit_dump_seq_list(struct iscsi_cmd *cmd)
46 } 48 }
47} 49}
48 50
49void iscsit_dump_pdu_list(struct iscsi_cmd *cmd) 51static void iscsit_dump_pdu_list(struct iscsi_cmd *cmd)
50{ 52{
51 int i; 53 int i;
52 struct iscsi_pdu *pdu; 54 struct iscsi_pdu *pdu;
@@ -61,6 +63,10 @@ void iscsit_dump_pdu_list(struct iscsi_cmd *cmd)
61 pdu->length, pdu->pdu_send_order, pdu->seq_no); 63 pdu->length, pdu->pdu_send_order, pdu->seq_no);
62 } 64 }
63} 65}
66#else
67static void iscsit_dump_seq_list(struct iscsi_cmd *cmd) {}
68static void iscsit_dump_pdu_list(struct iscsi_cmd *cmd) {}
69#endif
64 70
65static void iscsit_ordered_seq_lists( 71static void iscsit_ordered_seq_lists(
66 struct iscsi_cmd *cmd, 72 struct iscsi_cmd *cmd,
@@ -135,11 +141,11 @@ redo:
135 seq_count++; 141 seq_count++;
136 continue; 142 continue;
137 } 143 }
138 array = kzalloc(seq_count * sizeof(u32), GFP_KERNEL); 144 array = kcalloc(seq_count, sizeof(u32), GFP_KERNEL);
139 if (!array) { 145 if (!array) {
140 pr_err("Unable to allocate memory" 146 pr_err("Unable to allocate memory"
141 " for random array.\n"); 147 " for random array.\n");
142 return -1; 148 return -ENOMEM;
143 } 149 }
144 iscsit_create_random_array(array, seq_count); 150 iscsit_create_random_array(array, seq_count);
145 151
@@ -155,11 +161,11 @@ redo:
155 } 161 }
156 162
157 if (seq_count) { 163 if (seq_count) {
158 array = kzalloc(seq_count * sizeof(u32), GFP_KERNEL); 164 array = kcalloc(seq_count, sizeof(u32), GFP_KERNEL);
159 if (!array) { 165 if (!array) {
160 pr_err("Unable to allocate memory for" 166 pr_err("Unable to allocate memory for"
161 " random array.\n"); 167 " random array.\n");
162 return -1; 168 return -ENOMEM;
163 } 169 }
164 iscsit_create_random_array(array, seq_count); 170 iscsit_create_random_array(array, seq_count);
165 171
@@ -187,10 +193,10 @@ static int iscsit_randomize_seq_lists(
187 if (!seq_count) 193 if (!seq_count)
188 return 0; 194 return 0;
189 195
190 array = kzalloc(seq_count * sizeof(u32), GFP_KERNEL); 196 array = kcalloc(seq_count, sizeof(u32), GFP_KERNEL);
191 if (!array) { 197 if (!array) {
192 pr_err("Unable to allocate memory for random array.\n"); 198 pr_err("Unable to allocate memory for random array.\n");
193 return -1; 199 return -ENOMEM;
194 } 200 }
195 iscsit_create_random_array(array, seq_count); 201 iscsit_create_random_array(array, seq_count);
196 202
@@ -221,11 +227,10 @@ static void iscsit_determine_counts_for_list(
221 227
222 if ((bl->type == PDULIST_UNSOLICITED) || 228 if ((bl->type == PDULIST_UNSOLICITED) ||
223 (bl->type == PDULIST_IMMEDIATE_AND_UNSOLICITED)) 229 (bl->type == PDULIST_IMMEDIATE_AND_UNSOLICITED))
224 unsolicited_data_length = (cmd->data_length > 230 unsolicited_data_length = min(cmd->se_cmd.data_length,
225 conn->sess->sess_ops->FirstBurstLength) ? 231 conn->sess->sess_ops->FirstBurstLength);
226 conn->sess->sess_ops->FirstBurstLength : cmd->data_length;
227 232
228 while (offset < cmd->data_length) { 233 while (offset < cmd->se_cmd.data_length) {
229 *pdu_count += 1; 234 *pdu_count += 1;
230 235
231 if (check_immediate) { 236 if (check_immediate) {
@@ -239,10 +244,10 @@ static void iscsit_determine_counts_for_list(
239 } 244 }
240 if (unsolicited_data_length > 0) { 245 if (unsolicited_data_length > 0) {
241 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) 246 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength)
242 >= cmd->data_length) { 247 >= cmd->se_cmd.data_length) {
243 unsolicited_data_length -= 248 unsolicited_data_length -=
244 (cmd->data_length - offset); 249 (cmd->se_cmd.data_length - offset);
245 offset += (cmd->data_length - offset); 250 offset += (cmd->se_cmd.data_length - offset);
246 continue; 251 continue;
247 } 252 }
248 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) 253 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength)
@@ -263,8 +268,8 @@ static void iscsit_determine_counts_for_list(
263 continue; 268 continue;
264 } 269 }
265 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >= 270 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >=
266 cmd->data_length) { 271 cmd->se_cmd.data_length) {
267 offset += (cmd->data_length - offset); 272 offset += (cmd->se_cmd.data_length - offset);
268 continue; 273 continue;
269 } 274 }
270 if ((burstlength + conn->conn_ops->MaxRecvDataSegmentLength) >= 275 if ((burstlength + conn->conn_ops->MaxRecvDataSegmentLength) >=
@@ -283,10 +288,10 @@ static void iscsit_determine_counts_for_list(
283 288
284 289
285/* 290/*
286 * Builds PDU and/or Sequence list, called while DataSequenceInOrder=No 291 * Builds PDU and/or Sequence list, called while DataSequenceInOrder=No
287 * and DataPDUInOrder=No. 292 * or DataPDUInOrder=No.
288 */ 293 */
289static int iscsit_build_pdu_and_seq_list( 294static int iscsit_do_build_pdu_and_seq_lists(
290 struct iscsi_cmd *cmd, 295 struct iscsi_cmd *cmd,
291 struct iscsi_build_list *bl) 296 struct iscsi_build_list *bl)
292{ 297{
@@ -306,11 +311,10 @@ static int iscsit_build_pdu_and_seq_list(
306 311
307 if ((bl->type == PDULIST_UNSOLICITED) || 312 if ((bl->type == PDULIST_UNSOLICITED) ||
308 (bl->type == PDULIST_IMMEDIATE_AND_UNSOLICITED)) 313 (bl->type == PDULIST_IMMEDIATE_AND_UNSOLICITED))
309 unsolicited_data_length = (cmd->data_length > 314 unsolicited_data_length = min(cmd->se_cmd.data_length,
310 conn->sess->sess_ops->FirstBurstLength) ? 315 conn->sess->sess_ops->FirstBurstLength);
311 conn->sess->sess_ops->FirstBurstLength : cmd->data_length;
312 316
313 while (offset < cmd->data_length) { 317 while (offset < cmd->se_cmd.data_length) {
314 pdu_count++; 318 pdu_count++;
315 if (!datapduinorder) { 319 if (!datapduinorder) {
316 pdu[i].offset = offset; 320 pdu[i].offset = offset;
@@ -346,21 +350,21 @@ static int iscsit_build_pdu_and_seq_list(
346 if (unsolicited_data_length > 0) { 350 if (unsolicited_data_length > 0) {
347 if ((offset + 351 if ((offset +
348 conn->conn_ops->MaxRecvDataSegmentLength) >= 352 conn->conn_ops->MaxRecvDataSegmentLength) >=
349 cmd->data_length) { 353 cmd->se_cmd.data_length) {
350 if (!datapduinorder) { 354 if (!datapduinorder) {
351 pdu[i].type = PDUTYPE_UNSOLICITED; 355 pdu[i].type = PDUTYPE_UNSOLICITED;
352 pdu[i].length = 356 pdu[i].length =
353 (cmd->data_length - offset); 357 (cmd->se_cmd.data_length - offset);
354 } 358 }
355 if (!datasequenceinorder) { 359 if (!datasequenceinorder) {
356 seq[seq_no].type = SEQTYPE_UNSOLICITED; 360 seq[seq_no].type = SEQTYPE_UNSOLICITED;
357 seq[seq_no].pdu_count = pdu_count; 361 seq[seq_no].pdu_count = pdu_count;
358 seq[seq_no].xfer_len = (burstlength + 362 seq[seq_no].xfer_len = (burstlength +
359 (cmd->data_length - offset)); 363 (cmd->se_cmd.data_length - offset));
360 } 364 }
361 unsolicited_data_length -= 365 unsolicited_data_length -=
362 (cmd->data_length - offset); 366 (cmd->se_cmd.data_length - offset);
363 offset += (cmd->data_length - offset); 367 offset += (cmd->se_cmd.data_length - offset);
364 continue; 368 continue;
365 } 369 }
366 if ((offset + 370 if ((offset +
@@ -402,18 +406,18 @@ static int iscsit_build_pdu_and_seq_list(
402 continue; 406 continue;
403 } 407 }
404 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >= 408 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >=
405 cmd->data_length) { 409 cmd->se_cmd.data_length) {
406 if (!datapduinorder) { 410 if (!datapduinorder) {
407 pdu[i].type = PDUTYPE_NORMAL; 411 pdu[i].type = PDUTYPE_NORMAL;
408 pdu[i].length = (cmd->data_length - offset); 412 pdu[i].length = (cmd->se_cmd.data_length - offset);
409 } 413 }
410 if (!datasequenceinorder) { 414 if (!datasequenceinorder) {
411 seq[seq_no].type = SEQTYPE_NORMAL; 415 seq[seq_no].type = SEQTYPE_NORMAL;
412 seq[seq_no].pdu_count = pdu_count; 416 seq[seq_no].pdu_count = pdu_count;
413 seq[seq_no].xfer_len = (burstlength + 417 seq[seq_no].xfer_len = (burstlength +
414 (cmd->data_length - offset)); 418 (cmd->se_cmd.data_length - offset));
415 } 419 }
416 offset += (cmd->data_length - offset); 420 offset += (cmd->se_cmd.data_length - offset);
417 continue; 421 continue;
418 } 422 }
419 if ((burstlength + conn->conn_ops->MaxRecvDataSegmentLength) >= 423 if ((burstlength + conn->conn_ops->MaxRecvDataSegmentLength) >=
@@ -464,9 +468,8 @@ static int iscsit_build_pdu_and_seq_list(
464 } else 468 } else
465 iscsit_ordered_seq_lists(cmd, bl->type); 469 iscsit_ordered_seq_lists(cmd, bl->type);
466 } 470 }
467#if 0 471
468 iscsit_dump_seq_list(cmd); 472 iscsit_dump_seq_list(cmd);
469#endif
470 } 473 }
471 if (!datapduinorder) { 474 if (!datapduinorder) {
472 if (bl->data_direction & ISCSI_PDU_WRITE) { 475 if (bl->data_direction & ISCSI_PDU_WRITE) {
@@ -484,50 +487,86 @@ static int iscsit_build_pdu_and_seq_list(
484 } else 487 } else
485 iscsit_ordered_pdu_lists(cmd, bl->type); 488 iscsit_ordered_pdu_lists(cmd, bl->type);
486 } 489 }
487#if 0 490
488 iscsit_dump_pdu_list(cmd); 491 iscsit_dump_pdu_list(cmd);
489#endif
490 } 492 }
491 493
492 return 0; 494 return 0;
493} 495}
494 496
495/* 497int iscsit_build_pdu_and_seq_lists(
496 * Only called while DataSequenceInOrder=No or DataPDUInOrder=No.
497 */
498int iscsit_do_build_list(
499 struct iscsi_cmd *cmd, 498 struct iscsi_cmd *cmd,
500 struct iscsi_build_list *bl) 499 u32 immediate_data_length)
501{ 500{
501 struct iscsi_build_list bl;
502 u32 pdu_count = 0, seq_count = 1; 502 u32 pdu_count = 0, seq_count = 1;
503 struct iscsi_conn *conn = cmd->conn; 503 struct iscsi_conn *conn = cmd->conn;
504 struct iscsi_pdu *pdu = NULL; 504 struct iscsi_pdu *pdu = NULL;
505 struct iscsi_seq *seq = NULL; 505 struct iscsi_seq *seq = NULL;
506 506
507 iscsit_determine_counts_for_list(cmd, bl, &seq_count, &pdu_count); 507 struct iscsi_session *sess = conn->sess;
508 struct iscsi_node_attrib *na;
509
510 /*
511 * Do nothing if no OOO shenanigans
512 */
513 if (sess->sess_ops->DataSequenceInOrder &&
514 sess->sess_ops->DataPDUInOrder)
515 return 0;
516
517 if (cmd->data_direction == DMA_NONE)
518 return 0;
519
520 na = iscsit_tpg_get_node_attrib(sess);
521 memset(&bl, 0, sizeof(struct iscsi_build_list));
522
523 if (cmd->data_direction == DMA_FROM_DEVICE) {
524 bl.data_direction = ISCSI_PDU_READ;
525 bl.type = PDULIST_NORMAL;
526 if (na->random_datain_pdu_offsets)
527 bl.randomize |= RANDOM_DATAIN_PDU_OFFSETS;
528 if (na->random_datain_seq_offsets)
529 bl.randomize |= RANDOM_DATAIN_SEQ_OFFSETS;
530 } else {
531 bl.data_direction = ISCSI_PDU_WRITE;
532 bl.immediate_data_length = immediate_data_length;
533 if (na->random_r2t_offsets)
534 bl.randomize |= RANDOM_R2T_OFFSETS;
535
536 if (!cmd->immediate_data && !cmd->unsolicited_data)
537 bl.type = PDULIST_NORMAL;
538 else if (cmd->immediate_data && !cmd->unsolicited_data)
539 bl.type = PDULIST_IMMEDIATE;
540 else if (!cmd->immediate_data && cmd->unsolicited_data)
541 bl.type = PDULIST_UNSOLICITED;
542 else if (cmd->immediate_data && cmd->unsolicited_data)
543 bl.type = PDULIST_IMMEDIATE_AND_UNSOLICITED;
544 }
545
546 iscsit_determine_counts_for_list(cmd, &bl, &seq_count, &pdu_count);
508 547
509 if (!conn->sess->sess_ops->DataSequenceInOrder) { 548 if (!conn->sess->sess_ops->DataSequenceInOrder) {
510 seq = kzalloc(seq_count * sizeof(struct iscsi_seq), GFP_ATOMIC); 549 seq = kcalloc(seq_count, sizeof(struct iscsi_seq), GFP_ATOMIC);
511 if (!seq) { 550 if (!seq) {
512 pr_err("Unable to allocate struct iscsi_seq list\n"); 551 pr_err("Unable to allocate struct iscsi_seq list\n");
513 return -1; 552 return -ENOMEM;
514 } 553 }
515 cmd->seq_list = seq; 554 cmd->seq_list = seq;
516 cmd->seq_count = seq_count; 555 cmd->seq_count = seq_count;
517 } 556 }
518 557
519 if (!conn->sess->sess_ops->DataPDUInOrder) { 558 if (!conn->sess->sess_ops->DataPDUInOrder) {
520 pdu = kzalloc(pdu_count * sizeof(struct iscsi_pdu), GFP_ATOMIC); 559 pdu = kcalloc(pdu_count, sizeof(struct iscsi_pdu), GFP_ATOMIC);
521 if (!pdu) { 560 if (!pdu) {
522 pr_err("Unable to allocate struct iscsi_pdu list.\n"); 561 pr_err("Unable to allocate struct iscsi_pdu list.\n");
523 kfree(seq); 562 kfree(seq);
524 return -1; 563 return -ENOMEM;
525 } 564 }
526 cmd->pdu_list = pdu; 565 cmd->pdu_list = pdu;
527 cmd->pdu_count = pdu_count; 566 cmd->pdu_count = pdu_count;
528 } 567 }
529 568
530 return iscsit_build_pdu_and_seq_list(cmd, bl); 569 return iscsit_do_build_pdu_and_seq_lists(cmd, &bl);
531} 570}
532 571
533struct iscsi_pdu *iscsit_get_pdu_holder( 572struct iscsi_pdu *iscsit_get_pdu_holder(
@@ -572,13 +611,12 @@ redo:
572 pdu = &cmd->pdu_list[cmd->pdu_start]; 611 pdu = &cmd->pdu_list[cmd->pdu_start];
573 612
574 for (i = 0; pdu[i].seq_no != cmd->seq_no; i++) { 613 for (i = 0; pdu[i].seq_no != cmd->seq_no; i++) {
575#if 0
576 pr_debug("pdu[i].seq_no: %d, pdu[i].pdu" 614 pr_debug("pdu[i].seq_no: %d, pdu[i].pdu"
577 "_send_order: %d, pdu[i].offset: %d," 615 "_send_order: %d, pdu[i].offset: %d,"
578 " pdu[i].length: %d\n", pdu[i].seq_no, 616 " pdu[i].length: %d\n", pdu[i].seq_no,
579 pdu[i].pdu_send_order, pdu[i].offset, 617 pdu[i].pdu_send_order, pdu[i].offset,
580 pdu[i].length); 618 pdu[i].length);
581#endif 619
582 if (pdu[i].pdu_send_order == cmd->pdu_send_order) { 620 if (pdu[i].pdu_send_order == cmd->pdu_send_order) {
583 cmd->pdu_send_order++; 621 cmd->pdu_send_order++;
584 return &pdu[i]; 622 return &pdu[i];
@@ -601,11 +639,11 @@ redo:
601 pr_err("struct iscsi_seq is NULL!\n"); 639 pr_err("struct iscsi_seq is NULL!\n");
602 return NULL; 640 return NULL;
603 } 641 }
604#if 0 642
605 pr_debug("seq->pdu_start: %d, seq->pdu_count: %d," 643 pr_debug("seq->pdu_start: %d, seq->pdu_count: %d,"
606 " seq->seq_no: %d\n", seq->pdu_start, seq->pdu_count, 644 " seq->seq_no: %d\n", seq->pdu_start, seq->pdu_count,
607 seq->seq_no); 645 seq->seq_no);
608#endif 646
609 pdu = &cmd->pdu_list[seq->pdu_start]; 647 pdu = &cmd->pdu_list[seq->pdu_start];
610 648
611 if (seq->pdu_send_order == seq->pdu_count) { 649 if (seq->pdu_send_order == seq->pdu_count) {
@@ -645,12 +683,11 @@ struct iscsi_seq *iscsit_get_seq_holder(
645 } 683 }
646 684
647 for (i = 0; i < cmd->seq_count; i++) { 685 for (i = 0; i < cmd->seq_count; i++) {
648#if 0
649 pr_debug("seq_list[i].orig_offset: %d, seq_list[i]." 686 pr_debug("seq_list[i].orig_offset: %d, seq_list[i]."
650 "xfer_len: %d, seq_list[i].seq_no %u\n", 687 "xfer_len: %d, seq_list[i].seq_no %u\n",
651 cmd->seq_list[i].orig_offset, cmd->seq_list[i].xfer_len, 688 cmd->seq_list[i].orig_offset, cmd->seq_list[i].xfer_len,
652 cmd->seq_list[i].seq_no); 689 cmd->seq_list[i].seq_no);
653#endif 690
654 if ((cmd->seq_list[i].orig_offset + 691 if ((cmd->seq_list[i].orig_offset +
655 cmd->seq_list[i].xfer_len) >= 692 cmd->seq_list[i].xfer_len) >=
656 (offset + length)) 693 (offset + length))
diff --git a/drivers/target/iscsi/iscsi_target_seq_pdu_list.h b/drivers/target/iscsi/iscsi_target_seq_pdu_list.h
index 0d52a10e3069..d5b153751a8d 100644
--- a/drivers/target/iscsi/iscsi_target_seq_pdu_list.h
+++ b/drivers/target/iscsi/iscsi_target_seq_pdu_list.h
@@ -78,7 +78,7 @@ struct iscsi_seq {
78 u32 xfer_len; 78 u32 xfer_len;
79} ____cacheline_aligned; 79} ____cacheline_aligned;
80 80
81extern int iscsit_do_build_list(struct iscsi_cmd *, struct iscsi_build_list *); 81extern int iscsit_build_pdu_and_seq_lists(struct iscsi_cmd *, u32);
82extern struct iscsi_pdu *iscsit_get_pdu_holder(struct iscsi_cmd *, u32, u32); 82extern struct iscsi_pdu *iscsit_get_pdu_holder(struct iscsi_cmd *, u32, u32);
83extern struct iscsi_pdu *iscsit_get_pdu_holder_for_seq(struct iscsi_cmd *, struct iscsi_seq *); 83extern struct iscsi_pdu *iscsit_get_pdu_holder_for_seq(struct iscsi_cmd *, struct iscsi_seq *);
84extern struct iscsi_seq *iscsit_get_seq_holder(struct iscsi_cmd *, u32, u32); 84extern struct iscsi_seq *iscsit_get_seq_holder(struct iscsi_cmd *, u32, u32);
diff --git a/drivers/target/iscsi/iscsi_target_tmr.c b/drivers/target/iscsi/iscsi_target_tmr.c
index e01da9d2b37e..f4e640b51fd1 100644
--- a/drivers/target/iscsi/iscsi_target_tmr.c
+++ b/drivers/target/iscsi/iscsi_target_tmr.c
@@ -78,10 +78,7 @@ int iscsit_tmr_task_warm_reset(
78{ 78{
79 struct iscsi_session *sess = conn->sess; 79 struct iscsi_session *sess = conn->sess;
80 struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess); 80 struct iscsi_node_attrib *na = iscsit_tpg_get_node_attrib(sess);
81#if 0 81
82 struct iscsi_init_task_mgt_cmnd *hdr =
83 (struct iscsi_init_task_mgt_cmnd *) buf;
84#endif
85 if (!na->tmr_warm_reset) { 82 if (!na->tmr_warm_reset) {
86 pr_err("TMR Opcode TARGET_WARM_RESET authorization" 83 pr_err("TMR Opcode TARGET_WARM_RESET authorization"
87 " failed for Initiator Node: %s\n", 84 " failed for Initiator Node: %s\n",
@@ -216,7 +213,7 @@ static int iscsit_task_reassign_complete_nop_out(
216 iscsit_task_reassign_remove_cmd(cmd, cr, conn->sess); 213 iscsit_task_reassign_remove_cmd(cmd, cr, conn->sess);
217 214
218 spin_lock_bh(&conn->cmd_lock); 215 spin_lock_bh(&conn->cmd_lock);
219 list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 216 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
220 spin_unlock_bh(&conn->cmd_lock); 217 spin_unlock_bh(&conn->cmd_lock);
221 218
222 cmd->i_state = ISTATE_SEND_NOPIN; 219 cmd->i_state = ISTATE_SEND_NOPIN;
@@ -272,9 +269,9 @@ static int iscsit_task_reassign_complete_write(
272 offset = cmd->next_burst_len = cmd->write_data_done; 269 offset = cmd->next_burst_len = cmd->write_data_done;
273 270
274 if ((conn->sess->sess_ops->FirstBurstLength - offset) >= 271 if ((conn->sess->sess_ops->FirstBurstLength - offset) >=
275 cmd->data_length) { 272 cmd->se_cmd.data_length) {
276 no_build_r2ts = 1; 273 no_build_r2ts = 1;
277 length = (cmd->data_length - offset); 274 length = (cmd->se_cmd.data_length - offset);
278 } else 275 } else
279 length = (conn->sess->sess_ops->FirstBurstLength - offset); 276 length = (conn->sess->sess_ops->FirstBurstLength - offset);
280 277
@@ -292,7 +289,7 @@ static int iscsit_task_reassign_complete_write(
292 /* 289 /*
293 * iscsit_build_r2ts_for_cmd() can handle the rest from here. 290 * iscsit_build_r2ts_for_cmd() can handle the rest from here.
294 */ 291 */
295 return iscsit_build_r2ts_for_cmd(cmd, conn, 2); 292 return iscsit_build_r2ts_for_cmd(cmd, conn, true);
296} 293}
297 294
298static int iscsit_task_reassign_complete_read( 295static int iscsit_task_reassign_complete_read(
@@ -385,7 +382,7 @@ static int iscsit_task_reassign_complete_scsi_cmnd(
385 iscsit_task_reassign_remove_cmd(cmd, cr, conn->sess); 382 iscsit_task_reassign_remove_cmd(cmd, cr, conn->sess);
386 383
387 spin_lock_bh(&conn->cmd_lock); 384 spin_lock_bh(&conn->cmd_lock);
388 list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 385 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
389 spin_unlock_bh(&conn->cmd_lock); 386 spin_unlock_bh(&conn->cmd_lock);
390 387
391 if (se_cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION) { 388 if (se_cmd->se_cmd_flags & SCF_SENT_CHECK_CONDITION) {
diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c
index 4eba86d2bd82..b42cdeb153df 100644
--- a/drivers/target/iscsi/iscsi_target_util.c
+++ b/drivers/target/iscsi/iscsi_target_util.c
@@ -163,7 +163,7 @@ struct iscsi_cmd *iscsit_allocate_cmd(struct iscsi_conn *conn, gfp_t gfp_mask)
163 } 163 }
164 164
165 cmd->conn = conn; 165 cmd->conn = conn;
166 INIT_LIST_HEAD(&cmd->i_list); 166 INIT_LIST_HEAD(&cmd->i_conn_node);
167 INIT_LIST_HEAD(&cmd->datain_list); 167 INIT_LIST_HEAD(&cmd->datain_list);
168 INIT_LIST_HEAD(&cmd->cmd_r2t_list); 168 INIT_LIST_HEAD(&cmd->cmd_r2t_list);
169 init_completion(&cmd->reject_comp); 169 init_completion(&cmd->reject_comp);
@@ -176,174 +176,6 @@ struct iscsi_cmd *iscsit_allocate_cmd(struct iscsi_conn *conn, gfp_t gfp_mask)
176 return cmd; 176 return cmd;
177} 177}
178 178
179/*
180 * Called from iscsi_handle_scsi_cmd()
181 */
182struct iscsi_cmd *iscsit_allocate_se_cmd(
183 struct iscsi_conn *conn,
184 u32 data_length,
185 int data_direction,
186 int iscsi_task_attr)
187{
188 struct iscsi_cmd *cmd;
189 struct se_cmd *se_cmd;
190 int sam_task_attr;
191
192 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL);
193 if (!cmd)
194 return NULL;
195
196 cmd->data_direction = data_direction;
197 cmd->data_length = data_length;
198 /*
199 * Figure out the SAM Task Attribute for the incoming SCSI CDB
200 */
201 if ((iscsi_task_attr == ISCSI_ATTR_UNTAGGED) ||
202 (iscsi_task_attr == ISCSI_ATTR_SIMPLE))
203 sam_task_attr = MSG_SIMPLE_TAG;
204 else if (iscsi_task_attr == ISCSI_ATTR_ORDERED)
205 sam_task_attr = MSG_ORDERED_TAG;
206 else if (iscsi_task_attr == ISCSI_ATTR_HEAD_OF_QUEUE)
207 sam_task_attr = MSG_HEAD_TAG;
208 else if (iscsi_task_attr == ISCSI_ATTR_ACA)
209 sam_task_attr = MSG_ACA_TAG;
210 else {
211 pr_debug("Unknown iSCSI Task Attribute: 0x%02x, using"
212 " MSG_SIMPLE_TAG\n", iscsi_task_attr);
213 sam_task_attr = MSG_SIMPLE_TAG;
214 }
215
216 se_cmd = &cmd->se_cmd;
217 /*
218 * Initialize struct se_cmd descriptor from target_core_mod infrastructure
219 */
220 transport_init_se_cmd(se_cmd, &lio_target_fabric_configfs->tf_ops,
221 conn->sess->se_sess, data_length, data_direction,
222 sam_task_attr, &cmd->sense_buffer[0]);
223 return cmd;
224}
225
226struct iscsi_cmd *iscsit_allocate_se_cmd_for_tmr(
227 struct iscsi_conn *conn,
228 u8 function)
229{
230 struct iscsi_cmd *cmd;
231 struct se_cmd *se_cmd;
232 int rc;
233 u8 tcm_function;
234
235 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL);
236 if (!cmd)
237 return NULL;
238
239 cmd->data_direction = DMA_NONE;
240
241 cmd->tmr_req = kzalloc(sizeof(struct iscsi_tmr_req), GFP_KERNEL);
242 if (!cmd->tmr_req) {
243 pr_err("Unable to allocate memory for"
244 " Task Management command!\n");
245 goto out;
246 }
247 /*
248 * TASK_REASSIGN for ERL=2 / connection stays inside of
249 * LIO-Target $FABRIC_MOD
250 */
251 if (function == ISCSI_TM_FUNC_TASK_REASSIGN)
252 return cmd;
253
254 se_cmd = &cmd->se_cmd;
255 /*
256 * Initialize struct se_cmd descriptor from target_core_mod infrastructure
257 */
258 transport_init_se_cmd(se_cmd, &lio_target_fabric_configfs->tf_ops,
259 conn->sess->se_sess, 0, DMA_NONE,
260 MSG_SIMPLE_TAG, &cmd->sense_buffer[0]);
261
262 switch (function) {
263 case ISCSI_TM_FUNC_ABORT_TASK:
264 tcm_function = TMR_ABORT_TASK;
265 break;
266 case ISCSI_TM_FUNC_ABORT_TASK_SET:
267 tcm_function = TMR_ABORT_TASK_SET;
268 break;
269 case ISCSI_TM_FUNC_CLEAR_ACA:
270 tcm_function = TMR_CLEAR_ACA;
271 break;
272 case ISCSI_TM_FUNC_CLEAR_TASK_SET:
273 tcm_function = TMR_CLEAR_TASK_SET;
274 break;
275 case ISCSI_TM_FUNC_LOGICAL_UNIT_RESET:
276 tcm_function = TMR_LUN_RESET;
277 break;
278 case ISCSI_TM_FUNC_TARGET_WARM_RESET:
279 tcm_function = TMR_TARGET_WARM_RESET;
280 break;
281 case ISCSI_TM_FUNC_TARGET_COLD_RESET:
282 tcm_function = TMR_TARGET_COLD_RESET;
283 break;
284 default:
285 pr_err("Unknown iSCSI TMR Function:"
286 " 0x%02x\n", function);
287 goto out;
288 }
289
290 rc = core_tmr_alloc_req(se_cmd, cmd->tmr_req, tcm_function, GFP_KERNEL);
291 if (rc < 0)
292 goto out;
293
294 cmd->tmr_req->se_tmr_req = se_cmd->se_tmr_req;
295
296 return cmd;
297out:
298 iscsit_release_cmd(cmd);
299 return NULL;
300}
301
302int iscsit_decide_list_to_build(
303 struct iscsi_cmd *cmd,
304 u32 immediate_data_length)
305{
306 struct iscsi_build_list bl;
307 struct iscsi_conn *conn = cmd->conn;
308 struct iscsi_session *sess = conn->sess;
309 struct iscsi_node_attrib *na;
310
311 if (sess->sess_ops->DataSequenceInOrder &&
312 sess->sess_ops->DataPDUInOrder)
313 return 0;
314
315 if (cmd->data_direction == DMA_NONE)
316 return 0;
317
318 na = iscsit_tpg_get_node_attrib(sess);
319 memset(&bl, 0, sizeof(struct iscsi_build_list));
320
321 if (cmd->data_direction == DMA_FROM_DEVICE) {
322 bl.data_direction = ISCSI_PDU_READ;
323 bl.type = PDULIST_NORMAL;
324 if (na->random_datain_pdu_offsets)
325 bl.randomize |= RANDOM_DATAIN_PDU_OFFSETS;
326 if (na->random_datain_seq_offsets)
327 bl.randomize |= RANDOM_DATAIN_SEQ_OFFSETS;
328 } else {
329 bl.data_direction = ISCSI_PDU_WRITE;
330 bl.immediate_data_length = immediate_data_length;
331 if (na->random_r2t_offsets)
332 bl.randomize |= RANDOM_R2T_OFFSETS;
333
334 if (!cmd->immediate_data && !cmd->unsolicited_data)
335 bl.type = PDULIST_NORMAL;
336 else if (cmd->immediate_data && !cmd->unsolicited_data)
337 bl.type = PDULIST_IMMEDIATE;
338 else if (!cmd->immediate_data && cmd->unsolicited_data)
339 bl.type = PDULIST_UNSOLICITED;
340 else if (cmd->immediate_data && cmd->unsolicited_data)
341 bl.type = PDULIST_IMMEDIATE_AND_UNSOLICITED;
342 }
343
344 return iscsit_do_build_list(cmd, &bl);
345}
346
347struct iscsi_seq *iscsit_get_seq_holder_for_datain( 179struct iscsi_seq *iscsit_get_seq_holder_for_datain(
348 struct iscsi_cmd *cmd, 180 struct iscsi_cmd *cmd,
349 u32 seq_send_order) 181 u32 seq_send_order)
@@ -502,14 +334,14 @@ int iscsit_check_unsolicited_dataout(struct iscsi_cmd *cmd, unsigned char *buf)
502 if (!(hdr->flags & ISCSI_FLAG_CMD_FINAL)) 334 if (!(hdr->flags & ISCSI_FLAG_CMD_FINAL))
503 return 0; 335 return 0;
504 336
505 if (((cmd->first_burst_len + payload_length) != cmd->data_length) && 337 if (((cmd->first_burst_len + payload_length) != cmd->se_cmd.data_length) &&
506 ((cmd->first_burst_len + payload_length) != 338 ((cmd->first_burst_len + payload_length) !=
507 conn->sess->sess_ops->FirstBurstLength)) { 339 conn->sess->sess_ops->FirstBurstLength)) {
508 pr_err("Unsolicited non-immediate data received %u" 340 pr_err("Unsolicited non-immediate data received %u"
509 " does not equal FirstBurstLength: %u, and does" 341 " does not equal FirstBurstLength: %u, and does"
510 " not equal ExpXferLen %u.\n", 342 " not equal ExpXferLen %u.\n",
511 (cmd->first_burst_len + payload_length), 343 (cmd->first_burst_len + payload_length),
512 conn->sess->sess_ops->FirstBurstLength, cmd->data_length); 344 conn->sess->sess_ops->FirstBurstLength, cmd->se_cmd.data_length);
513 transport_send_check_condition_and_sense(se_cmd, 345 transport_send_check_condition_and_sense(se_cmd,
514 TCM_INCORRECT_AMOUNT_OF_DATA, 0); 346 TCM_INCORRECT_AMOUNT_OF_DATA, 0);
515 return -1; 347 return -1;
@@ -524,7 +356,7 @@ struct iscsi_cmd *iscsit_find_cmd_from_itt(
524 struct iscsi_cmd *cmd; 356 struct iscsi_cmd *cmd;
525 357
526 spin_lock_bh(&conn->cmd_lock); 358 spin_lock_bh(&conn->cmd_lock);
527 list_for_each_entry(cmd, &conn->conn_cmd_list, i_list) { 359 list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
528 if (cmd->init_task_tag == init_task_tag) { 360 if (cmd->init_task_tag == init_task_tag) {
529 spin_unlock_bh(&conn->cmd_lock); 361 spin_unlock_bh(&conn->cmd_lock);
530 return cmd; 362 return cmd;
@@ -545,7 +377,7 @@ struct iscsi_cmd *iscsit_find_cmd_from_itt_or_dump(
545 struct iscsi_cmd *cmd; 377 struct iscsi_cmd *cmd;
546 378
547 spin_lock_bh(&conn->cmd_lock); 379 spin_lock_bh(&conn->cmd_lock);
548 list_for_each_entry(cmd, &conn->conn_cmd_list, i_list) { 380 list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
549 if (cmd->init_task_tag == init_task_tag) { 381 if (cmd->init_task_tag == init_task_tag) {
550 spin_unlock_bh(&conn->cmd_lock); 382 spin_unlock_bh(&conn->cmd_lock);
551 return cmd; 383 return cmd;
@@ -568,7 +400,7 @@ struct iscsi_cmd *iscsit_find_cmd_from_ttt(
568 struct iscsi_cmd *cmd = NULL; 400 struct iscsi_cmd *cmd = NULL;
569 401
570 spin_lock_bh(&conn->cmd_lock); 402 spin_lock_bh(&conn->cmd_lock);
571 list_for_each_entry(cmd, &conn->conn_cmd_list, i_list) { 403 list_for_each_entry(cmd, &conn->conn_cmd_list, i_conn_node) {
572 if (cmd->targ_xfer_tag == targ_xfer_tag) { 404 if (cmd->targ_xfer_tag == targ_xfer_tag) {
573 spin_unlock_bh(&conn->cmd_lock); 405 spin_unlock_bh(&conn->cmd_lock);
574 return cmd; 406 return cmd;
@@ -596,7 +428,7 @@ int iscsit_find_cmd_for_recovery(
596 spin_lock(&sess->cr_i_lock); 428 spin_lock(&sess->cr_i_lock);
597 list_for_each_entry(cr, &sess->cr_inactive_list, cr_list) { 429 list_for_each_entry(cr, &sess->cr_inactive_list, cr_list) {
598 spin_lock(&cr->conn_recovery_cmd_lock); 430 spin_lock(&cr->conn_recovery_cmd_lock);
599 list_for_each_entry(cmd, &cr->conn_recovery_cmd_list, i_list) { 431 list_for_each_entry(cmd, &cr->conn_recovery_cmd_list, i_conn_node) {
600 if (cmd->init_task_tag == init_task_tag) { 432 if (cmd->init_task_tag == init_task_tag) {
601 spin_unlock(&cr->conn_recovery_cmd_lock); 433 spin_unlock(&cr->conn_recovery_cmd_lock);
602 spin_unlock(&sess->cr_i_lock); 434 spin_unlock(&sess->cr_i_lock);
@@ -616,7 +448,7 @@ int iscsit_find_cmd_for_recovery(
616 spin_lock(&sess->cr_a_lock); 448 spin_lock(&sess->cr_a_lock);
617 list_for_each_entry(cr, &sess->cr_active_list, cr_list) { 449 list_for_each_entry(cr, &sess->cr_active_list, cr_list) {
618 spin_lock(&cr->conn_recovery_cmd_lock); 450 spin_lock(&cr->conn_recovery_cmd_lock);
619 list_for_each_entry(cmd, &cr->conn_recovery_cmd_list, i_list) { 451 list_for_each_entry(cmd, &cr->conn_recovery_cmd_list, i_conn_node) {
620 if (cmd->init_task_tag == init_task_tag) { 452 if (cmd->init_task_tag == init_task_tag) {
621 spin_unlock(&cr->conn_recovery_cmd_lock); 453 spin_unlock(&cr->conn_recovery_cmd_lock);
622 spin_unlock(&sess->cr_a_lock); 454 spin_unlock(&sess->cr_a_lock);
@@ -813,7 +645,6 @@ void iscsit_free_queue_reqs_for_conn(struct iscsi_conn *conn)
813void iscsit_release_cmd(struct iscsi_cmd *cmd) 645void iscsit_release_cmd(struct iscsi_cmd *cmd)
814{ 646{
815 struct iscsi_conn *conn = cmd->conn; 647 struct iscsi_conn *conn = cmd->conn;
816 int i;
817 648
818 iscsit_free_r2ts_from_list(cmd); 649 iscsit_free_r2ts_from_list(cmd);
819 iscsit_free_all_datain_reqs(cmd); 650 iscsit_free_all_datain_reqs(cmd);
@@ -824,11 +655,6 @@ void iscsit_release_cmd(struct iscsi_cmd *cmd)
824 kfree(cmd->tmr_req); 655 kfree(cmd->tmr_req);
825 kfree(cmd->iov_data); 656 kfree(cmd->iov_data);
826 657
827 for (i = 0; i < cmd->t_mem_sg_nents; i++)
828 __free_page(sg_page(&cmd->t_mem_sg[i]));
829
830 kfree(cmd->t_mem_sg);
831
832 if (conn) { 658 if (conn) {
833 iscsit_remove_cmd_from_immediate_queue(cmd, conn); 659 iscsit_remove_cmd_from_immediate_queue(cmd, conn);
834 iscsit_remove_cmd_from_response_queue(cmd, conn); 660 iscsit_remove_cmd_from_response_queue(cmd, conn);
@@ -1038,7 +864,7 @@ static int iscsit_add_nopin(struct iscsi_conn *conn, int want_response)
1038 spin_unlock_bh(&conn->sess->ttt_lock); 864 spin_unlock_bh(&conn->sess->ttt_lock);
1039 865
1040 spin_lock_bh(&conn->cmd_lock); 866 spin_lock_bh(&conn->cmd_lock);
1041 list_add_tail(&cmd->i_list, &conn->conn_cmd_list); 867 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
1042 spin_unlock_bh(&conn->cmd_lock); 868 spin_unlock_bh(&conn->cmd_lock);
1043 869
1044 if (want_response) 870 if (want_response)
diff --git a/drivers/target/iscsi/iscsi_target_util.h b/drivers/target/iscsi/iscsi_target_util.h
index 835bf7de0281..e1c729b8a1c5 100644
--- a/drivers/target/iscsi/iscsi_target_util.h
+++ b/drivers/target/iscsi/iscsi_target_util.h
@@ -9,9 +9,6 @@ extern struct iscsi_r2t *iscsit_get_r2t_from_list(struct iscsi_cmd *);
9extern void iscsit_free_r2t(struct iscsi_r2t *, struct iscsi_cmd *); 9extern void iscsit_free_r2t(struct iscsi_r2t *, struct iscsi_cmd *);
10extern void iscsit_free_r2ts_from_list(struct iscsi_cmd *); 10extern void iscsit_free_r2ts_from_list(struct iscsi_cmd *);
11extern struct iscsi_cmd *iscsit_allocate_cmd(struct iscsi_conn *, gfp_t); 11extern struct iscsi_cmd *iscsit_allocate_cmd(struct iscsi_conn *, gfp_t);
12extern struct iscsi_cmd *iscsit_allocate_se_cmd(struct iscsi_conn *, u32, int, int);
13extern struct iscsi_cmd *iscsit_allocate_se_cmd_for_tmr(struct iscsi_conn *, u8);
14extern int iscsit_decide_list_to_build(struct iscsi_cmd *, u32);
15extern struct iscsi_seq *iscsit_get_seq_holder_for_datain(struct iscsi_cmd *, u32); 12extern struct iscsi_seq *iscsit_get_seq_holder_for_datain(struct iscsi_cmd *, u32);
16extern struct iscsi_seq *iscsit_get_seq_holder_for_r2t(struct iscsi_cmd *); 13extern struct iscsi_seq *iscsit_get_seq_holder_for_r2t(struct iscsi_cmd *);
17extern struct iscsi_r2t *iscsit_get_holder_for_r2tsn(struct iscsi_cmd *, u32); 14extern struct iscsi_r2t *iscsit_get_holder_for_r2tsn(struct iscsi_cmd *, u32);
diff --git a/drivers/target/loopback/tcm_loop.c b/drivers/target/loopback/tcm_loop.c
index a9b4eeefe9fc..38dfac2b0a1c 100644
--- a/drivers/target/loopback/tcm_loop.c
+++ b/drivers/target/loopback/tcm_loop.c
@@ -213,7 +213,7 @@ static void tcm_loop_submission_work(struct work_struct *work)
213 * associated read buffers, go ahead and do that here for type 213 * associated read buffers, go ahead and do that here for type
214 * SCF_SCSI_CONTROL_SG_IO_CDB. Also note that this is currently 214 * SCF_SCSI_CONTROL_SG_IO_CDB. Also note that this is currently
215 * guaranteed to be a single SGL for SCF_SCSI_CONTROL_SG_IO_CDB 215 * guaranteed to be a single SGL for SCF_SCSI_CONTROL_SG_IO_CDB
216 * by target core in transport_generic_allocate_tasks() -> 216 * by target core in target_setup_cmd_from_cdb() ->
217 * transport_generic_cmd_sequencer(). 217 * transport_generic_cmd_sequencer().
218 */ 218 */
219 if (se_cmd->se_cmd_flags & SCF_SCSI_CONTROL_SG_IO_CDB && 219 if (se_cmd->se_cmd_flags & SCF_SCSI_CONTROL_SG_IO_CDB &&
@@ -227,7 +227,7 @@ static void tcm_loop_submission_work(struct work_struct *work)
227 } 227 }
228 } 228 }
229 229
230 ret = transport_generic_allocate_tasks(se_cmd, sc->cmnd); 230 ret = target_setup_cmd_from_cdb(se_cmd, sc->cmnd);
231 if (ret == -ENOMEM) { 231 if (ret == -ENOMEM) {
232 transport_send_check_condition_and_sense(se_cmd, 232 transport_send_check_condition_and_sense(se_cmd,
233 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE, 0); 233 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE, 0);
diff --git a/drivers/target/target_core_alua.c b/drivers/target/target_core_alua.c
index c7746a3339d4..e624b836469c 100644
--- a/drivers/target/target_core_alua.c
+++ b/drivers/target/target_core_alua.c
@@ -59,26 +59,31 @@ struct t10_alua_lu_gp *default_lu_gp;
59 * 59 *
60 * See spc4r17 section 6.27 60 * See spc4r17 section 6.27
61 */ 61 */
62int target_emulate_report_target_port_groups(struct se_task *task) 62int target_emulate_report_target_port_groups(struct se_cmd *cmd)
63{ 63{
64 struct se_cmd *cmd = task->task_se_cmd;
65 struct se_subsystem_dev *su_dev = cmd->se_dev->se_sub_dev; 64 struct se_subsystem_dev *su_dev = cmd->se_dev->se_sub_dev;
66 struct se_port *port; 65 struct se_port *port;
67 struct t10_alua_tg_pt_gp *tg_pt_gp; 66 struct t10_alua_tg_pt_gp *tg_pt_gp;
68 struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem; 67 struct t10_alua_tg_pt_gp_member *tg_pt_gp_mem;
69 unsigned char *buf; 68 unsigned char *buf;
70 u32 rd_len = 0, off = 4; /* Skip over RESERVED area to first 69 u32 rd_len = 0, off;
71 Target port group descriptor */ 70 int ext_hdr = (cmd->t_task_cdb[1] & 0x20);
72 /* 71 /*
73 * Need at least 4 bytes of response data or else we can't 72 * Skip over RESERVED area to first Target port group descriptor
74 * even fit the return data length. 73 * depending on the PARAMETER DATA FORMAT type..
75 */ 74 */
76 if (cmd->data_length < 4) { 75 if (ext_hdr != 0)
77 pr_warn("REPORT TARGET PORT GROUPS allocation length %u" 76 off = 8;
78 " too small\n", cmd->data_length); 77 else
78 off = 4;
79
80 if (cmd->data_length < off) {
81 pr_warn("REPORT TARGET PORT GROUPS allocation length %u too"
82 " small for %s header\n", cmd->data_length,
83 (ext_hdr) ? "extended" : "normal");
84 cmd->scsi_sense_reason = TCM_INVALID_CDB_FIELD;
79 return -EINVAL; 85 return -EINVAL;
80 } 86 }
81
82 buf = transport_kmap_data_sg(cmd); 87 buf = transport_kmap_data_sg(cmd);
83 88
84 spin_lock(&su_dev->t10_alua.tg_pt_gps_lock); 89 spin_lock(&su_dev->t10_alua.tg_pt_gps_lock);
@@ -159,15 +164,34 @@ int target_emulate_report_target_port_groups(struct se_task *task)
159 /* 164 /*
160 * Set the RETURN DATA LENGTH set in the header of the DataIN Payload 165 * Set the RETURN DATA LENGTH set in the header of the DataIN Payload
161 */ 166 */
162 buf[0] = ((rd_len >> 24) & 0xff); 167 put_unaligned_be32(rd_len, &buf[0]);
163 buf[1] = ((rd_len >> 16) & 0xff);
164 buf[2] = ((rd_len >> 8) & 0xff);
165 buf[3] = (rd_len & 0xff);
166 168
169 /*
170 * Fill in the Extended header parameter data format if requested
171 */
172 if (ext_hdr != 0) {
173 buf[4] = 0x10;
174 /*
175 * Set the implict transition time (in seconds) for the application
176 * client to use as a base for it's transition timeout value.
177 *
178 * Use the current tg_pt_gp_mem -> tg_pt_gp membership from the LUN
179 * this CDB was received upon to determine this value individually
180 * for ALUA target port group.
181 */
182 port = cmd->se_lun->lun_sep;
183 tg_pt_gp_mem = port->sep_alua_tg_pt_gp_mem;
184 if (tg_pt_gp_mem) {
185 spin_lock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
186 tg_pt_gp = tg_pt_gp_mem->tg_pt_gp;
187 if (tg_pt_gp)
188 buf[5] = tg_pt_gp->tg_pt_gp_implict_trans_secs;
189 spin_unlock(&tg_pt_gp_mem->tg_pt_gp_mem_lock);
190 }
191 }
167 transport_kunmap_data_sg(cmd); 192 transport_kunmap_data_sg(cmd);
168 193
169 task->task_scsi_status = GOOD; 194 target_complete_cmd(cmd, GOOD);
170 transport_complete_task(task, 1);
171 return 0; 195 return 0;
172} 196}
173 197
@@ -176,9 +200,8 @@ int target_emulate_report_target_port_groups(struct se_task *task)
176 * 200 *
177 * See spc4r17 section 6.35 201 * See spc4r17 section 6.35
178 */ 202 */
179int target_emulate_set_target_port_groups(struct se_task *task) 203int target_emulate_set_target_port_groups(struct se_cmd *cmd)
180{ 204{
181 struct se_cmd *cmd = task->task_se_cmd;
182 struct se_device *dev = cmd->se_dev; 205 struct se_device *dev = cmd->se_dev;
183 struct se_subsystem_dev *su_dev = dev->se_sub_dev; 206 struct se_subsystem_dev *su_dev = dev->se_sub_dev;
184 struct se_port *port, *l_port = cmd->se_lun->lun_sep; 207 struct se_port *port, *l_port = cmd->se_lun->lun_sep;
@@ -351,8 +374,7 @@ int target_emulate_set_target_port_groups(struct se_task *task)
351 374
352out: 375out:
353 transport_kunmap_data_sg(cmd); 376 transport_kunmap_data_sg(cmd);
354 task->task_scsi_status = GOOD; 377 target_complete_cmd(cmd, GOOD);
355 transport_complete_task(task, 1);
356 return 0; 378 return 0;
357} 379}
358 380
@@ -391,7 +413,7 @@ static inline int core_alua_state_standby(
391 case RECEIVE_DIAGNOSTIC: 413 case RECEIVE_DIAGNOSTIC:
392 case SEND_DIAGNOSTIC: 414 case SEND_DIAGNOSTIC:
393 case MAINTENANCE_IN: 415 case MAINTENANCE_IN:
394 switch (cdb[1]) { 416 switch (cdb[1] & 0x1f) {
395 case MI_REPORT_TARGET_PGS: 417 case MI_REPORT_TARGET_PGS:
396 return 0; 418 return 0;
397 default: 419 default:
@@ -433,7 +455,7 @@ static inline int core_alua_state_unavailable(
433 case INQUIRY: 455 case INQUIRY:
434 case REPORT_LUNS: 456 case REPORT_LUNS:
435 case MAINTENANCE_IN: 457 case MAINTENANCE_IN:
436 switch (cdb[1]) { 458 switch (cdb[1] & 0x1f) {
437 case MI_REPORT_TARGET_PGS: 459 case MI_REPORT_TARGET_PGS:
438 return 0; 460 return 0;
439 default: 461 default:
@@ -473,7 +495,7 @@ static inline int core_alua_state_transition(
473 case INQUIRY: 495 case INQUIRY:
474 case REPORT_LUNS: 496 case REPORT_LUNS:
475 case MAINTENANCE_IN: 497 case MAINTENANCE_IN:
476 switch (cdb[1]) { 498 switch (cdb[1] & 0x1f) {
477 case MI_REPORT_TARGET_PGS: 499 case MI_REPORT_TARGET_PGS:
478 return 0; 500 return 0;
479 default: 501 default:
@@ -1359,6 +1381,7 @@ struct t10_alua_tg_pt_gp *core_alua_allocate_tg_pt_gp(
1359 */ 1381 */
1360 tg_pt_gp->tg_pt_gp_nonop_delay_msecs = ALUA_DEFAULT_NONOP_DELAY_MSECS; 1382 tg_pt_gp->tg_pt_gp_nonop_delay_msecs = ALUA_DEFAULT_NONOP_DELAY_MSECS;
1361 tg_pt_gp->tg_pt_gp_trans_delay_msecs = ALUA_DEFAULT_TRANS_DELAY_MSECS; 1383 tg_pt_gp->tg_pt_gp_trans_delay_msecs = ALUA_DEFAULT_TRANS_DELAY_MSECS;
1384 tg_pt_gp->tg_pt_gp_implict_trans_secs = ALUA_DEFAULT_IMPLICT_TRANS_SECS;
1362 1385
1363 if (def_group) { 1386 if (def_group) {
1364 spin_lock(&su_dev->t10_alua.tg_pt_gps_lock); 1387 spin_lock(&su_dev->t10_alua.tg_pt_gps_lock);
@@ -1855,6 +1878,37 @@ ssize_t core_alua_store_trans_delay_msecs(
1855 return count; 1878 return count;
1856} 1879}
1857 1880
1881ssize_t core_alua_show_implict_trans_secs(
1882 struct t10_alua_tg_pt_gp *tg_pt_gp,
1883 char *page)
1884{
1885 return sprintf(page, "%d\n", tg_pt_gp->tg_pt_gp_implict_trans_secs);
1886}
1887
1888ssize_t core_alua_store_implict_trans_secs(
1889 struct t10_alua_tg_pt_gp *tg_pt_gp,
1890 const char *page,
1891 size_t count)
1892{
1893 unsigned long tmp;
1894 int ret;
1895
1896 ret = strict_strtoul(page, 0, &tmp);
1897 if (ret < 0) {
1898 pr_err("Unable to extract implict_trans_secs\n");
1899 return -EINVAL;
1900 }
1901 if (tmp > ALUA_MAX_IMPLICT_TRANS_SECS) {
1902 pr_err("Passed implict_trans_secs: %lu, exceeds"
1903 " ALUA_MAX_IMPLICT_TRANS_SECS: %d\n", tmp,
1904 ALUA_MAX_IMPLICT_TRANS_SECS);
1905 return -EINVAL;
1906 }
1907 tg_pt_gp->tg_pt_gp_implict_trans_secs = (int)tmp;
1908
1909 return count;
1910}
1911
1858ssize_t core_alua_show_preferred_bit( 1912ssize_t core_alua_show_preferred_bit(
1859 struct t10_alua_tg_pt_gp *tg_pt_gp, 1913 struct t10_alua_tg_pt_gp *tg_pt_gp,
1860 char *page) 1914 char *page)
diff --git a/drivers/target/target_core_alua.h b/drivers/target/target_core_alua.h
index c5b4ecd3e745..f920c170d47b 100644
--- a/drivers/target/target_core_alua.h
+++ b/drivers/target/target_core_alua.h
@@ -52,6 +52,12 @@
52#define ALUA_DEFAULT_TRANS_DELAY_MSECS 0 52#define ALUA_DEFAULT_TRANS_DELAY_MSECS 0
53#define ALUA_MAX_TRANS_DELAY_MSECS 30000 /* 30 seconds */ 53#define ALUA_MAX_TRANS_DELAY_MSECS 30000 /* 30 seconds */
54/* 54/*
55 * Used for the recommended application client implict transition timeout
56 * in seconds, returned by the REPORT_TARGET_PORT_GROUPS w/ extended header.
57 */
58#define ALUA_DEFAULT_IMPLICT_TRANS_SECS 0
59#define ALUA_MAX_IMPLICT_TRANS_SECS 255
60/*
55 * Used by core_alua_update_tpg_primary_metadata() and 61 * Used by core_alua_update_tpg_primary_metadata() and
56 * core_alua_update_tpg_secondary_metadata() 62 * core_alua_update_tpg_secondary_metadata()
57 */ 63 */
@@ -66,8 +72,8 @@ extern struct kmem_cache *t10_alua_lu_gp_mem_cache;
66extern struct kmem_cache *t10_alua_tg_pt_gp_cache; 72extern struct kmem_cache *t10_alua_tg_pt_gp_cache;
67extern struct kmem_cache *t10_alua_tg_pt_gp_mem_cache; 73extern struct kmem_cache *t10_alua_tg_pt_gp_mem_cache;
68 74
69extern int target_emulate_report_target_port_groups(struct se_task *); 75extern int target_emulate_report_target_port_groups(struct se_cmd *);
70extern int target_emulate_set_target_port_groups(struct se_task *); 76extern int target_emulate_set_target_port_groups(struct se_cmd *);
71extern int core_alua_check_nonop_delay(struct se_cmd *); 77extern int core_alua_check_nonop_delay(struct se_cmd *);
72extern int core_alua_do_port_transition(struct t10_alua_tg_pt_gp *, 78extern int core_alua_do_port_transition(struct t10_alua_tg_pt_gp *,
73 struct se_device *, struct se_port *, 79 struct se_device *, struct se_port *,
@@ -107,6 +113,10 @@ extern ssize_t core_alua_show_trans_delay_msecs(struct t10_alua_tg_pt_gp *,
107 char *); 113 char *);
108extern ssize_t core_alua_store_trans_delay_msecs(struct t10_alua_tg_pt_gp *, 114extern ssize_t core_alua_store_trans_delay_msecs(struct t10_alua_tg_pt_gp *,
109 const char *, size_t); 115 const char *, size_t);
116extern ssize_t core_alua_show_implict_trans_secs(struct t10_alua_tg_pt_gp *,
117 char *);
118extern ssize_t core_alua_store_implict_trans_secs(struct t10_alua_tg_pt_gp *,
119 const char *, size_t);
110extern ssize_t core_alua_show_preferred_bit(struct t10_alua_tg_pt_gp *, 120extern ssize_t core_alua_show_preferred_bit(struct t10_alua_tg_pt_gp *,
111 char *); 121 char *);
112extern ssize_t core_alua_store_preferred_bit(struct t10_alua_tg_pt_gp *, 122extern ssize_t core_alua_store_preferred_bit(struct t10_alua_tg_pt_gp *,
diff --git a/drivers/target/target_core_cdb.c b/drivers/target/target_core_cdb.c
index 30a67707036f..9888693a18fe 100644
--- a/drivers/target/target_core_cdb.c
+++ b/drivers/target/target_core_cdb.c
@@ -432,6 +432,7 @@ static int
432target_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf) 432target_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf)
433{ 433{
434 struct se_device *dev = cmd->se_dev; 434 struct se_device *dev = cmd->se_dev;
435 u32 max_sectors;
435 int have_tp = 0; 436 int have_tp = 0;
436 437
437 /* 438 /*
@@ -456,7 +457,9 @@ target_emulate_evpd_b0(struct se_cmd *cmd, unsigned char *buf)
456 /* 457 /*
457 * Set MAXIMUM TRANSFER LENGTH 458 * Set MAXIMUM TRANSFER LENGTH
458 */ 459 */
459 put_unaligned_be32(dev->se_sub_dev->se_dev_attrib.fabric_max_sectors, &buf[8]); 460 max_sectors = min(dev->se_sub_dev->se_dev_attrib.fabric_max_sectors,
461 dev->se_sub_dev->se_dev_attrib.hw_max_sectors);
462 put_unaligned_be32(max_sectors, &buf[8]);
460 463
461 /* 464 /*
462 * Set OPTIMAL TRANSFER LENGTH 465 * Set OPTIMAL TRANSFER LENGTH
@@ -598,9 +601,8 @@ target_emulate_evpd_00(struct se_cmd *cmd, unsigned char *buf)
598 return 0; 601 return 0;
599} 602}
600 603
601int target_emulate_inquiry(struct se_task *task) 604int target_emulate_inquiry(struct se_cmd *cmd)
602{ 605{
603 struct se_cmd *cmd = task->task_se_cmd;
604 struct se_device *dev = cmd->se_dev; 606 struct se_device *dev = cmd->se_dev;
605 struct se_portal_group *tpg = cmd->se_lun->lun_sep->sep_tpg; 607 struct se_portal_group *tpg = cmd->se_lun->lun_sep->sep_tpg;
606 unsigned char *buf, *map_buf; 608 unsigned char *buf, *map_buf;
@@ -664,16 +666,13 @@ out:
664 } 666 }
665 transport_kunmap_data_sg(cmd); 667 transport_kunmap_data_sg(cmd);
666 668
667 if (!ret) { 669 if (!ret)
668 task->task_scsi_status = GOOD; 670 target_complete_cmd(cmd, GOOD);
669 transport_complete_task(task, 1);
670 }
671 return ret; 671 return ret;
672} 672}
673 673
674int target_emulate_readcapacity(struct se_task *task) 674int target_emulate_readcapacity(struct se_cmd *cmd)
675{ 675{
676 struct se_cmd *cmd = task->task_se_cmd;
677 struct se_device *dev = cmd->se_dev; 676 struct se_device *dev = cmd->se_dev;
678 unsigned char *buf; 677 unsigned char *buf;
679 unsigned long long blocks_long = dev->transport->get_blocks(dev); 678 unsigned long long blocks_long = dev->transport->get_blocks(dev);
@@ -697,14 +696,12 @@ int target_emulate_readcapacity(struct se_task *task)
697 696
698 transport_kunmap_data_sg(cmd); 697 transport_kunmap_data_sg(cmd);
699 698
700 task->task_scsi_status = GOOD; 699 target_complete_cmd(cmd, GOOD);
701 transport_complete_task(task, 1);
702 return 0; 700 return 0;
703} 701}
704 702
705int target_emulate_readcapacity_16(struct se_task *task) 703int target_emulate_readcapacity_16(struct se_cmd *cmd)
706{ 704{
707 struct se_cmd *cmd = task->task_se_cmd;
708 struct se_device *dev = cmd->se_dev; 705 struct se_device *dev = cmd->se_dev;
709 unsigned char *buf; 706 unsigned char *buf;
710 unsigned long long blocks = dev->transport->get_blocks(dev); 707 unsigned long long blocks = dev->transport->get_blocks(dev);
@@ -732,8 +729,7 @@ int target_emulate_readcapacity_16(struct se_task *task)
732 729
733 transport_kunmap_data_sg(cmd); 730 transport_kunmap_data_sg(cmd);
734 731
735 task->task_scsi_status = GOOD; 732 target_complete_cmd(cmd, GOOD);
736 transport_complete_task(task, 1);
737 return 0; 733 return 0;
738} 734}
739 735
@@ -872,9 +868,8 @@ target_modesense_dpofua(unsigned char *buf, int type)
872 } 868 }
873} 869}
874 870
875int target_emulate_modesense(struct se_task *task) 871int target_emulate_modesense(struct se_cmd *cmd)
876{ 872{
877 struct se_cmd *cmd = task->task_se_cmd;
878 struct se_device *dev = cmd->se_dev; 873 struct se_device *dev = cmd->se_dev;
879 char *cdb = cmd->t_task_cdb; 874 char *cdb = cmd->t_task_cdb;
880 unsigned char *rbuf; 875 unsigned char *rbuf;
@@ -947,14 +942,12 @@ int target_emulate_modesense(struct se_task *task)
947 memcpy(rbuf, buf, offset); 942 memcpy(rbuf, buf, offset);
948 transport_kunmap_data_sg(cmd); 943 transport_kunmap_data_sg(cmd);
949 944
950 task->task_scsi_status = GOOD; 945 target_complete_cmd(cmd, GOOD);
951 transport_complete_task(task, 1);
952 return 0; 946 return 0;
953} 947}
954 948
955int target_emulate_request_sense(struct se_task *task) 949int target_emulate_request_sense(struct se_cmd *cmd)
956{ 950{
957 struct se_cmd *cmd = task->task_se_cmd;
958 unsigned char *cdb = cmd->t_task_cdb; 951 unsigned char *cdb = cmd->t_task_cdb;
959 unsigned char *buf; 952 unsigned char *buf;
960 u8 ua_asc = 0, ua_ascq = 0; 953 u8 ua_asc = 0, ua_ascq = 0;
@@ -1008,8 +1001,7 @@ int target_emulate_request_sense(struct se_task *task)
1008 1001
1009end: 1002end:
1010 transport_kunmap_data_sg(cmd); 1003 transport_kunmap_data_sg(cmd);
1011 task->task_scsi_status = GOOD; 1004 target_complete_cmd(cmd, GOOD);
1012 transport_complete_task(task, 1);
1013 return 0; 1005 return 0;
1014} 1006}
1015 1007
@@ -1017,9 +1009,8 @@ end:
1017 * Used for TCM/IBLOCK and TCM/FILEIO for block/blk-lib.c level discard support. 1009 * Used for TCM/IBLOCK and TCM/FILEIO for block/blk-lib.c level discard support.
1018 * Note this is not used for TCM/pSCSI passthrough 1010 * Note this is not used for TCM/pSCSI passthrough
1019 */ 1011 */
1020int target_emulate_unmap(struct se_task *task) 1012int target_emulate_unmap(struct se_cmd *cmd)
1021{ 1013{
1022 struct se_cmd *cmd = task->task_se_cmd;
1023 struct se_device *dev = cmd->se_dev; 1014 struct se_device *dev = cmd->se_dev;
1024 unsigned char *buf, *ptr = NULL; 1015 unsigned char *buf, *ptr = NULL;
1025 unsigned char *cdb = &cmd->t_task_cdb[0]; 1016 unsigned char *cdb = &cmd->t_task_cdb[0];
@@ -1066,10 +1057,8 @@ int target_emulate_unmap(struct se_task *task)
1066 1057
1067err: 1058err:
1068 transport_kunmap_data_sg(cmd); 1059 transport_kunmap_data_sg(cmd);
1069 if (!ret) { 1060 if (!ret)
1070 task->task_scsi_status = GOOD; 1061 target_complete_cmd(cmd, GOOD);
1071 transport_complete_task(task, 1);
1072 }
1073 return ret; 1062 return ret;
1074} 1063}
1075 1064
@@ -1077,9 +1066,8 @@ err:
1077 * Used for TCM/IBLOCK and TCM/FILEIO for block/blk-lib.c level discard support. 1066 * Used for TCM/IBLOCK and TCM/FILEIO for block/blk-lib.c level discard support.
1078 * Note this is not used for TCM/pSCSI passthrough 1067 * Note this is not used for TCM/pSCSI passthrough
1079 */ 1068 */
1080int target_emulate_write_same(struct se_task *task) 1069int target_emulate_write_same(struct se_cmd *cmd)
1081{ 1070{
1082 struct se_cmd *cmd = task->task_se_cmd;
1083 struct se_device *dev = cmd->se_dev; 1071 struct se_device *dev = cmd->se_dev;
1084 sector_t range; 1072 sector_t range;
1085 sector_t lba = cmd->t_task_lba; 1073 sector_t lba = cmd->t_task_lba;
@@ -1118,79 +1106,25 @@ int target_emulate_write_same(struct se_task *task)
1118 return ret; 1106 return ret;
1119 } 1107 }
1120 1108
1121 task->task_scsi_status = GOOD; 1109 target_complete_cmd(cmd, GOOD);
1122 transport_complete_task(task, 1);
1123 return 0; 1110 return 0;
1124} 1111}
1125 1112
1126int target_emulate_synchronize_cache(struct se_task *task) 1113int target_emulate_synchronize_cache(struct se_cmd *cmd)
1127{ 1114{
1128 struct se_device *dev = task->task_se_cmd->se_dev; 1115 if (!cmd->se_dev->transport->do_sync_cache) {
1129 struct se_cmd *cmd = task->task_se_cmd;
1130
1131 if (!dev->transport->do_sync_cache) {
1132 pr_err("SYNCHRONIZE_CACHE emulation not supported" 1116 pr_err("SYNCHRONIZE_CACHE emulation not supported"
1133 " for: %s\n", dev->transport->name); 1117 " for: %s\n", cmd->se_dev->transport->name);
1134 cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE; 1118 cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE;
1135 return -ENOSYS; 1119 return -ENOSYS;
1136 } 1120 }
1137 1121
1138 dev->transport->do_sync_cache(task); 1122 cmd->se_dev->transport->do_sync_cache(cmd);
1139 return 0; 1123 return 0;
1140} 1124}
1141 1125
1142int target_emulate_noop(struct se_task *task) 1126int target_emulate_noop(struct se_cmd *cmd)
1143{ 1127{
1144 task->task_scsi_status = GOOD; 1128 target_complete_cmd(cmd, GOOD);
1145 transport_complete_task(task, 1);
1146 return 0; 1129 return 0;
1147} 1130}
1148
1149/*
1150 * Write a CDB into @cdb that is based on the one the intiator sent us,
1151 * but updated to only cover the sectors that the current task handles.
1152 */
1153void target_get_task_cdb(struct se_task *task, unsigned char *cdb)
1154{
1155 struct se_cmd *cmd = task->task_se_cmd;
1156 unsigned int cdb_len = scsi_command_size(cmd->t_task_cdb);
1157
1158 memcpy(cdb, cmd->t_task_cdb, cdb_len);
1159 if (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) {
1160 unsigned long long lba = task->task_lba;
1161 u32 sectors = task->task_sectors;
1162
1163 switch (cdb_len) {
1164 case 6:
1165 /* 21-bit LBA and 8-bit sectors */
1166 cdb[1] = (lba >> 16) & 0x1f;
1167 cdb[2] = (lba >> 8) & 0xff;
1168 cdb[3] = lba & 0xff;
1169 cdb[4] = sectors & 0xff;
1170 break;
1171 case 10:
1172 /* 32-bit LBA and 16-bit sectors */
1173 put_unaligned_be32(lba, &cdb[2]);
1174 put_unaligned_be16(sectors, &cdb[7]);
1175 break;
1176 case 12:
1177 /* 32-bit LBA and 32-bit sectors */
1178 put_unaligned_be32(lba, &cdb[2]);
1179 put_unaligned_be32(sectors, &cdb[6]);
1180 break;
1181 case 16:
1182 /* 64-bit LBA and 32-bit sectors */
1183 put_unaligned_be64(lba, &cdb[2]);
1184 put_unaligned_be32(sectors, &cdb[10]);
1185 break;
1186 case 32:
1187 /* 64-bit LBA and 32-bit sectors, extended CDB */
1188 put_unaligned_be64(lba, &cdb[12]);
1189 put_unaligned_be32(sectors, &cdb[28]);
1190 break;
1191 default:
1192 BUG();
1193 }
1194 }
1195}
1196EXPORT_SYMBOL(target_get_task_cdb);
diff --git a/drivers/target/target_core_configfs.c b/drivers/target/target_core_configfs.c
index cbb66537d230..801efa892046 100644
--- a/drivers/target/target_core_configfs.c
+++ b/drivers/target/target_core_configfs.c
@@ -683,9 +683,6 @@ SE_DEV_ATTR(block_size, S_IRUGO | S_IWUSR);
683DEF_DEV_ATTRIB_RO(hw_max_sectors); 683DEF_DEV_ATTRIB_RO(hw_max_sectors);
684SE_DEV_ATTR_RO(hw_max_sectors); 684SE_DEV_ATTR_RO(hw_max_sectors);
685 685
686DEF_DEV_ATTRIB(max_sectors);
687SE_DEV_ATTR(max_sectors, S_IRUGO | S_IWUSR);
688
689DEF_DEV_ATTRIB(fabric_max_sectors); 686DEF_DEV_ATTRIB(fabric_max_sectors);
690SE_DEV_ATTR(fabric_max_sectors, S_IRUGO | S_IWUSR); 687SE_DEV_ATTR(fabric_max_sectors, S_IRUGO | S_IWUSR);
691 688
@@ -727,7 +724,6 @@ static struct configfs_attribute *target_core_dev_attrib_attrs[] = {
727 &target_core_dev_attrib_hw_block_size.attr, 724 &target_core_dev_attrib_hw_block_size.attr,
728 &target_core_dev_attrib_block_size.attr, 725 &target_core_dev_attrib_block_size.attr,
729 &target_core_dev_attrib_hw_max_sectors.attr, 726 &target_core_dev_attrib_hw_max_sectors.attr,
730 &target_core_dev_attrib_max_sectors.attr,
731 &target_core_dev_attrib_fabric_max_sectors.attr, 727 &target_core_dev_attrib_fabric_max_sectors.attr,
732 &target_core_dev_attrib_optimal_sectors.attr, 728 &target_core_dev_attrib_optimal_sectors.attr,
733 &target_core_dev_attrib_hw_queue_depth.attr, 729 &target_core_dev_attrib_hw_queue_depth.attr,
@@ -2451,6 +2447,26 @@ static ssize_t target_core_alua_tg_pt_gp_store_attr_trans_delay_msecs(
2451SE_DEV_ALUA_TG_PT_ATTR(trans_delay_msecs, S_IRUGO | S_IWUSR); 2447SE_DEV_ALUA_TG_PT_ATTR(trans_delay_msecs, S_IRUGO | S_IWUSR);
2452 2448
2453/* 2449/*
2450 * implict_trans_secs
2451 */
2452static ssize_t target_core_alua_tg_pt_gp_show_attr_implict_trans_secs(
2453 struct t10_alua_tg_pt_gp *tg_pt_gp,
2454 char *page)
2455{
2456 return core_alua_show_implict_trans_secs(tg_pt_gp, page);
2457}
2458
2459static ssize_t target_core_alua_tg_pt_gp_store_attr_implict_trans_secs(
2460 struct t10_alua_tg_pt_gp *tg_pt_gp,
2461 const char *page,
2462 size_t count)
2463{
2464 return core_alua_store_implict_trans_secs(tg_pt_gp, page, count);
2465}
2466
2467SE_DEV_ALUA_TG_PT_ATTR(implict_trans_secs, S_IRUGO | S_IWUSR);
2468
2469/*
2454 * preferred 2470 * preferred
2455 */ 2471 */
2456 2472
@@ -2574,6 +2590,7 @@ static struct configfs_attribute *target_core_alua_tg_pt_gp_attrs[] = {
2574 &target_core_alua_tg_pt_gp_alua_write_metadata.attr, 2590 &target_core_alua_tg_pt_gp_alua_write_metadata.attr,
2575 &target_core_alua_tg_pt_gp_nonop_delay_msecs.attr, 2591 &target_core_alua_tg_pt_gp_nonop_delay_msecs.attr,
2576 &target_core_alua_tg_pt_gp_trans_delay_msecs.attr, 2592 &target_core_alua_tg_pt_gp_trans_delay_msecs.attr,
2593 &target_core_alua_tg_pt_gp_implict_trans_secs.attr,
2577 &target_core_alua_tg_pt_gp_preferred.attr, 2594 &target_core_alua_tg_pt_gp_preferred.attr,
2578 &target_core_alua_tg_pt_gp_tg_pt_gp_id.attr, 2595 &target_core_alua_tg_pt_gp_tg_pt_gp_id.attr,
2579 &target_core_alua_tg_pt_gp_members.attr, 2596 &target_core_alua_tg_pt_gp_members.attr,
diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index aa6267746383..5ad972856a8d 100644
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -643,9 +643,8 @@ void core_dev_unexport(
643 lun->lun_se_dev = NULL; 643 lun->lun_se_dev = NULL;
644} 644}
645 645
646int target_report_luns(struct se_task *se_task) 646int target_report_luns(struct se_cmd *se_cmd)
647{ 647{
648 struct se_cmd *se_cmd = se_task->task_se_cmd;
649 struct se_dev_entry *deve; 648 struct se_dev_entry *deve;
650 struct se_session *se_sess = se_cmd->se_sess; 649 struct se_session *se_sess = se_cmd->se_sess;
651 unsigned char *buf; 650 unsigned char *buf;
@@ -696,8 +695,7 @@ done:
696 buf[3] = (lun_count & 0xff); 695 buf[3] = (lun_count & 0xff);
697 transport_kunmap_data_sg(se_cmd); 696 transport_kunmap_data_sg(se_cmd);
698 697
699 se_task->task_scsi_status = GOOD; 698 target_complete_cmd(se_cmd, GOOD);
700 transport_complete_task(se_task, 1);
701 return 0; 699 return 0;
702} 700}
703 701
@@ -878,15 +876,12 @@ void se_dev_set_default_attribs(
878 dev->se_sub_dev->se_dev_attrib.hw_block_size = limits->logical_block_size; 876 dev->se_sub_dev->se_dev_attrib.hw_block_size = limits->logical_block_size;
879 dev->se_sub_dev->se_dev_attrib.block_size = limits->logical_block_size; 877 dev->se_sub_dev->se_dev_attrib.block_size = limits->logical_block_size;
880 /* 878 /*
881 * max_sectors is based on subsystem plugin dependent requirements. 879 * Align max_hw_sectors down to PAGE_SIZE I/O transfers
882 */ 880 */
883 dev->se_sub_dev->se_dev_attrib.hw_max_sectors = limits->max_hw_sectors; 881 limits->max_hw_sectors = se_dev_align_max_sectors(limits->max_hw_sectors,
884 /*
885 * Align max_sectors down to PAGE_SIZE to follow transport_allocate_data_tasks()
886 */
887 limits->max_sectors = se_dev_align_max_sectors(limits->max_sectors,
888 limits->logical_block_size); 882 limits->logical_block_size);
889 dev->se_sub_dev->se_dev_attrib.max_sectors = limits->max_sectors; 883 dev->se_sub_dev->se_dev_attrib.hw_max_sectors = limits->max_hw_sectors;
884
890 /* 885 /*
891 * Set fabric_max_sectors, which is reported in block limits 886 * Set fabric_max_sectors, which is reported in block limits
892 * VPD page (B0h). 887 * VPD page (B0h).
@@ -1170,64 +1165,6 @@ int se_dev_set_queue_depth(struct se_device *dev, u32 queue_depth)
1170 return 0; 1165 return 0;
1171} 1166}
1172 1167
1173int se_dev_set_max_sectors(struct se_device *dev, u32 max_sectors)
1174{
1175 int force = 0; /* Force setting for VDEVS */
1176
1177 if (atomic_read(&dev->dev_export_obj.obj_access_count)) {
1178 pr_err("dev[%p]: Unable to change SE Device"
1179 " max_sectors while dev_export_obj: %d count exists\n",
1180 dev, atomic_read(&dev->dev_export_obj.obj_access_count));
1181 return -EINVAL;
1182 }
1183 if (!max_sectors) {
1184 pr_err("dev[%p]: Illegal ZERO value for"
1185 " max_sectors\n", dev);
1186 return -EINVAL;
1187 }
1188 if (max_sectors < DA_STATUS_MAX_SECTORS_MIN) {
1189 pr_err("dev[%p]: Passed max_sectors: %u less than"
1190 " DA_STATUS_MAX_SECTORS_MIN: %u\n", dev, max_sectors,
1191 DA_STATUS_MAX_SECTORS_MIN);
1192 return -EINVAL;
1193 }
1194 if (dev->transport->transport_type == TRANSPORT_PLUGIN_PHBA_PDEV) {
1195 if (max_sectors > dev->se_sub_dev->se_dev_attrib.hw_max_sectors) {
1196 pr_err("dev[%p]: Passed max_sectors: %u"
1197 " greater than TCM/SE_Device max_sectors:"
1198 " %u\n", dev, max_sectors,
1199 dev->se_sub_dev->se_dev_attrib.hw_max_sectors);
1200 return -EINVAL;
1201 }
1202 } else {
1203 if (!force && (max_sectors >
1204 dev->se_sub_dev->se_dev_attrib.hw_max_sectors)) {
1205 pr_err("dev[%p]: Passed max_sectors: %u"
1206 " greater than TCM/SE_Device max_sectors"
1207 ": %u, use force=1 to override.\n", dev,
1208 max_sectors, dev->se_sub_dev->se_dev_attrib.hw_max_sectors);
1209 return -EINVAL;
1210 }
1211 if (max_sectors > DA_STATUS_MAX_SECTORS_MAX) {
1212 pr_err("dev[%p]: Passed max_sectors: %u"
1213 " greater than DA_STATUS_MAX_SECTORS_MAX:"
1214 " %u\n", dev, max_sectors,
1215 DA_STATUS_MAX_SECTORS_MAX);
1216 return -EINVAL;
1217 }
1218 }
1219 /*
1220 * Align max_sectors down to PAGE_SIZE to follow transport_allocate_data_tasks()
1221 */
1222 max_sectors = se_dev_align_max_sectors(max_sectors,
1223 dev->se_sub_dev->se_dev_attrib.block_size);
1224
1225 dev->se_sub_dev->se_dev_attrib.max_sectors = max_sectors;
1226 pr_debug("dev[%p]: SE Device max_sectors changed to %u\n",
1227 dev, max_sectors);
1228 return 0;
1229}
1230
1231int se_dev_set_fabric_max_sectors(struct se_device *dev, u32 fabric_max_sectors) 1168int se_dev_set_fabric_max_sectors(struct se_device *dev, u32 fabric_max_sectors)
1232{ 1169{
1233 if (atomic_read(&dev->dev_export_obj.obj_access_count)) { 1170 if (atomic_read(&dev->dev_export_obj.obj_access_count)) {
@@ -1341,7 +1278,6 @@ struct se_lun *core_dev_add_lun(
1341 u32 lun) 1278 u32 lun)
1342{ 1279{
1343 struct se_lun *lun_p; 1280 struct se_lun *lun_p;
1344 u32 lun_access = 0;
1345 int rc; 1281 int rc;
1346 1282
1347 if (atomic_read(&dev->dev_access_obj.obj_access_count) != 0) { 1283 if (atomic_read(&dev->dev_access_obj.obj_access_count) != 0) {
@@ -1354,12 +1290,8 @@ struct se_lun *core_dev_add_lun(
1354 if (IS_ERR(lun_p)) 1290 if (IS_ERR(lun_p))
1355 return lun_p; 1291 return lun_p;
1356 1292
1357 if (dev->dev_flags & DF_READ_ONLY) 1293 rc = core_tpg_post_addlun(tpg, lun_p,
1358 lun_access = TRANSPORT_LUNFLAGS_READ_ONLY; 1294 TRANSPORT_LUNFLAGS_READ_WRITE, dev);
1359 else
1360 lun_access = TRANSPORT_LUNFLAGS_READ_WRITE;
1361
1362 rc = core_tpg_post_addlun(tpg, lun_p, lun_access, dev);
1363 if (rc < 0) 1295 if (rc < 0)
1364 return ERR_PTR(rc); 1296 return ERR_PTR(rc);
1365 1297
diff --git a/drivers/target/target_core_file.c b/drivers/target/target_core_file.c
index f286955331a2..686dba189f8e 100644
--- a/drivers/target/target_core_file.c
+++ b/drivers/target/target_core_file.c
@@ -133,15 +133,10 @@ static struct se_device *fd_create_virtdevice(
133 ret = PTR_ERR(dev_p); 133 ret = PTR_ERR(dev_p);
134 goto fail; 134 goto fail;
135 } 135 }
136#if 0 136
137 if (di->no_create_file) 137 /* O_DIRECT too? */
138 flags = O_RDWR | O_LARGEFILE;
139 else
140 flags = O_RDWR | O_CREAT | O_LARGEFILE;
141#else
142 flags = O_RDWR | O_CREAT | O_LARGEFILE; 138 flags = O_RDWR | O_CREAT | O_LARGEFILE;
143#endif 139
144/* flags |= O_DIRECT; */
145 /* 140 /*
146 * If fd_buffered_io=1 has not been set explicitly (the default), 141 * If fd_buffered_io=1 has not been set explicitly (the default),
147 * use O_SYNC to force FILEIO writes to disk. 142 * use O_SYNC to force FILEIO writes to disk.
@@ -249,53 +244,33 @@ static void fd_free_device(void *p)
249 kfree(fd_dev); 244 kfree(fd_dev);
250} 245}
251 246
252static inline struct fd_request *FILE_REQ(struct se_task *task) 247static int fd_do_readv(struct se_cmd *cmd, struct scatterlist *sgl,
253{ 248 u32 sgl_nents)
254 return container_of(task, struct fd_request, fd_task);
255}
256
257
258static struct se_task *
259fd_alloc_task(unsigned char *cdb)
260{ 249{
261 struct fd_request *fd_req; 250 struct se_device *se_dev = cmd->se_dev;
262
263 fd_req = kzalloc(sizeof(struct fd_request), GFP_KERNEL);
264 if (!fd_req) {
265 pr_err("Unable to allocate struct fd_request\n");
266 return NULL;
267 }
268
269 return &fd_req->fd_task;
270}
271
272static int fd_do_readv(struct se_task *task)
273{
274 struct fd_request *req = FILE_REQ(task);
275 struct se_device *se_dev = req->fd_task.task_se_cmd->se_dev;
276 struct fd_dev *dev = se_dev->dev_ptr; 251 struct fd_dev *dev = se_dev->dev_ptr;
277 struct file *fd = dev->fd_file; 252 struct file *fd = dev->fd_file;
278 struct scatterlist *sg = task->task_sg; 253 struct scatterlist *sg;
279 struct iovec *iov; 254 struct iovec *iov;
280 mm_segment_t old_fs; 255 mm_segment_t old_fs;
281 loff_t pos = (task->task_lba * 256 loff_t pos = (cmd->t_task_lba *
282 se_dev->se_sub_dev->se_dev_attrib.block_size); 257 se_dev->se_sub_dev->se_dev_attrib.block_size);
283 int ret = 0, i; 258 int ret = 0, i;
284 259
285 iov = kzalloc(sizeof(struct iovec) * task->task_sg_nents, GFP_KERNEL); 260 iov = kzalloc(sizeof(struct iovec) * sgl_nents, GFP_KERNEL);
286 if (!iov) { 261 if (!iov) {
287 pr_err("Unable to allocate fd_do_readv iov[]\n"); 262 pr_err("Unable to allocate fd_do_readv iov[]\n");
288 return -ENOMEM; 263 return -ENOMEM;
289 } 264 }
290 265
291 for_each_sg(task->task_sg, sg, task->task_sg_nents, i) { 266 for_each_sg(sgl, sg, sgl_nents, i) {
292 iov[i].iov_len = sg->length; 267 iov[i].iov_len = sg->length;
293 iov[i].iov_base = sg_virt(sg); 268 iov[i].iov_base = sg_virt(sg);
294 } 269 }
295 270
296 old_fs = get_fs(); 271 old_fs = get_fs();
297 set_fs(get_ds()); 272 set_fs(get_ds());
298 ret = vfs_readv(fd, &iov[0], task->task_sg_nents, &pos); 273 ret = vfs_readv(fd, &iov[0], sgl_nents, &pos);
299 set_fs(old_fs); 274 set_fs(old_fs);
300 275
301 kfree(iov); 276 kfree(iov);
@@ -305,10 +280,10 @@ static int fd_do_readv(struct se_task *task)
305 * block_device. 280 * block_device.
306 */ 281 */
307 if (S_ISBLK(fd->f_dentry->d_inode->i_mode)) { 282 if (S_ISBLK(fd->f_dentry->d_inode->i_mode)) {
308 if (ret < 0 || ret != task->task_size) { 283 if (ret < 0 || ret != cmd->data_length) {
309 pr_err("vfs_readv() returned %d," 284 pr_err("vfs_readv() returned %d,"
310 " expecting %d for S_ISBLK\n", ret, 285 " expecting %d for S_ISBLK\n", ret,
311 (int)task->task_size); 286 (int)cmd->data_length);
312 return (ret < 0 ? ret : -EINVAL); 287 return (ret < 0 ? ret : -EINVAL);
313 } 288 }
314 } else { 289 } else {
@@ -322,38 +297,38 @@ static int fd_do_readv(struct se_task *task)
322 return 1; 297 return 1;
323} 298}
324 299
325static int fd_do_writev(struct se_task *task) 300static int fd_do_writev(struct se_cmd *cmd, struct scatterlist *sgl,
301 u32 sgl_nents)
326{ 302{
327 struct fd_request *req = FILE_REQ(task); 303 struct se_device *se_dev = cmd->se_dev;
328 struct se_device *se_dev = req->fd_task.task_se_cmd->se_dev;
329 struct fd_dev *dev = se_dev->dev_ptr; 304 struct fd_dev *dev = se_dev->dev_ptr;
330 struct file *fd = dev->fd_file; 305 struct file *fd = dev->fd_file;
331 struct scatterlist *sg = task->task_sg; 306 struct scatterlist *sg;
332 struct iovec *iov; 307 struct iovec *iov;
333 mm_segment_t old_fs; 308 mm_segment_t old_fs;
334 loff_t pos = (task->task_lba * 309 loff_t pos = (cmd->t_task_lba *
335 se_dev->se_sub_dev->se_dev_attrib.block_size); 310 se_dev->se_sub_dev->se_dev_attrib.block_size);
336 int ret, i = 0; 311 int ret, i = 0;
337 312
338 iov = kzalloc(sizeof(struct iovec) * task->task_sg_nents, GFP_KERNEL); 313 iov = kzalloc(sizeof(struct iovec) * sgl_nents, GFP_KERNEL);
339 if (!iov) { 314 if (!iov) {
340 pr_err("Unable to allocate fd_do_writev iov[]\n"); 315 pr_err("Unable to allocate fd_do_writev iov[]\n");
341 return -ENOMEM; 316 return -ENOMEM;
342 } 317 }
343 318
344 for_each_sg(task->task_sg, sg, task->task_sg_nents, i) { 319 for_each_sg(sgl, sg, sgl_nents, i) {
345 iov[i].iov_len = sg->length; 320 iov[i].iov_len = sg->length;
346 iov[i].iov_base = sg_virt(sg); 321 iov[i].iov_base = sg_virt(sg);
347 } 322 }
348 323
349 old_fs = get_fs(); 324 old_fs = get_fs();
350 set_fs(get_ds()); 325 set_fs(get_ds());
351 ret = vfs_writev(fd, &iov[0], task->task_sg_nents, &pos); 326 ret = vfs_writev(fd, &iov[0], sgl_nents, &pos);
352 set_fs(old_fs); 327 set_fs(old_fs);
353 328
354 kfree(iov); 329 kfree(iov);
355 330
356 if (ret < 0 || ret != task->task_size) { 331 if (ret < 0 || ret != cmd->data_length) {
357 pr_err("vfs_writev() returned %d\n", ret); 332 pr_err("vfs_writev() returned %d\n", ret);
358 return (ret < 0 ? ret : -EINVAL); 333 return (ret < 0 ? ret : -EINVAL);
359 } 334 }
@@ -361,9 +336,8 @@ static int fd_do_writev(struct se_task *task)
361 return 1; 336 return 1;
362} 337}
363 338
364static void fd_emulate_sync_cache(struct se_task *task) 339static void fd_emulate_sync_cache(struct se_cmd *cmd)
365{ 340{
366 struct se_cmd *cmd = task->task_se_cmd;
367 struct se_device *dev = cmd->se_dev; 341 struct se_device *dev = cmd->se_dev;
368 struct fd_dev *fd_dev = dev->dev_ptr; 342 struct fd_dev *fd_dev = dev->dev_ptr;
369 int immed = (cmd->t_task_cdb[1] & 0x2); 343 int immed = (cmd->t_task_cdb[1] & 0x2);
@@ -375,7 +349,7 @@ static void fd_emulate_sync_cache(struct se_task *task)
375 * for this SYNCHRONIZE_CACHE op 349 * for this SYNCHRONIZE_CACHE op
376 */ 350 */
377 if (immed) 351 if (immed)
378 transport_complete_sync_cache(cmd, 1); 352 target_complete_cmd(cmd, SAM_STAT_GOOD);
379 353
380 /* 354 /*
381 * Determine if we will be flushing the entire device. 355 * Determine if we will be flushing the entire device.
@@ -395,33 +369,37 @@ static void fd_emulate_sync_cache(struct se_task *task)
395 if (ret != 0) 369 if (ret != 0)
396 pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret); 370 pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret);
397 371
398 if (!immed) 372 if (immed)
399 transport_complete_sync_cache(cmd, ret == 0); 373 return;
374
375 if (ret) {
376 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
377 target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
378 } else {
379 target_complete_cmd(cmd, SAM_STAT_GOOD);
380 }
400} 381}
401 382
402/* 383static void fd_emulate_write_fua(struct se_cmd *cmd)
403 * WRITE Force Unit Access (FUA) emulation on a per struct se_task
404 * LBA range basis..
405 */
406static void fd_emulate_write_fua(struct se_cmd *cmd, struct se_task *task)
407{ 384{
408 struct se_device *dev = cmd->se_dev; 385 struct se_device *dev = cmd->se_dev;
409 struct fd_dev *fd_dev = dev->dev_ptr; 386 struct fd_dev *fd_dev = dev->dev_ptr;
410 loff_t start = task->task_lba * dev->se_sub_dev->se_dev_attrib.block_size; 387 loff_t start = cmd->t_task_lba *
411 loff_t end = start + task->task_size; 388 dev->se_sub_dev->se_dev_attrib.block_size;
389 loff_t end = start + cmd->data_length;
412 int ret; 390 int ret;
413 391
414 pr_debug("FILEIO: FUA WRITE LBA: %llu, bytes: %u\n", 392 pr_debug("FILEIO: FUA WRITE LBA: %llu, bytes: %u\n",
415 task->task_lba, task->task_size); 393 cmd->t_task_lba, cmd->data_length);
416 394
417 ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1); 395 ret = vfs_fsync_range(fd_dev->fd_file, start, end, 1);
418 if (ret != 0) 396 if (ret != 0)
419 pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret); 397 pr_err("FILEIO: vfs_fsync_range() failed: %d\n", ret);
420} 398}
421 399
422static int fd_do_task(struct se_task *task) 400static int fd_execute_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
401 u32 sgl_nents, enum dma_data_direction data_direction)
423{ 402{
424 struct se_cmd *cmd = task->task_se_cmd;
425 struct se_device *dev = cmd->se_dev; 403 struct se_device *dev = cmd->se_dev;
426 int ret = 0; 404 int ret = 0;
427 405
@@ -429,10 +407,10 @@ static int fd_do_task(struct se_task *task)
429 * Call vectorized fileio functions to map struct scatterlist 407 * Call vectorized fileio functions to map struct scatterlist
430 * physical memory addresses to struct iovec virtual memory. 408 * physical memory addresses to struct iovec virtual memory.
431 */ 409 */
432 if (task->task_data_direction == DMA_FROM_DEVICE) { 410 if (data_direction == DMA_FROM_DEVICE) {
433 ret = fd_do_readv(task); 411 ret = fd_do_readv(cmd, sgl, sgl_nents);
434 } else { 412 } else {
435 ret = fd_do_writev(task); 413 ret = fd_do_writev(cmd, sgl, sgl_nents);
436 414
437 if (ret > 0 && 415 if (ret > 0 &&
438 dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0 && 416 dev->se_sub_dev->se_dev_attrib.emulate_write_cache > 0 &&
@@ -443,7 +421,7 @@ static int fd_do_task(struct se_task *task)
443 * and return some sense data to let the initiator 421 * and return some sense data to let the initiator
444 * know the FUA WRITE cache sync failed..? 422 * know the FUA WRITE cache sync failed..?
445 */ 423 */
446 fd_emulate_write_fua(cmd, task); 424 fd_emulate_write_fua(cmd);
447 } 425 }
448 426
449 } 427 }
@@ -452,24 +430,11 @@ static int fd_do_task(struct se_task *task)
452 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 430 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
453 return ret; 431 return ret;
454 } 432 }
455 if (ret) { 433 if (ret)
456 task->task_scsi_status = GOOD; 434 target_complete_cmd(cmd, SAM_STAT_GOOD);
457 transport_complete_task(task, 1);
458 }
459 return 0; 435 return 0;
460} 436}
461 437
462/* fd_free_task(): (Part of se_subsystem_api_t template)
463 *
464 *
465 */
466static void fd_free_task(struct se_task *task)
467{
468 struct fd_request *req = FILE_REQ(task);
469
470 kfree(req);
471}
472
473enum { 438enum {
474 Opt_fd_dev_name, Opt_fd_dev_size, Opt_fd_buffered_io, Opt_err 439 Opt_fd_dev_name, Opt_fd_dev_size, Opt_fd_buffered_io, Opt_err
475}; 440};
@@ -632,10 +597,8 @@ static struct se_subsystem_api fileio_template = {
632 .allocate_virtdevice = fd_allocate_virtdevice, 597 .allocate_virtdevice = fd_allocate_virtdevice,
633 .create_virtdevice = fd_create_virtdevice, 598 .create_virtdevice = fd_create_virtdevice,
634 .free_device = fd_free_device, 599 .free_device = fd_free_device,
635 .alloc_task = fd_alloc_task, 600 .execute_cmd = fd_execute_cmd,
636 .do_task = fd_do_task,
637 .do_sync_cache = fd_emulate_sync_cache, 601 .do_sync_cache = fd_emulate_sync_cache,
638 .free_task = fd_free_task,
639 .check_configfs_dev_params = fd_check_configfs_dev_params, 602 .check_configfs_dev_params = fd_check_configfs_dev_params,
640 .set_configfs_dev_params = fd_set_configfs_dev_params, 603 .set_configfs_dev_params = fd_set_configfs_dev_params,
641 .show_configfs_dev_params = fd_show_configfs_dev_params, 604 .show_configfs_dev_params = fd_show_configfs_dev_params,
diff --git a/drivers/target/target_core_file.h b/drivers/target/target_core_file.h
index 59e6e73106c2..fbd59ef7d8be 100644
--- a/drivers/target/target_core_file.h
+++ b/drivers/target/target_core_file.h
@@ -12,10 +12,6 @@
12#define RRF_EMULATE_CDB 0x01 12#define RRF_EMULATE_CDB 0x01
13#define RRF_GOT_LBA 0x02 13#define RRF_GOT_LBA 0x02
14 14
15struct fd_request {
16 struct se_task fd_task;
17};
18
19#define FBDF_HAS_PATH 0x01 15#define FBDF_HAS_PATH 0x01
20#define FBDF_HAS_SIZE 0x02 16#define FBDF_HAS_SIZE 0x02
21#define FDBD_USE_BUFFERED_IO 0x04 17#define FDBD_USE_BUFFERED_IO 0x04
diff --git a/drivers/target/target_core_iblock.c b/drivers/target/target_core_iblock.c
index 2ec299e8a73e..fd47950727b4 100644
--- a/drivers/target/target_core_iblock.c
+++ b/drivers/target/target_core_iblock.c
@@ -189,26 +189,6 @@ static void iblock_free_device(void *p)
189 kfree(ib_dev); 189 kfree(ib_dev);
190} 190}
191 191
192static inline struct iblock_req *IBLOCK_REQ(struct se_task *task)
193{
194 return container_of(task, struct iblock_req, ib_task);
195}
196
197static struct se_task *
198iblock_alloc_task(unsigned char *cdb)
199{
200 struct iblock_req *ib_req;
201
202 ib_req = kzalloc(sizeof(struct iblock_req), GFP_KERNEL);
203 if (!ib_req) {
204 pr_err("Unable to allocate memory for struct iblock_req\n");
205 return NULL;
206 }
207
208 atomic_set(&ib_req->pending, 1);
209 return &ib_req->ib_task;
210}
211
212static unsigned long long iblock_emulate_read_cap_with_block_size( 192static unsigned long long iblock_emulate_read_cap_with_block_size(
213 struct se_device *dev, 193 struct se_device *dev,
214 struct block_device *bd, 194 struct block_device *bd,
@@ -295,8 +275,16 @@ static void iblock_end_io_flush(struct bio *bio, int err)
295 if (err) 275 if (err)
296 pr_err("IBLOCK: cache flush failed: %d\n", err); 276 pr_err("IBLOCK: cache flush failed: %d\n", err);
297 277
298 if (cmd) 278 if (cmd) {
299 transport_complete_sync_cache(cmd, err == 0); 279 if (err) {
280 cmd->scsi_sense_reason =
281 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
282 target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
283 } else {
284 target_complete_cmd(cmd, SAM_STAT_GOOD);
285 }
286 }
287
300 bio_put(bio); 288 bio_put(bio);
301} 289}
302 290
@@ -304,9 +292,8 @@ static void iblock_end_io_flush(struct bio *bio, int err)
304 * Implement SYCHRONIZE CACHE. Note that we can't handle lba ranges and must 292 * Implement SYCHRONIZE CACHE. Note that we can't handle lba ranges and must
305 * always flush the whole cache. 293 * always flush the whole cache.
306 */ 294 */
307static void iblock_emulate_sync_cache(struct se_task *task) 295static void iblock_emulate_sync_cache(struct se_cmd *cmd)
308{ 296{
309 struct se_cmd *cmd = task->task_se_cmd;
310 struct iblock_dev *ib_dev = cmd->se_dev->dev_ptr; 297 struct iblock_dev *ib_dev = cmd->se_dev->dev_ptr;
311 int immed = (cmd->t_task_cdb[1] & 0x2); 298 int immed = (cmd->t_task_cdb[1] & 0x2);
312 struct bio *bio; 299 struct bio *bio;
@@ -316,7 +303,7 @@ static void iblock_emulate_sync_cache(struct se_task *task)
316 * for this SYNCHRONIZE_CACHE op. 303 * for this SYNCHRONIZE_CACHE op.
317 */ 304 */
318 if (immed) 305 if (immed)
319 transport_complete_sync_cache(cmd, 1); 306 target_complete_cmd(cmd, SAM_STAT_GOOD);
320 307
321 bio = bio_alloc(GFP_KERNEL, 0); 308 bio = bio_alloc(GFP_KERNEL, 0);
322 bio->bi_end_io = iblock_end_io_flush; 309 bio->bi_end_io = iblock_end_io_flush;
@@ -335,11 +322,6 @@ static int iblock_do_discard(struct se_device *dev, sector_t lba, u32 range)
335 return blkdev_issue_discard(bd, lba, range, GFP_KERNEL, barrier); 322 return blkdev_issue_discard(bd, lba, range, GFP_KERNEL, barrier);
336} 323}
337 324
338static void iblock_free_task(struct se_task *task)
339{
340 kfree(IBLOCK_REQ(task));
341}
342
343enum { 325enum {
344 Opt_udev_path, Opt_force, Opt_err 326 Opt_udev_path, Opt_force, Opt_err
345}; 327};
@@ -448,19 +430,35 @@ static ssize_t iblock_show_configfs_dev_params(
448 return bl; 430 return bl;
449} 431}
450 432
433static void iblock_complete_cmd(struct se_cmd *cmd)
434{
435 struct iblock_req *ibr = cmd->priv;
436 u8 status;
437
438 if (!atomic_dec_and_test(&ibr->pending))
439 return;
440
441 if (atomic_read(&ibr->ib_bio_err_cnt))
442 status = SAM_STAT_CHECK_CONDITION;
443 else
444 status = SAM_STAT_GOOD;
445
446 target_complete_cmd(cmd, status);
447 kfree(ibr);
448}
449
451static void iblock_bio_destructor(struct bio *bio) 450static void iblock_bio_destructor(struct bio *bio)
452{ 451{
453 struct se_task *task = bio->bi_private; 452 struct se_cmd *cmd = bio->bi_private;
454 struct iblock_dev *ib_dev = task->task_se_cmd->se_dev->dev_ptr; 453 struct iblock_dev *ib_dev = cmd->se_dev->dev_ptr;
455 454
456 bio_free(bio, ib_dev->ibd_bio_set); 455 bio_free(bio, ib_dev->ibd_bio_set);
457} 456}
458 457
459static struct bio * 458static struct bio *
460iblock_get_bio(struct se_task *task, sector_t lba, u32 sg_num) 459iblock_get_bio(struct se_cmd *cmd, sector_t lba, u32 sg_num)
461{ 460{
462 struct iblock_dev *ib_dev = task->task_se_cmd->se_dev->dev_ptr; 461 struct iblock_dev *ib_dev = cmd->se_dev->dev_ptr;
463 struct iblock_req *ib_req = IBLOCK_REQ(task);
464 struct bio *bio; 462 struct bio *bio;
465 463
466 /* 464 /*
@@ -476,19 +474,11 @@ iblock_get_bio(struct se_task *task, sector_t lba, u32 sg_num)
476 return NULL; 474 return NULL;
477 } 475 }
478 476
479 pr_debug("Allocated bio: %p task_sg_nents: %u using ibd_bio_set:"
480 " %p\n", bio, task->task_sg_nents, ib_dev->ibd_bio_set);
481 pr_debug("Allocated bio: %p task_size: %u\n", bio, task->task_size);
482
483 bio->bi_bdev = ib_dev->ibd_bd; 477 bio->bi_bdev = ib_dev->ibd_bd;
484 bio->bi_private = task; 478 bio->bi_private = cmd;
485 bio->bi_destructor = iblock_bio_destructor; 479 bio->bi_destructor = iblock_bio_destructor;
486 bio->bi_end_io = &iblock_bio_done; 480 bio->bi_end_io = &iblock_bio_done;
487 bio->bi_sector = lba; 481 bio->bi_sector = lba;
488 atomic_inc(&ib_req->pending);
489
490 pr_debug("Set bio->bi_sector: %llu\n", (unsigned long long)bio->bi_sector);
491 pr_debug("Set ib_req->pending: %d\n", atomic_read(&ib_req->pending));
492 return bio; 482 return bio;
493} 483}
494 484
@@ -503,20 +493,21 @@ static void iblock_submit_bios(struct bio_list *list, int rw)
503 blk_finish_plug(&plug); 493 blk_finish_plug(&plug);
504} 494}
505 495
506static int iblock_do_task(struct se_task *task) 496static int iblock_execute_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
497 u32 sgl_nents, enum dma_data_direction data_direction)
507{ 498{
508 struct se_cmd *cmd = task->task_se_cmd;
509 struct se_device *dev = cmd->se_dev; 499 struct se_device *dev = cmd->se_dev;
510 struct iblock_req *ibr = IBLOCK_REQ(task); 500 struct iblock_req *ibr;
511 struct bio *bio; 501 struct bio *bio;
512 struct bio_list list; 502 struct bio_list list;
513 struct scatterlist *sg; 503 struct scatterlist *sg;
514 u32 i, sg_num = task->task_sg_nents; 504 u32 sg_num = sgl_nents;
515 sector_t block_lba; 505 sector_t block_lba;
516 unsigned bio_cnt; 506 unsigned bio_cnt;
517 int rw; 507 int rw;
508 int i;
518 509
519 if (task->task_data_direction == DMA_TO_DEVICE) { 510 if (data_direction == DMA_TO_DEVICE) {
520 /* 511 /*
521 * Force data to disk if we pretend to not have a volatile 512 * Force data to disk if we pretend to not have a volatile
522 * write cache, or the initiator set the Force Unit Access bit. 513 * write cache, or the initiator set the Force Unit Access bit.
@@ -532,17 +523,17 @@ static int iblock_do_task(struct se_task *task)
532 } 523 }
533 524
534 /* 525 /*
535 * Do starting conversion up from non 512-byte blocksize with 526 * Convert the blocksize advertised to the initiator to the 512 byte
536 * struct se_task SCSI blocksize into Linux/Block 512 units for BIO. 527 * units unconditionally used by the Linux block layer.
537 */ 528 */
538 if (dev->se_sub_dev->se_dev_attrib.block_size == 4096) 529 if (dev->se_sub_dev->se_dev_attrib.block_size == 4096)
539 block_lba = (task->task_lba << 3); 530 block_lba = (cmd->t_task_lba << 3);
540 else if (dev->se_sub_dev->se_dev_attrib.block_size == 2048) 531 else if (dev->se_sub_dev->se_dev_attrib.block_size == 2048)
541 block_lba = (task->task_lba << 2); 532 block_lba = (cmd->t_task_lba << 2);
542 else if (dev->se_sub_dev->se_dev_attrib.block_size == 1024) 533 else if (dev->se_sub_dev->se_dev_attrib.block_size == 1024)
543 block_lba = (task->task_lba << 1); 534 block_lba = (cmd->t_task_lba << 1);
544 else if (dev->se_sub_dev->se_dev_attrib.block_size == 512) 535 else if (dev->se_sub_dev->se_dev_attrib.block_size == 512)
545 block_lba = task->task_lba; 536 block_lba = cmd->t_task_lba;
546 else { 537 else {
547 pr_err("Unsupported SCSI -> BLOCK LBA conversion:" 538 pr_err("Unsupported SCSI -> BLOCK LBA conversion:"
548 " %u\n", dev->se_sub_dev->se_dev_attrib.block_size); 539 " %u\n", dev->se_sub_dev->se_dev_attrib.block_size);
@@ -550,17 +541,22 @@ static int iblock_do_task(struct se_task *task)
550 return -ENOSYS; 541 return -ENOSYS;
551 } 542 }
552 543
553 bio = iblock_get_bio(task, block_lba, sg_num); 544 ibr = kzalloc(sizeof(struct iblock_req), GFP_KERNEL);
554 if (!bio) { 545 if (!ibr)
555 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 546 goto fail;
556 return -ENOMEM; 547 cmd->priv = ibr;
557 } 548
549 bio = iblock_get_bio(cmd, block_lba, sgl_nents);
550 if (!bio)
551 goto fail_free_ibr;
558 552
559 bio_list_init(&list); 553 bio_list_init(&list);
560 bio_list_add(&list, bio); 554 bio_list_add(&list, bio);
555
556 atomic_set(&ibr->pending, 2);
561 bio_cnt = 1; 557 bio_cnt = 1;
562 558
563 for_each_sg(task->task_sg, sg, task->task_sg_nents, i) { 559 for_each_sg(sgl, sg, sgl_nents, i) {
564 /* 560 /*
565 * XXX: if the length the device accepts is shorter than the 561 * XXX: if the length the device accepts is shorter than the
566 * length of the S/G list entry this will cause and 562 * length of the S/G list entry this will cause and
@@ -573,9 +569,11 @@ static int iblock_do_task(struct se_task *task)
573 bio_cnt = 0; 569 bio_cnt = 0;
574 } 570 }
575 571
576 bio = iblock_get_bio(task, block_lba, sg_num); 572 bio = iblock_get_bio(cmd, block_lba, sg_num);
577 if (!bio) 573 if (!bio)
578 goto fail; 574 goto fail_put_bios;
575
576 atomic_inc(&ibr->pending);
579 bio_list_add(&list, bio); 577 bio_list_add(&list, bio);
580 bio_cnt++; 578 bio_cnt++;
581 } 579 }
@@ -586,17 +584,16 @@ static int iblock_do_task(struct se_task *task)
586 } 584 }
587 585
588 iblock_submit_bios(&list, rw); 586 iblock_submit_bios(&list, rw);
589 587 iblock_complete_cmd(cmd);
590 if (atomic_dec_and_test(&ibr->pending)) {
591 transport_complete_task(task,
592 !atomic_read(&ibr->ib_bio_err_cnt));
593 }
594 return 0; 588 return 0;
595 589
596fail: 590fail_put_bios:
597 while ((bio = bio_list_pop(&list))) 591 while ((bio = bio_list_pop(&list)))
598 bio_put(bio); 592 bio_put(bio);
593fail_free_ibr:
594 kfree(ibr);
599 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 595 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
596fail:
600 return -ENOMEM; 597 return -ENOMEM;
601} 598}
602 599
@@ -621,8 +618,8 @@ static sector_t iblock_get_blocks(struct se_device *dev)
621 618
622static void iblock_bio_done(struct bio *bio, int err) 619static void iblock_bio_done(struct bio *bio, int err)
623{ 620{
624 struct se_task *task = bio->bi_private; 621 struct se_cmd *cmd = bio->bi_private;
625 struct iblock_req *ibr = IBLOCK_REQ(task); 622 struct iblock_req *ibr = cmd->priv;
626 623
627 /* 624 /*
628 * Set -EIO if !BIO_UPTODATE and the passed is still err=0 625 * Set -EIO if !BIO_UPTODATE and the passed is still err=0
@@ -642,14 +639,7 @@ static void iblock_bio_done(struct bio *bio, int err)
642 639
643 bio_put(bio); 640 bio_put(bio);
644 641
645 if (!atomic_dec_and_test(&ibr->pending)) 642 iblock_complete_cmd(cmd);
646 return;
647
648 pr_debug("done[%p] bio: %p task_lba: %llu bio_lba: %llu err=%d\n",
649 task, bio, task->task_lba,
650 (unsigned long long)bio->bi_sector, err);
651
652 transport_complete_task(task, !atomic_read(&ibr->ib_bio_err_cnt));
653} 643}
654 644
655static struct se_subsystem_api iblock_template = { 645static struct se_subsystem_api iblock_template = {
@@ -663,11 +653,9 @@ static struct se_subsystem_api iblock_template = {
663 .allocate_virtdevice = iblock_allocate_virtdevice, 653 .allocate_virtdevice = iblock_allocate_virtdevice,
664 .create_virtdevice = iblock_create_virtdevice, 654 .create_virtdevice = iblock_create_virtdevice,
665 .free_device = iblock_free_device, 655 .free_device = iblock_free_device,
666 .alloc_task = iblock_alloc_task, 656 .execute_cmd = iblock_execute_cmd,
667 .do_task = iblock_do_task,
668 .do_discard = iblock_do_discard, 657 .do_discard = iblock_do_discard,
669 .do_sync_cache = iblock_emulate_sync_cache, 658 .do_sync_cache = iblock_emulate_sync_cache,
670 .free_task = iblock_free_task,
671 .check_configfs_dev_params = iblock_check_configfs_dev_params, 659 .check_configfs_dev_params = iblock_check_configfs_dev_params,
672 .set_configfs_dev_params = iblock_set_configfs_dev_params, 660 .set_configfs_dev_params = iblock_set_configfs_dev_params,
673 .show_configfs_dev_params = iblock_show_configfs_dev_params, 661 .show_configfs_dev_params = iblock_show_configfs_dev_params,
diff --git a/drivers/target/target_core_iblock.h b/drivers/target/target_core_iblock.h
index e929370b6fd3..66cf7b9e205e 100644
--- a/drivers/target/target_core_iblock.h
+++ b/drivers/target/target_core_iblock.h
@@ -7,7 +7,6 @@
7#define IBLOCK_LBA_SHIFT 9 7#define IBLOCK_LBA_SHIFT 9
8 8
9struct iblock_req { 9struct iblock_req {
10 struct se_task ib_task;
11 atomic_t pending; 10 atomic_t pending;
12 atomic_t ib_bio_err_cnt; 11 atomic_t ib_bio_err_cnt;
13} ____cacheline_aligned; 12} ____cacheline_aligned;
diff --git a/drivers/target/target_core_internal.h b/drivers/target/target_core_internal.h
index 21c05638f158..165e82429687 100644
--- a/drivers/target/target_core_internal.h
+++ b/drivers/target/target_core_internal.h
@@ -5,15 +5,15 @@
5extern struct t10_alua_lu_gp *default_lu_gp; 5extern struct t10_alua_lu_gp *default_lu_gp;
6 6
7/* target_core_cdb.c */ 7/* target_core_cdb.c */
8int target_emulate_inquiry(struct se_task *task); 8int target_emulate_inquiry(struct se_cmd *cmd);
9int target_emulate_readcapacity(struct se_task *task); 9int target_emulate_readcapacity(struct se_cmd *cmd);
10int target_emulate_readcapacity_16(struct se_task *task); 10int target_emulate_readcapacity_16(struct se_cmd *cmd);
11int target_emulate_modesense(struct se_task *task); 11int target_emulate_modesense(struct se_cmd *cmd);
12int target_emulate_request_sense(struct se_task *task); 12int target_emulate_request_sense(struct se_cmd *cmd);
13int target_emulate_unmap(struct se_task *task); 13int target_emulate_unmap(struct se_cmd *cmd);
14int target_emulate_write_same(struct se_task *task); 14int target_emulate_write_same(struct se_cmd *cmd);
15int target_emulate_synchronize_cache(struct se_task *task); 15int target_emulate_synchronize_cache(struct se_cmd *cmd);
16int target_emulate_noop(struct se_task *task); 16int target_emulate_noop(struct se_cmd *cmd);
17 17
18/* target_core_device.c */ 18/* target_core_device.c */
19struct se_dev_entry *core_get_se_deve_from_rtpi(struct se_node_acl *, u16); 19struct se_dev_entry *core_get_se_deve_from_rtpi(struct se_node_acl *, u16);
@@ -28,7 +28,7 @@ int core_dev_export(struct se_device *, struct se_portal_group *,
28 struct se_lun *); 28 struct se_lun *);
29void core_dev_unexport(struct se_device *, struct se_portal_group *, 29void core_dev_unexport(struct se_device *, struct se_portal_group *,
30 struct se_lun *); 30 struct se_lun *);
31int target_report_luns(struct se_task *); 31int target_report_luns(struct se_cmd *);
32void se_release_device_for_hba(struct se_device *); 32void se_release_device_for_hba(struct se_device *);
33void se_release_vpd_for_dev(struct se_device *); 33void se_release_vpd_for_dev(struct se_device *);
34int se_free_virtual_device(struct se_device *, struct se_hba *); 34int se_free_virtual_device(struct se_device *, struct se_hba *);
@@ -104,8 +104,7 @@ void release_se_kmem_caches(void);
104u32 scsi_get_new_index(scsi_index_t); 104u32 scsi_get_new_index(scsi_index_t);
105void transport_subsystem_check_init(void); 105void transport_subsystem_check_init(void);
106void transport_cmd_finish_abort(struct se_cmd *, int); 106void transport_cmd_finish_abort(struct se_cmd *, int);
107void __transport_remove_task_from_execute_queue(struct se_task *, 107void __target_remove_from_execute_list(struct se_cmd *);
108 struct se_device *);
109unsigned char *transport_dump_cmd_direction(struct se_cmd *); 108unsigned char *transport_dump_cmd_direction(struct se_cmd *);
110void transport_dump_dev_state(struct se_device *, char *, int *); 109void transport_dump_dev_state(struct se_device *, char *, int *);
111void transport_dump_dev_info(struct se_device *, struct se_lun *, 110void transport_dump_dev_info(struct se_device *, struct se_lun *,
@@ -114,7 +113,7 @@ void transport_dump_vpd_proto_id(struct t10_vpd *, unsigned char *, int);
114int transport_dump_vpd_assoc(struct t10_vpd *, unsigned char *, int); 113int transport_dump_vpd_assoc(struct t10_vpd *, unsigned char *, int);
115int transport_dump_vpd_ident_type(struct t10_vpd *, unsigned char *, int); 114int transport_dump_vpd_ident_type(struct t10_vpd *, unsigned char *, int);
116int transport_dump_vpd_ident(struct t10_vpd *, unsigned char *, int); 115int transport_dump_vpd_ident(struct t10_vpd *, unsigned char *, int);
117bool target_stop_task(struct se_task *task, unsigned long *flags); 116bool target_stop_cmd(struct se_cmd *cmd, unsigned long *flags);
118int transport_clear_lun_from_sessions(struct se_lun *); 117int transport_clear_lun_from_sessions(struct se_lun *);
119void transport_send_task_abort(struct se_cmd *); 118void transport_send_task_abort(struct se_cmd *);
120 119
diff --git a/drivers/target/target_core_pr.c b/drivers/target/target_core_pr.c
index c3148b10b4b3..85564998500a 100644
--- a/drivers/target/target_core_pr.c
+++ b/drivers/target/target_core_pr.c
@@ -193,9 +193,8 @@ static int target_check_scsi2_reservation_conflict(struct se_cmd *cmd)
193 return 0; 193 return 0;
194} 194}
195 195
196int target_scsi2_reservation_release(struct se_task *task) 196int target_scsi2_reservation_release(struct se_cmd *cmd)
197{ 197{
198 struct se_cmd *cmd = task->task_se_cmd;
199 struct se_device *dev = cmd->se_dev; 198 struct se_device *dev = cmd->se_dev;
200 struct se_session *sess = cmd->se_sess; 199 struct se_session *sess = cmd->se_sess;
201 struct se_portal_group *tpg = sess->se_tpg; 200 struct se_portal_group *tpg = sess->se_tpg;
@@ -237,16 +236,13 @@ int target_scsi2_reservation_release(struct se_task *task)
237out_unlock: 236out_unlock:
238 spin_unlock(&dev->dev_reservation_lock); 237 spin_unlock(&dev->dev_reservation_lock);
239out: 238out:
240 if (!ret) { 239 if (!ret)
241 task->task_scsi_status = GOOD; 240 target_complete_cmd(cmd, GOOD);
242 transport_complete_task(task, 1);
243 }
244 return ret; 241 return ret;
245} 242}
246 243
247int target_scsi2_reservation_reserve(struct se_task *task) 244int target_scsi2_reservation_reserve(struct se_cmd *cmd)
248{ 245{
249 struct se_cmd *cmd = task->task_se_cmd;
250 struct se_device *dev = cmd->se_dev; 246 struct se_device *dev = cmd->se_dev;
251 struct se_session *sess = cmd->se_sess; 247 struct se_session *sess = cmd->se_sess;
252 struct se_portal_group *tpg = sess->se_tpg; 248 struct se_portal_group *tpg = sess->se_tpg;
@@ -307,10 +303,8 @@ int target_scsi2_reservation_reserve(struct se_task *task)
307out_unlock: 303out_unlock:
308 spin_unlock(&dev->dev_reservation_lock); 304 spin_unlock(&dev->dev_reservation_lock);
309out: 305out:
310 if (!ret) { 306 if (!ret)
311 task->task_scsi_status = GOOD; 307 target_complete_cmd(cmd, GOOD);
312 transport_complete_task(task, 1);
313 }
314 return ret; 308 return ret;
315} 309}
316 310
@@ -503,11 +497,10 @@ static int core_scsi3_pr_seq_non_holder(
503 * statement. 497 * statement.
504 */ 498 */
505 if (!ret && !other_cdb) { 499 if (!ret && !other_cdb) {
506#if 0
507 pr_debug("Allowing explict CDB: 0x%02x for %s" 500 pr_debug("Allowing explict CDB: 0x%02x for %s"
508 " reservation holder\n", cdb[0], 501 " reservation holder\n", cdb[0],
509 core_scsi3_pr_dump_type(pr_reg_type)); 502 core_scsi3_pr_dump_type(pr_reg_type));
510#endif 503
511 return ret; 504 return ret;
512 } 505 }
513 /* 506 /*
@@ -535,14 +528,14 @@ static int core_scsi3_pr_seq_non_holder(
535 * as we expect registered non-reservation holding 528 * as we expect registered non-reservation holding
536 * nexuses to issue CDBs. 529 * nexuses to issue CDBs.
537 */ 530 */
538#if 0 531
539 if (!registered_nexus) { 532 if (!registered_nexus) {
540 pr_debug("Allowing implict CDB: 0x%02x" 533 pr_debug("Allowing implict CDB: 0x%02x"
541 " for %s reservation on unregistered" 534 " for %s reservation on unregistered"
542 " nexus\n", cdb[0], 535 " nexus\n", cdb[0],
543 core_scsi3_pr_dump_type(pr_reg_type)); 536 core_scsi3_pr_dump_type(pr_reg_type));
544 } 537 }
545#endif 538
546 return 0; 539 return 0;
547 } 540 }
548 } else if ((reg_only) || (all_reg)) { 541 } else if ((reg_only) || (all_reg)) {
@@ -551,11 +544,11 @@ static int core_scsi3_pr_seq_non_holder(
551 * For PR_*_REG_ONLY and PR_*_ALL_REG reservations, 544 * For PR_*_REG_ONLY and PR_*_ALL_REG reservations,
552 * allow commands from registered nexuses. 545 * allow commands from registered nexuses.
553 */ 546 */
554#if 0 547
555 pr_debug("Allowing implict CDB: 0x%02x for %s" 548 pr_debug("Allowing implict CDB: 0x%02x for %s"
556 " reservation\n", cdb[0], 549 " reservation\n", cdb[0],
557 core_scsi3_pr_dump_type(pr_reg_type)); 550 core_scsi3_pr_dump_type(pr_reg_type));
558#endif 551
559 return 0; 552 return 0;
560 } 553 }
561 } 554 }
@@ -1669,12 +1662,12 @@ static int core_scsi3_decode_spec_i_port(
1669 ret = -EINVAL; 1662 ret = -EINVAL;
1670 goto out; 1663 goto out;
1671 } 1664 }
1672#if 0 1665
1673 pr_debug("SPC-3 PR SPEC_I_PT: Got %s data_length: %u tpdl: %u" 1666 pr_debug("SPC-3 PR SPEC_I_PT: Got %s data_length: %u tpdl: %u"
1674 " tid_len: %d for %s + %s\n", 1667 " tid_len: %d for %s + %s\n",
1675 dest_tpg->se_tpg_tfo->get_fabric_name(), cmd->data_length, 1668 dest_tpg->se_tpg_tfo->get_fabric_name(), cmd->data_length,
1676 tpdl, tid_len, i_str, iport_ptr); 1669 tpdl, tid_len, i_str, iport_ptr);
1677#endif 1670
1678 if (tid_len > tpdl) { 1671 if (tid_len > tpdl) {
1679 pr_err("SPC-3 PR SPEC_I_PT: Illegal tid_len:" 1672 pr_err("SPC-3 PR SPEC_I_PT: Illegal tid_len:"
1680 " %u for Transport ID: %s\n", tid_len, ptr); 1673 " %u for Transport ID: %s\n", tid_len, ptr);
@@ -1717,12 +1710,12 @@ static int core_scsi3_decode_spec_i_port(
1717 ret = -EINVAL; 1710 ret = -EINVAL;
1718 goto out; 1711 goto out;
1719 } 1712 }
1720#if 0 1713
1721 pr_debug("SPC-3 PR SPEC_I_PT: Located %s Node: %s" 1714 pr_debug("SPC-3 PR SPEC_I_PT: Located %s Node: %s"
1722 " dest_se_deve mapped_lun: %u\n", 1715 " dest_se_deve mapped_lun: %u\n",
1723 dest_tpg->se_tpg_tfo->get_fabric_name(), 1716 dest_tpg->se_tpg_tfo->get_fabric_name(),
1724 dest_node_acl->initiatorname, dest_se_deve->mapped_lun); 1717 dest_node_acl->initiatorname, dest_se_deve->mapped_lun);
1725#endif 1718
1726 /* 1719 /*
1727 * Skip any TransportIDs that already have a registration for 1720 * Skip any TransportIDs that already have a registration for
1728 * this target port. 1721 * this target port.
@@ -3476,10 +3469,10 @@ static int core_scsi3_emulate_pro_register_and_move(
3476 3469
3477 buf = transport_kmap_data_sg(cmd); 3470 buf = transport_kmap_data_sg(cmd);
3478 proto_ident = (buf[24] & 0x0f); 3471 proto_ident = (buf[24] & 0x0f);
3479#if 0 3472
3480 pr_debug("SPC-3 PR REGISTER_AND_MOVE: Extracted Protocol Identifier:" 3473 pr_debug("SPC-3 PR REGISTER_AND_MOVE: Extracted Protocol Identifier:"
3481 " 0x%02x\n", proto_ident); 3474 " 0x%02x\n", proto_ident);
3482#endif 3475
3483 if (proto_ident != dest_tf_ops->get_fabric_proto_ident(dest_se_tpg)) { 3476 if (proto_ident != dest_tf_ops->get_fabric_proto_ident(dest_se_tpg)) {
3484 pr_err("SPC-3 PR REGISTER_AND_MOVE: Received" 3477 pr_err("SPC-3 PR REGISTER_AND_MOVE: Received"
3485 " proto_ident: 0x%02x does not match ident: 0x%02x" 3478 " proto_ident: 0x%02x does not match ident: 0x%02x"
@@ -3578,11 +3571,11 @@ after_iport_check:
3578 ret = -EINVAL; 3571 ret = -EINVAL;
3579 goto out; 3572 goto out;
3580 } 3573 }
3581#if 0 3574
3582 pr_debug("SPC-3 PR REGISTER_AND_MOVE: Found %s dest_node_acl:" 3575 pr_debug("SPC-3 PR REGISTER_AND_MOVE: Found %s dest_node_acl:"
3583 " %s from TransportID\n", dest_tf_ops->get_fabric_name(), 3576 " %s from TransportID\n", dest_tf_ops->get_fabric_name(),
3584 dest_node_acl->initiatorname); 3577 dest_node_acl->initiatorname);
3585#endif 3578
3586 /* 3579 /*
3587 * Locate the struct se_dev_entry pointer for the matching RELATIVE TARGET 3580 * Locate the struct se_dev_entry pointer for the matching RELATIVE TARGET
3588 * PORT IDENTIFIER. 3581 * PORT IDENTIFIER.
@@ -3606,12 +3599,12 @@ after_iport_check:
3606 ret = -EINVAL; 3599 ret = -EINVAL;
3607 goto out; 3600 goto out;
3608 } 3601 }
3609#if 0 3602
3610 pr_debug("SPC-3 PR REGISTER_AND_MOVE: Located %s node %s LUN" 3603 pr_debug("SPC-3 PR REGISTER_AND_MOVE: Located %s node %s LUN"
3611 " ACL for dest_se_deve->mapped_lun: %u\n", 3604 " ACL for dest_se_deve->mapped_lun: %u\n",
3612 dest_tf_ops->get_fabric_name(), dest_node_acl->initiatorname, 3605 dest_tf_ops->get_fabric_name(), dest_node_acl->initiatorname,
3613 dest_se_deve->mapped_lun); 3606 dest_se_deve->mapped_lun);
3614#endif 3607
3615 /* 3608 /*
3616 * A persistent reservation needs to already existing in order to 3609 * A persistent reservation needs to already existing in order to
3617 * successfully complete the REGISTER_AND_MOVE service action.. 3610 * successfully complete the REGISTER_AND_MOVE service action..
@@ -3802,9 +3795,8 @@ static unsigned long long core_scsi3_extract_reservation_key(unsigned char *cdb)
3802/* 3795/*
3803 * See spc4r17 section 6.14 Table 170 3796 * See spc4r17 section 6.14 Table 170
3804 */ 3797 */
3805int target_scsi3_emulate_pr_out(struct se_task *task) 3798int target_scsi3_emulate_pr_out(struct se_cmd *cmd)
3806{ 3799{
3807 struct se_cmd *cmd = task->task_se_cmd;
3808 unsigned char *cdb = &cmd->t_task_cdb[0]; 3800 unsigned char *cdb = &cmd->t_task_cdb[0];
3809 unsigned char *buf; 3801 unsigned char *buf;
3810 u64 res_key, sa_res_key; 3802 u64 res_key, sa_res_key;
@@ -3944,10 +3936,8 @@ int target_scsi3_emulate_pr_out(struct se_task *task)
3944 } 3936 }
3945 3937
3946out: 3938out:
3947 if (!ret) { 3939 if (!ret)
3948 task->task_scsi_status = GOOD; 3940 target_complete_cmd(cmd, GOOD);
3949 transport_complete_task(task, 1);
3950 }
3951 return ret; 3941 return ret;
3952} 3942}
3953 3943
@@ -4302,9 +4292,8 @@ static int core_scsi3_pri_read_full_status(struct se_cmd *cmd)
4302 return 0; 4292 return 0;
4303} 4293}
4304 4294
4305int target_scsi3_emulate_pr_in(struct se_task *task) 4295int target_scsi3_emulate_pr_in(struct se_cmd *cmd)
4306{ 4296{
4307 struct se_cmd *cmd = task->task_se_cmd;
4308 int ret; 4297 int ret;
4309 4298
4310 /* 4299 /*
@@ -4345,10 +4334,8 @@ int target_scsi3_emulate_pr_in(struct se_task *task)
4345 break; 4334 break;
4346 } 4335 }
4347 4336
4348 if (!ret) { 4337 if (!ret)
4349 task->task_scsi_status = GOOD; 4338 target_complete_cmd(cmd, GOOD);
4350 transport_complete_task(task, 1);
4351 }
4352 return ret; 4339 return ret;
4353} 4340}
4354 4341
diff --git a/drivers/target/target_core_pr.h b/drivers/target/target_core_pr.h
index 7a233feb7e99..af6c460d886d 100644
--- a/drivers/target/target_core_pr.h
+++ b/drivers/target/target_core_pr.h
@@ -47,8 +47,8 @@ extern struct kmem_cache *t10_pr_reg_cache;
47 47
48extern int core_pr_dump_initiator_port(struct t10_pr_registration *, 48extern int core_pr_dump_initiator_port(struct t10_pr_registration *,
49 char *, u32); 49 char *, u32);
50extern int target_scsi2_reservation_release(struct se_task *task); 50extern int target_scsi2_reservation_release(struct se_cmd *);
51extern int target_scsi2_reservation_reserve(struct se_task *task); 51extern int target_scsi2_reservation_reserve(struct se_cmd *);
52extern int core_scsi3_alloc_aptpl_registration( 52extern int core_scsi3_alloc_aptpl_registration(
53 struct t10_reservation *, u64, 53 struct t10_reservation *, u64,
54 unsigned char *, unsigned char *, u32, 54 unsigned char *, unsigned char *, u32,
@@ -61,8 +61,8 @@ extern void core_scsi3_free_pr_reg_from_nacl(struct se_device *,
61extern void core_scsi3_free_all_registrations(struct se_device *); 61extern void core_scsi3_free_all_registrations(struct se_device *);
62extern unsigned char *core_scsi3_pr_dump_type(int); 62extern unsigned char *core_scsi3_pr_dump_type(int);
63 63
64extern int target_scsi3_emulate_pr_in(struct se_task *task); 64extern int target_scsi3_emulate_pr_in(struct se_cmd *);
65extern int target_scsi3_emulate_pr_out(struct se_task *task); 65extern int target_scsi3_emulate_pr_out(struct se_cmd *);
66extern int core_setup_reservations(struct se_device *, int); 66extern int core_setup_reservations(struct se_device *, int);
67 67
68#endif /* TARGET_CORE_PR_H */ 68#endif /* TARGET_CORE_PR_H */
diff --git a/drivers/target/target_core_pscsi.c b/drivers/target/target_core_pscsi.c
index 94c905fcbceb..4ce2cf642fce 100644
--- a/drivers/target/target_core_pscsi.c
+++ b/drivers/target/target_core_pscsi.c
@@ -663,22 +663,12 @@ static void pscsi_free_device(void *p)
663 kfree(pdv); 663 kfree(pdv);
664} 664}
665 665
666static inline struct pscsi_plugin_task *PSCSI_TASK(struct se_task *task) 666static int pscsi_transport_complete(struct se_cmd *cmd, struct scatterlist *sg)
667{ 667{
668 return container_of(task, struct pscsi_plugin_task, pscsi_task); 668 struct pscsi_dev_virt *pdv = cmd->se_dev->dev_ptr;
669}
670
671
672/* pscsi_transport_complete():
673 *
674 *
675 */
676static int pscsi_transport_complete(struct se_task *task)
677{
678 struct pscsi_dev_virt *pdv = task->task_se_cmd->se_dev->dev_ptr;
679 struct scsi_device *sd = pdv->pdv_sd; 669 struct scsi_device *sd = pdv->pdv_sd;
680 int result; 670 int result;
681 struct pscsi_plugin_task *pt = PSCSI_TASK(task); 671 struct pscsi_plugin_task *pt = cmd->priv;
682 unsigned char *cdb = &pt->pscsi_cdb[0]; 672 unsigned char *cdb = &pt->pscsi_cdb[0];
683 673
684 result = pt->pscsi_result; 674 result = pt->pscsi_result;
@@ -688,12 +678,11 @@ static int pscsi_transport_complete(struct se_task *task)
688 */ 678 */
689 if (((cdb[0] == MODE_SENSE) || (cdb[0] == MODE_SENSE_10)) && 679 if (((cdb[0] == MODE_SENSE) || (cdb[0] == MODE_SENSE_10)) &&
690 (status_byte(result) << 1) == SAM_STAT_GOOD) { 680 (status_byte(result) << 1) == SAM_STAT_GOOD) {
691 if (!task->task_se_cmd->se_deve) 681 if (!cmd->se_deve)
692 goto after_mode_sense; 682 goto after_mode_sense;
693 683
694 if (task->task_se_cmd->se_deve->lun_flags & 684 if (cmd->se_deve->lun_flags & TRANSPORT_LUNFLAGS_READ_ONLY) {
695 TRANSPORT_LUNFLAGS_READ_ONLY) { 685 unsigned char *buf = transport_kmap_data_sg(cmd);
696 unsigned char *buf = transport_kmap_data_sg(task->task_se_cmd);
697 686
698 if (cdb[0] == MODE_SENSE_10) { 687 if (cdb[0] == MODE_SENSE_10) {
699 if (!(buf[3] & 0x80)) 688 if (!(buf[3] & 0x80))
@@ -703,7 +692,7 @@ static int pscsi_transport_complete(struct se_task *task)
703 buf[2] |= 0x80; 692 buf[2] |= 0x80;
704 } 693 }
705 694
706 transport_kunmap_data_sg(task->task_se_cmd); 695 transport_kunmap_data_sg(cmd);
707 } 696 }
708 } 697 }
709after_mode_sense: 698after_mode_sense:
@@ -722,7 +711,6 @@ after_mode_sense:
722 if (((cdb[0] == MODE_SELECT) || (cdb[0] == MODE_SELECT_10)) && 711 if (((cdb[0] == MODE_SELECT) || (cdb[0] == MODE_SELECT_10)) &&
723 (status_byte(result) << 1) == SAM_STAT_GOOD) { 712 (status_byte(result) << 1) == SAM_STAT_GOOD) {
724 unsigned char *buf; 713 unsigned char *buf;
725 struct scatterlist *sg = task->task_sg;
726 u16 bdl; 714 u16 bdl;
727 u32 blocksize; 715 u32 blocksize;
728 716
@@ -757,35 +745,6 @@ after_mode_select:
757 return 0; 745 return 0;
758} 746}
759 747
760static struct se_task *
761pscsi_alloc_task(unsigned char *cdb)
762{
763 struct pscsi_plugin_task *pt;
764
765 /*
766 * Dynamically alloc cdb space, since it may be larger than
767 * TCM_MAX_COMMAND_SIZE
768 */
769 pt = kzalloc(sizeof(*pt) + scsi_command_size(cdb), GFP_KERNEL);
770 if (!pt) {
771 pr_err("Unable to allocate struct pscsi_plugin_task\n");
772 return NULL;
773 }
774
775 return &pt->pscsi_task;
776}
777
778static void pscsi_free_task(struct se_task *task)
779{
780 struct pscsi_plugin_task *pt = PSCSI_TASK(task);
781
782 /*
783 * We do not release the bio(s) here associated with this task, as
784 * this is handled by bio_put() and pscsi_bi_endio().
785 */
786 kfree(pt);
787}
788
789enum { 748enum {
790 Opt_scsi_host_id, Opt_scsi_channel_id, Opt_scsi_target_id, 749 Opt_scsi_host_id, Opt_scsi_channel_id, Opt_scsi_target_id,
791 Opt_scsi_lun_id, Opt_err 750 Opt_scsi_lun_id, Opt_err
@@ -958,26 +917,25 @@ static inline struct bio *pscsi_get_bio(int sg_num)
958 return bio; 917 return bio;
959} 918}
960 919
961static int pscsi_map_sg(struct se_task *task, struct scatterlist *task_sg, 920static int pscsi_map_sg(struct se_cmd *cmd, struct scatterlist *sgl,
921 u32 sgl_nents, enum dma_data_direction data_direction,
962 struct bio **hbio) 922 struct bio **hbio)
963{ 923{
964 struct se_cmd *cmd = task->task_se_cmd; 924 struct pscsi_dev_virt *pdv = cmd->se_dev->dev_ptr;
965 struct pscsi_dev_virt *pdv = task->task_se_cmd->se_dev->dev_ptr;
966 u32 task_sg_num = task->task_sg_nents;
967 struct bio *bio = NULL, *tbio = NULL; 925 struct bio *bio = NULL, *tbio = NULL;
968 struct page *page; 926 struct page *page;
969 struct scatterlist *sg; 927 struct scatterlist *sg;
970 u32 data_len = task->task_size, i, len, bytes, off; 928 u32 data_len = cmd->data_length, i, len, bytes, off;
971 int nr_pages = (task->task_size + task_sg[0].offset + 929 int nr_pages = (cmd->data_length + sgl[0].offset +
972 PAGE_SIZE - 1) >> PAGE_SHIFT; 930 PAGE_SIZE - 1) >> PAGE_SHIFT;
973 int nr_vecs = 0, rc; 931 int nr_vecs = 0, rc;
974 int rw = (task->task_data_direction == DMA_TO_DEVICE); 932 int rw = (data_direction == DMA_TO_DEVICE);
975 933
976 *hbio = NULL; 934 *hbio = NULL;
977 935
978 pr_debug("PSCSI: nr_pages: %d\n", nr_pages); 936 pr_debug("PSCSI: nr_pages: %d\n", nr_pages);
979 937
980 for_each_sg(task_sg, sg, task_sg_num, i) { 938 for_each_sg(sgl, sg, sgl_nents, i) {
981 page = sg_page(sg); 939 page = sg_page(sg);
982 off = sg->offset; 940 off = sg->offset;
983 len = sg->length; 941 len = sg->length;
@@ -1009,7 +967,7 @@ static int pscsi_map_sg(struct se_task *task, struct scatterlist *task_sg,
1009 * Set *hbio pointer to handle the case: 967 * Set *hbio pointer to handle the case:
1010 * nr_pages > BIO_MAX_PAGES, where additional 968 * nr_pages > BIO_MAX_PAGES, where additional
1011 * bios need to be added to complete a given 969 * bios need to be added to complete a given
1012 * struct se_task 970 * command.
1013 */ 971 */
1014 if (!*hbio) 972 if (!*hbio)
1015 *hbio = tbio = bio; 973 *hbio = tbio = bio;
@@ -1049,7 +1007,7 @@ static int pscsi_map_sg(struct se_task *task, struct scatterlist *task_sg,
1049 } 1007 }
1050 } 1008 }
1051 1009
1052 return task->task_sg_nents; 1010 return sgl_nents;
1053fail: 1011fail:
1054 while (*hbio) { 1012 while (*hbio) {
1055 bio = *hbio; 1013 bio = *hbio;
@@ -1061,52 +1019,61 @@ fail:
1061 return -ENOMEM; 1019 return -ENOMEM;
1062} 1020}
1063 1021
1064static int pscsi_do_task(struct se_task *task) 1022static int pscsi_execute_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
1023 u32 sgl_nents, enum dma_data_direction data_direction)
1065{ 1024{
1066 struct se_cmd *cmd = task->task_se_cmd; 1025 struct pscsi_dev_virt *pdv = cmd->se_dev->dev_ptr;
1067 struct pscsi_dev_virt *pdv = task->task_se_cmd->se_dev->dev_ptr; 1026 struct pscsi_plugin_task *pt;
1068 struct pscsi_plugin_task *pt = PSCSI_TASK(task);
1069 struct request *req; 1027 struct request *req;
1070 struct bio *hbio; 1028 struct bio *hbio;
1071 int ret; 1029 int ret;
1072 1030
1073 target_get_task_cdb(task, pt->pscsi_cdb); 1031 /*
1032 * Dynamically alloc cdb space, since it may be larger than
1033 * TCM_MAX_COMMAND_SIZE
1034 */
1035 pt = kzalloc(sizeof(*pt) + scsi_command_size(cmd->t_task_cdb), GFP_KERNEL);
1036 if (!pt) {
1037 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1038 return -ENOMEM;
1039 }
1040 cmd->priv = pt;
1041
1042 memcpy(pt->pscsi_cdb, cmd->t_task_cdb,
1043 scsi_command_size(cmd->t_task_cdb));
1074 1044
1075 if (task->task_se_cmd->se_cmd_flags & SCF_SCSI_NON_DATA_CDB) { 1045 if (cmd->se_cmd_flags & SCF_SCSI_NON_DATA_CDB) {
1076 req = blk_get_request(pdv->pdv_sd->request_queue, 1046 req = blk_get_request(pdv->pdv_sd->request_queue,
1077 (task->task_data_direction == DMA_TO_DEVICE), 1047 (data_direction == DMA_TO_DEVICE),
1078 GFP_KERNEL); 1048 GFP_KERNEL);
1079 if (!req || IS_ERR(req)) { 1049 if (!req || IS_ERR(req)) {
1080 pr_err("PSCSI: blk_get_request() failed: %ld\n", 1050 pr_err("PSCSI: blk_get_request() failed: %ld\n",
1081 req ? IS_ERR(req) : -ENOMEM); 1051 req ? IS_ERR(req) : -ENOMEM);
1082 cmd->scsi_sense_reason = 1052 cmd->scsi_sense_reason =
1083 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1053 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1084 return -ENODEV; 1054 goto fail;
1085 } 1055 }
1086 } else { 1056 } else {
1087 BUG_ON(!task->task_size); 1057 BUG_ON(!cmd->data_length);
1088 1058
1089 /* 1059 ret = pscsi_map_sg(cmd, sgl, sgl_nents, data_direction, &hbio);
1090 * Setup the main struct request for the task->task_sg[] payload
1091 */
1092 ret = pscsi_map_sg(task, task->task_sg, &hbio);
1093 if (ret < 0) { 1060 if (ret < 0) {
1094 cmd->scsi_sense_reason = 1061 cmd->scsi_sense_reason =
1095 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1062 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1096 return ret; 1063 goto fail;
1097 } 1064 }
1098 1065
1099 req = blk_make_request(pdv->pdv_sd->request_queue, hbio, 1066 req = blk_make_request(pdv->pdv_sd->request_queue, hbio,
1100 GFP_KERNEL); 1067 GFP_KERNEL);
1101 if (IS_ERR(req)) { 1068 if (IS_ERR(req)) {
1102 pr_err("pSCSI: blk_make_request() failed\n"); 1069 pr_err("pSCSI: blk_make_request() failed\n");
1103 goto fail; 1070 goto fail_free_bio;
1104 } 1071 }
1105 } 1072 }
1106 1073
1107 req->cmd_type = REQ_TYPE_BLOCK_PC; 1074 req->cmd_type = REQ_TYPE_BLOCK_PC;
1108 req->end_io = pscsi_req_done; 1075 req->end_io = pscsi_req_done;
1109 req->end_io_data = task; 1076 req->end_io_data = cmd;
1110 req->cmd_len = scsi_command_size(pt->pscsi_cdb); 1077 req->cmd_len = scsi_command_size(pt->pscsi_cdb);
1111 req->cmd = &pt->pscsi_cdb[0]; 1078 req->cmd = &pt->pscsi_cdb[0];
1112 req->sense = &pt->pscsi_sense[0]; 1079 req->sense = &pt->pscsi_sense[0];
@@ -1118,12 +1085,12 @@ static int pscsi_do_task(struct se_task *task)
1118 req->retries = PS_RETRY; 1085 req->retries = PS_RETRY;
1119 1086
1120 blk_execute_rq_nowait(pdv->pdv_sd->request_queue, NULL, req, 1087 blk_execute_rq_nowait(pdv->pdv_sd->request_queue, NULL, req,
1121 (task->task_se_cmd->sam_task_attr == MSG_HEAD_TAG), 1088 (cmd->sam_task_attr == MSG_HEAD_TAG),
1122 pscsi_req_done); 1089 pscsi_req_done);
1123 1090
1124 return 0; 1091 return 0;
1125 1092
1126fail: 1093fail_free_bio:
1127 while (hbio) { 1094 while (hbio) {
1128 struct bio *bio = hbio; 1095 struct bio *bio = hbio;
1129 hbio = hbio->bi_next; 1096 hbio = hbio->bi_next;
@@ -1131,16 +1098,14 @@ fail:
1131 bio_endio(bio, 0); /* XXX: should be error */ 1098 bio_endio(bio, 0); /* XXX: should be error */
1132 } 1099 }
1133 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 1100 cmd->scsi_sense_reason = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1101fail:
1102 kfree(pt);
1134 return -ENOMEM; 1103 return -ENOMEM;
1135} 1104}
1136 1105
1137/* pscsi_get_sense_buffer(): 1106static unsigned char *pscsi_get_sense_buffer(struct se_cmd *cmd)
1138 *
1139 *
1140 */
1141static unsigned char *pscsi_get_sense_buffer(struct se_task *task)
1142{ 1107{
1143 struct pscsi_plugin_task *pt = PSCSI_TASK(task); 1108 struct pscsi_plugin_task *pt = cmd->priv;
1144 1109
1145 return pt->pscsi_sense; 1110 return pt->pscsi_sense;
1146} 1111}
@@ -1180,48 +1145,36 @@ static sector_t pscsi_get_blocks(struct se_device *dev)
1180 return 0; 1145 return 0;
1181} 1146}
1182 1147
1183/* pscsi_handle_SAM_STATUS_failures(): 1148static void pscsi_req_done(struct request *req, int uptodate)
1184 *
1185 *
1186 */
1187static inline void pscsi_process_SAM_status(
1188 struct se_task *task,
1189 struct pscsi_plugin_task *pt)
1190{ 1149{
1191 task->task_scsi_status = status_byte(pt->pscsi_result); 1150 struct se_cmd *cmd = req->end_io_data;
1192 if (task->task_scsi_status) { 1151 struct pscsi_plugin_task *pt = cmd->priv;
1193 task->task_scsi_status <<= 1; 1152
1194 pr_debug("PSCSI Status Byte exception at task: %p CDB:" 1153 pt->pscsi_result = req->errors;
1195 " 0x%02x Result: 0x%08x\n", task, pt->pscsi_cdb[0], 1154 pt->pscsi_resid = req->resid_len;
1155
1156 cmd->scsi_status = status_byte(pt->pscsi_result) << 1;
1157 if (cmd->scsi_status) {
1158 pr_debug("PSCSI Status Byte exception at cmd: %p CDB:"
1159 " 0x%02x Result: 0x%08x\n", cmd, pt->pscsi_cdb[0],
1196 pt->pscsi_result); 1160 pt->pscsi_result);
1197 } 1161 }
1198 1162
1199 switch (host_byte(pt->pscsi_result)) { 1163 switch (host_byte(pt->pscsi_result)) {
1200 case DID_OK: 1164 case DID_OK:
1201 transport_complete_task(task, (!task->task_scsi_status)); 1165 target_complete_cmd(cmd, cmd->scsi_status);
1202 break; 1166 break;
1203 default: 1167 default:
1204 pr_debug("PSCSI Host Byte exception at task: %p CDB:" 1168 pr_debug("PSCSI Host Byte exception at cmd: %p CDB:"
1205 " 0x%02x Result: 0x%08x\n", task, pt->pscsi_cdb[0], 1169 " 0x%02x Result: 0x%08x\n", cmd, pt->pscsi_cdb[0],
1206 pt->pscsi_result); 1170 pt->pscsi_result);
1207 task->task_scsi_status = SAM_STAT_CHECK_CONDITION; 1171 cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE;
1208 task->task_se_cmd->scsi_sense_reason = 1172 target_complete_cmd(cmd, SAM_STAT_CHECK_CONDITION);
1209 TCM_UNSUPPORTED_SCSI_OPCODE;
1210 transport_complete_task(task, 0);
1211 break; 1173 break;
1212 } 1174 }
1213}
1214 1175
1215static void pscsi_req_done(struct request *req, int uptodate)
1216{
1217 struct se_task *task = req->end_io_data;
1218 struct pscsi_plugin_task *pt = PSCSI_TASK(task);
1219
1220 pt->pscsi_result = req->errors;
1221 pt->pscsi_resid = req->resid_len;
1222
1223 pscsi_process_SAM_status(task, pt);
1224 __blk_put_request(req->q, req); 1176 __blk_put_request(req->q, req);
1177 kfree(pt);
1225} 1178}
1226 1179
1227static struct se_subsystem_api pscsi_template = { 1180static struct se_subsystem_api pscsi_template = {
@@ -1235,9 +1188,7 @@ static struct se_subsystem_api pscsi_template = {
1235 .create_virtdevice = pscsi_create_virtdevice, 1188 .create_virtdevice = pscsi_create_virtdevice,
1236 .free_device = pscsi_free_device, 1189 .free_device = pscsi_free_device,
1237 .transport_complete = pscsi_transport_complete, 1190 .transport_complete = pscsi_transport_complete,
1238 .alloc_task = pscsi_alloc_task, 1191 .execute_cmd = pscsi_execute_cmd,
1239 .do_task = pscsi_do_task,
1240 .free_task = pscsi_free_task,
1241 .check_configfs_dev_params = pscsi_check_configfs_dev_params, 1192 .check_configfs_dev_params = pscsi_check_configfs_dev_params,
1242 .set_configfs_dev_params = pscsi_set_configfs_dev_params, 1193 .set_configfs_dev_params = pscsi_set_configfs_dev_params,
1243 .show_configfs_dev_params = pscsi_show_configfs_dev_params, 1194 .show_configfs_dev_params = pscsi_show_configfs_dev_params,
diff --git a/drivers/target/target_core_pscsi.h b/drivers/target/target_core_pscsi.h
index 43f1c419e8e5..bc1e5e11eca0 100644
--- a/drivers/target/target_core_pscsi.h
+++ b/drivers/target/target_core_pscsi.h
@@ -22,7 +22,6 @@
22#include <linux/kobject.h> 22#include <linux/kobject.h>
23 23
24struct pscsi_plugin_task { 24struct pscsi_plugin_task {
25 struct se_task pscsi_task;
26 unsigned char pscsi_sense[SCSI_SENSE_BUFFERSIZE]; 25 unsigned char pscsi_sense[SCSI_SENSE_BUFFERSIZE];
27 int pscsi_direction; 26 int pscsi_direction;
28 int pscsi_result; 27 int pscsi_result;
diff --git a/drivers/target/target_core_rd.c b/drivers/target/target_core_rd.c
index 8b68f7b82631..d0ceb873c0e5 100644
--- a/drivers/target/target_core_rd.c
+++ b/drivers/target/target_core_rd.c
@@ -64,9 +64,6 @@ static int rd_attach_hba(struct se_hba *hba, u32 host_id)
64 pr_debug("CORE_HBA[%d] - TCM Ramdisk HBA Driver %s on" 64 pr_debug("CORE_HBA[%d] - TCM Ramdisk HBA Driver %s on"
65 " Generic Target Core Stack %s\n", hba->hba_id, 65 " Generic Target Core Stack %s\n", hba->hba_id,
66 RD_HBA_VERSION, TARGET_CORE_MOD_VERSION); 66 RD_HBA_VERSION, TARGET_CORE_MOD_VERSION);
67 pr_debug("CORE_HBA[%d] - Attached Ramdisk HBA: %u to Generic"
68 " MaxSectors: %u\n", hba->hba_id,
69 rd_host->rd_host_id, RD_MAX_SECTORS);
70 67
71 return 0; 68 return 0;
72} 69}
@@ -199,10 +196,7 @@ static int rd_build_device_space(struct rd_dev *rd_dev)
199 return 0; 196 return 0;
200} 197}
201 198
202static void *rd_allocate_virtdevice( 199static void *rd_allocate_virtdevice(struct se_hba *hba, const char *name)
203 struct se_hba *hba,
204 const char *name,
205 int rd_direct)
206{ 200{
207 struct rd_dev *rd_dev; 201 struct rd_dev *rd_dev;
208 struct rd_host *rd_host = hba->hba_ptr; 202 struct rd_host *rd_host = hba->hba_ptr;
@@ -214,25 +208,12 @@ static void *rd_allocate_virtdevice(
214 } 208 }
215 209
216 rd_dev->rd_host = rd_host; 210 rd_dev->rd_host = rd_host;
217 rd_dev->rd_direct = rd_direct;
218 211
219 return rd_dev; 212 return rd_dev;
220} 213}
221 214
222static void *rd_MEMCPY_allocate_virtdevice(struct se_hba *hba, const char *name) 215static struct se_device *rd_create_virtdevice(struct se_hba *hba,
223{ 216 struct se_subsystem_dev *se_dev, void *p)
224 return rd_allocate_virtdevice(hba, name, 0);
225}
226
227/* rd_create_virtdevice():
228 *
229 *
230 */
231static struct se_device *rd_create_virtdevice(
232 struct se_hba *hba,
233 struct se_subsystem_dev *se_dev,
234 void *p,
235 int rd_direct)
236{ 217{
237 struct se_device *dev; 218 struct se_device *dev;
238 struct se_dev_limits dev_limits; 219 struct se_dev_limits dev_limits;
@@ -247,13 +228,12 @@ static struct se_device *rd_create_virtdevice(
247 if (ret < 0) 228 if (ret < 0)
248 goto fail; 229 goto fail;
249 230
250 snprintf(prod, 16, "RAMDISK-%s", (rd_dev->rd_direct) ? "DR" : "MCP"); 231 snprintf(prod, 16, "RAMDISK-MCP");
251 snprintf(rev, 4, "%s", (rd_dev->rd_direct) ? RD_DR_VERSION : 232 snprintf(rev, 4, "%s", RD_MCP_VERSION);
252 RD_MCP_VERSION);
253 233
254 dev_limits.limits.logical_block_size = RD_BLOCKSIZE; 234 dev_limits.limits.logical_block_size = RD_BLOCKSIZE;
255 dev_limits.limits.max_hw_sectors = RD_MAX_SECTORS; 235 dev_limits.limits.max_hw_sectors = UINT_MAX;
256 dev_limits.limits.max_sectors = RD_MAX_SECTORS; 236 dev_limits.limits.max_sectors = UINT_MAX;
257 dev_limits.hw_queue_depth = RD_MAX_DEVICE_QUEUE_DEPTH; 237 dev_limits.hw_queue_depth = RD_MAX_DEVICE_QUEUE_DEPTH;
258 dev_limits.queue_depth = RD_DEVICE_QUEUE_DEPTH; 238 dev_limits.queue_depth = RD_DEVICE_QUEUE_DEPTH;
259 239
@@ -264,12 +244,10 @@ static struct se_device *rd_create_virtdevice(
264 goto fail; 244 goto fail;
265 245
266 rd_dev->rd_dev_id = rd_host->rd_host_dev_id_count++; 246 rd_dev->rd_dev_id = rd_host->rd_host_dev_id_count++;
267 rd_dev->rd_queue_depth = dev->queue_depth;
268 247
269 pr_debug("CORE_RD[%u] - Added TCM %s Ramdisk Device ID: %u of" 248 pr_debug("CORE_RD[%u] - Added TCM MEMCPY Ramdisk Device ID: %u of"
270 " %u pages in %u tables, %lu total bytes\n", 249 " %u pages in %u tables, %lu total bytes\n",
271 rd_host->rd_host_id, (!rd_dev->rd_direct) ? "MEMCPY" : 250 rd_host->rd_host_id, rd_dev->rd_dev_id, rd_dev->rd_page_count,
272 "DIRECT", rd_dev->rd_dev_id, rd_dev->rd_page_count,
273 rd_dev->sg_table_count, 251 rd_dev->sg_table_count,
274 (unsigned long)(rd_dev->rd_page_count * PAGE_SIZE)); 252 (unsigned long)(rd_dev->rd_page_count * PAGE_SIZE));
275 253
@@ -280,18 +258,6 @@ fail:
280 return ERR_PTR(ret); 258 return ERR_PTR(ret);
281} 259}
282 260
283static struct se_device *rd_MEMCPY_create_virtdevice(
284 struct se_hba *hba,
285 struct se_subsystem_dev *se_dev,
286 void *p)
287{
288 return rd_create_virtdevice(hba, se_dev, p, 0);
289}
290
291/* rd_free_device(): (Part of se_subsystem_api_t template)
292 *
293 *
294 */
295static void rd_free_device(void *p) 261static void rd_free_device(void *p)
296{ 262{
297 struct rd_dev *rd_dev = p; 263 struct rd_dev *rd_dev = p;
@@ -300,29 +266,6 @@ static void rd_free_device(void *p)
300 kfree(rd_dev); 266 kfree(rd_dev);
301} 267}
302 268
303static inline struct rd_request *RD_REQ(struct se_task *task)
304{
305 return container_of(task, struct rd_request, rd_task);
306}
307
308static struct se_task *
309rd_alloc_task(unsigned char *cdb)
310{
311 struct rd_request *rd_req;
312
313 rd_req = kzalloc(sizeof(struct rd_request), GFP_KERNEL);
314 if (!rd_req) {
315 pr_err("Unable to allocate struct rd_request\n");
316 return NULL;
317 }
318
319 return &rd_req->rd_task;
320}
321
322/* rd_get_sg_table():
323 *
324 *
325 */
326static struct rd_dev_sg_table *rd_get_sg_table(struct rd_dev *rd_dev, u32 page) 269static struct rd_dev_sg_table *rd_get_sg_table(struct rd_dev *rd_dev, u32 page)
327{ 270{
328 u32 i; 271 u32 i;
@@ -341,31 +284,41 @@ static struct rd_dev_sg_table *rd_get_sg_table(struct rd_dev *rd_dev, u32 page)
341 return NULL; 284 return NULL;
342} 285}
343 286
344static int rd_MEMCPY(struct rd_request *req, u32 read_rd) 287static int rd_execute_cmd(struct se_cmd *cmd, struct scatterlist *sgl,
288 u32 sgl_nents, enum dma_data_direction data_direction)
345{ 289{
346 struct se_task *task = &req->rd_task; 290 struct se_device *se_dev = cmd->se_dev;
347 struct rd_dev *dev = req->rd_task.task_se_cmd->se_dev->dev_ptr; 291 struct rd_dev *dev = se_dev->dev_ptr;
348 struct rd_dev_sg_table *table; 292 struct rd_dev_sg_table *table;
349 struct scatterlist *rd_sg; 293 struct scatterlist *rd_sg;
350 struct sg_mapping_iter m; 294 struct sg_mapping_iter m;
351 u32 rd_offset = req->rd_offset; 295 u32 rd_offset;
296 u32 rd_size;
297 u32 rd_page;
352 u32 src_len; 298 u32 src_len;
299 u64 tmp;
300
301 tmp = cmd->t_task_lba * se_dev->se_sub_dev->se_dev_attrib.block_size;
302 rd_offset = do_div(tmp, PAGE_SIZE);
303 rd_page = tmp;
304 rd_size = cmd->data_length;
353 305
354 table = rd_get_sg_table(dev, req->rd_page); 306 table = rd_get_sg_table(dev, rd_page);
355 if (!table) 307 if (!table)
356 return -EINVAL; 308 return -EINVAL;
357 309
358 rd_sg = &table->sg_table[req->rd_page - table->page_start_offset]; 310 rd_sg = &table->sg_table[rd_page - table->page_start_offset];
359 311
360 pr_debug("RD[%u]: %s LBA: %llu, Size: %u Page: %u, Offset: %u\n", 312 pr_debug("RD[%u]: %s LBA: %llu, Size: %u Page: %u, Offset: %u\n",
361 dev->rd_dev_id, read_rd ? "Read" : "Write", 313 dev->rd_dev_id,
362 task->task_lba, req->rd_size, req->rd_page, 314 data_direction == DMA_FROM_DEVICE ? "Read" : "Write",
363 rd_offset); 315 cmd->t_task_lba, rd_size, rd_page, rd_offset);
364 316
365 src_len = PAGE_SIZE - rd_offset; 317 src_len = PAGE_SIZE - rd_offset;
366 sg_miter_start(&m, task->task_sg, task->task_sg_nents, 318 sg_miter_start(&m, sgl, sgl_nents,
367 read_rd ? SG_MITER_TO_SG : SG_MITER_FROM_SG); 319 data_direction == DMA_FROM_DEVICE ?
368 while (req->rd_size) { 320 SG_MITER_TO_SG : SG_MITER_FROM_SG);
321 while (rd_size) {
369 u32 len; 322 u32 len;
370 void *rd_addr; 323 void *rd_addr;
371 324
@@ -375,13 +328,13 @@ static int rd_MEMCPY(struct rd_request *req, u32 read_rd)
375 328
376 rd_addr = sg_virt(rd_sg) + rd_offset; 329 rd_addr = sg_virt(rd_sg) + rd_offset;
377 330
378 if (read_rd) 331 if (data_direction == DMA_FROM_DEVICE)
379 memcpy(m.addr, rd_addr, len); 332 memcpy(m.addr, rd_addr, len);
380 else 333 else
381 memcpy(rd_addr, m.addr, len); 334 memcpy(rd_addr, m.addr, len);
382 335
383 req->rd_size -= len; 336 rd_size -= len;
384 if (!req->rd_size) 337 if (!rd_size)
385 continue; 338 continue;
386 339
387 src_len -= len; 340 src_len -= len;
@@ -391,15 +344,15 @@ static int rd_MEMCPY(struct rd_request *req, u32 read_rd)
391 } 344 }
392 345
393 /* rd page completed, next one please */ 346 /* rd page completed, next one please */
394 req->rd_page++; 347 rd_page++;
395 rd_offset = 0; 348 rd_offset = 0;
396 src_len = PAGE_SIZE; 349 src_len = PAGE_SIZE;
397 if (req->rd_page <= table->page_end_offset) { 350 if (rd_page <= table->page_end_offset) {
398 rd_sg++; 351 rd_sg++;
399 continue; 352 continue;
400 } 353 }
401 354
402 table = rd_get_sg_table(dev, req->rd_page); 355 table = rd_get_sg_table(dev, rd_page);
403 if (!table) { 356 if (!table) {
404 sg_miter_stop(&m); 357 sg_miter_stop(&m);
405 return -EINVAL; 358 return -EINVAL;
@@ -409,43 +362,11 @@ static int rd_MEMCPY(struct rd_request *req, u32 read_rd)
409 rd_sg = table->sg_table; 362 rd_sg = table->sg_table;
410 } 363 }
411 sg_miter_stop(&m); 364 sg_miter_stop(&m);
412 return 0;
413}
414 365
415/* rd_MEMCPY_do_task(): (Part of se_subsystem_api_t template) 366 target_complete_cmd(cmd, SAM_STAT_GOOD);
416 *
417 *
418 */
419static int rd_MEMCPY_do_task(struct se_task *task)
420{
421 struct se_device *dev = task->task_se_cmd->se_dev;
422 struct rd_request *req = RD_REQ(task);
423 u64 tmp;
424 int ret;
425
426 tmp = task->task_lba * dev->se_sub_dev->se_dev_attrib.block_size;
427 req->rd_offset = do_div(tmp, PAGE_SIZE);
428 req->rd_page = tmp;
429 req->rd_size = task->task_size;
430
431 ret = rd_MEMCPY(req, task->task_data_direction == DMA_FROM_DEVICE);
432 if (ret != 0)
433 return ret;
434
435 task->task_scsi_status = GOOD;
436 transport_complete_task(task, 1);
437 return 0; 367 return 0;
438} 368}
439 369
440/* rd_free_task(): (Part of se_subsystem_api_t template)
441 *
442 *
443 */
444static void rd_free_task(struct se_task *task)
445{
446 kfree(RD_REQ(task));
447}
448
449enum { 370enum {
450 Opt_rd_pages, Opt_err 371 Opt_rd_pages, Opt_err
451}; 372};
@@ -512,9 +433,8 @@ static ssize_t rd_show_configfs_dev_params(
512 char *b) 433 char *b)
513{ 434{
514 struct rd_dev *rd_dev = se_dev->se_dev_su_ptr; 435 struct rd_dev *rd_dev = se_dev->se_dev_su_ptr;
515 ssize_t bl = sprintf(b, "TCM RamDisk ID: %u RamDisk Makeup: %s\n", 436 ssize_t bl = sprintf(b, "TCM RamDisk ID: %u RamDisk Makeup: rd_mcp\n",
516 rd_dev->rd_dev_id, (rd_dev->rd_direct) ? 437 rd_dev->rd_dev_id);
517 "rd_direct" : "rd_mcp");
518 bl += sprintf(b + bl, " PAGES/PAGE_SIZE: %u*%lu" 438 bl += sprintf(b + bl, " PAGES/PAGE_SIZE: %u*%lu"
519 " SG_table_count: %u\n", rd_dev->rd_page_count, 439 " SG_table_count: %u\n", rd_dev->rd_page_count,
520 PAGE_SIZE, rd_dev->sg_table_count); 440 PAGE_SIZE, rd_dev->sg_table_count);
@@ -545,12 +465,10 @@ static struct se_subsystem_api rd_mcp_template = {
545 .transport_type = TRANSPORT_PLUGIN_VHBA_VDEV, 465 .transport_type = TRANSPORT_PLUGIN_VHBA_VDEV,
546 .attach_hba = rd_attach_hba, 466 .attach_hba = rd_attach_hba,
547 .detach_hba = rd_detach_hba, 467 .detach_hba = rd_detach_hba,
548 .allocate_virtdevice = rd_MEMCPY_allocate_virtdevice, 468 .allocate_virtdevice = rd_allocate_virtdevice,
549 .create_virtdevice = rd_MEMCPY_create_virtdevice, 469 .create_virtdevice = rd_create_virtdevice,
550 .free_device = rd_free_device, 470 .free_device = rd_free_device,
551 .alloc_task = rd_alloc_task, 471 .execute_cmd = rd_execute_cmd,
552 .do_task = rd_MEMCPY_do_task,
553 .free_task = rd_free_task,
554 .check_configfs_dev_params = rd_check_configfs_dev_params, 472 .check_configfs_dev_params = rd_check_configfs_dev_params,
555 .set_configfs_dev_params = rd_set_configfs_dev_params, 473 .set_configfs_dev_params = rd_set_configfs_dev_params,
556 .show_configfs_dev_params = rd_show_configfs_dev_params, 474 .show_configfs_dev_params = rd_show_configfs_dev_params,
diff --git a/drivers/target/target_core_rd.h b/drivers/target/target_core_rd.h
index 784e56a04100..21458125fe51 100644
--- a/drivers/target/target_core_rd.h
+++ b/drivers/target/target_core_rd.h
@@ -2,7 +2,6 @@
2#define TARGET_CORE_RD_H 2#define TARGET_CORE_RD_H
3 3
4#define RD_HBA_VERSION "v4.0" 4#define RD_HBA_VERSION "v4.0"
5#define RD_DR_VERSION "4.0"
6#define RD_MCP_VERSION "4.0" 5#define RD_MCP_VERSION "4.0"
7 6
8/* Largest piece of memory kmalloc can allocate */ 7/* Largest piece of memory kmalloc can allocate */
@@ -10,28 +9,11 @@
10#define RD_DEVICE_QUEUE_DEPTH 32 9#define RD_DEVICE_QUEUE_DEPTH 32
11#define RD_MAX_DEVICE_QUEUE_DEPTH 128 10#define RD_MAX_DEVICE_QUEUE_DEPTH 128
12#define RD_BLOCKSIZE 512 11#define RD_BLOCKSIZE 512
13#define RD_MAX_SECTORS 1024
14 12
15/* Used in target_core_init_configfs() for virtual LUN 0 access */ 13/* Used in target_core_init_configfs() for virtual LUN 0 access */
16int __init rd_module_init(void); 14int __init rd_module_init(void);
17void rd_module_exit(void); 15void rd_module_exit(void);
18 16
19#define RRF_EMULATE_CDB 0x01
20#define RRF_GOT_LBA 0x02
21
22struct rd_request {
23 struct se_task rd_task;
24
25 /* Offset from start of page */
26 u32 rd_offset;
27 /* Starting page in Ramdisk for request */
28 u32 rd_page;
29 /* Total number of pages needed for request */
30 u32 rd_page_count;
31 /* Scatterlist count */
32 u32 rd_size;
33} ____cacheline_aligned;
34
35struct rd_dev_sg_table { 17struct rd_dev_sg_table {
36 u32 page_start_offset; 18 u32 page_start_offset;
37 u32 page_end_offset; 19 u32 page_end_offset;
@@ -42,7 +24,6 @@ struct rd_dev_sg_table {
42#define RDF_HAS_PAGE_COUNT 0x01 24#define RDF_HAS_PAGE_COUNT 0x01
43 25
44struct rd_dev { 26struct rd_dev {
45 int rd_direct;
46 u32 rd_flags; 27 u32 rd_flags;
47 /* Unique Ramdisk Device ID in Ramdisk HBA */ 28 /* Unique Ramdisk Device ID in Ramdisk HBA */
48 u32 rd_dev_id; 29 u32 rd_dev_id;
@@ -50,7 +31,6 @@ struct rd_dev {
50 u32 rd_page_count; 31 u32 rd_page_count;
51 /* Number of SG tables in sg_table_array */ 32 /* Number of SG tables in sg_table_array */
52 u32 sg_table_count; 33 u32 sg_table_count;
53 u32 rd_queue_depth;
54 /* Array of rd_dev_sg_table_t containing scatterlists */ 34 /* Array of rd_dev_sg_table_t containing scatterlists */
55 struct rd_dev_sg_table *sg_table_array; 35 struct rd_dev_sg_table *sg_table_array;
56 /* Ramdisk HBA device is connected to */ 36 /* Ramdisk HBA device is connected to */
diff --git a/drivers/target/target_core_tmr.c b/drivers/target/target_core_tmr.c
index f015839aef89..84caf1bed9a3 100644
--- a/drivers/target/target_core_tmr.c
+++ b/drivers/target/target_core_tmr.c
@@ -244,7 +244,7 @@ static void core_tmr_drain_tmr_list(
244 } 244 }
245} 245}
246 246
247static void core_tmr_drain_task_list( 247static void core_tmr_drain_state_list(
248 struct se_device *dev, 248 struct se_device *dev,
249 struct se_cmd *prout_cmd, 249 struct se_cmd *prout_cmd,
250 struct se_node_acl *tmr_nacl, 250 struct se_node_acl *tmr_nacl,
@@ -252,12 +252,13 @@ static void core_tmr_drain_task_list(
252 struct list_head *preempt_and_abort_list) 252 struct list_head *preempt_and_abort_list)
253{ 253{
254 LIST_HEAD(drain_task_list); 254 LIST_HEAD(drain_task_list);
255 struct se_cmd *cmd; 255 struct se_cmd *cmd, *next;
256 struct se_task *task, *task_tmp;
257 unsigned long flags; 256 unsigned long flags;
258 int fe_count; 257 int fe_count;
258
259 /* 259 /*
260 * Complete outstanding struct se_task CDBs with TASK_ABORTED SAM status. 260 * Complete outstanding commands with TASK_ABORTED SAM status.
261 *
261 * This is following sam4r17, section 5.6 Aborting commands, Table 38 262 * This is following sam4r17, section 5.6 Aborting commands, Table 38
262 * for TMR LUN_RESET: 263 * for TMR LUN_RESET:
263 * 264 *
@@ -278,56 +279,43 @@ static void core_tmr_drain_task_list(
278 * in the Control Mode Page. 279 * in the Control Mode Page.
279 */ 280 */
280 spin_lock_irqsave(&dev->execute_task_lock, flags); 281 spin_lock_irqsave(&dev->execute_task_lock, flags);
281 list_for_each_entry_safe(task, task_tmp, &dev->state_task_list, 282 list_for_each_entry_safe(cmd, next, &dev->state_list, state_list) {
282 t_state_list) {
283 if (!task->task_se_cmd) {
284 pr_err("task->task_se_cmd is NULL!\n");
285 continue;
286 }
287 cmd = task->task_se_cmd;
288
289 /* 283 /*
290 * For PREEMPT_AND_ABORT usage, only process commands 284 * For PREEMPT_AND_ABORT usage, only process commands
291 * with a matching reservation key. 285 * with a matching reservation key.
292 */ 286 */
293 if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd)) 287 if (target_check_cdb_and_preempt(preempt_and_abort_list, cmd))
294 continue; 288 continue;
289
295 /* 290 /*
296 * Not aborting PROUT PREEMPT_AND_ABORT CDB.. 291 * Not aborting PROUT PREEMPT_AND_ABORT CDB..
297 */ 292 */
298 if (prout_cmd == cmd) 293 if (prout_cmd == cmd)
299 continue; 294 continue;
300 295
301 list_move_tail(&task->t_state_list, &drain_task_list); 296 list_move_tail(&cmd->state_list, &drain_task_list);
302 task->t_state_active = false; 297 cmd->state_active = false;
303 /* 298
304 * Remove from task execute list before processing drain_task_list 299 if (!list_empty(&cmd->execute_list))
305 */ 300 __target_remove_from_execute_list(cmd);
306 if (!list_empty(&task->t_execute_list))
307 __transport_remove_task_from_execute_queue(task, dev);
308 } 301 }
309 spin_unlock_irqrestore(&dev->execute_task_lock, flags); 302 spin_unlock_irqrestore(&dev->execute_task_lock, flags);
310 303
311 while (!list_empty(&drain_task_list)) { 304 while (!list_empty(&drain_task_list)) {
312 task = list_entry(drain_task_list.next, struct se_task, t_state_list); 305 cmd = list_entry(drain_task_list.next, struct se_cmd, state_list);
313 list_del(&task->t_state_list); 306 list_del(&cmd->state_list);
314 cmd = task->task_se_cmd;
315 307
316 pr_debug("LUN_RESET: %s cmd: %p task: %p" 308 pr_debug("LUN_RESET: %s cmd: %p"
317 " ITT/CmdSN: 0x%08x/0x%08x, i_state: %d, t_state: %d" 309 " ITT/CmdSN: 0x%08x/0x%08x, i_state: %d, t_state: %d"
318 "cdb: 0x%02x\n", 310 "cdb: 0x%02x\n",
319 (preempt_and_abort_list) ? "Preempt" : "", cmd, task, 311 (preempt_and_abort_list) ? "Preempt" : "", cmd,
320 cmd->se_tfo->get_task_tag(cmd), 0, 312 cmd->se_tfo->get_task_tag(cmd), 0,
321 cmd->se_tfo->get_cmd_state(cmd), cmd->t_state, 313 cmd->se_tfo->get_cmd_state(cmd), cmd->t_state,
322 cmd->t_task_cdb[0]); 314 cmd->t_task_cdb[0]);
323 pr_debug("LUN_RESET: ITT[0x%08x] - pr_res_key: 0x%016Lx" 315 pr_debug("LUN_RESET: ITT[0x%08x] - pr_res_key: 0x%016Lx"
324 " t_task_cdbs: %d t_task_cdbs_left: %d" 316 " -- CMD_T_ACTIVE: %d"
325 " t_task_cdbs_sent: %d -- CMD_T_ACTIVE: %d"
326 " CMD_T_STOP: %d CMD_T_SENT: %d\n", 317 " CMD_T_STOP: %d CMD_T_SENT: %d\n",
327 cmd->se_tfo->get_task_tag(cmd), cmd->pr_res_key, 318 cmd->se_tfo->get_task_tag(cmd), cmd->pr_res_key,
328 cmd->t_task_list_num,
329 atomic_read(&cmd->t_task_cdbs_left),
330 atomic_read(&cmd->t_task_cdbs_sent),
331 (cmd->transport_state & CMD_T_ACTIVE) != 0, 319 (cmd->transport_state & CMD_T_ACTIVE) != 0,
332 (cmd->transport_state & CMD_T_STOP) != 0, 320 (cmd->transport_state & CMD_T_STOP) != 0,
333 (cmd->transport_state & CMD_T_SENT) != 0); 321 (cmd->transport_state & CMD_T_SENT) != 0);
@@ -343,20 +331,13 @@ static void core_tmr_drain_task_list(
343 cancel_work_sync(&cmd->work); 331 cancel_work_sync(&cmd->work);
344 332
345 spin_lock_irqsave(&cmd->t_state_lock, flags); 333 spin_lock_irqsave(&cmd->t_state_lock, flags);
346 target_stop_task(task, &flags); 334 target_stop_cmd(cmd, &flags);
347 335
348 if (!atomic_dec_and_test(&cmd->t_task_cdbs_ex_left)) {
349 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
350 pr_debug("LUN_RESET: Skipping task: %p, dev: %p for"
351 " t_task_cdbs_ex_left: %d\n", task, dev,
352 atomic_read(&cmd->t_task_cdbs_ex_left));
353 continue;
354 }
355 fe_count = atomic_read(&cmd->t_fe_count); 336 fe_count = atomic_read(&cmd->t_fe_count);
356 337
357 if (!(cmd->transport_state & CMD_T_ACTIVE)) { 338 if (!(cmd->transport_state & CMD_T_ACTIVE)) {
358 pr_debug("LUN_RESET: got CMD_T_ACTIVE for" 339 pr_debug("LUN_RESET: got CMD_T_ACTIVE for"
359 " task: %p, t_fe_count: %d dev: %p\n", task, 340 " cdb: %p, t_fe_count: %d dev: %p\n", cmd,
360 fe_count, dev); 341 fe_count, dev);
361 cmd->transport_state |= CMD_T_ABORTED; 342 cmd->transport_state |= CMD_T_ABORTED;
362 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 343 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
@@ -364,8 +345,8 @@ static void core_tmr_drain_task_list(
364 core_tmr_handle_tas_abort(tmr_nacl, cmd, tas, fe_count); 345 core_tmr_handle_tas_abort(tmr_nacl, cmd, tas, fe_count);
365 continue; 346 continue;
366 } 347 }
367 pr_debug("LUN_RESET: Got !CMD_T_ACTIVE for task: %p," 348 pr_debug("LUN_RESET: Got !CMD_T_ACTIVE for cdb: %p,"
368 " t_fe_count: %d dev: %p\n", task, fe_count, dev); 349 " t_fe_count: %d dev: %p\n", cmd, fe_count, dev);
369 cmd->transport_state |= CMD_T_ABORTED; 350 cmd->transport_state |= CMD_T_ABORTED;
370 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 351 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
371 352
@@ -384,13 +365,11 @@ static void core_tmr_drain_cmd_list(
384 struct se_queue_obj *qobj = &dev->dev_queue_obj; 365 struct se_queue_obj *qobj = &dev->dev_queue_obj;
385 struct se_cmd *cmd, *tcmd; 366 struct se_cmd *cmd, *tcmd;
386 unsigned long flags; 367 unsigned long flags;
368
387 /* 369 /*
388 * Release all commands remaining in the struct se_device cmd queue. 370 * Release all commands remaining in the per-device command queue.
389 * 371 *
390 * This follows the same logic as above for the struct se_device 372 * This follows the same logic as above for the state list.
391 * struct se_task state list, where commands are returned with
392 * TASK_ABORTED status, if there is an outstanding $FABRIC_MOD
393 * reference, otherwise the struct se_cmd is released.
394 */ 373 */
395 spin_lock_irqsave(&qobj->cmd_queue_lock, flags); 374 spin_lock_irqsave(&qobj->cmd_queue_lock, flags);
396 list_for_each_entry_safe(cmd, tcmd, &qobj->qobj_list, se_queue_node) { 375 list_for_each_entry_safe(cmd, tcmd, &qobj->qobj_list, se_queue_node) {
@@ -466,7 +445,7 @@ int core_tmr_lun_reset(
466 dev->transport->name, tas); 445 dev->transport->name, tas);
467 446
468 core_tmr_drain_tmr_list(dev, tmr, preempt_and_abort_list); 447 core_tmr_drain_tmr_list(dev, tmr, preempt_and_abort_list);
469 core_tmr_drain_task_list(dev, prout_cmd, tmr_nacl, tas, 448 core_tmr_drain_state_list(dev, prout_cmd, tmr_nacl, tas,
470 preempt_and_abort_list); 449 preempt_and_abort_list);
471 core_tmr_drain_cmd_list(dev, prout_cmd, tmr_nacl, tas, 450 core_tmr_drain_cmd_list(dev, prout_cmd, tmr_nacl, tas,
472 preempt_and_abort_list); 451 preempt_and_abort_list);
diff --git a/drivers/target/target_core_tpg.c b/drivers/target/target_core_tpg.c
index e320ec24aa1b..8bd58e284185 100644
--- a/drivers/target/target_core_tpg.c
+++ b/drivers/target/target_core_tpg.c
@@ -153,10 +153,7 @@ void core_tpg_add_node_to_devs(
153 * demo_mode_write_protect is ON, or READ_ONLY; 153 * demo_mode_write_protect is ON, or READ_ONLY;
154 */ 154 */
155 if (!tpg->se_tpg_tfo->tpg_check_demo_mode_write_protect(tpg)) { 155 if (!tpg->se_tpg_tfo->tpg_check_demo_mode_write_protect(tpg)) {
156 if (dev->dev_flags & DF_READ_ONLY) 156 lun_access = TRANSPORT_LUNFLAGS_READ_WRITE;
157 lun_access = TRANSPORT_LUNFLAGS_READ_ONLY;
158 else
159 lun_access = TRANSPORT_LUNFLAGS_READ_WRITE;
160 } else { 157 } else {
161 /* 158 /*
162 * Allow only optical drives to issue R/W in default RO 159 * Allow only optical drives to issue R/W in default RO
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index 443704f84fd5..b05fdc0c05d3 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -72,7 +72,6 @@ static int __transport_execute_tasks(struct se_device *dev, struct se_cmd *);
72static void transport_complete_task_attr(struct se_cmd *cmd); 72static void transport_complete_task_attr(struct se_cmd *cmd);
73static void transport_handle_queue_full(struct se_cmd *cmd, 73static void transport_handle_queue_full(struct se_cmd *cmd,
74 struct se_device *dev); 74 struct se_device *dev);
75static void transport_free_dev_tasks(struct se_cmd *cmd);
76static int transport_generic_get_mem(struct se_cmd *cmd); 75static int transport_generic_get_mem(struct se_cmd *cmd);
77static void transport_put_cmd(struct se_cmd *cmd); 76static void transport_put_cmd(struct se_cmd *cmd);
78static void transport_remove_cmd_from_queue(struct se_cmd *cmd); 77static void transport_remove_cmd_from_queue(struct se_cmd *cmd);
@@ -331,9 +330,9 @@ void target_get_session(struct se_session *se_sess)
331} 330}
332EXPORT_SYMBOL(target_get_session); 331EXPORT_SYMBOL(target_get_session);
333 332
334int target_put_session(struct se_session *se_sess) 333void target_put_session(struct se_session *se_sess)
335{ 334{
336 return kref_put(&se_sess->sess_kref, target_release_session); 335 kref_put(&se_sess->sess_kref, target_release_session);
337} 336}
338EXPORT_SYMBOL(target_put_session); 337EXPORT_SYMBOL(target_put_session);
339 338
@@ -444,31 +443,23 @@ EXPORT_SYMBOL(transport_deregister_session);
444/* 443/*
445 * Called with cmd->t_state_lock held. 444 * Called with cmd->t_state_lock held.
446 */ 445 */
447static void transport_all_task_dev_remove_state(struct se_cmd *cmd) 446static void target_remove_from_state_list(struct se_cmd *cmd)
448{ 447{
449 struct se_device *dev = cmd->se_dev; 448 struct se_device *dev = cmd->se_dev;
450 struct se_task *task;
451 unsigned long flags; 449 unsigned long flags;
452 450
453 if (!dev) 451 if (!dev)
454 return; 452 return;
455 453
456 list_for_each_entry(task, &cmd->t_task_list, t_list) { 454 if (cmd->transport_state & CMD_T_BUSY)
457 if (task->task_flags & TF_ACTIVE) 455 return;
458 continue;
459
460 spin_lock_irqsave(&dev->execute_task_lock, flags);
461 if (task->t_state_active) {
462 pr_debug("Removed ITT: 0x%08x dev: %p task[%p]\n",
463 cmd->se_tfo->get_task_tag(cmd), dev, task);
464 456
465 list_del(&task->t_state_list); 457 spin_lock_irqsave(&dev->execute_task_lock, flags);
466 atomic_dec(&cmd->t_task_cdbs_ex_left); 458 if (cmd->state_active) {
467 task->t_state_active = false; 459 list_del(&cmd->state_list);
468 } 460 cmd->state_active = false;
469 spin_unlock_irqrestore(&dev->execute_task_lock, flags);
470 } 461 }
471 462 spin_unlock_irqrestore(&dev->execute_task_lock, flags);
472} 463}
473 464
474/* transport_cmd_check_stop(): 465/* transport_cmd_check_stop():
@@ -497,7 +488,7 @@ static int transport_cmd_check_stop(
497 488
498 cmd->transport_state &= ~CMD_T_ACTIVE; 489 cmd->transport_state &= ~CMD_T_ACTIVE;
499 if (transport_off == 2) 490 if (transport_off == 2)
500 transport_all_task_dev_remove_state(cmd); 491 target_remove_from_state_list(cmd);
501 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 492 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
502 493
503 complete(&cmd->transport_lun_stop_comp); 494 complete(&cmd->transport_lun_stop_comp);
@@ -513,7 +504,7 @@ static int transport_cmd_check_stop(
513 cmd->se_tfo->get_task_tag(cmd)); 504 cmd->se_tfo->get_task_tag(cmd));
514 505
515 if (transport_off == 2) 506 if (transport_off == 2)
516 transport_all_task_dev_remove_state(cmd); 507 target_remove_from_state_list(cmd);
517 508
518 /* 509 /*
519 * Clear struct se_cmd->se_lun before the transport_off == 2 handoff 510 * Clear struct se_cmd->se_lun before the transport_off == 2 handoff
@@ -529,7 +520,7 @@ static int transport_cmd_check_stop(
529 if (transport_off) { 520 if (transport_off) {
530 cmd->transport_state &= ~CMD_T_ACTIVE; 521 cmd->transport_state &= ~CMD_T_ACTIVE;
531 if (transport_off == 2) { 522 if (transport_off == 2) {
532 transport_all_task_dev_remove_state(cmd); 523 target_remove_from_state_list(cmd);
533 /* 524 /*
534 * Clear struct se_cmd->se_lun before the transport_off == 2 525 * Clear struct se_cmd->se_lun before the transport_off == 2
535 * handoff to fabric module. 526 * handoff to fabric module.
@@ -577,7 +568,7 @@ static void transport_lun_remove_cmd(struct se_cmd *cmd)
577 spin_lock_irqsave(&cmd->t_state_lock, flags); 568 spin_lock_irqsave(&cmd->t_state_lock, flags);
578 if (cmd->transport_state & CMD_T_DEV_ACTIVE) { 569 if (cmd->transport_state & CMD_T_DEV_ACTIVE) {
579 cmd->transport_state &= ~CMD_T_DEV_ACTIVE; 570 cmd->transport_state &= ~CMD_T_DEV_ACTIVE;
580 transport_all_task_dev_remove_state(cmd); 571 target_remove_from_state_list(cmd);
581 } 572 }
582 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 573 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
583 574
@@ -669,29 +660,6 @@ static void transport_remove_cmd_from_queue(struct se_cmd *cmd)
669 spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags); 660 spin_unlock_irqrestore(&qobj->cmd_queue_lock, flags);
670} 661}
671 662
672/*
673 * Completion function used by TCM subsystem plugins (such as FILEIO)
674 * for queueing up response from struct se_subsystem_api->do_task()
675 */
676void transport_complete_sync_cache(struct se_cmd *cmd, int good)
677{
678 struct se_task *task = list_entry(cmd->t_task_list.next,
679 struct se_task, t_list);
680
681 if (good) {
682 cmd->scsi_status = SAM_STAT_GOOD;
683 task->task_scsi_status = GOOD;
684 } else {
685 task->task_scsi_status = SAM_STAT_CHECK_CONDITION;
686 task->task_se_cmd->scsi_sense_reason =
687 TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
688
689 }
690
691 transport_complete_task(task, good);
692}
693EXPORT_SYMBOL(transport_complete_sync_cache);
694
695static void target_complete_failure_work(struct work_struct *work) 663static void target_complete_failure_work(struct work_struct *work)
696{ 664{
697 struct se_cmd *cmd = container_of(work, struct se_cmd, work); 665 struct se_cmd *cmd = container_of(work, struct se_cmd, work);
@@ -699,40 +667,32 @@ static void target_complete_failure_work(struct work_struct *work)
699 transport_generic_request_failure(cmd); 667 transport_generic_request_failure(cmd);
700} 668}
701 669
702/* transport_complete_task(): 670void target_complete_cmd(struct se_cmd *cmd, u8 scsi_status)
703 *
704 * Called from interrupt and non interrupt context depending
705 * on the transport plugin.
706 */
707void transport_complete_task(struct se_task *task, int success)
708{ 671{
709 struct se_cmd *cmd = task->task_se_cmd;
710 struct se_device *dev = cmd->se_dev; 672 struct se_device *dev = cmd->se_dev;
673 int success = scsi_status == GOOD;
711 unsigned long flags; 674 unsigned long flags;
712 675
676 cmd->scsi_status = scsi_status;
677
678
713 spin_lock_irqsave(&cmd->t_state_lock, flags); 679 spin_lock_irqsave(&cmd->t_state_lock, flags);
714 task->task_flags &= ~TF_ACTIVE; 680 cmd->transport_state &= ~CMD_T_BUSY;
715 681
716 /*
717 * See if any sense data exists, if so set the TASK_SENSE flag.
718 * Also check for any other post completion work that needs to be
719 * done by the plugins.
720 */
721 if (dev && dev->transport->transport_complete) { 682 if (dev && dev->transport->transport_complete) {
722 if (dev->transport->transport_complete(task) != 0) { 683 if (dev->transport->transport_complete(cmd,
684 cmd->t_data_sg) != 0) {
723 cmd->se_cmd_flags |= SCF_TRANSPORT_TASK_SENSE; 685 cmd->se_cmd_flags |= SCF_TRANSPORT_TASK_SENSE;
724 task->task_flags |= TF_HAS_SENSE;
725 success = 1; 686 success = 1;
726 } 687 }
727 } 688 }
728 689
729 /* 690 /*
730 * See if we are waiting for outstanding struct se_task 691 * See if we are waiting to complete for an exception condition.
731 * to complete for an exception condition
732 */ 692 */
733 if (task->task_flags & TF_REQUEST_STOP) { 693 if (cmd->transport_state & CMD_T_REQUEST_STOP) {
734 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 694 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
735 complete(&task->task_stop_comp); 695 complete(&cmd->task_stop_comp);
736 return; 696 return;
737 } 697 }
738 698
@@ -740,15 +700,6 @@ void transport_complete_task(struct se_task *task, int success)
740 cmd->transport_state |= CMD_T_FAILED; 700 cmd->transport_state |= CMD_T_FAILED;
741 701
742 /* 702 /*
743 * Decrement the outstanding t_task_cdbs_left count. The last
744 * struct se_task from struct se_cmd will complete itself into the
745 * device queue depending upon int success.
746 */
747 if (!atomic_dec_and_test(&cmd->t_task_cdbs_left)) {
748 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
749 return;
750 }
751 /*
752 * Check for case where an explict ABORT_TASK has been received 703 * Check for case where an explict ABORT_TASK has been received
753 * and transport_wait_for_tasks() will be waiting for completion.. 704 * and transport_wait_for_tasks() will be waiting for completion..
754 */ 705 */
@@ -770,157 +721,77 @@ void transport_complete_task(struct se_task *task, int success)
770 721
771 queue_work(target_completion_wq, &cmd->work); 722 queue_work(target_completion_wq, &cmd->work);
772} 723}
773EXPORT_SYMBOL(transport_complete_task); 724EXPORT_SYMBOL(target_complete_cmd);
774
775/*
776 * Called by transport_add_tasks_from_cmd() once a struct se_cmd's
777 * struct se_task list are ready to be added to the active execution list
778 * struct se_device
779 725
780 * Called with se_dev_t->execute_task_lock called. 726static void target_add_to_state_list(struct se_cmd *cmd)
781 */
782static inline int transport_add_task_check_sam_attr(
783 struct se_task *task,
784 struct se_task *task_prev,
785 struct se_device *dev)
786{ 727{
787 /* 728 struct se_device *dev = cmd->se_dev;
788 * No SAM Task attribute emulation enabled, add to tail of 729 unsigned long flags;
789 * execution queue 730
790 */ 731 spin_lock_irqsave(&dev->execute_task_lock, flags);
791 if (dev->dev_task_attr_type != SAM_TASK_ATTR_EMULATED) { 732 if (!cmd->state_active) {
792 list_add_tail(&task->t_execute_list, &dev->execute_task_list); 733 list_add_tail(&cmd->state_list, &dev->state_list);
793 return 0; 734 cmd->state_active = true;
794 }
795 /*
796 * HEAD_OF_QUEUE attribute for received CDB, which means
797 * the first task that is associated with a struct se_cmd goes to
798 * head of the struct se_device->execute_task_list, and task_prev
799 * after that for each subsequent task
800 */
801 if (task->task_se_cmd->sam_task_attr == MSG_HEAD_TAG) {
802 list_add(&task->t_execute_list,
803 (task_prev != NULL) ?
804 &task_prev->t_execute_list :
805 &dev->execute_task_list);
806
807 pr_debug("Set HEAD_OF_QUEUE for task CDB: 0x%02x"
808 " in execution queue\n",
809 task->task_se_cmd->t_task_cdb[0]);
810 return 1;
811 } 735 }
812 /* 736 spin_unlock_irqrestore(&dev->execute_task_lock, flags);
813 * For ORDERED, SIMPLE or UNTAGGED attribute tasks once they have been
814 * transitioned from Dermant -> Active state, and are added to the end
815 * of the struct se_device->execute_task_list
816 */
817 list_add_tail(&task->t_execute_list, &dev->execute_task_list);
818 return 0;
819} 737}
820 738
821/* __transport_add_task_to_execute_queue(): 739static void __target_add_to_execute_list(struct se_cmd *cmd)
822 *
823 * Called with se_dev_t->execute_task_lock called.
824 */
825static void __transport_add_task_to_execute_queue(
826 struct se_task *task,
827 struct se_task *task_prev,
828 struct se_device *dev)
829{ 740{
830 int head_of_queue; 741 struct se_device *dev = cmd->se_dev;
831 742 bool head_of_queue = false;
832 head_of_queue = transport_add_task_check_sam_attr(task, task_prev, dev);
833 atomic_inc(&dev->execute_tasks);
834 743
835 if (task->t_state_active) 744 if (!list_empty(&cmd->execute_list))
836 return; 745 return;
837 /*
838 * Determine if this task needs to go to HEAD_OF_QUEUE for the
839 * state list as well. Running with SAM Task Attribute emulation
840 * will always return head_of_queue == 0 here
841 */
842 if (head_of_queue)
843 list_add(&task->t_state_list, (task_prev) ?
844 &task_prev->t_state_list :
845 &dev->state_task_list);
846 else
847 list_add_tail(&task->t_state_list, &dev->state_task_list);
848 746
849 task->t_state_active = true; 747 if (dev->dev_task_attr_type == SAM_TASK_ATTR_EMULATED &&
748 cmd->sam_task_attr == MSG_HEAD_TAG)
749 head_of_queue = true;
850 750
851 pr_debug("Added ITT: 0x%08x task[%p] to dev: %p\n", 751 if (head_of_queue)
852 task->task_se_cmd->se_tfo->get_task_tag(task->task_se_cmd), 752 list_add(&cmd->execute_list, &dev->execute_list);
853 task, dev); 753 else
854} 754 list_add_tail(&cmd->execute_list, &dev->execute_list);
855 755
856static void transport_add_tasks_to_state_queue(struct se_cmd *cmd) 756 atomic_inc(&dev->execute_tasks);
857{
858 struct se_device *dev = cmd->se_dev;
859 struct se_task *task;
860 unsigned long flags;
861 757
862 spin_lock_irqsave(&cmd->t_state_lock, flags); 758 if (cmd->state_active)
863 list_for_each_entry(task, &cmd->t_task_list, t_list) { 759 return;
864 spin_lock(&dev->execute_task_lock);
865 if (!task->t_state_active) {
866 list_add_tail(&task->t_state_list,
867 &dev->state_task_list);
868 task->t_state_active = true;
869
870 pr_debug("Added ITT: 0x%08x task[%p] to dev: %p\n",
871 task->task_se_cmd->se_tfo->get_task_tag(
872 task->task_se_cmd), task, dev);
873 }
874 spin_unlock(&dev->execute_task_lock);
875 }
876 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
877}
878 760
879static void __transport_add_tasks_from_cmd(struct se_cmd *cmd) 761 if (head_of_queue)
880{ 762 list_add(&cmd->state_list, &dev->state_list);
881 struct se_device *dev = cmd->se_dev; 763 else
882 struct se_task *task, *task_prev = NULL; 764 list_add_tail(&cmd->state_list, &dev->state_list);
883 765
884 list_for_each_entry(task, &cmd->t_task_list, t_list) { 766 cmd->state_active = true;
885 if (!list_empty(&task->t_execute_list))
886 continue;
887 /*
888 * __transport_add_task_to_execute_queue() handles the
889 * SAM Task Attribute emulation if enabled
890 */
891 __transport_add_task_to_execute_queue(task, task_prev, dev);
892 task_prev = task;
893 }
894} 767}
895 768
896static void transport_add_tasks_from_cmd(struct se_cmd *cmd) 769static void target_add_to_execute_list(struct se_cmd *cmd)
897{ 770{
898 unsigned long flags; 771 unsigned long flags;
899 struct se_device *dev = cmd->se_dev; 772 struct se_device *dev = cmd->se_dev;
900 773
901 spin_lock_irqsave(&dev->execute_task_lock, flags); 774 spin_lock_irqsave(&dev->execute_task_lock, flags);
902 __transport_add_tasks_from_cmd(cmd); 775 __target_add_to_execute_list(cmd);
903 spin_unlock_irqrestore(&dev->execute_task_lock, flags); 776 spin_unlock_irqrestore(&dev->execute_task_lock, flags);
904} 777}
905 778
906void __transport_remove_task_from_execute_queue(struct se_task *task, 779void __target_remove_from_execute_list(struct se_cmd *cmd)
907 struct se_device *dev)
908{ 780{
909 list_del_init(&task->t_execute_list); 781 list_del_init(&cmd->execute_list);
910 atomic_dec(&dev->execute_tasks); 782 atomic_dec(&cmd->se_dev->execute_tasks);
911} 783}
912 784
913static void transport_remove_task_from_execute_queue( 785static void target_remove_from_execute_list(struct se_cmd *cmd)
914 struct se_task *task,
915 struct se_device *dev)
916{ 786{
787 struct se_device *dev = cmd->se_dev;
917 unsigned long flags; 788 unsigned long flags;
918 789
919 if (WARN_ON(list_empty(&task->t_execute_list))) 790 if (WARN_ON(list_empty(&cmd->execute_list)))
920 return; 791 return;
921 792
922 spin_lock_irqsave(&dev->execute_task_lock, flags); 793 spin_lock_irqsave(&dev->execute_task_lock, flags);
923 __transport_remove_task_from_execute_queue(task, dev); 794 __target_remove_from_execute_list(cmd);
924 spin_unlock_irqrestore(&dev->execute_task_lock, flags); 795 spin_unlock_irqrestore(&dev->execute_task_lock, flags);
925} 796}
926 797
@@ -999,8 +870,9 @@ void transport_dump_dev_state(
999 870
1000 *bl += sprintf(b + *bl, " Execute/Max Queue Depth: %d/%d", 871 *bl += sprintf(b + *bl, " Execute/Max Queue Depth: %d/%d",
1001 atomic_read(&dev->execute_tasks), dev->queue_depth); 872 atomic_read(&dev->execute_tasks), dev->queue_depth);
1002 *bl += sprintf(b + *bl, " SectorSize: %u MaxSectors: %u\n", 873 *bl += sprintf(b + *bl, " SectorSize: %u HwMaxSectors: %u\n",
1003 dev->se_sub_dev->se_dev_attrib.block_size, dev->se_sub_dev->se_dev_attrib.max_sectors); 874 dev->se_sub_dev->se_dev_attrib.block_size,
875 dev->se_sub_dev->se_dev_attrib.hw_max_sectors);
1004 *bl += sprintf(b + *bl, " "); 876 *bl += sprintf(b + *bl, " ");
1005} 877}
1006 878
@@ -1344,9 +1216,9 @@ struct se_device *transport_add_device_to_core_hba(
1344 INIT_LIST_HEAD(&dev->dev_list); 1216 INIT_LIST_HEAD(&dev->dev_list);
1345 INIT_LIST_HEAD(&dev->dev_sep_list); 1217 INIT_LIST_HEAD(&dev->dev_sep_list);
1346 INIT_LIST_HEAD(&dev->dev_tmr_list); 1218 INIT_LIST_HEAD(&dev->dev_tmr_list);
1347 INIT_LIST_HEAD(&dev->execute_task_list); 1219 INIT_LIST_HEAD(&dev->execute_list);
1348 INIT_LIST_HEAD(&dev->delayed_cmd_list); 1220 INIT_LIST_HEAD(&dev->delayed_cmd_list);
1349 INIT_LIST_HEAD(&dev->state_task_list); 1221 INIT_LIST_HEAD(&dev->state_list);
1350 INIT_LIST_HEAD(&dev->qf_cmd_list); 1222 INIT_LIST_HEAD(&dev->qf_cmd_list);
1351 spin_lock_init(&dev->execute_task_lock); 1223 spin_lock_init(&dev->execute_task_lock);
1352 spin_lock_init(&dev->delayed_cmd_lock); 1224 spin_lock_init(&dev->delayed_cmd_lock);
@@ -1457,6 +1329,7 @@ static inline void transport_generic_prepare_cdb(
1457 case VERIFY_16: /* SBC - VRProtect */ 1329 case VERIFY_16: /* SBC - VRProtect */
1458 case WRITE_VERIFY: /* SBC - VRProtect */ 1330 case WRITE_VERIFY: /* SBC - VRProtect */
1459 case WRITE_VERIFY_12: /* SBC - VRProtect */ 1331 case WRITE_VERIFY_12: /* SBC - VRProtect */
1332 case MAINTENANCE_IN: /* SPC - Parameter Data Format for SA RTPG */
1460 break; 1333 break;
1461 default: 1334 default:
1462 cdb[1] &= 0x1f; /* clear logical unit number */ 1335 cdb[1] &= 0x1f; /* clear logical unit number */
@@ -1464,29 +1337,6 @@ static inline void transport_generic_prepare_cdb(
1464 } 1337 }
1465} 1338}
1466 1339
1467static struct se_task *
1468transport_generic_get_task(struct se_cmd *cmd,
1469 enum dma_data_direction data_direction)
1470{
1471 struct se_task *task;
1472 struct se_device *dev = cmd->se_dev;
1473
1474 task = dev->transport->alloc_task(cmd->t_task_cdb);
1475 if (!task) {
1476 pr_err("Unable to allocate struct se_task\n");
1477 return NULL;
1478 }
1479
1480 INIT_LIST_HEAD(&task->t_list);
1481 INIT_LIST_HEAD(&task->t_execute_list);
1482 INIT_LIST_HEAD(&task->t_state_list);
1483 init_completion(&task->task_stop_comp);
1484 task->task_se_cmd = cmd;
1485 task->task_data_direction = data_direction;
1486
1487 return task;
1488}
1489
1490static int transport_generic_cmd_sequencer(struct se_cmd *, unsigned char *); 1340static int transport_generic_cmd_sequencer(struct se_cmd *, unsigned char *);
1491 1341
1492/* 1342/*
@@ -1507,11 +1357,13 @@ void transport_init_se_cmd(
1507 INIT_LIST_HEAD(&cmd->se_qf_node); 1357 INIT_LIST_HEAD(&cmd->se_qf_node);
1508 INIT_LIST_HEAD(&cmd->se_queue_node); 1358 INIT_LIST_HEAD(&cmd->se_queue_node);
1509 INIT_LIST_HEAD(&cmd->se_cmd_list); 1359 INIT_LIST_HEAD(&cmd->se_cmd_list);
1510 INIT_LIST_HEAD(&cmd->t_task_list); 1360 INIT_LIST_HEAD(&cmd->execute_list);
1361 INIT_LIST_HEAD(&cmd->state_list);
1511 init_completion(&cmd->transport_lun_fe_stop_comp); 1362 init_completion(&cmd->transport_lun_fe_stop_comp);
1512 init_completion(&cmd->transport_lun_stop_comp); 1363 init_completion(&cmd->transport_lun_stop_comp);
1513 init_completion(&cmd->t_transport_stop_comp); 1364 init_completion(&cmd->t_transport_stop_comp);
1514 init_completion(&cmd->cmd_wait_comp); 1365 init_completion(&cmd->cmd_wait_comp);
1366 init_completion(&cmd->task_stop_comp);
1515 spin_lock_init(&cmd->t_state_lock); 1367 spin_lock_init(&cmd->t_state_lock);
1516 cmd->transport_state = CMD_T_DEV_ACTIVE; 1368 cmd->transport_state = CMD_T_DEV_ACTIVE;
1517 1369
@@ -1521,6 +1373,8 @@ void transport_init_se_cmd(
1521 cmd->data_direction = data_direction; 1373 cmd->data_direction = data_direction;
1522 cmd->sam_task_attr = task_attr; 1374 cmd->sam_task_attr = task_attr;
1523 cmd->sense_buffer = sense_buffer; 1375 cmd->sense_buffer = sense_buffer;
1376
1377 cmd->state_active = false;
1524} 1378}
1525EXPORT_SYMBOL(transport_init_se_cmd); 1379EXPORT_SYMBOL(transport_init_se_cmd);
1526 1380
@@ -1550,11 +1404,11 @@ static int transport_check_alloc_task_attr(struct se_cmd *cmd)
1550 return 0; 1404 return 0;
1551} 1405}
1552 1406
1553/* transport_generic_allocate_tasks(): 1407/* target_setup_cmd_from_cdb():
1554 * 1408 *
1555 * Called from fabric RX Thread. 1409 * Called from fabric RX Thread.
1556 */ 1410 */
1557int transport_generic_allocate_tasks( 1411int target_setup_cmd_from_cdb(
1558 struct se_cmd *cmd, 1412 struct se_cmd *cmd,
1559 unsigned char *cdb) 1413 unsigned char *cdb)
1560{ 1414{
@@ -1620,7 +1474,7 @@ int transport_generic_allocate_tasks(
1620 spin_unlock(&cmd->se_lun->lun_sep_lock); 1474 spin_unlock(&cmd->se_lun->lun_sep_lock);
1621 return 0; 1475 return 0;
1622} 1476}
1623EXPORT_SYMBOL(transport_generic_allocate_tasks); 1477EXPORT_SYMBOL(target_setup_cmd_from_cdb);
1624 1478
1625/* 1479/*
1626 * Used by fabric module frontends to queue tasks directly. 1480 * Used by fabric module frontends to queue tasks directly.
@@ -1701,6 +1555,8 @@ void target_submit_cmd(struct se_cmd *se_cmd, struct se_session *se_sess,
1701 */ 1555 */
1702 transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess, 1556 transport_init_se_cmd(se_cmd, se_tpg->se_tpg_tfo, se_sess,
1703 data_length, data_dir, task_attr, sense); 1557 data_length, data_dir, task_attr, sense);
1558 if (flags & TARGET_SCF_UNKNOWN_SIZE)
1559 se_cmd->unknown_data_length = 1;
1704 /* 1560 /*
1705 * Obtain struct se_cmd->cmd_kref reference and add new cmd to 1561 * Obtain struct se_cmd->cmd_kref reference and add new cmd to
1706 * se_sess->sess_cmd_list. A second kref_get here is necessary 1562 * se_sess->sess_cmd_list. A second kref_get here is necessary
@@ -1726,11 +1582,18 @@ void target_submit_cmd(struct se_cmd *se_cmd, struct se_session *se_sess,
1726 * Sanitize CDBs via transport_generic_cmd_sequencer() and 1582 * Sanitize CDBs via transport_generic_cmd_sequencer() and
1727 * allocate the necessary tasks to complete the received CDB+data 1583 * allocate the necessary tasks to complete the received CDB+data
1728 */ 1584 */
1729 rc = transport_generic_allocate_tasks(se_cmd, cdb); 1585 rc = target_setup_cmd_from_cdb(se_cmd, cdb);
1730 if (rc != 0) { 1586 if (rc != 0) {
1731 transport_generic_request_failure(se_cmd); 1587 transport_generic_request_failure(se_cmd);
1732 return; 1588 return;
1733 } 1589 }
1590
1591 /*
1592 * Check if we need to delay processing because of ALUA
1593 * Active/NonOptimized primary access state..
1594 */
1595 core_alua_check_nonop_delay(se_cmd);
1596
1734 /* 1597 /*
1735 * Dispatch se_cmd descriptor to se_lun->lun_se_dev backend 1598 * Dispatch se_cmd descriptor to se_lun->lun_se_dev backend
1736 * for immediate execution of READs, otherwise wait for 1599 * for immediate execution of READs, otherwise wait for
@@ -1872,72 +1735,30 @@ int transport_generic_handle_tmr(
1872EXPORT_SYMBOL(transport_generic_handle_tmr); 1735EXPORT_SYMBOL(transport_generic_handle_tmr);
1873 1736
1874/* 1737/*
1875 * If the task is active, request it to be stopped and sleep until it 1738 * If the cmd is active, request it to be stopped and sleep until it
1876 * has completed. 1739 * has completed.
1877 */ 1740 */
1878bool target_stop_task(struct se_task *task, unsigned long *flags) 1741bool target_stop_cmd(struct se_cmd *cmd, unsigned long *flags)
1879{ 1742{
1880 struct se_cmd *cmd = task->task_se_cmd;
1881 bool was_active = false; 1743 bool was_active = false;
1882 1744
1883 if (task->task_flags & TF_ACTIVE) { 1745 if (cmd->transport_state & CMD_T_BUSY) {
1884 task->task_flags |= TF_REQUEST_STOP; 1746 cmd->transport_state |= CMD_T_REQUEST_STOP;
1885 spin_unlock_irqrestore(&cmd->t_state_lock, *flags); 1747 spin_unlock_irqrestore(&cmd->t_state_lock, *flags);
1886 1748
1887 pr_debug("Task %p waiting to complete\n", task); 1749 pr_debug("cmd %p waiting to complete\n", cmd);
1888 wait_for_completion(&task->task_stop_comp); 1750 wait_for_completion(&cmd->task_stop_comp);
1889 pr_debug("Task %p stopped successfully\n", task); 1751 pr_debug("cmd %p stopped successfully\n", cmd);
1890 1752
1891 spin_lock_irqsave(&cmd->t_state_lock, *flags); 1753 spin_lock_irqsave(&cmd->t_state_lock, *flags);
1892 atomic_dec(&cmd->t_task_cdbs_left); 1754 cmd->transport_state &= ~CMD_T_REQUEST_STOP;
1893 task->task_flags &= ~(TF_ACTIVE | TF_REQUEST_STOP); 1755 cmd->transport_state &= ~CMD_T_BUSY;
1894 was_active = true; 1756 was_active = true;
1895 } 1757 }
1896 1758
1897 return was_active; 1759 return was_active;
1898} 1760}
1899 1761
1900static int transport_stop_tasks_for_cmd(struct se_cmd *cmd)
1901{
1902 struct se_task *task, *task_tmp;
1903 unsigned long flags;
1904 int ret = 0;
1905
1906 pr_debug("ITT[0x%08x] - Stopping tasks\n",
1907 cmd->se_tfo->get_task_tag(cmd));
1908
1909 /*
1910 * No tasks remain in the execution queue
1911 */
1912 spin_lock_irqsave(&cmd->t_state_lock, flags);
1913 list_for_each_entry_safe(task, task_tmp,
1914 &cmd->t_task_list, t_list) {
1915 pr_debug("Processing task %p\n", task);
1916 /*
1917 * If the struct se_task has not been sent and is not active,
1918 * remove the struct se_task from the execution queue.
1919 */
1920 if (!(task->task_flags & (TF_ACTIVE | TF_SENT))) {
1921 spin_unlock_irqrestore(&cmd->t_state_lock,
1922 flags);
1923 transport_remove_task_from_execute_queue(task,
1924 cmd->se_dev);
1925
1926 pr_debug("Task %p removed from execute queue\n", task);
1927 spin_lock_irqsave(&cmd->t_state_lock, flags);
1928 continue;
1929 }
1930
1931 if (!target_stop_task(task, &flags)) {
1932 pr_debug("Task %p - did nothing\n", task);
1933 ret++;
1934 }
1935 }
1936 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
1937
1938 return ret;
1939}
1940
1941/* 1762/*
1942 * Handle SAM-esque emulation for generic transport request failures. 1763 * Handle SAM-esque emulation for generic transport request failures.
1943 */ 1764 */
@@ -1951,13 +1772,7 @@ void transport_generic_request_failure(struct se_cmd *cmd)
1951 pr_debug("-----[ i_state: %d t_state: %d scsi_sense_reason: %d\n", 1772 pr_debug("-----[ i_state: %d t_state: %d scsi_sense_reason: %d\n",
1952 cmd->se_tfo->get_cmd_state(cmd), 1773 cmd->se_tfo->get_cmd_state(cmd),
1953 cmd->t_state, cmd->scsi_sense_reason); 1774 cmd->t_state, cmd->scsi_sense_reason);
1954 pr_debug("-----[ t_tasks: %d t_task_cdbs_left: %d" 1775 pr_debug("-----[ CMD_T_ACTIVE: %d CMD_T_STOP: %d CMD_T_SENT: %d\n",
1955 " t_task_cdbs_sent: %d t_task_cdbs_ex_left: %d --"
1956 " CMD_T_ACTIVE: %d CMD_T_STOP: %d CMD_T_SENT: %d\n",
1957 cmd->t_task_list_num,
1958 atomic_read(&cmd->t_task_cdbs_left),
1959 atomic_read(&cmd->t_task_cdbs_sent),
1960 atomic_read(&cmd->t_task_cdbs_ex_left),
1961 (cmd->transport_state & CMD_T_ACTIVE) != 0, 1776 (cmd->transport_state & CMD_T_ACTIVE) != 0,
1962 (cmd->transport_state & CMD_T_STOP) != 0, 1777 (cmd->transport_state & CMD_T_STOP) != 0,
1963 (cmd->transport_state & CMD_T_SENT) != 0); 1778 (cmd->transport_state & CMD_T_SENT) != 0);
@@ -2156,7 +1971,7 @@ static inline int transport_execute_task_attr(struct se_cmd *cmd)
2156 * Called from fabric module context in transport_generic_new_cmd() and 1971 * Called from fabric module context in transport_generic_new_cmd() and
2157 * transport_generic_process_write() 1972 * transport_generic_process_write()
2158 */ 1973 */
2159static int transport_execute_tasks(struct se_cmd *cmd) 1974static void transport_execute_tasks(struct se_cmd *cmd)
2160{ 1975{
2161 int add_tasks; 1976 int add_tasks;
2162 struct se_device *se_dev = cmd->se_dev; 1977 struct se_device *se_dev = cmd->se_dev;
@@ -2170,71 +1985,52 @@ static int transport_execute_tasks(struct se_cmd *cmd)
2170 * attribute for the tasks of the received struct se_cmd CDB 1985 * attribute for the tasks of the received struct se_cmd CDB
2171 */ 1986 */
2172 add_tasks = transport_execute_task_attr(cmd); 1987 add_tasks = transport_execute_task_attr(cmd);
2173 if (!add_tasks) 1988 if (add_tasks) {
2174 goto execute_tasks; 1989 __transport_execute_tasks(se_dev, cmd);
2175 /* 1990 return;
2176 * __transport_execute_tasks() -> __transport_add_tasks_from_cmd() 1991 }
2177 * adds associated se_tasks while holding dev->execute_task_lock
2178 * before I/O dispath to avoid a double spinlock access.
2179 */
2180 __transport_execute_tasks(se_dev, cmd);
2181 return 0;
2182 } 1992 }
2183
2184execute_tasks:
2185 __transport_execute_tasks(se_dev, NULL); 1993 __transport_execute_tasks(se_dev, NULL);
2186 return 0;
2187} 1994}
2188 1995
2189/*
2190 * Called to check struct se_device tcq depth window, and once open pull struct se_task
2191 * from struct se_device->execute_task_list and
2192 *
2193 * Called from transport_processing_thread()
2194 */
2195static int __transport_execute_tasks(struct se_device *dev, struct se_cmd *new_cmd) 1996static int __transport_execute_tasks(struct se_device *dev, struct se_cmd *new_cmd)
2196{ 1997{
2197 int error; 1998 int error;
2198 struct se_cmd *cmd = NULL; 1999 struct se_cmd *cmd = NULL;
2199 struct se_task *task = NULL;
2200 unsigned long flags; 2000 unsigned long flags;
2201 2001
2202check_depth: 2002check_depth:
2203 spin_lock_irq(&dev->execute_task_lock); 2003 spin_lock_irq(&dev->execute_task_lock);
2204 if (new_cmd != NULL) 2004 if (new_cmd != NULL)
2205 __transport_add_tasks_from_cmd(new_cmd); 2005 __target_add_to_execute_list(new_cmd);
2206 2006
2207 if (list_empty(&dev->execute_task_list)) { 2007 if (list_empty(&dev->execute_list)) {
2208 spin_unlock_irq(&dev->execute_task_lock); 2008 spin_unlock_irq(&dev->execute_task_lock);
2209 return 0; 2009 return 0;
2210 } 2010 }
2211 task = list_first_entry(&dev->execute_task_list, 2011 cmd = list_first_entry(&dev->execute_list, struct se_cmd, execute_list);
2212 struct se_task, t_execute_list); 2012 __target_remove_from_execute_list(cmd);
2213 __transport_remove_task_from_execute_queue(task, dev);
2214 spin_unlock_irq(&dev->execute_task_lock); 2013 spin_unlock_irq(&dev->execute_task_lock);
2215 2014
2216 cmd = task->task_se_cmd;
2217 spin_lock_irqsave(&cmd->t_state_lock, flags); 2015 spin_lock_irqsave(&cmd->t_state_lock, flags);
2218 task->task_flags |= (TF_ACTIVE | TF_SENT); 2016 cmd->transport_state |= CMD_T_BUSY;
2219 atomic_inc(&cmd->t_task_cdbs_sent); 2017 cmd->transport_state |= CMD_T_SENT;
2220
2221 if (atomic_read(&cmd->t_task_cdbs_sent) ==
2222 cmd->t_task_list_num)
2223 cmd->transport_state |= CMD_T_SENT;
2224 2018
2225 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2019 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2226 2020
2227 if (cmd->execute_task) 2021 if (cmd->execute_cmd)
2228 error = cmd->execute_task(task); 2022 error = cmd->execute_cmd(cmd);
2229 else 2023 else {
2230 error = dev->transport->do_task(task); 2024 error = dev->transport->execute_cmd(cmd, cmd->t_data_sg,
2025 cmd->t_data_nents, cmd->data_direction);
2026 }
2027
2231 if (error != 0) { 2028 if (error != 0) {
2232 spin_lock_irqsave(&cmd->t_state_lock, flags); 2029 spin_lock_irqsave(&cmd->t_state_lock, flags);
2233 task->task_flags &= ~TF_ACTIVE; 2030 cmd->transport_state &= ~CMD_T_BUSY;
2234 cmd->transport_state &= ~CMD_T_SENT; 2031 cmd->transport_state &= ~CMD_T_SENT;
2235 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2032 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2236 2033
2237 transport_stop_tasks_for_cmd(cmd);
2238 transport_generic_request_failure(cmd); 2034 transport_generic_request_failure(cmd);
2239 } 2035 }
2240 2036
@@ -2392,12 +2188,12 @@ static inline u32 transport_get_size(
2392 } else /* bytes */ 2188 } else /* bytes */
2393 return sectors; 2189 return sectors;
2394 } 2190 }
2395#if 0 2191
2396 pr_debug("Returning block_size: %u, sectors: %u == %u for" 2192 pr_debug("Returning block_size: %u, sectors: %u == %u for"
2397 " %s object\n", dev->se_sub_dev->se_dev_attrib.block_size, sectors, 2193 " %s object\n", dev->se_sub_dev->se_dev_attrib.block_size,
2398 dev->se_sub_dev->se_dev_attrib.block_size * sectors, 2194 sectors, dev->se_sub_dev->se_dev_attrib.block_size * sectors,
2399 dev->transport->name); 2195 dev->transport->name);
2400#endif 2196
2401 return dev->se_sub_dev->se_dev_attrib.block_size * sectors; 2197 return dev->se_sub_dev->se_dev_attrib.block_size * sectors;
2402} 2198}
2403 2199
@@ -2462,7 +2258,6 @@ static int transport_get_sense_data(struct se_cmd *cmd)
2462{ 2258{
2463 unsigned char *buffer = cmd->sense_buffer, *sense_buffer = NULL; 2259 unsigned char *buffer = cmd->sense_buffer, *sense_buffer = NULL;
2464 struct se_device *dev = cmd->se_dev; 2260 struct se_device *dev = cmd->se_dev;
2465 struct se_task *task = NULL, *task_tmp;
2466 unsigned long flags; 2261 unsigned long flags;
2467 u32 offset = 0; 2262 u32 offset = 0;
2468 2263
@@ -2477,44 +2272,37 @@ static int transport_get_sense_data(struct se_cmd *cmd)
2477 return 0; 2272 return 0;
2478 } 2273 }
2479 2274
2480 list_for_each_entry_safe(task, task_tmp, 2275 if (!(cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE))
2481 &cmd->t_task_list, t_list) { 2276 goto out;
2482 if (!(task->task_flags & TF_HAS_SENSE))
2483 continue;
2484
2485 if (!dev->transport->get_sense_buffer) {
2486 pr_err("dev->transport->get_sense_buffer"
2487 " is NULL\n");
2488 continue;
2489 }
2490
2491 sense_buffer = dev->transport->get_sense_buffer(task);
2492 if (!sense_buffer) {
2493 pr_err("ITT[0x%08x]_TASK[%p]: Unable to locate"
2494 " sense buffer for task with sense\n",
2495 cmd->se_tfo->get_task_tag(cmd), task);
2496 continue;
2497 }
2498 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2499 2277
2500 offset = cmd->se_tfo->set_fabric_sense_len(cmd, 2278 if (!dev->transport->get_sense_buffer) {
2501 TRANSPORT_SENSE_BUFFER); 2279 pr_err("dev->transport->get_sense_buffer is NULL\n");
2280 goto out;
2281 }
2502 2282
2503 memcpy(&buffer[offset], sense_buffer, 2283 sense_buffer = dev->transport->get_sense_buffer(cmd);
2504 TRANSPORT_SENSE_BUFFER); 2284 if (!sense_buffer) {
2505 cmd->scsi_status = task->task_scsi_status; 2285 pr_err("ITT 0x%08x cmd %p: Unable to locate"
2506 /* Automatically padded */ 2286 " sense buffer for task with sense\n",
2507 cmd->scsi_sense_length = 2287 cmd->se_tfo->get_task_tag(cmd), cmd);
2508 (TRANSPORT_SENSE_BUFFER + offset); 2288 goto out;
2509
2510 pr_debug("HBA_[%u]_PLUG[%s]: Set SAM STATUS: 0x%02x"
2511 " and sense\n",
2512 dev->se_hba->hba_id, dev->transport->name,
2513 cmd->scsi_status);
2514 return 0;
2515 } 2289 }
2290
2516 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2291 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2517 2292
2293 offset = cmd->se_tfo->set_fabric_sense_len(cmd, TRANSPORT_SENSE_BUFFER);
2294
2295 memcpy(&buffer[offset], sense_buffer, TRANSPORT_SENSE_BUFFER);
2296
2297 /* Automatically padded */
2298 cmd->scsi_sense_length = TRANSPORT_SENSE_BUFFER + offset;
2299
2300 pr_debug("HBA_[%u]_PLUG[%s]: Set SAM STATUS: 0x%02x and sense\n",
2301 dev->se_hba->hba_id, dev->transport->name, cmd->scsi_status);
2302 return 0;
2303
2304out:
2305 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2518 return -1; 2306 return -1;
2519} 2307}
2520 2308
@@ -2581,7 +2369,7 @@ static int target_check_write_same_discard(unsigned char *flags, struct se_devic
2581 * Generic Command Sequencer that should work for most DAS transport 2369 * Generic Command Sequencer that should work for most DAS transport
2582 * drivers. 2370 * drivers.
2583 * 2371 *
2584 * Called from transport_generic_allocate_tasks() in the $FABRIC_MOD 2372 * Called from target_setup_cmd_from_cdb() in the $FABRIC_MOD
2585 * RX Thread. 2373 * RX Thread.
2586 * 2374 *
2587 * FIXME: Need to support other SCSI OPCODES where as well. 2375 * FIXME: Need to support other SCSI OPCODES where as well.
@@ -2615,11 +2403,10 @@ static int transport_generic_cmd_sequencer(
2615 * by the ALUA primary or secondary access state.. 2403 * by the ALUA primary or secondary access state..
2616 */ 2404 */
2617 if (ret > 0) { 2405 if (ret > 0) {
2618#if 0
2619 pr_debug("[%s]: ALUA TG Port not available," 2406 pr_debug("[%s]: ALUA TG Port not available,"
2620 " SenseKey: NOT_READY, ASC/ASCQ: 0x04/0x%02x\n", 2407 " SenseKey: NOT_READY, ASC/ASCQ: 0x04/0x%02x\n",
2621 cmd->se_tfo->get_fabric_name(), alua_ascq); 2408 cmd->se_tfo->get_fabric_name(), alua_ascq);
2622#endif 2409
2623 transport_set_sense_codes(cmd, 0x04, alua_ascq); 2410 transport_set_sense_codes(cmd, 0x04, alua_ascq);
2624 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION; 2411 cmd->se_cmd_flags |= SCF_SCSI_CDB_EXCEPTION;
2625 cmd->scsi_sense_reason = TCM_CHECK_CONDITION_NOT_READY; 2412 cmd->scsi_sense_reason = TCM_CHECK_CONDITION_NOT_READY;
@@ -2695,6 +2482,7 @@ static int transport_generic_cmd_sequencer(
2695 cmd->se_cmd_flags |= SCF_SCSI_DATA_SG_IO_CDB; 2482 cmd->se_cmd_flags |= SCF_SCSI_DATA_SG_IO_CDB;
2696 break; 2483 break;
2697 case WRITE_10: 2484 case WRITE_10:
2485 case WRITE_VERIFY:
2698 sectors = transport_get_sectors_10(cdb, cmd, &sector_ret); 2486 sectors = transport_get_sectors_10(cdb, cmd, &sector_ret);
2699 if (sector_ret) 2487 if (sector_ret)
2700 goto out_unsupported_cdb; 2488 goto out_unsupported_cdb;
@@ -2796,7 +2584,7 @@ static int transport_generic_cmd_sequencer(
2796 if (target_check_write_same_discard(&cdb[10], dev) < 0) 2584 if (target_check_write_same_discard(&cdb[10], dev) < 0)
2797 goto out_unsupported_cdb; 2585 goto out_unsupported_cdb;
2798 if (!passthrough) 2586 if (!passthrough)
2799 cmd->execute_task = target_emulate_write_same; 2587 cmd->execute_cmd = target_emulate_write_same;
2800 break; 2588 break;
2801 default: 2589 default:
2802 pr_err("VARIABLE_LENGTH_CMD service action" 2590 pr_err("VARIABLE_LENGTH_CMD service action"
@@ -2810,9 +2598,9 @@ static int transport_generic_cmd_sequencer(
2810 /* 2598 /*
2811 * Check for emulated MI_REPORT_TARGET_PGS. 2599 * Check for emulated MI_REPORT_TARGET_PGS.
2812 */ 2600 */
2813 if (cdb[1] == MI_REPORT_TARGET_PGS && 2601 if ((cdb[1] & 0x1f) == MI_REPORT_TARGET_PGS &&
2814 su_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) { 2602 su_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) {
2815 cmd->execute_task = 2603 cmd->execute_cmd =
2816 target_emulate_report_target_port_groups; 2604 target_emulate_report_target_port_groups;
2817 } 2605 }
2818 size = (cdb[6] << 24) | (cdb[7] << 16) | 2606 size = (cdb[6] << 24) | (cdb[7] << 16) |
@@ -2835,13 +2623,13 @@ static int transport_generic_cmd_sequencer(
2835 size = cdb[4]; 2623 size = cdb[4];
2836 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2624 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
2837 if (!passthrough) 2625 if (!passthrough)
2838 cmd->execute_task = target_emulate_modesense; 2626 cmd->execute_cmd = target_emulate_modesense;
2839 break; 2627 break;
2840 case MODE_SENSE_10: 2628 case MODE_SENSE_10:
2841 size = (cdb[7] << 8) + cdb[8]; 2629 size = (cdb[7] << 8) + cdb[8];
2842 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2630 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
2843 if (!passthrough) 2631 if (!passthrough)
2844 cmd->execute_task = target_emulate_modesense; 2632 cmd->execute_cmd = target_emulate_modesense;
2845 break; 2633 break;
2846 case GPCMD_READ_BUFFER_CAPACITY: 2634 case GPCMD_READ_BUFFER_CAPACITY:
2847 case GPCMD_SEND_OPC: 2635 case GPCMD_SEND_OPC:
@@ -2863,13 +2651,13 @@ static int transport_generic_cmd_sequencer(
2863 break; 2651 break;
2864 case PERSISTENT_RESERVE_IN: 2652 case PERSISTENT_RESERVE_IN:
2865 if (su_dev->t10_pr.res_type == SPC3_PERSISTENT_RESERVATIONS) 2653 if (su_dev->t10_pr.res_type == SPC3_PERSISTENT_RESERVATIONS)
2866 cmd->execute_task = target_scsi3_emulate_pr_in; 2654 cmd->execute_cmd = target_scsi3_emulate_pr_in;
2867 size = (cdb[7] << 8) + cdb[8]; 2655 size = (cdb[7] << 8) + cdb[8];
2868 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2656 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
2869 break; 2657 break;
2870 case PERSISTENT_RESERVE_OUT: 2658 case PERSISTENT_RESERVE_OUT:
2871 if (su_dev->t10_pr.res_type == SPC3_PERSISTENT_RESERVATIONS) 2659 if (su_dev->t10_pr.res_type == SPC3_PERSISTENT_RESERVATIONS)
2872 cmd->execute_task = target_scsi3_emulate_pr_out; 2660 cmd->execute_cmd = target_scsi3_emulate_pr_out;
2873 size = (cdb[7] << 8) + cdb[8]; 2661 size = (cdb[7] << 8) + cdb[8];
2874 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2662 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
2875 break; 2663 break;
@@ -2890,7 +2678,7 @@ static int transport_generic_cmd_sequencer(
2890 */ 2678 */
2891 if (cdb[1] == MO_SET_TARGET_PGS && 2679 if (cdb[1] == MO_SET_TARGET_PGS &&
2892 su_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) { 2680 su_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) {
2893 cmd->execute_task = 2681 cmd->execute_cmd =
2894 target_emulate_set_target_port_groups; 2682 target_emulate_set_target_port_groups;
2895 } 2683 }
2896 2684
@@ -2912,7 +2700,7 @@ static int transport_generic_cmd_sequencer(
2912 cmd->sam_task_attr = MSG_HEAD_TAG; 2700 cmd->sam_task_attr = MSG_HEAD_TAG;
2913 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2701 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
2914 if (!passthrough) 2702 if (!passthrough)
2915 cmd->execute_task = target_emulate_inquiry; 2703 cmd->execute_cmd = target_emulate_inquiry;
2916 break; 2704 break;
2917 case READ_BUFFER: 2705 case READ_BUFFER:
2918 size = (cdb[6] << 16) + (cdb[7] << 8) + cdb[8]; 2706 size = (cdb[6] << 16) + (cdb[7] << 8) + cdb[8];
@@ -2922,7 +2710,7 @@ static int transport_generic_cmd_sequencer(
2922 size = READ_CAP_LEN; 2710 size = READ_CAP_LEN;
2923 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2711 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
2924 if (!passthrough) 2712 if (!passthrough)
2925 cmd->execute_task = target_emulate_readcapacity; 2713 cmd->execute_cmd = target_emulate_readcapacity;
2926 break; 2714 break;
2927 case READ_MEDIA_SERIAL_NUMBER: 2715 case READ_MEDIA_SERIAL_NUMBER:
2928 case SECURITY_PROTOCOL_IN: 2716 case SECURITY_PROTOCOL_IN:
@@ -2934,7 +2722,7 @@ static int transport_generic_cmd_sequencer(
2934 switch (cmd->t_task_cdb[1] & 0x1f) { 2722 switch (cmd->t_task_cdb[1] & 0x1f) {
2935 case SAI_READ_CAPACITY_16: 2723 case SAI_READ_CAPACITY_16:
2936 if (!passthrough) 2724 if (!passthrough)
2937 cmd->execute_task = 2725 cmd->execute_cmd =
2938 target_emulate_readcapacity_16; 2726 target_emulate_readcapacity_16;
2939 break; 2727 break;
2940 default: 2728 default:
@@ -2977,7 +2765,7 @@ static int transport_generic_cmd_sequencer(
2977 size = cdb[4]; 2765 size = cdb[4];
2978 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2766 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
2979 if (!passthrough) 2767 if (!passthrough)
2980 cmd->execute_task = target_emulate_request_sense; 2768 cmd->execute_cmd = target_emulate_request_sense;
2981 break; 2769 break;
2982 case READ_ELEMENT_STATUS: 2770 case READ_ELEMENT_STATUS:
2983 size = 65536 * cdb[7] + 256 * cdb[8] + cdb[9]; 2771 size = 65536 * cdb[7] + 256 * cdb[8] + cdb[9];
@@ -3006,7 +2794,7 @@ static int transport_generic_cmd_sequencer(
3006 * emulation disabled. 2794 * emulation disabled.
3007 */ 2795 */
3008 if (su_dev->t10_pr.res_type != SPC_PASSTHROUGH) 2796 if (su_dev->t10_pr.res_type != SPC_PASSTHROUGH)
3009 cmd->execute_task = target_scsi2_reservation_reserve; 2797 cmd->execute_cmd = target_scsi2_reservation_reserve;
3010 cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB; 2798 cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB;
3011 break; 2799 break;
3012 case RELEASE: 2800 case RELEASE:
@@ -3021,7 +2809,7 @@ static int transport_generic_cmd_sequencer(
3021 size = cmd->data_length; 2809 size = cmd->data_length;
3022 2810
3023 if (su_dev->t10_pr.res_type != SPC_PASSTHROUGH) 2811 if (su_dev->t10_pr.res_type != SPC_PASSTHROUGH)
3024 cmd->execute_task = target_scsi2_reservation_release; 2812 cmd->execute_cmd = target_scsi2_reservation_release;
3025 cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB; 2813 cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB;
3026 break; 2814 break;
3027 case SYNCHRONIZE_CACHE: 2815 case SYNCHRONIZE_CACHE:
@@ -3053,13 +2841,13 @@ static int transport_generic_cmd_sequencer(
3053 if (transport_cmd_get_valid_sectors(cmd) < 0) 2841 if (transport_cmd_get_valid_sectors(cmd) < 0)
3054 goto out_invalid_cdb_field; 2842 goto out_invalid_cdb_field;
3055 } 2843 }
3056 cmd->execute_task = target_emulate_synchronize_cache; 2844 cmd->execute_cmd = target_emulate_synchronize_cache;
3057 break; 2845 break;
3058 case UNMAP: 2846 case UNMAP:
3059 size = get_unaligned_be16(&cdb[7]); 2847 size = get_unaligned_be16(&cdb[7]);
3060 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2848 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
3061 if (!passthrough) 2849 if (!passthrough)
3062 cmd->execute_task = target_emulate_unmap; 2850 cmd->execute_cmd = target_emulate_unmap;
3063 break; 2851 break;
3064 case WRITE_SAME_16: 2852 case WRITE_SAME_16:
3065 sectors = transport_get_sectors_16(cdb, cmd, &sector_ret); 2853 sectors = transport_get_sectors_16(cdb, cmd, &sector_ret);
@@ -3079,7 +2867,7 @@ static int transport_generic_cmd_sequencer(
3079 if (target_check_write_same_discard(&cdb[1], dev) < 0) 2867 if (target_check_write_same_discard(&cdb[1], dev) < 0)
3080 goto out_unsupported_cdb; 2868 goto out_unsupported_cdb;
3081 if (!passthrough) 2869 if (!passthrough)
3082 cmd->execute_task = target_emulate_write_same; 2870 cmd->execute_cmd = target_emulate_write_same;
3083 break; 2871 break;
3084 case WRITE_SAME: 2872 case WRITE_SAME:
3085 sectors = transport_get_sectors_10(cdb, cmd, &sector_ret); 2873 sectors = transport_get_sectors_10(cdb, cmd, &sector_ret);
@@ -3102,7 +2890,7 @@ static int transport_generic_cmd_sequencer(
3102 if (target_check_write_same_discard(&cdb[1], dev) < 0) 2890 if (target_check_write_same_discard(&cdb[1], dev) < 0)
3103 goto out_unsupported_cdb; 2891 goto out_unsupported_cdb;
3104 if (!passthrough) 2892 if (!passthrough)
3105 cmd->execute_task = target_emulate_write_same; 2893 cmd->execute_cmd = target_emulate_write_same;
3106 break; 2894 break;
3107 case ALLOW_MEDIUM_REMOVAL: 2895 case ALLOW_MEDIUM_REMOVAL:
3108 case ERASE: 2896 case ERASE:
@@ -3115,7 +2903,7 @@ static int transport_generic_cmd_sequencer(
3115 case WRITE_FILEMARKS: 2903 case WRITE_FILEMARKS:
3116 cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB; 2904 cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB;
3117 if (!passthrough) 2905 if (!passthrough)
3118 cmd->execute_task = target_emulate_noop; 2906 cmd->execute_cmd = target_emulate_noop;
3119 break; 2907 break;
3120 case GPCMD_CLOSE_TRACK: 2908 case GPCMD_CLOSE_TRACK:
3121 case INITIALIZE_ELEMENT_STATUS: 2909 case INITIALIZE_ELEMENT_STATUS:
@@ -3125,7 +2913,7 @@ static int transport_generic_cmd_sequencer(
3125 cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB; 2913 cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB;
3126 break; 2914 break;
3127 case REPORT_LUNS: 2915 case REPORT_LUNS:
3128 cmd->execute_task = target_report_luns; 2916 cmd->execute_cmd = target_report_luns;
3129 size = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9]; 2917 size = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9];
3130 /* 2918 /*
3131 * Do implict HEAD_OF_QUEUE processing for REPORT_LUNS 2919 * Do implict HEAD_OF_QUEUE processing for REPORT_LUNS
@@ -3135,6 +2923,42 @@ static int transport_generic_cmd_sequencer(
3135 cmd->sam_task_attr = MSG_HEAD_TAG; 2923 cmd->sam_task_attr = MSG_HEAD_TAG;
3136 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2924 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
3137 break; 2925 break;
2926 case GET_EVENT_STATUS_NOTIFICATION:
2927 size = (cdb[7] << 8) | cdb[8];
2928 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
2929 break;
2930 case ATA_16:
2931 /* Only support ATA passthrough to pSCSI backends.. */
2932 if (!passthrough)
2933 goto out_unsupported_cdb;
2934
2935 /* T_LENGTH */
2936 switch (cdb[2] & 0x3) {
2937 case 0x0:
2938 sectors = 0;
2939 break;
2940 case 0x1:
2941 sectors = (((cdb[1] & 0x1) ? cdb[3] : 0) << 8) | cdb[4];
2942 break;
2943 case 0x2:
2944 sectors = (((cdb[1] & 0x1) ? cdb[5] : 0) << 8) | cdb[6];
2945 break;
2946 case 0x3:
2947 pr_err("T_LENGTH=0x3 not supported for ATA_16\n");
2948 goto out_invalid_cdb_field;
2949 }
2950
2951 /* BYTE_BLOCK */
2952 if (cdb[2] & 0x4) {
2953 /* BLOCK T_TYPE: 512 or sector */
2954 size = sectors * ((cdb[2] & 0x10) ?
2955 dev->se_sub_dev->se_dev_attrib.block_size : 512);
2956 } else {
2957 /* BYTE */
2958 size = sectors;
2959 }
2960 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB;
2961 break;
3138 default: 2962 default:
3139 pr_warn("TARGET_CORE[%s]: Unsupported SCSI Opcode" 2963 pr_warn("TARGET_CORE[%s]: Unsupported SCSI Opcode"
3140 " 0x%02x, sending CHECK_CONDITION.\n", 2964 " 0x%02x, sending CHECK_CONDITION.\n",
@@ -3142,6 +2966,9 @@ static int transport_generic_cmd_sequencer(
3142 goto out_unsupported_cdb; 2966 goto out_unsupported_cdb;
3143 } 2967 }
3144 2968
2969 if (cmd->unknown_data_length)
2970 cmd->data_length = size;
2971
3145 if (size != cmd->data_length) { 2972 if (size != cmd->data_length) {
3146 pr_warn("TARGET_CORE[%s]: Expected Transfer Length:" 2973 pr_warn("TARGET_CORE[%s]: Expected Transfer Length:"
3147 " %u does not match SCSI CDB Length: %u for SAM Opcode:" 2974 " %u does not match SCSI CDB Length: %u for SAM Opcode:"
@@ -3177,15 +3004,25 @@ static int transport_generic_cmd_sequencer(
3177 cmd->data_length = size; 3004 cmd->data_length = size;
3178 } 3005 }
3179 3006
3180 if (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB && 3007 if (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) {
3181 sectors > dev->se_sub_dev->se_dev_attrib.fabric_max_sectors) { 3008 if (sectors > su_dev->se_dev_attrib.fabric_max_sectors) {
3182 printk_ratelimited(KERN_ERR "SCSI OP %02xh with too big sectors %u\n", 3009 printk_ratelimited(KERN_ERR "SCSI OP %02xh with too"
3183 cdb[0], sectors); 3010 " big sectors %u exceeds fabric_max_sectors:"
3184 goto out_invalid_cdb_field; 3011 " %u\n", cdb[0], sectors,
3012 su_dev->se_dev_attrib.fabric_max_sectors);
3013 goto out_invalid_cdb_field;
3014 }
3015 if (sectors > su_dev->se_dev_attrib.hw_max_sectors) {
3016 printk_ratelimited(KERN_ERR "SCSI OP %02xh with too"
3017 " big sectors %u exceeds backend hw_max_sectors:"
3018 " %u\n", cdb[0], sectors,
3019 su_dev->se_dev_attrib.hw_max_sectors);
3020 goto out_invalid_cdb_field;
3021 }
3185 } 3022 }
3186 3023
3187 /* reject any command that we don't have a handler for */ 3024 /* reject any command that we don't have a handler for */
3188 if (!(passthrough || cmd->execute_task || 3025 if (!(passthrough || cmd->execute_cmd ||
3189 (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB))) 3026 (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB)))
3190 goto out_unsupported_cdb; 3027 goto out_unsupported_cdb;
3191 3028
@@ -3250,7 +3087,7 @@ static void transport_complete_task_attr(struct se_cmd *cmd)
3250 cmd_p->t_task_cdb[0], 3087 cmd_p->t_task_cdb[0],
3251 cmd_p->sam_task_attr, cmd_p->se_ordered_id); 3088 cmd_p->sam_task_attr, cmd_p->se_ordered_id);
3252 3089
3253 transport_add_tasks_from_cmd(cmd_p); 3090 target_add_to_execute_list(cmd_p);
3254 new_active_tasks++; 3091 new_active_tasks++;
3255 3092
3256 spin_lock(&dev->delayed_cmd_lock); 3093 spin_lock(&dev->delayed_cmd_lock);
@@ -3346,10 +3183,6 @@ static void target_complete_ok_work(struct work_struct *work)
3346 if (transport_get_sense_data(cmd) < 0) 3183 if (transport_get_sense_data(cmd) < 0)
3347 reason = TCM_NON_EXISTENT_LUN; 3184 reason = TCM_NON_EXISTENT_LUN;
3348 3185
3349 /*
3350 * Only set when an struct se_task->task_scsi_status returned
3351 * a non GOOD status.
3352 */
3353 if (cmd->scsi_status) { 3186 if (cmd->scsi_status) {
3354 ret = transport_send_check_condition_and_sense( 3187 ret = transport_send_check_condition_and_sense(
3355 cmd, reason, 1); 3188 cmd, reason, 1);
@@ -3424,33 +3257,6 @@ queue_full:
3424 transport_handle_queue_full(cmd, cmd->se_dev); 3257 transport_handle_queue_full(cmd, cmd->se_dev);
3425} 3258}
3426 3259
3427static void transport_free_dev_tasks(struct se_cmd *cmd)
3428{
3429 struct se_task *task, *task_tmp;
3430 unsigned long flags;
3431 LIST_HEAD(dispose_list);
3432
3433 spin_lock_irqsave(&cmd->t_state_lock, flags);
3434 list_for_each_entry_safe(task, task_tmp,
3435 &cmd->t_task_list, t_list) {
3436 if (!(task->task_flags & TF_ACTIVE))
3437 list_move_tail(&task->t_list, &dispose_list);
3438 }
3439 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
3440
3441 while (!list_empty(&dispose_list)) {
3442 task = list_first_entry(&dispose_list, struct se_task, t_list);
3443
3444 if (task->task_sg != cmd->t_data_sg &&
3445 task->task_sg != cmd->t_bidi_data_sg)
3446 kfree(task->task_sg);
3447
3448 list_del(&task->t_list);
3449
3450 cmd->se_dev->transport->free_task(task);
3451 }
3452}
3453
3454static inline void transport_free_sgl(struct scatterlist *sgl, int nents) 3260static inline void transport_free_sgl(struct scatterlist *sgl, int nents)
3455{ 3261{
3456 struct scatterlist *sg; 3262 struct scatterlist *sg;
@@ -3511,7 +3317,6 @@ static void transport_release_cmd(struct se_cmd *cmd)
3511static void transport_put_cmd(struct se_cmd *cmd) 3317static void transport_put_cmd(struct se_cmd *cmd)
3512{ 3318{
3513 unsigned long flags; 3319 unsigned long flags;
3514 int free_tasks = 0;
3515 3320
3516 spin_lock_irqsave(&cmd->t_state_lock, flags); 3321 spin_lock_irqsave(&cmd->t_state_lock, flags);
3517 if (atomic_read(&cmd->t_fe_count)) { 3322 if (atomic_read(&cmd->t_fe_count)) {
@@ -3519,21 +3324,12 @@ static void transport_put_cmd(struct se_cmd *cmd)
3519 goto out_busy; 3324 goto out_busy;
3520 } 3325 }
3521 3326
3522 if (atomic_read(&cmd->t_se_count)) {
3523 if (!atomic_dec_and_test(&cmd->t_se_count))
3524 goto out_busy;
3525 }
3526
3527 if (cmd->transport_state & CMD_T_DEV_ACTIVE) { 3327 if (cmd->transport_state & CMD_T_DEV_ACTIVE) {
3528 cmd->transport_state &= ~CMD_T_DEV_ACTIVE; 3328 cmd->transport_state &= ~CMD_T_DEV_ACTIVE;
3529 transport_all_task_dev_remove_state(cmd); 3329 target_remove_from_state_list(cmd);
3530 free_tasks = 1;
3531 } 3330 }
3532 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 3331 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
3533 3332
3534 if (free_tasks != 0)
3535 transport_free_dev_tasks(cmd);
3536
3537 transport_free_pages(cmd); 3333 transport_free_pages(cmd);
3538 transport_release_cmd(cmd); 3334 transport_release_cmd(cmd);
3539 return; 3335 return;
@@ -3683,245 +3479,14 @@ out:
3683 return -ENOMEM; 3479 return -ENOMEM;
3684} 3480}
3685 3481
3686/* Reduce sectors if they are too long for the device */
3687static inline sector_t transport_limit_task_sectors(
3688 struct se_device *dev,
3689 unsigned long long lba,
3690 sector_t sectors)
3691{
3692 sectors = min_t(sector_t, sectors, dev->se_sub_dev->se_dev_attrib.max_sectors);
3693
3694 if (dev->transport->get_device_type(dev) == TYPE_DISK)
3695 if ((lba + sectors) > transport_dev_end_lba(dev))
3696 sectors = ((transport_dev_end_lba(dev) - lba) + 1);
3697
3698 return sectors;
3699}
3700
3701
3702/*
3703 * This function can be used by HW target mode drivers to create a linked
3704 * scatterlist from all contiguously allocated struct se_task->task_sg[].
3705 * This is intended to be called during the completion path by TCM Core
3706 * when struct target_core_fabric_ops->check_task_sg_chaining is enabled.
3707 */
3708void transport_do_task_sg_chain(struct se_cmd *cmd)
3709{
3710 struct scatterlist *sg_first = NULL;
3711 struct scatterlist *sg_prev = NULL;
3712 int sg_prev_nents = 0;
3713 struct scatterlist *sg;
3714 struct se_task *task;
3715 u32 chained_nents = 0;
3716 int i;
3717
3718 BUG_ON(!cmd->se_tfo->task_sg_chaining);
3719
3720 /*
3721 * Walk the struct se_task list and setup scatterlist chains
3722 * for each contiguously allocated struct se_task->task_sg[].
3723 */
3724 list_for_each_entry(task, &cmd->t_task_list, t_list) {
3725 if (!task->task_sg)
3726 continue;
3727
3728 if (!sg_first) {
3729 sg_first = task->task_sg;
3730 chained_nents = task->task_sg_nents;
3731 } else {
3732 sg_chain(sg_prev, sg_prev_nents, task->task_sg);
3733 chained_nents += task->task_sg_nents;
3734 }
3735 /*
3736 * For the padded tasks, use the extra SGL vector allocated
3737 * in transport_allocate_data_tasks() for the sg_prev_nents
3738 * offset into sg_chain() above.
3739 *
3740 * We do not need the padding for the last task (or a single
3741 * task), but in that case we will never use the sg_prev_nents
3742 * value below which would be incorrect.
3743 */
3744 sg_prev_nents = (task->task_sg_nents + 1);
3745 sg_prev = task->task_sg;
3746 }
3747 /*
3748 * Setup the starting pointer and total t_tasks_sg_linked_no including
3749 * padding SGs for linking and to mark the end.
3750 */
3751 cmd->t_tasks_sg_chained = sg_first;
3752 cmd->t_tasks_sg_chained_no = chained_nents;
3753
3754 pr_debug("Setup cmd: %p cmd->t_tasks_sg_chained: %p and"
3755 " t_tasks_sg_chained_no: %u\n", cmd, cmd->t_tasks_sg_chained,
3756 cmd->t_tasks_sg_chained_no);
3757
3758 for_each_sg(cmd->t_tasks_sg_chained, sg,
3759 cmd->t_tasks_sg_chained_no, i) {
3760
3761 pr_debug("SG[%d]: %p page: %p length: %d offset: %d\n",
3762 i, sg, sg_page(sg), sg->length, sg->offset);
3763 if (sg_is_chain(sg))
3764 pr_debug("SG: %p sg_is_chain=1\n", sg);
3765 if (sg_is_last(sg))
3766 pr_debug("SG: %p sg_is_last=1\n", sg);
3767 }
3768}
3769EXPORT_SYMBOL(transport_do_task_sg_chain);
3770
3771/*
3772 * Break up cmd into chunks transport can handle
3773 */
3774static int
3775transport_allocate_data_tasks(struct se_cmd *cmd,
3776 enum dma_data_direction data_direction,
3777 struct scatterlist *cmd_sg, unsigned int sgl_nents)
3778{
3779 struct se_device *dev = cmd->se_dev;
3780 int task_count, i;
3781 unsigned long long lba;
3782 sector_t sectors, dev_max_sectors;
3783 u32 sector_size;
3784
3785 if (transport_cmd_get_valid_sectors(cmd) < 0)
3786 return -EINVAL;
3787
3788 dev_max_sectors = dev->se_sub_dev->se_dev_attrib.max_sectors;
3789 sector_size = dev->se_sub_dev->se_dev_attrib.block_size;
3790
3791 WARN_ON(cmd->data_length % sector_size);
3792
3793 lba = cmd->t_task_lba;
3794 sectors = DIV_ROUND_UP(cmd->data_length, sector_size);
3795 task_count = DIV_ROUND_UP_SECTOR_T(sectors, dev_max_sectors);
3796
3797 /*
3798 * If we need just a single task reuse the SG list in the command
3799 * and avoid a lot of work.
3800 */
3801 if (task_count == 1) {
3802 struct se_task *task;
3803 unsigned long flags;
3804
3805 task = transport_generic_get_task(cmd, data_direction);
3806 if (!task)
3807 return -ENOMEM;
3808
3809 task->task_sg = cmd_sg;
3810 task->task_sg_nents = sgl_nents;
3811
3812 task->task_lba = lba;
3813 task->task_sectors = sectors;
3814 task->task_size = task->task_sectors * sector_size;
3815
3816 spin_lock_irqsave(&cmd->t_state_lock, flags);
3817 list_add_tail(&task->t_list, &cmd->t_task_list);
3818 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
3819
3820 return task_count;
3821 }
3822
3823 for (i = 0; i < task_count; i++) {
3824 struct se_task *task;
3825 unsigned int task_size, task_sg_nents_padded;
3826 struct scatterlist *sg;
3827 unsigned long flags;
3828 int count;
3829
3830 task = transport_generic_get_task(cmd, data_direction);
3831 if (!task)
3832 return -ENOMEM;
3833
3834 task->task_lba = lba;
3835 task->task_sectors = min(sectors, dev_max_sectors);
3836 task->task_size = task->task_sectors * sector_size;
3837
3838 /*
3839 * This now assumes that passed sg_ents are in PAGE_SIZE chunks
3840 * in order to calculate the number per task SGL entries
3841 */
3842 task->task_sg_nents = DIV_ROUND_UP(task->task_size, PAGE_SIZE);
3843 /*
3844 * Check if the fabric module driver is requesting that all
3845 * struct se_task->task_sg[] be chained together.. If so,
3846 * then allocate an extra padding SG entry for linking and
3847 * marking the end of the chained SGL for every task except
3848 * the last one for (task_count > 1) operation, or skipping
3849 * the extra padding for the (task_count == 1) case.
3850 */
3851 if (cmd->se_tfo->task_sg_chaining && (i < (task_count - 1))) {
3852 task_sg_nents_padded = (task->task_sg_nents + 1);
3853 } else
3854 task_sg_nents_padded = task->task_sg_nents;
3855
3856 task->task_sg = kmalloc(sizeof(struct scatterlist) *
3857 task_sg_nents_padded, GFP_KERNEL);
3858 if (!task->task_sg) {
3859 cmd->se_dev->transport->free_task(task);
3860 return -ENOMEM;
3861 }
3862
3863 sg_init_table(task->task_sg, task_sg_nents_padded);
3864
3865 task_size = task->task_size;
3866
3867 /* Build new sgl, only up to task_size */
3868 for_each_sg(task->task_sg, sg, task->task_sg_nents, count) {
3869 if (cmd_sg->length > task_size)
3870 break;
3871
3872 *sg = *cmd_sg;
3873 task_size -= cmd_sg->length;
3874 cmd_sg = sg_next(cmd_sg);
3875 }
3876
3877 lba += task->task_sectors;
3878 sectors -= task->task_sectors;
3879
3880 spin_lock_irqsave(&cmd->t_state_lock, flags);
3881 list_add_tail(&task->t_list, &cmd->t_task_list);
3882 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
3883 }
3884
3885 return task_count;
3886}
3887
3888static int
3889transport_allocate_control_task(struct se_cmd *cmd)
3890{
3891 struct se_task *task;
3892 unsigned long flags;
3893
3894 /* Workaround for handling zero-length control CDBs */
3895 if ((cmd->se_cmd_flags & SCF_SCSI_CONTROL_SG_IO_CDB) &&
3896 !cmd->data_length)
3897 return 0;
3898
3899 task = transport_generic_get_task(cmd, cmd->data_direction);
3900 if (!task)
3901 return -ENOMEM;
3902
3903 task->task_sg = cmd->t_data_sg;
3904 task->task_size = cmd->data_length;
3905 task->task_sg_nents = cmd->t_data_nents;
3906
3907 spin_lock_irqsave(&cmd->t_state_lock, flags);
3908 list_add_tail(&task->t_list, &cmd->t_task_list);
3909 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
3910
3911 /* Success! Return number of tasks allocated */
3912 return 1;
3913}
3914
3915/* 3482/*
3916 * Allocate any required ressources to execute the command, and either place 3483 * Allocate any required resources to execute the command. For writes we
3917 * it on the execution queue if possible. For writes we might not have the 3484 * might not have the payload yet, so notify the fabric via a call to
3918 * payload yet, thus notify the fabric via a call to ->write_pending instead. 3485 * ->write_pending instead. Otherwise place it on the execution queue.
3919 */ 3486 */
3920int transport_generic_new_cmd(struct se_cmd *cmd) 3487int transport_generic_new_cmd(struct se_cmd *cmd)
3921{ 3488{
3922 struct se_device *dev = cmd->se_dev; 3489 struct se_device *dev = cmd->se_dev;
3923 int task_cdbs, task_cdbs_bidi = 0;
3924 int set_counts = 1;
3925 int ret = 0; 3490 int ret = 0;
3926 3491
3927 /* 3492 /*
@@ -3936,35 +3501,9 @@ int transport_generic_new_cmd(struct se_cmd *cmd)
3936 goto out_fail; 3501 goto out_fail;
3937 } 3502 }
3938 3503
3939 /* 3504 /* Workaround for handling zero-length control CDBs */
3940 * For BIDI command set up the read tasks first. 3505 if ((cmd->se_cmd_flags & SCF_SCSI_CONTROL_SG_IO_CDB) &&
3941 */ 3506 !cmd->data_length) {
3942 if (cmd->t_bidi_data_sg &&
3943 dev->transport->transport_type != TRANSPORT_PLUGIN_PHBA_PDEV) {
3944 BUG_ON(!(cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB));
3945
3946 task_cdbs_bidi = transport_allocate_data_tasks(cmd,
3947 DMA_FROM_DEVICE, cmd->t_bidi_data_sg,
3948 cmd->t_bidi_data_nents);
3949 if (task_cdbs_bidi <= 0)
3950 goto out_fail;
3951
3952 atomic_inc(&cmd->t_fe_count);
3953 atomic_inc(&cmd->t_se_count);
3954 set_counts = 0;
3955 }
3956
3957 if (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) {
3958 task_cdbs = transport_allocate_data_tasks(cmd,
3959 cmd->data_direction, cmd->t_data_sg,
3960 cmd->t_data_nents);
3961 } else {
3962 task_cdbs = transport_allocate_control_task(cmd);
3963 }
3964
3965 if (task_cdbs < 0)
3966 goto out_fail;
3967 else if (!task_cdbs && (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB)) {
3968 spin_lock_irq(&cmd->t_state_lock); 3507 spin_lock_irq(&cmd->t_state_lock);
3969 cmd->t_state = TRANSPORT_COMPLETE; 3508 cmd->t_state = TRANSPORT_COMPLETE;
3970 cmd->transport_state |= CMD_T_ACTIVE; 3509 cmd->transport_state |= CMD_T_ACTIVE;
@@ -3982,29 +3521,31 @@ int transport_generic_new_cmd(struct se_cmd *cmd)
3982 return 0; 3521 return 0;
3983 } 3522 }
3984 3523
3985 if (set_counts) { 3524 if (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) {
3986 atomic_inc(&cmd->t_fe_count); 3525 struct se_dev_attrib *attr = &dev->se_sub_dev->se_dev_attrib;
3987 atomic_inc(&cmd->t_se_count); 3526
3527 if (transport_cmd_get_valid_sectors(cmd) < 0)
3528 return -EINVAL;
3529
3530 BUG_ON(cmd->data_length % attr->block_size);
3531 BUG_ON(DIV_ROUND_UP(cmd->data_length, attr->block_size) >
3532 attr->hw_max_sectors);
3988 } 3533 }
3989 3534
3990 cmd->t_task_list_num = (task_cdbs + task_cdbs_bidi); 3535 atomic_inc(&cmd->t_fe_count);
3991 atomic_set(&cmd->t_task_cdbs_left, cmd->t_task_list_num);
3992 atomic_set(&cmd->t_task_cdbs_ex_left, cmd->t_task_list_num);
3993 3536
3994 /* 3537 /*
3995 * For WRITEs, let the fabric know its buffer is ready.. 3538 * For WRITEs, let the fabric know its buffer is ready.
3996 * This WRITE struct se_cmd (and all of its associated struct se_task's) 3539 *
3997 * will be added to the struct se_device execution queue after its WRITE 3540 * The command will be added to the execution queue after its write
3998 * data has arrived. (ie: It gets handled by the transport processing 3541 * data has arrived.
3999 * thread a second time)
4000 */ 3542 */
4001 if (cmd->data_direction == DMA_TO_DEVICE) { 3543 if (cmd->data_direction == DMA_TO_DEVICE) {
4002 transport_add_tasks_to_state_queue(cmd); 3544 target_add_to_state_list(cmd);
4003 return transport_generic_write_pending(cmd); 3545 return transport_generic_write_pending(cmd);
4004 } 3546 }
4005 /* 3547 /*
4006 * Everything else but a WRITE, add the struct se_cmd's struct se_task's 3548 * Everything else but a WRITE, add the command to the execution queue.
4007 * to the execution queue.
4008 */ 3549 */
4009 transport_execute_tasks(cmd); 3550 transport_execute_tasks(cmd);
4010 return 0; 3551 return 0;
@@ -4091,8 +3632,6 @@ void transport_generic_free_cmd(struct se_cmd *cmd, int wait_for_tasks)
4091 if (cmd->se_lun) 3632 if (cmd->se_lun)
4092 transport_lun_remove_cmd(cmd); 3633 transport_lun_remove_cmd(cmd);
4093 3634
4094 transport_free_dev_tasks(cmd);
4095
4096 transport_put_cmd(cmd); 3635 transport_put_cmd(cmd);
4097 } 3636 }
4098} 3637}
@@ -4233,7 +3772,8 @@ EXPORT_SYMBOL(target_wait_for_sess_cmds);
4233static int transport_lun_wait_for_tasks(struct se_cmd *cmd, struct se_lun *lun) 3772static int transport_lun_wait_for_tasks(struct se_cmd *cmd, struct se_lun *lun)
4234{ 3773{
4235 unsigned long flags; 3774 unsigned long flags;
4236 int ret; 3775 int ret = 0;
3776
4237 /* 3777 /*
4238 * If the frontend has already requested this struct se_cmd to 3778 * If the frontend has already requested this struct se_cmd to
4239 * be stopped, we can safely ignore this struct se_cmd. 3779 * be stopped, we can safely ignore this struct se_cmd.
@@ -4253,10 +3793,21 @@ static int transport_lun_wait_for_tasks(struct se_cmd *cmd, struct se_lun *lun)
4253 3793
4254 wake_up_interruptible(&cmd->se_dev->dev_queue_obj.thread_wq); 3794 wake_up_interruptible(&cmd->se_dev->dev_queue_obj.thread_wq);
4255 3795
4256 ret = transport_stop_tasks_for_cmd(cmd); 3796 // XXX: audit task_flags checks.
3797 spin_lock_irqsave(&cmd->t_state_lock, flags);
3798 if ((cmd->transport_state & CMD_T_BUSY) &&
3799 (cmd->transport_state & CMD_T_SENT)) {
3800 if (!target_stop_cmd(cmd, &flags))
3801 ret++;
3802 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
3803 } else {
3804 spin_unlock_irqrestore(&cmd->t_state_lock,
3805 flags);
3806 target_remove_from_execute_list(cmd);
3807 }
4257 3808
4258 pr_debug("ConfigFS: cmd: %p t_tasks: %d stop tasks ret:" 3809 pr_debug("ConfigFS: cmd: %p stop tasks ret:"
4259 " %d\n", cmd, cmd->t_task_list_num, ret); 3810 " %d\n", cmd, ret);
4260 if (!ret) { 3811 if (!ret) {
4261 pr_debug("ConfigFS: ITT[0x%08x] - stopping cmd....\n", 3812 pr_debug("ConfigFS: ITT[0x%08x] - stopping cmd....\n",
4262 cmd->se_tfo->get_task_tag(cmd)); 3813 cmd->se_tfo->get_task_tag(cmd));
@@ -4328,10 +3879,9 @@ static void __transport_clear_lun_from_sessions(struct se_lun *lun)
4328 goto check_cond; 3879 goto check_cond;
4329 } 3880 }
4330 cmd->transport_state &= ~CMD_T_DEV_ACTIVE; 3881 cmd->transport_state &= ~CMD_T_DEV_ACTIVE;
4331 transport_all_task_dev_remove_state(cmd); 3882 target_remove_from_state_list(cmd);
4332 spin_unlock_irqrestore(&cmd->t_state_lock, cmd_flags); 3883 spin_unlock_irqrestore(&cmd->t_state_lock, cmd_flags);
4333 3884
4334 transport_free_dev_tasks(cmd);
4335 /* 3885 /*
4336 * The Storage engine stopped this struct se_cmd before it was 3886 * The Storage engine stopped this struct se_cmd before it was
4337 * send to the fabric frontend for delivery back to the 3887 * send to the fabric frontend for delivery back to the
@@ -4444,7 +3994,7 @@ bool transport_wait_for_tasks(struct se_cmd *cmd)
4444 wait_for_completion(&cmd->transport_lun_fe_stop_comp); 3994 wait_for_completion(&cmd->transport_lun_fe_stop_comp);
4445 spin_lock_irqsave(&cmd->t_state_lock, flags); 3995 spin_lock_irqsave(&cmd->t_state_lock, flags);
4446 3996
4447 transport_all_task_dev_remove_state(cmd); 3997 target_remove_from_state_list(cmd);
4448 /* 3998 /*
4449 * At this point, the frontend who was the originator of this 3999 * At this point, the frontend who was the originator of this
4450 * struct se_cmd, now owns the structure and can be released through 4000 * struct se_cmd, now owns the structure and can be released through
@@ -4710,12 +4260,12 @@ int transport_check_aborted_status(struct se_cmd *cmd, int send_status)
4710 if (!send_status || 4260 if (!send_status ||
4711 (cmd->se_cmd_flags & SCF_SENT_DELAYED_TAS)) 4261 (cmd->se_cmd_flags & SCF_SENT_DELAYED_TAS))
4712 return 1; 4262 return 1;
4713#if 0 4263
4714 pr_debug("Sending delayed SAM_STAT_TASK_ABORTED" 4264 pr_debug("Sending delayed SAM_STAT_TASK_ABORTED"
4715 " status for CDB: 0x%02x ITT: 0x%08x\n", 4265 " status for CDB: 0x%02x ITT: 0x%08x\n",
4716 cmd->t_task_cdb[0], 4266 cmd->t_task_cdb[0],
4717 cmd->se_tfo->get_task_tag(cmd)); 4267 cmd->se_tfo->get_task_tag(cmd));
4718#endif 4268
4719 cmd->se_cmd_flags |= SCF_SENT_DELAYED_TAS; 4269 cmd->se_cmd_flags |= SCF_SENT_DELAYED_TAS;
4720 cmd->se_tfo->queue_status(cmd); 4270 cmd->se_tfo->queue_status(cmd);
4721 ret = 1; 4271 ret = 1;
@@ -4748,11 +4298,11 @@ void transport_send_task_abort(struct se_cmd *cmd)
4748 } 4298 }
4749 } 4299 }
4750 cmd->scsi_status = SAM_STAT_TASK_ABORTED; 4300 cmd->scsi_status = SAM_STAT_TASK_ABORTED;
4751#if 0 4301
4752 pr_debug("Setting SAM_STAT_TASK_ABORTED status for CDB: 0x%02x," 4302 pr_debug("Setting SAM_STAT_TASK_ABORTED status for CDB: 0x%02x,"
4753 " ITT: 0x%08x\n", cmd->t_task_cdb[0], 4303 " ITT: 0x%08x\n", cmd->t_task_cdb[0],
4754 cmd->se_tfo->get_task_tag(cmd)); 4304 cmd->se_tfo->get_task_tag(cmd));
4755#endif 4305
4756 cmd->se_tfo->queue_status(cmd); 4306 cmd->se_tfo->queue_status(cmd);
4757} 4307}
4758 4308
@@ -4865,7 +4415,7 @@ get_cmd:
4865 } 4415 }
4866 4416
4867out: 4417out:
4868 WARN_ON(!list_empty(&dev->state_task_list)); 4418 WARN_ON(!list_empty(&dev->state_list));
4869 WARN_ON(!list_empty(&dev->dev_queue_obj.qobj_list)); 4419 WARN_ON(!list_empty(&dev->dev_queue_obj.qobj_list));
4870 dev->process_thread = NULL; 4420 dev->process_thread = NULL;
4871 return 0; 4421 return 0;
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index a375f257aabc..f03fb9730f5b 100644
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -215,20 +215,10 @@ int ft_write_pending(struct se_cmd *se_cmd)
215 */ 215 */
216 if ((ep->xid <= lport->lro_xid) && 216 if ((ep->xid <= lport->lro_xid) &&
217 (fh->fh_r_ctl == FC_RCTL_DD_DATA_DESC)) { 217 (fh->fh_r_ctl == FC_RCTL_DD_DATA_DESC)) {
218 if (se_cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) { 218 if ((se_cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB) &&
219 /* 219 lport->tt.ddp_target(lport, ep->xid,
220 * cmd may have been broken up into multiple 220 se_cmd->t_data_sg,
221 * tasks. Link their sgs together so we can 221 se_cmd->t_data_nents))
222 * operate on them all at once.
223 */
224 transport_do_task_sg_chain(se_cmd);
225 cmd->sg = se_cmd->t_tasks_sg_chained;
226 cmd->sg_cnt =
227 se_cmd->t_tasks_sg_chained_no;
228 }
229 if (cmd->sg && lport->tt.ddp_target(lport, ep->xid,
230 cmd->sg,
231 cmd->sg_cnt))
232 cmd->was_ddp_setup = 1; 222 cmd->was_ddp_setup = 1;
233 } 223 }
234 } 224 }
diff --git a/drivers/target/tcm_fc/tfc_conf.c b/drivers/target/tcm_fc/tfc_conf.c
index 2948dc944619..9501844fae2d 100644
--- a/drivers/target/tcm_fc/tfc_conf.c
+++ b/drivers/target/tcm_fc/tfc_conf.c
@@ -576,9 +576,6 @@ int ft_register_configfs(void)
576 } 576 }
577 fabric->tf_ops = ft_fabric_ops; 577 fabric->tf_ops = ft_fabric_ops;
578 578
579 /* Allowing support for task_sg_chaining */
580 fabric->tf_ops.task_sg_chaining = 1;
581
582 /* 579 /*
583 * Setup default attribute lists for various fabric->tf_cit_tmpl 580 * Setup default attribute lists for various fabric->tf_cit_tmpl
584 */ 581 */
diff --git a/drivers/target/tcm_fc/tfc_io.c b/drivers/target/tcm_fc/tfc_io.c
index dc7c0db26e20..071a505f98fc 100644
--- a/drivers/target/tcm_fc/tfc_io.c
+++ b/drivers/target/tcm_fc/tfc_io.c
@@ -228,7 +228,7 @@ void ft_recv_write_data(struct ft_cmd *cmd, struct fc_frame *fp)
228 "payload, Frame will be dropped if" 228 "payload, Frame will be dropped if"
229 "'Sequence Initiative' bit in f_ctl is" 229 "'Sequence Initiative' bit in f_ctl is"
230 "not set\n", __func__, ep->xid, f_ctl, 230 "not set\n", __func__, ep->xid, f_ctl,
231 cmd->sg, cmd->sg_cnt); 231 se_cmd->t_data_sg, se_cmd->t_data_nents);
232 /* 232 /*
233 * Invalidate HW DDP context if it was setup for respective 233 * Invalidate HW DDP context if it was setup for respective
234 * command. Invalidation of HW DDP context is requited in both 234 * command. Invalidation of HW DDP context is requited in both
diff --git a/include/target/target_core_backend.h b/include/target/target_core_backend.h
index 8c9ff1b14396..2d7db85e93ae 100644
--- a/include/target/target_core_backend.h
+++ b/include/target/target_core_backend.h
@@ -23,12 +23,11 @@ struct se_subsystem_api {
23 struct se_device *(*create_virtdevice)(struct se_hba *, 23 struct se_device *(*create_virtdevice)(struct se_hba *,
24 struct se_subsystem_dev *, void *); 24 struct se_subsystem_dev *, void *);
25 void (*free_device)(void *); 25 void (*free_device)(void *);
26 int (*transport_complete)(struct se_task *task); 26 int (*transport_complete)(struct se_cmd *cmd, struct scatterlist *);
27 struct se_task *(*alloc_task)(unsigned char *cdb); 27 int (*execute_cmd)(struct se_cmd *, struct scatterlist *, u32,
28 int (*do_task)(struct se_task *); 28 enum dma_data_direction);
29 int (*do_discard)(struct se_device *, sector_t, u32); 29 int (*do_discard)(struct se_device *, sector_t, u32);
30 void (*do_sync_cache)(struct se_task *); 30 void (*do_sync_cache)(struct se_cmd *);
31 void (*free_task)(struct se_task *);
32 ssize_t (*check_configfs_dev_params)(struct se_hba *, 31 ssize_t (*check_configfs_dev_params)(struct se_hba *,
33 struct se_subsystem_dev *); 32 struct se_subsystem_dev *);
34 ssize_t (*set_configfs_dev_params)(struct se_hba *, 33 ssize_t (*set_configfs_dev_params)(struct se_hba *,
@@ -38,7 +37,7 @@ struct se_subsystem_api {
38 u32 (*get_device_rev)(struct se_device *); 37 u32 (*get_device_rev)(struct se_device *);
39 u32 (*get_device_type)(struct se_device *); 38 u32 (*get_device_type)(struct se_device *);
40 sector_t (*get_blocks)(struct se_device *); 39 sector_t (*get_blocks)(struct se_device *);
41 unsigned char *(*get_sense_buffer)(struct se_task *); 40 unsigned char *(*get_sense_buffer)(struct se_cmd *);
42}; 41};
43 42
44int transport_subsystem_register(struct se_subsystem_api *); 43int transport_subsystem_register(struct se_subsystem_api *);
@@ -48,10 +47,7 @@ struct se_device *transport_add_device_to_core_hba(struct se_hba *,
48 struct se_subsystem_api *, struct se_subsystem_dev *, u32, 47 struct se_subsystem_api *, struct se_subsystem_dev *, u32,
49 void *, struct se_dev_limits *, const char *, const char *); 48 void *, struct se_dev_limits *, const char *, const char *);
50 49
51void transport_complete_sync_cache(struct se_cmd *, int); 50void target_complete_cmd(struct se_cmd *, u8);
52void transport_complete_task(struct se_task *, int);
53
54void target_get_task_cdb(struct se_task *, unsigned char *);
55 51
56void transport_set_vpd_proto_id(struct t10_vpd *, unsigned char *); 52void transport_set_vpd_proto_id(struct t10_vpd *, unsigned char *);
57int transport_set_vpd_assoc(struct t10_vpd *, unsigned char *); 53int transport_set_vpd_assoc(struct t10_vpd *, unsigned char *);
diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h
index aaccc5f5fc9f..dc35d8660aa6 100644
--- a/include/target/target_core_base.h
+++ b/include/target/target_core_base.h
@@ -73,9 +73,8 @@
73/* 73/*
74 * struct se_device->dev_flags 74 * struct se_device->dev_flags
75 */ 75 */
76#define DF_READ_ONLY 0x00000001 76#define DF_SPC2_RESERVATIONS 0x00000001
77#define DF_SPC2_RESERVATIONS 0x00000002 77#define DF_SPC2_RESERVATIONS_WITH_ISID 0x00000002
78#define DF_SPC2_RESERVATIONS_WITH_ISID 0x00000004
79 78
80/* struct se_dev_attrib sanity values */ 79/* struct se_dev_attrib sanity values */
81/* Default max_unmap_lba_count */ 80/* Default max_unmap_lba_count */
@@ -141,14 +140,6 @@ enum transport_tpg_type_table {
141 TRANSPORT_TPG_TYPE_DISCOVERY = 1, 140 TRANSPORT_TPG_TYPE_DISCOVERY = 1,
142}; 141};
143 142
144/* struct se_task->task_flags */
145enum se_task_flags {
146 TF_ACTIVE = (1 << 0),
147 TF_SENT = (1 << 1),
148 TF_REQUEST_STOP = (1 << 2),
149 TF_HAS_SENSE = (1 << 3),
150};
151
152/* Special transport agnostic struct se_cmd->t_states */ 143/* Special transport agnostic struct se_cmd->t_states */
153enum transport_state_table { 144enum transport_state_table {
154 TRANSPORT_NO_STATE = 0, 145 TRANSPORT_NO_STATE = 0,
@@ -234,6 +225,7 @@ enum tcm_sense_reason_table {
234enum target_sc_flags_table { 225enum target_sc_flags_table {
235 TARGET_SCF_BIDI_OP = 0x01, 226 TARGET_SCF_BIDI_OP = 0x01,
236 TARGET_SCF_ACK_KREF = 0x02, 227 TARGET_SCF_ACK_KREF = 0x02,
228 TARGET_SCF_UNKNOWN_SIZE = 0x04,
237}; 229};
238 230
239/* fabric independent task management function values */ 231/* fabric independent task management function values */
@@ -338,6 +330,7 @@ struct t10_alua_tg_pt_gp {
338 int tg_pt_gp_alua_access_type; 330 int tg_pt_gp_alua_access_type;
339 int tg_pt_gp_nonop_delay_msecs; 331 int tg_pt_gp_nonop_delay_msecs;
340 int tg_pt_gp_trans_delay_msecs; 332 int tg_pt_gp_trans_delay_msecs;
333 int tg_pt_gp_implict_trans_secs;
341 int tg_pt_gp_pref; 334 int tg_pt_gp_pref;
342 int tg_pt_gp_write_metadata; 335 int tg_pt_gp_write_metadata;
343 /* Used by struct t10_alua_tg_pt_gp->tg_pt_gp_md_buf_len */ 336 /* Used by struct t10_alua_tg_pt_gp->tg_pt_gp_md_buf_len */
@@ -485,23 +478,6 @@ struct se_queue_obj {
485 wait_queue_head_t thread_wq; 478 wait_queue_head_t thread_wq;
486}; 479};
487 480
488struct se_task {
489 unsigned long long task_lba;
490 u32 task_sectors;
491 u32 task_size;
492 struct se_cmd *task_se_cmd;
493 struct scatterlist *task_sg;
494 u32 task_sg_nents;
495 u16 task_flags;
496 u8 task_scsi_status;
497 enum dma_data_direction task_data_direction;
498 struct list_head t_list;
499 struct list_head t_execute_list;
500 struct list_head t_state_list;
501 bool t_state_active;
502 struct completion task_stop_comp;
503};
504
505struct se_tmr_req { 481struct se_tmr_req {
506 /* Task Management function to be performed */ 482 /* Task Management function to be performed */
507 u8 function; 483 u8 function;
@@ -538,6 +514,7 @@ struct se_cmd {
538 /* Used to signal cmd->se_tfo->check_release_cmd() usage per cmd */ 514 /* Used to signal cmd->se_tfo->check_release_cmd() usage per cmd */
539 unsigned check_release:1; 515 unsigned check_release:1;
540 unsigned cmd_wait_set:1; 516 unsigned cmd_wait_set:1;
517 unsigned unknown_data_length:1;
541 /* See se_cmd_flags_table */ 518 /* See se_cmd_flags_table */
542 u32 se_cmd_flags; 519 u32 se_cmd_flags;
543 u32 se_ordered_id; 520 u32 se_ordered_id;
@@ -565,18 +542,13 @@ struct se_cmd {
565 struct completion cmd_wait_comp; 542 struct completion cmd_wait_comp;
566 struct kref cmd_kref; 543 struct kref cmd_kref;
567 struct target_core_fabric_ops *se_tfo; 544 struct target_core_fabric_ops *se_tfo;
568 int (*execute_task)(struct se_task *); 545 int (*execute_cmd)(struct se_cmd *);
569 void (*transport_complete_callback)(struct se_cmd *); 546 void (*transport_complete_callback)(struct se_cmd *);
570 547
571 unsigned char *t_task_cdb; 548 unsigned char *t_task_cdb;
572 unsigned char __t_task_cdb[TCM_MAX_COMMAND_SIZE]; 549 unsigned char __t_task_cdb[TCM_MAX_COMMAND_SIZE];
573 unsigned long long t_task_lba; 550 unsigned long long t_task_lba;
574 u32 t_tasks_sg_chained_no;
575 atomic_t t_fe_count; 551 atomic_t t_fe_count;
576 atomic_t t_se_count;
577 atomic_t t_task_cdbs_left;
578 atomic_t t_task_cdbs_ex_left;
579 atomic_t t_task_cdbs_sent;
580 unsigned int transport_state; 552 unsigned int transport_state;
581#define CMD_T_ABORTED (1 << 0) 553#define CMD_T_ABORTED (1 << 0)
582#define CMD_T_ACTIVE (1 << 1) 554#define CMD_T_ACTIVE (1 << 1)
@@ -588,11 +560,12 @@ struct se_cmd {
588#define CMD_T_LUN_STOP (1 << 7) 560#define CMD_T_LUN_STOP (1 << 7)
589#define CMD_T_LUN_FE_STOP (1 << 8) 561#define CMD_T_LUN_FE_STOP (1 << 8)
590#define CMD_T_DEV_ACTIVE (1 << 9) 562#define CMD_T_DEV_ACTIVE (1 << 9)
563#define CMD_T_REQUEST_STOP (1 << 10)
564#define CMD_T_BUSY (1 << 11)
591 spinlock_t t_state_lock; 565 spinlock_t t_state_lock;
592 struct completion t_transport_stop_comp; 566 struct completion t_transport_stop_comp;
593 struct completion transport_lun_fe_stop_comp; 567 struct completion transport_lun_fe_stop_comp;
594 struct completion transport_lun_stop_comp; 568 struct completion transport_lun_stop_comp;
595 struct scatterlist *t_tasks_sg_chained;
596 569
597 struct work_struct work; 570 struct work_struct work;
598 571
@@ -602,10 +575,15 @@ struct se_cmd {
602 struct scatterlist *t_bidi_data_sg; 575 struct scatterlist *t_bidi_data_sg;
603 unsigned int t_bidi_data_nents; 576 unsigned int t_bidi_data_nents;
604 577
605 /* Used for BIDI READ */ 578 struct list_head execute_list;
606 struct list_head t_task_list; 579 struct list_head state_list;
607 u32 t_task_list_num; 580 bool state_active;
581
582 /* old task stop completion, consider merging with some of the above */
583 struct completion task_stop_comp;
608 584
585 /* backend private data */
586 void *priv;
609}; 587};
610 588
611struct se_ua { 589struct se_ua {
@@ -731,7 +709,6 @@ struct se_dev_attrib {
731 u32 hw_block_size; 709 u32 hw_block_size;
732 u32 block_size; 710 u32 block_size;
733 u32 hw_max_sectors; 711 u32 hw_max_sectors;
734 u32 max_sectors;
735 u32 fabric_max_sectors; 712 u32 fabric_max_sectors;
736 u32 optimal_sectors; 713 u32 optimal_sectors;
737 u32 hw_queue_depth; 714 u32 hw_queue_depth;
@@ -829,8 +806,8 @@ struct se_device {
829 struct task_struct *process_thread; 806 struct task_struct *process_thread;
830 struct work_struct qf_work_queue; 807 struct work_struct qf_work_queue;
831 struct list_head delayed_cmd_list; 808 struct list_head delayed_cmd_list;
832 struct list_head execute_task_list; 809 struct list_head execute_list;
833 struct list_head state_task_list; 810 struct list_head state_list;
834 struct list_head qf_cmd_list; 811 struct list_head qf_cmd_list;
835 /* Pointer to associated SE HBA */ 812 /* Pointer to associated SE HBA */
836 struct se_hba *se_hba; 813 struct se_hba *se_hba;
diff --git a/include/target/target_core_fabric.h b/include/target/target_core_fabric.h
index 10c690809601..116959933f46 100644
--- a/include/target/target_core_fabric.h
+++ b/include/target/target_core_fabric.h
@@ -3,12 +3,6 @@
3 3
4struct target_core_fabric_ops { 4struct target_core_fabric_ops {
5 struct configfs_subsystem *tf_subsys; 5 struct configfs_subsystem *tf_subsys;
6 /*
7 * Optional to signal struct se_task->task_sg[] padding entries
8 * for scatterlist chaining using transport_do_task_sg_link(),
9 * disabled by default
10 */
11 bool task_sg_chaining;
12 char *(*get_fabric_name)(void); 6 char *(*get_fabric_name)(void);
13 u8 (*get_fabric_proto_ident)(struct se_portal_group *); 7 u8 (*get_fabric_proto_ident)(struct se_portal_group *);
14 char *(*tpg_get_wwn)(struct se_portal_group *); 8 char *(*tpg_get_wwn)(struct se_portal_group *);
@@ -102,7 +96,7 @@ void __transport_register_session(struct se_portal_group *,
102void transport_register_session(struct se_portal_group *, 96void transport_register_session(struct se_portal_group *,
103 struct se_node_acl *, struct se_session *, void *); 97 struct se_node_acl *, struct se_session *, void *);
104void target_get_session(struct se_session *); 98void target_get_session(struct se_session *);
105int target_put_session(struct se_session *); 99void target_put_session(struct se_session *);
106void transport_free_session(struct se_session *); 100void transport_free_session(struct se_session *);
107void target_put_nacl(struct se_node_acl *); 101void target_put_nacl(struct se_node_acl *);
108void transport_deregister_session_configfs(struct se_session *); 102void transport_deregister_session_configfs(struct se_session *);
@@ -112,7 +106,7 @@ void transport_deregister_session(struct se_session *);
112void transport_init_se_cmd(struct se_cmd *, struct target_core_fabric_ops *, 106void transport_init_se_cmd(struct se_cmd *, struct target_core_fabric_ops *,
113 struct se_session *, u32, int, int, unsigned char *); 107 struct se_session *, u32, int, int, unsigned char *);
114int transport_lookup_cmd_lun(struct se_cmd *, u32); 108int transport_lookup_cmd_lun(struct se_cmd *, u32);
115int transport_generic_allocate_tasks(struct se_cmd *, unsigned char *); 109int target_setup_cmd_from_cdb(struct se_cmd *, unsigned char *);
116void target_submit_cmd(struct se_cmd *, struct se_session *, unsigned char *, 110void target_submit_cmd(struct se_cmd *, struct se_session *, unsigned char *,
117 unsigned char *, u32, u32, int, int, int); 111 unsigned char *, u32, u32, int, int, int);
118int target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess, 112int target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess,
@@ -124,7 +118,6 @@ int transport_generic_handle_cdb_map(struct se_cmd *);
124int transport_generic_handle_data(struct se_cmd *); 118int transport_generic_handle_data(struct se_cmd *);
125int transport_generic_map_mem_to_cmd(struct se_cmd *cmd, 119int transport_generic_map_mem_to_cmd(struct se_cmd *cmd,
126 struct scatterlist *, u32, struct scatterlist *, u32); 120 struct scatterlist *, u32, struct scatterlist *, u32);
127void transport_do_task_sg_chain(struct se_cmd *);
128int transport_generic_new_cmd(struct se_cmd *); 121int transport_generic_new_cmd(struct se_cmd *);
129 122
130void transport_generic_process_write(struct se_cmd *); 123void transport_generic_process_write(struct se_cmd *);
generated by cgit v1.2.2 (git 2.25.0) at 2025-01-06 12:44:08 -0500