Unify PR variable names to reduce confusion.

diff --git a/sys/cam/ctl/ctl.c b/sys/cam/ctl/ctl.c
index 1cbf8209b68aa9ef68365fc560a0ca0a95ebcc6d..52319eabefd9856c12b8c4c3abea26f0f57f09a9 100644 (file)
--- a/sys/cam/ctl/ctl.c
+++ b/sys/cam/ctl/ctl.c
@@ -781,9 +781,9 @@ alloc:
        msg->hdr.nexus.targ_lun = lun->lun;
        msg->hdr.nexus.targ_mapped_lun = lun->lun;
        msg->lun.flags = lun->flags;
-       msg->lun.pr_generation = lun->PRGeneration;
+       msg->lun.pr_generation = lun->pr_generation;
        msg->lun.pr_res_idx = lun->pr_res_idx;
-       msg->lun.pr_res_type = lun->res_type;
+       msg->lun.pr_res_type = lun->pr_res_type;
        msg->lun.pr_key_count = lun->pr_key_count;
        i = 0;
        if (lun->lun_devid) {
@@ -1085,9 +1085,9 @@ ctl_isc_lun_sync(struct ctl_softc *softc, union ctl_ha_msg *msg, int len)
                /* If peer is primary and we are not -- use data */
                if ((lun->flags & CTL_LUN_PRIMARY_SC) == 0 &&
                    (lun->flags & CTL_LUN_PEER_SC_PRIMARY)) {
-                       lun->PRGeneration = msg->lun.pr_generation;
+                       lun->pr_generation = msg->lun.pr_generation;
                        lun->pr_res_idx = msg->lun.pr_res_idx;
-                       lun->res_type = msg->lun.pr_res_type;
+                       lun->pr_res_type = msg->lun.pr_res_type;
                        lun->pr_key_count = msg->lun.pr_key_count;
                        for (k = 0; k < CTL_MAX_INITIATORS; k++)
                                ctl_clr_prkey(lun, k);
@@ -5130,7 +5130,7 @@ ctl_start_stop(struct ctl_scsiio *ctsio)
 
                        residx = ctl_get_initindex(&ctsio->io_hdr.nexus);
                        if (ctl_get_prkey(lun, residx) == 0 ||
-                           (lun->pr_res_idx != residx && lun->res_type < 4)) {
+                           (lun->pr_res_idx != residx && lun->pr_res_type < 4)) {
 
                                ctl_set_reservation_conflict(ctsio);
                                ctl_done((union ctl_io *)ctsio);
@@ -7540,7 +7540,7 @@ retry:
                        goto retry;
                }
 
-               scsi_ulto4b(lun->PRGeneration, res_keys->header.generation);
+               scsi_ulto4b(lun->pr_generation, res_keys->header.generation);
 
                scsi_ulto4b(sizeof(struct scsi_per_res_key) *
                             lun->pr_key_count, res_keys->header.length);
@@ -7571,7 +7571,7 @@ retry:
 
                res = (struct scsi_per_res_in_rsrv *)ctsio->kern_data_ptr;
 
-               scsi_ulto4b(lun->PRGeneration, res->header.generation);
+               scsi_ulto4b(lun->pr_generation, res->header.generation);
 
                if (lun->flags & CTL_LUN_PR_RESERVED)
                {
@@ -7614,7 +7614,7 @@ retry:
                        scsi_u64to8b(ctl_get_prkey(lun, lun->pr_res_idx),
                            res->data.reservation);
                }
-               res->data.scopetype = lun->res_type;
+               res->data.scopetype = lun->pr_res_type;
                break;
        }
        case SPRI_RC:     //report capabilities
@@ -7659,7 +7659,7 @@ retry:
                        goto retry;
                }
 
-               scsi_ulto4b(lun->PRGeneration, res_status->header.generation);
+               scsi_ulto4b(lun->pr_generation, res_status->header.generation);
 
                res_desc = &res_status->desc[0];
                for (i = 0; i < CTL_MAX_INITIATORS; i++) {
@@ -7671,7 +7671,7 @@ retry:
                            (lun->pr_res_idx == i ||
                             lun->pr_res_idx == CTL_PR_ALL_REGISTRANTS)) {
                                res_desc->flags = SPRI_FULL_R_HOLDER;
-                               res_desc->scopetype = lun->res_type;
+                               res_desc->scopetype = lun->pr_res_type;
                        }
                        scsi_ulto2b(i / CTL_MAX_INIT_PER_PORT,
                            res_desc->rel_trgt_port_id);
