xref: /titanic_51/usr/src/uts/common/fs/nfs/nfs4_srv.c (revision 0cfb4e8b28ab16b0cb224619362e8135673714c3)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  *	Copyright (c) 1983,1984,1985,1986,1987,1988,1989  AT&T.
28  *	All Rights Reserved
29  */
30 
31 #pragma ident	"%Z%%M%	%I%	%E% SMI"
32 
33 #include <sys/param.h>
34 #include <sys/types.h>
35 #include <sys/systm.h>
36 #include <sys/cred.h>
37 #include <sys/buf.h>
38 #include <sys/vfs.h>
39 #include <sys/vfs_opreg.h>
40 #include <sys/vnode.h>
41 #include <sys/uio.h>
42 #include <sys/errno.h>
43 #include <sys/sysmacros.h>
44 #include <sys/statvfs.h>
45 #include <sys/kmem.h>
46 #include <sys/dirent.h>
47 #include <sys/cmn_err.h>
48 #include <sys/debug.h>
49 #include <sys/systeminfo.h>
50 #include <sys/flock.h>
51 #include <sys/pathname.h>
52 #include <sys/nbmlock.h>
53 #include <sys/share.h>
54 #include <sys/atomic.h>
55 #include <sys/policy.h>
56 #include <sys/fem.h>
57 #include <sys/sdt.h>
58 #include <sys/ddi.h>
59 
60 #include <rpc/types.h>
61 #include <rpc/auth.h>
62 #include <rpc/rpcsec_gss.h>
63 #include <rpc/svc.h>
64 
65 #include <nfs/nfs.h>
66 #include <nfs/export.h>
67 #include <nfs/lm.h>
68 #include <nfs/nfs4.h>
69 
70 #include <sys/strsubr.h>
71 #include <sys/strsun.h>
72 
73 #include <inet/common.h>
74 #include <inet/ip.h>
75 #include <inet/ip6.h>
76 
77 #include <sys/tsol/label.h>
78 #include <sys/tsol/tndb.h>
79 
80 #define	RFS4_MAXLOCK_TRIES 4	/* Try to get the lock this many times */
81 static int rfs4_maxlock_tries = RFS4_MAXLOCK_TRIES;
82 #define	RFS4_LOCK_DELAY 10	/* Milliseconds */
83 static clock_t rfs4_lock_delay = RFS4_LOCK_DELAY;
84 
85 /* End of Tunables */
86 
87 /*
88  * Used to bump the stateid4.seqid value and show changes in the stateid
89  */
90 #define	next_stateid(sp) (++(sp)->bits.chgseq)
91 
92 /*
93  * RFS4_MINLEN_ENTRY4: XDR-encoded size of smallest possible dirent.
94  *	This is used to return NFS4ERR_TOOSMALL when clients specify
95  *	maxcount that isn't large enough to hold the smallest possible
96  *	XDR encoded dirent.
97  *
98  *	    sizeof cookie (8 bytes) +
99  *	    sizeof name_len (4 bytes) +
100  *	    sizeof smallest (padded) name (4 bytes) +
101  *	    sizeof bitmap4_len (12 bytes) +   NOTE: we always encode len=2 bm4
102  *	    sizeof attrlist4_len (4 bytes) +
103  *	    sizeof next boolean (4 bytes)
104  *
105  * RFS4_MINLEN_RDDIR4: XDR-encoded size of READDIR op reply containing
106  * the smallest possible entry4 (assumes no attrs requested).
107  *	sizeof nfsstat4 (4 bytes) +
108  *	sizeof verifier4 (8 bytes) +
109  *	sizeof entry4list bool (4 bytes) +
110  *	sizeof entry4 	(36 bytes) +
111  *	sizeof eof bool  (4 bytes)
112  *
113  * RFS4_MINLEN_RDDIR_BUF: minimum length of buffer server will provide to
114  *	VOP_READDIR.  Its value is the size of the maximum possible dirent
115  *	for solaris.  The DIRENT64_RECLEN macro returns	the size of dirent
116  *	required for a given name length.  MAXNAMELEN is the maximum
117  *	filename length allowed in Solaris.  The first two DIRENT64_RECLEN()
118  *	macros are to allow for . and .. entries -- just a minor tweak to try
119  *	and guarantee that buffer we give to VOP_READDIR will be large enough
120  *	to hold ., .., and the largest possible solaris dirent64.
121  */
122 #define	RFS4_MINLEN_ENTRY4 36
123 #define	RFS4_MINLEN_RDDIR4 (4 + NFS4_VERIFIER_SIZE + 4 + RFS4_MINLEN_ENTRY4 + 4)
124 #define	RFS4_MINLEN_RDDIR_BUF \
125 	(DIRENT64_RECLEN(1) + DIRENT64_RECLEN(2) + DIRENT64_RECLEN(MAXNAMELEN))
126 
127 /*
128  * It would be better to pad to 4 bytes since that's what XDR would do,
129  * but the dirents UFS gives us are already padded to 8, so just take
130  * what we're given.  Dircount is only a hint anyway.  Currently the
131  * solaris kernel is ASCII only, so there's no point in calling the
132  * UTF8 functions.
133  *
134  * dirent64: named padded to provide 8 byte struct alignment
135  *	d_ino(8) + d_off(8) + d_reclen(2) + d_name(namelen + null(1) + pad)
136  *
137  * cookie: uint64_t   +  utf8namelen: uint_t  +   utf8name padded to 8 bytes
138  *
139  */
140 #define	DIRENT64_TO_DIRCOUNT(dp) \
141 	(3 * BYTES_PER_XDR_UNIT + DIRENT64_NAMELEN((dp)->d_reclen))
142 
143 time_t rfs4_start_time;			/* Initialized in rfs4_srvrinit */
144 
145 static sysid_t lockt_sysid;		/* dummy sysid for all LOCKT calls */
146 
147 u_longlong_t nfs4_srv_caller_id;
148 uint_t nfs4_srv_vkey = 0;
149 
150 verifier4	Write4verf;
151 verifier4	Readdir4verf;
152 
153 void		rfs4_init_compound_state(struct compound_state *);
154 
155 static void	nullfree(caddr_t);
156 static void	rfs4_op_inval(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
157 			struct compound_state *);
158 static void	rfs4_op_access(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
159 			struct compound_state *);
160 static void	rfs4_op_close(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
161 			struct compound_state *);
162 static void	rfs4_op_commit(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
163 			struct compound_state *);
164 static void	rfs4_op_create(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
165 			struct compound_state *);
166 static void	rfs4_op_create_free(nfs_resop4 *resop);
167 static void	rfs4_op_delegreturn(nfs_argop4 *, nfs_resop4 *,
168 			struct svc_req *, struct compound_state *);
169 static void	rfs4_op_delegpurge(nfs_argop4 *, nfs_resop4 *,
170 			struct svc_req *, struct compound_state *);
171 static void	rfs4_op_getattr(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
172 			struct compound_state *);
173 static void	rfs4_op_getattr_free(nfs_resop4 *);
174 static void	rfs4_op_getfh(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
175 			struct compound_state *);
176 static void	rfs4_op_getfh_free(nfs_resop4 *);
177 static void	rfs4_op_illegal(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
178 			struct compound_state *);
179 static void	rfs4_op_link(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
180 			struct compound_state *);
181 static void	rfs4_op_lock(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
182 			struct compound_state *);
183 static void	lock_denied_free(nfs_resop4 *);
184 static void	rfs4_op_locku(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
185 			struct compound_state *);
186 static void	rfs4_op_lockt(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
187 			struct compound_state *);
188 static void	rfs4_op_lookup(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
189 			struct compound_state *);
190 static void	rfs4_op_lookupp(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
191 			struct compound_state *);
192 static void	rfs4_op_openattr(nfs_argop4 *argop, nfs_resop4 *resop,
193 				struct svc_req *req, struct compound_state *cs);
194 static void	rfs4_op_nverify(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
195 			struct compound_state *);
196 static void	rfs4_op_open(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
197 			struct compound_state *);
198 static void	rfs4_op_open_confirm(nfs_argop4 *, nfs_resop4 *,
199 			struct svc_req *, struct compound_state *);
200 static void	rfs4_op_open_downgrade(nfs_argop4 *, nfs_resop4 *,
201 			struct svc_req *, struct compound_state *);
202 static void	rfs4_op_putfh(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
203 			struct compound_state *);
204 static void	rfs4_op_putpubfh(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
205 			struct compound_state *);
206 static void	rfs4_op_putrootfh(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
207 			struct compound_state *);
208 static void	rfs4_op_read(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
209 			struct compound_state *);
210 static void	rfs4_op_read_free(nfs_resop4 *);
211 static void	rfs4_op_readdir_free(nfs_resop4 *resop);
212 static void	rfs4_op_readlink(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
213 			struct compound_state *);
214 static void	rfs4_op_readlink_free(nfs_resop4 *);
215 static void	rfs4_op_release_lockowner(nfs_argop4 *, nfs_resop4 *,
216 			struct svc_req *, struct compound_state *);
217 static void	rfs4_op_remove(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
218 			struct compound_state *);
219 static void	rfs4_op_rename(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
220 			struct compound_state *);
221 static void	rfs4_op_renew(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
222 			struct compound_state *);
223 static void	rfs4_op_restorefh(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
224 			struct compound_state *);
225 static void	rfs4_op_savefh(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
226 			struct compound_state *);
227 static void	rfs4_op_setattr(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
228 			struct compound_state *);
229 static void	rfs4_op_verify(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
230 			struct compound_state *);
231 static void	rfs4_op_write(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
232 			struct compound_state *);
233 static void	rfs4_op_setclientid(nfs_argop4 *, nfs_resop4 *,
234 			struct svc_req *, struct compound_state *);
235 static void	rfs4_op_setclientid_confirm(nfs_argop4 *, nfs_resop4 *,
236 			struct svc_req *req, struct compound_state *);
237 static void	rfs4_op_secinfo(nfs_argop4 *, nfs_resop4 *, struct svc_req *,
238 			struct compound_state *);
239 static void	rfs4_op_secinfo_free(nfs_resop4 *);
240 
241 static nfsstat4 check_open_access(uint32_t,
242 				struct compound_state *, struct svc_req *);
243 nfsstat4 rfs4_client_sysid(rfs4_client_t *, sysid_t *);
244 static int	vop_shrlock(vnode_t *, int, struct shrlock *, int);
245 static int 	rfs4_shrlock(rfs4_state_t *, int);
246 static int	rfs4_share(rfs4_state_t *);
247 void rfs4_ss_clid(rfs4_client_t *, struct svc_req *);
248 
249 /*
250  * translation table for attrs
251  */
252 struct nfs4_ntov_table {
253 	union nfs4_attr_u *na;
254 	uint8_t amap[NFS4_MAXNUM_ATTRS];
255 	int attrcnt;
256 	bool_t vfsstat;
257 };
258 
259 static void	nfs4_ntov_table_init(struct nfs4_ntov_table *ntovp);
260 static void	nfs4_ntov_table_free(struct nfs4_ntov_table *ntovp,
261 				    struct nfs4_svgetit_arg *sargp);
262 
263 static nfsstat4	do_rfs4_set_attrs(bitmap4 *resp, fattr4 *fattrp,
264 		    struct compound_state *cs, struct nfs4_svgetit_arg *sargp,
265 		    struct nfs4_ntov_table *ntovp, nfs4_attr_cmd_t cmd);
266 
267 fem_t	*deleg_rdops;
268 fem_t	*deleg_wrops;
269 
270 rfs4_servinst_t	*rfs4_cur_servinst = NULL;	/* current server instance */
271 kmutex_t	rfs4_servinst_lock;		/* protects linked list */
272 int		rfs4_seen_first_compound;	/* set first time we see one */
273 
274 /*
275  * NFS4 op dispatch table
276  */
277 
278 struct rfsv4disp {
279 	void	(*dis_proc)();		/* proc to call */
280 	void	(*dis_resfree)();	/* frees space allocated by proc */
281 	int	dis_flags;		/* RPC_IDEMPOTENT, etc... */
282 };
283 
284 static struct rfsv4disp rfsv4disptab[] = {
285 	/*
286 	 * NFS VERSION 4
287 	 */
288 
289 	/* RFS_NULL = 0 */
290 	{rfs4_op_illegal, nullfree, 0},
291 
292 	/* UNUSED = 1 */
293 	{rfs4_op_illegal, nullfree, 0},
294 
295 	/* UNUSED = 2 */
296 	{rfs4_op_illegal, nullfree, 0},
297 
298 	/* OP_ACCESS = 3 */
299 	{rfs4_op_access, nullfree, RPC_IDEMPOTENT},
300 
301 	/* OP_CLOSE = 4 */
302 	{rfs4_op_close, nullfree, 0},
303 
304 	/* OP_COMMIT = 5 */
305 	{rfs4_op_commit, nullfree, RPC_IDEMPOTENT},
306 
307 	/* OP_CREATE = 6 */
308 	{rfs4_op_create, nullfree, 0},
309 
310 	/* OP_DELEGPURGE = 7 */
311 	{rfs4_op_delegpurge, nullfree, 0},
312 
313 	/* OP_DELEGRETURN = 8 */
314 	{rfs4_op_delegreturn, nullfree, 0},
315 
316 	/* OP_GETATTR = 9 */
317 	{rfs4_op_getattr, rfs4_op_getattr_free, RPC_IDEMPOTENT},
318 
319 	/* OP_GETFH = 10 */
320 	{rfs4_op_getfh, rfs4_op_getfh_free, RPC_ALL},
321 
322 	/* OP_LINK = 11 */
323 	{rfs4_op_link, nullfree, 0},
324 
325 	/* OP_LOCK = 12 */
326 	{rfs4_op_lock, lock_denied_free, 0},
327 
328 	/* OP_LOCKT = 13 */
329 	{rfs4_op_lockt, lock_denied_free, 0},
330 
331 	/* OP_LOCKU = 14 */
332 	{rfs4_op_locku, nullfree, 0},
333 
334 	/* OP_LOOKUP = 15 */
335 	{rfs4_op_lookup, nullfree, (RPC_IDEMPOTENT|RPC_PUBLICFH_OK)},
336 
337 	/* OP_LOOKUPP = 16 */
338 	{rfs4_op_lookupp, nullfree, (RPC_IDEMPOTENT|RPC_PUBLICFH_OK)},
339 
340 	/* OP_NVERIFY = 17 */
341 	{rfs4_op_nverify, nullfree, RPC_IDEMPOTENT},
342 
343 	/* OP_OPEN = 18 */
344 	{rfs4_op_open, rfs4_free_reply, 0},
345 
346 	/* OP_OPENATTR = 19 */
347 	{rfs4_op_openattr, nullfree, 0},
348 
349 	/* OP_OPEN_CONFIRM = 20 */
350 	{rfs4_op_open_confirm, nullfree, 0},
351 
352 	/* OP_OPEN_DOWNGRADE = 21 */
353 	{rfs4_op_open_downgrade, nullfree, 0},
354 
355 	/* OP_OPEN_PUTFH = 22 */
356 	{rfs4_op_putfh, nullfree, RPC_ALL},
357 
358 	/* OP_PUTPUBFH = 23 */
359 	{rfs4_op_putpubfh, nullfree, RPC_ALL},
360 
361 	/* OP_PUTROOTFH = 24 */
362 	{rfs4_op_putrootfh, nullfree, RPC_ALL},
363 
364 	/* OP_READ = 25 */
365 	{rfs4_op_read, rfs4_op_read_free, RPC_IDEMPOTENT},
366 
367 	/* OP_READDIR = 26 */
368 	{rfs4_op_readdir, rfs4_op_readdir_free, RPC_IDEMPOTENT},
369 
370 	/* OP_READLINK = 27 */
371 	{rfs4_op_readlink, rfs4_op_readlink_free, RPC_IDEMPOTENT},
372 
373 	/* OP_REMOVE = 28 */
374 	{rfs4_op_remove, nullfree, 0},
375 
376 	/* OP_RENAME = 29 */
377 	{rfs4_op_rename, nullfree, 0},
378 
379 	/* OP_RENEW = 30 */
380 	{rfs4_op_renew, nullfree, 0},
381 
382 	/* OP_RESTOREFH = 31 */
383 	{rfs4_op_restorefh, nullfree, RPC_ALL},
384 
385 	/* OP_SAVEFH = 32 */
386 	{rfs4_op_savefh, nullfree, RPC_ALL},
387 
388 	/* OP_SECINFO = 33 */
389 	{rfs4_op_secinfo, rfs4_op_secinfo_free, 0},
390 
391 	/* OP_SETATTR = 34 */
392 	{rfs4_op_setattr, nullfree, 0},
393 
394 	/* OP_SETCLIENTID = 35 */
395 	{rfs4_op_setclientid, nullfree, 0},
396 
397 	/* OP_SETCLIENTID_CONFIRM = 36 */
398 	{rfs4_op_setclientid_confirm, nullfree, 0},
399 
400 	/* OP_VERIFY = 37 */
401 	{rfs4_op_verify, nullfree, RPC_IDEMPOTENT},
402 
403 	/* OP_WRITE = 38 */
404 	{rfs4_op_write, nullfree, 0},
405 
406 	/* OP_RELEASE_LOCKOWNER = 39 */
407 	{rfs4_op_release_lockowner, nullfree, 0},
408 };
409 
410 static uint_t rfsv4disp_cnt = sizeof (rfsv4disptab) / sizeof (rfsv4disptab[0]);
411 
412 #define	OP_ILLEGAL_IDX (rfsv4disp_cnt)
413 
414 #ifdef DEBUG
415 
416 int rfs4_fillone_debug = 0;
417 int rfs4_shrlock_debug = 0;
418 int rfs4_no_stub_access = 1;
419 int rfs4_rddir_debug = 0;
420 
421 static char *rfs4_op_string[] = {
422 	"rfs4_op_null",
423 	"rfs4_op_1 unused",
424 	"rfs4_op_2 unused",
425 	"rfs4_op_access",
426 	"rfs4_op_close",
427 	"rfs4_op_commit",
428 	"rfs4_op_create",
429 	"rfs4_op_delegpurge",
430 	"rfs4_op_delegreturn",
431 	"rfs4_op_getattr",
432 	"rfs4_op_getfh",
433 	"rfs4_op_link",
434 	"rfs4_op_lock",
435 	"rfs4_op_lockt",
436 	"rfs4_op_locku",
437 	"rfs4_op_lookup",
438 	"rfs4_op_lookupp",
439 	"rfs4_op_nverify",
440 	"rfs4_op_open",
441 	"rfs4_op_openattr",
442 	"rfs4_op_open_confirm",
443 	"rfs4_op_open_downgrade",
444 	"rfs4_op_putfh",
445 	"rfs4_op_putpubfh",
446 	"rfs4_op_putrootfh",
447 	"rfs4_op_read",
448 	"rfs4_op_readdir",
449 	"rfs4_op_readlink",
450 	"rfs4_op_remove",
451 	"rfs4_op_rename",
452 	"rfs4_op_renew",
453 	"rfs4_op_restorefh",
454 	"rfs4_op_savefh",
455 	"rfs4_op_secinfo",
456 	"rfs4_op_setattr",
457 	"rfs4_op_setclientid",
458 	"rfs4_op_setclient_confirm",
459 	"rfs4_op_verify",
460 	"rfs4_op_write",
461 	"rfs4_op_release_lockowner",
462 	"rfs4_op_illegal"
463 };
464 #endif
465 
466 void rfs4_ss_chkclid(rfs4_client_t *);
467 
468 extern size_t strlcpy(char *dst, const char *src, size_t dstsize);
469 
470 #ifdef	nextdp
471 #undef nextdp
472 #endif
473 #define	nextdp(dp)	((struct dirent64 *)((char *)(dp) + (dp)->d_reclen))
474 
475 static const fs_operation_def_t nfs4_rd_deleg_tmpl[] = {
476 	VOPNAME_OPEN,		{ .femop_open = deleg_rd_open },
477 	VOPNAME_WRITE,		{ .femop_write = deleg_rd_write },
478 	VOPNAME_SETATTR,	{ .femop_setattr = deleg_rd_setattr },
479 	VOPNAME_RWLOCK,		{ .femop_rwlock = deleg_rd_rwlock },
480 	VOPNAME_SPACE,		{ .femop_space = deleg_rd_space },
481 	VOPNAME_SETSECATTR,	{ .femop_setsecattr = deleg_rd_setsecattr },
482 	VOPNAME_VNEVENT,	{ .femop_vnevent = deleg_rd_vnevent },
483 	NULL,			NULL
484 };
485 static const fs_operation_def_t nfs4_wr_deleg_tmpl[] = {
486 	VOPNAME_OPEN,		{ .femop_open = deleg_wr_open },
487 	VOPNAME_READ,		{ .femop_read = deleg_wr_read },
488 	VOPNAME_WRITE,		{ .femop_write = deleg_wr_write },
489 	VOPNAME_SETATTR,	{ .femop_setattr = deleg_wr_setattr },
490 	VOPNAME_RWLOCK,		{ .femop_rwlock = deleg_wr_rwlock },
491 	VOPNAME_SPACE,		{ .femop_space = deleg_wr_space },
492 	VOPNAME_SETSECATTR,	{ .femop_setsecattr = deleg_wr_setsecattr },
493 	VOPNAME_VNEVENT,	{ .femop_vnevent = deleg_wr_vnevent },
494 	NULL,			NULL
495 };
496 
497 int
498 rfs4_srvrinit(void)
499 {
500 	timespec32_t verf;
501 	int error;
502 	extern void rfs4_attr_init();
503 	extern krwlock_t rfs4_deleg_policy_lock;
504 
505 	/*
506 	 * The following algorithm attempts to find a unique verifier
507 	 * to be used as the write verifier returned from the server
508 	 * to the client.  It is important that this verifier change
509 	 * whenever the server reboots.  Of secondary importance, it
510 	 * is important for the verifier to be unique between two
511 	 * different servers.
512 	 *
513 	 * Thus, an attempt is made to use the system hostid and the
514 	 * current time in seconds when the nfssrv kernel module is
515 	 * loaded.  It is assumed that an NFS server will not be able
516 	 * to boot and then to reboot in less than a second.  If the
517 	 * hostid has not been set, then the current high resolution
518 	 * time is used.  This will ensure different verifiers each
519 	 * time the server reboots and minimize the chances that two
520 	 * different servers will have the same verifier.
521 	 * XXX - this is broken on LP64 kernels.
522 	 */
523 	verf.tv_sec = (time_t)nfs_atoi(hw_serial);
524 	if (verf.tv_sec != 0) {
525 		verf.tv_nsec = gethrestime_sec();
526 	} else {
527 		timespec_t tverf;
528 
529 		gethrestime(&tverf);
530 		verf.tv_sec = (time_t)tverf.tv_sec;
531 		verf.tv_nsec = tverf.tv_nsec;
532 	}
533 
534 	Write4verf = *(uint64_t *)&verf;
535 
536 	rfs4_attr_init();
537 	mutex_init(&rfs4_deleg_lock, NULL, MUTEX_DEFAULT, NULL);
538 
539 	/* Used to manage create/destroy of server state */
540 	mutex_init(&rfs4_state_lock, NULL, MUTEX_DEFAULT, NULL);
541 
542 	/* Used to manage access to server instance linked list */
543 	mutex_init(&rfs4_servinst_lock, NULL, MUTEX_DEFAULT, NULL);
544 
545 	/* Used to manage access to rfs4_deleg_policy */
546 	rw_init(&rfs4_deleg_policy_lock, NULL, RW_DEFAULT, NULL);
547 
548 	error = fem_create("deleg_rdops", nfs4_rd_deleg_tmpl, &deleg_rdops);
549 	if (error != 0) {
550 		rfs4_disable_delegation();
551 	} else {
552 		error = fem_create("deleg_wrops", nfs4_wr_deleg_tmpl,
553 		    &deleg_wrops);
554 		if (error != 0) {
555 			rfs4_disable_delegation();
556 			fem_free(deleg_rdops);
557 		}
558 	}
559 
560 	nfs4_srv_caller_id = fs_new_caller_id();
561 
562 	lockt_sysid = lm_alloc_sysidt();
563 
564 	vsd_create(&nfs4_srv_vkey, NULL);
565 
566 	return (0);
567 }
568 
569 void
570 rfs4_srvrfini(void)
571 {
572 	extern krwlock_t rfs4_deleg_policy_lock;
573 
574 	if (lockt_sysid != LM_NOSYSID) {
575 		lm_free_sysidt(lockt_sysid);
576 		lockt_sysid = LM_NOSYSID;
577 	}
578 
579 	mutex_destroy(&rfs4_deleg_lock);
580 	mutex_destroy(&rfs4_state_lock);
581 	rw_destroy(&rfs4_deleg_policy_lock);
582 
583 	fem_free(deleg_rdops);
584 	fem_free(deleg_wrops);
585 }
586 
587 void
588 rfs4_init_compound_state(struct compound_state *cs)
589 {
590 	bzero(cs, sizeof (*cs));
591 	cs->cont = TRUE;
592 	cs->access = CS_ACCESS_DENIED;
593 	cs->deleg = FALSE;
594 	cs->mandlock = FALSE;
595 	cs->fh.nfs_fh4_val = cs->fhbuf;
596 }
597 
598 void
599 rfs4_grace_start(rfs4_servinst_t *sip)
600 {
601 	time_t now = gethrestime_sec();
602 
603 	rw_enter(&sip->rwlock, RW_WRITER);
604 	sip->start_time = now;
605 	sip->grace_period = rfs4_grace_period;
606 	rw_exit(&sip->rwlock);
607 }
608 
609 /*
610  * returns true if the instance's grace period has never been started
611  */
612 int
613 rfs4_servinst_grace_new(rfs4_servinst_t *sip)
614 {
615 	time_t start_time;
616 
617 	rw_enter(&sip->rwlock, RW_READER);
618 	start_time = sip->start_time;
619 	rw_exit(&sip->rwlock);
620 
621 	return (start_time == 0);
622 }
623 
624 /*
625  * Indicates if server instance is within the
626  * grace period.
627  */
628 int
629 rfs4_servinst_in_grace(rfs4_servinst_t *sip)
630 {
631 	time_t grace_expiry;
632 
633 	rw_enter(&sip->rwlock, RW_READER);
634 	grace_expiry = sip->start_time + sip->grace_period;
635 	rw_exit(&sip->rwlock);
636 
637 	return (gethrestime_sec() < grace_expiry);
638 }
639 
640 int
641 rfs4_clnt_in_grace(rfs4_client_t *cp)
642 {
643 	ASSERT(rfs4_dbe_refcnt(cp->dbe) > 0);
644 
645 	return (rfs4_servinst_in_grace(cp->server_instance));
646 }
647 
648 /*
649  * reset all currently active grace periods
650  */
651 void
652 rfs4_grace_reset_all(void)
653 {
654 	rfs4_servinst_t *sip;
655 
656 	mutex_enter(&rfs4_servinst_lock);
657 	for (sip = rfs4_cur_servinst; sip != NULL; sip = sip->prev)
658 		if (rfs4_servinst_in_grace(sip))
659 			rfs4_grace_start(sip);
660 	mutex_exit(&rfs4_servinst_lock);
661 }
662 
663 /*
664  * start any new instances' grace periods
665  */
666 void
667 rfs4_grace_start_new(void)
668 {
669 	rfs4_servinst_t *sip;
670 
671 	mutex_enter(&rfs4_servinst_lock);
672 	for (sip = rfs4_cur_servinst; sip != NULL; sip = sip->prev)
673 		if (rfs4_servinst_grace_new(sip))
674 			rfs4_grace_start(sip);
675 	mutex_exit(&rfs4_servinst_lock);
676 }
677 
678 static rfs4_dss_path_t *
679 rfs4_dss_newpath(rfs4_servinst_t *sip, char *path, unsigned index)
680 {
681 	size_t len;
682 	rfs4_dss_path_t *dss_path;
683 
684 	dss_path = kmem_alloc(sizeof (rfs4_dss_path_t), KM_SLEEP);
685 
686 	/*
687 	 * Take a copy of the string, since the original may be overwritten.
688 	 * Sadly, no strdup() in the kernel.
689 	 */
690 	/* allow for NUL */
691 	len = strlen(path) + 1;
692 	dss_path->path = kmem_alloc(len, KM_SLEEP);
693 	(void) strlcpy(dss_path->path, path, len);
694 
695 	/* associate with servinst */
696 	dss_path->sip = sip;
697 	dss_path->index = index;
698 
699 	/*
700 	 * Add to list of served paths.
701 	 * No locking required, as we're only ever called at startup.
702 	 */
703 	if (rfs4_dss_pathlist == NULL) {
704 		/* this is the first dss_path_t */
705 
706 		/* needed for insque/remque */
707 		dss_path->next = dss_path->prev = dss_path;
708 
709 		rfs4_dss_pathlist = dss_path;
710 	} else {
711 		insque(dss_path, rfs4_dss_pathlist);
712 	}
713 
714 	return (dss_path);
715 }
716 
717 /*
718  * Create a new server instance, and make it the currently active instance.
719  * Note that starting the grace period too early will reduce the clients'
720  * recovery window.
721  */
722 void
723 rfs4_servinst_create(int start_grace, int dss_npaths, char **dss_paths)
724 {
725 	unsigned i;
726 	rfs4_servinst_t *sip;
727 	rfs4_oldstate_t *oldstate;
728 
729 	sip = kmem_alloc(sizeof (rfs4_servinst_t), KM_SLEEP);
730 	rw_init(&sip->rwlock, NULL, RW_DEFAULT, NULL);
731 
732 	sip->start_time = (time_t)0;
733 	sip->grace_period = (time_t)0;
734 	sip->next = NULL;
735 	sip->prev = NULL;
736 
737 	rw_init(&sip->oldstate_lock, NULL, RW_DEFAULT, NULL);
738 	/*
739 	 * This initial dummy entry is required to setup for insque/remque.
740 	 * It must be skipped over whenever the list is traversed.
741 	 */
742 	oldstate = kmem_alloc(sizeof (rfs4_oldstate_t), KM_SLEEP);
743 	/* insque/remque require initial list entry to be self-terminated */
744 	oldstate->next = oldstate;
745 	oldstate->prev = oldstate;
746 	sip->oldstate = oldstate;
747 
748 
749 	sip->dss_npaths = dss_npaths;
750 	sip->dss_paths = kmem_alloc(dss_npaths *
751 	    sizeof (rfs4_dss_path_t *), KM_SLEEP);
752 
753 	for (i = 0; i < dss_npaths; i++) {
754 		sip->dss_paths[i] = rfs4_dss_newpath(sip, dss_paths[i], i);
755 	}
756 
757 	mutex_enter(&rfs4_servinst_lock);
758 	if (rfs4_cur_servinst != NULL) {
759 		/* add to linked list */
760 		sip->prev = rfs4_cur_servinst;
761 		rfs4_cur_servinst->next = sip;
762 	}
763 	if (start_grace)
764 		rfs4_grace_start(sip);
765 	/* make the new instance "current" */
766 	rfs4_cur_servinst = sip;
767 
768 	mutex_exit(&rfs4_servinst_lock);
769 }
770 
771 /*
772  * In future, we might add a rfs4_servinst_destroy(sip) but, for now, destroy
773  * all instances directly.
774  */
775 void
776 rfs4_servinst_destroy_all(void)
777 {
778 	rfs4_servinst_t *sip, *prev, *current;
779 #ifdef DEBUG
780 	int n = 0;
781 #endif
782 
783 	mutex_enter(&rfs4_servinst_lock);
784 	ASSERT(rfs4_cur_servinst != NULL);
785 	current = rfs4_cur_servinst;
786 	rfs4_cur_servinst = NULL;
787 	for (sip = current; sip != NULL; sip = prev) {
788 		prev = sip->prev;
789 		rw_destroy(&sip->rwlock);
790 		if (sip->oldstate)
791 			kmem_free(sip->oldstate, sizeof (rfs4_oldstate_t));
792 		if (sip->dss_paths)
793 			kmem_free(sip->dss_paths,
794 			    sip->dss_npaths * sizeof (rfs4_dss_path_t *));
795 		kmem_free(sip, sizeof (rfs4_servinst_t));
796 #ifdef DEBUG
797 		n++;
798 #endif
799 	}
800 	mutex_exit(&rfs4_servinst_lock);
801 }
802 
803 /*
804  * Assign the current server instance to a client_t.
805  * Should be called with cp->dbe held.
806  */
807 void
808 rfs4_servinst_assign(rfs4_client_t *cp, rfs4_servinst_t *sip)
809 {
810 	ASSERT(rfs4_dbe_refcnt(cp->dbe) > 0);
811 
812 	/*
813 	 * The lock ensures that if the current instance is in the process
814 	 * of changing, we will see the new one.
815 	 */
816 	mutex_enter(&rfs4_servinst_lock);
817 	cp->server_instance = sip;
818 	mutex_exit(&rfs4_servinst_lock);
819 }
820 
821 rfs4_servinst_t *
822 rfs4_servinst(rfs4_client_t *cp)
823 {
824 	ASSERT(rfs4_dbe_refcnt(cp->dbe) > 0);
825 
826 	return (cp->server_instance);
827 }
828 
829 /* ARGSUSED */
830 static void
831 nullfree(caddr_t resop)
832 {
833 }
834 
835 /*
836  * This is a fall-through for invalid or not implemented (yet) ops
837  */
838 /* ARGSUSED */
839 static void
840 rfs4_op_inval(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
841 	struct compound_state *cs)
842 {
843 	*cs->statusp = *((nfsstat4 *)&(resop)->nfs_resop4_u) = NFS4ERR_INVAL;
844 }
845 
846 /*
847  * Check if the security flavor, nfsnum, is in the flavor_list.
848  */
849 bool_t
850 in_flavor_list(int nfsnum, int *flavor_list, int count)
851 {
852 	int i;
853 
854 	for (i = 0; i < count; i++) {
855 		if (nfsnum == flavor_list[i])
856 			return (TRUE);
857 	}
858 	return (FALSE);
859 }
860 
861 /*
862  * Used by rfs4_op_secinfo to get the security information from the
863  * export structure associated with the component.
864  */
865 /* ARGSUSED */
866 static nfsstat4
867 do_rfs4_op_secinfo(struct compound_state *cs, char *nm, SECINFO4res *resp)
868 {
869 	int error, different_export = 0;
870 	vnode_t *dvp, *vp, *tvp;
871 	struct exportinfo *exi = NULL;
872 	fid_t fid;
873 	uint_t count, i;
874 	secinfo4 *resok_val;
875 	struct secinfo *secp;
876 	seconfig_t *si;
877 	bool_t did_traverse;
878 	int dotdot, walk;
879 
880 	dvp = cs->vp;
881 	dotdot = (nm[0] == '.' && nm[1] == '.' && nm[2] == '\0');
882 
883 	/*
884 	 * If dotdotting, then need to check whether it's above the
885 	 * root of a filesystem, or above an export point.
886 	 */
887 	if (dotdot) {
888 
889 		/*
890 		 * If dotdotting at the root of a filesystem, then
891 		 * need to traverse back to the mounted-on filesystem
892 		 * and do the dotdot lookup there.
893 		 */
894 		if (cs->vp->v_flag & VROOT) {
895 
896 			/*
897 			 * If at the system root, then can
898 			 * go up no further.
899 			 */
900 			if (VN_CMP(dvp, rootdir))
901 				return (puterrno4(ENOENT));
902 
903 			/*
904 			 * Traverse back to the mounted-on filesystem
905 			 */
906 			dvp = untraverse(cs->vp);
907 
908 			/*
909 			 * Set the different_export flag so we remember
910 			 * to pick up a new exportinfo entry for
911 			 * this new filesystem.
912 			 */
913 			different_export = 1;
914 		} else {
915 
916 			/*
917 			 * If dotdotting above an export point then set
918 			 * the different_export to get new export info.
919 			 */
920 			different_export = nfs_exported(cs->exi, cs->vp);
921 		}
922 	}
923 
924 	/*
925 	 * Get the vnode for the component "nm".
926 	 */
927 	error = VOP_LOOKUP(dvp, nm, &vp, NULL, 0, NULL, cs->cr,
928 	    NULL, NULL, NULL);
929 	if (error)
930 		return (puterrno4(error));
931 
932 	/*
933 	 * If the vnode is in a pseudo filesystem, or if the security flavor
934 	 * used in the request is valid but not an explicitly shared flavor,
935 	 * or the access bit indicates that this is a limited access,
936 	 * check whether this vnode is visible.
937 	 */
938 	if (!different_export &&
939 	    (PSEUDO(cs->exi) || ! is_exported_sec(cs->nfsflavor, cs->exi) ||
940 	    cs->access & CS_ACCESS_LIMITED)) {
941 		if (! nfs_visible(cs->exi, vp, &different_export)) {
942 			VN_RELE(vp);
943 			return (puterrno4(ENOENT));
944 		}
945 	}
946 
947 	/*
948 	 * If it's a mountpoint, then traverse it.
949 	 */
950 	if (vn_ismntpt(vp)) {
951 		tvp = vp;
952 		if ((error = traverse(&tvp)) != 0) {
953 			VN_RELE(vp);
954 			return (puterrno4(error));
955 		}
956 		/* remember that we had to traverse mountpoint */
957 		did_traverse = TRUE;
958 		vp = tvp;
959 		different_export = 1;
960 	} else if (vp->v_vfsp != dvp->v_vfsp) {
961 		/*
962 		 * If vp isn't a mountpoint and the vfs ptrs aren't the same,
963 		 * then vp is probably an LOFS object.  We don't need the
964 		 * realvp, we just need to know that we might have crossed
965 		 * a server fs boundary and need to call checkexport4.
966 		 * (LOFS lookup hides server fs mountpoints, and actually calls
967 		 * traverse)
968 		 */
969 		different_export = 1;
970 		did_traverse = FALSE;
971 	}
972 
973 	/*
974 	 * Get the export information for it.
975 	 */
976 	if (different_export) {
977 
978 		bzero(&fid, sizeof (fid));
979 		fid.fid_len = MAXFIDSZ;
980 		error = vop_fid_pseudo(vp, &fid);
981 		if (error) {
982 			VN_RELE(vp);
983 			return (puterrno4(error));
984 		}
985 
986 		if (dotdot)
987 			exi = nfs_vptoexi(NULL, vp, cs->cr, &walk, NULL, TRUE);
988 		else
989 			exi = checkexport4(&vp->v_vfsp->vfs_fsid, &fid, vp);
990 
991 		if (exi == NULL) {
992 			if (did_traverse == TRUE) {
993 				/*
994 				 * If this vnode is a mounted-on vnode,
995 				 * but the mounted-on file system is not
996 				 * exported, send back the secinfo for
997 				 * the exported node that the mounted-on
998 				 * vnode lives in.
999 				 */
1000 				exi = cs->exi;
1001 			} else {
1002 				VN_RELE(vp);
1003 				return (puterrno4(EACCES));
1004 			}
1005 		}
1006 	} else {
1007 		exi = cs->exi;
1008 	}
1009 	ASSERT(exi != NULL);
1010 
1011 
1012 	/*
1013 	 * Create the secinfo result based on the security information
1014 	 * from the exportinfo structure (exi).
1015 	 *
1016 	 * Return all flavors for a pseudo node.
1017 	 * For a real export node, return the flavor that the client
1018 	 * has access with.
1019 	 */
1020 	ASSERT(RW_LOCK_HELD(&exported_lock));
1021 	if (PSEUDO(exi)) {
1022 		count = exi->exi_export.ex_seccnt; /* total sec count */
1023 		resok_val = kmem_alloc(count * sizeof (secinfo4), KM_SLEEP);
1024 		secp = exi->exi_export.ex_secinfo;
1025 
1026 		for (i = 0; i < count; i++) {
1027 			si = &secp[i].s_secinfo;
1028 			resok_val[i].flavor = si->sc_rpcnum;
1029 			if (resok_val[i].flavor == RPCSEC_GSS) {
1030 				rpcsec_gss_info *info;
1031 
1032 				info = &resok_val[i].flavor_info;
1033 				info->qop = si->sc_qop;
1034 				info->service = (rpc_gss_svc_t)si->sc_service;
1035 
1036 				/* get oid opaque data */
1037 				info->oid.sec_oid4_len =
1038 				    si->sc_gss_mech_type->length;
1039 				info->oid.sec_oid4_val = kmem_alloc(
1040 				    si->sc_gss_mech_type->length, KM_SLEEP);
1041 				bcopy(
1042 				    si->sc_gss_mech_type->elements,
1043 				    info->oid.sec_oid4_val,
1044 				    info->oid.sec_oid4_len);
1045 			}
1046 		}
1047 		resp->SECINFO4resok_len = count;
1048 		resp->SECINFO4resok_val = resok_val;
1049 	} else {
1050 		int ret_cnt = 0, k = 0;
1051 		int *flavor_list;
1052 
1053 		count = exi->exi_export.ex_seccnt; /* total sec count */
1054 		secp = exi->exi_export.ex_secinfo;
1055 
1056 		flavor_list = kmem_alloc(count * sizeof (int), KM_SLEEP);
1057 		/* find out which flavors to return */
1058 		for (i = 0; i < count; i ++) {
1059 			int access, flavor, perm;
1060 
1061 			flavor = secp[i].s_secinfo.sc_nfsnum;
1062 			perm = secp[i].s_flags;
1063 
1064 			access = nfsauth4_secinfo_access(exi, cs->req,
1065 			    flavor, perm);
1066 
1067 			if (! (access & NFSAUTH_DENIED) &&
1068 			    ! (access & NFSAUTH_WRONGSEC)) {
1069 				flavor_list[ret_cnt] = flavor;
1070 				ret_cnt++;
1071 			}
1072 		}
1073 
1074 		/* Create the returning SECINFO value */
1075 		resok_val = kmem_alloc(ret_cnt * sizeof (secinfo4), KM_SLEEP);
1076 
1077 		for (i = 0; i < count; i++) {
1078 			/*
1079 			 * If the flavor is in the flavor list,
1080 			 * fill in resok_val.
1081 			 */
1082 			si = &secp[i].s_secinfo;
1083 			if (in_flavor_list(si->sc_nfsnum,
1084 			    flavor_list, ret_cnt)) {
1085 				resok_val[k].flavor = si->sc_rpcnum;
1086 				if (resok_val[k].flavor == RPCSEC_GSS) {
1087 					rpcsec_gss_info *info;
1088 
1089 					info = &resok_val[k].flavor_info;
1090 					info->qop = si->sc_qop;
1091 					info->service = (rpc_gss_svc_t)
1092 					    si->sc_service;
1093 
1094 					/* get oid opaque data */
1095 					info->oid.sec_oid4_len =
1096 					    si->sc_gss_mech_type->length;
1097 					info->oid.sec_oid4_val = kmem_alloc(
1098 					    si->sc_gss_mech_type->length,
1099 					    KM_SLEEP);
1100 					bcopy(si->sc_gss_mech_type->elements,
1101 					    info->oid.sec_oid4_val,
1102 					    info->oid.sec_oid4_len);
1103 				}
1104 				k++;
1105 			}
1106 			if (k >= ret_cnt)
1107 				break;
1108 		}
1109 		resp->SECINFO4resok_len = ret_cnt;
1110 		resp->SECINFO4resok_val = resok_val;
1111 		kmem_free(flavor_list, count * sizeof (int));
1112 	}
1113 
1114 	VN_RELE(vp);
1115 	return (NFS4_OK);
1116 }
1117 
1118 /*
1119  * SECINFO (Operation 33): Obtain required security information on
1120  * the component name in the format of (security-mechanism-oid, qop, service)
1121  * triplets.
1122  */
1123 /* ARGSUSED */
1124 static void
1125 rfs4_op_secinfo(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
1126 	struct compound_state *cs)
1127 {
1128 	SECINFO4args *args = &argop->nfs_argop4_u.opsecinfo;
1129 	SECINFO4res *resp = &resop->nfs_resop4_u.opsecinfo;
1130 	utf8string *utfnm = &args->name;
1131 	uint_t len;
1132 	char *nm;
1133 
1134 	DTRACE_NFSV4_2(op__secinfo__start, struct compound_state *, cs,
1135 	    SECINFO4args *, args);
1136 
1137 	/*
1138 	 * Current file handle (cfh) should have been set before getting
1139 	 * into this function. If not, return error.
1140 	 */
1141 	if (cs->vp == NULL) {
1142 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
1143 		goto out;
1144 	}
1145 
1146 	if (cs->vp->v_type != VDIR) {
1147 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
1148 		goto out;
1149 	}
1150 
1151 	/*
1152 	 * Verify the component name. If failed, error out, but
1153 	 * do not error out if the component name is a "..".
1154 	 * SECINFO will return its parents secinfo data for SECINFO "..".
1155 	 */
1156 	if (!utf8_dir_verify(utfnm)) {
1157 		if (utfnm->utf8string_len != 2 ||
1158 		    utfnm->utf8string_val[0] != '.' ||
1159 		    utfnm->utf8string_val[1] != '.') {
1160 			*cs->statusp = resp->status = NFS4ERR_INVAL;
1161 			goto out;
1162 		}
1163 	}
1164 
1165 	nm = utf8_to_str(utfnm, &len, NULL);
1166 	if (nm == NULL) {
1167 		*cs->statusp = resp->status = NFS4ERR_INVAL;
1168 		goto out;
1169 	}
1170 
1171 	if (len > MAXNAMELEN) {
1172 		*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
1173 		kmem_free(nm, len);
1174 		goto out;
1175 	}
1176 
1177 	*cs->statusp = resp->status = do_rfs4_op_secinfo(cs, nm, resp);
1178 
1179 	kmem_free(nm, len);
1180 
1181 out:
1182 	DTRACE_NFSV4_2(op__secinfo__done, struct compound_state *, cs,
1183 	    SECINFO4res *, resp);
1184 }
1185 
1186 /*
1187  * Free SECINFO result.
1188  */
1189 /* ARGSUSED */
1190 static void
1191 rfs4_op_secinfo_free(nfs_resop4 *resop)
1192 {
1193 	SECINFO4res *resp = &resop->nfs_resop4_u.opsecinfo;
1194 	int count, i;
1195 	secinfo4 *resok_val;
1196 
1197 	/* If this is not an Ok result, nothing to free. */
1198 	if (resp->status != NFS4_OK) {
1199 		return;
1200 	}
1201 
1202 	count = resp->SECINFO4resok_len;
1203 	resok_val = resp->SECINFO4resok_val;
1204 
1205 	for (i = 0; i < count; i++) {
1206 		if (resok_val[i].flavor == RPCSEC_GSS) {
1207 			rpcsec_gss_info *info;
1208 
1209 			info = &resok_val[i].flavor_info;
1210 			kmem_free(info->oid.sec_oid4_val,
1211 			    info->oid.sec_oid4_len);
1212 		}
1213 	}
1214 	kmem_free(resok_val, count * sizeof (secinfo4));
1215 	resp->SECINFO4resok_len = 0;
1216 	resp->SECINFO4resok_val = NULL;
1217 }
1218 
1219 /* ARGSUSED */
1220 static void
1221 rfs4_op_access(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
1222 	struct compound_state *cs)
1223 {
1224 	ACCESS4args *args = &argop->nfs_argop4_u.opaccess;
1225 	ACCESS4res *resp = &resop->nfs_resop4_u.opaccess;
1226 	int error;
1227 	vnode_t *vp;
1228 	struct vattr va;
1229 	int checkwriteperm;
1230 	cred_t *cr = cs->cr;
1231 	bslabel_t *clabel, *slabel;
1232 	ts_label_t *tslabel;
1233 	boolean_t admin_low_client;
1234 
1235 	DTRACE_NFSV4_2(op__access__start, struct compound_state *, cs,
1236 	    ACCESS4args *, args);
1237 
1238 #if 0	/* XXX allow access even if !cs->access. Eventually only pseudo fs */
1239 	if (cs->access == CS_ACCESS_DENIED) {
1240 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
1241 		goto out;
1242 	}
1243 #endif
1244 	if (cs->vp == NULL) {
1245 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
1246 		goto out;
1247 	}
1248 
1249 	ASSERT(cr != NULL);
1250 
1251 	vp = cs->vp;
1252 
1253 	/*
1254 	 * If the file system is exported read only, it is not appropriate
1255 	 * to check write permissions for regular files and directories.
1256 	 * Special files are interpreted by the client, so the underlying
1257 	 * permissions are sent back to the client for interpretation.
1258 	 */
1259 	if (rdonly4(cs->exi, cs->vp, req) &&
1260 	    (vp->v_type == VREG || vp->v_type == VDIR))
1261 		checkwriteperm = 0;
1262 	else
1263 		checkwriteperm = 1;
1264 
1265 	/*
1266 	 * XXX
1267 	 * We need the mode so that we can correctly determine access
1268 	 * permissions relative to a mandatory lock file.  Access to
1269 	 * mandatory lock files is denied on the server, so it might
1270 	 * as well be reflected to the server during the open.
1271 	 */
1272 	va.va_mask = AT_MODE;
1273 	error = VOP_GETATTR(vp, &va, 0, cr, NULL);
1274 	if (error) {
1275 		*cs->statusp = resp->status = puterrno4(error);
1276 		goto out;
1277 	}
1278 	resp->access = 0;
1279 	resp->supported = 0;
1280 
1281 	if (is_system_labeled()) {
1282 		ASSERT(req->rq_label != NULL);
1283 		clabel = req->rq_label;
1284 		DTRACE_PROBE2(tx__rfs4__log__info__opaccess__clabel, char *,
1285 		    "got client label from request(1)",
1286 		    struct svc_req *, req);
1287 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
1288 			if ((tslabel = nfs_getflabel(vp)) == NULL) {
1289 				*cs->statusp = resp->status = puterrno4(EACCES);
1290 				goto out;
1291 			}
1292 			slabel = label2bslabel(tslabel);
1293 			DTRACE_PROBE3(tx__rfs4__log__info__opaccess__slabel,
1294 			    char *, "got server label(1) for vp(2)",
1295 			    bslabel_t *, slabel, vnode_t *, vp);
1296 
1297 			admin_low_client = B_FALSE;
1298 		} else
1299 			admin_low_client = B_TRUE;
1300 	}
1301 
1302 	if (args->access & ACCESS4_READ) {
1303 		error = VOP_ACCESS(vp, VREAD, 0, cr, NULL);
1304 		if (!error && !MANDLOCK(vp, va.va_mode) &&
1305 		    (!is_system_labeled() || admin_low_client ||
1306 		    bldominates(clabel, slabel)))
1307 			resp->access |= ACCESS4_READ;
1308 		resp->supported |= ACCESS4_READ;
1309 	}
1310 	if ((args->access & ACCESS4_LOOKUP) && vp->v_type == VDIR) {
1311 		error = VOP_ACCESS(vp, VEXEC, 0, cr, NULL);
1312 		if (!error && (!is_system_labeled() || admin_low_client ||
1313 		    bldominates(clabel, slabel)))
1314 			resp->access |= ACCESS4_LOOKUP;
1315 		resp->supported |= ACCESS4_LOOKUP;
1316 	}
1317 	if (checkwriteperm &&
1318 	    (args->access & (ACCESS4_MODIFY|ACCESS4_EXTEND))) {
1319 		error = VOP_ACCESS(vp, VWRITE, 0, cr, NULL);
1320 		if (!error && !MANDLOCK(vp, va.va_mode) &&
1321 		    (!is_system_labeled() || admin_low_client ||
1322 		    blequal(clabel, slabel)))
1323 			resp->access |=
1324 			    (args->access & (ACCESS4_MODIFY|ACCESS4_EXTEND));
1325 		resp->supported |= (ACCESS4_MODIFY|ACCESS4_EXTEND);
1326 	}
1327 
1328 	if (checkwriteperm &&
1329 	    (args->access & ACCESS4_DELETE) && vp->v_type == VDIR) {
1330 		error = VOP_ACCESS(vp, VWRITE, 0, cr, NULL);
1331 		if (!error && (!is_system_labeled() || admin_low_client ||
1332 		    blequal(clabel, slabel)))
1333 			resp->access |= ACCESS4_DELETE;
1334 		resp->supported |= ACCESS4_DELETE;
1335 	}
1336 	if (args->access & ACCESS4_EXECUTE && vp->v_type != VDIR) {
1337 		error = VOP_ACCESS(vp, VEXEC, 0, cr, NULL);
1338 		if (!error && !MANDLOCK(vp, va.va_mode) &&
1339 		    (!is_system_labeled() || admin_low_client ||
1340 		    bldominates(clabel, slabel)))
1341 			resp->access |= ACCESS4_EXECUTE;
1342 		resp->supported |= ACCESS4_EXECUTE;
1343 	}
1344 
1345 	if (is_system_labeled() && !admin_low_client)
1346 		label_rele(tslabel);
1347 
1348 	*cs->statusp = resp->status = NFS4_OK;
1349 out:
1350 	DTRACE_NFSV4_2(op__access__done, struct compound_state *, cs,
1351 	    ACCESS4res *, resp);
1352 }
1353 
1354 /* ARGSUSED */
1355 static void
1356 rfs4_op_commit(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
1357 	struct compound_state *cs)
1358 {
1359 	COMMIT4args *args = &argop->nfs_argop4_u.opcommit;
1360 	COMMIT4res *resp = &resop->nfs_resop4_u.opcommit;
1361 	int error;
1362 	vnode_t *vp = cs->vp;
1363 	cred_t *cr = cs->cr;
1364 	vattr_t va;
1365 
1366 	DTRACE_NFSV4_2(op__commit__start, struct compound_state *, cs,
1367 	    COMMIT4args *, args);
1368 
1369 	if (vp == NULL) {
1370 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
1371 		goto out;
1372 	}
1373 	if (cs->access == CS_ACCESS_DENIED) {
1374 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
1375 		goto out;
1376 	}
1377 
1378 	if (args->offset + args->count < args->offset) {
1379 		*cs->statusp = resp->status = NFS4ERR_INVAL;
1380 		goto out;
1381 	}
1382 
1383 	va.va_mask = AT_UID;
1384 	error = VOP_GETATTR(vp, &va, 0, cr, NULL);
1385 
1386 	/*
1387 	 * If we can't get the attributes, then we can't do the
1388 	 * right access checking.  So, we'll fail the request.
1389 	 */
1390 	if (error) {
1391 		*cs->statusp = resp->status = puterrno4(error);
1392 		goto out;
1393 	}
1394 	if (rdonly4(cs->exi, cs->vp, req)) {
1395 		*cs->statusp = resp->status = NFS4ERR_ROFS;
1396 		goto out;
1397 	}
1398 
1399 	if (vp->v_type != VREG) {
1400 		if (vp->v_type == VDIR)
1401 			resp->status = NFS4ERR_ISDIR;
1402 		else
1403 			resp->status = NFS4ERR_INVAL;
1404 		*cs->statusp = resp->status;
1405 		goto out;
1406 	}
1407 
1408 	if (crgetuid(cr) != va.va_uid &&
1409 	    (error = VOP_ACCESS(vp, VWRITE, 0, cs->cr, NULL))) {
1410 		*cs->statusp = resp->status = puterrno4(error);
1411 		goto out;
1412 	}
1413 
1414 	error = VOP_PUTPAGE(vp, args->offset, args->count, 0, cr, NULL);
1415 	if (!error)
1416 		error = VOP_FSYNC(vp, FNODSYNC, cr, NULL);
1417 
1418 	if (error) {
1419 		*cs->statusp = resp->status = puterrno4(error);
1420 		goto out;
1421 	}
1422 
1423 	*cs->statusp = resp->status = NFS4_OK;
1424 	resp->writeverf = Write4verf;
1425 out:
1426 	DTRACE_NFSV4_2(op__commit__done, struct compound_state *, cs,
1427 	    COMMIT4res *, resp);
1428 }
1429 
1430 /*
1431  * rfs4_op_mknod is called from rfs4_op_create after all initial verification
1432  * was completed. It does the nfsv4 create for special files.
1433  */
1434 /* ARGSUSED */
1435 static vnode_t *
1436 do_rfs4_op_mknod(CREATE4args *args, CREATE4res *resp, struct svc_req *req,
1437 	struct compound_state *cs, vattr_t *vap, char *nm)
1438 {
1439 	int error;
1440 	cred_t *cr = cs->cr;
1441 	vnode_t *dvp = cs->vp;
1442 	vnode_t *vp = NULL;
1443 	int mode;
1444 	enum vcexcl excl;
1445 
1446 	switch (args->type) {
1447 	case NF4CHR:
1448 	case NF4BLK:
1449 		if (secpolicy_sys_devices(cr) != 0) {
1450 			*cs->statusp = resp->status = NFS4ERR_PERM;
1451 			return (NULL);
1452 		}
1453 		if (args->type == NF4CHR)
1454 			vap->va_type = VCHR;
1455 		else
1456 			vap->va_type = VBLK;
1457 		vap->va_rdev = makedevice(args->ftype4_u.devdata.specdata1,
1458 		    args->ftype4_u.devdata.specdata2);
1459 		vap->va_mask |= AT_RDEV;
1460 		break;
1461 	case NF4SOCK:
1462 		vap->va_type = VSOCK;
1463 		break;
1464 	case NF4FIFO:
1465 		vap->va_type = VFIFO;
1466 		break;
1467 	default:
1468 		*cs->statusp = resp->status = NFS4ERR_BADTYPE;
1469 		return (NULL);
1470 	}
1471 
1472 	/*
1473 	 * Must specify the mode.
1474 	 */
1475 	if (!(vap->va_mask & AT_MODE)) {
1476 		*cs->statusp = resp->status = NFS4ERR_INVAL;
1477 		return (NULL);
1478 	}
1479 
1480 	excl = EXCL;
1481 
1482 	mode = 0;
1483 
1484 	error = VOP_CREATE(dvp, nm, vap, excl, mode, &vp, cr, 0, NULL, NULL);
1485 	if (error) {
1486 		*cs->statusp = resp->status = puterrno4(error);
1487 		return (NULL);
1488 	}
1489 	return (vp);
1490 }
1491 
1492 /*
1493  * nfsv4 create is used to create non-regular files. For regular files,
1494  * use nfsv4 open.
1495  */
1496 /* ARGSUSED */
1497 static void
1498 rfs4_op_create(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
1499 	struct compound_state *cs)
1500 {
1501 	CREATE4args *args = &argop->nfs_argop4_u.opcreate;
1502 	CREATE4res *resp = &resop->nfs_resop4_u.opcreate;
1503 	int error;
1504 	struct vattr bva, iva, iva2, ava, *vap;
1505 	cred_t *cr = cs->cr;
1506 	vnode_t *dvp = cs->vp;
1507 	vnode_t *vp = NULL;
1508 	vnode_t *realvp;
1509 	char *nm, *lnm;
1510 	uint_t len, llen;
1511 	int syncval = 0;
1512 	struct nfs4_svgetit_arg sarg;
1513 	struct nfs4_ntov_table ntov;
1514 	struct statvfs64 sb;
1515 	nfsstat4 status;
1516 
1517 	DTRACE_NFSV4_2(op__create__start, struct compound_state *, cs,
1518 	    CREATE4args *, args);
1519 
1520 	resp->attrset = 0;
1521 
1522 	if (dvp == NULL) {
1523 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
1524 		goto out;
1525 	}
1526 
1527 	/*
1528 	 * If there is an unshared filesystem mounted on this vnode,
1529 	 * do not allow to create an object in this directory.
1530 	 */
1531 	if (vn_ismntpt(dvp)) {
1532 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
1533 		goto out;
1534 	}
1535 
1536 	/* Verify that type is correct */
1537 	switch (args->type) {
1538 	case NF4LNK:
1539 	case NF4BLK:
1540 	case NF4CHR:
1541 	case NF4SOCK:
1542 	case NF4FIFO:
1543 	case NF4DIR:
1544 		break;
1545 	default:
1546 		*cs->statusp = resp->status = NFS4ERR_BADTYPE;
1547 		goto out;
1548 	};
1549 
1550 	if (cs->access == CS_ACCESS_DENIED) {
1551 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
1552 		goto out;
1553 	}
1554 	if (dvp->v_type != VDIR) {
1555 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
1556 		goto out;
1557 	}
1558 	if (!utf8_dir_verify(&args->objname)) {
1559 		*cs->statusp = resp->status = NFS4ERR_INVAL;
1560 		goto out;
1561 	}
1562 
1563 	if (rdonly4(cs->exi, cs->vp, req)) {
1564 		*cs->statusp = resp->status = NFS4ERR_ROFS;
1565 		goto out;
1566 	}
1567 
1568 	/*
1569 	 * Name of newly created object
1570 	 */
1571 	nm = utf8_to_fn(&args->objname, &len, NULL);
1572 	if (nm == NULL) {
1573 		*cs->statusp = resp->status = NFS4ERR_INVAL;
1574 		goto out;
1575 	}
1576 
1577 	if (len > MAXNAMELEN) {
1578 		*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
1579 		kmem_free(nm, len);
1580 		goto out;
1581 	}
1582 
1583 	resp->attrset = 0;
1584 
1585 	sarg.sbp = &sb;
1586 	nfs4_ntov_table_init(&ntov);
1587 
1588 	status = do_rfs4_set_attrs(&resp->attrset,
1589 	    &args->createattrs, cs, &sarg, &ntov, NFS4ATTR_SETIT);
1590 
1591 	if (sarg.vap->va_mask == 0 && status == NFS4_OK)
1592 		status = NFS4ERR_INVAL;
1593 
1594 	if (status != NFS4_OK) {
1595 		*cs->statusp = resp->status = status;
1596 		kmem_free(nm, len);
1597 		nfs4_ntov_table_free(&ntov, &sarg);
1598 		resp->attrset = 0;
1599 		goto out;
1600 	}
1601 
1602 	/* Get "before" change value */
1603 	bva.va_mask = AT_CTIME|AT_SEQ;
1604 	error = VOP_GETATTR(dvp, &bva, 0, cr, NULL);
1605 	if (error) {
1606 		*cs->statusp = resp->status = puterrno4(error);
1607 		kmem_free(nm, len);
1608 		nfs4_ntov_table_free(&ntov, &sarg);
1609 		resp->attrset = 0;
1610 		goto out;
1611 	}
1612 	NFS4_SET_FATTR4_CHANGE(resp->cinfo.before, bva.va_ctime)
1613 
1614 	vap = sarg.vap;
1615 
1616 	/*
1617 	 * Set default initial values for attributes when not specified
1618 	 * in createattrs.
1619 	 */
1620 	if ((vap->va_mask & AT_UID) == 0) {
1621 		vap->va_uid = crgetuid(cr);
1622 		vap->va_mask |= AT_UID;
1623 	}
1624 	if ((vap->va_mask & AT_GID) == 0) {
1625 		vap->va_gid = crgetgid(cr);
1626 		vap->va_mask |= AT_GID;
1627 	}
1628 
1629 	vap->va_mask |= AT_TYPE;
1630 	switch (args->type) {
1631 	case NF4DIR:
1632 		vap->va_type = VDIR;
1633 		if ((vap->va_mask & AT_MODE) == 0) {
1634 			vap->va_mode = 0700;	/* default: owner rwx only */
1635 			vap->va_mask |= AT_MODE;
1636 		}
1637 		error = VOP_MKDIR(dvp, nm, vap, &vp, cr, NULL, 0, NULL);
1638 		if (error)
1639 			break;
1640 
1641 		/*
1642 		 * Get the initial "after" sequence number, if it fails,
1643 		 * set to zero
1644 		 */
1645 		iva.va_mask = AT_SEQ;
1646 		if (VOP_GETATTR(dvp, &iva, 0, cs->cr, NULL))
1647 			iva.va_seq = 0;
1648 		break;
1649 	case NF4LNK:
1650 		vap->va_type = VLNK;
1651 		if ((vap->va_mask & AT_MODE) == 0) {
1652 			vap->va_mode = 0700;	/* default: owner rwx only */
1653 			vap->va_mask |= AT_MODE;
1654 		}
1655 
1656 		/*
1657 		 * symlink names must be treated as data
1658 		 */
1659 		lnm = utf8_to_str(&args->ftype4_u.linkdata, &llen, NULL);
1660 
1661 		if (lnm == NULL) {
1662 			*cs->statusp = resp->status = NFS4ERR_INVAL;
1663 			kmem_free(nm, len);
1664 			nfs4_ntov_table_free(&ntov, &sarg);
1665 			resp->attrset = 0;
1666 			goto out;
1667 		}
1668 
1669 		if (llen > MAXPATHLEN) {
1670 			*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
1671 			kmem_free(nm, len);
1672 			kmem_free(lnm, llen);
1673 			nfs4_ntov_table_free(&ntov, &sarg);
1674 			resp->attrset = 0;
1675 			goto out;
1676 		}
1677 
1678 		error = VOP_SYMLINK(dvp, nm, vap, lnm, cr, NULL, 0);
1679 		if (lnm != NULL)
1680 			kmem_free(lnm, llen);
1681 		if (error)
1682 			break;
1683 
1684 		/*
1685 		 * Get the initial "after" sequence number, if it fails,
1686 		 * set to zero
1687 		 */
1688 		iva.va_mask = AT_SEQ;
1689 		if (VOP_GETATTR(dvp, &iva, 0, cs->cr, NULL))
1690 			iva.va_seq = 0;
1691 
1692 		error = VOP_LOOKUP(dvp, nm, &vp, NULL, 0, NULL, cr,
1693 		    NULL, NULL, NULL);
1694 		if (error)
1695 			break;
1696 
1697 		/*
1698 		 * va_seq is not safe over VOP calls, check it again
1699 		 * if it has changed zero out iva to force atomic = FALSE.
1700 		 */
1701 		iva2.va_mask = AT_SEQ;
1702 		if (VOP_GETATTR(dvp, &iva2, 0, cs->cr, NULL) ||
1703 		    iva2.va_seq != iva.va_seq)
1704 			iva.va_seq = 0;
1705 		break;
1706 	default:
1707 		/*
1708 		 * probably a special file.
1709 		 */
1710 		if ((vap->va_mask & AT_MODE) == 0) {
1711 			vap->va_mode = 0600;	/* default: owner rw only */
1712 			vap->va_mask |= AT_MODE;
1713 		}
1714 		syncval = FNODSYNC;
1715 		/*
1716 		 * We know this will only generate one VOP call
1717 		 */
1718 		vp = do_rfs4_op_mknod(args, resp, req, cs, vap, nm);
1719 
1720 		if (vp == NULL) {
1721 			kmem_free(nm, len);
1722 			nfs4_ntov_table_free(&ntov, &sarg);
1723 			resp->attrset = 0;
1724 			goto out;
1725 		}
1726 
1727 		/*
1728 		 * Get the initial "after" sequence number, if it fails,
1729 		 * set to zero
1730 		 */
1731 		iva.va_mask = AT_SEQ;
1732 		if (VOP_GETATTR(dvp, &iva, 0, cs->cr, NULL))
1733 			iva.va_seq = 0;
1734 
1735 		break;
1736 	}
1737 	kmem_free(nm, len);
1738 
1739 	if (error) {
1740 		*cs->statusp = resp->status = puterrno4(error);
1741 	}
1742 
1743 	/*
1744 	 * Force modified data and metadata out to stable storage.
1745 	 */
1746 	(void) VOP_FSYNC(dvp, 0, cr, NULL);
1747 
1748 	if (resp->status != NFS4_OK) {
1749 		if (vp != NULL)
1750 			VN_RELE(vp);
1751 		nfs4_ntov_table_free(&ntov, &sarg);
1752 		resp->attrset = 0;
1753 		goto out;
1754 	}
1755 
1756 	/*
1757 	 * Finish setup of cinfo response, "before" value already set.
1758 	 * Get "after" change value, if it fails, simply return the
1759 	 * before value.
1760 	 */
1761 	ava.va_mask = AT_CTIME|AT_SEQ;
1762 	if (VOP_GETATTR(dvp, &ava, 0, cr, NULL)) {
1763 		ava.va_ctime = bva.va_ctime;
1764 		ava.va_seq = 0;
1765 	}
1766 	NFS4_SET_FATTR4_CHANGE(resp->cinfo.after, ava.va_ctime);
1767 
1768 	/*
1769 	 * True verification that object was created with correct
1770 	 * attrs is impossible.  The attrs could have been changed
1771 	 * immediately after object creation.  If attributes did
1772 	 * not verify, the only recourse for the server is to
1773 	 * destroy the object.  Maybe if some attrs (like gid)
1774 	 * are set incorrectly, the object should be destroyed;
1775 	 * however, seems bad as a default policy.  Do we really
1776 	 * want to destroy an object over one of the times not
1777 	 * verifying correctly?  For these reasons, the server
1778 	 * currently sets bits in attrset for createattrs
1779 	 * that were set; however, no verification is done.
1780 	 *
1781 	 * vmask_to_nmask accounts for vattr bits set on create
1782 	 *	[do_rfs4_set_attrs() only sets resp bits for
1783 	 *	 non-vattr/vfs bits.]
1784 	 * Mask off any bits set by default so as not to return
1785 	 * more attrset bits than were requested in createattrs
1786 	 */
1787 	nfs4_vmask_to_nmask(sarg.vap->va_mask, &resp->attrset);
1788 	resp->attrset &= args->createattrs.attrmask;
1789 	nfs4_ntov_table_free(&ntov, &sarg);
1790 
1791 	error = makefh4(&cs->fh, vp, cs->exi);
1792 	if (error) {
1793 		*cs->statusp = resp->status = puterrno4(error);
1794 	}
1795 
1796 	/*
1797 	 * The cinfo.atomic = TRUE only if we got no errors, we have
1798 	 * non-zero va_seq's, and it has incremented by exactly one
1799 	 * during the creation and it didn't change during the VOP_LOOKUP
1800 	 * or VOP_FSYNC.
1801 	 */
1802 	if (!error && bva.va_seq && iva.va_seq && ava.va_seq &&
1803 	    iva.va_seq == (bva.va_seq + 1) && iva.va_seq == ava.va_seq)
1804 		resp->cinfo.atomic = TRUE;
1805 	else
1806 		resp->cinfo.atomic = FALSE;
1807 
1808 	/*
1809 	 * Force modified metadata out to stable storage.
1810 	 *
1811 	 * if a underlying vp exists, pass it to VOP_FSYNC
1812 	 */
1813 	if (VOP_REALVP(vp, &realvp, NULL) == 0)
1814 		(void) VOP_FSYNC(realvp, syncval, cr, NULL);
1815 	else
1816 		(void) VOP_FSYNC(vp, syncval, cr, NULL);
1817 
1818 	if (resp->status != NFS4_OK) {
1819 		VN_RELE(vp);
1820 		goto out;
1821 	}
1822 	if (cs->vp)
1823 		VN_RELE(cs->vp);
1824 
1825 	cs->vp = vp;
1826 	*cs->statusp = resp->status = NFS4_OK;
1827 out:
1828 	DTRACE_NFSV4_2(op__create__done, struct compound_state *, cs,
1829 	    CREATE4res *, resp);
1830 }
1831 
1832 /*ARGSUSED*/
1833 static void
1834 rfs4_op_delegpurge(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
1835     struct compound_state *cs)
1836 {
1837 	DTRACE_NFSV4_2(op__delegpurge__start, struct compound_state *, cs,
1838 	    DELEGPURGE4args *, &argop->nfs_argop4_u.opdelegpurge);
1839 
1840 	rfs4_op_inval(argop, resop, req, cs);
1841 
1842 	DTRACE_NFSV4_2(op__delegpurge__done, struct compound_state *, cs,
1843 	    DELEGPURGE4res *, &resop->nfs_resop4_u.opdelegpurge);
1844 }
1845 
1846 /*ARGSUSED*/
1847 static void
1848 rfs4_op_delegreturn(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
1849 	struct compound_state *cs)
1850 {
1851 	DELEGRETURN4args *args = &argop->nfs_argop4_u.opdelegreturn;
1852 	DELEGRETURN4res *resp = &resop->nfs_resop4_u.opdelegreturn;
1853 	rfs4_deleg_state_t *dsp;
1854 	nfsstat4 status;
1855 
1856 	DTRACE_NFSV4_2(op__delegreturn__start, struct compound_state *, cs,
1857 	    DELEGRETURN4args *, args);
1858 
1859 	status = rfs4_get_deleg_state(&args->deleg_stateid, &dsp);
1860 	resp->status = *cs->statusp = status;
1861 	if (status != NFS4_OK)
1862 		goto out;
1863 
1864 	/* Ensure specified filehandle matches */
1865 	if (cs->vp != dsp->finfo->vp) {
1866 		resp->status = *cs->statusp = NFS4ERR_BAD_STATEID;
1867 	} else
1868 		rfs4_return_deleg(dsp, FALSE);
1869 
1870 	rfs4_update_lease(dsp->client);
1871 
1872 	rfs4_deleg_state_rele(dsp);
1873 out:
1874 	DTRACE_NFSV4_2(op__delegreturn__done, struct compound_state *, cs,
1875 	    DELEGRETURN4res *, resp);
1876 }
1877 
1878 /*
1879  * Check to see if a given "flavor" is an explicitly shared flavor.
1880  * The assumption of this routine is the "flavor" is already a valid
1881  * flavor in the secinfo list of "exi".
1882  *
1883  *	e.g.
1884  *		# share -o sec=flavor1 /export
1885  *		# share -o sec=flavor2 /export/home
1886  *
1887  *		flavor2 is not an explicitly shared flavor for /export,
1888  *		however it is in the secinfo list for /export thru the
1889  *		server namespace setup.
1890  */
1891 int
1892 is_exported_sec(int flavor, struct exportinfo *exi)
1893 {
1894 	int	i;
1895 	struct secinfo *sp;
1896 
1897 	sp = exi->exi_export.ex_secinfo;
1898 	for (i = 0; i < exi->exi_export.ex_seccnt; i++) {
1899 		if (flavor == sp[i].s_secinfo.sc_nfsnum ||
1900 		    sp[i].s_secinfo.sc_nfsnum == AUTH_NONE) {
1901 			return (SEC_REF_EXPORTED(&sp[i]));
1902 		}
1903 	}
1904 
1905 	/* Should not reach this point based on the assumption */
1906 	return (0);
1907 }
1908 
1909 /*
1910  * Check if the security flavor used in the request matches what is
1911  * required at the export point or at the root pseudo node (exi_root).
1912  *
1913  * returns 1 if there's a match or if exported with AUTH_NONE; 0 otherwise.
1914  *
1915  */
1916 static int
1917 secinfo_match_or_authnone(struct compound_state *cs)
1918 {
1919 	int	i;
1920 	struct secinfo *sp;
1921 
1922 	/*
1923 	 * Check cs->nfsflavor (from the request) against
1924 	 * the current export data in cs->exi.
1925 	 */
1926 	sp = cs->exi->exi_export.ex_secinfo;
1927 	for (i = 0; i < cs->exi->exi_export.ex_seccnt; i++) {
1928 		if (cs->nfsflavor == sp[i].s_secinfo.sc_nfsnum ||
1929 		    sp[i].s_secinfo.sc_nfsnum == AUTH_NONE)
1930 			return (1);
1931 	}
1932 
1933 	return (0);
1934 }
1935 
1936 /*
1937  * Check the access authority for the client and return the correct error.
1938  */
1939 nfsstat4
1940 call_checkauth4(struct compound_state *cs, struct svc_req *req)
1941 {
1942 	int	authres;
1943 
1944 	/*
1945 	 * First, check if the security flavor used in the request
1946 	 * are among the flavors set in the server namespace.
1947 	 */
1948 	if (!secinfo_match_or_authnone(cs)) {
1949 		*cs->statusp = NFS4ERR_WRONGSEC;
1950 		return (*cs->statusp);
1951 	}
1952 
1953 	authres = checkauth4(cs, req);
1954 
1955 	if (authres > 0) {
1956 		*cs->statusp = NFS4_OK;
1957 		if (! (cs->access & CS_ACCESS_LIMITED))
1958 			cs->access = CS_ACCESS_OK;
1959 	} else if (authres == 0) {
1960 		*cs->statusp = NFS4ERR_ACCESS;
1961 	} else if (authres == -2) {
1962 		*cs->statusp = NFS4ERR_WRONGSEC;
1963 	} else {
1964 		*cs->statusp = NFS4ERR_DELAY;
1965 	}
1966 	return (*cs->statusp);
1967 }
1968 
1969 /*
1970  * bitmap4_to_attrmask is called by getattr and readdir.
1971  * It sets up the vattr mask and determines whether vfsstat call is needed
1972  * based on the input bitmap.
1973  * Returns nfsv4 status.
1974  */
1975 static nfsstat4
1976 bitmap4_to_attrmask(bitmap4 breq, struct nfs4_svgetit_arg *sargp)
1977 {
1978 	int i;
1979 	uint_t	va_mask;
1980 	struct statvfs64 *sbp = sargp->sbp;
1981 
1982 	sargp->sbp = NULL;
1983 	sargp->flag = 0;
1984 	sargp->rdattr_error = NFS4_OK;
1985 	sargp->mntdfid_set = FALSE;
1986 	if (sargp->cs->vp)
1987 		sargp->xattr = get_fh4_flag(&sargp->cs->fh,
1988 		    FH4_ATTRDIR | FH4_NAMEDATTR);
1989 	else
1990 		sargp->xattr = 0;
1991 
1992 	/*
1993 	 * Set rdattr_error_req to true if return error per
1994 	 * failed entry rather than fail the readdir.
1995 	 */
1996 	if (breq & FATTR4_RDATTR_ERROR_MASK)
1997 		sargp->rdattr_error_req = 1;
1998 	else
1999 		sargp->rdattr_error_req = 0;
2000 
2001 	/*
2002 	 * generate the va_mask
2003 	 * Handle the easy cases first
2004 	 */
2005 	switch (breq) {
2006 	case NFS4_NTOV_ATTR_MASK:
2007 		sargp->vap->va_mask = NFS4_NTOV_ATTR_AT_MASK;
2008 		return (NFS4_OK);
2009 
2010 	case NFS4_FS_ATTR_MASK:
2011 		sargp->vap->va_mask = NFS4_FS_ATTR_AT_MASK;
2012 		sargp->sbp = sbp;
2013 		return (NFS4_OK);
2014 
2015 	case NFS4_NTOV_ATTR_CACHE_MASK:
2016 		sargp->vap->va_mask = NFS4_NTOV_ATTR_CACHE_AT_MASK;
2017 		return (NFS4_OK);
2018 
2019 	case FATTR4_LEASE_TIME_MASK:
2020 		sargp->vap->va_mask = 0;
2021 		return (NFS4_OK);
2022 
2023 	default:
2024 		va_mask = 0;
2025 		for (i = 0; i < nfs4_ntov_map_size; i++) {
2026 			if ((breq & nfs4_ntov_map[i].fbit) &&
2027 			    nfs4_ntov_map[i].vbit)
2028 				va_mask |= nfs4_ntov_map[i].vbit;
2029 		}
2030 
2031 		/*
2032 		 * Check is vfsstat is needed
2033 		 */
2034 		if (breq & NFS4_FS_ATTR_MASK)
2035 			sargp->sbp = sbp;
2036 
2037 		sargp->vap->va_mask = va_mask;
2038 		return (NFS4_OK);
2039 	}
2040 	/* NOTREACHED */
2041 }
2042 
2043 /*
2044  * bitmap4_get_sysattrs is called by getattr and readdir.
2045  * It calls both VOP_GETATTR and VFS_STATVFS calls to get the attrs.
2046  * Returns nfsv4 status.
2047  */
2048 static nfsstat4
2049 bitmap4_get_sysattrs(struct nfs4_svgetit_arg *sargp)
2050 {
2051 	int error;
2052 	struct compound_state *cs = sargp->cs;
2053 	vnode_t *vp = cs->vp;
2054 
2055 	if (sargp->sbp != NULL) {
2056 		if (error = VFS_STATVFS(vp->v_vfsp, sargp->sbp)) {
2057 			sargp->sbp = NULL;	/* to identify error */
2058 			return (puterrno4(error));
2059 		}
2060 	}
2061 
2062 	return (rfs4_vop_getattr(vp, sargp->vap, 0, cs->cr));
2063 }
2064 
2065 static void
2066 nfs4_ntov_table_init(struct nfs4_ntov_table *ntovp)
2067 {
2068 	ntovp->na = kmem_zalloc(sizeof (union nfs4_attr_u) * nfs4_ntov_map_size,
2069 	    KM_SLEEP);
2070 	ntovp->attrcnt = 0;
2071 	ntovp->vfsstat = FALSE;
2072 }
2073 
2074 static void
2075 nfs4_ntov_table_free(struct nfs4_ntov_table *ntovp,
2076 	struct nfs4_svgetit_arg *sargp)
2077 {
2078 	int i;
2079 	union nfs4_attr_u *na;
2080 	uint8_t *amap;
2081 
2082 	/*
2083 	 * XXX Should do the same checks for whether the bit is set
2084 	 */
2085 	for (i = 0, na = ntovp->na, amap = ntovp->amap;
2086 	    i < ntovp->attrcnt; i++, na++, amap++) {
2087 		(void) (*nfs4_ntov_map[*amap].sv_getit)(
2088 		    NFS4ATTR_FREEIT, sargp, na);
2089 	}
2090 	if ((sargp->op == NFS4ATTR_SETIT) || (sargp->op == NFS4ATTR_VERIT)) {
2091 		/*
2092 		 * xdr_free for getattr will be done later
2093 		 */
2094 		for (i = 0, na = ntovp->na, amap = ntovp->amap;
2095 		    i < ntovp->attrcnt; i++, na++, amap++) {
2096 			xdr_free(nfs4_ntov_map[*amap].xfunc, (caddr_t)na);
2097 		}
2098 	}
2099 	kmem_free(ntovp->na, sizeof (union nfs4_attr_u) * nfs4_ntov_map_size);
2100 }
2101 
2102 /*
2103  * do_rfs4_op_getattr gets the system attrs and converts into fattr4.
2104  */
2105 static nfsstat4
2106 do_rfs4_op_getattr(bitmap4 breq, fattr4 *fattrp,
2107 	struct nfs4_svgetit_arg *sargp)
2108 {
2109 	int error = 0;
2110 	int i, k;
2111 	struct nfs4_ntov_table ntov;
2112 	XDR xdr;
2113 	ulong_t xdr_size;
2114 	char *xdr_attrs;
2115 	nfsstat4 status = NFS4_OK;
2116 	nfsstat4 prev_rdattr_error = sargp->rdattr_error;
2117 	union nfs4_attr_u *na;
2118 	uint8_t *amap;
2119 
2120 	sargp->op = NFS4ATTR_GETIT;
2121 	sargp->flag = 0;
2122 
2123 	fattrp->attrmask = 0;
2124 	/* if no bits requested, then return empty fattr4 */
2125 	if (breq == 0) {
2126 		fattrp->attrlist4_len = 0;
2127 		fattrp->attrlist4 = NULL;
2128 		return (NFS4_OK);
2129 	}
2130 
2131 	/*
2132 	 * return NFS4ERR_INVAL when client requests write-only attrs
2133 	 */
2134 	if (breq & (FATTR4_TIME_ACCESS_SET_MASK | FATTR4_TIME_MODIFY_SET_MASK))
2135 		return (NFS4ERR_INVAL);
2136 
2137 	nfs4_ntov_table_init(&ntov);
2138 	na = ntov.na;
2139 	amap = ntov.amap;
2140 
2141 	/*
2142 	 * Now loop to get or verify the attrs
2143 	 */
2144 	for (i = 0; i < nfs4_ntov_map_size; i++) {
2145 		if (breq & nfs4_ntov_map[i].fbit) {
2146 			if ((*nfs4_ntov_map[i].sv_getit)(
2147 			    NFS4ATTR_SUPPORTED, sargp, NULL) == 0) {
2148 
2149 				error = (*nfs4_ntov_map[i].sv_getit)(
2150 				    NFS4ATTR_GETIT, sargp, na);
2151 
2152 				/*
2153 				 * Possible error values:
2154 				 * >0 if sv_getit failed to
2155 				 * get the attr; 0 if succeeded;
2156 				 * <0 if rdattr_error and the
2157 				 * attribute cannot be returned.
2158 				 */
2159 				if (error && !(sargp->rdattr_error_req))
2160 					goto done;
2161 				/*
2162 				 * If error then just for entry
2163 				 */
2164 				if (error == 0) {
2165 					fattrp->attrmask |=
2166 					    nfs4_ntov_map[i].fbit;
2167 					*amap++ =
2168 					    (uint8_t)nfs4_ntov_map[i].nval;
2169 					na++;
2170 					(ntov.attrcnt)++;
2171 				} else if ((error > 0) &&
2172 				    (sargp->rdattr_error == NFS4_OK)) {
2173 					sargp->rdattr_error = puterrno4(error);
2174 				}
2175 				error = 0;
2176 			}
2177 		}
2178 	}
2179 
2180 	/*
2181 	 * If rdattr_error was set after the return value for it was assigned,
2182 	 * update it.
2183 	 */
2184 	if (prev_rdattr_error != sargp->rdattr_error) {
2185 		na = ntov.na;
2186 		amap = ntov.amap;
2187 		for (i = 0; i < ntov.attrcnt; i++, na++, amap++) {
2188 			k = *amap;
2189 			if (k < FATTR4_RDATTR_ERROR) {
2190 				continue;
2191 			}
2192 			if ((k == FATTR4_RDATTR_ERROR) &&
2193 			    ((*nfs4_ntov_map[k].sv_getit)(
2194 			    NFS4ATTR_SUPPORTED, sargp, NULL) == 0)) {
2195 
2196 				(void) (*nfs4_ntov_map[k].sv_getit)(
2197 				    NFS4ATTR_GETIT, sargp, na);
2198 			}
2199 			break;
2200 		}
2201 	}
2202 
2203 	xdr_size = 0;
2204 	na = ntov.na;
2205 	amap = ntov.amap;
2206 	for (i = 0; i < ntov.attrcnt; i++, na++, amap++) {
2207 		xdr_size += xdr_sizeof(nfs4_ntov_map[*amap].xfunc, na);
2208 	}
2209 
2210 	fattrp->attrlist4_len = xdr_size;
2211 	if (xdr_size) {
2212 		/* freed by rfs4_op_getattr_free() */
2213 		fattrp->attrlist4 = xdr_attrs = kmem_zalloc(xdr_size, KM_SLEEP);
2214 
2215 		xdrmem_create(&xdr, xdr_attrs, xdr_size, XDR_ENCODE);
2216 
2217 		na = ntov.na;
2218 		amap = ntov.amap;
2219 		for (i = 0; i < ntov.attrcnt; i++, na++, amap++) {
2220 			if (!(*nfs4_ntov_map[*amap].xfunc)(&xdr, na)) {
2221 				cmn_err(CE_WARN, "do_rfs4_op_getattr: xdr "
2222 				    "encode of attribute %d failed\n", *amap);
2223 				status = NFS4ERR_SERVERFAULT;
2224 				break;
2225 			}
2226 		}
2227 		/* xdrmem_destroy(&xdrs); */	/* NO-OP */
2228 	} else {
2229 		fattrp->attrlist4 = NULL;
2230 	}
2231 done:
2232 
2233 	nfs4_ntov_table_free(&ntov, sargp);
2234 
2235 	if (error != 0)
2236 		status = puterrno4(error);
2237 
2238 	return (status);
2239 }
2240 
2241 /* ARGSUSED */
2242 static void
2243 rfs4_op_getattr(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
2244 	struct compound_state *cs)
2245 {
2246 	GETATTR4args *args = &argop->nfs_argop4_u.opgetattr;
2247 	GETATTR4res *resp = &resop->nfs_resop4_u.opgetattr;
2248 	struct nfs4_svgetit_arg sarg;
2249 	struct statvfs64 sb;
2250 	nfsstat4 status;
2251 
2252 	DTRACE_NFSV4_2(op__getattr__start, struct compound_state *, cs,
2253 	    GETATTR4args *, args);
2254 
2255 	if (cs->vp == NULL) {
2256 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2257 		goto out;
2258 	}
2259 
2260 	if (cs->access == CS_ACCESS_DENIED) {
2261 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
2262 		goto out;
2263 	}
2264 
2265 	sarg.sbp = &sb;
2266 	sarg.cs = cs;
2267 
2268 	status = bitmap4_to_attrmask(args->attr_request, &sarg);
2269 	if (status == NFS4_OK) {
2270 		status = bitmap4_get_sysattrs(&sarg);
2271 		if (status == NFS4_OK)
2272 			status = do_rfs4_op_getattr(args->attr_request,
2273 			    &resp->obj_attributes, &sarg);
2274 	}
2275 	*cs->statusp = resp->status = status;
2276 out:
2277 	DTRACE_NFSV4_2(op__getattr__done, struct compound_state *, cs,
2278 	    GETATTR4res *, resp);
2279 }
2280 
2281 static void
2282 rfs4_op_getattr_free(nfs_resop4 *resop)
2283 {
2284 	GETATTR4res *resp = &resop->nfs_resop4_u.opgetattr;
2285 
2286 	nfs4_fattr4_free(&resp->obj_attributes);
2287 }
2288 
2289 /* ARGSUSED */
2290 static void
2291 rfs4_op_getfh(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
2292 	struct compound_state *cs)
2293 {
2294 	GETFH4res *resp = &resop->nfs_resop4_u.opgetfh;
2295 
2296 	DTRACE_NFSV4_1(op__getfh__start, struct compound_state *, cs);
2297 
2298 	if (cs->vp == NULL) {
2299 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2300 		goto out;
2301 	}
2302 	if (cs->access == CS_ACCESS_DENIED) {
2303 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
2304 		goto out;
2305 	}
2306 
2307 	resp->object.nfs_fh4_val =
2308 	    kmem_alloc(cs->fh.nfs_fh4_len, KM_SLEEP);
2309 	nfs_fh4_copy(&cs->fh, &resp->object);
2310 	*cs->statusp = resp->status = NFS4_OK;
2311 out:
2312 	DTRACE_NFSV4_2(op__getfh__done, struct compound_state *, cs,
2313 	    GETFH4res *, resp);
2314 }
2315 
2316 static void
2317 rfs4_op_getfh_free(nfs_resop4 *resop)
2318 {
2319 	GETFH4res *resp = &resop->nfs_resop4_u.opgetfh;
2320 
2321 	if (resp->status == NFS4_OK &&
2322 	    resp->object.nfs_fh4_val != NULL) {
2323 		kmem_free(resp->object.nfs_fh4_val, resp->object.nfs_fh4_len);
2324 		resp->object.nfs_fh4_val = NULL;
2325 		resp->object.nfs_fh4_len = 0;
2326 	}
2327 }
2328 
2329 /*
2330  * illegal: args: void
2331  *	    res : status (NFS4ERR_OP_ILLEGAL)
2332  */
2333 /* ARGSUSED */
2334 static void
2335 rfs4_op_illegal(nfs_argop4 *argop, nfs_resop4 *resop,
2336 	struct svc_req *req, struct compound_state *cs)
2337 {
2338 	ILLEGAL4res *resp = &resop->nfs_resop4_u.opillegal;
2339 
2340 	resop->resop = OP_ILLEGAL;
2341 	*cs->statusp = resp->status = NFS4ERR_OP_ILLEGAL;
2342 }
2343 
2344 /*
2345  * link: args: SAVED_FH: file, CURRENT_FH: target directory
2346  *	 res: status. If success - CURRENT_FH unchanged, return change_info
2347  */
2348 /* ARGSUSED */
2349 static void
2350 rfs4_op_link(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
2351 	struct compound_state *cs)
2352 {
2353 	LINK4args *args = &argop->nfs_argop4_u.oplink;
2354 	LINK4res *resp = &resop->nfs_resop4_u.oplink;
2355 	int error;
2356 	vnode_t *vp;
2357 	vnode_t *dvp;
2358 	struct vattr bdva, idva, adva;
2359 	char *nm;
2360 	uint_t  len;
2361 
2362 	DTRACE_NFSV4_2(op__link__start, struct compound_state *, cs,
2363 	    LINK4args *, args);
2364 
2365 	/* SAVED_FH: source object */
2366 	vp = cs->saved_vp;
2367 	if (vp == NULL) {
2368 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2369 		goto out;
2370 	}
2371 
2372 	/* CURRENT_FH: target directory */
2373 	dvp = cs->vp;
2374 	if (dvp == NULL) {
2375 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2376 		goto out;
2377 	}
2378 
2379 	/*
2380 	 * If there is a non-shared filesystem mounted on this vnode,
2381 	 * do not allow to link any file in this directory.
2382 	 */
2383 	if (vn_ismntpt(dvp)) {
2384 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
2385 		goto out;
2386 	}
2387 
2388 	if (cs->access == CS_ACCESS_DENIED) {
2389 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
2390 		goto out;
2391 	}
2392 
2393 	/* Check source object's type validity */
2394 	if (vp->v_type == VDIR) {
2395 		*cs->statusp = resp->status = NFS4ERR_ISDIR;
2396 		goto out;
2397 	}
2398 
2399 	/* Check target directory's type */
2400 	if (dvp->v_type != VDIR) {
2401 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
2402 		goto out;
2403 	}
2404 
2405 	if (cs->saved_exi != cs->exi) {
2406 		*cs->statusp = resp->status = NFS4ERR_XDEV;
2407 		goto out;
2408 	}
2409 
2410 	if (!utf8_dir_verify(&args->newname)) {
2411 		*cs->statusp = resp->status = NFS4ERR_INVAL;
2412 		goto out;
2413 	}
2414 
2415 	nm = utf8_to_fn(&args->newname, &len, NULL);
2416 	if (nm == NULL) {
2417 		*cs->statusp = resp->status = NFS4ERR_INVAL;
2418 		goto out;
2419 	}
2420 
2421 	if (len > MAXNAMELEN) {
2422 		*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
2423 		kmem_free(nm, len);
2424 		goto out;
2425 	}
2426 
2427 	if (rdonly4(cs->exi, cs->vp, req)) {
2428 		*cs->statusp = resp->status = NFS4ERR_ROFS;
2429 		kmem_free(nm, len);
2430 		goto out;
2431 	}
2432 
2433 	/* Get "before" change value */
2434 	bdva.va_mask = AT_CTIME|AT_SEQ;
2435 	error = VOP_GETATTR(dvp, &bdva, 0, cs->cr, NULL);
2436 	if (error) {
2437 		*cs->statusp = resp->status = puterrno4(error);
2438 		kmem_free(nm, len);
2439 		goto out;
2440 	}
2441 
2442 	NFS4_SET_FATTR4_CHANGE(resp->cinfo.before, bdva.va_ctime)
2443 
2444 	error = VOP_LINK(dvp, vp, nm, cs->cr, NULL, 0);
2445 
2446 	kmem_free(nm, len);
2447 
2448 	/*
2449 	 * Get the initial "after" sequence number, if it fails, set to zero
2450 	 */
2451 	idva.va_mask = AT_SEQ;
2452 	if (VOP_GETATTR(dvp, &idva, 0, cs->cr, NULL))
2453 		idva.va_seq = 0;
2454 
2455 	/*
2456 	 * Force modified data and metadata out to stable storage.
2457 	 */
2458 	(void) VOP_FSYNC(vp, FNODSYNC, cs->cr, NULL);
2459 	(void) VOP_FSYNC(dvp, 0, cs->cr, NULL);
2460 
2461 	if (error) {
2462 		*cs->statusp = resp->status = puterrno4(error);
2463 		goto out;
2464 	}
2465 
2466 	/*
2467 	 * Get "after" change value, if it fails, simply return the
2468 	 * before value.
2469 	 */
2470 	adva.va_mask = AT_CTIME|AT_SEQ;
2471 	if (VOP_GETATTR(dvp, &adva, 0, cs->cr, NULL)) {
2472 		adva.va_ctime = bdva.va_ctime;
2473 		adva.va_seq = 0;
2474 	}
2475 
2476 	NFS4_SET_FATTR4_CHANGE(resp->cinfo.after, adva.va_ctime)
2477 
2478 	/*
2479 	 * The cinfo.atomic = TRUE only if we have
2480 	 * non-zero va_seq's, and it has incremented by exactly one
2481 	 * during the VOP_LINK and it didn't change during the VOP_FSYNC.
2482 	 */
2483 	if (bdva.va_seq && idva.va_seq && adva.va_seq &&
2484 	    idva.va_seq == (bdva.va_seq + 1) && idva.va_seq == adva.va_seq)
2485 		resp->cinfo.atomic = TRUE;
2486 	else
2487 		resp->cinfo.atomic = FALSE;
2488 
2489 	*cs->statusp = resp->status = NFS4_OK;
2490 out:
2491 	DTRACE_NFSV4_2(op__link__done, struct compound_state *, cs,
2492 	    LINK4res *, resp);
2493 }
2494 
2495 /*
2496  * Used by rfs4_op_lookup and rfs4_op_lookupp to do the actual work.
2497  */
2498 
2499 /* ARGSUSED */
2500 static nfsstat4
2501 do_rfs4_op_lookup(char *nm, uint_t buflen, struct svc_req *req,
2502 	struct compound_state *cs)
2503 {
2504 	int error;
2505 	int different_export = 0;
2506 	vnode_t *vp, *tvp, *pre_tvp = NULL, *oldvp = NULL;
2507 	struct exportinfo *exi = NULL, *pre_exi = NULL;
2508 	nfsstat4 stat;
2509 	fid_t fid;
2510 	int attrdir, dotdot, walk;
2511 	bool_t is_newvp = FALSE;
2512 
2513 	if (cs->vp->v_flag & V_XATTRDIR) {
2514 		attrdir = 1;
2515 		ASSERT(get_fh4_flag(&cs->fh, FH4_ATTRDIR));
2516 	} else {
2517 		attrdir = 0;
2518 		ASSERT(! get_fh4_flag(&cs->fh, FH4_ATTRDIR));
2519 	}
2520 
2521 	dotdot = (nm[0] == '.' && nm[1] == '.' && nm[2] == '\0');
2522 
2523 	/*
2524 	 * If dotdotting, then need to check whether it's
2525 	 * above the root of a filesystem, or above an
2526 	 * export point.
2527 	 */
2528 	if (dotdot) {
2529 
2530 		/*
2531 		 * If dotdotting at the root of a filesystem, then
2532 		 * need to traverse back to the mounted-on filesystem
2533 		 * and do the dotdot lookup there.
2534 		 */
2535 		if (cs->vp->v_flag & VROOT) {
2536 
2537 			/*
2538 			 * If at the system root, then can
2539 			 * go up no further.
2540 			 */
2541 			if (VN_CMP(cs->vp, rootdir))
2542 				return (puterrno4(ENOENT));
2543 
2544 			/*
2545 			 * Traverse back to the mounted-on filesystem
2546 			 */
2547 			cs->vp = untraverse(cs->vp);
2548 
2549 			/*
2550 			 * Set the different_export flag so we remember
2551 			 * to pick up a new exportinfo entry for
2552 			 * this new filesystem.
2553 			 */
2554 			different_export = 1;
2555 		} else {
2556 
2557 			/*
2558 			 * If dotdotting above an export point then set
2559 			 * the different_export to get new export info.
2560 			 */
2561 			different_export = nfs_exported(cs->exi, cs->vp);
2562 		}
2563 	}
2564 
2565 	error = VOP_LOOKUP(cs->vp, nm, &vp, NULL, 0, NULL, cs->cr,
2566 	    NULL, NULL, NULL);
2567 	if (error)
2568 		return (puterrno4(error));
2569 
2570 	/*
2571 	 * If the vnode is in a pseudo filesystem, check whether it is visible.
2572 	 *
2573 	 * XXX if the vnode is a symlink and it is not visible in
2574 	 * a pseudo filesystem, return ENOENT (not following symlink).
2575 	 * V4 client can not mount such symlink. This is a regression
2576 	 * from V2/V3.
2577 	 *
2578 	 * In the same exported filesystem, if the security flavor used
2579 	 * is not an explicitly shared flavor, limit the view to the visible
2580 	 * list entries only. This is not a WRONGSEC case because it's already
2581 	 * checked via PUTROOTFH/PUTPUBFH or PUTFH.
2582 	 */
2583 	if (!different_export &&
2584 	    (PSEUDO(cs->exi) || ! is_exported_sec(cs->nfsflavor, cs->exi) ||
2585 	    cs->access & CS_ACCESS_LIMITED)) {
2586 		if (! nfs_visible(cs->exi, vp, &different_export)) {
2587 			VN_RELE(vp);
2588 			return (puterrno4(ENOENT));
2589 		}
2590 	}
2591 
2592 	/*
2593 	 * If it's a mountpoint, then traverse it.
2594 	 */
2595 	if (vn_ismntpt(vp)) {
2596 		pre_exi = cs->exi;	/* save pre-traversed exportinfo */
2597 		pre_tvp = vp;		/* save pre-traversed vnode	*/
2598 
2599 		/*
2600 		 * hold pre_tvp to counteract rele by traverse.  We will
2601 		 * need pre_tvp below if checkexport4 fails
2602 		 */
2603 		VN_HOLD(pre_tvp);
2604 		tvp = vp;
2605 		if ((error = traverse(&tvp)) != 0) {
2606 			VN_RELE(vp);
2607 			VN_RELE(pre_tvp);
2608 			return (puterrno4(error));
2609 		}
2610 		vp = tvp;
2611 		different_export = 1;
2612 	} else if (vp->v_vfsp != cs->vp->v_vfsp) {
2613 		/*
2614 		 * The vfsp comparison is to handle the case where
2615 		 * a LOFS mount is shared.  lo_lookup traverses mount points,
2616 		 * and NFS is unaware of local fs transistions because
2617 		 * v_vfsmountedhere isn't set.  For this special LOFS case,
2618 		 * the dir and the obj returned by lookup will have different
2619 		 * vfs ptrs.
2620 		 */
2621 		different_export = 1;
2622 	}
2623 
2624 	if (different_export) {
2625 
2626 		bzero(&fid, sizeof (fid));
2627 		fid.fid_len = MAXFIDSZ;
2628 		error = vop_fid_pseudo(vp, &fid);
2629 		if (error) {
2630 			VN_RELE(vp);
2631 			if (pre_tvp)
2632 				VN_RELE(pre_tvp);
2633 			return (puterrno4(error));
2634 		}
2635 
2636 		if (dotdot)
2637 			exi = nfs_vptoexi(NULL, vp, cs->cr, &walk, NULL, TRUE);
2638 		else
2639 			exi = checkexport4(&vp->v_vfsp->vfs_fsid, &fid, vp);
2640 
2641 		if (exi == NULL) {
2642 			if (pre_tvp) {
2643 				/*
2644 				 * If this vnode is a mounted-on vnode,
2645 				 * but the mounted-on file system is not
2646 				 * exported, send back the filehandle for
2647 				 * the mounted-on vnode, not the root of
2648 				 * the mounted-on file system.
2649 				 */
2650 				VN_RELE(vp);
2651 				vp = pre_tvp;
2652 				exi = pre_exi;
2653 			} else {
2654 				VN_RELE(vp);
2655 				return (puterrno4(EACCES));
2656 			}
2657 		} else if (pre_tvp) {
2658 			/* we're done with pre_tvp now. release extra hold */
2659 			VN_RELE(pre_tvp);
2660 		}
2661 
2662 		cs->exi = exi;
2663 
2664 		/*
2665 		 * Now we do a checkauth4. The reason is that
2666 		 * this client/user may not have access to the new
2667 		 * exported file system, and if he does,
2668 		 * the client/user may be mapped to a different uid.
2669 		 *
2670 		 * We start with a new cr, because the checkauth4 done
2671 		 * in the PUT*FH operation over wrote the cred's uid,
2672 		 * gid, etc, and we want the real thing before calling
2673 		 * checkauth4()
2674 		 */
2675 		crfree(cs->cr);
2676 		cs->cr = crdup(cs->basecr);
2677 
2678 		if (cs->vp)
2679 			oldvp = cs->vp;
2680 		cs->vp = vp;
2681 		is_newvp = TRUE;
2682 
2683 		stat = call_checkauth4(cs, req);
2684 		if (stat != NFS4_OK) {
2685 			VN_RELE(cs->vp);
2686 			cs->vp = oldvp;
2687 			return (stat);
2688 		}
2689 	}
2690 
2691 	/*
2692 	 * After various NFS checks, do a label check on the path
2693 	 * component. The label on this path should either be the
2694 	 * global zone's label or a zone's label. We are only
2695 	 * interested in the zone's label because exported files
2696 	 * in global zone is accessible (though read-only) to
2697 	 * clients. The exportability/visibility check is already
2698 	 * done before reaching this code.
2699 	 */
2700 	if (is_system_labeled()) {
2701 		bslabel_t *clabel;
2702 
2703 		ASSERT(req->rq_label != NULL);
2704 		clabel = req->rq_label;
2705 		DTRACE_PROBE2(tx__rfs4__log__info__oplookup__clabel, char *,
2706 		    "got client label from request(1)", struct svc_req *, req);
2707 
2708 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
2709 			if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK)) {
2710 				error = EACCES;
2711 				goto err_out;
2712 			}
2713 		} else {
2714 			/*
2715 			 * We grant access to admin_low label clients
2716 			 * only if the client is trusted, i.e. also
2717 			 * running Solaris Trusted Extension.
2718 			 */
2719 			struct sockaddr	*ca;
2720 			int		addr_type;
2721 			void		*ipaddr;
2722 			tsol_tpc_t	*tp;
2723 
2724 			ca = (struct sockaddr *)svc_getrpccaller(
2725 			    req->rq_xprt)->buf;
2726 			if (ca->sa_family == AF_INET) {
2727 				addr_type = IPV4_VERSION;
2728 				ipaddr = &((struct sockaddr_in *)ca)->sin_addr;
2729 			} else if (ca->sa_family == AF_INET6) {
2730 				addr_type = IPV6_VERSION;
2731 				ipaddr = &((struct sockaddr_in6 *)
2732 				    ca)->sin6_addr;
2733 			}
2734 			tp = find_tpc(ipaddr, addr_type, B_FALSE);
2735 			if (tp == NULL || tp->tpc_tp.tp_doi !=
2736 			    l_admin_low->tsl_doi || tp->tpc_tp.host_type !=
2737 			    SUN_CIPSO) {
2738 				if (tp != NULL)
2739 					TPC_RELE(tp);
2740 				error = EACCES;
2741 				goto err_out;
2742 			}
2743 			TPC_RELE(tp);
2744 		}
2745 	}
2746 
2747 	error = makefh4(&cs->fh, vp, cs->exi);
2748 
2749 err_out:
2750 	if (error) {
2751 		if (is_newvp) {
2752 			VN_RELE(cs->vp);
2753 			cs->vp = oldvp;
2754 		} else
2755 			VN_RELE(vp);
2756 		return (puterrno4(error));
2757 	}
2758 
2759 	if (!is_newvp) {
2760 		if (cs->vp)
2761 			VN_RELE(cs->vp);
2762 		cs->vp = vp;
2763 	} else if (oldvp)
2764 		VN_RELE(oldvp);
2765 
2766 	/*
2767 	 * if did lookup on attrdir and didn't lookup .., set named
2768 	 * attr fh flag
2769 	 */
2770 	if (attrdir && ! dotdot)
2771 		set_fh4_flag(&cs->fh, FH4_NAMEDATTR);
2772 
2773 	/* Assume false for now, open proc will set this */
2774 	cs->mandlock = FALSE;
2775 
2776 	return (NFS4_OK);
2777 }
2778 
2779 /* ARGSUSED */
2780 static void
2781 rfs4_op_lookup(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
2782 	struct compound_state *cs)
2783 {
2784 	LOOKUP4args *args = &argop->nfs_argop4_u.oplookup;
2785 	LOOKUP4res *resp = &resop->nfs_resop4_u.oplookup;
2786 	char *nm;
2787 	uint_t len;
2788 
2789 	DTRACE_NFSV4_2(op__lookup__start, struct compound_state *, cs,
2790 	    LOOKUP4args *, args);
2791 
2792 	if (cs->vp == NULL) {
2793 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2794 		goto out;
2795 	}
2796 
2797 	if (cs->vp->v_type == VLNK) {
2798 		*cs->statusp = resp->status = NFS4ERR_SYMLINK;
2799 		goto out;
2800 	}
2801 
2802 	if (cs->vp->v_type != VDIR) {
2803 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
2804 		goto out;
2805 	}
2806 
2807 	if (!utf8_dir_verify(&args->objname)) {
2808 		*cs->statusp = resp->status = NFS4ERR_INVAL;
2809 		goto out;
2810 	}
2811 
2812 	nm = utf8_to_str(&args->objname, &len, NULL);
2813 	if (nm == NULL) {
2814 		*cs->statusp = resp->status = NFS4ERR_INVAL;
2815 		goto out;
2816 	}
2817 
2818 	if (len > MAXNAMELEN) {
2819 		*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
2820 		kmem_free(nm, len);
2821 		goto out;
2822 	}
2823 
2824 	*cs->statusp = resp->status = do_rfs4_op_lookup(nm, len, req, cs);
2825 
2826 	kmem_free(nm, len);
2827 
2828 out:
2829 	DTRACE_NFSV4_2(op__lookup__done, struct compound_state *, cs,
2830 	    LOOKUP4res *, resp);
2831 }
2832 
2833 /* ARGSUSED */
2834 static void
2835 rfs4_op_lookupp(nfs_argop4 *args, nfs_resop4 *resop, struct svc_req *req,
2836 	struct compound_state *cs)
2837 {
2838 	LOOKUPP4res *resp = &resop->nfs_resop4_u.oplookupp;
2839 
2840 	DTRACE_NFSV4_1(op__lookupp__start, struct compound_state *, cs);
2841 
2842 	if (cs->vp == NULL) {
2843 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2844 		goto out;
2845 	}
2846 
2847 	if (cs->vp->v_type != VDIR) {
2848 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
2849 		goto out;
2850 	}
2851 
2852 	*cs->statusp = resp->status = do_rfs4_op_lookup("..", 3, req, cs);
2853 
2854 	/*
2855 	 * From NFSV4 Specification, LOOKUPP should not check for
2856 	 * NFS4ERR_WRONGSEC. Retrun NFS4_OK instead.
2857 	 */
2858 	if (resp->status == NFS4ERR_WRONGSEC) {
2859 		*cs->statusp = resp->status = NFS4_OK;
2860 	}
2861 
2862 out:
2863 	DTRACE_NFSV4_2(op__lookupp__done, struct compound_state *, cs,
2864 	    LOOKUPP4res *, resp);
2865 }
2866 
2867 
2868 /*ARGSUSED2*/
2869 static void
2870 rfs4_op_openattr(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
2871 	struct compound_state *cs)
2872 {
2873 	OPENATTR4args	*args = &argop->nfs_argop4_u.opopenattr;
2874 	OPENATTR4res	*resp = &resop->nfs_resop4_u.opopenattr;
2875 	vnode_t		*avp = NULL;
2876 	int		lookup_flags = LOOKUP_XATTR, error;
2877 	int		exp_ro = 0;
2878 
2879 	DTRACE_NFSV4_2(op__openattr__start, struct compound_state *, cs,
2880 	    OPENATTR4args *, args);
2881 
2882 	if (cs->vp == NULL) {
2883 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
2884 		goto out;
2885 	}
2886 
2887 	/*
2888 	 * Make a couple of checks made by copen()
2889 	 *
2890 	 * Check to make sure underlying fs supports xattrs.  This
2891 	 * is required because solaris filesystem implementations
2892 	 * (UFS/TMPFS) don't enforce the noxattr mount option
2893 	 * in VOP_LOOKUP(LOOKUP_XATTR).  If fs doesn't support this
2894 	 * pathconf cmd or if fs supports cmd but doesn't claim
2895 	 * support for xattr, return NOTSUPP.  It would be better
2896 	 * to use VOP_PATHCONF( _PC_XATTR_ENABLED) for this; however,
2897 	 * that cmd is not available to VOP_PATHCONF interface
2898 	 * (it's only implemented inside pathconf syscall)...
2899 	 *
2900 	 * Verify permission to put attributes on files (access
2901 	 * checks from copen).
2902 	 */
2903 
2904 	if ((cs->vp->v_vfsp->vfs_flag & VFS_XATTR) == 0 &&
2905 	    !vfs_has_feature(cs->vp->v_vfsp, VFSFT_XVATTR)) {
2906 		*cs->statusp = resp->status = puterrno4(ENOTSUP);
2907 		goto out;
2908 	}
2909 
2910 	if ((VOP_ACCESS(cs->vp, VREAD, 0, cs->cr, NULL) != 0) &&
2911 	    (VOP_ACCESS(cs->vp, VWRITE, 0, cs->cr, NULL) != 0) &&
2912 	    (VOP_ACCESS(cs->vp, VEXEC, 0, cs->cr, NULL) != 0)) {
2913 		*cs->statusp = resp->status = puterrno4(EACCES);
2914 		goto out;
2915 	}
2916 
2917 	/*
2918 	 * The CREATE_XATTR_DIR VOP flag cannot be specified if
2919 	 * the file system is exported read-only -- regardless of
2920 	 * createdir flag.  Otherwise the attrdir would be created
2921 	 * (assuming server fs isn't mounted readonly locally).  If
2922 	 * VOP_LOOKUP returns ENOENT in this case, the error will
2923 	 * be translated into EROFS.  ENOSYS is mapped to ENOTSUP
2924 	 * because specfs has no VOP_LOOKUP op, so the macro would
2925 	 * return ENOSYS.  EINVAL is returned by all (current)
2926 	 * Solaris file system implementations when any of their
2927 	 * restrictions are violated (xattr(dir) can't have xattrdir).
2928 	 * Returning NOTSUPP is more appropriate in this case
2929 	 * because the object will never be able to have an attrdir.
2930 	 */
2931 	if (args->createdir && ! (exp_ro = rdonly4(cs->exi, cs->vp, req)))
2932 		lookup_flags |= CREATE_XATTR_DIR;
2933 
2934 	error = VOP_LOOKUP(cs->vp, "", &avp, NULL, lookup_flags, NULL, cs->cr,
2935 	    NULL, NULL, NULL);
2936 
2937 	if (error) {
2938 		if (error == ENOENT && args->createdir && exp_ro)
2939 			*cs->statusp = resp->status = puterrno4(EROFS);
2940 		else if (error == EINVAL || error == ENOSYS)
2941 			*cs->statusp = resp->status = puterrno4(ENOTSUP);
2942 		else
2943 			*cs->statusp = resp->status = puterrno4(error);
2944 		goto out;
2945 	}
2946 
2947 	ASSERT(avp->v_flag & V_XATTRDIR);
2948 
2949 	error = makefh4(&cs->fh, avp, cs->exi);
2950 
2951 	if (error) {
2952 		VN_RELE(avp);
2953 		*cs->statusp = resp->status = puterrno4(error);
2954 		goto out;
2955 	}
2956 
2957 	VN_RELE(cs->vp);
2958 	cs->vp = avp;
2959 
2960 	/*
2961 	 * There is no requirement for an attrdir fh flag
2962 	 * because the attrdir has a vnode flag to distinguish
2963 	 * it from regular (non-xattr) directories.  The
2964 	 * FH4_ATTRDIR flag is set for future sanity checks.
2965 	 */
2966 	set_fh4_flag(&cs->fh, FH4_ATTRDIR);
2967 	*cs->statusp = resp->status = NFS4_OK;
2968 
2969 out:
2970 	DTRACE_NFSV4_2(op__openattr__done, struct compound_state *, cs,
2971 	    OPENATTR4res *, resp);
2972 }
2973 
2974 static int
2975 do_io(int direction, vnode_t *vp, struct uio *uio, int ioflag, cred_t *cred,
2976     caller_context_t *ct)
2977 {
2978 	int error;
2979 	int i;
2980 	clock_t delaytime;
2981 
2982 	delaytime = MSEC_TO_TICK_ROUNDUP(rfs4_lock_delay);
2983 
2984 	/*
2985 	 * Don't block on mandatory locks. If this routine returns
2986 	 * EAGAIN, the caller should return NFS4ERR_LOCKED.
2987 	 */
2988 	uio->uio_fmode = FNONBLOCK;
2989 
2990 	for (i = 0; i < rfs4_maxlock_tries; i++) {
2991 
2992 
2993 		if (direction == FREAD) {
2994 			(void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, ct);
2995 			error = VOP_READ(vp, uio, ioflag, cred, ct);
2996 			VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, ct);
2997 		} else {
2998 			(void) VOP_RWLOCK(vp, V_WRITELOCK_TRUE, ct);
2999 			error = VOP_WRITE(vp, uio, ioflag, cred, ct);
3000 			VOP_RWUNLOCK(vp, V_WRITELOCK_TRUE, ct);
3001 		}
3002 
3003 		if (error != EAGAIN)
3004 			break;
3005 
3006 		if (i < rfs4_maxlock_tries - 1) {
3007 			delay(delaytime);
3008 			delaytime *= 2;
3009 		}
3010 	}
3011 
3012 	return (error);
3013 }
3014 
3015 /* ARGSUSED */
3016 static void
3017 rfs4_op_read(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
3018 	struct compound_state *cs)
3019 {
3020 	READ4args *args = &argop->nfs_argop4_u.opread;
3021 	READ4res *resp = &resop->nfs_resop4_u.opread;
3022 	int error;
3023 	int verror;
3024 	vnode_t *vp;
3025 	struct vattr va;
3026 	struct iovec iov;
3027 	struct uio uio;
3028 	u_offset_t offset;
3029 	bool_t *deleg = &cs->deleg;
3030 	nfsstat4 stat;
3031 	int in_crit = 0;
3032 	mblk_t *mp;
3033 	int alloc_err = 0;
3034 	caller_context_t ct;
3035 
3036 	DTRACE_NFSV4_2(op__read__start, struct compound_state *, cs,
3037 	    READ4args, args);
3038 
3039 	vp = cs->vp;
3040 	if (vp == NULL) {
3041 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
3042 		goto out;
3043 	}
3044 	if (cs->access == CS_ACCESS_DENIED) {
3045 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
3046 		goto out;
3047 	}
3048 
3049 	if ((stat = rfs4_check_stateid(FREAD, vp, &args->stateid, FALSE,
3050 	    deleg, TRUE, &ct)) != NFS4_OK) {
3051 		*cs->statusp = resp->status = stat;
3052 		goto out;
3053 	}
3054 
3055 	/*
3056 	 * Enter the critical region before calling VOP_RWLOCK
3057 	 * to avoid a deadlock with write requests.
3058 	 */
3059 	if (nbl_need_check(vp)) {
3060 		nbl_start_crit(vp, RW_READER);
3061 		in_crit = 1;
3062 		if (nbl_conflict(vp, NBL_READ, args->offset, args->count, 0,
3063 		    &ct)) {
3064 			*cs->statusp = resp->status = NFS4ERR_LOCKED;
3065 			goto out;
3066 		}
3067 	}
3068 
3069 	if ((stat = rfs4_check_stateid(FREAD, vp, &args->stateid, FALSE,
3070 	    deleg, TRUE, &ct)) != NFS4_OK) {
3071 		*cs->statusp = resp->status = stat;
3072 		goto out;
3073 	}
3074 
3075 	va.va_mask = AT_MODE|AT_SIZE|AT_UID;
3076 	verror = VOP_GETATTR(vp, &va, 0, cs->cr, &ct);
3077 
3078 	/*
3079 	 * If we can't get the attributes, then we can't do the
3080 	 * right access checking.  So, we'll fail the request.
3081 	 */
3082 	if (verror) {
3083 		*cs->statusp = resp->status = puterrno4(verror);
3084 		goto out;
3085 	}
3086 
3087 	if (vp->v_type != VREG) {
3088 		*cs->statusp = resp->status =
3089 		    ((vp->v_type == VDIR) ? NFS4ERR_ISDIR : NFS4ERR_INVAL);
3090 		goto out;
3091 	}
3092 
3093 	if (crgetuid(cs->cr) != va.va_uid &&
3094 	    (error = VOP_ACCESS(vp, VREAD, 0, cs->cr, &ct)) &&
3095 	    (error = VOP_ACCESS(vp, VEXEC, 0, cs->cr, &ct))) {
3096 		*cs->statusp = resp->status = puterrno4(error);
3097 		goto out;
3098 	}
3099 
3100 	if (MANDLOCK(vp, va.va_mode)) { /* XXX - V4 supports mand locking */
3101 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
3102 		goto out;
3103 	}
3104 
3105 	offset = args->offset;
3106 	if (offset >= va.va_size) {
3107 		*cs->statusp = resp->status = NFS4_OK;
3108 		resp->eof = TRUE;
3109 		resp->data_len = 0;
3110 		resp->data_val = NULL;
3111 		resp->mblk = NULL;
3112 		*cs->statusp = resp->status = NFS4_OK;
3113 		goto out;
3114 	}
3115 
3116 	if (args->count == 0) {
3117 		*cs->statusp = resp->status = NFS4_OK;
3118 		resp->eof = FALSE;
3119 		resp->data_len = 0;
3120 		resp->data_val = NULL;
3121 		resp->mblk = NULL;
3122 		goto out;
3123 	}
3124 
3125 	/*
3126 	 * Do not allocate memory more than maximum allowed
3127 	 * transfer size
3128 	 */
3129 	if (args->count > rfs4_tsize(req))
3130 		args->count = rfs4_tsize(req);
3131 
3132 	/*
3133 	 * mp will contain the data to be sent out in the read reply.
3134 	 * It will be freed after the reply has been sent.
3135 	 * Let's roundup the data to a BYTES_PER_XDR_UNIT multiple,
3136 	 * so that the call to xdrmblk_putmblk() never fails.
3137 	 * If the first alloc of the requested size fails, then
3138 	 * decrease the size to something more reasonable and wait
3139 	 * for the allocation to occur.
3140 	 */
3141 	mp = allocb(RNDUP(args->count), BPRI_MED);
3142 	if (mp == NULL) {
3143 		if (args->count > MAXBSIZE)
3144 			args->count = MAXBSIZE;
3145 		mp = allocb_wait(RNDUP(args->count), BPRI_MED,
3146 		    STR_NOSIG, &alloc_err);
3147 	}
3148 	ASSERT(mp != NULL);
3149 	ASSERT(alloc_err == 0);
3150 
3151 	iov.iov_base = (caddr_t)mp->b_datap->db_base;
3152 	iov.iov_len = args->count;
3153 	uio.uio_iov = &iov;
3154 	uio.uio_iovcnt = 1;
3155 	uio.uio_segflg = UIO_SYSSPACE;
3156 	uio.uio_extflg = UIO_COPY_CACHED;
3157 	uio.uio_loffset = args->offset;
3158 	uio.uio_resid = args->count;
3159 
3160 	error = do_io(FREAD, vp, &uio, 0, cs->cr, &ct);
3161 
3162 	va.va_mask = AT_SIZE;
3163 	verror = VOP_GETATTR(vp, &va, 0, cs->cr, &ct);
3164 
3165 	if (error) {
3166 		freeb(mp);
3167 		*cs->statusp = resp->status = puterrno4(error);
3168 		goto out;
3169 	}
3170 
3171 	*cs->statusp = resp->status = NFS4_OK;
3172 
3173 	ASSERT(uio.uio_resid >= 0);
3174 	resp->data_len = args->count - uio.uio_resid;
3175 	resp->data_val = (char *)mp->b_datap->db_base;
3176 	resp->mblk = mp;
3177 
3178 	if (!verror && offset + resp->data_len == va.va_size)
3179 		resp->eof = TRUE;
3180 	else
3181 		resp->eof = FALSE;
3182 
3183 out:
3184 	if (in_crit)
3185 		nbl_end_crit(vp);
3186 
3187 	DTRACE_NFSV4_2(op__read__done, struct compound_state *, cs,
3188 	    READ4res *, resp);
3189 }
3190 
3191 static void
3192 rfs4_op_read_free(nfs_resop4 *resop)
3193 {
3194 	READ4res *resp = &resop->nfs_resop4_u.opread;
3195 
3196 	if (resp->status == NFS4_OK && resp->mblk != NULL) {
3197 		freeb(resp->mblk);
3198 		resp->mblk = NULL;
3199 		resp->data_val = NULL;
3200 		resp->data_len = 0;
3201 	}
3202 }
3203 
3204 static void
3205 rfs4_op_readdir_free(nfs_resop4 *resop)
3206 {
3207 	READDIR4res *resp = &resop->nfs_resop4_u.opreaddir;
3208 
3209 	if (resp->status == NFS4_OK && resp->mblk != NULL) {
3210 		freeb(resp->mblk);
3211 		resp->mblk = NULL;
3212 		resp->data_len = 0;
3213 	}
3214 }
3215 
3216 
3217 /* ARGSUSED */
3218 static void
3219 rfs4_op_putpubfh(nfs_argop4 *args, nfs_resop4 *resop, struct svc_req *req,
3220 	struct compound_state *cs)
3221 {
3222 	PUTPUBFH4res *resp = &resop->nfs_resop4_u.opputpubfh;
3223 	int error;
3224 	vnode_t *vp;
3225 	struct exportinfo *exi, *sav_exi;
3226 	nfs_fh4_fmt_t *fh_fmtp;
3227 
3228 	DTRACE_NFSV4_1(op__putpubfh__start, struct compound_state *, cs);
3229 
3230 	if (cs->vp) {
3231 		VN_RELE(cs->vp);
3232 		cs->vp = NULL;
3233 	}
3234 
3235 	if (cs->cr)
3236 		crfree(cs->cr);
3237 
3238 	cs->cr = crdup(cs->basecr);
3239 
3240 	vp = exi_public->exi_vp;
3241 	if (vp == NULL) {
3242 		*cs->statusp = resp->status = NFS4ERR_SERVERFAULT;
3243 		goto out;
3244 	}
3245 
3246 	if (is_system_labeled()) {
3247 		bslabel_t *clabel;
3248 
3249 		ASSERT(req->rq_label != NULL);
3250 		clabel = req->rq_label;
3251 		DTRACE_PROBE2(tx__rfs4__log__info__opputpubfh__clabel, char *,
3252 		    "got client label from request(1)",
3253 		    struct svc_req *, req);
3254 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
3255 			if (!do_rfs_label_check(clabel, vp, DOMINANCE_CHECK)) {
3256 				*cs->statusp = resp->status =
3257 				    NFS4ERR_SERVERFAULT;
3258 				return;
3259 			}
3260 		}
3261 	}
3262 
3263 	error = makefh4(&cs->fh, vp, exi_public);
3264 	if (error != 0) {
3265 		*cs->statusp = resp->status = puterrno4(error);
3266 		goto out;
3267 	}
3268 	sav_exi = cs->exi;
3269 	if (exi_public == exi_root) {
3270 		/*
3271 		 * No filesystem is actually shared public, so we default
3272 		 * to exi_root. In this case, we must check whether root
3273 		 * is exported.
3274 		 */
3275 		fh_fmtp = (nfs_fh4_fmt_t *)cs->fh.nfs_fh4_val;
3276 
3277 		/*
3278 		 * if root filesystem is exported, the exportinfo struct that we
3279 		 * should use is what checkexport4 returns, because root_exi is
3280 		 * actually a mostly empty struct.
3281 		 */
3282 		exi = checkexport4(&fh_fmtp->fh4_fsid,
3283 		    (fid_t *)&fh_fmtp->fh4_xlen, NULL);
3284 		cs->exi = ((exi != NULL) ? exi : exi_public);
3285 	} else {
3286 		/*
3287 		 * it's a properly shared filesystem
3288 		 */
3289 		cs->exi = exi_public;
3290 	}
3291 
3292 	VN_HOLD(vp);
3293 	cs->vp = vp;
3294 
3295 	if ((resp->status = call_checkauth4(cs, req)) != NFS4_OK) {
3296 		VN_RELE(cs->vp);
3297 		cs->vp = NULL;
3298 		cs->exi = sav_exi;
3299 		goto out;
3300 	}
3301 
3302 	*cs->statusp = resp->status = NFS4_OK;
3303 out:
3304 	DTRACE_NFSV4_2(op__putpubfh__done, struct compound_state *, cs,
3305 	    PUTPUBFH4res *, resp);
3306 }
3307 
3308 /*
3309  * XXX - issue with put*fh operations. Suppose /export/home is exported.
3310  * Suppose an NFS client goes to mount /export/home/joe. If /export, home,
3311  * or joe have restrictive search permissions, then we shouldn't let
3312  * the client get a file handle. This is easy to enforce. However, we
3313  * don't know what security flavor should be used until we resolve the
3314  * path name. Another complication is uid mapping. If root is
3315  * the user, then it will be mapped to the anonymous user by default,
3316  * but we won't know that till we've resolved the path name. And we won't
3317  * know what the anonymous user is.
3318  * Luckily, SECINFO is specified to take a full filename.
3319  * So what we will have to in rfs4_op_lookup is check that flavor of
3320  * the target object matches that of the request, and if root was the
3321  * caller, check for the root= and anon= options, and if necessary,
3322  * repeat the lookup using the right cred_t. But that's not done yet.
3323  */
3324 /* ARGSUSED */
3325 static void
3326 rfs4_op_putfh(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
3327 	struct compound_state *cs)
3328 {
3329 	PUTFH4args *args = &argop->nfs_argop4_u.opputfh;
3330 	PUTFH4res *resp = &resop->nfs_resop4_u.opputfh;
3331 	nfs_fh4_fmt_t *fh_fmtp;
3332 
3333 	DTRACE_NFSV4_2(op__putfh__start, struct compound_state *, cs,
3334 	    PUTFH4args *, args);
3335 
3336 	if (cs->vp) {
3337 		VN_RELE(cs->vp);
3338 		cs->vp = NULL;
3339 	}
3340 
3341 	if (cs->cr) {
3342 		crfree(cs->cr);
3343 		cs->cr = NULL;
3344 	}
3345 
3346 
3347 	if (args->object.nfs_fh4_len < NFS_FH4_LEN) {
3348 		*cs->statusp = resp->status = NFS4ERR_BADHANDLE;
3349 		goto out;
3350 	}
3351 
3352 	fh_fmtp = (nfs_fh4_fmt_t *)args->object.nfs_fh4_val;
3353 	cs->exi = checkexport4(&fh_fmtp->fh4_fsid, (fid_t *)&fh_fmtp->fh4_xlen,
3354 	    NULL);
3355 
3356 	if (cs->exi == NULL) {
3357 		*cs->statusp = resp->status = NFS4ERR_STALE;
3358 		goto out;
3359 	}
3360 
3361 	cs->cr = crdup(cs->basecr);
3362 
3363 	ASSERT(cs->cr != NULL);
3364 
3365 	if (! (cs->vp = nfs4_fhtovp(&args->object, cs->exi, &resp->status))) {
3366 		*cs->statusp = resp->status;
3367 		goto out;
3368 	}
3369 
3370 	if ((resp->status = call_checkauth4(cs, req)) != NFS4_OK) {
3371 		VN_RELE(cs->vp);
3372 		cs->vp = NULL;
3373 		goto out;
3374 	}
3375 
3376 	nfs_fh4_copy(&args->object, &cs->fh);
3377 	*cs->statusp = resp->status = NFS4_OK;
3378 	cs->deleg = FALSE;
3379 
3380 out:
3381 	DTRACE_NFSV4_2(op__putfh__done, struct compound_state *, cs,
3382 	    PUTFH4res *, resp);
3383 }
3384 
3385 /* ARGSUSED */
3386 static void
3387 rfs4_op_putrootfh(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
3388 	struct compound_state *cs)
3389 
3390 {
3391 	PUTROOTFH4res *resp = &resop->nfs_resop4_u.opputrootfh;
3392 	int error;
3393 	fid_t fid;
3394 	struct exportinfo *exi, *sav_exi;
3395 
3396 	DTRACE_NFSV4_1(op__putrootfh__start, struct compound_state *, cs);
3397 
3398 	if (cs->vp) {
3399 		VN_RELE(cs->vp);
3400 		cs->vp = NULL;
3401 	}
3402 
3403 	if (cs->cr)
3404 		crfree(cs->cr);
3405 
3406 	cs->cr = crdup(cs->basecr);
3407 
3408 	/*
3409 	 * Using rootdir, the system root vnode,
3410 	 * get its fid.
3411 	 */
3412 	bzero(&fid, sizeof (fid));
3413 	fid.fid_len = MAXFIDSZ;
3414 	error = vop_fid_pseudo(rootdir, &fid);
3415 	if (error != 0) {
3416 		*cs->statusp = resp->status = puterrno4(error);
3417 		goto out;
3418 	}
3419 
3420 	/*
3421 	 * Then use the root fsid & fid it to find out if it's exported
3422 	 *
3423 	 * If the server root isn't exported directly, then
3424 	 * it should at least be a pseudo export based on
3425 	 * one or more exports further down in the server's
3426 	 * file tree.
3427 	 */
3428 	exi = checkexport4(&rootdir->v_vfsp->vfs_fsid, &fid, NULL);
3429 	if (exi == NULL || exi->exi_export.ex_flags & EX_PUBLIC) {
3430 		NFS4_DEBUG(rfs4_debug,
3431 			(CE_WARN, "rfs4_op_putrootfh: export check failure"));
3432 		*cs->statusp = resp->status = NFS4ERR_SERVERFAULT;
3433 		goto out;
3434 	}
3435 
3436 	/*
3437 	 * Now make a filehandle based on the root
3438 	 * export and root vnode.
3439 	 */
3440 	error = makefh4(&cs->fh, rootdir, exi);
3441 	if (error != 0) {
3442 		*cs->statusp = resp->status = puterrno4(error);
3443 		goto out;
3444 	}
3445 
3446 	sav_exi = cs->exi;
3447 	cs->exi = exi;
3448 
3449 	VN_HOLD(rootdir);
3450 	cs->vp = rootdir;
3451 
3452 	if ((resp->status = call_checkauth4(cs, req)) != NFS4_OK) {
3453 		VN_RELE(rootdir);
3454 		cs->vp = NULL;
3455 		cs->exi = sav_exi;
3456 		goto out;
3457 	}
3458 
3459 	*cs->statusp = resp->status = NFS4_OK;
3460 	cs->deleg = FALSE;
3461 out:
3462 	DTRACE_NFSV4_2(op__putrootfh__done, struct compound_state *, cs,
3463 	    PUTROOTFH4res *, resp);
3464 }
3465 
3466 /*
3467  * A directory entry is a valid nfsv4 entry if
3468  * - it has a non-zero ino
3469  * - it is not a dot or dotdot name
3470  * - it is visible in a pseudo export or in a real export that can
3471  *   only have a limited view.
3472  */
3473 static bool_t
3474 valid_nfs4_entry(struct exportinfo *exi, struct dirent64 *dp,
3475 		int *expseudo, int check_visible)
3476 {
3477 	if (dp->d_ino == 0 || NFS_IS_DOTNAME(dp->d_name)) {
3478 		*expseudo = 0;
3479 		return (FALSE);
3480 	}
3481 
3482 	if (! check_visible) {
3483 		*expseudo = 0;
3484 		return (TRUE);
3485 	}
3486 
3487 	return (nfs_visible_inode(exi, dp->d_ino, expseudo));
3488 }
3489 
3490 /*
3491  * set_rdattr_params sets up the variables used to manage what information
3492  * to get for each directory entry.
3493  */
3494 static nfsstat4
3495 set_rdattr_params(struct nfs4_svgetit_arg *sargp,
3496 		bitmap4 attrs, bool_t *need_to_lookup)
3497 {
3498 	uint_t	va_mask;
3499 	nfsstat4 status;
3500 	bitmap4 objbits;
3501 
3502 	status = bitmap4_to_attrmask(attrs, sargp);
3503 	if (status != NFS4_OK) {
3504 		/*
3505 		 * could not even figure attr mask
3506 		 */
3507 		return (status);
3508 	}
3509 	va_mask = sargp->vap->va_mask;
3510 
3511 	/*
3512 	 * dirent's d_ino is always correct value for mounted_on_fileid.
3513 	 * mntdfid_set is set once here, but mounted_on_fileid is
3514 	 * set in main dirent processing loop for each dirent.
3515 	 * The mntdfid_set is a simple optimization that lets the
3516 	 * server attr code avoid work when caller is readdir.
3517 	 */
3518 	sargp->mntdfid_set = TRUE;
3519 
3520 	/*
3521 	 * Lookup entry only if client asked for any of the following:
3522 	 * a) vattr attrs
3523 	 * b) vfs attrs
3524 	 * c) attrs w/per-object scope requested (change, filehandle, etc)
3525 	 *    other than mounted_on_fileid (which we can take from dirent)
3526 	 */
3527 	objbits = attrs ? attrs & NFS4_VP_ATTR_MASK : 0;
3528 
3529 	if (va_mask || sargp->sbp || (objbits & ~FATTR4_MOUNTED_ON_FILEID_MASK))
3530 		*need_to_lookup = TRUE;
3531 	else
3532 		*need_to_lookup = FALSE;
3533 
3534 	if (sargp->sbp == NULL)
3535 		return (NFS4_OK);
3536 
3537 	/*
3538 	 * If filesystem attrs are requested, get them now from the
3539 	 * directory vp, as most entries will have same filesystem. The only
3540 	 * exception are mounted over entries but we handle
3541 	 * those as we go (XXX mounted over detection not yet implemented).
3542 	 */
3543 	sargp->vap->va_mask = 0;	/* to avoid VOP_GETATTR */
3544 	status = bitmap4_get_sysattrs(sargp);
3545 	sargp->vap->va_mask = va_mask;
3546 
3547 	if ((status != NFS4_OK) && sargp->rdattr_error_req) {
3548 		/*
3549 		 * Failed to get filesystem attributes.
3550 		 * Return a rdattr_error for each entry, but don't fail.
3551 		 * However, don't get any obj-dependent attrs.
3552 		 */
3553 		sargp->rdattr_error = status;	/* for rdattr_error */
3554 		*need_to_lookup = FALSE;
3555 		/*
3556 		 * At least get fileid for regular readdir output
3557 		 */
3558 		sargp->vap->va_mask &= AT_NODEID;
3559 		status = NFS4_OK;
3560 	}
3561 
3562 	return (status);
3563 }
3564 
3565 /*
3566  * readlink: args: CURRENT_FH.
3567  *	res: status. If success - CURRENT_FH unchanged, return linktext.
3568  */
3569 
3570 /* ARGSUSED */
3571 static void
3572 rfs4_op_readlink(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
3573 	struct compound_state *cs)
3574 {
3575 	READLINK4res *resp = &resop->nfs_resop4_u.opreadlink;
3576 	int error;
3577 	vnode_t *vp;
3578 	struct iovec iov;
3579 	struct vattr va;
3580 	struct uio uio;
3581 	char *data;
3582 
3583 	DTRACE_NFSV4_1(op__readlink__start, struct compound_state *, cs);
3584 
3585 	/* CURRENT_FH: directory */
3586 	vp = cs->vp;
3587 	if (vp == NULL) {
3588 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
3589 		goto out;
3590 	}
3591 
3592 	if (cs->access == CS_ACCESS_DENIED) {
3593 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
3594 		goto out;
3595 	}
3596 
3597 	if (vp->v_type == VDIR) {
3598 		*cs->statusp = resp->status = NFS4ERR_ISDIR;
3599 		goto out;
3600 	}
3601 
3602 	if (vp->v_type != VLNK) {
3603 		*cs->statusp = resp->status = NFS4ERR_INVAL;
3604 		goto out;
3605 	}
3606 
3607 	va.va_mask = AT_MODE;
3608 	error = VOP_GETATTR(vp, &va, 0, cs->cr, NULL);
3609 	if (error) {
3610 		*cs->statusp = resp->status = puterrno4(error);
3611 		goto out;
3612 	}
3613 
3614 	if (MANDLOCK(vp, va.va_mode)) {
3615 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
3616 		goto out;
3617 	}
3618 
3619 	data = kmem_alloc(MAXPATHLEN + 1, KM_SLEEP);
3620 
3621 	iov.iov_base = data;
3622 	iov.iov_len = MAXPATHLEN;
3623 	uio.uio_iov = &iov;
3624 	uio.uio_iovcnt = 1;
3625 	uio.uio_segflg = UIO_SYSSPACE;
3626 	uio.uio_extflg = UIO_COPY_CACHED;
3627 	uio.uio_loffset = 0;
3628 	uio.uio_resid = MAXPATHLEN;
3629 
3630 	error = VOP_READLINK(vp, &uio, cs->cr, NULL);
3631 
3632 	if (error) {
3633 		kmem_free((caddr_t)data, (uint_t)MAXPATHLEN + 1);
3634 		*cs->statusp = resp->status = puterrno4(error);
3635 		goto out;
3636 	}
3637 
3638 	*(data + MAXPATHLEN - uio.uio_resid) = '\0';
3639 
3640 	/*
3641 	 * treat link name as data
3642 	 */
3643 	(void) str_to_utf8(data, &resp->link);
3644 
3645 	kmem_free((caddr_t)data, (uint_t)MAXPATHLEN + 1);
3646 	*cs->statusp = resp->status = NFS4_OK;
3647 
3648 out:
3649 	DTRACE_NFSV4_2(op__readlink__done, struct compound_state *, cs,
3650 	    READLINK4res *, resp);
3651 }
3652 
3653 static void
3654 rfs4_op_readlink_free(nfs_resop4 *resop)
3655 {
3656 	READLINK4res *resp = &resop->nfs_resop4_u.opreadlink;
3657 	utf8string *symlink = &resp->link;
3658 
3659 	if (symlink->utf8string_val) {
3660 		UTF8STRING_FREE(*symlink)
3661 	}
3662 }
3663 
3664 /*
3665  * release_lockowner:
3666  *	Release any state associated with the supplied
3667  *	lockowner. Note if any lo_state is holding locks we will not
3668  *	rele that lo_state and thus the lockowner will not be destroyed.
3669  *	A client using lock after the lock owner stateid has been released
3670  *	will suffer the consequence of NFS4ERR_BAD_STATEID and would have
3671  *	to reissue the lock with new_lock_owner set to TRUE.
3672  *	args: lock_owner
3673  *	res:  status
3674  */
3675 /* ARGSUSED */
3676 static void
3677 rfs4_op_release_lockowner(nfs_argop4 *argop, nfs_resop4 *resop,
3678 	struct svc_req *req, struct compound_state *cs)
3679 {
3680 	RELEASE_LOCKOWNER4args *ap = &argop->nfs_argop4_u.oprelease_lockowner;
3681 	RELEASE_LOCKOWNER4res *resp = &resop->nfs_resop4_u.oprelease_lockowner;
3682 	rfs4_lockowner_t *lo;
3683 	rfs4_openowner_t *oop;
3684 	rfs4_state_t *sp;
3685 	rfs4_lo_state_t *lsp;
3686 	rfs4_client_t *cp;
3687 	bool_t create = FALSE;
3688 	locklist_t *llist;
3689 	sysid_t sysid;
3690 
3691 	DTRACE_NFSV4_2(op__release__lockowner__start, struct compound_state *,
3692 	    cs, RELEASE_LOCKOWNER4args *, ap);
3693 
3694 	/* Make sure there is a clientid around for this request */
3695 	cp = rfs4_findclient_by_id(ap->lock_owner.clientid, FALSE);
3696 
3697 	if (cp == NULL) {
3698 		*cs->statusp = resp->status =
3699 		    rfs4_check_clientid(&ap->lock_owner.clientid, 0);
3700 		goto out;
3701 	}
3702 	rfs4_client_rele(cp);
3703 
3704 	lo = rfs4_findlockowner(&ap->lock_owner, &create);
3705 	if (lo == NULL) {
3706 		*cs->statusp = resp->status = NFS4_OK;
3707 		goto out;
3708 	}
3709 	ASSERT(lo->client != NULL);
3710 
3711 	/*
3712 	 * Check for EXPIRED client. If so will reap state with in a lease
3713 	 * period or on next set_clientid_confirm step
3714 	 */
3715 	if (rfs4_lease_expired(lo->client)) {
3716 		rfs4_lockowner_rele(lo);
3717 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
3718 		goto out;
3719 	}
3720 
3721 	/*
3722 	 * If no sysid has been assigned, then no locks exist; just return.
3723 	 */
3724 	rfs4_dbe_lock(lo->client->dbe);
3725 	if (lo->client->sysidt == LM_NOSYSID) {
3726 		rfs4_lockowner_rele(lo);
3727 		rfs4_dbe_unlock(lo->client->dbe);
3728 		goto out;
3729 	}
3730 
3731 	sysid = lo->client->sysidt;
3732 	rfs4_dbe_unlock(lo->client->dbe);
3733 
3734 	/*
3735 	 * Mark the lockowner invalid.
3736 	 */
3737 	rfs4_dbe_hide(lo->dbe);
3738 
3739 	/*
3740 	 * sysid-pid pair should now not be used since the lockowner is
3741 	 * invalid. If the client were to instantiate the lockowner again
3742 	 * it would be assigned a new pid. Thus we can get the list of
3743 	 * current locks.
3744 	 */
3745 
3746 	llist = flk_get_active_locks(sysid, lo->pid);
3747 	/* If we are still holding locks fail */
3748 	if (llist != NULL) {
3749 
3750 		*cs->statusp = resp->status = NFS4ERR_LOCKS_HELD;
3751 
3752 		flk_free_locklist(llist);
3753 		/*
3754 		 * We need to unhide the lockowner so the client can
3755 		 * try it again. The bad thing here is if the client
3756 		 * has a logic error that took it here in the first place
3757 		 * he probably has lost accounting of the locks that it
3758 		 * is holding. So we may have dangling state until the
3759 		 * open owner state is reaped via close. One scenario
3760 		 * that could possibly occur is that the client has
3761 		 * sent the unlock request(s) in separate threads
3762 		 * and has not waited for the replies before sending the
3763 		 * RELEASE_LOCKOWNER request. Presumably, it would expect
3764 		 * and deal appropriately with NFS4ERR_LOCKS_HELD, by
3765 		 * reissuing the request.
3766 		 */
3767 		rfs4_dbe_unhide(lo->dbe);
3768 		rfs4_lockowner_rele(lo);
3769 		goto out;
3770 	}
3771 
3772 	/*
3773 	 * For the corresponding client we need to check each open
3774 	 * owner for any opens that have lockowner state associated
3775 	 * with this lockowner.
3776 	 */
3777 
3778 	rfs4_dbe_lock(lo->client->dbe);
3779 	for (oop = lo->client->openownerlist.next->oop; oop != NULL;
3780 	    oop = oop->openownerlist.next->oop) {
3781 
3782 		rfs4_dbe_lock(oop->dbe);
3783 		for (sp = oop->ownerstateids.next->sp; sp != NULL;
3784 		    sp = sp->ownerstateids.next->sp) {
3785 
3786 			rfs4_dbe_lock(sp->dbe);
3787 			for (lsp = sp->lockownerlist.next->lsp;
3788 			    lsp != NULL; lsp = lsp->lockownerlist.next->lsp) {
3789 				if (lsp->locker == lo) {
3790 					rfs4_dbe_lock(lsp->dbe);
3791 					rfs4_dbe_invalidate(lsp->dbe);
3792 					rfs4_dbe_unlock(lsp->dbe);
3793 				}
3794 			}
3795 			rfs4_dbe_unlock(sp->dbe);
3796 		}
3797 		rfs4_dbe_unlock(oop->dbe);
3798 	}
3799 	rfs4_dbe_unlock(lo->client->dbe);
3800 
3801 	rfs4_lockowner_rele(lo);
3802 
3803 	*cs->statusp = resp->status = NFS4_OK;
3804 
3805 out:
3806 	DTRACE_NFSV4_2(op__release__lockowner__done, struct compound_state *,
3807 	    cs, RELEASE_LOCKOWNER4res *, resp);
3808 }
3809 
3810 /*
3811  * short utility function to lookup a file and recall the delegation
3812  */
3813 static rfs4_file_t *
3814 rfs4_lookup_and_findfile(vnode_t *dvp, char *nm, vnode_t **vpp,
3815 	int *lkup_error, cred_t *cr)
3816 {
3817 	vnode_t *vp;
3818 	rfs4_file_t *fp = NULL;
3819 	bool_t fcreate = FALSE;
3820 	int error;
3821 
3822 	if (vpp)
3823 		*vpp = NULL;
3824 
3825 	if ((error = VOP_LOOKUP(dvp, nm, &vp, NULL, 0, NULL, cr, NULL, NULL,
3826 	    NULL)) == 0) {
3827 		if (vp->v_type == VREG)
3828 			fp = rfs4_findfile(vp, NULL, &fcreate);
3829 		if (vpp)
3830 			*vpp = vp;
3831 		else
3832 			VN_RELE(vp);
3833 	}
3834 
3835 	if (lkup_error)
3836 		*lkup_error = error;
3837 
3838 	return (fp);
3839 }
3840 
3841 /*
3842  * remove: args: CURRENT_FH: directory; name.
3843  *	res: status. If success - CURRENT_FH unchanged, return change_info
3844  *		for directory.
3845  */
3846 /* ARGSUSED */
3847 static void
3848 rfs4_op_remove(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
3849 	struct compound_state *cs)
3850 {
3851 	REMOVE4args *args = &argop->nfs_argop4_u.opremove;
3852 	REMOVE4res *resp = &resop->nfs_resop4_u.opremove;
3853 	int error;
3854 	vnode_t *dvp, *vp;
3855 	struct vattr bdva, idva, adva;
3856 	char *nm;
3857 	uint_t len;
3858 	rfs4_file_t *fp;
3859 	int in_crit = 0;
3860 	bslabel_t *clabel;
3861 
3862 	DTRACE_NFSV4_2(op__remove__start, struct compound_state *, cs,
3863 	    REMOVE4args *, args);
3864 
3865 	/* CURRENT_FH: directory */
3866 	dvp = cs->vp;
3867 	if (dvp == NULL) {
3868 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
3869 		goto out;
3870 	}
3871 
3872 	if (cs->access == CS_ACCESS_DENIED) {
3873 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
3874 		goto out;
3875 	}
3876 
3877 	/*
3878 	 * If there is an unshared filesystem mounted on this vnode,
3879 	 * Do not allow to remove anything in this directory.
3880 	 */
3881 	if (vn_ismntpt(dvp)) {
3882 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
3883 		goto out;
3884 	}
3885 
3886 	if (dvp->v_type != VDIR) {
3887 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
3888 		goto out;
3889 	}
3890 
3891 	if (!utf8_dir_verify(&args->target)) {
3892 		*cs->statusp = resp->status = NFS4ERR_INVAL;
3893 		goto out;
3894 	}
3895 
3896 	/*
3897 	 * Lookup the file so that we can check if it's a directory
3898 	 */
3899 	nm = utf8_to_fn(&args->target, &len, NULL);
3900 	if (nm == NULL) {
3901 		*cs->statusp = resp->status = NFS4ERR_INVAL;
3902 		goto out;
3903 	}
3904 
3905 	if (len > MAXNAMELEN) {
3906 		*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
3907 		kmem_free(nm, len);
3908 		goto out;
3909 	}
3910 
3911 	if (rdonly4(cs->exi, cs->vp, req)) {
3912 		*cs->statusp = resp->status = NFS4ERR_ROFS;
3913 		kmem_free(nm, len);
3914 		goto out;
3915 	}
3916 
3917 	/*
3918 	 * Lookup the file to determine type and while we are see if
3919 	 * there is a file struct around and check for delegation.
3920 	 * We don't need to acquire va_seq before this lookup, if
3921 	 * it causes an update, cinfo.before will not match, which will
3922 	 * trigger a cache flush even if atomic is TRUE.
3923 	 */
3924 	if (fp = rfs4_lookup_and_findfile(dvp, nm, &vp, &error, cs->cr)) {
3925 		if (rfs4_check_delegated_byfp(FWRITE, fp, TRUE, TRUE, TRUE,
3926 		    NULL)) {
3927 			VN_RELE(vp);
3928 			rfs4_file_rele(fp);
3929 			*cs->statusp = resp->status = NFS4ERR_DELAY;
3930 			kmem_free(nm, len);
3931 			goto out;
3932 		}
3933 	}
3934 
3935 	/* Didn't find anything to remove */
3936 	if (vp == NULL) {
3937 		*cs->statusp = resp->status = error;
3938 		kmem_free(nm, len);
3939 		goto out;
3940 	}
3941 
3942 	if (nbl_need_check(vp)) {
3943 		nbl_start_crit(vp, RW_READER);
3944 		in_crit = 1;
3945 		if (nbl_conflict(vp, NBL_REMOVE, 0, 0, 0, NULL)) {
3946 			*cs->statusp = resp->status = NFS4ERR_FILE_OPEN;
3947 			kmem_free(nm, len);
3948 			nbl_end_crit(vp);
3949 			VN_RELE(vp);
3950 			if (fp) {
3951 				rfs4_clear_dont_grant(fp);
3952 				rfs4_file_rele(fp);
3953 			}
3954 			goto out;
3955 		}
3956 	}
3957 
3958 	/* check label before allowing removal */
3959 	if (is_system_labeled()) {
3960 		ASSERT(req->rq_label != NULL);
3961 		clabel = req->rq_label;
3962 		DTRACE_PROBE2(tx__rfs4__log__info__opremove__clabel, char *,
3963 		    "got client label from request(1)",
3964 		    struct svc_req *, req);
3965 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
3966 			if (!do_rfs_label_check(clabel, vp, EQUALITY_CHECK)) {
3967 				*cs->statusp = resp->status = NFS4ERR_ACCESS;
3968 				kmem_free(nm, len);
3969 				if (in_crit)
3970 					nbl_end_crit(vp);
3971 				VN_RELE(vp);
3972 				if (fp) {
3973 					rfs4_clear_dont_grant(fp);
3974 					rfs4_file_rele(fp);
3975 				}
3976 				goto out;
3977 			}
3978 		}
3979 	}
3980 
3981 	/* Get dir "before" change value */
3982 	bdva.va_mask = AT_CTIME|AT_SEQ;
3983 	error = VOP_GETATTR(dvp, &bdva, 0, cs->cr, NULL);
3984 	if (error) {
3985 		*cs->statusp = resp->status = puterrno4(error);
3986 		kmem_free(nm, len);
3987 		goto out;
3988 	}
3989 	NFS4_SET_FATTR4_CHANGE(resp->cinfo.before, bdva.va_ctime)
3990 
3991 	/* Actually do the REMOVE operation */
3992 	if (vp->v_type == VDIR) {
3993 		/*
3994 		 * Can't remove a directory that has a mounted-on filesystem.
3995 		 */
3996 		if (vn_ismntpt(vp)) {
3997 			error = EACCES;
3998 		} else {
3999 			/*
4000 			 * System V defines rmdir to return EEXIST,
4001 			 * not * ENOTEMPTY, if the directory is not
4002 			 * empty.  A System V NFS server needs to map
4003 			 * NFS4ERR_EXIST to NFS4ERR_NOTEMPTY to
4004 			 * transmit over the wire.
4005 			 */
4006 			if ((error = VOP_RMDIR(dvp, nm, rootdir, cs->cr,
4007 			    NULL, 0)) == EEXIST)
4008 				error = ENOTEMPTY;
4009 		}
4010 	} else {
4011 		if ((error = VOP_REMOVE(dvp, nm, cs->cr, NULL, 0)) == 0 &&
4012 		    fp != NULL) {
4013 			struct vattr va;
4014 			vnode_t *tvp;
4015 
4016 			rfs4_dbe_lock(fp->dbe);
4017 			tvp = fp->vp;
4018 			if (tvp)
4019 				VN_HOLD(tvp);
4020 			rfs4_dbe_unlock(fp->dbe);
4021 
4022 			if (tvp) {
4023 				/*
4024 				 * This is va_seq safe because we are not
4025 				 * manipulating dvp.
4026 				 */
4027 				va.va_mask = AT_NLINK;
4028 				if (!VOP_GETATTR(tvp, &va, 0, cs->cr, NULL) &&
4029 				    va.va_nlink == 0) {
4030 					/* Remove state on file remove */
4031 					if (in_crit) {
4032 						nbl_end_crit(vp);
4033 						in_crit = 0;
4034 					}
4035 					rfs4_close_all_state(fp);
4036 				}
4037 				VN_RELE(tvp);
4038 			}
4039 		}
4040 	}
4041 
4042 	if (in_crit)
4043 		nbl_end_crit(vp);
4044 	VN_RELE(vp);
4045 
4046 	if (fp) {
4047 		rfs4_clear_dont_grant(fp);
4048 		rfs4_file_rele(fp);
4049 	}
4050 	kmem_free(nm, len);
4051 
4052 	if (error) {
4053 		*cs->statusp = resp->status = puterrno4(error);
4054 		goto out;
4055 	}
4056 
4057 	/*
4058 	 * Get the initial "after" sequence number, if it fails, set to zero
4059 	 */
4060 	idva.va_mask = AT_SEQ;
4061 	if (VOP_GETATTR(dvp, &idva, 0, cs->cr, NULL))
4062 		idva.va_seq = 0;
4063 
4064 	/*
4065 	 * Force modified data and metadata out to stable storage.
4066 	 */
4067 	(void) VOP_FSYNC(dvp, 0, cs->cr, NULL);
4068 
4069 	/*
4070 	 * Get "after" change value, if it fails, simply return the
4071 	 * before value.
4072 	 */
4073 	adva.va_mask = AT_CTIME|AT_SEQ;
4074 	if (VOP_GETATTR(dvp, &adva, 0, cs->cr, NULL)) {
4075 		adva.va_ctime = bdva.va_ctime;
4076 		adva.va_seq = 0;
4077 	}
4078 
4079 	NFS4_SET_FATTR4_CHANGE(resp->cinfo.after, adva.va_ctime)
4080 
4081 	/*
4082 	 * The cinfo.atomic = TRUE only if we have
4083 	 * non-zero va_seq's, and it has incremented by exactly one
4084 	 * during the VOP_REMOVE/RMDIR and it didn't change during
4085 	 * the VOP_FSYNC.
4086 	 */
4087 	if (bdva.va_seq && idva.va_seq && adva.va_seq &&
4088 	    idva.va_seq == (bdva.va_seq + 1) && idva.va_seq == adva.va_seq)
4089 		resp->cinfo.atomic = TRUE;
4090 	else
4091 		resp->cinfo.atomic = FALSE;
4092 
4093 	*cs->statusp = resp->status = NFS4_OK;
4094 
4095 out:
4096 	DTRACE_NFSV4_2(op__remove__done, struct compound_state *, cs,
4097 	    REMOVE4res *, resp);
4098 }
4099 
4100 /*
4101  * rename: args: SAVED_FH: from directory, CURRENT_FH: target directory,
4102  *		oldname and newname.
4103  *	res: status. If success - CURRENT_FH unchanged, return change_info
4104  *		for both from and target directories.
4105  */
4106 /* ARGSUSED */
4107 static void
4108 rfs4_op_rename(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
4109 	struct compound_state *cs)
4110 {
4111 	RENAME4args *args = &argop->nfs_argop4_u.oprename;
4112 	RENAME4res *resp = &resop->nfs_resop4_u.oprename;
4113 	int error;
4114 	vnode_t *odvp;
4115 	vnode_t *ndvp;
4116 	vnode_t *srcvp, *targvp;
4117 	struct vattr obdva, oidva, oadva;
4118 	struct vattr nbdva, nidva, nadva;
4119 	char *onm, *nnm;
4120 	uint_t olen, nlen;
4121 	rfs4_file_t *fp, *sfp;
4122 	int in_crit_src, in_crit_targ;
4123 	int fp_rele_grant_hold, sfp_rele_grant_hold;
4124 	bslabel_t *clabel;
4125 
4126 	DTRACE_NFSV4_2(op__rename__start, struct compound_state *, cs,
4127 	    RENAME4args *, args);
4128 
4129 	fp = sfp = NULL;
4130 	srcvp = targvp = NULL;
4131 	in_crit_src = in_crit_targ = 0;
4132 	fp_rele_grant_hold = sfp_rele_grant_hold = 0;
4133 
4134 	/* CURRENT_FH: target directory */
4135 	ndvp = cs->vp;
4136 	if (ndvp == NULL) {
4137 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
4138 		goto out;
4139 	}
4140 
4141 	/* SAVED_FH: from directory */
4142 	odvp = cs->saved_vp;
4143 	if (odvp == NULL) {
4144 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
4145 		goto out;
4146 	}
4147 
4148 	if (cs->access == CS_ACCESS_DENIED) {
4149 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
4150 		goto out;
4151 	}
4152 
4153 	/*
4154 	 * If there is an unshared filesystem mounted on this vnode,
4155 	 * do not allow to rename objects in this directory.
4156 	 */
4157 	if (vn_ismntpt(odvp)) {
4158 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
4159 		goto out;
4160 	}
4161 
4162 	/*
4163 	 * If there is an unshared filesystem mounted on this vnode,
4164 	 * do not allow to rename to this directory.
4165 	 */
4166 	if (vn_ismntpt(ndvp)) {
4167 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
4168 		goto out;
4169 	}
4170 
4171 	if (odvp->v_type != VDIR || ndvp->v_type != VDIR) {
4172 		*cs->statusp = resp->status = NFS4ERR_NOTDIR;
4173 		goto out;
4174 	}
4175 
4176 	if (cs->saved_exi != cs->exi) {
4177 		*cs->statusp = resp->status = NFS4ERR_XDEV;
4178 		goto out;
4179 	}
4180 
4181 	if (!utf8_dir_verify(&args->oldname)) {
4182 		*cs->statusp = resp->status = NFS4ERR_INVAL;
4183 		goto out;
4184 	}
4185 
4186 	if (!utf8_dir_verify(&args->newname)) {
4187 		*cs->statusp = resp->status = NFS4ERR_INVAL;
4188 		goto out;
4189 	}
4190 
4191 	onm = utf8_to_fn(&args->oldname, &olen, NULL);
4192 	if (onm == NULL) {
4193 		*cs->statusp = resp->status = NFS4ERR_INVAL;
4194 		goto out;
4195 	}
4196 
4197 	nnm = utf8_to_fn(&args->newname, &nlen, NULL);
4198 	if (nnm == NULL) {
4199 		*cs->statusp = resp->status = NFS4ERR_INVAL;
4200 		kmem_free(onm, olen);
4201 		goto out;
4202 	}
4203 
4204 	if (olen > MAXNAMELEN || nlen > MAXNAMELEN) {
4205 		*cs->statusp = resp->status = NFS4ERR_NAMETOOLONG;
4206 		kmem_free(onm, olen);
4207 		kmem_free(nnm, nlen);
4208 		goto out;
4209 	}
4210 
4211 
4212 	if (rdonly4(cs->exi, cs->vp, req)) {
4213 		*cs->statusp = resp->status = NFS4ERR_ROFS;
4214 		kmem_free(onm, olen);
4215 		kmem_free(nnm, nlen);
4216 		goto out;
4217 	}
4218 
4219 	/* check label of the target dir */
4220 	if (is_system_labeled()) {
4221 		ASSERT(req->rq_label != NULL);
4222 		clabel = req->rq_label;
4223 		DTRACE_PROBE2(tx__rfs4__log__info__oprename__clabel, char *,
4224 		    "got client label from request(1)",
4225 		    struct svc_req *, req);
4226 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
4227 			if (!do_rfs_label_check(clabel, ndvp,
4228 			    EQUALITY_CHECK)) {
4229 				*cs->statusp = resp->status = NFS4ERR_ACCESS;
4230 				goto out;
4231 			}
4232 		}
4233 	}
4234 
4235 	/*
4236 	 * Is the source a file and have a delegation?
4237 	 * We don't need to acquire va_seq before these lookups, if
4238 	 * it causes an update, cinfo.before will not match, which will
4239 	 * trigger a cache flush even if atomic is TRUE.
4240 	 */
4241 	if (sfp = rfs4_lookup_and_findfile(odvp, onm, &srcvp, &error, cs->cr)) {
4242 		if (rfs4_check_delegated_byfp(FWRITE, sfp, TRUE, TRUE, TRUE,
4243 		    NULL)) {
4244 			*cs->statusp = resp->status = NFS4ERR_DELAY;
4245 			goto err_out;
4246 		}
4247 	}
4248 
4249 	if (srcvp == NULL) {
4250 		*cs->statusp = resp->status = puterrno4(error);
4251 		kmem_free(onm, olen);
4252 		kmem_free(nnm, nlen);
4253 		goto out;
4254 	}
4255 
4256 	sfp_rele_grant_hold = 1;
4257 
4258 	/* Does the destination exist and a file and have a delegation? */
4259 	if (fp = rfs4_lookup_and_findfile(ndvp, nnm, &targvp, NULL, cs->cr)) {
4260 		if (rfs4_check_delegated_byfp(FWRITE, fp, TRUE, TRUE, TRUE,
4261 		    NULL)) {
4262 			*cs->statusp = resp->status = NFS4ERR_DELAY;
4263 			goto err_out;
4264 		}
4265 	}
4266 	fp_rele_grant_hold = 1;
4267 
4268 
4269 	/* Check for NBMAND lock on both source and target */
4270 	if (nbl_need_check(srcvp)) {
4271 		nbl_start_crit(srcvp, RW_READER);
4272 		in_crit_src = 1;
4273 		if (nbl_conflict(srcvp, NBL_RENAME, 0, 0, 0, NULL)) {
4274 			*cs->statusp = resp->status = NFS4ERR_FILE_OPEN;
4275 			goto err_out;
4276 		}
4277 	}
4278 
4279 	if (targvp && nbl_need_check(targvp)) {
4280 		nbl_start_crit(targvp, RW_READER);
4281 		in_crit_targ = 1;
4282 		if (nbl_conflict(targvp, NBL_REMOVE, 0, 0, 0, NULL)) {
4283 			*cs->statusp = resp->status = NFS4ERR_FILE_OPEN;
4284 			goto err_out;
4285 		}
4286 	}
4287 
4288 	/* Get source "before" change value */
4289 	obdva.va_mask = AT_CTIME|AT_SEQ;
4290 	error = VOP_GETATTR(odvp, &obdva, 0, cs->cr, NULL);
4291 	if (!error) {
4292 		nbdva.va_mask = AT_CTIME|AT_SEQ;
4293 		error = VOP_GETATTR(ndvp, &nbdva, 0, cs->cr, NULL);
4294 	}
4295 	if (error) {
4296 		*cs->statusp = resp->status = puterrno4(error);
4297 		goto err_out;
4298 	}
4299 
4300 	NFS4_SET_FATTR4_CHANGE(resp->source_cinfo.before, obdva.va_ctime)
4301 	NFS4_SET_FATTR4_CHANGE(resp->target_cinfo.before, nbdva.va_ctime)
4302 
4303 	if ((error = VOP_RENAME(odvp, onm, ndvp, nnm, cs->cr, NULL, 0)) == 0 &&
4304 	    fp != NULL) {
4305 		struct vattr va;
4306 		vnode_t *tvp;
4307 
4308 		rfs4_dbe_lock(fp->dbe);
4309 		tvp = fp->vp;
4310 		if (tvp)
4311 			VN_HOLD(tvp);
4312 		rfs4_dbe_unlock(fp->dbe);
4313 
4314 		if (tvp) {
4315 			va.va_mask = AT_NLINK;
4316 			if (!VOP_GETATTR(tvp, &va, 0, cs->cr, NULL) &&
4317 			    va.va_nlink == 0) {
4318 				/* The file is gone and so should the state */
4319 				if (in_crit_targ) {
4320 					nbl_end_crit(targvp);
4321 					in_crit_targ = 0;
4322 				}
4323 				rfs4_close_all_state(fp);
4324 			}
4325 			VN_RELE(tvp);
4326 		}
4327 	}
4328 	if (error == 0) {
4329 		char *tmp;
4330 
4331 		/* fix the path name for the renamed file */
4332 		mutex_enter(&srcvp->v_lock);
4333 		tmp = srcvp->v_path;
4334 		srcvp->v_path = NULL;
4335 		mutex_exit(&srcvp->v_lock);
4336 		vn_setpath(rootdir, ndvp, srcvp, nnm, nlen - 1);
4337 		if (tmp != NULL)
4338 			kmem_free(tmp, strlen(tmp) + 1);
4339 	}
4340 
4341 	if (in_crit_src)
4342 		nbl_end_crit(srcvp);
4343 	if (srcvp)
4344 		VN_RELE(srcvp);
4345 	if (in_crit_targ)
4346 		nbl_end_crit(targvp);
4347 	if (targvp)
4348 		VN_RELE(targvp);
4349 
4350 	if (sfp) {
4351 		rfs4_clear_dont_grant(sfp);
4352 		rfs4_file_rele(sfp);
4353 	}
4354 	if (fp) {
4355 		rfs4_clear_dont_grant(fp);
4356 		rfs4_file_rele(fp);
4357 	}
4358 
4359 	kmem_free(onm, olen);
4360 	kmem_free(nnm, nlen);
4361 
4362 	/*
4363 	 * Get the initial "after" sequence number, if it fails, set to zero
4364 	 */
4365 	oidva.va_mask = AT_SEQ;
4366 	if (VOP_GETATTR(odvp, &oidva, 0, cs->cr, NULL))
4367 		oidva.va_seq = 0;
4368 
4369 	nidva.va_mask = AT_SEQ;
4370 	if (VOP_GETATTR(ndvp, &nidva, 0, cs->cr, NULL))
4371 		nidva.va_seq = 0;
4372 
4373 	/*
4374 	 * Force modified data and metadata out to stable storage.
4375 	 */
4376 	(void) VOP_FSYNC(odvp, 0, cs->cr, NULL);
4377 	(void) VOP_FSYNC(ndvp, 0, cs->cr, NULL);
4378 
4379 	if (error) {
4380 		*cs->statusp = resp->status = puterrno4(error);
4381 		goto out;
4382 	}
4383 
4384 	/*
4385 	 * Get "after" change values, if it fails, simply return the
4386 	 * before value.
4387 	 */
4388 	oadva.va_mask = AT_CTIME|AT_SEQ;
4389 	if (VOP_GETATTR(odvp, &oadva, 0, cs->cr, NULL)) {
4390 		oadva.va_ctime = obdva.va_ctime;
4391 		oadva.va_seq = 0;
4392 	}
4393 
4394 	nadva.va_mask = AT_CTIME|AT_SEQ;
4395 	if (VOP_GETATTR(odvp, &nadva, 0, cs->cr, NULL)) {
4396 		nadva.va_ctime = nbdva.va_ctime;
4397 		nadva.va_seq = 0;
4398 	}
4399 
4400 	NFS4_SET_FATTR4_CHANGE(resp->source_cinfo.after, oadva.va_ctime)
4401 	NFS4_SET_FATTR4_CHANGE(resp->target_cinfo.after, nadva.va_ctime)
4402 
4403 	/*
4404 	 * The cinfo.atomic = TRUE only if we have
4405 	 * non-zero va_seq's, and it has incremented by exactly one
4406 	 * during the VOP_RENAME and it didn't change during the VOP_FSYNC.
4407 	 */
4408 	if (obdva.va_seq && oidva.va_seq && oadva.va_seq &&
4409 	    oidva.va_seq == (obdva.va_seq + 1) && oidva.va_seq == oadva.va_seq)
4410 		resp->source_cinfo.atomic = TRUE;
4411 	else
4412 		resp->source_cinfo.atomic = FALSE;
4413 
4414 	if (nbdva.va_seq && nidva.va_seq && nadva.va_seq &&
4415 	    nidva.va_seq == (nbdva.va_seq + 1) && nidva.va_seq == nadva.va_seq)
4416 		resp->target_cinfo.atomic = TRUE;
4417 	else
4418 		resp->target_cinfo.atomic = FALSE;
4419 
4420 #ifdef	VOLATILE_FH_TEST
4421 	{
4422 	extern void add_volrnm_fh(struct exportinfo *, vnode_t *);
4423 
4424 	/*
4425 	 * Add the renamed file handle to the volatile rename list
4426 	 */
4427 	if (cs->exi->exi_export.ex_flags & EX_VOLRNM) {
4428 		/* file handles may expire on rename */
4429 		vnode_t *vp;
4430 
4431 		nnm = utf8_to_fn(&args->newname, &nlen, NULL);
4432 		/*
4433 		 * Already know that nnm will be a valid string
4434 		 */
4435 		error = VOP_LOOKUP(ndvp, nnm, &vp, NULL, 0, NULL, cs->cr,
4436 		    NULL, NULL, NULL);
4437 		kmem_free(nnm, nlen);
4438 		if (!error) {
4439 			add_volrnm_fh(cs->exi, vp);
4440 			VN_RELE(vp);
4441 		}
4442 	}
4443 	}
4444 #endif	/* VOLATILE_FH_TEST */
4445 
4446 	*cs->statusp = resp->status = NFS4_OK;
4447 out:
4448 	DTRACE_NFSV4_2(op__rename__done, struct compound_state *, cs,
4449 	    RENAME4res *, resp);
4450 	return;
4451 
4452 err_out:
4453 	kmem_free(onm, olen);
4454 	kmem_free(nnm, nlen);
4455 
4456 	if (in_crit_src) nbl_end_crit(srcvp);
4457 	if (in_crit_targ) nbl_end_crit(targvp);
4458 	if (targvp) VN_RELE(targvp);
4459 	if (srcvp) VN_RELE(srcvp);
4460 	if (sfp) {
4461 		if (sfp_rele_grant_hold) rfs4_clear_dont_grant(sfp);
4462 		rfs4_file_rele(sfp);
4463 	}
4464 	if (fp) {
4465 		if (fp_rele_grant_hold) rfs4_clear_dont_grant(fp);
4466 		rfs4_file_rele(fp);
4467 	}
4468 
4469 	DTRACE_NFSV4_2(op__rename__done, struct compound_state *, cs,
4470 	    RENAME4res *, resp);
4471 }
4472 
4473 /* ARGSUSED */
4474 static void
4475 rfs4_op_renew(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
4476 	struct compound_state *cs)
4477 {
4478 	RENEW4args *args = &argop->nfs_argop4_u.oprenew;
4479 	RENEW4res *resp = &resop->nfs_resop4_u.oprenew;
4480 	rfs4_client_t *cp;
4481 
4482 	DTRACE_NFSV4_2(op__renew__start, struct compound_state *, cs,
4483 	    RENEW4args *, args);
4484 
4485 	if ((cp = rfs4_findclient_by_id(args->clientid, FALSE)) == NULL) {
4486 		*cs->statusp = resp->status =
4487 		    rfs4_check_clientid(&args->clientid, 0);
4488 		goto out;
4489 	}
4490 
4491 	if (rfs4_lease_expired(cp)) {
4492 		rfs4_client_rele(cp);
4493 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
4494 		goto out;
4495 	}
4496 
4497 	rfs4_update_lease(cp);
4498 
4499 	mutex_enter(cp->cbinfo.cb_lock);
4500 	if (cp->cbinfo.cb_notified_of_cb_path_down == FALSE) {
4501 		cp->cbinfo.cb_notified_of_cb_path_down = TRUE;
4502 		*cs->statusp = resp->status = NFS4ERR_CB_PATH_DOWN;
4503 	} else {
4504 		*cs->statusp = resp->status = NFS4_OK;
4505 	}
4506 	mutex_exit(cp->cbinfo.cb_lock);
4507 
4508 	rfs4_client_rele(cp);
4509 
4510 out:
4511 	DTRACE_NFSV4_2(op__renew__done, struct compound_state *, cs,
4512 	    RENEW4res *, resp);
4513 }
4514 
4515 /* ARGSUSED */
4516 static void
4517 rfs4_op_restorefh(nfs_argop4 *args, nfs_resop4 *resop, struct svc_req *req,
4518 	struct compound_state *cs)
4519 {
4520 	RESTOREFH4res *resp = &resop->nfs_resop4_u.oprestorefh;
4521 
4522 	DTRACE_NFSV4_1(op__restorefh__start, struct compound_state *, cs);
4523 
4524 	/* No need to check cs->access - we are not accessing any object */
4525 	if ((cs->saved_vp == NULL) || (cs->saved_fh.nfs_fh4_val == NULL)) {
4526 		*cs->statusp = resp->status = NFS4ERR_RESTOREFH;
4527 		goto out;
4528 	}
4529 	if (cs->vp != NULL) {
4530 		VN_RELE(cs->vp);
4531 	}
4532 	cs->vp = cs->saved_vp;
4533 	cs->saved_vp = NULL;
4534 	cs->exi = cs->saved_exi;
4535 	nfs_fh4_copy(&cs->saved_fh, &cs->fh);
4536 	*cs->statusp = resp->status = NFS4_OK;
4537 	cs->deleg = FALSE;
4538 
4539 out:
4540 	DTRACE_NFSV4_2(op__restorefh__done, struct compound_state *, cs,
4541 	    RESTOREFH4res *, resp);
4542 }
4543 
4544 /* ARGSUSED */
4545 static void
4546 rfs4_op_savefh(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
4547 	struct compound_state *cs)
4548 {
4549 	SAVEFH4res *resp = &resop->nfs_resop4_u.opsavefh;
4550 
4551 	DTRACE_NFSV4_1(op__savefh__start, struct compound_state *, cs);
4552 
4553 	/* No need to check cs->access - we are not accessing any object */
4554 	if (cs->vp == NULL) {
4555 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
4556 		goto out;
4557 	}
4558 	if (cs->saved_vp != NULL) {
4559 		VN_RELE(cs->saved_vp);
4560 	}
4561 	cs->saved_vp = cs->vp;
4562 	VN_HOLD(cs->saved_vp);
4563 	cs->saved_exi = cs->exi;
4564 	/*
4565 	 * since SAVEFH is fairly rare, don't alloc space for its fh
4566 	 * unless necessary.
4567 	 */
4568 	if (cs->saved_fh.nfs_fh4_val == NULL) {
4569 		cs->saved_fh.nfs_fh4_val = kmem_alloc(NFS4_FHSIZE, KM_SLEEP);
4570 	}
4571 	nfs_fh4_copy(&cs->fh, &cs->saved_fh);
4572 	*cs->statusp = resp->status = NFS4_OK;
4573 
4574 out:
4575 	DTRACE_NFSV4_2(op__savefh__done, struct compound_state *, cs,
4576 	    SAVEFH4res *, resp);
4577 }
4578 
4579 /*
4580  * rfs4_verify_attr is called when nfsv4 Setattr failed, but we wish to
4581  * return the bitmap of attrs that were set successfully. It is also
4582  * called by Verify/Nverify to test the vattr/vfsstat attrs. It should
4583  * always be called only after rfs4_do_set_attrs().
4584  *
4585  * Verify that the attributes are same as the expected ones. sargp->vap
4586  * and sargp->sbp contain the input attributes as translated from fattr4.
4587  *
4588  * This function verifies only the attrs that correspond to a vattr or
4589  * vfsstat struct. That is because of the extra step needed to get the
4590  * corresponding system structs. Other attributes have already been set or
4591  * verified by do_rfs4_set_attrs.
4592  *
4593  * Return 0 if all attrs match, -1 if some don't, error if error processing.
4594  */
4595 static int
4596 rfs4_verify_attr(struct nfs4_svgetit_arg *sargp,
4597 	bitmap4 *resp, struct nfs4_ntov_table *ntovp)
4598 {
4599 	int error, ret_error = 0;
4600 	int i, k;
4601 	uint_t sva_mask = sargp->vap->va_mask;
4602 	uint_t vbit;
4603 	union nfs4_attr_u *na;
4604 	uint8_t *amap;
4605 	bool_t getsb = ntovp->vfsstat;
4606 
4607 	if (sva_mask != 0) {
4608 		/*
4609 		 * Okay to overwrite sargp->vap because we verify based
4610 		 * on the incoming values.
4611 		 */
4612 		ret_error = VOP_GETATTR(sargp->cs->vp, sargp->vap, 0,
4613 		    sargp->cs->cr, NULL);
4614 		if (ret_error) {
4615 			if (resp == NULL)
4616 				return (ret_error);
4617 			/*
4618 			 * Must return bitmap of successful attrs
4619 			 */
4620 			sva_mask = 0;	/* to prevent checking vap later */
4621 		} else {
4622 			/*
4623 			 * Some file systems clobber va_mask. it is probably
4624 			 * wrong of them to do so, nonethless we practice
4625 			 * defensive coding.
4626 			 * See bug id 4276830.
4627 			 */
4628 			sargp->vap->va_mask = sva_mask;
4629 		}
4630 	}
4631 
4632 	if (getsb) {
4633 		/*
4634 		 * Now get the superblock and loop on the bitmap, as there is
4635 		 * no simple way of translating from superblock to bitmap4.
4636 		 */
4637 		ret_error = VFS_STATVFS(sargp->cs->vp->v_vfsp, sargp->sbp);
4638 		if (ret_error) {
4639 			if (resp == NULL)
4640 				goto errout;
4641 			getsb = FALSE;
4642 		}
4643 	}
4644 
4645 	/*
4646 	 * Now loop and verify each attribute which getattr returned
4647 	 * whether it's the same as the input.
4648 	 */
4649 	if (resp == NULL && !getsb && (sva_mask == 0))
4650 		goto errout;
4651 
4652 	na = ntovp->na;
4653 	amap = ntovp->amap;
4654 	k = 0;
4655 	for (i = 0; i < ntovp->attrcnt; i++, na++, amap++) {
4656 		k = *amap;
4657 		ASSERT(nfs4_ntov_map[k].nval == k);
4658 		vbit = nfs4_ntov_map[k].vbit;
4659 
4660 		/*
4661 		 * If vattr attribute but VOP_GETATTR failed, or it's
4662 		 * superblock attribute but VFS_STATVFS failed, skip
4663 		 */
4664 		if (vbit) {
4665 			if ((vbit & sva_mask) == 0)
4666 				continue;
4667 		} else if (!(getsb && nfs4_ntov_map[k].vfsstat)) {
4668 			continue;
4669 		}
4670 		error = (*nfs4_ntov_map[k].sv_getit)(NFS4ATTR_VERIT, sargp, na);
4671 		if (resp != NULL) {
4672 			if (error)
4673 				ret_error = -1;	/* not all match */
4674 			else	/* update response bitmap */
4675 				*resp |= nfs4_ntov_map[k].fbit;
4676 			continue;
4677 		}
4678 		if (error) {
4679 			ret_error = -1;	/* not all match */
4680 			break;
4681 		}
4682 	}
4683 errout:
4684 	return (ret_error);
4685 }
4686 
4687 /*
4688  * Decode the attribute to be set/verified. If the attr requires a sys op
4689  * (VOP_GETATTR, VFS_VFSSTAT), and the request is to verify, then don't
4690  * call the sv_getit function for it, because the sys op hasn't yet been done.
4691  * Return 0 for success, error code if failed.
4692  *
4693  * Note: the decoded arg is not freed here but in nfs4_ntov_table_free.
4694  */
4695 static int
4696 decode_fattr4_attr(nfs4_attr_cmd_t cmd, struct nfs4_svgetit_arg *sargp,
4697 	int k, XDR *xdrp, bitmap4 *resp_bval, union nfs4_attr_u *nap)
4698 {
4699 	int error = 0;
4700 	bool_t set_later;
4701 
4702 	sargp->vap->va_mask |= nfs4_ntov_map[k].vbit;
4703 
4704 	if ((*nfs4_ntov_map[k].xfunc)(xdrp, nap)) {
4705 		set_later = nfs4_ntov_map[k].vbit || nfs4_ntov_map[k].vfsstat;
4706 		/*
4707 		 * don't verify yet if a vattr or sb dependent attr,
4708 		 * because we don't have their sys values yet.
4709 		 * Will be done later.
4710 		 */
4711 		if (! (set_later && (cmd == NFS4ATTR_VERIT))) {
4712 			/*
4713 			 * ACLs are a special case, since setting the MODE
4714 			 * conflicts with setting the ACL.  We delay setting
4715 			 * the ACL until all other attributes have been set.
4716 			 * The ACL gets set in do_rfs4_op_setattr().
4717 			 */
4718 			if (nfs4_ntov_map[k].fbit != FATTR4_ACL_MASK) {
4719 				error = (*nfs4_ntov_map[k].sv_getit)(cmd,
4720 				    sargp, nap);
4721 				if (error) {
4722 					xdr_free(nfs4_ntov_map[k].xfunc,
4723 					    (caddr_t)nap);
4724 				}
4725 			}
4726 		}
4727 	} else {
4728 #ifdef  DEBUG
4729 		cmn_err(CE_NOTE, "decode_fattr4_attr: error "
4730 		    "decoding attribute %d\n", k);
4731 #endif
4732 		error = EINVAL;
4733 	}
4734 	if (!error && resp_bval && !set_later) {
4735 		*resp_bval |= nfs4_ntov_map[k].fbit;
4736 	}
4737 
4738 	return (error);
4739 }
4740 
4741 /*
4742  * Set vattr based on incoming fattr4 attrs - used by setattr.
4743  * Set response mask. Ignore any values that are not writable vattr attrs.
4744  */
4745 static nfsstat4
4746 do_rfs4_set_attrs(bitmap4 *resp, fattr4 *fattrp, struct compound_state *cs,
4747 		struct nfs4_svgetit_arg *sargp, struct nfs4_ntov_table *ntovp,
4748 		nfs4_attr_cmd_t cmd)
4749 {
4750 	int error = 0;
4751 	int i;
4752 	char *attrs = fattrp->attrlist4;
4753 	uint32_t attrslen = fattrp->attrlist4_len;
4754 	XDR xdr;
4755 	nfsstat4 status = NFS4_OK;
4756 	vnode_t *vp = cs->vp;
4757 	union nfs4_attr_u *na;
4758 	uint8_t *amap;
4759 
4760 #ifndef lint
4761 	/*
4762 	 * Make sure that maximum attribute number can be expressed as an
4763 	 * 8 bit quantity.
4764 	 */
4765 	ASSERT(NFS4_MAXNUM_ATTRS <= (UINT8_MAX + 1));
4766 #endif
4767 
4768 	if (vp == NULL) {
4769 		if (resp)
4770 			*resp = 0;
4771 		return (NFS4ERR_NOFILEHANDLE);
4772 	}
4773 	if (cs->access == CS_ACCESS_DENIED) {
4774 		if (resp)
4775 			*resp = 0;
4776 		return (NFS4ERR_ACCESS);
4777 	}
4778 
4779 	sargp->op = cmd;
4780 	sargp->cs = cs;
4781 	sargp->flag = 0;	/* may be set later */
4782 	sargp->vap->va_mask = 0;
4783 	sargp->rdattr_error = NFS4_OK;
4784 	sargp->rdattr_error_req = FALSE;
4785 	/* sargp->sbp is set by the caller */
4786 
4787 	xdrmem_create(&xdr, attrs, attrslen, XDR_DECODE);
4788 
4789 	na = ntovp->na;
4790 	amap = ntovp->amap;
4791 
4792 	/*
4793 	 * The following loop iterates on the nfs4_ntov_map checking
4794 	 * if the fbit is set in the requested bitmap.
4795 	 * If set then we process the arguments using the
4796 	 * rfs4_fattr4 conversion functions to populate the setattr
4797 	 * vattr and va_mask. Any settable attrs that are not using vattr
4798 	 * will be set in this loop.
4799 	 */
4800 	for (i = 0; i < nfs4_ntov_map_size; i++) {
4801 		if (!(fattrp->attrmask & nfs4_ntov_map[i].fbit)) {
4802 			continue;
4803 		}
4804 		/*
4805 		 * If setattr, must be a writable attr.
4806 		 * If verify/nverify, must be a readable attr.
4807 		 */
4808 		if ((error = (*nfs4_ntov_map[i].sv_getit)(
4809 		    NFS4ATTR_SUPPORTED, sargp, NULL)) != 0) {
4810 			/*
4811 			 * Client tries to set/verify an
4812 			 * unsupported attribute, tries to set
4813 			 * a read only attr or verify a write
4814 			 * only one - error!
4815 			 */
4816 			break;
4817 		}
4818 		/*
4819 		 * Decode the attribute to set/verify
4820 		 */
4821 		error = decode_fattr4_attr(cmd, sargp, nfs4_ntov_map[i].nval,
4822 		    &xdr, resp ? resp : NULL, na);
4823 		if (error)
4824 			break;
4825 		*amap++ = (uint8_t)nfs4_ntov_map[i].nval;
4826 		na++;
4827 		(ntovp->attrcnt)++;
4828 		if (nfs4_ntov_map[i].vfsstat)
4829 			ntovp->vfsstat = TRUE;
4830 	}
4831 
4832 	if (error != 0)
4833 		status = (error == ENOTSUP ? NFS4ERR_ATTRNOTSUPP :
4834 		    puterrno4(error));
4835 	/* xdrmem_destroy(&xdrs); */	/* NO-OP */
4836 	return (status);
4837 }
4838 
4839 static nfsstat4
4840 do_rfs4_op_setattr(bitmap4 *resp, fattr4 *fattrp, struct compound_state *cs,
4841 		stateid4 *stateid)
4842 {
4843 	int error = 0;
4844 	struct nfs4_svgetit_arg sarg;
4845 	bool_t trunc;
4846 
4847 	nfsstat4 status = NFS4_OK;
4848 	cred_t *cr = cs->cr;
4849 	vnode_t *vp = cs->vp;
4850 	struct nfs4_ntov_table ntov;
4851 	struct statvfs64 sb;
4852 	struct vattr bva;
4853 	struct flock64 bf;
4854 	int in_crit = 0;
4855 	uint_t saved_mask = 0;
4856 	caller_context_t ct;
4857 
4858 	*resp = 0;
4859 	sarg.sbp = &sb;
4860 	nfs4_ntov_table_init(&ntov);
4861 	status = do_rfs4_set_attrs(resp, fattrp, cs, &sarg, &ntov,
4862 	    NFS4ATTR_SETIT);
4863 	if (status != NFS4_OK) {
4864 		/*
4865 		 * failed set attrs
4866 		 */
4867 		goto done;
4868 	}
4869 	if ((sarg.vap->va_mask == 0) &&
4870 	    (! (fattrp->attrmask & FATTR4_ACL_MASK))) {
4871 		/*
4872 		 * no further work to be done
4873 		 */
4874 		goto done;
4875 	}
4876 
4877 	/*
4878 	 * If we got a request to set the ACL and the MODE, only
4879 	 * allow changing VSUID, VSGID, and VSVTX.  Attempting
4880 	 * to change any other bits, along with setting an ACL,
4881 	 * gives NFS4ERR_INVAL.
4882 	 */
4883 	if ((fattrp->attrmask & FATTR4_ACL_MASK) &&
4884 	    (fattrp->attrmask & FATTR4_MODE_MASK)) {
4885 		vattr_t va;
4886 
4887 		va.va_mask = AT_MODE;
4888 		error = VOP_GETATTR(vp, &va, 0, cs->cr, NULL);
4889 		if (error) {
4890 			status = puterrno4(error);
4891 			goto done;
4892 		}
4893 		if ((sarg.vap->va_mode ^ va.va_mode) &
4894 		    ~(VSUID | VSGID | VSVTX)) {
4895 			status = NFS4ERR_INVAL;
4896 			goto done;
4897 		}
4898 	}
4899 
4900 	/* Check stateid only if size has been set */
4901 	if (sarg.vap->va_mask & AT_SIZE) {
4902 		trunc = (sarg.vap->va_size == 0);
4903 		status = rfs4_check_stateid(FWRITE, cs->vp, stateid,
4904 		    trunc, &cs->deleg, sarg.vap->va_mask & AT_SIZE, &ct);
4905 		if (status != NFS4_OK)
4906 			goto done;
4907 	} else {
4908 		ct.cc_sysid = 0;
4909 		ct.cc_pid = 0;
4910 		ct.cc_caller_id = nfs4_srv_caller_id;
4911 		ct.cc_flags = CC_DONTBLOCK;
4912 	}
4913 
4914 	/* XXX start of possible race with delegations */
4915 
4916 	/*
4917 	 * We need to specially handle size changes because it is
4918 	 * possible for the client to create a file with read-only
4919 	 * modes, but with the file opened for writing. If the client
4920 	 * then tries to set the file size, e.g. ftruncate(3C),
4921 	 * fcntl(F_FREESP), the normal access checking done in
4922 	 * VOP_SETATTR would prevent the client from doing it even though
4923 	 * it should be allowed to do so.  To get around this, we do the
4924 	 * access checking for ourselves and use VOP_SPACE which doesn't
4925 	 * do the access checking.
4926 	 * Also the client should not be allowed to change the file
4927 	 * size if there is a conflicting non-blocking mandatory lock in
4928 	 * the region of the change.
4929 	 */
4930 	if (vp->v_type == VREG && (sarg.vap->va_mask & AT_SIZE)) {
4931 		u_offset_t offset;
4932 		ssize_t length;
4933 
4934 		/*
4935 		 * ufs_setattr clears AT_SIZE from vap->va_mask, but
4936 		 * before returning, sarg.vap->va_mask is used to
4937 		 * generate the setattr reply bitmap.  We also clear
4938 		 * AT_SIZE below before calling VOP_SPACE.  For both
4939 		 * of these cases, the va_mask needs to be saved here
4940 		 * and restored after calling VOP_SETATTR.
4941 		 */
4942 		saved_mask = sarg.vap->va_mask;
4943 
4944 		/*
4945 		 * Check any possible conflict due to NBMAND locks.
4946 		 * Get into critical region before VOP_GETATTR, so the
4947 		 * size attribute is valid when checking conflicts.
4948 		 */
4949 		if (nbl_need_check(vp)) {
4950 			nbl_start_crit(vp, RW_READER);
4951 			in_crit = 1;
4952 		}
4953 
4954 		bva.va_mask = AT_UID|AT_SIZE;
4955 		if (error = VOP_GETATTR(vp, &bva, 0, cr, &ct)) {
4956 			status = puterrno4(error);
4957 			goto done;
4958 		}
4959 
4960 		if (in_crit) {
4961 			if (sarg.vap->va_size < bva.va_size) {
4962 				offset = sarg.vap->va_size;
4963 				length = bva.va_size - sarg.vap->va_size;
4964 			} else {
4965 				offset = bva.va_size;
4966 				length = sarg.vap->va_size - bva.va_size;
4967 			}
4968 			if (nbl_conflict(vp, NBL_WRITE, offset, length, 0,
4969 			    &ct)) {
4970 				status = NFS4ERR_LOCKED;
4971 				goto done;
4972 			}
4973 		}
4974 
4975 		if (crgetuid(cr) == bva.va_uid) {
4976 			sarg.vap->va_mask &= ~AT_SIZE;
4977 			bf.l_type = F_WRLCK;
4978 			bf.l_whence = 0;
4979 			bf.l_start = (off64_t)sarg.vap->va_size;
4980 			bf.l_len = 0;
4981 			bf.l_sysid = 0;
4982 			bf.l_pid = 0;
4983 			error = VOP_SPACE(vp, F_FREESP, &bf, FWRITE,
4984 			    (offset_t)sarg.vap->va_size, cr, &ct);
4985 		}
4986 	}
4987 
4988 	if (!error && sarg.vap->va_mask != 0)
4989 		error = VOP_SETATTR(vp, sarg.vap, sarg.flag, cr, &ct);
4990 
4991 	/* restore va_mask -- ufs_setattr clears AT_SIZE */
4992 	if (saved_mask & AT_SIZE)
4993 		sarg.vap->va_mask |= AT_SIZE;
4994 
4995 	/*
4996 	 * If an ACL was being set, it has been delayed until now,
4997 	 * in order to set the mode (via the VOP_SETATTR() above) first.
4998 	 */
4999 	if ((! error) && (fattrp->attrmask & FATTR4_ACL_MASK)) {
5000 		int i;
5001 
5002 		for (i = 0; i < NFS4_MAXNUM_ATTRS; i++)
5003 			if (ntov.amap[i] == FATTR4_ACL)
5004 				break;
5005 		if (i < NFS4_MAXNUM_ATTRS) {
5006 			error = (*nfs4_ntov_map[FATTR4_ACL].sv_getit)(
5007 			    NFS4ATTR_SETIT, &sarg, &ntov.na[i]);
5008 			if (error == 0) {
5009 				*resp |= FATTR4_ACL_MASK;
5010 			} else if (error == ENOTSUP) {
5011 				(void) rfs4_verify_attr(&sarg, resp, &ntov);
5012 				status = NFS4ERR_ATTRNOTSUPP;
5013 				goto done;
5014 			}
5015 		} else {
5016 			NFS4_DEBUG(rfs4_debug,
5017 			    (CE_NOTE, "do_rfs4_op_setattr: "
5018 			    "unable to find ACL in fattr4"));
5019 			error = EINVAL;
5020 		}
5021 	}
5022 
5023 	if (error) {
5024 		/* check if a monitor detected a delegation conflict */
5025 		if (error == EAGAIN && (ct.cc_flags & CC_WOULDBLOCK))
5026 			status = NFS4ERR_DELAY;
5027 		else
5028 			status = puterrno4(error);
5029 
5030 		/*
5031 		 * Set the response bitmap when setattr failed.
5032 		 * If VOP_SETATTR partially succeeded, test by doing a
5033 		 * VOP_GETATTR on the object and comparing the data
5034 		 * to the setattr arguments.
5035 		 */
5036 		(void) rfs4_verify_attr(&sarg, resp, &ntov);
5037 	} else {
5038 		/*
5039 		 * Force modified metadata out to stable storage.
5040 		 */
5041 		(void) VOP_FSYNC(vp, FNODSYNC, cr, &ct);
5042 		/*
5043 		 * Set response bitmap
5044 		 */
5045 		nfs4_vmask_to_nmask_set(sarg.vap->va_mask, resp);
5046 	}
5047 
5048 /* Return early and already have a NFSv4 error */
5049 done:
5050 	/*
5051 	 * Except for nfs4_vmask_to_nmask_set(), vattr --> fattr
5052 	 * conversion sets both readable and writeable NFS4 attrs
5053 	 * for AT_MTIME and AT_ATIME.  The line below masks out
5054 	 * unrequested attrs from the setattr result bitmap.  This
5055 	 * is placed after the done: label to catch the ATTRNOTSUP
5056 	 * case.
5057 	 */
5058 	*resp &= fattrp->attrmask;
5059 
5060 	if (in_crit)
5061 		nbl_end_crit(vp);
5062 
5063 	nfs4_ntov_table_free(&ntov, &sarg);
5064 
5065 	return (status);
5066 }
5067 
5068 /* ARGSUSED */
5069 static void
5070 rfs4_op_setattr(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
5071 	struct compound_state *cs)
5072 {
5073 	SETATTR4args *args = &argop->nfs_argop4_u.opsetattr;
5074 	SETATTR4res *resp = &resop->nfs_resop4_u.opsetattr;
5075 	bslabel_t *clabel;
5076 
5077 	DTRACE_NFSV4_2(op__setattr__start, struct compound_state *, cs,
5078 	    SETATTR4args *, args);
5079 
5080 	if (cs->vp == NULL) {
5081 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
5082 		goto out;
5083 	}
5084 
5085 	/*
5086 	 * If there is an unshared filesystem mounted on this vnode,
5087 	 * do not allow to setattr on this vnode.
5088 	 */
5089 	if (vn_ismntpt(cs->vp)) {
5090 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
5091 		goto out;
5092 	}
5093 
5094 	resp->attrsset = 0;
5095 
5096 	if (rdonly4(cs->exi, cs->vp, req)) {
5097 		*cs->statusp = resp->status = NFS4ERR_ROFS;
5098 		goto out;
5099 	}
5100 
5101 	/* check label before setting attributes */
5102 	if (is_system_labeled()) {
5103 		ASSERT(req->rq_label != NULL);
5104 		clabel = req->rq_label;
5105 		DTRACE_PROBE2(tx__rfs4__log__info__opsetattr__clabel, char *,
5106 		    "got client label from request(1)",
5107 		    struct svc_req *, req);
5108 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
5109 			if (!do_rfs_label_check(clabel, cs->vp,
5110 			    EQUALITY_CHECK)) {
5111 				*cs->statusp = resp->status = NFS4ERR_ACCESS;
5112 				goto out;
5113 			}
5114 		}
5115 	}
5116 
5117 	*cs->statusp = resp->status =
5118 	    do_rfs4_op_setattr(&resp->attrsset, &args->obj_attributes, cs,
5119 	    &args->stateid);
5120 
5121 out:
5122 	DTRACE_NFSV4_2(op__setattr__done, struct compound_state *, cs,
5123 	    SETATTR4res *, resp);
5124 }
5125 
5126 /* ARGSUSED */
5127 static void
5128 rfs4_op_verify(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
5129 	struct compound_state *cs)
5130 {
5131 	/*
5132 	 * verify and nverify are exactly the same, except that nverify
5133 	 * succeeds when some argument changed, and verify succeeds when
5134 	 * when none changed.
5135 	 */
5136 
5137 	VERIFY4args  *args = &argop->nfs_argop4_u.opverify;
5138 	VERIFY4res *resp = &resop->nfs_resop4_u.opverify;
5139 
5140 	int error;
5141 	struct nfs4_svgetit_arg sarg;
5142 	struct statvfs64 sb;
5143 	struct nfs4_ntov_table ntov;
5144 
5145 	DTRACE_NFSV4_2(op__verify__start, struct compound_state *, cs,
5146 	    VERIFY4args *, args);
5147 
5148 	if (cs->vp == NULL) {
5149 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
5150 		goto out;
5151 	}
5152 
5153 	sarg.sbp = &sb;
5154 	nfs4_ntov_table_init(&ntov);
5155 	resp->status = do_rfs4_set_attrs(NULL, &args->obj_attributes, cs,
5156 	    &sarg, &ntov, NFS4ATTR_VERIT);
5157 	if (resp->status != NFS4_OK) {
5158 		/*
5159 		 * do_rfs4_set_attrs will try to verify systemwide attrs,
5160 		 * so could return -1 for "no match".
5161 		 */
5162 		if (resp->status == -1)
5163 			resp->status = NFS4ERR_NOT_SAME;
5164 		goto done;
5165 	}
5166 	error = rfs4_verify_attr(&sarg, NULL, &ntov);
5167 	switch (error) {
5168 	case 0:
5169 		resp->status = NFS4_OK;
5170 		break;
5171 	case -1:
5172 		resp->status = NFS4ERR_NOT_SAME;
5173 		break;
5174 	default:
5175 		resp->status = puterrno4(error);
5176 		break;
5177 	}
5178 done:
5179 	*cs->statusp = resp->status;
5180 	nfs4_ntov_table_free(&ntov, &sarg);
5181 out:
5182 	DTRACE_NFSV4_2(op__verify__done, struct compound_state *, cs,
5183 	    VERIFY4res *, resp);
5184 }
5185 
5186 /* ARGSUSED */
5187 static void
5188 rfs4_op_nverify(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
5189 	struct compound_state *cs)
5190 {
5191 	/*
5192 	 * verify and nverify are exactly the same, except that nverify
5193 	 * succeeds when some argument changed, and verify succeeds when
5194 	 * when none changed.
5195 	 */
5196 
5197 	NVERIFY4args  *args = &argop->nfs_argop4_u.opnverify;
5198 	NVERIFY4res *resp = &resop->nfs_resop4_u.opnverify;
5199 
5200 	int error;
5201 	struct nfs4_svgetit_arg sarg;
5202 	struct statvfs64 sb;
5203 	struct nfs4_ntov_table ntov;
5204 
5205 	DTRACE_NFSV4_2(op__nverify__start, struct compound_state *, cs,
5206 	    NVERIFY4args *, args);
5207 
5208 	if (cs->vp == NULL) {
5209 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
5210 		DTRACE_NFSV4_2(op__nverify__done, struct compound_state *, cs,
5211 		    NVERIFY4res *, resp);
5212 		return;
5213 	}
5214 	sarg.sbp = &sb;
5215 	nfs4_ntov_table_init(&ntov);
5216 	resp->status = do_rfs4_set_attrs(NULL, &args->obj_attributes, cs,
5217 	    &sarg, &ntov, NFS4ATTR_VERIT);
5218 	if (resp->status != NFS4_OK) {
5219 		/*
5220 		 * do_rfs4_set_attrs will try to verify systemwide attrs,
5221 		 * so could return -1 for "no match".
5222 		 */
5223 		if (resp->status == -1)
5224 			resp->status = NFS4_OK;
5225 		goto done;
5226 	}
5227 	error = rfs4_verify_attr(&sarg, NULL, &ntov);
5228 	switch (error) {
5229 	case 0:
5230 		resp->status = NFS4ERR_SAME;
5231 		break;
5232 	case -1:
5233 		resp->status = NFS4_OK;
5234 		break;
5235 	default:
5236 		resp->status = puterrno4(error);
5237 		break;
5238 	}
5239 done:
5240 	*cs->statusp = resp->status;
5241 	nfs4_ntov_table_free(&ntov, &sarg);
5242 
5243 	DTRACE_NFSV4_2(op__nverify__done, struct compound_state *, cs,
5244 	    NVERIFY4res *, resp);
5245 }
5246 
5247 /*
5248  * XXX - This should live in an NFS header file.
5249  */
5250 #define	MAX_IOVECS	12
5251 
5252 /* ARGSUSED */
5253 static void
5254 rfs4_op_write(nfs_argop4 *argop, nfs_resop4 *resop, struct svc_req *req,
5255 	struct compound_state *cs)
5256 {
5257 	WRITE4args *args = &argop->nfs_argop4_u.opwrite;
5258 	WRITE4res *resp = &resop->nfs_resop4_u.opwrite;
5259 	int error;
5260 	vnode_t *vp;
5261 	struct vattr bva;
5262 	u_offset_t rlimit;
5263 	struct uio uio;
5264 	struct iovec iov[MAX_IOVECS];
5265 	struct iovec *iovp;
5266 	int iovcnt;
5267 	int ioflag;
5268 	cred_t *savecred, *cr;
5269 	bool_t *deleg = &cs->deleg;
5270 	nfsstat4 stat;
5271 	int in_crit = 0;
5272 	caller_context_t ct;
5273 
5274 	DTRACE_NFSV4_2(op__write__start, struct compound_state *, cs,
5275 	    WRITE4args *, args);
5276 
5277 	vp = cs->vp;
5278 	if (vp == NULL) {
5279 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
5280 		goto out;
5281 	}
5282 	if (cs->access == CS_ACCESS_DENIED) {
5283 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
5284 		goto out;
5285 	}
5286 
5287 	cr = cs->cr;
5288 
5289 	if ((stat = rfs4_check_stateid(FWRITE, vp, &args->stateid, FALSE,
5290 	    deleg, TRUE, &ct)) != NFS4_OK) {
5291 		*cs->statusp = resp->status = stat;
5292 		goto out;
5293 	}
5294 
5295 	/*
5296 	 * We have to enter the critical region before calling VOP_RWLOCK
5297 	 * to avoid a deadlock with ufs.
5298 	 */
5299 	if (nbl_need_check(vp)) {
5300 		nbl_start_crit(vp, RW_READER);
5301 		in_crit = 1;
5302 		if (nbl_conflict(vp, NBL_WRITE,
5303 		    args->offset, args->data_len, 0, &ct)) {
5304 			*cs->statusp = resp->status = NFS4ERR_LOCKED;
5305 			goto out;
5306 		}
5307 	}
5308 
5309 	bva.va_mask = AT_MODE | AT_UID;
5310 	error = VOP_GETATTR(vp, &bva, 0, cr, &ct);
5311 
5312 	/*
5313 	 * If we can't get the attributes, then we can't do the
5314 	 * right access checking.  So, we'll fail the request.
5315 	 */
5316 	if (error) {
5317 		*cs->statusp = resp->status = puterrno4(error);
5318 		goto out;
5319 	}
5320 
5321 	if (rdonly4(cs->exi, cs->vp, req)) {
5322 		*cs->statusp = resp->status = NFS4ERR_ROFS;
5323 		goto out;
5324 	}
5325 
5326 	if (vp->v_type != VREG) {
5327 		*cs->statusp = resp->status =
5328 		    ((vp->v_type == VDIR) ? NFS4ERR_ISDIR : NFS4ERR_INVAL);
5329 		goto out;
5330 	}
5331 
5332 	if (crgetuid(cr) != bva.va_uid &&
5333 	    (error = VOP_ACCESS(vp, VWRITE, 0, cr, &ct))) {
5334 		*cs->statusp = resp->status = puterrno4(error);
5335 		goto out;
5336 	}
5337 
5338 	if (MANDLOCK(vp, bva.va_mode)) {
5339 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
5340 		goto out;
5341 	}
5342 
5343 	if (args->data_len == 0) {
5344 		*cs->statusp = resp->status = NFS4_OK;
5345 		resp->count = 0;
5346 		resp->committed = args->stable;
5347 		resp->writeverf = Write4verf;
5348 		goto out;
5349 	}
5350 
5351 	if (args->mblk != NULL) {
5352 		mblk_t *m;
5353 		uint_t bytes, round_len;
5354 
5355 		iovcnt = 0;
5356 		bytes = 0;
5357 		round_len = roundup(args->data_len, BYTES_PER_XDR_UNIT);
5358 		for (m = args->mblk;
5359 		    m != NULL && bytes < round_len;
5360 		    m = m->b_cont) {
5361 			iovcnt++;
5362 			bytes += MBLKL(m);
5363 		}
5364 #ifdef DEBUG
5365 		/* should have ended on an mblk boundary */
5366 		if (bytes != round_len) {
5367 			printf("bytes=0x%x, round_len=0x%x, req len=0x%x\n",
5368 			    bytes, round_len, args->data_len);
5369 			printf("args=%p, args->mblk=%p, m=%p", (void *)args,
5370 			    (void *)args->mblk, (void *)m);
5371 			ASSERT(bytes == round_len);
5372 		}
5373 #endif
5374 		if (iovcnt <= MAX_IOVECS) {
5375 			iovp = iov;
5376 		} else {
5377 			iovp = kmem_alloc(sizeof (*iovp) * iovcnt, KM_SLEEP);
5378 		}
5379 		mblk_to_iov(args->mblk, iovcnt, iovp);
5380 	} else {
5381 		iovcnt = 1;
5382 		iovp = iov;
5383 		iovp->iov_base = args->data_val;
5384 		iovp->iov_len = args->data_len;
5385 	}
5386 
5387 	uio.uio_iov = iovp;
5388 	uio.uio_iovcnt = iovcnt;
5389 
5390 	uio.uio_segflg = UIO_SYSSPACE;
5391 	uio.uio_extflg = UIO_COPY_DEFAULT;
5392 	uio.uio_loffset = args->offset;
5393 	uio.uio_resid = args->data_len;
5394 	uio.uio_llimit = curproc->p_fsz_ctl;
5395 	rlimit = uio.uio_llimit - args->offset;
5396 	if (rlimit < (u_offset_t)uio.uio_resid)
5397 		uio.uio_resid = (int)rlimit;
5398 
5399 	if (args->stable == UNSTABLE4)
5400 		ioflag = 0;
5401 	else if (args->stable == FILE_SYNC4)
5402 		ioflag = FSYNC;
5403 	else if (args->stable == DATA_SYNC4)
5404 		ioflag = FDSYNC;
5405 	else {
5406 		if (iovp != iov)
5407 			kmem_free(iovp, sizeof (*iovp) * iovcnt);
5408 		*cs->statusp = resp->status = NFS4ERR_INVAL;
5409 		goto out;
5410 	}
5411 
5412 	/*
5413 	 * We're changing creds because VM may fault and we need
5414 	 * the cred of the current thread to be used if quota
5415 	 * checking is enabled.
5416 	 */
5417 	savecred = curthread->t_cred;
5418 	curthread->t_cred = cr;
5419 	error = do_io(FWRITE, vp, &uio, ioflag, cr, &ct);
5420 	curthread->t_cred = savecred;
5421 
5422 	if (iovp != iov)
5423 		kmem_free(iovp, sizeof (*iovp) * iovcnt);
5424 
5425 	if (error) {
5426 		*cs->statusp = resp->status = puterrno4(error);
5427 		goto out;
5428 	}
5429 
5430 	*cs->statusp = resp->status = NFS4_OK;
5431 	resp->count = args->data_len - uio.uio_resid;
5432 
5433 	if (ioflag == 0)
5434 		resp->committed = UNSTABLE4;
5435 	else
5436 		resp->committed = FILE_SYNC4;
5437 
5438 	resp->writeverf = Write4verf;
5439 
5440 out:
5441 	if (in_crit)
5442 		nbl_end_crit(vp);
5443 
5444 	DTRACE_NFSV4_2(op__write__done, struct compound_state *, cs,
5445 	    WRITE4res *, resp);
5446 }
5447 
5448 
5449 /* XXX put in a header file */
5450 extern int	sec_svc_getcred(struct svc_req *, cred_t *,  caddr_t *, int *);
5451 
5452 void
5453 rfs4_compound(COMPOUND4args *args, COMPOUND4res *resp, struct exportinfo *exi,
5454 	struct svc_req *req, cred_t *cr)
5455 {
5456 	uint_t i;
5457 	struct compound_state cs;
5458 
5459 	rfs4_init_compound_state(&cs);
5460 	/*
5461 	 * Form a reply tag by copying over the reqeuest tag.
5462 	 */
5463 	resp->tag.utf8string_val =
5464 	    kmem_alloc(args->tag.utf8string_len, KM_SLEEP);
5465 	resp->tag.utf8string_len = args->tag.utf8string_len;
5466 	bcopy(args->tag.utf8string_val, resp->tag.utf8string_val,
5467 	    resp->tag.utf8string_len);
5468 
5469 	cs.statusp = &resp->status;
5470 	cs.req = req;
5471 
5472 	/*
5473 	 * XXX for now, minorversion should be zero
5474 	 */
5475 	if (args->minorversion != NFS4_MINORVERSION) {
5476 		DTRACE_NFSV4_2(compound__start, struct compound_state *,
5477 		    &cs, COMPOUND4args *, args);
5478 		resp->array_len = 0;
5479 		resp->array = NULL;
5480 		resp->status = NFS4ERR_MINOR_VERS_MISMATCH;
5481 		DTRACE_NFSV4_2(compound__done, struct compound_state *,
5482 		    &cs, COMPOUND4res *, resp);
5483 		resp->array_len = 0;
5484 		return;
5485 	}
5486 
5487 	resp->array_len = args->array_len;
5488 	resp->array = kmem_zalloc(args->array_len * sizeof (nfs_resop4),
5489 	    KM_SLEEP);
5490 
5491 	ASSERT(exi == NULL);
5492 	ASSERT(cr == NULL);
5493 
5494 	cr = crget();
5495 	ASSERT(cr != NULL);
5496 
5497 	if (sec_svc_getcred(req, cr, &cs.principal, &cs.nfsflavor) == 0) {
5498 		DTRACE_NFSV4_2(compound__start, struct compound_state *,
5499 		    &cs, COMPOUND4args *, args);
5500 		crfree(cr);
5501 		DTRACE_NFSV4_2(compound__done, struct compound_state *,
5502 		    &cs, COMPOUND4res *, resp);
5503 		return;
5504 	}
5505 
5506 	cs.basecr = cr;
5507 
5508 	DTRACE_NFSV4_2(compound__start, struct compound_state *, &cs,
5509 	    COMPOUND4args *, args);
5510 
5511 	/*
5512 	 * For now, NFS4 compound processing must be protected by
5513 	 * exported_lock because it can access more than one exportinfo
5514 	 * per compound and share/unshare can now change multiple
5515 	 * exinfo structs.  The NFS2/3 code only refs 1 exportinfo
5516 	 * per proc (excluding public exinfo), and exi_count design
5517 	 * is sufficient to protect concurrent execution of NFS2/3
5518 	 * ops along with unexport.  This lock will be removed as
5519 	 * part of the NFSv4 phase 2 namespace redesign work.
5520 	 */
5521 	rw_enter(&exported_lock, RW_READER);
5522 
5523 	/*
5524 	 * If this is the first compound we've seen, we need to start all
5525 	 * new instances' grace periods.
5526 	 */
5527 	if (rfs4_seen_first_compound == 0) {
5528 		rfs4_grace_start_new();
5529 		/*
5530 		 * This must be set after rfs4_grace_start_new(), otherwise
5531 		 * another thread could proceed past here before the former
5532 		 * is finished.
5533 		 */
5534 		rfs4_seen_first_compound = 1;
5535 	}
5536 
5537 	for (i = 0; i < args->array_len && cs.cont; i++) {
5538 		nfs_argop4 *argop;
5539 		nfs_resop4 *resop;
5540 		uint_t op;
5541 
5542 		argop = &args->array[i];
5543 		resop = &resp->array[i];
5544 		resop->resop = argop->argop;
5545 		op = (uint_t)resop->resop;
5546 
5547 		if (op < rfsv4disp_cnt) {
5548 			/*
5549 			 * Count the individual ops here; NULL and COMPOUND
5550 			 * are counted in common_dispatch()
5551 			 */
5552 			rfsproccnt_v4_ptr[op].value.ui64++;
5553 
5554 			NFS4_DEBUG(rfs4_debug > 1,
5555 			    (CE_NOTE, "Executing %s", rfs4_op_string[op]));
5556 			(*rfsv4disptab[op].dis_proc)(argop, resop, req, &cs);
5557 			NFS4_DEBUG(rfs4_debug > 1, (CE_NOTE, "%s returned %d",
5558 			    rfs4_op_string[op], *cs.statusp));
5559 			if (*cs.statusp != NFS4_OK)
5560 				cs.cont = FALSE;
5561 		} else {
5562 			/*
5563 			 * This is effectively dead code since XDR code
5564 			 * will have already returned BADXDR if op doesn't
5565 			 * decode to legal value.  This only done for a
5566 			 * day when XDR code doesn't verify v4 opcodes.
5567 			 */
5568 			op = OP_ILLEGAL;
5569 			rfsproccnt_v4_ptr[OP_ILLEGAL_IDX].value.ui64++;
5570 
5571 			rfs4_op_illegal(argop, resop, req, &cs);
5572 			cs.cont = FALSE;
5573 		}
5574 
5575 		/*
5576 		 * If not at last op, and if we are to stop, then
5577 		 * compact the results array.
5578 		 */
5579 		if ((i + 1) < args->array_len && !cs.cont) {
5580 			nfs_resop4 *new_res = kmem_alloc(
5581 			    (i+1) * sizeof (nfs_resop4), KM_SLEEP);
5582 			bcopy(resp->array,
5583 			    new_res, (i+1) * sizeof (nfs_resop4));
5584 			kmem_free(resp->array,
5585 			    args->array_len * sizeof (nfs_resop4));
5586 
5587 			resp->array_len =  i + 1;
5588 			resp->array = new_res;
5589 		}
5590 	}
5591 
5592 	rw_exit(&exported_lock);
5593 
5594 	DTRACE_NFSV4_2(compound__done, struct compound_state *, &cs,
5595 	    COMPOUND4res *, resp);
5596 
5597 	if (cs.vp)
5598 		VN_RELE(cs.vp);
5599 	if (cs.saved_vp)
5600 		VN_RELE(cs.saved_vp);
5601 	if (cs.saved_fh.nfs_fh4_val)
5602 		kmem_free(cs.saved_fh.nfs_fh4_val, NFS4_FHSIZE);
5603 
5604 	if (cs.basecr)
5605 		crfree(cs.basecr);
5606 	if (cs.cr)
5607 		crfree(cs.cr);
5608 	/*
5609 	 * done with this compound request, free the label
5610 	 */
5611 
5612 	if (req->rq_label != NULL) {
5613 		kmem_free(req->rq_label, sizeof (bslabel_t));
5614 		req->rq_label = NULL;
5615 	}
5616 }
5617 
5618 /*
5619  * XXX because of what appears to be duplicate calls to rfs4_compound_free
5620  * XXX zero out the tag and array values. Need to investigate why the
5621  * XXX calls occur, but at least prevent the panic for now.
5622  */
5623 void
5624 rfs4_compound_free(COMPOUND4res *resp)
5625 {
5626 	uint_t i;
5627 
5628 	if (resp->tag.utf8string_val) {
5629 		UTF8STRING_FREE(resp->tag)
5630 	}
5631 
5632 	for (i = 0; i < resp->array_len; i++) {
5633 		nfs_resop4 *resop;
5634 		uint_t op;
5635 
5636 		resop = &resp->array[i];
5637 		op = (uint_t)resop->resop;
5638 		if (op < rfsv4disp_cnt) {
5639 			(*rfsv4disptab[op].dis_resfree)(resop);
5640 		}
5641 	}
5642 	if (resp->array != NULL) {
5643 		kmem_free(resp->array, resp->array_len * sizeof (nfs_resop4));
5644 	}
5645 }
5646 
5647 /*
5648  * Process the value of the compound request rpc flags, as a bit-AND
5649  * of the individual per-op flags (idempotent, allowork, publicfh_ok)
5650  */
5651 void
5652 rfs4_compound_flagproc(COMPOUND4args *args, int *flagp)
5653 {
5654 	int i;
5655 	int flag = RPC_ALL;
5656 
5657 	for (i = 0; flag && i < args->array_len; i++) {
5658 		uint_t op;
5659 
5660 		op = (uint_t)args->array[i].argop;
5661 
5662 		if (op < rfsv4disp_cnt)
5663 			flag &= rfsv4disptab[op].dis_flags;
5664 		else
5665 			flag = 0;
5666 	}
5667 	*flagp = flag;
5668 }
5669 
5670 nfsstat4
5671 rfs4_client_sysid(rfs4_client_t *cp, sysid_t *sp)
5672 {
5673 	nfsstat4 e;
5674 
5675 	rfs4_dbe_lock(cp->dbe);
5676 
5677 	if (cp->sysidt != LM_NOSYSID) {
5678 		*sp = cp->sysidt;
5679 		e = NFS4_OK;
5680 
5681 	} else if ((cp->sysidt = lm_alloc_sysidt()) != LM_NOSYSID) {
5682 		*sp = cp->sysidt;
5683 		e = NFS4_OK;
5684 
5685 		NFS4_DEBUG(rfs4_debug, (CE_NOTE,
5686 		    "rfs4_client_sysid: allocated 0x%x\n", *sp));
5687 	} else
5688 		e = NFS4ERR_DELAY;
5689 
5690 	rfs4_dbe_unlock(cp->dbe);
5691 	return (e);
5692 }
5693 
5694 #if defined(DEBUG) && ! defined(lint)
5695 static void lock_print(char *str, int operation, struct flock64 *flk)
5696 {
5697 	char *op, *type;
5698 
5699 	switch (operation) {
5700 	case F_GETLK: op = "F_GETLK";
5701 		break;
5702 	case F_SETLK: op = "F_SETLK";
5703 		break;
5704 	case F_SETLK_NBMAND: op = "F_SETLK_NBMAND";
5705 		break;
5706 	default: op = "F_UNKNOWN";
5707 		break;
5708 	}
5709 	switch (flk->l_type) {
5710 	case F_UNLCK: type = "F_UNLCK";
5711 		break;
5712 	case F_RDLCK: type = "F_RDLCK";
5713 		break;
5714 	case F_WRLCK: type = "F_WRLCK";
5715 		break;
5716 	default: type = "F_UNKNOWN";
5717 		break;
5718 	}
5719 
5720 	ASSERT(flk->l_whence == 0);
5721 	cmn_err(CE_NOTE, "%s:  %s, type = %s, off = %llx len = %llx pid = %d",
5722 	    str, op, type, (longlong_t)flk->l_start,
5723 	    flk->l_len ? (longlong_t)flk->l_len : ~0LL, flk->l_pid);
5724 }
5725 
5726 #define	LOCK_PRINT(d, s, t, f) if (d) lock_print(s, t, f)
5727 #else
5728 #define	LOCK_PRINT(d, s, t, f)
5729 #endif
5730 
5731 /*ARGSUSED*/
5732 static bool_t
5733 creds_ok(cred_set_t cr_set, struct svc_req *req, struct compound_state *cs)
5734 {
5735 	return (TRUE);
5736 }
5737 
5738 /*
5739  * Look up the pathname using the vp in cs as the directory vnode.
5740  * cs->vp will be the vnode for the file on success
5741  */
5742 
5743 static nfsstat4
5744 rfs4_lookup(component4 *component, struct svc_req *req,
5745 	    struct compound_state *cs)
5746 {
5747 	char *nm;
5748 	uint32_t len;
5749 	nfsstat4 status;
5750 
5751 	if (cs->vp == NULL) {
5752 		return (NFS4ERR_NOFILEHANDLE);
5753 	}
5754 	if (cs->vp->v_type != VDIR) {
5755 		return (NFS4ERR_NOTDIR);
5756 	}
5757 
5758 	if (!utf8_dir_verify(component))
5759 		return (NFS4ERR_INVAL);
5760 
5761 	nm = utf8_to_fn(component, &len, NULL);
5762 	if (nm == NULL) {
5763 		return (NFS4ERR_INVAL);
5764 	}
5765 
5766 	if (len > MAXNAMELEN) {
5767 		kmem_free(nm, len);
5768 		return (NFS4ERR_NAMETOOLONG);
5769 	}
5770 
5771 	status = do_rfs4_op_lookup(nm, len, req, cs);
5772 
5773 	kmem_free(nm, len);
5774 
5775 	return (status);
5776 }
5777 
5778 static nfsstat4
5779 rfs4_lookupfile(component4 *component, struct svc_req *req,
5780 		struct compound_state *cs, uint32_t access,
5781 		change_info4 *cinfo)
5782 {
5783 	nfsstat4 status;
5784 	vnode_t *dvp = cs->vp;
5785 	vattr_t bva, ava, fva;
5786 	int error;
5787 
5788 	/* Get "before" change value */
5789 	bva.va_mask = AT_CTIME|AT_SEQ;
5790 	error = VOP_GETATTR(dvp, &bva, 0, cs->cr, NULL);
5791 	if (error)
5792 		return (puterrno4(error));
5793 
5794 	/* rfs4_lookup may VN_RELE directory */
5795 	VN_HOLD(dvp);
5796 
5797 	status = rfs4_lookup(component, req, cs);
5798 	if (status != NFS4_OK) {
5799 		VN_RELE(dvp);
5800 		return (status);
5801 	}
5802 
5803 	/*
5804 	 * Get "after" change value, if it fails, simply return the
5805 	 * before value.
5806 	 */
5807 	ava.va_mask = AT_CTIME|AT_SEQ;
5808 	if (VOP_GETATTR(dvp, &ava, 0, cs->cr, NULL)) {
5809 		ava.va_ctime = bva.va_ctime;
5810 		ava.va_seq = 0;
5811 	}
5812 	VN_RELE(dvp);
5813 
5814 	/*
5815 	 * Validate the file is a file
5816 	 */
5817 	fva.va_mask = AT_TYPE|AT_MODE;
5818 	error = VOP_GETATTR(cs->vp, &fva, 0, cs->cr, NULL);
5819 	if (error)
5820 		return (puterrno4(error));
5821 
5822 	if (fva.va_type != VREG) {
5823 		if (fva.va_type == VDIR)
5824 			return (NFS4ERR_ISDIR);
5825 		if (fva.va_type == VLNK)
5826 			return (NFS4ERR_SYMLINK);
5827 		return (NFS4ERR_INVAL);
5828 	}
5829 
5830 	NFS4_SET_FATTR4_CHANGE(cinfo->before, bva.va_ctime);
5831 	NFS4_SET_FATTR4_CHANGE(cinfo->after, ava.va_ctime);
5832 
5833 	/*
5834 	 * It is undefined if VOP_LOOKUP will change va_seq, so
5835 	 * cinfo.atomic = TRUE only if we have
5836 	 * non-zero va_seq's, and they have not changed.
5837 	 */
5838 	if (bva.va_seq && ava.va_seq && ava.va_seq == bva.va_seq)
5839 		cinfo->atomic = TRUE;
5840 	else
5841 		cinfo->atomic = FALSE;
5842 
5843 	/* Check for mandatory locking */
5844 	cs->mandlock = MANDLOCK(cs->vp, fva.va_mode);
5845 	return (check_open_access(access, cs, req));
5846 }
5847 
5848 static nfsstat4
5849 create_vnode(vnode_t *dvp, char *nm,  vattr_t *vap, createmode4 mode,
5850 	    timespec32_t *mtime, cred_t *cr, vnode_t **vpp, bool_t *created)
5851 {
5852 	int error;
5853 	nfsstat4 status = NFS4_OK;
5854 	vattr_t va;
5855 
5856 tryagain:
5857 
5858 	/*
5859 	 * The file open mode used is VWRITE.  If the client needs
5860 	 * some other semantic, then it should do the access checking
5861 	 * itself.  It would have been nice to have the file open mode
5862 	 * passed as part of the arguments.
5863 	 */
5864 
5865 	*created = TRUE;
5866 	error = VOP_CREATE(dvp, nm, vap, EXCL, VWRITE, vpp, cr, 0, NULL, NULL);
5867 
5868 	if (error) {
5869 		*created = FALSE;
5870 
5871 		/*
5872 		 * If we got something other than file already exists
5873 		 * then just return this error.  Otherwise, we got
5874 		 * EEXIST.  If we were doing a GUARDED create, then
5875 		 * just return this error.  Otherwise, we need to
5876 		 * make sure that this wasn't a duplicate of an
5877 		 * exclusive create request.
5878 		 *
5879 		 * The assumption is made that a non-exclusive create
5880 		 * request will never return EEXIST.
5881 		 */
5882 
5883 		if (error != EEXIST || mode == GUARDED4) {
5884 			status = puterrno4(error);
5885 			return (status);
5886 		}
5887 		error = VOP_LOOKUP(dvp, nm, vpp, NULL, 0, NULL, cr,
5888 		    NULL, NULL, NULL);
5889 
5890 		if (error) {
5891 			/*
5892 			 * We couldn't find the file that we thought that
5893 			 * we just created.  So, we'll just try creating
5894 			 * it again.
5895 			 */
5896 			if (error == ENOENT)
5897 				goto tryagain;
5898 
5899 			status = puterrno4(error);
5900 			return (status);
5901 		}
5902 
5903 		if (mode == UNCHECKED4) {
5904 			/* existing object must be regular file */
5905 			if ((*vpp)->v_type != VREG) {
5906 				if ((*vpp)->v_type == VDIR)
5907 					status = NFS4ERR_ISDIR;
5908 				else if ((*vpp)->v_type == VLNK)
5909 					status = NFS4ERR_SYMLINK;
5910 				else
5911 					status = NFS4ERR_INVAL;
5912 				VN_RELE(*vpp);
5913 				return (status);
5914 			}
5915 
5916 			return (NFS4_OK);
5917 		}
5918 
5919 		/* Check for duplicate request */
5920 		ASSERT(mtime != 0);
5921 		va.va_mask = AT_MTIME;
5922 		error = VOP_GETATTR(*vpp, &va, 0, cr, NULL);
5923 		if (!error) {
5924 			/* We found the file */
5925 			if (va.va_mtime.tv_sec != mtime->tv_sec ||
5926 			    va.va_mtime.tv_nsec != mtime->tv_nsec) {
5927 				/* but its not our creation */
5928 				VN_RELE(*vpp);
5929 				return (NFS4ERR_EXIST);
5930 			}
5931 			*created = TRUE; /* retrans of create == created */
5932 			return (NFS4_OK);
5933 		}
5934 		VN_RELE(*vpp);
5935 		return (NFS4ERR_EXIST);
5936 	}
5937 
5938 	return (NFS4_OK);
5939 }
5940 
5941 static nfsstat4
5942 check_open_access(uint32_t access,
5943 		struct compound_state *cs, struct svc_req *req)
5944 {
5945 	int error;
5946 	vnode_t *vp;
5947 	bool_t readonly;
5948 	cred_t *cr = cs->cr;
5949 
5950 	/* For now we don't allow mandatory locking as per V2/V3 */
5951 	if (cs->access == CS_ACCESS_DENIED || cs->mandlock) {
5952 		return (NFS4ERR_ACCESS);
5953 	}
5954 
5955 	vp = cs->vp;
5956 	ASSERT(cr != NULL && vp->v_type == VREG);
5957 
5958 	/*
5959 	 * If the file system is exported read only and we are trying
5960 	 * to open for write, then return NFS4ERR_ROFS
5961 	 */
5962 
5963 	readonly = rdonly4(cs->exi, cs->vp, req);
5964 
5965 	if ((access & OPEN4_SHARE_ACCESS_WRITE) && readonly)
5966 		return (NFS4ERR_ROFS);
5967 
5968 	if (access & OPEN4_SHARE_ACCESS_READ) {
5969 		if ((VOP_ACCESS(vp, VREAD, 0, cr, NULL) != 0) &&
5970 		    (VOP_ACCESS(vp, VEXEC, 0, cr, NULL) != 0)) {
5971 			return (NFS4ERR_ACCESS);
5972 		}
5973 	}
5974 
5975 	if (access & OPEN4_SHARE_ACCESS_WRITE) {
5976 		error = VOP_ACCESS(vp, VWRITE, 0, cr, NULL);
5977 		if (error)
5978 			return (NFS4ERR_ACCESS);
5979 	}
5980 
5981 	return (NFS4_OK);
5982 }
5983 
5984 static nfsstat4
5985 rfs4_createfile(OPEN4args *args, struct svc_req *req, struct compound_state *cs,
5986 		change_info4 *cinfo, bitmap4 *attrset, clientid4 clientid)
5987 {
5988 	struct nfs4_svgetit_arg sarg;
5989 	struct nfs4_ntov_table ntov;
5990 
5991 	bool_t ntov_table_init = FALSE;
5992 	struct statvfs64 sb;
5993 	nfsstat4 status;
5994 	vnode_t *vp;
5995 	vattr_t bva, ava, iva, cva, *vap;
5996 	vnode_t *dvp;
5997 	timespec32_t *mtime;
5998 	char *nm = NULL;
5999 	uint_t buflen;
6000 	bool_t created;
6001 	bool_t setsize = FALSE;
6002 	len_t reqsize;
6003 	int error;
6004 	bool_t trunc;
6005 	caller_context_t ct;
6006 	component4 *component;
6007 	bslabel_t *clabel;
6008 
6009 	sarg.sbp = &sb;
6010 
6011 	dvp = cs->vp;
6012 
6013 	/* Check if the file system is read only */
6014 	if (rdonly4(cs->exi, dvp, req))
6015 		return (NFS4ERR_ROFS);
6016 
6017 	/* check the label of including directory */
6018 	if (is_system_labeled()) {
6019 		ASSERT(req->rq_label != NULL);
6020 		clabel = req->rq_label;
6021 		DTRACE_PROBE2(tx__rfs4__log__info__opremove__clabel, char *,
6022 		    "got client label from request(1)",
6023 		    struct svc_req *, req);
6024 		if (!blequal(&l_admin_low->tsl_label, clabel)) {
6025 			if (!do_rfs_label_check(clabel, dvp, EQUALITY_CHECK)) {
6026 				return (NFS4ERR_ACCESS);
6027 			}
6028 		}
6029 	}
6030 
6031 	/*
6032 	 * Get the last component of path name in nm. cs will reference
6033 	 * the including directory on success.
6034 	 */
6035 	component = &args->open_claim4_u.file;
6036 	if (!utf8_dir_verify(component))
6037 		return (NFS4ERR_INVAL);
6038 
6039 	nm = utf8_to_fn(component, &buflen, NULL);
6040 
6041 	if (nm == NULL)
6042 		return (NFS4ERR_RESOURCE);
6043 
6044 	if (buflen > MAXNAMELEN) {
6045 		kmem_free(nm, buflen);
6046 		return (NFS4ERR_NAMETOOLONG);
6047 	}
6048 
6049 	bva.va_mask = AT_TYPE|AT_CTIME|AT_SEQ;
6050 	error = VOP_GETATTR(dvp, &bva, 0, cs->cr, NULL);
6051 	if (error) {
6052 		kmem_free(nm, buflen);
6053 		return (puterrno4(error));
6054 	}
6055 
6056 	if (bva.va_type != VDIR) {
6057 		kmem_free(nm, buflen);
6058 		return (NFS4ERR_NOTDIR);
6059 	}
6060 
6061 	NFS4_SET_FATTR4_CHANGE(cinfo->before, bva.va_ctime)
6062 
6063 	switch (args->mode) {
6064 	case GUARDED4:
6065 		/*FALLTHROUGH*/
6066 	case UNCHECKED4:
6067 		nfs4_ntov_table_init(&ntov);
6068 		ntov_table_init = TRUE;
6069 
6070 		*attrset = 0;
6071 		status = do_rfs4_set_attrs(attrset,
6072 		    &args->createhow4_u.createattrs,
6073 		    cs, &sarg, &ntov, NFS4ATTR_SETIT);
6074 
6075 		if (status == NFS4_OK && (sarg.vap->va_mask & AT_TYPE) &&
6076 		    sarg.vap->va_type != VREG) {
6077 			if (sarg.vap->va_type == VDIR)
6078 				status = NFS4ERR_ISDIR;
6079 			else if (sarg.vap->va_type == VLNK)
6080 				status = NFS4ERR_SYMLINK;
6081 			else
6082 				status = NFS4ERR_INVAL;
6083 		}
6084 
6085 		if (status != NFS4_OK) {
6086 			kmem_free(nm, buflen);
6087 			nfs4_ntov_table_free(&ntov, &sarg);
6088 			*attrset = 0;
6089 			return (status);
6090 		}
6091 
6092 		vap = sarg.vap;
6093 		vap->va_type = VREG;
6094 		vap->va_mask |= AT_TYPE;
6095 
6096 		if ((vap->va_mask & AT_MODE) == 0) {
6097 			vap->va_mask |= AT_MODE;
6098 			vap->va_mode = (mode_t)0600;
6099 		}
6100 
6101 		if (vap->va_mask & AT_SIZE) {
6102 
6103 			/* Disallow create with a non-zero size */
6104 
6105 			if ((reqsize = sarg.vap->va_size) != 0) {
6106 				kmem_free(nm, buflen);
6107 				nfs4_ntov_table_free(&ntov, &sarg);
6108 				*attrset = 0;
6109 				return (NFS4ERR_INVAL);
6110 			}
6111 			setsize = TRUE;
6112 		}
6113 		break;
6114 
6115 	case EXCLUSIVE4:
6116 		/* prohibit EXCL create of named attributes */
6117 		if (dvp->v_flag & V_XATTRDIR) {
6118 			kmem_free(nm, buflen);
6119 			*attrset = 0;
6120 			return (NFS4ERR_INVAL);
6121 		}
6122 
6123 		cva.va_mask = AT_TYPE | AT_MTIME | AT_MODE;
6124 		cva.va_type = VREG;
6125 		/*
6126 		 * Ensure no time overflows. Assumes underlying
6127 		 * filesystem supports at least 32 bits.
6128 		 * Truncate nsec to usec resolution to allow valid
6129 		 * compares even if the underlying filesystem truncates.
6130 		 */
6131 		mtime = (timespec32_t *)&args->createhow4_u.createverf;
6132 		cva.va_mtime.tv_sec = mtime->tv_sec % TIME32_MAX;
6133 		cva.va_mtime.tv_nsec = (mtime->tv_nsec / 1000) * 1000;
6134 		cva.va_mode = (mode_t)0;
6135 		vap = &cva;
6136 		break;
6137 	}
6138 
6139 	status = create_vnode(dvp, nm, vap, args->mode, mtime,
6140 	    cs->cr, &vp, &created);
6141 	kmem_free(nm, buflen);
6142 
6143 	if (status != NFS4_OK) {
6144 		if (ntov_table_init)
6145 			nfs4_ntov_table_free(&ntov, &sarg);
6146 		*attrset = 0;
6147 		return (status);
6148 	}
6149 
6150 	trunc = (setsize && !created);
6151 
6152 	if (args->mode != EXCLUSIVE4) {
6153 		bitmap4 createmask = args->createhow4_u.createattrs.attrmask;
6154 
6155 		/*
6156 		 * True verification that object was created with correct
6157 		 * attrs is impossible.  The attrs could have been changed
6158 		 * immediately after object creation.  If attributes did
6159 		 * not verify, the only recourse for the server is to
6160 		 * destroy the object.  Maybe if some attrs (like gid)
6161 		 * are set incorrectly, the object should be destroyed;
6162 		 * however, seems bad as a default policy.  Do we really
6163 		 * want to destroy an object over one of the times not
6164 		 * verifying correctly?  For these reasons, the server
6165 		 * currently sets bits in attrset for createattrs
6166 		 * that were set; however, no verification is done.
6167 		 *
6168 		 * vmask_to_nmask accounts for vattr bits set on create
6169 		 *	[do_rfs4_set_attrs() only sets resp bits for
6170 		 *	 non-vattr/vfs bits.]
6171 		 * Mask off any bits we set by default so as not to return
6172 		 * more attrset bits than were requested in createattrs
6173 		 */
6174 		if (created) {
6175 			nfs4_vmask_to_nmask(sarg.vap->va_mask, attrset);
6176 			*attrset &= createmask;
6177 		} else {
6178 			/*
6179 			 * We did not create the vnode (we tried but it
6180 			 * already existed).  In this case, the only createattr
6181 			 * that the spec allows the server to set is size,
6182 			 * and even then, it can only be set if it is 0.
6183 			 */
6184 			*attrset = 0;
6185 			if (trunc)
6186 				*attrset = FATTR4_SIZE_MASK;
6187 		}
6188 	}
6189 	if (ntov_table_init)
6190 		nfs4_ntov_table_free(&ntov, &sarg);
6191 
6192 	/*
6193 	 * Get the initial "after" sequence number, if it fails,
6194 	 * set to zero, time to before.
6195 	 */
6196 	iva.va_mask = AT_CTIME|AT_SEQ;
6197 	if (VOP_GETATTR(dvp, &iva, 0, cs->cr, NULL)) {
6198 		iva.va_seq = 0;
6199 		iva.va_ctime = bva.va_ctime;
6200 	}
6201 
6202 	/*
6203 	 * create_vnode attempts to create the file exclusive,
6204 	 * if it already exists the VOP_CREATE will fail and
6205 	 * may not increase va_seq. It is atomic if
6206 	 * we haven't changed the directory, but if it has changed
6207 	 * we don't know what changed it.
6208 	 */
6209 	if (!created) {
6210 		if (bva.va_seq && iva.va_seq &&
6211 		    bva.va_seq == iva.va_seq)
6212 			cinfo->atomic = TRUE;
6213 		else
6214 			cinfo->atomic = FALSE;
6215 		NFS4_SET_FATTR4_CHANGE(cinfo->after, iva.va_ctime);
6216 	} else {
6217 		/*
6218 		 * The entry was created, we need to sync the
6219 		 * directory metadata.
6220 		 */
6221 		(void) VOP_FSYNC(dvp, 0, cs->cr, NULL);
6222 
6223 		/*
6224 		 * Get "after" change value, if it fails, simply return the
6225 		 * before value.
6226 		 */
6227 		ava.va_mask = AT_CTIME|AT_SEQ;
6228 		if (VOP_GETATTR(dvp, &ava, 0, cs->cr, NULL)) {
6229 			ava.va_ctime = bva.va_ctime;
6230 			ava.va_seq = 0;
6231 		}
6232 
6233 		NFS4_SET_FATTR4_CHANGE(cinfo->after, ava.va_ctime);
6234 
6235 		/*
6236 		 * The cinfo->atomic = TRUE only if we have
6237 		 * non-zero va_seq's, and it has incremented by exactly one
6238 		 * during the create_vnode and it didn't
6239 		 * change during the VOP_FSYNC.
6240 		 */
6241 		if (bva.va_seq && iva.va_seq && ava.va_seq &&
6242 		    iva.va_seq == (bva.va_seq + 1) && iva.va_seq == ava.va_seq)
6243 			cinfo->atomic = TRUE;
6244 		else
6245 			cinfo->atomic = FALSE;
6246 	}
6247 
6248 	/* Check for mandatory locking and that the size gets set. */
6249 	cva.va_mask = AT_MODE;
6250 	if (setsize)
6251 		cva.va_mask |= AT_SIZE;
6252 
6253 	/* Assume the worst */
6254 	cs->mandlock = TRUE;
6255 
6256 	if (VOP_GETATTR(vp, &cva, 0, cs->cr, NULL) == 0) {
6257 		cs->mandlock = MANDLOCK(cs->vp, cva.va_mode);
6258 
6259 		/*
6260 		 * Truncate the file if necessary; this would be
6261 		 * the case for create over an existing file.
6262 		 */
6263 
6264 		if (trunc) {
6265 			int in_crit = 0;
6266 			rfs4_file_t *fp;
6267 			bool_t create = FALSE;
6268 
6269 			/*
6270 			 * We are writing over an existing file.
6271 			 * Check to see if we need to recall a delegation.
6272 			 */
6273 			rfs4_hold_deleg_policy();
6274 			if ((fp = rfs4_findfile(vp, NULL, &create)) != NULL) {
6275 				if (rfs4_check_delegated_byfp(FWRITE, fp,
6276 				    (reqsize == 0), FALSE, FALSE, &clientid)) {
6277 					rfs4_file_rele(fp);
6278 					rfs4_rele_deleg_policy();
6279 					VN_RELE(vp);
6280 					*attrset = 0;
6281 					return (NFS4ERR_DELAY);
6282 				}
6283 				rfs4_file_rele(fp);
6284 			}
6285 			rfs4_rele_deleg_policy();
6286 
6287 			if (nbl_need_check(vp)) {
6288 				in_crit = 1;
6289 
6290 				ASSERT(reqsize == 0);
6291 
6292 				nbl_start_crit(vp, RW_READER);
6293 				if (nbl_conflict(vp, NBL_WRITE, 0,
6294 				    cva.va_size, 0, NULL)) {
6295 					in_crit = 0;
6296 					nbl_end_crit(vp);
6297 					VN_RELE(vp);
6298 					*attrset = 0;
6299 					return (NFS4ERR_ACCESS);
6300 				}
6301 			}
6302 			ct.cc_sysid = 0;
6303 			ct.cc_pid = 0;
6304 			ct.cc_caller_id = nfs4_srv_caller_id;
6305 			ct.cc_flags = CC_DONTBLOCK;
6306 
6307 			cva.va_mask = AT_SIZE;
6308 			cva.va_size = reqsize;
6309 			(void) VOP_SETATTR(vp, &cva, 0, cs->cr, &ct);
6310 			if (in_crit)
6311 				nbl_end_crit(vp);
6312 		}
6313 	}
6314 
6315 	error = makefh4(&cs->fh, vp, cs->exi);
6316 
6317 	/*
6318 	 * Force modified data and metadata out to stable storage.
6319 	 */
6320 	(void) VOP_FSYNC(vp, FNODSYNC, cs->cr, NULL);
6321 
6322 	if (error) {
6323 		VN_RELE(vp);
6324 		*attrset = 0;
6325 		return (puterrno4(error));
6326 	}
6327 
6328 	/* if parent dir is attrdir, set namedattr fh flag */
6329 	if (dvp->v_flag & V_XATTRDIR)
6330 		set_fh4_flag(&cs->fh, FH4_NAMEDATTR);
6331 
6332 	if (cs->vp)
6333 		VN_RELE(cs->vp);
6334 
6335 	cs->vp = vp;
6336 
6337 	/*
6338 	 * if we did not create the file, we will need to check
6339 	 * the access bits on the file
6340 	 */
6341 
6342 	if (!created) {
6343 		if (setsize)
6344 			args->share_access |= OPEN4_SHARE_ACCESS_WRITE;
6345 		status = check_open_access(args->share_access, cs, req);
6346 		if (status != NFS4_OK)
6347 			*attrset = 0;
6348 	}
6349 	return (status);
6350 }
6351 
6352 /*ARGSUSED*/
6353 static void
6354 rfs4_do_open(struct compound_state *cs, struct svc_req *req,
6355 		rfs4_openowner_t *oo, delegreq_t deleg,
6356 		uint32_t access, uint32_t deny,
6357 		OPEN4res *resp, int deleg_cur)
6358 {
6359 	/* XXX Currently not using req  */
6360 	rfs4_state_t *state;
6361 	rfs4_file_t *file;
6362 	bool_t screate = TRUE;
6363 	bool_t fcreate = TRUE;
6364 	uint32_t amodes;
6365 	uint32_t dmodes;
6366 	rfs4_deleg_state_t *dsp;
6367 	struct shrlock shr;
6368 	struct shr_locowner shr_loco;
6369 	sysid_t sysid;
6370 	nfsstat4 status;
6371 	caller_context_t ct;
6372 	int fflags = 0;
6373 	int recall = 0;
6374 	int err;
6375 	int cmd;
6376 
6377 	/* get the file struct and hold a lock on it during initial open */
6378 	file = rfs4_findfile_withlock(cs->vp, &cs->fh, &fcreate);
6379 	if (file == NULL) {
6380 		NFS4_DEBUG(rfs4_debug,
6381 		    (CE_NOTE, "rfs4_do_open: can't find file"));
6382 		resp->status = NFS4ERR_SERVERFAULT;
6383 		return;
6384 	}
6385 
6386 	state = rfs4_findstate_by_owner_file(oo, file, &screate);
6387 	if (state == NULL) {
6388 		NFS4_DEBUG(rfs4_debug,
6389 		    (CE_NOTE, "rfs4_do_open: can't find state"));
6390 		resp->status = NFS4ERR_RESOURCE;
6391 		/* No need to keep any reference */
6392 		rfs4_file_rele_withunlock(file);
6393 		return;
6394 	}
6395 
6396 	/* try to get the sysid before continuing */
6397 	if ((status = rfs4_client_sysid(oo->client, &sysid)) != NFS4_OK) {
6398 		resp->status = status;
6399 		rfs4_file_rele(file);
6400 		/* Not a fully formed open; "close" it */
6401 		if (screate == TRUE)
6402 			rfs4_state_close(state, FALSE, FALSE, cs->cr);
6403 		rfs4_state_rele(state);
6404 		return;
6405 	}
6406 
6407 	/* Calculate the fflags for this OPEN. */
6408 	if (access & OPEN4_SHARE_ACCESS_READ)
6409 		fflags |= FREAD;
6410 	if (access & OPEN4_SHARE_ACCESS_WRITE)
6411 		fflags |= FWRITE;
6412 
6413 	/*
6414 	 * Calculate the new deny and access mode that this open is adding to
6415 	 * the file for this open owner;
6416 	 */
6417 	dmodes = (deny & ~state->share_deny);
6418 	amodes = (access & ~state->share_access);
6419 
6420 	/*
6421 	 * Check to see the client has already sent an open for this
6422 	 * open owner on this file with the same share/deny modes.
6423 	 * If so, we don't need to check for a conflict and we don't
6424 	 * need to add another shrlock.  If not, then we need to
6425 	 * check for conflicts in deny and access before checking for
6426 	 * conflicts in delegation.  We don't want to recall a
6427 	 * delegation based on an open that will eventually fail based
6428 	 * on shares modes.
6429 	 */
6430 
6431 	if (dmodes || amodes) {
6432 		shr.s_access = (short)access;
6433 		shr.s_deny = (short)deny;
6434 		shr.s_pid = rfs4_dbe_getid(oo->dbe);
6435 		shr.s_sysid = sysid;
6436 		shr_loco.sl_pid = shr.s_pid;
6437 		shr_loco.sl_id = shr.s_sysid;
6438 		shr.s_owner = (caddr_t)&shr_loco;
6439 		shr.s_own_len = sizeof (shr_loco);
6440 
6441 		cmd = nbl_need_check(cs->vp) ? F_SHARE_NBMAND : F_SHARE;
6442 		if ((err = vop_shrlock(cs->vp, cmd, &shr, fflags)) != 0) {
6443 
6444 			resp->status = err == EAGAIN ?
6445 			    NFS4ERR_SHARE_DENIED : puterrno4(err);
6446 
6447 			rfs4_file_rele(file);
6448 			/* Not a fully formed open; "close" it */
6449 			if (screate == TRUE)
6450 				rfs4_state_close(state, FALSE, FALSE, cs->cr);
6451 			rfs4_state_rele(state);
6452 			return;
6453 		}
6454 	}
6455 
6456 	rfs4_dbe_lock(state->dbe);
6457 	rfs4_dbe_lock(file->dbe);
6458 
6459 	/*
6460 	 * Check to see if this file is delegated and if so, if a
6461 	 * recall needs to be done.
6462 	 */
6463 	if (rfs4_check_recall(state, access)) {
6464 		rfs4_dbe_unlock(file->dbe);
6465 		rfs4_dbe_unlock(state->dbe);
6466 		rfs4_recall_deleg(file, FALSE, state->owner->client);
6467 		delay(NFS4_DELEGATION_CONFLICT_DELAY);
6468 		rfs4_dbe_lock(state->dbe);
6469 		rfs4_dbe_lock(file->dbe);
6470 		/* Let's see if the delegation was returned */
6471 		if (rfs4_check_recall(state, access)) {
6472 			rfs4_dbe_unlock(file->dbe);
6473 			rfs4_dbe_unlock(state->dbe);
6474 			rfs4_file_rele(file);
6475 			rfs4_update_lease(state->owner->client);
6476 			(void) vop_shrlock(cs->vp, F_UNSHARE, &shr, fflags);
6477 			/* Not a fully formed open; "close" it */
6478 			if (screate == TRUE)
6479 				rfs4_state_close(state, FALSE, FALSE, cs->cr);
6480 			rfs4_state_rele(state);
6481 			resp->status = NFS4ERR_DELAY;
6482 			return;
6483 		}
6484 	}
6485 	/*
6486 	 * the share check passed and any delegation conflict has been
6487 	 * taken care of, now call vop_open.
6488 	 * if this is the first open then call vop_open with fflags.
6489 	 * if not, call vn_open_upgrade with just the upgrade flags.
6490 	 *
6491 	 * if the file has been opened already, it will have the current
6492 	 * access mode in the state struct.  if it has no share access, then
6493 	 * this is a new open.
6494 	 *
6495 	 * However, if this is open with CLAIM_DLEGATE_CUR, then don't
6496 	 * call VOP_OPEN(), just do the open upgrade.
6497 	 */
6498 	if (((state->share_access & OPEN4_SHARE_ACCESS_BOTH) == 0) &&
6499 	    !deleg_cur) {
6500 		ct.cc_sysid = sysid;
6501 		ct.cc_pid = shr.s_pid;
6502 		ct.cc_caller_id = nfs4_srv_caller_id;
6503 		ct.cc_flags = CC_DONTBLOCK;
6504 		err = VOP_OPEN(&cs->vp, fflags, cs->cr, &ct);
6505 		if (err) {
6506 			rfs4_dbe_unlock(file->dbe);
6507 			rfs4_dbe_unlock(state->dbe);
6508 			rfs4_file_rele(file);
6509 			(void) vop_shrlock(cs->vp, F_UNSHARE, &shr, fflags);
6510 			/* Not a fully formed open; "close" it */
6511 			if (screate == TRUE)
6512 				rfs4_state_close(state, FALSE, FALSE, cs->cr);
6513 			rfs4_state_rele(state);
6514 			resp->status = NFS4ERR_SERVERFAULT;
6515 			return;
6516 		}
6517 	} else { /* open upgrade */
6518 		/*
6519 		 * calculate the fflags for the new mode that is being added
6520 		 * by this upgrade.
6521 		 */
6522 		fflags = 0;
6523 		if (amodes & OPEN4_SHARE_ACCESS_READ)
6524 			fflags |= FREAD;
6525 		if (amodes & OPEN4_SHARE_ACCESS_WRITE)
6526 			fflags |= FWRITE;
6527 		vn_open_upgrade(cs->vp, fflags);
6528 	}
6529 
6530 	if (dmodes & OPEN4_SHARE_DENY_READ)
6531 		file->deny_read++;
6532 	if (dmodes & OPEN4_SHARE_DENY_WRITE)
6533 		file->deny_write++;
6534 	file->share_deny |= deny;
6535 	state->share_deny |= deny;
6536 
6537 	if (amodes & OPEN4_SHARE_ACCESS_READ)
6538 		file->access_read++;
6539 	if (amodes & OPEN4_SHARE_ACCESS_WRITE)
6540 		file->access_write++;
6541 	file->share_access |= access;
6542 	state->share_access |= access;
6543 
6544 	/*
6545 	 * Check for delegation here. if the deleg argument is not
6546 	 * DELEG_ANY, then this is a reclaim from a client and
6547 	 * we must honor the delegation requested. If necessary we can
6548 	 * set the recall flag.
6549 	 */
6550 
6551 	dsp = rfs4_grant_delegation(deleg, state, &recall);
6552 
6553 	cs->deleg = (file->dinfo->dtype == OPEN_DELEGATE_WRITE);
6554 
6555 	next_stateid(&state->stateid);
6556 
6557 	resp->stateid = state->stateid.stateid;
6558 
6559 	rfs4_dbe_unlock(file->dbe);
6560 	rfs4_dbe_unlock(state->dbe);
6561 
6562 	if (dsp) {
6563 		rfs4_set_deleg_response(dsp, &resp->delegation, NULL, recall);
6564 		rfs4_deleg_state_rele(dsp);
6565 	}
6566 
6567 	rfs4_file_rele(file);
6568 	rfs4_state_rele(state);
6569 
6570 	resp->status = NFS4_OK;
6571 }
6572 
6573 /*ARGSUSED*/
6574 static void
6575 rfs4_do_opennull(struct compound_state *cs, struct svc_req *req,
6576 		OPEN4args *args, rfs4_openowner_t *oo, OPEN4res *resp)
6577 {
6578 	change_info4 *cinfo = &resp->cinfo;
6579 	bitmap4 *attrset = &resp->attrset;
6580 
6581 	if (args->opentype == OPEN4_NOCREATE)
6582 		resp->status = rfs4_lookupfile(&args->open_claim4_u.file,
6583 		    req, cs, args->share_access, cinfo);
6584 	else {
6585 		/* inhibit delegation grants during exclusive create */
6586 
6587 		if (args->mode == EXCLUSIVE4)
6588 			rfs4_disable_delegation();
6589 
6590 		resp->status = rfs4_createfile(args, req, cs, cinfo, attrset,
6591 		    oo->client->clientid);
6592 	}
6593 
6594 	if (resp->status == NFS4_OK) {
6595 
6596 		/* cs->vp cs->fh now reference the desired file */
6597 
6598 		rfs4_do_open(cs, req, oo, DELEG_ANY, args->share_access,
6599 		    args->share_deny, resp, 0);
6600 
6601 		/*
6602 		 * If rfs4_createfile set attrset, we must
6603 		 * clear this attrset before the response is copied.
6604 		 */
6605 		if (resp->status != NFS4_OK && resp->attrset) {
6606 			resp->attrset = 0;
6607 		}
6608 	}
6609 	else
6610 		*cs->statusp = resp->status;
6611 
6612 	if (args->mode == EXCLUSIVE4)
6613 		rfs4_enable_delegation();
6614 }
6615 
6616 /*ARGSUSED*/
6617 static void
6618 rfs4_do_openprev(struct compound_state *cs, struct svc_req *req,
6619 		OPEN4args *args, rfs4_openowner_t *oo, OPEN4res *resp)
6620 {
6621 	change_info4 *cinfo = &resp->cinfo;
6622 	vattr_t va;
6623 	vtype_t v_type = cs->vp->v_type;
6624 	int error = 0;
6625 
6626 	/* Verify that we have a regular file */
6627 	if (v_type != VREG) {
6628 		if (v_type == VDIR)
6629 			resp->status = NFS4ERR_ISDIR;
6630 		else if (v_type == VLNK)
6631 			resp->status = NFS4ERR_SYMLINK;
6632 		else
6633 			resp->status = NFS4ERR_INVAL;
6634 		return;
6635 	}
6636 
6637 	va.va_mask = AT_MODE|AT_UID;
6638 	error = VOP_GETATTR(cs->vp, &va, 0, cs->cr, NULL);
6639 	if (error) {
6640 		resp->status = puterrno4(error);
6641 		return;
6642 	}
6643 
6644 	cs->mandlock = MANDLOCK(cs->vp, va.va_mode);
6645 
6646 	/*
6647 	 * Check if we have access to the file, Note the the file
6648 	 * could have originally been open UNCHECKED or GUARDED
6649 	 * with mode bits that will now fail, but there is nothing
6650 	 * we can really do about that except in the case that the
6651 	 * owner of the file is the one requesting the open.
6652 	 */
6653 	if (crgetuid(cs->cr) != va.va_uid) {
6654 		resp->status = check_open_access(args->share_access, cs, req);
6655 		if (resp->status != NFS4_OK) {
6656 			return;
6657 		}
6658 	}
6659 
6660 	/*
6661 	 * cinfo on a CLAIM_PREVIOUS is undefined, initialize to zero
6662 	 */
6663 	cinfo->before = 0;
6664 	cinfo->after = 0;
6665 	cinfo->atomic = FALSE;
6666 
6667 	rfs4_do_open(cs, req, oo,
6668 	    NFS4_DELEG4TYPE2REQTYPE(args->open_claim4_u.delegate_type),
6669 	    args->share_access, args->share_deny, resp, 0);
6670 }
6671 
6672 static void
6673 rfs4_do_opendelcur(struct compound_state *cs, struct svc_req *req,
6674 		OPEN4args *args, rfs4_openowner_t *oo, OPEN4res *resp)
6675 {
6676 	int error;
6677 	nfsstat4 status;
6678 	stateid4 stateid =
6679 	    args->open_claim4_u.delegate_cur_info.delegate_stateid;
6680 	rfs4_deleg_state_t *dsp;
6681 
6682 	/*
6683 	 * Find the state info from the stateid and confirm that the
6684 	 * file is delegated.  If the state openowner is the same as
6685 	 * the supplied openowner we're done. If not, get the file
6686 	 * info from the found state info. Use that file info to
6687 	 * create the state for this lock owner. Note solaris doen't
6688 	 * really need the pathname to find the file. We may want to
6689 	 * lookup the pathname and make sure that the vp exist and
6690 	 * matches the vp in the file structure. However it is
6691 	 * possible that the pathname nolonger exists (local process
6692 	 * unlinks the file), so this may not be that useful.
6693 	 */
6694 
6695 	status = rfs4_get_deleg_state(&stateid, &dsp);
6696 	if (status != NFS4_OK) {
6697 		resp->status = status;
6698 		return;
6699 	}
6700 
6701 	ASSERT(dsp->finfo->dinfo->dtype != OPEN_DELEGATE_NONE);
6702 
6703 	/*
6704 	 * New lock owner, create state. Since this was probably called
6705 	 * in response to a CB_RECALL we set deleg to DELEG_NONE
6706 	 */
6707 
6708 	ASSERT(cs->vp != NULL);
6709 	VN_RELE(cs->vp);
6710 	VN_HOLD(dsp->finfo->vp);
6711 	cs->vp = dsp->finfo->vp;
6712 
6713 	if (error = makefh4(&cs->fh, cs->vp, cs->exi)) {
6714 		rfs4_deleg_state_rele(dsp);
6715 		*cs->statusp = resp->status = puterrno4(error);
6716 		return;
6717 	}
6718 
6719 	/* Mark progress for delegation returns */
6720 	dsp->finfo->dinfo->time_lastwrite = gethrestime_sec();
6721 	rfs4_deleg_state_rele(dsp);
6722 	rfs4_do_open(cs, req, oo, DELEG_NONE,
6723 	    args->share_access, args->share_deny, resp, 1);
6724 }
6725 
6726 /*ARGSUSED*/
6727 static void
6728 rfs4_do_opendelprev(struct compound_state *cs, struct svc_req *req,
6729 			OPEN4args *args, rfs4_openowner_t *oo, OPEN4res *resp)
6730 {
6731 	/*
6732 	 * Lookup the pathname, it must already exist since this file
6733 	 * was delegated.
6734 	 *
6735 	 * Find the file and state info for this vp and open owner pair.
6736 	 *	check that they are in fact delegated.
6737 	 *	check that the state access and deny modes are the same.
6738 	 *
6739 	 * Return the delgation possibly seting the recall flag.
6740 	 */
6741 	rfs4_file_t *file;
6742 	rfs4_state_t *state;
6743 	bool_t create = FALSE;
6744 	bool_t dcreate = FALSE;
6745 	rfs4_deleg_state_t *dsp;
6746 	nfsace4 *ace;
6747 
6748 
6749 	/* Note we ignore oflags */
6750 	resp->status = rfs4_lookupfile(&args->open_claim4_u.file_delegate_prev,
6751 	    req, cs, args->share_access, &resp->cinfo);
6752 
6753 	if (resp->status != NFS4_OK) {
6754 		return;
6755 	}
6756 
6757 	/* get the file struct and hold a lock on it during initial open */
6758 	file = rfs4_findfile_withlock(cs->vp, NULL, &create);
6759 	if (file == NULL) {
6760 		NFS4_DEBUG(rfs4_debug,
6761 		    (CE_NOTE, "rfs4_do_opendelprev: can't find file"));
6762 		resp->status = NFS4ERR_SERVERFAULT;
6763 		return;
6764 	}
6765 
6766 	state = rfs4_findstate_by_owner_file(oo, file, &create);
6767 	if (state == NULL) {
6768 		NFS4_DEBUG(rfs4_debug,
6769 		    (CE_NOTE, "rfs4_do_opendelprev: can't find state"));
6770 		resp->status = NFS4ERR_SERVERFAULT;
6771 		rfs4_file_rele_withunlock(file);
6772 		return;
6773 	}
6774 
6775 	rfs4_dbe_lock(state->dbe);
6776 	rfs4_dbe_lock(file->dbe);
6777 	if (args->share_access != state->share_access ||
6778 	    args->share_deny != state->share_deny ||
6779 	    state->finfo->dinfo->dtype == OPEN_DELEGATE_NONE) {
6780 		NFS4_DEBUG(rfs4_debug,
6781 		    (CE_NOTE, "rfs4_do_opendelprev: state mixup"));
6782 		rfs4_dbe_unlock(file->dbe);
6783 		rfs4_dbe_unlock(state->dbe);
6784 		rfs4_file_rele(file);
6785 		rfs4_state_rele(state);
6786 		resp->status = NFS4ERR_SERVERFAULT;
6787 		return;
6788 	}
6789 	rfs4_dbe_unlock(file->dbe);
6790 	rfs4_dbe_unlock(state->dbe);
6791 
6792 	dsp = rfs4_finddeleg(state, &dcreate);
6793 	if (dsp == NULL) {
6794 		rfs4_state_rele(state);
6795 		rfs4_file_rele(file);
6796 		resp->status = NFS4ERR_SERVERFAULT;
6797 		return;
6798 	}
6799 
6800 	next_stateid(&state->stateid);
6801 
6802 	resp->stateid = state->stateid.stateid;
6803 
6804 	resp->delegation.delegation_type = dsp->dtype;
6805 
6806 	if (dsp->dtype == OPEN_DELEGATE_READ) {
6807 		open_read_delegation4 *rv =
6808 		    &resp->delegation.open_delegation4_u.read;
6809 
6810 		rv->stateid = dsp->delegid.stateid;
6811 		rv->recall = FALSE; /* no policy in place to set to TRUE */
6812 		ace = &rv->permissions;
6813 	} else {
6814 		open_write_delegation4 *rv =
6815 		    &resp->delegation.open_delegation4_u.write;
6816 
6817 		rv->stateid = dsp->delegid.stateid;
6818 		rv->recall = FALSE;  /* no policy in place to set to TRUE */
6819 		ace = &rv->permissions;
6820 		rv->space_limit.limitby = NFS_LIMIT_SIZE;
6821 		rv->space_limit.nfs_space_limit4_u.filesize = UINT64_MAX;
6822 	}
6823 
6824 	/* XXX For now */
6825 	ace->type = ACE4_ACCESS_ALLOWED_ACE_TYPE;
6826 	ace->flag = 0;
6827 	ace->access_mask = 0;
6828 	ace->who.utf8string_len = 0;
6829 	ace->who.utf8string_val = 0;
6830 
6831 	rfs4_deleg_state_rele(dsp);
6832 	rfs4_state_rele(state);
6833 	rfs4_file_rele(file);
6834 }
6835 
6836 typedef enum {
6837 	NFS4_CHKSEQ_OKAY = 0,
6838 	NFS4_CHKSEQ_REPLAY = 1,
6839 	NFS4_CHKSEQ_BAD = 2
6840 } rfs4_chkseq_t;
6841 
6842 /*
6843  * Generic function for sequence number checks.
6844  */
6845 static rfs4_chkseq_t
6846 rfs4_check_seqid(seqid4 seqid, nfs_resop4 *lastop,
6847 		seqid4 rqst_seq, nfs_resop4 *resop, bool_t copyres)
6848 {
6849 	/* Same sequence ids and matching operations? */
6850 	if (seqid == rqst_seq && resop->resop == lastop->resop) {
6851 		if (copyres == TRUE) {
6852 			rfs4_free_reply(resop);
6853 			rfs4_copy_reply(resop, lastop);
6854 		}
6855 		NFS4_DEBUG(rfs4_debug, (CE_NOTE,
6856 		    "Replayed SEQID %d\n", seqid));
6857 		return (NFS4_CHKSEQ_REPLAY);
6858 	}
6859 
6860 	/* If the incoming sequence is not the next expected then it is bad */
6861 	if (rqst_seq != seqid + 1) {
6862 		if (rqst_seq == seqid) {
6863 			NFS4_DEBUG(rfs4_debug,
6864 			    (CE_NOTE, "BAD SEQID: Replayed sequence id "
6865 			    "but last op was %d current op is %d\n",
6866 			    lastop->resop, resop->resop));
6867 			return (NFS4_CHKSEQ_BAD);
6868 		}
6869 		NFS4_DEBUG(rfs4_debug,
6870 		    (CE_NOTE, "BAD SEQID: got %u expecting %u\n",
6871 		    rqst_seq, seqid));
6872 		return (NFS4_CHKSEQ_BAD);
6873 	}
6874 
6875 	/* Everything okay -- next expected */
6876 	return (NFS4_CHKSEQ_OKAY);
6877 }
6878 
6879 
6880 static rfs4_chkseq_t
6881 rfs4_check_open_seqid(seqid4 seqid, rfs4_openowner_t *op, nfs_resop4 *resop)
6882 {
6883 	rfs4_chkseq_t rc;
6884 
6885 	rfs4_dbe_lock(op->dbe);
6886 	rc = rfs4_check_seqid(op->open_seqid, op->reply, seqid, resop, TRUE);
6887 	rfs4_dbe_unlock(op->dbe);
6888 
6889 	if (rc == NFS4_CHKSEQ_OKAY)
6890 		rfs4_update_lease(op->client);
6891 
6892 	return (rc);
6893 }
6894 
6895 static rfs4_chkseq_t
6896 rfs4_check_olo_seqid(seqid4 olo_seqid, rfs4_openowner_t *op,
6897 	nfs_resop4 *resop)
6898 {
6899 	rfs4_chkseq_t rc;
6900 
6901 	rfs4_dbe_lock(op->dbe);
6902 	rc = rfs4_check_seqid(op->open_seqid, op->reply,
6903 	    olo_seqid, resop, FALSE);
6904 	rfs4_dbe_unlock(op->dbe);
6905 
6906 	return (rc);
6907 }
6908 
6909 static rfs4_chkseq_t
6910 rfs4_check_lock_seqid(seqid4 seqid, rfs4_lo_state_t *lp, nfs_resop4 *resop)
6911 {
6912 	rfs4_chkseq_t rc = NFS4_CHKSEQ_OKAY;
6913 
6914 	rfs4_dbe_lock(lp->dbe);
6915 	if (!lp->skip_seqid_check)
6916 		rc = rfs4_check_seqid(lp->seqid, lp->reply, seqid, resop, TRUE);
6917 	rfs4_dbe_unlock(lp->dbe);
6918 
6919 	return (rc);
6920 }
6921 
6922 static void
6923 rfs4_op_open(nfs_argop4 *argop, nfs_resop4 *resop,
6924 	    struct svc_req *req, struct compound_state *cs)
6925 {
6926 	OPEN4args *args = &argop->nfs_argop4_u.opopen;
6927 	OPEN4res *resp = &resop->nfs_resop4_u.opopen;
6928 	open_owner4 *owner = &args->owner;
6929 	open_claim_type4 claim = args->claim;
6930 	rfs4_client_t *cp;
6931 	rfs4_openowner_t *oo;
6932 	bool_t create;
6933 	bool_t replay = FALSE;
6934 	int can_reclaim;
6935 
6936 	DTRACE_NFSV4_2(op__open__start, struct compound_state *, cs,
6937 	    OPEN4args *, args);
6938 
6939 	if (cs->vp == NULL) {
6940 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
6941 		goto end;
6942 	}
6943 
6944 	/*
6945 	 * Need to check clientid and lease expiration first based on
6946 	 * error ordering and incrementing sequence id.
6947 	 */
6948 	cp = rfs4_findclient_by_id(owner->clientid, FALSE);
6949 	if (cp == NULL) {
6950 		*cs->statusp = resp->status =
6951 		    rfs4_check_clientid(&owner->clientid, 0);
6952 		goto end;
6953 	}
6954 
6955 	if (rfs4_lease_expired(cp)) {
6956 		rfs4_client_close(cp);
6957 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
6958 		goto end;
6959 	}
6960 	can_reclaim = cp->can_reclaim;
6961 
6962 	/*
6963 	 * Find the open_owner for use from this point forward.  Take
6964 	 * care in updating the sequence id based on the type of error
6965 	 * being returned.
6966 	 */
6967 retry:
6968 	create = TRUE;
6969 	oo = rfs4_findopenowner(owner, &create, args->seqid);
6970 	if (oo == NULL) {
6971 		*cs->statusp = resp->status = NFS4ERR_STALE_CLIENTID;
6972 		rfs4_client_rele(cp);
6973 		goto end;
6974 	}
6975 
6976 	/* Hold off access to the sequence space while the open is done */
6977 	rfs4_sw_enter(&oo->oo_sw);
6978 
6979 	/*
6980 	 * If the open_owner existed before at the server, then check
6981 	 * the sequence id.
6982 	 */
6983 	if (!create && !oo->postpone_confirm) {
6984 		switch (rfs4_check_open_seqid(args->seqid, oo, resop)) {
6985 		case NFS4_CHKSEQ_BAD:
6986 			if ((args->seqid > oo->open_seqid) &&
6987 			    oo->need_confirm) {
6988 				rfs4_free_opens(oo, TRUE, FALSE);
6989 				rfs4_sw_exit(&oo->oo_sw);
6990 				rfs4_openowner_rele(oo);
6991 				goto retry;
6992 			}
6993 			resp->status = NFS4ERR_BAD_SEQID;
6994 			goto out;
6995 		case NFS4_CHKSEQ_REPLAY: /* replay of previous request */
6996 			replay = TRUE;
6997 			goto out;
6998 		default:
6999 			break;
7000 		}
7001 
7002 		/*
7003 		 * Sequence was ok and open owner exists
7004 		 * check to see if we have yet to see an
7005 		 * open_confirm.
7006 		 */
7007 		if (oo->need_confirm) {
7008 			rfs4_free_opens(oo, TRUE, FALSE);
7009 			rfs4_sw_exit(&oo->oo_sw);
7010 			rfs4_openowner_rele(oo);
7011 			goto retry;
7012 		}
7013 	}
7014 	/* Grace only applies to regular-type OPENs */
7015 	if (rfs4_clnt_in_grace(cp) &&
7016 	    (claim == CLAIM_NULL || claim == CLAIM_DELEGATE_CUR)) {
7017 		*cs->statusp = resp->status = NFS4ERR_GRACE;
7018 		goto out;
7019 	}
7020 
7021 	/*
7022 	 * If previous state at the server existed then can_reclaim
7023 	 * will be set. If not reply NFS4ERR_NO_GRACE to the
7024 	 * client.
7025 	 */
7026 	if (rfs4_clnt_in_grace(cp) && claim == CLAIM_PREVIOUS && !can_reclaim) {
7027 		*cs->statusp = resp->status = NFS4ERR_NO_GRACE;
7028 		goto out;
7029 	}
7030 
7031 
7032 	/*
7033 	 * Reject the open if the client has missed the grace period
7034 	 */
7035 	if (!rfs4_clnt_in_grace(cp) && claim == CLAIM_PREVIOUS) {
7036 		*cs->statusp = resp->status = NFS4ERR_NO_GRACE;
7037 		goto out;
7038 	}
7039 
7040 	/* Couple of up-front bookkeeping items */
7041 	if (oo->need_confirm) {
7042 		/*
7043 		 * If this is a reclaim OPEN then we should not ask
7044 		 * for a confirmation of the open_owner per the
7045 		 * protocol specification.
7046 		 */
7047 		if (claim == CLAIM_PREVIOUS)
7048 			oo->need_confirm = FALSE;
7049 		else
7050 			resp->rflags |= OPEN4_RESULT_CONFIRM;
7051 	}
7052 	resp->rflags |= OPEN4_RESULT_LOCKTYPE_POSIX;
7053 
7054 	/*
7055 	 * If there is an unshared filesystem mounted on this vnode,
7056 	 * do not allow to open/create in this directory.
7057 	 */
7058 	if (vn_ismntpt(cs->vp)) {
7059 		*cs->statusp = resp->status = NFS4ERR_ACCESS;
7060 		goto out;
7061 	}
7062 
7063 	/*
7064 	 * access must READ, WRITE, or BOTH.  No access is invalid.
7065 	 * deny can be READ, WRITE, BOTH, or NONE.
7066 	 * bits not defined for access/deny are invalid.
7067 	 */
7068 	if (! (args->share_access & OPEN4_SHARE_ACCESS_BOTH) ||
7069 	    (args->share_access & ~OPEN4_SHARE_ACCESS_BOTH) ||
7070 	    (args->share_deny & ~OPEN4_SHARE_DENY_BOTH)) {
7071 		*cs->statusp = resp->status = NFS4ERR_INVAL;
7072 		goto out;
7073 	}
7074 
7075 
7076 	/*
7077 	 * make sure attrset is zero before response is built.
7078 	 */
7079 	resp->attrset = 0;
7080 
7081 	switch (claim) {
7082 	case CLAIM_NULL:
7083 		rfs4_do_opennull(cs, req, args, oo, resp);
7084 		break;
7085 	case CLAIM_PREVIOUS:
7086 		rfs4_do_openprev(cs, req, args, oo, resp);
7087 		break;
7088 	case CLAIM_DELEGATE_CUR:
7089 		rfs4_do_opendelcur(cs, req, args, oo, resp);
7090 		break;
7091 	case CLAIM_DELEGATE_PREV:
7092 		rfs4_do_opendelprev(cs, req, args, oo, resp);
7093 		break;
7094 	default:
7095 		resp->status = NFS4ERR_INVAL;
7096 		break;
7097 	}
7098 
7099 out:
7100 	rfs4_client_rele(cp);
7101 
7102 	/* Catch sequence id handling here to make it a little easier */
7103 	switch (resp->status) {
7104 	case NFS4ERR_BADXDR:
7105 	case NFS4ERR_BAD_SEQID:
7106 	case NFS4ERR_BAD_STATEID:
7107 	case NFS4ERR_NOFILEHANDLE:
7108 	case NFS4ERR_RESOURCE:
7109 	case NFS4ERR_STALE_CLIENTID:
7110 	case NFS4ERR_STALE_STATEID:
7111 		/*
7112 		 * The protocol states that if any of these errors are
7113 		 * being returned, the sequence id should not be
7114 		 * incremented.  Any other return requires an
7115 		 * increment.
7116 		 */
7117 		break;
7118 	default:
7119 		/* Always update the lease in this case */
7120 		rfs4_update_lease(oo->client);
7121 
7122 		/* Regular response - copy the result */
7123 		if (!replay)
7124 			rfs4_update_open_resp(oo, resop, &cs->fh);
7125 
7126 		/*
7127 		 * REPLAY case: Only if the previous response was OK
7128 		 * do we copy the filehandle.  If not OK, no
7129 		 * filehandle to copy.
7130 		 */
7131 		if (replay == TRUE &&
7132 		    resp->status == NFS4_OK &&
7133 		    oo->reply_fh.nfs_fh4_val) {
7134 			/*
7135 			 * If this is a replay, we must restore the
7136 			 * current filehandle/vp to that of what was
7137 			 * returned originally.  Try our best to do
7138 			 * it.
7139 			 */
7140 			nfs_fh4_fmt_t *fh_fmtp =
7141 			    (nfs_fh4_fmt_t *)oo->reply_fh.nfs_fh4_val;
7142 
7143 			cs->exi = checkexport4(&fh_fmtp->fh4_fsid,
7144 			    (fid_t *)&fh_fmtp->fh4_xlen, NULL);
7145 
7146 			if (cs->exi == NULL) {
7147 				resp->status = NFS4ERR_STALE;
7148 				goto finish;
7149 			}
7150 
7151 			VN_RELE(cs->vp);
7152 
7153 			cs->vp = nfs4_fhtovp(&oo->reply_fh, cs->exi,
7154 			    &resp->status);
7155 
7156 			if (cs->vp == NULL)
7157 				goto finish;
7158 
7159 			nfs_fh4_copy(&oo->reply_fh, &cs->fh);
7160 		}
7161 
7162 		/*
7163 		 * If this was a replay, no need to update the
7164 		 * sequence id. If the open_owner was not created on
7165 		 * this pass, then update.  The first use of an
7166 		 * open_owner will not bump the sequence id.
7167 		 */
7168 		if (replay == FALSE && !create)
7169 			rfs4_update_open_sequence(oo);
7170 		/*
7171 		 * If the client is receiving an error and the
7172 		 * open_owner needs to be confirmed, there is no way
7173 		 * to notify the client of this fact ignoring the fact
7174 		 * that the server has no method of returning a
7175 		 * stateid to confirm.  Therefore, the server needs to
7176 		 * mark this open_owner in a way as to avoid the
7177 		 * sequence id checking the next time the client uses
7178 		 * this open_owner.
7179 		 */
7180 		if (resp->status != NFS4_OK && oo->need_confirm)
7181 			oo->postpone_confirm = TRUE;
7182 		/*
7183 		 * If OK response then clear the postpone flag and
7184 		 * reset the sequence id to keep in sync with the
7185 		 * client.
7186 		 */
7187 		if (resp->status == NFS4_OK && oo->postpone_confirm) {
7188 			oo->postpone_confirm = FALSE;
7189 			oo->open_seqid = args->seqid;
7190 		}
7191 		break;
7192 	}
7193 
7194 finish:
7195 	*cs->statusp = resp->status;
7196 
7197 	rfs4_sw_exit(&oo->oo_sw);
7198 	rfs4_openowner_rele(oo);
7199 
7200 end:
7201 	DTRACE_NFSV4_2(op__open__done, struct compound_state *, cs,
7202 	    OPEN4res *, resp);
7203 }
7204 
7205 /*ARGSUSED*/
7206 void
7207 rfs4_op_open_confirm(nfs_argop4 *argop, nfs_resop4 *resop,
7208 		    struct svc_req *req, struct compound_state *cs)
7209 {
7210 	OPEN_CONFIRM4args *args = &argop->nfs_argop4_u.opopen_confirm;
7211 	OPEN_CONFIRM4res *resp = &resop->nfs_resop4_u.opopen_confirm;
7212 	rfs4_state_t *sp;
7213 	nfsstat4 status;
7214 
7215 	DTRACE_NFSV4_2(op__open__confirm__start, struct compound_state *, cs,
7216 	    OPEN_CONFIRM4args *, args);
7217 
7218 	if (cs->vp == NULL) {
7219 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
7220 		goto out;
7221 	}
7222 
7223 	status = rfs4_get_state(&args->open_stateid, &sp, RFS4_DBS_VALID);
7224 	if (status != NFS4_OK) {
7225 		*cs->statusp = resp->status = status;
7226 		goto out;
7227 	}
7228 
7229 	/* Ensure specified filehandle matches */
7230 	if (cs->vp != sp->finfo->vp) {
7231 		rfs4_state_rele(sp);
7232 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
7233 		goto out;
7234 	}
7235 
7236 	/* hold off other access to open_owner while we tinker */
7237 	rfs4_sw_enter(&sp->owner->oo_sw);
7238 
7239 	switch (rfs4_check_stateid_seqid(sp, &args->open_stateid)) {
7240 	case NFS4_CHECK_STATEID_OKAY:
7241 		if (rfs4_check_open_seqid(args->seqid, sp->owner,
7242 		    resop) != 0) {
7243 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
7244 			break;
7245 		}
7246 		/*
7247 		 * If it is the appropriate stateid and determined to
7248 		 * be "OKAY" then this means that the stateid does not
7249 		 * need to be confirmed and the client is in error for
7250 		 * sending an OPEN_CONFIRM.
7251 		 */
7252 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
7253 		break;
7254 	case NFS4_CHECK_STATEID_OLD:
7255 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
7256 		break;
7257 	case NFS4_CHECK_STATEID_BAD:
7258 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
7259 		break;
7260 	case NFS4_CHECK_STATEID_EXPIRED:
7261 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
7262 		break;
7263 	case NFS4_CHECK_STATEID_CLOSED:
7264 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
7265 		break;
7266 	case NFS4_CHECK_STATEID_REPLAY:
7267 		switch (rfs4_check_open_seqid(args->seqid, sp->owner, resop)) {
7268 		case NFS4_CHKSEQ_OKAY:
7269 			/*
7270 			 * This is replayed stateid; if seqid matches
7271 			 * next expected, then client is using wrong seqid.
7272 			 */
7273 			/* fall through */
7274 		case NFS4_CHKSEQ_BAD:
7275 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
7276 			break;
7277 		case NFS4_CHKSEQ_REPLAY:
7278 			/*
7279 			 * Note this case is the duplicate case so
7280 			 * resp->status is already set.
7281 			 */
7282 			*cs->statusp = resp->status;
7283 			rfs4_update_lease(sp->owner->client);
7284 			break;
7285 		}
7286 		break;
7287 	case NFS4_CHECK_STATEID_UNCONFIRMED:
7288 		if (rfs4_check_open_seqid(args->seqid, sp->owner,
7289 		    resop) != NFS4_CHKSEQ_OKAY) {
7290 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
7291 			break;
7292 		}
7293 		*cs->statusp = resp->status = NFS4_OK;
7294 
7295 		next_stateid(&sp->stateid);
7296 		resp->open_stateid = sp->stateid.stateid;
7297 		sp->owner->need_confirm = FALSE;
7298 		rfs4_update_lease(sp->owner->client);
7299 		rfs4_update_open_sequence(sp->owner);
7300 		rfs4_update_open_resp(sp->owner, resop, NULL);
7301 		break;
7302 	default:
7303 		ASSERT(FALSE);
7304 		*cs->statusp = resp->status = NFS4ERR_SERVERFAULT;
7305 		break;
7306 	}
7307 	rfs4_sw_exit(&sp->owner->oo_sw);
7308 	rfs4_state_rele(sp);
7309 
7310 out:
7311 	DTRACE_NFSV4_2(op__open__confirm__done, struct compound_state *, cs,
7312 	    OPEN_CONFIRM4res *, resp);
7313 }
7314 
7315 /*ARGSUSED*/
7316 void
7317 rfs4_op_open_downgrade(nfs_argop4 *argop, nfs_resop4 *resop,
7318 		    struct svc_req *req, struct compound_state *cs)
7319 {
7320 	OPEN_DOWNGRADE4args *args = &argop->nfs_argop4_u.opopen_downgrade;
7321 	OPEN_DOWNGRADE4res *resp = &resop->nfs_resop4_u.opopen_downgrade;
7322 	uint32_t access = args->share_access;
7323 	uint32_t deny = args->share_deny;
7324 	nfsstat4 status;
7325 	rfs4_state_t *sp;
7326 	rfs4_file_t *fp;
7327 	int fflags = 0;
7328 
7329 	DTRACE_NFSV4_2(op__open__downgrade__start, struct compound_state *, cs,
7330 	    OPEN_DOWNGRADE4args *, args);
7331 
7332 	if (cs->vp == NULL) {
7333 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
7334 		goto out;
7335 	}
7336 
7337 	status = rfs4_get_state(&args->open_stateid, &sp, RFS4_DBS_VALID);
7338 	if (status != NFS4_OK) {
7339 		*cs->statusp = resp->status = status;
7340 		goto out;
7341 	}
7342 
7343 	/* Ensure specified filehandle matches */
7344 	if (cs->vp != sp->finfo->vp) {
7345 		rfs4_state_rele(sp);
7346 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
7347 		goto out;
7348 	}
7349 
7350 	/* hold off other access to open_owner while we tinker */
7351 	rfs4_sw_enter(&sp->owner->oo_sw);
7352 
7353 	switch (rfs4_check_stateid_seqid(sp, &args->open_stateid)) {
7354 	case NFS4_CHECK_STATEID_OKAY:
7355 		if (rfs4_check_open_seqid(args->seqid, sp->owner,
7356 		    resop) != NFS4_CHKSEQ_OKAY) {
7357 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
7358 			goto end;
7359 		}
7360 		break;
7361 	case NFS4_CHECK_STATEID_OLD:
7362 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
7363 		goto end;
7364 	case NFS4_CHECK_STATEID_BAD:
7365 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
7366 		goto end;
7367 	case NFS4_CHECK_STATEID_EXPIRED:
7368 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
7369 		goto end;
7370 	case NFS4_CHECK_STATEID_CLOSED:
7371 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
7372 		goto end;
7373 	case NFS4_CHECK_STATEID_UNCONFIRMED:
7374 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
7375 		goto end;
7376 	case NFS4_CHECK_STATEID_REPLAY:
7377 		/* Check the sequence id for the open owner */
7378 		switch (rfs4_check_open_seqid(args->seqid, sp->owner, resop)) {
7379 		case NFS4_CHKSEQ_OKAY:
7380 			/*
7381 			 * This is replayed stateid; if seqid matches
7382 			 * next expected, then client is using wrong seqid.
7383 			 */
7384 			/* fall through */
7385 		case NFS4_CHKSEQ_BAD:
7386 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
7387 			goto end;
7388 		case NFS4_CHKSEQ_REPLAY:
7389 			/*
7390 			 * Note this case is the duplicate case so
7391 			 * resp->status is already set.
7392 			 */
7393 			*cs->statusp = resp->status;
7394 			rfs4_update_lease(sp->owner->client);
7395 			goto end;
7396 		}
7397 		break;
7398 	default:
7399 		ASSERT(FALSE);
7400 		break;
7401 	}
7402 
7403 	rfs4_dbe_lock(sp->dbe);
7404 	/*
7405 	 * Check that the new access modes and deny modes are valid.
7406 	 * Check that no invalid bits are set.
7407 	 */
7408 	if ((access & ~(OPEN4_SHARE_ACCESS_READ | OPEN4_SHARE_ACCESS_WRITE)) ||
7409 	    (deny & ~(OPEN4_SHARE_DENY_READ | OPEN4_SHARE_DENY_WRITE))) {
7410 		*cs->statusp = resp->status = NFS4ERR_INVAL;
7411 		rfs4_update_open_sequence(sp->owner);
7412 		rfs4_dbe_unlock(sp->dbe);
7413 		goto end;
7414 	}
7415 
7416 	/*
7417 	 * The new modes must be a subset of the current modes and
7418 	 * the access must specify at least one mode. To test that
7419 	 * the new mode is a subset of the current modes we bitwise
7420 	 * AND them together and check that the result equals the new
7421 	 * mode. For example:
7422 	 * New mode, access == R and current mode, sp->share_access  == RW
7423 	 * access & sp->share_access == R == access, so the new access mode
7424 	 * is valid. Consider access == RW, sp->share_access = R
7425 	 * access & sp->share_access == R != access, so the new access mode
7426 	 * is invalid.
7427 	 */
7428 	if ((access & sp->share_access) != access ||
7429 	    (deny & sp->share_deny) != deny ||
7430 	    (access &
7431 	    (OPEN4_SHARE_ACCESS_READ | OPEN4_SHARE_ACCESS_WRITE)) == 0) {
7432 		*cs->statusp = resp->status = NFS4ERR_INVAL;
7433 		rfs4_update_open_sequence(sp->owner);
7434 		rfs4_dbe_unlock(sp->dbe);
7435 		goto end;
7436 	}
7437 
7438 	/*
7439 	 * Release any share locks associated with this stateID.
7440 	 * Strictly speaking, this violates the spec because the
7441 	 * spec effectively requires that open downgrade be atomic.
7442 	 * At present, fs_shrlock does not have this capability.
7443 	 */
7444 	rfs4_dbe_unlock(sp->dbe);
7445 	rfs4_unshare(sp);
7446 	rfs4_dbe_lock(sp->dbe);
7447 
7448 	fp = sp->finfo;
7449 	rfs4_dbe_lock(fp->dbe);
7450 
7451 	/*
7452 	 * If the current mode has deny read and the new mode
7453 	 * does not, decrement the number of deny read mode bits
7454 	 * and if it goes to zero turn off the deny read bit
7455 	 * on the file.
7456 	 */
7457 	if ((sp->share_deny & OPEN4_SHARE_DENY_READ) &&
7458 	    (deny & OPEN4_SHARE_DENY_READ) == 0) {
7459 		fp->deny_read--;
7460 		if (fp->deny_read == 0)
7461 			fp->share_deny &= ~OPEN4_SHARE_DENY_READ;
7462 	}
7463 
7464 	/*
7465 	 * If the current mode has deny write and the new mode
7466 	 * does not, decrement the number of deny write mode bits
7467 	 * and if it goes to zero turn off the deny write bit
7468 	 * on the file.
7469 	 */
7470 	if ((sp->share_deny & OPEN4_SHARE_DENY_WRITE) &&
7471 	    (deny & OPEN4_SHARE_DENY_WRITE) == 0) {
7472 		fp->deny_write--;
7473 		if (fp->deny_write == 0)
7474 			fp->share_deny &= ~OPEN4_SHARE_DENY_WRITE;
7475 	}
7476 
7477 	/*
7478 	 * If the current mode has access read and the new mode
7479 	 * does not, decrement the number of access read mode bits
7480 	 * and if it goes to zero turn off the access read bit
7481 	 * on the file.  set fflags to FREAD for the call to
7482 	 * vn_open_downgrade().
7483 	 */
7484 	if ((sp->share_access & OPEN4_SHARE_ACCESS_READ) &&
7485 	    (access & OPEN4_SHARE_ACCESS_READ) == 0) {
7486 		fp->access_read--;
7487 		if (fp->access_read == 0)
7488 			fp->share_access &= ~OPEN4_SHARE_ACCESS_READ;
7489 		fflags |= FREAD;
7490 	}
7491 
7492 	/*
7493 	 * If the current mode has access write and the new mode
7494 	 * does not, decrement the number of access write mode bits
7495 	 * and if it goes to zero turn off the access write bit
7496 	 * on the file.  set fflags to FWRITE for the call to
7497 	 * vn_open_downgrade().
7498 	 */
7499 	if ((sp->share_access & OPEN4_SHARE_ACCESS_WRITE) &&
7500 	    (access & OPEN4_SHARE_ACCESS_WRITE) == 0) {
7501 		fp->access_write--;
7502 		if (fp->access_write == 0)
7503 			fp->share_deny &= ~OPEN4_SHARE_ACCESS_WRITE;
7504 		fflags |= FWRITE;
7505 	}
7506 
7507 	/* Set the new access and deny modes */
7508 	sp->share_access = access;
7509 	sp->share_deny = deny;
7510 	/* Check that the file is still accessible */
7511 	ASSERT(fp->share_access);
7512 
7513 	rfs4_dbe_unlock(fp->dbe);
7514 
7515 	rfs4_dbe_unlock(sp->dbe);
7516 
7517 	if ((status = rfs4_share(sp)) != NFS4_OK) {
7518 		*cs->statusp = resp->status = NFS4ERR_SERVERFAULT;
7519 		rfs4_update_open_sequence(sp->owner);
7520 		goto end;
7521 	}
7522 
7523 	/*
7524 	 * we successfully downgraded the share lock, now we need to downgrade
7525 	 * the open.  it is possible that the downgrade was only for a deny
7526 	 * mode and we have nothing else to do.
7527 	 */
7528 	if ((fflags & (FREAD|FWRITE)) != 0)
7529 		vn_open_downgrade(cs->vp, fflags);
7530 
7531 	rfs4_dbe_lock(sp->dbe);
7532 
7533 	/* Update the stateid */
7534 	next_stateid(&sp->stateid);
7535 	resp->open_stateid = sp->stateid.stateid;
7536 
7537 	rfs4_dbe_unlock(sp->dbe);
7538 
7539 	*cs->statusp = resp->status = NFS4_OK;
7540 	/* Update the lease */
7541 	rfs4_update_lease(sp->owner->client);
7542 	/* And the sequence */
7543 	rfs4_update_open_sequence(sp->owner);
7544 	rfs4_update_open_resp(sp->owner, resop, NULL);
7545 
7546 end:
7547 	rfs4_sw_exit(&sp->owner->oo_sw);
7548 	rfs4_state_rele(sp);
7549 out:
7550 	DTRACE_NFSV4_2(op__open__downgrade__done, struct compound_state *, cs,
7551 	    OPEN_DOWNGRADE4res *, resp);
7552 }
7553 
7554 /*
7555  * The logic behind this function is detailed in the NFSv4 RFC in the
7556  * SETCLIENTID operation description under IMPLEMENTATION.  Refer to
7557  * that section for explicit guidance to server behavior for
7558  * SETCLIENTID.
7559  */
7560 void
7561 rfs4_op_setclientid(nfs_argop4 *argop, nfs_resop4 *resop,
7562 		    struct svc_req *req, struct compound_state *cs)
7563 {
7564 	SETCLIENTID4args *args = &argop->nfs_argop4_u.opsetclientid;
7565 	SETCLIENTID4res *res = &resop->nfs_resop4_u.opsetclientid;
7566 	rfs4_client_t *cp, *newcp, *cp_confirmed, *cp_unconfirmed;
7567 	bool_t create = TRUE;
7568 	char *addr, *netid;
7569 	int len;
7570 
7571 	DTRACE_NFSV4_2(op__setclientid__start, struct compound_state *, cs,
7572 	    SETCLIENTID4args *, args);
7573 retry:
7574 	newcp = cp_confirmed = cp_unconfirmed = NULL;
7575 
7576 	/*
7577 	 * In search of an EXISTING client matching the incoming
7578 	 * request to establish a new client identifier at the server
7579 	 */
7580 	create = TRUE;
7581 	cp = rfs4_findclient(&args->client, &create, NULL);
7582 
7583 	/* Should never happen */
7584 	ASSERT(cp != NULL);
7585 
7586 	if (cp == NULL) {
7587 		*cs->statusp = res->status = NFS4ERR_SERVERFAULT;
7588 		goto out;
7589 	}
7590 
7591 	/*
7592 	 * Easiest case. Client identifier is newly created and is
7593 	 * unconfirmed.  Also note that for this case, no other
7594 	 * entries exist for the client identifier.  Nothing else to
7595 	 * check.  Just setup the response and respond.
7596 	 */
7597 	if (create) {
7598 		*cs->statusp = res->status = NFS4_OK;
7599 		res->SETCLIENTID4res_u.resok4.clientid = cp->clientid;
7600 		res->SETCLIENTID4res_u.resok4.setclientid_confirm =
7601 		    cp->confirm_verf;
7602 		/* Setup callback information; CB_NULL confirmation later */
7603 		rfs4_client_setcb(cp, &args->callback, args->callback_ident);
7604 
7605 		rfs4_client_rele(cp);
7606 		goto out;
7607 	}
7608 
7609 	/*
7610 	 * An existing, confirmed client may exist but it may not have
7611 	 * been active for at least one lease period.  If so, then
7612 	 * "close" the client and create a new client identifier
7613 	 */
7614 	if (rfs4_lease_expired(cp)) {
7615 		rfs4_client_close(cp);
7616 		goto retry;
7617 	}
7618 
7619 	if (cp->need_confirm == TRUE)
7620 		cp_unconfirmed = cp;
7621 	else
7622 		cp_confirmed = cp;
7623 
7624 	cp = NULL;
7625 
7626 	/*
7627 	 * We have a confirmed client, now check for an
7628 	 * unconfimred entry
7629 	 */
7630 	if (cp_confirmed) {
7631 		/* If creds don't match then client identifier is inuse */
7632 		if (!creds_ok(cp_confirmed->cr_set, req, cs)) {
7633 			rfs4_cbinfo_t *cbp;
7634 			/*
7635 			 * Some one else has established this client
7636 			 * id. Try and say * who they are. We will use
7637 			 * the call back address supplied by * the
7638 			 * first client.
7639 			 */
7640 			*cs->statusp = res->status = NFS4ERR_CLID_INUSE;
7641 
7642 			addr = netid = NULL;
7643 
7644 			cbp = &cp_confirmed->cbinfo;
7645 			if (cbp->cb_callback.cb_location.r_addr &&
7646 			    cbp->cb_callback.cb_location.r_netid) {
7647 				cb_client4 *cbcp = &cbp->cb_callback;
7648 
7649 				len = strlen(cbcp->cb_location.r_addr)+1;
7650 				addr = kmem_alloc(len, KM_SLEEP);
7651 				bcopy(cbcp->cb_location.r_addr, addr, len);
7652 				len = strlen(cbcp->cb_location.r_netid)+1;
7653 				netid = kmem_alloc(len, KM_SLEEP);
7654 				bcopy(cbcp->cb_location.r_netid, netid, len);
7655 			}
7656 
7657 			res->SETCLIENTID4res_u.client_using.r_addr = addr;
7658 			res->SETCLIENTID4res_u.client_using.r_netid = netid;
7659 
7660 			rfs4_client_rele(cp_confirmed);
7661 		}
7662 
7663 		/*
7664 		 * Confirmed, creds match, and verifier matches; must
7665 		 * be an update of the callback info
7666 		 */
7667 		if (cp_confirmed->nfs_client.verifier ==
7668 		    args->client.verifier) {
7669 			/* Setup callback information */
7670 			rfs4_client_setcb(cp_confirmed, &args->callback,
7671 			    args->callback_ident);
7672 
7673 			/* everything okay -- move ahead */
7674 			*cs->statusp = res->status = NFS4_OK;
7675 			res->SETCLIENTID4res_u.resok4.clientid =
7676 			    cp_confirmed->clientid;
7677 
7678 			/* update the confirm_verifier and return it */
7679 			rfs4_client_scv_next(cp_confirmed);
7680 			res->SETCLIENTID4res_u.resok4.setclientid_confirm =
7681 			    cp_confirmed->confirm_verf;
7682 
7683 			rfs4_client_rele(cp_confirmed);
7684 			goto out;
7685 		}
7686 
7687 		/*
7688 		 * Creds match but the verifier doesn't.  Must search
7689 		 * for an unconfirmed client that would be replaced by
7690 		 * this request.
7691 		 */
7692 		create = FALSE;
7693 		cp_unconfirmed = rfs4_findclient(&args->client, &create,
7694 		    cp_confirmed);
7695 	}
7696 
7697 	/*
7698 	 * At this point, we have taken care of the brand new client
7699 	 * struct, INUSE case, update of an existing, and confirmed
7700 	 * client struct.
7701 	 */
7702 
7703 	/*
7704 	 * check to see if things have changed while we originally
7705 	 * picked up the client struct.  If they have, then return and
7706 	 * retry the processing of this SETCLIENTID request.
7707 	 */
7708 	if (cp_unconfirmed) {
7709 		rfs4_dbe_lock(cp_unconfirmed->dbe);
7710 		if (!cp_unconfirmed->need_confirm) {
7711 			rfs4_dbe_unlock(cp_unconfirmed->dbe);
7712 			rfs4_client_rele(cp_unconfirmed);
7713 			if (cp_confirmed)
7714 				rfs4_client_rele(cp_confirmed);
7715 			goto retry;
7716 		}
7717 		/* do away with the old unconfirmed one */
7718 		rfs4_dbe_invalidate(cp_unconfirmed->dbe);
7719 		rfs4_dbe_unlock(cp_unconfirmed->dbe);
7720 		rfs4_client_rele(cp_unconfirmed);
7721 		cp_unconfirmed = NULL;
7722 	}
7723 
7724 	/*
7725 	 * This search will temporarily hide the confirmed client
7726 	 * struct while a new client struct is created as the
7727 	 * unconfirmed one.
7728 	 */
7729 	create = TRUE;
7730 	newcp = rfs4_findclient(&args->client, &create, cp_confirmed);
7731 
7732 	ASSERT(newcp != NULL);
7733 
7734 	if (newcp == NULL) {
7735 		*cs->statusp = res->status = NFS4ERR_SERVERFAULT;
7736 		rfs4_client_rele(cp_confirmed);
7737 		goto out;
7738 	}
7739 
7740 	/*
7741 	 * If one was not created, then a similar request must be in
7742 	 * process so release and start over with this one
7743 	 */
7744 	if (create != TRUE) {
7745 		rfs4_client_rele(newcp);
7746 		if (cp_confirmed)
7747 			rfs4_client_rele(cp_confirmed);
7748 		goto retry;
7749 	}
7750 
7751 	*cs->statusp = res->status = NFS4_OK;
7752 	res->SETCLIENTID4res_u.resok4.clientid = newcp->clientid;
7753 	res->SETCLIENTID4res_u.resok4.setclientid_confirm = newcp->confirm_verf;
7754 	/* Setup callback information; CB_NULL confirmation later */
7755 	rfs4_client_setcb(newcp, &args->callback, args->callback_ident);
7756 
7757 	newcp->cp_confirmed = cp_confirmed;
7758 
7759 	rfs4_client_rele(newcp);
7760 
7761 out:
7762 	DTRACE_NFSV4_2(op__setclientid__done, struct compound_state *, cs,
7763 	    SETCLIENTID4res *, res);
7764 }
7765 
7766 /*ARGSUSED*/
7767 void
7768 rfs4_op_setclientid_confirm(nfs_argop4 *argop, nfs_resop4 *resop,
7769 			    struct svc_req *req, struct compound_state *cs)
7770 {
7771 	SETCLIENTID_CONFIRM4args *args =
7772 	    &argop->nfs_argop4_u.opsetclientid_confirm;
7773 	SETCLIENTID_CONFIRM4res *res =
7774 	    &resop->nfs_resop4_u.opsetclientid_confirm;
7775 	rfs4_client_t *cp, *cptoclose = NULL;
7776 
7777 	DTRACE_NFSV4_2(op__setclientid__confirm__start,
7778 	    struct compound_state *, cs,
7779 	    SETCLIENTID_CONFIRM4args *, args);
7780 
7781 	*cs->statusp = res->status = NFS4_OK;
7782 
7783 	cp = rfs4_findclient_by_id(args->clientid, TRUE);
7784 
7785 	if (cp == NULL) {
7786 		*cs->statusp = res->status =
7787 		    rfs4_check_clientid(&args->clientid, 1);
7788 		goto out;
7789 	}
7790 
7791 	if (!creds_ok(cp, req, cs)) {
7792 		*cs->statusp = res->status = NFS4ERR_CLID_INUSE;
7793 		rfs4_client_rele(cp);
7794 		goto out;
7795 	}
7796 
7797 	/* If the verifier doesn't match, the record doesn't match */
7798 	if (cp->confirm_verf != args->setclientid_confirm) {
7799 		*cs->statusp = res->status = NFS4ERR_STALE_CLIENTID;
7800 		rfs4_client_rele(cp);
7801 		goto out;
7802 	}
7803 
7804 	rfs4_dbe_lock(cp->dbe);
7805 	cp->need_confirm = FALSE;
7806 	if (cp->cp_confirmed) {
7807 		cptoclose = cp->cp_confirmed;
7808 		cptoclose->ss_remove = 1;
7809 		cp->cp_confirmed = NULL;
7810 	}
7811 
7812 	/*
7813 	 * Update the client's associated server instance, if it's changed
7814 	 * since the client was created.
7815 	 */
7816 	if (rfs4_servinst(cp) != rfs4_cur_servinst)
7817 		rfs4_servinst_assign(cp, rfs4_cur_servinst);
7818 
7819 	/*
7820 	 * Record clientid in stable storage.
7821 	 * Must be done after server instance has been assigned.
7822 	 */
7823 	rfs4_ss_clid(cp, req);
7824 
7825 	rfs4_dbe_unlock(cp->dbe);
7826 
7827 	if (cptoclose)
7828 		/* don't need to rele, client_close does it */
7829 		rfs4_client_close(cptoclose);
7830 
7831 	/* If needed, initiate CB_NULL call for callback path */
7832 	rfs4_deleg_cb_check(cp);
7833 	rfs4_update_lease(cp);
7834 
7835 	/*
7836 	 * Check to see if client can perform reclaims
7837 	 */
7838 	rfs4_ss_chkclid(cp);
7839 
7840 	rfs4_client_rele(cp);
7841 
7842 out:
7843 	DTRACE_NFSV4_2(op__setclientid__confirm__done,
7844 	    struct compound_state *, cs,
7845 	    SETCLIENTID_CONFIRM4 *, res);
7846 }
7847 
7848 
7849 /*ARGSUSED*/
7850 void
7851 rfs4_op_close(nfs_argop4 *argop, nfs_resop4 *resop,
7852 	    struct svc_req *req, struct compound_state *cs)
7853 {
7854 	CLOSE4args *args = &argop->nfs_argop4_u.opclose;
7855 	CLOSE4res *resp = &resop->nfs_resop4_u.opclose;
7856 	rfs4_state_t *sp;
7857 	nfsstat4 status;
7858 
7859 	DTRACE_NFSV4_2(op__close__start, struct compound_state *, cs,
7860 	    CLOSE4args *, args);
7861 
7862 	if (cs->vp == NULL) {
7863 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
7864 		goto out;
7865 	}
7866 
7867 	status = rfs4_get_state(&args->open_stateid, &sp, RFS4_DBS_INVALID);
7868 	if (status != NFS4_OK) {
7869 		*cs->statusp = resp->status = status;
7870 		goto out;
7871 	}
7872 
7873 	/* Ensure specified filehandle matches */
7874 	if (cs->vp != sp->finfo->vp) {
7875 		rfs4_state_rele(sp);
7876 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
7877 		goto out;
7878 	}
7879 
7880 	/* hold off other access to open_owner while we tinker */
7881 	rfs4_sw_enter(&sp->owner->oo_sw);
7882 
7883 	switch (rfs4_check_stateid_seqid(sp, &args->open_stateid)) {
7884 	case NFS4_CHECK_STATEID_OKAY:
7885 		if (rfs4_check_open_seqid(args->seqid, sp->owner,
7886 		    resop) != NFS4_CHKSEQ_OKAY) {
7887 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
7888 			goto end;
7889 		}
7890 		break;
7891 	case NFS4_CHECK_STATEID_OLD:
7892 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
7893 		goto end;
7894 	case NFS4_CHECK_STATEID_BAD:
7895 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
7896 		goto end;
7897 	case NFS4_CHECK_STATEID_EXPIRED:
7898 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
7899 		goto end;
7900 	case NFS4_CHECK_STATEID_CLOSED:
7901 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
7902 		goto end;
7903 	case NFS4_CHECK_STATEID_UNCONFIRMED:
7904 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
7905 		goto end;
7906 	case NFS4_CHECK_STATEID_REPLAY:
7907 		/* Check the sequence id for the open owner */
7908 		switch (rfs4_check_open_seqid(args->seqid, sp->owner, resop)) {
7909 		case NFS4_CHKSEQ_OKAY:
7910 			/*
7911 			 * This is replayed stateid; if seqid matches
7912 			 * next expected, then client is using wrong seqid.
7913 			 */
7914 			/* FALL THROUGH */
7915 		case NFS4_CHKSEQ_BAD:
7916 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
7917 			goto end;
7918 		case NFS4_CHKSEQ_REPLAY:
7919 			/*
7920 			 * Note this case is the duplicate case so
7921 			 * resp->status is already set.
7922 			 */
7923 			*cs->statusp = resp->status;
7924 			rfs4_update_lease(sp->owner->client);
7925 			goto end;
7926 		}
7927 		break;
7928 	default:
7929 		ASSERT(FALSE);
7930 		break;
7931 	}
7932 
7933 	rfs4_dbe_lock(sp->dbe);
7934 
7935 	/* Update the stateid. */
7936 	next_stateid(&sp->stateid);
7937 	resp->open_stateid = sp->stateid.stateid;
7938 
7939 	rfs4_dbe_unlock(sp->dbe);
7940 
7941 	rfs4_update_lease(sp->owner->client);
7942 	rfs4_update_open_sequence(sp->owner);
7943 	rfs4_update_open_resp(sp->owner, resop, NULL);
7944 
7945 	rfs4_state_close(sp, FALSE, FALSE, cs->cr);
7946 
7947 	*cs->statusp = resp->status = status;
7948 
7949 end:
7950 	rfs4_sw_exit(&sp->owner->oo_sw);
7951 	rfs4_state_rele(sp);
7952 out:
7953 	DTRACE_NFSV4_2(op__close__done, struct compound_state *, cs,
7954 	    CLOSE4res *, resp);
7955 }
7956 
7957 /*
7958  * Manage the counts on the file struct and close all file locks
7959  */
7960 /*ARGSUSED*/
7961 void
7962 rfs4_release_share_lock_state(rfs4_state_t *sp, cred_t *cr,
7963 	bool_t close_of_client)
7964 {
7965 	rfs4_file_t *fp = sp->finfo;
7966 	rfs4_lo_state_t *lsp;
7967 	struct shrlock shr;
7968 	struct shr_locowner shr_loco;
7969 	int fflags, s_access, s_deny;
7970 
7971 	fflags = s_access = s_deny = 0;
7972 	/*
7973 	 * Decrement the count for each access and deny bit that this
7974 	 * state has contributed to the file. If the file counts go to zero
7975 	 * clear the appropriate bit in the appropriate mask.
7976 	 */
7977 
7978 	if (sp->share_access & OPEN4_SHARE_ACCESS_READ) {
7979 		fp->access_read--;
7980 		fflags |= FREAD;
7981 		s_access |= F_RDACC;
7982 		if (fp->access_read == 0)
7983 			fp->share_access &= ~OPEN4_SHARE_ACCESS_READ;
7984 	}
7985 	if (sp->share_access & OPEN4_SHARE_ACCESS_WRITE) {
7986 		fp->access_write--;
7987 		fflags |= FWRITE;
7988 		s_access |= F_WRACC;
7989 		if (fp->access_write == 0)
7990 			fp->share_access &= ~OPEN4_SHARE_ACCESS_WRITE;
7991 	}
7992 	if (sp->share_deny & OPEN4_SHARE_DENY_READ) {
7993 		fp->deny_read--;
7994 		s_deny |= F_RDDNY;
7995 		if (fp->deny_read == 0)
7996 			fp->share_deny &= ~OPEN4_SHARE_DENY_READ;
7997 	}
7998 	if (sp->share_deny & OPEN4_SHARE_DENY_WRITE) {
7999 		fp->deny_write--;
8000 		s_deny |= F_WRDNY;
8001 		if (fp->deny_write == 0)
8002 			fp->share_deny &= ~OPEN4_SHARE_DENY_WRITE;
8003 	}
8004 
8005 	/*
8006 	 * If this call is part of the larger closing down of client
8007 	 * state then it is just easier to release all locks
8008 	 * associated with this client instead of going through each
8009 	 * individual file and cleaning locks there.
8010 	 */
8011 	if (close_of_client) {
8012 		if (sp->owner->client->unlksys_completed == FALSE &&
8013 		    sp->lockownerlist.next->lsp != NULL &&
8014 		    sp->owner->client->sysidt != LM_NOSYSID) {
8015 			/* Is the PxFS kernel module loaded? */
8016 			if (lm_remove_file_locks != NULL) {
8017 				int new_sysid;
8018 
8019 				/* Encode the cluster nodeid in new sysid */
8020 				new_sysid = sp->owner->client->sysidt;
8021 				lm_set_nlmid_flk(&new_sysid);
8022 
8023 				/*
8024 				 * This PxFS routine removes file locks for a
8025 				 * client over all nodes of a cluster.
8026 				 */
8027 				NFS4_DEBUG(rfs4_debug, (CE_NOTE,
8028 				    "lm_remove_file_locks(sysid=0x%x)\n",
8029 				    new_sysid));
8030 				(*lm_remove_file_locks)(new_sysid);
8031 			} else {
8032 				struct flock64 flk;
8033 
8034 				/* Release all locks for this client */
8035 				flk.l_type = F_UNLKSYS;
8036 				flk.l_whence = 0;
8037 				flk.l_start = 0;
8038 				flk.l_len = 0;
8039 				flk.l_sysid = sp->owner->client->sysidt;
8040 				flk.l_pid = 0;
8041 				(void) VOP_FRLOCK(sp->finfo->vp, F_SETLK, &flk,
8042 				    F_REMOTELOCK | FREAD | FWRITE,
8043 				    (u_offset_t)0, NULL, CRED(), NULL);
8044 			}
8045 
8046 			sp->owner->client->unlksys_completed = TRUE;
8047 		}
8048 	}
8049 
8050 	/*
8051 	 * Release all locks on this file by this lock owner or at
8052 	 * least mark the locks as having been released
8053 	 */
8054 	for (lsp = sp->lockownerlist.next->lsp; lsp != NULL;
8055 	    lsp = lsp->lockownerlist.next->lsp) {
8056 
8057 		lsp->locks_cleaned = TRUE;
8058 
8059 		/* Was this already taken care of above? */
8060 		if (!close_of_client &&
8061 		    sp->owner->client->sysidt != LM_NOSYSID)
8062 			(void) cleanlocks(sp->finfo->vp, lsp->locker->pid,
8063 			    lsp->locker->client->sysidt);
8064 	}
8065 
8066 	/*
8067 	 * Release any shrlocks associated with this open state ID.
8068 	 * This must be done before the rfs4_state gets marked closed.
8069 	 */
8070 	if (sp->owner->client->sysidt != LM_NOSYSID) {
8071 		shr.s_access = s_access;
8072 		shr.s_deny = s_deny;
8073 		shr.s_pid = rfs4_dbe_getid(sp->owner->dbe);
8074 		shr.s_sysid = sp->owner->client->sysidt;
8075 		shr_loco.sl_pid = shr.s_pid;
8076 		shr_loco.sl_id = shr.s_sysid;
8077 		shr.s_owner = (caddr_t)&shr_loco;
8078 		shr.s_own_len = sizeof (shr_loco);
8079 		(void) vop_shrlock(sp->finfo->vp, F_UNSHARE, &shr, fflags);
8080 	}
8081 
8082 	(void) VOP_CLOSE(fp->vp, fflags, 1, (offset_t)0, cr, NULL);
8083 }
8084 
8085 /*
8086  * lock_denied: Fill in a LOCK4deneid structure given an flock64 structure.
8087  */
8088 static nfsstat4
8089 lock_denied(LOCK4denied *dp, struct flock64 *flk)
8090 {
8091 	rfs4_lockowner_t *lo;
8092 	rfs4_client_t *cp;
8093 	uint32_t len;
8094 
8095 	lo = rfs4_findlockowner_by_pid(flk->l_pid);
8096 	if (lo != NULL) {
8097 		cp = lo->client;
8098 		if (rfs4_lease_expired(cp)) {
8099 			rfs4_lockowner_rele(lo);
8100 			rfs4_dbe_hold(cp->dbe);
8101 			rfs4_client_close(cp);
8102 			return (NFS4ERR_EXPIRED);
8103 		}
8104 		dp->owner.clientid = lo->owner.clientid;
8105 		len = lo->owner.owner_len;
8106 		dp->owner.owner_val = kmem_alloc(len, KM_SLEEP);
8107 		bcopy(lo->owner.owner_val, dp->owner.owner_val, len);
8108 		dp->owner.owner_len = len;
8109 		rfs4_lockowner_rele(lo);
8110 		goto finish;
8111 	}
8112 
8113 	/*
8114 	 * Its not a NFS4 lock. We take advantage that the upper 32 bits
8115 	 * of the client id contain the boot time for a NFS4 lock. So we
8116 	 * fabricate and identity by setting clientid to the sysid, and
8117 	 * the lock owner to the pid.
8118 	 */
8119 	dp->owner.clientid = flk->l_sysid;
8120 	len = sizeof (pid_t);
8121 	dp->owner.owner_len = len;
8122 	dp->owner.owner_val = kmem_alloc(len, KM_SLEEP);
8123 	bcopy(&flk->l_pid, dp->owner.owner_val, len);
8124 finish:
8125 	dp->offset = flk->l_start;
8126 	dp->length = flk->l_len;
8127 
8128 	if (flk->l_type == F_RDLCK)
8129 		dp->locktype = READ_LT;
8130 	else if (flk->l_type == F_WRLCK)
8131 		dp->locktype = WRITE_LT;
8132 	else
8133 		return (NFS4ERR_INVAL);	/* no mapping from POSIX ltype to v4 */
8134 
8135 	return (NFS4_OK);
8136 }
8137 
8138 static int
8139 setlock(vnode_t *vp, struct flock64 *flock, int flag, cred_t *cred)
8140 {
8141 	int error;
8142 	struct flock64 flk;
8143 	int i;
8144 	clock_t delaytime;
8145 	int cmd;
8146 
8147 	cmd = nbl_need_check(vp) ? F_SETLK_NBMAND : F_SETLK;
8148 retry:
8149 	delaytime = MSEC_TO_TICK_ROUNDUP(rfs4_lock_delay);
8150 
8151 	for (i = 0; i < rfs4_maxlock_tries; i++) {
8152 		LOCK_PRINT(rfs4_debug, "setlock", cmd, flock);
8153 		error = VOP_FRLOCK(vp, cmd,
8154 		    flock, flag, (u_offset_t)0, NULL, cred, NULL);
8155 
8156 		if (error != EAGAIN && error != EACCES)
8157 			break;
8158 
8159 		if (i < rfs4_maxlock_tries - 1) {
8160 			delay(delaytime);
8161 			delaytime *= 2;
8162 		}
8163 	}
8164 
8165 	if (error == EAGAIN || error == EACCES) {
8166 		/* Get the owner of the lock */
8167 		flk = *flock;
8168 		LOCK_PRINT(rfs4_debug, "setlock", F_GETLK, &flk);
8169 		if (VOP_FRLOCK(vp, F_GETLK, &flk, flag,
8170 		    (u_offset_t)0, NULL, cred, NULL) == 0) {
8171 			if (flk.l_type == F_UNLCK) {
8172 				/* No longer locked, retry */
8173 				goto retry;
8174 			}
8175 			*flock = flk;
8176 			LOCK_PRINT(rfs4_debug, "setlock(blocking lock)",
8177 			    F_GETLK, &flk);
8178 		}
8179 	}
8180 
8181 	return (error);
8182 }
8183 
8184 /*ARGSUSED*/
8185 static nfsstat4
8186 rfs4_do_lock(rfs4_lo_state_t *lp, nfs_lock_type4 locktype,
8187 	    seqid4 seqid, offset4 offset,
8188 	    length4 length, cred_t *cred, nfs_resop4 *resop)
8189 {
8190 	nfsstat4 status;
8191 	rfs4_lockowner_t *lo = lp->locker;
8192 	rfs4_state_t *sp = lp->state;
8193 	struct flock64 flock;
8194 	int16_t ltype;
8195 	int flag;
8196 	int error;
8197 	sysid_t sysid;
8198 	LOCK4res *lres;
8199 
8200 	if (rfs4_lease_expired(lo->client)) {
8201 		return (NFS4ERR_EXPIRED);
8202 	}
8203 
8204 	if ((status = rfs4_client_sysid(lo->client, &sysid)) != NFS4_OK)
8205 		return (status);
8206 
8207 	/* Check for zero length. To lock to end of file use all ones for V4 */
8208 	if (length == 0)
8209 		return (NFS4ERR_INVAL);
8210 	else if (length == (length4)(~0))
8211 		length = 0;		/* Posix to end of file  */
8212 
8213 retry:
8214 	rfs4_dbe_lock(sp->dbe);
8215 
8216 
8217 	if (resop->resop != OP_LOCKU) {
8218 		switch (locktype) {
8219 		case READ_LT:
8220 		case READW_LT:
8221 			if ((sp->share_access
8222 			    & OPEN4_SHARE_ACCESS_READ) == 0) {
8223 				rfs4_dbe_unlock(sp->dbe);
8224 
8225 				return (NFS4ERR_OPENMODE);
8226 			}
8227 			ltype = F_RDLCK;
8228 			break;
8229 		case WRITE_LT:
8230 		case WRITEW_LT:
8231 			if ((sp->share_access
8232 			    & OPEN4_SHARE_ACCESS_WRITE) == 0) {
8233 				rfs4_dbe_unlock(sp->dbe);
8234 
8235 				return (NFS4ERR_OPENMODE);
8236 			}
8237 			ltype = F_WRLCK;
8238 			break;
8239 		}
8240 	} else
8241 		ltype = F_UNLCK;
8242 
8243 	flock.l_type = ltype;
8244 	flock.l_whence = 0;		/* SEEK_SET */
8245 	flock.l_start = offset;
8246 	flock.l_len = length;
8247 	flock.l_sysid = sysid;
8248 	flock.l_pid = lp->locker->pid;
8249 
8250 	/* Note that length4 is uint64_t but l_len and l_start are off64_t */
8251 	if (flock.l_len < 0 || flock.l_start < 0) {
8252 		rfs4_dbe_unlock(sp->dbe);
8253 		return (NFS4ERR_INVAL);
8254 	}
8255 
8256 	/*
8257 	 * N.B. FREAD has the same value as OPEN4_SHARE_ACCESS_READ and
8258 	 * FWRITE has the same value as OPEN4_SHARE_ACCESS_WRITE.
8259 	 */
8260 	flag = (int)sp->share_access | F_REMOTELOCK;
8261 
8262 	error = setlock(sp->finfo->vp, &flock, flag, cred);
8263 	if (error == 0) {
8264 		rfs4_dbe_lock(lp->dbe);
8265 		next_stateid(&lp->lockid);
8266 		rfs4_dbe_unlock(lp->dbe);
8267 	}
8268 
8269 	rfs4_dbe_unlock(sp->dbe);
8270 
8271 	/*
8272 	 * N.B. We map error values to nfsv4 errors. This is differrent
8273 	 * than puterrno4 routine.
8274 	 */
8275 	switch (error) {
8276 	case 0:
8277 		status = NFS4_OK;
8278 		break;
8279 	case EAGAIN:
8280 	case EACCES:		/* Old value */
8281 		/* Can only get here if op is OP_LOCK */
8282 		ASSERT(resop->resop == OP_LOCK);
8283 		lres = &resop->nfs_resop4_u.oplock;
8284 		status = NFS4ERR_DENIED;
8285 		if (lock_denied(&lres->LOCK4res_u.denied, &flock)
8286 		    == NFS4ERR_EXPIRED)
8287 			goto retry;
8288 		break;
8289 	case ENOLCK:
8290 		status = NFS4ERR_DELAY;
8291 		break;
8292 	case EOVERFLOW:
8293 		status = NFS4ERR_INVAL;
8294 		break;
8295 	case EINVAL:
8296 		status = NFS4ERR_NOTSUPP;
8297 		break;
8298 	default:
8299 		cmn_err(CE_WARN, "rfs4_do_lock: unexpected errno (%d)", error);
8300 		status = NFS4ERR_SERVERFAULT;
8301 		break;
8302 	}
8303 
8304 	return (status);
8305 }
8306 
8307 /*ARGSUSED*/
8308 void
8309 rfs4_op_lock(nfs_argop4 *argop, nfs_resop4 *resop,
8310 	    struct svc_req *req, struct compound_state *cs)
8311 {
8312 	LOCK4args *args = &argop->nfs_argop4_u.oplock;
8313 	LOCK4res *resp = &resop->nfs_resop4_u.oplock;
8314 	nfsstat4 status;
8315 	stateid4 *stateid;
8316 	rfs4_lockowner_t *lo;
8317 	rfs4_client_t *cp;
8318 	rfs4_state_t *sp = NULL;
8319 	rfs4_lo_state_t *lsp = NULL;
8320 	bool_t ls_sw_held = FALSE;
8321 	bool_t create = TRUE;
8322 	bool_t lcreate = TRUE;
8323 	bool_t dup_lock = FALSE;
8324 	int rc;
8325 
8326 	DTRACE_NFSV4_2(op__lock__start, struct compound_state *, cs,
8327 	    LOCK4args *, args);
8328 
8329 	if (cs->vp == NULL) {
8330 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
8331 		DTRACE_NFSV4_2(op__lock__done, struct compound_state *,
8332 		    cs, LOCK4res *, resp);
8333 		return;
8334 	}
8335 
8336 	if (args->locker.new_lock_owner) {
8337 		/* Create a new lockowner for this instance */
8338 		open_to_lock_owner4 *olo = &args->locker.locker4_u.open_owner;
8339 
8340 		NFS4_DEBUG(rfs4_debug, (CE_NOTE, "Creating new lock owner"));
8341 
8342 		stateid = &olo->open_stateid;
8343 		status = rfs4_get_state(stateid, &sp, RFS4_DBS_VALID);
8344 		if (status != NFS4_OK) {
8345 			NFS4_DEBUG(rfs4_debug,
8346 			    (CE_NOTE, "Get state failed in lock %d", status));
8347 			*cs->statusp = resp->status = status;
8348 			DTRACE_NFSV4_2(op__lock__done, struct compound_state *,
8349 			    cs, LOCK4res *, resp);
8350 			return;
8351 		}
8352 
8353 		/* Ensure specified filehandle matches */
8354 		if (cs->vp != sp->finfo->vp) {
8355 			rfs4_state_rele(sp);
8356 			*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
8357 			DTRACE_NFSV4_2(op__lock__done, struct compound_state *,
8358 			    cs, LOCK4res *, resp);
8359 			return;
8360 		}
8361 
8362 		/* hold off other access to open_owner while we tinker */
8363 		rfs4_sw_enter(&sp->owner->oo_sw);
8364 
8365 		switch (rc = rfs4_check_stateid_seqid(sp, stateid)) {
8366 		case NFS4_CHECK_STATEID_OLD:
8367 			*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
8368 			goto end;
8369 		case NFS4_CHECK_STATEID_BAD:
8370 			*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
8371 			goto end;
8372 		case NFS4_CHECK_STATEID_EXPIRED:
8373 			*cs->statusp = resp->status = NFS4ERR_EXPIRED;
8374 			goto end;
8375 		case NFS4_CHECK_STATEID_UNCONFIRMED:
8376 			*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
8377 			goto end;
8378 		case NFS4_CHECK_STATEID_CLOSED:
8379 			*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
8380 			goto end;
8381 		case NFS4_CHECK_STATEID_OKAY:
8382 		case NFS4_CHECK_STATEID_REPLAY:
8383 			switch (rfs4_check_olo_seqid(olo->open_seqid,
8384 			    sp->owner, resop)) {
8385 			case NFS4_CHKSEQ_OKAY:
8386 				if (rc == NFS4_CHECK_STATEID_OKAY)
8387 					break;
8388 				/*
8389 				 * This is replayed stateid; if seqid
8390 				 * matches next expected, then client
8391 				 * is using wrong seqid.
8392 				 */
8393 				/* FALLTHROUGH */
8394 			case NFS4_CHKSEQ_BAD:
8395 				*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
8396 				goto end;
8397 			case NFS4_CHKSEQ_REPLAY:
8398 				/* This is a duplicate LOCK request */
8399 				dup_lock = TRUE;
8400 
8401 				/*
8402 				 * For a duplicate we do not want to
8403 				 * create a new lockowner as it should
8404 				 * already exist.
8405 				 * Turn off the lockowner create flag.
8406 				 */
8407 				lcreate = FALSE;
8408 			}
8409 			break;
8410 		}
8411 
8412 		lo = rfs4_findlockowner(&olo->lock_owner, &lcreate);
8413 		if (lo == NULL) {
8414 			NFS4_DEBUG(rfs4_debug,
8415 			    (CE_NOTE, "rfs4_op_lock: no lock owner"));
8416 			*cs->statusp = resp->status = NFS4ERR_RESOURCE;
8417 			goto end;
8418 		}
8419 
8420 		lsp = rfs4_findlo_state_by_owner(lo, sp, &create);
8421 		if (lsp == NULL) {
8422 			rfs4_update_lease(sp->owner->client);
8423 			/*
8424 			 * Only update theh open_seqid if this is not
8425 			 * a duplicate request
8426 			 */
8427 			if (dup_lock == FALSE) {
8428 				rfs4_update_open_sequence(sp->owner);
8429 			}
8430 
8431 			NFS4_DEBUG(rfs4_debug,
8432 			    (CE_NOTE, "rfs4_op_lock: no state"));
8433 			*cs->statusp = resp->status = NFS4ERR_SERVERFAULT;
8434 			rfs4_update_open_resp(sp->owner, resop, NULL);
8435 			rfs4_lockowner_rele(lo);
8436 			goto end;
8437 		}
8438 
8439 		/*
8440 		 * This is the new_lock_owner branch and the client is
8441 		 * supposed to be associating a new lock_owner with
8442 		 * the open file at this point.  If we find that a
8443 		 * lock_owner/state association already exists and a
8444 		 * successful LOCK request was returned to the client,
8445 		 * an error is returned to the client since this is
8446 		 * not appropriate.  The client should be using the
8447 		 * existing lock_owner branch.
8448 		 */
8449 		if (dup_lock == FALSE && create == FALSE) {
8450 			if (lsp->lock_completed == TRUE) {
8451 				*cs->statusp =
8452 				    resp->status = NFS4ERR_BAD_SEQID;
8453 				rfs4_lockowner_rele(lo);
8454 				goto end;
8455 			}
8456 		}
8457 
8458 		rfs4_update_lease(sp->owner->client);
8459 
8460 		/*
8461 		 * Only update theh open_seqid if this is not
8462 		 * a duplicate request
8463 		 */
8464 		if (dup_lock == FALSE) {
8465 			rfs4_update_open_sequence(sp->owner);
8466 		}
8467 
8468 		/*
8469 		 * If this is a duplicate lock request, just copy the
8470 		 * previously saved reply and return.
8471 		 */
8472 		if (dup_lock == TRUE) {
8473 			/* verify that lock_seqid's match */
8474 			if (lsp->seqid != olo->lock_seqid) {
8475 				NFS4_DEBUG(rfs4_debug,
8476 				    (CE_NOTE, "rfs4_op_lock: Dup-Lock seqid bad"
8477 				    "lsp->seqid=%d old->seqid=%d",
8478 				    lsp->seqid, olo->lock_seqid));
8479 				*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
8480 			} else {
8481 				rfs4_copy_reply(resop, lsp->reply);
8482 				/*
8483 				 * Make sure to copy the just
8484 				 * retrieved reply status into the
8485 				 * overall compound status
8486 				 */
8487 				*cs->statusp = resp->status;
8488 			}
8489 			rfs4_lockowner_rele(lo);
8490 			goto end;
8491 		}
8492 
8493 		rfs4_dbe_lock(lsp->dbe);
8494 
8495 		/* Make sure to update the lock sequence id */
8496 		lsp->seqid = olo->lock_seqid;
8497 
8498 		NFS4_DEBUG(rfs4_debug,
8499 		    (CE_NOTE, "Lock seqid established as %d", lsp->seqid));
8500 
8501 		/*
8502 		 * This is used to signify the newly created lockowner
8503 		 * stateid and its sequence number.  The checks for
8504 		 * sequence number and increment don't occur on the
8505 		 * very first lock request for a lockowner.
8506 		 */
8507 		lsp->skip_seqid_check = TRUE;
8508 
8509 		/* hold off other access to lsp while we tinker */
8510 		rfs4_sw_enter(&lsp->ls_sw);
8511 		ls_sw_held = TRUE;
8512 
8513 		rfs4_dbe_unlock(lsp->dbe);
8514 
8515 		rfs4_lockowner_rele(lo);
8516 	} else {
8517 		stateid = &args->locker.locker4_u.lock_owner.lock_stateid;
8518 		/* get lsp and hold the lock on the underlying file struct */
8519 		if ((status = rfs4_get_lo_state(stateid, &lsp, TRUE))
8520 		    != NFS4_OK) {
8521 			*cs->statusp = resp->status = status;
8522 			DTRACE_NFSV4_2(op__lock__done, struct compound_state *,
8523 			    cs, LOCK4res *, resp);
8524 			return;
8525 		}
8526 		create = FALSE;	/* We didn't create lsp */
8527 
8528 		/* Ensure specified filehandle matches */
8529 		if (cs->vp != lsp->state->finfo->vp) {
8530 			rfs4_lo_state_rele(lsp, TRUE);
8531 			*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
8532 			DTRACE_NFSV4_2(op__lock__done, struct compound_state *,
8533 			    cs, LOCK4res *, resp);
8534 			return;
8535 		}
8536 
8537 		/* hold off other access to lsp while we tinker */
8538 		rfs4_sw_enter(&lsp->ls_sw);
8539 		ls_sw_held = TRUE;
8540 
8541 		switch (rfs4_check_lo_stateid_seqid(lsp, stateid)) {
8542 		/*
8543 		 * The stateid looks like it was okay (expected to be
8544 		 * the next one)
8545 		 */
8546 		case NFS4_CHECK_STATEID_OKAY:
8547 			/*
8548 			 * The sequence id is now checked.  Determine
8549 			 * if this is a replay or if it is in the
8550 			 * expected (next) sequence.  In the case of a
8551 			 * replay, there are two replay conditions
8552 			 * that may occur.  The first is the normal
8553 			 * condition where a LOCK is done with a
8554 			 * NFS4_OK response and the stateid is
8555 			 * updated.  That case is handled below when
8556 			 * the stateid is identified as a REPLAY.  The
8557 			 * second is the case where an error is
8558 			 * returned, like NFS4ERR_DENIED, and the
8559 			 * sequence number is updated but the stateid
8560 			 * is not updated.  This second case is dealt
8561 			 * with here.  So it may seem odd that the
8562 			 * stateid is okay but the sequence id is a
8563 			 * replay but it is okay.
8564 			 */
8565 			switch (rfs4_check_lock_seqid(
8566 			    args->locker.locker4_u.lock_owner.lock_seqid,
8567 			    lsp, resop)) {
8568 			case NFS4_CHKSEQ_REPLAY:
8569 				if (resp->status != NFS4_OK) {
8570 					/*
8571 					 * Here is our replay and need
8572 					 * to verify that the last
8573 					 * response was an error.
8574 					 */
8575 					*cs->statusp = resp->status;
8576 					goto end;
8577 				}
8578 				/*
8579 				 * This is done since the sequence id
8580 				 * looked like a replay but it didn't
8581 				 * pass our check so a BAD_SEQID is
8582 				 * returned as a result.
8583 				 */
8584 				/*FALLTHROUGH*/
8585 			case NFS4_CHKSEQ_BAD:
8586 				*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
8587 				goto end;
8588 			case NFS4_CHKSEQ_OKAY:
8589 				/* Everything looks okay move ahead */
8590 				break;
8591 			}
8592 			break;
8593 		case NFS4_CHECK_STATEID_OLD:
8594 			*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
8595 			goto end;
8596 		case NFS4_CHECK_STATEID_BAD:
8597 			*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
8598 			goto end;
8599 		case NFS4_CHECK_STATEID_EXPIRED:
8600 			*cs->statusp = resp->status = NFS4ERR_EXPIRED;
8601 			goto end;
8602 		case NFS4_CHECK_STATEID_CLOSED:
8603 			*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
8604 			goto end;
8605 		case NFS4_CHECK_STATEID_REPLAY:
8606 			switch (rfs4_check_lock_seqid(
8607 			    args->locker.locker4_u.lock_owner.lock_seqid,
8608 			    lsp, resop)) {
8609 			case NFS4_CHKSEQ_OKAY:
8610 				/*
8611 				 * This is a replayed stateid; if
8612 				 * seqid matches the next expected,
8613 				 * then client is using wrong seqid.
8614 				 */
8615 			case NFS4_CHKSEQ_BAD:
8616 				*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
8617 				goto end;
8618 			case NFS4_CHKSEQ_REPLAY:
8619 				rfs4_update_lease(lsp->locker->client);
8620 				*cs->statusp = status = resp->status;
8621 				goto end;
8622 			}
8623 			break;
8624 		default:
8625 			ASSERT(FALSE);
8626 			break;
8627 		}
8628 
8629 		rfs4_update_lock_sequence(lsp);
8630 		rfs4_update_lease(lsp->locker->client);
8631 	}
8632 
8633 	/*
8634 	 * NFS4 only allows locking on regular files, so
8635 	 * verify type of object.
8636 	 */
8637 	if (cs->vp->v_type != VREG) {
8638 		if (cs->vp->v_type == VDIR)
8639 			status = NFS4ERR_ISDIR;
8640 		else
8641 			status = NFS4ERR_INVAL;
8642 		goto out;
8643 	}
8644 
8645 	cp = lsp->state->owner->client;
8646 
8647 	if (rfs4_clnt_in_grace(cp) && !args->reclaim) {
8648 		status = NFS4ERR_GRACE;
8649 		goto out;
8650 	}
8651 
8652 	if (rfs4_clnt_in_grace(cp) && args->reclaim && !cp->can_reclaim) {
8653 		status = NFS4ERR_NO_GRACE;
8654 		goto out;
8655 	}
8656 
8657 	if (!rfs4_clnt_in_grace(cp) && args->reclaim) {
8658 		status = NFS4ERR_NO_GRACE;
8659 		goto out;
8660 	}
8661 
8662 	if (lsp->state->finfo->dinfo->dtype == OPEN_DELEGATE_WRITE)
8663 		cs->deleg = TRUE;
8664 
8665 	status = rfs4_do_lock(lsp, args->locktype,
8666 	    args->locker.locker4_u.lock_owner.lock_seqid,
8667 	    args->offset, args->length, cs->cr, resop);
8668 
8669 out:
8670 	lsp->skip_seqid_check = FALSE;
8671 
8672 	*cs->statusp = resp->status = status;
8673 
8674 	if (status == NFS4_OK) {
8675 		resp->LOCK4res_u.lock_stateid = lsp->lockid.stateid;
8676 		lsp->lock_completed = TRUE;
8677 	}
8678 	/*
8679 	 * Only update the "OPEN" response here if this was a new
8680 	 * lock_owner
8681 	 */
8682 	if (sp)
8683 		rfs4_update_open_resp(sp->owner, resop, NULL);
8684 
8685 	rfs4_update_lock_resp(lsp, resop);
8686 
8687 end:
8688 	if (lsp) {
8689 		if (ls_sw_held)
8690 			rfs4_sw_exit(&lsp->ls_sw);
8691 		/*
8692 		 * If an sp obtained, then the lsp does not represent
8693 		 * a lock on the file struct.
8694 		 */
8695 		if (sp != NULL)
8696 			rfs4_lo_state_rele(lsp, FALSE);
8697 		else
8698 			rfs4_lo_state_rele(lsp, TRUE);
8699 	}
8700 	if (sp) {
8701 		rfs4_sw_exit(&sp->owner->oo_sw);
8702 		rfs4_state_rele(sp);
8703 	}
8704 
8705 	DTRACE_NFSV4_2(op__lock__done, struct compound_state *, cs,
8706 	    LOCK4res *, resp);
8707 }
8708 
8709 /* free function for LOCK/LOCKT */
8710 static void
8711 lock_denied_free(nfs_resop4 *resop)
8712 {
8713 	LOCK4denied *dp = NULL;
8714 
8715 	switch (resop->resop) {
8716 	case OP_LOCK:
8717 		if (resop->nfs_resop4_u.oplock.status == NFS4ERR_DENIED)
8718 			dp = &resop->nfs_resop4_u.oplock.LOCK4res_u.denied;
8719 		break;
8720 	case OP_LOCKT:
8721 		if (resop->nfs_resop4_u.oplockt.status == NFS4ERR_DENIED)
8722 			dp = &resop->nfs_resop4_u.oplockt.denied;
8723 		break;
8724 	default:
8725 		break;
8726 	}
8727 
8728 	if (dp)
8729 		kmem_free(dp->owner.owner_val, dp->owner.owner_len);
8730 }
8731 
8732 /*ARGSUSED*/
8733 void
8734 rfs4_op_locku(nfs_argop4 *argop, nfs_resop4 *resop,
8735 	    struct svc_req *req, struct compound_state *cs)
8736 {
8737 	LOCKU4args *args = &argop->nfs_argop4_u.oplocku;
8738 	LOCKU4res *resp = &resop->nfs_resop4_u.oplocku;
8739 	nfsstat4 status;
8740 	stateid4 *stateid = &args->lock_stateid;
8741 	rfs4_lo_state_t *lsp;
8742 
8743 	DTRACE_NFSV4_2(op__locku__start, struct compound_state *, cs,
8744 	    LOCKU4args *, args);
8745 
8746 	if (cs->vp == NULL) {
8747 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
8748 		DTRACE_NFSV4_2(op__locku__done, struct compound_state *, cs,
8749 		    LOCKU4res *, resp);
8750 		return;
8751 	}
8752 
8753 	if ((status = rfs4_get_lo_state(stateid, &lsp, TRUE)) != NFS4_OK) {
8754 		*cs->statusp = resp->status = status;
8755 		DTRACE_NFSV4_2(op__locku__done, struct compound_state *, cs,
8756 		    LOCKU4res *, resp);
8757 		return;
8758 	}
8759 
8760 	/* Ensure specified filehandle matches */
8761 	if (cs->vp != lsp->state->finfo->vp) {
8762 		rfs4_lo_state_rele(lsp, TRUE);
8763 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
8764 		DTRACE_NFSV4_2(op__locku__done, struct compound_state *, cs,
8765 		    LOCKU4res *, resp);
8766 		return;
8767 	}
8768 
8769 	/* hold off other access to lsp while we tinker */
8770 	rfs4_sw_enter(&lsp->ls_sw);
8771 
8772 	switch (rfs4_check_lo_stateid_seqid(lsp, stateid)) {
8773 	case NFS4_CHECK_STATEID_OKAY:
8774 		if (rfs4_check_lock_seqid(args->seqid, lsp, resop)
8775 		    != NFS4_CHKSEQ_OKAY) {
8776 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
8777 			goto end;
8778 		}
8779 		break;
8780 	case NFS4_CHECK_STATEID_OLD:
8781 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
8782 		goto end;
8783 	case NFS4_CHECK_STATEID_BAD:
8784 		*cs->statusp = resp->status = NFS4ERR_BAD_STATEID;
8785 		goto end;
8786 	case NFS4_CHECK_STATEID_EXPIRED:
8787 		*cs->statusp = resp->status = NFS4ERR_EXPIRED;
8788 		goto end;
8789 	case NFS4_CHECK_STATEID_CLOSED:
8790 		*cs->statusp = resp->status = NFS4ERR_OLD_STATEID;
8791 		goto end;
8792 	case NFS4_CHECK_STATEID_REPLAY:
8793 		switch (rfs4_check_lock_seqid(args->seqid, lsp, resop)) {
8794 		case NFS4_CHKSEQ_OKAY:
8795 				/*
8796 				 * This is a replayed stateid; if
8797 				 * seqid matches the next expected,
8798 				 * then client is using wrong seqid.
8799 				 */
8800 		case NFS4_CHKSEQ_BAD:
8801 			*cs->statusp = resp->status = NFS4ERR_BAD_SEQID;
8802 			goto end;
8803 		case NFS4_CHKSEQ_REPLAY:
8804 			rfs4_update_lease(lsp->locker->client);
8805 			*cs->statusp = status = resp->status;
8806 			goto end;
8807 		}
8808 		break;
8809 	default:
8810 		ASSERT(FALSE);
8811 		break;
8812 	}
8813 
8814 	rfs4_update_lock_sequence(lsp);
8815 	rfs4_update_lease(lsp->locker->client);
8816 
8817 	/*
8818 	 * NFS4 only allows locking on regular files, so
8819 	 * verify type of object.
8820 	 */
8821 	if (cs->vp->v_type != VREG) {
8822 		if (cs->vp->v_type == VDIR)
8823 			status = NFS4ERR_ISDIR;
8824 		else
8825 			status = NFS4ERR_INVAL;
8826 		goto out;
8827 	}
8828 
8829 	if (rfs4_clnt_in_grace(lsp->state->owner->client)) {
8830 		status = NFS4ERR_GRACE;
8831 		goto out;
8832 	}
8833 
8834 	status = rfs4_do_lock(lsp, args->locktype,
8835 	    args->seqid, args->offset, args->length, cs->cr, resop);
8836 
8837 out:
8838 	*cs->statusp = resp->status = status;
8839 
8840 	if (status == NFS4_OK)
8841 		resp->lock_stateid = lsp->lockid.stateid;
8842 
8843 	rfs4_update_lock_resp(lsp, resop);
8844 
8845 end:
8846 	rfs4_sw_exit(&lsp->ls_sw);
8847 	rfs4_lo_state_rele(lsp, TRUE);
8848 
8849 	DTRACE_NFSV4_2(op__locku__done, struct compound_state *, cs,
8850 	    LOCKU4res *, resp);
8851 }
8852 
8853 /*
8854  * LOCKT is a best effort routine, the client can not be guaranteed that
8855  * the status return is still in effect by the time the reply is received.
8856  * They are numerous race conditions in this routine, but we are not required
8857  * and can not be accurate.
8858  */
8859 /*ARGSUSED*/
8860 void
8861 rfs4_op_lockt(nfs_argop4 *argop, nfs_resop4 *resop,
8862 	    struct svc_req *req, struct compound_state *cs)
8863 {
8864 	LOCKT4args *args = &argop->nfs_argop4_u.oplockt;
8865 	LOCKT4res *resp = &resop->nfs_resop4_u.oplockt;
8866 	rfs4_lockowner_t *lo;
8867 	rfs4_client_t *cp;
8868 	bool_t create = FALSE;
8869 	struct flock64 flk;
8870 	int error;
8871 	int flag = FREAD | FWRITE;
8872 	int ltype;
8873 	length4 posix_length;
8874 	sysid_t sysid;
8875 	pid_t pid;
8876 
8877 	DTRACE_NFSV4_2(op__lockt__start, struct compound_state *, cs,
8878 	    LOCKT4args *, args);
8879 
8880 	if (cs->vp == NULL) {
8881 		*cs->statusp = resp->status = NFS4ERR_NOFILEHANDLE;
8882 		goto out;
8883 	}
8884 
8885 	/*
8886 	 * NFS4 only allows locking on regular files, so
8887 	 * verify type of object.
8888 	 */
8889 	if (cs->vp->v_type != VREG) {
8890 		if (cs->vp->v_type == VDIR)
8891 			*cs->statusp = resp->status = NFS4ERR_ISDIR;
8892 		else
8893 			*cs->statusp = resp->status =  NFS4ERR_INVAL;
8894 		goto out;
8895 	}
8896 
8897 	/*
8898 	 * Check out the clientid to ensure the server knows about it
8899 	 * so that we correctly inform the client of a server reboot.
8900 	 */
8901 	if ((cp = rfs4_findclient_by_id(args->owner.clientid, FALSE))
8902 	    == NULL) {
8903 		*cs->statusp = resp->status =
8904 		    rfs4_check_clientid(&args->owner.clientid, 0);
8905 		goto out;
8906 	}
8907 	if (rfs4_lease_expired(cp)) {
8908 		rfs4_client_close(cp);
8909 		/*
8910 		 * Protocol doesn't allow returning NFS4ERR_STALE as
8911 		 * other operations do on this check so STALE_CLIENTID
8912 		 * is returned instead
8913 		 */
8914 		*cs->statusp = resp->status = NFS4ERR_STALE_CLIENTID;
8915 		goto out;
8916 	}
8917 
8918 	if (rfs4_clnt_in_grace(cp) && !(cp->can_reclaim)) {
8919 		*cs->statusp = resp->status = NFS4ERR_GRACE;
8920 		rfs4_client_rele(cp);
8921 		goto out;
8922 	}
8923 	rfs4_client_rele(cp);
8924 
8925 	resp->status = NFS4_OK;
8926 
8927 	switch (args->locktype) {
8928 	case READ_LT:
8929 	case READW_LT:
8930 		ltype = F_RDLCK;
8931 		break;
8932 	case WRITE_LT:
8933 	case WRITEW_LT:
8934 		ltype = F_WRLCK;
8935 		break;
8936 	}
8937 
8938 	posix_length = args->length;
8939 	/* Check for zero length. To lock to end of file use all ones for V4 */
8940 	if (posix_length == 0) {
8941 		*cs->statusp = resp->status = NFS4ERR_INVAL;
8942 		goto out;
8943 	} else if (posix_length == (length4)(~0)) {
8944 		posix_length = 0;	/* Posix to end of file  */
8945 	}
8946 
8947 	/* Find or create a lockowner */
8948 	lo = rfs4_findlockowner(&args->owner, &create);
8949 
8950 	if (lo) {
8951 		pid = lo->pid;
8952 		if ((resp->status =
8953 		    rfs4_client_sysid(lo->client, &sysid)) != NFS4_OK)
8954 			goto err;
8955 	} else {
8956 		pid = 0;
8957 		sysid = lockt_sysid;
8958 	}
8959 retry:
8960 	flk.l_type = ltype;
8961 	flk.l_whence = 0;		/* SEEK_SET */
8962 	flk.l_start = args->offset;
8963 	flk.l_len = posix_length;
8964 	flk.l_sysid = sysid;
8965 	flk.l_pid = pid;
8966 	flag |= F_REMOTELOCK;
8967 
8968 	LOCK_PRINT(rfs4_debug, "rfs4_op_lockt", F_GETLK, &flk);
8969 
8970 	/* Note that length4 is uint64_t but l_len and l_start are off64_t */
8971 	if (flk.l_len < 0 || flk.l_start < 0) {
8972 		resp->status = NFS4ERR_INVAL;
8973 		goto err;
8974 	}
8975 	error = VOP_FRLOCK(cs->vp, F_GETLK, &flk, flag, (u_offset_t)0,
8976 	    NULL, cs->cr, NULL);
8977 
8978 	/*
8979 	 * N.B. We map error values to nfsv4 errors. This is differrent
8980 	 * than puterrno4 routine.
8981 	 */
8982 	switch (error) {
8983 	case 0:
8984 		if (flk.l_type == F_UNLCK)
8985 			resp->status = NFS4_OK;
8986 		else {
8987 			if (lock_denied(&resp->denied, &flk) == NFS4ERR_EXPIRED)
8988 				goto retry;
8989 			resp->status = NFS4ERR_DENIED;
8990 		}
8991 		break;
8992 	case EOVERFLOW:
8993 		resp->status = NFS4ERR_INVAL;
8994 		break;
8995 	case EINVAL:
8996 		resp->status = NFS4ERR_NOTSUPP;
8997 		break;
8998 	default:
8999 		cmn_err(CE_WARN, "rfs4_op_lockt: unexpected errno (%d)",
9000 		    error);
9001 		resp->status = NFS4ERR_SERVERFAULT;
9002 		break;
9003 	}
9004 
9005 err:
9006 	if (lo)
9007 		rfs4_lockowner_rele(lo);
9008 	*cs->statusp = resp->status;
9009 out:
9010 	DTRACE_NFSV4_2(op__lockt__done, struct compound_state *, cs,
9011 	    LOCKT4res *, resp);
9012 }
9013 
9014 static int
9015 vop_shrlock(vnode_t *vp, int cmd, struct shrlock *sp, int fflags)
9016 {
9017 	int err;
9018 
9019 	if (cmd == F_UNSHARE && sp->s_deny == 0 && sp->s_access == 0)
9020 		return (0);
9021 
9022 	err = VOP_SHRLOCK(vp, cmd, sp, fflags, CRED(), NULL);
9023 
9024 	NFS4_DEBUG(rfs4_shrlock_debug,
9025 	    (CE_NOTE, "rfs4_shrlock %s vp=%p acc=%d dny=%d sysid=%d "
9026 	    "pid=%d err=%d\n", cmd == F_UNSHARE ? "UNSHR" : "SHARE",
9027 	    (void *) vp, sp->s_access, sp->s_deny, sp->s_sysid, sp->s_pid,
9028 	    err));
9029 
9030 	return (err);
9031 }
9032 
9033 static int
9034 rfs4_shrlock(rfs4_state_t *sp, int cmd)
9035 {
9036 	struct shrlock shr;
9037 	struct shr_locowner shr_loco;
9038 	int fflags;
9039 
9040 	fflags = shr.s_access = shr.s_deny = 0;
9041 
9042 	if (sp->share_access & OPEN4_SHARE_ACCESS_READ) {
9043 		fflags |= FREAD;
9044 		shr.s_access |= F_RDACC;
9045 	}
9046 	if (sp->share_access & OPEN4_SHARE_ACCESS_WRITE) {
9047 		fflags |= FWRITE;
9048 		shr.s_access |= F_WRACC;
9049 	}
9050 	if (sp->share_deny & OPEN4_SHARE_DENY_READ)
9051 		shr.s_deny |= F_RDDNY;
9052 	if (sp->share_deny & OPEN4_SHARE_DENY_WRITE)
9053 		shr.s_deny |= F_WRDNY;
9054 
9055 	shr.s_pid = rfs4_dbe_getid(sp->owner->dbe);
9056 	shr.s_sysid = sp->owner->client->sysidt;
9057 	shr_loco.sl_pid = shr.s_pid;
9058 	shr_loco.sl_id = shr.s_sysid;
9059 	shr.s_owner = (caddr_t)&shr_loco;
9060 	shr.s_own_len = sizeof (shr_loco);
9061 	return (vop_shrlock(sp->finfo->vp, cmd, &shr, fflags));
9062 }
9063 
9064 static int
9065 rfs4_share(rfs4_state_t *sp)
9066 {
9067 	int cmd;
9068 	cmd = nbl_need_check(sp->finfo->vp) ? F_SHARE_NBMAND : F_SHARE;
9069 	return (rfs4_shrlock(sp, cmd));
9070 }
9071 
9072 void
9073 rfs4_unshare(rfs4_state_t *sp)
9074 {
9075 	(void) rfs4_shrlock(sp, F_UNSHARE);
9076 }
9077