target/iscsi: Eliminate iscsi_cmd.data_length

+11 -14

drivers/target/iscsi/iscsi_target.c

··· 968 968 buf, conn); 969 969 970 970 cmd->data_direction = data_direction; 971 - cmd->data_length = hdr->data_length; 972 971 iscsi_task_attr = hdr->flags & ISCSI_FLAG_CMD_ATTR_MASK; 973 972 /* 974 973 * Figure out the SAM Task Attribute for the incoming SCSI CDB ··· 1025 1026 * Initialize struct se_cmd descriptor from target_core_mod infrastructure 1026 1027 */ 1027 1028 transport_init_se_cmd(&cmd->se_cmd, &lio_target_fabric_configfs->tf_ops, 1028 - conn->sess->se_sess, cmd->data_length, cmd->data_direction, 1029 + conn->sess->se_sess, hdr->data_length, cmd->data_direction, 1029 1030 sam_task_attr, &cmd->sense_buffer[0]); 1030 1031 1031 1032 pr_debug("Got SCSI Command, ITT: 0x%08x, CmdSN: 0x%08x," ··· 1060 1061 */ 1061 1062 send_check_condition = 1; 1062 1063 } else { 1063 - cmd->data_length = cmd->se_cmd.data_length; 1064 - 1065 1064 if (iscsit_decide_list_to_build(cmd, payload_length) < 0) 1066 1065 return iscsit_add_reject_from_cmd( 1067 1066 ISCSI_REASON_BOOKMARK_NO_RESOURCES, ··· 1326 1329 se_cmd = &cmd->se_cmd; 1327 1330 iscsit_mod_dataout_timer(cmd); 1328 1331 1329 - if ((hdr->offset + payload_length) > cmd->data_length) { 1332 + if ((hdr->offset + payload_length) > cmd->se_cmd.data_length) { 1330 1333 pr_err("DataOut Offset: %u, Length %u greater than" 1331 1334 " iSCSI Command EDTL %u, protocol error.\n", 1332 - hdr->offset, payload_length, cmd->data_length); 1335 + hdr->offset, payload_length, cmd->se_cmd.data_length); 1333 1336 return iscsit_add_reject_from_cmd(ISCSI_REASON_BOOKMARK_INVALID, 1334 1337 1, 0, buf, cmd); 1335 1338 } ··· 2424 2427 2425 2428 cmd->write_data_done += length; 2426 2429 2427 - if (cmd->write_data_done == cmd->data_length) { 2430 + if (cmd->write_data_done == cmd->se_cmd.data_length) { 2428 2431 spin_lock_bh(&cmd->istate_lock); 2429 2432 cmd->cmd_flags |= ICF_GOT_LAST_DATAOUT; 2430 2433 cmd->i_state = ISTATE_RECEIVED_LAST_DATAOUT; ··· 2556 2559 /* 2557 2560 * Be paranoid and double check the logic for now. 2558 2561 */ 2559 - if ((datain.offset + datain.length) > cmd->data_length) { 2562 + if ((datain.offset + datain.length) > cmd->se_cmd.data_length) { 2560 2563 pr_err("Command ITT: 0x%08x, datain.offset: %u and" 2561 2564 " datain.length: %u exceeds cmd->data_length: %u\n", 2562 2565 cmd->init_task_tag, datain.offset, datain.length, 2563 - cmd->data_length); 2566 + cmd->se_cmd.data_length); 2564 2567 return -1; 2565 2568 } 2566 2569 ··· 3068 3071 conn->sess->sess_ops->MaxBurstLength - 3069 3072 cmd->next_burst_len; 3070 3073 3071 - if (new_data_end > cmd->data_length) 3072 - xfer_len = cmd->data_length - offset; 3074 + if (new_data_end > cmd->se_cmd.data_length) 3075 + xfer_len = cmd->se_cmd.data_length - offset; 3073 3076 else 3074 3077 xfer_len = 3075 3078 conn->sess->sess_ops->MaxBurstLength - ··· 3078 3081 int new_data_end = offset + 3079 3082 conn->sess->sess_ops->MaxBurstLength; 3080 3083 3081 - if (new_data_end > cmd->data_length) 3082 - xfer_len = cmd->data_length - offset; 3084 + if (new_data_end > cmd->se_cmd.data_length) 3085 + xfer_len = cmd->se_cmd.data_length - offset; 3083 3086 else 3084 3087 xfer_len = conn->sess->sess_ops->MaxBurstLength; 3085 3088 } 3086 3089 cmd->r2t_offset += xfer_len; 3087 3090 3088 - if (cmd->r2t_offset == cmd->data_length) 3091 + if (cmd->r2t_offset == cmd->se_cmd.data_length) 3089 3092 cmd->cmd_flags |= ICF_SENT_LAST_R2T; 3090 3093 } else { 3091 3094 struct iscsi_seq *seq;

-2

drivers/target/iscsi/iscsi_target_core.h

··· 380 380 u32 buf_ptr_size; 381 381 /* Used to store DataDigest */ 382 382 u32 data_crc; 383 - /* Total size in bytes associated with command */ 384 - u32 data_length; 385 383 /* Counter for MaxOutstandingR2T */ 386 384 u32 outstanding_r2ts; 387 385 /* Next R2T Offset when DataSequenceInOrder=Yes */

+9 -9

drivers/target/iscsi/iscsi_target_datain_values.c

··· 110 110 read_data_done = (!dr->recovery) ? 111 111 cmd->read_data_done : dr->read_data_done; 112 112 113 - read_data_left = (cmd->data_length - read_data_done); 113 + read_data_left = (cmd->se_cmd.data_length - read_data_done); 114 114 if (!read_data_left) { 115 115 pr_err("ITT: 0x%08x read_data_left is zero!\n", 116 116 cmd->init_task_tag); ··· 209 209 seq_send_order = (!dr->recovery) ? 210 210 cmd->seq_send_order : dr->seq_send_order; 211 211 212 - read_data_left = (cmd->data_length - read_data_done); 212 + read_data_left = (cmd->se_cmd.data_length - read_data_done); 213 213 if (!read_data_left) { 214 214 pr_err("ITT: 0x%08x read_data_left is zero!\n", 215 215 cmd->init_task_tag); ··· 228 228 offset = (seq->offset + seq->next_burst_len); 229 229 230 230 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >= 231 - cmd->data_length) { 232 - datain->length = (cmd->data_length - offset); 231 + cmd->se_cmd.data_length) { 232 + datain->length = (cmd->se_cmd.data_length - offset); 233 233 datain->offset = offset; 234 234 235 235 datain->flags |= ISCSI_FLAG_CMD_FINAL; ··· 261 261 } 262 262 } 263 263 264 - if ((read_data_done + datain->length) == cmd->data_length) 264 + if ((read_data_done + datain->length) == cmd->se_cmd.data_length) 265 265 datain->flags |= ISCSI_FLAG_DATA_STATUS; 266 266 267 267 datain->data_sn = (!dr->recovery) ? cmd->data_sn++ : dr->data_sn++; ··· 330 330 read_data_done = (!dr->recovery) ? 331 331 cmd->read_data_done : dr->read_data_done; 332 332 333 - read_data_left = (cmd->data_length - read_data_done); 333 + read_data_left = (cmd->se_cmd.data_length - read_data_done); 334 334 if (!read_data_left) { 335 335 pr_err("ITT: 0x%08x read_data_left is zero!\n", 336 336 cmd->init_task_tag); ··· 341 341 if (!pdu) 342 342 return dr; 343 343 344 - if ((read_data_done + pdu->length) == cmd->data_length) { 344 + if ((read_data_done + pdu->length) == cmd->se_cmd.data_length) { 345 345 pdu->flags |= (ISCSI_FLAG_CMD_FINAL | ISCSI_FLAG_DATA_STATUS); 346 346 if (conn->sess->sess_ops->ErrorRecoveryLevel > 0) 347 347 pdu->flags |= ISCSI_FLAG_DATA_ACK; ··· 430 430 seq_send_order = (!dr->recovery) ? 431 431 cmd->seq_send_order : dr->seq_send_order; 432 432 433 - read_data_left = (cmd->data_length - read_data_done); 433 + read_data_left = (cmd->se_cmd.data_length - read_data_done); 434 434 if (!read_data_left) { 435 435 pr_err("ITT: 0x%08x read_data_left is zero!\n", 436 436 cmd->init_task_tag); ··· 460 460 } else 461 461 seq->next_burst_len += pdu->length; 462 462 463 - if ((read_data_done + pdu->length) == cmd->data_length) 463 + if ((read_data_done + pdu->length) == cmd->se_cmd.data_length) 464 464 pdu->flags |= ISCSI_FLAG_DATA_STATUS; 465 465 466 466 pdu->data_sn = (!dr->recovery) ? cmd->data_sn++ : dr->data_sn++;

+12 -12

drivers/target/iscsi/iscsi_target_erl0.c

··· 48 48 if (cmd->unsolicited_data) { 49 49 cmd->seq_start_offset = cmd->write_data_done; 50 50 cmd->seq_end_offset = (cmd->write_data_done + 51 - (cmd->data_length > 51 + (cmd->se_cmd.data_length > 52 52 conn->sess->sess_ops->FirstBurstLength) ? 53 - conn->sess->sess_ops->FirstBurstLength : cmd->data_length); 53 + conn->sess->sess_ops->FirstBurstLength : cmd->se_cmd.data_length); 54 54 return; 55 55 } 56 56 ··· 59 59 60 60 if (!cmd->seq_start_offset && !cmd->seq_end_offset) { 61 61 cmd->seq_start_offset = cmd->write_data_done; 62 - cmd->seq_end_offset = (cmd->data_length > 62 + cmd->seq_end_offset = (cmd->se_cmd.data_length > 63 63 conn->sess->sess_ops->MaxBurstLength) ? 64 64 (cmd->write_data_done + 65 - conn->sess->sess_ops->MaxBurstLength) : cmd->data_length; 65 + conn->sess->sess_ops->MaxBurstLength) : cmd->se_cmd.data_length; 66 66 } else { 67 67 cmd->seq_start_offset = cmd->seq_end_offset; 68 68 cmd->seq_end_offset = ((cmd->seq_end_offset + 69 69 conn->sess->sess_ops->MaxBurstLength) >= 70 - cmd->data_length) ? cmd->data_length : 70 + cmd->se_cmd.data_length) ? cmd->se_cmd.data_length : 71 71 (cmd->seq_end_offset + 72 72 conn->sess->sess_ops->MaxBurstLength); 73 73 } ··· 182 182 if (!conn->sess->sess_ops->DataPDUInOrder) 183 183 goto out; 184 184 185 - if ((first_burst_len != cmd->data_length) && 185 + if ((first_burst_len != cmd->se_cmd.data_length) && 186 186 (first_burst_len != conn->sess->sess_ops->FirstBurstLength)) { 187 187 pr_err("Unsolicited non-immediate data" 188 188 " received %u does not equal FirstBurstLength: %u, and" 189 189 " does not equal ExpXferLen %u.\n", first_burst_len, 190 190 conn->sess->sess_ops->FirstBurstLength, 191 - cmd->data_length); 191 + cmd->se_cmd.data_length); 192 192 transport_send_check_condition_and_sense(&cmd->se_cmd, 193 193 TCM_INCORRECT_AMOUNT_OF_DATA, 0); 194 194 return DATAOUT_CANNOT_RECOVER; ··· 201 201 conn->sess->sess_ops->FirstBurstLength); 202 202 return DATAOUT_CANNOT_RECOVER; 203 203 } 204 - if (first_burst_len == cmd->data_length) { 204 + if (first_burst_len == cmd->se_cmd.data_length) { 205 205 pr_err("Command ITT: 0x%08x reached" 206 206 " ExpXferLen: %u, but ISCSI_FLAG_CMD_FINAL is not set. protocol" 207 - " error.\n", cmd->init_task_tag, cmd->data_length); 207 + " error.\n", cmd->init_task_tag, cmd->se_cmd.data_length); 208 208 return DATAOUT_CANNOT_RECOVER; 209 209 } 210 210 } ··· 294 294 if ((next_burst_len < 295 295 conn->sess->sess_ops->MaxBurstLength) && 296 296 ((cmd->write_data_done + payload_length) < 297 - cmd->data_length)) { 297 + cmd->se_cmd.data_length)) { 298 298 pr_err("Command ITT: 0x%08x set ISCSI_FLAG_CMD_FINAL" 299 299 " before end of DataOUT sequence, protocol" 300 300 " error.\n", cmd->init_task_tag); ··· 319 319 return DATAOUT_CANNOT_RECOVER; 320 320 } 321 321 if ((cmd->write_data_done + payload_length) == 322 - cmd->data_length) { 322 + cmd->se_cmd.data_length) { 323 323 pr_err("Command ITT: 0x%08x reached" 324 324 " last DataOUT PDU in sequence but ISCSI_FLAG_" 325 325 "CMD_FINAL is not set, protocol error.\n", ··· 640 640 641 641 cmd->write_data_done += payload_length; 642 642 643 - if (cmd->write_data_done == cmd->data_length) 643 + if (cmd->write_data_done == cmd->se_cmd.data_length) 644 644 return DATAOUT_SEND_TO_TRANSPORT; 645 645 else if (send_r2t) 646 646 return DATAOUT_SEND_R2T;

+4 -4

drivers/target/iscsi/iscsi_target_erl1.c

··· 1116 1116 if (cmd->unsolicited_data) { 1117 1117 *offset = 0; 1118 1118 *length = (conn->sess->sess_ops->FirstBurstLength > 1119 - cmd->data_length) ? 1120 - cmd->data_length : 1119 + cmd->se_cmd.data_length) ? 1120 + cmd->se_cmd.data_length : 1121 1121 conn->sess->sess_ops->FirstBurstLength; 1122 1122 return 0; 1123 1123 } ··· 1188 1188 if (conn->sess->sess_ops->DataPDUInOrder) { 1189 1189 pdu_offset = cmd->write_data_done; 1190 1190 if ((pdu_offset + (conn->sess->sess_ops->MaxBurstLength - 1191 - cmd->next_burst_len)) > cmd->data_length) 1192 - pdu_length = (cmd->data_length - 1191 + cmd->next_burst_len)) > cmd->se_cmd.data_length) 1192 + pdu_length = (cmd->se_cmd.data_length - 1193 1193 cmd->write_data_done); 1194 1194 else 1195 1195 pdu_length = (conn->sess->sess_ops->MaxBurstLength -

+20 -22

drivers/target/iscsi/iscsi_target_seq_pdu_list.c

··· 226 226 227 227 if ((bl->type == PDULIST_UNSOLICITED) || 228 228 (bl->type == PDULIST_IMMEDIATE_AND_UNSOLICITED)) 229 - unsolicited_data_length = (cmd->data_length > 230 - conn->sess->sess_ops->FirstBurstLength) ? 231 - conn->sess->sess_ops->FirstBurstLength : cmd->data_length; 229 + unsolicited_data_length = min(cmd->se_cmd.data_length, 230 + conn->sess->sess_ops->FirstBurstLength); 232 231 233 - while (offset < cmd->data_length) { 232 + while (offset < cmd->se_cmd.data_length) { 234 233 *pdu_count += 1; 235 234 236 235 if (check_immediate) { ··· 243 244 } 244 245 if (unsolicited_data_length > 0) { 245 246 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) 246 - >= cmd->data_length) { 247 + >= cmd->se_cmd.data_length) { 247 248 unsolicited_data_length -= 248 - (cmd->data_length - offset); 249 - offset += (cmd->data_length - offset); 249 + (cmd->se_cmd.data_length - offset); 250 + offset += (cmd->se_cmd.data_length - offset); 250 251 continue; 251 252 } 252 253 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) ··· 267 268 continue; 268 269 } 269 270 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >= 270 - cmd->data_length) { 271 - offset += (cmd->data_length - offset); 271 + cmd->se_cmd.data_length) { 272 + offset += (cmd->se_cmd.data_length - offset); 272 273 continue; 273 274 } 274 275 if ((burstlength + conn->conn_ops->MaxRecvDataSegmentLength) >= ··· 310 311 311 312 if ((bl->type == PDULIST_UNSOLICITED) || 312 313 (bl->type == PDULIST_IMMEDIATE_AND_UNSOLICITED)) 313 - unsolicited_data_length = (cmd->data_length > 314 - conn->sess->sess_ops->FirstBurstLength) ? 315 - conn->sess->sess_ops->FirstBurstLength : cmd->data_length; 314 + unsolicited_data_length = min(cmd->se_cmd.data_length, 315 + conn->sess->sess_ops->FirstBurstLength); 316 316 317 - while (offset < cmd->data_length) { 317 + while (offset < cmd->se_cmd.data_length) { 318 318 pdu_count++; 319 319 if (!datapduinorder) { 320 320 pdu[i].offset = offset; ··· 349 351 if (unsolicited_data_length > 0) { 350 352 if ((offset + 351 353 conn->conn_ops->MaxRecvDataSegmentLength) >= 352 - cmd->data_length) { 354 + cmd->se_cmd.data_length) { 353 355 if (!datapduinorder) { 354 356 pdu[i].type = PDUTYPE_UNSOLICITED; 355 357 pdu[i].length = 356 - (cmd->data_length - offset); 358 + (cmd->se_cmd.data_length - offset); 357 359 } 358 360 if (!datasequenceinorder) { 359 361 seq[seq_no].type = SEQTYPE_UNSOLICITED; 360 362 seq[seq_no].pdu_count = pdu_count; 361 363 seq[seq_no].xfer_len = (burstlength + 362 - (cmd->data_length - offset)); 364 + (cmd->se_cmd.data_length - offset)); 363 365 } 364 366 unsolicited_data_length -= 365 - (cmd->data_length - offset); 366 - offset += (cmd->data_length - offset); 367 + (cmd->se_cmd.data_length - offset); 368 + offset += (cmd->se_cmd.data_length - offset); 367 369 continue; 368 370 } 369 371 if ((offset + ··· 405 407 continue; 406 408 } 407 409 if ((offset + conn->conn_ops->MaxRecvDataSegmentLength) >= 408 - cmd->data_length) { 410 + cmd->se_cmd.data_length) { 409 411 if (!datapduinorder) { 410 412 pdu[i].type = PDUTYPE_NORMAL; 411 - pdu[i].length = (cmd->data_length - offset); 413 + pdu[i].length = (cmd->se_cmd.data_length - offset); 412 414 } 413 415 if (!datasequenceinorder) { 414 416 seq[seq_no].type = SEQTYPE_NORMAL; 415 417 seq[seq_no].pdu_count = pdu_count; 416 418 seq[seq_no].xfer_len = (burstlength + 417 - (cmd->data_length - offset)); 419 + (cmd->se_cmd.data_length - offset)); 418 420 } 419 - offset += (cmd->data_length - offset); 421 + offset += (cmd->se_cmd.data_length - offset); 420 422 continue; 421 423 } 422 424 if ((burstlength + conn->conn_ops->MaxRecvDataSegmentLength) >=

+2 -2

drivers/target/iscsi/iscsi_target_tmr.c

··· 269 269 offset = cmd->next_burst_len = cmd->write_data_done; 270 270 271 271 if ((conn->sess->sess_ops->FirstBurstLength - offset) >= 272 - cmd->data_length) { 272 + cmd->se_cmd.data_length) { 273 273 no_build_r2ts = 1; 274 - length = (cmd->data_length - offset); 274 + length = (cmd->se_cmd.data_length - offset); 275 275 } else 276 276 length = (conn->sess->sess_ops->FirstBurstLength - offset); 277 277

+2 -2

drivers/target/iscsi/iscsi_target_util.c

··· 379 379 if (!(hdr->flags & ISCSI_FLAG_CMD_FINAL)) 380 380 return 0; 381 381 382 - if (((cmd->first_burst_len + payload_length) != cmd->data_length) && 382 + if (((cmd->first_burst_len + payload_length) != cmd->se_cmd.data_length) && 383 383 ((cmd->first_burst_len + payload_length) != 384 384 conn->sess->sess_ops->FirstBurstLength)) { 385 385 pr_err("Unsolicited non-immediate data received %u" 386 386 " does not equal FirstBurstLength: %u, and does" 387 387 " not equal ExpXferLen %u.\n", 388 388 (cmd->first_burst_len + payload_length), 389 - conn->sess->sess_ops->FirstBurstLength, cmd->data_length); 389 + conn->sess->sess_ops->FirstBurstLength, cmd->se_cmd.data_length); 390 390 transport_send_check_condition_and_sense(se_cmd, 391 391 TCM_INCORRECT_AMOUNT_OF_DATA, 0); 392 392 return -1;