diff --git a/Makefile.am b/Makefile.am index 81da850..b497e8e 100644 --- a/Makefile.am +++ b/Makefile.am @@ -155,7 +155,12 @@ bin_iscsi_test_SOURCES = test-tool/iscsi-test.c \ test-tool/1110_persistent_reserve_in_serviceaction_range.c \ test-tool/1120_persistent_register_simple.c \ test-tool/1130_persistent_reserve_simple.c \ - test-tool/1140_persistent_reserve_access_check_ea.c + test-tool/1140_persistent_reserve_access_check_ea.c \ + test-tool/1141_persistent_reserve_access_check_we.c \ + test-tool/1142_persistent_reserve_access_check_earo.c \ + test-tool/1143_persistent_reserve_access_check_wero.c \ + test-tool/1144_persistent_reserve_access_check_eaar.c \ + test-tool/1145_persistent_reserve_access_check_wear.c endif diff --git a/test-tool/1141_persistent_reserve_access_check_we.c b/test-tool/1141_persistent_reserve_access_check_we.c new file mode 100644 index 0000000..db73566 --- /dev/null +++ b/test-tool/1141_persistent_reserve_access_check_we.c @@ -0,0 +1,164 @@ +/* + Copyright (C) 2013 by Lee Duncan + + 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 + +#include "iscsi.h" +#include "scsi-lowlevel.h" +#include "iscsi-test.h" + + +int T1141_persistent_reserve_access_check_we(const char *initiator, + const char *url) +{ + struct iscsi_context *iscsi = NULL, *iscsi2 = NULL; + int ret; + int lun, lun2; + const unsigned long long key = rand_key(); + const unsigned long long key2 = rand_key(); + const enum scsi_persistent_out_type pr_type = + SCSI_PERSISTENT_RESERVE_TYPE_WRITE_EXCLUSIVE; + const char *pr_type_str = scsi_pr_type_str(pr_type); + unsigned char *buf = NULL; + + + printf("1141_persistent_reserve_access_check_we:\n"); + printf("=========================================\n"); + if (show_info) { + int idx = 1; + + printf("Test that access constrols are correct for %s Persistent Reservations\n", + pr_type_str); + printf("%d, %s Reservation Holder Read Access\n", + idx++, pr_type_str); + printf("%d, %s Reservation Holder Write Access\n", + idx++, pr_type_str); + printf("%d, non-%s Reservation Holder does not have read access\n", + idx++, pr_type_str); + printf("%d, non-%s Reservation Holder does not have write access\n", + idx++, pr_type_str); + return 0; + } + + iscsi = iscsi_context_login(initiator, url, &lun); + if (iscsi == NULL) { + printf("Failed to login to target\n"); + ret = -1; + goto finished; + } + iscsi2 = iscsi_context_login(initiatorname2, url, &lun2); + if (iscsi2 == NULL) { + printf("Failed to login to target (2nd initiator)\n"); + ret = -1; + goto finished; + } + + if (!data_loss) { + printf("--dataloss flag is not set. Skipping test\n"); + ret = -2; + goto finished; + } + + /* register our reservation key with the target */ + ret = register_and_ignore(iscsi, lun, key); + if (ret != 0) + goto finished; + ret = register_and_ignore(iscsi2, lun2, key2); + if (ret != 0) + goto finished; + + /* reserve the target through initiator 1 */ + ret = reserve(iscsi, lun, key, pr_type); + if (ret != 0) + goto finished; + + /* verify target reservation */ + ret = verify_reserved_as(iscsi, lun, + pr_type_is_all_registrants(pr_type) ? 0 : key, + pr_type); + if (ret != 0) + goto finished; + + buf = malloc(512); /* allocate a buffer */ + if (buf == NULL) { + printf("failed to allocate 512 byes of memory\n"); + ret = -1; + goto finished; + } + + /* make sure init1 can read */ + ret = verify_read_works(iscsi, lun, buf); + if (ret != 0) + goto finished; + + /* make sure init1 can write */ + ret = verify_write_works(iscsi, lun, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does have read access */ + ret = verify_read_works(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does not have write access */ + ret = verify_write_fails(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* unregister init2 */ + ret = register_key(iscsi2, lun2, 0, key); + if (ret != 0) { + goto finished; + } + + /* make sure init2 does have read access */ + ret = verify_read_works(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does not have write access */ + ret = verify_write_fails(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* release our reservation */ + ret = release(iscsi, lun, key, pr_type); + if (ret != 0) + goto finished; + + /* remove our key from the target */ + ret = register_key(iscsi, lun, 0, key); + if (ret != 0) + goto finished; + +finished: + /* XXX should we clean up key if needed? */ + if (iscsi) { + iscsi_logout_sync(iscsi); + iscsi_destroy_context(iscsi); + } + if (iscsi2) { + iscsi_logout_sync(iscsi2); + iscsi_destroy_context(iscsi2); + } + if (buf) + free(buf); + return ret; +} diff --git a/test-tool/1142_persistent_reserve_access_check_earo.c b/test-tool/1142_persistent_reserve_access_check_earo.c new file mode 100644 index 0000000..90f8af2 --- /dev/null +++ b/test-tool/1142_persistent_reserve_access_check_earo.c @@ -0,0 +1,164 @@ +/* + Copyright (C) 2013 by Lee Duncan + + 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 + +#include "iscsi.h" +#include "scsi-lowlevel.h" +#include "iscsi-test.h" + + +int T1142_persistent_reserve_access_check_earo(const char *initiator, + const char *url) +{ + struct iscsi_context *iscsi = NULL, *iscsi2 = NULL; + int ret; + int lun, lun2; + const unsigned long long key = rand_key(); + const unsigned long long key2 = rand_key(); + const enum scsi_persistent_out_type pr_type = + SCSI_PERSISTENT_RESERVE_TYPE_EXCLUSIVE_ACCESS_REGISTRANTS_ONLY; + const char *pr_type_str = scsi_pr_type_str(pr_type); + unsigned char *buf = NULL; + + + printf("1142_persistent_reserve_access_check_earo:\n"); + printf("=========================================\n"); + if (show_info) { + int idx = 1; + + printf("Test that access constrols are correct for %s Persistent Reservations\n", + pr_type_str); + printf("%d, %s Reservation Holder Read Access\n", + idx++, pr_type_str); + printf("%d, %s Reservation Holder Write Access\n", + idx++, pr_type_str); + printf("%d, non-%s Reservation Holder does not have read access\n", + idx++, pr_type_str); + printf("%d, non-%s Reservation Holder does not have write access\n", + idx++, pr_type_str); + return 0; + } + + iscsi = iscsi_context_login(initiator, url, &lun); + if (iscsi == NULL) { + printf("Failed to login to target\n"); + ret = -1; + goto finished; + } + iscsi2 = iscsi_context_login(initiatorname2, url, &lun2); + if (iscsi2 == NULL) { + printf("Failed to login to target (2nd initiator)\n"); + ret = -1; + goto finished; + } + + if (!data_loss) { + printf("--dataloss flag is not set. Skipping test\n"); + ret = -2; + goto finished; + } + + /* register our reservation key with the target */ + ret = register_and_ignore(iscsi, lun, key); + if (ret != 0) + goto finished; + ret = register_and_ignore(iscsi2, lun2, key2); + if (ret != 0) + goto finished; + + /* reserve the target through initiator 1 */ + ret = reserve(iscsi, lun, key, pr_type); + if (ret != 0) + goto finished; + + /* verify target reservation */ + ret = verify_reserved_as(iscsi, lun, + pr_type_is_all_registrants(pr_type) ? 0 : key, + pr_type); + if (ret != 0) + goto finished; + + buf = malloc(512); /* allocate a buffer */ + if (buf == NULL) { + printf("failed to allocate 512 byes of memory\n"); + ret = -1; + goto finished; + } + + /* make sure init1 can read */ + ret = verify_read_works(iscsi, lun, buf); + if (ret != 0) + goto finished; + + /* make sure init1 can write */ + ret = verify_write_works(iscsi, lun, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does have read access */ + ret = verify_read_works(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does have write access */ + ret = verify_write_works(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* unregister init2 */ + ret = register_key(iscsi2, lun2, 0, key); + if (ret != 0) { + goto finished; + } + + /* make sure init2 does not have read access */ + ret = verify_read_fails(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does not have write access */ + ret = verify_write_fails(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* release our reservation */ + ret = release(iscsi, lun, key, pr_type); + if (ret != 0) + goto finished; + + /* remove our key from the target */ + ret = register_key(iscsi, lun, 0, key); + if (ret != 0) + goto finished; + +finished: + /* XXX should we clean up key if needed? */ + if (iscsi) { + iscsi_logout_sync(iscsi); + iscsi_destroy_context(iscsi); + } + if (iscsi2) { + iscsi_logout_sync(iscsi2); + iscsi_destroy_context(iscsi2); + } + if (buf) + free(buf); + return ret; +} diff --git a/test-tool/1143_persistent_reserve_access_check_wero.c b/test-tool/1143_persistent_reserve_access_check_wero.c new file mode 100644 index 0000000..ac766d9 --- /dev/null +++ b/test-tool/1143_persistent_reserve_access_check_wero.c @@ -0,0 +1,164 @@ +/* + Copyright (C) 2013 by Lee Duncan + + 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 + +#include "iscsi.h" +#include "scsi-lowlevel.h" +#include "iscsi-test.h" + + +int T1143_persistent_reserve_access_check_wero(const char *initiator, + const char *url) +{ + struct iscsi_context *iscsi = NULL, *iscsi2 = NULL; + int ret; + int lun, lun2; + const unsigned long long key = rand_key(); + const unsigned long long key2 = rand_key(); + const enum scsi_persistent_out_type pr_type = + SCSI_PERSISTENT_RESERVE_TYPE_WRITE_EXCLUSIVE_REGISTRANTS_ONLY; + const char *pr_type_str = scsi_pr_type_str(pr_type); + unsigned char *buf = NULL; + + + printf("1143_persistent_reserve_access_check_wero:\n"); + printf("=========================================\n"); + if (show_info) { + int idx = 1; + + printf("Test that access constrols are correct for %s Persistent Reservations\n", + pr_type_str); + printf("%d, %s Reservation Holder Read Access\n", + idx++, pr_type_str); + printf("%d, %s Reservation Holder Write Access\n", + idx++, pr_type_str); + printf("%d, non-%s Reservation Holder does not have read access\n", + idx++, pr_type_str); + printf("%d, non-%s Reservation Holder does not have write access\n", + idx++, pr_type_str); + return 0; + } + + iscsi = iscsi_context_login(initiator, url, &lun); + if (iscsi == NULL) { + printf("Failed to login to target\n"); + ret = -1; + goto finished; + } + iscsi2 = iscsi_context_login(initiatorname2, url, &lun2); + if (iscsi2 == NULL) { + printf("Failed to login to target (2nd initiator)\n"); + ret = -1; + goto finished; + } + + if (!data_loss) { + printf("--dataloss flag is not set. Skipping test\n"); + ret = -2; + goto finished; + } + + /* register our reservation key with the target */ + ret = register_and_ignore(iscsi, lun, key); + if (ret != 0) + goto finished; + ret = register_and_ignore(iscsi2, lun2, key2); + if (ret != 0) + goto finished; + + /* reserve the target through initiator 1 */ + ret = reserve(iscsi, lun, key, pr_type); + if (ret != 0) + goto finished; + + /* verify target reservation */ + ret = verify_reserved_as(iscsi, lun, + pr_type_is_all_registrants(pr_type) ? 0 : key, + pr_type); + if (ret != 0) + goto finished; + + buf = malloc(512); /* allocate a buffer */ + if (buf == NULL) { + printf("failed to allocate 512 byes of memory\n"); + ret = -1; + goto finished; + } + + /* make sure init1 can read */ + ret = verify_read_works(iscsi, lun, buf); + if (ret != 0) + goto finished; + + /* make sure init1 can write */ + ret = verify_write_works(iscsi, lun, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does have read access */ + ret = verify_read_works(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does have write access */ + ret = verify_write_works(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* unregister init2 */ + ret = register_key(iscsi2, lun2, 0, key); + if (ret != 0) { + goto finished; + } + + /* make sure init2 does have read access */ + ret = verify_read_works(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does not have write access */ + ret = verify_write_fails(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* release our reservation */ + ret = release(iscsi, lun, key, pr_type); + if (ret != 0) + goto finished; + + /* remove our key from the target */ + ret = register_key(iscsi, lun, 0, key); + if (ret != 0) + goto finished; + +finished: + /* XXX should we clean up key if needed? */ + if (iscsi) { + iscsi_logout_sync(iscsi); + iscsi_destroy_context(iscsi); + } + if (iscsi2) { + iscsi_logout_sync(iscsi2); + iscsi_destroy_context(iscsi2); + } + if (buf) + free(buf); + return ret; +} diff --git a/test-tool/1144_persistent_reserve_access_check_eaar.c b/test-tool/1144_persistent_reserve_access_check_eaar.c new file mode 100644 index 0000000..511172c --- /dev/null +++ b/test-tool/1144_persistent_reserve_access_check_eaar.c @@ -0,0 +1,164 @@ +/* + Copyright (C) 2013 by Lee Duncan + + 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 + +#include "iscsi.h" +#include "scsi-lowlevel.h" +#include "iscsi-test.h" + + +int T1144_persistent_reserve_access_check_eaar(const char *initiator, + const char *url) +{ + struct iscsi_context *iscsi = NULL, *iscsi2 = NULL; + int ret; + int lun, lun2; + const unsigned long long key = rand_key(); + const unsigned long long key2 = rand_key(); + const enum scsi_persistent_out_type pr_type = + SCSI_PERSISTENT_RESERVE_TYPE_EXCLUSIVE_ACCESS_ALL_REGISTRANTS; + const char *pr_type_str = scsi_pr_type_str(pr_type); + unsigned char *buf = NULL; + + + printf("1144_persistent_reserve_access_check_eaar:\n"); + printf("=========================================\n"); + if (show_info) { + int idx = 1; + + printf("Test that access constrols are correct for %s Persistent Reservations\n", + pr_type_str); + printf("%d, %s Reservation Holder Read Access\n", + idx++, pr_type_str); + printf("%d, %s Reservation Holder Write Access\n", + idx++, pr_type_str); + printf("%d, non-%s Reservation Holder does not have read access\n", + idx++, pr_type_str); + printf("%d, non-%s Reservation Holder does not have write access\n", + idx++, pr_type_str); + return 0; + } + + iscsi = iscsi_context_login(initiator, url, &lun); + if (iscsi == NULL) { + printf("Failed to login to target\n"); + ret = -1; + goto finished; + } + iscsi2 = iscsi_context_login(initiatorname2, url, &lun2); + if (iscsi2 == NULL) { + printf("Failed to login to target (2nd initiator)\n"); + ret = -1; + goto finished; + } + + if (!data_loss) { + printf("--dataloss flag is not set. Skipping test\n"); + ret = -2; + goto finished; + } + + /* register our reservation key with the target */ + ret = register_and_ignore(iscsi, lun, key); + if (ret != 0) + goto finished; + ret = register_and_ignore(iscsi2, lun2, key2); + if (ret != 0) + goto finished; + + /* reserve the target through initiator 1 */ + ret = reserve(iscsi, lun, key, pr_type); + if (ret != 0) + goto finished; + + /* verify target reservation */ + ret = verify_reserved_as(iscsi, lun, + pr_type_is_all_registrants(pr_type) ? 0 : key, + pr_type); + if (ret != 0) + goto finished; + + buf = malloc(512); /* allocate a buffer */ + if (buf == NULL) { + printf("failed to allocate 512 byes of memory\n"); + ret = -1; + goto finished; + } + + /* make sure init1 can read */ + ret = verify_read_works(iscsi, lun, buf); + if (ret != 0) + goto finished; + + /* make sure init1 can write */ + ret = verify_write_works(iscsi, lun, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does have read access */ + ret = verify_read_works(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does have write access */ + ret = verify_write_works(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* unregister init2 */ + ret = register_key(iscsi2, lun2, 0, key); + if (ret != 0) { + goto finished; + } + + /* make sure init2 does not have read access */ + ret = verify_read_fails(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does not have write access */ + ret = verify_write_fails(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* release our reservation */ + ret = release(iscsi, lun, key, pr_type); + if (ret != 0) + goto finished; + + /* remove our key from the target */ + ret = register_key(iscsi, lun, 0, key); + if (ret != 0) + goto finished; + +finished: + /* XXX should we clean up key if needed? */ + if (iscsi) { + iscsi_logout_sync(iscsi); + iscsi_destroy_context(iscsi); + } + if (iscsi2) { + iscsi_logout_sync(iscsi2); + iscsi_destroy_context(iscsi2); + } + if (buf) + free(buf); + return ret; +} diff --git a/test-tool/1145_persistent_reserve_access_check_wear.c b/test-tool/1145_persistent_reserve_access_check_wear.c new file mode 100644 index 0000000..36f9af0 --- /dev/null +++ b/test-tool/1145_persistent_reserve_access_check_wear.c @@ -0,0 +1,164 @@ +/* + Copyright (C) 2013 by Lee Duncan + + 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 + +#include "iscsi.h" +#include "scsi-lowlevel.h" +#include "iscsi-test.h" + + +int T1145_persistent_reserve_access_check_wear(const char *initiator, + const char *url) +{ + struct iscsi_context *iscsi = NULL, *iscsi2 = NULL; + int ret; + int lun, lun2; + const unsigned long long key = rand_key(); + const unsigned long long key2 = rand_key(); + const enum scsi_persistent_out_type pr_type = + SCSI_PERSISTENT_RESERVE_TYPE_WRITE_EXCLUSIVE_ALL_REGISTRANTS; + const char *pr_type_str = scsi_pr_type_str(pr_type); + unsigned char *buf = NULL; + + + printf("1145_persistent_reserve_access_check_wear:\n"); + printf("=========================================\n"); + if (show_info) { + int idx = 1; + + printf("Test that access constrols are correct for %s Persistent Reservations\n", + pr_type_str); + printf("%d, %s Reservation Holder Read Access\n", + idx++, pr_type_str); + printf("%d, %s Reservation Holder Write Access\n", + idx++, pr_type_str); + printf("%d, non-%s Reservation Holder does not have read access\n", + idx++, pr_type_str); + printf("%d, non-%s Reservation Holder does not have write access\n", + idx++, pr_type_str); + return 0; + } + + iscsi = iscsi_context_login(initiator, url, &lun); + if (iscsi == NULL) { + printf("Failed to login to target\n"); + ret = -1; + goto finished; + } + iscsi2 = iscsi_context_login(initiatorname2, url, &lun2); + if (iscsi2 == NULL) { + printf("Failed to login to target (2nd initiator)\n"); + ret = -1; + goto finished; + } + + if (!data_loss) { + printf("--dataloss flag is not set. Skipping test\n"); + ret = -2; + goto finished; + } + + /* register our reservation key with the target */ + ret = register_and_ignore(iscsi, lun, key); + if (ret != 0) + goto finished; + ret = register_and_ignore(iscsi2, lun2, key2); + if (ret != 0) + goto finished; + + /* reserve the target through initiator 1 */ + ret = reserve(iscsi, lun, key, pr_type); + if (ret != 0) + goto finished; + + /* verify target reservation */ + ret = verify_reserved_as(iscsi, lun, + pr_type_is_all_registrants(pr_type) ? 0 : key, + pr_type); + if (ret != 0) + goto finished; + + buf = malloc(512); /* allocate a buffer */ + if (buf == NULL) { + printf("failed to allocate 512 byes of memory\n"); + ret = -1; + goto finished; + } + + /* make sure init1 can read */ + ret = verify_read_works(iscsi, lun, buf); + if (ret != 0) + goto finished; + + /* make sure init1 can write */ + ret = verify_write_works(iscsi, lun, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does have read access */ + ret = verify_read_works(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does have write access */ + ret = verify_write_works(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* unregister init2 */ + ret = register_key(iscsi2, lun2, 0, key); + if (ret != 0) { + goto finished; + } + + /* make sure init2 does have read access */ + ret = verify_read_works(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* make sure init2 does not have write access */ + ret = verify_write_fails(iscsi2, lun2, buf); + if (ret != 0) + goto finished; + + /* release our reservation */ + ret = release(iscsi, lun, key, pr_type); + if (ret != 0) + goto finished; + + /* remove our key from the target */ + ret = register_key(iscsi, lun, 0, key); + if (ret != 0) + goto finished; + +finished: + /* XXX should we clean up key if needed? */ + if (iscsi) { + iscsi_logout_sync(iscsi); + iscsi_destroy_context(iscsi); + } + if (iscsi2) { + iscsi_logout_sync(iscsi2); + iscsi_destroy_context(iscsi2); + } + if (buf) + free(buf); + return ret; +} diff --git a/test-tool/iscsi-test.c b/test-tool/iscsi-test.c index 3eee800..0028216 100644 --- a/test-tool/iscsi-test.c +++ b/test-tool/iscsi-test.c @@ -270,6 +270,11 @@ struct scsi_test tests[] = { { "T1120_persistent_register_simple", T1120_persistent_register_simple }, { "T1130_persistent_reserve_simple", T1130_persistent_reserve_simple }, { "T1140_persistent_reserve_access_check_ea", T1140_persistent_reserve_access_check_ea }, +{ "T1141_persistent_reserve_access_check_we", T1141_persistent_reserve_access_check_we }, +{ "T1142_persistent_reserve_access_check_earo", T1142_persistent_reserve_access_check_earo }, +{ "T1143_persistent_reserve_access_check_wero", T1143_persistent_reserve_access_check_wero }, +{ "T1144_persistent_reserve_access_check_eaar", T1144_persistent_reserve_access_check_eaar }, +{ "T1145_persistent_reserve_access_check_wear", T1145_persistent_reserve_access_check_wear }, { NULL, NULL } }; diff --git a/test-tool/iscsi-test.h b/test-tool/iscsi-test.h index 25400eb..23bb019 100644 --- a/test-tool/iscsi-test.h +++ b/test-tool/iscsi-test.h @@ -210,6 +210,11 @@ int T1110_persistent_reserve_in_serviceaction_range(const char *initiator, const int T1120_persistent_register_simple(const char *initiator, const char *url); int T1130_persistent_reserve_simple(const char *initiator, const char *url); int T1140_persistent_reserve_access_check_ea(const char *initiator, const char *url); +int T1141_persistent_reserve_access_check_we(const char *initiator, const char *url); +int T1142_persistent_reserve_access_check_earo(const char *initiator, const char *url); +int T1143_persistent_reserve_access_check_wero(const char *initiator, const char *url); +int T1144_persistent_reserve_access_check_eaar(const char *initiator, const char *url); +int T1145_persistent_reserve_access_check_wear(const char *initiator, const char *url); /*