1 /* $NetBSD: autofs.c,v 1.6 2020/05/23 23:42:43 ad Exp $ */ 2 3 /*- 4 * Copyright (c) 2017 The NetBSD Foundation, Inc. 5 * Copyright (c) 2016 The DragonFly Project 6 * Copyright (c) 2014 The FreeBSD Foundation 7 * All rights reserved. 8 * 9 * This code is derived from software contributed to The NetBSD Foundation 10 * by Tomohiro Kusumi <kusumi.tomohiro@gmail.com>. 11 * 12 * This software was developed by Edward Tomasz Napierala under sponsorship 13 * from the FreeBSD Foundation. 14 * 15 * Redistribution and use in source and binary forms, with or without 16 * modification, are permitted provided that the following conditions 17 * are met: 18 * 1. Redistributions of source code must retain the above copyright 19 * notice, this list of conditions and the following disclaimer. 20 * 2. Redistributions in binary form must reproduce the above copyright 21 * notice, this list of conditions and the following disclaimer in the 22 * documentation and/or other materials provided with the distribution. 23 * 24 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 25 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 26 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 27 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 28 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 29 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 30 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 31 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 32 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 33 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 34 * SUCH DAMAGE. 35 * 36 */ 37 /*- 38 * Copyright (c) 1989, 1991, 1993, 1995 39 * The Regents of the University of California. All rights reserved. 40 * 41 * This code is derived from software contributed to Berkeley by 42 * Rick Macklem at The University of Guelph. 43 * 44 * Redistribution and use in source and binary forms, with or without 45 * modification, are permitted provided that the following conditions 46 * are met: 47 * 1. Redistributions of source code must retain the above copyright 48 * notice, this list of conditions and the following disclaimer. 49 * 2. Redistributions in binary form must reproduce the above copyright 50 * notice, this list of conditions and the following disclaimer in the 51 * documentation and/or other materials provided with the distribution. 52 * 3. Neither the name of the University nor the names of its contributors 53 * may be used to endorse or promote products derived from this software 54 * without specific prior written permission. 55 * 56 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 57 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 58 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 59 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 60 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 61 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 62 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 63 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 64 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 65 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 66 * SUCH DAMAGE. 67 * 68 */ 69 70 #include <sys/cdefs.h> 71 __KERNEL_RCSID(0, "$NetBSD: autofs.c,v 1.6 2020/05/23 23:42:43 ad Exp $"); 72 73 #include "autofs.h" 74 75 #include "ioconf.h" 76 77 #include <sys/atomic.h> 78 #include <sys/queue.h> 79 #include <sys/signalvar.h> 80 81 static dev_type_open(autofs_open); 82 static dev_type_close(autofs_close); 83 static dev_type_ioctl(autofs_ioctl); 84 85 const struct cdevsw autofs_cdevsw = { 86 .d_open = autofs_open, 87 .d_close = autofs_close, 88 .d_read = noread, 89 .d_write = nowrite, 90 .d_ioctl = autofs_ioctl, 91 .d_stop = nostop, 92 .d_tty = notty, 93 .d_poll = nopoll, 94 .d_mmap = nommap, 95 .d_kqfilter = nokqfilter, 96 .d_discard = nodiscard, 97 .d_flag = D_OTHER, 98 }; 99 100 /* 101 * List of signals that can interrupt an autofs trigger. 102 */ 103 static int autofs_sig_set[] = { 104 SIGINT, 105 SIGTERM, 106 SIGHUP, 107 SIGKILL, 108 SIGQUIT, 109 }; 110 111 struct pool autofs_request_pool; 112 struct pool autofs_node_pool; 113 struct autofs_softc *autofs_softc = NULL; 114 struct workqueue *autofs_tmo_wq = NULL; 115 116 int autofs_debug = 1; 117 int autofs_mount_on_stat = 0; 118 int autofs_timeout = 30; 119 int autofs_cache = 600; 120 int autofs_retry_attempts = 3; 121 int autofs_retry_delay = 1; 122 int autofs_interruptible = 1; 123 124 void 125 autofsattach(int n) 126 { 127 } 128 129 static int 130 autofs_node_cmp(const struct autofs_node *a, const struct autofs_node *b) 131 { 132 133 return strcmp(a->an_name, b->an_name); 134 } 135 136 RB_GENERATE(autofs_node_tree, autofs_node, an_entry, autofs_node_cmp); 137 138 bool 139 autofs_ignore_thread(void) 140 { 141 142 if (autofs_softc->sc_dev_opened == false) 143 return false; 144 145 mutex_enter(&proc_lock); 146 if (autofs_softc->sc_dev_sid == curproc->p_pgrp->pg_id) { 147 mutex_exit(&proc_lock); 148 return true; 149 } 150 mutex_exit(&proc_lock); 151 152 return false; 153 } 154 155 static char * 156 autofs_path(struct autofs_node *anp) 157 { 158 struct autofs_mount *amp = anp->an_mount; 159 size_t len; 160 char *path, *tmp; 161 162 path = kmem_strdup("", KM_SLEEP); 163 for (; anp->an_parent; anp = anp->an_parent) { 164 len = strlen(anp->an_name) + strlen(path) + 2; 165 tmp = kmem_alloc(len, KM_SLEEP); 166 snprintf(tmp, len, "%s/%s", anp->an_name, path); 167 kmem_strfree(path); 168 path = tmp; 169 } 170 171 len = strlen(amp->am_on) + strlen(path) + 2; 172 tmp = kmem_alloc(len, KM_SLEEP); 173 snprintf(tmp, len, "%s/%s", amp->am_on, path); 174 kmem_strfree(path); 175 176 return tmp; 177 } 178 179 void 180 autofs_timeout_wq(struct work *wk, void *arg) 181 { 182 struct autofs_request *ar = (void *)wk; 183 184 mutex_enter(&autofs_softc->sc_lock); 185 AUTOFS_WARN("request %d for %s timed out after %d seconds", 186 ar->ar_id, ar->ar_path, autofs_timeout); 187 188 ar->ar_error = ETIMEDOUT; 189 ar->ar_wildcards = true; 190 ar->ar_done = true; 191 ar->ar_in_progress = false; 192 cv_broadcast(&autofs_softc->sc_cv); 193 mutex_exit(&autofs_softc->sc_lock); 194 } 195 196 static void 197 autofs_timeout_callout(void *context) 198 { 199 struct autofs_request *ar = context; 200 201 workqueue_enqueue(autofs_tmo_wq, &ar->ar_wk, NULL); 202 } 203 204 bool 205 autofs_cached(struct autofs_node *anp, const char *component, int componentlen) 206 { 207 struct autofs_mount *amp = anp->an_mount; 208 209 KASSERT(!mutex_owned(&->am_lock)); 210 211 /* 212 * For root node we need to request automountd(8) assistance even 213 * if the node is marked as cached, but the requested top-level 214 * directory does not exist. This is necessary for wildcard indirect 215 * map keys to work. We don't do this if we know that there are 216 * no wildcards. 217 */ 218 if (!anp->an_parent && componentlen && anp->an_wildcards) { 219 int error; 220 KASSERT(amp->am_root == anp); 221 mutex_enter(&->am_lock); 222 error = autofs_node_find(anp, component, componentlen, NULL); 223 mutex_exit(&->am_lock); 224 if (error) 225 return false; 226 } 227 228 return anp->an_cached; 229 } 230 231 static void 232 autofs_cache_callout(void *context) 233 { 234 struct autofs_node *anp = context; 235 236 autofs_node_uncache(anp); 237 } 238 239 void 240 autofs_flush(struct autofs_mount *amp) 241 { 242 struct autofs_node *anp = amp->am_root; 243 struct autofs_node *child; 244 245 mutex_enter(&->am_lock); 246 RB_FOREACH(child, autofs_node_tree, &anp->an_children) { 247 autofs_node_uncache(child); 248 } 249 autofs_node_uncache(amp->am_root); 250 mutex_exit(&->am_lock); 251 252 AUTOFS_DEBUG("%s flushed", amp->am_on); 253 } 254 255 /* 256 * The set/restore sigmask functions are used to (temporarily) overwrite 257 * the thread sigmask during triggering. 258 */ 259 static void 260 autofs_set_sigmask(sigset_t *oldset) 261 { 262 sigset_t newset; 263 int i; 264 265 sigfillset(&newset); 266 /* Remove the autofs set of signals from newset */ 267 mutex_enter(&proc_lock); 268 mutex_enter(curproc->p_lock); 269 270 for (i = 0; i < __arraycount(autofs_sig_set); i++) { 271 /* 272 * But make sure we leave the ones already masked 273 * by the process, i.e. remove the signal from the 274 * temporary signalmask only if it wasn't already 275 * in sigmask. 276 */ 277 if (!sigismasked(curlwp, autofs_sig_set[i])) 278 sigdelset(&newset, autofs_sig_set[i]); 279 } 280 sigprocmask1(curlwp, SIG_SETMASK, &newset, oldset); 281 282 mutex_exit(curproc->p_lock); 283 mutex_exit(&proc_lock); 284 } 285 286 static void 287 autofs_restore_sigmask(sigset_t *set) 288 { 289 290 mutex_enter(&proc_lock); 291 mutex_enter(curproc->p_lock); 292 293 sigprocmask1(curlwp, SIG_SETMASK, set, NULL); 294 295 mutex_exit(curproc->p_lock); 296 mutex_exit(&proc_lock); 297 } 298 299 static int 300 autofs_trigger_one(struct autofs_node *anp, const char *component, 301 int componentlen) 302 { 303 struct autofs_mount *amp = anp->an_mount; 304 struct autofs_request *ar; 305 char *key, *path; 306 int error = 0, request_error; 307 bool wildcards; 308 309 KASSERT(mutex_owned(&autofs_softc->sc_lock)); 310 311 if (!anp->an_parent) { 312 key = autofs_strndup(component, componentlen, KM_SLEEP); 313 } else { 314 struct autofs_node *firstanp; 315 for (firstanp = anp; firstanp->an_parent->an_parent; 316 firstanp = firstanp->an_parent) 317 continue; 318 key = kmem_strdup(firstanp->an_name, KM_SLEEP); 319 } 320 321 path = autofs_path(anp); 322 323 TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) { 324 if (strcmp(ar->ar_path, path)) 325 continue; 326 if (strcmp(ar->ar_key, key)) 327 continue; 328 329 KASSERT(!strcmp(ar->ar_from, amp->am_from)); 330 KASSERT(!strcmp(ar->ar_prefix, amp->am_prefix)); 331 KASSERT(!strcmp(ar->ar_options, amp->am_options)); 332 break; 333 } 334 335 if (ar) { 336 atomic_add_int(&ar->ar_refcount, 1); 337 } else { 338 ar = pool_get(&autofs_request_pool, PR_WAITOK); 339 ar->ar_mount = amp; 340 ar->ar_id = autofs_softc->sc_last_request_id++; 341 ar->ar_done = false; 342 ar->ar_error = 0; 343 ar->ar_wildcards = false; 344 ar->ar_in_progress = false; 345 strlcpy(ar->ar_from, amp->am_from, sizeof(ar->ar_from)); 346 strlcpy(ar->ar_path, path, sizeof(ar->ar_path)); 347 strlcpy(ar->ar_prefix, amp->am_prefix, sizeof(ar->ar_prefix)); 348 strlcpy(ar->ar_key, key, sizeof(ar->ar_key)); 349 strlcpy(ar->ar_options, 350 amp->am_options, sizeof(ar->ar_options)); 351 352 callout_init(&ar->ar_callout, 0); 353 callout_reset(&ar->ar_callout, autofs_timeout * hz, 354 autofs_timeout_callout, ar); 355 ar->ar_refcount = 1; 356 TAILQ_INSERT_TAIL(&autofs_softc->sc_requests, ar, ar_next); 357 } 358 359 cv_broadcast(&autofs_softc->sc_cv); 360 while (ar->ar_done == false) { 361 if (autofs_interruptible) { 362 sigset_t oldset; 363 autofs_set_sigmask(&oldset); 364 error = cv_wait_sig(&autofs_softc->sc_cv, 365 &autofs_softc->sc_lock); 366 autofs_restore_sigmask(&oldset); 367 if (error) { 368 AUTOFS_WARN("cv_wait_sig for %s failed " 369 "with error %d", ar->ar_path, error); 370 break; 371 } 372 } else { 373 cv_wait(&autofs_softc->sc_cv, &autofs_softc->sc_lock); 374 } 375 } 376 377 request_error = ar->ar_error; 378 if (request_error) 379 AUTOFS_WARN("request for %s completed with error %d, " 380 "pid %d (%s)", ar->ar_path, request_error, 381 curproc->p_pid, curproc->p_comm); 382 383 wildcards = ar->ar_wildcards; 384 385 /* 386 * Check if this is the last reference. 387 */ 388 if (!atomic_add_int_nv(&ar->ar_refcount, -1)) { 389 TAILQ_REMOVE(&autofs_softc->sc_requests, ar, ar_next); 390 mutex_exit(&autofs_softc->sc_lock); 391 callout_halt(&ar->ar_callout, NULL); 392 pool_put(&autofs_request_pool, ar); 393 mutex_enter(&autofs_softc->sc_lock); 394 } 395 396 /* 397 * Note that we do not do negative caching on purpose. This 398 * way the user can retry access at any time, e.g. after fixing 399 * the failure reason, without waiting for cache timer to expire. 400 */ 401 if (!error && !request_error && autofs_cache > 0) { 402 autofs_node_cache(anp); 403 anp->an_wildcards = wildcards; 404 callout_reset(&anp->an_callout, autofs_cache * hz, 405 autofs_cache_callout, anp); 406 } 407 408 kmem_strfree(key); 409 kmem_strfree(path); 410 411 if (error) 412 return error; 413 return request_error; 414 } 415 416 int 417 autofs_trigger(struct autofs_node *anp, const char *component, 418 int componentlen) 419 { 420 for (;;) { 421 int error, dummy; 422 423 error = autofs_trigger_one(anp, component, componentlen); 424 if (!error) { 425 anp->an_retries = 0; 426 return 0; 427 } 428 if (error == EINTR || error == ERESTART) { 429 AUTOFS_DEBUG("trigger interrupted by signal, " 430 "not retrying"); 431 anp->an_retries = 0; 432 return error; 433 } 434 anp->an_retries++; 435 if (anp->an_retries >= autofs_retry_attempts) { 436 AUTOFS_DEBUG("trigger failed %d times; returning " 437 "error %d", anp->an_retries, error); 438 anp->an_retries = 0; 439 return error; 440 441 } 442 AUTOFS_DEBUG("trigger failed with error %d; will retry in " 443 "%d seconds, %d attempts left", error, autofs_retry_delay, 444 autofs_retry_attempts - anp->an_retries); 445 mutex_exit(&autofs_softc->sc_lock); 446 tsleep(&dummy, 0, "autofs_retry", autofs_retry_delay * hz); 447 mutex_enter(&autofs_softc->sc_lock); 448 } 449 } 450 451 static int 452 autofs_ioctl_request(struct autofs_daemon_request *adr) 453 { 454 struct autofs_request *ar; 455 456 mutex_enter(&autofs_softc->sc_lock); 457 for (;;) { 458 int error; 459 TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) { 460 if (ar->ar_done) 461 continue; 462 if (ar->ar_in_progress) 463 continue; 464 break; 465 } 466 467 if (ar) 468 break; 469 470 error = cv_wait_sig(&autofs_softc->sc_cv, 471 &autofs_softc->sc_lock); 472 if (error) { 473 mutex_exit(&autofs_softc->sc_lock); 474 return error; 475 } 476 } 477 478 ar->ar_in_progress = true; 479 mutex_exit(&autofs_softc->sc_lock); 480 481 adr->adr_id = ar->ar_id; 482 strlcpy(adr->adr_from, ar->ar_from, sizeof(adr->adr_from)); 483 strlcpy(adr->adr_path, ar->ar_path, sizeof(adr->adr_path)); 484 strlcpy(adr->adr_prefix, ar->ar_prefix, sizeof(adr->adr_prefix)); 485 strlcpy(adr->adr_key, ar->ar_key, sizeof(adr->adr_key)); 486 strlcpy(adr->adr_options, ar->ar_options, sizeof(adr->adr_options)); 487 488 mutex_enter(&proc_lock); 489 autofs_softc->sc_dev_sid = curproc->p_pgrp->pg_id; 490 mutex_exit(&proc_lock); 491 492 return 0; 493 } 494 495 static int 496 autofs_ioctl_done(struct autofs_daemon_done *add) 497 { 498 struct autofs_request *ar; 499 500 mutex_enter(&autofs_softc->sc_lock); 501 TAILQ_FOREACH(ar, &autofs_softc->sc_requests, ar_next) { 502 if (ar->ar_id == add->add_id) 503 break; 504 } 505 506 if (!ar) { 507 mutex_exit(&autofs_softc->sc_lock); 508 AUTOFS_DEBUG("id %d not found", add->add_id); 509 return ESRCH; 510 } 511 512 ar->ar_error = add->add_error; 513 ar->ar_wildcards = add->add_wildcards; 514 ar->ar_done = true; 515 ar->ar_in_progress = false; 516 cv_broadcast(&autofs_softc->sc_cv); 517 518 mutex_exit(&autofs_softc->sc_lock); 519 520 return 0; 521 } 522 523 static int 524 autofs_open(dev_t dev, int flags, int mode, struct lwp *l) 525 { 526 527 mutex_enter(&autofs_softc->sc_lock); 528 /* 529 * We must never block automountd(8) and its descendants, and we use 530 * session ID to determine that: we store session id of the process 531 * that opened the device, and then compare it with session ids 532 * of triggering processes. This means running a second automountd(8) 533 * instance would break the previous one. The check below prevents 534 * it from happening. 535 */ 536 if (autofs_softc->sc_dev_opened) { 537 mutex_exit(&autofs_softc->sc_lock); 538 return EBUSY; 539 } 540 541 autofs_softc->sc_dev_opened = true; 542 mutex_exit(&autofs_softc->sc_lock); 543 544 return 0; 545 } 546 547 static int 548 autofs_close(dev_t dev, int flags, int mode, struct lwp *l) 549 { 550 551 mutex_enter(&autofs_softc->sc_lock); 552 KASSERT(autofs_softc->sc_dev_opened); 553 autofs_softc->sc_dev_opened = false; 554 mutex_exit(&autofs_softc->sc_lock); 555 556 return 0; 557 } 558 559 static int 560 autofs_ioctl(dev_t dev, const u_long cmd, void *data, int flag, struct lwp *l) 561 { 562 563 KASSERT(autofs_softc->sc_dev_opened); 564 565 switch (cmd) { 566 case AUTOFSREQUEST: 567 return autofs_ioctl_request( 568 (struct autofs_daemon_request *)data); 569 case AUTOFSDONE: 570 return autofs_ioctl_done( 571 (struct autofs_daemon_done *)data); 572 default: 573 AUTOFS_DEBUG("invalid cmd %lx", cmd); 574 return EINVAL; 575 } 576 return EINVAL; 577 } 578