[dragonfly.git] / sys / vfs / nwfs / nwfs_io.c

/*
 * Copyright (c) 1999, Boris Popov
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *    This product includes software developed by Boris Popov.
 * 4. Neither the name of the author nor the names of any co-contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * $FreeBSD: src/sys/nwfs/nwfs_io.c,v 1.6.2.1 2000/10/25 02:11:10 bp Exp $
 * $DragonFly: src/sys/vfs/nwfs/nwfs_io.c,v 1.24 2007/02/22 15:50:50 corecode Exp $
 *
 */
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/resourcevar.h>	/* defines plimit structure in proc struct */
#include <sys/kernel.h>
#include <sys/buf.h>
#include <sys/proc.h>
#include <sys/mount.h>
#include <sys/namei.h>
#include <sys/vnode.h>
#include <sys/dirent.h>
#include <sys/signalvar.h>
#include <sys/sysctl.h>

#include <vm/vm.h>
#include <vm/vm_page.h>
#include <vm/vm_extern.h>
#include <vm/vm_object.h>
#include <vm/vm_pager.h>
#include <vm/vnode_pager.h>

#include <netproto/ncp/ncp.h>
#include <netproto/ncp/ncp_conn.h>
#include <netproto/ncp/ncp_subr.h>

#include <sys/thread2.h>

#include <machine/limits.h>

#include "nwfs.h"
#include "nwfs_node.h"
#include "nwfs_subr.h"

static int nwfs_fastlookup = 1;

SYSCTL_DECL(_vfs_nwfs);
SYSCTL_INT(_vfs_nwfs, OID_AUTO, fastlookup, CTLFLAG_RW, &nwfs_fastlookup, 0, "");


extern int nwfs_pbuf_freecnt;

#define	NWFS_RWCACHE

static int
nwfs_readvdir(struct vnode *vp, struct uio *uio, struct ucred *cred)
{
	struct nwmount *nmp = VTONWFS(vp);
	int error, i;
	struct nwnode *np;
	struct nw_entry_info fattr;
	struct vnode *newvp;
	ncpfid fid;
	ino_t d_ino;
	size_t d_namlen;
	const char *d_name;
	uint8_t d_type;

	np = VTONW(vp);
	NCPVNDEBUG("dirname='%s'\n",np->n_name);
	if (uio->uio_offset < 0 || uio->uio_offset > INT_MAX)
		return (EINVAL);
	error = 0;
	i = (int)uio->uio_offset; /* offset in directory */
	if (i == 0) {
		error = ncp_initsearch(vp, uio->uio_td, cred);
		if (error) {
			NCPVNDEBUG("cannot initialize search, error=%d",error);
			return( error );
		}
	}

	for (; !error && uio->uio_resid > 0; i++) {
		switch (i) {
		    case 0:		/* `.' */
			d_ino = np->n_fid.f_id;
			if (d_ino == 0)
				d_ino = NWFS_ROOT_INO;
			d_namlen = 1;
			d_name = ".";
			d_type = DT_DIR;
			break;
		    case 1:		/* `..' */
			d_ino = np->n_parent.f_id;
			if (d_ino == 0)
				d_ino = NWFS_ROOT_INO;
			d_namlen = 2;
			d_name = "..";
			d_type = DT_DIR;
			break;
		    default:
			error = ncp_search_for_file_or_subdir(nmp, &np->n_seq, &fattr, uio->uio_td, cred);
			if (error && error < 0x80)
				goto done;
			d_ino = fattr.dirEntNum;
			d_type = (fattr.attributes & aDIR) ? DT_DIR : DT_REG;
			d_namlen = fattr.nameLen;
			d_name = fattr.entryName;
#if 0
			if (error && eofflag) {
			/*	*eofflag = 1;*/
			        break;
			}
#endif
			break;
		}
		if (nwfs_fastlookup && !error && i > 1) {
			fid.f_id = fattr.dirEntNum;
			fid.f_parent = np->n_fid.f_id;
			error = nwfs_nget(vp->v_mount, fid, &fattr, vp, &newvp);
			if (!error) {
				VTONW(newvp)->n_ctime = VTONW(newvp)->n_vattr.va_ctime.tv_sec;
				vput(newvp);
			} else
				error = 0;
		}
		if (error >= 0x80) {
		    error = 0;
		    break;
		}
		if (vop_write_dirent(&error, uio, d_ino, d_type, d_namlen, d_name))
			break;
	}
done:
	uio->uio_offset = i;
	return (error);
}

int
nwfs_readvnode(struct vnode *vp, struct uio *uiop, struct ucred *cred)
{
	struct nwmount *nmp = VFSTONWFS(vp->v_mount);
	struct nwnode *np = VTONW(vp);
	struct thread *td;
	struct vattr vattr;
	int error, biosize;

	if (vp->v_type != VREG && vp->v_type != VDIR) {
		kprintf("%s: vn types other than VREG or VDIR are unsupported !\n",__func__);
		return EIO;
	}
	if (uiop->uio_resid == 0) return 0;
	if (uiop->uio_offset < 0) return EINVAL;
	td = uiop->uio_td;
	if (vp->v_type == VDIR) {
		error = nwfs_readvdir(vp, uiop, cred);
		return error;
	}
	biosize = NWFSTOCONN(nmp)->buffer_size;
	if (np->n_flag & NMODIFIED) {
		nwfs_attr_cacheremove(vp);
		error = VOP_GETATTR(vp, &vattr);
		if (error) return (error);
		np->n_mtime = vattr.va_mtime.tv_sec;
	} else {
		error = VOP_GETATTR(vp, &vattr);
		if (error) return (error);
		if (np->n_mtime != vattr.va_mtime.tv_sec) {
			error = nwfs_vinvalbuf(vp, V_SAVE, 1);
			if (error) return (error);
			np->n_mtime = vattr.va_mtime.tv_sec;
		}
	}
	error = ncp_read(NWFSTOCONN(nmp), &np->n_fh, uiop,cred);
	return (error);
}

