xref: /illumos-gate/usr/src/uts/common/fs/nfs/nfs_vfsops.c (revision dcedb507)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  *
25  *	Copyright (c) 1983,1984,1985,1986,1987,1988,1989  AT&T.
26  *	All rights reserved.
27  */
28 
29 #include <sys/param.h>
30 #include <sys/types.h>
31 #include <sys/systm.h>
32 #include <sys/cred.h>
33 #include <sys/vfs.h>
34 #include <sys/vfs_opreg.h>
35 #include <sys/vnode.h>
36 #include <sys/pathname.h>
37 #include <sys/sysmacros.h>
38 #include <sys/kmem.h>
39 #include <sys/mkdev.h>
40 #include <sys/mount.h>
41 #include <sys/mntent.h>
42 #include <sys/statvfs.h>
43 #include <sys/errno.h>
44 #include <sys/debug.h>
45 #include <sys/cmn_err.h>
46 #include <sys/utsname.h>
47 #include <sys/bootconf.h>
48 #include <sys/modctl.h>
49 #include <sys/acl.h>
50 #include <sys/flock.h>
51 #include <sys/policy.h>
52 #include <sys/zone.h>
53 #include <sys/class.h>
54 #include <sys/socket.h>
55 #include <sys/netconfig.h>
56 #include <sys/mntent.h>
57 #include <sys/tsol/label.h>
58 
59 #include <rpc/types.h>
60 #include <rpc/auth.h>
61 #include <rpc/clnt.h>
62 
63 #include <nfs/nfs.h>
64 #include <nfs/nfs_clnt.h>
65 #include <nfs/rnode.h>
66 #include <nfs/mount.h>
67 #include <nfs/nfs_acl.h>
68 
69 #include <fs/fs_subr.h>
70 
71 /*
72  * From rpcsec module (common/rpcsec).
73  */
74 extern int sec_clnt_loadinfo(struct sec_data *, struct sec_data **, model_t);
75 extern void sec_clnt_freeinfo(struct sec_data *);
76 
77 static int pathconf_copyin(struct nfs_args *, struct pathcnf *);
78 static int pathconf_get(struct mntinfo *, struct nfs_args *);
79 static void pathconf_rele(struct mntinfo *);
80 
81 /*
82  * The order and contents of this structure must be kept in sync with that of
83  * rfsreqcnt_v2_tmpl in nfs_stats.c
84  */
85 static char *rfsnames_v2[] = {
86 	"null", "getattr", "setattr", "unused", "lookup", "readlink", "read",
87 	"unused", "write", "create", "remove", "rename", "link", "symlink",
88 	"mkdir", "rmdir", "readdir", "fsstat"
89 };
90 
91 /*
92  * This table maps from NFS protocol number into call type.
93  * Zero means a "Lookup" type call
94  * One  means a "Read" type call
95  * Two  means a "Write" type call
96  * This is used to select a default time-out.
97  */
98 static uchar_t call_type_v2[] = {
99 	0, 0, 1, 0, 0, 0, 1,
100 	0, 2, 2, 2, 2, 2, 2,
101 	2, 2, 1, 0
102 };
103 
104 /*
105  * Similar table, but to determine which timer to use
106  * (only real reads and writes!)
107  */
108 static uchar_t timer_type_v2[] = {
109 	0, 0, 0, 0, 0, 0, 1,
110 	0, 2, 0, 0, 0, 0, 0,
111 	0, 0, 1, 0
112 };
113 
114 /*
115  * This table maps from NFS protocol number into a call type
116  * for the semisoft mount option.
117  * Zero means do not repeat operation.
118  * One  means repeat.
119  */
120 static uchar_t ss_call_type_v2[] = {
121 	0, 0, 1, 0, 0, 0, 0,
122 	0, 1, 1, 1, 1, 1, 1,
123 	1, 1, 0, 0
124 };
125 
126 /*
127  * nfs vfs operations.
128  */
129 static int	nfs_mount(vfs_t *, vnode_t *, struct mounta *, cred_t *);
130 static int	nfs_unmount(vfs_t *, int, cred_t *);
131 static int	nfs_root(vfs_t *, vnode_t **);
132 static int	nfs_statvfs(vfs_t *, struct statvfs64 *);
133 static int	nfs_sync(vfs_t *, short, cred_t *);
134 static int	nfs_vget(vfs_t *, vnode_t **, fid_t *);
135 static int	nfs_mountroot(vfs_t *, whymountroot_t);
136 static void	nfs_freevfs(vfs_t *);
137 
138 static int	nfsrootvp(vnode_t **, vfs_t *, struct servinfo *,
139 		    int, cred_t *, zone_t *);
140 
141 /*
142  * Initialize the vfs structure
143  */
144 
145 int nfsfstyp;
146 vfsops_t *nfs_vfsops;
147 
148 /*
149  * Debug variable to check for rdma based
150  * transport startup and cleanup. Controlled
151  * through /etc/system. Off by default.
152  */
153 int rdma_debug = 0;
154 
155 int
156 nfsinit(int fstyp, char *name)
157 {
158 	static const fs_operation_def_t nfs_vfsops_template[] = {
159 		VFSNAME_MOUNT,		{ .vfs_mount = nfs_mount },
160 		VFSNAME_UNMOUNT,	{ .vfs_unmount = nfs_unmount },
161 		VFSNAME_ROOT,		{ .vfs_root = nfs_root },
162 		VFSNAME_STATVFS,	{ .vfs_statvfs = nfs_statvfs },
163 		VFSNAME_SYNC,		{ .vfs_sync = nfs_sync },
164 		VFSNAME_VGET,		{ .vfs_vget = nfs_vget },
165 		VFSNAME_MOUNTROOT,	{ .vfs_mountroot = nfs_mountroot },
166 		VFSNAME_FREEVFS,	{ .vfs_freevfs = nfs_freevfs },
167 		NULL,			NULL
168 	};
169 	int error;
170 
171 	error = vfs_setfsops(fstyp, nfs_vfsops_template, &nfs_vfsops);
172 	if (error != 0) {
173 		zcmn_err(GLOBAL_ZONEID, CE_WARN,
174 		    "nfsinit: bad vfs ops template");
175 		return (error);
176 	}
177 
178 	error = vn_make_ops(name, nfs_vnodeops_template, &nfs_vnodeops);
179 	if (error != 0) {
180 		(void) vfs_freevfsops_by_type(fstyp);
181 		zcmn_err(GLOBAL_ZONEID, CE_WARN,
182 		    "nfsinit: bad vnode ops template");
183 		return (error);
184 	}
185 
186 
187 	nfsfstyp = fstyp;
188 
189 	return (0);
190 }
191 
192 void
193 nfsfini(void)
194 {
195 }
196 
197 static void
198 nfs_free_args(struct nfs_args *nargs, nfs_fhandle *fh)
199 {
200 
201 	if (fh)
202 		kmem_free(fh, sizeof (*fh));
203 
204 	if (nargs->pathconf) {
205 		kmem_free(nargs->pathconf, sizeof (struct pathcnf));
206 		nargs->pathconf = NULL;
207 	}
208 
209 	if (nargs->knconf) {
210 		if (nargs->knconf->knc_protofmly)
211 			kmem_free(nargs->knconf->knc_protofmly, KNC_STRSIZE);
212 		if (nargs->knconf->knc_proto)
213 			kmem_free(nargs->knconf->knc_proto, KNC_STRSIZE);
214 		kmem_free(nargs->knconf, sizeof (*nargs->knconf));
215 		nargs->knconf = NULL;
216 	}
217 
218 	if (nargs->fh) {
219 		kmem_free(nargs->fh, strlen(nargs->fh) + 1);
220 		nargs->fh = NULL;
221 	}
222 
223 	if (nargs->hostname) {
224 		kmem_free(nargs->hostname, strlen(nargs->hostname) + 1);
225 		nargs->hostname = NULL;
226 	}
227 
228 	if (nargs->addr) {
229 		if (nargs->addr->buf) {
230 			ASSERT(nargs->addr->len);
231 			kmem_free(nargs->addr->buf, nargs->addr->len);
232 		}
233 		kmem_free(nargs->addr, sizeof (struct netbuf));
234 		nargs->addr = NULL;
235 	}
236 
237 	if (nargs->syncaddr) {
238 		ASSERT(nargs->syncaddr->len);
239 		if (nargs->syncaddr->buf) {
240 			ASSERT(nargs->syncaddr->len);
241 			kmem_free(nargs->syncaddr->buf, nargs->syncaddr->len);
242 		}
243 		kmem_free(nargs->syncaddr, sizeof (struct netbuf));
244 		nargs->syncaddr = NULL;
245 	}
246 
247 	if (nargs->netname) {
248 		kmem_free(nargs->netname, strlen(nargs->netname) + 1);
249 		nargs->netname = NULL;
250 	}
251 
252 	if (nargs->nfs_ext_u.nfs_extA.secdata) {
253 		sec_clnt_freeinfo(nargs->nfs_ext_u.nfs_extA.secdata);
254 		nargs->nfs_ext_u.nfs_extA.secdata = NULL;
255 	}
256 }
257 
258 static int
259 nfs_copyin(char *data, int datalen, struct nfs_args *nargs, nfs_fhandle *fh)
260 {
261 
262 	int error;
263 	size_t nlen;			/* length of netname */
264 	size_t hlen;			/* length of hostname */
265 	char netname[MAXNETNAMELEN+1];	/* server's netname */
266 	struct netbuf addr;		/* server's address */
267 	struct netbuf syncaddr;		/* AUTH_DES time sync addr */
268 	struct knetconfig *knconf;	/* transport knetconfig structure */
269 	struct sec_data *secdata = NULL;	/* security data */
270 	STRUCT_DECL(nfs_args, args);		/* nfs mount arguments */
271 	STRUCT_DECL(knetconfig, knconf_tmp);
272 	STRUCT_DECL(netbuf, addr_tmp);
273 	int flags;
274 	struct pathcnf	*pc;		/* Pathconf */
275 	char *p, *pf;
276 	char *userbufptr;
277 
278 
279 	bzero(nargs, sizeof (*nargs));
280 
281 	STRUCT_INIT(args, get_udatamodel());
282 	bzero(STRUCT_BUF(args), SIZEOF_STRUCT(nfs_args, DATAMODEL_NATIVE));
283 	if (copyin(data, STRUCT_BUF(args), MIN(datalen, STRUCT_SIZE(args))))
284 		return (EFAULT);
285 
286 	nargs->wsize = STRUCT_FGET(args, wsize);
287 	nargs->rsize = STRUCT_FGET(args, rsize);
288 	nargs->timeo = STRUCT_FGET(args, timeo);
289 	nargs->retrans = STRUCT_FGET(args, retrans);
290 	nargs->acregmin = STRUCT_FGET(args, acregmin);
291 	nargs->acregmax = STRUCT_FGET(args, acregmax);
292 	nargs->acdirmin = STRUCT_FGET(args, acdirmin);
293 	nargs->acdirmax = STRUCT_FGET(args, acdirmax);
294 
295 	flags = STRUCT_FGET(args, flags);
296 	nargs->flags = flags;
297 
298 
299 	addr.buf = NULL;
300 	syncaddr.buf = NULL;
301 
302 	/*
303 	 * Allocate space for a knetconfig structure and
304 	 * its strings and copy in from user-land.
305 	 */
306 	knconf = kmem_zalloc(sizeof (*knconf), KM_SLEEP);
307 	STRUCT_INIT(knconf_tmp, get_udatamodel());
308 	if (copyin(STRUCT_FGETP(args, knconf), STRUCT_BUF(knconf_tmp),
309 	    STRUCT_SIZE(knconf_tmp))) {
310 		kmem_free(knconf, sizeof (*knconf));
311 		return (EFAULT);
312 	}
313 
314 	knconf->knc_semantics = STRUCT_FGET(knconf_tmp, knc_semantics);
315 	knconf->knc_protofmly = STRUCT_FGETP(knconf_tmp, knc_protofmly);
316 	knconf->knc_proto = STRUCT_FGETP(knconf_tmp, knc_proto);
317 	if (get_udatamodel() != DATAMODEL_LP64) {
318 		knconf->knc_rdev = expldev(STRUCT_FGET(knconf_tmp, knc_rdev));
319 	} else {
320 		knconf->knc_rdev = STRUCT_FGET(knconf_tmp, knc_rdev);
321 	}
322 
323 	pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
324 	p = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
325 	error = copyinstr(knconf->knc_protofmly, pf, KNC_STRSIZE, NULL);
326 	if (error) {
327 		kmem_free(pf, KNC_STRSIZE);
328 		kmem_free(p, KNC_STRSIZE);
329 		kmem_free(knconf, sizeof (*knconf));
330 		return (error);
331 	}
332 
333 	error = copyinstr(knconf->knc_proto, p, KNC_STRSIZE, NULL);
334 	if (error) {
335 		kmem_free(pf, KNC_STRSIZE);
336 		kmem_free(p, KNC_STRSIZE);
337 		kmem_free(knconf, sizeof (*knconf));
338 		return (error);
339 	}
340 
341 
342 	knconf->knc_protofmly = pf;
343 	knconf->knc_proto = p;
344 
345 	nargs->knconf = knconf;
346 
347 	/* Copyin pathconf if there is one */
348 	if (STRUCT_FGETP(args, pathconf) != NULL) {
349 		pc = kmem_alloc(sizeof (*pc), KM_SLEEP);
350 		error = pathconf_copyin(STRUCT_BUF(args), pc);
351 		nargs->pathconf = pc;
352 		if (error)
353 			goto errout;
354 	}
355 
356 	/*
357 	 * Get server address
358 	 */
359 	STRUCT_INIT(addr_tmp, get_udatamodel());
360 	if (copyin(STRUCT_FGETP(args, addr), STRUCT_BUF(addr_tmp),
361 	    STRUCT_SIZE(addr_tmp))) {
362 		error = EFAULT;
363 		goto errout;
364 	}
365 	nargs->addr = kmem_alloc(sizeof (struct netbuf), KM_SLEEP);
366 	userbufptr = STRUCT_FGETP(addr_tmp, buf);
367 	addr.len = STRUCT_FGET(addr_tmp, len);
368 	addr.buf = kmem_alloc(addr.len, KM_SLEEP);
369 	addr.maxlen = addr.len;
370 	if (copyin(userbufptr, addr.buf, addr.len)) {
371 		kmem_free(addr.buf, addr.len);
372 		error = EFAULT;
373 		goto errout;
374 	}
375 	bcopy(&addr, nargs->addr, sizeof (struct netbuf));
376 
377 	/*
378 	 * Get the root fhandle
379 	 */
380 
381 	if (copyin(STRUCT_FGETP(args, fh), &fh->fh_buf, NFS_FHSIZE)) {
382 		error = EFAULT;
383 		goto errout;
384 	}
385 	fh->fh_len = NFS_FHSIZE;
386 
387 	/*
388 	 * Get server's hostname
389 	 */
390 	if (flags & NFSMNT_HOSTNAME) {
391 		error = copyinstr(STRUCT_FGETP(args, hostname), netname,
392 		    sizeof (netname), &hlen);
393 		if (error)
394 			goto errout;
395 		nargs->hostname = kmem_zalloc(hlen, KM_SLEEP);
396 		(void) strcpy(nargs->hostname, netname);
397 
398 	} else {
399 		nargs->hostname = NULL;
400 	}
401 
402 
403 	/*
404 	 * If there are syncaddr and netname data, load them in. This is
405 	 * to support data needed for NFSV4 when AUTH_DH is the negotiated
406 	 * flavor via SECINFO. (instead of using MOUNT protocol in V3).
407 	 */
408 	netname[0] = '\0';
409 	if (flags & NFSMNT_SECURE) {
410 		if (STRUCT_FGETP(args, syncaddr) == NULL) {
411 			error = EINVAL;
412 			goto errout;
413 		}
414 		/* get syncaddr */
415 		STRUCT_INIT(addr_tmp, get_udatamodel());
416 		if (copyin(STRUCT_FGETP(args, syncaddr), STRUCT_BUF(addr_tmp),
417 		    STRUCT_SIZE(addr_tmp))) {
418 			error = EINVAL;
419 			goto errout;
420 		}
421 		userbufptr = STRUCT_FGETP(addr_tmp, buf);
422 		syncaddr.len = STRUCT_FGET(addr_tmp, len);
423 		syncaddr.buf = kmem_alloc(syncaddr.len, KM_SLEEP);
424 		syncaddr.maxlen = syncaddr.len;
425 		if (copyin(userbufptr, syncaddr.buf, syncaddr.len)) {
426 			kmem_free(syncaddr.buf, syncaddr.len);
427 			error = EFAULT;
428 			goto errout;
429 		}
430 
431 		nargs->syncaddr = kmem_alloc(sizeof (struct netbuf), KM_SLEEP);
432 		bcopy(&syncaddr, nargs->syncaddr, sizeof (struct netbuf));
433 
434 		ASSERT(STRUCT_FGETP(args, netname));
435 		if (copyinstr(STRUCT_FGETP(args, netname), netname,
436 		    sizeof (netname), &nlen)) {
437 			error = EFAULT;
438 			goto errout;
439 		}
440 
441 		netname[nlen] = '\0';
442 		nargs->netname = kmem_zalloc(nlen, KM_SLEEP);
443 		(void) strcpy(nargs->netname, netname);
444 	}
445 
446 	/*
447 	 * Get the extention data which has the security data structure.
448 	 * This includes data for AUTH_SYS as well.
449 	 */
450 	if (flags & NFSMNT_NEWARGS) {
451 		nargs->nfs_args_ext = STRUCT_FGET(args, nfs_args_ext);
452 		if (nargs->nfs_args_ext == NFS_ARGS_EXTA ||
453 		    nargs->nfs_args_ext == NFS_ARGS_EXTB) {
454 			/*
455 			 * Indicating the application is using the new
456 			 * sec_data structure to pass in the security
457 			 * data.
458 			 */
459 			if (STRUCT_FGETP(args,
460 			    nfs_ext_u.nfs_extA.secdata) != NULL) {
461 				error = sec_clnt_loadinfo(
462 				    (struct sec_data *)STRUCT_FGETP(args,
463 				    nfs_ext_u.nfs_extA.secdata), &secdata,
464 				    get_udatamodel());
465 			}
466 			nargs->nfs_ext_u.nfs_extA.secdata = secdata;
467 		}
468 	}
469 
470 	if (error)
471 		goto errout;
472 
473 	/*
474 	 * Failover support:
475 	 *
476 	 * We may have a linked list of nfs_args structures,
477 	 * which means the user is looking for failover.  If
478 	 * the mount is either not "read-only" or "soft",
479 	 * we want to bail out with EINVAL.
480 	 */
481 	if (nargs->nfs_args_ext == NFS_ARGS_EXTB)
482 		nargs->nfs_ext_u.nfs_extB.next =
483 		    STRUCT_FGETP(args, nfs_ext_u.nfs_extB.next);
484 
485 errout:
486 	if (error)
487 		nfs_free_args(nargs, fh);
488 
489 	return (error);
490 }
491 
492 
493 /*
494  * nfs mount vfsop
495  * Set up mount info record and attach it to vfs struct.
496  */
497 static int
498 nfs_mount(vfs_t *vfsp, vnode_t *mvp, struct mounta *uap, cred_t *cr)
499 {
500 	char *data = uap->dataptr;
501 	int error;
502 	vnode_t *rtvp;			/* the server's root */
503 	mntinfo_t *mi;			/* mount info, pointed at by vfs */
504 	size_t nlen;			/* length of netname */
505 	struct knetconfig *knconf;	/* transport knetconfig structure */
506 	struct knetconfig *rdma_knconf;	/* rdma transport structure */
507 	rnode_t *rp;
508 	struct servinfo *svp;		/* nfs server info */
509 	struct servinfo *svp_tail = NULL; /* previous nfs server info */
510 	struct servinfo *svp_head;	/* first nfs server info */
511 	struct servinfo *svp_2ndlast;	/* 2nd last in the server info list */
512 	struct sec_data *secdata;	/* security data */
513 	struct nfs_args	*args = NULL;
514 	int flags, addr_type;
515 	zone_t *zone = nfs_zone();
516 	zone_t *mntzone = NULL;
517 	nfs_fhandle	*fhandle = NULL;
518 
519 	if ((error = secpolicy_fs_mount(cr, mvp, vfsp)) != 0)
520 		return (error);
521 
522 	if (mvp->v_type != VDIR)
523 		return (ENOTDIR);
524 
525 	/*
526 	 * get arguments
527 	 *
528 	 * nfs_args is now versioned and is extensible, so
529 	 * uap->datalen might be different from sizeof (args)
530 	 * in a compatible situation.
531 	 */
532 more:
533 
534 	if (!(uap->flags & MS_SYSSPACE)) {
535 		if (args == NULL)
536 			args = kmem_alloc(sizeof (struct nfs_args), KM_SLEEP);
537 		else {
538 			nfs_free_args(args, fhandle);
539 			fhandle = NULL;
540 		}
541 		if (fhandle == NULL)
542 			fhandle = kmem_zalloc(sizeof (nfs_fhandle), KM_SLEEP);
543 		error = nfs_copyin(data, uap->datalen, args, fhandle);
544 		if (error)  {
545 			if (args)
546 				kmem_free(args, sizeof (*args));
547 			return (error);
548 		}
549 	} else {
550 		args = (struct nfs_args *)data;
551 		fhandle = (nfs_fhandle *)args->fh;
552 	}
553 
554 
555 	flags = args->flags;
556 
557 	if (uap->flags & MS_REMOUNT) {
558 		size_t n;
559 		char name[FSTYPSZ];
560 
561 		if (uap->flags & MS_SYSSPACE)
562 			error = copystr(uap->fstype, name, FSTYPSZ, &n);
563 		else
564 			error = copyinstr(uap->fstype, name, FSTYPSZ, &n);
565 
566 		if (error) {
567 			if (error == ENAMETOOLONG)
568 				return (EINVAL);
569 			return (error);
570 		}
571 
572 
573 		/*
574 		 * This check is to ensure that the request is a
575 		 * genuine nfs remount request.
576 		 */
577 
578 		if (strncmp(name, "nfs", 3) != 0)
579 			return (EINVAL);
580 
581 		/*
582 		 * If the request changes the locking type, disallow the
583 		 * remount,
584 		 * because it's questionable whether we can transfer the
585 		 * locking state correctly.
586 		 *
587 		 * Remounts need to save the pathconf information.
588 		 * Part of the infamous static kludge.
589 		 */
590 
591 		if ((mi = VFTOMI(vfsp)) != NULL) {
592 			uint_t new_mi_llock;
593 			uint_t old_mi_llock;
594 
595 			new_mi_llock = (flags & NFSMNT_LLOCK) ? 1 : 0;
596 			old_mi_llock = (mi->mi_flags & MI_LLOCK) ? 1 : 0;
597 			if (old_mi_llock != new_mi_llock)
598 				return (EBUSY);
599 		}
600 		error = pathconf_get((struct mntinfo *)vfsp->vfs_data, args);
601 
602 		if (!(uap->flags & MS_SYSSPACE)) {
603 			nfs_free_args(args, fhandle);
604 			kmem_free(args, sizeof (*args));
605 		}
606 
607 		return (error);
608 	}
609 
610 	mutex_enter(&mvp->v_lock);
611 	if (!(uap->flags & MS_OVERLAY) &&
612 	    (mvp->v_count != 1 || (mvp->v_flag & VROOT))) {
613 		mutex_exit(&mvp->v_lock);
614 		if (!(uap->flags & MS_SYSSPACE)) {
615 			nfs_free_args(args, fhandle);
616 			kmem_free(args, sizeof (*args));
617 		}
618 		return (EBUSY);
619 	}
620 	mutex_exit(&mvp->v_lock);
621 
622 	/* make sure things are zeroed for errout: */
623 	rtvp = NULL;
624 	mi = NULL;
625 	secdata = NULL;
626 
627 	/*
628 	 * A valid knetconfig structure is required.
629 	 */
630 	if (!(flags & NFSMNT_KNCONF)) {
631 		if (!(uap->flags & MS_SYSSPACE)) {
632 			nfs_free_args(args, fhandle);
633 			kmem_free(args, sizeof (*args));
634 		}
635 		return (EINVAL);
636 	}
637 
638 	if ((strlen(args->knconf->knc_protofmly) >= KNC_STRSIZE) ||
639 	    (strlen(args->knconf->knc_proto) >= KNC_STRSIZE)) {
640 		if (!(uap->flags & MS_SYSSPACE)) {
641 			nfs_free_args(args, fhandle);
642 			kmem_free(args, sizeof (*args));
643 		}
644 		return (EINVAL);
645 	}
646 
647 
648 	/*
649 	 * Allocate a servinfo struct.
650 	 */
651 	svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
652 	mutex_init(&svp->sv_lock, NULL, MUTEX_DEFAULT, NULL);
653 	if (svp_tail) {
654 		svp_2ndlast = svp_tail;
655 		svp_tail->sv_next = svp;
656 	} else {
657 		svp_head = svp;
658 		svp_2ndlast = svp;
659 	}
660 
661 	svp_tail = svp;
662 
663 	/*
664 	 * Get knetconfig and server address
665 	 */
666 	svp->sv_knconf = args->knconf;
667 	args->knconf = NULL;
668 
669 	if (args->addr == NULL || args->addr->buf == NULL) {
670 		error = EINVAL;
671 		goto errout;
672 	}
673 
674 	svp->sv_addr.maxlen = args->addr->maxlen;
675 	svp->sv_addr.len = args->addr->len;
676 	svp->sv_addr.buf = args->addr->buf;
677 	args->addr->buf = NULL;
678 
679 	/*
680 	 * Get the root fhandle
681 	 */
682 	ASSERT(fhandle);
683 
684 	bcopy(&fhandle->fh_buf, &svp->sv_fhandle.fh_buf, fhandle->fh_len);
685 	svp->sv_fhandle.fh_len = fhandle->fh_len;
686 
687 	/*
688 	 * Get server's hostname
689 	 */
690 	if (flags & NFSMNT_HOSTNAME) {
691 		if (args->hostname == NULL) {
692 			error = EINVAL;
693 			goto errout;
694 		}
695 		svp->sv_hostnamelen = strlen(args->hostname) + 1;
696 		svp->sv_hostname = args->hostname;
697 		args->hostname = NULL;
698 	} else {
699 		char *p = "unknown-host";
700 		svp->sv_hostnamelen = strlen(p) + 1;
701 		svp->sv_hostname = kmem_zalloc(svp->sv_hostnamelen, KM_SLEEP);
702 		(void) strcpy(svp->sv_hostname, p);
703 	}
704 
705 
706 	/*
707 	 * RDMA MOUNT SUPPORT FOR NFS v2:
708 	 * Establish, is it possible to use RDMA, if so overload the
709 	 * knconf with rdma specific knconf and free the orignal.
710 	 */
711 	if ((flags & NFSMNT_TRYRDMA) || (flags & NFSMNT_DORDMA)) {
712 		/*
713 		 * Determine the addr type for RDMA, IPv4 or v6.
714 		 */
715 		if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET) == 0)
716 			addr_type = AF_INET;
717 		else if (strcmp(svp->sv_knconf->knc_protofmly, NC_INET6) == 0)
718 			addr_type = AF_INET6;
719 
720 		if (rdma_reachable(addr_type, &svp->sv_addr,
721 		    &rdma_knconf) == 0) {
722 			/*
723 			 * If successful, hijack, the orignal knconf and
724 			 * replace with a new one, depending on the flags.
725 			 */
726 			svp->sv_origknconf = svp->sv_knconf;
727 			svp->sv_knconf = rdma_knconf;
728 			knconf = rdma_knconf;
729 		} else {
730 			if (flags & NFSMNT_TRYRDMA) {
731 #ifdef	DEBUG
732 				if (rdma_debug)
733 					zcmn_err(getzoneid(), CE_WARN,
734 					    "no RDMA onboard, revert\n");
735 #endif
736 			}
737 
738 			if (flags & NFSMNT_DORDMA) {
739 				/*
740 				 * If proto=rdma is specified and no RDMA
741 				 * path to this server is avialable then
742 				 * ditch this server.
743 				 * This is not included in the mountable
744 				 * server list or the replica list.
745 				 * Check if more servers are specified;
746 				 * Failover case, otherwise bail out of mount.
747 				 */
748 				if (args->nfs_args_ext == NFS_ARGS_EXTB &&
749 				    args->nfs_ext_u.nfs_extB.next != NULL) {
750 					data = (char *)
751 					    args->nfs_ext_u.nfs_extB.next;
752 					if (uap->flags & MS_RDONLY &&
753 					    !(flags & NFSMNT_SOFT)) {
754 						if (svp_head->sv_next == NULL) {
755 							svp_tail = NULL;
756 							svp_2ndlast = NULL;
757 							sv_free(svp_head);
758 							goto more;
759 						} else {
760 							svp_tail = svp_2ndlast;
761 							svp_2ndlast->sv_next =
762 							    NULL;
763 							sv_free(svp);
764 							goto more;
765 						}
766 					}
767 				} else {
768 					/*
769 					 * This is the last server specified
770 					 * in the nfs_args list passed down
771 					 * and its not rdma capable.
772 					 */
773 					if (svp_head->sv_next == NULL) {
774 						/*
775 						 * Is this the only one
776 						 */
777 						error = EINVAL;
778 #ifdef	DEBUG
779 						if (rdma_debug)
780 							zcmn_err(getzoneid(),
781 							    CE_WARN,
782 							    "No RDMA srv");
783 #endif
784 						goto errout;
785 					} else {
786 						/*
787 						 * There is list, since some
788 						 * servers specified before
789 						 * this passed all requirements
790 						 */
791 						svp_tail = svp_2ndlast;
792 						svp_2ndlast->sv_next = NULL;
793 						sv_free(svp);
794 						goto proceed;
795 					}
796 				}
797 			}
798 		}
799 	}
800 
801 	/*
802 	 * Get the extention data which has the new security data structure.
803 	 */
804 	if (flags & NFSMNT_NEWARGS) {
805 		switch (args->nfs_args_ext) {
806 		case NFS_ARGS_EXTA:
807 		case NFS_ARGS_EXTB:
808 			/*
809 			 * Indicating the application is using the new
810 			 * sec_data structure to pass in the security
811 			 * data.
812 			 */
813 			secdata = args->nfs_ext_u.nfs_extA.secdata;
814 			if (secdata == NULL) {
815 				error = EINVAL;
816 			} else {
817 				/*
818 				 * Need to validate the flavor here if
819 				 * sysspace, userspace was already
820 				 * validate from the nfs_copyin function.
821 				 */
822 				switch (secdata->rpcflavor) {
823 					case AUTH_NONE:
824 					case AUTH_UNIX:
825 					case AUTH_LOOPBACK:
826 					case AUTH_DES:
827 					case RPCSEC_GSS:
828 						break;
829 					default:
830 						error = EINVAL;
831 						goto errout;
832 				}
833 			}
834 			args->nfs_ext_u.nfs_extA.secdata = NULL;
835 			break;
836 
837 		default:
838 			error = EINVAL;
839 			break;
840 		}
841 	} else if (flags & NFSMNT_SECURE) {
842 		/*
843 		 * Keep this for backward compatibility to support
844 		 * NFSMNT_SECURE/NFSMNT_RPCTIMESYNC flags.
845 		 */
846 		if (args->syncaddr == NULL || args->syncaddr->buf == NULL) {
847 			error = EINVAL;
848 			goto errout;
849 		}
850 
851 		/*
852 		 * get time sync address.
853 		 */
854 		if (args->syncaddr == NULL) {
855 			error = EFAULT;
856 			goto errout;
857 		}
858 
859 		/*
860 		 * Move security related data to the sec_data structure.
861 		 */
862 		{
863 			dh_k4_clntdata_t *data;
864 			char *pf, *p;
865 
866 			secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP);
867 			if (flags & NFSMNT_RPCTIMESYNC)
868 				secdata->flags |= AUTH_F_RPCTIMESYNC;
869 			data = kmem_alloc(sizeof (*data), KM_SLEEP);
870 			bcopy(args->syncaddr, &data->syncaddr,
871 			    sizeof (*args->syncaddr));
872 
873 
874 			/*
875 			 * duplicate the knconf information for the
876 			 * new opaque data.
877 			 */
878 			data->knconf = kmem_alloc(sizeof (*knconf), KM_SLEEP);
879 			*data->knconf = *knconf;
880 			pf = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
881 			p = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
882 			bcopy(knconf->knc_protofmly, pf, KNC_STRSIZE);
883 			bcopy(knconf->knc_proto, pf, KNC_STRSIZE);
884 			data->knconf->knc_protofmly = pf;
885 			data->knconf->knc_proto = p;
886 
887 			/* move server netname to the sec_data structure */
888 			nlen = strlen(args->hostname) + 1;
889 			if (nlen != 0) {
890 				data->netname = kmem_alloc(nlen, KM_SLEEP);
891 				bcopy(args->hostname, data->netname, nlen);
892 				data->netnamelen = (int)nlen;
893 			}
894 			secdata->secmod = secdata->rpcflavor = AUTH_DES;
895 			secdata->data = (caddr_t)data;
896 		}
897 	} else {
898 		secdata = kmem_alloc(sizeof (*secdata), KM_SLEEP);
899 		secdata->secmod = secdata->rpcflavor = AUTH_UNIX;
900 		secdata->data = NULL;
901 	}
902 	svp->sv_secdata = secdata;
903 
904 	/*
905 	 * See bug 1180236.
906 	 * If mount secure failed, we will fall back to AUTH_NONE
907 	 * and try again.  nfs3rootvp() will turn this back off.
908 	 *
909 	 * The NFS Version 2 mount uses GETATTR and STATFS procedures.
910 	 * The server does not care if these procedures have the proper
911 	 * authentication flavor, so if mount retries using AUTH_NONE
912 	 * that does not require a credential setup for root then the
913 	 * automounter would work without requiring root to be
914 	 * keylogged into AUTH_DES.
915 	 */
916 	if (secdata->rpcflavor != AUTH_UNIX &&
917 	    secdata->rpcflavor != AUTH_LOOPBACK)
918 		secdata->flags |= AUTH_F_TRYNONE;
919 
920 	/*
921 	 * Failover support:
922 	 *
923 	 * We may have a linked list of nfs_args structures,
924 	 * which means the user is looking for failover.  If
925 	 * the mount is either not "read-only" or "soft",
926 	 * we want to bail out with EINVAL.
927 	 */
928 	if (args->nfs_args_ext == NFS_ARGS_EXTB &&
929 	    args->nfs_ext_u.nfs_extB.next != NULL) {
930 		if (uap->flags & MS_RDONLY && !(flags & NFSMNT_SOFT)) {
931 			data = (char *)args->nfs_ext_u.nfs_extB.next;
932 			goto more;
933 		}
934 		error = EINVAL;
935 		goto errout;
936 	}
937 
938 	/*
939 	 * Determine the zone we're being mounted into.
940 	 */
941 	zone_hold(mntzone = zone);		/* start with this assumption */
942 	if (getzoneid() == GLOBAL_ZONEID) {
943 		zone_rele(mntzone);
944 		mntzone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
945 		ASSERT(mntzone != NULL);
946 		if (mntzone != zone) {
947 			error = EBUSY;
948 			goto errout;
949 		}
950 	}
951 
952 	if (is_system_labeled()) {
953 		error = nfs_mount_label_policy(vfsp, &svp->sv_addr,
954 		    svp->sv_knconf, cr);
955 
956 		if (error > 0)
957 			goto errout;
958 
959 		if (error == -1) {
960 			/* change mount to read-only to prevent write-down */
961 			vfs_setmntopt(vfsp, MNTOPT_RO, NULL, 0);
962 		}
963 	}
964 
965 	/*
966 	 * Stop the mount from going any further if the zone is going away.
967 	 */
968 	if (zone_status_get(mntzone) >= ZONE_IS_SHUTTING_DOWN) {
969 		error = EBUSY;
970 		goto errout;
971 	}
972 
973 	/*
974 	 * Get root vnode.
975 	 */
976 proceed:
977 	error = nfsrootvp(&rtvp, vfsp, svp_head, flags, cr, mntzone);
978 
979 	if (error)
980 		goto errout;
981 
982 	/*
983 	 * Set option fields in the mount info record
984 	 */
985 	mi = VTOMI(rtvp);
986 
987 	if (svp_head->sv_next)
988 		mi->mi_flags |= MI_LLOCK;
989 
990 	error = nfs_setopts(rtvp, DATAMODEL_NATIVE, args);
991 	if (!error) {
992 		/* static pathconf kludge */
993 		error = pathconf_get(mi, args);
994 	}
995 
996 errout:
997 	if (rtvp != NULL) {
998 		if (error) {
999 			rp = VTOR(rtvp);
1000 			if (rp->r_flags & RHASHED)
1001 				rp_rmhash(rp);
1002 		}
1003 		VN_RELE(rtvp);
1004 	}
1005 
1006 	if (error) {
1007 		sv_free(svp_head);
1008 		if (mi != NULL) {
1009 			nfs_async_stop(vfsp);
1010 			nfs_async_manager_stop(vfsp);
1011 			if (mi->mi_io_kstats) {
1012 				kstat_delete(mi->mi_io_kstats);
1013 				mi->mi_io_kstats = NULL;
1014 			}
1015 			if (mi->mi_ro_kstats) {
1016 				kstat_delete(mi->mi_ro_kstats);
1017 				mi->mi_ro_kstats = NULL;
1018 			}
1019 			nfs_free_mi(mi);
1020 		}
1021 	}
1022 
1023 	if (!(uap->flags & MS_SYSSPACE)) {
1024 		nfs_free_args(args, fhandle);
1025 		kmem_free(args, sizeof (*args));
1026 	}
1027 
1028 	if (mntzone != NULL)
1029 		zone_rele(mntzone);
1030 
1031 	return (error);
1032 }
1033 
1034 /*
1035  * The pathconf information is kept on a linked list of kmem_alloc'ed
1036  * structs. We search the list & add a new struct iff there is no other
1037  * struct with the same information.
1038  * See sys/pathconf.h for ``the rest of the story.''
1039  */
1040 static struct pathcnf *allpc = NULL;
1041 
1042 static int
1043 pathconf_copyin(struct nfs_args *args, struct pathcnf *pc)
1044 {
1045 	STRUCT_DECL(pathcnf, pc_tmp);
1046 	STRUCT_HANDLE(nfs_args, ap);
1047 	int i;
1048 	model_t	model;
1049 
1050 	model = get_udatamodel();
1051 	STRUCT_INIT(pc_tmp, model);
1052 	STRUCT_SET_HANDLE(ap, model, args);
1053 
1054 	if ((STRUCT_FGET(ap, flags) & NFSMNT_POSIX) &&
1055 	    STRUCT_FGETP(ap, pathconf) != NULL) {
1056 		if (copyin(STRUCT_FGETP(ap, pathconf), STRUCT_BUF(pc_tmp),
1057 		    STRUCT_SIZE(pc_tmp)))
1058 			return (EFAULT);
1059 		if (_PC_ISSET(_PC_ERROR, STRUCT_FGET(pc_tmp, pc_mask)))
1060 			return (EINVAL);
1061 
1062 		pc->pc_link_max = STRUCT_FGET(pc_tmp, pc_link_max);
1063 		pc->pc_max_canon = STRUCT_FGET(pc_tmp, pc_max_canon);
1064 		pc->pc_max_input = STRUCT_FGET(pc_tmp, pc_max_input);
1065 		pc->pc_name_max = STRUCT_FGET(pc_tmp, pc_name_max);
1066 		pc->pc_path_max = STRUCT_FGET(pc_tmp, pc_path_max);
1067 		pc->pc_pipe_buf = STRUCT_FGET(pc_tmp, pc_pipe_buf);
1068 		pc->pc_vdisable = STRUCT_FGET(pc_tmp, pc_vdisable);
1069 		pc->pc_xxx = STRUCT_FGET(pc_tmp, pc_xxx);
1070 		for (i = 0; i < _PC_N; i++)
1071 			pc->pc_mask[i] = STRUCT_FGET(pc_tmp, pc_mask[i]);
1072 	}
1073 	return (0);
1074 }
1075 
1076 static int
1077 pathconf_get(struct mntinfo *mi, struct nfs_args *args)
1078 {
1079 	struct pathcnf *p, *pc;
1080 
1081 	pc = args->pathconf;
1082 	if (mi->mi_pathconf != NULL) {
1083 		pathconf_rele(mi);
1084 		mi->mi_pathconf = NULL;
1085 	}
1086 
1087 	if (args->flags & NFSMNT_POSIX && args->pathconf != NULL) {
1088 		if (_PC_ISSET(_PC_ERROR, pc->pc_mask))
1089 			return (EINVAL);
1090 
1091 		for (p = allpc; p != NULL; p = p->pc_next) {
1092 			if (PCCMP(p, pc) == 0)
1093 				break;
1094 		}
1095 		if (p != NULL) {
1096 			mi->mi_pathconf = p;
1097 			p->pc_refcnt++;
1098 		} else {
1099 			p = kmem_alloc(sizeof (*p), KM_SLEEP);
1100 			bcopy(pc, p, sizeof (struct pathcnf));
1101 			p->pc_next = allpc;
1102 			p->pc_refcnt = 1;
1103 			allpc = mi->mi_pathconf = p;
1104 		}
1105 	}
1106 	return (0);
1107 }
1108 
1109 /*
1110  * release the static pathconf information
1111  */
1112 static void
1113 pathconf_rele(struct mntinfo *mi)
1114 {
1115 	if (mi->mi_pathconf != NULL) {
1116 		if (--mi->mi_pathconf->pc_refcnt == 0) {
1117 			struct pathcnf *p;
1118 			struct pathcnf *p2;
1119 
1120 			p2 = p = allpc;
1121 			while (p != NULL && p != mi->mi_pathconf) {
1122 				p2 = p;
1123 				p = p->pc_next;
1124 			}
1125 			if (p == NULL) {
1126 				panic("mi->pathconf");
1127 				/*NOTREACHED*/
1128 			}
1129 			if (p == allpc)
1130 				allpc = p->pc_next;
1131 			else
1132 				p2->pc_next = p->pc_next;
1133 			kmem_free(p, sizeof (*p));
1134 			mi->mi_pathconf = NULL;
1135 		}
1136 	}
1137 }
1138 
1139 static int nfs_dynamic = 1;	/* global variable to enable dynamic retrans. */
1140 static ushort_t nfs_max_threads = 8;	/* max number of active async threads */
1141 static uint_t nfs_async_clusters = 1;	/* # of reqs from each async queue */
1142 static uint_t nfs_cots_timeo = NFS_COTS_TIMEO;
1143 
1144 static int
1145 nfsrootvp(vnode_t **rtvpp, vfs_t *vfsp, struct servinfo *svp,
1146 	int flags, cred_t *cr, zone_t *zone)
1147 {
1148 	vnode_t *rtvp;
1149 	mntinfo_t *mi;
1150 	dev_t nfs_dev;
1151 	struct vattr va;
1152 	int error;
1153 	rnode_t *rp;
1154 	int i;
1155 	struct nfs_stats *nfsstatsp;
1156 	cred_t *lcr = NULL, *tcr = cr;
1157 
1158 	nfsstatsp = zone_getspecific(nfsstat_zone_key, nfs_zone());
1159 	ASSERT(nfsstatsp != NULL);
1160 
1161 	/*
1162 	 * Create a mount record and link it to the vfs struct.
1163 	 */
1164 	mi = kmem_zalloc(sizeof (*mi), KM_SLEEP);
1165 	mutex_init(&mi->mi_lock, NULL, MUTEX_DEFAULT, NULL);
1166 	mutex_init(&mi->mi_remap_lock, NULL, MUTEX_DEFAULT, NULL);
1167 	mi->mi_flags = MI_ACL | MI_EXTATTR;
1168 	if (!(flags & NFSMNT_SOFT))
1169 		mi->mi_flags |= MI_HARD;
1170 	if ((flags & NFSMNT_SEMISOFT))
1171 		mi->mi_flags |= MI_SEMISOFT;
1172 	if ((flags & NFSMNT_NOPRINT))
1173 		mi->mi_flags |= MI_NOPRINT;
1174 	if (flags & NFSMNT_INT)
1175 		mi->mi_flags |= MI_INT;
1176 	mi->mi_retrans = NFS_RETRIES;
1177 	if (svp->sv_knconf->knc_semantics == NC_TPI_COTS_ORD ||
1178 	    svp->sv_knconf->knc_semantics == NC_TPI_COTS)
1179 		mi->mi_timeo = nfs_cots_timeo;
1180 	else
1181 		mi->mi_timeo = NFS_TIMEO;
1182 	mi->mi_prog = NFS_PROGRAM;
1183 	mi->mi_vers = NFS_VERSION;
1184 	mi->mi_rfsnames = rfsnames_v2;
1185 	mi->mi_reqs = nfsstatsp->nfs_stats_v2.rfsreqcnt_ptr;
1186 	mi->mi_call_type = call_type_v2;
1187 	mi->mi_ss_call_type = ss_call_type_v2;
1188 	mi->mi_timer_type = timer_type_v2;
1189 	mi->mi_aclnames = aclnames_v2;
1190 	mi->mi_aclreqs = nfsstatsp->nfs_stats_v2.aclreqcnt_ptr;
1191 	mi->mi_acl_call_type = acl_call_type_v2;
1192 	mi->mi_acl_ss_call_type = acl_ss_call_type_v2;
1193 	mi->mi_acl_timer_type = acl_timer_type_v2;
1194 	cv_init(&mi->mi_failover_cv, NULL, CV_DEFAULT, NULL);
1195 	mi->mi_servers = svp;
1196 	mi->mi_curr_serv = svp;
1197 	mi->mi_acregmin = SEC2HR(ACREGMIN);
1198 	mi->mi_acregmax = SEC2HR(ACREGMAX);
1199 	mi->mi_acdirmin = SEC2HR(ACDIRMIN);
1200 	mi->mi_acdirmax = SEC2HR(ACDIRMAX);
1201 
1202 	if (nfs_dynamic)
1203 		mi->mi_flags |= MI_DYNAMIC;
1204 
1205 	if (flags & NFSMNT_DIRECTIO)
1206 		mi->mi_flags |= MI_DIRECTIO;
1207 
1208 	/*
1209 	 * Make a vfs struct for nfs.  We do this here instead of below
1210 	 * because rtvp needs a vfs before we can do a getattr on it.
1211 	 *
1212 	 * Assign a unique device id to the mount
1213 	 */
1214 	mutex_enter(&nfs_minor_lock);
1215 	do {
1216 		nfs_minor = (nfs_minor + 1) & MAXMIN32;
1217 		nfs_dev = makedevice(nfs_major, nfs_minor);
1218 	} while (vfs_devismounted(nfs_dev));
1219 	mutex_exit(&nfs_minor_lock);
1220 
1221 	vfsp->vfs_dev = nfs_dev;
1222 	vfs_make_fsid(&vfsp->vfs_fsid, nfs_dev, nfsfstyp);
1223 	vfsp->vfs_data = (caddr_t)mi;
1224 	vfsp->vfs_fstype = nfsfstyp;
1225 	vfsp->vfs_bsize = NFS_MAXDATA;
1226 
1227 	/*
1228 	 * Initialize fields used to support async putpage operations.
1229 	 */
1230 	for (i = 0; i < NFS_ASYNC_TYPES; i++)
1231 		mi->mi_async_clusters[i] = nfs_async_clusters;
1232 	mi->mi_async_init_clusters = nfs_async_clusters;
1233 	mi->mi_async_curr = &mi->mi_async_reqs[0];
1234 	mi->mi_max_threads = nfs_max_threads;
1235 	mutex_init(&mi->mi_async_lock, NULL, MUTEX_DEFAULT, NULL);
1236 	cv_init(&mi->mi_async_reqs_cv, NULL, CV_DEFAULT, NULL);
1237 	cv_init(&mi->mi_async_work_cv, NULL, CV_DEFAULT, NULL);
1238 	cv_init(&mi->mi_async_cv, NULL, CV_DEFAULT, NULL);
1239 
1240 	mi->mi_vfsp = vfsp;
1241 	zone_hold(mi->mi_zone = zone);
1242 	nfs_mi_zonelist_add(mi);
1243 
1244 	/*
1245 	 * Make the root vnode, use it to get attributes,
1246 	 * then remake it with the attributes.
1247 	 */
1248 	rtvp = makenfsnode((fhandle_t *)svp->sv_fhandle.fh_buf,
1249 	    NULL, vfsp, gethrtime(), cr, NULL, NULL);
1250 
1251 	va.va_mask = AT_ALL;
1252 
1253 	/*
1254 	 * If the uid is set then set the creds for secure mounts
1255 	 * by proxy processes such as automountd.
1256 	 */
1257 	if (svp->sv_secdata->uid != 0 &&
1258 	    svp->sv_secdata->rpcflavor == RPCSEC_GSS) {
1259 		lcr = crdup(cr);
1260 		(void) crsetugid(lcr, svp->sv_secdata->uid, crgetgid(cr));
1261 		tcr = lcr;
1262 	}
1263 
1264 	error = nfsgetattr(rtvp, &va, tcr);
1265 	if (error)
1266 		goto bad;
1267 	rtvp->v_type = va.va_type;
1268 
1269 	/*
1270 	 * Poll every server to get the filesystem stats; we're
1271 	 * only interested in the server's transfer size, and we
1272 	 * want the minimum.
1273 	 *
1274 	 * While we're looping, we'll turn off AUTH_F_TRYNONE,
1275 	 * which is only for the mount operation.
1276 	 */
1277 
1278 	mi->mi_tsize = MIN(NFS_MAXDATA, nfstsize());
1279 	mi->mi_stsize = MIN(NFS_MAXDATA, nfstsize());
1280 
1281 	for (svp = mi->mi_servers; svp != NULL; svp = svp->sv_next) {
1282 		struct nfsstatfs fs;
1283 		int douprintf;
1284 
1285 		douprintf = 1;
1286 		mi->mi_curr_serv = svp;
1287 
1288 		error = rfs2call(mi, RFS_STATFS, xdr_fhandle,
1289 		    (caddr_t)svp->sv_fhandle.fh_buf, xdr_statfs, (caddr_t)&fs,
1290 		    tcr, &douprintf, &fs.fs_status, 0, NULL);
1291 		if (error)
1292 			goto bad;
1293 		mi->mi_stsize = MIN(mi->mi_stsize, fs.fs_tsize);
1294 		svp->sv_secdata->flags &= ~AUTH_F_TRYNONE;
1295 	}
1296 	mi->mi_curr_serv = mi->mi_servers;
1297 	mi->mi_curread = mi->mi_tsize;
1298 	mi->mi_curwrite = mi->mi_stsize;
1299 
1300 	/*
1301 	 * Start the manager thread responsible for handling async worker
1302 	 * threads.
1303 	 */
1304 	VFS_HOLD(vfsp);	/* add reference for thread */
1305 	mi->mi_manager_thread = zthread_create(NULL, 0, nfs_async_manager,
1306 	    vfsp, 0, minclsyspri);
1307 	ASSERT(mi->mi_manager_thread != NULL);
1308 
1309 	/*
1310 	 * Initialize kstats
1311 	 */
1312 	nfs_mnt_kstat_init(vfsp);
1313 
1314 	mi->mi_type = rtvp->v_type;
1315 
1316 	*rtvpp = rtvp;
1317 	if (lcr != NULL)
1318 		crfree(lcr);
1319 
1320 	return (0);
1321 bad:
1322 	/*
1323 	 * An error occurred somewhere, need to clean up...
1324 	 * We need to release our reference to the root vnode and
1325 	 * destroy the mntinfo struct that we just created.
1326 	 */
1327 	if (lcr != NULL)
1328 		crfree(lcr);
1329 	rp = VTOR(rtvp);
1330 	if (rp->r_flags & RHASHED)
1331 		rp_rmhash(rp);
1332 	VN_RELE(rtvp);
1333 	nfs_async_stop(vfsp);
1334 	nfs_async_manager_stop(vfsp);
1335 	if (mi->mi_io_kstats) {
1336 		kstat_delete(mi->mi_io_kstats);
1337 		mi->mi_io_kstats = NULL;
1338 	}
1339 	if (mi->mi_ro_kstats) {
1340 		kstat_delete(mi->mi_ro_kstats);
1341 		mi->mi_ro_kstats = NULL;
1342 	}
1343 	nfs_free_mi(mi);
1344 	*rtvpp = NULL;
1345 	return (error);
1346 }
1347 
1348 /*
1349  * vfs operations
1350  */
1351 static int
1352 nfs_unmount(vfs_t *vfsp, int flag, cred_t *cr)
1353 {
1354 	mntinfo_t *mi;
1355 	ushort_t omax;
1356 
1357 	if (secpolicy_fs_unmount(cr, vfsp) != 0)
1358 		return (EPERM);
1359 
1360 	mi = VFTOMI(vfsp);
1361 	if (flag & MS_FORCE) {
1362 
1363 		vfsp->vfs_flag |= VFS_UNMOUNTED;
1364 
1365 		/*
1366 		 * We are about to stop the async manager.
1367 		 * Let every one know not to schedule any
1368 		 * more async requests.
1369 		 */
1370 		mutex_enter(&mi->mi_async_lock);
1371 		mi->mi_max_threads = 0;
1372 		cv_broadcast(&mi->mi_async_work_cv);
1373 		mutex_exit(&mi->mi_async_lock);
1374 
1375 		/*
1376 		 * We need to stop the manager thread explicitly; the worker
1377 		 * threads can time out and exit on their own.
1378 		 */
1379 		nfs_async_manager_stop(vfsp);
1380 		destroy_rtable(vfsp, cr);
1381 		if (mi->mi_io_kstats) {
1382 			kstat_delete(mi->mi_io_kstats);
1383 			mi->mi_io_kstats = NULL;
1384 		}
1385 		if (mi->mi_ro_kstats) {
1386 			kstat_delete(mi->mi_ro_kstats);
1387 			mi->mi_ro_kstats = NULL;
1388 		}
1389 		return (0);
1390 	}
1391 	/*
1392 	 * Wait until all asynchronous putpage operations on
1393 	 * this file system are complete before flushing rnodes
1394 	 * from the cache.
1395 	 */
1396 	omax = mi->mi_max_threads;
1397 	if (nfs_async_stop_sig(vfsp)) {
1398 		return (EINTR);
1399 	}
1400 	rflush(vfsp, cr);
1401 	/*
1402 	 * If there are any active vnodes on this file system,
1403 	 * then the file system is busy and can't be umounted.
1404 	 */
1405 	if (check_rtable(vfsp)) {
1406 		mutex_enter(&mi->mi_async_lock);
1407 		mi->mi_max_threads = omax;
1408 		mutex_exit(&mi->mi_async_lock);
1409 		return (EBUSY);
1410 	}
1411 	/*
1412 	 * The unmount can't fail from now on; stop the manager thread.
1413 	 */
1414 	nfs_async_manager_stop(vfsp);
1415 	/*
1416 	 * Destroy all rnodes belonging to this file system from the
1417 	 * rnode hash queues and purge any resources allocated to
1418 	 * them.
1419 	 */
1420 	destroy_rtable(vfsp, cr);
1421 	if (mi->mi_io_kstats) {
1422 		kstat_delete(mi->mi_io_kstats);
1423 		mi->mi_io_kstats = NULL;
1424 	}
1425 	if (mi->mi_ro_kstats) {
1426 		kstat_delete(mi->mi_ro_kstats);
1427 		mi->mi_ro_kstats = NULL;
1428 	}
1429 	return (0);
1430 }
1431 
1432 /*
1433  * find root of nfs
1434  */
1435 static int
1436 nfs_root(vfs_t *vfsp, vnode_t **vpp)
1437 {
1438 	mntinfo_t *mi;
1439 	vnode_t *vp;
1440 	servinfo_t *svp;
1441 	rnode_t *rp;
1442 	int error = 0;
1443 
1444 	mi = VFTOMI(vfsp);
1445 
1446 	if (nfs_zone() != mi->mi_zone)
1447 		return (EPERM);
1448 
1449 	svp = mi->mi_curr_serv;
1450 	if (svp && (svp->sv_flags & SV_ROOT_STALE)) {
1451 		mutex_enter(&svp->sv_lock);
1452 		svp->sv_flags &= ~SV_ROOT_STALE;
1453 		mutex_exit(&svp->sv_lock);
1454 		error = ENOENT;
1455 	}
1456 
1457 	vp = makenfsnode((fhandle_t *)mi->mi_curr_serv->sv_fhandle.fh_buf,
1458 	    NULL, vfsp, gethrtime(), CRED(), NULL, NULL);
1459 
1460 	/*
1461 	 * if the SV_ROOT_STALE flag was reset above, reset the
1462 	 * RSTALE flag if needed and return an error
1463 	 */
1464 	if (error == ENOENT) {
1465 		rp = VTOR(vp);
1466 		if (svp && rp->r_flags & RSTALE) {
1467 			mutex_enter(&rp->r_statelock);
1468 			rp->r_flags &= ~RSTALE;
1469 			mutex_exit(&rp->r_statelock);
1470 		}
1471 		VN_RELE(vp);
1472 		return (error);
1473 	}
1474 
1475 	ASSERT(vp->v_type == VNON || vp->v_type == mi->mi_type);
1476 
1477 	vp->v_type = mi->mi_type;
1478 
1479 	*vpp = vp;
1480 
1481 	return (0);
1482 }
1483 
1484 /*
1485  * Get file system statistics.
1486  */
1487 static int
1488 nfs_statvfs(vfs_t *vfsp, struct statvfs64 *sbp)
1489 {
1490 	int error;
1491 	mntinfo_t *mi;
1492 	struct nfsstatfs fs;
1493 	int douprintf;
1494 	failinfo_t fi;
1495 	vnode_t *vp;
1496 
1497 	error = nfs_root(vfsp, &vp);
1498 	if (error)
1499 		return (error);
1500 
1501 	mi = VFTOMI(vfsp);
1502 	douprintf = 1;
1503 	fi.vp = vp;
1504 	fi.fhp = NULL;		/* no need to update, filehandle not copied */
1505 	fi.copyproc = nfscopyfh;
1506 	fi.lookupproc = nfslookup;
1507 	fi.xattrdirproc = acl_getxattrdir2;
1508 
1509 	error = rfs2call(mi, RFS_STATFS, xdr_fhandle, (caddr_t)VTOFH(vp),
1510 	    xdr_statfs, (caddr_t)&fs, CRED(), &douprintf, &fs.fs_status, 0,
1511 	    &fi);
1512 
1513 	if (!error) {
1514 		error = geterrno(fs.fs_status);
1515 		if (!error) {
1516 			mutex_enter(&mi->mi_lock);
1517 			if (mi->mi_stsize) {
1518 				mi->mi_stsize = MIN(mi->mi_stsize, fs.fs_tsize);
1519 			} else {
1520 				mi->mi_stsize = fs.fs_tsize;
1521 				mi->mi_curwrite = mi->mi_stsize;
1522 			}
1523 			mutex_exit(&mi->mi_lock);
1524 			sbp->f_bsize = fs.fs_bsize;
1525 			sbp->f_frsize = fs.fs_bsize;
1526 			sbp->f_blocks = (fsblkcnt64_t)fs.fs_blocks;
1527 			sbp->f_bfree = (fsblkcnt64_t)fs.fs_bfree;
1528 			/*
1529 			 * Some servers may return negative available
1530 			 * block counts.  They may do this because they
1531 			 * calculate the number of available blocks by
1532 			 * subtracting the number of used blocks from
1533 			 * the total number of blocks modified by the
1534 			 * minimum free value.  For example, if the
1535 			 * minumum free percentage is 10 and the file
1536 			 * system is greater than 90 percent full, then
1537 			 * 90 percent of the total blocks minus the
1538 			 * actual number of used blocks may be a
1539 			 * negative number.
1540 			 *
1541 			 * In this case, we need to sign extend the
1542 			 * negative number through the assignment from
1543 			 * the 32 bit bavail count to the 64 bit bavail
1544 			 * count.
1545 			 *
1546 			 * We need to be able to discern between there
1547 			 * just being a lot of available blocks on the
1548 			 * file system and the case described above.
1549 			 * We are making the assumption that it does
1550 			 * not make sense to have more available blocks
1551 			 * than there are free blocks.  So, if there
1552 			 * are, then we treat the number as if it were
1553 			 * a negative number and arrange to have it
1554 			 * sign extended when it is converted from 32
1555 			 * bits to 64 bits.
1556 			 */
1557 			if (fs.fs_bavail <= fs.fs_bfree)
1558 				sbp->f_bavail = (fsblkcnt64_t)fs.fs_bavail;
1559 			else {
1560 				sbp->f_bavail =
1561 				    (fsblkcnt64_t)((long)fs.fs_bavail);
1562 			}
1563 			sbp->f_files = (fsfilcnt64_t)-1;
1564 			sbp->f_ffree = (fsfilcnt64_t)-1;
1565 			sbp->f_favail = (fsfilcnt64_t)-1;
1566 			sbp->f_fsid = (unsigned long)vfsp->vfs_fsid.val[0];
1567 			(void) strncpy(sbp->f_basetype,
1568 			    vfssw[vfsp->vfs_fstype].vsw_name, FSTYPSZ);
1569 			sbp->f_flag = vf_to_stf(vfsp->vfs_flag);
1570 			sbp->f_namemax = (uint32_t)-1;
1571 		} else {
1572 			PURGE_STALE_FH(error, vp, CRED());
1573 		}
1574 	}
1575 
1576 	VN_RELE(vp);
1577 
1578 	return (error);
1579 }
1580 
1581 static kmutex_t nfs_syncbusy;
1582 
1583 /*
1584  * Flush dirty nfs files for file system vfsp.
1585  * If vfsp == NULL, all nfs files are flushed.
1586  */
1587 /* ARGSUSED */
1588 static int
1589 nfs_sync(vfs_t *vfsp, short flag, cred_t *cr)
1590 {
1591 	/*
1592 	 * Cross-zone calls are OK here, since this translates to a
1593 	 * VOP_PUTPAGE(B_ASYNC), which gets picked up by the right zone.
1594 	 */
1595 	if (!(flag & SYNC_ATTR) && mutex_tryenter(&nfs_syncbusy) != 0) {
1596 		rflush(vfsp, cr);
1597 		mutex_exit(&nfs_syncbusy);
1598 	}
1599 	return (0);
1600 }
1601 
1602 /* ARGSUSED */
1603 static int
1604 nfs_vget(vfs_t *vfsp, vnode_t **vpp, fid_t *fidp)
1605 {
1606 	int error;
1607 	vnode_t *vp;
1608 	struct vattr va;
1609 	struct nfs_fid *nfsfidp = (struct nfs_fid *)fidp;
1610 	zoneid_t zoneid = VFTOMI(vfsp)->mi_zone->zone_id;
1611 
1612 	if (nfs_zone() != VFTOMI(vfsp)->mi_zone)
1613 		return (EPERM);
1614 	if (fidp->fid_len != (sizeof (*nfsfidp) - sizeof (short))) {
1615 #ifdef DEBUG
1616 		zcmn_err(zoneid, CE_WARN,
1617 		    "nfs_vget: bad fid len, %d/%d", fidp->fid_len,
1618 		    (int)(sizeof (*nfsfidp) - sizeof (short)));
1619 #endif
1620 		*vpp = NULL;
1621 		return (ESTALE);
1622 	}
1623 
1624 	vp = makenfsnode((fhandle_t *)(nfsfidp->nf_data), NULL, vfsp,
1625 	    gethrtime(), CRED(), NULL, NULL);
1626 
1627 	if (VTOR(vp)->r_flags & RSTALE) {
1628 		VN_RELE(vp);
1629 		*vpp = NULL;
1630 		return (ENOENT);
1631 	}
1632 
1633 	if (vp->v_type == VNON) {
1634 		va.va_mask = AT_ALL;
1635 		error = nfsgetattr(vp, &va, CRED());
1636 		if (error) {
1637 			VN_RELE(vp);
1638 			*vpp = NULL;
1639 			return (error);
1640 		}
1641 		vp->v_type = va.va_type;
1642 	}
1643 
1644 	*vpp = vp;
1645 
1646 	return (0);
1647 }
1648 
1649 /* ARGSUSED */
1650 static int
1651 nfs_mountroot(vfs_t *vfsp, whymountroot_t why)
1652 {
1653 	vnode_t *rtvp;
1654 	char root_hostname[SYS_NMLN+1];
1655 	struct servinfo *svp;
1656 	int error;
1657 	int vfsflags;
1658 	size_t size;
1659 	char *root_path;
1660 	struct pathname pn;
1661 	char *name;
1662 	cred_t *cr;
1663 	struct nfs_args args;		/* nfs mount arguments */
1664 	static char token[10];
1665 
1666 	bzero(&args, sizeof (args));
1667 
1668 	/* do this BEFORE getfile which causes xid stamps to be initialized */
1669 	clkset(-1L);		/* hack for now - until we get time svc? */
1670 
1671 	if (why == ROOT_REMOUNT) {
1672 		/*
1673 		 * Shouldn't happen.
1674 		 */
1675 		panic("nfs_mountroot: why == ROOT_REMOUNT");
1676 	}
1677 
1678 	if (why == ROOT_UNMOUNT) {
1679 		/*
1680 		 * Nothing to do for NFS.
1681 		 */
1682 		return (0);
1683 	}
1684 
1685 	/*
1686 	 * why == ROOT_INIT
1687 	 */
1688 
1689 	name = token;
1690 	*name = 0;
1691 	getfsname("root", name, sizeof (token));
1692 
1693 	pn_alloc(&pn);
1694 	root_path = pn.pn_path;
1695 
1696 	svp = kmem_zalloc(sizeof (*svp), KM_SLEEP);
1697 	svp->sv_knconf = kmem_zalloc(sizeof (*svp->sv_knconf), KM_SLEEP);
1698 	svp->sv_knconf->knc_protofmly = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
1699 	svp->sv_knconf->knc_proto = kmem_alloc(KNC_STRSIZE, KM_SLEEP);
1700 
1701 	/*
1702 	 * Get server address
1703 	 * Get the root fhandle
1704 	 * Get server's transport
1705 	 * Get server's hostname
1706 	 * Get options
1707 	 */
1708 	args.addr = &svp->sv_addr;
1709 	args.fh = (char *)&svp->sv_fhandle.fh_buf;
1710 	args.knconf = svp->sv_knconf;
1711 	args.hostname = root_hostname;
1712 	vfsflags = 0;
1713 	if (error = mount_root(*name ? name : "root", root_path, NFS_VERSION,
1714 	    &args, &vfsflags)) {
1715 		nfs_cmn_err(error, CE_WARN,
1716 		    "nfs_mountroot: mount_root failed: %m");
1717 		sv_free(svp);
1718 		pn_free(&pn);
1719 		return (error);
1720 	}
1721 	svp->sv_fhandle.fh_len = NFS_FHSIZE;
1722 	svp->sv_hostnamelen = (int)(strlen(root_hostname) + 1);
1723 	svp->sv_hostname = kmem_alloc(svp->sv_hostnamelen, KM_SLEEP);
1724 	(void) strcpy(svp->sv_hostname, root_hostname);
1725 
1726 	/*
1727 	 * Force root partition to always be mounted with AUTH_UNIX for now
1728 	 */
1729 	svp->sv_secdata = kmem_alloc(sizeof (*svp->sv_secdata), KM_SLEEP);
1730 	svp->sv_secdata->secmod = AUTH_UNIX;
1731 	svp->sv_secdata->rpcflavor = AUTH_UNIX;
1732 	svp->sv_secdata->data = NULL;
1733 
1734 	cr = crgetcred();
1735 	rtvp = NULL;
1736 
1737 	error = nfsrootvp(&rtvp, vfsp, svp, args.flags, cr, global_zone);
1738 
1739 	crfree(cr);
1740 
1741 	if (error) {
1742 		pn_free(&pn);
1743 		sv_free(svp);
1744 		return (error);
1745 	}
1746 
1747 	error = nfs_setopts(rtvp, DATAMODEL_NATIVE, &args);
1748 	if (error) {
1749 		nfs_cmn_err(error, CE_WARN,
1750 		    "nfs_mountroot: invalid root mount options");
1751 		pn_free(&pn);
1752 		goto errout;
1753 	}
1754 
1755 	(void) vfs_lock_wait(vfsp);
1756 	vfs_add(NULL, vfsp, vfsflags);
1757 	vfs_unlock(vfsp);
1758 
1759 	size = strlen(svp->sv_hostname);
1760 	(void) strcpy(rootfs.bo_name, svp->sv_hostname);
1761 	rootfs.bo_name[size] = ':';
1762 	(void) strcpy(&rootfs.bo_name[size + 1], root_path);
1763 
1764 	pn_free(&pn);
1765 
1766 errout:
1767 	if (error) {
1768 		sv_free(svp);
1769 		nfs_async_stop(vfsp);
1770 		nfs_async_manager_stop(vfsp);
1771 	}
1772 
1773 	if (rtvp != NULL)
1774 		VN_RELE(rtvp);
1775 
1776 	return (error);
1777 }
1778 
1779 /*
1780  * Initialization routine for VFS routines.  Should only be called once
1781  */
1782 int
1783 nfs_vfsinit(void)
1784 {
1785 	mutex_init(&nfs_syncbusy, NULL, MUTEX_DEFAULT, NULL);
1786 	return (0);
1787 }
1788 
1789 void
1790 nfs_vfsfini(void)
1791 {
1792 	mutex_destroy(&nfs_syncbusy);
1793 }
1794 
1795 void
1796 nfs_freevfs(vfs_t *vfsp)
1797 {
1798 	mntinfo_t *mi;
1799 	servinfo_t *svp;
1800 
1801 	/* free up the resources */
1802 	mi = VFTOMI(vfsp);
1803 	pathconf_rele(mi);
1804 	svp = mi->mi_servers;
1805 	mi->mi_servers = mi->mi_curr_serv = NULL;
1806 	sv_free(svp);
1807 
1808 	/*
1809 	 * By this time we should have already deleted the
1810 	 * mi kstats in the unmount code. If they are still around
1811 	 * somethings wrong
1812 	 */
1813 	ASSERT(mi->mi_io_kstats == NULL);
1814 	nfs_free_mi(mi);
1815 }
1816