admin/libiscsi
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

TESTS: update writesame tests to new API

Browse Source 
Signed-off-by: Ronnie Sahlberg <sahlberg@localhost>
This commit is contained in:
Ronnie Sahlberg
2014-09-17 10:07:10 -07:00
committed by Ronnie Sahlberg
parent d3f98dfdd5
commit 8585e4509b
20 changed files with 179 additions and 653 deletions
Download Patch File Download Diff File Expand all files Collapse all files

564
test-tool/iscsi-support.c
View File

@@ -3618,549 +3618,81 @@ write16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, in
}
int
writesame10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
writesame10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq)
{
struct scsi_task *task;
uint64_t realdatalen;
struct iscsi_data d;
int ret;
logging(LOG_VERBOSE, "Send WRITESAME10 LBA:%d blocks:%d "
"wrprotect:%d anchor:%d unmap:%d group:%d",
lba, num, wrprotect,
anchor, unmap_flag, group);
if (!data_loss) {
printf("--dataloss flag is not set in. Skipping write\n");
return -1;
}
task = iscsi_writesame10_sync(iscsi, lun, lba,
data, datalen, num,
anchor, unmap_flag, wrprotect, group);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME10 command: %s",
iscsi_get_error(iscsi));
return -1;
}
if (task->status == SCSI_STATUS_CHECK_CONDITION
&& task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST
&& task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME10 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_CHECK_CONDITION
&& task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST
&& task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB) {
if (inq_bl->wsnz == 1 && num == 0) {
logging(LOG_NORMAL, "[SKIPPED] Target does not support WRITESAME10 with NUMBER OF LOGICAL BLOCKS == 0");
scsi_free_scsi_task(task);
return -3;
}
if (datalen == 0) {
realdatalen = num_blocks;
} else {
realdatalen = datalen;
}
if (inq_bl->max_ws_len > 0 && realdatalen > inq_bl->max_ws_len) {
logging(LOG_NORMAL, "[SKIPPED] Number of WRITESAME10 logical blocks to be written exceeds MAXIMUM WRITE SAME LENGTH");
scsi_free_scsi_task(task);
return -4;
}
}
if (task->status != SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] WRITESAME10 command: "
"failed with sense. %s", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] WRITESAME10 returned SUCCESS.");
return 0;
}
int
writesame10_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send WRITESAME10 (Expecting LBA_OUT_OF_RANGE) "
"LBA:%d blocks:%d "
logging(LOG_VERBOSE, "Send WRITESAME10 (Expecting %s) LBA:%d blocks:%d "
"wrprotect:%d anchor:%d unmap:%d group:%d",
lba, num, wrprotect,
anchor, unmap_flag, group);
scsi_status_str(status),
lba, num, wrprotect, anchor, unmap_flag, group);
if (!data_loss) {
printf("--dataloss flag is not set in. Skipping write\n");
return -1;
}
task = iscsi_writesame10_sync(iscsi, lun, lba,
data, datalen, num,
anchor, unmap_flag, wrprotect, group);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME10 command: %s",
iscsi_get_error(iscsi));
return -1;
}
if (task->status == SCSI_STATUS_CHECK_CONDITION
&& task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST
&& task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME10 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] WRITESAME10 successful but should "
"have failed with ILLEGAL_REQUEST/LBA_OUT_OF_RANGE");
scsi_free_scsi_task(task);
return -1;
}
if (task->status != SCSI_STATUS_CHECK_CONDITION
|| task->sense.key != SCSI_SENSE_ILLEGAL_REQUEST
|| task->sense.ascq != SCSI_SENSE_ASCQ_LBA_OUT_OF_RANGE) {
logging(LOG_NORMAL, "[FAILED] WRITESAME10 failed with wrong sense. "
"Should have failed with ILLEGAL_REQUEST/"
"LBA_OUT_OF_RANGE. Sense:%s\n", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
task = scsi_cdb_writesame10(wrprotect, anchor, unmap_flag, lba, group,
num, datalen);
assert(task != NULL);
if (data != NULL) {
task->expxferlen = datalen;
} else {
task->expxferlen = 0;
task->xfer_dir = SCSI_XFER_NONE;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] WRITESAME10 returned ILLEGAL_REQUEST/LBA_OUT_OF_RANGE.");
return 0;
d.data = data;
d.size = datalen;
task = iscsi_scsi_command_sync(iscsi, lun, task, &d);
ret = check_result("WRITESAME10", iscsi, task, status, key, ascq, num_ascq);
if (task) {
scsi_free_scsi_task(task);
}
return ret;
}
int
writesame10_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
writesame16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq)
{
struct scsi_task *task;
struct iscsi_data d;
int ret;
logging(LOG_VERBOSE, "Send WRITESAME10 (Expecting INVALID_FIELD_IN_CDB) "
"LBA:%d blocks:%d "
"wrprotect:%d anchor:%d unmap:%d group:%d",
lba, num, wrprotect,
anchor, unmap_flag, group);
logging(LOG_VERBOSE, "Send WRITESAME16 (Expecting %s) LBA:%" PRIu64
" blocks:%d wrprotect:%d anchor:%d unmap:%d group:%d",
scsi_status_str(status),
lba, num, wrprotect, anchor, unmap_flag, group);
if (!data_loss) {
printf("--dataloss flag is not set in. Skipping write\n");
return -1;
}
task = iscsi_writesame10_sync(iscsi, lun, lba,
data, datalen, num,
anchor, unmap_flag, wrprotect, group);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME10 command: %s",
iscsi_get_error(iscsi));
return -1;
task = scsi_cdb_writesame16(wrprotect, anchor, unmap_flag, lba, group,
num, datalen);
assert(task != NULL);
if (data != NULL) {
task->expxferlen = datalen;
} else {
task->expxferlen = 0;
task->xfer_dir = SCSI_XFER_NONE;
}
if (task->status == SCSI_STATUS_CHECK_CONDITION
&& task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST
&& task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME10 is not implemented on target");
d.data = data;
d.size = datalen;
task = iscsi_scsi_command_sync(iscsi, lun, task, &d);
ret = check_result("WRITESAME16", iscsi, task, status, key, ascq, num_ascq);
if (task) {
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] WRITESAME10 successful but should "
"have failed with ILLEGAL_REQUEST/INVALID_FIELD_IN_CDB");
scsi_free_scsi_task(task);
return -1;
}
if (task->status != SCSI_STATUS_CHECK_CONDITION
|| task->sense.key != SCSI_SENSE_ILLEGAL_REQUEST
|| task->sense.ascq != SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB) {
logging(LOG_NORMAL, "[FAILED] WRITESAME10 failed with wrong sense. "
"Should have failed with ILLEGAL_REQUEST/"
"INVALID_FIELD_IN_CDB. Sense:%s\n",
iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] WRITESAME10 returned ILLEGAL_REQUEST/INVALID_FIELD_IN_CDB.");
return 0;
}
int
writesame10_writeprotected(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send WRITESAME10 (Expecting WRITE_PROTECTED) "
"LBA:%d blocks:%d "
"wrprotect:%d anchor:%d unmap:%d group:%d",
lba, num, wrprotect,
anchor, unmap_flag, group);
if (!data_loss) {
printf("--dataloss flag is not set in. Skipping write\n");
return -1;
}
task = iscsi_writesame10_sync(iscsi, lun, lba,
data, datalen, num,
anchor, unmap_flag, wrprotect, group);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME10 command: %s",
iscsi_get_error(iscsi));
return -1;
}
if (task->status == SCSI_STATUS_CHECK_CONDITION
&& task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST
&& task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME10 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] WRITESAME10 successful but should "
"have failed with DATA_PROTECTION/WRITE_PROTECTED");
scsi_free_scsi_task(task);
return -1;
}
if (task->status != SCSI_STATUS_CHECK_CONDITION
|| task->sense.key != SCSI_SENSE_DATA_PROTECTION
|| task->sense.ascq != SCSI_SENSE_ASCQ_WRITE_PROTECTED) {
logging(LOG_NORMAL, "[FAILED] WRITESAME10 failed with wrong sense. "
"Should have failed with DATA_PROTECTION/"
"WRITE_PROTECTED. Sense:%s\n", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] WRITESAME10 returned DATA_PROTECTION/WRITE_PROTECTED.");
return 0;
}
int
writesame10_nomedium(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send WRITESAME10 (Expecting MEDIUM_NOT_PRESENT) "
"LBA:%d blocks:%d "
"wrprotect:%d anchor:%d unmap:%d group:%d",
lba, num, wrprotect,
anchor, unmap_flag, group);
if (!data_loss) {
printf("--dataloss flag is not set in. Skipping write\n");
return -1;
}
task = iscsi_writesame10_sync(iscsi, lun, lba,
data, datalen, num,
anchor, unmap_flag, wrprotect, group);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME10 command: %s",
iscsi_get_error(iscsi));
return -1;
}
if (task->status == SCSI_STATUS_CHECK_CONDITION
&& task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST
&& task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME10 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] WRITESAME10 command successful. But should have failed with NOT_READY/MEDIUM_NOT_PRESENT*");
scsi_free_scsi_task(task);
return -1;
}
if (task->status != SCSI_STATUS_CHECK_CONDITION
|| task->sense.key != SCSI_SENSE_NOT_READY
|| (task->sense.ascq != SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT
&& task->sense.ascq != SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_OPEN
&& task->sense.ascq != SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_CLOSED)) {
logging(LOG_NORMAL, "[FAILED] WRITESAME10 Should have failed "
"with NOT_READY/MEDIUM_NOT_PRESENT* But failed "
"with %s", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] WRITESAME10 returned MEDIUM_NOT_PRESENT.");
return 0;
}
int
writesame16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
{
struct scsi_task *task;
uint64_t realdatalen;
logging(LOG_VERBOSE, "Send WRITESAME16 LBA:%" PRIu64 " blocks:%d "
"wrprotect:%d anchor:%d unmap:%d group:%d",
lba, num, wrprotect,
anchor, unmap_flag, group);
if (!data_loss) {
printf("--dataloss flag is not set in. Skipping write\n");
return -1;
}
task = iscsi_writesame16_sync(iscsi, lun, lba,
data, datalen, num,
anchor, unmap_flag, wrprotect, group);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME16 command: %s",
iscsi_get_error(iscsi));
return -1;
}
if (task->status == SCSI_STATUS_CHECK_CONDITION
&& task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST
&& task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_CHECK_CONDITION
&& task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST
&& task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB) {
if (inq_bl->wsnz == 1 && num == 0) {
logging(LOG_NORMAL, "[SKIPPED] Target does not support WRITESAME16 with NUMBER OF LOGICAL BLOCKS == 0");
scsi_free_scsi_task(task);
return -3;
}
if (datalen == 0) {
realdatalen = num_blocks;
} else {
realdatalen = datalen;
}
if (inq_bl->max_ws_len > 0 && realdatalen > inq_bl->max_ws_len) {
logging(LOG_NORMAL, "[SKIPPED] Number of WRITESAME16 logical blocks to be written exceeds MAXIMUM WRITE SAME LENGTH");
scsi_free_scsi_task(task);
return -4;
}
}
if (task->status != SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] WRITESAME16 command: "
"failed with sense. %s", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] WRITESAME16 returned SUCCESS.");
return 0;
}
int
writesame16_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send WRITESAME16 (Expecting LBA_OUT_OF_RANGE) "
"LBA:%" PRIu64 " blocks:%d "
"wrprotect:%d anchor:%d unmap:%d group:%d",
lba, num, wrprotect,
anchor, unmap_flag, group);
if (!data_loss) {
printf("--dataloss flag is not set in. Skipping write\n");
return -1;
}
task = iscsi_writesame16_sync(iscsi, lun, lba,
data, datalen, num,
anchor, unmap_flag, wrprotect, group);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME16 command: %s",
iscsi_get_error(iscsi));
return -1;
}
if (task->status == SCSI_STATUS_CHECK_CONDITION
&& task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST
&& task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] WRITESAME16 successful but should "
"have failed with ILLEGAL_REQUEST/LBA_OUT_OF_RANGE");
scsi_free_scsi_task(task);
return -1;
}
if (task->status != SCSI_STATUS_CHECK_CONDITION
|| task->sense.key != SCSI_SENSE_ILLEGAL_REQUEST
|| task->sense.ascq != SCSI_SENSE_ASCQ_LBA_OUT_OF_RANGE) {
logging(LOG_NORMAL, "[FAILED] WRITESAME16 failed with wrong sense. "
"Should have failed with ILLEGAL_REQUEST/"
"LBA_OUT_OF_RANGE. Sense:%s\n", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] WRITESAME16 returned ILLEGAL_REQUEST/LBA_OUT_OF_RANGE.");
return 0;
}
int
writesame16_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send WRITESAME16 (Expecting INVALID_FIELD_IN_CDB) "
"LBA:%" PRIu64 " blocks:%d "
"wrprotect:%d anchor:%d unmap:%d group:%d",
lba, num, wrprotect,
anchor, unmap_flag, group);
if (!data_loss) {
printf("--dataloss flag is not set in. Skipping write\n");
return -1;
}
task = iscsi_writesame16_sync(iscsi, lun, lba,
data, datalen, num,
anchor, unmap_flag, wrprotect, group);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME16 command: %s",
iscsi_get_error(iscsi));
return -1;
}
if (task->status == SCSI_STATUS_CHECK_CONDITION
&& task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST
&& task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] WRITESAME16 successful but should "
"have failed with ILLEGAL_REQUEST/INVALID_FIELD_IN_CDB");
scsi_free_scsi_task(task);
return -1;
}
if (task->status != SCSI_STATUS_CHECK_CONDITION
|| task->sense.key != SCSI_SENSE_ILLEGAL_REQUEST
|| task->sense.ascq != SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB) {
logging(LOG_NORMAL, "[FAILED] WRITESAME16 failed with wrong sense. "
"Should have failed with ILLEGAL_REQUEST/"
"INVALID_FIELD_IN_CDB. Sense:%s\n",
iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] WRITESAME16 returned ILLEGAL_REQUEST/INVALID_FIELD_IN_CDB.");
return 0;
}
int
writesame16_writeprotected(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send WRITESAME16 (Expecting WRITE_PROTECTED) "
"LBA:%" PRIu64 " blocks:%d "
"wrprotect:%d anchor:%d unmap:%d group:%d",
lba, num, wrprotect,
anchor, unmap_flag, group);
if (!data_loss) {
printf("--dataloss flag is not set in. Skipping write\n");
return -1;
}
task = iscsi_writesame16_sync(iscsi, lun, lba,
data, datalen, num,
anchor, unmap_flag, wrprotect, group);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME16 command: %s",
iscsi_get_error(iscsi));
return -1;
}
if (task->status == SCSI_STATUS_CHECK_CONDITION
&& task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST
&& task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] WRITESAME16 successful but should "
"have failed with DATA_PROTECTION/WRITE_PROTECTED");
scsi_free_scsi_task(task);
return -1;
}
if (task->status != SCSI_STATUS_CHECK_CONDITION
|| task->sense.key != SCSI_SENSE_DATA_PROTECTION
|| task->sense.ascq != SCSI_SENSE_ASCQ_WRITE_PROTECTED) {
logging(LOG_NORMAL, "[FAILED] WRITESAME16 failed with wrong sense. "
"Should have failed with DATA_PROTECTION/"
"WRITE_PROTECTED. Sense:%s\n", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] WRITESAME16 returned DATA_PROTECTION/WRITE_PROTECTED.");
return 0;
}
int
writesame16_nomedium(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num, int anchor, int unmap_flag, int wrprotect, int group, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send WRITESAME16 (Expecting MEDIUM_NOT_PRESENT) "
"LBA:%" PRIu64 " blocks:%d "
"wrprotect:%d anchor:%d unmap:%d group:%d",
lba, num, wrprotect,
anchor, unmap_flag, group);
if (!data_loss) {
printf("--dataloss flag is not set in. Skipping write\n");
return -1;
}
task = iscsi_writesame16_sync(iscsi, lun, lba,
data, datalen, num,
anchor, unmap_flag, wrprotect, group);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send WRITESAME16 command: %s",
iscsi_get_error(iscsi));
return -1;
}
if (task->status == SCSI_STATUS_CHECK_CONDITION
&& task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST
&& task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] WRITESAME16 command successful. But should have failed with NOT_READY/MEDIUM_NOT_PRESENT*");
scsi_free_scsi_task(task);
return -1;
}
if (task->status != SCSI_STATUS_CHECK_CONDITION
|| task->sense.key != SCSI_SENSE_NOT_READY
|| (task->sense.ascq != SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT
&& task->sense.ascq != SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_OPEN
&& task->sense.ascq != SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_CLOSED)) {
logging(LOG_NORMAL, "[FAILED] WRITESAME16 Should have failed "
"with NOT_READY/MEDIUM_NOT_PRESENT* But failed "
"with %s", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] WRITESAME16 returned MEDIUM_NOT_PRESENT.");
return 0;
return ret;
}
int