int
nwfs_writevnode(struct vnode *vp, struct uio *uiop, struct ucred *cred,
		int ioflag)
{
	struct nwmount *nmp = VTONWFS(vp);
	struct nwnode *np = VTONW(vp);
	struct thread *td;
/*	struct vattr vattr;*/
	int error = 0;

	if (vp->v_type != VREG) {
		kprintf("%s: vn types other than VREG unsupported !\n",__func__);
		return EIO;
	}
	NCPVNDEBUG("ofs=%d,resid=%d\n",(int)uiop->uio_offset, uiop->uio_resid);
	if (uiop->uio_offset < 0) return EINVAL;
	td = uiop->uio_td;
	if (ioflag & (IO_APPEND | IO_SYNC)) {
		if (np->n_flag & NMODIFIED) {
			nwfs_attr_cacheremove(vp);
			error = nwfs_vinvalbuf(vp, V_SAVE, 1);
			if (error) return (error);
		}
		if (ioflag & IO_APPEND) {
		/* We can relay only on local information about file size,
		 * because until file is closed NetWare will not return
		 * the correct size. */
#if notyet
			nwfs_attr_cacheremove(vp);
			error = VOP_GETATTR(vp, &vattr);
			if (error) return (error);
#endif
			uiop->uio_offset = np->n_size;
		}
	}
	if (uiop->uio_resid == 0) return 0;
	if (td->td_proc && uiop->uio_offset + uiop->uio_resid > 
	    td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
		lwpsignal(td->td_proc, td->td_lwp, SIGXFSZ);
		return (EFBIG);
	}
	error = ncp_write(NWFSTOCONN(nmp), &np->n_fh, uiop, cred);
	NCPVNDEBUG("after: ofs=%d,resid=%d\n",(int)uiop->uio_offset, uiop->uio_resid);
	if (!error) {
		if (uiop->uio_offset > np->n_size) {
			np->n_vattr.va_size = np->n_size = uiop->uio_offset;
			vnode_pager_setsize(vp, np->n_size);
		}
	}
	return (error);
}

/*
 * Do an I/O operation to/from a cache block.
 */
int
nwfs_doio(struct vnode *vp, struct bio *bio, struct ucred *cr, struct thread *td)
{
	struct buf *bp = bio->bio_buf;
	struct uio *uiop;
	struct nwnode *np;
	struct nwmount *nmp;
	int error = 0;
	struct uio uio;
	struct iovec io;

	np = VTONW(vp);
	nmp = VFSTONWFS(vp->v_mount);
	uiop = &uio;
	uiop->uio_iov = &io;
	uiop->uio_iovcnt = 1;
	uiop->uio_segflg = UIO_SYSSPACE;
	uiop->uio_td = td;

	if (bp->b_cmd == BUF_CMD_READ) {
	    io.iov_len = uiop->uio_resid = (size_t)bp->b_bcount;
	    io.iov_base = bp->b_data;
	    uiop->uio_rw = UIO_READ;
	    switch (vp->v_type) {
	      case VREG:
		uiop->uio_offset = bio->bio_offset;
		error = ncp_read(NWFSTOCONN(nmp), &np->n_fh, uiop, cr);
		if (error)
			break;
		if (uiop->uio_resid) {
			size_t left = uiop->uio_resid;
			size_t nread = bp->b_bcount - left;
			if (left > 0)
				bzero((char *)bp->b_data + nread, left);
		}
		break;
/*	    case VDIR:
		nfsstats.readdir_bios++;
		uiop->uio_offset = bio->bio_offset;
		if (nmp->nm_flag & NFSMNT_RDIRPLUS) {
			error = nfs_readdirplusrpc(vp, uiop, cr);
			if (error == NFSERR_NOTSUPP)
				nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
		}
		if ((nmp->nm_flag & NFSMNT_RDIRPLUS) == 0)
			error = nfs_readdirrpc(vp, uiop, cr);
		if (error == 0 && uiop->uio_resid == (size_t)bp->b_bcount)
			bp->b_flags |= B_INVAL;
		break;
*/
	    default:
		kprintf("nwfs_doio:  type %x unexpected\n",vp->v_type);
		break;
	    };
	    if (error) {
		bp->b_flags |= B_ERROR;
		bp->b_error = error;
	    }
	} else { /* write */
	    KKASSERT(bp->b_cmd == BUF_CMD_WRITE);
	    if (bio->bio_offset + bp->b_dirtyend > np->n_size)
		bp->b_dirtyend = np->n_size - bio->bio_offset;

	    if (bp->b_dirtyend > bp->b_dirtyoff) {
		io.iov_len = uiop->uio_resid =
			(size_t)(bp->b_dirtyend - bp->b_dirtyoff);
		uiop->uio_offset = bio->bio_offset + bp->b_dirtyoff;
		io.iov_base = (char *)bp->b_data + bp->b_dirtyoff;
		uiop->uio_rw = UIO_WRITE;
		error = ncp_write(NWFSTOCONN(nmp), &np->n_fh, uiop, cr);

		/*
		 * For an interrupted write, the buffer is still valid
		 * and the write hasn't been pushed to the server yet,
		 * so we can't set B_ERROR and report the interruption
		 * by setting B_EINTR. For the async case, B_EINTR
		 * is not relevant, so the rpc attempt is essentially
		 * a noop.  For the case of a V3 write rpc not being
		 * committed to stable storage, the block is still
		 * dirty and requires either a commit rpc or another
		 * write rpc with iomode == NFSV3WRITE_FILESYNC before
		 * the block is reused. This is indicated by setting
		 * the B_DELWRI and B_NEEDCOMMIT flags.
		 */
    		if (error == EINTR
		    || (!error && (bp->b_flags & B_NEEDCOMMIT))) {

			crit_enter();
			bp->b_flags &= ~(B_INVAL|B_NOCACHE);
			if ((bp->b_flags & B_PAGING) == 0)
			    bdirty(bp);
			bp->b_flags |= B_EINTR;
			crit_exit();
	    	} else {
			if (error) {
				bp->b_flags |= B_ERROR;
				bp->b_error /*= np->n_error */= error;
/*				np->n_flag |= NWRITEERR;*/
			}
			bp->b_dirtyoff = bp->b_dirtyend = 0;
		}
	    } else {
		bp->b_resid = 0;
		biodone(bio);
		return (0);
	    }
	}
	bp->b_resid = (int)uiop->uio_resid;
	biodone(bio);
	return (error);
}

/*
 * Vnode op for VM getpages.
 * Wish wish .... get rid from multiple IO routines
 *
 * nwfs_getpages(struct vnode *a_vp, vm_page_t *a_m, int a_count,
 *		 int a_reqpage, vm_ooffset_t a_offset)
 */
int
nwfs_getpages(struct vop_getpages_args *ap)
{
#ifndef NWFS_RWCACHE
	return vnode_pager_generic_getpages(ap->a_vp, ap->a_m, ap->a_count,
		ap->a_reqpage);
#else
	int i, error, npages;
	size_t nextoff, toff;
	size_t count;
	size_t size;
	struct uio uio;
	struct iovec iov;
	vm_offset_t kva;
	struct buf *bp;
	struct vnode *vp;
	struct thread *td = curthread;	/* XXX */
	struct ucred *cred;
	struct nwmount *nmp;
	struct nwnode *np;
	vm_page_t *pages;

	KKASSERT(td->td_proc);
	cred = td->td_proc->p_ucred;

	vp = ap->a_vp;
	np = VTONW(vp);
	nmp = VFSTONWFS(vp->v_mount);
	pages = ap->a_m;
	count = (size_t)ap->a_count;

	if (vp->v_object == NULL) {
		kprintf("nwfs_getpages: called with non-merged cache vnode??\n");
		return VM_PAGER_ERROR;
	}

	bp = getpbuf(&nwfs_pbuf_freecnt);
	npages = btoc(count);
	kva = (vm_offset_t) bp->b_data;
	pmap_qenter(kva, pages, npages);

	iov.iov_base = (caddr_t) kva;
	iov.iov_len = count;
	uio.uio_iov = &iov;
	uio.uio_iovcnt = 1;
	uio.uio_offset = IDX_TO_OFF(pages[0]->pindex);
	uio.uio_resid = count;
	uio.uio_segflg = UIO_SYSSPACE;
	uio.uio_rw = UIO_READ;
	uio.uio_td = td;

	error = ncp_read(NWFSTOCONN(nmp), &np->n_fh, &uio,cred);
	pmap_qremove(kva, npages);

	relpbuf(bp, &nwfs_pbuf_freecnt);

	if (error && (uio.uio_resid == count)) {
		kprintf("nwfs_getpages: error %d\n",error);
		for (i = 0; i < npages; i++) {
			if (ap->a_reqpage != i)
				vnode_pager_freepage(pages[i]);
		}
		return VM_PAGER_ERROR;
	}

	size = count - uio.uio_resid;

	for (i = 0, toff = 0; i < npages; i++, toff = nextoff) {
		vm_page_t m;
		nextoff = toff + PAGE_SIZE;
		m = pages[i];

		m->flags &= ~PG_ZERO;

		if (nextoff <= size) {
			m->valid = VM_PAGE_BITS_ALL;
			m->dirty = 0;
		} else {
			int nvalid = ((size + DEV_BSIZE - 1) - toff) & ~(DEV_BSIZE - 1);
			vm_page_set_validclean(m, 0, nvalid);
		}
		
		if (i != ap->a_reqpage) {
			/*
			 * Whether or not to leave the page activated is up in
			 * the air, but we should put the page on a page queue
			 * somewhere (it already is in the object).  Result:
			 * It appears that emperical results show that
			 * deactivating pages is best.
			 */

			/*
			 * Just in case someone was asking for this page we
			 * now tell them that it is ok to use.
			 */
			if (!error) {
				if (m->flags & PG_WANTED)
					vm_page_activate(m);
				else
					vm_page_deactivate(m);
				vm_page_wakeup(m);
			} else {
				vnode_pager_freepage(m);
			}
		}
	}
	return 0;
#endif /* NWFS_RWCACHE */
}

/*
 * Vnode op for VM putpages.
 * possible bug: all IO done in sync mode
 * Note that vop_close always invalidate pages before close, so it's
 * not necessary to open vnode.
 *
 * nwfs_putpages(struct vnode *a_vp, vm_page_t *a_m, int a_count,
 *		 int a_sync, int *a_rtvals, vm_ooffset_t a_offset)
 */
int
nwfs_putpages(struct vop_putpages_args *ap)
{
	int error;
	struct thread *td = curthread;	/* XXX */
	struct vnode *vp = ap->a_vp;
	struct ucred *cred;

#ifndef NWFS_RWCACHE
	KKASSERT(td->td_proc);
	cred = td->td_proc->p_ucred;		/* XXX */
	VOP_OPEN(vp, FWRITE, cred, NULL);
	error = vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
		ap->a_sync, ap->a_rtvals);
	VOP_CLOSE(vp, FWRITE, cred);
	return error;
#else
	struct uio uio;
	struct iovec iov;
	vm_offset_t kva;
	struct buf *bp;
	int i, npages, count;
	int *rtvals;
	struct nwmount *nmp;
	struct nwnode *np;
	vm_page_t *pages;

	KKASSERT(td->td_proc);
	cred = td->td_proc->p_ucred;		/* XXX */

/*	VOP_OPEN(vp, FWRITE, cred, NULL);*/
	np = VTONW(vp);
	nmp = VFSTONWFS(vp->v_mount);
	pages = ap->a_m;
	count = ap->a_count;
	rtvals = ap->a_rtvals;
	npages = btoc(count);

	for (i = 0; i < npages; i++) {
		rtvals[i] = VM_PAGER_AGAIN;
	}

	bp = getpbuf(&nwfs_pbuf_freecnt);
	kva = (vm_offset_t) bp->b_data;
	pmap_qenter(kva, pages, npages);

	iov.iov_base = (caddr_t) kva;
	iov.iov_len = count;
	uio.uio_iov = &iov;
	uio.uio_iovcnt = 1;
	uio.uio_offset = IDX_TO_OFF(pages[0]->pindex);
	uio.uio_resid = count;
	uio.uio_segflg = UIO_SYSSPACE;
	uio.uio_rw = UIO_WRITE;
	uio.uio_td = td;
	NCPVNDEBUG("ofs=%d,resid=%d\n",(int)uio.uio_offset, uio.uio_resid);

	error = ncp_write(NWFSTOCONN(nmp), &np->n_fh, &uio, cred);
