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 "load-fragment.h"
  36 #include "load-dropin.h"
  37 #include "unit-name.h"
  38 #include "special.h"
  39 #include "label.h"
  40 #include "mkdir.h"
  41 #include "path-util.h"
  42 #include "dbus-automount.h"
  43 #include "bus-util.h"
  44 #include "bus-error.h"
  45
  46 static const UnitActiveState state_translation_table[_AUTOMOUNT_STATE_MAX] = {
  47         [AUTOMOUNT_DEAD] = UNIT_INACTIVE,
  48         [AUTOMOUNT_WAITING] = UNIT_ACTIVE,
  49         [AUTOMOUNT_RUNNING] = UNIT_ACTIVE,
  50         [AUTOMOUNT_FAILED] = UNIT_FAILED
  51 };
  52
  53 static int open_dev_autofs(Manager *m);
  54 static int automount_dispatch_io(sd_event_source *s, int fd, uint32_t events, void *userdata);
  55
  56 static void automount_init(Unit *u) {
  57         Automount *a = AUTOMOUNT(u);
  58
  59         assert(u);
  60         assert(u->load_state == UNIT_STUB);
  61
  62         a->pipe_fd = -1;
  63         a->directory_mode = 0755;
  64         UNIT(a)->ignore_on_isolate = true;
  65 }
  66
  67 static void repeat_unmount(const char *path) {
  68         assert(path);
  69
  70         for (;;) {
  71                 /* If there are multiple mounts on a mount point, this
  72                  * removes them all */
  73
  74                 if (umount2(path, MNT_DETACH) >= 0)
  75                         continue;
  76
  77                 if (errno != EINVAL)
  78                         log_error_errno(errno, "Failed to unmount: %m");
  79
  80                 break;
  81         }
  82 }
  83
  84 static void unmount_autofs(Automount *a) {
  85         assert(a);
  86
  87         if (a->pipe_fd < 0)
  88                 return;
  89
  90         automount_send_ready(a, -EHOSTDOWN);
  91
  92         a->pipe_event_source = sd_event_source_unref(a->pipe_event_source);
  93         a->pipe_fd = safe_close(a->pipe_fd);
  94
  95         /* If we reload/reexecute things we keep the mount point
  96          * around */
  97         if (a->where &&
  98             (UNIT(a)->manager->exit_code != MANAGER_RELOAD &&
  99              UNIT(a)->manager->exit_code != MANAGER_REEXECUTE))
 100                 repeat_unmount(a->where);
 101 }
 102
 103 static void automount_done(Unit *u) {
 104         Automount *a = AUTOMOUNT(u);
 105
 106         assert(a);
 107
 108         unmount_autofs(a);
 109
 110         free(a->where);
 111         a->where = NULL;
 112
 113         set_free(a->tokens);
 114         a->tokens = NULL;
 115 }
 116
 117 static int automount_add_mount_links(Automount *a) {
 118         _cleanup_free_ char *parent = NULL;
 119         int r;
 120
 121         assert(a);
 122
 123         r = path_get_parent(a->where, &parent);
 124         if (r < 0)
 125                 return r;
 126
 127         return unit_require_mounts_for(UNIT(a), parent);
 128 }
 129
 130 static int automount_add_default_dependencies(Automount *a) {
 131         int r;
 132
 133         assert(a);
 134
 135         if (UNIT(a)->manager->running_as != SYSTEMD_SYSTEM)
 136                 return 0;
 137
 138         r = unit_add_two_dependencies_by_name(UNIT(a), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
 139         if (r < 0)
 140                 return r;
 141
 142         return 0;
 143 }
 144
 145 static int automount_verify(Automount *a) {
 146         bool b;
 147         _cleanup_free_ char *e = NULL;
 148         assert(a);
 149
 150         if (UNIT(a)->load_state != UNIT_LOADED)
 151                 return 0;
 152
 153         if (path_equal(a->where, "/")) {
 154                 log_unit_error(UNIT(a)->id, "Cannot have an automount unit for the root directory. Refusing.");
 155                 return -EINVAL;
 156         }
 157
 158         e = unit_name_from_path(a->where, ".automount");
 159         if (!e)
 160                 return -ENOMEM;
 161
 162         b = unit_has_name(UNIT(a), e);
 163
 164         if (!b) {
 165                 log_unit_error(UNIT(a)->id, "%s's Where setting doesn't match unit name. Refusing.", UNIT(a)->id);
 166                 return -EINVAL;
 167         }
 168
 169         return 0;
 170 }
 171
 172 static int automount_load(Unit *u) {
 173         Automount *a = AUTOMOUNT(u);
 174         int r;
 175
 176         assert(u);
 177         assert(u->load_state == UNIT_STUB);
 178
 179         /* Load a .automount file */
 180         r = unit_load_fragment_and_dropin_optional(u);
 181         if (r < 0)
 182                 return r;
 183
 184         if (u->load_state == UNIT_LOADED) {
 185                 Unit *x;
 186
 187                 if (!a->where) {
 188                         a->where = unit_name_to_path(u->id);
 189                         if (!a->where)
 190                                 return -ENOMEM;
 191                 }
 192
 193                 path_kill_slashes(a->where);
 194
 195                 r = unit_load_related_unit(u, ".mount", &x);
 196                 if (r < 0)
 197                         return r;
 198
 199                 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, x, true);
 200                 if (r < 0)
 201                         return r;
 202
 203                 r = automount_add_mount_links(a);
 204                 if (r < 0)
 205                         return r;
 206
 207                 if (UNIT(a)->default_dependencies) {
 208                         r = automount_add_default_dependencies(a);
 209                         if (r < 0)
 210                                 return r;
 211                 }
 212         }
 213
 214         return automount_verify(a);
 215 }
 216
 217 static void automount_set_state(Automount *a, AutomountState state) {
 218         AutomountState old_state;
 219         assert(a);
 220
 221         old_state = a->state;
 222         a->state = state;
 223
 224         if (state != AUTOMOUNT_WAITING &&
 225             state != AUTOMOUNT_RUNNING)
 226                 unmount_autofs(a);
 227
 228         if (state != old_state)
 229                 log_unit_debug(UNIT(a)->id,
 230                                "%s changed %s -> %s",
 231                                UNIT(a)->id,
 232                                automount_state_to_string(old_state),
 233                                automount_state_to_string(state));
 234
 235         unit_notify(UNIT(a), state_translation_table[old_state], state_translation_table[state], true);
 236 }
 237
 238 static int automount_coldplug(Unit *u) {
 239         Automount *a = AUTOMOUNT(u);
 240         int r;
 241
 242         assert(a);
 243         assert(a->state == AUTOMOUNT_DEAD);
 244
 245         if (a->deserialized_state != a->state) {
 246
 247                 r = open_dev_autofs(u->manager);
 248                 if (r < 0)
 249                         return r;
 250
 251                 if (a->deserialized_state == AUTOMOUNT_WAITING ||
 252                     a->deserialized_state == AUTOMOUNT_RUNNING) {
 253
 254                         assert(a->pipe_fd >= 0);
 255
 256                         r = sd_event_add_io(u->manager->event, &a->pipe_event_source, a->pipe_fd, EPOLLIN, automount_dispatch_io, u);
 257                         if (r < 0)
 258                                 return r;
 259                 }
 260
 261                 automount_set_state(a, a->deserialized_state);
 262         }
 263
 264         return 0;
 265 }
 266
 267 static void automount_dump(Unit *u, FILE *f, const char *prefix) {
 268         Automount *a = AUTOMOUNT(u);
 269
 270         assert(a);
 271
 272         fprintf(f,
 273                 "%sAutomount State: %s\n"
 274                 "%sResult: %s\n"
 275                 "%sWhere: %s\n"
 276                 "%sDirectoryMode: %04o\n",
 277                 prefix, automount_state_to_string(a->state),
 278                 prefix, automount_result_to_string(a->result),
 279                 prefix, a->where,
 280                 prefix, a->directory_mode);
 281 }
 282
 283 static void automount_enter_dead(Automount *a, AutomountResult f) {
 284         assert(a);
 285
 286         if (f != AUTOMOUNT_SUCCESS)
 287                 a->result = f;
 288
 289         automount_set_state(a, a->result != AUTOMOUNT_SUCCESS ? AUTOMOUNT_FAILED : AUTOMOUNT_DEAD);
 290 }
 291
 292 static int open_dev_autofs(Manager *m) {
 293         struct autofs_dev_ioctl param;
 294
 295         assert(m);
 296
 297         if (m->dev_autofs_fd >= 0)
 298                 return m->dev_autofs_fd;
 299
 300         label_fix("/dev/autofs", false, false);
 301
 302         m->dev_autofs_fd = open("/dev/autofs", O_CLOEXEC|O_RDONLY);
 303         if (m->dev_autofs_fd < 0)
 304                 return log_error_errno(errno, "Failed to open /dev/autofs: %m");
 305
 306         init_autofs_dev_ioctl(&param);
 307         if (ioctl(m->dev_autofs_fd, AUTOFS_DEV_IOCTL_VERSION, &param) < 0) {
 308                 m->dev_autofs_fd = safe_close(m->dev_autofs_fd);
 309                 return -errno;
 310         }
 311
 312         log_debug("Autofs kernel version %i.%i", param.ver_major, param.ver_minor);
 313
 314         return m->dev_autofs_fd;
 315 }
 316
 317 static int open_ioctl_fd(int dev_autofs_fd, const char *where, dev_t devid) {
 318         struct autofs_dev_ioctl *param;
 319         size_t l;
 320
 321         assert(dev_autofs_fd >= 0);
 322         assert(where);
 323
 324         l = sizeof(struct autofs_dev_ioctl) + strlen(where) + 1;
 325         param = alloca(l);
 326
 327         init_autofs_dev_ioctl(param);
 328         param->size = l;
 329         param->ioctlfd = -1;
 330         param->openmount.devid = devid;
 331         strcpy(param->path, where);
 332
 333         if (ioctl(dev_autofs_fd, AUTOFS_DEV_IOCTL_OPENMOUNT, param) < 0)
 334                 return -errno;
 335
 336         if (param->ioctlfd < 0)
 337                 return -EIO;
 338
 339         fd_cloexec(param->ioctlfd, true);
 340         return param->ioctlfd;
 341 }
 342
 343 static int autofs_protocol(int dev_autofs_fd, int ioctl_fd) {
 344         uint32_t major, minor;
 345         struct autofs_dev_ioctl param;
 346
 347         assert(dev_autofs_fd >= 0);
 348         assert(ioctl_fd >= 0);
 349
 350         init_autofs_dev_ioctl(&param);
 351         param.ioctlfd = ioctl_fd;
 352
 353         if (ioctl(dev_autofs_fd, AUTOFS_DEV_IOCTL_PROTOVER, &param) < 0)
 354                 return -errno;
 355
 356         major = param.protover.version;
 357
 358         init_autofs_dev_ioctl(&param);
 359         param.ioctlfd = ioctl_fd;
 360
 361         if (ioctl(dev_autofs_fd, AUTOFS_DEV_IOCTL_PROTOSUBVER, &param) < 0)
 362                 return -errno;
 363
 364         minor = param.protosubver.sub_version;
 365
 366         log_debug("Autofs protocol version %i.%i", major, minor);
 367         return 0;
 368 }
 369
 370 static int autofs_set_timeout(int dev_autofs_fd, int ioctl_fd, time_t sec) {
 371         struct autofs_dev_ioctl param;
 372
 373         assert(dev_autofs_fd >= 0);
 374         assert(ioctl_fd >= 0);
 375
 376         init_autofs_dev_ioctl(&param);
 377         param.ioctlfd = ioctl_fd;
 378         param.timeout.timeout = sec;
 379
 380         if (ioctl(dev_autofs_fd, AUTOFS_DEV_IOCTL_TIMEOUT, &param) < 0)
 381                 return -errno;
 382
 383         return 0;
 384 }
 385
 386 static int autofs_send_ready(int dev_autofs_fd, int ioctl_fd, uint32_t token, int status) {
 387         struct autofs_dev_ioctl param;
 388
 389         assert(dev_autofs_fd >= 0);
 390         assert(ioctl_fd >= 0);
 391
 392         init_autofs_dev_ioctl(&param);
 393         param.ioctlfd = ioctl_fd;
 394
 395         if (status) {
 396                 param.fail.token = token;
 397                 param.fail.status = status;
 398         } else
 399                 param.ready.token = token;
 400
 401         if (ioctl(dev_autofs_fd, status ? AUTOFS_DEV_IOCTL_FAIL : AUTOFS_DEV_IOCTL_READY, &param) < 0)
 402                 return -errno;
 403
 404         return 0;
 405 }
 406
 407 int automount_send_ready(Automount *a, int status) {
 408         _cleanup_close_ int ioctl_fd = -1;
 409         unsigned token;
 410         int r;
 411
 412         assert(a);
 413         assert(status <= 0);
 414
 415         if (set_isempty(a->tokens))
 416                 return 0;
 417
 418         ioctl_fd = open_ioctl_fd(UNIT(a)->manager->dev_autofs_fd, a->where, a->dev_id);
 419         if (ioctl_fd < 0)
 420                 return ioctl_fd;
 421
 422         if (status)
 423                 log_unit_debug_errno(UNIT(a)->id, status, "Sending failure: %m");
 424         else
 425                 log_unit_debug(UNIT(a)->id, "Sending success.");
 426
 427         r = 0;
 428
 429         /* Autofs thankfully does not hand out 0 as a token */
 430         while ((token = PTR_TO_UINT(set_steal_first(a->tokens)))) {
 431                 int k;
 432
 433                 /* Autofs fun fact II:
 434                  *
 435                  * if you pass a positive status code here, the kernel will
 436                  * freeze! Yay! */
 437
 438                 k = autofs_send_ready(UNIT(a)->manager->dev_autofs_fd,
 439                                       ioctl_fd,
 440                                       token,
 441                                       status);
 442                 if (k < 0)
 443                         r = k;
 444         }
 445
 446         return r;
 447 }
 448
 449 static void automount_enter_waiting(Automount *a) {
 450         _cleanup_close_ int ioctl_fd = -1;
 451         int p[2] = { -1, -1 };
 452         char name[32], options[128];
 453         bool mounted = false;
 454         int r, dev_autofs_fd;
 455         struct stat st;
 456
 457         assert(a);
 458         assert(a->pipe_fd < 0);
 459         assert(a->where);
 460
 461         if (a->tokens)
 462                 set_clear(a->tokens);
 463
 464         dev_autofs_fd = open_dev_autofs(UNIT(a)->manager);
 465         if (dev_autofs_fd < 0) {
 466                 r = dev_autofs_fd;
 467                 goto fail;
 468         }
 469
 470         /* We knowingly ignore the results of this call */
 471         mkdir_p_label(a->where, 0555);
 472
 473         warn_if_dir_nonempty(a->meta.id, a->where);
 474
 475         if (pipe2(p, O_NONBLOCK|O_CLOEXEC) < 0) {
 476                 r = -errno;
 477                 goto fail;
 478         }
 479
 480         snprintf(options, sizeof(options), "fd=%i,pgrp=%u,minproto=5,maxproto=5,direct", p[1], (unsigned) getpgrp());
 481         char_array_0(options);
 482
 483         snprintf(name, sizeof(name), "systemd-%u", (unsigned) getpid());
 484         char_array_0(name);
 485
 486         if (mount(name, a->where, "autofs", 0, options) < 0) {
 487                 r = -errno;
 488                 goto fail;
 489         }
 490
 491         mounted = true;
 492
 493         p[1] = safe_close(p[1]);
 494
 495         if (stat(a->where, &st) < 0) {
 496                 r = -errno;
 497                 goto fail;
 498         }
 499
 500         ioctl_fd = open_ioctl_fd(dev_autofs_fd, a->where, st.st_dev);
 501         if (ioctl_fd < 0) {
 502                 r = ioctl_fd;
 503                 goto fail;
 504         }
 505
 506         r = autofs_protocol(dev_autofs_fd, ioctl_fd);
 507         if (r < 0)
 508                 goto fail;
 509
 510         r = autofs_set_timeout(dev_autofs_fd, ioctl_fd, 300);
 511         if (r < 0)
 512                 goto fail;
 513
 514         /* Autofs fun fact:
 515          *
 516          * Unless we close the ioctl fd here, for some weird reason
 517          * the direct mount will not receive events from the
 518          * kernel. */
 519
 520         r = sd_event_add_io(UNIT(a)->manager->event, &a->pipe_event_source, p[0], EPOLLIN, automount_dispatch_io, a);
 521         if (r < 0)
 522                 goto fail;
 523
 524         a->pipe_fd = p[0];
 525         a->dev_id = st.st_dev;
 526
 527         automount_set_state(a, AUTOMOUNT_WAITING);
 528
 529         return;
 530
 531 fail:
 532         safe_close_pair(p);
 533
 534         if (mounted)
 535                 repeat_unmount(a->where);
 536
 537         log_unit_error(UNIT(a)->id,
 538                        "Failed to initialize automounter: %s", strerror(-r));
 539         automount_enter_dead(a, AUTOMOUNT_FAILURE_RESOURCES);
 540 }
 541
 542 static void automount_enter_runnning(Automount *a) {
 543         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 544         struct stat st;
 545         int r;
 546
 547         assert(a);
 548
 549         /* We don't take mount requests anymore if we are supposed to
 550          * shut down anyway */
 551         if (unit_stop_pending(UNIT(a))) {
 552                 log_unit_debug(UNIT(a)->id,
 553                                "Suppressing automount request on %s since unit stop is scheduled.", UNIT(a)->id);
 554                 automount_send_ready(a, -EHOSTDOWN);
 555                 return;
 556         }
 557
 558         mkdir_p_label(a->where, a->directory_mode);
 559
 560         /* Before we do anything, let's see if somebody is playing games with us? */
 561         if (lstat(a->where, &st) < 0) {
 562                 log_unit_warning(UNIT(a)->id,
 563                                  "%s failed to stat automount point: %m", UNIT(a)->id);
 564                 goto fail;
 565         }
 566
 567         if (!S_ISDIR(st.st_mode) || st.st_dev != a->dev_id)
 568                 log_unit_info(UNIT(a)->id,
 569                               "%s's automount point already active?", UNIT(a)->id);
 570         else {
 571                 r = manager_add_job(UNIT(a)->manager, JOB_START, UNIT_TRIGGER(UNIT(a)),
 572                                     JOB_REPLACE, true, &error, NULL);
 573                 if (r < 0) {
 574                         log_unit_warning(UNIT(a)->id,
 575                                          "%s failed to queue mount startup job: %s",
 576                                          UNIT(a)->id, bus_error_message(&error, r));
 577                         goto fail;
 578                 }
 579         }
 580
 581         automount_set_state(a, AUTOMOUNT_RUNNING);
 582         return;
 583
 584 fail:
 585         automount_enter_dead(a, AUTOMOUNT_FAILURE_RESOURCES);
 586 }
 587
 588 static int automount_start(Unit *u) {
 589         Automount *a = AUTOMOUNT(u);
 590
 591         assert(a);
 592         assert(a->state == AUTOMOUNT_DEAD || a->state == AUTOMOUNT_FAILED);
 593
 594         if (path_is_mount_point(a->where, false)) {
 595                 log_unit_error(u->id,
 596                                "Path %s is already a mount point, refusing start for %s",
 597                                a->where, u->id);
 598                 return -EEXIST;
 599         }
 600
 601         if (UNIT_TRIGGER(u)->load_state != UNIT_LOADED)
 602                 return -ENOENT;
 603
 604         a->result = AUTOMOUNT_SUCCESS;
 605         automount_enter_waiting(a);
 606         return 0;
 607 }
 608
 609 static int automount_stop(Unit *u) {
 610         Automount *a = AUTOMOUNT(u);
 611
 612         assert(a);
 613         assert(a->state == AUTOMOUNT_WAITING || a->state == AUTOMOUNT_RUNNING);
 614
 615         automount_enter_dead(a, AUTOMOUNT_SUCCESS);
 616         return 0;
 617 }
 618
 619 static int automount_serialize(Unit *u, FILE *f, FDSet *fds) {
 620         Automount *a = AUTOMOUNT(u);
 621         void *p;
 622         Iterator i;
 623
 624         assert(a);
 625         assert(f);
 626         assert(fds);
 627
 628         unit_serialize_item(u, f, "state", automount_state_to_string(a->state));
 629         unit_serialize_item(u, f, "result", automount_result_to_string(a->result));
 630         unit_serialize_item_format(u, f, "dev-id", "%u", (unsigned) a->dev_id);
 631
 632         SET_FOREACH(p, a->tokens, i)
 633                 unit_serialize_item_format(u, f, "token", "%u", PTR_TO_UINT(p));
 634
 635         if (a->pipe_fd >= 0) {
 636                 int copy;
 637
 638                 copy = fdset_put_dup(fds, a->pipe_fd);
 639                 if (copy < 0)
 640                         return copy;
 641
 642                 unit_serialize_item_format(u, f, "pipe-fd", "%i", copy);
 643         }
 644
 645         return 0;
 646 }
 647
 648 static int automount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 649         Automount *a = AUTOMOUNT(u);
 650         int r;
 651
 652         assert(a);
 653         assert(fds);
 654
 655         if (streq(key, "state")) {
 656                 AutomountState state;
 657
 658                 state = automount_state_from_string(value);
 659                 if (state < 0)
 660                         log_unit_debug(u->id, "Failed to parse state value %s", value);
 661                 else
 662                         a->deserialized_state = state;
 663         } else if (streq(key, "result")) {
 664                 AutomountResult f;
 665
 666                 f = automount_result_from_string(value);
 667                 if (f < 0)
 668                         log_unit_debug(u->id, "Failed to parse result value %s", value);
 669                 else if (f != AUTOMOUNT_SUCCESS)
 670                         a->result = f;
 671
 672         } else if (streq(key, "dev-id")) {
 673                 unsigned d;
 674
 675                 if (safe_atou(value, &d) < 0)
 676                         log_unit_debug(u->id, "Failed to parse dev-id value %s", value);
 677                 else
 678                         a->dev_id = (unsigned) d;
 679         } else if (streq(key, "token")) {
 680                 unsigned token;
 681
 682                 if (safe_atou(value, &token) < 0)
 683                         log_unit_debug(u->id, "Failed to parse token value %s", value);
 684                 else {
 685                         if (!a->tokens)
 686                                 if (!(a->tokens = set_new(NULL)))
 687                                         return -ENOMEM;
 688
 689                         r = set_put(a->tokens, UINT_TO_PTR(token));
 690                         if (r < 0)
 691                                 return r;
 692                 }
 693         } else if (streq(key, "pipe-fd")) {
 694                 int fd;
 695
 696                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
 697                         log_unit_debug(u->id, "Failed to parse pipe-fd value %s", value);
 698                 else {
 699                         safe_close(a->pipe_fd);
 700                         a->pipe_fd = fdset_remove(fds, fd);
 701                 }
 702         } else
 703                 log_unit_debug(u->id, "Unknown serialization key '%s'", key);
 704
 705         return 0;
 706 }
 707
 708 static UnitActiveState automount_active_state(Unit *u) {
 709         assert(u);
 710
 711         return state_translation_table[AUTOMOUNT(u)->state];
 712 }
 713
 714 static const char *automount_sub_state_to_string(Unit *u) {
 715         assert(u);
 716
 717         return automount_state_to_string(AUTOMOUNT(u)->state);
 718 }
 719
 720 static bool automount_check_gc(Unit *u) {
 721         assert(u);
 722
 723         if (!UNIT_TRIGGER(u))
 724                 return false;
 725
 726         return UNIT_VTABLE(UNIT_TRIGGER(u))->check_gc(UNIT_TRIGGER(u));
 727 }
 728
 729 static int automount_dispatch_io(sd_event_source *s, int fd, uint32_t events, void *userdata) {
 730         union autofs_v5_packet_union packet;
 731         Automount *a = AUTOMOUNT(userdata);
 732         ssize_t l;
 733         int r;
 734
 735         assert(a);
 736         assert(fd == a->pipe_fd);
 737
 738         if (events != EPOLLIN) {
 739                 log_unit_error(UNIT(a)->id, "Got invalid poll event on pipe.");
 740                 goto fail;
 741         }
 742
 743         l = loop_read(a->pipe_fd, &packet, sizeof(packet), true);
 744         if (l != sizeof(packet)) {
 745                 if (l < 0)
 746                         log_unit_error_errno(UNIT(a)->id, l, "Invalid read from pipe: %m");
 747                 else
 748                         log_unit_error(UNIT(a)->id, "Invalid read from pipe: short read");
 749                 goto fail;
 750         }
 751
 752         switch (packet.hdr.type) {
 753
 754         case autofs_ptype_missing_direct:
 755
 756                 if (packet.v5_packet.pid > 0) {
 757                         _cleanup_free_ char *p = NULL;
 758
 759                         get_process_comm(packet.v5_packet.pid, &p);
 760                         log_unit_info(UNIT(a)->id,
 761                                        "Got automount request for %s, triggered by "PID_FMT" (%s)",
 762                                        a->where, packet.v5_packet.pid, strna(p));
 763                 } else
 764                         log_unit_debug(UNIT(a)->id, "Got direct mount request on %s", a->where);
 765
 766                 r = set_ensure_allocated(&a->tokens, NULL);
 767                 if (r < 0) {
 768                         log_unit_error(UNIT(a)->id, "Failed to allocate token set.");
 769                         goto fail;
 770                 }
 771
 772                 r = set_put(a->tokens, UINT_TO_PTR(packet.v5_packet.wait_queue_token));
 773                 if (r < 0) {
 774                         log_unit_error_errno(UNIT(a)->id, r, "Failed to remember token: %m");
 775                         goto fail;
 776                 }
 777
 778                 automount_enter_runnning(a);
 779                 break;
 780
 781         default:
 782                 log_unit_error(UNIT(a)->id, "Received unknown automount request %i", packet.hdr.type);
 783                 break;
 784         }
 785
 786         return 0;
 787
 788 fail:
 789         automount_enter_dead(a, AUTOMOUNT_FAILURE_RESOURCES);
 790         return 0;
 791 }
 792
 793 static void automount_shutdown(Manager *m) {
 794         assert(m);
 795
 796         m->dev_autofs_fd = safe_close(m->dev_autofs_fd);
 797 }
 798
 799 static void automount_reset_failed(Unit *u) {
 800         Automount *a = AUTOMOUNT(u);
 801
 802         assert(a);
 803
 804         if (a->state == AUTOMOUNT_FAILED)
 805                 automount_set_state(a, AUTOMOUNT_DEAD);
 806
 807         a->result = AUTOMOUNT_SUCCESS;
 808 }
 809
 810 static const char* const automount_state_table[_AUTOMOUNT_STATE_MAX] = {
 811         [AUTOMOUNT_DEAD] = "dead",
 812         [AUTOMOUNT_WAITING] = "waiting",
 813         [AUTOMOUNT_RUNNING] = "running",
 814         [AUTOMOUNT_FAILED] = "failed"
 815 };
 816
 817 DEFINE_STRING_TABLE_LOOKUP(automount_state, AutomountState);
 818
 819 static const char* const automount_result_table[_AUTOMOUNT_RESULT_MAX] = {
 820         [AUTOMOUNT_SUCCESS] = "success",
 821         [AUTOMOUNT_FAILURE_RESOURCES] = "resources"
 822 };
 823
 824 DEFINE_STRING_TABLE_LOOKUP(automount_result, AutomountResult);
 825
 826 const UnitVTable automount_vtable = {
 827         .object_size = sizeof(Automount),
 828
 829         .sections =
 830                 "Unit\0"
 831                 "Automount\0"
 832                 "Install\0",
 833
 834         .no_alias = true,
 835         .no_instances = true,
 836
 837         .init = automount_init,
 838         .load = automount_load,
 839         .done = automount_done,
 840
 841         .coldplug = automount_coldplug,
 842
 843         .dump = automount_dump,
 844
 845         .start = automount_start,
 846         .stop = automount_stop,
 847
 848         .serialize = automount_serialize,
 849         .deserialize_item = automount_deserialize_item,
 850
 851         .active_state = automount_active_state,
 852         .sub_state_to_string = automount_sub_state_to_string,
 853
 854         .check_gc = automount_check_gc,
 855
 856         .reset_failed = automount_reset_failed,
 857
 858         .bus_interface = "org.freedesktop.systemd1.Automount",
 859         .bus_vtable = bus_automount_vtable,
 860
 861         .shutdown = automount_shutdown,
 862
 863         .status_message_formats = {
 864                 .finished_start_job = {
 865                         [JOB_DONE]       = "Set up automount %s.",
 866                         [JOB_FAILED]     = "Failed to set up automount %s.",
 867                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
 868                 },
 869                 .finished_stop_job = {
 870                         [JOB_DONE]       = "Unset automount %s.",
 871                         [JOB_FAILED]     = "Failed to unset automount %s.",
 872                 },
 873         },
 874 };