xref: /titanic_52/usr/src/uts/common/avs/ns/nsctl/nsc_resv.c (revision fcf3ce441efd61da9bb2884968af01cb7c1452cc)

/*
 * 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 2008 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

#define	__NSC_GEN__
#include <sys/ncall/ncall.h>
#include "nsc_dev.h"
#include "../nsctl.h"
#ifdef DS_DDICT
#include "../contract.h"
#endif


static int _nsc_attach_fd(nsc_fd_t *, int);
static int _nsc_detach_owner(nsc_fd_t *, int);
static int _nsc_fd_fn(nsc_fd_t *, int (*)(), int, int);
static int _nsc_attach_iodev(nsc_iodev_t *, int);
static int _nsc_attach_dev(nsc_dev_t *, int);
static int _nsc_call_dev(nsc_dev_t *, blindfn_t, blind_t,
    int *, int *, int, int, nsc_iodev_t *);


/*
 * void
 * _nsc_init_resv (void)
 *	Initialise reserve mechanism.
 *
 * Calling/Exit State:
 *	Called at initialisation time to allocate necessary
 *	data structures.
 */
void
_nsc_init_resv()
{
}


/*
 * void
 * _nsc_deinit_resv (void)
 *	De-initialise reserve mechanism.
 *
 * Calling/Exit State:
 *	Called at unload time to de-allocate resources.
 */
void
_nsc_deinit_resv()
{
}


/*
 * int
 * nsc_attach (nsc_fd_t *fd, int flag)
 *	Force attach of file descriptor.
 *
 * Calling/Exit State:
 *	Returns 0 if the attach succeeds, otherwise
 *	returns an error code.
 *
 * Description:
 *	Tries to attach the file descriptor by reserving
 *	and then releasing it. This is intended purely as
 *	a performance aid since there is no guarantee that
 *	the file descriptor will remain attached upon
 *	return.
 */
int
nsc_attach(fd, flag)
nsc_fd_t *fd;
int flag;
{
	int rc;

	rc = nsc_reserve(fd, flag);

	if (rc == 0)
		nsc_release(fd);

	return (rc);
}


/*
 * int
 * nsc_reserve (nsc_fd_t *fd, int flag)
 *	Reserve file descriptor.
 *
 * Calling/Exit State:
 *	Returns 0 if the reserve succeeds, otherwise
 *	returns an error code.
 *
 * Description:
 *	Reserves the file descriptor for either NSC_READ or
 *	NSC_WRITE access. If neither is specified the mode
 *	with which the file was opened will be used. Trying
 *	to reserve a read only file in write mode will cause
 *	EACCES to be returned.
 *
 *	If NSC_NOBLOCK is specifed and the reserve cannot be
 *	completed immediately, EAGAIN will be returned.
 *
 *	If NSC_NOWAIT is set and the device is busy, EAGAIN
 *	will be returned.
 *
 *	If NSC_TRY is set and the device is already reserved
 *	EAGAIN will be returned.
 *
 *	If NSC_PCATCH is specified and a signal is received,
 *	the reserve will be terminated and EINTR returned.
 *
 *	If NSC_MULTI is set then multiple reserves of the
 *	same type are permitted for the file descriptor.
 */
