/*

 * 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) 1984, 1986, 1987, 1988, 1989 AT&T	*/

/*	  All Rights Reserved  	*/

/*

 */

/*

 * Generic vnode operations.

 */

#include <sys/types.h>

#include <sys/param.h>

#include <sys/systm.h>

#include <sys/errno.h>

#include <sys/fcntl.h>

#include <sys/flock.h>

#include <sys/statvfs.h>

#include <sys/vfs.h>

#include <sys/vnode.h>

#include <sys/proc.h>

#include <sys/user.h>

#include <sys/unistd.h>

#include <sys/cred.h>

#include <sys/poll.h>

#include <sys/debug.h>

#include <sys/cmn_err.h>

#include <sys/stream.h>

#include <fs/fs_subr.h>

#include <fs/fs_reparse.h>

#include <sys/door.h>

#include <sys/acl.h>

#include <sys/share.h>

#include <sys/file.h>

#include <sys/kmem.h>

#include <sys/file.h>

#include <sys/nbmlock.h>

#include <acl/acl_common.h>

#include <sys/pathname.h>

static callb_cpr_t *frlock_serialize_blocked(flk_cb_when_t, void *);

/*

 * Tunable to limit the number of retry to recover from STALE error.

 */

int fs_estale_retry = 5;

/*

 * supports for reparse point door upcall

 */

static door_handle_t reparsed_door;

static kmutex_t reparsed_door_lock;

/*

 * The associated operation is not supported by the file system.

 */

int

fs_nosys()

{

	return (ENOSYS);

}

/*

 * The associated operation is invalid (on this vnode).

 */

int

fs_inval()

{

	return (EINVAL);

}

/*

 * The associated operation is valid only for directories.

 */

int

fs_notdir()

{

	return (ENOTDIR);

}

/*

 * Free the file system specific resources. For the file systems that

 * do not support the forced unmount, it will be a nop function.

 */

/*ARGSUSED*/

void

fs_freevfs(vfs_t *vfsp)

{

}

/* ARGSUSED */

int

fs_nosys_map(struct vnode *vp,

	offset_t off,

	struct as *as,

	caddr_t *addrp,

	size_t len,

	uchar_t prot,

	uchar_t maxprot,

	uint_t flags,

	struct cred *cr,

	caller_context_t *ct)

{

	return (ENOSYS);

}

/* ARGSUSED */

int

fs_nosys_addmap(struct vnode *vp,

	offset_t off,

	struct as *as,

	caddr_t addr,

	size_t len,

	uchar_t prot,

	uchar_t maxprot,

	uint_t flags,

	struct cred *cr,

	caller_context_t *ct)

{

	return (ENOSYS);

}

/* ARGSUSED */

int

fs_nosys_poll(vnode_t *vp,

	register short events,

	int anyyet,

	register short *reventsp,

	struct pollhead **phpp,

	caller_context_t *ct)

{

	return (ENOSYS);

}

/*

 * The file system has nothing to sync to disk.  However, the

 * VFS_SYNC operation must not fail.

 */

/* ARGSUSED */

int

fs_sync(struct vfs *vfspp, short flag, cred_t *cr)

{

	return (0);

}

/*

 * Does nothing but VOP_FSYNC must not fail.

 */

/* ARGSUSED */

int

fs_fsync(vnode_t *vp, int syncflag, cred_t *cr, caller_context_t *ct)

{

	return (0);

}

/*

 * Does nothing but VOP_PUTPAGE must not fail.

 */

/* ARGSUSED */

int

fs_putpage(vnode_t *vp, offset_t off, size_t len, int flags, cred_t *cr,

	caller_context_t *ctp)

{

	return (0);

}

/*

 * Does nothing but VOP_IOCTL must not fail.

 */

/* ARGSUSED */

int

fs_ioctl(vnode_t *vp, int com, intptr_t data, int flag, cred_t *cred,

	int *rvalp)

{

	return (0);

}

/*

 * Read/write lock/unlock.  Does nothing.

 */

/* ARGSUSED */

int

fs_rwlock(vnode_t *vp, int write_lock, caller_context_t *ctp)

{

	return (-1);

}

/* ARGSUSED */

void

fs_rwunlock(vnode_t *vp, int write_lock, caller_context_t *ctp)

