ns/nsctl/nsc_dev.c

/*
 * 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.
 */

#include <sys/types.h>
#include <sys/debug.h>
#include <sys/ksynch.h>
#include <sys/kmem.h>
#include <sys/cmn_err.h>
#include <sys/errno.h>
#include <sys/ddi.h>

#include <sys/ncall/ncall.h>

#define __NSC_GEN__
#include "nsc_dev.h"

#ifdef DS_DDICT
#include "../contract.h"
#endif

#include "../nsctl.h"

#define NSC_DEVMIN  "DevMin"
#define NSC_DEVMAJ  "DevMaj"

#define _I(x)   (((long)(&((nsc_io_t *)0)->x))/sizeof (long))
#define _F(x)   (((long)(&((nsc_fd_t *)0)->x))/sizeof (long))


nsc_def_t _nsc_io_def[] = {
    "Open",     (uintptr_t)nsc_null,    _I(open),
    "Close",    (uintptr_t)nsc_null,    _I(close),
    "Attach",   (uintptr_t)nsc_null,    _I(attach),
    "Detach",   (uintptr_t)nsc_null,    _I(detach),
    "Flush",    (uintptr_t)nsc_null,    _I(flush),
    "Provide",  0,      _I(provide),
    0,      0,      0
};

nsc_def_t _nsc_fd_def[] = {
    "Pinned",   (uintptr_t)nsc_null,    _F(sf_pinned),
    "Unpinned", (uintptr_t)nsc_null,    _F(sf_unpinned),
    "Attach",   (uintptr_t)nsc_null,    _F(sf_attach),
    "Detach",   (uintptr_t)nsc_null,    _F(sf_detach),
    "Flush",    (uintptr_t)nsc_null,    _F(sf_flush),
    0,      0,      0
};

kmutex_t _nsc_io_lock;
kmutex_t _nsc_devval_lock;

nsc_io_t *_nsc_io_top = NULL;
nsc_io_t *_nsc_null_io = NULL;
nsc_dev_t *_nsc_dev_top = NULL;
nsc_dev_t *_nsc_dev_pend = NULL;
nsc_path_t *_nsc_path_top = NULL;
nsc_devval_t *_nsc_devval_top = NULL;

extern nsc_def_t _nsc_disk_def[];
extern nsc_def_t _nsc_cache_def[];

extern nsc_mem_t *_nsc_local_mem;
extern nsc_rmmap_t *_nsc_global_map;

static clock_t _nsc_io_lbolt;

static nsc_io_t *_nsc_find_io(char *, int, int *);
nsc_io_t *_nsc_reserve_io(char *, int);
static nsc_io_t *_nsc_alloc_io(int, char *, int);

static int _nsc_open_fn(nsc_fd_t *, int);
static int _nsc_close_fn(nsc_fd_t *);
static int _nsc_alloc_fd(char *, int, int, nsc_fd_t **);
static int _nsc_alloc_iodev(nsc_dev_t *, int, nsc_iodev_t **);
static int _nsc_alloc_dev(char *, nsc_dev_t **);
static int _nsc_reopen_io(char *, int);
static int _nsc_reopen_dev(nsc_dev_t *, int);
static int _nsc_relock_dev(nsc_dev_t *, nsc_fd_t *, nsc_iodev_t *);
static int _nsc_reopen_fd(nsc_fd_t *, int);
static int _nsc_decode_io(nsc_def_t *, nsc_io_t *);

void _nsc_release_io(nsc_io_t *);
static void _nsc_free_fd(nsc_fd_t *);
static void _nsc_free_iodev(nsc_iodev_t *);
static void _nsc_free_dev(nsc_dev_t *);
static void _nsc_free_io(nsc_io_t *);
static void _nsc_relink_fd(nsc_fd_t *, nsc_fd_t **, nsc_fd_t **, nsc_iodev_t *);

static int _nsc_setval(nsc_dev_t *, char *, char *, int, int);
static void r_nsc_setval(ncall_t *, int *);
static void r_nsc_setval_all(ncall_t *, int *);

extern void _nsc_add_disk(nsc_io_t *);
extern void _nsc_add_cache(nsc_io_t *);


/*
 * void
 * _nsc_init_dev (void)
 *  Initialise device subsystem.
 *
 * Calling/Exit State:
 *  Called at driver initialisation time to allocate necessary
 *  data structures.
 */
void
_nsc_init_dev()
{
    mutex_init(&_nsc_io_lock, NULL, MUTEX_DRIVER, NULL);
    mutex_init(&_nsc_devval_lock, NULL, MUTEX_DRIVER, NULL);

    _nsc_null_io = nsc_register_io("null", NSC_NULL, (nsc_def_t *)0);

    if (!_nsc_null_io)
        cmn_err(CE_PANIC, "nsctl: nsc_init_dev");

    ncall_register_svc(NSC_SETVAL_ALL, r_nsc_setval_all);
    ncall_register_svc(NSC_SETVAL, r_nsc_setval);
}


void
_nsc_deinit_dev()
{
    nsc_devval_t *dv;
    nsc_val_t *vp;

    mutex_enter(&_nsc_devval_lock);

    while ((dv = _nsc_devval_top) != NULL) {
        while ((vp = dv->dv_values) != NULL) {
            dv->dv_values = vp->sv_next;
            nsc_kmem_free(vp, sizeof (*vp));
        }

        _nsc_devval_top = dv->dv_next;
        nsc_kmem_free(dv, sizeof (*dv));
    }

    mutex_exit(&_nsc_devval_lock);

    ncall_unregister_svc(NSC_SETVAL_ALL);
    ncall_unregister_svc(NSC_SETVAL);

    mutex_destroy(&_nsc_devval_lock);
    mutex_destroy(&_nsc_io_lock);
}


/*
 * nsc_io_t *
 * nsc_register_io (char *name, int type, nsc_def_t *def)
 *  Register an I/O module.
 *
 * Calling/Exit State:
 *  Returns a token for use in future calls to nsc_unregister_io.
 *  The ID and flags for the module are specified by 'type' and
 *  the appropriate entry points are defined using 'def'. If
 *  registration fails NULL is returned.
 *
 * Description:
 *  Registers an I/O module for use by subsequent calls to
 *  nsc_open.
 */
nsc_io_t *
nsc_register_io(name, type, def)
char *name;
int type;
nsc_def_t *def;
{
    nsc_io_t *io, *tp;
    int rc, id, flag;
    nsc_io_t **iop;

    id = (type & NSC_TYPES);
    flag = (type & ~NSC_TYPES);

    if ((!(id & NSC_ID) || (id & ~NSC_IDS)) &&
            (id != NSC_NULL || _nsc_null_io))
        return (NULL);

    if (!(io = _nsc_alloc_io(id, name, flag)))
        return (NULL);

    rc = _nsc_decode_io(def, io);

    if (!rc && id != NSC_NULL) {
        _nsc_free_io(io);
        return (NULL);
    }

    mutex_enter(&_nsc_io_lock);

    for (tp = _nsc_io_top; tp; tp = tp->next) {
        if (strcmp(tp->name, name) == 0 || tp->id == id) {
            mutex_exit(&_nsc_io_lock);
            _nsc_free_io(io);
            return (NULL);
        }
    }

    for (iop = &_nsc_io_top; *iop; iop = &(*iop)->next)
        if (id >= (*iop)->id)
            break;

    io->next = (*iop);
    (*iop) = io;

    _nsc_io_lbolt = nsc_lbolt();

    while ((rc = _nsc_reopen_io(NULL, 0)) != 0)
        if (rc != ERESTART)
            break;

    mutex_exit(&_nsc_io_lock);
    return (io);
}