12
test-tool/iscsi-support.h
View File

@@ -314,16 +314,8 @@ int verify16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datale
int write10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int wrprotect, int dpo, int fua, int fua_nv, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
int write12(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int wrprotect, int dpo, int fua, int fua_nv, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
int write16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int wrprotect, int dpo, int fua, int fua_nv, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
int writesame10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
int writesame10_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
int writesame10_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
int writesame10_writeprotected(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
int writesame10_nomedium(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
int writesame16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
int writesame16_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
int writesame16_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
int writesame16_writeprotected(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
int writesame16_nomedium(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data);
int writesame10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
int writesame16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int num_blocks, int anchor, int unmap, int wrprotect, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
int writeverify10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int wrprotect, int dpo, int bytchk, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
int writeverify12(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int wrprotect, int dpo, int bytchk, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
int writeverify16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int wrprotect, int dpo, int bytchk, int group, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);

10
test-tool/test_nomedia_sbc.c
View File

@@ -231,8 +231,9 @@ test_nomedia_sbc(void)
logging(LOG_VERBOSE, "[SKIPPED] Test not implemented yet");
logging(LOG_VERBOSE, "Test WRITESAME10 when medium is ejected.");
ret = writesame10_nomedium(iscsic, tgt_lun, 0, block_size,
1, 0, 0, 0, 0, buf);
ret = writesame10(iscsic, tgt_lun, 0, block_size,
1, 0, 0, 0, 0, buf,
EXPECT_NO_MEDIUM);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] target does not support "
"WRITESAME10");
@@ -241,8 +242,9 @@ test_nomedia_sbc(void)
}
logging(LOG_VERBOSE, "Test WRITESAME16 when medium is ejected.");
ret = writesame16_nomedium(iscsic, tgt_lun, 0, block_size,
1, 0, 0, 0, 0, buf);
ret = writesame16(iscsic, tgt_lun, 0, block_size,
1, 0, 0, 0, 0, buf,
EXPECT_NO_MEDIUM);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] target does not support "
"WRITESAME16");