{

}

/*

 * Compare two vnodes.

 */

/*ARGSUSED2*/

int

fs_cmp(vnode_t *vp1, vnode_t *vp2, caller_context_t *ct)

{

	return (vp1 == vp2);

}

/*

 * No-op seek operation.

 */

/* ARGSUSED */

int

fs_seek(vnode_t *vp, offset_t ooff, offset_t *noffp, caller_context_t *ct)

{

	return ((*noffp < 0 || *noffp > MAXOFFSET_T) ? EINVAL : 0);

}

/*

 * File and record locking.

 */

/* ARGSUSED */

int

fs_frlock(register vnode_t *vp, int cmd, struct flock64 *bfp, int flag,

	offset_t offset, flk_callback_t *flk_cbp, cred_t *cr,

	caller_context_t *ct)

{

	int frcmd;

	int nlmid;

	int error = 0;

	flk_callback_t serialize_callback;

	int serialize = 0;

	v_mode_t mode;

	switch (cmd) {

	case F_GETLK:

	case F_O_GETLK:

		if (flag & F_REMOTELOCK) {

			frcmd = RCMDLCK;

		} else if (flag & F_PXFSLOCK) {

			frcmd = PCMDLCK;

		} else {

			frcmd = 0;

			bfp->l_pid = ttoproc(curthread)->p_pid;

			bfp->l_sysid = 0;

		}

		break;

	case F_SETLK_NBMAND:

		/*

		 * Are NBMAND locks allowed on this file?

		 */

		if (!vp->v_vfsp ||

		    !(vp->v_vfsp->vfs_flag & VFS_NBMAND)) {

			error = EINVAL;

			goto done;

		}

		if (vp->v_type != VREG) {

			error = EINVAL;

			goto done;

		}

		/*FALLTHROUGH*/

	case F_SETLK:

		if (flag & F_REMOTELOCK) {

			frcmd = SETFLCK|RCMDLCK;

		} else if (flag & F_PXFSLOCK) {

			frcmd = SETFLCK|PCMDLCK;

		} else {

			frcmd = SETFLCK;

			bfp->l_pid = ttoproc(curthread)->p_pid;

			bfp->l_sysid = 0;

		}

		if (cmd == F_SETLK_NBMAND &&

		    (bfp->l_type == F_RDLCK || bfp->l_type == F_WRLCK)) {

			frcmd |= NBMLCK;

		}

		if (nbl_need_check(vp)) {

			nbl_start_crit(vp, RW_WRITER);

			serialize = 1;

			if (frcmd & NBMLCK) {

				mode = (bfp->l_type == F_RDLCK) ?

				    V_READ : V_RDANDWR;

				if (vn_is_mapped(vp, mode)) {

					error = EAGAIN;

					goto done;

				}

			}

		}

		break;

	case F_SETLKW:

		if (flag & F_REMOTELOCK) {

			frcmd = SETFLCK|SLPFLCK|RCMDLCK;

		} else if (flag & F_PXFSLOCK) {

			frcmd = SETFLCK|SLPFLCK|PCMDLCK;

		} else {

			frcmd = SETFLCK|SLPFLCK;

			bfp->l_pid = ttoproc(curthread)->p_pid;

			bfp->l_sysid = 0;

		}

		if (nbl_need_check(vp)) {

			nbl_start_crit(vp, RW_WRITER);

			serialize = 1;

		}

		break;

	case F_HASREMOTELOCKS:

		nlmid = GETNLMID(bfp->l_sysid);

		if (nlmid != 0) {	/* booted as a cluster */

			l_has_rmt(bfp) =

			    cl_flk_has_remote_locks_for_nlmid(vp, nlmid);

		} else {		/* not booted as a cluster */

			l_has_rmt(bfp) = flk_has_remote_locks(vp);

		}

		goto done;

	default:

		error = EINVAL;

		goto done;

	}

	/*

	 * If this is a blocking lock request and we're serializing lock

	 * requests, modify the callback list to leave the critical region

	 * while we're waiting for the lock.

	 */

	if (serialize && (frcmd & SLPFLCK) != 0) {

		flk_add_callback(&serialize_callback,

		    frlock_serialize_blocked, vp, flk_cbp);

		flk_cbp = &serialize_callback;

	}

	error = reclock(vp, bfp, frcmd, flag, offset, flk_cbp);

done:

	if (serialize)

		nbl_end_crit(vp);

	return (error);

}