/*
 * static int
 * _nsc_decode_io (nsc_def_t *def, nsc_io_t *io)
 *  Decode I/O module definition.
 *
 * Calling/Exit State:
 *  Returns TRUE if the definition contains an adequate
 *  description of an I/O module.
 *
 * Description:
 *  Decode the definition of an I/O module and supply
 *  translation routines where possible for operations
 *  that are not defined.
 */
static int
_nsc_decode_io(def, io)
nsc_def_t *def;
nsc_io_t *io;
{
    nsc_decode_param(def, _nsc_io_def, (long *)io);
    nsc_decode_param(def, _nsc_disk_def, (long *)io);
    nsc_decode_param(def, _nsc_cache_def, (long *)io);

    _nsc_add_disk(io);
    _nsc_add_cache(io);

    return (1);
}


/*
 * int
 * nsc_unregister_io (nsc_io_t *io, int flag)
 *  Un-register an I/O module.
 *
 * Calling/Exit State:
 *  Returns 0 on success, otherwise returns an error code.
 *
 * Description:
 *  The specified I/O module is un-registered if possible.
 *  All open file descriptors using the module will be closed
 *  in preparation for a subsequent re-open.
 *
 *  If NSC_PCATCH is specified and a signal is received,
 *  the unregister will be terminated and EINTR returned.
 */
int
nsc_unregister_io(nsc_io_t *io, int flag)
{
    nsc_path_t *sp;
    nsc_io_t *xio;
    int rc = 0;

    if (io == _nsc_null_io)
        return (EINVAL);

    mutex_enter(&_nsc_io_lock);

    for (xio = _nsc_io_top; xio; xio = xio->next)
        if (xio == io)
            break;

    if (!xio || io->pend) {
        mutex_exit(&_nsc_io_lock);
        return (xio ? EALREADY : 0);
    }

    io->pend = 1;
lp:
    for (sp = _nsc_path_top; sp; sp = sp->sp_next)
        if (sp->sp_io == io) {
            mutex_exit(&_nsc_io_lock);

            if ((rc = nsc_unregister_path(sp, flag)) != 0) {
                io->pend = 0;
                return (rc);
            }

            mutex_enter(&_nsc_io_lock);
            goto lp;
        }

    _nsc_io_lbolt = nsc_lbolt();

    while (io->refcnt && !rc) {
        while ((rc = _nsc_reopen_io(NULL, flag)) != 0)
            if (rc != ERESTART)
                break;

        if (rc || !io->refcnt)
            break;

        if (!cv_wait_sig(&io->cv, &_nsc_io_lock))
            rc = EINTR;
    }

    /*
     * We have tried to get rid of all the IO provider's clients.
     * If there are still anonymous buffers outstanding, then fail
     * the unregister.
     */

    if (!rc && io->abufcnt > 0)
        rc = EUSERS;

    if (rc)
        io->pend = 0;

    mutex_exit(&_nsc_io_lock);

    if (!rc)
        _nsc_free_io(io);

    return (rc);
}


/*
 * nsc_path_t *
 * nsc_register_path (char *path, int type, nsc_io_t *io)
 *  Register interest in pathname.
 *
 * Calling/Exit State:
 *  Returns a token for use in future calls to
 *  nsc_unregister_path. The 'path' argument can contain
 *  wild characters. If registration fails NULL is returned.
 *  May not be called for io providers that support NSC_ANON.
 *
 * Description:
 *  Registers an interest in any pathnames matching 'path'
 *  which are opened with the specified type.
 */
nsc_path_t *
nsc_register_path(char *path, int type, nsc_io_t *io)
{
    nsc_path_t *sp, **spp;
    int rc;

    if ((type & NSC_IDS) || !io || (io->provide & NSC_ANON) ||
        !(sp = nsc_kmem_zalloc(sizeof (*sp), KM_SLEEP, _nsc_local_mem)))
        return (NULL);

    sp->sp_path = nsc_strdup(path);
    sp->sp_type = type;
    sp->sp_io = io;

    mutex_enter(&_nsc_io_lock);

    for (spp = &_nsc_path_top; *spp; spp = &(*spp)->sp_next)
        if (io->id >= (*spp)->sp_io->id)
            break;

    sp->sp_next = (*spp);
    (*spp) = sp;

    _nsc_io_lbolt = nsc_lbolt();

    while ((rc = _nsc_reopen_io(path, 0)) != 0)
        if (rc != ERESTART)
            break;

    mutex_exit(&_nsc_io_lock);
    return (sp);
}


/*
 * int
 * nsc_unregister_path (nsc_path_t *sp, int flag)
 *  Un-register interest in pathname.
 *
 * Calling/Exit State:
 *  Returns 0 on success, otherwise returns an error code.
 *
 * Description:
 *  Interest in the specified pathname is un-registered
 *  if possible. All appropriate file descriptors will be
 *  closed in preparation for a subsequent re-open.
 *
 *  If NSC_PCATCH is specified and a signal is received,
 *  the unregister will be terminated and EINTR returned.
 */
int
nsc_unregister_path(sp, flag)
nsc_path_t *sp;
int flag;
{
    nsc_path_t *xsp, **spp;
    int rc;

    mutex_enter(&_nsc_io_lock);

    for (xsp = _nsc_path_top; xsp; xsp = xsp->sp_next)
        if (xsp == sp)
            break;

    if (!xsp || sp->sp_pend) {
        mutex_exit(&_nsc_io_lock);
        return (xsp ? EALREADY : 0);
    }

    sp->sp_pend = 1;
    _nsc_io_lbolt = nsc_lbolt();

    while ((rc = _nsc_reopen_io(sp->sp_path, flag)) != 0)
        if (rc != ERESTART) {
            sp->sp_pend = 0;
            mutex_exit(&_nsc_io_lock);
            return (rc);
        }

    for (spp = &_nsc_path_top; *spp; spp = &(*spp)->sp_next)
        if (*spp == sp)
            break;

    if (*spp)
        (*spp) = sp->sp_next;

    mutex_exit(&_nsc_io_lock);

    nsc_strfree(sp->sp_path);
    nsc_kmem_free(sp, sizeof (*sp));
    return (0);
}


/*
 * static int
 * _nsc_reopen_io (char *path, int flag)
 *  Force re-open of all file descriptors.
 *
 * Calling/Exit State:
 *  The _nsc_io_lock must be held across calls to
 *  this function.
 *
 *  Returns 0 if the force succeeds without releasing
 *  _nsc_io_lock, otherwise returns an error code.
 *
 * Description:
 *  A re-open is forced for all file descriptors as
 *  appropriate. For performance reasons available
 *  devices are re-opened before those that would block.
 */
static int
_nsc_reopen_io(path, flag)
char *path;
int flag;
{
    nsc_dev_t *dp, *dev;
    int rc, errno = 0;
    int try, run;

    for (run = 1, try = (NSC_TRY | NSC_DEFER); run--; try = 0) {
        for (dev = _nsc_dev_top; dev; dev = dev->nsc_next) {
            if (path && !nsc_strmatch(dev->nsc_path, path))
                continue;

            if (!(rc = _nsc_reopen_dev(dev, flag | try)))
                continue;

            for (dp = _nsc_dev_top; dp; dp = dp->nsc_next)
                if (dp == dev)
                    break;

            if (!dp)
                return (ERESTART);

            if (try && !(flag & NSC_TRY))
                run = 1;
            if (!run && errno != ERESTART)
                errno = rc;
        }
    }

    return (errno);
}


