/*

 * CDDL HEADER START

 *

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

 * Common Development and Distribution License, Version 1.0 only

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

/*

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*

 * 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 <sys/acl.h>

#include <sys/share.h>

#include <sys/file.h>

#include <sys/kmem.h>

#include <sys/file.h>

#include <sys/nbmlock.h>

static callb_cpr_t *frlock_serialize_blocked(flk_cb_when_t, void *);

/*

 * 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)

{

	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)

{

	return (ENOSYS);

}

/* ARGSUSED */

int

fs_nosys_poll(vnode_t *vp,

	register short events,

	int anyyet,

	register short *reventsp,

	struct pollhead **phpp)

{

	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);

}

/*

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

 */

int

fs_cmp(vnode_t *vp1, vnode_t *vp2)

{

	return (vp1 == vp2);

}

/*

 * No-op seek operation.

 */

/* ARGSUSED */

int

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

{

	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)

{

	int frcmd;

	int nlmid;

	int error = 0;

	flk_callback_t serialize_callback;

	int serialize = 0;

	switch (cmd) {

	case F_GETLK:

	case F_O_GETLK:

		if (flag & F_REMOTELOCK) {

			frcmd = RCMDLCK;

			break;

		}

		if (flag & F_PXFSLOCK) {

			frcmd = PCMDLCK;

			break;

		}

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

		bfp->l_sysid = 0;

		frcmd = 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:

		/*

		 * Check whether there is an NBMAND share reservation that

		 * conflicts with the lock request.

		 */

		if (nbl_need_check(vp)) {

			nbl_start_crit(vp, RW_WRITER);

			serialize = 1;

			if (share_blocks_lock(vp, bfp)) {

				error = EAGAIN;

				goto done;

			}

		}

		if (flag & F_REMOTELOCK) {

			frcmd = SETFLCK|RCMDLCK;

			break;

		}

		if (flag & F_PXFSLOCK) {

			frcmd = SETFLCK|PCMDLCK;

			break;

		}

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

		bfp->l_sysid = 0;

		frcmd = SETFLCK;

		if (cmd == F_SETLK_NBMAND &&

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

			/* would check here for conflict with mapped region */

			frcmd |= NBMLCK;

		}

		break;

	case F_SETLKW:

		/*

		 * If there is an NBMAND share reservation that conflicts

		 * with the lock request, block until the conflicting share

		 * reservation goes away.

		 */

		if (nbl_need_check(vp)) {

			nbl_start_crit(vp, RW_WRITER);

			serialize = 1;

			if (share_blocks_lock(vp, bfp)) {

				error = wait_for_share(vp, bfp);

				if (error != 0)

					goto done;

			}

		}

		if (flag & F_REMOTELOCK) {

			frcmd = SETFLCK|SLPFLCK|RCMDLCK;

			break;

		}

		if (flag & F_PXFSLOCK) {

			frcmd = SETFLCK|SLPFLCK|PCMDLCK;

			break;

		}

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

		bfp->l_sysid = 0;

		frcmd = SETFLCK|SLPFLCK;

		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)

{

	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)

{

	*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)

{

	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;

	default:

		error = EINVAL;

		break;

	}

	if (error == 0)

		*valp = val;

	return (error);

}

/*

 * Dispose of a page.

 */

/* ARGSUSED */

void

fs_dispose(struct vnode *vp, page_t *pp, int fl, int dn, struct cred *cr)

{

	ASSERT(fl == B_FREE || fl == B_INVAL);

	if (fl == B_FREE)

		page_free(pp, dn);

	else

		page_destroy(pp, dn);

}

/* ARGSUSED */

void

fs_nodispose(struct vnode *vp, page_t *pp, int fl, int dn, struct cred *cr)

{

	cmn_err(CE_PANIC, "fs_nodispose invoked");

}

/*

 * fabricate acls for file systems that do not support acls.

 */

/* ARGSUSED */

int

fs_fab_acl(vp, vsecattr, flag, cr)

vnode_t		*vp;

vsecattr_t	*vsecattr;

int		flag;

cred_t		*cr;

{

	aclent_t	*aclentp;

	struct vattr	vattr;

	int		error;

	vsecattr->vsa_aclcnt	= 0;

	vsecattr->vsa_aclentp	= NULL;

	vsecattr->vsa_dfaclcnt	= 0;	/* Default ACLs are not fabricated */

	vsecattr->vsa_dfaclentp	= NULL;

	if (vsecattr->vsa_mask & (VSA_ACLCNT | VSA_ACL))

		vsecattr->vsa_aclcnt	= 4; /* USER, GROUP, OTHER, and CLASS */

	if (vsecattr->vsa_mask & VSA_ACL) {

		vsecattr->vsa_aclentp = kmem_zalloc(4 * sizeof (aclent_t),

		    KM_SLEEP);

		vattr.va_mask = AT_MODE | AT_UID | AT_GID;

		if (error = VOP_GETATTR(vp, &vattr, 0, CRED()))

			return (error);

		aclentp = vsecattr->vsa_aclentp;