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

Merge pull request #301 from ddiss/iscsi_sendtargets_nop

Browse Source 
test-tool: add iSCSI SendTargets, Nop-Out and CHAP auth tests
This commit is contained in:
Ronnie Sahlberg
2019-09-27 13:32:15 -07:00
committed by GitHub
parent f36b936db1 84d80878a6
commit 101c1a5835
48 changed files with 656 additions and 365 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
include/iscsi-private.h
View File

@@ -288,10 +288,10 @@ void iscsi_pdu_set_datasn(struct iscsi_pdu *pdu, uint32_t datasn);
void iscsi_pdu_set_bufferoffset(struct iscsi_pdu *pdu, uint32_t bufferoffset);
void iscsi_cancel_pdus(struct iscsi_context *iscsi);
int iscsi_pdu_add_data(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
unsigned char *dptr, int dsize);
const unsigned char *dptr, int dsize);
int iscsi_queue_pdu(struct iscsi_context *iscsi, struct iscsi_pdu *pdu);
int iscsi_add_data(struct iscsi_context *iscsi, struct iscsi_data *data,
unsigned char *dptr, int dsize, int pdualignment);
const unsigned char *dptr, int dsize, int pdualignment);
struct scsi_task;
void iscsi_pdu_set_cdb(struct iscsi_pdu *pdu, struct scsi_task *task);

4
lib/pdu.c
View File

