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

TEST: update all the verify tests to a new API

Browse Source 
Signed-off-by: Ronnie Sahlberg <sahlberg@localhost>
This commit is contained in:
Ronnie Sahlberg
2014-09-16 14:22:58 -07:00
committed by Ronnie Sahlberg
parent 138939cb0e
commit 8aefc7d579
24 changed files with 211 additions and 671 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -48,6 +48,21 @@ const char *initiatorname2 =
const char *tgt_url;
int no_medium_ascqs[3] = {
SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT,
SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_OPEN,
SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_CLOSED
};
int lba_oob_ascqs[1] = {
SCSI_SENSE_ASCQ_LBA_OUT_OF_RANGE
};
int invalid_cdb_ascqs[1] = {
SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB
};
int write_protect_ascqs[1] = {
SCSI_SENSE_ASCQ_WRITE_PROTECTED
};
struct scsi_inquiry_standard *inq;
struct scsi_inquiry_logical_block_provisioning *inq_lbp;
struct scsi_inquiry_block_device_characteristics *inq_bdc;
@@ -65,21 +80,6 @@ int readonly;
int sbc3_support;
int maximum_transfer_length;
int no_medium_ascqs[3] = {
SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT,
SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_OPEN,
SCSI_SENSE_ASCQ_MEDIUM_NOT_PRESENT_TRAY_CLOSED
};
int lba_oob_ascqs[1] = {
SCSI_SENSE_ASCQ_LBA_OUT_OF_RANGE
};
int invalid_cdb_ascqs[1] = {
SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB
};
int write_protect_ascqs[1] = {
SCSI_SENSE_ASCQ_WRITE_PROTECTED
};
int (*real_iscsi_queue_pdu)(struct iscsi_context *iscsi, struct iscsi_pdu *pdu);
static const char *scsi_status_str(int status)
@@ -3440,573 +3440,82 @@ unmap_nomedium(struct iscsi_context *iscsi, int lun, int anchor, struct unmap_li
}
int
verify10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
verify10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, 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 VERIFY10 LBA:%d blocks:%d vprotect:%d dpo:%d bytchk:%d", lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify10_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY10 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] VERIFY10 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status != SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY10 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] VERIFY10 returned SUCCESS.");
return 0;
}
int
verify10_nomedium(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send VERIFY10 (Expecting MEDIUM_NOT_PRESENT) "
"LBA:%d blocks:%d vprotect:%d dpo:%d bytchk:%d",
logging(LOG_VERBOSE, "Send VERIFY10 (Expecting %s) LBA:%d "
"blocks:%d vprotect:%d dpo:%d bytchk:%d",
scsi_status_str(status),
lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify10_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY10 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] VERIFY10 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY10 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] VERIFY10 after eject failed with the wrong sense code. Should fail with NOT_READY/MEDIUM_NOT_PRESENT* but failed with %s", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
task = scsi_cdb_verify10(lba, datalen, vprotect, dpo, bytchk, blocksize);
assert(task != NULL);
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] VERIFY10 returned MEDIUM_NOT_PRESENT.");
return 0;
d.data = data;
d.size = datalen;
task = iscsi_scsi_command_sync(iscsi, lun, task, &d);
ret = check_result("VERIFY10", iscsi, task, status, key, ascq, num_ascq);
if (task) {
scsi_free_scsi_task(task);
}
return ret;
}
int
verify10_miscompare(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
verify12(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, 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 VERIFY10 (Expecting MISCOMPARE) "
"LBA:%d blocks:%d vprotect:%d dpo:%d bytchk:%d",
logging(LOG_VERBOSE, "Send VERIFY12 (Expecting %s) LBA:%d "
"blocks:%d vprotect:%d dpo:%d bytchk:%d",
scsi_status_str(status),
lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify10_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY10 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] VERIFY10 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY10 successful but should have failed with MISCOMPARE");
scsi_free_scsi_task(task);
return -1;
}
if (task->sense.key != SCSI_SENSE_MISCOMPARE) {
logging(LOG_NORMAL, "[FAILED] VERIFY10 command returned wrong sense key. MISCOMPARE MISCOMPARE 0x%x expected but got key 0x%x. Sense:%s", SCSI_SENSE_MISCOMPARE, task->sense.key, iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
task = scsi_cdb_verify12(lba, datalen, vprotect, dpo, bytchk, blocksize);
assert(task != NULL);
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] VERIFY10 returned MISCOMPARE.");
return 0;
d.data = data;
d.size = datalen;
task = iscsi_scsi_command_sync(iscsi, lun, task, &d);
ret = check_result("VERIFY12", iscsi, task, status, key, ascq, num_ascq);
if (task) {
scsi_free_scsi_task(task);
}
return ret;
}
int
verify10_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
verify16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, 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 VERIFY10 (Expecting LBA_OUT_OF_RANGE) "
"LBA:%d blocks:%d vprotect:%d dpo:%d bytchk:%d",
logging(LOG_VERBOSE, "Send VERIFY16 (Expecting %s) LBA:%" PRIu64
" blocks:%d vprotect:%d dpo:%d bytchk:%d",
scsi_status_str(status),
lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify10_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY10 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] VERIFY10 is not implemented on target");
task = scsi_cdb_verify16(lba, datalen, vprotect, dpo, bytchk, blocksize);
assert(task != NULL);
d.data = data;
d.size = datalen;
task = iscsi_scsi_command_sync(iscsi, lun, task, &d);
ret = check_result("VERIFY16", 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] VERIFY10 successful but should have failed with 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] VERIFY10 should have failed with ILLEGAL_REQUEST/LBA_OUT_OF_RANGE. Sense:%s", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] VERIFY10 returned LBA_OUT_OF_RANGE.");
return 0;
}
int
verify10_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send VERIFY10 (Expecting INVALID_FIELD_IN_CDB) "
"LBA:%d blocks:%d vprotect:%d dpo:%d bytchk:%d",
lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify10_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY10 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] VERIFY10 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY10 successful but should have failed with ILLEGAL_REQUEST");
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] VERIFY10 should have failed with ILLEGAL_REQUEST/INVALID_FIELD_IN_CDB. Sense:%s", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] VERIFY10 returned INVALID_FIELD_IN_CDB.");
return 0;
}
int
verify12(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send VERIFY12 LBA:%d blocks:%d vprotect:%d dpo:%d bytchk:%d", lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify12_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY12 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] VERIFY12 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status != SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY12 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] VERIFY12 returned SUCCESS.");
return 0;
}
int
verify12_nomedium(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send VERIFY12 (Expecting MEDIUM_NOT_PRESENT) "
"LBA:%d blocks:%d vprotect:%d dpo:%d bytchk:%d",
lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify12_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY12 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] VERIFY12 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY12 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] VERIFY12 after eject failed with the wrong sense code. Should fail 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] VERIFY12 returned MEDIUM_NOT_PRESENT.");
return 0;
}
int
verify12_miscompare(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send VERIFY12 (expecting MISCOMPARE) "
"LBA:%d blocks:%d vprotect:%d dpo:%d bytchk:%d",
lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify12_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY12 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] VERIFY12 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY12 successful but should have failed with MISCOMPARE");
scsi_free_scsi_task(task);
return -1;
}
if (task->sense.key != SCSI_SENSE_MISCOMPARE) {
logging(LOG_NORMAL, "[FAILED] VERIFY12 command returned wrong sense key. MISCOMPARE MISCOMPARE 0x%x expected but got key 0x%x. Sense:%s", SCSI_SENSE_MISCOMPARE, task->sense.key, iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] VERIFY12 returned MISCOMPARE.");
return 0;
}
int
verify12_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send VERIFY12 (Expecting LBA_OUT_OF_RANGE) "
"LBA:%d blocks:%d vprotect:%d dpo:%d bytchk:%d",
lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify12_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY12 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] VERIFY12 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY12 successful but should have failed with 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] VERIFY12 should have failed with ILLEGAL_REQUEST/LBA_OUT_OF_RANGE. Sense:%s", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] VERIFY12 returned LBA_OUT_OF_RANGE.");
return 0;
}
int
verify12_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send VERIFY12 (Expecting INVALID_FIELD_IN_CDB) "
"LBA:%d blocks:%d vprotect:%d dpo:%d bytchk:%d",
lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify12_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY12 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] VERIFY12 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY12 successful but should have failed with ILLEGAL_REQUEST");
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] VERIFY12 should have failed with ILLEGAL_REQUEST/INVALID_FIELD_IN_CDB. Sense:%s", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] VERIFY12 returned INVALID_FIELD_IN_CDB.");
return 0;
}
int
verify16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send VERIFY16 LBA:%" PRIu64 " blocks:%d vprotect:%d dpo:%d bytchk:%d", lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify16_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY16 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] VERIFY16 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status != SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY16 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] VERIFY16 returned SUCCESS.");
return 0;
}
int
verify16_nomedium(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send VERIFY16 (Expecting MEDIUM_NOT_PRESENT) "
"LBA:%" PRIu64 " blocks:%d vprotect:%d dpo:%d bytchk:%d",
lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify16_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY16 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] VERIFY16 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY16 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] VERIFY16 after eject failed with the wrong sense code. Should fail 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] VERIFY16 returned NOT_MEDIUM_NOT_PRESENT.");
return 0;
}
int
verify16_miscompare(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send VERIFY16 (Expecting MISCOMPARE) "
"LBA:%" PRIu64 " blocks:%d vprotect:%d dpo:%d bytchk:%d",
lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify16_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY16 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] VERIFY16 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY16 successful but should have failed with MISCOMPARE");
scsi_free_scsi_task(task);
return -1;
}
if (task->sense.key != SCSI_SENSE_MISCOMPARE) {
logging(LOG_NORMAL, "[FAILED] VERIFY16 command returned wrong sense key. MISCOMPARE MISCOMPARE 0x%x expected but got key 0x%x. Sense:%s", SCSI_SENSE_MISCOMPARE, task->sense.key, iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] VERIFY16 returned MISCOMPARE.");
return 0;
}
int
verify16_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send VERIFY16 (Expecting LBA_OUT_OF_RANGE) "
"LBA:%" PRIu64 " blocks:%d vprotect:%d dpo:%d bytchk:%d",
lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify16_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY16 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] VERIFY16 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY16 successful but should have failed with 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] VERIFY16 should have failed with ILLEGAL_REQUEST/LBA_OUT_OF_RANGE. Sense:%s", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] VERIFY16 returned LBA_OUT_OF_RANGE.");
return 0;
}
int
verify16_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send VERIFY16 (Expecting INVALID_FIELD_IN_CDB) "
"LBA:%" PRIu64 " blocks:%d vprotect:%d dpo:%d bytchk:%d",
lba, datalen / blocksize, vprotect, dpo, bytchk);
task = iscsi_verify16_sync(iscsi, lun, data, datalen, lba, vprotect, dpo, bytchk, blocksize);
if (task == NULL) {
logging(LOG_NORMAL, "[FAILED] Failed to send VERIFY16 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] VERIFY16 is not implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] VERIFY16 successful but should have failed with 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_INVALID_FIELD_IN_CDB) {
logging(LOG_NORMAL, "[FAILED] VERIFY16 should have failed with ILLEGAL_REQUEST/INVALID_FIELD_IN_CDB. Sense:%s", iscsi_get_error(iscsi));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] VERIFY16 returned INVALID_FIELD_IN_CDB.");
return 0;
return ret;
}
int

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