/*
 * static int
 * _nsc_reopen_dev (nsc_dev_t *dev, int flag)
 *  Force re-open of entire device.
 *
 * Calling/Exit State:
 *  The _nsc_io_lock must be held across calls to
 *  this function.
 *
 *  Returns 0 if the force succeeds without releasing
 *  _nsc_io_lock, otherwise returns an error code.
 *
 * Description:
 *  A re-open is forced for all file descriptors for the
 *  device as appropriate.
 */
static int
_nsc_reopen_dev(dev, flag)
nsc_dev_t *dev;
int flag;
{
    int rc, errno = 0;
    nsc_iodev_t *iodev;
    int try, run;
    nsc_fd_t *fd;

    mutex_enter(&dev->nsc_lock);

    for (run = 1, try = (NSC_TRY | NSC_DEFER); run--; try = 0)
        for (iodev = dev->nsc_list; iodev; iodev = iodev->si_next) {
            for (fd = iodev->si_open; fd; fd = fd->sf_next) {
                if (!(rc = _nsc_reopen_fd(fd, flag | try)))
                    continue;

                if (rc == -ERESTART)
                    return (ERESTART);

                if (!_nsc_relock_dev(dev, fd, iodev))
                    return (ERESTART);

                if (try && !(flag & NSC_TRY))
                    run = 1;
                if (!run && errno != ERESTART)
                    errno = rc;
            }
        }

    for (run = 1, try = (NSC_TRY | NSC_DEFER); run--; try = 0)
        for (fd = dev->nsc_close; fd; fd = fd->sf_next) {
            if (!(rc = _nsc_reopen_fd(fd, flag | try)))
                continue;

            if (rc == -ERESTART)
                return (ERESTART);

            if (!_nsc_relock_dev(dev, fd, NULL))
                return (ERESTART);

            if (try && !(flag & NSC_TRY))
                run = 1;
            if (!run && errno != ERESTART)
                errno = rc;
        }

    mutex_exit(&dev->nsc_lock);
    return (errno);
}


/*
 * static int
 * _nsc_relock_dev (nsc_dev_t *dev, nsc_fd_t *fd, nsc_iodev_t *iodev)
 *  Relock device structure if possible.
 *
 * Calling/Exit State:
 *  The _nsc_io_lock must be held across calls to
 *  this function.
 *
 *  Checks whether the file descriptor is still part
 *  of the specified device and I/O device. If so the
 *  device lock is taken. Otherwise FALSE is returned.
 */
static int
_nsc_relock_dev(nsc_dev_t *dev, nsc_fd_t *fd, nsc_iodev_t *iodev)
{
    nsc_fd_t *fp = NULL;
    nsc_iodev_t *iop;
    nsc_dev_t *dp;

    for (dp = _nsc_dev_top; dp; dp = dp->nsc_next)
        if (dp == dev)
            break;

    if (!dp)
        return (0);

    mutex_enter(&dev->nsc_lock);

    if (iodev)
        for (iop = dev->nsc_list; iop; iop = iop->si_next)
            if (iop == iodev)
                break;

    if (!iodev || iop) {
        fp = (iodev) ? iodev->si_open : dev->nsc_close;

        for (; fp; fp = fp->sf_next)
            if (fp == fd)
                break;
    }

    if (!fp) {
        mutex_exit(&dev->nsc_lock);
        return (0);
    }

    return (1);
}


/*
 * static int
 * _nsc_reopen_fd (nsc_fd_t *dev, int flag)
 *  Force re-open of file descriptor.
 *
 * Calling/Exit State:
 *  Both _nsc_io_lock and the device lock must be held
 *  across calls to this function.
 *
 *  Returns 0 if the force succeeds without releasing
 *  any locks, otherwise returns an error code. If an
 *  error code is returned the device lock is released.
 *
 * Description:
 *  If appropriate the file descriptor is closed in order
 *  to force a subsequent open using the currently available
 *  resources.
 */
static int
_nsc_reopen_fd(fd, flag)
nsc_fd_t *fd;
int flag;
{
    nsc_dev_t *dev = fd->sf_dev;
    nsc_iodev_t *iodev = fd->sf_iodev;
    int changed = 0;
    int rc;

    if (!fd->sf_pend && !iodev)
        return (0);

    if (fd->sf_pend == _NSC_OPEN)
        if (fd->sf_lbolt - _nsc_io_lbolt > 0)
            return (0);

    if (iodev &&
        (iodev->si_io ==
        _nsc_find_io(dev->nsc_path, fd->sf_type, &changed)) &&
        !changed)
        return (0);

    if (iodev)
        fd->sf_reopen = 1;

    mutex_exit(&_nsc_io_lock);

    dev->nsc_reopen = 1;

    rc = _nsc_close_fd(fd, flag);

    dev->nsc_reopen = 0;

    if (rc == EAGAIN && (flag & NSC_DEFER) && fd->sf_reopen)
        dev->nsc_drop = 1;

    mutex_exit(&dev->nsc_lock);

    if (rc == -ERESTART)
        delay(2);   /* allow other threads cpu time */

    mutex_enter(&_nsc_io_lock);
    return (rc ? rc : ERESTART);
}


/*
 * nsc_fd_t *
 * nsc_open (char *path, int type, nsc_def_t *def, blind_t arg, int *sts)
 *  Open file descriptor for pathname.
 *
 * Calling/Exit State:
 *  Returns file descriptor if open succeeds, otherwise
 *  returns 0 and puts error code in the location pointed
 *  to by sts.
 *
 * Description:
 *  Open the specified pathname using an appropriate access
 *  method.
 */
nsc_fd_t *
nsc_open(path, type, def, arg, sts)
char *path;
int type;
nsc_def_t *def;
blind_t arg;
int *sts;
{
    int flag, rc;
    nsc_fd_t *fd;

    flag = (type & ~NSC_TYPES);
    type &= NSC_TYPES;

    if ((flag & NSC_READ) == 0)
        flag |= NSC_RDWR;

    if ((rc = _nsc_alloc_fd(path, type, flag, &fd)) != 0) {
        if (sts)
            *sts = rc;
        return (NULL);
    }

    fd->sf_arg = arg;
    fd->sf_aio = _nsc_null_io;

    nsc_decode_param(def, _nsc_fd_def, (long *)fd);

    mutex_enter(&fd->sf_dev->nsc_lock);

    while ((rc = _nsc_open_fd(fd, flag)) != 0)
        if (rc != ERESTART)
            break;

    mutex_exit(&fd->sf_dev->nsc_lock);

    if (rc) {
        _nsc_free_fd(fd);
        if (sts)
            *sts = rc;
        return (NULL);
    }

    return (fd);
}


/*
 * int
 * _nsc_open_fd (nsc_fd_t *fd, int flag)
 *  Open file descriptor.
 *
 * Calling/Exit State:
 *  The device lock must be held across calls to
 *  this function.
 *
 *  Returns 0 if the open succeeds, otherwise
 *  returns an error code.
 *
 * Description:
 *  Open the specified file descriptor.
 */
int
_nsc_open_fd(fd, flag)
nsc_fd_t *fd;
int flag;
{
    nsc_dev_t *dev = fd->sf_dev;
    int rc;

    if (fd->sf_pend)
        return (_nsc_wait_dev(dev, flag));

    if (fd->sf_iodev)
        return (0);
    if (flag & NSC_NOBLOCK)
        return (EAGAIN);

    fd->sf_pend = _NSC_OPEN;
    fd->sf_lbolt = nsc_lbolt();

    mutex_exit(&dev->nsc_lock);

    rc = _nsc_open_fn(fd, flag);

    mutex_enter(&dev->nsc_lock);
    fd->sf_pend = 0;

    if (!rc)
        fd->sf_iodev->si_pend = 0;

    if (dev->nsc_wait || dev->nsc_refcnt <= 0)
        cv_broadcast(&dev->nsc_cv);

    return (rc ? rc : ERESTART);
}


