1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
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.
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.
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/>.
24 #include <sys/mount.h>
27 #include <sys/epoll.h>
29 #include <linux/auto_fs4.h>
30 #include <linux/auto_dev-ioctl.h>
33 #include "automount.h"
35 #include "unit-name.h"
39 #include "path-util.h"
40 #include "dbus-automount.h"
42 #include "bus-error.h"
43 #include "formats-util.h"
44 #include "process-util.h"
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
59 static inline void expire_data_free(struct expire_data
*data
) {
63 safe_close(data
->dev_autofs_fd
);
64 safe_close(data
->ioctl_fd
);
68 DEFINE_TRIVIAL_CLEANUP_FUNC(struct expire_data
*, expire_data_free
);
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
);
73 static void automount_init(Unit
*u
) {
74 Automount
*a
= AUTOMOUNT(u
);
77 assert(u
->load_state
== UNIT_STUB
);
80 a
->directory_mode
= 0755;
81 UNIT(a
)->ignore_on_isolate
= true;
84 static void repeat_unmount(const char *path
) {
88 /* If there are multiple mounts on a mount point, this
91 if (umount2(path
, MNT_DETACH
) >= 0)
95 log_error_errno(errno
, "Failed to unmount: %m");
101 static int automount_send_ready(Automount
*a
, Set
*tokens
, int status
);
103 static void unmount_autofs(Automount
*a
) {
109 automount_send_ready(a
, a
->tokens
, -EHOSTDOWN
);
110 automount_send_ready(a
, a
->expire_tokens
, -EHOSTDOWN
);
112 a
->pipe_event_source
= sd_event_source_unref(a
->pipe_event_source
);
113 a
->pipe_fd
= safe_close(a
->pipe_fd
);
115 /* If we reload/reexecute things we keep the mount point
118 (UNIT(a
)->manager
->exit_code
!= MANAGER_RELOAD
&&
119 UNIT(a
)->manager
->exit_code
!= MANAGER_REEXECUTE
))
120 repeat_unmount(a
->where
);
123 static void automount_done(Unit
*u
) {
124 Automount
*a
= AUTOMOUNT(u
);
130 a
->where
= mfree(a
->where
);
132 a
->tokens
= set_free(a
->tokens
);
133 a
->expire_tokens
= set_free(a
->expire_tokens
);
135 a
->expire_event_source
= sd_event_source_unref(a
->expire_event_source
);
138 static int automount_add_mount_links(Automount
*a
) {
139 _cleanup_free_
char *parent
= NULL
;
144 r
= path_get_parent(a
->where
, &parent
);
148 return unit_require_mounts_for(UNIT(a
), parent
);
151 static int automount_add_default_dependencies(Automount
*a
) {
156 if (UNIT(a
)->manager
->running_as
!= MANAGER_SYSTEM
)
159 r
= unit_add_two_dependencies_by_name(UNIT(a
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_UMOUNT_TARGET
, NULL
, true);
166 static int automount_verify(Automount
*a
) {
167 _cleanup_free_
char *e
= NULL
;
172 if (UNIT(a
)->load_state
!= UNIT_LOADED
)
175 if (path_equal(a
->where
, "/")) {
176 log_unit_error(UNIT(a
), "Cannot have an automount unit for the root directory. Refusing.");
180 r
= unit_name_from_path(a
->where
, ".automount", &e
);
182 return log_unit_error(UNIT(a
), "Failed to generate unit name from path: %m");
184 if (!unit_has_name(UNIT(a
), e
)) {
185 log_unit_error(UNIT(a
), "Where= setting doesn't match unit name. Refusing.");
192 static int automount_load(Unit
*u
) {
193 Automount
*a
= AUTOMOUNT(u
);
197 assert(u
->load_state
== UNIT_STUB
);
199 /* Load a .automount file */
200 r
= unit_load_fragment_and_dropin_optional(u
);
204 if (u
->load_state
== UNIT_LOADED
) {
208 r
= unit_name_to_path(u
->id
, &a
->where
);
213 path_kill_slashes(a
->where
);
215 r
= unit_load_related_unit(u
, ".mount", &x
);
219 r
= unit_add_two_dependencies(u
, UNIT_BEFORE
, UNIT_TRIGGERS
, x
, true);
223 r
= automount_add_mount_links(a
);
227 if (UNIT(a
)->default_dependencies
) {
228 r
= automount_add_default_dependencies(a
);
234 return automount_verify(a
);
237 static void automount_set_state(Automount
*a
, AutomountState state
) {
238 AutomountState old_state
;
241 old_state
= a
->state
;
244 if (state
!= AUTOMOUNT_WAITING
&&
245 state
!= AUTOMOUNT_RUNNING
)
248 if (state
!= old_state
)
249 log_unit_debug(UNIT(a
), "Changed %s -> %s", automount_state_to_string(old_state
), automount_state_to_string(state
));
251 unit_notify(UNIT(a
), state_translation_table
[old_state
], state_translation_table
[state
], true);
254 static int automount_coldplug(Unit
*u
) {
255 Automount
*a
= AUTOMOUNT(u
);
259 assert(a
->state
== AUTOMOUNT_DEAD
);
261 if (a
->deserialized_state
!= a
->state
) {
263 r
= open_dev_autofs(u
->manager
);
267 if (a
->deserialized_state
== AUTOMOUNT_WAITING
||
268 a
->deserialized_state
== AUTOMOUNT_RUNNING
) {
269 assert(a
->pipe_fd
>= 0);
271 r
= sd_event_add_io(u
->manager
->event
, &a
->pipe_event_source
, a
->pipe_fd
, EPOLLIN
, automount_dispatch_io
, u
);
275 (void) sd_event_source_set_description(a
->pipe_event_source
, "automount-io");
278 automount_set_state(a
, a
->deserialized_state
);
284 static void automount_dump(Unit
*u
, FILE *f
, const char *prefix
) {
285 char time_string
[FORMAT_TIMESPAN_MAX
];
286 Automount
*a
= AUTOMOUNT(u
);
291 "%sAutomount State: %s\n"
294 "%sDirectoryMode: %04o\n"
295 "%sTimeoutIdleUSec: %s\n",
296 prefix
, automount_state_to_string(a
->state
),
297 prefix
, automount_result_to_string(a
->result
),
299 prefix
, a
->directory_mode
,
300 prefix
, format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, a
->timeout_idle_usec
, USEC_PER_SEC
));
303 static void automount_enter_dead(Automount
*a
, AutomountResult f
) {
306 if (f
!= AUTOMOUNT_SUCCESS
)
309 automount_set_state(a
, a
->result
!= AUTOMOUNT_SUCCESS
? AUTOMOUNT_FAILED
: AUTOMOUNT_DEAD
);
312 static int open_dev_autofs(Manager
*m
) {
313 struct autofs_dev_ioctl param
;
317 if (m
->dev_autofs_fd
>= 0)
318 return m
->dev_autofs_fd
;
320 label_fix("/dev/autofs", false, false);
322 m
->dev_autofs_fd
= open("/dev/autofs", O_CLOEXEC
|O_RDONLY
);
323 if (m
->dev_autofs_fd
< 0)
324 return log_error_errno(errno
, "Failed to open /dev/autofs: %m");
326 init_autofs_dev_ioctl(¶m
);
327 if (ioctl(m
->dev_autofs_fd
, AUTOFS_DEV_IOCTL_VERSION
, ¶m
) < 0) {
328 m
->dev_autofs_fd
= safe_close(m
->dev_autofs_fd
);
332 log_debug("Autofs kernel version %i.%i", param
.ver_major
, param
.ver_minor
);
334 return m
->dev_autofs_fd
;
337 static int open_ioctl_fd(int dev_autofs_fd
, const char *where
, dev_t devid
) {
338 struct autofs_dev_ioctl
*param
;
341 assert(dev_autofs_fd
>= 0);
344 l
= sizeof(struct autofs_dev_ioctl
) + strlen(where
) + 1;
347 init_autofs_dev_ioctl(param
);
350 param
->openmount
.devid
= devid
;
351 strcpy(param
->path
, where
);
353 if (ioctl(dev_autofs_fd
, AUTOFS_DEV_IOCTL_OPENMOUNT
, param
) < 0)
356 if (param
->ioctlfd
< 0)
359 (void) fd_cloexec(param
->ioctlfd
, true);
360 return param
->ioctlfd
;
363 static int autofs_protocol(int dev_autofs_fd
, int ioctl_fd
) {
364 uint32_t major
, minor
;
365 struct autofs_dev_ioctl param
;
367 assert(dev_autofs_fd
>= 0);
368 assert(ioctl_fd
>= 0);
370 init_autofs_dev_ioctl(¶m
);
371 param
.ioctlfd
= ioctl_fd
;
373 if (ioctl(dev_autofs_fd
, AUTOFS_DEV_IOCTL_PROTOVER
, ¶m
) < 0)
376 major
= param
.protover
.version
;
378 init_autofs_dev_ioctl(¶m
);
379 param
.ioctlfd
= ioctl_fd
;
381 if (ioctl(dev_autofs_fd
, AUTOFS_DEV_IOCTL_PROTOSUBVER
, ¶m
) < 0)
384 minor
= param
.protosubver
.sub_version
;
386 log_debug("Autofs protocol version %i.%i", major
, minor
);
390 static int autofs_set_timeout(int dev_autofs_fd
, int ioctl_fd
, usec_t usec
) {
391 struct autofs_dev_ioctl param
;
393 assert(dev_autofs_fd
>= 0);
394 assert(ioctl_fd
>= 0);
396 init_autofs_dev_ioctl(¶m
);
397 param
.ioctlfd
= ioctl_fd
;
399 /* Convert to seconds, rounding up. */
400 param
.timeout
.timeout
= (usec
+ USEC_PER_SEC
- 1) / USEC_PER_SEC
;
402 if (ioctl(dev_autofs_fd
, AUTOFS_DEV_IOCTL_TIMEOUT
, ¶m
) < 0)
408 static int autofs_send_ready(int dev_autofs_fd
, int ioctl_fd
, uint32_t token
, int status
) {
409 struct autofs_dev_ioctl param
;
411 assert(dev_autofs_fd
>= 0);
412 assert(ioctl_fd
>= 0);
414 init_autofs_dev_ioctl(¶m
);
415 param
.ioctlfd
= ioctl_fd
;
418 param
.fail
.token
= token
;
419 param
.fail
.status
= status
;
421 param
.ready
.token
= token
;
423 if (ioctl(dev_autofs_fd
, status
? AUTOFS_DEV_IOCTL_FAIL
: AUTOFS_DEV_IOCTL_READY
, ¶m
) < 0)
429 static int automount_send_ready(Automount
*a
, Set
*tokens
, int status
) {
430 _cleanup_close_
int ioctl_fd
= -1;
437 if (set_isempty(tokens
))
440 ioctl_fd
= open_ioctl_fd(UNIT(a
)->manager
->dev_autofs_fd
, a
->where
, a
->dev_id
);
445 log_unit_debug_errno(UNIT(a
), status
, "Sending failure: %m");
447 log_unit_debug(UNIT(a
), "Sending success.");
451 /* Autofs thankfully does not hand out 0 as a token */
452 while ((token
= PTR_TO_UINT(set_steal_first(tokens
)))) {
455 /* Autofs fun fact II:
457 * if you pass a positive status code here, the kernel will
460 k
= autofs_send_ready(UNIT(a
)->manager
->dev_autofs_fd
,
471 static int automount_start_expire(Automount
*a
);
473 int automount_update_mount(Automount
*a
, MountState old_state
, MountState state
) {
480 case MOUNT_REMOUNTING
:
481 automount_send_ready(a
, a
->tokens
, 0);
482 r
= automount_start_expire(a
);
484 log_unit_warning_errno(UNIT(a
), r
, "Failed to start expiration timer, ignoring: %m");
487 case MOUNT_UNMOUNTING
:
488 case MOUNT_MOUNTING_SIGTERM
:
489 case MOUNT_MOUNTING_SIGKILL
:
490 case MOUNT_REMOUNTING_SIGTERM
:
491 case MOUNT_REMOUNTING_SIGKILL
:
492 case MOUNT_UNMOUNTING_SIGTERM
:
493 case MOUNT_UNMOUNTING_SIGKILL
:
495 if (old_state
!= state
)
496 automount_send_ready(a
, a
->tokens
, -ENODEV
);
497 (void) sd_event_source_set_enabled(a
->expire_event_source
, SD_EVENT_OFF
);
505 automount_send_ready(a
, a
->expire_tokens
, 0);
508 case MOUNT_MOUNTING_DONE
:
509 case MOUNT_MOUNTING_SIGTERM
:
510 case MOUNT_MOUNTING_SIGKILL
:
511 case MOUNT_REMOUNTING_SIGTERM
:
512 case MOUNT_REMOUNTING_SIGKILL
:
513 case MOUNT_UNMOUNTING_SIGTERM
:
514 case MOUNT_UNMOUNTING_SIGKILL
:
516 if (old_state
!= state
)
517 automount_send_ready(a
, a
->expire_tokens
, -ENODEV
);
526 static void automount_enter_waiting(Automount
*a
) {
527 _cleanup_close_
int ioctl_fd
= -1;
528 int p
[2] = { -1, -1 };
529 char name
[sizeof("systemd-")-1 + DECIMAL_STR_MAX(pid_t
) + 1];
530 char options
[sizeof("fd=,pgrp=,minproto=5,maxproto=5,direct")-1
531 + DECIMAL_STR_MAX(int) + DECIMAL_STR_MAX(gid_t
) + 1];
532 bool mounted
= false;
533 int r
, dev_autofs_fd
;
537 assert(a
->pipe_fd
< 0);
540 set_clear(a
->tokens
);
542 r
= unit_fail_if_symlink(UNIT(a
), a
->where
);
546 (void) mkdir_p_label(a
->where
, 0555);
548 unit_warn_if_dir_nonempty(UNIT(a
), a
->where
);
550 dev_autofs_fd
= open_dev_autofs(UNIT(a
)->manager
);
551 if (dev_autofs_fd
< 0) {
556 if (pipe2(p
, O_NONBLOCK
|O_CLOEXEC
) < 0) {
561 xsprintf(options
, "fd=%i,pgrp="PID_FMT
",minproto=5,maxproto=5,direct", p
[1], getpgrp());
562 xsprintf(name
, "systemd-"PID_FMT
, getpid());
563 if (mount(name
, a
->where
, "autofs", 0, options
) < 0) {
570 p
[1] = safe_close(p
[1]);
572 if (stat(a
->where
, &st
) < 0) {
577 ioctl_fd
= open_ioctl_fd(dev_autofs_fd
, a
->where
, st
.st_dev
);
583 r
= autofs_protocol(dev_autofs_fd
, ioctl_fd
);
587 r
= autofs_set_timeout(dev_autofs_fd
, ioctl_fd
, a
->timeout_idle_usec
);
593 * Unless we close the ioctl fd here, for some weird reason
594 * the direct mount will not receive events from the
597 r
= sd_event_add_io(UNIT(a
)->manager
->event
, &a
->pipe_event_source
, p
[0], EPOLLIN
, automount_dispatch_io
, a
);
601 (void) sd_event_source_set_description(a
->pipe_event_source
, "automount-io");
604 a
->dev_id
= st
.st_dev
;
606 automount_set_state(a
, AUTOMOUNT_WAITING
);
614 repeat_unmount(a
->where
);
616 log_unit_error_errno(UNIT(a
), r
, "Failed to initialize automounter: %m");
617 automount_enter_dead(a
, AUTOMOUNT_FAILURE_RESOURCES
);
620 static void *expire_thread(void *p
) {
621 struct autofs_dev_ioctl param
;
622 _cleanup_(expire_data_freep
) struct expire_data
*data
= (struct expire_data
*)p
;
625 assert(data
->dev_autofs_fd
>= 0);
626 assert(data
->ioctl_fd
>= 0);
628 init_autofs_dev_ioctl(¶m
);
629 param
.ioctlfd
= data
->ioctl_fd
;
632 r
= ioctl(data
->dev_autofs_fd
, AUTOFS_DEV_IOCTL_EXPIRE
, ¶m
);
636 log_warning_errno(errno
, "Failed to expire automount, ignoring: %m");
641 static int automount_dispatch_expire(sd_event_source
*source
, usec_t usec
, void *userdata
) {
642 Automount
*a
= AUTOMOUNT(userdata
);
643 _cleanup_(expire_data_freep
) struct expire_data
*data
= NULL
;
647 assert(source
== a
->expire_event_source
);
649 data
= new0(struct expire_data
, 1);
655 data
->dev_autofs_fd
= fcntl(UNIT(a
)->manager
->dev_autofs_fd
, F_DUPFD_CLOEXEC
, 3);
656 if (data
->dev_autofs_fd
< 0)
657 return log_unit_error_errno(UNIT(a
), errno
, "Failed to duplicate autofs fd: %m");
659 data
->ioctl_fd
= open_ioctl_fd(UNIT(a
)->manager
->dev_autofs_fd
, a
->where
, a
->dev_id
);
660 if (data
->ioctl_fd
< 0)
661 return log_unit_error_errno(UNIT(a
), data
->ioctl_fd
, "Couldn't open autofs ioctl fd: %m");
663 r
= asynchronous_job(expire_thread
, data
);
665 return log_unit_error_errno(UNIT(a
), r
, "Failed to start expire job: %m");
669 return automount_start_expire(a
);
672 static int automount_start_expire(Automount
*a
) {
678 if (a
->timeout_idle_usec
== 0)
681 timeout
= now(CLOCK_MONOTONIC
) + MAX(a
->timeout_idle_usec
/3, USEC_PER_SEC
);
683 if (a
->expire_event_source
) {
684 r
= sd_event_source_set_time(a
->expire_event_source
, timeout
);
688 return sd_event_source_set_enabled(a
->expire_event_source
, SD_EVENT_ONESHOT
);
691 r
= sd_event_add_time(
692 UNIT(a
)->manager
->event
,
693 &a
->expire_event_source
,
694 CLOCK_MONOTONIC
, timeout
, 0,
695 automount_dispatch_expire
, a
);
699 (void) sd_event_source_set_description(a
->expire_event_source
, "automount-expire");
704 static void automount_enter_runnning(Automount
*a
) {
705 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
711 /* We don't take mount requests anymore if we are supposed to
712 * shut down anyway */
713 if (unit_stop_pending(UNIT(a
))) {
714 log_unit_debug(UNIT(a
), "Suppressing automount request since unit stop is scheduled.");
715 automount_send_ready(a
, a
->tokens
, -EHOSTDOWN
);
716 automount_send_ready(a
, a
->expire_tokens
, -EHOSTDOWN
);
720 mkdir_p_label(a
->where
, a
->directory_mode
);
722 /* Before we do anything, let's see if somebody is playing games with us? */
723 if (lstat(a
->where
, &st
) < 0) {
724 log_unit_warning_errno(UNIT(a
), errno
, "Failed to stat automount point: %m");
728 if (!S_ISDIR(st
.st_mode
) || st
.st_dev
!= a
->dev_id
)
729 log_unit_info(UNIT(a
), "Automount point already active?");
731 r
= manager_add_job(UNIT(a
)->manager
, JOB_START
, UNIT_TRIGGER(UNIT(a
)),
732 JOB_REPLACE
, true, &error
, NULL
);
734 log_unit_warning(UNIT(a
), "Failed to queue mount startup job: %s", bus_error_message(&error
, r
));
739 automount_set_state(a
, AUTOMOUNT_RUNNING
);
743 automount_enter_dead(a
, AUTOMOUNT_FAILURE_RESOURCES
);
746 static int automount_start(Unit
*u
) {
747 Automount
*a
= AUTOMOUNT(u
);
750 assert(a
->state
== AUTOMOUNT_DEAD
|| a
->state
== AUTOMOUNT_FAILED
);
752 if (path_is_mount_point(a
->where
, 0) > 0) {
753 log_unit_error(u
, "Path %s is already a mount point, refusing start.", a
->where
);
757 if (UNIT_TRIGGER(u
)->load_state
!= UNIT_LOADED
)
760 a
->result
= AUTOMOUNT_SUCCESS
;
761 automount_enter_waiting(a
);
765 static int automount_stop(Unit
*u
) {
766 Automount
*a
= AUTOMOUNT(u
);
769 assert(a
->state
== AUTOMOUNT_WAITING
|| a
->state
== AUTOMOUNT_RUNNING
);
771 automount_enter_dead(a
, AUTOMOUNT_SUCCESS
);
775 static int automount_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
776 Automount
*a
= AUTOMOUNT(u
);
784 unit_serialize_item(u
, f
, "state", automount_state_to_string(a
->state
));
785 unit_serialize_item(u
, f
, "result", automount_result_to_string(a
->result
));
786 unit_serialize_item_format(u
, f
, "dev-id", "%u", (unsigned) a
->dev_id
);
788 SET_FOREACH(p
, a
->tokens
, i
)
789 unit_serialize_item_format(u
, f
, "token", "%u", PTR_TO_UINT(p
));
790 SET_FOREACH(p
, a
->expire_tokens
, i
)
791 unit_serialize_item_format(u
, f
, "expire-token", "%u", PTR_TO_UINT(p
));
793 if (a
->pipe_fd
>= 0) {
796 copy
= fdset_put_dup(fds
, a
->pipe_fd
);
800 unit_serialize_item_format(u
, f
, "pipe-fd", "%i", copy
);
806 static int automount_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
807 Automount
*a
= AUTOMOUNT(u
);
813 if (streq(key
, "state")) {
814 AutomountState state
;
816 state
= automount_state_from_string(value
);
818 log_unit_debug(u
, "Failed to parse state value: %s", value
);
820 a
->deserialized_state
= state
;
821 } else if (streq(key
, "result")) {
824 f
= automount_result_from_string(value
);
826 log_unit_debug(u
, "Failed to parse result value: %s", value
);
827 else if (f
!= AUTOMOUNT_SUCCESS
)
830 } else if (streq(key
, "dev-id")) {
833 if (safe_atou(value
, &d
) < 0)
834 log_unit_debug(u
, "Failed to parse dev-id value: %s", value
);
836 a
->dev_id
= (unsigned) d
;
837 } else if (streq(key
, "token")) {
840 if (safe_atou(value
, &token
) < 0)
841 log_unit_debug(u
, "Failed to parse token value: %s", value
);
843 r
= set_ensure_allocated(&a
->tokens
, NULL
);
849 r
= set_put(a
->tokens
, UINT_TO_PTR(token
));
851 log_unit_error_errno(u
, r
, "Failed to add token to set: %m");
853 } else if (streq(key
, "expire-token")) {
856 if (safe_atou(value
, &token
) < 0)
857 log_unit_debug(u
, "Failed to parse token value: %s", value
);
859 r
= set_ensure_allocated(&a
->expire_tokens
, NULL
);
865 r
= set_put(a
->expire_tokens
, UINT_TO_PTR(token
));
867 log_unit_error_errno(u
, r
, "Failed to add expire token to set: %m");
869 } else if (streq(key
, "pipe-fd")) {
872 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
873 log_unit_debug(u
, "Failed to parse pipe-fd value: %s", value
);
875 safe_close(a
->pipe_fd
);
876 a
->pipe_fd
= fdset_remove(fds
, fd
);
879 log_unit_debug(u
, "Unknown serialization key: %s", key
);
884 static UnitActiveState
automount_active_state(Unit
*u
) {
887 return state_translation_table
[AUTOMOUNT(u
)->state
];
890 static const char *automount_sub_state_to_string(Unit
*u
) {
893 return automount_state_to_string(AUTOMOUNT(u
)->state
);
896 static bool automount_check_gc(Unit
*u
) {
899 if (!UNIT_TRIGGER(u
))
902 return UNIT_VTABLE(UNIT_TRIGGER(u
))->check_gc(UNIT_TRIGGER(u
));
905 static int automount_dispatch_io(sd_event_source
*s
, int fd
, uint32_t events
, void *userdata
) {
906 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
907 union autofs_v5_packet_union packet
;
908 Automount
*a
= AUTOMOUNT(userdata
);
913 assert(fd
== a
->pipe_fd
);
915 if (events
!= EPOLLIN
) {
916 log_unit_error(UNIT(a
), "Got invalid poll event %"PRIu32
" on pipe (fd=%d)", events
, fd
);
920 r
= loop_read_exact(a
->pipe_fd
, &packet
, sizeof(packet
), true);
922 log_unit_error_errno(UNIT(a
), r
, "Invalid read from pipe: %m");
926 switch (packet
.hdr
.type
) {
928 case autofs_ptype_missing_direct
:
930 if (packet
.v5_packet
.pid
> 0) {
931 _cleanup_free_
char *p
= NULL
;
933 get_process_comm(packet
.v5_packet
.pid
, &p
);
934 log_unit_info(UNIT(a
), "Got automount request for %s, triggered by %"PRIu32
" (%s)", a
->where
, packet
.v5_packet
.pid
, strna(p
));
936 log_unit_debug(UNIT(a
), "Got direct mount request on %s", a
->where
);
938 r
= set_ensure_allocated(&a
->tokens
, NULL
);
940 log_unit_error(UNIT(a
), "Failed to allocate token set.");
944 r
= set_put(a
->tokens
, UINT_TO_PTR(packet
.v5_packet
.wait_queue_token
));
946 log_unit_error_errno(UNIT(a
), r
, "Failed to remember token: %m");
950 automount_enter_runnning(a
);
953 case autofs_ptype_expire_direct
:
954 log_unit_debug(UNIT(a
), "Got direct umount request on %s", a
->where
);
956 (void) sd_event_source_set_enabled(a
->expire_event_source
, SD_EVENT_OFF
);
958 r
= set_ensure_allocated(&a
->expire_tokens
, NULL
);
960 log_unit_error(UNIT(a
), "Failed to allocate token set.");
964 r
= set_put(a
->expire_tokens
, UINT_TO_PTR(packet
.v5_packet
.wait_queue_token
));
966 log_unit_error_errno(UNIT(a
), r
, "Failed to remember token: %m");
970 /* Before we do anything, let's see if somebody is playing games with us? */
971 if (lstat(a
->where
, &st
) < 0) {
972 log_unit_warning_errno(UNIT(a
), errno
, "Failed to stat automount point: %m");
976 if (!S_ISDIR(st
.st_mode
) || st
.st_dev
== a
->dev_id
) {
977 log_unit_info(UNIT(a
), "Automount point already unmounted?");
978 automount_send_ready(a
, a
->expire_tokens
, 0);
982 r
= manager_add_job(UNIT(a
)->manager
, JOB_STOP
, UNIT_TRIGGER(UNIT(a
)), JOB_REPLACE
, true, &error
, NULL
);
984 log_unit_warning(UNIT(a
), "Failed to queue umount startup job: %s", bus_error_message(&error
, r
));
990 log_unit_error(UNIT(a
), "Received unknown automount request %i", packet
.hdr
.type
);
997 automount_enter_dead(a
, AUTOMOUNT_FAILURE_RESOURCES
);
1001 static void automount_shutdown(Manager
*m
) {
1004 m
->dev_autofs_fd
= safe_close(m
->dev_autofs_fd
);
1007 static void automount_reset_failed(Unit
*u
) {
1008 Automount
*a
= AUTOMOUNT(u
);
1012 if (a
->state
== AUTOMOUNT_FAILED
)
1013 automount_set_state(a
, AUTOMOUNT_DEAD
);
1015 a
->result
= AUTOMOUNT_SUCCESS
;
1018 static bool automount_supported(void) {
1019 static int supported
= -1;
1022 supported
= access("/dev/autofs", F_OK
) >= 0;
1027 static const char* const automount_state_table
[_AUTOMOUNT_STATE_MAX
] = {
1028 [AUTOMOUNT_DEAD
] = "dead",
1029 [AUTOMOUNT_WAITING
] = "waiting",
1030 [AUTOMOUNT_RUNNING
] = "running",
1031 [AUTOMOUNT_FAILED
] = "failed"
1034 DEFINE_STRING_TABLE_LOOKUP(automount_state
, AutomountState
);
1036 static const char* const automount_result_table
[_AUTOMOUNT_RESULT_MAX
] = {
1037 [AUTOMOUNT_SUCCESS
] = "success",
1038 [AUTOMOUNT_FAILURE_RESOURCES
] = "resources"
1041 DEFINE_STRING_TABLE_LOOKUP(automount_result
, AutomountResult
);
1043 const UnitVTable automount_vtable
= {
1044 .object_size
= sizeof(Automount
),
1052 .no_instances
= true,
1054 .init
= automount_init
,
1055 .load
= automount_load
,
1056 .done
= automount_done
,
1058 .coldplug
= automount_coldplug
,
1060 .dump
= automount_dump
,
1062 .start
= automount_start
,
1063 .stop
= automount_stop
,
1065 .serialize
= automount_serialize
,
1066 .deserialize_item
= automount_deserialize_item
,
1068 .active_state
= automount_active_state
,
1069 .sub_state_to_string
= automount_sub_state_to_string
,
1071 .check_gc
= automount_check_gc
,
1073 .reset_failed
= automount_reset_failed
,
1075 .bus_vtable
= bus_automount_vtable
,
1077 .shutdown
= automount_shutdown
,
1078 .supported
= automount_supported
,
1080 .status_message_formats
= {
1081 .finished_start_job
= {
1082 [JOB_DONE
] = "Set up automount %s.",
1083 [JOB_FAILED
] = "Failed to set up automount %s.",
1085 .finished_stop_job
= {
1086 [JOB_DONE
] = "Unset automount %s.",
1087 [JOB_FAILED
] = "Failed to unset automount %s.",