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

TESTS: convert most of SANITIZE to new saner api

Browse Source 
Signed-off-by: Ronnie Sahlberg <ronniesahlberg@gmail.com>
This commit is contained in:
Ronnie Sahlberg
2014-10-14 19:25:17 -07:00
parent fe9620092c
commit 8ac7d64082
11 changed files with 66 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -115,13 +115,6 @@ static const char *scsi_status_str(int status)
return "UNKNOWN";
}
static int status_is_invalid_field_in_cdb(struct scsi_task *task)
{
return task->status == SCSI_STATUS_CHECK_CONDITION
&& task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST
&& task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_FIELD_IN_CDB;
}
/*
* There is no agreement among the T10 committee whether a SCSI target should
* report "invalid opcode", "invalid field in CDB" or "invalid field in
@@ -1236,82 +1229,34 @@ synchronizecache16(struct scsi_device *sdev, uint64_t lba, int num, int sync_nv,
return ret;
}
int sanitize(struct scsi_device *sdev, int immed, int ause, int sa, int param_len, struct iscsi_data *data)
int sanitize(struct scsi_device *sdev, int immed, int ause, int sa, int param_len, struct iscsi_data *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq)
{
struct scsi_task *task;
int ret;
logging(LOG_VERBOSE, "Send SANITIZE IMMED:%d AUSE:%d SA:%d "
"PARAM_LEN:%d",
logging(LOG_VERBOSE, "Send SANITIZE (Expecting %s) IMMED:%d AUSE:%d "
"SA:%d PARAM_LEN:%d",
scsi_status_str(status),
immed, ause, sa, param_len);
if (!data_loss) {
printf("--dataloss flag is not set in. Skipping sanitize\n");
return -1;
}
task = iscsi_sanitize_sync(sdev->iscsi_ctx, sdev->iscsi_lun, immed, ause, sa, param_len,
data);
if (task == NULL) {
logging(LOG_NORMAL,
"[FAILED] Failed to send SANITIZE command: %s",
iscsi_get_error(sdev->iscsi_ctx));
return -1;
}
if (status_is_invalid_opcode(task)) {
logging(LOG_NORMAL, "[SKIPPED] SANITIZE is not "
"implemented on target");
scsi_free_scsi_task(task);
return -2;
}
if (task->status != SCSI_STATUS_GOOD) {
logging(LOG_NORMAL,
"[FAILED] SANITIZE command: failed with sense. %s",
iscsi_get_error(sdev->iscsi_ctx));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] SANITIZE returned SUCCESS.");
return 0;
}
task = scsi_cdb_sanitize(immed, ause, sa, param_len);
int sanitize_invalidfieldincdb(struct scsi_device *sdev, int immed, int ause, int sa, int param_len, struct iscsi_data *data)
{
struct scsi_task *task;
assert(task != NULL);
logging(LOG_VERBOSE, "Send SANITIZE (Expecting INVALID_FIELD_IN_CDB) "
"IMMED:%d AUSE:%d SA:%d "
"PARAM_LEN:%d",
immed, ause, sa, param_len);
task = send_scsi_command(sdev, task, data);
task = iscsi_sanitize_sync(sdev->iscsi_ctx, sdev->iscsi_lun, immed, ause, sa, param_len,
data);
if (task == NULL) {
logging(LOG_NORMAL,
"[FAILED] Failed to send SANITIZE command: %s",
iscsi_get_error(sdev->iscsi_ctx));
return -1;
}
if (status_is_invalid_opcode(task)) {
logging(LOG_NORMAL, "[SKIPPED] SANITIZE is not "
"implemented on target");
ret = check_result("SANITIZE", sdev, 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] SANITIZE successful but should "
"have failed with ILLEGAL_REQUEST/INVALID_FIELD_IN_CDB");
scsi_free_scsi_task(task);
return -1;
}
if (!status_is_invalid_field_in_cdb(task)) {
logging(LOG_NORMAL, "[FAILED] SANITIZE failed with wrong "
"sense. Should have failed with ILLEGAL_REQUEST/"
"INVALID_FIELD_IN_CDB. Sense:%s\n",
iscsi_get_error(sdev->iscsi_ctx));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] SANITIZE returned ILLEGAL_REQUEST/"
"INVALID_FIELD_IB_CDB.");
return 0;
return ret;
}
int sanitize_conflict(struct scsi_device *sdev, int immed, int ause, int sa, int param_len, struct iscsi_data *data)
@@ -1349,45 +1294,6 @@ int sanitize_conflict(struct scsi_device *sdev, int immed, int ause, int sa, int
return 0;
}
int sanitize_writeprotected(struct scsi_device *sdev, int immed, int ause, int sa, int param_len, struct iscsi_data *data)
{
struct scsi_task *task;
logging(LOG_VERBOSE, "Send SANITIZE (Expecting WRITE_PROTECTED) "
"IMMED:%d AUSE:%d SA:%d "
"PARAM_LEN:%d",
immed, ause, sa, param_len);
task = iscsi_sanitize_sync(sdev->iscsi_ctx, sdev->iscsi_lun, immed, ause, sa, param_len,
data);
if (task == NULL) {
logging(LOG_NORMAL,
"[FAILED] Failed to send SANITIZE command: %s",
iscsi_get_error(sdev->iscsi_ctx));
return -1;
}
if (task->status == SCSI_STATUS_GOOD) {
logging(LOG_NORMAL, "[FAILED] SANITIZE 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] SANITIZE failed with wrong "
"sense. Should have failed with DATA_PRTOTECTION/"
"WRITE_PROTECTED. Sense:%s\n",
iscsi_get_error(sdev->iscsi_ctx));
scsi_free_scsi_task(task);
return -1;
}
scsi_free_scsi_task(task);
logging(LOG_VERBOSE, "[OK] SANITIZE returned DATA_PROTECTION/WRITE_PROTECTED.");
return 0;
}
int startstopunit(struct scsi_device *sdev, int immed, int pcm, int pc, int no_flush, int loej, int start, int status, enum scsi_sense_key key, int *ascq, int num_ascq)
{
struct scsi_task *task;

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

@@ -287,10 +287,8 @@ int report_supported_opcodes(struct scsi_device *sdev, struct scsi_task **save_t
int release6(struct scsi_device *sdev);
int reserve6(struct scsi_device *sdev);
int reserve6_conflict(struct scsi_device *sdev);
int sanitize(struct scsi_device *sdev, int immed, int ause, int sa, int param_len, struct iscsi_data *data);
int sanitize(struct scsi_device *sdev, int immed, int ause, int sa, int param_len, struct iscsi_data *data, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
int sanitize_conflict(struct scsi_device *sdev, int immed, int ause, int sa, int param_len, struct iscsi_data *data);
int sanitize_invalidfieldincdb(struct scsi_device *sdev, int immed, int ause, int sa, int param_len, struct iscsi_data *data);
int sanitize_writeprotected(struct scsi_device *sdev, int immed, int ause, int sa, int param_len, struct iscsi_data *data);
int startstopunit(struct scsi_device *sdev, int immed, int pcm, int pc, int no_flush, int loej, int start, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
int synchronizecache10(struct scsi_device *sdev, uint32_t lba, int num_blocks, int sync_nv, int immed, int status, enum scsi_sense_key key, int *ascq, int num_ascq);
int synchronizecache16(struct scsi_device *sdev, uint64_t lba, int num_blocks, int sync_nv, int immed, int status, enum scsi_sense_key key, int *ascq, int num_ascq);

8
test-tool/test_sanitize_block_erase.c
View File

@@ -325,8 +325,8 @@ test_sanitize_block_erase(void)
logging(LOG_VERBOSE, "Test we can perform basic BLOCK ERASE SANITIZE");
ret = sanitize(sd,
0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Check that the first 256 LBAs are wiped.");
@@ -341,8 +341,8 @@ test_sanitize_block_erase(void)
logging(LOG_VERBOSE, "BLOCK_ERASE parameter list length must be 0");
logging(LOG_VERBOSE, "Test that non-zero param length is an error for "
"BLOCK ERASE");
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_BLOCK_ERASE, 8, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 8, &data,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
if (inq_bdc) {

8
test-tool/test_sanitize_block_erase_reserved.c
View File

@@ -63,8 +63,8 @@ void test_sanitize_block_erase_reserved(void)
logging(LOG_VERBOSE, "Send SANITIZE command with the reserved "
"bit in byte 1 set to 1");
change_num = 1;
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] SANITIZE BLOCK_ERASE is not "
"implemented on target.");
@@ -79,8 +79,8 @@ void test_sanitize_block_erase_reserved(void)
"byte %d set to non-zero", i);
change_num = i;
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
}
}

8
test-tool/test_sanitize_crypto_erase.c
View File

@@ -184,8 +184,8 @@ test_sanitize_crypto_erase(void)
logging(LOG_VERBOSE, "Test we can perform basic CRYPTO ERASE SANITIZE");
ret = sanitize(sd,
0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Check that the first 256 LBAs are wiped.");
@@ -202,8 +202,8 @@ return;
logging(LOG_VERBOSE, "CRYPTO_ERASE parameter list length must be 0");
logging(LOG_VERBOSE, "Test that non-zero param length is an error for "
"CRYPTO ERASE");
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 8, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 8, &data,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
if (inq_bdc) {

8
test-tool/test_sanitize_crypto_erase_reserved.c
View File

@@ -63,8 +63,8 @@ void test_sanitize_crypto_erase_reserved(void)
logging(LOG_VERBOSE, "Send SANITIZE command with the reserved "
"bit in byte 1 set to 1");
change_num = 1;
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] SANITIZE CRYPTO_ERASE is not "
"implemented on target.");
@@ -79,8 +79,8 @@ void test_sanitize_crypto_erase_reserved(void)
"byte %d set to non-zero", i);
change_num = i;
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
}
}

4
test-tool/test_sanitize_exit_failure_mode.c
View File

@@ -60,7 +60,7 @@ test_sanitize_exit_failure_mode(void)
"be 0");
logging(LOG_VERBOSE, "Test that non-zero param length is an error for "
"EXIT_FAILURE_MODE");
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_EXIT_FAILURE_MODE, 8, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_EXIT_FAILURE_MODE, 8, &data,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
}

4
test-tool/test_sanitize_invalid_serviceaction.c
View File

@@ -51,8 +51,8 @@ test_sanitize_invalid_serviceaction(void)
logging(LOG_VERBOSE, "Verify that ServiceAction:0x%02d is "
"an error.", i);
ret = sanitize_invalidfieldincdb(sd,
0, 0, i, 0, NULL);
ret = sanitize(sd, 0, 0, i, 0, NULL,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] SANITIZE is not "
"implemented.");

33
test-tool/test_sanitize_overwrite.c
View File

@@ -124,8 +124,8 @@ test_sanitize_overwrite(void)
data.data[1] = 0x00;
data.data[2] = block_size >> 8;
data.data[3] = block_size & 0xff;
ret = sanitize(sd,
0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "Check that the first 256 LBAs are wiped.");
@@ -140,8 +140,8 @@ test_sanitize_overwrite(void)
data.data[2] = (block_size / 2) >> 8;
data.data[3] = (block_size / 2 ) & 0xff;
ret = sanitize(sd,
0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
@@ -151,8 +151,8 @@ test_sanitize_overwrite(void)
data.data[2] = 0;
data.data[3] = 4;
ret = sanitize(sd,
0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
logging(LOG_VERBOSE, "OVERWRITE parameter list length must "
@@ -161,8 +161,8 @@ test_sanitize_overwrite(void)
logging(LOG_VERBOSE, "Test OVERWRITE with ParamLen:%d is an "
"error.", i);
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_OVERWRITE, i, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, i, &data,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] SANITIZE is not "
"implemented.");
@@ -180,8 +180,9 @@ test_sanitize_overwrite(void)
data.size = block_size + 8;
data.data = alloca(block_size + 8); /* so we can send IP > blocksize */
memset(data.data, 0, data.size);
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_OVERWRITE, block_size + 5, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, block_size + 5, &data,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] SANITIZE is not "
"implemented.");
@@ -199,8 +200,8 @@ test_sanitize_overwrite(void)
data.data[1] = 0x00;
data.data[2] = block_size >> 8;
data.data[3] = block_size & 0xff;
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
@@ -212,8 +213,8 @@ test_sanitize_overwrite(void)
data.data[1] = 0x00;
data.data[2] = 0x00;
data.data[3] = 0x00;
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
@@ -226,7 +227,7 @@ test_sanitize_overwrite(void)
data.data[1] = 0x00;
data.data[2] = (block_size + 4) >> 8;
data.data[3] = (block_size + 4) & 0xff;
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
}

