/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2012 Milan Jurik. All rights reserved.
 * Copyright (c) 2016 by Delphix. All rights reserved.
 * Copyright 2017 Joyent, Inc.
 */


/*
 * Overview of the RSM Kernel Agent:
 * ---------------------------------
 *
 * rsm.c constitutes the implementation of the RSM kernel agent. The RSM
 * kernel agent is a pseudo device driver which makes use of the RSMPI
 * interface on behalf of the RSMAPI user library.
 *
 * The kernel agent functionality can be categorized into the following
 * components:
 * 1. Driver Infrastructure
 * 2. Export/Import Segment Management
 * 3. Internal resource allocation/deallocation
 *
 * The driver infrastructure includes the basic module loading entry points
 * like _init, _info, _fini to load, unload and report information about
 * the driver module. The driver infrastructure also includes the
 * autoconfiguration entry points namely, attach, detach and getinfo for
 * the device autoconfiguration.
 *
 * The kernel agent is a pseudo character device driver and exports
 * a cb_ops structure which defines the driver entry points for character
 * device access. This includes the open and close entry points. The
 * other entry points provided include ioctl, devmap and segmap and chpoll.
 * read and write entry points are not used since the device is memory
 * mapped. Also ddi_prop_op is used for the prop_op entry point.
 *
 * The ioctl entry point supports a number of commands, which are used by
 * the RSMAPI library in order to export and import segments. These
 * commands include commands for binding and rebinding the physical pages
 * allocated to the virtual address range, publishing the export segment,
 * unpublishing and republishing an export segment, creating an
 * import segment and a virtual connection from this import segment to
 * an export segment, performing scatter-gather data transfer, barrier
 * operations.
 *
 *
 * Export and Import segments:
 * ---------------------------
 *
 * In order to create an RSM export segment a process allocates a range in its
 * virtual address space for the segment using standard Solaris interfaces.
 * The process then calls RSMAPI, which in turn makes an ioctl call to the
 * RSM kernel agent for an allocation of physical memory pages and for
 * creation of the export segment by binding these pages to the virtual
 * address range. These pages are locked in memory so that remote accesses
 * are always applied to the correct page. Then the RSM segment is published,
 * again via RSMAPI making an ioctl to the RSM kernel agent, and a segment id
 * is assigned to it.
 *
 * In order to import a published RSM segment, RSMAPI creates an import
 * segment and forms a virtual connection across the interconnect to the
 * export segment, via an ioctl into the kernel agent with the connect
 * command. The import segment setup is completed by mapping the
 * local device memory into the importers virtual address space. The
 * mapping of the import segment is handled by the segmap/devmap
 * infrastructure described as follows.
 *
 * Segmap and Devmap interfaces:
 *
 * The RSM kernel agent allows device memory to be directly accessed by user
 * threads via memory mapping. In order to do so, the RSM kernel agent
 * supports the devmap and segmap entry points.
 *
 * The segmap entry point(rsm_segmap) is responsible for setting up a memory
 * mapping as requested by mmap. The devmap entry point(rsm_devmap) is
 * responsible for exporting the device memory to the user applications.
 * rsm_segmap calls RSMPI rsm_map to allocate device memory. Then the
 * control is transfered to the devmap_setup call which calls rsm_devmap.
 *
 * rsm_devmap validates the user mapping to the device or kernel memory
 * and passes the information to the system for setting up the mapping. The
 * actual setting up of the mapping is done by devmap_devmem_setup(for
 * device memory) or devmap_umem_setup(for kernel memory). Callbacks are
 * registered for device context management via the devmap_devmem_setup
 * or devmap_umem_setup calls. The callbacks are rsmmap_map, rsmmap_unmap,
 * rsmmap_access, rsmmap_dup. The callbacks are called when a new mapping
 * is created, a mapping is freed, a mapping is accessed or an existing
 * mapping is duplicated respectively. These callbacks allow the RSM kernel
 * agent to maintain state information associated with the mappings.
 * The state information is mainly in the form of a cookie list for the import
 * segment for which mapping has been done.
 *
 * Forced disconnect of import segments:
 *
 * When an exported segment is unpublished, the exporter sends a forced
 * disconnect message to all its importers. The importer segments are
 * unloaded and disconnected. This involves unloading the original
 * mappings and remapping to a preallocated kernel trash page. This is
 * done by devmap_umem_remap. The trash/dummy page is a kernel page,
 * preallocated by the kernel agent during attach using ddi_umem_alloc with
 * the DDI_UMEM_TRASH flag set. This avoids a core dump in the application
 * due to unloading of the original mappings.
 *
 * Additionally every segment has a mapping generation number associated
 * with it. This is an entry in the barrier generation page, created
 * during attach time. This mapping generation number for the import
 * segments is incremented on a force disconnect to notify the application
 * of the force disconnect. On this notification, the application needs
 * to reconnect the segment to establish a new legitimate mapping.
 *
 *
 * Locks used in the kernel agent:
 * -------------------------------
 *
 * The kernel agent uses a variety of mutexes and condition variables for
 * mutual exclusion of the shared data structures and for synchronization
 * between the various threads. Some of the locks are described as follows.
 *
 * Each resource structure, which represents either an export/import segment
 * has a lock associated with it. The lock is the resource mutex, rsmrc_lock.
 * This is used directly by RSMRC_LOCK and RSMRC_UNLOCK macros and in the
 * rsmseglock_acquire and rsmseglock_release macros. An additional
 * lock called the rsmsi_lock is used for the shared import data structure
 * that is relevant for resources representing import segments. There is
 * also a condition variable associated with the resource called s_cv. This
 * is used to wait for events like the segment state change etc.
 *
 * The resource structures are allocated from a pool of resource structures,
 * called rsm_resource. This pool is protected via a reader-writer lock,
 * called rsmrc_lock.
 *
 * There are two separate hash tables, one for the export segments and
 * one for the import segments. The export segments are inserted into the
 * export segment hash table only after they have been published and the
 * import segments are inserted in the import segments list only after they
 * have successfully connected to an exported segment. These tables are
 * protected via reader-writer locks.
 *
 * Debug Support in the kernel agent:
 * ----------------------------------
 *
 * Debugging support in the kernel agent is provided by the following
 * macros.
 *
 * DBG_PRINTF((category, level, message)) is a macro which logs a debug
 * message to the kernel agents debug buffer, rsmka_dbg. This debug buffer
 * can be viewed in kmdb as *rsmka_dbg/s. The message is logged based
 * on the definition of the category and level. All messages that belong to
 * the specified category(rsmdbg_category) and are of an equal or greater
 * severity than the specified level(rsmdbg_level) are logged. The message
 * is a string which uses the same formatting rules as the strings used in
 * printf.
 *
 * The category defines which component of the kernel agent has logged this
 * message. There are a number of categories that have been defined such as
 * RSM_KERNEL_AGENT, RSM_OPS, RSM_IMPORT, RSM_EXPORT etc. A macro,
 * DBG_ADDCATEGORY is used to add in another category to the currently
 * specified category value so that the component using this new category
 * can also effectively log debug messages. Thus, the category of a specific
 * message is some combination of the available categories and we can define
 * sub-categories if we want a finer level of granularity.
 *
 * The level defines the severity of the message. Different level values are
 * defined, with RSM_ERR being the most severe and RSM_DEBUG_VERBOSE being
 * the least severe(debug level is 0).
 *
 * DBG_DEFINE and DBG_DEFINE_STR are macros provided to declare a debug
 * variable or a string respectively.
 *
 *
 * NOTES:
 *
 * Special Fork and Exec Handling:
 * -------------------------------
 *
 * The backing physical pages of an exported segment are always locked down.
 * Thus, there are two cases in which a process having exported segments
 * will cause a cpu to hang: (1) the process invokes exec; (2) a process
 * forks and invokes exit before the duped file descriptors for the export
 * segments are closed in the child process. The hang is caused because the
 * address space release algorithm in Solaris VM subsystem is based on a
 * non-blocking loop which does not terminate while segments are locked
 * down. In addition to this, Solaris VM subsystem lacks a callback
 * mechanism to the rsm kernel agent to allow unlocking these export
 * segment pages.
 *
 * In order to circumvent this problem, the kernel agent does the following.
 * The Solaris VM subsystem keeps memory segments in increasing order of
 * virtual addressses. Thus a special page(special_exit_offset) is allocated
 * by the kernel agent and is mmapped into the heap area of the process address
 * space(the mmap is done by the RSMAPI library). During the mmap processing
 * of this special page by the devmap infrastructure, a callback(the same
 * devmap context management callbacks discussed above) is registered for an
 * unmap.
 *
 * As discussed above, this page is processed by the Solaris address space
 * release code before any of the exported segments pages(which are allocated
 * from high memory). It is during this processing that the unmap callback gets
 * called and this callback is responsible for force destroying the exported
 * segments and thus eliminating the problem of locked pages.
 *
 * Flow-control:
 * ------------
 *
 * A credit based flow control algorithm is used for messages whose
 * processing cannot be done in the interrupt context because it might
 * involve invoking rsmpi calls, or might take a long time to complete
 * or might need to allocate resources. The algorithm operates on a per
 * path basis. To send a message the pathend needs to have a credit and
 * it consumes one for every message that is flow controlled. On the
 * receiving pathend the message is put on a msgbuf_queue and a task is
 * dispatched on the worker thread - recv_taskq where it is processed.
 * After processing the message, the receiving pathend dequeues the message,
 * and if it has processed > RSMIPC_LOTSFREE_MSGBUFS messages sends
 * credits to the sender pathend.
 *
 * RSM_DRTEST:
 * -----------
 *
 * This is used to enable the DR testing using a test driver on test
 * platforms which do not supported DR.
 *
 */

#include <sys/types.h>
#include <sys/param.h>
#include <sys/user.h>
#include <sys/buf.h>
#include <sys/systm.h>
#include <sys/cred.h>
#include <sys/vm.h>
#include <sys/uio.h>
#include <vm/seg.h>
#include <vm/page.h>
#include <sys/stat.h>

#include <sys/time.h>
#include <sys/errno.h>

#include <sys/file.h>
#include <sys/uio.h>
#include <sys/proc.h>
#include <sys/mman.h>
#include <sys/open.h>
#include <sys/atomic.h>
#include <sys/mem_config.h>


#include <sys/ddi.h>
#include <sys/devops.h>
#include <sys/ddidevmap.h>
#include <sys/sunddi.h>
#include <sys/esunddi.h>
#include <sys/ddi_impldefs.h>

#include <sys/kmem.h>
#include <sys/conf.h>
#include <sys/devops.h>
#include <sys/ddi_impldefs.h>

#include <sys/modctl.h>

#include <sys/policy.h>
#include <sys/types.h>
#include <sys/conf.h>
#include <sys/param.h>

#include <sys/taskq.h>

#include <sys/rsm/rsm_common.h>
#include <sys/rsm/rsmapi_common.h>
#include <sys/rsm/rsm.h>
#include <rsm_in.h>
#include <sys/rsm/rsmka_path_int.h>
#include <sys/rsm/rsmpi.h>

#include <sys/modctl.h>
#include <sys/debug.h>

#include <sys/tuneable.h>

#ifdef  RSM_DRTEST
extern int rsm_kphysm_setup_func_register(kphysm_setup_vector_t *vec,
                void *arg);
extern void rsm_kphysm_setup_func_unregister(kphysm_setup_vector_t *vec,
                void *arg);
#endif

extern void dbg_printf(int category, int level, char *fmt, ...);
extern void rsmka_pathmanager_init();
extern void rsmka_pathmanager_cleanup();
extern void rele_sendq_token(sendq_token_t *);
extern rsm_addr_t get_remote_hwaddr(adapter_t *, rsm_node_id_t);
extern rsm_node_id_t get_remote_nodeid(adapter_t *, rsm_addr_t);
extern int rsmka_topology_ioctl(caddr_t, int, int);

extern pri_t maxclsyspri;
extern work_queue_t work_queue;
extern kmutex_t ipc_info_lock;
extern kmutex_t ipc_info_cvlock;
extern kcondvar_t ipc_info_cv;
extern kmutex_t path_hold_cvlock;
extern kcondvar_t path_hold_cv;

extern kmutex_t rsmka_buf_lock;

extern path_t *rsm_find_path(char *, int, rsm_addr_t);
extern adapter_t *rsmka_lookup_adapter(char *, int);
extern sendq_token_t *rsmka_get_sendq_token(rsm_node_id_t, sendq_token_t *);
extern boolean_t rsmka_do_path_active(path_t *, int);
extern boolean_t rsmka_check_node_alive(rsm_node_id_t);
extern void rsmka_release_adapter(adapter_t *);
extern void rsmka_enqueue_msgbuf(path_t *path, void *data);
extern void rsmka_dequeue_msgbuf(path_t *path);
extern msgbuf_elem_t *rsmka_gethead_msgbuf(path_t *path);
/* lint -w2 */

static int rsm_open(dev_t *, int, int, cred_t *);
static int rsm_close(dev_t, int, int, cred_t *);
static int rsm_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
    cred_t *credp, int *rvalp);
static int rsm_devmap(dev_t, devmap_cookie_t, offset_t, size_t, size_t *,
    uint_t);
static int rsm_segmap(dev_t, off_t, struct as *, caddr_t *, off_t, uint_t,
    uint_t, uint_t, cred_t *);
static int rsm_chpoll(dev_t dev, short events, int anyyet, short *reventsp,
    struct pollhead **phpp);

static int rsm_info(dev_info_t *, ddi_info_cmd_t, void *, void **);
static int rsm_attach(dev_info_t *, ddi_attach_cmd_t);
static int rsm_detach(dev_info_t *, ddi_detach_cmd_t);

static int rsmipc_send(rsm_node_id_t, rsmipc_request_t *, rsmipc_reply_t *);
static void rsm_force_unload(rsm_node_id_t, rsm_memseg_id_t, boolean_t);
static void rsm_send_importer_disconnects(rsm_memseg_id_t, rsm_node_id_t);
static void rsm_send_republish(rsm_memseg_id_t, rsmapi_access_entry_t *, int,
                                rsm_permission_t);
static void rsm_export_force_destroy(ddi_umem_cookie_t *);
static void rsmacl_free(rsmapi_access_entry_t *, int);
static void rsmpiacl_free(rsm_access_entry_t *, int);

static int rsm_inc_pgcnt(pgcnt_t);
static void rsm_dec_pgcnt(pgcnt_t);
static void rsm_free_mapinfo(rsm_mapinfo_t *mapinfop);
static rsm_mapinfo_t *rsm_get_mapinfo(rsmseg_t *, off_t, size_t, off_t *,
                                        size_t *);
static void exporter_quiesce();
static void rsmseg_suspend(rsmseg_t *, int *);
static void rsmsegshare_suspend(rsmseg_t *);
static int rsmseg_resume(rsmseg_t *, void **);
static int rsmsegshare_resume(rsmseg_t *);

static struct cb_ops rsm_cb_ops = {
        rsm_open,               /* open */
        rsm_close,              /* close */
        nodev,                  /* strategy */
        nodev,                  /* print */
        nodev,                  /* dump */
        nodev,                  /* read */
        nodev,                  /* write */
        rsm_ioctl,              /* ioctl */
        rsm_devmap,             /* devmap */
        NULL,                   /* mmap */
        rsm_segmap,             /* segmap */
        rsm_chpoll,             /* poll */
        ddi_prop_op,            /* cb_prop_op */
        0,                      /* streamtab  */
        D_NEW|D_MP|D_DEVMAP,    /* Driver compatibility flag */
        0,
        0,
        0
};

static struct dev_ops rsm_ops = {
        DEVO_REV,               /* devo_rev, */
        0,                      /* refcnt  */
        rsm_info,               /* get_dev_info */
        nulldev,                /* identify */
        nulldev,                /* probe */
        rsm_attach,             /* attach */
        rsm_detach,             /* detach */
        nodev,                  /* reset */
        &rsm_cb_ops,            /* driver operations */
        (struct bus_ops *)0,    /* bus operations */
        0,
        ddi_quiesce_not_needed,         /* quiesce */
};

/*
 * Module linkage information for the kernel.
 */

static struct modldrv modldrv = {
        &mod_driverops, /* Type of module.  This one is a pseudo driver */
        "Remote Shared Memory Driver",
        &rsm_ops,       /* driver ops */
};

static struct modlinkage modlinkage = {
        MODREV_1,
        (void *)&modldrv,
        0,
        0,
        0
};

static void rsm_dr_callback_post_add(void *arg, pgcnt_t delta);
static int rsm_dr_callback_pre_del(void *arg, pgcnt_t delta);
static void rsm_dr_callback_post_del(void *arg, pgcnt_t delta, int cancelled);

static kphysm_setup_vector_t rsm_dr_callback_vec = {
        KPHYSM_SETUP_VECTOR_VERSION,
        rsm_dr_callback_post_add,
        rsm_dr_callback_pre_del,
        rsm_dr_callback_post_del
};

/* This flag can be changed to 0 to help with PIT testing */
int rsmka_modunloadok = 1;
int no_reply_cnt = 0;

uint64_t rsm_ctrlmsg_errcnt = 0;
uint64_t rsm_ipcsend_errcnt = 0;

#define MAX_NODES 64

static struct rsm_driver_data rsm_drv_data;
static struct rsmresource_table rsm_resource;

static void rsmresource_insert(minor_t, rsmresource_t *, rsm_resource_type_t);
static void rsmresource_destroy(void);
static int rsmresource_alloc(minor_t *);
static rsmresource_t *rsmresource_free(minor_t rnum);
static int rsm_closeconnection(rsmseg_t *seg, void **cookie);
static int rsm_unpublish(rsmseg_t *seg, int mode);
static int rsm_unbind(rsmseg_t *seg);
static uint_t rsmhash(rsm_memseg_id_t key);
static void rsmhash_alloc(rsmhash_table_t *rhash, int size);
static void rsmhash_free(rsmhash_table_t *rhash, int size);
static void *rsmhash_getbkt(rsmhash_table_t *rhash, uint_t hashval);
static void **rsmhash_bktaddr(rsmhash_table_t *rhash, uint_t hashval);
static int rsm_send_notimporting(rsm_node_id_t dest, rsm_memseg_id_t segid,
                                        void *cookie);
int rsm_disconnect(rsmseg_t *seg);
void rsmseg_unload(rsmseg_t *);
void rsm_suspend_complete(rsm_node_id_t src_node, int flag);

rsm_intr_hand_ret_t rsm_srv_func(rsm_controller_object_t *chd,
    rsm_intr_q_op_t opcode, rsm_addr_t src,
    void *data, size_t size, rsm_intr_hand_arg_t arg);

static void rsm_intr_callback(void *, rsm_addr_t, rsm_intr_hand_arg_t);

rsm_node_id_t my_nodeid;

/* cookie, va, offsets and length for the barrier */
static rsm_gnum_t               *bar_va;
static ddi_umem_cookie_t        bar_cookie;
static off_t                    barrier_offset;
static size_t                   barrier_size;
static int                      max_segs;

/* cookie for the trash memory */
static ddi_umem_cookie_t        remap_cookie;

static rsm_memseg_id_t  rsm_nextavail_segmentid;

extern taskq_t *work_taskq;
extern char *taskq_name;

static dev_info_t *rsm_dip;     /* private copy of devinfo pointer */

static rsmhash_table_t rsm_export_segs;         /* list of exported segs */
rsmhash_table_t rsm_import_segs;                /* list of imported segs */
static rsmhash_table_t rsm_event_queues;        /* list of event queues */

static  rsm_ipc_t       rsm_ipc;                /* ipc info */

/* list of nodes to which RSMIPC_MSG_SUSPEND has been sent */
static list_head_t      rsm_suspend_list;

/* list of descriptors for remote importers */
static importers_table_t importer_list;

kmutex_t rsm_suspend_cvlock;
kcondvar_t rsm_suspend_cv;

static kmutex_t rsm_lock;

adapter_t loopback_adapter;
rsm_controller_attr_t loopback_attr;

int rsmipc_send_controlmsg(path_t *path, int msgtype);

void rsmka_init_loopback();

int rsmka_null_seg_create(
    rsm_controller_handle_t,
    rsm_memseg_export_handle_t *,
    size_t,
    uint_t,
    rsm_memory_local_t *,
    rsm_resource_callback_t,
    rsm_resource_callback_arg_t);

int rsmka_null_seg_destroy(
    rsm_memseg_export_handle_t);

int rsmka_null_bind(
    rsm_memseg_export_handle_t,
    off_t,
    rsm_memory_local_t *,
    rsm_resource_callback_t,
    rsm_resource_callback_arg_t);

int rsmka_null_unbind(
    rsm_memseg_export_handle_t,
    off_t,
    size_t);

int rsmka_null_rebind(
    rsm_memseg_export_handle_t,
    off_t,
    rsm_memory_local_t *,
    rsm_resource_callback_t,
    rsm_resource_callback_arg_t);

int rsmka_null_publish(
    rsm_memseg_export_handle_t,
    rsm_access_entry_t [],
    uint_t,
    rsm_memseg_id_t,
    rsm_resource_callback_t,
    rsm_resource_callback_arg_t);


int rsmka_null_republish(
    rsm_memseg_export_handle_t,
    rsm_access_entry_t [],
    uint_t,
    rsm_resource_callback_t,
    rsm_resource_callback_arg_t);

int rsmka_null_unpublish(
    rsm_memseg_export_handle_t);

rsm_ops_t null_rsmpi_ops;

/*
 * data and locks to keep track of total amount of exported memory
 */
static  pgcnt_t         rsm_pgcnt;
static  pgcnt_t         rsm_pgcnt_max;  /* max allowed */
static  kmutex_t        rsm_pgcnt_lock;

static  int             rsm_enable_dr;

static  char            loopback_str[] = "loopback";

int             rsm_hash_size;

/*
 * The locking model is as follows:
 *
 * Local operations:
 *              find resource - grab reader lock on resouce list
 *              insert rc     - grab writer lock
 *              delete rc     - grab writer lock and resource mutex
 *              read/write    - no lock
 *
 * Remote invocations:
 *              find resource - grab read lock and resource mutex
 *
 * State:
 *              resource state - grab resource mutex
 */

int
_init(void)
{
        int e;

        e = mod_install(&modlinkage);
        if (e != 0) {
                return (e);
        }

        mutex_init(&rsm_lock, NULL, MUTEX_DRIVER, NULL);

        mutex_init(&rsmka_buf_lock, NULL, MUTEX_DEFAULT, NULL);


        rw_init(&rsm_resource.rsmrc_lock, NULL, RW_DRIVER, NULL);

        rsm_hash_size = RSM_HASHSZ;

        rw_init(&rsm_export_segs.rsmhash_rw, NULL, RW_DRIVER, NULL);

        rw_init(&rsm_import_segs.rsmhash_rw, NULL, RW_DRIVER, NULL);

        mutex_init(&importer_list.lock, NULL, MUTEX_DRIVER, NULL);

        mutex_init(&rsm_ipc.lock, NULL, MUTEX_DRIVER, NULL);
        cv_init(&rsm_ipc.cv, NULL, CV_DRIVER, 0);

        mutex_init(&rsm_suspend_cvlock, NULL, MUTEX_DRIVER, NULL);
        cv_init(&rsm_suspend_cv, NULL, CV_DRIVER, 0);

        mutex_init(&rsm_drv_data.drv_lock, NULL, MUTEX_DRIVER, NULL);
        cv_init(&rsm_drv_data.drv_cv, NULL, CV_DRIVER, 0);

        rsm_ipc.count = RSMIPC_SZ;
        rsm_ipc.wanted = 0;
        rsm_ipc.sequence = 0;

        (void) mutex_init(&rsm_pgcnt_lock, NULL, MUTEX_DRIVER, NULL);

        for (e = 0; e < RSMIPC_SZ; e++) {
                rsmipc_slot_t *slot = &rsm_ipc.slots[e];

                RSMIPC_SET(slot, RSMIPC_FREE);
                mutex_init(&slot->rsmipc_lock, NULL, MUTEX_DRIVER, NULL);
                cv_init(&slot->rsmipc_cv, NULL, CV_DRIVER, 0);
        }

        /*
         * Initialize the suspend message list
         */
        rsm_suspend_list.list_head = NULL;
        mutex_init(&rsm_suspend_list.list_lock, NULL, MUTEX_DRIVER, NULL);

        /*
         * It is assumed here that configuration data is available
         * during system boot since _init may be called at that time.
         */

        rsmka_pathmanager_init();

        DBG_PRINTF((RSM_KERNEL_AGENT, RSM_DEBUG_VERBOSE,
            "rsm: _init done\n"));

        return (DDI_SUCCESS);

}

int
_info(struct modinfo *modinfop)
{

        return (mod_info(&modlinkage, modinfop));
}

int
_fini(void)
{
        int e;

        DBG_PRINTF((RSM_KERNEL_AGENT, RSM_DEBUG_VERBOSE,
            "rsm: _fini enter\n"));

        /*
         * The rsmka_modunloadok flag is simply used to help with
         * the PIT testing. Make this flag 0 to disallow modunload.
         */
        if (rsmka_modunloadok == 0)
                return (EBUSY);

        /* rsm_detach will be called as a result of mod_remove */
        e = mod_remove(&modlinkage);
        if (e) {
                DBG_PRINTF((RSM_KERNEL_AGENT, RSM_ERR,
                    "Unable to fini RSM %x\n", e));
                return (e);
        }

        rsmka_pathmanager_cleanup();

        rw_destroy(&rsm_resource.rsmrc_lock);

        rw_destroy(&rsm_export_segs.rsmhash_rw);
        rw_destroy(&rsm_import_segs.rsmhash_rw);
        rw_destroy(&rsm_event_queues.rsmhash_rw);

        mutex_destroy(&importer_list.lock);

        mutex_destroy(&rsm_ipc.lock);
        cv_destroy(&rsm_ipc.cv);

        (void) mutex_destroy(&rsm_suspend_list.list_lock);

        (void) mutex_destroy(&rsm_pgcnt_lock);

        DBG_PRINTF((RSM_KERNEL_AGENT, RSM_DEBUG_VERBOSE, "_fini done\n"));

        return (DDI_SUCCESS);

}

/*ARGSUSED1*/
static int
rsm_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
        minor_t rnum;
        int     percent;
        int     ret;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_attach enter\n"));

        switch (cmd) {
        case DDI_ATTACH:
                break;
        case DDI_RESUME:
        default:
                DBG_PRINTF((category, RSM_ERR,
                    "rsm:rsm_attach - cmd not supported\n"));
                return (DDI_FAILURE);
        }

        if (rsm_dip != NULL) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm:rsm_attach - supports only "
                    "one instance\n"));
                return (DDI_FAILURE);
        }

        rsm_enable_dr = ddi_prop_get_int(DDI_DEV_T_ANY, devi,
            DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
            "enable-dynamic-reconfiguration", 1);

        mutex_enter(&rsm_drv_data.drv_lock);
        rsm_drv_data.drv_state = RSM_DRV_REG_PROCESSING;
        mutex_exit(&rsm_drv_data.drv_lock);

        if (rsm_enable_dr) {
#ifdef  RSM_DRTEST
                ret = rsm_kphysm_setup_func_register(&rsm_dr_callback_vec,
                    (void *)NULL);
#else
                ret = kphysm_setup_func_register(&rsm_dr_callback_vec,
                    (void *)NULL);
#endif
                if (ret != 0) {
                        mutex_exit(&rsm_drv_data.drv_lock);
                        cmn_err(CE_CONT, "rsm:rsm_attach - Dynamic "
                            "reconfiguration setup failed\n");
                        return (DDI_FAILURE);
                }
        }

        mutex_enter(&rsm_drv_data.drv_lock);
        ASSERT(rsm_drv_data.drv_state == RSM_DRV_REG_PROCESSING);
        rsm_drv_data.drv_state = RSM_DRV_OK;
        cv_broadcast(&rsm_drv_data.drv_cv);
        mutex_exit(&rsm_drv_data.drv_lock);

        /*
         * page_list_read_lock();
         * xx_setup();
         * page_list_read_unlock();
         */

        rsm_hash_size = ddi_prop_get_int(DDI_DEV_T_ANY, devi,
            DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
            "segment-hashtable-size", RSM_HASHSZ);
        if (rsm_hash_size == 0) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm: segment-hashtable-size in rsm.conf "
                    "must be greater than 0, defaulting to 128\n"));
                rsm_hash_size = RSM_HASHSZ;
        }

        DBG_PRINTF((category, RSM_DEBUG, "rsm_attach rsm_hash_size: %d\n",
            rsm_hash_size));

        rsm_pgcnt = 0;

        percent = ddi_prop_get_int(DDI_DEV_T_ANY, devi,
            DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
            "max-exported-memory", 0);
        if (percent < 0) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm:rsm_attach not enough memory available to "
                    "export, or max-exported-memory set incorrectly.\n"));
                return (DDI_FAILURE);
        }
        /* 0 indicates no fixed upper limit. maxmem is the max  */
        /* available pageable physical mem                      */
        rsm_pgcnt_max = (percent*maxmem)/100;

        if (rsm_pgcnt_max > 0) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm: Available physical memory = %lu pages, "
                    "Max exportable memory = %lu pages",
                    maxmem, rsm_pgcnt_max));
        }

        /*
         * Create minor number
         */
        if (rsmresource_alloc(&rnum) != RSM_SUCCESS) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm: rsm_attach - Unable to get "
                    "minor number\n"));
                return (DDI_FAILURE);
        }

        ASSERT(rnum == RSM_DRIVER_MINOR);

        if (ddi_create_minor_node(devi, DRIVER_NAME, S_IFCHR,
            rnum, DDI_PSEUDO, 0) == DDI_FAILURE) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm: rsm_attach - unable to allocate "
                    "minor #\n"));
                return (DDI_FAILURE);
        }

        rsm_dip = devi;
        /*
         * Allocate the hashtables
         */
        rsmhash_alloc(&rsm_export_segs, rsm_hash_size);
        rsmhash_alloc(&rsm_import_segs, rsm_hash_size);

        importer_list.bucket = (importing_token_t **)
            kmem_zalloc(rsm_hash_size * sizeof (importing_token_t *), KM_SLEEP);

        /*
         * Allocate a resource struct
         */
        {
                rsmresource_t *p;

                p = (rsmresource_t *)kmem_zalloc(sizeof (*p), KM_SLEEP);

                mutex_init(&p->rsmrc_lock, NULL, MUTEX_DRIVER, (void *) NULL);

                rsmresource_insert(rnum, p, RSM_RESOURCE_BAR);
        }

        /*
         * Based on the rsm.conf property max-segments, determine the maximum
         * number of segments that can be exported/imported. This is then used
         * to determine the size for barrier failure pages.
         */

        /* First get the max number of segments from the rsm.conf file */
        max_segs = ddi_prop_get_int(DDI_DEV_T_ANY, devi,
            DDI_PROP_DONTPASS | DDI_PROP_NOTPROM,
            "max-segments", 0);
        if (max_segs == 0) {
                /* Use default number of segments */
                max_segs = RSM_MAX_NUM_SEG;
        }

        /*
         * Based on the max number of segments allowed, determine the barrier
         * page size. add 1 to max_segs since the barrier page itself uses
         * a slot
         */
        barrier_size = roundup((max_segs + 1) * sizeof (rsm_gnum_t),
            PAGESIZE);

        /*
         * allocation of the barrier failure page
         */
        bar_va = (rsm_gnum_t *)ddi_umem_alloc(barrier_size,
            DDI_UMEM_SLEEP, &bar_cookie);

        /*
         * Set the barrier_offset
         */
        barrier_offset = 0;

        /*
         * Allocate a trash memory and get a cookie for it. This will be used
         * when remapping segments during force disconnects. Allocate the
         * trash memory with a large size which is page aligned.
         */
        (void) ddi_umem_alloc((size_t)TRASHSIZE,
            DDI_UMEM_TRASH, &remap_cookie);

        /* initialize user segment id allocation variable */
        rsm_nextavail_segmentid = (rsm_memseg_id_t)RSM_USER_APP_ID_BASE;

        /*
         * initialize the null_rsmpi_ops vector and the loopback adapter
         */
        rsmka_init_loopback();


        ddi_report_dev(devi);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_attach done\n"));

        return (DDI_SUCCESS);
}

/*
 * The call to mod_remove in the _fine routine will cause the system
 * to call rsm_detach
 */
/*ARGSUSED*/
static int
rsm_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_detach enter\n"));

        switch (cmd) {
        case DDI_DETACH:
                break;
        default:
                DBG_PRINTF((category, RSM_ERR,
                    "rsm:rsm_detach - cmd %x not supported\n",
                    cmd));
                return (DDI_FAILURE);
        }

        mutex_enter(&rsm_drv_data.drv_lock);
        while (rsm_drv_data.drv_state != RSM_DRV_OK)
                cv_wait(&rsm_drv_data.drv_cv, &rsm_drv_data.drv_lock);
        rsm_drv_data.drv_state = RSM_DRV_UNREG_PROCESSING;
        mutex_exit(&rsm_drv_data.drv_lock);

        /*
         * Unregister the DR callback functions
         */
        if (rsm_enable_dr) {
#ifdef  RSM_DRTEST
                rsm_kphysm_setup_func_unregister(&rsm_dr_callback_vec,
                    (void *)NULL);
#else
                kphysm_setup_func_unregister(&rsm_dr_callback_vec,
                    (void *)NULL);
#endif
        }

        mutex_enter(&rsm_drv_data.drv_lock);
        ASSERT(rsm_drv_data.drv_state == RSM_DRV_UNREG_PROCESSING);
        rsm_drv_data.drv_state = RSM_DRV_NEW;
        mutex_exit(&rsm_drv_data.drv_lock);

        ASSERT(rsm_suspend_list.list_head == NULL);

        /*
         * Release all resources, seglist, controller, ...
         */

        /* remove intersend queues */
        /* remove registered services */


        ddi_remove_minor_node(dip, DRIVER_NAME);
        rsm_dip = NULL;

        /*
         * Free minor zero resource
         */
        {
                rsmresource_t *p;

                p = rsmresource_free(RSM_DRIVER_MINOR);
                if (p) {
                        mutex_destroy(&p->rsmrc_lock);
                        kmem_free((void *)p, sizeof (*p));
                }
        }

        /*
         * Free resource table
         */

        rsmresource_destroy();

        /*
         * Free the hash tables
         */
        rsmhash_free(&rsm_export_segs, rsm_hash_size);
        rsmhash_free(&rsm_import_segs, rsm_hash_size);

        kmem_free((void *)importer_list.bucket,
            rsm_hash_size * sizeof (importing_token_t *));
        importer_list.bucket = NULL;


        /* free barrier page */
        if (bar_cookie != NULL) {
                ddi_umem_free(bar_cookie);
        }
        bar_va = NULL;
        bar_cookie = NULL;

        /*
         * Free the memory allocated for the trash
         */
        if (remap_cookie != NULL) {
                ddi_umem_free(remap_cookie);
        }
        remap_cookie = NULL;

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_detach done\n"));

        return (DDI_SUCCESS);
}

