/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 *

 *	Copyright (c) 1983,1984,1985,1986,1987,1988,1989 AT&T.

 *	All rights reserved.

 */

#include <sys/param.h>

#include <sys/types.h>

#include <sys/systm.h>

#include <sys/cred.h>

#include <sys/time.h>

#include <sys/vnode.h>

#include <sys/vfs.h>

#include <sys/vfs_opreg.h>

#include <sys/file.h>

#include <sys/filio.h>

#include <sys/uio.h>

#include <sys/buf.h>

#include <sys/mman.h>

#include <sys/pathname.h>

#include <sys/dirent.h>

#include <sys/debug.h>

#include <sys/vmsystm.h>

#include <sys/fcntl.h>

#include <sys/flock.h>

#include <sys/swap.h>

#include <sys/errno.h>

#include <sys/strsubr.h>

#include <sys/sysmacros.h>

#include <sys/kmem.h>

#include <sys/cmn_err.h>

#include <sys/pathconf.h>

#include <sys/utsname.h>

#include <sys/dnlc.h>

#include <sys/acl.h>

#include <sys/atomic.h>

#include <sys/policy.h>

#include <sys/sdt.h>

#include <rpc/types.h>

#include <rpc/auth.h>

#include <rpc/clnt.h>

#include <nfs/nfs.h>

#include <nfs/nfs_clnt.h>

#include <nfs/rnode.h>

#include <nfs/nfs_acl.h>

#include <nfs/lm.h>

#include <vm/hat.h>

#include <vm/as.h>

#include <vm/page.h>

#include <vm/pvn.h>

#include <vm/seg.h>

#include <vm/seg_map.h>

#include <vm/seg_kpm.h>

#include <vm/seg_vn.h>

#include <fs/fs_subr.h>

#include <sys/ddi.h>

static int	nfs_rdwrlbn(vnode_t *, page_t *, u_offset_t, size_t, int,

			cred_t *);

static int	nfswrite(vnode_t *, caddr_t, uint_t, int, cred_t *);

static int	nfsread(vnode_t *, caddr_t, uint_t, int, size_t *, cred_t *);

static int	nfssetattr(vnode_t *, struct vattr *, int, cred_t *);

static int	nfslookup_dnlc(vnode_t *, char *, vnode_t **, cred_t *);

static int	nfslookup_otw(vnode_t *, char *, vnode_t **, cred_t *, int);

static int	nfsrename(vnode_t *, char *, vnode_t *, char *, cred_t *,

			caller_context_t *);

static int	nfsreaddir(vnode_t *, rddir_cache *, cred_t *);

static int	nfs_bio(struct buf *, cred_t *);

static int	nfs_getapage(vnode_t *, u_offset_t, size_t, uint_t *,

			page_t *[], size_t, struct seg *, caddr_t,

			enum seg_rw, cred_t *);

static void	nfs_readahead(vnode_t *, u_offset_t, caddr_t, struct seg *,

			cred_t *);

static int	nfs_sync_putapage(vnode_t *, page_t *, u_offset_t, size_t,

			int, cred_t *);

static int	nfs_sync_pageio(vnode_t *, page_t *, u_offset_t, size_t,

			int, cred_t *);

static void	nfs_delmap_callback(struct as *, void *, uint_t);

/*

 * Error flags used to pass information about certain special errors

 * which need to be handled specially.

 */

#define	NFS_EOF			-98

/*

 * These are the vnode ops routines which implement the vnode interface to

 * the networked file system.  These routines just take their parameters,

 * make them look networkish by putting the right info into interface structs,

 * and then calling the appropriate remote routine(s) to do the work.

 *

 * Note on directory name lookup cacheing:  If we detect a stale fhandle,

 * we purge the directory cache relative to that vnode.  This way, the

 * user won't get burned by the cache repeatedly.  See <nfs/rnode.h> for

 * more details on rnode locking.

 */

static int	nfs_open(vnode_t **, int, cred_t *, caller_context_t *);

static int	nfs_close(vnode_t *, int, int, offset_t, cred_t *,

			caller_context_t *);

static int	nfs_read(vnode_t *, struct uio *, int, cred_t *,

			caller_context_t *);

static int	nfs_write(vnode_t *, struct uio *, int, cred_t *,

			caller_context_t *);

