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