void test_prout_reserve_simple(void) { int ret = 0; int i; const unsigned long long key = rand_key(); logging(LOG_VERBOSE, LOG_BLANK_LINE); logging(LOG_VERBOSE, "Test Persistent Reserve IN RESERVE works."); /* register our reservation key with the target */ ret = prout_register_and_ignore(sd, key); if (ret == -2) { CU_PASS("PERSISTENT RESERVE OUT is not implemented."); return; } CU_ASSERT_EQUAL(ret, 0); /* test each reservatoin type */ for (i = 0; pr_types_to_test[i] != 0; i++) { enum scsi_persistent_out_type pr_type = pr_types_to_test[i]; /* reserve the target */ ret = prout_reserve(sd, key, pr_type); CU_ASSERT_EQUAL(ret, 0); /* verify target reservation */ ret = prin_verify_reserved_as(sd, pr_type_is_all_registrants(pr_type) ? 0 : key, pr_type); CU_ASSERT_EQUAL(ret, 0); /* release our reservation */ ret = prout_release(sd, key, pr_type); CU_ASSERT_EQUAL(ret, 0); } /* remove our key from the target */ ret = prout_register_key(sd, 0, key); CU_ASSERT_EQUAL(ret, 0); }
static void verify_persistent_reserve_access(struct scsi_device *sd1, struct scsi_device *sd2, const enum scsi_persistent_out_type pr_type, int reg_i2_can_read, int reg_i2_can_write, int unreg_i2_can_read, int unreg_i2_can_write) { int ret; const unsigned long long key = rand_key(); const unsigned long long key2 = rand_key(); logging(LOG_VERBOSE, LOG_BLANK_LINE); logging(LOG_VERBOSE, "Verify access for reservation type: %s", scsi_pr_type_str(pr_type)); /* send TURs to clear possible check conditions */ (void) testunitready_clear_ua(sd1); (void) testunitready_clear_ua(sd2); /* register our reservation key with the target */ ret = prout_register_and_ignore(sd1, key); if (ret == -2) { CU_PASS("PERSISTENT RESERVE OUT is not implemented."); return; } CU_ASSERT_EQUAL(0, ret); ret = prout_register_and_ignore(sd2, key2); CU_ASSERT_EQUAL(0, ret); /* reserve the target through initiator 1 */ ret = prout_reserve(sd1, key, pr_type); CU_ASSERT_EQUAL(0, ret); /* verify target reservation */ ret = prin_verify_reserved_as(sd1, pr_type_is_all_registrants(pr_type) ? 0 : key, pr_type); CU_ASSERT_EQUAL(0, ret); CU_ASSERT_PTR_NOT_NULL_FATAL(scratch); /* make sure init1 can read */ ret = verify_read_works(sd1, scratch); CU_ASSERT_EQUAL(0, ret); /* make sure init1 can write */ ret = verify_write_works(sd1, scratch); CU_ASSERT_EQUAL(0, ret); /* verify registered init2 read access */ if (reg_i2_can_read) ret = verify_read_works(sd2, scratch); else ret = verify_read_fails(sd2, scratch); CU_ASSERT_EQUAL(0, ret); /* verify registered init2 write access */ if (reg_i2_can_write) ret = verify_write_works(sd2, scratch); else ret = verify_write_fails(sd2, scratch); CU_ASSERT_EQUAL(0, ret); /* unregister init2 */ ret = prout_register_key(sd2, 0, key2); CU_ASSERT_EQUAL(0, ret); /* verify unregistered init2 read access */ if (unreg_i2_can_read) ret = verify_read_works(sd2, scratch); else ret = verify_read_fails(sd2, scratch); CU_ASSERT_EQUAL(0, ret); /* verify unregistered init2 write access */ if (unreg_i2_can_write) ret = verify_write_works(sd2, scratch); else ret = verify_write_fails(sd2, scratch); CU_ASSERT_EQUAL(0, ret); /* release our reservation */ ret = prout_release(sd1, key, pr_type); CU_ASSERT_EQUAL(0, ret); /* remove our key from the target */ ret = prout_register_key(sd1, 0, key); CU_ASSERT_EQUAL(0, ret); }
static void verify_persistent_reserve_ownership(struct scsi_device *sd1, struct scsi_device *sd2, const enum scsi_persistent_out_type pr_type, int resvn_is_shared) { int ret; const unsigned long long key1 = rand_key(); const unsigned long long key2 = rand_key(); logging(LOG_VERBOSE, LOG_BLANK_LINE); logging(LOG_VERBOSE, "Verify ownership for reservation type: %s", scsi_pr_type_str(pr_type)); /* send TURs to clear possible check conditions */ (void) testunitready_clear_ua(sd1); (void) testunitready_clear_ua(sd2); /* register our reservation key with the target */ ret = prout_register_and_ignore(sd1, key1); if (ret == -2) { logging(LOG_NORMAL, "[SKIPPED] PERSISTEN RESERVE OUT is not implemented."); CU_PASS("PERSISTENT RESERVE OUT is not implemented."); return; } CU_ASSERT_EQUAL(0, ret); ret = prout_register_and_ignore(sd2, key2); CU_ASSERT_EQUAL(0, ret); /* reserve the target through initiator 1 */ ret = prout_reserve(sd1, key1, pr_type); CU_ASSERT_EQUAL(0, ret); /* verify target reservation */ ret = prin_verify_reserved_as(sd1, pr_type_is_all_registrants(pr_type) ? 0 : key1, pr_type); CU_ASSERT_EQUAL(0, ret); /* unregister init1 */ ret = prout_register_key(sd1, 0, key1); CU_ASSERT_EQUAL(0, ret); /* verify if reservation is still present */ if (resvn_is_shared) { /* verify target reservation */ ret = prin_verify_reserved_as(sd1, pr_type_is_all_registrants(pr_type) ? 0 : key1, pr_type); CU_ASSERT_EQUAL(0, ret); /* release our reservation */ ret = prout_release(sd2, key2, pr_type); CU_ASSERT_EQUAL(0, ret); } else { /* verify target is not reserved now */ ret = prin_verify_not_reserved(sd1); CU_ASSERT_EQUAL(0, ret); /* send TUR to clear possible check condition */ (void) testunitready_clear_ua(sd2); } /* remove our remaining key from the target */ ret = prout_register_key(sd2, 0, key2); CU_ASSERT_EQUAL(0, ret); }
void test_prin_report_caps_simple(void) { int ret = 0; const unsigned long long key = rand_key(); struct scsi_task *tsk; struct scsi_persistent_reserve_in_report_capabilities *rcaps; struct test_prin_report_caps_types *type; CHECK_FOR_DATALOSS; logging(LOG_VERBOSE, LOG_BLANK_LINE); logging(LOG_VERBOSE, "Test Persistent Reserve In REPORT CAPABILITIES works."); /* register our reservation key with the target */ ret = prout_register_and_ignore(sd, key); if (ret == -2) { logging(LOG_NORMAL, "[SKIPPED] PERSISTENT RESERVE OUT is not implemented."); CU_PASS("PERSISTENT RESERVE OUT is not implemented."); return; } CU_ASSERT_EQUAL(ret, 0); ret = prin_report_caps(sd, &tsk, &rcaps); CU_ASSERT_EQUAL(ret, 0); logging(LOG_VERBOSE, "Checking PERSISTENT RESERVE IN REPORT CAPABILITIES fields."); CU_ASSERT_EQUAL(rcaps->length, 8); CU_ASSERT_TRUE(rcaps->allow_commands <= 5); CU_ASSERT_EQUAL(rcaps->persistent_reservation_type_mask & ~SCSI_PR_TYPE_MASK_ALL, 0); for (type = &report_caps_types_array[0]; type->mask != 0; type++) { if (!(rcaps->persistent_reservation_type_mask & type->mask)) { logging(LOG_NORMAL, "PERSISTENT RESERVE op 0x%x not supported", type->op); continue; } logging(LOG_VERBOSE, "PERSISTENT RESERVE OUT op 0x%x supported, testing", type->op); /* reserve the target */ ret = prout_reserve(sd, key, type->op); CU_ASSERT_EQUAL(ret, 0); /* verify target reservation */ ret = prin_verify_reserved_as(sd, pr_type_is_all_registrants(type->op) ? 0 : key, type->op); CU_ASSERT_EQUAL(0, ret); /* release the target */ ret = prout_release(sd, key, type->op); CU_ASSERT_EQUAL(ret, 0); } scsi_free_scsi_task(tsk); rcaps = NULL; /* freed with tsk */ /* drop registration */ ret = prout_register_key(sd, 0, key); CU_ASSERT_EQUAL(ret, 0); }
void test_prout_clear_simple(void) { int ret = 0; uint32_t old_gen; const unsigned long long key = rand_key(); struct scsi_task *tsk; struct scsi_persistent_reserve_in_read_keys *rk = NULL; CHECK_FOR_DATALOSS; logging(LOG_VERBOSE, LOG_BLANK_LINE); logging(LOG_VERBOSE, "Test Persistent Reserve OUT CLEAR works."); /* register our reservation key with the target */ ret = prout_register_and_ignore(sd, key); if (ret == -2) { CU_PASS("PERSISTENT RESERVE OUT is not implemented."); return; } CU_ASSERT_EQUAL(ret, 0); ret = prin_read_keys(sd, &tsk, &rk, 16384); CU_ASSERT_EQUAL(ret, 0); CU_ASSERT_NOT_EQUAL(rk, NULL); if (!rk) goto out; CU_ASSERT_NOT_EQUAL(rk->num_keys, 0); /* retain PR generation number to check for increments */ old_gen = rk->prgeneration; scsi_free_scsi_task(tsk); rk = NULL; /* freed with tsk */ /* reserve the target */ ret = prout_reserve(sd, key, SCSI_PERSISTENT_RESERVE_TYPE_EXCLUSIVE_ACCESS); CU_ASSERT_EQUAL(ret, 0); /* verify target reservation */ ret = prin_verify_reserved_as(sd, key, SCSI_PERSISTENT_RESERVE_TYPE_EXCLUSIVE_ACCESS); CU_ASSERT_EQUAL(ret, 0); /* clear reservation and registration */ ret = prout_clear(sd, key); CU_ASSERT_EQUAL(ret, 0); ret = prin_verify_not_reserved(sd); CU_ASSERT_EQUAL(ret, 0); ret = prin_read_keys(sd, &tsk, &rk, 16384); CU_ASSERT_EQUAL(ret, 0); CU_ASSERT_NOT_EQUAL(rk, NULL); if (!rk) goto out; CU_ASSERT_EQUAL(rk->num_keys, 0); /* generation incremented once for CLEAR (not for RESERVE) */ CU_ASSERT_EQUAL(rk->prgeneration, old_gen + 1); out: scsi_free_scsi_task(tsk); rk = NULL; /* freed with tsk */ }