xref: /illumos-gate/usr/src/uts/common/io/comstar/lu/stmf_sbd/sbd_pgr.c (revision 61dfa509)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2014 Nexenta Systems, Inc.  All rights reserved.
 */

#include <sys/atomic.h>
#include <sys/conf.h>
#include <sys/byteorder.h>
#include <sys/scsi/scsi_types.h>
#include <sys/scsi/generic/persist.h>

#include <sys/lpif.h>
#include <sys/stmf.h>
#include <sys/stmf_ioctl.h>
#include <sys/portif.h>
#include <sys/stmf_sbd_ioctl.h>

#include "stmf_sbd.h"
#include "sbd_impl.h"

#define	MAX_PGR_PARAM_LIST_LENGTH	(256 * 1024)

int  sbd_pgr_reservation_conflict(scsi_task_t *, struct sbd_lu *sl);
void sbd_pgr_reset(sbd_lu_t *);
void sbd_pgr_initialize_it(scsi_task_t *, sbd_it_data_t *);
void sbd_handle_pgr_in_cmd(scsi_task_t *, stmf_data_buf_t *);
void sbd_handle_pgr_out_cmd(scsi_task_t *, stmf_data_buf_t *);
void sbd_handle_pgr_out_data(scsi_task_t *, stmf_data_buf_t *);
void sbd_pgr_keylist_dealloc(sbd_lu_t *);
char *sbd_get_devid_string(sbd_lu_t *);

sbd_status_t sbd_pgr_meta_init(sbd_lu_t *);
sbd_status_t sbd_pgr_meta_load(sbd_lu_t *);
sbd_status_t sbd_pgr_meta_write(sbd_lu_t *);
static void sbd_swap_pgr_info(sbd_pgr_info_t *);
static void sbd_swap_pgrkey_info(sbd_pgr_key_info_t *);
static void sbd_pgr_key_free(sbd_pgr_key_t *);
static void sbd_pgr_remove_key(sbd_lu_t *, sbd_pgr_key_t *);
static uint32_t sbd_pgr_remove_keys(sbd_lu_t *, sbd_it_data_t *,
	sbd_pgr_key_t *, uint64_t, boolean_t);
static boolean_t sbd_pgr_key_compare(sbd_pgr_key_t *, scsi_devid_desc_t *,
	stmf_remote_port_t *);
static sbd_pgr_key_t *sbd_pgr_key_alloc(scsi_devid_desc_t *,
	scsi_transport_id_t *, int16_t, int16_t);

static void sbd_pgr_set_pgr_check_flag(sbd_lu_t *, boolean_t);
static void sbd_pgr_set_ua_conditions(sbd_lu_t *, sbd_it_data_t *, uint8_t);
static void sbd_pgr_in_read_keys(scsi_task_t *, stmf_data_buf_t *);
static void sbd_pgr_in_report_capabilities(scsi_task_t *, stmf_data_buf_t *);
static void sbd_pgr_in_read_reservation(scsi_task_t *, stmf_data_buf_t *);
static void sbd_pgr_in_read_full_status(scsi_task_t *, stmf_data_buf_t *);
static void sbd_pgr_out_register(scsi_task_t *, stmf_data_buf_t *);
static void sbd_pgr_out_reserve(scsi_task_t *);
static void sbd_pgr_out_release(scsi_task_t *);
static void sbd_pgr_out_clear(scsi_task_t *);
static void sbd_pgr_out_preempt(scsi_task_t *, stmf_data_buf_t *);
static void sbd_pgr_out_register_and_move(scsi_task_t *, stmf_data_buf_t *);

static sbd_pgr_key_t *sbd_pgr_do_register(sbd_lu_t *, sbd_it_data_t *,
	scsi_devid_desc_t *, stmf_remote_port_t *, uint8_t, uint64_t);
static void sbd_pgr_do_unregister(sbd_lu_t *, sbd_it_data_t *, sbd_pgr_key_t *);
static void sbd_pgr_do_release(sbd_lu_t *, sbd_it_data_t *, uint8_t);
static void sbd_pgr_do_reserve(sbd_pgr_t *, sbd_pgr_key_t *, sbd_it_data_t *it,
	stmf_scsi_session_t *, scsi_cdb_prout_t *);

static boolean_t sbd_pgr_should_save(sbd_lu_t *);
extern sbd_status_t sbd_write_meta_section(sbd_lu_t *, sm_section_hdr_t *);
extern sbd_status_t sbd_read_meta_section(sbd_lu_t *, sm_section_hdr_t **,
	uint16_t);
extern void sbd_swap_section_hdr(sm_section_hdr_t *);
extern void sbd_handle_short_write_transfers(scsi_task_t *task,
	stmf_data_buf_t *dbuf, uint32_t cdb_xfer_size);
extern void sbd_handle_short_read_transfers(scsi_task_t *task,
	stmf_data_buf_t *dbuf, uint8_t *p, uint32_t cdb_xfer_size,
	uint32_t cmd_xfer_size);
extern uint16_t stmf_scsilib_get_lport_rtid(scsi_devid_desc_t *devid);
extern scsi_devid_desc_t *stmf_scsilib_get_devid_desc(uint16_t rtpid);
extern char sbd_ctoi(char c);

/*
 *
 *
 *   +-----------+
 *   |           |sl_it_list
 *   |           |---------------------------------------+
 *   |           |                                       |
 *   |  sbd_lu_t |                                       |
 *   |           |                                       |
 *   |           |                                       |
 *   |           |                                       |
 *   +-----+-----+                                       V
 *         |                                          +-------+
 *         V                                          |       |
 *   +-----------+ pgr_key_list               +------>|       |
 *   |           |------------+  +-->(NULL)   | +- ---|sbd_it |
 *   |           |            |  |            | |     | _data |
 *   | sbd_pgr_t |            V  |            | |     |       |
 *   |           |          +-------+         | |     +-------+
 *   |           |---+      |       |         | |         |
 *   |           |   |      |sbd_pgr|---------+ |         v
 *   +-----------+   |      | _key_t|<----------+     +-------+
 *                   |      |       |                 |       |
 *                   |      |       |                 |       |
 *                   |      +-------+        +--------|       |
 *                   |         |^            |        |       |
 *                   |         ||            |        |       |
 *                   |         v|            |        +-------+
 *                   |      +-------+        |            |
 *                   |      |       |        |            v
 *                   |      |ALL_TG_|<-------+        +-------+
 *                   |      |PT = 1 |<---------+      |       |
 *                   |      |       |---+      |      |       |
 *                   |      |       |   |      +------|       |
 *          (pgr_rsvholder  +-------+   V             |       |
 *             pgr_flags&      |^     (NUll)          |       |
 *              RSVD_ONE)      ||                     +-------+
 *                   |         v|                         |
 *                   |      +-------+                     v
 *                   |      |       |                 +-------+
 *                   |      |  not  |                 |       |
 *                   |      |claimed|---+             |       |
 *                   |      |       |   |        +----| unreg |
 *                   |      |       |   V        |    |       |
 *                   |      +-------+ (NUll)     V    |       |
 *                   |         |^              (NUll) +-------+
 *                   |         ||                         |
 *                   |         v|                         v
 *                   |      +-------+                 +-------+
 *                   |      |       |                 |       |
 *                   |      |reserv-|<----------------|       |
 *                   +----->|  ation|---------------->|       |
 *                          |holder |                 |       |
 *                          |key    |                 |       |
 *                          +-------+                 +-------+
 *                              |^                        |
 *                              ||                        v
 *                              v|                    +-------+
 *                           +-------+                |       |
 *                           |       |                |       |
 *                           |  not  |---+       +----| unreg |
 *                           |claimed|   |       |    |       |
 *                           |       |   V       V    |       |
 *                           |       | (NUll)  (NUll) +-------+
 *                           +-------+                    |
 *                              |                         v
 *                              v                      (NULL)
 *                           (NULL)
 *
 *
 */

#define	PGR_CONFLICT_FREE_CMDS(cdb)	( \
	/* ----------------------- */                                      \
	/* SPC-3 (rev 23) Table 31 */                                      \
	/* ----------------------- */                                      \
	((cdb[0]) == SCMD_INQUIRY)					|| \
	((cdb[0]) == SCMD_LOG_SENSE_G1)					|| \
	((cdb[0]) == SCMD_PERSISTENT_RESERVE_IN)			|| \
	((cdb[0]) == SCMD_REPORT_LUNS)					|| \
	((cdb[0]) == SCMD_REQUEST_SENSE)				|| \
	((cdb[0]) == SCMD_TEST_UNIT_READY)				|| \
	/* PREVENT ALLOW MEDIUM REMOVAL with prevent == 0 */               \
	((((cdb[0]) == SCMD_DOORLOCK) && (((cdb[4]) & 0x3) == 0)))	|| \
	/* SERVICE ACTION IN with READ MEDIA SERIAL NUMBER (0x01) */       \
	(((cdb[0]) == SCMD_SVC_ACTION_IN_G5) && (                          \
	    ((cdb[1]) & 0x1F) == 0x01))					|| \
	/* MAINTENANCE IN with service actions REPORT ALIASES (0x0Bh) */   \
	/* REPORT DEVICE IDENTIFIER (0x05)  REPORT PRIORITY (0x0Eh) */     \
	/* REPORT TARGET PORT GROUPS (0x0A) REPORT TIMESTAMP (0x0F) */     \
	(((cdb[0]) == SCMD_MAINTENANCE_IN) && (                            \
	    (((cdb[1]) & 0x1F) == 0x0B) ||                                 \
	    (((cdb[1]) & 0x1F) == 0x05) ||                                 \
	    (((cdb[1]) & 0x1F) == 0x0E) ||                                 \
	    (((cdb[1]) & 0x1F) == 0x0A) ||                                 \
	    (((cdb[1]) & 0x1F) == 0x0F)))				|| \
	/* REGISTER and REGISTER_AND_IGNORE_EXISTING_KEY */                \
	/* actions for PERSISTENT RESERVE OUT command */                   \
	(((cdb[0]) == SCMD_PERSISTENT_RESERVE_OUT) && (                    \
	    (((cdb[1]) & 0x1F) == PR_OUT_REGISTER_AND_IGNORE_EXISTING_KEY) || \
	    (((cdb[1]) & 0x1F) == PR_OUT_REGISTER)))			|| \
	/* ----------------------- */                                      \
	/* SBC-3 (rev 17) Table 3  */                                      \
	/* ----------------------- */                                      \
	/* READ CAPACITY(10) */                                            \
	((cdb[0]) == SCMD_READ_CAPACITY)				|| \
	/* READ CAPACITY(16) */                                            \
	(((cdb[0]) == SCMD_SVC_ACTION_IN_G4) && (                          \
	    ((cdb[1]) & 0x1F) == 0x10))					|| \
	/* START STOP UNIT with START bit 0 and POWER CONDITION 0  */      \
	(((cdb[0]) == SCMD_START_STOP) && (                                \
	    (((cdb[4]) & 0xF0) == 0) && (((cdb[4]) & 0x01) == 0))))
