/*

 * 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 2005 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

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

#include <sys/param.h>

#include <sys/types.h>

#include <sys/systm.h>

#include <sys/cred.h>

#include <sys/proc.h>

#include <sys/user.h>

#include <sys/time.h>

#include <sys/vnode.h>

#include <sys/vfs.h>

#include <sys/file.h>

#include <sys/uio.h>

#include <sys/buf.h>

#include <sys/mman.h>

#include <sys/tiuser.h>

#include <sys/pathname.h>

#include <sys/dirent.h>

#include <sys/conf.h>

#include <sys/debug.h>

#include <sys/unistd.h>

#include <sys/vmsystm.h>

#include <sys/fcntl.h>

#include <sys/flock.h>

#include <sys/swap.h>

#include <sys/errno.h>

#include <sys/sysmacros.h>

#include <sys/disp.h>

#include <sys/kmem.h>

#include <sys/cmn_err.h>

#include <sys/vtrace.h>

#include <sys/pathconf.h>

#include <sys/dnlc.h>

#include <sys/acl.h>

#include <rpc/types.h>

#include <rpc/auth.h>

#include <rpc/clnt.h>

#include <rpc/xdr.h>

#include <nfs/nfs.h>

#include <nfs/nfs_clnt.h>

#include <nfs/rnode.h>

#include <nfs/nfs_acl.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_kmem.h>

#include <vm/seg_vn.h>

#include <vm/rm.h>

#include <fs/fs_subr.h>

/*

 * The order and contents of this structure must be kept in sync with that of

 * aclreqcnt_v2_tmpl in nfs_stats.c

 */

char *aclnames_v2[] = {

	"null", "getacl", "setacl", "getattr", "access", "getxattrdir"

};

/*

 * This table maps from NFS protocol number into call type.

 * Zero means a "Lookup" type call

 * One  means a "Read" type call

 * Two  means a "Write" type call

 * This is used to select a default time-out.

 */

uchar_t acl_call_type_v2[] = {

	0, 0, 1, 0, 0, 0

};

/*

 * Similar table, but to determine which timer to use

 * (only real reads and writes!)

 */

uchar_t acl_timer_type_v2[] = {

	0, 0, 0, 0, 0, 0

};

/*

 * This table maps from acl operation into a call type

 * for the semisoft mount option.

 * Zero means do not repeat operation.

 * One  means repeat.

 */

uchar_t acl_ss_call_type_v2[] = {

	0, 0, 1, 0, 0, 0

};

static int nfs_acl_dup_cache(vsecattr_t *, vsecattr_t *);

static void nfs_acl_dup_res(rnode_t *, vsecattr_t *);

/* ARGSUSED */

int

acl_getacl2(vnode_t *vp, vsecattr_t *vsp, int flag, cred_t *cr)

{

	int error;

	GETACL2args args;

	GETACL2res res;

	int doqueue;

	vattr_t va;

	rnode_t *rp;

	failinfo_t fi;

	hrtime_t t;

	rp = VTOR(vp);

	if (rp->r_secattr != NULL) {

		error = nfs_validate_caches(vp, cr);

		if (error)

			return (error);

		mutex_enter(&rp->r_statelock);

		if (rp->r_secattr != NULL) {

			if (nfs_acl_dup_cache(vsp, rp->r_secattr)) {

				mutex_exit(&rp->r_statelock);

				return (0);

			}

		}

		mutex_exit(&rp->r_statelock);

	}

	args.mask = vsp->vsa_mask;

	args.fh = *VTOFH(vp);

	fi.vp = vp;

	fi.fhp = (caddr_t)&args.fh;

	fi.copyproc = nfscopyfh;

	fi.lookupproc = nfslookup;

	fi.xattrdirproc = acl_getxattrdir2;

	res.resok.acl.vsa_aclentp = NULL;

	res.resok.acl.vsa_dfaclentp = NULL;

	doqueue = 1;

	t = gethrtime();

	error = acl2call(VTOMI(vp), ACLPROC2_GETACL,

	    xdr_GETACL2args, (caddr_t)&args,

	    xdr_GETACL2res, (caddr_t)&res, cr,

	    &doqueue, &res.status, 0, &fi);

	if (error)

		return (error);

	error = geterrno(res.status);

	if (!error) {

		(void) nfs_cache_fattr(vp, &res.resok.attr, &va, t, cr);

		nfs_acl_dup_res(rp, &res.resok.acl);

		*vsp = res.resok.acl;

	} else {

		PURGE_STALE_FH(error, vp, cr);

	}

	return (error);

}

/* ARGSUSED */

int

acl_setacl2(vnode_t *vp, vsecattr_t *vsp, int flag, cred_t *cr)