static int	nfs_ioctl(vnode_t *, int, intptr_t, int, cred_t *, int *,

			caller_context_t *);

static int	nfs_getattr(vnode_t *, struct vattr *, int, cred_t *,

			caller_context_t *);

static int	nfs_setattr(vnode_t *, struct vattr *, int, cred_t *,

			caller_context_t *);

static int	nfs_access(vnode_t *, int, int, cred_t *, caller_context_t *);

static int	nfs_accessx(void *, int, cred_t *);

static int	nfs_readlink(vnode_t *, struct uio *, cred_t *,

			caller_context_t *);

static int	nfs_fsync(vnode_t *, int, cred_t *, caller_context_t *);

static void	nfs_inactive(vnode_t *, cred_t *, caller_context_t *);

static int	nfs_lookup(vnode_t *, char *, vnode_t **, struct pathname *,

			int, vnode_t *, cred_t *, caller_context_t *,

			int *, pathname_t *);

static int	nfs_create(vnode_t *, char *, struct vattr *, enum vcexcl,

			int, vnode_t **, cred_t *, int, caller_context_t *,

			vsecattr_t *);

static int	nfs_remove(vnode_t *, char *, cred_t *, caller_context_t *,

			int);

static int	nfs_link(vnode_t *, vnode_t *, char *, cred_t *,

			caller_context_t *, int);

static int	nfs_rename(vnode_t *, char *, vnode_t *, char *, cred_t *,

			caller_context_t *, int);

static int	nfs_mkdir(vnode_t *, char *, struct vattr *, vnode_t **,

			cred_t *, caller_context_t *, int, vsecattr_t *);

static int	nfs_rmdir(vnode_t *, char *, vnode_t *, cred_t *,

			caller_context_t *, int);

static int	nfs_symlink(vnode_t *, char *, struct vattr *, char *,

			cred_t *, caller_context_t *, int);

static int	nfs_readdir(vnode_t *, struct uio *, cred_t *, int *,

			caller_context_t *, int);

static int	nfs_fid(vnode_t *, fid_t *, caller_context_t *);

static int	nfs_rwlock(vnode_t *, int, caller_context_t *);

static void	nfs_rwunlock(vnode_t *, int, caller_context_t *);

static int	nfs_seek(vnode_t *, offset_t, offset_t *, caller_context_t *);

static int	nfs_getpage(vnode_t *, offset_t, size_t, uint_t *,

			page_t *[], size_t, struct seg *, caddr_t,

			enum seg_rw, cred_t *, caller_context_t *);

static int	nfs_putpage(vnode_t *, offset_t, size_t, int, cred_t *,

			caller_context_t *);

static int	nfs_map(vnode_t *, offset_t, struct as *, caddr_t *, size_t,

			uchar_t, uchar_t, uint_t, cred_t *, caller_context_t *);

static int	nfs_addmap(vnode_t *, offset_t, struct as *, caddr_t, size_t,

			uchar_t, uchar_t, uint_t, cred_t *, caller_context_t *);

static int	nfs_frlock(vnode_t *, int, struct flock64 *, int, offset_t,

			struct flk_callback *, cred_t *, caller_context_t *);

static int	nfs_space(vnode_t *, int, struct flock64 *, int, offset_t,

			cred_t *, caller_context_t *);

static int	nfs_realvp(vnode_t *, vnode_t **, caller_context_t *);

static int	nfs_delmap(vnode_t *, offset_t, struct as *, caddr_t, size_t,

			uint_t, uint_t, uint_t, cred_t *, caller_context_t *);

static int	nfs_pathconf(vnode_t *, int, ulong_t *, cred_t *,

			caller_context_t *);

static int	nfs_pageio(vnode_t *, page_t *, u_offset_t, size_t, int,

			cred_t *, caller_context_t *);

static int	nfs_setsecattr(vnode_t *, vsecattr_t *, int, cred_t *,

			caller_context_t *);

static int	nfs_getsecattr(vnode_t *, vsecattr_t *, int, cred_t *,

			caller_context_t *);

static int	nfs_shrlock(vnode_t *, int, struct shrlock *, int, cred_t *,

			caller_context_t *);

struct vnodeops *nfs_vnodeops;

