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

Tests: Add helpers for SANITIZE

Browse Source 
Signed-off-by: Ronnie Sahlberg <ronniesahlberg@gmail.com>
This commit is contained in:
Ronnie Sahlberg
2016-02-21 09:25:47 -08:00
parent d18dbe49aa
commit 39d128db6d
11 changed files with 71 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -210,6 +210,20 @@ do { \
CU_ASSERT_EQUAL(_r, 0); \
} while (0);
#define SANITIZE(...) \
do { \
int _r; \
_r = sanitize(__VA_ARGS__); \
if (_r == -2) { \
logging(LOG_NORMAL, "[SKIPPED] SANITIZE " \
"is not implemented."); \
CU_PASS("[SKIPPED] Target does not support " \
"SANITIZE. Skipping test"); \
return; \
} \
CU_ASSERT_EQUAL(_r, 0); \
} while (0);
#define VERIFY10(...) \
do { \
int _r; \

11
test-tool/test_sanitize_block_erase.c
View File

@@ -246,7 +246,6 @@ check_lun_is_wiped(unsigned char *buf, uint64_t lba)
void
test_sanitize_block_erase(void)
{
int ret;
struct iscsi_data data;
struct scsi_command_descriptor *cd;
unsigned char *buf = alloca(256 * block_size);
@@ -323,9 +322,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,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Check that the first 256 LBAs are wiped.");
check_lun_is_wiped(buf, 0);
@@ -339,9 +337,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(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 8, &data,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 8, &data,
EXPECT_INVALID_FIELD_IN_CDB);
if (inq_bdc) {
logging(LOG_VERBOSE, "Check WABEREQ setting and that READ "

19
test-tool/test_sanitize_block_erase_reserved.c
View File

@@ -50,7 +50,7 @@ static int my_iscsi_queue_pdu(struct iscsi_context *iscsi _U_, struct iscsi_pdu
void test_sanitize_block_erase_reserved(void)
{
int i, ret;
int i;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test SANITIZE BLOCK_ERASE Reserved bits/bytes");
@@ -64,24 +64,15 @@ 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(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.");
CU_PASS("SANITIZE is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL,
EXPECT_INVALID_FIELD_IN_CDB);
for (i = 2; i < 7; i++) {
logging(LOG_VERBOSE, "Send SANITIZE command with the reserved "
"byte %d set to non-zero", i);
change_num = i;
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL,
EXPECT_INVALID_FIELD_IN_CDB);
}
}

14
test-tool/test_sanitize_crypto_erase.c
View File

@@ -135,7 +135,6 @@ check_lun_is_wiped(unsigned char *buf, uint64_t lba)
void
test_sanitize_crypto_erase(void)
{
int ret;
struct iscsi_data data;
struct scsi_command_descriptor *cd;
unsigned char *buf = alloca(256 * block_size);
@@ -185,17 +184,14 @@ 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,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Check that the first 256 LBAs are wiped.");
check_lun_is_wiped(buf, 0);
logging(LOG_VERBOSE, "Check that the last 256 LBAs are wiped.");
check_lun_is_wiped(buf, num_blocks - 256);
return;
data.size = 8;
data.data = alloca(data.size);
memset(data.data, 0, data.size);
@@ -203,10 +199,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(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 8, &data,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 8, &data,
EXPECT_INVALID_FIELD_IN_CDB);
if (inq_bdc) {
logging(LOG_VERBOSE, "Check WACEREQ setting and that READ "
"after SANITIZE works correctly.");

19
test-tool/test_sanitize_crypto_erase_reserved.c
View File

@@ -50,7 +50,7 @@ static int my_iscsi_queue_pdu(struct iscsi_context *iscsi _U_, struct iscsi_pdu
void test_sanitize_crypto_erase_reserved(void)
{
int i, ret;
int i;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test SANITIZE CRYPTO_ERASE Reserved bits/bytes");
@@ -64,24 +64,15 @@ 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(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.");
CU_PASS("SANITIZE is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL,
EXPECT_INVALID_FIELD_IN_CDB);
for (i = 2; i < 7; i++) {
logging(LOG_VERBOSE, "Send SANITIZE command with the reserved "
"byte %d set to non-zero", i);
change_num = i;
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL,
EXPECT_INVALID_FIELD_IN_CDB);
}
}

7
test-tool/test_sanitize_exit_failure_mode.c
View File

@@ -30,7 +30,6 @@
void
test_sanitize_exit_failure_mode(void)
{
int ret;
struct iscsi_data data;
struct scsi_command_descriptor *cd;
@@ -56,12 +55,10 @@ test_sanitize_exit_failure_mode(void)
data.data = alloca(data.size);
memset(data.data, 0, data.size);
logging(LOG_VERBOSE, "EXIT_FAILURE_MODE parameter list length must "
"be 0");
logging(LOG_VERBOSE, "Test that non-zero param length is an error for "
"EXIT_FAILURE_MODE");
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_EXIT_FAILURE_MODE, 8, &data,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_EXIT_FAILURE_MODE, 8, &data,
EXPECT_INVALID_FIELD_IN_CDB);
}

15
test-tool/test_sanitize_invalid_serviceaction.c
View File

@@ -30,14 +30,13 @@
void
test_sanitize_invalid_serviceaction(void)
{
int i, ret;
int i;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test SANITIZE for invalid serviceactions");
CHECK_FOR_SANITIZE;
logging(LOG_VERBOSE, "Test all invalid service actions and make sure "
"they fail with an error");
for (i = 0; i <= 0x1f; i++) {
@@ -52,15 +51,7 @@ test_sanitize_invalid_serviceaction(void)
logging(LOG_VERBOSE, "Verify that ServiceAction:0x%02d is "
"an error.", i);
ret = sanitize(sd, 0, 0, i, 0, NULL,
EXPECT_INVALID_FIELD_IN_CDB);
if (ret == -2) {
logging(LOG_NORMAL, "[SKIPPED] SANITIZE is not "
"implemented.");
CU_PASS("SANITIZE is not implemented.");
return;
} else {
CU_ASSERT_EQUAL(ret, 0);
}
SANITIZE(sd, 0, 0, i, 0, NULL,
EXPECT_INVALID_FIELD_IN_CDB);
}
}

61
test-tool/test_sanitize_overwrite.c
View File

@@ -66,7 +66,7 @@ check_lun_is_wiped(uint64_t lba, unsigned char c)
void
test_sanitize_overwrite(void)
{
int i, ret;
int i;
struct iscsi_data data;
struct scsi_command_descriptor *cd;
@@ -123,9 +123,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,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Check that the first 256 LBAs are wiped.");
check_lun_is_wiped(0, 0xaa);
@@ -139,10 +138,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,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "Test SANITIZE OVERWRITE with initialization pattern of 4 bytes");
data.size = 4 + 4;
@@ -150,9 +147,8 @@ test_sanitize_overwrite(void)
data.data[2] = 0;
data.data[3] = 4;
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_STATUS_GOOD);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_STATUS_GOOD);
logging(LOG_VERBOSE, "OVERWRITE parameter list length must "
"be > 4 and < blocksize+5");
@@ -160,16 +156,8 @@ test_sanitize_overwrite(void)
logging(LOG_VERBOSE, "Test OVERWRITE with ParamLen:%d is an "
"error.", i);
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.");
CU_PASS("SANITIZE is not implemented.");
return;
} else {
CU_ASSERT_EQUAL(ret, 0);
}
SANITIZE(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, i, &data,
EXPECT_INVALID_FIELD_IN_CDB);
}
@@ -179,18 +167,8 @@ 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(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.");
CU_PASS("SANITIZE is not implemented.");
return;
} else {
CU_ASSERT_EQUAL(ret, 0);
}
SANITIZE(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, block_size + 5, &data,
EXPECT_INVALID_FIELD_IN_CDB);
logging(LOG_VERBOSE, "Test OVERWRITE COUNT == 0 is an error");
data.size = block_size + 4;
@@ -199,10 +177,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,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_INVALID_FIELD_IN_CDB);
logging(LOG_VERBOSE, "Test INITIALIZATION PATTERN LENGTH == 0 is an "
"error");
@@ -212,10 +188,8 @@ test_sanitize_overwrite(void)
data.data[1] = 0x00;
data.data[2] = 0x00;
data.data[3] = 0x00;
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_INVALID_FIELD_IN_CDB);
logging(LOG_VERBOSE, "Test INITIALIZATION PATTERN LENGTH == %zd > %zd "
"(blocksize) is an error", block_size + 4, block_size);
@@ -226,7 +200,6 @@ test_sanitize_overwrite(void)
data.data[1] = 0x00;
data.data[2] = (block_size + 4) >> 8;
data.data[3] = (block_size + 4) & 0xff;
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_INVALID_FIELD_IN_CDB);
}