/* End of PGR_CONFLICT_FREE_CMDS */

/* Commands allowed for registered IT nexues but not reservation holder */
#define	PGR_REGISTERED_POSSIBLE_CMDS(cdb)	( \
	(((cdb[0]) == SCMD_PERSISTENT_RESERVE_OUT) && (                \
	    (((cdb[1]) & 0x1F) == PR_OUT_RELEASE)		||     \
	    (((cdb[1]) & 0x1F) == PR_OUT_CLEAR)			||     \
	    (((cdb[1]) & 0x1F) == PR_OUT_PREEMPT)		||     \
	    (((cdb[1]) & 0x1F) == PR_OUT_PREEMPT_ABORT))))

/* List of commands allowed when WR_EX type reservation held */
#define	PGR_READ_POSSIBLE_CMDS(c)	(  \
	((c) == SCMD_READ)		|| \
	((c) == SCMD_READ_G1)		|| \
	((c) == SCMD_READ_G4)		|| \
	((c) == SCMD_READ_G5)		|| \
	/* READ FETCH (10) (16) */         \
	((c) == SCMD_READ_POSITION)	|| \
	((c) == 0x90)			|| \
	/* READ DEFECT DATA */             \
	((c) == SCMD_READ_DEFECT_LIST)	|| \
	((c) == 0xB7)			|| \
	/* VERIFY (10) (16) (12) */        \
	((c) == SCMD_VERIFY)		|| \
	((c) == SCMD_VERIFY_G4)		|| \
	((c) == SCMD_VERIFY_G5)		|| \
	/* XDREAD (10) */                  \
	((c) == 0x52))

#define	PGR_RESERVATION_HOLDER(pgr, key, it)	( \
	((pgr)->pgr_flags & SBD_PGR_RSVD_ALL_REGISTRANTS) || ( \
	    ((pgr)->pgr_rsvholder) && ((pgr)->pgr_rsvholder == (key)) && \
	    ((key)->pgr_key_it) && ((key)->pgr_key_it == (it))))

#define	PGR_SET_FLAG(flg, val)		(atomic_or_8(&(flg), (val)))
#define	PGR_CLEAR_FLAG(flg, val)	(atomic_and_8(&(flg), ~(val)))
#define	PGR_CLEAR_RSV_FLAG(flg)		(atomic_and_8(&(flg), \
	(~(SBD_PGR_RSVD_ALL_REGISTRANTS | SBD_PGR_RSVD_ONE))))

#define	PGR_VALID_SCOPE(scope)	((scope) == PR_LU_SCOPE)
#define	PGR_VALID_TYPE(type)	( \
				((type) == PGR_TYPE_WR_EX)	|| \
				((type) == PGR_TYPE_EX_AC)	|| \
				((type) == PGR_TYPE_WR_EX_RO)	|| \
				((type) == PGR_TYPE_EX_AC_RO)	|| \
				((type) == PGR_TYPE_WR_EX_AR)	|| \
				((type) == PGR_TYPE_EX_AC_AR))

#define	ALIGNED_TO_8BYTE_BOUNDARY(i)	(((i) + 7) & ~7)

static void
sbd_swap_pgr_info(sbd_pgr_info_t *spi)
{
	sbd_swap_section_hdr(&spi->pgr_sms_header);
	if (spi->pgr_data_order == SMS_DATA_ORDER)
		return;
	spi->pgr_sms_header.sms_chksum += SMS_DATA_ORDER - spi->pgr_data_order;
	spi->pgr_rsvholder_indx		= BSWAP_32(spi->pgr_rsvholder_indx);
	spi->pgr_numkeys		= BSWAP_32(spi->pgr_numkeys);
}

static void
sbd_swap_pgrkey_info(sbd_pgr_key_info_t *key)
{
	key->pgr_key			= BSWAP_64(key->pgr_key);
	key->pgr_key_lpt_len		= BSWAP_16(key->pgr_key_lpt_len);
	key->pgr_key_rpt_len		= BSWAP_16(key->pgr_key_rpt_len);
}

sbd_status_t
sbd_pgr_meta_init(sbd_lu_t *slu)
{
	sbd_pgr_info_t	*spi = NULL;
	uint32_t	sz;
	sbd_status_t	ret;

	sz = sizeof (sbd_pgr_info_t);
	spi = (sbd_pgr_info_t *)kmem_zalloc(sz, KM_SLEEP);
	spi->pgr_data_order = SMS_DATA_ORDER;
	spi->pgr_sms_header.sms_size = sz;
	spi->pgr_sms_header.sms_id = SMS_ID_PGR_INFO;
	spi->pgr_sms_header.sms_data_order = SMS_DATA_ORDER;

	ret = sbd_write_meta_section(slu, (sm_section_hdr_t *)spi);
	kmem_free(spi, sz);
	return (ret);
}

/*
 * Evaluate common cases where a PERSISTENT RESERVE OUT CDB handler should call
 * sbd_pgr_meta_write().
 */
static boolean_t
sbd_pgr_should_save(sbd_lu_t *slu)
{
	sbd_pgr_t		*pgr = slu->sl_pgr;

	if (stmf_is_pgr_aptpl_always() == B_TRUE ||
	    (pgr->pgr_flags & (SBD_PGR_APTPL)))
		return (B_TRUE);
	else
		return (B_FALSE);
}

sbd_status_t
sbd_pgr_meta_load(sbd_lu_t *slu)
{
	sbd_pgr_t		*pgr = slu->sl_pgr;
	sbd_pgr_info_t		*spi = NULL;
	sbd_pgr_key_t		*key, *last_key = NULL;
	sbd_pgr_key_info_t	*spi_key;
	sbd_status_t		ret = SBD_SUCCESS;
	scsi_devid_desc_t	*lpt;
	uint8_t			*ptr, *keyoffset,  *endoffset;
	uint32_t		i, sz;

	ret = sbd_read_meta_section(slu, (sm_section_hdr_t **)&spi,
	    SMS_ID_PGR_INFO);
	if (ret != SBD_SUCCESS) {
		/* No PGR section found, means volume made before PGR support */
		if (ret == SBD_NOT_FOUND) {
			/* So just create a default PGR section */
			ret = sbd_pgr_meta_init(slu);
		}
		return (ret);
	}

	if (spi->pgr_data_order != SMS_DATA_ORDER) {
		sbd_swap_pgr_info(spi);
	}

	pgr->pgr_flags = spi->pgr_flags;
	/*
	 * We reload APTPL reservations when:
	 *  1. Global override is enabled
	 *  2. APTPL was explicitly asserted in the PERSISTENT RESERVE OUT CDB
	 */
	if (stmf_is_pgr_aptpl_always() || (pgr->pgr_flags & SBD_PGR_APTPL)) {
		pgr->pgr_rsv_type = spi->pgr_rsv_type;
		pgr->pgr_rsv_scope = spi->pgr_rsv_scope;
	} else {
		PGR_CLEAR_RSV_FLAG(pgr->pgr_flags);
	}

	PGR_CLEAR_FLAG(slu->sl_pgr->pgr_flags, SBD_PGR_ALL_KEYS_HAS_IT);

	endoffset	= (uint8_t *)spi;
	endoffset	+= spi->pgr_sms_header.sms_size;
	keyoffset	= (uint8_t *)(spi + 1);
	for (i = 1; i <= spi->pgr_numkeys; i++) {

		spi_key = (sbd_pgr_key_info_t *)keyoffset;
		if (spi->pgr_data_order != SMS_DATA_ORDER) {
			sbd_swap_pgrkey_info(spi_key);
		}

		/* Calculate the size and next offset */
		sz = ALIGNED_TO_8BYTE_BOUNDARY(sizeof (sbd_pgr_key_info_t) - 1 +
		    spi_key->pgr_key_lpt_len + spi_key->pgr_key_rpt_len);
		keyoffset += sz;

		/* Validate the key fields */
		if (spi_key->pgr_key_rpt_len == 0 || endoffset < keyoffset ||
		    (spi_key->pgr_key_lpt_len == 0 &&
		    !(spi_key->pgr_key_flags & SBD_PGR_KEY_ALL_TG_PT))) {
			ret = SBD_META_CORRUPTED;
			goto sbd_pgr_meta_load_failed;
		}

		lpt = (scsi_devid_desc_t *)spi_key->pgr_key_it;
		ptr = (uint8_t *)spi_key->pgr_key_it + spi_key->pgr_key_lpt_len;

		if (spi_key->pgr_key_flags & SBD_PGR_KEY_TPT_ID_FLAG) {
			uint16_t tpd_len = 0;

			if (!stmf_scsilib_tptid_validate(
			    (scsi_transport_id_t *)ptr,
			    spi_key->pgr_key_rpt_len, &tpd_len)) {
				ret = SBD_META_CORRUPTED;
				goto sbd_pgr_meta_load_failed;
			}
			if (tpd_len != spi_key->pgr_key_rpt_len) {
				ret = SBD_META_CORRUPTED;
				goto sbd_pgr_meta_load_failed;
			}
			key = sbd_pgr_key_alloc(lpt, (scsi_transport_id_t *)ptr,
			    spi_key->pgr_key_lpt_len, spi_key->pgr_key_rpt_len);
		} else {
			stmf_remote_port_t	*rpt = NULL;

			/*
			 * This block is executed only if the metadata was
			 * stored before the implementation of Transport ID
			 * support.
			 */
			rpt = stmf_scsilib_devid_to_remote_port(
			    (scsi_devid_desc_t *)ptr);
			if (rpt == NULL) {
				ret = SBD_META_CORRUPTED;
				goto sbd_pgr_meta_load_failed;
			}
			key = sbd_pgr_key_alloc(lpt, rpt->rport_tptid,
			    spi_key->pgr_key_lpt_len, rpt->rport_tptid_sz);
			stmf_remote_port_free(rpt);
		}

		key->pgr_key		= spi_key->pgr_key;
		key->pgr_key_flags	= spi_key->pgr_key_flags;
		key->pgr_key_prev	= last_key;

		if (last_key) {
			last_key->pgr_key_next = key;
		} else {
			pgr->pgr_keylist = key;
		}
		last_key = key;

		if ((pgr->pgr_flags & SBD_PGR_RSVD_ONE) &&
		    (i == spi->pgr_rsvholder_indx)) {
			pgr->pgr_rsvholder = key;
		}
	}

	kmem_free(spi, spi->pgr_sms_header.sms_size);
	return (ret);

sbd_pgr_meta_load_failed:
	{
	char *lun_name = sbd_get_devid_string(slu);
	sbd_pgr_keylist_dealloc(slu);
	kmem_free(spi, spi->pgr_sms_header.sms_size);
	cmn_err(CE_WARN, "sbd_pgr_meta_load: Failed to load PGR meta data "
	    "for lun %s.", lun_name);
	kmem_free(lun_name, strlen(lun_name) + 1);
	return (ret);
	}
}