@@ -7760,11 +7760,11 @@ ctl_pro_preempt(struct ctl_softc *softc, struct ctl_lun *lun, uint64_t res_key,
                                ctl_est_ua(lun, i, CTL_UA_REG_PREEMPT);
                        }
                        lun->pr_key_count = 1;
-                       lun->res_type = type;
-                       if (lun->res_type != SPR_TYPE_WR_EX_AR
-                        && lun->res_type != SPR_TYPE_EX_AC_AR)
+                       lun->pr_res_type = type;
+                       if (lun->pr_res_type != SPR_TYPE_WR_EX_AR &&
+                           lun->pr_res_type != SPR_TYPE_EX_AC_AR)
                                lun->pr_res_idx = residx;
-                       lun->PRGeneration++;
+                       lun->pr_generation++;
                        mtx_unlock(&lun->lun_lock);
 
                        /* send msg to other side */
@@ -7834,7 +7834,7 @@ ctl_pro_preempt(struct ctl_softc *softc, struct ctl_lun *lun, uint64_t res_key,
                        ctl_done((union ctl_io *)ctsio);
                        return (CTL_RETVAL_COMPLETE);
                }
-               lun->PRGeneration++;
+               lun->pr_generation++;
                mtx_unlock(&lun->lun_lock);
 
                /* send msg to other side */
@@ -7900,19 +7900,19 @@ ctl_pro_preempt(struct ctl_softc *softc, struct ctl_lun *lun, uint64_t res_key,
                                        ctl_clr_prkey(lun, i);
                                        lun->pr_key_count--;
                                        ctl_est_ua(lun, i, CTL_UA_REG_PREEMPT);
-                               } else if (type != lun->res_type
-                                       && (lun->res_type == SPR_TYPE_WR_EX_RO
-                                        || lun->res_type ==SPR_TYPE_EX_AC_RO)){
+                               } else if (type != lun->pr_res_type &&
+                                   (lun->pr_res_type == SPR_TYPE_WR_EX_RO ||
+                                    lun->pr_res_type == SPR_TYPE_EX_AC_RO)) {
                                        ctl_est_ua(lun, i, CTL_UA_RES_RELEASE);
                                }
                        }
-                       lun->res_type = type;
-                       if (lun->res_type != SPR_TYPE_WR_EX_AR
-                        && lun->res_type != SPR_TYPE_EX_AC_AR)
+                       lun->pr_res_type = type;
+                       if (lun->pr_res_type != SPR_TYPE_WR_EX_AR &&
+                           lun->pr_res_type != SPR_TYPE_EX_AC_AR)
                                lun->pr_res_idx = residx;
                        else
                                lun->pr_res_idx = CTL_PR_ALL_REGISTRANTS;
-                       lun->PRGeneration++;
+                       lun->pr_generation++;
                        mtx_unlock(&lun->lun_lock);
 
                        persis_io.hdr.nexus = ctsio->io_hdr.nexus;
@@ -7949,7 +7949,7 @@ ctl_pro_preempt(struct ctl_softc *softc, struct ctl_lun *lun, uint64_t res_key,
                                ctl_done((union ctl_io *)ctsio);
                                return (1);
                        }
-                       lun->PRGeneration++;
+                       lun->pr_generation++;
                        mtx_unlock(&lun->lun_lock);
 
                        persis_io.hdr.nexus = ctsio->io_hdr.nexus;
@@ -7993,9 +7993,9 @@ ctl_pro_preempt_other(struct ctl_lun *lun, union ctl_ha_msg *msg)
                        }
 
                        lun->pr_key_count = 1;
