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

Configure Feed

Select the types of activity you want to include in your feed.

target: refactor transport_emulate_control_cdb

Encapsulate each CDB emulation into a function of its own, to prepare
setting ->exectute_task to these routines.

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
6ed5a557 e76a35d6

+59 -46
+59 -46
drivers/target/target_core_cdb.c
··· 680 680 } 681 681 682 682 static int 683 - target_emulate_inquiry(struct se_cmd *cmd) 683 + target_emulate_inquiry(struct se_task *task) 684 684 { 685 + struct se_cmd *cmd = task->task_se_cmd; 685 686 struct se_device *dev = cmd->se_dev; 686 687 unsigned char *buf; 687 688 unsigned char *cdb = cmd->t_task_cdb; ··· 722 721 } 723 722 724 723 static int 725 - target_emulate_readcapacity(struct se_cmd *cmd) 724 + target_emulate_readcapacity(struct se_task *task) 726 725 { 726 + struct se_cmd *cmd = task->task_se_cmd; 727 727 struct se_device *dev = cmd->se_dev; 728 728 unsigned char *buf; 729 729 unsigned long long blocks_long = dev->transport->get_blocks(dev); ··· 757 755 } 758 756 759 757 static int 760 - target_emulate_readcapacity_16(struct se_cmd *cmd) 758 + target_emulate_readcapacity_16(struct se_task *task) 761 759 { 760 + struct se_cmd *cmd = task->task_se_cmd; 762 761 struct se_device *dev = cmd->se_dev; 763 762 unsigned char *buf; 764 763 unsigned long long blocks = dev->transport->get_blocks(dev); ··· 926 923 } 927 924 928 925 static int 929 - target_emulate_modesense(struct se_cmd *cmd, int ten) 926 + target_emulate_modesense(struct se_task *task) 930 927 { 928 + struct se_cmd *cmd = task->task_se_cmd; 931 929 struct se_device *dev = cmd->se_dev; 932 930 char *cdb = cmd->t_task_cdb; 933 931 unsigned char *rbuf; 934 932 int type = dev->transport->get_device_type(dev); 935 - int offset = (ten) ? 8 : 4; 933 + int ten = (cmd->t_task_cdb[0] == MODE_SENSE_10); 934 + int offset = ten ? 8 : 4; 936 935 int length = 0; 937 936 unsigned char buf[SE_MODE_PAGE_BUF]; 938 937 ··· 1004 999 } 1005 1000 1006 1001 static int 1007 - target_emulate_request_sense(struct se_cmd *cmd) 1002 + target_emulate_request_sense(struct se_task *task) 1008 1003 { 1004 + struct se_cmd *cmd = task->task_se_cmd; 1009 1005 unsigned char *cdb = cmd->t_task_cdb; 1010 1006 unsigned char *buf; 1011 1007 u8 ua_asc = 0, ua_ascq = 0; ··· 1085 1079 int ret = 0, offset; 1086 1080 unsigned short dl, bd_dl; 1087 1081 1082 + if (!dev->transport->do_discard) { 1083 + pr_err("UNMAP emulation not supported for: %s\n", 1084 + dev->transport->name); 1085 + return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1086 + } 1087 + 1088 1088 /* First UNMAP block descriptor starts at 8 byte offset */ 1089 1089 offset = 8; 1090 1090 size -= 8; ··· 1131 1119 * Note this is not used for TCM/pSCSI passthrough 1132 1120 */ 1133 1121 static int 1134 - target_emulate_write_same(struct se_task *task, u32 num_blocks) 1122 + target_emulate_write_same(struct se_task *task) 1135 1123 { 1136 1124 struct se_cmd *cmd = task->task_se_cmd; 1137 1125 struct se_device *dev = cmd->se_dev; 1138 1126 sector_t range; 1139 1127 sector_t lba = cmd->t_task_lba; 1128 + u32 num_blocks; 1140 1129 int ret; 1130 + 1131 + if (!dev->transport->do_discard) { 1132 + pr_err("WRITE_SAME emulation not supported" 1133 + " for: %s\n", dev->transport->name); 1134 + return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1135 + } 1136 + 1137 + if (cmd->t_task_cdb[0] == WRITE_SAME) 1138 + num_blocks = get_unaligned_be16(&cmd->t_task_cdb[7]); 1139 + else if (cmd->t_task_cdb[0] == WRITE_SAME_16) 1140 + num_blocks = get_unaligned_be32(&cmd->t_task_cdb[10]); 1141 + else /* WRITE_SAME_32 via VARIABLE_LENGTH_CMD */ 1142 + num_blocks = get_unaligned_be32(&cmd->t_task_cdb[28]); 1143 + 1141 1144 /* 1142 1145 * Use the explicit range when non zero is supplied, otherwise calculate 1143 1146 * the remaining range based on ->get_blocks() - starting LBA. ··· 1174 1147 return 0; 1175 1148 } 1176 1149 1150 + static int 1151 + target_emulate_synchronize_cache(struct se_task *task) 1152 + { 1153 + struct se_device *dev = task->task_se_cmd->se_dev; 1154 + 1155 + if (!dev->transport->do_sync_cache) { 1156 + pr_err("SYNCHRONIZE_CACHE emulation not supported" 1157 + " for: %s\n", dev->transport->name); 1158 + return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1159 + } 1160 + 1161 + dev->transport->do_sync_cache(task); 1162 + return 0; 1163 + } 1164 + 1177 1165 int 1178 1166 transport_emulate_control_cdb(struct se_task *task) 1179 1167 { ··· 1199 1157 1200 1158 switch (cmd->t_task_cdb[0]) { 1201 1159 case INQUIRY: 1202 - ret = target_emulate_inquiry(cmd); 1160 + ret = target_emulate_inquiry(task); 1203 1161 break; 1204 1162 case READ_CAPACITY: 1205 - ret = target_emulate_readcapacity(cmd); 1163 + ret = target_emulate_readcapacity(task); 1206 1164 break; 1207 1165 case MODE_SENSE: 1208 - ret = target_emulate_modesense(cmd, 0); 1166 + ret = target_emulate_modesense(task); 1209 1167 break; 1210 1168 case MODE_SENSE_10: 1211 - ret = target_emulate_modesense(cmd, 1); 1169 + ret = target_emulate_modesense(task); 1212 1170 break; 1213 1171 case SERVICE_ACTION_IN: 1214 1172 switch (cmd->t_task_cdb[1] & 0x1f) { 1215 1173 case SAI_READ_CAPACITY_16: 1216 - ret = target_emulate_readcapacity_16(cmd); 1174 + ret = target_emulate_readcapacity_16(task); 1217 1175 break; 1218 1176 default: 1219 1177 pr_err("Unsupported SA: 0x%02x\n", ··· 1222 1180 } 1223 1181 break; 1224 1182 case REQUEST_SENSE: 1225 - ret = target_emulate_request_sense(cmd); 1183 + ret = target_emulate_request_sense(task); 1226 1184 break; 1227 1185 case UNMAP: 1228 - if (!dev->transport->do_discard) { 1229 - pr_err("UNMAP emulation not supported for: %s\n", 1230 - dev->transport->name); 1231 - return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1232 - } 1233 1186 ret = target_emulate_unmap(task); 1234 1187 break; 1235 1188 case WRITE_SAME: 1236 - if (!dev->transport->do_discard) { 1237 - pr_err("WRITE_SAME emulation not supported" 1238 - " for: %s\n", dev->transport->name); 1239 - return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1240 - } 1241 - ret = target_emulate_write_same(task, 1242 - get_unaligned_be16(&cmd->t_task_cdb[7])); 1189 + ret = target_emulate_write_same(task); 1243 1190 break; 1244 1191 case WRITE_SAME_16: 1245 - if (!dev->transport->do_discard) { 1246 - pr_err("WRITE_SAME_16 emulation not supported" 1247 - " for: %s\n", dev->transport->name); 1248 - return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1249 - } 1250 - ret = target_emulate_write_same(task, 1251 - get_unaligned_be32(&cmd->t_task_cdb[10])); 1192 + ret = target_emulate_write_same(task); 1252 1193 break; 1253 1194 case VARIABLE_LENGTH_CMD: 1254 1195 service_action = 1255 1196 get_unaligned_be16(&cmd->t_task_cdb[8]); 1256 1197 switch (service_action) { 1257 1198 case WRITE_SAME_32: 1258 - if (!dev->transport->do_discard) { 1259 - pr_err("WRITE_SAME_32 SA emulation not" 1260 - " supported for: %s\n", 1261 - dev->transport->name); 1262 - return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1263 - } 1264 - ret = target_emulate_write_same(task, 1265 - get_unaligned_be32(&cmd->t_task_cdb[28])); 1199 + ret = target_emulate_write_same(task); 1266 1200 break; 1267 1201 default: 1268 1202 pr_err("Unsupported VARIABLE_LENGTH_CMD SA:" ··· 1248 1230 break; 1249 1231 case SYNCHRONIZE_CACHE: 1250 1232 case 0x91: /* SYNCHRONIZE_CACHE_16: */ 1251 - if (!dev->transport->do_sync_cache) { 1252 - pr_err("SYNCHRONIZE_CACHE emulation not supported" 1253 - " for: %s\n", dev->transport->name); 1254 - return PYX_TRANSPORT_UNKNOWN_SAM_OPCODE; 1255 - } 1256 - dev->transport->do_sync_cache(task); 1233 + ret = target_emulate_synchronize_cache(task); 1257 1234 break; 1258 1235 case ALLOW_MEDIUM_REMOVAL: 1259 1236 case ERASE: