2 * Copyright (c) 2014 The FreeBSD Foundation
5 * This software was developed by Edward Tomasz Napierala under sponsorship
6 * from the FreeBSD Foundation.
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
34 #include <sys/param.h>
35 #include <sys/kernel.h>
36 #include <sys/condvar.h>
37 #include <sys/dirent.h>
38 #include <sys/fcntl.h>
40 #include <sys/mount.h>
41 #include <sys/mutex.h>
42 #include <sys/namei.h>
43 #include <sys/signalvar.h>
45 #include <sys/systm.h>
46 #include <sys/taskqueue.h>
48 #include <sys/vnode.h>
49 #include <machine/atomic.h>
52 #include <fs/autofs/autofs.h>
54 static int autofs_trigger_vn(struct vnode *vp, const char *path,
55 int pathlen, struct vnode **newvp);
57 extern struct autofs_softc *autofs_softc;
60 autofs_access(struct vop_access_args *ap)
64 * Nothing to do here; the only kind of access control
65 * needed is in autofs_mkdir().
72 autofs_getattr(struct vop_getattr_args *ap)
74 struct vnode *vp, *newvp;
75 struct autofs_node *anp;
85 KASSERT(ap->a_vp->v_type == VDIR, ("!VDIR"));
88 * The reason we must do this is that some tree-walking software,
89 * namely fts(3), assumes that stat(".") results will not change
90 * between chdir("subdir") and chdir(".."), and fails with ENOENT
93 if (autofs_mount_on_stat && autofs_cached(anp, NULL, 0) == false &&
94 autofs_ignore_thread(curthread) == false) {
95 error = autofs_trigger_vn(vp, "", 0, &newvp);
100 error = VOP_GETATTR(newvp, ap->a_vap,
109 vap->va_nlink = 3; /* XXX */
112 vap->va_rdev = NODEV;
113 vap->va_fsid = mp->mnt_stat.f_fsid.val[0];
114 vap->va_fileid = anp->an_fileno;
115 vap->va_size = S_BLKSIZE;
116 vap->va_blocksize = S_BLKSIZE;
117 vap->va_mtime = anp->an_ctime;
118 vap->va_atime = anp->an_ctime;
119 vap->va_ctime = anp->an_ctime;
120 vap->va_birthtime = anp->an_ctime;
124 vap->va_bytes = S_BLKSIZE;
132 * Unlock the vnode, request automountd(8) action, and then lock it back.
133 * If anything got mounted on top of the vnode, return the new filesystem's
134 * root vnode in 'newvp', locked.
137 autofs_trigger_vn(struct vnode *vp, const char *path, int pathlen,
138 struct vnode **newvp)
140 struct autofs_node *anp;
141 struct autofs_mount *amp;
142 int error, lock_flags;
145 amp = VFSTOAUTOFS(vp->v_mount);
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.
153 lock_flags = VOP_ISLOCKED(vp);
157 sx_xlock(&autofs_softc->sc_lock);
160 * XXX: Workaround for mounting the same thing multiple times; revisit.
162 if (vp->v_mountedhere != NULL) {
167 error = autofs_trigger(anp, path, pathlen);
169 sx_xunlock(&autofs_softc->sc_lock);
170 vn_lock(vp, lock_flags | LK_RETRY);
172 if ((vp->v_iflag & VI_DOOMED) != 0) {
173 AUTOFS_DEBUG("VI_DOOMED");
180 if (vp->v_mountedhere == NULL) {
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
190 anp->an_cached = false;
193 error = VFS_ROOT(vp->v_mountedhere, lock_flags, newvp);
195 AUTOFS_WARN("VFS_ROOT() failed with error %d", error);
203 autofs_vget_callback(struct mount *mp, void *arg, int flags,
208 return (autofs_node_vn(arg, mp, flags, vpp));
212 autofs_lookup(struct vop_lookup_args *ap)
214 struct vnode *dvp, *newvp, **vpp;
216 struct autofs_mount *amp;
217 struct autofs_node *anp, *child;
218 struct componentname *cnp;
224 amp = VFSTOAUTOFS(mp);
228 if (cnp->cn_flags & ISDOTDOT) {
229 KASSERT(anp->an_parent != NULL, ("NULL parent"));
231 * Note that in this case, dvp is the child vnode, and we
232 * are looking up the parent vnode - exactly reverse from
233 * normal operation. Unlocking dvp requires some rather
234 * tricky unlock/relock dance to prevent mp from being freed;
235 * use vn_vget_ino_gen() which takes care of all that.
237 error = vn_vget_ino_gen(dvp, autofs_vget_callback,
238 anp->an_parent, cnp->cn_lkflags, vpp);
240 AUTOFS_WARN("vn_vget_ino_gen() failed with error %d",
247 if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') {
254 if (autofs_cached(anp, cnp->cn_nameptr, cnp->cn_namelen) == false &&
255 autofs_ignore_thread(cnp->cn_thread) == false) {
256 error = autofs_trigger_vn(dvp,
257 cnp->cn_nameptr, cnp->cn_namelen, &newvp);
263 * The target filesystem got automounted.
264 * Let the lookup(9) go around with the same
273 error = autofs_node_find(anp, cnp->cn_nameptr, cnp->cn_namelen, &child);
275 if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE) {
277 return (EJUSTRETURN);
285 * XXX: Dropping the node here is ok, because we never remove nodes.
289 error = autofs_node_vn(child, mp, cnp->cn_lkflags, vpp);
291 if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE)
292 return (EJUSTRETURN);
301 autofs_mkdir(struct vop_mkdir_args *ap)
304 struct autofs_node *anp;
305 struct autofs_mount *amp;
306 struct autofs_node *child;
311 amp = VFSTOAUTOFS(vp->v_mount);
314 * Do not allow mkdir() if the calling thread is not
315 * automountd(8) descendant.
317 if (autofs_ignore_thread(curthread) == false)
321 error = autofs_node_new(anp, amp, ap->a_cnp->cn_nameptr,
322 ap->a_cnp->cn_namelen, &child);
329 error = autofs_node_vn(child, vp->v_mount, LK_EXCLUSIVE, ap->a_vpp);
335 * Write out a single 'struct dirent', based on 'name' and 'fileno' arguments.
338 autofs_readdir_one(struct uio *uio, const char *name, int fileno,
341 struct dirent dirent;
342 size_t namlen, padded_namlen, reclen;
345 namlen = strlen(name);
346 padded_namlen = roundup2(namlen + 1, __alignof(struct dirent));
347 KASSERT(padded_namlen <= MAXNAMLEN, ("%zd > MAXNAMLEN", padded_namlen));
348 reclen = offsetof(struct dirent, d_name) + padded_namlen;
356 if (uio->uio_resid < reclen)
359 dirent.d_fileno = fileno;
360 dirent.d_reclen = reclen;
361 dirent.d_type = DT_DIR;
362 dirent.d_namlen = namlen;
363 memcpy(dirent.d_name, name, namlen);
364 memset(dirent.d_name + namlen, 0, padded_namlen - namlen);
365 error = uiomove(&dirent, reclen, uio);
371 autofs_dirent_reclen(const char *name)
375 (void)autofs_readdir_one(NULL, name, -1, &reclen);
381 autofs_readdir(struct vop_readdir_args *ap)
383 struct vnode *vp, *newvp;
384 struct autofs_mount *amp;
385 struct autofs_node *anp, *child;
387 size_t reclen, reclens;
388 ssize_t initial_resid;
392 amp = VFSTOAUTOFS(vp->v_mount);
395 initial_resid = ap->a_uio->uio_resid;
397 KASSERT(vp->v_type == VDIR, ("!VDIR"));
399 if (autofs_cached(anp, NULL, 0) == false &&
400 autofs_ignore_thread(curthread) == false) {
401 error = autofs_trigger_vn(vp, "", 0, &newvp);
406 error = VOP_READDIR(newvp, ap->a_uio, ap->a_cred,
407 ap->a_eofflag, ap->a_ncookies, ap->a_cookies);
413 if (uio->uio_offset < 0)
416 if (ap->a_eofflag != NULL)
417 *ap->a_eofflag = FALSE;
420 * Write out the directory entry for ".". This is conditional
421 * on the current offset into the directory; same applies to the
422 * other two cases below.
424 if (uio->uio_offset == 0) {
425 error = autofs_readdir_one(uio, ".", anp->an_fileno, &reclen);
429 reclens = autofs_dirent_reclen(".");
432 * Write out the directory entry for "..".
434 if (uio->uio_offset <= reclens) {
435 if (uio->uio_offset != reclens)
437 if (anp->an_parent == NULL) {
438 error = autofs_readdir_one(uio, "..",
439 anp->an_fileno, &reclen);
441 error = autofs_readdir_one(uio, "..",
442 anp->an_parent->an_fileno, &reclen);
448 reclens += autofs_dirent_reclen("..");
451 * Write out the directory entries for subdirectories.
454 RB_FOREACH(child, autofs_node_tree, &anp->an_children) {
456 * Check the offset to skip entries returned by previous
457 * calls to getdents().
459 if (uio->uio_offset > reclens) {
460 reclens += autofs_dirent_reclen(child->an_name);
465 * Prevent seeking into the middle of dirent.
467 if (uio->uio_offset != reclens) {
472 error = autofs_readdir_one(uio, child->an_name,
473 child->an_fileno, &reclen);
482 if (ap->a_eofflag != NULL)
483 *ap->a_eofflag = TRUE;
489 * Return error if the initial buffer was too small to do anything.
491 if (uio->uio_resid == initial_resid)
495 * Don't return an error if we managed to copy out some entries.
497 if (uio->uio_resid < reclen)
504 autofs_reclaim(struct vop_reclaim_args *ap)
507 struct autofs_node *anp;
513 * We do not free autofs_node here; instead we are
514 * destroying them in autofs_node_delete().
516 sx_xlock(&anp->an_vnode_lock);
517 anp->an_vnode = NULL;
519 sx_xunlock(&anp->an_vnode_lock);
524 struct vop_vector autofs_vnodeops = {
525 .vop_default = &default_vnodeops,
527 .vop_access = autofs_access,
528 .vop_lookup = autofs_lookup,
529 .vop_create = VOP_EOPNOTSUPP,
530 .vop_getattr = autofs_getattr,
531 .vop_link = VOP_EOPNOTSUPP,
532 .vop_mkdir = autofs_mkdir,
533 .vop_mknod = VOP_EOPNOTSUPP,
534 .vop_read = VOP_EOPNOTSUPP,
535 .vop_readdir = autofs_readdir,
536 .vop_remove = VOP_EOPNOTSUPP,
537 .vop_rename = VOP_EOPNOTSUPP,
538 .vop_rmdir = VOP_EOPNOTSUPP,
539 .vop_setattr = VOP_EOPNOTSUPP,
540 .vop_symlink = VOP_EOPNOTSUPP,
541 .vop_write = VOP_EOPNOTSUPP,
542 .vop_reclaim = autofs_reclaim,
546 autofs_node_new(struct autofs_node *parent, struct autofs_mount *amp,
547 const char *name, int namelen, struct autofs_node **anpp)
549 struct autofs_node *anp;
551 if (parent != NULL) {
552 AUTOFS_ASSERT_XLOCKED(parent->an_mount);
554 KASSERT(autofs_node_find(parent, name, namelen, NULL) == ENOENT,
555 ("node \"%s\" already exists", name));
558 anp = uma_zalloc(autofs_node_zone, M_WAITOK | M_ZERO);
560 anp->an_name = strndup(name, namelen, M_AUTOFS);
562 anp->an_name = strdup(name, M_AUTOFS);
563 anp->an_fileno = atomic_fetchadd_int(&->am_last_fileno, 1);
564 callout_init(&anp->an_callout, 1);
566 * The reason for SX_NOWITNESS here is that witness(4)
567 * cannot tell vnodes apart, so the following perfectly
568 * valid lock order...
570 * vnode lock A -> autofsvlk B -> vnode lock B
572 * ... gets reported as a LOR.
574 sx_init_flags(&anp->an_vnode_lock, "autofsvlk", SX_NOWITNESS);
575 getnanotime(&anp->an_ctime);
576 anp->an_parent = parent;
579 RB_INSERT(autofs_node_tree, &parent->an_children, anp);
580 RB_INIT(&anp->an_children);
587 autofs_node_find(struct autofs_node *parent, const char *name,
588 int namelen, struct autofs_node **anpp)
590 struct autofs_node *anp, find;
593 AUTOFS_ASSERT_LOCKED(parent->an_mount);
596 find.an_name = strndup(name, namelen, M_AUTOFS);
598 find.an_name = strdup(name, M_AUTOFS);
600 anp = RB_FIND(autofs_node_tree, &parent->an_children, &find);
609 free(find.an_name, M_AUTOFS);
615 autofs_node_delete(struct autofs_node *anp)
617 struct autofs_node *parent;
619 AUTOFS_ASSERT_XLOCKED(anp->an_mount);
620 KASSERT(RB_EMPTY(&anp->an_children), ("have children"));
622 callout_drain(&anp->an_callout);
624 parent = anp->an_parent;
626 RB_REMOVE(autofs_node_tree, &parent->an_children, anp);
627 sx_destroy(&anp->an_vnode_lock);
628 free(anp->an_name, M_AUTOFS);
629 uma_zfree(autofs_node_zone, anp);
633 autofs_node_vn(struct autofs_node *anp, struct mount *mp, int flags,
639 AUTOFS_ASSERT_UNLOCKED(anp->an_mount);
641 sx_xlock(&anp->an_vnode_lock);
645 error = vget(vp, flags | LK_RETRY, curthread);
647 AUTOFS_WARN("vget failed with error %d", error);
648 sx_xunlock(&anp->an_vnode_lock);
651 if (vp->v_iflag & VI_DOOMED) {
653 * We got forcibly unmounted.
655 AUTOFS_DEBUG("doomed vnode");
656 sx_xunlock(&anp->an_vnode_lock);
663 sx_xunlock(&anp->an_vnode_lock);
667 error = getnewvnode("autofs", mp, &autofs_vnodeops, &vp);
669 sx_xunlock(&anp->an_vnode_lock);
673 error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
675 sx_xunlock(&anp->an_vnode_lock);
681 if (anp->an_parent == NULL)
682 vp->v_vflag |= VV_ROOT;
687 error = insmntque(vp, mp);
689 AUTOFS_DEBUG("insmntque() failed with error %d", error);
690 sx_xunlock(&anp->an_vnode_lock);
694 KASSERT(anp->an_vnode == NULL, ("lost race"));
697 sx_xunlock(&anp->an_vnode_lock);