{

	int error;

	SETACL2args args;

	SETACL2res res;

	int doqueue;

	vattr_t va;

	rnode_t *rp;

	hrtime_t t;

	args.fh = *VTOFH(vp);

	args.acl = *vsp;

	doqueue = 1;

	t = gethrtime();

	error = acl2call(VTOMI(vp), ACLPROC2_SETACL,

	    xdr_SETACL2args, (caddr_t)&args,

	    xdr_SETACL2res, (caddr_t)&res, cr,

	    &doqueue, &res.status, 0, NULL);

	/*

	 * On success, adding the arguments to setsecattr into the cache have

	 * not proven adequate.  On error, we cannot depend on cache.

	 * Simply flush the cache to force the next getsecattr

	 * to go over the wire.

	 */

	rp = VTOR(vp);

	mutex_enter(&rp->r_statelock);

	if (rp->r_secattr != NULL) {

		nfs_acl_free(rp->r_secattr);

		rp->r_secattr = NULL;

	}

	mutex_exit(&rp->r_statelock);

	if (error)

		return (error);

	error = geterrno(res.status);

	if (!error) {

		(void) nfs_cache_fattr(vp, &res.resok.attr, &va, t, cr);

	} else {

		PURGE_STALE_FH(error, vp, cr);

	}

	return (error);

}

int

acl_getattr2_otw(vnode_t *vp, vattr_t *vap, cred_t *cr)

{

	int error;

	GETATTR2args args;

	GETATTR2res res;

	int doqueue;

	failinfo_t fi;

	hrtime_t t;

	args.fh = *VTOFH(vp);

	fi.vp = vp;

	fi.fhp = (caddr_t)&args.fh;

	fi.copyproc = nfscopyfh;

	fi.lookupproc = nfslookup;

	fi.xattrdirproc = acl_getxattrdir2;

	doqueue = 1;

	t = gethrtime();

	error = acl2call(VTOMI(vp), ACLPROC2_GETATTR,

	    xdr_GETATTR2args, (caddr_t)&args,

	    xdr_GETATTR2res, (caddr_t)&res, cr,

	    &doqueue, &res.status, 0, &fi);

	if (error)

		return (error);

	error = geterrno(res.status);

	if (!error) {

		error = nfs_cache_fattr(vp, &res.resok.attr, vap, t, cr);

	} else {

		PURGE_STALE_FH(error, vp, cr);

	}

	return (error);

}

/* ARGSUSED */

int

acl_access2(vnode_t *vp, int mode, int flags, cred_t *cr)

{

	int error;

	ACCESS2args args;

	ACCESS2res res;

	int doqueue;

	uint32 acc;

	rnode_t *rp;

	cred_t *cred, *ncr, *ncrfree = NULL;

	vattr_t va;

	failinfo_t fi;

	nfs_access_type_t cacc;

	hrtime_t t;

	acc = 0;

	if (mode & VREAD)

		acc |= ACCESS2_READ;

	if (mode & VWRITE) {

		if (vn_is_readonly(vp) && !IS_DEVVP(vp))

			return (EROFS);

		if (vp->v_type == VDIR)

			acc |= ACCESS2_DELETE;

		acc |= ACCESS2_MODIFY | ACCESS2_EXTEND;

	}

	if (mode & VEXEC) {

		if (vp->v_type == VDIR)

			acc |= ACCESS2_LOOKUP;

		else

			acc |= ACCESS2_EXECUTE;

	}

	rp = VTOR(vp);

	if (vp->v_type == VDIR) {

		args.access = ACCESS2_READ | ACCESS2_DELETE | ACCESS2_MODIFY |

		    ACCESS2_EXTEND | ACCESS2_LOOKUP;

	} else {

		args.access = ACCESS2_READ | ACCESS2_MODIFY | ACCESS2_EXTEND |

		    ACCESS2_EXECUTE;

	}

	args.fh = *VTOFH(vp);

	fi.vp = vp;

	fi.fhp = (caddr_t)&args.fh;

	fi.copyproc = nfscopyfh;

	fi.lookupproc = nfslookup;

	fi.xattrdirproc = acl_getxattrdir2;

	cred = cr;

	/*

	 * ncr and ncrfree both initially

	 * point to the memory area returned

	 * by crnetadjust();

	 * ncrfree not NULL when exiting means

	 * that we need to release it

	 */

	ncr = crnetadjust(cred);

	ncrfree = ncr;

tryagain:

	if (rp->r_acache != NULL) {

		cacc = nfs_access_check(rp, acc, cr);

		if (cacc == NFS_ACCESS_ALLOWED) {

			if (ncrfree != NULL)

				crfree(ncrfree);

			return (0);

		}

		if (cacc == NFS_ACCESS_DENIED) {

			/*

			 * If the cred can be adjusted, try again

			 * with the new cred.

			 */

			if (ncr != NULL) {

				cred = ncr;

				ncr = NULL;

				goto tryagain;

			}

			if (ncrfree != NULL)

				crfree(ncrfree);

			return (EACCES);

		}

	}

	doqueue = 1;

	t = gethrtime();

	error = acl2call(VTOMI(vp), ACLPROC2_ACCESS,

	    xdr_ACCESS2args, (caddr_t)&args,

	    xdr_ACCESS2res, (caddr_t)&res, cred,

	    &doqueue, &res.status, 0, &fi);

	if (error) {

		if (ncrfree != NULL)

			crfree(ncrfree);

		return (error);

	}

	error = geterrno(res.status);

	if (!error) {

		(void) nfs_cache_fattr(vp, &res.resok.attr, &va, t, cr);

		nfs_access_cache(rp, args.access, res.resok.access, cred);

		/*

		 * we just cached results with cred; if cred is the

		 * adjusted credentials from crnetadjust, we do not want

		 * to release them before exiting: hence setting ncrfree

		 * to NULL

		 */

		if (cred != cr)

			ncrfree = NULL;

		if ((acc & res.resok.access) != acc) {

			/*

			 * If the cred can be adjusted, try again

			 * with the new cred.

			 */

			if (ncr != NULL) {

				cred = ncr;

				ncr = NULL;

				goto tryagain;

			}

			error = EACCES;

		}

	} else {

		PURGE_STALE_FH(error, vp, cr);

	}

	if (ncrfree != NULL)

		crfree(ncrfree);

	return (error);

}

