xref: /illumos-gate/usr/src/uts/common/fs/nfs/nfs4_srv.c (revision f3b585ce)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
545916cd2Sjpk  * Common Development and Distribution License (the "License").
645916cd2Sjpk  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
217c478bd9Sstevel@tonic-gate /*
22aa59c4cbSrsb  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
237c478bd9Sstevel@tonic-gate  * Use is subject to license terms.
247c478bd9Sstevel@tonic-gate  */
257c478bd9Sstevel@tonic-gate 
267c478bd9Sstevel@tonic-gate /*
277c478bd9Sstevel@tonic-gate  *	Copyright (c) 1983,1984,1985,1986,1987,1988,1989  AT&T.
287c478bd9Sstevel@tonic-gate  *	All Rights Reserved
297c478bd9Sstevel@tonic-gate  */
307c478bd9Sstevel@tonic-gate 
317c478bd9Sstevel@tonic-gate #pragma ident	"%Z%%M%	%I%	%E% SMI"
327c478bd9Sstevel@tonic-gate 
337c478bd9Sstevel@tonic-gate #include <sys/param.h>
347c478bd9Sstevel@tonic-gate #include <sys/types.h>
357c478bd9Sstevel@tonic-gate #include <sys/systm.h>
367c478bd9Sstevel@tonic-gate #include <sys/cred.h>
377c478bd9Sstevel@tonic-gate #include <sys/buf.h>
387c478bd9Sstevel@tonic-gate #include <sys/vfs.h>
39aa59c4cbSrsb #include <sys/vfs_opreg.h>
407c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
417c478bd9Sstevel@tonic-gate #include <sys/uio.h>
427c478bd9Sstevel@tonic-gate #include <sys/errno.h>
437c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
447c478bd9Sstevel@tonic-gate #include <sys/statvfs.h>
457c478bd9Sstevel@tonic-gate #include <sys/kmem.h>
467c478bd9Sstevel@tonic-gate #include <sys/dirent.h>
477c478bd9Sstevel@tonic-gate #include <sys/cmn_err.h>
487c478bd9Sstevel@tonic-gate #include <sys/debug.h>
497c478bd9Sstevel@tonic-gate #include <sys/systeminfo.h>
507c478bd9Sstevel@tonic-gate #include <sys/flock.h>
517c478bd9Sstevel@tonic-gate #include <sys/pathname.h>
527c478bd9Sstevel@tonic-gate #include <sys/nbmlock.h>
537c478bd9Sstevel@tonic-gate #include <sys/share.h>
547c478bd9Sstevel@tonic-gate #include <sys/atomic.h>
557c478bd9Sstevel@tonic-gate #include <sys/policy.h>
567c478bd9Sstevel@tonic-gate #include <sys/fem.h>
5745916cd2Sjpk #include <sys/sdt.h>
58cee86682Scalum #include <sys/ddi.h>
597c478bd9Sstevel@tonic-gate 
607c478bd9Sstevel@tonic-gate #include <rpc/types.h>
617c478bd9Sstevel@tonic-gate #include <rpc/auth.h>
627c478bd9Sstevel@tonic-gate #include <rpc/rpcsec_gss.h>
637c478bd9Sstevel@tonic-gate #include <rpc/svc.h>
647c478bd9Sstevel@tonic-gate 
657c478bd9Sstevel@tonic-gate #include <nfs/nfs.h>
667c478bd9Sstevel@tonic-gate #include <nfs/export.h>
677c478bd9Sstevel@tonic-gate #include <nfs/lm.h>
687c478bd9Sstevel@tonic-gate #include <nfs/nfs4.h>
697c478bd9Sstevel@tonic-gate 
707c478bd9Sstevel@tonic-gate #include <sys/strsubr.h>
717c478bd9Sstevel@tonic-gate #include <sys/strsun.h>
727c478bd9Sstevel@tonic-gate 
737c478bd9Sstevel@tonic-gate #include <inet/common.h>
747c478bd9Sstevel@tonic-gate #include <inet/ip.h>
757c478bd9Sstevel@tonic-gate #include <inet/ip6.h>
767c478bd9Sstevel@tonic-gate 
7745916cd2Sjpk #include <sys/tsol/label.h>
7845916cd2Sjpk #include <sys/tsol/tndb.h>
7945916cd2Sjpk 
807c478bd9Sstevel@tonic-gate #define	RFS4_MAXLOCK_TRIES 4	/* Try to get the lock this many times */
817c478bd9Sstevel@tonic-gate static int rfs4_maxlock_tries = RFS4_MAXLOCK_TRIES;
827c478bd9Sstevel@tonic-gate #define	RFS4_LOCK_DELAY 10	/* Milliseconds */
837c478bd9Sstevel@tonic-gate static clock_t rfs4_lock_delay = RFS4_LOCK_DELAY;
847c478bd9Sstevel@tonic-gate 
857c478bd9Sstevel@tonic-gate /* End of Tunables */
867c478bd9Sstevel@tonic-gate 
877c478bd9Sstevel@tonic-gate /*
887c478bd9Sstevel@tonic-gate  * Used to bump the stateid4.seqid value and show changes in the stateid
897c478bd9Sstevel@tonic-gate  */
907c478bd9Sstevel@tonic-gate #define	next_stateid(sp) (++(sp)->bits.chgseq)
917c478bd9Sstevel@tonic-gate 
927c478bd9Sstevel@tonic-gate /*
937c478bd9Sstevel@tonic-gate  * RFS4_MINLEN_ENTRY4: XDR-encoded size of smallest possible dirent.
947c478bd9Sstevel@tonic-gate  *	This is used to return NFS4ERR_TOOSMALL when clients specify
957c478bd9Sstevel@tonic-gate  *	maxcount that isn't large enough to hold the smallest possible
967c478bd9Sstevel@tonic-gate  *	XDR encoded dirent.
977c478bd9Sstevel@tonic-gate  *
987c478bd9Sstevel@tonic-gate  *	    sizeof cookie (8 bytes) +
997c478bd9Sstevel@tonic-gate  *	    sizeof name_len (4 bytes) +
1007c478bd9Sstevel@tonic-gate  *	    sizeof smallest (padded) name (4 bytes) +
1017c478bd9Sstevel@tonic-gate  *	    sizeof bitmap4_len (12 bytes) +   NOTE: we always encode len=2 bm4
1027c478bd9Sstevel@tonic-gate  *	    sizeof attrlist4_len (4 bytes) +
1037c478bd9Sstevel@tonic-gate  *	    sizeof next boolean (4 bytes)
1047c478bd9Sstevel@tonic-gate  *
1057c478bd9Sstevel@tonic-gate  * RFS4_MINLEN_RDDIR4: XDR-encoded size of READDIR op reply containing
1067c478bd9Sstevel@tonic-gate  * the smallest possible entry4 (assumes no attrs requested).
1077c478bd9Sstevel@tonic-gate  *	sizeof nfsstat4 (4 bytes) +
1087c478bd9Sstevel@tonic-gate  *	sizeof verifier4 (8 bytes) +
1097c478bd9Sstevel@tonic-gate  *	sizeof entry4list bool (4 bytes) +
1107c478bd9Sstevel@tonic-gate  *	sizeof entry4 	(36 bytes) +
1117c478bd9Sstevel@tonic-gate  *	sizeof eof bool  (4 bytes)
1127c478bd9Sstevel@tonic-gate  *
1137c478bd9Sstevel@tonic-gate  * RFS4_MINLEN_RDDIR_BUF: minimum length of buffer server will provide to
1147c478bd9Sstevel@tonic-gate  *	VOP_READDIR.  Its value is the size of the maximum possible dirent
1157c478bd9Sstevel@tonic-gate  *	for solaris.  The DIRENT64_RECLEN macro returns	the size of dirent
1167c478bd9Sstevel@tonic-gate  *	required for a given name length.  MAXNAMELEN is the maximum
1177c478bd9Sstevel@tonic-gate  *	filename length allowed in Solaris.  The first two DIRENT64_RECLEN()
1187c478bd9Sstevel@tonic-gate  *	macros are to allow for . and .. entries -- just a minor tweak to try
1197c478bd9Sstevel@tonic-gate  *	and guarantee that buffer we give to VOP_READDIR will be large enough
1207c478bd9Sstevel@tonic-gate  *	to hold ., .., and the largest possible solaris dirent64.
1217c478bd9Sstevel@tonic-gate  */
1227c478bd9Sstevel@tonic-gate #define	RFS4_MINLEN_ENTRY4 36
1237c478bd9Sstevel@tonic-gate #define	RFS4_MINLEN_RDDIR4 (4 + NFS4_VERIFIER_SIZE + 4 + RFS4_MINLEN_ENTRY4 + 4)
1247c478bd9Sstevel@tonic-gate #define	RFS4_MINLEN_RDDIR_BUF \
1257c478bd9Sstevel@tonic-gate 	(DIRENT64_RECLEN(1) + DIRENT64_RECLEN(2) + DIRENT64_RECLEN(MAXNAMELEN))
1267c478bd9Sstevel@tonic-gate 
1277c478bd9Sstevel@tonic-gate /*
1287c478bd9Sstevel@tonic-gate  * It would be better to pad to 4 bytes since that's what XDR would do,
1297c478bd9Sstevel@tonic-gate  * but the dirents UFS gives us are already padded to 8, so just take
1307c478bd9Sstevel@tonic-gate  * what we're given.  Dircount is only a hint anyway.  Currently the
1317c478bd9Sstevel@tonic-gate  * solaris kernel is ASCII only, so there's no point in calling the
1327c478bd9Sstevel@tonic-gate  * UTF8 functions.
1337c478bd9Sstevel@tonic-gate  *
1347c478bd9Sstevel@tonic-gate  * dirent64: named padded to provide 8 byte struct alignment
1357c478bd9Sstevel@tonic-gate  *	d_ino(8) + d_off(8) + d_reclen(2) + d_name(namelen + null(1) + pad)
1367c478bd9Sstevel@tonic-gate  *
1377c478bd9Sstevel@tonic-gate  * cookie: uint64_t   +  utf8namelen: uint_t  +   utf8name padded to 8 bytes
1387c478bd9Sstevel@tonic-gate  *
1397c478bd9Sstevel@tonic-gate  */
1407c478bd9Sstevel@tonic-gate #define	DIRENT64_TO_DIRCOUNT(dp) \
1417c478bd9Sstevel@tonic-gate 	(3 * BYTES_PER_XDR_UNIT + DIRENT64_NAMELEN((dp)->d_reclen))
1427c478bd9Sstevel@tonic-gate 
1437c478bd9Sstevel@tonic-gate time_t rfs4_start_time;			/* Initialized in rfs4_srvrinit */
1447c478bd9Sstevel@tonic-gate 
1457c478bd9Sstevel@tonic-gate static sysid_t lockt_sysid;		/* dummy sysid for all LOCKT calls */
1467c478bd9Sstevel@tonic-gate 
1477c478bd9Sstevel@tonic-gate u_longlong_t nfs4_srv_caller_id;
1481b300de9Sjwahlig uint_t nfs4_srv_vkey = 0;
1497c478bd9Sstevel@tonic-gate 
1507c478bd9Sstevel@tonic-gate verifier4	Write4verf;
1517c478bd9Sstevel@tonic-gate verifier4	Readdir4verf;
1527c478bd9Sstevel@tonic-gate 
1537c478bd9Sstevel@tonic-gate void		rfs4_init_compound_state(struct compound_state *);
1547c478bd9Sstevel@tonic-gate 
1557c478bd9Sstevel@tonic-gate static void	nullfree(caddr_t);
1567c478bd9Sstevel@tonic-gate static void	rfs4_op_inval(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1577c478bd9Sstevel@tonic-gate 			struct compound_state *);
1587c478bd9Sstevel@tonic-gate static void	rfs4_op_access(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1597c478bd9Sstevel@tonic-gate 			struct compound_state *);
1607c478bd9Sstevel@tonic-gate static void	rfs4_op_close(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1617c478bd9Sstevel@tonic-gate 			struct compound_state *);
1627c478bd9Sstevel@tonic-gate static void	rfs4_op_commit(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1637c478bd9Sstevel@tonic-gate 			struct compound_state *);
1647c478bd9Sstevel@tonic-gate static void	rfs4_op_create(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1657c478bd9Sstevel@tonic-gate 			struct compound_state *);
1667c478bd9Sstevel@tonic-gate static void	rfs4_op_create_free(nfs_resop4 *resop);
1677c478bd9Sstevel@tonic-gate static void	rfs4_op_delegreturn(nfs_argop4 *, nfs_resop4 *,
168*f3b585ceSsamf 			struct svc_req *, struct compound_state *);
169*f3b585ceSsamf static void	rfs4_op_delegpurge(nfs_argop4 *, nfs_resop4 *,
170*f3b585ceSsamf 			struct svc_req *, struct compound_state *);
1717c478bd9Sstevel@tonic-gate static void	rfs4_op_getattr(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1727c478bd9Sstevel@tonic-gate 			struct compound_state *);
1737c478bd9Sstevel@tonic-gate static void	rfs4_op_getattr_free(nfs_resop4 *);
1747c478bd9Sstevel@tonic-gate static void	rfs4_op_getfh(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1757c478bd9Sstevel@tonic-gate 			struct compound_state *);
1767c478bd9Sstevel@tonic-gate static void	rfs4_op_getfh_free(nfs_resop4 *);
1777c478bd9Sstevel@tonic-gate static void	rfs4_op_illegal(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1787c478bd9Sstevel@tonic-gate 			struct compound_state *);
1797c478bd9Sstevel@tonic-gate static void	rfs4_op_link(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1807c478bd9Sstevel@tonic-gate 			struct compound_state *);
1817c478bd9Sstevel@tonic-gate static void	rfs4_op_lock(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1827c478bd9Sstevel@tonic-gate 			struct compound_state *);
1837c478bd9Sstevel@tonic-gate static void	lock_denied_free(nfs_resop4 *);
1847c478bd9Sstevel@tonic-gate static void	rfs4_op_locku(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1857c478bd9Sstevel@tonic-gate 			struct compound_state *);
1867c478bd9Sstevel@tonic-gate static void	rfs4_op_lockt(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1877c478bd9Sstevel@tonic-gate 			struct compound_state *);
1887c478bd9Sstevel@tonic-gate static void	rfs4_op_lookup(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1897c478bd9Sstevel@tonic-gate 			struct compound_state *);
1907c478bd9Sstevel@tonic-gate static void	rfs4_op_lookupp(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1917c478bd9Sstevel@tonic-gate 			struct compound_state *);
1927c478bd9Sstevel@tonic-gate static void	rfs4_op_openattr(nfs_argop4 *argop, nfs_resop4 *resop,
1937c478bd9Sstevel@tonic-gate 				struct svc_req *req, struct compound_state *cs);
1947c478bd9Sstevel@tonic-gate static void	rfs4_op_nverify(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1957c478bd9Sstevel@tonic-gate 			struct compound_state *);
1967c478bd9Sstevel@tonic-gate static void	rfs4_op_open(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
1977c478bd9Sstevel@tonic-gate 			struct compound_state *);
1987c478bd9Sstevel@tonic-gate static void	rfs4_op_open_confirm(nfs_argop4 *, nfs_resop4 *,
1997c478bd9Sstevel@tonic-gate 			struct svc_req *, struct compound_state *);
2007c478bd9Sstevel@tonic-gate static void	rfs4_op_open_downgrade(nfs_argop4 *, nfs_resop4 *,
2017c478bd9Sstevel@tonic-gate 			struct svc_req *, struct compound_state *);
2027c478bd9Sstevel@tonic-gate static void	rfs4_op_putfh(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2037c478bd9Sstevel@tonic-gate 			struct compound_state *);
2047c478bd9Sstevel@tonic-gate static void	rfs4_op_putpubfh(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2057c478bd9Sstevel@tonic-gate 			struct compound_state *);
2067c478bd9Sstevel@tonic-gate static void	rfs4_op_putrootfh(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2077c478bd9Sstevel@tonic-gate 			struct compound_state *);
2087c478bd9Sstevel@tonic-gate static void	rfs4_op_read(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2097c478bd9Sstevel@tonic-gate 			struct compound_state *);
2107c478bd9Sstevel@tonic-gate static void	rfs4_op_read_free(nfs_resop4 *);
2117c478bd9Sstevel@tonic-gate static void	rfs4_op_readdir_free(nfs_resop4 *resop);
2127c478bd9Sstevel@tonic-gate static void	rfs4_op_readlink(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2137c478bd9Sstevel@tonic-gate 			struct compound_state *);
2147c478bd9Sstevel@tonic-gate static void	rfs4_op_readlink_free(nfs_resop4 *);
2157c478bd9Sstevel@tonic-gate static void	rfs4_op_release_lockowner(nfs_argop4 *, nfs_resop4 *,
2167c478bd9Sstevel@tonic-gate 			struct svc_req *, struct compound_state *);
2177c478bd9Sstevel@tonic-gate static void	rfs4_op_remove(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2187c478bd9Sstevel@tonic-gate 			struct compound_state *);
2197c478bd9Sstevel@tonic-gate static void	rfs4_op_rename(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2207c478bd9Sstevel@tonic-gate 			struct compound_state *);
2217c478bd9Sstevel@tonic-gate static void	rfs4_op_renew(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2227c478bd9Sstevel@tonic-gate 			struct compound_state *);
2237c478bd9Sstevel@tonic-gate static void	rfs4_op_restorefh(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2247c478bd9Sstevel@tonic-gate 			struct compound_state *);
2257c478bd9Sstevel@tonic-gate static void	rfs4_op_savefh(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2267c478bd9Sstevel@tonic-gate 			struct compound_state *);
2277c478bd9Sstevel@tonic-gate static void	rfs4_op_setattr(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2287c478bd9Sstevel@tonic-gate 			struct compound_state *);
2297c478bd9Sstevel@tonic-gate static void	rfs4_op_verify(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2307c478bd9Sstevel@tonic-gate 			struct compound_state *);
2317c478bd9Sstevel@tonic-gate static void	rfs4_op_write(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2327c478bd9Sstevel@tonic-gate 			struct compound_state *);
2337c478bd9Sstevel@tonic-gate static void	rfs4_op_setclientid(nfs_argop4 *, nfs_resop4 *,
2347c478bd9Sstevel@tonic-gate 			struct svc_req *, struct compound_state *);
2357c478bd9Sstevel@tonic-gate static void	rfs4_op_setclientid_confirm(nfs_argop4 *, nfs_resop4 *,
2367c478bd9Sstevel@tonic-gate 			struct svc_req *req, struct compound_state *);
2377c478bd9Sstevel@tonic-gate static void	rfs4_op_secinfo(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
2387c478bd9Sstevel@tonic-gate 			struct compound_state *);
2397c478bd9Sstevel@tonic-gate static void	rfs4_op_secinfo_free(nfs_resop4 *);
2407c478bd9Sstevel@tonic-gate 
2417c478bd9Sstevel@tonic-gate static nfsstat4 check_open_access(uint32_t,
2427c478bd9Sstevel@tonic-gate 				struct compound_state *, struct svc_req *);
2437c478bd9Sstevel@tonic-gate nfsstat4 rfs4_client_sysid(rfs4_client_t *, sysid_t *);
2447c478bd9Sstevel@tonic-gate static int	vop_shrlock(vnode_t *, int, struct shrlock *, int);
2457c478bd9Sstevel@tonic-gate static int 	rfs4_shrlock(rfs4_state_t *, int);
2467c478bd9Sstevel@tonic-gate static int	rfs4_share(rfs4_state_t *);
2477c478bd9Sstevel@tonic-gate void rfs4_ss_clid(rfs4_client_t *, struct svc_req *);
2487c478bd9Sstevel@tonic-gate 
2497c478bd9Sstevel@tonic-gate /*
2507c478bd9Sstevel@tonic-gate  * translation table for attrs
2517c478bd9Sstevel@tonic-gate  */
2527c478bd9Sstevel@tonic-gate struct nfs4_ntov_table {
2537c478bd9Sstevel@tonic-gate 	union nfs4_attr_u *na;
2547c478bd9Sstevel@tonic-gate 	uint8_t amap[NFS4_MAXNUM_ATTRS];
2557c478bd9Sstevel@tonic-gate 	int attrcnt;
2567c478bd9Sstevel@tonic-gate 	bool_t vfsstat;
2577c478bd9Sstevel@tonic-gate };
2587c478bd9Sstevel@tonic-gate 
2597c478bd9Sstevel@tonic-gate static void	nfs4_ntov_table_init(struct nfs4_ntov_table *ntovp);
2607c478bd9Sstevel@tonic-gate static void	nfs4_ntov_table_free(struct nfs4_ntov_table *ntovp,
2617c478bd9Sstevel@tonic-gate 				    struct nfs4_svgetit_arg *sargp);
2627c478bd9Sstevel@tonic-gate 
2637c478bd9Sstevel@tonic-gate static nfsstat4	do_rfs4_set_attrs(bitmap4 *resp, fattr4 *fattrp,
2647c478bd9Sstevel@tonic-gate 		    struct compound_state *cs, struct nfs4_svgetit_arg *sargp,
2657c478bd9Sstevel@tonic-gate 		    struct nfs4_ntov_table *ntovp, nfs4_attr_cmd_t cmd);
2667c478bd9Sstevel@tonic-gate 
2677c478bd9Sstevel@tonic-gate fem_t	*deleg_rdops;
2687c478bd9Sstevel@tonic-gate fem_t	*deleg_wrops;
2697c478bd9Sstevel@tonic-gate 
2707c478bd9Sstevel@tonic-gate rfs4_servinst_t	*rfs4_cur_servinst = NULL;	/* current server instance */
2717c478bd9Sstevel@tonic-gate kmutex_t	rfs4_servinst_lock;		/* protects linked list */
2727c478bd9Sstevel@tonic-gate int		rfs4_seen_first_compound;	/* set first time we see one */
2737c478bd9Sstevel@tonic-gate 
2747c478bd9Sstevel@tonic-gate /*
2757c478bd9Sstevel@tonic-gate  * NFS4 op dispatch table
2767c478bd9Sstevel@tonic-gate  */
2777c478bd9Sstevel@tonic-gate 
2787c478bd9Sstevel@tonic-gate struct rfsv4disp {
2797c478bd9Sstevel@tonic-gate 	void	(*dis_proc)();		/* proc to call */
2807c478bd9Sstevel@tonic-gate 	void	(*dis_resfree)();	/* frees space allocated by proc */
2817c478bd9Sstevel@tonic-gate 	int	dis_flags;		/* RPC_IDEMPOTENT, etc... */
2827c478bd9Sstevel@tonic-gate };
2837c478bd9Sstevel@tonic-gate 
2847c478bd9Sstevel@tonic-gate static struct rfsv4disp rfsv4disptab[] = {
2857c478bd9Sstevel@tonic-gate 	/*
2867c478bd9Sstevel@tonic-gate 	 * NFS VERSION 4
2877c478bd9Sstevel@tonic-gate 	 */
2887c478bd9Sstevel@tonic-gate 
2897c478bd9Sstevel@tonic-gate 	/* RFS_NULL = 0 */
2907c478bd9Sstevel@tonic-gate 	{rfs4_op_illegal, nullfree, 0},
2917c478bd9Sstevel@tonic-gate 
2927c478bd9Sstevel@tonic-gate 	/* UNUSED = 1 */
2937c478bd9Sstevel@tonic-gate 	{rfs4_op_illegal, nullfree, 0},
2947c478bd9Sstevel@tonic-gate 
2957c478bd9Sstevel@tonic-gate 	/* UNUSED = 2 */
2967c478bd9Sstevel@tonic-gate 	{rfs4_op_illegal, nullfree, 0},
2977c478bd9Sstevel@tonic-gate 
2987c478bd9Sstevel@tonic-gate 	/* OP_ACCESS = 3 */
2997c478bd9Sstevel@tonic-gate 	{rfs4_op_access, nullfree, RPC_IDEMPOTENT},
3007c478bd9Sstevel@tonic-gate 
3017c478bd9Sstevel@tonic-gate 	/* OP_CLOSE = 4 */
3027c478bd9Sstevel@tonic-gate 	{rfs4_op_close, nullfree, 0},
3037c478bd9Sstevel@tonic-gate 
3047c478bd9Sstevel@tonic-gate 	/* OP_COMMIT = 5 */
3057c478bd9Sstevel@tonic-gate 	{rfs4_op_commit, nullfree, RPC_IDEMPOTENT},
3067c478bd9Sstevel@tonic-gate 
3077c478bd9Sstevel@tonic-gate 	/* OP_CREATE = 6 */
3087c478bd9Sstevel@tonic-gate 	{rfs4_op_create, nullfree, 0},
3097c478bd9Sstevel@tonic-gate 
3107c478bd9Sstevel@tonic-gate 	/* OP_DELEGPURGE = 7 */
311*f3b585ceSsamf 	{rfs4_op_delegpurge, nullfree, 0},
3127c478bd9Sstevel@tonic-gate 
3137c478bd9Sstevel@tonic-gate 	/* OP_DELEGRETURN = 8 */
3147c478bd9Sstevel@tonic-gate 	{rfs4_op_delegreturn, nullfree, 0},
3157c478bd9Sstevel@tonic-gate 
3167c478bd9Sstevel@tonic-gate 	/* OP_GETATTR = 9 */
3177c478bd9Sstevel@tonic-gate 	{rfs4_op_getattr, rfs4_op_getattr_free, RPC_IDEMPOTENT},
3187c478bd9Sstevel@tonic-gate 
3197c478bd9Sstevel@tonic-gate 	/* OP_GETFH = 10 */
3207c478bd9Sstevel@tonic-gate 	{rfs4_op_getfh, rfs4_op_getfh_free, RPC_ALL},
3217c478bd9Sstevel@tonic-gate 
3227c478bd9Sstevel@tonic-gate 	/* OP_LINK = 11 */
3237c478bd9Sstevel@tonic-gate 	{rfs4_op_link, nullfree, 0},
3247c478bd9Sstevel@tonic-gate 
3257c478bd9Sstevel@tonic-gate 	/* OP_LOCK = 12 */
3267c478bd9Sstevel@tonic-gate 	{rfs4_op_lock, lock_denied_free, 0},
3277c478bd9Sstevel@tonic-gate 
3287c478bd9Sstevel@tonic-gate 	/* OP_LOCKT = 13 */
3297c478bd9Sstevel@tonic-gate 	{rfs4_op_lockt, lock_denied_free, 0},
3307c478bd9Sstevel@tonic-gate 
3317c478bd9Sstevel@tonic-gate 	/* OP_LOCKU = 14 */
3327c478bd9Sstevel@tonic-gate 	{rfs4_op_locku, nullfree, 0},
3337c478bd9Sstevel@tonic-gate 
3347c478bd9Sstevel@tonic-gate 	/* OP_LOOKUP = 15 */
3357c478bd9Sstevel@tonic-gate 	{rfs4_op_lookup, nullfree, (RPC_IDEMPOTENT|RPC_PUBLICFH_OK)},
3367c478bd9Sstevel@tonic-gate 
3377c478bd9Sstevel@tonic-gate 	/* OP_LOOKUPP = 16 */
3387c478bd9Sstevel@tonic-gate 	{rfs4_op_lookupp, nullfree, (RPC_IDEMPOTENT|RPC_PUBLICFH_OK)},
3397c478bd9Sstevel@tonic-gate 
3407c478bd9Sstevel@tonic-gate 	/* OP_NVERIFY = 17 */
3417c478bd9Sstevel@tonic-gate 	{rfs4_op_nverify, nullfree, RPC_IDEMPOTENT},
3427c478bd9Sstevel@tonic-gate 
3437c478bd9Sstevel@tonic-gate 	/* OP_OPEN = 18 */
3447c478bd9Sstevel@tonic-gate 	{rfs4_op_open, rfs4_free_reply, 0},
3457c478bd9Sstevel@tonic-gate 
3467c478bd9Sstevel@tonic-gate 	/* OP_OPENATTR = 19 */
3477c478bd9Sstevel@tonic-gate 	{rfs4_op_openattr, nullfree, 0},
3487c478bd9Sstevel@tonic-gate 
3497c478bd9Sstevel@tonic-gate 	/* OP_OPEN_CONFIRM = 20 */
3507c478bd9Sstevel@tonic-gate 	{rfs4_op_open_confirm, nullfree, 0},
3517c478bd9Sstevel@tonic-gate 
3527c478bd9Sstevel@tonic-gate 	/* OP_OPEN_DOWNGRADE = 21 */
3537c478bd9Sstevel@tonic-gate 	{rfs4_op_open_downgrade, nullfree, 0},
3547c478bd9Sstevel@tonic-gate 
3557c478bd9Sstevel@tonic-gate 	/* OP_OPEN_PUTFH = 22 */
3567c478bd9Sstevel@tonic-gate 	{rfs4_op_putfh, nullfree, RPC_ALL},
3577c478bd9Sstevel@tonic-gate 
3587c478bd9Sstevel@tonic-gate 	/* OP_PUTPUBFH = 23 */
3597c478bd9Sstevel@tonic-gate 	{rfs4_op_putpubfh, nullfree, RPC_ALL},
3607c478bd9Sstevel@tonic-gate 
3617c478bd9Sstevel@tonic-gate 	/* OP_PUTROOTFH = 24 */
3627c478bd9Sstevel@tonic-gate 	{rfs4_op_putrootfh, nullfree, RPC_ALL},
3637c478bd9Sstevel@tonic-gate 
3647c478bd9Sstevel@tonic-gate 	/* OP_READ = 25 */
3657c478bd9Sstevel@tonic-gate 	{rfs4_op_read, rfs4_op_read_free, RPC_IDEMPOTENT},
3667c478bd9Sstevel@tonic-gate 
3677c478bd9Sstevel@tonic-gate 	/* OP_READDIR = 26 */
3687c478bd9Sstevel@tonic-gate 	{rfs4_op_readdir, rfs4_op_readdir_free, RPC_IDEMPOTENT},
3697c478bd9Sstevel@tonic-gate 
3707c478bd9Sstevel@tonic-gate 	/* OP_READLINK = 27 */
3717c478bd9Sstevel@tonic-gate 	{rfs4_op_readlink, rfs4_op_readlink_free, RPC_IDEMPOTENT},
3727c478bd9Sstevel@tonic-gate 
3737c478bd9Sstevel@tonic-gate 	/* OP_REMOVE = 28 */
3747c478bd9Sstevel@tonic-gate 	{rfs4_op_remove, nullfree, 0},
3757c478bd9Sstevel@tonic-gate 
3767c478bd9Sstevel@tonic-gate 	/* OP_RENAME = 29 */
3777c478bd9Sstevel@tonic-gate 	{rfs4_op_rename, nullfree, 0},
3787c478bd9Sstevel@tonic-gate 
3797c478bd9Sstevel@tonic-gate 	/* OP_RENEW = 30 */
3807c478bd9Sstevel@tonic-gate 	{rfs4_op_renew, nullfree, 0},
3817c478bd9Sstevel@tonic-gate 
3827c478bd9Sstevel@tonic-gate 	/* OP_RESTOREFH = 31 */
3837c478bd9Sstevel@tonic-gate 	{rfs4_op_restorefh, nullfree, RPC_ALL},
3847c478bd9Sstevel@tonic-gate 
3857c478bd9Sstevel@tonic-gate 	/* OP_SAVEFH = 32 */
3867c478bd9Sstevel@tonic-gate 	{rfs4_op_savefh, nullfree, RPC_ALL},
3877c478bd9Sstevel@tonic-gate 
3887c478bd9Sstevel@tonic-gate 	/* OP_SECINFO = 33 */
3897c478bd9Sstevel@tonic-gate 	{rfs4_op_secinfo, rfs4_op_secinfo_free, 0},
3907c478bd9Sstevel@tonic-gate 
3917c478bd9Sstevel@tonic-gate 	/* OP_SETATTR = 34 */
3927c478bd9Sstevel@tonic-gate 	{rfs4_op_setattr, nullfree, 0},
3937c478bd9Sstevel@tonic-gate 
3947c478bd9Sstevel@tonic-gate 	/* OP_SETCLIENTID = 35 */
3957c478bd9Sstevel@tonic-gate 	{rfs4_op_setclientid, nullfree, 0},
3967c478bd9Sstevel@tonic-gate 
3977c478bd9Sstevel@tonic-gate 	/* OP_SETCLIENTID_CONFIRM = 36 */
3987c478bd9Sstevel@tonic-gate 	{rfs4_op_setclientid_confirm, nullfree, 0},
3997c478bd9Sstevel@tonic-gate 
4007c478bd9Sstevel@tonic-gate 	/* OP_VERIFY = 37 */
4017c478bd9Sstevel@tonic-gate 	{rfs4_op_verify, nullfree, RPC_IDEMPOTENT},
4027c478bd9Sstevel@tonic-gate 
4037c478bd9Sstevel@tonic-gate 	/* OP_WRITE = 38 */
4047c478bd9Sstevel@tonic-gate 	{rfs4_op_write, nullfree, 0},
4057c478bd9Sstevel@tonic-gate 
4067c478bd9Sstevel@tonic-gate 	/* OP_RELEASE_LOCKOWNER = 39 */
4077c478bd9Sstevel@tonic-gate 	{rfs4_op_release_lockowner, nullfree, 0},
4087c478bd9Sstevel@tonic-gate };
4097c478bd9Sstevel@tonic-gate 
4107c478bd9Sstevel@tonic-gate static uint_t rfsv4disp_cnt = sizeof (rfsv4disptab) / sizeof (rfsv4disptab[0]);
4117c478bd9Sstevel@tonic-gate 
4127c478bd9Sstevel@tonic-gate #define	OP_ILLEGAL_IDX (rfsv4disp_cnt)
4137c478bd9Sstevel@tonic-gate 
4147c478bd9Sstevel@tonic-gate #ifdef DEBUG
4157c478bd9Sstevel@tonic-gate 
4167c478bd9Sstevel@tonic-gate int rfs4_fillone_debug = 0;
4177c478bd9Sstevel@tonic-gate int rfs4_shrlock_debug = 0;
4187c478bd9Sstevel@tonic-gate int rfs4_no_stub_access = 1;
4197c478bd9Sstevel@tonic-gate int rfs4_rddir_debug = 0;
4207c478bd9Sstevel@tonic-gate 
4217c478bd9Sstevel@tonic-gate static char *rfs4_op_string[] = {
4227c478bd9Sstevel@tonic-gate 	"rfs4_op_null",
4237c478bd9Sstevel@tonic-gate 	"rfs4_op_1 unused",
4247c478bd9Sstevel@tonic-gate 	"rfs4_op_2 unused",
4257c478bd9Sstevel@tonic-gate 	"rfs4_op_access",
4267c478bd9Sstevel@tonic-gate 	"rfs4_op_close",
4277c478bd9Sstevel@tonic-gate 	"rfs4_op_commit",
4287c478bd9Sstevel@tonic-gate 	"rfs4_op_create",
4297c478bd9Sstevel@tonic-gate 	"rfs4_op_delegpurge",
4307c478bd9Sstevel@tonic-gate 	"rfs4_op_delegreturn",
4317c478bd9Sstevel@tonic-gate 	"rfs4_op_getattr",
4327c478bd9Sstevel@tonic-gate 	"rfs4_op_getfh",
4337c478bd9Sstevel@tonic-gate 	"rfs4_op_link",
4347c478bd9Sstevel@tonic-gate 	"rfs4_op_lock",
4357c478bd9Sstevel@tonic-gate 	"rfs4_op_lockt",
4367c478bd9Sstevel@tonic-gate 	"rfs4_op_locku",
4377c478bd9Sstevel@tonic-gate 	"rfs4_op_lookup",
4387c478bd9Sstevel@tonic-gate 	"rfs4_op_lookupp",
4397c478bd9Sstevel@tonic-gate 	"rfs4_op_nverify",
4407c478bd9Sstevel@tonic-gate 	"rfs4_op_open",
4417c478bd9Sstevel@tonic-gate 	"rfs4_op_openattr",
4427c478bd9Sstevel@tonic-gate 	"rfs4_op_open_confirm",
4437c478bd9Sstevel@tonic-gate 	"rfs4_op_open_downgrade",
4447c478bd9Sstevel@tonic-gate 	"rfs4_op_putfh",
4457c478bd9Sstevel@tonic-gate 	"rfs4_op_putpubfh",
4467c478bd9Sstevel@tonic-gate 	"rfs4_op_putrootfh",
4477c478bd9Sstevel@tonic-gate 	"rfs4_op_read",
4487c478bd9Sstevel@tonic-gate 	"rfs4_op_readdir",
4497c478bd9Sstevel@tonic-gate 	"rfs4_op_readlink",
4507c478bd9Sstevel@tonic-gate 	"rfs4_op_remove",
4517c478bd9Sstevel@tonic-gate 	"rfs4_op_rename",
4527c478bd9Sstevel@tonic-gate 	"rfs4_op_renew",
4537c478bd9Sstevel@tonic-gate 	"rfs4_op_restorefh",
4547c478bd9Sstevel@tonic-gate 	"rfs4_op_savefh",
4557c478bd9Sstevel@tonic-gate 	"rfs4_op_secinfo",
4567c478bd9Sstevel@tonic-gate 	"rfs4_op_setattr",
4577c478bd9Sstevel@tonic-gate 	"rfs4_op_setclientid",
4587c478bd9Sstevel@tonic-gate 	"rfs4_op_setclient_confirm",
4597c478bd9Sstevel@tonic-gate 	"rfs4_op_verify",
4607c478bd9Sstevel@tonic-gate 	"rfs4_op_write",
4617c478bd9Sstevel@tonic-gate 	"rfs4_op_release_lockowner",
4627c478bd9Sstevel@tonic-gate 	"rfs4_op_illegal"
4637c478bd9Sstevel@tonic-gate };
4647c478bd9Sstevel@tonic-gate #endif
4657c478bd9Sstevel@tonic-gate 
4667c478bd9Sstevel@tonic-gate void rfs4_ss_chkclid(rfs4_client_t *);
4677c478bd9Sstevel@tonic-gate 
468cee86682Scalum extern size_t strlcpy(char *dst, const char *src, size_t dstsize);
469cee86682Scalum 
4707c478bd9Sstevel@tonic-gate #ifdef	nextdp
4717c478bd9Sstevel@tonic-gate #undef nextdp
4727c478bd9Sstevel@tonic-gate #endif
4737c478bd9Sstevel@tonic-gate #define	nextdp(dp)	((struct dirent64 *)((char *)(dp) + (dp)->d_reclen))
4747c478bd9Sstevel@tonic-gate 
4757c478bd9Sstevel@tonic-gate static const fs_operation_def_t nfs4_rd_deleg_tmpl[] = {
476cfae96c2Sjwahlig 	VOPNAME_OPEN,		{ .femop_open = deleg_rd_open },
477cfae96c2Sjwahlig 	VOPNAME_WRITE,		{ .femop_write = deleg_rd_write },
478cfae96c2Sjwahlig 	VOPNAME_SETATTR,	{ .femop_setattr = deleg_rd_setattr },
479aa59c4cbSrsb 	VOPNAME_RWLOCK,		{ .femop_rwlock = deleg_rd_rwlock },
480cfae96c2Sjwahlig 	VOPNAME_SPACE,		{ .femop_space = deleg_rd_space },
481cfae96c2Sjwahlig 	VOPNAME_SETSECATTR,	{ .femop_setsecattr = deleg_rd_setsecattr },
482cfae96c2Sjwahlig 	VOPNAME_VNEVENT,	{ .femop_vnevent = deleg_rd_vnevent },
483aa59c4cbSrsb 	NULL,			NULL
4847c478bd9Sstevel@tonic-gate };
4857c478bd9Sstevel@tonic-gate static const fs_operation_def_t nfs4_wr_deleg_tmpl[] = {
486cfae96c2Sjwahlig 	VOPNAME_OPEN,		{ .femop_open = deleg_wr_open },
487cfae96c2Sjwahlig 	VOPNAME_READ,		{ .femop_read = deleg_wr_read },
488cfae96c2Sjwahlig 	VOPNAME_WRITE,		{ .femop_write = deleg_wr_write },
489cfae96c2Sjwahlig 	VOPNAME_SETATTR,	{ .femop_setattr = deleg_wr_setattr },
490aa59c4cbSrsb 	VOPNAME_RWLOCK,		{ .femop_rwlock = deleg_wr_rwlock },
491cfae96c2Sjwahlig 	VOPNAME_SPACE,		{ .femop_space = deleg_wr_space },
492cfae96c2Sjwahlig 	VOPNAME_SETSECATTR,	{ .femop_setsecattr = deleg_wr_setsecattr },
493cfae96c2Sjwahlig 	VOPNAME_VNEVENT,	{ .femop_vnevent = deleg_wr_vnevent },
494aa59c4cbSrsb 	NULL,			NULL
4957c478bd9Sstevel@tonic-gate };
4967c478bd9Sstevel@tonic-gate 
4977c478bd9Sstevel@tonic-gate int
4987c478bd9Sstevel@tonic-gate rfs4_srvrinit(void)
4997c478bd9Sstevel@tonic-gate {
5007c478bd9Sstevel@tonic-gate 	timespec32_t verf;
5017c478bd9Sstevel@tonic-gate 	int error;
5027c478bd9Sstevel@tonic-gate 	extern void rfs4_attr_init();
5037c478bd9Sstevel@tonic-gate 	extern krwlock_t rfs4_deleg_policy_lock;
5047c478bd9Sstevel@tonic-gate 
5057c478bd9Sstevel@tonic-gate 	/*
5067c478bd9Sstevel@tonic-gate 	 * The following algorithm attempts to find a unique verifier
5077c478bd9Sstevel@tonic-gate 	 * to be used as the write verifier returned from the server
5087c478bd9Sstevel@tonic-gate 	 * to the client.  It is important that this verifier change
5097c478bd9Sstevel@tonic-gate 	 * whenever the server reboots.  Of secondary importance, it
5107c478bd9Sstevel@tonic-gate 	 * is important for the verifier to be unique between two
5117c478bd9Sstevel@tonic-gate 	 * different servers.
5127c478bd9Sstevel@tonic-gate 	 *
5137c478bd9Sstevel@tonic-gate 	 * Thus, an attempt is made to use the system hostid and the
5147c478bd9Sstevel@tonic-gate 	 * current time in seconds when the nfssrv kernel module is
5157c478bd9Sstevel@tonic-gate 	 * loaded.  It is assumed that an NFS server will not be able
5167c478bd9Sstevel@tonic-gate 	 * to boot and then to reboot in less than a second.  If the
5177c478bd9Sstevel@tonic-gate 	 * hostid has not been set, then the current high resolution
5187c478bd9Sstevel@tonic-gate 	 * time is used.  This will ensure different verifiers each
5197c478bd9Sstevel@tonic-gate 	 * time the server reboots and minimize the chances that two
5207c478bd9Sstevel@tonic-gate 	 * different servers will have the same verifier.
5217c478bd9Sstevel@tonic-gate 	 * XXX - this is broken on LP64 kernels.
5227c478bd9Sstevel@tonic-gate 	 */
5237c478bd9Sstevel@tonic-gate 	verf.tv_sec = (time_t)nfs_atoi(hw_serial);
5247c478bd9Sstevel@tonic-gate 	if (verf.tv_sec != 0) {
5257c478bd9Sstevel@tonic-gate 		verf.tv_nsec = gethrestime_sec();
5267c478bd9Sstevel@tonic-gate 	} else {
5277c478bd9Sstevel@tonic-gate 		timespec_t tverf;
5287c478bd9Sstevel@tonic-gate 
5297c478bd9Sstevel@tonic-gate 		gethrestime(&tverf);
5307c478bd9Sstevel@tonic-gate 		verf.tv_sec = (time_t)tverf.tv_sec;
5317c478bd9Sstevel@tonic-gate 		verf.tv_nsec = tverf.tv_nsec;
5327c478bd9Sstevel@tonic-gate 	}
5337c478bd9Sstevel@tonic-gate 
5347c478bd9Sstevel@tonic-gate 	Write4verf = *(uint64_t *)&verf;
5357c478bd9Sstevel@tonic-gate 
5367c478bd9Sstevel@tonic-gate 	rfs4_attr_init();
5377c478bd9Sstevel@tonic-gate 	mutex_init(&rfs4_deleg_lock, NULL, MUTEX_DEFAULT, NULL);
5387c478bd9Sstevel@tonic-gate 
5397c478bd9Sstevel@tonic-gate 	/* Used to manage create/destroy of server state */
5407c478bd9Sstevel@tonic-gate 	mutex_init(&rfs4_state_lock, NULL, MUTEX_DEFAULT, NULL);
5417c478bd9Sstevel@tonic-gate 
5427c478bd9Sstevel@tonic-gate 	/* Used to manage access to server instance linked list */
5437c478bd9Sstevel@tonic-gate 	mutex_init(&rfs4_servinst_lock, NULL, MUTEX_DEFAULT, NULL);
5447c478bd9Sstevel@tonic-gate 
5457c478bd9Sstevel@tonic-gate 	/* Used to manage access to rfs4_deleg_policy */
5467c478bd9Sstevel@tonic-gate 	rw_init(&rfs4_deleg_policy_lock, NULL, RW_DEFAULT, NULL);
5477c478bd9Sstevel@tonic-gate 
5487c478bd9Sstevel@tonic-gate 	error = fem_create("deleg_rdops", nfs4_rd_deleg_tmpl, &deleg_rdops);
5497c478bd9Sstevel@tonic-gate 	if (error != 0) {
5507c478bd9Sstevel@tonic-gate 		rfs4_disable_delegation();
5517c478bd9Sstevel@tonic-gate 	} else {
5527c478bd9Sstevel@tonic-gate 		error = fem_create("deleg_wrops", nfs4_wr_deleg_tmpl,
5531b300de9Sjwahlig 		    &deleg_wrops);
5547c478bd9Sstevel@tonic-gate 		if (error != 0) {
5557c478bd9Sstevel@tonic-gate 			rfs4_disable_delegation();
5567c478bd9Sstevel@tonic-gate 			fem_free(deleg_rdops);
5577c478bd9Sstevel@tonic-gate 		}
5587c478bd9Sstevel@tonic-gate 	}
5597c478bd9Sstevel@tonic-gate 
5607c478bd9Sstevel@tonic-gate 	nfs4_srv_caller_id = fs_new_caller_id();
5617c478bd9Sstevel@tonic-gate 
5627c478bd9Sstevel@tonic-gate 	lockt_sysid = lm_alloc_sysidt();
5637c478bd9Sstevel@tonic-gate 
5641b300de9Sjwahlig 	vsd_create(&nfs4_srv_vkey, NULL);
5651b300de9Sjwahlig 
5667c478bd9Sstevel@tonic-gate 	return (0);
5677c478bd9Sstevel@tonic-gate }
5687c478bd9Sstevel@tonic-gate 
5697c478bd9Sstevel@tonic-gate void
5707c478bd9Sstevel@tonic-gate rfs4_srvrfini(void)
5717c478bd9Sstevel@tonic-gate {
5727c478bd9Sstevel@tonic-gate 	extern krwlock_t rfs4_deleg_policy_lock;
5737c478bd9Sstevel@tonic-gate 
5747c478bd9Sstevel@tonic-gate 	if (lockt_sysid != LM_NOSYSID) {
5757c478bd9Sstevel@tonic-gate 		lm_free_sysidt(lockt_sysid);
5767c478bd9Sstevel@tonic-gate 		lockt_sysid = LM_NOSYSID;
5777c478bd9Sstevel@tonic-gate 	}
5787c478bd9Sstevel@tonic-gate 
5797c478bd9Sstevel@tonic-gate 	mutex_destroy(&rfs4_deleg_lock);
5807c478bd9Sstevel@tonic-gate 	mutex_destroy(&rfs4_state_lock);
5817c478bd9Sstevel@tonic-gate 	rw_destroy(&rfs4_deleg_policy_lock);
5827c478bd9Sstevel@tonic-gate 
5837c478bd9Sstevel@tonic-gate 	fem_free(deleg_rdops);
5847c478bd9Sstevel@tonic-gate 	fem_free(deleg_wrops);
5857c478bd9Sstevel@tonic-gate }
5867c478bd9Sstevel@tonic-gate 
5877c478bd9Sstevel@tonic-gate void
5887c478bd9Sstevel@tonic-gate rfs4_init_compound_state(struct compound_state *cs)
5897c478bd9Sstevel@tonic-gate {
5907c478bd9Sstevel@tonic-gate 	bzero(cs, sizeof (*cs));
5917c478bd9Sstevel@tonic-gate 	cs->cont = TRUE;
5927c478bd9Sstevel@tonic-gate 	cs->access = CS_ACCESS_DENIED;
5937c478bd9Sstevel@tonic-gate 	cs->deleg = FALSE;
5947c478bd9Sstevel@tonic-gate 	cs->mandlock = FALSE;
5957c478bd9Sstevel@tonic-gate 	cs->fh.nfs_fh4_val = cs->fhbuf;
5967c478bd9Sstevel@tonic-gate }
5977c478bd9Sstevel@tonic-gate 
5987c478bd9Sstevel@tonic-gate void
5997c478bd9Sstevel@tonic-gate rfs4_grace_start(rfs4_servinst_t *sip)
6007c478bd9Sstevel@tonic-gate {
6017c478bd9Sstevel@tonic-gate 	time_t now = gethrestime_sec();
6027c478bd9Sstevel@tonic-gate 
6037c478bd9Sstevel@tonic-gate 	rw_enter(&sip->rwlock, RW_WRITER);
6047c478bd9Sstevel@tonic-gate 	sip->start_time = now;
6057c478bd9Sstevel@tonic-gate 	sip->grace_period = rfs4_grace_period;
6067c478bd9Sstevel@tonic-gate 	rw_exit(&sip->rwlock);
6077c478bd9Sstevel@tonic-gate }
6087c478bd9Sstevel@tonic-gate 
6097c478bd9Sstevel@tonic-gate /*
6107c478bd9Sstevel@tonic-gate  * returns true if the instance's grace period has never been started
6117c478bd9Sstevel@tonic-gate  */
6127c478bd9Sstevel@tonic-gate int
6137c478bd9Sstevel@tonic-gate rfs4_servinst_grace_new(rfs4_servinst_t *sip)
6147c478bd9Sstevel@tonic-gate {
6157c478bd9Sstevel@tonic-gate 	time_t start_time;
6167c478bd9Sstevel@tonic-gate 
6177c478bd9Sstevel@tonic-gate 	rw_enter(&sip->rwlock, RW_READER);
6187c478bd9Sstevel@tonic-gate 	start_time = sip->start_time;
6197c478bd9Sstevel@tonic-gate 	rw_exit(&sip->rwlock);
6207c478bd9Sstevel@tonic-gate 
6217c478bd9Sstevel@tonic-gate 	return (start_time == 0);
6227c478bd9Sstevel@tonic-gate }
6237c478bd9Sstevel@tonic-gate 
6247c478bd9Sstevel@tonic-gate /*
6257c478bd9Sstevel@tonic-gate  * Indicates if server instance is within the
6267c478bd9Sstevel@tonic-gate  * grace period.
6277c478bd9Sstevel@tonic-gate  */
6287c478bd9Sstevel@tonic-gate int
6297c478bd9Sstevel@tonic-gate rfs4_servinst_in_grace(rfs4_servinst_t *sip)
6307c478bd9Sstevel@tonic-gate {
6317c478bd9Sstevel@tonic-gate 	time_t grace_expiry;
6327c478bd9Sstevel@tonic-gate 
6337c478bd9Sstevel@tonic-gate 	rw_enter(&sip->rwlock, RW_READER);
6347c478bd9Sstevel@tonic-gate 	grace_expiry = sip->start_time + sip->grace_period;
6357c478bd9Sstevel@tonic-gate 	rw_exit(&sip->rwlock);
6367c478bd9Sstevel@tonic-gate 
6377c478bd9Sstevel@tonic-gate 	return (gethrestime_sec() < grace_expiry);
6387c478bd9Sstevel@tonic-gate }
6397c478bd9Sstevel@tonic-gate 
6407c478bd9Sstevel@tonic-gate int
6417c478bd9Sstevel@tonic-gate rfs4_clnt_in_grace(rfs4_client_t *cp)
6427c478bd9Sstevel@tonic-gate {
6437c478bd9Sstevel@tonic-gate 	ASSERT(rfs4_dbe_refcnt(cp->dbe) > 0);
6447c478bd9Sstevel@tonic-gate 
6457c478bd9Sstevel@tonic-gate 	return (rfs4_servinst_in_grace(cp->server_instance));
6467c478bd9Sstevel@tonic-gate }
6477c478bd9Sstevel@tonic-gate 
6487c478bd9Sstevel@tonic-gate /*
6497c478bd9Sstevel@tonic-gate  * reset all currently active grace periods
6507c478bd9Sstevel@tonic-gate  */
6517c478bd9Sstevel@tonic-gate void
6527c478bd9Sstevel@tonic-gate rfs4_grace_reset_all(void)
6537c478bd9Sstevel@tonic-gate {
6547c478bd9Sstevel@tonic-gate 	rfs4_servinst_t *sip;
6557c478bd9Sstevel@tonic-gate 
6567c478bd9Sstevel@tonic-gate 	mutex_enter(&rfs4_servinst_lock);
657cee86682Scalum 	for (sip = rfs4_cur_servinst; sip != NULL; sip = sip->prev)
658cee86682Scalum 		if (rfs4_servinst_in_grace(sip))
6597c478bd9Sstevel@tonic-gate 			rfs4_grace_start(sip);
6607c478bd9Sstevel@tonic-gate 	mutex_exit(&rfs4_servinst_lock);
6617c478bd9Sstevel@tonic-gate }
6627c478bd9Sstevel@tonic-gate 
6637c478bd9Sstevel@tonic-gate /*
6647c478bd9Sstevel@tonic-gate  * start any new instances' grace periods
6657c478bd9Sstevel@tonic-gate  */
6667c478bd9Sstevel@tonic-gate void
6677c478bd9Sstevel@tonic-gate rfs4_grace_start_new(void)
6687c478bd9Sstevel@tonic-gate {
6697c478bd9Sstevel@tonic-gate 	rfs4_servinst_t *sip;
6707c478bd9Sstevel@tonic-gate 
6717c478bd9Sstevel@tonic-gate 	mutex_enter(&rfs4_servinst_lock);
672cee86682Scalum 	for (sip = rfs4_cur_servinst; sip != NULL; sip = sip->prev)
6737c478bd9Sstevel@tonic-gate 		if (rfs4_servinst_grace_new(sip))
6747c478bd9Sstevel@tonic-gate 			rfs4_grace_start(sip);
6757c478bd9Sstevel@tonic-gate 	mutex_exit(&rfs4_servinst_lock);
676cee86682Scalum }
677cee86682Scalum 
678cee86682Scalum static rfs4_dss_path_t *
679cee86682Scalum rfs4_dss_newpath(rfs4_servinst_t *sip, char *path, unsigned index)
680cee86682Scalum {
681cee86682Scalum 	size_t len;
682cee86682Scalum 	rfs4_dss_path_t *dss_path;
683cee86682Scalum 
684cee86682Scalum 	dss_path = kmem_alloc(sizeof (rfs4_dss_path_t), KM_SLEEP);
685cee86682Scalum 
686cee86682Scalum 	/*
687cee86682Scalum 	 * Take a copy of the string, since the original may be overwritten.
688cee86682Scalum 	 * Sadly, no strdup() in the kernel.
689cee86682Scalum 	 */
690cee86682Scalum 	/* allow for NUL */
691cee86682Scalum 	len = strlen(path) + 1;
692cee86682Scalum 	dss_path->path = kmem_alloc(len, KM_SLEEP);
693cee86682Scalum 	(void) strlcpy(dss_path->path, path, len);
694cee86682Scalum 
695cee86682Scalum 	/* associate with servinst */
696cee86682Scalum 	dss_path->sip = sip;
697cee86682Scalum 	dss_path->index = index;
698cee86682Scalum 
699cee86682Scalum 	/*
700cee86682Scalum 	 * Add to list of served paths.
701cee86682Scalum 	 * No locking required, as we're only ever called at startup.
702cee86682Scalum 	 */
703cee86682Scalum 	if (rfs4_dss_pathlist == NULL) {
704cee86682Scalum 		/* this is the first dss_path_t */
7057c478bd9Sstevel@tonic-gate 
706cee86682Scalum 		/* needed for insque/remque */
707cee86682Scalum 		dss_path->next = dss_path->prev = dss_path;
708cee86682Scalum 
709cee86682Scalum 		rfs4_dss_pathlist = dss_path;
710cee86682Scalum 	} else {
711cee86682Scalum 		insque(dss_path, rfs4_dss_pathlist);
712cee86682Scalum 	}
713cee86682Scalum 
714cee86682Scalum 	return (dss_path);
7157c478bd9Sstevel@tonic-gate }
7167c478bd9Sstevel@tonic-gate 
7177c478bd9Sstevel@tonic-gate /*
7187c478bd9Sstevel@tonic-gate  * Create a new server instance, and make it the currently active instance.
7197c478bd9Sstevel@tonic-gate  * Note that starting the grace period too early will reduce the clients'
7207c478bd9Sstevel@tonic-gate  * recovery window.
7217c478bd9Sstevel@tonic-gate  */
7227c478bd9Sstevel@tonic-gate void
723cee86682Scalum rfs4_servinst_create(int start_grace, int dss_npaths, char **dss_paths)
7247c478bd9Sstevel@tonic-gate {
725cee86682Scalum 	unsigned i;
7267c478bd9Sstevel@tonic-gate 	rfs4_servinst_t *sip;
727cee86682Scalum 	rfs4_oldstate_t *oldstate;
7287c478bd9Sstevel@tonic-gate 
7297c478bd9Sstevel@tonic-gate 	sip = kmem_alloc(sizeof (rfs4_servinst_t), KM_SLEEP);
7307c478bd9Sstevel@tonic-gate 	rw_init(&sip->rwlock, NULL, RW_DEFAULT, NULL);
7317c478bd9Sstevel@tonic-gate 
7327c478bd9Sstevel@tonic-gate 	sip->start_time = (time_t)0;
7337c478bd9Sstevel@tonic-gate 	sip->grace_period = (time_t)0;
7347c478bd9Sstevel@tonic-gate 	sip->next = NULL;
7357c478bd9Sstevel@tonic-gate 	sip->prev = NULL;
7367c478bd9Sstevel@tonic-gate 
737cee86682Scalum 	rw_init(&sip->oldstate_lock, NULL, RW_DEFAULT, NULL);
738cee86682Scalum 	/*
739cee86682Scalum 	 * This initial dummy entry is required to setup for insque/remque.
740cee86682Scalum 	 * It must be skipped over whenever the list is traversed.
741cee86682Scalum 	 */
742cee86682Scalum 	oldstate = kmem_alloc(sizeof (rfs4_oldstate_t), KM_SLEEP);
743cee86682Scalum 	/* insque/remque require initial list entry to be self-terminated */
744cee86682Scalum 	oldstate->next = oldstate;
745cee86682Scalum 	oldstate->prev = oldstate;
746cee86682Scalum 	sip->oldstate = oldstate;
747cee86682Scalum 
748cee86682Scalum 
749cee86682Scalum 	sip->dss_npaths = dss_npaths;
750cee86682Scalum 	sip->dss_paths = kmem_alloc(dss_npaths *
751cee86682Scalum 	    sizeof (rfs4_dss_path_t *), KM_SLEEP);
752cee86682Scalum 
753cee86682Scalum 	for (i = 0; i < dss_npaths; i++) {
754cee86682Scalum 		sip->dss_paths[i] = rfs4_dss_newpath(sip, dss_paths[i], i);
755cee86682Scalum 	}
756cee86682Scalum 
7577c478bd9Sstevel@tonic-gate 	mutex_enter(&rfs4_servinst_lock);
758cee86682Scalum 	if (rfs4_cur_servinst != NULL) {
7597c478bd9Sstevel@tonic-gate 		/* add to linked list */
7607c478bd9Sstevel@tonic-gate 		sip->prev = rfs4_cur_servinst;
7617c478bd9Sstevel@tonic-gate 		rfs4_cur_servinst->next = sip;
7627c478bd9Sstevel@tonic-gate 	}
7637c478bd9Sstevel@tonic-gate 	if (start_grace)
7647c478bd9Sstevel@tonic-gate 		rfs4_grace_start(sip);
7657c478bd9Sstevel@tonic-gate 	/* make the new instance "current" */
7667c478bd9Sstevel@tonic-gate 	rfs4_cur_servinst = sip;
7677c478bd9Sstevel@tonic-gate 
768cee86682Scalum 	mutex_exit(&rfs4_servinst_lock);
7697c478bd9Sstevel@tonic-gate }
7707c478bd9Sstevel@tonic-gate 
7717c478bd9Sstevel@tonic-gate /*
7727c478bd9Sstevel@tonic-gate  * In future, we might add a rfs4_servinst_destroy(sip) but, for now, destroy
7737c478bd9Sstevel@tonic-gate  * all instances directly.
7747c478bd9Sstevel@tonic-gate  */
7757c478bd9Sstevel@tonic-gate void
7767c478bd9Sstevel@tonic-gate rfs4_servinst_destroy_all(void)
7777c478bd9Sstevel@tonic-gate {
7787c478bd9Sstevel@tonic-gate 	rfs4_servinst_t *sip, *prev, *current;
7797c478bd9Sstevel@tonic-gate #ifdef DEBUG
7807c478bd9Sstevel@tonic-gate 	int n = 0;
7817c478bd9Sstevel@tonic-gate #endif
7827c478bd9Sstevel@tonic-gate 
7837c478bd9Sstevel@tonic-gate 	mutex_enter(&rfs4_servinst_lock);
7847c478bd9Sstevel@tonic-gate 	ASSERT(rfs4_cur_servinst != NULL);
7857c478bd9Sstevel@tonic-gate 	current = rfs4_cur_servinst;
7867c478bd9Sstevel@tonic-gate 	rfs4_cur_servinst = NULL;
7877c478bd9Sstevel@tonic-gate 	for (sip = current; sip != NULL; sip = prev) {
7887c478bd9Sstevel@tonic-gate 		prev = sip->prev;
7897c478bd9Sstevel@tonic-gate 		rw_destroy(&sip->rwlock);
790cee86682Scalum 		if (sip->oldstate)
791cee86682Scalum 			kmem_free(sip->oldstate, sizeof (rfs4_oldstate_t));
792cee86682Scalum 		if (sip->dss_paths)
793cee86682Scalum 			kmem_free(sip->dss_paths,
794cee86682Scalum 			    sip->dss_npaths * sizeof (rfs4_dss_path_t *));
7957c478bd9Sstevel@tonic-gate 		kmem_free(sip, sizeof (rfs4_servinst_t));
7967c478bd9Sstevel@tonic-gate #ifdef DEBUG
7977c478bd9Sstevel@tonic-gate 		n++;
7987c478bd9Sstevel@tonic-gate #endif
7997c478bd9Sstevel@tonic-gate 	}
8007c478bd9Sstevel@tonic-gate 	mutex_exit(&rfs4_servinst_lock);
8017c478bd9Sstevel@tonic-gate }
8027c478bd9Sstevel@tonic-gate 
8037c478bd9Sstevel@tonic-gate /*
8047c478bd9Sstevel@tonic-gate  * Assign the current server instance to a client_t.
8057c478bd9Sstevel@tonic-gate  * Should be called with cp->dbe held.
8067c478bd9Sstevel@tonic-gate  */
8077c478bd9Sstevel@tonic-gate void
8087c478bd9Sstevel@tonic-gate rfs4_servinst_assign(rfs4_client_t *cp, rfs4_servinst_t *sip)
8097c478bd9Sstevel@tonic-gate {
8107c478bd9Sstevel@tonic-gate 	ASSERT(rfs4_dbe_refcnt(cp->dbe) > 0);
8117c478bd9Sstevel@tonic-gate 
8127c478bd9Sstevel@tonic-gate 	/*
8137c478bd9Sstevel@tonic-gate 	 * The lock ensures that if the current instance is in the process
8147c478bd9Sstevel@tonic-gate 	 * of changing, we will see the new one.
8157c478bd9Sstevel@tonic-gate 	 */
8167c478bd9Sstevel@tonic-gate 	mutex_enter(&rfs4_servinst_lock);
8177c478bd9Sstevel@tonic-gate 	cp->server_instance = sip;
8187c478bd9Sstevel@tonic-gate 	mutex_exit(&rfs4_servinst_lock);
8197c478bd9Sstevel@tonic-gate }
8207c478bd9Sstevel@tonic-gate 
8217c478bd9Sstevel@tonic-gate rfs4_servinst_t *
8227c478bd9Sstevel@tonic-gate rfs4_servinst(rfs4_client_t *cp)
8237c478bd9Sstevel@tonic-gate {
8247c478bd9Sstevel@tonic-gate 	ASSERT(rfs4_dbe_refcnt(cp->dbe) > 0);
8257c478bd9Sstevel@tonic-gate 
8267c478bd9Sstevel@tonic-gate 	return (cp->server_instance);
8277c478bd9Sstevel@tonic-gate }
8287c478bd9Sstevel@tonic-gate 
8297c478bd9Sstevel@tonic-gate /* ARGSUSED */
8307c478bd9Sstevel@tonic-gate static void
8317c478bd9Sstevel@tonic-gate nullfree(caddr_t resop)
8327c478bd9Sstevel@tonic-gate {
8337c478bd9Sstevel@tonic-gate }
8347c478bd9Sstevel@tonic-gate 
8357c478bd9Sstevel@tonic-gate /*
8367c478bd9Sstevel@tonic-gate  * This is a fall-through for invalid or not implemented (yet) ops
8377c478bd9Sstevel@tonic-gate  */
8387c478bd9Sstevel@tonic-gate /* ARGSUSED */
8397c478bd9Sstevel@tonic-gate static void
8407c478bd9Sstevel@tonic-gate rfs4_op_inval(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
8417c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
8427c478bd9Sstevel@tonic-gate {
8437c478bd9Sstevel@tonic-gate 	*cs->statusp = *((nfsstat4 *)&(resop)->nfs_resop4_u) = NFS4ERR_INVAL;
8447c478bd9Sstevel@tonic-gate }
8457c478bd9Sstevel@tonic-gate 
8467c478bd9Sstevel@tonic-gate /*
8477c478bd9Sstevel@tonic-gate  * Check if the security flavor, nfsnum, is in the flavor_list.
8487c478bd9Sstevel@tonic-gate  */
8497c478bd9Sstevel@tonic-gate bool_t
8507c478bd9Sstevel@tonic-gate in_flavor_list(int nfsnum, int *flavor_list, int count)
8517c478bd9Sstevel@tonic-gate {
8527c478bd9Sstevel@tonic-gate 	int i;
8537c478bd9Sstevel@tonic-gate 
8547c478bd9Sstevel@tonic-gate 	for (i = 0; i < count; i++) {
8557c478bd9Sstevel@tonic-gate 		if (nfsnum == flavor_list[i])
8567c478bd9Sstevel@tonic-gate 			return (TRUE);
8577c478bd9Sstevel@tonic-gate 	}
8587c478bd9Sstevel@tonic-gate 	return (FALSE);
8597c478bd9Sstevel@tonic-gate }
8607c478bd9Sstevel@tonic-gate 
8617c478bd9Sstevel@tonic-gate /*
8627c478bd9Sstevel@tonic-gate  * Used by rfs4_op_secinfo to get the security information from the
8637c478bd9Sstevel@tonic-gate  * export structure associated with the component.
8647c478bd9Sstevel@tonic-gate  */
8657c478bd9Sstevel@tonic-gate /* ARGSUSED */
8667c478bd9Sstevel@tonic-gate static nfsstat4
8677c478bd9Sstevel@tonic-gate do_rfs4_op_secinfo(struct compound_state *cs, char *nm, SECINFO4res *resp)
8687c478bd9Sstevel@tonic-gate {
8697c478bd9Sstevel@tonic-gate 	int error, different_export = 0;
8707c478bd9Sstevel@tonic-gate 	vnode_t *dvp, *vp, *tvp;
8717c478bd9Sstevel@tonic-gate 	struct exportinfo *exi = NULL;
8727c478bd9Sstevel@tonic-gate 	fid_t fid;
8737c478bd9Sstevel@tonic-gate 	uint_t count, i;
8747c478bd9Sstevel@tonic-gate 	secinfo4 *resok_val;
8757c478bd9Sstevel@tonic-gate 	struct secinfo *secp;
8761b300de9Sjwahlig 	seconfig_t *si;
8777c478bd9Sstevel@tonic-gate 	bool_t did_traverse;
8787c478bd9Sstevel@tonic-gate 	int dotdot, walk;
8797c478bd9Sstevel@tonic-gate 
8807c478bd9Sstevel@tonic-gate 	dvp = cs->vp;
8817c478bd9Sstevel@tonic-gate 	dotdot = (nm[0] == '.' && nm[1] == '.' && nm[2] == '\0');
8827c478bd9Sstevel@tonic-gate 
8837c478bd9Sstevel@tonic-gate 	/*
8847c478bd9Sstevel@tonic-gate 	 * If dotdotting, then need to check whether it's above the
8857c478bd9Sstevel@tonic-gate 	 * root of a filesystem, or above an export point.
8867c478bd9Sstevel@tonic-gate 	 */
8877c478bd9Sstevel@tonic-gate 	if (dotdot) {
8887c478bd9Sstevel@tonic-gate 
8897c478bd9Sstevel@tonic-gate 		/*
8907c478bd9Sstevel@tonic-gate 		 * If dotdotting at the root of a filesystem, then
8917c478bd9Sstevel@tonic-gate 		 * need to traverse back to the mounted-on filesystem
8927c478bd9Sstevel@tonic-gate 		 * and do the dotdot lookup there.
8937c478bd9Sstevel@tonic-gate 		 */
8947c478bd9Sstevel@tonic-gate 		if (cs->vp->v_flag & VROOT) {
8957c478bd9Sstevel@tonic-gate 
8967c478bd9Sstevel@tonic-gate 			/*
8977c478bd9Sstevel@tonic-gate 			 * If at the system root, then can
8987c478bd9Sstevel@tonic-gate 			 * go up no further.
8997c478bd9Sstevel@tonic-gate 			 */
9007c478bd9Sstevel@tonic-gate 			if (VN_CMP(dvp, rootdir))
9017c478bd9Sstevel@tonic-gate 				return (puterrno4(ENOENT));
9027c478bd9Sstevel@tonic-gate 
9037c478bd9Sstevel@tonic-gate 			/*
9047c478bd9Sstevel@tonic-gate 			 * Traverse back to the mounted-on filesystem
9057c478bd9Sstevel@tonic-gate 			 */
9067c478bd9Sstevel@tonic-gate 			dvp = untraverse(cs->vp);
9077c478bd9Sstevel@tonic-gate 
9087c478bd9Sstevel@tonic-gate 			/*
9097c478bd9Sstevel@tonic-gate 			 * Set the different_export flag so we remember
9107c478bd9Sstevel@tonic-gate 			 * to pick up a new exportinfo entry for
9117c478bd9Sstevel@tonic-gate 			 * this new filesystem.
9127c478bd9Sstevel@tonic-gate 			 */
9137c478bd9Sstevel@tonic-gate 			different_export = 1;
9147c478bd9Sstevel@tonic-gate 		} else {
9157c478bd9Sstevel@tonic-gate 
9167c478bd9Sstevel@tonic-gate 			/*
9177c478bd9Sstevel@tonic-gate 			 * If dotdotting above an export point then set
9187c478bd9Sstevel@tonic-gate 			 * the different_export to get new export info.
9197c478bd9Sstevel@tonic-gate 			 */
9207c478bd9Sstevel@tonic-gate 			different_export = nfs_exported(cs->exi, cs->vp);
9217c478bd9Sstevel@tonic-gate 		}
9227c478bd9Sstevel@tonic-gate 	}
9237c478bd9Sstevel@tonic-gate 
9247c478bd9Sstevel@tonic-gate 	/*
9257c478bd9Sstevel@tonic-gate 	 * Get the vnode for the component "nm".
9267c478bd9Sstevel@tonic-gate 	 */
927da6c28aaSamw 	error = VOP_LOOKUP(dvp, nm, &vp, NULL, 0, NULL, cs->cr,
928da6c28aaSamw 	    NULL, NULL, NULL);
9297c478bd9Sstevel@tonic-gate 	if (error)
9307c478bd9Sstevel@tonic-gate 		return (puterrno4(error));
9317c478bd9Sstevel@tonic-gate 
9327c478bd9Sstevel@tonic-gate 	/*
9337c478bd9Sstevel@tonic-gate 	 * If the vnode is in a pseudo filesystem, or if the security flavor
9347c478bd9Sstevel@tonic-gate 	 * used in the request is valid but not an explicitly shared flavor,
9357c478bd9Sstevel@tonic-gate 	 * or the access bit indicates that this is a limited access,
9367c478bd9Sstevel@tonic-gate 	 * check whether this vnode is visible.
9377c478bd9Sstevel@tonic-gate 	 */
9387c478bd9Sstevel@tonic-gate 	if (!different_export &&
9397c478bd9Sstevel@tonic-gate 	    (PSEUDO(cs->exi) || ! is_exported_sec(cs->nfsflavor, cs->exi) ||
9407c478bd9Sstevel@tonic-gate 	    cs->access & CS_ACCESS_LIMITED)) {
9417c478bd9Sstevel@tonic-gate 		if (! nfs_visible(cs->exi, vp, &different_export)) {
9427c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
9437c478bd9Sstevel@tonic-gate 			return (puterrno4(ENOENT));
9447c478bd9Sstevel@tonic-gate 		}
9457c478bd9Sstevel@tonic-gate 	}
9467c478bd9Sstevel@tonic-gate 
9477c478bd9Sstevel@tonic-gate 	/*
9487c478bd9Sstevel@tonic-gate 	 * If it's a mountpoint, then traverse it.
9497c478bd9Sstevel@tonic-gate 	 */
9507c478bd9Sstevel@tonic-gate 	if (vn_ismntpt(vp)) {
9517c478bd9Sstevel@tonic-gate 		tvp = vp;
9527c478bd9Sstevel@tonic-gate 		if ((error = traverse(&tvp)) != 0) {
9537c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
9547c478bd9Sstevel@tonic-gate 			return (puterrno4(error));
9557c478bd9Sstevel@tonic-gate 		}
9567c478bd9Sstevel@tonic-gate 		/* remember that we had to traverse mountpoint */
9577c478bd9Sstevel@tonic-gate 		did_traverse = TRUE;
9587c478bd9Sstevel@tonic-gate 		vp = tvp;
9597c478bd9Sstevel@tonic-gate 		different_export = 1;
9607c478bd9Sstevel@tonic-gate 	} else if (vp->v_vfsp != dvp->v_vfsp) {
9617c478bd9Sstevel@tonic-gate 		/*
9627c478bd9Sstevel@tonic-gate 		 * If vp isn't a mountpoint and the vfs ptrs aren't the same,
9637c478bd9Sstevel@tonic-gate 		 * then vp is probably an LOFS object.  We don't need the
9647c478bd9Sstevel@tonic-gate 		 * realvp, we just need to know that we might have crossed
9657c478bd9Sstevel@tonic-gate 		 * a server fs boundary and need to call checkexport4.
9667c478bd9Sstevel@tonic-gate 		 * (LOFS lookup hides server fs mountpoints, and actually calls
9677c478bd9Sstevel@tonic-gate 		 * traverse)
9687c478bd9Sstevel@tonic-gate 		 */
9697c478bd9Sstevel@tonic-gate 		different_export = 1;
9707c478bd9Sstevel@tonic-gate 		did_traverse = FALSE;
9717c478bd9Sstevel@tonic-gate 	}
9727c478bd9Sstevel@tonic-gate 
9737c478bd9Sstevel@tonic-gate 	/*
9747c478bd9Sstevel@tonic-gate 	 * Get the export information for it.
9757c478bd9Sstevel@tonic-gate 	 */
9767c478bd9Sstevel@tonic-gate 	if (different_export) {
9777c478bd9Sstevel@tonic-gate 
9787c478bd9Sstevel@tonic-gate 		bzero(&fid, sizeof (fid));
9797c478bd9Sstevel@tonic-gate 		fid.fid_len = MAXFIDSZ;
9807c478bd9Sstevel@tonic-gate 		error = vop_fid_pseudo(vp, &fid);
9817c478bd9Sstevel@tonic-gate 		if (error) {
9827c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
9837c478bd9Sstevel@tonic-gate 			return (puterrno4(error));
9847c478bd9Sstevel@tonic-gate 		}
9857c478bd9Sstevel@tonic-gate 
9867c478bd9Sstevel@tonic-gate 		if (dotdot)
9877c478bd9Sstevel@tonic-gate 			exi = nfs_vptoexi(NULL, vp, cs->cr, &walk, NULL, TRUE);
9887c478bd9Sstevel@tonic-gate 		else
9897c478bd9Sstevel@tonic-gate 			exi = checkexport4(&vp->v_vfsp->vfs_fsid, &fid, vp);
9907c478bd9Sstevel@tonic-gate 
9917c478bd9Sstevel@tonic-gate 		if (exi == NULL) {
9927c478bd9Sstevel@tonic-gate 			if (did_traverse == TRUE) {
9937c478bd9Sstevel@tonic-gate 				/*
9947c478bd9Sstevel@tonic-gate 				 * If this vnode is a mounted-on vnode,
9957c478bd9Sstevel@tonic-gate 				 * but the mounted-on file system is not
9967c478bd9Sstevel@tonic-gate 				 * exported, send back the secinfo for
9977c478bd9Sstevel@tonic-gate 				 * the exported node that the mounted-on
9987c478bd9Sstevel@tonic-gate 				 * vnode lives in.
9997c478bd9Sstevel@tonic-gate 				 */
10007c478bd9Sstevel@tonic-gate 				exi = cs->exi;
10017c478bd9Sstevel@tonic-gate 			} else {
10027c478bd9Sstevel@tonic-gate 				VN_RELE(vp);
10037c478bd9Sstevel@tonic-gate 				return (puterrno4(EACCES));
10047c478bd9Sstevel@tonic-gate 			}
10057c478bd9Sstevel@tonic-gate 		}
10067c478bd9Sstevel@tonic-gate 	} else {
10077c478bd9Sstevel@tonic-gate 		exi = cs->exi;
10087c478bd9Sstevel@tonic-gate 	}
10097c478bd9Sstevel@tonic-gate 	ASSERT(exi != NULL);
10107c478bd9Sstevel@tonic-gate 
10117c478bd9Sstevel@tonic-gate 
10127c478bd9Sstevel@tonic-gate 	/*
10137c478bd9Sstevel@tonic-gate 	 * Create the secinfo result based on the security information
10147c478bd9Sstevel@tonic-gate 	 * from the exportinfo structure (exi).
10157c478bd9Sstevel@tonic-gate 	 *
10167c478bd9Sstevel@tonic-gate 	 * Return all flavors for a pseudo node.
10177c478bd9Sstevel@tonic-gate 	 * For a real export node, return the flavor that the client
10187c478bd9Sstevel@tonic-gate 	 * has access with.
10197c478bd9Sstevel@tonic-gate 	 */
10207c478bd9Sstevel@tonic-gate 	ASSERT(RW_LOCK_HELD(&exported_lock));
10217c478bd9Sstevel@tonic-gate 	if (PSEUDO(exi)) {
10227c478bd9Sstevel@tonic-gate 		count = exi->exi_export.ex_seccnt; /* total sec count */
10237c478bd9Sstevel@tonic-gate 		resok_val = kmem_alloc(count * sizeof (secinfo4), KM_SLEEP);
10247c478bd9Sstevel@tonic-gate 		secp = exi->exi_export.ex_secinfo;
10257c478bd9Sstevel@tonic-gate 
10267c478bd9Sstevel@tonic-gate 		for (i = 0; i < count; i++) {
10271b300de9Sjwahlig 			si = &secp[i].s_secinfo;
10281b300de9Sjwahlig 			resok_val[i].flavor = si->sc_rpcnum;
10291b300de9Sjwahlig 			if (resok_val[i].flavor == RPCSEC_GSS) {
10301b300de9Sjwahlig 				rpcsec_gss_info *info;
10311b300de9Sjwahlig 
10321b300de9Sjwahlig 				info = &resok_val[i].flavor_info;
10331b300de9Sjwahlig 				info->qop = si->sc_qop;
10341b300de9Sjwahlig 				info->service = (rpc_gss_svc_t)si->sc_service;
10351b300de9Sjwahlig 
10361b300de9Sjwahlig 				/* get oid opaque data */
10371b300de9Sjwahlig 				info->oid.sec_oid4_len =
10381b300de9Sjwahlig 				    si->sc_gss_mech_type->length;
10391b300de9Sjwahlig 				info->oid.sec_oid4_val = kmem_alloc(
10401b300de9Sjwahlig 				    si->sc_gss_mech_type->length, KM_SLEEP);
10411b300de9Sjwahlig 				bcopy(
10421b300de9Sjwahlig 				    si->sc_gss_mech_type->elements,
10431b300de9Sjwahlig 				    info->oid.sec_oid4_val,
10441b300de9Sjwahlig 				    info->oid.sec_oid4_len);
10451b300de9Sjwahlig 			}
10467c478bd9Sstevel@tonic-gate 		}
10477c478bd9Sstevel@tonic-gate 		resp->SECINFO4resok_len = count;
10487c478bd9Sstevel@tonic-gate 		resp->SECINFO4resok_val = resok_val;
10497c478bd9Sstevel@tonic-gate 	} else {
10507c478bd9Sstevel@tonic-gate 		int ret_cnt = 0, k = 0;
10517c478bd9Sstevel@tonic-gate 		int *flavor_list;
10527c478bd9Sstevel@tonic-gate 
10537c478bd9Sstevel@tonic-gate 		count = exi->exi_export.ex_seccnt; /* total sec count */
10547c478bd9Sstevel@tonic-gate 		secp = exi->exi_export.ex_secinfo;
10557c478bd9Sstevel@tonic-gate 
10567c478bd9Sstevel@tonic-gate 		flavor_list = kmem_alloc(count * sizeof (int), KM_SLEEP);
10577c478bd9Sstevel@tonic-gate 		/* find out which flavors to return */
10587c478bd9Sstevel@tonic-gate 		for (i = 0; i < count; i ++) {
10597c478bd9Sstevel@tonic-gate 			int access, flavor, perm;
10607c478bd9Sstevel@tonic-gate 
10617c478bd9Sstevel@tonic-gate 			flavor = secp[i].s_secinfo.sc_nfsnum;
10627c478bd9Sstevel@tonic-gate 			perm = secp[i].s_flags;
10637c478bd9Sstevel@tonic-gate 
10647c478bd9Sstevel@tonic-gate 			access = nfsauth4_secinfo_access(exi, cs->req,
10651b300de9Sjwahlig 			    flavor, perm);
10667c478bd9Sstevel@tonic-gate 
10677c478bd9Sstevel@tonic-gate 			if (! (access & NFSAUTH_DENIED) &&
10687c478bd9Sstevel@tonic-gate 			    ! (access & NFSAUTH_WRONGSEC)) {
10697c478bd9Sstevel@tonic-gate 				flavor_list[ret_cnt] = flavor;
10707c478bd9Sstevel@tonic-gate 				ret_cnt++;
10717c478bd9Sstevel@tonic-gate 			}
10727c478bd9Sstevel@tonic-gate 		}
10737c478bd9Sstevel@tonic-gate 
10747c478bd9Sstevel@tonic-gate 		/* Create the returning SECINFO value */
10757c478bd9Sstevel@tonic-gate 		resok_val = kmem_alloc(ret_cnt * sizeof (secinfo4), KM_SLEEP);
10767c478bd9Sstevel@tonic-gate 
10777c478bd9Sstevel@tonic-gate 		for (i = 0; i < count; i++) {
1078*f3b585ceSsamf 			/*
1079*f3b585ceSsamf 			 * If the flavor is in the flavor list,
1080*f3b585ceSsamf 			 * fill in resok_val.
1081*f3b585ceSsamf 			 */
10821b300de9Sjwahlig 			si = &secp[i].s_secinfo;
10831b300de9Sjwahlig 			if (in_flavor_list(si->sc_nfsnum,
10841b300de9Sjwahlig 			    flavor_list, ret_cnt)) {
10851b300de9Sjwahlig 				resok_val[k].flavor = si->sc_rpcnum;
10861b300de9Sjwahlig 				if (resok_val[k].flavor == RPCSEC_GSS) {
10871b300de9Sjwahlig 					rpcsec_gss_info *info;
10881b300de9Sjwahlig 
10891b300de9Sjwahlig 					info = &resok_val[k].flavor_info;
10901b300de9Sjwahlig 					info->qop = si->sc_qop;
10911b300de9Sjwahlig 					info->service = (rpc_gss_svc_t)
10921b300de9Sjwahlig 					    si->sc_service;
10931b300de9Sjwahlig 
10941b300de9Sjwahlig 					/* get oid opaque data */
10951b300de9Sjwahlig 					info->oid.sec_oid4_len =
10961b300de9Sjwahlig 					    si->sc_gss_mech_type->length;
10971b300de9Sjwahlig 					info->oid.sec_oid4_val = kmem_alloc(
10981b300de9Sjwahlig 					    si->sc_gss_mech_type->length,
10991b300de9Sjwahlig 					    KM_SLEEP);
11001b300de9Sjwahlig 					bcopy(si->sc_gss_mech_type->elements,
11011b300de9Sjwahlig 					    info->oid.sec_oid4_val,
11021b300de9Sjwahlig 					    info->oid.sec_oid4_len);
11031b300de9Sjwahlig 				}
11041b300de9Sjwahlig 				k++;
11057c478bd9Sstevel@tonic-gate 			}
1106*f3b585ceSsamf 			if (k >= ret_cnt)
1107*f3b585ceSsamf 				break;
11087c478bd9Sstevel@tonic-gate 		}
11097c478bd9Sstevel@tonic-gate 		resp->SECINFO4resok_len = ret_cnt;
11107c478bd9Sstevel@tonic-gate 		resp->SECINFO4resok_val = resok_val;
11117c478bd9Sstevel@tonic-gate 		kmem_free(flavor_list, count * sizeof (int));
11127c478bd9Sstevel@tonic-gate 	}
11137c478bd9Sstevel@tonic-gate 
11147c478bd9Sstevel@tonic-gate 	VN_RELE(vp);
11157c478bd9Sstevel@tonic-gate 	return (NFS4_OK);
11167c478bd9Sstevel@tonic-gate }
11177c478bd9Sstevel@tonic-gate 
11187c478bd9Sstevel@tonic-gate /*
11197c478bd9Sstevel@tonic-gate  * SECINFO (Operation 33): Obtain required security information on
11207c478bd9Sstevel@tonic-gate  * the component name in the format of (security-mechanism-oid, qop, service)
11217c478bd9Sstevel@tonic-gate  * triplets.
11227c478bd9Sstevel@tonic-gate  */
11237c478bd9Sstevel@tonic-gate /* ARGSUSED */
11247c478bd9Sstevel@tonic-gate static void
11257c478bd9Sstevel@tonic-gate rfs4_op_secinfo(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
11267c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
11277c478bd9Sstevel@tonic-gate {
1128*f3b585ceSsamf 	SECINFO4args *args = &argop->nfs_argop4_u.opsecinfo;
11297c478bd9Sstevel@tonic-gate 	SECINFO4res *resp = &resop->nfs_resop4_u.opsecinfo;
1130*f3b585ceSsamf 	utf8string *utfnm = &args->name;
11317c478bd9Sstevel@tonic-gate 	uint_t len;
11327c478bd9Sstevel@tonic-gate 	char *nm;
11337c478bd9Sstevel@tonic-gate 
1134*f3b585ceSsamf 	DTRACE_NFSV4_2(op__secinfo__start, struct compound_state *, cs,
1135*f3b585ceSsamf 	    SECINFO4args *, args);
1136*f3b585ceSsamf 
11377c478bd9Sstevel@tonic-gate 	/*
11387c478bd9Sstevel@tonic-gate 	 * Current file handle (cfh) should have been set before getting
11397c478bd9Sstevel@tonic-gate 	 * into this function. If not, return error.
11407c478bd9Sstevel@tonic-gate 	 */
11417c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
11427c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
1143*f3b585ceSsamf 		goto out;
11447c478bd9Sstevel@tonic-gate 	}
11457c478bd9Sstevel@tonic-gate 
11467c478bd9Sstevel@tonic-gate 	if (cs->vp->v_type != VDIR) {
11477c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
1148*f3b585ceSsamf 		goto out;
11497c478bd9Sstevel@tonic-gate 	}
11507c478bd9Sstevel@tonic-gate 
11517c478bd9Sstevel@tonic-gate 	/*
11527c478bd9Sstevel@tonic-gate 	 * Verify the component name. If failed, error out, but
11537c478bd9Sstevel@tonic-gate 	 * do not error out if the component name is a "..".
11547c478bd9Sstevel@tonic-gate 	 * SECINFO will return its parents secinfo data for SECINFO "..".
11557c478bd9Sstevel@tonic-gate 	 */
11567c478bd9Sstevel@tonic-gate 	if (!utf8_dir_verify(utfnm)) {
11577c478bd9Sstevel@tonic-gate 		if (utfnm->utf8string_len != 2 ||
11581b300de9Sjwahlig 		    utfnm->utf8string_val[0] != '.' ||
11591b300de9Sjwahlig 		    utfnm->utf8string_val[1] != '.') {
11607c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_INVAL;
1161*f3b585ceSsamf 			goto out;
11627c478bd9Sstevel@tonic-gate 		}
11637c478bd9Sstevel@tonic-gate 	}
11647c478bd9Sstevel@tonic-gate 
11657c478bd9Sstevel@tonic-gate 	nm = utf8_to_str(utfnm, &len, NULL);
11667c478bd9Sstevel@tonic-gate 	if (nm == NULL) {
11677c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
1168*f3b585ceSsamf 		goto out;
11697c478bd9Sstevel@tonic-gate 	}
11707c478bd9Sstevel@tonic-gate 
11717c478bd9Sstevel@tonic-gate 	if (len > MAXNAMELEN) {
11727c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
11737c478bd9Sstevel@tonic-gate 		kmem_free(nm, len);
1174*f3b585ceSsamf 		goto out;
11757c478bd9Sstevel@tonic-gate 	}
11767c478bd9Sstevel@tonic-gate 
11777c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = do_rfs4_op_secinfo(cs, nm, resp);
11787c478bd9Sstevel@tonic-gate 
11797c478bd9Sstevel@tonic-gate 	kmem_free(nm, len);
1180*f3b585ceSsamf 
1181*f3b585ceSsamf out:
1182*f3b585ceSsamf 	DTRACE_NFSV4_2(op__secinfo__done, struct compound_state *, cs,
1183*f3b585ceSsamf 	    SECINFO4res *, resp);
11847c478bd9Sstevel@tonic-gate }
11857c478bd9Sstevel@tonic-gate 
11867c478bd9Sstevel@tonic-gate /*
11877c478bd9Sstevel@tonic-gate  * Free SECINFO result.
11887c478bd9Sstevel@tonic-gate  */
11897c478bd9Sstevel@tonic-gate /* ARGSUSED */
11907c478bd9Sstevel@tonic-gate static void
11917c478bd9Sstevel@tonic-gate rfs4_op_secinfo_free(nfs_resop4 *resop)
11927c478bd9Sstevel@tonic-gate {
11937c478bd9Sstevel@tonic-gate 	SECINFO4res *resp = &resop->nfs_resop4_u.opsecinfo;
11947c478bd9Sstevel@tonic-gate 	int count, i;
11957c478bd9Sstevel@tonic-gate 	secinfo4 *resok_val;
11967c478bd9Sstevel@tonic-gate 
11977c478bd9Sstevel@tonic-gate 	/* If this is not an Ok result, nothing to free. */
11987c478bd9Sstevel@tonic-gate 	if (resp->status != NFS4_OK) {
11997c478bd9Sstevel@tonic-gate 		return;
12007c478bd9Sstevel@tonic-gate 	}
12017c478bd9Sstevel@tonic-gate 
12027c478bd9Sstevel@tonic-gate 	count = resp->SECINFO4resok_len;
12037c478bd9Sstevel@tonic-gate 	resok_val = resp->SECINFO4resok_val;
12047c478bd9Sstevel@tonic-gate 
12057c478bd9Sstevel@tonic-gate 	for (i = 0; i < count; i++) {
12061b300de9Sjwahlig 		if (resok_val[i].flavor == RPCSEC_GSS) {
12071b300de9Sjwahlig 			rpcsec_gss_info *info;
12087c478bd9Sstevel@tonic-gate 
12091b300de9Sjwahlig 			info = &resok_val[i].flavor_info;
12101b300de9Sjwahlig 			kmem_free(info->oid.sec_oid4_val,
12111b300de9Sjwahlig 			    info->oid.sec_oid4_len);
12121b300de9Sjwahlig 		}
12137c478bd9Sstevel@tonic-gate 	}
12147c478bd9Sstevel@tonic-gate 	kmem_free(resok_val, count * sizeof (secinfo4));
12157c478bd9Sstevel@tonic-gate 	resp->SECINFO4resok_len = 0;
12167c478bd9Sstevel@tonic-gate 	resp->SECINFO4resok_val = NULL;
12177c478bd9Sstevel@tonic-gate }
12187c478bd9Sstevel@tonic-gate 
12197c478bd9Sstevel@tonic-gate /* ARGSUSED */
12207c478bd9Sstevel@tonic-gate static void
12217c478bd9Sstevel@tonic-gate rfs4_op_access(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
12227c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
12237c478bd9Sstevel@tonic-gate {
12247c478bd9Sstevel@tonic-gate 	ACCESS4args *args = &argop->nfs_argop4_u.opaccess;
12257c478bd9Sstevel@tonic-gate 	ACCESS4res *resp = &resop->nfs_resop4_u.opaccess;
12267c478bd9Sstevel@tonic-gate 	int error;
12277c478bd9Sstevel@tonic-gate 	vnode_t *vp;
12287c478bd9Sstevel@tonic-gate 	struct vattr va;
12297c478bd9Sstevel@tonic-gate 	int checkwriteperm;
12307c478bd9Sstevel@tonic-gate 	cred_t *cr = cs->cr;
123145916cd2Sjpk 	bslabel_t *clabel, *slabel;
123245916cd2Sjpk 	ts_label_t *tslabel;
123345916cd2Sjpk 	boolean_t admin_low_client;
12347c478bd9Sstevel@tonic-gate 
1235*f3b585ceSsamf 	DTRACE_NFSV4_2(op__access__start, struct compound_state *, cs,
1236*f3b585ceSsamf 	    ACCESS4args *, args);
1237*f3b585ceSsamf 
12387c478bd9Sstevel@tonic-gate #if 0	/* XXX allow access even if !cs->access. Eventually only pseudo fs */
12397c478bd9Sstevel@tonic-gate 	if (cs->access == CS_ACCESS_DENIED) {
12407c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
1241*f3b585ceSsamf 		goto out;
12427c478bd9Sstevel@tonic-gate 	}
12437c478bd9Sstevel@tonic-gate #endif
12447c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
12457c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
1246*f3b585ceSsamf 		goto out;
12477c478bd9Sstevel@tonic-gate 	}
12487c478bd9Sstevel@tonic-gate 
12497c478bd9Sstevel@tonic-gate 	ASSERT(cr != NULL);
12507c478bd9Sstevel@tonic-gate 
12517c478bd9Sstevel@tonic-gate 	vp = cs->vp;
12527c478bd9Sstevel@tonic-gate 
12537c478bd9Sstevel@tonic-gate 	/*
12547c478bd9Sstevel@tonic-gate 	 * If the file system is exported read only, it is not appropriate
12557c478bd9Sstevel@tonic-gate 	 * to check write permissions for regular files and directories.
12567c478bd9Sstevel@tonic-gate 	 * Special files are interpreted by the client, so the underlying
12577c478bd9Sstevel@tonic-gate 	 * permissions are sent back to the client for interpretation.
12587c478bd9Sstevel@tonic-gate 	 */
12597c478bd9Sstevel@tonic-gate 	if (rdonly4(cs->exi, cs->vp, req) &&
12601b300de9Sjwahlig 	    (vp->v_type == VREG || vp->v_type == VDIR))
12617c478bd9Sstevel@tonic-gate 		checkwriteperm = 0;
12627c478bd9Sstevel@tonic-gate 	else
12637c478bd9Sstevel@tonic-gate 		checkwriteperm = 1;
12647c478bd9Sstevel@tonic-gate 
12657c478bd9Sstevel@tonic-gate 	/*
12667c478bd9Sstevel@tonic-gate 	 * XXX
12677c478bd9Sstevel@tonic-gate 	 * We need the mode so that we can correctly determine access
12687c478bd9Sstevel@tonic-gate 	 * permissions relative to a mandatory lock file.  Access to
12697c478bd9Sstevel@tonic-gate 	 * mandatory lock files is denied on the server, so it might
12707c478bd9Sstevel@tonic-gate 	 * as well be reflected to the server during the open.
12717c478bd9Sstevel@tonic-gate 	 */
12727c478bd9Sstevel@tonic-gate 	va.va_mask = AT_MODE;
1273da6c28aaSamw 	error = VOP_GETATTR(vp, &va, 0, cr, NULL);
12747c478bd9Sstevel@tonic-gate 	if (error) {
12757c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
1276*f3b585ceSsamf 		goto out;
12777c478bd9Sstevel@tonic-gate 	}
12787c478bd9Sstevel@tonic-gate 	resp->access = 0;
12797c478bd9Sstevel@tonic-gate 	resp->supported = 0;
12807c478bd9Sstevel@tonic-gate 
128145916cd2Sjpk 	if (is_system_labeled()) {
128245916cd2Sjpk 		ASSERT(req->rq_label != NULL);
128345916cd2Sjpk 		clabel = req->rq_label;
128445916cd2Sjpk 		DTRACE_PROBE2(tx__rfs4__log__info__opaccess__clabel, char *,
128545916cd2Sjpk 		    "got client label from request(1)",
128645916cd2Sjpk 		    struct svc_req *, req);
128745916cd2Sjpk 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
128803986916Sjarrett 			if ((tslabel = nfs_getflabel(vp)) == NULL) {
128945916cd2Sjpk 				*cs->statusp = resp->status = puterrno4(EACCES);
1290*f3b585ceSsamf 				goto out;
129145916cd2Sjpk 			}
129245916cd2Sjpk 			slabel = label2bslabel(tslabel);
129345916cd2Sjpk 			DTRACE_PROBE3(tx__rfs4__log__info__opaccess__slabel,
129445916cd2Sjpk 			    char *, "got server label(1) for vp(2)",
129545916cd2Sjpk 			    bslabel_t *, slabel, vnode_t *, vp);
129645916cd2Sjpk 
129745916cd2Sjpk 			admin_low_client = B_FALSE;
129845916cd2Sjpk 		} else
129945916cd2Sjpk 			admin_low_client = B_TRUE;
130045916cd2Sjpk 	}
130145916cd2Sjpk 
13027c478bd9Sstevel@tonic-gate 	if (args->access & ACCESS4_READ) {
1303da6c28aaSamw 		error = VOP_ACCESS(vp, VREAD, 0, cr, NULL);
130445916cd2Sjpk 		if (!error && !MANDLOCK(vp, va.va_mode) &&
130545916cd2Sjpk 		    (!is_system_labeled() || admin_low_client ||
130645916cd2Sjpk 		    bldominates(clabel, slabel)))
13077c478bd9Sstevel@tonic-gate 			resp->access |= ACCESS4_READ;
13087c478bd9Sstevel@tonic-gate 		resp->supported |= ACCESS4_READ;
13097c478bd9Sstevel@tonic-gate 	}
13107c478bd9Sstevel@tonic-gate 	if ((args->access & ACCESS4_LOOKUP) && vp->v_type == VDIR) {
1311da6c28aaSamw 		error = VOP_ACCESS(vp, VEXEC, 0, cr, NULL);
131245916cd2Sjpk 		if (!error && (!is_system_labeled() || admin_low_client ||
131345916cd2Sjpk 		    bldominates(clabel, slabel)))
13147c478bd9Sstevel@tonic-gate 			resp->access |= ACCESS4_LOOKUP;
13157c478bd9Sstevel@tonic-gate 		resp->supported |= ACCESS4_LOOKUP;
13167c478bd9Sstevel@tonic-gate 	}
13177c478bd9Sstevel@tonic-gate 	if (checkwriteperm &&
13187c478bd9Sstevel@tonic-gate 	    (args->access & (ACCESS4_MODIFY|ACCESS4_EXTEND))) {
1319da6c28aaSamw 		error = VOP_ACCESS(vp, VWRITE, 0, cr, NULL);
132045916cd2Sjpk 		if (!error && !MANDLOCK(vp, va.va_mode) &&
132145916cd2Sjpk 		    (!is_system_labeled() || admin_low_client ||
132245916cd2Sjpk 		    blequal(clabel, slabel)))
13237c478bd9Sstevel@tonic-gate 			resp->access |=
13247c478bd9Sstevel@tonic-gate 			    (args->access & (ACCESS4_MODIFY|ACCESS4_EXTEND));
13257c478bd9Sstevel@tonic-gate 		resp->supported |= (ACCESS4_MODIFY|ACCESS4_EXTEND);
13267c478bd9Sstevel@tonic-gate 	}
13277c478bd9Sstevel@tonic-gate 
13287c478bd9Sstevel@tonic-gate 	if (checkwriteperm &&
13297c478bd9Sstevel@tonic-gate 	    (args->access & ACCESS4_DELETE) && vp->v_type == VDIR) {
1330da6c28aaSamw 		error = VOP_ACCESS(vp, VWRITE, 0, cr, NULL);
133145916cd2Sjpk 		if (!error && (!is_system_labeled() || admin_low_client ||
133245916cd2Sjpk 		    blequal(clabel, slabel)))
13337c478bd9Sstevel@tonic-gate 			resp->access |= ACCESS4_DELETE;
13347c478bd9Sstevel@tonic-gate 		resp->supported |= ACCESS4_DELETE;
13357c478bd9Sstevel@tonic-gate 	}
13367c478bd9Sstevel@tonic-gate 	if (args->access & ACCESS4_EXECUTE && vp->v_type != VDIR) {
1337da6c28aaSamw 		error = VOP_ACCESS(vp, VEXEC, 0, cr, NULL);
133845916cd2Sjpk 		if (!error && !MANDLOCK(vp, va.va_mode) &&
133945916cd2Sjpk 		    (!is_system_labeled() || admin_low_client ||
134045916cd2Sjpk 		    bldominates(clabel, slabel)))
13417c478bd9Sstevel@tonic-gate 			resp->access |= ACCESS4_EXECUTE;
13427c478bd9Sstevel@tonic-gate 		resp->supported |= ACCESS4_EXECUTE;
13437c478bd9Sstevel@tonic-gate 	}
13447c478bd9Sstevel@tonic-gate 
134545916cd2Sjpk 	if (is_system_labeled() && !admin_low_client)
134645916cd2Sjpk 		label_rele(tslabel);
134745916cd2Sjpk 
13487c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
1349*f3b585ceSsamf out:
1350*f3b585ceSsamf 	DTRACE_NFSV4_2(op__access__done, struct compound_state *, cs,
1351*f3b585ceSsamf 	    ACCESS4res *, resp);
13527c478bd9Sstevel@tonic-gate }
13537c478bd9Sstevel@tonic-gate 
13547c478bd9Sstevel@tonic-gate /* ARGSUSED */
13557c478bd9Sstevel@tonic-gate static void
13567c478bd9Sstevel@tonic-gate rfs4_op_commit(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
13577c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
13587c478bd9Sstevel@tonic-gate {
13597c478bd9Sstevel@tonic-gate 	COMMIT4args *args = &argop->nfs_argop4_u.opcommit;
13607c478bd9Sstevel@tonic-gate 	COMMIT4res *resp = &resop->nfs_resop4_u.opcommit;
13617c478bd9Sstevel@tonic-gate 	int error;
13627c478bd9Sstevel@tonic-gate 	vnode_t *vp = cs->vp;
13637c478bd9Sstevel@tonic-gate 	cred_t *cr = cs->cr;
13647c478bd9Sstevel@tonic-gate 	vattr_t va;
13657c478bd9Sstevel@tonic-gate 
1366*f3b585ceSsamf 	DTRACE_NFSV4_2(op__commit__start, struct compound_state *, cs,
1367*f3b585ceSsamf 	    COMMIT4args *, args);
1368*f3b585ceSsamf 
13697c478bd9Sstevel@tonic-gate 	if (vp == NULL) {
13707c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
1371*f3b585ceSsamf 		goto out;
13727c478bd9Sstevel@tonic-gate 	}
13737c478bd9Sstevel@tonic-gate 	if (cs->access == CS_ACCESS_DENIED) {
13747c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
1375*f3b585ceSsamf 		goto out;
13767c478bd9Sstevel@tonic-gate 	}
13777c478bd9Sstevel@tonic-gate 
13787c478bd9Sstevel@tonic-gate 	if (args->offset + args->count < args->offset) {
13797c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
1380*f3b585ceSsamf 		goto out;
13817c478bd9Sstevel@tonic-gate 	}
13827c478bd9Sstevel@tonic-gate 
13837c478bd9Sstevel@tonic-gate 	va.va_mask = AT_UID;
1384da6c28aaSamw 	error = VOP_GETATTR(vp, &va, 0, cr, NULL);
13857c478bd9Sstevel@tonic-gate 
13867c478bd9Sstevel@tonic-gate 	/*
13877c478bd9Sstevel@tonic-gate 	 * If we can't get the attributes, then we can't do the
13887c478bd9Sstevel@tonic-gate 	 * right access checking.  So, we'll fail the request.
13897c478bd9Sstevel@tonic-gate 	 */
13907c478bd9Sstevel@tonic-gate 	if (error) {
13917c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
1392*f3b585ceSsamf 		goto out;
13937c478bd9Sstevel@tonic-gate 	}
13947c478bd9Sstevel@tonic-gate 	if (rdonly4(cs->exi, cs->vp, req)) {
13957c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ROFS;
1396*f3b585ceSsamf 		goto out;
13977c478bd9Sstevel@tonic-gate 	}
13987c478bd9Sstevel@tonic-gate 
13997c478bd9Sstevel@tonic-gate 	if (vp->v_type != VREG) {
14007c478bd9Sstevel@tonic-gate 		if (vp->v_type == VDIR)
14017c478bd9Sstevel@tonic-gate 			resp->status = NFS4ERR_ISDIR;
14027c478bd9Sstevel@tonic-gate 		else
14037c478bd9Sstevel@tonic-gate 			resp->status = NFS4ERR_INVAL;
14047c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status;
1405*f3b585ceSsamf 		goto out;
14067c478bd9Sstevel@tonic-gate 	}
14077c478bd9Sstevel@tonic-gate 
14087c478bd9Sstevel@tonic-gate 	if (crgetuid(cr) != va.va_uid &&
1409da6c28aaSamw 	    (error = VOP_ACCESS(vp, VWRITE, 0, cs->cr, NULL))) {
14107c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
1411*f3b585ceSsamf 		goto out;
14127c478bd9Sstevel@tonic-gate 	}
14137c478bd9Sstevel@tonic-gate 
1414da6c28aaSamw 	error = VOP_PUTPAGE(vp, args->offset, args->count, 0, cr, NULL);
14157c478bd9Sstevel@tonic-gate 	if (!error)
1416da6c28aaSamw 		error = VOP_FSYNC(vp, FNODSYNC, cr, NULL);
14177c478bd9Sstevel@tonic-gate 
14187c478bd9Sstevel@tonic-gate 	if (error) {
14197c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
1420*f3b585ceSsamf 		goto out;
14217c478bd9Sstevel@tonic-gate 	}
14227c478bd9Sstevel@tonic-gate 
14237c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
14247c478bd9Sstevel@tonic-gate 	resp->writeverf = Write4verf;
1425*f3b585ceSsamf out:
1426*f3b585ceSsamf 	DTRACE_NFSV4_2(op__commit__done, struct compound_state *, cs,
1427*f3b585ceSsamf 	    COMMIT4res *, resp);
14287c478bd9Sstevel@tonic-gate }
14297c478bd9Sstevel@tonic-gate 
14307c478bd9Sstevel@tonic-gate /*
14317c478bd9Sstevel@tonic-gate  * rfs4_op_mknod is called from rfs4_op_create after all initial verification
14327c478bd9Sstevel@tonic-gate  * was completed. It does the nfsv4 create for special files.
14337c478bd9Sstevel@tonic-gate  */
14347c478bd9Sstevel@tonic-gate /* ARGSUSED */
14357c478bd9Sstevel@tonic-gate static vnode_t *
14367c478bd9Sstevel@tonic-gate do_rfs4_op_mknod(CREATE4args *args, CREATE4res *resp, struct svc_req *req,
14377c478bd9Sstevel@tonic-gate 	struct compound_state *cs, vattr_t *vap, char *nm)
14387c478bd9Sstevel@tonic-gate {
14397c478bd9Sstevel@tonic-gate 	int error;
14407c478bd9Sstevel@tonic-gate 	cred_t *cr = cs->cr;
14417c478bd9Sstevel@tonic-gate 	vnode_t *dvp = cs->vp;
14427c478bd9Sstevel@tonic-gate 	vnode_t *vp = NULL;
14437c478bd9Sstevel@tonic-gate 	int mode;
14447c478bd9Sstevel@tonic-gate 	enum vcexcl excl;
14457c478bd9Sstevel@tonic-gate 
14467c478bd9Sstevel@tonic-gate 	switch (args->type) {
14477c478bd9Sstevel@tonic-gate 	case NF4CHR:
14487c478bd9Sstevel@tonic-gate 	case NF4BLK:
14497c478bd9Sstevel@tonic-gate 		if (secpolicy_sys_devices(cr) != 0) {
14507c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_PERM;
14517c478bd9Sstevel@tonic-gate 			return (NULL);
14527c478bd9Sstevel@tonic-gate 		}
14537c478bd9Sstevel@tonic-gate 		if (args->type == NF4CHR)
14547c478bd9Sstevel@tonic-gate 			vap->va_type = VCHR;
14557c478bd9Sstevel@tonic-gate 		else
14567c478bd9Sstevel@tonic-gate 			vap->va_type = VBLK;
14577c478bd9Sstevel@tonic-gate 		vap->va_rdev = makedevice(args->ftype4_u.devdata.specdata1,
14581b300de9Sjwahlig 		    args->ftype4_u.devdata.specdata2);
14597c478bd9Sstevel@tonic-gate 		vap->va_mask |= AT_RDEV;
14607c478bd9Sstevel@tonic-gate 		break;
14617c478bd9Sstevel@tonic-gate 	case NF4SOCK:
14627c478bd9Sstevel@tonic-gate 		vap->va_type = VSOCK;
14637c478bd9Sstevel@tonic-gate 		break;
14647c478bd9Sstevel@tonic-gate 	case NF4FIFO:
14657c478bd9Sstevel@tonic-gate 		vap->va_type = VFIFO;
14667c478bd9Sstevel@tonic-gate 		break;
14677c478bd9Sstevel@tonic-gate 	default:
14687c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BADTYPE;
14697c478bd9Sstevel@tonic-gate 		return (NULL);
14707c478bd9Sstevel@tonic-gate 	}
14717c478bd9Sstevel@tonic-gate 
14727c478bd9Sstevel@tonic-gate 	/*
14737c478bd9Sstevel@tonic-gate 	 * Must specify the mode.
14747c478bd9Sstevel@tonic-gate 	 */
14757c478bd9Sstevel@tonic-gate 	if (!(vap->va_mask & AT_MODE)) {
14767c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
14777c478bd9Sstevel@tonic-gate 		return (NULL);
14787c478bd9Sstevel@tonic-gate 	}
14797c478bd9Sstevel@tonic-gate 
14807c478bd9Sstevel@tonic-gate 	excl = EXCL;
14817c478bd9Sstevel@tonic-gate 
14827c478bd9Sstevel@tonic-gate 	mode = 0;
14837c478bd9Sstevel@tonic-gate 
1484da6c28aaSamw 	error = VOP_CREATE(dvp, nm, vap, excl, mode, &vp, cr, 0, NULL, NULL);
14857c478bd9Sstevel@tonic-gate 	if (error) {
14867c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
14877c478bd9Sstevel@tonic-gate 		return (NULL);
14887c478bd9Sstevel@tonic-gate 	}
14897c478bd9Sstevel@tonic-gate 	return (vp);
14907c478bd9Sstevel@tonic-gate }
14917c478bd9Sstevel@tonic-gate 
14927c478bd9Sstevel@tonic-gate /*
14937c478bd9Sstevel@tonic-gate  * nfsv4 create is used to create non-regular files. For regular files,
14947c478bd9Sstevel@tonic-gate  * use nfsv4 open.
14957c478bd9Sstevel@tonic-gate  */
14967c478bd9Sstevel@tonic-gate /* ARGSUSED */
14977c478bd9Sstevel@tonic-gate static void
14987c478bd9Sstevel@tonic-gate rfs4_op_create(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
14997c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
15007c478bd9Sstevel@tonic-gate {
15017c478bd9Sstevel@tonic-gate 	CREATE4args *args = &argop->nfs_argop4_u.opcreate;
15027c478bd9Sstevel@tonic-gate 	CREATE4res *resp = &resop->nfs_resop4_u.opcreate;
15037c478bd9Sstevel@tonic-gate 	int error;
15047c478bd9Sstevel@tonic-gate 	struct vattr bva, iva, iva2, ava, *vap;
15057c478bd9Sstevel@tonic-gate 	cred_t *cr = cs->cr;
15067c478bd9Sstevel@tonic-gate 	vnode_t *dvp = cs->vp;
15077c478bd9Sstevel@tonic-gate 	vnode_t *vp = NULL;
15087c478bd9Sstevel@tonic-gate 	char *nm, *lnm;
15097c478bd9Sstevel@tonic-gate 	uint_t len, llen;
15107c478bd9Sstevel@tonic-gate 	int syncval = 0;
15117c478bd9Sstevel@tonic-gate 	struct nfs4_svgetit_arg sarg;
15127c478bd9Sstevel@tonic-gate 	struct nfs4_ntov_table ntov;
15137c478bd9Sstevel@tonic-gate 	struct statvfs64 sb;
15147c478bd9Sstevel@tonic-gate 	nfsstat4 status;
15157c478bd9Sstevel@tonic-gate 
1516*f3b585ceSsamf 	DTRACE_NFSV4_2(op__create__start, struct compound_state *, cs,
1517*f3b585ceSsamf 	    CREATE4args *, args);
1518*f3b585ceSsamf 
15197c478bd9Sstevel@tonic-gate 	resp->attrset = 0;
15207c478bd9Sstevel@tonic-gate 
15217c478bd9Sstevel@tonic-gate 	if (dvp == NULL) {
15227c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
1523*f3b585ceSsamf 		goto out;
15247c478bd9Sstevel@tonic-gate 	}
15257c478bd9Sstevel@tonic-gate 
15267c478bd9Sstevel@tonic-gate 	/*
15277c478bd9Sstevel@tonic-gate 	 * If there is an unshared filesystem mounted on this vnode,
15287c478bd9Sstevel@tonic-gate 	 * do not allow to create an object in this directory.
15297c478bd9Sstevel@tonic-gate 	 */
15307c478bd9Sstevel@tonic-gate 	if (vn_ismntpt(dvp)) {
15317c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
1532*f3b585ceSsamf 		goto out;
15337c478bd9Sstevel@tonic-gate 	}
15347c478bd9Sstevel@tonic-gate 
15357c478bd9Sstevel@tonic-gate 	/* Verify that type is correct */
15367c478bd9Sstevel@tonic-gate 	switch (args->type) {
15377c478bd9Sstevel@tonic-gate 	case NF4LNK:
15387c478bd9Sstevel@tonic-gate 	case NF4BLK:
15397c478bd9Sstevel@tonic-gate 	case NF4CHR:
15407c478bd9Sstevel@tonic-gate 	case NF4SOCK:
15417c478bd9Sstevel@tonic-gate 	case NF4FIFO:
15427c478bd9Sstevel@tonic-gate 	case NF4DIR:
15437c478bd9Sstevel@tonic-gate 		break;
15447c478bd9Sstevel@tonic-gate 	default:
15457c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BADTYPE;
1546*f3b585ceSsamf 		goto out;
15477c478bd9Sstevel@tonic-gate 	};
15487c478bd9Sstevel@tonic-gate 
15497c478bd9Sstevel@tonic-gate 	if (cs->access == CS_ACCESS_DENIED) {
15507c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
1551*f3b585ceSsamf 		goto out;
15527c478bd9Sstevel@tonic-gate 	}
15537c478bd9Sstevel@tonic-gate 	if (dvp->v_type != VDIR) {
15547c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
1555*f3b585ceSsamf 		goto out;
15567c478bd9Sstevel@tonic-gate 	}
15577c478bd9Sstevel@tonic-gate 	if (!utf8_dir_verify(&args->objname)) {
15587c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
1559*f3b585ceSsamf 		goto out;
15607c478bd9Sstevel@tonic-gate 	}
15617c478bd9Sstevel@tonic-gate 
15627c478bd9Sstevel@tonic-gate 	if (rdonly4(cs->exi, cs->vp, req)) {
15637c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ROFS;
1564*f3b585ceSsamf 		goto out;
15657c478bd9Sstevel@tonic-gate 	}
15667c478bd9Sstevel@tonic-gate 
15677c478bd9Sstevel@tonic-gate 	/*
15687c478bd9Sstevel@tonic-gate 	 * Name of newly created object
15697c478bd9Sstevel@tonic-gate 	 */
15707c478bd9Sstevel@tonic-gate 	nm = utf8_to_fn(&args->objname, &len, NULL);
15717c478bd9Sstevel@tonic-gate 	if (nm == NULL) {
15727c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
1573*f3b585ceSsamf 		goto out;
15747c478bd9Sstevel@tonic-gate 	}
15757c478bd9Sstevel@tonic-gate 
15767c478bd9Sstevel@tonic-gate 	if (len > MAXNAMELEN) {
15777c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
15787c478bd9Sstevel@tonic-gate 		kmem_free(nm, len);
1579*f3b585ceSsamf 		goto out;
15807c478bd9Sstevel@tonic-gate 	}
15817c478bd9Sstevel@tonic-gate 
15827c478bd9Sstevel@tonic-gate 	resp->attrset = 0;
15837c478bd9Sstevel@tonic-gate 
15847c478bd9Sstevel@tonic-gate 	sarg.sbp = &sb;
15857c478bd9Sstevel@tonic-gate 	nfs4_ntov_table_init(&ntov);
15867c478bd9Sstevel@tonic-gate 
15877c478bd9Sstevel@tonic-gate 	status = do_rfs4_set_attrs(&resp->attrset,
15881b300de9Sjwahlig 	    &args->createattrs, cs, &sarg, &ntov, NFS4ATTR_SETIT);
15897c478bd9Sstevel@tonic-gate 
15907c478bd9Sstevel@tonic-gate 	if (sarg.vap->va_mask == 0 && status == NFS4_OK)
15917c478bd9Sstevel@tonic-gate 		status = NFS4ERR_INVAL;
15927c478bd9Sstevel@tonic-gate 
15937c478bd9Sstevel@tonic-gate 	if (status != NFS4_OK) {
15947c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = status;
15957c478bd9Sstevel@tonic-gate 		kmem_free(nm, len);
15967c478bd9Sstevel@tonic-gate 		nfs4_ntov_table_free(&ntov, &sarg);
15977c478bd9Sstevel@tonic-gate 		resp->attrset = 0;
1598*f3b585ceSsamf 		goto out;
15997c478bd9Sstevel@tonic-gate 	}
16007c478bd9Sstevel@tonic-gate 
16017c478bd9Sstevel@tonic-gate 	/* Get "before" change value */
16027c478bd9Sstevel@tonic-gate 	bva.va_mask = AT_CTIME|AT_SEQ;
1603da6c28aaSamw 	error = VOP_GETATTR(dvp, &bva, 0, cr, NULL);
16047c478bd9Sstevel@tonic-gate 	if (error) {
16057c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
16067c478bd9Sstevel@tonic-gate 		kmem_free(nm, len);
16077c478bd9Sstevel@tonic-gate 		nfs4_ntov_table_free(&ntov, &sarg);
16087c478bd9Sstevel@tonic-gate 		resp->attrset = 0;
1609*f3b585ceSsamf 		goto out;
16107c478bd9Sstevel@tonic-gate 	}
16117c478bd9Sstevel@tonic-gate 	NFS4_SET_FATTR4_CHANGE(resp->cinfo.before, bva.va_ctime)
16127c478bd9Sstevel@tonic-gate 
16137c478bd9Sstevel@tonic-gate 	vap = sarg.vap;
16147c478bd9Sstevel@tonic-gate 
16157c478bd9Sstevel@tonic-gate 	/*
16167c478bd9Sstevel@tonic-gate 	 * Set default initial values for attributes when not specified
16177c478bd9Sstevel@tonic-gate 	 * in createattrs.
16187c478bd9Sstevel@tonic-gate 	 */
16197c478bd9Sstevel@tonic-gate 	if ((vap->va_mask & AT_UID) == 0) {
16207c478bd9Sstevel@tonic-gate 		vap->va_uid = crgetuid(cr);
16217c478bd9Sstevel@tonic-gate 		vap->va_mask |= AT_UID;
16227c478bd9Sstevel@tonic-gate 	}
16237c478bd9Sstevel@tonic-gate 	if ((vap->va_mask & AT_GID) == 0) {
16247c478bd9Sstevel@tonic-gate 		vap->va_gid = crgetgid(cr);
16257c478bd9Sstevel@tonic-gate 		vap->va_mask |= AT_GID;
16267c478bd9Sstevel@tonic-gate 	}
16277c478bd9Sstevel@tonic-gate 
16287c478bd9Sstevel@tonic-gate 	vap->va_mask |= AT_TYPE;
16297c478bd9Sstevel@tonic-gate 	switch (args->type) {
16307c478bd9Sstevel@tonic-gate 	case NF4DIR:
16317c478bd9Sstevel@tonic-gate 		vap->va_type = VDIR;
16327c478bd9Sstevel@tonic-gate 		if ((vap->va_mask & AT_MODE) == 0) {
16337c478bd9Sstevel@tonic-gate 			vap->va_mode = 0700;	/* default: owner rwx only */
16347c478bd9Sstevel@tonic-gate 			vap->va_mask |= AT_MODE;
16357c478bd9Sstevel@tonic-gate 		}
1636da6c28aaSamw 		error = VOP_MKDIR(dvp, nm, vap, &vp, cr, NULL, 0, NULL);
16377c478bd9Sstevel@tonic-gate 		if (error)
16387c478bd9Sstevel@tonic-gate 			break;
16397c478bd9Sstevel@tonic-gate 
16407c478bd9Sstevel@tonic-gate 		/*
16417c478bd9Sstevel@tonic-gate 		 * Get the initial "after" sequence number, if it fails,
16427c478bd9Sstevel@tonic-gate 		 * set to zero
16437c478bd9Sstevel@tonic-gate 		 */
16447c478bd9Sstevel@tonic-gate 		iva.va_mask = AT_SEQ;
1645da6c28aaSamw 		if (VOP_GETATTR(dvp, &iva, 0, cs->cr, NULL))
16467c478bd9Sstevel@tonic-gate 			iva.va_seq = 0;
16477c478bd9Sstevel@tonic-gate 		break;
16487c478bd9Sstevel@tonic-gate 	case NF4LNK:
16497c478bd9Sstevel@tonic-gate 		vap->va_type = VLNK;
16507c478bd9Sstevel@tonic-gate 		if ((vap->va_mask & AT_MODE) == 0) {
16517c478bd9Sstevel@tonic-gate 			vap->va_mode = 0700;	/* default: owner rwx only */
16527c478bd9Sstevel@tonic-gate 			vap->va_mask |= AT_MODE;
16537c478bd9Sstevel@tonic-gate 		}
16547c478bd9Sstevel@tonic-gate 
16557c478bd9Sstevel@tonic-gate 		/*
16567c478bd9Sstevel@tonic-gate 		 * symlink names must be treated as data
16577c478bd9Sstevel@tonic-gate 		 */
16587c478bd9Sstevel@tonic-gate 		lnm = utf8_to_str(&args->ftype4_u.linkdata, &llen, NULL);
16597c478bd9Sstevel@tonic-gate 
16607c478bd9Sstevel@tonic-gate 		if (lnm == NULL) {
16617c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_INVAL;
16627c478bd9Sstevel@tonic-gate 			kmem_free(nm, len);
16637c478bd9Sstevel@tonic-gate 			nfs4_ntov_table_free(&ntov, &sarg);
16647c478bd9Sstevel@tonic-gate 			resp->attrset = 0;
1665*f3b585ceSsamf 			goto out;
16667c478bd9Sstevel@tonic-gate 		}
16677c478bd9Sstevel@tonic-gate 
16687c478bd9Sstevel@tonic-gate 		if (llen > MAXPATHLEN) {
16697c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
16707c478bd9Sstevel@tonic-gate 			kmem_free(nm, len);
16717c478bd9Sstevel@tonic-gate 			kmem_free(lnm, llen);
16727c478bd9Sstevel@tonic-gate 			nfs4_ntov_table_free(&ntov, &sarg);
16737c478bd9Sstevel@tonic-gate 			resp->attrset = 0;
1674*f3b585ceSsamf 			goto out;
16757c478bd9Sstevel@tonic-gate 		}
16767c478bd9Sstevel@tonic-gate 
1677da6c28aaSamw 		error = VOP_SYMLINK(dvp, nm, vap, lnm, cr, NULL, 0);
16787c478bd9Sstevel@tonic-gate 		if (lnm != NULL)
16797c478bd9Sstevel@tonic-gate 			kmem_free(lnm, llen);
16807c478bd9Sstevel@tonic-gate 		if (error)
16817c478bd9Sstevel@tonic-gate 			break;
16827c478bd9Sstevel@tonic-gate 
16837c478bd9Sstevel@tonic-gate 		/*
16847c478bd9Sstevel@tonic-gate 		 * Get the initial "after" sequence number, if it fails,
16857c478bd9Sstevel@tonic-gate 		 * set to zero
16867c478bd9Sstevel@tonic-gate 		 */
16877c478bd9Sstevel@tonic-gate 		iva.va_mask = AT_SEQ;
1688da6c28aaSamw 		if (VOP_GETATTR(dvp, &iva, 0, cs->cr, NULL))
16897c478bd9Sstevel@tonic-gate 			iva.va_seq = 0;
16907c478bd9Sstevel@tonic-gate 
1691da6c28aaSamw 		error = VOP_LOOKUP(dvp, nm, &vp, NULL, 0, NULL, cr,
1692da6c28aaSamw 		    NULL, NULL, NULL);
16937c478bd9Sstevel@tonic-gate 		if (error)
16947c478bd9Sstevel@tonic-gate 			break;
16957c478bd9Sstevel@tonic-gate 
16967c478bd9Sstevel@tonic-gate 		/*
16977c478bd9Sstevel@tonic-gate 		 * va_seq is not safe over VOP calls, check it again
16987c478bd9Sstevel@tonic-gate 		 * if it has changed zero out iva to force atomic = FALSE.
16997c478bd9Sstevel@tonic-gate 		 */
17007c478bd9Sstevel@tonic-gate 		iva2.va_mask = AT_SEQ;
1701da6c28aaSamw 		if (VOP_GETATTR(dvp, &iva2, 0, cs->cr, NULL) ||
17021b300de9Sjwahlig 		    iva2.va_seq != iva.va_seq)
17037c478bd9Sstevel@tonic-gate 			iva.va_seq = 0;
17047c478bd9Sstevel@tonic-gate 		break;
17057c478bd9Sstevel@tonic-gate 	default:
17067c478bd9Sstevel@tonic-gate 		/*
17077c478bd9Sstevel@tonic-gate 		 * probably a special file.
17087c478bd9Sstevel@tonic-gate 		 */
17097c478bd9Sstevel@tonic-gate 		if ((vap->va_mask & AT_MODE) == 0) {
17107c478bd9Sstevel@tonic-gate 			vap->va_mode = 0600;	/* default: owner rw only */
17117c478bd9Sstevel@tonic-gate 			vap->va_mask |= AT_MODE;
17127c478bd9Sstevel@tonic-gate 		}
17137c478bd9Sstevel@tonic-gate 		syncval = FNODSYNC;
17147c478bd9Sstevel@tonic-gate 		/*
17157c478bd9Sstevel@tonic-gate 		 * We know this will only generate one VOP call
17167c478bd9Sstevel@tonic-gate 		 */
17177c478bd9Sstevel@tonic-gate 		vp = do_rfs4_op_mknod(args, resp, req, cs, vap, nm);
17187c478bd9Sstevel@tonic-gate 
17197c478bd9Sstevel@tonic-gate 		if (vp == NULL) {
17207c478bd9Sstevel@tonic-gate 			kmem_free(nm, len);
17217c478bd9Sstevel@tonic-gate 			nfs4_ntov_table_free(&ntov, &sarg);
17227c478bd9Sstevel@tonic-gate 			resp->attrset = 0;
1723*f3b585ceSsamf 			goto out;
17247c478bd9Sstevel@tonic-gate 		}
17257c478bd9Sstevel@tonic-gate 
17267c478bd9Sstevel@tonic-gate 		/*
17277c478bd9Sstevel@tonic-gate 		 * Get the initial "after" sequence number, if it fails,
17287c478bd9Sstevel@tonic-gate 		 * set to zero
17297c478bd9Sstevel@tonic-gate 		 */
17307c478bd9Sstevel@tonic-gate 		iva.va_mask = AT_SEQ;
1731da6c28aaSamw 		if (VOP_GETATTR(dvp, &iva, 0, cs->cr, NULL))
17327c478bd9Sstevel@tonic-gate 			iva.va_seq = 0;
17337c478bd9Sstevel@tonic-gate 
17347c478bd9Sstevel@tonic-gate 		break;
17357c478bd9Sstevel@tonic-gate 	}
17367c478bd9Sstevel@tonic-gate 	kmem_free(nm, len);
17377c478bd9Sstevel@tonic-gate 
17387c478bd9Sstevel@tonic-gate 	if (error) {
17397c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
17407c478bd9Sstevel@tonic-gate 	}
17417c478bd9Sstevel@tonic-gate 
17427c478bd9Sstevel@tonic-gate 	/*
17437c478bd9Sstevel@tonic-gate 	 * Force modified data and metadata out to stable storage.
17447c478bd9Sstevel@tonic-gate 	 */
1745da6c28aaSamw 	(void) VOP_FSYNC(dvp, 0, cr, NULL);
17467c478bd9Sstevel@tonic-gate 
17477c478bd9Sstevel@tonic-gate 	if (resp->status != NFS4_OK) {
17487c478bd9Sstevel@tonic-gate 		if (vp != NULL)
17497c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
17507c478bd9Sstevel@tonic-gate 		nfs4_ntov_table_free(&ntov, &sarg);
17517c478bd9Sstevel@tonic-gate 		resp->attrset = 0;
1752*f3b585ceSsamf 		goto out;
17537c478bd9Sstevel@tonic-gate 	}
17547c478bd9Sstevel@tonic-gate 
17557c478bd9Sstevel@tonic-gate 	/*
17567c478bd9Sstevel@tonic-gate 	 * Finish setup of cinfo response, "before" value already set.
17577c478bd9Sstevel@tonic-gate 	 * Get "after" change value, if it fails, simply return the
17587c478bd9Sstevel@tonic-gate 	 * before value.
17597c478bd9Sstevel@tonic-gate 	 */
17607c478bd9Sstevel@tonic-gate 	ava.va_mask = AT_CTIME|AT_SEQ;
1761da6c28aaSamw 	if (VOP_GETATTR(dvp, &ava, 0, cr, NULL)) {
17627c478bd9Sstevel@tonic-gate 		ava.va_ctime = bva.va_ctime;
17637c478bd9Sstevel@tonic-gate 		ava.va_seq = 0;
17647c478bd9Sstevel@tonic-gate 	}
17657c478bd9Sstevel@tonic-gate 	NFS4_SET_FATTR4_CHANGE(resp->cinfo.after, ava.va_ctime);
17667c478bd9Sstevel@tonic-gate 
17677c478bd9Sstevel@tonic-gate 	/*
17687c478bd9Sstevel@tonic-gate 	 * True verification that object was created with correct
17697c478bd9Sstevel@tonic-gate 	 * attrs is impossible.  The attrs could have been changed
17707c478bd9Sstevel@tonic-gate 	 * immediately after object creation.  If attributes did
17717c478bd9Sstevel@tonic-gate 	 * not verify, the only recourse for the server is to
17727c478bd9Sstevel@tonic-gate 	 * destroy the object.  Maybe if some attrs (like gid)
17737c478bd9Sstevel@tonic-gate 	 * are set incorrectly, the object should be destroyed;
17747c478bd9Sstevel@tonic-gate 	 * however, seems bad as a default policy.  Do we really
17757c478bd9Sstevel@tonic-gate 	 * want to destroy an object over one of the times not
17767c478bd9Sstevel@tonic-gate 	 * verifying correctly?  For these reasons, the server
17777c478bd9Sstevel@tonic-gate 	 * currently sets bits in attrset for createattrs
17787c478bd9Sstevel@tonic-gate 	 * that were set; however, no verification is done.
17797c478bd9Sstevel@tonic-gate 	 *
17807c478bd9Sstevel@tonic-gate 	 * vmask_to_nmask accounts for vattr bits set on create
17817c478bd9Sstevel@tonic-gate 	 *	[do_rfs4_set_attrs() only sets resp bits for
17827c478bd9Sstevel@tonic-gate 	 *	 non-vattr/vfs bits.]
17837c478bd9Sstevel@tonic-gate 	 * Mask off any bits set by default so as not to return
17847c478bd9Sstevel@tonic-gate 	 * more attrset bits than were requested in createattrs
17857c478bd9Sstevel@tonic-gate 	 */
17867c478bd9Sstevel@tonic-gate 	nfs4_vmask_to_nmask(sarg.vap->va_mask, &resp->attrset);
17877c478bd9Sstevel@tonic-gate 	resp->attrset &= args->createattrs.attrmask;
17887c478bd9Sstevel@tonic-gate 	nfs4_ntov_table_free(&ntov, &sarg);
17897c478bd9Sstevel@tonic-gate 
17907c478bd9Sstevel@tonic-gate 	error = makefh4(&cs->fh, vp, cs->exi);
17917c478bd9Sstevel@tonic-gate 	if (error) {
17927c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
17937c478bd9Sstevel@tonic-gate 	}
17947c478bd9Sstevel@tonic-gate 
17957c478bd9Sstevel@tonic-gate 	/*
17967c478bd9Sstevel@tonic-gate 	 * The cinfo.atomic = TRUE only if we got no errors, we have
17977c478bd9Sstevel@tonic-gate 	 * non-zero va_seq's, and it has incremented by exactly one
17987c478bd9Sstevel@tonic-gate 	 * during the creation and it didn't change during the VOP_LOOKUP
17997c478bd9Sstevel@tonic-gate 	 * or VOP_FSYNC.
18007c478bd9Sstevel@tonic-gate 	 */
18017c478bd9Sstevel@tonic-gate 	if (!error && bva.va_seq && iva.va_seq && ava.va_seq &&
18021b300de9Sjwahlig 	    iva.va_seq == (bva.va_seq + 1) && iva.va_seq == ava.va_seq)
18037c478bd9Sstevel@tonic-gate 		resp->cinfo.atomic = TRUE;
18047c478bd9Sstevel@tonic-gate 	else
18057c478bd9Sstevel@tonic-gate 		resp->cinfo.atomic = FALSE;
18067c478bd9Sstevel@tonic-gate 
1807da6c28aaSamw 	(void) VOP_FSYNC(vp, syncval, cr, NULL);
18087c478bd9Sstevel@tonic-gate 
18097c478bd9Sstevel@tonic-gate 	if (resp->status != NFS4_OK) {
18107c478bd9Sstevel@tonic-gate 		VN_RELE(vp);
1811*f3b585ceSsamf 		goto out;
18127c478bd9Sstevel@tonic-gate 	}
18137c478bd9Sstevel@tonic-gate 	if (cs->vp)
18147c478bd9Sstevel@tonic-gate 		VN_RELE(cs->vp);
18157c478bd9Sstevel@tonic-gate 
18167c478bd9Sstevel@tonic-gate 	cs->vp = vp;
18177c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
1818*f3b585ceSsamf out:
1819*f3b585ceSsamf 	DTRACE_NFSV4_2(op__create__done, struct compound_state *, cs,
1820*f3b585ceSsamf 	    CREATE4res *, resp);
18217c478bd9Sstevel@tonic-gate }
18227c478bd9Sstevel@tonic-gate 
1823*f3b585ceSsamf /*ARGSUSED*/
1824*f3b585ceSsamf static void
1825*f3b585ceSsamf rfs4_op_delegpurge(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
1826*f3b585ceSsamf     struct compound_state *cs)
1827*f3b585ceSsamf {
1828*f3b585ceSsamf 	DTRACE_NFSV4_2(op__delegpurge__start, struct compound_state *, cs,
1829*f3b585ceSsamf 	    DELEGPURGE4args *, &argop->nfs_argop4_u.opdelegpurge);
1830*f3b585ceSsamf 
1831*f3b585ceSsamf 	rfs4_op_inval(argop, resop, req, cs);
1832*f3b585ceSsamf 
1833*f3b585ceSsamf 	DTRACE_NFSV4_2(op__delegpurge__done, struct compound_state *, cs,
1834*f3b585ceSsamf 	    DELEGPURGE4res *, &resop->nfs_resop4_u.opdelegpurge);
1835*f3b585ceSsamf }
18367c478bd9Sstevel@tonic-gate 
18377c478bd9Sstevel@tonic-gate /*ARGSUSED*/
18387c478bd9Sstevel@tonic-gate static void
18397c478bd9Sstevel@tonic-gate rfs4_op_delegreturn(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
18407c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
18417c478bd9Sstevel@tonic-gate {
18427c478bd9Sstevel@tonic-gate 	DELEGRETURN4args *args = &argop->nfs_argop4_u.opdelegreturn;
18437c478bd9Sstevel@tonic-gate 	DELEGRETURN4res *resp = &resop->nfs_resop4_u.opdelegreturn;
18447c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_t *dsp;
18457c478bd9Sstevel@tonic-gate 	nfsstat4 status;
18467c478bd9Sstevel@tonic-gate 
1847*f3b585ceSsamf 	DTRACE_NFSV4_2(op__delegreturn__start, struct compound_state *, cs,
1848*f3b585ceSsamf 	    DELEGRETURN4args *, args);
1849*f3b585ceSsamf 
18507c478bd9Sstevel@tonic-gate 	status = rfs4_get_deleg_state(&args->deleg_stateid, &dsp);
18517c478bd9Sstevel@tonic-gate 	resp->status = *cs->statusp = status;
18527c478bd9Sstevel@tonic-gate 	if (status != NFS4_OK)
1853*f3b585ceSsamf 		goto out;
18547c478bd9Sstevel@tonic-gate 
18557c478bd9Sstevel@tonic-gate 	/* Ensure specified filehandle matches */
18567c478bd9Sstevel@tonic-gate 	if (cs->vp != dsp->finfo->vp) {
18577c478bd9Sstevel@tonic-gate 		resp->status = *cs->statusp = NFS4ERR_BAD_STATEID;
18587c478bd9Sstevel@tonic-gate 	} else
18597c478bd9Sstevel@tonic-gate 		rfs4_return_deleg(dsp, FALSE);
18607c478bd9Sstevel@tonic-gate 
18617c478bd9Sstevel@tonic-gate 	rfs4_update_lease(dsp->client);
18627c478bd9Sstevel@tonic-gate 
18637c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_rele(dsp);
1864*f3b585ceSsamf out:
1865*f3b585ceSsamf 	DTRACE_NFSV4_2(op__delegreturn__done, struct compound_state *, cs,
1866*f3b585ceSsamf 	    DELEGRETURN4res *, resp);
18677c478bd9Sstevel@tonic-gate }
18687c478bd9Sstevel@tonic-gate 
18697c478bd9Sstevel@tonic-gate /*
18707c478bd9Sstevel@tonic-gate  * Check to see if a given "flavor" is an explicitly shared flavor.
18717c478bd9Sstevel@tonic-gate  * The assumption of this routine is the "flavor" is already a valid
18727c478bd9Sstevel@tonic-gate  * flavor in the secinfo list of "exi".
18737c478bd9Sstevel@tonic-gate  *
18747c478bd9Sstevel@tonic-gate  *	e.g.
18757c478bd9Sstevel@tonic-gate  *		# share -o sec=flavor1 /export
18767c478bd9Sstevel@tonic-gate  *		# share -o sec=flavor2 /export/home
18777c478bd9Sstevel@tonic-gate  *
18787c478bd9Sstevel@tonic-gate  *		flavor2 is not an explicitly shared flavor for /export,
18797c478bd9Sstevel@tonic-gate  *		however it is in the secinfo list for /export thru the
18807c478bd9Sstevel@tonic-gate  *		server namespace setup.
18817c478bd9Sstevel@tonic-gate  */
18827c478bd9Sstevel@tonic-gate int
18837c478bd9Sstevel@tonic-gate is_exported_sec(int flavor, struct exportinfo *exi)
18847c478bd9Sstevel@tonic-gate {
18857c478bd9Sstevel@tonic-gate 	int	i;
18867c478bd9Sstevel@tonic-gate 	struct secinfo *sp;
18877c478bd9Sstevel@tonic-gate 
18887c478bd9Sstevel@tonic-gate 	sp = exi->exi_export.ex_secinfo;
18897c478bd9Sstevel@tonic-gate 	for (i = 0; i < exi->exi_export.ex_seccnt; i++) {
18907c478bd9Sstevel@tonic-gate 		if (flavor == sp[i].s_secinfo.sc_nfsnum ||
18917c478bd9Sstevel@tonic-gate 		    sp[i].s_secinfo.sc_nfsnum == AUTH_NONE) {
18927c478bd9Sstevel@tonic-gate 			return (SEC_REF_EXPORTED(&sp[i]));
18937c478bd9Sstevel@tonic-gate 		}
18947c478bd9Sstevel@tonic-gate 	}
18957c478bd9Sstevel@tonic-gate 
18967c478bd9Sstevel@tonic-gate 	/* Should not reach this point based on the assumption */
18977c478bd9Sstevel@tonic-gate 	return (0);
18987c478bd9Sstevel@tonic-gate }
18997c478bd9Sstevel@tonic-gate 
19007c478bd9Sstevel@tonic-gate /*
19017c478bd9Sstevel@tonic-gate  * Check if the security flavor used in the request matches what is
19027c478bd9Sstevel@tonic-gate  * required at the export point or at the root pseudo node (exi_root).
19037c478bd9Sstevel@tonic-gate  *
19047c478bd9Sstevel@tonic-gate  * returns 1 if there's a match or if exported with AUTH_NONE; 0 otherwise.
19057c478bd9Sstevel@tonic-gate  *
19067c478bd9Sstevel@tonic-gate  */
19077c478bd9Sstevel@tonic-gate static int
19087c478bd9Sstevel@tonic-gate secinfo_match_or_authnone(struct compound_state *cs)
19097c478bd9Sstevel@tonic-gate {
19107c478bd9Sstevel@tonic-gate 	int	i;
19117c478bd9Sstevel@tonic-gate 	struct secinfo *sp;
19127c478bd9Sstevel@tonic-gate 
19137c478bd9Sstevel@tonic-gate 	/*
19147c478bd9Sstevel@tonic-gate 	 * Check cs->nfsflavor (from the request) against
19157c478bd9Sstevel@tonic-gate 	 * the current export data in cs->exi.
19167c478bd9Sstevel@tonic-gate 	 */
19177c478bd9Sstevel@tonic-gate 	sp = cs->exi->exi_export.ex_secinfo;
19187c478bd9Sstevel@tonic-gate 	for (i = 0; i < cs->exi->exi_export.ex_seccnt; i++) {
19197c478bd9Sstevel@tonic-gate 		if (cs->nfsflavor == sp[i].s_secinfo.sc_nfsnum ||
19207c478bd9Sstevel@tonic-gate 		    sp[i].s_secinfo.sc_nfsnum == AUTH_NONE)
19217c478bd9Sstevel@tonic-gate 			return (1);
19227c478bd9Sstevel@tonic-gate 	}
19237c478bd9Sstevel@tonic-gate 
19247c478bd9Sstevel@tonic-gate 	return (0);
19257c478bd9Sstevel@tonic-gate }
19267c478bd9Sstevel@tonic-gate 
19277c478bd9Sstevel@tonic-gate /*
19287c478bd9Sstevel@tonic-gate  * Check the access authority for the client and return the correct error.
19297c478bd9Sstevel@tonic-gate  */
19307c478bd9Sstevel@tonic-gate nfsstat4
19317c478bd9Sstevel@tonic-gate call_checkauth4(struct compound_state *cs, struct svc_req *req)
19327c478bd9Sstevel@tonic-gate {
19337c478bd9Sstevel@tonic-gate 	int	authres;
19347c478bd9Sstevel@tonic-gate 
19357c478bd9Sstevel@tonic-gate 	/*
19367c478bd9Sstevel@tonic-gate 	 * First, check if the security flavor used in the request
19377c478bd9Sstevel@tonic-gate 	 * are among the flavors set in the server namespace.
19387c478bd9Sstevel@tonic-gate 	 */
19397c478bd9Sstevel@tonic-gate 	if (!secinfo_match_or_authnone(cs)) {
19407c478bd9Sstevel@tonic-gate 		*cs->statusp = NFS4ERR_WRONGSEC;
19417c478bd9Sstevel@tonic-gate 		return (*cs->statusp);
19427c478bd9Sstevel@tonic-gate 	}
19437c478bd9Sstevel@tonic-gate 
19447c478bd9Sstevel@tonic-gate 	authres = checkauth4(cs, req);
19457c478bd9Sstevel@tonic-gate 
19467c478bd9Sstevel@tonic-gate 	if (authres > 0) {
19477c478bd9Sstevel@tonic-gate 		*cs->statusp = NFS4_OK;
19487c478bd9Sstevel@tonic-gate 		if (! (cs->access & CS_ACCESS_LIMITED))
19497c478bd9Sstevel@tonic-gate 			cs->access = CS_ACCESS_OK;
19507c478bd9Sstevel@tonic-gate 	} else if (authres == 0) {
19517c478bd9Sstevel@tonic-gate 		*cs->statusp = NFS4ERR_ACCESS;
19527c478bd9Sstevel@tonic-gate 	} else if (authres == -2) {
19537c478bd9Sstevel@tonic-gate 		*cs->statusp = NFS4ERR_WRONGSEC;
19547c478bd9Sstevel@tonic-gate 	} else {
19557c478bd9Sstevel@tonic-gate 		*cs->statusp = NFS4ERR_DELAY;
19567c478bd9Sstevel@tonic-gate 	}
19577c478bd9Sstevel@tonic-gate 	return (*cs->statusp);
19587c478bd9Sstevel@tonic-gate }
19597c478bd9Sstevel@tonic-gate 
19607c478bd9Sstevel@tonic-gate /*
19617c478bd9Sstevel@tonic-gate  * bitmap4_to_attrmask is called by getattr and readdir.
19627c478bd9Sstevel@tonic-gate  * It sets up the vattr mask and determines whether vfsstat call is needed
19637c478bd9Sstevel@tonic-gate  * based on the input bitmap.
19647c478bd9Sstevel@tonic-gate  * Returns nfsv4 status.
19657c478bd9Sstevel@tonic-gate  */
19667c478bd9Sstevel@tonic-gate static nfsstat4
19677c478bd9Sstevel@tonic-gate bitmap4_to_attrmask(bitmap4 breq, struct nfs4_svgetit_arg *sargp)
19687c478bd9Sstevel@tonic-gate {
19697c478bd9Sstevel@tonic-gate 	int i;
19707c478bd9Sstevel@tonic-gate 	uint_t	va_mask;
19717c478bd9Sstevel@tonic-gate 	struct statvfs64 *sbp = sargp->sbp;
19727c478bd9Sstevel@tonic-gate 
19737c478bd9Sstevel@tonic-gate 	sargp->sbp = NULL;
19747c478bd9Sstevel@tonic-gate 	sargp->flag = 0;
19757c478bd9Sstevel@tonic-gate 	sargp->rdattr_error = NFS4_OK;
19767c478bd9Sstevel@tonic-gate 	sargp->mntdfid_set = FALSE;
19777c478bd9Sstevel@tonic-gate 	if (sargp->cs->vp)
19787c478bd9Sstevel@tonic-gate 		sargp->xattr = get_fh4_flag(&sargp->cs->fh,
19791b300de9Sjwahlig 		    FH4_ATTRDIR | FH4_NAMEDATTR);
19807c478bd9Sstevel@tonic-gate 	else
19817c478bd9Sstevel@tonic-gate 		sargp->xattr = 0;
19827c478bd9Sstevel@tonic-gate 
19837c478bd9Sstevel@tonic-gate 	/*
19847c478bd9Sstevel@tonic-gate 	 * Set rdattr_error_req to true if return error per
19857c478bd9Sstevel@tonic-gate 	 * failed entry rather than fail the readdir.
19867c478bd9Sstevel@tonic-gate 	 */
19877c478bd9Sstevel@tonic-gate 	if (breq & FATTR4_RDATTR_ERROR_MASK)
19887c478bd9Sstevel@tonic-gate 		sargp->rdattr_error_req = 1;
19897c478bd9Sstevel@tonic-gate 	else
19907c478bd9Sstevel@tonic-gate 		sargp->rdattr_error_req = 0;
19917c478bd9Sstevel@tonic-gate 
19927c478bd9Sstevel@tonic-gate 	/*
19937c478bd9Sstevel@tonic-gate 	 * generate the va_mask
19947c478bd9Sstevel@tonic-gate 	 * Handle the easy cases first
19957c478bd9Sstevel@tonic-gate 	 */
19967c478bd9Sstevel@tonic-gate 	switch (breq) {
19977c478bd9Sstevel@tonic-gate 	case NFS4_NTOV_ATTR_MASK:
19987c478bd9Sstevel@tonic-gate 		sargp->vap->va_mask = NFS4_NTOV_ATTR_AT_MASK;
19997c478bd9Sstevel@tonic-gate 		return (NFS4_OK);
20007c478bd9Sstevel@tonic-gate 
20017c478bd9Sstevel@tonic-gate 	case NFS4_FS_ATTR_MASK:
20027c478bd9Sstevel@tonic-gate 		sargp->vap->va_mask = NFS4_FS_ATTR_AT_MASK;
20037c478bd9Sstevel@tonic-gate 		sargp->sbp = sbp;
20047c478bd9Sstevel@tonic-gate 		return (NFS4_OK);
20057c478bd9Sstevel@tonic-gate 
20067c478bd9Sstevel@tonic-gate 	case NFS4_NTOV_ATTR_CACHE_MASK:
20077c478bd9Sstevel@tonic-gate 		sargp->vap->va_mask = NFS4_NTOV_ATTR_CACHE_AT_MASK;
20087c478bd9Sstevel@tonic-gate 		return (NFS4_OK);
20097c478bd9Sstevel@tonic-gate 
20107c478bd9Sstevel@tonic-gate 	case FATTR4_LEASE_TIME_MASK:
20117c478bd9Sstevel@tonic-gate 		sargp->vap->va_mask = 0;
20127c478bd9Sstevel@tonic-gate 		return (NFS4_OK);
20137c478bd9Sstevel@tonic-gate 
20147c478bd9Sstevel@tonic-gate 	default:
20157c478bd9Sstevel@tonic-gate 		va_mask = 0;
20167c478bd9Sstevel@tonic-gate 		for (i = 0; i < nfs4_ntov_map_size; i++) {
20177c478bd9Sstevel@tonic-gate 			if ((breq & nfs4_ntov_map[i].fbit) &&
20181b300de9Sjwahlig 			    nfs4_ntov_map[i].vbit)
20197c478bd9Sstevel@tonic-gate 				va_mask |= nfs4_ntov_map[i].vbit;
20207c478bd9Sstevel@tonic-gate 		}
20217c478bd9Sstevel@tonic-gate 
20227c478bd9Sstevel@tonic-gate 		/*
20237c478bd9Sstevel@tonic-gate 		 * Check is vfsstat is needed
20247c478bd9Sstevel@tonic-gate 		 */
20257c478bd9Sstevel@tonic-gate 		if (breq & NFS4_FS_ATTR_MASK)
20267c478bd9Sstevel@tonic-gate 			sargp->sbp = sbp;
20277c478bd9Sstevel@tonic-gate 
20287c478bd9Sstevel@tonic-gate 		sargp->vap->va_mask = va_mask;
20297c478bd9Sstevel@tonic-gate 		return (NFS4_OK);
20307c478bd9Sstevel@tonic-gate 	}
20317c478bd9Sstevel@tonic-gate 	/* NOTREACHED */
20327c478bd9Sstevel@tonic-gate }
20337c478bd9Sstevel@tonic-gate 
20347c478bd9Sstevel@tonic-gate /*
20357c478bd9Sstevel@tonic-gate  * bitmap4_get_sysattrs is called by getattr and readdir.
20367c478bd9Sstevel@tonic-gate  * It calls both VOP_GETATTR and VFS_STATVFS calls to get the attrs.
20377c478bd9Sstevel@tonic-gate  * Returns nfsv4 status.
20387c478bd9Sstevel@tonic-gate  */
20397c478bd9Sstevel@tonic-gate static nfsstat4
20407c478bd9Sstevel@tonic-gate bitmap4_get_sysattrs(struct nfs4_svgetit_arg *sargp)
20417c478bd9Sstevel@tonic-gate {
20427c478bd9Sstevel@tonic-gate 	int error;
20437c478bd9Sstevel@tonic-gate 	struct compound_state *cs = sargp->cs;
20447c478bd9Sstevel@tonic-gate 	vnode_t *vp = cs->vp;
20457c478bd9Sstevel@tonic-gate 
20467c478bd9Sstevel@tonic-gate 	if (sargp->sbp != NULL) {
20477c478bd9Sstevel@tonic-gate 		if (error = VFS_STATVFS(vp->v_vfsp, sargp->sbp)) {
20487c478bd9Sstevel@tonic-gate 			sargp->sbp = NULL;	/* to identify error */
20497c478bd9Sstevel@tonic-gate 			return (puterrno4(error));
20507c478bd9Sstevel@tonic-gate 		}
20517c478bd9Sstevel@tonic-gate 	}
20527c478bd9Sstevel@tonic-gate 
20537c478bd9Sstevel@tonic-gate 	return (rfs4_vop_getattr(vp, sargp->vap, 0, cs->cr));
20547c478bd9Sstevel@tonic-gate }
20557c478bd9Sstevel@tonic-gate 
20567c478bd9Sstevel@tonic-gate static void
20577c478bd9Sstevel@tonic-gate nfs4_ntov_table_init(struct nfs4_ntov_table *ntovp)
20587c478bd9Sstevel@tonic-gate {
20597c478bd9Sstevel@tonic-gate 	ntovp->na = kmem_zalloc(sizeof (union nfs4_attr_u) * nfs4_ntov_map_size,
20601b300de9Sjwahlig 	    KM_SLEEP);
20617c478bd9Sstevel@tonic-gate 	ntovp->attrcnt = 0;
20627c478bd9Sstevel@tonic-gate 	ntovp->vfsstat = FALSE;
20637c478bd9Sstevel@tonic-gate }
20647c478bd9Sstevel@tonic-gate 
20657c478bd9Sstevel@tonic-gate static void
20667c478bd9Sstevel@tonic-gate nfs4_ntov_table_free(struct nfs4_ntov_table *ntovp,
20677c478bd9Sstevel@tonic-gate 	struct nfs4_svgetit_arg *sargp)
20687c478bd9Sstevel@tonic-gate {
20697c478bd9Sstevel@tonic-gate 	int i;
20707c478bd9Sstevel@tonic-gate 	union nfs4_attr_u *na;
20717c478bd9Sstevel@tonic-gate 	uint8_t *amap;
20727c478bd9Sstevel@tonic-gate 
20737c478bd9Sstevel@tonic-gate 	/*
20747c478bd9Sstevel@tonic-gate 	 * XXX Should do the same checks for whether the bit is set
20757c478bd9Sstevel@tonic-gate 	 */
20767c478bd9Sstevel@tonic-gate 	for (i = 0, na = ntovp->na, amap = ntovp->amap;
20771b300de9Sjwahlig 	    i < ntovp->attrcnt; i++, na++, amap++) {
20787c478bd9Sstevel@tonic-gate 		(void) (*nfs4_ntov_map[*amap].sv_getit)(
20791b300de9Sjwahlig 		    NFS4ATTR_FREEIT, sargp, na);
20807c478bd9Sstevel@tonic-gate 	}
20817c478bd9Sstevel@tonic-gate 	if ((sargp->op == NFS4ATTR_SETIT) || (sargp->op == NFS4ATTR_VERIT)) {
20827c478bd9Sstevel@tonic-gate 		/*
20837c478bd9Sstevel@tonic-gate 		 * xdr_free for getattr will be done later
20847c478bd9Sstevel@tonic-gate 		 */
20857c478bd9Sstevel@tonic-gate 		for (i = 0, na = ntovp->na, amap = ntovp->amap;
20861b300de9Sjwahlig 		    i < ntovp->attrcnt; i++, na++, amap++) {
20877c478bd9Sstevel@tonic-gate 			xdr_free(nfs4_ntov_map[*amap].xfunc, (caddr_t)na);
20887c478bd9Sstevel@tonic-gate 		}
20897c478bd9Sstevel@tonic-gate 	}
20907c478bd9Sstevel@tonic-gate 	kmem_free(ntovp->na, sizeof (union nfs4_attr_u) * nfs4_ntov_map_size);
20917c478bd9Sstevel@tonic-gate }
20927c478bd9Sstevel@tonic-gate 
20937c478bd9Sstevel@tonic-gate /*
20947c478bd9Sstevel@tonic-gate  * do_rfs4_op_getattr gets the system attrs and converts into fattr4.
20957c478bd9Sstevel@tonic-gate  */
20967c478bd9Sstevel@tonic-gate static nfsstat4
20977c478bd9Sstevel@tonic-gate do_rfs4_op_getattr(bitmap4 breq, fattr4 *fattrp,
20987c478bd9Sstevel@tonic-gate 	struct nfs4_svgetit_arg *sargp)
20997c478bd9Sstevel@tonic-gate {
21007c478bd9Sstevel@tonic-gate 	int error = 0;
21017c478bd9Sstevel@tonic-gate 	int i, k;
21027c478bd9Sstevel@tonic-gate 	struct nfs4_ntov_table ntov;
21037c478bd9Sstevel@tonic-gate 	XDR xdr;
21047c478bd9Sstevel@tonic-gate 	ulong_t xdr_size;
21057c478bd9Sstevel@tonic-gate 	char *xdr_attrs;
21067c478bd9Sstevel@tonic-gate 	nfsstat4 status = NFS4_OK;
21077c478bd9Sstevel@tonic-gate 	nfsstat4 prev_rdattr_error = sargp->rdattr_error;
21087c478bd9Sstevel@tonic-gate 	union nfs4_attr_u *na;
21097c478bd9Sstevel@tonic-gate 	uint8_t *amap;
21107c478bd9Sstevel@tonic-gate 
21117c478bd9Sstevel@tonic-gate 	sargp->op = NFS4ATTR_GETIT;
21127c478bd9Sstevel@tonic-gate 	sargp->flag = 0;
21137c478bd9Sstevel@tonic-gate 
21147c478bd9Sstevel@tonic-gate 	fattrp->attrmask = 0;
21157c478bd9Sstevel@tonic-gate 	/* if no bits requested, then return empty fattr4 */
21167c478bd9Sstevel@tonic-gate 	if (breq == 0) {
21177c478bd9Sstevel@tonic-gate 		fattrp->attrlist4_len = 0;
21187c478bd9Sstevel@tonic-gate 		fattrp->attrlist4 = NULL;
21197c478bd9Sstevel@tonic-gate 		return (NFS4_OK);
21207c478bd9Sstevel@tonic-gate 	}
21217c478bd9Sstevel@tonic-gate 
21227c478bd9Sstevel@tonic-gate 	/*
21237c478bd9Sstevel@tonic-gate 	 * return NFS4ERR_INVAL when client requests write-only attrs
21247c478bd9Sstevel@tonic-gate 	 */
21257c478bd9Sstevel@tonic-gate 	if (breq & (FATTR4_TIME_ACCESS_SET_MASK | FATTR4_TIME_MODIFY_SET_MASK))
21267c478bd9Sstevel@tonic-gate 		return (NFS4ERR_INVAL);
21277c478bd9Sstevel@tonic-gate 
21287c478bd9Sstevel@tonic-gate 	nfs4_ntov_table_init(&ntov);
21297c478bd9Sstevel@tonic-gate 	na = ntov.na;
21307c478bd9Sstevel@tonic-gate 	amap = ntov.amap;
21317c478bd9Sstevel@tonic-gate 
21327c478bd9Sstevel@tonic-gate 	/*
21337c478bd9Sstevel@tonic-gate 	 * Now loop to get or verify the attrs
21347c478bd9Sstevel@tonic-gate 	 */
21357c478bd9Sstevel@tonic-gate 	for (i = 0; i < nfs4_ntov_map_size; i++) {
21367c478bd9Sstevel@tonic-gate 		if (breq & nfs4_ntov_map[i].fbit) {
21377c478bd9Sstevel@tonic-gate 			if ((*nfs4_ntov_map[i].sv_getit)(
21381b300de9Sjwahlig 			    NFS4ATTR_SUPPORTED, sargp, NULL) == 0) {
21397c478bd9Sstevel@tonic-gate 
21407c478bd9Sstevel@tonic-gate 				error = (*nfs4_ntov_map[i].sv_getit)(
21411b300de9Sjwahlig 				    NFS4ATTR_GETIT, sargp, na);
21427c478bd9Sstevel@tonic-gate 
21437c478bd9Sstevel@tonic-gate 				/*
21447c478bd9Sstevel@tonic-gate 				 * Possible error values:
21457c478bd9Sstevel@tonic-gate 				 * >0 if sv_getit failed to
21467c478bd9Sstevel@tonic-gate 				 * get the attr; 0 if succeeded;
21477c478bd9Sstevel@tonic-gate 				 * <0 if rdattr_error and the
21487c478bd9Sstevel@tonic-gate 				 * attribute cannot be returned.
21497c478bd9Sstevel@tonic-gate 				 */
21507c478bd9Sstevel@tonic-gate 				if (error && !(sargp->rdattr_error_req))
21517c478bd9Sstevel@tonic-gate 					goto done;
21527c478bd9Sstevel@tonic-gate 				/*
21537c478bd9Sstevel@tonic-gate 				 * If error then just for entry
21547c478bd9Sstevel@tonic-gate 				 */
21557c478bd9Sstevel@tonic-gate 				if (error == 0) {
21567c478bd9Sstevel@tonic-gate 					fattrp->attrmask |=
21571b300de9Sjwahlig 					    nfs4_ntov_map[i].fbit;
21587c478bd9Sstevel@tonic-gate 					*amap++ =
21591b300de9Sjwahlig 					    (uint8_t)nfs4_ntov_map[i].nval;
21607c478bd9Sstevel@tonic-gate 					na++;
21617c478bd9Sstevel@tonic-gate 					(ntov.attrcnt)++;
21627c478bd9Sstevel@tonic-gate 				} else if ((error > 0) &&
21631b300de9Sjwahlig 				    (sargp->rdattr_error == NFS4_OK)) {
21647c478bd9Sstevel@tonic-gate 					sargp->rdattr_error = puterrno4(error);
21657c478bd9Sstevel@tonic-gate 				}
21667c478bd9Sstevel@tonic-gate 				error = 0;
21677c478bd9Sstevel@tonic-gate 			}
21687c478bd9Sstevel@tonic-gate 		}
21697c478bd9Sstevel@tonic-gate 	}
21707c478bd9Sstevel@tonic-gate 
21717c478bd9Sstevel@tonic-gate 	/*
21727c478bd9Sstevel@tonic-gate 	 * If rdattr_error was set after the return value for it was assigned,
21737c478bd9Sstevel@tonic-gate 	 * update it.
21747c478bd9Sstevel@tonic-gate 	 */
21757c478bd9Sstevel@tonic-gate 	if (prev_rdattr_error != sargp->rdattr_error) {
21767c478bd9Sstevel@tonic-gate 		na = ntov.na;
21777c478bd9Sstevel@tonic-gate 		amap = ntov.amap;
21787c478bd9Sstevel@tonic-gate 		for (i = 0; i < ntov.attrcnt; i++, na++, amap++) {
21797c478bd9Sstevel@tonic-gate 			k = *amap;
21807c478bd9Sstevel@tonic-gate 			if (k < FATTR4_RDATTR_ERROR) {
21817c478bd9Sstevel@tonic-gate 				continue;
21827c478bd9Sstevel@tonic-gate 			}
21837c478bd9Sstevel@tonic-gate 			if ((k == FATTR4_RDATTR_ERROR) &&
21847c478bd9Sstevel@tonic-gate 			    ((*nfs4_ntov_map[k].sv_getit)(
21851b300de9Sjwahlig 			    NFS4ATTR_SUPPORTED, sargp, NULL) == 0)) {
21867c478bd9Sstevel@tonic-gate 
21877c478bd9Sstevel@tonic-gate 				(void) (*nfs4_ntov_map[k].sv_getit)(
21881b300de9Sjwahlig 				    NFS4ATTR_GETIT, sargp, na);
21897c478bd9Sstevel@tonic-gate 			}
21907c478bd9Sstevel@tonic-gate 			break;
21917c478bd9Sstevel@tonic-gate 		}
21927c478bd9Sstevel@tonic-gate 	}
21937c478bd9Sstevel@tonic-gate 
21947c478bd9Sstevel@tonic-gate 	xdr_size = 0;
21957c478bd9Sstevel@tonic-gate 	na = ntov.na;
21967c478bd9Sstevel@tonic-gate 	amap = ntov.amap;
21977c478bd9Sstevel@tonic-gate 	for (i = 0; i < ntov.attrcnt; i++, na++, amap++) {
21987c478bd9Sstevel@tonic-gate 		xdr_size += xdr_sizeof(nfs4_ntov_map[*amap].xfunc, na);
21997c478bd9Sstevel@tonic-gate 	}
22007c478bd9Sstevel@tonic-gate 
22017c478bd9Sstevel@tonic-gate 	fattrp->attrlist4_len = xdr_size;
22027c478bd9Sstevel@tonic-gate 	if (xdr_size) {
22037c478bd9Sstevel@tonic-gate 		/* freed by rfs4_op_getattr_free() */
22047c478bd9Sstevel@tonic-gate 		fattrp->attrlist4 = xdr_attrs = kmem_zalloc(xdr_size, KM_SLEEP);
22057c478bd9Sstevel@tonic-gate 
22067c478bd9Sstevel@tonic-gate 		xdrmem_create(&xdr, xdr_attrs, xdr_size, XDR_ENCODE);
22077c478bd9Sstevel@tonic-gate 
22087c478bd9Sstevel@tonic-gate 		na = ntov.na;
22097c478bd9Sstevel@tonic-gate 		amap = ntov.amap;
22107c478bd9Sstevel@tonic-gate 		for (i = 0; i < ntov.attrcnt; i++, na++, amap++) {
22117c478bd9Sstevel@tonic-gate 			if (!(*nfs4_ntov_map[*amap].xfunc)(&xdr, na)) {
22127c478bd9Sstevel@tonic-gate 				cmn_err(CE_WARN, "do_rfs4_op_getattr: xdr "
22131b300de9Sjwahlig 				    "encode of attribute %d failed\n", *amap);
22147c478bd9Sstevel@tonic-gate 				status = NFS4ERR_SERVERFAULT;
22157c478bd9Sstevel@tonic-gate 				break;
22167c478bd9Sstevel@tonic-gate 			}
22177c478bd9Sstevel@tonic-gate 		}
22187c478bd9Sstevel@tonic-gate 		/* xdrmem_destroy(&xdrs); */	/* NO-OP */
22197c478bd9Sstevel@tonic-gate 	} else {
22207c478bd9Sstevel@tonic-gate 		fattrp->attrlist4 = NULL;
22217c478bd9Sstevel@tonic-gate 	}
22227c478bd9Sstevel@tonic-gate done:
22237c478bd9Sstevel@tonic-gate 
22247c478bd9Sstevel@tonic-gate 	nfs4_ntov_table_free(&ntov, sargp);
22257c478bd9Sstevel@tonic-gate 
22267c478bd9Sstevel@tonic-gate 	if (error != 0)
22277c478bd9Sstevel@tonic-gate 		status = puterrno4(error);
22287c478bd9Sstevel@tonic-gate 
22297c478bd9Sstevel@tonic-gate 	return (status);
22307c478bd9Sstevel@tonic-gate }
22317c478bd9Sstevel@tonic-gate 
22327c478bd9Sstevel@tonic-gate /* ARGSUSED */
22337c478bd9Sstevel@tonic-gate static void
22347c478bd9Sstevel@tonic-gate rfs4_op_getattr(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
22357c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
22367c478bd9Sstevel@tonic-gate {
22377c478bd9Sstevel@tonic-gate 	GETATTR4args *args = &argop->nfs_argop4_u.opgetattr;
22387c478bd9Sstevel@tonic-gate 	GETATTR4res *resp = &resop->nfs_resop4_u.opgetattr;
22397c478bd9Sstevel@tonic-gate 	struct nfs4_svgetit_arg sarg;
22407c478bd9Sstevel@tonic-gate 	struct statvfs64 sb;
22417c478bd9Sstevel@tonic-gate 	nfsstat4 status;
22427c478bd9Sstevel@tonic-gate 
2243*f3b585ceSsamf 	DTRACE_NFSV4_2(op__getattr__start, struct compound_state *, cs,
2244*f3b585ceSsamf 	    GETATTR4args *, args);
2245*f3b585ceSsamf 
22467c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
22477c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2248*f3b585ceSsamf 		goto out;
22497c478bd9Sstevel@tonic-gate 	}
22507c478bd9Sstevel@tonic-gate 
22517c478bd9Sstevel@tonic-gate 	if (cs->access == CS_ACCESS_DENIED) {
22527c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
2253*f3b585ceSsamf 		goto out;
22547c478bd9Sstevel@tonic-gate 	}
22557c478bd9Sstevel@tonic-gate 
22567c478bd9Sstevel@tonic-gate 	sarg.sbp = &sb;
22577c478bd9Sstevel@tonic-gate 	sarg.cs = cs;
22587c478bd9Sstevel@tonic-gate 
22597c478bd9Sstevel@tonic-gate 	status = bitmap4_to_attrmask(args->attr_request, &sarg);
22607c478bd9Sstevel@tonic-gate 	if (status == NFS4_OK) {
22617c478bd9Sstevel@tonic-gate 		status = bitmap4_get_sysattrs(&sarg);
22627c478bd9Sstevel@tonic-gate 		if (status == NFS4_OK)
22637c478bd9Sstevel@tonic-gate 			status = do_rfs4_op_getattr(args->attr_request,
22641b300de9Sjwahlig 			    &resp->obj_attributes, &sarg);
22657c478bd9Sstevel@tonic-gate 	}
22667c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = status;
2267*f3b585ceSsamf out:
2268*f3b585ceSsamf 	DTRACE_NFSV4_2(op__getattr__done, struct compound_state *, cs,
2269*f3b585ceSsamf 	    GETATTR4res *, resp);
22707c478bd9Sstevel@tonic-gate }
22717c478bd9Sstevel@tonic-gate 
22727c478bd9Sstevel@tonic-gate static void
22737c478bd9Sstevel@tonic-gate rfs4_op_getattr_free(nfs_resop4 *resop)
22747c478bd9Sstevel@tonic-gate {
22757c478bd9Sstevel@tonic-gate 	GETATTR4res *resp = &resop->nfs_resop4_u.opgetattr;
22767c478bd9Sstevel@tonic-gate 
22777c478bd9Sstevel@tonic-gate 	nfs4_fattr4_free(&resp->obj_attributes);
22787c478bd9Sstevel@tonic-gate }
22797c478bd9Sstevel@tonic-gate 
22807c478bd9Sstevel@tonic-gate /* ARGSUSED */
22817c478bd9Sstevel@tonic-gate static void
22827c478bd9Sstevel@tonic-gate rfs4_op_getfh(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
22837c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
22847c478bd9Sstevel@tonic-gate {
22857c478bd9Sstevel@tonic-gate 	GETFH4res *resp = &resop->nfs_resop4_u.opgetfh;
22867c478bd9Sstevel@tonic-gate 
2287*f3b585ceSsamf 	DTRACE_NFSV4_1(op__getfh__start, struct compound_state *, cs);
2288*f3b585ceSsamf 
22897c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
22907c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2291*f3b585ceSsamf 		goto out;
22927c478bd9Sstevel@tonic-gate 	}
22937c478bd9Sstevel@tonic-gate 	if (cs->access == CS_ACCESS_DENIED) {
22947c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
2295*f3b585ceSsamf 		goto out;
22967c478bd9Sstevel@tonic-gate 	}
22977c478bd9Sstevel@tonic-gate 
22987c478bd9Sstevel@tonic-gate 	resp->object.nfs_fh4_val =
22991b300de9Sjwahlig 	    kmem_alloc(cs->fh.nfs_fh4_len, KM_SLEEP);
23007c478bd9Sstevel@tonic-gate 	nfs_fh4_copy(&cs->fh, &resp->object);
23017c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
2302*f3b585ceSsamf out:
2303*f3b585ceSsamf 	DTRACE_NFSV4_2(op__getfh__done, struct compound_state *, cs,
2304*f3b585ceSsamf 	    GETFH4res *, resp);
23057c478bd9Sstevel@tonic-gate }
23067c478bd9Sstevel@tonic-gate 
23077c478bd9Sstevel@tonic-gate static void
23087c478bd9Sstevel@tonic-gate rfs4_op_getfh_free(nfs_resop4 *resop)
23097c478bd9Sstevel@tonic-gate {
23107c478bd9Sstevel@tonic-gate 	GETFH4res *resp = &resop->nfs_resop4_u.opgetfh;
23117c478bd9Sstevel@tonic-gate 
23127c478bd9Sstevel@tonic-gate 	if (resp->status == NFS4_OK &&
23137c478bd9Sstevel@tonic-gate 	    resp->object.nfs_fh4_val != NULL) {
23147c478bd9Sstevel@tonic-gate 		kmem_free(resp->object.nfs_fh4_val, resp->object.nfs_fh4_len);
23157c478bd9Sstevel@tonic-gate 		resp->object.nfs_fh4_val = NULL;
23167c478bd9Sstevel@tonic-gate 		resp->object.nfs_fh4_len = 0;
23177c478bd9Sstevel@tonic-gate 	}
23187c478bd9Sstevel@tonic-gate }
23197c478bd9Sstevel@tonic-gate 
23207c478bd9Sstevel@tonic-gate /*
23217c478bd9Sstevel@tonic-gate  * illegal: args: void
23227c478bd9Sstevel@tonic-gate  *	    res : status (NFS4ERR_OP_ILLEGAL)
23237c478bd9Sstevel@tonic-gate  */
23247c478bd9Sstevel@tonic-gate /* ARGSUSED */
23257c478bd9Sstevel@tonic-gate static void
23267c478bd9Sstevel@tonic-gate rfs4_op_illegal(nfs_argop4 *argop, nfs_resop4 *resop,
23277c478bd9Sstevel@tonic-gate 	struct svc_req *req, struct compound_state *cs)
23287c478bd9Sstevel@tonic-gate {
23297c478bd9Sstevel@tonic-gate 	ILLEGAL4res *resp = &resop->nfs_resop4_u.opillegal;
23307c478bd9Sstevel@tonic-gate 
23317c478bd9Sstevel@tonic-gate 	resop->resop = OP_ILLEGAL;
23327c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4ERR_OP_ILLEGAL;
23337c478bd9Sstevel@tonic-gate }
23347c478bd9Sstevel@tonic-gate 
23357c478bd9Sstevel@tonic-gate /*
23367c478bd9Sstevel@tonic-gate  * link: args: SAVED_FH: file, CURRENT_FH: target directory
23377c478bd9Sstevel@tonic-gate  *	 res: status. If success - CURRENT_FH unchanged, return change_info
23387c478bd9Sstevel@tonic-gate  */
23397c478bd9Sstevel@tonic-gate /* ARGSUSED */
23407c478bd9Sstevel@tonic-gate static void
23417c478bd9Sstevel@tonic-gate rfs4_op_link(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
23427c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
23437c478bd9Sstevel@tonic-gate {
23447c478bd9Sstevel@tonic-gate 	LINK4args *args = &argop->nfs_argop4_u.oplink;
23457c478bd9Sstevel@tonic-gate 	LINK4res *resp = &resop->nfs_resop4_u.oplink;
23467c478bd9Sstevel@tonic-gate 	int error;
23477c478bd9Sstevel@tonic-gate 	vnode_t *vp;
23487c478bd9Sstevel@tonic-gate 	vnode_t *dvp;
23497c478bd9Sstevel@tonic-gate 	struct vattr bdva, idva, adva;
23507c478bd9Sstevel@tonic-gate 	char *nm;
23517c478bd9Sstevel@tonic-gate 	uint_t  len;
23527c478bd9Sstevel@tonic-gate 
2353*f3b585ceSsamf 	DTRACE_NFSV4_2(op__link__start, struct compound_state *, cs,
2354*f3b585ceSsamf 	    LINK4args *, args);
2355*f3b585ceSsamf 
23567c478bd9Sstevel@tonic-gate 	/* SAVED_FH: source object */
23577c478bd9Sstevel@tonic-gate 	vp = cs->saved_vp;
23587c478bd9Sstevel@tonic-gate 	if (vp == NULL) {
23597c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2360*f3b585ceSsamf 		goto out;
23617c478bd9Sstevel@tonic-gate 	}
23627c478bd9Sstevel@tonic-gate 
23637c478bd9Sstevel@tonic-gate 	/* CURRENT_FH: target directory */
23647c478bd9Sstevel@tonic-gate 	dvp = cs->vp;
23657c478bd9Sstevel@tonic-gate 	if (dvp == NULL) {
23667c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2367*f3b585ceSsamf 		goto out;
23687c478bd9Sstevel@tonic-gate 	}
23697c478bd9Sstevel@tonic-gate 
23707c478bd9Sstevel@tonic-gate 	/*
23717c478bd9Sstevel@tonic-gate 	 * If there is a non-shared filesystem mounted on this vnode,
23727c478bd9Sstevel@tonic-gate 	 * do not allow to link any file in this directory.
23737c478bd9Sstevel@tonic-gate 	 */
23747c478bd9Sstevel@tonic-gate 	if (vn_ismntpt(dvp)) {
23757c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
2376*f3b585ceSsamf 		goto out;
23777c478bd9Sstevel@tonic-gate 	}
23787c478bd9Sstevel@tonic-gate 
23797c478bd9Sstevel@tonic-gate 	if (cs->access == CS_ACCESS_DENIED) {
23807c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
2381*f3b585ceSsamf 		goto out;
23827c478bd9Sstevel@tonic-gate 	}
23837c478bd9Sstevel@tonic-gate 
23847c478bd9Sstevel@tonic-gate 	/* Check source object's type validity */
23857c478bd9Sstevel@tonic-gate 	if (vp->v_type == VDIR) {
23867c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ISDIR;
2387*f3b585ceSsamf 		goto out;
23887c478bd9Sstevel@tonic-gate 	}
23897c478bd9Sstevel@tonic-gate 
23907c478bd9Sstevel@tonic-gate 	/* Check target directory's type */
23917c478bd9Sstevel@tonic-gate 	if (dvp->v_type != VDIR) {
23927c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
2393*f3b585ceSsamf 		goto out;
23947c478bd9Sstevel@tonic-gate 	}
23957c478bd9Sstevel@tonic-gate 
23967c478bd9Sstevel@tonic-gate 	if (cs->saved_exi != cs->exi) {
23977c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_XDEV;
2398*f3b585ceSsamf 		goto out;
23997c478bd9Sstevel@tonic-gate 	}
24007c478bd9Sstevel@tonic-gate 
24017c478bd9Sstevel@tonic-gate 	if (!utf8_dir_verify(&args->newname)) {
24027c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
2403*f3b585ceSsamf 		goto out;
24047c478bd9Sstevel@tonic-gate 	}
24057c478bd9Sstevel@tonic-gate 
24067c478bd9Sstevel@tonic-gate 	nm = utf8_to_fn(&args->newname, &len, NULL);
24077c478bd9Sstevel@tonic-gate 	if (nm == NULL) {
24087c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
2409*f3b585ceSsamf 		goto out;
24107c478bd9Sstevel@tonic-gate 	}
24117c478bd9Sstevel@tonic-gate 
24127c478bd9Sstevel@tonic-gate 	if (len > MAXNAMELEN) {
24137c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
24147c478bd9Sstevel@tonic-gate 		kmem_free(nm, len);
2415*f3b585ceSsamf 		goto out;
24167c478bd9Sstevel@tonic-gate 	}
24177c478bd9Sstevel@tonic-gate 
24187c478bd9Sstevel@tonic-gate 	if (rdonly4(cs->exi, cs->vp, req)) {
24197c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ROFS;
24207c478bd9Sstevel@tonic-gate 		kmem_free(nm, len);
2421*f3b585ceSsamf 		goto out;
24227c478bd9Sstevel@tonic-gate 	}
24237c478bd9Sstevel@tonic-gate 
24247c478bd9Sstevel@tonic-gate 	/* Get "before" change value */
24257c478bd9Sstevel@tonic-gate 	bdva.va_mask = AT_CTIME|AT_SEQ;
2426da6c28aaSamw 	error = VOP_GETATTR(dvp, &bdva, 0, cs->cr, NULL);
24277c478bd9Sstevel@tonic-gate 	if (error) {
24287c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
24297c478bd9Sstevel@tonic-gate 		kmem_free(nm, len);
2430*f3b585ceSsamf 		goto out;
24317c478bd9Sstevel@tonic-gate 	}
24327c478bd9Sstevel@tonic-gate 
24337c478bd9Sstevel@tonic-gate 	NFS4_SET_FATTR4_CHANGE(resp->cinfo.before, bdva.va_ctime)
24347c478bd9Sstevel@tonic-gate 
2435da6c28aaSamw 	error = VOP_LINK(dvp, vp, nm, cs->cr, NULL, 0);
24367c478bd9Sstevel@tonic-gate 
24377c478bd9Sstevel@tonic-gate 	kmem_free(nm, len);
24387c478bd9Sstevel@tonic-gate 
24397c478bd9Sstevel@tonic-gate 	/*
24407c478bd9Sstevel@tonic-gate 	 * Get the initial "after" sequence number, if it fails, set to zero
24417c478bd9Sstevel@tonic-gate 	 */
24427c478bd9Sstevel@tonic-gate 	idva.va_mask = AT_SEQ;
2443da6c28aaSamw 	if (VOP_GETATTR(dvp, &idva, 0, cs->cr, NULL))
24447c478bd9Sstevel@tonic-gate 		idva.va_seq = 0;
24457c478bd9Sstevel@tonic-gate 
24467c478bd9Sstevel@tonic-gate 	/*
24477c478bd9Sstevel@tonic-gate 	 * Force modified data and metadata out to stable storage.
24487c478bd9Sstevel@tonic-gate 	 */
2449da6c28aaSamw 	(void) VOP_FSYNC(vp, FNODSYNC, cs->cr, NULL);
2450da6c28aaSamw 	(void) VOP_FSYNC(dvp, 0, cs->cr, NULL);
24517c478bd9Sstevel@tonic-gate 
24527c478bd9Sstevel@tonic-gate 	if (error) {
24537c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
2454*f3b585ceSsamf 		goto out;
24557c478bd9Sstevel@tonic-gate 	}
24567c478bd9Sstevel@tonic-gate 
24577c478bd9Sstevel@tonic-gate 	/*
24587c478bd9Sstevel@tonic-gate 	 * Get "after" change value, if it fails, simply return the
24597c478bd9Sstevel@tonic-gate 	 * before value.
24607c478bd9Sstevel@tonic-gate 	 */
24617c478bd9Sstevel@tonic-gate 	adva.va_mask = AT_CTIME|AT_SEQ;
2462da6c28aaSamw 	if (VOP_GETATTR(dvp, &adva, 0, cs->cr, NULL)) {
24637c478bd9Sstevel@tonic-gate 		adva.va_ctime = bdva.va_ctime;
24647c478bd9Sstevel@tonic-gate 		adva.va_seq = 0;
24657c478bd9Sstevel@tonic-gate 	}
24667c478bd9Sstevel@tonic-gate 
24677c478bd9Sstevel@tonic-gate 	NFS4_SET_FATTR4_CHANGE(resp->cinfo.after, adva.va_ctime)
24687c478bd9Sstevel@tonic-gate 
24697c478bd9Sstevel@tonic-gate 	/*
24707c478bd9Sstevel@tonic-gate 	 * The cinfo.atomic = TRUE only if we have
24717c478bd9Sstevel@tonic-gate 	 * non-zero va_seq's, and it has incremented by exactly one
24727c478bd9Sstevel@tonic-gate 	 * during the VOP_LINK and it didn't change during the VOP_FSYNC.
24737c478bd9Sstevel@tonic-gate 	 */
24747c478bd9Sstevel@tonic-gate 	if (bdva.va_seq && idva.va_seq && adva.va_seq &&
24751b300de9Sjwahlig 	    idva.va_seq == (bdva.va_seq + 1) && idva.va_seq == adva.va_seq)
24767c478bd9Sstevel@tonic-gate 		resp->cinfo.atomic = TRUE;
24777c478bd9Sstevel@tonic-gate 	else
24787c478bd9Sstevel@tonic-gate 		resp->cinfo.atomic = FALSE;
24797c478bd9Sstevel@tonic-gate 
24807c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
2481*f3b585ceSsamf out:
2482*f3b585ceSsamf 	DTRACE_NFSV4_2(op__link__done, struct compound_state *, cs,
2483*f3b585ceSsamf 	    LINK4res *, resp);
24847c478bd9Sstevel@tonic-gate }
24857c478bd9Sstevel@tonic-gate 
24867c478bd9Sstevel@tonic-gate /*
24877c478bd9Sstevel@tonic-gate  * Used by rfs4_op_lookup and rfs4_op_lookupp to do the actual work.
24887c478bd9Sstevel@tonic-gate  */
24897c478bd9Sstevel@tonic-gate 
24907c478bd9Sstevel@tonic-gate /* ARGSUSED */
24917c478bd9Sstevel@tonic-gate static nfsstat4
24927c478bd9Sstevel@tonic-gate do_rfs4_op_lookup(char *nm, uint_t buflen, struct svc_req *req,
24937c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
24947c478bd9Sstevel@tonic-gate {
24957c478bd9Sstevel@tonic-gate 	int error;
24967c478bd9Sstevel@tonic-gate 	int different_export = 0;
24977c478bd9Sstevel@tonic-gate 	vnode_t *vp, *tvp, *pre_tvp = NULL, *oldvp = NULL;
24987c478bd9Sstevel@tonic-gate 	struct exportinfo *exi = NULL, *pre_exi = NULL;
24997c478bd9Sstevel@tonic-gate 	nfsstat4 stat;
25007c478bd9Sstevel@tonic-gate 	fid_t fid;
25017c478bd9Sstevel@tonic-gate 	int attrdir, dotdot, walk;
25027c478bd9Sstevel@tonic-gate 	bool_t is_newvp = FALSE;
25037c478bd9Sstevel@tonic-gate 
25047c478bd9Sstevel@tonic-gate 	if (cs->vp->v_flag & V_XATTRDIR) {
25057c478bd9Sstevel@tonic-gate 		attrdir = 1;
25067c478bd9Sstevel@tonic-gate 		ASSERT(get_fh4_flag(&cs->fh, FH4_ATTRDIR));
25077c478bd9Sstevel@tonic-gate 	} else {
25087c478bd9Sstevel@tonic-gate 		attrdir = 0;
25097c478bd9Sstevel@tonic-gate 		ASSERT(! get_fh4_flag(&cs->fh, FH4_ATTRDIR));
25107c478bd9Sstevel@tonic-gate 	}
25117c478bd9Sstevel@tonic-gate 
25127c478bd9Sstevel@tonic-gate 	dotdot = (nm[0] == '.' && nm[1] == '.' && nm[2] == '\0');
25137c478bd9Sstevel@tonic-gate 
25147c478bd9Sstevel@tonic-gate 	/*
25157c478bd9Sstevel@tonic-gate 	 * If dotdotting, then need to check whether it's
25167c478bd9Sstevel@tonic-gate 	 * above the root of a filesystem, or above an
25177c478bd9Sstevel@tonic-gate 	 * export point.
25187c478bd9Sstevel@tonic-gate 	 */
25197c478bd9Sstevel@tonic-gate 	if (dotdot) {
25207c478bd9Sstevel@tonic-gate 
25217c478bd9Sstevel@tonic-gate 		/*
25227c478bd9Sstevel@tonic-gate 		 * If dotdotting at the root of a filesystem, then
25237c478bd9Sstevel@tonic-gate 		 * need to traverse back to the mounted-on filesystem
25247c478bd9Sstevel@tonic-gate 		 * and do the dotdot lookup there.
25257c478bd9Sstevel@tonic-gate 		 */
25267c478bd9Sstevel@tonic-gate 		if (cs->vp->v_flag & VROOT) {
25277c478bd9Sstevel@tonic-gate 
25287c478bd9Sstevel@tonic-gate 			/*
25297c478bd9Sstevel@tonic-gate 			 * If at the system root, then can
25307c478bd9Sstevel@tonic-gate 			 * go up no further.
25317c478bd9Sstevel@tonic-gate 			 */
25327c478bd9Sstevel@tonic-gate 			if (VN_CMP(cs->vp, rootdir))
25337c478bd9Sstevel@tonic-gate 				return (puterrno4(ENOENT));
25347c478bd9Sstevel@tonic-gate 
25357c478bd9Sstevel@tonic-gate 			/*
25367c478bd9Sstevel@tonic-gate 			 * Traverse back to the mounted-on filesystem
25377c478bd9Sstevel@tonic-gate 			 */
25387c478bd9Sstevel@tonic-gate 			cs->vp = untraverse(cs->vp);
25397c478bd9Sstevel@tonic-gate 
25407c478bd9Sstevel@tonic-gate 			/*
25417c478bd9Sstevel@tonic-gate 			 * Set the different_export flag so we remember
25427c478bd9Sstevel@tonic-gate 			 * to pick up a new exportinfo entry for
25437c478bd9Sstevel@tonic-gate 			 * this new filesystem.
25447c478bd9Sstevel@tonic-gate 			 */
25457c478bd9Sstevel@tonic-gate 			different_export = 1;
25467c478bd9Sstevel@tonic-gate 		} else {
25477c478bd9Sstevel@tonic-gate 
25487c478bd9Sstevel@tonic-gate 			/*
25497c478bd9Sstevel@tonic-gate 			 * If dotdotting above an export point then set
25507c478bd9Sstevel@tonic-gate 			 * the different_export to get new export info.
25517c478bd9Sstevel@tonic-gate 			 */
25527c478bd9Sstevel@tonic-gate 			different_export = nfs_exported(cs->exi, cs->vp);
25537c478bd9Sstevel@tonic-gate 		}
25547c478bd9Sstevel@tonic-gate 	}
25557c478bd9Sstevel@tonic-gate 
2556da6c28aaSamw 	error = VOP_LOOKUP(cs->vp, nm, &vp, NULL, 0, NULL, cs->cr,
2557da6c28aaSamw 	    NULL, NULL, NULL);
25587c478bd9Sstevel@tonic-gate 	if (error)
25597c478bd9Sstevel@tonic-gate 		return (puterrno4(error));
25607c478bd9Sstevel@tonic-gate 
25617c478bd9Sstevel@tonic-gate 	/*
25627c478bd9Sstevel@tonic-gate 	 * If the vnode is in a pseudo filesystem, check whether it is visible.
25637c478bd9Sstevel@tonic-gate 	 *
25647c478bd9Sstevel@tonic-gate 	 * XXX if the vnode is a symlink and it is not visible in
25657c478bd9Sstevel@tonic-gate 	 * a pseudo filesystem, return ENOENT (not following symlink).
25667c478bd9Sstevel@tonic-gate 	 * V4 client can not mount such symlink. This is a regression
25677c478bd9Sstevel@tonic-gate 	 * from V2/V3.
25687c478bd9Sstevel@tonic-gate 	 *
25697c478bd9Sstevel@tonic-gate 	 * In the same exported filesystem, if the security flavor used
25707c478bd9Sstevel@tonic-gate 	 * is not an explicitly shared flavor, limit the view to the visible
25717c478bd9Sstevel@tonic-gate 	 * list entries only. This is not a WRONGSEC case because it's already
25727c478bd9Sstevel@tonic-gate 	 * checked via PUTROOTFH/PUTPUBFH or PUTFH.
25737c478bd9Sstevel@tonic-gate 	 */
25747c478bd9Sstevel@tonic-gate 	if (!different_export &&
25757c478bd9Sstevel@tonic-gate 	    (PSEUDO(cs->exi) || ! is_exported_sec(cs->nfsflavor, cs->exi) ||
25767c478bd9Sstevel@tonic-gate 	    cs->access & CS_ACCESS_LIMITED)) {
25777c478bd9Sstevel@tonic-gate 		if (! nfs_visible(cs->exi, vp, &different_export)) {
25787c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
25797c478bd9Sstevel@tonic-gate 			return (puterrno4(ENOENT));
25807c478bd9Sstevel@tonic-gate 		}
25817c478bd9Sstevel@tonic-gate 	}
25827c478bd9Sstevel@tonic-gate 
25837c478bd9Sstevel@tonic-gate 	/*
25847c478bd9Sstevel@tonic-gate 	 * If it's a mountpoint, then traverse it.
25857c478bd9Sstevel@tonic-gate 	 */
25867c478bd9Sstevel@tonic-gate 	if (vn_ismntpt(vp)) {
25877c478bd9Sstevel@tonic-gate 		pre_exi = cs->exi;	/* save pre-traversed exportinfo */
25887c478bd9Sstevel@tonic-gate 		pre_tvp = vp;		/* save pre-traversed vnode	*/
25897c478bd9Sstevel@tonic-gate 
25907c478bd9Sstevel@tonic-gate 		/*
25917c478bd9Sstevel@tonic-gate 		 * hold pre_tvp to counteract rele by traverse.  We will
25927c478bd9Sstevel@tonic-gate 		 * need pre_tvp below if checkexport4 fails
25937c478bd9Sstevel@tonic-gate 		 */
25947c478bd9Sstevel@tonic-gate 		VN_HOLD(pre_tvp);
25957c478bd9Sstevel@tonic-gate 		tvp = vp;
25967c478bd9Sstevel@tonic-gate 		if ((error = traverse(&tvp)) != 0) {
25977c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
25987c478bd9Sstevel@tonic-gate 			VN_RELE(pre_tvp);
25997c478bd9Sstevel@tonic-gate 			return (puterrno4(error));
26007c478bd9Sstevel@tonic-gate 		}
26017c478bd9Sstevel@tonic-gate 		vp = tvp;
26027c478bd9Sstevel@tonic-gate 		different_export = 1;
26037c478bd9Sstevel@tonic-gate 	} else if (vp->v_vfsp != cs->vp->v_vfsp) {
26047c478bd9Sstevel@tonic-gate 		/*
26057c478bd9Sstevel@tonic-gate 		 * The vfsp comparison is to handle the case where
26067c478bd9Sstevel@tonic-gate 		 * a LOFS mount is shared.  lo_lookup traverses mount points,
26077c478bd9Sstevel@tonic-gate 		 * and NFS is unaware of local fs transistions because
26087c478bd9Sstevel@tonic-gate 		 * v_vfsmountedhere isn't set.  For this special LOFS case,
26097c478bd9Sstevel@tonic-gate 		 * the dir and the obj returned by lookup will have different
26107c478bd9Sstevel@tonic-gate 		 * vfs ptrs.
26117c478bd9Sstevel@tonic-gate 		 */
26127c478bd9Sstevel@tonic-gate 		different_export = 1;
26137c478bd9Sstevel@tonic-gate 	}
26147c478bd9Sstevel@tonic-gate 
26157c478bd9Sstevel@tonic-gate 	if (different_export) {
26167c478bd9Sstevel@tonic-gate 
26177c478bd9Sstevel@tonic-gate 		bzero(&fid, sizeof (fid));
26187c478bd9Sstevel@tonic-gate 		fid.fid_len = MAXFIDSZ;
26197c478bd9Sstevel@tonic-gate 		error = vop_fid_pseudo(vp, &fid);
26207c478bd9Sstevel@tonic-gate 		if (error) {
26217c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
26227c478bd9Sstevel@tonic-gate 			if (pre_tvp)
26237c478bd9Sstevel@tonic-gate 				VN_RELE(pre_tvp);
26247c478bd9Sstevel@tonic-gate 			return (puterrno4(error));
26257c478bd9Sstevel@tonic-gate 		}
26267c478bd9Sstevel@tonic-gate 
26277c478bd9Sstevel@tonic-gate 		if (dotdot)
26287c478bd9Sstevel@tonic-gate 			exi = nfs_vptoexi(NULL, vp, cs->cr, &walk, NULL, TRUE);
26297c478bd9Sstevel@tonic-gate 		else
26307c478bd9Sstevel@tonic-gate 			exi = checkexport4(&vp->v_vfsp->vfs_fsid, &fid, vp);
26317c478bd9Sstevel@tonic-gate 
26327c478bd9Sstevel@tonic-gate 		if (exi == NULL) {
26337c478bd9Sstevel@tonic-gate 			if (pre_tvp) {
26347c478bd9Sstevel@tonic-gate 				/*
26357c478bd9Sstevel@tonic-gate 				 * If this vnode is a mounted-on vnode,
26367c478bd9Sstevel@tonic-gate 				 * but the mounted-on file system is not
26377c478bd9Sstevel@tonic-gate 				 * exported, send back the filehandle for
26387c478bd9Sstevel@tonic-gate 				 * the mounted-on vnode, not the root of
26397c478bd9Sstevel@tonic-gate 				 * the mounted-on file system.
26407c478bd9Sstevel@tonic-gate 				 */
26417c478bd9Sstevel@tonic-gate 				VN_RELE(vp);
26427c478bd9Sstevel@tonic-gate 				vp = pre_tvp;
26437c478bd9Sstevel@tonic-gate 				exi = pre_exi;
26447c478bd9Sstevel@tonic-gate 			} else {
26457c478bd9Sstevel@tonic-gate 				VN_RELE(vp);
26467c478bd9Sstevel@tonic-gate 				return (puterrno4(EACCES));
26477c478bd9Sstevel@tonic-gate 			}
26487c478bd9Sstevel@tonic-gate 		} else if (pre_tvp) {
26497c478bd9Sstevel@tonic-gate 			/* we're done with pre_tvp now. release extra hold */
26507c478bd9Sstevel@tonic-gate 			VN_RELE(pre_tvp);
26517c478bd9Sstevel@tonic-gate 		}
26527c478bd9Sstevel@tonic-gate 
26537c478bd9Sstevel@tonic-gate 		cs->exi = exi;
26547c478bd9Sstevel@tonic-gate 
26557c478bd9Sstevel@tonic-gate 		/*
26567c478bd9Sstevel@tonic-gate 		 * Now we do a checkauth4. The reason is that
26577c478bd9Sstevel@tonic-gate 		 * this client/user may not have access to the new
26587c478bd9Sstevel@tonic-gate 		 * exported file system, and if he does,
26597c478bd9Sstevel@tonic-gate 		 * the client/user may be mapped to a different uid.
26607c478bd9Sstevel@tonic-gate 		 *
26617c478bd9Sstevel@tonic-gate 		 * We start with a new cr, because the checkauth4 done
26627c478bd9Sstevel@tonic-gate 		 * in the PUT*FH operation over wrote the cred's uid,
26637c478bd9Sstevel@tonic-gate 		 * gid, etc, and we want the real thing before calling
26647c478bd9Sstevel@tonic-gate 		 * checkauth4()
26657c478bd9Sstevel@tonic-gate 		 */
26667c478bd9Sstevel@tonic-gate 		crfree(cs->cr);
26677c478bd9Sstevel@tonic-gate 		cs->cr = crdup(cs->basecr);
26687c478bd9Sstevel@tonic-gate 
26697c478bd9Sstevel@tonic-gate 		if (cs->vp)
26707c478bd9Sstevel@tonic-gate 			oldvp = cs->vp;
26717c478bd9Sstevel@tonic-gate 		cs->vp = vp;
26727c478bd9Sstevel@tonic-gate 		is_newvp = TRUE;
26737c478bd9Sstevel@tonic-gate 
26747c478bd9Sstevel@tonic-gate 		stat = call_checkauth4(cs, req);
26757c478bd9Sstevel@tonic-gate 		if (stat != NFS4_OK) {
26767c478bd9Sstevel@tonic-gate 			VN_RELE(cs->vp);
26777c478bd9Sstevel@tonic-gate 			cs->vp = oldvp;
26787c478bd9Sstevel@tonic-gate 			return (stat);
26797c478bd9Sstevel@tonic-gate 		}
26807c478bd9Sstevel@tonic-gate 	}
26817c478bd9Sstevel@tonic-gate 
268245916cd2Sjpk 	/*
268345916cd2Sjpk 	 * After various NFS checks, do a label check on the path
268445916cd2Sjpk 	 * component. The label on this path should either be the
268545916cd2Sjpk 	 * global zone's label or a zone's label. We are only
268645916cd2Sjpk 	 * interested in the zone's label because exported files
268745916cd2Sjpk 	 * in global zone is accessible (though read-only) to
268845916cd2Sjpk 	 * clients. The exportability/visibility check is already
268945916cd2Sjpk 	 * done before reaching this code.
269045916cd2Sjpk 	 */
269145916cd2Sjpk 	if (is_system_labeled()) {
269245916cd2Sjpk 		bslabel_t *clabel;
269345916cd2Sjpk 
269445916cd2Sjpk 		ASSERT(req->rq_label != NULL);
269545916cd2Sjpk 		clabel = req->rq_label;
269645916cd2Sjpk 		DTRACE_PROBE2(tx__rfs4__log__info__oplookup__clabel, char *,
269745916cd2Sjpk 		    "got client label from request(1)", struct svc_req *, req);
269845916cd2Sjpk 
269945916cd2Sjpk 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
270003986916Sjarrett 			if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK)) {
270145916cd2Sjpk 				error = EACCES;
270245916cd2Sjpk 				goto err_out;
270345916cd2Sjpk 			}
270445916cd2Sjpk 		} else {
270545916cd2Sjpk 			/*
270645916cd2Sjpk 			 * We grant access to admin_low label clients
270745916cd2Sjpk 			 * only if the client is trusted, i.e. also
270845916cd2Sjpk 			 * running Solaris Trusted Extension.
270945916cd2Sjpk 			 */
271045916cd2Sjpk 			struct sockaddr	*ca;
271145916cd2Sjpk 			int		addr_type;
271245916cd2Sjpk 			void		*ipaddr;
271345916cd2Sjpk 			tsol_tpc_t	*tp;
271445916cd2Sjpk 
271545916cd2Sjpk 			ca = (struct sockaddr *)svc_getrpccaller(
271645916cd2Sjpk 			    req->rq_xprt)->buf;
271745916cd2Sjpk 			if (ca->sa_family == AF_INET) {
271845916cd2Sjpk 				addr_type = IPV4_VERSION;
271945916cd2Sjpk 				ipaddr = &((struct sockaddr_in *)ca)->sin_addr;
272045916cd2Sjpk 			} else if (ca->sa_family == AF_INET6) {
272145916cd2Sjpk 				addr_type = IPV6_VERSION;
272245916cd2Sjpk 				ipaddr = &((struct sockaddr_in6 *)
272345916cd2Sjpk 				    ca)->sin6_addr;
272445916cd2Sjpk 			}
272545916cd2Sjpk 			tp = find_tpc(ipaddr, addr_type, B_FALSE);
272645916cd2Sjpk 			if (tp == NULL || tp->tpc_tp.tp_doi !=
272745916cd2Sjpk 			    l_admin_low->tsl_doi || tp->tpc_tp.host_type !=
272845916cd2Sjpk 			    SUN_CIPSO) {
272903986916Sjarrett 				if (tp != NULL)
273003986916Sjarrett 					TPC_RELE(tp);
273145916cd2Sjpk 				error = EACCES;
273245916cd2Sjpk 				goto err_out;
273345916cd2Sjpk 			}
273403986916Sjarrett 			TPC_RELE(tp);
273545916cd2Sjpk 		}
273645916cd2Sjpk 	}
273745916cd2Sjpk 
27387c478bd9Sstevel@tonic-gate 	error = makefh4(&cs->fh, vp, cs->exi);
27397c478bd9Sstevel@tonic-gate 
274045916cd2Sjpk err_out:
27417c478bd9Sstevel@tonic-gate 	if (error) {
27427c478bd9Sstevel@tonic-gate 		if (is_newvp) {
27437c478bd9Sstevel@tonic-gate 			VN_RELE(cs->vp);
27447c478bd9Sstevel@tonic-gate 			cs->vp = oldvp;
27457c478bd9Sstevel@tonic-gate 		} else
27467c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
27477c478bd9Sstevel@tonic-gate 		return (puterrno4(error));
27487c478bd9Sstevel@tonic-gate 	}
27497c478bd9Sstevel@tonic-gate 
27507c478bd9Sstevel@tonic-gate 	if (!is_newvp) {
27517c478bd9Sstevel@tonic-gate 		if (cs->vp)
27527c478bd9Sstevel@tonic-gate 			VN_RELE(cs->vp);
27537c478bd9Sstevel@tonic-gate 		cs->vp = vp;
27547c478bd9Sstevel@tonic-gate 	} else if (oldvp)
27557c478bd9Sstevel@tonic-gate 		VN_RELE(oldvp);
27567c478bd9Sstevel@tonic-gate 
27577c478bd9Sstevel@tonic-gate 	/*
27587c478bd9Sstevel@tonic-gate 	 * if did lookup on attrdir and didn't lookup .., set named
27597c478bd9Sstevel@tonic-gate 	 * attr fh flag
27607c478bd9Sstevel@tonic-gate 	 */
27617c478bd9Sstevel@tonic-gate 	if (attrdir && ! dotdot)
27627c478bd9Sstevel@tonic-gate 		set_fh4_flag(&cs->fh, FH4_NAMEDATTR);
27637c478bd9Sstevel@tonic-gate 
27647c478bd9Sstevel@tonic-gate 	/* Assume false for now, open proc will set this */
27657c478bd9Sstevel@tonic-gate 	cs->mandlock = FALSE;
27667c478bd9Sstevel@tonic-gate 
27677c478bd9Sstevel@tonic-gate 	return (NFS4_OK);
27687c478bd9Sstevel@tonic-gate }
27697c478bd9Sstevel@tonic-gate 
27707c478bd9Sstevel@tonic-gate /* ARGSUSED */
27717c478bd9Sstevel@tonic-gate static void
27727c478bd9Sstevel@tonic-gate rfs4_op_lookup(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
27737c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
27747c478bd9Sstevel@tonic-gate {
27757c478bd9Sstevel@tonic-gate 	LOOKUP4args *args = &argop->nfs_argop4_u.oplookup;
27767c478bd9Sstevel@tonic-gate 	LOOKUP4res *resp = &resop->nfs_resop4_u.oplookup;
27777c478bd9Sstevel@tonic-gate 	char *nm;
27787c478bd9Sstevel@tonic-gate 	uint_t len;
27797c478bd9Sstevel@tonic-gate 
2780*f3b585ceSsamf 	DTRACE_NFSV4_2(op__lookup__start, struct compound_state *, cs,
2781*f3b585ceSsamf 	    LOOKUP4args *, args);
2782*f3b585ceSsamf 
27837c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
27847c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2785*f3b585ceSsamf 		goto out;
27867c478bd9Sstevel@tonic-gate 	}
27877c478bd9Sstevel@tonic-gate 
27887c478bd9Sstevel@tonic-gate 	if (cs->vp->v_type == VLNK) {
27897c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_SYMLINK;
2790*f3b585ceSsamf 		goto out;
27917c478bd9Sstevel@tonic-gate 	}
27927c478bd9Sstevel@tonic-gate 
27937c478bd9Sstevel@tonic-gate 	if (cs->vp->v_type != VDIR) {
27947c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
2795*f3b585ceSsamf 		goto out;
27967c478bd9Sstevel@tonic-gate 	}
27977c478bd9Sstevel@tonic-gate 
27987c478bd9Sstevel@tonic-gate 	if (!utf8_dir_verify(&args->objname)) {
27997c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
2800*f3b585ceSsamf 		goto out;
28017c478bd9Sstevel@tonic-gate 	}
28027c478bd9Sstevel@tonic-gate 
28037c478bd9Sstevel@tonic-gate 	nm = utf8_to_str(&args->objname, &len, NULL);
28047c478bd9Sstevel@tonic-gate 	if (nm == NULL) {
28057c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
2806*f3b585ceSsamf 		goto out;
28077c478bd9Sstevel@tonic-gate 	}
28087c478bd9Sstevel@tonic-gate 
28097c478bd9Sstevel@tonic-gate 	if (len > MAXNAMELEN) {
28107c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
28117c478bd9Sstevel@tonic-gate 		kmem_free(nm, len);
2812*f3b585ceSsamf 		goto out;
28137c478bd9Sstevel@tonic-gate 	}
28147c478bd9Sstevel@tonic-gate 
28157c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = do_rfs4_op_lookup(nm, len, req, cs);
28167c478bd9Sstevel@tonic-gate 
28177c478bd9Sstevel@tonic-gate 	kmem_free(nm, len);
2818*f3b585ceSsamf 
2819*f3b585ceSsamf out:
2820*f3b585ceSsamf 	DTRACE_NFSV4_2(op__lookup__done, struct compound_state *, cs,
2821*f3b585ceSsamf 	    LOOKUP4res *, resp);
28227c478bd9Sstevel@tonic-gate }
28237c478bd9Sstevel@tonic-gate 
28247c478bd9Sstevel@tonic-gate /* ARGSUSED */
28257c478bd9Sstevel@tonic-gate static void
28267c478bd9Sstevel@tonic-gate rfs4_op_lookupp(nfs_argop4 *args, nfs_resop4 *resop, struct svc_req *req,
28277c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
28287c478bd9Sstevel@tonic-gate {
28297c478bd9Sstevel@tonic-gate 	LOOKUPP4res *resp = &resop->nfs_resop4_u.oplookupp;
28307c478bd9Sstevel@tonic-gate 
2831*f3b585ceSsamf 	DTRACE_NFSV4_1(op__lookupp__start, struct compound_state *, cs);
2832*f3b585ceSsamf 
28337c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
28347c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2835*f3b585ceSsamf 		goto out;
28367c478bd9Sstevel@tonic-gate 	}
28377c478bd9Sstevel@tonic-gate 
28387c478bd9Sstevel@tonic-gate 	if (cs->vp->v_type != VDIR) {
28397c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
2840*f3b585ceSsamf 		goto out;
28417c478bd9Sstevel@tonic-gate 	}
28427c478bd9Sstevel@tonic-gate 
28437c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = do_rfs4_op_lookup("..", 3, req, cs);
28447c478bd9Sstevel@tonic-gate 
28457c478bd9Sstevel@tonic-gate 	/*
28467c478bd9Sstevel@tonic-gate 	 * From NFSV4 Specification, LOOKUPP should not check for
28477c478bd9Sstevel@tonic-gate 	 * NFS4ERR_WRONGSEC. Retrun NFS4_OK instead.
28487c478bd9Sstevel@tonic-gate 	 */
28497c478bd9Sstevel@tonic-gate 	if (resp->status == NFS4ERR_WRONGSEC) {
28507c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4_OK;
28517c478bd9Sstevel@tonic-gate 	}
2852*f3b585ceSsamf 
2853*f3b585ceSsamf out:
2854*f3b585ceSsamf 	DTRACE_NFSV4_2(op__lookupp__done, struct compound_state *, cs,
2855*f3b585ceSsamf 	    LOOKUPP4res *, resp);
28567c478bd9Sstevel@tonic-gate }
28577c478bd9Sstevel@tonic-gate 
28587c478bd9Sstevel@tonic-gate 
28597c478bd9Sstevel@tonic-gate /*ARGSUSED2*/
28607c478bd9Sstevel@tonic-gate static void
28617c478bd9Sstevel@tonic-gate rfs4_op_openattr(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
28627c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
28637c478bd9Sstevel@tonic-gate {
28647c478bd9Sstevel@tonic-gate 	OPENATTR4args	*args = &argop->nfs_argop4_u.opopenattr;
28657c478bd9Sstevel@tonic-gate 	OPENATTR4res	*resp = &resop->nfs_resop4_u.opopenattr;
28667c478bd9Sstevel@tonic-gate 	vnode_t		*avp = NULL;
28677c478bd9Sstevel@tonic-gate 	int		lookup_flags = LOOKUP_XATTR, error;
28687c478bd9Sstevel@tonic-gate 	int		exp_ro = 0;
28697c478bd9Sstevel@tonic-gate 
2870*f3b585ceSsamf 	DTRACE_NFSV4_2(op__openattr__start, struct compound_state *, cs,
2871*f3b585ceSsamf 	    OPENATTR4args *, args);
2872*f3b585ceSsamf 
28737c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
28747c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2875*f3b585ceSsamf 		goto out;
28767c478bd9Sstevel@tonic-gate 	}
28777c478bd9Sstevel@tonic-gate 
28787c478bd9Sstevel@tonic-gate 	/*
28797c478bd9Sstevel@tonic-gate 	 * Make a couple of checks made by copen()
28807c478bd9Sstevel@tonic-gate 	 *
28817c478bd9Sstevel@tonic-gate 	 * Check to make sure underlying fs supports xattrs.  This
28827c478bd9Sstevel@tonic-gate 	 * is required because solaris filesystem implementations
28837c478bd9Sstevel@tonic-gate 	 * (UFS/TMPFS) don't enforce the noxattr mount option
28847c478bd9Sstevel@tonic-gate 	 * in VOP_LOOKUP(LOOKUP_XATTR).  If fs doesn't support this
28857c478bd9Sstevel@tonic-gate 	 * pathconf cmd or if fs supports cmd but doesn't claim
28867c478bd9Sstevel@tonic-gate 	 * support for xattr, return NOTSUPP.  It would be better
28877c478bd9Sstevel@tonic-gate 	 * to use VOP_PATHCONF( _PC_XATTR_ENABLED) for this; however,
28887c478bd9Sstevel@tonic-gate 	 * that cmd is not available to VOP_PATHCONF interface
28897c478bd9Sstevel@tonic-gate 	 * (it's only implemented inside pathconf syscall)...
28907c478bd9Sstevel@tonic-gate 	 *
28917c478bd9Sstevel@tonic-gate 	 * Verify permission to put attributes on files (access
28927c478bd9Sstevel@tonic-gate 	 * checks from copen).
28937c478bd9Sstevel@tonic-gate 	 */
28947c478bd9Sstevel@tonic-gate 
2895da6c28aaSamw 	if ((cs->vp->v_vfsp->vfs_flag & VFS_XATTR) == 0 &&
2896da6c28aaSamw 	    !vfs_has_feature(cs->vp->v_vfsp, VFSFT_XVATTR)) {
2897*f3b585ceSsamf 		*cs->statusp = resp->status = puterrno4(ENOTSUP);
2898*f3b585ceSsamf 		goto out;
28997c478bd9Sstevel@tonic-gate 	}
29007c478bd9Sstevel@tonic-gate 
2901da6c28aaSamw 	if ((VOP_ACCESS(cs->vp, VREAD, 0, cs->cr, NULL) != 0) &&
2902da6c28aaSamw 	    (VOP_ACCESS(cs->vp, VWRITE, 0, cs->cr, NULL) != 0) &&
2903da6c28aaSamw 	    (VOP_ACCESS(cs->vp, VEXEC, 0, cs->cr, NULL) != 0)) {
2904*f3b585ceSsamf 		*cs->statusp = resp->status = puterrno4(EACCES);
2905*f3b585ceSsamf 		goto out;
29067c478bd9Sstevel@tonic-gate 	}
29077c478bd9Sstevel@tonic-gate 
29087c478bd9Sstevel@tonic-gate 	/*
29097c478bd9Sstevel@tonic-gate 	 * The CREATE_XATTR_DIR VOP flag cannot be specified if
29107c478bd9Sstevel@tonic-gate 	 * the file system is exported read-only -- regardless of
29117c478bd9Sstevel@tonic-gate 	 * createdir flag.  Otherwise the attrdir would be created
29127c478bd9Sstevel@tonic-gate 	 * (assuming server fs isn't mounted readonly locally).  If
29137c478bd9Sstevel@tonic-gate 	 * VOP_LOOKUP returns ENOENT in this case, the error will
29147c478bd9Sstevel@tonic-gate 	 * be translated into EROFS.  ENOSYS is mapped to ENOTSUP
29157c478bd9Sstevel@tonic-gate 	 * because specfs has no VOP_LOOKUP op, so the macro would
29167c478bd9Sstevel@tonic-gate 	 * return ENOSYS.  EINVAL is returned by all (current)
29177c478bd9Sstevel@tonic-gate 	 * Solaris file system implementations when any of their
29187c478bd9Sstevel@tonic-gate 	 * restrictions are violated (xattr(dir) can't have xattrdir).
29197c478bd9Sstevel@tonic-gate 	 * Returning NOTSUPP is more appropriate in this case
29207c478bd9Sstevel@tonic-gate 	 * because the object will never be able to have an attrdir.
29217c478bd9Sstevel@tonic-gate 	 */
29227c478bd9Sstevel@tonic-gate 	if (args->createdir && ! (exp_ro = rdonly4(cs->exi, cs->vp, req)))
29237c478bd9Sstevel@tonic-gate 		lookup_flags |= CREATE_XATTR_DIR;
29247c478bd9Sstevel@tonic-gate 
2925da6c28aaSamw 	error = VOP_LOOKUP(cs->vp, "", &avp, NULL, lookup_flags, NULL, cs->cr,
2926da6c28aaSamw 	    NULL, NULL, NULL);
29277c478bd9Sstevel@tonic-gate 
29287c478bd9Sstevel@tonic-gate 	if (error) {
29297c478bd9Sstevel@tonic-gate 		if (error == ENOENT && args->createdir && exp_ro)
2930*f3b585ceSsamf 			*cs->statusp = resp->status = puterrno4(EROFS);
29317c478bd9Sstevel@tonic-gate 		else if (error == EINVAL || error == ENOSYS)
2932*f3b585ceSsamf 			*cs->statusp = resp->status = puterrno4(ENOTSUP);
2933*f3b585ceSsamf 		else
2934*f3b585ceSsamf 			*cs->statusp = resp->status = puterrno4(error);
2935*f3b585ceSsamf 		goto out;
29367c478bd9Sstevel@tonic-gate 	}
29377c478bd9Sstevel@tonic-gate 
29387c478bd9Sstevel@tonic-gate 	ASSERT(avp->v_flag & V_XATTRDIR);
29397c478bd9Sstevel@tonic-gate 
29407c478bd9Sstevel@tonic-gate 	error = makefh4(&cs->fh, avp, cs->exi);
29417c478bd9Sstevel@tonic-gate 
29427c478bd9Sstevel@tonic-gate 	if (error) {
29437c478bd9Sstevel@tonic-gate 		VN_RELE(avp);
2944*f3b585ceSsamf 		*cs->statusp = resp->status = puterrno4(error);
2945*f3b585ceSsamf 		goto out;
29467c478bd9Sstevel@tonic-gate 	}
29477c478bd9Sstevel@tonic-gate 
29487c478bd9Sstevel@tonic-gate 	VN_RELE(cs->vp);
29497c478bd9Sstevel@tonic-gate 	cs->vp = avp;
29507c478bd9Sstevel@tonic-gate 
29517c478bd9Sstevel@tonic-gate 	/*
29527c478bd9Sstevel@tonic-gate 	 * There is no requirement for an attrdir fh flag
29537c478bd9Sstevel@tonic-gate 	 * because the attrdir has a vnode flag to distinguish
29547c478bd9Sstevel@tonic-gate 	 * it from regular (non-xattr) directories.  The
29557c478bd9Sstevel@tonic-gate 	 * FH4_ATTRDIR flag is set for future sanity checks.
29567c478bd9Sstevel@tonic-gate 	 */
29577c478bd9Sstevel@tonic-gate 	set_fh4_flag(&cs->fh, FH4_ATTRDIR);
29587c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
29597c478bd9Sstevel@tonic-gate 
2960*f3b585ceSsamf out:
2961*f3b585ceSsamf 	DTRACE_NFSV4_2(op__openattr__done, struct compound_state *, cs,
2962*f3b585ceSsamf 	    OPENATTR4res *, resp);
29637c478bd9Sstevel@tonic-gate }
29647c478bd9Sstevel@tonic-gate 
29657c478bd9Sstevel@tonic-gate static int
2966da6c28aaSamw do_io(int direction, vnode_t *vp, struct uio *uio, int ioflag, cred_t *cred,
2967da6c28aaSamw     caller_context_t *ct)
29687c478bd9Sstevel@tonic-gate {
29697c478bd9Sstevel@tonic-gate 	int error;
29707c478bd9Sstevel@tonic-gate 	int i;
29717c478bd9Sstevel@tonic-gate 	clock_t delaytime;
29727c478bd9Sstevel@tonic-gate 
29737c478bd9Sstevel@tonic-gate 	delaytime = MSEC_TO_TICK_ROUNDUP(rfs4_lock_delay);
29747c478bd9Sstevel@tonic-gate 
29757c478bd9Sstevel@tonic-gate 	/*
29767c478bd9Sstevel@tonic-gate 	 * Don't block on mandatory locks. If this routine returns
29777c478bd9Sstevel@tonic-gate 	 * EAGAIN, the caller should return NFS4ERR_LOCKED.
29787c478bd9Sstevel@tonic-gate 	 */
29797c478bd9Sstevel@tonic-gate 	uio->uio_fmode = FNONBLOCK;
29807c478bd9Sstevel@tonic-gate 
29817c478bd9Sstevel@tonic-gate 	for (i = 0; i < rfs4_maxlock_tries; i++) {
29827c478bd9Sstevel@tonic-gate 
29837c478bd9Sstevel@tonic-gate 
29847c478bd9Sstevel@tonic-gate 		if (direction == FREAD) {
2985da6c28aaSamw 			(void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, ct);
2986da6c28aaSamw 			error = VOP_READ(vp, uio, ioflag, cred, ct);
2987da6c28aaSamw 			VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, ct);
29887c478bd9Sstevel@tonic-gate 		} else {
2989da6c28aaSamw 			(void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, ct);
2990da6c28aaSamw 			error = VOP_WRITE(vp, uio, ioflag, cred, ct);
2991da6c28aaSamw 			VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, ct);
29927c478bd9Sstevel@tonic-gate 		}
29937c478bd9Sstevel@tonic-gate 
29947c478bd9Sstevel@tonic-gate 		if (error != EAGAIN)
29957c478bd9Sstevel@tonic-gate 			break;
29967c478bd9Sstevel@tonic-gate 
29977c478bd9Sstevel@tonic-gate 		if (i < rfs4_maxlock_tries - 1) {
29987c478bd9Sstevel@tonic-gate 			delay(delaytime);
29997c478bd9Sstevel@tonic-gate 			delaytime *= 2;
30007c478bd9Sstevel@tonic-gate 		}
30017c478bd9Sstevel@tonic-gate 	}
30027c478bd9Sstevel@tonic-gate 
30037c478bd9Sstevel@tonic-gate 	return (error);
30047c478bd9Sstevel@tonic-gate }
30057c478bd9Sstevel@tonic-gate 
30067c478bd9Sstevel@tonic-gate /* ARGSUSED */
30077c478bd9Sstevel@tonic-gate static void
30087c478bd9Sstevel@tonic-gate rfs4_op_read(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
30097c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
30107c478bd9Sstevel@tonic-gate {
30117c478bd9Sstevel@tonic-gate 	READ4args *args = &argop->nfs_argop4_u.opread;
30127c478bd9Sstevel@tonic-gate 	READ4res *resp = &resop->nfs_resop4_u.opread;
30137c478bd9Sstevel@tonic-gate 	int error;
30147c478bd9Sstevel@tonic-gate 	int verror;
30157c478bd9Sstevel@tonic-gate 	vnode_t *vp;
30167c478bd9Sstevel@tonic-gate 	struct vattr va;
30177c478bd9Sstevel@tonic-gate 	struct iovec iov;
30187c478bd9Sstevel@tonic-gate 	struct uio uio;
30197c478bd9Sstevel@tonic-gate 	u_offset_t offset;
30207c478bd9Sstevel@tonic-gate 	bool_t *deleg = &cs->deleg;
30217c478bd9Sstevel@tonic-gate 	nfsstat4 stat;
30227c478bd9Sstevel@tonic-gate 	int in_crit = 0;
30237c478bd9Sstevel@tonic-gate 	mblk_t *mp;
30247c478bd9Sstevel@tonic-gate 	int alloc_err = 0;
3025da6c28aaSamw 	caller_context_t ct;
30267c478bd9Sstevel@tonic-gate 
3027*f3b585ceSsamf 	DTRACE_NFSV4_2(op__read__start, struct compound_state *, cs,
3028*f3b585ceSsamf 	    READ4args, args);
3029*f3b585ceSsamf 
30307c478bd9Sstevel@tonic-gate 	vp = cs->vp;
30317c478bd9Sstevel@tonic-gate 	if (vp == NULL) {
30327c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
3033*f3b585ceSsamf 		goto out;
30347c478bd9Sstevel@tonic-gate 	}
30357c478bd9Sstevel@tonic-gate 	if (cs->access == CS_ACCESS_DENIED) {
30367c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
3037*f3b585ceSsamf 		goto out;
30387c478bd9Sstevel@tonic-gate 	}
30397c478bd9Sstevel@tonic-gate 
3040da6c28aaSamw 	if ((stat = rfs4_check_stateid(FREAD, vp, &args->stateid, FALSE,
3041da6c28aaSamw 	    deleg, TRUE, &ct)) != NFS4_OK) {
3042da6c28aaSamw 		*cs->statusp = resp->status = stat;
3043da6c28aaSamw 		goto out;
3044da6c28aaSamw 	}
3045da6c28aaSamw 
30467c478bd9Sstevel@tonic-gate 	/*
30477c478bd9Sstevel@tonic-gate 	 * Enter the critical region before calling VOP_RWLOCK
30487c478bd9Sstevel@tonic-gate 	 * to avoid a deadlock with write requests.
30497c478bd9Sstevel@tonic-gate 	 */
30507c478bd9Sstevel@tonic-gate 	if (nbl_need_check(vp)) {
30517c478bd9Sstevel@tonic-gate 		nbl_start_crit(vp, RW_READER);
30527c478bd9Sstevel@tonic-gate 		in_crit = 1;
3053da6c28aaSamw 		if (nbl_conflict(vp, NBL_READ, args->offset, args->count, 0,
3054da6c28aaSamw 		    &ct)) {
30557c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_LOCKED;
30567c478bd9Sstevel@tonic-gate 			goto out;
30577c478bd9Sstevel@tonic-gate 		}
30587c478bd9Sstevel@tonic-gate 	}
30597c478bd9Sstevel@tonic-gate 
30607c478bd9Sstevel@tonic-gate 	if ((stat = rfs4_check_stateid(FREAD, vp, &args->stateid, FALSE,
3061da6c28aaSamw 	    deleg, TRUE, &ct)) != NFS4_OK) {
30627c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = stat;
30637c478bd9Sstevel@tonic-gate 		goto out;
30647c478bd9Sstevel@tonic-gate 	}
30657c478bd9Sstevel@tonic-gate 
30667c478bd9Sstevel@tonic-gate 	va.va_mask = AT_MODE|AT_SIZE|AT_UID;
3067da6c28aaSamw 	verror = VOP_GETATTR(vp, &va, 0, cs->cr, &ct);
30687c478bd9Sstevel@tonic-gate 
30697c478bd9Sstevel@tonic-gate 	/*
30707c478bd9Sstevel@tonic-gate 	 * If we can't get the attributes, then we can't do the
30717c478bd9Sstevel@tonic-gate 	 * right access checking.  So, we'll fail the request.
30727c478bd9Sstevel@tonic-gate 	 */
30737c478bd9Sstevel@tonic-gate 	if (verror) {
30747c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(verror);
30757c478bd9Sstevel@tonic-gate 		goto out;
30767c478bd9Sstevel@tonic-gate 	}
30777c478bd9Sstevel@tonic-gate 
30787c478bd9Sstevel@tonic-gate 	if (vp->v_type != VREG) {
30797c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status =
30801b300de9Sjwahlig 		    ((vp->v_type == VDIR) ? NFS4ERR_ISDIR : NFS4ERR_INVAL);
30817c478bd9Sstevel@tonic-gate 		goto out;
30827c478bd9Sstevel@tonic-gate 	}
30837c478bd9Sstevel@tonic-gate 
30847c478bd9Sstevel@tonic-gate 	if (crgetuid(cs->cr) != va.va_uid &&
3085da6c28aaSamw 	    (error = VOP_ACCESS(vp, VREAD, 0, cs->cr, &ct)) &&
3086da6c28aaSamw 	    (error = VOP_ACCESS(vp, VEXEC, 0, cs->cr, &ct))) {
30877c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
30887c478bd9Sstevel@tonic-gate 		goto out;
30897c478bd9Sstevel@tonic-gate 	}
30907c478bd9Sstevel@tonic-gate 
30917c478bd9Sstevel@tonic-gate 	if (MANDLOCK(vp, va.va_mode)) { /* XXX - V4 supports mand locking */
30927c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
30937c478bd9Sstevel@tonic-gate 		goto out;
30947c478bd9Sstevel@tonic-gate 	}
30957c478bd9Sstevel@tonic-gate 
30967c478bd9Sstevel@tonic-gate 	offset = args->offset;
30977c478bd9Sstevel@tonic-gate 	if (offset >= va.va_size) {
30987c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4_OK;
30997c478bd9Sstevel@tonic-gate 		resp->eof = TRUE;
31007c478bd9Sstevel@tonic-gate 		resp->data_len = 0;
31017c478bd9Sstevel@tonic-gate 		resp->data_val = NULL;
31027c478bd9Sstevel@tonic-gate 		resp->mblk = NULL;
31037c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4_OK;
31047c478bd9Sstevel@tonic-gate 		goto out;
31057c478bd9Sstevel@tonic-gate 	}
31067c478bd9Sstevel@tonic-gate 
31077c478bd9Sstevel@tonic-gate 	if (args->count == 0) {
31087c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4_OK;
31097c478bd9Sstevel@tonic-gate 		resp->eof = FALSE;
31107c478bd9Sstevel@tonic-gate 		resp->data_len = 0;
31117c478bd9Sstevel@tonic-gate 		resp->data_val = NULL;
31127c478bd9Sstevel@tonic-gate 		resp->mblk = NULL;
31137c478bd9Sstevel@tonic-gate 		goto out;
31147c478bd9Sstevel@tonic-gate 	}
31157c478bd9Sstevel@tonic-gate 
31167c478bd9Sstevel@tonic-gate 	/*
31177c478bd9Sstevel@tonic-gate 	 * Do not allocate memory more than maximum allowed
31187c478bd9Sstevel@tonic-gate 	 * transfer size
31197c478bd9Sstevel@tonic-gate 	 */
31207c478bd9Sstevel@tonic-gate 	if (args->count > rfs4_tsize(req))
31217c478bd9Sstevel@tonic-gate 		args->count = rfs4_tsize(req);
31227c478bd9Sstevel@tonic-gate 
31237c478bd9Sstevel@tonic-gate 	/*
31247c478bd9Sstevel@tonic-gate 	 * mp will contain the data to be sent out in the read reply.
31257c478bd9Sstevel@tonic-gate 	 * It will be freed after the reply has been sent.
31267c478bd9Sstevel@tonic-gate 	 * Let's roundup the data to a BYTES_PER_XDR_UNIT multiple,
31277c478bd9Sstevel@tonic-gate 	 * so that the call to xdrmblk_putmblk() never fails.
31287c478bd9Sstevel@tonic-gate 	 * If the first alloc of the requested size fails, then
31297c478bd9Sstevel@tonic-gate 	 * decrease the size to something more reasonable and wait
31307c478bd9Sstevel@tonic-gate 	 * for the allocation to occur.
31317c478bd9Sstevel@tonic-gate 	 */
31327c478bd9Sstevel@tonic-gate 	mp = allocb(RNDUP(args->count), BPRI_MED);
31337c478bd9Sstevel@tonic-gate 	if (mp == NULL) {
31347c478bd9Sstevel@tonic-gate 		if (args->count > MAXBSIZE)
31357c478bd9Sstevel@tonic-gate 			args->count = MAXBSIZE;
31367c478bd9Sstevel@tonic-gate 		mp = allocb_wait(RNDUP(args->count), BPRI_MED,
31371b300de9Sjwahlig 		    STR_NOSIG, &alloc_err);
31387c478bd9Sstevel@tonic-gate 	}
31397c478bd9Sstevel@tonic-gate 	ASSERT(mp != NULL);
31407c478bd9Sstevel@tonic-gate 	ASSERT(alloc_err == 0);
31417c478bd9Sstevel@tonic-gate 
31427c478bd9Sstevel@tonic-gate 	iov.iov_base = (caddr_t)mp->b_datap->db_base;
31437c478bd9Sstevel@tonic-gate 	iov.iov_len = args->count;
31447c478bd9Sstevel@tonic-gate 	uio.uio_iov = &iov;
31457c478bd9Sstevel@tonic-gate 	uio.uio_iovcnt = 1;
31467c478bd9Sstevel@tonic-gate 	uio.uio_segflg = UIO_SYSSPACE;
31477c478bd9Sstevel@tonic-gate 	uio.uio_extflg = UIO_COPY_CACHED;
31487c478bd9Sstevel@tonic-gate 	uio.uio_loffset = args->offset;
31497c478bd9Sstevel@tonic-gate 	uio.uio_resid = args->count;
31507c478bd9Sstevel@tonic-gate 
3151da6c28aaSamw 	error = do_io(FREAD, vp, &uio, 0, cs->cr, &ct);
31527c478bd9Sstevel@tonic-gate 
31537c478bd9Sstevel@tonic-gate 	va.va_mask = AT_SIZE;
3154da6c28aaSamw 	verror = VOP_GETATTR(vp, &va, 0, cs->cr, &ct);
31557c478bd9Sstevel@tonic-gate 
31567c478bd9Sstevel@tonic-gate 	if (error) {
31577c478bd9Sstevel@tonic-gate 		freeb(mp);
31587c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
31597c478bd9Sstevel@tonic-gate 		goto out;
31607c478bd9Sstevel@tonic-gate 	}
31617c478bd9Sstevel@tonic-gate 
31627c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
31637c478bd9Sstevel@tonic-gate 
31647c478bd9Sstevel@tonic-gate 	ASSERT(uio.uio_resid >= 0);
31657c478bd9Sstevel@tonic-gate 	resp->data_len = args->count - uio.uio_resid;
31667c478bd9Sstevel@tonic-gate 	resp->data_val = (char *)mp->b_datap->db_base;
31677c478bd9Sstevel@tonic-gate 	resp->mblk = mp;
31687c478bd9Sstevel@tonic-gate 
31697c478bd9Sstevel@tonic-gate 	if (!verror && offset + resp->data_len == va.va_size)
31707c478bd9Sstevel@tonic-gate 		resp->eof = TRUE;
31717c478bd9Sstevel@tonic-gate 	else
31727c478bd9Sstevel@tonic-gate 		resp->eof = FALSE;
31737c478bd9Sstevel@tonic-gate 
31747c478bd9Sstevel@tonic-gate out:
31757c478bd9Sstevel@tonic-gate 	if (in_crit)
31767c478bd9Sstevel@tonic-gate 		nbl_end_crit(vp);
3177*f3b585ceSsamf 
3178*f3b585ceSsamf 	DTRACE_NFSV4_2(op__read__done, struct compound_state *, cs,
3179*f3b585ceSsamf 	    READ4res *, resp);
31807c478bd9Sstevel@tonic-gate }
31817c478bd9Sstevel@tonic-gate 
31827c478bd9Sstevel@tonic-gate static void
31837c478bd9Sstevel@tonic-gate rfs4_op_read_free(nfs_resop4 *resop)
31847c478bd9Sstevel@tonic-gate {
31857c478bd9Sstevel@tonic-gate 	READ4res *resp = &resop->nfs_resop4_u.opread;
31867c478bd9Sstevel@tonic-gate 
31877c478bd9Sstevel@tonic-gate 	if (resp->status == NFS4_OK && resp->mblk != NULL) {
31887c478bd9Sstevel@tonic-gate 		freeb(resp->mblk);
31897c478bd9Sstevel@tonic-gate 		resp->mblk = NULL;
31907c478bd9Sstevel@tonic-gate 		resp->data_val = NULL;
31917c478bd9Sstevel@tonic-gate 		resp->data_len = 0;
31927c478bd9Sstevel@tonic-gate 	}
31937c478bd9Sstevel@tonic-gate }
31947c478bd9Sstevel@tonic-gate 
31957c478bd9Sstevel@tonic-gate static void
31967c478bd9Sstevel@tonic-gate rfs4_op_readdir_free(nfs_resop4 *resop)
31977c478bd9Sstevel@tonic-gate {
31987c478bd9Sstevel@tonic-gate 	READDIR4res *resp = &resop->nfs_resop4_u.opreaddir;
31997c478bd9Sstevel@tonic-gate 
32007c478bd9Sstevel@tonic-gate 	if (resp->status == NFS4_OK && resp->mblk != NULL) {
32017c478bd9Sstevel@tonic-gate 		freeb(resp->mblk);
32027c478bd9Sstevel@tonic-gate 		resp->mblk = NULL;
32037c478bd9Sstevel@tonic-gate 		resp->data_len = 0;
32047c478bd9Sstevel@tonic-gate 	}
32057c478bd9Sstevel@tonic-gate }
32067c478bd9Sstevel@tonic-gate 
32077c478bd9Sstevel@tonic-gate 
32087c478bd9Sstevel@tonic-gate /* ARGSUSED */
32097c478bd9Sstevel@tonic-gate static void
32107c478bd9Sstevel@tonic-gate rfs4_op_putpubfh(nfs_argop4 *args, nfs_resop4 *resop, struct svc_req *req,
32117c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
32127c478bd9Sstevel@tonic-gate {
32137c478bd9Sstevel@tonic-gate 	PUTPUBFH4res *resp = &resop->nfs_resop4_u.opputpubfh;
32147c478bd9Sstevel@tonic-gate 	int error;
32157c478bd9Sstevel@tonic-gate 	vnode_t *vp;
32167c478bd9Sstevel@tonic-gate 	struct exportinfo *exi, *sav_exi;
32177c478bd9Sstevel@tonic-gate 	nfs_fh4_fmt_t *fh_fmtp;
32187c478bd9Sstevel@tonic-gate 
3219*f3b585ceSsamf 	DTRACE_NFSV4_1(op__putpubfh__start, struct compound_state *, cs);
3220*f3b585ceSsamf 
32217c478bd9Sstevel@tonic-gate 	if (cs->vp) {
32227c478bd9Sstevel@tonic-gate 		VN_RELE(cs->vp);
32237c478bd9Sstevel@tonic-gate 		cs->vp = NULL;
32247c478bd9Sstevel@tonic-gate 	}
32257c478bd9Sstevel@tonic-gate 
32267c478bd9Sstevel@tonic-gate 	if (cs->cr)
32277c478bd9Sstevel@tonic-gate 		crfree(cs->cr);
32287c478bd9Sstevel@tonic-gate 
32297c478bd9Sstevel@tonic-gate 	cs->cr = crdup(cs->basecr);
32307c478bd9Sstevel@tonic-gate 
32317c478bd9Sstevel@tonic-gate 	vp = exi_public->exi_vp;
32327c478bd9Sstevel@tonic-gate 	if (vp == NULL) {
32337c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_SERVERFAULT;
3234*f3b585ceSsamf 		goto out;
32357c478bd9Sstevel@tonic-gate 	}
32367c478bd9Sstevel@tonic-gate 
323703986916Sjarrett 	if (is_system_labeled()) {
323803986916Sjarrett 		bslabel_t *clabel;
323903986916Sjarrett 
324003986916Sjarrett 		ASSERT(req->rq_label != NULL);
324103986916Sjarrett 		clabel = req->rq_label;
324203986916Sjarrett 		DTRACE_PROBE2(tx__rfs4__log__info__opputpubfh__clabel, char *,
324303986916Sjarrett 		    "got client label from request(1)",
324403986916Sjarrett 		    struct svc_req *, req);
324503986916Sjarrett 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
324603986916Sjarrett 			if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK)) {
324703986916Sjarrett 				*cs->statusp = resp->status =
324803986916Sjarrett 				    NFS4ERR_SERVERFAULT;
324903986916Sjarrett 				return;
325003986916Sjarrett 			}
325103986916Sjarrett 		}
325203986916Sjarrett 	}
325303986916Sjarrett 
32547c478bd9Sstevel@tonic-gate 	error = makefh4(&cs->fh, vp, exi_public);
32557c478bd9Sstevel@tonic-gate 	if (error != 0) {
32567c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
3257*f3b585ceSsamf 		goto out;
32587c478bd9Sstevel@tonic-gate 	}
32597c478bd9Sstevel@tonic-gate 	sav_exi = cs->exi;
32607c478bd9Sstevel@tonic-gate 	if (exi_public == exi_root) {
32617c478bd9Sstevel@tonic-gate 		/*
32627c478bd9Sstevel@tonic-gate 		 * No filesystem is actually shared public, so we default
32637c478bd9Sstevel@tonic-gate 		 * to exi_root. In this case, we must check whether root
32647c478bd9Sstevel@tonic-gate 		 * is exported.
32657c478bd9Sstevel@tonic-gate 		 */
32667c478bd9Sstevel@tonic-gate 		fh_fmtp = (nfs_fh4_fmt_t *)cs->fh.nfs_fh4_val;
32677c478bd9Sstevel@tonic-gate 
32687c478bd9Sstevel@tonic-gate 		/*
32697c478bd9Sstevel@tonic-gate 		 * if root filesystem is exported, the exportinfo struct that we
32707c478bd9Sstevel@tonic-gate 		 * should use is what checkexport4 returns, because root_exi is
32717c478bd9Sstevel@tonic-gate 		 * actually a mostly empty struct.
32727c478bd9Sstevel@tonic-gate 		 */
32737c478bd9Sstevel@tonic-gate 		exi = checkexport4(&fh_fmtp->fh4_fsid,
32741b300de9Sjwahlig 		    (fid_t *)&fh_fmtp->fh4_xlen, NULL);
32757c478bd9Sstevel@tonic-gate 		cs->exi = ((exi != NULL) ? exi : exi_public);
32767c478bd9Sstevel@tonic-gate 	} else {
32777c478bd9Sstevel@tonic-gate 		/*
32787c478bd9Sstevel@tonic-gate 		 * it's a properly shared filesystem
32797c478bd9Sstevel@tonic-gate 		 */
32807c478bd9Sstevel@tonic-gate 		cs->exi = exi_public;
32817c478bd9Sstevel@tonic-gate 	}
32827c478bd9Sstevel@tonic-gate 
32837c478bd9Sstevel@tonic-gate 	VN_HOLD(vp);
32847c478bd9Sstevel@tonic-gate 	cs->vp = vp;
32857c478bd9Sstevel@tonic-gate 
32867c478bd9Sstevel@tonic-gate 	if ((resp->status = call_checkauth4(cs, req)) != NFS4_OK) {
32877c478bd9Sstevel@tonic-gate 		VN_RELE(cs->vp);
32887c478bd9Sstevel@tonic-gate 		cs->vp = NULL;
32897c478bd9Sstevel@tonic-gate 		cs->exi = sav_exi;
3290*f3b585ceSsamf 		goto out;
32917c478bd9Sstevel@tonic-gate 	}
32927c478bd9Sstevel@tonic-gate 
32937c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
3294*f3b585ceSsamf out:
3295*f3b585ceSsamf 	DTRACE_NFSV4_2(op__putpubfh__done, struct compound_state *, cs,
3296*f3b585ceSsamf 	    PUTPUBFH4res *, resp);
32977c478bd9Sstevel@tonic-gate }
32987c478bd9Sstevel@tonic-gate 
32997c478bd9Sstevel@tonic-gate /*
33007c478bd9Sstevel@tonic-gate  * XXX - issue with put*fh operations. Suppose /export/home is exported.
33017c478bd9Sstevel@tonic-gate  * Suppose an NFS client goes to mount /export/home/joe. If /export, home,
33027c478bd9Sstevel@tonic-gate  * or joe have restrictive search permissions, then we shouldn't let
33037c478bd9Sstevel@tonic-gate  * the client get a file handle. This is easy to enforce. However, we
33047c478bd9Sstevel@tonic-gate  * don't know what security flavor should be used until we resolve the
33057c478bd9Sstevel@tonic-gate  * path name. Another complication is uid mapping. If root is
33067c478bd9Sstevel@tonic-gate  * the user, then it will be mapped to the anonymous user by default,
33077c478bd9Sstevel@tonic-gate  * but we won't know that till we've resolved the path name. And we won't
33087c478bd9Sstevel@tonic-gate  * know what the anonymous user is.
33097c478bd9Sstevel@tonic-gate  * Luckily, SECINFO is specified to take a full filename.
33107c478bd9Sstevel@tonic-gate  * So what we will have to in rfs4_op_lookup is check that flavor of
33117c478bd9Sstevel@tonic-gate  * the target object matches that of the request, and if root was the
33127c478bd9Sstevel@tonic-gate  * caller, check for the root= and anon= options, and if necessary,
33137c478bd9Sstevel@tonic-gate  * repeat the lookup using the right cred_t. But that's not done yet.
33147c478bd9Sstevel@tonic-gate  */
33157c478bd9Sstevel@tonic-gate /* ARGSUSED */
33167c478bd9Sstevel@tonic-gate static void
33177c478bd9Sstevel@tonic-gate rfs4_op_putfh(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
33187c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
33197c478bd9Sstevel@tonic-gate {
33207c478bd9Sstevel@tonic-gate 	PUTFH4args *args = &argop->nfs_argop4_u.opputfh;
33217c478bd9Sstevel@tonic-gate 	PUTFH4res *resp = &resop->nfs_resop4_u.opputfh;
33227c478bd9Sstevel@tonic-gate 	nfs_fh4_fmt_t *fh_fmtp;
33237c478bd9Sstevel@tonic-gate 
3324*f3b585ceSsamf 	DTRACE_NFSV4_2(op__putfh__start, struct compound_state *, cs,
3325*f3b585ceSsamf 	    PUTFH4args *, args);
3326*f3b585ceSsamf 
33277c478bd9Sstevel@tonic-gate 	if (cs->vp) {
33287c478bd9Sstevel@tonic-gate 		VN_RELE(cs->vp);
33297c478bd9Sstevel@tonic-gate 		cs->vp = NULL;
33307c478bd9Sstevel@tonic-gate 	}
33317c478bd9Sstevel@tonic-gate 
33327c478bd9Sstevel@tonic-gate 	if (cs->cr) {
33337c478bd9Sstevel@tonic-gate 		crfree(cs->cr);
33347c478bd9Sstevel@tonic-gate 		cs->cr = NULL;
33357c478bd9Sstevel@tonic-gate 	}
33367c478bd9Sstevel@tonic-gate 
33377c478bd9Sstevel@tonic-gate 
33387c478bd9Sstevel@tonic-gate 	if (args->object.nfs_fh4_len < NFS_FH4_LEN) {
33397c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BADHANDLE;
3340*f3b585ceSsamf 		goto out;
33417c478bd9Sstevel@tonic-gate 	}
33427c478bd9Sstevel@tonic-gate 
33437c478bd9Sstevel@tonic-gate 	fh_fmtp = (nfs_fh4_fmt_t *)args->object.nfs_fh4_val;
33447c478bd9Sstevel@tonic-gate 	cs->exi = checkexport4(&fh_fmtp->fh4_fsid, (fid_t *)&fh_fmtp->fh4_xlen,
33451b300de9Sjwahlig 	    NULL);
33467c478bd9Sstevel@tonic-gate 
33477c478bd9Sstevel@tonic-gate 	if (cs->exi == NULL) {
33487c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_STALE;
3349*f3b585ceSsamf 		goto out;
33507c478bd9Sstevel@tonic-gate 	}
33517c478bd9Sstevel@tonic-gate 
33527c478bd9Sstevel@tonic-gate 	cs->cr = crdup(cs->basecr);
33537c478bd9Sstevel@tonic-gate 
33547c478bd9Sstevel@tonic-gate 	ASSERT(cs->cr != NULL);
33557c478bd9Sstevel@tonic-gate 
33567c478bd9Sstevel@tonic-gate 	if (! (cs->vp = nfs4_fhtovp(&args->object, cs->exi, &resp->status))) {
33577c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status;
3358*f3b585ceSsamf 		goto out;
33597c478bd9Sstevel@tonic-gate 	}
33607c478bd9Sstevel@tonic-gate 
33617c478bd9Sstevel@tonic-gate 	if ((resp->status = call_checkauth4(cs, req)) != NFS4_OK) {
33627c478bd9Sstevel@tonic-gate 		VN_RELE(cs->vp);
33637c478bd9Sstevel@tonic-gate 		cs->vp = NULL;
3364*f3b585ceSsamf 		goto out;
33657c478bd9Sstevel@tonic-gate 	}
33667c478bd9Sstevel@tonic-gate 
33677c478bd9Sstevel@tonic-gate 	nfs_fh4_copy(&args->object, &cs->fh);
33687c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
33697c478bd9Sstevel@tonic-gate 	cs->deleg = FALSE;
3370*f3b585ceSsamf 
3371*f3b585ceSsamf out:
3372*f3b585ceSsamf 	DTRACE_NFSV4_2(op__putfh__done, struct compound_state *, cs,
3373*f3b585ceSsamf 	    PUTFH4res *, resp);
33747c478bd9Sstevel@tonic-gate }
33757c478bd9Sstevel@tonic-gate 
33767c478bd9Sstevel@tonic-gate /* ARGSUSED */
33777c478bd9Sstevel@tonic-gate static void
33787c478bd9Sstevel@tonic-gate rfs4_op_putrootfh(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
33797c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
33807c478bd9Sstevel@tonic-gate 
33817c478bd9Sstevel@tonic-gate {
33827c478bd9Sstevel@tonic-gate 	PUTROOTFH4res *resp = &resop->nfs_resop4_u.opputrootfh;
33837c478bd9Sstevel@tonic-gate 	int error;
33847c478bd9Sstevel@tonic-gate 	fid_t fid;
33857c478bd9Sstevel@tonic-gate 	struct exportinfo *exi, *sav_exi;
33867c478bd9Sstevel@tonic-gate 
3387*f3b585ceSsamf 	DTRACE_NFSV4_1(op__putrootfh__start, struct compound_state *, cs);
3388*f3b585ceSsamf 
33897c478bd9Sstevel@tonic-gate 	if (cs->vp) {
33907c478bd9Sstevel@tonic-gate 		VN_RELE(cs->vp);
33917c478bd9Sstevel@tonic-gate 		cs->vp = NULL;
33927c478bd9Sstevel@tonic-gate 	}
33937c478bd9Sstevel@tonic-gate 
33947c478bd9Sstevel@tonic-gate 	if (cs->cr)
33957c478bd9Sstevel@tonic-gate 		crfree(cs->cr);
33967c478bd9Sstevel@tonic-gate 
33977c478bd9Sstevel@tonic-gate 	cs->cr = crdup(cs->basecr);
33987c478bd9Sstevel@tonic-gate 
33997c478bd9Sstevel@tonic-gate 	/*
34007c478bd9Sstevel@tonic-gate 	 * Using rootdir, the system root vnode,
34017c478bd9Sstevel@tonic-gate 	 * get its fid.
34027c478bd9Sstevel@tonic-gate 	 */
34037c478bd9Sstevel@tonic-gate 	bzero(&fid, sizeof (fid));
34047c478bd9Sstevel@tonic-gate 	fid.fid_len = MAXFIDSZ;
34057c478bd9Sstevel@tonic-gate 	error = vop_fid_pseudo(rootdir, &fid);
34067c478bd9Sstevel@tonic-gate 	if (error != 0) {
34077c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
3408*f3b585ceSsamf 		goto out;
34097c478bd9Sstevel@tonic-gate 	}
34107c478bd9Sstevel@tonic-gate 
34117c478bd9Sstevel@tonic-gate 	/*
34127c478bd9Sstevel@tonic-gate 	 * Then use the root fsid & fid it to find out if it's exported
34137c478bd9Sstevel@tonic-gate 	 *
34147c478bd9Sstevel@tonic-gate 	 * If the server root isn't exported directly, then
34157c478bd9Sstevel@tonic-gate 	 * it should at least be a pseudo export based on
34167c478bd9Sstevel@tonic-gate 	 * one or more exports further down in the server's
34177c478bd9Sstevel@tonic-gate 	 * file tree.
34187c478bd9Sstevel@tonic-gate 	 */
34197c478bd9Sstevel@tonic-gate 	exi = checkexport4(&rootdir->v_vfsp->vfs_fsid, &fid, NULL);
34207c478bd9Sstevel@tonic-gate 	if (exi == NULL || exi->exi_export.ex_flags & EX_PUBLIC) {
34217c478bd9Sstevel@tonic-gate 		NFS4_DEBUG(rfs4_debug,
34227c478bd9Sstevel@tonic-gate 			(CE_WARN, "rfs4_op_putrootfh: export check failure"));
34237c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_SERVERFAULT;
3424*f3b585ceSsamf 		goto out;
34257c478bd9Sstevel@tonic-gate 	}
34267c478bd9Sstevel@tonic-gate 
34277c478bd9Sstevel@tonic-gate 	/*
34287c478bd9Sstevel@tonic-gate 	 * Now make a filehandle based on the root
34297c478bd9Sstevel@tonic-gate 	 * export and root vnode.
34307c478bd9Sstevel@tonic-gate 	 */
34317c478bd9Sstevel@tonic-gate 	error = makefh4(&cs->fh, rootdir, exi);
34327c478bd9Sstevel@tonic-gate 	if (error != 0) {
34337c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
3434*f3b585ceSsamf 		goto out;
34357c478bd9Sstevel@tonic-gate 	}
34367c478bd9Sstevel@tonic-gate 
34377c478bd9Sstevel@tonic-gate 	sav_exi = cs->exi;
34387c478bd9Sstevel@tonic-gate 	cs->exi = exi;
34397c478bd9Sstevel@tonic-gate 
34407c478bd9Sstevel@tonic-gate 	VN_HOLD(rootdir);
34417c478bd9Sstevel@tonic-gate 	cs->vp = rootdir;
34427c478bd9Sstevel@tonic-gate 
34437c478bd9Sstevel@tonic-gate 	if ((resp->status = call_checkauth4(cs, req)) != NFS4_OK) {
34447c478bd9Sstevel@tonic-gate 		VN_RELE(rootdir);
34457c478bd9Sstevel@tonic-gate 		cs->vp = NULL;
34467c478bd9Sstevel@tonic-gate 		cs->exi = sav_exi;
3447*f3b585ceSsamf 		goto out;
34487c478bd9Sstevel@tonic-gate 	}
34497c478bd9Sstevel@tonic-gate 
34507c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
34517c478bd9Sstevel@tonic-gate 	cs->deleg = FALSE;
3452*f3b585ceSsamf out:
3453*f3b585ceSsamf 	DTRACE_NFSV4_2(op__putrootfh__done, struct compound_state *, cs,
3454*f3b585ceSsamf 	    PUTROOTFH4res *, resp);
34557c478bd9Sstevel@tonic-gate }
34567c478bd9Sstevel@tonic-gate 
34577c478bd9Sstevel@tonic-gate /*
34587c478bd9Sstevel@tonic-gate  * A directory entry is a valid nfsv4 entry if
34597c478bd9Sstevel@tonic-gate  * - it has a non-zero ino
34607c478bd9Sstevel@tonic-gate  * - it is not a dot or dotdot name
34617c478bd9Sstevel@tonic-gate  * - it is visible in a pseudo export or in a real export that can
34627c478bd9Sstevel@tonic-gate  *   only have a limited view.
34637c478bd9Sstevel@tonic-gate  */
34647c478bd9Sstevel@tonic-gate static bool_t
34657c478bd9Sstevel@tonic-gate valid_nfs4_entry(struct exportinfo *exi, struct dirent64 *dp,
34667c478bd9Sstevel@tonic-gate 		int *expseudo, int check_visible)
34677c478bd9Sstevel@tonic-gate {
34687c478bd9Sstevel@tonic-gate 	if (dp->d_ino == 0 || NFS_IS_DOTNAME(dp->d_name)) {
34697c478bd9Sstevel@tonic-gate 		*expseudo = 0;
34707c478bd9Sstevel@tonic-gate 		return (FALSE);
34717c478bd9Sstevel@tonic-gate 	}
34727c478bd9Sstevel@tonic-gate 
34737c478bd9Sstevel@tonic-gate 	if (! check_visible) {
34747c478bd9Sstevel@tonic-gate 		*expseudo = 0;
34757c478bd9Sstevel@tonic-gate 		return (TRUE);
34767c478bd9Sstevel@tonic-gate 	}
34777c478bd9Sstevel@tonic-gate 
34787c478bd9Sstevel@tonic-gate 	return (nfs_visible_inode(exi, dp->d_ino, expseudo));
34797c478bd9Sstevel@tonic-gate }
34807c478bd9Sstevel@tonic-gate 
34817c478bd9Sstevel@tonic-gate /*
34827c478bd9Sstevel@tonic-gate  * set_rdattr_params sets up the variables used to manage what information
34837c478bd9Sstevel@tonic-gate  * to get for each directory entry.
34847c478bd9Sstevel@tonic-gate  */
34857c478bd9Sstevel@tonic-gate static nfsstat4
34867c478bd9Sstevel@tonic-gate set_rdattr_params(struct nfs4_svgetit_arg *sargp,
34877c478bd9Sstevel@tonic-gate 		bitmap4 attrs, bool_t *need_to_lookup)
34887c478bd9Sstevel@tonic-gate {
34897c478bd9Sstevel@tonic-gate 	uint_t	va_mask;
34907c478bd9Sstevel@tonic-gate 	nfsstat4 status;
34917c478bd9Sstevel@tonic-gate 	bitmap4 objbits;
34927c478bd9Sstevel@tonic-gate 
34937c478bd9Sstevel@tonic-gate 	status = bitmap4_to_attrmask(attrs, sargp);
34947c478bd9Sstevel@tonic-gate 	if (status != NFS4_OK) {
34957c478bd9Sstevel@tonic-gate 		/*
34967c478bd9Sstevel@tonic-gate 		 * could not even figure attr mask
34977c478bd9Sstevel@tonic-gate 		 */
34987c478bd9Sstevel@tonic-gate 		return (status);
34997c478bd9Sstevel@tonic-gate 	}
35007c478bd9Sstevel@tonic-gate 	va_mask = sargp->vap->va_mask;
35017c478bd9Sstevel@tonic-gate 
35027c478bd9Sstevel@tonic-gate 	/*
35037c478bd9Sstevel@tonic-gate 	 * dirent's d_ino is always correct value for mounted_on_fileid.
35047c478bd9Sstevel@tonic-gate 	 * mntdfid_set is set once here, but mounted_on_fileid is
35057c478bd9Sstevel@tonic-gate 	 * set in main dirent processing loop for each dirent.
35067c478bd9Sstevel@tonic-gate 	 * The mntdfid_set is a simple optimization that lets the
35077c478bd9Sstevel@tonic-gate 	 * server attr code avoid work when caller is readdir.
35087c478bd9Sstevel@tonic-gate 	 */
35097c478bd9Sstevel@tonic-gate 	sargp->mntdfid_set = TRUE;
35107c478bd9Sstevel@tonic-gate 
35117c478bd9Sstevel@tonic-gate 	/*
35127c478bd9Sstevel@tonic-gate 	 * Lookup entry only if client asked for any of the following:
35137c478bd9Sstevel@tonic-gate 	 * a) vattr attrs
35147c478bd9Sstevel@tonic-gate 	 * b) vfs attrs
35157c478bd9Sstevel@tonic-gate 	 * c) attrs w/per-object scope requested (change, filehandle, etc)
35167c478bd9Sstevel@tonic-gate 	 *    other than mounted_on_fileid (which we can take from dirent)
35177c478bd9Sstevel@tonic-gate 	 */
35187c478bd9Sstevel@tonic-gate 	objbits = attrs ? attrs & NFS4_VP_ATTR_MASK : 0;
35197c478bd9Sstevel@tonic-gate 
35207c478bd9Sstevel@tonic-gate 	if (va_mask || sargp->sbp || (objbits & ~FATTR4_MOUNTED_ON_FILEID_MASK))
35217c478bd9Sstevel@tonic-gate 		*need_to_lookup = TRUE;
35227c478bd9Sstevel@tonic-gate 	else
35237c478bd9Sstevel@tonic-gate 		*need_to_lookup = FALSE;
35247c478bd9Sstevel@tonic-gate 
35257c478bd9Sstevel@tonic-gate 	if (sargp->sbp == NULL)
35267c478bd9Sstevel@tonic-gate 		return (NFS4_OK);
35277c478bd9Sstevel@tonic-gate 
35287c478bd9Sstevel@tonic-gate 	/*
35297c478bd9Sstevel@tonic-gate 	 * If filesystem attrs are requested, get them now from the
35307c478bd9Sstevel@tonic-gate 	 * directory vp, as most entries will have same filesystem. The only
35317c478bd9Sstevel@tonic-gate 	 * exception are mounted over entries but we handle
35327c478bd9Sstevel@tonic-gate 	 * those as we go (XXX mounted over detection not yet implemented).
35337c478bd9Sstevel@tonic-gate 	 */
35347c478bd9Sstevel@tonic-gate 	sargp->vap->va_mask = 0;	/* to avoid VOP_GETATTR */
35357c478bd9Sstevel@tonic-gate 	status = bitmap4_get_sysattrs(sargp);
35367c478bd9Sstevel@tonic-gate 	sargp->vap->va_mask = va_mask;
35377c478bd9Sstevel@tonic-gate 
35387c478bd9Sstevel@tonic-gate 	if ((status != NFS4_OK) && sargp->rdattr_error_req) {
35397c478bd9Sstevel@tonic-gate 		/*
35407c478bd9Sstevel@tonic-gate 		 * Failed to get filesystem attributes.
35417c478bd9Sstevel@tonic-gate 		 * Return a rdattr_error for each entry, but don't fail.
35427c478bd9Sstevel@tonic-gate 		 * However, don't get any obj-dependent attrs.
35437c478bd9Sstevel@tonic-gate 		 */
35447c478bd9Sstevel@tonic-gate 		sargp->rdattr_error = status;	/* for rdattr_error */
35457c478bd9Sstevel@tonic-gate 		*need_to_lookup = FALSE;
35467c478bd9Sstevel@tonic-gate 		/*
35477c478bd9Sstevel@tonic-gate 		 * At least get fileid for regular readdir output
35487c478bd9Sstevel@tonic-gate 		 */
35497c478bd9Sstevel@tonic-gate 		sargp->vap->va_mask &= AT_NODEID;
35507c478bd9Sstevel@tonic-gate 		status = NFS4_OK;
35517c478bd9Sstevel@tonic-gate 	}
35527c478bd9Sstevel@tonic-gate 
35537c478bd9Sstevel@tonic-gate 	return (status);
35547c478bd9Sstevel@tonic-gate }
35557c478bd9Sstevel@tonic-gate 
35567c478bd9Sstevel@tonic-gate /*
35577c478bd9Sstevel@tonic-gate  * readlink: args: CURRENT_FH.
35587c478bd9Sstevel@tonic-gate  *	res: status. If success - CURRENT_FH unchanged, return linktext.
35597c478bd9Sstevel@tonic-gate  */
35607c478bd9Sstevel@tonic-gate 
35617c478bd9Sstevel@tonic-gate /* ARGSUSED */
35627c478bd9Sstevel@tonic-gate static void
35637c478bd9Sstevel@tonic-gate rfs4_op_readlink(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
35647c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
35657c478bd9Sstevel@tonic-gate {
35667c478bd9Sstevel@tonic-gate 	READLINK4res *resp = &resop->nfs_resop4_u.opreadlink;
35677c478bd9Sstevel@tonic-gate 	int error;
35687c478bd9Sstevel@tonic-gate 	vnode_t *vp;
35697c478bd9Sstevel@tonic-gate 	struct iovec iov;
35707c478bd9Sstevel@tonic-gate 	struct vattr va;
35717c478bd9Sstevel@tonic-gate 	struct uio uio;
35727c478bd9Sstevel@tonic-gate 	char *data;
35737c478bd9Sstevel@tonic-gate 
3574*f3b585ceSsamf 	DTRACE_NFSV4_1(op__readlink__start, struct compound_state *, cs);
3575*f3b585ceSsamf 
35767c478bd9Sstevel@tonic-gate 	/* CURRENT_FH: directory */
35777c478bd9Sstevel@tonic-gate 	vp = cs->vp;
35787c478bd9Sstevel@tonic-gate 	if (vp == NULL) {
35797c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
3580*f3b585ceSsamf 		goto out;
35817c478bd9Sstevel@tonic-gate 	}
35827c478bd9Sstevel@tonic-gate 
35837c478bd9Sstevel@tonic-gate 	if (cs->access == CS_ACCESS_DENIED) {
35847c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
3585*f3b585ceSsamf 		goto out;
35867c478bd9Sstevel@tonic-gate 	}
35877c478bd9Sstevel@tonic-gate 
35887c478bd9Sstevel@tonic-gate 	if (vp->v_type == VDIR) {
35897c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ISDIR;
3590*f3b585ceSsamf 		goto out;
35917c478bd9Sstevel@tonic-gate 	}
35927c478bd9Sstevel@tonic-gate 
35937c478bd9Sstevel@tonic-gate 	if (vp->v_type != VLNK) {
35947c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
3595*f3b585ceSsamf 		goto out;
35967c478bd9Sstevel@tonic-gate 	}
35977c478bd9Sstevel@tonic-gate 
35987c478bd9Sstevel@tonic-gate 	va.va_mask = AT_MODE;
3599da6c28aaSamw 	error = VOP_GETATTR(vp, &va, 0, cs->cr, NULL);
36007c478bd9Sstevel@tonic-gate 	if (error) {
36017c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
3602*f3b585ceSsamf 		goto out;
36037c478bd9Sstevel@tonic-gate 	}
36047c478bd9Sstevel@tonic-gate 
36057c478bd9Sstevel@tonic-gate 	if (MANDLOCK(vp, va.va_mode)) {
36067c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
3607*f3b585ceSsamf 		goto out;
36087c478bd9Sstevel@tonic-gate 	}
36097c478bd9Sstevel@tonic-gate 
36107c478bd9Sstevel@tonic-gate 	data = kmem_alloc(MAXPATHLEN + 1, KM_SLEEP);
36117c478bd9Sstevel@tonic-gate 
36127c478bd9Sstevel@tonic-gate 	iov.iov_base = data;
36137c478bd9Sstevel@tonic-gate 	iov.iov_len = MAXPATHLEN;
36147c478bd9Sstevel@tonic-gate 	uio.uio_iov = &iov;
36157c478bd9Sstevel@tonic-gate 	uio.uio_iovcnt = 1;
36167c478bd9Sstevel@tonic-gate 	uio.uio_segflg = UIO_SYSSPACE;
36177c478bd9Sstevel@tonic-gate 	uio.uio_extflg = UIO_COPY_CACHED;
36187c478bd9Sstevel@tonic-gate 	uio.uio_loffset = 0;
36197c478bd9Sstevel@tonic-gate 	uio.uio_resid = MAXPATHLEN;
36207c478bd9Sstevel@tonic-gate 
3621da6c28aaSamw 	error = VOP_READLINK(vp, &uio, cs->cr, NULL);
36227c478bd9Sstevel@tonic-gate 
36237c478bd9Sstevel@tonic-gate 	if (error) {
36247c478bd9Sstevel@tonic-gate 		kmem_free((caddr_t)data, (uint_t)MAXPATHLEN + 1);
36257c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
3626*f3b585ceSsamf 		goto out;
36277c478bd9Sstevel@tonic-gate 	}
36287c478bd9Sstevel@tonic-gate 
36297c478bd9Sstevel@tonic-gate 	*(data + MAXPATHLEN - uio.uio_resid) = '\0';
36307c478bd9Sstevel@tonic-gate 
36317c478bd9Sstevel@tonic-gate 	/*
36327c478bd9Sstevel@tonic-gate 	 * treat link name as data
36337c478bd9Sstevel@tonic-gate 	 */
36347c478bd9Sstevel@tonic-gate 	(void) str_to_utf8(data, &resp->link);
36357c478bd9Sstevel@tonic-gate 
36367c478bd9Sstevel@tonic-gate 	kmem_free((caddr_t)data, (uint_t)MAXPATHLEN + 1);
36377c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
3638*f3b585ceSsamf 
3639*f3b585ceSsamf out:
3640*f3b585ceSsamf 	DTRACE_NFSV4_2(op__readlink__done, struct compound_state *, cs,
3641*f3b585ceSsamf 	    READLINK4res *, resp);
36427c478bd9Sstevel@tonic-gate }
36437c478bd9Sstevel@tonic-gate 
36447c478bd9Sstevel@tonic-gate static void
36457c478bd9Sstevel@tonic-gate rfs4_op_readlink_free(nfs_resop4 *resop)
36467c478bd9Sstevel@tonic-gate {
36477c478bd9Sstevel@tonic-gate 	READLINK4res *resp = &resop->nfs_resop4_u.opreadlink;
36487c478bd9Sstevel@tonic-gate 	utf8string *symlink = &resp->link;
36497c478bd9Sstevel@tonic-gate 
36507c478bd9Sstevel@tonic-gate 	if (symlink->utf8string_val) {
36517c478bd9Sstevel@tonic-gate 		UTF8STRING_FREE(*symlink)
36527c478bd9Sstevel@tonic-gate 	}
36537c478bd9Sstevel@tonic-gate }
36547c478bd9Sstevel@tonic-gate 
36557c478bd9Sstevel@tonic-gate /*
36567c478bd9Sstevel@tonic-gate  * release_lockowner:
36577c478bd9Sstevel@tonic-gate  *	Release any state associated with the supplied
36587c478bd9Sstevel@tonic-gate  *	lockowner. Note if any lo_state is holding locks we will not
36597c478bd9Sstevel@tonic-gate  *	rele that lo_state and thus the lockowner will not be destroyed.
36607c478bd9Sstevel@tonic-gate  *	A client using lock after the lock owner stateid has been released
36617c478bd9Sstevel@tonic-gate  *	will suffer the consequence of NFS4ERR_BAD_STATEID and would have
36627c478bd9Sstevel@tonic-gate  *	to reissue the lock with new_lock_owner set to TRUE.
36637c478bd9Sstevel@tonic-gate  *	args: lock_owner
36647c478bd9Sstevel@tonic-gate  *	res:  status
36657c478bd9Sstevel@tonic-gate  */
36667c478bd9Sstevel@tonic-gate /* ARGSUSED */
36677c478bd9Sstevel@tonic-gate static void
36687c478bd9Sstevel@tonic-gate rfs4_op_release_lockowner(nfs_argop4 *argop, nfs_resop4 *resop,
36697c478bd9Sstevel@tonic-gate 	struct svc_req *req, struct compound_state *cs)
36707c478bd9Sstevel@tonic-gate {
36717c478bd9Sstevel@tonic-gate 	RELEASE_LOCKOWNER4args *ap = &argop->nfs_argop4_u.oprelease_lockowner;
36727c478bd9Sstevel@tonic-gate 	RELEASE_LOCKOWNER4res *resp = &resop->nfs_resop4_u.oprelease_lockowner;
36737c478bd9Sstevel@tonic-gate 	rfs4_lockowner_t *lo;
36747c478bd9Sstevel@tonic-gate 	rfs4_openowner_t *oop;
36757c478bd9Sstevel@tonic-gate 	rfs4_state_t *sp;
36767c478bd9Sstevel@tonic-gate 	rfs4_lo_state_t *lsp;
36777c478bd9Sstevel@tonic-gate 	rfs4_client_t *cp;
36787c478bd9Sstevel@tonic-gate 	bool_t create = FALSE;
36797c478bd9Sstevel@tonic-gate 	locklist_t *llist;
36807c478bd9Sstevel@tonic-gate 	sysid_t sysid;
36817c478bd9Sstevel@tonic-gate 
3682*f3b585ceSsamf 	DTRACE_NFSV4_2(op__release__lockowner__start, struct compound_state *,
3683*f3b585ceSsamf 	    cs, RELEASE_LOCKOWNER4args *, ap);
3684*f3b585ceSsamf 
36857c478bd9Sstevel@tonic-gate 	/* Make sure there is a clientid around for this request */
36867c478bd9Sstevel@tonic-gate 	cp = rfs4_findclient_by_id(ap->lock_owner.clientid, FALSE);
36877c478bd9Sstevel@tonic-gate 
36887c478bd9Sstevel@tonic-gate 	if (cp == NULL) {
36897c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status =
36901b300de9Sjwahlig 		    rfs4_check_clientid(&ap->lock_owner.clientid, 0);
3691*f3b585ceSsamf 		goto out;
36927c478bd9Sstevel@tonic-gate 	}
36937c478bd9Sstevel@tonic-gate 	rfs4_client_rele(cp);
36947c478bd9Sstevel@tonic-gate 
36957c478bd9Sstevel@tonic-gate 	lo = rfs4_findlockowner(&ap->lock_owner, &create);
36967c478bd9Sstevel@tonic-gate 	if (lo == NULL) {
36977c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4_OK;
3698*f3b585ceSsamf 		goto out;
36997c478bd9Sstevel@tonic-gate 	}
37007c478bd9Sstevel@tonic-gate 	ASSERT(lo->client != NULL);
37017c478bd9Sstevel@tonic-gate 
37027c478bd9Sstevel@tonic-gate 	/*
37037c478bd9Sstevel@tonic-gate 	 * Check for EXPIRED client. If so will reap state with in a lease
37047c478bd9Sstevel@tonic-gate 	 * period or on next set_clientid_confirm step
37057c478bd9Sstevel@tonic-gate 	 */
37067c478bd9Sstevel@tonic-gate 	if (rfs4_lease_expired(lo->client)) {
37077c478bd9Sstevel@tonic-gate 		rfs4_lockowner_rele(lo);
37087c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
3709*f3b585ceSsamf 		goto out;
37107c478bd9Sstevel@tonic-gate 	}
37117c478bd9Sstevel@tonic-gate 
37127c478bd9Sstevel@tonic-gate 	/*
37137c478bd9Sstevel@tonic-gate 	 * If no sysid has been assigned, then no locks exist; just return.
37147c478bd9Sstevel@tonic-gate 	 */
37157c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(lo->client->dbe);
37167c478bd9Sstevel@tonic-gate 	if (lo->client->sysidt == LM_NOSYSID) {
37177c478bd9Sstevel@tonic-gate 		rfs4_lockowner_rele(lo);
37187c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(lo->client->dbe);
3719*f3b585ceSsamf 		goto out;
37207c478bd9Sstevel@tonic-gate 	}
37217c478bd9Sstevel@tonic-gate 
37227c478bd9Sstevel@tonic-gate 	sysid = lo->client->sysidt;
37237c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(lo->client->dbe);
37247c478bd9Sstevel@tonic-gate 
37257c478bd9Sstevel@tonic-gate 	/*
37267c478bd9Sstevel@tonic-gate 	 * Mark the lockowner invalid.
37277c478bd9Sstevel@tonic-gate 	 */
37287c478bd9Sstevel@tonic-gate 	rfs4_dbe_hide(lo->dbe);
37297c478bd9Sstevel@tonic-gate 
37307c478bd9Sstevel@tonic-gate 	/*
37317c478bd9Sstevel@tonic-gate 	 * sysid-pid pair should now not be used since the lockowner is
37327c478bd9Sstevel@tonic-gate 	 * invalid. If the client were to instantiate the lockowner again
37337c478bd9Sstevel@tonic-gate 	 * it would be assigned a new pid. Thus we can get the list of
37347c478bd9Sstevel@tonic-gate 	 * current locks.
37357c478bd9Sstevel@tonic-gate 	 */
37367c478bd9Sstevel@tonic-gate 
37377c478bd9Sstevel@tonic-gate 	llist = flk_get_active_locks(sysid, lo->pid);
37387c478bd9Sstevel@tonic-gate 	/* If we are still holding locks fail */
37397c478bd9Sstevel@tonic-gate 	if (llist != NULL) {
37407c478bd9Sstevel@tonic-gate 
37417c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_LOCKS_HELD;
37427c478bd9Sstevel@tonic-gate 
37437c478bd9Sstevel@tonic-gate 		flk_free_locklist(llist);
37447c478bd9Sstevel@tonic-gate 		/*
37457c478bd9Sstevel@tonic-gate 		 * We need to unhide the lockowner so the client can
37467c478bd9Sstevel@tonic-gate 		 * try it again. The bad thing here is if the client
37477c478bd9Sstevel@tonic-gate 		 * has a logic error that took it here in the first place
37487c478bd9Sstevel@tonic-gate 		 * he probably has lost accounting of the locks that it
37497c478bd9Sstevel@tonic-gate 		 * is holding. So we may have dangling state until the
37507c478bd9Sstevel@tonic-gate 		 * open owner state is reaped via close. One scenario
37517c478bd9Sstevel@tonic-gate 		 * that could possibly occur is that the client has
37527c478bd9Sstevel@tonic-gate 		 * sent the unlock request(s) in separate threads
37537c478bd9Sstevel@tonic-gate 		 * and has not waited for the replies before sending the
37547c478bd9Sstevel@tonic-gate 		 * RELEASE_LOCKOWNER request. Presumably, it would expect
37557c478bd9Sstevel@tonic-gate 		 * and deal appropriately with NFS4ERR_LOCKS_HELD, by
37567c478bd9Sstevel@tonic-gate 		 * reissuing the request.
37577c478bd9Sstevel@tonic-gate 		 */
37587c478bd9Sstevel@tonic-gate 		rfs4_dbe_unhide(lo->dbe);
37597c478bd9Sstevel@tonic-gate 		rfs4_lockowner_rele(lo);
3760*f3b585ceSsamf 		goto out;
37617c478bd9Sstevel@tonic-gate 	}
37627c478bd9Sstevel@tonic-gate 
37637c478bd9Sstevel@tonic-gate 	/*
37647c478bd9Sstevel@tonic-gate 	 * For the corresponding client we need to check each open
37657c478bd9Sstevel@tonic-gate 	 * owner for any opens that have lockowner state associated
37667c478bd9Sstevel@tonic-gate 	 * with this lockowner.
37677c478bd9Sstevel@tonic-gate 	 */
37687c478bd9Sstevel@tonic-gate 
37697c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(lo->client->dbe);
37707c478bd9Sstevel@tonic-gate 	for (oop = lo->client->openownerlist.next->oop; oop != NULL;
37717c478bd9Sstevel@tonic-gate 	    oop = oop->openownerlist.next->oop) {
37727c478bd9Sstevel@tonic-gate 
37737c478bd9Sstevel@tonic-gate 		rfs4_dbe_lock(oop->dbe);
37747c478bd9Sstevel@tonic-gate 		for (sp = oop->ownerstateids.next->sp; sp != NULL;
37757c478bd9Sstevel@tonic-gate 		    sp = sp->ownerstateids.next->sp) {
37767c478bd9Sstevel@tonic-gate 
37777c478bd9Sstevel@tonic-gate 			rfs4_dbe_lock(sp->dbe);
37787c478bd9Sstevel@tonic-gate 			for (lsp = sp->lockownerlist.next->lsp;
37797c478bd9Sstevel@tonic-gate 			    lsp != NULL; lsp = lsp->lockownerlist.next->lsp) {
37807c478bd9Sstevel@tonic-gate 				if (lsp->locker == lo) {
37817c478bd9Sstevel@tonic-gate 					rfs4_dbe_lock(lsp->dbe);
37827c478bd9Sstevel@tonic-gate 					rfs4_dbe_invalidate(lsp->dbe);
37837c478bd9Sstevel@tonic-gate 					rfs4_dbe_unlock(lsp->dbe);
37847c478bd9Sstevel@tonic-gate 				}
37857c478bd9Sstevel@tonic-gate 			}
37867c478bd9Sstevel@tonic-gate 			rfs4_dbe_unlock(sp->dbe);
37877c478bd9Sstevel@tonic-gate 		}
37887c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(oop->dbe);
37897c478bd9Sstevel@tonic-gate 	}
37907c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(lo->client->dbe);
37917c478bd9Sstevel@tonic-gate 
37927c478bd9Sstevel@tonic-gate 	rfs4_lockowner_rele(lo);
37937c478bd9Sstevel@tonic-gate 
37947c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
3795*f3b585ceSsamf 
3796*f3b585ceSsamf out:
3797*f3b585ceSsamf 	DTRACE_NFSV4_2(op__release__lockowner__done, struct compound_state *,
3798*f3b585ceSsamf 	    cs, RELEASE_LOCKOWNER4res *, resp);
37997c478bd9Sstevel@tonic-gate }
38007c478bd9Sstevel@tonic-gate 
38017c478bd9Sstevel@tonic-gate /*
38027c478bd9Sstevel@tonic-gate  * short utility function to lookup a file and recall the delegation
38037c478bd9Sstevel@tonic-gate  */
38047c478bd9Sstevel@tonic-gate static rfs4_file_t *
38057c478bd9Sstevel@tonic-gate rfs4_lookup_and_findfile(vnode_t *dvp, char *nm, vnode_t **vpp,
38067c478bd9Sstevel@tonic-gate 	int *lkup_error, cred_t *cr)
38077c478bd9Sstevel@tonic-gate {
38087c478bd9Sstevel@tonic-gate 	vnode_t *vp;
38097c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp = NULL;
38107c478bd9Sstevel@tonic-gate 	bool_t fcreate = FALSE;
38117c478bd9Sstevel@tonic-gate 	int error;
38127c478bd9Sstevel@tonic-gate 
38137c478bd9Sstevel@tonic-gate 	if (vpp)
38147c478bd9Sstevel@tonic-gate 		*vpp = NULL;
38157c478bd9Sstevel@tonic-gate 
3816da6c28aaSamw 	if ((error = VOP_LOOKUP(dvp, nm, &vp, NULL, 0, NULL, cr, NULL, NULL,
3817da6c28aaSamw 	    NULL)) == 0) {
38187c478bd9Sstevel@tonic-gate 		if (vp->v_type == VREG)
38197c478bd9Sstevel@tonic-gate 			fp = rfs4_findfile(vp, NULL, &fcreate);
38207c478bd9Sstevel@tonic-gate 		if (vpp)
38217c478bd9Sstevel@tonic-gate 			*vpp = vp;
38227c478bd9Sstevel@tonic-gate 		else
38237c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
38247c478bd9Sstevel@tonic-gate 	}
38257c478bd9Sstevel@tonic-gate 
38267c478bd9Sstevel@tonic-gate 	if (lkup_error)
38277c478bd9Sstevel@tonic-gate 		*lkup_error = error;
38287c478bd9Sstevel@tonic-gate 
38297c478bd9Sstevel@tonic-gate 	return (fp);
38307c478bd9Sstevel@tonic-gate }
38317c478bd9Sstevel@tonic-gate 
38327c478bd9Sstevel@tonic-gate /*
38337c478bd9Sstevel@tonic-gate  * remove: args: CURRENT_FH: directory; name.
38347c478bd9Sstevel@tonic-gate  *	res: status. If success - CURRENT_FH unchanged, return change_info
38357c478bd9Sstevel@tonic-gate  *		for directory.
38367c478bd9Sstevel@tonic-gate  */
38377c478bd9Sstevel@tonic-gate /* ARGSUSED */
38387c478bd9Sstevel@tonic-gate static void
38397c478bd9Sstevel@tonic-gate rfs4_op_remove(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
38407c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
38417c478bd9Sstevel@tonic-gate {
38427c478bd9Sstevel@tonic-gate 	REMOVE4args *args = &argop->nfs_argop4_u.opremove;
38437c478bd9Sstevel@tonic-gate 	REMOVE4res *resp = &resop->nfs_resop4_u.opremove;
38447c478bd9Sstevel@tonic-gate 	int error;
38457c478bd9Sstevel@tonic-gate 	vnode_t *dvp, *vp;
38467c478bd9Sstevel@tonic-gate 	struct vattr bdva, idva, adva;
38477c478bd9Sstevel@tonic-gate 	char *nm;
38487c478bd9Sstevel@tonic-gate 	uint_t len;
38497c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp;
38507c478bd9Sstevel@tonic-gate 	int in_crit = 0;
385145916cd2Sjpk 	bslabel_t *clabel;
38527c478bd9Sstevel@tonic-gate 
3853*f3b585ceSsamf 	DTRACE_NFSV4_2(op__remove__start, struct compound_state *, cs,
3854*f3b585ceSsamf 	    REMOVE4args *, args);
3855*f3b585ceSsamf 
38567c478bd9Sstevel@tonic-gate 	/* CURRENT_FH: directory */
38577c478bd9Sstevel@tonic-gate 	dvp = cs->vp;
38587c478bd9Sstevel@tonic-gate 	if (dvp == NULL) {
38597c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
3860*f3b585ceSsamf 		goto out;
38617c478bd9Sstevel@tonic-gate 	}
38627c478bd9Sstevel@tonic-gate 
38637c478bd9Sstevel@tonic-gate 	if (cs->access == CS_ACCESS_DENIED) {
38647c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
3865*f3b585ceSsamf 		goto out;
38667c478bd9Sstevel@tonic-gate 	}
38677c478bd9Sstevel@tonic-gate 
38687c478bd9Sstevel@tonic-gate 	/*
38697c478bd9Sstevel@tonic-gate 	 * If there is an unshared filesystem mounted on this vnode,
38707c478bd9Sstevel@tonic-gate 	 * Do not allow to remove anything in this directory.
38717c478bd9Sstevel@tonic-gate 	 */
38727c478bd9Sstevel@tonic-gate 	if (vn_ismntpt(dvp)) {
38737c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
3874*f3b585ceSsamf 		goto out;
38757c478bd9Sstevel@tonic-gate 	}
38767c478bd9Sstevel@tonic-gate 
38777c478bd9Sstevel@tonic-gate 	if (dvp->v_type != VDIR) {
38787c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
3879*f3b585ceSsamf 		goto out;
38807c478bd9Sstevel@tonic-gate 	}
38817c478bd9Sstevel@tonic-gate 
38827c478bd9Sstevel@tonic-gate 	if (!utf8_dir_verify(&args->target)) {
38837c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
3884*f3b585ceSsamf 		goto out;
38857c478bd9Sstevel@tonic-gate 	}
38867c478bd9Sstevel@tonic-gate 
38877c478bd9Sstevel@tonic-gate 	/*
38887c478bd9Sstevel@tonic-gate 	 * Lookup the file so that we can check if it's a directory
38897c478bd9Sstevel@tonic-gate 	 */
38907c478bd9Sstevel@tonic-gate 	nm = utf8_to_fn(&args->target, &len, NULL);
38917c478bd9Sstevel@tonic-gate 	if (nm == NULL) {
38927c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
3893*f3b585ceSsamf 		goto out;
38947c478bd9Sstevel@tonic-gate 	}
38957c478bd9Sstevel@tonic-gate 
38967c478bd9Sstevel@tonic-gate 	if (len > MAXNAMELEN) {
38977c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
38987c478bd9Sstevel@tonic-gate 		kmem_free(nm, len);
3899*f3b585ceSsamf 		goto out;
39007c478bd9Sstevel@tonic-gate 	}
39017c478bd9Sstevel@tonic-gate 
39027c478bd9Sstevel@tonic-gate 	if (rdonly4(cs->exi, cs->vp, req)) {
39037c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ROFS;
39047c478bd9Sstevel@tonic-gate 		kmem_free(nm, len);
3905*f3b585ceSsamf 		goto out;
39067c478bd9Sstevel@tonic-gate 	}
39077c478bd9Sstevel@tonic-gate 
39087c478bd9Sstevel@tonic-gate 	/*
39097c478bd9Sstevel@tonic-gate 	 * Lookup the file to determine type and while we are see if
39107c478bd9Sstevel@tonic-gate 	 * there is a file struct around and check for delegation.
39117c478bd9Sstevel@tonic-gate 	 * We don't need to acquire va_seq before this lookup, if
39127c478bd9Sstevel@tonic-gate 	 * it causes an update, cinfo.before will not match, which will
39137c478bd9Sstevel@tonic-gate 	 * trigger a cache flush even if atomic is TRUE.
39147c478bd9Sstevel@tonic-gate 	 */
39157c478bd9Sstevel@tonic-gate 	if (fp = rfs4_lookup_and_findfile(dvp, nm, &vp, &error, cs->cr)) {
39167c478bd9Sstevel@tonic-gate 		if (rfs4_check_delegated_byfp(FWRITE, fp, TRUE, TRUE, TRUE,
39171b300de9Sjwahlig 		    NULL)) {
39187c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
39197c478bd9Sstevel@tonic-gate 			rfs4_file_rele(fp);
39207c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_DELAY;
39217c478bd9Sstevel@tonic-gate 			kmem_free(nm, len);
3922*f3b585ceSsamf 			goto out;
39237c478bd9Sstevel@tonic-gate 		}
39247c478bd9Sstevel@tonic-gate 	}
39257c478bd9Sstevel@tonic-gate 
39267c478bd9Sstevel@tonic-gate 	/* Didn't find anything to remove */
39277c478bd9Sstevel@tonic-gate 	if (vp == NULL) {
39287c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = error;
39297c478bd9Sstevel@tonic-gate 		kmem_free(nm, len);
3930*f3b585ceSsamf 		goto out;
39317c478bd9Sstevel@tonic-gate 	}
39327c478bd9Sstevel@tonic-gate 
39337c478bd9Sstevel@tonic-gate 	if (nbl_need_check(vp)) {
39347c478bd9Sstevel@tonic-gate 		nbl_start_crit(vp, RW_READER);
39357c478bd9Sstevel@tonic-gate 		in_crit = 1;
3936da6c28aaSamw 		if (nbl_conflict(vp, NBL_REMOVE, 0, 0, 0, NULL)) {
39377c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_FILE_OPEN;
39387c478bd9Sstevel@tonic-gate 			kmem_free(nm, len);
39397c478bd9Sstevel@tonic-gate 			nbl_end_crit(vp);
39407c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
39417c478bd9Sstevel@tonic-gate 			if (fp) {
39427c478bd9Sstevel@tonic-gate 				rfs4_clear_dont_grant(fp);
39437c478bd9Sstevel@tonic-gate 				rfs4_file_rele(fp);
39447c478bd9Sstevel@tonic-gate 			}
3945*f3b585ceSsamf 			goto out;
39467c478bd9Sstevel@tonic-gate 		}
39477c478bd9Sstevel@tonic-gate 	}
39487c478bd9Sstevel@tonic-gate 
394945916cd2Sjpk 	/* check label before allowing removal */
395045916cd2Sjpk 	if (is_system_labeled()) {
395145916cd2Sjpk 		ASSERT(req->rq_label != NULL);
395245916cd2Sjpk 		clabel = req->rq_label;
395345916cd2Sjpk 		DTRACE_PROBE2(tx__rfs4__log__info__opremove__clabel, char *,
395445916cd2Sjpk 		    "got client label from request(1)",
395545916cd2Sjpk 		    struct svc_req *, req);
395645916cd2Sjpk 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
395703986916Sjarrett 			if (!do_rfs_label_check(clabel, vp, EQUALITY_CHECK)) {
395845916cd2Sjpk 				*cs->statusp = resp->status = NFS4ERR_ACCESS;
395945916cd2Sjpk 				kmem_free(nm, len);
396045916cd2Sjpk 				if (in_crit)
396145916cd2Sjpk 					nbl_end_crit(vp);
396245916cd2Sjpk 				VN_RELE(vp);
396345916cd2Sjpk 				if (fp) {
396445916cd2Sjpk 					rfs4_clear_dont_grant(fp);
396545916cd2Sjpk 					rfs4_file_rele(fp);
396645916cd2Sjpk 				}
3967*f3b585ceSsamf 				goto out;
396845916cd2Sjpk 			}
396945916cd2Sjpk 		}
397045916cd2Sjpk 	}
397145916cd2Sjpk 
39727c478bd9Sstevel@tonic-gate 	/* Get dir "before" change value */
39737c478bd9Sstevel@tonic-gate 	bdva.va_mask = AT_CTIME|AT_SEQ;
3974da6c28aaSamw 	error = VOP_GETATTR(dvp, &bdva, 0, cs->cr, NULL);
39757c478bd9Sstevel@tonic-gate 	if (error) {
39767c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
39777c478bd9Sstevel@tonic-gate 		kmem_free(nm, len);
3978*f3b585ceSsamf 		goto out;
39797c478bd9Sstevel@tonic-gate 	}
39807c478bd9Sstevel@tonic-gate 	NFS4_SET_FATTR4_CHANGE(resp->cinfo.before, bdva.va_ctime)
39817c478bd9Sstevel@tonic-gate 
39827c478bd9Sstevel@tonic-gate 	/* Actually do the REMOVE operation */
39837c478bd9Sstevel@tonic-gate 	if (vp->v_type == VDIR) {
39847c478bd9Sstevel@tonic-gate 		/*
39857c478bd9Sstevel@tonic-gate 		 * Can't remove a directory that has a mounted-on filesystem.
39867c478bd9Sstevel@tonic-gate 		 */
39877c478bd9Sstevel@tonic-gate 		if (vn_ismntpt(vp)) {
39887c478bd9Sstevel@tonic-gate 			error = EACCES;
39897c478bd9Sstevel@tonic-gate 		} else {
39907c478bd9Sstevel@tonic-gate 			/*
39917c478bd9Sstevel@tonic-gate 			 * System V defines rmdir to return EEXIST,
39927c478bd9Sstevel@tonic-gate 			 * not * ENOTEMPTY, if the directory is not
39937c478bd9Sstevel@tonic-gate 			 * empty.  A System V NFS server needs to map
39947c478bd9Sstevel@tonic-gate 			 * NFS4ERR_EXIST to NFS4ERR_NOTEMPTY to
39957c478bd9Sstevel@tonic-gate 			 * transmit over the wire.
39967c478bd9Sstevel@tonic-gate 			 */
3997da6c28aaSamw 			if ((error = VOP_RMDIR(dvp, nm, rootdir, cs->cr,
3998da6c28aaSamw 			    NULL, 0)) == EEXIST)
39997c478bd9Sstevel@tonic-gate 				error = ENOTEMPTY;
40007c478bd9Sstevel@tonic-gate 		}
40017c478bd9Sstevel@tonic-gate 	} else {
4002da6c28aaSamw 		if ((error = VOP_REMOVE(dvp, nm, cs->cr, NULL, 0)) == 0 &&
40031b300de9Sjwahlig 		    fp != NULL) {
40047c478bd9Sstevel@tonic-gate 			struct vattr va;
4005418d27f3Sshepler 			vnode_t *tvp;
40067c478bd9Sstevel@tonic-gate 
4007418d27f3Sshepler 			rfs4_dbe_lock(fp->dbe);
4008418d27f3Sshepler 			tvp = fp->vp;
4009418d27f3Sshepler 			if (tvp)
4010418d27f3Sshepler 				VN_HOLD(tvp);
4011418d27f3Sshepler 			rfs4_dbe_unlock(fp->dbe);
4012418d27f3Sshepler 
4013418d27f3Sshepler 			if (tvp) {
4014418d27f3Sshepler 				/*
4015418d27f3Sshepler 				 * This is va_seq safe because we are not
4016418d27f3Sshepler 				 * manipulating dvp.
4017418d27f3Sshepler 				 */
4018418d27f3Sshepler 				va.va_mask = AT_NLINK;
4019da6c28aaSamw 				if (!VOP_GETATTR(tvp, &va, 0, cs->cr, NULL) &&
40201b300de9Sjwahlig 				    va.va_nlink == 0) {
4021418d27f3Sshepler 					/* Remove state on file remove */
4022418d27f3Sshepler 					if (in_crit) {
4023418d27f3Sshepler 						nbl_end_crit(vp);
4024418d27f3Sshepler 						in_crit = 0;
4025418d27f3Sshepler 					}
4026418d27f3Sshepler 					rfs4_close_all_state(fp);
40277c478bd9Sstevel@tonic-gate 				}
4028418d27f3Sshepler 				VN_RELE(tvp);
40297c478bd9Sstevel@tonic-gate 			}
40307c478bd9Sstevel@tonic-gate 		}
40317c478bd9Sstevel@tonic-gate 	}
40327c478bd9Sstevel@tonic-gate 
40337c478bd9Sstevel@tonic-gate 	if (in_crit)
40347c478bd9Sstevel@tonic-gate 		nbl_end_crit(vp);
40357c478bd9Sstevel@tonic-gate 	VN_RELE(vp);
40367c478bd9Sstevel@tonic-gate 
40377c478bd9Sstevel@tonic-gate 	if (fp) {
40387c478bd9Sstevel@tonic-gate 		rfs4_clear_dont_grant(fp);
40397c478bd9Sstevel@tonic-gate 		rfs4_file_rele(fp);
40407c478bd9Sstevel@tonic-gate 	}
40417c478bd9Sstevel@tonic-gate 	kmem_free(nm, len);
40427c478bd9Sstevel@tonic-gate 
40437c478bd9Sstevel@tonic-gate 	if (error) {
40447c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
4045*f3b585ceSsamf 		goto out;
40467c478bd9Sstevel@tonic-gate 	}
40477c478bd9Sstevel@tonic-gate 
40487c478bd9Sstevel@tonic-gate 	/*
40497c478bd9Sstevel@tonic-gate 	 * Get the initial "after" sequence number, if it fails, set to zero
40507c478bd9Sstevel@tonic-gate 	 */
40517c478bd9Sstevel@tonic-gate 	idva.va_mask = AT_SEQ;
4052da6c28aaSamw 	if (VOP_GETATTR(dvp, &idva, 0, cs->cr, NULL))
40537c478bd9Sstevel@tonic-gate 		idva.va_seq = 0;
40547c478bd9Sstevel@tonic-gate 
40557c478bd9Sstevel@tonic-gate 	/*
40567c478bd9Sstevel@tonic-gate 	 * Force modified data and metadata out to stable storage.
40577c478bd9Sstevel@tonic-gate 	 */
4058da6c28aaSamw 	(void) VOP_FSYNC(dvp, 0, cs->cr, NULL);
40597c478bd9Sstevel@tonic-gate 
40607c478bd9Sstevel@tonic-gate 	/*
40617c478bd9Sstevel@tonic-gate 	 * Get "after" change value, if it fails, simply return the
40627c478bd9Sstevel@tonic-gate 	 * before value.
40637c478bd9Sstevel@tonic-gate 	 */
40647c478bd9Sstevel@tonic-gate 	adva.va_mask = AT_CTIME|AT_SEQ;
4065da6c28aaSamw 	if (VOP_GETATTR(dvp, &adva, 0, cs->cr, NULL)) {
40667c478bd9Sstevel@tonic-gate 		adva.va_ctime = bdva.va_ctime;
40677c478bd9Sstevel@tonic-gate 		adva.va_seq = 0;
40687c478bd9Sstevel@tonic-gate 	}
40697c478bd9Sstevel@tonic-gate 
40707c478bd9Sstevel@tonic-gate 	NFS4_SET_FATTR4_CHANGE(resp->cinfo.after, adva.va_ctime)
40717c478bd9Sstevel@tonic-gate 
40727c478bd9Sstevel@tonic-gate 	/*
40737c478bd9Sstevel@tonic-gate 	 * The cinfo.atomic = TRUE only if we have
40747c478bd9Sstevel@tonic-gate 	 * non-zero va_seq's, and it has incremented by exactly one
40757c478bd9Sstevel@tonic-gate 	 * during the VOP_REMOVE/RMDIR and it didn't change during
40767c478bd9Sstevel@tonic-gate 	 * the VOP_FSYNC.
40777c478bd9Sstevel@tonic-gate 	 */
40787c478bd9Sstevel@tonic-gate 	if (bdva.va_seq && idva.va_seq && adva.va_seq &&
40791b300de9Sjwahlig 	    idva.va_seq == (bdva.va_seq + 1) && idva.va_seq == adva.va_seq)
40807c478bd9Sstevel@tonic-gate 		resp->cinfo.atomic = TRUE;
40817c478bd9Sstevel@tonic-gate 	else
40827c478bd9Sstevel@tonic-gate 		resp->cinfo.atomic = FALSE;
40837c478bd9Sstevel@tonic-gate 
40847c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
4085*f3b585ceSsamf 
4086*f3b585ceSsamf out:
4087*f3b585ceSsamf 	DTRACE_NFSV4_2(op__remove__done, struct compound_state *, cs,
4088*f3b585ceSsamf 	    REMOVE4res *, resp);
40897c478bd9Sstevel@tonic-gate }
40907c478bd9Sstevel@tonic-gate 
40917c478bd9Sstevel@tonic-gate /*
40927c478bd9Sstevel@tonic-gate  * rename: args: SAVED_FH: from directory, CURRENT_FH: target directory,
40937c478bd9Sstevel@tonic-gate  *		oldname and newname.
40947c478bd9Sstevel@tonic-gate  *	res: status. If success - CURRENT_FH unchanged, return change_info
40957c478bd9Sstevel@tonic-gate  *		for both from and target directories.
40967c478bd9Sstevel@tonic-gate  */
40977c478bd9Sstevel@tonic-gate /* ARGSUSED */
40987c478bd9Sstevel@tonic-gate static void
40997c478bd9Sstevel@tonic-gate rfs4_op_rename(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
41007c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
41017c478bd9Sstevel@tonic-gate {
41027c478bd9Sstevel@tonic-gate 	RENAME4args *args = &argop->nfs_argop4_u.oprename;
41037c478bd9Sstevel@tonic-gate 	RENAME4res *resp = &resop->nfs_resop4_u.oprename;
41047c478bd9Sstevel@tonic-gate 	int error;
41057c478bd9Sstevel@tonic-gate 	vnode_t *odvp;
41067c478bd9Sstevel@tonic-gate 	vnode_t *ndvp;
41077c478bd9Sstevel@tonic-gate 	vnode_t *srcvp, *targvp;
41087c478bd9Sstevel@tonic-gate 	struct vattr obdva, oidva, oadva;
41097c478bd9Sstevel@tonic-gate 	struct vattr nbdva, nidva, nadva;
41107c478bd9Sstevel@tonic-gate 	char *onm, *nnm;
41117c478bd9Sstevel@tonic-gate 	uint_t olen, nlen;
41127c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp, *sfp;
41137c478bd9Sstevel@tonic-gate 	int in_crit_src, in_crit_targ;
41147c478bd9Sstevel@tonic-gate 	int fp_rele_grant_hold, sfp_rele_grant_hold;
411545916cd2Sjpk 	bslabel_t *clabel;
41167c478bd9Sstevel@tonic-gate 
4117*f3b585ceSsamf 	DTRACE_NFSV4_2(op__rename__start, struct compound_state *, cs,
4118*f3b585ceSsamf 	    RENAME4args *, args);
4119*f3b585ceSsamf 
41207c478bd9Sstevel@tonic-gate 	fp = sfp = NULL;
41217c478bd9Sstevel@tonic-gate 	srcvp = targvp = NULL;
41227c478bd9Sstevel@tonic-gate 	in_crit_src = in_crit_targ = 0;
41237c478bd9Sstevel@tonic-gate 	fp_rele_grant_hold = sfp_rele_grant_hold = 0;
41247c478bd9Sstevel@tonic-gate 
41257c478bd9Sstevel@tonic-gate 	/* CURRENT_FH: target directory */
41267c478bd9Sstevel@tonic-gate 	ndvp = cs->vp;
41277c478bd9Sstevel@tonic-gate 	if (ndvp == NULL) {
41287c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
4129*f3b585ceSsamf 		goto out;
41307c478bd9Sstevel@tonic-gate 	}
41317c478bd9Sstevel@tonic-gate 
41327c478bd9Sstevel@tonic-gate 	/* SAVED_FH: from directory */
41337c478bd9Sstevel@tonic-gate 	odvp = cs->saved_vp;
41347c478bd9Sstevel@tonic-gate 	if (odvp == NULL) {
41357c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
4136*f3b585ceSsamf 		goto out;
41377c478bd9Sstevel@tonic-gate 	}
41387c478bd9Sstevel@tonic-gate 
41397c478bd9Sstevel@tonic-gate 	if (cs->access == CS_ACCESS_DENIED) {
41407c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
4141*f3b585ceSsamf 		goto out;
41427c478bd9Sstevel@tonic-gate 	}
41437c478bd9Sstevel@tonic-gate 
41447c478bd9Sstevel@tonic-gate 	/*
41457c478bd9Sstevel@tonic-gate 	 * If there is an unshared filesystem mounted on this vnode,
41467c478bd9Sstevel@tonic-gate 	 * do not allow to rename objects in this directory.
41477c478bd9Sstevel@tonic-gate 	 */
41487c478bd9Sstevel@tonic-gate 	if (vn_ismntpt(odvp)) {
41497c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
4150*f3b585ceSsamf 		goto out;
41517c478bd9Sstevel@tonic-gate 	}
41527c478bd9Sstevel@tonic-gate 
41537c478bd9Sstevel@tonic-gate 	/*
41547c478bd9Sstevel@tonic-gate 	 * If there is an unshared filesystem mounted on this vnode,
41557c478bd9Sstevel@tonic-gate 	 * do not allow to rename to this directory.
41567c478bd9Sstevel@tonic-gate 	 */
41577c478bd9Sstevel@tonic-gate 	if (vn_ismntpt(ndvp)) {
41587c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
4159*f3b585ceSsamf 		goto out;
41607c478bd9Sstevel@tonic-gate 	}
41617c478bd9Sstevel@tonic-gate 
41627c478bd9Sstevel@tonic-gate 	if (odvp->v_type != VDIR || ndvp->v_type != VDIR) {
41637c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
4164*f3b585ceSsamf 		goto out;
41657c478bd9Sstevel@tonic-gate 	}
41667c478bd9Sstevel@tonic-gate 
41677c478bd9Sstevel@tonic-gate 	if (cs->saved_exi != cs->exi) {
41687c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_XDEV;
4169*f3b585ceSsamf 		goto out;
41707c478bd9Sstevel@tonic-gate 	}
41717c478bd9Sstevel@tonic-gate 
41727c478bd9Sstevel@tonic-gate 	if (!utf8_dir_verify(&args->oldname)) {
41737c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
4174*f3b585ceSsamf 		goto out;
41757c478bd9Sstevel@tonic-gate 	}
41767c478bd9Sstevel@tonic-gate 
41777c478bd9Sstevel@tonic-gate 	if (!utf8_dir_verify(&args->newname)) {
41787c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
4179*f3b585ceSsamf 		goto out;
41807c478bd9Sstevel@tonic-gate 	}
41817c478bd9Sstevel@tonic-gate 
41827c478bd9Sstevel@tonic-gate 	onm = utf8_to_fn(&args->oldname, &olen, NULL);
41837c478bd9Sstevel@tonic-gate 	if (onm == NULL) {
41847c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
4185*f3b585ceSsamf 		goto out;
41867c478bd9Sstevel@tonic-gate 	}
41877c478bd9Sstevel@tonic-gate 
41887c478bd9Sstevel@tonic-gate 	nnm = utf8_to_fn(&args->newname, &nlen, NULL);
41897c478bd9Sstevel@tonic-gate 	if (nnm == NULL) {
41907c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
41917c478bd9Sstevel@tonic-gate 		kmem_free(onm, olen);
4192*f3b585ceSsamf 		goto out;
41937c478bd9Sstevel@tonic-gate 	}
41947c478bd9Sstevel@tonic-gate 
41957c478bd9Sstevel@tonic-gate 	if (olen > MAXNAMELEN || nlen > MAXNAMELEN) {
41967c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
41977c478bd9Sstevel@tonic-gate 		kmem_free(onm, olen);
41987c478bd9Sstevel@tonic-gate 		kmem_free(nnm, nlen);
4199*f3b585ceSsamf 		goto out;
42007c478bd9Sstevel@tonic-gate 	}
42017c478bd9Sstevel@tonic-gate 
42027c478bd9Sstevel@tonic-gate 
42037c478bd9Sstevel@tonic-gate 	if (rdonly4(cs->exi, cs->vp, req)) {
42047c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ROFS;
42057c478bd9Sstevel@tonic-gate 		kmem_free(onm, olen);
42067c478bd9Sstevel@tonic-gate 		kmem_free(nnm, nlen);
4207*f3b585ceSsamf 		goto out;
42087c478bd9Sstevel@tonic-gate 	}
42097c478bd9Sstevel@tonic-gate 
421045916cd2Sjpk 	/* check label of the target dir */
421145916cd2Sjpk 	if (is_system_labeled()) {
421245916cd2Sjpk 		ASSERT(req->rq_label != NULL);
421345916cd2Sjpk 		clabel = req->rq_label;
421445916cd2Sjpk 		DTRACE_PROBE2(tx__rfs4__log__info__oprename__clabel, char *,
421545916cd2Sjpk 		    "got client label from request(1)",
421645916cd2Sjpk 		    struct svc_req *, req);
421745916cd2Sjpk 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
421803986916Sjarrett 			if (!do_rfs_label_check(clabel, ndvp,
421945916cd2Sjpk 			    EQUALITY_CHECK)) {
422045916cd2Sjpk 				*cs->statusp = resp->status = NFS4ERR_ACCESS;
4221*f3b585ceSsamf 				goto out;
422245916cd2Sjpk 			}
422345916cd2Sjpk 		}
422445916cd2Sjpk 	}
422545916cd2Sjpk 
42267c478bd9Sstevel@tonic-gate 	/*
42277c478bd9Sstevel@tonic-gate 	 * Is the source a file and have a delegation?
42287c478bd9Sstevel@tonic-gate 	 * We don't need to acquire va_seq before these lookups, if
42297c478bd9Sstevel@tonic-gate 	 * it causes an update, cinfo.before will not match, which will
42307c478bd9Sstevel@tonic-gate 	 * trigger a cache flush even if atomic is TRUE.
42317c478bd9Sstevel@tonic-gate 	 */
42327c478bd9Sstevel@tonic-gate 	if (sfp = rfs4_lookup_and_findfile(odvp, onm, &srcvp, &error, cs->cr)) {
42337c478bd9Sstevel@tonic-gate 		if (rfs4_check_delegated_byfp(FWRITE, sfp, TRUE, TRUE, TRUE,
42341b300de9Sjwahlig 		    NULL)) {
42357c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_DELAY;
42367c478bd9Sstevel@tonic-gate 			goto err_out;
42377c478bd9Sstevel@tonic-gate 		}
42387c478bd9Sstevel@tonic-gate 	}
42397c478bd9Sstevel@tonic-gate 
42407c478bd9Sstevel@tonic-gate 	if (srcvp == NULL) {
42417c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
42427c478bd9Sstevel@tonic-gate 		kmem_free(onm, olen);
42437c478bd9Sstevel@tonic-gate 		kmem_free(nnm, nlen);
4244*f3b585ceSsamf 		goto out;
42457c478bd9Sstevel@tonic-gate 	}
42467c478bd9Sstevel@tonic-gate 
42477c478bd9Sstevel@tonic-gate 	sfp_rele_grant_hold = 1;
42487c478bd9Sstevel@tonic-gate 
42497c478bd9Sstevel@tonic-gate 	/* Does the destination exist and a file and have a delegation? */
42507c478bd9Sstevel@tonic-gate 	if (fp = rfs4_lookup_and_findfile(ndvp, nnm, &targvp, NULL, cs->cr)) {
42517c478bd9Sstevel@tonic-gate 		if (rfs4_check_delegated_byfp(FWRITE, fp, TRUE, TRUE, TRUE,
42521b300de9Sjwahlig 		    NULL)) {
42537c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_DELAY;
42547c478bd9Sstevel@tonic-gate 			goto err_out;
42557c478bd9Sstevel@tonic-gate 		}
42567c478bd9Sstevel@tonic-gate 	}
42577c478bd9Sstevel@tonic-gate 	fp_rele_grant_hold = 1;
42587c478bd9Sstevel@tonic-gate 
42597c478bd9Sstevel@tonic-gate 
42607c478bd9Sstevel@tonic-gate 	/* Check for NBMAND lock on both source and target */
42617c478bd9Sstevel@tonic-gate 	if (nbl_need_check(srcvp)) {
42627c478bd9Sstevel@tonic-gate 		nbl_start_crit(srcvp, RW_READER);
42637c478bd9Sstevel@tonic-gate 		in_crit_src = 1;
4264da6c28aaSamw 		if (nbl_conflict(srcvp, NBL_RENAME, 0, 0, 0, NULL)) {
42657c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_FILE_OPEN;
42667c478bd9Sstevel@tonic-gate 			goto err_out;
42677c478bd9Sstevel@tonic-gate 		}
42687c478bd9Sstevel@tonic-gate 	}
42697c478bd9Sstevel@tonic-gate 
42707c478bd9Sstevel@tonic-gate 	if (targvp && nbl_need_check(targvp)) {
42717c478bd9Sstevel@tonic-gate 		nbl_start_crit(targvp, RW_READER);
42727c478bd9Sstevel@tonic-gate 		in_crit_targ = 1;
4273da6c28aaSamw 		if (nbl_conflict(targvp, NBL_REMOVE, 0, 0, 0, NULL)) {
42747c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_FILE_OPEN;
42757c478bd9Sstevel@tonic-gate 			goto err_out;
42767c478bd9Sstevel@tonic-gate 		}
42777c478bd9Sstevel@tonic-gate 	}
42787c478bd9Sstevel@tonic-gate 
42797c478bd9Sstevel@tonic-gate 	/* Get source "before" change value */
42807c478bd9Sstevel@tonic-gate 	obdva.va_mask = AT_CTIME|AT_SEQ;
4281da6c28aaSamw 	error = VOP_GETATTR(odvp, &obdva, 0, cs->cr, NULL);
42827c478bd9Sstevel@tonic-gate 	if (!error) {
42837c478bd9Sstevel@tonic-gate 		nbdva.va_mask = AT_CTIME|AT_SEQ;
4284da6c28aaSamw 		error = VOP_GETATTR(ndvp, &nbdva, 0, cs->cr, NULL);
42857c478bd9Sstevel@tonic-gate 	}
42867c478bd9Sstevel@tonic-gate 	if (error) {
42877c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
42887c478bd9Sstevel@tonic-gate 		goto err_out;
42897c478bd9Sstevel@tonic-gate 	}
42907c478bd9Sstevel@tonic-gate 
42917c478bd9Sstevel@tonic-gate 	NFS4_SET_FATTR4_CHANGE(resp->source_cinfo.before, obdva.va_ctime)
42927c478bd9Sstevel@tonic-gate 	NFS4_SET_FATTR4_CHANGE(resp->target_cinfo.before, nbdva.va_ctime)
42937c478bd9Sstevel@tonic-gate 
4294da6c28aaSamw 	if ((error = VOP_RENAME(odvp, onm, ndvp, nnm, cs->cr, NULL, 0)) == 0 &&
42951b300de9Sjwahlig 	    fp != NULL) {
42967c478bd9Sstevel@tonic-gate 		struct vattr va;
4297418d27f3Sshepler 		vnode_t *tvp;
4298418d27f3Sshepler 
4299418d27f3Sshepler 		rfs4_dbe_lock(fp->dbe);
4300418d27f3Sshepler 		tvp = fp->vp;
4301418d27f3Sshepler 		if (tvp)
4302418d27f3Sshepler 			VN_HOLD(tvp);
4303418d27f3Sshepler 		rfs4_dbe_unlock(fp->dbe);
43047c478bd9Sstevel@tonic-gate 
4305418d27f3Sshepler 		if (tvp) {
4306418d27f3Sshepler 			va.va_mask = AT_NLINK;
4307da6c28aaSamw 			if (!VOP_GETATTR(tvp, &va, 0, cs->cr, NULL) &&
43081b300de9Sjwahlig 			    va.va_nlink == 0) {
4309418d27f3Sshepler 				/* The file is gone and so should the state */
4310418d27f3Sshepler 				if (in_crit_targ) {
4311418d27f3Sshepler 					nbl_end_crit(targvp);
4312418d27f3Sshepler 					in_crit_targ = 0;
4313418d27f3Sshepler 				}
4314418d27f3Sshepler 				rfs4_close_all_state(fp);
43157c478bd9Sstevel@tonic-gate 			}
4316418d27f3Sshepler 			VN_RELE(tvp);
43177c478bd9Sstevel@tonic-gate 		}
43187c478bd9Sstevel@tonic-gate 	}
4319c9264041Sjwahlig 	if (error == 0) {
4320c9264041Sjwahlig 		char *tmp;
4321c9264041Sjwahlig 
4322c9264041Sjwahlig 		/* fix the path name for the renamed file */
4323c9264041Sjwahlig 		mutex_enter(&srcvp->v_lock);
4324c9264041Sjwahlig 		tmp = srcvp->v_path;
4325c9264041Sjwahlig 		srcvp->v_path = NULL;
4326c9264041Sjwahlig 		mutex_exit(&srcvp->v_lock);
4327c9264041Sjwahlig 		vn_setpath(rootdir, ndvp, srcvp, nnm, nlen - 1);
4328c9264041Sjwahlig 		if (tmp != NULL)
4329c9264041Sjwahlig 			kmem_free(tmp, strlen(tmp) + 1);
4330c9264041Sjwahlig 	}
43317c478bd9Sstevel@tonic-gate 
43327c478bd9Sstevel@tonic-gate 	if (in_crit_src)
43337c478bd9Sstevel@tonic-gate 		nbl_end_crit(srcvp);
43347c478bd9Sstevel@tonic-gate 	if (srcvp)
43357c478bd9Sstevel@tonic-gate 		VN_RELE(srcvp);
43367c478bd9Sstevel@tonic-gate 	if (in_crit_targ)
43377c478bd9Sstevel@tonic-gate 		nbl_end_crit(targvp);
43387c478bd9Sstevel@tonic-gate 	if (targvp)
43397c478bd9Sstevel@tonic-gate 		VN_RELE(targvp);
43407c478bd9Sstevel@tonic-gate 
43417c478bd9Sstevel@tonic-gate 	if (sfp) {
43427c478bd9Sstevel@tonic-gate 		rfs4_clear_dont_grant(sfp);
43437c478bd9Sstevel@tonic-gate 		rfs4_file_rele(sfp);
43447c478bd9Sstevel@tonic-gate 	}
43457c478bd9Sstevel@tonic-gate 	if (fp) {
43467c478bd9Sstevel@tonic-gate 		rfs4_clear_dont_grant(fp);
43477c478bd9Sstevel@tonic-gate 		rfs4_file_rele(fp);
43487c478bd9Sstevel@tonic-gate 	}
43497c478bd9Sstevel@tonic-gate 
43507c478bd9Sstevel@tonic-gate 	kmem_free(onm, olen);
43517c478bd9Sstevel@tonic-gate 	kmem_free(nnm, nlen);
43527c478bd9Sstevel@tonic-gate 
43537c478bd9Sstevel@tonic-gate 	/*
43547c478bd9Sstevel@tonic-gate 	 * Get the initial "after" sequence number, if it fails, set to zero
43557c478bd9Sstevel@tonic-gate 	 */
43567c478bd9Sstevel@tonic-gate 	oidva.va_mask = AT_SEQ;
4357da6c28aaSamw 	if (VOP_GETATTR(odvp, &oidva, 0, cs->cr, NULL))
43587c478bd9Sstevel@tonic-gate 		oidva.va_seq = 0;
43597c478bd9Sstevel@tonic-gate 
43607c478bd9Sstevel@tonic-gate 	nidva.va_mask = AT_SEQ;
4361da6c28aaSamw 	if (VOP_GETATTR(ndvp, &nidva, 0, cs->cr, NULL))
43627c478bd9Sstevel@tonic-gate 		nidva.va_seq = 0;
43637c478bd9Sstevel@tonic-gate 
43647c478bd9Sstevel@tonic-gate 	/*
43657c478bd9Sstevel@tonic-gate 	 * Force modified data and metadata out to stable storage.
43667c478bd9Sstevel@tonic-gate 	 */
4367da6c28aaSamw 	(void) VOP_FSYNC(odvp, 0, cs->cr, NULL);
4368da6c28aaSamw 	(void) VOP_FSYNC(ndvp, 0, cs->cr, NULL);
43697c478bd9Sstevel@tonic-gate 
43707c478bd9Sstevel@tonic-gate 	if (error) {
43717c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
4372*f3b585ceSsamf 		goto out;
43737c478bd9Sstevel@tonic-gate 	}
43747c478bd9Sstevel@tonic-gate 
43757c478bd9Sstevel@tonic-gate 	/*
43767c478bd9Sstevel@tonic-gate 	 * Get "after" change values, if it fails, simply return the
43777c478bd9Sstevel@tonic-gate 	 * before value.
43787c478bd9Sstevel@tonic-gate 	 */
43797c478bd9Sstevel@tonic-gate 	oadva.va_mask = AT_CTIME|AT_SEQ;
4380da6c28aaSamw 	if (VOP_GETATTR(odvp, &oadva, 0, cs->cr, NULL)) {
43817c478bd9Sstevel@tonic-gate 		oadva.va_ctime = obdva.va_ctime;
43827c478bd9Sstevel@tonic-gate 		oadva.va_seq = 0;
43837c478bd9Sstevel@tonic-gate 	}
43847c478bd9Sstevel@tonic-gate 
43857c478bd9Sstevel@tonic-gate 	nadva.va_mask = AT_CTIME|AT_SEQ;
4386da6c28aaSamw 	if (VOP_GETATTR(odvp, &nadva, 0, cs->cr, NULL)) {
43877c478bd9Sstevel@tonic-gate 		nadva.va_ctime = nbdva.va_ctime;
43887c478bd9Sstevel@tonic-gate 		nadva.va_seq = 0;
43897c478bd9Sstevel@tonic-gate 	}
43907c478bd9Sstevel@tonic-gate 
43917c478bd9Sstevel@tonic-gate 	NFS4_SET_FATTR4_CHANGE(resp->source_cinfo.after, oadva.va_ctime)
43927c478bd9Sstevel@tonic-gate 	NFS4_SET_FATTR4_CHANGE(resp->target_cinfo.after, nadva.va_ctime)
43937c478bd9Sstevel@tonic-gate 
43947c478bd9Sstevel@tonic-gate 	/*
43957c478bd9Sstevel@tonic-gate 	 * The cinfo.atomic = TRUE only if we have
43967c478bd9Sstevel@tonic-gate 	 * non-zero va_seq's, and it has incremented by exactly one
43977c478bd9Sstevel@tonic-gate 	 * during the VOP_RENAME and it didn't change during the VOP_FSYNC.
43987c478bd9Sstevel@tonic-gate 	 */
43997c478bd9Sstevel@tonic-gate 	if (obdva.va_seq && oidva.va_seq && oadva.va_seq &&
44001b300de9Sjwahlig 	    oidva.va_seq == (obdva.va_seq + 1) && oidva.va_seq == oadva.va_seq)
44017c478bd9Sstevel@tonic-gate 		resp->source_cinfo.atomic = TRUE;
44027c478bd9Sstevel@tonic-gate 	else
44037c478bd9Sstevel@tonic-gate 		resp->source_cinfo.atomic = FALSE;
44047c478bd9Sstevel@tonic-gate 
44057c478bd9Sstevel@tonic-gate 	if (nbdva.va_seq && nidva.va_seq && nadva.va_seq &&
44061b300de9Sjwahlig 	    nidva.va_seq == (nbdva.va_seq + 1) && nidva.va_seq == nadva.va_seq)
44077c478bd9Sstevel@tonic-gate 		resp->target_cinfo.atomic = TRUE;
44087c478bd9Sstevel@tonic-gate 	else
44097c478bd9Sstevel@tonic-gate 		resp->target_cinfo.atomic = FALSE;
44107c478bd9Sstevel@tonic-gate 
44117c478bd9Sstevel@tonic-gate #ifdef	VOLATILE_FH_TEST
44127c478bd9Sstevel@tonic-gate 	{
44137c478bd9Sstevel@tonic-gate 	extern void add_volrnm_fh(struct exportinfo *, vnode_t *);
44147c478bd9Sstevel@tonic-gate 
44157c478bd9Sstevel@tonic-gate 	/*
44167c478bd9Sstevel@tonic-gate 	 * Add the renamed file handle to the volatile rename list
44177c478bd9Sstevel@tonic-gate 	 */
44187c478bd9Sstevel@tonic-gate 	if (cs->exi->exi_export.ex_flags & EX_VOLRNM) {
44197c478bd9Sstevel@tonic-gate 		/* file handles may expire on rename */
44207c478bd9Sstevel@tonic-gate 		vnode_t *vp;
44217c478bd9Sstevel@tonic-gate 
44227c478bd9Sstevel@tonic-gate 		nnm = utf8_to_fn(&args->newname, &nlen, NULL);
44237c478bd9Sstevel@tonic-gate 		/*
44247c478bd9Sstevel@tonic-gate 		 * Already know that nnm will be a valid string
44257c478bd9Sstevel@tonic-gate 		 */
4426da6c28aaSamw 		error = VOP_LOOKUP(ndvp, nnm, &vp, NULL, 0, NULL, cs->cr,
4427da6c28aaSamw 		    NULL, NULL, NULL);
44287c478bd9Sstevel@tonic-gate 		kmem_free(nnm, nlen);
44297c478bd9Sstevel@tonic-gate 		if (!error) {
44307c478bd9Sstevel@tonic-gate 			add_volrnm_fh(cs->exi, vp);
44317c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
44327c478bd9Sstevel@tonic-gate 		}
44337c478bd9Sstevel@tonic-gate 	}
44347c478bd9Sstevel@tonic-gate 	}
44357c478bd9Sstevel@tonic-gate #endif	/* VOLATILE_FH_TEST */
44367c478bd9Sstevel@tonic-gate 
44377c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
4438*f3b585ceSsamf out:
4439*f3b585ceSsamf 	DTRACE_NFSV4_2(op__rename__done, struct compound_state *, cs,
4440*f3b585ceSsamf 	    RENAME4res *, resp);
44417c478bd9Sstevel@tonic-gate 	return;
44427c478bd9Sstevel@tonic-gate 
44437c478bd9Sstevel@tonic-gate err_out:
44447c478bd9Sstevel@tonic-gate 	kmem_free(onm, olen);
44457c478bd9Sstevel@tonic-gate 	kmem_free(nnm, nlen);
44467c478bd9Sstevel@tonic-gate 
44477c478bd9Sstevel@tonic-gate 	if (in_crit_src) nbl_end_crit(srcvp);
44487c478bd9Sstevel@tonic-gate 	if (in_crit_targ) nbl_end_crit(targvp);
44497c478bd9Sstevel@tonic-gate 	if (targvp) VN_RELE(targvp);
44507c478bd9Sstevel@tonic-gate 	if (srcvp) VN_RELE(srcvp);
44517c478bd9Sstevel@tonic-gate 	if (sfp) {
44527c478bd9Sstevel@tonic-gate 		if (sfp_rele_grant_hold) rfs4_clear_dont_grant(sfp);
44537c478bd9Sstevel@tonic-gate 		rfs4_file_rele(sfp);
44547c478bd9Sstevel@tonic-gate 	}
44557c478bd9Sstevel@tonic-gate 	if (fp) {
44567c478bd9Sstevel@tonic-gate 		if (fp_rele_grant_hold) rfs4_clear_dont_grant(fp);
44577c478bd9Sstevel@tonic-gate 		rfs4_file_rele(fp);
44587c478bd9Sstevel@tonic-gate 	}
4459*f3b585ceSsamf 
4460*f3b585ceSsamf 	DTRACE_NFSV4_2(op__rename__done, struct compound_state *, cs,
4461*f3b585ceSsamf 	    RENAME4res *, resp);
44627c478bd9Sstevel@tonic-gate }
44637c478bd9Sstevel@tonic-gate 
44647c478bd9Sstevel@tonic-gate /* ARGSUSED */
44657c478bd9Sstevel@tonic-gate static void
44667c478bd9Sstevel@tonic-gate rfs4_op_renew(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
44677c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
44687c478bd9Sstevel@tonic-gate {
44697c478bd9Sstevel@tonic-gate 	RENEW4args *args = &argop->nfs_argop4_u.oprenew;
44707c478bd9Sstevel@tonic-gate 	RENEW4res *resp = &resop->nfs_resop4_u.oprenew;
44717c478bd9Sstevel@tonic-gate 	rfs4_client_t *cp;
44727c478bd9Sstevel@tonic-gate 
4473*f3b585ceSsamf 	DTRACE_NFSV4_2(op__renew__start, struct compound_state *, cs,
4474*f3b585ceSsamf 	    RENEW4args *, args);
4475*f3b585ceSsamf 
44767c478bd9Sstevel@tonic-gate 	if ((cp = rfs4_findclient_by_id(args->clientid, FALSE)) == NULL) {
44777c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status =
44781b300de9Sjwahlig 		    rfs4_check_clientid(&args->clientid, 0);
4479*f3b585ceSsamf 		goto out;
44807c478bd9Sstevel@tonic-gate 	}
44817c478bd9Sstevel@tonic-gate 
44827c478bd9Sstevel@tonic-gate 	if (rfs4_lease_expired(cp)) {
44837c478bd9Sstevel@tonic-gate 		rfs4_client_rele(cp);
44847c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
4485*f3b585ceSsamf 		goto out;
44867c478bd9Sstevel@tonic-gate 	}
44877c478bd9Sstevel@tonic-gate 
44887c478bd9Sstevel@tonic-gate 	rfs4_update_lease(cp);
44897c478bd9Sstevel@tonic-gate 
44907c478bd9Sstevel@tonic-gate 	mutex_enter(cp->cbinfo.cb_lock);
44917c478bd9Sstevel@tonic-gate 	if (cp->cbinfo.cb_notified_of_cb_path_down == FALSE) {
44927c478bd9Sstevel@tonic-gate 		cp->cbinfo.cb_notified_of_cb_path_down = TRUE;
44937c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_CB_PATH_DOWN;
44947c478bd9Sstevel@tonic-gate 	} else {
44957c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4_OK;
44967c478bd9Sstevel@tonic-gate 	}
44977c478bd9Sstevel@tonic-gate 	mutex_exit(cp->cbinfo.cb_lock);
44987c478bd9Sstevel@tonic-gate 
44997c478bd9Sstevel@tonic-gate 	rfs4_client_rele(cp);
45007c478bd9Sstevel@tonic-gate 
4501*f3b585ceSsamf out:
4502*f3b585ceSsamf 	DTRACE_NFSV4_2(op__renew__done, struct compound_state *, cs,
4503*f3b585ceSsamf 	    RENEW4res *, resp);
45047c478bd9Sstevel@tonic-gate }
45057c478bd9Sstevel@tonic-gate 
45067c478bd9Sstevel@tonic-gate /* ARGSUSED */
45077c478bd9Sstevel@tonic-gate static void
45087c478bd9Sstevel@tonic-gate rfs4_op_restorefh(nfs_argop4 *args, nfs_resop4 *resop, struct svc_req *req,
45097c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
45107c478bd9Sstevel@tonic-gate {
45117c478bd9Sstevel@tonic-gate 	RESTOREFH4res *resp = &resop->nfs_resop4_u.oprestorefh;
45127c478bd9Sstevel@tonic-gate 
4513*f3b585ceSsamf 	DTRACE_NFSV4_1(op__restorefh__start, struct compound_state *, cs);
4514*f3b585ceSsamf 
45157c478bd9Sstevel@tonic-gate 	/* No need to check cs->access - we are not accessing any object */
45167c478bd9Sstevel@tonic-gate 	if ((cs->saved_vp == NULL) || (cs->saved_fh.nfs_fh4_val == NULL)) {
45177c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_RESTOREFH;
4518*f3b585ceSsamf 		goto out;
45197c478bd9Sstevel@tonic-gate 	}
45207c478bd9Sstevel@tonic-gate 	if (cs->vp != NULL) {
45217c478bd9Sstevel@tonic-gate 		VN_RELE(cs->vp);
45227c478bd9Sstevel@tonic-gate 	}
45237c478bd9Sstevel@tonic-gate 	cs->vp = cs->saved_vp;
45247c478bd9Sstevel@tonic-gate 	cs->saved_vp = NULL;
45257c478bd9Sstevel@tonic-gate 	cs->exi = cs->saved_exi;
45267c478bd9Sstevel@tonic-gate 	nfs_fh4_copy(&cs->saved_fh, &cs->fh);
45277c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
45287c478bd9Sstevel@tonic-gate 	cs->deleg = FALSE;
4529*f3b585ceSsamf 
4530*f3b585ceSsamf out:
4531*f3b585ceSsamf 	DTRACE_NFSV4_2(op__restorefh__done, struct compound_state *, cs,
4532*f3b585ceSsamf 	    RESTOREFH4res *, resp);
45337c478bd9Sstevel@tonic-gate }
45347c478bd9Sstevel@tonic-gate 
45357c478bd9Sstevel@tonic-gate /* ARGSUSED */
45367c478bd9Sstevel@tonic-gate static void
45377c478bd9Sstevel@tonic-gate rfs4_op_savefh(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
45387c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
45397c478bd9Sstevel@tonic-gate {
45407c478bd9Sstevel@tonic-gate 	SAVEFH4res *resp = &resop->nfs_resop4_u.opsavefh;
45417c478bd9Sstevel@tonic-gate 
4542*f3b585ceSsamf 	DTRACE_NFSV4_1(op__savefh__start, struct compound_state *, cs);
4543*f3b585ceSsamf 
45447c478bd9Sstevel@tonic-gate 	/* No need to check cs->access - we are not accessing any object */
45457c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
45467c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
4547*f3b585ceSsamf 		goto out;
45487c478bd9Sstevel@tonic-gate 	}
45497c478bd9Sstevel@tonic-gate 	if (cs->saved_vp != NULL) {
45507c478bd9Sstevel@tonic-gate 		VN_RELE(cs->saved_vp);
45517c478bd9Sstevel@tonic-gate 	}
45527c478bd9Sstevel@tonic-gate 	cs->saved_vp = cs->vp;
45537c478bd9Sstevel@tonic-gate 	VN_HOLD(cs->saved_vp);
45547c478bd9Sstevel@tonic-gate 	cs->saved_exi = cs->exi;
45557c478bd9Sstevel@tonic-gate 	/*
45567c478bd9Sstevel@tonic-gate 	 * since SAVEFH is fairly rare, don't alloc space for its fh
45577c478bd9Sstevel@tonic-gate 	 * unless necessary.
45587c478bd9Sstevel@tonic-gate 	 */
45597c478bd9Sstevel@tonic-gate 	if (cs->saved_fh.nfs_fh4_val == NULL) {
45607c478bd9Sstevel@tonic-gate 		cs->saved_fh.nfs_fh4_val = kmem_alloc(NFS4_FHSIZE, KM_SLEEP);
45617c478bd9Sstevel@tonic-gate 	}
45627c478bd9Sstevel@tonic-gate 	nfs_fh4_copy(&cs->fh, &cs->saved_fh);
45637c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
4564*f3b585ceSsamf 
4565*f3b585ceSsamf out:
4566*f3b585ceSsamf 	DTRACE_NFSV4_2(op__savefh__done, struct compound_state *, cs,
4567*f3b585ceSsamf 	    SAVEFH4res *, resp);
45687c478bd9Sstevel@tonic-gate }
45697c478bd9Sstevel@tonic-gate 
45707c478bd9Sstevel@tonic-gate /*
45717c478bd9Sstevel@tonic-gate  * rfs4_verify_attr is called when nfsv4 Setattr failed, but we wish to
45727c478bd9Sstevel@tonic-gate  * return the bitmap of attrs that were set successfully. It is also
45737c478bd9Sstevel@tonic-gate  * called by Verify/Nverify to test the vattr/vfsstat attrs. It should
45747c478bd9Sstevel@tonic-gate  * always be called only after rfs4_do_set_attrs().
45757c478bd9Sstevel@tonic-gate  *
45767c478bd9Sstevel@tonic-gate  * Verify that the attributes are same as the expected ones. sargp->vap
45777c478bd9Sstevel@tonic-gate  * and sargp->sbp contain the input attributes as translated from fattr4.
45787c478bd9Sstevel@tonic-gate  *
45797c478bd9Sstevel@tonic-gate  * This function verifies only the attrs that correspond to a vattr or
45807c478bd9Sstevel@tonic-gate  * vfsstat struct. That is because of the extra step needed to get the
45817c478bd9Sstevel@tonic-gate  * corresponding system structs. Other attributes have already been set or
45827c478bd9Sstevel@tonic-gate  * verified by do_rfs4_set_attrs.
45837c478bd9Sstevel@tonic-gate  *
45847c478bd9Sstevel@tonic-gate  * Return 0 if all attrs match, -1 if some don't, error if error processing.
45857c478bd9Sstevel@tonic-gate  */
45867c478bd9Sstevel@tonic-gate static int
45877c478bd9Sstevel@tonic-gate rfs4_verify_attr(struct nfs4_svgetit_arg *sargp,
45887c478bd9Sstevel@tonic-gate 	bitmap4 *resp, struct nfs4_ntov_table *ntovp)
45897c478bd9Sstevel@tonic-gate {
45907c478bd9Sstevel@tonic-gate 	int error, ret_error = 0;
45917c478bd9Sstevel@tonic-gate 	int i, k;
45927c478bd9Sstevel@tonic-gate 	uint_t sva_mask = sargp->vap->va_mask;
45937c478bd9Sstevel@tonic-gate 	uint_t vbit;
45947c478bd9Sstevel@tonic-gate 	union nfs4_attr_u *na;
45957c478bd9Sstevel@tonic-gate 	uint8_t *amap;
45967c478bd9Sstevel@tonic-gate 	bool_t getsb = ntovp->vfsstat;
45977c478bd9Sstevel@tonic-gate 
45987c478bd9Sstevel@tonic-gate 	if (sva_mask != 0) {
45997c478bd9Sstevel@tonic-gate 		/*
46007c478bd9Sstevel@tonic-gate 		 * Okay to overwrite sargp->vap because we verify based
46017c478bd9Sstevel@tonic-gate 		 * on the incoming values.
46027c478bd9Sstevel@tonic-gate 		 */
46037c478bd9Sstevel@tonic-gate 		ret_error = VOP_GETATTR(sargp->cs->vp, sargp->vap, 0,
4604da6c28aaSamw 		    sargp->cs->cr, NULL);
46057c478bd9Sstevel@tonic-gate 		if (ret_error) {
46067c478bd9Sstevel@tonic-gate 			if (resp == NULL)
46077c478bd9Sstevel@tonic-gate 				return (ret_error);
46087c478bd9Sstevel@tonic-gate 			/*
46097c478bd9Sstevel@tonic-gate 			 * Must return bitmap of successful attrs
46107c478bd9Sstevel@tonic-gate 			 */
46117c478bd9Sstevel@tonic-gate 			sva_mask = 0;	/* to prevent checking vap later */
46127c478bd9Sstevel@tonic-gate 		} else {
46137c478bd9Sstevel@tonic-gate 			/*
46147c478bd9Sstevel@tonic-gate 			 * Some file systems clobber va_mask. it is probably
46157c478bd9Sstevel@tonic-gate 			 * wrong of them to do so, nonethless we practice
46167c478bd9Sstevel@tonic-gate 			 * defensive coding.
46177c478bd9Sstevel@tonic-gate 			 * See bug id 4276830.
46187c478bd9Sstevel@tonic-gate 			 */
46197c478bd9Sstevel@tonic-gate 			sargp->vap->va_mask = sva_mask;
46207c478bd9Sstevel@tonic-gate 		}
46217c478bd9Sstevel@tonic-gate 	}
46227c478bd9Sstevel@tonic-gate 
46237c478bd9Sstevel@tonic-gate 	if (getsb) {
46247c478bd9Sstevel@tonic-gate 		/*
46257c478bd9Sstevel@tonic-gate 		 * Now get the superblock and loop on the bitmap, as there is
46267c478bd9Sstevel@tonic-gate 		 * no simple way of translating from superblock to bitmap4.
46277c478bd9Sstevel@tonic-gate 		 */
46287c478bd9Sstevel@tonic-gate 		ret_error = VFS_STATVFS(sargp->cs->vp->v_vfsp, sargp->sbp);
46297c478bd9Sstevel@tonic-gate 		if (ret_error) {
46307c478bd9Sstevel@tonic-gate 			if (resp == NULL)
46317c478bd9Sstevel@tonic-gate 				goto errout;
46327c478bd9Sstevel@tonic-gate 			getsb = FALSE;
46337c478bd9Sstevel@tonic-gate 		}
46347c478bd9Sstevel@tonic-gate 	}
46357c478bd9Sstevel@tonic-gate 
46367c478bd9Sstevel@tonic-gate 	/*
46377c478bd9Sstevel@tonic-gate 	 * Now loop and verify each attribute which getattr returned
46387c478bd9Sstevel@tonic-gate 	 * whether it's the same as the input.
46397c478bd9Sstevel@tonic-gate 	 */
46407c478bd9Sstevel@tonic-gate 	if (resp == NULL && !getsb && (sva_mask == 0))
46417c478bd9Sstevel@tonic-gate 		goto errout;
46427c478bd9Sstevel@tonic-gate 
46437c478bd9Sstevel@tonic-gate 	na = ntovp->na;
46447c478bd9Sstevel@tonic-gate 	amap = ntovp->amap;
46457c478bd9Sstevel@tonic-gate 	k = 0;
46467c478bd9Sstevel@tonic-gate 	for (i = 0; i < ntovp->attrcnt; i++, na++, amap++) {
46477c478bd9Sstevel@tonic-gate 		k = *amap;
46487c478bd9Sstevel@tonic-gate 		ASSERT(nfs4_ntov_map[k].nval == k);
46497c478bd9Sstevel@tonic-gate 		vbit = nfs4_ntov_map[k].vbit;
46507c478bd9Sstevel@tonic-gate 
46517c478bd9Sstevel@tonic-gate 		/*
46527c478bd9Sstevel@tonic-gate 		 * If vattr attribute but VOP_GETATTR failed, or it's
46537c478bd9Sstevel@tonic-gate 		 * superblock attribute but VFS_STATVFS failed, skip
46547c478bd9Sstevel@tonic-gate 		 */
46557c478bd9Sstevel@tonic-gate 		if (vbit) {
46567c478bd9Sstevel@tonic-gate 			if ((vbit & sva_mask) == 0)
46577c478bd9Sstevel@tonic-gate 				continue;
46587c478bd9Sstevel@tonic-gate 		} else if (!(getsb && nfs4_ntov_map[k].vfsstat)) {
46597c478bd9Sstevel@tonic-gate 			continue;
46607c478bd9Sstevel@tonic-gate 		}
46611b300de9Sjwahlig 		error = (*nfs4_ntov_map[k].sv_getit)(NFS4ATTR_VERIT, sargp, na);
46627c478bd9Sstevel@tonic-gate 		if (resp != NULL) {
46637c478bd9Sstevel@tonic-gate 			if (error)
46647c478bd9Sstevel@tonic-gate 				ret_error = -1;	/* not all match */
46657c478bd9Sstevel@tonic-gate 			else	/* update response bitmap */
46667c478bd9Sstevel@tonic-gate 				*resp |= nfs4_ntov_map[k].fbit;
46677c478bd9Sstevel@tonic-gate 			continue;
46687c478bd9Sstevel@tonic-gate 		}
46697c478bd9Sstevel@tonic-gate 		if (error) {
46707c478bd9Sstevel@tonic-gate 			ret_error = -1;	/* not all match */
46717c478bd9Sstevel@tonic-gate 			break;
46727c478bd9Sstevel@tonic-gate 		}
46737c478bd9Sstevel@tonic-gate 	}
46747c478bd9Sstevel@tonic-gate errout:
46757c478bd9Sstevel@tonic-gate 	return (ret_error);
46767c478bd9Sstevel@tonic-gate }
46777c478bd9Sstevel@tonic-gate 
46787c478bd9Sstevel@tonic-gate /*
46797c478bd9Sstevel@tonic-gate  * Decode the attribute to be set/verified. If the attr requires a sys op
46807c478bd9Sstevel@tonic-gate  * (VOP_GETATTR, VFS_VFSSTAT), and the request is to verify, then don't
46817c478bd9Sstevel@tonic-gate  * call the sv_getit function for it, because the sys op hasn't yet been done.
46827c478bd9Sstevel@tonic-gate  * Return 0 for success, error code if failed.
46837c478bd9Sstevel@tonic-gate  *
46847c478bd9Sstevel@tonic-gate  * Note: the decoded arg is not freed here but in nfs4_ntov_table_free.
46857c478bd9Sstevel@tonic-gate  */
46867c478bd9Sstevel@tonic-gate static int
46877c478bd9Sstevel@tonic-gate decode_fattr4_attr(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sargp,
46887c478bd9Sstevel@tonic-gate 	int k, XDR *xdrp, bitmap4 *resp_bval, union nfs4_attr_u *nap)
46897c478bd9Sstevel@tonic-gate {
46907c478bd9Sstevel@tonic-gate 	int error = 0;
46917c478bd9Sstevel@tonic-gate 	bool_t set_later;
46927c478bd9Sstevel@tonic-gate 
46937c478bd9Sstevel@tonic-gate 	sargp->vap->va_mask |= nfs4_ntov_map[k].vbit;
46947c478bd9Sstevel@tonic-gate 
46957c478bd9Sstevel@tonic-gate 	if ((*nfs4_ntov_map[k].xfunc)(xdrp, nap)) {
46967c478bd9Sstevel@tonic-gate 		set_later = nfs4_ntov_map[k].vbit || nfs4_ntov_map[k].vfsstat;
46977c478bd9Sstevel@tonic-gate 		/*
46987c478bd9Sstevel@tonic-gate 		 * don't verify yet if a vattr or sb dependent attr,
46997c478bd9Sstevel@tonic-gate 		 * because we don't have their sys values yet.
47007c478bd9Sstevel@tonic-gate 		 * Will be done later.
47017c478bd9Sstevel@tonic-gate 		 */
47027c478bd9Sstevel@tonic-gate 		if (! (set_later && (cmd == NFS4ATTR_VERIT))) {
47037c478bd9Sstevel@tonic-gate 			/*
47047c478bd9Sstevel@tonic-gate 			 * ACLs are a special case, since setting the MODE
47057c478bd9Sstevel@tonic-gate 			 * conflicts with setting the ACL.  We delay setting
47067c478bd9Sstevel@tonic-gate 			 * the ACL until all other attributes have been set.
47077c478bd9Sstevel@tonic-gate 			 * The ACL gets set in do_rfs4_op_setattr().
47087c478bd9Sstevel@tonic-gate 			 */
47097c478bd9Sstevel@tonic-gate 			if (nfs4_ntov_map[k].fbit != FATTR4_ACL_MASK) {
47107c478bd9Sstevel@tonic-gate 				error = (*nfs4_ntov_map[k].sv_getit)(cmd,
47117c478bd9Sstevel@tonic-gate 				    sargp, nap);
47127c478bd9Sstevel@tonic-gate 				if (error) {
47137c478bd9Sstevel@tonic-gate 					xdr_free(nfs4_ntov_map[k].xfunc,
47147c478bd9Sstevel@tonic-gate 					    (caddr_t)nap);
47157c478bd9Sstevel@tonic-gate 				}
47167c478bd9Sstevel@tonic-gate 			}
47177c478bd9Sstevel@tonic-gate 		}
47187c478bd9Sstevel@tonic-gate 	} else {
47197c478bd9Sstevel@tonic-gate #ifdef  DEBUG
47207c478bd9Sstevel@tonic-gate 		cmn_err(CE_NOTE, "decode_fattr4_attr: error "
47211b300de9Sjwahlig 		    "decoding attribute %d\n", k);
47227c478bd9Sstevel@tonic-gate #endif
47237c478bd9Sstevel@tonic-gate 		error = EINVAL;
47247c478bd9Sstevel@tonic-gate 	}
47257c478bd9Sstevel@tonic-gate 	if (!error && resp_bval && !set_later) {
47267c478bd9Sstevel@tonic-gate 		*resp_bval |= nfs4_ntov_map[k].fbit;
47277c478bd9Sstevel@tonic-gate 	}
47287c478bd9Sstevel@tonic-gate 
47297c478bd9Sstevel@tonic-gate 	return (error);
47307c478bd9Sstevel@tonic-gate }
47317c478bd9Sstevel@tonic-gate 
47327c478bd9Sstevel@tonic-gate /*
47337c478bd9Sstevel@tonic-gate  * Set vattr based on incoming fattr4 attrs - used by setattr.
47347c478bd9Sstevel@tonic-gate  * Set response mask. Ignore any values that are not writable vattr attrs.
47357c478bd9Sstevel@tonic-gate  */
47367c478bd9Sstevel@tonic-gate static nfsstat4
47377c478bd9Sstevel@tonic-gate do_rfs4_set_attrs(bitmap4 *resp, fattr4 *fattrp, struct compound_state *cs,
47387c478bd9Sstevel@tonic-gate 		struct nfs4_svgetit_arg *sargp, struct nfs4_ntov_table *ntovp,
47397c478bd9Sstevel@tonic-gate 		nfs4_attr_cmd_t cmd)
47407c478bd9Sstevel@tonic-gate {
47417c478bd9Sstevel@tonic-gate 	int error = 0;
47427c478bd9Sstevel@tonic-gate 	int i;
47437c478bd9Sstevel@tonic-gate 	char *attrs = fattrp->attrlist4;
47447c478bd9Sstevel@tonic-gate 	uint32_t attrslen = fattrp->attrlist4_len;
47457c478bd9Sstevel@tonic-gate 	XDR xdr;
47467c478bd9Sstevel@tonic-gate 	nfsstat4 status = NFS4_OK;
47477c478bd9Sstevel@tonic-gate 	vnode_t *vp = cs->vp;
47487c478bd9Sstevel@tonic-gate 	union nfs4_attr_u *na;
47497c478bd9Sstevel@tonic-gate 	uint8_t *amap;
47507c478bd9Sstevel@tonic-gate 
47517c478bd9Sstevel@tonic-gate #ifndef lint
47527c478bd9Sstevel@tonic-gate 	/*
47537c478bd9Sstevel@tonic-gate 	 * Make sure that maximum attribute number can be expressed as an
47547c478bd9Sstevel@tonic-gate 	 * 8 bit quantity.
47557c478bd9Sstevel@tonic-gate 	 */
47567c478bd9Sstevel@tonic-gate 	ASSERT(NFS4_MAXNUM_ATTRS <= (UINT8_MAX + 1));
47577c478bd9Sstevel@tonic-gate #endif
47587c478bd9Sstevel@tonic-gate 
47597c478bd9Sstevel@tonic-gate 	if (vp == NULL) {
47607c478bd9Sstevel@tonic-gate 		if (resp)
47617c478bd9Sstevel@tonic-gate 			*resp = 0;
47627c478bd9Sstevel@tonic-gate 		return (NFS4ERR_NOFILEHANDLE);
47637c478bd9Sstevel@tonic-gate 	}
47647c478bd9Sstevel@tonic-gate 	if (cs->access == CS_ACCESS_DENIED) {
47657c478bd9Sstevel@tonic-gate 		if (resp)
47667c478bd9Sstevel@tonic-gate 			*resp = 0;
47677c478bd9Sstevel@tonic-gate 		return (NFS4ERR_ACCESS);
47687c478bd9Sstevel@tonic-gate 	}
47697c478bd9Sstevel@tonic-gate 
47707c478bd9Sstevel@tonic-gate 	sargp->op = cmd;
47717c478bd9Sstevel@tonic-gate 	sargp->cs = cs;
47727c478bd9Sstevel@tonic-gate 	sargp->flag = 0;	/* may be set later */
47737c478bd9Sstevel@tonic-gate 	sargp->vap->va_mask = 0;
47747c478bd9Sstevel@tonic-gate 	sargp->rdattr_error = NFS4_OK;
47757c478bd9Sstevel@tonic-gate 	sargp->rdattr_error_req = FALSE;
47767c478bd9Sstevel@tonic-gate 	/* sargp->sbp is set by the caller */
47777c478bd9Sstevel@tonic-gate 
47787c478bd9Sstevel@tonic-gate 	xdrmem_create(&xdr, attrs, attrslen, XDR_DECODE);
47797c478bd9Sstevel@tonic-gate 
47807c478bd9Sstevel@tonic-gate 	na = ntovp->na;
47817c478bd9Sstevel@tonic-gate 	amap = ntovp->amap;
47827c478bd9Sstevel@tonic-gate 
47837c478bd9Sstevel@tonic-gate 	/*
47847c478bd9Sstevel@tonic-gate 	 * The following loop iterates on the nfs4_ntov_map checking
47857c478bd9Sstevel@tonic-gate 	 * if the fbit is set in the requested bitmap.
47867c478bd9Sstevel@tonic-gate 	 * If set then we process the arguments using the
47877c478bd9Sstevel@tonic-gate 	 * rfs4_fattr4 conversion functions to populate the setattr
47887c478bd9Sstevel@tonic-gate 	 * vattr and va_mask. Any settable attrs that are not using vattr
47897c478bd9Sstevel@tonic-gate 	 * will be set in this loop.
47907c478bd9Sstevel@tonic-gate 	 */
47917c478bd9Sstevel@tonic-gate 	for (i = 0; i < nfs4_ntov_map_size; i++) {
47927c478bd9Sstevel@tonic-gate 		if (!(fattrp->attrmask & nfs4_ntov_map[i].fbit)) {
47937c478bd9Sstevel@tonic-gate 			continue;
47947c478bd9Sstevel@tonic-gate 		}
47957c478bd9Sstevel@tonic-gate 		/*
47967c478bd9Sstevel@tonic-gate 		 * If setattr, must be a writable attr.
47977c478bd9Sstevel@tonic-gate 		 * If verify/nverify, must be a readable attr.
47987c478bd9Sstevel@tonic-gate 		 */
47997c478bd9Sstevel@tonic-gate 		if ((error = (*nfs4_ntov_map[i].sv_getit)(
48001b300de9Sjwahlig 		    NFS4ATTR_SUPPORTED, sargp, NULL)) != 0) {
48017c478bd9Sstevel@tonic-gate 			/*
48027c478bd9Sstevel@tonic-gate 			 * Client tries to set/verify an
48037c478bd9Sstevel@tonic-gate 			 * unsupported attribute, tries to set
48047c478bd9Sstevel@tonic-gate 			 * a read only attr or verify a write
48057c478bd9Sstevel@tonic-gate 			 * only one - error!
48067c478bd9Sstevel@tonic-gate 			 */
48077c478bd9Sstevel@tonic-gate 			break;
48087c478bd9Sstevel@tonic-gate 		}
48097c478bd9Sstevel@tonic-gate 		/*
48107c478bd9Sstevel@tonic-gate 		 * Decode the attribute to set/verify
48117c478bd9Sstevel@tonic-gate 		 */
48127c478bd9Sstevel@tonic-gate 		error = decode_fattr4_attr(cmd, sargp, nfs4_ntov_map[i].nval,
48131b300de9Sjwahlig 		    &xdr, resp ? resp : NULL, na);
48147c478bd9Sstevel@tonic-gate 		if (error)
48157c478bd9Sstevel@tonic-gate 			break;
48167c478bd9Sstevel@tonic-gate 		*amap++ = (uint8_t)nfs4_ntov_map[i].nval;
48177c478bd9Sstevel@tonic-gate 		na++;
48187c478bd9Sstevel@tonic-gate 		(ntovp->attrcnt)++;
48197c478bd9Sstevel@tonic-gate 		if (nfs4_ntov_map[i].vfsstat)
48207c478bd9Sstevel@tonic-gate 			ntovp->vfsstat = TRUE;
48217c478bd9Sstevel@tonic-gate 	}
48227c478bd9Sstevel@tonic-gate 
48237c478bd9Sstevel@tonic-gate 	if (error != 0)
48241b300de9Sjwahlig 		status = (error == ENOTSUP ? NFS4ERR_ATTRNOTSUPP :
48251b300de9Sjwahlig 		    puterrno4(error));
48267c478bd9Sstevel@tonic-gate 	/* xdrmem_destroy(&xdrs); */	/* NO-OP */
48277c478bd9Sstevel@tonic-gate 	return (status);
48287c478bd9Sstevel@tonic-gate }
48297c478bd9Sstevel@tonic-gate 
48307c478bd9Sstevel@tonic-gate static nfsstat4
48317c478bd9Sstevel@tonic-gate do_rfs4_op_setattr(bitmap4 *resp, fattr4 *fattrp, struct compound_state *cs,
48327c478bd9Sstevel@tonic-gate 		stateid4 *stateid)
48337c478bd9Sstevel@tonic-gate {
48347c478bd9Sstevel@tonic-gate 	int error = 0;
48357c478bd9Sstevel@tonic-gate 	struct nfs4_svgetit_arg sarg;
48367c478bd9Sstevel@tonic-gate 	bool_t trunc;
48377c478bd9Sstevel@tonic-gate 
48387c478bd9Sstevel@tonic-gate 	nfsstat4 status = NFS4_OK;
48397c478bd9Sstevel@tonic-gate 	cred_t *cr = cs->cr;
48407c478bd9Sstevel@tonic-gate 	vnode_t *vp = cs->vp;
48417c478bd9Sstevel@tonic-gate 	struct nfs4_ntov_table ntov;
48427c478bd9Sstevel@tonic-gate 	struct statvfs64 sb;
48437c478bd9Sstevel@tonic-gate 	struct vattr bva;
48447c478bd9Sstevel@tonic-gate 	struct flock64 bf;
48457c478bd9Sstevel@tonic-gate 	int in_crit = 0;
48467c478bd9Sstevel@tonic-gate 	uint_t saved_mask = 0;
48477c478bd9Sstevel@tonic-gate 	caller_context_t ct;
48487c478bd9Sstevel@tonic-gate 
48497c478bd9Sstevel@tonic-gate 	*resp = 0;
48507c478bd9Sstevel@tonic-gate 	sarg.sbp = &sb;
48517c478bd9Sstevel@tonic-gate 	nfs4_ntov_table_init(&ntov);
48527c478bd9Sstevel@tonic-gate 	status = do_rfs4_set_attrs(resp, fattrp, cs, &sarg, &ntov,
48531b300de9Sjwahlig 	    NFS4ATTR_SETIT);
48547c478bd9Sstevel@tonic-gate 	if (status != NFS4_OK) {
48557c478bd9Sstevel@tonic-gate 		/*
48567c478bd9Sstevel@tonic-gate 		 * failed set attrs
48577c478bd9Sstevel@tonic-gate 		 */
48587c478bd9Sstevel@tonic-gate 		goto done;
48597c478bd9Sstevel@tonic-gate 	}
48607c478bd9Sstevel@tonic-gate 	if ((sarg.vap->va_mask == 0) &&
48617c478bd9Sstevel@tonic-gate 	    (! (fattrp->attrmask & FATTR4_ACL_MASK))) {
48627c478bd9Sstevel@tonic-gate 		/*
48637c478bd9Sstevel@tonic-gate 		 * no further work to be done
48647c478bd9Sstevel@tonic-gate 		 */
48657c478bd9Sstevel@tonic-gate 		goto done;
48667c478bd9Sstevel@tonic-gate 	}
48677c478bd9Sstevel@tonic-gate 
48687c478bd9Sstevel@tonic-gate 	/*
48697c478bd9Sstevel@tonic-gate 	 * If we got a request to set the ACL and the MODE, only
48707c478bd9Sstevel@tonic-gate 	 * allow changing VSUID, VSGID, and VSVTX.  Attempting
48717c478bd9Sstevel@tonic-gate 	 * to change any other bits, along with setting an ACL,
48727c478bd9Sstevel@tonic-gate 	 * gives NFS4ERR_INVAL.
48737c478bd9Sstevel@tonic-gate 	 */
48747c478bd9Sstevel@tonic-gate 	if ((fattrp->attrmask & FATTR4_ACL_MASK) &&
48757c478bd9Sstevel@tonic-gate 	    (fattrp->attrmask & FATTR4_MODE_MASK)) {
48767c478bd9Sstevel@tonic-gate 		vattr_t va;
48777c478bd9Sstevel@tonic-gate 
48787c478bd9Sstevel@tonic-gate 		va.va_mask = AT_MODE;
4879da6c28aaSamw 		error = VOP_GETATTR(vp, &va, 0, cs->cr, NULL);
48807c478bd9Sstevel@tonic-gate 		if (error) {
48817c478bd9Sstevel@tonic-gate 			status = puterrno4(error);
48827c478bd9Sstevel@tonic-gate 			goto done;
48837c478bd9Sstevel@tonic-gate 		}
48847c478bd9Sstevel@tonic-gate 		if ((sarg.vap->va_mode ^ va.va_mode) &
48857c478bd9Sstevel@tonic-gate 		    ~(VSUID | VSGID | VSVTX)) {
48867c478bd9Sstevel@tonic-gate 			status = NFS4ERR_INVAL;
48877c478bd9Sstevel@tonic-gate 			goto done;
48887c478bd9Sstevel@tonic-gate 		}
48897c478bd9Sstevel@tonic-gate 	}
48907c478bd9Sstevel@tonic-gate 
48917c478bd9Sstevel@tonic-gate 	/* Check stateid only if size has been set */
48927c478bd9Sstevel@tonic-gate 	if (sarg.vap->va_mask & AT_SIZE) {
48937c478bd9Sstevel@tonic-gate 		trunc = (sarg.vap->va_size == 0);
48947c478bd9Sstevel@tonic-gate 		status = rfs4_check_stateid(FWRITE, cs->vp, stateid,
4895da6c28aaSamw 		    trunc, &cs->deleg, sarg.vap->va_mask & AT_SIZE, &ct);
48967c478bd9Sstevel@tonic-gate 		if (status != NFS4_OK)
48977c478bd9Sstevel@tonic-gate 			goto done;
4898da6c28aaSamw 	} else {
4899da6c28aaSamw 		ct.cc_sysid = 0;
4900da6c28aaSamw 		ct.cc_pid = 0;
4901da6c28aaSamw 		ct.cc_caller_id = nfs4_srv_caller_id;
49027c478bd9Sstevel@tonic-gate 	}
49037c478bd9Sstevel@tonic-gate 
49047c478bd9Sstevel@tonic-gate 	/* XXX start of possible race with delegations */
49057c478bd9Sstevel@tonic-gate 
49067c478bd9Sstevel@tonic-gate 	/*
49077c478bd9Sstevel@tonic-gate 	 * We need to specially handle size changes because it is
49087c478bd9Sstevel@tonic-gate 	 * possible for the client to create a file with read-only
49097c478bd9Sstevel@tonic-gate 	 * modes, but with the file opened for writing. If the client
49107c478bd9Sstevel@tonic-gate 	 * then tries to set the file size, e.g. ftruncate(3C),
49117c478bd9Sstevel@tonic-gate 	 * fcntl(F_FREESP), the normal access checking done in
49127c478bd9Sstevel@tonic-gate 	 * VOP_SETATTR would prevent the client from doing it even though
49137c478bd9Sstevel@tonic-gate 	 * it should be allowed to do so.  To get around this, we do the
49147c478bd9Sstevel@tonic-gate 	 * access checking for ourselves and use VOP_SPACE which doesn't
49157c478bd9Sstevel@tonic-gate 	 * do the access checking.
49167c478bd9Sstevel@tonic-gate 	 * Also the client should not be allowed to change the file
49177c478bd9Sstevel@tonic-gate 	 * size if there is a conflicting non-blocking mandatory lock in
49187c478bd9Sstevel@tonic-gate 	 * the region of the change.
49197c478bd9Sstevel@tonic-gate 	 */
49207c478bd9Sstevel@tonic-gate 	if (vp->v_type == VREG && (sarg.vap->va_mask & AT_SIZE)) {
49217c478bd9Sstevel@tonic-gate 		u_offset_t offset;
49227c478bd9Sstevel@tonic-gate 		ssize_t length;
49237c478bd9Sstevel@tonic-gate 
49249720e166Sjasmith 		/*
49259720e166Sjasmith 		 * ufs_setattr clears AT_SIZE from vap->va_mask, but
49269720e166Sjasmith 		 * before returning, sarg.vap->va_mask is used to
49279720e166Sjasmith 		 * generate the setattr reply bitmap.  We also clear
49289720e166Sjasmith 		 * AT_SIZE below before calling VOP_SPACE.  For both
49299720e166Sjasmith 		 * of these cases, the va_mask needs to be saved here
49309720e166Sjasmith 		 * and restored after calling VOP_SETATTR.
49319720e166Sjasmith 		 */
49329720e166Sjasmith 		saved_mask = sarg.vap->va_mask;
49339720e166Sjasmith 
49347c478bd9Sstevel@tonic-gate 		/*
49357c478bd9Sstevel@tonic-gate 		 * Check any possible conflict due to NBMAND locks.
49367c478bd9Sstevel@tonic-gate 		 * Get into critical region before VOP_GETATTR, so the
49377c478bd9Sstevel@tonic-gate 		 * size attribute is valid when checking conflicts.
49387c478bd9Sstevel@tonic-gate 		 */
49397c478bd9Sstevel@tonic-gate 		if (nbl_need_check(vp)) {
49407c478bd9Sstevel@tonic-gate 			nbl_start_crit(vp, RW_READER);
49417c478bd9Sstevel@tonic-gate 			in_crit = 1;
49427c478bd9Sstevel@tonic-gate 		}
49437c478bd9Sstevel@tonic-gate 
49447c478bd9Sstevel@tonic-gate 		bva.va_mask = AT_UID|AT_SIZE;
4945da6c28aaSamw 		if (error = VOP_GETATTR(vp, &bva, 0, cr, &ct)) {
49467c478bd9Sstevel@tonic-gate 			status = puterrno4(error);
49477c478bd9Sstevel@tonic-gate 			goto done;
49487c478bd9Sstevel@tonic-gate 		}
49497c478bd9Sstevel@tonic-gate 
49507c478bd9Sstevel@tonic-gate 		if (in_crit) {
49517c478bd9Sstevel@tonic-gate 			if (sarg.vap->va_size < bva.va_size) {
49527c478bd9Sstevel@tonic-gate 				offset = sarg.vap->va_size;
49537c478bd9Sstevel@tonic-gate 				length = bva.va_size - sarg.vap->va_size;
49547c478bd9Sstevel@tonic-gate 			} else {
49557c478bd9Sstevel@tonic-gate 				offset = bva.va_size;
49567c478bd9Sstevel@tonic-gate 				length = sarg.vap->va_size - bva.va_size;
49577c478bd9Sstevel@tonic-gate 			}
4958da6c28aaSamw 			if (nbl_conflict(vp, NBL_WRITE, offset, length, 0,
4959da6c28aaSamw 			    &ct)) {
49607c478bd9Sstevel@tonic-gate 				status = NFS4ERR_LOCKED;
49617c478bd9Sstevel@tonic-gate 				goto done;
49627c478bd9Sstevel@tonic-gate 			}
49637c478bd9Sstevel@tonic-gate 		}
49647c478bd9Sstevel@tonic-gate 
49657c478bd9Sstevel@tonic-gate 		if (crgetuid(cr) == bva.va_uid) {
49667c478bd9Sstevel@tonic-gate 			sarg.vap->va_mask &= ~AT_SIZE;
49677c478bd9Sstevel@tonic-gate 			bf.l_type = F_WRLCK;
49687c478bd9Sstevel@tonic-gate 			bf.l_whence = 0;
49697c478bd9Sstevel@tonic-gate 			bf.l_start = (off64_t)sarg.vap->va_size;
49707c478bd9Sstevel@tonic-gate 			bf.l_len = 0;
49717c478bd9Sstevel@tonic-gate 			bf.l_sysid = 0;
49727c478bd9Sstevel@tonic-gate 			bf.l_pid = 0;
49737c478bd9Sstevel@tonic-gate 			error = VOP_SPACE(vp, F_FREESP, &bf, FWRITE,
49741b300de9Sjwahlig 			    (offset_t)sarg.vap->va_size, cr, &ct);
49757c478bd9Sstevel@tonic-gate 		}
49767c478bd9Sstevel@tonic-gate 	}
49777c478bd9Sstevel@tonic-gate 
49787c478bd9Sstevel@tonic-gate 	if (!error && sarg.vap->va_mask != 0)
49797c478bd9Sstevel@tonic-gate 		error = VOP_SETATTR(vp, sarg.vap, sarg.flag, cr, &ct);
49807c478bd9Sstevel@tonic-gate 
49819720e166Sjasmith 	/* restore va_mask -- ufs_setattr clears AT_SIZE */
49827c478bd9Sstevel@tonic-gate 	if (saved_mask & AT_SIZE)
49837c478bd9Sstevel@tonic-gate 		sarg.vap->va_mask |= AT_SIZE;
49847c478bd9Sstevel@tonic-gate 
49857c478bd9Sstevel@tonic-gate 	/*
49867c478bd9Sstevel@tonic-gate 	 * If an ACL was being set, it has been delayed until now,
49877c478bd9Sstevel@tonic-gate 	 * in order to set the mode (via the VOP_SETATTR() above) first.
49887c478bd9Sstevel@tonic-gate 	 */
49897c478bd9Sstevel@tonic-gate 	if ((! error) && (fattrp->attrmask & FATTR4_ACL_MASK)) {
49907c478bd9Sstevel@tonic-gate 		int i;
49917c478bd9Sstevel@tonic-gate 
49927c478bd9Sstevel@tonic-gate 		for (i = 0; i < NFS4_MAXNUM_ATTRS; i++)
49937c478bd9Sstevel@tonic-gate 			if (ntov.amap[i] == FATTR4_ACL)
49947c478bd9Sstevel@tonic-gate 				break;
49957c478bd9Sstevel@tonic-gate 		if (i < NFS4_MAXNUM_ATTRS) {
49967c478bd9Sstevel@tonic-gate 			error = (*nfs4_ntov_map[FATTR4_ACL].sv_getit)(
49977c478bd9Sstevel@tonic-gate 			    NFS4ATTR_SETIT, &sarg, &ntov.na[i]);
49987c478bd9Sstevel@tonic-gate 			if (error == 0) {
49997c478bd9Sstevel@tonic-gate 				*resp |= FATTR4_ACL_MASK;
50007c478bd9Sstevel@tonic-gate 			} else if (error == ENOTSUP) {
50017c478bd9Sstevel@tonic-gate 				(void) rfs4_verify_attr(&sarg, resp, &ntov);
50027c478bd9Sstevel@tonic-gate 				status = NFS4ERR_ATTRNOTSUPP;
50037c478bd9Sstevel@tonic-gate 				goto done;
50047c478bd9Sstevel@tonic-gate 			}
50057c478bd9Sstevel@tonic-gate 		} else {
50067c478bd9Sstevel@tonic-gate 			NFS4_DEBUG(rfs4_debug,
50077c478bd9Sstevel@tonic-gate 			    (CE_NOTE, "do_rfs4_op_setattr: "
50087c478bd9Sstevel@tonic-gate 			    "unable to find ACL in fattr4"));
50097c478bd9Sstevel@tonic-gate 			error = EINVAL;
50107c478bd9Sstevel@tonic-gate 		}
50117c478bd9Sstevel@tonic-gate 	}
50127c478bd9Sstevel@tonic-gate 
50137c478bd9Sstevel@tonic-gate 	if (error) {
50147c478bd9Sstevel@tonic-gate 		status = puterrno4(error);
50157c478bd9Sstevel@tonic-gate 
50167c478bd9Sstevel@tonic-gate 		/*
50177c478bd9Sstevel@tonic-gate 		 * Set the response bitmap when setattr failed.
50187c478bd9Sstevel@tonic-gate 		 * If VOP_SETATTR partially succeeded, test by doing a
50197c478bd9Sstevel@tonic-gate 		 * VOP_GETATTR on the object and comparing the data
50207c478bd9Sstevel@tonic-gate 		 * to the setattr arguments.
50217c478bd9Sstevel@tonic-gate 		 */
50227c478bd9Sstevel@tonic-gate 		(void) rfs4_verify_attr(&sarg, resp, &ntov);
50237c478bd9Sstevel@tonic-gate 	} else {
50247c478bd9Sstevel@tonic-gate 		/*
50257c478bd9Sstevel@tonic-gate 		 * Force modified metadata out to stable storage.
50267c478bd9Sstevel@tonic-gate 		 */
5027da6c28aaSamw 		(void) VOP_FSYNC(vp, FNODSYNC, cr, &ct);
50287c478bd9Sstevel@tonic-gate 		/*
50297c478bd9Sstevel@tonic-gate 		 * Set response bitmap
50307c478bd9Sstevel@tonic-gate 		 */
50319720e166Sjasmith 		nfs4_vmask_to_nmask_set(sarg.vap->va_mask, resp);
50327c478bd9Sstevel@tonic-gate 	}
50337c478bd9Sstevel@tonic-gate 
50347c478bd9Sstevel@tonic-gate /* Return early and already have a NFSv4 error */
50357c478bd9Sstevel@tonic-gate done:
50369720e166Sjasmith 	/*
50379720e166Sjasmith 	 * Except for nfs4_vmask_to_nmask_set(), vattr --> fattr
50389720e166Sjasmith 	 * conversion sets both readable and writeable NFS4 attrs
50399720e166Sjasmith 	 * for AT_MTIME and AT_ATIME.  The line below masks out
50409720e166Sjasmith 	 * unrequested attrs from the setattr result bitmap.  This
50419720e166Sjasmith 	 * is placed after the done: label to catch the ATTRNOTSUP
50429720e166Sjasmith 	 * case.
50439720e166Sjasmith 	 */
50449720e166Sjasmith 	*resp &= fattrp->attrmask;
50459720e166Sjasmith 
50467c478bd9Sstevel@tonic-gate 	if (in_crit)
50477c478bd9Sstevel@tonic-gate 		nbl_end_crit(vp);
50487c478bd9Sstevel@tonic-gate 
50497c478bd9Sstevel@tonic-gate 	nfs4_ntov_table_free(&ntov, &sarg);
50507c478bd9Sstevel@tonic-gate 
50517c478bd9Sstevel@tonic-gate 	return (status);
50527c478bd9Sstevel@tonic-gate }
50537c478bd9Sstevel@tonic-gate 
50547c478bd9Sstevel@tonic-gate /* ARGSUSED */
50557c478bd9Sstevel@tonic-gate static void
50567c478bd9Sstevel@tonic-gate rfs4_op_setattr(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
50577c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
50587c478bd9Sstevel@tonic-gate {
50597c478bd9Sstevel@tonic-gate 	SETATTR4args *args = &argop->nfs_argop4_u.opsetattr;
50607c478bd9Sstevel@tonic-gate 	SETATTR4res *resp = &resop->nfs_resop4_u.opsetattr;
506145916cd2Sjpk 	bslabel_t *clabel;
50627c478bd9Sstevel@tonic-gate 
5063*f3b585ceSsamf 	DTRACE_NFSV4_2(op__setattr__start, struct compound_state *, cs,
5064*f3b585ceSsamf 	    SETATTR4args *, args);
5065*f3b585ceSsamf 
50667c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
50677c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
5068*f3b585ceSsamf 		goto out;
50697c478bd9Sstevel@tonic-gate 	}
50707c478bd9Sstevel@tonic-gate 
50717c478bd9Sstevel@tonic-gate 	/*
50727c478bd9Sstevel@tonic-gate 	 * If there is an unshared filesystem mounted on this vnode,
50737c478bd9Sstevel@tonic-gate 	 * do not allow to setattr on this vnode.
50747c478bd9Sstevel@tonic-gate 	 */
50757c478bd9Sstevel@tonic-gate 	if (vn_ismntpt(cs->vp)) {
50767c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
5077*f3b585ceSsamf 		goto out;
50787c478bd9Sstevel@tonic-gate 	}
50797c478bd9Sstevel@tonic-gate 
50807c478bd9Sstevel@tonic-gate 	resp->attrsset = 0;
50817c478bd9Sstevel@tonic-gate 
50827c478bd9Sstevel@tonic-gate 	if (rdonly4(cs->exi, cs->vp, req)) {
50837c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ROFS;
5084*f3b585ceSsamf 		goto out;
50857c478bd9Sstevel@tonic-gate 	}
50867c478bd9Sstevel@tonic-gate 
508745916cd2Sjpk 	/* check label before setting attributes */
508845916cd2Sjpk 	if (is_system_labeled()) {
508945916cd2Sjpk 		ASSERT(req->rq_label != NULL);
509045916cd2Sjpk 		clabel = req->rq_label;
509145916cd2Sjpk 		DTRACE_PROBE2(tx__rfs4__log__info__opsetattr__clabel, char *,
509245916cd2Sjpk 		    "got client label from request(1)",
509345916cd2Sjpk 		    struct svc_req *, req);
509445916cd2Sjpk 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
509503986916Sjarrett 			if (!do_rfs_label_check(clabel, cs->vp,
509645916cd2Sjpk 			    EQUALITY_CHECK)) {
509745916cd2Sjpk 				*cs->statusp = resp->status = NFS4ERR_ACCESS;
5098*f3b585ceSsamf 				goto out;
509945916cd2Sjpk 			}
510045916cd2Sjpk 		}
510145916cd2Sjpk 	}
510245916cd2Sjpk 
51037c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status =
51041b300de9Sjwahlig 	    do_rfs4_op_setattr(&resp->attrsset, &args->obj_attributes, cs,
51051b300de9Sjwahlig 	    &args->stateid);
5106*f3b585ceSsamf 
5107*f3b585ceSsamf out:
5108*f3b585ceSsamf 	DTRACE_NFSV4_2(op__setattr__done, struct compound_state *, cs,
5109*f3b585ceSsamf 	    SETATTR4res *, resp);
51107c478bd9Sstevel@tonic-gate }
51117c478bd9Sstevel@tonic-gate 
51127c478bd9Sstevel@tonic-gate /* ARGSUSED */
51137c478bd9Sstevel@tonic-gate static void
51147c478bd9Sstevel@tonic-gate rfs4_op_verify(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
51157c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
51167c478bd9Sstevel@tonic-gate {
51177c478bd9Sstevel@tonic-gate 	/*
51187c478bd9Sstevel@tonic-gate 	 * verify and nverify are exactly the same, except that nverify
51197c478bd9Sstevel@tonic-gate 	 * succeeds when some argument changed, and verify succeeds when
51207c478bd9Sstevel@tonic-gate 	 * when none changed.
51217c478bd9Sstevel@tonic-gate 	 */
51227c478bd9Sstevel@tonic-gate 
51237c478bd9Sstevel@tonic-gate 	VERIFY4args  *args = &argop->nfs_argop4_u.opverify;
51247c478bd9Sstevel@tonic-gate 	VERIFY4res *resp = &resop->nfs_resop4_u.opverify;
51257c478bd9Sstevel@tonic-gate 
51267c478bd9Sstevel@tonic-gate 	int error;
51277c478bd9Sstevel@tonic-gate 	struct nfs4_svgetit_arg sarg;
51287c478bd9Sstevel@tonic-gate 	struct statvfs64 sb;
51297c478bd9Sstevel@tonic-gate 	struct nfs4_ntov_table ntov;
51307c478bd9Sstevel@tonic-gate 
5131*f3b585ceSsamf 	DTRACE_NFSV4_2(op__verify__start, struct compound_state *, cs,
5132*f3b585ceSsamf 	    VERIFY4args *, args);
5133*f3b585ceSsamf 
51347c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
51357c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
5136*f3b585ceSsamf 		goto out;
51377c478bd9Sstevel@tonic-gate 	}
51387c478bd9Sstevel@tonic-gate 
51397c478bd9Sstevel@tonic-gate 	sarg.sbp = &sb;
51407c478bd9Sstevel@tonic-gate 	nfs4_ntov_table_init(&ntov);
51417c478bd9Sstevel@tonic-gate 	resp->status = do_rfs4_set_attrs(NULL, &args->obj_attributes, cs,
51421b300de9Sjwahlig 	    &sarg, &ntov, NFS4ATTR_VERIT);
51437c478bd9Sstevel@tonic-gate 	if (resp->status != NFS4_OK) {
51447c478bd9Sstevel@tonic-gate 		/*
51457c478bd9Sstevel@tonic-gate 		 * do_rfs4_set_attrs will try to verify systemwide attrs,
51467c478bd9Sstevel@tonic-gate 		 * so could return -1 for "no match".
51477c478bd9Sstevel@tonic-gate 		 */
51487c478bd9Sstevel@tonic-gate 		if (resp->status == -1)
51497c478bd9Sstevel@tonic-gate 			resp->status = NFS4ERR_NOT_SAME;
51507c478bd9Sstevel@tonic-gate 		goto done;
51517c478bd9Sstevel@tonic-gate 	}
51527c478bd9Sstevel@tonic-gate 	error = rfs4_verify_attr(&sarg, NULL, &ntov);
51537c478bd9Sstevel@tonic-gate 	switch (error) {
51547c478bd9Sstevel@tonic-gate 	case 0:
51557c478bd9Sstevel@tonic-gate 		resp->status = NFS4_OK;
51567c478bd9Sstevel@tonic-gate 		break;
51577c478bd9Sstevel@tonic-gate 	case -1:
51587c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_NOT_SAME;
51597c478bd9Sstevel@tonic-gate 		break;
51607c478bd9Sstevel@tonic-gate 	default:
51617c478bd9Sstevel@tonic-gate 		resp->status = puterrno4(error);
51627c478bd9Sstevel@tonic-gate 		break;
51637c478bd9Sstevel@tonic-gate 	}
51647c478bd9Sstevel@tonic-gate done:
51657c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status;
51667c478bd9Sstevel@tonic-gate 	nfs4_ntov_table_free(&ntov, &sarg);
5167*f3b585ceSsamf out:
5168*f3b585ceSsamf 	DTRACE_NFSV4_2(op__verify__done, struct compound_state *, cs,
5169*f3b585ceSsamf 	    VERIFY4res *, resp);
51707c478bd9Sstevel@tonic-gate }
51717c478bd9Sstevel@tonic-gate 
51727c478bd9Sstevel@tonic-gate /* ARGSUSED */
51737c478bd9Sstevel@tonic-gate static void
51747c478bd9Sstevel@tonic-gate rfs4_op_nverify(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
51757c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
51767c478bd9Sstevel@tonic-gate {
51777c478bd9Sstevel@tonic-gate 	/*
51787c478bd9Sstevel@tonic-gate 	 * verify and nverify are exactly the same, except that nverify
51797c478bd9Sstevel@tonic-gate 	 * succeeds when some argument changed, and verify succeeds when
51807c478bd9Sstevel@tonic-gate 	 * when none changed.
51817c478bd9Sstevel@tonic-gate 	 */
51827c478bd9Sstevel@tonic-gate 
51837c478bd9Sstevel@tonic-gate 	NVERIFY4args  *args = &argop->nfs_argop4_u.opnverify;
51847c478bd9Sstevel@tonic-gate 	NVERIFY4res *resp = &resop->nfs_resop4_u.opnverify;
51857c478bd9Sstevel@tonic-gate 
51867c478bd9Sstevel@tonic-gate 	int error;
51877c478bd9Sstevel@tonic-gate 	struct nfs4_svgetit_arg sarg;
51887c478bd9Sstevel@tonic-gate 	struct statvfs64 sb;
51897c478bd9Sstevel@tonic-gate 	struct nfs4_ntov_table ntov;
51907c478bd9Sstevel@tonic-gate 
5191*f3b585ceSsamf 	DTRACE_NFSV4_2(op__nverify__start, struct compound_state *, cs,
5192*f3b585ceSsamf 	    NVERIFY4args *, args);
5193*f3b585ceSsamf 
51947c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
51957c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
5196*f3b585ceSsamf 		DTRACE_NFSV4_2(op__nverify__done, struct compound_state *, cs,
5197*f3b585ceSsamf 		    NVERIFY4res *, resp);
51987c478bd9Sstevel@tonic-gate 		return;
51997c478bd9Sstevel@tonic-gate 	}
52007c478bd9Sstevel@tonic-gate 	sarg.sbp = &sb;
52017c478bd9Sstevel@tonic-gate 	nfs4_ntov_table_init(&ntov);
52027c478bd9Sstevel@tonic-gate 	resp->status = do_rfs4_set_attrs(NULL, &args->obj_attributes, cs,
52031b300de9Sjwahlig 	    &sarg, &ntov, NFS4ATTR_VERIT);
52047c478bd9Sstevel@tonic-gate 	if (resp->status != NFS4_OK) {
52057c478bd9Sstevel@tonic-gate 		/*
52067c478bd9Sstevel@tonic-gate 		 * do_rfs4_set_attrs will try to verify systemwide attrs,
52077c478bd9Sstevel@tonic-gate 		 * so could return -1 for "no match".
52087c478bd9Sstevel@tonic-gate 		 */
52097c478bd9Sstevel@tonic-gate 		if (resp->status == -1)
52107c478bd9Sstevel@tonic-gate 			resp->status = NFS4_OK;
52117c478bd9Sstevel@tonic-gate 		goto done;
52127c478bd9Sstevel@tonic-gate 	}
52137c478bd9Sstevel@tonic-gate 	error = rfs4_verify_attr(&sarg, NULL, &ntov);
52147c478bd9Sstevel@tonic-gate 	switch (error) {
52157c478bd9Sstevel@tonic-gate 	case 0:
52167c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_SAME;
52177c478bd9Sstevel@tonic-gate 		break;
52187c478bd9Sstevel@tonic-gate 	case -1:
52197c478bd9Sstevel@tonic-gate 		resp->status = NFS4_OK;
52207c478bd9Sstevel@tonic-gate 		break;
52217c478bd9Sstevel@tonic-gate 	default:
52227c478bd9Sstevel@tonic-gate 		resp->status = puterrno4(error);
52237c478bd9Sstevel@tonic-gate 		break;
52247c478bd9Sstevel@tonic-gate 	}
52257c478bd9Sstevel@tonic-gate done:
52267c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status;
52277c478bd9Sstevel@tonic-gate 	nfs4_ntov_table_free(&ntov, &sarg);
5228*f3b585ceSsamf 
5229*f3b585ceSsamf 	DTRACE_NFSV4_2(op__nverify__done, struct compound_state *, cs,
5230*f3b585ceSsamf 	    NVERIFY4res *, resp);
52317c478bd9Sstevel@tonic-gate }
52327c478bd9Sstevel@tonic-gate 
52337c478bd9Sstevel@tonic-gate /*
52347c478bd9Sstevel@tonic-gate  * XXX - This should live in an NFS header file.
52357c478bd9Sstevel@tonic-gate  */
52367c478bd9Sstevel@tonic-gate #define	MAX_IOVECS	12
52377c478bd9Sstevel@tonic-gate 
52387c478bd9Sstevel@tonic-gate /* ARGSUSED */
52397c478bd9Sstevel@tonic-gate static void
52407c478bd9Sstevel@tonic-gate rfs4_op_write(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
52417c478bd9Sstevel@tonic-gate 	struct compound_state *cs)
52427c478bd9Sstevel@tonic-gate {
5243*f3b585ceSsamf 	WRITE4args *args = &argop->nfs_argop4_u.opwrite;
52447c478bd9Sstevel@tonic-gate 	WRITE4res *resp = &resop->nfs_resop4_u.opwrite;
52457c478bd9Sstevel@tonic-gate 	int error;
52467c478bd9Sstevel@tonic-gate 	vnode_t *vp;
52477c478bd9Sstevel@tonic-gate 	struct vattr bva;
52487c478bd9Sstevel@tonic-gate 	u_offset_t rlimit;
52497c478bd9Sstevel@tonic-gate 	struct uio uio;
52507c478bd9Sstevel@tonic-gate 	struct iovec iov[MAX_IOVECS];
52517c478bd9Sstevel@tonic-gate 	struct iovec *iovp;
52527c478bd9Sstevel@tonic-gate 	int iovcnt;
52537c478bd9Sstevel@tonic-gate 	int ioflag;
52547c478bd9Sstevel@tonic-gate 	cred_t *savecred, *cr;
52557c478bd9Sstevel@tonic-gate 	bool_t *deleg = &cs->deleg;
52567c478bd9Sstevel@tonic-gate 	nfsstat4 stat;
52577c478bd9Sstevel@tonic-gate 	int in_crit = 0;
5258da6c28aaSamw 	caller_context_t ct;
52597c478bd9Sstevel@tonic-gate 
5260*f3b585ceSsamf 	DTRACE_NFSV4_2(op__write__start, struct compound_state *, cs,
5261*f3b585ceSsamf 	    WRITE4args *, args);
5262*f3b585ceSsamf 
52637c478bd9Sstevel@tonic-gate 	vp = cs->vp;
52647c478bd9Sstevel@tonic-gate 	if (vp == NULL) {
52657c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
5266*f3b585ceSsamf 		goto out;
52677c478bd9Sstevel@tonic-gate 	}
52687c478bd9Sstevel@tonic-gate 	if (cs->access == CS_ACCESS_DENIED) {
52697c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
5270*f3b585ceSsamf 		goto out;
52717c478bd9Sstevel@tonic-gate 	}
52727c478bd9Sstevel@tonic-gate 
52737c478bd9Sstevel@tonic-gate 	cr = cs->cr;
52747c478bd9Sstevel@tonic-gate 
5275da6c28aaSamw 	if ((stat = rfs4_check_stateid(FWRITE, vp, &args->stateid, FALSE,
5276da6c28aaSamw 	    deleg, TRUE, &ct)) != NFS4_OK) {
5277da6c28aaSamw 		*cs->statusp = resp->status = stat;
5278da6c28aaSamw 		goto out;
5279da6c28aaSamw 	}
5280da6c28aaSamw 
52817c478bd9Sstevel@tonic-gate 	/*
52827c478bd9Sstevel@tonic-gate 	 * We have to enter the critical region before calling VOP_RWLOCK
52837c478bd9Sstevel@tonic-gate 	 * to avoid a deadlock with ufs.
52847c478bd9Sstevel@tonic-gate 	 */
52857c478bd9Sstevel@tonic-gate 	if (nbl_need_check(vp)) {
52867c478bd9Sstevel@tonic-gate 		nbl_start_crit(vp, RW_READER);
52877c478bd9Sstevel@tonic-gate 		in_crit = 1;
52887c478bd9Sstevel@tonic-gate 		if (nbl_conflict(vp, NBL_WRITE,
5289da6c28aaSamw 		    args->offset, args->data_len, 0, &ct)) {
52907c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_LOCKED;
52917c478bd9Sstevel@tonic-gate 			goto out;
52927c478bd9Sstevel@tonic-gate 		}
52937c478bd9Sstevel@tonic-gate 	}
52947c478bd9Sstevel@tonic-gate 
52957c478bd9Sstevel@tonic-gate 	bva.va_mask = AT_MODE | AT_UID;
5296da6c28aaSamw 	error = VOP_GETATTR(vp, &bva, 0, cr, &ct);
52977c478bd9Sstevel@tonic-gate 
52987c478bd9Sstevel@tonic-gate 	/*
52997c478bd9Sstevel@tonic-gate 	 * If we can't get the attributes, then we can't do the
53007c478bd9Sstevel@tonic-gate 	 * right access checking.  So, we'll fail the request.
53017c478bd9Sstevel@tonic-gate 	 */
53027c478bd9Sstevel@tonic-gate 	if (error) {
53037c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
53047c478bd9Sstevel@tonic-gate 		goto out;
53057c478bd9Sstevel@tonic-gate 	}
53067c478bd9Sstevel@tonic-gate 
53077c478bd9Sstevel@tonic-gate 	if (rdonly4(cs->exi, cs->vp, req)) {
53087c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ROFS;
53097c478bd9Sstevel@tonic-gate 		goto out;
53107c478bd9Sstevel@tonic-gate 	}
53117c478bd9Sstevel@tonic-gate 
53127c478bd9Sstevel@tonic-gate 	if (vp->v_type != VREG) {
53137c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status =
53141b300de9Sjwahlig 		    ((vp->v_type == VDIR) ? NFS4ERR_ISDIR : NFS4ERR_INVAL);
53157c478bd9Sstevel@tonic-gate 		goto out;
53167c478bd9Sstevel@tonic-gate 	}
53177c478bd9Sstevel@tonic-gate 
53187c478bd9Sstevel@tonic-gate 	if (crgetuid(cr) != bva.va_uid &&
5319da6c28aaSamw 	    (error = VOP_ACCESS(vp, VWRITE, 0, cr, &ct))) {
53207c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
53217c478bd9Sstevel@tonic-gate 		goto out;
53227c478bd9Sstevel@tonic-gate 	}
53237c478bd9Sstevel@tonic-gate 
53247c478bd9Sstevel@tonic-gate 	if (MANDLOCK(vp, bva.va_mode)) {
53257c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
53267c478bd9Sstevel@tonic-gate 		goto out;
53277c478bd9Sstevel@tonic-gate 	}
53287c478bd9Sstevel@tonic-gate 
53297c478bd9Sstevel@tonic-gate 	if (args->data_len == 0) {
53307c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4_OK;
53317c478bd9Sstevel@tonic-gate 		resp->count = 0;
53327c478bd9Sstevel@tonic-gate 		resp->committed = args->stable;
53337c478bd9Sstevel@tonic-gate 		resp->writeverf = Write4verf;
53347c478bd9Sstevel@tonic-gate 		goto out;
53357c478bd9Sstevel@tonic-gate 	}
53367c478bd9Sstevel@tonic-gate 
53377c478bd9Sstevel@tonic-gate 	if (args->mblk != NULL) {
53387c478bd9Sstevel@tonic-gate 		mblk_t *m;
53397c478bd9Sstevel@tonic-gate 		uint_t bytes, round_len;
53407c478bd9Sstevel@tonic-gate 
53417c478bd9Sstevel@tonic-gate 		iovcnt = 0;
53427c478bd9Sstevel@tonic-gate 		bytes = 0;
53437c478bd9Sstevel@tonic-gate 		round_len = roundup(args->data_len, BYTES_PER_XDR_UNIT);
53447c478bd9Sstevel@tonic-gate 		for (m = args->mblk;
53457c478bd9Sstevel@tonic-gate 		    m != NULL && bytes < round_len;
53467c478bd9Sstevel@tonic-gate 		    m = m->b_cont) {
53477c478bd9Sstevel@tonic-gate 			iovcnt++;
53487c478bd9Sstevel@tonic-gate 			bytes += MBLKL(m);
53497c478bd9Sstevel@tonic-gate 		}
53507c478bd9Sstevel@tonic-gate #ifdef DEBUG
53517c478bd9Sstevel@tonic-gate 		/* should have ended on an mblk boundary */
53527c478bd9Sstevel@tonic-gate 		if (bytes != round_len) {
53537c478bd9Sstevel@tonic-gate 			printf("bytes=0x%x, round_len=0x%x, req len=0x%x\n",
53547c478bd9Sstevel@tonic-gate 			    bytes, round_len, args->data_len);
53557c478bd9Sstevel@tonic-gate 			printf("args=%p, args->mblk=%p, m=%p", (void *)args,
53567c478bd9Sstevel@tonic-gate 			    (void *)args->mblk, (void *)m);
53577c478bd9Sstevel@tonic-gate 			ASSERT(bytes == round_len);
53587c478bd9Sstevel@tonic-gate 		}
53597c478bd9Sstevel@tonic-gate #endif
53607c478bd9Sstevel@tonic-gate 		if (iovcnt <= MAX_IOVECS) {
53617c478bd9Sstevel@tonic-gate 			iovp = iov;
53627c478bd9Sstevel@tonic-gate 		} else {
53637c478bd9Sstevel@tonic-gate 			iovp = kmem_alloc(sizeof (*iovp) * iovcnt, KM_SLEEP);
53647c478bd9Sstevel@tonic-gate 		}
53657c478bd9Sstevel@tonic-gate 		mblk_to_iov(args->mblk, iovcnt, iovp);
53667c478bd9Sstevel@tonic-gate 	} else {
53677c478bd9Sstevel@tonic-gate 		iovcnt = 1;
53687c478bd9Sstevel@tonic-gate 		iovp = iov;
53697c478bd9Sstevel@tonic-gate 		iovp->iov_base = args->data_val;
53707c478bd9Sstevel@tonic-gate 		iovp->iov_len = args->data_len;
53717c478bd9Sstevel@tonic-gate 	}
53727c478bd9Sstevel@tonic-gate 
53737c478bd9Sstevel@tonic-gate 	uio.uio_iov = iovp;
53747c478bd9Sstevel@tonic-gate 	uio.uio_iovcnt = iovcnt;
53757c478bd9Sstevel@tonic-gate 
53767c478bd9Sstevel@tonic-gate 	uio.uio_segflg = UIO_SYSSPACE;
53777c478bd9Sstevel@tonic-gate 	uio.uio_extflg = UIO_COPY_DEFAULT;
53787c478bd9Sstevel@tonic-gate 	uio.uio_loffset = args->offset;
53797c478bd9Sstevel@tonic-gate 	uio.uio_resid = args->data_len;
53807c478bd9Sstevel@tonic-gate 	uio.uio_llimit = curproc->p_fsz_ctl;
53817c478bd9Sstevel@tonic-gate 	rlimit = uio.uio_llimit - args->offset;
53827c478bd9Sstevel@tonic-gate 	if (rlimit < (u_offset_t)uio.uio_resid)
53837c478bd9Sstevel@tonic-gate 		uio.uio_resid = (int)rlimit;
53847c478bd9Sstevel@tonic-gate 
53857c478bd9Sstevel@tonic-gate 	if (args->stable == UNSTABLE4)
53867c478bd9Sstevel@tonic-gate 		ioflag = 0;
53877c478bd9Sstevel@tonic-gate 	else if (args->stable == FILE_SYNC4)
53887c478bd9Sstevel@tonic-gate 		ioflag = FSYNC;
53897c478bd9Sstevel@tonic-gate 	else if (args->stable == DATA_SYNC4)
53907c478bd9Sstevel@tonic-gate 		ioflag = FDSYNC;
53917c478bd9Sstevel@tonic-gate 	else {
53927c478bd9Sstevel@tonic-gate 		if (iovp != iov)
53937c478bd9Sstevel@tonic-gate 			kmem_free(iovp, sizeof (*iovp) * iovcnt);
53947c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
53957c478bd9Sstevel@tonic-gate 		goto out;
53967c478bd9Sstevel@tonic-gate 	}
53977c478bd9Sstevel@tonic-gate 
53987c478bd9Sstevel@tonic-gate 	/*
53997c478bd9Sstevel@tonic-gate 	 * We're changing creds because VM may fault and we need
54007c478bd9Sstevel@tonic-gate 	 * the cred of the current thread to be used if quota
54017c478bd9Sstevel@tonic-gate 	 * checking is enabled.
54027c478bd9Sstevel@tonic-gate 	 */
54037c478bd9Sstevel@tonic-gate 	savecred = curthread->t_cred;
54047c478bd9Sstevel@tonic-gate 	curthread->t_cred = cr;
5405da6c28aaSamw 	error = do_io(FWRITE, vp, &uio, ioflag, cr, &ct);
54067c478bd9Sstevel@tonic-gate 	curthread->t_cred = savecred;
54077c478bd9Sstevel@tonic-gate 
54087c478bd9Sstevel@tonic-gate 	if (iovp != iov)
54097c478bd9Sstevel@tonic-gate 		kmem_free(iovp, sizeof (*iovp) * iovcnt);
54107c478bd9Sstevel@tonic-gate 
54117c478bd9Sstevel@tonic-gate 	if (error) {
54127c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
54137c478bd9Sstevel@tonic-gate 		goto out;
54147c478bd9Sstevel@tonic-gate 	}
54157c478bd9Sstevel@tonic-gate 
54167c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
54177c478bd9Sstevel@tonic-gate 	resp->count = args->data_len - uio.uio_resid;
54187c478bd9Sstevel@tonic-gate 
54197c478bd9Sstevel@tonic-gate 	if (ioflag == 0)
54207c478bd9Sstevel@tonic-gate 		resp->committed = UNSTABLE4;
54217c478bd9Sstevel@tonic-gate 	else
54227c478bd9Sstevel@tonic-gate 		resp->committed = FILE_SYNC4;
54237c478bd9Sstevel@tonic-gate 
54247c478bd9Sstevel@tonic-gate 	resp->writeverf = Write4verf;
54257c478bd9Sstevel@tonic-gate 
54267c478bd9Sstevel@tonic-gate out:
54277c478bd9Sstevel@tonic-gate 	if (in_crit)
54287c478bd9Sstevel@tonic-gate 		nbl_end_crit(vp);
5429*f3b585ceSsamf 
5430*f3b585ceSsamf 	DTRACE_NFSV4_2(op__write__done, struct compound_state *, cs,
5431*f3b585ceSsamf 	    WRITE4res *, resp);
54327c478bd9Sstevel@tonic-gate }
54337c478bd9Sstevel@tonic-gate 
54347c478bd9Sstevel@tonic-gate 
54357c478bd9Sstevel@tonic-gate /* XXX put in a header file */
54367c478bd9Sstevel@tonic-gate extern int	sec_svc_getcred(struct svc_req *, cred_t *,  caddr_t *, int *);
54377c478bd9Sstevel@tonic-gate 
54387c478bd9Sstevel@tonic-gate void
54397c478bd9Sstevel@tonic-gate rfs4_compound(COMPOUND4args *args, COMPOUND4res *resp, struct exportinfo *exi,
54407c478bd9Sstevel@tonic-gate 	struct svc_req *req, cred_t *cr)
54417c478bd9Sstevel@tonic-gate {
54427c478bd9Sstevel@tonic-gate 	uint_t i;
54437c478bd9Sstevel@tonic-gate 	struct compound_state cs;
54447c478bd9Sstevel@tonic-gate 
54457c478bd9Sstevel@tonic-gate 	rfs4_init_compound_state(&cs);
54467c478bd9Sstevel@tonic-gate 	/*
54477c478bd9Sstevel@tonic-gate 	 * Form a reply tag by copying over the reqeuest tag.
54487c478bd9Sstevel@tonic-gate 	 */
54497c478bd9Sstevel@tonic-gate 	resp->tag.utf8string_val =
54501b300de9Sjwahlig 	    kmem_alloc(args->tag.utf8string_len, KM_SLEEP);
54517c478bd9Sstevel@tonic-gate 	resp->tag.utf8string_len = args->tag.utf8string_len;
54527c478bd9Sstevel@tonic-gate 	bcopy(args->tag.utf8string_val, resp->tag.utf8string_val,
54531b300de9Sjwahlig 	    resp->tag.utf8string_len);
54547c478bd9Sstevel@tonic-gate 
54557c478bd9Sstevel@tonic-gate 	cs.statusp = &resp->status;
5456*f3b585ceSsamf 	cs.req = req;
54577c478bd9Sstevel@tonic-gate 
54587c478bd9Sstevel@tonic-gate 	/*
54597c478bd9Sstevel@tonic-gate 	 * XXX for now, minorversion should be zero
54607c478bd9Sstevel@tonic-gate 	 */
54617c478bd9Sstevel@tonic-gate 	if (args->minorversion != NFS4_MINORVERSION) {
5462*f3b585ceSsamf 		DTRACE_NFSV4_2(compound__start, struct compound_state *,
5463*f3b585ceSsamf 		    &cs, COMPOUND4args *, args);
54647c478bd9Sstevel@tonic-gate 		resp->array_len = 0;
54657c478bd9Sstevel@tonic-gate 		resp->array = NULL;
54667c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_MINOR_VERS_MISMATCH;
5467*f3b585ceSsamf 		DTRACE_NFSV4_2(compound__done, struct compound_state *,
5468*f3b585ceSsamf 		    &cs, COMPOUND4res *, resp);
5469*f3b585ceSsamf 		resp->array_len = 0;
54707c478bd9Sstevel@tonic-gate 		return;
54717c478bd9Sstevel@tonic-gate 	}
54727c478bd9Sstevel@tonic-gate 
54737c478bd9Sstevel@tonic-gate 	resp->array_len = args->array_len;
54747c478bd9Sstevel@tonic-gate 	resp->array = kmem_zalloc(args->array_len * sizeof (nfs_resop4),
54751b300de9Sjwahlig 	    KM_SLEEP);
54767c478bd9Sstevel@tonic-gate 
54777c478bd9Sstevel@tonic-gate 	ASSERT(exi == NULL);
54787c478bd9Sstevel@tonic-gate 	ASSERT(cr == NULL);
54797c478bd9Sstevel@tonic-gate 
54807c478bd9Sstevel@tonic-gate 	cr = crget();
54817c478bd9Sstevel@tonic-gate 	ASSERT(cr != NULL);
54827c478bd9Sstevel@tonic-gate 
54837c478bd9Sstevel@tonic-gate 	if (sec_svc_getcred(req, cr, &cs.principal, &cs.nfsflavor) == 0) {
5484*f3b585ceSsamf 		DTRACE_NFSV4_2(compound__start, struct compound_state *,
5485*f3b585ceSsamf 		    &cs, COMPOUND4args *, args);
54867c478bd9Sstevel@tonic-gate 		crfree(cr);
5487*f3b585ceSsamf 		DTRACE_NFSV4_2(compound__done, struct compound_state *,
5488*f3b585ceSsamf 		    &cs, COMPOUND4res *, resp);
54897c478bd9Sstevel@tonic-gate 		return;
54907c478bd9Sstevel@tonic-gate 	}
54917c478bd9Sstevel@tonic-gate 
54927c478bd9Sstevel@tonic-gate 	cs.basecr = cr;
54937c478bd9Sstevel@tonic-gate 
5494*f3b585ceSsamf 	DTRACE_NFSV4_2(compound__start, struct compound_state *, &cs,
5495*f3b585ceSsamf 	    COMPOUND4args *, args);
54967c478bd9Sstevel@tonic-gate 
54977c478bd9Sstevel@tonic-gate 	/*
54987c478bd9Sstevel@tonic-gate 	 * For now, NFS4 compound processing must be protected by
54997c478bd9Sstevel@tonic-gate 	 * exported_lock because it can access more than one exportinfo
55007c478bd9Sstevel@tonic-gate 	 * per compound and share/unshare can now change multiple
55017c478bd9Sstevel@tonic-gate 	 * exinfo structs.  The NFS2/3 code only refs 1 exportinfo
55027c478bd9Sstevel@tonic-gate 	 * per proc (excluding public exinfo), and exi_count design
55037c478bd9Sstevel@tonic-gate 	 * is sufficient to protect concurrent execution of NFS2/3
55047c478bd9Sstevel@tonic-gate 	 * ops along with unexport.  This lock will be removed as
55057c478bd9Sstevel@tonic-gate 	 * part of the NFSv4 phase 2 namespace redesign work.
55067c478bd9Sstevel@tonic-gate 	 */
55077c478bd9Sstevel@tonic-gate 	rw_enter(&exported_lock, RW_READER);
55087c478bd9Sstevel@tonic-gate 
55097c478bd9Sstevel@tonic-gate 	/*
55107c478bd9Sstevel@tonic-gate 	 * If this is the first compound we've seen, we need to start all
55117c478bd9Sstevel@tonic-gate 	 * new instances' grace periods.
55127c478bd9Sstevel@tonic-gate 	 */
55137c478bd9Sstevel@tonic-gate 	if (rfs4_seen_first_compound == 0) {
55147c478bd9Sstevel@tonic-gate 		rfs4_grace_start_new();
55157c478bd9Sstevel@tonic-gate 		/*
55167c478bd9Sstevel@tonic-gate 		 * This must be set after rfs4_grace_start_new(), otherwise
55177c478bd9Sstevel@tonic-gate 		 * another thread could proceed past here before the former
55187c478bd9Sstevel@tonic-gate 		 * is finished.
55197c478bd9Sstevel@tonic-gate 		 */
55207c478bd9Sstevel@tonic-gate 		rfs4_seen_first_compound = 1;
55217c478bd9Sstevel@tonic-gate 	}
55227c478bd9Sstevel@tonic-gate 
55237c478bd9Sstevel@tonic-gate 	for (i = 0; i < args->array_len && cs.cont; i++) {
55247c478bd9Sstevel@tonic-gate 		nfs_argop4 *argop;
55257c478bd9Sstevel@tonic-gate 		nfs_resop4 *resop;
55267c478bd9Sstevel@tonic-gate 		uint_t op;
55277c478bd9Sstevel@tonic-gate 
55287c478bd9Sstevel@tonic-gate 		argop = &args->array[i];
55297c478bd9Sstevel@tonic-gate 		resop = &resp->array[i];
55307c478bd9Sstevel@tonic-gate 		resop->resop = argop->argop;
55317c478bd9Sstevel@tonic-gate 		op = (uint_t)resop->resop;
55327c478bd9Sstevel@tonic-gate 
55337c478bd9Sstevel@tonic-gate 		if (op < rfsv4disp_cnt) {
55347c478bd9Sstevel@tonic-gate 			/*
55357c478bd9Sstevel@tonic-gate 			 * Count the individual ops here; NULL and COMPOUND
55367c478bd9Sstevel@tonic-gate 			 * are counted in common_dispatch()
55377c478bd9Sstevel@tonic-gate 			 */
55387c478bd9Sstevel@tonic-gate 			rfsproccnt_v4_ptr[op].value.ui64++;
55397c478bd9Sstevel@tonic-gate 
55407c478bd9Sstevel@tonic-gate 			NFS4_DEBUG(rfs4_debug > 1,
55411b300de9Sjwahlig 			    (CE_NOTE, "Executing %s", rfs4_op_string[op]));
55427c478bd9Sstevel@tonic-gate 			(*rfsv4disptab[op].dis_proc)(argop, resop, req, &cs);
55431b300de9Sjwahlig 			NFS4_DEBUG(rfs4_debug > 1, (CE_NOTE, "%s returned %d",
55441b300de9Sjwahlig 			    rfs4_op_string[op], *cs.statusp));
55457c478bd9Sstevel@tonic-gate 			if (*cs.statusp != NFS4_OK)
55467c478bd9Sstevel@tonic-gate 				cs.cont = FALSE;
55477c478bd9Sstevel@tonic-gate 		} else {
55487c478bd9Sstevel@tonic-gate 			/*
55497c478bd9Sstevel@tonic-gate 			 * This is effectively dead code since XDR code
55507c478bd9Sstevel@tonic-gate 			 * will have already returned BADXDR if op doesn't
55517c478bd9Sstevel@tonic-gate 			 * decode to legal value.  This only done for a
55527c478bd9Sstevel@tonic-gate 			 * day when XDR code doesn't verify v4 opcodes.
55537c478bd9Sstevel@tonic-gate 			 */
55547c478bd9Sstevel@tonic-gate 			op = OP_ILLEGAL;
55557c478bd9Sstevel@tonic-gate 			rfsproccnt_v4_ptr[OP_ILLEGAL_IDX].value.ui64++;
55567c478bd9Sstevel@tonic-gate 
55577c478bd9Sstevel@tonic-gate 			rfs4_op_illegal(argop, resop, req, &cs);
55587c478bd9Sstevel@tonic-gate 			cs.cont = FALSE;
55597c478bd9Sstevel@tonic-gate 		}
55607c478bd9Sstevel@tonic-gate 
55617c478bd9Sstevel@tonic-gate 		/*
55627c478bd9Sstevel@tonic-gate 		 * If not at last op, and if we are to stop, then
55637c478bd9Sstevel@tonic-gate 		 * compact the results array.
55647c478bd9Sstevel@tonic-gate 		 */
55657c478bd9Sstevel@tonic-gate 		if ((i + 1) < args->array_len && !cs.cont) {
55667c478bd9Sstevel@tonic-gate 			nfs_resop4 *new_res = kmem_alloc(
55671b300de9Sjwahlig 			    (i+1) * sizeof (nfs_resop4), KM_SLEEP);
55687c478bd9Sstevel@tonic-gate 			bcopy(resp->array,
55691b300de9Sjwahlig 			    new_res, (i+1) * sizeof (nfs_resop4));
55707c478bd9Sstevel@tonic-gate 			kmem_free(resp->array,
55711b300de9Sjwahlig 			    args->array_len * sizeof (nfs_resop4));
55727c478bd9Sstevel@tonic-gate 
55737c478bd9Sstevel@tonic-gate 			resp->array_len =  i + 1;
55747c478bd9Sstevel@tonic-gate 			resp->array = new_res;
55757c478bd9Sstevel@tonic-gate 		}
55767c478bd9Sstevel@tonic-gate 	}
55777c478bd9Sstevel@tonic-gate 
55787c478bd9Sstevel@tonic-gate 	rw_exit(&exported_lock);
55797c478bd9Sstevel@tonic-gate 
5580*f3b585ceSsamf 	DTRACE_NFSV4_2(compound__done, struct compound_state *, &cs,
5581*f3b585ceSsamf 	    COMPOUND4res *, resp);
5582*f3b585ceSsamf 
55837c478bd9Sstevel@tonic-gate 	if (cs.vp)
55847c478bd9Sstevel@tonic-gate 		VN_RELE(cs.vp);
55857c478bd9Sstevel@tonic-gate 	if (cs.saved_vp)
55867c478bd9Sstevel@tonic-gate 		VN_RELE(cs.saved_vp);
55877c478bd9Sstevel@tonic-gate 	if (cs.saved_fh.nfs_fh4_val)
55887c478bd9Sstevel@tonic-gate 		kmem_free(cs.saved_fh.nfs_fh4_val, NFS4_FHSIZE);
55897c478bd9Sstevel@tonic-gate 
55907c478bd9Sstevel@tonic-gate 	if (cs.basecr)
55917c478bd9Sstevel@tonic-gate 		crfree(cs.basecr);
55927c478bd9Sstevel@tonic-gate 	if (cs.cr)
55937c478bd9Sstevel@tonic-gate 		crfree(cs.cr);
559445916cd2Sjpk 	/*
559545916cd2Sjpk 	 * done with this compound request, free the label
559645916cd2Sjpk 	 */
559745916cd2Sjpk 
559845916cd2Sjpk 	if (req->rq_label != NULL) {
559945916cd2Sjpk 		kmem_free(req->rq_label, sizeof (bslabel_t));
560045916cd2Sjpk 		req->rq_label = NULL;
560145916cd2Sjpk 	}
56027c478bd9Sstevel@tonic-gate }
56037c478bd9Sstevel@tonic-gate 
56047c478bd9Sstevel@tonic-gate /*
56057c478bd9Sstevel@tonic-gate  * XXX because of what appears to be duplicate calls to rfs4_compound_free
56067c478bd9Sstevel@tonic-gate  * XXX zero out the tag and array values. Need to investigate why the
56077c478bd9Sstevel@tonic-gate  * XXX calls occur, but at least prevent the panic for now.
56087c478bd9Sstevel@tonic-gate  */
56097c478bd9Sstevel@tonic-gate void
56107c478bd9Sstevel@tonic-gate rfs4_compound_free(COMPOUND4res *resp)
56117c478bd9Sstevel@tonic-gate {
56127c478bd9Sstevel@tonic-gate 	uint_t i;
56137c478bd9Sstevel@tonic-gate 
56147c478bd9Sstevel@tonic-gate 	if (resp->tag.utf8string_val) {
56157c478bd9Sstevel@tonic-gate 		UTF8STRING_FREE(resp->tag)
56167c478bd9Sstevel@tonic-gate 	}
56177c478bd9Sstevel@tonic-gate 
56187c478bd9Sstevel@tonic-gate 	for (i = 0; i < resp->array_len; i++) {
56197c478bd9Sstevel@tonic-gate 		nfs_resop4 *resop;
56207c478bd9Sstevel@tonic-gate 		uint_t op;
56217c478bd9Sstevel@tonic-gate 
56227c478bd9Sstevel@tonic-gate 		resop = &resp->array[i];
56237c478bd9Sstevel@tonic-gate 		op = (uint_t)resop->resop;
56247c478bd9Sstevel@tonic-gate 		if (op < rfsv4disp_cnt) {
56257c478bd9Sstevel@tonic-gate 			(*rfsv4disptab[op].dis_resfree)(resop);
56267c478bd9Sstevel@tonic-gate 		}
56277c478bd9Sstevel@tonic-gate 	}
56287c478bd9Sstevel@tonic-gate 	if (resp->array != NULL) {
56297c478bd9Sstevel@tonic-gate 		kmem_free(resp->array, resp->array_len * sizeof (nfs_resop4));
56307c478bd9Sstevel@tonic-gate 	}
56317c478bd9Sstevel@tonic-gate }
56327c478bd9Sstevel@tonic-gate 
56337c478bd9Sstevel@tonic-gate /*
56347c478bd9Sstevel@tonic-gate  * Process the value of the compound request rpc flags, as a bit-AND
56357c478bd9Sstevel@tonic-gate  * of the individual per-op flags (idempotent, allowork, publicfh_ok)
56367c478bd9Sstevel@tonic-gate  */
56377c478bd9Sstevel@tonic-gate void
56387c478bd9Sstevel@tonic-gate rfs4_compound_flagproc(COMPOUND4args *args, int *flagp)
56397c478bd9Sstevel@tonic-gate {
56407c478bd9Sstevel@tonic-gate 	int i;
56417c478bd9Sstevel@tonic-gate 	int flag = RPC_ALL;
56427c478bd9Sstevel@tonic-gate 
56437c478bd9Sstevel@tonic-gate 	for (i = 0; flag && i < args->array_len; i++) {
56447c478bd9Sstevel@tonic-gate 		uint_t op;
56457c478bd9Sstevel@tonic-gate 
56467c478bd9Sstevel@tonic-gate 		op = (uint_t)args->array[i].argop;
56477c478bd9Sstevel@tonic-gate 
56487c478bd9Sstevel@tonic-gate 		if (op < rfsv4disp_cnt)
56497c478bd9Sstevel@tonic-gate 			flag &= rfsv4disptab[op].dis_flags;
56507c478bd9Sstevel@tonic-gate 		else
56517c478bd9Sstevel@tonic-gate 			flag = 0;
56527c478bd9Sstevel@tonic-gate 	}
56537c478bd9Sstevel@tonic-gate 	*flagp = flag;
56547c478bd9Sstevel@tonic-gate }
56557c478bd9Sstevel@tonic-gate 
56567c478bd9Sstevel@tonic-gate nfsstat4
56577c478bd9Sstevel@tonic-gate rfs4_client_sysid(rfs4_client_t *cp, sysid_t *sp)
56587c478bd9Sstevel@tonic-gate {
56597c478bd9Sstevel@tonic-gate 	nfsstat4 e;
56607c478bd9Sstevel@tonic-gate 
56617c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(cp->dbe);
56627c478bd9Sstevel@tonic-gate 
56637c478bd9Sstevel@tonic-gate 	if (cp->sysidt != LM_NOSYSID) {
56647c478bd9Sstevel@tonic-gate 		*sp = cp->sysidt;
56657c478bd9Sstevel@tonic-gate 		e = NFS4_OK;
56667c478bd9Sstevel@tonic-gate 
56677c478bd9Sstevel@tonic-gate 	} else if ((cp->sysidt = lm_alloc_sysidt()) != LM_NOSYSID) {
56687c478bd9Sstevel@tonic-gate 		*sp = cp->sysidt;
56697c478bd9Sstevel@tonic-gate 		e = NFS4_OK;
56707c478bd9Sstevel@tonic-gate 
56717c478bd9Sstevel@tonic-gate 		NFS4_DEBUG(rfs4_debug, (CE_NOTE,
56721b300de9Sjwahlig 		    "rfs4_client_sysid: allocated 0x%x\n", *sp));
56737c478bd9Sstevel@tonic-gate 	} else
56747c478bd9Sstevel@tonic-gate 		e = NFS4ERR_DELAY;
56757c478bd9Sstevel@tonic-gate 
56767c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(cp->dbe);
56777c478bd9Sstevel@tonic-gate 	return (e);
56787c478bd9Sstevel@tonic-gate }
56797c478bd9Sstevel@tonic-gate 
56807c478bd9Sstevel@tonic-gate #if defined(DEBUG) && ! defined(lint)
56817c478bd9Sstevel@tonic-gate static void lock_print(char *str, int operation, struct flock64 *flk)
56827c478bd9Sstevel@tonic-gate {
56837c478bd9Sstevel@tonic-gate 	char *op, *type;
56847c478bd9Sstevel@tonic-gate 
56857c478bd9Sstevel@tonic-gate 	switch (operation) {
56867c478bd9Sstevel@tonic-gate 	case F_GETLK: op = "F_GETLK";
56877c478bd9Sstevel@tonic-gate 		break;
56887c478bd9Sstevel@tonic-gate 	case F_SETLK: op = "F_SETLK";
56897c478bd9Sstevel@tonic-gate 		break;
5690da6c28aaSamw 	case F_SETLK_NBMAND: op = "F_SETLK_NBMAND";
5691da6c28aaSamw 		break;
56927c478bd9Sstevel@tonic-gate 	default: op = "F_UNKNOWN";
56937c478bd9Sstevel@tonic-gate 		break;
56947c478bd9Sstevel@tonic-gate 	}
56957c478bd9Sstevel@tonic-gate 	switch (flk->l_type) {
56967c478bd9Sstevel@tonic-gate 	case F_UNLCK: type = "F_UNLCK";
56977c478bd9Sstevel@tonic-gate 		break;
56987c478bd9Sstevel@tonic-gate 	case F_RDLCK: type = "F_RDLCK";
56997c478bd9Sstevel@tonic-gate 		break;
57007c478bd9Sstevel@tonic-gate 	case F_WRLCK: type = "F_WRLCK";
57017c478bd9Sstevel@tonic-gate 		break;
57027c478bd9Sstevel@tonic-gate 	default: type = "F_UNKNOWN";
57037c478bd9Sstevel@tonic-gate 		break;
57047c478bd9Sstevel@tonic-gate 	}
57057c478bd9Sstevel@tonic-gate 
57067c478bd9Sstevel@tonic-gate 	ASSERT(flk->l_whence == 0);
57077c478bd9Sstevel@tonic-gate 	cmn_err(CE_NOTE, "%s:  %s, type = %s, off = %llx len = %llx pid = %d",
57081b300de9Sjwahlig 	    str, op, type, (longlong_t)flk->l_start,
57091b300de9Sjwahlig 	    flk->l_len ? (longlong_t)flk->l_len : ~0LL, flk->l_pid);
57107c478bd9Sstevel@tonic-gate }
57117c478bd9Sstevel@tonic-gate 
57127c478bd9Sstevel@tonic-gate #define	LOCK_PRINT(d, s, t, f) if (d) lock_print(s, t, f)
57137c478bd9Sstevel@tonic-gate #else
57147c478bd9Sstevel@tonic-gate #define	LOCK_PRINT(d, s, t, f)
57157c478bd9Sstevel@tonic-gate #endif
57167c478bd9Sstevel@tonic-gate 
57177c478bd9Sstevel@tonic-gate /*ARGSUSED*/
57187c478bd9Sstevel@tonic-gate static bool_t
57197c478bd9Sstevel@tonic-gate creds_ok(cred_set_t cr_set, struct svc_req *req, struct compound_state *cs)
57207c478bd9Sstevel@tonic-gate {
57217c478bd9Sstevel@tonic-gate 	return (TRUE);
57227c478bd9Sstevel@tonic-gate }
57237c478bd9Sstevel@tonic-gate 
57247c478bd9Sstevel@tonic-gate /*
57257c478bd9Sstevel@tonic-gate  * Look up the pathname using the vp in cs as the directory vnode.
57267c478bd9Sstevel@tonic-gate  * cs->vp will be the vnode for the file on success
57277c478bd9Sstevel@tonic-gate  */
57287c478bd9Sstevel@tonic-gate 
57297c478bd9Sstevel@tonic-gate static nfsstat4
57307c478bd9Sstevel@tonic-gate rfs4_lookup(component4 *component, struct svc_req *req,
57317c478bd9Sstevel@tonic-gate 	    struct compound_state *cs)
57327c478bd9Sstevel@tonic-gate {
57337c478bd9Sstevel@tonic-gate 	char *nm;
57347c478bd9Sstevel@tonic-gate 	uint32_t len;
57357c478bd9Sstevel@tonic-gate 	nfsstat4 status;
57367c478bd9Sstevel@tonic-gate 
57377c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
57387c478bd9Sstevel@tonic-gate 		return (NFS4ERR_NOFILEHANDLE);
57397c478bd9Sstevel@tonic-gate 	}
57407c478bd9Sstevel@tonic-gate 	if (cs->vp->v_type != VDIR) {
57417c478bd9Sstevel@tonic-gate 		return (NFS4ERR_NOTDIR);
57427c478bd9Sstevel@tonic-gate 	}
57437c478bd9Sstevel@tonic-gate 
57447c478bd9Sstevel@tonic-gate 	if (!utf8_dir_verify(component))
57457c478bd9Sstevel@tonic-gate 		return (NFS4ERR_INVAL);
57467c478bd9Sstevel@tonic-gate 
57477c478bd9Sstevel@tonic-gate 	nm = utf8_to_fn(component, &len, NULL);
57487c478bd9Sstevel@tonic-gate 	if (nm == NULL) {
57497c478bd9Sstevel@tonic-gate 		return (NFS4ERR_INVAL);
57507c478bd9Sstevel@tonic-gate 	}
57517c478bd9Sstevel@tonic-gate 
57527c478bd9Sstevel@tonic-gate 	if (len > MAXNAMELEN) {
57537c478bd9Sstevel@tonic-gate 		kmem_free(nm, len);
57547c478bd9Sstevel@tonic-gate 		return (NFS4ERR_NAMETOOLONG);
57557c478bd9Sstevel@tonic-gate 	}
57567c478bd9Sstevel@tonic-gate 
57577c478bd9Sstevel@tonic-gate 	status = do_rfs4_op_lookup(nm, len, req, cs);
57587c478bd9Sstevel@tonic-gate 
57597c478bd9Sstevel@tonic-gate 	kmem_free(nm, len);
57607c478bd9Sstevel@tonic-gate 
57617c478bd9Sstevel@tonic-gate 	return (status);
57627c478bd9Sstevel@tonic-gate }
57637c478bd9Sstevel@tonic-gate 
57647c478bd9Sstevel@tonic-gate static nfsstat4
57657c478bd9Sstevel@tonic-gate rfs4_lookupfile(component4 *component, struct svc_req *req,
57667c478bd9Sstevel@tonic-gate 		struct compound_state *cs, uint32_t access,
57677c478bd9Sstevel@tonic-gate 		change_info4 *cinfo)
57687c478bd9Sstevel@tonic-gate {
57697c478bd9Sstevel@tonic-gate 	nfsstat4 status;
57707c478bd9Sstevel@tonic-gate 	vnode_t *dvp = cs->vp;
57717c478bd9Sstevel@tonic-gate 	vattr_t bva, ava, fva;
57727c478bd9Sstevel@tonic-gate 	int error;
57737c478bd9Sstevel@tonic-gate 
57747c478bd9Sstevel@tonic-gate 	/* Get "before" change value */
57757c478bd9Sstevel@tonic-gate 	bva.va_mask = AT_CTIME|AT_SEQ;
5776da6c28aaSamw 	error = VOP_GETATTR(dvp, &bva, 0, cs->cr, NULL);
57777c478bd9Sstevel@tonic-gate 	if (error)
57787c478bd9Sstevel@tonic-gate 		return (puterrno4(error));
57797c478bd9Sstevel@tonic-gate 
57807c478bd9Sstevel@tonic-gate 	/* rfs4_lookup may VN_RELE directory */
57817c478bd9Sstevel@tonic-gate 	VN_HOLD(dvp);
57827c478bd9Sstevel@tonic-gate 
57837c478bd9Sstevel@tonic-gate 	status = rfs4_lookup(component, req, cs);
57847c478bd9Sstevel@tonic-gate 	if (status != NFS4_OK) {
57857c478bd9Sstevel@tonic-gate 		VN_RELE(dvp);
57867c478bd9Sstevel@tonic-gate 		return (status);
57877c478bd9Sstevel@tonic-gate 	}
57887c478bd9Sstevel@tonic-gate 
57897c478bd9Sstevel@tonic-gate 	/*
57907c478bd9Sstevel@tonic-gate 	 * Get "after" change value, if it fails, simply return the
57917c478bd9Sstevel@tonic-gate 	 * before value.
57927c478bd9Sstevel@tonic-gate 	 */
57937c478bd9Sstevel@tonic-gate 	ava.va_mask = AT_CTIME|AT_SEQ;
5794da6c28aaSamw 	if (VOP_GETATTR(dvp, &ava, 0, cs->cr, NULL)) {
57957c478bd9Sstevel@tonic-gate 		ava.va_ctime = bva.va_ctime;
57967c478bd9Sstevel@tonic-gate 		ava.va_seq = 0;
57977c478bd9Sstevel@tonic-gate 	}
57987c478bd9Sstevel@tonic-gate 	VN_RELE(dvp);
57997c478bd9Sstevel@tonic-gate 
58007c478bd9Sstevel@tonic-gate 	/*
58017c478bd9Sstevel@tonic-gate 	 * Validate the file is a file
58027c478bd9Sstevel@tonic-gate 	 */
58037c478bd9Sstevel@tonic-gate 	fva.va_mask = AT_TYPE|AT_MODE;
5804da6c28aaSamw 	error = VOP_GETATTR(cs->vp, &fva, 0, cs->cr, NULL);
58057c478bd9Sstevel@tonic-gate 	if (error)
58067c478bd9Sstevel@tonic-gate 		return (puterrno4(error));
58077c478bd9Sstevel@tonic-gate 
58087c478bd9Sstevel@tonic-gate 	if (fva.va_type != VREG) {
58097c478bd9Sstevel@tonic-gate 		if (fva.va_type == VDIR)
58107c478bd9Sstevel@tonic-gate 			return (NFS4ERR_ISDIR);
58117c478bd9Sstevel@tonic-gate 		if (fva.va_type == VLNK)
58127c478bd9Sstevel@tonic-gate 			return (NFS4ERR_SYMLINK);
58137c478bd9Sstevel@tonic-gate 		return (NFS4ERR_INVAL);
58147c478bd9Sstevel@tonic-gate 	}
58157c478bd9Sstevel@tonic-gate 
58167c478bd9Sstevel@tonic-gate 	NFS4_SET_FATTR4_CHANGE(cinfo->before, bva.va_ctime);
58177c478bd9Sstevel@tonic-gate 	NFS4_SET_FATTR4_CHANGE(cinfo->after, ava.va_ctime);
58187c478bd9Sstevel@tonic-gate 
58197c478bd9Sstevel@tonic-gate 	/*
58207c478bd9Sstevel@tonic-gate 	 * It is undefined if VOP_LOOKUP will change va_seq, so
58217c478bd9Sstevel@tonic-gate 	 * cinfo.atomic = TRUE only if we have
58227c478bd9Sstevel@tonic-gate 	 * non-zero va_seq's, and they have not changed.
58237c478bd9Sstevel@tonic-gate 	 */
58247c478bd9Sstevel@tonic-gate 	if (bva.va_seq && ava.va_seq && ava.va_seq == bva.va_seq)
58257c478bd9Sstevel@tonic-gate 		cinfo->atomic = TRUE;
58267c478bd9Sstevel@tonic-gate 	else
58277c478bd9Sstevel@tonic-gate 		cinfo->atomic = FALSE;
58287c478bd9Sstevel@tonic-gate 
58297c478bd9Sstevel@tonic-gate 	/* Check for mandatory locking */
58307c478bd9Sstevel@tonic-gate 	cs->mandlock = MANDLOCK(cs->vp, fva.va_mode);
58317c478bd9Sstevel@tonic-gate 	return (check_open_access(access, cs, req));
58327c478bd9Sstevel@tonic-gate }
58337c478bd9Sstevel@tonic-gate 
58347c478bd9Sstevel@tonic-gate static nfsstat4
58357c478bd9Sstevel@tonic-gate create_vnode(vnode_t *dvp, char *nm,  vattr_t *vap, createmode4 mode,
58367c478bd9Sstevel@tonic-gate 	    timespec32_t *mtime, cred_t *cr, vnode_t **vpp, bool_t *created)
58377c478bd9Sstevel@tonic-gate {
58387c478bd9Sstevel@tonic-gate 	int error;
58397c478bd9Sstevel@tonic-gate 	nfsstat4 status = NFS4_OK;
58407c478bd9Sstevel@tonic-gate 	vattr_t va;
58417c478bd9Sstevel@tonic-gate 
58427c478bd9Sstevel@tonic-gate tryagain:
58437c478bd9Sstevel@tonic-gate 
58447c478bd9Sstevel@tonic-gate 	/*
58457c478bd9Sstevel@tonic-gate 	 * The file open mode used is VWRITE.  If the client needs
58467c478bd9Sstevel@tonic-gate 	 * some other semantic, then it should do the access checking
58477c478bd9Sstevel@tonic-gate 	 * itself.  It would have been nice to have the file open mode
58487c478bd9Sstevel@tonic-gate 	 * passed as part of the arguments.
58497c478bd9Sstevel@tonic-gate 	 */
58507c478bd9Sstevel@tonic-gate 
58517c478bd9Sstevel@tonic-gate 	*created = TRUE;
5852da6c28aaSamw 	error = VOP_CREATE(dvp, nm, vap, EXCL, VWRITE, vpp, cr, 0, NULL, NULL);
58537c478bd9Sstevel@tonic-gate 
58547c478bd9Sstevel@tonic-gate 	if (error) {
58557c478bd9Sstevel@tonic-gate 		*created = FALSE;
58567c478bd9Sstevel@tonic-gate 
58577c478bd9Sstevel@tonic-gate 		/*
58587c478bd9Sstevel@tonic-gate 		 * If we got something other than file already exists
58597c478bd9Sstevel@tonic-gate 		 * then just return this error.  Otherwise, we got
58607c478bd9Sstevel@tonic-gate 		 * EEXIST.  If we were doing a GUARDED create, then
58617c478bd9Sstevel@tonic-gate 		 * just return this error.  Otherwise, we need to
58627c478bd9Sstevel@tonic-gate 		 * make sure that this wasn't a duplicate of an
58637c478bd9Sstevel@tonic-gate 		 * exclusive create request.
58647c478bd9Sstevel@tonic-gate 		 *
58657c478bd9Sstevel@tonic-gate 		 * The assumption is made that a non-exclusive create
58667c478bd9Sstevel@tonic-gate 		 * request will never return EEXIST.
58677c478bd9Sstevel@tonic-gate 		 */
58687c478bd9Sstevel@tonic-gate 
58697c478bd9Sstevel@tonic-gate 		if (error != EEXIST || mode == GUARDED4) {
58707c478bd9Sstevel@tonic-gate 			status = puterrno4(error);
58717c478bd9Sstevel@tonic-gate 			return (status);
58727c478bd9Sstevel@tonic-gate 		}
5873da6c28aaSamw 		error = VOP_LOOKUP(dvp, nm, vpp, NULL, 0, NULL, cr,
5874da6c28aaSamw 		    NULL, NULL, NULL);
58757c478bd9Sstevel@tonic-gate 
58767c478bd9Sstevel@tonic-gate 		if (error) {
58777c478bd9Sstevel@tonic-gate 			/*
58787c478bd9Sstevel@tonic-gate 			 * We couldn't find the file that we thought that
58797c478bd9Sstevel@tonic-gate 			 * we just created.  So, we'll just try creating
58807c478bd9Sstevel@tonic-gate 			 * it again.
58817c478bd9Sstevel@tonic-gate 			 */
58827c478bd9Sstevel@tonic-gate 			if (error == ENOENT)
58837c478bd9Sstevel@tonic-gate 				goto tryagain;
58847c478bd9Sstevel@tonic-gate 
58857c478bd9Sstevel@tonic-gate 			status = puterrno4(error);
58867c478bd9Sstevel@tonic-gate 			return (status);
58877c478bd9Sstevel@tonic-gate 		}
58887c478bd9Sstevel@tonic-gate 
58897c478bd9Sstevel@tonic-gate 		if (mode == UNCHECKED4) {
58907c478bd9Sstevel@tonic-gate 			/* existing object must be regular file */
58917c478bd9Sstevel@tonic-gate 			if ((*vpp)->v_type != VREG) {
58927c478bd9Sstevel@tonic-gate 				if ((*vpp)->v_type == VDIR)
58937c478bd9Sstevel@tonic-gate 					status = NFS4ERR_ISDIR;
58947c478bd9Sstevel@tonic-gate 				else if ((*vpp)->v_type == VLNK)
58957c478bd9Sstevel@tonic-gate 					status = NFS4ERR_SYMLINK;
58967c478bd9Sstevel@tonic-gate 				else
58977c478bd9Sstevel@tonic-gate 					status = NFS4ERR_INVAL;
58987c478bd9Sstevel@tonic-gate 				VN_RELE(*vpp);
58997c478bd9Sstevel@tonic-gate 				return (status);
59007c478bd9Sstevel@tonic-gate 			}
59017c478bd9Sstevel@tonic-gate 
59027c478bd9Sstevel@tonic-gate 			return (NFS4_OK);
59037c478bd9Sstevel@tonic-gate 		}
59047c478bd9Sstevel@tonic-gate 
59057c478bd9Sstevel@tonic-gate 		/* Check for duplicate request */
59067c478bd9Sstevel@tonic-gate 		ASSERT(mtime != 0);
59077c478bd9Sstevel@tonic-gate 		va.va_mask = AT_MTIME;
5908da6c28aaSamw 		error = VOP_GETATTR(*vpp, &va, 0, cr, NULL);
59097c478bd9Sstevel@tonic-gate 		if (!error) {
59107c478bd9Sstevel@tonic-gate 			/* We found the file */
59117c478bd9Sstevel@tonic-gate 			if (va.va_mtime.tv_sec != mtime->tv_sec ||
59127c478bd9Sstevel@tonic-gate 			    va.va_mtime.tv_nsec != mtime->tv_nsec) {
59137c478bd9Sstevel@tonic-gate 				/* but its not our creation */
59147c478bd9Sstevel@tonic-gate 				VN_RELE(*vpp);
59157c478bd9Sstevel@tonic-gate 				return (NFS4ERR_EXIST);
59167c478bd9Sstevel@tonic-gate 			}
59177c478bd9Sstevel@tonic-gate 			*created = TRUE; /* retrans of create == created */
59187c478bd9Sstevel@tonic-gate 			return (NFS4_OK);
59197c478bd9Sstevel@tonic-gate 		}
59207c478bd9Sstevel@tonic-gate 		VN_RELE(*vpp);
59217c478bd9Sstevel@tonic-gate 		return (NFS4ERR_EXIST);
59227c478bd9Sstevel@tonic-gate 	}
59237c478bd9Sstevel@tonic-gate 
59247c478bd9Sstevel@tonic-gate 	return (NFS4_OK);
59257c478bd9Sstevel@tonic-gate }
59267c478bd9Sstevel@tonic-gate 
59277c478bd9Sstevel@tonic-gate static nfsstat4
59287c478bd9Sstevel@tonic-gate check_open_access(uint32_t access,
59297c478bd9Sstevel@tonic-gate 		struct compound_state *cs, struct svc_req *req)
59307c478bd9Sstevel@tonic-gate {
59317c478bd9Sstevel@tonic-gate 	int error;
59327c478bd9Sstevel@tonic-gate 	vnode_t *vp;
59337c478bd9Sstevel@tonic-gate 	bool_t readonly;
59347c478bd9Sstevel@tonic-gate 	cred_t *cr = cs->cr;
59357c478bd9Sstevel@tonic-gate 
59367c478bd9Sstevel@tonic-gate 	/* For now we don't allow mandatory locking as per V2/V3 */
59377c478bd9Sstevel@tonic-gate 	if (cs->access == CS_ACCESS_DENIED || cs->mandlock) {
59387c478bd9Sstevel@tonic-gate 		return (NFS4ERR_ACCESS);
59397c478bd9Sstevel@tonic-gate 	}
59407c478bd9Sstevel@tonic-gate 
59417c478bd9Sstevel@tonic-gate 	vp = cs->vp;
59427c478bd9Sstevel@tonic-gate 	ASSERT(cr != NULL && vp->v_type == VREG);
59437c478bd9Sstevel@tonic-gate 
59447c478bd9Sstevel@tonic-gate 	/*
59457c478bd9Sstevel@tonic-gate 	 * If the file system is exported read only and we are trying
59467c478bd9Sstevel@tonic-gate 	 * to open for write, then return NFS4ERR_ROFS
59477c478bd9Sstevel@tonic-gate 	 */
59487c478bd9Sstevel@tonic-gate 
59497c478bd9Sstevel@tonic-gate 	readonly = rdonly4(cs->exi, cs->vp, req);
59507c478bd9Sstevel@tonic-gate 
59517c478bd9Sstevel@tonic-gate 	if ((access & OPEN4_SHARE_ACCESS_WRITE) && readonly)
59527c478bd9Sstevel@tonic-gate 		return (NFS4ERR_ROFS);
59537c478bd9Sstevel@tonic-gate 
59547c478bd9Sstevel@tonic-gate 	if (access & OPEN4_SHARE_ACCESS_READ) {
5955da6c28aaSamw 		if ((VOP_ACCESS(vp, VREAD, 0, cr, NULL) != 0) &&
5956da6c28aaSamw 		    (VOP_ACCESS(vp, VEXEC, 0, cr, NULL) != 0)) {
59577c478bd9Sstevel@tonic-gate 			return (NFS4ERR_ACCESS);
59587c478bd9Sstevel@tonic-gate 		}
59597c478bd9Sstevel@tonic-gate 	}
59607c478bd9Sstevel@tonic-gate 
59617c478bd9Sstevel@tonic-gate 	if (access & OPEN4_SHARE_ACCESS_WRITE) {
5962da6c28aaSamw 		error = VOP_ACCESS(vp, VWRITE, 0, cr, NULL);
59637c478bd9Sstevel@tonic-gate 		if (error)
59647c478bd9Sstevel@tonic-gate 			return (NFS4ERR_ACCESS);
59657c478bd9Sstevel@tonic-gate 	}
59667c478bd9Sstevel@tonic-gate 
59677c478bd9Sstevel@tonic-gate 	return (NFS4_OK);
59687c478bd9Sstevel@tonic-gate }
59697c478bd9Sstevel@tonic-gate 
59707c478bd9Sstevel@tonic-gate static nfsstat4
59717c478bd9Sstevel@tonic-gate rfs4_createfile(OPEN4args *args, struct svc_req *req, struct compound_state *cs,
59727c478bd9Sstevel@tonic-gate 		change_info4 *cinfo, bitmap4 *attrset, clientid4 clientid)
59737c478bd9Sstevel@tonic-gate {
59747c478bd9Sstevel@tonic-gate 	struct nfs4_svgetit_arg sarg;
59757c478bd9Sstevel@tonic-gate 	struct nfs4_ntov_table ntov;
59767c478bd9Sstevel@tonic-gate 
59777c478bd9Sstevel@tonic-gate 	bool_t ntov_table_init = FALSE;
59787c478bd9Sstevel@tonic-gate 	struct statvfs64 sb;
59797c478bd9Sstevel@tonic-gate 	nfsstat4 status;
59807c478bd9Sstevel@tonic-gate 	vnode_t *vp;
59817c478bd9Sstevel@tonic-gate 	vattr_t bva, ava, iva, cva, *vap;
59827c478bd9Sstevel@tonic-gate 	vnode_t *dvp;
59837c478bd9Sstevel@tonic-gate 	timespec32_t *mtime;
59847c478bd9Sstevel@tonic-gate 	char *nm = NULL;
59857c478bd9Sstevel@tonic-gate 	uint_t buflen;
59867c478bd9Sstevel@tonic-gate 	bool_t created;
59877c478bd9Sstevel@tonic-gate 	bool_t setsize = FALSE;
59887c478bd9Sstevel@tonic-gate 	len_t reqsize;
59897c478bd9Sstevel@tonic-gate 	int error;
59907c478bd9Sstevel@tonic-gate 	bool_t trunc;
59917c478bd9Sstevel@tonic-gate 	caller_context_t ct;
59927c478bd9Sstevel@tonic-gate 	component4 *component;
599345916cd2Sjpk 	bslabel_t *clabel;
59947c478bd9Sstevel@tonic-gate 
59957c478bd9Sstevel@tonic-gate 	sarg.sbp = &sb;
59967c478bd9Sstevel@tonic-gate 
59977c478bd9Sstevel@tonic-gate 	dvp = cs->vp;
59987c478bd9Sstevel@tonic-gate 
59997c478bd9Sstevel@tonic-gate 	/* Check if the file system is read only */
60007c478bd9Sstevel@tonic-gate 	if (rdonly4(cs->exi, dvp, req))
60017c478bd9Sstevel@tonic-gate 		return (NFS4ERR_ROFS);
60027c478bd9Sstevel@tonic-gate 
600345916cd2Sjpk 	/* check the label of including directory */
600445916cd2Sjpk 	if (is_system_labeled()) {
600545916cd2Sjpk 		ASSERT(req->rq_label != NULL);
600645916cd2Sjpk 		clabel = req->rq_label;
600745916cd2Sjpk 		DTRACE_PROBE2(tx__rfs4__log__info__opremove__clabel, char *,
600845916cd2Sjpk 		    "got client label from request(1)",
600945916cd2Sjpk 		    struct svc_req *, req);
601045916cd2Sjpk 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
601103986916Sjarrett 			if (!do_rfs_label_check(clabel, dvp, EQUALITY_CHECK)) {
601245916cd2Sjpk 				return (NFS4ERR_ACCESS);
601345916cd2Sjpk 			}
601445916cd2Sjpk 		}
601545916cd2Sjpk 	}
601645916cd2Sjpk 
60177c478bd9Sstevel@tonic-gate 	/*
60187c478bd9Sstevel@tonic-gate 	 * Get the last component of path name in nm. cs will reference
60197c478bd9Sstevel@tonic-gate 	 * the including directory on success.
60207c478bd9Sstevel@tonic-gate 	 */
60217c478bd9Sstevel@tonic-gate 	component = &args->open_claim4_u.file;
60227c478bd9Sstevel@tonic-gate 	if (!utf8_dir_verify(component))
60237c478bd9Sstevel@tonic-gate 		return (NFS4ERR_INVAL);
60247c478bd9Sstevel@tonic-gate 
60257c478bd9Sstevel@tonic-gate 	nm = utf8_to_fn(component, &buflen, NULL);
60267c478bd9Sstevel@tonic-gate 
60277c478bd9Sstevel@tonic-gate 	if (nm == NULL)
60287c478bd9Sstevel@tonic-gate 		return (NFS4ERR_RESOURCE);
60297c478bd9Sstevel@tonic-gate 
60307c478bd9Sstevel@tonic-gate 	if (buflen > MAXNAMELEN) {
60317c478bd9Sstevel@tonic-gate 		kmem_free(nm, buflen);
60327c478bd9Sstevel@tonic-gate 		return (NFS4ERR_NAMETOOLONG);
60337c478bd9Sstevel@tonic-gate 	}
60347c478bd9Sstevel@tonic-gate 
60357c478bd9Sstevel@tonic-gate 	bva.va_mask = AT_TYPE|AT_CTIME|AT_SEQ;
6036da6c28aaSamw 	error = VOP_GETATTR(dvp, &bva, 0, cs->cr, NULL);
60377c478bd9Sstevel@tonic-gate 	if (error) {
60387c478bd9Sstevel@tonic-gate 		kmem_free(nm, buflen);
60397c478bd9Sstevel@tonic-gate 		return (puterrno4(error));
60407c478bd9Sstevel@tonic-gate 	}
60417c478bd9Sstevel@tonic-gate 
60427c478bd9Sstevel@tonic-gate 	if (bva.va_type != VDIR) {
60437c478bd9Sstevel@tonic-gate 		kmem_free(nm, buflen);
60447c478bd9Sstevel@tonic-gate 		return (NFS4ERR_NOTDIR);
60457c478bd9Sstevel@tonic-gate 	}
60467c478bd9Sstevel@tonic-gate 
60477c478bd9Sstevel@tonic-gate 	NFS4_SET_FATTR4_CHANGE(cinfo->before, bva.va_ctime)
60487c478bd9Sstevel@tonic-gate 
60497c478bd9Sstevel@tonic-gate 	switch (args->mode) {
60507c478bd9Sstevel@tonic-gate 	case GUARDED4:
60517c478bd9Sstevel@tonic-gate 		/*FALLTHROUGH*/
60527c478bd9Sstevel@tonic-gate 	case UNCHECKED4:
60537c478bd9Sstevel@tonic-gate 		nfs4_ntov_table_init(&ntov);
60547c478bd9Sstevel@tonic-gate 		ntov_table_init = TRUE;
60557c478bd9Sstevel@tonic-gate 
60567c478bd9Sstevel@tonic-gate 		*attrset = 0;
60577c478bd9Sstevel@tonic-gate 		status = do_rfs4_set_attrs(attrset,
60581b300de9Sjwahlig 		    &args->createhow4_u.createattrs,
60591b300de9Sjwahlig 		    cs, &sarg, &ntov, NFS4ATTR_SETIT);
60607c478bd9Sstevel@tonic-gate 
60617c478bd9Sstevel@tonic-gate 		if (status == NFS4_OK && (sarg.vap->va_mask & AT_TYPE) &&
60627c478bd9Sstevel@tonic-gate 		    sarg.vap->va_type != VREG) {
60637c478bd9Sstevel@tonic-gate 			if (sarg.vap->va_type == VDIR)
60647c478bd9Sstevel@tonic-gate 				status = NFS4ERR_ISDIR;
60657c478bd9Sstevel@tonic-gate 			else if (sarg.vap->va_type == VLNK)
60667c478bd9Sstevel@tonic-gate 				status = NFS4ERR_SYMLINK;
60677c478bd9Sstevel@tonic-gate 			else
60687c478bd9Sstevel@tonic-gate 				status = NFS4ERR_INVAL;
60697c478bd9Sstevel@tonic-gate 		}
60707c478bd9Sstevel@tonic-gate 
60717c478bd9Sstevel@tonic-gate 		if (status != NFS4_OK) {
60727c478bd9Sstevel@tonic-gate 			kmem_free(nm, buflen);
60737c478bd9Sstevel@tonic-gate 			nfs4_ntov_table_free(&ntov, &sarg);
60747c478bd9Sstevel@tonic-gate 			*attrset = 0;
60757c478bd9Sstevel@tonic-gate 			return (status);
60767c478bd9Sstevel@tonic-gate 		}
60777c478bd9Sstevel@tonic-gate 
60787c478bd9Sstevel@tonic-gate 		vap = sarg.vap;
60797c478bd9Sstevel@tonic-gate 		vap->va_type = VREG;
60807c478bd9Sstevel@tonic-gate 		vap->va_mask |= AT_TYPE;
60817c478bd9Sstevel@tonic-gate 
60827c478bd9Sstevel@tonic-gate 		if ((vap->va_mask & AT_MODE) == 0) {
60837c478bd9Sstevel@tonic-gate 			vap->va_mask |= AT_MODE;
60847c478bd9Sstevel@tonic-gate 			vap->va_mode = (mode_t)0600;
60857c478bd9Sstevel@tonic-gate 		}
60867c478bd9Sstevel@tonic-gate 
60877c478bd9Sstevel@tonic-gate 		if (vap->va_mask & AT_SIZE) {
60887c478bd9Sstevel@tonic-gate 
60897c478bd9Sstevel@tonic-gate 			/* Disallow create with a non-zero size */
60907c478bd9Sstevel@tonic-gate 
60917c478bd9Sstevel@tonic-gate 			if ((reqsize = sarg.vap->va_size) != 0) {
60927c478bd9Sstevel@tonic-gate 				kmem_free(nm, buflen);
60937c478bd9Sstevel@tonic-gate 				nfs4_ntov_table_free(&ntov, &sarg);
60947c478bd9Sstevel@tonic-gate 				*attrset = 0;
60957c478bd9Sstevel@tonic-gate 				return (NFS4ERR_INVAL);
60967c478bd9Sstevel@tonic-gate 			}
60977c478bd9Sstevel@tonic-gate 			setsize = TRUE;
60987c478bd9Sstevel@tonic-gate 		}
60997c478bd9Sstevel@tonic-gate 		break;
61007c478bd9Sstevel@tonic-gate 
61017c478bd9Sstevel@tonic-gate 	case EXCLUSIVE4:
61027c478bd9Sstevel@tonic-gate 		/* prohibit EXCL create of named attributes */
61037c478bd9Sstevel@tonic-gate 		if (dvp->v_flag & V_XATTRDIR) {
61047c478bd9Sstevel@tonic-gate 			kmem_free(nm, buflen);
61057c478bd9Sstevel@tonic-gate 			*attrset = 0;
61067c478bd9Sstevel@tonic-gate 			return (NFS4ERR_INVAL);
61077c478bd9Sstevel@tonic-gate 		}
61087c478bd9Sstevel@tonic-gate 
61097c478bd9Sstevel@tonic-gate 		cva.va_mask = AT_TYPE | AT_MTIME | AT_MODE;
61107c478bd9Sstevel@tonic-gate 		cva.va_type = VREG;
61117c478bd9Sstevel@tonic-gate 		/*
61127c478bd9Sstevel@tonic-gate 		 * Ensure no time overflows. Assumes underlying
61137c478bd9Sstevel@tonic-gate 		 * filesystem supports at least 32 bits.
61147c478bd9Sstevel@tonic-gate 		 * Truncate nsec to usec resolution to allow valid
61157c478bd9Sstevel@tonic-gate 		 * compares even if the underlying filesystem truncates.
61167c478bd9Sstevel@tonic-gate 		 */
61177c478bd9Sstevel@tonic-gate 		mtime = (timespec32_t *)&args->createhow4_u.createverf;
61187c478bd9Sstevel@tonic-gate 		cva.va_mtime.tv_sec = mtime->tv_sec % TIME32_MAX;
61197c478bd9Sstevel@tonic-gate 		cva.va_mtime.tv_nsec = (mtime->tv_nsec / 1000) * 1000;
61207c478bd9Sstevel@tonic-gate 		cva.va_mode = (mode_t)0;
61217c478bd9Sstevel@tonic-gate 		vap = &cva;
61227c478bd9Sstevel@tonic-gate 		break;
61237c478bd9Sstevel@tonic-gate 	}
61247c478bd9Sstevel@tonic-gate 
61257c478bd9Sstevel@tonic-gate 	status = create_vnode(dvp, nm, vap, args->mode, mtime,
61261b300de9Sjwahlig 	    cs->cr, &vp, &created);
61277c478bd9Sstevel@tonic-gate 	kmem_free(nm, buflen);
61287c478bd9Sstevel@tonic-gate 
61297c478bd9Sstevel@tonic-gate 	if (status != NFS4_OK) {
61307c478bd9Sstevel@tonic-gate 		if (ntov_table_init)
61317c478bd9Sstevel@tonic-gate 			nfs4_ntov_table_free(&ntov, &sarg);
61327c478bd9Sstevel@tonic-gate 		*attrset = 0;
61337c478bd9Sstevel@tonic-gate 		return (status);
61347c478bd9Sstevel@tonic-gate 	}
61357c478bd9Sstevel@tonic-gate 
61367c478bd9Sstevel@tonic-gate 	trunc = (setsize && !created);
61377c478bd9Sstevel@tonic-gate 
61387c478bd9Sstevel@tonic-gate 	if (args->mode != EXCLUSIVE4) {
61397c478bd9Sstevel@tonic-gate 		bitmap4 createmask = args->createhow4_u.createattrs.attrmask;
61407c478bd9Sstevel@tonic-gate 
61417c478bd9Sstevel@tonic-gate 		/*
61427c478bd9Sstevel@tonic-gate 		 * True verification that object was created with correct
61437c478bd9Sstevel@tonic-gate 		 * attrs is impossible.  The attrs could have been changed
61447c478bd9Sstevel@tonic-gate 		 * immediately after object creation.  If attributes did
61457c478bd9Sstevel@tonic-gate 		 * not verify, the only recourse for the server is to
61467c478bd9Sstevel@tonic-gate 		 * destroy the object.  Maybe if some attrs (like gid)
61477c478bd9Sstevel@tonic-gate 		 * are set incorrectly, the object should be destroyed;
61487c478bd9Sstevel@tonic-gate 		 * however, seems bad as a default policy.  Do we really
61497c478bd9Sstevel@tonic-gate 		 * want to destroy an object over one of the times not
61507c478bd9Sstevel@tonic-gate 		 * verifying correctly?  For these reasons, the server
61517c478bd9Sstevel@tonic-gate 		 * currently sets bits in attrset for createattrs
61527c478bd9Sstevel@tonic-gate 		 * that were set; however, no verification is done.
61537c478bd9Sstevel@tonic-gate 		 *
61547c478bd9Sstevel@tonic-gate 		 * vmask_to_nmask accounts for vattr bits set on create
61557c478bd9Sstevel@tonic-gate 		 *	[do_rfs4_set_attrs() only sets resp bits for
61567c478bd9Sstevel@tonic-gate 		 *	 non-vattr/vfs bits.]
61577c478bd9Sstevel@tonic-gate 		 * Mask off any bits we set by default so as not to return
61587c478bd9Sstevel@tonic-gate 		 * more attrset bits than were requested in createattrs
61597c478bd9Sstevel@tonic-gate 		 */
61607c478bd9Sstevel@tonic-gate 		if (created) {
61617c478bd9Sstevel@tonic-gate 			nfs4_vmask_to_nmask(sarg.vap->va_mask, attrset);
61627c478bd9Sstevel@tonic-gate 			*attrset &= createmask;
61637c478bd9Sstevel@tonic-gate 		} else {
61647c478bd9Sstevel@tonic-gate 			/*
61657c478bd9Sstevel@tonic-gate 			 * We did not create the vnode (we tried but it
61667c478bd9Sstevel@tonic-gate 			 * already existed).  In this case, the only createattr
61677c478bd9Sstevel@tonic-gate 			 * that the spec allows the server to set is size,
61687c478bd9Sstevel@tonic-gate 			 * and even then, it can only be set if it is 0.
61697c478bd9Sstevel@tonic-gate 			 */
61707c478bd9Sstevel@tonic-gate 			*attrset = 0;
61717c478bd9Sstevel@tonic-gate 			if (trunc)
61727c478bd9Sstevel@tonic-gate 				*attrset = FATTR4_SIZE_MASK;
61737c478bd9Sstevel@tonic-gate 		}
61747c478bd9Sstevel@tonic-gate 	}
61757c478bd9Sstevel@tonic-gate 	if (ntov_table_init)
61767c478bd9Sstevel@tonic-gate 		nfs4_ntov_table_free(&ntov, &sarg);
61777c478bd9Sstevel@tonic-gate 
61787c478bd9Sstevel@tonic-gate 	/*
61797c478bd9Sstevel@tonic-gate 	 * Get the initial "after" sequence number, if it fails,
61807c478bd9Sstevel@tonic-gate 	 * set to zero, time to before.
61817c478bd9Sstevel@tonic-gate 	 */
61827c478bd9Sstevel@tonic-gate 	iva.va_mask = AT_CTIME|AT_SEQ;
6183da6c28aaSamw 	if (VOP_GETATTR(dvp, &iva, 0, cs->cr, NULL)) {
61847c478bd9Sstevel@tonic-gate 		iva.va_seq = 0;
61857c478bd9Sstevel@tonic-gate 		iva.va_ctime = bva.va_ctime;
61867c478bd9Sstevel@tonic-gate 	}
61877c478bd9Sstevel@tonic-gate 
61887c478bd9Sstevel@tonic-gate 	/*
61897c478bd9Sstevel@tonic-gate 	 * create_vnode attempts to create the file exclusive,
61907c478bd9Sstevel@tonic-gate 	 * if it already exists the VOP_CREATE will fail and
61917c478bd9Sstevel@tonic-gate 	 * may not increase va_seq. It is atomic if
61927c478bd9Sstevel@tonic-gate 	 * we haven't changed the directory, but if it has changed
61937c478bd9Sstevel@tonic-gate 	 * we don't know what changed it.
61947c478bd9Sstevel@tonic-gate 	 */
61957c478bd9Sstevel@tonic-gate 	if (!created) {
61967c478bd9Sstevel@tonic-gate 		if (bva.va_seq && iva.va_seq &&
61971b300de9Sjwahlig 		    bva.va_seq == iva.va_seq)
61987c478bd9Sstevel@tonic-gate 			cinfo->atomic = TRUE;
61997c478bd9Sstevel@tonic-gate 		else
62007c478bd9Sstevel@tonic-gate 			cinfo->atomic = FALSE;
62017c478bd9Sstevel@tonic-gate 		NFS4_SET_FATTR4_CHANGE(cinfo->after, iva.va_ctime);
62027c478bd9Sstevel@tonic-gate 	} else {
62037c478bd9Sstevel@tonic-gate 		/*
62047c478bd9Sstevel@tonic-gate 		 * The entry was created, we need to sync the
62057c478bd9Sstevel@tonic-gate 		 * directory metadata.
62067c478bd9Sstevel@tonic-gate 		 */
6207da6c28aaSamw 		(void) VOP_FSYNC(dvp, 0, cs->cr, NULL);
62087c478bd9Sstevel@tonic-gate 
62097c478bd9Sstevel@tonic-gate 		/*
62107c478bd9Sstevel@tonic-gate 		 * Get "after" change value, if it fails, simply return the
62117c478bd9Sstevel@tonic-gate 		 * before value.
62127c478bd9Sstevel@tonic-gate 		 */
62137c478bd9Sstevel@tonic-gate 		ava.va_mask = AT_CTIME|AT_SEQ;
6214da6c28aaSamw 		if (VOP_GETATTR(dvp, &ava, 0, cs->cr, NULL)) {
62157c478bd9Sstevel@tonic-gate 			ava.va_ctime = bva.va_ctime;
62167c478bd9Sstevel@tonic-gate 			ava.va_seq = 0;
62177c478bd9Sstevel@tonic-gate 		}
62187c478bd9Sstevel@tonic-gate 
62197c478bd9Sstevel@tonic-gate 		NFS4_SET_FATTR4_CHANGE(cinfo->after, ava.va_ctime);
62207c478bd9Sstevel@tonic-gate 
62217c478bd9Sstevel@tonic-gate 		/*
62227c478bd9Sstevel@tonic-gate 		 * The cinfo->atomic = TRUE only if we have
62237c478bd9Sstevel@tonic-gate 		 * non-zero va_seq's, and it has incremented by exactly one
62247c478bd9Sstevel@tonic-gate 		 * during the create_vnode and it didn't
62257c478bd9Sstevel@tonic-gate 		 * change during the VOP_FSYNC.
62267c478bd9Sstevel@tonic-gate 		 */
62277c478bd9Sstevel@tonic-gate 		if (bva.va_seq && iva.va_seq && ava.va_seq &&
62281b300de9Sjwahlig 		    iva.va_seq == (bva.va_seq + 1) && iva.va_seq == ava.va_seq)
62297c478bd9Sstevel@tonic-gate 			cinfo->atomic = TRUE;
62307c478bd9Sstevel@tonic-gate 		else
62317c478bd9Sstevel@tonic-gate 			cinfo->atomic = FALSE;
62327c478bd9Sstevel@tonic-gate 	}
62337c478bd9Sstevel@tonic-gate 
62347c478bd9Sstevel@tonic-gate 	/* Check for mandatory locking and that the size gets set. */
62357c478bd9Sstevel@tonic-gate 	cva.va_mask = AT_MODE;
62367c478bd9Sstevel@tonic-gate 	if (setsize)
62377c478bd9Sstevel@tonic-gate 		cva.va_mask |= AT_SIZE;
62387c478bd9Sstevel@tonic-gate 
62397c478bd9Sstevel@tonic-gate 	/* Assume the worst */
62407c478bd9Sstevel@tonic-gate 	cs->mandlock = TRUE;
62417c478bd9Sstevel@tonic-gate 
6242da6c28aaSamw 	if (VOP_GETATTR(vp, &cva, 0, cs->cr, NULL) == 0) {
62437c478bd9Sstevel@tonic-gate 		cs->mandlock = MANDLOCK(cs->vp, cva.va_mode);
62447c478bd9Sstevel@tonic-gate 
62457c478bd9Sstevel@tonic-gate 		/*
62467c478bd9Sstevel@tonic-gate 		 * Truncate the file if necessary; this would be
62477c478bd9Sstevel@tonic-gate 		 * the case for create over an existing file.
62487c478bd9Sstevel@tonic-gate 		 */
62497c478bd9Sstevel@tonic-gate 
62507c478bd9Sstevel@tonic-gate 		if (trunc) {
62517c478bd9Sstevel@tonic-gate 			int in_crit = 0;
62527c478bd9Sstevel@tonic-gate 			rfs4_file_t *fp;
62537c478bd9Sstevel@tonic-gate 			bool_t create = FALSE;
62547c478bd9Sstevel@tonic-gate 
62557c478bd9Sstevel@tonic-gate 			/*
62567c478bd9Sstevel@tonic-gate 			 * We are writing over an existing file.
62577c478bd9Sstevel@tonic-gate 			 * Check to see if we need to recall a delegation.
62587c478bd9Sstevel@tonic-gate 			 */
62597c478bd9Sstevel@tonic-gate 			rfs4_hold_deleg_policy();
62607c478bd9Sstevel@tonic-gate 			if ((fp = rfs4_findfile(vp, NULL, &create)) != NULL) {
62617c478bd9Sstevel@tonic-gate 				if (rfs4_check_delegated_byfp(FWRITE, fp,
62621b300de9Sjwahlig 				    (reqsize == 0), FALSE, FALSE, &clientid)) {
62637c478bd9Sstevel@tonic-gate 					rfs4_file_rele(fp);
62647c478bd9Sstevel@tonic-gate 					rfs4_rele_deleg_policy();
62657c478bd9Sstevel@tonic-gate 					VN_RELE(vp);
62667c478bd9Sstevel@tonic-gate 					*attrset = 0;
62677c478bd9Sstevel@tonic-gate 					return (NFS4ERR_DELAY);
62687c478bd9Sstevel@tonic-gate 				}
62697c478bd9Sstevel@tonic-gate 				rfs4_file_rele(fp);
62707c478bd9Sstevel@tonic-gate 			}
62717c478bd9Sstevel@tonic-gate 			rfs4_rele_deleg_policy();
62727c478bd9Sstevel@tonic-gate 
62737c478bd9Sstevel@tonic-gate 			if (nbl_need_check(vp)) {
62747c478bd9Sstevel@tonic-gate 				in_crit = 1;
62757c478bd9Sstevel@tonic-gate 
62767c478bd9Sstevel@tonic-gate 				ASSERT(reqsize == 0);
62777c478bd9Sstevel@tonic-gate 
62787c478bd9Sstevel@tonic-gate 				nbl_start_crit(vp, RW_READER);
62797c478bd9Sstevel@tonic-gate 				if (nbl_conflict(vp, NBL_WRITE, 0,
6280da6c28aaSamw 				    cva.va_size, 0, NULL)) {
62817c478bd9Sstevel@tonic-gate 					in_crit = 0;
62827c478bd9Sstevel@tonic-gate 					nbl_end_crit(vp);
62837c478bd9Sstevel@tonic-gate 					VN_RELE(vp);
62847c478bd9Sstevel@tonic-gate 					*attrset = 0;
62857c478bd9Sstevel@tonic-gate 					return (NFS4ERR_ACCESS);
62867c478bd9Sstevel@tonic-gate 				}
62877c478bd9Sstevel@tonic-gate 			}
62887c478bd9Sstevel@tonic-gate 			ct.cc_sysid = 0;
62897c478bd9Sstevel@tonic-gate 			ct.cc_pid = 0;
62907c478bd9Sstevel@tonic-gate 			ct.cc_caller_id = nfs4_srv_caller_id;
62917c478bd9Sstevel@tonic-gate 
62927c478bd9Sstevel@tonic-gate 			cva.va_mask = AT_SIZE;
62937c478bd9Sstevel@tonic-gate 			cva.va_size = reqsize;
62947c478bd9Sstevel@tonic-gate 			(void) VOP_SETATTR(vp, &cva, 0, cs->cr, &ct);
62957c478bd9Sstevel@tonic-gate 			if (in_crit)
62967c478bd9Sstevel@tonic-gate 				nbl_end_crit(vp);
62977c478bd9Sstevel@tonic-gate 		}
62987c478bd9Sstevel@tonic-gate 	}
62997c478bd9Sstevel@tonic-gate 
63007c478bd9Sstevel@tonic-gate 	error = makefh4(&cs->fh, vp, cs->exi);
63017c478bd9Sstevel@tonic-gate 
63027c478bd9Sstevel@tonic-gate 	/*
63037c478bd9Sstevel@tonic-gate 	 * Force modified data and metadata out to stable storage.
63047c478bd9Sstevel@tonic-gate 	 */
6305da6c28aaSamw 	(void) VOP_FSYNC(vp, FNODSYNC, cs->cr, NULL);
63067c478bd9Sstevel@tonic-gate 
63077c478bd9Sstevel@tonic-gate 	if (error) {
63087c478bd9Sstevel@tonic-gate 		VN_RELE(vp);
63097c478bd9Sstevel@tonic-gate 		*attrset = 0;
63107c478bd9Sstevel@tonic-gate 		return (puterrno4(error));
63117c478bd9Sstevel@tonic-gate 	}
63127c478bd9Sstevel@tonic-gate 
63137c478bd9Sstevel@tonic-gate 	/* if parent dir is attrdir, set namedattr fh flag */
63147c478bd9Sstevel@tonic-gate 	if (dvp->v_flag & V_XATTRDIR)
63157c478bd9Sstevel@tonic-gate 		set_fh4_flag(&cs->fh, FH4_NAMEDATTR);
63167c478bd9Sstevel@tonic-gate 
63177c478bd9Sstevel@tonic-gate 	if (cs->vp)
63187c478bd9Sstevel@tonic-gate 		VN_RELE(cs->vp);
63197c478bd9Sstevel@tonic-gate 
63207c478bd9Sstevel@tonic-gate 	cs->vp = vp;
63217c478bd9Sstevel@tonic-gate 
63227c478bd9Sstevel@tonic-gate 	/*
63237c478bd9Sstevel@tonic-gate 	 * if we did not create the file, we will need to check
63247c478bd9Sstevel@tonic-gate 	 * the access bits on the file
63257c478bd9Sstevel@tonic-gate 	 */
63267c478bd9Sstevel@tonic-gate 
63277c478bd9Sstevel@tonic-gate 	if (!created) {
63287c478bd9Sstevel@tonic-gate 		if (setsize)
63297c478bd9Sstevel@tonic-gate 			args->share_access |= OPEN4_SHARE_ACCESS_WRITE;
63307c478bd9Sstevel@tonic-gate 		status = check_open_access(args->share_access, cs, req);
63317c478bd9Sstevel@tonic-gate 		if (status != NFS4_OK)
63327c478bd9Sstevel@tonic-gate 			*attrset = 0;
63337c478bd9Sstevel@tonic-gate 	}
63347c478bd9Sstevel@tonic-gate 	return (status);
63357c478bd9Sstevel@tonic-gate }
63367c478bd9Sstevel@tonic-gate 
63377c478bd9Sstevel@tonic-gate /*ARGSUSED*/
63387c478bd9Sstevel@tonic-gate static void
63397c478bd9Sstevel@tonic-gate rfs4_do_open(struct compound_state *cs, struct svc_req *req,
63407c478bd9Sstevel@tonic-gate 		rfs4_openowner_t *oo, delegreq_t deleg,
63417c478bd9Sstevel@tonic-gate 		uint32_t access, uint32_t deny,
6342da6c28aaSamw 		OPEN4res *resp, int deleg_cur)
63437c478bd9Sstevel@tonic-gate {
63447c478bd9Sstevel@tonic-gate 	/* XXX Currently not using req  */
63457c478bd9Sstevel@tonic-gate 	rfs4_state_t *state;
63467c478bd9Sstevel@tonic-gate 	rfs4_file_t *file;
63477c478bd9Sstevel@tonic-gate 	bool_t screate = TRUE;
63487c478bd9Sstevel@tonic-gate 	bool_t fcreate = TRUE;
63497c478bd9Sstevel@tonic-gate 	uint32_t amodes;
63507c478bd9Sstevel@tonic-gate 	uint32_t dmodes;
63517c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_t *dsp;
63527c478bd9Sstevel@tonic-gate 	struct shrlock shr;
63537c478bd9Sstevel@tonic-gate 	struct shr_locowner shr_loco;
63547c478bd9Sstevel@tonic-gate 	sysid_t sysid;
63557c478bd9Sstevel@tonic-gate 	nfsstat4 status;
6356da6c28aaSamw 	caller_context_t ct;
63577c478bd9Sstevel@tonic-gate 	int fflags = 0;
63587c478bd9Sstevel@tonic-gate 	int recall = 0;
63597c478bd9Sstevel@tonic-gate 	int err;
6360da6c28aaSamw 	int cmd;
63617c478bd9Sstevel@tonic-gate 
63627c478bd9Sstevel@tonic-gate 	/* get the file struct and hold a lock on it during initial open */
63637c478bd9Sstevel@tonic-gate 	file = rfs4_findfile_withlock(cs->vp, &cs->fh, &fcreate);
63647c478bd9Sstevel@tonic-gate 	if (file == NULL) {
63657c478bd9Sstevel@tonic-gate 		NFS4_DEBUG(rfs4_debug,
63661b300de9Sjwahlig 		    (CE_NOTE, "rfs4_do_open: can't find file"));
63677c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_SERVERFAULT;
63687c478bd9Sstevel@tonic-gate 		return;
63697c478bd9Sstevel@tonic-gate 	}
63707c478bd9Sstevel@tonic-gate 
63717c478bd9Sstevel@tonic-gate 	state = rfs4_findstate_by_owner_file(oo, file, &screate);
63727c478bd9Sstevel@tonic-gate 	if (state == NULL) {
63737c478bd9Sstevel@tonic-gate 		NFS4_DEBUG(rfs4_debug,
63741b300de9Sjwahlig 		    (CE_NOTE, "rfs4_do_open: can't find state"));
63757c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_RESOURCE;
63767c478bd9Sstevel@tonic-gate 		/* No need to keep any reference */
63777c478bd9Sstevel@tonic-gate 		rfs4_file_rele_withunlock(file);
63787c478bd9Sstevel@tonic-gate 		return;
63797c478bd9Sstevel@tonic-gate 	}
63807c478bd9Sstevel@tonic-gate 
6381fd93bfc3Sjwahlig 	/* try to get the sysid before continuing */
63827c478bd9Sstevel@tonic-gate 	if ((status = rfs4_client_sysid(oo->client, &sysid)) != NFS4_OK) {
63837c478bd9Sstevel@tonic-gate 		resp->status = status;
63847c478bd9Sstevel@tonic-gate 		rfs4_file_rele(file);
63857c478bd9Sstevel@tonic-gate 		/* Not a fully formed open; "close" it */
63867c478bd9Sstevel@tonic-gate 		if (screate == TRUE)
63877c478bd9Sstevel@tonic-gate 			rfs4_state_close(state, FALSE, FALSE, cs->cr);
63887c478bd9Sstevel@tonic-gate 		rfs4_state_rele(state);
63897c478bd9Sstevel@tonic-gate 		return;
63907c478bd9Sstevel@tonic-gate 	}
63917c478bd9Sstevel@tonic-gate 
6392da6c28aaSamw 	/* Calculate the fflags for this OPEN. */
6393da6c28aaSamw 	if (access & OPEN4_SHARE_ACCESS_READ)
6394da6c28aaSamw 		fflags |= FREAD;
6395da6c28aaSamw 	if (access & OPEN4_SHARE_ACCESS_WRITE)
6396da6c28aaSamw 		fflags |= FWRITE;
6397da6c28aaSamw 
6398fd93bfc3Sjwahlig 	/*
6399fd93bfc3Sjwahlig 	 * Calculate the new deny and access mode that this open is adding to
6400fd93bfc3Sjwahlig 	 * the file for this open owner;
6401fd93bfc3Sjwahlig 	 */
6402fd93bfc3Sjwahlig 	dmodes = (deny & ~state->share_deny);
6403fd93bfc3Sjwahlig 	amodes = (access & ~state->share_access);
64047c478bd9Sstevel@tonic-gate 
6405fd93bfc3Sjwahlig 	/*
6406fd93bfc3Sjwahlig 	 * Check to see the client has already sent an open for this
6407fd93bfc3Sjwahlig 	 * open owner on this file with the same share/deny modes.
6408fd93bfc3Sjwahlig 	 * If so, we don't need to check for a conflict and we don't
6409fd93bfc3Sjwahlig 	 * need to add another shrlock.  If not, then we need to
6410fd93bfc3Sjwahlig 	 * check for conflicts in deny and access before checking for
6411fd93bfc3Sjwahlig 	 * conflicts in delegation.  We don't want to recall a
6412fd93bfc3Sjwahlig 	 * delegation based on an open that will eventually fail based
6413fd93bfc3Sjwahlig 	 * on shares modes.
6414fd93bfc3Sjwahlig 	 */
64157c478bd9Sstevel@tonic-gate 
6416fd93bfc3Sjwahlig 	if (dmodes || amodes) {
6417fd93bfc3Sjwahlig 		shr.s_access = (short)access;
6418fd93bfc3Sjwahlig 		shr.s_deny = (short)deny;
6419fd93bfc3Sjwahlig 		shr.s_pid = rfs4_dbe_getid(oo->dbe);
6420fd93bfc3Sjwahlig 		shr.s_sysid = sysid;
6421fd93bfc3Sjwahlig 		shr_loco.sl_pid = shr.s_pid;
6422fd93bfc3Sjwahlig 		shr_loco.sl_id = shr.s_sysid;
6423fd93bfc3Sjwahlig 		shr.s_owner = (caddr_t)&shr_loco;
6424fd93bfc3Sjwahlig 		shr.s_own_len = sizeof (shr_loco);
64257c478bd9Sstevel@tonic-gate 
6426da6c28aaSamw 		cmd = nbl_need_check(cs->vp) ? F_SHARE_NBMAND : F_SHARE;
6427da6c28aaSamw 		if ((err = vop_shrlock(cs->vp, cmd, &shr, fflags)) != 0) {
6428fd93bfc3Sjwahlig 
6429fd93bfc3Sjwahlig 			resp->status = err == EAGAIN ?
64301b300de9Sjwahlig 			    NFS4ERR_SHARE_DENIED : puterrno4(err);
6431fd93bfc3Sjwahlig 
6432fd93bfc3Sjwahlig 			rfs4_file_rele(file);
6433fd93bfc3Sjwahlig 			/* Not a fully formed open; "close" it */
6434fd93bfc3Sjwahlig 			if (screate == TRUE)
6435fd93bfc3Sjwahlig 				rfs4_state_close(state, FALSE, FALSE, cs->cr);
6436fd93bfc3Sjwahlig 			rfs4_state_rele(state);
6437fd93bfc3Sjwahlig 			return;
6438fd93bfc3Sjwahlig 		}
64397c478bd9Sstevel@tonic-gate 	}
64407c478bd9Sstevel@tonic-gate 
64417c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(state->dbe);
64427c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(file->dbe);
64437c478bd9Sstevel@tonic-gate 
64447c478bd9Sstevel@tonic-gate 	/*
64457c478bd9Sstevel@tonic-gate 	 * Check to see if this file is delegated and if so, if a
64467c478bd9Sstevel@tonic-gate 	 * recall needs to be done.
64477c478bd9Sstevel@tonic-gate 	 */
64487c478bd9Sstevel@tonic-gate 	if (rfs4_check_recall(state, access)) {
64497c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(file->dbe);
64507c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(state->dbe);
64517c478bd9Sstevel@tonic-gate 		rfs4_recall_deleg(file, FALSE, state->owner->client);
64527c478bd9Sstevel@tonic-gate 		delay(NFS4_DELEGATION_CONFLICT_DELAY);
64537c478bd9Sstevel@tonic-gate 		rfs4_dbe_lock(state->dbe);
64547c478bd9Sstevel@tonic-gate 		rfs4_dbe_lock(file->dbe);
64557c478bd9Sstevel@tonic-gate 		/* Let's see if the delegation was returned */
64567c478bd9Sstevel@tonic-gate 		if (rfs4_check_recall(state, access)) {
64577c478bd9Sstevel@tonic-gate 			rfs4_dbe_unlock(file->dbe);
64587c478bd9Sstevel@tonic-gate 			rfs4_dbe_unlock(state->dbe);
64597c478bd9Sstevel@tonic-gate 			rfs4_file_rele(file);
64607c478bd9Sstevel@tonic-gate 			rfs4_update_lease(state->owner->client);
64617c478bd9Sstevel@tonic-gate 			(void) vop_shrlock(cs->vp, F_UNSHARE, &shr, fflags);
64627c478bd9Sstevel@tonic-gate 			/* Not a fully formed open; "close" it */
64637c478bd9Sstevel@tonic-gate 			if (screate == TRUE)
64647c478bd9Sstevel@tonic-gate 				rfs4_state_close(state, FALSE, FALSE, cs->cr);
64657c478bd9Sstevel@tonic-gate 			rfs4_state_rele(state);
64667c478bd9Sstevel@tonic-gate 			resp->status = NFS4ERR_DELAY;
64677c478bd9Sstevel@tonic-gate 			return;
64687c478bd9Sstevel@tonic-gate 		}
64697c478bd9Sstevel@tonic-gate 	}
6470da6c28aaSamw 	/*
6471da6c28aaSamw 	 * the share check passed and any delegation conflict has been
6472da6c28aaSamw 	 * taken care of, now call vop_open.
6473da6c28aaSamw 	 * if this is the first open then call vop_open with fflags.
6474da6c28aaSamw 	 * if not, call vn_open_upgrade with just the upgrade flags.
6475da6c28aaSamw 	 *
6476da6c28aaSamw 	 * if the file has been opened already, it will have the current
6477da6c28aaSamw 	 * access mode in the state struct.  if it has no share access, then
6478da6c28aaSamw 	 * this is a new open.
6479da6c28aaSamw 	 *
6480da6c28aaSamw 	 * However, if this is open with CLAIM_DLEGATE_CUR, then don't
6481da6c28aaSamw 	 * call VOP_OPEN(), just do the open upgrade.
6482da6c28aaSamw 	 */
6483da6c28aaSamw 	if (((state->share_access & OPEN4_SHARE_ACCESS_BOTH) == 0) &&
6484da6c28aaSamw 	    !deleg_cur) {
6485da6c28aaSamw 		ct.cc_sysid = sysid;
6486da6c28aaSamw 		ct.cc_pid = shr.s_pid;
6487da6c28aaSamw 		ct.cc_caller_id = nfs4_srv_caller_id;
6488da6c28aaSamw 		err = VOP_OPEN(&cs->vp, fflags, cs->cr, &ct);
6489da6c28aaSamw 		if (err) {
6490da6c28aaSamw 			rfs4_dbe_unlock(file->dbe);
6491da6c28aaSamw 			rfs4_dbe_unlock(state->dbe);
6492da6c28aaSamw 			rfs4_file_rele(file);
6493da6c28aaSamw 			(void) vop_shrlock(cs->vp, F_UNSHARE, &shr, fflags);
6494da6c28aaSamw 			/* Not a fully formed open; "close" it */
6495da6c28aaSamw 			if (screate == TRUE)
6496da6c28aaSamw 				rfs4_state_close(state, FALSE, FALSE, cs->cr);
6497da6c28aaSamw 			rfs4_state_rele(state);
6498da6c28aaSamw 			resp->status = NFS4ERR_SERVERFAULT;
6499da6c28aaSamw 			return;
6500da6c28aaSamw 		}
6501da6c28aaSamw 	} else { /* open upgrade */
6502da6c28aaSamw 		/*
6503da6c28aaSamw 		 * calculate the fflags for the new mode that is being added
6504da6c28aaSamw 		 * by this upgrade.
6505da6c28aaSamw 		 */
6506da6c28aaSamw 		fflags = 0;
6507da6c28aaSamw 		if (amodes & OPEN4_SHARE_ACCESS_READ)
6508da6c28aaSamw 			fflags |= FREAD;
6509da6c28aaSamw 		if (amodes & OPEN4_SHARE_ACCESS_WRITE)
6510da6c28aaSamw 			fflags |= FWRITE;
6511da6c28aaSamw 		vn_open_upgrade(cs->vp, fflags);
6512da6c28aaSamw 	}
65137c478bd9Sstevel@tonic-gate 
65147c478bd9Sstevel@tonic-gate 	if (dmodes & OPEN4_SHARE_DENY_READ)
65157c478bd9Sstevel@tonic-gate 		file->deny_read++;
65167c478bd9Sstevel@tonic-gate 	if (dmodes & OPEN4_SHARE_DENY_WRITE)
65177c478bd9Sstevel@tonic-gate 		file->deny_write++;
65187c478bd9Sstevel@tonic-gate 	file->share_deny |= deny;
65197c478bd9Sstevel@tonic-gate 	state->share_deny |= deny;
65207c478bd9Sstevel@tonic-gate 
65217c478bd9Sstevel@tonic-gate 	if (amodes & OPEN4_SHARE_ACCESS_READ)
65227c478bd9Sstevel@tonic-gate 		file->access_read++;
65237c478bd9Sstevel@tonic-gate 	if (amodes & OPEN4_SHARE_ACCESS_WRITE)
65247c478bd9Sstevel@tonic-gate 		file->access_write++;
65257c478bd9Sstevel@tonic-gate 	file->share_access |= access;
65267c478bd9Sstevel@tonic-gate 	state->share_access |= access;
65277c478bd9Sstevel@tonic-gate 
65287c478bd9Sstevel@tonic-gate 	/*
65297c478bd9Sstevel@tonic-gate 	 * Check for delegation here. if the deleg argument is not
65307c478bd9Sstevel@tonic-gate 	 * DELEG_ANY, then this is a reclaim from a client and
65317c478bd9Sstevel@tonic-gate 	 * we must honor the delegation requested. If necessary we can
65327c478bd9Sstevel@tonic-gate 	 * set the recall flag.
65337c478bd9Sstevel@tonic-gate 	 */
65347c478bd9Sstevel@tonic-gate 
65357c478bd9Sstevel@tonic-gate 	dsp = rfs4_grant_delegation(deleg, state, &recall);
65367c478bd9Sstevel@tonic-gate 
65377c478bd9Sstevel@tonic-gate 	cs->deleg = (file->dinfo->dtype == OPEN_DELEGATE_WRITE);
65387c478bd9Sstevel@tonic-gate 
65397c478bd9Sstevel@tonic-gate 	next_stateid(&state->stateid);
65407c478bd9Sstevel@tonic-gate 
65417c478bd9Sstevel@tonic-gate 	resp->stateid = state->stateid.stateid;
65427c478bd9Sstevel@tonic-gate 
65437c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(file->dbe);
65447c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(state->dbe);
65457c478bd9Sstevel@tonic-gate 
65467c478bd9Sstevel@tonic-gate 	if (dsp) {
65477c478bd9Sstevel@tonic-gate 		rfs4_set_deleg_response(dsp, &resp->delegation, NULL, recall);
65487c478bd9Sstevel@tonic-gate 		rfs4_deleg_state_rele(dsp);
65497c478bd9Sstevel@tonic-gate 	}
65507c478bd9Sstevel@tonic-gate 
65517c478bd9Sstevel@tonic-gate 	rfs4_file_rele(file);
65527c478bd9Sstevel@tonic-gate 	rfs4_state_rele(state);
65537c478bd9Sstevel@tonic-gate 
65547c478bd9Sstevel@tonic-gate 	resp->status = NFS4_OK;
65557c478bd9Sstevel@tonic-gate }
65567c478bd9Sstevel@tonic-gate 
65577c478bd9Sstevel@tonic-gate /*ARGSUSED*/
65587c478bd9Sstevel@tonic-gate static void
65597c478bd9Sstevel@tonic-gate rfs4_do_opennull(struct compound_state *cs, struct svc_req *req,
65607c478bd9Sstevel@tonic-gate 		OPEN4args *args, rfs4_openowner_t *oo, OPEN4res *resp)
65617c478bd9Sstevel@tonic-gate {
65627c478bd9Sstevel@tonic-gate 	change_info4 *cinfo = &resp->cinfo;
65637c478bd9Sstevel@tonic-gate 	bitmap4 *attrset = &resp->attrset;
65647c478bd9Sstevel@tonic-gate 
65657c478bd9Sstevel@tonic-gate 	if (args->opentype == OPEN4_NOCREATE)
65667c478bd9Sstevel@tonic-gate 		resp->status = rfs4_lookupfile(&args->open_claim4_u.file,
65671b300de9Sjwahlig 		    req, cs, args->share_access, cinfo);
65687c478bd9Sstevel@tonic-gate 	else {
65697c478bd9Sstevel@tonic-gate 		/* inhibit delegation grants during exclusive create */
65707c478bd9Sstevel@tonic-gate 
65717c478bd9Sstevel@tonic-gate 		if (args->mode == EXCLUSIVE4)
65727c478bd9Sstevel@tonic-gate 			rfs4_disable_delegation();
65737c478bd9Sstevel@tonic-gate 
65747c478bd9Sstevel@tonic-gate 		resp->status = rfs4_createfile(args, req, cs, cinfo, attrset,
65751b300de9Sjwahlig 		    oo->client->clientid);
65767c478bd9Sstevel@tonic-gate 	}
65777c478bd9Sstevel@tonic-gate 
65787c478bd9Sstevel@tonic-gate 	if (resp->status == NFS4_OK) {
65797c478bd9Sstevel@tonic-gate 
65807c478bd9Sstevel@tonic-gate 		/* cs->vp cs->fh now reference the desired file */
65817c478bd9Sstevel@tonic-gate 
65827c478bd9Sstevel@tonic-gate 		rfs4_do_open(cs, req, oo, DELEG_ANY, args->share_access,
6583da6c28aaSamw 		    args->share_deny, resp, 0);
65847c478bd9Sstevel@tonic-gate 
65857c478bd9Sstevel@tonic-gate 		/*
65867c478bd9Sstevel@tonic-gate 		 * If rfs4_createfile set attrset, we must
65877c478bd9Sstevel@tonic-gate 		 * clear this attrset before the response is copied.
65887c478bd9Sstevel@tonic-gate 		 */
65897c478bd9Sstevel@tonic-gate 		if (resp->status != NFS4_OK && resp->attrset) {
65907c478bd9Sstevel@tonic-gate 			resp->attrset = 0;
65917c478bd9Sstevel@tonic-gate 		}
65927c478bd9Sstevel@tonic-gate 	}
65937c478bd9Sstevel@tonic-gate 	else
65947c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status;
65957c478bd9Sstevel@tonic-gate 
65967c478bd9Sstevel@tonic-gate 	if (args->mode == EXCLUSIVE4)
65977c478bd9Sstevel@tonic-gate 		rfs4_enable_delegation();
65987c478bd9Sstevel@tonic-gate }
65997c478bd9Sstevel@tonic-gate 
66007c478bd9Sstevel@tonic-gate /*ARGSUSED*/
66017c478bd9Sstevel@tonic-gate static void
66027c478bd9Sstevel@tonic-gate rfs4_do_openprev(struct compound_state *cs, struct svc_req *req,
66037c478bd9Sstevel@tonic-gate 		OPEN4args *args, rfs4_openowner_t *oo, OPEN4res *resp)
66047c478bd9Sstevel@tonic-gate {
66057c478bd9Sstevel@tonic-gate 	change_info4 *cinfo = &resp->cinfo;
66067c478bd9Sstevel@tonic-gate 	vattr_t va;
66077c478bd9Sstevel@tonic-gate 	vtype_t v_type = cs->vp->v_type;
66087c478bd9Sstevel@tonic-gate 	int error = 0;
66097c478bd9Sstevel@tonic-gate 
66107c478bd9Sstevel@tonic-gate 	/* Verify that we have a regular file */
66117c478bd9Sstevel@tonic-gate 	if (v_type != VREG) {
66127c478bd9Sstevel@tonic-gate 		if (v_type == VDIR)
66137c478bd9Sstevel@tonic-gate 			resp->status = NFS4ERR_ISDIR;
66147c478bd9Sstevel@tonic-gate 		else if (v_type == VLNK)
66157c478bd9Sstevel@tonic-gate 			resp->status = NFS4ERR_SYMLINK;
66167c478bd9Sstevel@tonic-gate 		else
66177c478bd9Sstevel@tonic-gate 			resp->status = NFS4ERR_INVAL;
66187c478bd9Sstevel@tonic-gate 		return;
66197c478bd9Sstevel@tonic-gate 	}
66207c478bd9Sstevel@tonic-gate 
66217c478bd9Sstevel@tonic-gate 	va.va_mask = AT_MODE|AT_UID;
6622da6c28aaSamw 	error = VOP_GETATTR(cs->vp, &va, 0, cs->cr, NULL);
66237c478bd9Sstevel@tonic-gate 	if (error) {
66247c478bd9Sstevel@tonic-gate 		resp->status = puterrno4(error);
66257c478bd9Sstevel@tonic-gate 		return;
66267c478bd9Sstevel@tonic-gate 	}
66277c478bd9Sstevel@tonic-gate 
66287c478bd9Sstevel@tonic-gate 	cs->mandlock = MANDLOCK(cs->vp, va.va_mode);
66297c478bd9Sstevel@tonic-gate 
66307c478bd9Sstevel@tonic-gate 	/*
66317c478bd9Sstevel@tonic-gate 	 * Check if we have access to the file, Note the the file
66327c478bd9Sstevel@tonic-gate 	 * could have originally been open UNCHECKED or GUARDED
66337c478bd9Sstevel@tonic-gate 	 * with mode bits that will now fail, but there is nothing
66347c478bd9Sstevel@tonic-gate 	 * we can really do about that except in the case that the
66357c478bd9Sstevel@tonic-gate 	 * owner of the file is the one requesting the open.
66367c478bd9Sstevel@tonic-gate 	 */
66377c478bd9Sstevel@tonic-gate 	if (crgetuid(cs->cr) != va.va_uid) {
66387c478bd9Sstevel@tonic-gate 		resp->status = check_open_access(args->share_access, cs, req);
66397c478bd9Sstevel@tonic-gate 		if (resp->status != NFS4_OK) {
66407c478bd9Sstevel@tonic-gate 			return;
66417c478bd9Sstevel@tonic-gate 		}
66427c478bd9Sstevel@tonic-gate 	}
66437c478bd9Sstevel@tonic-gate 
66447c478bd9Sstevel@tonic-gate 	/*
66457c478bd9Sstevel@tonic-gate 	 * cinfo on a CLAIM_PREVIOUS is undefined, initialize to zero
66467c478bd9Sstevel@tonic-gate 	 */
66477c478bd9Sstevel@tonic-gate 	cinfo->before = 0;
66487c478bd9Sstevel@tonic-gate 	cinfo->after = 0;
66497c478bd9Sstevel@tonic-gate 	cinfo->atomic = FALSE;
66507c478bd9Sstevel@tonic-gate 
66517c478bd9Sstevel@tonic-gate 	rfs4_do_open(cs, req, oo,
66521b300de9Sjwahlig 	    NFS4_DELEG4TYPE2REQTYPE(args->open_claim4_u.delegate_type),
6653da6c28aaSamw 	    args->share_access, args->share_deny, resp, 0);
66547c478bd9Sstevel@tonic-gate }
66557c478bd9Sstevel@tonic-gate 
66567c478bd9Sstevel@tonic-gate static void
66577c478bd9Sstevel@tonic-gate rfs4_do_opendelcur(struct compound_state *cs, struct svc_req *req,
66587c478bd9Sstevel@tonic-gate 		OPEN4args *args, rfs4_openowner_t *oo, OPEN4res *resp)
66597c478bd9Sstevel@tonic-gate {
66607c478bd9Sstevel@tonic-gate 	int error;
66617c478bd9Sstevel@tonic-gate 	nfsstat4 status;
66627c478bd9Sstevel@tonic-gate 	stateid4 stateid =
66631b300de9Sjwahlig 	    args->open_claim4_u.delegate_cur_info.delegate_stateid;
66647c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_t *dsp;
66657c478bd9Sstevel@tonic-gate 
66667c478bd9Sstevel@tonic-gate 	/*
66677c478bd9Sstevel@tonic-gate 	 * Find the state info from the stateid and confirm that the
66687c478bd9Sstevel@tonic-gate 	 * file is delegated.  If the state openowner is the same as
66697c478bd9Sstevel@tonic-gate 	 * the supplied openowner we're done. If not, get the file
66707c478bd9Sstevel@tonic-gate 	 * info from the found state info. Use that file info to
66717c478bd9Sstevel@tonic-gate 	 * create the state for this lock owner. Note solaris doen't
66727c478bd9Sstevel@tonic-gate 	 * really need the pathname to find the file. We may want to
66737c478bd9Sstevel@tonic-gate 	 * lookup the pathname and make sure that the vp exist and
66747c478bd9Sstevel@tonic-gate 	 * matches the vp in the file structure. However it is
66757c478bd9Sstevel@tonic-gate 	 * possible that the pathname nolonger exists (local process
66767c478bd9Sstevel@tonic-gate 	 * unlinks the file), so this may not be that useful.
66777c478bd9Sstevel@tonic-gate 	 */
66787c478bd9Sstevel@tonic-gate 
66797c478bd9Sstevel@tonic-gate 	status = rfs4_get_deleg_state(&stateid, &dsp);
66807c478bd9Sstevel@tonic-gate 	if (status != NFS4_OK) {
66817c478bd9Sstevel@tonic-gate 		resp->status = status;
66827c478bd9Sstevel@tonic-gate 		return;
66837c478bd9Sstevel@tonic-gate 	}
66847c478bd9Sstevel@tonic-gate 
66857c478bd9Sstevel@tonic-gate 	ASSERT(dsp->finfo->dinfo->dtype != OPEN_DELEGATE_NONE);
66867c478bd9Sstevel@tonic-gate 
66877c478bd9Sstevel@tonic-gate 	/*
66887c478bd9Sstevel@tonic-gate 	 * New lock owner, create state. Since this was probably called
66897c478bd9Sstevel@tonic-gate 	 * in response to a CB_RECALL we set deleg to DELEG_NONE
66907c478bd9Sstevel@tonic-gate 	 */
66917c478bd9Sstevel@tonic-gate 
66927c478bd9Sstevel@tonic-gate 	ASSERT(cs->vp != NULL);
66937c478bd9Sstevel@tonic-gate 	VN_RELE(cs->vp);
66947c478bd9Sstevel@tonic-gate 	VN_HOLD(dsp->finfo->vp);
66957c478bd9Sstevel@tonic-gate 	cs->vp = dsp->finfo->vp;
66967c478bd9Sstevel@tonic-gate 
66977c478bd9Sstevel@tonic-gate 	if (error = makefh4(&cs->fh, cs->vp, cs->exi)) {
66987c478bd9Sstevel@tonic-gate 		rfs4_deleg_state_rele(dsp);
66997c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = puterrno4(error);
67007c478bd9Sstevel@tonic-gate 		return;
67017c478bd9Sstevel@tonic-gate 	}
67027c478bd9Sstevel@tonic-gate 
67037c478bd9Sstevel@tonic-gate 	/* Mark progress for delegation returns */
67047c478bd9Sstevel@tonic-gate 	dsp->finfo->dinfo->time_lastwrite = gethrestime_sec();
67057c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_rele(dsp);
67067c478bd9Sstevel@tonic-gate 	rfs4_do_open(cs, req, oo, DELEG_NONE,
6707da6c28aaSamw 	    args->share_access, args->share_deny, resp, 1);
67087c478bd9Sstevel@tonic-gate }
67097c478bd9Sstevel@tonic-gate 
67107c478bd9Sstevel@tonic-gate /*ARGSUSED*/
67117c478bd9Sstevel@tonic-gate static void
67127c478bd9Sstevel@tonic-gate rfs4_do_opendelprev(struct compound_state *cs, struct svc_req *req,
67137c478bd9Sstevel@tonic-gate 			OPEN4args *args, rfs4_openowner_t *oo, OPEN4res *resp)
67147c478bd9Sstevel@tonic-gate {
67157c478bd9Sstevel@tonic-gate 	/*
67167c478bd9Sstevel@tonic-gate 	 * Lookup the pathname, it must already exist since this file
67177c478bd9Sstevel@tonic-gate 	 * was delegated.
67187c478bd9Sstevel@tonic-gate 	 *
67197c478bd9Sstevel@tonic-gate 	 * Find the file and state info for this vp and open owner pair.
67207c478bd9Sstevel@tonic-gate 	 *	check that they are in fact delegated.
67217c478bd9Sstevel@tonic-gate 	 *	check that the state access and deny modes are the same.
67227c478bd9Sstevel@tonic-gate 	 *
67237c478bd9Sstevel@tonic-gate 	 * Return the delgation possibly seting the recall flag.
67247c478bd9Sstevel@tonic-gate 	 */
67257c478bd9Sstevel@tonic-gate 	rfs4_file_t *file;
67267c478bd9Sstevel@tonic-gate 	rfs4_state_t *state;
67277c478bd9Sstevel@tonic-gate 	bool_t create = FALSE;
67287c478bd9Sstevel@tonic-gate 	bool_t dcreate = FALSE;
67297c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_t *dsp;
67307c478bd9Sstevel@tonic-gate 	nfsace4 *ace;
67317c478bd9Sstevel@tonic-gate 
67327c478bd9Sstevel@tonic-gate 
67337c478bd9Sstevel@tonic-gate 	/* Note we ignore oflags */
67347c478bd9Sstevel@tonic-gate 	resp->status = rfs4_lookupfile(&args->open_claim4_u.file_delegate_prev,
67351b300de9Sjwahlig 	    req, cs, args->share_access, &resp->cinfo);
67367c478bd9Sstevel@tonic-gate 
67377c478bd9Sstevel@tonic-gate 	if (resp->status != NFS4_OK) {
67387c478bd9Sstevel@tonic-gate 		return;
67397c478bd9Sstevel@tonic-gate 	}
67407c478bd9Sstevel@tonic-gate 
67417c478bd9Sstevel@tonic-gate 	/* get the file struct and hold a lock on it during initial open */
67427c478bd9Sstevel@tonic-gate 	file = rfs4_findfile_withlock(cs->vp, NULL, &create);
67437c478bd9Sstevel@tonic-gate 	if (file == NULL) {
67447c478bd9Sstevel@tonic-gate 		NFS4_DEBUG(rfs4_debug,
67451b300de9Sjwahlig 		    (CE_NOTE, "rfs4_do_opendelprev: can't find file"));
67467c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_SERVERFAULT;
67477c478bd9Sstevel@tonic-gate 		return;
67487c478bd9Sstevel@tonic-gate 	}
67497c478bd9Sstevel@tonic-gate 
67507c478bd9Sstevel@tonic-gate 	state = rfs4_findstate_by_owner_file(oo, file, &create);
67517c478bd9Sstevel@tonic-gate 	if (state == NULL) {
67527c478bd9Sstevel@tonic-gate 		NFS4_DEBUG(rfs4_debug,
67531b300de9Sjwahlig 		    (CE_NOTE, "rfs4_do_opendelprev: can't find state"));
67547c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_SERVERFAULT;
67557c478bd9Sstevel@tonic-gate 		rfs4_file_rele_withunlock(file);
67567c478bd9Sstevel@tonic-gate 		return;
67577c478bd9Sstevel@tonic-gate 	}
67587c478bd9Sstevel@tonic-gate 
67597c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(state->dbe);
67607c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(file->dbe);
67617c478bd9Sstevel@tonic-gate 	if (args->share_access != state->share_access ||
67621b300de9Sjwahlig 	    args->share_deny != state->share_deny ||
67631b300de9Sjwahlig 	    state->finfo->dinfo->dtype == OPEN_DELEGATE_NONE) {
67647c478bd9Sstevel@tonic-gate 		NFS4_DEBUG(rfs4_debug,
67651b300de9Sjwahlig 		    (CE_NOTE, "rfs4_do_opendelprev: state mixup"));
67667c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(file->dbe);
67677c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(state->dbe);
67687c478bd9Sstevel@tonic-gate 		rfs4_file_rele(file);
67697c478bd9Sstevel@tonic-gate 		rfs4_state_rele(state);
67707c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_SERVERFAULT;
67717c478bd9Sstevel@tonic-gate 		return;
67727c478bd9Sstevel@tonic-gate 	}
67737c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(file->dbe);
67747c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(state->dbe);
67757c478bd9Sstevel@tonic-gate 
67767c478bd9Sstevel@tonic-gate 	dsp = rfs4_finddeleg(state, &dcreate);
67777c478bd9Sstevel@tonic-gate 	if (dsp == NULL) {
67787c478bd9Sstevel@tonic-gate 		rfs4_state_rele(state);
67797c478bd9Sstevel@tonic-gate 		rfs4_file_rele(file);
67807c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_SERVERFAULT;
67817c478bd9Sstevel@tonic-gate 		return;
67827c478bd9Sstevel@tonic-gate 	}
67837c478bd9Sstevel@tonic-gate 
67847c478bd9Sstevel@tonic-gate 	next_stateid(&state->stateid);
67857c478bd9Sstevel@tonic-gate 
67867c478bd9Sstevel@tonic-gate 	resp->stateid = state->stateid.stateid;
67877c478bd9Sstevel@tonic-gate 
67887c478bd9Sstevel@tonic-gate 	resp->delegation.delegation_type = dsp->dtype;
67897c478bd9Sstevel@tonic-gate 
67907c478bd9Sstevel@tonic-gate 	if (dsp->dtype == OPEN_DELEGATE_READ) {
67917c478bd9Sstevel@tonic-gate 		open_read_delegation4 *rv =
67921b300de9Sjwahlig 		    &resp->delegation.open_delegation4_u.read;
67937c478bd9Sstevel@tonic-gate 
67947c478bd9Sstevel@tonic-gate 		rv->stateid = dsp->delegid.stateid;
67957c478bd9Sstevel@tonic-gate 		rv->recall = FALSE; /* no policy in place to set to TRUE */
67967c478bd9Sstevel@tonic-gate 		ace = &rv->permissions;
67977c478bd9Sstevel@tonic-gate 	} else {
67987c478bd9Sstevel@tonic-gate 		open_write_delegation4 *rv =
67991b300de9Sjwahlig 		    &resp->delegation.open_delegation4_u.write;
68007c478bd9Sstevel@tonic-gate 
68017c478bd9Sstevel@tonic-gate 		rv->stateid = dsp->delegid.stateid;
68027c478bd9Sstevel@tonic-gate 		rv->recall = FALSE;  /* no policy in place to set to TRUE */
68037c478bd9Sstevel@tonic-gate 		ace = &rv->permissions;
68047c478bd9Sstevel@tonic-gate 		rv->space_limit.limitby = NFS_LIMIT_SIZE;
68057c478bd9Sstevel@tonic-gate 		rv->space_limit.nfs_space_limit4_u.filesize = UINT64_MAX;
68067c478bd9Sstevel@tonic-gate 	}
68077c478bd9Sstevel@tonic-gate 
68087c478bd9Sstevel@tonic-gate 	/* XXX For now */
68097c478bd9Sstevel@tonic-gate 	ace->type = ACE4_ACCESS_ALLOWED_ACE_TYPE;
68107c478bd9Sstevel@tonic-gate 	ace->flag = 0;
68117c478bd9Sstevel@tonic-gate 	ace->access_mask = 0;
68127c478bd9Sstevel@tonic-gate 	ace->who.utf8string_len = 0;
68137c478bd9Sstevel@tonic-gate 	ace->who.utf8string_val = 0;
68147c478bd9Sstevel@tonic-gate 
68157c478bd9Sstevel@tonic-gate 	rfs4_deleg_state_rele(dsp);
68167c478bd9Sstevel@tonic-gate 	rfs4_state_rele(state);
68177c478bd9Sstevel@tonic-gate 	rfs4_file_rele(file);
68187c478bd9Sstevel@tonic-gate }
68197c478bd9Sstevel@tonic-gate 
68207c478bd9Sstevel@tonic-gate typedef enum {
68217c478bd9Sstevel@tonic-gate 	NFS4_CHKSEQ_OKAY = 0,
68227c478bd9Sstevel@tonic-gate 	NFS4_CHKSEQ_REPLAY = 1,
68237c478bd9Sstevel@tonic-gate 	NFS4_CHKSEQ_BAD = 2
68247c478bd9Sstevel@tonic-gate } rfs4_chkseq_t;
68257c478bd9Sstevel@tonic-gate 
68267c478bd9Sstevel@tonic-gate /*
68277c478bd9Sstevel@tonic-gate  * Generic function for sequence number checks.
68287c478bd9Sstevel@tonic-gate  */
68297c478bd9Sstevel@tonic-gate static rfs4_chkseq_t
68307c478bd9Sstevel@tonic-gate rfs4_check_seqid(seqid4 seqid, nfs_resop4 *lastop,
68317c478bd9Sstevel@tonic-gate 		seqid4 rqst_seq, nfs_resop4 *resop, bool_t copyres)
68327c478bd9Sstevel@tonic-gate {
68337c478bd9Sstevel@tonic-gate 	/* Same sequence ids and matching operations? */
68347c478bd9Sstevel@tonic-gate 	if (seqid == rqst_seq && resop->resop == lastop->resop) {
68357c478bd9Sstevel@tonic-gate 		if (copyres == TRUE) {
68367c478bd9Sstevel@tonic-gate 			rfs4_free_reply(resop);
68377c478bd9Sstevel@tonic-gate 			rfs4_copy_reply(resop, lastop);
68387c478bd9Sstevel@tonic-gate 		}
68397c478bd9Sstevel@tonic-gate 		NFS4_DEBUG(rfs4_debug, (CE_NOTE,
68401b300de9Sjwahlig 		    "Replayed SEQID %d\n", seqid));
68417c478bd9Sstevel@tonic-gate 		return (NFS4_CHKSEQ_REPLAY);
68427c478bd9Sstevel@tonic-gate 	}
68437c478bd9Sstevel@tonic-gate 
68447c478bd9Sstevel@tonic-gate 	/* If the incoming sequence is not the next expected then it is bad */
68457c478bd9Sstevel@tonic-gate 	if (rqst_seq != seqid + 1) {
68467c478bd9Sstevel@tonic-gate 		if (rqst_seq == seqid) {
68477c478bd9Sstevel@tonic-gate 			NFS4_DEBUG(rfs4_debug,
68481b300de9Sjwahlig 			    (CE_NOTE, "BAD SEQID: Replayed sequence id "
68491b300de9Sjwahlig 			    "but last op was %d current op is %d\n",
68501b300de9Sjwahlig 			    lastop->resop, resop->resop));
68517c478bd9Sstevel@tonic-gate 			return (NFS4_CHKSEQ_BAD);
68527c478bd9Sstevel@tonic-gate 		}
68537c478bd9Sstevel@tonic-gate 		NFS4_DEBUG(rfs4_debug,
68541b300de9Sjwahlig 		    (CE_NOTE, "BAD SEQID: got %u expecting %u\n",
68551b300de9Sjwahlig 		    rqst_seq, seqid));
68567c478bd9Sstevel@tonic-gate 		return (NFS4_CHKSEQ_BAD);
68577c478bd9Sstevel@tonic-gate 	}
68587c478bd9Sstevel@tonic-gate 
68597c478bd9Sstevel@tonic-gate 	/* Everything okay -- next expected */
68607c478bd9Sstevel@tonic-gate 	return (NFS4_CHKSEQ_OKAY);
68617c478bd9Sstevel@tonic-gate }
68627c478bd9Sstevel@tonic-gate 
68637c478bd9Sstevel@tonic-gate 
68647c478bd9Sstevel@tonic-gate static rfs4_chkseq_t
68657c478bd9Sstevel@tonic-gate rfs4_check_open_seqid(seqid4 seqid, rfs4_openowner_t *op, nfs_resop4 *resop)
68667c478bd9Sstevel@tonic-gate {
68677c478bd9Sstevel@tonic-gate 	rfs4_chkseq_t rc;
68687c478bd9Sstevel@tonic-gate 
68697c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(op->dbe);
68707c478bd9Sstevel@tonic-gate 	rc = rfs4_check_seqid(op->open_seqid, op->reply, seqid, resop, TRUE);
68717c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(op->dbe);
68727c478bd9Sstevel@tonic-gate 
68737c478bd9Sstevel@tonic-gate 	if (rc == NFS4_CHKSEQ_OKAY)
68747c478bd9Sstevel@tonic-gate 		rfs4_update_lease(op->client);
68757c478bd9Sstevel@tonic-gate 
68767c478bd9Sstevel@tonic-gate 	return (rc);
68777c478bd9Sstevel@tonic-gate }
68787c478bd9Sstevel@tonic-gate 
68797c478bd9Sstevel@tonic-gate static rfs4_chkseq_t
68807c478bd9Sstevel@tonic-gate rfs4_check_olo_seqid(seqid4 olo_seqid, rfs4_openowner_t *op,
68817c478bd9Sstevel@tonic-gate 	nfs_resop4 *resop)
68827c478bd9Sstevel@tonic-gate {
68837c478bd9Sstevel@tonic-gate 	rfs4_chkseq_t rc;
68847c478bd9Sstevel@tonic-gate 
68857c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(op->dbe);
68867c478bd9Sstevel@tonic-gate 	rc = rfs4_check_seqid(op->open_seqid, op->reply,
68871b300de9Sjwahlig 	    olo_seqid, resop, FALSE);
68887c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(op->dbe);
68897c478bd9Sstevel@tonic-gate 
68907c478bd9Sstevel@tonic-gate 	return (rc);
68917c478bd9Sstevel@tonic-gate }
68927c478bd9Sstevel@tonic-gate 
68937c478bd9Sstevel@tonic-gate static rfs4_chkseq_t
68947c478bd9Sstevel@tonic-gate rfs4_check_lock_seqid(seqid4 seqid, rfs4_lo_state_t *lp, nfs_resop4 *resop)
68957c478bd9Sstevel@tonic-gate {
68967c478bd9Sstevel@tonic-gate 	rfs4_chkseq_t rc = NFS4_CHKSEQ_OKAY;
68977c478bd9Sstevel@tonic-gate 
68987c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(lp->dbe);
68997c478bd9Sstevel@tonic-gate 	if (!lp->skip_seqid_check)
69001b300de9Sjwahlig 		rc = rfs4_check_seqid(lp->seqid, lp->reply, seqid, resop, TRUE);
69017c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(lp->dbe);
69027c478bd9Sstevel@tonic-gate 
69037c478bd9Sstevel@tonic-gate 	return (rc);
69047c478bd9Sstevel@tonic-gate }
69057c478bd9Sstevel@tonic-gate 
69067c478bd9Sstevel@tonic-gate static void
69077c478bd9Sstevel@tonic-gate rfs4_op_open(nfs_argop4 *argop, nfs_resop4 *resop,
69087c478bd9Sstevel@tonic-gate 	    struct svc_req *req, struct compound_state *cs)
69097c478bd9Sstevel@tonic-gate {
69107c478bd9Sstevel@tonic-gate 	OPEN4args *args = &argop->nfs_argop4_u.opopen;
69117c478bd9Sstevel@tonic-gate 	OPEN4res *resp = &resop->nfs_resop4_u.opopen;
69127c478bd9Sstevel@tonic-gate 	open_owner4 *owner = &args->owner;
69137c478bd9Sstevel@tonic-gate 	open_claim_type4 claim = args->claim;
69147c478bd9Sstevel@tonic-gate 	rfs4_client_t *cp;
69157c478bd9Sstevel@tonic-gate 	rfs4_openowner_t *oo;
69167c478bd9Sstevel@tonic-gate 	bool_t create;
69177c478bd9Sstevel@tonic-gate 	bool_t replay = FALSE;
69187c478bd9Sstevel@tonic-gate 	int can_reclaim;
69197c478bd9Sstevel@tonic-gate 
6920*f3b585ceSsamf 	DTRACE_NFSV4_2(op__open__start, struct compound_state *, cs,
6921*f3b585ceSsamf 	    OPEN4args *, args);
69227c478bd9Sstevel@tonic-gate 
69237c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
69247c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
6925*f3b585ceSsamf 		goto end;
69267c478bd9Sstevel@tonic-gate 	}
69277c478bd9Sstevel@tonic-gate 
69287c478bd9Sstevel@tonic-gate 	/*
69297c478bd9Sstevel@tonic-gate 	 * Need to check clientid and lease expiration first based on
69307c478bd9Sstevel@tonic-gate 	 * error ordering and incrementing sequence id.
69317c478bd9Sstevel@tonic-gate 	 */
69327c478bd9Sstevel@tonic-gate 	cp = rfs4_findclient_by_id(owner->clientid, FALSE);
69337c478bd9Sstevel@tonic-gate 	if (cp == NULL) {
69347c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status =
69351b300de9Sjwahlig 		    rfs4_check_clientid(&owner->clientid, 0);
6936*f3b585ceSsamf 		goto end;
69377c478bd9Sstevel@tonic-gate 	}
69387c478bd9Sstevel@tonic-gate 
69397c478bd9Sstevel@tonic-gate 	if (rfs4_lease_expired(cp)) {
69407c478bd9Sstevel@tonic-gate 		rfs4_client_close(cp);
69417c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
6942*f3b585ceSsamf 		goto end;
69437c478bd9Sstevel@tonic-gate 	}
69447c478bd9Sstevel@tonic-gate 	can_reclaim = cp->can_reclaim;
69457c478bd9Sstevel@tonic-gate 
69467c478bd9Sstevel@tonic-gate 	/*
69477c478bd9Sstevel@tonic-gate 	 * Find the open_owner for use from this point forward.  Take
69487c478bd9Sstevel@tonic-gate 	 * care in updating the sequence id based on the type of error
69497c478bd9Sstevel@tonic-gate 	 * being returned.
69507c478bd9Sstevel@tonic-gate 	 */
69517c478bd9Sstevel@tonic-gate retry:
69527c478bd9Sstevel@tonic-gate 	create = TRUE;
69537c478bd9Sstevel@tonic-gate 	oo = rfs4_findopenowner(owner, &create, args->seqid);
69547c478bd9Sstevel@tonic-gate 	if (oo == NULL) {
69557c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_STALE_CLIENTID;
69567c478bd9Sstevel@tonic-gate 		rfs4_client_rele(cp);
6957*f3b585ceSsamf 		goto end;
69587c478bd9Sstevel@tonic-gate 	}
69597c478bd9Sstevel@tonic-gate 
69607c478bd9Sstevel@tonic-gate 	/* Hold off access to the sequence space while the open is done */
69617c478bd9Sstevel@tonic-gate 	rfs4_sw_enter(&oo->oo_sw);
69627c478bd9Sstevel@tonic-gate 
69637c478bd9Sstevel@tonic-gate 	/*
69647c478bd9Sstevel@tonic-gate 	 * If the open_owner existed before at the server, then check
69657c478bd9Sstevel@tonic-gate 	 * the sequence id.
69667c478bd9Sstevel@tonic-gate 	 */
69677c478bd9Sstevel@tonic-gate 	if (!create && !oo->postpone_confirm) {
69687c478bd9Sstevel@tonic-gate 		switch (rfs4_check_open_seqid(args->seqid, oo, resop)) {
69697c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_BAD:
69707c478bd9Sstevel@tonic-gate 			if ((args->seqid > oo->open_seqid) &&
69711b300de9Sjwahlig 			    oo->need_confirm) {
69727c478bd9Sstevel@tonic-gate 				rfs4_free_opens(oo, TRUE, FALSE);
69737c478bd9Sstevel@tonic-gate 				rfs4_sw_exit(&oo->oo_sw);
69747c478bd9Sstevel@tonic-gate 				rfs4_openowner_rele(oo);
69757c478bd9Sstevel@tonic-gate 				goto retry;
69767c478bd9Sstevel@tonic-gate 			}
69777c478bd9Sstevel@tonic-gate 			resp->status = NFS4ERR_BAD_SEQID;
69787c478bd9Sstevel@tonic-gate 			goto out;
69797c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_REPLAY: /* replay of previous request */
69807c478bd9Sstevel@tonic-gate 			replay = TRUE;
69817c478bd9Sstevel@tonic-gate 			goto out;
69827c478bd9Sstevel@tonic-gate 		default:
69837c478bd9Sstevel@tonic-gate 			break;
69847c478bd9Sstevel@tonic-gate 		}
69857c478bd9Sstevel@tonic-gate 
69867c478bd9Sstevel@tonic-gate 		/*
69877c478bd9Sstevel@tonic-gate 		 * Sequence was ok and open owner exists
69887c478bd9Sstevel@tonic-gate 		 * check to see if we have yet to see an
69897c478bd9Sstevel@tonic-gate 		 * open_confirm.
69907c478bd9Sstevel@tonic-gate 		 */
69917c478bd9Sstevel@tonic-gate 		if (oo->need_confirm) {
69927c478bd9Sstevel@tonic-gate 			rfs4_free_opens(oo, TRUE, FALSE);
69937c478bd9Sstevel@tonic-gate 			rfs4_sw_exit(&oo->oo_sw);
69947c478bd9Sstevel@tonic-gate 			rfs4_openowner_rele(oo);
69957c478bd9Sstevel@tonic-gate 			goto retry;
69967c478bd9Sstevel@tonic-gate 		}
69977c478bd9Sstevel@tonic-gate 	}
69987c478bd9Sstevel@tonic-gate 	/* Grace only applies to regular-type OPENs */
69997c478bd9Sstevel@tonic-gate 	if (rfs4_clnt_in_grace(cp) &&
70007c478bd9Sstevel@tonic-gate 	    (claim == CLAIM_NULL || claim == CLAIM_DELEGATE_CUR)) {
70017c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_GRACE;
70027c478bd9Sstevel@tonic-gate 		goto out;
70037c478bd9Sstevel@tonic-gate 	}
70047c478bd9Sstevel@tonic-gate 
70057c478bd9Sstevel@tonic-gate 	/*
70067c478bd9Sstevel@tonic-gate 	 * If previous state at the server existed then can_reclaim
70077c478bd9Sstevel@tonic-gate 	 * will be set. If not reply NFS4ERR_NO_GRACE to the
70087c478bd9Sstevel@tonic-gate 	 * client.
70097c478bd9Sstevel@tonic-gate 	 */
70107c478bd9Sstevel@tonic-gate 	if (rfs4_clnt_in_grace(cp) && claim == CLAIM_PREVIOUS && !can_reclaim) {
70117c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NO_GRACE;
70127c478bd9Sstevel@tonic-gate 		goto out;
70137c478bd9Sstevel@tonic-gate 	}
70147c478bd9Sstevel@tonic-gate 
70157c478bd9Sstevel@tonic-gate 
70167c478bd9Sstevel@tonic-gate 	/*
70177c478bd9Sstevel@tonic-gate 	 * Reject the open if the client has missed the grace period
70187c478bd9Sstevel@tonic-gate 	 */
70197c478bd9Sstevel@tonic-gate 	if (!rfs4_clnt_in_grace(cp) && claim == CLAIM_PREVIOUS) {
70207c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NO_GRACE;
70217c478bd9Sstevel@tonic-gate 		goto out;
70227c478bd9Sstevel@tonic-gate 	}
70237c478bd9Sstevel@tonic-gate 
70247c478bd9Sstevel@tonic-gate 	/* Couple of up-front bookkeeping items */
70257c478bd9Sstevel@tonic-gate 	if (oo->need_confirm) {
70267c478bd9Sstevel@tonic-gate 		/*
70277c478bd9Sstevel@tonic-gate 		 * If this is a reclaim OPEN then we should not ask
70287c478bd9Sstevel@tonic-gate 		 * for a confirmation of the open_owner per the
70297c478bd9Sstevel@tonic-gate 		 * protocol specification.
70307c478bd9Sstevel@tonic-gate 		 */
70317c478bd9Sstevel@tonic-gate 		if (claim == CLAIM_PREVIOUS)
70327c478bd9Sstevel@tonic-gate 			oo->need_confirm = FALSE;
70337c478bd9Sstevel@tonic-gate 		else
70347c478bd9Sstevel@tonic-gate 			resp->rflags |= OPEN4_RESULT_CONFIRM;
70357c478bd9Sstevel@tonic-gate 	}
70367c478bd9Sstevel@tonic-gate 	resp->rflags |= OPEN4_RESULT_LOCKTYPE_POSIX;
70377c478bd9Sstevel@tonic-gate 
70387c478bd9Sstevel@tonic-gate 	/*
70397c478bd9Sstevel@tonic-gate 	 * If there is an unshared filesystem mounted on this vnode,
70407c478bd9Sstevel@tonic-gate 	 * do not allow to open/create in this directory.
70417c478bd9Sstevel@tonic-gate 	 */
70427c478bd9Sstevel@tonic-gate 	if (vn_ismntpt(cs->vp)) {
70437c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
70447c478bd9Sstevel@tonic-gate 		goto out;
70457c478bd9Sstevel@tonic-gate 	}
70467c478bd9Sstevel@tonic-gate 
70477c478bd9Sstevel@tonic-gate 	/*
70487c478bd9Sstevel@tonic-gate 	 * access must READ, WRITE, or BOTH.  No access is invalid.
70497c478bd9Sstevel@tonic-gate 	 * deny can be READ, WRITE, BOTH, or NONE.
70507c478bd9Sstevel@tonic-gate 	 * bits not defined for access/deny are invalid.
70517c478bd9Sstevel@tonic-gate 	 */
70527c478bd9Sstevel@tonic-gate 	if (! (args->share_access & OPEN4_SHARE_ACCESS_BOTH) ||
70537c478bd9Sstevel@tonic-gate 	    (args->share_access & ~OPEN4_SHARE_ACCESS_BOTH) ||
70547c478bd9Sstevel@tonic-gate 	    (args->share_deny & ~OPEN4_SHARE_DENY_BOTH)) {
70557c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
70567c478bd9Sstevel@tonic-gate 		goto out;
70577c478bd9Sstevel@tonic-gate 	}
70587c478bd9Sstevel@tonic-gate 
70597c478bd9Sstevel@tonic-gate 
70607c478bd9Sstevel@tonic-gate 	/*
70617c478bd9Sstevel@tonic-gate 	 * make sure attrset is zero before response is built.
70627c478bd9Sstevel@tonic-gate 	 */
70637c478bd9Sstevel@tonic-gate 	resp->attrset = 0;
70647c478bd9Sstevel@tonic-gate 
70657c478bd9Sstevel@tonic-gate 	switch (claim) {
70667c478bd9Sstevel@tonic-gate 	case CLAIM_NULL:
70677c478bd9Sstevel@tonic-gate 		rfs4_do_opennull(cs, req, args, oo, resp);
70681b300de9Sjwahlig 		break;
70697c478bd9Sstevel@tonic-gate 	case CLAIM_PREVIOUS:
70707c478bd9Sstevel@tonic-gate 		rfs4_do_openprev(cs, req, args, oo, resp);
70711b300de9Sjwahlig 		break;
70727c478bd9Sstevel@tonic-gate 	case CLAIM_DELEGATE_CUR:
70737c478bd9Sstevel@tonic-gate 		rfs4_do_opendelcur(cs, req, args, oo, resp);
70741b300de9Sjwahlig 		break;
70757c478bd9Sstevel@tonic-gate 	case CLAIM_DELEGATE_PREV:
70767c478bd9Sstevel@tonic-gate 		rfs4_do_opendelprev(cs, req, args, oo, resp);
70771b300de9Sjwahlig 		break;
70787c478bd9Sstevel@tonic-gate 	default:
70797c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_INVAL;
70807c478bd9Sstevel@tonic-gate 		break;
70817c478bd9Sstevel@tonic-gate 	}
70827c478bd9Sstevel@tonic-gate 
70837c478bd9Sstevel@tonic-gate out:
70847c478bd9Sstevel@tonic-gate 	rfs4_client_rele(cp);
70857c478bd9Sstevel@tonic-gate 
70867c478bd9Sstevel@tonic-gate 	/* Catch sequence id handling here to make it a little easier */
70877c478bd9Sstevel@tonic-gate 	switch (resp->status) {
70887c478bd9Sstevel@tonic-gate 	case NFS4ERR_BADXDR:
70897c478bd9Sstevel@tonic-gate 	case NFS4ERR_BAD_SEQID:
70907c478bd9Sstevel@tonic-gate 	case NFS4ERR_BAD_STATEID:
70917c478bd9Sstevel@tonic-gate 	case NFS4ERR_NOFILEHANDLE:
70927c478bd9Sstevel@tonic-gate 	case NFS4ERR_RESOURCE:
70937c478bd9Sstevel@tonic-gate 	case NFS4ERR_STALE_CLIENTID:
70947c478bd9Sstevel@tonic-gate 	case NFS4ERR_STALE_STATEID:
70957c478bd9Sstevel@tonic-gate 		/*
70967c478bd9Sstevel@tonic-gate 		 * The protocol states that if any of these errors are
70977c478bd9Sstevel@tonic-gate 		 * being returned, the sequence id should not be
70987c478bd9Sstevel@tonic-gate 		 * incremented.  Any other return requires an
70997c478bd9Sstevel@tonic-gate 		 * increment.
71007c478bd9Sstevel@tonic-gate 		 */
71017c478bd9Sstevel@tonic-gate 		break;
71027c478bd9Sstevel@tonic-gate 	default:
71037c478bd9Sstevel@tonic-gate 		/* Always update the lease in this case */
71047c478bd9Sstevel@tonic-gate 		rfs4_update_lease(oo->client);
71057c478bd9Sstevel@tonic-gate 
71067c478bd9Sstevel@tonic-gate 		/* Regular response - copy the result */
71077c478bd9Sstevel@tonic-gate 		if (!replay)
71087c478bd9Sstevel@tonic-gate 			rfs4_update_open_resp(oo, resop, &cs->fh);
71097c478bd9Sstevel@tonic-gate 
71107c478bd9Sstevel@tonic-gate 		/*
71117c478bd9Sstevel@tonic-gate 		 * REPLAY case: Only if the previous response was OK
71127c478bd9Sstevel@tonic-gate 		 * do we copy the filehandle.  If not OK, no
71137c478bd9Sstevel@tonic-gate 		 * filehandle to copy.
71147c478bd9Sstevel@tonic-gate 		 */
71157c478bd9Sstevel@tonic-gate 		if (replay == TRUE &&
71167c478bd9Sstevel@tonic-gate 		    resp->status == NFS4_OK &&
71177c478bd9Sstevel@tonic-gate 		    oo->reply_fh.nfs_fh4_val) {
71187c478bd9Sstevel@tonic-gate 			/*
71197c478bd9Sstevel@tonic-gate 			 * If this is a replay, we must restore the
71207c478bd9Sstevel@tonic-gate 			 * current filehandle/vp to that of what was
71217c478bd9Sstevel@tonic-gate 			 * returned originally.  Try our best to do
71227c478bd9Sstevel@tonic-gate 			 * it.
71237c478bd9Sstevel@tonic-gate 			 */
71247c478bd9Sstevel@tonic-gate 			nfs_fh4_fmt_t *fh_fmtp =
71251b300de9Sjwahlig 			    (nfs_fh4_fmt_t *)oo->reply_fh.nfs_fh4_val;
71267c478bd9Sstevel@tonic-gate 
71277c478bd9Sstevel@tonic-gate 			cs->exi = checkexport4(&fh_fmtp->fh4_fsid,
71281b300de9Sjwahlig 			    (fid_t *)&fh_fmtp->fh4_xlen, NULL);
71297c478bd9Sstevel@tonic-gate 
71307c478bd9Sstevel@tonic-gate 			if (cs->exi == NULL) {
71317c478bd9Sstevel@tonic-gate 				resp->status = NFS4ERR_STALE;
71327c478bd9Sstevel@tonic-gate 				goto finish;
71337c478bd9Sstevel@tonic-gate 			}
71347c478bd9Sstevel@tonic-gate 
71357c478bd9Sstevel@tonic-gate 			VN_RELE(cs->vp);
71367c478bd9Sstevel@tonic-gate 
71377c478bd9Sstevel@tonic-gate 			cs->vp = nfs4_fhtovp(&oo->reply_fh, cs->exi,
71381b300de9Sjwahlig 			    &resp->status);
71397c478bd9Sstevel@tonic-gate 
71407c478bd9Sstevel@tonic-gate 			if (cs->vp == NULL)
71417c478bd9Sstevel@tonic-gate 				goto finish;
71427c478bd9Sstevel@tonic-gate 
71437c478bd9Sstevel@tonic-gate 			nfs_fh4_copy(&oo->reply_fh, &cs->fh);
71447c478bd9Sstevel@tonic-gate 		}
71457c478bd9Sstevel@tonic-gate 
71467c478bd9Sstevel@tonic-gate 		/*
71477c478bd9Sstevel@tonic-gate 		 * If this was a replay, no need to update the
71487c478bd9Sstevel@tonic-gate 		 * sequence id. If the open_owner was not created on
71497c478bd9Sstevel@tonic-gate 		 * this pass, then update.  The first use of an
71507c478bd9Sstevel@tonic-gate 		 * open_owner will not bump the sequence id.
71517c478bd9Sstevel@tonic-gate 		 */
71527c478bd9Sstevel@tonic-gate 		if (replay == FALSE && !create)
71537c478bd9Sstevel@tonic-gate 			rfs4_update_open_sequence(oo);
71547c478bd9Sstevel@tonic-gate 		/*
71557c478bd9Sstevel@tonic-gate 		 * If the client is receiving an error and the
71567c478bd9Sstevel@tonic-gate 		 * open_owner needs to be confirmed, there is no way
71577c478bd9Sstevel@tonic-gate 		 * to notify the client of this fact ignoring the fact
71587c478bd9Sstevel@tonic-gate 		 * that the server has no method of returning a
71597c478bd9Sstevel@tonic-gate 		 * stateid to confirm.  Therefore, the server needs to
71607c478bd9Sstevel@tonic-gate 		 * mark this open_owner in a way as to avoid the
71617c478bd9Sstevel@tonic-gate 		 * sequence id checking the next time the client uses
71627c478bd9Sstevel@tonic-gate 		 * this open_owner.
71637c478bd9Sstevel@tonic-gate 		 */
71647c478bd9Sstevel@tonic-gate 		if (resp->status != NFS4_OK && oo->need_confirm)
71657c478bd9Sstevel@tonic-gate 			oo->postpone_confirm = TRUE;
71667c478bd9Sstevel@tonic-gate 		/*
71677c478bd9Sstevel@tonic-gate 		 * If OK response then clear the postpone flag and
71687c478bd9Sstevel@tonic-gate 		 * reset the sequence id to keep in sync with the
71697c478bd9Sstevel@tonic-gate 		 * client.
71707c478bd9Sstevel@tonic-gate 		 */
71717c478bd9Sstevel@tonic-gate 		if (resp->status == NFS4_OK && oo->postpone_confirm) {
71727c478bd9Sstevel@tonic-gate 			oo->postpone_confirm = FALSE;
71737c478bd9Sstevel@tonic-gate 			oo->open_seqid = args->seqid;
71747c478bd9Sstevel@tonic-gate 		}
71757c478bd9Sstevel@tonic-gate 		break;
71767c478bd9Sstevel@tonic-gate 	}
71777c478bd9Sstevel@tonic-gate 
71787c478bd9Sstevel@tonic-gate finish:
71797c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status;
71807c478bd9Sstevel@tonic-gate 
71817c478bd9Sstevel@tonic-gate 	rfs4_sw_exit(&oo->oo_sw);
71827c478bd9Sstevel@tonic-gate 	rfs4_openowner_rele(oo);
7183*f3b585ceSsamf 
7184*f3b585ceSsamf end:
7185*f3b585ceSsamf 	DTRACE_NFSV4_2(op__open__done, struct compound_state *, cs,
7186*f3b585ceSsamf 	    OPEN4res *, resp);
71877c478bd9Sstevel@tonic-gate }
71887c478bd9Sstevel@tonic-gate 
71897c478bd9Sstevel@tonic-gate /*ARGSUSED*/
71907c478bd9Sstevel@tonic-gate void
71917c478bd9Sstevel@tonic-gate rfs4_op_open_confirm(nfs_argop4 *argop, nfs_resop4 *resop,
71927c478bd9Sstevel@tonic-gate 		    struct svc_req *req, struct compound_state *cs)
71937c478bd9Sstevel@tonic-gate {
71947c478bd9Sstevel@tonic-gate 	OPEN_CONFIRM4args *args = &argop->nfs_argop4_u.opopen_confirm;
71957c478bd9Sstevel@tonic-gate 	OPEN_CONFIRM4res *resp = &resop->nfs_resop4_u.opopen_confirm;
71967c478bd9Sstevel@tonic-gate 	rfs4_state_t *sp;
71977c478bd9Sstevel@tonic-gate 	nfsstat4 status;
71987c478bd9Sstevel@tonic-gate 
7199*f3b585ceSsamf 	DTRACE_NFSV4_2(op__open__confirm__start, struct compound_state *, cs,
7200*f3b585ceSsamf 	    OPEN_CONFIRM4args *, args);
7201*f3b585ceSsamf 
72027c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
72037c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
7204*f3b585ceSsamf 		goto out;
72057c478bd9Sstevel@tonic-gate 	}
72067c478bd9Sstevel@tonic-gate 
72077c478bd9Sstevel@tonic-gate 	status = rfs4_get_state(&args->open_stateid, &sp, RFS4_DBS_VALID);
72087c478bd9Sstevel@tonic-gate 	if (status != NFS4_OK) {
72097c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = status;
7210*f3b585ceSsamf 		goto out;
72117c478bd9Sstevel@tonic-gate 	}
72127c478bd9Sstevel@tonic-gate 
72137c478bd9Sstevel@tonic-gate 	/* Ensure specified filehandle matches */
72147c478bd9Sstevel@tonic-gate 	if (cs->vp != sp->finfo->vp) {
72157c478bd9Sstevel@tonic-gate 		rfs4_state_rele(sp);
72167c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
7217*f3b585ceSsamf 		goto out;
72187c478bd9Sstevel@tonic-gate 	}
72197c478bd9Sstevel@tonic-gate 
72207c478bd9Sstevel@tonic-gate 	/* hold off other access to open_owner while we tinker */
72217c478bd9Sstevel@tonic-gate 	rfs4_sw_enter(&sp->owner->oo_sw);
72227c478bd9Sstevel@tonic-gate 
72237c478bd9Sstevel@tonic-gate 	switch (rfs4_check_stateid_seqid(sp, &args->open_stateid)) {
72247c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_OKAY:
72257c478bd9Sstevel@tonic-gate 		if (rfs4_check_open_seqid(args->seqid, sp->owner,
72261b300de9Sjwahlig 		    resop) != 0) {
72277c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
72287c478bd9Sstevel@tonic-gate 			break;
72297c478bd9Sstevel@tonic-gate 		}
72307c478bd9Sstevel@tonic-gate 		/*
72317c478bd9Sstevel@tonic-gate 		 * If it is the appropriate stateid and determined to
72327c478bd9Sstevel@tonic-gate 		 * be "OKAY" then this means that the stateid does not
72337c478bd9Sstevel@tonic-gate 		 * need to be confirmed and the client is in error for
72347c478bd9Sstevel@tonic-gate 		 * sending an OPEN_CONFIRM.
72357c478bd9Sstevel@tonic-gate 		 */
72367c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
72377c478bd9Sstevel@tonic-gate 		break;
72387c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_OLD:
72397c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
72407c478bd9Sstevel@tonic-gate 		break;
72417c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_BAD:
72427c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
72437c478bd9Sstevel@tonic-gate 		break;
72447c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_EXPIRED:
72457c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
72467c478bd9Sstevel@tonic-gate 		break;
72477c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_CLOSED:
72487c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
72497c478bd9Sstevel@tonic-gate 		break;
72507c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_REPLAY:
72517c478bd9Sstevel@tonic-gate 		switch (rfs4_check_open_seqid(args->seqid, sp->owner, resop)) {
72527c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_OKAY:
72537c478bd9Sstevel@tonic-gate 			/*
72547c478bd9Sstevel@tonic-gate 			 * This is replayed stateid; if seqid matches
72557c478bd9Sstevel@tonic-gate 			 * next expected, then client is using wrong seqid.
72567c478bd9Sstevel@tonic-gate 			 */
72577c478bd9Sstevel@tonic-gate 			/* fall through */
72587c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_BAD:
72597c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
72607c478bd9Sstevel@tonic-gate 			break;
72617c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_REPLAY:
72627c478bd9Sstevel@tonic-gate 			/*
72637c478bd9Sstevel@tonic-gate 			 * Note this case is the duplicate case so
72647c478bd9Sstevel@tonic-gate 			 * resp->status is already set.
72657c478bd9Sstevel@tonic-gate 			 */
72667c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status;
72677c478bd9Sstevel@tonic-gate 			rfs4_update_lease(sp->owner->client);
72687c478bd9Sstevel@tonic-gate 			break;
72697c478bd9Sstevel@tonic-gate 		}
72707c478bd9Sstevel@tonic-gate 		break;
72717c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_UNCONFIRMED:
72727c478bd9Sstevel@tonic-gate 		if (rfs4_check_open_seqid(args->seqid, sp->owner,
72731b300de9Sjwahlig 		    resop) != NFS4_CHKSEQ_OKAY) {
72747c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
72757c478bd9Sstevel@tonic-gate 			break;
72767c478bd9Sstevel@tonic-gate 		}
72777c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4_OK;
72787c478bd9Sstevel@tonic-gate 
72797c478bd9Sstevel@tonic-gate 		next_stateid(&sp->stateid);
72807c478bd9Sstevel@tonic-gate 		resp->open_stateid = sp->stateid.stateid;
72817c478bd9Sstevel@tonic-gate 		sp->owner->need_confirm = FALSE;
72827c478bd9Sstevel@tonic-gate 		rfs4_update_lease(sp->owner->client);
72837c478bd9Sstevel@tonic-gate 		rfs4_update_open_sequence(sp->owner);
72847c478bd9Sstevel@tonic-gate 		rfs4_update_open_resp(sp->owner, resop, NULL);
72857c478bd9Sstevel@tonic-gate 		break;
72867c478bd9Sstevel@tonic-gate 	default:
72877c478bd9Sstevel@tonic-gate 		ASSERT(FALSE);
72887c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_SERVERFAULT;
72897c478bd9Sstevel@tonic-gate 		break;
72907c478bd9Sstevel@tonic-gate 	}
72917c478bd9Sstevel@tonic-gate 	rfs4_sw_exit(&sp->owner->oo_sw);
72927c478bd9Sstevel@tonic-gate 	rfs4_state_rele(sp);
7293*f3b585ceSsamf 
7294*f3b585ceSsamf out:
7295*f3b585ceSsamf 	DTRACE_NFSV4_2(op__open__confirm__done, struct compound_state *, cs,
7296*f3b585ceSsamf 	    OPEN_CONFIRM4res *, resp);
72977c478bd9Sstevel@tonic-gate }
72987c478bd9Sstevel@tonic-gate 
72997c478bd9Sstevel@tonic-gate /*ARGSUSED*/
73007c478bd9Sstevel@tonic-gate void
73017c478bd9Sstevel@tonic-gate rfs4_op_open_downgrade(nfs_argop4 *argop, nfs_resop4 *resop,
73027c478bd9Sstevel@tonic-gate 		    struct svc_req *req, struct compound_state *cs)
73037c478bd9Sstevel@tonic-gate {
73047c478bd9Sstevel@tonic-gate 	OPEN_DOWNGRADE4args *args = &argop->nfs_argop4_u.opopen_downgrade;
73057c478bd9Sstevel@tonic-gate 	OPEN_DOWNGRADE4res *resp = &resop->nfs_resop4_u.opopen_downgrade;
73067c478bd9Sstevel@tonic-gate 	uint32_t access = args->share_access;
73077c478bd9Sstevel@tonic-gate 	uint32_t deny = args->share_deny;
73087c478bd9Sstevel@tonic-gate 	nfsstat4 status;
73097c478bd9Sstevel@tonic-gate 	rfs4_state_t *sp;
73107c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp;
7311da6c28aaSamw 	int fflags = 0;
73127c478bd9Sstevel@tonic-gate 
7313*f3b585ceSsamf 	DTRACE_NFSV4_2(op__open__downgrade__start, struct compound_state *, cs,
7314*f3b585ceSsamf 	    OPEN_DOWNGRADE4args *, args);
7315*f3b585ceSsamf 
73167c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
73177c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
7318*f3b585ceSsamf 		goto out;
73197c478bd9Sstevel@tonic-gate 	}
73207c478bd9Sstevel@tonic-gate 
73217c478bd9Sstevel@tonic-gate 	status = rfs4_get_state(&args->open_stateid, &sp, RFS4_DBS_VALID);
73227c478bd9Sstevel@tonic-gate 	if (status != NFS4_OK) {
73237c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = status;
7324*f3b585ceSsamf 		goto out;
73257c478bd9Sstevel@tonic-gate 	}
73267c478bd9Sstevel@tonic-gate 
73277c478bd9Sstevel@tonic-gate 	/* Ensure specified filehandle matches */
73287c478bd9Sstevel@tonic-gate 	if (cs->vp != sp->finfo->vp) {
73297c478bd9Sstevel@tonic-gate 		rfs4_state_rele(sp);
73307c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
7331*f3b585ceSsamf 		goto out;
73327c478bd9Sstevel@tonic-gate 	}
73337c478bd9Sstevel@tonic-gate 
73347c478bd9Sstevel@tonic-gate 	/* hold off other access to open_owner while we tinker */
73357c478bd9Sstevel@tonic-gate 	rfs4_sw_enter(&sp->owner->oo_sw);
73367c478bd9Sstevel@tonic-gate 
73377c478bd9Sstevel@tonic-gate 	switch (rfs4_check_stateid_seqid(sp, &args->open_stateid)) {
73387c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_OKAY:
73397c478bd9Sstevel@tonic-gate 		if (rfs4_check_open_seqid(args->seqid, sp->owner,
73401b300de9Sjwahlig 		    resop) != NFS4_CHKSEQ_OKAY) {
73417c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
73427c478bd9Sstevel@tonic-gate 			goto end;
73437c478bd9Sstevel@tonic-gate 		}
73447c478bd9Sstevel@tonic-gate 		break;
73457c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_OLD:
73467c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
73477c478bd9Sstevel@tonic-gate 		goto end;
73487c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_BAD:
73497c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
73507c478bd9Sstevel@tonic-gate 		goto end;
73517c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_EXPIRED:
73527c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
73537c478bd9Sstevel@tonic-gate 		goto end;
73547c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_CLOSED:
73557c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
73567c478bd9Sstevel@tonic-gate 		goto end;
73577c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_UNCONFIRMED:
73587c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
73597c478bd9Sstevel@tonic-gate 		goto end;
73607c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_REPLAY:
73617c478bd9Sstevel@tonic-gate 		/* Check the sequence id for the open owner */
73627c478bd9Sstevel@tonic-gate 		switch (rfs4_check_open_seqid(args->seqid, sp->owner, resop)) {
73637c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_OKAY:
73647c478bd9Sstevel@tonic-gate 			/*
73657c478bd9Sstevel@tonic-gate 			 * This is replayed stateid; if seqid matches
73667c478bd9Sstevel@tonic-gate 			 * next expected, then client is using wrong seqid.
73677c478bd9Sstevel@tonic-gate 			 */
73687c478bd9Sstevel@tonic-gate 			/* fall through */
73697c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_BAD:
73707c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
73717c478bd9Sstevel@tonic-gate 			goto end;
73727c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_REPLAY:
73737c478bd9Sstevel@tonic-gate 			/*
73747c478bd9Sstevel@tonic-gate 			 * Note this case is the duplicate case so
73757c478bd9Sstevel@tonic-gate 			 * resp->status is already set.
73767c478bd9Sstevel@tonic-gate 			 */
73777c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status;
73787c478bd9Sstevel@tonic-gate 			rfs4_update_lease(sp->owner->client);
73797c478bd9Sstevel@tonic-gate 			goto end;
73807c478bd9Sstevel@tonic-gate 		}
73817c478bd9Sstevel@tonic-gate 		break;
73827c478bd9Sstevel@tonic-gate 	default:
73837c478bd9Sstevel@tonic-gate 		ASSERT(FALSE);
73847c478bd9Sstevel@tonic-gate 		break;
73857c478bd9Sstevel@tonic-gate 	}
73867c478bd9Sstevel@tonic-gate 
73877c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(sp->dbe);
73887c478bd9Sstevel@tonic-gate 	/*
73897c478bd9Sstevel@tonic-gate 	 * Check that the new access modes and deny modes are valid.
73907c478bd9Sstevel@tonic-gate 	 * Check that no invalid bits are set.
73917c478bd9Sstevel@tonic-gate 	 */
73927c478bd9Sstevel@tonic-gate 	if ((access & ~(OPEN4_SHARE_ACCESS_READ | OPEN4_SHARE_ACCESS_WRITE)) ||
7393da6c28aaSamw 	    (deny & ~(OPEN4_SHARE_DENY_READ | OPEN4_SHARE_DENY_WRITE))) {
73947c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
73957c478bd9Sstevel@tonic-gate 		rfs4_update_open_sequence(sp->owner);
73967c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(sp->dbe);
73977c478bd9Sstevel@tonic-gate 		goto end;
73987c478bd9Sstevel@tonic-gate 	}
73997c478bd9Sstevel@tonic-gate 
74007c478bd9Sstevel@tonic-gate 	/*
74017c478bd9Sstevel@tonic-gate 	 * The new modes must be a subset of the current modes and
74027c478bd9Sstevel@tonic-gate 	 * the access must specify at least one mode. To test that
74037c478bd9Sstevel@tonic-gate 	 * the new mode is a subset of the current modes we bitwise
74047c478bd9Sstevel@tonic-gate 	 * AND them together and check that the result equals the new
74057c478bd9Sstevel@tonic-gate 	 * mode. For example:
74067c478bd9Sstevel@tonic-gate 	 * New mode, access == R and current mode, sp->share_access  == RW
74077c478bd9Sstevel@tonic-gate 	 * access & sp->share_access == R == access, so the new access mode
74087c478bd9Sstevel@tonic-gate 	 * is valid. Consider access == RW, sp->share_access = R
74097c478bd9Sstevel@tonic-gate 	 * access & sp->share_access == R != access, so the new access mode
74107c478bd9Sstevel@tonic-gate 	 * is invalid.
74117c478bd9Sstevel@tonic-gate 	 */
74127c478bd9Sstevel@tonic-gate 	if ((access & sp->share_access) != access ||
74137c478bd9Sstevel@tonic-gate 	    (deny & sp->share_deny) != deny ||
74147c478bd9Sstevel@tonic-gate 	    (access &
74157c478bd9Sstevel@tonic-gate 	    (OPEN4_SHARE_ACCESS_READ | OPEN4_SHARE_ACCESS_WRITE)) == 0) {
74167c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
74177c478bd9Sstevel@tonic-gate 		rfs4_update_open_sequence(sp->owner);
74187c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(sp->dbe);
74197c478bd9Sstevel@tonic-gate 		goto end;
74207c478bd9Sstevel@tonic-gate 	}
74217c478bd9Sstevel@tonic-gate 
74227c478bd9Sstevel@tonic-gate 	/*
74237c478bd9Sstevel@tonic-gate 	 * Release any share locks associated with this stateID.
74247c478bd9Sstevel@tonic-gate 	 * Strictly speaking, this violates the spec because the
74257c478bd9Sstevel@tonic-gate 	 * spec effectively requires that open downgrade be atomic.
74267c478bd9Sstevel@tonic-gate 	 * At present, fs_shrlock does not have this capability.
74277c478bd9Sstevel@tonic-gate 	 */
74287c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(sp->dbe);
74297c478bd9Sstevel@tonic-gate 	rfs4_unshare(sp);
74307c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(sp->dbe);
74317c478bd9Sstevel@tonic-gate 
74327c478bd9Sstevel@tonic-gate 	fp = sp->finfo;
74337c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(fp->dbe);
74347c478bd9Sstevel@tonic-gate 
74357c478bd9Sstevel@tonic-gate 	/*
74367c478bd9Sstevel@tonic-gate 	 * If the current mode has deny read and the new mode
74377c478bd9Sstevel@tonic-gate 	 * does not, decrement the number of deny read mode bits
74387c478bd9Sstevel@tonic-gate 	 * and if it goes to zero turn off the deny read bit
74397c478bd9Sstevel@tonic-gate 	 * on the file.
74407c478bd9Sstevel@tonic-gate 	 */
74417c478bd9Sstevel@tonic-gate 	if ((sp->share_deny & OPEN4_SHARE_DENY_READ) &&
74427c478bd9Sstevel@tonic-gate 	    (deny & OPEN4_SHARE_DENY_READ) == 0) {
74437c478bd9Sstevel@tonic-gate 		fp->deny_read--;
74447c478bd9Sstevel@tonic-gate 		if (fp->deny_read == 0)
74457c478bd9Sstevel@tonic-gate 			fp->share_deny &= ~OPEN4_SHARE_DENY_READ;
74467c478bd9Sstevel@tonic-gate 	}
74477c478bd9Sstevel@tonic-gate 
74487c478bd9Sstevel@tonic-gate 	/*
74497c478bd9Sstevel@tonic-gate 	 * If the current mode has deny write and the new mode
74507c478bd9Sstevel@tonic-gate 	 * does not, decrement the number of deny write mode bits
74517c478bd9Sstevel@tonic-gate 	 * and if it goes to zero turn off the deny write bit
74527c478bd9Sstevel@tonic-gate 	 * on the file.
74537c478bd9Sstevel@tonic-gate 	 */
74547c478bd9Sstevel@tonic-gate 	if ((sp->share_deny & OPEN4_SHARE_DENY_WRITE) &&
74557c478bd9Sstevel@tonic-gate 	    (deny & OPEN4_SHARE_DENY_WRITE) == 0) {
74567c478bd9Sstevel@tonic-gate 		fp->deny_write--;
74577c478bd9Sstevel@tonic-gate 		if (fp->deny_write == 0)
74587c478bd9Sstevel@tonic-gate 			fp->share_deny &= ~OPEN4_SHARE_DENY_WRITE;
74597c478bd9Sstevel@tonic-gate 	}
74607c478bd9Sstevel@tonic-gate 
74617c478bd9Sstevel@tonic-gate 	/*
74627c478bd9Sstevel@tonic-gate 	 * If the current mode has access read and the new mode
74637c478bd9Sstevel@tonic-gate 	 * does not, decrement the number of access read mode bits
74647c478bd9Sstevel@tonic-gate 	 * and if it goes to zero turn off the access read bit
7465da6c28aaSamw 	 * on the file.  set fflags to FREAD for the call to
7466da6c28aaSamw 	 * vn_open_downgrade().
74677c478bd9Sstevel@tonic-gate 	 */
74687c478bd9Sstevel@tonic-gate 	if ((sp->share_access & OPEN4_SHARE_ACCESS_READ) &&
74697c478bd9Sstevel@tonic-gate 	    (access & OPEN4_SHARE_ACCESS_READ) == 0) {
74707c478bd9Sstevel@tonic-gate 		fp->access_read--;
74717c478bd9Sstevel@tonic-gate 		if (fp->access_read == 0)
74727c478bd9Sstevel@tonic-gate 			fp->share_access &= ~OPEN4_SHARE_ACCESS_READ;
7473da6c28aaSamw 		fflags |= FREAD;
74747c478bd9Sstevel@tonic-gate 	}
74757c478bd9Sstevel@tonic-gate 
74767c478bd9Sstevel@tonic-gate 	/*
74777c478bd9Sstevel@tonic-gate 	 * If the current mode has access write and the new mode
74787c478bd9Sstevel@tonic-gate 	 * does not, decrement the number of access write mode bits
74797c478bd9Sstevel@tonic-gate 	 * and if it goes to zero turn off the access write bit
7480da6c28aaSamw 	 * on the file.  set fflags to FWRITE for the call to
7481da6c28aaSamw 	 * vn_open_downgrade().
74827c478bd9Sstevel@tonic-gate 	 */
74837c478bd9Sstevel@tonic-gate 	if ((sp->share_access & OPEN4_SHARE_ACCESS_WRITE) &&
74847c478bd9Sstevel@tonic-gate 	    (access & OPEN4_SHARE_ACCESS_WRITE) == 0) {
74857c478bd9Sstevel@tonic-gate 		fp->access_write--;
74867c478bd9Sstevel@tonic-gate 		if (fp->access_write == 0)
74877c478bd9Sstevel@tonic-gate 			fp->share_deny &= ~OPEN4_SHARE_ACCESS_WRITE;
7488da6c28aaSamw 		fflags |= FWRITE;
74897c478bd9Sstevel@tonic-gate 	}
74907c478bd9Sstevel@tonic-gate 
74917c478bd9Sstevel@tonic-gate 	/* Set the new access and deny modes */
74927c478bd9Sstevel@tonic-gate 	sp->share_access = access;
74937c478bd9Sstevel@tonic-gate 	sp->share_deny = deny;
74947c478bd9Sstevel@tonic-gate 	/* Check that the file is still accessible */
74957c478bd9Sstevel@tonic-gate 	ASSERT(fp->share_access);
74967c478bd9Sstevel@tonic-gate 
74977c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(fp->dbe);
74987c478bd9Sstevel@tonic-gate 
74997c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(sp->dbe);
7500da6c28aaSamw 
75017c478bd9Sstevel@tonic-gate 	if ((status = rfs4_share(sp)) != NFS4_OK) {
75027c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_SERVERFAULT;
75037c478bd9Sstevel@tonic-gate 		rfs4_update_open_sequence(sp->owner);
75047c478bd9Sstevel@tonic-gate 		goto end;
75057c478bd9Sstevel@tonic-gate 	}
75067c478bd9Sstevel@tonic-gate 
7507da6c28aaSamw 	/*
7508da6c28aaSamw 	 * we successfully downgraded the share lock, now we need to downgrade
7509da6c28aaSamw 	 * the open.  it is possible that the downgrade was only for a deny
7510da6c28aaSamw 	 * mode and we have nothing else to do.
7511da6c28aaSamw 	 */
7512da6c28aaSamw 	if ((fflags & (FREAD|FWRITE)) != 0)
7513da6c28aaSamw 		vn_open_downgrade(cs->vp, fflags);
7514da6c28aaSamw 
75157c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(sp->dbe);
75167c478bd9Sstevel@tonic-gate 
75177c478bd9Sstevel@tonic-gate 	/* Update the stateid */
75187c478bd9Sstevel@tonic-gate 	next_stateid(&sp->stateid);
75197c478bd9Sstevel@tonic-gate 	resp->open_stateid = sp->stateid.stateid;
75207c478bd9Sstevel@tonic-gate 
75217c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(sp->dbe);
75227c478bd9Sstevel@tonic-gate 
75237c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = NFS4_OK;
75247c478bd9Sstevel@tonic-gate 	/* Update the lease */
75257c478bd9Sstevel@tonic-gate 	rfs4_update_lease(sp->owner->client);
75267c478bd9Sstevel@tonic-gate 	/* And the sequence */
75277c478bd9Sstevel@tonic-gate 	rfs4_update_open_sequence(sp->owner);
75287c478bd9Sstevel@tonic-gate 	rfs4_update_open_resp(sp->owner, resop, NULL);
75297c478bd9Sstevel@tonic-gate 
75307c478bd9Sstevel@tonic-gate end:
75317c478bd9Sstevel@tonic-gate 	rfs4_sw_exit(&sp->owner->oo_sw);
75327c478bd9Sstevel@tonic-gate 	rfs4_state_rele(sp);
7533*f3b585ceSsamf out:
7534*f3b585ceSsamf 	DTRACE_NFSV4_2(op__open__downgrade__done, struct compound_state *, cs,
7535*f3b585ceSsamf 	    OPEN_DOWNGRADE4res *, resp);
75367c478bd9Sstevel@tonic-gate }
75377c478bd9Sstevel@tonic-gate 
75387c478bd9Sstevel@tonic-gate /*
75397c478bd9Sstevel@tonic-gate  * The logic behind this function is detailed in the NFSv4 RFC in the
75407c478bd9Sstevel@tonic-gate  * SETCLIENTID operation description under IMPLEMENTATION.  Refer to
75417c478bd9Sstevel@tonic-gate  * that section for explicit guidance to server behavior for
75427c478bd9Sstevel@tonic-gate  * SETCLIENTID.
75437c478bd9Sstevel@tonic-gate  */
75447c478bd9Sstevel@tonic-gate void
75457c478bd9Sstevel@tonic-gate rfs4_op_setclientid(nfs_argop4 *argop, nfs_resop4 *resop,
75467c478bd9Sstevel@tonic-gate 		    struct svc_req *req, struct compound_state *cs)
75477c478bd9Sstevel@tonic-gate {
75487c478bd9Sstevel@tonic-gate 	SETCLIENTID4args *args = &argop->nfs_argop4_u.opsetclientid;
75497c478bd9Sstevel@tonic-gate 	SETCLIENTID4res *res = &resop->nfs_resop4_u.opsetclientid;
75507c478bd9Sstevel@tonic-gate 	rfs4_client_t *cp, *newcp, *cp_confirmed, *cp_unconfirmed;
75517c478bd9Sstevel@tonic-gate 	bool_t create = TRUE;
75527c478bd9Sstevel@tonic-gate 	char *addr, *netid;
75537c478bd9Sstevel@tonic-gate 	int len;
75547c478bd9Sstevel@tonic-gate 
7555*f3b585ceSsamf 	DTRACE_NFSV4_2(op__setclientid__start, struct compound_state *, cs,
7556*f3b585ceSsamf 	    SETCLIENTID4args *, args);
75577c478bd9Sstevel@tonic-gate retry:
75587c478bd9Sstevel@tonic-gate 	newcp = cp_confirmed = cp_unconfirmed = NULL;
75597c478bd9Sstevel@tonic-gate 
75607c478bd9Sstevel@tonic-gate 	/*
75617c478bd9Sstevel@tonic-gate 	 * In search of an EXISTING client matching the incoming
75627c478bd9Sstevel@tonic-gate 	 * request to establish a new client identifier at the server
75637c478bd9Sstevel@tonic-gate 	 */
75647c478bd9Sstevel@tonic-gate 	create = TRUE;
75657c478bd9Sstevel@tonic-gate 	cp = rfs4_findclient(&args->client, &create, NULL);
75667c478bd9Sstevel@tonic-gate 
75677c478bd9Sstevel@tonic-gate 	/* Should never happen */
75687c478bd9Sstevel@tonic-gate 	ASSERT(cp != NULL);
75697c478bd9Sstevel@tonic-gate 
75707c478bd9Sstevel@tonic-gate 	if (cp == NULL) {
75717c478bd9Sstevel@tonic-gate 		*cs->statusp = res->status = NFS4ERR_SERVERFAULT;
7572*f3b585ceSsamf 		goto out;
75737c478bd9Sstevel@tonic-gate 	}
75747c478bd9Sstevel@tonic-gate 
75757c478bd9Sstevel@tonic-gate 	/*
75767c478bd9Sstevel@tonic-gate 	 * Easiest case. Client identifier is newly created and is
75777c478bd9Sstevel@tonic-gate 	 * unconfirmed.  Also note that for this case, no other
75787c478bd9Sstevel@tonic-gate 	 * entries exist for the client identifier.  Nothing else to
75797c478bd9Sstevel@tonic-gate 	 * check.  Just setup the response and respond.
75807c478bd9Sstevel@tonic-gate 	 */
75817c478bd9Sstevel@tonic-gate 	if (create) {
75827c478bd9Sstevel@tonic-gate 		*cs->statusp = res->status = NFS4_OK;
75837c478bd9Sstevel@tonic-gate 		res->SETCLIENTID4res_u.resok4.clientid = cp->clientid;
75847c478bd9Sstevel@tonic-gate 		res->SETCLIENTID4res_u.resok4.setclientid_confirm =
75851b300de9Sjwahlig 		    cp->confirm_verf;
75867c478bd9Sstevel@tonic-gate 		/* Setup callback information; CB_NULL confirmation later */
75877c478bd9Sstevel@tonic-gate 		rfs4_client_setcb(cp, &args->callback, args->callback_ident);
75887c478bd9Sstevel@tonic-gate 
75897c478bd9Sstevel@tonic-gate 		rfs4_client_rele(cp);
7590*f3b585ceSsamf 		goto out;
75917c478bd9Sstevel@tonic-gate 	}
75927c478bd9Sstevel@tonic-gate 
75937c478bd9Sstevel@tonic-gate 	/*
75947c478bd9Sstevel@tonic-gate 	 * An existing, confirmed client may exist but it may not have
75957c478bd9Sstevel@tonic-gate 	 * been active for at least one lease period.  If so, then
75967c478bd9Sstevel@tonic-gate 	 * "close" the client and create a new client identifier
75977c478bd9Sstevel@tonic-gate 	 */
75987c478bd9Sstevel@tonic-gate 	if (rfs4_lease_expired(cp)) {
75997c478bd9Sstevel@tonic-gate 		rfs4_client_close(cp);
76007c478bd9Sstevel@tonic-gate 		goto retry;
76017c478bd9Sstevel@tonic-gate 	}
76027c478bd9Sstevel@tonic-gate 
76037c478bd9Sstevel@tonic-gate 	if (cp->need_confirm == TRUE)
76047c478bd9Sstevel@tonic-gate 		cp_unconfirmed = cp;
76057c478bd9Sstevel@tonic-gate 	else
76067c478bd9Sstevel@tonic-gate 		cp_confirmed = cp;
76077c478bd9Sstevel@tonic-gate 
76087c478bd9Sstevel@tonic-gate 	cp = NULL;
76097c478bd9Sstevel@tonic-gate 
76107c478bd9Sstevel@tonic-gate 	/*
76117c478bd9Sstevel@tonic-gate 	 * We have a confirmed client, now check for an
76127c478bd9Sstevel@tonic-gate 	 * unconfimred entry
76137c478bd9Sstevel@tonic-gate 	 */
76147c478bd9Sstevel@tonic-gate 	if (cp_confirmed) {
76157c478bd9Sstevel@tonic-gate 		/* If creds don't match then client identifier is inuse */
76167c478bd9Sstevel@tonic-gate 		if (!creds_ok(cp_confirmed->cr_set, req, cs)) {
76177c478bd9Sstevel@tonic-gate 			rfs4_cbinfo_t *cbp;
76187c478bd9Sstevel@tonic-gate 			/*
76197c478bd9Sstevel@tonic-gate 			 * Some one else has established this client
76207c478bd9Sstevel@tonic-gate 			 * id. Try and say * who they are. We will use
76217c478bd9Sstevel@tonic-gate 			 * the call back address supplied by * the
76227c478bd9Sstevel@tonic-gate 			 * first client.
76237c478bd9Sstevel@tonic-gate 			 */
76247c478bd9Sstevel@tonic-gate 			*cs->statusp = res->status = NFS4ERR_CLID_INUSE;
76257c478bd9Sstevel@tonic-gate 
76267c478bd9Sstevel@tonic-gate 			addr = netid = NULL;
76277c478bd9Sstevel@tonic-gate 
76287c478bd9Sstevel@tonic-gate 			cbp = &cp_confirmed->cbinfo;
76297c478bd9Sstevel@tonic-gate 			if (cbp->cb_callback.cb_location.r_addr &&
76307c478bd9Sstevel@tonic-gate 			    cbp->cb_callback.cb_location.r_netid) {
76317c478bd9Sstevel@tonic-gate 				cb_client4 *cbcp = &cbp->cb_callback;
76327c478bd9Sstevel@tonic-gate 
76337c478bd9Sstevel@tonic-gate 				len = strlen(cbcp->cb_location.r_addr)+1;
76347c478bd9Sstevel@tonic-gate 				addr = kmem_alloc(len, KM_SLEEP);
76357c478bd9Sstevel@tonic-gate 				bcopy(cbcp->cb_location.r_addr, addr, len);
76367c478bd9Sstevel@tonic-gate 				len = strlen(cbcp->cb_location.r_netid)+1;
76377c478bd9Sstevel@tonic-gate 				netid = kmem_alloc(len, KM_SLEEP);
76387c478bd9Sstevel@tonic-gate 				bcopy(cbcp->cb_location.r_netid, netid, len);
76397c478bd9Sstevel@tonic-gate 			}
76407c478bd9Sstevel@tonic-gate 
76417c478bd9Sstevel@tonic-gate 			res->SETCLIENTID4res_u.client_using.r_addr = addr;
76427c478bd9Sstevel@tonic-gate 			res->SETCLIENTID4res_u.client_using.r_netid = netid;
76437c478bd9Sstevel@tonic-gate 
76447c478bd9Sstevel@tonic-gate 			rfs4_client_rele(cp_confirmed);
76457c478bd9Sstevel@tonic-gate 		}
76467c478bd9Sstevel@tonic-gate 
76477c478bd9Sstevel@tonic-gate 		/*
76487c478bd9Sstevel@tonic-gate 		 * Confirmed, creds match, and verifier matches; must
76497c478bd9Sstevel@tonic-gate 		 * be an update of the callback info
76507c478bd9Sstevel@tonic-gate 		 */
76517c478bd9Sstevel@tonic-gate 		if (cp_confirmed->nfs_client.verifier ==
76521b300de9Sjwahlig 		    args->client.verifier) {
76537c478bd9Sstevel@tonic-gate 			/* Setup callback information */
76547c478bd9Sstevel@tonic-gate 			rfs4_client_setcb(cp_confirmed, &args->callback,
76551b300de9Sjwahlig 			    args->callback_ident);
76567c478bd9Sstevel@tonic-gate 
76577c478bd9Sstevel@tonic-gate 			/* everything okay -- move ahead */
76587c478bd9Sstevel@tonic-gate 			*cs->statusp = res->status = NFS4_OK;
76597c478bd9Sstevel@tonic-gate 			res->SETCLIENTID4res_u.resok4.clientid =
76601b300de9Sjwahlig 			    cp_confirmed->clientid;
76617c478bd9Sstevel@tonic-gate 
76627c478bd9Sstevel@tonic-gate 			/* update the confirm_verifier and return it */
76637c478bd9Sstevel@tonic-gate 			rfs4_client_scv_next(cp_confirmed);
76647c478bd9Sstevel@tonic-gate 			res->SETCLIENTID4res_u.resok4.setclientid_confirm =
76651b300de9Sjwahlig 			    cp_confirmed->confirm_verf;
76667c478bd9Sstevel@tonic-gate 
76677c478bd9Sstevel@tonic-gate 			rfs4_client_rele(cp_confirmed);
7668*f3b585ceSsamf 			goto out;
76697c478bd9Sstevel@tonic-gate 		}
76707c478bd9Sstevel@tonic-gate 
76717c478bd9Sstevel@tonic-gate 		/*
76727c478bd9Sstevel@tonic-gate 		 * Creds match but the verifier doesn't.  Must search
76737c478bd9Sstevel@tonic-gate 		 * for an unconfirmed client that would be replaced by
76747c478bd9Sstevel@tonic-gate 		 * this request.
76757c478bd9Sstevel@tonic-gate 		 */
76767c478bd9Sstevel@tonic-gate 		create = FALSE;
76777c478bd9Sstevel@tonic-gate 		cp_unconfirmed = rfs4_findclient(&args->client, &create,
76781b300de9Sjwahlig 		    cp_confirmed);
76797c478bd9Sstevel@tonic-gate 	}
76807c478bd9Sstevel@tonic-gate 
76817c478bd9Sstevel@tonic-gate 	/*
76827c478bd9Sstevel@tonic-gate 	 * At this point, we have taken care of the brand new client
76837c478bd9Sstevel@tonic-gate 	 * struct, INUSE case, update of an existing, and confirmed
76847c478bd9Sstevel@tonic-gate 	 * client struct.
76857c478bd9Sstevel@tonic-gate 	 */
76867c478bd9Sstevel@tonic-gate 
76877c478bd9Sstevel@tonic-gate 	/*
76887c478bd9Sstevel@tonic-gate 	 * check to see if things have changed while we originally
76897c478bd9Sstevel@tonic-gate 	 * picked up the client struct.  If they have, then return and
76907c478bd9Sstevel@tonic-gate 	 * retry the processing of this SETCLIENTID request.
76917c478bd9Sstevel@tonic-gate 	 */
76927c478bd9Sstevel@tonic-gate 	if (cp_unconfirmed) {
76937c478bd9Sstevel@tonic-gate 		rfs4_dbe_lock(cp_unconfirmed->dbe);
76947c478bd9Sstevel@tonic-gate 		if (!cp_unconfirmed->need_confirm) {
76957c478bd9Sstevel@tonic-gate 			rfs4_dbe_unlock(cp_unconfirmed->dbe);
76967c478bd9Sstevel@tonic-gate 			rfs4_client_rele(cp_unconfirmed);
76977c478bd9Sstevel@tonic-gate 			if (cp_confirmed)
76987c478bd9Sstevel@tonic-gate 				rfs4_client_rele(cp_confirmed);
76997c478bd9Sstevel@tonic-gate 			goto retry;
77007c478bd9Sstevel@tonic-gate 		}
77017c478bd9Sstevel@tonic-gate 		/* do away with the old unconfirmed one */
77027c478bd9Sstevel@tonic-gate 		rfs4_dbe_invalidate(cp_unconfirmed->dbe);
77037c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(cp_unconfirmed->dbe);
77047c478bd9Sstevel@tonic-gate 		rfs4_client_rele(cp_unconfirmed);
77057c478bd9Sstevel@tonic-gate 		cp_unconfirmed = NULL;
77067c478bd9Sstevel@tonic-gate 	}
77077c478bd9Sstevel@tonic-gate 
77087c478bd9Sstevel@tonic-gate 	/*
77097c478bd9Sstevel@tonic-gate 	 * This search will temporarily hide the confirmed client
77107c478bd9Sstevel@tonic-gate 	 * struct while a new client struct is created as the
77117c478bd9Sstevel@tonic-gate 	 * unconfirmed one.
77127c478bd9Sstevel@tonic-gate 	 */
77137c478bd9Sstevel@tonic-gate 	create = TRUE;
77147c478bd9Sstevel@tonic-gate 	newcp = rfs4_findclient(&args->client, &create, cp_confirmed);
77157c478bd9Sstevel@tonic-gate 
77167c478bd9Sstevel@tonic-gate 	ASSERT(newcp != NULL);
77177c478bd9Sstevel@tonic-gate 
77187c478bd9Sstevel@tonic-gate 	if (newcp == NULL) {
77197c478bd9Sstevel@tonic-gate 		*cs->statusp = res->status = NFS4ERR_SERVERFAULT;
77207c478bd9Sstevel@tonic-gate 		rfs4_client_rele(cp_confirmed);
7721*f3b585ceSsamf 		goto out;
77227c478bd9Sstevel@tonic-gate 	}
77237c478bd9Sstevel@tonic-gate 
77247c478bd9Sstevel@tonic-gate 	/*
77257c478bd9Sstevel@tonic-gate 	 * If one was not created, then a similar request must be in
77267c478bd9Sstevel@tonic-gate 	 * process so release and start over with this one
77277c478bd9Sstevel@tonic-gate 	 */
77287c478bd9Sstevel@tonic-gate 	if (create != TRUE) {
77297c478bd9Sstevel@tonic-gate 		rfs4_client_rele(newcp);
77307c478bd9Sstevel@tonic-gate 		if (cp_confirmed)
77317c478bd9Sstevel@tonic-gate 			rfs4_client_rele(cp_confirmed);
77327c478bd9Sstevel@tonic-gate 		goto retry;
77337c478bd9Sstevel@tonic-gate 	}
77347c478bd9Sstevel@tonic-gate 
77357c478bd9Sstevel@tonic-gate 	*cs->statusp = res->status = NFS4_OK;
77367c478bd9Sstevel@tonic-gate 	res->SETCLIENTID4res_u.resok4.clientid = newcp->clientid;
77371b300de9Sjwahlig 	res->SETCLIENTID4res_u.resok4.setclientid_confirm = newcp->confirm_verf;
77387c478bd9Sstevel@tonic-gate 	/* Setup callback information; CB_NULL confirmation later */
77391b300de9Sjwahlig 	rfs4_client_setcb(newcp, &args->callback, args->callback_ident);
77407c478bd9Sstevel@tonic-gate 
77417c478bd9Sstevel@tonic-gate 	newcp->cp_confirmed = cp_confirmed;
77427c478bd9Sstevel@tonic-gate 
77437c478bd9Sstevel@tonic-gate 	rfs4_client_rele(newcp);
7744*f3b585ceSsamf 
7745*f3b585ceSsamf out:
7746*f3b585ceSsamf 	DTRACE_NFSV4_2(op__setclientid__done, struct compound_state *, cs,
7747*f3b585ceSsamf 	    SETCLIENTID4res *, res);
77487c478bd9Sstevel@tonic-gate }
77497c478bd9Sstevel@tonic-gate 
77507c478bd9Sstevel@tonic-gate /*ARGSUSED*/
77517c478bd9Sstevel@tonic-gate void
77527c478bd9Sstevel@tonic-gate rfs4_op_setclientid_confirm(nfs_argop4 *argop, nfs_resop4 *resop,
77537c478bd9Sstevel@tonic-gate 			    struct svc_req *req, struct compound_state *cs)
77547c478bd9Sstevel@tonic-gate {
77557c478bd9Sstevel@tonic-gate 	SETCLIENTID_CONFIRM4args *args =
77561b300de9Sjwahlig 	    &argop->nfs_argop4_u.opsetclientid_confirm;
77577c478bd9Sstevel@tonic-gate 	SETCLIENTID_CONFIRM4res *res =
77581b300de9Sjwahlig 	    &resop->nfs_resop4_u.opsetclientid_confirm;
77597c478bd9Sstevel@tonic-gate 	rfs4_client_t *cp, *cptoclose = NULL;
77607c478bd9Sstevel@tonic-gate 
7761*f3b585ceSsamf 	DTRACE_NFSV4_2(op__setclientid__confirm__start,
7762*f3b585ceSsamf 	    struct compound_state *, cs,
7763*f3b585ceSsamf 	    SETCLIENTID_CONFIRM4args *, args);
7764*f3b585ceSsamf 
77657c478bd9Sstevel@tonic-gate 	*cs->statusp = res->status = NFS4_OK;
77667c478bd9Sstevel@tonic-gate 
77677c478bd9Sstevel@tonic-gate 	cp = rfs4_findclient_by_id(args->clientid, TRUE);
77687c478bd9Sstevel@tonic-gate 
77697c478bd9Sstevel@tonic-gate 	if (cp == NULL) {
77707c478bd9Sstevel@tonic-gate 		*cs->statusp = res->status =
77711b300de9Sjwahlig 		    rfs4_check_clientid(&args->clientid, 1);
7772*f3b585ceSsamf 		goto out;
77737c478bd9Sstevel@tonic-gate 	}
77747c478bd9Sstevel@tonic-gate 
77757c478bd9Sstevel@tonic-gate 	if (!creds_ok(cp, req, cs)) {
77767c478bd9Sstevel@tonic-gate 		*cs->statusp = res->status = NFS4ERR_CLID_INUSE;
77777c478bd9Sstevel@tonic-gate 		rfs4_client_rele(cp);
7778*f3b585ceSsamf 		goto out;
77797c478bd9Sstevel@tonic-gate 	}
77807c478bd9Sstevel@tonic-gate 
77817c478bd9Sstevel@tonic-gate 	/* If the verifier doesn't match, the record doesn't match */
77827c478bd9Sstevel@tonic-gate 	if (cp->confirm_verf != args->setclientid_confirm) {
77837c478bd9Sstevel@tonic-gate 		*cs->statusp = res->status = NFS4ERR_STALE_CLIENTID;
77847c478bd9Sstevel@tonic-gate 		rfs4_client_rele(cp);
7785*f3b585ceSsamf 		goto out;
77867c478bd9Sstevel@tonic-gate 	}
77877c478bd9Sstevel@tonic-gate 
77887c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(cp->dbe);
77897c478bd9Sstevel@tonic-gate 	cp->need_confirm = FALSE;
77907c478bd9Sstevel@tonic-gate 	if (cp->cp_confirmed) {
77917c478bd9Sstevel@tonic-gate 		cptoclose = cp->cp_confirmed;
77927c478bd9Sstevel@tonic-gate 		cptoclose->ss_remove = 1;
77937c478bd9Sstevel@tonic-gate 		cp->cp_confirmed = NULL;
77947c478bd9Sstevel@tonic-gate 	}
77957c478bd9Sstevel@tonic-gate 
77967c478bd9Sstevel@tonic-gate 	/*
7797cee86682Scalum 	 * Update the client's associated server instance, if it's changed
7798cee86682Scalum 	 * since the client was created.
7799cee86682Scalum 	 */
7800cee86682Scalum 	if (rfs4_servinst(cp) != rfs4_cur_servinst)
7801cee86682Scalum 		rfs4_servinst_assign(cp, rfs4_cur_servinst);
7802cee86682Scalum 
7803cee86682Scalum 	/*
7804cee86682Scalum 	 * Record clientid in stable storage.
7805cee86682Scalum 	 * Must be done after server instance has been assigned.
78067c478bd9Sstevel@tonic-gate 	 */
78077c478bd9Sstevel@tonic-gate 	rfs4_ss_clid(cp, req);
78087c478bd9Sstevel@tonic-gate 
78097c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(cp->dbe);
78107c478bd9Sstevel@tonic-gate 
78117c478bd9Sstevel@tonic-gate 	if (cptoclose)
78127c478bd9Sstevel@tonic-gate 		/* don't need to rele, client_close does it */
78137c478bd9Sstevel@tonic-gate 		rfs4_client_close(cptoclose);
78147c478bd9Sstevel@tonic-gate 
78157c478bd9Sstevel@tonic-gate 	/* If needed, initiate CB_NULL call for callback path */
78167c478bd9Sstevel@tonic-gate 	rfs4_deleg_cb_check(cp);
78177c478bd9Sstevel@tonic-gate 	rfs4_update_lease(cp);
78187c478bd9Sstevel@tonic-gate 
78197c478bd9Sstevel@tonic-gate 	/*
78207c478bd9Sstevel@tonic-gate 	 * Check to see if client can perform reclaims
78217c478bd9Sstevel@tonic-gate 	 */
78227c478bd9Sstevel@tonic-gate 	rfs4_ss_chkclid(cp);
78237c478bd9Sstevel@tonic-gate 
78247c478bd9Sstevel@tonic-gate 	rfs4_client_rele(cp);
7825*f3b585ceSsamf 
7826*f3b585ceSsamf out:
7827*f3b585ceSsamf 	DTRACE_NFSV4_2(op__setclientid__confirm__done,
7828*f3b585ceSsamf 	    struct compound_state *, cs,
7829*f3b585ceSsamf 	    SETCLIENTID_CONFIRM4 *, res);
78307c478bd9Sstevel@tonic-gate }
78317c478bd9Sstevel@tonic-gate 
78327c478bd9Sstevel@tonic-gate 
78337c478bd9Sstevel@tonic-gate /*ARGSUSED*/
78347c478bd9Sstevel@tonic-gate void
78357c478bd9Sstevel@tonic-gate rfs4_op_close(nfs_argop4 *argop, nfs_resop4 *resop,
78367c478bd9Sstevel@tonic-gate 	    struct svc_req *req, struct compound_state *cs)
78377c478bd9Sstevel@tonic-gate {
78387c478bd9Sstevel@tonic-gate 	CLOSE4args *args = &argop->nfs_argop4_u.opclose;
78397c478bd9Sstevel@tonic-gate 	CLOSE4res *resp = &resop->nfs_resop4_u.opclose;
78407c478bd9Sstevel@tonic-gate 	rfs4_state_t *sp;
78417c478bd9Sstevel@tonic-gate 	nfsstat4 status;
78427c478bd9Sstevel@tonic-gate 
7843*f3b585ceSsamf 	DTRACE_NFSV4_2(op__close__start, struct compound_state *, cs,
7844*f3b585ceSsamf 	    CLOSE4args *, args);
7845*f3b585ceSsamf 
78467c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
78477c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
7848*f3b585ceSsamf 		goto out;
78497c478bd9Sstevel@tonic-gate 	}
78507c478bd9Sstevel@tonic-gate 
78517c478bd9Sstevel@tonic-gate 	status = rfs4_get_state(&args->open_stateid, &sp, RFS4_DBS_INVALID);
78527c478bd9Sstevel@tonic-gate 	if (status != NFS4_OK) {
78537c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = status;
7854*f3b585ceSsamf 		goto out;
78557c478bd9Sstevel@tonic-gate 	}
78567c478bd9Sstevel@tonic-gate 
78577c478bd9Sstevel@tonic-gate 	/* Ensure specified filehandle matches */
78587c478bd9Sstevel@tonic-gate 	if (cs->vp != sp->finfo->vp) {
78597c478bd9Sstevel@tonic-gate 		rfs4_state_rele(sp);
78607c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
7861*f3b585ceSsamf 		goto out;
78627c478bd9Sstevel@tonic-gate 	}
78637c478bd9Sstevel@tonic-gate 
78647c478bd9Sstevel@tonic-gate 	/* hold off other access to open_owner while we tinker */
78657c478bd9Sstevel@tonic-gate 	rfs4_sw_enter(&sp->owner->oo_sw);
78667c478bd9Sstevel@tonic-gate 
78677c478bd9Sstevel@tonic-gate 	switch (rfs4_check_stateid_seqid(sp, &args->open_stateid)) {
78687c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_OKAY:
78697c478bd9Sstevel@tonic-gate 		if (rfs4_check_open_seqid(args->seqid, sp->owner,
78701b300de9Sjwahlig 		    resop) != NFS4_CHKSEQ_OKAY) {
78717c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
78727c478bd9Sstevel@tonic-gate 			goto end;
78737c478bd9Sstevel@tonic-gate 		}
78747c478bd9Sstevel@tonic-gate 		break;
78757c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_OLD:
78767c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
78777c478bd9Sstevel@tonic-gate 		goto end;
78787c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_BAD:
78797c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
78807c478bd9Sstevel@tonic-gate 		goto end;
78817c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_EXPIRED:
78827c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
78837c478bd9Sstevel@tonic-gate 		goto end;
78847c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_CLOSED:
78857c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
78867c478bd9Sstevel@tonic-gate 		goto end;
78877c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_UNCONFIRMED:
78887c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
78897c478bd9Sstevel@tonic-gate 		goto end;
78907c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_REPLAY:
78917c478bd9Sstevel@tonic-gate 		/* Check the sequence id for the open owner */
78927c478bd9Sstevel@tonic-gate 		switch (rfs4_check_open_seqid(args->seqid, sp->owner, resop)) {
78937c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_OKAY:
78947c478bd9Sstevel@tonic-gate 			/*
78957c478bd9Sstevel@tonic-gate 			 * This is replayed stateid; if seqid matches
78967c478bd9Sstevel@tonic-gate 			 * next expected, then client is using wrong seqid.
78977c478bd9Sstevel@tonic-gate 			 */
78987c478bd9Sstevel@tonic-gate 			/* FALL THROUGH */
78997c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_BAD:
79007c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
79017c478bd9Sstevel@tonic-gate 			goto end;
79027c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_REPLAY:
79037c478bd9Sstevel@tonic-gate 			/*
79047c478bd9Sstevel@tonic-gate 			 * Note this case is the duplicate case so
79057c478bd9Sstevel@tonic-gate 			 * resp->status is already set.
79067c478bd9Sstevel@tonic-gate 			 */
79077c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status;
79087c478bd9Sstevel@tonic-gate 			rfs4_update_lease(sp->owner->client);
79097c478bd9Sstevel@tonic-gate 			goto end;
79107c478bd9Sstevel@tonic-gate 		}
79117c478bd9Sstevel@tonic-gate 		break;
79127c478bd9Sstevel@tonic-gate 	default:
79137c478bd9Sstevel@tonic-gate 		ASSERT(FALSE);
79147c478bd9Sstevel@tonic-gate 		break;
79157c478bd9Sstevel@tonic-gate 	}
79167c478bd9Sstevel@tonic-gate 
79177c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(sp->dbe);
79187c478bd9Sstevel@tonic-gate 
79197c478bd9Sstevel@tonic-gate 	/* Update the stateid. */
79207c478bd9Sstevel@tonic-gate 	next_stateid(&sp->stateid);
79217c478bd9Sstevel@tonic-gate 	resp->open_stateid = sp->stateid.stateid;
79227c478bd9Sstevel@tonic-gate 
79237c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(sp->dbe);
79247c478bd9Sstevel@tonic-gate 
79257c478bd9Sstevel@tonic-gate 	rfs4_update_lease(sp->owner->client);
79267c478bd9Sstevel@tonic-gate 	rfs4_update_open_sequence(sp->owner);
79277c478bd9Sstevel@tonic-gate 	rfs4_update_open_resp(sp->owner, resop, NULL);
79287c478bd9Sstevel@tonic-gate 
79297c478bd9Sstevel@tonic-gate 	rfs4_state_close(sp, FALSE, FALSE, cs->cr);
79307c478bd9Sstevel@tonic-gate 
79317c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = status;
79327c478bd9Sstevel@tonic-gate 
79337c478bd9Sstevel@tonic-gate end:
79347c478bd9Sstevel@tonic-gate 	rfs4_sw_exit(&sp->owner->oo_sw);
79357c478bd9Sstevel@tonic-gate 	rfs4_state_rele(sp);
7936*f3b585ceSsamf out:
7937*f3b585ceSsamf 	DTRACE_NFSV4_2(op__close__done, struct compound_state *, cs,
7938*f3b585ceSsamf 	    CLOSE4res *, resp);
79397c478bd9Sstevel@tonic-gate }
79407c478bd9Sstevel@tonic-gate 
79417c478bd9Sstevel@tonic-gate /*
79427c478bd9Sstevel@tonic-gate  * Manage the counts on the file struct and close all file locks
79437c478bd9Sstevel@tonic-gate  */
79447c478bd9Sstevel@tonic-gate /*ARGSUSED*/
79457c478bd9Sstevel@tonic-gate void
79467c478bd9Sstevel@tonic-gate rfs4_release_share_lock_state(rfs4_state_t *sp, cred_t *cr,
79477c478bd9Sstevel@tonic-gate 	bool_t close_of_client)
79487c478bd9Sstevel@tonic-gate {
79497c478bd9Sstevel@tonic-gate 	rfs4_file_t *fp = sp->finfo;
79507c478bd9Sstevel@tonic-gate 	rfs4_lo_state_t *lsp;
79517c478bd9Sstevel@tonic-gate 	struct shrlock shr;
79527c478bd9Sstevel@tonic-gate 	struct shr_locowner shr_loco;
79537c478bd9Sstevel@tonic-gate 	int fflags, s_access, s_deny;
79547c478bd9Sstevel@tonic-gate 
79557c478bd9Sstevel@tonic-gate 	fflags = s_access = s_deny = 0;
79567c478bd9Sstevel@tonic-gate 	/*
79577c478bd9Sstevel@tonic-gate 	 * Decrement the count for each access and deny bit that this
79587c478bd9Sstevel@tonic-gate 	 * state has contributed to the file. If the file counts go to zero
79597c478bd9Sstevel@tonic-gate 	 * clear the appropriate bit in the appropriate mask.
79607c478bd9Sstevel@tonic-gate 	 */
79617c478bd9Sstevel@tonic-gate 
79627c478bd9Sstevel@tonic-gate 	if (sp->share_access & OPEN4_SHARE_ACCESS_READ) {
79637c478bd9Sstevel@tonic-gate 		fp->access_read--;
79647c478bd9Sstevel@tonic-gate 		fflags |= FREAD;
79657c478bd9Sstevel@tonic-gate 		s_access |= F_RDACC;
79667c478bd9Sstevel@tonic-gate 		if (fp->access_read == 0)
79677c478bd9Sstevel@tonic-gate 			fp->share_access &= ~OPEN4_SHARE_ACCESS_READ;
79687c478bd9Sstevel@tonic-gate 	}
79697c478bd9Sstevel@tonic-gate 	if (sp->share_access & OPEN4_SHARE_ACCESS_WRITE) {
79707c478bd9Sstevel@tonic-gate 		fp->access_write--;
79717c478bd9Sstevel@tonic-gate 		fflags |= FWRITE;
79727c478bd9Sstevel@tonic-gate 		s_access |= F_WRACC;
79737c478bd9Sstevel@tonic-gate 		if (fp->access_write == 0)
79747c478bd9Sstevel@tonic-gate 			fp->share_access &= ~OPEN4_SHARE_ACCESS_WRITE;
79757c478bd9Sstevel@tonic-gate 	}
79767c478bd9Sstevel@tonic-gate 	if (sp->share_deny & OPEN4_SHARE_DENY_READ) {
79777c478bd9Sstevel@tonic-gate 		fp->deny_read--;
79787c478bd9Sstevel@tonic-gate 		s_deny |= F_RDDNY;
79797c478bd9Sstevel@tonic-gate 		if (fp->deny_read == 0)
79807c478bd9Sstevel@tonic-gate 			fp->share_deny &= ~OPEN4_SHARE_DENY_READ;
79817c478bd9Sstevel@tonic-gate 	}
79827c478bd9Sstevel@tonic-gate 	if (sp->share_deny & OPEN4_SHARE_DENY_WRITE) {
79837c478bd9Sstevel@tonic-gate 		fp->deny_write--;
79847c478bd9Sstevel@tonic-gate 		s_deny |= F_WRDNY;
79857c478bd9Sstevel@tonic-gate 		if (fp->deny_write == 0)
79867c478bd9Sstevel@tonic-gate 			fp->share_deny &= ~OPEN4_SHARE_DENY_WRITE;
79877c478bd9Sstevel@tonic-gate 	}
79887c478bd9Sstevel@tonic-gate 
79897c478bd9Sstevel@tonic-gate 	/*
79907c478bd9Sstevel@tonic-gate 	 * If this call is part of the larger closing down of client
79917c478bd9Sstevel@tonic-gate 	 * state then it is just easier to release all locks
79927c478bd9Sstevel@tonic-gate 	 * associated with this client instead of going through each
79937c478bd9Sstevel@tonic-gate 	 * individual file and cleaning locks there.
79947c478bd9Sstevel@tonic-gate 	 */
79957c478bd9Sstevel@tonic-gate 	if (close_of_client) {
79967c478bd9Sstevel@tonic-gate 		if (sp->owner->client->unlksys_completed == FALSE &&
79977c478bd9Sstevel@tonic-gate 		    sp->lockownerlist.next->lsp != NULL &&
79981b300de9Sjwahlig 		    sp->owner->client->sysidt != LM_NOSYSID) {
79997c478bd9Sstevel@tonic-gate 			/* Is the PxFS kernel module loaded? */
80007c478bd9Sstevel@tonic-gate 			if (lm_remove_file_locks != NULL) {
80017c478bd9Sstevel@tonic-gate 				int new_sysid;
80027c478bd9Sstevel@tonic-gate 
80037c478bd9Sstevel@tonic-gate 				/* Encode the cluster nodeid in new sysid */
80047c478bd9Sstevel@tonic-gate 				new_sysid = sp->owner->client->sysidt;
80057c478bd9Sstevel@tonic-gate 				lm_set_nlmid_flk(&new_sysid);
80067c478bd9Sstevel@tonic-gate 
80077c478bd9Sstevel@tonic-gate 				/*
80087c478bd9Sstevel@tonic-gate 				 * This PxFS routine removes file locks for a
80097c478bd9Sstevel@tonic-gate 				 * client over all nodes of a cluster.
80107c478bd9Sstevel@tonic-gate 				 */
80117c478bd9Sstevel@tonic-gate 				NFS4_DEBUG(rfs4_debug, (CE_NOTE,
80127c478bd9Sstevel@tonic-gate 				    "lm_remove_file_locks(sysid=0x%x)\n",
80137c478bd9Sstevel@tonic-gate 				    new_sysid));
80147c478bd9Sstevel@tonic-gate 				(*lm_remove_file_locks)(new_sysid);
80157c478bd9Sstevel@tonic-gate 			} else {
80167c478bd9Sstevel@tonic-gate 				struct flock64 flk;
80177c478bd9Sstevel@tonic-gate 
80187c478bd9Sstevel@tonic-gate 				/* Release all locks for this client */
80197c478bd9Sstevel@tonic-gate 				flk.l_type = F_UNLKSYS;
80207c478bd9Sstevel@tonic-gate 				flk.l_whence = 0;
80217c478bd9Sstevel@tonic-gate 				flk.l_start = 0;
80227c478bd9Sstevel@tonic-gate 				flk.l_len = 0;
80237c478bd9Sstevel@tonic-gate 				flk.l_sysid = sp->owner->client->sysidt;
80247c478bd9Sstevel@tonic-gate 				flk.l_pid = 0;
80257c478bd9Sstevel@tonic-gate 				(void) VOP_FRLOCK(sp->finfo->vp, F_SETLK, &flk,
80267c478bd9Sstevel@tonic-gate 				    F_REMOTELOCK | FREAD | FWRITE,
8027da6c28aaSamw 				    (u_offset_t)0, NULL, CRED(), NULL);
80287c478bd9Sstevel@tonic-gate 			}
80297c478bd9Sstevel@tonic-gate 
80307c478bd9Sstevel@tonic-gate 			sp->owner->client->unlksys_completed = TRUE;
80317c478bd9Sstevel@tonic-gate 		}
80327c478bd9Sstevel@tonic-gate 	}
80337c478bd9Sstevel@tonic-gate 
80347c478bd9Sstevel@tonic-gate 	/*
80357c478bd9Sstevel@tonic-gate 	 * Release all locks on this file by this lock owner or at
80367c478bd9Sstevel@tonic-gate 	 * least mark the locks as having been released
80377c478bd9Sstevel@tonic-gate 	 */
80387c478bd9Sstevel@tonic-gate 	for (lsp = sp->lockownerlist.next->lsp; lsp != NULL;
80391b300de9Sjwahlig 	    lsp = lsp->lockownerlist.next->lsp) {
80407c478bd9Sstevel@tonic-gate 
80417c478bd9Sstevel@tonic-gate 		lsp->locks_cleaned = TRUE;
80427c478bd9Sstevel@tonic-gate 
80437c478bd9Sstevel@tonic-gate 		/* Was this already taken care of above? */
80447c478bd9Sstevel@tonic-gate 		if (!close_of_client &&
80457c478bd9Sstevel@tonic-gate 		    sp->owner->client->sysidt != LM_NOSYSID)
80467c478bd9Sstevel@tonic-gate 			(void) cleanlocks(sp->finfo->vp, lsp->locker->pid,
80471b300de9Sjwahlig 			    lsp->locker->client->sysidt);
80487c478bd9Sstevel@tonic-gate 	}
80497c478bd9Sstevel@tonic-gate 
80507c478bd9Sstevel@tonic-gate 	/*
80517c478bd9Sstevel@tonic-gate 	 * Release any shrlocks associated with this open state ID.
80527c478bd9Sstevel@tonic-gate 	 * This must be done before the rfs4_state gets marked closed.
80537c478bd9Sstevel@tonic-gate 	 */
80547c478bd9Sstevel@tonic-gate 	if (sp->owner->client->sysidt != LM_NOSYSID) {
80557c478bd9Sstevel@tonic-gate 		shr.s_access = s_access;
80567c478bd9Sstevel@tonic-gate 		shr.s_deny = s_deny;
80577c478bd9Sstevel@tonic-gate 		shr.s_pid = rfs4_dbe_getid(sp->owner->dbe);
80587c478bd9Sstevel@tonic-gate 		shr.s_sysid = sp->owner->client->sysidt;
80597c478bd9Sstevel@tonic-gate 		shr_loco.sl_pid = shr.s_pid;
80607c478bd9Sstevel@tonic-gate 		shr_loco.sl_id = shr.s_sysid;
80617c478bd9Sstevel@tonic-gate 		shr.s_owner = (caddr_t)&shr_loco;
80627c478bd9Sstevel@tonic-gate 		shr.s_own_len = sizeof (shr_loco);
80637c478bd9Sstevel@tonic-gate 		(void) vop_shrlock(sp->finfo->vp, F_UNSHARE, &shr, fflags);
80647c478bd9Sstevel@tonic-gate 	}
8065da6c28aaSamw 
8066da6c28aaSamw 	(void) VOP_CLOSE(fp->vp, fflags, 1, (offset_t)0, cr, NULL);
80677c478bd9Sstevel@tonic-gate }
80687c478bd9Sstevel@tonic-gate 
80697c478bd9Sstevel@tonic-gate /*
80707c478bd9Sstevel@tonic-gate  * lock_denied: Fill in a LOCK4deneid structure given an flock64 structure.
80717c478bd9Sstevel@tonic-gate  */
80727c478bd9Sstevel@tonic-gate static nfsstat4
80737c478bd9Sstevel@tonic-gate lock_denied(LOCK4denied *dp, struct flock64 *flk)
80747c478bd9Sstevel@tonic-gate {
80757c478bd9Sstevel@tonic-gate 	rfs4_lockowner_t *lo;
80767c478bd9Sstevel@tonic-gate 	rfs4_client_t *cp;
80777c478bd9Sstevel@tonic-gate 	uint32_t len;
80787c478bd9Sstevel@tonic-gate 
80797c478bd9Sstevel@tonic-gate 	lo = rfs4_findlockowner_by_pid(flk->l_pid);
80807c478bd9Sstevel@tonic-gate 	if (lo != NULL) {
80817c478bd9Sstevel@tonic-gate 		cp = lo->client;
80827c478bd9Sstevel@tonic-gate 		if (rfs4_lease_expired(cp)) {
80837c478bd9Sstevel@tonic-gate 			rfs4_lockowner_rele(lo);
80847c478bd9Sstevel@tonic-gate 			rfs4_dbe_hold(cp->dbe);
80857c478bd9Sstevel@tonic-gate 			rfs4_client_close(cp);
80867c478bd9Sstevel@tonic-gate 			return (NFS4ERR_EXPIRED);
80877c478bd9Sstevel@tonic-gate 		}
80887c478bd9Sstevel@tonic-gate 		dp->owner.clientid = lo->owner.clientid;
80897c478bd9Sstevel@tonic-gate 		len = lo->owner.owner_len;
80907c478bd9Sstevel@tonic-gate 		dp->owner.owner_val = kmem_alloc(len, KM_SLEEP);
80917c478bd9Sstevel@tonic-gate 		bcopy(lo->owner.owner_val, dp->owner.owner_val, len);
80927c478bd9Sstevel@tonic-gate 		dp->owner.owner_len = len;
80937c478bd9Sstevel@tonic-gate 		rfs4_lockowner_rele(lo);
80947c478bd9Sstevel@tonic-gate 		goto finish;
80957c478bd9Sstevel@tonic-gate 	}
80967c478bd9Sstevel@tonic-gate 
80977c478bd9Sstevel@tonic-gate 	/*
80987c478bd9Sstevel@tonic-gate 	 * Its not a NFS4 lock. We take advantage that the upper 32 bits
80997c478bd9Sstevel@tonic-gate 	 * of the client id contain the boot time for a NFS4 lock. So we
81007c478bd9Sstevel@tonic-gate 	 * fabricate and identity by setting clientid to the sysid, and
81017c478bd9Sstevel@tonic-gate 	 * the lock owner to the pid.
81027c478bd9Sstevel@tonic-gate 	 */
81037c478bd9Sstevel@tonic-gate 	dp->owner.clientid = flk->l_sysid;
81047c478bd9Sstevel@tonic-gate 	len = sizeof (pid_t);
81057c478bd9Sstevel@tonic-gate 	dp->owner.owner_len = len;
81067c478bd9Sstevel@tonic-gate 	dp->owner.owner_val = kmem_alloc(len, KM_SLEEP);
81077c478bd9Sstevel@tonic-gate 	bcopy(&flk->l_pid, dp->owner.owner_val, len);
81087c478bd9Sstevel@tonic-gate finish:
81097c478bd9Sstevel@tonic-gate 	dp->offset = flk->l_start;
81107c478bd9Sstevel@tonic-gate 	dp->length = flk->l_len;
81117c478bd9Sstevel@tonic-gate 
81127c478bd9Sstevel@tonic-gate 	if (flk->l_type == F_RDLCK)
81137c478bd9Sstevel@tonic-gate 		dp->locktype = READ_LT;
81147c478bd9Sstevel@tonic-gate 	else if (flk->l_type == F_WRLCK)
81157c478bd9Sstevel@tonic-gate 		dp->locktype = WRITE_LT;
81167c478bd9Sstevel@tonic-gate 	else
81177c478bd9Sstevel@tonic-gate 		return (NFS4ERR_INVAL);	/* no mapping from POSIX ltype to v4 */
81187c478bd9Sstevel@tonic-gate 
81197c478bd9Sstevel@tonic-gate 	return (NFS4_OK);
81207c478bd9Sstevel@tonic-gate }
81217c478bd9Sstevel@tonic-gate 
81227c478bd9Sstevel@tonic-gate static int
81237c478bd9Sstevel@tonic-gate setlock(vnode_t *vp, struct flock64 *flock, int flag, cred_t *cred)
81247c478bd9Sstevel@tonic-gate {
81257c478bd9Sstevel@tonic-gate 	int error;
81267c478bd9Sstevel@tonic-gate 	struct flock64 flk;
81277c478bd9Sstevel@tonic-gate 	int i;
81287c478bd9Sstevel@tonic-gate 	clock_t delaytime;
8129da6c28aaSamw 	int cmd;
81307c478bd9Sstevel@tonic-gate 
8131da6c28aaSamw 	cmd = nbl_need_check(vp) ? F_SETLK_NBMAND : F_SETLK;
81327c478bd9Sstevel@tonic-gate retry:
81337c478bd9Sstevel@tonic-gate 	delaytime = MSEC_TO_TICK_ROUNDUP(rfs4_lock_delay);
81347c478bd9Sstevel@tonic-gate 
81357c478bd9Sstevel@tonic-gate 	for (i = 0; i < rfs4_maxlock_tries; i++) {
8136da6c28aaSamw 		LOCK_PRINT(rfs4_debug, "setlock", cmd, flock);
8137da6c28aaSamw 		error = VOP_FRLOCK(vp, cmd,
8138da6c28aaSamw 		    flock, flag, (u_offset_t)0, NULL, cred, NULL);
81397c478bd9Sstevel@tonic-gate 
81407c478bd9Sstevel@tonic-gate 		if (error != EAGAIN && error != EACCES)
81417c478bd9Sstevel@tonic-gate 			break;
81427c478bd9Sstevel@tonic-gate 
81437c478bd9Sstevel@tonic-gate 		if (i < rfs4_maxlock_tries - 1) {
81447c478bd9Sstevel@tonic-gate 			delay(delaytime);
81457c478bd9Sstevel@tonic-gate 			delaytime *= 2;
81467c478bd9Sstevel@tonic-gate 		}
81477c478bd9Sstevel@tonic-gate 	}
81487c478bd9Sstevel@tonic-gate 
81497c478bd9Sstevel@tonic-gate 	if (error == EAGAIN || error == EACCES) {
81507c478bd9Sstevel@tonic-gate 		/* Get the owner of the lock */
81517c478bd9Sstevel@tonic-gate 		flk = *flock;
81527c478bd9Sstevel@tonic-gate 		LOCK_PRINT(rfs4_debug, "setlock", F_GETLK, &flk);
8153da6c28aaSamw 		if (VOP_FRLOCK(vp, F_GETLK, &flk, flag,
8154da6c28aaSamw 		    (u_offset_t)0, NULL, cred, NULL) == 0) {
81557c478bd9Sstevel@tonic-gate 			if (flk.l_type == F_UNLCK) {
81567c478bd9Sstevel@tonic-gate 				/* No longer locked, retry */
81577c478bd9Sstevel@tonic-gate 				goto retry;
81587c478bd9Sstevel@tonic-gate 			}
81597c478bd9Sstevel@tonic-gate 			*flock = flk;
81607c478bd9Sstevel@tonic-gate 			LOCK_PRINT(rfs4_debug, "setlock(blocking lock)",
81611b300de9Sjwahlig 			    F_GETLK, &flk);
81627c478bd9Sstevel@tonic-gate 		}
81637c478bd9Sstevel@tonic-gate 	}
81647c478bd9Sstevel@tonic-gate 
81657c478bd9Sstevel@tonic-gate 	return (error);
81667c478bd9Sstevel@tonic-gate }
81677c478bd9Sstevel@tonic-gate 
81687c478bd9Sstevel@tonic-gate /*ARGSUSED*/
81697c478bd9Sstevel@tonic-gate static nfsstat4
81707c478bd9Sstevel@tonic-gate rfs4_do_lock(rfs4_lo_state_t *lp, nfs_lock_type4 locktype,
81717c478bd9Sstevel@tonic-gate 	    seqid4 seqid, offset4 offset,
81727c478bd9Sstevel@tonic-gate 	    length4 length, cred_t *cred, nfs_resop4 *resop)
81737c478bd9Sstevel@tonic-gate {
81747c478bd9Sstevel@tonic-gate 	nfsstat4 status;
81757c478bd9Sstevel@tonic-gate 	rfs4_lockowner_t *lo = lp->locker;
81767c478bd9Sstevel@tonic-gate 	rfs4_state_t *sp = lp->state;
81777c478bd9Sstevel@tonic-gate 	struct flock64 flock;
81787c478bd9Sstevel@tonic-gate 	int16_t ltype;
81797c478bd9Sstevel@tonic-gate 	int flag;
81807c478bd9Sstevel@tonic-gate 	int error;
81817c478bd9Sstevel@tonic-gate 	sysid_t sysid;
81827c478bd9Sstevel@tonic-gate 	LOCK4res *lres;
81837c478bd9Sstevel@tonic-gate 
81847c478bd9Sstevel@tonic-gate 	if (rfs4_lease_expired(lo->client)) {
81857c478bd9Sstevel@tonic-gate 		return (NFS4ERR_EXPIRED);
81867c478bd9Sstevel@tonic-gate 	}
81877c478bd9Sstevel@tonic-gate 
81887c478bd9Sstevel@tonic-gate 	if ((status = rfs4_client_sysid(lo->client, &sysid)) != NFS4_OK)
81897c478bd9Sstevel@tonic-gate 		return (status);
81907c478bd9Sstevel@tonic-gate 
81917c478bd9Sstevel@tonic-gate 	/* Check for zero length. To lock to end of file use all ones for V4 */
81927c478bd9Sstevel@tonic-gate 	if (length == 0)
81937c478bd9Sstevel@tonic-gate 		return (NFS4ERR_INVAL);
81947c478bd9Sstevel@tonic-gate 	else if (length == (length4)(~0))
81957c478bd9Sstevel@tonic-gate 		length = 0;		/* Posix to end of file  */
81967c478bd9Sstevel@tonic-gate 
81977c478bd9Sstevel@tonic-gate retry:
81987c478bd9Sstevel@tonic-gate 	rfs4_dbe_lock(sp->dbe);
81997c478bd9Sstevel@tonic-gate 
82007c478bd9Sstevel@tonic-gate 
82017c478bd9Sstevel@tonic-gate 	if (resop->resop != OP_LOCKU) {
82027c478bd9Sstevel@tonic-gate 		switch (locktype) {
82037c478bd9Sstevel@tonic-gate 		case READ_LT:
82047c478bd9Sstevel@tonic-gate 		case READW_LT:
82057c478bd9Sstevel@tonic-gate 			if ((sp->share_access
82067c478bd9Sstevel@tonic-gate 			    & OPEN4_SHARE_ACCESS_READ) == 0) {
82077c478bd9Sstevel@tonic-gate 				rfs4_dbe_unlock(sp->dbe);
82087c478bd9Sstevel@tonic-gate 
82097c478bd9Sstevel@tonic-gate 				return (NFS4ERR_OPENMODE);
82107c478bd9Sstevel@tonic-gate 			}
82117c478bd9Sstevel@tonic-gate 			ltype = F_RDLCK;
82127c478bd9Sstevel@tonic-gate 			break;
82137c478bd9Sstevel@tonic-gate 		case WRITE_LT:
82147c478bd9Sstevel@tonic-gate 		case WRITEW_LT:
82157c478bd9Sstevel@tonic-gate 			if ((sp->share_access
82167c478bd9Sstevel@tonic-gate 			    & OPEN4_SHARE_ACCESS_WRITE) == 0) {
82177c478bd9Sstevel@tonic-gate 				rfs4_dbe_unlock(sp->dbe);
82187c478bd9Sstevel@tonic-gate 
82197c478bd9Sstevel@tonic-gate 				return (NFS4ERR_OPENMODE);
82207c478bd9Sstevel@tonic-gate 			}
82217c478bd9Sstevel@tonic-gate 			ltype = F_WRLCK;
82227c478bd9Sstevel@tonic-gate 			break;
82237c478bd9Sstevel@tonic-gate 		}
82247c478bd9Sstevel@tonic-gate 	} else
82257c478bd9Sstevel@tonic-gate 		ltype = F_UNLCK;
82267c478bd9Sstevel@tonic-gate 
82277c478bd9Sstevel@tonic-gate 	flock.l_type = ltype;
82287c478bd9Sstevel@tonic-gate 	flock.l_whence = 0;		/* SEEK_SET */
82297c478bd9Sstevel@tonic-gate 	flock.l_start = offset;
82307c478bd9Sstevel@tonic-gate 	flock.l_len = length;
82317c478bd9Sstevel@tonic-gate 	flock.l_sysid = sysid;
82327c478bd9Sstevel@tonic-gate 	flock.l_pid = lp->locker->pid;
82337c478bd9Sstevel@tonic-gate 
82347c478bd9Sstevel@tonic-gate 	/* Note that length4 is uint64_t but l_len and l_start are off64_t */
82357c478bd9Sstevel@tonic-gate 	if (flock.l_len < 0 || flock.l_start < 0) {
82367c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(sp->dbe);
82377c478bd9Sstevel@tonic-gate 		return (NFS4ERR_INVAL);
82387c478bd9Sstevel@tonic-gate 	}
82397c478bd9Sstevel@tonic-gate 
82407c478bd9Sstevel@tonic-gate 	/*
82417c478bd9Sstevel@tonic-gate 	 * N.B. FREAD has the same value as OPEN4_SHARE_ACCESS_READ and
82427c478bd9Sstevel@tonic-gate 	 * FWRITE has the same value as OPEN4_SHARE_ACCESS_WRITE.
82437c478bd9Sstevel@tonic-gate 	 */
82447c478bd9Sstevel@tonic-gate 	flag = (int)sp->share_access | F_REMOTELOCK;
82457c478bd9Sstevel@tonic-gate 
82467c478bd9Sstevel@tonic-gate 	error = setlock(sp->finfo->vp, &flock, flag, cred);
82477c478bd9Sstevel@tonic-gate 	if (error == 0) {
82487c478bd9Sstevel@tonic-gate 		rfs4_dbe_lock(lp->dbe);
82497c478bd9Sstevel@tonic-gate 		next_stateid(&lp->lockid);
82507c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(lp->dbe);
82517c478bd9Sstevel@tonic-gate 	}
82527c478bd9Sstevel@tonic-gate 
82537c478bd9Sstevel@tonic-gate 	rfs4_dbe_unlock(sp->dbe);
82547c478bd9Sstevel@tonic-gate 
82557c478bd9Sstevel@tonic-gate 	/*
82567c478bd9Sstevel@tonic-gate 	 * N.B. We map error values to nfsv4 errors. This is differrent
82577c478bd9Sstevel@tonic-gate 	 * than puterrno4 routine.
82587c478bd9Sstevel@tonic-gate 	 */
82597c478bd9Sstevel@tonic-gate 	switch (error) {
82607c478bd9Sstevel@tonic-gate 	case 0:
82617c478bd9Sstevel@tonic-gate 		status = NFS4_OK;
82627c478bd9Sstevel@tonic-gate 		break;
82637c478bd9Sstevel@tonic-gate 	case EAGAIN:
82647c478bd9Sstevel@tonic-gate 	case EACCES:		/* Old value */
82657c478bd9Sstevel@tonic-gate 		/* Can only get here if op is OP_LOCK */
82667c478bd9Sstevel@tonic-gate 		ASSERT(resop->resop == OP_LOCK);
82677c478bd9Sstevel@tonic-gate 		lres = &resop->nfs_resop4_u.oplock;
82687c478bd9Sstevel@tonic-gate 		status = NFS4ERR_DENIED;
82697c478bd9Sstevel@tonic-gate 		if (lock_denied(&lres->LOCK4res_u.denied, &flock)
82701b300de9Sjwahlig 		    == NFS4ERR_EXPIRED)
82717c478bd9Sstevel@tonic-gate 			goto retry;
82727c478bd9Sstevel@tonic-gate 		break;
82737c478bd9Sstevel@tonic-gate 	case ENOLCK:
82747c478bd9Sstevel@tonic-gate 		status = NFS4ERR_DELAY;
82757c478bd9Sstevel@tonic-gate 		break;
82767c478bd9Sstevel@tonic-gate 	case EOVERFLOW:
82777c478bd9Sstevel@tonic-gate 		status = NFS4ERR_INVAL;
82787c478bd9Sstevel@tonic-gate 		break;
82797c478bd9Sstevel@tonic-gate 	case EINVAL:
82807c478bd9Sstevel@tonic-gate 		status = NFS4ERR_NOTSUPP;
82817c478bd9Sstevel@tonic-gate 		break;
82827c478bd9Sstevel@tonic-gate 	default:
82831b300de9Sjwahlig 		cmn_err(CE_WARN, "rfs4_do_lock: unexpected errno (%d)", error);
82847c478bd9Sstevel@tonic-gate 		status = NFS4ERR_SERVERFAULT;
82857c478bd9Sstevel@tonic-gate 		break;
82867c478bd9Sstevel@tonic-gate 	}
82877c478bd9Sstevel@tonic-gate 
82887c478bd9Sstevel@tonic-gate 	return (status);
82897c478bd9Sstevel@tonic-gate }
82907c478bd9Sstevel@tonic-gate 
82917c478bd9Sstevel@tonic-gate /*ARGSUSED*/
82927c478bd9Sstevel@tonic-gate void
82937c478bd9Sstevel@tonic-gate rfs4_op_lock(nfs_argop4 *argop, nfs_resop4 *resop,
82947c478bd9Sstevel@tonic-gate 	    struct svc_req *req, struct compound_state *cs)
82957c478bd9Sstevel@tonic-gate {
82967c478bd9Sstevel@tonic-gate 	LOCK4args *args = &argop->nfs_argop4_u.oplock;
82977c478bd9Sstevel@tonic-gate 	LOCK4res *resp = &resop->nfs_resop4_u.oplock;
82987c478bd9Sstevel@tonic-gate 	nfsstat4 status;
82997c478bd9Sstevel@tonic-gate 	stateid4 *stateid;
83007c478bd9Sstevel@tonic-gate 	rfs4_lockowner_t *lo;
83017c478bd9Sstevel@tonic-gate 	rfs4_client_t *cp;
83027c478bd9Sstevel@tonic-gate 	rfs4_state_t *sp = NULL;
83037c478bd9Sstevel@tonic-gate 	rfs4_lo_state_t *lsp = NULL;
83047c478bd9Sstevel@tonic-gate 	bool_t ls_sw_held = FALSE;
83057c478bd9Sstevel@tonic-gate 	bool_t create = TRUE;
83067c478bd9Sstevel@tonic-gate 	bool_t lcreate = TRUE;
83077c478bd9Sstevel@tonic-gate 	bool_t dup_lock = FALSE;
83087c478bd9Sstevel@tonic-gate 	int rc;
83097c478bd9Sstevel@tonic-gate 
8310*f3b585ceSsamf 	DTRACE_NFSV4_2(op__lock__start, struct compound_state *, cs,
8311*f3b585ceSsamf 	    LOCK4args *, args);
8312*f3b585ceSsamf 
83137c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
83147c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
8315*f3b585ceSsamf 		DTRACE_NFSV4_2(op__lock__done, struct compound_state *,
8316*f3b585ceSsamf 		    cs, LOCK4res *, resp);
83177c478bd9Sstevel@tonic-gate 		return;
83187c478bd9Sstevel@tonic-gate 	}
83197c478bd9Sstevel@tonic-gate 
83207c478bd9Sstevel@tonic-gate 	if (args->locker.new_lock_owner) {
83217c478bd9Sstevel@tonic-gate 		/* Create a new lockowner for this instance */
83227c478bd9Sstevel@tonic-gate 		open_to_lock_owner4 *olo = &args->locker.locker4_u.open_owner;
83237c478bd9Sstevel@tonic-gate 
83247c478bd9Sstevel@tonic-gate 		NFS4_DEBUG(rfs4_debug, (CE_NOTE, "Creating new lock owner"));
83257c478bd9Sstevel@tonic-gate 
83267c478bd9Sstevel@tonic-gate 		stateid = &olo->open_stateid;
83277c478bd9Sstevel@tonic-gate 		status = rfs4_get_state(stateid, &sp, RFS4_DBS_VALID);
83287c478bd9Sstevel@tonic-gate 		if (status != NFS4_OK) {
83297c478bd9Sstevel@tonic-gate 			NFS4_DEBUG(rfs4_debug,
83301b300de9Sjwahlig 			    (CE_NOTE, "Get state failed in lock %d", status));
83317c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = status;
8332*f3b585ceSsamf 			DTRACE_NFSV4_2(op__lock__done, struct compound_state *,
8333*f3b585ceSsamf 			    cs, LOCK4res *, resp);
83347c478bd9Sstevel@tonic-gate 			return;
83357c478bd9Sstevel@tonic-gate 		}
83367c478bd9Sstevel@tonic-gate 
83377c478bd9Sstevel@tonic-gate 		/* Ensure specified filehandle matches */
83387c478bd9Sstevel@tonic-gate 		if (cs->vp != sp->finfo->vp) {
83397c478bd9Sstevel@tonic-gate 			rfs4_state_rele(sp);
83407c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
8341*f3b585ceSsamf 			DTRACE_NFSV4_2(op__lock__done, struct compound_state *,
8342*f3b585ceSsamf 			    cs, LOCK4res *, resp);
83437c478bd9Sstevel@tonic-gate 			return;
83447c478bd9Sstevel@tonic-gate 		}
83457c478bd9Sstevel@tonic-gate 
83467c478bd9Sstevel@tonic-gate 		/* hold off other access to open_owner while we tinker */
83477c478bd9Sstevel@tonic-gate 		rfs4_sw_enter(&sp->owner->oo_sw);
83487c478bd9Sstevel@tonic-gate 
83497c478bd9Sstevel@tonic-gate 		switch (rc = rfs4_check_stateid_seqid(sp, stateid)) {
83507c478bd9Sstevel@tonic-gate 		case NFS4_CHECK_STATEID_OLD:
83517c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
83527c478bd9Sstevel@tonic-gate 			goto end;
83537c478bd9Sstevel@tonic-gate 		case NFS4_CHECK_STATEID_BAD:
83547c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
83557c478bd9Sstevel@tonic-gate 			goto end;
83567c478bd9Sstevel@tonic-gate 		case NFS4_CHECK_STATEID_EXPIRED:
83577c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_EXPIRED;
83587c478bd9Sstevel@tonic-gate 			goto end;
83597c478bd9Sstevel@tonic-gate 		case NFS4_CHECK_STATEID_UNCONFIRMED:
83607c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
83617c478bd9Sstevel@tonic-gate 			goto end;
83627c478bd9Sstevel@tonic-gate 		case NFS4_CHECK_STATEID_CLOSED:
83637c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
83647c478bd9Sstevel@tonic-gate 			goto end;
83657c478bd9Sstevel@tonic-gate 		case NFS4_CHECK_STATEID_OKAY:
83667c478bd9Sstevel@tonic-gate 		case NFS4_CHECK_STATEID_REPLAY:
83677c478bd9Sstevel@tonic-gate 			switch (rfs4_check_olo_seqid(olo->open_seqid,
83681b300de9Sjwahlig 			    sp->owner, resop)) {
83697c478bd9Sstevel@tonic-gate 			case NFS4_CHKSEQ_OKAY:
83707c478bd9Sstevel@tonic-gate 				if (rc == NFS4_CHECK_STATEID_OKAY)
83717c478bd9Sstevel@tonic-gate 					break;
83727c478bd9Sstevel@tonic-gate 				/*
83737c478bd9Sstevel@tonic-gate 				 * This is replayed stateid; if seqid
83747c478bd9Sstevel@tonic-gate 				 * matches next expected, then client
83757c478bd9Sstevel@tonic-gate 				 * is using wrong seqid.
83767c478bd9Sstevel@tonic-gate 				 */
83777c478bd9Sstevel@tonic-gate 				/* FALLTHROUGH */
83787c478bd9Sstevel@tonic-gate 			case NFS4_CHKSEQ_BAD:
83791b300de9Sjwahlig 				*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
83807c478bd9Sstevel@tonic-gate 				goto end;
83817c478bd9Sstevel@tonic-gate 			case NFS4_CHKSEQ_REPLAY:
83827c478bd9Sstevel@tonic-gate 				/* This is a duplicate LOCK request */
83837c478bd9Sstevel@tonic-gate 				dup_lock = TRUE;
83847c478bd9Sstevel@tonic-gate 
83857c478bd9Sstevel@tonic-gate 				/*
83867c478bd9Sstevel@tonic-gate 				 * For a duplicate we do not want to
83877c478bd9Sstevel@tonic-gate 				 * create a new lockowner as it should
83887c478bd9Sstevel@tonic-gate 				 * already exist.
83897c478bd9Sstevel@tonic-gate 				 * Turn off the lockowner create flag.
83907c478bd9Sstevel@tonic-gate 				 */
83917c478bd9Sstevel@tonic-gate 				lcreate = FALSE;
83927c478bd9Sstevel@tonic-gate 			}
83937c478bd9Sstevel@tonic-gate 			break;
83947c478bd9Sstevel@tonic-gate 		}
83957c478bd9Sstevel@tonic-gate 
83967c478bd9Sstevel@tonic-gate 		lo = rfs4_findlockowner(&olo->lock_owner, &lcreate);
83977c478bd9Sstevel@tonic-gate 		if (lo == NULL) {
83987c478bd9Sstevel@tonic-gate 			NFS4_DEBUG(rfs4_debug,
83991b300de9Sjwahlig 			    (CE_NOTE, "rfs4_op_lock: no lock owner"));
84007c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_RESOURCE;
84017c478bd9Sstevel@tonic-gate 			goto end;
84027c478bd9Sstevel@tonic-gate 		}
84037c478bd9Sstevel@tonic-gate 
84047c478bd9Sstevel@tonic-gate 		lsp = rfs4_findlo_state_by_owner(lo, sp, &create);
84057c478bd9Sstevel@tonic-gate 		if (lsp == NULL) {
84067c478bd9Sstevel@tonic-gate 			rfs4_update_lease(sp->owner->client);
84077c478bd9Sstevel@tonic-gate 			/*
84087c478bd9Sstevel@tonic-gate 			 * Only update theh open_seqid if this is not
84097c478bd9Sstevel@tonic-gate 			 * a duplicate request
84107c478bd9Sstevel@tonic-gate 			 */
84117c478bd9Sstevel@tonic-gate 			if (dup_lock == FALSE) {
84127c478bd9Sstevel@tonic-gate 				rfs4_update_open_sequence(sp->owner);
84137c478bd9Sstevel@tonic-gate 			}
84147c478bd9Sstevel@tonic-gate 
84157c478bd9Sstevel@tonic-gate 			NFS4_DEBUG(rfs4_debug,
84161b300de9Sjwahlig 			    (CE_NOTE, "rfs4_op_lock: no state"));
84177c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_SERVERFAULT;
84187c478bd9Sstevel@tonic-gate 			rfs4_update_open_resp(sp->owner, resop, NULL);
84197c478bd9Sstevel@tonic-gate 			rfs4_lockowner_rele(lo);
84207c478bd9Sstevel@tonic-gate 			goto end;
84217c478bd9Sstevel@tonic-gate 		}
84227c478bd9Sstevel@tonic-gate 
84237c478bd9Sstevel@tonic-gate 		/*
84247c478bd9Sstevel@tonic-gate 		 * This is the new_lock_owner branch and the client is
84257c478bd9Sstevel@tonic-gate 		 * supposed to be associating a new lock_owner with
84267c478bd9Sstevel@tonic-gate 		 * the open file at this point.  If we find that a
84277c478bd9Sstevel@tonic-gate 		 * lock_owner/state association already exists and a
84287c478bd9Sstevel@tonic-gate 		 * successful LOCK request was returned to the client,
84297c478bd9Sstevel@tonic-gate 		 * an error is returned to the client since this is
84307c478bd9Sstevel@tonic-gate 		 * not appropriate.  The client should be using the
84317c478bd9Sstevel@tonic-gate 		 * existing lock_owner branch.
84327c478bd9Sstevel@tonic-gate 		 */
84337c478bd9Sstevel@tonic-gate 		if (dup_lock == FALSE && create == FALSE) {
84347c478bd9Sstevel@tonic-gate 			if (lsp->lock_completed == TRUE) {
84357c478bd9Sstevel@tonic-gate 				*cs->statusp =
84361b300de9Sjwahlig 				    resp->status = NFS4ERR_BAD_SEQID;
84377c478bd9Sstevel@tonic-gate 				rfs4_lockowner_rele(lo);
84387c478bd9Sstevel@tonic-gate 				goto end;
84397c478bd9Sstevel@tonic-gate 			}
84407c478bd9Sstevel@tonic-gate 		}
84417c478bd9Sstevel@tonic-gate 
84427c478bd9Sstevel@tonic-gate 		rfs4_update_lease(sp->owner->client);
84437c478bd9Sstevel@tonic-gate 
84447c478bd9Sstevel@tonic-gate 		/*
84457c478bd9Sstevel@tonic-gate 		 * Only update theh open_seqid if this is not
84467c478bd9Sstevel@tonic-gate 		 * a duplicate request
84477c478bd9Sstevel@tonic-gate 		 */
84487c478bd9Sstevel@tonic-gate 		if (dup_lock == FALSE) {
84497c478bd9Sstevel@tonic-gate 			rfs4_update_open_sequence(sp->owner);
84507c478bd9Sstevel@tonic-gate 		}
84517c478bd9Sstevel@tonic-gate 
84527c478bd9Sstevel@tonic-gate 		/*
84537c478bd9Sstevel@tonic-gate 		 * If this is a duplicate lock request, just copy the
84547c478bd9Sstevel@tonic-gate 		 * previously saved reply and return.
84557c478bd9Sstevel@tonic-gate 		 */
84567c478bd9Sstevel@tonic-gate 		if (dup_lock == TRUE) {
84577c478bd9Sstevel@tonic-gate 			/* verify that lock_seqid's match */
84587c478bd9Sstevel@tonic-gate 			if (lsp->seqid != olo->lock_seqid) {
84597c478bd9Sstevel@tonic-gate 				NFS4_DEBUG(rfs4_debug,
84601b300de9Sjwahlig 				    (CE_NOTE, "rfs4_op_lock: Dup-Lock seqid bad"
84611b300de9Sjwahlig 				    "lsp->seqid=%d old->seqid=%d",
84621b300de9Sjwahlig 				    lsp->seqid, olo->lock_seqid));
84637c478bd9Sstevel@tonic-gate 				*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
84647c478bd9Sstevel@tonic-gate 			} else {
84657c478bd9Sstevel@tonic-gate 				rfs4_copy_reply(resop, lsp->reply);
84667c478bd9Sstevel@tonic-gate 				/*
84677c478bd9Sstevel@tonic-gate 				 * Make sure to copy the just
84687c478bd9Sstevel@tonic-gate 				 * retrieved reply status into the
84697c478bd9Sstevel@tonic-gate 				 * overall compound status
84707c478bd9Sstevel@tonic-gate 				 */
84717c478bd9Sstevel@tonic-gate 				*cs->statusp = resp->status;
84727c478bd9Sstevel@tonic-gate 			}
84737c478bd9Sstevel@tonic-gate 			rfs4_lockowner_rele(lo);
84747c478bd9Sstevel@tonic-gate 			goto end;
84757c478bd9Sstevel@tonic-gate 		}
84767c478bd9Sstevel@tonic-gate 
84777c478bd9Sstevel@tonic-gate 		rfs4_dbe_lock(lsp->dbe);
84787c478bd9Sstevel@tonic-gate 
84797c478bd9Sstevel@tonic-gate 		/* Make sure to update the lock sequence id */
84807c478bd9Sstevel@tonic-gate 		lsp->seqid = olo->lock_seqid;
84817c478bd9Sstevel@tonic-gate 
84827c478bd9Sstevel@tonic-gate 		NFS4_DEBUG(rfs4_debug,
84831b300de9Sjwahlig 		    (CE_NOTE, "Lock seqid established as %d", lsp->seqid));
84847c478bd9Sstevel@tonic-gate 
84857c478bd9Sstevel@tonic-gate 		/*
84867c478bd9Sstevel@tonic-gate 		 * This is used to signify the newly created lockowner
84877c478bd9Sstevel@tonic-gate 		 * stateid and its sequence number.  The checks for
84887c478bd9Sstevel@tonic-gate 		 * sequence number and increment don't occur on the
84897c478bd9Sstevel@tonic-gate 		 * very first lock request for a lockowner.
84907c478bd9Sstevel@tonic-gate 		 */
84917c478bd9Sstevel@tonic-gate 		lsp->skip_seqid_check = TRUE;
84927c478bd9Sstevel@tonic-gate 
84937c478bd9Sstevel@tonic-gate 		/* hold off other access to lsp while we tinker */
84947c478bd9Sstevel@tonic-gate 		rfs4_sw_enter(&lsp->ls_sw);
84957c478bd9Sstevel@tonic-gate 		ls_sw_held = TRUE;
84967c478bd9Sstevel@tonic-gate 
84977c478bd9Sstevel@tonic-gate 		rfs4_dbe_unlock(lsp->dbe);
84987c478bd9Sstevel@tonic-gate 
84997c478bd9Sstevel@tonic-gate 		rfs4_lockowner_rele(lo);
85007c478bd9Sstevel@tonic-gate 	} else {
85017c478bd9Sstevel@tonic-gate 		stateid = &args->locker.locker4_u.lock_owner.lock_stateid;
85027c478bd9Sstevel@tonic-gate 		/* get lsp and hold the lock on the underlying file struct */
85037c478bd9Sstevel@tonic-gate 		if ((status = rfs4_get_lo_state(stateid, &lsp, TRUE))
85047c478bd9Sstevel@tonic-gate 		    != NFS4_OK) {
85057c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = status;
8506*f3b585ceSsamf 			DTRACE_NFSV4_2(op__lock__done, struct compound_state *,
8507*f3b585ceSsamf 			    cs, LOCK4res *, resp);
85087c478bd9Sstevel@tonic-gate 			return;
85097c478bd9Sstevel@tonic-gate 		}
85107c478bd9Sstevel@tonic-gate 		create = FALSE;	/* We didn't create lsp */
85117c478bd9Sstevel@tonic-gate 
85127c478bd9Sstevel@tonic-gate 		/* Ensure specified filehandle matches */
85137c478bd9Sstevel@tonic-gate 		if (cs->vp != lsp->state->finfo->vp) {
85147c478bd9Sstevel@tonic-gate 			rfs4_lo_state_rele(lsp, TRUE);
85157c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
8516*f3b585ceSsamf 			DTRACE_NFSV4_2(op__lock__done, struct compound_state *,
8517*f3b585ceSsamf 			    cs, LOCK4res *, resp);
85187c478bd9Sstevel@tonic-gate 			return;
85197c478bd9Sstevel@tonic-gate 		}
85207c478bd9Sstevel@tonic-gate 
85217c478bd9Sstevel@tonic-gate 		/* hold off other access to lsp while we tinker */
85227c478bd9Sstevel@tonic-gate 		rfs4_sw_enter(&lsp->ls_sw);
85237c478bd9Sstevel@tonic-gate 		ls_sw_held = TRUE;
85247c478bd9Sstevel@tonic-gate 
85257c478bd9Sstevel@tonic-gate 		switch (rfs4_check_lo_stateid_seqid(lsp, stateid)) {
85267c478bd9Sstevel@tonic-gate 		/*
85277c478bd9Sstevel@tonic-gate 		 * The stateid looks like it was okay (expected to be
85287c478bd9Sstevel@tonic-gate 		 * the next one)
85297c478bd9Sstevel@tonic-gate 		 */
85307c478bd9Sstevel@tonic-gate 		case NFS4_CHECK_STATEID_OKAY:
85317c478bd9Sstevel@tonic-gate 			/*
85327c478bd9Sstevel@tonic-gate 			 * The sequence id is now checked.  Determine
85337c478bd9Sstevel@tonic-gate 			 * if this is a replay or if it is in the
85347c478bd9Sstevel@tonic-gate 			 * expected (next) sequence.  In the case of a
85357c478bd9Sstevel@tonic-gate 			 * replay, there are two replay conditions
85367c478bd9Sstevel@tonic-gate 			 * that may occur.  The first is the normal
85377c478bd9Sstevel@tonic-gate 			 * condition where a LOCK is done with a
85387c478bd9Sstevel@tonic-gate 			 * NFS4_OK response and the stateid is
85397c478bd9Sstevel@tonic-gate 			 * updated.  That case is handled below when
85407c478bd9Sstevel@tonic-gate 			 * the stateid is identified as a REPLAY.  The
85417c478bd9Sstevel@tonic-gate 			 * second is the case where an error is
85427c478bd9Sstevel@tonic-gate 			 * returned, like NFS4ERR_DENIED, and the
85437c478bd9Sstevel@tonic-gate 			 * sequence number is updated but the stateid
85447c478bd9Sstevel@tonic-gate 			 * is not updated.  This second case is dealt
85457c478bd9Sstevel@tonic-gate 			 * with here.  So it may seem odd that the
85467c478bd9Sstevel@tonic-gate 			 * stateid is okay but the sequence id is a
85477c478bd9Sstevel@tonic-gate 			 * replay but it is okay.
85487c478bd9Sstevel@tonic-gate 			 */
85497c478bd9Sstevel@tonic-gate 			switch (rfs4_check_lock_seqid(
85501b300de9Sjwahlig 			    args->locker.locker4_u.lock_owner.lock_seqid,
85511b300de9Sjwahlig 			    lsp, resop)) {
85527c478bd9Sstevel@tonic-gate 			case NFS4_CHKSEQ_REPLAY:
85537c478bd9Sstevel@tonic-gate 				if (resp->status != NFS4_OK) {
85547c478bd9Sstevel@tonic-gate 					/*
85557c478bd9Sstevel@tonic-gate 					 * Here is our replay and need
85567c478bd9Sstevel@tonic-gate 					 * to verify that the last
85577c478bd9Sstevel@tonic-gate 					 * response was an error.
85587c478bd9Sstevel@tonic-gate 					 */
85597c478bd9Sstevel@tonic-gate 					*cs->statusp = resp->status;
85607c478bd9Sstevel@tonic-gate 					goto end;
85617c478bd9Sstevel@tonic-gate 				}
85627c478bd9Sstevel@tonic-gate 				/*
85637c478bd9Sstevel@tonic-gate 				 * This is done since the sequence id
85647c478bd9Sstevel@tonic-gate 				 * looked like a replay but it didn't
85657c478bd9Sstevel@tonic-gate 				 * pass our check so a BAD_SEQID is
85667c478bd9Sstevel@tonic-gate 				 * returned as a result.
85677c478bd9Sstevel@tonic-gate 				 */
85687c478bd9Sstevel@tonic-gate 				/*FALLTHROUGH*/
85697c478bd9Sstevel@tonic-gate 			case NFS4_CHKSEQ_BAD:
85701b300de9Sjwahlig 				*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
85717c478bd9Sstevel@tonic-gate 				goto end;
85727c478bd9Sstevel@tonic-gate 			case NFS4_CHKSEQ_OKAY:
85737c478bd9Sstevel@tonic-gate 				/* Everything looks okay move ahead */
85747c478bd9Sstevel@tonic-gate 				break;
85757c478bd9Sstevel@tonic-gate 			}
85767c478bd9Sstevel@tonic-gate 			break;
85777c478bd9Sstevel@tonic-gate 		case NFS4_CHECK_STATEID_OLD:
85787c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
85797c478bd9Sstevel@tonic-gate 			goto end;
85807c478bd9Sstevel@tonic-gate 		case NFS4_CHECK_STATEID_BAD:
85817c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
85827c478bd9Sstevel@tonic-gate 			goto end;
85837c478bd9Sstevel@tonic-gate 		case NFS4_CHECK_STATEID_EXPIRED:
85847c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_EXPIRED;
85857c478bd9Sstevel@tonic-gate 			goto end;
85867c478bd9Sstevel@tonic-gate 		case NFS4_CHECK_STATEID_CLOSED:
85877c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
85887c478bd9Sstevel@tonic-gate 			goto end;
85897c478bd9Sstevel@tonic-gate 		case NFS4_CHECK_STATEID_REPLAY:
85907c478bd9Sstevel@tonic-gate 			switch (rfs4_check_lock_seqid(
85911b300de9Sjwahlig 			    args->locker.locker4_u.lock_owner.lock_seqid,
85921b300de9Sjwahlig 			    lsp, resop)) {
85937c478bd9Sstevel@tonic-gate 			case NFS4_CHKSEQ_OKAY:
85947c478bd9Sstevel@tonic-gate 				/*
85957c478bd9Sstevel@tonic-gate 				 * This is a replayed stateid; if
85967c478bd9Sstevel@tonic-gate 				 * seqid matches the next expected,
85977c478bd9Sstevel@tonic-gate 				 * then client is using wrong seqid.
85987c478bd9Sstevel@tonic-gate 				 */
85997c478bd9Sstevel@tonic-gate 			case NFS4_CHKSEQ_BAD:
86001b300de9Sjwahlig 				*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
86017c478bd9Sstevel@tonic-gate 				goto end;
86027c478bd9Sstevel@tonic-gate 			case NFS4_CHKSEQ_REPLAY:
86037c478bd9Sstevel@tonic-gate 				rfs4_update_lease(lsp->locker->client);
86047c478bd9Sstevel@tonic-gate 				*cs->statusp = status = resp->status;
86057c478bd9Sstevel@tonic-gate 				goto end;
86067c478bd9Sstevel@tonic-gate 			}
86077c478bd9Sstevel@tonic-gate 			break;
86087c478bd9Sstevel@tonic-gate 		default:
86097c478bd9Sstevel@tonic-gate 			ASSERT(FALSE);
86107c478bd9Sstevel@tonic-gate 			break;
86117c478bd9Sstevel@tonic-gate 		}
86127c478bd9Sstevel@tonic-gate 
86137c478bd9Sstevel@tonic-gate 		rfs4_update_lock_sequence(lsp);
86147c478bd9Sstevel@tonic-gate 		rfs4_update_lease(lsp->locker->client);
86157c478bd9Sstevel@tonic-gate 	}
86167c478bd9Sstevel@tonic-gate 
86177c478bd9Sstevel@tonic-gate 	/*
86187c478bd9Sstevel@tonic-gate 	 * NFS4 only allows locking on regular files, so
86197c478bd9Sstevel@tonic-gate 	 * verify type of object.
86207c478bd9Sstevel@tonic-gate 	 */
86217c478bd9Sstevel@tonic-gate 	if (cs->vp->v_type != VREG) {
86227c478bd9Sstevel@tonic-gate 		if (cs->vp->v_type == VDIR)
86237c478bd9Sstevel@tonic-gate 			status = NFS4ERR_ISDIR;
86247c478bd9Sstevel@tonic-gate 		else
86257c478bd9Sstevel@tonic-gate 			status = NFS4ERR_INVAL;
86267c478bd9Sstevel@tonic-gate 		goto out;
86277c478bd9Sstevel@tonic-gate 	}
86287c478bd9Sstevel@tonic-gate 
86297c478bd9Sstevel@tonic-gate 	cp = lsp->state->owner->client;
86307c478bd9Sstevel@tonic-gate 
86317c478bd9Sstevel@tonic-gate 	if (rfs4_clnt_in_grace(cp) && !args->reclaim) {
86327c478bd9Sstevel@tonic-gate 		status = NFS4ERR_GRACE;
86337c478bd9Sstevel@tonic-gate 		goto out;
86347c478bd9Sstevel@tonic-gate 	}
86357c478bd9Sstevel@tonic-gate 
86367c478bd9Sstevel@tonic-gate 	if (rfs4_clnt_in_grace(cp) && args->reclaim && !cp->can_reclaim) {
86377c478bd9Sstevel@tonic-gate 		status = NFS4ERR_NO_GRACE;
86387c478bd9Sstevel@tonic-gate 		goto out;
86397c478bd9Sstevel@tonic-gate 	}
86407c478bd9Sstevel@tonic-gate 
86417c478bd9Sstevel@tonic-gate 	if (!rfs4_clnt_in_grace(cp) && args->reclaim) {
86427c478bd9Sstevel@tonic-gate 		status = NFS4ERR_NO_GRACE;
86437c478bd9Sstevel@tonic-gate 		goto out;
86447c478bd9Sstevel@tonic-gate 	}
86457c478bd9Sstevel@tonic-gate 
86467c478bd9Sstevel@tonic-gate 	if (lsp->state->finfo->dinfo->dtype == OPEN_DELEGATE_WRITE)
86477c478bd9Sstevel@tonic-gate 		cs->deleg = TRUE;
86487c478bd9Sstevel@tonic-gate 
86497c478bd9Sstevel@tonic-gate 	status = rfs4_do_lock(lsp, args->locktype,
86501b300de9Sjwahlig 	    args->locker.locker4_u.lock_owner.lock_seqid,
86511b300de9Sjwahlig 	    args->offset, args->length, cs->cr, resop);
86527c478bd9Sstevel@tonic-gate 
86537c478bd9Sstevel@tonic-gate out:
86547c478bd9Sstevel@tonic-gate 	lsp->skip_seqid_check = FALSE;
86557c478bd9Sstevel@tonic-gate 
86567c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = status;
86577c478bd9Sstevel@tonic-gate 
86587c478bd9Sstevel@tonic-gate 	if (status == NFS4_OK) {
86597c478bd9Sstevel@tonic-gate 		resp->LOCK4res_u.lock_stateid = lsp->lockid.stateid;
86607c478bd9Sstevel@tonic-gate 		lsp->lock_completed = TRUE;
86617c478bd9Sstevel@tonic-gate 	}
86627c478bd9Sstevel@tonic-gate 	/*
86637c478bd9Sstevel@tonic-gate 	 * Only update the "OPEN" response here if this was a new
86647c478bd9Sstevel@tonic-gate 	 * lock_owner
86657c478bd9Sstevel@tonic-gate 	 */
86667c478bd9Sstevel@tonic-gate 	if (sp)
86677c478bd9Sstevel@tonic-gate 		rfs4_update_open_resp(sp->owner, resop, NULL);
86687c478bd9Sstevel@tonic-gate 
86697c478bd9Sstevel@tonic-gate 	rfs4_update_lock_resp(lsp, resop);
86707c478bd9Sstevel@tonic-gate 
86717c478bd9Sstevel@tonic-gate end:
86727c478bd9Sstevel@tonic-gate 	if (lsp) {
86737c478bd9Sstevel@tonic-gate 		if (ls_sw_held)
86747c478bd9Sstevel@tonic-gate 			rfs4_sw_exit(&lsp->ls_sw);
86757c478bd9Sstevel@tonic-gate 		/*
86767c478bd9Sstevel@tonic-gate 		 * If an sp obtained, then the lsp does not represent
86777c478bd9Sstevel@tonic-gate 		 * a lock on the file struct.
86787c478bd9Sstevel@tonic-gate 		 */
86797c478bd9Sstevel@tonic-gate 		if (sp != NULL)
86807c478bd9Sstevel@tonic-gate 			rfs4_lo_state_rele(lsp, FALSE);
86817c478bd9Sstevel@tonic-gate 		else
86827c478bd9Sstevel@tonic-gate 			rfs4_lo_state_rele(lsp, TRUE);
86837c478bd9Sstevel@tonic-gate 	}
86847c478bd9Sstevel@tonic-gate 	if (sp) {
86857c478bd9Sstevel@tonic-gate 		rfs4_sw_exit(&sp->owner->oo_sw);
86867c478bd9Sstevel@tonic-gate 		rfs4_state_rele(sp);
86877c478bd9Sstevel@tonic-gate 	}
8688*f3b585ceSsamf 
8689*f3b585ceSsamf 	DTRACE_NFSV4_2(op__lock__done, struct compound_state *, cs,
8690*f3b585ceSsamf 	    LOCK4res *, resp);
86917c478bd9Sstevel@tonic-gate }
86927c478bd9Sstevel@tonic-gate 
86937c478bd9Sstevel@tonic-gate /* free function for LOCK/LOCKT */
86947c478bd9Sstevel@tonic-gate static void
86957c478bd9Sstevel@tonic-gate lock_denied_free(nfs_resop4 *resop)
86967c478bd9Sstevel@tonic-gate {
86977c478bd9Sstevel@tonic-gate 	LOCK4denied *dp = NULL;
86987c478bd9Sstevel@tonic-gate 
86997c478bd9Sstevel@tonic-gate 	switch (resop->resop) {
87007c478bd9Sstevel@tonic-gate 	case OP_LOCK:
87017c478bd9Sstevel@tonic-gate 		if (resop->nfs_resop4_u.oplock.status == NFS4ERR_DENIED)
87027c478bd9Sstevel@tonic-gate 			dp = &resop->nfs_resop4_u.oplock.LOCK4res_u.denied;
87037c478bd9Sstevel@tonic-gate 		break;
87047c478bd9Sstevel@tonic-gate 	case OP_LOCKT:
87057c478bd9Sstevel@tonic-gate 		if (resop->nfs_resop4_u.oplockt.status == NFS4ERR_DENIED)
87067c478bd9Sstevel@tonic-gate 			dp = &resop->nfs_resop4_u.oplockt.denied;
87077c478bd9Sstevel@tonic-gate 		break;
87087c478bd9Sstevel@tonic-gate 	default:
87097c478bd9Sstevel@tonic-gate 		break;
87107c478bd9Sstevel@tonic-gate 	}
87117c478bd9Sstevel@tonic-gate 
87127c478bd9Sstevel@tonic-gate 	if (dp)
87137c478bd9Sstevel@tonic-gate 		kmem_free(dp->owner.owner_val, dp->owner.owner_len);
87147c478bd9Sstevel@tonic-gate }
87157c478bd9Sstevel@tonic-gate 
87167c478bd9Sstevel@tonic-gate /*ARGSUSED*/
87177c478bd9Sstevel@tonic-gate void
87187c478bd9Sstevel@tonic-gate rfs4_op_locku(nfs_argop4 *argop, nfs_resop4 *resop,
87197c478bd9Sstevel@tonic-gate 	    struct svc_req *req, struct compound_state *cs)
87207c478bd9Sstevel@tonic-gate {
87217c478bd9Sstevel@tonic-gate 	LOCKU4args *args = &argop->nfs_argop4_u.oplocku;
87227c478bd9Sstevel@tonic-gate 	LOCKU4res *resp = &resop->nfs_resop4_u.oplocku;
87237c478bd9Sstevel@tonic-gate 	nfsstat4 status;
87247c478bd9Sstevel@tonic-gate 	stateid4 *stateid = &args->lock_stateid;
87257c478bd9Sstevel@tonic-gate 	rfs4_lo_state_t *lsp;
87267c478bd9Sstevel@tonic-gate 
8727*f3b585ceSsamf 	DTRACE_NFSV4_2(op__locku__start, struct compound_state *, cs,
8728*f3b585ceSsamf 	    LOCKU4args *, args);
8729*f3b585ceSsamf 
87307c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
87317c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
8732*f3b585ceSsamf 		DTRACE_NFSV4_2(op__locku__done, struct compound_state *, cs,
8733*f3b585ceSsamf 		    LOCKU4res *, resp);
87347c478bd9Sstevel@tonic-gate 		return;
87357c478bd9Sstevel@tonic-gate 	}
87367c478bd9Sstevel@tonic-gate 
87377c478bd9Sstevel@tonic-gate 	if ((status = rfs4_get_lo_state(stateid, &lsp, TRUE)) != NFS4_OK) {
87387c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = status;
8739*f3b585ceSsamf 		DTRACE_NFSV4_2(op__locku__done, struct compound_state *, cs,
8740*f3b585ceSsamf 		    LOCKU4res *, resp);
87417c478bd9Sstevel@tonic-gate 		return;
87427c478bd9Sstevel@tonic-gate 	}
87437c478bd9Sstevel@tonic-gate 
87447c478bd9Sstevel@tonic-gate 	/* Ensure specified filehandle matches */
87457c478bd9Sstevel@tonic-gate 	if (cs->vp != lsp->state->finfo->vp) {
87467c478bd9Sstevel@tonic-gate 		rfs4_lo_state_rele(lsp, TRUE);
87477c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
8748*f3b585ceSsamf 		DTRACE_NFSV4_2(op__locku__done, struct compound_state *, cs,
8749*f3b585ceSsamf 		    LOCKU4res *, resp);
87507c478bd9Sstevel@tonic-gate 		return;
87517c478bd9Sstevel@tonic-gate 	}
87527c478bd9Sstevel@tonic-gate 
87537c478bd9Sstevel@tonic-gate 	/* hold off other access to lsp while we tinker */
87547c478bd9Sstevel@tonic-gate 	rfs4_sw_enter(&lsp->ls_sw);
87557c478bd9Sstevel@tonic-gate 
87567c478bd9Sstevel@tonic-gate 	switch (rfs4_check_lo_stateid_seqid(lsp, stateid)) {
87577c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_OKAY:
87587c478bd9Sstevel@tonic-gate 		if (rfs4_check_lock_seqid(args->seqid, lsp, resop)
87597c478bd9Sstevel@tonic-gate 		    != NFS4_CHKSEQ_OKAY) {
87607c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
87617c478bd9Sstevel@tonic-gate 			goto end;
87627c478bd9Sstevel@tonic-gate 		}
87637c478bd9Sstevel@tonic-gate 		break;
87647c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_OLD:
87657c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
87667c478bd9Sstevel@tonic-gate 		goto end;
87677c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_BAD:
87687c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
87697c478bd9Sstevel@tonic-gate 		goto end;
87707c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_EXPIRED:
87717c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
87727c478bd9Sstevel@tonic-gate 		goto end;
87737c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_CLOSED:
87747c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
87757c478bd9Sstevel@tonic-gate 		goto end;
87767c478bd9Sstevel@tonic-gate 	case NFS4_CHECK_STATEID_REPLAY:
87777c478bd9Sstevel@tonic-gate 		switch (rfs4_check_lock_seqid(args->seqid, lsp, resop)) {
87787c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_OKAY:
87797c478bd9Sstevel@tonic-gate 				/*
87807c478bd9Sstevel@tonic-gate 				 * This is a replayed stateid; if
87817c478bd9Sstevel@tonic-gate 				 * seqid matches the next expected,
87827c478bd9Sstevel@tonic-gate 				 * then client is using wrong seqid.
87837c478bd9Sstevel@tonic-gate 				 */
87847c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_BAD:
87851b300de9Sjwahlig 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
87867c478bd9Sstevel@tonic-gate 			goto end;
87877c478bd9Sstevel@tonic-gate 		case NFS4_CHKSEQ_REPLAY:
87887c478bd9Sstevel@tonic-gate 			rfs4_update_lease(lsp->locker->client);
87897c478bd9Sstevel@tonic-gate 			*cs->statusp = status = resp->status;
87907c478bd9Sstevel@tonic-gate 			goto end;
87917c478bd9Sstevel@tonic-gate 		}
87927c478bd9Sstevel@tonic-gate 		break;
87937c478bd9Sstevel@tonic-gate 	default:
87947c478bd9Sstevel@tonic-gate 		ASSERT(FALSE);
87957c478bd9Sstevel@tonic-gate 		break;
87967c478bd9Sstevel@tonic-gate 	}
87977c478bd9Sstevel@tonic-gate 
87987c478bd9Sstevel@tonic-gate 	rfs4_update_lock_sequence(lsp);
87997c478bd9Sstevel@tonic-gate 	rfs4_update_lease(lsp->locker->client);
88007c478bd9Sstevel@tonic-gate 
88017c478bd9Sstevel@tonic-gate 	/*
88027c478bd9Sstevel@tonic-gate 	 * NFS4 only allows locking on regular files, so
88037c478bd9Sstevel@tonic-gate 	 * verify type of object.
88047c478bd9Sstevel@tonic-gate 	 */
88057c478bd9Sstevel@tonic-gate 	if (cs->vp->v_type != VREG) {
88067c478bd9Sstevel@tonic-gate 		if (cs->vp->v_type == VDIR)
88077c478bd9Sstevel@tonic-gate 			status = NFS4ERR_ISDIR;
88087c478bd9Sstevel@tonic-gate 		else
88097c478bd9Sstevel@tonic-gate 			status = NFS4ERR_INVAL;
88107c478bd9Sstevel@tonic-gate 		goto out;
88117c478bd9Sstevel@tonic-gate 	}
88127c478bd9Sstevel@tonic-gate 
88137c478bd9Sstevel@tonic-gate 	if (rfs4_clnt_in_grace(lsp->state->owner->client)) {
88147c478bd9Sstevel@tonic-gate 		status = NFS4ERR_GRACE;
88157c478bd9Sstevel@tonic-gate 		goto out;
88167c478bd9Sstevel@tonic-gate 	}
88177c478bd9Sstevel@tonic-gate 
88187c478bd9Sstevel@tonic-gate 	status = rfs4_do_lock(lsp, args->locktype,
88191b300de9Sjwahlig 	    args->seqid, args->offset, args->length, cs->cr, resop);
88207c478bd9Sstevel@tonic-gate 
88217c478bd9Sstevel@tonic-gate out:
88227c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status = status;
88237c478bd9Sstevel@tonic-gate 
88247c478bd9Sstevel@tonic-gate 	if (status == NFS4_OK)
88257c478bd9Sstevel@tonic-gate 		resp->lock_stateid = lsp->lockid.stateid;
88267c478bd9Sstevel@tonic-gate 
88277c478bd9Sstevel@tonic-gate 	rfs4_update_lock_resp(lsp, resop);
88287c478bd9Sstevel@tonic-gate 
88297c478bd9Sstevel@tonic-gate end:
88307c478bd9Sstevel@tonic-gate 	rfs4_sw_exit(&lsp->ls_sw);
88317c478bd9Sstevel@tonic-gate 	rfs4_lo_state_rele(lsp, TRUE);
8832*f3b585ceSsamf 
8833*f3b585ceSsamf 	DTRACE_NFSV4_2(op__locku__done, struct compound_state *, cs,
8834*f3b585ceSsamf 	    LOCKU4res *, resp);
88357c478bd9Sstevel@tonic-gate }
88367c478bd9Sstevel@tonic-gate 
88377c478bd9Sstevel@tonic-gate /*
88387c478bd9Sstevel@tonic-gate  * LOCKT is a best effort routine, the client can not be guaranteed that
88397c478bd9Sstevel@tonic-gate  * the status return is still in effect by the time the reply is received.
88407c478bd9Sstevel@tonic-gate  * They are numerous race conditions in this routine, but we are not required
88417c478bd9Sstevel@tonic-gate  * and can not be accurate.
88427c478bd9Sstevel@tonic-gate  */
88437c478bd9Sstevel@tonic-gate /*ARGSUSED*/
88447c478bd9Sstevel@tonic-gate void
88457c478bd9Sstevel@tonic-gate rfs4_op_lockt(nfs_argop4 *argop, nfs_resop4 *resop,
88467c478bd9Sstevel@tonic-gate 	    struct svc_req *req, struct compound_state *cs)
88477c478bd9Sstevel@tonic-gate {
88487c478bd9Sstevel@tonic-gate 	LOCKT4args *args = &argop->nfs_argop4_u.oplockt;
88497c478bd9Sstevel@tonic-gate 	LOCKT4res *resp = &resop->nfs_resop4_u.oplockt;
88507c478bd9Sstevel@tonic-gate 	rfs4_lockowner_t *lo;
88517c478bd9Sstevel@tonic-gate 	rfs4_client_t *cp;
88527c478bd9Sstevel@tonic-gate 	bool_t create = FALSE;
88537c478bd9Sstevel@tonic-gate 	struct flock64 flk;
88547c478bd9Sstevel@tonic-gate 	int error;
88557c478bd9Sstevel@tonic-gate 	int flag = FREAD | FWRITE;
88567c478bd9Sstevel@tonic-gate 	int ltype;
88577c478bd9Sstevel@tonic-gate 	length4 posix_length;
88587c478bd9Sstevel@tonic-gate 	sysid_t sysid;
88597c478bd9Sstevel@tonic-gate 	pid_t pid;
88607c478bd9Sstevel@tonic-gate 
8861*f3b585ceSsamf 	DTRACE_NFSV4_2(op__lockt__start, struct compound_state *, cs,
8862*f3b585ceSsamf 	    LOCKT4args *, args);
8863*f3b585ceSsamf 
88647c478bd9Sstevel@tonic-gate 	if (cs->vp == NULL) {
88657c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
8866*f3b585ceSsamf 		goto out;
88677c478bd9Sstevel@tonic-gate 	}
88687c478bd9Sstevel@tonic-gate 
88697c478bd9Sstevel@tonic-gate 	/*
88707c478bd9Sstevel@tonic-gate 	 * NFS4 only allows locking on regular files, so
88717c478bd9Sstevel@tonic-gate 	 * verify type of object.
88727c478bd9Sstevel@tonic-gate 	 */
88737c478bd9Sstevel@tonic-gate 	if (cs->vp->v_type != VREG) {
88747c478bd9Sstevel@tonic-gate 		if (cs->vp->v_type == VDIR)
88757c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status = NFS4ERR_ISDIR;
88767c478bd9Sstevel@tonic-gate 		else
88777c478bd9Sstevel@tonic-gate 			*cs->statusp = resp->status =  NFS4ERR_INVAL;
8878*f3b585ceSsamf 		goto out;
88797c478bd9Sstevel@tonic-gate 	}
88807c478bd9Sstevel@tonic-gate 
88817c478bd9Sstevel@tonic-gate 	/*
88827c478bd9Sstevel@tonic-gate 	 * Check out the clientid to ensure the server knows about it
88837c478bd9Sstevel@tonic-gate 	 * so that we correctly inform the client of a server reboot.
88847c478bd9Sstevel@tonic-gate 	 */
88857c478bd9Sstevel@tonic-gate 	if ((cp = rfs4_findclient_by_id(args->owner.clientid, FALSE))
88867c478bd9Sstevel@tonic-gate 	    == NULL) {
88877c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status =
88881b300de9Sjwahlig 		    rfs4_check_clientid(&args->owner.clientid, 0);
8889*f3b585ceSsamf 		goto out;
88907c478bd9Sstevel@tonic-gate 	}
88917c478bd9Sstevel@tonic-gate 	if (rfs4_lease_expired(cp)) {
88927c478bd9Sstevel@tonic-gate 		rfs4_client_close(cp);
88937c478bd9Sstevel@tonic-gate 		/*
88947c478bd9Sstevel@tonic-gate 		 * Protocol doesn't allow returning NFS4ERR_STALE as
88957c478bd9Sstevel@tonic-gate 		 * other operations do on this check so STALE_CLIENTID
88967c478bd9Sstevel@tonic-gate 		 * is returned instead
88977c478bd9Sstevel@tonic-gate 		 */
88987c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_STALE_CLIENTID;
8899*f3b585ceSsamf 		goto out;
89007c478bd9Sstevel@tonic-gate 	}
89017c478bd9Sstevel@tonic-gate 
89027c478bd9Sstevel@tonic-gate 	if (rfs4_clnt_in_grace(cp)) {
89037c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_GRACE;
8904*f3b585ceSsamf 		goto out;
89057c478bd9Sstevel@tonic-gate 	}
89067c478bd9Sstevel@tonic-gate 	rfs4_client_rele(cp);
89077c478bd9Sstevel@tonic-gate 
89087c478bd9Sstevel@tonic-gate 	resp->status = NFS4_OK;
89097c478bd9Sstevel@tonic-gate 
89107c478bd9Sstevel@tonic-gate 	switch (args->locktype) {
89117c478bd9Sstevel@tonic-gate 	case READ_LT:
89127c478bd9Sstevel@tonic-gate 	case READW_LT:
89137c478bd9Sstevel@tonic-gate 		ltype = F_RDLCK;
89147c478bd9Sstevel@tonic-gate 		break;
89157c478bd9Sstevel@tonic-gate 	case WRITE_LT:
89167c478bd9Sstevel@tonic-gate 	case WRITEW_LT:
89177c478bd9Sstevel@tonic-gate 		ltype = F_WRLCK;
89187c478bd9Sstevel@tonic-gate 		break;
89197c478bd9Sstevel@tonic-gate 	}
89207c478bd9Sstevel@tonic-gate 
89217c478bd9Sstevel@tonic-gate 	posix_length = args->length;
89227c478bd9Sstevel@tonic-gate 	/* Check for zero length. To lock to end of file use all ones for V4 */
89237c478bd9Sstevel@tonic-gate 	if (posix_length == 0) {
89247c478bd9Sstevel@tonic-gate 		*cs->statusp = resp->status = NFS4ERR_INVAL;
8925*f3b585ceSsamf 		goto out;
89267c478bd9Sstevel@tonic-gate 	} else if (posix_length == (length4)(~0)) {
89277c478bd9Sstevel@tonic-gate 		posix_length = 0;	/* Posix to end of file  */
89287c478bd9Sstevel@tonic-gate 	}
89297c478bd9Sstevel@tonic-gate 
89307c478bd9Sstevel@tonic-gate 	/* Find or create a lockowner */
89317c478bd9Sstevel@tonic-gate 	lo = rfs4_findlockowner(&args->owner, &create);
89327c478bd9Sstevel@tonic-gate 
89337c478bd9Sstevel@tonic-gate 	if (lo) {
89347c478bd9Sstevel@tonic-gate 		pid = lo->pid;
89357c478bd9Sstevel@tonic-gate 		if ((resp->status =
89361b300de9Sjwahlig 		    rfs4_client_sysid(lo->client, &sysid)) != NFS4_OK)
8937*f3b585ceSsamf 			goto err;
89387c478bd9Sstevel@tonic-gate 		goto out;
89397c478bd9Sstevel@tonic-gate 	} else {
89407c478bd9Sstevel@tonic-gate 		pid = 0;
89417c478bd9Sstevel@tonic-gate 		sysid = lockt_sysid;
89427c478bd9Sstevel@tonic-gate 	}
89437c478bd9Sstevel@tonic-gate retry:
89447c478bd9Sstevel@tonic-gate 	flk.l_type = ltype;
89457c478bd9Sstevel@tonic-gate 	flk.l_whence = 0;		/* SEEK_SET */
89467c478bd9Sstevel@tonic-gate 	flk.l_start = args->offset;
89477c478bd9Sstevel@tonic-gate 	flk.l_len = posix_length;
89487c478bd9Sstevel@tonic-gate 	flk.l_sysid = sysid;
89497c478bd9Sstevel@tonic-gate 	flk.l_pid = pid;
89507c478bd9Sstevel@tonic-gate 	flag |= F_REMOTELOCK;
89517c478bd9Sstevel@tonic-gate 
89527c478bd9Sstevel@tonic-gate 	LOCK_PRINT(rfs4_debug, "rfs4_op_lockt", F_GETLK, &flk);
89537c478bd9Sstevel@tonic-gate 
89547c478bd9Sstevel@tonic-gate 	/* Note that length4 is uint64_t but l_len and l_start are off64_t */
89557c478bd9Sstevel@tonic-gate 	if (flk.l_len < 0 || flk.l_start < 0) {
89567c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_INVAL;
8957*f3b585ceSsamf 		goto err;
89587c478bd9Sstevel@tonic-gate 	}
89597c478bd9Sstevel@tonic-gate 	error = VOP_FRLOCK(cs->vp, F_GETLK, &flk, flag, (u_offset_t)0,
8960da6c28aaSamw 	    NULL, cs->cr, NULL);
89617c478bd9Sstevel@tonic-gate 
89627c478bd9Sstevel@tonic-gate 	/*
89637c478bd9Sstevel@tonic-gate 	 * N.B. We map error values to nfsv4 errors. This is differrent
89647c478bd9Sstevel@tonic-gate 	 * than puterrno4 routine.
89657c478bd9Sstevel@tonic-gate 	 */
89667c478bd9Sstevel@tonic-gate 	switch (error) {
89677c478bd9Sstevel@tonic-gate 	case 0:
89687c478bd9Sstevel@tonic-gate 		if (flk.l_type == F_UNLCK)
89697c478bd9Sstevel@tonic-gate 			resp->status = NFS4_OK;
89707c478bd9Sstevel@tonic-gate 		else {
89717c478bd9Sstevel@tonic-gate 			if (lock_denied(&resp->denied, &flk) == NFS4ERR_EXPIRED)
89727c478bd9Sstevel@tonic-gate 				goto retry;
89737c478bd9Sstevel@tonic-gate 			resp->status = NFS4ERR_DENIED;
89747c478bd9Sstevel@tonic-gate 		}
89757c478bd9Sstevel@tonic-gate 		break;
89767c478bd9Sstevel@tonic-gate 	case EOVERFLOW:
89777c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_INVAL;
89787c478bd9Sstevel@tonic-gate 		break;
89797c478bd9Sstevel@tonic-gate 	case EINVAL:
89807c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_NOTSUPP;
89817c478bd9Sstevel@tonic-gate 		break;
89827c478bd9Sstevel@tonic-gate 	default:
89837c478bd9Sstevel@tonic-gate 		cmn_err(CE_WARN, "rfs4_op_lockt: unexpected errno (%d)",
89841b300de9Sjwahlig 		    error);
89857c478bd9Sstevel@tonic-gate 		resp->status = NFS4ERR_SERVERFAULT;
89867c478bd9Sstevel@tonic-gate 		break;
89877c478bd9Sstevel@tonic-gate 	}
89887c478bd9Sstevel@tonic-gate 
8989*f3b585ceSsamf err:
89907c478bd9Sstevel@tonic-gate 	if (lo)
89917c478bd9Sstevel@tonic-gate 		rfs4_lockowner_rele(lo);
89927c478bd9Sstevel@tonic-gate 	*cs->statusp = resp->status;
8993*f3b585ceSsamf out:
8994*f3b585ceSsamf 	DTRACE_NFSV4_2(op__lockt__done, struct compound_state *, cs,
8995*f3b585ceSsamf 	    LOCKT4res *, resp);
89967c478bd9Sstevel@tonic-gate }
89977c478bd9Sstevel@tonic-gate 
89987c478bd9Sstevel@tonic-gate static int
89997c478bd9Sstevel@tonic-gate vop_shrlock(vnode_t *vp, int cmd, struct shrlock *sp, int fflags)
90007c478bd9Sstevel@tonic-gate {
90017c478bd9Sstevel@tonic-gate 	int err;
90027c478bd9Sstevel@tonic-gate 
90037c478bd9Sstevel@tonic-gate 	if (cmd == F_UNSHARE && sp->s_deny == 0 && sp->s_access == 0)
90047c478bd9Sstevel@tonic-gate 		return (0);
90057c478bd9Sstevel@tonic-gate 
9006da6c28aaSamw 	err = VOP_SHRLOCK(vp, cmd, sp, fflags, CRED(), NULL);
90077c478bd9Sstevel@tonic-gate 
90087c478bd9Sstevel@tonic-gate 	NFS4_DEBUG(rfs4_shrlock_debug,
90091b300de9Sjwahlig 	    (CE_NOTE, "rfs4_shrlock %s vp=%p acc=%d dny=%d sysid=%d "
9010da6c28aaSamw 	    "pid=%d err=%d\n", cmd == F_UNSHARE ? "UNSHR" : "SHARE",
90111b300de9Sjwahlig 	    (void *) vp, sp->s_access, sp->s_deny, sp->s_sysid, sp->s_pid,
90121b300de9Sjwahlig 	    err));
90137c478bd9Sstevel@tonic-gate 
90147c478bd9Sstevel@tonic-gate 	return (err);
90157c478bd9Sstevel@tonic-gate }
90167c478bd9Sstevel@tonic-gate 
90177c478bd9Sstevel@tonic-gate static int
90187c478bd9Sstevel@tonic-gate rfs4_shrlock(rfs4_state_t *sp, int cmd)
90197c478bd9Sstevel@tonic-gate {
90207c478bd9Sstevel@tonic-gate 	struct shrlock shr;
90217c478bd9Sstevel@tonic-gate 	struct shr_locowner shr_loco;
90227c478bd9Sstevel@tonic-gate 	int fflags;
90237c478bd9Sstevel@tonic-gate 
90247c478bd9Sstevel@tonic-gate 	fflags = shr.s_access = shr.s_deny = 0;
90257c478bd9Sstevel@tonic-gate 
90267c478bd9Sstevel@tonic-gate 	if (sp->share_access & OPEN4_SHARE_ACCESS_READ) {
90277c478bd9Sstevel@tonic-gate 		fflags |= FREAD;
90287c478bd9Sstevel@tonic-gate 		shr.s_access |= F_RDACC;
90297c478bd9Sstevel@tonic-gate 	}
90307c478bd9Sstevel@tonic-gate 	if (sp->share_access & OPEN4_SHARE_ACCESS_WRITE) {
90317c478bd9Sstevel@tonic-gate 		fflags |= FWRITE;
90327c478bd9Sstevel@tonic-gate 		shr.s_access |= F_WRACC;
90337c478bd9Sstevel@tonic-gate 	}
90347c478bd9Sstevel@tonic-gate 	if (sp->share_deny & OPEN4_SHARE_DENY_READ)
90357c478bd9Sstevel@tonic-gate 		shr.s_deny |= F_RDDNY;
90367c478bd9Sstevel@tonic-gate 	if (sp->share_deny & OPEN4_SHARE_DENY_WRITE)
90377c478bd9Sstevel@tonic-gate 		shr.s_deny |= F_WRDNY;
90387c478bd9Sstevel@tonic-gate 
90397c478bd9Sstevel@tonic-gate 	shr.s_pid = rfs4_dbe_getid(sp->owner->dbe);
90407c478bd9Sstevel@tonic-gate 	shr.s_sysid = sp->owner->client->sysidt;
90417c478bd9Sstevel@tonic-gate 	shr_loco.sl_pid = shr.s_pid;
90427c478bd9Sstevel@tonic-gate 	shr_loco.sl_id = shr.s_sysid;
90437c478bd9Sstevel@tonic-gate 	shr.s_owner = (caddr_t)&shr_loco;
90447c478bd9Sstevel@tonic-gate 	shr.s_own_len = sizeof (shr_loco);
90457c478bd9Sstevel@tonic-gate 	return (vop_shrlock(sp->finfo->vp, cmd, &shr, fflags));
90467c478bd9Sstevel@tonic-gate }
90477c478bd9Sstevel@tonic-gate 
90487c478bd9Sstevel@tonic-gate static int
90497c478bd9Sstevel@tonic-gate rfs4_share(rfs4_state_t *sp)
90507c478bd9Sstevel@tonic-gate {
9051da6c28aaSamw 	int cmd;
9052da6c28aaSamw 	cmd = nbl_need_check(sp->finfo->vp) ? F_SHARE_NBMAND : F_SHARE;
9053da6c28aaSamw 	return (rfs4_shrlock(sp, cmd));
90547c478bd9Sstevel@tonic-gate }
90557c478bd9Sstevel@tonic-gate 
90567c478bd9Sstevel@tonic-gate void
90577c478bd9Sstevel@tonic-gate rfs4_unshare(rfs4_state_t *sp)
90587c478bd9Sstevel@tonic-gate {
90597c478bd9Sstevel@tonic-gate 	(void) rfs4_shrlock(sp, F_UNSHARE);
90607c478bd9Sstevel@tonic-gate }
9061