/*	VOP_CLOSE(vp, FWRITE, cred);*/
	NCPVNDEBUG("paged write done: %d\n", error);

	pmap_qremove(kva, npages);
	relpbuf(bp, &nwfs_pbuf_freecnt);

	if (!error) {
		int nwritten = round_page(count - uio.uio_resid) / PAGE_SIZE;
		for (i = 0; i < nwritten; i++) {
			rtvals[i] = VM_PAGER_OK;
			pages[i]->dirty = 0;
		}
	}
	return rtvals[0];
#endif /* NWFS_RWCACHE */
}
/*
 * Flush and invalidate all dirty buffers. If another process is already
 * doing the flush, just wait for completion.
 */
int
nwfs_vinvalbuf(struct vnode *vp, int flags, int intrflg)
{
	struct nwnode *np = VTONW(vp);
/*	struct nwmount *nmp = VTONWFS(vp);*/
	int error = 0, slpflag, slptimeo;

	if (vp->v_flag & VRECLAIMED) {
		return (0);
	}
	if (intrflg) {
		slpflag = PCATCH;
		slptimeo = 2 * hz;
	} else {
		slpflag = 0;
		slptimeo = 0;
	}
	while (np->n_flag & NFLUSHINPROG) {
		np->n_flag |= NFLUSHWANT;
		error = tsleep((caddr_t)&np->n_flag, 0, "nwfsvinv", slptimeo);
		error = ncp_chkintr(NWFSTOCONN(VTONWFS(vp)), curthread);
		if (error == EINTR && intrflg)
			return EINTR;
	}
	np->n_flag |= NFLUSHINPROG;
	error = vinvalbuf(vp, flags, slpflag, 0);
	while (error) {
		if (intrflg && (error == ERESTART || error == EINTR)) {
			np->n_flag &= ~NFLUSHINPROG;
			if (np->n_flag & NFLUSHWANT) {
				np->n_flag &= ~NFLUSHWANT;
				wakeup((caddr_t)&np->n_flag);
			}
			return EINTR;
		}
		error = vinvalbuf(vp, flags, slpflag, 0);
	}
	np->n_flag &= ~(NMODIFIED | NFLUSHINPROG);
	if (np->n_flag & NFLUSHWANT) {
		np->n_flag &= ~NFLUSHWANT;
		wakeup((caddr_t)&np->n_flag);
	}
	return (error);
}
Commit	Line	Data
984263bc MD	1	/*
	2	* Copyright (c) 1999, Boris Popov
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. All advertising materials mentioning features or use of this software
	14	* must display the following acknowledgement:
	15	* This product includes software developed by Boris Popov.
	16	* 4. Neither the name of the author nor the names of any co-contributors
	17	* may be used to endorse or promote products derived from this software
	18	* without specific prior written permission.
	19	*
	20	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	21	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	22	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	23	* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	24	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	25	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	26	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	27	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	28	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	29	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	30	* SUCH DAMAGE.
	31	*
	32	* $FreeBSD: src/sys/nwfs/nwfs_io.c,v 1.6.2.1 2000/10/25 02:11:10 bp Exp $
7278a846	33	* $DragonFly: src/sys/vfs/nwfs/nwfs_io.c,v 1.24 2007/02/22 15:50:50 corecode Exp $
984263bc MD	34	*
	35	*/
	36	#include <sys/param.h>
	37	#include <sys/systm.h>
	38	#include <sys/resourcevar.h> /* defines plimit structure in proc struct */
	39	#include <sys/kernel.h>
	40	#include <sys/buf.h>
	41	#include <sys/proc.h>
	42	#include <sys/mount.h>
	43	#include <sys/namei.h>
	44	#include <sys/vnode.h>
	45	#include <sys/dirent.h>
	46	#include <sys/signalvar.h>
	47	#include <sys/sysctl.h>
	48
	49	#include <vm/vm.h>
	50	#include <vm/vm_page.h>
	51	#include <vm/vm_extern.h>
	52	#include <vm/vm_object.h>
	53	#include <vm/vm_pager.h>
	54	#include <vm/vnode_pager.h>
	55
d2438d69 MD	56	#include <netproto/ncp/ncp.h>
	57	#include <netproto/ncp/ncp_conn.h>
	58	#include <netproto/ncp/ncp_subr.h>
984263bc	59
165dba55 DR	60	#include <sys/thread2.h>
165dba55 DR	61
b7d9f6b6 JS	62	#include <machine/limits.h>
b7d9f6b6 JS	63
1f2de5d4 MD	64	#include "nwfs.h"
	65	#include "nwfs_node.h"
	66	#include "nwfs_subr.h"
984263bc MD	67
	68	static int nwfs_fastlookup = 1;
	69
984263bc MD	70	SYSCTL_DECL(_vfs_nwfs);
	71	SYSCTL_INT(_vfs_nwfs, OID_AUTO, fastlookup, CTLFLAG_RW, &nwfs_fastlookup, 0, "");
	72
	73
	74	extern int nwfs_pbuf_freecnt;
	75
984263bc MD	76	#define NWFS_RWCACHE
	77
	78	static int