/*ARGSUSED*/
static int
rsm_info(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg, void **result)
{
        register int error;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_info enter\n"));

        switch (infocmd) {
        case DDI_INFO_DEVT2DEVINFO:
                if (rsm_dip == NULL)
                        error = DDI_FAILURE;
                else {
                        *result = (void *)rsm_dip;
                        error = DDI_SUCCESS;
                }
                break;
        case DDI_INFO_DEVT2INSTANCE:
                *result = (void *)0;
                error = DDI_SUCCESS;
                break;
        default:
                error = DDI_FAILURE;
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_info done\n"));
        return (error);
}

adapter_t *
rsm_getadapter(rsm_ioctlmsg_t *msg, int mode)
{
        adapter_t *adapter;
        char adapter_devname[MAXNAMELEN];
        int instance;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_IMPORT | RSM_EXPORT | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_getadapter enter\n"));

        instance = msg->cnum;

        if ((msg->cname_len <= 0) || (msg->cname_len > MAXNAMELEN)) {
                return (NULL);
        }

        if (ddi_copyin(msg->cname, adapter_devname, msg->cname_len, mode))
                return (NULL);

        if (strcmp(adapter_devname, "loopback") == 0)
                return (&loopback_adapter);

        adapter = rsmka_lookup_adapter(adapter_devname, instance);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_getadapter done\n"));

        return (adapter);
}


/*
 * *********************** Resource Number Management ********************
 * All resources are stored in a simple hash table. The table is an array
 * of pointers to resource blks. Each blk contains:
 *      base    - base number of this blk
 *      used    - number of used slots in this blk.
 *      blks    - array of pointers to resource items.
 * An entry in a resource blk is empty if it's NULL.
 *
 * We start with no resource array. Each time we run out of slots, we
 * reallocate a new larger array and copy the pointer to the new array and
 * a new resource blk is allocated and added to the hash table.
 *
 * The resource control block contains:
 *      root    - array of pointer of resource blks
 *      sz      - current size of array.
 *      len     - last valid entry in array.
 *
 * A search operation based on a resource number is as follows:
 *      index = rnum / RESOURCE_BLKSZ;
 *      ASSERT(index < resource_block.len);
 *      ASSERT(index < resource_block.sz);
 *      offset = rnum % RESOURCE_BLKSZ;
 *      ASSERT(offset >= resource_block.root[index]->base);
 *      ASSERT(offset < resource_block.root[index]->base + RESOURCE_BLKSZ);
 *      return resource_block.root[index]->blks[offset];
 *
 * A resource blk is freed with its used count reachs zero.
 */
static int
rsmresource_alloc(minor_t *rnum)
{

        /* search for available resource slot */
        int i, j, empty = -1;
        rsmresource_blk_t *blk;

        DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
            "rsmresource_alloc enter\n"));

        rw_enter(&rsm_resource.rsmrc_lock, RW_WRITER);

        /* Try to find an empty slot */
        for (i = 0; i < rsm_resource.rsmrc_len; i++) {
                blk = rsm_resource.rsmrc_root[i];
                if (blk != NULL && blk->rsmrcblk_avail > 0) {
                        /* found an empty slot in this blk */
                        for (j = 0; j < RSMRC_BLKSZ; j++) {
                                if (blk->rsmrcblk_blks[j] == NULL) {
                                        *rnum = (minor_t)
                                            (j + (i * RSMRC_BLKSZ));
                                        /*
                                         * obey gen page limits
                                         */
                                        if (*rnum >= max_segs + 1) {
                                                if (empty < 0) {
                                                        rw_exit(&rsm_resource.
                                                            rsmrc_lock);
                                                        DBG_PRINTF((
                                                            RSM_KERNEL_ALL,
                                                            RSM_ERR,
                                                            "rsmresource"
                                                            "_alloc failed:"
                                                            "not enough res"
                                                            "%d\n", *rnum));
                                        return (RSMERR_INSUFFICIENT_RESOURCES);
                                                } else {
                                                        /* use empty slot */
                                                        break;
                                                }

                                        }

                                        blk->rsmrcblk_blks[j] = RSMRC_RESERVED;
                                        blk->rsmrcblk_avail--;
                                        rw_exit(&rsm_resource.rsmrc_lock);
                                        DBG_PRINTF((RSM_KERNEL_ALL,
                                            RSM_DEBUG_VERBOSE,
                                            "rsmresource_alloc done\n"));
                                        return (RSM_SUCCESS);
                                }
                        }
                } else if (blk == NULL && empty < 0) {
                        /* remember first empty slot */
                        empty = i;
                }
        }

        /* Couldn't find anything, allocate a new blk */
        /*
         * Do we need to reallocate the root array
         */
        if (empty < 0) {
                if (rsm_resource.rsmrc_len == rsm_resource.rsmrc_sz) {
                        /*
                         * Allocate new array and copy current stuff into it
                         */
                        rsmresource_blk_t       **p;
                        uint_t newsz = (uint_t)rsm_resource.rsmrc_sz +
                            RSMRC_BLKSZ;
                        /*
                         * Don't allocate more that max valid rnum
                         */
                        if (rsm_resource.rsmrc_len*RSMRC_BLKSZ >=
                            max_segs + 1) {
                                rw_exit(&rsm_resource.rsmrc_lock);
                                return (RSMERR_INSUFFICIENT_RESOURCES);
                        }

                        p = (rsmresource_blk_t **)kmem_zalloc(
                            newsz * sizeof (*p),
                            KM_SLEEP);

                        if (rsm_resource.rsmrc_root) {
                                uint_t oldsz;

                                oldsz = (uint_t)(rsm_resource.rsmrc_sz *
                                    (int)sizeof (*p));

                                /*
                                 * Copy old data into new space and
                                 * free old stuff
                                 */
                                bcopy(rsm_resource.rsmrc_root, p, oldsz);
                                kmem_free(rsm_resource.rsmrc_root, oldsz);
                        }

                        rsm_resource.rsmrc_root = p;
                        rsm_resource.rsmrc_sz = (int)newsz;
                }

                empty = rsm_resource.rsmrc_len;
                rsm_resource.rsmrc_len++;
        }

        /*
         * Allocate a new blk
         */
        blk = (rsmresource_blk_t *)kmem_zalloc(sizeof (*blk), KM_SLEEP);
        ASSERT(rsm_resource.rsmrc_root[empty] == NULL);
        rsm_resource.rsmrc_root[empty] = blk;
        blk->rsmrcblk_avail = RSMRC_BLKSZ - 1;

        /*
         * Allocate slot
         */

        *rnum = (minor_t)(empty * RSMRC_BLKSZ);

        /*
         * watch out not to exceed bounds of barrier page
         */
        if (*rnum >= max_segs + 1) {
                rw_exit(&rsm_resource.rsmrc_lock);
                DBG_PRINTF((RSM_KERNEL_ALL, RSM_ERR,
                    "rsmresource_alloc failed %d\n", *rnum));

                return (RSMERR_INSUFFICIENT_RESOURCES);
        }
        blk->rsmrcblk_blks[0] = RSMRC_RESERVED;


        rw_exit(&rsm_resource.rsmrc_lock);

        DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
            "rsmresource_alloc done\n"));

        return (RSM_SUCCESS);
}

static rsmresource_t *
rsmresource_free(minor_t rnum)
{

        /* search for available resource slot */
        int i, j;
        rsmresource_blk_t *blk;
        rsmresource_t *p;

        DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
            "rsmresource_free enter\n"));

        i = (int)(rnum / RSMRC_BLKSZ);
        j = (int)(rnum % RSMRC_BLKSZ);

        if (i >= rsm_resource.rsmrc_len) {
                DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
                    "rsmresource_free done\n"));
                return (NULL);
        }

        rw_enter(&rsm_resource.rsmrc_lock, RW_WRITER);

        ASSERT(rsm_resource.rsmrc_root);
        ASSERT(i < rsm_resource.rsmrc_len);
        ASSERT(i < rsm_resource.rsmrc_sz);
        blk = rsm_resource.rsmrc_root[i];
        if (blk == NULL) {
                rw_exit(&rsm_resource.rsmrc_lock);
                DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
                    "rsmresource_free done\n"));
                return (NULL);
        }

        ASSERT(blk->rsmrcblk_blks[j]); /* reserved or full */

        p = blk->rsmrcblk_blks[j];
        if (p == RSMRC_RESERVED) {
                p = NULL;
        }

        blk->rsmrcblk_blks[j] = NULL;
        blk->rsmrcblk_avail++;
        if (blk->rsmrcblk_avail == RSMRC_BLKSZ) {
                /* free this blk */
                kmem_free(blk, sizeof (*blk));
                rsm_resource.rsmrc_root[i] = NULL;
        }

        rw_exit(&rsm_resource.rsmrc_lock);

        DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
            "rsmresource_free done\n"));

        return (p);
}

static rsmresource_t *
rsmresource_lookup(minor_t rnum, int lock)
{
        int i, j;
        rsmresource_blk_t *blk;
        rsmresource_t *p;

        DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
            "rsmresource_lookup enter\n"));

        /* Find resource and lock it in READER mode */
        /* search for available resource slot */

        i = (int)(rnum / RSMRC_BLKSZ);
        j = (int)(rnum % RSMRC_BLKSZ);

        if (i >= rsm_resource.rsmrc_len) {
                DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
                    "rsmresource_lookup done\n"));
                return (NULL);
        }

        rw_enter(&rsm_resource.rsmrc_lock, RW_READER);

        blk = rsm_resource.rsmrc_root[i];
        if (blk != NULL) {
                ASSERT(i < rsm_resource.rsmrc_len);
                ASSERT(i < rsm_resource.rsmrc_sz);

                p = blk->rsmrcblk_blks[j];
                if (lock == RSM_LOCK) {
                        if (p != RSMRC_RESERVED) {
                                mutex_enter(&p->rsmrc_lock);
                        } else {
                                p = NULL;
                        }
                }
        } else {
                p = NULL;
        }
        rw_exit(&rsm_resource.rsmrc_lock);

        DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
            "rsmresource_lookup done\n"));

        return (p);
}

static void
rsmresource_insert(minor_t rnum, rsmresource_t *p, rsm_resource_type_t type)
{
        /* Find resource and lock it in READER mode */
        /* Caller can upgrade if need be */
        /* search for available resource slot */
        int i, j;
        rsmresource_blk_t *blk;

        DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
            "rsmresource_insert enter\n"));

        i = (int)(rnum / RSMRC_BLKSZ);
        j = (int)(rnum % RSMRC_BLKSZ);

        p->rsmrc_type = type;
        p->rsmrc_num = rnum;

        rw_enter(&rsm_resource.rsmrc_lock, RW_READER);

        ASSERT(rsm_resource.rsmrc_root);
        ASSERT(i < rsm_resource.rsmrc_len);
        ASSERT(i < rsm_resource.rsmrc_sz);

        blk = rsm_resource.rsmrc_root[i];
        ASSERT(blk);

        ASSERT(blk->rsmrcblk_blks[j] == RSMRC_RESERVED);

        blk->rsmrcblk_blks[j] = p;

        DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
            "rsmresource_insert done\n"));

        rw_exit(&rsm_resource.rsmrc_lock);
}

static void
rsmresource_destroy()
{
        int i, j;

        DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
            "rsmresource_destroy enter\n"));

        rw_enter(&rsm_resource.rsmrc_lock, RW_WRITER);

        for (i = 0; i < rsm_resource.rsmrc_len; i++) {
                rsmresource_blk_t       *blk;

                blk = rsm_resource.rsmrc_root[i];
                if (blk == NULL) {
                        continue;
                }
                for (j = 0; j < RSMRC_BLKSZ; j++) {
                        if (blk->rsmrcblk_blks[j] != NULL) {
                                DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
                                    "Not null slot %d, %lx\n", j,
                                    (size_t)blk->rsmrcblk_blks[j]));
                        }
                }
                kmem_free(blk, sizeof (*blk));
                rsm_resource.rsmrc_root[i] = NULL;
        }
        if (rsm_resource.rsmrc_root) {
                i = rsm_resource.rsmrc_sz * (int)sizeof (rsmresource_blk_t *);
                kmem_free(rsm_resource.rsmrc_root, (uint_t)i);
                rsm_resource.rsmrc_root = NULL;
                rsm_resource.rsmrc_len = 0;
                rsm_resource.rsmrc_sz = 0;
        }

        DBG_PRINTF((RSM_KERNEL_ALL, RSM_DEBUG_VERBOSE,
            "rsmresource_destroy done\n"));

        rw_exit(&rsm_resource.rsmrc_lock);
}


/* ******************** Generic Key Hash Table Management ********* */
static rsmresource_t *
rsmhash_lookup(rsmhash_table_t *rhash, rsm_memseg_id_t key,
    rsm_resource_state_t state)
{
        rsmresource_t   *p;
        uint_t          hashval;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmhash_lookup enter\n"));

        hashval = rsmhash(key);

        DBG_PRINTF((category, RSM_DEBUG_LVL2, "rsmhash_lookup %u=%d\n",
            key, hashval));

        rw_enter(&rhash->rsmhash_rw, RW_READER);

        p = (rsmresource_t *)rsmhash_getbkt(rhash, hashval);

        for (; p; p = p->rsmrc_next) {
                if (p->rsmrc_key == key) {
                        /* acquire resource lock */
                        RSMRC_LOCK(p);
                        break;
                }
        }

        rw_exit(&rhash->rsmhash_rw);

        if (p != NULL && p->rsmrc_state != state) {
                /* state changed, release lock and return null */
                RSMRC_UNLOCK(p);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmhash_lookup done: state changed\n"));
                return (NULL);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmhash_lookup done\n"));

        return (p);
}

static void
rsmhash_rm(rsmhash_table_t *rhash, rsmresource_t *rcelm)
{
        rsmresource_t           *p, **back;
        uint_t                  hashval;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmhash_rm enter\n"));

        hashval = rsmhash(rcelm->rsmrc_key);

        DBG_PRINTF((category, RSM_DEBUG_LVL2, "rsmhash_rm %u=%d\n",
            rcelm->rsmrc_key, hashval));

        /*
         * It's ok not to find the segment.
         */
        rw_enter(&rhash->rsmhash_rw, RW_WRITER);

        back = (rsmresource_t **)rsmhash_bktaddr(rhash, hashval);

        for (; (p = *back) != NULL;  back = &p->rsmrc_next) {
                if (p == rcelm) {
                        *back = rcelm->rsmrc_next;
                        break;
                }
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmhash_rm done\n"));

        rw_exit(&rhash->rsmhash_rw);
}

static int
rsmhash_add(rsmhash_table_t *rhash, rsmresource_t *new, rsm_memseg_id_t key,
    int dup_check, rsm_resource_state_t state)
{
        rsmresource_t   *p = NULL, **bktp;
        uint_t          hashval;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmhash_add enter\n"));

        /* lock table */
        rw_enter(&rhash->rsmhash_rw, RW_WRITER);

        /*
         * If the current resource state is other than the state passed in
         * then the resource is (probably) already on the list. eg. for an
         * import segment if the state is not RSM_STATE_NEW then it's on the
         * list already.
         */
        RSMRC_LOCK(new);
        if (new->rsmrc_state != state) {
                RSMRC_UNLOCK(new);
                rw_exit(&rhash->rsmhash_rw);
                return (RSMERR_BAD_SEG_HNDL);
        }

        hashval = rsmhash(key);
        DBG_PRINTF((category, RSM_DEBUG_LVL2, "rsmhash_add %d\n", hashval));

        if (dup_check) {
                /*
                 * Used for checking export segments; don't want to have
                 * the same key used for multiple segments.
                 */

                p = (rsmresource_t *)rsmhash_getbkt(rhash, hashval);

                for (; p; p = p->rsmrc_next) {
                        if (p->rsmrc_key == key) {
                                RSMRC_UNLOCK(new);
                                break;
                        }
                }
        }

        if (p == NULL) {
                /* Key doesn't exist, add it */

                bktp = (rsmresource_t **)rsmhash_bktaddr(rhash, hashval);

                new->rsmrc_key = key;
                new->rsmrc_next = *bktp;
                *bktp = new;
        }

        rw_exit(&rhash->rsmhash_rw);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmhash_add done\n"));

        return (p == NULL ? RSM_SUCCESS : RSMERR_SEGID_IN_USE);
}

/*
 * XOR each byte of the key.
 */
static uint_t
rsmhash(rsm_memseg_id_t key)
{
        uint_t  hash = key;

        hash ^=  (key >> 8);
        hash ^=  (key >> 16);
        hash ^=  (key >> 24);

        return (hash % rsm_hash_size);

}

/*
 * generic function to get a specific bucket
 */
static void *
rsmhash_getbkt(rsmhash_table_t *rhash, uint_t hashval)
{

        if (rhash->bucket == NULL)
                return (NULL);
        else
                return ((void *)rhash->bucket[hashval]);
}

/*
 * generic function to get a specific bucket's address
 */
static void **
rsmhash_bktaddr(rsmhash_table_t *rhash, uint_t hashval)
{
        if (rhash->bucket == NULL)
                return (NULL);
        else
                return ((void **)&(rhash->bucket[hashval]));
}

/*
 * generic function to alloc a hash table
 */
static void
rsmhash_alloc(rsmhash_table_t *rhash, int size)
{
        rhash->bucket = (rsmresource_t **)
            kmem_zalloc(size * sizeof (rsmresource_t *), KM_SLEEP);
}

/*
 * generic function to free a hash table
 */
static void
rsmhash_free(rsmhash_table_t *rhash, int size)
{

        kmem_free((void *)rhash->bucket, size * sizeof (caddr_t));
        rhash->bucket = NULL;

}
/* *********************** Exported Segment Key Management ************ */

#define rsmexport_add(new, key)         \
        rsmhash_add(&rsm_export_segs, (rsmresource_t *)new, key, 1, \
            RSM_STATE_BIND)

#define rsmexport_rm(arg)       \
        rsmhash_rm(&rsm_export_segs, (rsmresource_t *)(arg))

#define rsmexport_lookup(key)   \
        (rsmseg_t *)rsmhash_lookup(&rsm_export_segs, key, RSM_STATE_EXPORT)

/* ************************** Import Segment List Management ********** */

/*
 *  Add segment to import list. This will be useful for paging and loopback
 * segment unloading.
 */
#define rsmimport_add(arg, key) \
        rsmhash_add(&rsm_import_segs, (rsmresource_t *)(arg), (key), 0, \
            RSM_STATE_NEW)

#define rsmimport_rm(arg)       \
        rsmhash_rm(&rsm_import_segs, (rsmresource_t *)(arg))

/*
 *      #define rsmimport_lookup(key)   \
 *      (rsmseg_t *)rsmhash_lookup(&rsm_import_segs, (key), RSM_STATE_CONNECT)
 */

/*
 * increase the ref count and make the import segment point to the
 * shared data structure. Return a pointer to the share data struct
 * and the shared data struct is locked upon return
 */
static rsm_import_share_t *
rsmshare_get(rsm_memseg_id_t key, rsm_node_id_t node, adapter_t *adapter,
    rsmseg_t *segp)
{
        uint_t          hash;
        rsmresource_t           *p;
        rsm_import_share_t      *shdatap;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmshare_get enter\n"));

        hash = rsmhash(key);
        /* lock table */
        rw_enter(&rsm_import_segs.rsmhash_rw, RW_WRITER);
        DBG_PRINTF((category, RSM_DEBUG_LVL2, "rsmshare_get:key=%u, hash=%d\n",
            key, hash));

        p = (rsmresource_t *)rsmhash_getbkt(&rsm_import_segs, hash);

        for (; p; p = p->rsmrc_next) {
                /*
                 * Look for an entry that is importing the same exporter
                 * with the share data structure allocated.
                 */
                if ((p->rsmrc_key == key) &&
                    (p->rsmrc_node == node) &&
                    (p->rsmrc_adapter == adapter) &&
                    (((rsmseg_t *)p)->s_share != NULL)) {
                        shdatap = ((rsmseg_t *)p)->s_share;
                        break;
                }
        }

        if (p == NULL) {
                /* we are the first importer, create the shared data struct */
                shdatap = kmem_zalloc(sizeof (rsm_import_share_t), KM_SLEEP);
                shdatap->rsmsi_state = RSMSI_STATE_NEW;
                shdatap->rsmsi_segid = key;
                shdatap->rsmsi_node = node;
                mutex_init(&shdatap->rsmsi_lock, NULL, MUTEX_DRIVER, NULL);
                cv_init(&shdatap->rsmsi_cv, NULL, CV_DRIVER, 0);
        }

        rsmseglock_acquire(segp);

        /* we grab the shared lock before returning from this function */
        mutex_enter(&shdatap->rsmsi_lock);

        shdatap->rsmsi_refcnt++;
        segp->s_share = shdatap;

        rsmseglock_release(segp);

        rw_exit(&rsm_import_segs.rsmhash_rw);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmshare_get done\n"));

        return (shdatap);
}

/*
 * the shared data structure should be locked before calling
 * rsmsharecv_signal().
 * Change the state and signal any waiting segments.
 */
void
rsmsharecv_signal(rsmseg_t *seg, int oldstate, int newstate)
{
        ASSERT(rsmsharelock_held(seg));

        if (seg->s_share->rsmsi_state == oldstate) {
                seg->s_share->rsmsi_state = newstate;
                cv_broadcast(&seg->s_share->rsmsi_cv);
        }
}

/*
 * Add to the hash table
 */
static void
importer_list_add(rsm_node_id_t node, rsm_memseg_id_t key, rsm_addr_t hwaddr,
    void *cookie)
{

        importing_token_t       *head;
        importing_token_t       *new_token;
        int                     index;

        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "importer_list_add enter\n"));

        new_token = kmem_zalloc(sizeof (importing_token_t), KM_SLEEP);
        new_token->importing_node = node;
        new_token->key = key;
        new_token->import_segment_cookie = cookie;
        new_token->importing_adapter_hwaddr = hwaddr;

        index = rsmhash(key);

        mutex_enter(&importer_list.lock);

        head = importer_list.bucket[index];
        importer_list.bucket[index] = new_token;
        new_token->next = head;
        mutex_exit(&importer_list.lock);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "importer_list_add done\n"));
}

static void
importer_list_rm(rsm_node_id_t node,  rsm_memseg_id_t key, void *cookie)
{

        importing_token_t       *prev, *token = NULL;
        int                     index;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "importer_list_rm enter\n"));

        index = rsmhash(key);

        mutex_enter(&importer_list.lock);

        token = importer_list.bucket[index];

        prev = token;
        while (token != NULL) {
                if (token->importing_node == node &&
                    token->import_segment_cookie == cookie) {
                        if (prev == token)
                                importer_list.bucket[index] = token->next;
                        else
                                prev->next = token->next;
                        kmem_free((void *)token, sizeof (*token));
                        break;
                } else {
                        prev = token;
                        token = token->next;
                }
        }

        mutex_exit(&importer_list.lock);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "importer_list_rm done\n"));


}

/* **************************Segment Structure Management ************* */

/*
 * Free segment structure
 */
static void
rsmseg_free(rsmseg_t *seg)
{

        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmseg_free enter\n"));

        /* need to take seglock here to avoid race with rsmmap_unmap() */
        rsmseglock_acquire(seg);
        if (seg->s_ckl != NULL) {
                /* Segment is still busy */
                seg->s_state = RSM_STATE_END;
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmseg_free done\n"));
                return;
        }

        rsmseglock_release(seg);

        ASSERT(seg->s_state == RSM_STATE_END || seg->s_state == RSM_STATE_NEW);

        /*
         * If it's an importer decrement the refcount
         * and if its down to zero free the shared data structure.
         * This is where failures during rsm_connect() are unrefcounted
         */
        if (seg->s_share != NULL) {

                ASSERT(seg->s_type == RSM_RESOURCE_IMPORT_SEGMENT);

                rsmsharelock_acquire(seg);

                ASSERT(seg->s_share->rsmsi_refcnt > 0);

                seg->s_share->rsmsi_refcnt--;

                if (seg->s_share->rsmsi_refcnt == 0) {
                        rsmsharelock_release(seg);
                        mutex_destroy(&seg->s_share->rsmsi_lock);
                        cv_destroy(&seg->s_share->rsmsi_cv);
                        kmem_free((void *)(seg->s_share),
                            sizeof (rsm_import_share_t));
                } else {
                        rsmsharelock_release(seg);
                }
                /*
                 * The following needs to be done after any
                 * rsmsharelock calls which use seg->s_share.
                 */
                seg->s_share = NULL;
        }

        cv_destroy(&seg->s_cv);
        mutex_destroy(&seg->s_lock);
        rsmacl_free(seg->s_acl, seg->s_acl_len);
        rsmpiacl_free(seg->s_acl_in, seg->s_acl_len);
        if (seg->s_adapter)
                rsmka_release_adapter(seg->s_adapter);

        kmem_free((void *)seg, sizeof (*seg));

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmseg_free done\n"));

}


static rsmseg_t *
rsmseg_alloc(minor_t num, struct cred *cred)
{
        rsmseg_t        *new;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmseg_alloc enter\n"));
        /*
         * allocate memory for new segment. This should be a segkmem cache.
         */
        new = (rsmseg_t *)kmem_zalloc(sizeof (*new), KM_SLEEP);

        new->s_state = RSM_STATE_NEW;
        new->s_minor    = num;
        new->s_acl_len  = 0;
        new->s_cookie = NULL;
        new->s_adapter = NULL;

        new->s_mode = 0777 & ~PTOU((ttoproc(curthread)))->u_cmask;
        /* we don't have a key yet, will set at export/connect */
        new->s_uid  = crgetuid(cred);
        new->s_gid  = crgetgid(cred);

        mutex_init(&new->s_lock, NULL, MUTEX_DRIVER, (void *)NULL);
        cv_init(&new->s_cv, NULL, CV_DRIVER, 0);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmseg_alloc done\n"));

        return (new);
}

/* ******************************** Driver Open/Close/Poll *************** */

/*ARGSUSED1*/
static int
rsm_open(dev_t *devp, int flag, int otyp, struct cred *cred)
{
        minor_t rnum;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL| RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_open enter\n"));
        /*
         * Char only
         */
        if (otyp != OTYP_CHR) {
                DBG_PRINTF((category, RSM_ERR, "rsm_open: bad otyp\n"));
                return (EINVAL);
        }

        /*
         * Only zero can be opened, clones are used for resources.
         */
        if (getminor(*devp) != RSM_DRIVER_MINOR) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_open: bad minor %d\n", getminor(*devp)));
                return (ENODEV);
        }

        if ((flag & FEXCL) != 0 && secpolicy_excl_open(cred) != 0) {
                DBG_PRINTF((category, RSM_ERR, "rsm_open: bad perm\n"));
                return (EPERM);
        }

        if (!(flag & FWRITE)) {
                /*
                 * The library function _rsm_librsm_init calls open for
                 * /dev/rsm with flag set to O_RDONLY.  We want a valid
                 * file descriptor to be returned for minor device zero.
                 */

                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_open RDONLY done\n"));
                return (DDI_SUCCESS);
        }

        /*
         * - allocate new minor number and segment.
         * - add segment to list of all segments.
         * - set minordev data to segment
         * - update devp argument to new device
         * - update s_cred to cred; make sure you do crhold(cred);
         */

        /* allocate a new resource number */
        if (rsmresource_alloc(&rnum) == RSM_SUCCESS) {
                /*
                 * We will bind this minor to a specific resource in first
                 * ioctl
                 */
                *devp = makedevice(getmajor(*devp), rnum);
        } else {
                return (EAGAIN);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_open done\n"));
        return (DDI_SUCCESS);
}

static void
rsmseg_close(rsmseg_t *seg, int force_flag)
{
        int e = RSM_SUCCESS;

        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL| RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmseg_close enter\n"));

        rsmseglock_acquire(seg);
        if (!force_flag && (seg->s_hdr.rsmrc_type ==
            RSM_RESOURCE_EXPORT_SEGMENT)) {
                /*
                 * If we are processing rsm_close wait for force_destroy
                 * processing to complete since force_destroy processing
                 * needs to finish first before we can free the segment.
                 * force_destroy is only for export segments
                 */
                while (seg->s_flags & RSM_FORCE_DESTROY_WAIT) {
                        cv_wait(&seg->s_cv, &seg->s_lock);
                }
        }
        rsmseglock_release(seg);

        /* It's ok to read the state without a lock */
        switch (seg->s_state) {
        case RSM_STATE_EXPORT:
        case RSM_STATE_EXPORT_QUIESCING:
        case RSM_STATE_EXPORT_QUIESCED:
                e = rsm_unpublish(seg, 1);
                /* FALLTHRU */
        case RSM_STATE_BIND_QUIESCED:
                /* FALLTHRU */
        case RSM_STATE_BIND:
                e = rsm_unbind(seg);
                if (e != RSM_SUCCESS && force_flag == 1)
                        return;
                ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_EXPORT_SEGMENT);
                /* FALLTHRU */
        case RSM_STATE_NEW_QUIESCED:
                rsmseglock_acquire(seg);
                seg->s_state = RSM_STATE_NEW;
                cv_broadcast(&seg->s_cv);
                rsmseglock_release(seg);
                break;
        case RSM_STATE_NEW:
                break;
        case RSM_STATE_ZOMBIE:
                /*
                 * Segments in this state have been removed off the
                 * exported segments list and have been unpublished
                 * and unbind. These segments have been removed during
                 * a callback to the rsm_export_force_destroy, which
                 * is called for the purpose of unlocking these
                 * exported memory segments when a process exits but
                 * leaves the segments locked down since rsm_close is
                 * is not called for the segments. This can happen
                 * when a process calls fork or exec and then exits.
                 * Once the segments are in the ZOMBIE state, all that
                 * remains is to destroy them when rsm_close is called.
                 * This is done here. Thus, for such segments the
                 * the state is changed to new so that later in this
                 * function rsmseg_free is called.
                 */
                rsmseglock_acquire(seg);
                seg->s_state = RSM_STATE_NEW;
                rsmseglock_release(seg);
                break;
        case RSM_STATE_MAP_QUIESCE:
        case RSM_STATE_ACTIVE:
                /* Disconnect will handle the unmap */
        case RSM_STATE_CONN_QUIESCE:
        case RSM_STATE_CONNECT:
        case RSM_STATE_DISCONNECT:
                ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);
                (void) rsm_disconnect(seg);
                break;
        case RSM_STATE_MAPPING:
                /*FALLTHRU*/
        case RSM_STATE_END:
                DBG_PRINTF((category, RSM_ERR,
                    "Invalid segment state %d in rsm_close\n", seg->s_state));
                break;
        default:
                DBG_PRINTF((category, RSM_ERR,
                    "Invalid segment state %d in rsm_close\n", seg->s_state));
                break;
        }

        /*
         * check state.
         * - make sure you do crfree(s_cred);
         * release segment and minor number
         */
        ASSERT(seg->s_state == RSM_STATE_NEW);

        /*
         * The export_force_destroy callback is created to unlock
         * the exported segments of a process
         * when the process does a fork or exec and then exits calls this
         * function with the force flag set to 1 which indicates that the
         * segment state must be converted to ZOMBIE. This state means that the
         * segments still exist and have been unlocked and most importantly the
         * only operation allowed is to destroy them on an rsm_close.
         */
        if (force_flag) {
                rsmseglock_acquire(seg);
                seg->s_state = RSM_STATE_ZOMBIE;
                rsmseglock_release(seg);
        } else {
                rsmseg_free(seg);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmseg_close done\n"));
}

static int
rsm_close(dev_t dev, int flag, int otyp, cred_t *cred)
{
        minor_t rnum = getminor(dev);
        rsmresource_t *res;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL| RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_close enter\n"));

        flag = flag; cred = cred;

        if (otyp != OTYP_CHR)
                return (EINVAL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rnum = %d\n", rnum));

        /*
         * At this point we are the last reference to the resource.
         * Free resource number from resource table.
         * It's ok to remove number before we free the segment.
         * We need to lock the resource to protect against remote calls.
         */
        if (rnum == RSM_DRIVER_MINOR ||
            (res = rsmresource_free(rnum)) == NULL) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_close done\n"));
                return (DDI_SUCCESS);
        }

        switch (res->rsmrc_type) {
        case RSM_RESOURCE_EXPORT_SEGMENT:
        case RSM_RESOURCE_IMPORT_SEGMENT:
                rsmseg_close((rsmseg_t *)res, 0);
                break;
        case RSM_RESOURCE_BAR:
                DBG_PRINTF((category, RSM_ERR, "bad resource in rsm_close\n"));
                break;
        default:
                break;
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_close done\n"));

        return (DDI_SUCCESS);
}

/*
 * rsm_inc_pgcnt
 *
 * Description: increment rsm page counter.
 *
 * Parameters:  pgcnt_t pnum;   number of pages to be used
 *
 * Returns:     RSM_SUCCESS     if memory limit not exceeded
 *              ENOSPC          if memory limit exceeded. In this case, the
 *                              page counter remains unchanged.
 *
 */
static int
rsm_inc_pgcnt(pgcnt_t pnum)
{
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);
        if (rsm_pgcnt_max == 0) { /* no upper limit has been set */
                return (RSM_SUCCESS);
        }

        mutex_enter(&rsm_pgcnt_lock);

        if (rsm_pgcnt + pnum > rsm_pgcnt_max) {
                /* ensure that limits have not been exceeded */
                mutex_exit(&rsm_pgcnt_lock);
                return (RSMERR_INSUFFICIENT_MEM);
        }

        rsm_pgcnt += pnum;
        DBG_PRINTF((category, RSM_DEBUG, "rsm_pgcnt incr to %d.\n",
            rsm_pgcnt));
        mutex_exit(&rsm_pgcnt_lock);

        return (RSM_SUCCESS);
}

/*
 * rsm_dec_pgcnt
 *
 * Description: decrement rsm page counter.
 *
 * Parameters:  pgcnt_t pnum;   number of pages freed
 *
 */
static void
rsm_dec_pgcnt(pgcnt_t pnum)
{
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        if (rsm_pgcnt_max == 0) { /* no upper limit has been set */
                return;
        }

        mutex_enter(&rsm_pgcnt_lock);
        ASSERT(rsm_pgcnt >= pnum);
        rsm_pgcnt -= pnum;
        DBG_PRINTF((category, RSM_DEBUG, "rsm_pgcnt decr to %d.\n",
            rsm_pgcnt));
        mutex_exit(&rsm_pgcnt_lock);
}

static struct umem_callback_ops rsm_as_ops = {
        UMEM_CALLBACK_VERSION, /* version number */
        rsm_export_force_destroy,
};

static int
rsm_bind_pages(ddi_umem_cookie_t *cookie, caddr_t vaddr, size_t len,
    proc_t *procp)
{
        int error = RSM_SUCCESS;
        ulong_t pnum;
        struct umem_callback_ops *callbackops = &rsm_as_ops;

        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_bind_pages enter\n"));

        /*
         * Make sure vaddr and len are aligned on a page boundary
         */
        if ((uintptr_t)vaddr & (PAGESIZE - 1)) {
                return (RSMERR_BAD_ADDR);
        }

        if (len & (PAGESIZE - 1)) {
                return (RSMERR_BAD_LENGTH);
        }

        /*
         * Find number of pages
         */
        pnum = btopr(len);
        error = rsm_inc_pgcnt(pnum);
        if (error != RSM_SUCCESS) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_bind_pages:mem limit exceeded\n"));
                return (RSMERR_INSUFFICIENT_MEM);
        }

        error = umem_lockmemory(vaddr, len,
            DDI_UMEMLOCK_WRITE|DDI_UMEMLOCK_READ|DDI_UMEMLOCK_LONGTERM,
            cookie,
            callbackops, procp);

        if (error) {
                rsm_dec_pgcnt(pnum);
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_bind_pages:ddi_umem_lock failed\n"));
                /*
                 * ddi_umem_lock, in the case of failure, returns one of
                 * the following three errors. These are translated into
                 * the RSMERR namespace and returned.
                 */
                if (error == EFAULT)
                        return (RSMERR_BAD_ADDR);
                else if (error == EACCES)
                        return (RSMERR_PERM_DENIED);
                else
                        return (RSMERR_INSUFFICIENT_MEM);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_bind_pages done\n"));

        return (error);

}

static int
rsm_unbind_pages(rsmseg_t *seg)
{
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_unbind_pages enter\n"));

        ASSERT(rsmseglock_held(seg));

        if (seg->s_cookie != NULL) {
                /* unlock address range */
                ddi_umem_unlock(seg->s_cookie);
                rsm_dec_pgcnt(btopr(seg->s_len));
                seg->s_cookie = NULL;
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_unbind_pages done\n"));

        return (RSM_SUCCESS);
}


static int
rsm_bind(rsmseg_t *seg, rsm_ioctlmsg_t *msg, intptr_t dataptr, int mode)
{
        int e;
        adapter_t *adapter;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_bind enter\n"));

        adapter = rsm_getadapter(msg, mode);
        if (adapter == NULL) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_bind done:no adapter\n"));
                return (RSMERR_CTLR_NOT_PRESENT);
        }

        /* lock address range */
        if (msg->vaddr == NULL) {
                rsmka_release_adapter(adapter);
                DBG_PRINTF((category, RSM_ERR,
                    "rsm: rsm_bind done: invalid vaddr\n"));
                return (RSMERR_BAD_ADDR);
        }
        if (msg->len <= 0) {
                rsmka_release_adapter(adapter);
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_bind: invalid length\n"));
                return (RSMERR_BAD_LENGTH);
        }

        /* Lock segment */
        rsmseglock_acquire(seg);

        while (seg->s_state == RSM_STATE_NEW_QUIESCED) {
                if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsm_bind done: cv_wait INTERRUPTED"));
                        rsmka_release_adapter(adapter);
                        rsmseglock_release(seg);
                        return (RSMERR_INTERRUPTED);
                }
        }

        ASSERT(seg->s_state == RSM_STATE_NEW);

        ASSERT(seg->s_cookie == NULL);

        e = rsm_bind_pages(&seg->s_cookie, msg->vaddr, msg->len, curproc);
        if (e == RSM_SUCCESS) {
                seg->s_flags |= RSM_USER_MEMORY;
                if (msg->perm & RSM_ALLOW_REBIND) {
                        seg->s_flags |= RSMKA_ALLOW_UNBIND_REBIND;
                }
                if (msg->perm & RSM_CREATE_SEG_DONTWAIT) {
                        seg->s_flags |= RSMKA_SET_RESOURCE_DONTWAIT;
                }
                seg->s_region.r_vaddr = msg->vaddr;
                /*
                 * Set the s_pid value in the segment structure. This is used
                 * to identify exported segments belonging to a particular
                 * process so that when the process exits, these segments can
                 * be unlocked forcefully even if rsm_close is not called on
                 * process exit since there maybe other processes referencing
                 * them (for example on a fork or exec).
                 * The s_pid value is also used to authenticate the process
                 * doing a publish or unpublish on the export segment. Only
                 * the creator of the export segment has a right to do a
                 * publish or unpublish and unbind on the segment.
                 */
                seg->s_pid = ddi_get_pid();
                seg->s_len = msg->len;
                seg->s_state = RSM_STATE_BIND;
                seg->s_adapter = adapter;
                seg->s_proc = curproc;
        } else {
                rsmka_release_adapter(adapter);
                DBG_PRINTF((category, RSM_WARNING,
                    "unable to lock down pages\n"));
        }

        msg->rnum = seg->s_minor;
        /* Unlock segment */
        rsmseglock_release(seg);

        if (e == RSM_SUCCESS) {
                /* copyout the resource number */
#ifdef _MULTI_DATAMODEL
                if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
                        rsm_ioctlmsg32_t msg32;

                        msg32.rnum = msg->rnum;
                        if (ddi_copyout((caddr_t)&msg32.rnum,
                            (caddr_t)&((rsm_ioctlmsg32_t *)dataptr)->rnum,
                            sizeof (minor_t), mode)) {
                                rsmka_release_adapter(adapter);
                                e = RSMERR_BAD_ADDR;
                        }
                }
#endif
                if (ddi_copyout((caddr_t)&msg->rnum,
                    (caddr_t)&((rsm_ioctlmsg_t *)dataptr)->rnum,
                    sizeof (minor_t), mode)) {
                        rsmka_release_adapter(adapter);
                        e = RSMERR_BAD_ADDR;
                }
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_bind done\n"));

        return (e);
}

static void
rsm_remap_local_importers(rsm_node_id_t src_nodeid,
    rsm_memseg_id_t ex_segid, ddi_umem_cookie_t cookie)
{
        rsmresource_t   *p = NULL;
        rsmhash_table_t *rhash = &rsm_import_segs;
        uint_t          index;

        DBG_PRINTF((RSM_KERNEL_AGENT | RSM_FUNC_ALL, RSM_DEBUG_VERBOSE,
            "rsm_remap_local_importers enter\n"));

        index = rsmhash(ex_segid);

        rw_enter(&rhash->rsmhash_rw, RW_READER);

        p = rsmhash_getbkt(rhash, index);

        for (; p; p = p->rsmrc_next) {
                rsmseg_t *seg = (rsmseg_t *)p;
                rsmseglock_acquire(seg);
                /*
                 * Change the s_cookie value of only the local importers
                 * which have been mapped (in state RSM_STATE_ACTIVE).
                 * Note that there is no need to change the s_cookie value
                 * if the imported segment is in RSM_STATE_MAPPING since
                 * eventually the s_cookie will be updated via the mapping
                 * functionality.
                 */
                if ((seg->s_segid == ex_segid) && (seg->s_node == src_nodeid) &&
                    (seg->s_state == RSM_STATE_ACTIVE)) {
                        seg->s_cookie = cookie;
                }
                rsmseglock_release(seg);
        }
        rw_exit(&rhash->rsmhash_rw);

        DBG_PRINTF((RSM_KERNEL_AGENT | RSM_FUNC_ALL, RSM_DEBUG_VERBOSE,
            "rsm_remap_local_importers done\n"));
}

