1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
23  */
24 
25 /*
26  *	Copyright (c) 1983,1984,1985,1986,1987,1988,1989  AT&T.
27  *	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/vfs.h>
35 #include <sys/vfs_opreg.h>
36 #include <sys/vnode.h>
37 #include <sys/pathname.h>
38 #include <sys/sysmacros.h>
39 #include <sys/kmem.h>
40 #include <sys/mkdev.h>
41 #include <sys/mount.h>
42 #include <sys/statvfs.h>
43 #include <sys/errno.h>
44 #include <sys/debug.h>
45 #include <sys/cmn_err.h>
46 #include <sys/utsname.h>
47 #include <sys/bootconf.h>
48 #include <sys/modctl.h>
49 #include <sys/acl.h>
50 #include <sys/flock.h>
51 #include <sys/time.h>
52 #include <sys/disp.h>
53 #include <sys/policy.h>
54 #include <sys/socket.h>
55 #include <sys/netconfig.h>
56 #include <sys/dnlc.h>
57 #include <sys/list.h>
58 #include <sys/mntent.h>
59 #include <sys/tsol/label.h>
60 
61 #include <rpc/types.h>
62 #include <rpc/auth.h>
63 #include <rpc/rpcsec_gss.h>
64 #include <rpc/clnt.h>
65 
66 #include <nfs/nfs.h>
67 #include <nfs/nfs_clnt.h>
68 #include <nfs/mount.h>
69 #include <nfs/nfs_acl.h>
70 
71 #include <fs/fs_subr.h>
72 
73 #include <nfs/nfs4.h>
74 #include <nfs/rnode4.h>
75 #include <nfs/nfs4_clnt.h>
76 #include <sys/fs/autofs.h>
77 
78 #include <sys/sdt.h>
79 
80 
81 /*
82  * Arguments passed to thread to free data structures from forced unmount.
83  */
84 
85 typedef struct {
86 	vfs_t	*fm_vfsp;
87 	int	fm_flag;
88 	cred_t	*fm_cr;
89 } freemountargs_t;
90 
91 static void	async_free_mount(vfs_t *, int, cred_t *);
92 static void	nfs4_free_mount(vfs_t *, int, cred_t *);
93 static void	nfs4_free_mount_thread(freemountargs_t *);
94 static int nfs4_chkdup_servinfo4(servinfo4_t *, servinfo4_t *);
95 
96 /*
97  * From rpcsec module (common/rpcsec).
98  */
99 extern int sec_clnt_loadinfo(struct sec_data *, struct sec_data **, model_t);
100 extern void sec_clnt_freeinfo(struct sec_data *);
101 
102 /*
103  * The order and contents of this structure must be kept in sync with that of
104  * rfsreqcnt_v4_tmpl in nfs_stats.c
105  */
106 static char *rfsnames_v4[] = {
107 	"null", "compound", "reserved",	"access", "close", "commit", "create",
108 	"delegpurge", "delegreturn", "getattr",	"getfh", "link", "lock",
109 	"lockt", "locku", "lookup", "lookupp", "nverify", "open", "openattr",
110 	"open_confirm",	"open_downgrade", "putfh", "putpubfh", "putrootfh",
111 	"read", "readdir", "readlink", "remove", "rename", "renew",
112 	"restorefh", "savefh", "secinfo", "setattr", "setclientid",
113 	"setclientid_confirm", "verify", "write"
114 };
115 
116 /*
117  * nfs4_max_mount_retry is the number of times the client will redrive
118  * a mount compound before giving up and returning failure.  The intent
119  * is to redrive mount compounds which fail NFS4ERR_STALE so that
120  * if a component of the server path being mounted goes stale, it can
121  * "recover" by redriving the mount compund (LOOKUP ops).  This recovery
122  * code is needed outside of the recovery framework because mount is a
123  * special case.  The client doesn't create vnodes/rnodes for components
124  * of the server path being mounted.  The recovery code recovers real
125  * client objects, not STALE FHs which map to components of the server
126  * path being mounted.
127  *
128  * We could just fail the mount on the first time, but that would
129  * instantly trigger failover (from nfs4_mount), and the client should
130  * try to re-lookup the STALE FH before doing failover.  The easiest
131  * way to "re-lookup" is to simply redrive the mount compound.
132  */
133 static int nfs4_max_mount_retry = 2;
134 
135 /*
136  * nfs4 vfs operations.
137  */
138 int		nfs4_mount(vfs_t *, vnode_t *, struct mounta *, cred_t *);
139 static int	nfs4_unmount(vfs_t *, int, cred_t *);
140 static int	nfs4_root(vfs_t *, vnode_t **);
141 static int	nfs4_statvfs(vfs_t *, struct statvfs64 *);
142 static int	nfs4_sync(vfs_t *, short, cred_t *);
143 static int	nfs4_vget(vfs_t *, vnode_t **, fid_t *);
144 static int	nfs4_mountroot(vfs_t *, whymountroot_t);
145 static void	nfs4_freevfs(vfs_t *);
146 
147 static int	nfs4rootvp(vnode_t **, vfs_t *, struct servinfo4 *,
148 		    int, cred_t *, zone_t *);
149 
150 vfsops_t	*nfs4_vfsops;
151 
152 int nfs4_vfsinit(void);
153 void nfs4_vfsfini(void);
154 static void nfs4setclientid_init(void);
155 static void nfs4setclientid_fini(void);
156 static void nfs4setclientid_otw(mntinfo4_t *, servinfo4_t *,  cred_t *,
157 		struct nfs4_server *, nfs4_error_t *, int *);
158 static void	destroy_nfs4_server(nfs4_server_t *);
159 static void	remove_mi(nfs4_server_t *, mntinfo4_t *);
160 
161 extern void nfs4_ephemeral_init(void);
162 extern void nfs4_ephemeral_fini(void);
163 
164 /* referral related routines */
165 static servinfo4_t *copy_svp(servinfo4_t *);
166 static void free_knconf_contents(struct knetconfig *k);
167 static char *extract_referral_point(const char *, int);
168 static void setup_newsvpath(servinfo4_t *, int);
169 static void update_servinfo4(servinfo4_t *, fs_location4 *,
170 		struct nfs_fsl_info *, char *, int);
171 
172 /*
173  * Initialize the vfs structure
174  */
175 
176 static int nfs4fstyp;
177 
178 
179 /*
180  * Debug variable to check for rdma based
181  * transport startup and cleanup. Controlled
182  * through /etc/system. Off by default.
183  */
184 extern int rdma_debug;
185 
186 int
187 nfs4init(int fstyp, char *name)
188 {
189 	static const fs_operation_def_t nfs4_vfsops_template[] = {
190 		VFSNAME_MOUNT,		{ .vfs_mount = nfs4_mount },
191 		VFSNAME_UNMOUNT,	{ .vfs_unmount = nfs4_unmount },
192 		VFSNAME_ROOT,		{ .vfs_root = nfs4_root },
193 		VFSNAME_STATVFS,	{ .vfs_statvfs = nfs4_statvfs },
194 		VFSNAME_SYNC,		{ .vfs_sync = nfs4_sync },
195 		VFSNAME_VGET,		{ .vfs_vget = nfs4_vget },
196 		VFSNAME_MOUNTROOT,	{ .vfs_mountroot = nfs4_mountroot },
197 		VFSNAME_FREEVFS,	{ .vfs_freevfs = nfs4_freevfs },
198 		NULL,			NULL
199 	};
200 	int error;
201 
202 	nfs4_vfsops = NULL;
203 	nfs4_vnodeops = NULL;
204 	nfs4_trigger_vnodeops = NULL;
205 
206 	error = vfs_setfsops(fstyp, nfs4_vfsops_template, &nfs4_vfsops);
207 	if (error != 0) {
208 		zcmn_err(GLOBAL_ZONEID, CE_WARN,
209 		    "nfs4init: bad vfs ops template");
210 		goto out;
211 	}
212 
213 	error = vn_make_ops(name, nfs4_vnodeops_template, &nfs4_vnodeops);
214 	if (error != 0) {
215 		zcmn_err(GLOBAL_ZONEID, CE_WARN,
216 		    "nfs4init: bad vnode ops template");
217 		goto out;
218 	}
219 
220 	error = vn_make_ops("nfs4_trigger", nfs4_trigger_vnodeops_template,
221 	    &nfs4_trigger_vnodeops);
222 	if (error != 0) {
223 		zcmn_err(GLOBAL_ZONEID, CE_WARN,
224 		    "nfs4init: bad trigger vnode ops template");
225 		goto out;
226 	}
227 
228 	nfs4fstyp = fstyp;
229 	(void) nfs4_vfsinit();
230 	(void) nfs4_init_dot_entries();
231 
232 out:
233 	if (error) {
234 		if (nfs4_trigger_vnodeops != NULL)
235 			vn_freevnodeops(nfs4_trigger_vnodeops);
236 
237 		if (nfs4_vnodeops != NULL)
238 			vn_freevnodeops(nfs4_vnodeops);
239 
240 		(void) vfs_freevfsops_by_type(fstyp);
241 	}
242 
243 	return (error);
244 }
245 
246 void
247 nfs4fini(void)
248 {
249 	(void) nfs4_destroy_dot_entries();
250 	nfs4_vfsfini();
251 }
252 
253 /*
254  * Create a new sec_data structure to store AUTH_DH related data:
255  * netname, syncaddr, knetconfig. There is no AUTH_F_RPCTIMESYNC
256  * flag set for NFS V4 since we are avoiding to contact the rpcbind
257  * daemon and is using the IP time service (IPPORT_TIMESERVER).
258  *
259  * sec_data can be freed by sec_clnt_freeinfo().
260  */
261 static struct sec_data *
262 create_authdh_data(char *netname, int nlen, struct netbuf *syncaddr,
263 		struct knetconfig *knconf) {
264 	struct sec_data *secdata;
265 	dh_k4_clntdata_t *data;
266 	char *pf, *p;
267 
268 	if (syncaddr == NULL || syncaddr->buf == NULL || nlen == 0)
269 		return (NULL);
270 
271 	secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP);
272 	secdata->flags = 0;
273 
274 	data = kmem_alloc(sizeof (*data), KM_SLEEP);
275 
276 	data->syncaddr.maxlen = syncaddr->maxlen;
277 	data->syncaddr.len = syncaddr->len;
278 	data->syncaddr.buf = (char *)kmem_alloc(syncaddr->len, KM_SLEEP);
279 	bcopy(syncaddr->buf, data->syncaddr.buf, syncaddr->len);
280 
281 	/*
282 	 * duplicate the knconf information for the
283 	 * new opaque data.
284 	 */
285 	data->knconf = kmem_alloc(sizeof (*knconf), KM_SLEEP);
286 	*data->knconf = *knconf;
287 	pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
288 	p = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
289 	bcopy(knconf->knc_protofmly, pf, KNC_STRSIZE);
290 	bcopy(knconf->knc_proto, p, KNC_STRSIZE);
291 	data->knconf->knc_protofmly = pf;
292 	data->knconf->knc_proto = p;
293 
294 	/* move server netname to the sec_data structure */
295 	data->netname = kmem_alloc(nlen, KM_SLEEP);
296 	bcopy(netname, data->netname, nlen);
297 	data->netnamelen = (int)nlen;
298 
299 	secdata->secmod = AUTH_DH;
300 	secdata->rpcflavor = AUTH_DH;
301 	secdata->data = (caddr_t)data;
302 
303 	return (secdata);
304 }
305 
306 /*
307  * Returns (deep) copy of sec_data_t. Allocates all memory required; caller
308  * is responsible for freeing.
309  */
310 sec_data_t *
311 copy_sec_data(sec_data_t *fsecdata) {
312 	sec_data_t *tsecdata;
313 
314 	if (fsecdata == NULL)
315 		return (NULL);
316 
317 	if (fsecdata->rpcflavor == AUTH_DH) {
318 		dh_k4_clntdata_t *fdata = (dh_k4_clntdata_t *)fsecdata->data;
319 
320 		if (fdata == NULL)
321 			return (NULL);
322 
323 		tsecdata = (sec_data_t *)create_authdh_data(fdata->netname,
324 		    fdata->netnamelen, &fdata->syncaddr, fdata->knconf);
325 
326 		return (tsecdata);
327 	}
328 
329 	tsecdata = kmem_zalloc(sizeof (sec_data_t), KM_SLEEP);
330 
331 	tsecdata->secmod = fsecdata->secmod;
332 	tsecdata->rpcflavor = fsecdata->rpcflavor;
333 	tsecdata->flags = fsecdata->flags;
334 	tsecdata->uid = fsecdata->uid;
335 
336 	if (fsecdata->rpcflavor == RPCSEC_GSS) {
337 		gss_clntdata_t *gcd = (gss_clntdata_t *)fsecdata->data;
338 
339 		tsecdata->data = (caddr_t)copy_sec_data_gss(gcd);
340 	} else {
341 		tsecdata->data = NULL;
342 	}
343 
344 	return (tsecdata);
345 }
346 
347 gss_clntdata_t *
348 copy_sec_data_gss(gss_clntdata_t *fdata)
349 {
350 	gss_clntdata_t *tdata;
351 
352 	if (fdata == NULL)
353 		return (NULL);
354 
355 	tdata = kmem_zalloc(sizeof (gss_clntdata_t), KM_SLEEP);
356 
357 	tdata->mechanism.length = fdata->mechanism.length;
358 	tdata->mechanism.elements = kmem_zalloc(fdata->mechanism.length,
359 	    KM_SLEEP);
360 	bcopy(fdata->mechanism.elements, tdata->mechanism.elements,
361 	    fdata->mechanism.length);
362 
363 	tdata->service = fdata->service;
364 
365 	(void) strcpy(tdata->uname, fdata->uname);
366 	(void) strcpy(tdata->inst, fdata->inst);
367 	(void) strcpy(tdata->realm, fdata->realm);
368 
369 	tdata->qop = fdata->qop;
370 
371 	return (tdata);
372 }
373 
374 static int
375 nfs4_chkdup_servinfo4(servinfo4_t *svp_head, servinfo4_t *svp)
376 {
377 	servinfo4_t *si;
378 
379 	/*
380 	 * Iterate over the servinfo4 list to make sure
381 	 * we do not have a duplicate. Skip any servinfo4
382 	 * that has been marked "NOT IN USE"
383 	 */
384 	for (si = svp_head; si; si = si->sv_next) {
385 		(void) nfs_rw_enter_sig(&si->sv_lock, RW_READER, 0);
386 		if (si->sv_flags & SV4_NOTINUSE) {
387 			nfs_rw_exit(&si->sv_lock);
388 			continue;
389 		}
390 		nfs_rw_exit(&si->sv_lock);
391 		if (si == svp)
392 			continue;
393 		if (si->sv_addr.len == svp->sv_addr.len &&
394 		    strcmp(si->sv_knconf->knc_protofmly,
395 		    svp->sv_knconf->knc_protofmly) == 0 &&
396 		    bcmp(si->sv_addr.buf, svp->sv_addr.buf,
397 		    si->sv_addr.len) == 0) {
398 			/* it's a duplicate */
399 			return (1);
400 		}
401 	}
402 	/* it's not a duplicate */
403 	return (0);
404 }
405 
406 void
407 nfs4_free_args(struct nfs_args *nargs)
408 {
409 	if (nargs->knconf) {
410 		if (nargs->knconf->knc_protofmly)
411 			kmem_free(nargs->knconf->knc_protofmly,
412 			    KNC_STRSIZE);
413 		if (nargs->knconf->knc_proto)
414 			kmem_free(nargs->knconf->knc_proto, KNC_STRSIZE);
415 		kmem_free(nargs->knconf, sizeof (*nargs->knconf));
416 		nargs->knconf = NULL;
417 	}
418 
419 	if (nargs->fh) {
420 		kmem_free(nargs->fh, strlen(nargs->fh) + 1);
421 		nargs->fh = NULL;
422 	}
423 
424 	if (nargs->hostname) {
425 		kmem_free(nargs->hostname, strlen(nargs->hostname) + 1);
426 		nargs->hostname = NULL;
427 	}
428 
429 	if (nargs->addr) {
430 		if (nargs->addr->buf) {
431 			ASSERT(nargs->addr->len);
432 			kmem_free(nargs->addr->buf, nargs->addr->len);
433 		}
434 		kmem_free(nargs->addr, sizeof (struct netbuf));
435 		nargs->addr = NULL;
436 	}
437 
438 	if (nargs->syncaddr) {
439 		ASSERT(nargs->syncaddr->len);
440 		if (nargs->syncaddr->buf) {
441 			ASSERT(nargs->syncaddr->len);
442 			kmem_free(nargs->syncaddr->buf, nargs->syncaddr->len);
443 		}
444 		kmem_free(nargs->syncaddr, sizeof (struct netbuf));
445 		nargs->syncaddr = NULL;
446 	}
447 
448 	if (nargs->netname) {
449 		kmem_free(nargs->netname, strlen(nargs->netname) + 1);
450 		nargs->netname = NULL;
451 	}
452 
453 	if (nargs->nfs_ext_u.nfs_extA.secdata) {
454 		sec_clnt_freeinfo(
455 		    nargs->nfs_ext_u.nfs_extA.secdata);
456 		nargs->nfs_ext_u.nfs_extA.secdata = NULL;
457 	}
458 }
459 
460 
461 int
462 nfs4_copyin(char *data, int datalen, struct nfs_args *nargs)
463 {
464 
465 	int error;
466 	size_t hlen;			/* length of hostname */
467 	size_t nlen;			/* length of netname */
468 	char netname[MAXNETNAMELEN+1];	/* server's netname */
469 	struct netbuf addr;		/* server's address */
470 	struct netbuf syncaddr;		/* AUTH_DES time sync addr */
471 	struct knetconfig *knconf;		/* transport structure */
472 	struct sec_data *secdata = NULL;	/* security data */
473 	STRUCT_DECL(nfs_args, args);		/* nfs mount arguments */
474 	STRUCT_DECL(knetconfig, knconf_tmp);
475 	STRUCT_DECL(netbuf, addr_tmp);
476 	int flags;
477 	char *p, *pf;
478 	struct pathname pn;
479 	char *userbufptr;
480 
481 
482 	bzero(nargs, sizeof (*nargs));
483 
484 	STRUCT_INIT(args, get_udatamodel());
485 	bzero(STRUCT_BUF(args), SIZEOF_STRUCT(nfs_args, DATAMODEL_NATIVE));
486 	if (copyin(data, STRUCT_BUF(args), MIN(datalen,
487 	    STRUCT_SIZE(args))))
488 		return (EFAULT);
489 
490 	nargs->wsize = STRUCT_FGET(args, wsize);
491 	nargs->rsize = STRUCT_FGET(args, rsize);
492 	nargs->timeo = STRUCT_FGET(args, timeo);
493 	nargs->retrans = STRUCT_FGET(args, retrans);
494 	nargs->acregmin = STRUCT_FGET(args, acregmin);
495 	nargs->acregmax = STRUCT_FGET(args, acregmax);
496 	nargs->acdirmin = STRUCT_FGET(args, acdirmin);
497 	nargs->acdirmax = STRUCT_FGET(args, acdirmax);
498 
499 	flags = STRUCT_FGET(args, flags);
500 	nargs->flags = flags;
501 
502 	addr.buf = NULL;
503 	syncaddr.buf = NULL;
504 
505 
506 	/*
507 	 * Allocate space for a knetconfig structure and
508 	 * its strings and copy in from user-land.
509 	 */
510 	knconf = kmem_zalloc(sizeof (*knconf), KM_SLEEP);
511 	STRUCT_INIT(knconf_tmp, get_udatamodel());
512 	if (copyin(STRUCT_FGETP(args, knconf), STRUCT_BUF(knconf_tmp),
513 	    STRUCT_SIZE(knconf_tmp))) {
514 		kmem_free(knconf, sizeof (*knconf));
515 		return (EFAULT);
516 	}
517 
518 	knconf->knc_semantics = STRUCT_FGET(knconf_tmp, knc_semantics);
519 	knconf->knc_protofmly = STRUCT_FGETP(knconf_tmp, knc_protofmly);
520 	knconf->knc_proto = STRUCT_FGETP(knconf_tmp, knc_proto);
521 	if (get_udatamodel() != DATAMODEL_LP64) {
522 		knconf->knc_rdev = expldev(STRUCT_FGET(knconf_tmp, knc_rdev));
523 	} else {
524 		knconf->knc_rdev = STRUCT_FGET(knconf_tmp, knc_rdev);
525 	}
526 
527 	pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
528 	p = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
529 	error = copyinstr(knconf->knc_protofmly, pf, KNC_STRSIZE, NULL);
530 	if (error) {
531 		kmem_free(pf, KNC_STRSIZE);
532 		kmem_free(p, KNC_STRSIZE);
533 		kmem_free(knconf, sizeof (*knconf));
534 		return (error);
535 	}
536 
537 	error = copyinstr(knconf->knc_proto, p, KNC_STRSIZE, NULL);
538 	if (error) {
539 		kmem_free(pf, KNC_STRSIZE);
540 		kmem_free(p, KNC_STRSIZE);
541 		kmem_free(knconf, sizeof (*knconf));
542 		return (error);
543 	}
544 
545 
546 	knconf->knc_protofmly = pf;
547 	knconf->knc_proto = p;
548 
549 	nargs->knconf = knconf;
550 
551 	/*
552 	 * Get server address
553 	 */
554 	STRUCT_INIT(addr_tmp, get_udatamodel());
555 	if (copyin(STRUCT_FGETP(args, addr), STRUCT_BUF(addr_tmp),
556 	    STRUCT_SIZE(addr_tmp))) {
557 		error = EFAULT;
558 		goto errout;
559 	}
560 
561 	nargs->addr = kmem_zalloc(sizeof (struct netbuf), KM_SLEEP);
562 	userbufptr = STRUCT_FGETP(addr_tmp, buf);
563 	addr.len = STRUCT_FGET(addr_tmp, len);
564 	addr.buf = kmem_alloc(addr.len, KM_SLEEP);
565 	addr.maxlen = addr.len;
566 	if (copyin(userbufptr, addr.buf, addr.len)) {
567 		kmem_free(addr.buf, addr.len);
568 		error = EFAULT;
569 		goto errout;
570 	}
571 	bcopy(&addr, nargs->addr, sizeof (struct netbuf));
572 
573 	/*
574 	 * Get the root fhandle
575 	 */
576 	error = pn_get(STRUCT_FGETP(args, fh), UIO_USERSPACE, &pn);
577 	if (error)
578 		goto errout;
579 
580 	/* Volatile fh: keep server paths, so use actual-size strings */
581 	nargs->fh = kmem_alloc(pn.pn_pathlen + 1, KM_SLEEP);
582 	bcopy(pn.pn_path, nargs->fh, pn.pn_pathlen);
583 	nargs->fh[pn.pn_pathlen] = '\0';
584 	pn_free(&pn);
585 
586 
587 	/*
588 	 * Get server's hostname
589 	 */
590 	if (flags & NFSMNT_HOSTNAME) {
591 		error = copyinstr(STRUCT_FGETP(args, hostname),
592 		    netname, sizeof (netname), &hlen);
593 		if (error)
594 			goto errout;
595 		nargs->hostname = kmem_zalloc(hlen, KM_SLEEP);
596 		(void) strcpy(nargs->hostname, netname);
597 
598 	} else {
599 		nargs->hostname = NULL;
600 	}
601 
602 
603 	/*
604 	 * If there are syncaddr and netname data, load them in. This is
605 	 * to support data needed for NFSV4 when AUTH_DH is the negotiated
606 	 * flavor via SECINFO. (instead of using MOUNT protocol in V3).
607 	 */
608 	netname[0] = '\0';
609 	if (flags & NFSMNT_SECURE) {
610 
611 		/* get syncaddr */
612 		STRUCT_INIT(addr_tmp, get_udatamodel());
613 		if (copyin(STRUCT_FGETP(args, syncaddr), STRUCT_BUF(addr_tmp),
614 		    STRUCT_SIZE(addr_tmp))) {
615 			error = EINVAL;
616 			goto errout;
617 		}
618 		userbufptr = STRUCT_FGETP(addr_tmp, buf);
619 		syncaddr.len = STRUCT_FGET(addr_tmp, len);
620 		syncaddr.buf = kmem_alloc(syncaddr.len, KM_SLEEP);
621 		syncaddr.maxlen = syncaddr.len;
622 		if (copyin(userbufptr, syncaddr.buf, syncaddr.len)) {
623 			kmem_free(syncaddr.buf, syncaddr.len);
624 			error = EFAULT;
625 			goto errout;
626 		}
627 
628 		nargs->syncaddr = kmem_alloc(sizeof (struct netbuf), KM_SLEEP);
629 		bcopy(&syncaddr, nargs->syncaddr, sizeof (struct netbuf));
630 
631 		/* get server's netname */
632 		if (copyinstr(STRUCT_FGETP(args, netname), netname,
633 		    sizeof (netname), &nlen)) {
634 			error = EFAULT;
635 			goto errout;
636 		}
637 
638 		netname[nlen] = '\0';
639 		nargs->netname = kmem_zalloc(nlen, KM_SLEEP);
640 		(void) strcpy(nargs->netname, netname);
641 	}
642 
643 	/*
644 	 * Get the extention data which has the security data structure.
645 	 * This includes data for AUTH_SYS as well.
646 	 */
647 	if (flags & NFSMNT_NEWARGS) {
648 		nargs->nfs_args_ext = STRUCT_FGET(args, nfs_args_ext);
649 		if (nargs->nfs_args_ext == NFS_ARGS_EXTA ||
650 		    nargs->nfs_args_ext == NFS_ARGS_EXTB) {
651 			/*
652 			 * Indicating the application is using the new
653 			 * sec_data structure to pass in the security
654 			 * data.
655 			 */
656 			if (STRUCT_FGETP(args,
657 			    nfs_ext_u.nfs_extA.secdata) != NULL) {
658 				error = sec_clnt_loadinfo(
659 				    (struct sec_data *)STRUCT_FGETP(args,
660 				    nfs_ext_u.nfs_extA.secdata),
661 				    &secdata, get_udatamodel());
662 			}
663 			nargs->nfs_ext_u.nfs_extA.secdata = secdata;
664 		}
665 	}
666 
667 	if (error)
668 		goto errout;
669 
670 	/*
671 	 * Failover support:
672 	 *
673 	 * We may have a linked list of nfs_args structures,
674 	 * which means the user is looking for failover.  If
675 	 * the mount is either not "read-only" or "soft",
676 	 * we want to bail out with EINVAL.
677 	 */
678 	if (nargs->nfs_args_ext == NFS_ARGS_EXTB)
679 		nargs->nfs_ext_u.nfs_extB.next =
680 		    STRUCT_FGETP(args, nfs_ext_u.nfs_extB.next);
681 
682 errout:
683 	if (error)
684 		nfs4_free_args(nargs);
685 
686 	return (error);
687 }
688 
689 
690 /*
691  * nfs mount vfsop
692  * Set up mount info record and attach it to vfs struct.
693  */
694 int
695 nfs4_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
696 {
697 	char *data = uap->dataptr;
698 	int error;
699 	vnode_t *rtvp;			/* the server's root */
700 	mntinfo4_t *mi;			/* mount info, pointed at by vfs */
701 	struct knetconfig *rdma_knconf;	/* rdma transport structure */
702 	rnode4_t *rp;
703 	struct servinfo4 *svp;		/* nfs server info */
704 	struct servinfo4 *svp_tail = NULL; /* previous nfs server info */
705 	struct servinfo4 *svp_head;	/* first nfs server info */
706 	struct servinfo4 *svp_2ndlast;	/* 2nd last in server info list */
707 	struct sec_data *secdata;	/* security data */
708 	struct nfs_args *args = NULL;
709 	int flags, addr_type, removed;
710 	zone_t *zone = nfs_zone();
711 	nfs4_error_t n4e;
712 	zone_t *mntzone = NULL;
713 
714 	if (secpolicy_fs_mount(cr, mvp, vfsp) != 0)
715 		return (EPERM);
716 	if (mvp->v_type != VDIR)
717 		return (ENOTDIR);
718 
719 	/*
720 	 * get arguments
721 	 *
722 	 * nfs_args is now versioned and is extensible, so
723 	 * uap->datalen might be different from sizeof (args)
724 	 * in a compatible situation.
725 	 */
726 more:
727 	if (!(uap->flags & MS_SYSSPACE)) {
728 		if (args == NULL)
729 			args = kmem_zalloc(sizeof (struct nfs_args), KM_SLEEP);
730 		else
731 			nfs4_free_args(args);
732 		error = nfs4_copyin(data, uap->datalen, args);
733 		if (error) {
734 			if (args) {
735 				kmem_free(args, sizeof (*args));
736 			}
737 			return (error);
738 		}
739 	} else {
740 		args = (struct nfs_args *)data;
741 	}
742 
743 	flags = args->flags;
744 
745 	/*
746 	 * If the request changes the locking type, disallow the remount,
747 	 * because it's questionable whether we can transfer the
748 	 * locking state correctly.
749 	 */
750 	if (uap->flags & MS_REMOUNT) {
751 		if (!(uap->flags & MS_SYSSPACE)) {
752 			nfs4_free_args(args);
753 			kmem_free(args, sizeof (*args));
754 		}
755 		if ((mi = VFTOMI4(vfsp)) != NULL) {
756 			uint_t new_mi_llock;
757 			uint_t old_mi_llock;
758 			new_mi_llock = (flags & NFSMNT_LLOCK) ? 1 : 0;
759 			old_mi_llock = (mi->mi_flags & MI4_LLOCK) ? 1 : 0;
760 			if (old_mi_llock != new_mi_llock)
761 				return (EBUSY);
762 		}
763 		return (0);
764 	}
765 
766 	/*
767 	 * For ephemeral mount trigger stub vnodes, we have two problems
768 	 * to solve: racing threads will likely fail the v_count check, and
769 	 * we want only one to proceed with the mount.
770 	 *
771 	 * For stubs, if the mount has already occurred (via a racing thread),
772 	 * just return success. If not, skip the v_count check and proceed.
773 	 * Note that we are already serialised at this point.
774 	 */
775 	mutex_enter(&mvp->v_lock);
776 	if (vn_matchops(mvp, nfs4_trigger_vnodeops)) {
777 		/* mntpt is a v4 stub vnode */
778 		ASSERT(RP_ISSTUB(VTOR4(mvp)));
779 		ASSERT(!(uap->flags & MS_OVERLAY));
780 		ASSERT(!(mvp->v_flag & VROOT));
781 		if (vn_mountedvfs(mvp) != NULL) {
782 			/* ephemeral mount has already occurred */
783 			ASSERT(uap->flags & MS_SYSSPACE);
784 			mutex_exit(&mvp->v_lock);
785 			return (0);
786 		}
787 	} else {
788 		/* mntpt is a non-v4 or v4 non-stub vnode */
789 		if (!(uap->flags & MS_OVERLAY) &&
790 		    (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
791 			mutex_exit(&mvp->v_lock);
792 			if (!(uap->flags & MS_SYSSPACE)) {
793 				nfs4_free_args(args);
794 				kmem_free(args, sizeof (*args));
795 			}
796 			return (EBUSY);
797 		}
798 	}
799 	mutex_exit(&mvp->v_lock);
800 
801 	/* make sure things are zeroed for errout: */
802 	rtvp = NULL;
803 	mi = NULL;
804 	secdata = NULL;
805 
806 	/*
807 	 * A valid knetconfig structure is required.
808 	 */
809 	if (!(flags & NFSMNT_KNCONF) ||
810 	    args->knconf == NULL || args->knconf->knc_protofmly == NULL ||
811 	    args->knconf->knc_proto == NULL ||
812 	    (strcmp(args->knconf->knc_proto, NC_UDP) == 0)) {
813 		if (!(uap->flags & MS_SYSSPACE)) {
814 			nfs4_free_args(args);
815 			kmem_free(args, sizeof (*args));
816 		}
817 		return (EINVAL);
818 	}
819 
820 	if ((strlen(args->knconf->knc_protofmly) >= KNC_STRSIZE) ||
821 	    (strlen(args->knconf->knc_proto) >= KNC_STRSIZE)) {
822 		if (!(uap->flags & MS_SYSSPACE)) {
823 			nfs4_free_args(args);
824 			kmem_free(args, sizeof (*args));
825 		}
826 		return (EINVAL);
827 	}
828 
829 	/*
830 	 * Allocate a servinfo4 struct.
831 	 */
832 	svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
833 	nfs_rw_init(&svp->sv_lock, NULL, RW_DEFAULT, NULL);
834 	if (svp_tail) {
835 		svp_2ndlast = svp_tail;
836 		svp_tail->sv_next = svp;
837 	} else {
838 		svp_head = svp;
839 		svp_2ndlast = svp;
840 	}
841 
842 	svp_tail = svp;
843 	svp->sv_knconf = args->knconf;
844 	args->knconf = NULL;
845 
846 	/*
847 	 * Get server address
848 	 */
849 	if (args->addr == NULL || args->addr->buf == NULL) {
850 		error = EINVAL;
851 		goto errout;
852 	}
853 
854 	svp->sv_addr.maxlen = args->addr->maxlen;
855 	svp->sv_addr.len = args->addr->len;
856 	svp->sv_addr.buf = args->addr->buf;
857 	args->addr->buf = NULL;
858 
859 	/*
860 	 * Get the root fhandle
861 	 */
862 	if (args->fh == NULL || (strlen(args->fh) >= MAXPATHLEN)) {
863 		error = EINVAL;
864 		goto errout;
865 	}
866 
867 	svp->sv_path = args->fh;
868 	svp->sv_pathlen = strlen(args->fh) + 1;
869 	args->fh = NULL;
870 
871 	/*
872 	 * Get server's hostname
873 	 */
874 	if (flags & NFSMNT_HOSTNAME) {
875 		if (args->hostname == NULL || (strlen(args->hostname) >
876 		    MAXNETNAMELEN)) {
877 			error = EINVAL;
878 			goto errout;
879 		}
880 		svp->sv_hostnamelen = strlen(args->hostname) + 1;
881 		svp->sv_hostname = args->hostname;
882 		args->hostname = NULL;
883 	} else {
884 		char *p = "unknown-host";
885 		svp->sv_hostnamelen = strlen(p) + 1;
886 		svp->sv_hostname = kmem_zalloc(svp->sv_hostnamelen, KM_SLEEP);
887 		(void) strcpy(svp->sv_hostname, p);
888 	}
889 
890 	/*
891 	 * RDMA MOUNT SUPPORT FOR NFS v4.
892 	 * Establish, is it possible to use RDMA, if so overload the
893 	 * knconf with rdma specific knconf and free the orignal knconf.
894 	 */
895 	if ((flags & NFSMNT_TRYRDMA) || (flags & NFSMNT_DORDMA)) {
896 		/*
897 		 * Determine the addr type for RDMA, IPv4 or v6.
898 		 */
899 		if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET) == 0)
900 			addr_type = AF_INET;
901 		else if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET6) == 0)
902 			addr_type = AF_INET6;
903 
904 		if (rdma_reachable(addr_type, &svp->sv_addr,
905 		    &rdma_knconf) == 0) {
906 			/*
907 			 * If successful, hijack the orignal knconf and
908 			 * replace with the new one, depending on the flags.
909 			 */
910 			svp->sv_origknconf = svp->sv_knconf;
911 			svp->sv_knconf = rdma_knconf;
912 		} else {
913 			if (flags & NFSMNT_TRYRDMA) {
914 #ifdef	DEBUG
915 				if (rdma_debug)
916 					zcmn_err(getzoneid(), CE_WARN,
917 					    "no RDMA onboard, revert\n");
918 #endif
919 			}
920 
921 			if (flags & NFSMNT_DORDMA) {
922 				/*
923 				 * If proto=rdma is specified and no RDMA
924 				 * path to this server is avialable then
925 				 * ditch this server.
926 				 * This is not included in the mountable
927 				 * server list or the replica list.
928 				 * Check if more servers are specified;
929 				 * Failover case, otherwise bail out of mount.
930 				 */
931 				if (args->nfs_args_ext == NFS_ARGS_EXTB &&
932 				    args->nfs_ext_u.nfs_extB.next != NULL) {
933 					data = (char *)
934 					    args->nfs_ext_u.nfs_extB.next;
935 					if (uap->flags & MS_RDONLY &&
936 					    !(flags & NFSMNT_SOFT)) {
937 						if (svp_head->sv_next == NULL) {
938 							svp_tail = NULL;
939 							svp_2ndlast = NULL;
940 							sv4_free(svp_head);
941 							goto more;
942 						} else {
943 							svp_tail = svp_2ndlast;
944 							svp_2ndlast->sv_next =
945 							    NULL;
946 							sv4_free(svp);
947 							goto more;
948 						}
949 					}
950 				} else {
951 					/*
952 					 * This is the last server specified
953 					 * in the nfs_args list passed down
954 					 * and its not rdma capable.
955 					 */
956 					if (svp_head->sv_next == NULL) {
957 						/*
958 						 * Is this the only one
959 						 */
960 						error = EINVAL;
961 #ifdef	DEBUG
962 						if (rdma_debug)
963 							zcmn_err(getzoneid(),
964 							    CE_WARN,
965 							    "No RDMA srv");
966 #endif
967 						goto errout;
968 					} else {
969 						/*
970 						 * There is list, since some
971 						 * servers specified before
972 						 * this passed all requirements
973 						 */
974 						svp_tail = svp_2ndlast;
975 						svp_2ndlast->sv_next = NULL;
976 						sv4_free(svp);
977 						goto proceed;
978 					}
979 				}
980 			}
981 		}
982 	}
983 
984 	/*
985 	 * If there are syncaddr and netname data, load them in. This is
986 	 * to support data needed for NFSV4 when AUTH_DH is the negotiated
987 	 * flavor via SECINFO. (instead of using MOUNT protocol in V3).
988 	 */
989 	if (args->flags & NFSMNT_SECURE) {
990 		svp->sv_dhsec = create_authdh_data(args->netname,
991 		    strlen(args->netname),
992 		    args->syncaddr, svp->sv_knconf);
993 	}
994 
995 	/*
996 	 * Get the extention data which has the security data structure.
997 	 * This includes data for AUTH_SYS as well.
998 	 */
999 	if (flags & NFSMNT_NEWARGS) {
1000 		switch (args->nfs_args_ext) {
1001 		case NFS_ARGS_EXTA:
1002 		case NFS_ARGS_EXTB:
1003 			/*
1004 			 * Indicating the application is using the new
1005 			 * sec_data structure to pass in the security
1006 			 * data.
1007 			 */
1008 			secdata = args->nfs_ext_u.nfs_extA.secdata;
1009 			if (secdata == NULL) {
1010 				error = EINVAL;
1011 			} else if (uap->flags & MS_SYSSPACE) {
1012 				/*
1013 				 * Need to validate the flavor here if
1014 				 * sysspace, userspace was already
1015 				 * validate from the nfs_copyin function.
1016 				 */
1017 				switch (secdata->rpcflavor) {
1018 				case AUTH_NONE:
1019 				case AUTH_UNIX:
1020 				case AUTH_LOOPBACK:
1021 				case AUTH_DES:
1022 				case RPCSEC_GSS:
1023 					break;
1024 				default:
1025 					error = EINVAL;
1026 					goto errout;
1027 				}
1028 			}
1029 			args->nfs_ext_u.nfs_extA.secdata = NULL;
1030 			break;
1031 
1032 		default:
1033 			error = EINVAL;
1034 			break;
1035 		}
1036 
1037 	} else if (flags & NFSMNT_SECURE) {
1038 		/*
1039 		 * NFSMNT_SECURE is deprecated but we keep it
1040 		 * to support the rogue user-generated application
1041 		 * that may use this undocumented interface to do
1042 		 * AUTH_DH security, e.g. our own rexd.
1043 		 *
1044 		 * Also note that NFSMNT_SECURE is used for passing
1045 		 * AUTH_DH info to be used in negotiation.
1046 		 */
1047 		secdata = create_authdh_data(args->netname,
1048 		    strlen(args->netname), args->syncaddr, svp->sv_knconf);
1049 
1050 	} else {
1051 		secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP);
1052 		secdata->secmod = secdata->rpcflavor = AUTH_SYS;
1053 		secdata->data = NULL;
1054 	}
1055 
1056 	svp->sv_secdata = secdata;
1057 
1058 	/*
1059 	 * User does not explictly specify a flavor, and a user
1060 	 * defined default flavor is passed down.
1061 	 */
1062 	if (flags & NFSMNT_SECDEFAULT) {
1063 		(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
1064 		svp->sv_flags |= SV4_TRYSECDEFAULT;
1065 		nfs_rw_exit(&svp->sv_lock);
1066 	}
1067 
1068 	/*
1069 	 * Failover support:
1070 	 *
1071 	 * We may have a linked list of nfs_args structures,
1072 	 * which means the user is looking for failover.  If
1073 	 * the mount is either not "read-only" or "soft",
1074 	 * we want to bail out with EINVAL.
1075 	 */
1076 	if (args->nfs_args_ext == NFS_ARGS_EXTB &&
1077 	    args->nfs_ext_u.nfs_extB.next != NULL) {
1078 		if (uap->flags & MS_RDONLY && !(flags & NFSMNT_SOFT)) {
1079 			data = (char *)args->nfs_ext_u.nfs_extB.next;
1080 			goto more;
1081 		}
1082 		error = EINVAL;
1083 		goto errout;
1084 	}
1085 
1086 	/*
1087 	 * Determine the zone we're being mounted into.
1088 	 */
1089 	zone_hold(mntzone = zone);		/* start with this assumption */
1090 	if (getzoneid() == GLOBAL_ZONEID) {
1091 		zone_rele(mntzone);
1092 		mntzone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
1093 		ASSERT(mntzone != NULL);
1094 		if (mntzone != zone) {
1095 			error = EBUSY;
1096 			goto errout;
1097 		}
1098 	}
1099 
1100 	if (is_system_labeled()) {
1101 		error = nfs_mount_label_policy(vfsp, &svp->sv_addr,
1102 		    svp->sv_knconf, cr);
1103 
1104 		if (error > 0)
1105 			goto errout;
1106 
1107 		if (error == -1) {
1108 			/* change mount to read-only to prevent write-down */
1109 			vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
1110 		}
1111 	}
1112 
1113 	/*
1114 	 * Stop the mount from going any further if the zone is going away.
1115 	 */
1116 	if (zone_status_get(mntzone) >= ZONE_IS_SHUTTING_DOWN) {
1117 		error = EBUSY;
1118 		goto errout;
1119 	}
1120 
1121 	/*
1122 	 * Get root vnode.
1123 	 */
1124 proceed:
1125 	error = nfs4rootvp(&rtvp, vfsp, svp_head, flags, cr, mntzone);
1126 	if (error) {
1127 		/* if nfs4rootvp failed, it will free svp_head */
1128 		svp_head = NULL;
1129 		goto errout;
1130 	}
1131 
1132 	mi = VTOMI4(rtvp);
1133 
1134 	/*
1135 	 * Send client id to the server, if necessary
1136 	 */
1137 	nfs4_error_zinit(&n4e);
1138 	nfs4setclientid(mi, cr, FALSE, &n4e);
1139 
1140 	error = n4e.error;
1141 
1142 	if (error)
1143 		goto errout;
1144 
1145 	/*
1146 	 * Set option fields in the mount info record
1147 	 */
1148 
1149 	if (svp_head->sv_next) {
1150 		mutex_enter(&mi->mi_lock);
1151 		mi->mi_flags |= MI4_LLOCK;
1152 		mutex_exit(&mi->mi_lock);
1153 	}
1154 	error = nfs4_setopts(rtvp, DATAMODEL_NATIVE, args);
1155 	if (error)
1156 		goto errout;
1157 
1158 	/*
1159 	 * Time to tie in the mirror mount info at last!
1160 	 */
1161 	if (flags & NFSMNT_EPHEMERAL)
1162 		error = nfs4_record_ephemeral_mount(mi, mvp);
1163 
1164 errout:
1165 	if (error) {
1166 		if (rtvp != NULL) {
1167 			rp = VTOR4(rtvp);
1168 			if (rp->r_flags & R4HASHED)
1169 				rp4_rmhash(rp);
1170 		}
1171 		if (mi != NULL) {
1172 			nfs4_async_stop(vfsp);
1173 			nfs4_async_manager_stop(vfsp);
1174 			nfs4_remove_mi_from_server(mi, NULL);
1175 			if (rtvp != NULL)
1176 				VN_RELE(rtvp);
1177 			if (mntzone != NULL)
1178 				zone_rele(mntzone);
1179 			/* need to remove it from the zone */
1180 			removed = nfs4_mi_zonelist_remove(mi);
1181 			if (removed)
1182 				zone_rele_ref(&mi->mi_zone_ref,
1183 				    ZONE_REF_NFSV4);
1184 			MI4_RELE(mi);
1185 			if (!(uap->flags & MS_SYSSPACE) && args) {
1186 				nfs4_free_args(args);
1187 				kmem_free(args, sizeof (*args));
1188 			}
1189 			return (error);
1190 		}
1191 		if (svp_head)
1192 			sv4_free(svp_head);
1193 	}
1194 
1195 	if (!(uap->flags & MS_SYSSPACE) && args) {
1196 		nfs4_free_args(args);
1197 		kmem_free(args, sizeof (*args));
1198 	}
1199 	if (rtvp != NULL)
1200 		VN_RELE(rtvp);
1201 
1202 	if (mntzone != NULL)
1203 		zone_rele(mntzone);
1204 
1205 	return (error);
1206 }
1207 
1208 #ifdef  DEBUG
1209 #define	VERS_MSG	"NFS4 server "
1210 #else
1211 #define	VERS_MSG	"NFS server "
1212 #endif
1213 
1214 #define	READ_MSG        \
1215 	VERS_MSG "%s returned 0 for read transfer size"
1216 #define	WRITE_MSG       \
1217 	VERS_MSG "%s returned 0 for write transfer size"
1218 #define	SIZE_MSG        \
1219 	VERS_MSG "%s returned 0 for maximum file size"
1220 
1221 /*
1222  * Get the symbolic link text from the server for a given filehandle
1223  * of that symlink.
1224  *
1225  *      (get symlink text) PUTFH READLINK
1226  */
1227 static int
1228 getlinktext_otw(mntinfo4_t *mi, nfs_fh4 *fh, char **linktextp, cred_t *cr,
1229     int flags)
1230 {
1231 	COMPOUND4args_clnt args;
1232 	COMPOUND4res_clnt res;
1233 	int doqueue;
1234 	nfs_argop4 argop[2];
1235 	nfs_resop4 *resop;
1236 	READLINK4res *lr_res;
1237 	uint_t len;
1238 	bool_t needrecov = FALSE;
1239 	nfs4_recov_state_t recov_state;
1240 	nfs4_sharedfh_t *sfh;
1241 	nfs4_error_t e;
1242 	int num_retry = nfs4_max_mount_retry;
1243 	int recovery = !(flags & NFS4_GETFH_NEEDSOP);
1244 
1245 	sfh = sfh4_get(fh, mi);
1246 	recov_state.rs_flags = 0;
1247 	recov_state.rs_num_retry_despite_err = 0;
1248 
1249 recov_retry:
1250 	nfs4_error_zinit(&e);
1251 
1252 	args.array_len = 2;
1253 	args.array = argop;
1254 	args.ctag = TAG_GET_SYMLINK;
1255 
1256 	if (! recovery) {
1257 		e.error = nfs4_start_op(mi, NULL, NULL, &recov_state);
1258 		if (e.error) {
1259 			sfh4_rele(&sfh);
1260 			return (e.error);
1261 		}
1262 	}
1263 
1264 	/* 0. putfh symlink fh */
1265 	argop[0].argop = OP_CPUTFH;
1266 	argop[0].nfs_argop4_u.opcputfh.sfh = sfh;
1267 
1268 	/* 1. readlink */
1269 	argop[1].argop = OP_READLINK;
1270 
1271 	doqueue = 1;
1272 
1273 	rfs4call(mi, &args, &res, cr, &doqueue, 0, &e);
1274 
1275 	needrecov = nfs4_needs_recovery(&e, FALSE, mi->mi_vfsp);
1276 
1277 	if (needrecov && !recovery && num_retry-- > 0) {
1278 
1279 		NFS4_DEBUG(nfs4_client_recov_debug, (CE_NOTE,
1280 		    "getlinktext_otw: initiating recovery\n"));
1281 
1282 		if (nfs4_start_recovery(&e, mi, NULL, NULL, NULL, NULL,
1283 		    OP_READLINK, NULL, NULL, NULL) == FALSE) {
1284 			nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov);
1285 			if (!e.error)
1286 				(void) xdr_free(xdr_COMPOUND4res_clnt,
1287 				    (caddr_t)&res);
1288 			goto recov_retry;
1289 		}
1290 	}
1291 
1292 	/*
1293 	 * If non-NFS4 pcol error and/or we weren't able to recover.
1294 	 */
1295 	if (e.error != 0) {
1296 		if (! recovery)
1297 			nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov);
1298 		sfh4_rele(&sfh);
1299 		return (e.error);
1300 	}
1301 
1302 	if (res.status) {
1303 		e.error = geterrno4(res.status);
1304 		(void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1305 		if (! recovery)
1306 			nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov);
1307 		sfh4_rele(&sfh);
1308 		return (e.error);
1309 	}
1310 
1311 	/* res.status == NFS4_OK */
1312 	ASSERT(res.status == NFS4_OK);
1313 
1314 	resop = &res.array[1];  /* readlink res */
1315 	lr_res = &resop->nfs_resop4_u.opreadlink;
1316 
1317 	/* treat symlink name as data */
1318 	*linktextp = utf8_to_str(&lr_res->link, &len, NULL);
1319 
1320 	if (! recovery)
1321 		nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov);
1322 	sfh4_rele(&sfh);
1323 	(void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1324 	return (0);
1325 }
1326 
1327 /*
1328  * Skip over consecutive slashes and "/./" in a pathname.
1329  */
1330 void
1331 pathname_skipslashdot(struct pathname *pnp)
1332 {
1333 	char *c1, *c2;
1334 
1335 	while (pnp->pn_pathlen > 0 && *pnp->pn_path == '/') {
1336 
1337 		c1 = pnp->pn_path + 1;
1338 		c2 = pnp->pn_path + 2;
1339 
1340 		if (*c1 == '.' && (*c2 == '/' || *c2 == '\0')) {
1341 			pnp->pn_path = pnp->pn_path + 2; /* skip "/." */
1342 			pnp->pn_pathlen = pnp->pn_pathlen - 2;
1343 		} else {
1344 			pnp->pn_path++;
1345 			pnp->pn_pathlen--;
1346 		}
1347 	}
1348 }
1349 
1350 /*
1351  * Resolve a symbolic link path. The symlink is in the nth component of
1352  * svp->sv_path and has an nfs4 file handle "fh".
1353  * Upon return, the sv_path will point to the new path that has the nth
1354  * component resolved to its symlink text.
1355  */
1356 int
1357 resolve_sympath(mntinfo4_t *mi, servinfo4_t *svp, int nth, nfs_fh4 *fh,
1358     cred_t *cr, int flags)
1359 {
1360 	char *oldpath;
1361 	char *symlink, *newpath;
1362 	struct pathname oldpn, newpn;
1363 	char component[MAXNAMELEN];
1364 	int i, addlen, error = 0;
1365 	int oldpathlen;
1366 
1367 	/* Get the symbolic link text over the wire. */
1368 	error = getlinktext_otw(mi, fh, &symlink, cr, flags);
1369 
1370 	if (error || symlink == NULL || strlen(symlink) == 0)
1371 		return (error);
1372 
1373 	/*
1374 	 * Compose the new pathname.
1375 	 * Note:
1376 	 *    - only the nth component is resolved for the pathname.
1377 	 *    - pathname.pn_pathlen does not count the ending null byte.
1378 	 */
1379 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
1380 	oldpath = svp->sv_path;
1381 	oldpathlen = svp->sv_pathlen;
1382 	if (error = pn_get(oldpath, UIO_SYSSPACE, &oldpn)) {
1383 		nfs_rw_exit(&svp->sv_lock);
1384 		kmem_free(symlink, strlen(symlink) + 1);
1385 		return (error);
1386 	}
1387 	nfs_rw_exit(&svp->sv_lock);
1388 	pn_alloc(&newpn);
1389 
1390 	/*
1391 	 * Skip over previous components from the oldpath so that the
1392 	 * oldpn.pn_path will point to the symlink component. Skip
1393 	 * leading slashes and "/./" (no OP_LOOKUP on ".") so that
1394 	 * pn_getcompnent can get the component.
1395 	 */
1396 	for (i = 1; i < nth; i++) {
1397 		pathname_skipslashdot(&oldpn);
1398 		error = pn_getcomponent(&oldpn, component);
1399 		if (error)
1400 			goto out;
1401 	}
1402 
1403 	/*
1404 	 * Copy the old path upto the component right before the symlink
1405 	 * if the symlink is not an absolute path.
1406 	 */
1407 	if (symlink[0] != '/') {
1408 		addlen = oldpn.pn_path - oldpn.pn_buf;
1409 		bcopy(oldpn.pn_buf, newpn.pn_path, addlen);
1410 		newpn.pn_pathlen += addlen;
1411 		newpn.pn_path += addlen;
1412 		newpn.pn_buf[newpn.pn_pathlen] = '/';
1413 		newpn.pn_pathlen++;
1414 		newpn.pn_path++;
1415 	}
1416 
1417 	/* copy the resolved symbolic link text */
1418 	addlen = strlen(symlink);
1419 	if (newpn.pn_pathlen + addlen >= newpn.pn_bufsize) {
1420 		error = ENAMETOOLONG;
1421 		goto out;
1422 	}
1423 	bcopy(symlink, newpn.pn_path, addlen);
1424 	newpn.pn_pathlen += addlen;
1425 	newpn.pn_path += addlen;
1426 
1427 	/*
1428 	 * Check if there is any remaining path after the symlink component.
1429 	 * First, skip the symlink component.
1430 	 */
1431 	pathname_skipslashdot(&oldpn);
1432 	if (error = pn_getcomponent(&oldpn, component))
1433 		goto out;
1434 
1435 	addlen = pn_pathleft(&oldpn); /* includes counting the slash */
1436 
1437 	/*
1438 	 * Copy the remaining path to the new pathname if there is any.
1439 	 */
1440 	if (addlen > 0) {
1441 		if (newpn.pn_pathlen + addlen >= newpn.pn_bufsize) {
1442 			error = ENAMETOOLONG;
1443 			goto out;
1444 		}
1445 		bcopy(oldpn.pn_path, newpn.pn_path, addlen);
1446 		newpn.pn_pathlen += addlen;
1447 	}
1448 	newpn.pn_buf[newpn.pn_pathlen] = '\0';
1449 
1450 	/* get the newpath and store it in the servinfo4_t */
1451 	newpath = kmem_alloc(newpn.pn_pathlen + 1, KM_SLEEP);
1452 	bcopy(newpn.pn_buf, newpath, newpn.pn_pathlen);
1453 	newpath[newpn.pn_pathlen] = '\0';
1454 
1455 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
1456 	svp->sv_path = newpath;
1457 	svp->sv_pathlen = strlen(newpath) + 1;
1458 	nfs_rw_exit(&svp->sv_lock);
1459 
1460 	kmem_free(oldpath, oldpathlen);
1461 out:
1462 	kmem_free(symlink, strlen(symlink) + 1);
1463 	pn_free(&newpn);
1464 	pn_free(&oldpn);
1465 
1466 	return (error);
1467 }
1468 
1469 /*
1470  * This routine updates servinfo4 structure with the new referred server
1471  * info.
1472  * nfsfsloc has the location related information
1473  * fsp has the hostname and pathname info.
1474  * new path = pathname from referral + part of orig pathname(based on nth).
1475  */
1476 static void
1477 update_servinfo4(servinfo4_t *svp, fs_location4 *fsp,
1478     struct nfs_fsl_info *nfsfsloc, char *orig_path, int nth)
1479 {
1480 	struct knetconfig *knconf, *svknconf;
1481 	struct netbuf *saddr;
1482 	sec_data_t	*secdata;
1483 	utf8string *host;
1484 	int i = 0, num_slashes = 0;
1485 	char *p, *spath, *op, *new_path;
1486 
1487 	/* Update knconf */
1488 	knconf = svp->sv_knconf;
1489 	free_knconf_contents(knconf);
1490 	bzero(knconf, sizeof (struct knetconfig));
1491 	svknconf = nfsfsloc->knconf;
1492 	knconf->knc_semantics = svknconf->knc_semantics;
1493 	knconf->knc_protofmly = kmem_zalloc(KNC_STRSIZE, KM_SLEEP);
1494 	knconf->knc_proto = kmem_zalloc(KNC_STRSIZE, KM_SLEEP);
1495 	knconf->knc_rdev = svknconf->knc_rdev;
1496 	bcopy(svknconf->knc_protofmly, knconf->knc_protofmly, KNC_STRSIZE);
1497 	bcopy(svknconf->knc_proto, knconf->knc_proto, KNC_STRSIZE);
1498 
1499 	/* Update server address */
1500 	saddr = &svp->sv_addr;
1501 	if (saddr->buf != NULL)
1502 		kmem_free(saddr->buf, saddr->maxlen);
1503 	saddr->buf  = kmem_alloc(nfsfsloc->addr->maxlen, KM_SLEEP);
1504 	saddr->len = nfsfsloc->addr->len;
1505 	saddr->maxlen = nfsfsloc->addr->maxlen;
1506 	bcopy(nfsfsloc->addr->buf, saddr->buf, nfsfsloc->addr->len);
1507 
1508 	/* Update server name */
1509 	host = fsp->server_val;
1510 	kmem_free(svp->sv_hostname, svp->sv_hostnamelen);
1511 	svp->sv_hostname = kmem_zalloc(host->utf8string_len + 1, KM_SLEEP);
1512 	bcopy(host->utf8string_val, svp->sv_hostname, host->utf8string_len);
1513 	svp->sv_hostname[host->utf8string_len] = '\0';
1514 	svp->sv_hostnamelen = host->utf8string_len + 1;
1515 
1516 	/*
1517 	 * Update server path.
1518 	 * We need to setup proper path here.
1519 	 * For ex., If we got a path name serv1:/rp/aaa/bbb
1520 	 * where aaa is a referral and points to serv2:/rpool/aa
1521 	 * we need to set the path to serv2:/rpool/aa/bbb
1522 	 * The first part of this below code generates /rpool/aa
1523 	 * and the second part appends /bbb to the server path.
1524 	 */
1525 	spath = p = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1526 	*p++ = '/';
1527 	for (i = 0; i < fsp->rootpath.pathname4_len; i++) {
1528 		component4 *comp;
1529 
1530 		comp = &fsp->rootpath.pathname4_val[i];
1531 		/* If no space, null the string and bail */
1532 		if ((p - spath) + comp->utf8string_len + 1 > MAXPATHLEN) {
1533 			p = spath + MAXPATHLEN - 1;
1534 			spath[0] = '\0';
1535 			break;
1536 		}
1537 		bcopy(comp->utf8string_val, p, comp->utf8string_len);
1538 		p += comp->utf8string_len;
1539 		*p++ = '/';
1540 	}
1541 	if (fsp->rootpath.pathname4_len != 0)
1542 		*(p - 1) = '\0';
1543 	else
1544 		*p = '\0';
1545 	p = spath;
1546 
1547 	new_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1548 	(void) strlcpy(new_path, p, MAXPATHLEN);
1549 	kmem_free(p, MAXPATHLEN);
1550 	i = strlen(new_path);
1551 
1552 	for (op = orig_path; *op; op++) {
1553 		if (*op == '/')
1554 			num_slashes++;
1555 		if (num_slashes == nth + 2) {
1556 			while (*op != '\0') {
1557 				new_path[i] = *op;
1558 				i++;
1559 				op++;
1560 			}
1561 			break;
1562 		}
1563 	}
1564 	new_path[i] = '\0';
1565 
1566 	kmem_free(svp->sv_path, svp->sv_pathlen);
1567 	svp->sv_pathlen = strlen(new_path) + 1;
1568 	svp->sv_path = kmem_alloc(svp->sv_pathlen, KM_SLEEP);
1569 	bcopy(new_path, svp->sv_path, svp->sv_pathlen);
1570 	kmem_free(new_path, MAXPATHLEN);
1571 
1572 	/*
1573 	 * All the security data is specific to old server.
1574 	 * Clean it up except secdata which deals with mount options.
1575 	 * We need to inherit that data. Copy secdata into our new servinfo4.
1576 	 */
1577 	if (svp->sv_dhsec) {
1578 		sec_clnt_freeinfo(svp->sv_dhsec);
1579 		svp->sv_dhsec = NULL;
1580 	}
1581 	if (svp->sv_save_secinfo &&
1582 	    svp->sv_save_secinfo != svp->sv_secinfo) {
1583 		secinfo_free(svp->sv_save_secinfo);
1584 		svp->sv_save_secinfo = NULL;
1585 	}
1586 	if (svp->sv_secinfo) {
1587 		secinfo_free(svp->sv_secinfo);
1588 		svp->sv_secinfo = NULL;
1589 	}
1590 	svp->sv_currsec = NULL;
1591 
1592 	secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP);
1593 	*secdata = *svp->sv_secdata;
1594 	secdata->data = NULL;
1595 	if (svp->sv_secdata) {
1596 		sec_clnt_freeinfo(svp->sv_secdata);
1597 		svp->sv_secdata = NULL;
1598 	}
1599 	svp->sv_secdata = secdata;
1600 }
1601 
1602 /*
1603  * Resolve a referral. The referral is in the n+1th component of
1604  * svp->sv_path and has a parent nfs4 file handle "fh".
1605  * Upon return, the sv_path will point to the new path that has referral
1606  * component resolved to its referred path and part of original path.
1607  * Hostname and other address information is also updated.
1608  */
1609 int
1610 resolve_referral(mntinfo4_t *mi, servinfo4_t *svp, cred_t *cr, int nth,
1611     nfs_fh4 *fh)
1612 {
1613 	nfs4_sharedfh_t	*sfh;
1614 	struct nfs_fsl_info nfsfsloc;
1615 	nfs4_ga_res_t garp;
1616 	COMPOUND4res_clnt callres;
1617 	fs_location4	*fsp;
1618 	char *nm, *orig_path;
1619 	int orig_pathlen = 0, ret = -1, index;
1620 
1621 	if (svp->sv_pathlen <= 0)
1622 		return (ret);
1623 
1624 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
1625 	orig_pathlen = svp->sv_pathlen;
1626 	orig_path = kmem_alloc(orig_pathlen, KM_SLEEP);
1627 	bcopy(svp->sv_path, orig_path, orig_pathlen);
1628 	nm = extract_referral_point(svp->sv_path, nth);
1629 	setup_newsvpath(svp, nth);
1630 	nfs_rw_exit(&svp->sv_lock);
1631 
1632 	sfh = sfh4_get(fh, mi);
1633 	index = nfs4_process_referral(mi, sfh, nm, cr,
1634 	    &garp, &callres, &nfsfsloc);
1635 	sfh4_rele(&sfh);
1636 	kmem_free(nm, MAXPATHLEN);
1637 	if (index < 0) {
1638 		kmem_free(orig_path, orig_pathlen);
1639 		return (index);
1640 	}
1641 
1642 	fsp =  &garp.n4g_ext_res->n4g_fslocations.locations_val[index];
1643 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
1644 	update_servinfo4(svp, fsp, &nfsfsloc, orig_path, nth);
1645 	nfs_rw_exit(&svp->sv_lock);
1646 
1647 	mutex_enter(&mi->mi_lock);
1648 	mi->mi_vfs_referral_loop_cnt++;
1649 	mutex_exit(&mi->mi_lock);
1650 
1651 	ret = 0;
1652 bad:
1653 	/* Free up XDR memory allocated in nfs4_process_referral() */
1654 	xdr_free(xdr_nfs_fsl_info, (char *)&nfsfsloc);
1655 	xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&callres);
1656 	kmem_free(orig_path, orig_pathlen);
1657 
1658 	return (ret);
1659 }
1660 
1661 /*
1662  * Get the root filehandle for the given filesystem and server, and update
1663  * svp.
1664  *
1665  * If NFS4_GETFH_NEEDSOP is set, then use nfs4_start_fop and nfs4_end_fop
1666  * to coordinate with recovery.  Otherwise, the caller is assumed to be
1667  * the recovery thread or have already done a start_fop.
1668  *
1669  * Errors are returned by the nfs4_error_t parameter.
1670  */
1671 static void
1672 nfs4getfh_otw(struct mntinfo4 *mi, servinfo4_t *svp, vtype_t *vtp,
1673     int flags, cred_t *cr, nfs4_error_t *ep)
1674 {
1675 	COMPOUND4args_clnt args;
1676 	COMPOUND4res_clnt res;
1677 	int doqueue = 1;
1678 	nfs_argop4 *argop;
1679 	nfs_resop4 *resop;
1680 	nfs4_ga_res_t *garp;
1681 	int num_argops;
1682 	lookup4_param_t lookuparg;
1683 	nfs_fh4 *tmpfhp;
1684 	nfs_fh4 *resfhp;
1685 	bool_t needrecov = FALSE;
1686 	nfs4_recov_state_t recov_state;
1687 	int llndx;
1688 	int nthcomp;
1689 	int recovery = !(flags & NFS4_GETFH_NEEDSOP);
1690 
1691 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
1692 	ASSERT(svp->sv_path != NULL);
1693 	if (svp->sv_path[0] == '\0') {
1694 		nfs_rw_exit(&svp->sv_lock);
1695 		nfs4_error_init(ep, EINVAL);
1696 		return;
1697 	}
1698 	nfs_rw_exit(&svp->sv_lock);
1699 
1700 	recov_state.rs_flags = 0;
1701 	recov_state.rs_num_retry_despite_err = 0;
1702 
1703 recov_retry:
1704 	if (mi->mi_vfs_referral_loop_cnt >= NFS4_REFERRAL_LOOP_MAX) {
1705 		DTRACE_PROBE3(nfs4clnt__debug__referral__loop, mntinfo4 *,
1706 		    mi, servinfo4_t *, svp, char *, "nfs4getfh_otw");
1707 		nfs4_error_init(ep, EINVAL);
1708 		return;
1709 	}
1710 	nfs4_error_zinit(ep);
1711 
1712 	if (!recovery) {
1713 		ep->error = nfs4_start_fop(mi, NULL, NULL, OH_MOUNT,
1714 		    &recov_state, NULL);
1715 
1716 		/*
1717 		 * If recovery has been started and this request as
1718 		 * initiated by a mount, then we must wait for recovery
1719 		 * to finish before proceeding, otherwise, the error
1720 		 * cleanup would remove data structures needed by the
1721 		 * recovery thread.
1722 		 */
1723 		if (ep->error) {
1724 			mutex_enter(&mi->mi_lock);
1725 			if (mi->mi_flags & MI4_MOUNTING) {
1726 				mi->mi_flags |= MI4_RECOV_FAIL;
1727 				mi->mi_error = EIO;
1728 
1729 				NFS4_DEBUG(nfs4_client_recov_debug, (CE_NOTE,
1730 				    "nfs4getfh_otw: waiting 4 recovery\n"));
1731 
1732 				while (mi->mi_flags & MI4_RECOV_ACTIV)
1733 					cv_wait(&mi->mi_failover_cv,
1734 					    &mi->mi_lock);
1735 			}
1736 			mutex_exit(&mi->mi_lock);
1737 			return;
1738 		}
1739 
1740 		/*
1741 		 * If the client does not specify a specific flavor to use
1742 		 * and has not gotten a secinfo list from the server yet,
1743 		 * retrieve the secinfo list from the server and use a
1744 		 * flavor from the list to mount.
1745 		 *
1746 		 * If fail to get the secinfo list from the server, then
1747 		 * try the default flavor.
1748 		 */
1749 		if ((svp->sv_flags & SV4_TRYSECDEFAULT) &&
1750 		    svp->sv_secinfo == NULL) {
1751 			(void) nfs4_secinfo_path(mi, cr, FALSE);
1752 		}
1753 	}
1754 
1755 	if (recovery)
1756 		args.ctag = TAG_REMAP_MOUNT;
1757 	else
1758 		args.ctag = TAG_MOUNT;
1759 
1760 	lookuparg.l4_getattrs = LKP4_ALL_ATTRIBUTES;
1761 	lookuparg.argsp = &args;
1762 	lookuparg.resp = &res;
1763 	lookuparg.header_len = 2;	/* Putrootfh, getfh */
1764 	lookuparg.trailer_len = 0;
1765 	lookuparg.ga_bits = FATTR4_FSINFO_MASK;
1766 	lookuparg.mi = mi;
1767 
1768 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
1769 	ASSERT(svp->sv_path != NULL);
1770 	llndx = nfs4lookup_setup(svp->sv_path, &lookuparg, 0);
1771 	nfs_rw_exit(&svp->sv_lock);
1772 
1773 	argop = args.array;
1774 	num_argops = args.array_len;
1775 
1776 	/* choose public or root filehandle */
1777 	if (flags & NFS4_GETFH_PUBLIC)
1778 		argop[0].argop = OP_PUTPUBFH;
1779 	else
1780 		argop[0].argop = OP_PUTROOTFH;
1781 
1782 	/* get fh */
1783 	argop[1].argop = OP_GETFH;
1784 
1785 	NFS4_DEBUG(nfs4_client_call_debug, (CE_NOTE,
1786 	    "nfs4getfh_otw: %s call, mi 0x%p",
1787 	    needrecov ? "recov" : "first", (void *)mi));
1788 
1789 	rfs4call(mi, &args, &res, cr, &doqueue, RFSCALL_SOFT, ep);
1790 
1791 	needrecov = nfs4_needs_recovery(ep, FALSE, mi->mi_vfsp);
1792 
1793 	if (needrecov) {
1794 		bool_t abort;
1795 
1796 		if (recovery) {
1797 			nfs4args_lookup_free(argop, num_argops);
1798 			kmem_free(argop,
1799 			    lookuparg.arglen * sizeof (nfs_argop4));
1800 			if (!ep->error)
1801 				(void) xdr_free(xdr_COMPOUND4res_clnt,
1802 				    (caddr_t)&res);
1803 			return;
1804 		}
1805 
1806 		NFS4_DEBUG(nfs4_client_recov_debug,
1807 		    (CE_NOTE, "nfs4getfh_otw: initiating recovery\n"));
1808 
1809 		abort = nfs4_start_recovery(ep, mi, NULL,
1810 		    NULL, NULL, NULL, OP_GETFH, NULL, NULL, NULL);
1811 		if (!ep->error) {
1812 			ep->error = geterrno4(res.status);
1813 			(void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1814 		}
1815 		nfs4args_lookup_free(argop, num_argops);
1816 		kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4));
1817 		nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state, needrecov);
1818 		/* have another go? */
1819 		if (abort == FALSE)
1820 			goto recov_retry;
1821 		return;
1822 	}
1823 
1824 	/*
1825 	 * No recovery, but check if error is set.
1826 	 */
1827 	if (ep->error)  {
1828 		nfs4args_lookup_free(argop, num_argops);
1829 		kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4));
1830 		if (!recovery)
1831 			nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state,
1832 			    needrecov);
1833 		return;
1834 	}
1835 
1836 is_link_err:
1837 
1838 	/* for non-recovery errors */
1839 	if (res.status && res.status != NFS4ERR_SYMLINK &&
1840 	    res.status != NFS4ERR_MOVED) {
1841 		if (!recovery) {
1842 			nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state,
1843 			    needrecov);
1844 		}
1845 		nfs4args_lookup_free(argop, num_argops);
1846 		kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4));
1847 		(void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1848 		return;
1849 	}
1850 
1851 	/*
1852 	 * If any intermediate component in the path is a symbolic link,
1853 	 * resolve the symlink, then try mount again using the new path.
1854 	 */
1855 	if (res.status == NFS4ERR_SYMLINK || res.status == NFS4ERR_MOVED) {
1856 		int where;
1857 
1858 		/*
1859 		 * Need to call nfs4_end_op before resolve_sympath to avoid
1860 		 * potential nfs4_start_op deadlock.
1861 		 */
1862 		if (!recovery)
1863 			nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state,
1864 			    needrecov);
1865 
1866 		/*
1867 		 * This must be from OP_LOOKUP failure. The (cfh) for this
1868 		 * OP_LOOKUP is a symlink node. Found out where the
1869 		 * OP_GETFH is for the (cfh) that is a symlink node.
1870 		 *
1871 		 * Example:
1872 		 * (mount) PUTROOTFH, GETFH, LOOKUP comp1, GETFH, GETATTR,
1873 		 * LOOKUP comp2, GETFH, GETATTR, LOOKUP comp3, GETFH, GETATTR
1874 		 *
1875 		 * LOOKUP comp3 fails with SYMLINK because comp2 is a symlink.
1876 		 * In this case, where = 7, nthcomp = 2.
1877 		 */
1878 		where = res.array_len - 2;
1879 		ASSERT(where > 0);
1880 
1881 		if (res.status == NFS4ERR_SYMLINK) {
1882 
1883 			resop = &res.array[where - 1];
1884 			ASSERT(resop->resop == OP_GETFH);
1885 			tmpfhp = &resop->nfs_resop4_u.opgetfh.object;
1886 			nthcomp = res.array_len/3 - 1;
1887 			ep->error = resolve_sympath(mi, svp, nthcomp,
1888 			    tmpfhp, cr, flags);
1889 
1890 		} else if (res.status == NFS4ERR_MOVED) {
1891 
1892 			resop = &res.array[where - 2];
1893 			ASSERT(resop->resop == OP_GETFH);
1894 			tmpfhp = &resop->nfs_resop4_u.opgetfh.object;
1895 			nthcomp = res.array_len/3 - 1;
1896 			ep->error = resolve_referral(mi, svp, cr, nthcomp,
1897 			    tmpfhp);
1898 		}
1899 
1900 		nfs4args_lookup_free(argop, num_argops);
1901 		kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4));
1902 		(void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1903 
1904 		if (ep->error)
1905 			return;
1906 
1907 		goto recov_retry;
1908 	}
1909 
1910 	/* getfh */
1911 	resop = &res.array[res.array_len - 2];
1912 	ASSERT(resop->resop == OP_GETFH);
1913 	resfhp = &resop->nfs_resop4_u.opgetfh.object;
1914 
1915 	/* getattr fsinfo res */
1916 	resop++;
1917 	garp = &resop->nfs_resop4_u.opgetattr.ga_res;
1918 
1919 	*vtp = garp->n4g_va.va_type;
1920 
1921 	mi->mi_fh_expire_type = garp->n4g_ext_res->n4g_fet;
1922 
1923 	mutex_enter(&mi->mi_lock);
1924 	if (garp->n4g_ext_res->n4g_pc4.pc4_link_support)
1925 		mi->mi_flags |= MI4_LINK;
1926 	if (garp->n4g_ext_res->n4g_pc4.pc4_symlink_support)
1927 		mi->mi_flags |= MI4_SYMLINK;
1928 	if (garp->n4g_ext_res->n4g_suppattrs & FATTR4_ACL_MASK)
1929 		mi->mi_flags |= MI4_ACL;
1930 	mutex_exit(&mi->mi_lock);
1931 
1932 	if (garp->n4g_ext_res->n4g_maxread == 0)
1933 		mi->mi_tsize =
1934 		    MIN(MAXBSIZE, mi->mi_tsize);
1935 	else
1936 		mi->mi_tsize =
1937 		    MIN(garp->n4g_ext_res->n4g_maxread,
1938 		    mi->mi_tsize);
1939 
1940 	if (garp->n4g_ext_res->n4g_maxwrite == 0)
1941 		mi->mi_stsize =
1942 		    MIN(MAXBSIZE, mi->mi_stsize);
1943 	else
1944 		mi->mi_stsize =
1945 		    MIN(garp->n4g_ext_res->n4g_maxwrite,
1946 		    mi->mi_stsize);
1947 
1948 	if (garp->n4g_ext_res->n4g_maxfilesize != 0)
1949 		mi->mi_maxfilesize =
1950 		    MIN(garp->n4g_ext_res->n4g_maxfilesize,
1951 		    mi->mi_maxfilesize);
1952 
1953 	/*
1954 	 * If the final component is a a symbolic link, resolve the symlink,
1955 	 * then try mount again using the new path.
1956 	 *
1957 	 * Assume no symbolic link for root filesysm "/".
1958 	 */
1959 	if (*vtp == VLNK) {
1960 		/*
1961 		 * nthcomp is the total result length minus
1962 		 * the 1st 2 OPs (PUTROOTFH, GETFH),
1963 		 * then divided by 3 (LOOKUP,GETFH,GETATTR)
1964 		 *
1965 		 * e.g. PUTROOTFH GETFH LOOKUP 1st-comp GETFH GETATTR
1966 		 *	LOOKUP 2nd-comp GETFH GETATTR
1967 		 *
1968 		 *	(8 - 2)/3 = 2
1969 		 */
1970 		nthcomp = (res.array_len - 2)/3;
1971 
1972 		/*
1973 		 * Need to call nfs4_end_op before resolve_sympath to avoid
1974 		 * potential nfs4_start_op deadlock. See RFE 4777612.
1975 		 */
1976 		if (!recovery)
1977 			nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state,
1978 			    needrecov);
1979 
1980 		ep->error = resolve_sympath(mi, svp, nthcomp, resfhp, cr,
1981 		    flags);
1982 
1983 		nfs4args_lookup_free(argop, num_argops);
1984 		kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4));
1985 		(void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1986 
1987 		if (ep->error)
1988 			return;
1989 
1990 		goto recov_retry;
1991 	}
1992 
1993 	/*
1994 	 * We need to figure out where in the compound the getfh
1995 	 * for the parent directory is. If the object to be mounted is
1996 	 * the root, then there is no lookup at all:
1997 	 * PUTROOTFH, GETFH.
1998 	 * If the object to be mounted is in the root, then the compound is:
1999 	 * PUTROOTFH, GETFH, LOOKUP, GETFH, GETATTR.
2000 	 * In either of these cases, the index of the GETFH is 1.
2001 	 * If it is not at the root, then it's something like:
2002 	 * PUTROOTFH, GETFH, LOOKUP, GETFH, GETATTR,
2003 	 * LOOKUP, GETFH, GETATTR
2004 	 * In this case, the index is llndx (last lookup index) - 2.
2005 	 */
2006 	if (llndx == -1 || llndx == 2)
2007 		resop = &res.array[1];
2008 	else {
2009 		ASSERT(llndx > 2);
2010 		resop = &res.array[llndx-2];
2011 	}
2012 
2013 	ASSERT(resop->resop == OP_GETFH);
2014 	tmpfhp = &resop->nfs_resop4_u.opgetfh.object;
2015 
2016 	/* save the filehandles for the replica */
2017 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2018 	ASSERT(tmpfhp->nfs_fh4_len <= NFS4_FHSIZE);
2019 	svp->sv_pfhandle.fh_len = tmpfhp->nfs_fh4_len;
2020 	bcopy(tmpfhp->nfs_fh4_val, svp->sv_pfhandle.fh_buf,
2021 	    tmpfhp->nfs_fh4_len);
2022 	ASSERT(resfhp->nfs_fh4_len <= NFS4_FHSIZE);
2023 	svp->sv_fhandle.fh_len = resfhp->nfs_fh4_len;
2024 	bcopy(resfhp->nfs_fh4_val, svp->sv_fhandle.fh_buf, resfhp->nfs_fh4_len);
2025 
2026 	/* initialize fsid and supp_attrs for server fs */
2027 	svp->sv_fsid = garp->n4g_fsid;
2028 	svp->sv_supp_attrs =
2029 	    garp->n4g_ext_res->n4g_suppattrs | FATTR4_MANDATTR_MASK;
2030 
2031 	nfs_rw_exit(&svp->sv_lock);
2032 	nfs4args_lookup_free(argop, num_argops);
2033 	kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4));
2034 	(void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
2035 	if (!recovery)
2036 		nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state, needrecov);
2037 }
2038 
2039 /*
2040  * Save a copy of Servinfo4_t structure.
2041  * We might need when there is a failure in getting file handle
2042  * in case of a referral to replace servinfo4 struct and try again.
2043  */
2044 static struct servinfo4 *
2045 copy_svp(servinfo4_t *nsvp)
2046 {
2047 	servinfo4_t *svp = NULL;
2048 	struct knetconfig *sknconf, *tknconf;
2049 	struct netbuf *saddr, *taddr;
2050 
2051 	svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
2052 	nfs_rw_init(&svp->sv_lock, NULL, RW_DEFAULT, NULL);
2053 	svp->sv_flags = nsvp->sv_flags;
2054 	svp->sv_fsid = nsvp->sv_fsid;
2055 	svp->sv_hostnamelen = nsvp->sv_hostnamelen;
2056 	svp->sv_pathlen = nsvp->sv_pathlen;
2057 	svp->sv_supp_attrs = nsvp->sv_supp_attrs;
2058 
2059 	svp->sv_path = kmem_alloc(svp->sv_pathlen, KM_SLEEP);
2060 	svp->sv_hostname = kmem_alloc(svp->sv_hostnamelen, KM_SLEEP);
2061 	bcopy(nsvp->sv_hostname, svp->sv_hostname, svp->sv_hostnamelen);
2062 	bcopy(nsvp->sv_path, svp->sv_path, svp->sv_pathlen);
2063 
2064 	saddr = &nsvp->sv_addr;
2065 	taddr = &svp->sv_addr;
2066 	taddr->maxlen = saddr->maxlen;
2067 	taddr->len = saddr->len;
2068 	if (saddr->len > 0) {
2069 		taddr->buf = kmem_zalloc(saddr->maxlen, KM_SLEEP);
2070 		bcopy(saddr->buf, taddr->buf, saddr->len);
2071 	}
2072 
2073 	svp->sv_knconf = kmem_zalloc(sizeof (struct knetconfig), KM_SLEEP);
2074 	sknconf = nsvp->sv_knconf;
2075 	tknconf = svp->sv_knconf;
2076 	tknconf->knc_semantics = sknconf->knc_semantics;
2077 	tknconf->knc_rdev = sknconf->knc_rdev;
2078 	if (sknconf->knc_proto != NULL) {
2079 		tknconf->knc_proto = kmem_zalloc(KNC_STRSIZE, KM_SLEEP);
2080 		bcopy(sknconf->knc_proto, (char *)tknconf->knc_proto,
2081 		    KNC_STRSIZE);
2082 	}
2083 	if (sknconf->knc_protofmly != NULL) {
2084 		tknconf->knc_protofmly = kmem_zalloc(KNC_STRSIZE, KM_SLEEP);
2085 		bcopy(sknconf->knc_protofmly, (char *)tknconf->knc_protofmly,
2086 		    KNC_STRSIZE);
2087 	}
2088 
2089 	if (nsvp->sv_origknconf != NULL) {
2090 		svp->sv_origknconf = kmem_zalloc(sizeof (struct knetconfig),
2091 		    KM_SLEEP);
2092 		sknconf = nsvp->sv_origknconf;
2093 		tknconf = svp->sv_origknconf;
2094 		tknconf->knc_semantics = sknconf->knc_semantics;
2095 		tknconf->knc_rdev = sknconf->knc_rdev;
2096 		if (sknconf->knc_proto != NULL) {
2097 			tknconf->knc_proto = kmem_zalloc(KNC_STRSIZE, KM_SLEEP);
2098 			bcopy(sknconf->knc_proto, (char *)tknconf->knc_proto,
2099 			    KNC_STRSIZE);
2100 		}
2101 		if (sknconf->knc_protofmly != NULL) {
2102 			tknconf->knc_protofmly = kmem_zalloc(KNC_STRSIZE,
2103 			    KM_SLEEP);
2104 			bcopy(sknconf->knc_protofmly,
2105 			    (char *)tknconf->knc_protofmly, KNC_STRSIZE);
2106 		}
2107 	}
2108 
2109 	svp->sv_secdata = copy_sec_data(nsvp->sv_secdata);
2110 	svp->sv_dhsec = copy_sec_data(svp->sv_dhsec);
2111 	/*
2112 	 * Rest of the security information is not copied as they are built
2113 	 * with the information available from secdata and dhsec.
2114 	 */
2115 	svp->sv_next = NULL;
2116 
2117 	return (svp);
2118 }
2119 
2120 servinfo4_t *
2121 restore_svp(mntinfo4_t *mi, servinfo4_t *svp, servinfo4_t *origsvp)
2122 {
2123 	servinfo4_t *srvnext, *tmpsrv;
2124 
2125 	if (strcmp(svp->sv_hostname, origsvp->sv_hostname) != 0) {
2126 		/*
2127 		 * Since the hostname changed, we must be dealing
2128 		 * with a referral, and the lookup failed.  We will
2129 		 * restore the whole servinfo4_t to what it was before.
2130 		 */
2131 		srvnext = svp->sv_next;
2132 		svp->sv_next = NULL;
2133 		tmpsrv = copy_svp(origsvp);
2134 		sv4_free(svp);
2135 		svp = tmpsrv;
2136 		svp->sv_next = srvnext;
2137 		mutex_enter(&mi->mi_lock);
2138 		mi->mi_servers = svp;
2139 		mi->mi_curr_serv = svp;
2140 		mutex_exit(&mi->mi_lock);
2141 
2142 	} else if (origsvp->sv_pathlen != svp->sv_pathlen) {
2143 
2144 		/*
2145 		 * For symlink case: restore original path because
2146 		 * it might have contained symlinks that were
2147 		 * expanded by nfsgetfh_otw before the failure occurred.
2148 		 */
2149 		(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
2150 		kmem_free(svp->sv_path, svp->sv_pathlen);
2151 		svp->sv_path =
2152 		    kmem_alloc(origsvp->sv_pathlen, KM_SLEEP);
2153 		svp->sv_pathlen = origsvp->sv_pathlen;
2154 		bcopy(origsvp->sv_path, svp->sv_path,
2155 		    origsvp->sv_pathlen);
2156 		nfs_rw_exit(&svp->sv_lock);
2157 	}
2158 	return (svp);
2159 }
2160 
2161 static ushort_t nfs4_max_threads = 8;	/* max number of active async threads */
2162 uint_t nfs4_bsize = 32 * 1024;	/* client `block' size */
2163 static uint_t nfs4_async_clusters = 1;	/* # of reqs from each async queue */
2164 static uint_t nfs4_cots_timeo = NFS_COTS_TIMEO;
2165 
2166 /*
2167  * Remap the root filehandle for the given filesystem.
2168  *
2169  * results returned via the nfs4_error_t parameter.
2170  */
2171 void
2172 nfs4_remap_root(mntinfo4_t *mi, nfs4_error_t *ep, int flags)
2173 {
2174 	struct servinfo4 *svp, *origsvp;
2175 	vtype_t vtype;
2176 	nfs_fh4 rootfh;
2177 	int getfh_flags;
2178 	int num_retry;
2179 
2180 	mutex_enter(&mi->mi_lock);
2181 
2182 remap_retry:
2183 	svp = mi->mi_curr_serv;
2184 	getfh_flags =
2185 	    (flags & NFS4_REMAP_NEEDSOP) ? NFS4_GETFH_NEEDSOP : 0;
2186 	getfh_flags |=
2187 	    (mi->mi_flags & MI4_PUBLIC) ? NFS4_GETFH_PUBLIC : 0;
2188 	mutex_exit(&mi->mi_lock);
2189 
2190 	/*
2191 	 * Just in case server path being mounted contains
2192 	 * symlinks and fails w/STALE, save the initial sv_path
2193 	 * so we can redrive the initial mount compound with the
2194 	 * initial sv_path -- not a symlink-expanded version.
2195 	 *
2196 	 * This could only happen if a symlink was expanded
2197 	 * and the expanded mount compound failed stale.  Because
2198 	 * it could be the case that the symlink was removed at
2199 	 * the server (and replaced with another symlink/dir,
2200 	 * we need to use the initial sv_path when attempting
2201 	 * to re-lookup everything and recover.
2202 	 */
2203 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
2204 	origsvp = copy_svp(svp);
2205 	nfs_rw_exit(&svp->sv_lock);
2206 
2207 	num_retry = nfs4_max_mount_retry;
2208 
2209 	do {
2210 		/*
2211 		 * Get the root fh from the server.  Retry nfs4_max_mount_retry
2212 		 * (2) times if it fails with STALE since the recovery
2213 		 * infrastructure doesn't do STALE recovery for components
2214 		 * of the server path to the object being mounted.
2215 		 */
2216 		nfs4getfh_otw(mi, svp, &vtype, getfh_flags, CRED(), ep);
2217 
2218 		if (ep->error == 0 && ep->stat == NFS4_OK)
2219 			break;
2220 
2221 		/*
2222 		 * For some reason, the mount compound failed.  Before
2223 		 * retrying, we need to restore original conditions.
2224 		 */
2225 		svp = restore_svp(mi, svp, origsvp);
2226 
2227 	} while (num_retry-- > 0);
2228 
2229 	sv4_free(origsvp);
2230 
2231 	if (ep->error != 0 || ep->stat != 0) {
2232 		return;
2233 	}
2234 
2235 	if (vtype != VNON && vtype != mi->mi_type) {
2236 		/* shouldn't happen */
2237 		zcmn_err(mi->mi_zone->zone_id, CE_WARN,
2238 		    "nfs4_remap_root: server root vnode type (%d) doesn't "
2239 		    "match mount info (%d)", vtype, mi->mi_type);
2240 	}
2241 
2242 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
2243 	rootfh.nfs_fh4_val = svp->sv_fhandle.fh_buf;
2244 	rootfh.nfs_fh4_len = svp->sv_fhandle.fh_len;
2245 	nfs_rw_exit(&svp->sv_lock);
2246 	sfh4_update(mi->mi_rootfh, &rootfh);
2247 
2248 	/*
2249 	 * It's possible that recovery took place on the filesystem
2250 	 * and the server has been updated between the time we did
2251 	 * the nfs4getfh_otw and now. Re-drive the otw operation
2252 	 * to make sure we have a good fh.
2253 	 */
2254 	mutex_enter(&mi->mi_lock);
2255 	if (mi->mi_curr_serv != svp)
2256 		goto remap_retry;
2257 
2258 	mutex_exit(&mi->mi_lock);
2259 }
2260 
2261 static int
2262 nfs4rootvp(vnode_t **rtvpp, vfs_t *vfsp, struct servinfo4 *svp_head,
2263     int flags, cred_t *cr, zone_t *zone)
2264 {
2265 	vnode_t *rtvp = NULL;
2266 	mntinfo4_t *mi;
2267 	dev_t nfs_dev;
2268 	int error = 0;
2269 	rnode4_t *rp;
2270 	int i, len;
2271 	struct vattr va;
2272 	vtype_t vtype = VNON;
2273 	vtype_t tmp_vtype = VNON;
2274 	struct servinfo4 *firstsvp = NULL, *svp = svp_head;
2275 	nfs4_oo_hash_bucket_t *bucketp;
2276 	nfs_fh4 fh;
2277 	char *droptext = "";
2278 	struct nfs_stats *nfsstatsp;
2279 	nfs4_fname_t *mfname;
2280 	nfs4_error_t e;
2281 	int num_retry, removed;
2282 	cred_t *lcr = NULL, *tcr = cr;
2283 	struct servinfo4 *origsvp;
2284 	char *resource;
2285 
2286 	nfsstatsp = zone_getspecific(nfsstat_zone_key, nfs_zone());
2287 	ASSERT(nfsstatsp != NULL);
2288 
2289 	ASSERT(nfs_zone() == zone);
2290 	ASSERT(crgetref(cr));
2291 
2292 	/*
2293 	 * Create a mount record and link it to the vfs struct.
2294 	 */
2295 	mi = kmem_zalloc(sizeof (*mi), KM_SLEEP);
2296 	mutex_init(&mi->mi_lock, NULL, MUTEX_DEFAULT, NULL);
2297 	nfs_rw_init(&mi->mi_recovlock, NULL, RW_DEFAULT, NULL);
2298 	nfs_rw_init(&mi->mi_rename_lock, NULL, RW_DEFAULT, NULL);
2299 	nfs_rw_init(&mi->mi_fh_lock, NULL, RW_DEFAULT, NULL);
2300 
2301 	if (!(flags & NFSMNT_SOFT))
2302 		mi->mi_flags |= MI4_HARD;
2303 	if ((flags & NFSMNT_NOPRINT))
2304 		mi->mi_flags |= MI4_NOPRINT;
2305 	if (flags & NFSMNT_INT)
2306 		mi->mi_flags |= MI4_INT;
2307 	if (flags & NFSMNT_PUBLIC)
2308 		mi->mi_flags |= MI4_PUBLIC;
2309 	if (flags & NFSMNT_MIRRORMOUNT)
2310 		mi->mi_flags |= MI4_MIRRORMOUNT;
2311 	if (flags & NFSMNT_REFERRAL)
2312 		mi->mi_flags |= MI4_REFERRAL;
2313 	mi->mi_retrans = NFS_RETRIES;
2314 	if (svp->sv_knconf->knc_semantics == NC_TPI_COTS_ORD ||
2315 	    svp->sv_knconf->knc_semantics == NC_TPI_COTS)
2316 		mi->mi_timeo = nfs4_cots_timeo;
2317 	else
2318 		mi->mi_timeo = NFS_TIMEO;
2319 	mi->mi_prog = NFS_PROGRAM;
2320 	mi->mi_vers = NFS_V4;
2321 	mi->mi_rfsnames = rfsnames_v4;
2322 	mi->mi_reqs = nfsstatsp->nfs_stats_v4.rfsreqcnt_ptr;
2323 	cv_init(&mi->mi_failover_cv, NULL, CV_DEFAULT, NULL);
2324 	mi->mi_servers = svp;
2325 	mi->mi_curr_serv = svp;
2326 	mi->mi_acregmin = SEC2HR(ACREGMIN);
2327 	mi->mi_acregmax = SEC2HR(ACREGMAX);
2328 	mi->mi_acdirmin = SEC2HR(ACDIRMIN);
2329 	mi->mi_acdirmax = SEC2HR(ACDIRMAX);
2330 	mi->mi_fh_expire_type = FH4_PERSISTENT;
2331 	mi->mi_clientid_next = NULL;
2332 	mi->mi_clientid_prev = NULL;
2333 	mi->mi_srv = NULL;
2334 	mi->mi_grace_wait = 0;
2335 	mi->mi_error = 0;
2336 	mi->mi_srvsettime = 0;
2337 	mi->mi_srvset_cnt = 0;
2338 
2339 	mi->mi_count = 1;
2340 
2341 	mi->mi_tsize = nfs4_tsize(svp->sv_knconf);
2342 	mi->mi_stsize = mi->mi_tsize;
2343 
2344 	if (flags & NFSMNT_DIRECTIO)
2345 		mi->mi_flags |= MI4_DIRECTIO;
2346 
2347 	mi->mi_flags |= MI4_MOUNTING;
2348 
2349 	/*
2350 	 * Make a vfs struct for nfs.  We do this here instead of below
2351 	 * because rtvp needs a vfs before we can do a getattr on it.
2352 	 *
2353 	 * Assign a unique device id to the mount
2354 	 */
2355 	mutex_enter(&nfs_minor_lock);
2356 	do {
2357 		nfs_minor = (nfs_minor + 1) & MAXMIN32;
2358 		nfs_dev = makedevice(nfs_major, nfs_minor);
2359 	} while (vfs_devismounted(nfs_dev));
2360 	mutex_exit(&nfs_minor_lock);
2361 
2362 	vfsp->vfs_dev = nfs_dev;
2363 	vfs_make_fsid(&vfsp->vfs_fsid, nfs_dev, nfs4fstyp);
2364 	vfsp->vfs_data = (caddr_t)mi;
2365 	vfsp->vfs_fstype = nfsfstyp;
2366 	vfsp->vfs_bsize = nfs4_bsize;
2367 
2368 	/*
2369 	 * Initialize fields used to support async putpage operations.
2370 	 */
2371 	for (i = 0; i < NFS4_ASYNC_TYPES; i++)
2372 		mi->mi_async_clusters[i] = nfs4_async_clusters;
2373 	mi->mi_async_init_clusters = nfs4_async_clusters;
2374 	mi->mi_async_curr[NFS4_ASYNC_QUEUE] =
2375 	    mi->mi_async_curr[NFS4_ASYNC_PGOPS_QUEUE] = &mi->mi_async_reqs[0];
2376 	mi->mi_max_threads = nfs4_max_threads;
2377 	mutex_init(&mi->mi_async_lock, NULL, MUTEX_DEFAULT, NULL);
2378 	cv_init(&mi->mi_async_reqs_cv, NULL, CV_DEFAULT, NULL);
2379 	cv_init(&mi->mi_async_work_cv[NFS4_ASYNC_QUEUE], NULL, CV_DEFAULT,
2380 	    NULL);
2381 	cv_init(&mi->mi_async_work_cv[NFS4_ASYNC_PGOPS_QUEUE], NULL,
2382 	    CV_DEFAULT, NULL);
2383 	cv_init(&mi->mi_async_cv, NULL, CV_DEFAULT, NULL);
2384 	cv_init(&mi->mi_inact_req_cv, NULL, CV_DEFAULT, NULL);
2385 
2386 	mi->mi_vfsp = vfsp;
2387 	mi->mi_zone = zone;
2388 	zone_init_ref(&mi->mi_zone_ref);
2389 	zone_hold_ref(zone, &mi->mi_zone_ref, ZONE_REF_NFSV4);
2390 	nfs4_mi_zonelist_add(mi);
2391 
2392 	/*
2393 	 * Initialize the <open owner/cred> hash table.
2394 	 */
2395 	for (i = 0; i < NFS4_NUM_OO_BUCKETS; i++) {
2396 		bucketp = &(mi->mi_oo_list[i]);
2397 		mutex_init(&bucketp->b_lock, NULL, MUTEX_DEFAULT, NULL);
2398 		list_create(&bucketp->b_oo_hash_list,
2399 		    sizeof (nfs4_open_owner_t),
2400 		    offsetof(nfs4_open_owner_t, oo_hash_node));
2401 	}
2402 
2403 	/*
2404 	 * Initialize the freed open owner list.
2405 	 */
2406 	mi->mi_foo_num = 0;
2407 	mi->mi_foo_max = NFS4_NUM_FREED_OPEN_OWNERS;
2408 	list_create(&mi->mi_foo_list, sizeof (nfs4_open_owner_t),
2409 	    offsetof(nfs4_open_owner_t, oo_foo_node));
2410 
2411 	list_create(&mi->mi_lost_state, sizeof (nfs4_lost_rqst_t),
2412 	    offsetof(nfs4_lost_rqst_t, lr_node));
2413 
2414 	list_create(&mi->mi_bseqid_list, sizeof (nfs4_bseqid_entry_t),
2415 	    offsetof(nfs4_bseqid_entry_t, bs_node));
2416 
2417 	/*
2418 	 * Initialize the msg buffer.
2419 	 */
2420 	list_create(&mi->mi_msg_list, sizeof (nfs4_debug_msg_t),
2421 	    offsetof(nfs4_debug_msg_t, msg_node));
2422 	mi->mi_msg_count = 0;
2423 	mutex_init(&mi->mi_msg_list_lock, NULL, MUTEX_DEFAULT, NULL);
2424 
2425 	/*
2426 	 * Initialize kstats
2427 	 */
2428 	nfs4_mnt_kstat_init(vfsp);
2429 
2430 	/*
2431 	 * Initialize the shared filehandle pool.
2432 	 */
2433 	sfh4_createtab(&mi->mi_filehandles);
2434 
2435 	/*
2436 	 * Save server path we're attempting to mount.
2437 	 */
2438 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2439 	origsvp = copy_svp(svp);
2440 	nfs_rw_exit(&svp->sv_lock);
2441 
2442 	/*
2443 	 * Make the GETFH call to get root fh for each replica.
2444 	 */
2445 	if (svp_head->sv_next)
2446 		droptext = ", dropping replica";
2447 
2448 	/*
2449 	 * If the uid is set then set the creds for secure mounts
2450 	 * by proxy processes such as automountd.
2451 	 */
2452 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
2453 	if (svp->sv_secdata->uid != 0 &&
2454 	    svp->sv_secdata->rpcflavor == RPCSEC_GSS) {
2455 		lcr = crdup(cr);
2456 		(void) crsetugid(lcr, svp->sv_secdata->uid, crgetgid(cr));
2457 		tcr = lcr;
2458 	}
2459 	nfs_rw_exit(&svp->sv_lock);
2460 	for (svp = svp_head; svp; svp = svp->sv_next) {
2461 		if (nfs4_chkdup_servinfo4(svp_head, svp)) {
2462 			nfs_cmn_err(error, CE_WARN,
2463 			    VERS_MSG "Host %s is a duplicate%s",
2464 			    svp->sv_hostname, droptext);
2465 			(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2466 			svp->sv_flags |= SV4_NOTINUSE;
2467 			nfs_rw_exit(&svp->sv_lock);
2468 			continue;
2469 		}
2470 		mi->mi_curr_serv = svp;
2471 
2472 		/*
2473 		 * Just in case server path being mounted contains
2474 		 * symlinks and fails w/STALE, save the initial sv_path
2475 		 * so we can redrive the initial mount compound with the
2476 		 * initial sv_path -- not a symlink-expanded version.
2477 		 *
2478 		 * This could only happen if a symlink was expanded
2479 		 * and the expanded mount compound failed stale.  Because
2480 		 * it could be the case that the symlink was removed at
2481 		 * the server (and replaced with another symlink/dir,
2482 		 * we need to use the initial sv_path when attempting
2483 		 * to re-lookup everything and recover.
2484 		 *
2485 		 * Other mount errors should evenutally be handled here also
2486 		 * (NFS4ERR_DELAY, NFS4ERR_RESOURCE).  For now, all mount
2487 		 * failures will result in mount being redriven a few times.
2488 		 */
2489 		num_retry = nfs4_max_mount_retry;
2490 		do {
2491 			nfs4getfh_otw(mi, svp, &tmp_vtype,
2492 			    ((flags & NFSMNT_PUBLIC) ? NFS4_GETFH_PUBLIC : 0) |
2493 			    NFS4_GETFH_NEEDSOP, tcr, &e);
2494 
2495 			if (e.error == 0 && e.stat == NFS4_OK)
2496 				break;
2497 
2498 			/*
2499 			 * For some reason, the mount compound failed.  Before
2500 			 * retrying, we need to restore original conditions.
2501 			 */
2502 			svp = restore_svp(mi, svp, origsvp);
2503 			svp_head = svp;
2504 
2505 		} while (num_retry-- > 0);
2506 		error = e.error ? e.error : geterrno4(e.stat);
2507 		if (error) {
2508 			nfs_cmn_err(error, CE_WARN,
2509 			    VERS_MSG "initial call to %s failed%s: %m",
2510 			    svp->sv_hostname, droptext);
2511 			(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2512 			svp->sv_flags |= SV4_NOTINUSE;
2513 			nfs_rw_exit(&svp->sv_lock);
2514 			mi->mi_flags &= ~MI4_RECOV_FAIL;
2515 			mi->mi_error = 0;
2516 			continue;
2517 		}
2518 
2519 		if (tmp_vtype == VBAD) {
2520 			zcmn_err(mi->mi_zone->zone_id, CE_WARN,
2521 			    VERS_MSG "%s returned a bad file type for "
2522 			    "root%s", svp->sv_hostname, droptext);
2523 			(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2524 			svp->sv_flags |= SV4_NOTINUSE;
2525 			nfs_rw_exit(&svp->sv_lock);
2526 			continue;
2527 		}
2528 
2529 		if (vtype == VNON) {
2530 			vtype = tmp_vtype;
2531 		} else if (vtype != tmp_vtype) {
2532 			zcmn_err(mi->mi_zone->zone_id, CE_WARN,
2533 			    VERS_MSG "%s returned a different file type "
2534 			    "for root%s", svp->sv_hostname, droptext);
2535 			(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2536 			svp->sv_flags |= SV4_NOTINUSE;
2537 			nfs_rw_exit(&svp->sv_lock);
2538 			continue;
2539 		}
2540 		if (firstsvp == NULL)
2541 			firstsvp = svp;
2542 	}
2543 
2544 	if (firstsvp == NULL) {
2545 		if (error == 0)
2546 			error = ENOENT;
2547 		goto bad;
2548 	}
2549 
2550 	mi->mi_curr_serv = svp = firstsvp;
2551 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
2552 	ASSERT((mi->mi_curr_serv->sv_flags & SV4_NOTINUSE) == 0);
2553 	fh.nfs_fh4_len = svp->sv_fhandle.fh_len;
2554 	fh.nfs_fh4_val = svp->sv_fhandle.fh_buf;
2555 	mi->mi_rootfh = sfh4_get(&fh, mi);
2556 	fh.nfs_fh4_len = svp->sv_pfhandle.fh_len;
2557 	fh.nfs_fh4_val = svp->sv_pfhandle.fh_buf;
2558 	mi->mi_srvparentfh = sfh4_get(&fh, mi);
2559 	nfs_rw_exit(&svp->sv_lock);
2560 
2561 	/*
2562 	 * Get the fname for filesystem root.
2563 	 */
2564 	mi->mi_fname = fn_get(NULL, ".", mi->mi_rootfh);
2565 	mfname = mi->mi_fname;
2566 	fn_hold(mfname);
2567 
2568 	/*
2569 	 * Make the root vnode without attributes.
2570 	 */
2571 	rtvp = makenfs4node_by_fh(mi->mi_rootfh, NULL,
2572 	    &mfname, NULL, mi, cr, gethrtime());
2573 	rtvp->v_type = vtype;
2574 
2575 	mi->mi_curread = mi->mi_tsize;
2576 	mi->mi_curwrite = mi->mi_stsize;
2577 
2578 	/*
2579 	 * Start the manager thread responsible for handling async worker
2580 	 * threads.
2581 	 */
2582 	MI4_HOLD(mi);
2583 	VFS_HOLD(vfsp);	/* add reference for thread */
2584 	mi->mi_manager_thread = zthread_create(NULL, 0, nfs4_async_manager,
2585 	    vfsp, 0, minclsyspri);
2586 	ASSERT(mi->mi_manager_thread != NULL);
2587 
2588 	/*
2589 	 * Create the thread that handles over-the-wire calls for
2590 	 * VOP_INACTIVE.
2591 	 * This needs to happen after the manager thread is created.
2592 	 */
2593 	MI4_HOLD(mi);
2594 	mi->mi_inactive_thread = zthread_create(NULL, 0, nfs4_inactive_thread,
2595 	    mi, 0, minclsyspri);
2596 	ASSERT(mi->mi_inactive_thread != NULL);
2597 
2598 	/* If we didn't get a type, get one now */
2599 	if (rtvp->v_type == VNON) {
2600 		va.va_mask = AT_TYPE;
2601 		error = nfs4getattr(rtvp, &va, tcr);
2602 		if (error)
2603 			goto bad;
2604 		rtvp->v_type = va.va_type;
2605 	}
2606 
2607 	mi->mi_type = rtvp->v_type;
2608 
2609 	mutex_enter(&mi->mi_lock);
2610 	mi->mi_flags &= ~MI4_MOUNTING;
2611 	mutex_exit(&mi->mi_lock);
2612 
2613 	/* Update VFS with new server and path info */
2614 	if ((strcmp(svp->sv_hostname, origsvp->sv_hostname) != 0) ||
2615 	    (strcmp(svp->sv_path, origsvp->sv_path) != 0)) {
2616 		len = svp->sv_hostnamelen + svp->sv_pathlen;
2617 		resource = kmem_zalloc(len, KM_SLEEP);
2618 		(void) strcat(resource, svp->sv_hostname);
2619 		(void) strcat(resource, ":");
2620 		(void) strcat(resource, svp->sv_path);
2621 		vfs_setresource(vfsp, resource, 0);
2622 		kmem_free(resource, len);
2623 	}
2624 
2625 	sv4_free(origsvp);
2626 	*rtvpp = rtvp;
2627 	if (lcr != NULL)
2628 		crfree(lcr);
2629 
2630 	return (0);
2631 bad:
2632 	/*
2633 	 * An error occurred somewhere, need to clean up...
2634 	 */
2635 	if (lcr != NULL)
2636 		crfree(lcr);
2637 
2638 	if (rtvp != NULL) {
2639 		/*
2640 		 * We need to release our reference to the root vnode and
2641 		 * destroy the mntinfo4 struct that we just created.
2642 		 */
2643 		rp = VTOR4(rtvp);
2644 		if (rp->r_flags & R4HASHED)
2645 			rp4_rmhash(rp);
2646 		VN_RELE(rtvp);
2647 	}
2648 	nfs4_async_stop(vfsp);
2649 	nfs4_async_manager_stop(vfsp);
2650 	removed = nfs4_mi_zonelist_remove(mi);
2651 	if (removed)
2652 		zone_rele_ref(&mi->mi_zone_ref, ZONE_REF_NFSV4);
2653 
2654 	/*
2655 	 * This releases the initial "hold" of the mi since it will never
2656 	 * be referenced by the vfsp.  Also, when mount returns to vfs.c
2657 	 * with an error, the vfsp will be destroyed, not rele'd.
2658 	 */
2659 	MI4_RELE(mi);
2660 
2661 	if (origsvp != NULL)
2662 		sv4_free(origsvp);
2663 
2664 	*rtvpp = NULL;
2665 	return (error);
2666 }
2667 
2668 /*
2669  * vfs operations
2670  */
2671 static int
2672 nfs4_unmount(vfs_t *vfsp, int flag, cred_t *cr)
2673 {
2674 	mntinfo4_t		*mi;
2675 	ushort_t		omax;
2676 	int			removed;
2677 
2678 	bool_t			must_unlock;
2679 
2680 	nfs4_ephemeral_tree_t	*eph_tree;
2681 
2682 	if (secpolicy_fs_unmount(cr, vfsp) != 0)
2683 		return (EPERM);
2684 
2685 	mi = VFTOMI4(vfsp);
2686 
2687 	if (flag & MS_FORCE) {
2688 		vfsp->vfs_flag |= VFS_UNMOUNTED;
2689 		if (nfs_zone() != mi->mi_zone) {
2690 			/*
2691 			 * If the request is coming from the wrong zone,
2692 			 * we don't want to create any new threads, and
2693 			 * performance is not a concern.  Do everything
2694 			 * inline.
2695 			 */
2696 			NFS4_DEBUG(nfs4_client_zone_debug, (CE_NOTE,
2697 			    "nfs4_unmount x-zone forced unmount of vfs %p\n",
2698 			    (void *)vfsp));
2699 			nfs4_free_mount(vfsp, flag, cr);
2700 		} else {
2701 			/*
2702 			 * Free data structures asynchronously, to avoid
2703 			 * blocking the current thread (for performance
2704 			 * reasons only).
2705 			 */
2706 			async_free_mount(vfsp, flag, cr);
2707 		}
2708 
2709 		return (0);
2710 	}
2711 
2712 	/*
2713 	 * Wait until all asynchronous putpage operations on
2714 	 * this file system are complete before flushing rnodes
2715 	 * from the cache.
2716 	 */
2717 	omax = mi->mi_max_threads;
2718 	if (nfs4_async_stop_sig(vfsp))
2719 		return (EINTR);
2720 
2721 	r4flush(vfsp, cr);
2722 
2723 	/*
2724 	 * About the only reason that this would fail would be
2725 	 * that the harvester is already busy tearing down this
2726 	 * node. So we fail back to the caller and let them try
2727 	 * again when needed.
2728 	 */
2729 	if (nfs4_ephemeral_umount(mi, flag, cr,
2730 	    &must_unlock, &eph_tree)) {
2731 		ASSERT(must_unlock == FALSE);
2732 		mutex_enter(&mi->mi_async_lock);
2733 		mi->mi_max_threads = omax;
2734 		mutex_exit(&mi->mi_async_lock);
2735 
2736 		return (EBUSY);
2737 	}
2738 
2739 	/*
2740 	 * If there are any active vnodes on this file system,
2741 	 * then the file system is busy and can't be unmounted.
2742 	 */
2743 	if (check_rtable4(vfsp)) {
2744 		nfs4_ephemeral_umount_unlock(&must_unlock, &eph_tree);
2745 
2746 		mutex_enter(&mi->mi_async_lock);
2747 		mi->mi_max_threads = omax;
2748 		mutex_exit(&mi->mi_async_lock);
2749 
2750 		return (EBUSY);
2751 	}
2752 
2753 	/*
2754 	 * The unmount can't fail from now on, so record any
2755 	 * ephemeral changes.
2756 	 */
2757 	nfs4_ephemeral_umount_activate(mi, &must_unlock, &eph_tree);
2758 
2759 	/*
2760 	 * There are no active files that could require over-the-wire
2761 	 * calls to the server, so stop the async manager and the
2762 	 * inactive thread.
2763 	 */
2764 	nfs4_async_manager_stop(vfsp);
2765 
2766 	/*
2767 	 * Destroy all rnodes belonging to this file system from the
2768 	 * rnode hash queues and purge any resources allocated to
2769 	 * them.
2770 	 */
2771 	destroy_rtable4(vfsp, cr);
2772 	vfsp->vfs_flag |= VFS_UNMOUNTED;
2773 
2774 	nfs4_remove_mi_from_server(mi, NULL);
2775 	removed = nfs4_mi_zonelist_remove(mi);
2776 	if (removed)
2777 		zone_rele_ref(&mi->mi_zone_ref, ZONE_REF_NFSV4);
2778 
2779 	return (0);
2780 }
2781 
2782 /*
2783  * find root of nfs
2784  */
2785 static int
2786 nfs4_root(vfs_t *vfsp, vnode_t **vpp)
2787 {
2788 	mntinfo4_t *mi;
2789 	vnode_t *vp;
2790 	nfs4_fname_t *mfname;
2791 	servinfo4_t *svp;
2792 
2793 	mi = VFTOMI4(vfsp);
2794 
2795 	if (nfs_zone() != mi->mi_zone)
2796 		return (EPERM);
2797 
2798 	svp = mi->mi_curr_serv;
2799 	if (svp) {
2800 		(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
2801 		if (svp->sv_flags & SV4_ROOT_STALE) {
2802 			nfs_rw_exit(&svp->sv_lock);
2803 
2804 			(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2805 			if (svp->sv_flags & SV4_ROOT_STALE) {
2806 				svp->sv_flags &= ~SV4_ROOT_STALE;
2807 				nfs_rw_exit(&svp->sv_lock);
2808 				return (ENOENT);
2809 			}
2810 			nfs_rw_exit(&svp->sv_lock);
2811 		} else
2812 			nfs_rw_exit(&svp->sv_lock);
2813 	}
2814 
2815 	mfname = mi->mi_fname;
2816 	fn_hold(mfname);
2817 	vp = makenfs4node_by_fh(mi->mi_rootfh, NULL, &mfname, NULL,
2818 	    VFTOMI4(vfsp), CRED(), gethrtime());
2819 
2820 	if (VTOR4(vp)->r_flags & R4STALE) {
2821 		VN_RELE(vp);
2822 		return (ENOENT);
2823 	}
2824 
2825 	ASSERT(vp->v_type == VNON || vp->v_type == mi->mi_type);
2826 
2827 	vp->v_type = mi->mi_type;
2828 
2829 	*vpp = vp;
2830 
2831 	return (0);
2832 }
2833 
2834 static int
2835 nfs4_statfs_otw(vnode_t *vp, struct statvfs64 *sbp, cred_t *cr)
2836 {
2837 	int error;
2838 	nfs4_ga_res_t gar;
2839 	nfs4_ga_ext_res_t ger;
2840 
2841 	gar.n4g_ext_res = &ger;
2842 
2843 	if (error = nfs4_attr_otw(vp, TAG_FSINFO, &gar,
2844 	    NFS4_STATFS_ATTR_MASK, cr))
2845 		return (error);
2846 
2847 	*sbp = gar.n4g_ext_res->n4g_sb;
2848 
2849 	return (0);
2850 }
2851 
2852 /*
2853  * Get file system statistics.
2854  */
2855 static int
2856 nfs4_statvfs(vfs_t *vfsp, struct statvfs64 *sbp)
2857 {
2858 	int error;
2859 	vnode_t *vp;
2860 	cred_t *cr;
2861 
2862 	error = nfs4_root(vfsp, &vp);
2863 	if (error)
2864 		return (error);
2865 
2866 	cr = CRED();
2867 
2868 	error = nfs4_statfs_otw(vp, sbp, cr);
2869 	if (!error) {
2870 		(void) strncpy(sbp->f_basetype,
2871 		    vfssw[vfsp->vfs_fstype].vsw_name, FSTYPSZ);
2872 		sbp->f_flag = vf_to_stf(vfsp->vfs_flag);
2873 	} else {
2874 		nfs4_purge_stale_fh(error, vp, cr);
2875 	}
2876 
2877 	VN_RELE(vp);
2878 
2879 	return (error);
2880 }
2881 
2882 static kmutex_t nfs4_syncbusy;
2883 
2884 /*
2885  * Flush dirty nfs files for file system vfsp.
2886  * If vfsp == NULL, all nfs files are flushed.
2887  *
2888  * SYNC_CLOSE in flag is passed to us to
2889  * indicate that we are shutting down and or
2890  * rebooting.
2891  */
2892 static int
2893 nfs4_sync(vfs_t *vfsp, short flag, cred_t *cr)
2894 {
2895 	/*
2896 	 * Cross-zone calls are OK here, since this translates to a
2897 	 * VOP_PUTPAGE(B_ASYNC), which gets picked up by the right zone.
2898 	 */
2899 	if (!(flag & SYNC_ATTR) && mutex_tryenter(&nfs4_syncbusy) != 0) {
2900 		r4flush(vfsp, cr);
2901 		mutex_exit(&nfs4_syncbusy);
2902 	}
2903 
2904 	/*
2905 	 * if SYNC_CLOSE is set then we know that
2906 	 * the system is rebooting, mark the mntinfo
2907 	 * for later examination.
2908 	 */
2909 	if (vfsp && (flag & SYNC_CLOSE)) {
2910 		mntinfo4_t *mi;
2911 
2912 		mi = VFTOMI4(vfsp);
2913 		if (!(mi->mi_flags & MI4_SHUTDOWN)) {
2914 			mutex_enter(&mi->mi_lock);
2915 			mi->mi_flags |= MI4_SHUTDOWN;
2916 			mutex_exit(&mi->mi_lock);
2917 		}
2918 	}
2919 	return (0);
2920 }
2921 
2922 /*
2923  * vget is difficult, if not impossible, to support in v4 because we don't
2924  * know the parent directory or name, which makes it impossible to create a
2925  * useful shadow vnode.  And we need the shadow vnode for things like
2926  * OPEN.
2927  */
2928 
2929 /* ARGSUSED */
2930 /*
2931  * XXX Check nfs4_vget_pseudo() for dependency.
2932  */
2933 static int
2934 nfs4_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
2935 {
2936 	return (EREMOTE);
2937 }
2938 
2939 /*
2940  * nfs4_mountroot get called in the case where we are diskless booting.  All
2941  * we need from here is the ability to get the server info and from there we
2942  * can simply call nfs4_rootvp.
2943  */
2944 /* ARGSUSED */
2945 static int
2946 nfs4_mountroot(vfs_t *vfsp, whymountroot_t why)
2947 {
2948 	vnode_t *rtvp;
2949 	char root_hostname[SYS_NMLN+1];
2950 	struct servinfo4 *svp;
2951 	int error;
2952 	int vfsflags;
2953 	size_t size;
2954 	char *root_path;
2955 	struct pathname pn;
2956 	char *name;
2957 	cred_t *cr;
2958 	mntinfo4_t *mi;
2959 	struct nfs_args args;		/* nfs mount arguments */
2960 	static char token[10];
2961 	nfs4_error_t n4e;
2962 
2963 	bzero(&args, sizeof (args));
2964 
2965 	/* do this BEFORE getfile which causes xid stamps to be initialized */
2966 	clkset(-1L);		/* hack for now - until we get time svc? */
2967 
2968 	if (why == ROOT_REMOUNT) {
2969 		/*
2970 		 * Shouldn't happen.
2971 		 */
2972 		panic("nfs4_mountroot: why == ROOT_REMOUNT");
2973 	}
2974 
2975 	if (why == ROOT_UNMOUNT) {
2976 		/*
2977 		 * Nothing to do for NFS.
2978 		 */
2979 		return (0);
2980 	}
2981 
2982 	/*
2983 	 * why == ROOT_INIT
2984 	 */
2985 
2986 	name = token;
2987 	*name = 0;
2988 	(void) getfsname("root", name, sizeof (token));
2989 
2990 	pn_alloc(&pn);
2991 	root_path = pn.pn_path;
2992 
2993 	svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
2994 	nfs_rw_init(&svp->sv_lock, NULL, RW_DEFAULT, NULL);
2995 	svp->sv_knconf = kmem_zalloc(sizeof (*svp->sv_knconf), KM_SLEEP);
2996 	svp->sv_knconf->knc_protofmly = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
2997 	svp->sv_knconf->knc_proto = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
2998 
2999 	/*
3000 	 * Get server address
3001 	 * Get the root path
3002 	 * Get server's transport
3003 	 * Get server's hostname
3004 	 * Get options
3005 	 */
3006 	args.addr = &svp->sv_addr;
3007 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
3008 	args.fh = (char *)&svp->sv_fhandle;
3009 	args.knconf = svp->sv_knconf;
3010 	args.hostname = root_hostname;
3011 	vfsflags = 0;
3012 	if (error = mount_root(*name ? name : "root", root_path, NFS_V4,
3013 	    &args, &vfsflags)) {
3014 		if (error == EPROTONOSUPPORT)
3015 			nfs_cmn_err(error, CE_WARN, "nfs4_mountroot: "
3016 			    "mount_root failed: server doesn't support NFS V4");
3017 		else
3018 			nfs_cmn_err(error, CE_WARN,
3019 			    "nfs4_mountroot: mount_root failed: %m");
3020 		nfs_rw_exit(&svp->sv_lock);
3021 		sv4_free(svp);
3022 		pn_free(&pn);
3023 		return (error);
3024 	}
3025 	nfs_rw_exit(&svp->sv_lock);
3026 	svp->sv_hostnamelen = (int)(strlen(root_hostname) + 1);
3027 	svp->sv_hostname = kmem_alloc(svp->sv_hostnamelen, KM_SLEEP);
3028 	(void) strcpy(svp->sv_hostname, root_hostname);
3029 
3030 	svp->sv_pathlen = (int)(strlen(root_path) + 1);
3031 	svp->sv_path = kmem_alloc(svp->sv_pathlen, KM_SLEEP);
3032 	(void) strcpy(svp->sv_path, root_path);
3033 
3034 	/*
3035 	 * Force root partition to always be mounted with AUTH_UNIX for now
3036 	 */
3037 	svp->sv_secdata = kmem_alloc(sizeof (*svp->sv_secdata), KM_SLEEP);
3038 	svp->sv_secdata->secmod = AUTH_UNIX;
3039 	svp->sv_secdata->rpcflavor = AUTH_UNIX;
3040 	svp->sv_secdata->data = NULL;
3041 
3042 	cr = crgetcred();
3043 	rtvp = NULL;
3044 
3045 	error = nfs4rootvp(&rtvp, vfsp, svp, args.flags, cr, global_zone);
3046 
3047 	if (error) {
3048 		crfree(cr);
3049 		pn_free(&pn);
3050 		sv4_free(svp);
3051 		return (error);
3052 	}
3053 
3054 	mi = VTOMI4(rtvp);
3055 
3056 	/*
3057 	 * Send client id to the server, if necessary
3058 	 */
3059 	nfs4_error_zinit(&n4e);
3060 	nfs4setclientid(mi, cr, FALSE, &n4e);
3061 	error = n4e.error;
3062 
3063 	crfree(cr);
3064 
3065 	if (error) {
3066 		pn_free(&pn);
3067 		goto errout;
3068 	}
3069 
3070 	error = nfs4_setopts(rtvp, DATAMODEL_NATIVE, &args);
3071 	if (error) {
3072 		nfs_cmn_err(error, CE_WARN,
3073 		    "nfs4_mountroot: invalid root mount options");
3074 		pn_free(&pn);
3075 		goto errout;
3076 	}
3077 
3078 	(void) vfs_lock_wait(vfsp);
3079 	vfs_add(NULL, vfsp, vfsflags);
3080 	vfs_unlock(vfsp);
3081 
3082 	size = strlen(svp->sv_hostname);
3083 	(void) strcpy(rootfs.bo_name, svp->sv_hostname);
3084 	rootfs.bo_name[size] = ':';
3085 	(void) strcpy(&rootfs.bo_name[size + 1], root_path);
3086 
3087 	pn_free(&pn);
3088 
3089 errout:
3090 	if (error) {
3091 		sv4_free(svp);
3092 		nfs4_async_stop(vfsp);
3093 		nfs4_async_manager_stop(vfsp);
3094 	}
3095 
3096 	if (rtvp != NULL)
3097 		VN_RELE(rtvp);
3098 
3099 	return (error);
3100 }
3101 
3102 /*
3103  * Initialization routine for VFS routines.  Should only be called once
3104  */
3105 int
3106 nfs4_vfsinit(void)
3107 {
3108 	mutex_init(&nfs4_syncbusy, NULL, MUTEX_DEFAULT, NULL);
3109 	nfs4setclientid_init();
3110 	nfs4_ephemeral_init();
3111 	return (0);
3112 }
3113 
3114 void
3115 nfs4_vfsfini(void)
3116 {
3117 	nfs4_ephemeral_fini();
3118 	nfs4setclientid_fini();
3119 	mutex_destroy(&nfs4_syncbusy);
3120 }
3121 
3122 void
3123 nfs4_freevfs(vfs_t *vfsp)
3124 {
3125 	mntinfo4_t *mi;
3126 
3127 	/* need to release the initial hold */
3128 	mi = VFTOMI4(vfsp);
3129 
3130 	/*
3131 	 * At this point, we can no longer reference the vfs
3132 	 * and need to inform other holders of the reference
3133 	 * to the mntinfo4_t.
3134 	 */
3135 	mi->mi_vfsp = NULL;
3136 
3137 	MI4_RELE(mi);
3138 }
3139 
3140 /*
3141  * Client side SETCLIENTID and SETCLIENTID_CONFIRM
3142  */
3143 struct nfs4_server nfs4_server_lst =
3144 	{ &nfs4_server_lst, &nfs4_server_lst };
3145 
3146 kmutex_t nfs4_server_lst_lock;
3147 
3148 static void
3149 nfs4setclientid_init(void)
3150 {
3151 	mutex_init(&nfs4_server_lst_lock, NULL, MUTEX_DEFAULT, NULL);
3152 }
3153 
3154 static void
3155 nfs4setclientid_fini(void)
3156 {
3157 	mutex_destroy(&nfs4_server_lst_lock);
3158 }
3159 
3160 int nfs4_retry_sclid_delay = NFS4_RETRY_SCLID_DELAY;
3161 int nfs4_num_sclid_retries = NFS4_NUM_SCLID_RETRIES;
3162 
3163 /*
3164  * Set the clientid for the server for "mi".  No-op if the clientid is
3165  * already set.
3166  *
3167  * The recovery boolean should be set to TRUE if this function was called
3168  * by the recovery code, and FALSE otherwise.  This is used to determine
3169  * if we need to call nfs4_start/end_op as well as grab the mi_recovlock
3170  * for adding a mntinfo4_t to a nfs4_server_t.
3171  *
3172  * Error is returned via 'n4ep'.  If there was a 'n4ep->stat' error, then
3173  * 'n4ep->error' is set to geterrno4(n4ep->stat).
3174  */
3175 void
3176 nfs4setclientid(mntinfo4_t *mi, cred_t *cr, bool_t recovery, nfs4_error_t *n4ep)
3177 {
3178 	struct nfs4_server *np;
3179 	struct servinfo4 *svp = mi->mi_curr_serv;
3180 	nfs4_recov_state_t recov_state;
3181 	int num_retries = 0;
3182 	bool_t retry;
3183 	cred_t *lcr = NULL;
3184 	int retry_inuse = 1; /* only retry once on NFS4ERR_CLID_INUSE */
3185 	time_t lease_time = 0;
3186 
3187 	recov_state.rs_flags = 0;
3188 	recov_state.rs_num_retry_despite_err = 0;
3189 	ASSERT(n4ep != NULL);
3190 
3191 recov_retry:
3192 	retry = FALSE;
3193 	nfs4_error_zinit(n4ep);
3194 	if (!recovery)
3195 		(void) nfs_rw_enter_sig(&mi->mi_recovlock, RW_READER, 0);
3196 
3197 	mutex_enter(&nfs4_server_lst_lock);
3198 	np = servinfo4_to_nfs4_server(svp); /* This locks np if it is found */
3199 	mutex_exit(&nfs4_server_lst_lock);
3200 	if (!np) {
3201 		struct nfs4_server *tnp;
3202 		np = new_nfs4_server(svp, cr);
3203 		mutex_enter(&np->s_lock);
3204 
3205 		mutex_enter(&nfs4_server_lst_lock);
3206 		tnp = servinfo4_to_nfs4_server(svp);
3207 		if (tnp) {
3208 			/*
3209 			 * another thread snuck in and put server on list.
3210 			 * since we aren't adding it to the nfs4_server_list
3211 			 * we need to set the ref count to 0 and destroy it.
3212 			 */
3213 			np->s_refcnt = 0;
3214 			destroy_nfs4_server(np);
3215 			np = tnp;
3216 		} else {
3217 			/*
3218 			 * do not give list a reference until everything
3219 			 * succeeds
3220 			 */
3221 			insque(np, &nfs4_server_lst);
3222 		}
3223 		mutex_exit(&nfs4_server_lst_lock);
3224 	}
3225 	ASSERT(MUTEX_HELD(&np->s_lock));
3226 	/*
3227 	 * If we find the server already has N4S_CLIENTID_SET, then
3228 	 * just return, we've already done SETCLIENTID to that server
3229 	 */
3230 	if (np->s_flags & N4S_CLIENTID_SET) {
3231 		/* add mi to np's mntinfo4_list */
3232 		nfs4_add_mi_to_server(np, mi);
3233 		if (!recovery)
3234 			nfs_rw_exit(&mi->mi_recovlock);
3235 		mutex_exit(&np->s_lock);
3236 		nfs4_server_rele(np);
3237 		return;
3238 	}
3239 	mutex_exit(&np->s_lock);
3240 
3241 
3242 	/*
3243 	 * Drop the mi_recovlock since nfs4_start_op will
3244 	 * acquire it again for us.
3245 	 */
3246 	if (!recovery) {
3247 		nfs_rw_exit(&mi->mi_recovlock);
3248 
3249 		n4ep->error = nfs4_start_op(mi, NULL, NULL, &recov_state);
3250 		if (n4ep->error) {
3251 			nfs4_server_rele(np);
3252 			return;
3253 		}
3254 	}
3255 
3256 	mutex_enter(&np->s_lock);
3257 	while (np->s_flags & N4S_CLIENTID_PEND) {
3258 		if (!cv_wait_sig(&np->s_clientid_pend, &np->s_lock)) {
3259 			mutex_exit(&np->s_lock);
3260 			nfs4_server_rele(np);
3261 			if (!recovery)
3262 				nfs4_end_op(mi, NULL, NULL, &recov_state,
3263 				    recovery);
3264 			n4ep->error = EINTR;
3265 			return;
3266 		}
3267 	}
3268 
3269 	if (np->s_flags & N4S_CLIENTID_SET) {
3270 		/* XXX copied/pasted from above */
3271 		/* add mi to np's mntinfo4_list */
3272 		nfs4_add_mi_to_server(np, mi);
3273 		mutex_exit(&np->s_lock);
3274 		nfs4_server_rele(np);
3275 		if (!recovery)
3276 			nfs4_end_op(mi, NULL, NULL, &recov_state, recovery);
3277 		return;
3278 	}
3279 
3280 	/*
3281 	 * Reset the N4S_CB_PINGED flag. This is used to
3282 	 * indicate if we have received a CB_NULL from the
3283 	 * server. Also we reset the waiter flag.
3284 	 */
3285 	np->s_flags &= ~(N4S_CB_PINGED | N4S_CB_WAITER);
3286 	/* any failure must now clear this flag */
3287 	np->s_flags |= N4S_CLIENTID_PEND;
3288 	mutex_exit(&np->s_lock);
3289 	nfs4setclientid_otw(mi, svp, cr, np, n4ep, &retry_inuse);
3290 
3291 	if (n4ep->error == EACCES) {
3292 		/*
3293 		 * If the uid is set then set the creds for secure mounts
3294 		 * by proxy processes such as automountd.
3295 		 */
3296 		(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
3297 		if (svp->sv_secdata->uid != 0) {
3298 			lcr = crdup(cr);
3299 			(void) crsetugid(lcr, svp->sv_secdata->uid,
3300 			    crgetgid(cr));
3301 		}
3302 		nfs_rw_exit(&svp->sv_lock);
3303 
3304 		if (lcr != NULL) {
3305 			mutex_enter(&np->s_lock);
3306 			crfree(np->s_cred);
3307 			np->s_cred = lcr;
3308 			mutex_exit(&np->s_lock);
3309 			nfs4setclientid_otw(mi, svp, lcr, np, n4ep,
3310 			    &retry_inuse);
3311 		}
3312 	}
3313 	mutex_enter(&np->s_lock);
3314 	lease_time = np->s_lease_time;
3315 	np->s_flags &= ~N4S_CLIENTID_PEND;
3316 	mutex_exit(&np->s_lock);
3317 
3318 	if (n4ep->error != 0 || n4ep->stat != NFS4_OK) {
3319 		/*
3320 		 * Start recovery if failover is a possibility.  If
3321 		 * invoked by the recovery thread itself, then just
3322 		 * return and let it handle the failover first.  NB:
3323 		 * recovery is not allowed if the mount is in progress
3324 		 * since the infrastructure is not sufficiently setup
3325 		 * to allow it.  Just return the error (after suitable
3326 		 * retries).
3327 		 */
3328 		if (FAILOVER_MOUNT4(mi) && nfs4_try_failover(n4ep)) {
3329 			(void) nfs4_start_recovery(n4ep, mi, NULL,
3330 			    NULL, NULL, NULL, OP_SETCLIENTID, NULL, NULL, NULL);
3331 			/*
3332 			 * Don't retry here, just return and let
3333 			 * recovery take over.
3334 			 */
3335 			if (recovery)
3336 				retry = FALSE;
3337 		} else if (nfs4_rpc_retry_error(n4ep->error) ||
3338 		    n4ep->stat == NFS4ERR_RESOURCE ||
3339 		    n4ep->stat == NFS4ERR_STALE_CLIENTID) {
3340 
3341 			retry = TRUE;
3342 			/*
3343 			 * Always retry if in recovery or once had
3344 			 * contact with the server (but now it's
3345 			 * overloaded).
3346 			 */
3347 			if (recovery == TRUE ||
3348 			    n4ep->error == ETIMEDOUT ||
3349 			    n4ep->error == ECONNRESET)
3350 				num_retries = 0;
3351 		} else if (retry_inuse && n4ep->error == 0 &&
3352 		    n4ep->stat == NFS4ERR_CLID_INUSE) {
3353 			retry = TRUE;
3354 			num_retries = 0;
3355 		}
3356 	} else {
3357 		/*
3358 		 * Since everything succeeded give the list a reference count if
3359 		 * it hasn't been given one by add_new_nfs4_server() or if this
3360 		 * is not a recovery situation in which case it is already on
3361 		 * the list.
3362 		 */
3363 		mutex_enter(&np->s_lock);
3364 		if ((np->s_flags & N4S_INSERTED) == 0) {
3365 			np->s_refcnt++;
3366 			np->s_flags |= N4S_INSERTED;
3367 		}
3368 		mutex_exit(&np->s_lock);
3369 	}
3370 
3371 	if (!recovery)
3372 		nfs4_end_op(mi, NULL, NULL, &recov_state, recovery);
3373 
3374 
3375 	if (retry && num_retries++ < nfs4_num_sclid_retries) {
3376 		if (retry_inuse) {
3377 			delay(SEC_TO_TICK(lease_time + nfs4_retry_sclid_delay));
3378 			retry_inuse = 0;
3379 		} else
3380 			delay(SEC_TO_TICK(nfs4_retry_sclid_delay));
3381 
3382 		nfs4_server_rele(np);
3383 		goto recov_retry;
3384 	}
3385 
3386 
3387 	if (n4ep->error == 0)
3388 		n4ep->error = geterrno4(n4ep->stat);
3389 
3390 	/* broadcast before release in case no other threads are waiting */
3391 	cv_broadcast(&np->s_clientid_pend);
3392 	nfs4_server_rele(np);
3393 }
3394 
3395 int nfs4setclientid_otw_debug = 0;
3396 
3397 /*
3398  * This function handles the recovery of STALE_CLIENTID for SETCLIENTID_CONFRIM,
3399  * but nothing else; the calling function must be designed to handle those
3400  * other errors.
3401  */
3402 static void
3403 nfs4setclientid_otw(mntinfo4_t *mi, struct servinfo4 *svp,  cred_t *cr,
3404     struct nfs4_server *np, nfs4_error_t *ep, int *retry_inusep)
3405 {
3406 	COMPOUND4args_clnt args;
3407 	COMPOUND4res_clnt res;
3408 	nfs_argop4 argop[3];
3409 	SETCLIENTID4args *s_args;
3410 	SETCLIENTID4resok *s_resok;
3411 	int doqueue = 1;
3412 	nfs4_ga_res_t *garp = NULL;
3413 	timespec_t prop_time, after_time;
3414 	verifier4 verf;
3415 	clientid4 tmp_clientid;
3416 
3417 	ASSERT(!MUTEX_HELD(&np->s_lock));
3418 
3419 	args.ctag = TAG_SETCLIENTID;
3420 
3421 	args.array = argop;
3422 	args.array_len = 3;
3423 
3424 	/* PUTROOTFH */
3425 	argop[0].argop = OP_PUTROOTFH;
3426 
3427 	/* GETATTR */
3428 	argop[1].argop = OP_GETATTR;
3429 	argop[1].nfs_argop4_u.opgetattr.attr_request = FATTR4_LEASE_TIME_MASK;
3430 	argop[1].nfs_argop4_u.opgetattr.mi = mi;
3431 
3432 	/* SETCLIENTID */
3433 	argop[2].argop = OP_SETCLIENTID;
3434 
3435 	s_args = &argop[2].nfs_argop4_u.opsetclientid;
3436 
3437 	mutex_enter(&np->s_lock);
3438 
3439 	s_args->client.verifier = np->clidtosend.verifier;
3440 	s_args->client.id_len = np->clidtosend.id_len;
3441 	ASSERT(s_args->client.id_len <= NFS4_OPAQUE_LIMIT);
3442 	s_args->client.id_val = np->clidtosend.id_val;
3443 
3444 	/*
3445 	 * Callback needs to happen on non-RDMA transport
3446 	 * Check if we have saved the original knetconfig
3447 	 * if so, use that instead.
3448 	 */
3449 	if (svp->sv_origknconf != NULL)
3450 		nfs4_cb_args(np, svp->sv_origknconf, s_args);
3451 	else
3452 		nfs4_cb_args(np, svp->sv_knconf, s_args);
3453 
3454 	mutex_exit(&np->s_lock);
3455 
3456 	rfs4call(mi, &args, &res, cr, &doqueue, 0, ep);
3457 
3458 	if (ep->error)
3459 		return;
3460 
3461 	/* getattr lease_time res */
3462 	if ((res.array_len >= 2) &&
3463 	    (res.array[1].nfs_resop4_u.opgetattr.status == NFS4_OK)) {
3464 		garp = &res.array[1].nfs_resop4_u.opgetattr.ga_res;
3465 
3466 #ifndef _LP64
3467 		/*
3468 		 * The 32 bit client cannot handle a lease time greater than
3469 		 * (INT32_MAX/1000000).  This is due to the use of the
3470 		 * lease_time in calls to drv_usectohz() in
3471 		 * nfs4_renew_lease_thread().  The problem is that
3472 		 * drv_usectohz() takes a time_t (which is just a long = 4
3473 		 * bytes) as its parameter.  The lease_time is multiplied by
3474 		 * 1000000 to convert seconds to usecs for the parameter.  If
3475 		 * a number bigger than (INT32_MAX/1000000) is used then we
3476 		 * overflow on the 32bit client.
3477 		 */
3478 		if (garp->n4g_ext_res->n4g_leasetime > (INT32_MAX/1000000)) {
3479 			garp->n4g_ext_res->n4g_leasetime = INT32_MAX/1000000;
3480 		}
3481 #endif
3482 
3483 		mutex_enter(&np->s_lock);
3484 		np->s_lease_time = garp->n4g_ext_res->n4g_leasetime;
3485 
3486 		/*
3487 		 * Keep track of the lease period for the mi's
3488 		 * mi_msg_list.  We need an appropiate time
3489 		 * bound to associate past facts with a current
3490 		 * event.  The lease period is perfect for this.
3491 		 */
3492 		mutex_enter(&mi->mi_msg_list_lock);
3493 		mi->mi_lease_period = np->s_lease_time;
3494 		mutex_exit(&mi->mi_msg_list_lock);
3495 		mutex_exit(&np->s_lock);
3496 	}
3497 
3498 
3499 	if (res.status == NFS4ERR_CLID_INUSE) {
3500 		clientaddr4 *clid_inuse;
3501 
3502 		if (!(*retry_inusep)) {
3503 			clid_inuse = &res.array->nfs_resop4_u.
3504 			    opsetclientid.SETCLIENTID4res_u.client_using;
3505 
3506 			zcmn_err(mi->mi_zone->zone_id, CE_NOTE,
3507 			    "NFS4 mount (SETCLIENTID failed)."
3508 			    "  nfs4_client_id.id is in"
3509 			    "use already by: r_netid<%s> r_addr<%s>",
3510 			    clid_inuse->r_netid, clid_inuse->r_addr);
3511 		}
3512 
3513 		/*
3514 		 * XXX - The client should be more robust in its
3515 		 * handling of clientid in use errors (regen another
3516 		 * clientid and try again?)
3517 		 */
3518 		(void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
3519 		return;
3520 	}
3521 
3522 	if (res.status) {
3523 		(void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
3524 		return;
3525 	}
3526 
3527 	s_resok = &res.array[2].nfs_resop4_u.
3528 	    opsetclientid.SETCLIENTID4res_u.resok4;
3529 
3530 	tmp_clientid = s_resok->clientid;
3531 
3532 	verf = s_resok->setclientid_confirm;
3533 
3534 #ifdef	DEBUG
3535 	if (nfs4setclientid_otw_debug) {
3536 		union {
3537 			clientid4	clientid;
3538 			int		foo[2];
3539 		} cid;
3540 
3541 		cid.clientid = s_resok->clientid;
3542 
3543 		zcmn_err(mi->mi_zone->zone_id, CE_NOTE,
3544 		"nfs4setclientid_otw: OK, clientid = %x,%x, "
3545 		"verifier = %" PRIx64 "\n", cid.foo[0], cid.foo[1], verf);
3546 	}
3547 #endif
3548 
3549 	(void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
3550 
3551 	/* Confirm the client id and get the lease_time attribute */
3552 
3553 	args.ctag = TAG_SETCLIENTID_CF;
3554 
3555 	args.array = argop;
3556 	args.array_len = 1;
3557 
3558 	argop[0].argop = OP_SETCLIENTID_CONFIRM;
3559 
3560 	argop[0].nfs_argop4_u.opsetclientid_confirm.clientid = tmp_clientid;
3561 	argop[0].nfs_argop4_u.opsetclientid_confirm.setclientid_confirm = verf;
3562 
3563 	/* used to figure out RTT for np */
3564 	gethrestime(&prop_time);
3565 
3566 	NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, "nfs4setlientid_otw: "
3567 	    "start time: %ld sec %ld nsec", prop_time.tv_sec,
3568 	    prop_time.tv_nsec));
3569 
3570 	rfs4call(mi, &args, &res, cr, &doqueue, 0, ep);
3571 
3572 	gethrestime(&after_time);
3573 	mutex_enter(&np->s_lock);
3574 	np->propagation_delay.tv_sec =
3575 	    MAX(1, after_time.tv_sec - prop_time.tv_sec);
3576 	mutex_exit(&np->s_lock);
3577 
3578 	NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, "nfs4setlcientid_otw: "
3579 	    "finish time: %ld sec ", after_time.tv_sec));
3580 
3581 	NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, "nfs4setclientid_otw: "
3582 	    "propagation delay set to %ld sec",
3583 	    np->propagation_delay.tv_sec));
3584 
3585 	if (ep->error)
3586 		return;
3587 
3588 	if (res.status == NFS4ERR_CLID_INUSE) {
3589 		clientaddr4 *clid_inuse;
3590 
3591 		if (!(*retry_inusep)) {
3592 			clid_inuse = &res.array->nfs_resop4_u.
3593 			    opsetclientid.SETCLIENTID4res_u.client_using;
3594 
3595 			zcmn_err(mi->mi_zone->zone_id, CE_NOTE,
3596 			    "SETCLIENTID_CONFIRM failed.  "
3597 			    "nfs4_client_id.id is in use already by: "
3598 			    "r_netid<%s> r_addr<%s>",
3599 			    clid_inuse->r_netid, clid_inuse->r_addr);
3600 		}
3601 
3602 		(void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
3603 		return;
3604 	}
3605 
3606 	if (res.status) {
3607 		(void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
3608 		return;
3609 	}
3610 
3611 	mutex_enter(&np->s_lock);
3612 	np->clientid = tmp_clientid;
3613 	np->s_flags |= N4S_CLIENTID_SET;
3614 
3615 	/* Add mi to np's mntinfo4 list */
3616 	nfs4_add_mi_to_server(np, mi);
3617 
3618 	if (np->lease_valid == NFS4_LEASE_NOT_STARTED) {
3619 		/*
3620 		 * Start lease management thread.
3621 		 * Keep trying until we succeed.
3622 		 */
3623 
3624 		np->s_refcnt++;		/* pass reference to thread */
3625 		(void) zthread_create(NULL, 0, nfs4_renew_lease_thread, np, 0,
3626 		    minclsyspri);
3627 	}
3628 	mutex_exit(&np->s_lock);
3629 
3630 	(void) xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
3631 }
3632 
3633 /*
3634  * Add mi to sp's mntinfo4_list if it isn't already in the list.  Makes
3635  * mi's clientid the same as sp's.
3636  * Assumes sp is locked down.
3637  */
3638 void
3639 nfs4_add_mi_to_server(nfs4_server_t *sp, mntinfo4_t *mi)
3640 {
3641 	mntinfo4_t *tmi;
3642 	int in_list = 0;
3643 
3644 	ASSERT(nfs_rw_lock_held(&mi->mi_recovlock, RW_READER) ||
3645 	    nfs_rw_lock_held(&mi->mi_recovlock, RW_WRITER));
3646 	ASSERT(sp != &nfs4_server_lst);
3647 	ASSERT(MUTEX_HELD(&sp->s_lock));
3648 
3649 	NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE,
3650 	    "nfs4_add_mi_to_server: add mi %p to sp %p",
3651 	    (void*)mi, (void*)sp));
3652 
3653 	for (tmi = sp->mntinfo4_list;
3654 	    tmi != NULL;
3655 	    tmi = tmi->mi_clientid_next) {
3656 		if (tmi == mi) {
3657 			NFS4_DEBUG(nfs4_client_lease_debug,
3658 			    (CE_NOTE,
3659 			    "nfs4_add_mi_to_server: mi in list"));
3660 			in_list = 1;
3661 		}
3662 	}
3663 
3664 	/*
3665 	 * First put a hold on the mntinfo4's vfsp so that references via
3666 	 * mntinfo4_list will be valid.
3667 	 */
3668 	if (!in_list)
3669 		VFS_HOLD(mi->mi_vfsp);
3670 
3671 	NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE, "nfs4_add_mi_to_server: "
3672 	    "hold vfs %p for mi: %p", (void*)mi->mi_vfsp, (void*)mi));
3673 
3674 	if (!in_list) {
3675 		if (sp->mntinfo4_list)
3676 			sp->mntinfo4_list->mi_clientid_prev = mi;
3677 		mi->mi_clientid_next = sp->mntinfo4_list;
3678 		mi->mi_srv = sp;
3679 		sp->mntinfo4_list = mi;
3680 		mi->mi_srvsettime = gethrestime_sec();
3681 		mi->mi_srvset_cnt++;
3682 	}
3683 
3684 	/* set mi's clientid to that of sp's for later matching */
3685 	mi->mi_clientid = sp->clientid;
3686 
3687 	/*
3688 	 * Update the clientid for any other mi's belonging to sp.  This
3689 	 * must be done here while we hold sp->s_lock, so that
3690 	 * find_nfs4_server() continues to work.
3691 	 */
3692 
3693 	for (tmi = sp->mntinfo4_list;
3694 	    tmi != NULL;
3695 	    tmi = tmi->mi_clientid_next) {
3696 		if (tmi != mi) {
3697 			tmi->mi_clientid = sp->clientid;
3698 		}
3699 	}
3700 }
3701 
3702 /*
3703  * Remove the mi from sp's mntinfo4_list and release its reference.
3704  * Exception: if mi still has open files, flag it for later removal (when
3705  * all the files are closed).
3706  *
3707  * If this is the last mntinfo4 in sp's list then tell the lease renewal
3708  * thread to exit.
3709  */
3710 static void
3711 nfs4_remove_mi_from_server_nolock(mntinfo4_t *mi, nfs4_server_t *sp)
3712 {
3713 	NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE,
3714 	    "nfs4_remove_mi_from_server_nolock: remove mi %p from sp %p",
3715 	    (void*)mi, (void*)sp));
3716 
3717 	ASSERT(sp != NULL);
3718 	ASSERT(MUTEX_HELD(&sp->s_lock));
3719 	ASSERT(mi->mi_open_files >= 0);
3720 
3721 	/*
3722 	 * First make sure this mntinfo4 can be taken off of the list,
3723 	 * ie: it doesn't have any open files remaining.
3724 	 */
3725 	if (mi->mi_open_files > 0) {
3726 		NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE,
3727 		    "nfs4_remove_mi_from_server_nolock: don't "
3728 		    "remove mi since it still has files open"));
3729 
3730 		mutex_enter(&mi->mi_lock);
3731 		mi->mi_flags |= MI4_REMOVE_ON_LAST_CLOSE;
3732 		mutex_exit(&mi->mi_lock);
3733 		return;
3734 	}
3735 
3736 	VFS_HOLD(mi->mi_vfsp);
3737 	remove_mi(sp, mi);
3738 	VFS_RELE(mi->mi_vfsp);
3739 
3740 	if (sp->mntinfo4_list == NULL) {
3741 		/* last fs unmounted, kill the thread */
3742 		NFS4_DEBUG(nfs4_client_lease_debug, (CE_NOTE,
3743 		    "remove_mi_from_nfs4_server_nolock: kill the thread"));
3744 		nfs4_mark_srv_dead(sp);
3745 	}
3746 }
3747 
3748 /*
3749  * Remove mi from sp's mntinfo4_list and release the vfs reference.
3750  */
3751 static void
3752 remove_mi(nfs4_server_t *sp, mntinfo4_t *mi)
3753 {
3754 	ASSERT(MUTEX_HELD(&sp->s_lock));
3755 
3756 	/*
3757 	 * We release a reference, and the caller must still have a
3758 	 * reference.
3759 	 */
3760 	ASSERT(mi->mi_vfsp->vfs_count >= 2);
3761 
3762 	if (mi->mi_clientid_prev) {
3763 		mi->mi_clientid_prev->mi_clientid_next = mi->mi_clientid_next;
3764 	} else {
3765 		/* This is the first mi in sp's mntinfo4_list */
3766 		/*
3767 		 * Make sure the first mntinfo4 in the list is the actual
3768 		 * mntinfo4 passed in.
3769 		 */
3770 		ASSERT(sp->mntinfo4_list == mi);
3771 
3772 		sp->mntinfo4_list = mi->mi_clientid_next;
3773 	}
3774 	if (mi->mi_clientid_next)
3775 		mi->mi_clientid_next->mi_clientid_prev = mi->mi_clientid_prev;
3776 
3777 	/* Now mark the mntinfo4's links as being removed */
3778 	mi->mi_clientid_prev = mi->mi_clientid_next = NULL;
3779 	mi->mi_srv = NULL;
3780 	mi->mi_srvset_cnt++;
3781 
3782 	VFS_RELE(mi->mi_vfsp);
3783 }
3784 
3785 /*
3786  * Free all the entries in sp's mntinfo4_list.
3787  */
3788 static void
3789 remove_all_mi(nfs4_server_t *sp)
3790 {
3791 	mntinfo4_t *mi;
3792 
3793 	ASSERT(MUTEX_HELD(&sp->s_lock));
3794 
3795 	while (sp->mntinfo4_list != NULL) {
3796 		mi = sp->mntinfo4_list;
3797 		/*
3798 		 * Grab a reference in case there is only one left (which
3799 		 * remove_mi() frees).
3800 		 */
3801 		VFS_HOLD(mi->mi_vfsp);
3802 		remove_mi(sp, mi);
3803 		VFS_RELE(mi->mi_vfsp);
3804 	}
3805 }
3806 
3807 /*
3808  * Remove the mi from sp's mntinfo4_list as above, and rele the vfs.
3809  *
3810  * This version can be called with a null nfs4_server_t arg,
3811  * and will either find the right one and handle locking, or
3812  * do nothing because the mi wasn't added to an sp's mntinfo4_list.
3813  */
3814 void
3815 nfs4_remove_mi_from_server(mntinfo4_t *mi, nfs4_server_t *esp)
3816 {
3817 	nfs4_server_t	*sp;
3818 
3819 	if (esp) {
3820 		nfs4_remove_mi_from_server_nolock(mi, esp);
3821 		return;
3822 	}
3823 
3824 	(void) nfs_rw_enter_sig(&mi->mi_recovlock, RW_READER, 0);
3825 	if (sp = find_nfs4_server_all(mi, 1)) {
3826 		nfs4_remove_mi_from_server_nolock(mi, sp);
3827 		mutex_exit(&sp->s_lock);
3828 		nfs4_server_rele(sp);
3829 	}
3830 	nfs_rw_exit(&mi->mi_recovlock);
3831 }
3832 
3833 /*
3834  * Return TRUE if the given server has any non-unmounted filesystems.
3835  */
3836 
3837 bool_t
3838 nfs4_fs_active(nfs4_server_t *sp)
3839 {
3840 	mntinfo4_t *mi;
3841 
3842 	ASSERT(MUTEX_HELD(&sp->s_lock));
3843 
3844 	for (mi = sp->mntinfo4_list; mi != NULL; mi = mi->mi_clientid_next) {
3845 		if (!(mi->mi_vfsp->vfs_flag & VFS_UNMOUNTED))
3846 			return (TRUE);
3847 	}
3848 
3849 	return (FALSE);
3850 }
3851 
3852 /*
3853  * Mark sp as finished and notify any waiters.
3854  */
3855 
3856 void
3857 nfs4_mark_srv_dead(nfs4_server_t *sp)
3858 {
3859 	ASSERT(MUTEX_HELD(&sp->s_lock));
3860 
3861 	sp->s_thread_exit = NFS4_THREAD_EXIT;
3862 	cv_broadcast(&sp->cv_thread_exit);
3863 }
3864 
3865 /*
3866  * Create a new nfs4_server_t structure.
3867  * Returns new node unlocked and not in list, but with a reference count of
3868  * 1.
3869  */
3870 struct nfs4_server *
3871 new_nfs4_server(struct servinfo4 *svp, cred_t *cr)
3872 {
3873 	struct nfs4_server *np;
3874 	timespec_t tt;
3875 	union {
3876 		struct {
3877 			uint32_t sec;
3878 			uint32_t subsec;
3879 		} un_curtime;
3880 		verifier4	un_verifier;
3881 	} nfs4clientid_verifier;
3882 	/*
3883 	 * We change this ID string carefully and with the Solaris
3884 	 * NFS server behaviour in mind.  "+referrals" indicates
3885 	 * a client that can handle an NFSv4 referral.
3886 	 */
3887 	char id_val[] = "Solaris: %s, NFSv4 kernel client +referrals";
3888 	int len;
3889 
3890 	np = kmem_zalloc(sizeof (struct nfs4_server), KM_SLEEP);
3891 	np->saddr.len = svp->sv_addr.len;
3892 	np->saddr.maxlen = svp->sv_addr.maxlen;
3893 	np->saddr.buf = kmem_alloc(svp->sv_addr.maxlen, KM_SLEEP);
3894 	bcopy(svp->sv_addr.buf, np->saddr.buf, svp->sv_addr.len);
3895 	np->s_refcnt = 1;
3896 
3897 	/*
3898 	 * Build the nfs_client_id4 for this server mount.  Ensure
3899 	 * the verifier is useful and that the identification is
3900 	 * somehow based on the server's address for the case of
3901 	 * multi-homed servers.
3902 	 */
3903 	nfs4clientid_verifier.un_verifier = 0;
3904 	gethrestime(&tt);
3905 	nfs4clientid_verifier.un_curtime.sec = (uint32_t)tt.tv_sec;
3906 	nfs4clientid_verifier.un_curtime.subsec = (uint32_t)tt.tv_nsec;
3907 	np->clidtosend.verifier = nfs4clientid_verifier.un_verifier;
3908 
3909 	/*
3910 	 * calculate the length of the opaque identifier.  Subtract 2
3911 	 * for the "%s" and add the traditional +1 for null
3912 	 * termination.
3913 	 */
3914 	len = strlen(id_val) - 2 + strlen(uts_nodename()) + 1;
3915 	np->clidtosend.id_len = len + np->saddr.maxlen;
3916 
3917 	np->clidtosend.id_val = kmem_alloc(np->clidtosend.id_len, KM_SLEEP);
3918 	(void) sprintf(np->clidtosend.id_val, id_val, uts_nodename());
3919 	bcopy(np->saddr.buf, &np->clidtosend.id_val[len], np->saddr.len);
3920 
3921 	np->s_flags = 0;
3922 	np->mntinfo4_list = NULL;
3923 	/* save cred for issuing rfs4calls inside the renew thread */
3924 	crhold(cr);
3925 	np->s_cred = cr;
3926 	cv_init(&np->cv_thread_exit, NULL, CV_DEFAULT, NULL);
3927 	mutex_init(&np->s_lock, NULL, MUTEX_DEFAULT, NULL);
3928 	nfs_rw_init(&np->s_recovlock, NULL, RW_DEFAULT, NULL);
3929 	list_create(&np->s_deleg_list, sizeof (rnode4_t),
3930 	    offsetof(rnode4_t, r_deleg_link));
3931 	np->s_thread_exit = 0;
3932 	np->state_ref_count = 0;
3933 	np->lease_valid = NFS4_LEASE_NOT_STARTED;
3934 	cv_init(&np->s_cv_otw_count, NULL, CV_DEFAULT, NULL);
3935 	cv_init(&np->s_clientid_pend, NULL, CV_DEFAULT, NULL);
3936 	np->s_otw_call_count = 0;
3937 	cv_init(&np->wait_cb_null, NULL, CV_DEFAULT, NULL);
3938 	np->zoneid = getzoneid();
3939 	np->zone_globals = nfs4_get_callback_globals();
3940 	ASSERT(np->zone_globals != NULL);
3941 	return (np);
3942 }
3943 
3944 /*
3945  * Create a new nfs4_server_t structure and add it to the list.
3946  * Returns new node locked; reference must eventually be freed.
3947  */
3948 static struct nfs4_server *
3949 add_new_nfs4_server(struct servinfo4 *svp, cred_t *cr)
3950 {
3951 	nfs4_server_t *sp;
3952 
3953 	ASSERT(MUTEX_HELD(&nfs4_server_lst_lock));
3954 	sp = new_nfs4_server(svp, cr);
3955 	mutex_enter(&sp->s_lock);
3956 	insque(sp, &nfs4_server_lst);
3957 	sp->s_refcnt++;			/* list gets a reference */
3958 	sp->s_flags |= N4S_INSERTED;
3959 	sp->clientid = 0;
3960 	return (sp);
3961 }
3962 
3963 int nfs4_server_t_debug = 0;
3964 
3965 #ifdef lint
3966 extern void
3967 dumpnfs4slist(char *, mntinfo4_t *, clientid4, servinfo4_t *);
3968 #endif
3969 
3970 #ifndef lint
3971 #ifdef DEBUG
3972 void
3973 dumpnfs4slist(char *txt, mntinfo4_t *mi, clientid4 clientid, servinfo4_t *srv_p)
3974 {
3975 	int hash16(void *p, int len);
3976 	nfs4_server_t *np;
3977 
3978 	NFS4_DEBUG(nfs4_server_t_debug, (CE_NOTE,
3979 	    "dumping nfs4_server_t list in %s", txt));
3980 	NFS4_DEBUG(nfs4_server_t_debug, (CE_CONT,
3981 	    "mi 0x%p, want clientid %llx, addr %d/%04X",
3982 	    mi, (longlong_t)clientid, srv_p->sv_addr.len,
3983 	    hash16((void *)srv_p->sv_addr.buf, srv_p->sv_addr.len)));
3984 	for (np = nfs4_server_lst.forw; np != &nfs4_server_lst;
3985 	    np = np->forw) {
3986 		NFS4_DEBUG(nfs4_server_t_debug, (CE_CONT,
3987 		    "node 0x%p,    clientid %llx, addr %d/%04X, cnt %d",
3988 		    np, (longlong_t)np->clientid, np->saddr.len,
3989 		    hash16((void *)np->saddr.buf, np->saddr.len),
3990 		    np->state_ref_count));
3991 		if (np->saddr.len == srv_p->sv_addr.len &&
3992 		    bcmp(np->saddr.buf, srv_p->sv_addr.buf,
3993 		    np->saddr.len) == 0)
3994 			NFS4_DEBUG(nfs4_server_t_debug, (CE_CONT,
3995 			    " - address matches"));
3996 		if (np->clientid == clientid || np->clientid == 0)
3997 			NFS4_DEBUG(nfs4_server_t_debug, (CE_CONT,
3998 			    " - clientid matches"));
3999 		if (np->s_thread_exit != NFS4_THREAD_EXIT)
4000 			NFS4_DEBUG(nfs4_server_t_debug, (CE_CONT,
4001 			    " - thread not exiting"));
4002 	}
4003 	delay(hz);
4004 }
4005 #endif
4006 #endif
4007 
4008 
4009 /*
4010  * Move a mntinfo4_t from one server list to another.
4011  * Locking of the two nfs4_server_t nodes will be done in list order.
4012  *
4013  * Returns NULL if the current nfs4_server_t for the filesystem could not
4014  * be found (e.g., due to forced unmount).  Otherwise returns a reference
4015  * to the new nfs4_server_t, which must eventually be freed.
4016  */
4017 nfs4_server_t *
4018 nfs4_move_mi(mntinfo4_t *mi, servinfo4_t *old, servinfo4_t *new)
4019 {
4020 	nfs4_server_t *p, *op = NULL, *np = NULL;
4021 	int num_open;
4022 	zoneid_t zoneid = nfs_zoneid();
4023 
4024 	ASSERT(nfs_zone() == mi->mi_zone);
4025 
4026 	mutex_enter(&nfs4_server_lst_lock);
4027 #ifdef DEBUG
4028 	if (nfs4_server_t_debug)
4029 		dumpnfs4slist("nfs4_move_mi", mi, (clientid4)0, new);
4030 #endif
4031 	for (p = nfs4_server_lst.forw; p != &nfs4_server_lst; p = p->forw) {
4032 		if (p->zoneid != zoneid)
4033 			continue;
4034 		if (p->saddr.len == old->sv_addr.len &&
4035 		    bcmp(p->saddr.buf, old->sv_addr.buf, p->saddr.len) == 0 &&
4036 		    p->s_thread_exit != NFS4_THREAD_EXIT) {
4037 			op = p;
4038 			mutex_enter(&op->s_lock);
4039 			op->s_refcnt++;
4040 		}
4041 		if (p->saddr.len == new->sv_addr.len &&
4042 		    bcmp(p->saddr.buf, new->sv_addr.buf, p->saddr.len) == 0 &&
4043 		    p->s_thread_exit != NFS4_THREAD_EXIT) {
4044 			np = p;
4045 			mutex_enter(&np->s_lock);
4046 		}
4047 		if (op != NULL && np != NULL)
4048 			break;
4049 	}
4050 	if (op == NULL) {
4051 		/*
4052 		 * Filesystem has been forcibly unmounted.  Bail out.
4053 		 */
4054 		if (np != NULL)
4055 			mutex_exit(&np->s_lock);
4056 		mutex_exit(&nfs4_server_lst_lock);
4057 		return (NULL);
4058 	}
4059 	if (np != NULL) {
4060 		np->s_refcnt++;
4061 	} else {
4062 #ifdef DEBUG
4063 		NFS4_DEBUG(nfs4_client_failover_debug, (CE_NOTE,
4064 		    "nfs4_move_mi: no target nfs4_server, will create."));
4065 #endif
4066 		np = add_new_nfs4_server(new, kcred);
4067 	}
4068 	mutex_exit(&nfs4_server_lst_lock);
4069 
4070 	NFS4_DEBUG(nfs4_client_failover_debug, (CE_NOTE,
4071 	    "nfs4_move_mi: for mi 0x%p, "
4072 	    "old servinfo4 0x%p, new servinfo4 0x%p, "
4073 	    "old nfs4_server 0x%p, new nfs4_server 0x%p, ",
4074 	    (void*)mi, (void*)old, (void*)new,
4075 	    (void*)op, (void*)np));
4076 	ASSERT(op != NULL && np != NULL);
4077 
4078 	/* discard any delegations */
4079 	nfs4_deleg_discard(mi, op);
4080 
4081 	num_open = mi->mi_open_files;
4082 	mi->mi_open_files = 0;
4083 	op->state_ref_count -= num_open;
4084 	ASSERT(op->state_ref_count >= 0);
4085 	np->state_ref_count += num_open;
4086 	nfs4_remove_mi_from_server_nolock(mi, op);
4087 	mi->mi_open_files = num_open;
4088 	NFS4_DEBUG(nfs4_client_failover_debug, (CE_NOTE,
4089 	    "nfs4_move_mi: mi_open_files %d, op->cnt %d, np->cnt %d",
4090 	    mi->mi_open_files, op->state_ref_count, np->state_ref_count));
4091 
4092 	nfs4_add_mi_to_server(np, mi);
4093 
4094 	mutex_exit(&op->s_lock);
4095 	mutex_exit(&np->s_lock);
4096 	nfs4_server_rele(op);
4097 
4098 	return (np);
4099 }
4100 
4101 /*
4102  * Need to have the nfs4_server_lst_lock.
4103  * Search the nfs4_server list to find a match on this servinfo4
4104  * based on its address.
4105  *
4106  * Returns NULL if no match is found.  Otherwise returns a reference (which
4107  * must eventually be freed) to a locked nfs4_server.
4108  */
4109 nfs4_server_t *
4110 servinfo4_to_nfs4_server(servinfo4_t *srv_p)
4111 {
4112 	nfs4_server_t *np;
4113 	zoneid_t zoneid = nfs_zoneid();
4114 
4115 	ASSERT(MUTEX_HELD(&nfs4_server_lst_lock));
4116 	for (np = nfs4_server_lst.forw; np != &nfs4_server_lst; np = np->forw) {
4117 		if (np->zoneid == zoneid &&
4118 		    np->saddr.len == srv_p->sv_addr.len &&
4119 		    bcmp(np->saddr.buf, srv_p->sv_addr.buf,
4120 		    np->saddr.len) == 0 &&
4121 		    np->s_thread_exit != NFS4_THREAD_EXIT) {
4122 			mutex_enter(&np->s_lock);
4123 			np->s_refcnt++;
4124 			return (np);
4125 		}
4126 	}
4127 	return (NULL);
4128 }
4129 
4130 /*
4131  * Locks the nfs4_server down if it is found and returns a reference that
4132  * must eventually be freed.
4133  */
4134 static nfs4_server_t *
4135 lookup_nfs4_server(nfs4_server_t *sp, int any_state)
4136 {
4137 	nfs4_server_t *np;
4138 
4139 	mutex_enter(&nfs4_server_lst_lock);
4140 	for (np = nfs4_server_lst.forw; np != &nfs4_server_lst; np = np->forw) {
4141 		mutex_enter(&np->s_lock);
4142 		if (np == sp && np->s_refcnt > 0 &&
4143 		    (np->s_thread_exit != NFS4_THREAD_EXIT || any_state)) {
4144 			mutex_exit(&nfs4_server_lst_lock);
4145 			np->s_refcnt++;
4146 			return (np);
4147 		}
4148 		mutex_exit(&np->s_lock);
4149 	}
4150 	mutex_exit(&nfs4_server_lst_lock);
4151 
4152 	return (NULL);
4153 }
4154 
4155 /*
4156  * The caller should be holding mi->mi_recovlock, and it should continue to
4157  * hold the lock until done with the returned nfs4_server_t.  Once
4158  * mi->mi_recovlock is released, there is no guarantee that the returned
4159  * mi->nfs4_server_t will continue to correspond to mi.
4160  */
4161 nfs4_server_t *
4162 find_nfs4_server(mntinfo4_t *mi)
4163 {
4164 	ASSERT(nfs_rw_lock_held(&mi->mi_recovlock, RW_READER) ||
4165 	    nfs_rw_lock_held(&mi->mi_recovlock, RW_WRITER));
4166 
4167 	return (lookup_nfs4_server(mi->mi_srv, 0));
4168 }
4169 
4170 /*
4171  * Same as above, but takes an "any_state" parameter which can be
4172  * set to 1 if the caller wishes to find nfs4_server_t's which
4173  * have been marked for termination by the exit of the renew
4174  * thread.  This should only be used by operations which are
4175  * cleaning up and will not cause an OTW op.
4176  */
4177 nfs4_server_t *
4178 find_nfs4_server_all(mntinfo4_t *mi, int any_state)
4179 {
4180 	ASSERT(nfs_rw_lock_held(&mi->mi_recovlock, RW_READER) ||
4181 	    nfs_rw_lock_held(&mi->mi_recovlock, RW_WRITER));
4182 
4183 	return (lookup_nfs4_server(mi->mi_srv, any_state));
4184 }
4185 
4186 /*
4187  * Lock sp, but only if it's still active (in the list and hasn't been
4188  * flagged as exiting) or 'any_state' is non-zero.
4189  * Returns TRUE if sp got locked and adds a reference to sp.
4190  */
4191 bool_t
4192 nfs4_server_vlock(nfs4_server_t *sp, int any_state)
4193 {
4194 	return (lookup_nfs4_server(sp, any_state) != NULL);
4195 }
4196 
4197 /*
4198  * Release the reference to sp and destroy it if that's the last one.
4199  */
4200 
4201 void
4202 nfs4_server_rele(nfs4_server_t *sp)
4203 {
4204 	mutex_enter(&sp->s_lock);
4205 	ASSERT(sp->s_refcnt > 0);
4206 	sp->s_refcnt--;
4207 	if (sp->s_refcnt > 0) {
4208 		mutex_exit(&sp->s_lock);
4209 		return;
4210 	}
4211 	mutex_exit(&sp->s_lock);
4212 
4213 	mutex_enter(&nfs4_server_lst_lock);
4214 	mutex_enter(&sp->s_lock);
4215 	if (sp->s_refcnt > 0) {
4216 		mutex_exit(&sp->s_lock);
4217 		mutex_exit(&nfs4_server_lst_lock);
4218 		return;
4219 	}
4220 	remque(sp);
4221 	sp->forw = sp->back = NULL;
4222 	mutex_exit(&nfs4_server_lst_lock);
4223 	destroy_nfs4_server(sp);
4224 }
4225 
4226 static void
4227 destroy_nfs4_server(nfs4_server_t *sp)
4228 {
4229 	ASSERT(MUTEX_HELD(&sp->s_lock));
4230 	ASSERT(sp->s_refcnt == 0);
4231 	ASSERT(sp->s_otw_call_count == 0);
4232 
4233 	remove_all_mi(sp);
4234 
4235 	crfree(sp->s_cred);
4236 	kmem_free(sp->saddr.buf, sp->saddr.maxlen);
4237 	kmem_free(sp->clidtosend.id_val, sp->clidtosend.id_len);
4238 	mutex_exit(&sp->s_lock);
4239 
4240 	/* destroy the nfs4_server */
4241 	nfs4callback_destroy(sp);
4242 	list_destroy(&sp->s_deleg_list);
4243 	mutex_destroy(&sp->s_lock);
4244 	cv_destroy(&sp->cv_thread_exit);
4245 	cv_destroy(&sp->s_cv_otw_count);
4246 	cv_destroy(&sp->s_clientid_pend);
4247 	cv_destroy(&sp->wait_cb_null);
4248 	nfs_rw_destroy(&sp->s_recovlock);
4249 	kmem_free(sp, sizeof (*sp));
4250 }
4251 
4252 /*
4253  * Fork off a thread to free the data structures for a mount.
4254  */
4255 
4256 static void
4257 async_free_mount(vfs_t *vfsp, int flag, cred_t *cr)
4258 {
4259 	freemountargs_t *args;
4260 	args = kmem_alloc(sizeof (freemountargs_t), KM_SLEEP);
4261 	args->fm_vfsp = vfsp;
4262 	VFS_HOLD(vfsp);
4263 	MI4_HOLD(VFTOMI4(vfsp));
4264 	args->fm_flag = flag;
4265 	args->fm_cr = cr;
4266 	crhold(cr);
4267 	(void) zthread_create(NULL, 0, nfs4_free_mount_thread, args, 0,
4268 	    minclsyspri);
4269 }
4270 
4271 static void
4272 nfs4_free_mount_thread(freemountargs_t *args)
4273 {
4274 	mntinfo4_t *mi;
4275 	nfs4_free_mount(args->fm_vfsp, args->fm_flag, args->fm_cr);
4276 	mi = VFTOMI4(args->fm_vfsp);
4277 	crfree(args->fm_cr);
4278 	VFS_RELE(args->fm_vfsp);
4279 	MI4_RELE(mi);
4280 	kmem_free(args, sizeof (freemountargs_t));
4281 	zthread_exit();
4282 	/* NOTREACHED */
4283 }
4284 
4285 /*
4286  * Thread to free the data structures for a given filesystem.
4287  */
4288 static void
4289 nfs4_free_mount(vfs_t *vfsp, int flag, cred_t *cr)
4290 {
4291 	mntinfo4_t		*mi = VFTOMI4(vfsp);
4292 	nfs4_server_t		*sp;
4293 	callb_cpr_t		cpr_info;
4294 	kmutex_t		cpr_lock;
4295 	boolean_t		async_thread;
4296 	int			removed;
4297 
4298 	bool_t			must_unlock;
4299 	nfs4_ephemeral_tree_t	*eph_tree;
4300 
4301 	/*
4302 	 * We need to participate in the CPR framework if this is a kernel
4303 	 * thread.
4304 	 */
4305 	async_thread = (curproc == nfs_zone()->zone_zsched);
4306 	if (async_thread) {
4307 		mutex_init(&cpr_lock, NULL, MUTEX_DEFAULT, NULL);
4308 		CALLB_CPR_INIT(&cpr_info, &cpr_lock, callb_generic_cpr,
4309 		    "nfsv4AsyncUnmount");
4310 	}
4311 
4312 	/*
4313 	 * We need to wait for all outstanding OTW calls
4314 	 * and recovery to finish before we remove the mi
4315 	 * from the nfs4_server_t, as current pending
4316 	 * calls might still need this linkage (in order
4317 	 * to find a nfs4_server_t from a mntinfo4_t).
4318 	 */
4319 	(void) nfs_rw_enter_sig(&mi->mi_recovlock, RW_READER, FALSE);
4320 	sp = find_nfs4_server(mi);
4321 	nfs_rw_exit(&mi->mi_recovlock);
4322 
4323 	if (sp) {
4324 		while (sp->s_otw_call_count != 0) {
4325 			if (async_thread) {
4326 				mutex_enter(&cpr_lock);
4327 				CALLB_CPR_SAFE_BEGIN(&cpr_info);
4328 				mutex_exit(&cpr_lock);
4329 			}
4330 			cv_wait(&sp->s_cv_otw_count, &sp->s_lock);
4331 			if (async_thread) {
4332 				mutex_enter(&cpr_lock);
4333 				CALLB_CPR_SAFE_END(&cpr_info, &cpr_lock);
4334 				mutex_exit(&cpr_lock);
4335 			}
4336 		}
4337 		mutex_exit(&sp->s_lock);
4338 		nfs4_server_rele(sp);
4339 		sp = NULL;
4340 	}
4341 
4342 	mutex_enter(&mi->mi_lock);
4343 	while (mi->mi_in_recovery != 0) {
4344 		if (async_thread) {
4345 			mutex_enter(&cpr_lock);
4346 			CALLB_CPR_SAFE_BEGIN(&cpr_info);
4347 			mutex_exit(&cpr_lock);
4348 		}
4349 		cv_wait(&mi->mi_cv_in_recov, &mi->mi_lock);
4350 		if (async_thread) {
4351 			mutex_enter(&cpr_lock);
4352 			CALLB_CPR_SAFE_END(&cpr_info, &cpr_lock);
4353 			mutex_exit(&cpr_lock);
4354 		}
4355 	}
4356 	mutex_exit(&mi->mi_lock);
4357 
4358 	/*
4359 	 * If we got an error, then do not nuke the
4360 	 * tree. Either the harvester is busy reclaiming
4361 	 * this node or we ran into some busy condition.
4362 	 *
4363 	 * The harvester will eventually come along and cleanup.
4364 	 * The only problem would be the root mount point.
4365 	 *
4366 	 * Since the busy node can occur for a variety
4367 	 * of reasons and can result in an entry staying
4368 	 * in df output but no longer accessible from the
4369 	 * directory tree, we are okay.
4370 	 */
4371 	if (!nfs4_ephemeral_umount(mi, flag, cr,
4372 	    &must_unlock, &eph_tree))
4373 		nfs4_ephemeral_umount_activate(mi, &must_unlock,
4374 		    &eph_tree);
4375 
4376 	/*
4377 	 * The original purge of the dnlc via 'dounmount'
4378 	 * doesn't guarantee that another dnlc entry was not
4379 	 * added while we waitied for all outstanding OTW
4380 	 * and recovery calls to finish.  So re-purge the
4381 	 * dnlc now.
4382 	 */
4383 	(void) dnlc_purge_vfsp(vfsp, 0);
4384 
4385 	/*
4386 	 * We need to explicitly stop the manager thread; the asyc worker
4387 	 * threads can timeout and exit on their own.
4388 	 */
4389 	mutex_enter(&mi->mi_async_lock);
4390 	mi->mi_max_threads = 0;
4391 	NFS4_WAKEALL_ASYNC_WORKERS(mi->mi_async_work_cv);
4392 	mutex_exit(&mi->mi_async_lock);
4393 	if (mi->mi_manager_thread)
4394 		nfs4_async_manager_stop(vfsp);
4395 
4396 	destroy_rtable4(vfsp, cr);
4397 
4398 	nfs4_remove_mi_from_server(mi, NULL);
4399 
4400 	if (async_thread) {
4401 		mutex_enter(&cpr_lock);
4402 		CALLB_CPR_EXIT(&cpr_info);	/* drops cpr_lock */
4403 		mutex_destroy(&cpr_lock);
4404 	}
4405 
4406 	removed = nfs4_mi_zonelist_remove(mi);
4407 	if (removed)
4408 		zone_rele_ref(&mi->mi_zone_ref, ZONE_REF_NFSV4);
4409 }
4410 
4411 /* Referral related sub-routines */
4412 
4413 /* Freeup knetconfig */
4414 static void
4415 free_knconf_contents(struct knetconfig *k)
4416 {
4417 	if (k == NULL)
4418 		return;
4419 	if (k->knc_protofmly)
4420 		kmem_free(k->knc_protofmly, KNC_STRSIZE);
4421 	if (k->knc_proto)
4422 		kmem_free(k->knc_proto, KNC_STRSIZE);
4423 }
4424 
4425 /*
4426  * This updates newpath variable with exact name component from the
4427  * path which gave us a NFS4ERR_MOVED error.
4428  * If the path is /rp/aaa/bbb and nth value is 1, aaa is returned.
4429  */
4430 static char *
4431 extract_referral_point(const char *svp, int nth)
4432 {
4433 	int num_slashes = 0;
4434 	const char *p;
4435 	char *newpath = NULL;
4436 	int i = 0;
4437 
4438 	newpath = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
4439 	for (p = svp; *p; p++) {
4440 		if (*p == '/')
4441 			num_slashes++;
4442 		if (num_slashes == nth + 1) {
4443 			p++;
4444 			while (*p != '/') {
4445 				if (*p == '\0')
4446 					break;
4447 				newpath[i] = *p;
4448 				i++;
4449 				p++;
4450 			}
4451 			newpath[i++] = '\0';
4452 			break;
4453 		}
4454 	}
4455 	return (newpath);
4456 }
4457 
4458 /*
4459  * This sets up a new path in sv_path to do a lookup of the referral point.
4460  * If the path is /rp/aaa/bbb and the referral point is aaa,
4461  * this updates /rp/aaa. This path will be used to get referral
4462  * location.
4463  */
4464 static void
4465 setup_newsvpath(servinfo4_t *svp, int nth)
4466 {
4467 	int num_slashes = 0, pathlen, i = 0;
4468 	char *newpath, *p;
4469 
4470 	newpath = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
4471 	for (p = svp->sv_path; *p; p++) {
4472 		newpath[i] =  *p;
4473 		if (*p == '/')
4474 			num_slashes++;
4475 		if (num_slashes == nth + 1) {
4476 			newpath[i] = '\0';
4477 			pathlen = strlen(newpath) + 1;
4478 			kmem_free(svp->sv_path, svp->sv_pathlen);
4479 			svp->sv_path = kmem_alloc(pathlen, KM_SLEEP);
4480 			svp->sv_pathlen = pathlen;
4481 			bcopy(newpath, svp->sv_path, pathlen);
4482 			break;
4483 		}
4484 		i++;
4485 	}
4486 	kmem_free(newpath, MAXPATHLEN);
4487 }
4488