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