20
test-tool/test_sanitize_overwrite_reserved.c
View File

@@ -51,7 +51,7 @@ static int my_iscsi_queue_pdu(struct iscsi_context *iscsi _U_, struct iscsi_pdu
void test_sanitize_overwrite_reserved(void)
{
int i, ret;
int i;
struct iscsi_data data;
data.size = block_size + 4;
@@ -74,25 +74,15 @@ 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(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.");
CU_PASS("SANITIZE is not implemented.");
return;
}
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_INVALID_FIELD_IN_CDB);
for (i = 2; i < 7; i++) {
logging(LOG_VERBOSE, "Send SANITIZE command with the reserved "
"byte %d set to non-zero", i);
change_num = i;
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size,
&data,
EXPECT_INVALID_FIELD_IN_CDB);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_INVALID_FIELD_IN_CDB);
}
}

16
test-tool/test_sanitize_readonly.c
View File

@@ -87,10 +87,8 @@ test_sanitize_readonly(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,
EXPECT_WRITE_PROTECTED);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_WRITE_PROTECTED);
}
@@ -103,9 +101,8 @@ test_sanitize_readonly(void)
"implemented according to REPORT_SUPPORTED_OPCODES.");
} else {
logging(LOG_VERBOSE, "Test SANITIZE BLOCK_ERASE");
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL,
EXPECT_WRITE_PROTECTED);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL,
EXPECT_WRITE_PROTECTED);
}
logging(LOG_VERBOSE, "Check if SANITIZE CRYPTO_ERASE is supported "
@@ -117,9 +114,8 @@ test_sanitize_readonly(void)
"implemented according to REPORT_SUPPORTED_OPCODES.");
} else {
logging(LOG_VERBOSE, "Test SANITIZE CRYPTO_ERASE");
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL,
EXPECT_WRITE_PROTECTED);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL,
EXPECT_WRITE_PROTECTED);
}