static int
rsm_rebind(rsmseg_t *seg, rsm_ioctlmsg_t *msg)
{
        int e;
        adapter_t *adapter;
        ddi_umem_cookie_t cookie;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_rebind enter\n"));

        /* Check for permissions to rebind */
        if (!(seg->s_flags & RSMKA_ALLOW_UNBIND_REBIND)) {
                return (RSMERR_REBIND_NOT_ALLOWED);
        }

        if (seg->s_pid != ddi_get_pid() &&
            ddi_get_pid() != 0) {
                DBG_PRINTF((category, RSM_ERR, "rsm_rebind: Not owner\n"));
                return (RSMERR_NOT_CREATOR);
        }

        /*
         * We will not be allowing partial rebind and hence length passed
         * in must be same as segment length
         */
        if (msg->vaddr == NULL) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_rebind done: null msg->vaddr\n"));
                return (RSMERR_BAD_ADDR);
        }
        if (msg->len != seg->s_len) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_rebind: invalid length\n"));
                return (RSMERR_BAD_LENGTH);
        }

        /* Lock segment */
        rsmseglock_acquire(seg);

        while ((seg->s_state == RSM_STATE_BIND_QUIESCED) ||
            (seg->s_state == RSM_STATE_EXPORT_QUIESCING) ||
            (seg->s_state == RSM_STATE_EXPORT_QUIESCED)) {
                if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
                        rsmseglock_release(seg);
                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsm_rebind done: cv_wait INTERRUPTED"));
                        return (RSMERR_INTERRUPTED);
                }
        }

        /* verify segment state */
        if ((seg->s_state != RSM_STATE_BIND) &&
            (seg->s_state != RSM_STATE_EXPORT)) {
                /* Unlock segment */
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_rebind done: invalid state\n"));
                return (RSMERR_BAD_SEG_HNDL);
        }

        ASSERT(seg->s_cookie != NULL);

        if (msg->vaddr == seg->s_region.r_vaddr) {
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_rebind done\n"));
                return (RSM_SUCCESS);
        }

        e = rsm_bind_pages(&cookie, msg->vaddr, msg->len, curproc);
        if (e == RSM_SUCCESS) {
                struct buf *xbuf;
                dev_t sdev = 0;
                rsm_memory_local_t mem;

                xbuf = ddi_umem_iosetup(cookie, 0, msg->len, B_WRITE,
                    sdev, 0, NULL, DDI_UMEM_SLEEP);
                ASSERT(xbuf != NULL);

                mem.ms_type = RSM_MEM_BUF;
                mem.ms_bp = xbuf;

                adapter = seg->s_adapter;
                e = adapter->rsmpi_ops->rsm_rebind(
                    seg->s_handle.out, 0, &mem,
                    RSM_RESOURCE_DONTWAIT, NULL);

                if (e == RSM_SUCCESS) {
                        /*
                         * unbind the older pages, and unload local importers;
                         * but don't disconnect importers
                         */
                        (void) rsm_unbind_pages(seg);
                        seg->s_cookie = cookie;
                        seg->s_region.r_vaddr = msg->vaddr;
                        rsm_remap_local_importers(my_nodeid, seg->s_segid,
                            cookie);
                } else {
                        /*
                         * Unbind the pages associated with "cookie" by the
                         * rsm_bind_pages calls prior to this. This is
                         * similar to what is done in the rsm_unbind_pages
                         * routine for the seg->s_cookie.
                         */
                        ddi_umem_unlock(cookie);
                        rsm_dec_pgcnt(btopr(msg->len));
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm_rebind failed with %d\n", e));
                }
                /*
                 * At present there is no dependency on the existence of xbuf.
                 * So we can free it here. If in the future this changes, it can
                 * be freed sometime during the segment destroy.
                 */
                freerbuf(xbuf);
        }

        /* Unlock segment */
        rsmseglock_release(seg);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_rebind done\n"));

        return (e);
}

static int
rsm_unbind(rsmseg_t *seg)
{
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_unbind enter\n"));

        rsmseglock_acquire(seg);

        /* verify segment state */
        if ((seg->s_state != RSM_STATE_BIND) &&
            (seg->s_state != RSM_STATE_BIND_QUIESCED)) {
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_unbind: invalid state\n"));
                return (RSMERR_BAD_SEG_HNDL);
        }

        /* unlock current range */
        (void) rsm_unbind_pages(seg);

        if (seg->s_state == RSM_STATE_BIND) {
                seg->s_state = RSM_STATE_NEW;
        } else if (seg->s_state == RSM_STATE_BIND_QUIESCED) {
                seg->s_state = RSM_STATE_NEW_QUIESCED;
        }

        rsmseglock_release(seg);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_unbind done\n"));

        return (RSM_SUCCESS);
}

/* **************************** Exporter Access List Management ******* */
static void
rsmacl_free(rsmapi_access_entry_t *acl, int acl_len)
{
        int     acl_sz;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmacl_free enter\n"));

        /* acl could be NULL */

        if (acl != NULL && acl_len > 0) {
                acl_sz = acl_len * sizeof (rsmapi_access_entry_t);
                kmem_free((void *)acl, acl_sz);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmacl_free done\n"));
}

static void
rsmpiacl_free(rsm_access_entry_t *acl, int acl_len)
{
        int     acl_sz;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmpiacl_free enter\n"));

        if (acl != NULL && acl_len > 0) {
                acl_sz = acl_len * sizeof (rsm_access_entry_t);
                kmem_free((void *)acl, acl_sz);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmpiacl_free done\n"));

}

static int
rsmacl_build(rsm_ioctlmsg_t *msg, int mode,
    rsmapi_access_entry_t **list, int *len, int loopback)
{
        rsmapi_access_entry_t *acl;
        int     acl_len;
        int i;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmacl_build enter\n"));

        *len = 0;
        *list = NULL;

        acl_len = msg->acl_len;
        if ((loopback && acl_len > 1) || (acl_len < 0) ||
            (acl_len > MAX_NODES)) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmacl_build done: acl invalid\n"));
                return (RSMERR_BAD_ACL);
        }

        if (acl_len > 0 && acl_len <= MAX_NODES) {
                size_t acl_size = acl_len * sizeof (rsmapi_access_entry_t);

                acl = kmem_alloc(acl_size, KM_SLEEP);

                if (ddi_copyin((caddr_t)msg->acl, (caddr_t)acl,
                    acl_size, mode)) {
                        kmem_free((void *) acl, acl_size);
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsmacl_build done: BAD_ADDR\n"));
                        return (RSMERR_BAD_ADDR);
                }

                /*
                 * Verify access list
                 */
                for (i = 0; i < acl_len; i++) {
                        if (acl[i].ae_node > MAX_NODES ||
                            (loopback && (acl[i].ae_node != my_nodeid)) ||
                            acl[i].ae_permission > RSM_ACCESS_TRUSTED) {
                                /* invalid entry */
                                kmem_free((void *) acl, acl_size);
                                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                                    "rsmacl_build done: EINVAL\n"));
                                return (RSMERR_BAD_ACL);
                        }
                }

                *len = acl_len;
                *list = acl;
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmacl_build done\n"));

        return (DDI_SUCCESS);
}

static int
rsmpiacl_create(rsmapi_access_entry_t *src, rsm_access_entry_t **dest,
    int acl_len, adapter_t *adapter)
{
        rsm_access_entry_t *acl;
        rsm_addr_t hwaddr;
        int i;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmpiacl_create enter\n"));

        if (src != NULL) {
                size_t acl_size = acl_len * sizeof (rsm_access_entry_t);
                acl = kmem_alloc(acl_size, KM_SLEEP);

                /*
                 * translate access list
                 */
                for (i = 0; i < acl_len; i++) {
                        if (src[i].ae_node == my_nodeid) {
                                acl[i].ae_addr = adapter->hwaddr;
                        } else {
                                hwaddr = get_remote_hwaddr(adapter,
                                    src[i].ae_node);
                                if ((int64_t)hwaddr < 0) {
                                        /* invalid hwaddr */
                                        kmem_free((void *) acl, acl_size);
                                        DBG_PRINTF((category,
                                            RSM_DEBUG_VERBOSE,
                                            "rsmpiacl_create done:"
                                            "EINVAL hwaddr\n"));
                                        return (RSMERR_INTERNAL_ERROR);
                                }
                                acl[i].ae_addr = hwaddr;
                        }
                        /* rsmpi understands only RSM_PERM_XXXX */
                        acl[i].ae_permission =
                            src[i].ae_permission & RSM_PERM_RDWR;
                }
                *dest = acl;
        } else {
                *dest = NULL;
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmpiacl_create done\n"));

        return (RSM_SUCCESS);
}

static int
rsmsegacl_validate(rsmipc_request_t *req, rsm_node_id_t rnode,
    rsmipc_reply_t *reply)
{

        int             i;
        rsmseg_t        *seg;
        rsm_memseg_id_t key = req->rsmipc_key;
        rsm_permission_t perm = req->rsmipc_perm;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmsegacl_validate enter\n"));

        /*
         * Find segment and grab its lock. The reason why we grab the segment
         * lock in side the search is to avoid the race when the segment is
         * being deleted and we already have a pointer to it.
         */
        seg = rsmexport_lookup(key);
        if (!seg) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmsegacl_validate done: %u ENXIO\n", key));
                return (RSMERR_SEG_NOT_PUBLISHED);
        }

        ASSERT(rsmseglock_held(seg));
        ASSERT(seg->s_state == RSM_STATE_EXPORT);

        /*
         * We implement a 2-level protection scheme.
         * First, we check if local/remote host has access rights.
         * Second, we check if the user has access rights.
         *
         * This routine only validates the rnode access_list
         */
        if (seg->s_acl_len > 0) {
                /*
                 * Check host access list
                 */
                ASSERT(seg->s_acl != NULL);
                for (i = 0; i < seg->s_acl_len; i++) {
                        if (seg->s_acl[i].ae_node == rnode) {
                                perm &= seg->s_acl[i].ae_permission;
                                goto found;
                        }
                }
                /* rnode is not found in the list */
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmsegacl_validate done: EPERM\n"));
                return (RSMERR_SEG_NOT_PUBLISHED_TO_NODE);
        } else {
                /* use default owner creation umask */
                perm &= seg->s_mode;
        }

found:
        /* update perm for this node */
        reply->rsmipc_mode = perm;
        reply->rsmipc_uid = seg->s_uid;
        reply->rsmipc_gid = seg->s_gid;
        reply->rsmipc_segid = seg->s_segid;
        reply->rsmipc_seglen = seg->s_len;

        /*
         * Perm of requesting node is valid; source will validate user
         */
        rsmseglock_release(seg);

        /*
         * Add the importer to the list right away, if connect fails
         * the importer will ask the exporter to remove it.
         */
        importer_list_add(rnode, key, req->rsmipc_adapter_hwaddr,
            req->rsmipc_segment_cookie);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmsegacl_validate done\n"));

        return (RSM_SUCCESS);
}


/* ************************** Exporter Calls ************************* */

static int
rsm_publish(rsmseg_t *seg, rsm_ioctlmsg_t *msg, intptr_t dataptr, int mode)
{
        int                     e;
        int                     acl_len;
        rsmapi_access_entry_t   *acl;
        rsm_access_entry_t      *rsmpi_acl;
        rsm_memory_local_t      mem;
        struct buf              *xbuf;
        dev_t                   sdev = 0;
        adapter_t               *adapter;
        rsm_memseg_id_t         segment_id = 0;
        int                     loopback_flag = 0;
        int                     create_flags = 0;
        rsm_resource_callback_t callback_flag;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_publish enter\n"));

        if (seg->s_adapter == &loopback_adapter)
                loopback_flag = 1;

        if (seg->s_pid != ddi_get_pid() &&
            ddi_get_pid() != 0) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_publish: Not creator\n"));
                return (RSMERR_NOT_CREATOR);
        }

        /*
         * Get per node access list
         */
        e = rsmacl_build(msg, mode, &acl, &acl_len, loopback_flag);
        if (e != DDI_SUCCESS) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_publish done: rsmacl_build failed\n"));
                return (e);
        }

        /*
         * The application provided msg->key is used for resolving a
         * segment id according to the following:
         *    key = 0                   Kernel Agent selects the segment id
         *    key <= RSM_DLPI_ID_END    Reserved for system usage except
         *                              RSMLIB range
         *    key < RSM_USER_APP_ID_BASE segment id = key
         *    key >= RSM_USER_APP_ID_BASE Reserved for KA selections
         *
         * rsm_nextavail_segmentid is initialized to 0x80000000 and
         * overflows to zero after 0x80000000 allocations.
         * An algorithm is needed which allows reinitialization and provides
         * for reallocation after overflow.  For now, ENOMEM is returned
         * once the overflow condition has occurred.
         */
        if (msg->key == 0) {
                mutex_enter(&rsm_lock);
                segment_id = rsm_nextavail_segmentid;
                if (segment_id != 0) {
                        rsm_nextavail_segmentid++;
                        mutex_exit(&rsm_lock);
                } else {
                        mutex_exit(&rsm_lock);
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm_publish done: no more keys avlbl\n"));
                        return (RSMERR_INSUFFICIENT_RESOURCES);
                }
        } else  if BETWEEN(msg->key, RSM_RSMLIB_ID_BASE, RSM_RSMLIB_ID_END)
                /* range reserved for internal use by base/ndi libraries */
                segment_id = msg->key;
        else    if (msg->key <= RSM_DLPI_ID_END)
                return (RSMERR_RESERVED_SEGID);
        else if (msg->key <= (uint_t)RSM_USER_APP_ID_BASE -1)
                segment_id = msg->key;
        else {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_publish done: invalid key %u\n", msg->key));
                return (RSMERR_RESERVED_SEGID);
        }

        /* Add key to exportlist; The segment lock is held on success */
        e = rsmexport_add(seg, segment_id);
        if (e) {
                rsmacl_free(acl, acl_len);
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_publish done: export_add failed: %d\n", e));
                return (e);
        }

        seg->s_segid = segment_id;

        if ((seg->s_state != RSM_STATE_BIND) &&
            (seg->s_state != RSM_STATE_BIND_QUIESCED)) {
                /* state changed since then, free acl and return */
                rsmseglock_release(seg);
                rsmexport_rm(seg);
                rsmacl_free(acl, acl_len);
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_publish done: segment in wrong state: %d\n",
                    seg->s_state));
                return (RSMERR_BAD_SEG_HNDL);
        }

        /*
         * If this is for a local memory handle and permissions are zero,
         * then the surrogate segment is very large and we want to skip
         * allocation of DVMA space.
         *
         * Careful!  If the user didn't use an ACL list, acl will be a NULL
         * pointer.  Check that before dereferencing it.
         */
        if (acl != (rsmapi_access_entry_t *)NULL) {
                if (acl[0].ae_node == my_nodeid && acl[0].ae_permission == 0)
                        goto skipdriver;
        }

        /* create segment  */
        xbuf = ddi_umem_iosetup(seg->s_cookie, 0, seg->s_len, B_WRITE,
            sdev, 0, NULL, DDI_UMEM_SLEEP);
        ASSERT(xbuf != NULL);

        mem.ms_type = RSM_MEM_BUF;
        mem.ms_bp = xbuf;

        /* This call includes a bind operations */

        adapter = seg->s_adapter;
        /*
         * create a acl list with hwaddr for RSMPI publish
         */
        e = rsmpiacl_create(acl, &rsmpi_acl, acl_len, adapter);

        if (e != RSM_SUCCESS) {
                rsmseglock_release(seg);
                rsmexport_rm(seg);
                rsmacl_free(acl, acl_len);
                freerbuf(xbuf);
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_publish done: rsmpiacl_create failed: %d\n", e));
                return (e);
        }

        if (seg->s_state == RSM_STATE_BIND) {
                /* create segment  */

                /* This call includes a bind operations */

                if (seg->s_flags & RSMKA_ALLOW_UNBIND_REBIND) {
                        create_flags = RSM_ALLOW_UNBIND_REBIND;
                }

                if (seg->s_flags & RSMKA_SET_RESOURCE_DONTWAIT) {
                        callback_flag  = RSM_RESOURCE_DONTWAIT;
                } else {
                        callback_flag  = RSM_RESOURCE_SLEEP;
                }

                e = adapter->rsmpi_ops->rsm_seg_create(
                    adapter->rsmpi_handle,
                    &seg->s_handle.out, seg->s_len,
                    create_flags, &mem,
                    callback_flag, NULL);
                /*
                 * At present there is no dependency on the existence of xbuf.
                 * So we can free it here. If in the future this changes, it can
                 * be freed sometime during the segment destroy.
                 */
                freerbuf(xbuf);

                if (e != RSM_SUCCESS) {
                        rsmseglock_release(seg);
                        rsmexport_rm(seg);
                        rsmacl_free(acl, acl_len);
                        rsmpiacl_free(rsmpi_acl, acl_len);
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm_publish done: export_create failed: %d\n", e));
                        /*
                         * The following assertion ensures that the two errors
                         * related to the length and its alignment do not occur
                         * since they have been checked during export_create
                         */
                        ASSERT(e != RSMERR_BAD_MEM_ALIGNMENT &&
                            e != RSMERR_BAD_LENGTH);
                        if (e == RSMERR_NOT_MEM)
                                e = RSMERR_INSUFFICIENT_MEM;

                        return (e);
                }
                /* export segment, this should create an IMMU mapping */
                e = adapter->rsmpi_ops->rsm_publish(
                    seg->s_handle.out,
                    rsmpi_acl, acl_len,
                    seg->s_segid,
                    RSM_RESOURCE_DONTWAIT, NULL);

                if (e != RSM_SUCCESS) {
                        adapter->rsmpi_ops->rsm_seg_destroy(seg->s_handle.out);
                        rsmseglock_release(seg);
                        rsmexport_rm(seg);
                        rsmacl_free(acl, acl_len);
                        rsmpiacl_free(rsmpi_acl, acl_len);
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm_publish done: export_publish failed: %d\n",
                            e));
                        return (e);
                }
        }

        seg->s_acl_in = rsmpi_acl;

skipdriver:
        /* defer s_acl/s_acl_len -> avoid crash in rsmseg_free */
        seg->s_acl_len  = acl_len;
        seg->s_acl      = acl;

        if (seg->s_state == RSM_STATE_BIND) {
                seg->s_state = RSM_STATE_EXPORT;
        } else if (seg->s_state == RSM_STATE_BIND_QUIESCED) {
                seg->s_state = RSM_STATE_EXPORT_QUIESCED;
                cv_broadcast(&seg->s_cv);
        }

        rsmseglock_release(seg);

        /*
         * If the segment id was solicited, then return it in
         * the original incoming message.
         */
        if (msg->key == 0) {
                msg->key = segment_id;
#ifdef _MULTI_DATAMODEL
                if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
                        rsm_ioctlmsg32_t msg32;

                        msg32.key = msg->key;
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsm_publish done\n"));
                        return (ddi_copyout((caddr_t)&msg32,
                            (caddr_t)dataptr, sizeof (msg32), mode));
                }
#endif
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_publish done\n"));
                return (ddi_copyout((caddr_t)msg,
                    (caddr_t)dataptr, sizeof (*msg), mode));
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_publish done\n"));
        return (DDI_SUCCESS);
}

/*
 * This function modifies the access control list of an already published
 * segment.  There is no effect on import segments which are already
 * connected.
 */
static int
rsm_republish(rsmseg_t *seg, rsm_ioctlmsg_t *msg, int mode)
{
        rsmapi_access_entry_t   *new_acl, *old_acl, *tmp_acl;
        rsm_access_entry_t      *rsmpi_new_acl, *rsmpi_old_acl;
        int                     new_acl_len, old_acl_len, tmp_acl_len;
        int                     e, i;
        adapter_t               *adapter;
        int                     loopback_flag = 0;
        rsm_memseg_id_t         key;
        rsm_permission_t        permission;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_republish enter\n"));

        if ((seg->s_state != RSM_STATE_EXPORT) &&
            (seg->s_state != RSM_STATE_EXPORT_QUIESCED) &&
            (seg->s_state != RSM_STATE_EXPORT_QUIESCING))
                return (RSMERR_SEG_NOT_PUBLISHED);

        if (seg->s_pid != ddi_get_pid() &&
            ddi_get_pid() != 0) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_republish: Not owner\n"));
                return (RSMERR_NOT_CREATOR);
        }

        if (seg->s_adapter == &loopback_adapter)
                loopback_flag = 1;

        /*
         * Build new list first
         */
        e = rsmacl_build(msg, mode, &new_acl, &new_acl_len, loopback_flag);
        if (e) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_republish done: rsmacl_build failed %d", e));
                return (e);
        }

        /* Lock segment */
        rsmseglock_acquire(seg);
        /*
         * a republish is in progress - REPUBLISH message is being
         * sent to the importers so wait for it to complete OR
         * wait till DR completes
         */
        while (((seg->s_state == RSM_STATE_EXPORT) &&
            (seg->s_flags & RSM_REPUBLISH_WAIT)) ||
            (seg->s_state == RSM_STATE_EXPORT_QUIESCED) ||
            (seg->s_state == RSM_STATE_EXPORT_QUIESCING)) {
                if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsm_republish done: cv_wait  INTERRUPTED"));
                        rsmseglock_release(seg);
                        rsmacl_free(new_acl, new_acl_len);
                        return (RSMERR_INTERRUPTED);
                }
        }

        /* recheck if state is valid */
        if (seg->s_state != RSM_STATE_EXPORT) {
                rsmseglock_release(seg);
                rsmacl_free(new_acl, new_acl_len);
                return (RSMERR_SEG_NOT_PUBLISHED);
        }

        key = seg->s_key;
        old_acl = seg->s_acl;
        old_acl_len = seg->s_acl_len;

        seg->s_acl = new_acl;
        seg->s_acl_len = new_acl_len;

        /*
         * This call will only be meaningful if and when the interconnect
         * layer makes use of the access list
         */
        adapter = seg->s_adapter;
        /*
         * create a acl list with hwaddr for RSMPI publish
         */
        e = rsmpiacl_create(new_acl, &rsmpi_new_acl, new_acl_len, adapter);

        if (e != RSM_SUCCESS) {
                seg->s_acl = old_acl;
                seg->s_acl_len = old_acl_len;
                rsmseglock_release(seg);
                rsmacl_free(new_acl, new_acl_len);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_republish done: rsmpiacl_create failed %d", e));
                return (e);
        }
        rsmpi_old_acl = seg->s_acl_in;
        seg->s_acl_in = rsmpi_new_acl;

        e = adapter->rsmpi_ops->rsm_republish(seg->s_handle.out,
            seg->s_acl_in, seg->s_acl_len,
            RSM_RESOURCE_DONTWAIT, NULL);

        if (e != RSM_SUCCESS) {
                seg->s_acl = old_acl;
                seg->s_acl_in = rsmpi_old_acl;
                seg->s_acl_len = old_acl_len;
                rsmseglock_release(seg);
                rsmacl_free(new_acl, new_acl_len);
                rsmpiacl_free(rsmpi_new_acl, new_acl_len);

                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_republish done: rsmpi republish failed %d\n", e));
                return (e);
        }

        /* create a tmp copy of the new acl */
        tmp_acl_len = new_acl_len;
        if (tmp_acl_len > 0) {
                tmp_acl = kmem_zalloc(new_acl_len*sizeof (*tmp_acl), KM_SLEEP);
                for (i = 0; i < tmp_acl_len; i++) {
                        tmp_acl[i].ae_node = new_acl[i].ae_node;
                        tmp_acl[i].ae_permission = new_acl[i].ae_permission;
                }
                /*
                 * The default permission of a node which was in the old
                 * ACL but not in the new ACL is 0 ie no access.
                 */
                permission = 0;
        } else {
                /*
                 * NULL acl means all importers can connect and
                 * default permission will be owner creation umask
                 */
                tmp_acl = NULL;
                permission = seg->s_mode;
        }

        /* make other republishers to wait for republish to complete */
        seg->s_flags |= RSM_REPUBLISH_WAIT;

        rsmseglock_release(seg);

        /* send the new perms to the importing nodes */
        rsm_send_republish(key, tmp_acl, tmp_acl_len, permission);

        rsmseglock_acquire(seg);
        seg->s_flags &= ~RSM_REPUBLISH_WAIT;
        /* wake up any one waiting for republish to complete */
        cv_broadcast(&seg->s_cv);
        rsmseglock_release(seg);

        rsmacl_free(tmp_acl, tmp_acl_len);
        rsmacl_free(old_acl, old_acl_len);
        rsmpiacl_free(rsmpi_old_acl, old_acl_len);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_republish done\n"));
        return (DDI_SUCCESS);
}

static int
rsm_unpublish(rsmseg_t *seg, int mode)
{
        rsmapi_access_entry_t   *acl;
        rsm_access_entry_t      *rsmpi_acl;
        int                     acl_len;
        int                     e;
        adapter_t *adapter;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_unpublish enter\n"));

        if (seg->s_pid != ddi_get_pid() &&
            ddi_get_pid() != 0) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_unpublish: Not creator\n"));
                return (RSMERR_NOT_CREATOR);
        }

        rsmseglock_acquire(seg);
        /*
         * wait for QUIESCING to complete here before rsmexport_rm
         * is called because the SUSPEND_COMPLETE mesg which changes
         * the seg state from EXPORT_QUIESCING to EXPORT_QUIESCED and
         * signals the cv_wait needs to find it in the hashtable.
         */
        while ((seg->s_state == RSM_STATE_EXPORT_QUIESCING) ||
            ((seg->s_state == RSM_STATE_EXPORT) && (seg->s_rdmacnt > 0))) {
                if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
                        rsmseglock_release(seg);
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm_unpublish done: cv_wait INTR qscing"
                            "getv/putv in progress"));
                        return (RSMERR_INTERRUPTED);
                }
        }

        /* verify segment state */
        if ((seg->s_state != RSM_STATE_EXPORT) &&
            (seg->s_state != RSM_STATE_EXPORT_QUIESCED)) {
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_unpublish done: bad state %x\n", seg->s_state));
                return (RSMERR_SEG_NOT_PUBLISHED);
        }

        rsmseglock_release(seg);

        rsmexport_rm(seg);

        rsm_send_importer_disconnects(seg->s_segid, my_nodeid);

        rsmseglock_acquire(seg);
        /*
         * wait for republish to complete
         */
        while ((seg->s_state == RSM_STATE_EXPORT) &&
            (seg->s_flags & RSM_REPUBLISH_WAIT)) {
                if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm_unpublish done: cv_wait INTR repubing"));
                        rsmseglock_release(seg);
                        return (RSMERR_INTERRUPTED);
                }
        }

        if ((seg->s_state != RSM_STATE_EXPORT) &&
            (seg->s_state != RSM_STATE_EXPORT_QUIESCED)) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_unpublish done: invalid state"));
                rsmseglock_release(seg);
                return (RSMERR_SEG_NOT_PUBLISHED);
        }

        /*
         * check for putv/get surrogate segment which was not published
         * to the driver.
         *
         * Be certain to see if there is an ACL first!  If this segment was
         * not published with an ACL, acl will be a null pointer.  Check
         * that before dereferencing it.
         */
        acl = seg->s_acl;
        if (acl != (rsmapi_access_entry_t *)NULL) {
                if (acl[0].ae_node == my_nodeid && acl[0].ae_permission == 0)
                        goto bypass;
        }

        /* The RSMPI unpublish/destroy has been done if seg is QUIESCED */
        if (seg->s_state == RSM_STATE_EXPORT_QUIESCED)
                goto bypass;

        adapter = seg->s_adapter;
        for (;;) {
                if (seg->s_state != RSM_STATE_EXPORT) {
                        rsmseglock_release(seg);
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm_unpublish done: bad state %x\n",
                            seg->s_state));
                        return (RSMERR_SEG_NOT_PUBLISHED);
                }

                /* unpublish from adapter */
                e = adapter->rsmpi_ops->rsm_unpublish(seg->s_handle.out);

                if (e == RSM_SUCCESS) {
                        break;
                }

                if (e == RSMERR_SEG_IN_USE && mode == 1) {
                        /*
                         * wait for unpublish to succeed, it's busy.
                         */
                        seg->s_flags |= RSM_EXPORT_WAIT;

                        /* wait for a max of 1 ms - this is an empirical */
                        /* value that was found by some minimal testing  */
                        /* can be fine tuned when we have better numbers */
                        /* A long term fix would be to send cv_signal    */
                        /* from the intr callback routine                */
                        /* currently nobody signals this wait            */
                        (void) cv_reltimedwait(&seg->s_cv, &seg->s_lock,
                            drv_usectohz(1000), TR_CLOCK_TICK);

                        DBG_PRINTF((category, RSM_ERR,
                            "rsm_unpublish: SEG_IN_USE\n"));

                        seg->s_flags &= ~RSM_EXPORT_WAIT;
                } else {
                        if (mode == 1) {
                                DBG_PRINTF((category, RSM_ERR,
                                    "rsm:rsmpi unpublish err %x\n", e));
                                seg->s_state = RSM_STATE_BIND;
                        }
                        rsmseglock_release(seg);
                        return (e);
                }
        }

        /* Free segment */
        e = adapter->rsmpi_ops->rsm_seg_destroy(seg->s_handle.out);

        if (e != RSM_SUCCESS) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_unpublish: rsmpi destroy key=%x failed %x\n",
                    seg->s_key, e));
        }

bypass:
        acl = seg->s_acl;
        rsmpi_acl = seg->s_acl_in;
        acl_len = seg->s_acl_len;

        seg->s_acl = NULL;
        seg->s_acl_in = NULL;
        seg->s_acl_len = 0;

        if (seg->s_state == RSM_STATE_EXPORT) {
                seg->s_state = RSM_STATE_BIND;
        } else if (seg->s_state == RSM_STATE_EXPORT_QUIESCED) {
                seg->s_state = RSM_STATE_BIND_QUIESCED;
                cv_broadcast(&seg->s_cv);
        }

        rsmseglock_release(seg);

        rsmacl_free(acl, acl_len);
        rsmpiacl_free(rsmpi_acl, acl_len);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_unpublish done\n"));

        return (DDI_SUCCESS);
}

/*
 * Called from rsm_unpublish to force an unload and disconnection of all
 * importers of the unpublished segment.
 *
 * First build the list of segments requiring a force disconnect, then
 * send a request for each.
 */
static void
rsm_send_importer_disconnects(rsm_memseg_id_t ex_segid,
    rsm_node_id_t ex_nodeid)
{
        rsmipc_request_t        request;
        importing_token_t       *prev_token, *token, *tmp_token, *tokp;
        importing_token_t       *force_disconnect_list = NULL;
        int                     index;

        DBG_PRINTF((RSM_KERNEL_AGENT | RSM_EXPORT, RSM_DEBUG_VERBOSE,
            "rsm_send_importer_disconnects enter\n"));

        index = rsmhash(ex_segid);

        mutex_enter(&importer_list.lock);

        prev_token = NULL;
        token = importer_list.bucket[index];

        while (token != NULL) {
                if (token->key == ex_segid) {
                        /*
                         * take it off the importer list and add it
                         * to the force disconnect list.
                         */
                        if (prev_token == NULL)
                                importer_list.bucket[index] = token->next;
                        else
                                prev_token->next = token->next;
                        tmp_token = token;
                        token = token->next;
                        if (force_disconnect_list == NULL) {
                                force_disconnect_list = tmp_token;
                                tmp_token->next = NULL;
                        } else {
                                tokp = force_disconnect_list;
                                /*
                                 * make sure that the tmp_token's node
                                 * is not already on the force disconnect
                                 * list.
                                 */
                                while (tokp != NULL) {
                                        if (tokp->importing_node ==
                                            tmp_token->importing_node) {
                                                break;
                                        }
                                        tokp = tokp->next;
                                }
                                if (tokp == NULL) {
                                        tmp_token->next =
                                            force_disconnect_list;
                                        force_disconnect_list = tmp_token;
                                } else {
                                        kmem_free((void *)tmp_token,
                                            sizeof (*token));
                                }
                        }

                } else {
                        prev_token = token;
                        token = token->next;
                }
        }
        mutex_exit(&importer_list.lock);

        token = force_disconnect_list;
        while (token != NULL) {
                if (token->importing_node == my_nodeid) {
                        rsm_force_unload(ex_nodeid, ex_segid,
                            DISCONNECT);
                } else {
                        request.rsmipc_hdr.rsmipc_type =
                            RSMIPC_MSG_DISCONNECT;
                        request.rsmipc_key = token->key;
                        for (;;) {
                                if (rsmipc_send(token->importing_node,
                                    &request,
                                    RSM_NO_REPLY) == RSM_SUCCESS) {
                                        break;
                                } else {
                                        delay(drv_usectohz(10000));
                                }
                        }
                }
                tmp_token = token;
                token = token->next;
                kmem_free((void *)tmp_token, sizeof (*token));
        }

        DBG_PRINTF((RSM_KERNEL_AGENT | RSM_EXPORT, RSM_DEBUG_VERBOSE,
            "rsm_send_importer_disconnects done\n"));
}

/*
 * This function is used as a callback for unlocking the pages locked
 * down by a process which then does a fork or an exec.
 * It marks the export segments corresponding to umem cookie given by
 * the *arg to be in a ZOMBIE state(by calling rsmseg_close to be
 * destroyed later when an rsm_close occurs).
 */
static void
rsm_export_force_destroy(ddi_umem_cookie_t *ck)
{
        rsmresource_blk_t *blk;
        rsmresource_t *p;
        rsmseg_t *eseg = NULL;
        int i, j;
        int found = 0;

        DBG_PRINTF((RSM_KERNEL_AGENT | RSM_EXPORT, RSM_DEBUG_VERBOSE,
            "rsm_export_force_destroy enter\n"));

        /*
         * Walk the resource list and locate the export segment (either
         * in the BIND or the EXPORT state) which corresponds to the
         * ddi_umem_cookie_t being freed up, and call rsmseg_close.
         * Change the state to ZOMBIE by calling rsmseg_close with the
         * force_flag argument (the second argument) set to 1. Also,
         * unpublish and unbind the segment, but don't free it. Free it
         * only on a rsm_close call for the segment.
         */
        rw_enter(&rsm_resource.rsmrc_lock, RW_READER);

        for (i = 0; i < rsm_resource.rsmrc_len; i++) {
                blk = rsm_resource.rsmrc_root[i];
                if (blk == NULL) {
                        continue;
                }

                for (j = 0; j < RSMRC_BLKSZ; j++) {
                        p = blk->rsmrcblk_blks[j];
                        if ((p != NULL) && (p != RSMRC_RESERVED) &&
                            (p->rsmrc_type == RSM_RESOURCE_EXPORT_SEGMENT)) {
                                eseg = (rsmseg_t *)p;
                                if (eseg->s_cookie != ck)
                                        continue; /* continue searching */
                                /*
                                 * Found the segment, set flag to indicate
                                 * force destroy processing is in progress
                                 */
                                rsmseglock_acquire(eseg);
                                eseg->s_flags |= RSM_FORCE_DESTROY_WAIT;
                                rsmseglock_release(eseg);
                                found = 1;
                                break;
                        }
                }

                if (found)
                        break;
        }

        rw_exit(&rsm_resource.rsmrc_lock);

        if (found) {
                ASSERT(eseg != NULL);
                /* call rsmseg_close with force flag set to 1 */
                rsmseg_close(eseg, 1);
                /*
                 * force destroy processing done, clear flag and signal any
                 * thread waiting in rsmseg_close.
                 */
                rsmseglock_acquire(eseg);
                eseg->s_flags &= ~RSM_FORCE_DESTROY_WAIT;
                cv_broadcast(&eseg->s_cv);
                rsmseglock_release(eseg);
        }

        DBG_PRINTF((RSM_KERNEL_AGENT | RSM_EXPORT, RSM_DEBUG_VERBOSE,
            "rsm_export_force_destroy done\n"));
}

/* ******************************* Remote Calls *********************** */
static void
rsm_intr_segconnect(rsm_node_id_t src, rsmipc_request_t *req)
{
        rsmipc_reply_t reply;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_intr_segconnect enter\n"));

        reply.rsmipc_status = (short)rsmsegacl_validate(req, src, &reply);

        reply.rsmipc_hdr.rsmipc_type = RSMIPC_MSG_REPLY;
        reply.rsmipc_hdr.rsmipc_cookie = req->rsmipc_hdr.rsmipc_cookie;

        (void) rsmipc_send(src, NULL, &reply);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_intr_segconnect done\n"));
}


/*
 * When an exported segment is unpublished the exporter sends an ipc
 * message (RSMIPC_MSG_DISCONNECT) to all importers.  The recv ipc dispatcher
 * calls this function.  The import list is scanned; segments which match the
 * exported segment id are unloaded and disconnected.
 *
 * Will also be called from rsm_rebind with disconnect_flag FALSE.
 *
 */
static void
rsm_force_unload(rsm_node_id_t src_nodeid, rsm_memseg_id_t ex_segid,
    boolean_t disconnect_flag)
{
        rsmresource_t   *p = NULL;
        rsmhash_table_t *rhash = &rsm_import_segs;
        uint_t          index;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_force_unload enter\n"));

        index = rsmhash(ex_segid);

        rw_enter(&rhash->rsmhash_rw, RW_READER);

        p = rsmhash_getbkt(rhash, index);

        for (; p; p = p->rsmrc_next) {
                rsmseg_t *seg = (rsmseg_t *)p;
                if ((seg->s_segid == ex_segid) && (seg->s_node == src_nodeid)) {
                        /*
                         * In order to make rsmseg_unload and rsm_force_unload
                         * thread safe, acquire the segment lock here.
                         * rsmseg_unload is responsible for releasing the lock.
                         * rsmseg_unload releases the lock just before a call
                         * to rsmipc_send or in case of an early exit which
                         * occurs if the segment was in the state
                         * RSM_STATE_CONNECTING or RSM_STATE_NEW.
                         */
                        rsmseglock_acquire(seg);
                        if (disconnect_flag)
                                seg->s_flags |= RSM_FORCE_DISCONNECT;
                        rsmseg_unload(seg);
                }
        }
        rw_exit(&rhash->rsmhash_rw);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_force_unload done\n"));
}