const fs_operation_def_t nfs_vnodeops_template[] = {

	VOPNAME_OPEN,		{ .vop_open = nfs_open },

	VOPNAME_CLOSE,		{ .vop_close = nfs_close },

	VOPNAME_READ,		{ .vop_read = nfs_read },

	VOPNAME_WRITE,		{ .vop_write = nfs_write },

	VOPNAME_IOCTL,		{ .vop_ioctl = nfs_ioctl },

	VOPNAME_GETATTR,	{ .vop_getattr = nfs_getattr },

	VOPNAME_SETATTR,	{ .vop_setattr = nfs_setattr },

	VOPNAME_ACCESS,		{ .vop_access = nfs_access },

	VOPNAME_LOOKUP,		{ .vop_lookup = nfs_lookup },

	VOPNAME_CREATE,		{ .vop_create = nfs_create },

	VOPNAME_REMOVE,		{ .vop_remove = nfs_remove },

	VOPNAME_LINK,		{ .vop_link = nfs_link },

	VOPNAME_RENAME,		{ .vop_rename = nfs_rename },

	VOPNAME_MKDIR,		{ .vop_mkdir = nfs_mkdir },

	VOPNAME_RMDIR,		{ .vop_rmdir = nfs_rmdir },

	VOPNAME_READDIR,	{ .vop_readdir = nfs_readdir },

	VOPNAME_SYMLINK,	{ .vop_symlink = nfs_symlink },

	VOPNAME_READLINK,	{ .vop_readlink = nfs_readlink },

	VOPNAME_FSYNC,		{ .vop_fsync = nfs_fsync },

	VOPNAME_INACTIVE,	{ .vop_inactive = nfs_inactive },

	VOPNAME_FID,		{ .vop_fid = nfs_fid },

	VOPNAME_RWLOCK,		{ .vop_rwlock = nfs_rwlock },

	VOPNAME_RWUNLOCK,	{ .vop_rwunlock = nfs_rwunlock },

	VOPNAME_SEEK,		{ .vop_seek = nfs_seek },

	VOPNAME_FRLOCK,		{ .vop_frlock = nfs_frlock },

	VOPNAME_SPACE,		{ .vop_space = nfs_space },

	VOPNAME_REALVP,		{ .vop_realvp = nfs_realvp },

	VOPNAME_GETPAGE,	{ .vop_getpage = nfs_getpage },

	VOPNAME_PUTPAGE,	{ .vop_putpage = nfs_putpage },

	VOPNAME_MAP,		{ .vop_map = nfs_map },

	VOPNAME_ADDMAP,		{ .vop_addmap = nfs_addmap },

	VOPNAME_DELMAP,		{ .vop_delmap = nfs_delmap },

	VOPNAME_DUMP,		{ .vop_dump = nfs_dump },

	VOPNAME_PATHCONF,	{ .vop_pathconf = nfs_pathconf },

	VOPNAME_PAGEIO,		{ .vop_pageio = nfs_pageio },

	VOPNAME_SETSECATTR,	{ .vop_setsecattr = nfs_setsecattr },

	VOPNAME_GETSECATTR,	{ .vop_getsecattr = nfs_getsecattr },

	VOPNAME_SHRLOCK,	{ .vop_shrlock = nfs_shrlock },

	VOPNAME_VNEVENT, 	{ .vop_vnevent = fs_vnevent_support },

	NULL,			NULL

};

/*

 * XXX:  This is referenced in modstubs.s

 */

struct vnodeops *

nfs_getvnodeops(void)

{

	return (nfs_vnodeops);

}

/* ARGSUSED */

static int

nfs_open(vnode_t **vpp, int flag, cred_t *cr, caller_context_t *ct)