22
test-tool/test_readonly_sbc.c
View File

@@ -59,34 +59,36 @@ test_readonly_sbc(void)
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test WRITE_SAME10 fails with WRITE_PROTECTED");
ret = writesame10_writeprotected(iscsic, tgt_lun, 0, block_size, 1,
0, 0, 0, 0, buf);
ret = writesame10(iscsic, tgt_lun, 0, block_size, 1,
0, 0, 0, 0, buf,
EXPECT_WRITE_PROTECTED);
if (ret == -2) {
logging(LOG_VERBOSE, "WRITE_SAME10 not supported on target. Skipped.");
}
CU_ASSERT_NOT_EQUAL(ret, -1);
logging(LOG_VERBOSE, "Test WRITE_SAME16 fails with WRITE_PROTECTED");
ret = writesame16_writeprotected(iscsic, tgt_lun, 0, block_size, 1,
0, 0, 0, 0, buf);
ret = writesame16(iscsic, tgt_lun, 0, block_size, 1,
0, 0, 0, 0, buf,
EXPECT_WRITE_PROTECTED);
if (ret == -2) {
logging(LOG_VERBOSE, "WRITE_SAME16 not supported on target. Skipped.");
}
CU_ASSERT_NOT_EQUAL(ret, -1);
logging(LOG_VERBOSE, "Test WRITE_SAME10 UNMAP fails with WRITE_PROTECTED");
ret = writesame10_writeprotected(iscsic, tgt_lun, 0,
block_size, 1,
0, 1, 0, 0, NULL);
ret = writesame10(iscsic, tgt_lun, 0,
block_size, 1, 0, 1, 0, 0, NULL,
EXPECT_WRITE_PROTECTED);
if (ret == -2) {
logging(LOG_VERBOSE, "WRITE_SAME10 not supported on target. Skipped.");
}
CU_ASSERT_NOT_EQUAL(ret, -1);
logging(LOG_VERBOSE, "Test WRITE_SAME16 UNMAP fails with WRITE_PROTECTED");
ret = writesame16_writeprotected(iscsic, tgt_lun, 0,
block_size, 1,
0, 1, 0, 0, NULL);
ret = writesame16(iscsic, tgt_lun, 0,
block_size, 1, 0, 1, 0, 0, NULL,
EXPECT_WRITE_PROTECTED);
if (ret == -2) {
logging(LOG_VERBOSE, "WRITE_SAME16 not supported on target. Skipped.");
}

