sys/fs/autofs/autofs.c

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