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 /*
23  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
24  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
25  */
26 
27 /*
28  *	Copyright (c) 1983,1984,1985,1986,1987,1988,1989  AT&T.
29  *	All Rights Reserved
30  */
31 
32 #include <sys/param.h>
33 #include <sys/types.h>
34 #include <sys/systm.h>
35 #include <sys/cred.h>
36 #include <sys/vfs.h>
37 #include <sys/vfs_opreg.h>
38 #include <sys/vnode.h>
39 #include <sys/pathname.h>
40 #include <sys/sysmacros.h>
41 #include <sys/kmem.h>
42 #include <sys/mkdev.h>
43 #include <sys/mount.h>
44 #include <sys/statvfs.h>
45 #include <sys/errno.h>
46 #include <sys/debug.h>
47 #include <sys/cmn_err.h>
48 #include <sys/utsname.h>
49 #include <sys/bootconf.h>
50 #include <sys/modctl.h>
51 #include <sys/acl.h>
52 #include <sys/flock.h>
53 #include <sys/time.h>
54 #include <sys/disp.h>
55 #include <sys/policy.h>
56 #include <sys/socket.h>
57 #include <sys/netconfig.h>
58 #include <sys/dnlc.h>
59 #include <sys/list.h>
60 #include <sys/mntent.h>
61 #include <sys/tsol/label.h>
62 
63 #include <rpc/types.h>
64 #include <rpc/auth.h>
65 #include <rpc/rpcsec_gss.h>
66 #include <rpc/clnt.h>
67 
68 #include <nfs/nfs.h>
69 #include <nfs/nfs_clnt.h>
70 #include <nfs/mount.h>
71 #include <nfs/nfs_acl.h>
72 
73 #include <fs/fs_subr.h>
74 
75 #include <nfs/nfs4.h>
76 #include <nfs/rnode4.h>
77 #include <nfs/nfs4_clnt.h>
78 #include <sys/fs/autofs.h>
79 
80 #include <sys/sdt.h>
81 
82 
83 /*
84  * Arguments passed to thread to free data structures from forced unmount.
85  */
86 
87 typedef struct {
88 	vfs_t	*fm_vfsp;
89 	int	fm_flag;
90 	cred_t	*fm_cr;
91 } freemountargs_t;
92 
93 static void	async_free_mount(vfs_t *, int, cred_t *);
94 static void	nfs4_free_mount(vfs_t *, int, cred_t *);
95 static void	nfs4_free_mount_thread(freemountargs_t *);
96 static int nfs4_chkdup_servinfo4(servinfo4_t *, servinfo4_t *);
97 
98 /*
99  * From rpcsec module (common/rpcsec).
100  */
101 extern int sec_clnt_loadinfo(struct sec_data *, struct sec_data **, model_t);
102 extern void sec_clnt_freeinfo(struct sec_data *);
103 
104 /*
105  * The order and contents of this structure must be kept in sync with that of
106  * rfsreqcnt_v4_tmpl in nfs_stats.c
107  */
108 static char *rfsnames_v4[] = {
109 	"null", "compound", "reserved",	"access", "close", "commit", "create",
110 	"delegpurge", "delegreturn", "getattr",	"getfh", "link", "lock",
111 	"lockt", "locku", "lookup", "lookupp", "nverify", "open", "openattr",
112 	"open_confirm",	"open_downgrade", "putfh", "putpubfh", "putrootfh",
113 	"read", "readdir", "readlink", "remove", "rename", "renew",
114 	"restorefh", "savefh", "secinfo", "setattr", "setclientid",
115 	"setclientid_confirm", "verify", "write"
116 };
117 
118 /*
119  * nfs4_max_mount_retry is the number of times the client will redrive
120  * a mount compound before giving up and returning failure.  The intent
121  * is to redrive mount compounds which fail NFS4ERR_STALE so that
122  * if a component of the server path being mounted goes stale, it can
123  * "recover" by redriving the mount compund (LOOKUP ops).  This recovery
124  * code is needed outside of the recovery framework because mount is a
125  * special case.  The client doesn't create vnodes/rnodes for components
126  * of the server path being mounted.  The recovery code recovers real
127  * client objects, not STALE FHs which map to components of the server
128  * path being mounted.
129  *
130  * We could just fail the mount on the first time, but that would
131  * instantly trigger failover (from nfs4_mount), and the client should
132  * try to re-lookup the STALE FH before doing failover.  The easiest
133  * way to "re-lookup" is to simply redrive the mount compound.
134  */
135 static int nfs4_max_mount_retry = 2;
136 
137 /*
138  * nfs4 vfs operations.
139  */
140 int		nfs4_mount(vfs_t *, vnode_t *, struct mounta *, cred_t *);
141 static int	nfs4_unmount(vfs_t *, int, cred_t *);
142 static int	nfs4_root(vfs_t *, vnode_t **);
143 static int	nfs4_statvfs(vfs_t *, struct statvfs64 *);
144 static int	nfs4_sync(vfs_t *, short, cred_t *);
145 static int	nfs4_vget(vfs_t *, vnode_t **, fid_t *);
146 static int	nfs4_mountroot(vfs_t *, whymountroot_t);
147 static void	nfs4_freevfs(vfs_t *);
148 
149 static int	nfs4rootvp(vnode_t **, vfs_t *, struct servinfo4 *,
150 		    int, cred_t *, zone_t *);
151 
152 vfsops_t	*nfs4_vfsops;
153 
154 int nfs4_vfsinit(void);
155 void nfs4_vfsfini(void);
156 static void nfs4setclientid_init(void);
157 static void nfs4setclientid_fini(void);
158 static void nfs4setclientid_otw(mntinfo4_t *, servinfo4_t *,  cred_t *,
159 		struct nfs4_server *, nfs4_error_t *, int *);
160 static void	destroy_nfs4_server(nfs4_server_t *);
161 static void	remove_mi(nfs4_server_t *, mntinfo4_t *);
162 
163 extern void nfs4_ephemeral_init(void);
164 extern void nfs4_ephemeral_fini(void);
165 
166 /* referral related routines */
167 static servinfo4_t *copy_svp(servinfo4_t *);
168 static void free_knconf_contents(struct knetconfig *k);
169 static char *extract_referral_point(const char *, int);
170 static void setup_newsvpath(servinfo4_t *, int);
171 static void update_servinfo4(servinfo4_t *, fs_location4 *,
172 		struct nfs_fsl_info *, char *, int);
173 
174 /*
175  * Initialize the vfs structure
176  */
177 
178 static int nfs4fstyp;
179 
180 
181 /*
182  * Debug variable to check for rdma based
183  * transport startup and cleanup. Controlled
184  * through /etc/system. Off by default.
185  */
186 extern int rdma_debug;
187 
188 int
nfs4init(int fstyp,char * name)189 nfs4init(int fstyp, char *name)
190 {
191 	static const fs_operation_def_t nfs4_vfsops_template[] = {
192 		VFSNAME_MOUNT,		{ .vfs_mount = nfs4_mount },
193 		VFSNAME_UNMOUNT,	{ .vfs_unmount = nfs4_unmount },
194 		VFSNAME_ROOT,		{ .vfs_root = nfs4_root },
195 		VFSNAME_STATVFS,	{ .vfs_statvfs = nfs4_statvfs },
196 		VFSNAME_SYNC,		{ .vfs_sync = nfs4_sync },
197 		VFSNAME_VGET,		{ .vfs_vget = nfs4_vget },
198 		VFSNAME_MOUNTROOT,	{ .vfs_mountroot = nfs4_mountroot },
199 		VFSNAME_FREEVFS,	{ .vfs_freevfs = nfs4_freevfs },
200 		NULL,			NULL
201 	};
202 	int error;
203 
204 	nfs4_vfsops = NULL;
205 	nfs4_vnodeops = NULL;
206 	nfs4_trigger_vnodeops = NULL;
207 
208 	error = vfs_setfsops(fstyp, nfs4_vfsops_template, &nfs4_vfsops);
209 	if (error != 0) {
210 		zcmn_err(GLOBAL_ZONEID, CE_WARN,
211 		    "nfs4init: bad vfs ops template");
212 		goto out;
213 	}
214 
215 	error = vn_make_ops(name, nfs4_vnodeops_template, &nfs4_vnodeops);
216 	if (error != 0) {
217 		zcmn_err(GLOBAL_ZONEID, CE_WARN,
218 		    "nfs4init: bad vnode ops template");
219 		goto out;
220 	}
221 
222 	error = vn_make_ops("nfs4_trigger", nfs4_trigger_vnodeops_template,
223 	    &nfs4_trigger_vnodeops);
224 	if (error != 0) {
225 		zcmn_err(GLOBAL_ZONEID, CE_WARN,
226 		    "nfs4init: bad trigger vnode ops template");
227 		goto out;
228 	}
229 
230 	nfs4fstyp = fstyp;
231 	(void) nfs4_vfsinit();
232 	(void) nfs4_init_dot_entries();
233 
234 out:
235 	if (error) {
236 		if (nfs4_trigger_vnodeops != NULL)
237 			vn_freevnodeops(nfs4_trigger_vnodeops);
238 
239 		if (nfs4_vnodeops != NULL)
240 			vn_freevnodeops(nfs4_vnodeops);
241 
242 		(void) vfs_freevfsops_by_type(fstyp);
243 	}
244 
245 	return (error);
246 }
247 
248 void
nfs4fini(void)249 nfs4fini(void)
250 {
251 	(void) nfs4_destroy_dot_entries();
252 	nfs4_vfsfini();
253 }
254 
255 /*
256  * Create a new sec_data structure to store AUTH_DH related data:
257  * netname, syncaddr, knetconfig. There is no AUTH_F_RPCTIMESYNC
258  * flag set for NFS V4 since we are avoiding to contact the rpcbind
259  * daemon and is using the IP time service (IPPORT_TIMESERVER).
260  *
261  * sec_data can be freed by sec_clnt_freeinfo().
262  */
263 static struct sec_data *
create_authdh_data(char * netname,int nlen,struct netbuf * syncaddr,struct knetconfig * knconf)264 create_authdh_data(char *netname, int nlen, struct netbuf *syncaddr,
265     struct knetconfig *knconf)
266 {
267 	struct sec_data *secdata;
268 	dh_k4_clntdata_t *data;
269 	char *pf, *p;
270 
271 	if (syncaddr == NULL || syncaddr->buf == NULL || nlen == 0)
272 		return (NULL);
273 
274 	secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP);
275 	secdata->flags = 0;
276 
277 	data = kmem_alloc(sizeof (*data), KM_SLEEP);
278 
279 	data->syncaddr.maxlen = syncaddr->maxlen;
280 	data->syncaddr.len = syncaddr->len;
281 	data->syncaddr.buf = (char *)kmem_alloc(syncaddr->len, KM_SLEEP);
282 	bcopy(syncaddr->buf, data->syncaddr.buf, syncaddr->len);
283 
284 	/*
285 	 * duplicate the knconf information for the
286 	 * new opaque data.
287 	 */
288 	data->knconf = kmem_alloc(sizeof (*knconf), KM_SLEEP);
289 	*data->knconf = *knconf;
290 	pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
291 	p = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
292 	bcopy(knconf->knc_protofmly, pf, KNC_STRSIZE);
293 	bcopy(knconf->knc_proto, p, KNC_STRSIZE);
294 	data->knconf->knc_protofmly = pf;
295 	data->knconf->knc_proto = p;
296 
297 	/* move server netname to the sec_data structure */
298 	data->netname = kmem_alloc(nlen, KM_SLEEP);
299 	bcopy(netname, data->netname, nlen);
300 	data->netnamelen = (int)nlen;
301 
302 	secdata->secmod = AUTH_DH;
303 	secdata->rpcflavor = AUTH_DH;
304 	secdata->data = (caddr_t)data;
305 
306 	return (secdata);
307 }
308 
309 /*
310  * Returns (deep) copy of sec_data_t. Allocates all memory required; caller
311  * is responsible for freeing.
312  */
313 sec_data_t *
copy_sec_data(sec_data_t * fsecdata)314 copy_sec_data(sec_data_t *fsecdata)
315 {
316 	sec_data_t *tsecdata;
317 
318 	if (fsecdata == NULL)
319 		return (NULL);
320 
321 	if (fsecdata->rpcflavor == AUTH_DH) {
322 		dh_k4_clntdata_t *fdata = (dh_k4_clntdata_t *)fsecdata->data;
323 
324 		if (fdata == NULL)
325 			return (NULL);
326 
327 		tsecdata = (sec_data_t *)create_authdh_data(fdata->netname,
328 		    fdata->netnamelen, &fdata->syncaddr, fdata->knconf);
329 
330 		return (tsecdata);
331 	}
332 
333 	tsecdata = kmem_zalloc(sizeof (sec_data_t), KM_SLEEP);
334 
335 	tsecdata->secmod = fsecdata->secmod;
336 	tsecdata->rpcflavor = fsecdata->rpcflavor;
337 	tsecdata->flags = fsecdata->flags;
338 	tsecdata->uid = fsecdata->uid;
339 
340 	if (fsecdata->rpcflavor == RPCSEC_GSS) {
341 		gss_clntdata_t *gcd = (gss_clntdata_t *)fsecdata->data;
342 
343 		tsecdata->data = (caddr_t)copy_sec_data_gss(gcd);
344 	} else {
345 		tsecdata->data = NULL;
346 	}
347 
348 	return (tsecdata);
349 }
350 
351 gss_clntdata_t *
copy_sec_data_gss(gss_clntdata_t * fdata)352 copy_sec_data_gss(gss_clntdata_t *fdata)
353 {
354 	gss_clntdata_t *tdata;
355 
356 	if (fdata == NULL)
357 		return (NULL);
358 
359 	tdata = kmem_zalloc(sizeof (gss_clntdata_t), KM_SLEEP);
360 
361 	tdata->mechanism.length = fdata->mechanism.length;
362 	tdata->mechanism.elements = kmem_zalloc(fdata->mechanism.length,
363 	    KM_SLEEP);
364 	bcopy(fdata->mechanism.elements, tdata->mechanism.elements,
365 	    fdata->mechanism.length);
366 
367 	tdata->service = fdata->service;
368 
369 	(void) strcpy(tdata->uname, fdata->uname);
370 	(void) strcpy(tdata->inst, fdata->inst);
371 	(void) strcpy(tdata->realm, fdata->realm);
372 
373 	tdata->qop = fdata->qop;
374 
375 	return (tdata);
376 }
377 
378 static int
nfs4_chkdup_servinfo4(servinfo4_t * svp_head,servinfo4_t * svp)379 nfs4_chkdup_servinfo4(servinfo4_t *svp_head, servinfo4_t *svp)
380 {
381 	servinfo4_t *si;
382 
383 	/*
384 	 * Iterate over the servinfo4 list to make sure
385 	 * we do not have a duplicate. Skip any servinfo4
386 	 * that has been marked "NOT IN USE"
387 	 */
388 	for (si = svp_head; si; si = si->sv_next) {
389 		(void) nfs_rw_enter_sig(&si->sv_lock, RW_READER, 0);
390 		if (si->sv_flags & SV4_NOTINUSE) {
391 			nfs_rw_exit(&si->sv_lock);
392 			continue;
393 		}
394 		nfs_rw_exit(&si->sv_lock);
395 		if (si == svp)
396 			continue;
397 		if (si->sv_addr.len == svp->sv_addr.len &&
398 		    strcmp(si->sv_knconf->knc_protofmly,
399 		    svp->sv_knconf->knc_protofmly) == 0 &&
400 		    bcmp(si->sv_addr.buf, svp->sv_addr.buf,
401 		    si->sv_addr.len) == 0) {
402 			/* it's a duplicate */
403 			return (1);
404 		}
405 	}
406 	/* it's not a duplicate */
407 	return (0);
408 }
409 
410 void
nfs4_free_args(struct nfs_args * nargs)411 nfs4_free_args(struct nfs_args *nargs)
412 {
413 	if (nargs->knconf) {
414 		if (nargs->knconf->knc_protofmly)
415 			kmem_free(nargs->knconf->knc_protofmly,
416 			    KNC_STRSIZE);
417 		if (nargs->knconf->knc_proto)
418 			kmem_free(nargs->knconf->knc_proto, KNC_STRSIZE);
419 		kmem_free(nargs->knconf, sizeof (*nargs->knconf));
420 		nargs->knconf = NULL;
421 	}
422 
423 	if (nargs->fh) {
424 		kmem_free(nargs->fh, strlen(nargs->fh) + 1);
425 		nargs->fh = NULL;
426 	}
427 
428 	if (nargs->hostname) {
429 		kmem_free(nargs->hostname, strlen(nargs->hostname) + 1);
430 		nargs->hostname = NULL;
431 	}
432 
433 	if (nargs->addr) {
434 		if (nargs->addr->buf) {
435 			ASSERT(nargs->addr->len);
436 			kmem_free(nargs->addr->buf, nargs->addr->len);
437 		}
438 		kmem_free(nargs->addr, sizeof (struct netbuf));
439 		nargs->addr = NULL;
440 	}
441 
442 	if (nargs->syncaddr) {
443 		ASSERT(nargs->syncaddr->len);
444 		if (nargs->syncaddr->buf) {
445 			ASSERT(nargs->syncaddr->len);
446 			kmem_free(nargs->syncaddr->buf, nargs->syncaddr->len);
447 		}
448 		kmem_free(nargs->syncaddr, sizeof (struct netbuf));
449 		nargs->syncaddr = NULL;
450 	}
451 
452 	if (nargs->netname) {
453 		kmem_free(nargs->netname, strlen(nargs->netname) + 1);
454 		nargs->netname = NULL;
455 	}
456 
457 	if (nargs->nfs_ext_u.nfs_extA.secdata) {
458 		sec_clnt_freeinfo(
459 		    nargs->nfs_ext_u.nfs_extA.secdata);
460 		nargs->nfs_ext_u.nfs_extA.secdata = NULL;
461 	}
462 }
463 
464 
465 int
nfs4_copyin(char * data,int datalen,struct nfs_args * nargs)466 nfs4_copyin(char *data, int datalen, struct nfs_args *nargs)
467 {
468 
469 	int error;
470 	size_t hlen;			/* length of hostname */
471 	size_t nlen;			/* length of netname */
472 	char netname[MAXNETNAMELEN+1];	/* server's netname */
473 	struct netbuf addr;		/* server's address */
474 	struct netbuf syncaddr;		/* AUTH_DES time sync addr */
475 	struct knetconfig *knconf;		/* transport structure */
476 	struct sec_data *secdata = NULL;	/* security data */
477 	STRUCT_DECL(nfs_args, args);		/* nfs mount arguments */
478 	STRUCT_DECL(knetconfig, knconf_tmp);
479 	STRUCT_DECL(netbuf, addr_tmp);
480 	int flags;
481 	char *p, *pf;
482 	struct pathname pn;
483 	char *userbufptr;
484 
485 
486 	bzero(nargs, sizeof (*nargs));
487 
488 	STRUCT_INIT(args, get_udatamodel());
489 	bzero(STRUCT_BUF(args), SIZEOF_STRUCT(nfs_args, DATAMODEL_NATIVE));
490 	if (copyin(data, STRUCT_BUF(args), MIN(datalen,
491 	    STRUCT_SIZE(args))))
492 		return (EFAULT);
493 
494 	nargs->wsize = STRUCT_FGET(args, wsize);
495 	nargs->rsize = STRUCT_FGET(args, rsize);
496 	nargs->timeo = STRUCT_FGET(args, timeo);
497 	nargs->retrans = STRUCT_FGET(args, retrans);
498 	nargs->acregmin = STRUCT_FGET(args, acregmin);
499 	nargs->acregmax = STRUCT_FGET(args, acregmax);
500 	nargs->acdirmin = STRUCT_FGET(args, acdirmin);
501 	nargs->acdirmax = STRUCT_FGET(args, acdirmax);
502 
503 	flags = STRUCT_FGET(args, flags);
504 	nargs->flags = flags;
505 
506 	addr.buf = NULL;
507 	syncaddr.buf = NULL;
508 
509 
510 	/*
511 	 * Allocate space for a knetconfig structure and
512 	 * its strings and copy in from user-land.
513 	 */
514 	knconf = kmem_zalloc(sizeof (*knconf), KM_SLEEP);
515 	STRUCT_INIT(knconf_tmp, get_udatamodel());
516 	if (copyin(STRUCT_FGETP(args, knconf), STRUCT_BUF(knconf_tmp),
517 	    STRUCT_SIZE(knconf_tmp))) {
518 		kmem_free(knconf, sizeof (*knconf));
519 		return (EFAULT);
520 	}
521 
522 	knconf->knc_semantics = STRUCT_FGET(knconf_tmp, knc_semantics);
523 	knconf->knc_protofmly = STRUCT_FGETP(knconf_tmp, knc_protofmly);
524 	knconf->knc_proto = STRUCT_FGETP(knconf_tmp, knc_proto);
525 	if (get_udatamodel() != DATAMODEL_LP64) {
526 		knconf->knc_rdev = expldev(STRUCT_FGET(knconf_tmp, knc_rdev));
527 	} else {
528 		knconf->knc_rdev = STRUCT_FGET(knconf_tmp, knc_rdev);
529 	}
530 
531 	pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
532 	p = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
533 	error = copyinstr(knconf->knc_protofmly, pf, KNC_STRSIZE, NULL);
534 	if (error) {
535 		kmem_free(pf, KNC_STRSIZE);
536 		kmem_free(p, KNC_STRSIZE);
537 		kmem_free(knconf, sizeof (*knconf));
538 		return (error);
539 	}
540 
541 	error = copyinstr(knconf->knc_proto, p, KNC_STRSIZE, NULL);
542 	if (error) {
543 		kmem_free(pf, KNC_STRSIZE);
544 		kmem_free(p, KNC_STRSIZE);
545 		kmem_free(knconf, sizeof (*knconf));
546 		return (error);
547 	}
548 
549 
550 	knconf->knc_protofmly = pf;
551 	knconf->knc_proto = p;
552 
553 	nargs->knconf = knconf;
554 
555 	/*
556 	 * Get server address
557 	 */
558 	STRUCT_INIT(addr_tmp, get_udatamodel());
559 	if (copyin(STRUCT_FGETP(args, addr), STRUCT_BUF(addr_tmp),
560 	    STRUCT_SIZE(addr_tmp))) {
561 		error = EFAULT;
562 		goto errout;
563 	}
564 
565 	nargs->addr = kmem_zalloc(sizeof (struct netbuf), KM_SLEEP);
566 	userbufptr = STRUCT_FGETP(addr_tmp, buf);
567 	addr.len = STRUCT_FGET(addr_tmp, len);
568 	addr.buf = kmem_alloc(addr.len, KM_SLEEP);
569 	addr.maxlen = addr.len;
570 	if (copyin(userbufptr, addr.buf, addr.len)) {
571 		kmem_free(addr.buf, addr.len);
572 		error = EFAULT;
573 		goto errout;
574 	}
575 	bcopy(&addr, nargs->addr, sizeof (struct netbuf));
576 
577 	/*
578 	 * Get the root fhandle
579 	 */
580 	error = pn_get(STRUCT_FGETP(args, fh), UIO_USERSPACE, &pn);
581 	if (error)
582 		goto errout;
583 
584 	/* Volatile fh: keep server paths, so use actual-size strings */
585 	nargs->fh = kmem_alloc(pn.pn_pathlen + 1, KM_SLEEP);
586 	bcopy(pn.pn_path, nargs->fh, pn.pn_pathlen);
587 	nargs->fh[pn.pn_pathlen] = '\0';
588 	pn_free(&pn);
589 
590 
591 	/*
592 	 * Get server's hostname
593 	 */
594 	if (flags & NFSMNT_HOSTNAME) {
595 		error = copyinstr(STRUCT_FGETP(args, hostname),
596 		    netname, sizeof (netname), &hlen);
597 		if (error)
598 			goto errout;
599 		nargs->hostname = kmem_zalloc(hlen, KM_SLEEP);
600 		(void) strcpy(nargs->hostname, netname);
601 
602 	} else {
603 		nargs->hostname = NULL;
604 	}
605 
606 
607 	/*
608 	 * If there are syncaddr and netname data, load them in. This is
609 	 * to support data needed for NFSV4 when AUTH_DH is the negotiated
610 	 * flavor via SECINFO. (instead of using MOUNT protocol in V3).
611 	 */
612 	netname[0] = '\0';
613 	if (flags & NFSMNT_SECURE) {
614 
615 		/* get syncaddr */
616 		STRUCT_INIT(addr_tmp, get_udatamodel());
617 		if (copyin(STRUCT_FGETP(args, syncaddr), STRUCT_BUF(addr_tmp),
618 		    STRUCT_SIZE(addr_tmp))) {
619 			error = EINVAL;
620 			goto errout;
621 		}
622 		userbufptr = STRUCT_FGETP(addr_tmp, buf);
623 		syncaddr.len = STRUCT_FGET(addr_tmp, len);
624 		syncaddr.buf = kmem_alloc(syncaddr.len, KM_SLEEP);
625 		syncaddr.maxlen = syncaddr.len;
626 		if (copyin(userbufptr, syncaddr.buf, syncaddr.len)) {
627 			kmem_free(syncaddr.buf, syncaddr.len);
628 			error = EFAULT;
629 			goto errout;
630 		}
631 
632 		nargs->syncaddr = kmem_alloc(sizeof (struct netbuf), KM_SLEEP);
633 		bcopy(&syncaddr, nargs->syncaddr, sizeof (struct netbuf));
634 
635 		/* get server's netname */
636 		if (copyinstr(STRUCT_FGETP(args, netname), netname,
637 		    sizeof (netname), &nlen)) {
638 			error = EFAULT;
639 			goto errout;
640 		}
641 
642 		netname[nlen] = '\0';
643 		nargs->netname = kmem_zalloc(nlen, KM_SLEEP);
644 		(void) strcpy(nargs->netname, netname);
645 	}
646 
647 	/*
648 	 * Get the extention data which has the security data structure.
649 	 * This includes data for AUTH_SYS as well.
650 	 */
651 	if (flags & NFSMNT_NEWARGS) {
652 		nargs->nfs_args_ext = STRUCT_FGET(args, nfs_args_ext);
653 		if (nargs->nfs_args_ext == NFS_ARGS_EXTA ||
654 		    nargs->nfs_args_ext == NFS_ARGS_EXTB) {
655 			/*
656 			 * Indicating the application is using the new
657 			 * sec_data structure to pass in the security
658 			 * data.
659 			 */
660 			if (STRUCT_FGETP(args,
661 			    nfs_ext_u.nfs_extA.secdata) != NULL) {
662 				error = sec_clnt_loadinfo(
663 				    (struct sec_data *)STRUCT_FGETP(args,
664 				    nfs_ext_u.nfs_extA.secdata),
665 				    &secdata, get_udatamodel());
666 			}
667 			nargs->nfs_ext_u.nfs_extA.secdata = secdata;
668 		}
669 	}
670 
671 	if (error)
672 		goto errout;
673 
674 	/*
675 	 * Failover support:
676 	 *
677 	 * We may have a linked list of nfs_args structures,
678 	 * which means the user is looking for failover.  If
679 	 * the mount is either not "read-only" or "soft",
680 	 * we want to bail out with EINVAL.
681 	 */
682 	if (nargs->nfs_args_ext == NFS_ARGS_EXTB)
683 		nargs->nfs_ext_u.nfs_extB.next =
684 		    STRUCT_FGETP(args, nfs_ext_u.nfs_extB.next);
685 
686 errout:
687 	if (error)
688 		nfs4_free_args(nargs);
689 
690 	return (error);
691 }
692 
693 
694 /*
695  * nfs mount vfsop
696  * Set up mount info record and attach it to vfs struct.
697  */
698 int
nfs4_mount(vfs_t * vfsp,vnode_t * mvp,struct mounta * uap,cred_t * cr)699 nfs4_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
700 {
701 	char *data = uap->dataptr;
702 	int error;
703 	vnode_t *rtvp;			/* the server's root */
704 	mntinfo4_t *mi;			/* mount info, pointed at by vfs */
705 	struct knetconfig *rdma_knconf;	/* rdma transport structure */
706 	rnode4_t *rp;
707 	struct servinfo4 *svp;		/* nfs server info */
708 	struct servinfo4 *svp_tail = NULL; /* previous nfs server info */
709 	struct servinfo4 *svp_head;	/* first nfs server info */
710 	struct servinfo4 *svp_2ndlast;	/* 2nd last in server info list */
711 	struct sec_data *secdata;	/* security data */
712 	struct nfs_args *args = NULL;
713 	int flags, addr_type, removed;
714 	zone_t *zone = nfs_zone();
715 	nfs4_error_t n4e;
716 	zone_t *mntzone = NULL;
717 
718 	if (secpolicy_fs_mount(cr, mvp, vfsp) != 0)
719 		return (EPERM);
720 	if (mvp->v_type != VDIR)
721 		return (ENOTDIR);
722 
723 	/*
724 	 * get arguments
725 	 *
726 	 * nfs_args is now versioned and is extensible, so
727 	 * uap->datalen might be different from sizeof (args)
728 	 * in a compatible situation.
729 	 */
730 more:
731 	if (!(uap->flags & MS_SYSSPACE)) {
732 		if (args == NULL)
733 			args = kmem_zalloc(sizeof (struct nfs_args), KM_SLEEP);
734 		else
735 			nfs4_free_args(args);
736 		error = nfs4_copyin(data, uap->datalen, args);
737 		if (error) {
738 			if (args) {
739 				kmem_free(args, sizeof (*args));
740 			}
741 			return (error);
742 		}
743 	} else {
744 		args = (struct nfs_args *)data;
745 	}
746 
747 	flags = args->flags;
748 
749 	/*
750 	 * If the request changes the locking type, disallow the remount,
751 	 * because it's questionable whether we can transfer the
752 	 * locking state correctly.
753 	 */
754 	if (uap->flags & MS_REMOUNT) {
755 		if (!(uap->flags & MS_SYSSPACE)) {
756 			nfs4_free_args(args);
757 			kmem_free(args, sizeof (*args));
758 		}
759 		if ((mi = VFTOMI4(vfsp)) != NULL) {
760 			uint_t new_mi_llock;
761 			uint_t old_mi_llock;
762 			new_mi_llock = (flags & NFSMNT_LLOCK) ? 1 : 0;
763 			old_mi_llock = (mi->mi_flags & MI4_LLOCK) ? 1 : 0;
764 			if (old_mi_llock != new_mi_llock)
765 				return (EBUSY);
766 		}
767 		return (0);
768 	}
769 
770 	/*
771 	 * For ephemeral mount trigger stub vnodes, we have two problems
772 	 * to solve: racing threads will likely fail the v_count check, and
773 	 * we want only one to proceed with the mount.
774 	 *
775 	 * For stubs, if the mount has already occurred (via a racing thread),
776 	 * just return success. If not, skip the v_count check and proceed.
777 	 * Note that we are already serialised at this point.
778 	 */
779 	mutex_enter(&mvp->v_lock);
780 	if (vn_matchops(mvp, nfs4_trigger_vnodeops)) {
781 		/* mntpt is a v4 stub vnode */
782 		ASSERT(RP_ISSTUB(VTOR4(mvp)));
783 		ASSERT(!(uap->flags & MS_OVERLAY));
784 		ASSERT(!(mvp->v_flag & VROOT));
785 		if (vn_mountedvfs(mvp) != NULL) {
786 			/* ephemeral mount has already occurred */
787 			ASSERT(uap->flags & MS_SYSSPACE);
788 			mutex_exit(&mvp->v_lock);
789 			return (0);
790 		}
791 	} else {
792 		/* mntpt is a non-v4 or v4 non-stub vnode */
793 		if (!(uap->flags & MS_OVERLAY) &&
794 		    (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
795 			mutex_exit(&mvp->v_lock);
796 			if (!(uap->flags & MS_SYSSPACE)) {
797 				nfs4_free_args(args);
798 				kmem_free(args, sizeof (*args));
799 			}
800 			return (EBUSY);
801 		}
802 	}
803 	mutex_exit(&mvp->v_lock);
804 
805 	/* make sure things are zeroed for errout: */
806 	rtvp = NULL;
807 	mi = NULL;
808 	secdata = NULL;
809 
810 	/*
811 	 * A valid knetconfig structure is required.
812 	 */
813 	if (!(flags & NFSMNT_KNCONF) ||
814 	    args->knconf == NULL || args->knconf->knc_protofmly == NULL ||
815 	    args->knconf->knc_proto == NULL ||
816 	    (strcmp(args->knconf->knc_proto, NC_UDP) == 0)) {
817 		if (!(uap->flags & MS_SYSSPACE)) {
818 			nfs4_free_args(args);
819 			kmem_free(args, sizeof (*args));
820 		}
821 		return (EINVAL);
822 	}
823 
824 	if ((strlen(args->knconf->knc_protofmly) >= KNC_STRSIZE) ||
825 	    (strlen(args->knconf->knc_proto) >= KNC_STRSIZE)) {
826 		if (!(uap->flags & MS_SYSSPACE)) {
827 			nfs4_free_args(args);
828 			kmem_free(args, sizeof (*args));
829 		}
830 		return (EINVAL);
831 	}
832 
833 	/*
834 	 * Allocate a servinfo4 struct.
835 	 */
836 	svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
837 	nfs_rw_init(&svp->sv_lock, NULL, RW_DEFAULT, NULL);
838 	if (svp_tail) {
839 		svp_2ndlast = svp_tail;
840 		svp_tail->sv_next = svp;
841 	} else {
842 		svp_head = svp;
843 		svp_2ndlast = svp;
844 	}
845 
846 	svp_tail = svp;
847 	svp->sv_knconf = args->knconf;
848 	args->knconf = NULL;
849 
850 	/*
851 	 * Get server address
852 	 */
853 	if (args->addr == NULL || args->addr->buf == NULL) {
854 		error = EINVAL;
855 		goto errout;
856 	}
857 
858 	svp->sv_addr.maxlen = args->addr->maxlen;
859 	svp->sv_addr.len = args->addr->len;
860 	svp->sv_addr.buf = args->addr->buf;
861 	args->addr->buf = NULL;
862 
863 	/*
864 	 * Get the root fhandle
865 	 */
866 	if (args->fh == NULL || (strlen(args->fh) >= MAXPATHLEN)) {
867 		error = EINVAL;
868 		goto errout;
869 	}
870 
871 	svp->sv_path = args->fh;
872 	svp->sv_pathlen = strlen(args->fh) + 1;
873 	args->fh = NULL;
874 
875 	/*
876 	 * Get server's hostname
877 	 */
878 	if (flags & NFSMNT_HOSTNAME) {
879 		if (args->hostname == NULL || (strlen(args->hostname) >
880 		    MAXNETNAMELEN)) {
881 			error = EINVAL;
882 			goto errout;
883 		}
884 		svp->sv_hostnamelen = strlen(args->hostname) + 1;
885 		svp->sv_hostname = args->hostname;
886 		args->hostname = NULL;
887 	} else {
888 		char *p = "unknown-host";
889 		svp->sv_hostnamelen = strlen(p) + 1;
890 		svp->sv_hostname = kmem_zalloc(svp->sv_hostnamelen, KM_SLEEP);
891 		(void) strcpy(svp->sv_hostname, p);
892 	}
893 
894 	/*
895 	 * RDMA MOUNT SUPPORT FOR NFS v4.
896 	 * Establish, is it possible to use RDMA, if so overload the
897 	 * knconf with rdma specific knconf and free the orignal knconf.
898 	 */
899 	if ((flags & NFSMNT_TRYRDMA) || (flags & NFSMNT_DORDMA)) {
900 		/*
901 		 * Determine the addr type for RDMA, IPv4 or v6.
902 		 */
903 		if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET) == 0)
904 			addr_type = AF_INET;
905 		else if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET6) == 0)
906 			addr_type = AF_INET6;
907 
908 		if (rdma_reachable(addr_type, &svp->sv_addr,
909 		    &rdma_knconf) == 0) {
910 			/*
911 			 * If successful, hijack the orignal knconf and
912 			 * replace with the new one, depending on the flags.
913 			 */
914 			svp->sv_origknconf = svp->sv_knconf;
915 			svp->sv_knconf = rdma_knconf;
916 		} else {
917 			if (flags & NFSMNT_TRYRDMA) {
918 #ifdef	DEBUG
919 				if (rdma_debug)
920 					zcmn_err(getzoneid(), CE_WARN,
921 					    "no RDMA onboard, revert\n");
922 #endif
923 			}
924 
925 			if (flags & NFSMNT_DORDMA) {
926 				/*
927 				 * If proto=rdma is specified and no RDMA
928 				 * path to this server is avialable then
929 				 * ditch this server.
930 				 * This is not included in the mountable
931 				 * server list or the replica list.
932 				 * Check if more servers are specified;
933 				 * Failover case, otherwise bail out of mount.
934 				 */
935 				if (args->nfs_args_ext == NFS_ARGS_EXTB &&
936 				    args->nfs_ext_u.nfs_extB.next != NULL) {
937 					data = (char *)
938 					    args->nfs_ext_u.nfs_extB.next;
939 					if (uap->flags & MS_RDONLY &&
940 					    !(flags & NFSMNT_SOFT)) {
941 						if (svp_head->sv_next == NULL) {
942 							svp_tail = NULL;
943 							svp_2ndlast = NULL;
944 							sv4_free(svp_head);
945 							goto more;
946 						} else {
947 							svp_tail = svp_2ndlast;
948 							svp_2ndlast->sv_next =
949 							    NULL;
950 							sv4_free(svp);
951 							goto more;
952 						}
953 					}
954 				} else {
955 					/*
956 					 * This is the last server specified
957 					 * in the nfs_args list passed down
958 					 * and its not rdma capable.
959 					 */
960 					if (svp_head->sv_next == NULL) {
961 						/*
962 						 * Is this the only one
963 						 */
964 						error = EINVAL;
965 #ifdef	DEBUG
966 						if (rdma_debug)
967 							zcmn_err(getzoneid(),
968 							    CE_WARN,
969 							    "No RDMA srv");
970 #endif
971 						goto errout;
972 					} else {
973 						/*
974 						 * There is list, since some
975 						 * servers specified before
976 						 * this passed all requirements
977 						 */
978 						svp_tail = svp_2ndlast;
979 						svp_2ndlast->sv_next = NULL;
980 						sv4_free(svp);
981 						goto proceed;
982 					}
983 				}
984 			}
985 		}
986 	}
987 
988 	/*
989 	 * If there are syncaddr and netname data, load them in. This is
990 	 * to support data needed for NFSV4 when AUTH_DH is the negotiated
991 	 * flavor via SECINFO. (instead of using MOUNT protocol in V3).
992 	 */
993 	if (args->flags & NFSMNT_SECURE) {
994 		svp->sv_dhsec = create_authdh_data(args->netname,
995 		    strlen(args->netname),
996 		    args->syncaddr, svp->sv_knconf);
997 	}
998 
999 	/*
1000 	 * Get the extention data which has the security data structure.
1001 	 * This includes data for AUTH_SYS as well.
1002 	 */
1003 	if (flags & NFSMNT_NEWARGS) {
1004 		switch (args->nfs_args_ext) {
1005 		case NFS_ARGS_EXTA:
1006 		case NFS_ARGS_EXTB:
1007 			/*
1008 			 * Indicating the application is using the new
1009 			 * sec_data structure to pass in the security
1010 			 * data.
1011 			 */
1012 			secdata = args->nfs_ext_u.nfs_extA.secdata;
1013 			if (secdata == NULL) {
1014 				error = EINVAL;
1015 			} else if (uap->flags & MS_SYSSPACE) {
1016 				/*
1017 				 * Need to validate the flavor here if
1018 				 * sysspace, userspace was already
1019 				 * validate from the nfs_copyin function.
1020 				 */
1021 				switch (secdata->rpcflavor) {
1022 				case AUTH_NONE:
1023 				case AUTH_UNIX:
1024 				case AUTH_LOOPBACK:
1025 				case AUTH_DES:
1026 				case RPCSEC_GSS:
1027 					break;
1028 				default:
1029 					error = EINVAL;
1030 					goto errout;
1031 				}
1032 			}
1033 			args->nfs_ext_u.nfs_extA.secdata = NULL;
1034 			break;
1035 
1036 		default:
1037 			error = EINVAL;
1038 			break;
1039 		}
1040 
1041 	} else if (flags & NFSMNT_SECURE) {
1042 		/*
1043 		 * NFSMNT_SECURE is deprecated but we keep it
1044 		 * to support the rogue user-generated application
1045 		 * that may use this undocumented interface to do
1046 		 * AUTH_DH security, e.g. our own rexd.
1047 		 *
1048 		 * Also note that NFSMNT_SECURE is used for passing
1049 		 * AUTH_DH info to be used in negotiation.
1050 		 */
1051 		secdata = create_authdh_data(args->netname,
1052 		    strlen(args->netname), args->syncaddr, svp->sv_knconf);
1053 
1054 	} else {
1055 		secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP);
1056 		secdata->secmod = secdata->rpcflavor = AUTH_SYS;
1057 		secdata->data = NULL;
1058 	}
1059 
1060 	svp->sv_secdata = secdata;
1061 
1062 	/*
1063 	 * User does not explictly specify a flavor, and a user
1064 	 * defined default flavor is passed down.
1065 	 */
1066 	if (flags & NFSMNT_SECDEFAULT) {
1067 		(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
1068 		svp->sv_flags |= SV4_TRYSECDEFAULT;
1069 		nfs_rw_exit(&svp->sv_lock);
1070 	}
1071 
1072 	/*
1073 	 * Failover support:
1074 	 *
1075 	 * We may have a linked list of nfs_args structures,
1076 	 * which means the user is looking for failover.  If
1077 	 * the mount is either not "read-only" or "soft",
1078 	 * we want to bail out with EINVAL.
1079 	 */
1080 	if (args->nfs_args_ext == NFS_ARGS_EXTB &&
1081 	    args->nfs_ext_u.nfs_extB.next != NULL) {
1082 		if (uap->flags & MS_RDONLY && !(flags & NFSMNT_SOFT)) {
1083 			data = (char *)args->nfs_ext_u.nfs_extB.next;
1084 			goto more;
1085 		}
1086 		error = EINVAL;
1087 		goto errout;
1088 	}
1089 
1090 	/*
1091 	 * Determine the zone we're being mounted into.
1092 	 */
1093 	zone_hold(mntzone = zone);		/* start with this assumption */
1094 	if (getzoneid() == GLOBAL_ZONEID) {
1095 		zone_rele(mntzone);
1096 		mntzone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
1097 		ASSERT(mntzone != NULL);
1098 		if (mntzone != zone) {
1099 			error = EBUSY;
1100 			goto errout;
1101 		}
1102 	}
1103 
1104 	if (is_system_labeled()) {
1105 		error = nfs_mount_label_policy(vfsp, &svp->sv_addr,
1106 		    svp->sv_knconf, cr);
1107 
1108 		if (error > 0)
1109 			goto errout;
1110 
1111 		if (error == -1) {
1112 			/* change mount to read-only to prevent write-down */
1113 			vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
1114 		}
1115 	}
1116 
1117 	/*
1118 	 * Stop the mount from going any further if the zone is going away.
1119 	 */
1120 	if (zone_status_get(mntzone) >= ZONE_IS_SHUTTING_DOWN) {
1121 		error = EBUSY;
1122 		goto errout;
1123 	}
1124 
1125 	/*
1126 	 * Get root vnode.
1127 	 */
1128 proceed:
1129 	error = nfs4rootvp(&rtvp, vfsp, svp_head, flags, cr, mntzone);
1130 	if (error) {
1131 		/* if nfs4rootvp failed, it will free svp_head */
1132 		svp_head = NULL;
1133 		goto errout;
1134 	}
1135 
1136 	mi = VTOMI4(rtvp);
1137 
1138 	/*
1139 	 * Send client id to the server, if necessary
1140 	 */
1141 	nfs4_error_zinit(&n4e);
1142 	nfs4setclientid(mi, cr, FALSE, &n4e);
1143 
1144 	error = n4e.error;
1145 
1146 	if (error)
1147 		goto errout;
1148 
1149 	/*
1150 	 * Set option fields in the mount info record
1151 	 */
1152 
1153 	if (svp_head->sv_next) {
1154 		mutex_enter(&mi->mi_lock);
1155 		mi->mi_flags |= MI4_LLOCK;
1156 		mutex_exit(&mi->mi_lock);
1157 	}
1158 	error = nfs4_setopts(rtvp, DATAMODEL_NATIVE, args);
1159 	if (error)
1160 		goto errout;
1161 
1162 	/*
1163 	 * Time to tie in the mirror mount info at last!
1164 	 */
1165 	if (flags & NFSMNT_EPHEMERAL)
1166 		error = nfs4_record_ephemeral_mount(mi, mvp);
1167 
1168 errout:
1169 	if (error) {
1170 		if (rtvp != NULL) {
1171 			rp = VTOR4(rtvp);
1172 			if (rp->r_flags & R4HASHED)
1173 				rp4_rmhash(rp);
1174 		}
1175 		if (mi != NULL) {
1176 			nfs4_async_stop(vfsp);
1177 			nfs4_async_manager_stop(vfsp);
1178 			nfs4_remove_mi_from_server(mi, NULL);
1179 			if (rtvp != NULL)
1180 				VN_RELE(rtvp);
1181 			if (mntzone != NULL)
1182 				zone_rele(mntzone);
1183 			/* need to remove it from the zone */
1184 			removed = nfs4_mi_zonelist_remove(mi);
1185 			if (removed)
1186 				zone_rele_ref(&mi->mi_zone_ref,
1187 				    ZONE_REF_NFSV4);
1188 			MI4_RELE(mi);
1189 			if (!(uap->flags & MS_SYSSPACE) && args) {
1190 				nfs4_free_args(args);
1191 				kmem_free(args, sizeof (*args));
1192 			}
1193 			return (error);
1194 		}
1195 		if (svp_head)
1196 			sv4_free(svp_head);
1197 	}
1198 
1199 	if (!(uap->flags & MS_SYSSPACE) && args) {
1200 		nfs4_free_args(args);
1201 		kmem_free(args, sizeof (*args));
1202 	}
1203 	if (rtvp != NULL)
1204 		VN_RELE(rtvp);
1205 
1206 	if (mntzone != NULL)
1207 		zone_rele(mntzone);
1208 
1209 	return (error);
1210 }
1211 
1212 #ifdef  DEBUG
1213 #define	VERS_MSG	"NFS4 server "
1214 #else
1215 #define	VERS_MSG	"NFS server "
1216 #endif
1217 
1218 #define	READ_MSG        \
1219 	VERS_MSG "%s returned 0 for read transfer size"
1220 #define	WRITE_MSG       \
1221 	VERS_MSG "%s returned 0 for write transfer size"
1222 #define	SIZE_MSG        \
1223 	VERS_MSG "%s returned 0 for maximum file size"
1224 
1225 /*
1226  * Get the symbolic link text from the server for a given filehandle
1227  * of that symlink.
1228  *
1229  *      (get symlink text) PUTFH READLINK
1230  */
1231 static int
getlinktext_otw(mntinfo4_t * mi,nfs_fh4 * fh,char ** linktextp,cred_t * cr,int flags)1232 getlinktext_otw(mntinfo4_t *mi, nfs_fh4 *fh, char **linktextp, cred_t *cr,
1233     int flags)
1234 {
1235 	COMPOUND4args_clnt args;
1236 	COMPOUND4res_clnt res;
1237 	int doqueue;
1238 	nfs_argop4 argop[2];
1239 	nfs_resop4 *resop;
1240 	READLINK4res *lr_res;
1241 	uint_t len;
1242 	bool_t needrecov = FALSE;
1243 	nfs4_recov_state_t recov_state;
1244 	nfs4_sharedfh_t *sfh;
1245 	nfs4_error_t e;
1246 	int num_retry = nfs4_max_mount_retry;
1247 	int recovery = !(flags & NFS4_GETFH_NEEDSOP);
1248 
1249 	sfh = sfh4_get(fh, mi);
1250 	recov_state.rs_flags = 0;
1251 	recov_state.rs_num_retry_despite_err = 0;
1252 
1253 recov_retry:
1254 	nfs4_error_zinit(&e);
1255 
1256 	args.array_len = 2;
1257 	args.array = argop;
1258 	args.ctag = TAG_GET_SYMLINK;
1259 
1260 	if (! recovery) {
1261 		e.error = nfs4_start_op(mi, NULL, NULL, &recov_state);
1262 		if (e.error) {
1263 			sfh4_rele(&sfh);
1264 			return (e.error);
1265 		}
1266 	}
1267 
1268 	/* 0. putfh symlink fh */
1269 	argop[0].argop = OP_CPUTFH;
1270 	argop[0].nfs_argop4_u.opcputfh.sfh = sfh;
1271 
1272 	/* 1. readlink */
1273 	argop[1].argop = OP_READLINK;
1274 
1275 	doqueue = 1;
1276 
1277 	rfs4call(mi, &args, &res, cr, &doqueue, 0, &e);
1278 
1279 	needrecov = nfs4_needs_recovery(&e, FALSE, mi->mi_vfsp);
1280 
1281 	if (needrecov && !recovery && num_retry-- > 0) {
1282 
1283 		NFS4_DEBUG(nfs4_client_recov_debug, (CE_NOTE,
1284 		    "getlinktext_otw: initiating recovery\n"));
1285 
1286 		if (nfs4_start_recovery(&e, mi, NULL, NULL, NULL, NULL,
1287 		    OP_READLINK, NULL, NULL, NULL) == FALSE) {
1288 			nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov);
1289 			if (!e.error)
1290 				xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1291 			goto recov_retry;
1292 		}
1293 	}
1294 
1295 	/*
1296 	 * If non-NFS4 pcol error and/or we weren't able to recover.
1297 	 */
1298 	if (e.error != 0) {
1299 		if (! recovery)
1300 			nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov);
1301 		sfh4_rele(&sfh);
1302 		return (e.error);
1303 	}
1304 
1305 	if (res.status) {
1306 		e.error = geterrno4(res.status);
1307 		xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1308 		if (! recovery)
1309 			nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov);
1310 		sfh4_rele(&sfh);
1311 		return (e.error);
1312 	}
1313 
1314 	/* res.status == NFS4_OK */
1315 	ASSERT(res.status == NFS4_OK);
1316 
1317 	resop = &res.array[1];  /* readlink res */
1318 	lr_res = &resop->nfs_resop4_u.opreadlink;
1319 
1320 	/* treat symlink name as data */
1321 	*linktextp = utf8_to_str((utf8string *)&lr_res->link, &len, NULL);
1322 
1323 	if (! recovery)
1324 		nfs4_end_op(mi, NULL, NULL, &recov_state, needrecov);
1325 	sfh4_rele(&sfh);
1326 	xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1327 	return (0);
1328 }
1329 
1330 /*
1331  * Skip over consecutive slashes and "/./" in a pathname.
1332  */
1333 void
pathname_skipslashdot(struct pathname * pnp)1334 pathname_skipslashdot(struct pathname *pnp)
1335 {
1336 	char *c1, *c2;
1337 
1338 	while (pnp->pn_pathlen > 0 && *pnp->pn_path == '/') {
1339 
1340 		c1 = pnp->pn_path + 1;
1341 		c2 = pnp->pn_path + 2;
1342 
1343 		if (*c1 == '.' && (*c2 == '/' || *c2 == '\0')) {
1344 			pnp->pn_path = pnp->pn_path + 2; /* skip "/." */
1345 			pnp->pn_pathlen = pnp->pn_pathlen - 2;
1346 		} else {
1347 			pnp->pn_path++;
1348 			pnp->pn_pathlen--;
1349 		}
1350 	}
1351 }
1352 
1353 /*
1354  * Resolve a symbolic link path. The symlink is in the nth component of
1355  * svp->sv_path and has an nfs4 file handle "fh".
1356  * Upon return, the sv_path will point to the new path that has the nth
1357  * component resolved to its symlink text.
1358  */
1359 int
resolve_sympath(mntinfo4_t * mi,servinfo4_t * svp,int nth,nfs_fh4 * fh,cred_t * cr,int flags)1360 resolve_sympath(mntinfo4_t *mi, servinfo4_t *svp, int nth, nfs_fh4 *fh,
1361     cred_t *cr, int flags)
1362 {
1363 	char *oldpath;
1364 	char *symlink, *newpath;
1365 	struct pathname oldpn, newpn;
1366 	char component[MAXNAMELEN];
1367 	int i, addlen, error = 0;
1368 	int oldpathlen;
1369 
1370 	/* Get the symbolic link text over the wire. */
1371 	error = getlinktext_otw(mi, fh, &symlink, cr, flags);
1372 
1373 	if (error || symlink == NULL || strlen(symlink) == 0)
1374 		return (error);
1375 
1376 	/*
1377 	 * Compose the new pathname.
1378 	 * Note:
1379 	 *    - only the nth component is resolved for the pathname.
1380 	 *    - pathname.pn_pathlen does not count the ending null byte.
1381 	 */
1382 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
1383 	oldpath = svp->sv_path;
1384 	oldpathlen = svp->sv_pathlen;
1385 	if (error = pn_get(oldpath, UIO_SYSSPACE, &oldpn)) {
1386 		nfs_rw_exit(&svp->sv_lock);
1387 		kmem_free(symlink, strlen(symlink) + 1);
1388 		return (error);
1389 	}
1390 	nfs_rw_exit(&svp->sv_lock);
1391 	pn_alloc(&newpn);
1392 
1393 	/*
1394 	 * Skip over previous components from the oldpath so that the
1395 	 * oldpn.pn_path will point to the symlink component. Skip
1396 	 * leading slashes and "/./" (no OP_LOOKUP on ".") so that
1397 	 * pn_getcompnent can get the component.
1398 	 */
1399 	for (i = 1; i < nth; i++) {
1400 		pathname_skipslashdot(&oldpn);
1401 		error = pn_getcomponent(&oldpn, component);
1402 		if (error)
1403 			goto out;
1404 	}
1405 
1406 	/*
1407 	 * Copy the old path upto the component right before the symlink
1408 	 * if the symlink is not an absolute path.
1409 	 */
1410 	if (symlink[0] != '/') {
1411 		addlen = oldpn.pn_path - oldpn.pn_buf;
1412 		bcopy(oldpn.pn_buf, newpn.pn_path, addlen);
1413 		newpn.pn_pathlen += addlen;
1414 		newpn.pn_path += addlen;
1415 		newpn.pn_buf[newpn.pn_pathlen] = '/';
1416 		newpn.pn_pathlen++;
1417 		newpn.pn_path++;
1418 	}
1419 
1420 	/* copy the resolved symbolic link text */
1421 	addlen = strlen(symlink);
1422 	if (newpn.pn_pathlen + addlen >= newpn.pn_bufsize) {
1423 		error = ENAMETOOLONG;
1424 		goto out;
1425 	}
1426 	bcopy(symlink, newpn.pn_path, addlen);
1427 	newpn.pn_pathlen += addlen;
1428 	newpn.pn_path += addlen;
1429 
1430 	/*
1431 	 * Check if there is any remaining path after the symlink component.
1432 	 * First, skip the symlink component.
1433 	 */
1434 	pathname_skipslashdot(&oldpn);
1435 	if (error = pn_getcomponent(&oldpn, component))
1436 		goto out;
1437 
1438 	addlen = pn_pathleft(&oldpn); /* includes counting the slash */
1439 
1440 	/*
1441 	 * Copy the remaining path to the new pathname if there is any.
1442 	 */
1443 	if (addlen > 0) {
1444 		if (newpn.pn_pathlen + addlen >= newpn.pn_bufsize) {
1445 			error = ENAMETOOLONG;
1446 			goto out;
1447 		}
1448 		bcopy(oldpn.pn_path, newpn.pn_path, addlen);
1449 		newpn.pn_pathlen += addlen;
1450 	}
1451 	newpn.pn_buf[newpn.pn_pathlen] = '\0';
1452 
1453 	/* get the newpath and store it in the servinfo4_t */
1454 	newpath = kmem_alloc(newpn.pn_pathlen + 1, KM_SLEEP);
1455 	bcopy(newpn.pn_buf, newpath, newpn.pn_pathlen);
1456 	newpath[newpn.pn_pathlen] = '\0';
1457 
1458 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
1459 	svp->sv_path = newpath;
1460 	svp->sv_pathlen = strlen(newpath) + 1;
1461 	nfs_rw_exit(&svp->sv_lock);
1462 
1463 	kmem_free(oldpath, oldpathlen);
1464 out:
1465 	kmem_free(symlink, strlen(symlink) + 1);
1466 	pn_free(&newpn);
1467 	pn_free(&oldpn);
1468 
1469 	return (error);
1470 }
1471 
1472 /*
1473  * This routine updates servinfo4 structure with the new referred server
1474  * info.
1475  * nfsfsloc has the location related information
1476  * fsp has the hostname and pathname info.
1477  * new path = pathname from referral + part of orig pathname(based on nth).
1478  */
1479 static void
update_servinfo4(servinfo4_t * svp,fs_location4 * fsp,struct nfs_fsl_info * nfsfsloc,char * orig_path,int nth)1480 update_servinfo4(servinfo4_t *svp, fs_location4 *fsp,
1481     struct nfs_fsl_info *nfsfsloc, char *orig_path, int nth)
1482 {
1483 	struct knetconfig *knconf, *svknconf;
1484 	struct netbuf *saddr;
1485 	sec_data_t	*secdata;
1486 	utf8string *host;
1487 	int i = 0, num_slashes = 0;
1488 	char *p, *spath, *op, *new_path;
1489 
1490 	/* Update knconf */
1491 	knconf = svp->sv_knconf;
1492 	free_knconf_contents(knconf);
1493 	bzero(knconf, sizeof (struct knetconfig));
1494 	svknconf = nfsfsloc->knconf;
1495 	knconf->knc_semantics = svknconf->knc_semantics;
1496 	knconf->knc_protofmly = kmem_zalloc(KNC_STRSIZE, KM_SLEEP);
1497 	knconf->knc_proto = kmem_zalloc(KNC_STRSIZE, KM_SLEEP);
1498 	knconf->knc_rdev = svknconf->knc_rdev;
1499 	bcopy(svknconf->knc_protofmly, knconf->knc_protofmly, KNC_STRSIZE);
1500 	bcopy(svknconf->knc_proto, knconf->knc_proto, KNC_STRSIZE);
1501 
1502 	/* Update server address */
1503 	saddr = &svp->sv_addr;
1504 	if (saddr->buf != NULL)
1505 		kmem_free(saddr->buf, saddr->maxlen);
1506 	saddr->buf  = kmem_alloc(nfsfsloc->addr->maxlen, KM_SLEEP);
1507 	saddr->len = nfsfsloc->addr->len;
1508 	saddr->maxlen = nfsfsloc->addr->maxlen;
1509 	bcopy(nfsfsloc->addr->buf, saddr->buf, nfsfsloc->addr->len);
1510 
1511 	/* Update server name */
1512 	host = fsp->server_val;
1513 	kmem_free(svp->sv_hostname, svp->sv_hostnamelen);
1514 	svp->sv_hostname = kmem_zalloc(host->utf8string_len + 1, KM_SLEEP);
1515 	bcopy(host->utf8string_val, svp->sv_hostname, host->utf8string_len);
1516 	svp->sv_hostname[host->utf8string_len] = '\0';
1517 	svp->sv_hostnamelen = host->utf8string_len + 1;
1518 
1519 	/*
1520 	 * Update server path.
1521 	 * We need to setup proper path here.
1522 	 * For ex., If we got a path name serv1:/rp/aaa/bbb
1523 	 * where aaa is a referral and points to serv2:/rpool/aa
1524 	 * we need to set the path to serv2:/rpool/aa/bbb
1525 	 * The first part of this below code generates /rpool/aa
1526 	 * and the second part appends /bbb to the server path.
1527 	 */
1528 	spath = p = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1529 	*p++ = '/';
1530 	for (i = 0; i < fsp->rootpath.pathname4_len; i++) {
1531 		component4 *comp;
1532 
1533 		comp = &fsp->rootpath.pathname4_val[i];
1534 		/* If no space, null the string and bail */
1535 		if ((p - spath) + comp->utf8string_len + 1 > MAXPATHLEN) {
1536 			p = spath + MAXPATHLEN - 1;
1537 			spath[0] = '\0';
1538 			break;
1539 		}
1540 		bcopy(comp->utf8string_val, p, comp->utf8string_len);
1541 		p += comp->utf8string_len;
1542 		*p++ = '/';
1543 	}
1544 	if (fsp->rootpath.pathname4_len != 0)
1545 		*(p - 1) = '\0';
1546 	else
1547 		*p = '\0';
1548 	p = spath;
1549 
1550 	new_path = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
1551 	(void) strlcpy(new_path, p, MAXPATHLEN);
1552 	kmem_free(p, MAXPATHLEN);
1553 	i = strlen(new_path);
1554 
1555 	for (op = orig_path; *op; op++) {
1556 		if (*op == '/')
1557 			num_slashes++;
1558 		if (num_slashes == nth + 2) {
1559 			while (*op != '\0') {
1560 				new_path[i] = *op;
1561 				i++;
1562 				op++;
1563 			}
1564 			break;
1565 		}
1566 	}
1567 	new_path[i] = '\0';
1568 
1569 	kmem_free(svp->sv_path, svp->sv_pathlen);
1570 	svp->sv_pathlen = strlen(new_path) + 1;
1571 	svp->sv_path = kmem_alloc(svp->sv_pathlen, KM_SLEEP);
1572 	bcopy(new_path, svp->sv_path, svp->sv_pathlen);
1573 	kmem_free(new_path, MAXPATHLEN);
1574 
1575 	/*
1576 	 * All the security data is specific to old server.
1577 	 * Clean it up except secdata which deals with mount options.
1578 	 * We need to inherit that data. Copy secdata into our new servinfo4.
1579 	 */
1580 	if (svp->sv_dhsec) {
1581 		sec_clnt_freeinfo(svp->sv_dhsec);
1582 		svp->sv_dhsec = NULL;
1583 	}
1584 	if (svp->sv_save_secinfo &&
1585 	    svp->sv_save_secinfo != svp->sv_secinfo) {
1586 		secinfo_free(svp->sv_save_secinfo);
1587 		svp->sv_save_secinfo = NULL;
1588 	}
1589 	if (svp->sv_secinfo) {
1590 		secinfo_free(svp->sv_secinfo);
1591 		svp->sv_secinfo = NULL;
1592 	}
1593 	svp->sv_currsec = NULL;
1594 
1595 	secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP);
1596 	*secdata = *svp->sv_secdata;
1597 	secdata->data = NULL;
1598 	if (svp->sv_secdata) {
1599 		sec_clnt_freeinfo(svp->sv_secdata);
1600 		svp->sv_secdata = NULL;
1601 	}
1602 	svp->sv_secdata = secdata;
1603 }
1604 
1605 /*
1606  * Resolve a referral. The referral is in the n+1th component of
1607  * svp->sv_path and has a parent nfs4 file handle "fh".
1608  * Upon return, the sv_path will point to the new path that has referral
1609  * component resolved to its referred path and part of original path.
1610  * Hostname and other address information is also updated.
1611  */
1612 int
resolve_referral(mntinfo4_t * mi,servinfo4_t * svp,cred_t * cr,int nth,nfs_fh4 * fh)1613 resolve_referral(mntinfo4_t *mi, servinfo4_t *svp, cred_t *cr, int nth,
1614     nfs_fh4 *fh)
1615 {
1616 	nfs4_sharedfh_t	*sfh;
1617 	struct nfs_fsl_info nfsfsloc;
1618 	nfs4_ga_res_t garp;
1619 	COMPOUND4res_clnt callres;
1620 	fs_location4	*fsp;
1621 	char *nm, *orig_path;
1622 	int orig_pathlen = 0, ret = -1, index;
1623 
1624 	if (svp->sv_pathlen <= 0)
1625 		return (ret);
1626 
1627 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
1628 	orig_pathlen = svp->sv_pathlen;
1629 	orig_path = kmem_alloc(orig_pathlen, KM_SLEEP);
1630 	bcopy(svp->sv_path, orig_path, orig_pathlen);
1631 	nm = extract_referral_point(svp->sv_path, nth);
1632 	setup_newsvpath(svp, nth);
1633 	nfs_rw_exit(&svp->sv_lock);
1634 
1635 	sfh = sfh4_get(fh, mi);
1636 	index = nfs4_process_referral(mi, sfh, nm, cr,
1637 	    &garp, &callres, &nfsfsloc);
1638 	sfh4_rele(&sfh);
1639 	kmem_free(nm, MAXPATHLEN);
1640 	if (index < 0) {
1641 		kmem_free(orig_path, orig_pathlen);
1642 		return (index);
1643 	}
1644 
1645 	fsp =  &garp.n4g_ext_res->n4g_fslocations.locations_val[index];
1646 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
1647 	update_servinfo4(svp, fsp, &nfsfsloc, orig_path, nth);
1648 	nfs_rw_exit(&svp->sv_lock);
1649 
1650 	mutex_enter(&mi->mi_lock);
1651 	mi->mi_vfs_referral_loop_cnt++;
1652 	mutex_exit(&mi->mi_lock);
1653 
1654 	ret = 0;
1655 bad:
1656 	/* Free up XDR memory allocated in nfs4_process_referral() */
1657 	xdr_free(xdr_nfs_fsl_info, (char *)&nfsfsloc);
1658 	xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&callres);
1659 	kmem_free(orig_path, orig_pathlen);
1660 
1661 	return (ret);
1662 }
1663 
1664 /*
1665  * Get the root filehandle for the given filesystem and server, and update
1666  * svp.
1667  *
1668  * If NFS4_GETFH_NEEDSOP is set, then use nfs4_start_fop and nfs4_end_fop
1669  * to coordinate with recovery.  Otherwise, the caller is assumed to be
1670  * the recovery thread or have already done a start_fop.
1671  *
1672  * Errors are returned by the nfs4_error_t parameter.
1673  */
1674 static void
nfs4getfh_otw(struct mntinfo4 * mi,servinfo4_t * svp,vtype_t * vtp,int flags,cred_t * cr,nfs4_error_t * ep)1675 nfs4getfh_otw(struct mntinfo4 *mi, servinfo4_t *svp, vtype_t *vtp,
1676     int flags, cred_t *cr, nfs4_error_t *ep)
1677 {
1678 	COMPOUND4args_clnt args;
1679 	COMPOUND4res_clnt res;
1680 	int doqueue = 1;
1681 	nfs_argop4 *argop;
1682 	nfs_resop4 *resop;
1683 	nfs4_ga_res_t *garp;
1684 	int num_argops;
1685 	lookup4_param_t lookuparg;
1686 	nfs_fh4 *tmpfhp;
1687 	nfs_fh4 *resfhp;
1688 	bool_t needrecov = FALSE;
1689 	nfs4_recov_state_t recov_state;
1690 	int llndx;
1691 	int nthcomp;
1692 	int recovery = !(flags & NFS4_GETFH_NEEDSOP);
1693 
1694 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
1695 	ASSERT(svp->sv_path != NULL);
1696 	if (svp->sv_path[0] == '\0') {
1697 		nfs_rw_exit(&svp->sv_lock);
1698 		nfs4_error_init(ep, EINVAL);
1699 		return;
1700 	}
1701 	nfs_rw_exit(&svp->sv_lock);
1702 
1703 	recov_state.rs_flags = 0;
1704 	recov_state.rs_num_retry_despite_err = 0;
1705 
1706 recov_retry:
1707 	if (mi->mi_vfs_referral_loop_cnt >= NFS4_REFERRAL_LOOP_MAX) {
1708 		DTRACE_PROBE3(nfs4clnt__debug__referral__loop, mntinfo4 *,
1709 		    mi, servinfo4_t *, svp, char *, "nfs4getfh_otw");
1710 		nfs4_error_init(ep, EINVAL);
1711 		return;
1712 	}
1713 	nfs4_error_zinit(ep);
1714 
1715 	if (!recovery) {
1716 		ep->error = nfs4_start_fop(mi, NULL, NULL, OH_MOUNT,
1717 		    &recov_state, NULL);
1718 
1719 		/*
1720 		 * If recovery has been started and this request as
1721 		 * initiated by a mount, then we must wait for recovery
1722 		 * to finish before proceeding, otherwise, the error
1723 		 * cleanup would remove data structures needed by the
1724 		 * recovery thread.
1725 		 */
1726 		if (ep->error) {
1727 			mutex_enter(&mi->mi_lock);
1728 			if (mi->mi_flags & MI4_MOUNTING) {
1729 				mi->mi_flags |= MI4_RECOV_FAIL;
1730 				mi->mi_error = EIO;
1731 
1732 				NFS4_DEBUG(nfs4_client_recov_debug, (CE_NOTE,
1733 				    "nfs4getfh_otw: waiting 4 recovery\n"));
1734 
1735 				while (mi->mi_flags & MI4_RECOV_ACTIV)
1736 					cv_wait(&mi->mi_failover_cv,
1737 					    &mi->mi_lock);
1738 			}
1739 			mutex_exit(&mi->mi_lock);
1740 			return;
1741 		}
1742 
1743 		/*
1744 		 * If the client does not specify a specific flavor to use
1745 		 * and has not gotten a secinfo list from the server yet,
1746 		 * retrieve the secinfo list from the server and use a
1747 		 * flavor from the list to mount.
1748 		 *
1749 		 * If fail to get the secinfo list from the server, then
1750 		 * try the default flavor.
1751 		 */
1752 		if ((svp->sv_flags & SV4_TRYSECDEFAULT) &&
1753 		    svp->sv_secinfo == NULL) {
1754 			(void) nfs4_secinfo_path(mi, cr, FALSE);
1755 		}
1756 	}
1757 
1758 	if (recovery)
1759 		args.ctag = TAG_REMAP_MOUNT;
1760 	else
1761 		args.ctag = TAG_MOUNT;
1762 
1763 	lookuparg.l4_getattrs = LKP4_ALL_ATTRIBUTES;
1764 	lookuparg.argsp = &args;
1765 	lookuparg.resp = &res;
1766 	lookuparg.header_len = 2;	/* Putrootfh, getfh */
1767 	lookuparg.trailer_len = 0;
1768 	lookuparg.ga_bits = FATTR4_FSINFO_MASK;
1769 	lookuparg.mi = mi;
1770 
1771 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
1772 	ASSERT(svp->sv_path != NULL);
1773 	llndx = nfs4lookup_setup(svp->sv_path, &lookuparg, 0);
1774 	nfs_rw_exit(&svp->sv_lock);
1775 
1776 	argop = args.array;
1777 	num_argops = args.array_len;
1778 
1779 	/* choose public or root filehandle */
1780 	if (flags & NFS4_GETFH_PUBLIC)
1781 		argop[0].argop = OP_PUTPUBFH;
1782 	else
1783 		argop[0].argop = OP_PUTROOTFH;
1784 
1785 	/* get fh */
1786 	argop[1].argop = OP_GETFH;
1787 
1788 	NFS4_DEBUG(nfs4_client_call_debug, (CE_NOTE,
1789 	    "nfs4getfh_otw: %s call, mi 0x%p",
1790 	    needrecov ? "recov" : "first", (void *)mi));
1791 
1792 	rfs4call(mi, &args, &res, cr, &doqueue, RFSCALL_SOFT, ep);
1793 
1794 	needrecov = nfs4_needs_recovery(ep, FALSE, mi->mi_vfsp);
1795 
1796 	if (needrecov) {
1797 		bool_t abort;
1798 
1799 		if (recovery) {
1800 			nfs4args_lookup_free(argop, num_argops);
1801 			kmem_free(argop,
1802 			    lookuparg.arglen * sizeof (nfs_argop4));
1803 			if (!ep->error)
1804 				xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1805 			return;
1806 		}
1807 
1808 		NFS4_DEBUG(nfs4_client_recov_debug,
1809 		    (CE_NOTE, "nfs4getfh_otw: initiating recovery\n"));
1810 
1811 		abort = nfs4_start_recovery(ep, mi, NULL,
1812 		    NULL, NULL, NULL, OP_GETFH, NULL, NULL, NULL);
1813 		if (!ep->error) {
1814 			ep->error = geterrno4(res.status);
1815 			xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1816 		}
1817 		nfs4args_lookup_free(argop, num_argops);
1818 		kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4));
1819 		nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state, needrecov);
1820 		/* have another go? */
1821 		if (abort == FALSE)
1822 			goto recov_retry;
1823 		return;
1824 	}
1825 
1826 	/*
1827 	 * No recovery, but check if error is set.
1828 	 */
1829 	if (ep->error)  {
1830 		nfs4args_lookup_free(argop, num_argops);
1831 		kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4));
1832 		if (!recovery)
1833 			nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state,
1834 			    needrecov);
1835 		return;
1836 	}
1837 
1838 is_link_err:
1839 
1840 	/* for non-recovery errors */
1841 	if (res.status && res.status != NFS4ERR_SYMLINK &&
1842 	    res.status != NFS4ERR_MOVED) {
1843 		if (!recovery) {
1844 			nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state,
1845 			    needrecov);
1846 		}
1847 		nfs4args_lookup_free(argop, num_argops);
1848 		kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4));
1849 		xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1850 		return;
1851 	}
1852 
1853 	/*
1854 	 * If any intermediate component in the path is a symbolic link,
1855 	 * resolve the symlink, then try mount again using the new path.
1856 	 */
1857 	if (res.status == NFS4ERR_SYMLINK || res.status == NFS4ERR_MOVED) {
1858 		int where;
1859 
1860 		/*
1861 		 * Need to call nfs4_end_op before resolve_sympath to avoid
1862 		 * potential nfs4_start_op deadlock.
1863 		 */
1864 		if (!recovery)
1865 			nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state,
1866 			    needrecov);
1867 
1868 		/*
1869 		 * This must be from OP_LOOKUP failure. The (cfh) for this
1870 		 * OP_LOOKUP is a symlink node. Found out where the
1871 		 * OP_GETFH is for the (cfh) that is a symlink node.
1872 		 *
1873 		 * Example:
1874 		 * (mount) PUTROOTFH, GETFH, LOOKUP comp1, GETFH, GETATTR,
1875 		 * LOOKUP comp2, GETFH, GETATTR, LOOKUP comp3, GETFH, GETATTR
1876 		 *
1877 		 * LOOKUP comp3 fails with SYMLINK because comp2 is a symlink.
1878 		 * In this case, where = 7, nthcomp = 2.
1879 		 */
1880 		where = res.array_len - 2;
1881 		ASSERT(where > 0);
1882 
1883 		if (res.status == NFS4ERR_SYMLINK) {
1884 
1885 			resop = &res.array[where - 1];
1886 			ASSERT(resop->resop == OP_GETFH);
1887 			tmpfhp = &resop->nfs_resop4_u.opgetfh.object;
1888 			nthcomp = res.array_len/3 - 1;
1889 			ep->error = resolve_sympath(mi, svp, nthcomp,
1890 			    tmpfhp, cr, flags);
1891 
1892 		} else if (res.status == NFS4ERR_MOVED) {
1893 
1894 			resop = &res.array[where - 2];
1895 			ASSERT(resop->resop == OP_GETFH);
1896 			tmpfhp = &resop->nfs_resop4_u.opgetfh.object;
1897 			nthcomp = res.array_len/3 - 1;
1898 			ep->error = resolve_referral(mi, svp, cr, nthcomp,
1899 			    tmpfhp);
1900 		}
1901 
1902 		nfs4args_lookup_free(argop, num_argops);
1903 		kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4));
1904 		xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1905 
1906 		if (ep->error)
1907 			return;
1908 
1909 		goto recov_retry;
1910 	}
1911 
1912 	/* getfh */
1913 	resop = &res.array[res.array_len - 2];
1914 	ASSERT(resop->resop == OP_GETFH);
1915 	resfhp = &resop->nfs_resop4_u.opgetfh.object;
1916 
1917 	/* getattr fsinfo res */
1918 	resop++;
1919 	garp = &resop->nfs_resop4_u.opgetattr.ga_res;
1920 
1921 	*vtp = garp->n4g_va.va_type;
1922 
1923 	mi->mi_fh_expire_type = garp->n4g_ext_res->n4g_fet;
1924 
1925 	mutex_enter(&mi->mi_lock);
1926 	if (garp->n4g_ext_res->n4g_pc4.pc4_link_support)
1927 		mi->mi_flags |= MI4_LINK;
1928 	if (garp->n4g_ext_res->n4g_pc4.pc4_symlink_support)
1929 		mi->mi_flags |= MI4_SYMLINK;
1930 	if (garp->n4g_ext_res->n4g_suppattrs & FATTR4_ACL_MASK)
1931 		mi->mi_flags |= MI4_ACL;
1932 	mutex_exit(&mi->mi_lock);
1933 
1934 	if (garp->n4g_ext_res->n4g_maxread == 0)
1935 		mi->mi_tsize =
1936 		    MIN(MAXBSIZE, mi->mi_tsize);
1937 	else
1938 		mi->mi_tsize =
1939 		    MIN(garp->n4g_ext_res->n4g_maxread,
1940 		    mi->mi_tsize);
1941 
1942 	if (garp->n4g_ext_res->n4g_maxwrite == 0)
1943 		mi->mi_stsize =
1944 		    MIN(MAXBSIZE, mi->mi_stsize);
1945 	else
1946 		mi->mi_stsize =
1947 		    MIN(garp->n4g_ext_res->n4g_maxwrite,
1948 		    mi->mi_stsize);
1949 
1950 	if (garp->n4g_ext_res->n4g_maxfilesize != 0)
1951 		mi->mi_maxfilesize =
1952 		    MIN(garp->n4g_ext_res->n4g_maxfilesize,
1953 		    mi->mi_maxfilesize);
1954 
1955 	/*
1956 	 * If the final component is a a symbolic link, resolve the symlink,
1957 	 * then try mount again using the new path.
1958 	 *
1959 	 * Assume no symbolic link for root filesysm "/".
1960 	 */
1961 	if (*vtp == VLNK) {
1962 		/*
1963 		 * nthcomp is the total result length minus
1964 		 * the 1st 2 OPs (PUTROOTFH, GETFH),
1965 		 * then divided by 3 (LOOKUP,GETFH,GETATTR)
1966 		 *
1967 		 * e.g. PUTROOTFH GETFH LOOKUP 1st-comp GETFH GETATTR
1968 		 *	LOOKUP 2nd-comp GETFH GETATTR
1969 		 *
1970 		 *	(8 - 2)/3 = 2
1971 		 */
1972 		nthcomp = (res.array_len - 2)/3;
1973 
1974 		/*
1975 		 * Need to call nfs4_end_op before resolve_sympath to avoid
1976 		 * potential nfs4_start_op deadlock. See RFE 4777612.
1977 		 */
1978 		if (!recovery)
1979 			nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state,
1980 			    needrecov);
1981 
1982 		ep->error = resolve_sympath(mi, svp, nthcomp, resfhp, cr,
1983 		    flags);
1984 
1985 		nfs4args_lookup_free(argop, num_argops);
1986 		kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4));
1987 		xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
1988 
1989 		if (ep->error)
1990 			return;
1991 
1992 		goto recov_retry;
1993 	}
1994 
1995 	/*
1996 	 * We need to figure out where in the compound the getfh
1997 	 * for the parent directory is. If the object to be mounted is
1998 	 * the root, then there is no lookup at all:
1999 	 * PUTROOTFH, GETFH.
2000 	 * If the object to be mounted is in the root, then the compound is:
2001 	 * PUTROOTFH, GETFH, LOOKUP, GETFH, GETATTR.
2002 	 * In either of these cases, the index of the GETFH is 1.
2003 	 * If it is not at the root, then it's something like:
2004 	 * PUTROOTFH, GETFH, LOOKUP, GETFH, GETATTR,
2005 	 * LOOKUP, GETFH, GETATTR
2006 	 * In this case, the index is llndx (last lookup index) - 2.
2007 	 */
2008 	if (llndx == -1 || llndx == 2)
2009 		resop = &res.array[1];
2010 	else {
2011 		ASSERT(llndx > 2);
2012 		resop = &res.array[llndx-2];
2013 	}
2014 
2015 	ASSERT(resop->resop == OP_GETFH);
2016 	tmpfhp = &resop->nfs_resop4_u.opgetfh.object;
2017 
2018 	/* save the filehandles for the replica */
2019 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2020 	ASSERT(tmpfhp->nfs_fh4_len <= NFS4_FHSIZE);
2021 	svp->sv_pfhandle.fh_len = tmpfhp->nfs_fh4_len;
2022 	bcopy(tmpfhp->nfs_fh4_val, svp->sv_pfhandle.fh_buf,
2023 	    tmpfhp->nfs_fh4_len);
2024 	ASSERT(resfhp->nfs_fh4_len <= NFS4_FHSIZE);
2025 	svp->sv_fhandle.fh_len = resfhp->nfs_fh4_len;
2026 	bcopy(resfhp->nfs_fh4_val, svp->sv_fhandle.fh_buf, resfhp->nfs_fh4_len);
2027 
2028 	/* initialize fsid and supp_attrs for server fs */
2029 	svp->sv_fsid = garp->n4g_fsid;
2030 	svp->sv_supp_attrs =
2031 	    garp->n4g_ext_res->n4g_suppattrs | FATTR4_MANDATTR_MASK;
2032 
2033 	nfs_rw_exit(&svp->sv_lock);
2034 	nfs4args_lookup_free(argop, num_argops);
2035 	kmem_free(argop, lookuparg.arglen * sizeof (nfs_argop4));
2036 	xdr_free(xdr_COMPOUND4res_clnt, (caddr_t)&res);
2037 	if (!recovery)
2038 		nfs4_end_fop(mi, NULL, NULL, OH_MOUNT, &recov_state, needrecov);
2039 }
2040 
2041 /*
2042  * Save a copy of Servinfo4_t structure.
2043  * We might need when there is a failure in getting file handle
2044  * in case of a referral to replace servinfo4 struct and try again.
2045  */
2046 static struct servinfo4 *
copy_svp(servinfo4_t * nsvp)2047 copy_svp(servinfo4_t *nsvp)
2048 {
2049 	servinfo4_t *svp = NULL;
2050 	struct knetconfig *sknconf, *tknconf;
2051 	struct netbuf *saddr, *taddr;
2052 
2053 	svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
2054 	nfs_rw_init(&svp->sv_lock, NULL, RW_DEFAULT, NULL);
2055 	svp->sv_flags = nsvp->sv_flags;
2056 	svp->sv_fsid = nsvp->sv_fsid;
2057 	svp->sv_hostnamelen = nsvp->sv_hostnamelen;
2058 	svp->sv_pathlen = nsvp->sv_pathlen;
2059 	svp->sv_supp_attrs = nsvp->sv_supp_attrs;
2060 
2061 	svp->sv_path = kmem_alloc(svp->sv_pathlen, KM_SLEEP);
2062 	svp->sv_hostname = kmem_alloc(svp->sv_hostnamelen, KM_SLEEP);
2063 	bcopy(nsvp->sv_hostname, svp->sv_hostname, svp->sv_hostnamelen);
2064 	bcopy(nsvp->sv_path, svp->sv_path, svp->sv_pathlen);
2065 
2066 	saddr = &nsvp->sv_addr;
2067 	taddr = &svp->sv_addr;
2068 	taddr->maxlen = saddr->maxlen;
2069 	taddr->len = saddr->len;
2070 	if (saddr->len > 0) {
2071 		taddr->buf = kmem_zalloc(saddr->maxlen, KM_SLEEP);
2072 		bcopy(saddr->buf, taddr->buf, saddr->len);
2073 	}
2074 
2075 	svp->sv_knconf = kmem_zalloc(sizeof (struct knetconfig), KM_SLEEP);
2076 	sknconf = nsvp->sv_knconf;
2077 	tknconf = svp->sv_knconf;
2078 	tknconf->knc_semantics = sknconf->knc_semantics;
2079 	tknconf->knc_rdev = sknconf->knc_rdev;
2080 	if (sknconf->knc_proto != NULL) {
2081 		tknconf->knc_proto = kmem_zalloc(KNC_STRSIZE, KM_SLEEP);
2082 		bcopy(sknconf->knc_proto, (char *)tknconf->knc_proto,
2083 		    KNC_STRSIZE);
2084 	}
2085 	if (sknconf->knc_protofmly != NULL) {
2086 		tknconf->knc_protofmly = kmem_zalloc(KNC_STRSIZE, KM_SLEEP);
2087 		bcopy(sknconf->knc_protofmly, (char *)tknconf->knc_protofmly,
2088 		    KNC_STRSIZE);
2089 	}
2090 
2091 	if (nsvp->sv_origknconf != NULL) {
2092 		svp->sv_origknconf = kmem_zalloc(sizeof (struct knetconfig),
2093 		    KM_SLEEP);
2094 		sknconf = nsvp->sv_origknconf;
2095 		tknconf = svp->sv_origknconf;
2096 		tknconf->knc_semantics = sknconf->knc_semantics;
2097 		tknconf->knc_rdev = sknconf->knc_rdev;
2098 		if (sknconf->knc_proto != NULL) {
2099 			tknconf->knc_proto = kmem_zalloc(KNC_STRSIZE, KM_SLEEP);
2100 			bcopy(sknconf->knc_proto, (char *)tknconf->knc_proto,
2101 			    KNC_STRSIZE);
2102 		}
2103 		if (sknconf->knc_protofmly != NULL) {
2104 			tknconf->knc_protofmly = kmem_zalloc(KNC_STRSIZE,
2105 			    KM_SLEEP);
2106 			bcopy(sknconf->knc_protofmly,
2107 			    (char *)tknconf->knc_protofmly, KNC_STRSIZE);
2108 		}
2109 	}
2110 
2111 	svp->sv_secdata = copy_sec_data(nsvp->sv_secdata);
2112 	svp->sv_dhsec = copy_sec_data(svp->sv_dhsec);
2113 	/*
2114 	 * Rest of the security information is not copied as they are built
2115 	 * with the information available from secdata and dhsec.
2116 	 */
2117 	svp->sv_next = NULL;
2118 
2119 	return (svp);
2120 }
2121 
2122 servinfo4_t *
restore_svp(mntinfo4_t * mi,servinfo4_t * svp,servinfo4_t * origsvp)2123 restore_svp(mntinfo4_t *mi, servinfo4_t *svp, servinfo4_t *origsvp)
2124 {
2125 	servinfo4_t *srvnext, *tmpsrv;
2126 
2127 	if (strcmp(svp->sv_hostname, origsvp->sv_hostname) != 0) {
2128 		/*
2129 		 * Since the hostname changed, we must be dealing
2130 		 * with a referral, and the lookup failed.  We will
2131 		 * restore the whole servinfo4_t to what it was before.
2132 		 */
2133 		srvnext = svp->sv_next;
2134 		svp->sv_next = NULL;
2135 		tmpsrv = copy_svp(origsvp);
2136 		sv4_free(svp);
2137 		svp = tmpsrv;
2138 		svp->sv_next = srvnext;
2139 		mutex_enter(&mi->mi_lock);
2140 		mi->mi_servers = svp;
2141 		mi->mi_curr_serv = svp;
2142 		mutex_exit(&mi->mi_lock);
2143 
2144 	} else if (origsvp->sv_pathlen != svp->sv_pathlen) {
2145 
2146 		/*
2147 		 * For symlink case: restore original path because
2148 		 * it might have contained symlinks that were
2149 		 * expanded by nfsgetfh_otw before the failure occurred.
2150 		 */
2151 		(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
2152 		kmem_free(svp->sv_path, svp->sv_pathlen);
2153 		svp->sv_path =
2154 		    kmem_alloc(origsvp->sv_pathlen, KM_SLEEP);
2155 		svp->sv_pathlen = origsvp->sv_pathlen;
2156 		bcopy(origsvp->sv_path, svp->sv_path,
2157 		    origsvp->sv_pathlen);
2158 		nfs_rw_exit(&svp->sv_lock);
2159 	}
2160 	return (svp);
2161 }
2162 
2163 static ushort_t nfs4_max_threads = 8;	/* max number of active async threads */
2164 uint_t nfs4_bsize = 32 * 1024;	/* client `block' size */
2165 static uint_t nfs4_async_clusters = 1;	/* # of reqs from each async queue */
2166 static uint_t nfs4_cots_timeo = NFS_COTS_TIMEO;
2167 
2168 /*
2169  * Remap the root filehandle for the given filesystem.
2170  *
2171  * results returned via the nfs4_error_t parameter.
2172  */
2173 void
nfs4_remap_root(mntinfo4_t * mi,nfs4_error_t * ep,int flags)2174 nfs4_remap_root(mntinfo4_t *mi, nfs4_error_t *ep, int flags)
2175 {
2176 	struct servinfo4 *svp, *origsvp;
2177 	vtype_t vtype;
2178 	nfs_fh4 rootfh;
2179 	int getfh_flags;
2180 	int num_retry;
2181 
2182 	mutex_enter(&mi->mi_lock);
2183 
2184 remap_retry:
2185 	svp = mi->mi_curr_serv;
2186 	getfh_flags =
2187 	    (flags & NFS4_REMAP_NEEDSOP) ? NFS4_GETFH_NEEDSOP : 0;
2188 	getfh_flags |=
2189 	    (mi->mi_flags & MI4_PUBLIC) ? NFS4_GETFH_PUBLIC : 0;
2190 	mutex_exit(&mi->mi_lock);
2191 
2192 	/*
2193 	 * Just in case server path being mounted contains
2194 	 * symlinks and fails w/STALE, save the initial sv_path
2195 	 * so we can redrive the initial mount compound with the
2196 	 * initial sv_path -- not a symlink-expanded version.
2197 	 *
2198 	 * This could only happen if a symlink was expanded
2199 	 * and the expanded mount compound failed stale.  Because
2200 	 * it could be the case that the symlink was removed at
2201 	 * the server (and replaced with another symlink/dir,
2202 	 * we need to use the initial sv_path when attempting
2203 	 * to re-lookup everything and recover.
2204 	 */
2205 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
2206 	origsvp = copy_svp(svp);
2207 	nfs_rw_exit(&svp->sv_lock);
2208 
2209 	num_retry = nfs4_max_mount_retry;
2210 
2211 	do {
2212 		/*
2213 		 * Get the root fh from the server.  Retry nfs4_max_mount_retry
2214 		 * (2) times if it fails with STALE since the recovery
2215 		 * infrastructure doesn't do STALE recovery for components
2216 		 * of the server path to the object being mounted.
2217 		 */
2218 		nfs4getfh_otw(mi, svp, &vtype, getfh_flags, CRED(), ep);
2219 
2220 		if (ep->error == 0 && ep->stat == NFS4_OK)
2221 			break;
2222 
2223 		/*
2224 		 * For some reason, the mount compound failed.  Before
2225 		 * retrying, we need to restore original conditions.
2226 		 */
2227 		svp = restore_svp(mi, svp, origsvp);
2228 
2229 	} while (num_retry-- > 0);
2230 
2231 	sv4_free(origsvp);
2232 
2233 	if (ep->error != 0 || ep->stat != 0) {
2234 		return;
2235 	}
2236 
2237 	if (vtype != VNON && vtype != mi->mi_type) {
2238 		/* shouldn't happen */
2239 		zcmn_err(mi->mi_zone->zone_id, CE_WARN,
2240 		    "nfs4_remap_root: server root vnode type (%d) doesn't "
2241 		    "match mount info (%d)", vtype, mi->mi_type);
2242 	}
2243 
2244 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
2245 	rootfh.nfs_fh4_val = svp->sv_fhandle.fh_buf;
2246 	rootfh.nfs_fh4_len = svp->sv_fhandle.fh_len;
2247 	nfs_rw_exit(&svp->sv_lock);
2248 	sfh4_update(mi->mi_rootfh, &rootfh);
2249 
2250 	/*
2251 	 * It's possible that recovery took place on the filesystem
2252 	 * and the server has been updated between the time we did
2253 	 * the nfs4getfh_otw and now. Re-drive the otw operation
2254 	 * to make sure we have a good fh.
2255 	 */
2256 	mutex_enter(&mi->mi_lock);
2257 	if (mi->mi_curr_serv != svp)
2258 		goto remap_retry;
2259 
2260 	mutex_exit(&mi->mi_lock);
2261 }
2262 
2263 static int
nfs4rootvp(vnode_t ** rtvpp,vfs_t * vfsp,struct servinfo4 * svp_head,int flags,cred_t * cr,zone_t * zone)2264 nfs4rootvp(vnode_t **rtvpp, vfs_t *vfsp, struct servinfo4 *svp_head,
2265     int flags, cred_t *cr, zone_t *zone)
2266 {
2267 	vnode_t *rtvp = NULL;
2268 	mntinfo4_t *mi;
2269 	dev_t nfs_dev;
2270 	int error = 0;
2271 	rnode4_t *rp;
2272 	int i, len;
2273 	struct vattr va;
2274 	vtype_t vtype = VNON;
2275 	vtype_t tmp_vtype = VNON;
2276 	struct servinfo4 *firstsvp = NULL, *svp = svp_head;
2277 	nfs4_oo_hash_bucket_t *bucketp;
2278 	nfs_fh4 fh;
2279 	char *droptext = "";
2280 	struct nfs_stats *nfsstatsp;
2281 	nfs4_fname_t *mfname;
2282 	nfs4_error_t e;
2283 	int num_retry, removed;
2284 	cred_t *lcr = NULL, *tcr = cr;
2285 	struct servinfo4 *origsvp;
2286 	char *resource;
2287 
2288 	nfsstatsp = zone_getspecific(nfsstat_zone_key, nfs_zone());
2289 	ASSERT(nfsstatsp != NULL);
2290 
2291 	ASSERT(nfs_zone() == zone);
2292 	ASSERT(crgetref(cr));
2293 
2294 	/*
2295 	 * Create a mount record and link it to the vfs struct.
2296 	 */
2297 	mi = kmem_zalloc(sizeof (*mi), KM_SLEEP);
2298 	mutex_init(&mi->mi_lock, NULL, MUTEX_DEFAULT, NULL);
2299 	nfs_rw_init(&mi->mi_recovlock, NULL, RW_DEFAULT, NULL);
2300 	nfs_rw_init(&mi->mi_rename_lock, NULL, RW_DEFAULT, NULL);
2301 	nfs_rw_init(&mi->mi_fh_lock, NULL, RW_DEFAULT, NULL);
2302 
2303 	if (!(flags & NFSMNT_SOFT))
2304 		mi->mi_flags |= MI4_HARD;
2305 	if ((flags & NFSMNT_NOPRINT))
2306 		mi->mi_flags |= MI4_NOPRINT;
2307 	if (flags & NFSMNT_INT)
2308 		mi->mi_flags |= MI4_INT;
2309 	if (flags & NFSMNT_PUBLIC)
2310 		mi->mi_flags |= MI4_PUBLIC;
2311 	if (flags & NFSMNT_MIRRORMOUNT)
2312 		mi->mi_flags |= MI4_MIRRORMOUNT;
2313 	if (flags & NFSMNT_REFERRAL)
2314 		mi->mi_flags |= MI4_REFERRAL;
2315 	mi->mi_retrans = NFS_RETRIES;
2316 	if (svp->sv_knconf->knc_semantics == NC_TPI_COTS_ORD ||
2317 	    svp->sv_knconf->knc_semantics == NC_TPI_COTS)
2318 		mi->mi_timeo = nfs4_cots_timeo;
2319 	else
2320 		mi->mi_timeo = NFS_TIMEO;
2321 	mi->mi_prog = NFS_PROGRAM;
2322 	mi->mi_vers = NFS_V4;
2323 	mi->mi_rfsnames = rfsnames_v4;
2324 	mi->mi_reqs = nfsstatsp->nfs_stats_v4.rfsreqcnt_ptr;
2325 	cv_init(&mi->mi_failover_cv, NULL, CV_DEFAULT, NULL);
2326 	mi->mi_servers = svp;
2327 	mi->mi_curr_serv = svp;
2328 	mi->mi_acregmin = SEC2HR(ACREGMIN);
2329 	mi->mi_acregmax = SEC2HR(ACREGMAX);
2330 	mi->mi_acdirmin = SEC2HR(ACDIRMIN);
2331 	mi->mi_acdirmax = SEC2HR(ACDIRMAX);
2332 	mi->mi_fh_expire_type = FH4_PERSISTENT;
2333 	mi->mi_clientid_next = NULL;
2334 	mi->mi_clientid_prev = NULL;
2335 	mi->mi_srv = NULL;
2336 	mi->mi_grace_wait = 0;
2337 	mi->mi_error = 0;
2338 	mi->mi_srvsettime = 0;
2339 	mi->mi_srvset_cnt = 0;
2340 
2341 	mi->mi_count = 1;
2342 
2343 	mi->mi_tsize = nfs4_tsize(svp->sv_knconf);
2344 	mi->mi_stsize = mi->mi_tsize;
2345 
2346 	if (flags & NFSMNT_DIRECTIO)
2347 		mi->mi_flags |= MI4_DIRECTIO;
2348 
2349 	mi->mi_flags |= MI4_MOUNTING;
2350 
2351 	mutex_init(&mi->mi_rnodes_lock, NULL, MUTEX_DEFAULT, NULL);
2352 	list_create(&mi->mi_rnodes, sizeof (rnode4_t),
2353 	    offsetof(rnode4_t, r_mi_link));
2354 
2355 	/*
2356 	 * Make a vfs struct for nfs.  We do this here instead of below
2357 	 * because rtvp needs a vfs before we can do a getattr on it.
2358 	 *
2359 	 * Assign a unique device id to the mount
2360 	 */
2361 	mutex_enter(&nfs_minor_lock);
2362 	do {
2363 		nfs_minor = (nfs_minor + 1) & MAXMIN32;
2364 		nfs_dev = makedevice(nfs_major, nfs_minor);
2365 	} while (vfs_devismounted(nfs_dev));
2366 	mutex_exit(&nfs_minor_lock);
2367 
2368 	vfsp->vfs_dev = nfs_dev;
2369 	vfs_make_fsid(&vfsp->vfs_fsid, nfs_dev, nfs4fstyp);
2370 	vfsp->vfs_data = (caddr_t)mi;
2371 	vfsp->vfs_fstype = nfsfstyp;
2372 	vfsp->vfs_bsize = nfs4_bsize;
2373 
2374 	/*
2375 	 * Initialize fields used to support async putpage operations.
2376 	 */
2377 	for (i = 0; i < NFS4_ASYNC_TYPES; i++)
2378 		mi->mi_async_clusters[i] = nfs4_async_clusters;
2379 	mi->mi_async_init_clusters = nfs4_async_clusters;
2380 	mi->mi_async_curr[NFS4_ASYNC_QUEUE] =
2381 	    mi->mi_async_curr[NFS4_ASYNC_PGOPS_QUEUE] = &mi->mi_async_reqs[0];
2382 	mi->mi_max_threads = nfs4_max_threads;
2383 	mutex_init(&mi->mi_async_lock, NULL, MUTEX_DEFAULT, NULL);
2384 	cv_init(&mi->mi_async_reqs_cv, NULL, CV_DEFAULT, NULL);
2385 	cv_init(&mi->mi_async_work_cv[NFS4_ASYNC_QUEUE], NULL, CV_DEFAULT,
2386 	    NULL);
2387 	cv_init(&mi->mi_async_work_cv[NFS4_ASYNC_PGOPS_QUEUE], NULL,
2388 	    CV_DEFAULT, NULL);
2389 	cv_init(&mi->mi_async_cv, NULL, CV_DEFAULT, NULL);
2390 	cv_init(&mi->mi_inact_req_cv, NULL, CV_DEFAULT, NULL);
2391 
2392 	mi->mi_vfsp = vfsp;
2393 	mi->mi_zone = zone;
2394 	zone_init_ref(&mi->mi_zone_ref);
2395 	zone_hold_ref(zone, &mi->mi_zone_ref, ZONE_REF_NFSV4);
2396 	nfs4_mi_zonelist_add(mi);
2397 
2398 	/*
2399 	 * Initialize the <open owner/cred> hash table.
2400 	 */
2401 	for (i = 0; i < NFS4_NUM_OO_BUCKETS; i++) {
2402 		bucketp = &(mi->mi_oo_list[i]);
2403 		mutex_init(&bucketp->b_lock, NULL, MUTEX_DEFAULT, NULL);
2404 		list_create(&bucketp->b_oo_hash_list,
2405 		    sizeof (nfs4_open_owner_t),
2406 		    offsetof(nfs4_open_owner_t, oo_hash_node));
2407 	}
2408 
2409 	/*
2410 	 * Initialize the freed open owner list.
2411 	 */
2412 	mi->mi_foo_num = 0;
2413 	mi->mi_foo_max = NFS4_NUM_FREED_OPEN_OWNERS;
2414 	list_create(&mi->mi_foo_list, sizeof (nfs4_open_owner_t),
2415 	    offsetof(nfs4_open_owner_t, oo_foo_node));
2416 
2417 	list_create(&mi->mi_lost_state, sizeof (nfs4_lost_rqst_t),
2418 	    offsetof(nfs4_lost_rqst_t, lr_node));
2419 
2420 	list_create(&mi->mi_bseqid_list, sizeof (nfs4_bseqid_entry_t),
2421 	    offsetof(nfs4_bseqid_entry_t, bs_node));
2422 
2423 	/*
2424 	 * Initialize the msg buffer.
2425 	 */
2426 	list_create(&mi->mi_msg_list, sizeof (nfs4_debug_msg_t),
2427 	    offsetof(nfs4_debug_msg_t, msg_node));
2428 	mi->mi_msg_count = 0;
2429 	mutex_init(&mi->mi_msg_list_lock, NULL, MUTEX_DEFAULT, NULL);
2430 
2431 	/*
2432 	 * Initialize kstats
2433 	 */
2434 	nfs4_mnt_kstat_init(vfsp);
2435 
2436 	/*
2437 	 * Initialize the shared filehandle pool.
2438 	 */
2439 	sfh4_createtab(&mi->mi_filehandles);
2440 
2441 	/*
2442 	 * Save server path we're attempting to mount.
2443 	 */
2444 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2445 	origsvp = copy_svp(svp);
2446 	nfs_rw_exit(&svp->sv_lock);
2447 
2448 	/*
2449 	 * Make the GETFH call to get root fh for each replica.
2450 	 */
2451 	if (svp_head->sv_next)
2452 		droptext = ", dropping replica";
2453 
2454 	/*
2455 	 * If the uid is set then set the creds for secure mounts
2456 	 * by proxy processes such as automountd.
2457 	 */
2458 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
2459 	if (svp->sv_secdata->uid != 0 &&
2460 	    svp->sv_secdata->rpcflavor == RPCSEC_GSS) {
2461 		lcr = crdup(cr);
2462 		(void) crsetugid(lcr, svp->sv_secdata->uid, crgetgid(cr));
2463 		tcr = lcr;
2464 	}
2465 	nfs_rw_exit(&svp->sv_lock);
2466 	for (svp = svp_head; svp; svp = svp->sv_next) {
2467 		if (nfs4_chkdup_servinfo4(svp_head, svp)) {
2468 			nfs_cmn_err(error, CE_WARN,
2469 			    VERS_MSG "Host %s is a duplicate%s",
2470 			    svp->sv_hostname, droptext);
2471 			(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2472 			svp->sv_flags |= SV4_NOTINUSE;
2473 			nfs_rw_exit(&svp->sv_lock);
2474 			continue;
2475 		}
2476 		mi->mi_curr_serv = svp;
2477 
2478 		/*
2479 		 * Just in case server path being mounted contains
2480 		 * symlinks and fails w/STALE, save the initial sv_path
2481 		 * so we can redrive the initial mount compound with the
2482 		 * initial sv_path -- not a symlink-expanded version.
2483 		 *
2484 		 * This could only happen if a symlink was expanded
2485 		 * and the expanded mount compound failed stale.  Because
2486 		 * it could be the case that the symlink was removed at
2487 		 * the server (and replaced with another symlink/dir,
2488 		 * we need to use the initial sv_path when attempting
2489 		 * to re-lookup everything and recover.
2490 		 *
2491 		 * Other mount errors should evenutally be handled here also
2492 		 * (NFS4ERR_DELAY, NFS4ERR_RESOURCE).  For now, all mount
2493 		 * failures will result in mount being redriven a few times.
2494 		 */
2495 		num_retry = nfs4_max_mount_retry;
2496 		do {
2497 			nfs4getfh_otw(mi, svp, &tmp_vtype,
2498 			    ((flags & NFSMNT_PUBLIC) ? NFS4_GETFH_PUBLIC : 0) |
2499 			    NFS4_GETFH_NEEDSOP, tcr, &e);
2500 
2501 			if (e.error == 0 && e.stat == NFS4_OK)
2502 				break;
2503 
2504 			/*
2505 			 * For some reason, the mount compound failed.  Before
2506 			 * retrying, we need to restore original conditions.
2507 			 */
2508 			svp = restore_svp(mi, svp, origsvp);
2509 			svp_head = svp;
2510 
2511 		} while (num_retry-- > 0);
2512 		error = e.error ? e.error : geterrno4(e.stat);
2513 		if (error) {
2514 			nfs_cmn_err(error, CE_WARN,
2515 			    VERS_MSG "initial call to %s failed%s: %m",
2516 			    svp->sv_hostname, droptext);
2517 			(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2518 			svp->sv_flags |= SV4_NOTINUSE;
2519 			nfs_rw_exit(&svp->sv_lock);
2520 			mi->mi_flags &= ~MI4_RECOV_FAIL;
2521 			mi->mi_error = 0;
2522 			continue;
2523 		}
2524 
2525 		if (tmp_vtype == VBAD) {
2526 			zcmn_err(mi->mi_zone->zone_id, CE_WARN,
2527 			    VERS_MSG "%s returned a bad file type for "
2528 			    "root%s", svp->sv_hostname, droptext);
2529 			(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2530 			svp->sv_flags |= SV4_NOTINUSE;
2531 			nfs_rw_exit(&svp->sv_lock);
2532 			continue;
2533 		}
2534 
2535 		if (vtype == VNON) {
2536 			vtype = tmp_vtype;
2537 		} else if (vtype != tmp_vtype) {
2538 			zcmn_err(mi->mi_zone->zone_id, CE_WARN,
2539 			    VERS_MSG "%s returned a different file type "
2540 			    "for root%s", svp->sv_hostname, droptext);
2541 			(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2542 			svp->sv_flags |= SV4_NOTINUSE;
2543 			nfs_rw_exit(&svp->sv_lock);
2544 			continue;
2545 		}
2546 		if (firstsvp == NULL)
2547 			firstsvp = svp;
2548 	}
2549 
2550 	if (firstsvp == NULL) {
2551 		if (error == 0)
2552 			error = ENOENT;
2553 		goto bad;
2554 	}
2555 
2556 	mi->mi_curr_serv = svp = firstsvp;
2557 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
2558 	ASSERT((mi->mi_curr_serv->sv_flags & SV4_NOTINUSE) == 0);
2559 	fh.nfs_fh4_len = svp->sv_fhandle.fh_len;
2560 	fh.nfs_fh4_val = svp->sv_fhandle.fh_buf;
2561 	mi->mi_rootfh = sfh4_get(&fh, mi);
2562 	fh.nfs_fh4_len = svp->sv_pfhandle.fh_len;
2563 	fh.nfs_fh4_val = svp->sv_pfhandle.fh_buf;
2564 	mi->mi_srvparentfh = sfh4_get(&fh, mi);
2565 	nfs_rw_exit(&svp->sv_lock);
2566 
2567 	/*
2568 	 * Get the fname for filesystem root.
2569 	 */
2570 	mi->mi_fname = fn_get(NULL, ".", mi->mi_rootfh);
2571 	mfname = mi->mi_fname;
2572 	fn_hold(mfname);
2573 
2574 	/*
2575 	 * Make the root vnode without attributes.
2576 	 */
2577 	rtvp = makenfs4node_by_fh(mi->mi_rootfh, NULL,
2578 	    &mfname, NULL, mi, cr, gethrtime());
2579 	rtvp->v_type = vtype;
2580 
2581 	mi->mi_curread = mi->mi_tsize;
2582 	mi->mi_curwrite = mi->mi_stsize;
2583 
2584 	/*
2585 	 * Start the manager thread responsible for handling async worker
2586 	 * threads.
2587 	 */
2588 	MI4_HOLD(mi);
2589 	VFS_HOLD(vfsp);	/* add reference for thread */
2590 	mi->mi_manager_thread = zthread_create(NULL, 0, nfs4_async_manager,
2591 	    vfsp, 0, minclsyspri);
2592 	ASSERT(mi->mi_manager_thread != NULL);
2593 
2594 	/*
2595 	 * Create the thread that handles over-the-wire calls for
2596 	 * VOP_INACTIVE.
2597 	 * This needs to happen after the manager thread is created.
2598 	 */
2599 	MI4_HOLD(mi);
2600 	mi->mi_inactive_thread = zthread_create(NULL, 0, nfs4_inactive_thread,
2601 	    mi, 0, minclsyspri);
2602 	ASSERT(mi->mi_inactive_thread != NULL);
2603 
2604 	/* If we didn't get a type, get one now */
2605 	if (rtvp->v_type == VNON) {
2606 		va.va_mask = AT_TYPE;
2607 		error = nfs4getattr(rtvp, &va, tcr);
2608 		if (error)
2609 			goto bad;
2610 		rtvp->v_type = va.va_type;
2611 	}
2612 
2613 	mi->mi_type = rtvp->v_type;
2614 
2615 	mutex_enter(&mi->mi_lock);
2616 	mi->mi_flags &= ~MI4_MOUNTING;
2617 	mutex_exit(&mi->mi_lock);
2618 
2619 	/* Update VFS with new server and path info */
2620 	if ((strcmp(svp->sv_hostname, origsvp->sv_hostname) != 0) ||
2621 	    (strcmp(svp->sv_path, origsvp->sv_path) != 0)) {
2622 		len = svp->sv_hostnamelen + svp->sv_pathlen;
2623 		resource = kmem_zalloc(len, KM_SLEEP);
2624 		(void) strcat(resource, svp->sv_hostname);
2625 		(void) strcat(resource, ":");
2626 		(void) strcat(resource, svp->sv_path);
2627 		vfs_setresource(vfsp, resource, 0);
2628 		kmem_free(resource, len);
2629 	}
2630 
2631 	sv4_free(origsvp);
2632 	*rtvpp = rtvp;
2633 	if (lcr != NULL)
2634 		crfree(lcr);
2635 
2636 	return (0);
2637 bad:
2638 	/*
2639 	 * An error occurred somewhere, need to clean up...
2640 	 */
2641 	if (lcr != NULL)
2642 		crfree(lcr);
2643 
2644 	if (rtvp != NULL) {
2645 		/*
2646 		 * We need to release our reference to the root vnode and
2647 		 * destroy the mntinfo4 struct that we just created.
2648 		 */
2649 		rp = VTOR4(rtvp);
2650 		if (rp->r_flags & R4HASHED)
2651 			rp4_rmhash(rp);
2652 		VN_RELE(rtvp);
2653 	}
2654 	nfs4_async_stop(vfsp);
2655 	nfs4_async_manager_stop(vfsp);
2656 	removed = nfs4_mi_zonelist_remove(mi);
2657 	if (removed)
2658 		zone_rele_ref(&mi->mi_zone_ref, ZONE_REF_NFSV4);
2659 
2660 	/*
2661 	 * This releases the initial "hold" of the mi since it will never
2662 	 * be referenced by the vfsp.  Also, when mount returns to vfs.c
2663 	 * with an error, the vfsp will be destroyed, not rele'd.
2664 	 */
2665 	MI4_RELE(mi);
2666 
2667 	if (origsvp != NULL)
2668 		sv4_free(origsvp);
2669 
2670 	*rtvpp = NULL;
2671 	return (error);
2672 }
2673 
2674 /*
2675  * vfs operations
2676  */
2677 static int
nfs4_unmount(vfs_t * vfsp,int flag,cred_t * cr)2678 nfs4_unmount(vfs_t *vfsp, int flag, cred_t *cr)
2679 {
2680 	mntinfo4_t		*mi;
2681 	ushort_t		omax;
2682 	int			removed;
2683 
2684 	bool_t			must_unlock;
2685 
2686 	nfs4_ephemeral_tree_t	*eph_tree;
2687 
2688 	if (secpolicy_fs_unmount(cr, vfsp) != 0)
2689 		return (EPERM);
2690 
2691 	mi = VFTOMI4(vfsp);
2692 
2693 	if (flag & MS_FORCE) {
2694 		vfsp->vfs_flag |= VFS_UNMOUNTED;
2695 		if (nfs_zone() != mi->mi_zone) {
2696 			/*
2697 			 * If the request is coming from the wrong zone,
2698 			 * we don't want to create any new threads, and
2699 			 * performance is not a concern.  Do everything
2700 			 * inline.
2701 			 */
2702 			NFS4_DEBUG(nfs4_client_zone_debug, (CE_NOTE,
2703 			    "nfs4_unmount x-zone forced unmount of vfs %p\n",
2704 			    (void *)vfsp));
2705 			nfs4_free_mount(vfsp, flag, cr);
2706 		} else {
2707 			/*
2708 			 * Free data structures asynchronously, to avoid
2709 			 * blocking the current thread (for performance
2710 			 * reasons only).
2711 			 */
2712 			async_free_mount(vfsp, flag, cr);
2713 		}
2714 
2715 		return (0);
2716 	}
2717 
2718 	/*
2719 	 * Wait until all asynchronous putpage operations on
2720 	 * this file system are complete before flushing rnodes
2721 	 * from the cache.
2722 	 */
2723 	omax = mi->mi_max_threads;
2724 	if (nfs4_async_stop_sig(vfsp))
2725 		return (EINTR);
2726 
2727 	r4flush(vfsp, cr);
2728 
2729 	/*
2730 	 * About the only reason that this would fail would be
2731 	 * that the harvester is already busy tearing down this
2732 	 * node. So we fail back to the caller and let them try
2733 	 * again when needed.
2734 	 */
2735 	if (nfs4_ephemeral_umount(mi, flag, cr,
2736 	    &must_unlock, &eph_tree)) {
2737 		ASSERT(must_unlock == FALSE);
2738 		mutex_enter(&mi->mi_async_lock);
2739 		mi->mi_max_threads = omax;
2740 		mutex_exit(&mi->mi_async_lock);
2741 
2742 		return (EBUSY);
2743 	}
2744 
2745 	/*
2746 	 * If there are any active vnodes on this file system,
2747 	 * then the file system is busy and can't be unmounted.
2748 	 */
2749 	if (check_rtable4(vfsp)) {
2750 		nfs4_ephemeral_umount_unlock(&must_unlock, &eph_tree);
2751 
2752 		mutex_enter(&mi->mi_async_lock);
2753 		mi->mi_max_threads = omax;
2754 		mutex_exit(&mi->mi_async_lock);
2755 
2756 		return (EBUSY);
2757 	}
2758 
2759 	/*
2760 	 * The unmount can't fail from now on, so record any
2761 	 * ephemeral changes.
2762 	 */
2763 	nfs4_ephemeral_umount_activate(mi, &must_unlock, &eph_tree);
2764 
2765 	/*
2766 	 * There are no active files that could require over-the-wire
2767 	 * calls to the server, so stop the async manager and the
2768 	 * inactive thread.
2769 	 */
2770 	nfs4_async_manager_stop(vfsp);
2771 
2772 	/*
2773 	 * Destroy all rnodes belonging to this file system from the
2774 	 * rnode hash queues and purge any resources allocated to
2775 	 * them.
2776 	 */
2777 	destroy_rtable4(vfsp, cr);
2778 	vfsp->vfs_flag |= VFS_UNMOUNTED;
2779 
2780 	nfs4_remove_mi_from_server(mi, NULL);
2781 	removed = nfs4_mi_zonelist_remove(mi);
2782 	if (removed)
2783 		zone_rele_ref(&mi->mi_zone_ref, ZONE_REF_NFSV4);
2784 
2785 	return (0);
2786 }
2787 
2788 /*
2789  * find root of nfs
2790  */
2791 static int
nfs4_root(vfs_t * vfsp,vnode_t ** vpp)2792 nfs4_root(vfs_t *vfsp, vnode_t **vpp)
2793 {
2794 	mntinfo4_t *mi;
2795 	vnode_t *vp;
2796 	nfs4_fname_t *mfname;
2797 	servinfo4_t *svp;
2798 
2799 	mi = VFTOMI4(vfsp);
2800 
2801 	if (nfs_zone() != mi->mi_zone)
2802 		return (EPERM);
2803 
2804 	svp = mi->mi_curr_serv;
2805 	if (svp) {
2806 		(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
2807 		if (svp->sv_flags & SV4_ROOT_STALE) {
2808 			nfs_rw_exit(&svp->sv_lock);
2809 
2810 			(void) nfs_rw_enter_sig(&svp->sv_lock, RW_WRITER, 0);
2811 			if (svp->sv_flags & SV4_ROOT_STALE) {
2812 				svp->sv_flags &= ~SV4_ROOT_STALE;
2813 				nfs_rw_exit(&svp->sv_lock);
2814 				return (ENOENT);
2815 			}
2816 			nfs_rw_exit(&svp->sv_lock);
2817 		} else
2818 			nfs_rw_exit(&svp->sv_lock);
2819 	}
2820 
2821 	mfname = mi->mi_fname;
2822 	fn_hold(mfname);
2823 	vp = makenfs4node_by_fh(mi->mi_rootfh, NULL, &mfname, NULL,
2824 	    VFTOMI4(vfsp), CRED(), gethrtime());
2825 
2826 	if (VTOR4(vp)->r_flags & R4STALE) {
2827 		VN_RELE(vp);
2828 		return (ENOENT);
2829 	}
2830 
2831 	ASSERT(vp->v_type == VNON || vp->v_type == mi->mi_type);
2832 
2833 	vp->v_type = mi->mi_type;
2834 
2835 	*vpp = vp;
2836 
2837 	return (0);
2838 }
2839 
2840 static int
nfs4_statfs_otw(vnode_t * vp,struct statvfs64 * sbp,cred_t * cr)2841 nfs4_statfs_otw(vnode_t *vp, struct statvfs64 *sbp, cred_t *cr)
2842 {
2843 	int error;
2844 	nfs4_ga_res_t gar;
2845 	nfs4_ga_ext_res_t ger;
2846 
2847 	gar.n4g_ext_res = &ger;
2848 
2849 	if (error = nfs4_attr_otw(vp, TAG_FSINFO, &gar,
2850 	    NFS4_STATFS_ATTR_MASK, cr))
2851 		return (error);
2852 
2853 	*sbp = gar.n4g_ext_res->n4g_sb;
2854 
2855 	return (0);
2856 }
2857 
2858 /*
2859  * Get file system statistics.
2860  */
2861 static int
nfs4_statvfs(vfs_t * vfsp,struct statvfs64 * sbp)2862 nfs4_statvfs(vfs_t *vfsp, struct statvfs64 *sbp)
2863 {
2864 	int error;
2865 	vnode_t *vp;
2866 	cred_t *cr;
2867 
2868 	error = nfs4_root(vfsp, &vp);
2869 	if (error)
2870 		return (error);
2871 
2872 	cr = CRED();
2873 
2874 	error = nfs4_statfs_otw(vp, sbp, cr);
2875 	if (!error) {
2876 		(void) strncpy(sbp->f_basetype,
2877 		    vfssw[vfsp->vfs_fstype].vsw_name, FSTYPSZ);
2878 		sbp->f_flag = vf_to_stf(vfsp->vfs_flag);
2879 	} else {
2880 		nfs4_purge_stale_fh(error, vp, cr);
2881 	}
2882 
2883 	VN_RELE(vp);
2884 
2885 	return (error);
2886 }
2887 
2888 static kmutex_t nfs4_syncbusy;
2889 
2890 /*
2891  * Flush dirty nfs files for file system vfsp.
2892  * If vfsp == NULL, all nfs files are flushed.
2893  *
2894  * SYNC_CLOSE in flag is passed to us to
2895  * indicate that we are shutting down and or
2896  * rebooting.
2897  */
2898 static int
nfs4_sync(vfs_t * vfsp,short flag,cred_t * cr)2899 nfs4_sync(vfs_t *vfsp, short flag, cred_t *cr)
2900 {
2901 	/*
2902 	 * Cross-zone calls are OK here, since this translates to a
2903 	 * VOP_PUTPAGE(B_ASYNC), which gets picked up by the right zone.
2904 	 */
2905 	if (!(flag & SYNC_ATTR) && mutex_tryenter(&nfs4_syncbusy) != 0) {
2906 		r4flush(vfsp, cr);
2907 		mutex_exit(&nfs4_syncbusy);
2908 	}
2909 
2910 	/*
2911 	 * if SYNC_CLOSE is set then we know that
2912 	 * the system is rebooting, mark the mntinfo
2913 	 * for later examination.
2914 	 */
2915 	if (vfsp && (flag & SYNC_CLOSE)) {
2916 		mntinfo4_t *mi;
2917 
2918 		mi = VFTOMI4(vfsp);
2919 		if (!(mi->mi_flags & MI4_SHUTDOWN)) {
2920 			mutex_enter(&mi->mi_lock);
2921 			mi->mi_flags |= MI4_SHUTDOWN;
2922 			mutex_exit(&mi->mi_lock);
2923 		}
2924 	}
2925 	return (0);
2926 }
2927 
2928 /*
2929  * vget is difficult, if not impossible, to support in v4 because we don't
2930  * know the parent directory or name, which makes it impossible to create a
2931  * useful shadow vnode.  And we need the shadow vnode for things like
2932  * OPEN.
2933  */
2934 
2935 /* ARGSUSED */
2936 /*
2937  * XXX Check nfs4_vget_pseudo() for dependency.
2938  */
2939 static int
nfs4_vget(vfs_t * vfsp,vnode_t ** vpp,fid_t * fidp)2940 nfs4_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
2941 {
2942 	return (EREMOTE);
2943 }
2944 
2945 /*
2946  * nfs4_mountroot get called in the case where we are diskless booting.  All
2947  * we need from here is the ability to get the server info and from there we
2948  * can simply call nfs4_rootvp.
2949  */
2950 /* ARGSUSED */
2951 static int
nfs4_mountroot(vfs_t * vfsp,whymountroot_t why)2952 nfs4_mountroot(vfs_t *vfsp, whymountroot_t why)
2953 {
2954 	vnode_t *rtvp;
2955 	char root_hostname[SYS_NMLN+1];
2956 	struct servinfo4 *svp;
2957 	int error;
2958 	int vfsflags;
2959 	size_t size;
2960 	char *root_path;
2961 	struct pathname pn;
2962 	char *name;
2963 	cred_t *cr;
2964 	mntinfo4_t *mi;
2965 	struct nfs_args args;		/* nfs mount arguments */
2966 	static char token[10];
2967 	nfs4_error_t n4e;
2968 
2969 	bzero(&args, sizeof (args));
2970 
2971 	/* do this BEFORE getfile which causes xid stamps to be initialized */
2972 	clkset(-1L);		/* hack for now - until we get time svc? */
2973 
2974 	if (why == ROOT_REMOUNT) {
2975 		/*
2976 		 * Shouldn't happen.
2977 		 */
2978 		panic("nfs4_mountroot: why == ROOT_REMOUNT");
2979 	}
2980 
2981 	if (why == ROOT_UNMOUNT) {
2982 		/*
2983 		 * Nothing to do for NFS.
2984 		 */
2985 		return (0);
2986 	}
2987 
2988 	/*
2989 	 * why == ROOT_INIT
2990 	 */
2991 
2992 	name = token;
2993 	*name = 0;
2994 	(void) getfsname("root", name, sizeof (token));
2995 
2996 	pn_alloc(&pn);
2997 	root_path = pn.pn_path;
2998 
2999 	svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
3000 	nfs_rw_init(&svp->sv_lock, NULL, RW_DEFAULT, NULL);
3001 	svp->sv_knconf = kmem_zalloc(sizeof (*svp->sv_knconf), KM_SLEEP);
3002 	svp->sv_knconf->knc_protofmly = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
3003 	svp->sv_knconf->knc_proto = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
3004 
3005 	/*
3006 	 * Get server address
3007 	 * Get the root path
3008 	 * Get server's transport
3009 	 * Get server's hostname
3010 	 * Get options
3011 	 */
3012 	args.addr = &svp->sv_addr;
3013 	(void) nfs_rw_enter_sig(&svp->sv_lock, RW_READER, 0);
3014 	args.fh = (char *)&svp->sv_fhandle;
3015 	args.knconf = svp->sv_knconf;
3016 	args.hostname = root_hostname;
3017 	vfsflags = 0;
3018 	if (error = mount_root(*name ? name : "root", root_path, NFS_V4,
3019 	    &args, &vfsflags)) {
3020 		if (error == EPROTONOSUPPORT)
3021 			nfs_cmn_err(error, CE_WARN, "nfs4_mountroot: "
3022 			    "mount_root failed: server doesn't support NFS V4");
3023 		else
3024 			nfs_cmn_err(error, CE_WARN,
3025 			    "nfs4_mountroot: mount_root failed: %m");
3026 		nfs_rw_exit(&svp->sv_lock);
3027 		sv4_free(svp);
3028 		pn_free(&pn);
3029 		return (error);
3030 	}
3031 	nfs_rw_exit(&svp->sv_lock);
3032 	svp->sv_hostnamelen = (int)(strlen(root_hostname) + 1);
3033 	svp->sv_hostname = kmem_alloc(svp->sv_hostnamelen, KM_SLEEP);
3034 	(void) strcpy(svp->sv_hostname, root_hostname);
3035 
3036 	svp->sv_pathlen = (int)(strlen(root_path) + 1);
3037 	svp->sv_path = kmem_alloc(svp->sv_pathlen, KM_SLEEP);
3038 	(void) strcpy(svp->sv_path, root_path);
3039 
3040 	/*
3041 	 * Force root partition to always be mounted with AUTH_UNIX for now
3042 	 */
3043 	svp->sv_secdata = kmem_alloc(sizeof (*svp->sv_secdata), KM_SLEEP);
3044 	svp->sv_secdata->secmod = AUTH_UNIX;
3045 	svp->sv_secdata->rpcflavor = AUTH_UNIX;
3046 	svp->sv_secdata->data = NULL;
3047 
3048 	cr = crgetcred();
3049 	rtvp = NULL;
3050 
3051 	error = nfs4rootvp(&rtvp, vfsp, svp, args.flags, cr, global_zone);
3052 
3053 	if (error) {
3054 		crfree(cr);
3055 		pn_free(&pn);
3056 		sv4_free(svp);
3057 		return (error);
3058 	}
3059 
3060 	mi = VTOMI4(rtvp);
3061 
3062 	/*
3063 	 * Send client id to the server, if necessary
3064 	 */
3065 	nfs4_error_zinit(&n4e);
3066 	nfs4setclientid(mi, cr, FALSE, &n4e);
3067 	error = n4e.error;
3068 
3069 	crfree(cr);
3070 
3071 	if (error) {
3072 		pn_free(&pn);
3073 		goto errout;
3074 	}
3075 
3076 	error = nfs4_setopts(rtvp, DATAMODEL_NATIVE, &args);
3077 	if (error) {
3078 		nfs_cmn_err(error, CE_WARN,
3079 		    "nfs4_mountroot: invalid root mount options");
3080 		pn_free(&pn);
3081 		goto errout;
3082 	}
3083 
3084 	(void) vfs_lock_wait(vfsp);
3085 	vfs_add(NULL, vfsp, vfsflags);
3086 	vfs_unlock(vfsp);
3087 
3088 	size = strlen(svp->sv_hostname);
3089 	(void) strcpy(rootfs.bo_name, svp->sv_hostname);
3090 	rootfs.bo_name[size] = ':';
3091 	(void) strcpy(&rootfs.bo_name[size + 1], root_path);
3092 
3093 	pn_free(&pn);
3094 
3095 errout:
3096 	if (error) {
3097 		sv4_free(svp);
3098 		nfs4_async_stop(vfsp);
3099 		nfs4_async_manager_stop(vfsp);
3100 	}
3101 
3102 	if (rtvp != NULL)
3103 		VN_RELE(rtvp);
3104 
3105 	return (error);
3106 }
3107 
3108 /*
3109  * Initialization routine for VFS routines.  Should only be called once
3110  */
3111 int
nfs4_vfsinit(void)3112 nfs4_vfsinit(void)
3113 {
3114 	mutex_init(&nfs4_syncbusy, NULL, MUTEX_DEFAULT, NULL);
3115 	nfs4setclientid_init();
3116 	nfs4_ephemeral_init();
3117 	return (0);
3118 }
3119 
3120 void
nfs4_vfsfini(void)3121 nfs4_vfsfini(void)
3122 {
3123 	nfs4_ephemeral_fini();
3124 	nfs4setclientid_fini();
3125 	mutex_destroy(&nfs4_syncbusy);
3126 }
3127 
3128 void
nfs4_freevfs(vfs_t * vfsp)3129 nfs4_freevfs(vfs_t *vfsp)
3130 {
3131 	mntinfo4_t *mi;
3132 
3133 	/* need to release the initial hold */
3134 	mi = VFTOMI4(vfsp);
3135 
3136 	/*
3137 	 * At this point, we can no longer reference the vfs
3138