/*
 * static int
 * _nsc_open_fn (nsc_fd_t *fd, int flag)
 *  Allocate I/O device and open file descriptor.
 *
 * Calling/Exit State:
 *  No locks may be held across this function.
 *
 *  If the open succeeds an I/O device will be
 *  attached to the file descriptor, marked as
 *  pending and 0 returned. Otherwise, returns
 *  an error code.
 *
 * Description:
 *  Allocate an I/O device and open the specified
 *  file descriptor.
 */
static int
_nsc_open_fn(fd, flag)
nsc_fd_t *fd;
int flag;
{
    nsc_dev_t *dev = fd->sf_dev;
    nsc_iodev_t *iodev;
    int rc;

    if ((rc = _nsc_alloc_iodev(dev, fd->sf_type, &iodev)) != 0)
        return (rc);

    mutex_enter(&dev->nsc_lock);

    if (iodev->si_pend) {
        rc = _nsc_wait_dev(dev, flag);
        mutex_exit(&dev->nsc_lock);
        _nsc_free_iodev(iodev);
        return (rc);
    }

    iodev->si_pend = _NSC_OPEN;
    mutex_exit(&dev->nsc_lock);

    rc = (*iodev->si_io->open)(dev->nsc_path,
            (fd->sf_flag & ~NSC_RDWR), &fd->sf_cd, iodev);

    if (rc) {
        iodev->si_pend = 0;
        _nsc_free_iodev(iodev);
        return (rc);
    }

    /* save away the DevMaj and DevMin values */
    if (iodev->si_io->id == NSC_RAW_ID) {
        rc = _nsc_setval(dev, NULL, NSC_DEVMAJ,
            (int)getmajor((dev_t)fd->sf_cd), FALSE);
#ifdef DEBUG
        if (rc != 1) {
            cmn_err(CE_NOTE, "!nsctl: could not set DevMaj (%s:%x)",
                dev->nsc_path, (int)getmajor((dev_t)fd->sf_cd));
        }
#endif

        rc = _nsc_setval(dev, NULL, NSC_DEVMIN,
            (int)getminor((dev_t)fd->sf_cd), FALSE);
#ifdef DEBUG
        if (rc != 1) {
            cmn_err(CE_NOTE, "!nsctl: could not set DevMin (%s:%x)",
                dev->nsc_path, (int)getminor((dev_t)fd->sf_cd));
        }
#endif
    }

    fd->sf_iodev = iodev;
    _nsc_relink_fd(fd, &dev->nsc_close, &iodev->si_open, iodev);

    return (0);
}


/*
 * int
 * nsc_close (nsc_fd_t *fd)
 *  Close file descriptor for pathname.
 *
 * Calling/Exit State:
 *  Returns 0 if close succeeds, otherwise returns error
 *  code.
 *
 * Description:
 *  Close the specified file descriptor. It is assumed
 *  that all other users of this file descriptor have
 *  finished. Any reserve will be discarded before the
 *  close is performed.
 */
int
nsc_close(fd)
nsc_fd_t *fd;
{
    int rc;

    if (!fd)
        return (0);

    while (fd->sf_reserve)
        nsc_release(fd);

    mutex_enter(&fd->sf_dev->nsc_lock);

    fd->sf_owner = NULL;

    while ((rc = _nsc_close_fd(fd, 0)) != 0)
        if (rc != ERESTART)
            break;

    nsc_decode_param(_nsc_fd_def, _nsc_fd_def, (long *)fd);

    mutex_exit(&fd->sf_dev->nsc_lock);

    if (!rc)
        _nsc_free_fd(fd);
    return (rc);
}


/*
 * int
 * _nsc_close_fd (nsc_fd_t *fd, int flag)
 *  Close file descriptor.
 *
 * Calling/Exit State:
 *  The device lock must be held across calls to
 *  this function.
 *
 *  Returns 0 if the close succeeds, otherwise
 *  returns an error code.
 *
 * Description:
 *  Close the specified file descriptor.
 */
int
_nsc_close_fd(fd, flag)
nsc_fd_t *fd;
int flag;
{
    nsc_dev_t *dev = fd->sf_dev;
    nsc_iodev_t *iodev;
    int rc;

    if (fd->sf_pend) {
        if (fd->sf_pend == _NSC_CLOSE && dev->nsc_reopen != 0)
            return (-ERESTART);

        return (_nsc_wait_dev(dev, flag));
    }

    flag |= NSC_RDWR;
    iodev = fd->sf_iodev;

    if (!iodev)
        return (0);

    if ((rc = _nsc_detach_fd(fd, flag)) != 0)
        return (rc);

    if (iodev->si_pend)
        return (_nsc_wait_dev(dev, flag));

    if (iodev->si_open == fd && !fd->sf_next) {
        if ((rc = _nsc_detach_iodev(iodev, NULL, flag)) != 0)
            return (rc);

        if (dev->nsc_list == iodev && !iodev->si_next)
            if ((rc = _nsc_detach_dev(dev, NULL, flag)) != 0)
                return (rc);
    }

    if (flag & NSC_NOBLOCK)
        return (EAGAIN);

    fd->sf_pend = _NSC_CLOSE;
    iodev->si_pend = _NSC_CLOSE;
    mutex_exit(&dev->nsc_lock);

    rc = _nsc_close_fn(fd);

    mutex_enter(&dev->nsc_lock);
    fd->sf_pend = 0;

    fd->sf_reopen = 0;
    if (rc)
        iodev->si_pend = 0;

    if (dev->nsc_wait || dev->nsc_refcnt <= 0)
        cv_broadcast(&dev->nsc_cv);

    return (rc ? rc : ERESTART);
}


/*
 * static int
 * _nsc_close_fn (nsc_fd_t *fd)
 *  Close file descriptor and free I/O device.
 *
 * Calling/Exit State:
 *  No locks may be held across this function.
 *
 *  Returns 0 if the close succeeds, otherwise
 *  returns an error code.
 *
 *  If the close succeeds the I/O device will be
 *  detached from the file descriptor, released
 *  and 0 returned. Otherwise, returns an error
 *  code.
 *
 * Description:
 *  Close the specified file descriptor and free
 *  the I/O device.
 */
static int
_nsc_close_fn(fd)
nsc_fd_t *fd;
{
    nsc_iodev_t *iodev = fd->sf_iodev;
    nsc_dev_t *dev = fd->sf_dev;
    int last, rc;

    last = (iodev->si_open == fd && !fd->sf_next);

    if (last || (iodev->si_io->flag & NSC_REFCNT))
        if ((rc = (*iodev->si_io->close)(fd->sf_cd)) != 0)
            return (rc);

    fd->sf_iodev = NULL;
    _nsc_relink_fd(fd, &iodev->si_open, &dev->nsc_close, iodev);

    iodev->si_pend = 0;
    _nsc_free_iodev(iodev);

    return (0);
}


/*
 * void
 * nsc_set_owner (nsc_fd_t *fd, nsc_iodev_t *iodev)
 *  Set owner associated with file descriptor.
 *
 * Calling/Exit State:
 *  Sets the owner field in the file descriptor.
 */
void
nsc_set_owner(nsc_fd_t *fd, nsc_iodev_t *iodev)
{
    if (fd) {
        mutex_enter(&fd->sf_dev->nsc_lock);
        fd->sf_owner = iodev;
        mutex_exit(&fd->sf_dev->nsc_lock);
    }
}


/*
 * char *
 * nsc_pathname (nsc_fd_t *fd)
 *  Pathname associated with file descriptor.
 *
 * Calling/Exit State:
 *  Returns a pointer to the pathname associated
 *  with the given file descriptor.
 */