9
test-tool/test_sanitize_overwrite_reserved.c
View File

@@ -73,8 +73,8 @@ void test_sanitize_overwrite_reserved(void)
logging(LOG_VERBOSE, "Send SANITIZE command with the reserved "
"bit in byte 1 set to 1");
change_num = 1;
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] SANITIZE OVERWRITE is not "
"implemented on target.");
@@ -89,8 +89,9 @@ void test_sanitize_overwrite_reserved(void)
"byte %d set to non-zero", i);
change_num = i;
ret = sanitize_invalidfieldincdb(sd,
0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size,
&data,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
}
}

13
test-tool/test_sanitize_readonly.c
View File

@@ -89,8 +89,9 @@ test_sanitize_readonly(void)
data.data[1] = 0x00;
data.data[2] = block_size >> 8;
data.data[3] = block_size & 0xff;
ret = sanitize_writeprotected(sd,
0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size,
&data,
EXPECT_WRITE_PROTECTED);
CU_ASSERT_EQUAL(ret, 0);
}
@@ -104,8 +105,8 @@ test_sanitize_readonly(void)
"implemented according to REPORT_SUPPORTED_OPCODES.");
} else {
logging(LOG_VERBOSE, "Test SANITIZE BLOCK_ERASE");
ret = sanitize_writeprotected(sd,
0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL,
EXPECT_WRITE_PROTECTED);
CU_ASSERT_EQUAL(ret, 0);
}
@@ -118,8 +119,8 @@ test_sanitize_readonly(void)
"implemented according to REPORT_SUPPORTED_OPCODES.");
} else {
logging(LOG_VERBOSE, "Test SANITIZE CRYPTO_ERASE");
ret = sanitize_writeprotected(sd,
0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL);
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL,
EXPECT_WRITE_PROTECTED);
CU_ASSERT_EQUAL(ret, 0);
}