16
test-tool/test_sanitize_reservations.c
View File

@@ -80,10 +80,8 @@ test_sanitize_reservations(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,
EXPECT_RESERVATION_CONFLICT);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_OVERWRITE, data.size, &data,
EXPECT_RESERVATION_CONFLICT);
}
@@ -96,9 +94,8 @@ test_sanitize_reservations(void)
"implemented according to REPORT_SUPPORTED_OPCODES.");
} else {
logging(LOG_VERBOSE, "Test SANITIZE BLOCK_ERASE");
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL,
EXPECT_RESERVATION_CONFLICT);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_BLOCK_ERASE, 0, NULL,
EXPECT_RESERVATION_CONFLICT);
}
logging(LOG_VERBOSE, "Check if SANITIZE CRYPTO_ERASE is supported "
@@ -110,9 +107,8 @@ test_sanitize_reservations(void)
"implemented according to REPORT_SUPPORTED_OPCODES.");
} else {
logging(LOG_VERBOSE, "Test SANITIZE CRYPTO_ERASE");
ret = sanitize(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL,
EXPECT_RESERVATION_CONFLICT);
CU_ASSERT_EQUAL(ret, 0);
SANITIZE(sd, 0, 0, SCSI_SANITIZE_CRYPTO_ERASE, 0, NULL,
EXPECT_RESERVATION_CONFLICT);
}
mpath_sd2_put(sd2);