/*

 * Callback when a lock request blocks and we are serializing requests.  If

 * before sleeping, leave the critical region.  If after wakeup, reenter

 * the critical region.

 */

static callb_cpr_t *

frlock_serialize_blocked(flk_cb_when_t when, void *infop)

{

	vnode_t *vp = (vnode_t *)infop;

	if (when == FLK_BEFORE_SLEEP)

		nbl_end_crit(vp);

	else {

		nbl_start_crit(vp, RW_WRITER);

	}

	return (NULL);

}

/*

 * Allow any flags.

 */

/* ARGSUSED */

int

fs_setfl(

	vnode_t *vp,

	int oflags,

	int nflags,

	cred_t *cr,

	caller_context_t *ct)

{

	return (0);

}

/*

 * Return the answer requested to poll() for non-device files.

 * Only POLLIN, POLLRDNORM, and POLLOUT are recognized.

 */

struct pollhead fs_pollhd;

/* ARGSUSED */

int

fs_poll(vnode_t *vp,

	register short events,

	int anyyet,

	register short *reventsp,

	struct pollhead **phpp,

	caller_context_t *ct)

{

	*reventsp = 0;

	if (events & POLLIN)

		*reventsp |= POLLIN;

	if (events & POLLRDNORM)

		*reventsp |= POLLRDNORM;

	if (events & POLLRDBAND)

		*reventsp |= POLLRDBAND;

	if (events & POLLOUT)

		*reventsp |= POLLOUT;

	if (events & POLLWRBAND)

		*reventsp |= POLLWRBAND;

	*phpp = !anyyet && !*reventsp ? &fs_pollhd : (struct pollhead *)NULL;

	return (0);

}

/*

 * POSIX pathconf() support.

 */

/* ARGSUSED */

int

fs_pathconf(

	vnode_t *vp,

	int cmd,

	ulong_t *valp,

	cred_t *cr,

	caller_context_t *ct)

{

	register ulong_t val;

	register int error = 0;

	struct statvfs64 vfsbuf;

	switch (cmd) {

	case _PC_LINK_MAX:

		val = MAXLINK;

		break;

	case _PC_MAX_CANON:

		val = MAX_CANON;

		break;

	case _PC_MAX_INPUT:

		val = MAX_INPUT;

		break;

	case _PC_NAME_MAX:

		bzero(&vfsbuf, sizeof (vfsbuf));

		if (error = VFS_STATVFS(vp->v_vfsp, &vfsbuf))

			break;

		val = vfsbuf.f_namemax;

		break;

	case _PC_PATH_MAX:

	case _PC_SYMLINK_MAX:

		val = MAXPATHLEN;

		break;

	case _PC_PIPE_BUF:

		val = PIPE_BUF;

		break;

	case _PC_NO_TRUNC:

		if (vp->v_vfsp->vfs_flag & VFS_NOTRUNC)

			val = 1;	/* NOTRUNC is enabled for vp */

		else

			val = (ulong_t)-1;

		break;

	case _PC_VDISABLE:

		val = _POSIX_VDISABLE;

		break;

	case _PC_CHOWN_RESTRICTED:

		if (rstchown)

			val = rstchown; /* chown restricted enabled */

		else

			val = (ulong_t)-1;

		break;

	case _PC_FILESIZEBITS:

		/*

		 * If ever we come here it means that underlying file system

		 * does not recognise the command and therefore this

		 * configurable limit cannot be determined. We return -1

		 * and don't change errno.

		 */

		val = (ulong_t)-1;    /* large file support */

		break;

	case _PC_ACL_ENABLED:

		val = 0;

		break;

	case _PC_CASE_BEHAVIOR:

		val = _CASE_SENSITIVE;

		if (vfs_has_feature(vp->v_vfsp, VFSFT_CASEINSENSITIVE) == 1)

			val |= _CASE_INSENSITIVE;

		if (vfs_has_feature(vp->v_vfsp, VFSFT_NOCASESENSITIVE) == 1)

			val &= ~_CASE_SENSITIVE;

		break;