@@ -169,7 +169,7 @@ iscsi_tcp_free_pdu(struct iscsi_context *iscsi, struct iscsi_pdu *pdu)
int
iscsi_add_data(struct iscsi_context *iscsi, struct iscsi_data *data,
unsigned char *dptr, int dsize, int pdualignment)
const unsigned char *dptr, int dsize, int pdualignment)
{
size_t len, aligned;
@@ -216,7 +216,7 @@ iscsi_add_data(struct iscsi_context *iscsi, struct iscsi_data *data,
int
iscsi_pdu_add_data(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
unsigned char *dptr, int dsize)
const unsigned char *dptr, int dsize)
{
if (pdu == NULL) {
iscsi_set_error(iscsi, "trying to add data to NULL pdu");

3
test-tool/Makefile.am
View File

@@ -40,6 +40,9 @@ iscsi_test_cu_SOURCES = iscsi-test-cu.c \
test_iscsi_cmdsn_toohigh.c \
test_iscsi_cmdsn_toolow.c \
test_iscsi_datasn_invalid.c \
test_iscsi_sendtargets.c \
test_iscsi_nop_simple.c \
test_iscsi_chap.c \
test_mandatory_sbc.c \
test_modesense6_all_pages.c \
test_modesense6_control.c \

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

@@ -186,6 +186,16 @@ do { \
} \
} while (0);
#define CHECK_FOR_ISCSI(_sd) \
do { \
if (_sd->iscsi_ctx == NULL) { \
logging(LOG_NORMAL, "[SKIPPED] Not an iSCSI device." \
" Skipping test"); \
CU_PASS("[SKIPPED] Not an iSCSI device. Skipping test"); \
return; \
} \
} while (0);
#define CHECK_SIZE(_min_blocks, _c) \
do { \
if (num_blocks < _min_blocks) { \

26
test-tool/iscsi-test-cu.c
View File

@@ -558,6 +558,23 @@ static CU_TestInfo tests_iscsi_datasn[] = {
CU_TEST_INFO_NULL
};
static CU_TestInfo tests_iscsi_sendtargets[] = {
{ (char *)"Simple", test_iscsi_sendtargets_simple },
{ (char *)"Invalid", test_iscsi_sendtargets_invalid },
CU_TEST_INFO_NULL
};
static CU_TestInfo tests_iscsi_nop[] = {
{ (char *)"Simple", test_iscsi_nop_simple },
CU_TEST_INFO_NULL
};
static CU_TestInfo tests_iscsi_chap[] = {
{ (char *)"Simple", test_iscsi_chap_simple },
{ (char *)"Invalid", test_iscsi_chap_invalid },
CU_TEST_INFO_NULL
};
static CU_TestInfo tests_iscsi_residuals[] = {
{ (char *)"Read10Invalid", test_read10_invalid },
{ (char *)"Read10Residuals", test_read10_residuals },
@@ -588,6 +605,12 @@ static libiscsi_suite_info iscsi_suites[] = {
tests_iscsi_residuals },
{ "iSCSITMF", NON_PGR_FUNCS,
tests_iscsi_tmf },
{ "iSCSISendTargets", NON_PGR_FUNCS,
tests_iscsi_sendtargets },
{ "iSCSINop", NON_PGR_FUNCS,
tests_iscsi_nop },
{ "iSCSICHAP", NON_PGR_FUNCS,
tests_iscsi_chap },
{ NULL, NULL, NULL, NULL, NULL, NULL }
};
@@ -645,6 +668,9 @@ static libiscsi_suite_info all_suites[] = {
{ "iSCSIdatasn", NON_PGR_FUNCS, tests_iscsi_datasn },
{ "iSCSIResiduals", NON_PGR_FUNCS, tests_iscsi_residuals },
{ "iSCSITMF", NON_PGR_FUNCS, tests_iscsi_tmf },
{ "iSCSISendTargets", NON_PGR_FUNCS, tests_iscsi_sendtargets },
{ "iSCSINop", NON_PGR_FUNCS, tests_iscsi_nop },
{ "iSCSICHAP", NON_PGR_FUNCS, tests_iscsi_chap },
{ "MultipathIO", NON_PGR_FUNCS, tests_multipathio },
{ NULL, NULL, NULL, NULL, NULL, NULL },
};

5
test-tool/iscsi-test-cu.h
View File

@@ -78,6 +78,11 @@ void test_iscsi_cmdsn_toohigh(void);
void test_iscsi_cmdsn_toolow(void);
void test_iscsi_datasn_invalid(void);
void test_iscsi_sendtargets_simple(void);
void test_iscsi_sendtargets_invalid(void);
void test_iscsi_nop_simple(void);
void test_iscsi_chap_simple(void);
void test_iscsi_chap_invalid(void);
void test_mandatory_sbc(void);

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;

221
test-tool/test_iscsi_chap.c Normal file
View File

@@ -0,0 +1,221 @@
/*
Copyright (C) 2019 SUSE LLC
Copyright (C) 2013 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#define _GNU_SOURCE
#include <stdio.h>
#include <arpa/inet.h>
#include <CUnit/CUnit.h>
#include <poll.h>
#include <string.h>
#include <assert.h>
#include <string.h>
#include "iscsi.h"
#include "iscsi-private.h"
#include "scsi-lowlevel.h"
#include "iscsi-test-cu.h"
static struct iscsi_transport iscsi_drv_orig;
static int
test_iscsi_strip_tag(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
const char *tag)
{
unsigned char *s;
unsigned char *end;
size_t remain;
size_t toklen;
toklen = strlen(tag);
if ((toklen < 2) || (tag[toklen - 1] != '=')) {
return -EINVAL;
}
s = memmem(pdu->outdata.data, pdu->outdata.size, tag, toklen);
if (s == NULL) {
return -ENOENT;
}
remain = pdu->outdata.size - (s - pdu->outdata.data);
if ((remain == 0) || (remain > pdu->outdata.size)) {
return -EINVAL;
}
end = memchr(s, 0, remain);
if (end == NULL) {
return -EINVAL;
}
toklen = end - s;
assert(toklen > 0);
/* handle padding */
while ((toklen < remain) && (s[toklen] == '\0')) {
toklen++;
}
memmove(s, s + toklen, remain - toklen);
pdu->outdata.size -= toklen;
/* update data segment length */
scsi_set_uint32(&pdu->outdata.data[4], pdu->outdata.size
- ISCSI_HEADER_SIZE(iscsi->header_digest));
logging(LOG_VERBOSE, "stripped %s key and value from PDU", tag);
return 0;
}
static int
chap_mod_strip_replace_queue(struct iscsi_context *iscsi, struct iscsi_pdu *pdu,
const char *new_chap_a)
{
int ret;
if ((pdu->outdata.data[0] & 0x3f) != ISCSI_PDU_LOGIN_REQUEST) {
goto out;
}
ret = test_iscsi_strip_tag(iscsi, pdu, "CHAP_A=");
if (ret == -ENOENT) {
logging(LOG_VERBOSE, "ignoring login PDU without CHAP_A");
goto out;;
}
if (ret < 0) {
return ret;
}
ret = iscsi_pdu_add_data(iscsi, pdu, (const unsigned char *)new_chap_a,
strlen(new_chap_a) + 1);
if (ret < 0) {
return ret;
}
logging(LOG_VERBOSE, "replaced Login PDU CHAP_A setting with %s", new_chap_a);
/* restore drv */
*iscsi->drv = iscsi_drv_orig;
out:
return iscsi_drv_orig.queue_pdu(iscsi, pdu);
}
static int
chap_mod_many_types_queue(struct iscsi_context *iscsi, struct iscsi_pdu *pdu)
{
return chap_mod_strip_replace_queue(iscsi, pdu, "CHAP_A=5,6,7,8");
}
static int
chap_mod_no_type_queue(struct iscsi_context *iscsi, struct iscsi_pdu *pdu)
{
return chap_mod_strip_replace_queue(iscsi, pdu, "CHAP_A=");
}
static int
chap_mod_bad_type_queue(struct iscsi_context *iscsi, struct iscsi_pdu *pdu)
{
/* value starts with '5', to catch targets that only check one byte */
return chap_mod_strip_replace_queue(iscsi, pdu, "CHAP_A=56");
}
static int
test_iscsi_chap_login(int (*test_queue_pdu)(struct iscsi_context *iscsi,
struct iscsi_pdu *pdu))
{
struct iscsi_context *iscsi;
struct iscsi_url *iscsi_url;
int ret;
iscsi = iscsi_create_context(initiatorname2);
if (iscsi == NULL) {
return -ENOMEM;
}
iscsi_url = iscsi_parse_full_url(iscsi, sd->iscsi_url);
if (iscsi_url == NULL) {
ret = -ENOMEM;
goto err_iscsi_destroy;
}
iscsi_set_targetname(iscsi, iscsi_url->target);
iscsi_set_session_type(iscsi, ISCSI_SESSION_NORMAL);
iscsi_set_header_digest(iscsi, ISCSI_HEADER_DIGEST_NONE_CRC32C);
iscsi_set_noautoreconnect(iscsi, 1);
iscsi_set_initiator_username_pwd(iscsi, iscsi_url->user,
iscsi_url->passwd);
/* override transport queue_pdu callback for PDU manipulation */
iscsi_drv_orig = *iscsi->drv;
iscsi->drv->queue_pdu = test_queue_pdu;
ret = iscsi_full_connect_sync(iscsi, iscsi_url->portal, iscsi_url->lun);
if (ret < 0) {
ret = -EIO;
goto err_url_destroy;
}
ret = 0;
err_url_destroy:
iscsi_destroy_url(iscsi_url);
/* XXX no need to restore iscsi_drv_orig */
err_iscsi_destroy:
iscsi_destroy_context(iscsi);
return ret;
}
void
test_iscsi_chap_simple(void)
{
int ret;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test CHAP_A negotiation");
CHECK_FOR_ISCSI(sd);
if (sd->iscsi_ctx->chap_a != 5) {
const char *err = "[SKIPPED] This test requires "
"an iSCSI session with CHAP_A=5";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
ret = test_iscsi_chap_login(chap_mod_many_types_queue);
CU_ASSERT_EQUAL(ret, 0);
}
void
test_iscsi_chap_invalid(void)
{
int ret;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test CHAP_A negotiation");
CHECK_FOR_ISCSI(sd);
if (sd->iscsi_ctx->chap_a != 5) {
const char *err = "[SKIPPED] This test requires "
"an iSCSI session with CHAP_A=5";
logging(LOG_NORMAL, "%s", err);
CU_PASS(err);
return;
}
ret = test_iscsi_chap_login(chap_mod_bad_type_queue);
CU_ASSERT_EQUAL(ret, -EIO);
ret = test_iscsi_chap_login(chap_mod_no_type_queue);
CU_ASSERT_EQUAL(ret, -EIO);
}

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;

109
test-tool/test_iscsi_nop_simple.c Normal file
View File

@@ -0,0 +1,109 @@
/*
Copyright (C) 2019 SUSE LLC
Copyright (C) 2013 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <arpa/inet.h>
#include <CUnit/CUnit.h>
#include <poll.h>
#include "iscsi.h"
#include "iscsi-private.h"
#include "scsi-lowlevel.h"
#include "iscsi-test-cu.h"
struct test_iscsi_nop_state {
int dispatched;
int completed;
char nop_buf[1024];
size_t nop_datalen;
};
static int
test_iscsi_nop_txrx(struct test_iscsi_nop_state *state)
{
while (state->completed < state->dispatched) {
struct pollfd pfd;
int ret;
pfd.fd = iscsi_get_fd(sd->iscsi_ctx);
pfd.events = iscsi_which_events(sd->iscsi_ctx);
ret = poll(&pfd, 1, -1);
if (ret < 0) {
return ret;
}
ret = iscsi_service(sd->iscsi_ctx, pfd.revents);
if (ret != 0) {
return ret;
}
}
return 0;
}
static void
test_iscsi_nop_cb(struct iscsi_context *iscsi _U_, int status,
void *command_data, void *private_data)
{
struct test_iscsi_nop_state *state = private_data;
struct iscsi_data *data = command_data;
CU_ASSERT_EQUAL(status, 0);
CU_ASSERT_PTR_NOT_NULL(data);
CU_ASSERT_EQUAL_FATAL(state->nop_datalen, data->size);
if (state->nop_datalen > 0) {
CU_ASSERT_EQUAL(0, memcmp(state->nop_buf, data->data,
state->nop_datalen));
}
state->completed++;
}
void
test_iscsi_nop_simple(void)
{
struct test_iscsi_nop_state state;
int ret;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test Nop Out Pings");
CHECK_FOR_ISCSI(sd);
memset(&state, 0, sizeof(state));
strncpy(state.nop_buf, "nopping", sizeof(state.nop_buf));
state.nop_datalen = strlen(state.nop_buf) + 1;
ret = iscsi_nop_out_async(sd->iscsi_ctx, test_iscsi_nop_cb,
(unsigned char *)state.nop_buf,
state.nop_datalen, &state);
CU_ASSERT_EQUAL(ret, 0);
state.dispatched++;
ret = test_iscsi_nop_txrx(&state);
CU_ASSERT_EQUAL(ret, 0);
/* no data */
state.nop_datalen = 0;
ret = iscsi_nop_out_async(sd->iscsi_ctx, test_iscsi_nop_cb,
NULL, state.nop_datalen, &state);
CU_ASSERT_EQUAL(ret, 0);
state.dispatched++;
ret = test_iscsi_nop_txrx(&state);
CU_ASSERT_EQUAL(ret, 0);
}

223
test-tool/test_iscsi_sendtargets.c Normal file
View File

@@ -0,0 +1,223 @@
/*
Copyright (C) 2019 SUSE LLC
Copyright (C) 2013 by Ronnie Sahlberg <ronniesahlberg@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, see <http://www.gnu.org/licenses/>.
*/
#include <stdio.h>
#include <stdbool.h>
#include <arpa/inet.h>
#include <CUnit/CUnit.h>
#include <poll.h>
#include "iscsi.h"
#include "iscsi-private.h"
#include "scsi-lowlevel.h"
#include "iscsi-test-cu.h"
struct test_iscsi_sendtargets_state {
int dispatched;
int completed;
int failed;
int succeeded;
bool expect_failure;
};
static int
test_iscsi_sendtargets_txrx(struct test_iscsi_sendtargets_state *state)
{
while (state->completed < state->dispatched) {
struct pollfd pfd;
int ret;
pfd.fd = iscsi_get_fd(sd->iscsi_ctx);
pfd.events = iscsi_which_events(sd->iscsi_ctx);
ret = poll(&pfd, 1, -1);
if (ret < 0) {
return ret;
}
ret = iscsi_service(sd->iscsi_ctx, pfd.revents);
if (ret != 0) {
return ret;
}
}
return 0;
}
static void
test_iscsi_sendtargets_cb(struct iscsi_context *iscsi _U_, int status,
void *command_data _U_, void *private_data)
{
struct test_iscsi_sendtargets_state *state = private_data;
state->completed++;
if (state->expect_failure) {
CU_ASSERT_NOT_EQUAL(status, 0);
} else {
CU_ASSERT_EQUAL(status, 0);
}
if (status != 0) {
logging(LOG_VERBOSE, "non-zero Text response %d",
state->completed);
state->failed++;
return;
}
state->succeeded++;
logging(LOG_VERBOSE, "zero Text response %d", state->completed);
}
static void
test_iscsi_sendtargets_simple_cb(struct iscsi_context *iscsi, int status,
void *command_data, void *private_data)
{
struct iscsi_discovery_address *da;
test_iscsi_sendtargets_cb(iscsi, status, command_data, private_data);
for (da = command_data; da != NULL; da = da->next) {
struct iscsi_target_portal *po;
logging(LOG_VERBOSE, "Target: %s", da->target_name);
for (po = da->portals; po != NULL; po = po->next) {
logging(LOG_VERBOSE, "+ Portal: %s", po->portal);
}
}
}
void
test_iscsi_sendtargets_simple(void)
{
struct test_iscsi_sendtargets_state state;
int ret;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test SendTargets in FFP");
CHECK_FOR_ISCSI(sd);
memset(&state, 0, sizeof(state));
ret = iscsi_discovery_async(sd->iscsi_ctx,
test_iscsi_sendtargets_simple_cb, &state);
CU_ASSERT_EQUAL(ret, 0);
state.dispatched++;
state.expect_failure = false;
ret = test_iscsi_sendtargets_txrx(&state);
CU_ASSERT_EQUAL(ret, 0);
CU_ASSERT_EQUAL(state.failed, 0);
CU_ASSERT_EQUAL(state.succeeded, 1);
}
int
test_iscsi_text_req_queue(struct iscsi_context *iscsi,
const char *kv_data,
iscsi_command_cb cb,
struct test_iscsi_sendtargets_state *state)
{
struct iscsi_pdu *pdu;
int ret;
pdu = iscsi_allocate_pdu(iscsi, ISCSI_PDU_TEXT_REQUEST,
ISCSI_PDU_TEXT_RESPONSE,
iscsi_itt_post_increment(iscsi),
ISCSI_PDU_DROP_ON_RECONNECT);
CU_ASSERT_PTR_NOT_NULL_FATAL(pdu);
iscsi_pdu_set_immediate(pdu);
iscsi_pdu_set_cmdsn(pdu, iscsi->cmdsn);
iscsi_pdu_set_pduflags(pdu, ISCSI_PDU_TEXT_FINAL);
iscsi_pdu_set_ttt(pdu, 0xffffffff);
ret = iscsi_pdu_add_data(iscsi, pdu, (unsigned char *)kv_data,
strlen(kv_data) + 1);
CU_ASSERT_EQUAL_FATAL(ret, 0);
pdu->callback = cb;
pdu->private_data = state;
ret = iscsi_queue_pdu(iscsi, pdu);
CU_ASSERT_EQUAL_FATAL(ret, 0);
state->dispatched++;
logging(LOG_VERBOSE, "queued Text request %d with %s",
state->dispatched, kv_data);
return 0;
}
void
test_iscsi_sendtargets_invalid(void)
{
struct test_iscsi_sendtargets_state state;
int ret;
logging(LOG_VERBOSE, LOG_BLANK_LINE);
logging(LOG_VERBOSE, "Test invalid SendTargets Text requests");
CHECK_FOR_ISCSI(sd);
memset(&state, 0, sizeof(state));
ret = test_iscsi_text_req_queue(sd->iscsi_ctx,
"SendTargetsPlease=All", /* bad key */
test_iscsi_sendtargets_cb,
&state);
CU_ASSERT_EQUAL(ret, 0);
state.expect_failure = true;
ret = test_iscsi_sendtargets_txrx(&state);
CU_ASSERT_EQUAL(ret, 0);
ret = test_iscsi_text_req_queue(sd->iscsi_ctx,
"SendTargets=Alle", /* bad val */
test_iscsi_sendtargets_cb,
&state);
CU_ASSERT_EQUAL(ret, 0);
state.expect_failure = true;
ret = test_iscsi_sendtargets_txrx(&state);
CU_ASSERT_EQUAL(ret, 0);
ret = test_iscsi_text_req_queue(sd->iscsi_ctx,
"SendTargets=A", /* bad val */
test_iscsi_sendtargets_cb,
&state);
CU_ASSERT_EQUAL(ret, 0);
state.expect_failure = true;
ret = test_iscsi_sendtargets_txrx(&state);
CU_ASSERT_EQUAL(ret, 0);
ret = test_iscsi_text_req_queue(sd->iscsi_ctx,
"sENDtARGETS=aLL", /* bad case */
test_iscsi_sendtargets_cb,
&state);
CU_ASSERT_EQUAL(ret, 0);
state.expect_failure = true;
ret = test_iscsi_sendtargets_txrx(&state);
CU_ASSERT_EQUAL(ret, 0);
ret = test_iscsi_text_req_queue(sd->iscsi_ctx,
"SendTargets=All", /* valid */
test_iscsi_sendtargets_cb,
&state);
CU_ASSERT_EQUAL(ret, 0);
state.expect_failure = false;
ret = test_iscsi_sendtargets_txrx(&state);
CU_ASSERT_EQUAL(ret, 0);
CU_ASSERT_EQUAL(state.failed, 4);
CU_ASSERT_EQUAL(state.succeeded, 1);
}

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);