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