static void
rsm_intr_reply(rsmipc_msghdr_t *msg)
{
        /*
         * Find slot for cookie in reply.
         * Match sequence with sequence in cookie
         * If no match; return
         * Try to grap lock of slot, if locked return
         * copy data into reply slot area
         * signal waiter
         */
        rsmipc_slot_t   *slot;
        rsmipc_cookie_t *cookie;
        void *data = (void *) msg;
        size_t size = sizeof (rsmipc_reply_t);
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_intr_reply enter\n"));

        cookie = &msg->rsmipc_cookie;
        if (cookie->ic.index >= RSMIPC_SZ) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm: rsm_intr_reply bad cookie %d\n", cookie->ic.index));
                return;
        }

        ASSERT(cookie->ic.index < RSMIPC_SZ);
        slot = &rsm_ipc.slots[cookie->ic.index];
        mutex_enter(&slot->rsmipc_lock);
        if (slot->rsmipc_cookie.value == cookie->value) {
                /* found a match */
                if (RSMIPC_GET(slot, RSMIPC_PENDING)) {
                        bcopy(data, slot->rsmipc_data, size);
                        RSMIPC_CLEAR(slot, RSMIPC_PENDING);
                        cv_signal(&slot->rsmipc_cv);
                }
        } else {
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm: rsm_intr_reply mismatched reply %d\n",
                    cookie->ic.index));
        }
        mutex_exit(&slot->rsmipc_lock);
        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_intr_reply done\n"));
}

/*
 * This function gets dispatched on the worker thread when we receive
 * the SQREADY message. This function sends the SQREADY_ACK message.
 */
static void
rsm_sqready_ack_deferred(void *arg)
{
        path_t  *path = (path_t *)arg;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_sqready_ack_deferred enter\n"));

        mutex_enter(&path->mutex);

        /*
         * If path is not active no point in sending the ACK
         * because the whole SQREADY protocol will again start
         * when the path becomes active.
         */
        if (path->state != RSMKA_PATH_ACTIVE) {
                /*
                 * decrement the path refcnt incremented in rsm_proc_sqready
                 */
                PATH_RELE_NOLOCK(path);
                mutex_exit(&path->mutex);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_sqready_ack_deferred done:!ACTIVE\n"));
                return;
        }

        /* send an SQREADY_ACK message */
        (void) rsmipc_send_controlmsg(path, RSMIPC_MSG_SQREADY_ACK);

        /* initialize credits to the max level */
        path->sendq_token.msgbuf_avail = RSMIPC_MAX_MESSAGES;

        /* wake up any send that is waiting for credits */
        cv_broadcast(&path->sendq_token.sendq_cv);

        /*
         * decrement the path refcnt since we incremented it in
         * rsm_proc_sqready
         */
        PATH_RELE_NOLOCK(path);

        mutex_exit(&path->mutex);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_sqready_ack_deferred done\n"));
}

/*
 * Process the SQREADY message
 */
static void
rsm_proc_sqready(rsmipc_controlmsg_t *msg, rsm_addr_t src_hwaddr,
    rsm_intr_hand_arg_t arg)
{
        rsmipc_msghdr_t         *msghdr = (rsmipc_msghdr_t *)msg;
        srv_handler_arg_t       *hdlr_argp = (srv_handler_arg_t *)arg;
        path_t                  *path;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_proc_sqready enter\n"));

        /* look up the path - incr the path refcnt */
        path = rsm_find_path(hdlr_argp->adapter_name,
            hdlr_argp->adapter_instance, src_hwaddr);

        /*
         * No path exists or path is not active - drop the message
         */
        if (path == NULL) {
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_proc_sqready done: msg dropped no path\n"));
                return;
        }

        mutex_exit(&path->mutex);

        /* drain any tasks from the previous incarnation */
        taskq_wait(path->recv_taskq);

        mutex_enter(&path->mutex);
        /*
         * If we'd sent an SQREADY message and were waiting for SQREADY_ACK
         * in the meanwhile we received an SQREADY message, blindly reset
         * the WAIT_FOR_SQACK flag because we'll just send SQREADY_ACK
         * and forget about the SQREADY that we sent.
         */
        path->flags &= ~RSMKA_WAIT_FOR_SQACK;

        if (path->state != RSMKA_PATH_ACTIVE) {
                /* decr refcnt and drop the mutex */
                PATH_RELE_NOLOCK(path);
                mutex_exit(&path->mutex);
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_proc_sqready done: msg dropped path !ACTIVE\n"));
                return;
        }

        DBG_PRINTF((category, RSM_DEBUG, "rsm_proc_sqready:path=%lx "
            " src=%lx:%llx\n", path, msghdr->rsmipc_src, src_hwaddr));

        /*
         * The sender's local incarnation number is our remote incarnation
         * number save it in the path data structure
         */
        path->remote_incn = msg->rsmipc_local_incn;
        path->sendq_token.msgbuf_avail = 0;
        path->procmsg_cnt = 0;

        /*
         * path is active - dispatch task to send SQREADY_ACK - remember
         * RSMPI calls can't be done in interrupt context
         *
         * We can use the recv_taskq to send because the remote endpoint
         * cannot start sending messages till it receives SQREADY_ACK hence
         * at this point there are no tasks on recv_taskq.
         *
         * The path refcnt will be decremented in rsm_sqready_ack_deferred.
         */
        (void) taskq_dispatch(path->recv_taskq,
            rsm_sqready_ack_deferred, path, KM_NOSLEEP);

        mutex_exit(&path->mutex);


        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_proc_sqready done\n"));
}

/*
 * Process the SQREADY_ACK message
 */
static void
rsm_proc_sqready_ack(rsmipc_controlmsg_t *msg, rsm_addr_t src_hwaddr,
    rsm_intr_hand_arg_t arg)
{
        rsmipc_msghdr_t         *msghdr = (rsmipc_msghdr_t *)msg;
        srv_handler_arg_t       *hdlr_argp = (srv_handler_arg_t *)arg;
        path_t                  *path;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_proc_sqready_ack enter\n"));

        /* look up the path - incr the path refcnt */
        path = rsm_find_path(hdlr_argp->adapter_name,
            hdlr_argp->adapter_instance, src_hwaddr);

        /*
         * drop the message if - no path exists or path is not active
         * or if its not waiting for SQREADY_ACK message
         */
        if (path == NULL) {
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_proc_sqready_ack done: msg dropped no path\n"));
                return;
        }

        if ((path->state != RSMKA_PATH_ACTIVE) ||
            !(path->flags & RSMKA_WAIT_FOR_SQACK)) {
                /* decrement the refcnt */
                PATH_RELE_NOLOCK(path);
                mutex_exit(&path->mutex);
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_proc_sqready_ack done: msg dropped\n"));
                return;
        }

        /*
         * Check if this message is in response to the last RSMIPC_MSG_SQREADY
         * sent, if not drop it.
         */
        if (path->local_incn != msghdr->rsmipc_incn) {
                /* decrement the refcnt */
                PATH_RELE_NOLOCK(path);
                mutex_exit(&path->mutex);
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_proc_sqready_ack done: msg old incn %lld\n",
                    msghdr->rsmipc_incn));
                return;
        }

        DBG_PRINTF((category, RSM_DEBUG, "rsm_proc_sqready_ack:path=%lx "
            " src=%lx:%llx\n", path, msghdr->rsmipc_src, src_hwaddr));

        /*
         * clear the WAIT_FOR_SQACK flag since we have recvd the ack
         */
        path->flags &= ~RSMKA_WAIT_FOR_SQACK;

        /* save the remote sendq incn number */
        path->remote_incn = msg->rsmipc_local_incn;

        /* initialize credits to the max level */
        path->sendq_token.msgbuf_avail = RSMIPC_MAX_MESSAGES;

        /* wake up any send that is waiting for credits */
        cv_broadcast(&path->sendq_token.sendq_cv);

        /* decrement the refcnt */
        PATH_RELE_NOLOCK(path);

        mutex_exit(&path->mutex);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_proc_sqready_ack done\n"));
}

/*
 * process the RSMIPC_MSG_CREDIT message
 */
static void
rsm_add_credits(rsmipc_controlmsg_t *msg, rsm_addr_t src_hwaddr,
    rsm_intr_hand_arg_t arg)
{
        rsmipc_msghdr_t         *msghdr = (rsmipc_msghdr_t *)msg;
        srv_handler_arg_t       *hdlr_argp = (srv_handler_arg_t *)arg;
        path_t                  *path;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL |
            RSM_INTR_CALLBACK | RSM_FLOWCONTROL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_add_credits enter\n"));

        /* look up the path - incr the path refcnt */
        path = rsm_find_path(hdlr_argp->adapter_name,
            hdlr_argp->adapter_instance, src_hwaddr);

        if (path == NULL) {
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_add_credits enter: path not found\n"));
                return;
        }

        /* the path is not active - discard credits */
        if (path->state != RSMKA_PATH_ACTIVE) {
                PATH_RELE_NOLOCK(path);
                mutex_exit(&path->mutex);
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_add_credits enter:path=%lx !ACTIVE\n", path));
                return;
        }

        /*
         * Check if these credits are for current incarnation of the path.
         */
        if (path->local_incn != msghdr->rsmipc_incn) {
                /* decrement the refcnt */
                PATH_RELE_NOLOCK(path);
                mutex_exit(&path->mutex);
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_add_credits enter: old incn %lld\n",
                    msghdr->rsmipc_incn));
                return;
        }

        DBG_PRINTF((category, RSM_DEBUG,
            "rsm_add_credits:path=%lx new-creds=%d "
            "curr credits=%d src=%lx:%llx\n", path, msg->rsmipc_credits,
            path->sendq_token.msgbuf_avail, msghdr->rsmipc_src,
            src_hwaddr));


        /* add credits to the path's sendq */
        path->sendq_token.msgbuf_avail += msg->rsmipc_credits;

        ASSERT(path->sendq_token.msgbuf_avail <= RSMIPC_MAX_MESSAGES);

        /* wake up any send that is waiting for credits */
        cv_broadcast(&path->sendq_token.sendq_cv);

        /* decrement the refcnt */
        PATH_RELE_NOLOCK(path);

        mutex_exit(&path->mutex);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_add_credits done\n"));
}

static void
rsm_intr_event(rsmipc_request_t *msg)
{
        rsmseg_t        *seg;
        rsmresource_t   *p;
        rsm_node_id_t   src_node;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_intr_event enter\n"));

        src_node = msg->rsmipc_hdr.rsmipc_src;

        if ((seg = msg->rsmipc_segment_cookie) != NULL) {
                /* This is for an import segment */
                uint_t hashval = rsmhash(msg->rsmipc_key);

                rw_enter(&rsm_import_segs.rsmhash_rw, RW_READER);

                p = (rsmresource_t *)rsmhash_getbkt(&rsm_import_segs, hashval);

                for (; p; p = p->rsmrc_next) {
                        if ((p->rsmrc_key == msg->rsmipc_key) &&
                            (p->rsmrc_node == src_node)) {
                                seg = (rsmseg_t *)p;
                                rsmseglock_acquire(seg);

                                atomic_inc_32(&seg->s_pollevent);

                                if (seg->s_pollflag & RSM_SEGMENT_POLL)
                                        pollwakeup(&seg->s_poll, POLLRDNORM);

                                rsmseglock_release(seg);
                        }
                }

                rw_exit(&rsm_import_segs.rsmhash_rw);
        } else {
                /* This is for an export segment */
                seg = rsmexport_lookup(msg->rsmipc_key);
                if (!seg) {
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsm_intr_event done: exp seg not found\n"));
                        return;
                }

                ASSERT(rsmseglock_held(seg));

                atomic_inc_32(&seg->s_pollevent);

                /*
                 * We must hold the segment lock here, or else the segment
                 * can be freed while pollwakeup is using it. This implies
                 * that we MUST NOT grab the segment lock during rsm_chpoll,
                 * as outlined in the chpoll(9E) man page.
                 */
                if (seg->s_pollflag & RSM_SEGMENT_POLL)
                        pollwakeup(&seg->s_poll, POLLRDNORM);

                rsmseglock_release(seg);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_intr_event done\n"));
}

/*
 * The exporter did a republish and changed the ACL - this change is only
 * visible to new importers.
 */
static void
importer_update(rsm_node_id_t src_node, rsm_memseg_id_t key,
    rsm_permission_t perm)
{

        rsmresource_t   *p;
        rsmseg_t        *seg;
        uint_t          hashval = rsmhash(key);
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "importer_update enter\n"));

        rw_enter(&rsm_import_segs.rsmhash_rw, RW_READER);

        p = (rsmresource_t *)rsmhash_getbkt(&rsm_import_segs, hashval);

        for (; p; p = p->rsmrc_next) {
                /*
                 * find the importer and update the permission in the shared
                 * data structure. Any new importers will use the new perms
                 */
                if ((p->rsmrc_key == key) && (p->rsmrc_node == src_node)) {
                        seg = (rsmseg_t *)p;

                        rsmseglock_acquire(seg);
                        rsmsharelock_acquire(seg);
                        seg->s_share->rsmsi_mode = perm;
                        rsmsharelock_release(seg);
                        rsmseglock_release(seg);

                        break;
                }
        }

        rw_exit(&rsm_import_segs.rsmhash_rw);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "importer_update done\n"));
}

void
rsm_suspend_complete(rsm_node_id_t src_node, int flag)
{
        int             done = 1; /* indicate all SUSPENDS have been acked */
        list_element_t  *elem;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_suspend_complete enter\n"));

        mutex_enter(&rsm_suspend_list.list_lock);

        if (rsm_suspend_list.list_head == NULL) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_suspend_complete done: suspend_list is empty\n"));
                mutex_exit(&rsm_suspend_list.list_lock);
                return;
        }

        elem = rsm_suspend_list.list_head;
        while (elem != NULL) {
                if (elem->nodeid == src_node) {
                        /* clear the pending flag for the node */
                        elem->flags &= ~RSM_SUSPEND_ACKPENDING;
                        elem->flags |= flag;
                }

                if (done && (elem->flags & RSM_SUSPEND_ACKPENDING))
                        done = 0; /* still some nodes have not yet ACKED */

                elem = elem->next;
        }

        mutex_exit(&rsm_suspend_list.list_lock);

        if (!done) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_suspend_complete done: acks pending\n"));
                return;
        }
        /*
         * Now that we are done with suspending all the remote importers
         * time to quiesce the local exporters
         */
        exporter_quiesce();

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_suspend_complete done\n"));
}

static void
exporter_quiesce()
{
        int             i, e;
        rsmresource_t   *current;
        rsmseg_t        *seg;
        adapter_t       *adapter;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "exporter_quiesce enter\n"));
        /*
         * The importers send a SUSPEND_COMPLETE to the exporter node
         *      Unpublish, unbind the export segment and
         *      move the segments to the EXPORT_QUIESCED state
         */

        rw_enter(&rsm_export_segs.rsmhash_rw, RW_READER);

        for (i = 0; i < rsm_hash_size; i++) {
                current = rsm_export_segs.bucket[i];
                while (current != NULL) {
                        seg = (rsmseg_t *)current;
                        rsmseglock_acquire(seg);
                        if (current->rsmrc_state ==
                            RSM_STATE_EXPORT_QUIESCING) {
                                adapter = seg->s_adapter;
                                /*
                                 * some local memory handles are not published
                                 * check if it was published
                                 */
                                if ((seg->s_acl == NULL) ||
                                    (seg->s_acl[0].ae_node != my_nodeid) ||
                                    (seg->s_acl[0].ae_permission != 0)) {

                                        e = adapter->rsmpi_ops->rsm_unpublish(
                                            seg->s_handle.out);
                                        DBG_PRINTF((category, RSM_DEBUG,
                                            "exporter_quiesce:unpub %d\n", e));

                                        e = adapter->rsmpi_ops->rsm_seg_destroy(
                                            seg->s_handle.out);

                                        DBG_PRINTF((category, RSM_DEBUG,
                                            "exporter_quiesce:destroy %d\n",
                                            e));
                                }

                                (void) rsm_unbind_pages(seg);
                                seg->s_state = RSM_STATE_EXPORT_QUIESCED;
                                cv_broadcast(&seg->s_cv);
                        }
                        rsmseglock_release(seg);
                        current = current->rsmrc_next;
                }
        }
        rw_exit(&rsm_export_segs.rsmhash_rw);

        /*
         * All the local segments we are done with the pre-del processing
         * - time to move to PREDEL_COMPLETED.
         */

        mutex_enter(&rsm_drv_data.drv_lock);

        ASSERT(rsm_drv_data.drv_state == RSM_DRV_PREDEL_STARTED);

        rsm_drv_data.drv_state = RSM_DRV_PREDEL_COMPLETED;

        cv_broadcast(&rsm_drv_data.drv_cv);

        mutex_exit(&rsm_drv_data.drv_lock);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "exporter_quiesce done\n"));
}

static void
importer_suspend(rsm_node_id_t src_node)
{
        int             i;
        int             susp_flg; /* true means already suspended */
        int             num_importers;
        rsmresource_t   *p = NULL, *curp;
        rsmhash_table_t *rhash = &rsm_import_segs;
        rsmseg_t        *seg;
        rsmipc_request_t request;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "importer_suspend enter\n"));

        rw_enter(&rhash->rsmhash_rw, RW_READER);
        for (i = 0; i < rsm_hash_size; i++) {
                p = rhash->bucket[i];

                /*
                 * Suspend all importers with same <node, key> pair.
                 * After the last one of the shared importers has been
                 * suspended - suspend the shared mappings/connection.
                 */
                for (; p; p = p->rsmrc_next) {
                        rsmseg_t *first = (rsmseg_t *)p;
                        if ((first->s_node != src_node) ||
                            (first->s_state == RSM_STATE_DISCONNECT))
                                continue; /* go to next entry */
                        /*
                         * search the rest of the bucket for
                         * other siblings (imprtrs with the same key)
                         * of "first" and suspend them.
                         * All importers with same key fall in
                         * the same bucket.
                         */
                        num_importers = 0;
                        for (curp = p; curp; curp = curp->rsmrc_next) {
                                seg = (rsmseg_t *)curp;

                                rsmseglock_acquire(seg);

                                if ((seg->s_node != first->s_node) ||
                                    (seg->s_key != first->s_key) ||
                                    (seg->s_state == RSM_STATE_DISCONNECT)) {
                                        /*
                                         * either not a peer segment or its a
                                         * disconnected segment - skip it
                                         */
                                        rsmseglock_release(seg);
                                        continue;
                                }

                                rsmseg_suspend(seg, &susp_flg);

                                if (susp_flg) { /* seg already suspended */
                                        rsmseglock_release(seg);
                                        break; /* the inner for loop */
                                }

                                num_importers++;
                                rsmsharelock_acquire(seg);
                                /*
                                 * we've processed all importers that are
                                 * siblings of "first"
                                 */
                                if (num_importers ==
                                    seg->s_share->rsmsi_refcnt) {
                                        rsmsharelock_release(seg);
                                        rsmseglock_release(seg);
                                        break;
                                }
                                rsmsharelock_release(seg);
                                rsmseglock_release(seg);
                        }

                        /*
                         * All the importers with the same key and
                         * nodeid as "first" have been suspended.
                         * Now suspend the shared connect/mapping.
                         * This is done only once.
                         */
                        if (!susp_flg) {
                                rsmsegshare_suspend(seg);
                        }
                }
        }

        rw_exit(&rhash->rsmhash_rw);

        /* send an ACK for SUSPEND message */
        request.rsmipc_hdr.rsmipc_type = RSMIPC_MSG_SUSPEND_DONE;
        (void) rsmipc_send(src_node, &request, RSM_NO_REPLY);


        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "importer_suspend done\n"));

}

static void
rsmseg_suspend(rsmseg_t *seg, int *susp_flg)
{
        int             recheck_state;
        rsmcookie_t     *hdl;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmseg_suspend enter: key=%u\n", seg->s_key));

        *susp_flg = 0;

        ASSERT(rsmseglock_held(seg));
        /* wait if putv/getv is in progress */
        while (seg->s_rdmacnt > 0)
                cv_wait(&seg->s_cv, &seg->s_lock);

        do {
                recheck_state = 0;

                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmseg_suspend:segment %x state=%d\n",
                    seg->s_key, seg->s_state));

                switch (seg->s_state) {
                case RSM_STATE_NEW:
                        /* not a valid state */
                        break;
                case RSM_STATE_CONNECTING:
                        seg->s_state = RSM_STATE_ABORT_CONNECT;
                        break;
                case RSM_STATE_ABORT_CONNECT:
                        break;
                case RSM_STATE_CONNECT:
                        seg->s_handle.in = NULL;
                        seg->s_state = RSM_STATE_CONN_QUIESCE;
                        break;
                case RSM_STATE_MAPPING:
                        /* wait until segment leaves the mapping state */
                        while (seg->s_state == RSM_STATE_MAPPING)
                                cv_wait(&seg->s_cv, &seg->s_lock);
                        recheck_state = 1;
                        break;
                case RSM_STATE_ACTIVE:
                        /* unload the mappings */
                        if (seg->s_ckl != NULL) {
                                hdl = seg->s_ckl;
                                for (; hdl != NULL; hdl = hdl->c_next) {
                                        (void) devmap_unload(hdl->c_dhp,
                                            hdl->c_off, hdl->c_len);
                                }
                        }
                        seg->s_mapinfo = NULL;
                        seg->s_state = RSM_STATE_MAP_QUIESCE;
                        break;
                case RSM_STATE_CONN_QUIESCE:
                        /* FALLTHRU */
                case RSM_STATE_MAP_QUIESCE:
                        /* rsmseg_suspend already done for seg */
                        *susp_flg = 1;
                        break;
                case RSM_STATE_DISCONNECT:
                        break;
                default:
                        ASSERT(0); /* invalid state */
                }
        } while (recheck_state);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmseg_suspend done\n"));
}

static void
rsmsegshare_suspend(rsmseg_t *seg)
{
        int                     e;
        adapter_t               *adapter;
        rsm_import_share_t      *sharedp;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmsegshare_suspend enter\n"));

        rsmseglock_acquire(seg);
        rsmsharelock_acquire(seg);

        sharedp = seg->s_share;
        adapter = seg->s_adapter;
        switch (sharedp->rsmsi_state) {
        case RSMSI_STATE_NEW:
                break;
        case RSMSI_STATE_CONNECTING:
                sharedp->rsmsi_state = RSMSI_STATE_ABORT_CONNECT;
                break;
        case RSMSI_STATE_ABORT_CONNECT:
                break;
        case RSMSI_STATE_CONNECTED:
                /* do the rsmpi disconnect */
                if (sharedp->rsmsi_node != my_nodeid) {
                        e = adapter->rsmpi_ops->
                            rsm_disconnect(sharedp->rsmsi_handle);

                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsm:rsmpi disconnect seg=%x:err=%d\n",
                            sharedp->rsmsi_segid, e));
                }

                sharedp->rsmsi_handle = NULL;

                sharedp->rsmsi_state = RSMSI_STATE_CONN_QUIESCE;
                break;
        case RSMSI_STATE_CONN_QUIESCE:
                break;
        case RSMSI_STATE_MAPPED:
                /* do the rsmpi unmap and disconnect */
                if (sharedp->rsmsi_node != my_nodeid) {
                        e = adapter->rsmpi_ops->rsm_unmap(seg->s_handle.in);

                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsmshare_suspend: rsmpi unmap %d\n", e));

                        e = adapter->rsmpi_ops->
                            rsm_disconnect(sharedp->rsmsi_handle);
                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsm:rsmpi disconnect seg=%x:err=%d\n",
                            sharedp->rsmsi_segid, e));
                }

                sharedp->rsmsi_handle = NULL;

                sharedp->rsmsi_state = RSMSI_STATE_MAP_QUIESCE;
                break;
        case RSMSI_STATE_MAP_QUIESCE:
                break;
        case RSMSI_STATE_DISCONNECTED:
                break;
        default:
                ASSERT(0); /* invalid state */
        }

        rsmsharelock_release(seg);
        rsmseglock_release(seg);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmsegshare_suspend done\n"));
}

/*
 * This should get called on receiving a RESUME message or from
 * the pathmanger if the node undergoing DR dies.
 */
static void
importer_resume(rsm_node_id_t src_node)
{
        int             i;
        rsmresource_t   *p = NULL;
        rsmhash_table_t *rhash = &rsm_import_segs;
        void            *cookie;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "importer_resume enter\n"));

        rw_enter(&rhash->rsmhash_rw, RW_READER);

        for (i = 0; i < rsm_hash_size; i++) {
                p = rhash->bucket[i];

                for (; p; p = p->rsmrc_next) {
                        rsmseg_t *seg = (rsmseg_t *)p;

                        rsmseglock_acquire(seg);

                        /* process only importers of node undergoing DR */
                        if (seg->s_node != src_node) {
                                rsmseglock_release(seg);
                                continue;
                        }

                        if (rsmseg_resume(seg, &cookie) != RSM_SUCCESS) {
                                rsmipc_request_t        request;
                                /*
                                 * rsmpi map/connect failed
                                 * inform the exporter so that it can
                                 * remove the importer.
                                 */
                                request.rsmipc_hdr.rsmipc_type =
                                    RSMIPC_MSG_NOTIMPORTING;
                                request.rsmipc_key = seg->s_segid;
                                request.rsmipc_segment_cookie = cookie;
                                rsmseglock_release(seg);
                                (void) rsmipc_send(seg->s_node, &request,
                                    RSM_NO_REPLY);
                        } else {
                                rsmseglock_release(seg);
                        }
                }
        }

        rw_exit(&rhash->rsmhash_rw);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "importer_resume done\n"));
}

static int
rsmseg_resume(rsmseg_t *seg, void **cookie)
{
        int                     e;
        int                     retc;
        off_t                   dev_offset;
        size_t                  maplen;
        uint_t                  maxprot;
        rsm_mapinfo_t           *p;
        rsmcookie_t             *hdl;
        rsm_import_share_t      *sharedp;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmseg_resume enter: key=%u\n", seg->s_key));

        *cookie = NULL;

        ASSERT(rsmseglock_held(seg));

        if ((seg->s_state != RSM_STATE_CONN_QUIESCE) &&
            (seg->s_state != RSM_STATE_MAP_QUIESCE)) {
                return (RSM_SUCCESS);
        }

        sharedp = seg->s_share;

        rsmsharelock_acquire(seg);

        /* resume the shared connection and/or mapping */
        retc = rsmsegshare_resume(seg);

        if (seg->s_state == RSM_STATE_CONN_QUIESCE) {
                /* shared state can either be connected or mapped */
                if ((sharedp->rsmsi_state == RSMSI_STATE_CONNECTED) ||
                    (sharedp->rsmsi_state == RSMSI_STATE_MAPPED)) {
                        ASSERT(retc == RSM_SUCCESS);
                        seg->s_handle.in = sharedp->rsmsi_handle;
                        rsmsharelock_release(seg);
                        seg->s_state = RSM_STATE_CONNECT;

                } else { /* error in rsmpi connect during resume */
                        seg->s_handle.in = NULL;
                        seg->s_state = RSM_STATE_DISCONNECT;

                        sharedp->rsmsi_refcnt--;
                        cookie = (void *)sharedp->rsmsi_cookie;

                        if (sharedp->rsmsi_refcnt == 0) {
                                ASSERT(sharedp->rsmsi_mapcnt == 0);
                                rsmsharelock_release(seg);

                                /* clean up the shared data structure */
                                mutex_destroy(&sharedp->rsmsi_lock);
                                cv_destroy(&sharedp->rsmsi_cv);
                                kmem_free((void *)(sharedp),
                                    sizeof (rsm_import_share_t));

                        } else {
                                rsmsharelock_release(seg);
                        }
                        /*
                         * The following needs to be done after any
                         * rsmsharelock calls which use seg->s_share.
                         */
                        seg->s_share = NULL;
                }

                /* signal any waiting segment */
                cv_broadcast(&seg->s_cv);

                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmseg_resume done:state=%d\n", seg->s_state));
                return (retc);
        }

        ASSERT(seg->s_state == RSM_STATE_MAP_QUIESCE);

        /* Setup protections for remap */
        maxprot = PROT_USER;
        if (seg->s_mode & RSM_PERM_READ) {
                maxprot |= PROT_READ;
        }
        if (seg->s_mode & RSM_PERM_WRITE) {
                maxprot |= PROT_WRITE;
        }

        if (sharedp->rsmsi_state != RSMSI_STATE_MAPPED) {
                /* error in rsmpi connect or map during resume */

                /* remap to trash page */
                ASSERT(seg->s_ckl != NULL);

                for (hdl = seg->s_ckl; hdl != NULL; hdl = hdl->c_next) {
                        e = devmap_umem_remap(hdl->c_dhp, rsm_dip,
                            remap_cookie, hdl->c_off, hdl->c_len,
                            maxprot, 0, NULL);

                        DBG_PRINTF((category, RSM_ERR,
                            "rsmseg_resume:remap=%d\n", e));
                }

                seg->s_handle.in = NULL;
                seg->s_state = RSM_STATE_DISCONNECT;

                sharedp->rsmsi_refcnt--;

                sharedp->rsmsi_mapcnt--;
                seg->s_mapinfo = NULL;

                if (sharedp->rsmsi_refcnt == 0) {
                        ASSERT(sharedp->rsmsi_mapcnt == 0);
                        rsmsharelock_release(seg);

                        /* clean up the shared data structure */
                        mutex_destroy(&sharedp->rsmsi_lock);
                        cv_destroy(&sharedp->rsmsi_cv);
                        kmem_free((void *)(sharedp),
                            sizeof (rsm_import_share_t));

                } else {
                        rsmsharelock_release(seg);
                }
                /*
                 * The following needs to be done after any
                 * rsmsharelock calls which use seg->s_share.
                 */
                seg->s_share = NULL;

                /* signal any waiting segment */
                cv_broadcast(&seg->s_cv);

                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmseg_resume done:seg=%x,err=%d\n",
                    seg->s_key, retc));
                return (retc);

        }

        seg->s_handle.in = sharedp->rsmsi_handle;

        if (seg->s_node == my_nodeid) { /* loopback */
                ASSERT(seg->s_mapinfo == NULL);

                for (hdl = seg->s_ckl; hdl != NULL; hdl = hdl->c_next) {
                        e = devmap_umem_remap(hdl->c_dhp,
                            rsm_dip, seg->s_cookie,
                            hdl->c_off, hdl->c_len,
                            maxprot, 0, NULL);

                        DBG_PRINTF((category, RSM_ERR,
                            "rsmseg_resume:remap=%d\n", e));
                }
        } else { /* remote exporter */
                /* remap to the new rsmpi maps */
                seg->s_mapinfo = sharedp->rsmsi_mapinfo;

                for (hdl = seg->s_ckl; hdl != NULL; hdl = hdl->c_next) {
                        p = rsm_get_mapinfo(seg, hdl->c_off, hdl->c_len,
                            &dev_offset, &maplen);
                        e = devmap_devmem_remap(hdl->c_dhp,
                            p->dip, p->dev_register, dev_offset,
                            maplen, maxprot, 0, NULL);

                        DBG_PRINTF((category, RSM_ERR,
                            "rsmseg_resume:remap=%d\n", e));
                }
        }

        rsmsharelock_release(seg);

        seg->s_state = RSM_STATE_ACTIVE;
        cv_broadcast(&seg->s_cv);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmseg_resume done\n"));

        return (retc);
}

static int
rsmsegshare_resume(rsmseg_t *seg)
{
        int                     e = RSM_SUCCESS;
        adapter_t               *adapter;
        rsm_import_share_t      *sharedp;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmsegshare_resume enter\n"));

        ASSERT(rsmseglock_held(seg));
        ASSERT(rsmsharelock_held(seg));

        sharedp = seg->s_share;

        /*
         * If we are not in a xxxx_QUIESCE state that means shared
         * connect/mapping processing has been already been done
         * so return success.
         */
        if ((sharedp->rsmsi_state != RSMSI_STATE_CONN_QUIESCE) &&
            (sharedp->rsmsi_state != RSMSI_STATE_MAP_QUIESCE)) {
                return (RSM_SUCCESS);
        }

        adapter = seg->s_adapter;

        if (sharedp->rsmsi_node != my_nodeid) {
                rsm_addr_t      hwaddr;
                hwaddr = get_remote_hwaddr(adapter, sharedp->rsmsi_node);

                e = adapter->rsmpi_ops->rsm_connect(
                    adapter->rsmpi_handle, hwaddr,
                    sharedp->rsmsi_segid, &sharedp->rsmsi_handle);

                DBG_PRINTF((category, RSM_DEBUG,
                    "rsmsegshare_resume:rsmpi connect seg=%x:err=%d\n",
                    sharedp->rsmsi_segid, e));

                if (e != RSM_SUCCESS) {
                        /* when do we send the NOT_IMPORTING message */
                        sharedp->rsmsi_handle = NULL;
                        sharedp->rsmsi_state = RSMSI_STATE_DISCONNECTED;
                        /* signal any waiting segment */
                        cv_broadcast(&sharedp->rsmsi_cv);
                        return (e);
                }
        }

        if (sharedp->rsmsi_state == RSMSI_STATE_CONN_QUIESCE) {
                sharedp->rsmsi_state = RSMSI_STATE_CONNECTED;
                /* signal any waiting segment */
                cv_broadcast(&sharedp->rsmsi_cv);
                return (e);
        }

        ASSERT(sharedp->rsmsi_state == RSMSI_STATE_MAP_QUIESCE);

        /* do the rsmpi map of the whole segment here */
        if (sharedp->rsmsi_node != my_nodeid) {
                size_t mapped_len;
                rsm_mapinfo_t *p;

                /*
                 * We need to do rsmpi maps with <off, lens> identical to
                 * the old mapinfo list because the segment mapping handles
                 * dhp and such need the fragmentation of rsmpi maps to be
                 * identical to what it was during the mmap of the segment
                 */
                p = sharedp->rsmsi_mapinfo;

                while (p != NULL) {
                        mapped_len = 0;

                        e = adapter->rsmpi_ops->rsm_map(
                            sharedp->rsmsi_handle, p->start_offset,
                            p->individual_len, &mapped_len,
                            &p->dip, &p->dev_register, &p->dev_offset,
                            NULL, NULL);

                        if (e != 0) {
                                DBG_PRINTF((category, RSM_ERR,
                                    "rsmsegshare_resume: rsmpi map err=%d\n",
                                    e));
                                break;
                        }

                        if (mapped_len != p->individual_len) {
                                DBG_PRINTF((category, RSM_ERR,
                                    "rsmsegshare_resume: rsmpi maplen"
                                    "< reqlen=%lx\n", mapped_len));
                                e = RSMERR_BAD_LENGTH;
                                break;
                        }

                        p = p->next;

                }


                if (e != RSM_SUCCESS) { /* rsmpi map failed */
                        int     err;
                        /* Check if this is the first rsm_map */
                        if (p != sharedp->rsmsi_mapinfo) {
                                /*
                                 * A single rsm_unmap undoes multiple rsm_maps.
                                 */
                                (void) seg->s_adapter->rsmpi_ops->
                                    rsm_unmap(sharedp->rsmsi_handle);
                        }

                        rsm_free_mapinfo(sharedp->rsmsi_mapinfo);
                        sharedp->rsmsi_mapinfo = NULL;

                        err = adapter->rsmpi_ops->
                            rsm_disconnect(sharedp->rsmsi_handle);

                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsmsegshare_resume:disconn seg=%x:err=%d\n",
                            sharedp->rsmsi_segid, err));

                        sharedp->rsmsi_handle = NULL;
                        sharedp->rsmsi_state = RSMSI_STATE_DISCONNECTED;

                        /* signal the waiting segments */
                        cv_broadcast(&sharedp->rsmsi_cv);
                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsmsegshare_resume done: rsmpi map err\n"));
                        return (e);
                }
        }

        sharedp->rsmsi_state = RSMSI_STATE_MAPPED;

        /* signal any waiting segment */
        cv_broadcast(&sharedp->rsmsi_cv);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmsegshare_resume done\n"));

        return (e);
}

/*
 * this is the routine that gets called by recv_taskq which is the
 * thread that processes messages that are flow-controlled.
 */
static void
rsm_intr_proc_deferred(void *arg)
{
        path_t                  *path = (path_t *)arg;
        rsmipc_request_t        *msg;
        rsmipc_msghdr_t         *msghdr;
        rsm_node_id_t           src_node;
        msgbuf_elem_t           *head;
        int                     e;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_intr_proc_deferred enter\n"));

        mutex_enter(&path->mutex);

        /* use the head of the msgbuf_queue */
        head = rsmka_gethead_msgbuf(path);

        mutex_exit(&path->mutex);

        msg = (rsmipc_request_t *)&(head->msg);
        msghdr = (rsmipc_msghdr_t *)msg;

        src_node = msghdr->rsmipc_src;

        /*
         * messages that need to send a reply should check the message version
         * before processing the message. And all messages that need to
         * send a reply should be processed here by the worker thread.
         */
        switch (msghdr->rsmipc_type) {
        case RSMIPC_MSG_SEGCONNECT:
                if (msghdr->rsmipc_version != RSM_VERSION) {
                        rsmipc_reply_t reply;
                        reply.rsmipc_status = RSMERR_BAD_DRIVER_VERSION;
                        reply.rsmipc_hdr.rsmipc_type = RSMIPC_MSG_REPLY;
                        reply.rsmipc_hdr.rsmipc_cookie = msghdr->rsmipc_cookie;
                        (void) rsmipc_send(msghdr->rsmipc_src, NULL, &reply);
                } else {
                        rsm_intr_segconnect(src_node, msg);
                }
                break;
        case RSMIPC_MSG_DISCONNECT:
                rsm_force_unload(src_node, msg->rsmipc_key, DISCONNECT);
                break;
        case RSMIPC_MSG_SUSPEND:
                importer_suspend(src_node);
                break;
        case RSMIPC_MSG_SUSPEND_DONE:
                rsm_suspend_complete(src_node, 0);
                break;
        case RSMIPC_MSG_RESUME:
                importer_resume(src_node);
                break;
        default:
                ASSERT(0);
        }

        mutex_enter(&path->mutex);

        rsmka_dequeue_msgbuf(path);

        /* incr procmsg_cnt can be at most RSMIPC_MAX_MESSAGES */
        if (path->procmsg_cnt < RSMIPC_MAX_MESSAGES)
                path->procmsg_cnt++;

        ASSERT(path->procmsg_cnt <= RSMIPC_MAX_MESSAGES);

        /* No need to send credits if path is going down */
        if ((path->state == RSMKA_PATH_ACTIVE) &&
            (path->procmsg_cnt >= RSMIPC_LOTSFREE_MSGBUFS)) {
                /*
                 * send credits and reset procmsg_cnt if success otherwise
                 * credits will be sent after processing the next message
                 */
                e = rsmipc_send_controlmsg(path, RSMIPC_MSG_CREDIT);
                if (e == 0)
                        path->procmsg_cnt = 0;
                else
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm_intr_proc_deferred:send credits err=%d\n", e));
        }

        /*
         * decrement the path refcnt since we incremented it in
         * rsm_intr_callback_dispatch
         */
        PATH_RELE_NOLOCK(path);

        mutex_exit(&path->mutex);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_intr_proc_deferred done\n"));
}