{

	int error;

	struct vattr va;

	rnode_t *rp;

	vnode_t *vp;

	vp = *vpp;

	rp = VTOR(vp);

	if (nfs_zone() != VTOMI(vp)->mi_zone)

		return (EIO);

	mutex_enter(&rp->r_statelock);

	if (rp->r_cred == NULL) {

		crhold(cr);

		rp->r_cred = cr;

	}

	mutex_exit(&rp->r_statelock);

	/*

	 * If there is no cached data or if close-to-open

	 * consistency checking is turned off, we can avoid

	 * the over the wire getattr.  Otherwise, if the

	 * file system is mounted readonly, then just verify

	 * the caches are up to date using the normal mechanism.

	 * Else, if the file is not mmap'd, then just mark

	 * the attributes as timed out.  They will be refreshed

	 * and the caches validated prior to being used.

	 * Else, the file system is mounted writeable so

	 * force an over the wire GETATTR in order to ensure

	 * that all cached data is valid.

	 */

	if (vp->v_count > 1 ||

	    ((vn_has_cached_data(vp) || HAVE_RDDIR_CACHE(rp)) &&

	    !(VTOMI(vp)->mi_flags & MI_NOCTO))) {

		if (vn_is_readonly(vp))

			error = nfs_validate_caches(vp, cr);

		else if (rp->r_mapcnt == 0 && vp->v_count == 1) {

			PURGE_ATTRCACHE(vp);

			error = 0;

		} else {

			va.va_mask = AT_ALL;

			error = nfs_getattr_otw(vp, &va, cr);

		}

	} else

		error = 0;

	return (error);

}

/* ARGSUSED */

static int

nfs_close(vnode_t *vp, int flag, int count, offset_t offset, cred_t *cr,

	caller_context_t *ct)

{

	rnode_t *rp;

	int error;

	struct vattr va;

	/*

	 * zone_enter(2) prevents processes from changing zones with NFS files

	 * open; if we happen to get here from the wrong zone we can't do

	 * anything over the wire.

	 */

	if (VTOMI(vp)->mi_zone != nfs_zone()) {

		/*

		 * We could attempt to clean up locks, except we're sure

		 * that the current process didn't acquire any locks on

		 * the file: any attempt to lock a file belong to another zone

		 * will fail, and one can't lock an NFS file and then change

		 * zones, as that fails too.

		 *

		 * Returning an error here is the sane thing to do.  A

		 * subsequent call to VN_RELE() which translates to a

		 * nfs_inactive() will clean up state: if the zone of the

		 * vnode's origin is still alive and kicking, an async worker

		 * thread will handle the request (from the correct zone), and

		 * everything (minus the final nfs_getattr_otw() call) should

		 * be OK. If the zone is going away nfs_async_inactive() will

		 * throw away cached pages inline.

		 */

		return (EIO);

	}

	/*

	 * If we are using local locking for this filesystem, then

	 * release all of the SYSV style record locks.  Otherwise,

	 * we are doing network locking and we need to release all

	 * of the network locks.  All of the locks held by this

	 * process on this file are released no matter what the

	 * incoming reference count is.

	 */

	if (VTOMI(vp)->mi_flags & MI_LLOCK) {

		cleanlocks(vp, ttoproc(curthread)->p_pid, 0);

		cleanshares(vp, ttoproc(curthread)->p_pid);

	} else

		nfs_lockrelease(vp, flag, offset, cr);

	if (count > 1)

		return (0);

	/*

	 * If the file has been `unlinked', then purge the

	 * DNLC so that this vnode will get reycled quicker

	 * and the .nfs* file on the server will get removed.

	 */

	rp = VTOR(vp);

	if (rp->r_unldvp != NULL)

		dnlc_purge_vp(vp);

	/*

	 * If the file was open for write and there are pages,

	 * then if the file system was mounted using the "no-close-

	 *	to-open" semantics, then start an asynchronous flush

	 *	of the all of the pages in the file.

	 * else the file system was not mounted using the "no-close-

	 *	to-open" semantics, then do a synchronous flush and

	 *	commit of all of the dirty and uncommitted pages.

	 *

	 * The asynchronous flush of the pages in the "nocto" path

	 * mostly just associates a cred pointer with the rnode so

	 * writes which happen later will have a better chance of

	 * working.  It also starts the data being written to the

	 * server, but without unnecessarily delaying the application.

	 */

	if ((flag & FWRITE) && vn_has_cached_data(vp)) {

		if ((VTOMI(vp)->mi_flags & MI_NOCTO)) {

			error = nfs_putpage(vp, (offset_t)0, 0, B_ASYNC,

			    cr, ct);

			if (error == EAGAIN)

				error = 0;

		} else

			error = nfs_putpage(vp, (offset_t)0, 0, 0, cr, ct);

		if (!error) {

			mutex_enter(&rp->r_statelock);

			error = rp->r_error;

			rp->r_error = 0;

			mutex_exit(&rp->r_statelock);

		}

	} else {

		mutex_enter(&rp->r_statelock);

		error = rp->r_error;

		rp->r_error = 0;

		mutex_exit(&rp->r_statelock);

	}

	/*

	 * If RWRITEATTR is set, then issue an over the wire GETATTR to

	 * refresh the attribute cache with a set of attributes which

	 * weren't returned from a WRITE.  This will enable the close-

	 * to-open processing to work.

	 */

	if (rp->r_flags & RWRITEATTR)

		(void) nfs_getattr_otw(vp, &va, cr);

	return (error);

}

