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

test-tool: use CHECK_FOR_ISCSI() helper macro

Browse Source 
This removes a large amount of boilerplate code.

Signed-off-by: David Disseldorp <ddiss@suse.de>
This commit is contained in:
David Disseldorp
2019-09-18 16:19:29 +02:00
parent 2600e538d8
commit e716691a45
41 changed files with 58 additions and 382 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
test-tool/test_async_abort_simple.c
View File

@@ -99,10 +99,7 @@ test_async_abort_simple(void)
CHECK_FOR_DATALOSS;
CHECK_FOR_SBC;
if (sd->iscsi_ctx == NULL) {
CU_PASS("[SKIPPED] Non-iSCSI");
return;
}
CHECK_FOR_ISCSI(sd);
if (maximum_transfer_length
&& (maximum_transfer_length < (int)(blocks_per_io))) {

5
test-tool/test_async_lu_reset_simple.c
View File

@@ -98,10 +98,7 @@ test_async_lu_reset_simple(void)
CHECK_FOR_DATALOSS;
CHECK_FOR_SBC;
if (sd->iscsi_ctx == NULL) {
CU_PASS("[SKIPPED] Non-iSCSI");
return;
}
CHECK_FOR_ISCSI(sd);
if (maximum_transfer_length
&& (maximum_transfer_length < (int)(blocks_per_io))) {

16
test-tool/test_async_read.c
View File

@@ -62,19 +62,17 @@ test_async_read(void)
struct tests_async_read_state state = { 0, 0, 0 };
const int blocks_per_io = 8;
const int num_ios = 1000;
/* IOs in flight concurrently, so need a buffer large enough for all */
unsigned char *buf = calloc(block_size * blocks_per_io, num_ios);
CU_ASSERT_NOT_EQUAL(buf, NULL);
if (!buf)
goto out;
unsigned char *buf = NULL;
CHECK_FOR_DATALOSS;
CHECK_FOR_SBC;
if (sd->iscsi_ctx == NULL) {
CU_PASS("[SKIPPED] Non-iSCSI");
CHECK_FOR_ISCSI(sd);
/* IOs in flight concurrently, so need a buffer large enough for all */
buf = calloc(block_size * blocks_per_io, num_ios);
CU_ASSERT_NOT_EQUAL(buf, NULL);
if (!buf)
goto out;
}
if (maximum_transfer_length
&& (maximum_transfer_length < (blocks_per_io * num_ios))) {

5
test-tool/test_async_write.c
View File

@@ -66,10 +66,7 @@ test_async_write(void)
CHECK_FOR_DATALOSS;
CHECK_FOR_SBC;
if (sd->iscsi_ctx == NULL) {
CU_PASS("[SKIPPED] Non-iSCSI");
return;
}
CHECK_FOR_ISCSI(sd);
if (maximum_transfer_length
&& (maximum_transfer_length < (blocks_per_io * num_ios))) {

8
test-tool/test_compareandwrite_invalid_dataout_size.c
View File

@@ -55,13 +55,7 @@ test_compareandwrite_invalid_dataout_size(void)
CHECK_FOR_THIN_PROVISIONING;
CHECK_FOR_LBPPB_GT_1;
CHECK_FOR_SBC;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
/* override transport queue_pdu callback for PDU manipulation */
iscsi_drv_orig = *sd->iscsi_ctx->drv;

8
test-tool/test_iscsi_cmdsn_toohigh.c
View File

@@ -55,13 +55,7 @@ void test_iscsi_cmdsn_toohigh(void)
logging(LOG_VERBOSE, "Test sending invalid iSCSI CMDSN");
logging(LOG_VERBOSE, "CMDSN MUST be in the range EXPCMDSN and MAXCMDSN");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, "RFC3720:3.2.2.1 CMDSN > MAXCMDSN must be silently ignored by the target");
logging(LOG_VERBOSE, "Send a TESTUNITREADY with CMDSN == MAXCMDSN+1. Should be ignored by the target.");

8
test-tool/test_iscsi_cmdsn_toolow.c
View File

@@ -55,13 +55,7 @@ void test_iscsi_cmdsn_toolow(void)
logging(LOG_VERBOSE, "Test sending invalid iSCSI CMDSN");
logging(LOG_VERBOSE, "CMDSN MUST be in the range EXPCMDSN and MAXCMDSN");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, "RFC3720:3.2.2.1 CMDSN < EXPCMDSN must be silently ignored by the target");
logging(LOG_VERBOSE, "Send a TESTUNITREADY with CMDSN == EXPCMDSN-1. Should be ignored by the target.");

9
test-tool/test_iscsi_datasn_invalid.c
View File

@@ -62,18 +62,11 @@ void test_iscsi_datasn_invalid(void)
int ret;
CHECK_FOR_DATALOSS;
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test sending invalid iSCSI DataSN");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
logging(LOG_VERBOSE, "Send two Data-Out PDU's with DataSN==0. Should fail.");
change_datasn = 1;

8
test-tool/test_iscsi_nop_simple.c
View File

@@ -83,13 +83,7 @@ test_iscsi_nop_simple(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test Nop Out Pings");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
memset(&state, 0, sizeof(state));
strncpy(state.nop_buf, "nopping", sizeof(state.nop_buf));

16
test-tool/test_iscsi_sendtargets.c
View File

@@ -106,13 +106,7 @@ test_iscsi_sendtargets_simple(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test SendTargets in FFP");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
memset(&state, 0, sizeof(state));
ret = iscsi_discovery_async(sd->iscsi_ctx,
@@ -172,13 +166,7 @@ test_iscsi_sendtargets_invalid(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test invalid SendTargets Text requests");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
memset(&state, 0, sizeof(state));
ret = test_iscsi_text_req_queue(sd->iscsi_ctx,

9
test-tool/test_preventallow_2_itnexuses.c
View File

@@ -33,18 +33,11 @@ test_preventallow_2_itnexuses(void)
CHECK_FOR_SBC;
CHECK_FOR_REMOVABLE;
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test that PREVENT MEDIUM REMOVAL are seen on other nexuses as well");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PREVENTALLOW test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
logging(LOG_VERBOSE, "Set the PREVENT flag");
PREVENTALLOW(sd, 1);

9
test-tool/test_preventallow_cold_reset.c
View File

@@ -31,18 +31,11 @@ test_preventallow_cold_reset(void)
CHECK_FOR_SBC;
CHECK_FOR_REMOVABLE;
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test that Target Warm Reset clears PREVENT MEDIUM REMOVAL");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PREVENTALLOW test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
logging(LOG_VERBOSE, "Set the PREVENT flag");
PREVENTALLOW(sd, 1);

9
test-tool/test_preventallow_itnexus_loss.c
View File

@@ -29,18 +29,11 @@ test_preventallow_itnexus_loss(void)
{
CHECK_FOR_SBC;
CHECK_FOR_REMOVABLE;
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test that IT-Nexus loss clears PREVENT MEDIUM REMOVAL");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PREVENTALLOW test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
logging(LOG_VERBOSE, "Set the PREVENT flag");
PREVENTALLOW(sd, 1);

9
test-tool/test_preventallow_logout.c
View File

@@ -29,18 +29,11 @@ test_preventallow_logout(void)
{
CHECK_FOR_SBC;
CHECK_FOR_REMOVABLE;
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test that Logout loss clears PREVENT MEDIUM REMOVAL");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PREVENTALLOW test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
logging(LOG_VERBOSE, "Set the PREVENT flag");
PREVENTALLOW(sd, 1);

9
test-tool/test_preventallow_lun_reset.c
View File

@@ -31,18 +31,11 @@ test_preventallow_lun_reset(void)
CHECK_FOR_SBC;
CHECK_FOR_REMOVABLE;
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test that Target Warm Reset clears PREVENT MEDIUM REMOVAL");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PREVENTALLOW test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
logging(LOG_VERBOSE, "Set the PREVENT flag");
PREVENTALLOW(sd, 1);

9
test-tool/test_preventallow_warm_reset.c
View File

@@ -31,18 +31,11 @@ test_preventallow_warm_reset(void)
CHECK_FOR_SBC;
CHECK_FOR_REMOVABLE;
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test that Target Warm Reset clears PREVENT MEDIUM REMOVAL");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PREVENTALLOW test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
logging(LOG_VERBOSE, "Set the PREVENT flag");
PREVENTALLOW(sd, 1);

9
test-tool/test_prout_preempt.c
View File

@@ -39,14 +39,7 @@ test_prout_preempt_rm_reg(void)
struct scsi_persistent_reserve_in_read_keys *rk;
CHECK_FOR_DATALOSS;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test Persistent Reserve IN PREEMPT works.");

48
test-tool/test_prout_reserve_access.c
View File

@@ -123,13 +123,7 @@ test_prout_reserve_access_ea(void)
struct scsi_device *sd2;
int ret;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
ret = mpath_sd2_get_or_clone(sd, &sd2);
CU_ASSERT_EQUAL(ret, 0);
@@ -147,13 +141,7 @@ test_prout_reserve_access_we(void)
struct scsi_device *sd2;
int ret;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
ret = mpath_sd2_get_or_clone(sd, &sd2);
CU_ASSERT_EQUAL(ret, 0);
@@ -171,13 +159,7 @@ test_prout_reserve_access_earo(void)
struct scsi_device *sd2;
int ret;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
ret = mpath_sd2_get_or_clone(sd, &sd2);
CU_ASSERT_EQUAL(ret, 0);
@@ -195,13 +177,7 @@ test_prout_reserve_access_wero(void)
struct scsi_device *sd2;
int ret;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
ret = mpath_sd2_get_or_clone(sd, &sd2);
CU_ASSERT_EQUAL(ret, 0);
@@ -219,13 +195,7 @@ test_prout_reserve_access_eaar(void)
struct scsi_device *sd2;
int ret;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
ret = mpath_sd2_get_or_clone(sd, &sd2);
CU_ASSERT_EQUAL(ret, 0);
@@ -243,13 +213,7 @@ test_prout_reserve_access_wear(void)
struct scsi_device *sd2;
int ret;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
ret = mpath_sd2_get_or_clone(sd, &sd2);
CU_ASSERT_EQUAL(ret, 0);

48
test-tool/test_prout_reserve_ownership.c
View File

@@ -98,13 +98,7 @@ test_prout_reserve_ownership_ea(void)
struct scsi_device *sd2;
int ret;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
ret = mpath_sd2_get_or_clone(sd, &sd2);
CU_ASSERT_EQUAL(ret, 0);
@@ -121,13 +115,7 @@ test_prout_reserve_ownership_we(void)
struct scsi_device *sd2;
int ret;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
ret = mpath_sd2_get_or_clone(sd, &sd2);
CU_ASSERT_EQUAL(ret, 0);
@@ -144,13 +132,7 @@ test_prout_reserve_ownership_earo(void)
struct scsi_device *sd2;
int ret;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
ret = mpath_sd2_get_or_clone(sd, &sd2);
CU_ASSERT_EQUAL(ret, 0);
@@ -167,13 +149,7 @@ test_prout_reserve_ownership_wero(void)
struct scsi_device *sd2;
int ret;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
ret = mpath_sd2_get_or_clone(sd, &sd2);
CU_ASSERT_EQUAL(ret, 0);
@@ -190,13 +166,7 @@ test_prout_reserve_ownership_eaar(void)
struct scsi_device *sd2;
int ret;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
ret = mpath_sd2_get_or_clone(sd, &sd2);
CU_ASSERT_EQUAL(ret, 0);
@@ -213,13 +183,7 @@ test_prout_reserve_ownership_wear(void)
struct scsi_device *sd2;
int ret;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This PERSISTENT RESERVE test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
ret = mpath_sd2_get_or_clone(sd, &sd2);
CU_ASSERT_EQUAL(ret, 0);

8
test-tool/test_read10_invalid.c
View File

@@ -38,13 +38,7 @@ test_read10_invalid(void)
logging(LOG_VERBOSE, "Test invalid READ10 commands");
logging(LOG_VERBOSE, "Block size is %zu", block_size);
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This READ10 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
/* Try a read10 of 1 block but xferlength == 0 */
task = malloc(sizeof(struct scsi_task));

8
test-tool/test_read10_residuals.c
View File

@@ -40,13 +40,7 @@ test_read10_residuals(void)
logging(LOG_VERBOSE, "Test READ10 commands with residuals");
logging(LOG_VERBOSE, "Block size is %zu", block_size);
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This READ10 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
/* Try a read10 of 1 block but xferlength == 0 */
task = malloc(sizeof(struct scsi_task));

8
test-tool/test_read12_residuals.c
View File

@@ -36,13 +36,7 @@ test_read12_residuals(void)
logging(LOG_VERBOSE, "Test READ12 commands with residuals");
logging(LOG_VERBOSE, "Block size is %zu", block_size);
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This READ12 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
task = malloc(sizeof(struct scsi_task));
CU_ASSERT_PTR_NOT_NULL_FATAL(task);

8
test-tool/test_read16_residuals.c
View File

@@ -36,13 +36,7 @@ test_read16_residuals(void)
logging(LOG_VERBOSE, "Test READ16 commands with residuals");
logging(LOG_VERBOSE, "Block size is %zu", block_size);
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This READ16 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
task = malloc(sizeof(struct scsi_task));
CU_ASSERT_PTR_NOT_NULL_FATAL(task);

8
test-tool/test_reserve6_2initiators.c
View File

@@ -34,13 +34,7 @@ test_reserve6_2initiators(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test RESERVE6/RELEASE6 across two initiators");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This RESERVE6 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
logging(LOG_NORMAL, "Take out a RESERVE6 from the first initiator");
RESERVE6(sd);

8
test-tool/test_reserve6_itnexus_loss.c
View File

@@ -34,13 +34,7 @@ test_reserve6_itnexus_loss(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test that RESERVE6 is released on it-nexus loss");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This RESERVE6 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
logging(LOG_NORMAL, "Take out a RESERVE6 from the first initiator");
RESERVE6(sd);

8
test-tool/test_reserve6_logout.c
View File

@@ -34,13 +34,7 @@ test_reserve6_logout(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test that RESERVE6 is released on logout");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This RESERVE6 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
logging(LOG_NORMAL, "Take out a RESERVE6 from the first initiator");
RESERVE6(sd);

8
test-tool/test_reserve6_lun_reset.c
View File

@@ -34,13 +34,7 @@ test_reserve6_lun_reset(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test that RESERVE6 is released on lun reset");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This RESERVE6 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, "Take out a RESERVE6 from the first initiator");
RESERVE6(sd);

8
test-tool/test_reserve6_target_cold_reset.c
View File

@@ -34,13 +34,7 @@ test_reserve6_target_cold_reset(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test that RESERVE6 is released on target cold reset");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This RESERVE6 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, "Take out a RESERVE6 from the first initiator");
RESERVE6(sd);

8
test-tool/test_reserve6_target_warm_reset.c
View File

@@ -34,13 +34,7 @@ test_reserve6_target_warm_reset(void)
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test that RESERVE6 is released on target warm reset");
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This RESERVE6 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, "Take out a RESERVE6 from the first initiator");
RESERVE6(sd);

8
test-tool/test_sanitize_block_erase_reserved.c
View File

@@ -57,13 +57,7 @@ void test_sanitize_block_erase_reserved(void)
CHECK_FOR_SANITIZE;
CHECK_FOR_DATALOSS;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
/* override transport queue_pdu callback for PDU manipulation */
iscsi_drv_orig = *sd->iscsi_ctx->drv;

8
test-tool/test_sanitize_crypto_erase_reserved.c
View File

@@ -57,13 +57,7 @@ void test_sanitize_crypto_erase_reserved(void)
CHECK_FOR_SANITIZE;
CHECK_FOR_DATALOSS;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
/* override transport queue_pdu callback for PDU manipulation */
iscsi_drv_orig = *sd->iscsi_ctx->drv;

8
test-tool/test_sanitize_overwrite_reserved.c
View File

@@ -68,13 +68,7 @@ void test_sanitize_overwrite_reserved(void)
CHECK_FOR_SANITIZE;
CHECK_FOR_DATALOSS;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This test is "
"only supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
/* override transport queue_pdu callback for PDU manipulation */
iscsi_drv_orig = *sd->iscsi_ctx->drv;

9
test-tool/test_sanitize_readonly.c
View File

@@ -40,14 +40,7 @@ test_sanitize_readonly(void)
CHECK_FOR_SANITIZE;
CHECK_FOR_DATALOSS;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This SANITIZE test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, "Create a second connection to the target");
ret = mpath_sd2_get_or_clone(sd, &sd2);

9
test-tool/test_sanitize_reservations.c
View File

@@ -40,14 +40,7 @@ test_sanitize_reservations(void)
CHECK_FOR_SANITIZE;
CHECK_FOR_DATALOSS;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This SANITIZE test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, "Create a second connection to the target");
ret = mpath_sd2_get_or_clone(sd, &sd2);

9
test-tool/test_sanitize_reset.c
View File

@@ -45,14 +45,7 @@ test_sanitize_reset(void)
CHECK_FOR_SANITIZE;
CHECK_FOR_DATALOSS;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This SANITIZE test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
logging(LOG_VERBOSE, "Check that SANITIZE OVERWRITE will continue "
"even after Task/Lun/Target/* reset.");

9
test-tool/test_write10_residuals.c
View File

@@ -42,14 +42,7 @@ test_write10_residuals(void)
CHECK_FOR_DATALOSS;
CHECK_FOR_SBC;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This WRITE10 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
/* Try a write10 of 1 block but xferlength == 0 */
task = malloc(sizeof(struct scsi_task));

9
test-tool/test_write12_residuals.c
View File

@@ -42,14 +42,7 @@ test_write12_residuals(void)
CHECK_FOR_DATALOSS;
CHECK_FOR_SBC;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This WRITE12 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
/* Try a write12 of 1 block but xferlength == 0 */
task = malloc(sizeof(struct scsi_task));

9
test-tool/test_write16_residuals.c
View File

@@ -42,14 +42,7 @@ test_write16_residuals(void)
CHECK_FOR_DATALOSS;
CHECK_FOR_SBC;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This WRITE16 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
/* Try a write16 of 1 block but xferlength == 0 */
task = malloc(sizeof(struct scsi_task));

9
test-tool/test_writeverify10_residuals.c
View File

@@ -42,14 +42,7 @@ test_writeverify10_residuals(void)
CHECK_FOR_DATALOSS;
CHECK_FOR_SBC;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This WRITEVERIFY10 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
/* check if writeverify10 is supported */
WRITEVERIFY10(sd, 0, 0, block_size, 0, 0, 0, 0, NULL,

9
test-tool/test_writeverify12_residuals.c
View File

@@ -42,14 +42,7 @@ test_writeverify12_residuals(void)
CHECK_FOR_DATALOSS;
CHECK_FOR_SBC;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This WRITEVERIFY12 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
/* check if writeverify12 is supported */
WRITEVERIFY12(sd, 0, 0, block_size, 0, 0, 0, 0, NULL,

17
test-tool/test_writeverify16_residuals.c
View File

@@ -42,27 +42,12 @@ test_writeverify16_residuals(void)
CHECK_FOR_DATALOSS;
CHECK_FOR_SBC;
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] This WRITEVERIFY16 test is only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
CHECK_FOR_ISCSI(sd);
/* check if writeverify16 is supported */
WRITEVERIFY16(sd, 0, 0, block_size, 0, 0, 1, 0, NULL,
EXPECT_STATUS_GOOD);
if (sd->iscsi_ctx == NULL) {
const char *err = "[SKIPPED] WRITEVERIFY16 tests are only "
"supported for iSCSI backends";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
/* Try a writeverify16 of 1 block but xferlength == 0 */
task = malloc(sizeof(struct scsi_task));
CU_ASSERT_PTR_NOT_NULL_FATAL(task);