char *
nsc_pathname(fd)
nsc_fd_t *fd;
{
    return ((fd) ? (fd->sf_dev->nsc_path) : 0);
}


/*
 * int
 * nsc_fdpathcmp(nsc_fd_t *fd, uint64_t phash, char *path)
 *  Compare fd to pathname and hash
 *
 * Calling/Exit State:
 *  Returns comparison value like strcmp(3C).
 *
 * Description:
 *  Does an optimised comparison of the pathname and associated hash
 *  value (as returned from nsc_strhash()) against the pathname of
 *  the filedescriptor, fd.
 */
int
nsc_fdpathcmp(nsc_fd_t *fd, uint64_t phash, char *path)
{
    int rc = -1;

    if (fd != NULL && fd->sf_dev->nsc_phash == phash)
        rc = strcmp(fd->sf_dev->nsc_path, path);

    return (rc);
}


static int
_nsc_setval(nsc_dev_t *dev, char *path, char *name, int val, int do_ncall)
{
    nsc_devval_t *dv;
    nsc_rval_t *rval;
    ncall_t *ncall;
    nsc_val_t *vp;
    uint64_t phash;
    char *pp;
    int rc;

    ASSERT(dev != NULL || path != NULL);
#ifdef DEBUG
    if (dev != NULL && path != NULL) {
        ASSERT(strcmp(dev->nsc_path, path) == 0);
    }
#endif

    pp = (dev != NULL) ? dev->nsc_path : path;

    if (strlen(name) >= NSC_SETVAL_MAX) {
#ifdef DEBUG
        cmn_err(CE_WARN, "!nsc_setval: max name size(%d) exceeded(%d)",
            NSC_SETVAL_MAX-1, (int)strlen(name));
#endif
        return (0);
    }

    phash = nsc_strhash(pp);

    mutex_enter(&_nsc_devval_lock);

    if (dev != NULL)
        dv = dev->nsc_values;
    else {
        for (dv = _nsc_devval_top; dv != NULL; dv = dv->dv_next) {
            if (phash == dv->dv_phash &&
                strcmp(pp, dv->dv_path) == 0)
                /* found dv for device */
                break;
        }
    }

    if (dv == NULL) {
        dv = nsc_kmem_zalloc(sizeof (*dv), KM_SLEEP, _nsc_local_mem);
        if (dv == NULL) {
            mutex_exit(&_nsc_devval_lock);
            return (0);
        }

        (void) strncpy(dv->dv_path, pp, sizeof (dv->dv_path));
        dv->dv_phash = phash;

        dv->dv_next = _nsc_devval_top;
        _nsc_devval_top = dv;
        if (dev != NULL)
            dev->nsc_values = dv;
    }

    for (vp = dv->dv_values; vp; vp = vp->sv_next) {
        if (strcmp(vp->sv_name, name) == 0) {
            vp->sv_value = val;
            break;
        }
    }

    if (vp == NULL) {
        vp = nsc_kmem_zalloc(sizeof (*vp), KM_SLEEP, _nsc_local_mem);
        if (vp != NULL) {
            (void) strncpy(vp->sv_name, name, sizeof (vp->sv_name));
            vp->sv_value = val;
            vp->sv_next = dv->dv_values;
            dv->dv_values = vp;
        }
    }

    mutex_exit(&_nsc_devval_lock);

    /*
     * phoenix: ncall the new value to the other node now.
     */

    if (vp && do_ncall) {
        /* CONSTCOND */
        ASSERT(sizeof (nsc_rval_t) <= NCALL_DATA_SZ);

        rval = nsc_kmem_zalloc(sizeof (*rval), KM_SLEEP,
            _nsc_local_mem);
        if (rval == NULL) {
            goto out;
        }

        rc = ncall_alloc(ncall_mirror(ncall_self()), 0, 0, &ncall);
        if (rc == 0) {
            (void) strncpy(rval->path, pp, sizeof (rval->path));
            (void) strncpy(rval->name, name, sizeof (rval->name));
            rval->value = val;

            rc = ncall_put_data(ncall, rval, sizeof (*rval));
            if (rc == 0) {
                /*
                 * Send synchronously and read a reply
                 * so that we know that the remote
                 * setval has completed before this
                 * function returns and hence whilst
                 * the device is still reserved on this
                 * node.
                 */
                if (ncall_send(ncall, 0, NSC_SETVAL) == 0)
                    (void) ncall_read_reply(ncall, 1, &rc);
            }

            ncall_free(ncall);
        }

        nsc_kmem_free(rval, sizeof (*rval));
    }

out:
    return (vp ? 1 : 0);
}


/* ARGSUSED */

static void
r_nsc_setval(ncall_t *ncall, int *ap)
{
    nsc_rval_t *rval;
    int rc;

    rval = nsc_kmem_zalloc(sizeof (*rval), KM_SLEEP, _nsc_local_mem);
    if (rval == NULL) {
        ncall_reply(ncall, ENOMEM);
        return;
    }

    rc = ncall_get_data(ncall, rval, sizeof (*rval));
    if (rc != 0) {
        ncall_reply(ncall, EFAULT);
        return;
    }

    if (_nsc_setval(NULL, rval->path, rval->name, rval->value, FALSE))
        rc = 0;
    else
        rc = ENOMEM;

    ncall_reply(ncall, rc);
    nsc_kmem_free(rval, sizeof (*rval));
}


/* ARGSUSED */

static void
r_nsc_setval_all(ncall_t *ncall, int *ap)
{
    nsc_rval_t *in = NULL, *out = NULL;
    nsc_devval_t *dv;
    nsc_val_t *vp;
    ncall_t *np;
    uint64_t phash;
    int rc;

    /* CONSTCOND */
    ASSERT(sizeof (nsc_rval_t) <= NCALL_DATA_SZ);

    in = nsc_kmem_zalloc(sizeof (*in), KM_SLEEP, _nsc_local_mem);
    out = nsc_kmem_zalloc(sizeof (*out), KM_SLEEP, _nsc_local_mem);
    if (in == NULL || out == NULL) {
        if (in != NULL) {
            nsc_kmem_free(in, sizeof (*in));
            in = NULL;
        }
        if (out != NULL) {
            nsc_kmem_free(out, sizeof (*out));
            out = NULL;
        }
        ncall_reply(ncall, ENOMEM);
    }

    rc = ncall_get_data(ncall, in, sizeof (*in));
    if (rc != 0) {
        ncall_reply(ncall, EFAULT);
        return;
    }

    phash = nsc_strhash(in->path);

    (void) strncpy(out->path, in->path, sizeof (out->path));

    rc = ncall_alloc(ncall_mirror(ncall_self()), 0, 0, &np);
    if (rc != 0) {
        ncall_reply(ncall, ENOMEM);
        return;
    }

    mutex_enter(&_nsc_devval_lock);

    for (dv = _nsc_devval_top; dv; dv = dv->dv_next) {
        if (dv->dv_phash == phash &&
            strcmp(dv->dv_path, in->path) == 0)
            break;
    }

    if (dv) {
        for (vp = dv->dv_values; vp; vp = vp->sv_next) {
            if (strcmp(vp->sv_name, NSC_DEVMIN) == 0 ||
                strcmp(vp->sv_name, NSC_DEVMAJ) == 0) {
                /* ignore the implicit DevMin/DevMaj values */
                continue;
            }

            (void) strncpy(out->name, vp->sv_name,
                sizeof (out->name));
            out->value = vp->sv_value;

            rc = ncall_put_data(np, out, sizeof (*out));
            if (rc == 0) {
                /*
                 * Send synchronously and read a reply
                 * so that we know that the remote
                 * setval has completed before this
                 * function returns.
                 */
                if (ncall_send(np, 0, NSC_SETVAL) == 0)
                    (void) ncall_read_reply(np, 1, &rc);
            }

            ncall_reset(np);
        }

        ncall_free(np);
        rc = 0;
    } else {
        rc = ENODEV;
    }

    mutex_exit(&_nsc_devval_lock);

    ncall_reply(ncall, rc);

    nsc_kmem_free(out, sizeof (*out));
    nsc_kmem_free(in, sizeof (*in));
}