sbd_status_t
sbd_pgr_meta_write(sbd_lu_t *slu)
{
	sbd_pgr_key_t		*key;
	sbd_pgr_info_t		*spi;
	sbd_pgr_key_info_t	*spi_key;
	sbd_pgr_t		*pgr = slu->sl_pgr;
	sbd_status_t		ret = SBD_SUCCESS;
	uint32_t		sz, totalsz;

	/* Calculate total pgr meta section size needed */
	sz = sizeof (sbd_pgr_info_t);
	if ((pgr->pgr_flags & SBD_PGR_APTPL) || stmf_is_pgr_aptpl_always()) {
		key = pgr->pgr_keylist;
		while (key != NULL) {
			sz = ALIGNED_TO_8BYTE_BOUNDARY(sz +
			    sizeof (sbd_pgr_key_info_t) - 1 +
			    key->pgr_key_lpt_len + key->pgr_key_rpt_len);
			key = key->pgr_key_next;
		}
	}
	totalsz = sz;

	spi = (sbd_pgr_info_t *)kmem_zalloc(totalsz, KM_SLEEP);
	spi->pgr_flags		= pgr->pgr_flags;
	spi->pgr_rsv_type	= pgr->pgr_rsv_type;
	spi->pgr_rsv_scope	= pgr->pgr_rsv_scope;
	spi->pgr_data_order	= SMS_DATA_ORDER;
	spi->pgr_numkeys	= 0;

	spi->pgr_sms_header.sms_size = totalsz;
	spi->pgr_sms_header.sms_id = SMS_ID_PGR_INFO;
	spi->pgr_sms_header.sms_data_order = SMS_DATA_ORDER;

	if ((pgr->pgr_flags & SBD_PGR_APTPL) || stmf_is_pgr_aptpl_always()) {
		uint8_t *ptr;
		key = pgr->pgr_keylist;
		sz = sizeof (sbd_pgr_info_t);
		while (key != NULL) {
			spi_key = (sbd_pgr_key_info_t *)((uint8_t *)spi + sz);
			spi_key->pgr_key = key->pgr_key;
			spi_key->pgr_key_flags = key->pgr_key_flags;
			spi_key->pgr_key_lpt_len = key->pgr_key_lpt_len;
			spi_key->pgr_key_rpt_len = key->pgr_key_rpt_len;
			ptr = spi_key->pgr_key_it;
			bcopy(key->pgr_key_lpt_id, ptr, key->pgr_key_lpt_len);
			ptr += key->pgr_key_lpt_len;
			bcopy(key->pgr_key_rpt_id, ptr, key->pgr_key_rpt_len);

			spi->pgr_numkeys++;
			if (key == pgr->pgr_rsvholder) {
				spi->pgr_rsvholder_indx = spi->pgr_numkeys;
			}

			sz = ALIGNED_TO_8BYTE_BOUNDARY(sz +
			    sizeof (sbd_pgr_key_info_t) - 1 +
			    key->pgr_key_lpt_len + key->pgr_key_rpt_len);
			key = key->pgr_key_next;
		}
	}
	rw_downgrade(&pgr->pgr_lock);
	ret = sbd_write_meta_section(slu, (sm_section_hdr_t *)spi);
	if (!rw_tryupgrade(&pgr->pgr_lock)) {
		rw_exit(&pgr->pgr_lock);
		rw_enter(&pgr->pgr_lock, RW_WRITER);
	}
	kmem_free(spi, totalsz);
	if (ret != SBD_SUCCESS) {
		sbd_pgr_key_t	*tmp_list;
		tmp_list = pgr->pgr_keylist;
		pgr->pgr_keylist = NULL;
		if (sbd_pgr_meta_load(slu) != SBD_SUCCESS) {
			char *lun_name = sbd_get_devid_string(slu);
			cmn_err(CE_WARN, "sbd_pgr_meta_write: Failed to revert "
			    "back to existing PGR state after meta write "
			    "failure, may cause PGR inconsistancy for lun %s.",
			    lun_name);
			kmem_free(lun_name, strlen(lun_name) + 1);
			pgr->pgr_keylist = tmp_list;
		} else {
			key = pgr->pgr_keylist;
			pgr->pgr_keylist = tmp_list;
			sbd_pgr_set_pgr_check_flag(slu, B_TRUE);
			sbd_pgr_keylist_dealloc(slu);
			pgr->pgr_keylist = key;
		}

	}
	return (ret);
}

static sbd_pgr_key_t *
sbd_pgr_key_alloc(scsi_devid_desc_t *lptid, scsi_transport_id_t *rptid,
    int16_t lpt_len, int16_t rpt_len)
{
	sbd_pgr_key_t *key;

	key = (sbd_pgr_key_t *)kmem_zalloc(sizeof (sbd_pgr_key_t), KM_SLEEP);

	if (lptid && lpt_len >= sizeof (scsi_devid_desc_t)) {
		key->pgr_key_lpt_len = lpt_len;
		key->pgr_key_lpt_id  = (scsi_devid_desc_t *)kmem_zalloc(
		    lpt_len, KM_SLEEP);
		bcopy(lptid, key->pgr_key_lpt_id, lpt_len);
	}

	if (rptid && rpt_len >= sizeof (scsi_transport_id_t)) {
		key->pgr_key_flags |= SBD_PGR_KEY_TPT_ID_FLAG;
		key->pgr_key_rpt_len = rpt_len;
		key->pgr_key_rpt_id  = (scsi_transport_id_t *)kmem_zalloc(
		    rpt_len, KM_SLEEP);
		bcopy(rptid, key->pgr_key_rpt_id, rpt_len);
	}

	return (key);
}

static void
sbd_pgr_key_free(sbd_pgr_key_t *key)
{
	if (key->pgr_key_lpt_id) {
		kmem_free(key->pgr_key_lpt_id, key->pgr_key_lpt_len);
	}
	if (key->pgr_key_rpt_id) {
		kmem_free(key->pgr_key_rpt_id, key->pgr_key_rpt_len);
	}
	kmem_free(key, sizeof (sbd_pgr_key_t));
}

void
sbd_pgr_keylist_dealloc(sbd_lu_t *slu)
{
	sbd_pgr_t	*pgr  = slu->sl_pgr;
	sbd_it_data_t	*it;
	sbd_pgr_key_t	*key;

	mutex_enter(&slu->sl_lock);
	for (it = slu->sl_it_list; it != NULL; it = it->sbd_it_next) {
		it->pgr_key_ptr = NULL;
	}
	mutex_exit(&slu->sl_lock);

	while (pgr->pgr_keylist != NULL) {
		key = pgr->pgr_keylist;
		pgr->pgr_keylist = key->pgr_key_next;
		sbd_pgr_key_free(key);
	}
}

/*
 * Reset and clear the keys, Can be used in the case of Lun Reset
 */
void
sbd_pgr_reset(sbd_lu_t *slu)
{
	sbd_pgr_t	*pgr  = slu->sl_pgr;

	rw_enter(&pgr->pgr_lock, RW_WRITER);
	if (!(pgr->pgr_flags & SBD_PGR_APTPL) &&
	    stmf_is_pgr_aptpl_always() == B_FALSE) {
		sbd_pgr_keylist_dealloc(slu);
		pgr->pgr_PRgeneration	= 0;
		pgr->pgr_rsvholder	= NULL;
		pgr->pgr_rsv_type	= 0;
		pgr->pgr_flags		= 0;
	}
	rw_exit(&pgr->pgr_lock);
}

static void
sbd_pgr_remove_key(sbd_lu_t *slu, sbd_pgr_key_t *key)
{
	sbd_pgr_t *pgr  = slu->sl_pgr;
	sbd_it_data_t *it;

	ASSERT(key);

	mutex_enter(&slu->sl_lock);
	if (key->pgr_key_flags & SBD_PGR_KEY_ALL_TG_PT) {
		for (it = slu->sl_it_list; it != NULL; it = it->sbd_it_next) {
			if (it->pgr_key_ptr == key)
				it->pgr_key_ptr = NULL;
		}
	} else {
		if (key->pgr_key_it) {
			key->pgr_key_it->pgr_key_ptr = NULL;
		}
	}
	mutex_exit(&slu->sl_lock);

	if (key->pgr_key_next) {
		key->pgr_key_next->pgr_key_prev = key->pgr_key_prev;
	}
	if (key->pgr_key_prev) {
		key->pgr_key_prev->pgr_key_next = key->pgr_key_next;
	} else {
		pgr->pgr_keylist =  key->pgr_key_next;
	}

	sbd_pgr_key_free(key);
}

/*
 * Remove keys depends on boolean variable "match"
 * match = B_TRUE  ==>	Remove all keys which matches the given svc_key,
 *			except for IT equal to given "my_it".
 * match = B_FALSE ==>	Remove all keys which does not matches the svc_key,
 *			except for IT equal to given "my_it"
 */
static uint32_t
sbd_pgr_remove_keys(sbd_lu_t *slu, sbd_it_data_t *my_it, sbd_pgr_key_t *my_key,
    uint64_t svc_key, boolean_t match)
{
	sbd_pgr_t	*pgr  = slu->sl_pgr;
	sbd_it_data_t	*it;
	sbd_pgr_key_t	*nextkey, *key = pgr->pgr_keylist;
	uint32_t	count = 0;

	while (key) {

		nextkey = key->pgr_key_next;
		if (match == B_TRUE && key->pgr_key == svc_key ||
		    match == B_FALSE && key->pgr_key != svc_key) {
			/*
			 * If the key is registered by current IT keep it,
			 * but just remove pgr pointers from other ITs
			 */
			if (key == my_key) {
				mutex_enter(&slu->sl_lock);
				for (it = slu->sl_it_list; it != NULL;
				    it = it->sbd_it_next) {
					if (it->pgr_key_ptr == key &&
					    it != my_it)
						it->pgr_key_ptr = NULL;
				}
				mutex_exit(&slu->sl_lock);
			} else {
				sbd_pgr_remove_key(slu, key);
			}
			count++;
		}
		key = nextkey;
	}
	return (count);
}

