xref: /freebsd/sys/fs/autofs/autofs_vnops.c (revision 2ed3236082a4473c1da8f72c1ebc071a7b54321f)
1 /*-
2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
3  *
4  * Copyright (c) 2014 The FreeBSD Foundation
5  * All rights reserved.
6  *
7  * This software was developed by Edward Tomasz Napierala under sponsorship
8  * from the FreeBSD Foundation.
9  *
10  * Redistribution and use in source and binary forms, with or without
11  * modification, are permitted provided that the following conditions
12  * are met:
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29  * SUCH DAMAGE.
30  *
31  */
32 
33 #include <sys/cdefs.h>
34 __FBSDID("$FreeBSD$");
35 
36 #include <sys/param.h>
37 #include <sys/systm.h>
38 #include <sys/kernel.h>
39 #include <sys/condvar.h>
40 #include <sys/dirent.h>
41 #include <sys/fcntl.h>
42 #include <sys/lock.h>
43 #include <sys/mount.h>
44 #include <sys/mutex.h>
45 #include <sys/namei.h>
46 #include <sys/signalvar.h>
47 #include <sys/stat.h>
48 #include <sys/taskqueue.h>
49 #include <sys/tree.h>
50 #include <sys/vnode.h>
51 #include <machine/atomic.h>
52 #include <vm/uma.h>
53 
54 #include <fs/autofs/autofs.h>
55 
56 static int	autofs_trigger_vn(struct vnode *vp, const char *path,
57 		    int pathlen, struct vnode **newvp);
58 
59 extern struct autofs_softc	*autofs_softc;
60 
61 static int
62 autofs_access(struct vop_access_args *ap)
63 {
64 
65 	/*
66 	 * Nothing to do here; the only kind of access control
67 	 * needed is in autofs_mkdir().
68 	 */
69 
70 	return (0);
71 }
72 
73 static int
74 autofs_getattr(struct vop_getattr_args *ap)
75 {
76 	struct vnode *vp, *newvp;
77 	struct autofs_node *anp;
78 	struct mount *mp;
79 	struct vattr *vap;
80 	int error;
81 
82 	vp = ap->a_vp;
83 	anp = vp->v_data;
84 	mp = vp->v_mount;
85 	vap = ap->a_vap;
86 
87 	KASSERT(ap->a_vp->v_type == VDIR, ("!VDIR"));
88 
89 	/*
90 	 * The reason we must do this is that some tree-walking software,
91 	 * namely fts(3), assumes that stat(".") results will not change
92 	 * between chdir("subdir") and chdir(".."), and fails with ENOENT
93 	 * otherwise.
94 	 */
95 	if (autofs_mount_on_stat && autofs_cached(anp, NULL, 0) == false &&
96 	    autofs_ignore_thread(curthread) == false) {
97 		error = autofs_trigger_vn(vp, "", 0, &newvp);
98 		if (error != 0)
99 			return (error);
100 
101 		if (newvp != NULL) {
102 			error = VOP_GETATTR(newvp, ap->a_vap,
103 			    ap->a_cred);
104 			vput(newvp);
105 			return (error);
106 		}
107 	}
108 
109 	vap->va_type = VDIR;
110 	vap->va_mode = 0755;
111 	vap->va_nlink = 3; /* XXX */
112 	vap->va_uid = 0;
113 	vap->va_gid = 0;
114 	vap->va_rdev = NODEV;
115 	vap->va_fsid = mp->mnt_stat.f_fsid.val[0];
116 	vap->va_fileid = anp->an_fileno;
117 	vap->va_size = S_BLKSIZE;
118 	vap->va_blocksize = S_BLKSIZE;
119 	vap->va_mtime = anp->an_ctime;
120 	vap->va_atime = anp->an_ctime;
121 	vap->va_ctime = anp->an_ctime;
122 	vap->va_birthtime = anp->an_ctime;
123 	vap->va_gen = 0;
124 	vap->va_flags = 0;
125 	vap->va_rdev = 0;
126 	vap->va_bytes = S_BLKSIZE;
127 	vap->va_filerev = 0;
128 	vap->va_spare = 0;
129 
130 	return (0);
131 }
132 
133 /*
134  * Unlock the vnode, request automountd(8) action, and then lock it back.
135  * If anything got mounted on top of the vnode, return the new filesystem's
136  * root vnode in 'newvp', locked.
137  */
138 static int
139 autofs_trigger_vn(struct vnode *vp, const char *path, int pathlen,
140     struct vnode **newvp)
141 {
142 	struct autofs_node *anp;
143 	int error, lock_flags;
144 
145 	anp = vp->v_data;
146 
147 	/*
148 	 * Release the vnode lock, so that other operations, in partcular
149 	 * mounting a filesystem on top of it, can proceed.  Increase use
150 	 * count, to prevent the vnode from being deallocated and to prevent
151 	 * filesystem from being unmounted.
152 	 */
153 	lock_flags = VOP_ISLOCKED(vp);
154 	vref(vp);
155 	VOP_UNLOCK(vp);
156 
157 	sx_xlock(&autofs_softc->sc_lock);
158 
159 	/*
160 	 * XXX: Workaround for mounting the same thing multiple times; revisit.
161 	 */
162 	if (vp->v_mountedhere != NULL) {
163 		error = 0;
164 		goto mounted;
165 	}
166 
167 	error = autofs_trigger(anp, path, pathlen);
168 mounted:
169 	sx_xunlock(&autofs_softc->sc_lock);
170 	vn_lock(vp, lock_flags | LK_RETRY);
171 	vunref(vp);
172 	if (VN_IS_DOOMED(vp)) {
173 		AUTOFS_DEBUG("VIRF_DOOMED");
174 		return (ENOENT);
175 	}
176 
177 	if (error != 0)
178 		return (error);
179 
180 	if (vp->v_mountedhere == NULL) {
181 		*newvp = NULL;
182 		return (0);
183 	} else {
184 		/*
185 		 * If the operation that succeeded was mount, then mark
186 		 * the node as non-cached.  Otherwise, if someone unmounts
187 		 * the filesystem before the cache times out, we will fail
188 		 * to trigger.
189 		 */
190 		anp->an_cached = false;
191 	}
192 
193 	error = VFS_ROOT(vp->v_mountedhere, lock_flags, newvp);
194 	if (error != 0) {
195 		AUTOFS_WARN("VFS_ROOT() failed with error %d", error);
196 		return (error);
197 	}
198 
199 	return (0);
200 }
201 
202 static int
203 autofs_vget_callback(struct mount *mp, void *arg, int flags,
204     struct vnode **vpp)
205 {
206 
207 	return (autofs_node_vn(arg, mp, flags, vpp));
208 }
209 
210 static int
211 autofs_lookup(struct vop_lookup_args *ap)
212 {
213 	struct vnode *dvp, *newvp, **vpp;
214 	struct mount *mp;
215 	struct autofs_mount *amp;
216 	struct autofs_node *anp, *child;
217 	struct componentname *cnp;
218 	int error;
219 
220 	dvp = ap->a_dvp;
221 	vpp = ap->a_vpp;
222 	mp = dvp->v_mount;
223 	amp = VFSTOAUTOFS(mp);
224 	anp = dvp->v_data;
225 	cnp = ap->a_cnp;
226 
227 	if (cnp->cn_flags & ISDOTDOT) {
228 		KASSERT(anp->an_parent != NULL, ("NULL parent"));
229 		/*
230 		 * Note that in this case, dvp is the child vnode, and we
231 		 * are looking up the parent vnode - exactly reverse from
232 		 * normal operation.  Unlocking dvp requires some rather
233 		 * tricky unlock/relock dance to prevent mp from being freed;
234 		 * use vn_vget_ino_gen() which takes care of all that.
235 		 */
236 		error = vn_vget_ino_gen(dvp, autofs_vget_callback,
237 		    anp->an_parent, cnp->cn_lkflags, vpp);
238 		if (error != 0) {
239 			AUTOFS_WARN("vn_vget_ino_gen() failed with error %d",
240 			    error);
241 			return (error);
242 		}
243 		return (error);
244 	}
245 
246 	if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
247 		vref(dvp);
248 		*vpp = dvp;
249 
250 		return (0);
251 	}
252 
253 	if (autofs_cached(anp, cnp->cn_nameptr, cnp->cn_namelen) == false &&
254 	    autofs_ignore_thread(cnp->cn_thread) == false) {
255 		error = autofs_trigger_vn(dvp,
256 		    cnp->cn_nameptr, cnp->cn_namelen, &newvp);
257 		if (error != 0)
258 			return (error);
259 
260 		if (newvp != NULL) {
261 			/*
262 			 * The target filesystem got automounted.
263 			 * Let the lookup(9) go around with the same
264 			 * path component.
265 			 */
266 			vput(newvp);
267 			return (ERELOOKUP);
268 		}
269 	}
270 
271 	AUTOFS_SLOCK(amp);
272 	error = autofs_node_find(anp, cnp->cn_nameptr, cnp->cn_namelen, &child);
273 	if (error != 0) {
274 		if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE) {
275 			AUTOFS_SUNLOCK(amp);
276 			return (EJUSTRETURN);
277 		}
278 
279 		AUTOFS_SUNLOCK(amp);
280 		return (ENOENT);
281 	}
282 
283 	/*
284 	 * XXX: Dropping the node here is ok, because we never remove nodes.
285 	 */
286 	AUTOFS_SUNLOCK(amp);
287 
288 	error = autofs_node_vn(child, mp, cnp->cn_lkflags, vpp);
289 	if (error != 0) {
290 		if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE)
291 			return (EJUSTRETURN);
292 
293 		return (error);
294 	}
295 
296 	return (0);
297 }
298 
299 static int
300 autofs_mkdir(struct vop_mkdir_args *ap)
301 {
302 	struct vnode *vp;
303 	struct autofs_node *anp;
304 	struct autofs_mount *amp;
305 	struct autofs_node *child;
306 	int error;
307 
308 	vp = ap->a_dvp;
309 	anp = vp->v_data;
310 	amp = VFSTOAUTOFS(vp->v_mount);
311 
312 	/*
313 	 * Do not allow mkdir() if the calling thread is not
314 	 * automountd(8) descendant.
315 	 */
316 	if (autofs_ignore_thread(curthread) == false)
317 		return (EPERM);
318 
319 	AUTOFS_XLOCK(amp);
320 	error = autofs_node_new(anp, amp, ap->a_cnp->cn_nameptr,
321 	    ap->a_cnp->cn_namelen, &child);
322 	if (error != 0) {
323 		AUTOFS_XUNLOCK(amp);
324 		return (error);
325 	}
326 	AUTOFS_XUNLOCK(amp);
327 
328 	error = autofs_node_vn(child, vp->v_mount, LK_EXCLUSIVE, ap->a_vpp);
329 
330 	return (error);
331 }
332 
333 static int
334 autofs_print(struct vop_print_args *ap)
335 {
336 	struct vnode *vp;
337 	struct autofs_node *anp;
338 
339 	vp = ap->a_vp;
340 	anp = vp->v_data;
341 
342 	printf("    name \"%s\", fileno %d, cached %d, wildcards %d\n",
343 	    anp->an_name, anp->an_fileno, anp->an_cached, anp->an_wildcards);
344 
345 	return (0);
346 }
347 
348 /*
349  * Write out a single 'struct dirent', based on 'name' and 'fileno' arguments.
350  */
351 static int
352 autofs_readdir_one(struct uio *uio, const char *name, int fileno,
353     size_t *reclenp)
354 {
355 	struct dirent dirent;
356 	size_t namlen, reclen;
357 	int error;
358 
359 	namlen = strlen(name);
360 	reclen = _GENERIC_DIRLEN(namlen);
361 	if (reclenp != NULL)
362 		*reclenp = reclen;
363 
364 	if (uio == NULL)
365 		return (0);
366 
367 	if (uio->uio_resid < reclen)
368 		return (EINVAL);
369 
370 	dirent.d_fileno = fileno;
371 	dirent.d_reclen = reclen;
372 	dirent.d_type = DT_DIR;
373 	dirent.d_namlen = namlen;
374 	memcpy(dirent.d_name, name, namlen);
375 	dirent_terminate(&dirent);
376 	error = uiomove(&dirent, reclen, uio);
377 
378 	return (error);
379 }
380 
381 static size_t
382 autofs_dirent_reclen(const char *name)
383 {
384 	size_t reclen;
385 
386 	(void)autofs_readdir_one(NULL, name, -1, &reclen);
387 
388 	return (reclen);
389 }
390 
391 static int
392 autofs_readdir(struct vop_readdir_args *ap)
393 {
394 	struct vnode *vp, *newvp;
395 	struct autofs_mount *amp;
396 	struct autofs_node *anp, *child;
397 	struct uio *uio;
398 	size_t reclen, reclens;
399 	ssize_t initial_resid;
400 	int error;
401 
402 	vp = ap->a_vp;
403 	amp = VFSTOAUTOFS(vp->v_mount);
404 	anp = vp->v_data;
405 	uio = ap->a_uio;
406 	initial_resid = ap->a_uio->uio_resid;
407 
408 	KASSERT(vp->v_type == VDIR, ("!VDIR"));
409 
410 	if (autofs_cached(anp, NULL, 0) == false &&
411 	    autofs_ignore_thread(curthread) == false) {
412 		error = autofs_trigger_vn(vp, "", 0, &newvp);
413 		if (error != 0)
414 			return (error);
415 
416 		if (newvp != NULL) {
417 			error = VOP_READDIR(newvp, ap->a_uio, ap->a_cred,
418 			    ap->a_eofflag, ap->a_ncookies, ap->a_cookies);
419 			vput(newvp);
420 			return (error);
421 		}
422 	}
423 
424 	if (uio->uio_offset < 0)
425 		return (EINVAL);
426 
427 	if (ap->a_eofflag != NULL)
428 		*ap->a_eofflag = FALSE;
429 
430 	/*
431 	 * Write out the directory entry for ".".  This is conditional
432 	 * on the current offset into the directory; same applies to the
433 	 * other two cases below.
434 	 */
435 	if (uio->uio_offset == 0) {
436 		error = autofs_readdir_one(uio, ".", anp->an_fileno, &reclen);
437 		if (error != 0)
438 			goto out;
439 	}
440 	reclens = autofs_dirent_reclen(".");
441 
442 	/*
443 	 * Write out the directory entry for "..".
444 	 */
445 	if (uio->uio_offset <= reclens) {
446 		if (uio->uio_offset != reclens)
447 			return (EINVAL);
448 		if (anp->an_parent == NULL) {
449 			error = autofs_readdir_one(uio, "..",
450 			    anp->an_fileno, &reclen);
451 		} else {
452 			error = autofs_readdir_one(uio, "..",
453 			    anp->an_parent->an_fileno, &reclen);
454 		}
455 		if (error != 0)
456 			goto out;
457 	}
458 
459 	reclens += autofs_dirent_reclen("..");
460 
461 	/*
462 	 * Write out the directory entries for subdirectories.
463 	 */
464 	AUTOFS_SLOCK(amp);
465 	RB_FOREACH(child, autofs_node_tree, &anp->an_children) {
466 		/*
467 		 * Check the offset to skip entries returned by previous
468 		 * calls to getdents().
469 		 */
470 		if (uio->uio_offset > reclens) {
471 			reclens += autofs_dirent_reclen(child->an_name);
472 			continue;
473 		}
474 
475 		/*
476 		 * Prevent seeking into the middle of dirent.
477 		 */
478 		if (uio->uio_offset != reclens) {
479 			AUTOFS_SUNLOCK(amp);
480 			return (EINVAL);
481 		}
482 
483 		error = autofs_readdir_one(uio, child->an_name,
484 		    child->an_fileno, &reclen);
485 		reclens += reclen;
486 		if (error != 0) {
487 			AUTOFS_SUNLOCK(amp);
488 			goto out;
489 		}
490 	}
491 	AUTOFS_SUNLOCK(amp);
492 
493 	if (ap->a_eofflag != NULL)
494 		*ap->a_eofflag = TRUE;
495 
496 	return (0);
497 
498 out:
499 	/*
500 	 * Return error if the initial buffer was too small to do anything.
501 	 */
502 	if (uio->uio_resid == initial_resid)
503 		return (error);
504 
505 	/*
506 	 * Don't return an error if we managed to copy out some entries.
507 	 */
508 	if (uio->uio_resid < reclen)
509 		return (0);
510 
511 	return (error);
512 }
513 
514 static int
515 autofs_reclaim(struct vop_reclaim_args *ap)
516 {
517 	struct vnode *vp;
518 	struct autofs_node *anp;
519 
520 	vp = ap->a_vp;
521 	anp = vp->v_data;
522 
523 	/*
524 	 * We do not free autofs_node here; instead we are
525 	 * destroying them in autofs_node_delete().
526 	 */
527 	sx_xlock(&anp->an_vnode_lock);
528 	anp->an_vnode = NULL;
529 	vp->v_data = NULL;
530 	sx_xunlock(&anp->an_vnode_lock);
531 
532 	return (0);
533 }
534 
535 struct vop_vector autofs_vnodeops = {
536 	.vop_default =		&default_vnodeops,
537 
538 	.vop_access =		autofs_access,
539 	.vop_lookup =		autofs_lookup,
540 	.vop_create =		VOP_EOPNOTSUPP,
541 	.vop_getattr =		autofs_getattr,
542 	.vop_link =		VOP_EOPNOTSUPP,
543 	.vop_mkdir =		autofs_mkdir,
544 	.vop_mknod =		VOP_EOPNOTSUPP,
545 	.vop_print =		autofs_print,
546 	.vop_read =		VOP_EOPNOTSUPP,
547 	.vop_readdir =		autofs_readdir,
548 	.vop_remove =		VOP_EOPNOTSUPP,
549 	.vop_rename =		VOP_EOPNOTSUPP,
550 	.vop_rmdir =		VOP_EOPNOTSUPP,
551 	.vop_setattr =		VOP_EOPNOTSUPP,
552 	.vop_symlink =		VOP_EOPNOTSUPP,
553 	.vop_write =		VOP_EOPNOTSUPP,
554 	.vop_reclaim =		autofs_reclaim,
555 };
556 VFS_VOP_VECTOR_REGISTER(autofs_vnodeops);
557 
558 int
559 autofs_node_new(struct autofs_node *parent, struct autofs_mount *amp,
560     const char *name, int namelen, struct autofs_node **anpp)
561 {
562 	struct autofs_node *anp;
563 
564 	if (parent != NULL) {
565 		AUTOFS_ASSERT_XLOCKED(parent->an_mount);
566 
567 		KASSERT(autofs_node_find(parent, name, namelen, NULL) == ENOENT,
568 		    ("node \"%s\" already exists", name));
569 	}
570 
571 	anp = uma_zalloc(autofs_node_zone, M_WAITOK | M_ZERO);
572 	if (namelen >= 0)
573 		anp->an_name = strndup(name, namelen, M_AUTOFS);
574 	else
575 		anp->an_name = strdup(name, M_AUTOFS);
576 	anp->an_fileno = atomic_fetchadd_int(&amp->am_last_fileno, 1);
577 	callout_init(&anp->an_callout, 1);
578 	/*
579 	 * The reason for SX_NOWITNESS here is that witness(4)
580 	 * cannot tell vnodes apart, so the following perfectly
581 	 * valid lock order...
582 	 *
583 	 * vnode lock A -> autofsvlk B -> vnode lock B
584 	 *
585 	 * ... gets reported as a LOR.
586 	 */
587 	sx_init_flags(&anp->an_vnode_lock, "autofsvlk", SX_NOWITNESS);
588 	getnanotime(&anp->an_ctime);
589 	anp->an_parent = parent;
590 	anp->an_mount = amp;
591 	if (parent != NULL)
592 		RB_INSERT(autofs_node_tree, &parent->an_children, anp);
593 	RB_INIT(&anp->an_children);
594 
595 	*anpp = anp;
596 	return (0);
597 }
598 
599 int
600 autofs_node_find(struct autofs_node *parent, const char *name,
601     int namelen, struct autofs_node **anpp)
602 {
603 	struct autofs_node *anp, find;
604 	int error;
605 
606 	AUTOFS_ASSERT_LOCKED(parent->an_mount);
607 
608 	if (namelen >= 0)
609 		find.an_name = strndup(name, namelen, M_AUTOFS);
610 	else
611 		find.an_name = strdup(name, M_AUTOFS);
612 
613 	anp = RB_FIND(autofs_node_tree, &parent->an_children, &find);
614 	if (anp != NULL) {
615 		error = 0;
616 		if (anpp != NULL)
617 			*anpp = anp;
618 	} else {
619 		error = ENOENT;
620 	}
621 
622 	free(find.an_name, M_AUTOFS);
623 
624 	return (error);
625 }
626 
627 void
628 autofs_node_delete(struct autofs_node *anp)
629 {
630 	struct autofs_node *parent;
631 
632 	AUTOFS_ASSERT_XLOCKED(anp->an_mount);
633 	KASSERT(RB_EMPTY(&anp->an_children), ("have children"));
634 
635 	callout_drain(&anp->an_callout);
636 
637 	parent = anp->an_parent;
638 	if (parent != NULL)
639 		RB_REMOVE(autofs_node_tree, &parent->an_children, anp);
640 	sx_destroy(&anp->an_vnode_lock);
641 	free(anp->an_name, M_AUTOFS);
642 	uma_zfree(autofs_node_zone, anp);
643 }
644 
645 int
646 autofs_node_vn(struct autofs_node *anp, struct mount *mp, int flags,
647     struct vnode **vpp)
648 {
649 	struct vnode *vp;
650 	int error;
651 
652 	AUTOFS_ASSERT_UNLOCKED(anp->an_mount);
653 
654 	sx_xlock(&anp->an_vnode_lock);
655 
656 	vp = anp->an_vnode;
657 	if (vp != NULL) {
658 		error = vget(vp, flags | LK_RETRY);
659 		if (error != 0) {
660 			AUTOFS_WARN("vget failed with error %d", error);
661 			sx_xunlock(&anp->an_vnode_lock);
662 			return (error);
663 		}
664 		if (VN_IS_DOOMED(vp)) {
665 			/*
666 			 * We got forcibly unmounted.
667 			 */
668 			AUTOFS_DEBUG("doomed vnode");
669 			sx_xunlock(&anp->an_vnode_lock);
670 			vput(vp);
671 
672 			return (ENOENT);
673 		}
674 
675 		*vpp = vp;
676 		sx_xunlock(&anp->an_vnode_lock);
677 		return (0);
678 	}
679 
680 	error = getnewvnode("autofs", mp, &autofs_vnodeops, &vp);
681 	if (error != 0) {
682 		sx_xunlock(&anp->an_vnode_lock);
683 		return (error);
684 	}
685 
686 	error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
687 	if (error != 0) {
688 		sx_xunlock(&anp->an_vnode_lock);
689 		vdrop(vp);
690 		return (error);
691 	}
692 
693 	vp->v_type = VDIR;
694 	if (anp->an_parent == NULL)
695 		vp->v_vflag |= VV_ROOT;
696 	vp->v_data = anp;
697 
698 	VN_LOCK_ASHARE(vp);
699 
700 	error = insmntque(vp, mp);
701 	if (error != 0) {
702 		AUTOFS_DEBUG("insmntque() failed with error %d", error);
703 		sx_xunlock(&anp->an_vnode_lock);
704 		return (error);
705 	}
706 
707 	KASSERT(anp->an_vnode == NULL, ("lost race"));
708 	anp->an_vnode = vp;
709 
710 	sx_xunlock(&anp->an_vnode_lock);
711 
712 	*vpp = vp;
713 	return (0);
714 }
715