/*
 * Flow-controlled messages are enqueued and dispatched onto a taskq here
 */
static void
rsm_intr_callback_dispatch(void *data, rsm_addr_t src_hwaddr,
    rsm_intr_hand_arg_t arg)
{
        srv_handler_arg_t       *hdlr_argp = (srv_handler_arg_t *)arg;
        path_t                  *path;
        rsmipc_msghdr_t *msghdr = (rsmipc_msghdr_t *)data;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_intr_callback_dispatch enter\n"));
        ASSERT(data && hdlr_argp);

        /* look up the path - incr the path refcnt */
        path = rsm_find_path(hdlr_argp->adapter_name,
            hdlr_argp->adapter_instance, src_hwaddr);

        /* the path has been removed - drop this message */
        if (path == NULL) {
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_intr_callback_dispatch done: msg dropped\n"));
                return;
        }
        /* the path is not active - don't accept new messages */
        if (path->state != RSMKA_PATH_ACTIVE) {
                PATH_RELE_NOLOCK(path);
                mutex_exit(&path->mutex);
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_intr_callback_dispatch done: msg dropped"
                    " path=%lx !ACTIVE\n", path));
                return;
        }

        /*
         * Check if this message was sent to an older incarnation
         * of the path/sendq.
         */
        if (path->local_incn != msghdr->rsmipc_incn) {
                /* decrement the refcnt */
                PATH_RELE_NOLOCK(path);
                mutex_exit(&path->mutex);
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_intr_callback_dispatch done: old incn %lld\n",
                    msghdr->rsmipc_incn));
                return;
        }

        /* copy and enqueue msg on the path's msgbuf queue */
        rsmka_enqueue_msgbuf(path, data);

        /*
         * schedule task to process messages - ignore retval from
         * task_dispatch because we sender cannot send more than
         * what receiver can handle.
         */
        (void) taskq_dispatch(path->recv_taskq,
            rsm_intr_proc_deferred, path, KM_NOSLEEP);

        mutex_exit(&path->mutex);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_intr_callback_dispatch done\n"));
}

/*
 * This procedure is called from rsm_srv_func when a remote node creates a
 * a send queue.  This event is used as a hint that an  earlier failed
 * attempt to create a send queue to that remote node may now succeed and
 * should be retried.  Indication of an earlier failed attempt is provided
 * by the RSMKA_SQCREATE_PENDING flag.
 */
static void
rsm_sqcreateop_callback(rsm_addr_t src_hwaddr, rsm_intr_hand_arg_t arg)
{
        srv_handler_arg_t       *hdlr_argp = (srv_handler_arg_t *)arg;
        path_t                  *path;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_sqcreateop_callback enter\n"));

        /* look up the path - incr the path refcnt */
        path = rsm_find_path(hdlr_argp->adapter_name,
            hdlr_argp->adapter_instance, src_hwaddr);

        if (path == NULL) {
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_sqcreateop_callback done: no path\n"));
                return;
        }

        if ((path->state == RSMKA_PATH_UP) &&
            (path->flags & RSMKA_SQCREATE_PENDING)) {
                /*
                 * previous attempt to create sendq had failed, retry
                 * it and move to RSMKA_PATH_ACTIVE state if successful.
                 * the refcnt will be decremented in the do_deferred_work
                 */
                (void) rsmka_do_path_active(path, RSMKA_NO_SLEEP);
        } else {
                /* decrement the refcnt */
                PATH_RELE_NOLOCK(path);
        }
        mutex_exit(&path->mutex);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_sqcreateop_callback done\n"));
}

static void
rsm_intr_callback(void *data, rsm_addr_t src_hwaddr, rsm_intr_hand_arg_t arg)
{
        rsmipc_msghdr_t *msghdr = (rsmipc_msghdr_t *)data;
        rsmipc_request_t *msg = (rsmipc_request_t *)data;
        rsmipc_controlmsg_t *ctrlmsg = (rsmipc_controlmsg_t *)data;
        rsm_node_id_t src_node;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_intr_callback enter:"
            "src=%d, type=%d\n", msghdr->rsmipc_src,
            msghdr->rsmipc_type));

        /*
         * Check for the version number in the msg header. If it is not
         * RSM_VERSION, drop the message. In the future, we need to manage
         * incompatible version numbers in some way
         */
        if (msghdr->rsmipc_version != RSM_VERSION) {
                DBG_PRINTF((category, RSM_ERR, "wrong KA version\n"));
                /*
                 * Drop requests that don't have a reply right here
                 * Request with reply will send a BAD_VERSION reply
                 * when they get processed by the worker thread.
                 */
                if (msghdr->rsmipc_type != RSMIPC_MSG_SEGCONNECT) {
                        return;
                }

        }

        src_node = msghdr->rsmipc_src;

        switch (msghdr->rsmipc_type) {
        case RSMIPC_MSG_SEGCONNECT:
        case RSMIPC_MSG_DISCONNECT:
        case RSMIPC_MSG_SUSPEND:
        case RSMIPC_MSG_SUSPEND_DONE:
        case RSMIPC_MSG_RESUME:
                /*
                 * These message types are handled by a worker thread using
                 * the flow-control algorithm.
                 * Any message processing that does one or more of the
                 * following should be handled in a worker thread.
                 *      - allocates resources and might sleep
                 *      - makes RSMPI calls down to the interconnect driver
                 *      this by defn include requests with reply.
                 *      - takes a long duration of time
                 */
                rsm_intr_callback_dispatch(data, src_hwaddr, arg);
                break;
        case RSMIPC_MSG_NOTIMPORTING:
                importer_list_rm(src_node, msg->rsmipc_key,
                    msg->rsmipc_segment_cookie);
                break;
        case RSMIPC_MSG_SQREADY:
                rsm_proc_sqready(data, src_hwaddr, arg);
                break;
        case RSMIPC_MSG_SQREADY_ACK:
                rsm_proc_sqready_ack(data, src_hwaddr, arg);
                break;
        case RSMIPC_MSG_CREDIT:
                rsm_add_credits(ctrlmsg, src_hwaddr, arg);
                break;
        case RSMIPC_MSG_REPLY:
                rsm_intr_reply(msghdr);
                break;
        case RSMIPC_MSG_BELL:
                rsm_intr_event(msg);
                break;
        case RSMIPC_MSG_IMPORTING:
                importer_list_add(src_node, msg->rsmipc_key,
                    msg->rsmipc_adapter_hwaddr,
                    msg->rsmipc_segment_cookie);
                break;
        case RSMIPC_MSG_REPUBLISH:
                importer_update(src_node, msg->rsmipc_key, msg->rsmipc_perm);
                break;
        default:
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_intr_callback: bad msg %lx type %d data %lx\n",
                    (size_t)msg, (int)(msghdr->rsmipc_type), (size_t)data));
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_intr_callback done\n"));

}

rsm_intr_hand_ret_t rsm_srv_func(rsm_controller_object_t *chd,
    rsm_intr_q_op_t opcode, rsm_addr_t src,
    void *data, size_t size, rsm_intr_hand_arg_t arg)
{
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_srv_func enter\n"));

        switch (opcode) {
        case RSM_INTR_Q_OP_CREATE:
                DBG_PRINTF((category, RSM_DEBUG, "rsm_srv_func:OP_CREATE\n"));
                rsm_sqcreateop_callback(src, arg);
                break;
        case RSM_INTR_Q_OP_DESTROY:
                DBG_PRINTF((category, RSM_DEBUG, "rsm_srv_func:OP_DESTROY\n"));
                break;
        case RSM_INTR_Q_OP_RECEIVE:
                rsm_intr_callback(data, src, arg);
                break;
        default:
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_srv_func: unknown opcode = %x\n", opcode));
        }

        chd = chd;
        size = size;

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_srv_func done\n"));

        return (RSM_INTR_HAND_CLAIMED);
}

/* *************************** IPC slots ************************* */
static rsmipc_slot_t *
rsmipc_alloc()
{
        int i;
        rsmipc_slot_t *slot;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmipc_alloc enter\n"));

        /* try to find a free slot, if not wait */
        mutex_enter(&rsm_ipc.lock);

        while (rsm_ipc.count == 0) {
                rsm_ipc.wanted = 1;
                cv_wait(&rsm_ipc.cv, &rsm_ipc.lock);
        }

        /* An empty slot is available, find it */
        slot = &rsm_ipc.slots[0];
        for (i = 0; i < RSMIPC_SZ; i++, slot++) {
                if (RSMIPC_GET(slot, RSMIPC_FREE)) {
                        RSMIPC_CLEAR(slot, RSMIPC_FREE);
                        break;
                }
        }

        ASSERT(i < RSMIPC_SZ);
        rsm_ipc.count--;        /* one less is available */
        rsm_ipc.sequence++; /* new sequence */

        slot->rsmipc_cookie.ic.sequence = (uint_t)rsm_ipc.sequence;
        slot->rsmipc_cookie.ic.index = (uint_t)i;

        mutex_exit(&rsm_ipc.lock);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmipc_alloc done\n"));

        return (slot);
}

static void
rsmipc_free(rsmipc_slot_t *slot)
{
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmipc_free enter\n"));

        ASSERT(MUTEX_HELD(&slot->rsmipc_lock));
        ASSERT(&rsm_ipc.slots[slot->rsmipc_cookie.ic.index] == slot);

        mutex_enter(&rsm_ipc.lock);

        RSMIPC_SET(slot, RSMIPC_FREE);

        slot->rsmipc_cookie.ic.sequence = 0;

        mutex_exit(&slot->rsmipc_lock);
        rsm_ipc.count++;
        ASSERT(rsm_ipc.count <= RSMIPC_SZ);
        if (rsm_ipc.wanted) {
                rsm_ipc.wanted = 0;
                cv_broadcast(&rsm_ipc.cv);
        }

        mutex_exit(&rsm_ipc.lock);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmipc_free done\n"));
}

static int
rsmipc_send(rsm_node_id_t dest, rsmipc_request_t *req, rsmipc_reply_t *reply)
{
        int             e = 0;
        int             credit_check = 0;
        int             retry_cnt = 0;
        int             min_retry_cnt = 10;
        rsm_send_t      is;
        rsmipc_slot_t   *rslot;
        adapter_t       *adapter;
        path_t          *path;
        sendq_token_t   *sendq_token;
        sendq_token_t   *used_sendq_token = NULL;
        rsm_send_q_handle_t     ipc_handle;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmipc_send enter:dest=%d",
            dest));

        /*
         * Check if this is a local case
         */
        if (dest == my_nodeid) {
                switch (req->rsmipc_hdr.rsmipc_type) {
                case RSMIPC_MSG_SEGCONNECT:
                        reply->rsmipc_status = (short)rsmsegacl_validate(
                            req, dest, reply);
                        break;
                case RSMIPC_MSG_BELL:
                        req->rsmipc_hdr.rsmipc_src = dest;
                        rsm_intr_event(req);
                        break;
                case RSMIPC_MSG_IMPORTING:
                        importer_list_add(dest, req->rsmipc_key,
                            req->rsmipc_adapter_hwaddr,
                            req->rsmipc_segment_cookie);
                        break;
                case RSMIPC_MSG_NOTIMPORTING:
                        importer_list_rm(dest, req->rsmipc_key,
                            req->rsmipc_segment_cookie);
                        break;
                case RSMIPC_MSG_REPUBLISH:
                        importer_update(dest, req->rsmipc_key,
                            req->rsmipc_perm);
                        break;
                case RSMIPC_MSG_SUSPEND:
                        importer_suspend(dest);
                        break;
                case RSMIPC_MSG_SUSPEND_DONE:
                        rsm_suspend_complete(dest, 0);
                        break;
                case RSMIPC_MSG_RESUME:
                        importer_resume(dest);
                        break;
                default:
                        ASSERT(0);
                }
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmipc_send done\n"));
                return (0);
        }

        if (dest >= MAX_NODES) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm: rsmipc_send bad node number %x\n", dest));
                return (RSMERR_REMOTE_NODE_UNREACHABLE);
        }

        /*
         * Oh boy! we are going remote.
         */

        /*
         * identify if we need to have credits to send this message
         * - only selected requests are flow controlled
         */
        if (req != NULL) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmipc_send:request type=%d\n",
                    req->rsmipc_hdr.rsmipc_type));

                switch (req->rsmipc_hdr.rsmipc_type) {
                case RSMIPC_MSG_SEGCONNECT:
                case RSMIPC_MSG_DISCONNECT:
                case RSMIPC_MSG_IMPORTING:
                case RSMIPC_MSG_SUSPEND:
                case RSMIPC_MSG_SUSPEND_DONE:
                case RSMIPC_MSG_RESUME:
                        credit_check = 1;
                        break;
                default:
                        credit_check = 0;
                }
        }

again:
        if (retry_cnt++ == min_retry_cnt) {
                /* backoff before further retries for 10ms */
                delay(drv_usectohz(10000));
                retry_cnt = 0; /* reset retry_cnt */
        }
        sendq_token = rsmka_get_sendq_token(dest, used_sendq_token);
        if (sendq_token == NULL) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm: rsmipc_send no device to reach node %d\n", dest));
                return (RSMERR_REMOTE_NODE_UNREACHABLE);
        }

        if ((sendq_token == used_sendq_token) &&
            ((e == RSMERR_CONN_ABORTED) || (e == RSMERR_TIMEOUT) ||
            (e == RSMERR_COMM_ERR_MAYBE_DELIVERED))) {
                rele_sendq_token(sendq_token);
                DBG_PRINTF((category, RSM_DEBUG, "rsmipc_send done=%d\n", e));
                return (RSMERR_CONN_ABORTED);
        } else
                used_sendq_token = sendq_token;

/* lint -save -e413 */
        path = SQ_TOKEN_TO_PATH(sendq_token);
        adapter = path->local_adapter;
/* lint -restore */
        ipc_handle = sendq_token->rsmpi_sendq_handle;

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmipc_send: path=%lx sendq_hdl=%lx\n", path, ipc_handle));

        if (reply == NULL) {
                /* Send request without ack */
                /*
                 * Set the rsmipc_version number in the msghdr for KA
                 * communication versioning
                 */
                req->rsmipc_hdr.rsmipc_version = RSM_VERSION;
                req->rsmipc_hdr.rsmipc_src = my_nodeid;
                /*
                 * remote endpoints incn should match the value in our
                 * path's remote_incn field. No need to grab any lock
                 * since we have refcnted the path in rsmka_get_sendq_token
                 */
                req->rsmipc_hdr.rsmipc_incn = path->remote_incn;

                is.is_data = (void *)req;
                is.is_size = sizeof (*req);
                is.is_flags = RSM_INTR_SEND_DELIVER | RSM_INTR_SEND_SLEEP;
                is.is_wait = 0;

                if (credit_check) {
                        mutex_enter(&path->mutex);
                        /*
                         * wait till we recv credits or path goes down. If path
                         * goes down rsm_send will fail and we handle the error
                         * then
                         */
                        while ((sendq_token->msgbuf_avail == 0) &&
                            (path->state == RSMKA_PATH_ACTIVE)) {
                                e = cv_wait_sig(&sendq_token->sendq_cv,
                                    &path->mutex);
                                if (e == 0) {
                                        mutex_exit(&path->mutex);
                                        no_reply_cnt++;
                                        rele_sendq_token(sendq_token);
                                        DBG_PRINTF((category, RSM_DEBUG,
                                            "rsmipc_send done: "
                                            "cv_wait INTERRUPTED"));
                                        return (RSMERR_INTERRUPTED);
                                }
                        }

                        /*
                         * path is not active retry on another path.
                         */
                        if (path->state != RSMKA_PATH_ACTIVE) {
                                mutex_exit(&path->mutex);
                                rele_sendq_token(sendq_token);
                                e = RSMERR_CONN_ABORTED;
                                DBG_PRINTF((category, RSM_ERR,
                                    "rsm: rsmipc_send: path !ACTIVE"));
                                goto again;
                        }

                        ASSERT(sendq_token->msgbuf_avail > 0);

                        /*
                         * reserve a msgbuf
                         */
                        sendq_token->msgbuf_avail--;

                        mutex_exit(&path->mutex);

                        e = adapter->rsmpi_ops->rsm_send(ipc_handle, &is,
                            NULL);

                        if (e != RSM_SUCCESS) {
                                mutex_enter(&path->mutex);
                                /*
                                 * release the reserved msgbuf since
                                 * the send failed
                                 */
                                sendq_token->msgbuf_avail++;
                                cv_broadcast(&sendq_token->sendq_cv);
                                mutex_exit(&path->mutex);
                        }
                } else
                        e = adapter->rsmpi_ops->rsm_send(ipc_handle, &is,
                            NULL);

                no_reply_cnt++;
                rele_sendq_token(sendq_token);
                if (e != RSM_SUCCESS) {
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm: rsmipc_send no reply send"
                            " err = %d no reply count = %d\n",
                            e, no_reply_cnt));
                        ASSERT(e != RSMERR_QUEUE_FENCE_UP &&
                            e != RSMERR_BAD_BARRIER_HNDL);
                        atomic_inc_64(&rsm_ipcsend_errcnt);
                        goto again;
                } else {
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsmipc_send done\n"));
                        return (e);
                }

        }

        if (req == NULL) {
                /* Send reply - No flow control is done for reply */
                /*
                 * Set the version in the msg header for KA communication
                 * versioning
                 */
                reply->rsmipc_hdr.rsmipc_version = RSM_VERSION;
                reply->rsmipc_hdr.rsmipc_src = my_nodeid;
                /* incn number is not used for reply msgs currently */
                reply->rsmipc_hdr.rsmipc_incn = path->remote_incn;

                is.is_data = (void *)reply;
                is.is_size = sizeof (*reply);
                is.is_flags = RSM_INTR_SEND_DELIVER | RSM_INTR_SEND_SLEEP;
                is.is_wait = 0;
                e = adapter->rsmpi_ops->rsm_send(ipc_handle, &is, NULL);
                rele_sendq_token(sendq_token);
                if (e != RSM_SUCCESS) {
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm: rsmipc_send reply send"
                            " err = %d\n", e));
                        atomic_inc_64(&rsm_ipcsend_errcnt);
                        goto again;
                } else {
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsmipc_send done\n"));
                        return (e);
                }
        }

        /* Reply needed */
        rslot = rsmipc_alloc(); /* allocate a new ipc slot */

        mutex_enter(&rslot->rsmipc_lock);

        rslot->rsmipc_data = (void *)reply;
        RSMIPC_SET(rslot, RSMIPC_PENDING);

        while (RSMIPC_GET(rslot, RSMIPC_PENDING)) {
                /*
                 * Set the rsmipc_version number in the msghdr for KA
                 * communication versioning
                 */
                req->rsmipc_hdr.rsmipc_version = RSM_VERSION;
                req->rsmipc_hdr.rsmipc_src = my_nodeid;
                req->rsmipc_hdr.rsmipc_cookie = rslot->rsmipc_cookie;
                /*
                 * remote endpoints incn should match the value in our
                 * path's remote_incn field. No need to grab any lock
                 * since we have refcnted the path in rsmka_get_sendq_token
                 */
                req->rsmipc_hdr.rsmipc_incn = path->remote_incn;

                is.is_data = (void *)req;
                is.is_size = sizeof (*req);
                is.is_flags = RSM_INTR_SEND_DELIVER | RSM_INTR_SEND_SLEEP;
                is.is_wait = 0;
                if (credit_check) {

                        mutex_enter(&path->mutex);
                        /*
                         * wait till we recv credits or path goes down. If path
                         * goes down rsm_send will fail and we handle the error
                         * then.
                         */
                        while ((sendq_token->msgbuf_avail == 0) &&
                            (path->state == RSMKA_PATH_ACTIVE)) {
                                e = cv_wait_sig(&sendq_token->sendq_cv,
                                    &path->mutex);
                                if (e == 0) {
                                        mutex_exit(&path->mutex);
                                        RSMIPC_CLEAR(rslot, RSMIPC_PENDING);
                                        rsmipc_free(rslot);
                                        rele_sendq_token(sendq_token);
                                        DBG_PRINTF((category, RSM_DEBUG,
                                            "rsmipc_send done: "
                                            "cv_wait INTERRUPTED"));
                                        return (RSMERR_INTERRUPTED);
                                }
                        }

                        /*
                         * path is not active retry on another path.
                         */
                        if (path->state != RSMKA_PATH_ACTIVE) {
                                mutex_exit(&path->mutex);
                                RSMIPC_CLEAR(rslot, RSMIPC_PENDING);
                                rsmipc_free(rslot);
                                rele_sendq_token(sendq_token);
                                e = RSMERR_CONN_ABORTED;
                                DBG_PRINTF((category, RSM_ERR,
                                    "rsm: rsmipc_send: path !ACTIVE"));
                                goto again;
                        }

                        ASSERT(sendq_token->msgbuf_avail > 0);

                        /*
                         * reserve a msgbuf
                         */
                        sendq_token->msgbuf_avail--;

                        mutex_exit(&path->mutex);

                        e = adapter->rsmpi_ops->rsm_send(ipc_handle, &is,
                            NULL);

                        if (e != RSM_SUCCESS) {
                                mutex_enter(&path->mutex);
                                /*
                                 * release the reserved msgbuf since
                                 * the send failed
                                 */
                                sendq_token->msgbuf_avail++;
                                cv_broadcast(&sendq_token->sendq_cv);
                                mutex_exit(&path->mutex);
                        }
                } else
                        e = adapter->rsmpi_ops->rsm_send(ipc_handle, &is,
                            NULL);

                if (e != RSM_SUCCESS) {
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm: rsmipc_send rsmpi send err = %d\n", e));
                        RSMIPC_CLEAR(rslot, RSMIPC_PENDING);
                        rsmipc_free(rslot);
                        rele_sendq_token(sendq_token);
                        atomic_inc_64(&rsm_ipcsend_errcnt);
                        goto again;
                }

                /* wait for a reply signal, a SIGINT, or 5 sec. timeout */
                e = cv_reltimedwait_sig(&rslot->rsmipc_cv, &rslot->rsmipc_lock,
                    drv_usectohz(5000000), TR_CLOCK_TICK);
                if (e < 0) {
                        /* timed out - retry */
                        e = RSMERR_TIMEOUT;
                } else if (e == 0) {
                        /* signalled - return error */
                        e = RSMERR_INTERRUPTED;
                        break;
                } else {
                        e = RSM_SUCCESS;
                }
        }

        RSMIPC_CLEAR(rslot, RSMIPC_PENDING);
        rsmipc_free(rslot);
        rele_sendq_token(sendq_token);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmipc_send done=%d\n", e));
        return (e);
}

static int
rsm_send_notimporting(rsm_node_id_t dest, rsm_memseg_id_t segid,  void *cookie)
{
        rsmipc_request_t request;

        /*
         *  inform the exporter to delete this importer
         */
        request.rsmipc_hdr.rsmipc_type = RSMIPC_MSG_NOTIMPORTING;
        request.rsmipc_key = segid;
        request.rsmipc_segment_cookie = cookie;
        return (rsmipc_send(dest, &request, RSM_NO_REPLY));
}

static void
rsm_send_republish(rsm_memseg_id_t segid, rsmapi_access_entry_t *acl,
    int acl_len, rsm_permission_t default_permission)
{
        int                     i;
        importing_token_t       *token;
        rsmipc_request_t        request;
        republish_token_t       *republish_list = NULL;
        republish_token_t       *rp;
        rsm_permission_t        permission;
        int                     index;

        /*
         * send the new access mode to all the nodes that have imported
         * this segment.
         * If the new acl does not have a node that was present in
         * the old acl a access permission of 0 is sent.
         */

        index = rsmhash(segid);

        /*
         * create a list of node/permissions to send the republish message
         */
        mutex_enter(&importer_list.lock);

        token = importer_list.bucket[index];
        while (token != NULL) {
                if (segid == token->key) {
                        permission = default_permission;

                        for (i = 0; i < acl_len; i++) {
                                if (token->importing_node == acl[i].ae_node) {
                                        permission = acl[i].ae_permission;
                                        break;
                                }
                        }
                        rp = kmem_zalloc(sizeof (republish_token_t), KM_SLEEP);

                        rp->key = segid;
                        rp->importing_node = token->importing_node;
                        rp->permission = permission;
                        rp->next = republish_list;
                        republish_list = rp;
                }
                token = token->next;
        }

        mutex_exit(&importer_list.lock);

        request.rsmipc_hdr.rsmipc_type = RSMIPC_MSG_REPUBLISH;
        request.rsmipc_key = segid;

        while (republish_list != NULL) {
                request.rsmipc_perm = republish_list->permission;
                (void) rsmipc_send(republish_list->importing_node,
                    &request, RSM_NO_REPLY);
                rp = republish_list;
                republish_list = republish_list->next;
                kmem_free(rp, sizeof (republish_token_t));
        }
}

static void
rsm_send_suspend()
{
        int                     i, e;
        rsmipc_request_t        request;
        list_element_t          *tokp;
        list_element_t          *head = NULL;
        importing_token_t       *token;
        DBG_PRINTF((RSM_KERNEL_AGENT | RSM_EXPORT, RSM_DEBUG_VERBOSE,
            "rsm_send_suspend enter\n"));

        /*
         * create a list of node to send the suspend message
         *
         * Currently the whole importer list is scanned and we obtain
         * all the nodes - this basically gets all nodes that at least
         * import one segment from the local node.
         *
         * no need to grab the rsm_suspend_list lock here since we are
         * single threaded when suspend is called.
         */

        mutex_enter(&importer_list.lock);
        for (i = 0; i < rsm_hash_size; i++) {

                token = importer_list.bucket[i];

                while (token != NULL) {

                        tokp = head;

                        /*
                         * make sure that the token's node
                         * is not already on the suspend list
                         */
                        while (tokp != NULL) {
                                if (tokp->nodeid == token->importing_node) {
                                        break;
                                }
                                tokp = tokp->next;
                        }

                        if (tokp == NULL) { /* not in suspend list */
                                tokp = kmem_zalloc(sizeof (list_element_t),
                                    KM_SLEEP);
                                tokp->nodeid = token->importing_node;
                                tokp->next = head;
                                head = tokp;
                        }

                        token = token->next;
                }
        }
        mutex_exit(&importer_list.lock);

        if (head == NULL) { /* no importers so go ahead and quiesce segments */
                exporter_quiesce();
                return;
        }

        mutex_enter(&rsm_suspend_list.list_lock);
        ASSERT(rsm_suspend_list.list_head == NULL);
        /*
         * update the suspend list righaway so that if a node dies the
         * pathmanager can set the NODE dead flag
         */
        rsm_suspend_list.list_head = head;
        mutex_exit(&rsm_suspend_list.list_lock);

        tokp = head;

        while (tokp != NULL) {
                request.rsmipc_hdr.rsmipc_type = RSMIPC_MSG_SUSPEND;
                e = rsmipc_send(tokp->nodeid, &request, RSM_NO_REPLY);
                /*
                 * Error in rsmipc_send currently happens due to inaccessibility
                 * of the remote node.
                 */
                if (e == RSM_SUCCESS) { /* send failed - don't wait for ack */
                        tokp->flags |= RSM_SUSPEND_ACKPENDING;
                }

                tokp = tokp->next;
        }

        DBG_PRINTF((RSM_KERNEL_AGENT | RSM_EXPORT, RSM_DEBUG_VERBOSE,
            "rsm_send_suspend done\n"));

}

static void
rsm_send_resume()
{
        rsmipc_request_t        request;
        list_element_t          *elem, *head;

        /*
         * save the suspend list so that we know where to send
         * the resume messages and make the suspend list head
         * NULL.
         */
        mutex_enter(&rsm_suspend_list.list_lock);
        head = rsm_suspend_list.list_head;
        rsm_suspend_list.list_head = NULL;
        mutex_exit(&rsm_suspend_list.list_lock);

        while (head != NULL) {
                elem = head;
                head = head->next;

                request.rsmipc_hdr.rsmipc_type = RSMIPC_MSG_RESUME;

                (void) rsmipc_send(elem->nodeid, &request, RSM_NO_REPLY);

                kmem_free((void *)elem, sizeof (list_element_t));

        }

}

/*
 * This function takes path and sends a message using the sendq
 * corresponding to it. The RSMIPC_MSG_SQREADY, RSMIPC_MSG_SQREADY_ACK
 * and RSMIPC_MSG_CREDIT are sent using this function.
 */
int
rsmipc_send_controlmsg(path_t *path, int msgtype)
{
        int                     e;
        int                     retry_cnt = 0;
        int                     min_retry_cnt = 10;
        adapter_t               *adapter;
        rsm_send_t              is;
        rsm_send_q_handle_t     ipc_handle;
        rsmipc_controlmsg_t     msg;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_FLOWCONTROL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmipc_send_controlmsg enter\n"));

        ASSERT(MUTEX_HELD(&path->mutex));

        adapter = path->local_adapter;

        DBG_PRINTF((category, RSM_DEBUG, "rsmipc_send_controlmsg:path=%lx "
            "msgtype=%d %lx:%llx->%lx:%llx procmsg=%d\n", path, msgtype,
            my_nodeid, adapter->hwaddr, path->remote_node,
            path->remote_hwaddr, path->procmsg_cnt));

        if (path->state != RSMKA_PATH_ACTIVE) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmipc_send_controlmsg done: ! RSMKA_PATH_ACTIVE"));
                return (1);
        }

        ipc_handle = path->sendq_token.rsmpi_sendq_handle;

        msg.rsmipc_hdr.rsmipc_version = RSM_VERSION;
        msg.rsmipc_hdr.rsmipc_src = my_nodeid;
        msg.rsmipc_hdr.rsmipc_type = msgtype;
        msg.rsmipc_hdr.rsmipc_incn = path->remote_incn;

        if (msgtype == RSMIPC_MSG_CREDIT)
                msg.rsmipc_credits = path->procmsg_cnt;

        msg.rsmipc_local_incn = path->local_incn;

        msg.rsmipc_adapter_hwaddr = adapter->hwaddr;
        /* incr the sendq, path refcnt */
        PATH_HOLD_NOLOCK(path);
        SENDQ_TOKEN_HOLD(path);

        do {
                /* drop the path lock before doing the rsm_send */
                mutex_exit(&path->mutex);

                is.is_data = (void *)&msg;
                is.is_size = sizeof (msg);
                is.is_flags = RSM_INTR_SEND_DELIVER | RSM_INTR_SEND_SLEEP;
                is.is_wait = 0;

                e = adapter->rsmpi_ops->rsm_send(ipc_handle, &is, NULL);

                ASSERT(e != RSMERR_QUEUE_FENCE_UP &&
                    e != RSMERR_BAD_BARRIER_HNDL);

                mutex_enter(&path->mutex);

                if (e == RSM_SUCCESS) {
                        break;
                }
                /* error counter for statistics */
                atomic_inc_64(&rsm_ctrlmsg_errcnt);

                DBG_PRINTF((category, RSM_ERR,
                    "rsmipc_send_controlmsg:rsm_send error=%d", e));

                if (++retry_cnt == min_retry_cnt) { /* backoff before retry */
                        (void) cv_reltimedwait(&path->sendq_token.sendq_cv,
                            &path->mutex, drv_usectohz(10000), TR_CLOCK_TICK);
                        retry_cnt = 0;
                }
        } while (path->state == RSMKA_PATH_ACTIVE);

        /* decrement the sendq,path refcnt that we incr before rsm_send */
        SENDQ_TOKEN_RELE(path);
        PATH_RELE_NOLOCK(path);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmipc_send_controlmsg done=%d", e));
        return (e);
}

/*
 * Called from rsm_force_unload and path_importer_disconnect. The memory
 * mapping for the imported segment is removed and the segment is
 * disconnected at the interconnect layer if disconnect_flag is TRUE.
 * rsm_force_unload will get disconnect_flag TRUE from rsm_intr_callback
 * and FALSE from rsm_rebind.
 *
 * When subsequent accesses cause page faulting, the dummy page is mapped
 * to resolve the fault, and the mapping generation number is incremented
 * so that the application can be notified on a close barrier operation.
 *
 * It is important to note that the caller of rsmseg_unload is responsible for
 * acquiring the segment lock before making a call to rsmseg_unload. This is
 * required to make the caller and rsmseg_unload thread safe. The segment lock
 * will be released by the rsmseg_unload function.
 */
void
rsmseg_unload(rsmseg_t *im_seg)
{
        rsmcookie_t             *hdl;
        void                    *shared_cookie;
        rsmipc_request_t        request;
        uint_t                  maxprot;

        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_INTR_CALLBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmseg_unload enter\n"));

        ASSERT(im_seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);

        /* wait until segment leaves the mapping state */
        while (im_seg->s_state == RSM_STATE_MAPPING)
                cv_wait(&im_seg->s_cv, &im_seg->s_lock);
        /*
         * An unload is only necessary if the segment is connected. However,
         * if the segment was on the import list in state RSM_STATE_CONNECTING
         * then a connection was in progress. Change to RSM_STATE_NEW
         * here to cause an early exit from the connection process.
         */
        if (im_seg->s_state == RSM_STATE_NEW) {
                rsmseglock_release(im_seg);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmseg_unload done: RSM_STATE_NEW\n"));
                return;
        } else if (im_seg->s_state == RSM_STATE_CONNECTING) {
                im_seg->s_state = RSM_STATE_ABORT_CONNECT;
                rsmsharelock_acquire(im_seg);
                im_seg->s_share->rsmsi_state = RSMSI_STATE_ABORT_CONNECT;
                rsmsharelock_release(im_seg);
                rsmseglock_release(im_seg);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmseg_unload done: RSM_STATE_CONNECTING\n"));
                return;
        }

        if (im_seg->s_flags & RSM_FORCE_DISCONNECT) {
                if (im_seg->s_ckl != NULL) {
                        int e;
                        /* Setup protections for remap */
                        maxprot = PROT_USER;
                        if (im_seg->s_mode & RSM_PERM_READ) {
                                maxprot |= PROT_READ;
                        }
                        if (im_seg->s_mode & RSM_PERM_WRITE) {
                                maxprot |= PROT_WRITE;
                        }
                        hdl = im_seg->s_ckl;
                        for (; hdl != NULL; hdl = hdl->c_next) {
                                e = devmap_umem_remap(hdl->c_dhp, rsm_dip,
                                    remap_cookie,
                                    hdl->c_off, hdl->c_len,
                                    maxprot, 0, NULL);

                                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                                    "remap returns %d\n", e));
                        }
                }

                (void) rsm_closeconnection(im_seg, &shared_cookie);

                if (shared_cookie != NULL) {
                        /*
                         * inform the exporting node so this import
                         * can be deleted from the list of importers.
                         */
                        request.rsmipc_hdr.rsmipc_type =
                            RSMIPC_MSG_NOTIMPORTING;
                        request.rsmipc_key = im_seg->s_segid;
                        request.rsmipc_segment_cookie = shared_cookie;
                        rsmseglock_release(im_seg);
                        (void) rsmipc_send(im_seg->s_node, &request,
                            RSM_NO_REPLY);
                } else {
                        rsmseglock_release(im_seg);
                }
        }
        else
                rsmseglock_release(im_seg);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmseg_unload done\n"));

}

/* ****************************** Importer Calls ************************ */

static int
rsm_access(uid_t owner, gid_t group, int perm, int mode, const struct cred *cr)
{
        int shifts = 0;

        if (crgetuid(cr) != owner) {
                shifts += 3;
                if (!groupmember(group, cr))
                        shifts += 3;
        }

        mode &= ~(perm << shifts);

        if (mode == 0)
                return (0);

        return (secpolicy_rsm_access(cr, owner, mode));
}


