xref: /titanic_41/usr/src/uts/common/fs/nfs/nfs_subr.c (revision 8d62b2231107e557adb17ea75579d9c49511457b)
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 2010 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * Copyright 2011 Nexenta Systems, Inc. All rights reserved.
28  */
29 
30 #include <sys/param.h>
31 #include <sys/types.h>
32 #include <sys/systm.h>
33 #include <sys/cred.h>
34 #include <sys/proc.h>
35 #include <sys/user.h>
36 #include <sys/time.h>
37 #include <sys/buf.h>
38 #include <sys/vfs.h>
39 #include <sys/vnode.h>
40 #include <sys/socket.h>
41 #include <sys/uio.h>
42 #include <sys/tiuser.h>
43 #include <sys/swap.h>
44 #include <sys/errno.h>
45 #include <sys/debug.h>
46 #include <sys/kmem.h>
47 #include <sys/kstat.h>
48 #include <sys/cmn_err.h>
49 #include <sys/vtrace.h>
50 #include <sys/session.h>
51 #include <sys/dnlc.h>
52 #include <sys/bitmap.h>
53 #include <sys/acl.h>
54 #include <sys/ddi.h>
55 #include <sys/pathname.h>
56 #include <sys/flock.h>
57 #include <sys/dirent.h>
58 #include <sys/flock.h>
59 #include <sys/callb.h>
60 #include <sys/atomic.h>
61 #include <sys/list.h>
62 #include <sys/tsol/tnet.h>
63 #include <sys/priv.h>
64 #include <sys/sdt.h>
65 #include <sys/attr.h>
66 
67 #include <inet/ip6.h>
68 
69 #include <rpc/types.h>
70 #include <rpc/xdr.h>
71 #include <rpc/auth.h>
72 #include <rpc/clnt.h>
73 
74 #include <nfs/nfs.h>
75 #include <nfs/nfs4.h>
76 #include <nfs/nfs_clnt.h>
77 #include <nfs/rnode.h>
78 #include <nfs/nfs_acl.h>
79 
80 #include <sys/tsol/label.h>
81 
82 /*
83  * The hash queues for the access to active and cached rnodes
84  * are organized as doubly linked lists.  A reader/writer lock
85  * for each hash bucket is used to control access and to synchronize
86  * lookups, additions, and deletions from the hash queue.
87  *
88  * The rnode freelist is organized as a doubly linked list with
89  * a head pointer.  Additions and deletions are synchronized via
90  * a single mutex.
91  *
92  * In order to add an rnode to the free list, it must be hashed into
93  * a hash queue and the exclusive lock to the hash queue be held.
94  * If an rnode is not hashed into a hash queue, then it is destroyed
95  * because it represents no valuable information that can be reused
96  * about the file.  The exclusive lock to the hash queue must be
97  * held in order to prevent a lookup in the hash queue from finding
98  * the rnode and using it and assuming that the rnode is not on the
99  * freelist.  The lookup in the hash queue will have the hash queue
100  * locked, either exclusive or shared.
101  *
102  * The vnode reference count for each rnode is not allowed to drop
103  * below 1.  This prevents external entities, such as the VM
104  * subsystem, from acquiring references to vnodes already on the
105  * freelist and then trying to place them back on the freelist
106  * when their reference is released.  This means that the when an
107  * rnode is looked up in the hash queues, then either the rnode
108  * is removed from the freelist and that reference is transferred to
109  * the new reference or the vnode reference count must be incremented
110  * accordingly.  The mutex for the freelist must be held in order to
111  * accurately test to see if the rnode is on the freelist or not.
112  * The hash queue lock might be held shared and it is possible that
113  * two different threads may race to remove the rnode from the
114  * freelist.  This race can be resolved by holding the mutex for the
115  * freelist.  Please note that the mutex for the freelist does not
116  * need to held if the rnode is not on the freelist.  It can not be
117  * placed on the freelist due to the requirement that the thread
118  * putting the rnode on the freelist must hold the exclusive lock
119  * to the hash queue and the thread doing the lookup in the hash
120  * queue is holding either a shared or exclusive lock to the hash
121  * queue.
122  *
123  * The lock ordering is:
124  *
125  *	hash bucket lock -> vnode lock
126  *	hash bucket lock -> freelist lock
127  */
128 static rhashq_t *rtable;
129 
130 static kmutex_t rpfreelist_lock;
131 static rnode_t *rpfreelist = NULL;
132 static long rnew = 0;
133 long nrnode = 0;
134 
135 static int rtablesize;
136 static int rtablemask;
137 
138 static int hashlen = 4;
139 
140 static struct kmem_cache *rnode_cache;
141 
142 /*
143  * Mutex to protect the following variables:
144  *	nfs_major
145  *	nfs_minor
146  */
147 kmutex_t nfs_minor_lock;
148 int nfs_major;
149 int nfs_minor;
150 
151 /* Do we allow preepoch (negative) time values otw? */
152 bool_t nfs_allow_preepoch_time = FALSE;	/* default: do not allow preepoch */
153 
154 /*
155  * Access cache
156  */
157 static acache_hash_t *acache;
158 static long nacache;	/* used strictly to size the number of hash queues */
159 
160 static int acachesize;
161 static int acachemask;
162 static struct kmem_cache *acache_cache;
163 
164 /*
165  * Client side utilities
166  */
167 
168 /*
169  * client side statistics
170  */
171 static const struct clstat clstat_tmpl = {
172 	{ "calls",	KSTAT_DATA_UINT64 },
173 	{ "badcalls",	KSTAT_DATA_UINT64 },
174 	{ "clgets",	KSTAT_DATA_UINT64 },
175 	{ "cltoomany",	KSTAT_DATA_UINT64 },
176 #ifdef DEBUG
177 	{ "clalloc",	KSTAT_DATA_UINT64 },
178 	{ "noresponse",	KSTAT_DATA_UINT64 },
179 	{ "failover",	KSTAT_DATA_UINT64 },
180 	{ "remap",	KSTAT_DATA_UINT64 },
181 #endif
182 };
183 
184 /*
185  * The following are statistics that describe behavior of the system as a whole
186  * and doesn't correspond to any one particular zone.
187  */
188 #ifdef DEBUG
189 static struct clstat_debug {
190 	kstat_named_t	nrnode;			/* number of allocated rnodes */
191 	kstat_named_t	access;			/* size of access cache */
192 	kstat_named_t	dirent;			/* size of readdir cache */
193 	kstat_named_t	dirents;		/* size of readdir buf cache */
194 	kstat_named_t	reclaim;		/* number of reclaims */
195 	kstat_named_t	clreclaim;		/* number of cl reclaims */
196 	kstat_named_t	f_reclaim;		/* number of free reclaims */
197 	kstat_named_t	a_reclaim;		/* number of active reclaims */
198 	kstat_named_t	r_reclaim;		/* number of rnode reclaims */
199 	kstat_named_t	rpath;			/* bytes used to store rpaths */
200 } clstat_debug = {
201 	{ "nrnode",	KSTAT_DATA_UINT64 },
202 	{ "access",	KSTAT_DATA_UINT64 },
203 	{ "dirent",	KSTAT_DATA_UINT64 },
204 	{ "dirents",	KSTAT_DATA_UINT64 },
205 	{ "reclaim",	KSTAT_DATA_UINT64 },
206 	{ "clreclaim",	KSTAT_DATA_UINT64 },
207 	{ "f_reclaim",	KSTAT_DATA_UINT64 },
208 	{ "a_reclaim",	KSTAT_DATA_UINT64 },
209 	{ "r_reclaim",	KSTAT_DATA_UINT64 },
210 	{ "r_path",	KSTAT_DATA_UINT64 },
211 };
212 #endif	/* DEBUG */
213 
214 /*
215  * We keep a global list of per-zone client data, so we can clean up all zones
216  * if we get low on memory.
217  */
218 static list_t nfs_clnt_list;
219 static kmutex_t nfs_clnt_list_lock;
220 static zone_key_t nfsclnt_zone_key;
221 
222 static struct kmem_cache *chtab_cache;
223 
224 /*
225  * Some servers do not properly update the attributes of the
226  * directory when changes are made.  To allow interoperability
227  * with these broken servers, the nfs_disable_rddir_cache
228  * parameter must be set in /etc/system
229  */
230 int nfs_disable_rddir_cache = 0;
231 
232 int		clget(clinfo_t *, servinfo_t *, cred_t *, CLIENT **,
233 		    struct chtab **);
234 void		clfree(CLIENT *, struct chtab *);
235 static int	acl_clget(mntinfo_t *, servinfo_t *, cred_t *, CLIENT **,
236 		    struct chtab **, struct nfs_clnt *);
237 static int	nfs_clget(mntinfo_t *, servinfo_t *, cred_t *, CLIENT **,
238 		    struct chtab **, struct nfs_clnt *);
239 static void	clreclaim(void *);
240 static int	nfs_feedback(int, int, mntinfo_t *);
241 static int	rfscall(mntinfo_t *, rpcproc_t, xdrproc_t, caddr_t, xdrproc_t,
242 		    caddr_t, cred_t *, int *, enum clnt_stat *, int,
243 		    failinfo_t *);
244 static int	aclcall(mntinfo_t *, rpcproc_t, xdrproc_t, caddr_t, xdrproc_t,
245 		    caddr_t, cred_t *, int *, int, failinfo_t *);
246 static void	rinactive(rnode_t *, cred_t *);
247 static int	rtablehash(nfs_fhandle *);
248 static vnode_t	*make_rnode(nfs_fhandle *, rhashq_t *, struct vfs *,
249 		    struct vnodeops *,
250 		    int (*)(vnode_t *, page_t *, u_offset_t *, size_t *, int,
251 			cred_t *),
252 		    int (*)(const void *, const void *), int *, cred_t *,
253 		    char *, char *);
254 static void	rp_rmfree(rnode_t *);
255 static void	rp_addhash(rnode_t *);
256 static void	rp_rmhash_locked(rnode_t *);
257 static rnode_t	*rfind(rhashq_t *, nfs_fhandle *, struct vfs *);
258 static void	destroy_rnode(rnode_t *);
259 static void	rddir_cache_free(rddir_cache *);
260 static int	nfs_free_data_reclaim(rnode_t *);
261 static int	nfs_active_data_reclaim(rnode_t *);
262 static int	nfs_free_reclaim(void);
263 static int	nfs_active_reclaim(void);
264 static int	nfs_rnode_reclaim(void);
265 static void	nfs_reclaim(void *);
266 static int	failover_safe(failinfo_t *);
267 static void	failover_newserver(mntinfo_t *mi);
268 static void	failover_thread(mntinfo_t *mi);
269 static int	failover_wait(mntinfo_t *);
270 static int	failover_remap(failinfo_t *);
271 static int	failover_lookup(char *, vnode_t *,
272 		    int (*)(vnode_t *, char *, vnode_t **,
273 			struct pathname *, int, vnode_t *, cred_t *, int),
274 		    int (*)(vnode_t *, vnode_t **, bool_t, cred_t *, int),
275 		    vnode_t **);
276 static void	nfs_free_r_path(rnode_t *);
277 static void	nfs_set_vroot(vnode_t *);
278 static char	*nfs_getsrvnames(mntinfo_t *, size_t *);
279 
280 /*
281  * from rpcsec module (common/rpcsec)
282  */
283 extern int sec_clnt_geth(CLIENT *, struct sec_data *, cred_t *, AUTH **);
284 extern void sec_clnt_freeh(AUTH *);
285 extern void sec_clnt_freeinfo(struct sec_data *);
286 
287 /*
288  * used in mount policy
289  */
290 extern ts_label_t *getflabel_cipso(vfs_t *);
291 
292 /*
293  * EIO or EINTR are not recoverable errors.
294  */
295 #define	IS_RECOVERABLE_ERROR(error)	!((error == EINTR) || (error == EIO))
296 
297 #ifdef DEBUG
298 #define	SRV_QFULL_MSG	"send queue to NFS%d server %s is full; still trying\n"
299 #define	SRV_NOTRESP_MSG	"NFS%d server %s not responding still trying\n"
300 #else
301 #define	SRV_QFULL_MSG	"send queue to NFS server %s is full still trying\n"
302 #define	SRV_NOTRESP_MSG	"NFS server %s not responding still trying\n"
303 #endif
304 /*
305  * Common handle get program for NFS, NFS ACL, and NFS AUTH client.
306  */
307 static int
308 clget_impl(clinfo_t *ci, servinfo_t *svp, cred_t *cr, CLIENT **newcl,
309     struct chtab **chp, struct nfs_clnt *nfscl)
310 {
311 	struct chhead *ch, *newch;
312 	struct chhead **plistp;
313 	struct chtab *cp;
314 	int error;
315 	k_sigset_t smask;
316 
317 	if (newcl == NULL || chp == NULL || ci == NULL)
318 		return (EINVAL);
319 
320 	*newcl = NULL;
321 	*chp = NULL;
322 
323 	/*
324 	 * Find an unused handle or create one
325 	 */
326 	newch = NULL;
327 	nfscl->nfscl_stat.clgets.value.ui64++;
328 top:
329 	/*
330 	 * Find the correct entry in the cache to check for free
331 	 * client handles.  The search is based on the RPC program
332 	 * number, program version number, dev_t for the transport
333 	 * device, and the protocol family.
334 	 */
335 	mutex_enter(&nfscl->nfscl_chtable_lock);
336 	plistp = &nfscl->nfscl_chtable;
337 	for (ch = nfscl->nfscl_chtable; ch != NULL; ch = ch->ch_next) {
338 		if (ch->ch_prog == ci->cl_prog &&
339 		    ch->ch_vers == ci->cl_vers &&
340 		    ch->ch_dev == svp->sv_knconf->knc_rdev &&
341 		    (strcmp(ch->ch_protofmly,
342 		    svp->sv_knconf->knc_protofmly) == 0))
343 			break;
344 		plistp = &ch->ch_next;
345 	}
346 
347 	/*
348 	 * If we didn't find a cache entry for this quadruple, then
349 	 * create one.  If we don't have one already preallocated,
350 	 * then drop the cache lock, create one, and then start over.
351 	 * If we did have a preallocated entry, then just add it to
352 	 * the front of the list.
353 	 */
354 	if (ch == NULL) {
355 		if (newch == NULL) {
356 			mutex_exit(&nfscl->nfscl_chtable_lock);
357 			newch = kmem_alloc(sizeof (*newch), KM_SLEEP);
358 			newch->ch_timesused = 0;
359 			newch->ch_prog = ci->cl_prog;
360 			newch->ch_vers = ci->cl_vers;
361 			newch->ch_dev = svp->sv_knconf->knc_rdev;
362 			newch->ch_protofmly = kmem_alloc(
363 			    strlen(svp->sv_knconf->knc_protofmly) + 1,
364 			    KM_SLEEP);
365 			(void) strcpy(newch->ch_protofmly,
366 			    svp->sv_knconf->knc_protofmly);
367 			newch->ch_list = NULL;
368 			goto top;
369 		}
370 		ch = newch;
371 		newch = NULL;
372 		ch->ch_next = nfscl->nfscl_chtable;
373 		nfscl->nfscl_chtable = ch;
374 	/*
375 	 * We found a cache entry, but if it isn't on the front of the
376 	 * list, then move it to the front of the list to try to take
377 	 * advantage of locality of operations.
378 	 */
379 	} else if (ch != nfscl->nfscl_chtable) {
380 		*plistp = ch->ch_next;
381 		ch->ch_next = nfscl->nfscl_chtable;
382 		nfscl->nfscl_chtable = ch;
383 	}
384 
385 	/*
386 	 * If there was a free client handle cached, then remove it
387 	 * from the list, init it, and use it.
388 	 */
389 	if (ch->ch_list != NULL) {
390 		cp = ch->ch_list;
391 		ch->ch_list = cp->ch_list;
392 		mutex_exit(&nfscl->nfscl_chtable_lock);
393 		if (newch != NULL) {
394 			kmem_free(newch->ch_protofmly,
395 			    strlen(newch->ch_protofmly) + 1);
396 			kmem_free(newch, sizeof (*newch));
397 		}
398 		(void) clnt_tli_kinit(cp->ch_client, svp->sv_knconf,
399 		    &svp->sv_addr, ci->cl_readsize, ci->cl_retrans, cr);
400 		error = sec_clnt_geth(cp->ch_client, svp->sv_secdata, cr,
401 		    &cp->ch_client->cl_auth);
402 		if (error || cp->ch_client->cl_auth == NULL) {
403 			CLNT_DESTROY(cp->ch_client);
404 			kmem_cache_free(chtab_cache, cp);
405 			return ((error != 0) ? error : EINTR);
406 		}
407 		ch->ch_timesused++;
408 		*newcl = cp->ch_client;
409 		*chp = cp;
410 		return (0);
411 	}
412 
413 	/*
414 	 * There weren't any free client handles which fit, so allocate
415 	 * a new one and use that.
416 	 */
417 #ifdef DEBUG
418 	atomic_inc_64(&nfscl->nfscl_stat.clalloc.value.ui64);
419 #endif
420 	mutex_exit(&nfscl->nfscl_chtable_lock);
421 
422 	nfscl->nfscl_stat.cltoomany.value.ui64++;
423 	if (newch != NULL) {
424 		kmem_free(newch->ch_protofmly, strlen(newch->ch_protofmly) + 1);
425 		kmem_free(newch, sizeof (*newch));
426 	}
427 
428 	cp = kmem_cache_alloc(chtab_cache, KM_SLEEP);
429 	cp->ch_head = ch;
430 
431 	sigintr(&smask, (int)ci->cl_flags & MI_INT);
432 	error = clnt_tli_kcreate(svp->sv_knconf, &svp->sv_addr, ci->cl_prog,
433 	    ci->cl_vers, ci->cl_readsize, ci->cl_retrans, cr, &cp->ch_client);
434 	sigunintr(&smask);
435 
436 	if (error != 0) {
437 		kmem_cache_free(chtab_cache, cp);
438 #ifdef DEBUG
439 		atomic_dec_64(&nfscl->nfscl_stat.clalloc.value.ui64);
440 #endif
441 		/*
442 		 * Warning is unnecessary if error is EINTR.
443 		 */
444 		if (error != EINTR) {
445 			nfs_cmn_err(error, CE_WARN,
446 			    "clget: couldn't create handle: %m\n");
447 		}
448 		return (error);
449 	}
450 	(void) CLNT_CONTROL(cp->ch_client, CLSET_PROGRESS, NULL);
451 	auth_destroy(cp->ch_client->cl_auth);
452 	error = sec_clnt_geth(cp->ch_client, svp->sv_secdata, cr,
453 	    &cp->ch_client->cl_auth);
454 	if (error || cp->ch_client->cl_auth == NULL) {
455 		CLNT_DESTROY(cp->ch_client);
456 		kmem_cache_free(chtab_cache, cp);
457 #ifdef DEBUG
458 		atomic_dec_64(&nfscl->nfscl_stat.clalloc.value.ui64);
459 #endif
460 		return ((error != 0) ? error : EINTR);
461 	}
462 	ch->ch_timesused++;
463 	*newcl = cp->ch_client;
464 	ASSERT(cp->ch_client->cl_nosignal == FALSE);
465 	*chp = cp;
466 	return (0);
467 }
468 
469 int
470 clget(clinfo_t *ci, servinfo_t *svp, cred_t *cr, CLIENT **newcl,
471     struct chtab **chp)
472 {
473 	struct nfs_clnt *nfscl;
474 
475 	nfscl = zone_getspecific(nfsclnt_zone_key, nfs_zone());
476 	ASSERT(nfscl != NULL);
477 
478 	return (clget_impl(ci, svp, cr, newcl, chp, nfscl));
479 }
480 
481 static int
482 acl_clget(mntinfo_t *mi, servinfo_t *svp, cred_t *cr, CLIENT **newcl,
483     struct chtab **chp, struct nfs_clnt *nfscl)
484 {
485 	clinfo_t ci;
486 	int error;
487 
488 	/*
489 	 * Set read buffer size to rsize
490 	 * and add room for RPC headers.
491 	 */
492 	ci.cl_readsize = mi->mi_tsize;
493 	if (ci.cl_readsize != 0)
494 		ci.cl_readsize += (RPC_MAXDATASIZE - NFS_MAXDATA);
495 
496 	/*
497 	 * If soft mount and server is down just try once.
498 	 * meaning: do not retransmit.
499 	 */
500 	if (!(mi->mi_flags & MI_HARD) && (mi->mi_flags & MI_DOWN))
501 		ci.cl_retrans = 0;
502 	else
503 		ci.cl_retrans = mi->mi_retrans;
504 
505 	ci.cl_prog = NFS_ACL_PROGRAM;
506 	ci.cl_vers = mi->mi_vers;
507 	ci.cl_flags = mi->mi_flags;
508 
509 	/*
510 	 * clget calls sec_clnt_geth() to get an auth handle. For RPCSEC_GSS
511 	 * security flavor, the client tries to establish a security context
512 	 * by contacting the server. If the connection is timed out or reset,
513 	 * e.g. server reboot, we will try again.
514 	 */
515 	do {
516 		error = clget_impl(&ci, svp, cr, newcl, chp, nfscl);
517 
518 		if (error == 0)
519 			break;
520 
521 		/*
522 		 * For forced unmount or zone shutdown, bail out, no retry.
523 		 */
524 		if (FS_OR_ZONE_GONE(mi->mi_vfsp)) {
525 			error = EIO;
526 			break;
527 		}
528 
529 		/* do not retry for softmount */
530 		if (!(mi->mi_flags & MI_HARD))
531 			break;
532 
533 		/* let the caller deal with the failover case */
534 		if (FAILOVER_MOUNT(mi))
535 			break;
536 
537 	} while (error == ETIMEDOUT || error == ECONNRESET);
538 
539 	return (error);
540 }
541 
542 static int
543 nfs_clget(mntinfo_t *mi, servinfo_t *svp, cred_t *cr, CLIENT **newcl,
544     struct chtab **chp, struct nfs_clnt *nfscl)
545 {
546 	clinfo_t ci;
547 	int error;
548 
549 	/*
550 	 * Set read buffer size to rsize
551 	 * and add room for RPC headers.
552 	 */
553 	ci.cl_readsize = mi->mi_tsize;
554 	if (ci.cl_readsize != 0)
555 		ci.cl_readsize += (RPC_MAXDATASIZE - NFS_MAXDATA);
556 
557 	/*
558 	 * If soft mount and server is down just try once.
559 	 * meaning: do not retransmit.
560 	 */
561 	if (!(mi->mi_flags & MI_HARD) && (mi->mi_flags & MI_DOWN))
562 		ci.cl_retrans = 0;
563 	else
564 		ci.cl_retrans = mi->mi_retrans;
565 
566 	ci.cl_prog = mi->mi_prog;
567 	ci.cl_vers = mi->mi_vers;
568 	ci.cl_flags = mi->mi_flags;
569 
570 	/*
571 	 * clget calls sec_clnt_geth() to get an auth handle. For RPCSEC_GSS
572 	 * security flavor, the client tries to establish a security context
573 	 * by contacting the server. If the connection is timed out or reset,
574 	 * e.g. server reboot, we will try again.
575 	 */
576 	do {
577 		error = clget_impl(&ci, svp, cr, newcl, chp, nfscl);
578 
579 		if (error == 0)
580 			break;
581 
582 		/*
583 		 * For forced unmount or zone shutdown, bail out, no retry.
584 		 */
585 		if (FS_OR_ZONE_GONE(mi->mi_vfsp)) {
586 			error = EIO;
587 			break;
588 		}
589 
590 		/* do not retry for softmount */
591 		if (!(mi->mi_flags & MI_HARD))
592 			break;
593 
594 		/* let the caller deal with the failover case */
595 		if (FAILOVER_MOUNT(mi))
596 			break;
597 
598 	} while (error == ETIMEDOUT || error == ECONNRESET);
599 
600 	return (error);
601 }
602 
603 static void
604 clfree_impl(CLIENT *cl, struct chtab *cp, struct nfs_clnt *nfscl)
605 {
606 	if (cl->cl_auth != NULL) {
607 		sec_clnt_freeh(cl->cl_auth);
608 		cl->cl_auth = NULL;
609 	}
610 
611 	/*
612 	 * Timestamp this cache entry so that we know when it was last
613 	 * used.
614 	 */
615 	cp->ch_freed = gethrestime_sec();
616 
617 	/*
618 	 * Add the free client handle to the front of the list.
619 	 * This way, the list will be sorted in youngest to oldest
620 	 * order.
621 	 */
622 	mutex_enter(&nfscl->nfscl_chtable_lock);
623 	cp->ch_list = cp->ch_head->ch_list;
624 	cp->ch_head->ch_list = cp;
625 	mutex_exit(&nfscl->nfscl_chtable_lock);
626 }
627 
628 void
629 clfree(CLIENT *cl, struct chtab *cp)
630 {
631 	struct nfs_clnt *nfscl;
632 
633 	nfscl = zone_getspecific(nfsclnt_zone_key, nfs_zone());
634 	ASSERT(nfscl != NULL);
635 
636 	clfree_impl(cl, cp, nfscl);
637 }
638 
639 #define	CL_HOLDTIME	60	/* time to hold client handles */
640 
641 static void
642 clreclaim_zone(struct nfs_clnt *nfscl, uint_t cl_holdtime)
643 {
644 	struct chhead *ch;
645 	struct chtab *cp;	/* list of objects that can be reclaimed */
646 	struct chtab *cpe;
647 	struct chtab *cpl;
648 	struct chtab **cpp;
649 #ifdef DEBUG
650 	int n = 0;
651 #endif
652 
653 	/*
654 	 * Need to reclaim some memory, so step through the cache
655 	 * looking through the lists for entries which can be freed.
656 	 */
657 	cp = NULL;
658 
659 	mutex_enter(&nfscl->nfscl_chtable_lock);
660 
661 	/*
662 	 * Here we step through each non-NULL quadruple and start to
663 	 * construct the reclaim list pointed to by cp.  Note that
664 	 * cp will contain all eligible chtab entries.  When this traversal
665 	 * completes, chtab entries from the last quadruple will be at the
666 	 * front of cp and entries from previously inspected quadruples have
667 	 * been appended to the rear of cp.
668 	 */
669 	for (ch = nfscl->nfscl_chtable; ch != NULL; ch = ch->ch_next) {
670 		if (ch->ch_list == NULL)
671 			continue;
672 		/*
673 		 * Search each list for entries older then
674 		 * cl_holdtime seconds.  The lists are maintained
675 		 * in youngest to oldest order so that when the
676 		 * first entry is found which is old enough, then
677 		 * all of the rest of the entries on the list will
678 		 * be old enough as well.
679 		 */
680 		cpl = ch->ch_list;
681 		cpp = &ch->ch_list;
682 		while (cpl != NULL &&
683 		    cpl->ch_freed + cl_holdtime > gethrestime_sec()) {
684 			cpp = &cpl->ch_list;
685 			cpl = cpl->ch_list;
686 		}
687 		if (cpl != NULL) {
688 			*cpp = NULL;
689 			if (cp != NULL) {
690 				cpe = cpl;
691 				while (cpe->ch_list != NULL)
692 					cpe = cpe->ch_list;
693 				cpe->ch_list = cp;
694 			}
695 			cp = cpl;
696 		}
697 	}
698 
699 	mutex_exit(&nfscl->nfscl_chtable_lock);
700 
701 	/*
702 	 * If cp is empty, then there is nothing to reclaim here.
703 	 */
704 	if (cp == NULL)
705 		return;
706 
707 	/*
708 	 * Step through the list of entries to free, destroying each client
709 	 * handle and kmem_free'ing the memory for each entry.
710 	 */
711 	while (cp != NULL) {
712 #ifdef DEBUG
713 		n++;
714 #endif
715 		CLNT_DESTROY(cp->ch_client);
716 		cpl = cp->ch_list;
717 		kmem_cache_free(chtab_cache, cp);
718 		cp = cpl;
719 	}
720 
721 #ifdef DEBUG
722 	/*
723 	 * Update clalloc so that nfsstat shows the current number
724 	 * of allocated client handles.
725 	 */
726 	atomic_add_64(&nfscl->nfscl_stat.clalloc.value.ui64, -n);
727 #endif
728 }
729 
730 /* ARGSUSED */
731 static void
732 clreclaim(void *all)
733 {
734 	struct nfs_clnt *nfscl;
735 
736 #ifdef DEBUG
737 	clstat_debug.clreclaim.value.ui64++;
738 #endif
739 	/*
740 	 * The system is low on memory; go through and try to reclaim some from
741 	 * every zone on the system.
742 	 */
743 	mutex_enter(&nfs_clnt_list_lock);
744 	nfscl = list_head(&nfs_clnt_list);
745 	for (; nfscl != NULL; nfscl = list_next(&nfs_clnt_list, nfscl))
746 		clreclaim_zone(nfscl, CL_HOLDTIME);
747 	mutex_exit(&nfs_clnt_list_lock);
748 }
749 
750 /*
751  * Minimum time-out values indexed by call type
752  * These units are in "eights" of a second to avoid multiplies
753  */
754 static unsigned int minimum_timeo[] = {
755 	6, 7, 10
756 };
757 
758 /*
759  * Back off for retransmission timeout, MAXTIMO is in hz of a sec
760  */
761 #define	MAXTIMO	(20*hz)
762 #define	backoff(tim)	(((tim) < MAXTIMO) ? dobackoff(tim) : (tim))
763 #define	dobackoff(tim)	((((tim) << 1) > MAXTIMO) ? MAXTIMO : ((tim) << 1))
764 
765 #define	MIN_NFS_TSIZE 512	/* minimum "chunk" of NFS IO */
766 #define	REDUCE_NFS_TIME (hz/2)	/* rtxcur we try to keep under */
767 #define	INCREASE_NFS_TIME (hz/3*8) /* srtt we try to keep under (scaled*8) */
768 
769 /*
770  * Function called when rfscall notices that we have been
771  * re-transmitting, or when we get a response without retransmissions.
772  * Return 1 if the transfer size was adjusted down - 0 if no change.
773  */
774 static int
775 nfs_feedback(int flag, int which, mntinfo_t *mi)
776 {
777 	int kind;
778 	int r = 0;
779 
780 	mutex_enter(&mi->mi_lock);
781 	if (flag == FEEDBACK_REXMIT1) {
782 		if (mi->mi_timers[NFS_CALLTYPES].rt_rtxcur != 0 &&
783 		    mi->mi_timers[NFS_CALLTYPES].rt_rtxcur < REDUCE_NFS_TIME)
784 			goto done;
785 		if (mi->mi_curread > MIN_NFS_TSIZE) {
786 			mi->mi_curread /= 2;
787 			if (mi->mi_curread < MIN_NFS_TSIZE)
788 				mi->mi_curread = MIN_NFS_TSIZE;
789 			r = 1;
790 		}
791 
792 		if (mi->mi_curwrite > MIN_NFS_TSIZE) {
793 			mi->mi_curwrite /= 2;
794 			if (mi->mi_curwrite < MIN_NFS_TSIZE)
795 				mi->mi_curwrite = MIN_NFS_TSIZE;
796 			r = 1;
797 		}
798 	} else if (flag == FEEDBACK_OK) {
799 		kind = mi->mi_timer_type[which];
800 		if (kind == 0 ||
801 		    mi->mi_timers[kind].rt_srtt >= INCREASE_NFS_TIME)
802 			goto done;
803 		if (kind == 1) {
804 			if (mi->mi_curread >= mi->mi_tsize)
805 				goto done;
806 			mi->mi_curread +=  MIN_NFS_TSIZE;
807 			if (mi->mi_curread > mi->mi_tsize/2)
808 				mi->mi_curread = mi->mi_tsize;
809 		} else if (kind == 2) {
810 			if (mi->mi_curwrite >= mi->mi_stsize)
811 				goto done;
812 			mi->mi_curwrite += MIN_NFS_TSIZE;
813 			if (mi->mi_curwrite > mi->mi_stsize/2)
814 				mi->mi_curwrite = mi->mi_stsize;
815 		}
816 	}
817 done:
818 	mutex_exit(&mi->mi_lock);
819 	return (r);
820 }
821 
822 #ifdef DEBUG
823 static int rfs2call_hits = 0;
824 static int rfs2call_misses = 0;
825 #endif
826 
827 int
828 rfs2call(mntinfo_t *mi, rpcproc_t which, xdrproc_t xdrargs, caddr_t argsp,
829     xdrproc_t xdrres, caddr_t resp, cred_t *cr, int *douprintf,
830     enum nfsstat *statusp, int flags, failinfo_t *fi)
831 {
832 	int rpcerror;
833 	enum clnt_stat rpc_status;
834 
835 	ASSERT(statusp != NULL);
836 
837 	rpcerror = rfscall(mi, which, xdrargs, argsp, xdrres, resp,
838 	    cr, douprintf, &rpc_status, flags, fi);
839 	if (!rpcerror) {
840 		/*
841 		 * See crnetadjust() for comments.
842 		 */
843 		if (*statusp == NFSERR_ACCES &&
844 		    (cr = crnetadjust(cr)) != NULL) {
845 #ifdef DEBUG
846 			rfs2call_hits++;
847 #endif
848 			rpcerror = rfscall(mi, which, xdrargs, argsp, xdrres,
849 			    resp, cr, douprintf, NULL, flags, fi);
850 			crfree(cr);
851 #ifdef DEBUG
852 			if (*statusp == NFSERR_ACCES)
853 				rfs2call_misses++;
854 #endif
855 		}
856 	} else if (rpc_status == RPC_PROCUNAVAIL) {
857 		*statusp = NFSERR_OPNOTSUPP;
858 		rpcerror = 0;
859 	}
860 
861 	return (rpcerror);
862 }
863 
864 #define	NFS3_JUKEBOX_DELAY	10 * hz
865 
866 static clock_t nfs3_jukebox_delay = 0;
867 
868 #ifdef DEBUG
869 static int rfs3call_hits = 0;
870 static int rfs3call_misses = 0;
871 #endif
872 
873 int
874 rfs3call(mntinfo_t *mi, rpcproc_t which, xdrproc_t xdrargs, caddr_t argsp,
875     xdrproc_t xdrres, caddr_t resp, cred_t *cr, int *douprintf,
876     nfsstat3 *statusp, int flags, failinfo_t *fi)
877 {
878 	int rpcerror;
879 	int user_informed;
880 
881 	user_informed = 0;
882 	do {
883 		rpcerror = rfscall(mi, which, xdrargs, argsp, xdrres, resp,
884 		    cr, douprintf, NULL, flags, fi);
885 		if (!rpcerror) {
886 			cred_t *crr;
887 			if (*statusp == NFS3ERR_JUKEBOX) {
888 				if (ttoproc(curthread) == &p0) {
889 					rpcerror = EAGAIN;
890 					break;
891 				}
892 				if (!user_informed) {
893 					user_informed = 1;
894 					uprintf(
895 		"file temporarily unavailable on the server, retrying...\n");
896 				}
897 				delay(nfs3_jukebox_delay);
898 			}
899 			/*
900 			 * See crnetadjust() for comments.
901 			 */
902 			else if (*statusp == NFS3ERR_ACCES &&
903 			    (crr = crnetadjust(cr)) != NULL) {
904 #ifdef DEBUG
905 				rfs3call_hits++;
906 #endif
907 				rpcerror = rfscall(mi, which, xdrargs, argsp,
908 				    xdrres, resp, crr, douprintf,
909 				    NULL, flags, fi);
910 
911 				crfree(crr);
912 #ifdef DEBUG
913 				if (*statusp == NFS3ERR_ACCES)
914 					rfs3call_misses++;
915 #endif
916 			}
917 		}
918 	} while (!rpcerror && *statusp == NFS3ERR_JUKEBOX);
919 
920 	return (rpcerror);
921 }
922 
923 #define	VALID_FH(fi)	(VTOR(fi->vp)->r_server == VTOMI(fi->vp)->mi_curr_serv)
924 #define	INC_READERS(mi)		{ \
925 	mi->mi_readers++; \
926 }
927 #define	DEC_READERS(mi)		{ \
928 	mi->mi_readers--; \
929 	if (mi->mi_readers == 0) \
930 		cv_broadcast(&mi->mi_failover_cv); \
931 }
932 
933 static int
934 rfscall(mntinfo_t *mi, rpcproc_t which, xdrproc_t xdrargs, caddr_t argsp,
935     xdrproc_t xdrres, caddr_t resp, cred_t *icr, int *douprintf,
936     enum clnt_stat *rpc_status, int flags, failinfo_t *fi)
937 {
938 	CLIENT *client;
939 	struct chtab *ch;
940 	cred_t *cr = icr;
941 	enum clnt_stat status;
942 	struct rpc_err rpcerr, rpcerr_tmp;
943 	struct timeval wait;
944 	int timeo;		/* in units of hz */
945 	int my_rsize, my_wsize;
946 	bool_t tryagain;
947 	bool_t cred_cloned = FALSE;
948 	k_sigset_t smask;
949 	servinfo_t *svp;
950 	struct nfs_clnt *nfscl;
951 	zoneid_t zoneid = getzoneid();
952 	char *msg;
953 #ifdef DEBUG
954 	char *bufp;
955 #endif
956 
957 
958 	TRACE_2(TR_FAC_NFS, TR_RFSCALL_START,
959 	    "rfscall_start:which %d mi %p", which, mi);
960 
961 	nfscl = zone_getspecific(nfsclnt_zone_key, nfs_zone());
962 	ASSERT(nfscl != NULL);
963 
964 	nfscl->nfscl_stat.calls.value.ui64++;
965 	mi->mi_reqs[which].value.ui64++;
966 
967 	rpcerr.re_status = RPC_SUCCESS;
968 
969 	/*
970 	 * In case of forced unmount or zone shutdown, return EIO.
971 	 */
972 
973 	if (FS_OR_ZONE_GONE(mi->mi_vfsp)) {
974 		rpcerr.re_status = RPC_FAILED;
975 		rpcerr.re_errno = EIO;
976 		return (rpcerr.re_errno);
977 	}
978 
979 	/*
980 	 * Remember the transfer sizes in case
981 	 * nfs_feedback changes them underneath us.
982 	 */
983 	my_rsize = mi->mi_curread;
984 	my_wsize = mi->mi_curwrite;
985 
986 	/*
987 	 * NFS client failover support
988 	 *
989 	 * If this rnode is not in sync with the current server (VALID_FH),
990 	 * we'd like to do a remap to get in sync.  We can be interrupted
991 	 * in failover_remap(), and if so we'll bail.  Otherwise, we'll
992 	 * use the best info we have to try the RPC.  Part of that is
993 	 * unconditionally updating the filehandle copy kept for V3.
994 	 *
995 	 * Locking: INC_READERS/DEC_READERS is a poor man's interrruptible
996 	 * rw_enter(); we're trying to keep the current server from being
997 	 * changed on us until we're done with the remapping and have a
998 	 * matching client handle.  We don't want to sending a filehandle
999 	 * to the wrong host.
1000 	 */
1001 failoverretry:
1002 	if (FAILOVER_MOUNT(mi)) {
1003 		mutex_enter(&mi->mi_lock);
1004 		if (!(flags & RFSCALL_SOFT) && failover_safe(fi)) {
1005 			if (failover_wait(mi)) {
1006 				mutex_exit(&mi->mi_lock);
1007 				return (EINTR);
1008 			}
1009 		}
1010 		INC_READERS(mi);
1011 		mutex_exit(&mi->mi_lock);
1012 		if (fi) {
1013 			if (!VALID_FH(fi) &&
1014 			    !(flags & RFSCALL_SOFT) && failover_safe(fi)) {
1015 				int remaperr;
1016 
1017 				svp = mi->mi_curr_serv;
1018 				remaperr = failover_remap(fi);
1019 				if (remaperr != 0) {
1020 #ifdef DEBUG
1021 					if (remaperr != EINTR)
1022 						nfs_cmn_err(remaperr, CE_WARN,
1023 					    "rfscall couldn't failover: %m");
1024 #endif
1025 					mutex_enter(&mi->mi_lock);
1026 					DEC_READERS(mi);
1027 					mutex_exit(&mi->mi_lock);
1028 					/*
1029 					 * If failover_remap returns ETIMEDOUT
1030 					 * and the filesystem is hard mounted
1031 					 * we have to retry the call with a new
1032 					 * server.
1033 					 */
1034 					if ((mi->mi_flags & MI_HARD) &&
1035 					    IS_RECOVERABLE_ERROR(remaperr)) {
1036 						if (svp == mi->mi_curr_serv)
1037 							failover_newserver(mi);
1038 						rpcerr.re_status = RPC_SUCCESS;
1039 						goto failoverretry;
1040 					}
1041 					rpcerr.re_errno = remaperr;
1042 					return (remaperr);
1043 				}
1044 			}
1045 			if (fi->fhp && fi->copyproc)
1046 				(*fi->copyproc)(fi->fhp, fi->vp);
1047 		}
1048 	}
1049 
1050 	/* For TSOL, use a new cred which has net_mac_aware flag */
1051 	if (!cred_cloned && is_system_labeled()) {
1052 		cred_cloned = TRUE;
1053 		cr = crdup(icr);
1054 		(void) setpflags(NET_MAC_AWARE, 1, cr);
1055 	}
1056 
1057 	/*
1058 	 * clget() calls clnt_tli_kinit() which clears the xid, so we
1059 	 * are guaranteed to reprocess the retry as a new request.
1060 	 */
1061 	svp = mi->mi_curr_serv;
1062 	rpcerr.re_errno = nfs_clget(mi, svp, cr, &client, &ch, nfscl);
1063 
1064 	if (FAILOVER_MOUNT(mi)) {
1065 		mutex_enter(&mi->mi_lock);
1066 		DEC_READERS(mi);
1067 		mutex_exit(&mi->mi_lock);
1068 
1069 		if ((rpcerr.re_errno == ETIMEDOUT ||
1070 		    rpcerr.re_errno == ECONNRESET) &&
1071 		    failover_safe(fi)) {
1072 			if (svp == mi->mi_curr_serv)
1073 				failover_newserver(mi);
1074 			goto failoverretry;
1075 		}
1076 	}
1077 	if (rpcerr.re_errno != 0)
1078 		return (rpcerr.re_errno);
1079 
1080 	if (svp->sv_knconf->knc_semantics == NC_TPI_COTS_ORD ||
1081 	    svp->sv_knconf->knc_semantics == NC_TPI_COTS) {
1082 		timeo = (mi->mi_timeo * hz) / 10;
1083 	} else {
1084 		mutex_enter(&mi->mi_lock);
1085 		timeo = CLNT_SETTIMERS(client,
1086 		    &(mi->mi_timers[mi->mi_timer_type[which]]),
1087 		    &(mi->mi_timers[NFS_CALLTYPES]),
1088 		    (minimum_timeo[mi->mi_call_type[which]]*hz)>>3,
1089 		    (void (*)())NULL, (caddr_t)mi, 0);
1090 		mutex_exit(&mi->mi_lock);
1091 	}
1092 
1093 	/*
1094 	 * If hard mounted fs, retry call forever unless hard error occurs.
1095 	 */
1096 	do {
1097 		tryagain = FALSE;
1098 
1099 		if (FS_OR_ZONE_GONE(mi->mi_vfsp)) {
1100 			status = RPC_FAILED;
1101 			rpcerr.re_status = RPC_FAILED;
1102 			rpcerr.re_errno = EIO;
1103 			break;
1104 		}
1105 
1106 		TICK_TO_TIMEVAL(timeo, &wait);
1107 
1108 		/*
1109 		 * Mask out all signals except SIGHUP, SIGINT, SIGQUIT
1110 		 * and SIGTERM. (Preserving the existing masks).
1111 		 * Mask out SIGINT if mount option nointr is specified.
1112 		 */
1113 		sigintr(&smask, (int)mi->mi_flags & MI_INT);
1114 		if (!(mi->mi_flags & MI_INT))
1115 			client->cl_nosignal = TRUE;
1116 
1117 		/*
1118 		 * If there is a current signal, then don't bother
1119 		 * even trying to send out the request because we
1120 		 * won't be able to block waiting for the response.
1121 		 * Simply assume RPC_INTR and get on with it.
1122 		 */
1123 		if (ttolwp(curthread) != NULL && ISSIG(curthread, JUSTLOOKING))
1124 			status = RPC_INTR;
1125 		else {
1126 			status = CLNT_CALL(client, which, xdrargs, argsp,
1127 			    xdrres, resp, wait);
1128 		}
1129 
1130 		if (!(mi->mi_flags & MI_INT))
1131 			client->cl_nosignal = FALSE;
1132 		/*
1133 		 * restore original signal mask
1134 		 */
1135 		sigunintr(&smask);
1136 
1137 		switch (status) {
1138 		case RPC_SUCCESS:
1139 			if ((mi->mi_flags & MI_DYNAMIC) &&
1140 			    mi->mi_timer_type[which] != 0 &&
1141 			    (mi->mi_curread != my_rsize ||
1142 			    mi->mi_curwrite != my_wsize))
1143 				(void) nfs_feedback(FEEDBACK_OK, which, mi);
1144 			break;
1145 
1146 		case RPC_INTR:
1147 			/*
1148 			 * There is no way to recover from this error,
1149 			 * even if mount option nointr is specified.
1150 			 * SIGKILL, for example, cannot be blocked.
1151 			 */
1152 			rpcerr.re_status = RPC_INTR;
1153 			rpcerr.re_errno = EINTR;
1154 			break;
1155 
1156 		case RPC_UDERROR:
1157 			/*
1158 			 * If the NFS server is local (vold) and
1159 			 * it goes away then we get RPC_UDERROR.
1160 			 * This is a retryable error, so we would
1161 			 * loop, so check to see if the specific
1162 			 * error was ECONNRESET, indicating that
1163 			 * target did not exist at all.  If so,
1164 			 * return with RPC_PROGUNAVAIL and
1165 			 * ECONNRESET to indicate why.
1166 			 */
1167 			CLNT_GETERR(client, &rpcerr);
1168 			if (rpcerr.re_errno == ECONNRESET) {
1169 				rpcerr.re_status = RPC_PROGUNAVAIL;
1170 				rpcerr.re_errno = ECONNRESET;
1171 				break;
1172 			}
1173 			/*FALLTHROUGH*/
1174 
1175 		default:		/* probably RPC_TIMEDOUT */
1176 			if (IS_UNRECOVERABLE_RPC(status))
1177 				break;
1178 
1179 			/*
1180 			 * increment server not responding count
1181 			 */
1182 			mutex_enter(&mi->mi_lock);
1183 			mi->mi_noresponse++;
1184 			mutex_exit(&mi->mi_lock);
1185 #ifdef DEBUG
1186 			nfscl->nfscl_stat.noresponse.value.ui64++;
1187 #endif
1188 
1189 			if (!(mi->mi_flags & MI_HARD)) {
1190 				if (!(mi->mi_flags & MI_SEMISOFT) ||
1191 				    (mi->mi_ss_call_type[which] == 0))
1192 					break;
1193 			}
1194 
1195 			/*
1196 			 * The call is in progress (over COTS).
1197 			 * Try the CLNT_CALL again, but don't
1198 			 * print a noisy error message.
1199 			 */
1200 			if (status == RPC_INPROGRESS) {
1201 				tryagain = TRUE;
1202 				break;
1203 			}
1204 
1205 			if (flags & RFSCALL_SOFT)
1206 				break;
1207 
1208 			/*
1209 			 * On zone shutdown, just move on.
1210 			 */
1211 			if (zone_status_get(curproc->p_zone) >=
1212 			    ZONE_IS_SHUTTING_DOWN) {
1213 				rpcerr.re_status = RPC_FAILED;
1214 				rpcerr.re_errno = EIO;
1215 				break;
1216 			}
1217 
1218 			/*
1219 			 * NFS client failover support
1220 			 *
1221 			 * If the current server just failed us, we'll
1222 			 * start the process of finding a new server.
1223 			 * After that, we can just retry.
1224 			 */
1225 			if (FAILOVER_MOUNT(mi) && failover_safe(fi)) {
1226 				if (svp == mi->mi_curr_serv)
1227 					failover_newserver(mi);
1228 				clfree_impl(client, ch, nfscl);
1229 				goto failoverretry;
1230 			}
1231 
1232 			tryagain = TRUE;
1233 			timeo = backoff(timeo);
1234 
1235 			CLNT_GETERR(client, &rpcerr_tmp);
1236 			if ((status == RPC_CANTSEND) &&
1237 			    (rpcerr_tmp.re_errno == ENOBUFS))
1238 				msg = SRV_QFULL_MSG;
1239 			else
1240 				msg = SRV_NOTRESP_MSG;
1241 
1242 			mutex_enter(&mi->mi_lock);
1243 			if (!(mi->mi_flags & MI_PRINTED)) {
1244 				mi->mi_flags |= MI_PRINTED;
1245 				mutex_exit(&mi->mi_lock);
1246 #ifdef DEBUG
1247 				zprintf(zoneid, msg, mi->mi_vers,
1248 				    svp->sv_hostname);
1249 #else
1250 				zprintf(zoneid, msg, svp->sv_hostname);
1251 #endif
1252 			} else
1253 				mutex_exit(&mi->mi_lock);
1254 			if (*douprintf && nfs_has_ctty()) {
1255 				*douprintf = 0;
1256 				if (!(mi->mi_flags & MI_NOPRINT))
1257 #ifdef DEBUG
1258 					uprintf(msg, mi->mi_vers,
1259 					    svp->sv_hostname);
1260 #else
1261 					uprintf(msg, svp->sv_hostname);
1262 #endif
1263 			}
1264 
1265 			/*
1266 			 * If doing dynamic adjustment of transfer
1267 			 * size and if it's a read or write call
1268 			 * and if the transfer size changed while
1269 			 * retransmitting or if the feedback routine
1270 			 * changed the transfer size,
1271 			 * then exit rfscall so that the transfer
1272 			 * size can be adjusted at the vnops level.
1273 			 */
1274 			if ((mi->mi_flags & MI_DYNAMIC) &&
1275 			    mi->mi_timer_type[which] != 0 &&
1276 			    (mi->mi_curread != my_rsize ||
1277 			    mi->mi_curwrite != my_wsize ||
1278 			    nfs_feedback(FEEDBACK_REXMIT1, which, mi))) {
1279 				/*
1280 				 * On read or write calls, return
1281 				 * back to the vnode ops level if
1282 				 * the transfer size changed.
1283 				 */
1284 				clfree_impl(client, ch, nfscl);
1285 				if (cred_cloned)
1286 					crfree(cr);
1287 				return (ENFS_TRYAGAIN);
1288 			}
1289 		}
1290 	} while (tryagain);
1291 
1292 	if (status != RPC_SUCCESS) {
1293 		/*
1294 		 * Let soft mounts use the timed out message.
1295 		 */
1296 		if (status == RPC_INPROGRESS)
1297 			status = RPC_TIMEDOUT;
1298 		nfscl->nfscl_stat.badcalls.value.ui64++;
1299 		if (status != RPC_INTR) {
1300 			mutex_enter(&mi->mi_lock);
1301 			mi->mi_flags |= MI_DOWN;
1302 			mutex_exit(&mi->mi_lock);
1303 			CLNT_GETERR(client, &rpcerr);
1304 #ifdef DEBUG
1305 			bufp = clnt_sperror(client, svp->sv_hostname);
1306 			zprintf(zoneid, "NFS%d %s failed for %s\n",
1307 			    mi->mi_vers, mi->mi_rfsnames[which], bufp);
1308 			if (nfs_has_ctty()) {
1309 				if (!(mi->mi_flags & MI_NOPRINT)) {
1310 					uprintf("NFS%d %s failed for %s\n",
1311 					    mi->mi_vers, mi->mi_rfsnames[which],
1312 					    bufp);
1313 				}
1314 			}
1315 			kmem_free(bufp, MAXPATHLEN);
1316 #else
1317 			zprintf(zoneid,
1318 			    "NFS %s failed for server %s: error %d (%s)\n",
1319 			    mi->mi_rfsnames[which], svp->sv_hostname,
1320 			    status, clnt_sperrno(status));
1321 			if (nfs_has_ctty()) {
1322 				if (!(mi->mi_flags & MI_NOPRINT)) {
1323 					uprintf(
1324 				"NFS %s failed for server %s: error %d (%s)\n",
1325 					    mi->mi_rfsnames[which],
1326 					    svp->sv_hostname, status,
1327 					    clnt_sperrno(status));
1328 				}
1329 			}
1330 #endif
1331 			/*
1332 			 * when CLNT_CALL() fails with RPC_AUTHERROR,
1333 			 * re_errno is set appropriately depending on
1334 			 * the authentication error
1335 			 */
1336 			if (status == RPC_VERSMISMATCH ||
1337 			    status == RPC_PROGVERSMISMATCH)
1338 				rpcerr.re_errno = EIO;
1339 		}
1340 	} else {
1341 		/*
1342 		 * Test the value of mi_down and mi_printed without
1343 		 * holding the mi_lock mutex.  If they are both zero,
1344 		 * then it is okay to skip the down and printed
1345 		 * processing.  This saves on a mutex_enter and
1346 		 * mutex_exit pair for a normal, successful RPC.
1347 		 * This was just complete overhead.
1348 		 */
1349 		if (mi->mi_flags & (MI_DOWN | MI_PRINTED)) {
1350 			mutex_enter(&mi->mi_lock);
1351 			mi->mi_flags &= ~MI_DOWN;
1352 			if (mi->mi_flags & MI_PRINTED) {
1353 				mi->mi_flags &= ~MI_PRINTED;
1354 				mutex_exit(&mi->mi_lock);
1355 #ifdef DEBUG
1356 			if (!(mi->mi_vfsp->vfs_flag & VFS_UNMOUNTED))
1357 				zprintf(zoneid, "NFS%d server %s ok\n",
1358 				    mi->mi_vers, svp->sv_hostname);
1359 #else
1360 			if (!(mi->mi_vfsp->vfs_flag & VFS_UNMOUNTED))
1361 				zprintf(zoneid, "NFS server %s ok\n",
1362 				    svp->sv_hostname);
1363 #endif
1364 			} else
1365 				mutex_exit(&mi->mi_lock);
1366 		}
1367 
1368 		if (*douprintf == 0) {
1369 			if (!(mi->mi_flags & MI_NOPRINT))
1370 #ifdef DEBUG
1371 				if (!(mi->mi_vfsp->vfs_flag & VFS_UNMOUNTED))
1372 					uprintf("NFS%d server %s ok\n",
1373 					    mi->mi_vers, svp->sv_hostname);
1374 #else
1375 			if (!(mi->mi_vfsp->vfs_flag & VFS_UNMOUNTED))
1376 				uprintf("NFS server %s ok\n", svp->sv_hostname);
1377 #endif
1378 			*douprintf = 1;
1379 		}
1380 	}
1381 
1382 	clfree_impl(client, ch, nfscl);
1383 	if (cred_cloned)
1384 		crfree(cr);
1385 
1386 	ASSERT(rpcerr.re_status == RPC_SUCCESS || rpcerr.re_errno != 0);
1387 
1388 	if (rpc_status != NULL)
1389 		*rpc_status = rpcerr.re_status;
1390 
1391 	TRACE_1(TR_FAC_NFS, TR_RFSCALL_END, "rfscall_end:errno %d",
1392 	    rpcerr.re_errno);
1393 
1394 	return (rpcerr.re_errno);
1395 }
1396 
1397 #ifdef DEBUG
1398 static int acl2call_hits = 0;
1399 static int acl2call_misses = 0;
1400 #endif
1401 
1402 int
1403 acl2call(mntinfo_t *mi, rpcproc_t which, xdrproc_t xdrargs, caddr_t argsp,
1404     xdrproc_t xdrres, caddr_t resp, cred_t *cr, int *douprintf,
1405     enum nfsstat *statusp, int flags, failinfo_t *fi)
1406 {
1407 	int rpcerror;
1408 
1409 	rpcerror = aclcall(mi, which, xdrargs, argsp, xdrres, resp,
1410 	    cr, douprintf, flags, fi);
1411 	if (!rpcerror) {
1412 		/*
1413 		 * See comments with crnetadjust().
1414 		 */
1415 		if (*statusp == NFSERR_ACCES &&
1416 		    (cr = crnetadjust(cr)) != NULL) {
1417 #ifdef DEBUG
1418 			acl2call_hits++;
1419 #endif
1420 			rpcerror = aclcall(mi, which, xdrargs, argsp, xdrres,
1421 			    resp, cr, douprintf, flags, fi);
1422 			crfree(cr);
1423 #ifdef DEBUG
1424 			if (*statusp == NFSERR_ACCES)
1425 				acl2call_misses++;
1426 #endif
1427 		}
1428 	}
1429 
1430 	return (rpcerror);
1431 }
1432 
1433 #ifdef DEBUG
1434 static int acl3call_hits = 0;
1435 static int acl3call_misses = 0;
1436 #endif
1437 
1438 int
1439 acl3call(mntinfo_t *mi, rpcproc_t which, xdrproc_t xdrargs, caddr_t argsp,
1440     xdrproc_t xdrres, caddr_t resp, cred_t *cr, int *douprintf,
1441     nfsstat3 *statusp, int flags, failinfo_t *fi)
1442 {
1443 	int rpcerror;
1444 	int user_informed;
1445 
1446 	user_informed = 0;
1447 
1448 	do {
1449 		rpcerror = aclcall(mi, which, xdrargs, argsp, xdrres, resp,
1450 		    cr, douprintf, flags, fi);
1451 		if (!rpcerror) {
1452 			cred_t *crr;
1453 			if (*statusp == NFS3ERR_JUKEBOX) {
1454 				if (!user_informed) {
1455 					user_informed = 1;
1456 					uprintf(
1457 		"file temporarily unavailable on the server, retrying...\n");
1458 				}
1459 				delay(nfs3_jukebox_delay);
1460 			}
1461 			/*
1462 			 * See crnetadjust() for comments.
1463 			 */
1464 			else if (*statusp == NFS3ERR_ACCES &&
1465 			    (crr = crnetadjust(cr)) != NULL) {
1466 #ifdef DEBUG
1467 				acl3call_hits++;
1468 #endif
1469 				rpcerror = aclcall(mi, which, xdrargs, argsp,
1470 				    xdrres, resp, crr, douprintf, flags, fi);
1471 
1472 				crfree(crr);
1473 #ifdef DEBUG
1474 				if (*statusp == NFS3ERR_ACCES)
1475 					acl3call_misses++;
1476 #endif
1477 			}
1478 		}
1479 	} while (!rpcerror && *statusp == NFS3ERR_JUKEBOX);
1480 
1481 	return (rpcerror);
1482 }
1483 
1484 static int
1485 aclcall(mntinfo_t *mi, rpcproc_t which, xdrproc_t xdrargs, caddr_t argsp,
1486     xdrproc_t xdrres, caddr_t resp, cred_t *icr, int *douprintf,
1487     int flags, failinfo_t *fi)
1488 {
1489 	CLIENT *client;
1490 	struct chtab *ch;
1491 	cred_t *cr = icr;
1492 	bool_t cred_cloned = FALSE;
1493 	enum clnt_stat status;
1494 	struct rpc_err rpcerr;
1495 	struct timeval wait;
1496 	int timeo;		/* in units of hz */
1497 #if 0 /* notyet */
1498 	int my_rsize, my_wsize;
1499 #endif
1500 	bool_t tryagain;
1501 	k_sigset_t smask;
1502 	servinfo_t *svp;
1503 	struct nfs_clnt *nfscl;
1504 	zoneid_t zoneid = getzoneid();
1505 #ifdef DEBUG
1506 	char *bufp;
1507 #endif
1508 
1509 #if 0 /* notyet */
1510 	TRACE_2(TR_FAC_NFS, TR_RFSCALL_START,
1511 	    "rfscall_start:which %d mi %p", which, mi);
1512 #endif
1513 
1514 	nfscl = zone_getspecific(nfsclnt_zone_key, nfs_zone());
1515 	ASSERT(nfscl != NULL);
1516 
1517 	nfscl->nfscl_stat.calls.value.ui64++;
1518 	mi->mi_aclreqs[which].value.ui64++;
1519 
1520 	rpcerr.re_status = RPC_SUCCESS;
1521 
1522 	if (FS_OR_ZONE_GONE(mi->mi_vfsp)) {
1523 		rpcerr.re_status = RPC_FAILED;
1524 		rpcerr.re_errno = EIO;
1525 		return (rpcerr.re_errno);
1526 	}
1527 
1528 #if 0 /* notyet */
1529 	/*
1530 	 * Remember the transfer sizes in case
1531 	 * nfs_feedback changes them underneath us.
1532 	 */
1533 	my_rsize = mi->mi_curread;
1534 	my_wsize = mi->mi_curwrite;
1535 #endif
1536 
1537 	/*
1538 	 * NFS client failover support
1539 	 *
1540 	 * If this rnode is not in sync with the current server (VALID_FH),
1541 	 * we'd like to do a remap to get in sync.  We can be interrupted
1542 	 * in failover_remap(), and if so we'll bail.  Otherwise, we'll
1543 	 * use the best info we have to try the RPC.  Part of that is
1544 	 * unconditionally updating the filehandle copy kept for V3.
1545 	 *
1546 	 * Locking: INC_READERS/DEC_READERS is a poor man's interrruptible
1547 	 * rw_enter(); we're trying to keep the current server from being
1548 	 * changed on us until we're done with the remapping and have a
1549 	 * matching client handle.  We don't want to sending a filehandle
1550 	 * to the wrong host.
1551 	 */
1552 failoverretry:
1553 	if (FAILOVER_MOUNT(mi)) {
1554 		mutex_enter(&mi->mi_lock);
1555 		if (!(flags & RFSCALL_SOFT) && failover_safe(fi)) {
1556 			if (failover_wait(mi)) {
1557 				mutex_exit(&mi->mi_lock);
1558 				return (EINTR);
1559 			}
1560 		}
1561 		INC_READERS(mi);
1562 		mutex_exit(&mi->mi_lock);
1563 		if (fi) {
1564 			if (!VALID_FH(fi) &&
1565 			    !(flags & RFSCALL_SOFT) && failover_safe(fi)) {
1566 				int remaperr;
1567 
1568 				svp = mi->mi_curr_serv;
1569 				remaperr = failover_remap(fi);
1570 				if (remaperr != 0) {
1571 #ifdef DEBUG
1572 					if (remaperr != EINTR)
1573 						nfs_cmn_err(remaperr, CE_WARN,
1574 					    "aclcall couldn't failover: %m");
1575 #endif
1576 					mutex_enter(&mi->mi_lock);
1577 					DEC_READERS(mi);
1578 					mutex_exit(&mi->mi_lock);
1579 
1580 					/*
1581 					 * If failover_remap returns ETIMEDOUT
1582 					 * and the filesystem is hard mounted
1583 					 * we have to retry the call with a new
1584 					 * server.
1585 					 */
1586 					if ((mi->mi_flags & MI_HARD) &&
1587 					    IS_RECOVERABLE_ERROR(remaperr)) {
1588 						if (svp == mi->mi_curr_serv)
1589 							failover_newserver(mi);
1590 						rpcerr.re_status = RPC_SUCCESS;
1591 						goto failoverretry;
1592 					}
1593 					return (remaperr);
1594 				}
1595 			}
1596 			if (fi->fhp && fi->copyproc)
1597 				(*fi->copyproc)(fi->fhp, fi->vp);
1598 		}
1599 	}
1600 
1601 	/* For TSOL, use a new cred which has net_mac_aware flag */
1602 	if (!cred_cloned && is_system_labeled()) {
1603 		cred_cloned = TRUE;
1604 		cr = crdup(icr);
1605 		(void) setpflags(NET_MAC_AWARE, 1, cr);
1606 	}
1607 
1608 	/*
1609 	 * acl_clget() calls clnt_tli_kinit() which clears the xid, so we
1610 	 * are guaranteed to reprocess the retry as a new request.
1611 	 */
1612 	svp = mi->mi_curr_serv;
1613 	rpcerr.re_errno = acl_clget(mi, svp, cr, &client, &ch, nfscl);
1614 	if (FAILOVER_MOUNT(mi)) {
1615 		mutex_enter(&mi->mi_lock);
1616 		DEC_READERS(mi);
1617 		mutex_exit(&mi->mi_lock);
1618 
1619 		if ((rpcerr.re_errno == ETIMEDOUT ||
1620 		    rpcerr.re_errno == ECONNRESET) &&
1621 		    failover_safe(fi)) {
1622 			if (svp == mi->mi_curr_serv)
1623 				failover_newserver(mi);
1624 			goto failoverretry;
1625 		}
1626 	}
1627 	if (rpcerr.re_errno != 0) {
1628 		if (cred_cloned)
1629 			crfree(cr);
1630 		return (rpcerr.re_errno);
1631 	}
1632 
1633 	if (svp->sv_knconf->knc_semantics == NC_TPI_COTS_ORD ||
1634 	    svp->sv_knconf->knc_semantics == NC_TPI_COTS) {
1635 		timeo = (mi->mi_timeo * hz) / 10;
1636 	} else {
1637 		mutex_enter(&mi->mi_lock);
1638 		timeo = CLNT_SETTIMERS(client,
1639 		    &(mi->mi_timers[mi->mi_acl_timer_type[which]]),
1640 		    &(mi->mi_timers[NFS_CALLTYPES]),
1641 		    (minimum_timeo[mi->mi_acl_call_type[which]]*hz)>>3,
1642 		    (void (*)()) 0, (caddr_t)mi, 0);
1643 		mutex_exit(&mi->mi_lock);
1644 	}
1645 
1646 	/*
1647 	 * If hard mounted fs, retry call forever unless hard error occurs.
1648 	 */
1649 	do {
1650 		tryagain = FALSE;
1651 
1652 		if (FS_OR_ZONE_GONE(mi->mi_vfsp)) {
1653 			status = RPC_FAILED;
1654 			rpcerr.re_status = RPC_FAILED;
1655 			rpcerr.re_errno = EIO;
1656 			break;
1657 		}
1658 
1659 		TICK_TO_TIMEVAL(timeo, &wait);
1660 
1661 		/*
1662 		 * Mask out all signals except SIGHUP, SIGINT, SIGQUIT
1663 		 * and SIGTERM. (Preserving the existing masks).
1664 		 * Mask out SIGINT if mount option nointr is specified.
1665 		 */
1666 		sigintr(&smask, (int)mi->mi_flags & MI_INT);
1667 		if (!(mi->mi_flags & MI_INT))
1668 			client->cl_nosignal = TRUE;
1669 
1670 		/*
1671 		 * If there is a current signal, then don't bother
1672 		 * even trying to send out the request because we
1673 		 * won't be able to block waiting for the response.
1674 		 * Simply assume RPC_INTR and get on with it.
1675 		 */
1676 		if (ttolwp(curthread) != NULL && ISSIG(curthread, JUSTLOOKING))
1677 			status = RPC_INTR;
1678 		else {
1679 			status = CLNT_CALL(client, which, xdrargs, argsp,
1680 			    xdrres, resp, wait);
1681 		}
1682 
1683 		if (!(mi->mi_flags & MI_INT))
1684 			client->cl_nosignal = FALSE;
1685 		/*
1686 		 * restore original signal mask
1687 		 */
1688 		sigunintr(&smask);
1689 
1690 		switch (status) {
1691 		case RPC_SUCCESS:
1692 #if 0 /* notyet */
1693 			if ((mi->mi_flags & MI_DYNAMIC) &&
1694 			    mi->mi_timer_type[which] != 0 &&
1695 			    (mi->mi_curread != my_rsize ||
1696 			    mi->mi_curwrite != my_wsize))
1697 				(void) nfs_feedback(FEEDBACK_OK, which, mi);
1698 #endif
1699 			break;
1700 
1701 		/*
1702 		 * Unfortunately, there are servers in the world which
1703 		 * are not coded correctly.  They are not prepared to
1704 		 * handle RPC requests to the NFS port which are not
1705 		 * NFS requests.  Thus, they may try to process the
1706 		 * NFS_ACL request as if it were an NFS request.  This
1707 		 * does not work.  Generally, an error will be generated
1708 		 * on the client because it will not be able to decode
1709 		 * the response from the server.  However, it seems
1710 		 * possible that the server may not be able to decode
1711 		 * the arguments.  Thus, the criteria for deciding
1712 		 * whether the server supports NFS_ACL or not is whether
1713 		 * the following RPC errors are returned from CLNT_CALL.
1714 		 */
1715 		case RPC_CANTDECODERES:
1716 		case RPC_PROGUNAVAIL:
1717 		case RPC_CANTDECODEARGS:
1718 		case RPC_PROGVERSMISMATCH:
1719 			mutex_enter(&mi->mi_lock);
1720 			mi->mi_flags &= ~(MI_ACL | MI_EXTATTR);
1721 			mutex_exit(&mi->mi_lock);
1722 			break;
1723 
1724 		/*
1725 		 * If the server supports NFS_ACL but not the new ops
1726 		 * for extended attributes, make sure we don't retry.
1727 		 */
1728 		case RPC_PROCUNAVAIL:
1729 			mutex_enter(&mi->mi_lock);
1730 			mi->mi_flags &= ~MI_EXTATTR;
1731 			mutex_exit(&mi->mi_lock);
1732 			break;
1733 
1734 		case RPC_INTR:
1735 			/*
1736 			 * There is no way to recover from this error,
1737 			 * even if mount option nointr is specified.
1738 			 * SIGKILL, for example, cannot be blocked.
1739 			 */
1740 			rpcerr.re_status = RPC_INTR;
1741 			rpcerr.re_errno = EINTR;
1742 			break;
1743 
1744 		case RPC_UDERROR:
1745 			/*
1746 			 * If the NFS server is local (vold) and
1747 			 * it goes away then we get RPC_UDERROR.
1748 			 * This is a retryable error, so we would
1749 			 * loop, so check to see if the specific
1750 			 * error was ECONNRESET, indicating that
1751 			 * target did not exist at all.  If so,
1752 			 * return with RPC_PROGUNAVAIL and
1753 			 * ECONNRESET to indicate why.
1754 			 */
1755 			CLNT_GETERR(client, &rpcerr);
1756 			if (rpcerr.re_errno == ECONNRESET) {
1757 				rpcerr.re_status = RPC_PROGUNAVAIL;
1758 				rpcerr.re_errno = ECONNRESET;
1759 				break;
1760 			}
1761 			/*FALLTHROUGH*/
1762 
1763 		default:		/* probably RPC_TIMEDOUT */
1764 			if (IS_UNRECOVERABLE_RPC(status))
1765 				break;
1766 
1767 			/*
1768 			 * increment server not responding count
1769 			 */
1770 			mutex_enter(&mi->mi_lock);
1771 			mi->mi_noresponse++;
1772 			mutex_exit(&mi->mi_lock);
1773 #ifdef DEBUG
1774 			nfscl->nfscl_stat.noresponse.value.ui64++;
1775 #endif
1776 
1777 			if (!(mi->mi_flags & MI_HARD)) {
1778 				if (!(mi->mi_flags & MI_SEMISOFT) ||
1779 				    (mi->mi_acl_ss_call_type[which] == 0))
1780 					break;
1781 			}
1782 
1783 			/*
1784 			 * The call is in progress (over COTS).
1785 			 * Try the CLNT_CALL again, but don't
1786 			 * print a noisy error message.
1787 			 */
1788 			if (status == RPC_INPROGRESS) {
1789 				tryagain = TRUE;
1790 				break;
1791 			}
1792 
1793 			if (flags & RFSCALL_SOFT)
1794 				break;
1795 
1796 			/*
1797 			 * On zone shutdown, just move on.
1798 			 */
1799 			if (zone_status_get(curproc->p_zone) >=
1800 			    ZONE_IS_SHUTTING_DOWN) {
1801 				rpcerr.re_status = RPC_FAILED;
1802 				rpcerr.re_errno = EIO;
1803 				break;
1804 			}
1805 
1806 			/*
1807 			 * NFS client failover support
1808 			 *
1809 			 * If the current server just failed us, we'll
1810 			 * start the process of finding a new server.
1811 			 * After that, we can just retry.
1812 			 */
1813 			if (FAILOVER_MOUNT(mi) && failover_safe(fi)) {
1814 				if (svp == mi->mi_curr_serv)
1815 					failover_newserver(mi);
1816 				clfree_impl(client, ch, nfscl);
1817 				goto failoverretry;
1818 			}
1819 
1820 			tryagain = TRUE;
1821 			timeo = backoff(timeo);
1822 			mutex_enter(&mi->mi_lock);
1823 			if (!(mi->mi_flags & MI_PRINTED)) {
1824 				mi->mi_flags |= MI_PRINTED;
1825 				mutex_exit(&mi->mi_lock);
1826 #ifdef DEBUG
1827 				zprintf(zoneid,
1828 			"NFS_ACL%d server %s not responding still trying\n",
1829 				    mi->mi_vers, svp->sv_hostname);
1830 #else
1831 				zprintf(zoneid,
1832 			    "NFS server %s not responding still trying\n",
1833 				    svp->sv_hostname);
1834 #endif
1835 			} else
1836 				mutex_exit(&mi->mi_lock);
1837 			if (*douprintf && nfs_has_ctty()) {
1838 				*douprintf = 0;
1839 				if (!(mi->mi_flags & MI_NOPRINT))
1840 #ifdef DEBUG
1841 					uprintf(
1842 			"NFS_ACL%d server %s not responding still trying\n",
1843 					    mi->mi_vers, svp->sv_hostname);
1844 #else
1845 					uprintf(
1846 			    "NFS server %s not responding still trying\n",
1847 					    svp->sv_hostname);
1848 #endif
1849 			}
1850 
1851 #if 0 /* notyet */
1852 			/*
1853 			 * If doing dynamic adjustment of transfer
1854 			 * size and if it's a read or write call
1855 			 * and if the transfer size changed while
1856 			 * retransmitting or if the feedback routine
1857 			 * changed the transfer size,
1858 			 * then exit rfscall so that the transfer
1859 			 * size can be adjusted at the vnops level.
1860 			 */
1861 			if ((mi->mi_flags & MI_DYNAMIC) &&
1862 			    mi->mi_acl_timer_type[which] != 0 &&
1863 			    (mi->mi_curread != my_rsize ||
1864 			    mi->mi_curwrite != my_wsize ||
1865 			    nfs_feedback(FEEDBACK_REXMIT1, which, mi))) {
1866 				/*
1867 				 * On read or write calls, return
1868 				 * back to the vnode ops level if
1869 				 * the transfer size changed.
1870 				 */
1871 				clfree_impl(client, ch, nfscl);
1872 				if (cred_cloned)
1873 					crfree(cr);
1874 				return (ENFS_TRYAGAIN);
1875 			}
1876 #endif
1877 		}
1878 	} while (tryagain);
1879 
1880 	if (status != RPC_SUCCESS) {
1881 		/*
1882 		 * Let soft mounts use the timed out message.
1883 		 */
1884 		if (status == RPC_INPROGRESS)
1885 			status = RPC_TIMEDOUT;
1886 		nfscl->nfscl_stat.badcalls.value.ui64++;
1887 		if (status == RPC_CANTDECODERES ||
1888 		    status == RPC_PROGUNAVAIL ||
1889 		    status == RPC_PROCUNAVAIL ||
1890 		    status == RPC_CANTDECODEARGS ||
1891 		    status == RPC_PROGVERSMISMATCH)
1892 			CLNT_GETERR(client, &rpcerr);
1893 		else if (status != RPC_INTR) {
1894 			mutex_enter(&mi->mi_lock);
1895 			mi->mi_flags |= MI_DOWN;
1896 			mutex_exit(&mi->mi_lock);
1897 			CLNT_GETERR(client, &rpcerr);
1898 #ifdef DEBUG
1899 			bufp = clnt_sperror(client, svp->sv_hostname);
1900 			zprintf(zoneid, "NFS_ACL%d %s failed for %s\n",
1901 			    mi->mi_vers, mi->mi_aclnames[which], bufp);
1902 			if (nfs_has_ctty()) {
1903 				if (!(mi->mi_flags & MI_NOPRINT)) {
1904 					uprintf("NFS_ACL%d %s failed for %s\n",
1905 					    mi->mi_vers, mi->mi_aclnames[which],
1906 					    bufp);
1907 				}
1908 			}
1909 			kmem_free(bufp, MAXPATHLEN);
1910 #else
1911 			zprintf(zoneid,
1912 			    "NFS %s failed for server %s: error %d (%s)\n",
1913 			    mi->mi_aclnames[which], svp->sv_hostname,
1914 			    status, clnt_sperrno(status));
1915 			if (nfs_has_ctty()) {
1916 				if (!(mi->mi_flags & MI_NOPRINT))
1917 					uprintf(
1918 				"NFS %s failed for server %s: error %d (%s)\n",
1919 					    mi->mi_aclnames[which],
1920 					    svp->sv_hostname, status,
1921 					    clnt_sperrno(status));
1922 			}
1923 #endif
1924 			/*
1925 			 * when CLNT_CALL() fails with RPC_AUTHERROR,
1926 			 * re_errno is set appropriately depending on
1927 			 * the authentication error
1928 			 */
1929 			if (status == RPC_VERSMISMATCH ||
1930 			    status == RPC_PROGVERSMISMATCH)
1931 				rpcerr.re_errno = EIO;
1932 		}
1933 	} else {
1934 		/*
1935 		 * Test the value of mi_down and mi_printed without
1936 		 * holding the mi_lock mutex.  If they are both zero,
1937 		 * then it is okay to skip the down and printed
1938 		 * processing.  This saves on a mutex_enter and
1939 		 * mutex_exit pair for a normal, successful RPC.
1940 		 * This was just complete overhead.
1941 		 */
1942 		if (mi->mi_flags & (MI_DOWN | MI_PRINTED)) {
1943 			mutex_enter(&mi->mi_lock);
1944 			mi->mi_flags &= ~MI_DOWN;
1945 			if (mi->mi_flags & MI_PRINTED) {
1946 				mi->mi_flags &= ~MI_PRINTED;
1947 				mutex_exit(&mi->mi_lock);
1948 #ifdef DEBUG
1949 				zprintf(zoneid, "NFS_ACL%d server %s ok\n",
1950 				    mi->mi_vers, svp->sv_hostname);
1951 #else
1952 				zprintf(zoneid, "NFS server %s ok\n",
1953 				    svp->sv_hostname);
1954 #endif
1955 			} else
1956 				mutex_exit(&mi->mi_lock);
1957 		}
1958 
1959 		if (*douprintf == 0) {
1960 			if (!(mi->mi_flags & MI_NOPRINT))
1961 #ifdef DEBUG
1962 				uprintf("NFS_ACL%d server %s ok\n",
1963 				    mi->mi_vers, svp->sv_hostname);
1964 #else
1965 				uprintf("NFS server %s ok\n", svp->sv_hostname);
1966 #endif
1967 			*douprintf = 1;
1968 		}
1969 	}
1970 
1971 	clfree_impl(client, ch, nfscl);
1972 	if (cred_cloned)
1973 		crfree(cr);
1974 
1975 	ASSERT(rpcerr.re_status == RPC_SUCCESS || rpcerr.re_errno != 0);
1976 
1977 #if 0 /* notyet */
1978 	TRACE_1(TR_FAC_NFS, TR_RFSCALL_END, "rfscall_end:errno %d",
1979 	    rpcerr.re_errno);
1980 #endif
1981 
1982 	return (rpcerr.re_errno);
1983 }
1984 
1985 int
1986 vattr_to_sattr(struct vattr *vap, struct nfssattr *sa)
1987 {
1988 	uint_t mask = vap->va_mask;
1989 
1990 	if (!(mask & AT_MODE))
1991 		sa->sa_mode = (uint32_t)-1;
1992 	else
1993 		sa->sa_mode = vap->va_mode;
1994 	if (!(mask & AT_UID))
1995 		sa->sa_uid = (uint32_t)-1;
1996 	else
1997 		sa->sa_uid = (uint32_t)vap->va_uid;
1998 	if (!(mask & AT_GID))
1999 		sa->sa_gid = (uint32_t)-1;
2000 	else
2001 		sa->sa_gid = (uint32_t)vap->va_gid;
2002 	if (!(mask & AT_SIZE))
2003 		sa->sa_size = (uint32_t)-1;
2004 	else
2005 		sa->sa_size = (uint32_t)vap->va_size;
2006 	if (!(mask & AT_ATIME))
2007 		sa->sa_atime.tv_sec = sa->sa_atime.tv_usec = (int32_t)-1;
2008 	else {
2009 		/* check time validity */
2010 		if (! NFS_TIME_T_OK(vap->va_atime.tv_sec)) {
2011 			return (EOVERFLOW);
2012 		}
2013 		sa->sa_atime.tv_sec = vap->va_atime.tv_sec;
2014 		sa->sa_atime.tv_usec = vap->va_atime.tv_nsec / 1000;
2015 	}
2016 	if (!(mask & AT_MTIME))
2017 		sa->sa_mtime.tv_sec = sa->sa_mtime.tv_usec = (int32_t)-1;
2018 	else {
2019 		/* check time validity */
2020 		if (! NFS_TIME_T_OK(vap->va_mtime.tv_sec)) {
2021 			return (EOVERFLOW);
2022 		}
2023 		sa->sa_mtime.tv_sec = vap->va_mtime.tv_sec;
2024 		sa->sa_mtime.tv_usec = vap->va_mtime.tv_nsec / 1000;
2025 	}
2026 	return (0);
2027 }
2028 
2029 int
2030 vattr_to_sattr3(struct vattr *vap, sattr3 *sa)
2031 {
2032 	uint_t mask = vap->va_mask;
2033 
2034 	if (!(mask & AT_MODE))
2035 		sa->mode.set_it = FALSE;
2036 	else {
2037 		sa->mode.set_it = TRUE;
2038 		sa->mode.mode = (mode3)vap->va_mode;
2039 	}
2040 	if (!(mask & AT_UID))
2041 		sa->uid.set_it = FALSE;
2042 	else {
2043 		sa->uid.set_it = TRUE;
2044 		sa->uid.uid = (uid3)vap->va_uid;
2045 	}
2046 	if (!(mask & AT_GID))
2047 		sa->gid.set_it = FALSE;
2048 	else {
2049 		sa->gid.set_it = TRUE;
2050 		sa->gid.gid = (gid3)vap->va_gid;
2051 	}
2052 	if (!(mask & AT_SIZE))
2053 		sa->size.set_it = FALSE;
2054 	else {
2055 		sa->size.set_it = TRUE;
2056 		sa->size.size = (size3)vap->va_size;
2057 	}
2058 	if (!(mask & AT_ATIME))
2059 		sa->atime.set_it = DONT_CHANGE;
2060 	else {
2061 		/* check time validity */
2062 		if (! NFS_TIME_T_OK(vap->va_atime.tv_sec)) {
2063 			return (EOVERFLOW);
2064 		}
2065 		sa->atime.set_it = SET_TO_CLIENT_TIME;
2066 		sa->atime.atime.seconds = (uint32)vap->va_atime.tv_sec;
2067 		sa->atime.atime.nseconds = (uint32)vap->va_atime.tv_nsec;
2068 	}
2069 	if (!(mask & AT_MTIME))
2070 		sa->mtime.set_it = DONT_CHANGE;
2071 	else {
2072 		/* check time validity */
2073 		if (! NFS_TIME_T_OK(vap->va_mtime.tv_sec)) {
2074 			return (EOVERFLOW);
2075 		}
2076 		sa->mtime.set_it = SET_TO_CLIENT_TIME;
2077 		sa->mtime.mtime.seconds = (uint32)vap->va_mtime.tv_sec;
2078 		sa->mtime.mtime.nseconds = (uint32)vap->va_mtime.tv_nsec;
2079 	}
2080 	return (0);
2081 }
2082 
2083 void
2084 setdiropargs(struct nfsdiropargs *da, char *nm, vnode_t *dvp)
2085 {
2086 
2087 	da->da_fhandle = VTOFH(dvp);
2088 	da->da_name = nm;
2089 	da->da_flags = 0;
2090 }
2091 
2092 void
2093 setdiropargs3(diropargs3 *da, char *nm, vnode_t *dvp)
2094 {
2095 
2096 	da->dirp = VTOFH3(dvp);
2097 	da->name = nm;
2098 }
2099 
2100 int
2101 setdirgid(vnode_t *dvp, gid_t *gidp, cred_t *cr)
2102 {
2103 	int error;
2104 	rnode_t *rp;
2105 	struct vattr va;
2106 
2107 	va.va_mask = AT_MODE | AT_GID;
2108 	error = VOP_GETATTR(dvp, &va, 0, cr, NULL);
2109 	if (error)
2110 		return (error);
2111 
2112 	/*
2113 	 * To determine the expected group-id of the created file:
2114 	 *  1)	If the filesystem was not mounted with the Old-BSD-compatible
2115 	 *	GRPID option, and the directory's set-gid bit is clear,
2116 	 *	then use the process's gid.
2117 	 *  2)	Otherwise, set the group-id to the gid of the parent directory.
2118 	 */
2119 	rp = VTOR(dvp);
2120 	mutex_enter(&rp->r_statelock);
2121 	if (!(VTOMI(dvp)->mi_flags & MI_GRPID) && !(va.va_mode & VSGID))
2122 		*gidp = crgetgid(cr);
2123 	else
2124 		*gidp = va.va_gid;
2125 	mutex_exit(&rp->r_statelock);
2126 	return (0);
2127 }
2128 
2129 int
2130 setdirmode(vnode_t *dvp, mode_t *omp, cred_t *cr)
2131 {
2132 	int error;
2133 	struct vattr va;
2134 
2135 	va.va_mask = AT_MODE;
2136 	error = VOP_GETATTR(dvp, &va, 0, cr, NULL);
2137 	if (error)
2138 		return (error);
2139 
2140 	/*
2141 	 * Modify the expected mode (om) so that the set-gid bit matches
2142 	 * that of the parent directory (dvp).
2143 	 */
2144 	if (va.va_mode & VSGID)
2145 		*omp |= VSGID;
2146 	else
2147 		*omp &= ~VSGID;
2148 	return (0);
2149 }
2150 
2151 void
2152 nfs_setswaplike(vnode_t *vp, vattr_t *vap)
2153 {
2154 
2155 	if (vp->v_type == VREG && (vap->va_mode & (VEXEC | VSVTX)) == VSVTX) {
2156 		if (!(vp->v_flag & VSWAPLIKE)) {
2157 			mutex_enter(&vp->v_lock);
2158 			vp->v_flag |= VSWAPLIKE;
2159 			mutex_exit(&vp->v_lock);
2160 		}
2161 	} else {
2162 		if (vp->v_flag & VSWAPLIKE) {
2163 			mutex_enter(&vp->v_lock);
2164 			vp->v_flag &= ~VSWAPLIKE;
2165 			mutex_exit(&vp->v_lock);
2166 		}
2167 	}
2168 }
2169 
2170 /*
2171  * Free the resources associated with an rnode.
2172  */
2173 static void
2174 rinactive(rnode_t *rp, cred_t *cr)
2175 {
2176 	vnode_t *vp;
2177 	cred_t *cred;
2178 	char *contents;
2179 	int size;
2180 	vsecattr_t *vsp;
2181 	int error;
2182 	nfs3_pathconf_info *info;
2183 
2184 	/*
2185 	 * Before freeing anything, wait until all asynchronous
2186 	 * activity is done on this rnode.  This will allow all
2187 	 * asynchronous read ahead and write behind i/o's to
2188 	 * finish.
2189 	 */
2190 	mutex_enter(&rp->r_statelock);
2191 	while (rp->r_count > 0)
2192 		cv_wait(&rp->r_cv, &rp->r_statelock);
2193 	mutex_exit(&rp->r_statelock);
2194 
2195 	/*
2196 	 * Flush and invalidate all pages associated with the vnode.
2197 	 */
2198 	vp = RTOV(rp);
2199 	if (vn_has_cached_data(vp)) {
2200 		ASSERT(vp->v_type != VCHR);
2201 		if ((rp->r_flags & RDIRTY) && !rp->r_error) {
2202 			error = VOP_PUTPAGE(vp, (u_offset_t)0, 0, 0, cr, NULL);
2203 			if (error && (error == ENOSPC || error == EDQUOT)) {
2204 				mutex_enter(&rp->r_statelock);
2205 				if (!rp->r_error)
2206 					rp->r_error = error;
2207 				mutex_exit(&rp->r_statelock);
2208 			}
2209 		}
2210 		nfs_invalidate_pages(vp, (u_offset_t)0, cr);
2211 	}
2212 
2213 	/*
2214 	 * Free any held credentials and caches which may be associated
2215 	 * with this rnode.
2216 	 */
2217 	mutex_enter(&rp->r_statelock);
2218 	cred = rp->r_cred;
2219 	rp->r_cred = NULL;
2220 	contents = rp->r_symlink.contents;
2221 	size = rp->r_symlink.size;
2222 	rp->r_symlink.contents = NULL;
2223 	vsp = rp->r_secattr;
2224 	rp->r_secattr = NULL;
2225 	info = rp->r_pathconf;
2226 	rp->r_pathconf = NULL;
2227 	mutex_exit(&rp->r_statelock);
2228 
2229 	/*
2230 	 * Free the held credential.
2231 	 */
2232 	if (cred != NULL)
2233 		crfree(cred);
2234 
2235 	/*
2236 	 * Free the access cache entries.
2237 	 */
2238 	(void) nfs_access_purge_rp(rp);
2239 
2240 	/*
2241 	 * Free the readdir cache entries.
2242 	 */
2243 	if (HAVE_RDDIR_CACHE(rp))
2244 		nfs_purge_rddir_cache(vp);
2245 
2246 	/*
2247 	 * Free the symbolic link cache.
2248 	 */
2249 	if (contents != NULL) {
2250 
2251 		kmem_free((void *)contents, size);
2252 	}
2253 
2254 	/*
2255 	 * Free any cached ACL.
2256 	 */
2257 	if (vsp != NULL)
2258 		nfs_acl_free(vsp);
2259 
2260 	/*
2261 	 * Free any cached pathconf information.
2262 	 */
2263 	if (info != NULL)
2264 		kmem_free(info, sizeof (*info));
2265 }
2266 
2267 /*
2268  * Return a vnode for the given NFS Version 2 file handle.
2269  * If no rnode exists for this fhandle, create one and put it
2270  * into the hash queues.  If the rnode for this fhandle
2271  * already exists, return it.
2272  *
2273  * Note: make_rnode() may upgrade the hash bucket lock to exclusive.
2274  */
2275 vnode_t *
2276 makenfsnode(fhandle_t *fh, struct nfsfattr *attr, struct vfs *vfsp,
2277     hrtime_t t, cred_t *cr, char *dnm, char *nm)
2278 {
2279 	int newnode;
2280 	int index;
2281 	vnode_t *vp;
2282 	nfs_fhandle nfh;
2283 	vattr_t va;
2284 
2285 	nfh.fh_len = NFS_FHSIZE;
2286 	bcopy(fh, nfh.fh_buf, NFS_FHSIZE);
2287 
2288 	index = rtablehash(&nfh);
2289 	rw_enter(&rtable[index].r_lock, RW_READER);
2290 
2291 	vp = make_rnode(&nfh, &rtable[index], vfsp, nfs_vnodeops,
2292 	    nfs_putapage, nfs_rddir_compar, &newnode, cr, dnm, nm);
2293 
2294 	if (attr != NULL) {
2295 		if (!newnode) {
2296 			rw_exit(&rtable[index].r_lock);
2297 			(void) nfs_cache_fattr(vp, attr, &va, t, cr);
2298 		} else {
2299 			if (attr->na_type < NFNON || attr->na_type > NFSOC)
2300 				vp->v_type = VBAD;
2301 			else
2302 				vp->v_type = n2v_type(attr);
2303 			/*
2304 			 * A translation here seems to be necessary
2305 			 * because this function can be called
2306 			 * with `attr' that has come from the wire,
2307 			 * and been operated on by vattr_to_nattr().
2308 			 * See nfsrootvp()->VOP_GETTATTR()->nfsgetattr()
2309 			 * ->nfs_getattr_otw()->rfscall()->vattr_to_nattr()
2310 			 * ->makenfsnode().
2311 			 */
2312 			if ((attr->na_rdev & 0xffff0000) == 0)
2313 				vp->v_rdev = nfsv2_expdev(attr->na_rdev);
2314 			else
2315 				vp->v_rdev = expldev(n2v_rdev(attr));
2316 			nfs_attrcache(vp, attr, t);
2317 			rw_exit(&rtable[index].r_lock);
2318 		}
2319 	} else {
2320 		if (newnode) {
2321 			PURGE_ATTRCACHE(vp);
2322 		}
2323 		rw_exit(&rtable[index].r_lock);
2324 	}
2325 
2326 	return (vp);
2327 }
2328 
2329 /*
2330  * Return a vnode for the given NFS Version 3 file handle.
2331  * If no rnode exists for this fhandle, create one and put it
2332  * into the hash queues.  If the rnode for this fhandle
2333  * already exists, return it.
2334  *
2335  * Note: make_rnode() may upgrade the hash bucket lock to exclusive.
2336  */
2337 vnode_t *
2338 makenfs3node_va(nfs_fh3 *fh, vattr_t *vap, struct vfs *vfsp, hrtime_t t,
2339     cred_t *cr, char *dnm, char *nm)
2340 {
2341 	int newnode;
2342 	int index;
2343 	vnode_t *vp;
2344 
2345 	index = rtablehash((nfs_fhandle *)fh);
2346 	rw_enter(&rtable[index].r_lock, RW_READER);
2347 
2348 	vp = make_rnode((nfs_fhandle *)fh, &rtable[index], vfsp,
2349 	    nfs3_vnodeops, nfs3_putapage, nfs3_rddir_compar, &newnode, cr,
2350 	    dnm, nm);
2351 
2352 	if (vap == NULL) {
2353 		if (newnode) {
2354 			PURGE_ATTRCACHE(vp);
2355 		}
2356 		rw_exit(&rtable[index].r_lock);
2357 		return (vp);
2358 	}
2359 
2360 	if (!newnode) {
2361 		rw_exit(&rtable[index].r_lock);
2362 		nfs_attr_cache(vp, vap, t, cr);
2363 	} else {
2364 		rnode_t *rp = VTOR(vp);
2365 
2366 		vp->v_type = vap->va_type;
2367 		vp->v_rdev = vap->va_rdev;
2368 
2369 		mutex_enter(&rp->r_statelock);
2370 		if (rp->r_mtime <= t)
2371 			nfs_attrcache_va(vp, vap);
2372 		mutex_exit(&rp->r_statelock);
2373 		rw_exit(&rtable[index].r_lock);
2374 	}
2375 
2376 	return (vp);
2377 }
2378 
2379 vnode_t *
2380 makenfs3node(nfs_fh3 *fh, fattr3 *attr, struct vfs *vfsp, hrtime_t t,
2381     cred_t *cr, char *dnm, char *nm)
2382 {
2383 	int newnode;
2384 	int index;
2385 	vnode_t *vp;
2386 	vattr_t va;
2387 
2388 	index = rtablehash((nfs_fhandle *)fh);
2389 	rw_enter(&rtable[index].r_lock, RW_READER);
2390 
2391 	vp = make_rnode((nfs_fhandle *)fh, &rtable[index], vfsp,
2392 	    nfs3_vnodeops, nfs3_putapage, nfs3_rddir_compar, &newnode, cr,
2393 	    dnm, nm);
2394 
2395 	if (attr == NULL) {
2396 		if (newnode) {
2397 			PURGE_ATTRCACHE(vp);
2398 		}
2399 		rw_exit(&rtable[index].r_lock);
2400 		return (vp);
2401 	}
2402 
2403 	if (!newnode) {
2404 		rw_exit(&rtable[index].r_lock);
2405 		(void) nfs3_cache_fattr3(vp, attr, &va, t, cr);
2406 	} else {
2407 		if (attr->type < NF3REG || attr->type > NF3FIFO)
2408 			vp->v_type = VBAD;
2409 		else
2410 			vp->v_type = nf3_to_vt[attr->type];
2411 		vp->v_rdev = makedevice(attr->rdev.specdata1,
2412 		    attr->rdev.specdata2);
2413 		nfs3_attrcache(vp, attr, t);
2414 		rw_exit(&rtable[index].r_lock);
2415 	}
2416 
2417 	return (vp);
2418 }
2419 
2420 /*
2421  * Read this comment before making changes to rtablehash()!
2422  * This is a hash function in which seemingly obvious and harmless
2423  * changes can cause escalations costing million dollars!
2424  * Know what you are doing.
2425  *
2426  * rtablehash() implements Jenkins' one-at-a-time hash algorithm.  The
2427  * algorithm is currently detailed here:
2428  *
2429  *   http://burtleburtle.net/bob/hash/doobs.html
2430  *
2431  * Of course, the above link may not be valid by the time you are reading
2432  * this, but suffice it to say that the one-at-a-time algorithm works well in
2433  * almost all cases.  If you are changing the algorithm be sure to verify that
2434  * the hash algorithm still provides even distribution in all cases and with
2435  * any server returning filehandles in whatever order (sequential or random).
2436  */
2437 static int
2438 rtablehash(nfs_fhandle *fh)
2439 {
2440 	ulong_t hash, len, i;
2441 	char *key;
2442 
2443 	key = fh->fh_buf;
2444 	len = (ulong_t)fh->fh_len;
2445 	for (hash = 0, i = 0; i < len; i++) {
2446 		hash += key[i];
2447 		hash += (hash << 10);
2448 		hash ^= (hash >> 6);
2449 	}
2450 	hash += (hash << 3);
2451 	hash ^= (hash >> 11);
2452 	hash += (hash << 15);
2453 	return (hash & rtablemask);
2454 }
2455 
2456 static vnode_t *
2457 make_rnode(nfs_fhandle *fh, rhashq_t *rhtp, struct vfs *vfsp,
2458     struct vnodeops *vops,
2459     int (*putapage)(vnode_t *, page_t *, u_offset_t *, size_t *, int, cred_t *),
2460     int (*compar)(const void *, const void *),
2461     int *newnode, cred_t *cr, char *dnm, char *nm)
2462 {
2463 	rnode_t *rp;
2464 	rnode_t *trp;
2465 	vnode_t *vp;
2466 	mntinfo_t *mi;
2467 
2468 	ASSERT(RW_READ_HELD(&rhtp->r_lock));
2469 
2470 	mi = VFTOMI(vfsp);
2471 start:
2472 	if ((rp = rfind(rhtp, fh, vfsp)) != NULL) {
2473 		vp = RTOV(rp);
2474 		nfs_set_vroot(vp);
2475 		*newnode = 0;
2476 		return (vp);
2477 	}
2478 	rw_exit(&rhtp->r_lock);
2479 
2480 	mutex_enter(&rpfreelist_lock);
2481 	if (rpfreelist != NULL && rnew >= nrnode) {
2482 		rp = rpfreelist;
2483 		rp_rmfree(rp);
2484 		mutex_exit(&rpfreelist_lock);
2485 
2486 		vp = RTOV(rp);
2487 
2488 		if (rp->r_flags & RHASHED) {
2489 			rw_enter(&rp->r_hashq->r_lock, RW_WRITER);
2490 			mutex_enter(&vp->v_lock);
2491 			if (vp->v_count > 1) {
2492 				vp->v_count--;
2493 				mutex_exit(&vp->v_lock);
2494 				rw_exit(&rp->r_hashq->r_lock);
2495 				rw_enter(&rhtp->r_lock, RW_READER);
2496 				goto start;
2497 			}
2498 			mutex_exit(&vp->v_lock);
2499 			rp_rmhash_locked(rp);
2500 			rw_exit(&rp->r_hashq->r_lock);
2501 		}
2502 
2503 		rinactive(rp, cr);
2504 
2505 		mutex_enter(&vp->v_lock);
2506 		if (vp->v_count > 1) {
2507 			vp->v_count--;
2508 			mutex_exit(&vp->v_lock);
2509 			rw_enter(&rhtp->r_lock, RW_READER);
2510 			goto start;
2511 		}
2512 		mutex_exit(&vp->v_lock);
2513 		vn_invalid(vp);
2514 		/*
2515 		 * destroy old locks before bzero'ing and
2516 		 * recreating the locks below.
2517 		 */
2518 		nfs_rw_destroy(&rp->r_rwlock);
2519 		nfs_rw_destroy(&rp->r_lkserlock);
2520 		mutex_destroy(&rp->r_statelock);
2521 		cv_destroy(&rp->r_cv);
2522 		cv_destroy(&rp->r_commit.c_cv);
2523 		nfs_free_r_path(rp);
2524 		avl_destroy(&rp->r_dir);
2525 		/*
2526 		 * Make sure that if rnode is recycled then
2527 		 * VFS count is decremented properly before
2528 		 * reuse.
2529 		 */
2530 		VFS_RELE(vp->v_vfsp);
2531 		vn_reinit(vp);
2532 	} else {
2533 		vnode_t *new_vp;
2534 
2535 		mutex_exit(&rpfreelist_lock);
2536 
2537 		rp = kmem_cache_alloc(rnode_cache, KM_SLEEP);
2538 		new_vp = vn_alloc(KM_SLEEP);
2539 
2540 		atomic_inc_ulong((ulong_t *)&rnew);
2541 #ifdef DEBUG
2542 		clstat_debug.nrnode.value.ui64++;
2543 #endif
2544 		vp = new_vp;
2545 	}
2546 
2547 	bzero(rp, sizeof (*rp));
2548 	rp->r_vnode = vp;
2549 	nfs_rw_init(&rp->r_rwlock, NULL, RW_DEFAULT, NULL);
2550 	nfs_rw_init(&rp->r_lkserlock, NULL, RW_DEFAULT, NULL);
2551 	mutex_init(&rp->r_statelock, NULL, MUTEX_DEFAULT, NULL);
2552 	cv_init(&rp->r_cv, NULL, CV_DEFAULT, NULL);
2553 	cv_init(&rp->r_commit.c_cv, NULL, CV_DEFAULT, NULL);
2554 	rp->r_fh.fh_len = fh->fh_len;
2555 	bcopy(fh->fh_buf, rp->r_fh.fh_buf, fh->fh_len);
2556 	rp->r_server = mi->mi_curr_serv;
2557 	if (FAILOVER_MOUNT(mi)) {
2558 		/*
2559 		 * If replicated servers, stash pathnames
2560 		 */
2561 		if (dnm != NULL && nm != NULL) {
2562 			char *s, *p;
2563 			uint_t len;
2564 
2565 			len = (uint_t)(strlen(dnm) + strlen(nm) + 2);
2566 			rp->r_path = kmem_alloc(len, KM_SLEEP);
2567 #ifdef DEBUG
2568 			clstat_debug.rpath.value.ui64 += len;
2569 #endif
2570 			s = rp->r_path;
2571 			for (p = dnm; *p; p++)
2572 				*s++ = *p;
2573 			*s++ = '/';
2574 			for (p = nm; *p; p++)
2575 				*s++ = *p;
2576 			*s = '\0';
2577 		} else {
2578 			/* special case for root */
2579 			rp->r_path = kmem_alloc(2, KM_SLEEP);
2580 #ifdef DEBUG
2581 			clstat_debug.rpath.value.ui64 += 2;
2582 #endif
2583 			*rp->r_path = '.';
2584 			*(rp->r_path + 1) = '\0';
2585 		}
2586 	}
2587 	VFS_HOLD(vfsp);
2588 	rp->r_putapage = putapage;
2589 	rp->r_hashq = rhtp;
2590 	rp->r_flags = RREADDIRPLUS;
2591 	avl_create(&rp->r_dir, compar, sizeof (rddir_cache),
2592 	    offsetof(rddir_cache, tree));
2593 	vn_setops(vp, vops);
2594 	vp->v_data = (caddr_t)rp;
2595 	vp->v_vfsp = vfsp;
2596 	vp->v_type = VNON;
2597 	vp->v_flag |= VMODSORT;
2598 	nfs_set_vroot(vp);
2599 
2600 	/*
2601 	 * There is a race condition if someone else
2602 	 * alloc's the rnode while no locks are held, so we
2603 	 * check again and recover if found.
2604 	 */
2605 	rw_enter(&rhtp->r_lock, RW_WRITER);
2606 	if ((trp = rfind(rhtp, fh, vfsp)) != NULL) {
2607 		vp = RTOV(trp);
2608 		nfs_set_vroot(vp);
2609 		*newnode = 0;
2610 		rw_exit(&rhtp->r_lock);
2611 		rp_addfree(rp, cr);
2612 		rw_enter(&rhtp->r_lock, RW_READER);
2613 		return (vp);
2614 	}
2615 	rp_addhash(rp);
2616 	*newnode = 1;
2617 	return (vp);
2618 }
2619 
2620 /*
2621  * Callback function to check if the page should be marked as
2622  * modified. In the positive case, p_fsdata is set to C_NOCOMMIT.
2623  */
2624 int
2625 nfs_setmod_check(page_t *pp)
2626 {
2627 	if (pp->p_fsdata != C_NOCOMMIT) {
2628 		pp->p_fsdata = C_NOCOMMIT;
2629 		return (1);
2630 	}
2631 	return (0);
2632 }
2633 
2634 static void
2635 nfs_set_vroot(vnode_t *vp)
2636 {
2637 	rnode_t *rp;
2638 	nfs_fhandle *rootfh;
2639 
2640 	rp = VTOR(vp);
2641 	rootfh = &rp->r_server->sv_fhandle;
2642 	if (rootfh->fh_len == rp->r_fh.fh_len &&
2643 	    bcmp(rootfh->fh_buf, rp->r_fh.fh_buf, rp->r_fh.fh_len) == 0) {
2644 		if (!(vp->v_flag & VROOT)) {
2645 			mutex_enter(&vp->v_lock);
2646 			vp->v_flag |= VROOT;
2647 			mutex_exit(&vp->v_lock);
2648 		}
2649 	}
2650 }
2651 
2652 static void
2653 nfs_free_r_path(rnode_t *rp)
2654 {
2655 	char *path;
2656 	size_t len;
2657 
2658 	path = rp->r_path;
2659 	if (path) {
2660 		rp->r_path = NULL;
2661 		len = strlen(path) + 1;
2662 		kmem_free(path, len);
2663 #ifdef DEBUG
2664 		clstat_debug.rpath.value.ui64 -= len;
2665 #endif
2666 	}
2667 }
2668 
2669 /*
2670  * Put an rnode on the free list.
2671  *
2672  * Rnodes which were allocated above and beyond the normal limit
2673  * are immediately freed.
2674  */
2675 void
2676 rp_addfree(rnode_t *rp, cred_t *cr)
2677 {
2678 	vnode_t *vp;
2679 	struct vfs *vfsp;
2680 
2681 	vp = RTOV(rp);
2682 	ASSERT(vp->v_count >= 1);
2683 	ASSERT(rp->r_freef == NULL && rp->r_freeb == NULL);
2684 
2685 	/*
2686 	 * If we have too many rnodes allocated and there are no
2687 	 * references to this rnode, or if the rnode is no longer
2688 	 * accessible by it does not reside in the hash queues,
2689 	 * or if an i/o error occurred while writing to the file,
2690 	 * then just free it instead of putting it on the rnode
2691 	 * freelist.
2692 	 */
2693 	vfsp = vp->v_vfsp;
2694 	if (((rnew > nrnode || !(rp->r_flags & RHASHED) || rp->r_error ||
2695 	    (vfsp->vfs_flag & VFS_UNMOUNTED)) && rp->r_count == 0)) {
2696 		if (rp->r_flags & RHASHED) {
2697 			rw_enter(&rp->r_hashq->r_lock, RW_WRITER);
2698 			mutex_enter(&vp->v_lock);
2699 			if (vp->v_count > 1) {
2700 				vp->v_count--;
2701 				mutex_exit(&vp->v_lock);
2702 				rw_exit(&rp->r_hashq->r_lock);
2703 				return;
2704 			}
2705 			mutex_exit(&vp->v_lock);
2706 			rp_rmhash_locked(rp);
2707 			rw_exit(&rp->r_hashq->r_lock);
2708 		}
2709 
2710 		rinactive(rp, cr);
2711 
2712 		/*
2713 		 * Recheck the vnode reference count.  We need to
2714 		 * make sure that another reference has not been
2715 		 * acquired while we were not holding v_lock.  The
2716 		 * rnode is not in the rnode hash queues, so the
2717 		 * only way for a reference to have been acquired
2718 		 * is for a VOP_PUTPAGE because the rnode was marked
2719 		 * with RDIRTY or for a modified page.  This
2720 		 * reference may have been acquired before our call
2721 		 * to rinactive.  The i/o may have been completed,
2722 		 * thus allowing rinactive to complete, but the
2723 		 * reference to the vnode may not have been released
2724 		 * yet.  In any case, the rnode can not be destroyed
2725 		 * until the other references to this vnode have been
2726 		 * released.  The other references will take care of
2727 		 * either destroying the rnode or placing it on the
2728 		 * rnode freelist.  If there are no other references,
2729 		 * then the rnode may be safely destroyed.
2730 		 */
2731 		mutex_enter(&vp->v_lock);
2732 		if (vp->v_count > 1) {
2733 			vp->v_count--;
2734 			mutex_exit(&vp->v_lock);
2735 			return;
2736 		}
2737 		mutex_exit(&vp->v_lock);
2738 
2739 		destroy_rnode(rp);
2740 		return;
2741 	}
2742 
2743 	/*
2744 	 * Lock the hash queue and then recheck the reference count
2745 	 * to ensure that no other threads have acquired a reference
2746 	 * to indicate that the rnode should not be placed on the
2747 	 * freelist.  If another reference has been acquired, then
2748 	 * just release this one and let the other thread complete
2749 	 * the processing of adding this rnode to the freelist.
2750 	 */
2751 	rw_enter(&rp->r_hashq->r_lock, RW_WRITER);
2752 
2753 	mutex_enter(&vp->v_lock);
2754 	if (vp->v_count > 1) {
2755 		vp->v_count--;
2756 		mutex_exit(&vp->v_lock);
2757 		rw_exit(&rp->r_hashq->r_lock);
2758 		return;
2759 	}
2760 	mutex_exit(&vp->v_lock);
2761 
2762 	/*
2763 	 * If there is no cached data or metadata for this file, then
2764 	 * put the rnode on the front of the freelist so that it will
2765 	 * be reused before other rnodes which may have cached data or
2766 	 * metadata associated with them.
2767 	 */
2768 	mutex_enter(&rpfreelist_lock);
2769 	if (rpfreelist == NULL) {
2770 		rp->r_freef = rp;
2771 		rp->r_freeb = rp;
2772 		rpfreelist = rp;
2773 	} else {
2774 		rp->r_freef = rpfreelist;
2775 		rp->r_freeb = rpfreelist->r_freeb;
2776 		rpfreelist->r_freeb->r_freef = rp;
2777 		rpfreelist->r_freeb = rp;
2778 		if (!vn_has_cached_data(vp) &&
2779 		    !HAVE_RDDIR_CACHE(rp) &&
2780 		    rp->r_symlink.contents == NULL &&
2781 		    rp->r_secattr == NULL &&
2782 		    rp->r_pathconf == NULL)
2783 			rpfreelist = rp;
2784 	}
2785 	mutex_exit(&rpfreelist_lock);
2786 
2787 	rw_exit(&rp->r_hashq->r_lock);
2788 }
2789 
2790 /*
2791  * Remove an rnode from the free list.
2792  *
2793  * The caller must be holding rpfreelist_lock and the rnode
2794  * must be on the freelist.
2795  */
2796 static void
2797 rp_rmfree(rnode_t *rp)
2798 {
2799 
2800 	ASSERT(MUTEX_HELD(&rpfreelist_lock));
2801 	ASSERT(rp->r_freef != NULL && rp->r_freeb != NULL);
2802 
2803 	if (rp == rpfreelist) {
2804 		rpfreelist = rp->r_freef;
2805 		if (rp == rpfreelist)
2806 			rpfreelist = NULL;
2807 	}
2808 
2809 	rp->r_freeb->r_freef = rp->r_freef;
2810 	rp->r_freef->r_freeb = rp->r_freeb;
2811 
2812 	rp->r_freef = rp->r_freeb = NULL;
2813 }
2814 
2815 /*
2816  * Put a rnode in the hash table.
2817  *
2818  * The caller must be holding the exclusive hash queue lock.
2819  */
2820 static void
2821 rp_addhash(rnode_t *rp)
2822 {
2823 
2824 	ASSERT(RW_WRITE_HELD(&rp->r_hashq->r_lock));
2825 	ASSERT(!(rp->r_flags & RHASHED));
2826 
2827 	rp->r_hashf = rp->r_hashq->r_hashf;
2828 	rp->r_hashq->r_hashf = rp;
2829 	rp->r_hashb = (rnode_t *)rp->r_hashq;
2830 	rp->r_hashf->r_hashb = rp;
2831 
2832 	mutex_enter(&rp->r_statelock);
2833 	rp->r_flags |= RHASHED;
2834 	mutex_exit(&rp->r_statelock);
2835 }
2836 
2837 /*
2838  * Remove a rnode from the hash table.
2839  *
2840  * The caller must be holding the hash queue lock.
2841  */
2842 static void
2843 rp_rmhash_locked(rnode_t *rp)
2844 {
2845 
2846 	ASSERT(RW_WRITE_HELD(&rp->r_hashq->r_lock));
2847 	ASSERT(rp->r_flags & RHASHED);
2848 
2849 	rp->r_hashb->r_hashf = rp->r_hashf;
2850 	rp->r_hashf->r_hashb = rp->r_hashb;
2851 
2852 	mutex_enter(&rp->r_statelock);
2853 	rp->r_flags &= ~RHASHED;
2854 	mutex_exit(&rp->r_statelock);
2855 }
2856 
2857 /*
2858  * Remove a rnode from the hash table.
2859  *
2860  * The caller must not be holding the hash queue lock.
2861  */
2862 void
2863 rp_rmhash(rnode_t *rp)
2864 {
2865 
2866 	rw_enter(&rp->r_hashq->r_lock, RW_WRITER);
2867 	rp_rmhash_locked(rp);
2868 	rw_exit(&rp->r_hashq->r_lock);
2869 }
2870 
2871 /*
2872  * Lookup a rnode by fhandle.
2873  *
2874  * The caller must be holding the hash queue lock, either shared or exclusive.
2875  */
2876 static rnode_t *
2877 rfind(rhashq_t *rhtp, nfs_fhandle *fh, struct vfs *vfsp)
2878 {
2879 	rnode_t *rp;
2880 	vnode_t *vp;
2881 
2882 	ASSERT(RW_LOCK_HELD(&rhtp->r_lock));
2883 
2884 	for (rp = rhtp->r_hashf; rp != (rnode_t *)rhtp; rp = rp->r_hashf) {
2885 		vp = RTOV(rp);
2886 		if (vp->v_vfsp == vfsp &&
2887 		    rp->r_fh.fh_len == fh->fh_len &&
2888 		    bcmp(rp->r_fh.fh_buf, fh->fh_buf, fh->fh_len) == 0) {
2889 			/*
2890 			 * remove rnode from free list, if necessary.
2891 			 */
2892 			if (rp->r_freef != NULL) {
2893 				mutex_enter(&rpfreelist_lock);
2894 				/*
2895 				 * If the rnode is on the freelist,
2896 				 * then remove it and use that reference
2897 				 * as the new reference.  Otherwise,
2898 				 * need to increment the reference count.
2899 				 */
2900 				if (rp->r_freef != NULL) {
2901 					rp_rmfree(rp);
2902 					mutex_exit(&rpfreelist_lock);
2903 				} else {
2904 					mutex_exit(&rpfreelist_lock);
2905 					VN_HOLD(vp);
2906 				}
2907 			} else
2908 				VN_HOLD(vp);
2909 			return (rp);
2910 		}
2911 	}
2912 	return (NULL);
2913 }
2914 
2915 /*
2916  * Return 1 if there is a active vnode belonging to this vfs in the
2917  * rtable cache.
2918  *
2919  * Several of these checks are done without holding the usual
2920  * locks.  This is safe because destroy_rtable(), rp_addfree(),
2921  * etc. will redo the necessary checks before actually destroying
2922  * any rnodes.
2923  */
2924 int
2925 check_rtable(struct vfs *vfsp)
2926 {
2927 	int index;
2928 	rnode_t *rp;
2929 	vnode_t *vp;
2930 
2931 	for (index = 0; index < rtablesize; index++) {
2932 		rw_enter(&rtable[index].r_lock, RW_READER);
2933 		for (rp = rtable[index].r_hashf;
2934 		    rp != (rnode_t *)(&rtable[index]);
2935 		    rp = rp->r_hashf) {
2936 			vp = RTOV(rp);
2937 			if (vp->v_vfsp == vfsp) {
2938 				if (rp->r_freef == NULL ||
2939 				    (vn_has_cached_data(vp) &&
2940 				    (rp->r_flags & RDIRTY)) ||
2941 				    rp->r_count > 0) {
2942 					rw_exit(&rtable[index].r_lock);
2943 					return (1);
2944 				}
2945 			}
2946 		}
2947 		rw_exit(&rtable[index].r_lock);
2948 	}
2949 	return (0);
2950 }
2951 
2952 /*
2953  * Destroy inactive vnodes from the hash queues which belong to this
2954  * vfs.  It is essential that we destroy all inactive vnodes during a
2955  * forced unmount as well as during a normal unmount.
2956  */
2957 void
2958 destroy_rtable(struct vfs *vfsp, cred_t *cr)
2959 {
2960 	int index;
2961 	rnode_t *rp;
2962 	rnode_t *rlist;
2963 	rnode_t *r_hashf;
2964 	vnode_t *vp;
2965 
2966 	rlist = NULL;
2967 
2968 	for (index = 0; index < rtablesize; index++) {
2969 		rw_enter(&rtable[index].r_lock, RW_WRITER);
2970 		for (rp = rtable[index].r_hashf;
2971 		    rp != (rnode_t *)(&rtable[index]);
2972 		    rp = r_hashf) {
2973 			/* save the hash pointer before destroying */
2974 			r_hashf = rp->r_hashf;
2975 			vp = RTOV(rp);
2976 			if (vp->v_vfsp == vfsp) {
2977 				mutex_enter(&rpfreelist_lock);
2978 				if (rp->r_freef != NULL) {
2979 					rp_rmfree(rp);
2980 					mutex_exit(&rpfreelist_lock);
2981 					rp_rmhash_locked(rp);
2982 					rp->r_hashf = rlist;
2983 					rlist = rp;
2984 				} else
2985 					mutex_exit(&rpfreelist_lock);
2986 			}
2987 		}
2988 		rw_exit(&rtable[index].r_lock);
2989 	}
2990 
2991 	for (rp = rlist; rp != NULL; rp = rlist) {
2992 		rlist = rp->r_hashf;
2993 		/*
2994 		 * This call to rp_addfree will end up destroying the
2995 		 * rnode, but in a safe way with the appropriate set
2996 		 * of checks done.
2997 		 */
2998 		rp_addfree(rp, cr);
2999 	}
3000 
3001 }
3002 
3003 /*
3004  * This routine destroys all the resources associated with the rnode
3005  * and then the rnode itself.
3006  */
3007 static void
3008 destroy_rnode(rnode_t *rp)
3009 {
3010 	vnode_t *vp;
3011 	vfs_t *vfsp;
3012 
3013 	vp = RTOV(rp);
3014 	vfsp = vp->v_vfsp;
3015 
3016 	ASSERT(vp->v_count == 1);
3017 	ASSERT(rp->r_count == 0);
3018 	ASSERT(rp->r_lmpl == NULL);
3019 	ASSERT(rp->r_mapcnt == 0);
3020 	ASSERT(!(rp->r_flags & RHASHED));
3021 	ASSERT(rp->r_freef == NULL && rp->r_freeb == NULL);
3022 	atomic_dec_ulong((ulong_t *)&rnew);
3023 #ifdef DEBUG
3024 	clstat_debug.nrnode.value.ui64--;
3025 #endif
3026 	nfs_rw_destroy(&rp->r_rwlock);
3027 	nfs_rw_destroy(&rp->r_lkserlock);
3028 	mutex_destroy(&rp->r_statelock);
3029 	cv_destroy(&rp->r_cv);
3030 	cv_destroy(&rp->r_commit.c_cv);
3031 	if (rp->r_flags & RDELMAPLIST)
3032 		list_destroy(&rp->r_indelmap);
3033 	nfs_free_r_path(rp);
3034 	avl_destroy(&rp->r_dir);
3035 	vn_invalid(vp);
3036 	vn_free(vp);
3037 	kmem_cache_free(rnode_cache, rp);
3038 	VFS_RELE(vfsp);
3039 }
3040 
3041 /*
3042  * Flush all vnodes in this (or every) vfs.
3043  * Used by nfs_sync and by nfs_unmount.
3044  */
3045 void
3046 rflush(struct vfs *vfsp, cred_t *cr)
3047 {
3048 	int index;
3049 	rnode_t *rp;
3050 	vnode_t *vp, **vplist;
3051 	long num, cnt;
3052 
3053 	/*
3054 	 * Check to see whether there is anything to do.
3055 	 */
3056 	num = rnew;
3057 	if (num == 0)
3058 		return;
3059 
3060 	/*
3061 	 * Allocate a slot for all currently active rnodes on the
3062 	 * supposition that they all may need flushing.
3063 	 */
3064 	vplist = kmem_alloc(num * sizeof (*vplist), KM_SLEEP);
3065 	cnt = 0;
3066 
3067 	/*
3068 	 * Walk the hash queues looking for rnodes with page
3069 	 * lists associated with them.  Make a list of these
3070 	 * files.
3071 	 */
3072 	for (index = 0; index < rtablesize; index++) {
3073 		rw_enter(&rtable[index].r_lock, RW_READER);
3074 		for (rp = rtable[index].r_hashf;
3075 		    rp != (rnode_t *)(&rtable[index]);
3076 		    rp = rp->r_hashf) {
3077 			vp = RTOV(rp);
3078 			/*
3079 			 * Don't bother sync'ing a vp if it
3080 			 * is part of virtual swap device or
3081 			 * if VFS is read-only
3082 			 */
3083 			if (IS_SWAPVP(vp) || vn_is_readonly(vp))
3084 				continue;
3085 			/*
3086 			 * If flushing all mounted file systems or
3087 			 * the vnode belongs to this vfs, has pages
3088 			 * and is marked as either dirty or mmap'd,
3089 			 * hold and add this vnode to the list of
3090 			 * vnodes to flush.
3091 			 */
3092 			if ((vfsp == NULL || vp->v_vfsp == vfsp) &&
3093 			    vn_has_cached_data(vp) &&
3094 			    ((rp->r_flags & RDIRTY) || rp->r_mapcnt > 0)) {
3095 				VN_HOLD(vp);
3096 				vplist[cnt++] = vp;
3097 				if (cnt == num) {
3098 					rw_exit(&rtable[index].r_lock);
3099 					goto toomany;
3100 				}
3101 			}
3102 		}
3103 		rw_exit(&rtable[index].r_lock);
3104 	}
3105 toomany:
3106 
3107 	/*
3108 	 * Flush and release all of the files on the list.
3109 	 */
3110 	while (cnt-- > 0) {
3111 		vp = vplist[cnt];
3112 		(void) VOP_PUTPAGE(vp, (u_offset_t)0, 0, B_ASYNC, cr, NULL);
3113 		VN_RELE(vp);
3114 	}
3115 
3116 	/*
3117 	 * Free the space allocated to hold the list.
3118 	 */
3119 	kmem_free(vplist, num * sizeof (*vplist));
3120 }
3121 
3122 /*
3123  * This probably needs to be larger than or equal to
3124  * log2(sizeof (struct rnode)) due to the way that rnodes are
3125  * allocated.
3126  */
3127 #define	ACACHE_SHIFT_BITS	9
3128 
3129 static int
3130 acachehash(rnode_t *rp, cred_t *cr)
3131 {
3132 
3133 	return ((((intptr_t)rp >> ACACHE_SHIFT_BITS) + crgetuid(cr)) &
3134 	    acachemask);
3135 }
3136 
3137 #ifdef DEBUG
3138 static long nfs_access_cache_hits = 0;
3139 static long nfs_access_cache_misses = 0;
3140 #endif
3141 
3142 nfs_access_type_t
3143 nfs_access_check(rnode_t *rp, uint32_t acc, cred_t *cr)
3144 {
3145 	vnode_t *vp;
3146 	acache_t *ap;
3147 	acache_hash_t *hp;
3148 	nfs_access_type_t all;
3149 
3150 	vp = RTOV(rp);
3151 	if (!ATTRCACHE_VALID(vp) || nfs_waitfor_purge_complete(vp))
3152 		return (NFS_ACCESS_UNKNOWN);
3153 
3154 	if (rp->r_acache != NULL) {
3155 		hp = &acache[acachehash(rp, cr)];
3156 		rw_enter(&hp->lock, RW_READER);
3157 		ap = hp->next;
3158 		while (ap != (acache_t *)hp) {
3159 			if (crcmp(ap->cred, cr) == 0 && ap->rnode == rp) {
3160 				if ((ap->known & acc) == acc) {
3161 #ifdef DEBUG
3162 					nfs_access_cache_hits++;
3163 #endif
3164 					if ((ap->allowed & acc) == acc)
3165 						all = NFS_ACCESS_ALLOWED;
3166 					else
3167 						all = NFS_ACCESS_DENIED;
3168 				} else {
3169 #ifdef DEBUG
3170 					nfs_access_cache_misses++;
3171 #endif
3172 					all = NFS_ACCESS_UNKNOWN;
3173 				}
3174 				rw_exit(&hp->lock);
3175 				return (all);
3176 			}
3177 			ap = ap->next;
3178 		}
3179 		rw_exit(&hp->lock);
3180 	}
3181 
3182 #ifdef DEBUG
3183 	nfs_access_cache_misses++;
3184 #endif
3185 	return (NFS_ACCESS_UNKNOWN);
3186 }
3187 
3188 void
3189 nfs_access_cache(rnode_t *rp, uint32_t acc, uint32_t resacc, cred_t *cr)
3190 {
3191 	acache_t *ap;
3192 	acache_t *nap;
3193 	acache_hash_t *hp;
3194 
3195 	hp = &acache[acachehash(rp, cr)];
3196 
3197 	/*
3198 	 * Allocate now assuming that mostly an allocation will be
3199 	 * required.  This allows the allocation to happen without
3200 	 * holding the hash bucket locked.
3201 	 */
3202 	nap = kmem_cache_alloc(acache_cache, KM_NOSLEEP);
3203 	if (nap != NULL) {
3204 		nap->known = acc;
3205 		nap->allowed = resacc;
3206 		nap->rnode = rp;
3207 		crhold(cr);
3208 		nap->cred = cr;
3209 		nap->hashq = hp;
3210 	}
3211 
3212 	rw_enter(&hp->lock, RW_WRITER);
3213 
3214 	if (rp->r_acache != NULL) {
3215 		ap = hp->next;
3216 		while (ap != (acache_t *)hp) {
3217 			if (crcmp(ap->cred, cr) == 0 && ap->rnode == rp) {
3218 				ap->known |= acc;
3219 				ap->allowed &= ~acc;
3220 				ap->allowed |= resacc;
3221 				rw_exit(&hp->lock);
3222 				if (nap != NULL) {
3223 					crfree(nap->cred);
3224 					kmem_cache_free(acache_cache, nap);
3225 				}
3226 				return;
3227 			}
3228 			ap = ap->next;
3229 		}
3230 	}
3231 
3232 	if (nap != NULL) {
3233 #ifdef DEBUG
3234 		clstat_debug.access.value.ui64++;
3235 #endif
3236 		nap->next = hp->next;
3237 		hp->next = nap;
3238 		nap->next->prev = nap;
3239 		nap->prev = (acache_t *)hp;
3240 
3241 		mutex_enter(&rp->r_statelock);
3242 		nap->list = rp->r_acache;
3243 		rp->r_acache = nap;
3244 		mutex_exit(&rp->r_statelock);
3245 	}
3246 
3247 	rw_exit(&hp->lock);
3248 }
3249 
3250 int
3251 nfs_access_purge_rp(rnode_t *rp)
3252 {
3253 	acache_t *ap;
3254 	acache_t *tmpap;
3255 	acache_t *rplist;
3256 
3257 	/*
3258 	 * If there aren't any cached entries, then there is nothing
3259 	 * to free.
3260 	 */
3261 	if (rp->r_acache == NULL)
3262 		return (0);
3263 
3264 	mutex_enter(&rp->r_statelock);
3265 	rplist = rp->r_acache;
3266 	rp->r_acache = NULL;
3267 	mutex_exit(&rp->r_statelock);
3268 
3269 	/*
3270 	 * Loop through each entry in the list pointed to in the
3271 	 * rnode.  Remove each of these entries from the hash
3272 	 * queue that it is on and remove it from the list in
3273 	 * the rnode.
3274 	 */
3275 	for (ap = rplist; ap != NULL; ap = tmpap) {
3276 		rw_enter(&ap->hashq->lock, RW_WRITER);
3277 		ap->prev->next = ap->next;
3278 		ap->next->prev = ap->prev;
3279 		rw_exit(&ap->hashq->lock);
3280 
3281 		tmpap = ap->list;
3282 		crfree(ap->cred);
3283 		kmem_cache_free(acache_cache, ap);
3284 #ifdef DEBUG
3285 		clstat_debug.access.value.ui64--;
3286 #endif
3287 	}
3288 
3289 	return (1);
3290 }
3291 
3292 static const char prefix[] = ".nfs";
3293 
3294 static kmutex_t newnum_lock;
3295 
3296 int
3297 newnum(void)
3298 {
3299 	static uint_t newnum = 0;
3300 	uint_t id;
3301 
3302 	mutex_enter(&newnum_lock);
3303 	if (newnum == 0)
3304 		newnum = gethrestime_sec() & 0xffff;
3305 	id = newnum++;
3306 	mutex_exit(&newnum_lock);
3307 	return (id);
3308 }
3309 
3310 char *
3311 newname(void)
3312 {
3313 	char *news;
3314 	char *s;
3315 	const char *p;
3316 	uint_t id;
3317 
3318 	id = newnum();
3319 	news = kmem_alloc(MAXNAMELEN, KM_SLEEP);
3320 	s = news;
3321 	p = prefix;
3322 	while (*p != '\0')
3323 		*s++ = *p++;
3324 	while (id != 0) {
3325 		*s++ = "0123456789ABCDEF"[id & 0x0f];
3326 		id >>= 4;
3327 	}
3328 	*s = '\0';
3329 	return (news);
3330 }
3331 
3332 /*
3333  * Snapshot callback for nfs:0:nfs_client as registered with the kstat
3334  * framework.
3335  */
3336 static int
3337 cl_snapshot(kstat_t *ksp, void *buf, int rw)
3338 {
3339 	ksp->ks_snaptime = gethrtime();
3340 	if (rw == KSTAT_WRITE) {
3341 		bcopy(buf, ksp->ks_private, sizeof (clstat_tmpl));
3342 #ifdef DEBUG
3343 		/*
3344 		 * Currently only the global zone can write to kstats, but we
3345 		 * add the check just for paranoia.
3346 		 */
3347 		if (INGLOBALZONE(curproc))
3348 			bcopy((char *)buf + sizeof (clstat_tmpl), &clstat_debug,
3349 			    sizeof (clstat_debug));
3350 #endif
3351 	} else {
3352 		bcopy(ksp->ks_private, buf, sizeof (clstat_tmpl));
3353 #ifdef DEBUG
3354 		/*
3355 		 * If we're displaying the "global" debug kstat values, we
3356 		 * display them as-is to all zones since in fact they apply to
3357 		 * the system as a whole.
3358 		 */
3359 		bcopy(&clstat_debug, (char *)buf + sizeof (clstat_tmpl),
3360 		    sizeof (clstat_debug));
3361 #endif
3362 	}
3363 	return (0);
3364 }
3365 
3366 static void *
3367 clinit_zone(zoneid_t zoneid)
3368 {
3369 	kstat_t *nfs_client_kstat;
3370 	struct nfs_clnt *nfscl;
3371 	uint_t ndata;
3372 
3373 	nfscl = kmem_alloc(sizeof (*nfscl), KM_SLEEP);
3374 	mutex_init(&nfscl->nfscl_chtable_lock, NULL, MUTEX_DEFAULT, NULL);
3375 	nfscl->nfscl_chtable = NULL;
3376 	nfscl->nfscl_zoneid = zoneid;
3377 
3378 	bcopy(&clstat_tmpl, &nfscl->nfscl_stat, sizeof (clstat_tmpl));
3379 	ndata = sizeof (clstat_tmpl) / sizeof (kstat_named_t);
3380 #ifdef DEBUG
3381 	ndata += sizeof (clstat_debug) / sizeof (kstat_named_t);
3382 #endif
3383 	if ((nfs_client_kstat = kstat_create_zone("nfs", 0, "nfs_client",
3384 	    "misc", KSTAT_TYPE_NAMED, ndata,
3385 	    KSTAT_FLAG_VIRTUAL | KSTAT_FLAG_WRITABLE, zoneid)) != NULL) {
3386 		nfs_client_kstat->ks_private = &nfscl->nfscl_stat;
3387 		nfs_client_kstat->ks_snapshot = cl_snapshot;
3388 		kstat_install(nfs_client_kstat);
3389 	}
3390 	mutex_enter(&nfs_clnt_list_lock);
3391 	list_insert_head(&nfs_clnt_list, nfscl);
3392 	mutex_exit(&nfs_clnt_list_lock);
3393 	return (nfscl);
3394 }
3395 
3396 /*ARGSUSED*/
3397 static void
3398 clfini_zone(zoneid_t zoneid, void *arg)
3399 {
3400 	struct nfs_clnt *nfscl = arg;
3401 	chhead_t *chp, *next;
3402 
3403 	if (nfscl == NULL)
3404 		return;
3405 	mutex_enter(&nfs_clnt_list_lock);
3406 	list_remove(&nfs_clnt_list, nfscl);
3407 	mutex_exit(&nfs_clnt_list_lock);
3408 	clreclaim_zone(nfscl, 0);
3409 	for (chp = nfscl->nfscl_chtable; chp != NULL; chp = next) {
3410 		ASSERT(chp->ch_list == NULL);
3411 		kmem_free(chp->ch_protofmly, strlen(chp->ch_protofmly) + 1);
3412 		next = chp->ch_next;
3413 		kmem_free(chp, sizeof (*chp));
3414 	}
3415 	kstat_delete_byname_zone("nfs", 0, "nfs_client", zoneid);
3416 	mutex_destroy(&nfscl->nfscl_chtable_lock);
3417 	kmem_free(nfscl, sizeof (*nfscl));
3418 }
3419 
3420 /*
3421  * Called by endpnt_destructor to make sure the client handles are
3422  * cleaned up before the RPC endpoints.  This becomes a no-op if
3423  * clfini_zone (above) is called first.  This function is needed
3424  * (rather than relying on clfini_zone to clean up) because the ZSD
3425  * callbacks have no ordering mechanism, so we have no way to ensure
3426  * that clfini_zone is called before endpnt_destructor.
3427  */
3428 void
3429 clcleanup_zone(zoneid_t zoneid)
3430 {
3431 	struct nfs_clnt *nfscl;
3432 
3433 	mutex_enter(&nfs_clnt_list_lock);
3434 	nfscl = list_head(&nfs_clnt_list);
3435 	for (; nfscl != NULL; nfscl = list_next(&nfs_clnt_list, nfscl)) {
3436 		if (nfscl->nfscl_zoneid == zoneid) {
3437 			clreclaim_zone(nfscl, 0);
3438 			break;
3439 		}
3440 	}
3441 	mutex_exit(&nfs_clnt_list_lock);
3442 }
3443 
3444 int
3445 nfs_subrinit(void)
3446 {
3447 	int i;
3448 	ulong_t nrnode_max;
3449 
3450 	/*
3451 	 * Allocate and initialize the rnode hash queues
3452 	 */
3453 	if (nrnode <= 0)
3454 		nrnode = ncsize;
3455 	nrnode_max = (ulong_t)((kmem_maxavail() >> 2) / sizeof (struct rnode));
3456 	if (nrnode > nrnode_max || (nrnode == 0 && ncsize == 0)) {
3457 		zcmn_err(GLOBAL_ZONEID, CE_NOTE,
3458 		    "!setting nrnode to max value of %ld", nrnode_max);
3459 		nrnode = nrnode_max;
3460 	}
3461 
3462 	rtablesize = 1 << highbit(nrnode / hashlen);
3463 	rtablemask = rtablesize - 1;
3464 	rtable = kmem_alloc(rtablesize * sizeof (*rtable), KM_SLEEP);
3465 	for (i = 0; i < rtablesize; i++) {
3466 		rtable[i].r_hashf = (rnode_t *)(&rtable[i]);
3467 		rtable[i].r_hashb = (rnode_t *)(&rtable[i]);
3468 		rw_init(&rtable[i].r_lock, NULL, RW_DEFAULT, NULL);
3469 	}
3470 	rnode_cache = kmem_cache_create("rnode_cache", sizeof (rnode_t),
3471 	    0, NULL, NULL, nfs_reclaim, NULL, NULL, 0);
3472 
3473 	/*
3474 	 * Allocate and initialize the access cache
3475 	 */
3476 
3477 	/*
3478 	 * Initial guess is one access cache entry per rnode unless
3479 	 * nacache is set to a non-zero value and then it is used to
3480 	 * indicate a guess at the number of access cache entries.
3481 	 */
3482 	if (nacache > 0)
3483 		acachesize = 1 << highbit(nacache / hashlen);
3484 	else
3485 		acachesize = rtablesize;
3486 	acachemask = acachesize - 1;
3487 	acache = kmem_alloc(acachesize * sizeof (*acache), KM_SLEEP);
3488 	for (i = 0; i < acachesize; i++) {
3489 		acache[i].next = (acache_t *)&acache[i];
3490 		acache[i].prev = (acache_t *)&acache[i];
3491 		rw_init(&acache[i].lock, NULL, RW_DEFAULT, NULL);
3492 	}
3493 	acache_cache = kmem_cache_create("nfs_access_cache",
3494 	    sizeof (acache_t), 0, NULL, NULL, NULL, NULL, NULL, 0);
3495 	/*
3496 	 * Allocate and initialize the client handle cache
3497 	 */
3498 	chtab_cache = kmem_cache_create("client_handle_cache",
3499 	    sizeof (struct chtab), 0, NULL, NULL, clreclaim, NULL, NULL, 0);
3500 	/*
3501 	 * Initialize the list of per-zone client handles (and associated data).
3502 	 * This needs to be done before we call zone_key_create().
3503 	 */
3504 	list_create(&nfs_clnt_list, sizeof (struct nfs_clnt),
3505 	    offsetof(struct nfs_clnt, nfscl_node));
3506 	/*
3507 	 * Initialize the zone_key for per-zone client handle lists.
3508 	 */
3509 	zone_key_create(&nfsclnt_zone_key, clinit_zone, NULL, clfini_zone);
3510 	/*
3511 	 * Initialize the various mutexes and reader/writer locks
3512 	 */
3513 	mutex_init(&rpfreelist_lock, NULL, MUTEX_DEFAULT, NULL);
3514 	mutex_init(&newnum_lock, NULL, MUTEX_DEFAULT, NULL);
3515 	mutex_init(&nfs_minor_lock, NULL, MUTEX_DEFAULT, NULL);
3516 
3517 	/*
3518 	 * Assign unique major number for all nfs mounts
3519 	 */
3520 	if ((nfs_major = getudev()) == -1) {
3521 		zcmn_err(GLOBAL_ZONEID, CE_WARN,
3522 		    "nfs: init: can't get unique device number");
3523 		nfs_major = 0;
3524 	}
3525 	nfs_minor = 0;
3526 
3527 	if (nfs3_jukebox_delay == 0)
3528 		nfs3_jukebox_delay = NFS3_JUKEBOX_DELAY;
3529 
3530 	return (0);
3531 }
3532 
3533 void
3534 nfs_subrfini(void)
3535 {
3536 	int i;
3537 
3538 	/*
3539 	 * Deallocate the rnode hash queues
3540 	 */
3541 	kmem_cache_destroy(rnode_cache);
3542 
3543 	for (i = 0; i < rtablesize; i++)
3544 		rw_destroy(&rtable[i].r_lock);
3545 	kmem_free(rtable, rtablesize * sizeof (*rtable));
3546 
3547 	/*
3548 	 * Deallocated the access cache
3549 	 */
3550 	kmem_cache_destroy(acache_cache);
3551 
3552 	for (i = 0; i < acachesize; i++)
3553 		rw_destroy(&acache[i].lock);
3554 	kmem_free(acache, acachesize * sizeof (*acache));
3555 
3556 	/*
3557 	 * Deallocate the client handle cache
3558 	 */
3559 	kmem_cache_destroy(chtab_cache);
3560 
3561 	/*
3562 	 * Destroy the various mutexes and reader/writer locks
3563 	 */
3564 	mutex_destroy(&rpfreelist_lock);
3565 	mutex_destroy(&newnum_lock);
3566 	mutex_destroy(&nfs_minor_lock);
3567 	(void) zone_key_delete(nfsclnt_zone_key);
3568 }
3569 
3570 enum nfsstat
3571 puterrno(int error)
3572 {
3573 
3574 	switch (error) {
3575 	case EOPNOTSUPP:
3576 		return (NFSERR_OPNOTSUPP);
3577 	case ENAMETOOLONG:
3578 		return (NFSERR_NAMETOOLONG);
3579 	case ENOTEMPTY:
3580 		return (NFSERR_NOTEMPTY);
3581 	case EDQUOT:
3582 		return (NFSERR_DQUOT);
3583 	case ESTALE:
3584 		return (NFSERR_STALE);
3585 	case EREMOTE:
3586 		return (NFSERR_REMOTE);
3587 	case ENOSYS:
3588 		return (NFSERR_OPNOTSUPP);
3589 	case EOVERFLOW:
3590 		return (NFSERR_INVAL);
3591 	default:
3592 		return ((enum nfsstat)error);
3593 	}
3594 	/* NOTREACHED */
3595 }
3596 
3597 int
3598 geterrno(enum nfsstat status)
3599 {
3600 
3601 	switch (status) {
3602 	case NFSERR_OPNOTSUPP:
3603 		return (EOPNOTSUPP);
3604 	case NFSERR_NAMETOOLONG:
3605 		return (ENAMETOOLONG);
3606 	case NFSERR_NOTEMPTY:
3607 		return (ENOTEMPTY);
3608 	case NFSERR_DQUOT:
3609 		return (EDQUOT);
3610 	case NFSERR_STALE:
3611 		return (ESTALE);
3612 	case NFSERR_REMOTE:
3613 		return (EREMOTE);
3614 	case NFSERR_WFLUSH:
3615 		return (EIO);
3616 	default:
3617 		return ((int)status);
3618 	}
3619 	/* NOTREACHED */
3620 }
3621 
3622 enum nfsstat3
3623 puterrno3(int error)
3624 {
3625 
3626 #ifdef DEBUG
3627 	switch (error) {
3628 	case 0:
3629 		return (NFS3_OK);
3630 	case EPERM:
3631 		return (NFS3ERR_PERM);
3632 	case ENOENT:
3633 		return (NFS3ERR_NOENT);
3634 	case EIO:
3635 		return (NFS3ERR_IO);
3636 	case ENXIO:
3637 		return (NFS3ERR_NXIO);
3638 	case EACCES:
3639 		return (NFS3ERR_ACCES);
3640 	case EEXIST:
3641 		return (NFS3ERR_EXIST);
3642 	case EXDEV:
3643 		return (NFS3ERR_XDEV);
3644 	case ENODEV:
3645 		return (NFS3ERR_NODEV);
3646 	case ENOTDIR:
3647 		return (NFS3ERR_NOTDIR);
3648 	case EISDIR:
3649 		return (NFS3ERR_ISDIR);
3650 	case EINVAL:
3651 		return (NFS3ERR_INVAL);
3652 	case EFBIG:
3653 		return (NFS3ERR_FBIG);
3654 	case ENOSPC:
3655 		return (NFS3ERR_NOSPC);
3656 	case EROFS:
3657 		return (NFS3ERR_ROFS);
3658 	case EMLINK:
3659 		return (NFS3ERR_MLINK);
3660 	case ENAMETOOLONG:
3661 		return (NFS3ERR_NAMETOOLONG);
3662 	case ENOTEMPTY:
3663 		return (NFS3ERR_NOTEMPTY);
3664 	case EDQUOT:
3665 		return (NFS3ERR_DQUOT);
3666 	case ESTALE:
3667 		return (NFS3ERR_STALE);
3668 	case EREMOTE:
3669 		return (NFS3ERR_REMOTE);
3670 	case ENOSYS:
3671 	case EOPNOTSUPP:
3672 		return (NFS3ERR_NOTSUPP);
3673 	case EOVERFLOW:
3674 		return (NFS3ERR_INVAL);
3675 	default:
3676 		zcmn_err(getzoneid(), CE_WARN,
3677 		    "puterrno3: got error %d", error);
3678 		return ((enum nfsstat3)error);
3679 	}
3680 #else
3681 	switch (error) {
3682 	case ENAMETOOLONG:
3683 		return (NFS3ERR_NAMETOOLONG);
3684 	case ENOTEMPTY:
3685 		return (NFS3ERR_NOTEMPTY);
3686 	case EDQUOT:
3687 		return (NFS3ERR_DQUOT);
3688 	case ESTALE:
3689 		return (NFS3ERR_STALE);
3690 	case ENOSYS:
3691 	case EOPNOTSUPP:
3692 		return (NFS3ERR_NOTSUPP);
3693 	case EREMOTE:
3694 		return (NFS3ERR_REMOTE);
3695 	case EOVERFLOW:
3696 		return (NFS3ERR_INVAL);
3697 	default:
3698 		return ((enum nfsstat3)error);
3699 	}
3700 #endif
3701 }
3702 
3703 int
3704 geterrno3(enum nfsstat3 status)
3705 {
3706 
3707 #ifdef DEBUG
3708 	switch (status) {
3709 	case NFS3_OK:
3710 		return (0);
3711 	case NFS3ERR_PERM:
3712 		return (EPERM);
3713 	case NFS3ERR_NOENT:
3714 		return (ENOENT);
3715 	case NFS3ERR_IO:
3716 		return (EIO);
3717 	case NFS3ERR_NXIO:
3718 		return (ENXIO);
3719 	case NFS3ERR_ACCES:
3720 		return (EACCES);
3721 	case NFS3ERR_EXIST:
3722 		return (EEXIST);
3723 	case NFS3ERR_XDEV:
3724 		return (EXDEV);
3725 	case NFS3ERR_NODEV:
3726 		return (ENODEV);
3727 	case NFS3ERR_NOTDIR:
3728 		return (ENOTDIR);
3729 	case NFS3ERR_ISDIR:
3730 		return (EISDIR);
3731 	case NFS3ERR_INVAL:
3732 		return (EINVAL);
3733 	case NFS3ERR_FBIG:
3734 		return (EFBIG);
3735 	case NFS3ERR_NOSPC:
3736 		return (ENOSPC);
3737 	case NFS3ERR_ROFS:
3738 		return (EROFS);
3739 	case NFS3ERR_MLINK:
3740 		return (EMLINK);
3741 	case NFS3ERR_NAMETOOLONG:
3742 		return (ENAMETOOLONG);
3743 	case NFS3ERR_NOTEMPTY:
3744 		return (ENOTEMPTY);
3745 	case NFS3ERR_DQUOT:
3746 		return (EDQUOT);
3747 	case NFS3ERR_STALE:
3748 		return (ESTALE);
3749 	case NFS3ERR_REMOTE:
3750 		return (EREMOTE);
3751 	case NFS3ERR_BADHANDLE:
3752 		return (ESTALE);
3753 	case NFS3ERR_NOT_SYNC:
3754 		return (EINVAL);
3755 	case NFS3ERR_BAD_COOKIE:
3756 		return (ENOENT);
3757 	case NFS3ERR_NOTSUPP:
3758 		return (EOPNOTSUPP);
3759 	case NFS3ERR_TOOSMALL:
3760 		return (EINVAL);
3761 	case NFS3ERR_SERVERFAULT:
3762 		return (EIO);
3763 	case NFS3ERR_BADTYPE:
3764 		return (EINVAL);
3765 	case NFS3ERR_JUKEBOX:
3766 		return (ENXIO);
3767 	default:
3768 		zcmn_err(getzoneid(), CE_WARN,
3769 		    "geterrno3: got status %d", status);
3770 		return ((int)status);
3771 	}
3772 #else
3773 	switch (status) {
3774 	case NFS3ERR_NAMETOOLONG:
3775 		return (ENAMETOOLONG);
3776 	case NFS3ERR_NOTEMPTY:
3777 		return (ENOTEMPTY);
3778 	case NFS3ERR_DQUOT:
3779 		return (EDQUOT);
3780 	case NFS3ERR_STALE:
3781 	case NFS3ERR_BADHANDLE:
3782 		return (ESTALE);
3783 	case NFS3ERR_NOTSUPP:
3784 		return (EOPNOTSUPP);
3785 	case NFS3ERR_REMOTE:
3786 		return (EREMOTE);
3787 	case NFS3ERR_NOT_SYNC:
3788 	case NFS3ERR_TOOSMALL:
3789 	case NFS3ERR_BADTYPE:
3790 		return (EINVAL);
3791 	case NFS3ERR_BAD_COOKIE:
3792 		return (ENOENT);
3793 	case NFS3ERR_SERVERFAULT:
3794 		return (EIO);
3795 	case NFS3ERR_JUKEBOX:
3796 		return (ENXIO);
3797 	default:
3798 		return ((int)status);
3799 	}
3800 #endif
3801 }
3802 
3803 rddir_cache *
3804 rddir_cache_alloc(int flags)
3805 {
3806 	rddir_cache *rc;
3807 
3808 	rc = kmem_alloc(sizeof (*rc), flags);
3809 	if (rc != NULL) {
3810 		rc->entries = NULL;
3811 		rc->flags = RDDIR;
3812 		cv_init(&rc->cv, NULL, CV_DEFAULT, NULL);
3813 		mutex_init(&rc->lock, NULL, MUTEX_DEFAULT, NULL);
3814 		rc->count = 1;
3815 #ifdef DEBUG
3816 		atomic_inc_64(&clstat_debug.dirent.value.ui64);
3817 #endif
3818 	}
3819 	return (rc);
3820 }
3821 
3822 static void
3823 rddir_cache_free(rddir_cache *rc)
3824 {
3825 
3826 #ifdef DEBUG
3827 	atomic_dec_64(&clstat_debug.dirent.value.ui64);
3828 #endif
3829 	if (rc->entries != NULL) {
3830 #ifdef DEBUG
3831 		rddir_cache_buf_free(rc->entries, rc->buflen);
3832 #else
3833 		kmem_free(rc->entries, rc->buflen);
3834 #endif
3835 	}
3836 	cv_destroy(&rc->cv);
3837 	mutex_destroy(&rc->lock);
3838 	kmem_free(rc, sizeof (*rc));
3839 }
3840 
3841 void
3842 rddir_cache_hold(rddir_cache *rc)
3843 {
3844 
3845 	mutex_enter(&rc->lock);
3846 	rc->count++;
3847 	mutex_exit(&rc->lock);
3848 }
3849 
3850 void
3851 rddir_cache_rele(rddir_cache *rc)
3852 {
3853 
3854 	mutex_enter(&rc->lock);
3855 	ASSERT(rc->count > 0);
3856 	if (--rc->count == 0) {
3857 		mutex_exit(&rc->lock);
3858 		rddir_cache_free(rc);
3859 	} else
3860 		mutex_exit(&rc->lock);
3861 }
3862 
3863 #ifdef DEBUG
3864 char *
3865 rddir_cache_buf_alloc(size_t size, int flags)
3866 {
3867 	char *rc;
3868 
3869 	rc = kmem_alloc(size, flags);
3870 	if (rc != NULL)
3871 		atomic_add_64(&clstat_debug.dirents.value.ui64, size);
3872 	return (rc);
3873 }
3874 
3875 void
3876 rddir_cache_buf_free(void *addr, size_t size)
3877 {
3878 
3879 	atomic_add_64(&clstat_debug.dirents.value.ui64, -(int64_t)size);
3880 	kmem_free(addr, size);
3881 }
3882 #endif
3883 
3884 static int
3885 nfs_free_data_reclaim(rnode_t *rp)
3886 {
3887 	char *contents;
3888 	int size;
3889 	vsecattr_t *vsp;
3890 	nfs3_pathconf_info *info;
3891 	int freed;
3892 	cred_t *cred;
3893 
3894 	/*
3895 	 * Free any held credentials and caches which
3896 	 * may be associated with this rnode.
3897 	 */
3898 	mutex_enter(&rp->r_statelock);
3899 	cred = rp->r_cred;
3900 	rp->r_cred = NULL;
3901 	contents = rp->r_symlink.contents;
3902 	size = rp->r_symlink.size;
3903 	rp->r_symlink.contents = NULL;
3904 	vsp = rp->r_secattr;
3905 	rp->r_secattr = NULL;
3906 	info = rp->r_pathconf;
3907 	rp->r_pathconf = NULL;
3908 	mutex_exit(&rp->r_statelock);
3909 
3910 	if (cred != NULL)
3911 		crfree(cred);
3912 
3913 	/*
3914 	 * Free the access cache entries.
3915 	 */
3916 	freed = nfs_access_purge_rp(rp);
3917 
3918 	if (!HAVE_RDDIR_CACHE(rp) &&
3919 	    contents == NULL &&
3920 	    vsp == NULL &&
3921 	    info == NULL)
3922 		return (freed);
3923 
3924 	/*
3925 	 * Free the readdir cache entries
3926 	 */
3927 	if (HAVE_RDDIR_CACHE(rp))
3928 		nfs_purge_rddir_cache(RTOV(rp));
3929 
3930 	/*
3931 	 * Free the symbolic link cache.
3932 	 */
3933 	if (contents != NULL) {
3934 
3935 		kmem_free((void *)contents, size);
3936 	}
3937 
3938 	/*
3939 	 * Free any cached ACL.
3940 	 */
3941 	if (vsp != NULL)
3942 		nfs_acl_free(vsp);
3943 
3944 	/*
3945 	 * Free any cached pathconf information.
3946 	 */
3947 	if (info != NULL)
3948 		kmem_free(info, sizeof (*info));
3949 
3950 	return (1);
3951 }
3952 
3953 static int
3954 nfs_active_data_reclaim(rnode_t *rp)
3955 {
3956 	char *contents;
3957 	int size;
3958 	vsecattr_t *vsp;
3959 	nfs3_pathconf_info *info;
3960 	int freed;
3961 
3962 	/*
3963 	 * Free any held credentials and caches which
3964 	 * may be associated with this rnode.
3965 	 */
3966 	if (!mutex_tryenter(&rp->r_statelock))
3967 		return (0);
3968 	contents = rp->r_symlink.contents;
3969 	size = rp->r_symlink.size;
3970 	rp->r_symlink.contents = NULL;
3971 	vsp = rp->r_secattr;
3972 	rp->r_secattr = NULL;
3973 	info = rp->r_pathconf;
3974 	rp->r_pathconf = NULL;
3975 	mutex_exit(&rp->r_statelock);
3976 
3977 	/*
3978 	 * Free the access cache entries.
3979 	 */
3980 	freed = nfs_access_purge_rp(rp);
3981 
3982 	if (!HAVE_RDDIR_CACHE(rp) &&
3983 	    contents == NULL &&
3984 	    vsp == NULL &&
3985 	    info == NULL)
3986 		return (freed);
3987 
3988 	/*
3989 	 * Free the readdir cache entries
3990 	 */
3991 	if (HAVE_RDDIR_CACHE(rp))
3992 		nfs_purge_rddir_cache(RTOV(rp));
3993 
3994 	/*
3995 	 * Free the symbolic link cache.
3996 	 */
3997 	if (contents != NULL) {
3998 
3999 		kmem_free((void *)contents, size);
4000 	}
4001 
4002 	/*
4003 	 * Free any cached ACL.
4004 	 */
4005 	if (vsp != NULL)
4006 		nfs_acl_free(vsp);
4007 
4008 	/*
4009 	 * Free any cached pathconf information.
4010 	 */
4011 	if (info != NULL)
4012 		kmem_free(info, sizeof (*info));
4013 
4014 	return (1);
4015 }
4016 
4017 static int
4018 nfs_free_reclaim(void)
4019 {
4020 	int freed;
4021 	rnode_t *rp;
4022 
4023 #ifdef DEBUG
4024 	clstat_debug.f_reclaim.value.ui64++;
4025 #endif
4026 	freed = 0;
4027 	mutex_enter(&rpfreelist_lock);
4028 	rp = rpfreelist;
4029 	if (rp != NULL) {
4030 		do {
4031 			if (nfs_free_data_reclaim(rp))
4032 				freed = 1;
4033 		} while ((rp = rp->r_freef) != rpfreelist);
4034 	}
4035 	mutex_exit(&rpfreelist_lock);
4036 	return (freed);
4037 }
4038 
4039 static int
4040 nfs_active_reclaim(void)
4041 {
4042 	int freed;
4043 	int index;
4044 	rnode_t *rp;
4045 
4046 #ifdef DEBUG
4047 	clstat_debug.a_reclaim.value.ui64++;
4048 #endif
4049 	freed = 0;
4050 	for (index = 0; index < rtablesize; index++) {
4051 		rw_enter(&rtable[index].r_lock, RW_READER);
4052 		for (rp = rtable[index].r_hashf;
4053 		    rp != (rnode_t *)(&rtable[index]);
4054 		    rp = rp->r_hashf) {
4055 			if (nfs_active_data_reclaim(rp))
4056 				freed = 1;
4057 		}
4058 		rw_exit(&rtable[index].r_lock);
4059 	}
4060 	return (freed);
4061 }
4062 
4063 static int
4064 nfs_rnode_reclaim(void)
4065 {
4066 	int freed;
4067 	rnode_t *rp;
4068 	vnode_t *vp;
4069 
4070 #ifdef DEBUG
4071 	clstat_debug.r_reclaim.value.ui64++;
4072 #endif
4073 	freed = 0;
4074 	mutex_enter(&rpfreelist_lock);
4075 	while ((rp = rpfreelist) != NULL) {
4076 		rp_rmfree(rp);
4077 		mutex_exit(&rpfreelist_lock);
4078 		if (rp->r_flags & RHASHED) {
4079 			vp = RTOV(rp);
4080 			rw_enter(&rp->r_hashq->r_lock, RW_WRITER);
4081 			mutex_enter(&vp->v_lock);
4082 			if (vp->v_count > 1) {
4083 				vp->v_count--;
4084 				mutex_exit(&vp->v_lock);
4085 				rw_exit(&rp->r_hashq->r_lock);
4086 				mutex_enter(&rpfreelist_lock);
4087 				continue;
4088 			}
4089 			mutex_exit(&vp->v_lock);
4090 			rp_rmhash_locked(rp);
4091 			rw_exit(&rp->r_hashq->r_lock);
4092 		}
4093 		/*
4094 		 * This call to rp_addfree will end up destroying the
4095 		 * rnode, but in a safe way with the appropriate set
4096 		 * of checks done.
4097 		 */
4098 		rp_addfree(rp, CRED());
4099 		mutex_enter(&rpfreelist_lock);
4100 	}
4101 	mutex_exit(&rpfreelist_lock);
4102 	return (freed);
4103 }
4104 
4105 /*ARGSUSED*/
4106 static void
4107 nfs_reclaim(void *cdrarg)
4108 {
4109 
4110 #ifdef DEBUG
4111 	clstat_debug.reclaim.value.ui64++;
4112 #endif
4113 	if (nfs_free_reclaim())
4114 		return;
4115 
4116 	if (nfs_active_reclaim())
4117 		return;
4118 
4119 	(void) nfs_rnode_reclaim();
4120 }
4121 
4122 /*
4123  * NFS client failover support
4124  *
4125  * Routines to copy filehandles
4126  */
4127 void
4128 nfscopyfh(caddr_t fhp, vnode_t *vp)
4129 {
4130 	fhandle_t *dest = (fhandle_t *)fhp;
4131 
4132 	if (dest != NULL)
4133 		*dest = *VTOFH(vp);
4134 }
4135 
4136 void
4137 nfs3copyfh(caddr_t fhp, vnode_t *vp)
4138 {
4139 	nfs_fh3 *dest = (nfs_fh3 *)fhp;
4140 
4141 	if (dest != NULL)
4142 		*dest = *VTOFH3(vp);
4143 }
4144 
4145 /*
4146  * NFS client failover support
4147  *
4148  * failover_safe() will test various conditions to ensure that
4149  * failover is permitted for this vnode.  It will be denied
4150  * if:
4151  *	1) the operation in progress does not support failover (NULL fi)
4152  *	2) there are no available replicas (NULL mi_servers->sv_next)
4153  *	3) any locks are outstanding on this file
4154  */
4155 static int
4156 failover_safe(failinfo_t *fi)
4157 {
4158 
4159 	/*
4160 	 * Does this op permit failover?
4161 	 */
4162 	if (fi == NULL || fi->vp == NULL)
4163 		return (0);
4164 
4165 	/*
4166 	 * Are there any alternates to failover to?
4167 	 */
4168 	if (VTOMI(fi->vp)->mi_servers->sv_next == NULL)
4169 		return (0);
4170 
4171 	/*
4172 	 * Disable check; we've forced local locking
4173 	 *
4174 	 * if (flk_has_remote_locks(fi->vp))
4175 	 *	return (0);
4176 	 */
4177 
4178 	/*
4179 	 * If we have no partial path, we can't do anything
4180 	 */
4181 	if (VTOR(fi->vp)->r_path == NULL)
4182 		return (0);
4183 
4184 	return (1);
4185 }
4186 
4187 #include <sys/thread.h>
4188 
4189 /*
4190  * NFS client failover support
4191  *
4192  * failover_newserver() will start a search for a new server,
4193  * preferably by starting an async thread to do the work.  If
4194  * someone is already doing this (recognizable by MI_BINDINPROG
4195  * being set), it will simply return and the calling thread
4196  * will queue on the mi_failover_cv condition variable.
4197  */
4198 static void
4199 failover_newserver(mntinfo_t *mi)
4200 {
4201 	/*
4202 	 * Check if someone else is doing this already
4203 	 */
4204 	mutex_enter(&mi->mi_lock);
4205 	if (mi->mi_flags & MI_BINDINPROG) {
4206 		mutex_exit(&mi->mi_lock);
4207 		return;
4208 	}
4209 	mi->mi_flags |= MI_BINDINPROG;
4210 
4211 	/*
4212 	 * Need to hold the vfs struct so that it can't be released
4213 	 * while the failover thread is selecting a new server.
4214 	 */
4215 	VFS_HOLD(mi->mi_vfsp);
4216 
4217 	/*
4218 	 * Start a thread to do the real searching.
4219 	 */
4220 	(void) zthread_create(NULL, 0, failover_thread, mi, 0, minclsyspri);
4221 
4222 	mutex_exit(&mi->mi_lock);
4223 }
4224 
4225 /*
4226  * NFS client failover support
4227  *
4228  * failover_thread() will find a new server to replace the one
4229  * currently in use, wake up other threads waiting on this mount
4230  * point, and die.  It will start at the head of the server list
4231  * and poll servers until it finds one with an NFS server which is
4232  * registered and responds to a NULL procedure ping.
4233  *
4234  * XXX failover_thread is unsafe within the scope of the
4235  * present model defined for cpr to suspend the system.
4236  * Specifically, over-the-wire calls made by the thread
4237  * are unsafe. The thread needs to be reevaluated in case of
4238  * future updates to the cpr suspend model.
4239  */
4240 static void
4241 failover_thread(mntinfo_t *mi)
4242 {
4243 	servinfo_t *svp = NULL;
4244 	CLIENT *cl;
4245 	enum clnt_stat status;
4246 	struct timeval tv;
4247 	int error;
4248 	int oncethru = 0;
4249 	callb_cpr_t cprinfo;
4250 	rnode_t *rp;
4251 	int index;
4252 	char *srvnames;
4253 	size_t srvnames_len;
4254 	struct nfs_clnt *nfscl = NULL;
4255 	zoneid_t zoneid = getzoneid();
4256 
4257 #ifdef DEBUG
4258 	/*
4259 	 * This is currently only needed to access counters which exist on
4260 	 * DEBUG kernels, hence we don't want to pay the penalty of the lookup
4261 	 * on non-DEBUG kernels.
4262 	 */
4263 	nfscl = zone_getspecific(nfsclnt_zone_key, nfs_zone());
4264 	ASSERT(nfscl != NULL);
4265 #endif
4266 
4267 	/*
4268 	 * Its safe to piggyback on the mi_lock since failover_newserver()
4269 	 * code guarantees that there will be only one failover thread
4270 	 * per mountinfo at any instance.
4271 	 */
4272 	CALLB_CPR_INIT(&cprinfo, &mi->mi_lock, callb_generic_cpr,
4273 	    "failover_thread");
4274 
4275 	mutex_enter(&mi->mi_lock);
4276 	while (mi->mi_readers) {
4277 		CALLB_CPR_SAFE_BEGIN(&cprinfo);
4278 		cv_wait(&mi->mi_failover_cv, &mi->mi_lock);
4279 		CALLB_CPR_SAFE_END(&cprinfo, &mi->mi_lock);
4280 	}
4281 	mutex_exit(&mi->mi_lock);
4282 
4283 	tv.tv_sec = 2;
4284 	tv.tv_usec = 0;
4285 
4286 	/*
4287 	 * Ping the null NFS procedure of every server in
4288 	 * the list until one responds.  We always start
4289 	 * at the head of the list and always skip the one
4290 	 * that is current, since it's caused us a problem.
4291 	 */
4292 	while (svp == NULL) {
4293 		for (svp = mi->mi_servers; svp; svp = svp->sv_next) {
4294 			if (!oncethru && svp == mi->mi_curr_serv)
4295 				continue;
4296 
4297 			/*
4298 			 * If the file system was forcibly umounted
4299 			 * while trying to do a failover, then just
4300 			 * give up on the failover.  It won't matter
4301 			 * what the server is.
4302 			 */
4303 			if (FS_OR_ZONE_GONE(mi->mi_vfsp)) {
4304 				svp = NULL;
4305 				goto done;
4306 			}
4307 
4308 			error = clnt_tli_kcreate(svp->sv_knconf, &svp->sv_addr,
4309 			    NFS_PROGRAM, NFS_VERSION, 0, 1, CRED(), &cl);
4310 			if (error)
4311 				continue;
4312 
4313 			if (!(mi->mi_flags & MI_INT))
4314 				cl->cl_nosignal = TRUE;
4315 			status = CLNT_CALL(cl, RFS_NULL, xdr_void, NULL,
4316 			    xdr_void, NULL, tv);
4317 			if (!(mi->mi_flags & MI_INT))
4318 				cl->cl_nosignal = FALSE;
4319 			AUTH_DESTROY(cl->cl_auth);
4320 			CLNT_DESTROY(cl);
4321 			if (status == RPC_SUCCESS) {
4322 				if (svp == mi->mi_curr_serv) {
4323 #ifdef DEBUG
4324 					zcmn_err(zoneid, CE_NOTE,
4325 			"NFS%d: failing over: selecting original server %s",
4326 					    mi->mi_vers, svp->sv_hostname);
4327 #else
4328 					zcmn_err(zoneid, CE_NOTE,
4329 			"NFS: failing over: selecting original server %s",
4330 					    svp->sv_hostname);
4331 #endif
4332 				} else {
4333 #ifdef DEBUG
4334 					zcmn_err(zoneid, CE_NOTE,
4335 				    "NFS%d: failing over from %s to %s",
4336 					    mi->mi_vers,
4337 					    mi->mi_curr_serv->sv_hostname,
4338 					    svp->sv_hostname);
4339 #else
4340 					zcmn_err(zoneid, CE_NOTE,
4341 				    "NFS: failing over from %s to %s",
4342 					    mi->mi_curr_serv->sv_hostname,
4343 					    svp->sv_hostname);
4344 #endif
4345 				}
4346 				break;
4347 			}
4348 		}
4349 
4350 		if (svp == NULL) {
4351 			if (!oncethru) {
4352 				srvnames = nfs_getsrvnames(mi, &srvnames_len);
4353 #ifdef DEBUG
4354 				zprintf(zoneid,
4355 				    "NFS%d servers %s not responding "
4356 				    "still trying\n", mi->mi_vers, srvnames);
4357 #else
4358 				zprintf(zoneid, "NFS servers %s not responding "
4359 				    "still trying\n", srvnames);
4360 #endif
4361 				oncethru = 1;
4362 			}
4363 			mutex_enter(&mi->mi_lock);
4364 			CALLB_CPR_SAFE_BEGIN(&cprinfo);
4365 			mutex_exit(&mi->mi_lock);
4366 			delay(hz);
4367 			mutex_enter(&mi->mi_lock);
4368 			CALLB_CPR_SAFE_END(&cprinfo, &mi->mi_lock);
4369 			mutex_exit(&mi->mi_lock);
4370 		}
4371 	}
4372 
4373 	if (oncethru) {
4374 #ifdef DEBUG
4375 		zprintf(zoneid, "NFS%d servers %s ok\n", mi->mi_vers, srvnames);
4376 #else
4377 		zprintf(zoneid, "NFS servers %s ok\n", srvnames);
4378 #endif
4379 	}
4380 
4381 	if (svp != mi->mi_curr_serv) {
4382 		(void) dnlc_purge_vfsp(mi->mi_vfsp, 0);
4383 		index = rtablehash(&mi->mi_curr_serv->sv_fhandle);
4384 		rw_enter(&rtable[index].r_lock, RW_WRITER);
4385 		rp = rfind(&rtable[index], &mi->mi_curr_serv->sv_fhandle,
4386 		    mi->mi_vfsp);
4387 		if (rp != NULL) {
4388 			if (rp->r_flags & RHASHED)
4389 				rp_rmhash_locked(rp);
4390 			rw_exit(&rtable[index].r_lock);
4391 			rp->r_server = svp;
4392 			rp->r_fh = svp->sv_fhandle;
4393 			(void) nfs_free_data_reclaim(rp);
4394 			index = rtablehash(&rp->r_fh);
4395 			rp->r_hashq = &rtable[index];
4396 			rw_enter(&rp->r_hashq->r_lock, RW_WRITER);
4397 			vn_exists(RTOV(rp));
4398 			rp_addhash(rp);
4399 			rw_exit(&rp->r_hashq->r_lock);
4400 			VN_RELE(RTOV(rp));
4401 		} else
4402 			rw_exit(&rtable[index].r_lock);
4403 	}
4404 
4405 done:
4406 	if (oncethru)
4407 		kmem_free(srvnames, srvnames_len);
4408 	mutex_enter(&mi->mi_lock);
4409 	mi->mi_flags &= ~MI_BINDINPROG;
4410 	if (svp != NULL) {
4411 		mi->mi_curr_serv = svp;
4412 		mi->mi_failover++;
4413 #ifdef DEBUG
4414 	nfscl->nfscl_stat.failover.value.ui64++;
4415 #endif
4416 	}
4417 	cv_broadcast(&mi->mi_failover_cv);
4418 	CALLB_CPR_EXIT(&cprinfo);
4419 	VFS_RELE(mi->mi_vfsp);
4420 	zthread_exit();
4421 	/* NOTREACHED */
4422 }
4423 
4424 /*
4425  * NFS client failover support
4426  *
4427  * failover_wait() will put the thread to sleep until MI_BINDINPROG
4428  * is cleared, meaning that failover is complete.  Called with
4429  * mi_lock mutex held.
4430  */
4431 static int
4432 failover_wait(mntinfo_t *mi)
4433 {
4434 	k_sigset_t smask;
4435 
4436 	/*
4437 	 * If someone else is hunting for a living server,
4438 	 * sleep until it's done.  After our sleep, we may
4439 	 * be bound to the right server and get off cheaply.
4440 	 */
4441 	while (mi->mi_flags & MI_BINDINPROG) {
4442 		/*
4443 		 * Mask out all signals except SIGHUP, SIGINT, SIGQUIT
4444 		 * and SIGTERM. (Preserving the existing masks).
4445 		 * Mask out SIGINT if mount option nointr is specified.
4446 		 */
4447 		sigintr(&smask, (int)mi->mi_flags & MI_INT);
4448 		if (!cv_wait_sig(&mi->mi_failover_cv, &mi->mi_lock)) {
4449 			/*
4450 			 * restore original signal mask
4451 			 */
4452 			sigunintr(&smask);
4453 			return (EINTR);
4454 		}
4455 		/*
4456 		 * restore original signal mask
4457 		 */
4458 		sigunintr(&smask);
4459 	}
4460 	return (0);
4461 }
4462 
4463 /*
4464  * NFS client failover support
4465  *
4466  * failover_remap() will do a partial pathname lookup and find the
4467  * desired vnode on the current server.  The interim vnode will be
4468  * discarded after we pilfer the new filehandle.
4469  *
4470  * Side effects:
4471  * - This routine will also update the filehandle in the args structure
4472  *    pointed to by the fi->fhp pointer if it is non-NULL.
4473  */
4474 
4475 static int
4476 failover_remap(failinfo_t *fi)
4477 {
4478 	vnode_t *vp, *nvp, *rootvp;
4479 	rnode_t *rp, *nrp;
4480 	mntinfo_t *mi;
4481 	int error;
4482 #ifdef DEBUG
4483 	struct nfs_clnt *nfscl;
4484 
4485 	nfscl = zone_getspecific(nfsclnt_zone_key, nfs_zone());
4486 	ASSERT(nfscl != NULL);
4487 #endif
4488 	/*
4489 	 * Sanity check
4490 	 */
4491 	if (fi == NULL || fi->vp == NULL || fi->lookupproc == NULL)
4492 		return (EINVAL);
4493 	vp = fi->vp;
4494 	rp = VTOR(vp);
4495 	mi = VTOMI(vp);
4496 
4497 	if (!(vp->v_flag & VROOT)) {
4498 		/*
4499 		 * Given the root fh, use the path stored in
4500 		 * the rnode to find the fh for the new server.
4501 		 */
4502 		error = VFS_ROOT(mi->mi_vfsp, &rootvp);
4503 		if (error)
4504 			return (error);
4505 
4506 		error = failover_lookup(rp->r_path, rootvp,
4507 		    fi->lookupproc, fi->xattrdirproc, &nvp);
4508 
4509 		VN_RELE(rootvp);
4510 
4511 		if (error)
4512 			return (error);
4513 
4514 		/*
4515 		 * If we found the same rnode, we're done now
4516 		 */
4517 		if (nvp == vp) {
4518 			/*
4519 			 * Failed and the new server may physically be same
4520 			 * OR may share a same disk subsystem. In this case
4521 			 * file handle for a particular file path is not going
4522 			 * to change, given the same filehandle lookup will
4523 			 * always locate the same rnode as the existing one.
4524 			 * All we might need to do is to update the r_server
4525 			 * with the current servinfo.
4526 			 */
4527 			if (!VALID_FH(fi)) {
4528 				rp->r_server = mi->mi_curr_serv;
4529 			}
4530 			VN_RELE(nvp);
4531 			return (0);
4532 		}
4533 
4534 		/*
4535 		 * Try to make it so that no one else will find this
4536 		 * vnode because it is just a temporary to hold the
4537 		 * new file handle until that file handle can be
4538 		 * copied to the original vnode/rnode.
4539 		 */
4540 		nrp = VTOR(nvp);
4541 		mutex_enter(&mi->mi_remap_lock);
4542 		/*
4543 		 * Some other thread could have raced in here and could
4544 		 * have done the remap for this particular rnode before
4545 		 * this thread here. Check for rp->r_server and
4546 		 * mi->mi_curr_serv and return if they are same.
4547 		 */
4548 		if (VALID_FH(fi)) {
4549 			mutex_exit(&mi->mi_remap_lock);
4550 			VN_RELE(nvp);
4551 			return (0);
4552 		}
4553 
4554 		if (nrp->r_flags & RHASHED)
4555 			rp_rmhash(nrp);
4556 
4557 		/*
4558 		 * As a heuristic check on the validity of the new
4559 		 * file, check that the size and type match against
4560 		 * that we remember from the old version.
4561 		 */
4562 		if (rp->r_size != nrp->r_size || vp->v_type != nvp->v_type) {
4563 			mutex_exit(&mi->mi_remap_lock);
4564 			zcmn_err(mi->mi_zone->zone_id, CE_WARN,
4565 			    "NFS replicas %s and %s: file %s not same.",
4566 			    rp->r_server->sv_hostname,
4567 			    nrp->r_server->sv_hostname, rp->r_path);
4568 			VN_RELE(nvp);
4569 			return (EINVAL);
4570 		}
4571 
4572 		/*
4573 		 * snarf the filehandle from the new rnode
4574 		 * then release it, again while updating the
4575 		 * hash queues for the rnode.
4576 		 */
4577 		if (rp->r_flags & RHASHED)
4578 			rp_rmhash(rp);
4579 		rp->r_server = mi->mi_curr_serv;
4580 		rp->r_fh = nrp->r_fh;
4581 		rp->r_hashq = nrp->r_hashq;
4582 		/*
4583 		 * Copy the attributes from the new rnode to the old
4584 		 * rnode.  This will help to reduce unnecessary page
4585 		 * cache flushes.
4586 		 */
4587 		rp->r_attr = nrp->r_attr;
4588 		rp->r_attrtime = nrp->r_attrtime;
4589 		rp->r_mtime = nrp->r_mtime;
4590 		(void) nfs_free_data_reclaim(rp);
4591 		nfs_setswaplike(vp, &rp->r_attr);
4592 		rw_enter(&rp->r_hashq->r_lock, RW_WRITER);
4593 		rp_addhash(rp);
4594 		rw_exit(&rp->r_hashq->r_lock);
4595 		mutex_exit(&mi->mi_remap_lock);
4596 		VN_RELE(nvp);
4597 	}
4598 
4599 	/*
4600 	 * Update successful failover remap count
4601 	 */
4602 	mutex_enter(&mi->mi_lock);
4603 	mi->mi_remap++;
4604 	mutex_exit(&mi->mi_lock);
4605 #ifdef DEBUG
4606 	nfscl->nfscl_stat.remap.value.ui64++;
4607 #endif
4608 
4609 	/*
4610 	 * If we have a copied filehandle to update, do it now.
4611 	 */
4612 	if (fi->fhp != NULL && fi->copyproc != NULL)
4613 		(*fi->copyproc)(fi->fhp, vp);
4614 
4615 	return (0);
4616 }
4617 
4618 /*
4619  * NFS client failover support
4620  *
4621  * We want a simple pathname lookup routine to parse the pieces
4622  * of path in rp->r_path.  We know that the path was a created
4623  * as rnodes were made, so we know we have only to deal with
4624  * paths that look like:
4625  *	dir1/dir2/dir3/file
4626  * Any evidence of anything like .., symlinks, and ENOTDIR
4627  * are hard errors, because they mean something in this filesystem
4628  * is different from the one we came from, or has changed under
4629  * us in some way.  If this is true, we want the failure.
4630  *
4631  * Extended attributes: if the filesystem is mounted with extended
4632  * attributes enabled (-o xattr), the attribute directory will be
4633  * represented in the r_path as the magic name XATTR_RPATH. So if
4634  * we see that name in the pathname, is must be because this node
4635  * is an extended attribute.  Therefore, look it up that way.
4636  */
4637 static int
4638 failover_lookup(char *path, vnode_t *root,
4639     int (*lookupproc)(vnode_t *, char *, vnode_t **, struct pathname *, int,
4640 	vnode_t *, cred_t *, int),
4641     int (*xattrdirproc)(vnode_t *, vnode_t **, bool_t, cred_t *, int),
4642     vnode_t **new)
4643 {
4644 	vnode_t *dvp, *nvp;
4645 	int error = EINVAL;
4646 	char *s, *p, *tmppath;
4647 	size_t len;
4648 	mntinfo_t *mi;
4649 	bool_t xattr;
4650 
4651 	/* Make local copy of path */
4652 	len = strlen(path) + 1;
4653 	tmppath = kmem_alloc(len, KM_SLEEP);
4654 	(void) strcpy(tmppath, path);
4655 	s = tmppath;
4656 
4657 	dvp = root;
4658 	VN_HOLD(dvp);
4659 	mi = VTOMI(root);
4660 	xattr = mi->mi_flags & MI_EXTATTR;
4661 
4662 	do {
4663 		p = strchr(s, '/');
4664 		if (p != NULL)
4665 			*p = '\0';
4666 		if (xattr && strcmp(s, XATTR_RPATH) == 0) {
4667 			error = (*xattrdirproc)(dvp, &nvp, FALSE, CRED(),
4668 			    RFSCALL_SOFT);
4669 		} else {
4670 			error = (*lookupproc)(dvp, s, &nvp, NULL, 0, NULL,
4671 			    CRED(), RFSCALL_SOFT);
4672 		}
4673 		if (p != NULL)
4674 			*p++ = '/';
4675 		if (error) {
4676 			VN_RELE(dvp);
4677 			kmem_free(tmppath, len);
4678 			return (error);
4679 		}
4680 		s = p;
4681 		VN_RELE(dvp);
4682 		dvp = nvp;
4683 	} while (p != NULL);
4684 
4685 	if (nvp != NULL && new != NULL)
4686 		*new = nvp;
4687 	kmem_free(tmppath, len);
4688 	return (0);
4689 }
4690 
4691 /*
4692  * NFS client failover support
4693  *
4694  * sv_free() frees the malloc'd portion of a "servinfo_t".
4695  */
4696 void
4697 sv_free(servinfo_t *svp)
4698 {
4699 	servinfo_t *next;
4700 	struct knetconfig *knconf;
4701 
4702 	while (svp != NULL) {
4703 		next = svp->sv_next;
4704 		if (svp->sv_secdata)
4705 			sec_clnt_freeinfo(svp->sv_secdata);
4706 		if (svp->sv_hostname && svp->sv_hostnamelen > 0)
4707 			kmem_free(svp->sv_hostname, svp->sv_hostnamelen);
4708 		knconf = svp->sv_knconf;
4709 		if (knconf != NULL) {
4710 			if (knconf->knc_protofmly != NULL)
4711 				kmem_free(knconf->knc_protofmly, KNC_STRSIZE);
4712 			if (knconf->knc_proto != NULL)
4713 				kmem_free(knconf->knc_proto, KNC_STRSIZE);
4714 			kmem_free(knconf, sizeof (*knconf));
4715 		}
4716 		knconf = svp->sv_origknconf;
4717 		if (knconf != NULL) {
4718 			if (knconf->knc_protofmly != NULL)
4719 				kmem_free(knconf->knc_protofmly, KNC_STRSIZE);
4720 			if (knconf->knc_proto != NULL)
4721 				kmem_free(knconf->knc_proto, KNC_STRSIZE);
4722 			kmem_free(knconf, sizeof (*knconf));
4723 		}
4724 		if (svp->sv_addr.buf != NULL && svp->sv_addr.maxlen != 0)
4725 			kmem_free(svp->sv_addr.buf, svp->sv_addr.maxlen);
4726 		mutex_destroy(&svp->sv_lock);
4727 		kmem_free(svp, sizeof (*svp));
4728 		svp = next;
4729 	}
4730 }
4731 
4732 /*
4733  * Only can return non-zero if intr != 0.
4734  */
4735 int
4736 nfs_rw_enter_sig(nfs_rwlock_t *l, krw_t rw, int intr)
4737 {
4738 
4739 	mutex_enter(&l->lock);
4740 
4741 	/*
4742 	 * If this is a nested enter, then allow it.  There
4743 	 * must be as many exits as enters through.
4744 	 */
4745 	if (l->owner == curthread) {
4746 		/* lock is held for writing by current thread */
4747 		ASSERT(rw == RW_READER || rw == RW_WRITER);
4748 		l->count--;
4749 	} else if (rw == RW_READER) {
4750 		/*
4751 		 * While there is a writer active or writers waiting,
4752 		 * then wait for them to finish up and move on.  Then,
4753 		 * increment the count to indicate that a reader is
4754 		 * active.
4755 		 */
4756 		while (l->count < 0 || l->waiters > 0) {
4757 			if (intr) {
4758 				klwp_t *lwp = ttolwp(curthread);
4759 
4760 				if (lwp != NULL)
4761 					lwp->lwp_nostop++;
4762 				if (!cv_wait_sig(&l->cv, &l->lock)) {
4763 					if (lwp != NULL)
4764 						lwp->lwp_nostop--;
4765 					mutex_exit(&l->lock);
4766 					return (EINTR);
4767 				}
4768 				if (lwp != NULL)
4769 					lwp->lwp_nostop--;
4770 			} else
4771 				cv_wait(&l->cv, &l->lock);
4772 		}
4773 		ASSERT(l->count < INT_MAX);
4774 #ifdef	DEBUG
4775 		if ((l->count % 10000) == 9999)
4776 			cmn_err(CE_WARN, "nfs_rw_enter_sig: count %d on"
4777 			    "rwlock @ %p\n", l->count, (void *)&l);
4778 #endif
4779 		l->count++;
4780 	} else {
4781 		ASSERT(rw == RW_WRITER);
4782 		/*
4783 		 * While there are readers active or a writer
4784 		 * active, then wait for all of the readers
4785 		 * to finish or for the writer to finish.
4786 		 * Then, set the owner field to curthread and
4787 		 * decrement count to indicate that a writer
4788 		 * is active.
4789 		 */
4790 		while (l->count > 0 || l->owner != NULL) {
4791 			l->waiters++;
4792 			if (intr) {
4793 				klwp_t *lwp = ttolwp(curthread);
4794 
4795 				if (lwp != NULL)
4796 					lwp->lwp_nostop++;
4797 				if (!cv_wait_sig(&l->cv, &l->lock)) {
4798 					if (lwp != NULL)
4799 						lwp->lwp_nostop--;
4800 					l->waiters--;
4801 					cv_broadcast(&l->cv);
4802 					mutex_exit(&l->lock);
4803 					return (EINTR);
4804 				}
4805 				if (lwp != NULL)
4806 					lwp->lwp_nostop--;
4807 			} else
4808 				cv_wait(&l->cv, &l->lock);
4809 			l->waiters--;
4810 		}
4811 		l->owner = curthread;
4812 		l->count--;
4813 	}
4814 
4815 	mutex_exit(&l->lock);
4816 
4817 	return (0);
4818 }
4819 
4820 /*
4821  * If the lock is available, obtain it and return non-zero.  If there is
4822  * already a conflicting lock, return 0 immediately.
4823  */
4824 
4825 int
4826 nfs_rw_tryenter(nfs_rwlock_t *l, krw_t rw)
4827 {
4828 	mutex_enter(&l->lock);
4829 
4830 	/*
4831 	 * If this is a nested enter, then allow it.  There
4832 	 * must be as many exits as enters through.
4833 	 */
4834 	if (l->owner == curthread) {
4835 		/* lock is held for writing by current thread */
4836 		ASSERT(rw == RW_READER || rw == RW_WRITER);
4837 		l->count--;
4838 	} else if (rw == RW_READER) {
4839 		/*
4840 		 * If there is a writer active or writers waiting, deny the
4841 		 * lock.  Otherwise, bump the count of readers.
4842 		 */
4843 		if (l->count < 0 || l->waiters > 0) {
4844 			mutex_exit(&l->lock);
4845 			return (0);
4846 		}
4847 		l->count++;
4848 	} else {
4849 		ASSERT(rw == RW_WRITER);
4850 		/*
4851 		 * If there are readers active or a writer active, deny the
4852 		 * lock.  Otherwise, set the owner field to curthread and
4853 		 * decrement count to indicate that a writer is active.
4854 		 */
4855 		if (l->count > 0 || l->owner != NULL) {
4856 			mutex_exit(&l->lock);
4857 			return (0);
4858 		}
4859 		l->owner = curthread;
4860 		l->count--;
4861 	}
4862 
4863 	mutex_exit(&l->lock);
4864 
4865 	return (1);
4866 }
4867 
4868 void
4869 nfs_rw_exit(nfs_rwlock_t *l)
4870 {
4871 
4872 	mutex_enter(&l->lock);
4873 	/*
4874 	 * If this is releasing a writer lock, then increment count to
4875 	 * indicate that there is one less writer active.  If this was
4876 	 * the last of possibly nested writer locks, then clear the owner
4877 	 * field as well to indicate that there is no writer active
4878 	 * and wakeup any possible waiting writers or readers.
4879 	 *
4880 	 * If releasing a reader lock, then just decrement count to
4881 	 * indicate that there is one less reader active.  If this was
4882 	 * the last active reader and there are writer(s) waiting,
4883 	 * then wake up the first.
4884 	 */
4885 	if (l->owner != NULL) {
4886 		ASSERT(l->owner == curthread);
4887 		l->count++;
4888 		if (l->count == 0) {
4889 			l->owner = NULL;
4890 			cv_broadcast(&l->cv);
4891 		}
4892 	} else {
4893 		ASSERT(l->count > 0);
4894 		l->count--;
4895 		if (l->count == 0 && l->waiters > 0)
4896 			cv_broadcast(&l->cv);
4897 	}
4898 	mutex_exit(&l->lock);
4899 }
4900 
4901 int
4902 nfs_rw_lock_held(nfs_rwlock_t *l, krw_t rw)
4903 {
4904 
4905 	if (rw == RW_READER)
4906 		return (l->count > 0);
4907 	ASSERT(rw == RW_WRITER);
4908 	return (l->count < 0);
4909 }
4910 
4911 /* ARGSUSED */
4912 void
4913 nfs_rw_init(nfs_rwlock_t *l, char *name, krw_type_t type, void *arg)
4914 {
4915 
4916 	l->count = 0;
4917 	l->waiters = 0;
4918 	l->owner = NULL;
4919 	mutex_init(&l->lock, NULL, MUTEX_DEFAULT, NULL);
4920 	cv_init(&l->cv, NULL, CV_DEFAULT, NULL);
4921 }
4922 
4923 void
4924 nfs_rw_destroy(nfs_rwlock_t *l)
4925 {
4926 
4927 	mutex_destroy(&l->lock);
4928 	cv_destroy(&l->cv);
4929 }
4930 
4931 int
4932 nfs3_rddir_compar(const void *x, const void *y)
4933 {
4934 	rddir_cache *a = (rddir_cache *)x;
4935 	rddir_cache *b = (rddir_cache *)y;
4936 
4937 	if (a->nfs3_cookie == b->nfs3_cookie) {
4938 		if (a->buflen == b->buflen)
4939 			return (0);
4940 		if (a->buflen < b->buflen)
4941 			return (-1);
4942 		return (1);
4943 	}
4944 
4945 	if (a->nfs3_cookie < b->nfs3_cookie)
4946 		return (-1);
4947 
4948 	return (1);
4949 }
4950 
4951 int
4952 nfs_rddir_compar(const void *x, const void *y)
4953 {
4954 	rddir_cache *a = (rddir_cache *)x;
4955 	rddir_cache *b = (rddir_cache *)y;
4956 
4957 	if (a->nfs_cookie == b->nfs_cookie) {
4958 		if (a->buflen == b->buflen)
4959 			return (0);
4960 		if (a->buflen < b->buflen)
4961 			return (-1);
4962 		return (1);
4963 	}
4964 
4965 	if (a->nfs_cookie < b->nfs_cookie)
4966 		return (-1);
4967 
4968 	return (1);
4969 }
4970 
4971 static char *
4972 nfs_getsrvnames(mntinfo_t *mi, size_t *len)
4973 {
4974 	servinfo_t *s;
4975 	char *srvnames;
4976 	char *namep;
4977 	size_t length;
4978 
4979 	/*
4980 	 * Calculate the length of the string required to hold all
4981 	 * of the server names plus either a comma or a null
4982 	 * character following each individual one.
4983 	 */
4984 	length = 0;
4985 	for (s = mi->mi_servers; s != NULL; s = s->sv_next)
4986 		length += s->sv_hostnamelen;
4987 
4988 	srvnames = kmem_alloc(length, KM_SLEEP);
4989 
4990 	namep = srvnames;
4991 	for (s = mi->mi_servers; s != NULL; s = s->sv_next) {
4992 		(void) strcpy(namep, s->sv_hostname);
4993 		namep += s->sv_hostnamelen - 1;
4994 		*namep++ = ',';
4995 	}
4996 	*--namep = '\0';
4997 
4998 	*len = length;
4999 
5000 	return (srvnames);
5001 }
5002 
5003 /*
5004  * These two functions are temporary and designed for the upgrade-workaround
5005  * only.  They cannot be used for general zone-crossing NFS client support, and
5006  * will be removed shortly.
5007  *
5008  * When the workaround is enabled, all NFS traffic is forced into the global
5009  * zone.  These functions are called when the code needs to refer to the state
5010  * of the underlying network connection.  They're not called when the function
5011  * needs to refer to the state of the process that invoked the system call.
5012  * (E.g., when checking whether the zone is shutting down during the mount()
5013  * call.)
5014  */
5015 
5016 struct zone *
5017 nfs_zone(void)
5018 {
5019 	return (nfs_global_client_only != 0 ? global_zone : curproc->p_zone);
5020 }
5021 
5022 zoneid_t
5023 nfs_zoneid(void)
5024 {
5025 	return (nfs_global_client_only != 0 ? GLOBAL_ZONEID : getzoneid());
5026 }
5027 
5028 /*
5029  * nfs_mount_label_policy:
5030  *	Determine whether the mount is allowed according to MAC check,
5031  *	by comparing (where appropriate) label of the remote server
5032  *	against the label of the zone being mounted into.
5033  *
5034  *	Returns:
5035  *		 0 :	access allowed
5036  *		-1 :	read-only access allowed (i.e., read-down)
5037  *		>0 :	error code, such as EACCES
5038  */
5039 int
5040 nfs_mount_label_policy(vfs_t *vfsp, struct netbuf *addr,
5041     struct knetconfig *knconf, cred_t *cr)
5042 {
5043 	int		addr_type;
5044 	void		*ipaddr;
5045 	bslabel_t	*server_sl, *mntlabel;
5046 	zone_t		*mntzone = NULL;
5047 	ts_label_t	*zlabel;
5048 	tsol_tpc_t	*tp;
5049 	ts_label_t	*tsl = NULL;
5050 	int		retv;
5051 
5052 	/*
5053 	 * Get the zone's label.  Each zone on a labeled system has a label.
5054 	 */
5055 	mntzone = zone_find_by_any_path(refstr_value(vfsp->vfs_mntpt), B_FALSE);
5056 	zlabel = mntzone->zone_slabel;
5057 	ASSERT(zlabel != NULL);
5058 	label_hold(zlabel);
5059 
5060 	if (strcmp(knconf->knc_protofmly, NC_INET) == 0) {
5061 		addr_type = IPV4_VERSION;
5062 		ipaddr = &((struct sockaddr_in *)addr->buf)->sin_addr;
5063 	} else if (strcmp(knconf->knc_protofmly, NC_INET6) == 0) {
5064 		addr_type = IPV6_VERSION;
5065 		ipaddr = &((struct sockaddr_in6 *)addr->buf)->sin6_addr;
5066 	} else {
5067 		retv = 0;
5068 		goto out;
5069 	}
5070 
5071 	retv = EACCES;				/* assume the worst */
5072 
5073 	/*
5074 	 * Next, get the assigned label of the remote server.
5075 	 */
5076 	tp = find_tpc(ipaddr, addr_type, B_FALSE);
5077 	if (tp == NULL)
5078 		goto out;			/* error getting host entry */
5079 
5080 	if (tp->tpc_tp.tp_doi != zlabel->tsl_doi)
5081 		goto rel_tpc;			/* invalid domain */
5082 	if ((tp->tpc_tp.host_type != SUN_CIPSO) &&
5083 	    (tp->tpc_tp.host_type != UNLABELED))
5084 		goto rel_tpc;			/* invalid hosttype */
5085 
5086 	if (tp->tpc_tp.host_type == SUN_CIPSO) {
5087 		tsl = getflabel_cipso(vfsp);
5088 		if (tsl == NULL)
5089 			goto rel_tpc;		/* error getting server lbl */
5090 
5091 		server_sl = label2bslabel(tsl);
5092 	} else {	/* UNLABELED */
5093 		server_sl = &tp->tpc_tp.tp_def_label;
5094 	}
5095 
5096 	mntlabel = label2bslabel(zlabel);
5097 
5098 	/*
5099 	 * Now compare labels to complete the MAC check.  If the labels
5100 	 * are equal or if the requestor is in the global zone and has
5101 	 * NET_MAC_AWARE, then allow read-write access.   (Except for
5102 	 * mounts into the global zone itself; restrict these to
5103 	 * read-only.)
5104 	 *
5105 	 * If the requestor is in some other zone, but his label
5106 	 * dominates the server, then allow read-down.
5107 	 *
5108 	 * Otherwise, access is denied.
5109 	 */
5110 	if (blequal(mntlabel, server_sl) ||
5111 	    (crgetzoneid(cr) == GLOBAL_ZONEID &&
5112 	    getpflags(NET_MAC_AWARE, cr) != 0)) {
5113 		if ((mntzone == global_zone) ||
5114 		    !blequal(mntlabel, server_sl))
5115 			retv = -1;		/* read-only */
5116 		else
5117 			retv = 0;		/* access OK */
5118 	} else if (bldominates(mntlabel, server_sl)) {
5119 		retv = -1;			/* read-only */
5120 	} else {
5121 		retv = EACCES;
5122 	}
5123 
5124 	if (tsl != NULL)
5125 		label_rele(tsl);
5126 
5127 rel_tpc:
5128 	TPC_RELE(tp);
5129 out:
5130 	if (mntzone)
5131 		zone_rele(mntzone);
5132 	label_rele(zlabel);
5133 	return (retv);
5134 }
5135 
5136 boolean_t
5137 nfs_has_ctty(void)
5138 {
5139 	boolean_t rv;
5140 	mutex_enter(&curproc->p_splock);
5141 	rv = (curproc->p_sessp->s_vp != NULL);
5142 	mutex_exit(&curproc->p_splock);
5143 	return (rv);
5144 }
5145 
5146 /*
5147  * See if xattr directory to see if it has any generic user attributes
5148  */
5149 int
5150 do_xattr_exists_check(vnode_t *vp, ulong_t *valp, cred_t *cr)
5151 {
5152 	struct uio uio;
5153 	struct iovec iov;
5154 	char *dbuf;
5155 	struct dirent64 *dp;
5156 	size_t dlen = 8 * 1024;
5157 	size_t dbuflen;
5158 	int eof = 0;
5159 	int error;
5160 
5161 	*valp = 0;
5162 	dbuf = kmem_alloc(dlen, KM_SLEEP);
5163 	uio.uio_iov = &iov;
5164 	uio.uio_iovcnt = 1;
5165 	uio.uio_segflg = UIO_SYSSPACE;
5166 	uio.uio_fmode = 0;
5167 	uio.uio_extflg = UIO_COPY_CACHED;
5168 	uio.uio_loffset = 0;
5169 	uio.uio_resid = dlen;
5170 	iov.iov_base = dbuf;
5171 	iov.iov_len = dlen;
5172 	(void) VOP_RWLOCK(vp, V_WRITELOCK_FALSE, NULL);
5173 	error = VOP_READDIR(vp, &uio, cr, &eof, NULL, 0);
5174 	VOP_RWUNLOCK(vp, V_WRITELOCK_FALSE, NULL);
5175 
5176 	dbuflen = dlen - uio.uio_resid;
5177 
5178 	if (error || dbuflen == 0) {
5179 		kmem_free(dbuf, dlen);
5180 		return (error);
5181 	}
5182 
5183 	dp = (dirent64_t *)dbuf;
5184 
5185 	while ((intptr_t)dp < (intptr_t)dbuf + dbuflen) {
5186 		if (strcmp(dp->d_name, ".") == 0 ||
5187 		    strcmp(dp->d_name, "..") == 0 || strcmp(dp->d_name,
5188 		    VIEW_READWRITE) == 0 || strcmp(dp->d_name,
5189 		    VIEW_READONLY) == 0) {
5190 			dp = (dirent64_t *)((intptr_t)dp + dp->d_reclen);
5191 			continue;
5192 		}
5193 
5194 		*valp = 1;
5195 		break;
5196 	}
5197 	kmem_free(dbuf, dlen);
5198 	return (0);
5199 }
5200