@@ -308,21 +308,9 @@ int mode_sense(struct iscsi_context *iscsi, int lun);
int unmap(struct iscsi_context *iscsi, int lun, int anchor, struct unmap_list *list, int list_len);
int unmap_writeprotected(struct iscsi_context *iscsi, int lun, int anchor, struct unmap_list *list, int list_len);
int unmap_nomedium(struct iscsi_context *iscsi, int lun, int anchor, struct unmap_list *list, int list_len);
int verify10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify10_nomedium(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify10_miscompare(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify10_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify10_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify12(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify12_nomedium(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify12_miscompare(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify12_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify12_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify16_nomedium(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify16_miscompare(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify16_lbaoutofrange(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify16_invalidfieldincdb(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data);
int verify10(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
int verify12(struct iscsi_context *iscsi, int lun, uint32_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
int verify16(struct iscsi_context *iscsi, int lun, uint64_t lba, uint32_t datalen, int blocksize, int vprotect, int dpo, int bytchk, unsigned char *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
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 write10_invalidfieldincdb(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 write10_lbaoutofrange(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);

15
test-tool/test_nomedia_sbc.c
View File

@@ -128,8 +128,9 @@ test_nomedia_sbc(void)
}
logging(LOG_VERBOSE, "Test VERIFY10 when medium is ejected.");
ret = verify10_nomedium(iscsic, tgt_lun, 0, block_size, block_size,
0, 0, 1, buf);
ret = verify10(iscsic, tgt_lun, 0, block_size, block_size,
0, 0, 1, buf,
EXPECT_NO_MEDIUM);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] target does not support "
"VERIFY10");
@@ -138,8 +139,9 @@ test_nomedia_sbc(void)
}
logging(LOG_VERBOSE, "Test VERIFY12 when medium is ejected.");
ret = verify12_nomedium(iscsic, tgt_lun, 0, block_size, block_size,
0, 0, 1, buf);
ret = verify12(iscsic, tgt_lun, 0, block_size, block_size,
0, 0, 1, buf,
EXPECT_NO_MEDIUM);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] target does not support "
"VERIFY102");
@@ -148,8 +150,9 @@ test_nomedia_sbc(void)
}
logging(LOG_VERBOSE, "Test VERIFY16 when medium is ejected.");
ret = verify16_nomedium(iscsic, tgt_lun, 0, block_size, block_size,
0, 0, 1, buf);
ret = verify16(iscsic, tgt_lun, 0, block_size, block_size,
0, 0, 1, buf,
EXPECT_NO_MEDIUM);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] target does not support "
"VERIFY16");

18
test-tool/test_verify10_0blocks.c
View File

@@ -31,7 +31,8 @@ test_verify10_0blocks(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test VERIFY10 0-blocks at LBA==0");
ret = verify10(iscsic, tgt_lun, 0, 0, block_size,
0, 0, 1, NULL);
0, 0, 1, NULL,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY10 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY10. Skipping test");
@@ -40,19 +41,22 @@ test_verify10_0blocks(void)
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test VERIFY10 0-blocks one block past end-of-LUN");
ret = verify10_lbaoutofrange(iscsic, tgt_lun, num_blocks + 1, 0,
block_size, 0, 0, 1, NULL);
ret = verify10(iscsic, tgt_lun, num_blocks + 1, 0,
block_size, 0, 0, 1, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test VERIFY10 0-blocks at LBA==2^31");
ret = verify10_lbaoutofrange(iscsic, tgt_lun, 0x80000000, 0,
block_size, 0, 0, 1, NULL);
ret = verify10(iscsic, tgt_lun, 0x80000000, 0,
block_size, 0, 0, 1, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test VERIFY10 0-blocks at LBA==-1");
ret = verify10_lbaoutofrange(iscsic, tgt_lun, -1, 0, block_size,
0, 0, 1, NULL);
ret = verify10(iscsic, tgt_lun, -1, 0, block_size,
0, 0, 1, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}

23
test-tool/test_verify10_beyond_eol.c
View File

@@ -42,9 +42,9 @@ test_verify10_beyond_eol(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = verify10_lbaoutofrange(iscsic, tgt_lun, num_blocks + 1 - i,
i * block_size, block_size,
0, 0, 1, buf);
ret = verify10(iscsic, tgt_lun, num_blocks + 1 - i,
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_LBA_OOB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY10 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY10. Skipping test");
@@ -59,9 +59,9 @@ test_verify10_beyond_eol(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = verify10_lbaoutofrange(iscsic, tgt_lun, 0x80000000,
i * block_size, block_size,
0, 0, 1, buf);
ret = verify10(iscsic, tgt_lun, 0x80000000,
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
@@ -71,8 +71,9 @@ test_verify10_beyond_eol(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = verify10_lbaoutofrange(iscsic, tgt_lun, -1, i * block_size,
block_size, 0, 0, 1, buf);
ret = verify10(iscsic, tgt_lun, -1, i * block_size,
block_size, 0, 0, 1, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
@@ -82,9 +83,9 @@ test_verify10_beyond_eol(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = verify10_lbaoutofrange(iscsic, tgt_lun, num_blocks - 1,
i * block_size, block_size,
0, 0, 1, buf);
ret = verify10(iscsic, tgt_lun, num_blocks - 1,
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
}

6
test-tool/test_verify10_flags.c
View File

@@ -41,7 +41,8 @@ test_verify10_flags(void)
logging(LOG_VERBOSE, "Test VERIFY10 with DPO==1");
ret = verify10(iscsic, tgt_lun, 0, block_size,
block_size, 0, 1, 0, buf);
block_size, 0, 1, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY10 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY10. Skipping test");
@@ -53,7 +54,8 @@ test_verify10_flags(void)
logging(LOG_VERBOSE, "Test VERIFY10 with BYTCHK==1");
ret = verify10(iscsic, tgt_lun, 0, block_size,
block_size, 0, 0, 1, buf);
block_size, 0, 0, 1, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
free(buf);
}

10
test-tool/test_verify10_mismatch.c
View File

@@ -48,8 +48,9 @@ test_verify10_mismatch(void)
buf[offset] ^= 'X';
logging(LOG_VERBOSE, "Flip some bits in the data");
ret = verify10_miscompare(iscsic, tgt_lun, 0, i * block_size,
block_size, 0, 0, 1, buf);
ret = verify10(iscsic, tgt_lun, 0, i * block_size,
block_size, 0, 0, 1, buf,
EXPECT_MISCOMPARE);
if (ret == -2) {
CU_PASS("[SKIPPED] Target does not support VERIFY10. Skipping test");
return;
@@ -72,8 +73,9 @@ test_verify10_mismatch(void)
buf[offset] ^= 'X';
logging(LOG_VERBOSE, "Flip some bits in the data");
ret = verify10_miscompare(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size, 0, 0, 1, buf);
ret = verify10(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_MISCOMPARE);
CU_ASSERT_EQUAL(ret, 0);
}
}

6
test-tool/test_verify10_mismatch_no_cmp.c
View File

@@ -49,7 +49,8 @@ test_verify10_mismatch_no_cmp(void)
logging(LOG_VERBOSE, "Flip some bits in the data");
ret = verify10(iscsic, tgt_lun, 0, i * block_size,
block_size, 0, 0, 0, buf);
block_size, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY10 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY10. Skipping test");
@@ -74,7 +75,8 @@ test_verify10_mismatch_no_cmp(void)
logging(LOG_VERBOSE, "Flip some bits in the data");
ret = verify10(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size, 0, 0, 0, buf);
i * block_size, block_size, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}
}

6
test-tool/test_verify10_simple.c
View File

@@ -43,7 +43,8 @@ test_verify10_simple(void)
CU_ASSERT_EQUAL(ret, 0);
ret = verify10(iscsic, tgt_lun, 0, i * block_size,
block_size, 0, 0, 1, buf);
block_size, 0, 0, 1, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY10 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY10. Skipping test");
@@ -62,7 +63,8 @@ test_verify10_simple(void)
CU_ASSERT_EQUAL(ret, 0);
ret = verify10(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size, 0, 0, 1, buf);
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}
}

6
test-tool/test_verify10_vrprotect.c
View File

@@ -32,7 +32,6 @@ test_verify10_vrprotect(void)
int i, ret;
unsigned char *buf = alloca(block_size);
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test VERIFY10 with non-zero VRPROTECT");
@@ -45,8 +44,9 @@ test_verify10_vrprotect(void)
block_size, 0, 0, 0, 0, 0, buf);
CU_ASSERT_EQUAL(ret, 0);
ret = verify10_invalidfieldincdb(iscsic, tgt_lun, 0, block_size,
block_size, i, 0, 1, buf);
ret = verify10(iscsic, tgt_lun, 0, block_size,
block_size, i, 0, 1, buf,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY10 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY10. Skipping test");

18
test-tool/test_verify12_0blocks.c
View File

@@ -31,7 +31,8 @@ test_verify12_0blocks(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test VERIFY12 0-blocks at LBA==0");
ret = verify12(iscsic, tgt_lun, 0, 0, block_size,
0, 0, 1, NULL);
0, 0, 1, NULL,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY12 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY12. Skipping test");
@@ -40,19 +41,22 @@ test_verify12_0blocks(void)
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test VERIFY12 0-blocks one block past end-of-LUN");
ret = verify12_lbaoutofrange(iscsic, tgt_lun, num_blocks + 1, 0,
block_size, 0, 0, 1, NULL);
ret = verify12(iscsic, tgt_lun, num_blocks + 1, 0,
block_size, 0, 0, 1, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test VERIFY12 0-blocks at LBA==2^31");
ret = verify12_lbaoutofrange(iscsic, tgt_lun, 0x80000000, 0,
block_size, 0, 0, 1, NULL);
ret = verify12(iscsic, tgt_lun, 0x80000000, 0,
block_size, 0, 0, 1, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test VERIFY12 0-blocks at LBA==-1");
ret = verify12_lbaoutofrange(iscsic, tgt_lun, -1, 0, block_size,
0, 0, 1, NULL);
ret = verify12(iscsic, tgt_lun, -1, 0, block_size,
0, 0, 1, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}

23
test-tool/test_verify12_beyond_eol.c
View File

@@ -42,9 +42,9 @@ test_verify12_beyond_eol(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = verify12_lbaoutofrange(iscsic, tgt_lun, num_blocks + 1 - i,
i * block_size, block_size,
0, 0, 1, buf);
ret = verify12(iscsic, tgt_lun, num_blocks + 1 - i,
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_LBA_OOB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY12 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY12. Skipping test");
@@ -59,9 +59,9 @@ test_verify12_beyond_eol(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = verify12_lbaoutofrange(iscsic, tgt_lun, 0x80000000,
i * block_size, block_size,
0, 0, 1, buf);
ret = verify12(iscsic, tgt_lun, 0x80000000,
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
@@ -71,8 +71,9 @@ test_verify12_beyond_eol(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = verify12_lbaoutofrange(iscsic, tgt_lun, -1, i * block_size,
block_size, 0, 0, 1, buf);
ret = verify12(iscsic, tgt_lun, -1, i * block_size,
block_size, 0, 0, 1, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
@@ -82,9 +83,9 @@ test_verify12_beyond_eol(void)
if (maximum_transfer_length && maximum_transfer_length < i) {
break;
}
ret = verify12_lbaoutofrange(iscsic, tgt_lun, num_blocks - 1,
i * block_size, block_size,
0, 0, 1, buf);
ret = verify12(iscsic, tgt_lun, num_blocks - 1,
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
}

6
test-tool/test_verify12_flags.c
View File

@@ -42,7 +42,8 @@ test_verify12_flags(void)
logging(LOG_VERBOSE, "Test VERIFY12 with DPO==1");
ret = verify12(iscsic, tgt_lun, 0, block_size,
block_size, 0, 1, 0, buf);
block_size, 0, 1, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY12 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY12. Skipping test");
@@ -53,6 +54,7 @@ test_verify12_flags(void)
logging(LOG_VERBOSE, "Test VERIFY12 with BYTCHK==1");
ret = verify12(iscsic, tgt_lun, 0, block_size,
block_size, 0, 0, 1, buf);
block_size, 0, 0, 1, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}

10
test-tool/test_verify12_mismatch.c
View File

@@ -47,8 +47,9 @@ test_verify12_mismatch(void)
buf[offset] ^= 'X';
logging(LOG_VERBOSE, "Flip some bits in the data");
ret = verify12_miscompare(iscsic, tgt_lun, 0, i * block_size,
block_size, 0, 0, 1, buf);
ret = verify12(iscsic, tgt_lun, 0, i * block_size,
block_size, 0, 0, 1, buf,
EXPECT_MISCOMPARE);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY12 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY12. Skipping test");
@@ -72,8 +73,9 @@ test_verify12_mismatch(void)
buf[offset] ^= 'X';
logging(LOG_VERBOSE, "Flip some bits in the data");
ret = verify12_miscompare(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size, 0, 0, 1, buf);
ret = verify12(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_MISCOMPARE);
CU_ASSERT_EQUAL(ret, 0);
}
}

6
test-tool/test_verify12_mismatch_no_cmp.c
View File

@@ -48,7 +48,8 @@ test_verify12_mismatch_no_cmp(void)
logging(LOG_VERBOSE, "Flip some bits in the data");
ret = verify12(iscsic, tgt_lun, 0, i * block_size,
block_size, 0, 0, 0, buf);
block_size, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY12 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY12. Skipping test");
@@ -73,7 +74,8 @@ test_verify12_mismatch_no_cmp(void)
logging(LOG_VERBOSE, "Flip some bits in the data");
ret = verify12(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size, 0, 0, 0, buf);
i * block_size, block_size, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}
}

6
test-tool/test_verify12_simple.c
View File

@@ -43,7 +43,8 @@ test_verify12_simple(void)
CU_ASSERT_EQUAL(ret, 0);
ret = verify12(iscsic, tgt_lun, 0, i * block_size,
block_size, 0, 0, 1, buf);
block_size, 0, 0, 1, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY12 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY12. Skipping test");
@@ -62,7 +63,8 @@ test_verify12_simple(void)
CU_ASSERT_EQUAL(ret, 0);
ret = verify12(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size, 0, 0, 1, buf);
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}
}

5
test-tool/test_verify12_vrprotect.c
View File

@@ -44,8 +44,9 @@ test_verify12_vrprotect(void)
ret = read10(iscsic, tgt_lun, 0, block_size,
block_size, 0, 0, 0, 0, 0, buf);
ret = verify12_invalidfieldincdb(iscsic, tgt_lun, 0, block_size,
block_size, i, 0, 1, buf);
ret = verify12(iscsic, tgt_lun, 0, block_size,
block_size, i, 0, 1, buf,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY12 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY12. Skipping test");

18
test-tool/test_verify16_0blocks.c
View File

@@ -31,7 +31,8 @@ test_verify16_0blocks(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test VERIFY16 0-blocks at LBA==0");
ret = verify16(iscsic, tgt_lun, 0, 0, block_size,
0, 0, 1, NULL);
0, 0, 1, NULL,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY16. Skipping test");
@@ -40,19 +41,22 @@ test_verify16_0blocks(void)
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test VERIFY16 0-blocks one block past end-of-LUN");
ret = verify16_lbaoutofrange(iscsic, tgt_lun, num_blocks + 1, 0,
block_size, 0, 0, 1, NULL);
ret = verify16(iscsic, tgt_lun, num_blocks + 1, 0,
block_size, 0, 0, 1, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test VERIFY16 0-blocks at LBA==2^63");
ret = verify16_lbaoutofrange(iscsic, tgt_lun, 0x8000000000000000ULL, 0,
block_size, 0, 0, 1, NULL);
ret = verify16(iscsic, tgt_lun, 0x8000000000000000ULL, 0,
block_size, 0, 0, 1, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Test VERIFY16 0-blocks at LBA==-1");
ret = verify16_lbaoutofrange(iscsic, tgt_lun, -1, 0, block_size,
0, 0, 1, NULL);
ret = verify16(iscsic, tgt_lun, -1, 0, block_size,
0, 0, 1, NULL,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}

24
test-tool/test_verify16_beyond_eol.c
View File

@@ -39,9 +39,9 @@ test_verify16_beyond_eol(void)
break;
}
ret = verify16_lbaoutofrange(iscsic, tgt_lun, num_blocks + 1 - i,
i * block_size, block_size,
0, 0, 1, buf);
ret = verify16(iscsic, tgt_lun, num_blocks + 1 - i,
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_LBA_OOB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY16. Skipping test");
@@ -57,9 +57,9 @@ test_verify16_beyond_eol(void)
break;
}
ret = verify16_lbaoutofrange(iscsic, tgt_lun, 0x8000000000000000ULL,
i * block_size, block_size,
0, 0, 1, buf);
ret = verify16(iscsic, tgt_lun, 0x8000000000000000ULL,
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
@@ -70,8 +70,9 @@ test_verify16_beyond_eol(void)
break;
}
ret = verify16_lbaoutofrange(iscsic, tgt_lun, -1, i * block_size,
block_size, 0, 0, 1, buf);
ret = verify16(iscsic, tgt_lun, -1, i * block_size,
block_size, 0, 0, 1, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
@@ -82,9 +83,10 @@ test_verify16_beyond_eol(void)
break;
}
ret = verify16_lbaoutofrange(iscsic, tgt_lun, num_blocks - 1,
i * block_size, block_size,
0, 0, 1, buf);
ret = verify16(iscsic, tgt_lun, num_blocks - 1,
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_LBA_OOB);
CU_ASSERT_EQUAL(ret, 0);
}
}

7
test-tool/test_verify16_flags.c
View File

@@ -1,4 +1,3 @@
/*
Copyright (C) 2013 Ronnie Sahlberg <ronniesahlberg@gmail.com>
@@ -42,7 +41,8 @@ test_verify16_flags(void)
logging(LOG_VERBOSE, "Test VERIFY16 with DPO==1");
ret = verify16(iscsic, tgt_lun, 0, block_size,
block_size, 0, 1, 0, buf);
block_size, 0, 1, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY16. Skipping test");
@@ -53,6 +53,7 @@ test_verify16_flags(void)
logging(LOG_VERBOSE, "Test VERIFY16 with BYTCHK==1");
ret = verify16(iscsic, tgt_lun, 0, block_size,
block_size, 0, 0, 1, buf);
block_size, 0, 0, 1, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}

10
test-tool/test_verify16_mismatch.c
View File

@@ -48,8 +48,9 @@ test_verify16_mismatch(void)
buf[offset] ^= 'X';
logging(LOG_VERBOSE, "Flip some bits in the data");
ret = verify16_miscompare(iscsic, tgt_lun, 0, i * block_size,
block_size, 0, 0, 1, buf);
ret = verify16(iscsic, tgt_lun, 0, i * block_size,
block_size, 0, 0, 1, buf,
EXPECT_MISCOMPARE);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY16. Skipping test");
@@ -74,8 +75,9 @@ test_verify16_mismatch(void)
buf[offset] ^= 'X';
logging(LOG_VERBOSE, "Flip some bits in the data");
ret = verify16_miscompare(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size, 0, 0, 1, buf);
ret = verify16(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_MISCOMPARE);
CU_ASSERT_EQUAL(ret, 0);
}
}

7
test-tool/test_verify16_mismatch_no_cmp.c
View File

@@ -1,4 +1,3 @@
/*
Copyright (C) 2013 Ronnie Sahlberg <ronniesahlberg@gmail.com>
@@ -50,7 +49,8 @@ test_verify16_mismatch_no_cmp(void)
logging(LOG_VERBOSE, "Flip some bits in the data");
ret = verify16(iscsic, tgt_lun, 0, i * block_size,
block_size, 0, 0, 0, buf);
block_size, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY16. Skipping test");
@@ -76,7 +76,8 @@ test_verify16_mismatch_no_cmp(void)
logging(LOG_VERBOSE, "Flip some bits in the data");
ret = verify16(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size, 0, 0, 0, buf);
i * block_size, block_size, 0, 0, 0, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}
}

6
test-tool/test_verify16_simple.c
View File

@@ -42,7 +42,8 @@ test_verify16_simple(void)
block_size, 0, 0, 0, 0, 0, buf);
ret = verify16(iscsic, tgt_lun, 0, i * block_size,
block_size, 0, 0, 1, buf);
block_size, 0, 0, 1, buf,
EXPECT_STATUS_GOOD);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY16. Skipping test");
@@ -62,7 +63,8 @@ test_verify16_simple(void)
CU_ASSERT_EQUAL(ret, 0);
ret = verify16(iscsic, tgt_lun, num_blocks - i,
i * block_size, block_size, 0, 0, 1, buf);
i * block_size, block_size, 0, 0, 1, buf,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
}
}

5
test-tool/test_verify16_vrprotect.c
View File

@@ -44,8 +44,9 @@ test_verify16_vrprotect(void)
ret = read16(iscsic, tgt_lun, 0, block_size,
block_size, 0, 0, 0, 0, 0, buf);
ret = verify16_invalidfieldincdb(iscsic, tgt_lun, 0, block_size,
block_size, i, 0, 1, buf);
ret = verify16(iscsic, tgt_lun, 0, block_size,
block_size, i, 0, 1, buf,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] VERIFY16 is not implemented.");
CU_PASS("[SKIPPED] Target does not support VERIFY16. Skipping test");