ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

lib/scsi: Remove spdk prefix from private functions

Browse Source 
Signed-off-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Change-Id: I89aa5dc10150cff74a420ccf8c3842bd12e84f3c
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/1825
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Changpeng Liu <changpeng.liu@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
This commit is contained in:
Shuhei Matsumoto 2020-04-13 23:56:12 +09:00 committed by Tomasz Zawadzki
parent 18dec40111
commit 33a2974768
3 changed files with 161 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

192
lib/scsi/scsi_pr.c
View File

@ -37,9 +37,9 @@
/* Get registrant by I_T nexus */ /* Get registrant by I_T nexus */
static struct spdk_scsi_pr_registrant * static struct spdk_scsi_pr_registrant *
spdk_scsi_pr_get_registrant(struct spdk_scsi_lun *lun, scsi_pr_get_registrant(struct spdk_scsi_lun *lun,
struct spdk_scsi_port *initiator_port, struct spdk_scsi_port *initiator_port,
struct spdk_scsi_port *target_port) struct spdk_scsi_port *target_port)
{ {
struct spdk_scsi_pr_registrant *reg, *tmp; struct spdk_scsi_pr_registrant *reg, *tmp;
@ -55,7 +55,7 @@ spdk_scsi_pr_get_registrant(struct spdk_scsi_lun *lun,
/* Reservation type is all registrants or not */ /* Reservation type is all registrants or not */
static inline bool static inline bool
spdk_scsi_pr_is_all_registrants_type(struct spdk_scsi_lun *lun) scsi_pr_is_all_registrants_type(struct spdk_scsi_lun *lun)
{ {
return (lun->reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS || return (lun->reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS ||
lun->reservation.rtype == SPDK_SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS); lun->reservation.rtype == SPDK_SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS);
@ -63,10 +63,10 @@ spdk_scsi_pr_is_all_registrants_type(struct spdk_scsi_lun *lun)
/* Registrant is reservation holder or not */ /* Registrant is reservation holder or not */
static inline bool static inline bool
spdk_scsi_pr_registrant_is_holder(struct spdk_scsi_lun *lun, scsi_pr_registrant_is_holder(struct spdk_scsi_lun *lun,
struct spdk_scsi_pr_registrant *reg) struct spdk_scsi_pr_registrant *reg)
{ {
if (spdk_scsi_pr_is_all_registrants_type(lun)) { if (scsi_pr_is_all_registrants_type(lun)) {
return true; return true;
} }
@ -75,16 +75,16 @@ spdk_scsi_pr_registrant_is_holder(struct spdk_scsi_lun *lun,
/* LUN holds a reservation or not */ /* LUN holds a reservation or not */
static inline bool static inline bool
spdk_scsi_pr_has_reservation(struct spdk_scsi_lun *lun) scsi_pr_has_reservation(struct spdk_scsi_lun *lun)
{ {
return !(lun->reservation.holder == NULL); return !(lun->reservation.holder == NULL);
} }
static int static int
spdk_scsi_pr_register_registrant(struct spdk_scsi_lun *lun, scsi_pr_register_registrant(struct spdk_scsi_lun *lun,
struct spdk_scsi_port *initiator_port, struct spdk_scsi_port *initiator_port,
struct spdk_scsi_port *target_port, struct spdk_scsi_port *target_port,
uint64_t sa_rkey) uint64_t sa_rkey)
{ {
struct spdk_scsi_pr_registrant *reg; struct spdk_scsi_pr_registrant *reg;
@ -119,7 +119,7 @@ spdk_scsi_pr_register_registrant(struct spdk_scsi_lun *lun,
} }
static void static void
spdk_scsi_pr_release_reservation(struct spdk_scsi_lun *lun, struct spdk_scsi_pr_registrant *reg) scsi_pr_release_reservation(struct spdk_scsi_lun *lun, struct spdk_scsi_pr_registrant *reg)
{ {
bool all_regs = false; bool all_regs = false;
@ -127,7 +127,7 @@ spdk_scsi_pr_release_reservation(struct spdk_scsi_lun *lun, struct spdk_scsi_pr_
"with type %u\n", lun->reservation.rtype); "with type %u\n", lun->reservation.rtype);
/* TODO: Unit Attention */ /* TODO: Unit Attention */
all_regs = spdk_scsi_pr_is_all_registrants_type(lun); all_regs = scsi_pr_is_all_registrants_type(lun);
if (all_regs && !TAILQ_EMPTY(&lun->reg_head)) { if (all_regs && !TAILQ_EMPTY(&lun->reg_head)) {
lun->reservation.holder = TAILQ_FIRST(&lun->reg_head); lun->reservation.holder = TAILQ_FIRST(&lun->reg_head);
return; return;
@ -137,10 +137,10 @@ spdk_scsi_pr_release_reservation(struct spdk_scsi_lun *lun, struct spdk_scsi_pr_
} }
static void static void
spdk_scsi_pr_reserve_reservation(struct spdk_scsi_lun *lun, scsi_pr_reserve_reservation(struct spdk_scsi_lun *lun,
enum spdk_scsi_pr_type_code type, enum spdk_scsi_pr_type_code type,
uint64_t rkey, uint64_t rkey,
struct spdk_scsi_pr_registrant *holder) struct spdk_scsi_pr_registrant *holder)
{ {
lun->reservation.rtype = type; lun->reservation.rtype = type;
lun->reservation.crkey = rkey; lun->reservation.crkey = rkey;
@ -148,14 +148,14 @@ spdk_scsi_pr_reserve_reservation(struct spdk_scsi_lun *lun,
} }
static void static void
spdk_scsi_pr_unregister_registrant(struct spdk_scsi_lun *lun, scsi_pr_unregister_registrant(struct spdk_scsi_lun *lun,
struct spdk_scsi_pr_registrant *reg) struct spdk_scsi_pr_registrant *reg)
{ {
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "REGISTER: unregister registrant\n"); SPDK_DEBUGLOG(SPDK_LOG_SCSI, "REGISTER: unregister registrant\n");
TAILQ_REMOVE(&lun->reg_head, reg, link); TAILQ_REMOVE(&lun->reg_head, reg, link);
if (spdk_scsi_pr_registrant_is_holder(lun, reg)) { if (scsi_pr_registrant_is_holder(lun, reg)) {
spdk_scsi_pr_release_reservation(lun, reg); scsi_pr_release_reservation(lun, reg);
} }
free(reg); free(reg);
@ -163,9 +163,9 @@ spdk_scsi_pr_unregister_registrant(struct spdk_scsi_lun *lun,
} }
static void static void
spdk_scsi_pr_replace_registrant_key(struct spdk_scsi_lun *lun, scsi_pr_replace_registrant_key(struct spdk_scsi_lun *lun,
struct spdk_scsi_pr_registrant *reg, struct spdk_scsi_pr_registrant *reg,
uint64_t sa_rkey) uint64_t sa_rkey)
{ {
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "REGISTER: replace with new " SPDK_DEBUGLOG(SPDK_LOG_SCSI, "REGISTER: replace with new "
"reservation key 0x%"PRIx64"\n", sa_rkey); "reservation key 0x%"PRIx64"\n", sa_rkey);
@ -174,9 +174,9 @@ spdk_scsi_pr_replace_registrant_key(struct spdk_scsi_lun *lun,
} }
static int static int
spdk_scsi_pr_out_reserve(struct spdk_scsi_task *task, scsi_pr_out_reserve(struct spdk_scsi_task *task,
enum spdk_scsi_pr_type_code rtype, uint64_t rkey, enum spdk_scsi_pr_type_code rtype, uint64_t rkey,
uint8_t spec_i_pt, uint8_t all_tg_pt, uint8_t aptpl) uint8_t spec_i_pt, uint8_t all_tg_pt, uint8_t aptpl)
{ {
struct spdk_scsi_lun *lun = task->lun; struct spdk_scsi_lun *lun = task->lun;
struct spdk_scsi_pr_registrant *reg; struct spdk_scsi_pr_registrant *reg;
@ -195,7 +195,7 @@ spdk_scsi_pr_out_reserve(struct spdk_scsi_task *task,
return -EINVAL; return -EINVAL;
} }
reg = spdk_scsi_pr_get_registrant(lun, task->initiator_port, task->target_port); reg = scsi_pr_get_registrant(lun, task->initiator_port, task->target_port);
/* No registration for the I_T nexus */ /* No registration for the I_T nexus */
if (!reg) { if (!reg) {
SPDK_ERRLOG("No registration\n"); SPDK_ERRLOG("No registration\n");
@ -210,19 +210,19 @@ spdk_scsi_pr_out_reserve(struct spdk_scsi_task *task,
} }
/* reservation holder already exists */ /* reservation holder already exists */
if (spdk_scsi_pr_has_reservation(lun)) { if (scsi_pr_has_reservation(lun)) {
if (rtype != lun->reservation.rtype) { if (rtype != lun->reservation.rtype) {
SPDK_ERRLOG("Reservation type doesn't match\n"); SPDK_ERRLOG("Reservation type doesn't match\n");
goto conflict; goto conflict;
} }
if (!spdk_scsi_pr_registrant_is_holder(lun, reg)) { if (!scsi_pr_registrant_is_holder(lun, reg)) {
SPDK_ERRLOG("Only 1 holder is allowed for type %u\n", rtype); SPDK_ERRLOG("Only 1 holder is allowed for type %u\n", rtype);
goto conflict; goto conflict;
} }
} else { } else {
/* current I_T nexus is the first reservation holder */ /* current I_T nexus is the first reservation holder */
spdk_scsi_pr_reserve_reservation(lun, rtype, rkey, reg); scsi_pr_reserve_reservation(lun, rtype, rkey, reg);
} }
return 0; return 0;
@ -236,10 +236,10 @@ conflict:
} }
static int static int
spdk_scsi_pr_out_register(struct spdk_scsi_task *task, scsi_pr_out_register(struct spdk_scsi_task *task,
enum spdk_scsi_pr_out_service_action_code action, enum spdk_scsi_pr_out_service_action_code action,
uint64_t rkey, uint64_t sa_rkey, uint64_t rkey, uint64_t sa_rkey,
uint8_t spec_i_pt, uint8_t all_tg_pt, uint8_t aptpl) uint8_t spec_i_pt, uint8_t all_tg_pt, uint8_t aptpl)
{ {
struct spdk_scsi_lun *lun = task->lun; struct spdk_scsi_lun *lun = task->lun;
struct spdk_scsi_pr_registrant *reg; struct spdk_scsi_pr_registrant *reg;
@ -257,7 +257,7 @@ spdk_scsi_pr_out_register(struct spdk_scsi_task *task,
goto error_exit; goto error_exit;
} }
reg = spdk_scsi_pr_get_registrant(lun, task->initiator_port, task->target_port); reg = scsi_pr_get_registrant(lun, task->initiator_port, task->target_port);
/* an unregistered I_T nexus session */ /* an unregistered I_T nexus session */
if (!reg) { if (!reg) {
if (rkey && (action == SPDK_SCSI_PR_OUT_REGISTER)) { if (rkey && (action == SPDK_SCSI_PR_OUT_REGISTER)) {
@ -275,8 +275,8 @@ spdk_scsi_pr_out_register(struct spdk_scsi_task *task,
return 0; return 0;
} }
/* Add a new registrant for the I_T nexus */ /* Add a new registrant for the I_T nexus */
return spdk_scsi_pr_register_registrant(lun, task->initiator_port, return scsi_pr_register_registrant(lun, task->initiator_port,
task->target_port, sa_rkey); task->target_port, sa_rkey);
} else { } else {
/* a registered I_T nexus */ /* a registered I_T nexus */
if (rkey != reg->rkey && action == SPDK_SCSI_PR_OUT_REGISTER) { if (rkey != reg->rkey && action == SPDK_SCSI_PR_OUT_REGISTER) {
@ -290,10 +290,10 @@ spdk_scsi_pr_out_register(struct spdk_scsi_task *task,
if (!sa_rkey) { if (!sa_rkey) {
/* unregister */ /* unregister */
spdk_scsi_pr_unregister_registrant(lun, reg); scsi_pr_unregister_registrant(lun, reg);
} else { } else {
/* replace */ /* replace */
spdk_scsi_pr_replace_registrant_key(lun, reg, sa_rkey); scsi_pr_replace_registrant_key(lun, reg, sa_rkey);
} }
} }
@ -305,8 +305,8 @@ error_exit:
} }
static int static int
spdk_scsi_pr_out_release(struct spdk_scsi_task *task, scsi_pr_out_release(struct spdk_scsi_task *task,
enum spdk_scsi_pr_type_code rtype, uint64_t rkey) enum spdk_scsi_pr_type_code rtype, uint64_t rkey)
{ {
struct spdk_scsi_lun *lun = task->lun; struct spdk_scsi_lun *lun = task->lun;
struct spdk_scsi_pr_registrant *reg; struct spdk_scsi_pr_registrant *reg;
@ -315,7 +315,7 @@ spdk_scsi_pr_out_release(struct spdk_scsi_task *task,
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PR OUT RELEASE: rkey 0x%"PRIx64", " SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PR OUT RELEASE: rkey 0x%"PRIx64", "
"reservation type %u\n", rkey, rtype); "reservation type %u\n", rkey, rtype);
reg = spdk_scsi_pr_get_registrant(lun, task->initiator_port, task->target_port); reg = scsi_pr_get_registrant(lun, task->initiator_port, task->target_port);
if (!reg) { if (!reg) {
SPDK_ERRLOG("No registration\n"); SPDK_ERRLOG("No registration\n");
sk = SPDK_SCSI_SENSE_NOT_READY; sk = SPDK_SCSI_SENSE_NOT_READY;
@ -324,7 +324,7 @@ spdk_scsi_pr_out_release(struct spdk_scsi_task *task,
} }
/* no reservation holder */ /* no reservation holder */
if (!spdk_scsi_pr_has_reservation(lun)) { if (!scsi_pr_has_reservation(lun)) {
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "RELEASE: no reservation holder\n"); SPDK_DEBUGLOG(SPDK_LOG_SCSI, "RELEASE: no reservation holder\n");
return 0; return 0;
} }
@ -336,12 +336,12 @@ spdk_scsi_pr_out_release(struct spdk_scsi_task *task,
} }
/* I_T nexus is not a persistent reservation holder */ /* I_T nexus is not a persistent reservation holder */
if (!spdk_scsi_pr_registrant_is_holder(lun, reg)) { if (!scsi_pr_registrant_is_holder(lun, reg)) {
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "RELEASE: current I_T nexus is not holder\n"); SPDK_DEBUGLOG(SPDK_LOG_SCSI, "RELEASE: current I_T nexus is not holder\n");
return 0; return 0;
} }
spdk_scsi_pr_release_reservation(lun, reg); scsi_pr_release_reservation(lun, reg);
return 0; return 0;
@ -352,7 +352,7 @@ check_condition:
} }
static int static int
spdk_scsi_pr_out_clear(struct spdk_scsi_task *task, uint64_t rkey) scsi_pr_out_clear(struct spdk_scsi_task *task, uint64_t rkey)
{ {
struct spdk_scsi_lun *lun = task->lun; struct spdk_scsi_lun *lun = task->lun;
struct spdk_scsi_pr_registrant *reg, *tmp; struct spdk_scsi_pr_registrant *reg, *tmp;
@ -360,7 +360,7 @@ spdk_scsi_pr_out_clear(struct spdk_scsi_task *task, uint64_t rkey)
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PR OUT CLEAR: rkey 0x%"PRIx64"\n", rkey); SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PR OUT CLEAR: rkey 0x%"PRIx64"\n", rkey);
reg = spdk_scsi_pr_get_registrant(lun, task->initiator_port, task->target_port); reg = scsi_pr_get_registrant(lun, task->initiator_port, task->target_port);
if (!reg) { if (!reg) {
SPDK_ERRLOG("No registration\n"); SPDK_ERRLOG("No registration\n");
sc = SPDK_SCSI_STATUS_CHECK_CONDITION; sc = SPDK_SCSI_STATUS_CHECK_CONDITION;
@ -379,7 +379,7 @@ spdk_scsi_pr_out_clear(struct spdk_scsi_task *task, uint64_t rkey)
} }
TAILQ_FOREACH_SAFE(reg, &lun->reg_head, link, tmp) { TAILQ_FOREACH_SAFE(reg, &lun->reg_head, link, tmp) {
spdk_scsi_pr_unregister_registrant(lun, reg); scsi_pr_unregister_registrant(lun, reg);
} }
return 0; return 0;
@ -390,34 +390,34 @@ error_exit:
} }
static void static void
spdk_scsi_pr_remove_all_regs_by_key(struct spdk_scsi_lun *lun, uint64_t sa_rkey) scsi_pr_remove_all_regs_by_key(struct spdk_scsi_lun *lun, uint64_t sa_rkey)
{ {
struct spdk_scsi_pr_registrant *reg, *tmp; struct spdk_scsi_pr_registrant *reg, *tmp;
TAILQ_FOREACH_SAFE(reg, &lun->reg_head, link, tmp) { TAILQ_FOREACH_SAFE(reg, &lun->reg_head, link, tmp) {
if (reg->rkey == sa_rkey) { if (reg->rkey == sa_rkey) {
spdk_scsi_pr_unregister_registrant(lun, reg); scsi_pr_unregister_registrant(lun, reg);
} }
} }
} }
static void static void
spdk_scsi_pr_remove_all_other_regs(struct spdk_scsi_lun *lun, struct spdk_scsi_pr_registrant *reg) scsi_pr_remove_all_other_regs(struct spdk_scsi_lun *lun, struct spdk_scsi_pr_registrant *reg)
{ {
struct spdk_scsi_pr_registrant *reg_tmp, *reg_tmp2; struct spdk_scsi_pr_registrant *reg_tmp, *reg_tmp2;
TAILQ_FOREACH_SAFE(reg_tmp, &lun->reg_head, link, reg_tmp2) { TAILQ_FOREACH_SAFE(reg_tmp, &lun->reg_head, link, reg_tmp2) {
if (reg_tmp != reg) { if (reg_tmp != reg) {
spdk_scsi_pr_unregister_registrant(lun, reg_tmp); scsi_pr_unregister_registrant(lun, reg_tmp);
} }
} }
} }
static int static int
spdk_scsi_pr_out_preempt(struct spdk_scsi_task *task, scsi_pr_out_preempt(struct spdk_scsi_task *task,
enum spdk_scsi_pr_out_service_action_code action, enum spdk_scsi_pr_out_service_action_code action,
enum spdk_scsi_pr_type_code rtype, enum spdk_scsi_pr_type_code rtype,
uint64_t rkey, uint64_t sa_rkey) uint64_t rkey, uint64_t sa_rkey)
{ {
struct spdk_scsi_lun *lun = task->lun; struct spdk_scsi_lun *lun = task->lun;
struct spdk_scsi_pr_registrant *reg; struct spdk_scsi_pr_registrant *reg;
@ -428,7 +428,7 @@ spdk_scsi_pr_out_preempt(struct spdk_scsi_task *task,
rkey, sa_rkey, action, rtype, lun->reservation.rtype); rkey, sa_rkey, action, rtype, lun->reservation.rtype);
/* I_T nexus is not registered */ /* I_T nexus is not registered */
reg = spdk_scsi_pr_get_registrant(lun, task->initiator_port, task->target_port); reg = scsi_pr_get_registrant(lun, task->initiator_port, task->target_port);
if (!reg) { if (!reg) {
SPDK_ERRLOG("No registration\n"); SPDK_ERRLOG("No registration\n");
goto conflict; goto conflict;
@ -440,23 +440,23 @@ spdk_scsi_pr_out_preempt(struct spdk_scsi_task *task,
} }
/* no persistent reservation */ /* no persistent reservation */
if (!spdk_scsi_pr_has_reservation(lun)) { if (!scsi_pr_has_reservation(lun)) {
spdk_scsi_pr_remove_all_regs_by_key(lun, sa_rkey); scsi_pr_remove_all_regs_by_key(lun, sa_rkey);
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PREEMPT: no persistent reservation\n"); SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PREEMPT: no persistent reservation\n");
goto exit; goto exit;
} }
all_regs = spdk_scsi_pr_is_all_registrants_type(lun); all_regs = scsi_pr_is_all_registrants_type(lun);
if (all_regs) { if (all_regs) {
if (sa_rkey != 0) { if (sa_rkey != 0) {
spdk_scsi_pr_remove_all_regs_by_key(lun, sa_rkey); scsi_pr_remove_all_regs_by_key(lun, sa_rkey);
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PREEMPT: All registrants type with sa_rkey\n"); SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PREEMPT: All registrants type with sa_rkey\n");
} else { } else {
/* remove all other registrants and release persistent reservation if any */ /* remove all other registrants and release persistent reservation if any */
spdk_scsi_pr_remove_all_other_regs(lun, reg); scsi_pr_remove_all_other_regs(lun, reg);
/* create persistent reservation using new type and scope */ /* create persistent reservation using new type and scope */
spdk_scsi_pr_reserve_reservation(lun, rtype, 0, reg); scsi_pr_reserve_reservation(lun, rtype, 0, reg);
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PREEMPT: All registrants type with sa_rkey zeroed\n"); SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PREEMPT: All registrants type with sa_rkey zeroed\n");
} }
goto exit; goto exit;
@ -473,26 +473,26 @@ spdk_scsi_pr_out_preempt(struct spdk_scsi_task *task,
SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE); SPDK_SCSI_ASCQ_CAUSE_NOT_REPORTABLE);
return -EINVAL; return -EINVAL;
} }
spdk_scsi_pr_remove_all_regs_by_key(lun, sa_rkey); scsi_pr_remove_all_regs_by_key(lun, sa_rkey);
goto exit; goto exit;
} }
if (spdk_scsi_pr_registrant_is_holder(lun, reg)) { if (scsi_pr_registrant_is_holder(lun, reg)) {
spdk_scsi_pr_reserve_reservation(lun, rtype, rkey, reg); scsi_pr_reserve_reservation(lun, rtype, rkey, reg);
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PREEMPT: preempt itself with type %u\n", rtype); SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PREEMPT: preempt itself with type %u\n", rtype);
goto exit; goto exit;
} }
/* unregister registrants if any */ /* unregister registrants if any */
spdk_scsi_pr_remove_all_regs_by_key(lun, sa_rkey); scsi_pr_remove_all_regs_by_key(lun, sa_rkey);
reg = spdk_scsi_pr_get_registrant(lun, task->initiator_port, task->target_port); reg = scsi_pr_get_registrant(lun, task->initiator_port, task->target_port);
if (!reg) { if (!reg) {
SPDK_ERRLOG("Current I_T nexus registrant was removed\n"); SPDK_ERRLOG("Current I_T nexus registrant was removed\n");
goto conflict; goto conflict;
} }
/* preempt the holder */ /* preempt the holder */
spdk_scsi_pr_reserve_reservation(lun, rtype, rkey, reg); scsi_pr_reserve_reservation(lun, rtype, rkey, reg);
exit: exit:
lun->pr_generation++; lun->pr_generation++;
@ -531,30 +531,30 @@ scsi_pr_out(struct spdk_scsi_task *task, uint8_t *cdb,
switch (action) { switch (action) {
case SPDK_SCSI_PR_OUT_REGISTER: case SPDK_SCSI_PR_OUT_REGISTER:
case SPDK_SCSI_PR_OUT_REG_AND_IGNORE_KEY: case SPDK_SCSI_PR_OUT_REG_AND_IGNORE_KEY:
rc = spdk_scsi_pr_out_register(task, action, rkey, sa_rkey, rc = scsi_pr_out_register(task, action, rkey, sa_rkey,
spec_i_pt, all_tg_pt, aptpl); spec_i_pt, all_tg_pt, aptpl);
break; break;
case SPDK_SCSI_PR_OUT_RESERVE: case SPDK_SCSI_PR_OUT_RESERVE:
if (scope != SPDK_SCSI_PR_LU_SCOPE) { if (scope != SPDK_SCSI_PR_LU_SCOPE) {
goto invalid; goto invalid;
} }
rc = spdk_scsi_pr_out_reserve(task, rtype, rkey, rc = scsi_pr_out_reserve(task, rtype, rkey,
spec_i_pt, all_tg_pt, aptpl); spec_i_pt, all_tg_pt, aptpl);
break; break;
case SPDK_SCSI_PR_OUT_RELEASE: case SPDK_SCSI_PR_OUT_RELEASE:
if (scope != SPDK_SCSI_PR_LU_SCOPE) { if (scope != SPDK_SCSI_PR_LU_SCOPE) {
goto invalid; goto invalid;
} }
rc = spdk_scsi_pr_out_release(task, rtype, rkey); rc = scsi_pr_out_release(task, rtype, rkey);
break; break;
case SPDK_SCSI_PR_OUT_CLEAR: case SPDK_SCSI_PR_OUT_CLEAR:
rc = spdk_scsi_pr_out_clear(task, rkey); rc = scsi_pr_out_clear(task, rkey);
break; break;
case SPDK_SCSI_PR_OUT_PREEMPT: case SPDK_SCSI_PR_OUT_PREEMPT:
if (scope != SPDK_SCSI_PR_LU_SCOPE) { if (scope != SPDK_SCSI_PR_LU_SCOPE) {
goto invalid; goto invalid;
} }
rc = spdk_scsi_pr_out_preempt(task, action, rtype, rkey, sa_rkey); rc = scsi_pr_out_preempt(task, action, rtype, rkey, sa_rkey);
break; break;
default: default:
SPDK_ERRLOG("Invalid service action code %u\n", action); SPDK_ERRLOG("Invalid service action code %u\n", action);
@ -572,8 +572,8 @@ invalid:
} }
static int static int
spdk_scsi_pr_in_read_keys(struct spdk_scsi_task *task, uint8_t *data, scsi_pr_in_read_keys(struct spdk_scsi_task *task, uint8_t *data,
uint16_t data_len) uint16_t data_len)
{ {
struct spdk_scsi_lun *lun = task->lun; struct spdk_scsi_lun *lun = task->lun;
struct spdk_scsi_pr_in_read_keys_data *keys; struct spdk_scsi_pr_in_read_keys_data *keys;
@ -597,8 +597,8 @@ spdk_scsi_pr_in_read_keys(struct spdk_scsi_task *task, uint8_t *data,
} }
static int static int
spdk_scsi_pr_in_read_reservations(struct spdk_scsi_task *task, scsi_pr_in_read_reservations(struct spdk_scsi_task *task,
uint8_t *data, uint16_t data_len) uint8_t *data, uint16_t data_len)
{ {
struct spdk_scsi_lun *lun = task->lun; struct spdk_scsi_lun *lun = task->lun;
struct spdk_scsi_pr_in_read_reservations_data *param; struct spdk_scsi_pr_in_read_reservations_data *param;
@ -608,8 +608,8 @@ spdk_scsi_pr_in_read_reservations(struct spdk_scsi_task *task,
param = (struct spdk_scsi_pr_in_read_reservations_data *)(data); param = (struct spdk_scsi_pr_in_read_reservations_data *)(data);
to_be32(&param->header.pr_generation, lun->pr_generation); to_be32(&param->header.pr_generation, lun->pr_generation);
if (spdk_scsi_pr_has_reservation(lun)) { if (scsi_pr_has_reservation(lun)) {
all_regs = spdk_scsi_pr_is_all_registrants_type(lun); all_regs = scsi_pr_is_all_registrants_type(lun);
if (all_regs) { if (all_regs) {
to_be64(&param->rkey, 0); to_be64(&param->rkey, 0);
} else { } else {
@ -629,8 +629,8 @@ spdk_scsi_pr_in_read_reservations(struct spdk_scsi_task *task,
} }
static int static int
spdk_scsi_pr_in_report_capabilities(struct spdk_scsi_task *task, scsi_pr_in_report_capabilities(struct spdk_scsi_task *task,
uint8_t *data, uint16_t data_len) uint8_t *data, uint16_t data_len)
{ {
struct spdk_scsi_pr_in_report_capabilities_data *param; struct spdk_scsi_pr_in_report_capabilities_data *param;
@ -652,8 +652,8 @@ spdk_scsi_pr_in_report_capabilities(struct spdk_scsi_task *task,
} }
static int static int
spdk_scsi_pr_in_read_full_status(struct spdk_scsi_task *task, scsi_pr_in_read_full_status(struct spdk_scsi_task *task,
uint8_t *data, uint16_t data_len) uint8_t *data, uint16_t data_len)
{ {
struct spdk_scsi_lun *lun = task->lun; struct spdk_scsi_lun *lun = task->lun;
struct spdk_scsi_pr_in_full_status_data *param; struct spdk_scsi_pr_in_full_status_data *param;
@ -664,7 +664,7 @@ spdk_scsi_pr_in_read_full_status(struct spdk_scsi_task *task,
SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PR IN READ FULL STATUS\n"); SPDK_DEBUGLOG(SPDK_LOG_SCSI, "PR IN READ FULL STATUS\n");
all_regs = spdk_scsi_pr_is_all_registrants_type(lun); all_regs = scsi_pr_is_all_registrants_type(lun);
param = (struct spdk_scsi_pr_in_full_status_data *)data; param = (struct spdk_scsi_pr_in_full_status_data *)data;
to_be32(&param->header.pr_generation, lun->pr_generation); to_be32(&param->header.pr_generation, lun->pr_generation);
@ -712,19 +712,19 @@ scsi_pr_in(struct spdk_scsi_task *task, uint8_t *cdb,
switch (action) { switch (action) {
case SPDK_SCSI_PR_IN_READ_KEYS: case SPDK_SCSI_PR_IN_READ_KEYS:
rc = spdk_scsi_pr_in_read_keys(task, data, data_len); rc = scsi_pr_in_read_keys(task, data, data_len);
break; break;
case SPDK_SCSI_PR_IN_READ_RESERVATION: case SPDK_SCSI_PR_IN_READ_RESERVATION:
if (data_len < sizeof(struct spdk_scsi_pr_in_read_reservations_data)) { if (data_len < sizeof(struct spdk_scsi_pr_in_read_reservations_data)) {
goto invalid; goto invalid;
} }
rc = spdk_scsi_pr_in_read_reservations(task, data, data_len); rc = scsi_pr_in_read_reservations(task, data, data_len);
break; break;
case SPDK_SCSI_PR_IN_REPORT_CAPABILITIES: case SPDK_SCSI_PR_IN_REPORT_CAPABILITIES:
rc = spdk_scsi_pr_in_report_capabilities(task, data, data_len); rc = scsi_pr_in_report_capabilities(task, data, data_len);
break; break;
case SPDK_SCSI_PR_IN_READ_FULL_STATUS: case SPDK_SCSI_PR_IN_READ_FULL_STATUS:
rc = spdk_scsi_pr_in_read_full_status(task, data, data_len); rc = scsi_pr_in_read_full_status(task, data, data_len);
break; break;
default: default:
goto invalid; goto invalid;
@ -751,16 +751,16 @@ scsi_pr_check(struct spdk_scsi_task *task)
bool dma_to_device = false; bool dma_to_device = false;
/* no reservation holders */ /* no reservation holders */
if (!spdk_scsi_pr_has_reservation(lun)) { if (!scsi_pr_has_reservation(lun)) {
return 0; return 0;
} }
rtype = lun->reservation.rtype; rtype = lun->reservation.rtype;
assert(rtype != 0); assert(rtype != 0);
reg = spdk_scsi_pr_get_registrant(lun, task->initiator_port, task->target_port); reg = scsi_pr_get_registrant(lun, task->initiator_port, task->target_port);
/* current I_T nexus hold the reservation */ /* current I_T nexus hold the reservation */
if (spdk_scsi_pr_registrant_is_holder(lun, reg)) { if (scsi_pr_registrant_is_holder(lun, reg)) {
return 0; return 0;
} }

6
lib/scsi/scsi_rpc.c
View File

@ -38,8 +38,8 @@
#include "spdk/util.h" #include "spdk/util.h"
static void static void
spdk_rpc_scsi_get_devices(struct spdk_jsonrpc_request *request, rpc_scsi_get_devices(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct spdk_json_write_ctx *w; struct spdk_json_write_ctx *w;
struct spdk_scsi_dev *devs = scsi_dev_get_list(); struct spdk_scsi_dev *devs = scsi_dev_get_list();
@ -73,5 +73,5 @@ spdk_rpc_scsi_get_devices(struct spdk_jsonrpc_request *request,
spdk_jsonrpc_end_result(request, w); spdk_jsonrpc_end_result(request, w);
} }
SPDK_RPC_REGISTER("scsi_get_devices", spdk_rpc_scsi_get_devices, SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("scsi_get_devices", rpc_scsi_get_devices, SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(scsi_get_devices, get_scsi_devices) SPDK_RPC_REGISTER_ALIAS_DEPRECATED(scsi_get_devices, get_scsi_devices)

124
test/unit/lib/scsi/scsi_pr.c/scsi_pr_ut.c
View File

@ -169,30 +169,30 @@ test_build_registrants(void)
task.initiator_port = &g_i_port_a; task.initiator_port = &g_i_port_a;
/* Test Case: Host A registers with a new key */ /* Test Case: Host A registers with a new key */
task.status = 0; task.status = 0;
rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, rc = scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER,
0x0, 0xa1, 0, 0, 0); 0x0, 0xa1, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0); reg = scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0);
SPDK_CU_ASSERT_FATAL(reg != NULL); SPDK_CU_ASSERT_FATAL(reg != NULL);
SPDK_CU_ASSERT_FATAL(reg->rkey == 0xa1); SPDK_CU_ASSERT_FATAL(reg->rkey == 0xa1);
SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 1); SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 1);
/* Test Case: Host A replaces with a new key */ /* Test Case: Host A replaces with a new key */
task.status = 0; task.status = 0;
rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, rc = scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER,
0xa1, 0xa, 0, 0, 0); 0xa1, 0xa, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0); reg = scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0);
SPDK_CU_ASSERT_FATAL(reg != NULL); SPDK_CU_ASSERT_FATAL(reg != NULL);
SPDK_CU_ASSERT_FATAL(reg->rkey == 0xa); SPDK_CU_ASSERT_FATAL(reg->rkey == 0xa);
SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 2); SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 2);
/* Test Case: Host A replaces with a new key, reservation conflict is expected */ /* Test Case: Host A replaces with a new key, reservation conflict is expected */
task.status = 0; task.status = 0;
rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, rc = scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER,
0xa1, 0xdead, 0, 0, 0); 0xa1, 0xdead, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc < 0); SPDK_CU_ASSERT_FATAL(rc < 0);
reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0); reg = scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0);
SPDK_CU_ASSERT_FATAL(reg != NULL); SPDK_CU_ASSERT_FATAL(reg != NULL);
SPDK_CU_ASSERT_FATAL(reg->rkey == 0xa); SPDK_CU_ASSERT_FATAL(reg->rkey == 0xa);
SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 2); SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 2);
@ -202,10 +202,10 @@ test_build_registrants(void)
task.initiator_port = &g_i_port_b; task.initiator_port = &g_i_port_b;
/* Test Case: Host B registers with a new key */ /* Test Case: Host B registers with a new key */
task.status = 0; task.status = 0;
rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, rc = scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER,
0x0, 0xb, 0, 0, 0); 0x0, 0xb, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_b, &g_t_port_0); reg = scsi_pr_get_registrant(&g_lun, &g_i_port_b, &g_t_port_0);
SPDK_CU_ASSERT_FATAL(reg != NULL); SPDK_CU_ASSERT_FATAL(reg != NULL);
SPDK_CU_ASSERT_FATAL(reg->rkey == 0xb); SPDK_CU_ASSERT_FATAL(reg->rkey == 0xb);
SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 3); SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 3);
@ -214,10 +214,10 @@ test_build_registrants(void)
task.initiator_port = &g_i_port_c; task.initiator_port = &g_i_port_c;
/* Test Case: Host C registers with a new key */ /* Test Case: Host C registers with a new key */
task.status = 0; task.status = 0;
rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, rc = scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER,
0x0, 0xc, 0, 0, 0); 0x0, 0xc, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_c, &g_t_port_0); reg = scsi_pr_get_registrant(&g_lun, &g_i_port_c, &g_t_port_0);
SPDK_CU_ASSERT_FATAL(reg != NULL); SPDK_CU_ASSERT_FATAL(reg != NULL);
SPDK_CU_ASSERT_FATAL(reg->rkey == 0xc); SPDK_CU_ASSERT_FATAL(reg->rkey == 0xc);
SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 4); SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 4);
@ -252,8 +252,8 @@ test_reservation_reserve(void)
task.initiator_port = &g_i_port_a; task.initiator_port = &g_i_port_a;
task.status = 0; task.status = 0;
/* Test Case: Host A acquires the reservation */ /* Test Case: Host A acquires the reservation */
rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE, rc = scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE,
0xa, 0, 0, 0); 0xa, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xa); SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xa);
@ -264,8 +264,8 @@ test_reservation_reserve(void)
*/ */
task.initiator_port = &g_i_port_b; task.initiator_port = &g_i_port_b;
task.status = 0; task.status = 0;
rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE, rc = scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE,
0xb, 0, 0, 0); 0xb, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc < 0); SPDK_CU_ASSERT_FATAL(rc < 0);
SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_RESERVATION_CONFLICT); SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_RESERVATION_CONFLICT);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE);
@ -275,20 +275,20 @@ test_reservation_reserve(void)
/* Test Case: Host A unregister with reservation */ /* Test Case: Host A unregister with reservation */
task.initiator_port = &g_i_port_a; task.initiator_port = &g_i_port_a;
task.status = 0; task.status = 0;
rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, rc = scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER,
0xa, 0, 0, 0, 0); 0xa, 0, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == 0); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == 0);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0); SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0);
SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 1); SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 1);
reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0); reg = scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0);
SPDK_CU_ASSERT_FATAL(reg == NULL); SPDK_CU_ASSERT_FATAL(reg == NULL);
/* Test Case: Host B acquires the reservation */ /* Test Case: Host B acquires the reservation */
task.initiator_port = &g_i_port_b; task.initiator_port = &g_i_port_b;
task.status = 0; task.status = 0;
rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS, rc = scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS,
0xb, 0, 0, 0); 0xb, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS);
SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 1); SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 1);
@ -296,8 +296,8 @@ test_reservation_reserve(void)
/* Test Case: Host C acquires the reservation with invalid type */ /* Test Case: Host C acquires the reservation with invalid type */
task.initiator_port = &g_i_port_c; task.initiator_port = &g_i_port_c;
task.status = 0; task.status = 0;
rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE, rc = scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE,
0xc, 0, 0, 0); 0xc, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc < 0); SPDK_CU_ASSERT_FATAL(rc < 0);
SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_RESERVATION_CONFLICT); SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_RESERVATION_CONFLICT);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS);
@ -305,8 +305,8 @@ test_reservation_reserve(void)
/* Test Case: Host C acquires the reservation, all registrants type */ /* Test Case: Host C acquires the reservation, all registrants type */
task.status = 0; task.status = 0;
rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS, rc = scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS,
0xc, 0, 0, 0); 0xc, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS);
SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 1); SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen + 1);
@ -332,8 +332,8 @@ test_reservation_preempt_non_all_regs(void)
task.status = 0; task.status = 0;
gen = g_lun.pr_generation; gen = g_lun.pr_generation;
/* Host A acquires the reservation */ /* Host A acquires the reservation */
rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY, rc = scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY,
0xa, 0, 0, 0); 0xa, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xa); SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xa);
@ -343,31 +343,31 @@ test_reservation_preempt_non_all_regs(void)
* for zeroed service action reservation key */ * for zeroed service action reservation key */
task.initiator_port = &g_i_port_b; task.initiator_port = &g_i_port_b;
task.status = 0; task.status = 0;
rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, rc = scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT,
SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY, SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY,
0xb, 0); 0xb, 0);
SPDK_CU_ASSERT_FATAL(rc < 0); SPDK_CU_ASSERT_FATAL(rc < 0);
SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_CHECK_CONDITION); SPDK_CU_ASSERT_FATAL(task.status == SPDK_SCSI_STATUS_CHECK_CONDITION);
/* Test Case: Host B preempts Host A, Host A is unregisted */ /* Test Case: Host B preempts Host A, Host A is unregisted */
task.status = 0; task.status = 0;
gen = g_lun.pr_generation; gen = g_lun.pr_generation;
rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, rc = scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT,
SPDK_SCSI_PR_WRITE_EXCLUSIVE, SPDK_SCSI_PR_WRITE_EXCLUSIVE,
0xb, 0xa); 0xb, 0xa);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xb); SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xb);
SPDK_CU_ASSERT_FATAL(g_lun.pr_generation > gen); SPDK_CU_ASSERT_FATAL(g_lun.pr_generation > gen);
reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0); reg = scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0);
SPDK_CU_ASSERT_FATAL(reg == NULL); SPDK_CU_ASSERT_FATAL(reg == NULL);
/* Test Case: Host B preempts itself */ /* Test Case: Host B preempts itself */
task.status = 0; task.status = 0;
gen = g_lun.pr_generation; gen = g_lun.pr_generation;
rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, rc = scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT,
SPDK_SCSI_PR_WRITE_EXCLUSIVE, SPDK_SCSI_PR_WRITE_EXCLUSIVE,
0xb, 0xb); 0xb, 0xb);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xb); SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xb);
@ -376,13 +376,13 @@ test_reservation_preempt_non_all_regs(void)
/* Test Case: Host B preempts itself and remove registrants */ /* Test Case: Host B preempts itself and remove registrants */
task.status = 0; task.status = 0;
gen = g_lun.pr_generation; gen = g_lun.pr_generation;
rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, rc = scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT,
SPDK_SCSI_PR_WRITE_EXCLUSIVE, SPDK_SCSI_PR_WRITE_EXCLUSIVE,
0xb, 0xc); 0xb, 0xc);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xb); SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xb);
reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_c, &g_t_port_0); reg = scsi_pr_get_registrant(&g_lun, &g_i_port_c, &g_t_port_0);
SPDK_CU_ASSERT_FATAL(reg == NULL); SPDK_CU_ASSERT_FATAL(reg == NULL);
SPDK_CU_ASSERT_FATAL(g_lun.pr_generation > gen); SPDK_CU_ASSERT_FATAL(g_lun.pr_generation > gen);
@ -407,11 +407,11 @@ test_reservation_preempt_all_regs(void)
task.initiator_port = &g_i_port_b; task.initiator_port = &g_i_port_b;
task.status = 0; task.status = 0;
gen = g_lun.pr_generation; gen = g_lun.pr_generation;
rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, rc = scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT,
SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY, SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY,
0xb, 0xc); 0xb, 0xc);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_c, &g_t_port_0); reg = scsi_pr_get_registrant(&g_lun, &g_i_port_c, &g_t_port_0);
SPDK_CU_ASSERT_FATAL(reg == NULL); SPDK_CU_ASSERT_FATAL(reg == NULL);
SPDK_CU_ASSERT_FATAL(g_lun.pr_generation > gen); SPDK_CU_ASSERT_FATAL(g_lun.pr_generation > gen);
@ -419,8 +419,8 @@ test_reservation_preempt_all_regs(void)
task.status = 0; task.status = 0;
gen = g_lun.pr_generation; gen = g_lun.pr_generation;
/* Host A acquires the reservation */ /* Host A acquires the reservation */
rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS, rc = scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS,
0xa, 0, 0, 0); 0xa, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_ALL_REGS);
SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen); SPDK_CU_ASSERT_FATAL(g_lun.pr_generation == gen);
@ -429,11 +429,11 @@ test_reservation_preempt_all_regs(void)
task.initiator_port = &g_i_port_b; task.initiator_port = &g_i_port_b;
task.status = 0; task.status = 0;
gen = g_lun.pr_generation; gen = g_lun.pr_generation;
rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, rc = scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT,
SPDK_SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS, SPDK_SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS,
0xb, 0x0); 0xb, 0x0);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0); reg = scsi_pr_get_registrant(&g_lun, &g_i_port_a, &g_t_port_0);
SPDK_CU_ASSERT_FATAL(reg == NULL); SPDK_CU_ASSERT_FATAL(reg == NULL);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_EXCLUSIVE_ACCESS_ALL_REGS);
SPDK_CU_ASSERT_FATAL(g_lun.pr_generation > gen); SPDK_CU_ASSERT_FATAL(g_lun.pr_generation > gen);
@ -458,8 +458,8 @@ test_reservation_cmds_conflict(void)
/* Host A acquires the reservation */ /* Host A acquires the reservation */
task.initiator_port = &g_i_port_a; task.initiator_port = &g_i_port_a;
rc = spdk_scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY, rc = scsi_pr_out_reserve(&task, SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY,
0xa, 0, 0, 0); 0xa, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_WRITE_EXCLUSIVE_REGS_ONLY);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xa); SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xa);
@ -467,10 +467,10 @@ test_reservation_cmds_conflict(void)
/* Remove Host B registrant */ /* Remove Host B registrant */
task.initiator_port = &g_i_port_b; task.initiator_port = &g_i_port_b;
task.status = 0; task.status = 0;
rc = spdk_scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER, rc = scsi_pr_out_register(&task, SPDK_SCSI_PR_OUT_REGISTER,
0xb, 0, 0, 0, 0); 0xb, 0, 0, 0, 0);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
reg = spdk_scsi_pr_get_registrant(&g_lun, &g_i_port_b, &g_t_port_0); reg = scsi_pr_get_registrant(&g_lun, &g_i_port_b, &g_t_port_0);
SPDK_CU_ASSERT_FATAL(reg == NULL); SPDK_CU_ASSERT_FATAL(reg == NULL);
/* Test Case: Host B sends Read/Write commands, /* Test Case: Host B sends Read/Write commands,
@ -499,9 +499,9 @@ test_reservation_cmds_conflict(void)
/* Host A preempts itself with SPDK_SCSI_PR_EXCLUSIVE_ACCESS */ /* Host A preempts itself with SPDK_SCSI_PR_EXCLUSIVE_ACCESS */
task.initiator_port = &g_i_port_a; task.initiator_port = &g_i_port_a;
rc = spdk_scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT, rc = scsi_pr_out_preempt(&task, SPDK_SCSI_PR_OUT_PREEMPT,
SPDK_SCSI_PR_EXCLUSIVE_ACCESS, SPDK_SCSI_PR_EXCLUSIVE_ACCESS,
0xa, 0xa); 0xa, 0xa);
SPDK_CU_ASSERT_FATAL(rc == 0); SPDK_CU_ASSERT_FATAL(rc == 0);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_EXCLUSIVE_ACCESS); SPDK_CU_ASSERT_FATAL(g_lun.reservation.rtype == SPDK_SCSI_PR_EXCLUSIVE_ACCESS);
SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xa); SPDK_CU_ASSERT_FATAL(g_lun.reservation.crkey == 0xa);