static void
sbd_pgr_set_ua_conditions(sbd_lu_t *slu, sbd_it_data_t *my_it, uint8_t ua)
{
	sbd_it_data_t *it;

	mutex_enter(&slu->sl_lock);
	for (it = slu->sl_it_list; it != NULL; it = it->sbd_it_next) {
		if (it == my_it)
			continue;
		it->sbd_it_ua_conditions |= ua;
	}
	mutex_exit(&slu->sl_lock);
}

/*
 * Set the SBD_IT_PGR_CHECK_FLAG  depends on variable "registered". See Below.
 *
 *   If
 *     registered is B_TRUE  => Set PGR_CHECK_FLAG on all registered IT nexus
 *     registered is B_FALSE => Set PGR_CHECK_FLAG on all unregistered IT nexus
 */
static void
sbd_pgr_set_pgr_check_flag(sbd_lu_t *slu, boolean_t registered)
{
	sbd_it_data_t *it;

	PGR_CLEAR_FLAG(slu->sl_pgr->pgr_flags, SBD_PGR_ALL_KEYS_HAS_IT);
	mutex_enter(&slu->sl_lock);
	for (it = slu->sl_it_list; it != NULL; it = it->sbd_it_next) {
		if (it->pgr_key_ptr) {
			if (registered == B_TRUE)  {
				it->sbd_it_flags |=  SBD_IT_PGR_CHECK_FLAG;
			}
		} else {
			if (registered == B_FALSE)
				it->sbd_it_flags |=  SBD_IT_PGR_CHECK_FLAG;
		}
	}
	mutex_exit(&slu->sl_lock);
}

static boolean_t
sbd_pgr_key_compare(sbd_pgr_key_t *key, scsi_devid_desc_t *lpt,
    stmf_remote_port_t *rpt)
{
	scsi_devid_desc_t *id;

	if (!stmf_scsilib_tptid_compare(rpt->rport_tptid, key->pgr_key_rpt_id))
			return (B_FALSE);

	/*
	 * You can skip target port name comparison if ALL_TG_PT flag
	 * is set for this key;
	 */
	if (!(key->pgr_key_flags & SBD_PGR_KEY_ALL_TG_PT) && lpt) {
		id = key->pgr_key_lpt_id;
		if ((lpt->ident_length != id->ident_length) ||
		    (memcmp(id->ident, lpt->ident, id->ident_length) != 0)) {
			return (B_FALSE);
		}
	}
	return (B_TRUE);
}


sbd_pgr_key_t *
sbd_pgr_key_registered(sbd_pgr_t *pgr, scsi_devid_desc_t *lpt,
    stmf_remote_port_t *rpt)
{
	sbd_pgr_key_t *key;

	for (key = pgr->pgr_keylist; key != NULL; key = key->pgr_key_next) {
		if (sbd_pgr_key_compare(key, lpt, rpt) == B_TRUE) {
			return (key);
		}
	}
	return (NULL);
}

void
sbd_pgr_initialize_it(scsi_task_t *task, sbd_it_data_t *it)
{
	sbd_lu_t *slu = (sbd_lu_t *)task->task_lu->lu_provider_private;
	stmf_scsi_session_t	*ses = task->task_session;
	sbd_pgr_t		*pgr = slu->sl_pgr;
	sbd_pgr_key_t		*key;
	scsi_devid_desc_t	*lpt, *id;
	stmf_remote_port_t	*rpt;

	if (pgr->pgr_flags & SBD_PGR_ALL_KEYS_HAS_IT)
		return;

	rpt = ses->ss_rport;
	lpt = ses->ss_lport->lport_id;

	rw_enter(&pgr->pgr_lock, RW_WRITER);
	PGR_SET_FLAG(pgr->pgr_flags,  SBD_PGR_ALL_KEYS_HAS_IT);
	for (key = pgr->pgr_keylist; key != NULL; key = key->pgr_key_next) {

		if ((!(key->pgr_key_flags & SBD_PGR_KEY_ALL_TG_PT)) &&
		    key->pgr_key_it != NULL)
			continue;
		/*
		 * SBD_PGR_ALL_KEYS_HAS_IT is set only if no single key
		 * in the list has SBD_PGR_KEY_ALL_TG_PT flag set and
		 * pgr_key_it all keys points to some IT
		 */
		PGR_CLEAR_FLAG(pgr->pgr_flags, SBD_PGR_ALL_KEYS_HAS_IT);

		/* Check if key matches with given lpt rpt combination */
		if (sbd_pgr_key_compare(key, lpt, rpt) == B_FALSE)
			continue;

		/* IT nexus devid information matches with this key */
		if (key->pgr_key_flags & SBD_PGR_KEY_ALL_TG_PT) {
			/*
			 * If ALL_TG_PT is set, pgr_key_it will point to NULL,
			 * unless pgr->pgr_rsvholder pointing to this key.
			 * In that case, pgr_key_it should point to the IT
			 * which initiated that reservation.
			 */
			if (pgr->pgr_rsvholder == key) {
				id = key->pgr_key_lpt_id;
				if (lpt->ident_length == id->ident_length) {
					if (memcmp(id->ident, lpt->ident,
					    id->ident_length) == 0)
						key->pgr_key_it = it;
				}
			}

		} else {
			key->pgr_key_it = it;
		}

		mutex_enter(&slu->sl_lock);
		it->pgr_key_ptr = key;
		mutex_exit(&slu->sl_lock);
		rw_exit(&pgr->pgr_lock);
		return;
	}
	rw_exit(&pgr->pgr_lock);
}

/*
 * Check for any PGR Reservation conflict. return 0 if access allowed
 */
int
sbd_pgr_reservation_conflict(scsi_task_t *task, sbd_lu_t *slu)
{
	sbd_pgr_t	*pgr = slu->sl_pgr;
	sbd_it_data_t	*it  = (sbd_it_data_t *)task->task_lu_itl_handle;

	/* If Registered */
	if (pgr->pgr_flags & SBD_PGR_RSVD_ALL_REGISTRANTS && it->pgr_key_ptr)
			return (0);

	/* If you are registered */
	if (pgr->pgr_flags & SBD_PGR_RSVD_ONE) {
		rw_enter(&pgr->pgr_lock, RW_READER);

		/*
		 * Note: it->pgr_key_ptr is protected by sl_lock. Also,
		 *    it is expected to change its value only with pgr_lock
		 *    held. Hence we are safe to read its value without
		 *    grabbing sl_lock. But make sure that the value used is
		 *    not from registers by using "volatile" keyword.
		 *    Since this funtion is in performance path, we may want
		 *    to avoid grabbing sl_lock.
		 */
		if ((volatile sbd_pgr_key_t *)it->pgr_key_ptr) {
			/* If you are the reservation holder */
			if (pgr->pgr_rsvholder == it->pgr_key_ptr &&
			    it->pgr_key_ptr->pgr_key_it == it) {
				rw_exit(&pgr->pgr_lock);
				return (0);
			}

			/* If reserve type is not EX_AC */
			if (pgr->pgr_rsv_type != PGR_TYPE_EX_AC) {
				/* If reserve type is WR_EX allow read */
				if (pgr->pgr_rsv_type == PGR_TYPE_WR_EX) {
					if (PGR_READ_POSSIBLE_CMDS(
					    task->task_cdb[0])) {
						rw_exit(&pgr->pgr_lock);
						return (0);
					}
				/* For all other reserve types allow access */
				} else {
					rw_exit(&pgr->pgr_lock);
					return (0);
				}
			}

			/* If registered, allow these commands */
			if (PGR_REGISTERED_POSSIBLE_CMDS(task->task_cdb)) {
				rw_exit(&pgr->pgr_lock);
				return (0);
			}
		}
		rw_exit(&pgr->pgr_lock);
	}

	/* For any case, allow these commands */
	if (PGR_CONFLICT_FREE_CMDS(task->task_cdb)) {
		return (0);
	}

	/* Give read access if reservation type WR_EX for registrants */
	if (pgr->pgr_rsv_type == PGR_TYPE_WR_EX_RO ||
	    pgr->pgr_rsv_type == PGR_TYPE_WR_EX_AR) {
		if (PGR_READ_POSSIBLE_CMDS(task->task_cdb[0]))
			return (0);
	}

	/* If  you reached here, No access for you */
	return (1);
}

void
sbd_handle_pgr_in_cmd(scsi_task_t *task, stmf_data_buf_t *initial_dbuf)
{

	sbd_lu_t	*slu = (sbd_lu_t *)task->task_lu->lu_provider_private;
	sbd_pgr_t	*pgr = slu->sl_pgr;
	scsi_cdb_prin_t *pr_in;

	ASSERT(task->task_cdb[0] == SCMD_PERSISTENT_RESERVE_IN);

	pr_in = (scsi_cdb_prin_t *)task->task_cdb;

	rw_enter(&pgr->pgr_lock, RW_READER);
	switch (pr_in->action) {
	case PR_IN_READ_KEYS:
		sbd_pgr_in_read_keys(task, initial_dbuf);
		break;
	case PR_IN_READ_RESERVATION:
		sbd_pgr_in_read_reservation(task, initial_dbuf);
		break;
	case PR_IN_REPORT_CAPABILITIES:
		sbd_pgr_in_report_capabilities(task, initial_dbuf);
		break;
	case PR_IN_READ_FULL_STATUS:
		sbd_pgr_in_read_full_status(task, initial_dbuf);
		break;
	default :
		stmf_scsilib_send_status(task, STATUS_CHECK,
		    STMF_SAA_INVALID_FIELD_IN_CDB);
		break;
	}
	rw_exit(&pgr->pgr_lock);
}