static int
rsm_connect(rsmseg_t *seg, rsm_ioctlmsg_t *msg, cred_t *cred,
    intptr_t dataptr, int mode)
{
        int e;
        int                     recheck_state = 0;
        void                    *shared_cookie;
        rsmipc_request_t        request;
        rsmipc_reply_t          reply;
        rsm_permission_t        access;
        adapter_t               *adapter;
        rsm_addr_t              addr = 0;
        rsm_import_share_t      *sharedp;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IMPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_connect enter\n"));

        adapter = rsm_getadapter(msg, mode);
        if (adapter == NULL) {
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_connect done:ENODEV adapter=NULL\n"));
                return (RSMERR_CTLR_NOT_PRESENT);
        }

        if ((adapter == &loopback_adapter) && (msg->nodeid != my_nodeid)) {
                rsmka_release_adapter(adapter);
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_connect done:ENODEV loopback\n"));
                return (RSMERR_CTLR_NOT_PRESENT);
        }


        ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);
        ASSERT(seg->s_state == RSM_STATE_NEW);

        /*
         * Translate perm to access
         */
        if (msg->perm & ~RSM_PERM_RDWR) {
                rsmka_release_adapter(adapter);
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_connect done:EINVAL invalid perms\n"));
                return (RSMERR_BAD_PERMS);
        }
        access = 0;
        if (msg->perm & RSM_PERM_READ)
                access |= RSM_ACCESS_READ;
        if (msg->perm & RSM_PERM_WRITE)
                access |= RSM_ACCESS_WRITE;

        seg->s_node = msg->nodeid;

        /*
         * Adding to the import list locks the segment; release the segment
         * lock so we can get the reply for the send.
         */
        e = rsmimport_add(seg, msg->key);
        if (e) {
                rsmka_release_adapter(adapter);
                DBG_PRINTF((category, RSM_ERR,
                    "rsm_connect done:rsmimport_add failed %d\n", e));
                return (e);
        }
        seg->s_state = RSM_STATE_CONNECTING;

        /*
         * Set the s_adapter field here so as to have a valid comparison of
         * the adapter and the s_adapter value during rsmshare_get. For
         * any error, set s_adapter to NULL before doing a release_adapter
         */
        seg->s_adapter = adapter;

        rsmseglock_release(seg);

        /*
         * get the pointer to the shared data structure; the
         * shared data is locked and refcount has been incremented
         */
        sharedp = rsmshare_get(msg->key, msg->nodeid, adapter, seg);

        ASSERT(rsmsharelock_held(seg));

        do {
                /* flag indicates whether we need to recheck the state */
                recheck_state = 0;
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_connect:RSMSI_STATE=%d\n", sharedp->rsmsi_state));
                switch (sharedp->rsmsi_state) {
                case RSMSI_STATE_NEW:
                        sharedp->rsmsi_state = RSMSI_STATE_CONNECTING;
                        break;
                case RSMSI_STATE_CONNECTING:
                        /* FALLTHRU */
                case RSMSI_STATE_CONN_QUIESCE:
                        /* FALLTHRU */
                case RSMSI_STATE_MAP_QUIESCE:
                        /* wait for the state to change */
                        while ((sharedp->rsmsi_state ==
                            RSMSI_STATE_CONNECTING) ||
                            (sharedp->rsmsi_state ==
                            RSMSI_STATE_CONN_QUIESCE) ||
                            (sharedp->rsmsi_state ==
                            RSMSI_STATE_MAP_QUIESCE)) {
                                if (cv_wait_sig(&sharedp->rsmsi_cv,
                                    &sharedp->rsmsi_lock) == 0) {
                                        /* signalled - clean up and return */
                                        rsmsharelock_release(seg);
                                        rsmimport_rm(seg);
                                        seg->s_adapter = NULL;
                                        rsmka_release_adapter(adapter);
                                        seg->s_state = RSM_STATE_NEW;
                                        DBG_PRINTF((category, RSM_ERR,
                                            "rsm_connect done: INTERRUPTED\n"));
                                        return (RSMERR_INTERRUPTED);
                                }
                        }
                        /*
                         * the state changed, loop back and check what it is
                         */
                        recheck_state = 1;
                        break;
                case RSMSI_STATE_ABORT_CONNECT:
                        /* exit the loop and clean up further down */
                        break;
                case RSMSI_STATE_CONNECTED:
                        /* already connected, good - fall through */
                case RSMSI_STATE_MAPPED:
                        /* already mapped, wow - fall through */
                        /* access validation etc is done further down */
                        break;
                case RSMSI_STATE_DISCONNECTED:
                        /* disconnected - so reconnect now */
                        sharedp->rsmsi_state = RSMSI_STATE_CONNECTING;
                        break;
                default:
                        ASSERT(0); /* Invalid State */
                }
        } while (recheck_state);

        if (sharedp->rsmsi_state == RSMSI_STATE_CONNECTING) {
                /* we are the first to connect */
                rsmsharelock_release(seg);

                if (msg->nodeid != my_nodeid) {
                        addr = get_remote_hwaddr(adapter, msg->nodeid);

                        if ((int64_t)addr < 0) {
                                rsmsharelock_acquire(seg);
                                rsmsharecv_signal(seg, RSMSI_STATE_CONNECTING,
                                    RSMSI_STATE_NEW);
                                rsmsharelock_release(seg);
                                rsmimport_rm(seg);
                                seg->s_adapter = NULL;
                                rsmka_release_adapter(adapter);
                                seg->s_state = RSM_STATE_NEW;
                                DBG_PRINTF((category, RSM_ERR,
                                    "rsm_connect done: hwaddr<0\n"));
                                return (RSMERR_INTERNAL_ERROR);
                        }
                } else {
                        addr = adapter->hwaddr;
                }

                /*
                 * send request to node [src, dest, key, msgid] and get back
                 * [status, msgid, cookie]
                 */
                request.rsmipc_key = msg->key;
                /*
                 * we need the s_mode of the exporter so pass
                 * RSM_ACCESS_TRUSTED
                 */
                request.rsmipc_perm = RSM_ACCESS_TRUSTED;
                request.rsmipc_hdr.rsmipc_type = RSMIPC_MSG_SEGCONNECT;
                request.rsmipc_adapter_hwaddr = addr;
                request.rsmipc_segment_cookie = sharedp;

                e = (int)rsmipc_send(msg->nodeid, &request, &reply);
                if (e) {
                        rsmsharelock_acquire(seg);
                        rsmsharecv_signal(seg, RSMSI_STATE_CONNECTING,
                            RSMSI_STATE_NEW);
                        rsmsharelock_release(seg);
                        rsmimport_rm(seg);
                        seg->s_adapter = NULL;
                        rsmka_release_adapter(adapter);
                        seg->s_state = RSM_STATE_NEW;
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm_connect done:rsmipc_send failed %d\n", e));
                        return (e);
                }

                if (reply.rsmipc_status != RSM_SUCCESS) {
                        rsmsharelock_acquire(seg);
                        rsmsharecv_signal(seg, RSMSI_STATE_CONNECTING,
                            RSMSI_STATE_NEW);
                        rsmsharelock_release(seg);
                        rsmimport_rm(seg);
                        seg->s_adapter = NULL;
                        rsmka_release_adapter(adapter);
                        seg->s_state = RSM_STATE_NEW;
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm_connect done:rsmipc_send reply err %d\n",
                            reply.rsmipc_status));
                        return (reply.rsmipc_status);
                }

                rsmsharelock_acquire(seg);
                /* store the information recvd into the shared data struct */
                sharedp->rsmsi_mode = reply.rsmipc_mode;
                sharedp->rsmsi_uid = reply.rsmipc_uid;
                sharedp->rsmsi_gid = reply.rsmipc_gid;
                sharedp->rsmsi_seglen = reply.rsmipc_seglen;
                sharedp->rsmsi_cookie = sharedp;
        }

        rsmsharelock_release(seg);

        /*
         * Get the segment lock and check for a force disconnect
         * from the export side which would have changed the state
         * back to RSM_STATE_NEW. Once the segment lock is acquired a
         * force disconnect will be held off until the connection
         * has completed.
         */
        rsmseglock_acquire(seg);
        rsmsharelock_acquire(seg);
        ASSERT(seg->s_state == RSM_STATE_CONNECTING ||
            seg->s_state == RSM_STATE_ABORT_CONNECT);

        shared_cookie = sharedp->rsmsi_cookie;

        if ((seg->s_state == RSM_STATE_ABORT_CONNECT) ||
            (sharedp->rsmsi_state == RSMSI_STATE_ABORT_CONNECT)) {
                seg->s_state = RSM_STATE_NEW;
                seg->s_adapter = NULL;
                rsmsharelock_release(seg);
                rsmseglock_release(seg);
                rsmimport_rm(seg);
                rsmka_release_adapter(adapter);

                rsmsharelock_acquire(seg);
                if (!(sharedp->rsmsi_flags & RSMSI_FLAGS_ABORTDONE)) {
                        /*
                         * set a flag indicating abort handling has been
                         * done
                         */
                        sharedp->rsmsi_flags |= RSMSI_FLAGS_ABORTDONE;
                        rsmsharelock_release(seg);
                        /* send a message to exporter - only once */
                        (void) rsm_send_notimporting(msg->nodeid,
                            msg->key, shared_cookie);
                        rsmsharelock_acquire(seg);
                        /*
                         * wake up any waiting importers and inform that
                         * connection has been aborted
                         */
                        cv_broadcast(&sharedp->rsmsi_cv);
                }
                rsmsharelock_release(seg);

                DBG_PRINTF((category, RSM_ERR,
                    "rsm_connect done: RSM_STATE_ABORT_CONNECT\n"));
                return (RSMERR_INTERRUPTED);
        }


        /*
         * We need to verify that this process has access
         */
        e = rsm_access(sharedp->rsmsi_uid, sharedp->rsmsi_gid,
            access & sharedp->rsmsi_mode,
            (int)(msg->perm & RSM_PERM_RDWR), cred);
        if (e) {
                rsmsharelock_release(seg);
                seg->s_state = RSM_STATE_NEW;
                seg->s_adapter = NULL;
                rsmseglock_release(seg);
                rsmimport_rm(seg);
                rsmka_release_adapter(adapter);
                /*
                 * No need to lock segment it has been removed
                 * from the hash table
                 */
                rsmsharelock_acquire(seg);
                if (sharedp->rsmsi_state == RSMSI_STATE_CONNECTING) {
                        rsmsharelock_release(seg);
                        /* this is the first importer */

                        (void) rsm_send_notimporting(msg->nodeid, msg->key,
                            shared_cookie);
                        rsmsharelock_acquire(seg);
                        sharedp->rsmsi_state = RSMSI_STATE_NEW;
                        cv_broadcast(&sharedp->rsmsi_cv);
                }
                rsmsharelock_release(seg);

                DBG_PRINTF((category, RSM_ERR,
                    "rsm_connect done: ipcaccess failed\n"));
                return (RSMERR_PERM_DENIED);
        }

        /* update state and cookie */
        seg->s_segid = sharedp->rsmsi_segid;
        seg->s_len = sharedp->rsmsi_seglen;
        seg->s_mode = access & sharedp->rsmsi_mode;
        seg->s_pid = ddi_get_pid();
        seg->s_mapinfo = NULL;

        if (seg->s_node != my_nodeid) {
                if (sharedp->rsmsi_state == RSMSI_STATE_CONNECTING) {
                        e = adapter->rsmpi_ops->rsm_connect(
                            adapter->rsmpi_handle,
                            addr, seg->s_segid, &sharedp->rsmsi_handle);

                        if (e != RSM_SUCCESS) {
                                seg->s_state = RSM_STATE_NEW;
                                seg->s_adapter = NULL;
                                rsmsharelock_release(seg);
                                rsmseglock_release(seg);
                                rsmimport_rm(seg);
                                rsmka_release_adapter(adapter);
                                /*
                                 *  inform the exporter to delete this importer
                                 */
                                (void) rsm_send_notimporting(msg->nodeid,
                                    msg->key, shared_cookie);

                                /*
                                 * Now inform any waiting importers to
                                 * retry connect. This needs to be done
                                 * after sending notimporting so that
                                 * the notimporting is sent before a waiting
                                 * importer sends a segconnect while retrying
                                 *
                                 * No need to lock segment it has been removed
                                 * from the hash table
                                 */

                                rsmsharelock_acquire(seg);
                                sharedp->rsmsi_state = RSMSI_STATE_NEW;
                                cv_broadcast(&sharedp->rsmsi_cv);
                                rsmsharelock_release(seg);

                                DBG_PRINTF((category, RSM_ERR,
                                    "rsm_connect error %d\n", e));
                                if (e == RSMERR_SEG_NOT_PUBLISHED_TO_RSM_ADDR)
                                        return (
                                            RSMERR_SEG_NOT_PUBLISHED_TO_NODE);
                                else if ((e == RSMERR_RSM_ADDR_UNREACHABLE) ||
                                    (e == RSMERR_UNKNOWN_RSM_ADDR))
                                        return (RSMERR_REMOTE_NODE_UNREACHABLE);
                                else
                                        return (e);
                        }

                }
                seg->s_handle.in = sharedp->rsmsi_handle;

        }

        seg->s_state = RSM_STATE_CONNECT;


        seg->s_flags &= ~RSM_IMPORT_DUMMY;      /* clear dummy flag */
        if (bar_va) {
                /* increment generation number on barrier page */
                atomic_inc_16(bar_va + seg->s_hdr.rsmrc_num);
                /* return user off into barrier page where status will be */
                msg->off = (int)seg->s_hdr.rsmrc_num;
                msg->gnum = bar_va[msg->off];   /* gnum race */
        } else {
                msg->off = 0;
                msg->gnum = 0;  /* gnum race */
        }

        msg->len = (int)sharedp->rsmsi_seglen;
        msg->rnum = seg->s_minor;
        rsmsharecv_signal(seg, RSMSI_STATE_CONNECTING, RSMSI_STATE_CONNECTED);
        rsmsharelock_release(seg);
        rsmseglock_release(seg);

        /* Return back to user the segment size & perm in case it's needed */

#ifdef _MULTI_DATAMODEL
        if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
                rsm_ioctlmsg32_t msg32;

                if (msg->len > UINT_MAX)
                        msg32.len = RSM_MAXSZ_PAGE_ALIGNED;
                else
                        msg32.len = msg->len;
                msg32.off = msg->off;
                msg32.perm = msg->perm;
                msg32.gnum = msg->gnum;
                msg32.rnum = msg->rnum;

                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_connect done\n"));

                if (ddi_copyout((caddr_t)&msg32, (caddr_t)dataptr,
                    sizeof (msg32), mode))
                        return (RSMERR_BAD_ADDR);
                else
                        return (RSM_SUCCESS);
        }
#endif
        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_connect done\n"));

        if (ddi_copyout((caddr_t)msg, (caddr_t)dataptr, sizeof (*msg),
            mode))
                return (RSMERR_BAD_ADDR);
        else
                return (RSM_SUCCESS);
}

static int
rsm_unmap(rsmseg_t *seg)
{
        int                     err;
        adapter_t               *adapter;
        rsm_import_share_t      *sharedp;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IMPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_unmap enter %u\n", seg->s_segid));

        ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);

        /* assert seg is locked */
        ASSERT(rsmseglock_held(seg));
        ASSERT(seg->s_state != RSM_STATE_MAPPING);

        if ((seg->s_state != RSM_STATE_ACTIVE) &&
            (seg->s_state != RSM_STATE_MAP_QUIESCE)) {
                /* segment unmap has already been done */
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_unmap done\n"));
                return (RSM_SUCCESS);
        }

        sharedp = seg->s_share;

        rsmsharelock_acquire(seg);

        /*
         *      - shared data struct is in MAPPED or MAP_QUIESCE state
         */

        ASSERT(sharedp->rsmsi_state == RSMSI_STATE_MAPPED ||
            sharedp->rsmsi_state == RSMSI_STATE_MAP_QUIESCE);

        /*
         * Unmap pages - previously rsm_memseg_import_unmap was called only if
         * the segment cookie list was NULL; but it is always NULL when
         * called from rsmmap_unmap and won't be NULL when called for
         * a force disconnect - so the check for NULL cookie list was removed
         */

        ASSERT(sharedp->rsmsi_mapcnt > 0);

        sharedp->rsmsi_mapcnt--;

        if (sharedp->rsmsi_mapcnt == 0) {
                if (sharedp->rsmsi_state == RSMSI_STATE_MAPPED) {
                        /* unmap the shared RSMPI mapping */
                        adapter = seg->s_adapter;
                        if (seg->s_node != my_nodeid) {
                                ASSERT(sharedp->rsmsi_handle != NULL);
                                err = adapter->rsmpi_ops->
                                    rsm_unmap(sharedp->rsmsi_handle);
                                DBG_PRINTF((category, RSM_DEBUG,
                                    "rsm_unmap: rsmpi unmap %d\n", err));
                                rsm_free_mapinfo(sharedp->rsmsi_mapinfo);
                                sharedp->rsmsi_mapinfo = NULL;
                        }
                        sharedp->rsmsi_state = RSMSI_STATE_CONNECTED;
                } else { /* MAP_QUIESCE --munmap()--> CONN_QUIESCE */
                        sharedp->rsmsi_state = RSMSI_STATE_CONN_QUIESCE;
                }
        }

        rsmsharelock_release(seg);

        /*
         * The s_cookie field is used to store the cookie returned from the
         * ddi_umem_lock when binding the pages for an export segment. This
         * is the primary use of the s_cookie field and does not normally
         * pertain to any importing segment except in the loopback case.
         * For the loopback case, the import segment and export segment are
         * on the same node, the s_cookie field of the segment structure for
         * the importer is initialized to the s_cookie field in the exported
         * segment during the map operation and is used during the call to
         * devmap_umem_setup for the import mapping.
         * Thus, during unmap, we simply need to set s_cookie to NULL to
         * indicate that the mapping no longer exists.
         */
        seg->s_cookie = NULL;

        seg->s_mapinfo = NULL;

        if (seg->s_state == RSM_STATE_ACTIVE)
                seg->s_state = RSM_STATE_CONNECT;
        else
                seg->s_state = RSM_STATE_CONN_QUIESCE;

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_unmap done\n"));

        return (RSM_SUCCESS);
}

/*
 * cookie returned here if not null indicates that it is
 * the last importer and it can be used in the RSMIPC_NOT_IMPORTING
 * message.
 */
static int
rsm_closeconnection(rsmseg_t *seg, void **cookie)
{
        int                     e;
        adapter_t               *adapter;
        rsm_import_share_t      *sharedp;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IMPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_closeconnection enter\n"));

        *cookie = (void *)NULL;

        ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);

        /* assert seg is locked */
        ASSERT(rsmseglock_held(seg));

        if (seg->s_state == RSM_STATE_DISCONNECT) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_closeconnection done: already disconnected\n"));
                return (RSM_SUCCESS);
        }

        /* wait for all putv/getv ops to get done */
        while (seg->s_rdmacnt > 0) {
                cv_wait(&seg->s_cv, &seg->s_lock);
        }

        (void) rsm_unmap(seg);

        ASSERT(seg->s_state == RSM_STATE_CONNECT ||
            seg->s_state == RSM_STATE_CONN_QUIESCE);

        adapter = seg->s_adapter;
        sharedp = seg->s_share;

        ASSERT(sharedp != NULL);

        rsmsharelock_acquire(seg);

        /*
         * Disconnect on adapter
         *
         * The current algorithm is stateless, I don't have to contact
         * server when I go away. It only gives me permissions. Of course,
         * the adapters will talk to terminate the connect.
         *
         * disconnect is needed only if we are CONNECTED not in CONN_QUIESCE
         */
        if ((sharedp->rsmsi_state == RSMSI_STATE_CONNECTED) &&
            (sharedp->rsmsi_node != my_nodeid)) {

                if (sharedp->rsmsi_refcnt == 1) {
                        /* this is the last importer */
                        ASSERT(sharedp->rsmsi_mapcnt == 0);

                        e = adapter->rsmpi_ops->
                            rsm_disconnect(sharedp->rsmsi_handle);
                        if (e != RSM_SUCCESS) {
                                DBG_PRINTF((category, RSM_DEBUG,
                                    "rsm:disconnect failed seg=%x:err=%d\n",
                                    seg->s_key, e));
                        }
                }
        }

        seg->s_handle.in = NULL;

        sharedp->rsmsi_refcnt--;

        if (sharedp->rsmsi_refcnt == 0) {
                *cookie = (void *)sharedp->rsmsi_cookie;
                sharedp->rsmsi_state = RSMSI_STATE_DISCONNECTED;
                sharedp->rsmsi_handle = NULL;
                rsmsharelock_release(seg);

                /* clean up the shared data structure */
                mutex_destroy(&sharedp->rsmsi_lock);
                cv_destroy(&sharedp->rsmsi_cv);
                kmem_free((void *)(sharedp), sizeof (rsm_import_share_t));

        } else {
                rsmsharelock_release(seg);
        }

        /* increment generation number on barrier page */
        if (bar_va) {
                atomic_inc_16(bar_va + seg->s_hdr.rsmrc_num);
        }

        /*
         * The following needs to be done after any
         * rsmsharelock calls which use seg->s_share.
         */
        seg->s_share = NULL;

        seg->s_state = RSM_STATE_DISCONNECT;
        /* signal anyone waiting in the CONN_QUIESCE state */
        cv_broadcast(&seg->s_cv);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_closeconnection done\n"));

        return (RSM_SUCCESS);
}

int
rsm_disconnect(rsmseg_t *seg)
{
        rsmipc_request_t        request;
        void                    *shared_cookie;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IMPORT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_disconnect enter\n"));

        ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);

        /* assert seg isn't locked */
        ASSERT(!rsmseglock_held(seg));


        /* Remove segment from imported list */
        rsmimport_rm(seg);

        /* acquire the segment */
        rsmseglock_acquire(seg);

        /* wait until segment leaves the mapping state */
        while (seg->s_state == RSM_STATE_MAPPING)
                cv_wait(&seg->s_cv, &seg->s_lock);

        if (seg->s_state == RSM_STATE_DISCONNECT) {
                seg->s_state = RSM_STATE_NEW;
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_disconnect done: already disconnected\n"));
                return (RSM_SUCCESS);
        }

        (void) rsm_closeconnection(seg, &shared_cookie);

        /* update state */
        seg->s_state = RSM_STATE_NEW;

        if (shared_cookie != NULL) {
                /*
                 *  This is the last importer so inform the exporting node
                 *  so this import can be deleted from the list of importers.
                 */
                request.rsmipc_hdr.rsmipc_type = RSMIPC_MSG_NOTIMPORTING;
                request.rsmipc_key = seg->s_segid;
                request.rsmipc_segment_cookie = shared_cookie;
                rsmseglock_release(seg);
                (void) rsmipc_send(seg->s_node, &request, RSM_NO_REPLY);
        } else {
                rsmseglock_release(seg);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_disconnect done\n"));

        return (DDI_SUCCESS);
}

static int
rsm_chpoll(dev_t dev, short events, int anyyet, short *reventsp,
    struct pollhead **phpp)
{
        minor_t         rnum;
        rsmresource_t   *res;
        rsmseg_t        *seg;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_chpoll enter\n"));

        /* find minor, no lock */
        rnum = getminor(dev);
        res = rsmresource_lookup(rnum, RSM_NOLOCK);

        /* poll is supported only for export/import segments */
        if ((res == NULL) || (res == RSMRC_RESERVED) ||
            (res->rsmrc_type == RSM_RESOURCE_BAR)) {
                return (ENXIO);
        }

        /*
         * An exported segment must be in state RSM_STATE_EXPORT; an
         * imported segment must be in state RSM_STATE_ACTIVE.
         */
        seg = (rsmseg_t *)res;

        if (seg->s_pollevent) {
                *reventsp = POLLRDNORM;
        } else {
                *reventsp = 0;
        }

        if ((*reventsp == 0 && !anyyet) || (events & POLLET)) {
                /* cannot take segment lock here */
                *phpp = &seg->s_poll;
                seg->s_pollflag |= RSM_SEGMENT_POLL;
        }
        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_chpoll done\n"));
        return (0);
}



/* ************************* IOCTL Commands ********************* */

static rsmseg_t *
rsmresource_seg(rsmresource_t *res, minor_t rnum, cred_t *credp,
    rsm_resource_type_t type)
{
        /* get segment from resource handle */
        rsmseg_t *seg;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmresource_seg enter\n"));


        if (res != RSMRC_RESERVED) {
                seg = (rsmseg_t *)res;
        } else {
                /* Allocate segment now and bind it */
                seg = rsmseg_alloc(rnum, credp);

                /*
                 * if DR pre-processing is going on or DR is in progress
                 * then the new export segments should be in the NEW_QSCD state
                 */
                if (type == RSM_RESOURCE_EXPORT_SEGMENT) {
                        mutex_enter(&rsm_drv_data.drv_lock);
                        if ((rsm_drv_data.drv_state ==
                            RSM_DRV_PREDEL_STARTED) ||
                            (rsm_drv_data.drv_state ==
                            RSM_DRV_PREDEL_COMPLETED) ||
                            (rsm_drv_data.drv_state ==
                            RSM_DRV_DR_IN_PROGRESS)) {
                                seg->s_state = RSM_STATE_NEW_QUIESCED;
                        }
                        mutex_exit(&rsm_drv_data.drv_lock);
                }

                rsmresource_insert(rnum, (rsmresource_t *)seg, type);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmresource_seg done\n"));

        return (seg);
}

static int
rsmexport_ioctl(rsmseg_t *seg, rsm_ioctlmsg_t *msg, int cmd, intptr_t arg,
    int mode, cred_t *credp)
{
        int error;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmexport_ioctl enter\n"));

        arg = arg;
        credp = credp;

        ASSERT(seg != NULL);

        switch (cmd) {
        case RSM_IOCTL_BIND:
                error = rsm_bind(seg, msg, arg, mode);
                break;
        case RSM_IOCTL_REBIND:
                error = rsm_rebind(seg, msg);
                break;
        case RSM_IOCTL_UNBIND:
                error = ENOTSUP;
                break;
        case RSM_IOCTL_PUBLISH:
                error = rsm_publish(seg, msg, arg, mode);
                break;
        case RSM_IOCTL_REPUBLISH:
                error = rsm_republish(seg, msg, mode);
                break;
        case RSM_IOCTL_UNPUBLISH:
                error = rsm_unpublish(seg, 1);
                break;
        default:
                error = EINVAL;
                break;
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmexport_ioctl done: %d\n",
            error));

        return (error);
}
static int
rsmimport_ioctl(rsmseg_t *seg, rsm_ioctlmsg_t *msg, int cmd, intptr_t arg,
    int mode, cred_t *credp)
{
        int error;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IMPORT | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmimport_ioctl enter\n"));

        ASSERT(seg);

        switch (cmd) {
        case RSM_IOCTL_CONNECT:
                error = rsm_connect(seg, msg, credp, arg, mode);
                break;
        default:
                error = EINVAL;
                break;
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmimport_ioctl done: %d\n",
            error));
        return (error);
}

static int
rsmbar_ioctl(rsmseg_t *seg, rsm_ioctlmsg_t *msg, int cmd, intptr_t arg,
    int mode)
{
        int e;
        adapter_t *adapter;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IMPORT | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmbar_ioctl enter\n"));


        if ((seg->s_flags & RSM_IMPORT_DUMMY) != 0) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmbar_ioctl done: RSM_IMPORT_DUMMY\n"));
                return (RSMERR_CONN_ABORTED);
        } else if (seg->s_node == my_nodeid) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmbar_ioctl done: loopback\n"));
                return (RSM_SUCCESS);
        }

        adapter = seg->s_adapter;

        switch (cmd) {
        case RSM_IOCTL_BAR_CHECK:
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmbar_ioctl done: RSM_BAR_CHECK %d\n", bar_va));
                return (bar_va ? RSM_SUCCESS : EINVAL);
        case RSM_IOCTL_BAR_OPEN:
                e = adapter->rsmpi_ops->
                    rsm_open_barrier_ctrl(adapter->rsmpi_handle, &msg->bar);
                break;
        case RSM_IOCTL_BAR_ORDER:
                e = adapter->rsmpi_ops->rsm_order_barrier(&msg->bar);
                break;
        case RSM_IOCTL_BAR_CLOSE:
                e = adapter->rsmpi_ops->rsm_close_barrier(&msg->bar);
                break;
        default:
                e = EINVAL;
                break;
        }

        if (e == RSM_SUCCESS) {
#ifdef _MULTI_DATAMODEL
                if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
                        rsm_ioctlmsg32_t msg32;
                        int i;

                        for (i = 0; i < 4; i++) {
                                msg32.bar.comp[i].u64 = msg->bar.comp[i].u64;
                        }

                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsmbar_ioctl done\n"));
                        if (ddi_copyout((caddr_t)&msg32, (caddr_t)arg,
                            sizeof (msg32), mode))
                                return (RSMERR_BAD_ADDR);
                        else
                                return (RSM_SUCCESS);
                }
#endif
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmbar_ioctl done\n"));
                if (ddi_copyout((caddr_t)&msg->bar, (caddr_t)arg,
                    sizeof (*msg), mode))
                        return (RSMERR_BAD_ADDR);
                else
                        return (RSM_SUCCESS);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmbar_ioctl done: error=%d\n", e));

        return (e);
}

/*
 * Ring the doorbell of the export segment to which this segment is
 * connected.
 */
static int
exportbell_ioctl(rsmseg_t *seg, int cmd /*ARGSUSED*/)
{
        int e = 0;
        rsmipc_request_t request;

        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IMPORT | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "exportbell_ioctl enter\n"));

        request.rsmipc_key = seg->s_segid;
        request.rsmipc_hdr.rsmipc_type = RSMIPC_MSG_BELL;
        request.rsmipc_segment_cookie = NULL;
        e = rsmipc_send(seg->s_node, &request, RSM_NO_REPLY);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "exportbell_ioctl done: %d\n", e));

        return (e);
}

/*
 * Ring the doorbells of all segments importing this segment
 */
static int
importbell_ioctl(rsmseg_t *seg, int cmd /*ARGSUSED*/)
{
        importing_token_t       *token = NULL;
        rsmipc_request_t        request;
        int                     index;

        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_EXPORT | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "importbell_ioctl enter\n"));

        ASSERT(seg->s_state != RSM_STATE_NEW &&
            seg->s_state != RSM_STATE_NEW_QUIESCED);

        request.rsmipc_key = seg->s_segid;
        request.rsmipc_hdr.rsmipc_type = RSMIPC_MSG_BELL;

        index = rsmhash(seg->s_segid);

        token = importer_list.bucket[index];

        while (token != NULL) {
                if (seg->s_key == token->key) {
                        request.rsmipc_segment_cookie =
                            token->import_segment_cookie;
                        (void) rsmipc_send(token->importing_node,
                            &request, RSM_NO_REPLY);
                }
                token = token->next;
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "importbell_ioctl done\n"));
        return (RSM_SUCCESS);
}

static int
rsm_consumeevent_copyin(caddr_t arg, rsm_consume_event_msg_t *msgp,
    rsm_poll_event_t **eventspp, int mode)
{
        rsm_poll_event_t        *evlist = NULL;
        size_t                  evlistsz;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IOCTL);

#ifdef _MULTI_DATAMODEL
        if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
                int i;
                rsm_consume_event_msg32_t cemsg32 = {0};
                rsm_poll_event32_t      event32[RSM_MAX_POLLFDS];
                rsm_poll_event32_t      *evlist32;
                size_t                  evlistsz32;

                /* copyin the ioctl message */
                if (ddi_copyin(arg, (caddr_t)&cemsg32,
                    sizeof (rsm_consume_event_msg32_t), mode)) {
                        DBG_PRINTF((category, RSM_ERR,
                            "consumeevent_copyin msgp: RSMERR_BAD_ADDR\n"));
                        return (RSMERR_BAD_ADDR);
                }
                msgp->seglist = (caddr_t)(uintptr_t)cemsg32.seglist;
                msgp->numents = (int)cemsg32.numents;

                evlistsz32 = sizeof (rsm_poll_event32_t) * msgp->numents;
                /*
                 * If numents is large alloc events list on heap otherwise
                 * use the address of array that was passed in.
                 */
                if (msgp->numents > RSM_MAX_POLLFDS) {
                        if (msgp->numents > max_segs) { /* validate numents */
                                DBG_PRINTF((category, RSM_ERR,
                                    "consumeevent_copyin: "
                                    "RSMERR_BAD_ARGS_ERRORS\n"));
                                return (RSMERR_BAD_ARGS_ERRORS);
                        }
                        evlist32 = kmem_zalloc(evlistsz32, KM_SLEEP);
                } else {
                        evlist32 = event32;
                }

                /* copyin the seglist into the rsm_poll_event32_t array */
                if (ddi_copyin((caddr_t)msgp->seglist, (caddr_t)evlist32,
                    evlistsz32, mode)) {
                        if ((msgp->numents > RSM_MAX_POLLFDS) && evlist32) {
                                kmem_free(evlist32, evlistsz32);
                        }
                        DBG_PRINTF((category, RSM_ERR,
                            "consumeevent_copyin evlist: RSMERR_BAD_ADDR\n"));
                        return (RSMERR_BAD_ADDR);
                }

                /* evlist and evlistsz are based on rsm_poll_event_t type */
                evlistsz = sizeof (rsm_poll_event_t)* msgp->numents;

                if (msgp->numents > RSM_MAX_POLLFDS) {
                        evlist = kmem_zalloc(evlistsz, KM_SLEEP);
                        *eventspp = evlist;
                } else {
                        evlist = *eventspp;
                }
                /*
                 * copy the rsm_poll_event32_t array to the rsm_poll_event_t
                 * array
                 */
                for (i = 0; i < msgp->numents; i++) {
                        evlist[i].rnum = evlist32[i].rnum;
                        evlist[i].fdsidx = evlist32[i].fdsidx;
                        evlist[i].revent = evlist32[i].revent;
                }
                /* free the temp 32-bit event list */
                if ((msgp->numents > RSM_MAX_POLLFDS) && evlist32) {
                        kmem_free(evlist32, evlistsz32);
                }

                return (RSM_SUCCESS);
        }
#endif
        /* copyin the ioctl message */
        if (ddi_copyin(arg, (caddr_t)msgp, sizeof (rsm_consume_event_msg_t),
            mode)) {
                DBG_PRINTF((category, RSM_ERR,
                    "consumeevent_copyin msgp: RSMERR_BAD_ADDR\n"));
                return (RSMERR_BAD_ADDR);
        }
        /*
         * If numents is large alloc events list on heap otherwise
         * use the address of array that was passed in.
         */
        if (msgp->numents > RSM_MAX_POLLFDS) {
                if (msgp->numents > max_segs) { /* validate numents */
                        DBG_PRINTF((category, RSM_ERR,
                            "consumeevent_copyin: RSMERR_BAD_ARGS_ERRORS\n"));
                        return (RSMERR_BAD_ARGS_ERRORS);
                }
                evlistsz = sizeof (rsm_poll_event_t)*msgp->numents;
                evlist = kmem_zalloc(evlistsz, KM_SLEEP);
                *eventspp  = evlist;
        }

        /* copyin the seglist */
        if (ddi_copyin((caddr_t)msgp->seglist, (caddr_t)(*eventspp),
            sizeof (rsm_poll_event_t)*msgp->numents, mode)) {
                if (evlist) {
                        kmem_free(evlist, evlistsz);
                        *eventspp = NULL;
                }
                DBG_PRINTF((category, RSM_ERR,
                    "consumeevent_copyin evlist: RSMERR_BAD_ADDR\n"));
                return (RSMERR_BAD_ADDR);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "consumeevent_copyin done\n"));
        return (RSM_SUCCESS);
}

static int
rsm_consumeevent_copyout(rsm_consume_event_msg_t *msgp,
    rsm_poll_event_t *eventsp, int mode)
{
        size_t                  evlistsz;
        int                     err = RSM_SUCCESS;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "consumeevent_copyout enter: numents(%d) eventsp(%p)\n",
            msgp->numents, eventsp));

#ifdef _MULTI_DATAMODEL
        if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
                int i;
                rsm_poll_event32_t      event32[RSM_MAX_POLLFDS];
                rsm_poll_event32_t      *evlist32;
                size_t                  evlistsz32;

                evlistsz32 = sizeof (rsm_poll_event32_t)*msgp->numents;
                if (msgp->numents > RSM_MAX_POLLFDS) {
                        evlist32 = kmem_zalloc(evlistsz32, KM_SLEEP);
                } else {
                        evlist32 = event32;
                }

                /*
                 * copy the rsm_poll_event_t array to the rsm_poll_event32_t
                 * array
                 */
                for (i = 0; i < msgp->numents; i++) {
                        evlist32[i].rnum = eventsp[i].rnum;
                        evlist32[i].fdsidx = eventsp[i].fdsidx;
                        evlist32[i].revent = eventsp[i].revent;
                }

                if (ddi_copyout((caddr_t)evlist32, (caddr_t)msgp->seglist,
                    evlistsz32, mode)) {
                        err = RSMERR_BAD_ADDR;
                }

                if (msgp->numents > RSM_MAX_POLLFDS) {
                        if (evlist32) { /* free the temp 32-bit event list */
                                kmem_free(evlist32, evlistsz32);
                        }
                        /*
                         * eventsp and evlistsz are based on rsm_poll_event_t
                         * type
                         */
                        evlistsz = sizeof (rsm_poll_event_t)*msgp->numents;
                        /* event list on the heap and needs to be freed here */
                        if (eventsp) {
                                kmem_free(eventsp, evlistsz);
                        }
                }

                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "consumeevent_copyout done: err=%d\n", err));
                return (err);
        }
#endif
        evlistsz = sizeof (rsm_poll_event_t)*msgp->numents;

        if (ddi_copyout((caddr_t)eventsp, (caddr_t)msgp->seglist, evlistsz,
            mode)) {
                err = RSMERR_BAD_ADDR;
        }

        if ((msgp->numents > RSM_MAX_POLLFDS) && eventsp) {
                /* event list on the heap and needs to be freed here */
                kmem_free(eventsp, evlistsz);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "consumeevent_copyout done: err=%d\n", err));
        return (err);
}

static int
rsm_consumeevent_ioctl(caddr_t arg, int mode)
{
        int     rc;
        int     i;
        minor_t rnum;
        rsm_consume_event_msg_t msg = {0};
        rsmseg_t                *seg;
        rsm_poll_event_t        *event_list;
        rsm_poll_event_t        events[RSM_MAX_POLLFDS];
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IOCTL);

        event_list = events;

        if ((rc = rsm_consumeevent_copyin(arg, &msg, &event_list, mode)) !=
            RSM_SUCCESS) {
                return (rc);
        }

        for (i = 0; i < msg.numents; i++) {
                rnum = event_list[i].rnum;
                event_list[i].revent = 0;
                /* get the segment structure */
                seg = (rsmseg_t *)rsmresource_lookup(rnum, RSM_LOCK);
                if (seg) {
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "consumeevent_ioctl: rnum(%d) seg(%p)\n", rnum,
                            seg));
                        if (seg->s_pollevent) {
                                /* consume the event */
                                atomic_dec_32(&seg->s_pollevent);
                                event_list[i].revent = POLLRDNORM;
                        }
                        rsmseglock_release(seg);
                }
        }

        if ((rc = rsm_consumeevent_copyout(&msg, event_list, mode)) !=
            RSM_SUCCESS) {
                return (rc);
        }

        return (RSM_SUCCESS);
}

static int
iovec_copyin(caddr_t user_vec, rsmka_iovec_t *iovec, int count, int mode)
{
        int size;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IMPORT | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "iovec_copyin enter\n"));

#ifdef _MULTI_DATAMODEL
        if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
                rsmka_iovec32_t *iovec32, *iovec32_base;
                int i;

                size = count * sizeof (rsmka_iovec32_t);
                iovec32_base = iovec32 = kmem_zalloc(size, KM_SLEEP);
                if (ddi_copyin((caddr_t)user_vec,
                    (caddr_t)iovec32, size, mode)) {
                        kmem_free(iovec32, size);
                        DBG_PRINTF((category, RSM_DEBUG,
                            "iovec_copyin: returning RSMERR_BAD_ADDR\n"));
                        return (RSMERR_BAD_ADDR);
                }

                for (i = 0; i < count; i++, iovec++, iovec32++) {
                        iovec->io_type = (int)iovec32->io_type;
                        if (iovec->io_type == RSM_HANDLE_TYPE)
                                iovec->local.segid = (rsm_memseg_id_t)
                                    iovec32->local;
                        else
                                iovec->local.vaddr =
                                    (caddr_t)(uintptr_t)iovec32->local;
                        iovec->local_offset = (size_t)iovec32->local_offset;
                        iovec->remote_offset = (size_t)iovec32->remote_offset;
                        iovec->transfer_len = (size_t)iovec32->transfer_len;

                }
                kmem_free(iovec32_base, size);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "iovec_copyin done\n"));
                return (DDI_SUCCESS);
        }