22
test-tool/test_writesame10_0blocks.c
View File

@@ -41,8 +41,8 @@ test_writesame10_0blocks(void)
logging(LOG_VERBOSE, "Test WRITESAME10 0-blocks at LBA==0 (WSNZ=%d)",
inq_bl->wsnz);
ret = writesame10(iscsic, tgt_lun, 0,
block_size, 0,
0, 0, 0, 0, buf);
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
CU_PASS("[SKIPPED] Target does not support WRITESAME10. Skipping test");
return;
@@ -59,22 +59,22 @@ test_writesame10_0blocks(void)
}
logging(LOG_VERBOSE, "Test WRITESAME10 0-blocks one block past end-of-LUN");
ret = writesame10_lbaoutofrange(iscsic, tgt_lun, num_blocks + 1,
block_size, 0,
0, 0, 0, 0, buf);
ret = writesame10(iscsic, tgt_lun, num_blocks + 1,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test WRITESAME10 0-blocks at LBA==2^31");
ret = writesame10_lbaoutofrange(iscsic, tgt_lun, 0x80000000,
block_size, 0,
0, 0, 0, 0, buf);
ret = writesame10(iscsic, tgt_lun, 0x80000000,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test WRITESAME10 0-blocks at LBA==-1");
ret = writesame10_lbaoutofrange(iscsic, tgt_lun, -1,
block_size, 0,
0, 0, 0, 0, buf);
ret = writesame10(iscsic, tgt_lun, -1,
block_size, 0, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}

24
test-tool/test_writesame10_beyond_eol.c
View File

@@ -43,9 +43,9 @@ test_writesame10_beyond_eol(void)
logging(LOG_VERBOSE, "Test WRITESAME10 1-256 blocks one block beyond the end");
memset(buf, 0, block_size);
for (i = 1; i <= 256; i++) {
ret = writesame10_lbaoutofrange(iscsic, tgt_lun, num_blocks - i + 1,
block_size, i,
0, 0, 0, 0, buf);
ret = writesame10(iscsic, tgt_lun, num_blocks - i + 1,
block_size, i, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
if (ret == -2) {
CU_PASS("[SKIPPED] Target does not support WRITESAME10. Skipping test");
return;
@@ -56,27 +56,27 @@ test_writesame10_beyond_eol(void)
logging(LOG_VERBOSE, "Test WRITESAME10 1-256 blocks at LBA==2^31");
for (i = 1; i <= 256; i++) {
ret = writesame10_lbaoutofrange(iscsic, tgt_lun, 0x80000000,
block_size, i,
0, 0, 0, 0, buf);
ret = writesame10(iscsic, tgt_lun, 0x80000000,
block_size, i, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
logging(LOG_VERBOSE, "Test WRITESAME10 1-256 blocks at LBA==-1");
for (i = 1; i <= 256; i++) {
ret = writesame10_lbaoutofrange(iscsic, tgt_lun, -1,
block_size, i,
0, 0, 0, 0, buf);
ret = writesame10(iscsic, tgt_lun, -1,
block_size, i, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
logging(LOG_VERBOSE, "Test WRITESAME10 2-256 blocks all but one block beyond the end");
for (i = 2; i <= 256; i++) {
ret = writesame10_lbaoutofrange(iscsic, tgt_lun, num_blocks - 1,
block_size, i,
0, 0, 0, 0, buf);
ret = writesame10(iscsic, tgt_lun, num_blocks - 1,
block_size, i, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
}

9
test-tool/test_writesame10_simple.c
View File

@@ -1,4 +1,3 @@
/*
Copyright (C) 2013 Ronnie Sahlberg <ronniesahlberg@gmail.com>
@@ -42,8 +41,8 @@ test_writesame10_simple(void)
memset(buf, 0, block_size);
for (i = 1; i <= 256; i++) {
ret = writesame10(iscsic, tgt_lun, 0,
block_size, i,
0, 0, 0, 0, buf);
block_size, i, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
CU_PASS("[SKIPPED] Target does not support WRITESAME10. Skipping test");
return;
@@ -54,8 +53,8 @@ test_writesame10_simple(void)
logging(LOG_VERBOSE, "Test WRITESAME10 of 1-256 blocks at the end of the LUN");
for (i = 1; i <= 256; i++) {
ret = writesame10(iscsic, tgt_lun, num_blocks - i,
block_size, i,
0, 0, 0, 0, buf);
block_size, i, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}

34
test-tool/test_writesame10_unmap.c
View File

@@ -52,8 +52,8 @@ test_writesame10_unmap(void)
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
memset(buf, 0, block_size);
ret = writesame10(iscsic, tgt_lun, 0,
block_size, i,
0, 1, 0, 0, buf);
block_size, i, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
if (rc16->lbprz) {
@@ -90,8 +90,8 @@ test_writesame10_unmap(void)
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
memset(buf, 0, block_size);
ret = writesame10(iscsic, tgt_lun, num_blocks - i,
block_size, i,
0, 1, 0, 0, buf);
block_size, i, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
if (rc16->lbprz) {
@@ -116,9 +116,9 @@ test_writesame10_unmap(void)
logging(LOG_VERBOSE, "Verify that WRITESAME10 ANCHOR==1 + UNMAP==0 is "
"invalid");
ret = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, 1,
1, 0, 0, 0, buf);
ret = writesame10(iscsic, tgt_lun, 0,
block_size, 1, 1, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
@@ -127,14 +127,14 @@ test_writesame10_unmap(void)
logging(LOG_VERBOSE, "Test WRITESAME10 ANCHOR==1 + UNMAP==0");
memset(buf, 0, block_size);
ret = writesame10(iscsic, tgt_lun, 0,
block_size, 1,
1, 1, 0, 0, buf);
block_size, 1, 1, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
} else {
logging(LOG_VERBOSE, "Test WRITESAME10 ANCHOR==1 + UNMAP==0 no "
"ANC_SUP so expecting to fail");
ret = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, 1,
1, 1, 0, 0, buf);
ret = writesame10(iscsic, tgt_lun, 0,
block_size, 1, 1, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}
CU_ASSERT_EQUAL(ret, 0);
@@ -165,8 +165,8 @@ test_writesame10_unmap(void)
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
memset(buf, 0, block_size);
ret = writesame10(iscsic, tgt_lun, 0,
block_size, i,
0, 1, 0, 0, buf);
block_size, i, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
if (rc16->lbprz) {
@@ -193,9 +193,9 @@ test_writesame10_unmap(void)
"INVALID_FIELD_IN_CDB.");
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
ret = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, i,
0, 1, 0, 0, buf);
ret = writesame10(iscsic, tgt_lun, 0,
block_size, i, 0, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
}
}

4
test-tool/test_writesame10_unmap_unaligned.c
View File

@@ -42,8 +42,8 @@ test_writesame10_unmap_unaligned(void)
for (i = 1; i < lbppb; i++) {
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10 at LBA:%d", lbppb - i, i);
ret = writesame10(iscsic, tgt_lun, i,
block_size, lbppb - i,
0, 1, 0, 0, buf);
block_size, lbppb - i, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}
}

4
test-tool/test_writesame10_unmap_until_end.c
View File

@@ -54,8 +54,8 @@ test_writesame10_unmap_until_end(void)
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME10", i);
ret = writesame10(iscsic, tgt_lun, num_blocks - i,
block_size, i,
0, 1, 0, 0, buf);
block_size, i, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
if (rc16->lbprz) {

5
test-tool/test_writesame10_unmap_vpd.c
View File

@@ -43,9 +43,8 @@ test_writesame10_unmap_vpd(void)
logging(LOG_VERBOSE, "Unmap 1 block using WRITESAME10");
memset(buf, 0, block_size);
ret = writesame10(iscsic, tgt_lun, 0,
block_size, 1,
0, 1, 0, 0, buf);
block_size, 1, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret != 0) {
logging(LOG_VERBOSE, "WRITESAME10 UNMAP is not available. "
"Verify that VPD settings reflect this.");

6
test-tool/test_writesame10_wrprotect.c
View File

@@ -45,9 +45,9 @@ test_writesame10_wrprotect(void)
if (!inq->protect || (rc16 != NULL && !rc16->prot_en)) {
logging(LOG_VERBOSE, "Device does not support/use protection information. All commands should fail.");
for (i = 1; i < 8; i++) {
ret = writesame10_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, 1,
0, 0, i, 0, buf);
ret = writesame10(iscsic, tgt_lun, 0,
block_size, 1, 0, 0, i, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME10 is not implemented.");
CU_PASS("WRITESAME10 is not implemented.");

22
test-tool/test_writesame16_0blocks.c
View File

@@ -35,8 +35,8 @@ test_writesame16_0blocks(void)
logging(LOG_VERBOSE, "Test WRITESAME16 0-blocks at LBA==0 (WSNZ=%d)",
inq_bl->wsnz);
ret = writesame16(iscsic, tgt_lun, 0,
block_size, 0,
0, 0, 0, 0, NULL);
block_size, 0, 0, 0, 0, 0, NULL,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");
@@ -54,22 +54,22 @@ test_writesame16_0blocks(void)
}
logging(LOG_VERBOSE, "Test WRITESAME16 0-blocks one block past end-of-LUN");
ret = writesame16_lbaoutofrange(iscsic, tgt_lun, num_blocks + 1,
block_size, inq_bl->wsnz,
0, 0, 0, 0, NULL);
ret = writesame16(iscsic, tgt_lun, num_blocks + 1,
block_size, inq_bl->wsnz, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test WRITESAME16 0-blocks at LBA==2^63");
ret = writesame16_lbaoutofrange(iscsic, tgt_lun, 0x8000000000000000ULL,
block_size, inq_bl->wsnz,
0, 0, 0, 0, NULL);
ret = writesame16(iscsic, tgt_lun, 0x8000000000000000ULL,
block_size, inq_bl->wsnz, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test WRITESAME16 0-blocks at LBA==-1");
ret = writesame16_lbaoutofrange(iscsic, tgt_lun, -1,
block_size, inq_bl->wsnz,
0, 0, 0, 0, NULL);
ret = writesame16(iscsic, tgt_lun, -1,
block_size, inq_bl->wsnz, 0, 0, 0, 0, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}

24
test-tool/test_writesame16_beyond_eol.c
View File

@@ -38,9 +38,9 @@ test_writesame16_beyond_eol(void)
logging(LOG_VERBOSE, "Test WRITESAME16 1-256 blocks one block beyond the end");
memset(buf, 0, block_size);
for (i = 1; i <= 256; i++) {
ret = writesame16_lbaoutofrange(iscsic, tgt_lun, num_blocks - i + 1,
block_size, i,
0, 0, 0, 0, buf);
ret = writesame16(iscsic, tgt_lun, num_blocks - i + 1,
block_size, i, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");
@@ -52,27 +52,27 @@ test_writesame16_beyond_eol(void)
logging(LOG_VERBOSE, "Test WRITESAME16 1-256 blocks at LBA==2^63");
for (i = 1; i <= 256; i++) {
ret = writesame16_lbaoutofrange(iscsic, tgt_lun, 0x8000000000000000ULL,
block_size, i,
0, 0, 0, 0, buf);
ret = writesame16(iscsic, tgt_lun, 0x8000000000000000ULL,
block_size, i, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
logging(LOG_VERBOSE, "Test WRITESAME16 1-256 blocks at LBA==-1");
for (i = 1; i <= 256; i++) {
ret = writesame16_lbaoutofrange(iscsic, tgt_lun, -1,
block_size, i,
0, 0, 0, 0, buf);
ret = writesame16(iscsic, tgt_lun, -1,
block_size, i, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
logging(LOG_VERBOSE, "Test WRITESAME16 2-256 blocks all but one block beyond the end");
for (i = 2; i <= 256; i++) {
ret = writesame16_lbaoutofrange(iscsic, tgt_lun, num_blocks - 1,
block_size, i,
0, 0, 0, 0, buf);
ret = writesame16(iscsic, tgt_lun, num_blocks - 1,
block_size, i, 0, 0, 0, 0, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
}

8
test-tool/test_writesame16_simple.c
View File

@@ -41,8 +41,8 @@ test_writesame16_simple(void)
memset(buf, 0, block_size);
for (i = 1; i <= 256; i++) {
ret = writesame16(iscsic, tgt_lun, 0,
block_size, i,
0, 0, 0, 0, buf);
block_size, i, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");
@@ -54,8 +54,8 @@ test_writesame16_simple(void)
logging(LOG_VERBOSE, "Test WRITESAME16 of 1-256 blocks at the end of the LUN");
for (i = 1; i <= 256; i++) {
ret = writesame16(iscsic, tgt_lun, num_blocks - i,
block_size, i,
0, 0, 0, 0, buf);
block_size, i, 0, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}

44
test-tool/test_writesame16_unmap.c
View File

@@ -52,8 +52,8 @@ test_writesame16_unmap(void)
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
memset(buf, 0, block_size);
ret = writesame16(iscsic, tgt_lun, 0,
block_size, i,
0, 1, 0, 0, buf);
block_size, i, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");
@@ -91,8 +91,8 @@ test_writesame16_unmap(void)
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
memset(buf, 0, block_size);
ret = writesame16(iscsic, tgt_lun, num_blocks - i,
block_size, i,
0, 1, 0, 0, buf);
block_size, i, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
if (rc16->lbprz) {
@@ -113,9 +113,9 @@ test_writesame16_unmap(void)
}
logging(LOG_VERBOSE, "Verify that WRITESAME16 ANCHOR==1 + UNMAP==0 is invalid");
ret = writesame16_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, 1,
1, 0, 0, 0, buf);
ret = writesame16(iscsic, tgt_lun, 0,
block_size, 1, 1, 0, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
@@ -124,13 +124,13 @@ test_writesame16_unmap(void)
logging(LOG_VERBOSE, "Test WRITESAME16 ANCHOR==1 + UNMAP==0");
memset(buf, 0, block_size);
ret = writesame16(iscsic, tgt_lun, 0,
block_size, 1,
1, 1, 0, 0, buf);
block_size, 1, 1, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
} else {
logging(LOG_VERBOSE, "Test WRITESAME16 ANCHOR==1 + UNMAP==0 no ANC_SUP so expecting to fail");
ret = writesame16_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, 1,
1, 1, 0, 0, buf);
ret = writesame16(iscsic, tgt_lun, 0,
block_size, 1, 1, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
}
CU_ASSERT_EQUAL(ret, 0);
@@ -162,8 +162,8 @@ test_writesame16_unmap(void)
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
memset(buf, 0, block_size);
ret = writesame16(iscsic, tgt_lun, 0,
block_size, i,
0, 1, 0, 0, buf);
block_size, i, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
if (rc16->lbprz) {
@@ -188,9 +188,9 @@ test_writesame16_unmap(void)
"INVALID_FIELD_IN_CDB.");
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
ret = writesame16_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, i,
0, 1, 0, 0, buf);
ret = writesame16(iscsic, tgt_lun, 0,
block_size, i, 0, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
}
@@ -213,8 +213,8 @@ test_writesame16_unmap(void)
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
memset(buf, 0, block_size);
ret = writesame16(iscsic, tgt_lun, 0,
block_size, i,
0, 1, 0, 0, buf);
block_size, i, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
if (rc16->lbprz) {
@@ -239,9 +239,9 @@ test_writesame16_unmap(void)
"INVALID_FIELD_IN_CDB.");
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
ret = writesame16_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, i,
0, 1, 0, 0, buf);
ret = writesame16(iscsic, tgt_lun, 0,
block_size, i, 0, 1, 0, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
}

3
test-tool/test_writesame16_unmap_unaligned.c
View File

@@ -42,7 +42,8 @@ test_writesame16_unmap_unaligned(void)
for (i = 1; i < lbppb; i++) {
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16 at LBA:%d", lbppb - i, i);
ret = writesame16(iscsic, tgt_lun, i, 0, lbppb - i,
0, 1, 0, 0, NULL);
0, 1, 0, 0, NULL,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");

4
test-tool/test_writesame16_unmap_until_end.c
View File

@@ -52,8 +52,8 @@ test_writesame16_unmap_until_end(void)
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Unmap %d blocks using WRITESAME16", i);
ret = writesame16(iscsic, tgt_lun, num_blocks - i,
0, i,
0, 1, 0, 0, NULL);
0, i, 0, 1, 0, 0, NULL,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");

5
test-tool/test_writesame16_unmap_vpd.c
View File

@@ -44,9 +44,8 @@ test_writesame16_unmap_vpd(void)
logging(LOG_VERBOSE, "Unmap 1 block using WRITESAME16");
memset(buf, 0, block_size);
ret = writesame16(iscsic, tgt_lun, 0,
block_size, 1,
0, 1, 0, 0, buf);
block_size, 1, 0, 1, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret != 0) {
logging(LOG_VERBOSE, "WRITESAME16 UNMAP is not available. "
"Verify that VPD settings reflect this.");

6
test-tool/test_writesame16_wrprotect.c
View File

@@ -45,9 +45,9 @@ test_writesame16_wrprotect(void)
if (!inq->protect || (rc16 != NULL && !rc16->prot_en)) {
logging(LOG_VERBOSE, "Device does not support/use protection information. All commands should fail.");
for (i = 1; i < 8; i++) {
ret = writesame16_invalidfieldincdb(iscsic, tgt_lun, 0,
block_size, 1,
0, 0, i, 0, buf);
ret = writesame16(iscsic, tgt_lun, 0,
block_size, 1, 0, 0, i, 0, buf,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] WRITESAME16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support WRITESAME16. Skipping test");