chiark / gitweb /
f7954871318bf44ed6a963d9dd76f086e973c417
[elogind.git] / 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 };