#endif

        size = count * sizeof (rsmka_iovec_t);
        if (ddi_copyin((caddr_t)user_vec, (caddr_t)iovec, size, mode)) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "iovec_copyin done: RSMERR_BAD_ADDR\n"));
                return (RSMERR_BAD_ADDR);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "iovec_copyin done\n"));

        return (DDI_SUCCESS);
}


static int
sgio_copyin(caddr_t arg, rsmka_scat_gath_t *sg_io, int mode)
{
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IMPORT | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "sgio_copyin enter\n"));

#ifdef _MULTI_DATAMODEL
        if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
                rsmka_scat_gath32_t sg_io32;

                if (ddi_copyin(arg, (caddr_t)&sg_io32, sizeof (sg_io32),
                    mode)) {
                        DBG_PRINTF((category, RSM_DEBUG,
                            "sgio_copyin done: returning EFAULT\n"));
                        return (RSMERR_BAD_ADDR);
                }
                sg_io->local_nodeid = (rsm_node_id_t)sg_io32.local_nodeid;
                sg_io->io_request_count =  (size_t)sg_io32.io_request_count;
                sg_io->io_residual_count = (size_t)sg_io32.io_residual_count;
                sg_io->flags = (size_t)sg_io32.flags;
                sg_io->remote_handle = (rsm_memseg_import_handle_t)
                    (uintptr_t)sg_io32.remote_handle;
                sg_io->iovec = (rsmka_iovec_t *)(uintptr_t)sg_io32.iovec;
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "sgio_copyin done\n"));
                return (DDI_SUCCESS);
        }
#endif
        if (ddi_copyin(arg, (caddr_t)sg_io, sizeof (rsmka_scat_gath_t),
            mode)) {
                DBG_PRINTF((category, RSM_DEBUG,
                    "sgio_copyin done: returning EFAULT\n"));
                return (RSMERR_BAD_ADDR);
        }
        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "sgio_copyin done\n"));
        return (DDI_SUCCESS);
}

static int
sgio_resid_copyout(caddr_t arg, rsmka_scat_gath_t *sg_io, int mode)
{
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IMPORT | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "sgio_resid_copyout enter\n"));

#ifdef _MULTI_DATAMODEL
        if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
                rsmka_scat_gath32_t sg_io32;

                sg_io32.io_residual_count = sg_io->io_residual_count;
                sg_io32.flags = sg_io->flags;

                if (ddi_copyout((caddr_t)&sg_io32.io_residual_count,
                    (caddr_t)&((rsmka_scat_gath32_t *)arg)->io_residual_count,
                    sizeof (uint32_t), mode)) {

                        DBG_PRINTF((category, RSM_ERR,
                            "sgio_resid_copyout error: rescnt\n"));
                        return (RSMERR_BAD_ADDR);
                }

                if (ddi_copyout((caddr_t)&sg_io32.flags,
                    (caddr_t)&((rsmka_scat_gath32_t *)arg)->flags,
                    sizeof (uint32_t), mode)) {

                        DBG_PRINTF((category, RSM_ERR,
                            "sgio_resid_copyout error: flags\n"));
                        return (RSMERR_BAD_ADDR);
                }
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "sgio_resid_copyout done\n"));
                return (DDI_SUCCESS);
        }
#endif
        if (ddi_copyout((caddr_t)&sg_io->io_residual_count,
            (caddr_t)&((rsmka_scat_gath_t *)arg)->io_residual_count,
            sizeof (ulong_t), mode)) {

                DBG_PRINTF((category, RSM_ERR,
                    "sgio_resid_copyout error:rescnt\n"));
                return (RSMERR_BAD_ADDR);
        }

        if (ddi_copyout((caddr_t)&sg_io->flags,
            (caddr_t)&((rsmka_scat_gath_t *)arg)->flags,
            sizeof (uint_t), mode)) {

                DBG_PRINTF((category, RSM_ERR,
                    "sgio_resid_copyout error:flags\n"));
                return (RSMERR_BAD_ADDR);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "sgio_resid_copyout done\n"));
        return (DDI_SUCCESS);
}


static int
rsm_iovec_ioctl(dev_t dev, caddr_t arg, int cmd, int mode, cred_t *credp)
{
        rsmka_scat_gath_t       sg_io;
        rsmka_iovec_t           ka_iovec_arr[RSM_MAX_IOVLEN];
        rsmka_iovec_t           *ka_iovec;
        rsmka_iovec_t           *ka_iovec_start;
        rsmpi_scat_gath_t       rsmpi_sg_io;
        rsmpi_iovec_t           iovec_arr[RSM_MAX_IOVLEN];
        rsmpi_iovec_t           *iovec;
        rsmpi_iovec_t           *iovec_start = NULL;
        rsmapi_access_entry_t   *acl;
        rsmresource_t           *res;
        minor_t                 rnum;
        rsmseg_t                *im_seg, *ex_seg;
        int                     e;
        int                     error = 0;
        uint_t                  i;
        uint_t                  iov_proc = 0; /* num of iovecs processed */
        size_t                  size = 0;
        size_t                  ka_size;

        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_IMPORT | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_iovec_ioctl enter\n"));

        credp = credp;

        /*
         * Copyin the scatter/gather structure  and build new structure
         * for rsmpi.
         */
        e = sgio_copyin(arg, &sg_io, mode);
        if (e != DDI_SUCCESS) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_iovec_ioctl done: sgio_copyin %d\n", e));
                return (e);
        }

        if (sg_io.io_request_count > RSM_MAX_SGIOREQS) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_iovec_ioctl done: request_count(%d) too large\n",
                    sg_io.io_request_count));
                return (RSMERR_BAD_SGIO);
        }

        rsmpi_sg_io.io_request_count = sg_io.io_request_count;
        rsmpi_sg_io.io_residual_count = sg_io.io_request_count;
        rsmpi_sg_io.io_segflg = 0;

        /* Allocate memory and copyin io vector array  */
        if (sg_io.io_request_count > RSM_MAX_IOVLEN) {
                ka_size =  sg_io.io_request_count * sizeof (rsmka_iovec_t);
                ka_iovec_start = ka_iovec = kmem_zalloc(ka_size, KM_SLEEP);
        } else {
                ka_iovec_start = ka_iovec = ka_iovec_arr;
        }
        e = iovec_copyin((caddr_t)sg_io.iovec, ka_iovec,
            sg_io.io_request_count, mode);
        if (e != DDI_SUCCESS) {
                if (sg_io.io_request_count > RSM_MAX_IOVLEN)
                        kmem_free(ka_iovec, ka_size);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_iovec_ioctl done: iovec_copyin %d\n", e));
                return (e);
        }

        /* get the import segment descriptor */
        rnum = getminor(dev);
        res = rsmresource_lookup(rnum, RSM_LOCK);

        /*
         * The following sequence of locking may (or MAY NOT) cause a
         * deadlock but this is currently not addressed here since the
         * implementation will be changed to incorporate the use of
         * reference counting for both the import and the export segments.
         */

        /* rsmseglock_acquire(im_seg) done in rsmresource_lookup */

        im_seg = (rsmseg_t *)res;

        if (im_seg == NULL) {
                if (sg_io.io_request_count > RSM_MAX_IOVLEN)
                        kmem_free(ka_iovec, ka_size);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_iovec_ioctl done: rsmresource_lookup failed\n"));
                return (EINVAL);
        }
        /* putv/getv supported is supported only on import segments */
        if (im_seg->s_type != RSM_RESOURCE_IMPORT_SEGMENT) {
                rsmseglock_release(im_seg);
                if (sg_io.io_request_count > RSM_MAX_IOVLEN)
                        kmem_free(ka_iovec, ka_size);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_iovec_ioctl done: not an import segment\n"));
                return (EINVAL);
        }

        /*
         * wait for a remote DR to complete ie. for segments to get UNQUIESCED
         * as well as wait for a local DR to complete.
         */
        while ((im_seg->s_state == RSM_STATE_CONN_QUIESCE) ||
            (im_seg->s_state == RSM_STATE_MAP_QUIESCE) ||
            (im_seg->s_flags & RSM_DR_INPROGRESS)) {
                if (cv_wait_sig(&im_seg->s_cv, &im_seg->s_lock) == 0) {
                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsm_iovec_ioctl done: cv_wait INTR"));
                        rsmseglock_release(im_seg);
                        return (RSMERR_INTERRUPTED);
                }
        }

        if ((im_seg->s_state != RSM_STATE_CONNECT) &&
            (im_seg->s_state != RSM_STATE_ACTIVE)) {

                ASSERT(im_seg->s_state == RSM_STATE_DISCONNECT ||
                    im_seg->s_state == RSM_STATE_NEW);

                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_iovec_ioctl done: im_seg not conn/map"));
                rsmseglock_release(im_seg);
                e = RSMERR_BAD_SGIO;
                goto out;
        }

        im_seg->s_rdmacnt++;
        rsmseglock_release(im_seg);

        /*
         * Allocate and set up the io vector for rsmpi
         */
        if (sg_io.io_request_count > RSM_MAX_IOVLEN) {
                size = sg_io.io_request_count * sizeof (rsmpi_iovec_t);
                iovec_start = iovec = kmem_zalloc(size, KM_SLEEP);
        } else {
                iovec_start = iovec = iovec_arr;
        }

        rsmpi_sg_io.iovec = iovec;
        for (iov_proc = 0; iov_proc < sg_io.io_request_count; iov_proc++) {
                if (ka_iovec->io_type == RSM_HANDLE_TYPE) {
                        ex_seg = rsmexport_lookup(ka_iovec->local.segid);

                        if (ex_seg == NULL) {
                                e = RSMERR_BAD_SGIO;
                                break;
                        }
                        ASSERT(ex_seg->s_state == RSM_STATE_EXPORT);

                        acl = ex_seg->s_acl;
                        if (acl[0].ae_permission == 0) {
                                struct buf *xbuf;
                                dev_t sdev = 0;

                                xbuf = ddi_umem_iosetup(ex_seg->s_cookie,
                                    0, ex_seg->s_len, B_WRITE,
                                    sdev, 0, NULL, DDI_UMEM_SLEEP);

                                ASSERT(xbuf != NULL);

                                iovec->local_mem.ms_type = RSM_MEM_BUF;
                                iovec->local_mem.ms_memory.bp = xbuf;
                        } else {
                                iovec->local_mem.ms_type = RSM_MEM_HANDLE;
                                iovec->local_mem.ms_memory.handle =
                                    ex_seg->s_handle.out;
                        }
                        ex_seg->s_rdmacnt++; /* refcnt the handle */
                        rsmseglock_release(ex_seg);
                } else {
                        iovec->local_mem.ms_type = RSM_MEM_VADDR;
                        iovec->local_mem.ms_memory.vr.vaddr =
                            ka_iovec->local.vaddr;
                }

                iovec->local_offset = ka_iovec->local_offset;
                iovec->remote_handle = im_seg->s_handle.in;
                iovec->remote_offset = ka_iovec->remote_offset;
                iovec->transfer_length = ka_iovec->transfer_len;
                iovec++;
                ka_iovec++;
        }

        if (iov_proc <  sg_io.io_request_count) {
                /* error while processing handle */
                rsmseglock_acquire(im_seg);
                im_seg->s_rdmacnt--;   /* decrement the refcnt for importseg */
                if (im_seg->s_rdmacnt == 0) {
                        cv_broadcast(&im_seg->s_cv);
                }
                rsmseglock_release(im_seg);
                goto out;
        }

        /* call rsmpi */
        if (cmd == RSM_IOCTL_PUTV)
                e = im_seg->s_adapter->rsmpi_ops->rsm_memseg_import_putv(
                    im_seg->s_adapter->rsmpi_handle,
                    &rsmpi_sg_io);
        else if (cmd == RSM_IOCTL_GETV)
                e = im_seg->s_adapter->rsmpi_ops->rsm_memseg_import_getv(
                    im_seg->s_adapter->rsmpi_handle,
                    &rsmpi_sg_io);
        else {
                e = EINVAL;
                DBG_PRINTF((category, RSM_DEBUG,
                    "iovec_ioctl: bad command = %x\n", cmd));
        }


        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_iovec_ioctl RSMPI oper done %d\n", e));

        sg_io.io_residual_count = rsmpi_sg_io.io_residual_count;

        /*
         * Check for implicit signal post flag and do the signal
         * post if needed
         */
        if (sg_io.flags & RSM_IMPLICIT_SIGPOST &&
            e == RSM_SUCCESS) {
                rsmipc_request_t request;

                request.rsmipc_key = im_seg->s_segid;
                request.rsmipc_hdr.rsmipc_type = RSMIPC_MSG_BELL;
                request.rsmipc_segment_cookie = NULL;
                e = rsmipc_send(im_seg->s_node, &request, RSM_NO_REPLY);
                /*
                 * Reset the implicit signal post flag to 0 to indicate
                 * that the signal post has been done and need not be
                 * done in the RSMAPI library
                 */
                sg_io.flags &= ~RSM_IMPLICIT_SIGPOST;
        }

        rsmseglock_acquire(im_seg);
        im_seg->s_rdmacnt--;
        if (im_seg->s_rdmacnt == 0) {
                cv_broadcast(&im_seg->s_cv);
        }
        rsmseglock_release(im_seg);
        error = sgio_resid_copyout(arg, &sg_io, mode);
out:
        iovec = iovec_start;
        ka_iovec = ka_iovec_start;
        for (i = 0; i < iov_proc; i++) {
                if (ka_iovec->io_type == RSM_HANDLE_TYPE) {
                        ex_seg = rsmexport_lookup(ka_iovec->local.segid);

                        ASSERT(ex_seg != NULL);
                        ASSERT(ex_seg->s_state == RSM_STATE_EXPORT);

                        ex_seg->s_rdmacnt--; /* unrefcnt the handle */
                        if (ex_seg->s_rdmacnt == 0) {
                                cv_broadcast(&ex_seg->s_cv);
                        }
                        rsmseglock_release(ex_seg);
                }

                ASSERT(iovec != NULL); /* true if iov_proc > 0 */

                /*
                 * At present there is no dependency on the existence of xbufs
                 * created by ddi_umem_iosetup for each of the iovecs. So we
                 * can these xbufs here.
                 */
                if (iovec->local_mem.ms_type == RSM_MEM_BUF) {
                        freerbuf(iovec->local_mem.ms_memory.bp);
                }

                iovec++;
                ka_iovec++;
        }

        if (sg_io.io_request_count > RSM_MAX_IOVLEN) {
                if (iovec_start)
                        kmem_free(iovec_start, size);
                kmem_free(ka_iovec_start, ka_size);
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_iovec_ioctl done %d\n", e));
        /* if RSMPI call fails return that else return copyout's retval */
        return ((e != RSM_SUCCESS) ? e : error);

}


static int
rsmaddr_ioctl(int cmd, rsm_ioctlmsg_t *msg, int mode)
{
        adapter_t       *adapter;
        rsm_addr_t      addr;
        rsm_node_id_t   node;
        int             rval = DDI_SUCCESS;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmaddr_ioctl enter\n"));

        adapter =  rsm_getadapter(msg, mode);
        if (adapter == NULL) {
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsmaddr_ioctl done: adapter not found\n"));
                return (RSMERR_CTLR_NOT_PRESENT);
        }

        switch (cmd) {
        case RSM_IOCTL_MAP_TO_ADDR: /* nodeid to hwaddr mapping */
                /* returns the hwaddr in msg->hwaddr */
                if (msg->nodeid == my_nodeid) {
                        msg->hwaddr = adapter->hwaddr;
                } else {
                        addr = get_remote_hwaddr(adapter, msg->nodeid);
                        if ((int64_t)addr < 0) {
                                rval = RSMERR_INTERNAL_ERROR;
                        } else {
                                msg->hwaddr = addr;
                        }
                }
                break;
        case RSM_IOCTL_MAP_TO_NODEID: /* hwaddr to nodeid mapping */
                /* returns the nodeid in msg->nodeid */
                if (msg->hwaddr == adapter->hwaddr) {
                        msg->nodeid = my_nodeid;
                } else {
                        node = get_remote_nodeid(adapter, msg->hwaddr);
                        if ((int)node < 0) {
                                rval = RSMERR_INTERNAL_ERROR;
                        } else {
                                msg->nodeid = (rsm_node_id_t)node;
                        }
                }
                break;
        default:
                rval = EINVAL;
                break;
        }

        rsmka_release_adapter(adapter);
        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmaddr_ioctl done: %d\n", rval));
        return (rval);
}

static int
rsm_ddi_copyin(caddr_t arg, rsm_ioctlmsg_t *msg, int mode)
{
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_IOCTL | RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_ddi_copyin enter\n"));

#ifdef _MULTI_DATAMODEL

        if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
                rsm_ioctlmsg32_t msg32;
                int i;

                if (ddi_copyin(arg, (caddr_t)&msg32, sizeof (msg32), mode)) {
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsm_ddi_copyin done: EFAULT\n"));
                        return (RSMERR_BAD_ADDR);
                }
                msg->len = msg32.len;
                msg->vaddr = (caddr_t)(uintptr_t)msg32.vaddr;
                msg->arg = (caddr_t)(uintptr_t)msg32.arg;
                msg->key = msg32.key;
                msg->acl_len = msg32.acl_len;
                msg->acl = (rsmapi_access_entry_t *)(uintptr_t)msg32.acl;
                msg->cnum = msg32.cnum;
                msg->cname = (caddr_t)(uintptr_t)msg32.cname;
                msg->cname_len = msg32.cname_len;
                msg->nodeid = msg32.nodeid;
                msg->hwaddr = msg32.hwaddr;
                msg->perm = msg32.perm;
                for (i = 0; i < 4; i++) {
                        msg->bar.comp[i].u64 = msg32.bar.comp[i].u64;
                }
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_ddi_copyin done\n"));
                return (RSM_SUCCESS);
        }
#endif
        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_ddi_copyin done\n"));
        if (ddi_copyin(arg, (caddr_t)msg, sizeof (*msg), mode))
                return (RSMERR_BAD_ADDR);
        else
                return (RSM_SUCCESS);
}

static int
rsmattr_ddi_copyout(adapter_t *adapter, caddr_t arg, int mode)
{
        rsmka_int_controller_attr_t     rsm_cattr;
        DBG_DEFINE(category,
            RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_IOCTL | RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmattr_ddi_copyout enter\n"));
        /*
         * need to copy appropriate data from rsm_controller_attr_t
         * to rsmka_int_controller_attr_t
         */
#ifdef  _MULTI_DATAMODEL
        if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
                rsmka_int_controller_attr32_t rsm_cattr32;

                rsm_cattr32.attr_direct_access_sizes =
                    adapter->rsm_attr.attr_direct_access_sizes;
                rsm_cattr32.attr_atomic_sizes =
                    adapter->rsm_attr.attr_atomic_sizes;
                rsm_cattr32.attr_page_size =
                    adapter->rsm_attr.attr_page_size;
                if (adapter->rsm_attr.attr_max_export_segment_size >
                    UINT_MAX)
                        rsm_cattr32.attr_max_export_segment_size =
                            RSM_MAXSZ_PAGE_ALIGNED;
                else
                        rsm_cattr32.attr_max_export_segment_size =
                            adapter->rsm_attr.attr_max_export_segment_size;
                if (adapter->rsm_attr.attr_tot_export_segment_size >
                    UINT_MAX)
                        rsm_cattr32.attr_tot_export_segment_size =
                            RSM_MAXSZ_PAGE_ALIGNED;
                else
                        rsm_cattr32.attr_tot_export_segment_size =
                            adapter->rsm_attr.attr_tot_export_segment_size;
                if (adapter->rsm_attr.attr_max_export_segments >
                    UINT_MAX)
                        rsm_cattr32.attr_max_export_segments =
                            UINT_MAX;
                else
                        rsm_cattr32.attr_max_export_segments =
                            adapter->rsm_attr.attr_max_export_segments;
                if (adapter->rsm_attr.attr_max_import_map_size >
                    UINT_MAX)
                        rsm_cattr32.attr_max_import_map_size =
                            RSM_MAXSZ_PAGE_ALIGNED;
                else
                        rsm_cattr32.attr_max_import_map_size =
                            adapter->rsm_attr.attr_max_import_map_size;
                if (adapter->rsm_attr.attr_tot_import_map_size >
                    UINT_MAX)
                        rsm_cattr32.attr_tot_import_map_size =
                            RSM_MAXSZ_PAGE_ALIGNED;
                else
                        rsm_cattr32.attr_tot_import_map_size =
                            adapter->rsm_attr.attr_tot_import_map_size;
                if (adapter->rsm_attr.attr_max_import_segments >
                    UINT_MAX)
                        rsm_cattr32.attr_max_import_segments =
                            UINT_MAX;
                else
                        rsm_cattr32.attr_max_import_segments =
                            adapter->rsm_attr.attr_max_import_segments;
                rsm_cattr32.attr_controller_addr =
                    adapter->rsm_attr.attr_controller_addr;

                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmattr_ddi_copyout done\n"));
                if (ddi_copyout((caddr_t)&rsm_cattr32, arg,
                    sizeof (rsmka_int_controller_attr32_t), mode)) {
                        return (RSMERR_BAD_ADDR);
                }
                else
                        return (RSM_SUCCESS);
        }
#endif
        rsm_cattr.attr_direct_access_sizes =
            adapter->rsm_attr.attr_direct_access_sizes;
        rsm_cattr.attr_atomic_sizes =
            adapter->rsm_attr.attr_atomic_sizes;
        rsm_cattr.attr_page_size =
            adapter->rsm_attr.attr_page_size;
        rsm_cattr.attr_max_export_segment_size =
            adapter->rsm_attr.attr_max_export_segment_size;
        rsm_cattr.attr_tot_export_segment_size =
            adapter->rsm_attr.attr_tot_export_segment_size;
        rsm_cattr.attr_max_export_segments =
            adapter->rsm_attr.attr_max_export_segments;
        rsm_cattr.attr_max_import_map_size =
            adapter->rsm_attr.attr_max_import_map_size;
        rsm_cattr.attr_tot_import_map_size =
            adapter->rsm_attr.attr_tot_import_map_size;
        rsm_cattr.attr_max_import_segments =
            adapter->rsm_attr.attr_max_import_segments;
        rsm_cattr.attr_controller_addr =
            adapter->rsm_attr.attr_controller_addr;
        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmattr_ddi_copyout done\n"));
        if (ddi_copyout((caddr_t)&rsm_cattr, arg,
            sizeof (rsmka_int_controller_attr_t), mode)) {
                return (RSMERR_BAD_ADDR);
        }
        else
                return (RSM_SUCCESS);
}

/*ARGSUSED*/
static int
rsm_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rvalp)
{
        rsmseg_t *seg;
        rsmresource_t   *res;
        minor_t         rnum;
        rsm_ioctlmsg_t msg = {0};
        int error;
        adapter_t *adapter;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_IOCTL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_ioctl enter\n"));

        if (cmd == RSM_IOCTL_CONSUMEEVENT) {
                error = rsm_consumeevent_ioctl((caddr_t)arg, mode);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_ioctl RSM_IOCTL_CONSUMEEVENT done: %d\n", error));
                return (error);
        }

        /* topology cmd does not use the arg common to other cmds */
        if (RSM_IOCTL_CMDGRP(cmd) == RSM_IOCTL_TOPOLOGY) {
                error = rsmka_topology_ioctl((caddr_t)arg, cmd, mode);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_ioctl done: %d\n", error));
                return (error);
        }

        if (RSM_IOCTL_CMDGRP(cmd) == RSM_IOCTL_IOVEC) {
                error = rsm_iovec_ioctl(dev, (caddr_t)arg, cmd, mode, credp);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_ioctl done: %d\n", error));
                return (error);
        }

        /*
         * try to load arguments
         */
        if (cmd != RSM_IOCTL_RING_BELL &&
            rsm_ddi_copyin((caddr_t)arg, &msg, mode)) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_ioctl done: EFAULT\n"));
                return (RSMERR_BAD_ADDR);
        }

        if (cmd == RSM_IOCTL_ATTR) {
                adapter =  rsm_getadapter(&msg, mode);
                if (adapter == NULL) {
                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsm_ioctl done: ENODEV\n"));
                        return (RSMERR_CTLR_NOT_PRESENT);
                }
                error = rsmattr_ddi_copyout(adapter, msg.arg, mode);
                rsmka_release_adapter(adapter);
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_ioctl:after copyout %d\n", error));
                return (error);
        }

        if (cmd == RSM_IOCTL_BAR_INFO) {
                /* Return library off,len of barrier page */
                msg.off = barrier_offset;
                msg.len = (int)barrier_size;
#ifdef _MULTI_DATAMODEL
                if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
                        rsm_ioctlmsg32_t msg32;

                        if (msg.len > UINT_MAX)
                                msg.len = RSM_MAXSZ_PAGE_ALIGNED;
                        else
                                msg32.len = (int32_t)msg.len;
                        msg32.off = (int32_t)msg.off;
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsm_ioctl done\n"));
                        if (ddi_copyout((caddr_t)&msg32, (caddr_t)arg,
                            sizeof (msg32), mode))
                                return (RSMERR_BAD_ADDR);
                        else
                                return (RSM_SUCCESS);
                }
#endif
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_ioctl done\n"));
                if (ddi_copyout((caddr_t)&msg, (caddr_t)arg,
                    sizeof (msg), mode))
                        return (RSMERR_BAD_ADDR);
                else
                        return (RSM_SUCCESS);
        }

        if (RSM_IOCTL_CMDGRP(cmd) == RSM_IOCTL_MAP_ADDR) {
                /* map the nodeid or hwaddr */
                error = rsmaddr_ioctl(cmd, &msg, mode);
                if (error == RSM_SUCCESS) {
#ifdef _MULTI_DATAMODEL
                        if ((mode & DATAMODEL_MASK) == DATAMODEL_ILP32) {
                                rsm_ioctlmsg32_t msg32;

                                msg32.hwaddr = (uint64_t)msg.hwaddr;
                                msg32.nodeid = (uint32_t)msg.nodeid;

                                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                                    "rsm_ioctl done\n"));
                                if (ddi_copyout((caddr_t)&msg32, (caddr_t)arg,
                                    sizeof (msg32), mode))
                                        return (RSMERR_BAD_ADDR);
                                else
                                        return (RSM_SUCCESS);
                        }
#endif
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsm_ioctl done\n"));
                        if (ddi_copyout((caddr_t)&msg, (caddr_t)arg,
                            sizeof (msg), mode))
                                return (RSMERR_BAD_ADDR);
                        else
                                return (RSM_SUCCESS);
                }
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_ioctl done: %d\n", error));
                return (error);
        }

        /* Find resource and look it in read mode */
        rnum = getminor(dev);
        res = rsmresource_lookup(rnum, RSM_NOLOCK);
        ASSERT(res != NULL);

        /*
         * Find command group
         */
        switch (RSM_IOCTL_CMDGRP(cmd)) {
        case RSM_IOCTL_EXPORT_SEG:
                /*
                 * Export list is searched during publish, loopback and
                 * remote lookup call.
                 */
                seg = rsmresource_seg(res, rnum, credp,
                    RSM_RESOURCE_EXPORT_SEGMENT);
                if (seg->s_type == RSM_RESOURCE_EXPORT_SEGMENT) {
                        error = rsmexport_ioctl(seg, &msg, cmd, arg, mode,
                            credp);
                } else { /* export ioctl on an import/barrier resource */
                        error = RSMERR_BAD_SEG_HNDL;
                }
                break;
        case RSM_IOCTL_IMPORT_SEG:
                /* Import list is searched during remote unmap call. */
                seg = rsmresource_seg(res, rnum, credp,
                    RSM_RESOURCE_IMPORT_SEGMENT);
                if (seg->s_type == RSM_RESOURCE_IMPORT_SEGMENT) {
                        error = rsmimport_ioctl(seg, &msg, cmd, arg, mode,
                            credp);
                } else  { /* import ioctl on an export/barrier resource */
                        error = RSMERR_BAD_SEG_HNDL;
                }
                break;
        case RSM_IOCTL_BAR:
                if (res != RSMRC_RESERVED &&
                    res->rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT) {
                        error = rsmbar_ioctl((rsmseg_t *)res, &msg, cmd, arg,
                            mode);
                } else { /* invalid res value */
                        error = RSMERR_BAD_SEG_HNDL;
                }
                break;
        case RSM_IOCTL_BELL:
                if (res != RSMRC_RESERVED) {
                        if (res->rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT)
                                error = exportbell_ioctl((rsmseg_t *)res, cmd);
                        else if (res->rsmrc_type == RSM_RESOURCE_EXPORT_SEGMENT)
                                error = importbell_ioctl((rsmseg_t *)res, cmd);
                        else /* RSM_RESOURCE_BAR */
                                error = RSMERR_BAD_SEG_HNDL;
                } else { /* invalid res value */
                        error = RSMERR_BAD_SEG_HNDL;
                }
                break;
        default:
                error = EINVAL;
        }

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_ioctl done: %d\n",
            error));
        return (error);
}


/* **************************** Segment Mapping Operations ********* */
static rsm_mapinfo_t *
rsm_get_mapinfo(rsmseg_t *seg, off_t off, size_t len, off_t *dev_offset,
    size_t *map_len)
{
        rsm_mapinfo_t   *p;
        /*
         * Find the correct mapinfo structure to use during the mapping
         * from the seg->s_mapinfo list.
         * The seg->s_mapinfo list contains in reverse order the mappings
         * as returned by the RSMPI rsm_map. In rsm_devmap, we need to
         * access the correct entry within this list for the mapping
         * requested.
         *
         * The algorithm for selecting a list entry is as follows:
         *
         * When start_offset of an entry <= off we have found the entry
         * we were looking for. Adjust the dev_offset and map_len (needs
         * to be PAGESIZE aligned).
         */
        p = seg->s_mapinfo;
        for (; p; p = p->next) {
                if (p->start_offset <= off) {
                        *dev_offset = p->dev_offset + off - p->start_offset;
                        *map_len = (len > p->individual_len) ?
                            p->individual_len : ptob(btopr(len));
                        return (p);
                }
                p = p->next;
        }

        return (NULL);
}

static void
rsm_free_mapinfo(rsm_mapinfo_t  *mapinfo)
{
        rsm_mapinfo_t *p;

        while (mapinfo != NULL) {
                p = mapinfo;
                mapinfo = mapinfo->next;
                kmem_free(p, sizeof (*p));
        }
}

static int
rsmmap_map(devmap_cookie_t dhp, dev_t dev, uint_t flags, offset_t off,
    size_t len, void **pvtp)
{
        rsmcookie_t     *p;
        rsmresource_t   *res;
        rsmseg_t        *seg;
        minor_t rnum;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmmap_map enter\n"));

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmmap_map: dhp = %x\n", dhp));

        flags = flags;

        rnum = getminor(dev);
        res = (rsmresource_t *)rsmresource_lookup(rnum, RSM_NOLOCK);
        ASSERT(res != NULL);

        seg = (rsmseg_t *)res;

        rsmseglock_acquire(seg);

        ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);

        /*
         * Allocate structure and add cookie to segment list
         */
        p = kmem_alloc(sizeof (*p), KM_SLEEP);

        p->c_dhp = dhp;
        p->c_off = off;
        p->c_len = len;
        p->c_next = seg->s_ckl;
        seg->s_ckl = p;

        *pvtp = (void *)seg;

        rsmseglock_release(seg);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmmap_map done\n"));
        return (DDI_SUCCESS);
}

/*
 * Page fault handling is done here. The prerequisite mapping setup
 * has been done in rsm_devmap with calls to ddi_devmem_setup or
 * ddi_umem_setup
 */
static int
rsmmap_access(devmap_cookie_t dhp, void *pvt, offset_t offset, size_t len,
    uint_t type, uint_t rw)
{
        int e;
        rsmseg_t *seg = (rsmseg_t *)pvt;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmmap_access enter\n"));

        rsmseglock_acquire(seg);

        ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);

        while (seg->s_state == RSM_STATE_MAP_QUIESCE) {
                if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsmmap_access done: cv_wait INTR"));
                        rsmseglock_release(seg);
                        return (RSMERR_INTERRUPTED);
                }
        }

        ASSERT(seg->s_state == RSM_STATE_DISCONNECT ||
            seg->s_state == RSM_STATE_ACTIVE);

        if (seg->s_state == RSM_STATE_DISCONNECT)
                seg->s_flags |= RSM_IMPORT_DUMMY;

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmmap_access: dhp = %x\n", dhp));

        rsmseglock_release(seg);

        if (e = devmap_load(dhp, offset, len, type, rw)) {
                DBG_PRINTF((category, RSM_ERR, "devmap_load failed\n"));
        }


        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmmap_access done\n"));

        return (e);
}

static int
rsmmap_dup(devmap_cookie_t dhp, void *oldpvt, devmap_cookie_t new_dhp,
    void **newpvt)
{
        rsmseg_t        *seg = (rsmseg_t *)oldpvt;
        rsmcookie_t     *p, *old;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmmap_dup enter\n"));

        /*
         * Same as map, create an entry to hold cookie and add it to
         * connect segment list. The oldpvt is a pointer to segment.
         * Return segment pointer in newpvt.
         */
        rsmseglock_acquire(seg);

        ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);

        /*
         * Find old cookie
         */
        for (old = seg->s_ckl; old != NULL; old = old->c_next) {
                if (old->c_dhp == dhp) {
                        break;
                }
        }
        if (old == NULL) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsmmap_dup done: EINVAL\n"));
                rsmseglock_release(seg);
                return (EINVAL);
        }

        p = kmem_alloc(sizeof (*p), KM_SLEEP);

        p->c_dhp = new_dhp;
        p->c_off = old->c_off;
        p->c_len = old->c_len;
        p->c_next = seg->s_ckl;
        seg->s_ckl = p;

        *newpvt = (void *)seg;

        rsmseglock_release(seg);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmmap_dup done\n"));

        return (DDI_SUCCESS);
}

static void
rsmmap_unmap(devmap_cookie_t dhp, void *pvtp, offset_t off, size_t len,
    devmap_cookie_t new_dhp1, void **pvtp1,
    devmap_cookie_t new_dhp2, void **pvtp2)
{
        /*
         * Remove pvtp structure from segment list.
         */
        rsmseg_t        *seg = (rsmseg_t *)pvtp;
        int freeflag;

        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmmap_unmap enter\n"));

        off = off; len = len;
        pvtp1 = pvtp1; pvtp2 = pvtp2;

        rsmseglock_acquire(seg);

        ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmmap_unmap: dhp = %x\n", dhp));
        /*
         * We can go ahead and remove the dhps even if we are in
         * the MAPPING state because the dhps being removed here
         * belong to a different mmap and we are holding the segment
         * lock.
         */
        if (new_dhp1 == NULL && new_dhp2 == NULL) {
                /* find and remove dhp handle */
                rsmcookie_t *tmp, **back = &seg->s_ckl;

                while (*back != NULL) {
                        tmp = *back;
                        if (tmp->c_dhp == dhp) {
                                *back = tmp->c_next;
                                kmem_free(tmp, sizeof (*tmp));
                                break;
                        }
                        back = &tmp->c_next;
                }
        } else {
                DBG_PRINTF((category, RSM_DEBUG_LVL2,
                    "rsmmap_unmap:parital unmap"
                    "new_dhp1 %lx, new_dhp2 %lx\n",
                    (size_t)new_dhp1, (size_t)new_dhp2));
        }

        /*
         * rsmmap_unmap is called for each mapping cookie on the list.
         * When the list becomes empty and we are not in the MAPPING
         * state then unmap in the rsmpi driver.
         */
        if ((seg->s_ckl == NULL) && (seg->s_state != RSM_STATE_MAPPING))
                (void) rsm_unmap(seg);

        if (seg->s_state == RSM_STATE_END && seg->s_ckl == NULL) {
                freeflag = 1;
        } else {
                freeflag = 0;
        }

        rsmseglock_release(seg);

        if (freeflag) {
                /* Free the segment structure */
                rsmseg_free(seg);
        }
        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsmmap_unmap done\n"));

}

static struct devmap_callback_ctl rsmmap_ops = {
        DEVMAP_OPS_REV, /* devmap_ops version number    */
        rsmmap_map,     /* devmap_ops map routine */
        rsmmap_access,  /* devmap_ops access routine */
        rsmmap_dup,             /* devmap_ops dup routine               */
        rsmmap_unmap,   /* devmap_ops unmap routine */
};