/*
 * int
 * nsc_setval (nsc_fd_t *fd, char *name, int val)
 *  Set value for device.
 *
 * Calling/Exit State:
 *  Returns 1 if the value has been set, otherwise 0.
 *  Must be called with the fd reserved.
 *
 * Description:
 *  Sets the specified global variable for the device
 *  to the value provided.
 */
int
nsc_setval(nsc_fd_t *fd, char *name, int val)
{
    if (!fd)
        return (0);

    if (!nsc_held(fd))
        return (0);

    return (_nsc_setval(fd->sf_dev, NULL, name, val, TRUE));
}


/*
 * int
 * nsc_getval (nsc_fd_t *fd, char *name, int *vp)
 *  Get value from device.
 *
 * Calling/Exit State:
 *  Returns 1 if the value has been found, otherwise 0.
 *  Must be called with the fd reserved, except for "DevMaj" / "DevMin".
 *
 * Description:
 *  Finds the value of the specified device variable for
 *  the device and returns it in the location pointed to
 *  by vp.
 */
int
nsc_getval(nsc_fd_t *fd, char *name, int *vp)
{
    nsc_devval_t *dv;
    nsc_val_t *val;

    if (!fd)
        return (0);

    /*
     * Don't check for nsc_held() for the device number values
     * since these are magically created and cannot change when
     * the fd is not reserved.
     */

    if (strcmp(name, NSC_DEVMAJ) != 0 &&
        strcmp(name, NSC_DEVMIN) != 0 &&
        !nsc_held(fd))
        return (0);

    mutex_enter(&_nsc_devval_lock);

    dv = fd->sf_dev->nsc_values;
    val = NULL;

    if (dv != NULL) {
        for (val = dv->dv_values; val; val = val->sv_next) {
            if (strcmp(val->sv_name, name) == 0) {
                *vp = val->sv_value;
                break;
            }
        }
    }

    mutex_exit(&_nsc_devval_lock);

    return (val ? 1 : 0);
}


/*
 * char *
 * nsc_shared (nsc_fd_t *fd)
 *  Device is currently shared.
 *
 * Calling/Exit State:
 *  The device lock must be held across calls to this
 *  this function.
 *
 *  Returns an indication of whether the device accessed
 *  by the file descriptor is currently referenced by more
 *  than one user.
 *
 *  This is only intended for use in performance critical
 *  situations.
 */
int
nsc_shared(fd)
nsc_fd_t *fd;
{
    nsc_iodev_t *iodev;
    int cnt = 0;

    if (!fd)
        return (0);
    if (!fd->sf_iodev)
        return (1);

    for (iodev = fd->sf_dev->nsc_list; iodev; iodev = iodev->si_next)
        for (fd = iodev->si_open; fd; fd = fd->sf_next)
            if (!fd->sf_owner && cnt++)
                return (1);

    return (0);
}


/*
 * kmutex_t *
 * nsc_lock_addr (nsc_fd_t *fd)
 *  Address of device lock.
 *
 * Calling/Exit State:
 *  Returns a pointer to the spin lock associated with the
 *  device.
 *
 * Description:
 *  This is only intended for use in performance critical
 *  situations in conjunction with nsc_reserve_lk.
 */
kmutex_t *
nsc_lock_addr(fd)
nsc_fd_t *fd;
{
    return (&fd->sf_dev->nsc_lock);
}


/*
 * int
 * _nsc_call_io (long f, blind_t a, blind_t b, blind_t c)
 *  Call information function.
 *
 * Calling/Exit State:
 *  Returns result from function or 0 if not available.
 *  f represents the offset into the I/O structure at which
 *  the required function can be found and a, b, c are the
 *  desired arguments.
 *
 * Description:
 *  Calls the requested function for the first available
 *  cache interface.
 */
int
_nsc_call_io(long f, blind_t a, blind_t b, blind_t c)
{
    nsc_io_t *io;
    int (*fn)();
    int rc;

    io = _nsc_reserve_io(NULL, NSC_SDBC_ID);
    if (!io)
        io = _nsc_reserve_io(NULL, NSC_NULL);

    fn = (blindfn_t)(((long *)io)[f]);
    rc = (*fn)(a, b, c);

    _nsc_release_io(io);
    return (rc);
}


/*
 * nsc_io_t *
 * _nsc_reserve_io (char *, int type)
 *  Reserve I/O module.
 *
 * Calling/Exit State:
 *  Returns address of I/O structure matching specified
 *  type, or NULL.
 *
 * Description:
 *  Searches for an appropriate I/O module and increments
 *  the reference count to prevent it being unregistered.
 */
nsc_io_t *
_nsc_reserve_io(path, type)
char *path;
int type;
{
    nsc_io_t *io;

    mutex_enter(&_nsc_io_lock);

    if ((io = _nsc_find_io(path, type, NULL)) != 0)
        io->refcnt++;

    mutex_exit(&_nsc_io_lock);
    return (io);
}


/*
 * static nsc_io_t *
 * _nsc_find_io (char *path, int type, int *changed)
 *  Find I/O module.
 *
 * Calling/Exit State:
 *  The _nsc_io_lock must be held across calls to
 *  this function.
 *
 *  Returns address of I/O structure matching specified
 *  type, or NULL.
 *
 *  'changed' will be set to non-zero if there is a pending
 *  nsc_path_t that matches the criteria for the requested type.
 *  This allows nsctl to distinguish between multiple
 *  nsc_register_path's done by the same I/O provider.
 *
 * Description:
 *  Searches for an appropriate I/O module.
 *
 *  1.  If <type> is a single module id find the specified I/O
 *      module by module id.
 *
 *  2.  Find the highest module that provides any of the I/O types
 *      included in <type>, taking into account any modules
 *      registered via the nsc_register_path() interface if <path>
 *      is non-NULL.
 *
 *  3.  Find an I/O module following the rules in (2), but whose
 *      module id is less than the id OR'd into <type>.
 *
 *  If no module is found by the above algorithms and NSC_NULL was
 *  included in <type>, return the _nsc_null_io module. Otherwise
 *  return NULL.
 */
static nsc_io_t *
_nsc_find_io(char *path, int type, int *changed)
{
    nsc_path_t *sp = NULL;
    nsc_path_t *pp = NULL;
    nsc_io_t *io;

    type &= NSC_TYPES;

    if (path) {
        for (sp = _nsc_path_top; sp; sp = sp->sp_next) {
            if ((type & NSC_ID) &&
                sp->sp_io->id >= (type & NSC_IDS))
                continue;

            if (sp->sp_pend || (type & sp->sp_type) == 0)
                continue;

            if (nsc_strmatch(path, sp->sp_path))
                break;
        }

        if (sp) {
            /* look for matching pending paths */
            for (pp = _nsc_path_top; pp; pp = pp->sp_next) {
                if (pp->sp_pend &&
                    (type & pp->sp_type) &&
                    nsc_strmatch(path, pp->sp_path)) {
                    break;
                }
            }
        }
    }

    for (io = _nsc_io_top; io; io = io->next) {
        if (io->pend)
            continue;

        if (type & NSC_ID) {
            if ((type & ~NSC_IDS) == 0) {
                if (io->id == type)
                    break;
                continue;
            }

            if (io->id >= (type & NSC_IDS))
                continue;
        }

        if (io->provide & type)
            break;
    }

    if (pp && (!io || pp->sp_io->id >= io->id)) {
        /*
         * Mark this as a path change.
         */
        if (changed) {
            *changed = 1;
        }
    }

    if (sp && (!io || sp->sp_io->id >= io->id))
        io = sp->sp_io;

    if (!io && !(type & NSC_NULL))
        return (NULL);

    if (!io)
        io = _nsc_null_io;

    return (io);
}