void
sbd_handle_pgr_out_cmd(scsi_task_t *task, stmf_data_buf_t *initial_dbuf)
{

	scsi_cdb_prout_t *pr_out = (scsi_cdb_prout_t *)task->task_cdb;
	uint32_t param_len;

	ASSERT(task->task_cdb[0] == SCMD_PERSISTENT_RESERVE_OUT);

	switch (pr_out->action) {
		case PR_OUT_REGISTER:
		case PR_OUT_RESERVE:
		case PR_OUT_RELEASE:
		case PR_OUT_CLEAR:
		case PR_OUT_PREEMPT:
		case PR_OUT_PREEMPT_ABORT:
		case PR_OUT_REGISTER_AND_IGNORE_EXISTING_KEY:
		case PR_OUT_REGISTER_MOVE:
			param_len = READ_SCSI32(pr_out->param_len, uint32_t);
			if (param_len < MAX_PGR_PARAM_LIST_LENGTH &&
			    param_len > 0) {
				sbd_handle_short_write_transfers(task,
				    initial_dbuf, param_len);
			} else {
				stmf_scsilib_send_status(task, STATUS_CHECK,
				    STMF_SAA_PARAM_LIST_LENGTH_ERROR);
			}
			break;
		default :
			stmf_scsilib_send_status(task, STATUS_CHECK,
			    STMF_SAA_INVALID_FIELD_IN_CDB);
			break;
	}
}

void
sbd_handle_pgr_out_data(scsi_task_t *task, stmf_data_buf_t *dbuf)
{
	sbd_lu_t	*slu = (sbd_lu_t *)task->task_lu->lu_provider_private;
	scsi_cdb_prout_t	*pr_out	= (scsi_cdb_prout_t *)task->task_cdb;
	sbd_it_data_t		*it	= task->task_lu_itl_handle;
	sbd_pgr_t		*pgr	= slu->sl_pgr;
	sbd_pgr_key_t		*key;
	scsi_prout_plist_t	*plist;
	uint64_t		rsv_key;
	uint32_t		buflen;
	uint8_t			*buf;

	ASSERT(task->task_cdb[0] == SCMD_PERSISTENT_RESERVE_OUT);

	if (dbuf == NULL || dbuf->db_data_size < 24) {
		stmf_scsilib_send_status(task, STATUS_CHECK,
		    STMF_SAA_PARAM_LIST_LENGTH_ERROR);
		return;
	}

	buf = dbuf->db_sglist[0].seg_addr;
	buflen = dbuf->db_data_size;
	plist = (scsi_prout_plist_t *)buf;

	/* SPC3 - 6.12.1 */
	if (pr_out->action != PR_OUT_REGISTER_MOVE && buflen != 24) {
		if ((pr_out->action !=
		    PR_OUT_REGISTER_AND_IGNORE_EXISTING_KEY &&
		    pr_out->action != PR_OUT_REGISTER) ||
		    plist->spec_i_pt == 0) {
			stmf_scsilib_send_status(task, STATUS_CHECK,
			    STMF_SAA_PARAM_LIST_LENGTH_ERROR);
			return;
		}
	}

	/*
	 * Common Reservation Conflict Checks
	 *
	 * It is okey to handle REGISTER_MOVE with same plist here,
	 * because we are only accessing reservation key feild.
	 */
	rw_enter(&pgr->pgr_lock, RW_WRITER);

	/*
	 * Currently it is not mandatory to have volatile keyword here,
	 * because, it->pgr_key_ptr is not accessed yet. But still
	 * keeping it to safe gaurd against any possible future changes.
	 */
	key = (sbd_pgr_key_t *)((volatile sbd_pgr_key_t *)it->pgr_key_ptr);
	if (pr_out->action != PR_OUT_REGISTER &&
	    pr_out->action != PR_OUT_REGISTER_AND_IGNORE_EXISTING_KEY) {
		/* if IT is not yet registered send conflict status */
		if (key == NULL) {
			if (pr_out->action == PR_OUT_REGISTER_MOVE &&
			    SBD_PGR_RSVD_NONE(pgr)) {
				stmf_scsilib_send_status(task, STATUS_CHECK,
				    STMF_SAA_INVALID_FIELD_IN_CDB);

			} else {
				stmf_scsilib_send_status(task,
				    STATUS_RESERVATION_CONFLICT, 0);
			}
			rw_exit(&pgr->pgr_lock);
			return;
		}

		/* Given reservation key should matches with registered key */
		rsv_key = READ_SCSI64(plist->reservation_key, uint64_t);
		if (key->pgr_key != rsv_key) {
			stmf_scsilib_send_status(task,
			    STATUS_RESERVATION_CONFLICT, 0);
			rw_exit(&pgr->pgr_lock);
			return;
		}
	}

	switch (pr_out->action) {
	case PR_OUT_REGISTER:
	case PR_OUT_REGISTER_AND_IGNORE_EXISTING_KEY:
		sbd_pgr_out_register(task, dbuf);
		break;
	case PR_OUT_REGISTER_MOVE:
		sbd_pgr_out_register_and_move(task, dbuf);
		break;
	case PR_OUT_RESERVE:
		sbd_pgr_out_reserve(task);
		break;
	case PR_OUT_RELEASE:
		sbd_pgr_out_release(task);
		break;
	case PR_OUT_CLEAR:
		sbd_pgr_out_clear(task);
		break;
	case PR_OUT_PREEMPT:
	case PR_OUT_PREEMPT_ABORT:
		sbd_pgr_out_preempt(task, dbuf);
		break;
	default :
		stmf_scsilib_send_status(task, STATUS_CHECK,
		    STMF_SAA_INVALID_FIELD_IN_CDB);
		break;
	}
	rw_exit(&pgr->pgr_lock);
}

static void
sbd_pgr_in_read_keys(scsi_task_t *task, stmf_data_buf_t *initial_dbuf)
{
	sbd_lu_t	*slu   = (sbd_lu_t *)task->task_lu->lu_provider_private;
	sbd_pgr_t	*pgr   =  slu->sl_pgr;
	sbd_pgr_key_t	*key;
	scsi_prin_readrsrv_t *buf;
	uint32_t buf_size, cdb_len, numkeys = 0;
	uint64_t *reg_key;

	ASSERT(task->task_cdb[0] == SCMD_PERSISTENT_RESERVE_IN);

	cdb_len = READ_SCSI16(&task->task_cdb[7], uint16_t);
	for (key = pgr->pgr_keylist; key != NULL; key = key->pgr_key_next)
		++numkeys;
	buf_size = 8 + numkeys * 8; /* minimum 8 bytes */
	buf = kmem_zalloc(buf_size, KM_SLEEP);
	SCSI_WRITE32(buf->PRgeneration, pgr->pgr_PRgeneration);
	SCSI_WRITE32(buf->add_len, numkeys * 8);

	reg_key = (uint64_t *)&buf->key_list;
	for (key = pgr->pgr_keylist; key != NULL; key = key->pgr_key_next) {
		SCSI_WRITE64(reg_key, key->pgr_key);
		reg_key++;
	}
	sbd_handle_short_read_transfers(task, initial_dbuf, (uint8_t *)buf,
	    cdb_len, buf_size);
	kmem_free(buf, buf_size);
}

static void
sbd_pgr_in_read_reservation(scsi_task_t *task, stmf_data_buf_t *initial_dbuf)
{
	sbd_lu_t	*slu   = (sbd_lu_t *)task->task_lu->lu_provider_private;
	sbd_pgr_t	*pgr   =  slu->sl_pgr;
	scsi_prin_readrsrv_t *buf;
	uint32_t cdb_len, buf_len, buf_size = 24;

	ASSERT(task->task_cdb[0] == SCMD_PERSISTENT_RESERVE_IN);

	cdb_len = READ_SCSI16(&task->task_cdb[7], uint16_t);
	buf = kmem_zalloc(buf_size, KM_SLEEP); /* fixed size cdb, 24 bytes */
	SCSI_WRITE32(buf->PRgeneration, pgr->pgr_PRgeneration);

	if (SBD_PGR_RSVD_NONE(pgr)) {
		SCSI_WRITE32(buf->add_len, 0);
		buf_len = 8;
	} else {
		if (pgr->pgr_flags & SBD_PGR_RSVD_ALL_REGISTRANTS) {
			SCSI_WRITE64(
			    buf->key_list.res_key_list[0].reservation_key, 0);
		} else {
			SCSI_WRITE64(
			    buf->key_list.res_key_list[0].reservation_key,
			    pgr->pgr_rsvholder->pgr_key);
		}
		buf->key_list.res_key_list[0].type = pgr->pgr_rsv_type;
		buf->key_list.res_key_list[0].scope = pgr->pgr_rsv_scope;
		SCSI_WRITE32(buf->add_len, 16);
		buf_len = 24;
	}

	sbd_handle_short_read_transfers(task, initial_dbuf, (uint8_t *)buf,
	    cdb_len, buf_len);
	kmem_free(buf, buf_size);
}

static void
sbd_pgr_in_report_capabilities(scsi_task_t *task,
    stmf_data_buf_t *initial_dbuf)
{
	sbd_lu_t	*slu   = (sbd_lu_t *)task->task_lu->lu_provider_private;
	sbd_pgr_t	*pgr   =  slu->sl_pgr;
	scsi_prin_rpt_cap_t buf;
	uint32_t cdb_len;

	ASSERT(task->task_cdb[0] == SCMD_PERSISTENT_RESERVE_IN);
	ASSERT(pgr != NULL);

	bzero(&buf, sizeof (buf));
	buf.ptpl_c		= 1;   /* Persist Through Power Loss C */
	buf.atp_c		= 1;   /* All Target Ports Capable */
	buf.sip_c		= 1;   /* Specify Initiator Ports Capable */
	buf.crh			= 0;   /* Supports Reserve/Release exception */
	buf.tmv			= 1;   /* Type Mask Valid */
	buf.pr_type.wr_ex	= 1;   /* Write Exclusve */
	buf.pr_type.ex_ac	= 1;   /* Exclusive Access */
	buf.pr_type.wr_ex_ro	= 1;   /* Write Exclusive Registrants Only */
	buf.pr_type.ex_ac_ro	= 1;   /* Exclusive Access Registrants Only */
	buf.pr_type.wr_ex_ar	= 1;   /* Write Exclusive All Registrants */
	buf.pr_type.ex_ac_ar	= 1;   /* Exclusive Access All Registrants */

	/* Persist Though Power Loss Active */
	buf.ptpl_a = pgr->pgr_flags & SBD_PGR_APTPL;
	SCSI_WRITE16(&buf.length, 8);
	cdb_len = READ_SCSI16(&task->task_cdb[7], uint16_t);
	sbd_handle_short_read_transfers(task, initial_dbuf, (uint8_t *)&buf,
	    cdb_len, 8);
}

/* Minimum required size, SPC3 rev23 Table 110 */
#define	PGR_IN_READ_FULL_STATUS_MINBUFSZ	8
/* Full Satus Descriptor Fromat size, SPC3 rev23 Table 111 */
#define	PGR_IN_READ_FULL_STATUS_DESCFMTSZ	24