int
nsc_reserve(fd, flag)
nsc_fd_t *fd;
int flag;
{
	nsc_dev_t *dev = fd->sf_dev;
	int rc, rw;

	if ((flag & NSC_READ) == 0)
		flag |= (fd->sf_flag & NSC_RDWR);

	rw = (flag & NSC_RDWR);
	if ((fd->sf_flag & rw) != rw)
		return (EACCES);

	mutex_enter(&dev->nsc_lock);

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

	if (!rc && !fd->sf_reserve++) {
		fd->sf_aio = fd->sf_iodev->si_io;
		fd->sf_mode = (flag & NSC_MULTI);
	}

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


/*
 * int
 * nsc_reserve_lk (nsc_fd_t *fd)
 *	Reserve locked file descriptor.
 *
 * Calling/Exit State:
 *	The device lock must be held across calls to
 *	this function.
 *
 *	Must be preceeded by a successful call to nsc_avail.
 *
 * Description:
 *	Reserves the file descriptor using the mode specified
 *	when the file was opened. This is only intended for
 *	use in performance critical situations.
 */
void
nsc_reserve_lk(fd)
nsc_fd_t *fd;
{
	fd->sf_reserve = 1;
	fd->sf_aio = fd->sf_iodev->si_io;
}


/*
 * int
 * nsc_avail (nsc_fd_t *fd)
 *	Test if file descriptor is available.
 *
 * Calling/Exit State:
 *	The device lock must be held across calls to
 *	this function.
 *
 *	Returns true if the file descriptor is available to
 *	be reserved using the mode specified when the file
 *	was opened.
 *
 * Description:
 *	This is only intended for use in performance critical
 *	situations in conjunction with nsc_reserve_lk.
 */
int
nsc_avail(fd)
nsc_fd_t *fd;
{
	int rw;

	if (!fd || fd->sf_pend || fd->sf_reserve || fd->sf_reopen)
		return (0);

	if ((fd->sf_avail & _NSC_ATTACH) == 0)
		return (0);
	if ((fd->sf_avail & _NSC_PINNED) == 0)
		return (0);

	rw = (fd->sf_flag & NSC_RDWR);

	return ((fd->sf_avail & rw) == rw);
}


/*
 * int
 * nsc_held (nsc_fd_t *fd)
 *	Test if file descriptor is reserved.
 *
 * Calling/Exit State:
 *	Returns true if the file descriptor is currently
 *	reserved.
 */
int
nsc_held(fd)
nsc_fd_t *fd;
{
	return ((fd) ? fd->sf_reserve : 1);
}


/*
 * int
 * nsc_waiting (nsc_fd_t *fd)
 *	Test if another client is waiting for this device.
 *
 * Calling/Exit State:
 *	Must be called with the file descriptor reserved.
 *	Returns true if another thread is waiting to reserve this device.
 *
 * Description:
 *	This is only intended for use in performance critical
 *	situations and inherently returns historical information.
 */
int
nsc_waiting(nsc_fd_t *fd)
{
	nsc_dev_t *dev;

	if (!fd || !nsc_held(fd))
		return (FALSE);

	dev = fd->sf_dev;

	return (dev->nsc_wait || dev->nsc_refcnt <= 0);
}


/*
 * int
 * nsc_release_lk (nsc_fd_t *fd)
 *	Release locked file descriptor.
 *
 * Calling/Exit State:
 *	The device lock must be held across calls to
 *	this function.
 *
 *	Returns true if another node is waiting for the
 *	device and a call to nsc_detach should be made.
 *
 * Description:
 *	Releases the file descriptor. This is only intended
 *	for use in performance critical situations in
 *	conjunction with nsc_reserve_lk.
 */
int
nsc_release_lk(fd)
nsc_fd_t *fd;
{
	nsc_dev_t *dev = fd->sf_dev;

	fd->sf_reserve = 0;
	fd->sf_aio = _nsc_null_io;

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

	return (dev->nsc_drop > 0);
}


/*
 * int
 * nsc_release (nsc_fd_t *fd)
 *	Release file descriptor.
 *
 * Description:
 *	Releases the file descriptor. If another node
 *	is waiting for the device it will be completely
 *	detached before returning.
 */
void
nsc_release(fd)
nsc_fd_t *fd;
{
	nsc_dev_t *dev = fd->sf_dev;
	int rc;

	mutex_enter(&dev->nsc_lock);

	if (!fd->sf_reserve || --fd->sf_reserve) {
		mutex_exit(&dev->nsc_lock);
		return;
	}

	fd->sf_aio = _nsc_null_io;
	fd->sf_mode = 0;

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

	while (dev->nsc_drop > 0) {
		rc = _nsc_detach_dev(dev, NULL, NSC_RDWR);
		if (!rc || rc != ERESTART)
			break;
	}

	mutex_exit(&dev->nsc_lock);
}


/*
 * int
 * nsc_detach (nsc_fd_t *fd, int flag)
 *	Detach device from node.
 *
 * Calling/Exit State:
 *	Returns 0 if the reserve succeeds, otherwise
 *	returns an error code.
 *
 * Description:
 *	Detaches the device from the current node. If flag
 *	specifies read access then flush is called in preference
 *	to detach.
 *
 *	If NSC_NOBLOCK is specifed and the detach cannot be
 *	completed immediately, EAGAIN will be returned.
 *
 *	If NSC_TRY is set and the device is reserved, EAGAIN
 *	will be returned.
 *
 *	If NSC_NOWAIT is set and the device is busy, EAGAIN
 *	will be returned.
 *
 *	If NSC_PCATCH is specified and a signal is received,
 *	the reserve will be terminated and EINTR returned.
 *
 *	If NSC_DEFER is set and the device is reserved, then
 *	the detach will be done on release.
 */
int
nsc_detach(fd, flag)
nsc_fd_t *fd;
int flag;
{
	nsc_dev_t *dev;
	int rc;

	if (!fd)
		return (0);

	dev = fd->sf_dev;

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

	mutex_enter(&dev->nsc_lock);

	while ((rc = _nsc_detach_dev(dev, NULL, flag)) != 0)
		if (rc != ERESTART)
			break;

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

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


/*
 * static int
 * _nsc_attach_fd (nsc_fd_t *fd, int flag)
 *	Attach file descriptor.
 *
 * Calling/Exit State:
 *	The device lock must be held across calls to
 *	this function.
 *
 *	Returns 0 if the attach succeeds without releasing
 *	the device lock, otherwise returns an error code.
 *
 * Description:
 *	Attach the specified file descriptor. Other file
 *	descriptors for the same I/O device will be flushed
 *	or detached first as necessary.
 */
static int
_nsc_attach_fd(fd, flag)
nsc_fd_t *fd;
int flag;
{
	nsc_dev_t *dev = fd->sf_dev;
	int rw = (flag & NSC_RDWR);
	nsc_iodev_t *iodev;
	int rc, av;

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

	if (fd->sf_reopen)
		if ((rc = _nsc_close_fd(fd, flag)) != 0)
			return (rc);

	if (!fd->sf_iodev)
		if ((rc = _nsc_open_fd(fd, flag)) != 0)
			return (rc);

	iodev = fd->sf_iodev;

	if ((flag & fd->sf_mode & NSC_MULTI) && fd->sf_reserve)
		if ((fd->sf_avail & rw) == rw && !iodev->si_rpend)
			if (dev->nsc_drop == 0)
				return (0);

	if (fd->sf_reserve) {
		if (flag & NSC_TRY)
			return (EAGAIN);
		return (_nsc_wait_dev(dev, flag));
	}

	if (fd->sf_avail & _NSC_ATTACH)
		if (fd->sf_avail & _NSC_PINNED)
			if ((fd->sf_avail & rw) == rw)
				return (0);

	if (iodev->si_rpend && !fd->sf_avail)
		return (_nsc_wait_dev(dev, flag));

	if ((rc = _nsc_detach_iodev(iodev, fd, flag)) != 0 ||
	    (rc = _nsc_attach_iodev(iodev, flag)) != 0)
		return (rc);

	if (!fd->sf_avail) {
		fd->sf_avail = rw;
		return (_nsc_fd_fn(fd, fd->sf_attach, _NSC_ATTACH, flag));
	}

	if ((fd->sf_avail & _NSC_PINNED) == 0) {
		av = (fd->sf_avail | _NSC_PINNED);

		return _nsc_call_dev(dev, iodev->si_io->getpin,
			fd->sf_cd, &fd->sf_avail, &fd->sf_pend, av, flag, NULL);
	}

	fd->sf_avail |= rw;
	return (0);
}


/*
 * int
 * _nsc_detach_fd (nsc_fd_t *fd, int flag)
 *	Detach file descriptor.
 *
 * Calling/Exit State:
 *	The device lock must be held across calls to
 *	this function.
 *
 *	Returns 0 if the detach succeeds without releasing
 *	the device lock, otherwise returns an error code.
 *
 * Description:
 *	Detach the specified file descriptor. If flag
 *	specifies read access then flush is called in
 *	preference to detach.
 */
int
_nsc_detach_fd(fd, flag)
nsc_fd_t *fd;
int flag;
{
	nsc_dev_t *dev = fd->sf_dev;
	int rc;

	if (fd->sf_pend == _NSC_CLOSE)
		return (0);

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

	if (fd->sf_flush == nsc_null)
		flag |= NSC_RDWR;

	if ((fd->sf_avail & NSC_RDWR) == 0)
		if (!fd->sf_avail || !(flag & NSC_WRITE))
			return (0);

	if (fd->sf_reserve && fd->sf_owner)
		if ((rc = _nsc_detach_owner(fd, flag)) != 0)
			return (rc);

	if (fd->sf_reserve) {
		if (flag & NSC_TRY)
			return (EAGAIN);
		return (_nsc_wait_dev(dev, flag));
	}

	if (flag & NSC_WRITE) {
		if (fd->sf_iodev->si_busy)
			return (_nsc_wait_dev(dev, flag));

		return (_nsc_fd_fn(fd, fd->sf_detach, 0, flag));
	}

	return (_nsc_fd_fn(fd, fd->sf_flush, (fd->sf_avail & ~NSC_RDWR), flag));
}


/*
 * static int
 * _nsc_detach_owner (nsc_fd_t *fd, int flag)
 *	Detach owner of file descriptor.
 *
 * Calling/Exit State:
 *	The device lock must be held across calls to
 *	this function.
 *
 *	Returns 0 if the detach succeeds without releasing
 *	the device lock, otherwise returns an error code.
 *
 * Description:
 *	Detach the owner of the specified file descriptor.
 *	Wherever possible this is done without releasing
 *	the current device lock.
 */
static int
_nsc_detach_owner(fd, flag)
nsc_fd_t *fd;
int flag;
{
	nsc_dev_t *newdev = fd->sf_owner->si_dev;
	nsc_dev_t *dev = fd->sf_dev;
	int try;
	int rc;

	if (newdev == dev) {
		if ((rc = _nsc_detach_iodev(fd->sf_owner, NULL, flag)) == 0)
			fd->sf_owner = NULL;
		return (rc);
	}

	if ((try = mutex_tryenter(&newdev->nsc_lock)) != 0)
		if (!_nsc_detach_iodev(fd->sf_owner, NULL,
					(flag | NSC_NOBLOCK))) {
			mutex_exit(&newdev->nsc_lock);
			return (0);
		}

	if (flag & NSC_NOBLOCK) {
		if (try != 0)
			mutex_exit(&newdev->nsc_lock);
		return (EAGAIN);
	}

	fd->sf_pend = _NSC_OWNER;
	mutex_exit(&dev->nsc_lock);

	if (try == 0)
		mutex_enter(&newdev->nsc_lock);

	rc = _nsc_detach_iodev(fd->sf_owner, NULL, flag);
	fd->sf_owner = NULL;

	mutex_exit(&newdev->nsc_lock);

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

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

	return (rc ? rc : ERESTART);
}


/*
 * static int
 * _nsc_fd_fn (nsc_fd_t *fd, int (*fn)(), int a, int flag)
 *	Call function to attach/detach file descriptor.
 *
 * Calling/Exit State:
 *	The device lock must be held across calls to
 *	this function.
 *
 *	Returns an error code if the operation failed,
 *	otherwise returns ERESTART to indicate that the
 *	device state has changed.
 *
 * Description:
 *	Sets up the active I/O module and calls the
 *	specified function.
 */
static int
_nsc_fd_fn(nsc_fd_t *fd, int (*fn)(), int a, int flag)
{
	int rc;

	fd->sf_aio = fd->sf_iodev->si_io;

	rc = _nsc_call_dev(fd->sf_dev, fn, fd->sf_arg,
				&fd->sf_avail, &fd->sf_pend, a, flag, NULL);

	fd->sf_aio = _nsc_null_io;
	return (rc);
}


/*
 * static int
 * _nsc_attach_iodev (nsc_iodev_t *iodev, int flag)
 *	Attach I/O device.
 *
 * Calling/Exit State:
 *	The device lock must be held across calls to
 *	this function.
 *
 *	Returns 0 if the attach succeeds without releasing
 *	the device lock, otherwise returns an error code.
 *
 * Description:
 *	Attach the specified I/O device. Other I/O devices
 *	for the same device will be flushed or detached first
 *	as necessary.
 *
 *	It is assumed that any valid cache descriptor for
 *	this device can be used to attach the I/O device.
 */
static int
_nsc_attach_iodev(iodev, flag)
nsc_iodev_t *iodev;
int flag;
{
	nsc_dev_t *dev = iodev->si_dev;
	nsc_io_t *io = iodev->si_io;
	int rc, rw;

	rw = (flag & NSC_RDWR);

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

	if (iodev->si_avail & _NSC_ATTACH)
		if ((iodev->si_avail & rw) == rw)
			return (0);

	if ((io->flag & NSC_FILTER) == 0) {
		if (dev->nsc_rpend && !iodev->si_avail)
			return (_nsc_wait_dev(dev, flag));

		if ((rc = _nsc_detach_dev(dev, iodev, flag)) != 0 ||
		    (rc = _nsc_attach_dev(dev, flag)) != 0)
			return (rc);
	}

	if (!iodev->si_avail) {
		iodev->si_avail = rw;

		if (!iodev->si_open) {
			cmn_err(CE_PANIC,
			    "nsctl: _nsc_attach_iodev: %p no fds",
			    (void *)iodev);
		}

		return (_nsc_call_dev(dev, io->attach, iodev->si_open->sf_cd,
		    &iodev->si_avail, &iodev->si_pend, _NSC_ATTACH,
		    flag, iodev));
	}

	iodev->si_avail |= rw;
	return (0);
}


/*
 * int
 * _nsc_detach_iodev (nsc_iodev_t *iodev, nsc_fd_t *keep, int flag)
 *	Detach I/O device.
 *
 * Calling/Exit State:
 *	The device lock must be held across calls to
 *	this function.
 *
 *	Returns 0 if the detach succeeds without releasing
 *	the device lock, otherwise returns an error code.
 *
 * Description:
 *	Detach the specified I/O device except for file
 *	descriptor keep. If flag specifies read access then
 *	flush is called in preference to detach.
 *
 *	It is assumed that any valid cache descriptor for
 *	this device can be used to detach the I/O device.
 */
int
_nsc_detach_iodev(nsc_iodev_t *iodev, nsc_fd_t *keep, int flag)
{
	nsc_dev_t *dev = iodev->si_dev;
	nsc_io_t *io = iodev->si_io;
	int (*fn)(), av, rc;
	nsc_fd_t *fd;

	if (iodev->si_pend == _NSC_CLOSE)
		return (0);

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

	if (!keep && io->flush == nsc_null)
		flag |= NSC_RDWR;

	if ((iodev->si_avail & NSC_RDWR) == 0)
		if (!iodev->si_avail || !(flag & NSC_WRITE))
			return (0);

	iodev->si_rpend++;

	for (fd = iodev->si_open; fd; fd = fd->sf_next) {
		if (fd == keep)
			continue;

		if ((rc = _nsc_detach_fd(fd, flag)) != 0) {
			_nsc_wake_dev(dev, &iodev->si_rpend);
			return (rc);
		}
	}

	_nsc_wake_dev(dev, &iodev->si_rpend);

	if (keep)
		return (0);

	if (!iodev->si_open) {
		cmn_err(CE_PANIC,
		    "nsctl: _nsc_detach_iodev: %p no fds", (void *)iodev);
	}

	fn = (flag & NSC_WRITE) ? io->detach : io->flush;
	av = (flag & NSC_WRITE) ? 0 : (iodev->si_avail & ~NSC_RDWR);

	return (_nsc_call_dev(dev, fn, iodev->si_open->sf_cd,
	    &iodev->si_avail, &iodev->si_pend, av, flag, iodev));
}


/*
 * static int
 * _nsc_attach_dev (nsc_dev_t *dev, int flag)
 *	Attach device to node.
 *
 * Calling/Exit State:
 *	The device lock must be held across calls to
 *	this function.
 *
 *	Returns 0 if the attach succeeds without releasing
 *	the device lock, otherwise returns an error code.
 *
 * Description:
 *	Attach the device to the current node.
 */
static int
_nsc_attach_dev(dev, flag)
nsc_dev_t *dev;
int flag;
{
	if (dev->nsc_pend) {
		if (flag & NSC_TRY)
			return (EAGAIN);
		return (_nsc_wait_dev(dev, flag));
	}

	return (0);
}


/*
 * int
 * _nsc_detach_dev (nsc_dev_t *dev, nsc_iodev_t *keep, int flag)
 *	Detach device.
 *
 * Calling/Exit State:
 *	The device lock must be held across calls to
 *	this function.
 *
 *	Returns 0 if the detach succeeds without releasing
 *	the device lock, otherwise returns an error code.
 *
 * Description:
 *	Detach the device except for I/O descriptor keep.
 *	If flag specifies read access then flush is called
 *	in preference to detach. If appropriate the device
 *	will be released for use by another node.
 *
 *	All I/O devices are detached regardless of the
 *	current owner as a sanity check.
 */
int
_nsc_detach_dev(nsc_dev_t *dev, nsc_iodev_t *keep, int flag)
{
	nsc_iodev_t *iodev;
	int rc = 0;

	if (dev->nsc_pend) {
		if (flag & NSC_TRY)
			return (EAGAIN);
		return (_nsc_wait_dev(dev, flag));
	}

	dev->nsc_rpend++;

	for (iodev = dev->nsc_list; iodev; iodev = iodev->si_next) {
		if (iodev == keep)
			continue;
		if (iodev->si_io->flag & NSC_FILTER)
			continue;

		if ((rc = _nsc_detach_iodev(iodev, NULL, flag)) != 0)
			break;
	}

	_nsc_wake_dev(dev, &dev->nsc_rpend);

	if (keep || !(flag & NSC_WRITE))
		return (rc);
	if (rc == EAGAIN || rc == ERESTART)
		return (rc);

	dev->nsc_drop = 0;

	return (rc);
}


/*
 * static int
 * _nsc_call_dev (nsc_dev_t *dev, blindfn_t fn, blind_t arg,
 *    *int *ap, int *pp, int a, int flag, nsc_iodev_t *iodev)
 *	Call attach/detach function.
 *
 * Calling/Exit State:
 *	The device lock must be held across calls to this
 *	this function.
 *
 *	Returns an error code if the operation failed,
 *	otherwise returns ERESTART to indicate that the
 *	device state has changed.
 *
 *	The flags pointed to by ap are updated to reflect
 *	availability based upon argument a. The pending
 *	flag pointed to by pp is set whilst the operation
 *	is in progress.
 *
 * Description:
 *	Marks the device busy, temporarily releases the
 *	device lock and calls the specified function with
 *	the given argument.
 *
 *	If a detach is being performed then clear _NSC_ATTACH
 *	first to prevent pinned data callbacks. If the detach
 *	fails then clear _NSC_PINNED and indicate that a flush
 *	is required by setting NSC_READ.
 */
static int
_nsc_call_dev(nsc_dev_t *dev, blindfn_t fn, blind_t arg, int *ap, int *pp,
		int a, int flag, nsc_iodev_t *iodev)
{
	int rc = 0, v = *ap;

	if (flag & NSC_NOBLOCK)
		if (fn != nsc_null)
			return (EAGAIN);

	if (!a && v)
		*ap = (v & ~_NSC_ATTACH) | NSC_READ;

	if (fn != nsc_null) {
		*pp = (a) ? a : _NSC_DETACH;
		mutex_exit(&dev->nsc_lock);

		rc = (*fn)(arg, iodev);

		mutex_enter(&dev->nsc_lock);
		*pp = 0;
	}

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

	if (rc) {
		if (!a && v)
			a = (v & ~_NSC_PINNED) | NSC_READ;
		else if (v & _NSC_ATTACH)
			a = v;
		else
			a = 0;
	}

	*ap = a;
	return (rc ? rc : ERESTART);
}


/*
 * int
 * _nsc_wait_dev (nsc_dev_t *dev, int flag)
 *	Wait for device state to change.
 *
 * Calling/Exit State:
 *	Must be called with the device lock held.
 *	Returns EAGAIN if NSC_NOBLOCK or NSC_NOWAIT is set,
 *	or EINTR if the wait was interrupted, otherwise
 *	returns ERESTART to indicate that the device state
 *	has changed.
 *
 * Description:
 *	Waits for the device state to change before resuming.
 *
 * Remarks:
 *	If the reference count on the device has dropped to
 *	zero then cv_broadcast is called to wakeup _nsc_free_dev.
 */
int
_nsc_wait_dev(dev, flag)
nsc_dev_t *dev;
int flag;
{
	int rc = 1;

	if (flag & (NSC_NOBLOCK | NSC_NOWAIT))
		return (EAGAIN);

	dev->nsc_wait++;

	if (flag & NSC_PCATCH)
		rc = cv_wait_sig(&dev->nsc_cv, &dev->nsc_lock);
	else
		cv_wait(&dev->nsc_cv, &dev->nsc_lock);

	dev->nsc_wait--;

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

	return ((rc == 0) ? EINTR : ERESTART);
}


/*
 * void
 * _nsc_wake_dev (nsc_dev_t *dev, int *valp)
 *	Decrement value and wakeup device.
 *
 * Calling/Exit State:
 *	The device lock must be held across calls to
 *	this function.
 *
 * Description:
 *	Decrements the indicated value and if appropriate
 *	wakes up anybody waiting on the device.
 */
void
_nsc_wake_dev(dev, valp)
nsc_dev_t *dev;
int *valp;
{
	if (--(*valp))
		return;

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