/*
 * void
 * _nsc_release_io (nsc_io_t *)
 *  Release I/O module.
 *
 * Description:
 *  Releases reference to I/O structure and wakes up
 *  anybody waiting on it.
 */
void
_nsc_release_io(io)
nsc_io_t *io;
{
    mutex_enter(&_nsc_io_lock);

    io->refcnt--;
    cv_broadcast(&io->cv);

    mutex_exit(&_nsc_io_lock);
}


/*
 * static int
 * _nsc_alloc_fd (char *path, int type, int flag, nsc_fd_t **fdp)
 *  Allocate file descriptor structure.
 *
 * Calling/Exit State:
 *  Stores address of file descriptor through fdp and
 *  returns 0 on success, otherwise returns error code.
 *
 * Description:
 *  A new file descriptor is allocated and linked in to
 *  the file descriptor chain which is protected by the
 *  device lock.
 *
 *  On return the file descriptor must contain all the
 *  information necessary to perform an open. Details
 *  specific to user callbacks are not required yet.
 */
static int
_nsc_alloc_fd(path, type, flag, fdp)
char *path;
int type, flag;
nsc_fd_t **fdp;
{
    nsc_dev_t *dev;
    nsc_fd_t *fd;
    int rc;

    if (!(fd = (nsc_fd_t *)nsc_kmem_zalloc(
                sizeof (*fd), KM_SLEEP, _nsc_local_mem)))
        return (ENOMEM);

    if ((rc = _nsc_alloc_dev(path, &dev)) != 0) {
        nsc_kmem_free(fd, sizeof (*fd));
        return (rc);
    }

    mutex_enter(&dev->nsc_lock);

    fd->sf_type = type;
    fd->sf_flag = flag;
    fd->sf_dev = dev;
    fd->sf_next = dev->nsc_close;
    dev->nsc_close = fd;

    mutex_exit(&dev->nsc_lock);

    *fdp = fd;
    return (0);
}


/*
 * static int
 * _nsc_free_fd (nsc_fd_t *)
 *  Free file descriptor.
 *
 * Description:
 *  The file descriptor is removed from the chain and free'd
 *  once pending activity has completed.
 */
static void
_nsc_free_fd(fd)
nsc_fd_t *fd;
{
    nsc_dev_t *dev = fd->sf_dev;
    nsc_fd_t **fdp;

    if (!fd)
        return;

    mutex_enter(&dev->nsc_lock);

    for (fdp = &dev->nsc_close; *fdp; fdp = &(*fdp)->sf_next)
        if (*fdp == fd) {
            *fdp = fd->sf_next;
            break;
        }

    if (dev->nsc_wait || dev->nsc_refcnt <= 0)
        cv_broadcast(&dev->nsc_cv);

    while (fd->sf_pend)
        (void) _nsc_wait_dev(dev, 0);

    mutex_exit(&dev->nsc_lock);

    _nsc_free_dev(dev);

    nsc_kmem_free(fd, sizeof (*fd));
}


/*
 * static void
 * _nsc_relink_fd (nsc_fd_t *fd, nsc_fd_t **from,
 *              nsc_fd_t **to, nsc_iodev_t *iodev)
 *  Relink file descriptor.
 *
 * Description:
 *  Remove the file descriptor from the 'from' chain and
 *  add it to the 'to' chain. The busy flag in iodev is
 *  used to prevent modifications to the chain whilst a
 *  callback is in progress.
 */
static void
_nsc_relink_fd(nsc_fd_t *fd, nsc_fd_t **from, nsc_fd_t **to, nsc_iodev_t *iodev)
{
    nsc_dev_t *dev = fd->sf_dev;
    nsc_fd_t **fdp;

    mutex_enter(&dev->nsc_lock);

    while (iodev->si_busy)
        (void) _nsc_wait_dev(dev, 0);

    for (fdp = from; *fdp; fdp = &(*fdp)->sf_next)
        if (*fdp == fd) {
            *fdp = fd->sf_next;
            break;
        }

    fd->sf_next = (*to);
    (*to) = fd;

    mutex_exit(&dev->nsc_lock);
}


/*
 * static int
 * _nsc_alloc_iodev (nsc_dev_t *dev, int type, nsc_iodev_t **iodevp)
 *  Allocate I/O device structure.
 *
 * Calling/Exit State:
 *  Stores address of I/O device structure through iodevp
 *  and returns 0 on success, otherwise returns error code.
 *
 * Description:
 *  If an entry for the I/O device already exists increment
 *  the reference count and return the address, otherwise
 *  allocate a new structure.
 *
 *  A new structure is allocated before scanning the chain
 *  to avoid calling the memory allocator with a spin lock
 *  held. If an entry is found the new structure is free'd.
 *
 *  The I/O device chain is protected by the device lock.
 */
static int
_nsc_alloc_iodev(dev, type, iodevp)
nsc_dev_t *dev;
int type;
nsc_iodev_t **iodevp;
{
    nsc_iodev_t *iodev, *ip;
    nsc_io_t *io;

    if (!(iodev = (nsc_iodev_t *)nsc_kmem_zalloc(
                sizeof (*iodev), KM_SLEEP, _nsc_local_mem)))
        return (ENOMEM);

    mutex_init(&iodev->si_lock, NULL, MUTEX_DRIVER, NULL);
    cv_init(&iodev->si_cv, NULL, CV_DRIVER, NULL);

    if (!(io = _nsc_reserve_io(dev->nsc_path, type))) {
        mutex_destroy(&iodev->si_lock);
        cv_destroy(&iodev->si_cv);
        nsc_kmem_free(iodev, sizeof (*iodev));
        return (ENXIO);
    }

    iodev->si_refcnt++;
    iodev->si_io = io;
    iodev->si_dev = dev;

    mutex_enter(&_nsc_io_lock);
    dev->nsc_refcnt++;
    mutex_exit(&_nsc_io_lock);

    mutex_enter(&dev->nsc_lock);

    for (ip = dev->nsc_list; ip; ip = ip->si_next)
        if (ip->si_io == io) {
            ip->si_refcnt++;
            break;
        }

    if (!ip) {
        iodev->si_next = dev->nsc_list;
        dev->nsc_list = iodev;
    }

    mutex_exit(&dev->nsc_lock);

    if (ip) {
        _nsc_free_iodev(iodev);
        iodev = ip;
    }

    *iodevp = iodev;
    return (0);
}


/*
 * static int
 * _nsc_free_iodev (nsc_iodev_t *iodev)
 *  Free I/O device structure.
 *
 * Description:
 *  Decrements the reference count of a previously allocated
 *  I/O device structure. If this is the last reference it
 *  is removed from the device chain and free'd once pending
 *  activity has completed.
 */