static void
sbd_pgr_in_read_full_status(scsi_task_t *task,
    stmf_data_buf_t *initial_dbuf)
{
	sbd_lu_t	*slu   = (sbd_lu_t *)task->task_lu->lu_provider_private;
	sbd_pgr_t	*pgr   = slu->sl_pgr;
	sbd_pgr_key_t	*key;
	scsi_prin_status_t	*sts;
	scsi_prin_full_status_t	*buf;
	uint32_t		i, buf_size, cdb_len;
	uint8_t			*offset;

	ASSERT(task->task_cdb[0] == SCMD_PERSISTENT_RESERVE_IN);
	ASSERT(pgr != NULL);

	/* 4 byte allocation length for CDB, SPC3 rev23, Table 101 */
	cdb_len = READ_SCSI16(&task->task_cdb[7], uint16_t);

	/* PRgeneration and additional length fields */
	buf_size = PGR_IN_READ_FULL_STATUS_MINBUFSZ;
	for (key = pgr->pgr_keylist; key != NULL; key = key->pgr_key_next) {
		buf_size  = buf_size + PGR_IN_READ_FULL_STATUS_DESCFMTSZ +
		    key->pgr_key_rpt_len;
	}

	buf = kmem_zalloc(buf_size, KM_SLEEP);
	SCSI_WRITE32(buf->PRgeneration, pgr->pgr_PRgeneration);
	SCSI_WRITE32(buf->add_len, buf_size - PGR_IN_READ_FULL_STATUS_MINBUFSZ);

	offset	= (uint8_t *)&buf->full_desc[0];
	key	= pgr->pgr_keylist;
	i	= 0;
	while (key) {
		sts = (scsi_prin_status_t *)offset;
		SCSI_WRITE64(sts->reservation_key, key->pgr_key);
		if ((pgr->pgr_flags & SBD_PGR_RSVD_ALL_REGISTRANTS) ||
		    (pgr->pgr_rsvholder && pgr->pgr_rsvholder == key)) {
				sts->r_holder	= 1;
				sts->type	= pgr->pgr_rsv_type;
				sts->scope	= pgr->pgr_rsv_scope;
		}

		if (key->pgr_key_flags & SBD_PGR_KEY_ALL_TG_PT) {
			sts->all_tg_pt = 1;
		} else {
			SCSI_WRITE16(sts->rel_tgt_port_id,
			    stmf_scsilib_get_lport_rtid(key->pgr_key_lpt_id));
		}
		SCSI_WRITE32(sts->add_len, key->pgr_key_rpt_len);
		offset += PGR_IN_READ_FULL_STATUS_DESCFMTSZ;
		(void) memcpy(offset, key->pgr_key_rpt_id,
		    key->pgr_key_rpt_len);
		offset += key->pgr_key_rpt_len;
		key = key->pgr_key_next;
		++i;
	}
	ASSERT(offset <= (uint8_t *)buf + buf_size);

	sbd_handle_short_read_transfers(task, initial_dbuf, (uint8_t *)buf,
	    cdb_len, buf_size);
	kmem_free(buf, buf_size);
}

static void
sbd_pgr_out_register(scsi_task_t *task, stmf_data_buf_t *dbuf)
{
	sbd_lu_t	*slu = (sbd_lu_t *)task->task_lu->lu_provider_private;
	sbd_pgr_t		*pgr	= slu->sl_pgr;
	stmf_scsi_session_t	*ses	= task->task_session;
	sbd_it_data_t		*it	= task->task_lu_itl_handle;
	sbd_pgr_key_t		*key	= it->pgr_key_ptr;
	scsi_cdb_prout_t	*pr_out	= (scsi_cdb_prout_t *)task->task_cdb;
	scsi_devid_desc_t	*lpt	= ses->ss_lport->lport_id;
	scsi_prout_plist_t	*plist;
	stmf_remote_port_t	rport;
	uint8_t			*buf, keyflag;
	uint32_t		buflen;
	uint64_t		rsv_key, svc_key;

	buf = dbuf->db_sglist[0].seg_addr;
	plist = (scsi_prout_plist_t *)buf;
	buflen = dbuf->db_data_size;
	rsv_key = READ_SCSI64(plist->reservation_key, uint64_t);
	svc_key = READ_SCSI64(plist->service_key, uint64_t);

	/* Handling already registered IT session */
	if (key) {

		if (pr_out->action == PR_OUT_REGISTER &&
		    key->pgr_key != rsv_key) {
			stmf_scsilib_send_status(task,
			    STATUS_RESERVATION_CONFLICT, 0);
			return;
		}
		if (plist->spec_i_pt) {
			stmf_scsilib_send_status(task, STATUS_CHECK,
			    STMF_SAA_INVALID_FIELD_IN_CDB);
			return;
		}

		if (plist->all_tg_pt !=
		    (key->pgr_key_flags & SBD_PGR_KEY_ALL_TG_PT)) {
			stmf_scsilib_send_status(task, STATUS_CHECK,
			    STMF_SAA_INVALID_FIELD_IN_CDB);
			return;
		}

		if (svc_key == 0) {
			sbd_pgr_do_unregister(slu, it, key);
		} else {
			key->pgr_key = svc_key;
		}

		goto sbd_pgr_reg_done;
	}

	/* Handling unregistered IT session */
	if (pr_out->action == PR_OUT_REGISTER && rsv_key != 0) {
		stmf_scsilib_send_status(task, STATUS_RESERVATION_CONFLICT, 0);
		return;
	}

	if (svc_key == 0) {
		/* Do we need to consider aptpl here? I don't think so */
		pgr->pgr_PRgeneration++;
		stmf_scsilib_send_status(task, STATUS_GOOD, 0);
		return;
	}

	keyflag = SBD_PGR_KEY_TPT_ID_FLAG;
	if (plist->all_tg_pt) {
		keyflag |= SBD_PGR_KEY_ALL_TG_PT;
		lpt = NULL;
	}

	if (plist->spec_i_pt) {
		uint32_t max_tpdnum, tpdnum, i, adn_len = 0;
		uint16_t tpd_sz = 0;
		uint8_t *adn_dat;
		scsi_transport_id_t *tpd;
		stmf_remote_port_t *rpt_ary;

		if (pr_out->action == PR_OUT_REGISTER_AND_IGNORE_EXISTING_KEY) {
			stmf_scsilib_send_status(task, STATUS_CHECK,
			    STMF_SAA_INVALID_FIELD_IN_CDB);
			return;
		}

		/* Length validation SPC3 rev23 Section 6.12.3 and Table 115 */
		if (buflen >= sizeof (scsi_prout_plist_t) - 1 +
		    sizeof (uint32_t))
			adn_len = READ_SCSI32(plist->apd, uint32_t);
		/* SPC3 rev23, adn_len should be multiple of 4 */
		if (adn_len % 4 != 0 ||
		    adn_len < sizeof (scsi_transport_id_t) +
		    sizeof (uint32_t) ||
		    buflen < sizeof (scsi_prout_plist_t) - 1 + adn_len) {
			stmf_scsilib_send_status(task, STATUS_CHECK,
			    STMF_SAA_PARAM_LIST_LENGTH_ERROR);
			return;
		}

		tpdnum = 0;
		adn_dat = plist->apd + sizeof (uint32_t);
		max_tpdnum = adn_len / sizeof (scsi_transport_id_t);
		rpt_ary = (stmf_remote_port_t *)kmem_zalloc(
		    sizeof (stmf_remote_port_t) * max_tpdnum, KM_SLEEP);

		/* Check the validity of given TransportIDs */
		while (adn_len != 0) {
			if (!stmf_scsilib_tptid_validate(
			    (scsi_transport_id_t *)adn_dat, adn_len, &tpd_sz))
				break;
			/* SPC3 rev23, tpd_sz should be multiple of 4 */
			if (tpd_sz == 0 || tpd_sz % 4 != 0)
				break;
			tpd = (scsi_transport_id_t *)adn_dat;

			/* make sure that there is no duplicates */
			for (i = 0; i < tpdnum; i++) {
				if (stmf_scsilib_tptid_compare(
				    rpt_ary[i].rport_tptid, tpd))
					break;
			}
			if (i < tpdnum)
				break;

			rpt_ary[tpdnum].rport_tptid = tpd;
			rpt_ary[tpdnum].rport_tptid_sz = tpd_sz;

			/* Check if the given IT nexus is already registered */
			if (sbd_pgr_key_registered(pgr, lpt, &rpt_ary[tpdnum]))
				break;

			adn_len -= tpd_sz;
			adn_dat += tpd_sz;
			tpdnum++;
		}

		if (adn_len != 0) {
			kmem_free(rpt_ary,
			    sizeof (stmf_remote_port_t) * max_tpdnum);
			stmf_scsilib_send_status(task, STATUS_CHECK,
			    STMF_SAA_INVALID_FIELD_IN_CDB);
			return;
		}

		for (i = 0; i < tpdnum; i++) {
			(void) sbd_pgr_do_register(slu, NULL, lpt, &rpt_ary[i],
			    keyflag, svc_key);
		}
		kmem_free(rpt_ary, sizeof (stmf_remote_port_t) * max_tpdnum);
	}

	rport.rport_tptid = ses->ss_rport->rport_tptid;
	rport.rport_tptid_sz = ses->ss_rport->rport_tptid_sz;

	(void) sbd_pgr_do_register(slu, it, lpt, &rport, keyflag, svc_key);

sbd_pgr_reg_done:

	if (plist->aptpl || (sbd_pgr_should_save(slu) == B_TRUE)) {
		if (plist->aptpl)
			PGR_SET_FLAG(pgr->pgr_flags, SBD_PGR_APTPL);
		else
			PGR_CLEAR_FLAG(pgr->pgr_flags, SBD_PGR_APTPL);

		if (sbd_pgr_meta_write(slu) != SBD_SUCCESS) {
			stmf_scsilib_send_status(task, STATUS_CHECK,
			    STMF_SAA_INSUFFICIENT_REG_RESRCS);
			return;
		}
	}

	pgr->pgr_PRgeneration++;
	stmf_scsilib_send_status(task, STATUS_GOOD, 0);
}

