2 * Copyright (c) 2016 The DragonFly Project
3 * Copyright (c) 2014 The FreeBSD Foundation
6 * This software was developed by Edward Tomasz Napierala under sponsorship
7 * from the FreeBSD Foundation.
9 * Redistribution and use in source and binary forms, with or without
10 * modification, are permitted provided that the following conditions
12 * 1. Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * 2. Redistributions in binary form must reproduce the above copyright
15 * notice, this list of conditions and the following disclaimer in the
16 * documentation and/or other materials provided with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
22 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 * Copyright (c) 1989, 1991, 1993, 1995
33 * The Regents of the University of California. All rights reserved.
35 * This code is derived from software contributed to Berkeley by
36 * Rick Macklem at The University of Guelph.
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
41 * 1. Redistributions of source code must retain the above copyright
42 * notice, this list of conditions and the following disclaimer.
43 * 2. Redistributions in binary form must reproduce the above copyright
44 * notice, this list of conditions and the following disclaimer in the
45 * documentation and/or other materials provided with the distribution.
46 * 3. Neither the name of the University nor the names of its contributors
47 * may be used to endorse or promote products derived from this software
48 * without specific prior written permission.
50 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
51 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
52 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
53 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
54 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
58 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
59 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
64 #include <sys/kernel.h>
65 #include <sys/module.h>
66 #include <sys/sysctl.h>
67 #include <sys/queue.h>
68 #include <sys/signalvar.h>
69 #include <sys/refcount.h>
70 #include <sys/kern_syscall.h>
73 #include "autofs_ioctl.h"
75 MALLOC_DEFINE(M_AUTOFS, "autofs", "Automounter filesystem");
77 struct objcache *autofs_request_objcache = NULL;
78 static struct objcache_malloc_args autofs_request_args = {
79 sizeof(struct autofs_request), M_AUTOFS,
82 struct objcache *autofs_node_objcache = NULL;
83 static struct objcache_malloc_args autofs_node_args = {
84 sizeof(struct autofs_node), M_AUTOFS,
87 static int autofs_open(struct dev_open_args *ap);
88 static int autofs_close(struct dev_close_args *ap);
89 static int autofs_ioctl(struct dev_ioctl_args *ap);
91 struct dev_ops autofs_ops = {
93 .d_open = autofs_open,
94 .d_close = autofs_close,
95 .d_ioctl = autofs_ioctl,
99 * List of signals that can interrupt an autofs trigger.
101 int autofs_sig_set[] = {
109 struct autofs_softc *autofs_softc = NULL;
111 SYSCTL_NODE(_vfs, OID_AUTO, autofs, CTLFLAG_RD, 0, "Automounter filesystem");
112 int autofs_debug = 1;
113 TUNABLE_INT("vfs.autofs.debug", &autofs_debug);
114 SYSCTL_INT(_vfs_autofs, OID_AUTO, debug, CTLFLAG_RW,
115 &autofs_debug, 1, "Enable debug messages");
116 int autofs_mount_on_stat = 0; /* XXX: Not supported on DragonFly */
117 TUNABLE_INT("vfs.autofs.mount_on_stat", &autofs_mount_on_stat);
118 SYSCTL_INT(_vfs_autofs, OID_AUTO, mount_on_stat, CTLFLAG_RW,
119 &autofs_mount_on_stat, 0, "Trigger mount on stat(2) on mountpoint "
120 "(not supported on DragonFly)");
121 static int autofs_timeout = 30;
122 TUNABLE_INT("vfs.autofs.timeout", &autofs_timeout);
123 SYSCTL_INT(_vfs_autofs, OID_AUTO, timeout, CTLFLAG_RW,
124 &autofs_timeout, 30, "Number of seconds to wait for automountd(8)");
125 static int autofs_cache = 600;
126 TUNABLE_INT("vfs.autofs.cache", &autofs_cache);
127 SYSCTL_INT(_vfs_autofs, OID_AUTO, cache, CTLFLAG_RW,
128 &autofs_cache, 600, "Number of seconds to wait before reinvoking "
129 "automountd(8) for any given file or directory");
130 static int autofs_retry_attempts = 3;
131 TUNABLE_INT("vfs.autofs.retry_attempts", &autofs_retry_attempts);
132 SYSCTL_INT(_vfs_autofs, OID_AUTO, retry_attempts, CTLFLAG_RW,
133 &autofs_retry_attempts, 3, "Number of attempts before failing mount");
134 static int autofs_retry_delay = 1;
135 TUNABLE_INT("vfs.autofs.retry_delay", &autofs_retry_delay);
136 SYSCTL_INT(_vfs_autofs, OID_AUTO, retry_delay, CTLFLAG_RW,
137 &autofs_retry_delay, 1, "Number of seconds before retrying");
138 static int autofs_interruptible = 1;
139 TUNABLE_INT("vfs.autofs.interruptible", &autofs_interruptible);
140 SYSCTL_INT(_vfs_autofs, OID_AUTO, interruptible, CTLFLAG_RW,
141 &autofs_interruptible, 1, "Allow requests to be interrupted by signal");
143 static __inline pid_t
144 proc_pgid(const struct proc *p)
146 return (p->p_pgrp->pg_id);
150 autofs_node_cmp(const struct autofs_node *a, const struct autofs_node *b)
152 return (strcmp(a->an_name, b->an_name));
155 RB_GENERATE(autofs_node_tree, autofs_node, an_link, autofs_node_cmp);
158 autofs_request_objcache_ctor(void *obj, void *privdata, int ocflags)
160 struct autofs_request *ar = obj;
162 memset(ar, 0, sizeof(*ar));
167 autofs_node_objcache_ctor(void *obj, void *privdata, int ocflags)
169 struct autofs_node *an = obj;
171 memset(an, 0, sizeof(*an));
176 autofs_init(struct vfsconf *vfsp)
178 KASSERT(autofs_softc == NULL,
179 ("softc %p, should be NULL", autofs_softc));
181 autofs_softc = kmalloc(sizeof(*autofs_softc), M_AUTOFS,
184 autofs_request_objcache = objcache_create("autofs_request", 0, 0,
185 autofs_request_objcache_ctor, NULL, NULL,
186 objcache_malloc_alloc,
187 objcache_malloc_free,
188 &autofs_request_args);
190 autofs_node_objcache = objcache_create("autofs_node", 0, 0,
191 autofs_node_objcache_ctor, NULL, NULL,
192 objcache_malloc_alloc,
193 objcache_malloc_free,
196 TAILQ_INIT(&autofs_softc->sc_requests);
197 cv_init(&autofs_softc->sc_cv, "autofscv");
198 lockinit(&autofs_softc->sc_lock, "autofssclk", 0, 0);
199 autofs_softc->sc_dev_opened = false;
201 autofs_softc->sc_cdev = make_dev(&autofs_ops, 0, UID_ROOT,
202 GID_OPERATOR, 0640, "autofs");
203 if (autofs_softc->sc_cdev == NULL) {
204 AUTOFS_WARN("failed to create device node");
205 objcache_destroy(autofs_request_objcache);
206 objcache_destroy(autofs_node_objcache);
207 kfree(autofs_softc, M_AUTOFS);
211 autofs_softc->sc_cdev->si_drv1 = autofs_softc;
217 autofs_uninit(struct vfsconf *vfsp)
219 lockmgr(&autofs_softc->sc_lock, LK_EXCLUSIVE);
220 if (autofs_softc->sc_dev_opened) {
221 lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
225 if (autofs_softc->sc_cdev != NULL)
226 destroy_dev(autofs_softc->sc_cdev);
228 objcache_destroy(autofs_request_objcache);
229 objcache_destroy(autofs_node_objcache);
231 lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
233 kfree(autofs_softc, M_AUTOFS); /* race with open */
240 autofs_ignore_thread(void)
242 struct proc *curp = curproc;
244 if (autofs_softc->sc_dev_opened == false)
247 lwkt_gettoken(&curp->p_token);
248 if (autofs_softc->sc_dev_sid == proc_pgid(curp)) {
249 lwkt_reltoken(&curp->p_token);
252 lwkt_reltoken(&curp->p_token);
258 autofs_path(struct autofs_node *anp)
260 struct autofs_mount *amp = anp->an_mount;
263 path = kstrdup("", M_AUTOFS);
264 for (; anp->an_parent != NULL; anp = anp->an_parent) {
265 tmp = kmalloc(strlen(anp->an_name) + strlen(path) + 2,
267 strcpy(tmp, anp->an_name);
270 kfree(path, M_AUTOFS);
274 tmp = kmalloc(strlen(amp->am_on) + strlen(path) + 2,
276 strcpy(tmp, amp->am_on);
279 kfree(path, M_AUTOFS);
286 autofs_task(void *context, int pending)
288 struct autofs_request *ar = context;
290 lockmgr(&autofs_softc->sc_lock, LK_EXCLUSIVE);
291 AUTOFS_WARN("request %d for %s timed out after %d seconds",
292 ar->ar_id, ar->ar_path, autofs_timeout);
294 ar->ar_error = ETIMEDOUT;
295 ar->ar_wildcards = true;
297 ar->ar_in_progress = false;
298 cv_broadcast(&autofs_softc->sc_cv);
299 lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
303 autofs_cached(struct autofs_node *anp, const char *component, int componentlen)
305 struct autofs_mount *amp = anp->an_mount;
308 KKASSERT(mtx_notlocked(&->am_lock));
311 * For root node we need to request automountd(8) assistance even
312 * if the node is marked as cached, but the requested top-level
313 * directory does not exist. This is necessary for wildcard indirect
314 * map keys to work. We don't do this if we know that there are
317 if (anp->an_parent == NULL && componentlen != 0 && anp->an_wildcards) {
318 KKASSERT(amp->am_root == anp);
319 mtx_lock_sh_quick(&->am_lock);
320 error = autofs_node_find(anp, component, componentlen, NULL);
321 mtx_unlock_sh(&->am_lock);
326 return (anp->an_cached);
330 autofs_cache_callout(void *context)
332 struct autofs_node *anp = context;
334 autofs_node_uncache(anp);
338 autofs_flush(struct autofs_mount *amp)
340 struct autofs_node *anp = amp->am_root;
341 struct autofs_node *child;
343 mtx_lock_ex_quick(&->am_lock);
344 RB_FOREACH(child, autofs_node_tree, &anp->an_children) {
345 autofs_node_uncache(child);
347 autofs_node_uncache(amp->am_root);
348 mtx_unlock_ex(&->am_lock);
350 AUTOFS_DEBUG("%s flushed", amp->am_on);
354 * The set/restore sigmask functions are used to (temporarily) overwrite
355 * the thread sigmask during triggering.
358 autofs_set_sigmask(sigset_t *oldset)
360 struct lwp *lp = curthread->td_lwp;
365 /* Remove the autofs set of signals from newset */
366 lwkt_gettoken(&lp->lwp_token);
367 for (i = 0; i < nitems(autofs_sig_set); i++) {
369 * But make sure we leave the ones already masked
370 * by the process, i.e. remove the signal from the
371 * temporary signalmask only if it wasn't already
374 if (!SIGISMEMBER(lp->lwp_sigmask, autofs_sig_set[i]) &&
375 !SIGISMEMBER(lp->lwp_proc->p_sigacts->ps_sigignore,
376 autofs_sig_set[i])) {
377 SIGDELSET(newset, autofs_sig_set[i]);
380 kern_sigprocmask(SIG_SETMASK, &newset, oldset);
381 lwkt_reltoken(&lp->lwp_token);
385 autofs_restore_sigmask(sigset_t *set)
387 kern_sigprocmask(SIG_SETMASK, set, NULL);
391 autofs_trigger_one(struct autofs_node *anp,
392 const char *component, int componentlen)
394 #define _taskqueue_thread (taskqueue_thread[mycpuid])
395 struct autofs_mount *amp = anp->an_mount;
396 struct autofs_node *firstanp;
397 struct autofs_request *ar;
400 int error = 0, request_error, last;
403 KKASSERT(lockstatus(&autofs_softc->sc_lock, curthread) == LK_EXCLUSIVE);
405 if (anp->an_parent == NULL) {
406 key = kstrndup(component, componentlen, M_AUTOFS);
408 for (firstanp = anp; firstanp->an_parent->an_parent != NULL;
409 firstanp = firstanp->an_parent)
411 key = kstrdup(firstanp->an_name, M_AUTOFS);
414 path = autofs_path(anp);
416 TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) {
417 if (strcmp(ar->ar_path, path))
419 if (strcmp(ar->ar_key, key))
422 KASSERT(strcmp(ar->ar_from, amp->am_from) == 0,
423 ("from changed; %s != %s", ar->ar_from, amp->am_from));
424 KASSERT(strcmp(ar->ar_prefix, amp->am_prefix) == 0,
425 ("prefix changed; %s != %s",
426 ar->ar_prefix, amp->am_prefix));
427 KASSERT(strcmp(ar->ar_options, amp->am_options) == 0,
428 ("options changed; %s != %s",
429 ar->ar_options, amp->am_options));
434 refcount_acquire(&ar->ar_refcount);
436 ar = objcache_get(autofs_request_objcache, M_WAITOK);
438 ar->ar_id = autofs_softc->sc_last_request_id++;
441 ar->ar_wildcards = false;
442 ar->ar_in_progress = false;
443 strlcpy(ar->ar_from, amp->am_from, sizeof(ar->ar_from));
444 strlcpy(ar->ar_path, path, sizeof(ar->ar_path));
445 strlcpy(ar->ar_prefix, amp->am_prefix, sizeof(ar->ar_prefix));
446 strlcpy(ar->ar_key, key, sizeof(ar->ar_key));
447 strlcpy(ar->ar_options,
448 amp->am_options, sizeof(ar->ar_options));
449 TIMEOUT_TASK_INIT(_taskqueue_thread, &ar->ar_task, 0,
451 taskqueue_enqueue_timeout(_taskqueue_thread, &ar->ar_task,
452 autofs_timeout * hz);
453 refcount_init(&ar->ar_refcount, 1);
454 TAILQ_INSERT_TAIL(&autofs_softc->sc_requests, ar, ar_next);
457 cv_broadcast(&autofs_softc->sc_cv);
458 while (ar->ar_done == false) {
459 if (autofs_interruptible) {
460 autofs_set_sigmask(&oldset);
461 error = cv_wait_sig(&autofs_softc->sc_cv,
462 &autofs_softc->sc_lock);
463 autofs_restore_sigmask(&oldset);
465 AUTOFS_WARN("cv_wait_sig for %s failed "
466 "with error %d", ar->ar_path, error);
470 cv_wait(&autofs_softc->sc_cv, &autofs_softc->sc_lock);
474 request_error = ar->ar_error;
476 AUTOFS_WARN("request for %s completed with error %d",
477 ar->ar_path, request_error);
479 wildcards = ar->ar_wildcards;
481 last = refcount_release(&ar->ar_refcount);
483 TAILQ_REMOVE(&autofs_softc->sc_requests, ar, ar_next);
484 lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
485 taskqueue_cancel_timeout(_taskqueue_thread, &ar->ar_task, NULL);
486 taskqueue_drain_timeout(_taskqueue_thread, &ar->ar_task);
487 objcache_put(autofs_request_objcache, ar);
488 lockmgr(&autofs_softc->sc_lock, LK_EXCLUSIVE);
492 * Note that we do not do negative caching on purpose. This
493 * way the user can retry access at any time, e.g. after fixing
494 * the failure reason, without waiting for cache timer to expire.
496 if (error == 0 && request_error == 0 && autofs_cache > 0) {
497 autofs_node_cache(anp);
498 anp->an_wildcards = wildcards;
499 callout_reset(&anp->an_callout, autofs_cache * hz,
500 autofs_cache_callout, anp);
503 kfree(key, M_AUTOFS);
504 kfree(path, M_AUTOFS);
508 return (request_error);
512 autofs_trigger(struct autofs_node *anp,
513 const char *component, int componentlen)
518 error = autofs_trigger_one(anp, component, componentlen);
523 if (error == EINTR || error == ERESTART) {
524 AUTOFS_DEBUG("trigger interrupted by signal, "
530 if (anp->an_retries >= autofs_retry_attempts) {
531 AUTOFS_DEBUG("trigger failed %d times; returning "
532 "error %d", anp->an_retries, error);
537 AUTOFS_DEBUG("trigger failed with error %d; will retry in "
538 "%d seconds, %d attempts left", error, autofs_retry_delay,
539 autofs_retry_attempts - anp->an_retries);
540 lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
541 tsleep(&dummy, 0, "autofs_retry", autofs_retry_delay * hz);
542 lockmgr(&autofs_softc->sc_lock, LK_EXCLUSIVE);
547 autofs_ioctl_request(struct autofs_daemon_request *adr)
549 struct proc *curp = curproc;
550 struct autofs_request *ar;
553 lockmgr(&autofs_softc->sc_lock, LK_EXCLUSIVE);
555 TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) {
558 if (ar->ar_in_progress)
566 error = cv_wait_sig(&autofs_softc->sc_cv,
567 &autofs_softc->sc_lock);
569 lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
574 ar->ar_in_progress = true;
576 adr->adr_id = ar->ar_id;
577 strlcpy(adr->adr_from, ar->ar_from, sizeof(adr->adr_from));
578 strlcpy(adr->adr_path, ar->ar_path, sizeof(adr->adr_path));
579 strlcpy(adr->adr_prefix, ar->ar_prefix, sizeof(adr->adr_prefix));
580 strlcpy(adr->adr_key, ar->ar_key, sizeof(adr->adr_key));
581 strlcpy(adr->adr_options, ar->ar_options, sizeof(adr->adr_options));
583 lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
585 lwkt_gettoken(&curp->p_token);
586 autofs_softc->sc_dev_sid = proc_pgid(curp);
587 lwkt_reltoken(&curp->p_token);
593 autofs_ioctl_done(struct autofs_daemon_done *add)
595 struct autofs_request *ar;
597 lockmgr(&autofs_softc->sc_lock, LK_EXCLUSIVE);
598 TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) {
599 if (ar->ar_id == add->add_id)
604 lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
605 AUTOFS_DEBUG("id %d not found", add->add_id);
609 ar->ar_error = add->add_error;
610 ar->ar_wildcards = add->add_wildcards;
612 ar->ar_in_progress = false;
613 cv_broadcast(&autofs_softc->sc_cv);
615 lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
621 autofs_open(struct dev_open_args *ap)
623 lockmgr(&autofs_softc->sc_lock, LK_EXCLUSIVE);
625 * We must never block automountd(8) and its descendants, and we use
626 * session ID to determine that: we store session id of the process
627 * that opened the device, and then compare it with session ids
628 * of triggering processes. This means running a second automountd(8)
629 * instance would break the previous one. The check below prevents
632 if (autofs_softc->sc_dev_opened) {
633 lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
637 autofs_softc->sc_dev_opened = true;
638 lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
644 autofs_close(struct dev_close_args *ap)
646 lockmgr(&autofs_softc->sc_lock, LK_EXCLUSIVE);
647 KASSERT(autofs_softc->sc_dev_opened, ("not opened?"));
648 autofs_softc->sc_dev_opened = false;
649 lockmgr(&autofs_softc->sc_lock, LK_RELEASE);
655 autofs_ioctl(struct dev_ioctl_args *ap)
657 u_long cmd = ap->a_cmd;
658 void *arg = ap->a_data;
660 KASSERT(autofs_softc->sc_dev_opened, ("not opened?"));
664 return (autofs_ioctl_request(
665 (struct autofs_daemon_request *)arg));
667 return (autofs_ioctl_done(
668 (struct autofs_daemon_done *)arg));
670 AUTOFS_DEBUG("invalid cmd %lx", cmd);