src/core/automount.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <limits.h>
  24 #include <sys/mount.h>
  25 #include <unistd.h>
  26 #include <fcntl.h>
  27 #include <sys/epoll.h>
  28 #include <sys/stat.h>
  29 #include <linux/auto_fs4.h>
  30 #include <linux/auto_dev-ioctl.h>
  31
  32 #include "unit.h"
  33 #include "automount.h"
  34 #include "mount.h"
  35 #include "unit-name.h"
  36 #include "special.h"
  37 #include "label.h"
  38 #include "mkdir.h"
  39 #include "path-util.h"
  40 #include "dbus-automount.h"
  41 #include "bus-util.h"
  42 #include "bus-error.h"
  43 #include "formats-util.h"
  44 #include "process-util.h"
  45 #include "async.h"
  46
  47 static const UnitActiveState state_translation_table[_AUTOMOUNT_STATE_MAX] = {
  48         [AUTOMOUNT_DEAD] = UNIT_INACTIVE,
  49         [AUTOMOUNT_WAITING] = UNIT_ACTIVE,
  50         [AUTOMOUNT_RUNNING] = UNIT_ACTIVE,
  51         [AUTOMOUNT_FAILED] = UNIT_FAILED
  52 };
  53
  54 struct expire_data {
  55         int dev_autofs_fd;
  56         int ioctl_fd;
  57 };
  58
  59 static inline void expire_data_free(struct expire_data *data) {
  60         if (!data)
  61                 return;
  62
  63         safe_close(data->dev_autofs_fd);
  64         safe_close(data->ioctl_fd);
  65         free(data);
  66 }
  67
  68 DEFINE_TRIVIAL_CLEANUP_FUNC(struct expire_data*, expire_data_free);
  69
  70 static int open_dev_autofs(Manager *m);
  71 static int automount_dispatch_io(sd_event_source *s, int fd, uint32_t events, void *userdata);
  72
  73 static void automount_init(Unit *u) {
  74         Automount *a = AUTOMOUNT(u);
  75
  76         assert(u);
  77         assert(u->load_state == UNIT_STUB);
  78
  79         a->pipe_fd = -1;
  80         a->directory_mode = 0755;
  81         UNIT(a)->ignore_on_isolate = true;
  82 }
  83
  84 static void repeat_unmount(const char *path) {
  85         assert(path);
  86
  87         for (;;) {
  88                 /* If there are multiple mounts on a mount point, this
  89                  * removes them all */
  90
  91                 if (umount2(path, MNT_DETACH) >= 0)
  92                         continue;
  93
  94                 if (errno != EINVAL)
  95                         log_error_errno(errno, "Failed to unmount: %m");
  96
  97                 break;
  98         }
  99 }
 100
 101 static int automount_send_ready(Automount *a, Set *tokens, int status);
 102
 103 static void unmount_autofs(Automount *a) {
 104         assert(a);
 105
 106         if (a->pipe_fd < 0)
 107                 return;
 108
 109         automount_send_ready(a, a->tokens, -EHOSTDOWN);
 110         automount_send_ready(a, a->expire_tokens, -EHOSTDOWN);
 111
 112         a->pipe_event_source = sd_event_source_unref(a->pipe_event_source);
 113         a->pipe_fd = safe_close(a->pipe_fd);
 114
 115         /* If we reload/reexecute things we keep the mount point
 116          * around */
 117         if (a->where &&
 118             (UNIT(a)->manager->exit_code != MANAGER_RELOAD &&
 119              UNIT(a)->manager->exit_code != MANAGER_REEXECUTE))
 120                 repeat_unmount(a->where);
 121 }
 122
 123 static void automount_done(Unit *u) {
 124         Automount *a = AUTOMOUNT(u);
 125
 126         assert(a);
 127
 128         unmount_autofs(a);
 129
 130         a->where = mfree(a->where);
 131
 132         set_free(a->tokens);
 133         a->tokens = NULL;
 134         set_free(a->expire_tokens);
 135         a->expire_tokens = NULL;
 136
 137         a->expire_event_source = sd_event_source_unref(a->expire_event_source);
 138 }
 139
 140 static int automount_add_mount_links(Automount *a) {
 141         _cleanup_free_ char *parent = NULL;
 142         int r;
 143
 144         assert(a);
 145
 146         r = path_get_parent(a->where, &parent);
 147         if (r < 0)
 148                 return r;
 149
 150         return unit_require_mounts_for(UNIT(a), parent);
 151 }
 152
 153 static int automount_add_default_dependencies(Automount *a) {
 154         int r;
 155
 156         assert(a);
 157
 158         if (UNIT(a)->manager->running_as != MANAGER_SYSTEM)
 159                 return 0;
 160
 161         r = unit_add_two_dependencies_by_name(UNIT(a), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
 162         if (r < 0)
 163                 return r;
 164
 165         return 0;
 166 }
 167
 168 static int automount_verify(Automount *a) {
 169         _cleanup_free_ char *e = NULL;
 170         int r;
 171
 172         assert(a);
 173
 174         if (UNIT(a)->load_state != UNIT_LOADED)
 175                 return 0;
 176
 177         if (path_equal(a->where, "/")) {
 178                 log_unit_error(UNIT(a), "Cannot have an automount unit for the root directory. Refusing.");
 179                 return -EINVAL;
 180         }
 181
 182         r = unit_name_from_path(a->where, ".automount", &e);
 183         if (r < 0)
 184                 return log_unit_error(UNIT(a), "Failed to generate unit name from path: %m");
 185
 186         if (!unit_has_name(UNIT(a), e)) {
 187                 log_unit_error(UNIT(a), "Where= setting doesn't match unit name. Refusing.");
 188                 return -EINVAL;
 189         }
 190
 191         return 0;
 192 }
 193
 194 static int automount_load(Unit *u) {
 195         Automount *a = AUTOMOUNT(u);
 196         int r;
 197
 198         assert(u);
 199         assert(u->load_state == UNIT_STUB);
 200
 201         /* Load a .automount file */
 202         r = unit_load_fragment_and_dropin_optional(u);
 203         if (r < 0)
 204                 return r;
 205
 206         if (u->load_state == UNIT_LOADED) {
 207                 Unit *x;
 208
 209                 if (!a->where) {
 210                         r = unit_name_to_path(u->id, &a->where);
 211                         if (r < 0)
 212                                 return r;
 213                 }
 214
 215                 path_kill_slashes(a->where);
 216
 217                 r = unit_load_related_unit(u, ".mount", &x);
 218                 if (r < 0)
 219                         return r;
 220
 221                 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, x, true);
 222                 if (r < 0)
 223                         return r;
 224
 225                 r = automount_add_mount_links(a);
 226                 if (r < 0)
 227                         return r;
 228
 229                 if (UNIT(a)->default_dependencies) {
 230                         r = automount_add_default_dependencies(a);
 231                         if (r < 0)
 232                                 return r;
 233                 }
 234         }
 235
 236         return automount_verify(a);
 237 }
 238
 239 static void automount_set_state(Automount *a, AutomountState state) {
 240         AutomountState old_state;
 241         assert(a);
 242
 243         old_state = a->state;
 244         a->state = state;
 245
 246         if (state != AUTOMOUNT_WAITING &&
 247             state != AUTOMOUNT_RUNNING)
 248                 unmount_autofs(a);
 249
 250         if (state != old_state)
 251                 log_unit_debug(UNIT(a), "Changed %s -> %s", automount_state_to_string(old_state), automount_state_to_string(state));
 252
 253         unit_notify(UNIT(a), state_translation_table[old_state], state_translation_table[state], true);
 254 }
 255
 256 static int automount_coldplug(Unit *u) {
 257         Automount *a = AUTOMOUNT(u);
 258         int r;
 259
 260         assert(a);
 261         assert(a->state == AUTOMOUNT_DEAD);
 262
 263         if (a->deserialized_state != a->state) {
 264
 265                 r = open_dev_autofs(u->manager);
 266                 if (r < 0)
 267                         return r;
 268
 269                 if (a->deserialized_state == AUTOMOUNT_WAITING ||
 270                     a->deserialized_state == AUTOMOUNT_RUNNING) {
 271                         assert(a->pipe_fd >= 0);
 272
 273                         r = sd_event_add_io(u->manager->event, &a->pipe_event_source, a->pipe_fd, EPOLLIN, automount_dispatch_io, u);
 274                         if (r < 0)
 275                                 return r;
 276
 277                         (void) sd_event_source_set_description(a->pipe_event_source, "automount-io");
 278                 }
 279
 280                 automount_set_state(a, a->deserialized_state);
 281         }
 282
 283         return 0;
 284 }
 285
 286 static void automount_dump(Unit *u, FILE *f, const char *prefix) {
 287         char time_string[FORMAT_TIMESPAN_MAX];
 288         Automount *a = AUTOMOUNT(u);
 289
 290         assert(a);
 291
 292         fprintf(f,
 293                 "%sAutomount State: %s\n"
 294                 "%sResult: %s\n"
 295                 "%sWhere: %s\n"
 296                 "%sDirectoryMode: %04o\n"
 297                 "%sTimeoutIdleUSec: %s\n",
 298                 prefix, automount_state_to_string(a->state),
 299                 prefix, automount_result_to_string(a->result),
 300                 prefix, a->where,
 301                 prefix, a->directory_mode,
 302                 prefix, format_timespan(time_string, FORMAT_TIMESPAN_MAX, a->timeout_idle_usec, USEC_PER_SEC));
 303 }
 304
 305 static void automount_enter_dead(Automount *a, AutomountResult f) {
 306         assert(a);
 307
 308         if (f != AUTOMOUNT_SUCCESS)
 309                 a->result = f;
 310
 311         automount_set_state(a, a->result != AUTOMOUNT_SUCCESS ? AUTOMOUNT_FAILED : AUTOMOUNT_DEAD);
 312 }
 313
 314 static int open_dev_autofs(Manager *m) {
 315         struct autofs_dev_ioctl param;
 316
 317         assert(m);
 318
 319         if (m->dev_autofs_fd >= 0)
 320                 return m->dev_autofs_fd;
 321
 322         label_fix("/dev/autofs", false, false);
 323
 324         m->dev_autofs_fd = open("/dev/autofs", O_CLOEXEC|O_RDONLY);
 325         if (m->dev_autofs_fd < 0)
 326                 return log_error_errno(errno, "Failed to open /dev/autofs: %m");
 327
 328         init_autofs_dev_ioctl(&param);
 329         if (ioctl(m->dev_autofs_fd, AUTOFS_DEV_IOCTL_VERSION, &param) < 0) {
 330                 m->dev_autofs_fd = safe_close(m->dev_autofs_fd);
 331                 return -errno;
 332         }
 333
 334         log_debug("Autofs kernel version %i.%i", param.ver_major, param.ver_minor);
 335
 336         return m->dev_autofs_fd;
 337 }
 338
 339 static int open_ioctl_fd(int dev_autofs_fd, const char *where, dev_t devid) {
 340         struct autofs_dev_ioctl *param;
 341         size_t l;
 342
 343         assert(dev_autofs_fd >= 0);
 344         assert(where);
 345
 346         l = sizeof(struct autofs_dev_ioctl) + strlen(where) + 1;
 347         param = alloca(l);
 348
 349         init_autofs_dev_ioctl(param);
 350         param->size = l;
 351         param->ioctlfd = -1;
 352         param->openmount.devid = devid;
 353         strcpy(param->path, where);
 354
 355         if (ioctl(dev_autofs_fd, AUTOFS_DEV_IOCTL_OPENMOUNT, param) < 0)
 356                 return -errno;
 357
 358         if (param->ioctlfd < 0)
 359                 return -EIO;
 360
 361         (void) fd_cloexec(param->ioctlfd, true);
 362         return param->ioctlfd;
 363 }
 364
 365 static int autofs_protocol(int dev_autofs_fd, int ioctl_fd) {
 366         uint32_t major, minor;
 367         struct autofs_dev_ioctl param;
 368
 369         assert(dev_autofs_fd >= 0);
 370         assert(ioctl_fd >= 0);
 371
 372         init_autofs_dev_ioctl(&param);
 373         param.ioctlfd = ioctl_fd;
 374
 375         if (ioctl(dev_autofs_fd, AUTOFS_DEV_IOCTL_PROTOVER, &param) < 0)
 376                 return -errno;
 377
 378         major = param.protover.version;
 379
 380         init_autofs_dev_ioctl(&param);
 381         param.ioctlfd = ioctl_fd;
 382
 383         if (ioctl(dev_autofs_fd, AUTOFS_DEV_IOCTL_PROTOSUBVER, &param) < 0)
 384                 return -errno;
 385
 386         minor = param.protosubver.sub_version;
 387
 388         log_debug("Autofs protocol version %i.%i", major, minor);
 389         return 0;
 390 }
 391
 392 static int autofs_set_timeout(int dev_autofs_fd, int ioctl_fd, usec_t usec) {
 393         struct autofs_dev_ioctl param;
 394
 395         assert(dev_autofs_fd >= 0);
 396         assert(ioctl_fd >= 0);
 397
 398         init_autofs_dev_ioctl(&param);
 399         param.ioctlfd = ioctl_fd;
 400
 401         /* Convert to seconds, rounding up. */
 402         param.timeout.timeout = (usec + USEC_PER_SEC - 1) / USEC_PER_SEC;
 403
 404         if (ioctl(dev_autofs_fd, AUTOFS_DEV_IOCTL_TIMEOUT, &param) < 0)
 405                 return -errno;
 406
 407         return 0;
 408 }
 409
 410 static int autofs_send_ready(int dev_autofs_fd, int ioctl_fd, uint32_t token, int status) {
 411         struct autofs_dev_ioctl param;
 412
 413         assert(dev_autofs_fd >= 0);
 414         assert(ioctl_fd >= 0);
 415
 416         init_autofs_dev_ioctl(&param);
 417         param.ioctlfd = ioctl_fd;
 418
 419         if (status) {
 420                 param.fail.token = token;
 421                 param.fail.status = status;
 422         } else
 423                 param.ready.token = token;
 424
 425         if (ioctl(dev_autofs_fd, status ? AUTOFS_DEV_IOCTL_FAIL : AUTOFS_DEV_IOCTL_READY, &param) < 0)
 426                 return -errno;
 427
 428         return 0;
 429 }
 430
 431 static int automount_send_ready(Automount *a, Set *tokens, int status) {
 432         _cleanup_close_ int ioctl_fd = -1;
 433         unsigned token;
 434         int r;
 435
 436         assert(a);
 437         assert(status <= 0);
 438
 439         if (set_isempty(tokens))
 440                 return 0;
 441
 442         ioctl_fd = open_ioctl_fd(UNIT(a)->manager->dev_autofs_fd, a->where, a->dev_id);
 443         if (ioctl_fd < 0)
 444                 return ioctl_fd;
 445
 446         if (status)
 447                 log_unit_debug_errno(UNIT(a), status, "Sending failure: %m");
 448         else
 449                 log_unit_debug(UNIT(a), "Sending success.");
 450
 451         r = 0;
 452
 453         /* Autofs thankfully does not hand out 0 as a token */
 454         while ((token = PTR_TO_UINT(set_steal_first(tokens)))) {
 455                 int k;
 456
 457                 /* Autofs fun fact II:
 458                  *
 459                  * if you pass a positive status code here, the kernel will
 460                  * freeze! Yay! */
 461
 462                 k = autofs_send_ready(UNIT(a)->manager->dev_autofs_fd,
 463                                       ioctl_fd,
 464                                       token,
 465                                       status);
 466                 if (k < 0)
 467                         r = k;
 468         }
 469
 470         return r;
 471 }
 472
 473 static int automount_start_expire(Automount *a);
 474
 475 int automount_update_mount(Automount *a, MountState old_state, MountState state) {
 476         int r;
 477
 478         assert(a);
 479
 480         switch (state) {
 481         case MOUNT_MOUNTED:
 482         case MOUNT_REMOUNTING:
 483                 automount_send_ready(a, a->tokens, 0);
 484                 r = automount_start_expire(a);
 485                 if (r < 0)
 486                         log_unit_warning_errno(UNIT(a), r, "Failed to start expiration timer, ignoring: %m");
 487                 break;
 488          case MOUNT_DEAD:
 489          case MOUNT_UNMOUNTING:
 490          case MOUNT_MOUNTING_SIGTERM:
 491          case MOUNT_MOUNTING_SIGKILL:
 492          case MOUNT_REMOUNTING_SIGTERM:
 493          case MOUNT_REMOUNTING_SIGKILL:
 494          case MOUNT_UNMOUNTING_SIGTERM:
 495          case MOUNT_UNMOUNTING_SIGKILL:
 496          case MOUNT_FAILED:
 497                 if (old_state != state)
 498                         automount_send_ready(a, a->tokens, -ENODEV);
 499                 (void) sd_event_source_set_enabled(a->expire_event_source, SD_EVENT_OFF);
 500                 break;
 501         default:
 502                 break;
 503         }
 504
 505         switch (state) {
 506         case MOUNT_DEAD:
 507                 automount_send_ready(a, a->expire_tokens, 0);
 508                 break;
 509          case MOUNT_MOUNTING:
 510          case MOUNT_MOUNTING_DONE:
 511          case MOUNT_MOUNTING_SIGTERM:
 512          case MOUNT_MOUNTING_SIGKILL:
 513          case MOUNT_REMOUNTING_SIGTERM:
 514          case MOUNT_REMOUNTING_SIGKILL:
 515          case MOUNT_UNMOUNTING_SIGTERM:
 516          case MOUNT_UNMOUNTING_SIGKILL:
 517          case MOUNT_FAILED:
 518                 if (old_state != state)
 519                         automount_send_ready(a, a->expire_tokens, -ENODEV);
 520                 break;
 521         default:
 522                 break;
 523         }
 524
 525         return 0;
 526 }
 527
 528 static void automount_enter_waiting(Automount *a) {
 529         _cleanup_close_ int ioctl_fd = -1;
 530         int p[2] = { -1, -1 };
 531         char name[sizeof("systemd-")-1 + DECIMAL_STR_MAX(pid_t) + 1];
 532         char options[sizeof("fd=,pgrp=,minproto=5,maxproto=5,direct")-1
 533                      + DECIMAL_STR_MAX(int) + DECIMAL_STR_MAX(gid_t) + 1];
 534         bool mounted = false;
 535         int r, dev_autofs_fd;
 536         struct stat st;
 537
 538         assert(a);
 539         assert(a->pipe_fd < 0);
 540         assert(a->where);
 541
 542         set_clear(a->tokens);
 543
 544         r = unit_fail_if_symlink(UNIT(a), a->where);
 545         if (r < 0)
 546                 goto fail;
 547
 548         (void) mkdir_p_label(a->where, 0555);
 549
 550         unit_warn_if_dir_nonempty(UNIT(a), a->where);
 551
 552         dev_autofs_fd = open_dev_autofs(UNIT(a)->manager);
 553         if (dev_autofs_fd < 0) {
 554                 r = dev_autofs_fd;
 555                 goto fail;
 556         }
 557
 558         if (pipe2(p, O_NONBLOCK|O_CLOEXEC) < 0) {
 559                 r = -errno;
 560                 goto fail;
 561         }
 562
 563         xsprintf(options, "fd=%i,pgrp="PID_FMT",minproto=5,maxproto=5,direct", p[1], getpgrp());
 564         xsprintf(name, "systemd-"PID_FMT, getpid());
 565         if (mount(name, a->where, "autofs", 0, options) < 0) {
 566                 r = -errno;
 567                 goto fail;
 568         }
 569
 570         mounted = true;
 571
 572         p[1] = safe_close(p[1]);
 573
 574         if (stat(a->where, &st) < 0) {
 575                 r = -errno;
 576                 goto fail;
 577         }
 578
 579         ioctl_fd = open_ioctl_fd(dev_autofs_fd, a->where, st.st_dev);
 580         if (ioctl_fd < 0) {
 581                 r = ioctl_fd;
 582                 goto fail;
 583         }
 584
 585         r = autofs_protocol(dev_autofs_fd, ioctl_fd);
 586         if (r < 0)
 587                 goto fail;
 588
 589         r = autofs_set_timeout(dev_autofs_fd, ioctl_fd, a->timeout_idle_usec);
 590         if (r < 0)
 591                 goto fail;
 592
 593         /* Autofs fun fact:
 594          *
 595          * Unless we close the ioctl fd here, for some weird reason
 596          * the direct mount will not receive events from the
 597          * kernel. */
 598
 599         r = sd_event_add_io(UNIT(a)->manager->event, &a->pipe_event_source, p[0], EPOLLIN, automount_dispatch_io, a);
 600         if (r < 0)
 601                 goto fail;
 602
 603         (void) sd_event_source_set_description(a->pipe_event_source, "automount-io");
 604
 605         a->pipe_fd = p[0];
 606         a->dev_id = st.st_dev;
 607
 608         automount_set_state(a, AUTOMOUNT_WAITING);
 609
 610         return;
 611
 612 fail:
 613         safe_close_pair(p);
 614
 615         if (mounted)
 616                 repeat_unmount(a->where);
 617
 618         log_unit_error_errno(UNIT(a), r, "Failed to initialize automounter: %m");
 619         automount_enter_dead(a, AUTOMOUNT_FAILURE_RESOURCES);
 620 }
 621
 622 static void *expire_thread(void *p) {
 623         struct autofs_dev_ioctl param;
 624         _cleanup_(expire_data_freep) struct expire_data *data = (struct expire_data*)p;
 625         int r;
 626
 627         assert(data->dev_autofs_fd >= 0);
 628         assert(data->ioctl_fd >= 0);
 629
 630         init_autofs_dev_ioctl(&param);
 631         param.ioctlfd = data->ioctl_fd;
 632
 633         do {
 634                 r = ioctl(data->dev_autofs_fd, AUTOFS_DEV_IOCTL_EXPIRE, &param);
 635         } while (r >= 0);
 636
 637         if (errno != EAGAIN)
 638                 log_warning_errno(errno, "Failed to expire automount, ignoring: %m");
 639
 640         return NULL;
 641 }
 642
 643 static int automount_dispatch_expire(sd_event_source *source, usec_t usec, void *userdata) {
 644         Automount *a = AUTOMOUNT(userdata);
 645         _cleanup_(expire_data_freep) struct expire_data *data = NULL;
 646         int r;
 647
 648         assert(a);
 649         assert(source == a->expire_event_source);
 650
 651         data = new0(struct expire_data, 1);
 652         if (!data)
 653                 return log_oom();
 654
 655         data->ioctl_fd = -1;
 656
 657         data->dev_autofs_fd = fcntl(UNIT(a)->manager->dev_autofs_fd, F_DUPFD_CLOEXEC, 3);
 658         if (data->dev_autofs_fd < 0)
 659                 return log_unit_error_errno(UNIT(a), errno, "Failed to duplicate autofs fd: %m");
 660
 661         data->ioctl_fd = open_ioctl_fd(UNIT(a)->manager->dev_autofs_fd, a->where, a->dev_id);
 662         if (data->ioctl_fd < 0)
 663                 return log_unit_error_errno(UNIT(a), data->ioctl_fd, "Couldn't open autofs ioctl fd: %m");
 664
 665         r = asynchronous_job(expire_thread, data);
 666         if (r < 0)
 667                 return log_unit_error_errno(UNIT(a), r, "Failed to start expire job: %m");
 668
 669         data = NULL;
 670
 671         return automount_start_expire(a);
 672 }
 673
 674 static int automount_start_expire(Automount *a) {
 675         int r;
 676         usec_t timeout;
 677
 678         assert(a);
 679
 680         if (a->timeout_idle_usec == 0)
 681                 return 0;
 682
 683         timeout = now(CLOCK_MONOTONIC) + MAX(a->timeout_idle_usec/3, USEC_PER_SEC);
 684
 685         if (a->expire_event_source) {
 686                 r = sd_event_source_set_time(a->expire_event_source, timeout);
 687                 if (r < 0)
 688                         return r;
 689
 690                 return sd_event_source_set_enabled(a->expire_event_source, SD_EVENT_ONESHOT);
 691         }
 692
 693         r = sd_event_add_time(
 694                         UNIT(a)->manager->event,
 695                         &a->expire_event_source,
 696                         CLOCK_MONOTONIC, timeout, 0,
 697                         automount_dispatch_expire, a);
 698         if (r < 0)
 699                 return r;
 700
 701         (void) sd_event_source_set_description(a->expire_event_source, "automount-expire");
 702
 703         return 0;
 704 }
 705
 706 static void automount_enter_runnning(Automount *a) {
 707         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 708         struct stat st;
 709         int r;
 710
 711         assert(a);
 712
 713         /* We don't take mount requests anymore if we are supposed to
 714          * shut down anyway */
 715         if (unit_stop_pending(UNIT(a))) {
 716                 log_unit_debug(UNIT(a), "Suppressing automount request since unit stop is scheduled.");
 717                 automount_send_ready(a, a->tokens, -EHOSTDOWN);
 718                 automount_send_ready(a, a->expire_tokens, -EHOSTDOWN);
 719                 return;
 720         }
 721
 722         mkdir_p_label(a->where, a->directory_mode);
 723
 724         /* Before we do anything, let's see if somebody is playing games with us? */
 725         if (lstat(a->where, &st) < 0) {
 726                 log_unit_warning_errno(UNIT(a), errno, "Failed to stat automount point: %m");
 727                 goto fail;
 728         }
 729
 730         if (!S_ISDIR(st.st_mode) || st.st_dev != a->dev_id)
 731                 log_unit_info(UNIT(a), "Automount point already active?");
 732         else {
 733                 r = manager_add_job(UNIT(a)->manager, JOB_START, UNIT_TRIGGER(UNIT(a)),
 734                                     JOB_REPLACE, true, &error, NULL);
 735                 if (r < 0) {
 736                         log_unit_warning(UNIT(a), "Failed to queue mount startup job: %s", bus_error_message(&error, r));
 737                         goto fail;
 738                 }
 739         }
 740
 741         automount_set_state(a, AUTOMOUNT_RUNNING);
 742         return;
 743
 744 fail:
 745         automount_enter_dead(a, AUTOMOUNT_FAILURE_RESOURCES);
 746 }
 747
 748 static int automount_start(Unit *u) {
 749         Automount *a = AUTOMOUNT(u);
 750
 751         assert(a);
 752         assert(a->state == AUTOMOUNT_DEAD || a->state == AUTOMOUNT_FAILED);
 753
 754         if (path_is_mount_point(a->where, 0) > 0) {
 755                 log_unit_error(u, "Path %s is already a mount point, refusing start.", a->where);
 756                 return -EEXIST;
 757         }
 758
 759         if (UNIT_TRIGGER(u)->load_state != UNIT_LOADED)
 760                 return -ENOENT;
 761
 762         a->result = AUTOMOUNT_SUCCESS;
 763         automount_enter_waiting(a);
 764         return 1;
 765 }
 766
 767 static int automount_stop(Unit *u) {
 768         Automount *a = AUTOMOUNT(u);
 769
 770         assert(a);
 771         assert(a->state == AUTOMOUNT_WAITING || a->state == AUTOMOUNT_RUNNING);
 772
 773         automount_enter_dead(a, AUTOMOUNT_SUCCESS);
 774         return 1;
 775 }
 776
 777 static int automount_serialize(Unit *u, FILE *f, FDSet *fds) {
 778         Automount *a = AUTOMOUNT(u);
 779         void *p;
 780         Iterator i;
 781
 782         assert(a);
 783         assert(f);
 784         assert(fds);
 785
 786         unit_serialize_item(u, f, "state", automount_state_to_string(a->state));
 787         unit_serialize_item(u, f, "result", automount_result_to_string(a->result));
 788         unit_serialize_item_format(u, f, "dev-id", "%u", (unsigned) a->dev_id);
 789
 790         SET_FOREACH(p, a->tokens, i)
 791                 unit_serialize_item_format(u, f, "token", "%u", PTR_TO_UINT(p));
 792         SET_FOREACH(p, a->expire_tokens, i)
 793                 unit_serialize_item_format(u, f, "expire-token", "%u", PTR_TO_UINT(p));
 794
 795         if (a->pipe_fd >= 0) {
 796                 int copy;
 797
 798                 copy = fdset_put_dup(fds, a->pipe_fd);
 799                 if (copy < 0)
 800                         return copy;
 801
 802                 unit_serialize_item_format(u, f, "pipe-fd", "%i", copy);
 803         }
 804
 805         return 0;
 806 }
 807
 808 static int automount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 809         Automount *a = AUTOMOUNT(u);
 810         int r;
 811
 812         assert(a);
 813         assert(fds);
 814
 815         if (streq(key, "state")) {
 816                 AutomountState state;
 817
 818                 state = automount_state_from_string(value);
 819                 if (state < 0)
 820                         log_unit_debug(u, "Failed to parse state value: %s", value);
 821                 else
 822                         a->deserialized_state = state;
 823         } else if (streq(key, "result")) {
 824                 AutomountResult f;
 825
 826                 f = automount_result_from_string(value);
 827                 if (f < 0)
 828                         log_unit_debug(u, "Failed to parse result value: %s", value);
 829                 else if (f != AUTOMOUNT_SUCCESS)
 830                         a->result = f;
 831
 832         } else if (streq(key, "dev-id")) {
 833                 unsigned d;
 834
 835                 if (safe_atou(value, &d) < 0)
 836                         log_unit_debug(u, "Failed to parse dev-id value: %s", value);
 837                 else
 838                         a->dev_id = (unsigned) d;
 839         } else if (streq(key, "token")) {
 840                 unsigned token;
 841
 842                 if (safe_atou(value, &token) < 0)
 843                         log_unit_debug(u, "Failed to parse token value: %s", value);
 844                 else {
 845                         r = set_ensure_allocated(&a->tokens, NULL);
 846                         if (r < 0) {
 847                                 log_oom();
 848                                 return 0;
 849                         }
 850
 851                         r = set_put(a->tokens, UINT_TO_PTR(token));
 852                         if (r < 0)
 853                                 log_unit_error_errno(u, r, "Failed to add token to set: %m");
 854                 }
 855         } else if (streq(key, "expire-token")) {
 856                 unsigned token;
 857
 858                 if (safe_atou(value, &token) < 0)
 859                         log_unit_debug(u, "Failed to parse token value: %s", value);
 860                 else {
 861                         r = set_ensure_allocated(&a->expire_tokens, NULL);
 862                         if (r < 0) {
 863                                 log_oom();
 864                                 return 0;
 865                         }
 866
 867                         r = set_put(a->expire_tokens, UINT_TO_PTR(token));
 868                         if (r < 0)
 869                                 log_unit_error_errno(u, r, "Failed to add expire token to set: %m");
 870                 }
 871         } else if (streq(key, "pipe-fd")) {
 872                 int fd;
 873
 874                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
 875                         log_unit_debug(u, "Failed to parse pipe-fd value: %s", value);
 876                 else {
 877                         safe_close(a->pipe_fd);
 878                         a->pipe_fd = fdset_remove(fds, fd);
 879                 }
 880         } else
 881                 log_unit_debug(u, "Unknown serialization key: %s", key);
 882
 883         return 0;
 884 }
 885
 886 static UnitActiveState automount_active_state(Unit *u) {
 887         assert(u);
 888
 889         return state_translation_table[AUTOMOUNT(u)->state];
 890 }
 891
 892 static const char *automount_sub_state_to_string(Unit *u) {
 893         assert(u);
 894
 895         return automount_state_to_string(AUTOMOUNT(u)->state);
 896 }
 897
 898 static bool automount_check_gc(Unit *u) {
 899         assert(u);
 900
 901         if (!UNIT_TRIGGER(u))
 902                 return false;
 903
 904         return UNIT_VTABLE(UNIT_TRIGGER(u))->check_gc(UNIT_TRIGGER(u));
 905 }
 906
 907 static int automount_dispatch_io(sd_event_source *s, int fd, uint32_t events, void *userdata) {
 908         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 909         union autofs_v5_packet_union packet;
 910         Automount *a = AUTOMOUNT(userdata);
 911         struct stat st;
 912         int r;
 913
 914         assert(a);
 915         assert(fd == a->pipe_fd);
 916
 917         if (events != EPOLLIN) {
 918                 log_unit_error(UNIT(a), "Got invalid poll event %"PRIu32" on pipe (fd=%d)", events, fd);
 919                 goto fail;
 920         }
 921
 922         r = loop_read_exact(a->pipe_fd, &packet, sizeof(packet), true);
 923         if (r < 0) {
 924                 log_unit_error_errno(UNIT(a), r, "Invalid read from pipe: %m");
 925                 goto fail;
 926         }
 927
 928         switch (packet.hdr.type) {
 929
 930         case autofs_ptype_missing_direct:
 931
 932                 if (packet.v5_packet.pid > 0) {
 933                         _cleanup_free_ char *p = NULL;
 934
 935                         get_process_comm(packet.v5_packet.pid, &p);
 936                         log_unit_info(UNIT(a), "Got automount request for %s, triggered by %"PRIu32" (%s)", a->where, packet.v5_packet.pid, strna(p));
 937                 } else
 938                         log_unit_debug(UNIT(a), "Got direct mount request on %s", a->where);
 939
 940                 r = set_ensure_allocated(&a->tokens, NULL);
 941                 if (r < 0) {
 942                         log_unit_error(UNIT(a), "Failed to allocate token set.");
 943                         goto fail;
 944                 }
 945
 946                 r = set_put(a->tokens, UINT_TO_PTR(packet.v5_packet.wait_queue_token));
 947                 if (r < 0) {
 948                         log_unit_error_errno(UNIT(a), r, "Failed to remember token: %m");
 949                         goto fail;
 950                 }
 951
 952                 automount_enter_runnning(a);
 953                 break;
 954
 955         case autofs_ptype_expire_direct:
 956                 log_unit_debug(UNIT(a), "Got direct umount request on %s", a->where);
 957
 958                 (void) sd_event_source_set_enabled(a->expire_event_source, SD_EVENT_OFF);
 959
 960                 r = set_ensure_allocated(&a->expire_tokens, NULL);
 961                 if (r < 0) {
 962                         log_unit_error(UNIT(a), "Failed to allocate token set.");
 963                         goto fail;
 964                 }
 965
 966                 r = set_put(a->expire_tokens, UINT_TO_PTR(packet.v5_packet.wait_queue_token));
 967                 if (r < 0) {
 968                         log_unit_error_errno(UNIT(a), r, "Failed to remember token: %m");
 969                         goto fail;
 970                 }
 971
 972                 /* Before we do anything, let's see if somebody is playing games with us? */
 973                 if (lstat(a->where, &st) < 0) {
 974                         log_unit_warning_errno(UNIT(a), errno, "Failed to stat automount point: %m");
 975                         goto fail;
 976                 }
 977
 978                 if (!S_ISDIR(st.st_mode) || st.st_dev == a->dev_id) {
 979                         log_unit_info(UNIT(a), "Automount point already unmounted?");
 980                         automount_send_ready(a, a->expire_tokens, 0);
 981                         break;
 982                 }
 983
 984                 r = manager_add_job(UNIT(a)->manager, JOB_STOP, UNIT_TRIGGER(UNIT(a)), JOB_REPLACE, true, &error, NULL);
 985                 if (r < 0) {
 986                         log_unit_warning(UNIT(a), "Failed to queue umount startup job: %s", bus_error_message(&error, r));
 987                         goto fail;
 988                 }
 989                 break;
 990
 991         default:
 992                 log_unit_error(UNIT(a), "Received unknown automount request %i", packet.hdr.type);
 993                 break;
 994         }
 995
 996         return 0;
 997
 998 fail:
 999         automount_enter_dead(a, AUTOMOUNT_FAILURE_RESOURCES);
1000         return 0;
1001 }
1002
1003 static void automount_shutdown(Manager *m) {
1004         assert(m);
1005
1006         m->dev_autofs_fd = safe_close(m->dev_autofs_fd);
1007 }
1008
1009 static void automount_reset_failed(Unit *u) {
1010         Automount *a = AUTOMOUNT(u);
1011
1012         assert(a);
1013
1014         if (a->state == AUTOMOUNT_FAILED)
1015                 automount_set_state(a, AUTOMOUNT_DEAD);
1016
1017         a->result = AUTOMOUNT_SUCCESS;
1018 }
1019
1020 static bool automount_supported(void) {
1021         static int supported = -1;
1022
1023         if (supported < 0)
1024                 supported = access("/dev/autofs", F_OK) >= 0;
1025
1026         return supported;
1027 }
1028
1029 static const char* const automount_state_table[_AUTOMOUNT_STATE_MAX] = {
1030         [AUTOMOUNT_DEAD] = "dead",
1031         [AUTOMOUNT_WAITING] = "waiting",
1032         [AUTOMOUNT_RUNNING] = "running",
1033         [AUTOMOUNT_FAILED] = "failed"
1034 };
1035
1036 DEFINE_STRING_TABLE_LOOKUP(automount_state, AutomountState);
1037
1038 static const char* const automount_result_table[_AUTOMOUNT_RESULT_MAX] = {
1039         [AUTOMOUNT_SUCCESS] = "success",
1040         [AUTOMOUNT_FAILURE_RESOURCES] = "resources"
1041 };
1042
1043 DEFINE_STRING_TABLE_LOOKUP(automount_result, AutomountResult);
1044
1045 const UnitVTable automount_vtable = {
1046         .object_size = sizeof(Automount),
1047
1048         .sections =
1049                 "Unit\0"
1050                 "Automount\0"
1051                 "Install\0",
1052
1053         .no_alias = true,
1054         .no_instances = true,
1055
1056         .init = automount_init,
1057         .load = automount_load,
1058         .done = automount_done,
1059
1060         .coldplug = automount_coldplug,
1061
1062         .dump = automount_dump,
1063
1064         .start = automount_start,
1065         .stop = automount_stop,
1066
1067         .serialize = automount_serialize,
1068         .deserialize_item = automount_deserialize_item,
1069
1070         .active_state = automount_active_state,
1071         .sub_state_to_string = automount_sub_state_to_string,
1072
1073         .check_gc = automount_check_gc,
1074
1075         .reset_failed = automount_reset_failed,
1076
1077         .bus_vtable = bus_automount_vtable,
1078
1079         .shutdown = automount_shutdown,
1080         .supported = automount_supported,
1081
1082         .status_message_formats = {
1083                 .finished_start_job = {
1084                         [JOB_DONE]       = "Set up automount %s.",
1085                         [JOB_FAILED]     = "Failed to set up automount %s.",
1086                 },
1087                 .finished_stop_job = {
1088                         [JOB_DONE]       = "Unset automount %s.",
1089                         [JOB_FAILED]     = "Failed to unset automount %s.",
1090                 },
1091         },
1092 };