static sbd_pgr_key_t *
sbd_pgr_do_register(sbd_lu_t *slu, sbd_it_data_t *it, scsi_devid_desc_t *lpt,
    stmf_remote_port_t *rpt, uint8_t keyflag, uint64_t svc_key)
{
	sbd_pgr_t		*pgr = slu->sl_pgr;
	sbd_pgr_key_t		*key;
	uint16_t		lpt_len = 0;

	if (lpt)
		lpt_len	= sizeof (scsi_devid_desc_t) + lpt->ident_length;

	key = sbd_pgr_key_alloc(lpt, rpt->rport_tptid,
	    lpt_len, rpt->rport_tptid_sz);
	key->pgr_key = svc_key;
	key->pgr_key_flags |= keyflag;

	if (key->pgr_key_flags & SBD_PGR_KEY_ALL_TG_PT) {
		/* set PGR_CHECK flag for all unregistered IT nexus */
		sbd_pgr_set_pgr_check_flag(slu, B_FALSE);
	} else {
		key->pgr_key_it = it;
	}

	if (it) {
		mutex_enter(&slu->sl_lock);
		it->pgr_key_ptr = key;
		mutex_exit(&slu->sl_lock);
	} else {
		sbd_pgr_set_pgr_check_flag(slu, B_FALSE);
	}

	key->pgr_key_next = pgr->pgr_keylist;
	if (pgr->pgr_keylist) {
		pgr->pgr_keylist->pgr_key_prev = key;
	}
	pgr->pgr_keylist = key;

	return (key);
}

static void
sbd_pgr_do_unregister(sbd_lu_t *slu, sbd_it_data_t *it, sbd_pgr_key_t *key)
{
	if (slu->sl_pgr->pgr_rsvholder == key) {
		sbd_pgr_do_release(slu, it, SBD_UA_RESERVATIONS_RELEASED);
	}

	sbd_pgr_remove_key(slu, key);
	if (slu->sl_pgr->pgr_keylist == NULL) {
		PGR_CLEAR_RSV_FLAG(slu->sl_pgr->pgr_flags);
	}
}

static void
sbd_pgr_out_reserve(scsi_task_t *task)
{
	sbd_lu_t	*slu   = (sbd_lu_t *)task->task_lu->lu_provider_private;
	stmf_scsi_session_t	*ses	= task->task_session;
	scsi_cdb_prout_t	*pr_out	= (scsi_cdb_prout_t *)task->task_cdb;
	sbd_it_data_t		*it	= task->task_lu_itl_handle;
	sbd_pgr_t		*pgr	= slu->sl_pgr;
	sbd_pgr_key_t		*key	= it->pgr_key_ptr;

	ASSERT(key);

	if (!(PGR_VALID_SCOPE(pr_out->scope) && PGR_VALID_TYPE(pr_out->type))) {
		stmf_scsilib_send_status(task, STATUS_CHECK,
		    STMF_SAA_INVALID_FIELD_IN_CDB);
		return;
	}

	if (SBD_PGR_RSVD(pgr)) {
		if (PGR_RESERVATION_HOLDER(pgr, key, it)) {
			if (pgr->pgr_rsv_type != pr_out->type ||
			    pgr->pgr_rsv_scope != pr_out->scope) {
				stmf_scsilib_send_status(task,
				    STATUS_RESERVATION_CONFLICT, 0);
				return;
			}
		} else {
			stmf_scsilib_send_status(task,
			    STATUS_RESERVATION_CONFLICT, 0);
			return;

		}
	/* In case there is no reservation exist */
	} else {
		sbd_pgr_do_reserve(pgr, key, it, ses, pr_out);
		if (sbd_pgr_should_save(slu) == B_TRUE) {
			if (sbd_pgr_meta_write(slu) != SBD_SUCCESS) {
				stmf_scsilib_send_status(task, STATUS_CHECK,
				    STMF_SAA_INSUFFICIENT_REG_RESRCS);
				return;
			}
		}
	}

	stmf_scsilib_send_status(task, STATUS_GOOD, 0);
}

static void
sbd_pgr_do_reserve(sbd_pgr_t *pgr, sbd_pgr_key_t *key, sbd_it_data_t *it,
    stmf_scsi_session_t *ses, scsi_cdb_prout_t *pr_out)
{
	scsi_devid_desc_t	*lpt;
	uint16_t		lpt_len;

	pgr->pgr_rsv_type = pr_out->type;
	pgr->pgr_rsv_scope = pr_out->scope;
	if (pr_out->type == PGR_TYPE_WR_EX_AR ||
	    pr_out->type == PGR_TYPE_EX_AC_AR) {
		PGR_SET_FLAG(pgr->pgr_flags, SBD_PGR_RSVD_ALL_REGISTRANTS);
	} else {
		if (key->pgr_key_flags & SBD_PGR_KEY_ALL_TG_PT) {
			lpt = key->pgr_key_lpt_id;
			lpt_len = key->pgr_key_lpt_len;
			if (lpt_len > 0 && lpt != NULL) {
				kmem_free(lpt, lpt_len);
			}
			lpt = ses->ss_lport->lport_id;
			lpt_len = sizeof (scsi_devid_desc_t) +
			    lpt->ident_length;
			key->pgr_key_lpt_len = lpt_len;
			key->pgr_key_lpt_id = (scsi_devid_desc_t *)
			    kmem_zalloc(lpt_len, KM_SLEEP);
			bcopy(lpt, key->pgr_key_lpt_id, lpt_len);
			key->pgr_key_it = it;
		}

		PGR_SET_FLAG(pgr->pgr_flags, SBD_PGR_RSVD_ONE);
		pgr->pgr_rsvholder = key;
	}
}

static void
sbd_pgr_out_release(scsi_task_t *task)
{
	sbd_lu_t	*slu   = (sbd_lu_t *)task->task_lu->lu_provider_private;
	scsi_cdb_prout_t	*pr_out	= (scsi_cdb_prout_t *)task->task_cdb;
	sbd_it_data_t		*it	= task->task_lu_itl_handle;
	sbd_pgr_t		*pgr	= slu->sl_pgr;
	sbd_pgr_key_t		*key	= it->pgr_key_ptr;

	ASSERT(key);

	/*
	 * XXX this does not honor APTPL
	 * (i.e., changes made to a formerly-persistent reservation are not
	 *  updated here!!!)
	 */
	if (SBD_PGR_RSVD(pgr)) {
		if (pgr->pgr_flags & SBD_PGR_RSVD_ALL_REGISTRANTS ||
		    pgr->pgr_rsvholder == key) {
			if (pgr->pgr_rsv_type != pr_out->type ||
			    pgr->pgr_rsv_scope != pr_out->scope) {
				stmf_scsilib_send_status(task, STATUS_CHECK,
				    STMF_SAA_INVALID_RELEASE_OF_PR);
				return;
			}
			sbd_pgr_do_release(slu, it,
			    SBD_UA_RESERVATIONS_RELEASED);

			/*
			 * XXX T10 SPC-3 5.6.10.2 says nothing about what to
			 * do in the event of a failure updating the
			 * PGR nvram store for a reservation associated with
			 * an APTPL-enabled (see SPC-3 5.6.4.1) I_T
			 * registration during a RELEASE service action.
			 *
			 * Technically, the CDB completed successfully, as per
			 * the spec, but at some point we may need to enter
			 * a recovery mode on the initiator(s) if we power cycle
			 * the target at the wrong instant...
			 */
			if (sbd_pgr_should_save(slu) == B_TRUE) {
				if (sbd_pgr_meta_write(slu) != SBD_SUCCESS) {
					stmf_scsilib_send_status(task,
					    STATUS_CHECK,
					    STMF_SAA_INSUFFICIENT_REG_RESRCS);
					return;
				}
			}
		}
	}
	stmf_scsilib_send_status(task, STATUS_GOOD, 0);
}

static void
sbd_pgr_do_release(sbd_lu_t *slu, sbd_it_data_t *it, uint8_t ua_condition)
{

	sbd_pgr_t *pgr    =  slu->sl_pgr;

	/* Reset pgr_flags */
	PGR_CLEAR_RSV_FLAG(pgr->pgr_flags);
	pgr->pgr_rsvholder = NULL;

	/* set unit attention condition if necessary */
	if (pgr->pgr_rsv_type != PGR_TYPE_WR_EX &&
	    pgr->pgr_rsv_type != PGR_TYPE_EX_AC) {
		sbd_pgr_set_ua_conditions(slu, it, ua_condition);
	}
	pgr->pgr_rsv_type = 0;
}

static void
sbd_pgr_out_clear(scsi_task_t *task)
{
	sbd_lu_t	*slu   = (sbd_lu_t *)task->task_lu->lu_provider_private;
	sbd_it_data_t		*it	= task->task_lu_itl_handle;
	sbd_pgr_t		*pgr	= slu->sl_pgr;

	ASSERT(it->pgr_key_ptr);

	PGR_CLEAR_RSV_FLAG(pgr->pgr_flags);
	pgr->pgr_rsvholder = NULL;
	pgr->pgr_rsv_type = 0;
	mutex_enter(&slu->sl_lock);
	/* Remove all pointers from IT to pgr keys */
	for (it = slu->sl_it_list; it != NULL; it = it->sbd_it_next) {
		it->pgr_key_ptr = NULL;
	}
	mutex_exit(&slu->sl_lock);
	sbd_pgr_keylist_dealloc(slu);
	sbd_pgr_set_ua_conditions(slu, it, SBD_UA_RESERVATIONS_PREEMPTED);
	if (sbd_pgr_should_save(slu) == B_TRUE) {
		if (sbd_pgr_meta_write(slu) != SBD_SUCCESS) {
			stmf_scsilib_send_status(task, STATUS_CHECK,
			    STMF_SAA_INSUFFICIENT_REG_RESRCS);
			return;
		}
	}
	pgr->pgr_PRgeneration++;
	stmf_scsilib_send_status(task, STATUS_GOOD, 0);
}