-                       lun->res_type = msg->pr.pr_info.res_type;
-                       if (lun->res_type != SPR_TYPE_WR_EX_AR
-                        && lun->res_type != SPR_TYPE_EX_AC_AR)
+                       lun->pr_res_type = msg->pr.pr_info.res_type;
+                       if (lun->pr_res_type != SPR_TYPE_WR_EX_AR &&
+                           lun->pr_res_type != SPR_TYPE_EX_AC_AR)
                                lun->pr_res_idx = msg->pr.pr_info.residx;
                } else {
                        for (i = 0; i < CTL_MAX_INITIATORS; i++) {
@@ -8017,20 +8017,20 @@ ctl_pro_preempt_other(struct ctl_lun *lun, union ctl_ha_msg *msg)
                                ctl_clr_prkey(lun, i);
                                lun->pr_key_count--;
                                ctl_est_ua(lun, i, CTL_UA_REG_PREEMPT);
-                       } else if (msg->pr.pr_info.res_type != lun->res_type
-                               && (lun->res_type == SPR_TYPE_WR_EX_RO
-                                || lun->res_type == SPR_TYPE_EX_AC_RO)) {
+                       } else if (msg->pr.pr_info.res_type != lun->pr_res_type
+                           && (lun->pr_res_type == SPR_TYPE_WR_EX_RO ||
+                            lun->pr_res_type == SPR_TYPE_EX_AC_RO)) {
                                ctl_est_ua(lun, i, CTL_UA_RES_RELEASE);
                        }
                }
-               lun->res_type = msg->pr.pr_info.res_type;
-               if (lun->res_type != SPR_TYPE_WR_EX_AR
-                && lun->res_type != SPR_TYPE_EX_AC_AR)
+               lun->pr_res_type = msg->pr.pr_info.res_type;
+               if (lun->pr_res_type != SPR_TYPE_WR_EX_AR &&
+                   lun->pr_res_type != SPR_TYPE_EX_AC_AR)
                        lun->pr_res_idx = msg->pr.pr_info.residx;
                else
                        lun->pr_res_idx = CTL_PR_ALL_REGISTRANTS;
        }
-       lun->PRGeneration++;
+       lun->pr_generation++;
 
 }
 
@@ -8212,9 +8212,9 @@ ctl_persistent_reserve_out(struct ctl_scsiio *ctsio)
                                lun->flags &= ~CTL_LUN_PR_RESERVED;
                                lun->pr_res_idx = CTL_PR_NO_RESERVATION;
 