/* ARGSUSED */

static int

nfs_read(vnode_t *vp, struct uio *uiop, int ioflag, cred_t *cr,

	caller_context_t *ct)

{

	rnode_t *rp;

	u_offset_t off;

	offset_t diff;

	int on;

	size_t n;

	caddr_t base;

	uint_t flags;

	int error;

	mntinfo_t *mi;

	rp = VTOR(vp);

	mi = VTOMI(vp);

	if (nfs_zone() != mi->mi_zone)

		return (EIO);

	ASSERT(nfs_rw_lock_held(&rp->r_rwlock, RW_READER));

	if (vp->v_type != VREG)

		return (EISDIR);

	if (uiop->uio_resid == 0)

		return (0);

	if (uiop->uio_loffset > MAXOFF32_T)

		return (EFBIG);

	if (uiop->uio_loffset < 0 ||

	    uiop->uio_loffset + uiop->uio_resid > MAXOFF32_T)

		return (EINVAL);

	/*

	 * Bypass VM if caching has been disabled (e.g., locking) or if

	 * using client-side direct I/O and the file is not mmap'd and

	 * there are no cached pages.

	 */

	if ((vp->v_flag & VNOCACHE) ||

	    (((rp->r_flags & RDIRECTIO) || (mi->mi_flags & MI_DIRECTIO)) &&

	    rp->r_mapcnt == 0 && rp->r_inmap == 0 &&

	    !vn_has_cached_data(vp))) {

		size_t bufsize;

		size_t resid = 0;

		/*

		 * Let's try to do read in as large a chunk as we can

		 * (Filesystem (NFS client) bsize if possible/needed).

		 * For V3, this is 32K and for V2, this is 8K.

		 */

		bufsize = MIN(uiop->uio_resid, VTOMI(vp)->mi_curread);

		base = kmem_alloc(bufsize, KM_SLEEP);

		do {

			n = MIN(uiop->uio_resid, bufsize);

			error = nfsread(vp, base, uiop->uio_offset, n,

			    &resid, cr);

			if (!error) {

				n -= resid;

				error = uiomove(base, n, UIO_READ, uiop);

			}

		} while (!error && uiop->uio_resid > 0 && n > 0);

		kmem_free(base, bufsize);

		return (error);

	}

	error = 0;

	do {

		off = uiop->uio_loffset & MAXBMASK; /* mapping offset */

		on = uiop->uio_loffset & MAXBOFFSET; /* Relative offset */

		n = MIN(MAXBSIZE - on, uiop->uio_resid);

		error = nfs_validate_caches(vp, cr);

		if (error)

			break;

		mutex_enter(&rp->r_statelock);

		while (rp->r_flags & RINCACHEPURGE) {

			if (!cv_wait_sig(&rp->r_cv, &rp->r_statelock)) {

				mutex_exit(&rp->r_statelock);

				return (EINTR);

			}

		}

		diff = rp->r_size - uiop->uio_loffset;

		mutex_exit(&rp->r_statelock);

		if (diff <= 0)

			break;

		if (diff < n)

			n = (size_t)diff;

		if (vpm_enable) {

			/*

			 * Copy data.

			 */

			error = vpm_data_copy(vp, off + on, n, uiop,

			    1, NULL, 0, S_READ);

		} else {

			base = segmap_getmapflt(segkmap, vp, off + on, n,

			    1, S_READ);

			error = uiomove(base + on, n, UIO_READ, uiop);

		}

		if (!error) {

			/*

			 * If read a whole block or read to eof,

			 * won't need this buffer again soon.

			 */