xref: /titanic_52/usr/src/uts/common/fs/autofs/auto_vfsops.c (revision 69112edd987c28fa551d4f8d9362a84a45365f17)
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 
26 #include <sys/param.h>
27 #include <sys/errno.h>
28 #include <sys/proc.h>
29 #include <sys/disp.h>
30 #include <sys/vfs.h>
31 #include <sys/vfs_opreg.h>
32 #include <sys/vnode.h>
33 #include <sys/uio.h>
34 #include <sys/kmem.h>
35 #include <sys/cred.h>
36 #include <sys/statvfs.h>
37 #include <sys/mount.h>
38 #include <sys/tiuser.h>
39 #include <sys/cmn_err.h>
40 #include <sys/debug.h>
41 #include <sys/systm.h>
42 #include <sys/sysmacros.h>
43 #include <sys/pathname.h>
44 #include <rpc/types.h>
45 #include <rpc/auth.h>
46 #include <rpc/clnt.h>
47 #include <fs/fs_subr.h>
48 #include <sys/fs/autofs.h>
49 #include <sys/modctl.h>
50 #include <sys/mntent.h>
51 #include <sys/policy.h>
52 #include <sys/zone.h>
53 
54 static int autofs_init(int, char *);
55 
56 static major_t autofs_major;
57 static minor_t autofs_minor;
58 
59 kmutex_t autofs_minor_lock;
60 zone_key_t autofs_key;
61 
62 static mntopts_t auto_mntopts;
63 
64 /*
65  * The AUTOFS system call.
66  */
67 static struct sysent autofssysent = {
68 	2,
69 	SE_32RVAL1 | SE_ARGC | SE_NOUNLOAD,
70 	autofssys
71 };
72 
73 static struct modlsys modlsys = {
74 	&mod_syscallops,
75 	"AUTOFS syscall",
76 	&autofssysent
77 };
78 
79 #ifdef	_SYSCALL32_IMPL
80 static struct modlsys  modlsys32 = {
81 	&mod_syscallops32,
82 	"AUTOFS syscall (32-bit)",
83 	&autofssysent
84 };
85 #endif	/* _SYSCALL32_IMPL */
86 
87 static vfsdef_t vfw = {
88 	VFSDEF_VERSION,
89 	"autofs",
90 	autofs_init,
91 	VSW_HASPROTO|VSW_CANRWRO|VSW_CANREMOUNT|VSW_STATS,
92 	&auto_mntopts
93 };
94 
95 /*
96  * Module linkage information for the kernel.
97  */
98 static struct modlfs modlfs = {
99 	&mod_fsops, "filesystem for autofs", &vfw
100 };
101 
102 static struct modlinkage modlinkage = {
103 	MODREV_1,
104 	&modlfs,
105 	&modlsys,
106 #ifdef	_SYSCALL32_IMPL
107 	&modlsys32,
108 #endif
109 	NULL
110 };
111 
112 /*
113  * There are not enough stubs for rpcmod so we must force load it
114  */
115 char _depends_on[] = "strmod/rpcmod misc/rpcsec fs/mntfs";
116 
117 /*
118  * This is the module initialization routine.
119  */
120 int
121 _init(void)
122 {
123 	return (mod_install(&modlinkage));
124 }
125 
126 int
127 _fini(void)
128 {
129 	/*
130 	 * Don't allow the autofs module to be unloaded for now.
131 	 */
132 	return (EBUSY);
133 }
134 
135 int
136 _info(struct modinfo *modinfop)
137 {
138 	return (mod_info(&modlinkage, modinfop));
139 }
140 
141 static int autofs_fstype;
142 
143 /*
144  * autofs VFS operations
145  */
146 static int auto_mount(vfs_t *, vnode_t *, struct mounta *, cred_t *);
147 static int auto_unmount(vfs_t *, int, cred_t *);
148 static int auto_root(vfs_t *, vnode_t **);
149 static int auto_statvfs(vfs_t *, struct statvfs64 *);
150 
151 /*
152  * Auto Mount options table
153  */
154 
155 static char *direct_cancel[] = { MNTOPT_INDIRECT, NULL };
156 static char *indirect_cancel[] = { MNTOPT_DIRECT, NULL };
157 static char *browse_cancel[] = { MNTOPT_NOBROWSE, NULL };
158 static char *nobrowse_cancel[] = { MNTOPT_BROWSE, NULL };
159 
160 static mntopt_t mntopts[] = {
161 /*
162  *	option name		cancel options	default arg	flags
163  */
164 	{ MNTOPT_DIRECT,	direct_cancel,	NULL,		0,
165 		NULL },
166 	{ MNTOPT_INDIRECT,	indirect_cancel, NULL,		0,
167 		NULL },
168 	{ MNTOPT_IGNORE,	NULL,		NULL,
169 		MO_DEFAULT|MO_TAG,	NULL },
170 	{ "nest",		NULL,		NULL,		MO_TAG,
171 		NULL },
172 	{ MNTOPT_BROWSE,	browse_cancel,	NULL,		MO_TAG,
173 		NULL },
174 	{ MNTOPT_NOBROWSE,	nobrowse_cancel, NULL,		MO_TAG,
175 		NULL },
176 	{ MNTOPT_RESTRICT,	NULL,		NULL,		MO_TAG,
177 		NULL },
178 };
179 
180 static mntopts_t auto_mntopts = {
181 	sizeof (mntopts) / sizeof (mntopt_t),
182 	mntopts
183 };
184 
185 /*ARGSUSED*/
186 static void
187 autofs_zone_destructor(zoneid_t zoneid, void *arg)
188 {
189 	struct autofs_globals *fngp = arg;
190 	vnode_t *vp;
191 
192 	if (fngp == NULL)
193 		return;
194 	ASSERT(fngp->fng_fnnode_count == 1);
195 	ASSERT(fngp->fng_unmount_threads == 0);
196 	/*
197 	 * vn_alloc() initialized the rootnode with a count of 1; we need to
198 	 * make this 0 to placate auto_freefnnode().
199 	 */
200 	vp = fntovn(fngp->fng_rootfnnodep);
201 	ASSERT(vp->v_count == 1);
202 	vp->v_count--;
203 	auto_freefnnode(fngp->fng_rootfnnodep);
204 	mutex_destroy(&fngp->fng_unmount_threads_lock);
205 	kmem_free(fngp, sizeof (*fngp));
206 }
207 
208 /*
209  * rootfnnodep is allocated here.  Its sole purpose is to provide
210  * read/write locking for top level fnnodes.  This object is
211  * persistent and will not be deallocated until the zone is destroyed.
212  *
213  * The current zone is implied as the zone of interest, since we will be
214  * calling zthread_create() which must be called from the correct zone.
215  */
216 struct autofs_globals *
217 autofs_zone_init(void)
218 {
219 	char rootname[sizeof ("root_fnnode_zone_") + ZONEID_WIDTH];
220 	struct autofs_globals *fngp;
221 	zoneid_t zoneid = getzoneid();
222 
223 	fngp = kmem_zalloc(sizeof (*fngp), KM_SLEEP);
224 	(void) snprintf(rootname, sizeof (rootname), "root_fnnode_zone_%d",
225 	    zoneid);
226 	fngp->fng_rootfnnodep = auto_makefnnode(VNON, NULL, rootname, CRED(),
227 	    fngp);
228 	/*
229 	 * Don't need to hold fng_rootfnnodep as it's never really used for
230 	 * anything.
231 	 */
232 	fngp->fng_fnnode_count = 1;
233 	fngp->fng_printed_not_running_msg = 0;
234 	fngp->fng_zoneid = zoneid;
235 	mutex_init(&fngp->fng_unmount_threads_lock, NULL, MUTEX_DEFAULT,
236 	    NULL);
237 	fngp->fng_unmount_threads = 0;
238 
239 	mutex_init(&fngp->fng_autofs_daemon_lock, NULL, MUTEX_DEFAULT, NULL);
240 
241 	/*
242 	 * Start the unmounter thread for this zone.
243 	 */
244 	(void) zthread_create(NULL, 0, auto_do_unmount, fngp, 0, minclsyspri);
245 	return (fngp);
246 }
247 
248 int
249 autofs_init(int fstype, char *name)
250 {
251 	static const fs_operation_def_t auto_vfsops_template[] = {
252 		VFSNAME_MOUNT,		{ .vfs_mount = auto_mount },
253 		VFSNAME_UNMOUNT,	{ .vfs_unmount = auto_unmount },
254 		VFSNAME_ROOT,		{ .vfs_root = auto_root },
255 		VFSNAME_STATVFS,	{ .vfs_statvfs = auto_statvfs },
256 		NULL,			NULL
257 	};
258 	int error;
259 
260 	autofs_fstype = fstype;
261 	ASSERT(autofs_fstype != 0);
262 	/*
263 	 * Associate VFS ops vector with this fstype
264 	 */
265 	error = vfs_setfsops(fstype, auto_vfsops_template, NULL);
266 	if (error != 0) {
267 		cmn_err(CE_WARN, "autofs_init: bad vfs ops template");
268 		return (error);
269 	}
270 
271 	error = vn_make_ops(name, auto_vnodeops_template, &auto_vnodeops);
272 	if (error != 0) {
273 		(void) vfs_freevfsops_by_type(fstype);
274 		cmn_err(CE_WARN, "autofs_init: bad vnode ops template");
275 		return (error);
276 	}
277 
278 	mutex_init(&autofs_minor_lock, NULL, MUTEX_DEFAULT, NULL);
279 	/*
280 	 * Assign unique major number for all autofs mounts
281 	 */
282 	if ((autofs_major = getudev()) == (major_t)-1) {
283 		cmn_err(CE_WARN,
284 		    "autofs: autofs_init: can't get unique device number");
285 		mutex_destroy(&autofs_minor_lock);
286 		return (1);
287 	}
288 
289 	/*
290 	 * We'd like to be able to provide a constructor here, but we can't
291 	 * since it wants to zthread_create(), something it can't do in a ZSD
292 	 * constructor.
293 	 */
294 	zone_key_create(&autofs_key, NULL, NULL, autofs_zone_destructor);
295 
296 	return (0);
297 }
298 
299 static char *restropts[] = {
300 	RESTRICTED_MNTOPTS
301 };
302 
303 /*
304  * This routine adds those options to the option string `buf' which are
305  * forced by secpolicy_fs_mount.  If the automatic "security" options
306  * are set, the option string gets them added if they aren't already
307  * there.  We search the string with "strstr" and make sure that
308  * the string we find is bracketed with <start|",">MNTOPT<","|"\0">
309  *
310  * This is one half of the option inheritence algorithm which
311  * implements the "restrict" option.  The other half is implemented
312  * in automountd; it takes its cue from the options we add here.
313  */
314 static int
315 autofs_restrict_opts(struct vfs *vfsp, char *buf, size_t maxlen, size_t *curlen)
316 {
317 	int i;
318 	char *p;
319 	size_t len = *curlen - 1;
320 
321 	/* Unrestricted */
322 	if (!vfs_optionisset(vfsp, restropts[0], NULL))
323 		return (0);
324 
325 	for (i = 0; i < sizeof (restropts)/sizeof (restropts[0]); i++) {
326 		size_t olen = strlen(restropts[i]);
327 
328 		/* Add "restrict" always and the others insofar set */
329 		if ((i == 0 || vfs_optionisset(vfsp, restropts[i], NULL)) &&
330 		    ((p = strstr(buf, restropts[i])) == NULL ||
331 		    !((p == buf || p[-1] == ',') &&
332 		    (p[olen] == '\0' || p[olen] == ',')))) {
333 
334 			if (len + olen + 1 > maxlen)
335 				return (-1);
336 
337 			if (*buf != '\0')
338 				buf[len++] = ',';
339 			(void) strcpy(&buf[len], restropts[i]);
340 			len += olen;
341 		}
342 	}
343 	*curlen = len + 1;
344 	return (0);
345 }
346 
347 /* ARGSUSED */
348 static int
349 auto_mount(vfs_t *vfsp, vnode_t *vp, struct mounta *uap, cred_t *cr)
350 {
351 	int error;
352 	size_t len = 0;
353 	autofs_args args;
354 	fninfo_t *fnip = NULL;
355 	vnode_t *rootvp = NULL;
356 	fnnode_t *rootfnp = NULL;
357 	char *data = uap->dataptr;
358 	char datalen = uap->datalen;
359 	dev_t autofs_dev;
360 	char strbuff[MAXPATHLEN + 1];
361 	vnode_t *kkvp;
362 	struct autofs_globals *fngp;
363 	zone_t *zone = curproc->p_zone;
364 
365 	AUTOFS_DPRINT((4, "auto_mount: vfs %p vp %p\n", (void *)vfsp,
366 	    (void *)vp));
367 
368 	if ((error = secpolicy_fs_mount(cr, vp, vfsp)) != 0)
369 		return (EPERM);
370 
371 	if (zone == global_zone) {
372 		zone_t *mntzone;
373 
374 		mntzone = zone_find_by_path(refstr_value(vfsp->vfs_mntpt));
375 		ASSERT(mntzone != NULL);
376 		zone_rele(mntzone);
377 		if (mntzone != zone) {
378 			return (EBUSY);
379 		}
380 	}
381 
382 	/*
383 	 * Stop the mount from going any further if the zone is going away.
384 	 */
385 	if (zone_status_get(zone) >= ZONE_IS_SHUTTING_DOWN)
386 		return (EBUSY);
387 
388 	/*
389 	 * We need a lock to serialize this; minor_lock is as good as any.
390 	 */
391 	mutex_enter(&autofs_minor_lock);
392 	if ((fngp = zone_getspecific(autofs_key, zone)) == NULL) {
393 		fngp = autofs_zone_init();
394 		(void) zone_setspecific(autofs_key, zone, fngp);
395 	}
396 	mutex_exit(&autofs_minor_lock);
397 	ASSERT(fngp != NULL);
398 
399 	/*
400 	 * Get arguments
401 	 */
402 	if (uap->flags & MS_SYSSPACE) {
403 		if (datalen != sizeof (args))
404 			return (EINVAL);
405 		error = kcopy(data, &args, sizeof (args));
406 	} else {
407 		if (get_udatamodel() == DATAMODEL_NATIVE) {
408 			if (datalen != sizeof (args))
409 				return (EINVAL);
410 			error = copyin(data, &args, sizeof (args));
411 		} else {
412 			struct autofs_args32 args32;
413 
414 			if (datalen != sizeof (args32))
415 				return (EINVAL);
416 			error = copyin(data, &args32, sizeof (args32));
417 
418 			args.addr.maxlen = args32.addr.maxlen;
419 			args.addr.len = args32.addr.len;
420 			args.addr.buf = (char *)(uintptr_t)args32.addr.buf;
421 			args.path = (char *)(uintptr_t)args32.path;
422 			args.opts = (char *)(uintptr_t)args32.opts;
423 			args.map = (char *)(uintptr_t)args32.map;
424 			args.subdir = (char *)(uintptr_t)args32.subdir;
425 			args.key = (char *)(uintptr_t)args32.key;
426 			args.mount_to = args32.mount_to;
427 			args.rpc_to = args32.rpc_to;
428 			args.direct = args32.direct;
429 		}
430 	}
431 	if (error)
432 		return (EFAULT);
433 
434 	/*
435 	 * For a remount, only update mount information
436 	 * i.e. default mount options, map name, etc.
437 	 */
438 	if (uap->flags & MS_REMOUNT) {
439 		fnip = vfstofni(vfsp);
440 		if (fnip == NULL)
441 			return (EINVAL);
442 
443 		if (args.direct == 1)
444 			fnip->fi_flags |= MF_DIRECT;
445 		else
446 			fnip->fi_flags &= ~MF_DIRECT;
447 		fnip->fi_mount_to = args.mount_to;
448 		fnip->fi_rpc_to = args.rpc_to;
449 
450 		/*
451 		 * Get default options
452 		 */
453 		if (uap->flags & MS_SYSSPACE)
454 			error = copystr(args.opts, strbuff, sizeof (strbuff),
455 			    &len);
456 		else
457 			error = copyinstr(args.opts, strbuff, sizeof (strbuff),
458 			    &len);
459 		if (error)
460 			return (EFAULT);
461 
462 		if (autofs_restrict_opts(vfsp, strbuff, sizeof (strbuff), &len)
463 		    != 0) {
464 			return (EFAULT);
465 		}
466 
467 		kmem_free(fnip->fi_opts, fnip->fi_optslen);
468 		fnip->fi_opts = kmem_alloc(len, KM_SLEEP);
469 		fnip->fi_optslen = (int)len;
470 		bcopy(strbuff, fnip->fi_opts, len);
471 
472 		/*
473 		 * Get context/map name
474 		 */
475 		if (uap->flags & MS_SYSSPACE)
476 			error = copystr(args.map, strbuff, sizeof (strbuff),
477 			    &len);
478 		else
479 			error = copyinstr(args.map, strbuff, sizeof (strbuff),
480 			    &len);
481 		if (error)
482 			return (EFAULT);
483 
484 		kmem_free(fnip->fi_map, fnip->fi_maplen);
485 		fnip->fi_map = kmem_alloc(len, KM_SLEEP);
486 		fnip->fi_maplen = (int)len;
487 		bcopy(strbuff, fnip->fi_map, len);
488 
489 		return (0);
490 	}
491 
492 	/*
493 	 * Allocate fninfo struct and attach it to vfs
494 	 */
495 	fnip = kmem_zalloc(sizeof (*fnip), KM_SLEEP);
496 	fnip->fi_mountvfs = vfsp;
497 
498 	fnip->fi_mount_to = args.mount_to;
499 	fnip->fi_rpc_to = args.rpc_to;
500 	fnip->fi_refcnt = 0;
501 	vfsp->vfs_bsize = AUTOFS_BLOCKSIZE;
502 	vfsp->vfs_fstype = autofs_fstype;
503 
504 	/*
505 	 * Assign a unique device id to the mount
506 	 */
507 	mutex_enter(&autofs_minor_lock);
508 	do {
509 		autofs_minor = (autofs_minor + 1) & L_MAXMIN32;
510 		autofs_dev = makedevice(autofs_major, autofs_minor);
511 	} while (vfs_devismounted(autofs_dev));
512 	mutex_exit(&autofs_minor_lock);
513 	vfsp->vfs_dev = autofs_dev;
514 	vfs_make_fsid(&vfsp->vfs_fsid, autofs_dev, autofs_fstype);
515 	vfsp->vfs_data = (void *)fnip;
516 	vfsp->vfs_bcount = 0;
517 
518 	/*
519 	 * Get daemon address
520 	 */
521 	fnip->fi_addr.len = args.addr.len;
522 	fnip->fi_addr.maxlen = fnip->fi_addr.len;
523 	fnip->fi_addr.buf = kmem_alloc(args.addr.len, KM_SLEEP);
524 	if (uap->flags & MS_SYSSPACE)
525 		error = kcopy(args.addr.buf, fnip->fi_addr.buf, args.addr.len);
526 	else
527 		error = copyin(args.addr.buf, fnip->fi_addr.buf, args.addr.len);
528 	if (error) {
529 		error = EFAULT;
530 		goto errout;
531 	}
532 
533 	fnip->fi_zoneid = getzoneid();
534 	/*
535 	 * Get path for mountpoint
536 	 */
537 	if (uap->flags & MS_SYSSPACE)
538 		error = copystr(args.path, strbuff, sizeof (strbuff), &len);
539 	else
540 		error = copyinstr(args.path, strbuff, sizeof (strbuff), &len);
541 	if (error) {
542 		error = EFAULT;
543 		goto errout;
544 	}
545 	fnip->fi_path = kmem_alloc(len, KM_SLEEP);
546 	fnip->fi_pathlen = (int)len;
547 	bcopy(strbuff, fnip->fi_path, len);
548 
549 	/*
550 	 * Get default options
551 	 */
552 	if (uap->flags & MS_SYSSPACE)
553 		error = copystr(args.opts, strbuff, sizeof (strbuff), &len);
554 	else
555 		error = copyinstr(args.opts, strbuff, sizeof (strbuff), &len);
556 
557 	if (error != 0 ||
558 	    autofs_restrict_opts(vfsp, strbuff, sizeof (strbuff), &len) != 0) {
559 		error = EFAULT;
560 		goto errout;
561 	}
562 	fnip->fi_opts = kmem_alloc(len, KM_SLEEP);
563 	fnip->fi_optslen = (int)len;
564 	bcopy(strbuff, fnip->fi_opts, len);
565 
566 	/*
567 	 * Get context/map name
568 	 */
569 	if (uap->flags & MS_SYSSPACE)
570 		error = copystr(args.map, strbuff, sizeof (strbuff), &len);
571 	else
572 		error = copyinstr(args.map, strbuff, sizeof (strbuff), &len);
573 	if (error) {
574 		error = EFAULT;
575 		goto errout;
576 	}
577 	fnip->fi_map = kmem_alloc(len, KM_SLEEP);
578 	fnip->fi_maplen = (int)len;
579 	bcopy(strbuff, fnip->fi_map, len);
580 
581 	/*
582 	 * Get subdirectory within map
583 	 */
584 	if (uap->flags & MS_SYSSPACE)
585 		error = copystr(args.subdir, strbuff, sizeof (strbuff), &len);
586 	else
587 		error = copyinstr(args.subdir, strbuff, sizeof (strbuff), &len);
588 	if (error) {
589 		error = EFAULT;
590 		goto errout;
591 	}
592 	fnip->fi_subdir = kmem_alloc(len, KM_SLEEP);
593 	fnip->fi_subdirlen = (int)len;
594 	bcopy(strbuff, fnip->fi_subdir, len);
595 
596 	/*
597 	 * Get the key
598 	 */
599 	if (uap->flags & MS_SYSSPACE)
600 		error = copystr(args.key, strbuff, sizeof (strbuff), &len);
601 	else
602 		error = copyinstr(args.key, strbuff, sizeof (strbuff), &len);
603 	if (error) {
604 		error = EFAULT;
605 		goto errout;
606 	}
607 	fnip->fi_key = kmem_alloc(len, KM_SLEEP);
608 	fnip->fi_keylen = (int)len;
609 	bcopy(strbuff, fnip->fi_key, len);
610 
611 	/*
612 	 * Is this a direct mount?
613 	 */
614 	if (args.direct == 1)
615 		fnip->fi_flags |= MF_DIRECT;
616 
617 	/*
618 	 * Setup netconfig.
619 	 * Can I pass in knconf as mount argument? what
620 	 * happens when the daemon gets restarted?
621 	 */
622 	if ((error = lookupname("/dev/ticotsord", UIO_SYSSPACE, FOLLOW,
623 	    NULLVPP, &kkvp)) != 0) {
624 		cmn_err(CE_WARN, "autofs: lookupname: %d", error);
625 		goto errout;
626 	}
627 
628 	fnip->fi_knconf.knc_rdev = kkvp->v_rdev;
629 	fnip->fi_knconf.knc_protofmly = NC_LOOPBACK;
630 	fnip->fi_knconf.knc_semantics = NC_TPI_COTS_ORD;
631 	VN_RELE(kkvp);
632 
633 	/*
634 	 * Make the root vnode
635 	 */
636 	rootfnp = auto_makefnnode(VDIR, vfsp, fnip->fi_path, cr, fngp);
637 	if (rootfnp == NULL) {
638 		error = ENOMEM;
639 		goto errout;
640 	}
641 	rootvp = fntovn(rootfnp);
642 
643 	rootvp->v_flag |= VROOT;
644 	rootfnp->fn_mode = AUTOFS_MODE;
645 	rootfnp->fn_parent = rootfnp;
646 	/* account for ".." entry */
647 	rootfnp->fn_linkcnt = rootfnp->fn_size = 1;
648 	fnip->fi_rootvp = rootvp;
649 
650 	/*
651 	 * Add to list of top level AUTOFS' if it is being mounted by
652 	 * a user level process.
653 	 */
654 	if (!(uap->flags & MS_SYSSPACE)) {
655 		rw_enter(&fngp->fng_rootfnnodep->fn_rwlock, RW_WRITER);
656 		rootfnp->fn_parent = fngp->fng_rootfnnodep;
657 		rootfnp->fn_next = fngp->fng_rootfnnodep->fn_dirents;
658 		fngp->fng_rootfnnodep->fn_dirents = rootfnp;
659 		rw_exit(&fngp->fng_rootfnnodep->fn_rwlock);
660 	}
661 
662 	AUTOFS_DPRINT((5, "auto_mount: vfs %p root %p fnip %p return %d\n",
663 	    (void *)vfsp, (void *)rootvp, (void *)fnip, error));
664 
665 	return (0);
666 
667 errout:
668 	ASSERT(fnip != NULL);
669 	ASSERT((uap->flags & MS_REMOUNT) == 0);
670 
671 	if (fnip->fi_addr.buf != NULL)
672 		kmem_free(fnip->fi_addr.buf, fnip->fi_addr.len);
673 	if (fnip->fi_path != NULL)
674 		kmem_free(fnip->fi_path, fnip->fi_pathlen);
675 	if (fnip->fi_opts != NULL)
676 		kmem_free(fnip->fi_opts, fnip->fi_optslen);
677 	if (fnip->fi_map != NULL)
678 		kmem_free(fnip->fi_map, fnip->fi_maplen);
679 	if (fnip->fi_subdir != NULL)
680 		kmem_free(fnip->fi_subdir, fnip->fi_subdirlen);
681 	if (fnip->fi_key != NULL)
682 		kmem_free(fnip->fi_key, fnip->fi_keylen);
683 	kmem_free(fnip, sizeof (*fnip));
684 
685 	AUTOFS_DPRINT((5, "auto_mount: vfs %p root %p fnip %p return %d\n",
686 	    (void *)vfsp, (void *)rootvp, (void *)fnip, error));
687 
688 	return (error);
689 }
690 
691 /* ARGSUSED */
692 static int
693 auto_unmount(vfs_t *vfsp, int flag, cred_t *cr)
694 {
695 	fninfo_t *fnip;
696 	vnode_t *rvp;
697 	fnnode_t *rfnp, *fnp, *pfnp;
698 	fnnode_t *myrootfnnodep;
699 
700 	fnip = vfstofni(vfsp);
701 	AUTOFS_DPRINT((4, "auto_unmount vfsp %p fnip %p\n", (void *)vfsp,
702 	    (void *)fnip));
703 
704 	if (secpolicy_fs_unmount(cr, vfsp) != 0)
705 		return (EPERM);
706 	/*
707 	 * forced unmount is not supported by this file system
708 	 * and thus, ENOTSUP, is being returned.
709 	 */
710 	if (flag & MS_FORCE)
711 		return (ENOTSUP);
712 
713 	ASSERT(vn_vfswlock_held(vfsp->vfs_vnodecovered));
714 	rvp = fnip->fi_rootvp;
715 	rfnp = vntofn(rvp);
716 
717 	if (rvp->v_count > 1 || rfnp->fn_dirents != NULL)
718 		return (EBUSY);
719 
720 	/*
721 	 * The root vnode is on the linked list of root fnnodes only if
722 	 * this was not a trigger node. Since we have no way of knowing,
723 	 * if we don't find it, then we assume it was a trigger node.
724 	 */
725 	myrootfnnodep = rfnp->fn_globals->fng_rootfnnodep;
726 	pfnp = NULL;
727 	rw_enter(&myrootfnnodep->fn_rwlock, RW_WRITER);
728 	fnp = myrootfnnodep->fn_dirents;
729 	while (fnp != NULL) {
730 		if (fnp == rfnp) {
731 			/*
732 			 * A check here is made to see if rvp is busy.  If
733 			 * so, return EBUSY.  Otherwise proceed with
734 			 * disconnecting it from the list.
735 			 */
736 			if (rvp->v_count > 1 || rfnp->fn_dirents != NULL) {
737 				rw_exit(&myrootfnnodep->fn_rwlock);
738 				return (EBUSY);
739 			}
740 			if (pfnp)
741 				pfnp->fn_next = fnp->fn_next;
742 			else
743 				myrootfnnodep->fn_dirents = fnp->fn_next;
744 			fnp->fn_next = NULL;
745 			break;
746 		}
747 		pfnp = fnp;
748 		fnp = fnp->fn_next;
749 	}
750 	rw_exit(&myrootfnnodep->fn_rwlock);
751 
752 	ASSERT(rvp->v_count == 1);
753 	ASSERT(rfnp->fn_size == 1);
754 	ASSERT(rfnp->fn_linkcnt == 1);
755 	/*
756 	 * The following drops linkcnt to 0, therefore the disconnect is
757 	 * not attempted when auto_inactive() is called by
758 	 * vn_rele(). This is necessary because we have nothing to get
759 	 * disconnected from since we're the root of the filesystem. As a
760 	 * side effect the node is not freed, therefore I should free the
761 	 * node here.
762 	 *
763 	 * XXX - I really need to think of a better way of doing this.
764 	 */
765 	rfnp->fn_size--;
766 	rfnp->fn_linkcnt--;
767 
768 	/*
769 	 * release of last reference causes node
770 	 * to be freed
771 	 */
772 	VN_RELE(rvp);
773 	rfnp->fn_parent = NULL;
774 
775 	auto_freefnnode(rfnp);
776 
777 	kmem_free(fnip->fi_addr.buf, fnip->fi_addr.len);
778 	kmem_free(fnip->fi_path, fnip->fi_pathlen);
779 	kmem_free(fnip->fi_map, fnip->fi_maplen);
780 	kmem_free(fnip->fi_subdir, fnip->fi_subdirlen);
781 	kmem_free(fnip->fi_key, fnip->fi_keylen);
782 	kmem_free(fnip->fi_opts, fnip->fi_optslen);
783 	kmem_free(fnip, sizeof (*fnip));
784 	AUTOFS_DPRINT((5, "auto_unmount: return=0\n"));
785 
786 	return (0);
787 }
788 
789 
790 /*
791  * find root of autofs
792  */
793 static int
794 auto_root(vfs_t *vfsp, vnode_t **vpp)
795 {
796 	*vpp = (vnode_t *)vfstofni(vfsp)->fi_rootvp;
797 	VN_HOLD(*vpp);
798 
799 	AUTOFS_DPRINT((5, "auto_root: vfs %p, *vpp %p\n", (void *)vfsp,
800 	    (void *)*vpp));
801 	return (0);
802 }
803 
804 /*
805  * Get file system statistics.
806  */
807 static int
808 auto_statvfs(vfs_t *vfsp, struct statvfs64 *sbp)
809 {
810 	dev32_t d32;
811 
812 	AUTOFS_DPRINT((4, "auto_statvfs %p\n", (void *)vfsp));
813 
814 	bzero(sbp, sizeof (*sbp));
815 	sbp->f_bsize	= vfsp->vfs_bsize;
816 	sbp->f_frsize	= sbp->f_bsize;
817 	sbp->f_blocks	= (fsblkcnt64_t)0;
818 	sbp->f_bfree	= (fsblkcnt64_t)0;
819 	sbp->f_bavail	= (fsblkcnt64_t)0;
820 	sbp->f_files	= (fsfilcnt64_t)0;
821 	sbp->f_ffree	= (fsfilcnt64_t)0;
822 	sbp->f_favail	= (fsfilcnt64_t)0;
823 	(void) cmpldev(&d32, vfsp->vfs_dev);
824 	sbp->f_fsid	= d32;
825 	(void) strcpy(sbp->f_basetype, vfssw[vfsp->vfs_fstype].vsw_name);
826 	sbp->f_flag = vf_to_stf(vfsp->vfs_flag);
827 	sbp->f_namemax = MAXNAMELEN;
828 	(void) strcpy(sbp->f_fstr, MNTTYPE_AUTOFS);
829 
830 	return (0);
831 }
832