a9bb80e0 CP	79	nwfs_readvdir(struct vnode vp, struct uio uio, struct ucred *cred)
a9bb80e0 CP	80	{
984263bc	81	struct nwmount *nmp = VTONWFS(vp);
e54488bb	82	int error, i;
9e758ef5	83	struct nwnode *np;
984263bc MD	84	struct nw_entry_info fattr;
984263bc MD	85	struct vnode *newvp;
984263bc	86	ncpfid fid;
b7d9f6b6 JS	87	ino_t d_ino;
	88	size_t d_namlen;
	89	const char *d_name;
	90	uint8_t d_type;
984263bc MD	91
	92	np = VTONW(vp);
	93	NCPVNDEBUG("dirname='%s'\n",np->n_name);
e54488bb	94	if (uio->uio_offset < 0 \|\| uio->uio_offset > INT_MAX)
984263bc MD	95	return (EINVAL);
984263bc MD	96	error = 0;
e54488bb	97	i = (int)uio->uio_offset; /* offset in directory */
984263bc	98	if (i == 0) {
dadab5e9	99	error = ncp_initsearch(vp, uio->uio_td, cred);
984263bc MD	100	if (error) {
	101	NCPVNDEBUG("cannot initialize search, error=%d",error);
	102	return( error );
	103	}
	104	}
	105
b7d9f6b6	106	for (; !error && uio->uio_resid > 0; i++) {
984263bc MD	107	switch (i) {
984263bc MD	108	case 0: /* `.' */
b7d9f6b6 JS	109	d_ino = np->n_fid.f_id;
	110	if (d_ino == 0)
	111	d_ino = NWFS_ROOT_INO;
	112	d_namlen = 1;
	113	d_name = ".";
	114	d_type = DT_DIR;
	115	break;
984263bc	116	case 1: /* `..' */
b7d9f6b6 JS	117	d_ino = np->n_parent.f_id;
	118	if (d_ino == 0)
	119	d_ino = NWFS_ROOT_INO;
	120	d_namlen = 2;
	121	d_name = "..";
	122	d_type = DT_DIR;
984263bc MD	123	break;
984263bc MD	124	default:
dadab5e9	125	error = ncp_search_for_file_or_subdir(nmp, &np->n_seq, &fattr, uio->uio_td, cred);
b7d9f6b6 JS	126	if (error && error < 0x80)
	127	goto done;
	128	d_ino = fattr.dirEntNum;
	129	d_type = (fattr.attributes & aDIR) ? DT_DIR : DT_REG;
	130	d_namlen = fattr.nameLen;
	131	d_name = fattr.entryName;
984263bc MD	132	#if 0
	133	if (error && eofflag) {
	134	/* eofflag = 1;/
	135	break;
	136	}
	137	#endif
	138	break;
	139	}
	140	if (nwfs_fastlookup && !error && i > 1) {
	141	fid.f_id = fattr.dirEntNum;
	142	fid.f_parent = np->n_fid.f_id;
	143	error = nwfs_nget(vp->v_mount, fid, &fattr, vp, &newvp);
	144	if (!error) {
	145	VTONW(newvp)->n_ctime = VTONW(newvp)->n_vattr.va_ctime.tv_sec;
984263bc MD	146	vput(newvp);
	147	} else
	148	error = 0;
	149	}
	150	if (error >= 0x80) {
	151	error = 0;
	152	break;
	153	}
b7d9f6b6	154	if (vop_write_dirent(&error, uio, d_ino, d_type, d_namlen, d_name))
984263bc MD	155	break;
984263bc MD	156	}
b7d9f6b6 JS	157	done:
b7d9f6b6 JS	158	uio->uio_offset = i;
984263bc MD	159	return (error);
	160	}
	161
	162	int
a9bb80e0 CP	163	nwfs_readvnode(struct vnode vp, struct uio uiop, struct ucred *cred)
a9bb80e0 CP	164	{
984263bc MD	165	struct nwmount *nmp = VFSTONWFS(vp->v_mount);
984263bc MD	166	struct nwnode *np = VTONW(vp);
dadab5e9	167	struct thread *td;
984263bc MD	168	struct vattr vattr;
	169	int error, biosize;
	170
	171	if (vp->v_type != VREG && vp->v_type != VDIR) {
086c1d7e	172	kprintf("%s: vn types other than VREG or VDIR are unsupported !\n",__func__);
984263bc MD	173	return EIO;
	174	}
	175	if (uiop->uio_resid == 0) return 0;
	176	if (uiop->uio_offset < 0) return EINVAL;
dadab5e9	177	td = uiop->uio_td;
984263bc MD	178	if (vp->v_type == VDIR) {
	179	error = nwfs_readvdir(vp, uiop, cred);
	180	return error;
	181	}
	182	biosize = NWFSTOCONN(nmp)->buffer_size;
	183	if (np->n_flag & NMODIFIED) {
	184	nwfs_attr_cacheremove(vp);
87de5057	185	error = VOP_GETATTR(vp, &vattr);
984263bc MD	186	if (error) return (error);
	187	np->n_mtime = vattr.va_mtime.tv_sec;
	188	} else {
87de5057	189	error = VOP_GETATTR(vp, &vattr);
984263bc MD	190	if (error) return (error);
984263bc MD	191	if (np->n_mtime != vattr.va_mtime.tv_sec) {
87de5057	192	error = nwfs_vinvalbuf(vp, V_SAVE, 1);
984263bc MD	193	if (error) return (error);
	194	np->n_mtime = vattr.va_mtime.tv_sec;
	195	}
	196	}
	197	error = ncp_read(NWFSTOCONN(nmp), &np->n_fh, uiop,cred);
	198	return (error);
	199	}
	200
	201	int
a9bb80e0 CP	202	nwfs_writevnode(struct vnode vp, struct uio uiop, struct ucred *cred,
a9bb80e0 CP	203	int ioflag)
984263bc MD	204	{
	205	struct nwmount *nmp = VTONWFS(vp);
	206	struct nwnode *np = VTONW(vp);
dadab5e9	207	struct thread *td;
984263bc MD	208	/* struct vattr vattr;*/
	209	int error = 0;
	210
	211	if (vp->v_type != VREG) {
086c1d7e	212	kprintf("%s: vn types other than VREG unsupported !\n",__func__);
984263bc MD	213	return EIO;
	214	}
	215	NCPVNDEBUG("ofs=%d,resid=%d\n",(int)uiop->uio_offset, uiop->uio_resid);
	216	if (uiop->uio_offset < 0) return EINVAL;
dadab5e9	217	td = uiop->uio_td;
984263bc MD	218	if (ioflag & (IO_APPEND \| IO_SYNC)) {
	219	if (np->n_flag & NMODIFIED) {
	220	nwfs_attr_cacheremove(vp);
87de5057	221	error = nwfs_vinvalbuf(vp, V_SAVE, 1);
984263bc MD	222	if (error) return (error);
	223	}
	224	if (ioflag & IO_APPEND) {
	225	/* We can relay only on local information about file size,
	226	* because until file is closed NetWare will not return
	227	* the correct size. */
	228	#if notyet
	229	nwfs_attr_cacheremove(vp);
87de5057	230	error = VOP_GETATTR(vp, &vattr);
984263bc MD	231	if (error) return (error);
	232	#endif
	233	uiop->uio_offset = np->n_size;
	234	}
	235	}
	236	if (uiop->uio_resid == 0) return 0;
dadab5e9 MD	237	if (td->td_proc && uiop->uio_offset + uiop->uio_resid >
dadab5e9 MD	238	td->td_proc->p_rlimit[RLIMIT_FSIZE].rlim_cur) {
7278a846	239	lwpsignal(td->td_proc, td->td_lwp, SIGXFSZ);
984263bc MD	240	return (EFBIG);
	241	}
	242	error = ncp_write(NWFSTOCONN(nmp), &np->n_fh, uiop, cred);
	243	NCPVNDEBUG("after: ofs=%d,resid=%d\n",(int)uiop->uio_offset, uiop->uio_resid);
	244	if (!error) {
	245	if (uiop->uio_offset > np->n_size) {
	246	np->n_vattr.va_size = np->n_size = uiop->uio_offset;
	247	vnode_pager_setsize(vp, np->n_size);
	248	}
	249	}
	250	return (error);
	251	}
	252
	253	/*
	254	* Do an I/O operation to/from a cache block.
	255	*/
	256	int
81b5c339	257	nwfs_doio(struct vnode vp, struct bio bio, struct ucred cr, struct thread td)
984263bc	258	{
81b5c339	259	struct buf *bp = bio->bio_buf;
984263bc	260	struct uio *uiop;
984263bc MD	261	struct nwnode *np;
	262	struct nwmount *nmp;
	263	int error = 0;
	264	struct uio uio;
	265	struct iovec io;
	266
984263bc MD	267	np = VTONW(vp);
	268	nmp = VFSTONWFS(vp->v_mount);
	269	uiop = &uio;
	270	uiop->uio_iov = &io;
	271	uiop->uio_iovcnt = 1;
	272	uiop->uio_segflg = UIO_SYSSPACE;
dadab5e9	273	uiop->uio_td = td;
10f3fee5 MD	274
10f3fee5 MD	275	if (bp->b_cmd == BUF_CMD_READ) {
e54488bb	276	io.iov_len = uiop->uio_resid = (size_t)bp->b_bcount;
984263bc MD	277	io.iov_base = bp->b_data;
	278	uiop->uio_rw = UIO_READ;
	279	switch (vp->v_type) {
	280	case VREG:
54078292	281	uiop->uio_offset = bio->bio_offset;
984263bc MD	282	error = ncp_read(NWFSTOCONN(nmp), &np->n_fh, uiop, cr);
	283	if (error)
	284	break;
	285	if (uiop->uio_resid) {
e54488bb MD	286	size_t left = uiop->uio_resid;
e54488bb MD	287	size_t nread = bp->b_bcount - left;
984263bc	288	if (left > 0)
e54488bb	289	bzero((char *)bp->b_data + nread, left);
984263bc MD	290	}
	291	break;
	292	/* case VDIR:
	293	nfsstats.readdir_bios++;
54078292	294	uiop->uio_offset = bio->bio_offset;
984263bc MD	295	if (nmp->nm_flag & NFSMNT_RDIRPLUS) {
	296	error = nfs_readdirplusrpc(vp, uiop, cr);
	297	if (error == NFSERR_NOTSUPP)
	298	nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
	299	}
	300	if ((nmp->nm_flag & NFSMNT_RDIRPLUS) == 0)
	301	error = nfs_readdirrpc(vp, uiop, cr);
e54488bb	302	if (error == 0 && uiop->uio_resid == (size_t)bp->b_bcount)
984263bc MD	303	bp->b_flags \|= B_INVAL;
	304	break;
	305	*/
	306	default:
086c1d7e	307	kprintf("nwfs_doio: type %x unexpected\n",vp->v_type);
984263bc MD	308	break;
	309	};
	310	if (error) {
	311	bp->b_flags \|= B_ERROR;
	312	bp->b_error = error;
	313	}
	314	} else { /* write */
10f3fee5	315	KKASSERT(bp->b_cmd == BUF_CMD_WRITE);
54078292 MD	316	if (bio->bio_offset + bp->b_dirtyend > np->n_size)
54078292 MD	317	bp->b_dirtyend = np->n_size - bio->bio_offset;
984263bc MD	318
984263bc MD	319	if (bp->b_dirtyend > bp->b_dirtyoff) {
e54488bb MD	320	io.iov_len = uiop->uio_resid =
e54488bb MD	321	(size_t)(bp->b_dirtyend - bp->b_dirtyoff);
54078292	322	uiop->uio_offset = bio->bio_offset + bp->b_dirtyoff;
984263bc MD	323	io.iov_base = (char *)bp->b_data + bp->b_dirtyoff;
984263bc MD	324	uiop->uio_rw = UIO_WRITE;
984263bc	325	error = ncp_write(NWFSTOCONN(nmp), &np->n_fh, uiop, cr);
984263bc MD	326
	327	/*
	328	* For an interrupted write, the buffer is still valid
	329	* and the write hasn't been pushed to the server yet,
	330	* so we can't set B_ERROR and report the interruption
ae8e83e6	331	* by setting B_EINTR. For the async case, B_EINTR
984263bc MD	332	* is not relevant, so the rpc attempt is essentially
	333	* a noop. For the case of a V3 write rpc not being
	334	* committed to stable storage, the block is still
	335	* dirty and requires either a commit rpc or another
	336	* write rpc with iomode == NFSV3WRITE_FILESYNC before
	337	* the block is reused. This is indicated by setting
	338	* the B_DELWRI and B_NEEDCOMMIT flags.
	339	*/
	340	if (error == EINTR
	341	\|\| (!error && (bp->b_flags & B_NEEDCOMMIT))) {
984263bc	342
165dba55	343	crit_enter();
984263bc	344	bp->b_flags &= ~(B_INVAL\|B_NOCACHE);
10f3fee5	345	if ((bp->b_flags & B_PAGING) == 0)
984263bc	346	bdirty(bp);
ae8e83e6	347	bp->b_flags \|= B_EINTR;
165dba55	348	crit_exit();
984263bc MD	349	} else {
	350	if (error) {
	351	bp->b_flags \|= B_ERROR;
	352	bp->b_error /= np->n_error /= error;
	353	/* np->n_flag \|= NWRITEERR;*/
	354	}
	355	bp->b_dirtyoff = bp->b_dirtyend = 0;
	356	}
	357	} else {
	358	bp->b_resid = 0;
81b5c339	359	biodone(bio);
984263bc MD	360	return (0);
	361	}
	362	}
e54488bb	363	bp->b_resid = (int)uiop->uio_resid;
81b5c339	364	biodone(bio);
984263bc MD	365	return (error);
	366	}
	367
	368	/*
	369	* Vnode op for VM getpages.
	370	* Wish wish .... get rid from multiple IO routines
a9bb80e0 CP	371	*
	372	* nwfs_getpages(struct vnode a_vp, vm_page_t a_m, int a_count,
	373	* int a_reqpage, vm_ooffset_t a_offset)
984263bc MD	374	*/
984263bc MD	375	int
a9bb80e0	376	nwfs_getpages(struct vop_getpages_args *ap)
984263bc MD	377	{
	378	#ifndef NWFS_RWCACHE
	379	return vnode_pager_generic_getpages(ap->a_vp, ap->a_m, ap->a_count,
	380	ap->a_reqpage);
	381	#else
e54488bb MD	382	int i, error, npages;
	383	size_t nextoff, toff;
	384	size_t count;
	385	size_t size;
984263bc MD	386	struct uio uio;
	387	struct iovec iov;
	388	vm_offset_t kva;
	389	struct buf *bp;
	390	struct vnode *vp;
dadab5e9	391	struct thread td = curthread; / XXX */
984263bc MD	392	struct ucred *cred;
	393	struct nwmount *nmp;
	394	struct nwnode *np;
	395	vm_page_t *pages;
	396
dadab5e9 MD	397	KKASSERT(td->td_proc);
	398	cred = td->td_proc->p_ucred;
	399
984263bc	400	vp = ap->a_vp;
984263bc MD	401	np = VTONW(vp);
	402	nmp = VFSTONWFS(vp->v_mount);
	403	pages = ap->a_m;
e54488bb	404	count = (size_t)ap->a_count;
984263bc MD	405
984263bc MD	406	if (vp->v_object == NULL) {
086c1d7e	407	kprintf("nwfs_getpages: called with non-merged cache vnode??\n");
984263bc MD	408	return VM_PAGER_ERROR;
	409	}
	410
	411	bp = getpbuf(&nwfs_pbuf_freecnt);
	412	npages = btoc(count);
	413	kva = (vm_offset_t) bp->b_data;
	414	pmap_qenter(kva, pages, npages);
	415
	416	iov.iov_base = (caddr_t) kva;
	417	iov.iov_len = count;
	418	uio.uio_iov = &iov;
	419	uio.uio_iovcnt = 1;
	420	uio.uio_offset = IDX_TO_OFF(pages[0]->pindex);
	421	uio.uio_resid = count;
	422	uio.uio_segflg = UIO_SYSSPACE;
	423	uio.uio_rw = UIO_READ;
dadab5e9	424	uio.uio_td = td;
984263bc MD	425
	426	error = ncp_read(NWFSTOCONN(nmp), &np->n_fh, &uio,cred);
	427	pmap_qremove(kva, npages);
	428
	429	relpbuf(bp, &nwfs_pbuf_freecnt);
	430
	431	if (error && (uio.uio_resid == count)) {
086c1d7e	432	kprintf("nwfs_getpages: error %d\n",error);
984263bc MD	433	for (i = 0; i < npages; i++) {
	434	if (ap->a_reqpage != i)
	435	vnode_pager_freepage(pages[i]);
	436	}
	437	return VM_PAGER_ERROR;
	438	}
	439
	440	size = count - uio.uio_resid;
	441
	442	for (i = 0, toff = 0; i < npages; i++, toff = nextoff) {
	443	vm_page_t m;
	444	nextoff = toff + PAGE_SIZE;
	445	m = pages[i];
	446
	447	m->flags &= ~PG_ZERO;
	448
	449	if (nextoff <= size) {
	450	m->valid = VM_PAGE_BITS_ALL;
	451	m->dirty = 0;
	452	} else {
	453	int nvalid = ((size + DEV_BSIZE - 1) - toff) & ~(DEV_BSIZE - 1);
	454	vm_page_set_validclean(m, 0, nvalid);
	455	}
	456
	457	if (i != ap->a_reqpage) {
	458	/*
	459	* Whether or not to leave the page activated is up in
	460	* the air, but we should put the page on a page queue
	461	* somewhere (it already is in the object). Result:
	462	* It appears that emperical results show that
	463	* deactivating pages is best.
	464	*/
	465
	466	/*
	467	* Just in case someone was asking for this page we
	468	* now tell them that it is ok to use.
	469	*/
	470	if (!error) {
	471	if (m->flags & PG_WANTED)
	472	vm_page_activate(m);
	473	else
	474	vm_page_deactivate(m);
	475	vm_page_wakeup(m);
	476	} else {
	477	vnode_pager_freepage(m);
	478	}
	479	}
	480	}
	481	return 0;
	482	#endif /* NWFS_RWCACHE */
	483	}
	484
	485	/*
	486	* Vnode op for VM putpages.
	487	* possible bug: all IO done in sync mode
	488	* Note that vop_close always invalidate pages before close, so it's
	489	* not necessary to open vnode.
a9bb80e0 CP	490	*
	491	* nwfs_putpages(struct vnode a_vp, vm_page_t a_m, int a_count,
	492	* int a_sync, int *a_rtvals, vm_ooffset_t a_offset)
984263bc MD	493	*/
984263bc MD	494	int
a9bb80e0	495	nwfs_putpages(struct vop_putpages_args *ap)
984263bc MD	496	{
984263bc MD	497	int error;
dadab5e9	498	struct thread td = curthread; / XXX */
984263bc	499	struct vnode *vp = ap->a_vp;
984263bc MD	500	struct ucred *cred;
	501
	502	#ifndef NWFS_RWCACHE
dadab5e9 MD	503	KKASSERT(td->td_proc);
dadab5e9 MD	504	cred = td->td_proc->p_ucred; /* XXX */
87de5057	505	VOP_OPEN(vp, FWRITE, cred, NULL);
984263bc MD	506	error = vnode_pager_generic_putpages(ap->a_vp, ap->a_m, ap->a_count,
984263bc MD	507	ap->a_sync, ap->a_rtvals);
87de5057	508	VOP_CLOSE(vp, FWRITE, cred);
984263bc MD	509	return error;
	510	#else
	511	struct uio uio;
	512	struct iovec iov;
	513	vm_offset_t kva;
	514	struct buf *bp;
	515	int i, npages, count;
	516	int *rtvals;
	517	struct nwmount *nmp;
	518	struct nwnode *np;
	519	vm_page_t *pages;
	520
dadab5e9 MD	521	KKASSERT(td->td_proc);
	522	cred = td->td_proc->p_ucred; /* XXX */
	523
87de5057	524	/* VOP_OPEN(vp, FWRITE, cred, NULL);*/
984263bc MD	525	np = VTONW(vp);
	526	nmp = VFSTONWFS(vp->v_mount);
	527	pages = ap->a_m;
	528	count = ap->a_count;
	529	rtvals = ap->a_rtvals;
	530	npages = btoc(count);
	531
	532	for (i = 0; i < npages; i++) {
	533	rtvals[i] = VM_PAGER_AGAIN;
	534	}
	535
	536	bp = getpbuf(&nwfs_pbuf_freecnt);
	537	kva = (vm_offset_t) bp->b_data;
	538	pmap_qenter(kva, pages, npages);
	539
	540	iov.iov_base = (caddr_t) kva;
	541	iov.iov_len = count;
	542	uio.uio_iov = &iov;
	543	uio.uio_iovcnt = 1;
	544	uio.uio_offset = IDX_TO_OFF(pages[0]->pindex);
	545	uio.uio_resid = count;
	546	uio.uio_segflg = UIO_SYSSPACE;
	547	uio.uio_rw = UIO_WRITE;
dadab5e9	548	uio.uio_td = td;
984263bc MD	549	NCPVNDEBUG("ofs=%d,resid=%d\n",(int)uio.uio_offset, uio.uio_resid);
	550
	551	error = ncp_write(NWFSTOCONN(nmp), &np->n_fh, &uio, cred);
87de5057	552	/* VOP_CLOSE(vp, FWRITE, cred);*/
984263bc MD	553	NCPVNDEBUG("paged write done: %d\n", error);
	554
	555	pmap_qremove(kva, npages);
	556	relpbuf(bp, &nwfs_pbuf_freecnt);
	557
	558	if (!error) {
	559	int nwritten = round_page(count - uio.uio_resid) / PAGE_SIZE;
	560	for (i = 0; i < nwritten; i++) {
	561	rtvals[i] = VM_PAGER_OK;
	562	pages[i]->dirty = 0;
	563	}
	564	}
	565	return rtvals[0];
	566	#endif /* NWFS_RWCACHE */
	567	}
	568	/*
	569	* Flush and invalidate all dirty buffers. If another process is already
	570	* doing the flush, just wait for completion.
	571	*/
	572	int
87de5057	573	nwfs_vinvalbuf(struct vnode *vp, int flags, int intrflg)
984263bc MD	574	{
	575	struct nwnode *np = VTONW(vp);
	576	/* struct nwmount nmp = VTONWFS(vp);/
	577	int error = 0, slpflag, slptimeo;
	578
5fd012e0	579	if (vp->v_flag & VRECLAIMED) {
984263bc MD	580	return (0);
	581	}
	582	if (intrflg) {
	583	slpflag = PCATCH;
	584	slptimeo = 2 * hz;
	585	} else {
	586	slpflag = 0;
	587	slptimeo = 0;
	588	}
	589	while (np->n_flag & NFLUSHINPROG) {
	590	np->n_flag \|= NFLUSHWANT;
377d4740	591	error = tsleep((caddr_t)&np->n_flag, 0, "nwfsvinv", slptimeo);
87de5057	592	error = ncp_chkintr(NWFSTOCONN(VTONWFS(vp)), curthread);
984263bc MD	593	if (error == EINTR && intrflg)
	594	return EINTR;
	595	}
	596	np->n_flag \|= NFLUSHINPROG;
87de5057	597	error = vinvalbuf(vp, flags, slpflag, 0);
984263bc MD	598	while (error) {
	599	if (intrflg && (error == ERESTART \|\| error == EINTR)) {
	600	np->n_flag &= ~NFLUSHINPROG;
	601	if (np->n_flag & NFLUSHWANT) {
	602	np->n_flag &= ~NFLUSHWANT;
	603	wakeup((caddr_t)&np->n_flag);
	604	}
	605	return EINTR;
	606	}
87de5057	607	error = vinvalbuf(vp, flags, slpflag, 0);
984263bc MD	608	}
	609	np->n_flag &= ~(NMODIFIED \| NFLUSHINPROG);
	610	if (np->n_flag & NFLUSHWANT) {
	611	np->n_flag &= ~NFLUSHWANT;
	612	wakeup((caddr_t)&np->n_flag);
	613	}
	614	return (error);
	615	}