From 0d5c8a4f1147277bfc2b97eacb1ce25f39a13d3f Mon Sep 17 00:00:00 2001 From: Ronnie Sahlberg Date: Sun, 3 Mar 2013 13:37:52 -0800 Subject: [PATCH] TESTS: Add test for PREVENTALLOWMEDIUMREMOVAL are cleared on lun/target reset --- Makefile.am | 5 ++ include/iscsi.h | 27 +++++++ lib/libiscsi.def | 6 ++ lib/libiscsi.syms | 6 ++ lib/sync.c | 75 +++++++++++++++++++ test-tool/iscsi-test-cu.c | 5 ++ test-tool/iscsi-test-cu.h | 5 ++ test-tool/test_preventallow_cold_reset.c | 80 +++++++++++++++++++++ test-tool/test_preventallow_itnexus_loss.c | 83 ++++++++++++++++++++++ test-tool/test_preventallow_logout.c | 83 ++++++++++++++++++++++ test-tool/test_preventallow_lun_reset.c | 80 +++++++++++++++++++++ test-tool/test_preventallow_warm_reset.c | 80 +++++++++++++++++++++ 12 files changed, 535 insertions(+) create mode 100644 test-tool/test_preventallow_cold_reset.c create mode 100644 test-tool/test_preventallow_itnexus_loss.c create mode 100644 test-tool/test_preventallow_logout.c create mode 100644 test-tool/test_preventallow_lun_reset.c create mode 100644 test-tool/test_preventallow_warm_reset.c diff --git a/Makefile.am b/Makefile.am index 538b946..4b08b22 100644 --- a/Makefile.am +++ b/Makefile.am @@ -205,6 +205,11 @@ bin_iscsi_test_cu_SOURCES = test-tool/iscsi-test-cu.c \ test-tool/test_prefetch16_flags.c \ test-tool/test_preventallow_simple.c \ test-tool/test_preventallow_eject.c \ + test-tool/test_preventallow_itnexus_loss.c \ + test-tool/test_preventallow_logout.c \ + test-tool/test_preventallow_warm_reset.c \ + test-tool/test_preventallow_cold_reset.c \ + test-tool/test_preventallow_lun_reset.c \ test-tool/test_prin_read_keys_simple.c \ test-tool/test_prin_serviceaction_range.c \ test-tool/test_prout_register_simple.c \ diff --git a/include/iscsi.h b/include/iscsi.h index 26b1d24..98cdf5d 100644 --- a/include/iscsi.h +++ b/include/iscsi.h @@ -550,6 +550,33 @@ iscsi_task_mgmt_target_cold_reset_async(struct iscsi_context *iscsi, +/* + * Synchronous calls for task management + * + * Returns: + * 0 success. + * <0 error. + */ +EXTERN int +iscsi_task_mgmt_sync(struct iscsi_context *iscsi, + int lun, enum iscsi_task_mgmt_funcs function, + uint32_t ritt, uint32_t rcmdscn); + +EXTERN int +iscsi_task_mgmt_abort_task_sync(struct iscsi_context *iscsi, struct scsi_task *task); + +EXTERN int +iscsi_task_mgmt_abort_task_set_sync(struct iscsi_context *iscsi, uint32_t lun); + +EXTERN int +iscsi_task_mgmt_lun_reset_sync(struct iscsi_context *iscsi, uint32_t lun); + +EXTERN int +iscsi_task_mgmt_target_warm_reset_sync(struct iscsi_context *iscsi); + +EXTERN int +iscsi_task_mgmt_target_cold_reset_sync(struct iscsi_context *iscsi); + diff --git a/lib/libiscsi.def b/lib/libiscsi.def index 127c611..b50c145 100644 --- a/lib/libiscsi.def +++ b/lib/libiscsi.def @@ -97,11 +97,17 @@ iscsi_synchronizecache10_task iscsi_synchronizecache16_sync iscsi_synchronizecache16_task iscsi_task_mgmt_abort_task_async +iscsi_task_mgmt_abort_task_sync iscsi_task_mgmt_abort_task_set_async +iscsi_task_mgmt_abort_task_set_sync iscsi_task_mgmt_async +iscsi_task_mgmt_sync iscsi_task_mgmt_lun_reset_async +iscsi_task_mgmt_lun_reset_sync iscsi_task_mgmt_target_cold_reset_async +iscsi_task_mgmt_target_cold_reset_sync iscsi_task_mgmt_target_warm_reset_async +iscsi_task_mgmt_target_warm_reset_sync iscsi_testunitready_sync iscsi_testunitready_task iscsi_unmap_sync diff --git a/lib/libiscsi.syms b/lib/libiscsi.syms index 80673f5..a7ab6cb 100644 --- a/lib/libiscsi.syms +++ b/lib/libiscsi.syms @@ -95,11 +95,17 @@ iscsi_synchronizecache10_task iscsi_synchronizecache16_sync iscsi_synchronizecache16_task iscsi_task_mgmt_abort_task_async +iscsi_task_mgmt_abort_task_sync iscsi_task_mgmt_abort_task_set_async +iscsi_task_mgmt_abort_task_set_sync iscsi_task_mgmt_async +iscsi_task_mgmt_sync iscsi_task_mgmt_lun_reset_async +iscsi_task_mgmt_lun_reset_sync iscsi_task_mgmt_target_cold_reset_async +iscsi_task_mgmt_target_cold_reset_sync iscsi_task_mgmt_target_warm_reset_async +iscsi_task_mgmt_target_warm_reset_sync iscsi_testunitready_sync iscsi_testunitready_task iscsi_unmap_sync diff --git a/lib/sync.c b/lib/sync.c index a9e0e90..5736a37 100644 --- a/lib/sync.c +++ b/lib/sync.c @@ -157,6 +157,81 @@ int iscsi_logout_sync(struct iscsi_context *iscsi) return state.status; } +int +iscsi_task_mgmt_sync(struct iscsi_context *iscsi, + int lun, enum iscsi_task_mgmt_funcs function, + uint32_t ritt, uint32_t rcmdsn) +{ + struct iscsi_sync_state state; + + memset(&state, 0, sizeof(state)); + + if (iscsi_task_mgmt_async(iscsi, lun, function, + ritt, rcmdsn, + iscsi_sync_cb, &state) != 0) { + iscsi_set_error(iscsi, "Failed to send TASK MGMT function: %s", + iscsi_get_error(iscsi)); + return -1; + } + + event_loop(iscsi, &state); + + return state.status; +} + +int +iscsi_task_mgmt_abort_task_sync(struct iscsi_context *iscsi, + struct scsi_task *task) +{ + iscsi_scsi_cancel_task(iscsi, task); + + return iscsi_task_mgmt_sync(iscsi, task->lun, + ISCSI_TM_ABORT_TASK, + task->itt, task->cmdsn); +} + +int +iscsi_task_mgmt_abort_task_set_sync(struct iscsi_context *iscsi, + uint32_t lun) +{ + iscsi_scsi_cancel_all_tasks(iscsi); + + return iscsi_task_mgmt_sync(iscsi, lun, + ISCSI_TM_ABORT_TASK_SET, + 0xffffffff, 0); +} + +int +iscsi_task_mgmt_lun_reset_sync(struct iscsi_context *iscsi, + uint32_t lun) +{ + iscsi_scsi_cancel_all_tasks(iscsi); + + return iscsi_task_mgmt_sync(iscsi, lun, + ISCSI_TM_LUN_RESET, + 0xffffffff, 0); +} + +int +iscsi_task_mgmt_target_warm_reset_sync(struct iscsi_context *iscsi) +{ + iscsi_scsi_cancel_all_tasks(iscsi); + + return iscsi_task_mgmt_sync(iscsi, 0, + ISCSI_TM_TARGET_WARM_RESET, + 0xffffffff, 0); +} + + +int +iscsi_task_mgmt_target_cold_reset_sync(struct iscsi_context *iscsi) +{ + iscsi_scsi_cancel_all_tasks(iscsi); + + return iscsi_task_mgmt_sync(iscsi, 0, + ISCSI_TM_TARGET_COLD_RESET, + 0xffffffff, 0); +} /* diff --git a/test-tool/iscsi-test-cu.c b/test-tool/iscsi-test-cu.c index 9006a35..c7ec9e2 100644 --- a/test-tool/iscsi-test-cu.c +++ b/test-tool/iscsi-test-cu.c @@ -100,6 +100,11 @@ static CU_TestInfo tests_prefetch16[] = { static CU_TestInfo tests_preventallow[] = { { (char *)"testPreventAllowSimple", test_preventallow_simple }, { (char *)"testPreventAllowEject", test_preventallow_eject }, + { (char *)"testPreventAllowITNexusLoss", test_preventallow_itnexus_loss }, + { (char *)"testPreventAllowLogout", test_preventallow_logout }, + { (char *)"testPreventAllowWarmReset", test_preventallow_warm_reset }, + { (char *)"testPreventAllowColdReset", test_preventallow_cold_reset }, + { (char *)"testPreventAllowLUNReset", test_preventallow_lun_reset }, CU_TEST_INFO_NULL }; diff --git a/test-tool/iscsi-test-cu.h b/test-tool/iscsi-test-cu.h index 63dc8eb..d69493c 100644 --- a/test-tool/iscsi-test-cu.h +++ b/test-tool/iscsi-test-cu.h @@ -64,6 +64,11 @@ void test_prefetch16_flags(void); void test_preventallow_simple(void); void test_preventallow_eject(void); +void test_preventallow_itnexus_loss(void); +void test_preventallow_logout(void); +void test_preventallow_warm_reset(void); +void test_preventallow_cold_reset(void); +void test_preventallow_lun_reset(void); void test_prin_read_keys_simple(void); void test_prin_serviceaction_range(void); diff --git a/test-tool/test_preventallow_cold_reset.c b/test-tool/test_preventallow_cold_reset.c new file mode 100644 index 0000000..817b841 --- /dev/null +++ b/test-tool/test_preventallow_cold_reset.c @@ -0,0 +1,80 @@ +/* + Copyright (C) 2013 by Ronnie Sahlberg + + 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 . +*/ + +#include + +#include + +#include "iscsi.h" +#include "scsi-lowlevel.h" +#include "iscsi-support.h" +#include "iscsi-test-cu.h" + +void +test_preventallow_cold_reset(void) +{ + int ret; + + CHECK_FOR_SBC; + CHECK_FOR_REMOVABLE; + + logging(LOG_VERBOSE, LOG_BLANK_LINE); + logging(LOG_VERBOSE, "Test that Target Warm Reset clears PREVENT MEDIUM REMOVAL"); + + logging(LOG_VERBOSE, "Set the PREVENT flag"); + ret = preventallow(iscsic, tgt_lun, 1); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Try to eject the medium"); + ret = startstopunit_preventremoval(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Verify we can still access the media."); + ret = testunitready(iscsic, tgt_lun); + CU_ASSERT_EQUAL(ret, 0); + + + logging(LOG_VERBOSE, "Perform cold reset on target"); + ret = iscsi_task_mgmt_target_cold_reset_sync(iscsic); + logging(LOG_VERBOSE, "Wait until all unit attentions clear"); + while (testunitready(iscsic, tgt_lun) != 0); + CU_ASSERT_EQUAL(ret, 0); + + + logging(LOG_VERBOSE, "Try to eject the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Verify we can not access the media."); + ret = testunitready_nomedium(iscsic, tgt_lun); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Load the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + + logging(LOG_VERBOSE, "Clear PREVENT and load medium in case target failed"); + logging(LOG_VERBOSE, "Test we can clear PREVENT flag"); + ret = preventallow(iscsic, tgt_lun, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Load the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 1); + CU_ASSERT_EQUAL(ret, 0); + +} diff --git a/test-tool/test_preventallow_itnexus_loss.c b/test-tool/test_preventallow_itnexus_loss.c new file mode 100644 index 0000000..3c108a8 --- /dev/null +++ b/test-tool/test_preventallow_itnexus_loss.c @@ -0,0 +1,83 @@ +/* + Copyright (C) 2013 by Ronnie Sahlberg + + 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 . +*/ + +#include + +#include + +#include "iscsi.h" +#include "scsi-lowlevel.h" +#include "iscsi-support.h" +#include "iscsi-test-cu.h" + +void +test_preventallow_itnexus_loss(void) +{ + int ret; + + CHECK_FOR_SBC; + CHECK_FOR_REMOVABLE; + + logging(LOG_VERBOSE, LOG_BLANK_LINE); + logging(LOG_VERBOSE, "Test that IT-Nexus loss clears PREVENT MEDIUM REMOVAL"); + + logging(LOG_VERBOSE, "Set the PREVENT flag"); + ret = preventallow(iscsic, tgt_lun, 1); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Try to eject the medium"); + ret = startstopunit_preventremoval(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Verify we can still access the media."); + ret = testunitready(iscsic, tgt_lun); + CU_ASSERT_EQUAL(ret, 0); + + + logging(LOG_VERBOSE, "Disconnect from the target."); + iscsi_destroy_context(iscsic); + + logging(LOG_VERBOSE, "Reconnect to target"); + iscsic = iscsi_context_login(initiatorname1, tgt_url, &tgt_lun); + if (iscsic == NULL) { + logging(LOG_VERBOSE, "Failed to login to target"); + return; + } + + logging(LOG_VERBOSE, "Try to eject the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Verify we can not access the media."); + ret = testunitready_nomedium(iscsic, tgt_lun); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Load the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + + logging(LOG_VERBOSE, "Clear PREVENT and load medium in case target failed"); + logging(LOG_VERBOSE, "Test we can clear PREVENT flag"); + ret = preventallow(iscsic, tgt_lun, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Load the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 1); + CU_ASSERT_EQUAL(ret, 0); + +} diff --git a/test-tool/test_preventallow_logout.c b/test-tool/test_preventallow_logout.c new file mode 100644 index 0000000..0c336cd --- /dev/null +++ b/test-tool/test_preventallow_logout.c @@ -0,0 +1,83 @@ +/* + Copyright (C) 2013 by Ronnie Sahlberg + + 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 . +*/ + +#include + +#include + +#include "iscsi.h" +#include "scsi-lowlevel.h" +#include "iscsi-support.h" +#include "iscsi-test-cu.h" + +void +test_preventallow_logout(void) +{ + int ret; + + CHECK_FOR_SBC; + CHECK_FOR_REMOVABLE; + + logging(LOG_VERBOSE, LOG_BLANK_LINE); + logging(LOG_VERBOSE, "Test that Logout loss clears PREVENT MEDIUM REMOVAL"); + + logging(LOG_VERBOSE, "Set the PREVENT flag"); + ret = preventallow(iscsic, tgt_lun, 1); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Try to eject the medium"); + ret = startstopunit_preventremoval(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Verify we can still access the media."); + ret = testunitready(iscsic, tgt_lun); + CU_ASSERT_EQUAL(ret, 0); + + + logging(LOG_VERBOSE, "Logout from target"); + iscsi_logout_sync(iscsic); + + logging(LOG_VERBOSE, "Relogin to target"); + iscsic = iscsi_context_login(initiatorname1, tgt_url, &tgt_lun); + if (iscsic == NULL) { + logging(LOG_VERBOSE, "Failed to login to target"); + return; + } + + logging(LOG_VERBOSE, "Try to eject the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Verify we can not access the media."); + ret = testunitready_nomedium(iscsic, tgt_lun); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Load the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + + logging(LOG_VERBOSE, "Clear PREVENT and load medium in case target failed"); + logging(LOG_VERBOSE, "Test we can clear PREVENT flag"); + ret = preventallow(iscsic, tgt_lun, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Load the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 1); + CU_ASSERT_EQUAL(ret, 0); + +} diff --git a/test-tool/test_preventallow_lun_reset.c b/test-tool/test_preventallow_lun_reset.c new file mode 100644 index 0000000..fa1aa03 --- /dev/null +++ b/test-tool/test_preventallow_lun_reset.c @@ -0,0 +1,80 @@ +/* + Copyright (C) 2013 by Ronnie Sahlberg + + 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 . +*/ + +#include + +#include + +#include "iscsi.h" +#include "scsi-lowlevel.h" +#include "iscsi-support.h" +#include "iscsi-test-cu.h" + +void +test_preventallow_lun_reset(void) +{ + int ret; + + CHECK_FOR_SBC; + CHECK_FOR_REMOVABLE; + + logging(LOG_VERBOSE, LOG_BLANK_LINE); + logging(LOG_VERBOSE, "Test that Target Warm Reset clears PREVENT MEDIUM REMOVAL"); + + logging(LOG_VERBOSE, "Set the PREVENT flag"); + ret = preventallow(iscsic, tgt_lun, 1); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Try to eject the medium"); + ret = startstopunit_preventremoval(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Verify we can still access the media."); + ret = testunitready(iscsic, tgt_lun); + CU_ASSERT_EQUAL(ret, 0); + + + logging(LOG_VERBOSE, "Perform LUN reset on target"); + ret = iscsi_task_mgmt_lun_reset_sync(iscsic, tgt_lun); + CU_ASSERT_EQUAL(ret, 0); + logging(LOG_VERBOSE, "Wait until all unit attentions clear"); + while (testunitready(iscsic, tgt_lun) != 0); + + + logging(LOG_VERBOSE, "Try to eject the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Verify we can not access the media."); + ret = testunitready_nomedium(iscsic, tgt_lun); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Load the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + + logging(LOG_VERBOSE, "Clear PREVENT and load medium in case target failed"); + logging(LOG_VERBOSE, "Test we can clear PREVENT flag"); + ret = preventallow(iscsic, tgt_lun, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Load the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 1); + CU_ASSERT_EQUAL(ret, 0); + +} diff --git a/test-tool/test_preventallow_warm_reset.c b/test-tool/test_preventallow_warm_reset.c new file mode 100644 index 0000000..7f9edc3 --- /dev/null +++ b/test-tool/test_preventallow_warm_reset.c @@ -0,0 +1,80 @@ +/* + Copyright (C) 2013 by Ronnie Sahlberg + + 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 . +*/ + +#include + +#include + +#include "iscsi.h" +#include "scsi-lowlevel.h" +#include "iscsi-support.h" +#include "iscsi-test-cu.h" + +void +test_preventallow_warm_reset(void) +{ + int ret; + + CHECK_FOR_SBC; + CHECK_FOR_REMOVABLE; + + logging(LOG_VERBOSE, LOG_BLANK_LINE); + logging(LOG_VERBOSE, "Test that Target Warm Reset clears PREVENT MEDIUM REMOVAL"); + + logging(LOG_VERBOSE, "Set the PREVENT flag"); + ret = preventallow(iscsic, tgt_lun, 1); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Try to eject the medium"); + ret = startstopunit_preventremoval(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Verify we can still access the media."); + ret = testunitready(iscsic, tgt_lun); + CU_ASSERT_EQUAL(ret, 0); + + + logging(LOG_VERBOSE, "Perform warm reset on target"); + ret = iscsi_task_mgmt_target_warm_reset_sync(iscsic); + CU_ASSERT_EQUAL(ret, 0); + logging(LOG_VERBOSE, "Wait until all unit attentions clear"); + while (testunitready(iscsic, tgt_lun) != 0); + + + logging(LOG_VERBOSE, "Try to eject the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Verify we can not access the media."); + ret = testunitready_nomedium(iscsic, tgt_lun); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Load the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 0); + CU_ASSERT_EQUAL(ret, 0); + + + logging(LOG_VERBOSE, "Clear PREVENT and load medium in case target failed"); + logging(LOG_VERBOSE, "Test we can clear PREVENT flag"); + ret = preventallow(iscsic, tgt_lun, 0); + CU_ASSERT_EQUAL(ret, 0); + + logging(LOG_VERBOSE, "Load the medium"); + ret = startstopunit(iscsic, tgt_lun, 0, 0, 0, 0, 1, 1); + CU_ASSERT_EQUAL(ret, 0); + +}