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