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 } 638