static void
sbd_pgr_out_preempt(scsi_task_t *task, stmf_data_buf_t *dbuf)
{
	sbd_lu_t	*slu   = (sbd_lu_t *)task->task_lu->lu_provider_private;
	stmf_scsi_session_t	*ses	= task->task_session;
	scsi_cdb_prout_t	*pr_out	= (scsi_cdb_prout_t *)task->task_cdb;
	sbd_it_data_t		*it	= task->task_lu_itl_handle;
	sbd_pgr_t		*pgr	= slu->sl_pgr;
	sbd_pgr_key_t		*key	= it->pgr_key_ptr;
	scsi_prout_plist_t	*plist;
	uint8_t			*buf, change_rsv = 0;
	uint64_t		svc_key;

	ASSERT(key);

	buf = dbuf->db_sglist[0].seg_addr;
	plist = (scsi_prout_plist_t *)buf;
	svc_key = READ_SCSI64(plist->service_key, uint64_t);

	if (SBD_PGR_RSVD_NONE(pgr)) {
		if (svc_key == 0 ||
		    sbd_pgr_remove_keys(slu, it, key, svc_key, B_TRUE) == 0) {
			stmf_scsilib_send_status(task,
			    STATUS_RESERVATION_CONFLICT, 0);
			return;
		}

	} else if (pgr->pgr_flags & SBD_PGR_RSVD_ONE) {
		if (svc_key == 0) {
			stmf_scsilib_send_status(task, STATUS_CHECK,
			    STMF_SAA_INVALID_FIELD_IN_CDB);
			return;
		}

		/* Validity check of scope and type */
		if (pgr->pgr_rsvholder->pgr_key == svc_key) {
			if (!(PGR_VALID_SCOPE(pr_out->scope) &&
			    PGR_VALID_TYPE(pr_out->type))) {
				stmf_scsilib_send_status(task, STATUS_CHECK,
				    STMF_SAA_INVALID_FIELD_IN_CDB);
				return;
			}
		}

		if (pgr->pgr_rsvholder != key &&
		    pgr->pgr_rsvholder->pgr_key == svc_key) {
			sbd_pgr_do_release(slu, it,
			    SBD_UA_REGISTRATIONS_PREEMPTED);
			change_rsv = 1;
		}

		if (pgr->pgr_rsvholder == key &&
		    pgr->pgr_rsvholder->pgr_key == svc_key) {
			if (pr_out->scope != pgr->pgr_rsv_scope ||
			    pr_out->type != pgr->pgr_rsv_type) {
				sbd_pgr_do_release(slu, it,
				    SBD_UA_REGISTRATIONS_PREEMPTED);
				change_rsv = 1;
			}
		} else {
			/*
			 * Remove matched keys in all cases, except when the
			 * current IT nexus holds the reservation and the given
			 * svc_key matches with registered key.
			 * Note that, if the reservation is held by another
			 * IT nexus, and svc_key matches registered key for
			 * that IT nexus, sbd_pgr_remove_key() is not expected
			 * return 0. Hence, returning check condition after
			 * releasing the reservation does not arise.
			 */
			if (sbd_pgr_remove_keys(slu, it, key, svc_key, B_TRUE)
			    == 0) {
				stmf_scsilib_send_status(task,
				    STATUS_RESERVATION_CONFLICT, 0);
				return;
			}
		}

		if (change_rsv) {
			sbd_pgr_do_reserve(pgr, key, it, ses, pr_out);
		}

	} else if (pgr->pgr_flags & SBD_PGR_RSVD_ALL_REGISTRANTS) {
		if (svc_key == 0) {
			if (!(PGR_VALID_SCOPE(pr_out->scope) &&
			    PGR_VALID_TYPE(pr_out->type))) {
				stmf_scsilib_send_status(task, STATUS_CHECK,
				    STMF_SAA_INVALID_FIELD_IN_CDB);
				return;
			}
			sbd_pgr_do_release(slu, it,
			    SBD_UA_REGISTRATIONS_PREEMPTED);
			(void) sbd_pgr_remove_keys(slu, it, key, 0, B_FALSE);
			sbd_pgr_do_reserve(pgr, key, it, ses, pr_out);
		} else {
			if (sbd_pgr_remove_keys(slu, it, key, svc_key, B_TRUE)
			    == 0) {
				stmf_scsilib_send_status(task,
				    STATUS_RESERVATION_CONFLICT, 0);
				return;
			}
		}
	}

	if (sbd_pgr_should_save(slu) == B_TRUE) {
		if (sbd_pgr_meta_write(slu) != SBD_SUCCESS) {
			stmf_scsilib_send_status(task, STATUS_CHECK,
			    STMF_SAA_INSUFFICIENT_REG_RESRCS);
			return;
		}
	}

	pgr->pgr_PRgeneration++;

	if (pr_out->action == PR_OUT_PREEMPT_ABORT) {
		stmf_abort(STMF_QUEUE_ABORT_LU, task, STMF_ABORTED,
		    (void *)slu->sl_lu);
	}
	stmf_scsilib_send_status(task, STATUS_GOOD, 0);
}

static void
sbd_pgr_out_register_and_move(scsi_task_t *task, stmf_data_buf_t *dbuf)
{
	sbd_lu_t	*slu   = (sbd_lu_t *)task->task_lu->lu_provider_private;
	sbd_it_data_t		*it	= task->task_lu_itl_handle;
	sbd_pgr_t		*pgr	= slu->sl_pgr;
	sbd_pgr_key_t		*key	= it->pgr_key_ptr;
	scsi_devid_desc_t	*lpt;
	stmf_remote_port_t	rport;
	sbd_pgr_key_t		*newkey;
	scsi_prout_reg_move_plist_t *plist;
	uint8_t			*buf, lpt_len;
	uint16_t		tpd_len;
	uint32_t		adn_len;
	uint64_t		svc_key;

	/*
	 * Check whether the key holds the reservation or current reservation
	 * is of type all registrants.
	 */
	if (pgr->pgr_rsvholder != key) {
		stmf_scsilib_send_status(task, STATUS_RESERVATION_CONFLICT, 0);
		return;
	}

	buf = dbuf->db_sglist[0].seg_addr;
	plist = (scsi_prout_reg_move_plist_t *)buf;
	svc_key = READ_SCSI64(plist->service_key, uint64_t);
	if (svc_key == 0) {
		stmf_scsilib_send_status(task, STATUS_CHECK,
		    STMF_SAA_INVALID_FIELD_IN_CDB);
		return;
	}

	lpt = stmf_scsilib_get_devid_desc(READ_SCSI16(plist->rel_tgt_port_id,
	    uint16_t));
	if (lpt == NULL) {
		stmf_scsilib_send_status(task, STATUS_CHECK,
		    STMF_SAA_INVALID_FIELD_IN_CDB);
		return;
	}

	adn_len = READ_SCSI32(plist->tptid_len, uint32_t);
	if (!stmf_scsilib_tptid_validate(
	    (scsi_transport_id_t *)plist->tptid, adn_len, &tpd_len)) {
		kmem_free(lpt, sizeof (scsi_devid_desc_t) + lpt->ident_length);
		stmf_scsilib_send_status(task, STATUS_CHECK,
		    STMF_SAA_INVALID_FIELD_IN_PARAM_LIST);
		return;
	}

	rport.rport_tptid = (scsi_transport_id_t *)plist->tptid;
	rport.rport_tptid_sz = tpd_len;

	if (sbd_pgr_key_compare(key, lpt, &rport)) {
		kmem_free(lpt, sizeof (scsi_devid_desc_t) + lpt->ident_length);
		stmf_scsilib_send_status(task, STATUS_CHECK,
		    STMF_SAA_INVALID_FIELD_IN_PARAM_LIST);
		return;
	}

	newkey = sbd_pgr_key_registered(pgr, lpt, &rport);
	if (newkey) {
		/* Set the pgr_key, irrespective of what it currently holds */
		newkey->pgr_key = svc_key;

		/* all_tg_pt is set for found key, copy lpt info to the key */
		if (newkey->pgr_key_flags & SBD_PGR_KEY_ALL_TG_PT) {
			if (newkey->pgr_key_lpt_id &&
			    newkey->pgr_key_lpt_len > 0) {
				kmem_free(newkey->pgr_key_lpt_id,
				    newkey->pgr_key_lpt_len);
			}
			lpt_len = sizeof (scsi_devid_desc_t) +
			    lpt->ident_length;
			newkey->pgr_key_lpt_len = lpt_len;
			newkey->pgr_key_lpt_id = (scsi_devid_desc_t *)
			    kmem_zalloc(lpt_len, KM_SLEEP);
			bcopy(lpt, newkey->pgr_key_lpt_id, lpt_len);
		}
		/* No IT nexus information, hence set PGR_CHEK flag */
		sbd_pgr_set_pgr_check_flag(slu, B_TRUE);
	} else  {
		newkey = sbd_pgr_do_register(slu, NULL, lpt, &rport,
		    SBD_PGR_KEY_TPT_ID_FLAG, svc_key);
	}

	kmem_free(lpt, sizeof (scsi_devid_desc_t) + lpt->ident_length);

	/* Now reserve the key corresponding to the specified IT nexus */
	pgr->pgr_rsvholder = newkey;

	if (plist->unreg) {
		sbd_pgr_do_unregister(slu, it, key);
	}


	/* Write to disk if aptpl is currently set or this task is setting it */
	if (plist->aptpl || (sbd_pgr_should_save(slu) == B_TRUE)) {
		if (plist->aptpl)
			PGR_SET_FLAG(pgr->pgr_flags, SBD_PGR_APTPL);
		else
			PGR_CLEAR_FLAG(pgr->pgr_flags, SBD_PGR_APTPL);

		if (sbd_pgr_meta_write(slu) != SBD_SUCCESS) {
			stmf_scsilib_send_status(task, STATUS_CHECK,
			    STMF_SAA_INSUFFICIENT_REG_RESRCS);
			return;
		}
	}

	pgr->pgr_PRgeneration++;
	stmf_scsilib_send_status(task, STATUS_GOOD, 0);
}

void
sbd_pgr_remove_it_handle(sbd_lu_t *sl, sbd_it_data_t *my_it)
{
	sbd_it_data_t *it;

	rw_enter(&sl->sl_pgr->pgr_lock, RW_WRITER);
	mutex_enter(&sl->sl_lock);
	for (it = sl->sl_it_list; it != NULL; it = it->sbd_it_next) {
		if (it == my_it) {
			if (it->pgr_key_ptr) {
				sbd_pgr_key_t *key = it->pgr_key_ptr;
				if (key->pgr_key_it == it) {
					key->pgr_key_it = NULL;
					sl->sl_pgr->pgr_flags &=
					    ~SBD_PGR_ALL_KEYS_HAS_IT;
				}
			}
			break;
		}
	}
	mutex_exit(&sl->sl_lock);
	rw_exit(&sl->sl_pgr->pgr_lock);

}

char *
sbd_get_devid_string(sbd_lu_t *sl)
{
	char *str = (char *)kmem_zalloc(33, KM_SLEEP);
	(void) snprintf(str, 33,
	    "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
	    sl->sl_device_id[4], sl->sl_device_id[5], sl->sl_device_id[6],
	    sl->sl_device_id[7], sl->sl_device_id[8], sl->sl_device_id[9],
	    sl->sl_device_id[10], sl->sl_device_id[11], sl->sl_device_id[12],
	    sl->sl_device_id[13], sl->sl_device_id[14], sl->sl_device_id[15],
	    sl->sl_device_id[16], sl->sl_device_id[17], sl->sl_device_id[18],
	    sl->sl_device_id[19]);
	return (str);
}