static int
rsm_devmap(dev_t dev, devmap_cookie_t dhc, offset_t off, size_t len,
    size_t *maplen, uint_t model /*ARGSUSED*/)
{
        struct devmap_callback_ctl *callbackops = &rsmmap_ops;
        int             err;
        uint_t          maxprot;
        minor_t         rnum;
        rsmseg_t        *seg;
        off_t           dev_offset;
        size_t          cur_len;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_devmap enter\n"));

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_devmap: off = %lx, len = %lx\n", off, len));
        rnum = getminor(dev);
        seg = (rsmseg_t *)rsmresource_lookup(rnum, RSM_NOLOCK);
        ASSERT(seg != NULL);

        if (seg->s_hdr.rsmrc_type == RSM_RESOURCE_BAR) {
                if ((off == barrier_offset) &&
                    (len == barrier_size)) {

                        ASSERT(bar_va != NULL && bar_cookie != NULL);

                        /*
                         * The offset argument in devmap_umem_setup represents
                         * the offset within the kernel memory defined by the
                         * cookie. We use this offset as barrier_offset.
                         */
                        err = devmap_umem_setup(dhc, rsm_dip, NULL, bar_cookie,
                            barrier_offset, len, PROT_USER|PROT_READ,
                            DEVMAP_DEFAULTS, 0);

                        if (err != 0) {
                                DBG_PRINTF((category, RSM_ERR,
                                    "rsm_devmap done: %d\n", err));
                                return (RSMERR_MAP_FAILED);
                        }
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsm_devmap done: %d\n", err));

                        *maplen = barrier_size;

                        return (err);
                } else {
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsm_devmap done: %d\n", err));
                        return (RSMERR_MAP_FAILED);
                }
        }

        ASSERT(seg->s_hdr.rsmrc_type == RSM_RESOURCE_IMPORT_SEGMENT);
        ASSERT(seg->s_state == RSM_STATE_MAPPING);

        /*
         * Make sure we still have permission for the map operation.
         */
        maxprot = PROT_USER;
        if (seg->s_mode & RSM_PERM_READ) {
                maxprot |= PROT_READ;
        }

        if (seg->s_mode & RSM_PERM_WRITE) {
                maxprot |= PROT_WRITE;
        }

        /*
         * For each devmap call, rsmmap_map is called. This maintains driver
         * private information for the mapping. Thus, if there are multiple
         * devmap calls there will be multiple rsmmap_map calls and for each
         * call, the mapping information will be stored.
         * In case of an error during the processing of the devmap call, error
         * will be returned. This error return causes the caller of rsm_devmap
         * to undo all the mappings by calling rsmmap_unmap for each one.
         * rsmmap_unmap will free up the private information for the requested
         * mapping.
         */
        if (seg->s_node != my_nodeid) {
                rsm_mapinfo_t *p;

                p = rsm_get_mapinfo(seg, off, len, &dev_offset, &cur_len);
                if (p == NULL) {
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsm_devmap: incorrect mapping info\n"));
                        return (RSMERR_MAP_FAILED);
                }
                err = devmap_devmem_setup(dhc, p->dip,
                    callbackops, p->dev_register,
                    dev_offset, cur_len, maxprot,
                    DEVMAP_ALLOW_REMAP | DEVMAP_DEFAULTS, 0);

                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_devmap: dip=%lx,dreg=%lu,doff=%lx,"
                    "off=%lx,len=%lx\n",
                    p->dip, p->dev_register, dev_offset, off, cur_len));

                if (err != 0) {
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsm_devmap: devmap_devmem_setup failed %d\n",
                            err));
                        return (RSMERR_MAP_FAILED);
                }
                /* cur_len is always an integral multiple pagesize */
                ASSERT((cur_len & (PAGESIZE-1)) == 0);
                *maplen = cur_len;
                return (err);

        } else {
                err = devmap_umem_setup(dhc, rsm_dip, callbackops,
                    seg->s_cookie, off, len, maxprot,
                    DEVMAP_ALLOW_REMAP|DEVMAP_DEFAULTS, 0);
                if (err != 0) {
                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsm_devmap: devmap_umem_setup failed %d\n",
                            err));
                        return (RSMERR_MAP_FAILED);
                }
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_devmap: loopback done\n"));

                *maplen = ptob(btopr(len));

                return (err);
        }
}

/*
 * We can use the devmap framework for mapping device memory to user space by
 * specifying this routine in the rsm_cb_ops structure. The kernel mmap
 * processing calls this entry point and devmap_setup is called within this
 * function, which eventually calls rsm_devmap
 */
static int
rsm_segmap(dev_t dev, off_t off, struct as *as, caddr_t *addrp, off_t len,
    uint_t prot, uint_t maxprot, uint_t flags, struct cred *cred)
{
        int                     error = 0;
        int                     old_state;
        minor_t                 rnum;
        rsmseg_t                *seg, *eseg;
        adapter_t               *adapter;
        rsm_import_share_t      *sharedp;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_DDI);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "rsm_segmap enter\n"));

        /*
         * find segment
         */
        rnum = getminor(dev);
        seg = (rsmseg_t *)rsmresource_lookup(rnum, RSM_LOCK);

        if (seg == NULL) {
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_segmap done: invalid segment\n"));
                return (EINVAL);
        }

        /*
         * the user is trying to map a resource that has not been
         * defined yet. The library uses this to map in the
         * barrier page.
         */
        if (seg->s_hdr.rsmrc_type == RSM_RESOURCE_BAR) {
                rsmseglock_release(seg);

                /*
                 * The mapping for the barrier page is identified
                 * by the special offset barrier_offset
                 */

                if (off == (off_t)barrier_offset ||
                    len == (off_t)barrier_size) {
                        if (bar_cookie == NULL || bar_va == NULL) {
                                DBG_PRINTF((category, RSM_DEBUG,
                                    "rsm_segmap: bar cookie/va is NULL\n"));
                                return (EINVAL);
                        }

                        error = devmap_setup(dev, (offset_t)off, as, addrp,
                            (size_t)len, prot, maxprot, flags,  cred);

                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsm_segmap done: %d\n", error));
                        return (error);
                } else {
                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsm_segmap: bad offset/length\n"));
                        return (EINVAL);
                }
        }

        /* Make sure you can only map imported segments */
        if (seg->s_hdr.rsmrc_type != RSM_RESOURCE_IMPORT_SEGMENT) {
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_segmap done: not an import segment\n"));
                return (EINVAL);
        }
        /* check means library is broken */
        ASSERT(seg->s_hdr.rsmrc_num == rnum);

        /* wait for the segment to become unquiesced */
        while (seg->s_state == RSM_STATE_CONN_QUIESCE) {
                if (cv_wait_sig(&seg->s_cv, &seg->s_lock) == 0) {
                        rsmseglock_release(seg);
                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsm_segmap done: cv_wait INTR"));
                        return (ENODEV);
                }
        }

        /* wait until segment leaves the mapping state */
        while (seg->s_state == RSM_STATE_MAPPING)
                cv_wait(&seg->s_cv, &seg->s_lock);

        /*
         * we allow multiple maps of the same segment in the KA
         * and it works because we do an rsmpi map of the whole
         * segment during the first map and all the device mapping
         * information needed in rsm_devmap is in the mapinfo list.
         */
        if ((seg->s_state != RSM_STATE_CONNECT) &&
            (seg->s_state != RSM_STATE_ACTIVE)) {
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_segmap done: segment not connected\n"));
                return (ENODEV);
        }

        /*
         * Make sure we are not mapping a larger segment than what's
         * exported
         */
        if ((size_t)off + ptob(btopr(len)) > seg->s_len) {
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_segmap done: off+len>seg size\n"));
                return (ENXIO);
        }

        /*
         * Make sure we still have permission for the map operation.
         */
        maxprot = PROT_USER;
        if (seg->s_mode & RSM_PERM_READ) {
                maxprot |= PROT_READ;
        }

        if (seg->s_mode & RSM_PERM_WRITE) {
                maxprot |= PROT_WRITE;
        }

        if ((prot & maxprot) != prot) {
                /* No permission */
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_segmap done: no permission\n"));
                return (EACCES);
        }

        old_state = seg->s_state;

        ASSERT(seg->s_share != NULL);

        rsmsharelock_acquire(seg);

        sharedp = seg->s_share;

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_segmap:RSMSI_STATE=%d\n", sharedp->rsmsi_state));

        if ((sharedp->rsmsi_state != RSMSI_STATE_CONNECTED) &&
            (sharedp->rsmsi_state != RSMSI_STATE_MAPPED)) {
                rsmsharelock_release(seg);
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_DEBUG,
                    "rsm_segmap done:RSMSI_STATE %d invalid\n",
                    sharedp->rsmsi_state));
                return (ENODEV);
        }

        /*
         * Do the map - since we want importers to share mappings
         * we do the rsmpi map for the whole segment
         */
        if (seg->s_node != my_nodeid) {
                uint_t dev_register;
                off_t dev_offset;
                dev_info_t *dip;
                size_t tmp_len;
                size_t total_length_mapped = 0;
                size_t length_to_map = seg->s_len;
                off_t tmp_off = 0;
                rsm_mapinfo_t *p;

                /*
                 * length_to_map = seg->s_len is always an integral
                 * multiple of PAGESIZE. Length mapped in each entry in mapinfo
                 * list is a multiple of PAGESIZE - RSMPI map ensures this
                 */

                adapter = seg->s_adapter;
                ASSERT(sharedp->rsmsi_state == RSMSI_STATE_CONNECTED ||
                    sharedp->rsmsi_state == RSMSI_STATE_MAPPED);

                if (sharedp->rsmsi_state == RSMSI_STATE_CONNECTED) {
                        error = 0;
                        /* map the whole segment */
                        while (total_length_mapped < seg->s_len) {
                                tmp_len = 0;

                                error = adapter->rsmpi_ops->rsm_map(
                                    seg->s_handle.in, tmp_off,
                                    length_to_map, &tmp_len,
                                    &dip, &dev_register, &dev_offset,
                                    NULL, NULL);

                                if (error != 0)
                                        break;

                                /*
                                 * Store the mapping info obtained from rsm_map
                                 */
                                p = kmem_alloc(sizeof (*p), KM_SLEEP);
                                p->dev_register = dev_register;
                                p->dev_offset = dev_offset;
                                p->dip = dip;
                                p->individual_len = tmp_len;
                                p->start_offset = tmp_off;
                                p->next = sharedp->rsmsi_mapinfo;
                                sharedp->rsmsi_mapinfo = p;

                                total_length_mapped += tmp_len;
                                length_to_map -= tmp_len;
                                tmp_off += tmp_len;
                        }
                        seg->s_mapinfo = sharedp->rsmsi_mapinfo;

                        if (error != RSM_SUCCESS) {
                                /* Check if this is the the first rsm_map */
                                if (sharedp->rsmsi_mapinfo != NULL) {
                                        /*
                                         * A single rsm_unmap undoes
                                         * multiple rsm_maps.
                                         */
                                        (void) seg->s_adapter->rsmpi_ops->
                                            rsm_unmap(sharedp->rsmsi_handle);
                                        rsm_free_mapinfo(sharedp->
                                            rsmsi_mapinfo);
                                }
                                sharedp->rsmsi_mapinfo = NULL;
                                sharedp->rsmsi_state = RSMSI_STATE_CONNECTED;
                                rsmsharelock_release(seg);
                                rsmseglock_release(seg);
                                DBG_PRINTF((category, RSM_DEBUG,
                                    "rsm_segmap done: rsmpi map err %d\n",
                                    error));
                                ASSERT(error != RSMERR_BAD_LENGTH &&
                                    error != RSMERR_BAD_MEM_ALIGNMENT &&
                                    error != RSMERR_BAD_SEG_HNDL);
                                if (error == RSMERR_UNSUPPORTED_OPERATION)
                                        return (ENOTSUP);
                                else if (error == RSMERR_INSUFFICIENT_RESOURCES)
                                        return (EAGAIN);
                                else if (error == RSMERR_CONN_ABORTED)
                                        return (ENODEV);
                                else
                                        return (error);
                        } else {
                                sharedp->rsmsi_state = RSMSI_STATE_MAPPED;
                        }
                } else {
                        seg->s_mapinfo = sharedp->rsmsi_mapinfo;
                }

                sharedp->rsmsi_mapcnt++;

                rsmsharelock_release(seg);

                /* move to an intermediate mapping state */
                seg->s_state = RSM_STATE_MAPPING;
                rsmseglock_release(seg);

                error = devmap_setup(dev, (offset_t)off, as, addrp,
                    len, prot, maxprot, flags, cred);

                rsmseglock_acquire(seg);
                ASSERT(seg->s_state == RSM_STATE_MAPPING);

                if (error == DDI_SUCCESS) {
                        seg->s_state = RSM_STATE_ACTIVE;
                } else {
                        rsmsharelock_acquire(seg);

                        ASSERT(sharedp->rsmsi_state == RSMSI_STATE_MAPPED);

                        sharedp->rsmsi_mapcnt--;
                        if (sharedp->rsmsi_mapcnt == 0) {
                                /* unmap the shared RSMPI mapping */
                                ASSERT(sharedp->rsmsi_handle != NULL);
                                (void) adapter->rsmpi_ops->
                                    rsm_unmap(sharedp->rsmsi_handle);
                                rsm_free_mapinfo(sharedp->rsmsi_mapinfo);
                                sharedp->rsmsi_mapinfo = NULL;
                                sharedp->rsmsi_state = RSMSI_STATE_CONNECTED;
                        }

                        rsmsharelock_release(seg);
                        seg->s_state = old_state;
                        DBG_PRINTF((category, RSM_ERR,
                            "rsm: devmap_setup failed %d\n", error));
                }
                cv_broadcast(&seg->s_cv);
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_DEBUG_LVL2, "rsm_segmap done: %d\n",
                    error));
                return (error);
        } else {
                /*
                 * For loopback, the export segment mapping cookie (s_cookie)
                 * is also used as the s_cookie value for its import segments
                 * during mapping.
                 * Note that reference counting for s_cookie of the export
                 * segment is not required due to the following:
                 * We never have a case of the export segment being destroyed,
                 * leaving the import segments with a stale value for the
                 * s_cookie field, since a force disconnect is done prior to a
                 * destroy of an export segment. The force disconnect causes
                 * the s_cookie value to be reset to NULL. Also for the
                 * rsm_rebind operation, we change the s_cookie value of the
                 * export segment as well as of all its local (loopback)
                 * importers.
                 */
                DBG_ADDCATEGORY(category, RSM_LOOPBACK);

                rsmsharelock_release(seg);
                /*
                 * In order to maintain the lock ordering between the export
                 * and import segment locks, we need to acquire the export
                 * segment lock first and only then acquire the import
                 * segment lock.
                 * The above is necessary to avoid any deadlock scenarios
                 * with rsm_rebind which also acquires both the export
                 * and import segment locks in the above mentioned order.
                 * Based on code inspection, there seem to be no other
                 * situations in which both the export and import segment
                 * locks are acquired either in the same or opposite order
                 * as mentioned above.
                 * Thus in order to conform to the above lock order, we
                 * need to change the state of the import segment to
                 * RSM_STATE_MAPPING, release the lock. Once this is done we
                 * can now safely acquire the export segment lock first
                 * followed by the import segment lock which is as per
                 * the lock order mentioned above.
                 */
                /* move to an intermediate mapping state */
                seg->s_state = RSM_STATE_MAPPING;
                rsmseglock_release(seg);

                eseg = rsmexport_lookup(seg->s_key);

                if (eseg == NULL) {
                        rsmseglock_acquire(seg);
                        /*
                         * Revert to old_state and signal any waiters
                         * The shared state is not changed
                         */

                        seg->s_state = old_state;
                        cv_broadcast(&seg->s_cv);
                        rsmseglock_release(seg);
                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsm_segmap done: key %d not found\n", seg->s_key));
                        return (ENODEV);
                }

                rsmsharelock_acquire(seg);
                ASSERT(sharedp->rsmsi_state == RSMSI_STATE_CONNECTED ||
                    sharedp->rsmsi_state == RSMSI_STATE_MAPPED);

                sharedp->rsmsi_mapcnt++;
                sharedp->rsmsi_state = RSMSI_STATE_MAPPED;
                rsmsharelock_release(seg);

                ASSERT(eseg->s_cookie != NULL);

                /*
                 * It is not required or necessary to acquire the import
                 * segment lock here to change the value of s_cookie since
                 * no one will touch the import segment as long as it is
                 * in the RSM_STATE_MAPPING state.
                 */
                seg->s_cookie = eseg->s_cookie;

                rsmseglock_release(eseg);

                error = devmap_setup(dev, (offset_t)off, as, addrp, (size_t)len,
                    prot, maxprot, flags, cred);

                rsmseglock_acquire(seg);
                ASSERT(seg->s_state == RSM_STATE_MAPPING);
                if (error == 0) {
                        seg->s_state = RSM_STATE_ACTIVE;
                } else {
                        rsmsharelock_acquire(seg);

                        ASSERT(sharedp->rsmsi_state == RSMSI_STATE_MAPPED);

                        sharedp->rsmsi_mapcnt--;
                        if (sharedp->rsmsi_mapcnt == 0) {
                                sharedp->rsmsi_mapinfo = NULL;
                                sharedp->rsmsi_state = RSMSI_STATE_CONNECTED;
                        }
                        rsmsharelock_release(seg);
                        seg->s_state = old_state;
                        seg->s_cookie = NULL;
                }
                cv_broadcast(&seg->s_cv);
                rsmseglock_release(seg);
                DBG_PRINTF((category, RSM_DEBUG_LVL2,
                    "rsm_segmap done: %d\n", error));
                return (error);
        }
}

int
rsmka_null_seg_create(
    rsm_controller_handle_t argcp,
    rsm_memseg_export_handle_t *handle,
    size_t size,
    uint_t flags,
    rsm_memory_local_t *memory,
    rsm_resource_callback_t callback,
    rsm_resource_callback_arg_t callback_arg    /*ARGSUSED*/)
{
        return (RSM_SUCCESS);
}


int
rsmka_null_seg_destroy(
    rsm_memseg_export_handle_t argmemseg        /*ARGSUSED*/)
{
        return (RSM_SUCCESS);
}


int
rsmka_null_bind(
    rsm_memseg_export_handle_t argmemseg,
    off_t offset,
    rsm_memory_local_t *argmemory,
    rsm_resource_callback_t callback,
    rsm_resource_callback_arg_t callback_arg    /*ARGSUSED*/)
{
        return (RSM_SUCCESS);
}


int
rsmka_null_unbind(
    rsm_memseg_export_handle_t argmemseg,
    off_t offset,
    size_t length       /*ARGSUSED*/)
{
        return (DDI_SUCCESS);
}

int
rsmka_null_rebind(
    rsm_memseg_export_handle_t argmemseg,
    off_t offset,
    rsm_memory_local_t *memory,
    rsm_resource_callback_t callback,
    rsm_resource_callback_arg_t callback_arg    /*ARGSUSED*/)
{
        return (RSM_SUCCESS);
}

int
rsmka_null_publish(
    rsm_memseg_export_handle_t argmemseg,
    rsm_access_entry_t access_list[],
    uint_t access_list_length,
    rsm_memseg_id_t segment_id,
    rsm_resource_callback_t callback,
    rsm_resource_callback_arg_t callback_arg    /*ARGSUSED*/)
{
        return (RSM_SUCCESS);
}


int
rsmka_null_republish(
    rsm_memseg_export_handle_t memseg,
    rsm_access_entry_t access_list[],
    uint_t access_list_length,
    rsm_resource_callback_t callback,
    rsm_resource_callback_arg_t callback_arg    /*ARGSUSED*/)
{
        return (RSM_SUCCESS);
}

int
rsmka_null_unpublish(
    rsm_memseg_export_handle_t argmemseg        /*ARGSUSED*/)
{
        return (RSM_SUCCESS);
}


void
rsmka_init_loopback()
{
        rsm_ops_t       *ops = &null_rsmpi_ops;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL | RSM_LOOPBACK);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmka_init_loopback enter\n"));

        /* initialize null ops vector */
        ops->rsm_seg_create = rsmka_null_seg_create;
        ops->rsm_seg_destroy = rsmka_null_seg_destroy;
        ops->rsm_bind = rsmka_null_bind;
        ops->rsm_unbind = rsmka_null_unbind;
        ops->rsm_rebind = rsmka_null_rebind;
        ops->rsm_publish = rsmka_null_publish;
        ops->rsm_unpublish = rsmka_null_unpublish;
        ops->rsm_republish = rsmka_null_republish;

        /* initialize attributes for loopback adapter */
        loopback_attr.attr_name = loopback_str;
        loopback_attr.attr_page_size = 0x8; /* 8K */

        /* initialize loopback adapter */
        loopback_adapter.rsm_attr = loopback_attr;
        loopback_adapter.rsmpi_ops = &null_rsmpi_ops;
        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsmka_init_loopback done\n"));
}

/* ************** DR functions ********************************** */
static void
rsm_quiesce_exp_seg(rsmresource_t *resp)
{
        int             recheck_state;
        rsmseg_t        *segp = (rsmseg_t *)resp;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);
        DBG_DEFINE_STR(function, "rsm_unquiesce_exp_seg");

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "%s enter: key=%u\n", function, segp->s_key));

        rsmseglock_acquire(segp);
        do {
                recheck_state = 0;
                if ((segp->s_state == RSM_STATE_NEW_QUIESCED) ||
                    (segp->s_state == RSM_STATE_BIND_QUIESCED) ||
                    (segp->s_state == RSM_STATE_EXPORT_QUIESCING) ||
                    (segp->s_state == RSM_STATE_EXPORT_QUIESCED)) {
                        rsmseglock_release(segp);
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "%s done:state =%d\n", function,
                            segp->s_state));
                        return;
                }

                if (segp->s_state == RSM_STATE_NEW) {
                        segp->s_state = RSM_STATE_NEW_QUIESCED;
                        rsmseglock_release(segp);
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "%s done:state =%d\n", function,
                            segp->s_state));
                        return;
                }

                if (segp->s_state == RSM_STATE_BIND) {
                        /* unbind */
                        (void) rsm_unbind_pages(segp);
                        segp->s_state = RSM_STATE_BIND_QUIESCED;
                        rsmseglock_release(segp);
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "%s done:state =%d\n", function,
                            segp->s_state));
                        return;
                }

                if (segp->s_state == RSM_STATE_EXPORT) {
                        /*
                         * wait for putv/getv to complete if the segp is
                         * a local memory handle
                         */
                        while ((segp->s_state == RSM_STATE_EXPORT) &&
                            (segp->s_rdmacnt != 0)) {
                                cv_wait(&segp->s_cv, &segp->s_lock);
                        }

                        if (segp->s_state != RSM_STATE_EXPORT) {
                                /*
                                 * state changed need to see what it
                                 * should be changed to.
                                 */
                                recheck_state = 1;
                                continue;
                        }

                        segp->s_state = RSM_STATE_EXPORT_QUIESCING;
                        rsmseglock_release(segp);
                        /*
                         * send SUSPEND messages - currently it will be
                         * done at the end
                         */
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "%s done:state =%d\n", function,
                            segp->s_state));
                        return;
                }
        } while (recheck_state);

        rsmseglock_release(segp);
}

static void
rsm_unquiesce_exp_seg(rsmresource_t *resp)
{
        int                     ret;
        rsmseg_t                *segp = (rsmseg_t *)resp;
        rsmapi_access_entry_t   *acl;
        rsm_access_entry_t      *rsmpi_acl;
        int                     acl_len;
        int                     create_flags = 0;
        struct buf              *xbuf;
        rsm_memory_local_t      mem;
        adapter_t               *adapter;
        dev_t                   sdev = 0;
        rsm_resource_callback_t callback_flag;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);
        DBG_DEFINE_STR(function, "rsm_unquiesce_exp_seg");

        rsmseglock_acquire(segp);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "%s enter: key=%u, state=%d\n", function, segp->s_key,
            segp->s_state));

        if ((segp->s_state == RSM_STATE_NEW) ||
            (segp->s_state == RSM_STATE_BIND) ||
            (segp->s_state == RSM_STATE_EXPORT)) {
                rsmseglock_release(segp);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "%s done:state=%d\n",
                    function, segp->s_state));
                return;
        }

        if (segp->s_state == RSM_STATE_NEW_QUIESCED) {
                segp->s_state = RSM_STATE_NEW;
                cv_broadcast(&segp->s_cv);
                rsmseglock_release(segp);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "%s done:state=%d\n",
                    function, segp->s_state));
                return;
        }

        if (segp->s_state == RSM_STATE_BIND_QUIESCED) {
                /* bind the segment */
                ret = rsm_bind_pages(&segp->s_cookie, segp->s_region.r_vaddr,
                    segp->s_len, segp->s_proc);
                if (ret == RSM_SUCCESS) { /* bind successful */
                        segp->s_state = RSM_STATE_BIND;
                } else { /* bind failed - resource unavailable */
                        segp->s_state = RSM_STATE_NEW;
                }
                cv_broadcast(&segp->s_cv);
                rsmseglock_release(segp);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "%s done: bind_qscd bind = %d\n", function, ret));
                return;
        }

        while (segp->s_state == RSM_STATE_EXPORT_QUIESCING) {
                /* wait for the segment to move to EXPORT_QUIESCED state */
                cv_wait(&segp->s_cv, &segp->s_lock);
        }

        if (segp->s_state == RSM_STATE_EXPORT_QUIESCED) {
                /* bind the segment */
                ret = rsm_bind_pages(&segp->s_cookie, segp->s_region.r_vaddr,
                    segp->s_len, segp->s_proc);

                if (ret != RSM_SUCCESS) {
                        /* bind failed - resource unavailable */
                        acl_len = segp->s_acl_len;
                        acl = segp->s_acl;
                        rsmpi_acl = segp->s_acl_in;
                        segp->s_acl_len = 0;
                        segp->s_acl = NULL;
                        segp->s_acl_in = NULL;
                        rsmseglock_release(segp);

                        rsmexport_rm(segp);
                        rsmacl_free(acl, acl_len);
                        rsmpiacl_free(rsmpi_acl, acl_len);

                        rsmseglock_acquire(segp);
                        segp->s_state = RSM_STATE_NEW;
                        cv_broadcast(&segp->s_cv);
                        rsmseglock_release(segp);
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "%s done: exp_qscd bind failed = %d\n",
                            function, ret));
                        return;
                }
                /*
                 * publish the segment
                 * if  successful
                 *   segp->s_state = RSM_STATE_EXPORT;
                 * else failed
                 *   segp->s_state = RSM_STATE_BIND;
                 */

                /* check whether it is a local_memory_handle */
                if (segp->s_acl != (rsmapi_access_entry_t *)NULL) {
                        if ((segp->s_acl[0].ae_node == my_nodeid) &&
                            (segp->s_acl[0].ae_permission == 0)) {
                                segp->s_state = RSM_STATE_EXPORT;
                                cv_broadcast(&segp->s_cv);
                                rsmseglock_release(segp);
                                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                                    "%s done:exp_qscd\n", function));
                                return;
                        }
                }
                xbuf = ddi_umem_iosetup(segp->s_cookie, 0, segp->s_len, B_WRITE,
                    sdev, 0, NULL, DDI_UMEM_SLEEP);
                ASSERT(xbuf != NULL);

                mem.ms_type = RSM_MEM_BUF;
                mem.ms_bp = xbuf;

                adapter = segp->s_adapter;

                if (segp->s_flags & RSMKA_ALLOW_UNBIND_REBIND) {
                        create_flags = RSM_ALLOW_UNBIND_REBIND;
                }

                if (segp->s_flags & RSMKA_SET_RESOURCE_DONTWAIT) {
                        callback_flag  = RSM_RESOURCE_DONTWAIT;
                } else {
                        callback_flag  = RSM_RESOURCE_SLEEP;
                }

                ret = adapter->rsmpi_ops->rsm_seg_create(
                    adapter->rsmpi_handle, &segp->s_handle.out,
                    segp->s_len, create_flags, &mem,
                    callback_flag, NULL);

                if (ret != RSM_SUCCESS) {
                        acl_len = segp->s_acl_len;
                        acl = segp->s_acl;
                        rsmpi_acl = segp->s_acl_in;
                        segp->s_acl_len = 0;
                        segp->s_acl = NULL;
                        segp->s_acl_in = NULL;
                        rsmseglock_release(segp);

                        rsmexport_rm(segp);
                        rsmacl_free(acl, acl_len);
                        rsmpiacl_free(rsmpi_acl, acl_len);

                        rsmseglock_acquire(segp);
                        segp->s_state = RSM_STATE_BIND;
                        cv_broadcast(&segp->s_cv);
                        rsmseglock_release(segp);
                        DBG_PRINTF((category, RSM_ERR,
                            "%s done: exp_qscd create failed = %d\n",
                            function, ret));
                        return;
                }

                ret = adapter->rsmpi_ops->rsm_publish(
                    segp->s_handle.out, segp->s_acl_in, segp->s_acl_len,
                    segp->s_segid, RSM_RESOURCE_DONTWAIT, NULL);

                if (ret != RSM_SUCCESS) {
                        acl_len = segp->s_acl_len;
                        acl = segp->s_acl;
                        rsmpi_acl = segp->s_acl_in;
                        segp->s_acl_len = 0;
                        segp->s_acl = NULL;
                        segp->s_acl_in = NULL;
                        adapter->rsmpi_ops->rsm_seg_destroy(segp->s_handle.out);
                        rsmseglock_release(segp);

                        rsmexport_rm(segp);
                        rsmacl_free(acl, acl_len);
                        rsmpiacl_free(rsmpi_acl, acl_len);

                        rsmseglock_acquire(segp);
                        segp->s_state = RSM_STATE_BIND;
                        cv_broadcast(&segp->s_cv);
                        rsmseglock_release(segp);
                        DBG_PRINTF((category, RSM_ERR,
                            "%s done: exp_qscd publish failed = %d\n",
                            function, ret));
                        return;
                }

                segp->s_state = RSM_STATE_EXPORT;
                cv_broadcast(&segp->s_cv);
                rsmseglock_release(segp);
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "%s done: exp_qscd\n",
                    function));
                return;
        }

        rsmseglock_release(segp);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "%s done\n", function));
}

static void
rsm_quiesce_imp_seg(rsmresource_t *resp)
{
        rsmseg_t        *segp = (rsmseg_t *)resp;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);
        DBG_DEFINE_STR(function, "rsm_quiesce_imp_seg");

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "%s enter: key=%u\n", function, segp->s_key));

        rsmseglock_acquire(segp);
        segp->s_flags |= RSM_DR_INPROGRESS;

        while (segp->s_rdmacnt != 0) {
                /* wait for the RDMA to complete */
                cv_wait(&segp->s_cv, &segp->s_lock);
        }

        rsmseglock_release(segp);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "%s done\n", function));

}

static void
rsm_unquiesce_imp_seg(rsmresource_t *resp)
{
        rsmseg_t        *segp = (rsmseg_t *)resp;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);
        DBG_DEFINE_STR(function, "rsm_unquiesce_imp_seg");

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "%s enter: key=%u\n", function, segp->s_key));

        rsmseglock_acquire(segp);

        segp->s_flags &= ~RSM_DR_INPROGRESS;
        /* wake up any waiting putv/getv ops */
        cv_broadcast(&segp->s_cv);

        rsmseglock_release(segp);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE, "%s done\n", function));


}

static void
rsm_process_exp_seg(rsmresource_t *resp, int event)
{
        if (event == RSM_DR_QUIESCE)
                rsm_quiesce_exp_seg(resp);
        else /* UNQUIESCE */
                rsm_unquiesce_exp_seg(resp);
}

static void
rsm_process_imp_seg(rsmresource_t *resp, int event)
{
        if (event == RSM_DR_QUIESCE)
                rsm_quiesce_imp_seg(resp);
        else /* UNQUIESCE */
                rsm_unquiesce_imp_seg(resp);
}

static void
rsm_dr_process_local_segments(int event)
{

        int i, j;
        rsmresource_blk_t       *blk;
        rsmresource_t           *p;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_dr_process_local_segments enter\n"));

        /* iterate through the resource structure */

        rw_enter(&rsm_resource.rsmrc_lock, RW_READER);

        for (i = 0; i < rsm_resource.rsmrc_len; i++) {
                blk = rsm_resource.rsmrc_root[i];
                if (blk != NULL) {
                        for (j = 0; j < RSMRC_BLKSZ; j++) {
                                p = blk->rsmrcblk_blks[j];
                                if ((p != NULL) && (p != RSMRC_RESERVED)) {
                                        /* valid resource */
                                        if (p->rsmrc_type ==
                                            RSM_RESOURCE_EXPORT_SEGMENT)
                                                rsm_process_exp_seg(p, event);
                                        else if (p->rsmrc_type ==
                                            RSM_RESOURCE_IMPORT_SEGMENT)
                                                rsm_process_imp_seg(p, event);
                                }
                        }
                }
        }

        rw_exit(&rsm_resource.rsmrc_lock);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_dr_process_local_segments done\n"));
}

/* *************** DR callback functions ************ */
static void
rsm_dr_callback_post_add(void *arg, pgcnt_t delta /* ARGSUSED */)
{
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);
        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_dr_callback_post_add is a no-op\n"));
        /* Noop */
}

static int
rsm_dr_callback_pre_del(void *arg, pgcnt_t delta /* ARGSUSED */)
{
        int     recheck_state = 0;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_dr_callback_pre_del enter\n"));

        mutex_enter(&rsm_drv_data.drv_lock);

        do {
                recheck_state = 0;
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_dr_callback_pre_del:state=%d\n",
                    rsm_drv_data.drv_state));

                switch (rsm_drv_data.drv_state) {
                case RSM_DRV_NEW:
                        /*
                         * The state should usually never be RSM_DRV_NEW
                         * since in this state the callbacks have not yet
                         * been registered. So, ASSERT.
                         */
                        ASSERT(0);
                        return (0);
                case RSM_DRV_REG_PROCESSING:
                        /*
                         * The driver is in the process of registering
                         * with the DR framework. So, wait till the
                         * registration process is complete.
                         */
                        recheck_state = 1;
                        cv_wait(&rsm_drv_data.drv_cv, &rsm_drv_data.drv_lock);
                        break;
                case RSM_DRV_UNREG_PROCESSING:
                        /*
                         * If the state is RSM_DRV_UNREG_PROCESSING, the
                         * module is in the process of detaching and
                         * unregistering the callbacks from the DR
                         * framework. So, simply return.
                         */
                        mutex_exit(&rsm_drv_data.drv_lock);
                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsm_dr_callback_pre_del:"
                            "pre-del on NEW/UNREG\n"));
                        return (0);
                case RSM_DRV_OK:
                        rsm_drv_data.drv_state = RSM_DRV_PREDEL_STARTED;
                        break;
                case RSM_DRV_PREDEL_STARTED:
                        /* FALLTHRU */
                case RSM_DRV_PREDEL_COMPLETED:
                        /* FALLTHRU */
                case RSM_DRV_POSTDEL_IN_PROGRESS:
                        recheck_state = 1;
                        cv_wait(&rsm_drv_data.drv_cv, &rsm_drv_data.drv_lock);
                        break;
                case RSM_DRV_DR_IN_PROGRESS:
                        rsm_drv_data.drv_memdel_cnt++;
                        mutex_exit(&rsm_drv_data.drv_lock);
                        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                            "rsm_dr_callback_pre_del done\n"));
                        return (0);
                        /* break; */
                default:
                        ASSERT(0);
                        break;
                }

        } while (recheck_state);

        rsm_drv_data.drv_memdel_cnt++;

        mutex_exit(&rsm_drv_data.drv_lock);

        /* Do all the quiescing stuff here */
        DBG_PRINTF((category, RSM_DEBUG,
            "rsm_dr_callback_pre_del: quiesce things now\n"));

        rsm_dr_process_local_segments(RSM_DR_QUIESCE);

        /*
         * now that all local segments have been quiesced lets inform
         * the importers
         */
        rsm_send_suspend();

        /*
         * In response to the suspend message the remote node(s) will process
         * the segments and send a suspend_complete message. Till all
         * the nodes send the suspend_complete message we wait in the
         * RSM_DRV_PREDEL_STARTED state. In the exporter_quiesce
         * function we transition to the RSM_DRV_PREDEL_COMPLETED state.
         */
        mutex_enter(&rsm_drv_data.drv_lock);

        while (rsm_drv_data.drv_state == RSM_DRV_PREDEL_STARTED) {
                cv_wait(&rsm_drv_data.drv_cv, &rsm_drv_data.drv_lock);
        }

        ASSERT(rsm_drv_data.drv_state == RSM_DRV_PREDEL_COMPLETED);

        rsm_drv_data.drv_state = RSM_DRV_DR_IN_PROGRESS;
        cv_broadcast(&rsm_drv_data.drv_cv);

        mutex_exit(&rsm_drv_data.drv_lock);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_dr_callback_pre_del done\n"));

        return (0);
}

static void
rsm_dr_callback_post_del(void *arg, pgcnt_t delta, int cancelled /* ARGSUSED */)
{
        int     recheck_state = 0;
        DBG_DEFINE(category, RSM_KERNEL_AGENT | RSM_FUNC_ALL);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_dr_callback_post_del enter\n"));

        mutex_enter(&rsm_drv_data.drv_lock);

        do {
                recheck_state = 0;
                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                    "rsm_dr_callback_post_del:state=%d\n",
                    rsm_drv_data.drv_state));

                switch (rsm_drv_data.drv_state) {
                case RSM_DRV_NEW:
                        /*
                         * The driver state cannot not be RSM_DRV_NEW
                         * since in this state the callbacks have not
                         * yet been registered.
                         */
                        ASSERT(0);
                        return;
                case RSM_DRV_REG_PROCESSING:
                        /*
                         * The driver is in the process of registering with
                         * the DR framework. Wait till the registration is
                         * complete.
                         */
                        recheck_state = 1;
                        cv_wait(&rsm_drv_data.drv_cv, &rsm_drv_data.drv_lock);
                        break;
                case RSM_DRV_UNREG_PROCESSING:
                        /*
                         * RSM_DRV_UNREG_PROCESSING state means the module
                         * is detaching and unregistering the callbacks
                         * from the DR framework. So simply return.
                         */
                        /* FALLTHRU */
                case RSM_DRV_OK:
                        /*
                         * RSM_DRV_OK means we missed the pre-del
                         * corresponding to this post-del coz we had not
                         * registered yet, so simply return.
                         */
                        mutex_exit(&rsm_drv_data.drv_lock);
                        DBG_PRINTF((category, RSM_DEBUG,
                            "rsm_dr_callback_post_del:"
                            "post-del on OK/UNREG\n"));
                        return;
                        /* break; */
                case RSM_DRV_PREDEL_STARTED:
                        /* FALLTHRU */
                case RSM_DRV_PREDEL_COMPLETED:
                        /* FALLTHRU */
                case RSM_DRV_POSTDEL_IN_PROGRESS:
                        recheck_state = 1;
                        cv_wait(&rsm_drv_data.drv_cv, &rsm_drv_data.drv_lock);
                        break;
                case RSM_DRV_DR_IN_PROGRESS:
                        rsm_drv_data.drv_memdel_cnt--;
                        if (rsm_drv_data.drv_memdel_cnt > 0) {
                                mutex_exit(&rsm_drv_data.drv_lock);
                                DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
                                    "rsm_dr_callback_post_del done:\n"));
                                return;
                        }
                        rsm_drv_data.drv_state = RSM_DRV_POSTDEL_IN_PROGRESS;
                        break;
                default:
                        ASSERT(0);
                        return;
                        /* break; */
                }
        } while (recheck_state);

        mutex_exit(&rsm_drv_data.drv_lock);

        /* Do all the unquiescing stuff here */
        DBG_PRINTF((category, RSM_DEBUG,
            "rsm_dr_callback_post_del: unquiesce things now\n"));

        rsm_dr_process_local_segments(RSM_DR_UNQUIESCE);

        /*
         * now that all local segments have been unquiesced lets inform
         * the importers
         */
        rsm_send_resume();

        mutex_enter(&rsm_drv_data.drv_lock);

        rsm_drv_data.drv_state = RSM_DRV_OK;

        cv_broadcast(&rsm_drv_data.drv_cv);

        mutex_exit(&rsm_drv_data.drv_lock);

        DBG_PRINTF((category, RSM_DEBUG_VERBOSE,
            "rsm_dr_callback_post_del done\n"));

        return;

}