static void
_nsc_free_iodev(nsc_iodev_t *iodev)
{
    nsc_iodev_t **ipp;
    nsc_dev_t *dev;

    if (!iodev)
        return;

    dev = iodev->si_dev;

    mutex_enter(&dev->nsc_lock);

    if (--iodev->si_refcnt > 0) {
        mutex_exit(&dev->nsc_lock);
        return;
    }

    for (ipp = &dev->nsc_list; *ipp; ipp = &(*ipp)->si_next)
        if (*ipp == iodev) {
            *ipp = iodev->si_next;
            break;
        }

    if (dev->nsc_wait || dev->nsc_refcnt <= 0)
        cv_broadcast(&dev->nsc_cv);

    while (iodev->si_pend || iodev->si_rpend || iodev->si_busy)
        (void) _nsc_wait_dev(dev, 0);

    mutex_exit(&dev->nsc_lock);

    _nsc_release_io(iodev->si_io);
    _nsc_free_dev(dev);

    mutex_destroy(&iodev->si_lock);
    cv_destroy(&iodev->si_cv);

    nsc_kmem_free(iodev, sizeof (*iodev));
}


/*
 * static int
 * _nsc_alloc_dev (char *path, nsc_dev_t **devp)
 *  Allocate device structure.
 *
 * Calling/Exit State:
 *  Stores address of device structure through devp
 *  and returns 0 on success, otherwise returns error
 *  code.
 *
 * Description:
 *  If an entry for the device already exists increment
 *  the reference count and return the address, otherwise
 *  allocate a new structure.
 *
 *  A new structure is allocated before scanning the device
 *  chain to avoid calling the memory allocator with a spin
 *  lock held. If the device is found the new structure is
 *  free'd.
 *
 *  The device chain is protected by _nsc_io_lock.
 */
static int
_nsc_alloc_dev(char *path, nsc_dev_t **devp)
{
    nsc_dev_t *dev, *dp, **ddp;
    nsc_devval_t *dv;
    nsc_rval_t *rval;
    ncall_t *ncall;
    int rc;

    if (!(dev = (nsc_dev_t *)nsc_kmem_zalloc(
        sizeof (*dev), KM_SLEEP, _nsc_local_mem)))
        return (ENOMEM);

    dev->nsc_refcnt++;

    mutex_init(&dev->nsc_lock, NULL, MUTEX_DRIVER, NULL);
    cv_init(&dev->nsc_cv, NULL, CV_DRIVER, NULL);

    dev->nsc_phash = nsc_strhash(path);
    dev->nsc_path = nsc_strdup(path);

    mutex_enter(&_nsc_io_lock);

    dev->nsc_next = _nsc_dev_pend;
    _nsc_dev_pend = dev;

    mutex_exit(&_nsc_io_lock);

    mutex_enter(&_nsc_io_lock);

    for (dp = _nsc_dev_top; dp; dp = dp->nsc_next)
        if (dp->nsc_phash == dev->nsc_phash &&
            strcmp(dp->nsc_path, dev->nsc_path) == 0) {
            dp->nsc_refcnt++;
            break;
        }

    if (!dp) {
        for (ddp = &_nsc_dev_pend; *ddp; ddp = &(*ddp)->nsc_next)
            if (*ddp == dev) {
                *ddp = dev->nsc_next;
                break;
            }

        dev->nsc_next = _nsc_dev_top;
        _nsc_dev_top = dev;
    }

    mutex_exit(&_nsc_io_lock);

    if (dp) {
        _nsc_free_dev(dev);
        dev = dp;
    }

    /*
     * Try and find the device/values header for this device
     * and link it back to the device structure.
     */

    mutex_enter(&_nsc_devval_lock);

    if (dev->nsc_values == NULL) {
        for (dv = _nsc_devval_top; dv; dv = dv->dv_next) {
            if (dv->dv_phash == dev->nsc_phash &&
                strcmp(dv->dv_path, dev->nsc_path) == 0) {
                dev->nsc_values = dv;
                break;
            }
        }
    }

    mutex_exit(&_nsc_devval_lock);

    /*
     * Refresh the device/values from the other node
     */

    rval = nsc_kmem_zalloc(sizeof (*rval), KM_SLEEP, _nsc_local_mem);
    if (rval == NULL) {
        goto out;
    }

    rc = ncall_alloc(ncall_mirror(ncall_self()), 0, 0, &ncall);
    if (rc == 0) {
        (void) strncpy(rval->path, path, sizeof (rval->path));

        rc = ncall_put_data(ncall, rval, sizeof (*rval));
        if (rc == 0) {
            /*
             * Send synchronously and read a reply
             * so that we know that the updates
             * have completed before this
             * function returns.
             */
            if (ncall_send(ncall, 0, NSC_SETVAL_ALL) == 0)
                (void) ncall_read_reply(ncall, 1, &rc);
        }

        ncall_free(ncall);
    }

    nsc_kmem_free(rval, sizeof (*rval));

out:
    *devp = dev;
    return (0);
}


/*
 * static void
 * _nsc_free_dev (nsc_dev_t *dev)
 *  Free device structure.
 *
 * Description:
 *  Decrements the reference count of a previously allocated
 *  device structure. If this is the last reference it is
 *  removed from the device chain and free'd once pending
 *  activity has completed.
 *
 *  Whilst waiting for pending activity to cease the device is
 *  relinked onto the pending chain.
 */
static void
_nsc_free_dev(dev)
nsc_dev_t *dev;
{
    nsc_dev_t **ddp;

    if (!dev)
        return;

    mutex_enter(&_nsc_io_lock);

    if (--dev->nsc_refcnt > 0) {
        mutex_exit(&_nsc_io_lock);
        return;
    }

    for (ddp = &_nsc_dev_top; *ddp; ddp = &(*ddp)->nsc_next)
        if (*ddp == dev) {
            *ddp = dev->nsc_next;
            dev->nsc_next = _nsc_dev_pend;
            _nsc_dev_pend = dev;
            break;
        }

    mutex_exit(&_nsc_io_lock);

    mutex_enter(&dev->nsc_lock);

    while (dev->nsc_pend || dev->nsc_rpend || dev->nsc_wait) {
        cv_wait(&dev->nsc_cv, &dev->nsc_lock);
    }

    mutex_exit(&dev->nsc_lock);

    mutex_enter(&_nsc_io_lock);

    for (ddp = &_nsc_dev_pend; *ddp; ddp = &(*ddp)->nsc_next)
        if (*ddp == dev) {
            *ddp = dev->nsc_next;
            break;
        }

    mutex_exit(&_nsc_io_lock);

    mutex_destroy(&dev->nsc_lock);
    cv_destroy(&dev->nsc_cv);
    nsc_strfree(dev->nsc_path);

    nsc_kmem_free(dev, sizeof (*dev));
}


/*
 * static nsc_io_t *
 * _nsc_alloc_io (int id, char *name, int flag)
 *  Allocate an I/O structure.
 *
 * Calling/Exit State:
 *  Returns the address of the I/O structure, or NULL.
 */
static nsc_io_t *
_nsc_alloc_io(id, name, flag)
int id;
char *name;
int flag;
{
    nsc_io_t *io;

    if (!(io = (nsc_io_t *)nsc_kmem_zalloc(
            sizeof (*io), KM_NOSLEEP, _nsc_local_mem)))
        return (NULL);

    cv_init(&io->cv, NULL, CV_DRIVER, NULL);

    io->id = id;
    io->name = name;
    io->flag = flag;

    return (io);
}


/*
 * static void
 * _nsc_free_io (int id, char *name, int flag)
 *  Free an I/O structure.
 *
 * Calling/Exit State:
 *  Free the I/O structure and remove it from the chain.
 */
static void
_nsc_free_io(io)
nsc_io_t *io;
{
    nsc_io_t **iop;

    mutex_enter(&_nsc_io_lock);

    for (iop = &_nsc_io_top; *iop; iop = &(*iop)->next)
        if (*iop == io)
            break;

    if (*iop)
        (*iop) = io->next;

    mutex_exit(&_nsc_io_lock);

    cv_destroy(&io->cv);
    nsc_kmem_free(io, sizeof (*io));
}