static int xattr_lookup_neg_cache = 1;

/*

 * Look up a hidden attribute directory over the wire; the vnode

 * we start with could be a file or directory.  We have to be

 * tricky in recording the name in the rnode r_path - we use the

 * magic name XATTR_RPATH and rely on code in failover_lookup() to

 * detect this and use this routine to do the same lookup on

 * remapping.  DNLC is easier: slashes are legal, so we use

 * XATTR_DIR_NAME as UFS does.

 */

int

acl_getxattrdir2(vnode_t *vp, vnode_t **vpp, bool_t create, cred_t *cr,

	int rfscall_flags)

{

	int error;

	GETXATTRDIR2args args;

	GETXATTRDIR2res res;

	int doqueue;

	failinfo_t fi;

	hrtime_t t;

	args.fh = *VTOFH(vp);

	args.create = create;

	fi.vp = vp;

	fi.fhp = NULL;		/* no need to update, filehandle not copied */

	fi.copyproc = nfscopyfh;

	fi.lookupproc = nfslookup;

	fi.xattrdirproc = acl_getxattrdir2;

	doqueue = 1;

	t = gethrtime();

	error = acl2call(VTOMI(vp), ACLPROC2_GETXATTRDIR,

	    xdr_GETXATTRDIR2args, (caddr_t)&args,

	    xdr_GETXATTRDIR2res, (caddr_t)&res, cr,

	    &doqueue, &res.status, rfscall_flags, &fi);

	if (!error) {

		error = geterrno(res.status);

		if (!error) {

			*vpp = makenfsnode(&res.resok.fh, &res.resok.attr,

			    vp->v_vfsp, t, cr, VTOR(vp)->r_path, XATTR_RPATH);

			mutex_enter(&(*vpp)->v_lock);

			(*vpp)->v_flag |= V_XATTRDIR;

			mutex_exit(&(*vpp)->v_lock);

			if (!(rfscall_flags & RFSCALL_SOFT))

				dnlc_update(vp, XATTR_DIR_NAME, *vpp);

		} else {

			PURGE_STALE_FH(error, vp, cr);

			if (error == ENOENT && xattr_lookup_neg_cache)

				dnlc_enter(vp, XATTR_DIR_NAME, DNLC_NO_VNODE);

		}

	}

	return (error);

}

/*

 * The order and contents of this structure must be kept in sync with that of

 * aclreqcnt_v3_tmpl in nfs_stats.c

 */

char *aclnames_v3[] = {

	"null", "getacl", "setacl", "getxattrdir"

};

/*

 * This table maps from NFS protocol number into call type.

 * Zero means a "Lookup" type call

 * One  means a "Read" type call

 * Two  means a "Write" type call

 * This is used to select a default time-out.

 */

uchar_t acl_call_type_v3[] = {

	0, 0, 1, 0

};

/*

 * This table maps from acl operation into a call type

 * for the semisoft mount option.

 * Zero means do not repeat operation.

 * One  means repeat.

 */

uchar_t acl_ss_call_type_v3[] = {

	0, 0, 1, 0

};

/*

 * Similar table, but to determine which timer to use

 * (only real reads and writes!)

 */

uchar_t acl_timer_type_v3[] = {

	0, 0, 0, 0

};

/* ARGSUSED */

int

acl_getacl3(vnode_t *vp, vsecattr_t *vsp, int flag, cred_t *cr)

{

	int error;

	GETACL3args args;

	GETACL3res res;

	int doqueue;

	rnode_t *rp;

	failinfo_t fi;

	hrtime_t t;

	rp = VTOR(vp);

	if (rp->r_secattr != NULL) {

		error = nfs3_validate_caches(vp, cr);

		if (error)

			return (error);

		mutex_enter(&rp->r_statelock);

		if (rp->r_secattr != NULL) {

			if (nfs_acl_dup_cache(vsp, rp->r_secattr)) {