autofs.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * Copyright (c) 2014 The FreeBSD Foundation
    3  * All rights reserved.
    4  *
    5  * This software was developed by Edward Tomasz Napierala under sponsorship
    6  * from the FreeBSD Foundation.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   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.
   16  *
   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
   27  * SUCH DAMAGE.
   28  *
   29  */
   30 /*-
   31  * Copyright (c) 1989, 1991, 1993, 1995
   32  *      The Regents of the University of California.  All rights reserved.
   33  *
   34  * This code is derived from software contributed to Berkeley by
   35  * Rick Macklem at The University of Guelph.
   36  *
   37  * Redistribution and use in source and binary forms, with or without
   38  * modification, are permitted provided that the following conditions
   39  * are met:
   40  * 1. Redistributions of source code must retain the above copyright
   41  *    notice, this list of conditions and the following disclaimer.
   42  * 2. Redistributions in binary form must reproduce the above copyright
   43  *    notice, this list of conditions and the following disclaimer in the
   44  *    documentation and/or other materials provided with the distribution.
   45  * 4. Neither the name of the University nor the names of its contributors
   46  *    may be used to endorse or promote products derived from this software
   47  *    without specific prior written permission.
   48  *
   49  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   50  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   51  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   52  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   53  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   54  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   55  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   56  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   57  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   58  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   59  * SUCH DAMAGE.
   60  *
   61  */
   62 
   63 #include <sys/cdefs.h>
   64 __FBSDID("$FreeBSD$");
   65 
   66 #include <sys/param.h>
   67 #include <sys/systm.h>
   68 #include <sys/buf.h>
   69 #include <sys/conf.h>
   70 #include <sys/dirent.h>
   71 #include <sys/ioccom.h>
   72 #include <sys/kernel.h>
   73 #include <sys/module.h>
   74 #include <sys/mount.h>
   75 #include <sys/refcount.h>
   76 #include <sys/sx.h>
   77 #include <sys/sysctl.h>
   78 #include <sys/syscallsubr.h>
   79 #include <sys/taskqueue.h>
   80 #include <sys/tree.h>
   81 #include <sys/vnode.h>
   82 #include <machine/atomic.h>
   83 #include <vm/uma.h>
   84 
   85 #include <fs/autofs/autofs.h>
   86 #include <fs/autofs/autofs_ioctl.h>
   87 
   88 MALLOC_DEFINE(M_AUTOFS, "autofs", "Automounter filesystem");
   89 
   90 uma_zone_t autofs_request_zone;
   91 uma_zone_t autofs_node_zone;
   92 
   93 static int      autofs_open(struct cdev *dev, int flags, int fmt,
   94                     struct thread *td);
   95 static int      autofs_close(struct cdev *dev, int flag, int fmt,
   96                     struct thread *td);
   97 static int      autofs_ioctl(struct cdev *dev, u_long cmd, caddr_t arg,
   98                     int mode, struct thread *td);
   99 
  100 static struct cdevsw autofs_cdevsw = {
  101      .d_version = D_VERSION,
  102      .d_open   = autofs_open,
  103      .d_close   = autofs_close,
  104      .d_ioctl   = autofs_ioctl,
  105      .d_name    = "autofs",
  106 };
  107 
  108 /*
  109  * List of signals that can interrupt an autofs trigger.  Might be a good
  110  * idea to keep it synchronised with list in sys/fs/nfs/nfs_commonkrpc.c.
  111  */
  112 int autofs_sig_set[] = {
  113         SIGINT,
  114         SIGTERM,
  115         SIGHUP,
  116         SIGKILL,
  117         SIGQUIT
  118 };
  119 
  120 struct autofs_softc     *autofs_softc;
  121 
  122 SYSCTL_NODE(_vfs, OID_AUTO, autofs, CTLFLAG_RD, 0, "Automounter filesystem");
  123 int autofs_debug = 1;
  124 TUNABLE_INT("vfs.autofs.debug", &autofs_debug);
  125 SYSCTL_INT(_vfs_autofs, OID_AUTO, debug, CTLFLAG_RWTUN,
  126     &autofs_debug, 1, "Enable debug messages");
  127 int autofs_mount_on_stat = 0;
  128 TUNABLE_INT("vfs.autofs.mount_on_stat", &autofs_mount_on_stat);
  129 SYSCTL_INT(_vfs_autofs, OID_AUTO, mount_on_stat, CTLFLAG_RWTUN,
  130     &autofs_mount_on_stat, 0, "Trigger mount on stat(2) on mountpoint");
  131 int autofs_timeout = 30;
  132 TUNABLE_INT("vfs.autofs.timeout", &autofs_timeout);
  133 SYSCTL_INT(_vfs_autofs, OID_AUTO, timeout, CTLFLAG_RWTUN,
  134     &autofs_timeout, 30, "Number of seconds to wait for automountd(8)");
  135 int autofs_cache = 600;
  136 TUNABLE_INT("vfs.autofs.cache", &autofs_cache);
  137 SYSCTL_INT(_vfs_autofs, OID_AUTO, cache, CTLFLAG_RWTUN,
  138     &autofs_cache, 600, "Number of seconds to wait before reinvoking "
  139     "automountd(8) for any given file or directory");
  140 int autofs_retry_attempts = 3;
  141 TUNABLE_INT("vfs.autofs.retry_attempts", &autofs_retry_attempts);
  142 SYSCTL_INT(_vfs_autofs, OID_AUTO, retry_attempts, CTLFLAG_RWTUN,
  143     &autofs_retry_attempts, 3, "Number of attempts before failing mount");
  144 int autofs_retry_delay = 1;
  145 TUNABLE_INT("vfs.autofs.retry_delay", &autofs_retry_delay);
  146 SYSCTL_INT(_vfs_autofs, OID_AUTO, retry_delay, CTLFLAG_RWTUN,
  147     &autofs_retry_delay, 1, "Number of seconds before retrying");
  148 int autofs_interruptible = 1;
  149 TUNABLE_INT("vfs.autofs.interruptible", &autofs_interruptible);
  150 SYSCTL_INT(_vfs_autofs, OID_AUTO, interruptible, CTLFLAG_RWTUN,
  151     &autofs_interruptible, 1, "Allow requests to be interrupted by signal");
  152 
  153 static int
  154 autofs_node_cmp(const struct autofs_node *a, const struct autofs_node *b)
  155 {
  156 
  157         return (strcmp(a->an_name, b->an_name));
  158 }
  159 
  160 RB_GENERATE(autofs_node_tree, autofs_node, an_link, autofs_node_cmp);
  161 
  162 int
  163 autofs_init(struct vfsconf *vfsp)
  164 {
  165         int error;
  166 
  167         KASSERT(autofs_softc == NULL,
  168             ("softc %p, should be NULL", autofs_softc));
  169 
  170         autofs_softc = malloc(sizeof(*autofs_softc), M_AUTOFS,
  171             M_WAITOK | M_ZERO);
  172 
  173         autofs_request_zone = uma_zcreate("autofs_request",
  174             sizeof(struct autofs_request), NULL, NULL, NULL, NULL,
  175             UMA_ALIGN_PTR, 0);
  176         autofs_node_zone = uma_zcreate("autofs_node",
  177             sizeof(struct autofs_node), NULL, NULL, NULL, NULL,
  178             UMA_ALIGN_PTR, 0);
  179 
  180         TAILQ_INIT(&autofs_softc->sc_requests);
  181         cv_init(&autofs_softc->sc_cv, "autofscv");
  182         sx_init(&autofs_softc->sc_lock, "autofslk");
  183 
  184         error = make_dev_p(MAKEDEV_CHECKNAME, &autofs_softc->sc_cdev,
  185             &autofs_cdevsw, NULL, UID_ROOT, GID_WHEEL, 0600, "autofs");
  186         if (error != 0) {
  187                 AUTOFS_WARN("failed to create device node, error %d", error);
  188                 uma_zdestroy(autofs_request_zone);
  189                 uma_zdestroy(autofs_node_zone);
  190                 free(autofs_softc, M_AUTOFS);
  191 
  192                 return (error);
  193         }
  194         autofs_softc->sc_cdev->si_drv1 = autofs_softc;
  195 
  196         return (0);
  197 }
  198 
  199 int
  200 autofs_uninit(struct vfsconf *vfsp)
  201 {
  202 
  203         sx_xlock(&autofs_softc->sc_lock);
  204         if (autofs_softc->sc_dev_opened) {
  205                 sx_xunlock(&autofs_softc->sc_lock);
  206                 return (EBUSY);
  207         }
  208         if (autofs_softc->sc_cdev != NULL)
  209                 destroy_dev(autofs_softc->sc_cdev);
  210 
  211         uma_zdestroy(autofs_request_zone);
  212         uma_zdestroy(autofs_node_zone);
  213 
  214         sx_xunlock(&autofs_softc->sc_lock);
  215         /*
  216          * XXX: Race with open?
  217          */
  218         free(autofs_softc, M_AUTOFS);
  219 
  220         return (0);
  221 }
  222 
  223 bool
  224 autofs_ignore_thread(const struct thread *td)
  225 {
  226         struct proc *p;
  227 
  228         p = td->td_proc;
  229 
  230         if (autofs_softc->sc_dev_opened == false)
  231                 return (false);
  232 
  233         PROC_LOCK(p);
  234         if (p->p_session->s_sid == autofs_softc->sc_dev_sid) {
  235                 PROC_UNLOCK(p);
  236                 return (true);
  237         }
  238         PROC_UNLOCK(p);
  239 
  240         return (false);
  241 }
  242 
  243 static char *
  244 autofs_path(struct autofs_node *anp)
  245 {
  246         struct autofs_mount *amp;
  247         char *path, *tmp;
  248 
  249         amp = anp->an_mount;
  250 
  251         path = strdup("", M_AUTOFS);
  252         for (; anp->an_parent != NULL; anp = anp->an_parent) {
  253                 tmp = malloc(strlen(anp->an_name) + strlen(path) + 2,
  254                     M_AUTOFS, M_WAITOK);
  255                 strcpy(tmp, anp->an_name);
  256                 strcat(tmp, "/");
  257                 strcat(tmp, path);
  258                 free(path, M_AUTOFS);
  259                 path = tmp;
  260         }
  261 
  262         tmp = malloc(strlen(amp->am_mountpoint) + strlen(path) + 2,
  263             M_AUTOFS, M_WAITOK);
  264         strcpy(tmp, amp->am_mountpoint);
  265         strcat(tmp, "/");
  266         strcat(tmp, path);
  267         free(path, M_AUTOFS);
  268         path = tmp;
  269 
  270         return (path);
  271 }
  272 
  273 static void
  274 autofs_task(void *context, int pending)
  275 {
  276         struct autofs_request *ar;
  277 
  278         ar = context;
  279 
  280         sx_xlock(&autofs_softc->sc_lock);
  281         AUTOFS_WARN("request %d for %s timed out after %d seconds",
  282             ar->ar_id, ar->ar_path, autofs_timeout);
  283         /*
  284          * XXX: EIO perhaps?
  285          */
  286         ar->ar_error = ETIMEDOUT;
  287         ar->ar_wildcards = true;
  288         ar->ar_done = true;
  289         ar->ar_in_progress = false;
  290         cv_broadcast(&autofs_softc->sc_cv);
  291         sx_xunlock(&autofs_softc->sc_lock);
  292 }
  293 
  294 bool
  295 autofs_cached(struct autofs_node *anp, const char *component, int componentlen)
  296 {
  297         int error;
  298         struct autofs_mount *amp;
  299 
  300         amp = anp->an_mount;
  301 
  302         AUTOFS_ASSERT_UNLOCKED(amp);
  303 
  304         /*
  305          * For root node we need to request automountd(8) assistance even
  306          * if the node is marked as cached, but the requested top-level
  307          * directory does not exist.  This is necessary for wildcard indirect
  308          * map keys to work.  We don't do this if we know that there are
  309          * no wildcards.
  310          */
  311         if (anp->an_parent == NULL && componentlen != 0 && anp->an_wildcards) {
  312                 AUTOFS_SLOCK(amp);
  313                 error = autofs_node_find(anp, component, componentlen, NULL);
  314                 AUTOFS_SUNLOCK(amp);
  315                 if (error != 0)
  316                         return (false);
  317         }
  318 
  319         return (anp->an_cached);
  320 }
  321 
  322 static void
  323 autofs_cache_callout(void *context)
  324 {
  325         struct autofs_node *anp;
  326 
  327         anp = context;
  328         anp->an_cached = false;
  329 }
  330 
  331 void
  332 autofs_flush(struct autofs_mount *amp)
  333 {
  334 
  335         /*
  336          * XXX: This will do for now, but ideally we should iterate
  337          *      over all the nodes.
  338          */
  339         amp->am_root->an_cached = false;
  340         AUTOFS_DEBUG("%s flushed", amp->am_mountpoint);
  341 }
  342 
  343 /*
  344  * The set/restore sigmask functions are used to (temporarily) overwrite
  345  * the thread td_sigmask during triggering.
  346  */
  347 static void
  348 autofs_set_sigmask(sigset_t *oldset)
  349 {
  350         sigset_t newset;
  351         int i;
  352 
  353         SIGFILLSET(newset);
  354         /* Remove the autofs set of signals from newset */
  355         PROC_LOCK(curproc);
  356         mtx_lock(&curproc->p_sigacts->ps_mtx);
  357         for (i = 0 ; i < nitems(autofs_sig_set); i++) {
  358                 /*
  359                  * But make sure we leave the ones already masked
  360                  * by the process, i.e. remove the signal from the
  361                  * temporary signalmask only if it wasn't already
  362                  * in p_sigmask.
  363                  */
  364                 if (!SIGISMEMBER(curthread->td_sigmask, autofs_sig_set[i]) &&
  365                     !SIGISMEMBER(curproc->p_sigacts->ps_sigignore,
  366                     autofs_sig_set[i])) {
  367                         SIGDELSET(newset, autofs_sig_set[i]);
  368                 }
  369         }
  370         mtx_unlock(&curproc->p_sigacts->ps_mtx);
  371         kern_sigprocmask(curthread, SIG_SETMASK, &newset, oldset,
  372             SIGPROCMASK_PROC_LOCKED);
  373         PROC_UNLOCK(curproc);
  374 }
  375 
  376 static void
  377 autofs_restore_sigmask(sigset_t *set)
  378 {
  379 
  380         kern_sigprocmask(curthread, SIG_SETMASK, set, NULL, 0);
  381 }
  382 
  383 static int
  384 autofs_trigger_one(struct autofs_node *anp,
  385     const char *component, int componentlen)
  386 {
  387         sigset_t oldset;
  388         struct autofs_mount *amp;
  389         struct autofs_node *firstanp;
  390         struct autofs_request *ar;
  391         char *key, *path;
  392         int error = 0, request_error, last;
  393         bool wildcards;
  394 
  395         amp = anp->an_mount;
  396 
  397         sx_assert(&autofs_softc->sc_lock, SA_XLOCKED);
  398 
  399         if (anp->an_parent == NULL) {
  400                 key = strndup(component, componentlen, M_AUTOFS);
  401         } else {
  402                 for (firstanp = anp; firstanp->an_parent->an_parent != NULL;
  403                     firstanp = firstanp->an_parent)
  404                         continue;
  405                 key = strdup(firstanp->an_name, M_AUTOFS);
  406         }
  407 
  408         path = autofs_path(anp);
  409 
  410         TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) {
  411                 if (strcmp(ar->ar_path, path) != 0)
  412                         continue;
  413                 if (strcmp(ar->ar_key, key) != 0)
  414                         continue;
  415 
  416                 KASSERT(strcmp(ar->ar_from, amp->am_from) == 0,
  417                     ("from changed; %s != %s", ar->ar_from, amp->am_from));
  418                 KASSERT(strcmp(ar->ar_prefix, amp->am_prefix) == 0,
  419                     ("prefix changed; %s != %s",
  420                      ar->ar_prefix, amp->am_prefix));
  421                 KASSERT(strcmp(ar->ar_options, amp->am_options) == 0,
  422                     ("options changed; %s != %s",
  423                      ar->ar_options, amp->am_options));
  424 
  425                 break;
  426         }
  427 
  428         if (ar != NULL) {
  429                 refcount_acquire(&ar->ar_refcount);
  430         } else {
  431                 ar = uma_zalloc(autofs_request_zone, M_WAITOK | M_ZERO);
  432                 ar->ar_mount = amp;
  433 
  434                 ar->ar_id =
  435                     atomic_fetchadd_int(&autofs_softc->sc_last_request_id, 1);
  436                 strlcpy(ar->ar_from, amp->am_from, sizeof(ar->ar_from));
  437                 strlcpy(ar->ar_path, path, sizeof(ar->ar_path));
  438                 strlcpy(ar->ar_prefix, amp->am_prefix, sizeof(ar->ar_prefix));
  439                 strlcpy(ar->ar_key, key, sizeof(ar->ar_key));
  440                 strlcpy(ar->ar_options,
  441                     amp->am_options, sizeof(ar->ar_options));
  442 
  443                 TIMEOUT_TASK_INIT(taskqueue_thread, &ar->ar_task, 0,
  444                     autofs_task, ar);
  445                 taskqueue_enqueue_timeout(taskqueue_thread, &ar->ar_task,
  446                     autofs_timeout * hz);
  447                 refcount_init(&ar->ar_refcount, 1);
  448                 TAILQ_INSERT_TAIL(&autofs_softc->sc_requests, ar, ar_next);
  449         }
  450 
  451         cv_broadcast(&autofs_softc->sc_cv);
  452         while (ar->ar_done == false) {
  453                 if (autofs_interruptible != 0) {
  454                         autofs_set_sigmask(&oldset);
  455                         error = cv_wait_sig(&autofs_softc->sc_cv,
  456                             &autofs_softc->sc_lock);
  457                         autofs_restore_sigmask(&oldset);
  458                         if (error != 0) {
  459                                 AUTOFS_WARN("cv_wait_sig for %s failed "
  460                                     "with error %d", ar->ar_path, error);
  461                                 break;
  462                         }
  463                 } else {
  464                         cv_wait(&autofs_softc->sc_cv, &autofs_softc->sc_lock);
  465                 }
  466         }
  467 
  468         request_error = ar->ar_error;
  469         if (request_error != 0) {
  470                 AUTOFS_WARN("request for %s completed with error %d",
  471                     ar->ar_path, request_error);
  472         }
  473 
  474         wildcards = ar->ar_wildcards;
  475 
  476         last = refcount_release(&ar->ar_refcount);
  477         if (last) {
  478                 TAILQ_REMOVE(&autofs_softc->sc_requests, ar, ar_next);
  479                 /*
  480                  * Unlock the sc_lock, so that autofs_task() can complete.
  481                  */
  482                 sx_xunlock(&autofs_softc->sc_lock);
  483                 taskqueue_cancel_timeout(taskqueue_thread, &ar->ar_task, NULL);
  484                 taskqueue_drain_timeout(taskqueue_thread, &ar->ar_task);
  485                 uma_zfree(autofs_request_zone, ar);
  486                 sx_xlock(&autofs_softc->sc_lock);
  487         }
  488 
  489         /*
  490          * Note that we do not do negative caching on purpose.  This
  491          * way the user can retry access at any time, e.g. after fixing
  492          * the failure reason, without waiting for cache timer to expire.
  493          */
  494         if (error == 0 && request_error == 0 && autofs_cache > 0) {
  495                 anp->an_cached = true;
  496                 anp->an_wildcards = wildcards;
  497                 callout_reset(&anp->an_callout, autofs_cache * hz,
  498                     autofs_cache_callout, anp);
  499         }
  500 
  501         free(key, M_AUTOFS);
  502         free(path, M_AUTOFS);
  503 
  504         if (error != 0)
  505                 return (error);
  506         return (request_error);
  507 }
  508 
  509 /*
  510  * Send request to automountd(8) and wait for completion.
  511  */
  512 int
  513 autofs_trigger(struct autofs_node *anp,
  514     const char *component, int componentlen)
  515 {
  516         int error;
  517 
  518         for (;;) {
  519                 error = autofs_trigger_one(anp, component, componentlen);
  520                 if (error == 0) {
  521                         anp->an_retries = 0;
  522                         return (0);
  523                 }
  524                 if (error == EINTR || error == ERESTART) {
  525                         AUTOFS_DEBUG("trigger interrupted by signal, "
  526                             "not retrying");
  527                         anp->an_retries = 0;
  528                         return (error);
  529                 }
  530                 anp->an_retries++;
  531                 if (anp->an_retries >= autofs_retry_attempts) {
  532                         AUTOFS_DEBUG("trigger failed %d times; returning "
  533                             "error %d", anp->an_retries, error);
  534                         anp->an_retries = 0;
  535                         return (error);
  536 
  537                 }
  538                 AUTOFS_DEBUG("trigger failed with error %d; will retry in "
  539                     "%d seconds, %d attempts left", error, autofs_retry_delay,
  540                     autofs_retry_attempts - anp->an_retries);
  541                 sx_xunlock(&autofs_softc->sc_lock);
  542                 pause("autofs_retry", autofs_retry_delay * hz);
  543                 sx_xlock(&autofs_softc->sc_lock);
  544         }
  545 }
  546 
  547 static int
  548 autofs_ioctl_request(struct autofs_daemon_request *adr)
  549 {
  550         struct autofs_request *ar;
  551         int error;
  552 
  553         sx_xlock(&autofs_softc->sc_lock);
  554         for (;;) {
  555                 TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) {
  556                         if (ar->ar_done)
  557                                 continue;
  558                         if (ar->ar_in_progress)
  559                                 continue;
  560 
  561                         break;
  562                 }
  563 
  564                 if (ar != NULL)
  565                         break;
  566 
  567                 error = cv_wait_sig(&autofs_softc->sc_cv,
  568                     &autofs_softc->sc_lock);
  569                 if (error != 0) {
  570                         sx_xunlock(&autofs_softc->sc_lock);
  571                         return (error);
  572                 }
  573         }
  574 
  575         ar->ar_in_progress = true;
  576         sx_xunlock(&autofs_softc->sc_lock);
  577 
  578         adr->adr_id = ar->ar_id;
  579         strlcpy(adr->adr_from, ar->ar_from, sizeof(adr->adr_from));
  580         strlcpy(adr->adr_path, ar->ar_path, sizeof(adr->adr_path));
  581         strlcpy(adr->adr_prefix, ar->ar_prefix, sizeof(adr->adr_prefix));
  582         strlcpy(adr->adr_key, ar->ar_key, sizeof(adr->adr_key));
  583         strlcpy(adr->adr_options, ar->ar_options, sizeof(adr->adr_options));
  584 
  585         PROC_LOCK(curproc);
  586         autofs_softc->sc_dev_sid = curproc->p_session->s_sid;
  587         PROC_UNLOCK(curproc);
  588 
  589         return (0);
  590 }
  591 
  592 static int
  593 autofs_ioctl_done_101(struct autofs_daemon_done_101 *add)
  594 {
  595         struct autofs_request *ar;
  596 
  597         sx_xlock(&autofs_softc->sc_lock);
  598         TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) {
  599                 if (ar->ar_id == add->add_id)
  600                         break;
  601         }
  602 
  603         if (ar == NULL) {
  604                 sx_xunlock(&autofs_softc->sc_lock);
  605                 AUTOFS_DEBUG("id %d not found", add->add_id);
  606                 return (ESRCH);
  607         }
  608 
  609         ar->ar_error = add->add_error;
  610         ar->ar_wildcards = true;
  611         ar->ar_done = true;
  612         ar->ar_in_progress = false;
  613         cv_broadcast(&autofs_softc->sc_cv);
  614 
  615         sx_xunlock(&autofs_softc->sc_lock);
  616 
  617         return (0);
  618 }
  619 
  620 static int
  621 autofs_ioctl_done(struct autofs_daemon_done *add)
  622 {
  623         struct autofs_request *ar;
  624 
  625         sx_xlock(&autofs_softc->sc_lock);
  626         TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) {
  627                 if (ar->ar_id == add->add_id)
  628                         break;
  629         }
  630 
  631         if (ar == NULL) {
  632                 sx_xunlock(&autofs_softc->sc_lock);
  633                 AUTOFS_DEBUG("id %d not found", add->add_id);
  634                 return (ESRCH);
  635         }
  636 
  637         ar->ar_error = add->add_error;
  638         ar->ar_wildcards = add->add_wildcards;
  639         ar->ar_done = true;
  640         ar->ar_in_progress = false;
  641         cv_broadcast(&autofs_softc->sc_cv);
  642 
  643         sx_xunlock(&autofs_softc->sc_lock);
  644 
  645         return (0);
  646 }
  647 
  648 static int
  649 autofs_open(struct cdev *dev, int flags, int fmt, struct thread *td)
  650 {
  651 
  652         sx_xlock(&autofs_softc->sc_lock);
  653         /*
  654          * We must never block automountd(8) and its descendants, and we use
  655          * session ID to determine that: we store session id of the process
  656          * that opened the device, and then compare it with session ids
  657          * of triggering processes.  This means running a second automountd(8)
  658          * instance would break the previous one.  The check below prevents
  659          * it from happening.
  660          */
  661         if (autofs_softc->sc_dev_opened) {
  662                 sx_xunlock(&autofs_softc->sc_lock);
  663                 return (EBUSY);
  664         }
  665 
  666         autofs_softc->sc_dev_opened = true;
  667         sx_xunlock(&autofs_softc->sc_lock);
  668 
  669         return (0);
  670 }
  671 
  672 static int
  673 autofs_close(struct cdev *dev, int flag, int fmt, struct thread *td)
  674 {
  675 
  676         sx_xlock(&autofs_softc->sc_lock);
  677         KASSERT(autofs_softc->sc_dev_opened, ("not opened?"));
  678         autofs_softc->sc_dev_opened = false;
  679         sx_xunlock(&autofs_softc->sc_lock);
  680 
  681         return (0);
  682 }
  683 
  684 static int
  685 autofs_ioctl(struct cdev *dev, u_long cmd, caddr_t arg, int mode,
  686     struct thread *td)
  687 {
  688 
  689         KASSERT(autofs_softc->sc_dev_opened, ("not opened?"));
  690 
  691         switch (cmd) {
  692         case AUTOFSREQUEST:
  693                 return (autofs_ioctl_request(
  694                     (struct autofs_daemon_request *)arg));
  695         case AUTOFSDONE101:
  696                 return (autofs_ioctl_done_101(
  697                     (struct autofs_daemon_done_101 *)arg));
  698         case AUTOFSDONE:
  699                 return (autofs_ioctl_done(
  700                     (struct autofs_daemon_done *)arg));
  701         default:
  702                 AUTOFS_DEBUG("invalid cmd %lx", cmd);
  703                 return (EINVAL);
  704         }
  705 }
Cache object: 1067fc0fdbae5c9f96be976f3208e971
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/fs/autofs/autofs.c

FreeBSD/Linux Kernel Cross Reference
sys/fs/autofs/autofs.c