-                               if ((lun->res_type == SPR_TYPE_WR_EX_RO
-                                 || lun->res_type == SPR_TYPE_EX_AC_RO)
-                                && lun->pr_key_count) {
+                               if ((lun->pr_res_type == SPR_TYPE_WR_EX_RO ||
+                                    lun->pr_res_type == SPR_TYPE_EX_AC_RO) &&
+                                   lun->pr_key_count) {
                                        /*
                                         * If the reservation is a registrants
                                         * only type we need to generate a UA
@@ -8230,15 +8230,15 @@ ctl_persistent_reserve_out(struct ctl_scsiio *ctsio)
                                                    CTL_UA_RES_RELEASE);
                                        }
                                }
-                               lun->res_type = 0;
+                               lun->pr_res_type = 0;
                        } else if (lun->pr_res_idx == CTL_PR_ALL_REGISTRANTS) {
                                if (lun->pr_key_count==0) {
                                        lun->flags &= ~CTL_LUN_PR_RESERVED;
-                                       lun->res_type = 0;
+                                       lun->pr_res_type = 0;
                                        lun->pr_res_idx = CTL_PR_NO_RESERVATION;
                                }
                        }
-                       lun->PRGeneration++;
+                       lun->pr_generation++;
                        mtx_unlock(&lun->lun_lock);
 
                        persis_io.hdr.nexus = ctsio->io_hdr.nexus;
@@ -8257,7 +8257,7 @@ ctl_persistent_reserve_out(struct ctl_scsiio *ctsio)
                        if (ctl_get_prkey(lun, residx) == 0)
                                lun->pr_key_count++;
                        ctl_set_prkey(lun, residx, sa_res_key);
-                       lun->PRGeneration++;
+                       lun->pr_generation++;
                        mtx_unlock(&lun->lun_lock);
 
                        persis_io.hdr.nexus = ctsio->io_hdr.nexus;
@@ -8286,7 +8286,7 @@ ctl_persistent_reserve_out(struct ctl_scsiio *ctsio)
                         */
                        if ((lun->pr_res_idx != residx
                          && lun->pr_res_idx != CTL_PR_ALL_REGISTRANTS)
-                        || lun->res_type != type) {
+                        || lun->pr_res_type != type) {
                                mtx_unlock(&lun->lun_lock);
                                free(ctsio->kern_data_ptr, M_CTL);
                                ctl_set_reservation_conflict(ctsio);
@@ -8306,7 +8306,7 @@ ctl_persistent_reserve_out(struct ctl_scsiio *ctsio)
                                lun->pr_res_idx = CTL_PR_ALL_REGISTRANTS;
 
                        lun->flags |= CTL_LUN_PR_RESERVED;
-                       lun->res_type = type;
+                       lun->pr_res_type = type;
 
                        mtx_unlock(&lun->lun_lock);
 
@@ -8341,7 +8341,7 @@ ctl_persistent_reserve_out(struct ctl_scsiio *ctsio)
                        goto done;
                }
 
-               if (lun->res_type != type) {
+               if (lun->pr_res_type != type) {
                        mtx_unlock(&lun->lun_lock);
                        free(ctsio->kern_data_ptr, M_CTL);
                        ctl_set_illegal_pr_release(ctsio);
@@ -8352,7 +8352,7 @@ ctl_persistent_reserve_out(struct ctl_scsiio *ctsio)
                /* okay to release */
                lun->flags &= ~CTL_LUN_PR_RESERVED;
                lun->pr_res_idx = CTL_PR_NO_RESERVATION;
-               lun->res_type = 0;
+               lun->pr_res_type = 0;
 
                /*
                 * if this isn't an exclusive access
@@ -8382,7 +8382,7 @@ ctl_persistent_reserve_out(struct ctl_scsiio *ctsio)
 
                mtx_lock(&lun->lun_lock);
                lun->flags &= ~CTL_LUN_PR_RESERVED;
-               lun->res_type = 0;
+               lun->pr_res_type = 0;
                lun->pr_key_count = 0;
                lun->pr_res_idx = CTL_PR_NO_RESERVATION;
 
@@ -8392,7 +8392,7 @@ ctl_persistent_reserve_out(struct ctl_scsiio *ctsio)
                                ctl_clr_prkey(lun, i);
                                ctl_est_ua(lun, i, CTL_UA_REG_PREEMPT);
                        }
-               lun->PRGeneration++;
+               lun->pr_generation++;
                mtx_unlock(&lun->lun_lock);
 
                persis_io.hdr.nexus = ctsio->io_hdr.nexus;
@@ -8459,7 +8459,7 @@ ctl_hndl_per_res_out_on_other_sc(union ctl_ha_msg *msg)
                        lun->pr_key_count++;
                ctl_set_prkey(lun, msg->pr.pr_info.residx,
                    scsi_8btou64(msg->pr.pr_info.sa_res_key));
-               lun->PRGeneration++;
+               lun->pr_generation++;
                break;
 
        case CTL_PR_UNREG_KEY:
@@ -8472,9 +8472,9 @@ ctl_hndl_per_res_out_on_other_sc(union ctl_ha_msg *msg)
                        lun->flags &= ~CTL_LUN_PR_RESERVED;
                        lun->pr_res_idx = CTL_PR_NO_RESERVATION;
 
-                       if ((lun->res_type == SPR_TYPE_WR_EX_RO
-                         || lun->res_type == SPR_TYPE_EX_AC_RO)
-                        && lun->pr_key_count) {
+                       if ((lun->pr_res_type == SPR_TYPE_WR_EX_RO ||
+                            lun->pr_res_type == SPR_TYPE_EX_AC_RO) &&
+                           lun->pr_key_count) {
                                /*
                                 * If the reservation is a registrants
                                 * only type we need to generate a UA
@@ -8490,20 +8490,20 @@ ctl_hndl_per_res_out_on_other_sc(union ctl_ha_msg *msg)
                                        ctl_est_ua(lun, i, CTL_UA_RES_RELEASE);
                                }
                        }
-                       lun->res_type = 0;
+                       lun->pr_res_type = 0;
                } else if (lun->pr_res_idx == CTL_PR_ALL_REGISTRANTS) {
                        if (lun->pr_key_count==0) {
                                lun->flags &= ~CTL_LUN_PR_RESERVED;
-                               lun->res_type = 0;
+                               lun->pr_res_type = 0;
                                lun->pr_res_idx = CTL_PR_NO_RESERVATION;
                        }
                }
-               lun->PRGeneration++;
+               lun->pr_generation++;
                break;
 
        case CTL_PR_RESERVE:
                lun->flags |= CTL_LUN_PR_RESERVED;
-               lun->res_type = msg->pr.pr_info.res_type;
+               lun->pr_res_type = msg->pr.pr_info.res_type;
                lun->pr_res_idx = msg->pr.pr_info.residx;
 
                break;
@@ -8513,8 +8513,8 @@ ctl_hndl_per_res_out_on_other_sc(union ctl_ha_msg *msg)
                 * if this isn't an exclusive access res generate UA for all
                 * other registrants.
                 */
-               if (lun->res_type != SPR_TYPE_EX_AC
-                && lun->res_type != SPR_TYPE_WR_EX) {
+               if (lun->pr_res_type != SPR_TYPE_EX_AC &&
+                   lun->pr_res_type != SPR_TYPE_WR_EX) {
                        for (i = softc->init_min; i < softc->init_max; i++)
                                if (i == residx || ctl_get_prkey(lun, i) == 0)
                                        continue;
@@ -8523,7 +8523,7 @@ ctl_hndl_per_res_out_on_other_sc(union ctl_ha_msg *msg)
 
                lun->flags &= ~CTL_LUN_PR_RESERVED;
                lun->pr_res_idx = CTL_PR_NO_RESERVATION;
-               lun->res_type = 0;
+               lun->pr_res_type = 0;
                break;
 
        case CTL_PR_PREEMPT:
@@ -8531,7 +8531,7 @@ ctl_hndl_per_res_out_on_other_sc(union ctl_ha_msg *msg)
                break;
        case CTL_PR_CLEAR:
                lun->flags &= ~CTL_LUN_PR_RESERVED;
-               lun->res_type = 0;
+               lun->pr_res_type = 0;
                lun->pr_key_count = 0;
                lun->pr_res_idx = CTL_PR_NO_RESERVATION;
 
@@ -8541,7 +8541,7 @@ ctl_hndl_per_res_out_on_other_sc(union ctl_ha_msg *msg)
                        ctl_clr_prkey(lun, i);
                        ctl_est_ua(lun, i, CTL_UA_REG_PREEMPT);
                }
-               lun->PRGeneration++;
+               lun->pr_generation++;
                break;
        }
 
@@ -11286,9 +11286,9 @@ ctl_scsiio_lun_check(struct ctl_lun *lun,
            (entry->flags & CTL_CMD_FLAG_ALLOW_ON_PR_RESV)) {
                /* No reservation or command is allowed. */;
        } else if ((entry->flags & CTL_CMD_FLAG_ALLOW_ON_PR_WRESV) &&
-           (lun->res_type == SPR_TYPE_WR_EX ||
-            lun->res_type == SPR_TYPE_WR_EX_RO ||
-            lun->res_type == SPR_TYPE_WR_EX_AR)) {
+           (lun->pr_res_type == SPR_TYPE_WR_EX ||
+            lun->pr_res_type == SPR_TYPE_WR_EX_RO ||
+            lun->pr_res_type == SPR_TYPE_WR_EX_AR)) {
                /* The command is allowed for Write Exclusive resv. */;
        } else {
                /*
@@ -11296,8 +11296,8 @@ ctl_scsiio_lun_check(struct ctl_lun *lun,
                 * reservation and this isn't the res holder then set a
                 * conflict.
                 */
-               if (ctl_get_prkey(lun, residx) == 0
-                || (residx != lun->pr_res_idx && lun->res_type < 4)) {
+               if (ctl_get_prkey(lun, residx) == 0 ||
+                   (residx != lun->pr_res_idx && lun->pr_res_type < 4)) {
                        ctl_set_reservation_conflict(ctsio);
                        retval = 1;
                        goto bailout;

diff --git a/sys/cam/ctl/ctl_private.h b/sys/cam/ctl/ctl_private.h
index 826d00492e176c2b607c87a8a09d6d0364f76819..f9b29ff118795371e5bad3dc31294200f51e3fa1 100644 (file)
--- a/sys/cam/ctl/ctl_private.h
+++ b/sys/cam/ctl/ctl_private.h
@@ -392,11 +392,11 @@ struct ctl_lun {
        struct ctl_log_pages            log_pages;
        struct ctl_lun_io_stats         stats;
        uint32_t                        res_idx;
-       unsigned int                    PRGeneration;
+       uint32_t                        pr_generation;
        uint64_t                        *pr_keys[CTL_MAX_PORTS];
        int                             pr_key_count;
        uint32_t                        pr_res_idx;
-       uint8_t                         res_type;
+       uint8_t                         pr_res_type;
        int                             prevent_count;
        uint32_t                        prevent[(CTL_MAX_INITIATORS+31)/32];
        uint8_t                         *write_buffer;