aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/target
diff options
context:
space:
mode:
authorLinus Torvalds <torvalds@linux-foundation.org>2013-07-11 15:57:19 -0400
committerLinus Torvalds <torvalds@linux-foundation.org>2013-07-11 15:57:19 -0400
commit6d2fa9e141ea56a571ec842fd4f3a86bea44a203 (patch)
treee419f95b7d080046f0f4d4d5041b42a0889f2f0a /drivers/target
parent0fb3767b0a5601dd0d528bc8dbefc0567a34b7ec (diff)
parentca40d24eb8fc3c194b4439493ecf6b2d703812b8 (diff)
Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending
Pull SCSI target updates from Nicholas Bellinger: "Lots of activity this round on performance improvements in target-core while benchmarking the prototype scsi-mq initiator code with vhost-scsi fabric ports, along with a number of iscsi/iser-target improvements and hardening fixes for exception path cases post v3.10 merge. The highlights include: - Make persistent reservations APTPL buffer allocated on-demand, and drop per t10_reservation buffer. (grover) - Make virtual LUN=0 a NULLIO device, and skip allocation of NULLIO device pages (grover) - Add transport_cmd_check_stop write_pending bit to avoid extra access of ->t_state_lock is WRITE I/O submission fast-path. (nab) - Drop unnecessary CMD_T_DEV_ACTIVE check from transport_lun_remove_cmd to avoid extra access of ->t_state_lock in release fast-path. (nab) - Avoid extra t_state_lock access in __target_execute_cmd fast-path (nab) - Drop unnecessary vhost-scsi wait_for_tasks=true usage + ->t_state_lock access in release fast-path. (nab) - Convert vhost-scsi to use modern se_cmd->cmd_kref TARGET_SCF_ACK_KREF usage (nab) - Add tracepoints for SCSI commands being processed (roland) - Refactoring of iscsi-target handling of ISCSI_OP_NOOP + ISCSI_OP_TEXT to be transport independent (nab) - Add iscsi-target SendTargets=$IQN support for in-band discovery (nab) - Add iser-target support for in-band discovery (nab + Or) - Add iscsi-target demo-mode TPG authentication context support (nab) - Fix isert_put_reject payload buffer post (nab) - Fix iscsit_add_reject* usage for iser (nab) - Fix iscsit_sequence_cmd reject handling for iser (nab) - Fix ISCSI_OP_SCSI_TMFUNC handling for iser (nab) - Fix session reset bug with RDMA_CM_EVENT_DISCONNECTED (nab) The last five iscsi/iser-target items are CC'ed to stable, as they do address issues present in v3.10 code. They are certainly larger than I'd like for stable patch set, but are important to ensure proper REJECT exception handling in iser-target for 3.10.y" * 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/nab/target-pending: (51 commits) iser-target: Ignore non TEXT + LOGOUT opcodes for discovery target: make queue_tm_rsp() return void target: remove unused codes from enum tcm_tmrsp_table iscsi-target: kstrtou* configfs attribute parameter cleanups iscsi-target: Fix tfc_tpg_auth_cit configfs length overflow iscsi-target: Fix tfc_tpg_nacl_auth_cit configfs length overflow iser-target: Add support for ISCSI_OP_TEXT opcode + payload handling iser-target: Rename sense_buf_[dma,len] to pdu_[dma,len] iser-target: Add vendor_err debug output target: Add (obsolete) checking for PMI/LBA fields in READ CAPACITY(10) target: Return correct sense data for IO past the end of a device target: Add tracepoints for SCSI commands being processed iser-target: Fix session reset bug with RDMA_CM_EVENT_DISCONNECTED iscsi-target: Fix ISCSI_OP_SCSI_TMFUNC handling for iser iscsi-target: Fix iscsit_sequence_cmd reject handling for iser iscsi-target: Fix iscsit_add_reject* usage for iser iser-target: Fix isert_put_reject payload buffer post iscsi-target: missing kfree() on error path iscsi-target: Drop left-over iscsi_conn->bad_hdr target: Make core_scsi3_update_and_write_aptpl return sense_reason_t ...
Diffstat (limited to 'drivers/target')
-rw-r--r--drivers/target/iscsi/iscsi_target.c768
-rw-r--r--drivers/target/iscsi/iscsi_target.h2
-rw-r--r--drivers/target/iscsi/iscsi_target_configfs.c184
-rw-r--r--drivers/target/iscsi/iscsi_target_core.h11
-rw-r--r--drivers/target/iscsi/iscsi_target_erl0.c8
-rw-r--r--drivers/target/iscsi/iscsi_target_erl1.c26
-rw-r--r--drivers/target/iscsi/iscsi_target_nego.c13
-rw-r--r--drivers/target/iscsi/iscsi_target_parameters.c3
-rw-r--r--drivers/target/iscsi/iscsi_target_util.c28
-rw-r--r--drivers/target/iscsi/iscsi_target_util.h3
-rw-r--r--drivers/target/loopback/tcm_loop.c3
-rw-r--r--drivers/target/sbp/sbp_target.c3
-rw-r--r--drivers/target/target_core_configfs.c13
-rw-r--r--drivers/target/target_core_device.c5
-rw-r--r--drivers/target/target_core_fabric_configfs.c21
-rw-r--r--drivers/target/target_core_pr.c499
-rw-r--r--drivers/target/target_core_pr.h2
-rw-r--r--drivers/target/target_core_rd.c5
-rw-r--r--drivers/target/target_core_sbc.c18
-rw-r--r--drivers/target/target_core_tmr.c12
-rw-r--r--drivers/target/target_core_transport.c87
-rw-r--r--drivers/target/tcm_fc/tcm_fc.h2
-rw-r--r--drivers/target/tcm_fc/tfc_cmd.c8
23 files changed, 877 insertions, 847 deletions
diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index d7705e5824fb..f73da43cdf9e 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -628,25 +628,18 @@ static void __exit iscsi_target_cleanup_module(void)
628} 628}
629 629
630static int iscsit_add_reject( 630static int iscsit_add_reject(
631 struct iscsi_conn *conn,
631 u8 reason, 632 u8 reason,
632 int fail_conn, 633 unsigned char *buf)
633 unsigned char *buf,
634 struct iscsi_conn *conn)
635{ 634{
636 struct iscsi_cmd *cmd; 635 struct iscsi_cmd *cmd;
637 struct iscsi_reject *hdr;
638 int ret;
639 636
640 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL); 637 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL);
641 if (!cmd) 638 if (!cmd)
642 return -1; 639 return -1;
643 640
644 cmd->iscsi_opcode = ISCSI_OP_REJECT; 641 cmd->iscsi_opcode = ISCSI_OP_REJECT;
645 if (fail_conn) 642 cmd->reject_reason = reason;
646 cmd->cmd_flags |= ICF_REJECT_FAIL_CONN;
647
648 hdr = (struct iscsi_reject *) cmd->pdu;
649 hdr->reason = reason;
650 643
651 cmd->buf_ptr = kmemdup(buf, ISCSI_HDR_LEN, GFP_KERNEL); 644 cmd->buf_ptr = kmemdup(buf, ISCSI_HDR_LEN, GFP_KERNEL);
652 if (!cmd->buf_ptr) { 645 if (!cmd->buf_ptr) {
@@ -662,23 +655,16 @@ static int iscsit_add_reject(
662 cmd->i_state = ISTATE_SEND_REJECT; 655 cmd->i_state = ISTATE_SEND_REJECT;
663 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); 656 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
664 657
665 ret = wait_for_completion_interruptible(&cmd->reject_comp); 658 return -1;
666 if (ret != 0)
667 return -1;
668
669 return (!fail_conn) ? 0 : -1;
670} 659}
671 660
672int iscsit_add_reject_from_cmd( 661static int iscsit_add_reject_from_cmd(
662 struct iscsi_cmd *cmd,
673 u8 reason, 663 u8 reason,
674 int fail_conn, 664 bool add_to_conn,
675 int add_to_conn, 665 unsigned char *buf)
676 unsigned char *buf,
677 struct iscsi_cmd *cmd)
678{ 666{
679 struct iscsi_conn *conn; 667 struct iscsi_conn *conn;
680 struct iscsi_reject *hdr;
681 int ret;
682 668
683 if (!cmd->conn) { 669 if (!cmd->conn) {
684 pr_err("cmd->conn is NULL for ITT: 0x%08x\n", 670 pr_err("cmd->conn is NULL for ITT: 0x%08x\n",
@@ -688,11 +674,7 @@ int iscsit_add_reject_from_cmd(
688 conn = cmd->conn; 674 conn = cmd->conn;
689 675
690 cmd->iscsi_opcode = ISCSI_OP_REJECT; 676 cmd->iscsi_opcode = ISCSI_OP_REJECT;
691 if (fail_conn) 677 cmd->reject_reason = reason;
692 cmd->cmd_flags |= ICF_REJECT_FAIL_CONN;
693
694 hdr = (struct iscsi_reject *) cmd->pdu;
695 hdr->reason = reason;
696 678
697 cmd->buf_ptr = kmemdup(buf, ISCSI_HDR_LEN, GFP_KERNEL); 679 cmd->buf_ptr = kmemdup(buf, ISCSI_HDR_LEN, GFP_KERNEL);
698 if (!cmd->buf_ptr) { 680 if (!cmd->buf_ptr) {
@@ -709,8 +691,6 @@ int iscsit_add_reject_from_cmd(
709 691
710 cmd->i_state = ISTATE_SEND_REJECT; 692 cmd->i_state = ISTATE_SEND_REJECT;
711 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); 693 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
712
713 ret = wait_for_completion_interruptible(&cmd->reject_comp);
714 /* 694 /*
715 * Perform the kref_put now if se_cmd has already been setup by 695 * Perform the kref_put now if se_cmd has already been setup by
716 * scsit_setup_scsi_cmd() 696 * scsit_setup_scsi_cmd()
@@ -719,12 +699,19 @@ int iscsit_add_reject_from_cmd(
719 pr_debug("iscsi reject: calling target_put_sess_cmd >>>>>>\n"); 699 pr_debug("iscsi reject: calling target_put_sess_cmd >>>>>>\n");
720 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd); 700 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
721 } 701 }
722 if (ret != 0) 702 return -1;
723 return -1; 703}
724 704
725 return (!fail_conn) ? 0 : -1; 705static int iscsit_add_reject_cmd(struct iscsi_cmd *cmd, u8 reason,
706 unsigned char *buf)
707{
708 return iscsit_add_reject_from_cmd(cmd, reason, true, buf);
709}
710
711int iscsit_reject_cmd(struct iscsi_cmd *cmd, u8 reason, unsigned char *buf)
712{
713 return iscsit_add_reject_from_cmd(cmd, reason, false, buf);
726} 714}
727EXPORT_SYMBOL(iscsit_add_reject_from_cmd);
728 715
729/* 716/*
730 * Map some portion of the allocated scatterlist to an iovec, suitable for 717 * Map some portion of the allocated scatterlist to an iovec, suitable for
@@ -844,8 +831,8 @@ int iscsit_setup_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
844 !(hdr->flags & ISCSI_FLAG_CMD_FINAL)) { 831 !(hdr->flags & ISCSI_FLAG_CMD_FINAL)) {
845 pr_err("ISCSI_FLAG_CMD_WRITE & ISCSI_FLAG_CMD_FINAL" 832 pr_err("ISCSI_FLAG_CMD_WRITE & ISCSI_FLAG_CMD_FINAL"
846 " not set. Bad iSCSI Initiator.\n"); 833 " not set. Bad iSCSI Initiator.\n");
847 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID, 834 return iscsit_add_reject_cmd(cmd,
848 1, 1, buf, cmd); 835 ISCSI_REASON_BOOKMARK_INVALID, buf);
849 } 836 }
850 837
851 if (((hdr->flags & ISCSI_FLAG_CMD_READ) || 838 if (((hdr->flags & ISCSI_FLAG_CMD_READ) ||
@@ -865,8 +852,8 @@ int iscsit_setup_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
865 pr_err("ISCSI_FLAG_CMD_READ or ISCSI_FLAG_CMD_WRITE" 852 pr_err("ISCSI_FLAG_CMD_READ or ISCSI_FLAG_CMD_WRITE"
866 " set when Expected Data Transfer Length is 0 for" 853 " set when Expected Data Transfer Length is 0 for"
867 " CDB: 0x%02x. Bad iSCSI Initiator.\n", hdr->cdb[0]); 854 " CDB: 0x%02x. Bad iSCSI Initiator.\n", hdr->cdb[0]);
868 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID, 855 return iscsit_add_reject_cmd(cmd,
869 1, 1, buf, cmd); 856 ISCSI_REASON_BOOKMARK_INVALID, buf);
870 } 857 }
871done: 858done:
872 859
@@ -875,62 +862,62 @@ done:
875 pr_err("ISCSI_FLAG_CMD_READ and/or ISCSI_FLAG_CMD_WRITE" 862 pr_err("ISCSI_FLAG_CMD_READ and/or ISCSI_FLAG_CMD_WRITE"
876 " MUST be set if Expected Data Transfer Length is not 0." 863 " MUST be set if Expected Data Transfer Length is not 0."
877 " Bad iSCSI Initiator\n"); 864 " Bad iSCSI Initiator\n");
878 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID, 865 return iscsit_add_reject_cmd(cmd,
879 1, 1, buf, cmd); 866 ISCSI_REASON_BOOKMARK_INVALID, buf);
880 } 867 }
881 868
882 if ((hdr->flags & ISCSI_FLAG_CMD_READ) && 869 if ((hdr->flags & ISCSI_FLAG_CMD_READ) &&
883 (hdr->flags & ISCSI_FLAG_CMD_WRITE)) { 870 (hdr->flags & ISCSI_FLAG_CMD_WRITE)) {
884 pr_err("Bidirectional operations not supported!\n"); 871 pr_err("Bidirectional operations not supported!\n");
885 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID, 872 return iscsit_add_reject_cmd(cmd,
886 1, 1, buf, cmd); 873 ISCSI_REASON_BOOKMARK_INVALID, buf);
887 } 874 }
888 875
889 if (hdr->opcode & ISCSI_OP_IMMEDIATE) { 876 if (hdr->opcode & ISCSI_OP_IMMEDIATE) {
890 pr_err("Illegally set Immediate Bit in iSCSI Initiator" 877 pr_err("Illegally set Immediate Bit in iSCSI Initiator"
891 " Scsi Command PDU.\n"); 878 " Scsi Command PDU.\n");
892 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID, 879 return iscsit_add_reject_cmd(cmd,
893 1, 1, buf, cmd); 880 ISCSI_REASON_BOOKMARK_INVALID, buf);
894 } 881 }
895 882
896 if (payload_length && !conn->sess->sess_ops->ImmediateData) { 883 if (payload_length && !conn->sess->sess_ops->ImmediateData) {
897 pr_err("ImmediateData=No but DataSegmentLength=%u," 884 pr_err("ImmediateData=No but DataSegmentLength=%u,"
898 " protocol error.\n", payload_length); 885 " protocol error.\n", payload_length);
899 return iscsit_add_reject_from_cmd(ISCSI_REASON_PROTOCOL_ERROR, 886 return iscsit_add_reject_cmd(cmd,
900 1, 1, buf, cmd); 887 ISCSI_REASON_PROTOCOL_ERROR, buf);
901 } 888 }
902 889
903 if ((be32_to_cpu(hdr->data_length )== payload_length) && 890 if ((be32_to_cpu(hdr->data_length) == payload_length) &&
904 (!(hdr->flags & ISCSI_FLAG_CMD_FINAL))) { 891 (!(hdr->flags & ISCSI_FLAG_CMD_FINAL))) {
905 pr_err("Expected Data Transfer Length and Length of" 892 pr_err("Expected Data Transfer Length and Length of"
906 " Immediate Data are the same, but ISCSI_FLAG_CMD_FINAL" 893 " Immediate Data are the same, but ISCSI_FLAG_CMD_FINAL"
907 " bit is not set protocol error\n"); 894 " bit is not set protocol error\n");
908 return iscsit_add_reject_from_cmd(ISCSI_REASON_PROTOCOL_ERROR, 895 return iscsit_add_reject_cmd(cmd,
909 1, 1, buf, cmd); 896 ISCSI_REASON_PROTOCOL_ERROR, buf);
910 } 897 }
911 898
912 if (payload_length > be32_to_cpu(hdr->data_length)) { 899 if (payload_length > be32_to_cpu(hdr->data_length)) {
913 pr_err("DataSegmentLength: %u is greater than" 900 pr_err("DataSegmentLength: %u is greater than"
914 " EDTL: %u, protocol error.\n", payload_length, 901 " EDTL: %u, protocol error.\n", payload_length,
915 hdr->data_length); 902 hdr->data_length);
916 return iscsit_add_reject_from_cmd(ISCSI_REASON_PROTOCOL_ERROR, 903 return iscsit_add_reject_cmd(cmd,
917 1, 1, buf, cmd); 904 ISCSI_REASON_PROTOCOL_ERROR, buf);
918 } 905 }
919 906
920 if (payload_length > conn->conn_ops->MaxXmitDataSegmentLength) { 907 if (payload_length > conn->conn_ops->MaxXmitDataSegmentLength) {
921 pr_err("DataSegmentLength: %u is greater than" 908 pr_err("DataSegmentLength: %u is greater than"
922 " MaxXmitDataSegmentLength: %u, protocol error.\n", 909 " MaxXmitDataSegmentLength: %u, protocol error.\n",
923 payload_length, conn->conn_ops->MaxXmitDataSegmentLength); 910 payload_length, conn->conn_ops->MaxXmitDataSegmentLength);
924 return iscsit_add_reject_from_cmd(ISCSI_REASON_PROTOCOL_ERROR, 911 return iscsit_add_reject_cmd(cmd,
925 1, 1, buf, cmd); 912 ISCSI_REASON_PROTOCOL_ERROR, buf);
926 } 913 }
927 914
928 if (payload_length > conn->sess->sess_ops->FirstBurstLength) { 915 if (payload_length > conn->sess->sess_ops->FirstBurstLength) {
929 pr_err("DataSegmentLength: %u is greater than" 916 pr_err("DataSegmentLength: %u is greater than"
930 " FirstBurstLength: %u, protocol error.\n", 917 " FirstBurstLength: %u, protocol error.\n",
931 payload_length, conn->sess->sess_ops->FirstBurstLength); 918 payload_length, conn->sess->sess_ops->FirstBurstLength);
932 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID, 919 return iscsit_add_reject_cmd(cmd,
933 1, 1, buf, cmd); 920 ISCSI_REASON_BOOKMARK_INVALID, buf);
934 } 921 }
935 922
936 data_direction = (hdr->flags & ISCSI_FLAG_CMD_WRITE) ? DMA_TO_DEVICE : 923 data_direction = (hdr->flags & ISCSI_FLAG_CMD_WRITE) ? DMA_TO_DEVICE :
@@ -985,9 +972,8 @@ done:
985 972
986 dr = iscsit_allocate_datain_req(); 973 dr = iscsit_allocate_datain_req();
987 if (!dr) 974 if (!dr)
988 return iscsit_add_reject_from_cmd( 975 return iscsit_add_reject_cmd(cmd,
989 ISCSI_REASON_BOOKMARK_NO_RESOURCES, 976 ISCSI_REASON_BOOKMARK_NO_RESOURCES, buf);
990 1, 1, buf, cmd);
991 977
992 iscsit_attach_datain_req(cmd, dr); 978 iscsit_attach_datain_req(cmd, dr);
993 } 979 }
@@ -1015,18 +1001,16 @@ done:
1015 cmd->sense_reason = target_setup_cmd_from_cdb(&cmd->se_cmd, hdr->cdb); 1001 cmd->sense_reason = target_setup_cmd_from_cdb(&cmd->se_cmd, hdr->cdb);
1016 if (cmd->sense_reason) { 1002 if (cmd->sense_reason) {
1017 if (cmd->sense_reason == TCM_OUT_OF_RESOURCES) { 1003 if (cmd->sense_reason == TCM_OUT_OF_RESOURCES) {
1018 return iscsit_add_reject_from_cmd( 1004 return iscsit_add_reject_cmd(cmd,
1019 ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1005 ISCSI_REASON_BOOKMARK_NO_RESOURCES, buf);
1020 1, 1, buf, cmd);
1021 } 1006 }
1022 1007
1023 goto attach_cmd; 1008 goto attach_cmd;
1024 } 1009 }
1025 1010
1026 if (iscsit_build_pdu_and_seq_lists(cmd, payload_length) < 0) { 1011 if (iscsit_build_pdu_and_seq_lists(cmd, payload_length) < 0) {
1027 return iscsit_add_reject_from_cmd( 1012 return iscsit_add_reject_cmd(cmd,
1028 ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1013 ISCSI_REASON_BOOKMARK_NO_RESOURCES, buf);
1029 1, 1, buf, cmd);
1030 } 1014 }
1031 1015
1032attach_cmd: 1016attach_cmd:
@@ -1068,17 +1052,13 @@ int iscsit_process_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1068 * be acknowledged. (See below) 1052 * be acknowledged. (See below)
1069 */ 1053 */
1070 if (!cmd->immediate_data) { 1054 if (!cmd->immediate_data) {
1071 cmdsn_ret = iscsit_sequence_cmd(conn, cmd, hdr->cmdsn); 1055 cmdsn_ret = iscsit_sequence_cmd(conn, cmd,
1072 if (cmdsn_ret == CMDSN_LOWER_THAN_EXP) { 1056 (unsigned char *)hdr, hdr->cmdsn);
1073 if (!cmd->sense_reason) 1057 if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER)
1074 return 0; 1058 return -1;
1075 1059 else if (cmdsn_ret == CMDSN_LOWER_THAN_EXP) {
1076 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd); 1060 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
1077 return 0; 1061 return 0;
1078 } else if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER) {
1079 return iscsit_add_reject_from_cmd(
1080 ISCSI_REASON_PROTOCOL_ERROR,
1081 1, 0, (unsigned char *)hdr, cmd);
1082 } 1062 }
1083 } 1063 }
1084 1064
@@ -1103,6 +1083,9 @@ int iscsit_process_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1103 * iscsit_check_received_cmdsn() in iscsit_get_immediate_data() below. 1083 * iscsit_check_received_cmdsn() in iscsit_get_immediate_data() below.
1104 */ 1084 */
1105 if (cmd->sense_reason) { 1085 if (cmd->sense_reason) {
1086 if (cmd->reject_reason)
1087 return 0;
1088
1106 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd); 1089 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
1107 return 1; 1090 return 1;
1108 } 1091 }
@@ -1111,10 +1094,8 @@ int iscsit_process_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1111 * the backend memory allocation. 1094 * the backend memory allocation.
1112 */ 1095 */
1113 cmd->sense_reason = transport_generic_new_cmd(&cmd->se_cmd); 1096 cmd->sense_reason = transport_generic_new_cmd(&cmd->se_cmd);
1114 if (cmd->sense_reason) { 1097 if (cmd->sense_reason)
1115 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
1116 return 1; 1098 return 1;
1117 }
1118 1099
1119 return 0; 1100 return 0;
1120} 1101}
@@ -1124,6 +1105,7 @@ static int
1124iscsit_get_immediate_data(struct iscsi_cmd *cmd, struct iscsi_scsi_req *hdr, 1105iscsit_get_immediate_data(struct iscsi_cmd *cmd, struct iscsi_scsi_req *hdr,
1125 bool dump_payload) 1106 bool dump_payload)
1126{ 1107{
1108 struct iscsi_conn *conn = cmd->conn;
1127 int cmdsn_ret = 0, immed_ret = IMMEDIATE_DATA_NORMAL_OPERATION; 1109 int cmdsn_ret = 0, immed_ret = IMMEDIATE_DATA_NORMAL_OPERATION;
1128 /* 1110 /*
1129 * Special case for Unsupported SAM WRITE Opcodes and ImmediateData=Yes. 1111 * Special case for Unsupported SAM WRITE Opcodes and ImmediateData=Yes.
@@ -1140,20 +1122,25 @@ after_immediate_data:
1140 * DataCRC, check against ExpCmdSN/MaxCmdSN if 1122 * DataCRC, check against ExpCmdSN/MaxCmdSN if
1141 * Immediate Bit is not set. 1123 * Immediate Bit is not set.
1142 */ 1124 */
1143 cmdsn_ret = iscsit_sequence_cmd(cmd->conn, cmd, hdr->cmdsn); 1125 cmdsn_ret = iscsit_sequence_cmd(cmd->conn, cmd,
1126 (unsigned char *)hdr, hdr->cmdsn);
1127 if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER) {
1128 return -1;
1129 } else if (cmdsn_ret == CMDSN_LOWER_THAN_EXP) {
1130 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
1131 return 0;
1132 }
1144 1133
1145 if (cmd->sense_reason) { 1134 if (cmd->sense_reason) {
1146 if (iscsit_dump_data_payload(cmd->conn, 1135 int rc;
1147 cmd->first_burst_len, 1) < 0) 1136
1148 return -1; 1137 rc = iscsit_dump_data_payload(cmd->conn,
1138 cmd->first_burst_len, 1);
1139 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
1140 return rc;
1149 } else if (cmd->unsolicited_data) 1141 } else if (cmd->unsolicited_data)
1150 iscsit_set_unsoliticed_dataout(cmd); 1142 iscsit_set_unsoliticed_dataout(cmd);
1151 1143
1152 if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER)
1153 return iscsit_add_reject_from_cmd(
1154 ISCSI_REASON_PROTOCOL_ERROR,
1155 1, 0, (unsigned char *)hdr, cmd);
1156
1157 } else if (immed_ret == IMMEDIATE_DATA_ERL1_CRC_FAILURE) { 1144 } else if (immed_ret == IMMEDIATE_DATA_ERL1_CRC_FAILURE) {
1158 /* 1145 /*
1159 * Immediate Data failed DataCRC and ERL>=1, 1146 * Immediate Data failed DataCRC and ERL>=1,
@@ -1184,15 +1171,14 @@ iscsit_handle_scsi_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1184 1171
1185 rc = iscsit_setup_scsi_cmd(conn, cmd, buf); 1172 rc = iscsit_setup_scsi_cmd(conn, cmd, buf);
1186 if (rc < 0) 1173 if (rc < 0)
1187 return rc; 1174 return 0;
1188 /* 1175 /*
1189 * Allocation iovecs needed for struct socket operations for 1176 * Allocation iovecs needed for struct socket operations for
1190 * traditional iSCSI block I/O. 1177 * traditional iSCSI block I/O.
1191 */ 1178 */
1192 if (iscsit_allocate_iovecs(cmd) < 0) { 1179 if (iscsit_allocate_iovecs(cmd) < 0) {
1193 return iscsit_add_reject_from_cmd( 1180 return iscsit_add_reject_cmd(cmd,
1194 ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1181 ISCSI_REASON_BOOKMARK_NO_RESOURCES, buf);
1195 1, 0, buf, cmd);
1196 } 1182 }
1197 immed_data = cmd->immediate_data; 1183 immed_data = cmd->immediate_data;
1198 1184
@@ -1277,14 +1263,13 @@ iscsit_check_dataout_hdr(struct iscsi_conn *conn, unsigned char *buf,
1277 struct iscsi_data *hdr = (struct iscsi_data *)buf; 1263 struct iscsi_data *hdr = (struct iscsi_data *)buf;
1278 struct iscsi_cmd *cmd = NULL; 1264 struct iscsi_cmd *cmd = NULL;
1279 struct se_cmd *se_cmd; 1265 struct se_cmd *se_cmd;
1280 unsigned long flags;
1281 u32 payload_length = ntoh24(hdr->dlength); 1266 u32 payload_length = ntoh24(hdr->dlength);
1282 int rc; 1267 int rc;
1283 1268
1284 if (!payload_length) { 1269 if (!payload_length) {
1285 pr_err("DataOUT payload is ZERO, protocol error.\n"); 1270 pr_err("DataOUT payload is ZERO, protocol error.\n");
1286 return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 1271 return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
1287 buf, conn); 1272 buf);
1288 } 1273 }
1289 1274
1290 /* iSCSI write */ 1275 /* iSCSI write */
@@ -1301,8 +1286,8 @@ iscsit_check_dataout_hdr(struct iscsi_conn *conn, unsigned char *buf,
1301 pr_err("DataSegmentLength: %u is greater than" 1286 pr_err("DataSegmentLength: %u is greater than"
1302 " MaxXmitDataSegmentLength: %u\n", payload_length, 1287 " MaxXmitDataSegmentLength: %u\n", payload_length,
1303 conn->conn_ops->MaxXmitDataSegmentLength); 1288 conn->conn_ops->MaxXmitDataSegmentLength);
1304 return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 1289 return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
1305 buf, conn); 1290 buf);
1306 } 1291 }
1307 1292
1308 cmd = iscsit_find_cmd_from_itt_or_dump(conn, hdr->itt, 1293 cmd = iscsit_find_cmd_from_itt_or_dump(conn, hdr->itt,
@@ -1325,8 +1310,7 @@ iscsit_check_dataout_hdr(struct iscsi_conn *conn, unsigned char *buf,
1325 if (cmd->data_direction != DMA_TO_DEVICE) { 1310 if (cmd->data_direction != DMA_TO_DEVICE) {
1326 pr_err("Command ITT: 0x%08x received DataOUT for a" 1311 pr_err("Command ITT: 0x%08x received DataOUT for a"
1327 " NON-WRITE command.\n", cmd->init_task_tag); 1312 " NON-WRITE command.\n", cmd->init_task_tag);
1328 return iscsit_add_reject_from_cmd(ISCSI_REASON_PROTOCOL_ERROR, 1313 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR, buf);
1329 1, 0, buf, cmd);
1330 } 1314 }
1331 se_cmd = &cmd->se_cmd; 1315 se_cmd = &cmd->se_cmd;
1332 iscsit_mod_dataout_timer(cmd); 1316 iscsit_mod_dataout_timer(cmd);
@@ -1335,8 +1319,7 @@ iscsit_check_dataout_hdr(struct iscsi_conn *conn, unsigned char *buf,
1335 pr_err("DataOut Offset: %u, Length %u greater than" 1319 pr_err("DataOut Offset: %u, Length %u greater than"
1336 " iSCSI Command EDTL %u, protocol error.\n", 1320 " iSCSI Command EDTL %u, protocol error.\n",
1337 hdr->offset, payload_length, cmd->se_cmd.data_length); 1321 hdr->offset, payload_length, cmd->se_cmd.data_length);
1338 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID, 1322 return iscsit_reject_cmd(cmd, ISCSI_REASON_BOOKMARK_INVALID, buf);
1339 1, 0, buf, cmd);
1340 } 1323 }
1341 1324
1342 if (cmd->unsolicited_data) { 1325 if (cmd->unsolicited_data) {
@@ -1356,14 +1339,9 @@ iscsit_check_dataout_hdr(struct iscsi_conn *conn, unsigned char *buf,
1356 */ 1339 */
1357 1340
1358 /* Something's amiss if we're not in WRITE_PENDING state... */ 1341 /* Something's amiss if we're not in WRITE_PENDING state... */
1359 spin_lock_irqsave(&se_cmd->t_state_lock, flags);
1360 WARN_ON(se_cmd->t_state != TRANSPORT_WRITE_PENDING); 1342 WARN_ON(se_cmd->t_state != TRANSPORT_WRITE_PENDING);
1361 spin_unlock_irqrestore(&se_cmd->t_state_lock, flags);
1362
1363 spin_lock_irqsave(&se_cmd->t_state_lock, flags);
1364 if (!(se_cmd->se_cmd_flags & SCF_SUPPORTED_SAM_OPCODE)) 1343 if (!(se_cmd->se_cmd_flags & SCF_SUPPORTED_SAM_OPCODE))
1365 dump_unsolicited_data = 1; 1344 dump_unsolicited_data = 1;
1366 spin_unlock_irqrestore(&se_cmd->t_state_lock, flags);
1367 1345
1368 if (dump_unsolicited_data) { 1346 if (dump_unsolicited_data) {
1369 /* 1347 /*
@@ -1528,7 +1506,7 @@ static int iscsit_handle_data_out(struct iscsi_conn *conn, unsigned char *buf)
1528 1506
1529 rc = iscsit_check_dataout_hdr(conn, buf, &cmd); 1507 rc = iscsit_check_dataout_hdr(conn, buf, &cmd);
1530 if (rc < 0) 1508 if (rc < 0)
1531 return rc; 1509 return 0;
1532 else if (!cmd) 1510 else if (!cmd)
1533 return 0; 1511 return 0;
1534 1512
@@ -1541,24 +1519,16 @@ static int iscsit_handle_data_out(struct iscsi_conn *conn, unsigned char *buf)
1541 return iscsit_check_dataout_payload(cmd, hdr, data_crc_failed); 1519 return iscsit_check_dataout_payload(cmd, hdr, data_crc_failed);
1542} 1520}
1543 1521
1544int iscsit_handle_nop_out(struct iscsi_conn *conn, struct iscsi_cmd *cmd, 1522int iscsit_setup_nop_out(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1545 unsigned char *buf) 1523 struct iscsi_nopout *hdr)
1546{ 1524{
1547 unsigned char *ping_data = NULL; 1525 u32 payload_length = ntoh24(hdr->dlength);
1548 int cmdsn_ret, niov = 0, ret = 0, rx_got, rx_size;
1549 u32 checksum, data_crc, padding = 0, payload_length;
1550 struct iscsi_cmd *cmd_p = NULL;
1551 struct kvec *iov = NULL;
1552 struct iscsi_nopout *hdr;
1553
1554 hdr = (struct iscsi_nopout *) buf;
1555 payload_length = ntoh24(hdr->dlength);
1556 1526
1557 if (hdr->itt == RESERVED_ITT && !(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 1527 if (hdr->itt == RESERVED_ITT && !(hdr->opcode & ISCSI_OP_IMMEDIATE)) {
1558 pr_err("NOPOUT ITT is reserved, but Immediate Bit is" 1528 pr_err("NOPOUT ITT is reserved, but Immediate Bit is"
1559 " not set, protocol error.\n"); 1529 " not set, protocol error.\n");
1560 return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 1530 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
1561 buf, conn); 1531 (unsigned char *)hdr);
1562 } 1532 }
1563 1533
1564 if (payload_length > conn->conn_ops->MaxXmitDataSegmentLength) { 1534 if (payload_length > conn->conn_ops->MaxXmitDataSegmentLength) {
@@ -1566,8 +1536,8 @@ int iscsit_handle_nop_out(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1566 " greater than MaxXmitDataSegmentLength: %u, protocol" 1536 " greater than MaxXmitDataSegmentLength: %u, protocol"
1567 " error.\n", payload_length, 1537 " error.\n", payload_length,
1568 conn->conn_ops->MaxXmitDataSegmentLength); 1538 conn->conn_ops->MaxXmitDataSegmentLength);
1569 return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 1539 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
1570 buf, conn); 1540 (unsigned char *)hdr);
1571 } 1541 }
1572 1542
1573 pr_debug("Got NOPOUT Ping %s ITT: 0x%08x, TTT: 0x%08x," 1543 pr_debug("Got NOPOUT Ping %s ITT: 0x%08x, TTT: 0x%08x,"
@@ -1583,11 +1553,6 @@ int iscsit_handle_nop_out(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1583 * can contain ping data. 1553 * can contain ping data.
1584 */ 1554 */
1585 if (hdr->ttt == cpu_to_be32(0xFFFFFFFF)) { 1555 if (hdr->ttt == cpu_to_be32(0xFFFFFFFF)) {
1586 if (!cmd)
1587 return iscsit_add_reject(
1588 ISCSI_REASON_BOOKMARK_NO_RESOURCES,
1589 1, buf, conn);
1590
1591 cmd->iscsi_opcode = ISCSI_OP_NOOP_OUT; 1556 cmd->iscsi_opcode = ISCSI_OP_NOOP_OUT;
1592 cmd->i_state = ISTATE_SEND_NOPIN; 1557 cmd->i_state = ISTATE_SEND_NOPIN;
1593 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1558 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ?
@@ -1599,8 +1564,85 @@ int iscsit_handle_nop_out(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1599 cmd->data_direction = DMA_NONE; 1564 cmd->data_direction = DMA_NONE;
1600 } 1565 }
1601 1566
1567 return 0;
1568}
1569EXPORT_SYMBOL(iscsit_setup_nop_out);
1570
1571int iscsit_process_nop_out(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1572 struct iscsi_nopout *hdr)
1573{
1574 struct iscsi_cmd *cmd_p = NULL;
1575 int cmdsn_ret = 0;
1576 /*
1577 * Initiator is expecting a NopIN ping reply..
1578 */
1579 if (hdr->itt != RESERVED_ITT) {
1580 BUG_ON(!cmd);
1581
1582 spin_lock_bh(&conn->cmd_lock);
1583 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
1584 spin_unlock_bh(&conn->cmd_lock);
1585
1586 iscsit_ack_from_expstatsn(conn, be32_to_cpu(hdr->exp_statsn));
1587
1588 if (hdr->opcode & ISCSI_OP_IMMEDIATE) {
1589 iscsit_add_cmd_to_response_queue(cmd, conn,
1590 cmd->i_state);
1591 return 0;
1592 }
1593
1594 cmdsn_ret = iscsit_sequence_cmd(conn, cmd,
1595 (unsigned char *)hdr, hdr->cmdsn);
1596 if (cmdsn_ret == CMDSN_LOWER_THAN_EXP)
1597 return 0;
1598 if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER)
1599 return -1;
1600
1601 return 0;
1602 }
1603 /*
1604 * This was a response to a unsolicited NOPIN ping.
1605 */
1606 if (hdr->ttt != cpu_to_be32(0xFFFFFFFF)) {
1607 cmd_p = iscsit_find_cmd_from_ttt(conn, be32_to_cpu(hdr->ttt));
1608 if (!cmd_p)
1609 return -EINVAL;
1610
1611 iscsit_stop_nopin_response_timer(conn);
1612
1613 cmd_p->i_state = ISTATE_REMOVE;
1614 iscsit_add_cmd_to_immediate_queue(cmd_p, conn, cmd_p->i_state);
1615
1616 iscsit_start_nopin_timer(conn);
1617 return 0;
1618 }
1619 /*
1620 * Otherwise, initiator is not expecting a NOPIN is response.
1621 * Just ignore for now.
1622 */
1623 return 0;
1624}
1625EXPORT_SYMBOL(iscsit_process_nop_out);
1626
1627static int iscsit_handle_nop_out(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1628 unsigned char *buf)
1629{
1630 unsigned char *ping_data = NULL;
1631 struct iscsi_nopout *hdr = (struct iscsi_nopout *)buf;
1632 struct kvec *iov = NULL;
1633 u32 payload_length = ntoh24(hdr->dlength);
1634 int ret;
1635
1636 ret = iscsit_setup_nop_out(conn, cmd, hdr);
1637 if (ret < 0)
1638 return 0;
1639 /*
1640 * Handle NOP-OUT payload for traditional iSCSI sockets
1641 */
1602 if (payload_length && hdr->ttt == cpu_to_be32(0xFFFFFFFF)) { 1642 if (payload_length && hdr->ttt == cpu_to_be32(0xFFFFFFFF)) {
1603 rx_size = payload_length; 1643 u32 checksum, data_crc, padding = 0;
1644 int niov = 0, rx_got, rx_size = payload_length;
1645
1604 ping_data = kzalloc(payload_length + 1, GFP_KERNEL); 1646 ping_data = kzalloc(payload_length + 1, GFP_KERNEL);
1605 if (!ping_data) { 1647 if (!ping_data) {
1606 pr_err("Unable to allocate memory for" 1648 pr_err("Unable to allocate memory for"
@@ -1679,76 +1721,14 @@ int iscsit_handle_nop_out(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1679 pr_debug("Ping Data: \"%s\"\n", ping_data); 1721 pr_debug("Ping Data: \"%s\"\n", ping_data);
1680 } 1722 }
1681 1723
1682 if (hdr->itt != RESERVED_ITT) { 1724 return iscsit_process_nop_out(conn, cmd, hdr);
1683 if (!cmd) {
1684 pr_err("Checking CmdSN for NOPOUT,"
1685 " but cmd is NULL!\n");
1686 return -1;
1687 }
1688 /*
1689 * Initiator is expecting a NopIN ping reply,
1690 */
1691 spin_lock_bh(&conn->cmd_lock);
1692 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
1693 spin_unlock_bh(&conn->cmd_lock);
1694
1695 iscsit_ack_from_expstatsn(conn, be32_to_cpu(hdr->exp_statsn));
1696
1697 if (hdr->opcode & ISCSI_OP_IMMEDIATE) {
1698 iscsit_add_cmd_to_response_queue(cmd, conn,
1699 cmd->i_state);
1700 return 0;
1701 }
1702
1703 cmdsn_ret = iscsit_sequence_cmd(conn, cmd, hdr->cmdsn);
1704 if (cmdsn_ret == CMDSN_LOWER_THAN_EXP) {
1705 ret = 0;
1706 goto ping_out;
1707 }
1708 if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER)
1709 return iscsit_add_reject_from_cmd(
1710 ISCSI_REASON_PROTOCOL_ERROR,
1711 1, 0, buf, cmd);
1712
1713 return 0;
1714 }
1715
1716 if (hdr->ttt != cpu_to_be32(0xFFFFFFFF)) {
1717 /*
1718 * This was a response to a unsolicited NOPIN ping.
1719 */
1720 cmd_p = iscsit_find_cmd_from_ttt(conn, be32_to_cpu(hdr->ttt));
1721 if (!cmd_p)
1722 return -1;
1723
1724 iscsit_stop_nopin_response_timer(conn);
1725
1726 cmd_p->i_state = ISTATE_REMOVE;
1727 iscsit_add_cmd_to_immediate_queue(cmd_p, conn, cmd_p->i_state);
1728 iscsit_start_nopin_timer(conn);
1729 } else {
1730 /*
1731 * Initiator is not expecting a NOPIN is response.
1732 * Just ignore for now.
1733 *
1734 * iSCSI v19-91 10.18
1735 * "A NOP-OUT may also be used to confirm a changed
1736 * ExpStatSN if another PDU will not be available
1737 * for a long time."
1738 */
1739 ret = 0;
1740 goto out;
1741 }
1742
1743 return 0;
1744out: 1725out:
1745 if (cmd) 1726 if (cmd)
1746 iscsit_free_cmd(cmd, false); 1727 iscsit_free_cmd(cmd, false);
1747ping_out: 1728
1748 kfree(ping_data); 1729 kfree(ping_data);
1749 return ret; 1730 return ret;
1750} 1731}
1751EXPORT_SYMBOL(iscsit_handle_nop_out);
1752 1732
1753int 1733int
1754iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd, 1734iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
@@ -1757,8 +1737,8 @@ iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1757 struct se_tmr_req *se_tmr; 1737 struct se_tmr_req *se_tmr;
1758 struct iscsi_tmr_req *tmr_req; 1738 struct iscsi_tmr_req *tmr_req;
1759 struct iscsi_tm *hdr; 1739 struct iscsi_tm *hdr;
1760 int out_of_order_cmdsn = 0; 1740 int out_of_order_cmdsn = 0, ret;
1761 int ret; 1741 bool sess_ref = false;
1762 u8 function; 1742 u8 function;
1763 1743
1764 hdr = (struct iscsi_tm *) buf; 1744 hdr = (struct iscsi_tm *) buf;
@@ -1782,8 +1762,8 @@ iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1782 pr_err("Task Management Request TASK_REASSIGN not" 1762 pr_err("Task Management Request TASK_REASSIGN not"
1783 " issued as immediate command, bad iSCSI Initiator" 1763 " issued as immediate command, bad iSCSI Initiator"
1784 "implementation\n"); 1764 "implementation\n");
1785 return iscsit_add_reject_from_cmd(ISCSI_REASON_PROTOCOL_ERROR, 1765 return iscsit_add_reject_cmd(cmd,
1786 1, 1, buf, cmd); 1766 ISCSI_REASON_PROTOCOL_ERROR, buf);
1787 } 1767 }
1788 if ((function != ISCSI_TM_FUNC_ABORT_TASK) && 1768 if ((function != ISCSI_TM_FUNC_ABORT_TASK) &&
1789 be32_to_cpu(hdr->refcmdsn) != ISCSI_RESERVED_TAG) 1769 be32_to_cpu(hdr->refcmdsn) != ISCSI_RESERVED_TAG)
@@ -1795,9 +1775,9 @@ iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1795 if (!cmd->tmr_req) { 1775 if (!cmd->tmr_req) {
1796 pr_err("Unable to allocate memory for" 1776 pr_err("Unable to allocate memory for"
1797 " Task Management command!\n"); 1777 " Task Management command!\n");
1798 return iscsit_add_reject_from_cmd( 1778 return iscsit_add_reject_cmd(cmd,
1799 ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1779 ISCSI_REASON_BOOKMARK_NO_RESOURCES,
1800 1, 1, buf, cmd); 1780 buf);
1801 } 1781 }
1802 1782
1803 /* 1783 /*
@@ -1814,6 +1794,9 @@ iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1814 conn->sess->se_sess, 0, DMA_NONE, 1794 conn->sess->se_sess, 0, DMA_NONE,
1815 MSG_SIMPLE_TAG, cmd->sense_buffer + 2); 1795 MSG_SIMPLE_TAG, cmd->sense_buffer + 2);
1816 1796
1797 target_get_sess_cmd(conn->sess->se_sess, &cmd->se_cmd, true);
1798 sess_ref = true;
1799
1817 switch (function) { 1800 switch (function) {
1818 case ISCSI_TM_FUNC_ABORT_TASK: 1801 case ISCSI_TM_FUNC_ABORT_TASK:
1819 tcm_function = TMR_ABORT_TASK; 1802 tcm_function = TMR_ABORT_TASK;
@@ -1839,17 +1822,15 @@ iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1839 default: 1822 default:
1840 pr_err("Unknown iSCSI TMR Function:" 1823 pr_err("Unknown iSCSI TMR Function:"
1841 " 0x%02x\n", function); 1824 " 0x%02x\n", function);
1842 return iscsit_add_reject_from_cmd( 1825 return iscsit_add_reject_cmd(cmd,
1843 ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1826 ISCSI_REASON_BOOKMARK_NO_RESOURCES, buf);
1844 1, 1, buf, cmd);
1845 } 1827 }
1846 1828
1847 ret = core_tmr_alloc_req(&cmd->se_cmd, cmd->tmr_req, 1829 ret = core_tmr_alloc_req(&cmd->se_cmd, cmd->tmr_req,
1848 tcm_function, GFP_KERNEL); 1830 tcm_function, GFP_KERNEL);
1849 if (ret < 0) 1831 if (ret < 0)
1850 return iscsit_add_reject_from_cmd( 1832 return iscsit_add_reject_cmd(cmd,
1851 ISCSI_REASON_BOOKMARK_NO_RESOURCES, 1833 ISCSI_REASON_BOOKMARK_NO_RESOURCES, buf);
1852 1, 1, buf, cmd);
1853 1834
1854 cmd->tmr_req->se_tmr_req = cmd->se_cmd.se_tmr_req; 1835 cmd->tmr_req->se_tmr_req = cmd->se_cmd.se_tmr_req;
1855 } 1836 }
@@ -1908,9 +1889,8 @@ iscsit_handle_task_mgt_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1908 break; 1889 break;
1909 1890
1910 if (iscsit_check_task_reassign_expdatasn(tmr_req, conn) < 0) 1891 if (iscsit_check_task_reassign_expdatasn(tmr_req, conn) < 0)
1911 return iscsit_add_reject_from_cmd( 1892 return iscsit_add_reject_cmd(cmd,
1912 ISCSI_REASON_BOOKMARK_INVALID, 1, 1, 1893 ISCSI_REASON_BOOKMARK_INVALID, buf);
1913 buf, cmd);
1914 break; 1894 break;
1915 default: 1895 default:
1916 pr_err("Unknown TMR function: 0x%02x, protocol" 1896 pr_err("Unknown TMR function: 0x%02x, protocol"
@@ -1928,15 +1908,13 @@ attach:
1928 spin_unlock_bh(&conn->cmd_lock); 1908 spin_unlock_bh(&conn->cmd_lock);
1929 1909
1930 if (!(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 1910 if (!(hdr->opcode & ISCSI_OP_IMMEDIATE)) {
1931 int cmdsn_ret = iscsit_sequence_cmd(conn, cmd, hdr->cmdsn); 1911 int cmdsn_ret = iscsit_sequence_cmd(conn, cmd, buf, hdr->cmdsn);
1932 if (cmdsn_ret == CMDSN_HIGHER_THAN_EXP) 1912 if (cmdsn_ret == CMDSN_HIGHER_THAN_EXP)
1933 out_of_order_cmdsn = 1; 1913 out_of_order_cmdsn = 1;
1934 else if (cmdsn_ret == CMDSN_LOWER_THAN_EXP) 1914 else if (cmdsn_ret == CMDSN_LOWER_THAN_EXP)
1935 return 0; 1915 return 0;
1936 else if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER) 1916 else if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER)
1937 return iscsit_add_reject_from_cmd( 1917 return -1;
1938 ISCSI_REASON_PROTOCOL_ERROR,
1939 1, 0, buf, cmd);
1940 } 1918 }
1941 iscsit_ack_from_expstatsn(conn, be32_to_cpu(hdr->exp_statsn)); 1919 iscsit_ack_from_expstatsn(conn, be32_to_cpu(hdr->exp_statsn));
1942 1920
@@ -1956,51 +1934,135 @@ attach:
1956 * For connection recovery, this is also the default action for 1934 * For connection recovery, this is also the default action for
1957 * TMR TASK_REASSIGN. 1935 * TMR TASK_REASSIGN.
1958 */ 1936 */
1937 if (sess_ref) {
1938 pr_debug("Handle TMR, using sess_ref=true check\n");
1939 target_put_sess_cmd(conn->sess->se_sess, &cmd->se_cmd);
1940 }
1941
1959 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state); 1942 iscsit_add_cmd_to_response_queue(cmd, conn, cmd->i_state);
1960 return 0; 1943 return 0;
1961} 1944}
1962EXPORT_SYMBOL(iscsit_handle_task_mgt_cmd); 1945EXPORT_SYMBOL(iscsit_handle_task_mgt_cmd);
1963 1946
1964/* #warning FIXME: Support Text Command parameters besides SendTargets */ 1947/* #warning FIXME: Support Text Command parameters besides SendTargets */
1965static int iscsit_handle_text_cmd( 1948int
1966 struct iscsi_conn *conn, 1949iscsit_setup_text_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1967 unsigned char *buf) 1950 struct iscsi_text *hdr)
1968{ 1951{
1969 char *text_ptr, *text_in; 1952 u32 payload_length = ntoh24(hdr->dlength);
1970 int cmdsn_ret, niov = 0, rx_got, rx_size;
1971 u32 checksum = 0, data_crc = 0, payload_length;
1972 u32 padding = 0, pad_bytes = 0, text_length = 0;
1973 struct iscsi_cmd *cmd;
1974 struct kvec iov[3];
1975 struct iscsi_text *hdr;
1976
1977 hdr = (struct iscsi_text *) buf;
1978 payload_length = ntoh24(hdr->dlength);
1979 1953
1980 if (payload_length > conn->conn_ops->MaxXmitDataSegmentLength) { 1954 if (payload_length > conn->conn_ops->MaxXmitDataSegmentLength) {
1981 pr_err("Unable to accept text parameter length: %u" 1955 pr_err("Unable to accept text parameter length: %u"
1982 "greater than MaxXmitDataSegmentLength %u.\n", 1956 "greater than MaxXmitDataSegmentLength %u.\n",
1983 payload_length, conn->conn_ops->MaxXmitDataSegmentLength); 1957 payload_length, conn->conn_ops->MaxXmitDataSegmentLength);
1984 return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 1958 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
1985 buf, conn); 1959 (unsigned char *)hdr);
1986 } 1960 }
1987 1961
1988 pr_debug("Got Text Request: ITT: 0x%08x, CmdSN: 0x%08x," 1962 pr_debug("Got Text Request: ITT: 0x%08x, CmdSN: 0x%08x,"
1989 " ExpStatSN: 0x%08x, Length: %u\n", hdr->itt, hdr->cmdsn, 1963 " ExpStatSN: 0x%08x, Length: %u\n", hdr->itt, hdr->cmdsn,
1990 hdr->exp_statsn, payload_length); 1964 hdr->exp_statsn, payload_length);
1991 1965
1992 rx_size = text_length = payload_length; 1966 cmd->iscsi_opcode = ISCSI_OP_TEXT;
1993 if (text_length) { 1967 cmd->i_state = ISTATE_SEND_TEXTRSP;
1994 text_in = kzalloc(text_length, GFP_KERNEL); 1968 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0);
1969 conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt;
1970 cmd->targ_xfer_tag = 0xFFFFFFFF;
1971 cmd->cmd_sn = be32_to_cpu(hdr->cmdsn);
1972 cmd->exp_stat_sn = be32_to_cpu(hdr->exp_statsn);
1973 cmd->data_direction = DMA_NONE;
1974
1975 return 0;
1976}
1977EXPORT_SYMBOL(iscsit_setup_text_cmd);
1978
1979int
1980iscsit_process_text_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
1981 struct iscsi_text *hdr)
1982{
1983 unsigned char *text_in = cmd->text_in_ptr, *text_ptr;
1984 int cmdsn_ret;
1985
1986 if (!text_in) {
1987 pr_err("Unable to locate text_in buffer for sendtargets"
1988 " discovery\n");
1989 goto reject;
1990 }
1991 if (strncmp("SendTargets", text_in, 11) != 0) {
1992 pr_err("Received Text Data that is not"
1993 " SendTargets, cannot continue.\n");
1994 goto reject;
1995 }
1996 text_ptr = strchr(text_in, '=');
1997 if (!text_ptr) {
1998 pr_err("No \"=\" separator found in Text Data,"
1999 " cannot continue.\n");
2000 goto reject;
2001 }
2002 if (!strncmp("=All", text_ptr, 4)) {
2003 cmd->cmd_flags |= IFC_SENDTARGETS_ALL;
2004 } else if (!strncmp("=iqn.", text_ptr, 5) ||
2005 !strncmp("=eui.", text_ptr, 5)) {
2006 cmd->cmd_flags |= IFC_SENDTARGETS_SINGLE;
2007 } else {
2008 pr_err("Unable to locate valid SendTargets=%s value\n", text_ptr);
2009 goto reject;
2010 }
2011
2012 spin_lock_bh(&conn->cmd_lock);
2013 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
2014 spin_unlock_bh(&conn->cmd_lock);
2015
2016 iscsit_ack_from_expstatsn(conn, be32_to_cpu(hdr->exp_statsn));
2017
2018 if (!(hdr->opcode & ISCSI_OP_IMMEDIATE)) {
2019 cmdsn_ret = iscsit_sequence_cmd(conn, cmd,
2020 (unsigned char *)hdr, hdr->cmdsn);
2021 if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER)
2022 return -1;
2023
2024 return 0;
2025 }
2026
2027 return iscsit_execute_cmd(cmd, 0);
2028
2029reject:
2030 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR,
2031 (unsigned char *)hdr);
2032}
2033EXPORT_SYMBOL(iscsit_process_text_cmd);
2034
2035static int
2036iscsit_handle_text_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
2037 unsigned char *buf)
2038{
2039 struct iscsi_text *hdr = (struct iscsi_text *)buf;
2040 char *text_in = NULL;
2041 u32 payload_length = ntoh24(hdr->dlength);
2042 int rx_size, rc;
2043
2044 rc = iscsit_setup_text_cmd(conn, cmd, hdr);
2045 if (rc < 0)
2046 return 0;
2047
2048 rx_size = payload_length;
2049 if (payload_length) {
2050 u32 checksum = 0, data_crc = 0;
2051 u32 padding = 0, pad_bytes = 0;
2052 int niov = 0, rx_got;
2053 struct kvec iov[3];
2054
2055 text_in = kzalloc(payload_length, GFP_KERNEL);
1995 if (!text_in) { 2056 if (!text_in) {
1996 pr_err("Unable to allocate memory for" 2057 pr_err("Unable to allocate memory for"
1997 " incoming text parameters\n"); 2058 " incoming text parameters\n");
1998 return -1; 2059 goto reject;
1999 } 2060 }
2061 cmd->text_in_ptr = text_in;
2000 2062
2001 memset(iov, 0, 3 * sizeof(struct kvec)); 2063 memset(iov, 0, 3 * sizeof(struct kvec));
2002 iov[niov].iov_base = text_in; 2064 iov[niov].iov_base = text_in;
2003 iov[niov++].iov_len = text_length; 2065 iov[niov++].iov_len = payload_length;
2004 2066
2005 padding = ((-payload_length) & 3); 2067 padding = ((-payload_length) & 3);
2006 if (padding != 0) { 2068 if (padding != 0) {
@@ -2017,14 +2079,12 @@ static int iscsit_handle_text_cmd(
2017 } 2079 }
2018 2080
2019 rx_got = rx_data(conn, &iov[0], niov, rx_size); 2081 rx_got = rx_data(conn, &iov[0], niov, rx_size);
2020 if (rx_got != rx_size) { 2082 if (rx_got != rx_size)
2021 kfree(text_in); 2083 goto reject;
2022 return -1;
2023 }
2024 2084
2025 if (conn->conn_ops->DataDigest) { 2085 if (conn->conn_ops->DataDigest) {
2026 iscsit_do_crypto_hash_buf(&conn->conn_rx_hash, 2086 iscsit_do_crypto_hash_buf(&conn->conn_rx_hash,
2027 text_in, text_length, 2087 text_in, payload_length,
2028 padding, (u8 *)&pad_bytes, 2088 padding, (u8 *)&pad_bytes,
2029 (u8 *)&data_crc); 2089 (u8 *)&data_crc);
2030 2090
@@ -2036,8 +2096,7 @@ static int iscsit_handle_text_cmd(
2036 pr_err("Unable to recover from" 2096 pr_err("Unable to recover from"
2037 " Text Data digest failure while in" 2097 " Text Data digest failure while in"
2038 " ERL=0.\n"); 2098 " ERL=0.\n");
2039 kfree(text_in); 2099 goto reject;
2040 return -1;
2041 } else { 2100 } else {
2042 /* 2101 /*
2043 * Silently drop this PDU and let the 2102 * Silently drop this PDU and let the
@@ -2052,68 +2111,22 @@ static int iscsit_handle_text_cmd(
2052 } else { 2111 } else {
2053 pr_debug("Got CRC32C DataDigest" 2112 pr_debug("Got CRC32C DataDigest"
2054 " 0x%08x for %u bytes of text data.\n", 2113 " 0x%08x for %u bytes of text data.\n",
2055 checksum, text_length); 2114 checksum, payload_length);
2056 } 2115 }
2057 } 2116 }
2058 text_in[text_length - 1] = '\0'; 2117 text_in[payload_length - 1] = '\0';
2059 pr_debug("Successfully read %d bytes of text" 2118 pr_debug("Successfully read %d bytes of text"
2060 " data.\n", text_length); 2119 " data.\n", payload_length);
2061
2062 if (strncmp("SendTargets", text_in, 11) != 0) {
2063 pr_err("Received Text Data that is not"
2064 " SendTargets, cannot continue.\n");
2065 kfree(text_in);
2066 return -1;
2067 }
2068 text_ptr = strchr(text_in, '=');
2069 if (!text_ptr) {
2070 pr_err("No \"=\" separator found in Text Data,"
2071 " cannot continue.\n");
2072 kfree(text_in);
2073 return -1;
2074 }
2075 if (strncmp("=All", text_ptr, 4) != 0) {
2076 pr_err("Unable to locate All value for"
2077 " SendTargets key, cannot continue.\n");
2078 kfree(text_in);
2079 return -1;
2080 }
2081/*#warning Support SendTargets=(iSCSI Target Name/Nothing) values. */
2082 kfree(text_in);
2083 } 2120 }
2084 2121
2085 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL); 2122 return iscsit_process_text_cmd(conn, cmd, hdr);
2086 if (!cmd)
2087 return iscsit_add_reject(ISCSI_REASON_BOOKMARK_NO_RESOURCES,
2088 1, buf, conn);
2089
2090 cmd->iscsi_opcode = ISCSI_OP_TEXT;
2091 cmd->i_state = ISTATE_SEND_TEXTRSP;
2092 cmd->immediate_cmd = ((hdr->opcode & ISCSI_OP_IMMEDIATE) ? 1 : 0);
2093 conn->sess->init_task_tag = cmd->init_task_tag = hdr->itt;
2094 cmd->targ_xfer_tag = 0xFFFFFFFF;
2095 cmd->cmd_sn = be32_to_cpu(hdr->cmdsn);
2096 cmd->exp_stat_sn = be32_to_cpu(hdr->exp_statsn);
2097 cmd->data_direction = DMA_NONE;
2098
2099 spin_lock_bh(&conn->cmd_lock);
2100 list_add_tail(&cmd->i_conn_node, &conn->conn_cmd_list);
2101 spin_unlock_bh(&conn->cmd_lock);
2102 2123
2103 iscsit_ack_from_expstatsn(conn, be32_to_cpu(hdr->exp_statsn)); 2124reject:
2104 2125 kfree(cmd->text_in_ptr);
2105 if (!(hdr->opcode & ISCSI_OP_IMMEDIATE)) { 2126 cmd->text_in_ptr = NULL;
2106 cmdsn_ret = iscsit_sequence_cmd(conn, cmd, hdr->cmdsn); 2127 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR, buf);
2107 if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER)
2108 return iscsit_add_reject_from_cmd(
2109 ISCSI_REASON_PROTOCOL_ERROR,
2110 1, 0, buf, cmd);
2111
2112 return 0;
2113 }
2114
2115 return iscsit_execute_cmd(cmd, 0);
2116} 2128}
2129EXPORT_SYMBOL(iscsit_handle_text_cmd);
2117 2130
2118int iscsit_logout_closesession(struct iscsi_cmd *cmd, struct iscsi_conn *conn) 2131int iscsit_logout_closesession(struct iscsi_cmd *cmd, struct iscsi_conn *conn)
2119{ 2132{
@@ -2292,14 +2305,11 @@ iscsit_handle_logout_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
2292 if (ret < 0) 2305 if (ret < 0)
2293 return ret; 2306 return ret;
2294 } else { 2307 } else {
2295 cmdsn_ret = iscsit_sequence_cmd(conn, cmd, hdr->cmdsn); 2308 cmdsn_ret = iscsit_sequence_cmd(conn, cmd, buf, hdr->cmdsn);
2296 if (cmdsn_ret == CMDSN_LOWER_THAN_EXP) { 2309 if (cmdsn_ret == CMDSN_LOWER_THAN_EXP)
2297 logout_remove = 0; 2310 logout_remove = 0;
2298 } else if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER) { 2311 else if (cmdsn_ret == CMDSN_ERROR_CANNOT_RECOVER)
2299 return iscsit_add_reject_from_cmd( 2312 return -1;
2300 ISCSI_REASON_PROTOCOL_ERROR,
2301 1, 0, buf, cmd);
2302 }
2303 } 2313 }
2304 2314
2305 return logout_remove; 2315 return logout_remove;
@@ -2323,8 +2333,8 @@ static int iscsit_handle_snack(
2323 if (!conn->sess->sess_ops->ErrorRecoveryLevel) { 2333 if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
2324 pr_err("Initiator sent SNACK request while in" 2334 pr_err("Initiator sent SNACK request while in"
2325 " ErrorRecoveryLevel=0.\n"); 2335 " ErrorRecoveryLevel=0.\n");
2326 return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 2336 return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
2327 buf, conn); 2337 buf);
2328 } 2338 }
2329 /* 2339 /*
2330 * SNACK_DATA and SNACK_R2T are both 0, so check which function to 2340 * SNACK_DATA and SNACK_R2T are both 0, so check which function to
@@ -2348,13 +2358,13 @@ static int iscsit_handle_snack(
2348 case ISCSI_FLAG_SNACK_TYPE_RDATA: 2358 case ISCSI_FLAG_SNACK_TYPE_RDATA:
2349 /* FIXME: Support R-Data SNACK */ 2359 /* FIXME: Support R-Data SNACK */
2350 pr_err("R-Data SNACK Not Supported.\n"); 2360 pr_err("R-Data SNACK Not Supported.\n");
2351 return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 2361 return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
2352 buf, conn); 2362 buf);
2353 default: 2363 default:
2354 pr_err("Unknown SNACK type 0x%02x, protocol" 2364 pr_err("Unknown SNACK type 0x%02x, protocol"
2355 " error.\n", hdr->flags & 0x0f); 2365 " error.\n", hdr->flags & 0x0f);
2356 return iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 2366 return iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
2357 buf, conn); 2367 buf);
2358 } 2368 }
2359 2369
2360 return 0; 2370 return 0;
@@ -2426,14 +2436,14 @@ static int iscsit_handle_immediate_data(
2426 pr_err("Unable to recover from" 2436 pr_err("Unable to recover from"
2427 " Immediate Data digest failure while" 2437 " Immediate Data digest failure while"
2428 " in ERL=0.\n"); 2438 " in ERL=0.\n");
2429 iscsit_add_reject_from_cmd( 2439 iscsit_reject_cmd(cmd,
2430 ISCSI_REASON_DATA_DIGEST_ERROR, 2440 ISCSI_REASON_DATA_DIGEST_ERROR,
2431 1, 0, (unsigned char *)hdr, cmd); 2441 (unsigned char *)hdr);
2432 return IMMEDIATE_DATA_CANNOT_RECOVER; 2442 return IMMEDIATE_DATA_CANNOT_RECOVER;
2433 } else { 2443 } else {
2434 iscsit_add_reject_from_cmd( 2444 iscsit_reject_cmd(cmd,
2435 ISCSI_REASON_DATA_DIGEST_ERROR, 2445 ISCSI_REASON_DATA_DIGEST_ERROR,
2436 0, 0, (unsigned char *)hdr, cmd); 2446 (unsigned char *)hdr);
2437 return IMMEDIATE_DATA_ERL1_CRC_FAILURE; 2447 return IMMEDIATE_DATA_ERL1_CRC_FAILURE;
2438 } 2448 }
2439 } else { 2449 } else {
@@ -3276,8 +3286,6 @@ static u8 iscsit_convert_tcm_tmr_rsp(struct se_tmr_req *se_tmr)
3276 return ISCSI_TMF_RSP_NO_LUN; 3286 return ISCSI_TMF_RSP_NO_LUN;
3277 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED: 3287 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED:
3278 return ISCSI_TMF_RSP_NOT_SUPPORTED; 3288 return ISCSI_TMF_RSP_NOT_SUPPORTED;
3279 case TMR_FUNCTION_AUTHORIZATION_FAILED:
3280 return ISCSI_TMF_RSP_AUTH_FAILED;
3281 case TMR_FUNCTION_REJECTED: 3289 case TMR_FUNCTION_REJECTED:
3282 default: 3290 default:
3283 return ISCSI_TMF_RSP_REJECTED; 3291 return ISCSI_TMF_RSP_REJECTED;
@@ -3372,6 +3380,7 @@ static int iscsit_build_sendtargets_response(struct iscsi_cmd *cmd)
3372 struct iscsi_tpg_np *tpg_np; 3380 struct iscsi_tpg_np *tpg_np;
3373 int buffer_len, end_of_buf = 0, len = 0, payload_len = 0; 3381 int buffer_len, end_of_buf = 0, len = 0, payload_len = 0;
3374 unsigned char buf[ISCSI_IQN_LEN+12]; /* iqn + "TargetName=" + \0 */ 3382 unsigned char buf[ISCSI_IQN_LEN+12]; /* iqn + "TargetName=" + \0 */
3383 unsigned char *text_in = cmd->text_in_ptr, *text_ptr = NULL;
3375 3384
3376 buffer_len = max(conn->conn_ops->MaxRecvDataSegmentLength, 3385 buffer_len = max(conn->conn_ops->MaxRecvDataSegmentLength,
3377 SENDTARGETS_BUF_LIMIT); 3386 SENDTARGETS_BUF_LIMIT);
@@ -3382,9 +3391,31 @@ static int iscsit_build_sendtargets_response(struct iscsi_cmd *cmd)
3382 " response.\n"); 3391 " response.\n");
3383 return -ENOMEM; 3392 return -ENOMEM;
3384 } 3393 }
3394 /*
3395 * Locate pointer to iqn./eui. string for IFC_SENDTARGETS_SINGLE
3396 * explicit case..
3397 */
3398 if (cmd->cmd_flags & IFC_SENDTARGETS_SINGLE) {
3399 text_ptr = strchr(text_in, '=');
3400 if (!text_ptr) {
3401 pr_err("Unable to locate '=' string in text_in:"
3402 " %s\n", text_in);
3403 kfree(payload);
3404 return -EINVAL;
3405 }
3406 /*
3407 * Skip over '=' character..
3408 */
3409 text_ptr += 1;
3410 }
3385 3411
3386 spin_lock(&tiqn_lock); 3412 spin_lock(&tiqn_lock);
3387 list_for_each_entry(tiqn, &g_tiqn_list, tiqn_list) { 3413 list_for_each_entry(tiqn, &g_tiqn_list, tiqn_list) {
3414 if ((cmd->cmd_flags & IFC_SENDTARGETS_SINGLE) &&
3415 strcmp(tiqn->tiqn, text_ptr)) {
3416 continue;
3417 }
3418
3388 len = sprintf(buf, "TargetName=%s", tiqn->tiqn); 3419 len = sprintf(buf, "TargetName=%s", tiqn->tiqn);
3389 len += 1; 3420 len += 1;
3390 3421
@@ -3438,6 +3469,9 @@ static int iscsit_build_sendtargets_response(struct iscsi_cmd *cmd)
3438eob: 3469eob:
3439 if (end_of_buf) 3470 if (end_of_buf)
3440 break; 3471 break;
3472
3473 if (cmd->cmd_flags & IFC_SENDTARGETS_SINGLE)
3474 break;
3441 } 3475 }
3442 spin_unlock(&tiqn_lock); 3476 spin_unlock(&tiqn_lock);
3443 3477
@@ -3446,52 +3480,62 @@ eob:
3446 return payload_len; 3480 return payload_len;
3447} 3481}
3448 3482
3449/* 3483int
3450 * FIXME: Add support for F_BIT and C_BIT when the length is longer than 3484iscsit_build_text_rsp(struct iscsi_cmd *cmd, struct iscsi_conn *conn,
3451 * MaxRecvDataSegmentLength. 3485 struct iscsi_text_rsp *hdr)
3452 */
3453static int iscsit_send_text_rsp(
3454 struct iscsi_cmd *cmd,
3455 struct iscsi_conn *conn)
3456{ 3486{
3457 struct iscsi_text_rsp *hdr; 3487 int text_length, padding;
3458 struct kvec *iov;
3459 u32 padding = 0, tx_size = 0;
3460 int text_length, iov_count = 0;
3461 3488
3462 text_length = iscsit_build_sendtargets_response(cmd); 3489 text_length = iscsit_build_sendtargets_response(cmd);
3463 if (text_length < 0) 3490 if (text_length < 0)
3464 return text_length; 3491 return text_length;
3465 3492
3493 hdr->opcode = ISCSI_OP_TEXT_RSP;
3494 hdr->flags |= ISCSI_FLAG_CMD_FINAL;
3466 padding = ((-text_length) & 3); 3495 padding = ((-text_length) & 3);
3467 if (padding != 0) {
3468 memset(cmd->buf_ptr + text_length, 0, padding);
3469 pr_debug("Attaching %u additional bytes for"
3470 " padding.\n", padding);
3471 }
3472
3473 hdr = (struct iscsi_text_rsp *) cmd->pdu;
3474 memset(hdr, 0, ISCSI_HDR_LEN);
3475 hdr->opcode = ISCSI_OP_TEXT_RSP;
3476 hdr->flags |= ISCSI_FLAG_CMD_FINAL;
3477 hton24(hdr->dlength, text_length); 3496 hton24(hdr->dlength, text_length);
3478 hdr->itt = cmd->init_task_tag; 3497 hdr->itt = cmd->init_task_tag;
3479 hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag); 3498 hdr->ttt = cpu_to_be32(cmd->targ_xfer_tag);
3480 cmd->stat_sn = conn->stat_sn++; 3499 cmd->stat_sn = conn->stat_sn++;
3481 hdr->statsn = cpu_to_be32(cmd->stat_sn); 3500 hdr->statsn = cpu_to_be32(cmd->stat_sn);
3482 3501
3483 iscsit_increment_maxcmdsn(cmd, conn->sess); 3502 iscsit_increment_maxcmdsn(cmd, conn->sess);
3484 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn); 3503 hdr->exp_cmdsn = cpu_to_be32(conn->sess->exp_cmd_sn);
3485 hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn); 3504 hdr->max_cmdsn = cpu_to_be32(conn->sess->max_cmd_sn);
3486 3505
3487 iov = &cmd->iov_misc[0]; 3506 pr_debug("Built Text Response: ITT: 0x%08x, StatSN: 0x%08x,"
3507 " Length: %u, CID: %hu\n", cmd->init_task_tag, cmd->stat_sn,
3508 text_length, conn->cid);
3509
3510 return text_length + padding;
3511}
3512EXPORT_SYMBOL(iscsit_build_text_rsp);
3488 3513
3514/*
3515 * FIXME: Add support for F_BIT and C_BIT when the length is longer than
3516 * MaxRecvDataSegmentLength.
3517 */
3518static int iscsit_send_text_rsp(
3519 struct iscsi_cmd *cmd,
3520 struct iscsi_conn *conn)
3521{
3522 struct iscsi_text_rsp *hdr = (struct iscsi_text_rsp *)cmd->pdu;
3523 struct kvec *iov;
3524 u32 tx_size = 0;
3525 int text_length, iov_count = 0, rc;
3526
3527 rc = iscsit_build_text_rsp(cmd, conn, hdr);
3528 if (rc < 0)
3529 return rc;
3530
3531 text_length = rc;
3532 iov = &cmd->iov_misc[0];
3489 iov[iov_count].iov_base = cmd->pdu; 3533 iov[iov_count].iov_base = cmd->pdu;
3490 iov[iov_count++].iov_len = ISCSI_HDR_LEN; 3534 iov[iov_count++].iov_len = ISCSI_HDR_LEN;
3491 iov[iov_count].iov_base = cmd->buf_ptr; 3535 iov[iov_count].iov_base = cmd->buf_ptr;
3492 iov[iov_count++].iov_len = text_length + padding; 3536 iov[iov_count++].iov_len = text_length;
3493 3537
3494 tx_size += (ISCSI_HDR_LEN + text_length + padding); 3538 tx_size += (ISCSI_HDR_LEN + text_length);
3495 3539
3496 if (conn->conn_ops->HeaderDigest) { 3540 if (conn->conn_ops->HeaderDigest) {
3497 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN]; 3541 u32 *header_digest = (u32 *)&cmd->pdu[ISCSI_HDR_LEN];
@@ -3507,7 +3551,7 @@ static int iscsit_send_text_rsp(
3507 3551
3508 if (conn->conn_ops->DataDigest) { 3552 if (conn->conn_ops->DataDigest) {
3509 iscsit_do_crypto_hash_buf(&conn->conn_tx_hash, 3553 iscsit_do_crypto_hash_buf(&conn->conn_tx_hash,
3510 cmd->buf_ptr, (text_length + padding), 3554 cmd->buf_ptr, text_length,
3511 0, NULL, (u8 *)&cmd->data_crc); 3555 0, NULL, (u8 *)&cmd->data_crc);
3512 3556
3513 iov[iov_count].iov_base = &cmd->data_crc; 3557 iov[iov_count].iov_base = &cmd->data_crc;
@@ -3515,16 +3559,13 @@ static int iscsit_send_text_rsp(
3515 tx_size += ISCSI_CRC_LEN; 3559 tx_size += ISCSI_CRC_LEN;
3516 3560
3517 pr_debug("Attaching DataDigest for %u bytes of text" 3561 pr_debug("Attaching DataDigest for %u bytes of text"
3518 " data, CRC 0x%08x\n", (text_length + padding), 3562 " data, CRC 0x%08x\n", text_length,
3519 cmd->data_crc); 3563 cmd->data_crc);
3520 } 3564 }
3521 3565
3522 cmd->iov_misc_count = iov_count; 3566 cmd->iov_misc_count = iov_count;
3523 cmd->tx_size = tx_size; 3567 cmd->tx_size = tx_size;
3524 3568
3525 pr_debug("Built Text Response: ITT: 0x%08x, StatSN: 0x%08x,"
3526 " Length: %u, CID: %hu\n", cmd->init_task_tag, cmd->stat_sn,
3527 text_length, conn->cid);
3528 return 0; 3569 return 0;
3529} 3570}
3530 3571
@@ -3533,6 +3574,7 @@ iscsit_build_reject(struct iscsi_cmd *cmd, struct iscsi_conn *conn,
3533 struct iscsi_reject *hdr) 3574 struct iscsi_reject *hdr)
3534{ 3575{
3535 hdr->opcode = ISCSI_OP_REJECT; 3576 hdr->opcode = ISCSI_OP_REJECT;
3577 hdr->reason = cmd->reject_reason;
3536 hdr->flags |= ISCSI_FLAG_CMD_FINAL; 3578 hdr->flags |= ISCSI_FLAG_CMD_FINAL;
3537 hton24(hdr->dlength, ISCSI_HDR_LEN); 3579 hton24(hdr->dlength, ISCSI_HDR_LEN);
3538 hdr->ffffffff = cpu_to_be32(0xffffffff); 3580 hdr->ffffffff = cpu_to_be32(0xffffffff);
@@ -3806,18 +3848,11 @@ check_rsp_state:
3806 case ISTATE_SEND_STATUS_RECOVERY: 3848 case ISTATE_SEND_STATUS_RECOVERY:
3807 case ISTATE_SEND_TEXTRSP: 3849 case ISTATE_SEND_TEXTRSP:
3808 case ISTATE_SEND_TASKMGTRSP: 3850 case ISTATE_SEND_TASKMGTRSP:
3851 case ISTATE_SEND_REJECT:
3809 spin_lock_bh(&cmd->istate_lock); 3852 spin_lock_bh(&cmd->istate_lock);
3810 cmd->i_state = ISTATE_SENT_STATUS; 3853 cmd->i_state = ISTATE_SENT_STATUS;
3811 spin_unlock_bh(&cmd->istate_lock); 3854 spin_unlock_bh(&cmd->istate_lock);
3812 break; 3855 break;
3813 case ISTATE_SEND_REJECT:
3814 if (cmd->cmd_flags & ICF_REJECT_FAIL_CONN) {
3815 cmd->cmd_flags &= ~ICF_REJECT_FAIL_CONN;
3816 complete(&cmd->reject_comp);
3817 goto err;
3818 }
3819 complete(&cmd->reject_comp);
3820 break;
3821 default: 3856 default:
3822 pr_err("Unknown Opcode: 0x%02x ITT:" 3857 pr_err("Unknown Opcode: 0x%02x ITT:"
3823 " 0x%08x, i_state: %d on CID: %hu\n", 3858 " 0x%08x, i_state: %d on CID: %hu\n",
@@ -3922,8 +3957,7 @@ static int iscsi_target_rx_opcode(struct iscsi_conn *conn, unsigned char *buf)
3922 case ISCSI_OP_SCSI_CMD: 3957 case ISCSI_OP_SCSI_CMD:
3923 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL); 3958 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL);
3924 if (!cmd) 3959 if (!cmd)
3925 return iscsit_add_reject(ISCSI_REASON_BOOKMARK_NO_RESOURCES, 3960 goto reject;
3926 1, buf, conn);
3927 3961
3928 ret = iscsit_handle_scsi_cmd(conn, cmd, buf); 3962 ret = iscsit_handle_scsi_cmd(conn, cmd, buf);
3929 break; 3963 break;
@@ -3935,27 +3969,28 @@ static int iscsi_target_rx_opcode(struct iscsi_conn *conn, unsigned char *buf)
3935 if (hdr->ttt == cpu_to_be32(0xFFFFFFFF)) { 3969 if (hdr->ttt == cpu_to_be32(0xFFFFFFFF)) {
3936 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL); 3970 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL);
3937 if (!cmd) 3971 if (!cmd)
3938 return iscsit_add_reject(ISCSI_REASON_BOOKMARK_NO_RESOURCES, 3972 goto reject;
3939 1, buf, conn);
3940 } 3973 }
3941 ret = iscsit_handle_nop_out(conn, cmd, buf); 3974 ret = iscsit_handle_nop_out(conn, cmd, buf);
3942 break; 3975 break;
3943 case ISCSI_OP_SCSI_TMFUNC: 3976 case ISCSI_OP_SCSI_TMFUNC:
3944 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL); 3977 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL);
3945 if (!cmd) 3978 if (!cmd)
3946 return iscsit_add_reject(ISCSI_REASON_BOOKMARK_NO_RESOURCES, 3979 goto reject;
3947 1, buf, conn);
3948 3980
3949 ret = iscsit_handle_task_mgt_cmd(conn, cmd, buf); 3981 ret = iscsit_handle_task_mgt_cmd(conn, cmd, buf);
3950 break; 3982 break;
3951 case ISCSI_OP_TEXT: 3983 case ISCSI_OP_TEXT:
3952 ret = iscsit_handle_text_cmd(conn, buf); 3984 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL);
3985 if (!cmd)
3986 goto reject;
3987
3988 ret = iscsit_handle_text_cmd(conn, cmd, buf);
3953 break; 3989 break;
3954 case ISCSI_OP_LOGOUT: 3990 case ISCSI_OP_LOGOUT:
3955 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL); 3991 cmd = iscsit_allocate_cmd(conn, GFP_KERNEL);
3956 if (!cmd) 3992 if (!cmd)
3957 return iscsit_add_reject(ISCSI_REASON_BOOKMARK_NO_RESOURCES, 3993 goto reject;
3958 1, buf, conn);
3959 3994
3960 ret = iscsit_handle_logout_cmd(conn, cmd, buf); 3995 ret = iscsit_handle_logout_cmd(conn, cmd, buf);
3961 if (ret > 0) 3996 if (ret > 0)
@@ -3987,6 +4022,8 @@ static int iscsi_target_rx_opcode(struct iscsi_conn *conn, unsigned char *buf)
3987 } 4022 }
3988 4023
3989 return ret; 4024 return ret;
4025reject:
4026 return iscsit_add_reject(conn, ISCSI_REASON_BOOKMARK_NO_RESOURCES, buf);
3990} 4027}
3991 4028
3992int iscsi_target_rx_thread(void *arg) 4029int iscsi_target_rx_thread(void *arg)
@@ -4039,11 +4076,6 @@ restart:
4039 goto transport_err; 4076 goto transport_err;
4040 } 4077 }
4041 4078
4042 /*
4043 * Set conn->bad_hdr for use with REJECT PDUs.
4044 */
4045 memcpy(&conn->bad_hdr, &buffer, ISCSI_HDR_LEN);
4046
4047 if (conn->conn_ops->HeaderDigest) { 4079 if (conn->conn_ops->HeaderDigest) {
4048 iov.iov_base = &digest; 4080 iov.iov_base = &digest;
4049 iov.iov_len = ISCSI_CRC_LEN; 4081 iov.iov_len = ISCSI_CRC_LEN;
@@ -4086,8 +4118,8 @@ restart:
4086 (!(opcode & ISCSI_OP_LOGOUT)))) { 4118 (!(opcode & ISCSI_OP_LOGOUT)))) {
4087 pr_err("Received illegal iSCSI Opcode: 0x%02x" 4119 pr_err("Received illegal iSCSI Opcode: 0x%02x"
4088 " while in Discovery Session, rejecting.\n", opcode); 4120 " while in Discovery Session, rejecting.\n", opcode);
4089 iscsit_add_reject(ISCSI_REASON_PROTOCOL_ERROR, 1, 4121 iscsit_add_reject(conn, ISCSI_REASON_PROTOCOL_ERROR,
4090 buffer, conn); 4122 buffer);
4091 goto transport_err; 4123 goto transport_err;
4092 } 4124 }
4093 4125
diff --git a/drivers/target/iscsi/iscsi_target.h b/drivers/target/iscsi/iscsi_target.h
index a0050b2f294e..2c437cb8ca00 100644
--- a/drivers/target/iscsi/iscsi_target.h
+++ b/drivers/target/iscsi/iscsi_target.h
@@ -15,7 +15,7 @@ extern struct iscsi_np *iscsit_add_np(struct __kernel_sockaddr_storage *,
15extern int iscsit_reset_np_thread(struct iscsi_np *, struct iscsi_tpg_np *, 15extern int iscsit_reset_np_thread(struct iscsi_np *, struct iscsi_tpg_np *,
16 struct iscsi_portal_group *); 16 struct iscsi_portal_group *);
17extern int iscsit_del_np(struct iscsi_np *); 17extern int iscsit_del_np(struct iscsi_np *);
18extern int iscsit_add_reject_from_cmd(u8, int, int, unsigned char *, struct iscsi_cmd *); 18extern int iscsit_reject_cmd(struct iscsi_cmd *cmd, u8, unsigned char *);
19extern void iscsit_set_unsoliticed_dataout(struct iscsi_cmd *); 19extern void iscsit_set_unsoliticed_dataout(struct iscsi_cmd *);
20extern int iscsit_logout_closesession(struct iscsi_cmd *, struct iscsi_conn *); 20extern int iscsit_logout_closesession(struct iscsi_cmd *, struct iscsi_conn *);
21extern int iscsit_logout_closeconnection(struct iscsi_cmd *, struct iscsi_conn *); 21extern int iscsit_logout_closeconnection(struct iscsi_cmd *, struct iscsi_conn *);
diff --git a/drivers/target/iscsi/iscsi_target_configfs.c b/drivers/target/iscsi/iscsi_target_configfs.c
index 8d8b3ff68490..bbfd28893164 100644
--- a/drivers/target/iscsi/iscsi_target_configfs.c
+++ b/drivers/target/iscsi/iscsi_target_configfs.c
@@ -20,6 +20,7 @@
20 ****************************************************************************/ 20 ****************************************************************************/
21 21
22#include <linux/configfs.h> 22#include <linux/configfs.h>
23#include <linux/ctype.h>
23#include <linux/export.h> 24#include <linux/export.h>
24#include <linux/inet.h> 25#include <linux/inet.h>
25#include <target/target_core_base.h> 26#include <target/target_core_base.h>
@@ -78,11 +79,12 @@ static ssize_t lio_target_np_store_sctp(
78 struct iscsi_tpg_np *tpg_np = container_of(se_tpg_np, 79 struct iscsi_tpg_np *tpg_np = container_of(se_tpg_np,
79 struct iscsi_tpg_np, se_tpg_np); 80 struct iscsi_tpg_np, se_tpg_np);
80 struct iscsi_tpg_np *tpg_np_sctp = NULL; 81 struct iscsi_tpg_np *tpg_np_sctp = NULL;
81 char *endptr;
82 u32 op; 82 u32 op;
83 int ret; 83 int ret;
84 84
85 op = simple_strtoul(page, &endptr, 0); 85 ret = kstrtou32(page, 0, &op);
86 if (ret)
87 return ret;
86 if ((op != 1) && (op != 0)) { 88 if ((op != 1) && (op != 0)) {
87 pr_err("Illegal value for tpg_enable: %u\n", op); 89 pr_err("Illegal value for tpg_enable: %u\n", op);
88 return -EINVAL; 90 return -EINVAL;
@@ -382,11 +384,12 @@ static ssize_t iscsi_nacl_attrib_store_##name( \
382{ \ 384{ \
383 struct iscsi_node_acl *nacl = container_of(se_nacl, struct iscsi_node_acl, \ 385 struct iscsi_node_acl *nacl = container_of(se_nacl, struct iscsi_node_acl, \
384 se_node_acl); \ 386 se_node_acl); \
385 char *endptr; \
386 u32 val; \ 387 u32 val; \
387 int ret; \ 388 int ret; \
388 \ 389 \
389 val = simple_strtoul(page, &endptr, 0); \ 390 ret = kstrtou32(page, 0, &val); \
391 if (ret) \
392 return ret; \
390 ret = iscsit_na_##name(nacl, val); \ 393 ret = iscsit_na_##name(nacl, val); \
391 if (ret < 0) \ 394 if (ret < 0) \
392 return ret; \ 395 return ret; \
@@ -474,7 +477,7 @@ static ssize_t __iscsi_##prefix##_store_##name( \
474 if (!capable(CAP_SYS_ADMIN)) \ 477 if (!capable(CAP_SYS_ADMIN)) \
475 return -EPERM; \ 478 return -EPERM; \
476 \ 479 \
477 snprintf(auth->name, PAGE_SIZE, "%s", page); \ 480 snprintf(auth->name, sizeof(auth->name), "%s", page); \
478 if (!strncmp("NULL", auth->name, 4)) \ 481 if (!strncmp("NULL", auth->name, 4)) \
479 auth->naf_flags &= ~flags; \ 482 auth->naf_flags &= ~flags; \
480 else \ 483 else \
@@ -789,11 +792,12 @@ static ssize_t lio_target_nacl_store_cmdsn_depth(
789 struct iscsi_portal_group *tpg = container_of(se_tpg, 792 struct iscsi_portal_group *tpg = container_of(se_tpg,
790 struct iscsi_portal_group, tpg_se_tpg); 793 struct iscsi_portal_group, tpg_se_tpg);
791 struct config_item *acl_ci, *tpg_ci, *wwn_ci; 794 struct config_item *acl_ci, *tpg_ci, *wwn_ci;
792 char *endptr;
793 u32 cmdsn_depth = 0; 795 u32 cmdsn_depth = 0;
794 int ret; 796 int ret;
795 797
796 cmdsn_depth = simple_strtoul(page, &endptr, 0); 798 ret = kstrtou32(page, 0, &cmdsn_depth);
799 if (ret)
800 return ret;
797 if (cmdsn_depth > TA_DEFAULT_CMDSN_DEPTH_MAX) { 801 if (cmdsn_depth > TA_DEFAULT_CMDSN_DEPTH_MAX) {
798 pr_err("Passed cmdsn_depth: %u exceeds" 802 pr_err("Passed cmdsn_depth: %u exceeds"
799 " TA_DEFAULT_CMDSN_DEPTH_MAX: %u\n", cmdsn_depth, 803 " TA_DEFAULT_CMDSN_DEPTH_MAX: %u\n", cmdsn_depth,
@@ -977,14 +981,15 @@ static ssize_t iscsi_tpg_attrib_store_##name( \
977{ \ 981{ \
978 struct iscsi_portal_group *tpg = container_of(se_tpg, \ 982 struct iscsi_portal_group *tpg = container_of(se_tpg, \
979 struct iscsi_portal_group, tpg_se_tpg); \ 983 struct iscsi_portal_group, tpg_se_tpg); \
980 char *endptr; \
981 u32 val; \ 984 u32 val; \
982 int ret; \ 985 int ret; \
983 \ 986 \
984 if (iscsit_get_tpg(tpg) < 0) \ 987 if (iscsit_get_tpg(tpg) < 0) \
985 return -EINVAL; \ 988 return -EINVAL; \
986 \ 989 \
987 val = simple_strtoul(page, &endptr, 0); \ 990 ret = kstrtou32(page, 0, &val); \
991 if (ret) \
992 goto out; \
988 ret = iscsit_ta_##name(tpg, val); \ 993 ret = iscsit_ta_##name(tpg, val); \
989 if (ret < 0) \ 994 if (ret < 0) \
990 goto out; \ 995 goto out; \
@@ -1053,6 +1058,131 @@ static struct configfs_attribute *lio_target_tpg_attrib_attrs[] = {
1053 1058
1054/* End items for lio_target_tpg_attrib_cit */ 1059/* End items for lio_target_tpg_attrib_cit */
1055 1060
1061/* Start items for lio_target_tpg_auth_cit */
1062
1063#define __DEF_TPG_AUTH_STR(prefix, name, flags) \
1064static ssize_t __iscsi_##prefix##_show_##name( \
1065 struct se_portal_group *se_tpg, \
1066 char *page) \
1067{ \
1068 struct iscsi_portal_group *tpg = container_of(se_tpg, \
1069 struct iscsi_portal_group, tpg_se_tpg); \
1070 struct iscsi_node_auth *auth = &tpg->tpg_demo_auth; \
1071 \
1072 if (!capable(CAP_SYS_ADMIN)) \
1073 return -EPERM; \
1074 \
1075 return snprintf(page, PAGE_SIZE, "%s\n", auth->name); \
1076} \
1077 \
1078static ssize_t __iscsi_##prefix##_store_##name( \
1079 struct se_portal_group *se_tpg, \
1080 const char *page, \
1081 size_t count) \
1082{ \
1083 struct iscsi_portal_group *tpg = container_of(se_tpg, \
1084 struct iscsi_portal_group, tpg_se_tpg); \
1085 struct iscsi_node_auth *auth = &tpg->tpg_demo_auth; \
1086 \
1087 if (!capable(CAP_SYS_ADMIN)) \
1088 return -EPERM; \
1089 \
1090 snprintf(auth->name, sizeof(auth->name), "%s", page); \
1091 if (!(strncmp("NULL", auth->name, 4))) \
1092 auth->naf_flags &= ~flags; \
1093 else \
1094 auth->naf_flags |= flags; \
1095 \
1096 if ((auth->naf_flags & NAF_USERID_IN_SET) && \
1097 (auth->naf_flags & NAF_PASSWORD_IN_SET)) \
1098 auth->authenticate_target = 1; \
1099 else \
1100 auth->authenticate_target = 0; \
1101 \
1102 return count; \
1103}
1104
1105#define __DEF_TPG_AUTH_INT(prefix, name) \
1106static ssize_t __iscsi_##prefix##_show_##name( \
1107 struct se_portal_group *se_tpg, \
1108 char *page) \
1109{ \
1110 struct iscsi_portal_group *tpg = container_of(se_tpg, \
1111 struct iscsi_portal_group, tpg_se_tpg); \
1112 struct iscsi_node_auth *auth = &tpg->tpg_demo_auth; \
1113 \
1114 if (!capable(CAP_SYS_ADMIN)) \
1115 return -EPERM; \
1116 \
1117 return snprintf(page, PAGE_SIZE, "%d\n", auth->name); \
1118}
1119
1120#define DEF_TPG_AUTH_STR(name, flags) \
1121 __DEF_TPG_AUTH_STR(tpg_auth, name, flags) \
1122static ssize_t iscsi_tpg_auth_show_##name( \
1123 struct se_portal_group *se_tpg, \
1124 char *page) \
1125{ \
1126 return __iscsi_tpg_auth_show_##name(se_tpg, page); \
1127} \
1128 \
1129static ssize_t iscsi_tpg_auth_store_##name( \
1130 struct se_portal_group *se_tpg, \
1131 const char *page, \
1132 size_t count) \
1133{ \
1134 return __iscsi_tpg_auth_store_##name(se_tpg, page, count); \
1135}
1136
1137#define DEF_TPG_AUTH_INT(name) \
1138 __DEF_TPG_AUTH_INT(tpg_auth, name) \
1139static ssize_t iscsi_tpg_auth_show_##name( \
1140 struct se_portal_group *se_tpg, \
1141 char *page) \
1142{ \
1143 return __iscsi_tpg_auth_show_##name(se_tpg, page); \
1144}
1145
1146#define TPG_AUTH_ATTR(_name, _mode) TF_TPG_AUTH_ATTR(iscsi, _name, _mode);
1147#define TPG_AUTH_ATTR_RO(_name) TF_TPG_AUTH_ATTR_RO(iscsi, _name);
1148
1149/*
1150 * * One-way authentication userid
1151 * */
1152DEF_TPG_AUTH_STR(userid, NAF_USERID_SET);
1153TPG_AUTH_ATTR(userid, S_IRUGO | S_IWUSR);
1154/*
1155 * * One-way authentication password
1156 * */
1157DEF_TPG_AUTH_STR(password, NAF_PASSWORD_SET);
1158TPG_AUTH_ATTR(password, S_IRUGO | S_IWUSR);
1159/*
1160 * * Enforce mutual authentication
1161 * */
1162DEF_TPG_AUTH_INT(authenticate_target);
1163TPG_AUTH_ATTR_RO(authenticate_target);
1164/*
1165 * * Mutual authentication userid
1166 * */
1167DEF_TPG_AUTH_STR(userid_mutual, NAF_USERID_IN_SET);
1168TPG_AUTH_ATTR(userid_mutual, S_IRUGO | S_IWUSR);
1169/*
1170 * * Mutual authentication password
1171 * */
1172DEF_TPG_AUTH_STR(password_mutual, NAF_PASSWORD_IN_SET);
1173TPG_AUTH_ATTR(password_mutual, S_IRUGO | S_IWUSR);
1174
1175static struct configfs_attribute *lio_target_tpg_auth_attrs[] = {
1176 &iscsi_tpg_auth_userid.attr,
1177 &iscsi_tpg_auth_password.attr,
1178 &iscsi_tpg_auth_authenticate_target.attr,
1179 &iscsi_tpg_auth_userid_mutual.attr,
1180 &iscsi_tpg_auth_password_mutual.attr,
1181 NULL,
1182};
1183
1184/* End items for lio_target_tpg_auth_cit */
1185
1056/* Start items for lio_target_tpg_param_cit */ 1186/* Start items for lio_target_tpg_param_cit */
1057 1187
1058#define DEF_TPG_PARAM(name) \ 1188#define DEF_TPG_PARAM(name) \
@@ -1087,13 +1217,14 @@ static ssize_t iscsi_tpg_param_store_##name( \
1087 struct iscsi_portal_group *tpg = container_of(se_tpg, \ 1217 struct iscsi_portal_group *tpg = container_of(se_tpg, \
1088 struct iscsi_portal_group, tpg_se_tpg); \ 1218 struct iscsi_portal_group, tpg_se_tpg); \
1089 char *buf; \ 1219 char *buf; \
1090 int ret; \ 1220 int ret, len; \
1091 \ 1221 \
1092 buf = kzalloc(PAGE_SIZE, GFP_KERNEL); \ 1222 buf = kzalloc(PAGE_SIZE, GFP_KERNEL); \
1093 if (!buf) \ 1223 if (!buf) \
1094 return -ENOMEM; \ 1224 return -ENOMEM; \
1095 snprintf(buf, PAGE_SIZE, "%s=%s", __stringify(name), page); \ 1225 len = snprintf(buf, PAGE_SIZE, "%s=%s", __stringify(name), page); \
1096 buf[strlen(buf)-1] = '\0'; /* Kill newline */ \ 1226 if (isspace(buf[len-1])) \
1227 buf[len-1] = '\0'; /* Kill newline */ \
1097 \ 1228 \
1098 if (iscsit_get_tpg(tpg) < 0) { \ 1229 if (iscsit_get_tpg(tpg) < 0) { \
1099 kfree(buf); \ 1230 kfree(buf); \
@@ -1230,11 +1361,12 @@ static ssize_t lio_target_tpg_store_enable(
1230{ 1361{
1231 struct iscsi_portal_group *tpg = container_of(se_tpg, 1362 struct iscsi_portal_group *tpg = container_of(se_tpg,
1232 struct iscsi_portal_group, tpg_se_tpg); 1363 struct iscsi_portal_group, tpg_se_tpg);
1233 char *endptr;
1234 u32 op; 1364 u32 op;
1235 int ret = 0; 1365 int ret;
1236 1366
1237 op = simple_strtoul(page, &endptr, 0); 1367 ret = kstrtou32(page, 0, &op);
1368 if (ret)
1369 return ret;
1238 if ((op != 1) && (op != 0)) { 1370 if ((op != 1) && (op != 0)) {
1239 pr_err("Illegal value for tpg_enable: %u\n", op); 1371 pr_err("Illegal value for tpg_enable: %u\n", op);
1240 return -EINVAL; 1372 return -EINVAL;
@@ -1282,15 +1414,15 @@ static struct se_portal_group *lio_target_tiqn_addtpg(
1282{ 1414{
1283 struct iscsi_portal_group *tpg; 1415 struct iscsi_portal_group *tpg;
1284 struct iscsi_tiqn *tiqn; 1416 struct iscsi_tiqn *tiqn;
1285 char *tpgt_str, *end_ptr; 1417 char *tpgt_str;
1286 int ret = 0; 1418 int ret;
1287 unsigned short int tpgt; 1419 u16 tpgt;
1288 1420
1289 tiqn = container_of(wwn, struct iscsi_tiqn, tiqn_wwn); 1421 tiqn = container_of(wwn, struct iscsi_tiqn, tiqn_wwn);
1290 /* 1422 /*
1291 * Only tpgt_# directory groups can be created below 1423 * Only tpgt_# directory groups can be created below
1292 * target/iscsi/iqn.superturodiskarry/ 1424 * target/iscsi/iqn.superturodiskarry/
1293 */ 1425 */
1294 tpgt_str = strstr(name, "tpgt_"); 1426 tpgt_str = strstr(name, "tpgt_");
1295 if (!tpgt_str) { 1427 if (!tpgt_str) {
1296 pr_err("Unable to locate \"tpgt_#\" directory" 1428 pr_err("Unable to locate \"tpgt_#\" directory"
@@ -1298,7 +1430,9 @@ static struct se_portal_group *lio_target_tiqn_addtpg(
1298 return NULL; 1430 return NULL;
1299 } 1431 }
1300 tpgt_str += 5; /* Skip ahead of "tpgt_" */ 1432 tpgt_str += 5; /* Skip ahead of "tpgt_" */
1301 tpgt = (unsigned short int) simple_strtoul(tpgt_str, &end_ptr, 0); 1433 ret = kstrtou16(tpgt_str, 0, &tpgt);
1434 if (ret)
1435 return NULL;
1302 1436
1303 tpg = iscsit_alloc_portal_group(tiqn, tpgt); 1437 tpg = iscsit_alloc_portal_group(tiqn, tpgt);
1304 if (!tpg) 1438 if (!tpg)
@@ -1506,10 +1640,12 @@ static ssize_t iscsi_disc_store_enforce_discovery_auth(
1506{ 1640{
1507 struct iscsi_param *param; 1641 struct iscsi_param *param;
1508 struct iscsi_portal_group *discovery_tpg = iscsit_global->discovery_tpg; 1642 struct iscsi_portal_group *discovery_tpg = iscsit_global->discovery_tpg;
1509 char *endptr;
1510 u32 op; 1643 u32 op;
1644 int err;
1511 1645
1512 op = simple_strtoul(page, &endptr, 0); 1646 err = kstrtou32(page, 0, &op);
1647 if (err)
1648 return -EINVAL;
1513 if ((op != 1) && (op != 0)) { 1649 if ((op != 1) && (op != 0)) {
1514 pr_err("Illegal value for enforce_discovery_auth:" 1650 pr_err("Illegal value for enforce_discovery_auth:"
1515 " %u\n", op); 1651 " %u\n", op);
@@ -1655,13 +1791,12 @@ static int lio_queue_status(struct se_cmd *se_cmd)
1655 return 0; 1791 return 0;
1656} 1792}
1657 1793
1658static int lio_queue_tm_rsp(struct se_cmd *se_cmd) 1794static void lio_queue_tm_rsp(struct se_cmd *se_cmd)
1659{ 1795{
1660 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd); 1796 struct iscsi_cmd *cmd = container_of(se_cmd, struct iscsi_cmd, se_cmd);
1661 1797
1662 cmd->i_state = ISTATE_SEND_TASKMGTRSP; 1798 cmd->i_state = ISTATE_SEND_TASKMGTRSP;
1663 iscsit_add_cmd_to_response_queue(cmd, cmd->conn, cmd->i_state); 1799 iscsit_add_cmd_to_response_queue(cmd, cmd->conn, cmd->i_state);
1664 return 0;
1665} 1800}
1666 1801
1667static char *lio_tpg_get_endpoint_wwn(struct se_portal_group *se_tpg) 1802static char *lio_tpg_get_endpoint_wwn(struct se_portal_group *se_tpg)
@@ -1866,6 +2001,7 @@ int iscsi_target_register_configfs(void)
1866 TF_CIT_TMPL(fabric)->tfc_wwn_cit.ct_attrs = lio_target_wwn_attrs; 2001 TF_CIT_TMPL(fabric)->tfc_wwn_cit.ct_attrs = lio_target_wwn_attrs;
1867 TF_CIT_TMPL(fabric)->tfc_tpg_base_cit.ct_attrs = lio_target_tpg_attrs; 2002 TF_CIT_TMPL(fabric)->tfc_tpg_base_cit.ct_attrs = lio_target_tpg_attrs;
1868 TF_CIT_TMPL(fabric)->tfc_tpg_attrib_cit.ct_attrs = lio_target_tpg_attrib_attrs; 2003 TF_CIT_TMPL(fabric)->tfc_tpg_attrib_cit.ct_attrs = lio_target_tpg_attrib_attrs;
2004 TF_CIT_TMPL(fabric)->tfc_tpg_auth_cit.ct_attrs = lio_target_tpg_auth_attrs;
1869 TF_CIT_TMPL(fabric)->tfc_tpg_param_cit.ct_attrs = lio_target_tpg_param_attrs; 2005 TF_CIT_TMPL(fabric)->tfc_tpg_param_cit.ct_attrs = lio_target_tpg_param_attrs;
1870 TF_CIT_TMPL(fabric)->tfc_tpg_np_base_cit.ct_attrs = lio_target_portal_attrs; 2006 TF_CIT_TMPL(fabric)->tfc_tpg_np_base_cit.ct_attrs = lio_target_portal_attrs;
1871 TF_CIT_TMPL(fabric)->tfc_tpg_nacl_base_cit.ct_attrs = lio_target_initiator_attrs; 2007 TF_CIT_TMPL(fabric)->tfc_tpg_nacl_base_cit.ct_attrs = lio_target_initiator_attrs;
diff --git a/drivers/target/iscsi/iscsi_target_core.h b/drivers/target/iscsi/iscsi_target_core.h
index 60ec4b92be03..4f77a78edef9 100644
--- a/drivers/target/iscsi/iscsi_target_core.h
+++ b/drivers/target/iscsi/iscsi_target_core.h
@@ -132,7 +132,8 @@ enum cmd_flags_table {
132 ICF_CONTIG_MEMORY = 0x00000020, 132 ICF_CONTIG_MEMORY = 0x00000020,
133 ICF_ATTACHED_TO_RQUEUE = 0x00000040, 133 ICF_ATTACHED_TO_RQUEUE = 0x00000040,
134 ICF_OOO_CMDSN = 0x00000080, 134 ICF_OOO_CMDSN = 0x00000080,
135 ICF_REJECT_FAIL_CONN = 0x00000100, 135 IFC_SENDTARGETS_ALL = 0x00000100,
136 IFC_SENDTARGETS_SINGLE = 0x00000200,
136}; 137};
137 138
138/* struct iscsi_cmd->i_state */ 139/* struct iscsi_cmd->i_state */
@@ -366,6 +367,8 @@ struct iscsi_cmd {
366 u8 maxcmdsn_inc; 367 u8 maxcmdsn_inc;
367 /* Immediate Unsolicited Dataout */ 368 /* Immediate Unsolicited Dataout */
368 u8 unsolicited_data; 369 u8 unsolicited_data;
370 /* Reject reason code */
371 u8 reject_reason;
369 /* CID contained in logout PDU when opcode == ISCSI_INIT_LOGOUT_CMND */ 372 /* CID contained in logout PDU when opcode == ISCSI_INIT_LOGOUT_CMND */
370 u16 logout_cid; 373 u16 logout_cid;
371 /* Command flags */ 374 /* Command flags */
@@ -427,6 +430,8 @@ struct iscsi_cmd {
427 u32 tx_size; 430 u32 tx_size;
428 /* Buffer used for various purposes */ 431 /* Buffer used for various purposes */
429 void *buf_ptr; 432 void *buf_ptr;
433 /* Used by SendTargets=[iqn.,eui.] discovery */
434 void *text_in_ptr;
430 /* See include/linux/dma-mapping.h */ 435 /* See include/linux/dma-mapping.h */
431 enum dma_data_direction data_direction; 436 enum dma_data_direction data_direction;
432 /* iSCSI PDU Header + CRC */ 437 /* iSCSI PDU Header + CRC */
@@ -446,7 +451,6 @@ struct iscsi_cmd {
446 struct list_head datain_list; 451 struct list_head datain_list;
447 /* R2T List */ 452 /* R2T List */
448 struct list_head cmd_r2t_list; 453 struct list_head cmd_r2t_list;
449 struct completion reject_comp;
450 /* Timer for DataOUT */ 454 /* Timer for DataOUT */
451 struct timer_list dataout_timer; 455 struct timer_list dataout_timer;
452 /* Iovecs for SCSI data payload RX/TX w/ kernel level sockets */ 456 /* Iovecs for SCSI data payload RX/TX w/ kernel level sockets */
@@ -528,8 +532,6 @@ struct iscsi_conn {
528 u32 of_marker; 532 u32 of_marker;
529 /* Used for calculating OFMarker offset to next PDU */ 533 /* Used for calculating OFMarker offset to next PDU */
530 u32 of_marker_offset; 534 u32 of_marker_offset;
531 /* Complete Bad PDU for sending reject */
532 unsigned char bad_hdr[ISCSI_HDR_LEN];
533#define IPV6_ADDRESS_SPACE 48 535#define IPV6_ADDRESS_SPACE 48
534 unsigned char login_ip[IPV6_ADDRESS_SPACE]; 536 unsigned char login_ip[IPV6_ADDRESS_SPACE];
535 unsigned char local_ip[IPV6_ADDRESS_SPACE]; 537 unsigned char local_ip[IPV6_ADDRESS_SPACE];
@@ -809,6 +811,7 @@ struct iscsi_portal_group {
809 struct mutex tpg_access_lock; 811 struct mutex tpg_access_lock;
810 struct mutex np_login_lock; 812 struct mutex np_login_lock;
811 struct iscsi_tpg_attrib tpg_attrib; 813 struct iscsi_tpg_attrib tpg_attrib;
814 struct iscsi_node_auth tpg_demo_auth;
812 /* Pointer to default list of iSCSI parameters for TPG */ 815 /* Pointer to default list of iSCSI parameters for TPG */
813 struct iscsi_param_list *param_list; 816 struct iscsi_param_list *param_list;
814 struct iscsi_tiqn *tpg_tiqn; 817 struct iscsi_tiqn *tpg_tiqn;
diff --git a/drivers/target/iscsi/iscsi_target_erl0.c b/drivers/target/iscsi/iscsi_target_erl0.c
index dcb199da06b9..08bd87833321 100644
--- a/drivers/target/iscsi/iscsi_target_erl0.c
+++ b/drivers/target/iscsi/iscsi_target_erl0.c
@@ -746,13 +746,12 @@ int iscsit_check_post_dataout(
746 if (!conn->sess->sess_ops->ErrorRecoveryLevel) { 746 if (!conn->sess->sess_ops->ErrorRecoveryLevel) {
747 pr_err("Unable to recover from DataOUT CRC" 747 pr_err("Unable to recover from DataOUT CRC"
748 " failure while ERL=0, closing session.\n"); 748 " failure while ERL=0, closing session.\n");
749 iscsit_add_reject_from_cmd(ISCSI_REASON_DATA_DIGEST_ERROR, 749 iscsit_reject_cmd(cmd, ISCSI_REASON_DATA_DIGEST_ERROR,
750 1, 0, buf, cmd); 750 buf);
751 return DATAOUT_CANNOT_RECOVER; 751 return DATAOUT_CANNOT_RECOVER;
752 } 752 }
753 753
754 iscsit_add_reject_from_cmd(ISCSI_REASON_DATA_DIGEST_ERROR, 754 iscsit_reject_cmd(cmd, ISCSI_REASON_DATA_DIGEST_ERROR, buf);
755 0, 0, buf, cmd);
756 return iscsit_dataout_post_crc_failed(cmd, buf); 755 return iscsit_dataout_post_crc_failed(cmd, buf);
757 } 756 }
758} 757}
@@ -909,6 +908,7 @@ void iscsit_cause_connection_reinstatement(struct iscsi_conn *conn, int sleep)
909 wait_for_completion(&conn->conn_wait_comp); 908 wait_for_completion(&conn->conn_wait_comp);
910 complete(&conn->conn_post_wait_comp); 909 complete(&conn->conn_post_wait_comp);
911} 910}
911EXPORT_SYMBOL(iscsit_cause_connection_reinstatement);
912 912
913void iscsit_fall_back_to_erl0(struct iscsi_session *sess) 913void iscsit_fall_back_to_erl0(struct iscsi_session *sess)
914{ 914{
diff --git a/drivers/target/iscsi/iscsi_target_erl1.c b/drivers/target/iscsi/iscsi_target_erl1.c
index 40d9dbca987b..586c268679a4 100644
--- a/drivers/target/iscsi/iscsi_target_erl1.c
+++ b/drivers/target/iscsi/iscsi_target_erl1.c
@@ -162,9 +162,8 @@ static int iscsit_handle_r2t_snack(
162 " protocol error.\n", cmd->init_task_tag, begrun, 162 " protocol error.\n", cmd->init_task_tag, begrun,
163 (begrun + runlength), cmd->acked_data_sn); 163 (begrun + runlength), cmd->acked_data_sn);
164 164
165 return iscsit_add_reject_from_cmd( 165 return iscsit_reject_cmd(cmd,
166 ISCSI_REASON_PROTOCOL_ERROR, 166 ISCSI_REASON_PROTOCOL_ERROR, buf);
167 1, 0, buf, cmd);
168 } 167 }
169 168
170 if (runlength) { 169 if (runlength) {
@@ -173,8 +172,8 @@ static int iscsit_handle_r2t_snack(
173 " with BegRun: 0x%08x, RunLength: 0x%08x, exceeds" 172 " with BegRun: 0x%08x, RunLength: 0x%08x, exceeds"
174 " current R2TSN: 0x%08x, protocol error.\n", 173 " current R2TSN: 0x%08x, protocol error.\n",
175 cmd->init_task_tag, begrun, runlength, cmd->r2t_sn); 174 cmd->init_task_tag, begrun, runlength, cmd->r2t_sn);
176 return iscsit_add_reject_from_cmd( 175 return iscsit_reject_cmd(cmd,
177 ISCSI_REASON_BOOKMARK_INVALID, 1, 0, buf, cmd); 176 ISCSI_REASON_BOOKMARK_INVALID, buf);
178 } 177 }
179 last_r2tsn = (begrun + runlength); 178 last_r2tsn = (begrun + runlength);
180 } else 179 } else
@@ -433,8 +432,7 @@ static int iscsit_handle_recovery_datain(
433 " protocol error.\n", cmd->init_task_tag, begrun, 432 " protocol error.\n", cmd->init_task_tag, begrun,
434 (begrun + runlength), cmd->acked_data_sn); 433 (begrun + runlength), cmd->acked_data_sn);
435 434
436 return iscsit_add_reject_from_cmd(ISCSI_REASON_PROTOCOL_ERROR, 435 return iscsit_reject_cmd(cmd, ISCSI_REASON_PROTOCOL_ERROR, buf);
437 1, 0, buf, cmd);
438 } 436 }
439 437
440 /* 438 /*
@@ -445,14 +443,14 @@ static int iscsit_handle_recovery_datain(
445 pr_err("Initiator requesting BegRun: 0x%08x, RunLength" 443 pr_err("Initiator requesting BegRun: 0x%08x, RunLength"
446 ": 0x%08x greater than maximum DataSN: 0x%08x.\n", 444 ": 0x%08x greater than maximum DataSN: 0x%08x.\n",
447 begrun, runlength, (cmd->data_sn - 1)); 445 begrun, runlength, (cmd->data_sn - 1));
448 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID, 446 return iscsit_reject_cmd(cmd, ISCSI_REASON_BOOKMARK_INVALID,
449 1, 0, buf, cmd); 447 buf);
450 } 448 }
451 449
452 dr = iscsit_allocate_datain_req(); 450 dr = iscsit_allocate_datain_req();
453 if (!dr) 451 if (!dr)
454 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_NO_RESOURCES, 452 return iscsit_reject_cmd(cmd, ISCSI_REASON_BOOKMARK_NO_RESOURCES,
455 1, 0, buf, cmd); 453 buf);
456 454
457 dr->data_sn = dr->begrun = begrun; 455 dr->data_sn = dr->begrun = begrun;
458 dr->runlength = runlength; 456 dr->runlength = runlength;
@@ -1090,7 +1088,7 @@ int iscsit_handle_ooo_cmdsn(
1090 1088
1091 ooo_cmdsn = iscsit_allocate_ooo_cmdsn(); 1089 ooo_cmdsn = iscsit_allocate_ooo_cmdsn();
1092 if (!ooo_cmdsn) 1090 if (!ooo_cmdsn)
1093 return CMDSN_ERROR_CANNOT_RECOVER; 1091 return -ENOMEM;
1094 1092
1095 ooo_cmdsn->cmd = cmd; 1093 ooo_cmdsn->cmd = cmd;
1096 ooo_cmdsn->batch_count = (batch) ? 1094 ooo_cmdsn->batch_count = (batch) ?
@@ -1101,10 +1099,10 @@ int iscsit_handle_ooo_cmdsn(
1101 1099
1102 if (iscsit_attach_ooo_cmdsn(sess, ooo_cmdsn) < 0) { 1100 if (iscsit_attach_ooo_cmdsn(sess, ooo_cmdsn) < 0) {
1103 kmem_cache_free(lio_ooo_cache, ooo_cmdsn); 1101 kmem_cache_free(lio_ooo_cache, ooo_cmdsn);
1104 return CMDSN_ERROR_CANNOT_RECOVER; 1102 return -ENOMEM;
1105 } 1103 }
1106 1104
1107 return CMDSN_HIGHER_THAN_EXP; 1105 return 0;
1108} 1106}
1109 1107
1110static int iscsit_set_dataout_timeout_values( 1108static int iscsit_set_dataout_timeout_values(
diff --git a/drivers/target/iscsi/iscsi_target_nego.c b/drivers/target/iscsi/iscsi_target_nego.c
index cd5018ff9cd7..c4675b4ceb49 100644
--- a/drivers/target/iscsi/iscsi_target_nego.c
+++ b/drivers/target/iscsi/iscsi_target_nego.c
@@ -112,6 +112,7 @@ static u32 iscsi_handle_authentication(
112 struct iscsi_session *sess = conn->sess; 112 struct iscsi_session *sess = conn->sess;
113 struct iscsi_node_auth *auth; 113 struct iscsi_node_auth *auth;
114 struct iscsi_node_acl *iscsi_nacl; 114 struct iscsi_node_acl *iscsi_nacl;
115 struct iscsi_portal_group *iscsi_tpg;
115 struct se_node_acl *se_nacl; 116 struct se_node_acl *se_nacl;
116 117
117 if (!sess->sess_ops->SessionType) { 118 if (!sess->sess_ops->SessionType) {
@@ -132,7 +133,17 @@ static u32 iscsi_handle_authentication(
132 return -1; 133 return -1;
133 } 134 }
134 135
135 auth = ISCSI_NODE_AUTH(iscsi_nacl); 136 if (se_nacl->dynamic_node_acl) {
137 iscsi_tpg = container_of(se_nacl->se_tpg,
138 struct iscsi_portal_group, tpg_se_tpg);
139
140 auth = &iscsi_tpg->tpg_demo_auth;
141 } else {
142 iscsi_nacl = container_of(se_nacl, struct iscsi_node_acl,
143 se_node_acl);
144
145 auth = ISCSI_NODE_AUTH(iscsi_nacl);
146 }
136 } else { 147 } else {
137 /* 148 /*
138 * For SessionType=Discovery 149 * For SessionType=Discovery
diff --git a/drivers/target/iscsi/iscsi_target_parameters.c b/drivers/target/iscsi/iscsi_target_parameters.c
index e38222191a33..35fd6439eb01 100644
--- a/drivers/target/iscsi/iscsi_target_parameters.c
+++ b/drivers/target/iscsi/iscsi_target_parameters.c
@@ -1799,9 +1799,6 @@ void iscsi_set_connection_parameters(
1799 * this key is not sent over the wire. 1799 * this key is not sent over the wire.
1800 */ 1800 */
1801 if (!strcmp(param->name, MAXXMITDATASEGMENTLENGTH)) { 1801 if (!strcmp(param->name, MAXXMITDATASEGMENTLENGTH)) {
1802 if (param_list->iser == true)
1803 continue;
1804
1805 ops->MaxXmitDataSegmentLength = 1802 ops->MaxXmitDataSegmentLength =
1806 simple_strtoul(param->value, &tmpptr, 0); 1803 simple_strtoul(param->value, &tmpptr, 0);
1807 pr_debug("MaxXmitDataSegmentLength: %s\n", 1804 pr_debug("MaxXmitDataSegmentLength: %s\n",
diff --git a/drivers/target/iscsi/iscsi_target_util.c b/drivers/target/iscsi/iscsi_target_util.c
index 08a3bacef0c5..1df06d5e4e01 100644
--- a/drivers/target/iscsi/iscsi_target_util.c
+++ b/drivers/target/iscsi/iscsi_target_util.c
@@ -178,7 +178,6 @@ struct iscsi_cmd *iscsit_allocate_cmd(struct iscsi_conn *conn, gfp_t gfp_mask)
178 INIT_LIST_HEAD(&cmd->i_conn_node); 178 INIT_LIST_HEAD(&cmd->i_conn_node);
179 INIT_LIST_HEAD(&cmd->datain_list); 179 INIT_LIST_HEAD(&cmd->datain_list);
180 INIT_LIST_HEAD(&cmd->cmd_r2t_list); 180 INIT_LIST_HEAD(&cmd->cmd_r2t_list);
181 init_completion(&cmd->reject_comp);
182 spin_lock_init(&cmd->datain_lock); 181 spin_lock_init(&cmd->datain_lock);
183 spin_lock_init(&cmd->dataout_timeout_lock); 182 spin_lock_init(&cmd->dataout_timeout_lock);
184 spin_lock_init(&cmd->istate_lock); 183 spin_lock_init(&cmd->istate_lock);
@@ -284,13 +283,12 @@ static inline int iscsit_check_received_cmdsn(struct iscsi_session *sess, u32 cm
284 * Commands may be received out of order if MC/S is in use. 283 * Commands may be received out of order if MC/S is in use.
285 * Ensure they are executed in CmdSN order. 284 * Ensure they are executed in CmdSN order.
286 */ 285 */
287int iscsit_sequence_cmd( 286int iscsit_sequence_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
288 struct iscsi_conn *conn, 287 unsigned char *buf, __be32 cmdsn)
289 struct iscsi_cmd *cmd,
290 __be32 cmdsn)
291{ 288{
292 int ret; 289 int ret, cmdsn_ret;
293 int cmdsn_ret; 290 bool reject = false;
291 u8 reason = ISCSI_REASON_BOOKMARK_NO_RESOURCES;
294 292
295 mutex_lock(&conn->sess->cmdsn_mutex); 293 mutex_lock(&conn->sess->cmdsn_mutex);
296 294
@@ -300,9 +298,19 @@ int iscsit_sequence_cmd(
300 ret = iscsit_execute_cmd(cmd, 0); 298 ret = iscsit_execute_cmd(cmd, 0);
301 if ((ret >= 0) && !list_empty(&conn->sess->sess_ooo_cmdsn_list)) 299 if ((ret >= 0) && !list_empty(&conn->sess->sess_ooo_cmdsn_list))
302 iscsit_execute_ooo_cmdsns(conn->sess); 300 iscsit_execute_ooo_cmdsns(conn->sess);
301 else if (ret < 0) {
302 reject = true;
303 ret = CMDSN_ERROR_CANNOT_RECOVER;
304 }
303 break; 305 break;
304 case CMDSN_HIGHER_THAN_EXP: 306 case CMDSN_HIGHER_THAN_EXP:
305 ret = iscsit_handle_ooo_cmdsn(conn->sess, cmd, be32_to_cpu(cmdsn)); 307 ret = iscsit_handle_ooo_cmdsn(conn->sess, cmd, be32_to_cpu(cmdsn));
308 if (ret < 0) {
309 reject = true;
310 ret = CMDSN_ERROR_CANNOT_RECOVER;
311 break;
312 }
313 ret = CMDSN_HIGHER_THAN_EXP;
306 break; 314 break;
307 case CMDSN_LOWER_THAN_EXP: 315 case CMDSN_LOWER_THAN_EXP:
308 cmd->i_state = ISTATE_REMOVE; 316 cmd->i_state = ISTATE_REMOVE;
@@ -310,11 +318,16 @@ int iscsit_sequence_cmd(
310 ret = cmdsn_ret; 318 ret = cmdsn_ret;
311 break; 319 break;
312 default: 320 default:
321 reason = ISCSI_REASON_PROTOCOL_ERROR;
322 reject = true;
313 ret = cmdsn_ret; 323 ret = cmdsn_ret;
314 break; 324 break;
315 } 325 }
316 mutex_unlock(&conn->sess->cmdsn_mutex); 326 mutex_unlock(&conn->sess->cmdsn_mutex);
317 327
328 if (reject)
329 iscsit_reject_cmd(cmd, reason, buf);
330
318 return ret; 331 return ret;
319} 332}
320EXPORT_SYMBOL(iscsit_sequence_cmd); 333EXPORT_SYMBOL(iscsit_sequence_cmd);
@@ -681,6 +694,7 @@ void iscsit_release_cmd(struct iscsi_cmd *cmd)
681 kfree(cmd->seq_list); 694 kfree(cmd->seq_list);
682 kfree(cmd->tmr_req); 695 kfree(cmd->tmr_req);
683 kfree(cmd->iov_data); 696 kfree(cmd->iov_data);
697 kfree(cmd->text_in_ptr);
684 698
685 kmem_cache_free(lio_cmd_cache, cmd); 699 kmem_cache_free(lio_cmd_cache, cmd);
686} 700}
diff --git a/drivers/target/iscsi/iscsi_target_util.h b/drivers/target/iscsi/iscsi_target_util.h
index a4422659d049..e4fc34a02f57 100644
--- a/drivers/target/iscsi/iscsi_target_util.h
+++ b/drivers/target/iscsi/iscsi_target_util.h
@@ -13,7 +13,8 @@ extern struct iscsi_cmd *iscsit_allocate_cmd(struct iscsi_conn *, gfp_t);
13extern struct iscsi_seq *iscsit_get_seq_holder_for_datain(struct iscsi_cmd *, u32); 13extern struct iscsi_seq *iscsit_get_seq_holder_for_datain(struct iscsi_cmd *, u32);
14extern struct iscsi_seq *iscsit_get_seq_holder_for_r2t(struct iscsi_cmd *); 14extern struct iscsi_seq *iscsit_get_seq_holder_for_r2t(struct iscsi_cmd *);
15extern struct iscsi_r2t *iscsit_get_holder_for_r2tsn(struct iscsi_cmd *, u32); 15extern struct iscsi_r2t *iscsit_get_holder_for_r2tsn(struct iscsi_cmd *, u32);
16int iscsit_sequence_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd, __be32 cmdsn); 16extern int iscsit_sequence_cmd(struct iscsi_conn *conn, struct iscsi_cmd *cmd,
17 unsigned char * ,__be32 cmdsn);
17extern int iscsit_check_unsolicited_dataout(struct iscsi_cmd *, unsigned char *); 18extern int iscsit_check_unsolicited_dataout(struct iscsi_cmd *, unsigned char *);
18extern struct iscsi_cmd *iscsit_find_cmd_from_itt(struct iscsi_conn *, itt_t); 19extern struct iscsi_cmd *iscsit_find_cmd_from_itt(struct iscsi_conn *, itt_t);
19extern struct iscsi_cmd *iscsit_find_cmd_from_itt_or_dump(struct iscsi_conn *, 20extern struct iscsi_cmd *iscsit_find_cmd_from_itt_or_dump(struct iscsi_conn *,
diff --git a/drivers/target/loopback/tcm_loop.c b/drivers/target/loopback/tcm_loop.c
index 7c908141cc8a..568ad25f25d3 100644
--- a/drivers/target/loopback/tcm_loop.c
+++ b/drivers/target/loopback/tcm_loop.c
@@ -786,7 +786,7 @@ static int tcm_loop_queue_status(struct se_cmd *se_cmd)
786 return 0; 786 return 0;
787} 787}
788 788
789static int tcm_loop_queue_tm_rsp(struct se_cmd *se_cmd) 789static void tcm_loop_queue_tm_rsp(struct se_cmd *se_cmd)
790{ 790{
791 struct se_tmr_req *se_tmr = se_cmd->se_tmr_req; 791 struct se_tmr_req *se_tmr = se_cmd->se_tmr_req;
792 struct tcm_loop_tmr *tl_tmr = se_tmr->fabric_tmr_ptr; 792 struct tcm_loop_tmr *tl_tmr = se_tmr->fabric_tmr_ptr;
@@ -796,7 +796,6 @@ static int tcm_loop_queue_tm_rsp(struct se_cmd *se_cmd)
796 */ 796 */
797 atomic_set(&tl_tmr->tmr_complete, 1); 797 atomic_set(&tl_tmr->tmr_complete, 1);
798 wake_up(&tl_tmr->tl_tmr_wait); 798 wake_up(&tl_tmr->tl_tmr_wait);
799 return 0;
800} 799}
801 800
802static char *tcm_loop_dump_proto_id(struct tcm_loop_hba *tl_hba) 801static char *tcm_loop_dump_proto_id(struct tcm_loop_hba *tl_hba)
diff --git a/drivers/target/sbp/sbp_target.c b/drivers/target/sbp/sbp_target.c
index d3536f57444f..e51b09a04d52 100644
--- a/drivers/target/sbp/sbp_target.c
+++ b/drivers/target/sbp/sbp_target.c
@@ -1842,9 +1842,8 @@ static int sbp_queue_status(struct se_cmd *se_cmd)
1842 return sbp_send_sense(req); 1842 return sbp_send_sense(req);
1843} 1843}
1844 1844
1845static int sbp_queue_tm_rsp(struct se_cmd *se_cmd) 1845static void sbp_queue_tm_rsp(struct se_cmd *se_cmd)
1846{ 1846{
1847 return 0;
1848} 1847}
1849 1848
1850static int sbp_check_stop_free(struct se_cmd *se_cmd) 1849static int sbp_check_stop_free(struct se_cmd *se_cmd)
diff --git a/drivers/target/target_core_configfs.c b/drivers/target/target_core_configfs.c
index 4a8bd36d3958..e4d22933efaf 100644
--- a/drivers/target/target_core_configfs.c
+++ b/drivers/target/target_core_configfs.c
@@ -983,7 +983,6 @@ static ssize_t target_core_dev_pr_show_spc3_res(struct se_device *dev,
983 struct se_node_acl *se_nacl; 983 struct se_node_acl *se_nacl;
984 struct t10_pr_registration *pr_reg; 984 struct t10_pr_registration *pr_reg;
985 char i_buf[PR_REG_ISID_ID_LEN]; 985 char i_buf[PR_REG_ISID_ID_LEN];
986 int prf_isid;
987 986
988 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 987 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
989 988
@@ -992,12 +991,11 @@ static ssize_t target_core_dev_pr_show_spc3_res(struct se_device *dev,
992 return sprintf(page, "No SPC-3 Reservation holder\n"); 991 return sprintf(page, "No SPC-3 Reservation holder\n");
993 992
994 se_nacl = pr_reg->pr_reg_nacl; 993 se_nacl = pr_reg->pr_reg_nacl;
995 prf_isid = core_pr_dump_initiator_port(pr_reg, &i_buf[0], 994 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
996 PR_REG_ISID_ID_LEN);
997 995
998 return sprintf(page, "SPC-3 Reservation: %s Initiator: %s%s\n", 996 return sprintf(page, "SPC-3 Reservation: %s Initiator: %s%s\n",
999 se_nacl->se_tpg->se_tpg_tfo->get_fabric_name(), 997 se_nacl->se_tpg->se_tpg_tfo->get_fabric_name(),
1000 se_nacl->initiatorname, (prf_isid) ? &i_buf[0] : ""); 998 se_nacl->initiatorname, i_buf);
1001} 999}
1002 1000
1003static ssize_t target_core_dev_pr_show_spc2_res(struct se_device *dev, 1001static ssize_t target_core_dev_pr_show_spc2_res(struct se_device *dev,
@@ -1116,7 +1114,7 @@ static ssize_t target_core_dev_pr_show_attr_res_pr_registered_i_pts(
1116 unsigned char buf[384]; 1114 unsigned char buf[384];
1117 char i_buf[PR_REG_ISID_ID_LEN]; 1115 char i_buf[PR_REG_ISID_ID_LEN];
1118 ssize_t len = 0; 1116 ssize_t len = 0;
1119 int reg_count = 0, prf_isid; 1117 int reg_count = 0;
1120 1118
1121 len += sprintf(page+len, "SPC-3 PR Registrations:\n"); 1119 len += sprintf(page+len, "SPC-3 PR Registrations:\n");
1122 1120
@@ -1127,12 +1125,11 @@ static ssize_t target_core_dev_pr_show_attr_res_pr_registered_i_pts(
1127 memset(buf, 0, 384); 1125 memset(buf, 0, 384);
1128 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 1126 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
1129 tfo = pr_reg->pr_reg_nacl->se_tpg->se_tpg_tfo; 1127 tfo = pr_reg->pr_reg_nacl->se_tpg->se_tpg_tfo;
1130 prf_isid = core_pr_dump_initiator_port(pr_reg, &i_buf[0], 1128 core_pr_dump_initiator_port(pr_reg, i_buf,
1131 PR_REG_ISID_ID_LEN); 1129 PR_REG_ISID_ID_LEN);
1132 sprintf(buf, "%s Node: %s%s Key: 0x%016Lx PRgen: 0x%08x\n", 1130 sprintf(buf, "%s Node: %s%s Key: 0x%016Lx PRgen: 0x%08x\n",
1133 tfo->get_fabric_name(), 1131 tfo->get_fabric_name(),
1134 pr_reg->pr_reg_nacl->initiatorname, (prf_isid) ? 1132 pr_reg->pr_reg_nacl->initiatorname, i_buf, pr_reg->pr_res_key,
1135 &i_buf[0] : "", pr_reg->pr_res_key,
1136 pr_reg->pr_res_generation); 1133 pr_reg->pr_res_generation);
1137 1134
1138 if (len + strlen(buf) >= PAGE_SIZE) 1135 if (len + strlen(buf) >= PAGE_SIZE)
diff --git a/drivers/target/target_core_device.c b/drivers/target/target_core_device.c
index 4630481b6043..8f4142fe5f19 100644
--- a/drivers/target/target_core_device.c
+++ b/drivers/target/target_core_device.c
@@ -1410,7 +1410,6 @@ struct se_device *target_alloc_device(struct se_hba *hba, const char *name)
1410 INIT_LIST_HEAD(&dev->t10_alua.tg_pt_gps_list); 1410 INIT_LIST_HEAD(&dev->t10_alua.tg_pt_gps_list);
1411 spin_lock_init(&dev->t10_alua.tg_pt_gps_lock); 1411 spin_lock_init(&dev->t10_alua.tg_pt_gps_lock);
1412 1412
1413 dev->t10_pr.pr_aptpl_buf_len = PR_APTPL_BUF_LEN;
1414 dev->t10_wwn.t10_dev = dev; 1413 dev->t10_wwn.t10_dev = dev;
1415 dev->t10_alua.t10_dev = dev; 1414 dev->t10_alua.t10_dev = dev;
1416 1415
@@ -1545,7 +1544,7 @@ int core_dev_setup_virtual_lun0(void)
1545{ 1544{
1546 struct se_hba *hba; 1545 struct se_hba *hba;
1547 struct se_device *dev; 1546 struct se_device *dev;
1548 char buf[16]; 1547 char buf[] = "rd_pages=8,rd_nullio=1";
1549 int ret; 1548 int ret;
1550 1549
1551 hba = core_alloc_hba("rd_mcp", 0, HBA_FLAGS_INTERNAL_USE); 1550 hba = core_alloc_hba("rd_mcp", 0, HBA_FLAGS_INTERNAL_USE);
@@ -1558,8 +1557,6 @@ int core_dev_setup_virtual_lun0(void)
1558 goto out_free_hba; 1557 goto out_free_hba;
1559 } 1558 }
1560 1559
1561 memset(buf, 0, 16);
1562 sprintf(buf, "rd_pages=8");
1563 hba->transport->set_configfs_dev_params(dev, buf, sizeof(buf)); 1560 hba->transport->set_configfs_dev_params(dev, buf, sizeof(buf));
1564 1561
1565 ret = target_configure_device(dev); 1562 ret = target_configure_device(dev);
diff --git a/drivers/target/target_core_fabric_configfs.c b/drivers/target/target_core_fabric_configfs.c
index 04c775cb3e65..eb56eb129563 100644
--- a/drivers/target/target_core_fabric_configfs.c
+++ b/drivers/target/target_core_fabric_configfs.c
@@ -965,6 +965,19 @@ TF_CIT_SETUP(tpg_attrib, &target_fabric_tpg_attrib_item_ops, NULL, NULL);
965 965
966/* End of tfc_tpg_attrib_cit */ 966/* End of tfc_tpg_attrib_cit */
967 967
968/* Start of tfc_tpg_auth_cit */
969
970CONFIGFS_EATTR_OPS(target_fabric_tpg_auth, se_portal_group, tpg_auth_group);
971
972static struct configfs_item_operations target_fabric_tpg_auth_item_ops = {
973 .show_attribute = target_fabric_tpg_auth_attr_show,
974 .store_attribute = target_fabric_tpg_auth_attr_store,
975};
976
977TF_CIT_SETUP(tpg_auth, &target_fabric_tpg_auth_item_ops, NULL, NULL);
978
979/* End of tfc_tpg_attrib_cit */
980
968/* Start of tfc_tpg_param_cit */ 981/* Start of tfc_tpg_param_cit */
969 982
970CONFIGFS_EATTR_OPS(target_fabric_tpg_param, se_portal_group, tpg_param_group); 983CONFIGFS_EATTR_OPS(target_fabric_tpg_param, se_portal_group, tpg_param_group);
@@ -1030,8 +1043,9 @@ static struct config_group *target_fabric_make_tpg(
1030 se_tpg->tpg_group.default_groups[1] = &se_tpg->tpg_np_group; 1043 se_tpg->tpg_group.default_groups[1] = &se_tpg->tpg_np_group;
1031 se_tpg->tpg_group.default_groups[2] = &se_tpg->tpg_acl_group; 1044 se_tpg->tpg_group.default_groups[2] = &se_tpg->tpg_acl_group;
1032 se_tpg->tpg_group.default_groups[3] = &se_tpg->tpg_attrib_group; 1045 se_tpg->tpg_group.default_groups[3] = &se_tpg->tpg_attrib_group;
1033 se_tpg->tpg_group.default_groups[4] = &se_tpg->tpg_param_group; 1046 se_tpg->tpg_group.default_groups[4] = &se_tpg->tpg_auth_group;
1034 se_tpg->tpg_group.default_groups[5] = NULL; 1047 se_tpg->tpg_group.default_groups[5] = &se_tpg->tpg_param_group;
1048 se_tpg->tpg_group.default_groups[6] = NULL;
1035 1049
1036 config_group_init_type_name(&se_tpg->tpg_group, name, 1050 config_group_init_type_name(&se_tpg->tpg_group, name,
1037 &TF_CIT_TMPL(tf)->tfc_tpg_base_cit); 1051 &TF_CIT_TMPL(tf)->tfc_tpg_base_cit);
@@ -1043,6 +1057,8 @@ static struct config_group *target_fabric_make_tpg(
1043 &TF_CIT_TMPL(tf)->tfc_tpg_nacl_cit); 1057 &TF_CIT_TMPL(tf)->tfc_tpg_nacl_cit);
1044 config_group_init_type_name(&se_tpg->tpg_attrib_group, "attrib", 1058 config_group_init_type_name(&se_tpg->tpg_attrib_group, "attrib",
1045 &TF_CIT_TMPL(tf)->tfc_tpg_attrib_cit); 1059 &TF_CIT_TMPL(tf)->tfc_tpg_attrib_cit);
1060 config_group_init_type_name(&se_tpg->tpg_auth_group, "auth",
1061 &TF_CIT_TMPL(tf)->tfc_tpg_auth_cit);
1046 config_group_init_type_name(&se_tpg->tpg_param_group, "param", 1062 config_group_init_type_name(&se_tpg->tpg_param_group, "param",
1047 &TF_CIT_TMPL(tf)->tfc_tpg_param_cit); 1063 &TF_CIT_TMPL(tf)->tfc_tpg_param_cit);
1048 1064
@@ -1202,6 +1218,7 @@ int target_fabric_setup_cits(struct target_fabric_configfs *tf)
1202 target_fabric_setup_tpg_np_cit(tf); 1218 target_fabric_setup_tpg_np_cit(tf);
1203 target_fabric_setup_tpg_np_base_cit(tf); 1219 target_fabric_setup_tpg_np_base_cit(tf);
1204 target_fabric_setup_tpg_attrib_cit(tf); 1220 target_fabric_setup_tpg_attrib_cit(tf);
1221 target_fabric_setup_tpg_auth_cit(tf);
1205 target_fabric_setup_tpg_param_cit(tf); 1222 target_fabric_setup_tpg_param_cit(tf);
1206 target_fabric_setup_tpg_nacl_cit(tf); 1223 target_fabric_setup_tpg_nacl_cit(tf);
1207 target_fabric_setup_tpg_nacl_base_cit(tf); 1224 target_fabric_setup_tpg_nacl_base_cit(tf);
diff --git a/drivers/target/target_core_pr.c b/drivers/target/target_core_pr.c
index 3240f2cc81ef..bd78faf67c6b 100644
--- a/drivers/target/target_core_pr.c
+++ b/drivers/target/target_core_pr.c
@@ -53,18 +53,28 @@ struct pr_transport_id_holder {
53 struct list_head dest_list; 53 struct list_head dest_list;
54}; 54};
55 55
56int core_pr_dump_initiator_port( 56void core_pr_dump_initiator_port(
57 struct t10_pr_registration *pr_reg, 57 struct t10_pr_registration *pr_reg,
58 char *buf, 58 char *buf,
59 u32 size) 59 u32 size)
60{ 60{
61 if (!pr_reg->isid_present_at_reg) 61 if (!pr_reg->isid_present_at_reg)
62 return 0; 62 buf[0] = '\0';
63 63
64 snprintf(buf, size, ",i,0x%s", &pr_reg->pr_reg_isid[0]); 64 snprintf(buf, size, ",i,0x%s", pr_reg->pr_reg_isid);
65 return 1;
66} 65}
67 66
67enum register_type {
68 REGISTER,
69 REGISTER_AND_IGNORE_EXISTING_KEY,
70 REGISTER_AND_MOVE,
71};
72
73enum preempt_type {
74 PREEMPT,
75 PREEMPT_AND_ABORT,
76};
77
68static void __core_scsi3_complete_pro_release(struct se_device *, struct se_node_acl *, 78static void __core_scsi3_complete_pro_release(struct se_device *, struct se_node_acl *,
69 struct t10_pr_registration *, int); 79 struct t10_pr_registration *, int);
70 80
@@ -596,14 +606,6 @@ static struct t10_pr_registration *__core_scsi3_do_alloc_registration(
596 return NULL; 606 return NULL;
597 } 607 }
598 608
599 pr_reg->pr_aptpl_buf = kzalloc(dev->t10_pr.pr_aptpl_buf_len,
600 GFP_ATOMIC);
601 if (!pr_reg->pr_aptpl_buf) {
602 pr_err("Unable to allocate pr_reg->pr_aptpl_buf\n");
603 kmem_cache_free(t10_pr_reg_cache, pr_reg);
604 return NULL;
605 }
606
607 INIT_LIST_HEAD(&pr_reg->pr_reg_list); 609 INIT_LIST_HEAD(&pr_reg->pr_reg_list);
608 INIT_LIST_HEAD(&pr_reg->pr_reg_abort_list); 610 INIT_LIST_HEAD(&pr_reg->pr_reg_abort_list);
609 INIT_LIST_HEAD(&pr_reg->pr_reg_aptpl_list); 611 INIT_LIST_HEAD(&pr_reg->pr_reg_aptpl_list);
@@ -794,7 +796,6 @@ int core_scsi3_alloc_aptpl_registration(
794 pr_err("Unable to allocate struct t10_pr_registration\n"); 796 pr_err("Unable to allocate struct t10_pr_registration\n");
795 return -ENOMEM; 797 return -ENOMEM;
796 } 798 }
797 pr_reg->pr_aptpl_buf = kzalloc(pr_tmpl->pr_aptpl_buf_len, GFP_KERNEL);
798 799
799 INIT_LIST_HEAD(&pr_reg->pr_reg_list); 800 INIT_LIST_HEAD(&pr_reg->pr_reg_list);
800 INIT_LIST_HEAD(&pr_reg->pr_reg_abort_list); 801 INIT_LIST_HEAD(&pr_reg->pr_reg_abort_list);
@@ -848,11 +849,9 @@ static void core_scsi3_aptpl_reserve(
848 struct t10_pr_registration *pr_reg) 849 struct t10_pr_registration *pr_reg)
849{ 850{
850 char i_buf[PR_REG_ISID_ID_LEN]; 851 char i_buf[PR_REG_ISID_ID_LEN];
851 int prf_isid;
852 852
853 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 853 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
854 prf_isid = core_pr_dump_initiator_port(pr_reg, &i_buf[0], 854 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
855 PR_REG_ISID_ID_LEN);
856 855
857 spin_lock(&dev->dev_reservation_lock); 856 spin_lock(&dev->dev_reservation_lock);
858 dev->dev_pr_res_holder = pr_reg; 857 dev->dev_pr_res_holder = pr_reg;
@@ -865,11 +864,11 @@ static void core_scsi3_aptpl_reserve(
865 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0); 864 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
866 pr_debug("SPC-3 PR [%s] RESERVE Node: %s%s\n", 865 pr_debug("SPC-3 PR [%s] RESERVE Node: %s%s\n",
867 tpg->se_tpg_tfo->get_fabric_name(), node_acl->initiatorname, 866 tpg->se_tpg_tfo->get_fabric_name(), node_acl->initiatorname,
868 (prf_isid) ? &i_buf[0] : ""); 867 i_buf);
869} 868}
870 869
871static void __core_scsi3_add_registration(struct se_device *, struct se_node_acl *, 870static void __core_scsi3_add_registration(struct se_device *, struct se_node_acl *,
872 struct t10_pr_registration *, int, int); 871 struct t10_pr_registration *, enum register_type, int);
873 872
874static int __core_scsi3_check_aptpl_registration( 873static int __core_scsi3_check_aptpl_registration(
875 struct se_device *dev, 874 struct se_device *dev,
@@ -962,21 +961,19 @@ static void __core_scsi3_dump_registration(
962 struct se_device *dev, 961 struct se_device *dev,
963 struct se_node_acl *nacl, 962 struct se_node_acl *nacl,
964 struct t10_pr_registration *pr_reg, 963 struct t10_pr_registration *pr_reg,
965 int register_type) 964 enum register_type register_type)
966{ 965{
967 struct se_portal_group *se_tpg = nacl->se_tpg; 966 struct se_portal_group *se_tpg = nacl->se_tpg;
968 char i_buf[PR_REG_ISID_ID_LEN]; 967 char i_buf[PR_REG_ISID_ID_LEN];
969 int prf_isid;
970 968
971 memset(&i_buf[0], 0, PR_REG_ISID_ID_LEN); 969 memset(&i_buf[0], 0, PR_REG_ISID_ID_LEN);
972 prf_isid = core_pr_dump_initiator_port(pr_reg, &i_buf[0], 970 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
973 PR_REG_ISID_ID_LEN);
974 971
975 pr_debug("SPC-3 PR [%s] Service Action: REGISTER%s Initiator" 972 pr_debug("SPC-3 PR [%s] Service Action: REGISTER%s Initiator"
976 " Node: %s%s\n", tfo->get_fabric_name(), (register_type == 2) ? 973 " Node: %s%s\n", tfo->get_fabric_name(), (register_type == REGISTER_AND_MOVE) ?
977 "_AND_MOVE" : (register_type == 1) ? 974 "_AND_MOVE" : (register_type == REGISTER_AND_IGNORE_EXISTING_KEY) ?
978 "_AND_IGNORE_EXISTING_KEY" : "", nacl->initiatorname, 975 "_AND_IGNORE_EXISTING_KEY" : "", nacl->initiatorname,
979 (prf_isid) ? i_buf : ""); 976 i_buf);
980 pr_debug("SPC-3 PR [%s] registration on Target Port: %s,0x%04x\n", 977 pr_debug("SPC-3 PR [%s] registration on Target Port: %s,0x%04x\n",
981 tfo->get_fabric_name(), tfo->tpg_get_wwn(se_tpg), 978 tfo->get_fabric_name(), tfo->tpg_get_wwn(se_tpg),
982 tfo->tpg_get_tag(se_tpg)); 979 tfo->tpg_get_tag(se_tpg));
@@ -998,7 +995,7 @@ static void __core_scsi3_add_registration(
998 struct se_device *dev, 995 struct se_device *dev,
999 struct se_node_acl *nacl, 996 struct se_node_acl *nacl,
1000 struct t10_pr_registration *pr_reg, 997 struct t10_pr_registration *pr_reg,
1001 int register_type, 998 enum register_type register_type,
1002 int register_move) 999 int register_move)
1003{ 1000{
1004 struct target_core_fabric_ops *tfo = nacl->se_tpg->se_tpg_tfo; 1001 struct target_core_fabric_ops *tfo = nacl->se_tpg->se_tpg_tfo;
@@ -1064,7 +1061,7 @@ static int core_scsi3_alloc_registration(
1064 u64 sa_res_key, 1061 u64 sa_res_key,
1065 int all_tg_pt, 1062 int all_tg_pt,
1066 int aptpl, 1063 int aptpl,
1067 int register_type, 1064 enum register_type register_type,
1068 int register_move) 1065 int register_move)
1069{ 1066{
1070 struct t10_pr_registration *pr_reg; 1067 struct t10_pr_registration *pr_reg;
@@ -1225,11 +1222,9 @@ static void __core_scsi3_free_registration(
1225 pr_reg->pr_reg_nacl->se_tpg->se_tpg_tfo; 1222 pr_reg->pr_reg_nacl->se_tpg->se_tpg_tfo;
1226 struct t10_reservation *pr_tmpl = &dev->t10_pr; 1223 struct t10_reservation *pr_tmpl = &dev->t10_pr;
1227 char i_buf[PR_REG_ISID_ID_LEN]; 1224 char i_buf[PR_REG_ISID_ID_LEN];
1228 int prf_isid;
1229 1225
1230 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 1226 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
1231 prf_isid = core_pr_dump_initiator_port(pr_reg, &i_buf[0], 1227 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
1232 PR_REG_ISID_ID_LEN);
1233 1228
1234 pr_reg->pr_reg_deve->def_pr_registered = 0; 1229 pr_reg->pr_reg_deve->def_pr_registered = 0;
1235 pr_reg->pr_reg_deve->pr_res_key = 0; 1230 pr_reg->pr_reg_deve->pr_res_key = 0;
@@ -1257,7 +1252,7 @@ static void __core_scsi3_free_registration(
1257 pr_debug("SPC-3 PR [%s] Service Action: UNREGISTER Initiator" 1252 pr_debug("SPC-3 PR [%s] Service Action: UNREGISTER Initiator"
1258 " Node: %s%s\n", tfo->get_fabric_name(), 1253 " Node: %s%s\n", tfo->get_fabric_name(),
1259 pr_reg->pr_reg_nacl->initiatorname, 1254 pr_reg->pr_reg_nacl->initiatorname,
1260 (prf_isid) ? &i_buf[0] : ""); 1255 i_buf);
1261 pr_debug("SPC-3 PR [%s] for %s TCM Subsystem %s Object Target" 1256 pr_debug("SPC-3 PR [%s] for %s TCM Subsystem %s Object Target"
1262 " Port(s)\n", tfo->get_fabric_name(), 1257 " Port(s)\n", tfo->get_fabric_name(),
1263 (pr_reg->pr_reg_all_tg_pt) ? "ALL" : "SINGLE", 1258 (pr_reg->pr_reg_all_tg_pt) ? "ALL" : "SINGLE",
@@ -1269,7 +1264,6 @@ static void __core_scsi3_free_registration(
1269 if (!preempt_and_abort_list) { 1264 if (!preempt_and_abort_list) {
1270 pr_reg->pr_reg_deve = NULL; 1265 pr_reg->pr_reg_deve = NULL;
1271 pr_reg->pr_reg_nacl = NULL; 1266 pr_reg->pr_reg_nacl = NULL;
1272 kfree(pr_reg->pr_aptpl_buf);
1273 kmem_cache_free(t10_pr_reg_cache, pr_reg); 1267 kmem_cache_free(t10_pr_reg_cache, pr_reg);
1274 return; 1268 return;
1275 } 1269 }
@@ -1338,7 +1332,6 @@ void core_scsi3_free_all_registrations(
1338 list_for_each_entry_safe(pr_reg, pr_reg_tmp, &pr_tmpl->aptpl_reg_list, 1332 list_for_each_entry_safe(pr_reg, pr_reg_tmp, &pr_tmpl->aptpl_reg_list,
1339 pr_reg_aptpl_list) { 1333 pr_reg_aptpl_list) {
1340 list_del(&pr_reg->pr_reg_aptpl_list); 1334 list_del(&pr_reg->pr_reg_aptpl_list);
1341 kfree(pr_reg->pr_aptpl_buf);
1342 kmem_cache_free(t10_pr_reg_cache, pr_reg); 1335 kmem_cache_free(t10_pr_reg_cache, pr_reg);
1343 } 1336 }
1344 spin_unlock(&pr_tmpl->aptpl_reg_lock); 1337 spin_unlock(&pr_tmpl->aptpl_reg_lock);
@@ -1453,7 +1446,7 @@ core_scsi3_decode_spec_i_port(
1453 char *iport_ptr = NULL, dest_iport[64], i_buf[PR_REG_ISID_ID_LEN]; 1446 char *iport_ptr = NULL, dest_iport[64], i_buf[PR_REG_ISID_ID_LEN];
1454 sense_reason_t ret; 1447 sense_reason_t ret;
1455 u32 tpdl, tid_len = 0; 1448 u32 tpdl, tid_len = 0;
1456 int dest_local_nexus, prf_isid; 1449 int dest_local_nexus;
1457 u32 dest_rtpi = 0; 1450 u32 dest_rtpi = 0;
1458 1451
1459 memset(dest_iport, 0, 64); 1452 memset(dest_iport, 0, 64);
@@ -1764,8 +1757,7 @@ core_scsi3_decode_spec_i_port(
1764 kfree(tidh); 1757 kfree(tidh);
1765 1758
1766 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 1759 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
1767 prf_isid = core_pr_dump_initiator_port(dest_pr_reg, &i_buf[0], 1760 core_pr_dump_initiator_port(dest_pr_reg, i_buf, PR_REG_ISID_ID_LEN);
1768 PR_REG_ISID_ID_LEN);
1769 1761
1770 __core_scsi3_add_registration(cmd->se_dev, dest_node_acl, 1762 __core_scsi3_add_registration(cmd->se_dev, dest_node_acl,
1771 dest_pr_reg, 0, 0); 1763 dest_pr_reg, 0, 0);
@@ -1773,8 +1765,7 @@ core_scsi3_decode_spec_i_port(
1773 pr_debug("SPC-3 PR [%s] SPEC_I_PT: Successfully" 1765 pr_debug("SPC-3 PR [%s] SPEC_I_PT: Successfully"
1774 " registered Transport ID for Node: %s%s Mapped LUN:" 1766 " registered Transport ID for Node: %s%s Mapped LUN:"
1775 " %u\n", dest_tpg->se_tpg_tfo->get_fabric_name(), 1767 " %u\n", dest_tpg->se_tpg_tfo->get_fabric_name(),
1776 dest_node_acl->initiatorname, (prf_isid) ? 1768 dest_node_acl->initiatorname, i_buf, dest_se_deve->mapped_lun);
1777 &i_buf[0] : "", dest_se_deve->mapped_lun);
1778 1769
1779 if (dest_local_nexus) 1770 if (dest_local_nexus)
1780 continue; 1771 continue;
@@ -1813,7 +1804,6 @@ out:
1813 kmem_cache_free(t10_pr_reg_cache, pr_reg_tmp); 1804 kmem_cache_free(t10_pr_reg_cache, pr_reg_tmp);
1814 } 1805 }
1815 1806
1816 kfree(dest_pr_reg->pr_aptpl_buf);
1817 kmem_cache_free(t10_pr_reg_cache, dest_pr_reg); 1807 kmem_cache_free(t10_pr_reg_cache, dest_pr_reg);
1818 1808
1819 if (dest_local_nexus) 1809 if (dest_local_nexus)
@@ -1826,14 +1816,10 @@ out:
1826 return ret; 1816 return ret;
1827} 1817}
1828 1818
1829/* 1819static int core_scsi3_update_aptpl_buf(
1830 * Called with struct se_device->dev_reservation_lock held
1831 */
1832static int __core_scsi3_update_aptpl_buf(
1833 struct se_device *dev, 1820 struct se_device *dev,
1834 unsigned char *buf, 1821 unsigned char *buf,
1835 u32 pr_aptpl_buf_len, 1822 u32 pr_aptpl_buf_len)
1836 int clear_aptpl_metadata)
1837{ 1823{
1838 struct se_lun *lun; 1824 struct se_lun *lun;
1839 struct se_portal_group *tpg; 1825 struct se_portal_group *tpg;
@@ -1841,20 +1827,13 @@ static int __core_scsi3_update_aptpl_buf(
1841 unsigned char tmp[512], isid_buf[32]; 1827 unsigned char tmp[512], isid_buf[32];
1842 ssize_t len = 0; 1828 ssize_t len = 0;
1843 int reg_count = 0; 1829 int reg_count = 0;
1830 int ret = 0;
1844 1831
1845 memset(buf, 0, pr_aptpl_buf_len); 1832 spin_lock(&dev->dev_reservation_lock);
1846 /* 1833 spin_lock(&dev->t10_pr.registration_lock);
1847 * Called to clear metadata once APTPL has been deactivated.
1848 */
1849 if (clear_aptpl_metadata) {
1850 snprintf(buf, pr_aptpl_buf_len,
1851 "No Registrations or Reservations\n");
1852 return 0;
1853 }
1854 /* 1834 /*
1855 * Walk the registration list.. 1835 * Walk the registration list..
1856 */ 1836 */
1857 spin_lock(&dev->t10_pr.registration_lock);
1858 list_for_each_entry(pr_reg, &dev->t10_pr.registration_list, 1837 list_for_each_entry(pr_reg, &dev->t10_pr.registration_list,
1859 pr_reg_list) { 1838 pr_reg_list) {
1860 1839
@@ -1900,8 +1879,8 @@ static int __core_scsi3_update_aptpl_buf(
1900 if ((len + strlen(tmp) >= pr_aptpl_buf_len)) { 1879 if ((len + strlen(tmp) >= pr_aptpl_buf_len)) {
1901 pr_err("Unable to update renaming" 1880 pr_err("Unable to update renaming"
1902 " APTPL metadata\n"); 1881 " APTPL metadata\n");
1903 spin_unlock(&dev->t10_pr.registration_lock); 1882 ret = -EMSGSIZE;
1904 return -EMSGSIZE; 1883 goto out;
1905 } 1884 }
1906 len += sprintf(buf+len, "%s", tmp); 1885 len += sprintf(buf+len, "%s", tmp);
1907 1886
@@ -1918,48 +1897,32 @@ static int __core_scsi3_update_aptpl_buf(
1918 if ((len + strlen(tmp) >= pr_aptpl_buf_len)) { 1897 if ((len + strlen(tmp) >= pr_aptpl_buf_len)) {
1919 pr_err("Unable to update renaming" 1898 pr_err("Unable to update renaming"
1920 " APTPL metadata\n"); 1899 " APTPL metadata\n");
1921 spin_unlock(&dev->t10_pr.registration_lock); 1900 ret = -EMSGSIZE;
1922 return -EMSGSIZE; 1901 goto out;
1923 } 1902 }
1924 len += sprintf(buf+len, "%s", tmp); 1903 len += sprintf(buf+len, "%s", tmp);
1925 reg_count++; 1904 reg_count++;
1926 } 1905 }
1927 spin_unlock(&dev->t10_pr.registration_lock);
1928 1906
1929 if (!reg_count) 1907 if (!reg_count)
1930 len += sprintf(buf+len, "No Registrations or Reservations"); 1908 len += sprintf(buf+len, "No Registrations or Reservations");
1931 1909
1932 return 0; 1910out:
1933} 1911 spin_unlock(&dev->t10_pr.registration_lock);
1934
1935static int core_scsi3_update_aptpl_buf(
1936 struct se_device *dev,
1937 unsigned char *buf,
1938 u32 pr_aptpl_buf_len,
1939 int clear_aptpl_metadata)
1940{
1941 int ret;
1942
1943 spin_lock(&dev->dev_reservation_lock);
1944 ret = __core_scsi3_update_aptpl_buf(dev, buf, pr_aptpl_buf_len,
1945 clear_aptpl_metadata);
1946 spin_unlock(&dev->dev_reservation_lock); 1912 spin_unlock(&dev->dev_reservation_lock);
1947 1913
1948 return ret; 1914 return ret;
1949} 1915}
1950 1916
1951/*
1952 * Called with struct se_device->aptpl_file_mutex held
1953 */
1954static int __core_scsi3_write_aptpl_to_file( 1917static int __core_scsi3_write_aptpl_to_file(
1955 struct se_device *dev, 1918 struct se_device *dev,
1956 unsigned char *buf, 1919 unsigned char *buf)
1957 u32 pr_aptpl_buf_len)
1958{ 1920{
1959 struct t10_wwn *wwn = &dev->t10_wwn; 1921 struct t10_wwn *wwn = &dev->t10_wwn;
1960 struct file *file; 1922 struct file *file;
1961 int flags = O_RDWR | O_CREAT | O_TRUNC; 1923 int flags = O_RDWR | O_CREAT | O_TRUNC;
1962 char path[512]; 1924 char path[512];
1925 u32 pr_aptpl_buf_len;
1963 int ret; 1926 int ret;
1964 1927
1965 memset(path, 0, 512); 1928 memset(path, 0, 512);
@@ -1978,8 +1941,7 @@ static int __core_scsi3_write_aptpl_to_file(
1978 return PTR_ERR(file); 1941 return PTR_ERR(file);
1979 } 1942 }
1980 1943
1981 if (!pr_aptpl_buf_len) 1944 pr_aptpl_buf_len = (strlen(buf) + 1); /* Add extra for NULL */
1982 pr_aptpl_buf_len = (strlen(&buf[0]) + 1); /* Add extra for NULL */
1983 1945
1984 ret = kernel_write(file, buf, pr_aptpl_buf_len, 0); 1946 ret = kernel_write(file, buf, pr_aptpl_buf_len, 0);
1985 1947
@@ -1990,60 +1952,64 @@ static int __core_scsi3_write_aptpl_to_file(
1990 return ret ? -EIO : 0; 1952 return ret ? -EIO : 0;
1991} 1953}
1992 1954
1993static int 1955/*
1994core_scsi3_update_and_write_aptpl(struct se_device *dev, unsigned char *in_buf, 1956 * Clear the APTPL metadata if APTPL has been disabled, otherwise
1995 u32 in_pr_aptpl_buf_len) 1957 * write out the updated metadata to struct file for this SCSI device.
1958 */
1959static sense_reason_t core_scsi3_update_and_write_aptpl(struct se_device *dev, bool aptpl)
1996{ 1960{
1997 unsigned char null_buf[64], *buf; 1961 unsigned char *buf;
1998 u32 pr_aptpl_buf_len; 1962 int rc;
1999 int clear_aptpl_metadata = 0;
2000 int ret;
2001 1963
2002 /* 1964 if (!aptpl) {
2003 * Can be called with a NULL pointer from PROUT service action CLEAR 1965 char *null_buf = "No Registrations or Reservations\n";
2004 */ 1966
2005 if (!in_buf) { 1967 rc = __core_scsi3_write_aptpl_to_file(dev, null_buf);
2006 memset(null_buf, 0, 64); 1968 dev->t10_pr.pr_aptpl_active = 0;
2007 buf = &null_buf[0]; 1969 pr_debug("SPC-3 PR: Set APTPL Bit Deactivated\n");
2008 /* 1970
2009 * This will clear the APTPL metadata to: 1971 if (rc)
2010 * "No Registrations or Reservations" status 1972 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
2011 */ 1973
2012 pr_aptpl_buf_len = 64; 1974 return 0;
2013 clear_aptpl_metadata = 1;
2014 } else {
2015 buf = in_buf;
2016 pr_aptpl_buf_len = in_pr_aptpl_buf_len;
2017 } 1975 }
2018 1976
2019 ret = core_scsi3_update_aptpl_buf(dev, buf, pr_aptpl_buf_len, 1977 buf = kzalloc(PR_APTPL_BUF_LEN, GFP_KERNEL);
2020 clear_aptpl_metadata); 1978 if (!buf)
2021 if (ret != 0) 1979 return TCM_OUT_OF_RESOURCES;
2022 return ret;
2023 1980
2024 /* 1981 rc = core_scsi3_update_aptpl_buf(dev, buf, PR_APTPL_BUF_LEN);
2025 * __core_scsi3_write_aptpl_to_file() will call strlen() 1982 if (rc < 0) {
2026 * on the passed buf to determine pr_aptpl_buf_len. 1983 kfree(buf);
2027 */ 1984 return TCM_OUT_OF_RESOURCES;
2028 return __core_scsi3_write_aptpl_to_file(dev, buf, 0); 1985 }
1986
1987 rc = __core_scsi3_write_aptpl_to_file(dev, buf);
1988 if (rc != 0) {
1989 pr_err("SPC-3 PR: Could not update APTPL\n");
1990 kfree(buf);
1991 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
1992 }
1993 dev->t10_pr.pr_aptpl_active = 1;
1994 kfree(buf);
1995 pr_debug("SPC-3 PR: Set APTPL Bit Activated\n");
1996 return 0;
2029} 1997}
2030 1998
2031static sense_reason_t 1999static sense_reason_t
2032core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key, 2000core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
2033 int aptpl, int all_tg_pt, int spec_i_pt, int ignore_key) 2001 bool aptpl, bool all_tg_pt, bool spec_i_pt, enum register_type register_type)
2034{ 2002{
2035 struct se_session *se_sess = cmd->se_sess; 2003 struct se_session *se_sess = cmd->se_sess;
2036 struct se_device *dev = cmd->se_dev; 2004 struct se_device *dev = cmd->se_dev;
2037 struct se_dev_entry *se_deve; 2005 struct se_dev_entry *se_deve;
2038 struct se_lun *se_lun = cmd->se_lun; 2006 struct se_lun *se_lun = cmd->se_lun;
2039 struct se_portal_group *se_tpg; 2007 struct se_portal_group *se_tpg;
2040 struct t10_pr_registration *pr_reg, *pr_reg_p, *pr_reg_tmp, *pr_reg_e; 2008 struct t10_pr_registration *pr_reg, *pr_reg_p, *pr_reg_tmp;
2041 struct t10_reservation *pr_tmpl = &dev->t10_pr; 2009 struct t10_reservation *pr_tmpl = &dev->t10_pr;
2042 /* Used for APTPL metadata w/ UNREGISTER */
2043 unsigned char *pr_aptpl_buf = NULL;
2044 unsigned char isid_buf[PR_REG_ISID_LEN], *isid_ptr = NULL; 2010 unsigned char isid_buf[PR_REG_ISID_LEN], *isid_ptr = NULL;
2045 sense_reason_t ret = TCM_NO_SENSE; 2011 sense_reason_t ret = TCM_NO_SENSE;
2046 int pr_holder = 0, type; 2012 int pr_holder = 0;
2047 2013
2048 if (!se_sess || !se_lun) { 2014 if (!se_sess || !se_lun) {
2049 pr_err("SPC-3 PR: se_sess || struct se_lun is NULL!\n"); 2015 pr_err("SPC-3 PR: se_sess || struct se_lun is NULL!\n");
@@ -2061,8 +2027,8 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
2061 /* 2027 /*
2062 * Follow logic from spc4r17 Section 5.7.7, Register Behaviors Table 47 2028 * Follow logic from spc4r17 Section 5.7.7, Register Behaviors Table 47
2063 */ 2029 */
2064 pr_reg_e = core_scsi3_locate_pr_reg(dev, se_sess->se_node_acl, se_sess); 2030 pr_reg = core_scsi3_locate_pr_reg(dev, se_sess->se_node_acl, se_sess);
2065 if (!pr_reg_e) { 2031 if (!pr_reg) {
2066 if (res_key) { 2032 if (res_key) {
2067 pr_warn("SPC-3 PR: Reservation Key non-zero" 2033 pr_warn("SPC-3 PR: Reservation Key non-zero"
2068 " for SA REGISTER, returning CONFLICT\n"); 2034 " for SA REGISTER, returning CONFLICT\n");
@@ -2083,7 +2049,7 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
2083 if (core_scsi3_alloc_registration(cmd->se_dev, 2049 if (core_scsi3_alloc_registration(cmd->se_dev,
2084 se_sess->se_node_acl, se_deve, isid_ptr, 2050 se_sess->se_node_acl, se_deve, isid_ptr,
2085 sa_res_key, all_tg_pt, aptpl, 2051 sa_res_key, all_tg_pt, aptpl,
2086 ignore_key, 0)) { 2052 register_type, 0)) {
2087 pr_err("Unable to allocate" 2053 pr_err("Unable to allocate"
2088 " struct t10_pr_registration\n"); 2054 " struct t10_pr_registration\n");
2089 return TCM_INVALID_PARAMETER_LIST; 2055 return TCM_INVALID_PARAMETER_LIST;
@@ -2102,97 +2068,68 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
2102 if (ret != 0) 2068 if (ret != 0)
2103 return ret; 2069 return ret;
2104 } 2070 }
2105 /*
2106 * Nothing left to do for the APTPL=0 case.
2107 */
2108 if (!aptpl) {
2109 pr_tmpl->pr_aptpl_active = 0;
2110 core_scsi3_update_and_write_aptpl(cmd->se_dev, NULL, 0);
2111 pr_debug("SPC-3 PR: Set APTPL Bit Deactivated for"
2112 " REGISTER\n");
2113 return 0;
2114 }
2115 /*
2116 * Locate the newly allocated local I_T Nexus *pr_reg, and
2117 * update the APTPL metadata information using its
2118 * preallocated *pr_reg->pr_aptpl_buf.
2119 */
2120 pr_reg = core_scsi3_locate_pr_reg(cmd->se_dev,
2121 se_sess->se_node_acl, se_sess);
2122
2123 if (core_scsi3_update_and_write_aptpl(cmd->se_dev,
2124 &pr_reg->pr_aptpl_buf[0],
2125 pr_tmpl->pr_aptpl_buf_len)) {
2126 pr_tmpl->pr_aptpl_active = 1;
2127 pr_debug("SPC-3 PR: Set APTPL Bit Activated for REGISTER\n");
2128 }
2129 2071
2130 goto out_put_pr_reg; 2072 return core_scsi3_update_and_write_aptpl(dev, aptpl);
2131 } 2073 }
2132 2074
2133 /* 2075 /* ok, existing registration */
2134 * Locate the existing *pr_reg via struct se_node_acl pointers 2076
2135 */ 2077 if ((register_type == REGISTER) && (res_key != pr_reg->pr_res_key)) {
2136 pr_reg = pr_reg_e; 2078 pr_err("SPC-3 PR REGISTER: Received"
2137 type = pr_reg->pr_res_type; 2079 " res_key: 0x%016Lx does not match"
2138 2080 " existing SA REGISTER res_key:"
2139 if (!ignore_key) { 2081 " 0x%016Lx\n", res_key,
2140 if (res_key != pr_reg->pr_res_key) { 2082 pr_reg->pr_res_key);
2141 pr_err("SPC-3 PR REGISTER: Received" 2083 ret = TCM_RESERVATION_CONFLICT;
2142 " res_key: 0x%016Lx does not match" 2084 goto out;
2143 " existing SA REGISTER res_key:"
2144 " 0x%016Lx\n", res_key,
2145 pr_reg->pr_res_key);
2146 ret = TCM_RESERVATION_CONFLICT;
2147 goto out_put_pr_reg;
2148 }
2149 } 2085 }
2150 2086
2151 if (spec_i_pt) { 2087 if (spec_i_pt) {
2152 pr_err("SPC-3 PR UNREGISTER: SPEC_I_PT" 2088 pr_err("SPC-3 PR REGISTER: SPEC_I_PT"
2153 " set while sa_res_key=0\n"); 2089 " set on a registered nexus\n");
2154 ret = TCM_INVALID_PARAMETER_LIST; 2090 ret = TCM_INVALID_PARAMETER_LIST;
2155 goto out_put_pr_reg; 2091 goto out;
2156 } 2092 }
2157 2093
2158 /* 2094 /*
2159 * An existing ALL_TG_PT=1 registration being released 2095 * An existing ALL_TG_PT=1 registration being released
2160 * must also set ALL_TG_PT=1 in the incoming PROUT. 2096 * must also set ALL_TG_PT=1 in the incoming PROUT.
2161 */ 2097 */
2162 if (pr_reg->pr_reg_all_tg_pt && !(all_tg_pt)) { 2098 if (pr_reg->pr_reg_all_tg_pt && !all_tg_pt) {
2163 pr_err("SPC-3 PR UNREGISTER: ALL_TG_PT=1" 2099 pr_err("SPC-3 PR REGISTER: ALL_TG_PT=1"
2164 " registration exists, but ALL_TG_PT=1 bit not" 2100 " registration exists, but ALL_TG_PT=1 bit not"
2165 " present in received PROUT\n"); 2101 " present in received PROUT\n");
2166 ret = TCM_INVALID_CDB_FIELD; 2102 ret = TCM_INVALID_CDB_FIELD;
2167 goto out_put_pr_reg; 2103 goto out;
2168 } 2104 }
2169 2105
2170 /* 2106 /*
2171 * Allocate APTPL metadata buffer used for UNREGISTER ops 2107 * sa_res_key=1 Change Reservation Key for registered I_T Nexus.
2172 */ 2108 */
2173 if (aptpl) { 2109 if (sa_res_key) {
2174 pr_aptpl_buf = kzalloc(pr_tmpl->pr_aptpl_buf_len, 2110 /*
2175 GFP_KERNEL); 2111 * Increment PRgeneration counter for struct se_device"
2176 if (!pr_aptpl_buf) { 2112 * upon a successful REGISTER, see spc4r17 section 6.3.2
2177 pr_err("Unable to allocate" 2113 * READ_KEYS service action.
2178 " pr_aptpl_buf\n"); 2114 */
2179 ret = TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 2115 pr_reg->pr_res_generation = core_scsi3_pr_generation(cmd->se_dev);
2180 goto out_put_pr_reg; 2116 pr_reg->pr_res_key = sa_res_key;
2181 } 2117 pr_debug("SPC-3 PR [%s] REGISTER%s: Changed Reservation"
2182 } 2118 " Key for %s to: 0x%016Lx PRgeneration:"
2119 " 0x%08x\n", cmd->se_tfo->get_fabric_name(),
2120 (register_type == REGISTER_AND_IGNORE_EXISTING_KEY) ? "_AND_IGNORE_EXISTING_KEY" : "",
2121 pr_reg->pr_reg_nacl->initiatorname,
2122 pr_reg->pr_res_key, pr_reg->pr_res_generation);
2183 2123
2184 /* 2124 } else {
2185 * sa_res_key=0 Unregister Reservation Key for registered I_T 2125 /*
2186 * Nexus sa_res_key=1 Change Reservation Key for registered I_T 2126 * sa_res_key=0 Unregister Reservation Key for registered I_T Nexus.
2187 * Nexus. 2127 */
2188 */
2189 if (!sa_res_key) {
2190 pr_holder = core_scsi3_check_implict_release( 2128 pr_holder = core_scsi3_check_implict_release(
2191 cmd->se_dev, pr_reg); 2129 cmd->se_dev, pr_reg);
2192 if (pr_holder < 0) { 2130 if (pr_holder < 0) {
2193 kfree(pr_aptpl_buf);
2194 ret = TCM_RESERVATION_CONFLICT; 2131 ret = TCM_RESERVATION_CONFLICT;
2195 goto out_put_pr_reg; 2132 goto out;
2196 } 2133 }
2197 2134
2198 spin_lock(&pr_tmpl->registration_lock); 2135 spin_lock(&pr_tmpl->registration_lock);
@@ -2237,8 +2174,8 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
2237 * RESERVATIONS RELEASED. 2174 * RESERVATIONS RELEASED.
2238 */ 2175 */
2239 if (pr_holder && 2176 if (pr_holder &&
2240 (type == PR_TYPE_WRITE_EXCLUSIVE_REGONLY || 2177 (pr_reg->pr_res_type == PR_TYPE_WRITE_EXCLUSIVE_REGONLY ||
2241 type == PR_TYPE_EXCLUSIVE_ACCESS_REGONLY)) { 2178 pr_reg->pr_res_type == PR_TYPE_EXCLUSIVE_ACCESS_REGONLY)) {
2242 list_for_each_entry(pr_reg_p, 2179 list_for_each_entry(pr_reg_p,
2243 &pr_tmpl->registration_list, 2180 &pr_tmpl->registration_list,
2244 pr_reg_list) { 2181 pr_reg_list) {
@@ -2250,60 +2187,13 @@ core_scsi3_emulate_pro_register(struct se_cmd *cmd, u64 res_key, u64 sa_res_key,
2250 ASCQ_2AH_RESERVATIONS_RELEASED); 2187 ASCQ_2AH_RESERVATIONS_RELEASED);
2251 } 2188 }
2252 } 2189 }
2253 spin_unlock(&pr_tmpl->registration_lock);
2254
2255 if (!aptpl) {
2256 pr_tmpl->pr_aptpl_active = 0;
2257 core_scsi3_update_and_write_aptpl(dev, NULL, 0);
2258 pr_debug("SPC-3 PR: Set APTPL Bit Deactivated"
2259 " for UNREGISTER\n");
2260 return 0;
2261 }
2262 2190
2263 if (!core_scsi3_update_and_write_aptpl(dev, &pr_aptpl_buf[0], 2191 spin_unlock(&pr_tmpl->registration_lock);
2264 pr_tmpl->pr_aptpl_buf_len)) {
2265 pr_tmpl->pr_aptpl_active = 1;
2266 pr_debug("SPC-3 PR: Set APTPL Bit Activated"
2267 " for UNREGISTER\n");
2268 }
2269
2270 goto out_free_aptpl_buf;
2271 }
2272
2273 /*
2274 * Increment PRgeneration counter for struct se_device"
2275 * upon a successful REGISTER, see spc4r17 section 6.3.2
2276 * READ_KEYS service action.
2277 */
2278 pr_reg->pr_res_generation = core_scsi3_pr_generation(cmd->se_dev);
2279 pr_reg->pr_res_key = sa_res_key;
2280 pr_debug("SPC-3 PR [%s] REGISTER%s: Changed Reservation"
2281 " Key for %s to: 0x%016Lx PRgeneration:"
2282 " 0x%08x\n", cmd->se_tfo->get_fabric_name(),
2283 (ignore_key) ? "_AND_IGNORE_EXISTING_KEY" : "",
2284 pr_reg->pr_reg_nacl->initiatorname,
2285 pr_reg->pr_res_key, pr_reg->pr_res_generation);
2286
2287 if (!aptpl) {
2288 pr_tmpl->pr_aptpl_active = 0;
2289 core_scsi3_update_and_write_aptpl(dev, NULL, 0);
2290 pr_debug("SPC-3 PR: Set APTPL Bit Deactivated"
2291 " for REGISTER\n");
2292 ret = 0;
2293 goto out_put_pr_reg;
2294 } 2192 }
2295 2193
2296 if (!core_scsi3_update_and_write_aptpl(dev, &pr_aptpl_buf[0], 2194 ret = core_scsi3_update_and_write_aptpl(dev, aptpl);
2297 pr_tmpl->pr_aptpl_buf_len)) {
2298 pr_tmpl->pr_aptpl_active = 1;
2299 pr_debug("SPC-3 PR: Set APTPL Bit Activated"
2300 " for REGISTER\n");
2301 }
2302 2195
2303out_free_aptpl_buf: 2196out:
2304 kfree(pr_aptpl_buf);
2305 ret = 0;
2306out_put_pr_reg:
2307 core_scsi3_put_pr_reg(pr_reg); 2197 core_scsi3_put_pr_reg(pr_reg);
2308 return ret; 2198 return ret;
2309} 2199}
@@ -2340,7 +2230,6 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
2340 struct t10_reservation *pr_tmpl = &dev->t10_pr; 2230 struct t10_reservation *pr_tmpl = &dev->t10_pr;
2341 char i_buf[PR_REG_ISID_ID_LEN]; 2231 char i_buf[PR_REG_ISID_ID_LEN];
2342 sense_reason_t ret; 2232 sense_reason_t ret;
2343 int prf_isid;
2344 2233
2345 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 2234 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
2346 2235
@@ -2466,8 +2355,7 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
2466 pr_reg->pr_res_type = type; 2355 pr_reg->pr_res_type = type;
2467 pr_reg->pr_res_holder = 1; 2356 pr_reg->pr_res_holder = 1;
2468 dev->dev_pr_res_holder = pr_reg; 2357 dev->dev_pr_res_holder = pr_reg;
2469 prf_isid = core_pr_dump_initiator_port(pr_reg, &i_buf[0], 2358 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
2470 PR_REG_ISID_ID_LEN);
2471 2359
2472 pr_debug("SPC-3 PR [%s] Service Action: RESERVE created new" 2360 pr_debug("SPC-3 PR [%s] Service Action: RESERVE created new"
2473 " reservation holder TYPE: %s ALL_TG_PT: %d\n", 2361 " reservation holder TYPE: %s ALL_TG_PT: %d\n",
@@ -2476,17 +2364,11 @@ core_scsi3_pro_reserve(struct se_cmd *cmd, int type, int scope, u64 res_key)
2476 pr_debug("SPC-3 PR [%s] RESERVE Node: %s%s\n", 2364 pr_debug("SPC-3 PR [%s] RESERVE Node: %s%s\n",
2477 cmd->se_tfo->get_fabric_name(), 2365 cmd->se_tfo->get_fabric_name(),
2478 se_sess->se_node_acl->initiatorname, 2366 se_sess->se_node_acl->initiatorname,
2479 (prf_isid) ? &i_buf[0] : ""); 2367 i_buf);
2480 spin_unlock(&dev->dev_reservation_lock); 2368 spin_unlock(&dev->dev_reservation_lock);
2481 2369
2482 if (pr_tmpl->pr_aptpl_active) { 2370 if (pr_tmpl->pr_aptpl_active)
2483 if (!core_scsi3_update_and_write_aptpl(cmd->se_dev, 2371 core_scsi3_update_and_write_aptpl(cmd->se_dev, true);
2484 &pr_reg->pr_aptpl_buf[0],
2485 pr_tmpl->pr_aptpl_buf_len)) {
2486 pr_debug("SPC-3 PR: Updated APTPL metadata"
2487 " for RESERVE\n");
2488 }
2489 }
2490 2372
2491 ret = 0; 2373 ret = 0;
2492out_put_pr_reg: 2374out_put_pr_reg:
@@ -2524,11 +2406,9 @@ static void __core_scsi3_complete_pro_release(
2524{ 2406{
2525 struct target_core_fabric_ops *tfo = se_nacl->se_tpg->se_tpg_tfo; 2407 struct target_core_fabric_ops *tfo = se_nacl->se_tpg->se_tpg_tfo;
2526 char i_buf[PR_REG_ISID_ID_LEN]; 2408 char i_buf[PR_REG_ISID_ID_LEN];
2527 int prf_isid;
2528 2409
2529 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 2410 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
2530 prf_isid = core_pr_dump_initiator_port(pr_reg, &i_buf[0], 2411 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
2531 PR_REG_ISID_ID_LEN);
2532 /* 2412 /*
2533 * Go ahead and release the current PR reservation holder. 2413 * Go ahead and release the current PR reservation holder.
2534 */ 2414 */
@@ -2541,7 +2421,7 @@ static void __core_scsi3_complete_pro_release(
2541 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0); 2421 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
2542 pr_debug("SPC-3 PR [%s] RELEASE Node: %s%s\n", 2422 pr_debug("SPC-3 PR [%s] RELEASE Node: %s%s\n",
2543 tfo->get_fabric_name(), se_nacl->initiatorname, 2423 tfo->get_fabric_name(), se_nacl->initiatorname,
2544 (prf_isid) ? &i_buf[0] : ""); 2424 i_buf);
2545 /* 2425 /*
2546 * Clear TYPE and SCOPE for the next PROUT Service Action: RESERVE 2426 * Clear TYPE and SCOPE for the next PROUT Service Action: RESERVE
2547 */ 2427 */
@@ -2702,12 +2582,9 @@ core_scsi3_emulate_pro_release(struct se_cmd *cmd, int type, int scope,
2702 spin_unlock(&pr_tmpl->registration_lock); 2582 spin_unlock(&pr_tmpl->registration_lock);
2703 2583
2704write_aptpl: 2584write_aptpl:
2705 if (pr_tmpl->pr_aptpl_active) { 2585 if (pr_tmpl->pr_aptpl_active)
2706 if (!core_scsi3_update_and_write_aptpl(cmd->se_dev, 2586 core_scsi3_update_and_write_aptpl(cmd->se_dev, true);
2707 &pr_reg->pr_aptpl_buf[0], pr_tmpl->pr_aptpl_buf_len)) { 2587
2708 pr_debug("SPC-3 PR: Updated APTPL metadata for RELEASE\n");
2709 }
2710 }
2711out_put_pr_reg: 2588out_put_pr_reg:
2712 core_scsi3_put_pr_reg(pr_reg); 2589 core_scsi3_put_pr_reg(pr_reg);
2713 return ret; 2590 return ret;
@@ -2791,11 +2668,7 @@ core_scsi3_emulate_pro_clear(struct se_cmd *cmd, u64 res_key)
2791 pr_debug("SPC-3 PR [%s] Service Action: CLEAR complete\n", 2668 pr_debug("SPC-3 PR [%s] Service Action: CLEAR complete\n",
2792 cmd->se_tfo->get_fabric_name()); 2669 cmd->se_tfo->get_fabric_name());
2793 2670
2794 if (pr_tmpl->pr_aptpl_active) { 2671 core_scsi3_update_and_write_aptpl(cmd->se_dev, false);
2795 core_scsi3_update_and_write_aptpl(cmd->se_dev, NULL, 0);
2796 pr_debug("SPC-3 PR: Updated APTPL metadata"
2797 " for CLEAR\n");
2798 }
2799 2672
2800 core_scsi3_pr_generation(dev); 2673 core_scsi3_pr_generation(dev);
2801 return 0; 2674 return 0;
@@ -2810,16 +2683,14 @@ static void __core_scsi3_complete_pro_preempt(
2810 struct list_head *preempt_and_abort_list, 2683 struct list_head *preempt_and_abort_list,
2811 int type, 2684 int type,
2812 int scope, 2685 int scope,
2813 int abort) 2686 enum preempt_type preempt_type)
2814{ 2687{
2815 struct se_node_acl *nacl = pr_reg->pr_reg_nacl; 2688 struct se_node_acl *nacl = pr_reg->pr_reg_nacl;
2816 struct target_core_fabric_ops *tfo = nacl->se_tpg->se_tpg_tfo; 2689 struct target_core_fabric_ops *tfo = nacl->se_tpg->se_tpg_tfo;
2817 char i_buf[PR_REG_ISID_ID_LEN]; 2690 char i_buf[PR_REG_ISID_ID_LEN];
2818 int prf_isid;
2819 2691
2820 memset(i_buf, 0, PR_REG_ISID_ID_LEN); 2692 memset(i_buf, 0, PR_REG_ISID_ID_LEN);
2821 prf_isid = core_pr_dump_initiator_port(pr_reg, &i_buf[0], 2693 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
2822 PR_REG_ISID_ID_LEN);
2823 /* 2694 /*
2824 * Do an implict RELEASE of the existing reservation. 2695 * Do an implict RELEASE of the existing reservation.
2825 */ 2696 */
@@ -2834,12 +2705,12 @@ static void __core_scsi3_complete_pro_preempt(
2834 2705
2835 pr_debug("SPC-3 PR [%s] Service Action: PREEMPT%s created new" 2706 pr_debug("SPC-3 PR [%s] Service Action: PREEMPT%s created new"
2836 " reservation holder TYPE: %s ALL_TG_PT: %d\n", 2707 " reservation holder TYPE: %s ALL_TG_PT: %d\n",
2837 tfo->get_fabric_name(), (abort) ? "_AND_ABORT" : "", 2708 tfo->get_fabric_name(), (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "",
2838 core_scsi3_pr_dump_type(type), 2709 core_scsi3_pr_dump_type(type),
2839 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0); 2710 (pr_reg->pr_reg_all_tg_pt) ? 1 : 0);
2840 pr_debug("SPC-3 PR [%s] PREEMPT%s from Node: %s%s\n", 2711 pr_debug("SPC-3 PR [%s] PREEMPT%s from Node: %s%s\n",
2841 tfo->get_fabric_name(), (abort) ? "_AND_ABORT" : "", 2712 tfo->get_fabric_name(), (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "",
2842 nacl->initiatorname, (prf_isid) ? &i_buf[0] : ""); 2713 nacl->initiatorname, i_buf);
2843 /* 2714 /*
2844 * For PREEMPT_AND_ABORT, add the preempting reservation's 2715 * For PREEMPT_AND_ABORT, add the preempting reservation's
2845 * struct t10_pr_registration to the list that will be compared 2716 * struct t10_pr_registration to the list that will be compared
@@ -2869,14 +2740,13 @@ static void core_scsi3_release_preempt_and_abort(
2869 2740
2870 pr_reg->pr_reg_deve = NULL; 2741 pr_reg->pr_reg_deve = NULL;
2871 pr_reg->pr_reg_nacl = NULL; 2742 pr_reg->pr_reg_nacl = NULL;
2872 kfree(pr_reg->pr_aptpl_buf);
2873 kmem_cache_free(t10_pr_reg_cache, pr_reg); 2743 kmem_cache_free(t10_pr_reg_cache, pr_reg);
2874 } 2744 }
2875} 2745}
2876 2746
2877static sense_reason_t 2747static sense_reason_t
2878core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key, 2748core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
2879 u64 sa_res_key, int abort) 2749 u64 sa_res_key, enum preempt_type preempt_type)
2880{ 2750{
2881 struct se_device *dev = cmd->se_dev; 2751 struct se_device *dev = cmd->se_dev;
2882 struct se_node_acl *pr_reg_nacl; 2752 struct se_node_acl *pr_reg_nacl;
@@ -2896,7 +2766,7 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
2896 if (!pr_reg_n) { 2766 if (!pr_reg_n) {
2897 pr_err("SPC-3 PR: Unable to locate" 2767 pr_err("SPC-3 PR: Unable to locate"
2898 " PR_REGISTERED *pr_reg for PREEMPT%s\n", 2768 " PR_REGISTERED *pr_reg for PREEMPT%s\n",
2899 (abort) ? "_AND_ABORT" : ""); 2769 (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "");
2900 return TCM_RESERVATION_CONFLICT; 2770 return TCM_RESERVATION_CONFLICT;
2901 } 2771 }
2902 if (pr_reg_n->pr_res_key != res_key) { 2772 if (pr_reg_n->pr_res_key != res_key) {
@@ -2965,7 +2835,7 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
2965 pr_reg_nacl = pr_reg->pr_reg_nacl; 2835 pr_reg_nacl = pr_reg->pr_reg_nacl;
2966 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun; 2836 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun;
2967 __core_scsi3_free_registration(dev, pr_reg, 2837 __core_scsi3_free_registration(dev, pr_reg,
2968 (abort) ? &preempt_and_abort_list : 2838 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list :
2969 NULL, calling_it_nexus); 2839 NULL, calling_it_nexus);
2970 released_regs++; 2840 released_regs++;
2971 } else { 2841 } else {
@@ -2993,7 +2863,7 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
2993 pr_reg_nacl = pr_reg->pr_reg_nacl; 2863 pr_reg_nacl = pr_reg->pr_reg_nacl;
2994 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun; 2864 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun;
2995 __core_scsi3_free_registration(dev, pr_reg, 2865 __core_scsi3_free_registration(dev, pr_reg,
2996 (abort) ? &preempt_and_abort_list : 2866 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list :
2997 NULL, 0); 2867 NULL, 0);
2998 released_regs++; 2868 released_regs++;
2999 } 2869 }
@@ -3022,24 +2892,17 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
3022 */ 2892 */
3023 if (pr_res_holder && all_reg && !(sa_res_key)) { 2893 if (pr_res_holder && all_reg && !(sa_res_key)) {
3024 __core_scsi3_complete_pro_preempt(dev, pr_reg_n, 2894 __core_scsi3_complete_pro_preempt(dev, pr_reg_n,
3025 (abort) ? &preempt_and_abort_list : NULL, 2895 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list : NULL,
3026 type, scope, abort); 2896 type, scope, preempt_type);
3027 2897
3028 if (abort) 2898 if (preempt_type == PREEMPT_AND_ABORT)
3029 core_scsi3_release_preempt_and_abort( 2899 core_scsi3_release_preempt_and_abort(
3030 &preempt_and_abort_list, pr_reg_n); 2900 &preempt_and_abort_list, pr_reg_n);
3031 } 2901 }
3032 spin_unlock(&dev->dev_reservation_lock); 2902 spin_unlock(&dev->dev_reservation_lock);
3033 2903
3034 if (pr_tmpl->pr_aptpl_active) { 2904 if (pr_tmpl->pr_aptpl_active)
3035 if (!core_scsi3_update_and_write_aptpl(cmd->se_dev, 2905 core_scsi3_update_and_write_aptpl(cmd->se_dev, true);
3036 &pr_reg_n->pr_aptpl_buf[0],
3037 pr_tmpl->pr_aptpl_buf_len)) {
3038 pr_debug("SPC-3 PR: Updated APTPL"
3039 " metadata for PREEMPT%s\n", (abort) ?
3040 "_AND_ABORT" : "");
3041 }
3042 }
3043 2906
3044 core_scsi3_put_pr_reg(pr_reg_n); 2907 core_scsi3_put_pr_reg(pr_reg_n);
3045 core_scsi3_pr_generation(cmd->se_dev); 2908 core_scsi3_pr_generation(cmd->se_dev);
@@ -3103,7 +2966,7 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
3103 pr_reg_nacl = pr_reg->pr_reg_nacl; 2966 pr_reg_nacl = pr_reg->pr_reg_nacl;
3104 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun; 2967 pr_res_mapped_lun = pr_reg->pr_res_mapped_lun;
3105 __core_scsi3_free_registration(dev, pr_reg, 2968 __core_scsi3_free_registration(dev, pr_reg,
3106 (abort) ? &preempt_and_abort_list : NULL, 2969 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list : NULL,
3107 calling_it_nexus); 2970 calling_it_nexus);
3108 /* 2971 /*
3109 * e) Establish a unit attention condition for the initiator 2972 * e) Establish a unit attention condition for the initiator
@@ -3120,8 +2983,8 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
3120 * I_T nexus using the contents of the SCOPE and TYPE fields; 2983 * I_T nexus using the contents of the SCOPE and TYPE fields;
3121 */ 2984 */
3122 __core_scsi3_complete_pro_preempt(dev, pr_reg_n, 2985 __core_scsi3_complete_pro_preempt(dev, pr_reg_n,
3123 (abort) ? &preempt_and_abort_list : NULL, 2986 (preempt_type == PREEMPT_AND_ABORT) ? &preempt_and_abort_list : NULL,
3124 type, scope, abort); 2987 type, scope, preempt_type);
3125 /* 2988 /*
3126 * d) Process tasks as defined in 5.7.1; 2989 * d) Process tasks as defined in 5.7.1;
3127 * e) See above.. 2990 * e) See above..
@@ -3161,20 +3024,14 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
3161 * been removed from the primary pr_reg list), except the 3024 * been removed from the primary pr_reg list), except the
3162 * new persistent reservation holder, the calling Initiator Port. 3025 * new persistent reservation holder, the calling Initiator Port.
3163 */ 3026 */
3164 if (abort) { 3027 if (preempt_type == PREEMPT_AND_ABORT) {
3165 core_tmr_lun_reset(dev, NULL, &preempt_and_abort_list, cmd); 3028 core_tmr_lun_reset(dev, NULL, &preempt_and_abort_list, cmd);
3166 core_scsi3_release_preempt_and_abort(&preempt_and_abort_list, 3029 core_scsi3_release_preempt_and_abort(&preempt_and_abort_list,
3167 pr_reg_n); 3030 pr_reg_n);
3168 } 3031 }
3169 3032
3170 if (pr_tmpl->pr_aptpl_active) { 3033 if (pr_tmpl->pr_aptpl_active)
3171 if (!core_scsi3_update_and_write_aptpl(cmd->se_dev, 3034 core_scsi3_update_and_write_aptpl(cmd->se_dev, true);
3172 &pr_reg_n->pr_aptpl_buf[0],
3173 pr_tmpl->pr_aptpl_buf_len)) {
3174 pr_debug("SPC-3 PR: Updated APTPL metadata for PREEMPT"
3175 "%s\n", abort ? "_AND_ABORT" : "");
3176 }
3177 }
3178 3035
3179 core_scsi3_put_pr_reg(pr_reg_n); 3036 core_scsi3_put_pr_reg(pr_reg_n);
3180 core_scsi3_pr_generation(cmd->se_dev); 3037 core_scsi3_pr_generation(cmd->se_dev);
@@ -3183,7 +3040,7 @@ core_scsi3_pro_preempt(struct se_cmd *cmd, int type, int scope, u64 res_key,
3183 3040
3184static sense_reason_t 3041static sense_reason_t
3185core_scsi3_emulate_pro_preempt(struct se_cmd *cmd, int type, int scope, 3042core_scsi3_emulate_pro_preempt(struct se_cmd *cmd, int type, int scope,
3186 u64 res_key, u64 sa_res_key, int abort) 3043 u64 res_key, u64 sa_res_key, enum preempt_type preempt_type)
3187{ 3044{
3188 switch (type) { 3045 switch (type) {
3189 case PR_TYPE_WRITE_EXCLUSIVE: 3046 case PR_TYPE_WRITE_EXCLUSIVE:
@@ -3193,10 +3050,10 @@ core_scsi3_emulate_pro_preempt(struct se_cmd *cmd, int type, int scope,
3193 case PR_TYPE_WRITE_EXCLUSIVE_ALLREG: 3050 case PR_TYPE_WRITE_EXCLUSIVE_ALLREG:
3194 case PR_TYPE_EXCLUSIVE_ACCESS_ALLREG: 3051 case PR_TYPE_EXCLUSIVE_ACCESS_ALLREG:
3195 return core_scsi3_pro_preempt(cmd, type, scope, res_key, 3052 return core_scsi3_pro_preempt(cmd, type, scope, res_key,
3196 sa_res_key, abort); 3053 sa_res_key, preempt_type);
3197 default: 3054 default:
3198 pr_err("SPC-3 PR: Unknown Service Action PREEMPT%s" 3055 pr_err("SPC-3 PR: Unknown Service Action PREEMPT%s"
3199 " Type: 0x%02x\n", (abort) ? "_AND_ABORT" : "", type); 3056 " Type: 0x%02x\n", (preempt_type == PREEMPT_AND_ABORT) ? "_AND_ABORT" : "", type);
3200 return TCM_INVALID_CDB_FIELD; 3057 return TCM_INVALID_CDB_FIELD;
3201 } 3058 }
3202} 3059}
@@ -3220,7 +3077,7 @@ core_scsi3_emulate_pro_register_and_move(struct se_cmd *cmd, u64 res_key,
3220 unsigned char *initiator_str; 3077 unsigned char *initiator_str;
3221 char *iport_ptr = NULL, dest_iport[64], i_buf[PR_REG_ISID_ID_LEN]; 3078 char *iport_ptr = NULL, dest_iport[64], i_buf[PR_REG_ISID_ID_LEN];
3222 u32 tid_len, tmp_tid_len; 3079 u32 tid_len, tmp_tid_len;
3223 int new_reg = 0, type, scope, matching_iname, prf_isid; 3080 int new_reg = 0, type, scope, matching_iname;
3224 sense_reason_t ret; 3081 sense_reason_t ret;
3225 unsigned short rtpi; 3082 unsigned short rtpi;
3226 unsigned char proto_ident; 3083 unsigned char proto_ident;
@@ -3564,8 +3421,7 @@ after_iport_check:
3564 dest_pr_reg->pr_res_holder = 1; 3421 dest_pr_reg->pr_res_holder = 1;
3565 dest_pr_reg->pr_res_type = type; 3422 dest_pr_reg->pr_res_type = type;
3566 pr_reg->pr_res_scope = scope; 3423 pr_reg->pr_res_scope = scope;
3567 prf_isid = core_pr_dump_initiator_port(pr_reg, &i_buf[0], 3424 core_pr_dump_initiator_port(pr_reg, i_buf, PR_REG_ISID_ID_LEN);
3568 PR_REG_ISID_ID_LEN);
3569 /* 3425 /*
3570 * Increment PRGeneration for existing registrations.. 3426 * Increment PRGeneration for existing registrations..
3571 */ 3427 */
@@ -3581,7 +3437,7 @@ after_iport_check:
3581 pr_debug("SPC-3 PR Successfully moved reservation from" 3437 pr_debug("SPC-3 PR Successfully moved reservation from"
3582 " %s Fabric Node: %s%s -> %s Fabric Node: %s %s\n", 3438 " %s Fabric Node: %s%s -> %s Fabric Node: %s %s\n",
3583 tf_ops->get_fabric_name(), pr_reg_nacl->initiatorname, 3439 tf_ops->get_fabric_name(), pr_reg_nacl->initiatorname,
3584 (prf_isid) ? &i_buf[0] : "", dest_tf_ops->get_fabric_name(), 3440 i_buf, dest_tf_ops->get_fabric_name(),
3585 dest_node_acl->initiatorname, (iport_ptr != NULL) ? 3441 dest_node_acl->initiatorname, (iport_ptr != NULL) ?
3586 iport_ptr : ""); 3442 iport_ptr : "");
3587 /* 3443 /*
@@ -3602,24 +3458,7 @@ after_iport_check:
3602 } else 3458 } else
3603 core_scsi3_put_pr_reg(pr_reg); 3459 core_scsi3_put_pr_reg(pr_reg);
3604 3460
3605 /* 3461 core_scsi3_update_and_write_aptpl(cmd->se_dev, aptpl);
3606 * Clear the APTPL metadata if APTPL has been disabled, otherwise
3607 * write out the updated metadata to struct file for this SCSI device.
3608 */
3609 if (!aptpl) {
3610 pr_tmpl->pr_aptpl_active = 0;
3611 core_scsi3_update_and_write_aptpl(cmd->se_dev, NULL, 0);
3612 pr_debug("SPC-3 PR: Set APTPL Bit Deactivated for"
3613 " REGISTER_AND_MOVE\n");
3614 } else {
3615 pr_tmpl->pr_aptpl_active = 1;
3616 if (!core_scsi3_update_and_write_aptpl(cmd->se_dev,
3617 &dest_pr_reg->pr_aptpl_buf[0],
3618 pr_tmpl->pr_aptpl_buf_len)) {
3619 pr_debug("SPC-3 PR: Set APTPL Bit Activated for"
3620 " REGISTER_AND_MOVE\n");
3621 }
3622 }
3623 3462
3624 transport_kunmap_data_sg(cmd); 3463 transport_kunmap_data_sg(cmd);
3625 3464
@@ -3752,7 +3591,7 @@ target_scsi3_emulate_pr_out(struct se_cmd *cmd)
3752 switch (sa) { 3591 switch (sa) {
3753 case PRO_REGISTER: 3592 case PRO_REGISTER:
3754 ret = core_scsi3_emulate_pro_register(cmd, 3593 ret = core_scsi3_emulate_pro_register(cmd,
3755 res_key, sa_res_key, aptpl, all_tg_pt, spec_i_pt, 0); 3594 res_key, sa_res_key, aptpl, all_tg_pt, spec_i_pt, REGISTER);
3756 break; 3595 break;
3757 case PRO_RESERVE: 3596 case PRO_RESERVE:
3758 ret = core_scsi3_emulate_pro_reserve(cmd, type, scope, res_key); 3597 ret = core_scsi3_emulate_pro_reserve(cmd, type, scope, res_key);
@@ -3765,15 +3604,15 @@ target_scsi3_emulate_pr_out(struct se_cmd *cmd)
3765 break; 3604 break;
3766 case PRO_PREEMPT: 3605 case PRO_PREEMPT:
3767 ret = core_scsi3_emulate_pro_preempt(cmd, type, scope, 3606 ret = core_scsi3_emulate_pro_preempt(cmd, type, scope,
3768 res_key, sa_res_key, 0); 3607 res_key, sa_res_key, PREEMPT);
3769 break; 3608 break;
3770 case PRO_PREEMPT_AND_ABORT: 3609 case PRO_PREEMPT_AND_ABORT:
3771 ret = core_scsi3_emulate_pro_preempt(cmd, type, scope, 3610 ret = core_scsi3_emulate_pro_preempt(cmd, type, scope,
3772 res_key, sa_res_key, 1); 3611 res_key, sa_res_key, PREEMPT_AND_ABORT);
3773 break; 3612 break;
3774 case PRO_REGISTER_AND_IGNORE_EXISTING_KEY: 3613 case PRO_REGISTER_AND_IGNORE_EXISTING_KEY:
3775 ret = core_scsi3_emulate_pro_register(cmd, 3614 ret = core_scsi3_emulate_pro_register(cmd,
3776 0, sa_res_key, aptpl, all_tg_pt, spec_i_pt, 1); 3615 0, sa_res_key, aptpl, all_tg_pt, spec_i_pt, REGISTER_AND_IGNORE_EXISTING_KEY);
3777 break; 3616 break;
3778 case PRO_REGISTER_AND_MOVE: 3617 case PRO_REGISTER_AND_MOVE:
3779 ret = core_scsi3_emulate_pro_register_and_move(cmd, res_key, 3618 ret = core_scsi3_emulate_pro_register_and_move(cmd, res_key,
diff --git a/drivers/target/target_core_pr.h b/drivers/target/target_core_pr.h
index b4a004247ab2..ed75cdd32cb0 100644
--- a/drivers/target/target_core_pr.h
+++ b/drivers/target/target_core_pr.h
@@ -45,7 +45,7 @@
45 45
46extern struct kmem_cache *t10_pr_reg_cache; 46extern struct kmem_cache *t10_pr_reg_cache;
47 47
48extern int core_pr_dump_initiator_port(struct t10_pr_registration *, 48extern void core_pr_dump_initiator_port(struct t10_pr_registration *,
49 char *, u32); 49 char *, u32);
50extern sense_reason_t target_scsi2_reservation_release(struct se_cmd *); 50extern sense_reason_t target_scsi2_reservation_release(struct se_cmd *);
51extern sense_reason_t target_scsi2_reservation_reserve(struct se_cmd *); 51extern sense_reason_t target_scsi2_reservation_reserve(struct se_cmd *);
diff --git a/drivers/target/target_core_rd.c b/drivers/target/target_core_rd.c
index 0921a64b5550..51127d15d5c5 100644
--- a/drivers/target/target_core_rd.c
+++ b/drivers/target/target_core_rd.c
@@ -139,6 +139,11 @@ static int rd_build_device_space(struct rd_dev *rd_dev)
139 rd_dev->rd_page_count); 139 rd_dev->rd_page_count);
140 return -EINVAL; 140 return -EINVAL;
141 } 141 }
142
143 /* Don't need backing pages for NULLIO */
144 if (rd_dev->rd_flags & RDF_NULLIO)
145 return 0;
146
142 total_sg_needed = rd_dev->rd_page_count; 147 total_sg_needed = rd_dev->rd_page_count;
143 148
144 sg_tables = (total_sg_needed / max_sg_per_table) + 1; 149 sg_tables = (total_sg_needed / max_sg_per_table) + 1;
diff --git a/drivers/target/target_core_sbc.c b/drivers/target/target_core_sbc.c
index bbc5b0ee2bdc..8a462773d0c8 100644
--- a/drivers/target/target_core_sbc.c
+++ b/drivers/target/target_core_sbc.c
@@ -38,11 +38,27 @@ static sense_reason_t
38sbc_emulate_readcapacity(struct se_cmd *cmd) 38sbc_emulate_readcapacity(struct se_cmd *cmd)
39{ 39{
40 struct se_device *dev = cmd->se_dev; 40 struct se_device *dev = cmd->se_dev;
41 unsigned char *cdb = cmd->t_task_cdb;
41 unsigned long long blocks_long = dev->transport->get_blocks(dev); 42 unsigned long long blocks_long = dev->transport->get_blocks(dev);
42 unsigned char *rbuf; 43 unsigned char *rbuf;
43 unsigned char buf[8]; 44 unsigned char buf[8];
44 u32 blocks; 45 u32 blocks;
45 46
47 /*
48 * SBC-2 says:
49 * If the PMI bit is set to zero and the LOGICAL BLOCK
50 * ADDRESS field is not set to zero, the device server shall
51 * terminate the command with CHECK CONDITION status with
52 * the sense key set to ILLEGAL REQUEST and the additional
53 * sense code set to INVALID FIELD IN CDB.
54 *
55 * In SBC-3, these fields are obsolete, but some SCSI
56 * compliance tests actually check this, so we might as well
57 * follow SBC-2.
58 */
59 if (!(cdb[8] & 1) && !!(cdb[2] | cdb[3] | cdb[4] | cdb[5]))
60 return TCM_INVALID_CDB_FIELD;
61
46 if (blocks_long >= 0x00000000ffffffff) 62 if (blocks_long >= 0x00000000ffffffff)
47 blocks = 0xffffffff; 63 blocks = 0xffffffff;
48 else 64 else
@@ -581,7 +597,7 @@ sbc_parse_cdb(struct se_cmd *cmd, struct sbc_ops *ops)
581 pr_err("cmd exceeds last lba %llu " 597 pr_err("cmd exceeds last lba %llu "
582 "(lba %llu, sectors %u)\n", 598 "(lba %llu, sectors %u)\n",
583 end_lba, cmd->t_task_lba, sectors); 599 end_lba, cmd->t_task_lba, sectors);
584 return TCM_INVALID_CDB_FIELD; 600 return TCM_ADDRESS_OUT_OF_RANGE;
585 } 601 }
586 602
587 size = sbc_get_size(cmd, sectors); 603 size = sbc_get_size(cmd, sectors);
diff --git a/drivers/target/target_core_tmr.c b/drivers/target/target_core_tmr.c
index d0b4dd95b91e..0d7cacb91107 100644
--- a/drivers/target/target_core_tmr.c
+++ b/drivers/target/target_core_tmr.c
@@ -85,13 +85,8 @@ void core_tmr_release_req(
85static void core_tmr_handle_tas_abort( 85static void core_tmr_handle_tas_abort(
86 struct se_node_acl *tmr_nacl, 86 struct se_node_acl *tmr_nacl,
87 struct se_cmd *cmd, 87 struct se_cmd *cmd,
88 int tas, 88 int tas)
89 int fe_count)
90{ 89{
91 if (!fe_count) {
92 transport_cmd_finish_abort(cmd, 1);
93 return;
94 }
95 /* 90 /*
96 * TASK ABORTED status (TAS) bit support 91 * TASK ABORTED status (TAS) bit support
97 */ 92 */
@@ -253,7 +248,6 @@ static void core_tmr_drain_state_list(
253 LIST_HEAD(drain_task_list); 248 LIST_HEAD(drain_task_list);
254 struct se_cmd *cmd, *next; 249 struct se_cmd *cmd, *next;
255 unsigned long flags; 250 unsigned long flags;
256 int fe_count;
257 251
258 /* 252 /*
259 * Complete outstanding commands with TASK_ABORTED SAM status. 253 * Complete outstanding commands with TASK_ABORTED SAM status.
@@ -329,12 +323,10 @@ static void core_tmr_drain_state_list(
329 spin_lock_irqsave(&cmd->t_state_lock, flags); 323 spin_lock_irqsave(&cmd->t_state_lock, flags);
330 target_stop_cmd(cmd, &flags); 324 target_stop_cmd(cmd, &flags);
331 325
332 fe_count = atomic_read(&cmd->t_fe_count);
333
334 cmd->transport_state |= CMD_T_ABORTED; 326 cmd->transport_state |= CMD_T_ABORTED;
335 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 327 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
336 328
337 core_tmr_handle_tas_abort(tmr_nacl, cmd, tas, fe_count); 329 core_tmr_handle_tas_abort(tmr_nacl, cmd, tas);
338 } 330 }
339} 331}
340 332
diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
index 21e315874a54..7172d005d063 100644
--- a/drivers/target/target_core_transport.c
+++ b/drivers/target/target_core_transport.c
@@ -52,6 +52,9 @@
52#include "target_core_pr.h" 52#include "target_core_pr.h"
53#include "target_core_ua.h" 53#include "target_core_ua.h"
54 54
55#define CREATE_TRACE_POINTS
56#include <trace/events/target.h>
57
55static struct workqueue_struct *target_completion_wq; 58static struct workqueue_struct *target_completion_wq;
56static struct kmem_cache *se_sess_cache; 59static struct kmem_cache *se_sess_cache;
57struct kmem_cache *se_ua_cache; 60struct kmem_cache *se_ua_cache;
@@ -446,11 +449,15 @@ static void target_remove_from_state_list(struct se_cmd *cmd)
446 spin_unlock_irqrestore(&dev->execute_task_lock, flags); 449 spin_unlock_irqrestore(&dev->execute_task_lock, flags);
447} 450}
448 451
449static int transport_cmd_check_stop(struct se_cmd *cmd, bool remove_from_lists) 452static int transport_cmd_check_stop(struct se_cmd *cmd, bool remove_from_lists,
453 bool write_pending)
450{ 454{
451 unsigned long flags; 455 unsigned long flags;
452 456
453 spin_lock_irqsave(&cmd->t_state_lock, flags); 457 spin_lock_irqsave(&cmd->t_state_lock, flags);
458 if (write_pending)
459 cmd->t_state = TRANSPORT_WRITE_PENDING;
460
454 /* 461 /*
455 * Determine if IOCTL context caller in requesting the stopping of this 462 * Determine if IOCTL context caller in requesting the stopping of this
456 * command for LUN shutdown purposes. 463 * command for LUN shutdown purposes.
@@ -515,7 +522,7 @@ static int transport_cmd_check_stop(struct se_cmd *cmd, bool remove_from_lists)
515 522
516static int transport_cmd_check_stop_to_fabric(struct se_cmd *cmd) 523static int transport_cmd_check_stop_to_fabric(struct se_cmd *cmd)
517{ 524{
518 return transport_cmd_check_stop(cmd, true); 525 return transport_cmd_check_stop(cmd, true, false);
519} 526}
520 527
521static void transport_lun_remove_cmd(struct se_cmd *cmd) 528static void transport_lun_remove_cmd(struct se_cmd *cmd)
@@ -526,13 +533,6 @@ static void transport_lun_remove_cmd(struct se_cmd *cmd)
526 if (!lun) 533 if (!lun)
527 return; 534 return;
528 535
529 spin_lock_irqsave(&cmd->t_state_lock, flags);
530 if (cmd->transport_state & CMD_T_DEV_ACTIVE) {
531 cmd->transport_state &= ~CMD_T_DEV_ACTIVE;
532 target_remove_from_state_list(cmd);
533 }
534 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
535
536 spin_lock_irqsave(&lun->lun_cmd_lock, flags); 536 spin_lock_irqsave(&lun->lun_cmd_lock, flags);
537 if (!list_empty(&cmd->se_lun_node)) 537 if (!list_empty(&cmd->se_lun_node))
538 list_del_init(&cmd->se_lun_node); 538 list_del_init(&cmd->se_lun_node);
@@ -1092,7 +1092,6 @@ sense_reason_t
1092target_setup_cmd_from_cdb(struct se_cmd *cmd, unsigned char *cdb) 1092target_setup_cmd_from_cdb(struct se_cmd *cmd, unsigned char *cdb)
1093{ 1093{
1094 struct se_device *dev = cmd->se_dev; 1094 struct se_device *dev = cmd->se_dev;
1095 unsigned long flags;
1096 sense_reason_t ret; 1095 sense_reason_t ret;
1097 1096
1098 /* 1097 /*
@@ -1127,6 +1126,8 @@ target_setup_cmd_from_cdb(struct se_cmd *cmd, unsigned char *cdb)
1127 */ 1126 */
1128 memcpy(cmd->t_task_cdb, cdb, scsi_command_size(cdb)); 1127 memcpy(cmd->t_task_cdb, cdb, scsi_command_size(cdb));
1129 1128
1129 trace_target_sequencer_start(cmd);
1130
1130 /* 1131 /*
1131 * Check for an existing UNIT ATTENTION condition 1132 * Check for an existing UNIT ATTENTION condition
1132 */ 1133 */
@@ -1152,9 +1153,7 @@ target_setup_cmd_from_cdb(struct se_cmd *cmd, unsigned char *cdb)
1152 if (ret) 1153 if (ret)
1153 return ret; 1154 return ret;
1154 1155
1155 spin_lock_irqsave(&cmd->t_state_lock, flags);
1156 cmd->se_cmd_flags |= SCF_SUPPORTED_SAM_OPCODE; 1156 cmd->se_cmd_flags |= SCF_SUPPORTED_SAM_OPCODE;
1157 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
1158 1157
1159 spin_lock(&cmd->se_lun->lun_sep_lock); 1158 spin_lock(&cmd->se_lun->lun_sep_lock);
1160 if (cmd->se_lun->lun_sep) 1159 if (cmd->se_lun->lun_sep)
@@ -1552,7 +1551,8 @@ void transport_generic_request_failure(struct se_cmd *cmd,
1552 cmd->orig_fe_lun, 0x2C, 1551 cmd->orig_fe_lun, 0x2C,
1553 ASCQ_2CH_PREVIOUS_RESERVATION_CONFLICT_STATUS); 1552 ASCQ_2CH_PREVIOUS_RESERVATION_CONFLICT_STATUS);
1554 1553
1555 ret = cmd->se_tfo->queue_status(cmd); 1554 trace_target_cmd_complete(cmd);
1555 ret = cmd->se_tfo-> queue_status(cmd);
1556 if (ret == -EAGAIN || ret == -ENOMEM) 1556 if (ret == -EAGAIN || ret == -ENOMEM)
1557 goto queue_full; 1557 goto queue_full;
1558 goto check_stop; 1558 goto check_stop;
@@ -1583,10 +1583,6 @@ static void __target_execute_cmd(struct se_cmd *cmd)
1583{ 1583{
1584 sense_reason_t ret; 1584 sense_reason_t ret;
1585 1585
1586 spin_lock_irq(&cmd->t_state_lock);
1587 cmd->transport_state |= (CMD_T_BUSY|CMD_T_SENT);
1588 spin_unlock_irq(&cmd->t_state_lock);
1589
1590 if (cmd->execute_cmd) { 1586 if (cmd->execute_cmd) {
1591 ret = cmd->execute_cmd(cmd); 1587 ret = cmd->execute_cmd(cmd);
1592 if (ret) { 1588 if (ret) {
@@ -1693,11 +1689,17 @@ void target_execute_cmd(struct se_cmd *cmd)
1693 } 1689 }
1694 1690
1695 cmd->t_state = TRANSPORT_PROCESSING; 1691 cmd->t_state = TRANSPORT_PROCESSING;
1696 cmd->transport_state |= CMD_T_ACTIVE; 1692 cmd->transport_state |= CMD_T_ACTIVE|CMD_T_BUSY|CMD_T_SENT;
1697 spin_unlock_irq(&cmd->t_state_lock); 1693 spin_unlock_irq(&cmd->t_state_lock);
1698 1694
1699 if (!target_handle_task_attr(cmd)) 1695 if (target_handle_task_attr(cmd)) {
1700 __target_execute_cmd(cmd); 1696 spin_lock_irq(&cmd->t_state_lock);
1697 cmd->transport_state &= ~CMD_T_BUSY|CMD_T_SENT;
1698 spin_unlock_irq(&cmd->t_state_lock);
1699 return;
1700 }
1701
1702 __target_execute_cmd(cmd);
1701} 1703}
1702EXPORT_SYMBOL(target_execute_cmd); 1704EXPORT_SYMBOL(target_execute_cmd);
1703 1705
@@ -1770,6 +1772,7 @@ static void transport_complete_qf(struct se_cmd *cmd)
1770 transport_complete_task_attr(cmd); 1772 transport_complete_task_attr(cmd);
1771 1773
1772 if (cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) { 1774 if (cmd->se_cmd_flags & SCF_TRANSPORT_TASK_SENSE) {
1775 trace_target_cmd_complete(cmd);
1773 ret = cmd->se_tfo->queue_status(cmd); 1776 ret = cmd->se_tfo->queue_status(cmd);
1774 if (ret) 1777 if (ret)
1775 goto out; 1778 goto out;
@@ -1777,6 +1780,7 @@ static void transport_complete_qf(struct se_cmd *cmd)
1777 1780
1778 switch (cmd->data_direction) { 1781 switch (cmd->data_direction) {
1779 case DMA_FROM_DEVICE: 1782 case DMA_FROM_DEVICE:
1783 trace_target_cmd_complete(cmd);
1780 ret = cmd->se_tfo->queue_data_in(cmd); 1784 ret = cmd->se_tfo->queue_data_in(cmd);
1781 break; 1785 break;
1782 case DMA_TO_DEVICE: 1786 case DMA_TO_DEVICE:
@@ -1787,6 +1791,7 @@ static void transport_complete_qf(struct se_cmd *cmd)
1787 } 1791 }
1788 /* Fall through for DMA_TO_DEVICE */ 1792 /* Fall through for DMA_TO_DEVICE */
1789 case DMA_NONE: 1793 case DMA_NONE:
1794 trace_target_cmd_complete(cmd);
1790 ret = cmd->se_tfo->queue_status(cmd); 1795 ret = cmd->se_tfo->queue_status(cmd);
1791 break; 1796 break;
1792 default: 1797 default:
@@ -1865,6 +1870,7 @@ static void target_complete_ok_work(struct work_struct *work)
1865 } 1870 }
1866 spin_unlock(&cmd->se_lun->lun_sep_lock); 1871 spin_unlock(&cmd->se_lun->lun_sep_lock);
1867 1872
1873 trace_target_cmd_complete(cmd);
1868 ret = cmd->se_tfo->queue_data_in(cmd); 1874 ret = cmd->se_tfo->queue_data_in(cmd);
1869 if (ret == -EAGAIN || ret == -ENOMEM) 1875 if (ret == -EAGAIN || ret == -ENOMEM)
1870 goto queue_full; 1876 goto queue_full;
@@ -1893,6 +1899,7 @@ static void target_complete_ok_work(struct work_struct *work)
1893 } 1899 }
1894 /* Fall through for DMA_TO_DEVICE */ 1900 /* Fall through for DMA_TO_DEVICE */
1895 case DMA_NONE: 1901 case DMA_NONE:
1902 trace_target_cmd_complete(cmd);
1896 ret = cmd->se_tfo->queue_status(cmd); 1903 ret = cmd->se_tfo->queue_status(cmd);
1897 if (ret == -EAGAIN || ret == -ENOMEM) 1904 if (ret == -EAGAIN || ret == -ENOMEM)
1898 goto queue_full; 1905 goto queue_full;
@@ -1956,11 +1963,7 @@ static int transport_release_cmd(struct se_cmd *cmd)
1956 * If this cmd has been setup with target_get_sess_cmd(), drop 1963 * If this cmd has been setup with target_get_sess_cmd(), drop
1957 * the kref and call ->release_cmd() in kref callback. 1964 * the kref and call ->release_cmd() in kref callback.
1958 */ 1965 */
1959 if (cmd->check_release != 0) 1966 return target_put_sess_cmd(cmd->se_sess, cmd);
1960 return target_put_sess_cmd(cmd->se_sess, cmd);
1961
1962 cmd->se_tfo->release_cmd(cmd);
1963 return 1;
1964} 1967}
1965 1968
1966/** 1969/**
@@ -1971,21 +1974,6 @@ static int transport_release_cmd(struct se_cmd *cmd)
1971 */ 1974 */
1972static int transport_put_cmd(struct se_cmd *cmd) 1975static int transport_put_cmd(struct se_cmd *cmd)
1973{ 1976{
1974 unsigned long flags;
1975
1976 spin_lock_irqsave(&cmd->t_state_lock, flags);
1977 if (atomic_read(&cmd->t_fe_count) &&
1978 !atomic_dec_and_test(&cmd->t_fe_count)) {
1979 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
1980 return 0;
1981 }
1982
1983 if (cmd->transport_state & CMD_T_DEV_ACTIVE) {
1984 cmd->transport_state &= ~CMD_T_DEV_ACTIVE;
1985 target_remove_from_state_list(cmd);
1986 }
1987 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
1988
1989 transport_free_pages(cmd); 1977 transport_free_pages(cmd);
1990 return transport_release_cmd(cmd); 1978 return transport_release_cmd(cmd);
1991} 1979}
@@ -2103,9 +2091,6 @@ transport_generic_new_cmd(struct se_cmd *cmd)
2103 if (ret < 0) 2091 if (ret < 0)
2104 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; 2092 return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE;
2105 } 2093 }
2106
2107 atomic_inc(&cmd->t_fe_count);
2108
2109 /* 2094 /*
2110 * If this command is not a write we can execute it right here, 2095 * If this command is not a write we can execute it right here,
2111 * for write buffers we need to notify the fabric driver first 2096 * for write buffers we need to notify the fabric driver first
@@ -2116,12 +2101,7 @@ transport_generic_new_cmd(struct se_cmd *cmd)
2116 target_execute_cmd(cmd); 2101 target_execute_cmd(cmd);
2117 return 0; 2102 return 0;
2118 } 2103 }
2119 2104 transport_cmd_check_stop(cmd, false, true);
2120 spin_lock_irq(&cmd->t_state_lock);
2121 cmd->t_state = TRANSPORT_WRITE_PENDING;
2122 spin_unlock_irq(&cmd->t_state_lock);
2123
2124 transport_cmd_check_stop(cmd, false);
2125 2105
2126 ret = cmd->se_tfo->write_pending(cmd); 2106 ret = cmd->se_tfo->write_pending(cmd);
2127 if (ret == -EAGAIN || ret == -ENOMEM) 2107 if (ret == -EAGAIN || ret == -ENOMEM)
@@ -2202,8 +2182,6 @@ int target_get_sess_cmd(struct se_session *se_sess, struct se_cmd *se_cmd,
2202 goto out; 2182 goto out;
2203 } 2183 }
2204 list_add_tail(&se_cmd->se_cmd_list, &se_sess->sess_cmd_list); 2184 list_add_tail(&se_cmd->se_cmd_list, &se_sess->sess_cmd_list);
2205 se_cmd->check_release = 1;
2206
2207out: 2185out:
2208 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags); 2186 spin_unlock_irqrestore(&se_sess->sess_cmd_lock, flags);
2209 return ret; 2187 return ret;
@@ -2319,7 +2297,7 @@ static int transport_lun_wait_for_tasks(struct se_cmd *cmd, struct se_lun *lun)
2319 pr_debug("ConfigFS ITT[0x%08x] - CMD_T_STOP, skipping\n", 2297 pr_debug("ConfigFS ITT[0x%08x] - CMD_T_STOP, skipping\n",
2320 cmd->se_tfo->get_task_tag(cmd)); 2298 cmd->se_tfo->get_task_tag(cmd));
2321 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2299 spin_unlock_irqrestore(&cmd->t_state_lock, flags);
2322 transport_cmd_check_stop(cmd, false); 2300 transport_cmd_check_stop(cmd, false, false);
2323 return -EPERM; 2301 return -EPERM;
2324 } 2302 }
2325 cmd->transport_state |= CMD_T_LUN_FE_STOP; 2303 cmd->transport_state |= CMD_T_LUN_FE_STOP;
@@ -2427,7 +2405,7 @@ check_cond:
2427 2405
2428 spin_unlock_irqrestore(&cmd->t_state_lock, 2406 spin_unlock_irqrestore(&cmd->t_state_lock,
2429 cmd_flags); 2407 cmd_flags);
2430 transport_cmd_check_stop(cmd, false); 2408 transport_cmd_check_stop(cmd, false, false);
2431 complete(&cmd->transport_lun_fe_stop_comp); 2409 complete(&cmd->transport_lun_fe_stop_comp);
2432 spin_lock_irqsave(&lun->lun_cmd_lock, lun_flags); 2410 spin_lock_irqsave(&lun->lun_cmd_lock, lun_flags);
2433 continue; 2411 continue;
@@ -2778,6 +2756,7 @@ transport_send_check_condition_and_sense(struct se_cmd *cmd,
2778 cmd->scsi_sense_length = TRANSPORT_SENSE_BUFFER; 2756 cmd->scsi_sense_length = TRANSPORT_SENSE_BUFFER;
2779 2757
2780after_reason: 2758after_reason:
2759 trace_target_cmd_complete(cmd);
2781 return cmd->se_tfo->queue_status(cmd); 2760 return cmd->se_tfo->queue_status(cmd);
2782} 2761}
2783EXPORT_SYMBOL(transport_send_check_condition_and_sense); 2762EXPORT_SYMBOL(transport_send_check_condition_and_sense);
@@ -2794,6 +2773,7 @@ int transport_check_aborted_status(struct se_cmd *cmd, int send_status)
2794 cmd->t_task_cdb[0], cmd->se_tfo->get_task_tag(cmd)); 2773 cmd->t_task_cdb[0], cmd->se_tfo->get_task_tag(cmd));
2795 2774
2796 cmd->se_cmd_flags |= SCF_SENT_DELAYED_TAS; 2775 cmd->se_cmd_flags |= SCF_SENT_DELAYED_TAS;
2776 trace_target_cmd_complete(cmd);
2797 cmd->se_tfo->queue_status(cmd); 2777 cmd->se_tfo->queue_status(cmd);
2798 2778
2799 return 1; 2779 return 1;
@@ -2831,6 +2811,7 @@ void transport_send_task_abort(struct se_cmd *cmd)
2831 " ITT: 0x%08x\n", cmd->t_task_cdb[0], 2811 " ITT: 0x%08x\n", cmd->t_task_cdb[0],
2832 cmd->se_tfo->get_task_tag(cmd)); 2812 cmd->se_tfo->get_task_tag(cmd));
2833 2813
2814 trace_target_cmd_complete(cmd);
2834 cmd->se_tfo->queue_status(cmd); 2815 cmd->se_tfo->queue_status(cmd);
2835} 2816}
2836 2817
diff --git a/drivers/target/tcm_fc/tcm_fc.h b/drivers/target/tcm_fc/tcm_fc.h
index eea69358ced3..0dd54a44abcf 100644
--- a/drivers/target/tcm_fc/tcm_fc.h
+++ b/drivers/target/tcm_fc/tcm_fc.h
@@ -161,7 +161,7 @@ int ft_write_pending(struct se_cmd *);
161int ft_write_pending_status(struct se_cmd *); 161int ft_write_pending_status(struct se_cmd *);
162u32 ft_get_task_tag(struct se_cmd *); 162u32 ft_get_task_tag(struct se_cmd *);
163int ft_get_cmd_state(struct se_cmd *); 163int ft_get_cmd_state(struct se_cmd *);
164int ft_queue_tm_resp(struct se_cmd *); 164void ft_queue_tm_resp(struct se_cmd *);
165 165
166/* 166/*
167 * other internal functions. 167 * other internal functions.
diff --git a/drivers/target/tcm_fc/tfc_cmd.c b/drivers/target/tcm_fc/tfc_cmd.c
index b406f178ff39..0e5a1caed176 100644
--- a/drivers/target/tcm_fc/tfc_cmd.c
+++ b/drivers/target/tcm_fc/tfc_cmd.c
@@ -394,14 +394,14 @@ static void ft_send_tm(struct ft_cmd *cmd)
394/* 394/*
395 * Send status from completed task management request. 395 * Send status from completed task management request.
396 */ 396 */
397int ft_queue_tm_resp(struct se_cmd *se_cmd) 397void ft_queue_tm_resp(struct se_cmd *se_cmd)
398{ 398{
399 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd); 399 struct ft_cmd *cmd = container_of(se_cmd, struct ft_cmd, se_cmd);
400 struct se_tmr_req *tmr = se_cmd->se_tmr_req; 400 struct se_tmr_req *tmr = se_cmd->se_tmr_req;
401 enum fcp_resp_rsp_codes code; 401 enum fcp_resp_rsp_codes code;
402 402
403 if (cmd->aborted) 403 if (cmd->aborted)
404 return 0; 404 return;
405 switch (tmr->response) { 405 switch (tmr->response) {
406 case TMR_FUNCTION_COMPLETE: 406 case TMR_FUNCTION_COMPLETE:
407 code = FCP_TMF_CMPL; 407 code = FCP_TMF_CMPL;
@@ -413,10 +413,7 @@ int ft_queue_tm_resp(struct se_cmd *se_cmd)
413 code = FCP_TMF_REJECTED; 413 code = FCP_TMF_REJECTED;
414 break; 414 break;
415 case TMR_TASK_DOES_NOT_EXIST: 415 case TMR_TASK_DOES_NOT_EXIST:
416 case TMR_TASK_STILL_ALLEGIANT:
417 case TMR_TASK_FAILOVER_NOT_SUPPORTED:
418 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED: 416 case TMR_TASK_MGMT_FUNCTION_NOT_SUPPORTED:
419 case TMR_FUNCTION_AUTHORIZATION_FAILED:
420 default: 417 default:
421 code = FCP_TMF_FAILED; 418 code = FCP_TMF_FAILED;
422 break; 419 break;
@@ -424,7 +421,6 @@ int ft_queue_tm_resp(struct se_cmd *se_cmd)
424 pr_debug("tmr fn %d resp %d fcp code %d\n", 421 pr_debug("tmr fn %d resp %d fcp code %d\n",
425 tmr->function, tmr->response, code); 422 tmr->function, tmr->response, code);
426 ft_send_resp_code(cmd, code); 423 ft_send_resp_code(cmd, code);
427 return 0;
428} 424}
429 425
430static void ft_send_work(struct work_struct *work); 426static void ft_send_work(struct work_struct *work);
generated by cgit v1.2.2 (git 2.25.0) at 2025-02-06 12:11:28 -0500