tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

target: replace ->execute_task with ->execute_cmd

Make CDB emulation work on commands instead of tasks again as a preparation
of removing tasks completely.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Nicholas Bellinger <nab@linux-iscsi.org>

authored by

Christoph Hellwig and committed by
Nicholas Bellinger 6bb35e00 bd313778

+93 -122
+4 -8
drivers/target/target_core_alua.c
··· 59 59 * 60 60 * See spc4r17 section 6.27 61 61 */ 62 - int target_emulate_report_target_port_groups(struct se_task *task) 62 + int target_emulate_report_target_port_groups(struct se_cmd *cmd) 63 63 { 64 - struct se_cmd *cmd = task->task_se_cmd; 65 64 struct se_subsystem_dev *su_dev = cmd->se_dev->se_sub_dev; 66 65 struct se_port *port; 67 66 struct t10_alua_tg_pt_gp *tg_pt_gp; ··· 165 166 166 167 transport_kunmap_data_sg(cmd); 167 168 168 - task->task_scsi_status = GOOD; 169 - transport_complete_task(task, 1); 169 + target_complete_cmd(cmd, GOOD); 170 170 return 0; 171 171 } 172 172 ··· 174 176 * 175 177 * See spc4r17 section 6.35 176 178 */ 177 - int target_emulate_set_target_port_groups(struct se_task *task) 179 + int target_emulate_set_target_port_groups(struct se_cmd *cmd) 178 180 { 179 - struct se_cmd *cmd = task->task_se_cmd; 180 181 struct se_device *dev = cmd->se_dev; 181 182 struct se_subsystem_dev *su_dev = dev->se_sub_dev; 182 183 struct se_port *port, *l_port = cmd->se_lun->lun_sep; ··· 348 351 349 352 out: 350 353 transport_kunmap_data_sg(cmd); 351 - task->task_scsi_status = GOOD; 352 - transport_complete_task(task, 1); 354 + target_complete_cmd(cmd, GOOD); 353 355 return 0; 354 356 } 355 357
+2 -2
drivers/target/target_core_alua.h
··· 66 66 extern struct kmem_cache *t10_alua_tg_pt_gp_cache; 67 67 extern struct kmem_cache *t10_alua_tg_pt_gp_mem_cache; 68 68 69 - extern int target_emulate_report_target_port_groups(struct se_task *); 70 - extern int target_emulate_set_target_port_groups(struct se_task *); 69 + extern int target_emulate_report_target_port_groups(struct se_cmd *); 70 + extern int target_emulate_set_target_port_groups(struct se_cmd *); 71 71 extern int core_alua_check_nonop_delay(struct se_cmd *); 72 72 extern int core_alua_do_port_transition(struct t10_alua_tg_pt_gp *, 73 73 struct se_device *, struct se_port *,
+22 -42
drivers/target/target_core_cdb.c
··· 601 601 return 0; 602 602 } 603 603 604 - int target_emulate_inquiry(struct se_task *task) 604 + int target_emulate_inquiry(struct se_cmd *cmd) 605 605 { 606 - struct se_cmd *cmd = task->task_se_cmd; 607 606 struct se_device *dev = cmd->se_dev; 608 607 struct se_portal_group *tpg = cmd->se_lun->lun_sep->sep_tpg; 609 608 unsigned char *buf, *map_buf; ··· 666 667 } 667 668 transport_kunmap_data_sg(cmd); 668 669 669 - if (!ret) { 670 - task->task_scsi_status = GOOD; 671 - transport_complete_task(task, 1); 672 - } 670 + if (!ret) 671 + target_complete_cmd(cmd, GOOD); 673 672 return ret; 674 673 } 675 674 676 - int target_emulate_readcapacity(struct se_task *task) 675 + int target_emulate_readcapacity(struct se_cmd *cmd) 677 676 { 678 - struct se_cmd *cmd = task->task_se_cmd; 679 677 struct se_device *dev = cmd->se_dev; 680 678 unsigned char *buf; 681 679 unsigned long long blocks_long = dev->transport->get_blocks(dev); ··· 696 700 697 701 transport_kunmap_data_sg(cmd); 698 702 699 - task->task_scsi_status = GOOD; 700 - transport_complete_task(task, 1); 703 + target_complete_cmd(cmd, GOOD); 701 704 return 0; 702 705 } 703 706 704 - int target_emulate_readcapacity_16(struct se_task *task) 707 + int target_emulate_readcapacity_16(struct se_cmd *cmd) 705 708 { 706 - struct se_cmd *cmd = task->task_se_cmd; 707 709 struct se_device *dev = cmd->se_dev; 708 710 unsigned char *buf; 709 711 unsigned long long blocks = dev->transport->get_blocks(dev); ··· 729 735 730 736 transport_kunmap_data_sg(cmd); 731 737 732 - task->task_scsi_status = GOOD; 733 - transport_complete_task(task, 1); 738 + target_complete_cmd(cmd, GOOD); 734 739 return 0; 735 740 } 736 741 ··· 868 875 } 869 876 } 870 877 871 - int target_emulate_modesense(struct se_task *task) 878 + int target_emulate_modesense(struct se_cmd *cmd) 872 879 { 873 - struct se_cmd *cmd = task->task_se_cmd; 874 880 struct se_device *dev = cmd->se_dev; 875 881 char *cdb = cmd->t_task_cdb; 876 882 unsigned char *rbuf; ··· 942 950 memcpy(rbuf, buf, offset); 943 951 transport_kunmap_data_sg(cmd); 944 952 945 - task->task_scsi_status = GOOD; 946 - transport_complete_task(task, 1); 953 + target_complete_cmd(cmd, GOOD); 947 954 return 0; 948 955 } 949 956 950 - int target_emulate_request_sense(struct se_task *task) 957 + int target_emulate_request_sense(struct se_cmd *cmd) 951 958 { 952 - struct se_cmd *cmd = task->task_se_cmd; 953 959 unsigned char *cdb = cmd->t_task_cdb; 954 960 unsigned char *buf; 955 961 u8 ua_asc = 0, ua_ascq = 0; ··· 1001 1011 1002 1012 end: 1003 1013 transport_kunmap_data_sg(cmd); 1004 - task->task_scsi_status = GOOD; 1005 - transport_complete_task(task, 1); 1014 + target_complete_cmd(cmd, GOOD); 1006 1015 return 0; 1007 1016 } 1008 1017 ··· 1009 1020 * Used for TCM/IBLOCK and TCM/FILEIO for block/blk-lib.c level discard support. 1010 1021 * Note this is not used for TCM/pSCSI passthrough 1011 1022 */ 1012 - int target_emulate_unmap(struct se_task *task) 1023 + int target_emulate_unmap(struct se_cmd *cmd) 1013 1024 { 1014 - struct se_cmd *cmd = task->task_se_cmd; 1015 1025 struct se_device *dev = cmd->se_dev; 1016 1026 unsigned char *buf, *ptr = NULL; 1017 1027 unsigned char *cdb = &cmd->t_task_cdb[0]; ··· 1057 1069 1058 1070 err: 1059 1071 transport_kunmap_data_sg(cmd); 1060 - if (!ret) { 1061 - task->task_scsi_status = GOOD; 1062 - transport_complete_task(task, 1); 1063 - } 1072 + if (!ret) 1073 + target_complete_cmd(cmd, GOOD); 1064 1074 return ret; 1065 1075 } 1066 1076 ··· 1066 1080 * Used for TCM/IBLOCK and TCM/FILEIO for block/blk-lib.c level discard support. 1067 1081 * Note this is not used for TCM/pSCSI passthrough 1068 1082 */ 1069 - int target_emulate_write_same(struct se_task *task) 1083 + int target_emulate_write_same(struct se_cmd *cmd) 1070 1084 { 1071 - struct se_cmd *cmd = task->task_se_cmd; 1072 1085 struct se_device *dev = cmd->se_dev; 1073 1086 sector_t range; 1074 1087 sector_t lba = cmd->t_task_lba; ··· 1106 1121 return ret; 1107 1122 } 1108 1123 1109 - task->task_scsi_status = GOOD; 1110 - transport_complete_task(task, 1); 1124 + target_complete_cmd(cmd, GOOD); 1111 1125 return 0; 1112 1126 } 1113 1127 1114 - int target_emulate_synchronize_cache(struct se_task *task) 1128 + int target_emulate_synchronize_cache(struct se_cmd *cmd) 1115 1129 { 1116 - struct se_device *dev = task->task_se_cmd->se_dev; 1117 - struct se_cmd *cmd = task->task_se_cmd; 1118 - 1119 - if (!dev->transport->do_sync_cache) { 1130 + if (!cmd->se_dev->transport->do_sync_cache) { 1120 1131 pr_err("SYNCHRONIZE_CACHE emulation not supported" 1121 - " for: %s\n", dev->transport->name); 1132 + " for: %s\n", cmd->se_dev->transport->name); 1122 1133 cmd->scsi_sense_reason = TCM_UNSUPPORTED_SCSI_OPCODE; 1123 1134 return -ENOSYS; 1124 1135 } 1125 1136 1126 - dev->transport->do_sync_cache(task); 1137 + cmd->se_dev->transport->do_sync_cache(cmd); 1127 1138 return 0; 1128 1139 } 1129 1140 1130 - int target_emulate_noop(struct se_task *task) 1141 + int target_emulate_noop(struct se_cmd *cmd) 1131 1142 { 1132 - task->task_scsi_status = GOOD; 1133 - transport_complete_task(task, 1); 1143 + target_complete_cmd(cmd, GOOD); 1134 1144 return 0; 1135 1145 }
+2 -4
drivers/target/target_core_device.c
··· 643 643 lun->lun_se_dev = NULL; 644 644 } 645 645 646 - int target_report_luns(struct se_task *se_task) 646 + int target_report_luns(struct se_cmd *se_cmd) 647 647 { 648 - struct se_cmd *se_cmd = se_task->task_se_cmd; 649 648 struct se_dev_entry *deve; 650 649 struct se_session *se_sess = se_cmd->se_sess; 651 650 unsigned char *buf; ··· 695 696 buf[3] = (lun_count & 0xff); 696 697 transport_kunmap_data_sg(se_cmd); 697 698 698 - se_task->task_scsi_status = GOOD; 699 - transport_complete_task(se_task, 1); 699 + target_complete_cmd(se_cmd, GOOD); 700 700 return 0; 701 701 } 702 702
+1 -2
drivers/target/target_core_file.c
··· 356 356 return 1; 357 357 } 358 358 359 - static void fd_emulate_sync_cache(struct se_task *task) 359 + static void fd_emulate_sync_cache(struct se_cmd *cmd) 360 360 { 361 - struct se_cmd *cmd = task->task_se_cmd; 362 361 struct se_device *dev = cmd->se_dev; 363 362 struct fd_dev *fd_dev = dev->dev_ptr; 364 363 int immed = (cmd->t_task_cdb[1] & 0x2);
+1 -2
drivers/target/target_core_iblock.c
··· 304 304 * Implement SYCHRONIZE CACHE. Note that we can't handle lba ranges and must 305 305 * always flush the whole cache. 306 306 */ 307 - static void iblock_emulate_sync_cache(struct se_task *task) 307 + static void iblock_emulate_sync_cache(struct se_cmd *cmd) 308 308 { 309 - struct se_cmd *cmd = task->task_se_cmd; 310 309 struct iblock_dev *ib_dev = cmd->se_dev->dev_ptr; 311 310 int immed = (cmd->t_task_cdb[1] & 0x2); 312 311 struct bio *bio;
+10 -10
drivers/target/target_core_internal.h
··· 5 5 extern struct t10_alua_lu_gp *default_lu_gp; 6 6 7 7 /* target_core_cdb.c */ 8 - int target_emulate_inquiry(struct se_task *task); 9 - int target_emulate_readcapacity(struct se_task *task); 10 - int target_emulate_readcapacity_16(struct se_task *task); 11 - int target_emulate_modesense(struct se_task *task); 12 - int target_emulate_request_sense(struct se_task *task); 13 - int target_emulate_unmap(struct se_task *task); 14 - int target_emulate_write_same(struct se_task *task); 15 - int target_emulate_synchronize_cache(struct se_task *task); 16 - int target_emulate_noop(struct se_task *task); 8 + int target_emulate_inquiry(struct se_cmd *cmd); 9 + int target_emulate_readcapacity(struct se_cmd *cmd); 10 + int target_emulate_readcapacity_16(struct se_cmd *cmd); 11 + int target_emulate_modesense(struct se_cmd *cmd); 12 + int target_emulate_request_sense(struct se_cmd *cmd); 13 + int target_emulate_unmap(struct se_cmd *cmd); 14 + int target_emulate_write_same(struct se_cmd *cmd); 15 + int target_emulate_synchronize_cache(struct se_cmd *cmd); 16 + int target_emulate_noop(struct se_cmd *cmd); 17 17 18 18 /* target_core_device.c */ 19 19 struct se_dev_entry *core_get_se_deve_from_rtpi(struct se_node_acl *, u16); ··· 28 28 struct se_lun *); 29 29 void core_dev_unexport(struct se_device *, struct se_portal_group *, 30 30 struct se_lun *); 31 - int target_report_luns(struct se_task *); 31 + int target_report_luns(struct se_cmd *); 32 32 void se_release_device_for_hba(struct se_device *); 33 33 void se_release_vpd_for_dev(struct se_device *); 34 34 int se_free_virtual_device(struct se_device *, struct se_hba *);
+12 -24
drivers/target/target_core_pr.c
··· 193 193 return 0; 194 194 } 195 195 196 - int target_scsi2_reservation_release(struct se_task *task) 196 + int target_scsi2_reservation_release(struct se_cmd *cmd) 197 197 { 198 - struct se_cmd *cmd = task->task_se_cmd; 199 198 struct se_device *dev = cmd->se_dev; 200 199 struct se_session *sess = cmd->se_sess; 201 200 struct se_portal_group *tpg = sess->se_tpg; ··· 233 234 out_unlock: 234 235 spin_unlock(&dev->dev_reservation_lock); 235 236 out: 236 - if (!ret) { 237 - task->task_scsi_status = GOOD; 238 - transport_complete_task(task, 1); 239 - } 237 + if (!ret) 238 + target_complete_cmd(cmd, GOOD); 240 239 return ret; 241 240 } 242 241 243 - int target_scsi2_reservation_reserve(struct se_task *task) 242 + int target_scsi2_reservation_reserve(struct se_cmd *cmd) 244 243 { 245 - struct se_cmd *cmd = task->task_se_cmd; 246 244 struct se_device *dev = cmd->se_dev; 247 245 struct se_session *sess = cmd->se_sess; 248 246 struct se_portal_group *tpg = sess->se_tpg; ··· 300 304 out_unlock: 301 305 spin_unlock(&dev->dev_reservation_lock); 302 306 out: 303 - if (!ret) { 304 - task->task_scsi_status = GOOD; 305 - transport_complete_task(task, 1); 306 - } 307 + if (!ret) 308 + target_complete_cmd(cmd, GOOD); 307 309 return ret; 308 310 } 309 311 ··· 3792 3798 /* 3793 3799 * See spc4r17 section 6.14 Table 170 3794 3800 */ 3795 - int target_scsi3_emulate_pr_out(struct se_task *task) 3801 + int target_scsi3_emulate_pr_out(struct se_cmd *cmd) 3796 3802 { 3797 - struct se_cmd *cmd = task->task_se_cmd; 3798 3803 unsigned char *cdb = &cmd->t_task_cdb[0]; 3799 3804 unsigned char *buf; 3800 3805 u64 res_key, sa_res_key; ··· 3933 3940 } 3934 3941 3935 3942 out: 3936 - if (!ret) { 3937 - task->task_scsi_status = GOOD; 3938 - transport_complete_task(task, 1); 3939 - } 3943 + if (!ret) 3944 + target_complete_cmd(cmd, GOOD); 3940 3945 return ret; 3941 3946 } 3942 3947 ··· 4289 4298 return 0; 4290 4299 } 4291 4300 4292 - int target_scsi3_emulate_pr_in(struct se_task *task) 4301 + int target_scsi3_emulate_pr_in(struct se_cmd *cmd) 4293 4302 { 4294 - struct se_cmd *cmd = task->task_se_cmd; 4295 4303 int ret; 4296 4304 4297 4305 /* ··· 4331 4341 break; 4332 4342 } 4333 4343 4334 - if (!ret) { 4335 - task->task_scsi_status = GOOD; 4336 - transport_complete_task(task, 1); 4337 - } 4344 + if (!ret) 4345 + target_complete_cmd(cmd, GOOD); 4338 4346 return ret; 4339 4347 } 4340 4348
+4 -4
drivers/target/target_core_pr.h
··· 47 47 48 48 extern int core_pr_dump_initiator_port(struct t10_pr_registration *, 49 49 char *, u32); 50 - extern int target_scsi2_reservation_release(struct se_task *task); 51 - extern int target_scsi2_reservation_reserve(struct se_task *task); 50 + extern int target_scsi2_reservation_release(struct se_cmd *); 51 + extern int target_scsi2_reservation_reserve(struct se_cmd *); 52 52 extern int core_scsi3_alloc_aptpl_registration( 53 53 struct t10_reservation *, u64, 54 54 unsigned char *, unsigned char *, u32, ··· 61 61 extern void core_scsi3_free_all_registrations(struct se_device *); 62 62 extern unsigned char *core_scsi3_pr_dump_type(int); 63 63 64 - extern int target_scsi3_emulate_pr_in(struct se_task *task); 65 - extern int target_scsi3_emulate_pr_out(struct se_task *task); 64 + extern int target_scsi3_emulate_pr_in(struct se_cmd *); 65 + extern int target_scsi3_emulate_pr_out(struct se_cmd *); 66 66 extern int core_setup_reservations(struct se_device *, int); 67 67 68 68 #endif /* TARGET_CORE_PR_H */
+32 -22
drivers/target/target_core_transport.c
··· 772 772 } 773 773 EXPORT_SYMBOL(transport_complete_task); 774 774 775 + void target_complete_cmd(struct se_cmd *cmd, u8 scsi_status) 776 + { 777 + struct se_task *task = list_entry(cmd->t_task_list.next, 778 + struct se_task, t_list); 779 + 780 + task->task_scsi_status = scsi_status; 781 + transport_complete_task(task, scsi_status == GOOD); 782 + } 783 + EXPORT_SYMBOL(target_complete_cmd); 784 + 775 785 /* 776 786 * Called by transport_add_tasks_from_cmd() once a struct se_cmd's 777 787 * struct se_task list are ready to be added to the active execution list ··· 2243 2233 2244 2234 spin_unlock_irqrestore(&cmd->t_state_lock, flags); 2245 2235 2246 - if (cmd->execute_task) 2247 - error = cmd->execute_task(task); 2236 + if (cmd->execute_cmd) 2237 + error = cmd->execute_cmd(cmd); 2248 2238 else 2249 2239 error = dev->transport->do_task(task); 2250 2240 if (error != 0) { ··· 2814 2804 if (target_check_write_same_discard(&cdb[10], dev) < 0) 2815 2805 goto out_unsupported_cdb; 2816 2806 if (!passthrough) 2817 - cmd->execute_task = target_emulate_write_same; 2807 + cmd->execute_cmd = target_emulate_write_same; 2818 2808 break; 2819 2809 default: 2820 2810 pr_err("VARIABLE_LENGTH_CMD service action" ··· 2830 2820 */ 2831 2821 if (cdb[1] == MI_REPORT_TARGET_PGS && 2832 2822 su_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) { 2833 - cmd->execute_task = 2823 + cmd->execute_cmd = 2834 2824 target_emulate_report_target_port_groups; 2835 2825 } 2836 2826 size = (cdb[6] << 24) | (cdb[7] << 16) | ··· 2853 2843 size = cdb[4]; 2854 2844 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2855 2845 if (!passthrough) 2856 - cmd->execute_task = target_emulate_modesense; 2846 + cmd->execute_cmd = target_emulate_modesense; 2857 2847 break; 2858 2848 case MODE_SENSE_10: 2859 2849 size = (cdb[7] << 8) + cdb[8]; 2860 2850 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2861 2851 if (!passthrough) 2862 - cmd->execute_task = target_emulate_modesense; 2852 + cmd->execute_cmd = target_emulate_modesense; 2863 2853 break; 2864 2854 case GPCMD_READ_BUFFER_CAPACITY: 2865 2855 case GPCMD_SEND_OPC: ··· 2881 2871 break; 2882 2872 case PERSISTENT_RESERVE_IN: 2883 2873 if (su_dev->t10_pr.res_type == SPC3_PERSISTENT_RESERVATIONS) 2884 - cmd->execute_task = target_scsi3_emulate_pr_in; 2874 + cmd->execute_cmd = target_scsi3_emulate_pr_in; 2885 2875 size = (cdb[7] << 8) + cdb[8]; 2886 2876 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2887 2877 break; 2888 2878 case PERSISTENT_RESERVE_OUT: 2889 2879 if (su_dev->t10_pr.res_type == SPC3_PERSISTENT_RESERVATIONS) 2890 - cmd->execute_task = target_scsi3_emulate_pr_out; 2880 + cmd->execute_cmd = target_scsi3_emulate_pr_out; 2891 2881 size = (cdb[7] << 8) + cdb[8]; 2892 2882 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2893 2883 break; ··· 2908 2898 */ 2909 2899 if (cdb[1] == MO_SET_TARGET_PGS && 2910 2900 su_dev->t10_alua.alua_type == SPC3_ALUA_EMULATED) { 2911 - cmd->execute_task = 2901 + cmd->execute_cmd = 2912 2902 target_emulate_set_target_port_groups; 2913 2903 } 2914 2904 ··· 2930 2920 cmd->sam_task_attr = MSG_HEAD_TAG; 2931 2921 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2932 2922 if (!passthrough) 2933 - cmd->execute_task = target_emulate_inquiry; 2923 + cmd->execute_cmd = target_emulate_inquiry; 2934 2924 break; 2935 2925 case READ_BUFFER: 2936 2926 size = (cdb[6] << 16) + (cdb[7] << 8) + cdb[8]; ··· 2940 2930 size = READ_CAP_LEN; 2941 2931 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2942 2932 if (!passthrough) 2943 - cmd->execute_task = target_emulate_readcapacity; 2933 + cmd->execute_cmd = target_emulate_readcapacity; 2944 2934 break; 2945 2935 case READ_MEDIA_SERIAL_NUMBER: 2946 2936 case SECURITY_PROTOCOL_IN: ··· 2952 2942 switch (cmd->t_task_cdb[1] & 0x1f) { 2953 2943 case SAI_READ_CAPACITY_16: 2954 2944 if (!passthrough) 2955 - cmd->execute_task = 2945 + cmd->execute_cmd = 2956 2946 target_emulate_readcapacity_16; 2957 2947 break; 2958 2948 default: ··· 2995 2985 size = cdb[4]; 2996 2986 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 2997 2987 if (!passthrough) 2998 - cmd->execute_task = target_emulate_request_sense; 2988 + cmd->execute_cmd = target_emulate_request_sense; 2999 2989 break; 3000 2990 case READ_ELEMENT_STATUS: 3001 2991 size = 65536 * cdb[7] + 256 * cdb[8] + cdb[9]; ··· 3024 3014 * emulation disabled. 3025 3015 */ 3026 3016 if (su_dev->t10_pr.res_type != SPC_PASSTHROUGH) 3027 - cmd->execute_task = target_scsi2_reservation_reserve; 3017 + cmd->execute_cmd = target_scsi2_reservation_reserve; 3028 3018 cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB; 3029 3019 break; 3030 3020 case RELEASE: ··· 3039 3029 size = cmd->data_length; 3040 3030 3041 3031 if (su_dev->t10_pr.res_type != SPC_PASSTHROUGH) 3042 - cmd->execute_task = target_scsi2_reservation_release; 3032 + cmd->execute_cmd = target_scsi2_reservation_release; 3043 3033 cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB; 3044 3034 break; 3045 3035 case SYNCHRONIZE_CACHE: ··· 3071 3061 if (transport_cmd_get_valid_sectors(cmd) < 0) 3072 3062 goto out_invalid_cdb_field; 3073 3063 } 3074 - cmd->execute_task = target_emulate_synchronize_cache; 3064 + cmd->execute_cmd = target_emulate_synchronize_cache; 3075 3065 break; 3076 3066 case UNMAP: 3077 3067 size = get_unaligned_be16(&cdb[7]); 3078 3068 cmd->se_cmd_flags |= SCF_SCSI_CONTROL_SG_IO_CDB; 3079 3069 if (!passthrough) 3080 - cmd->execute_task = target_emulate_unmap; 3070 + cmd->execute_cmd = target_emulate_unmap; 3081 3071 break; 3082 3072 case WRITE_SAME_16: 3083 3073 sectors = transport_get_sectors_16(cdb, cmd, &sector_ret); ··· 3097 3087 if (target_check_write_same_discard(&cdb[1], dev) < 0) 3098 3088 goto out_unsupported_cdb; 3099 3089 if (!passthrough) 3100 - cmd->execute_task = target_emulate_write_same; 3090 + cmd->execute_cmd = target_emulate_write_same; 3101 3091 break; 3102 3092 case WRITE_SAME: 3103 3093 sectors = transport_get_sectors_10(cdb, cmd, &sector_ret); ··· 3120 3110 if (target_check_write_same_discard(&cdb[1], dev) < 0) 3121 3111 goto out_unsupported_cdb; 3122 3112 if (!passthrough) 3123 - cmd->execute_task = target_emulate_write_same; 3113 + cmd->execute_cmd = target_emulate_write_same; 3124 3114 break; 3125 3115 case ALLOW_MEDIUM_REMOVAL: 3126 3116 case ERASE: ··· 3133 3123 case WRITE_FILEMARKS: 3134 3124 cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB; 3135 3125 if (!passthrough) 3136 - cmd->execute_task = target_emulate_noop; 3126 + cmd->execute_cmd = target_emulate_noop; 3137 3127 break; 3138 3128 case GPCMD_CLOSE_TRACK: 3139 3129 case INITIALIZE_ELEMENT_STATUS: ··· 3143 3133 cmd->se_cmd_flags |= SCF_SCSI_NON_DATA_CDB; 3144 3134 break; 3145 3135 case REPORT_LUNS: 3146 - cmd->execute_task = target_report_luns; 3136 + cmd->execute_cmd = target_report_luns; 3147 3137 size = (cdb[6] << 24) | (cdb[7] << 16) | (cdb[8] << 8) | cdb[9]; 3148 3138 /* 3149 3139 * Do implict HEAD_OF_QUEUE processing for REPORT_LUNS ··· 3211 3201 } 3212 3202 3213 3203 /* reject any command that we don't have a handler for */ 3214 - if (!(passthrough || cmd->execute_task || 3204 + if (!(passthrough || cmd->execute_cmd || 3215 3205 (cmd->se_cmd_flags & SCF_SCSI_DATA_SG_IO_CDB))) 3216 3206 goto out_unsupported_cdb; 3217 3207
+2 -1
include/target/target_core_backend.h
··· 27 27 struct se_task *(*alloc_task)(unsigned char *cdb); 28 28 int (*do_task)(struct se_task *); 29 29 int (*do_discard)(struct se_device *, sector_t, u32); 30 - void (*do_sync_cache)(struct se_task *); 30 + void (*do_sync_cache)(struct se_cmd *); 31 31 void (*free_task)(struct se_task *); 32 32 ssize_t (*check_configfs_dev_params)(struct se_hba *, 33 33 struct se_subsystem_dev *); ··· 50 50 51 51 void transport_complete_sync_cache(struct se_cmd *, int); 52 52 void transport_complete_task(struct se_task *, int); 53 + void target_complete_cmd(struct se_cmd *, u8); 53 54 54 55 void transport_set_vpd_proto_id(struct t10_vpd *, unsigned char *); 55 56 int transport_set_vpd_assoc(struct t10_vpd *, unsigned char *);
+1 -1
include/target/target_core_base.h
··· 563 563 struct completion cmd_wait_comp; 564 564 struct kref cmd_kref; 565 565 struct target_core_fabric_ops *se_tfo; 566 - int (*execute_task)(struct se_task *); 566 + int (*execute_cmd)(struct se_cmd *); 567 567 void (*transport_complete_callback)(struct se_cmd *); 568 568 569 569 unsigned char *t_task_cdb;