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
);
135 set_free(a
->expire_tokens
);
136 a
->expire_tokens
= NULL
;
138 a
->expire_event_source
= sd_event_source_unref(a
->expire_event_source
);
141 static int automount_add_mount_links(Automount
*a
) {
142 _cleanup_free_
char *parent
= NULL
;
147 r
= path_get_parent(a
->where
, &parent
);
151 return unit_require_mounts_for(UNIT(a
), parent
);
154 static int automount_add_default_dependencies(Automount
*a
) {
159 if (UNIT(a
)->manager
->running_as
!= MANAGER_SYSTEM
)
162 r
= unit_add_two_dependencies_by_name(UNIT(a
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_UMOUNT_TARGET
, NULL
, true);
169 static int automount_verify(Automount
*a
) {
170 _cleanup_free_
char *e
= NULL
;
175 if (UNIT(a
)->load_state
!= UNIT_LOADED
)
178 if (path_equal(a
->where
, "/")) {
179 log_unit_error(UNIT(a
), "Cannot have an automount unit for the root directory. Refusing.");
183 r
= unit_name_from_path(a
->where
, ".automount", &e
);
185 return log_unit_error(UNIT(a
), "Failed to generate unit name from path: %m");
187 if (!unit_has_name(UNIT(a
), e
)) {
188 log_unit_error(UNIT(a
), "Where= setting doesn't match unit name. Refusing.");
195 static int automount_load(Unit
*u
) {
196 Automount
*a
= AUTOMOUNT(u
);
200 assert(u
->load_state
== UNIT_STUB
);
202 /* Load a .automount file */
203 r
= unit_load_fragment_and_dropin_optional(u
);
207 if (u
->load_state
== UNIT_LOADED
) {
211 r
= unit_name_to_path(u
->id
, &a
->where
);
216 path_kill_slashes(a
->where
);
218 r
= unit_load_related_unit(u
, ".mount", &x
);
222 r
= unit_add_two_dependencies(u
, UNIT_BEFORE
, UNIT_TRIGGERS
, x
, true);
226 r
= automount_add_mount_links(a
);
230 if (UNIT(a
)->default_dependencies
) {
231 r
= automount_add_default_dependencies(a
);
237 return automount_verify(a
);
240 static void automount_set_state(Automount
*a
, AutomountState state
) {
241 AutomountState old_state
;
244 old_state
= a
->state
;
247 if (state
!= AUTOMOUNT_WAITING
&&
248 state
!= AUTOMOUNT_RUNNING
)
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
));
254 unit_notify(UNIT(a
), state_translation_table
[old_state
], state_translation_table
[state
], true);
257 static int automount_coldplug(Unit
*u
) {
258 Automount
*a
= AUTOMOUNT(u
);
262 assert(a
->state
== AUTOMOUNT_DEAD
);
264 if (a
->deserialized_state
!= a
->state
) {
266 r
= open_dev_autofs(u
->manager
);
270 if (a
->deserialized_state
== AUTOMOUNT_WAITING
||
271 a
->deserialized_state
== AUTOMOUNT_RUNNING
) {
272 assert(a
->pipe_fd
>= 0);
274 r
= sd_event_add_io(u
->manager
->event
, &a
->pipe_event_source
, a
->pipe_fd
, EPOLLIN
, automount_dispatch_io
, u
);
278 (void) sd_event_source_set_description(a
->pipe_event_source
, "automount-io");
281 automount_set_state(a
, a
->deserialized_state
);
287 static void automount_dump(Unit
*u
, FILE *f
, const char *prefix
) {
288 char time_string
[FORMAT_TIMESPAN_MAX
];
289 Automount
*a
= AUTOMOUNT(u
);
294 "%sAutomount State: %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
),
302 prefix
, a
->directory_mode
,
303 prefix
, format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, a
->timeout_idle_usec
, USEC_PER_SEC
));
306 static void automount_enter_dead(Automount
*a
, AutomountResult f
) {
309 if (f
!= AUTOMOUNT_SUCCESS
)
312 automount_set_state(a
, a
->result
!= AUTOMOUNT_SUCCESS
? AUTOMOUNT_FAILED
: AUTOMOUNT_DEAD
);
315 static int open_dev_autofs(Manager
*m
) {
316 struct autofs_dev_ioctl param
;
320 if (m
->dev_autofs_fd
>= 0)
321 return m
->dev_autofs_fd
;
323 label_fix("/dev/autofs", false, false);
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");
329 init_autofs_dev_ioctl(¶m
);
330 if (ioctl(m
->dev_autofs_fd
, AUTOFS_DEV_IOCTL_VERSION
, ¶m
) < 0) {
331 m
->dev_autofs_fd
= safe_close(m
->dev_autofs_fd
);
335 log_debug("Autofs kernel version %i.%i", param
.ver_major
, param
.ver_minor
);
337 return m
->dev_autofs_fd
;
340 static int open_ioctl_fd(int dev_autofs_fd
, const char *where
, dev_t devid
) {
341 struct autofs_dev_ioctl
*param
;
344 assert(dev_autofs_fd
>= 0);
347 l
= sizeof(struct autofs_dev_ioctl
) + strlen(where
) + 1;
350 init_autofs_dev_ioctl(param
);
353 param
->openmount
.devid
= devid
;
354 strcpy(param
->path
, where
);
356 if (ioctl(dev_autofs_fd
, AUTOFS_DEV_IOCTL_OPENMOUNT
, param
) < 0)
359 if (param
->ioctlfd
< 0)
362 (void) fd_cloexec(param
->ioctlfd
, true);
363 return param
->ioctlfd
;
366 static int autofs_protocol(int dev_autofs_fd
, int ioctl_fd
) {
367 uint32_t major
, minor
;
368 struct autofs_dev_ioctl param
;
370 assert(dev_autofs_fd
>= 0);
371 assert(ioctl_fd
>= 0);
373 init_autofs_dev_ioctl(¶m
);
374 param
.ioctlfd
= ioctl_fd
;
376 if (ioctl(dev_autofs_fd
, AUTOFS_DEV_IOCTL_PROTOVER
, ¶m
) < 0)
379 major
= param
.protover
.version
;
381 init_autofs_dev_ioctl(¶m
);
382 param
.ioctlfd
= ioctl_fd
;
384 if (ioctl(dev_autofs_fd
, AUTOFS_DEV_IOCTL_PROTOSUBVER
, ¶m
) < 0)
387 minor
= param
.protosubver
.sub_version
;
389 log_debug("Autofs protocol version %i.%i", major
, minor
);
393 static int autofs_set_timeout(int dev_autofs_fd
, int ioctl_fd
, usec_t usec
) {
394 struct autofs_dev_ioctl param
;
396 assert(dev_autofs_fd
>= 0);
397 assert(ioctl_fd
>= 0);
399 init_autofs_dev_ioctl(¶m
);
400 param
.ioctlfd
= ioctl_fd
;
402 /* Convert to seconds, rounding up. */
403 param
.timeout
.timeout
= (usec
+ USEC_PER_SEC
- 1) / USEC_PER_SEC
;
405 if (ioctl(dev_autofs_fd
, AUTOFS_DEV_IOCTL_TIMEOUT
, ¶m
) < 0)
411 static int autofs_send_ready(int dev_autofs_fd
, int ioctl_fd
, uint32_t token
, int status
) {
412 struct autofs_dev_ioctl param
;
414 assert(dev_autofs_fd
>= 0);
415 assert(ioctl_fd
>= 0);
417 init_autofs_dev_ioctl(¶m
);
418 param
.ioctlfd
= ioctl_fd
;
421 param
.fail
.token
= token
;
422 param
.fail
.status
= status
;
424 param
.ready
.token
= token
;
426 if (ioctl(dev_autofs_fd
, status
? AUTOFS_DEV_IOCTL_FAIL
: AUTOFS_DEV_IOCTL_READY
, ¶m
) < 0)
432 static int automount_send_ready(Automount
*a
, Set
*tokens
, int status
) {
433 _cleanup_close_
int ioctl_fd
= -1;
440 if (set_isempty(tokens
))
443 ioctl_fd
= open_ioctl_fd(UNIT(a
)->manager
->dev_autofs_fd
, a
->where
, a
->dev_id
);
448 log_unit_debug_errno(UNIT(a
), status
, "Sending failure: %m");
450 log_unit_debug(UNIT(a
), "Sending success.");
454 /* Autofs thankfully does not hand out 0 as a token */
455 while ((token
= PTR_TO_UINT(set_steal_first(tokens
)))) {
458 /* Autofs fun fact II:
460 * if you pass a positive status code here, the kernel will
463 k
= autofs_send_ready(UNIT(a
)->manager
->dev_autofs_fd
,
474 static int automount_start_expire(Automount
*a
);
476 int automount_update_mount(Automount
*a
, MountState old_state
, MountState state
) {
483 case MOUNT_REMOUNTING
:
484 automount_send_ready(a
, a
->tokens
, 0);
485 r
= automount_start_expire(a
);
487 log_unit_warning_errno(UNIT(a
), r
, "Failed to start expiration timer, ignoring: %m");
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
:
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
);
508 automount_send_ready(a
, a
->expire_tokens
, 0);
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
:
519 if (old_state
!= state
)
520 automount_send_ready(a
, a
->expire_tokens
, -ENODEV
);
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
;
540 assert(a
->pipe_fd
< 0);
543 set_clear(a
->tokens
);
545 r
= unit_fail_if_symlink(UNIT(a
), a
->where
);
549 (void) mkdir_p_label(a
->where
, 0555);
551 unit_warn_if_dir_nonempty(UNIT(a
), a
->where
);
553 dev_autofs_fd
= open_dev_autofs(UNIT(a
)->manager
);
554 if (dev_autofs_fd
< 0) {
559 if (pipe2(p
, O_NONBLOCK
|O_CLOEXEC
) < 0) {
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) {
573 p
[1] = safe_close(p
[1]);
575 if (stat(a
->where
, &st
) < 0) {
580 ioctl_fd
= open_ioctl_fd(dev_autofs_fd
, a
->where
, st
.st_dev
);
586 r
= autofs_protocol(dev_autofs_fd
, ioctl_fd
);
590 r
= autofs_set_timeout(dev_autofs_fd
, ioctl_fd
, a
->timeout_idle_usec
);
596 * Unless we close the ioctl fd here, for some weird reason
597 * the direct mount will not receive events from the
600 r
= sd_event_add_io(UNIT(a
)->manager
->event
, &a
->pipe_event_source
, p
[0], EPOLLIN
, automount_dispatch_io
, a
);
604 (void) sd_event_source_set_description(a
->pipe_event_source
, "automount-io");
607 a
->dev_id
= st
.st_dev
;
609 automount_set_state(a
, AUTOMOUNT_WAITING
);
617 repeat_unmount(a
->where
);
619 log_unit_error_errno(UNIT(a
), r
, "Failed to initialize automounter: %m");
620 automount_enter_dead(a
, AUTOMOUNT_FAILURE_RESOURCES
);
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
;
628 assert(data
->dev_autofs_fd
>= 0);
629 assert(data
->ioctl_fd
>= 0);
631 init_autofs_dev_ioctl(¶m
);
632 param
.ioctlfd
= data
->ioctl_fd
;
635 r
= ioctl(data
->dev_autofs_fd
, AUTOFS_DEV_IOCTL_EXPIRE
, ¶m
);
639 log_warning_errno(errno
, "Failed to expire automount, ignoring: %m");
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
;
650 assert(source
== a
->expire_event_source
);
652 data
= new0(struct expire_data
, 1);
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");
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");
666 r
= asynchronous_job(expire_thread
, data
);
668 return log_unit_error_errno(UNIT(a
), r
, "Failed to start expire job: %m");
672 return automount_start_expire(a
);
675 static int automount_start_expire(Automount
*a
) {
681 if (a
->timeout_idle_usec
== 0)
684 timeout
= now(CLOCK_MONOTONIC
) + MAX(a
->timeout_idle_usec
/3, USEC_PER_SEC
);
686 if (a
->expire_event_source
) {
687 r
= sd_event_source_set_time(a
->expire_event_source
, timeout
);
691 return sd_event_source_set_enabled(a
->expire_event_source
, SD_EVENT_ONESHOT
);
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
);
702 (void) sd_event_source_set_description(a
->expire_event_source
, "automount-expire");
707 static void automount_enter_runnning(Automount
*a
) {
708 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
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
);
723 mkdir_p_label(a
->where
, a
->directory_mode
);
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");
731 if (!S_ISDIR(st
.st_mode
) || st
.st_dev
!= a
->dev_id
)
732 log_unit_info(UNIT(a
), "Automount point already active?");
734 r
= manager_add_job(UNIT(a
)->manager
, JOB_START
, UNIT_TRIGGER(UNIT(a
)),
735 JOB_REPLACE
, true, &error
, NULL
);
737 log_unit_warning(UNIT(a
), "Failed to queue mount startup job: %s", bus_error_message(&error
, r
));
742 automount_set_state(a
, AUTOMOUNT_RUNNING
);
746 automount_enter_dead(a
, AUTOMOUNT_FAILURE_RESOURCES
);
749 static int automount_start(Unit
*u
) {
750 Automount
*a
= AUTOMOUNT(u
);
753 assert(a
->state
== AUTOMOUNT_DEAD
|| a
->state
== AUTOMOUNT_FAILED
);
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
);
760 if (UNIT_TRIGGER(u
)->load_state
!= UNIT_LOADED
)
763 a
->result
= AUTOMOUNT_SUCCESS
;
764 automount_enter_waiting(a
);
768 static int automount_stop(Unit
*u
) {
769 Automount
*a
= AUTOMOUNT(u
);
772 assert(a
->state
== AUTOMOUNT_WAITING
|| a
->state
== AUTOMOUNT_RUNNING
);
774 automount_enter_dead(a
, AUTOMOUNT_SUCCESS
);
778 static int automount_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
779 Automount
*a
= AUTOMOUNT(u
);
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
);
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
));
796 if (a
->pipe_fd
>= 0) {
799 copy
= fdset_put_dup(fds
, a
->pipe_fd
);
803 unit_serialize_item_format(u
, f
, "pipe-fd", "%i", copy
);
809 static int automount_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
810 Automount
*a
= AUTOMOUNT(u
);
816 if (streq(key
, "state")) {
817 AutomountState state
;
819 state
= automount_state_from_string(value
);
821 log_unit_debug(u
, "Failed to parse state value: %s", value
);
823 a
->deserialized_state
= state
;
824 } else if (streq(key
, "result")) {
827 f
= automount_result_from_string(value
);
829 log_unit_debug(u
, "Failed to parse result value: %s", value
);
830 else if (f
!= AUTOMOUNT_SUCCESS
)
833 } else if (streq(key
, "dev-id")) {
836 if (safe_atou(value
, &d
) < 0)
837 log_unit_debug(u
, "Failed to parse dev-id value: %s", value
);
839 a
->dev_id
= (unsigned) d
;
840 } else if (streq(key
, "token")) {
843 if (safe_atou(value
, &token
) < 0)
844 log_unit_debug(u
, "Failed to parse token value: %s", value
);
846 r
= set_ensure_allocated(&a
->tokens
, NULL
);
852 r
= set_put(a
->tokens
, UINT_TO_PTR(token
));
854 log_unit_error_errno(u
, r
, "Failed to add token to set: %m");
856 } else if (streq(key
, "expire-token")) {
859 if (safe_atou(value
, &token
) < 0)
860 log_unit_debug(u
, "Failed to parse token value: %s", value
);
862 r
= set_ensure_allocated(&a
->expire_tokens
, NULL
);
868 r
= set_put(a
->expire_tokens
, UINT_TO_PTR(token
));
870 log_unit_error_errno(u
, r
, "Failed to add expire token to set: %m");
872 } else if (streq(key
, "pipe-fd")) {
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
);
878 safe_close(a
->pipe_fd
);
879 a
->pipe_fd
= fdset_remove(fds
, fd
);
882 log_unit_debug(u
, "Unknown serialization key: %s", key
);
887 static UnitActiveState
automount_active_state(Unit
*u
) {
890 return state_translation_table
[AUTOMOUNT(u
)->state
];
893 static const char *automount_sub_state_to_string(Unit
*u
) {
896 return automount_state_to_string(AUTOMOUNT(u
)->state
);
899 static bool automount_check_gc(Unit
*u
) {
902 if (!UNIT_TRIGGER(u
))
905 return UNIT_VTABLE(UNIT_TRIGGER(u
))->check_gc(UNIT_TRIGGER(u
));
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
);
916 assert(fd
== a
->pipe_fd
);
918 if (events
!= EPOLLIN
) {
919 log_unit_error(UNIT(a
), "Got invalid poll event %"PRIu32
" on pipe (fd=%d)", events
, fd
);
923 r
= loop_read_exact(a
->pipe_fd
, &packet
, sizeof(packet
), true);
925 log_unit_error_errno(UNIT(a
), r
, "Invalid read from pipe: %m");
929 switch (packet
.hdr
.type
) {
931 case autofs_ptype_missing_direct
:
933 if (packet
.v5_packet
.pid
> 0) {
934 _cleanup_free_
char *p
= NULL
;
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
));
939 log_unit_debug(UNIT(a
), "Got direct mount request on %s", a
->where
);
941 r
= set_ensure_allocated(&a
->tokens
, NULL
);
943 log_unit_error(UNIT(a
), "Failed to allocate token set.");
947 r
= set_put(a
->tokens
, UINT_TO_PTR(packet
.v5_packet
.wait_queue_token
));
949 log_unit_error_errno(UNIT(a
), r
, "Failed to remember token: %m");
953 automount_enter_runnning(a
);
956 case autofs_ptype_expire_direct
:
957 log_unit_debug(UNIT(a
), "Got direct umount request on %s", a
->where
);
959 (void) sd_event_source_set_enabled(a
->expire_event_source
, SD_EVENT_OFF
);
961 r
= set_ensure_allocated(&a
->expire_tokens
, NULL
);
963 log_unit_error(UNIT(a
), "Failed to allocate token set.");
967 r
= set_put(a
->expire_tokens
, UINT_TO_PTR(packet
.v5_packet
.wait_queue_token
));
969 log_unit_error_errno(UNIT(a
), r
, "Failed to remember token: %m");
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");
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);
985 r
= manager_add_job(UNIT(a
)->manager
, JOB_STOP
, UNIT_TRIGGER(UNIT(a
)), JOB_REPLACE
, true, &error
, NULL
);
987 log_unit_warning(UNIT(a
), "Failed to queue umount startup job: %s", bus_error_message(&error
, r
));
993 log_unit_error(UNIT(a
), "Received unknown automount request %i", packet
.hdr
.type
);
1000 automount_enter_dead(a
, AUTOMOUNT_FAILURE_RESOURCES
);
1004 static void automount_shutdown(Manager
*m
) {
1007 m
->dev_autofs_fd
= safe_close(m
->dev_autofs_fd
);
1010 static void automount_reset_failed(Unit
*u
) {
1011 Automount
*a
= AUTOMOUNT(u
);
1015 if (a
->state
== AUTOMOUNT_FAILED
)
1016 automount_set_state(a
, AUTOMOUNT_DEAD
);
1018 a
->result
= AUTOMOUNT_SUCCESS
;
1021 static bool automount_supported(void) {
1022 static int supported
= -1;
1025 supported
= access("/dev/autofs", F_OK
) >= 0;
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"
1037 DEFINE_STRING_TABLE_LOOKUP(automount_state
, AutomountState
);
1039 static const char* const automount_result_table
[_AUTOMOUNT_RESULT_MAX
] = {
1040 [AUTOMOUNT_SUCCESS
] = "success",
1041 [AUTOMOUNT_FAILURE_RESOURCES
] = "resources"
1044 DEFINE_STRING_TABLE_LOOKUP(automount_result
, AutomountResult
);
1046 const UnitVTable automount_vtable
= {
1047 .object_size
= sizeof(Automount
),
1055 .no_instances
= true,
1057 .init
= automount_init
,
1058 .load
= automount_load
,
1059 .done
= automount_done
,
1061 .coldplug
= automount_coldplug
,
1063 .dump
= automount_dump
,
1065 .start
= automount_start
,
1066 .stop
= automount_stop
,
1068 .serialize
= automount_serialize
,
1069 .deserialize_item
= automount_deserialize_item
,
1071 .active_state
= automount_active_state
,
1072 .sub_state_to_string
= automount_sub_state_to_string
,
1074 .check_gc
= automount_check_gc
,
1076 .reset_failed
= automount_reset_failed
,
1078 .bus_vtable
= bus_automount_vtable
,
1080 .shutdown
= automount_shutdown
,
1081 .supported
= automount_supported
,
1083 .status_message_formats
= {
1084 .finished_start_job
= {
1085 [JOB_DONE
] = "Set up automount %s.",
1086 [JOB_FAILED
] = "Failed to set up automount %s.",
1088 .finished_stop_job
= {
1089 [JOB_DONE
] = "Unset automount %s.",
1090 [JOB_FAILED
] = "Failed to unset automount %s.",