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/>.
25 #include <linux/auto_dev-ioctl.h>
26 #include <linux/auto_fs4.h>
27 #include <sys/epoll.h>
28 #include <sys/mount.h>
32 #include "alloc-util.h"
34 #include "automount.h"
35 #include "bus-error.h"
37 #include "dbus-automount.h"
39 #include "formats-util.h"
43 #include "mount-util.h"
45 #include "parse-util.h"
46 #include "path-util.h"
47 #include "process-util.h"
49 #include "stdio-util.h"
50 #include "string-table.h"
51 #include "string-util.h"
52 #include "unit-name.h"
55 static const UnitActiveState state_translation_table
[_AUTOMOUNT_STATE_MAX
] = {
56 [AUTOMOUNT_DEAD
] = UNIT_INACTIVE
,
57 [AUTOMOUNT_WAITING
] = UNIT_ACTIVE
,
58 [AUTOMOUNT_RUNNING
] = UNIT_ACTIVE
,
59 [AUTOMOUNT_FAILED
] = UNIT_FAILED
67 static inline void expire_data_free(struct expire_data
*data
) {
71 safe_close(data
->dev_autofs_fd
);
72 safe_close(data
->ioctl_fd
);
76 DEFINE_TRIVIAL_CLEANUP_FUNC(struct expire_data
*, expire_data_free
);
78 static int open_dev_autofs(Manager
*m
);
79 static int automount_dispatch_io(sd_event_source
*s
, int fd
, uint32_t events
, void *userdata
);
81 static void automount_init(Unit
*u
) {
82 Automount
*a
= AUTOMOUNT(u
);
85 assert(u
->load_state
== UNIT_STUB
);
88 a
->directory_mode
= 0755;
89 UNIT(a
)->ignore_on_isolate
= true;
92 static int automount_send_ready(Automount
*a
, Set
*tokens
, int status
);
94 static void unmount_autofs(Automount
*a
) {
102 automount_send_ready(a
, a
->tokens
, -EHOSTDOWN
);
103 automount_send_ready(a
, a
->expire_tokens
, -EHOSTDOWN
);
105 a
->pipe_event_source
= sd_event_source_unref(a
->pipe_event_source
);
106 a
->pipe_fd
= safe_close(a
->pipe_fd
);
108 /* If we reload/reexecute things we keep the mount point
111 (UNIT(a
)->manager
->exit_code
!= MANAGER_RELOAD
&&
112 UNIT(a
)->manager
->exit_code
!= MANAGER_REEXECUTE
)) {
113 r
= repeat_unmount(a
->where
, MNT_DETACH
);
115 log_error_errno(r
, "Failed to unmount: %m");
119 static void automount_done(Unit
*u
) {
120 Automount
*a
= AUTOMOUNT(u
);
126 a
->where
= mfree(a
->where
);
128 a
->tokens
= set_free(a
->tokens
);
129 a
->expire_tokens
= set_free(a
->expire_tokens
);
131 a
->expire_event_source
= sd_event_source_unref(a
->expire_event_source
);
134 static int automount_add_mount_links(Automount
*a
) {
135 _cleanup_free_
char *parent
= NULL
;
139 parent
= dirname_malloc(a
->where
);
143 return unit_require_mounts_for(UNIT(a
), parent
);
146 static int automount_add_default_dependencies(Automount
*a
) {
151 if (!UNIT(a
)->default_dependencies
)
154 if (UNIT(a
)->manager
->running_as
!= MANAGER_SYSTEM
)
157 r
= unit_add_two_dependencies_by_name(UNIT(a
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_UMOUNT_TARGET
, NULL
, true);
164 static int automount_verify(Automount
*a
) {
165 _cleanup_free_
char *e
= NULL
;
170 if (UNIT(a
)->load_state
!= UNIT_LOADED
)
173 if (path_equal(a
->where
, "/")) {
174 log_unit_error(UNIT(a
), "Cannot have an automount unit for the root directory. Refusing.");
178 r
= unit_name_from_path(a
->where
, ".automount", &e
);
180 return log_unit_error(UNIT(a
), "Failed to generate unit name from path: %m");
182 if (!unit_has_name(UNIT(a
), e
)) {
183 log_unit_error(UNIT(a
), "Where= setting doesn't match unit name. Refusing.");
190 static int automount_load(Unit
*u
) {
191 Automount
*a
= AUTOMOUNT(u
);
195 assert(u
->load_state
== UNIT_STUB
);
197 /* Load a .automount file */
198 r
= unit_load_fragment_and_dropin_optional(u
);
202 if (u
->load_state
== UNIT_LOADED
) {
206 r
= unit_name_to_path(u
->id
, &a
->where
);
211 path_kill_slashes(a
->where
);
213 r
= unit_load_related_unit(u
, ".mount", &x
);
217 r
= unit_add_two_dependencies(u
, UNIT_BEFORE
, UNIT_TRIGGERS
, x
, true);
221 r
= automount_add_mount_links(a
);
225 r
= automount_add_default_dependencies(a
);
230 return automount_verify(a
);
233 static void automount_set_state(Automount
*a
, AutomountState state
) {
234 AutomountState old_state
;
237 old_state
= a
->state
;
240 if (state
!= AUTOMOUNT_WAITING
&&
241 state
!= AUTOMOUNT_RUNNING
)
244 if (state
!= old_state
)
245 log_unit_debug(UNIT(a
), "Changed %s -> %s", automount_state_to_string(old_state
), automount_state_to_string(state
));
247 unit_notify(UNIT(a
), state_translation_table
[old_state
], state_translation_table
[state
], true);
250 static int automount_coldplug(Unit
*u
) {
251 Automount
*a
= AUTOMOUNT(u
);
255 assert(a
->state
== AUTOMOUNT_DEAD
);
257 if (a
->deserialized_state
!= a
->state
) {
259 r
= open_dev_autofs(u
->manager
);
263 if (a
->deserialized_state
== AUTOMOUNT_WAITING
||
264 a
->deserialized_state
== AUTOMOUNT_RUNNING
) {
265 assert(a
->pipe_fd
>= 0);
267 r
= sd_event_add_io(u
->manager
->event
, &a
->pipe_event_source
, a
->pipe_fd
, EPOLLIN
, automount_dispatch_io
, u
);
271 (void) sd_event_source_set_description(a
->pipe_event_source
, "automount-io");
274 automount_set_state(a
, a
->deserialized_state
);
280 static void automount_dump(Unit
*u
, FILE *f
, const char *prefix
) {
281 char time_string
[FORMAT_TIMESPAN_MAX
];
282 Automount
*a
= AUTOMOUNT(u
);
287 "%sAutomount State: %s\n"
290 "%sDirectoryMode: %04o\n"
291 "%sTimeoutIdleUSec: %s\n",
292 prefix
, automount_state_to_string(a
->state
),
293 prefix
, automount_result_to_string(a
->result
),
295 prefix
, a
->directory_mode
,
296 prefix
, format_timespan(time_string
, FORMAT_TIMESPAN_MAX
, a
->timeout_idle_usec
, USEC_PER_SEC
));
299 static void automount_enter_dead(Automount
*a
, AutomountResult f
) {
302 if (f
!= AUTOMOUNT_SUCCESS
)
305 automount_set_state(a
, a
->result
!= AUTOMOUNT_SUCCESS
? AUTOMOUNT_FAILED
: AUTOMOUNT_DEAD
);
308 static int open_dev_autofs(Manager
*m
) {
309 struct autofs_dev_ioctl param
;
313 if (m
->dev_autofs_fd
>= 0)
314 return m
->dev_autofs_fd
;
316 label_fix("/dev/autofs", false, false);
318 m
->dev_autofs_fd
= open("/dev/autofs", O_CLOEXEC
|O_RDONLY
);
319 if (m
->dev_autofs_fd
< 0)
320 return log_error_errno(errno
, "Failed to open /dev/autofs: %m");
322 init_autofs_dev_ioctl(¶m
);
323 if (ioctl(m
->dev_autofs_fd
, AUTOFS_DEV_IOCTL_VERSION
, ¶m
) < 0) {
324 m
->dev_autofs_fd
= safe_close(m
->dev_autofs_fd
);
328 log_debug("Autofs kernel version %i.%i", param
.ver_major
, param
.ver_minor
);
330 return m
->dev_autofs_fd
;
333 static int open_ioctl_fd(int dev_autofs_fd
, const char *where
, dev_t devid
) {
334 struct autofs_dev_ioctl
*param
;
337 assert(dev_autofs_fd
>= 0);
340 l
= sizeof(struct autofs_dev_ioctl
) + strlen(where
) + 1;
343 init_autofs_dev_ioctl(param
);
346 param
->openmount
.devid
= devid
;
347 strcpy(param
->path
, where
);
349 if (ioctl(dev_autofs_fd
, AUTOFS_DEV_IOCTL_OPENMOUNT
, param
) < 0)
352 if (param
->ioctlfd
< 0)
355 (void) fd_cloexec(param
->ioctlfd
, true);
356 return param
->ioctlfd
;
359 static int autofs_protocol(int dev_autofs_fd
, int ioctl_fd
) {
360 uint32_t major
, minor
;
361 struct autofs_dev_ioctl param
;
363 assert(dev_autofs_fd
>= 0);
364 assert(ioctl_fd
>= 0);
366 init_autofs_dev_ioctl(¶m
);
367 param
.ioctlfd
= ioctl_fd
;
369 if (ioctl(dev_autofs_fd
, AUTOFS_DEV_IOCTL_PROTOVER
, ¶m
) < 0)
372 major
= param
.protover
.version
;
374 init_autofs_dev_ioctl(¶m
);
375 param
.ioctlfd
= ioctl_fd
;
377 if (ioctl(dev_autofs_fd
, AUTOFS_DEV_IOCTL_PROTOSUBVER
, ¶m
) < 0)
380 minor
= param
.protosubver
.sub_version
;
382 log_debug("Autofs protocol version %i.%i", major
, minor
);
386 static int autofs_set_timeout(int dev_autofs_fd
, int ioctl_fd
, usec_t usec
) {
387 struct autofs_dev_ioctl param
;
389 assert(dev_autofs_fd
>= 0);
390 assert(ioctl_fd
>= 0);
392 init_autofs_dev_ioctl(¶m
);
393 param
.ioctlfd
= ioctl_fd
;
395 /* Convert to seconds, rounding up. */
396 param
.timeout
.timeout
= (usec
+ USEC_PER_SEC
- 1) / USEC_PER_SEC
;
398 if (ioctl(dev_autofs_fd
, AUTOFS_DEV_IOCTL_TIMEOUT
, ¶m
) < 0)
404 static int autofs_send_ready(int dev_autofs_fd
, int ioctl_fd
, uint32_t token
, int status
) {
405 struct autofs_dev_ioctl param
;
407 assert(dev_autofs_fd
>= 0);
408 assert(ioctl_fd
>= 0);
410 init_autofs_dev_ioctl(¶m
);
411 param
.ioctlfd
= ioctl_fd
;
414 param
.fail
.token
= token
;
415 param
.fail
.status
= status
;
417 param
.ready
.token
= token
;
419 if (ioctl(dev_autofs_fd
, status
? AUTOFS_DEV_IOCTL_FAIL
: AUTOFS_DEV_IOCTL_READY
, ¶m
) < 0)
425 static int automount_send_ready(Automount
*a
, Set
*tokens
, int status
) {
426 _cleanup_close_
int ioctl_fd
= -1;
433 if (set_isempty(tokens
))
436 ioctl_fd
= open_ioctl_fd(UNIT(a
)->manager
->dev_autofs_fd
, a
->where
, a
->dev_id
);
441 log_unit_debug_errno(UNIT(a
), status
, "Sending failure: %m");
443 log_unit_debug(UNIT(a
), "Sending success.");
447 /* Autofs thankfully does not hand out 0 as a token */
448 while ((token
= PTR_TO_UINT(set_steal_first(tokens
)))) {
451 /* Autofs fun fact II:
453 * if you pass a positive status code here, the kernel will
456 k
= autofs_send_ready(UNIT(a
)->manager
->dev_autofs_fd
,
467 static int automount_start_expire(Automount
*a
);
469 int automount_update_mount(Automount
*a
, MountState old_state
, MountState state
) {
476 case MOUNT_REMOUNTING
:
477 automount_send_ready(a
, a
->tokens
, 0);
478 r
= automount_start_expire(a
);
480 log_unit_warning_errno(UNIT(a
), r
, "Failed to start expiration timer, ignoring: %m");
483 case MOUNT_UNMOUNTING
:
484 case MOUNT_MOUNTING_SIGTERM
:
485 case MOUNT_MOUNTING_SIGKILL
:
486 case MOUNT_REMOUNTING_SIGTERM
:
487 case MOUNT_REMOUNTING_SIGKILL
:
488 case MOUNT_UNMOUNTING_SIGTERM
:
489 case MOUNT_UNMOUNTING_SIGKILL
:
491 if (old_state
!= state
)
492 automount_send_ready(a
, a
->tokens
, -ENODEV
);
493 (void) sd_event_source_set_enabled(a
->expire_event_source
, SD_EVENT_OFF
);
501 automount_send_ready(a
, a
->expire_tokens
, 0);
504 case MOUNT_MOUNTING_DONE
:
505 case MOUNT_MOUNTING_SIGTERM
:
506 case MOUNT_MOUNTING_SIGKILL
:
507 case MOUNT_REMOUNTING_SIGTERM
:
508 case MOUNT_REMOUNTING_SIGKILL
:
509 case MOUNT_UNMOUNTING_SIGTERM
:
510 case MOUNT_UNMOUNTING_SIGKILL
:
512 if (old_state
!= state
)
513 automount_send_ready(a
, a
->expire_tokens
, -ENODEV
);
522 static void automount_enter_waiting(Automount
*a
) {
523 _cleanup_close_
int ioctl_fd
= -1;
524 int p
[2] = { -1, -1 };
525 char name
[sizeof("systemd-")-1 + DECIMAL_STR_MAX(pid_t
) + 1];
526 char options
[sizeof("fd=,pgrp=,minproto=5,maxproto=5,direct")-1
527 + DECIMAL_STR_MAX(int) + DECIMAL_STR_MAX(gid_t
) + 1];
528 bool mounted
= false;
529 int r
, dev_autofs_fd
;
533 assert(a
->pipe_fd
< 0);
536 set_clear(a
->tokens
);
538 r
= unit_fail_if_symlink(UNIT(a
), a
->where
);
542 (void) mkdir_p_label(a
->where
, 0555);
544 unit_warn_if_dir_nonempty(UNIT(a
), a
->where
);
546 dev_autofs_fd
= open_dev_autofs(UNIT(a
)->manager
);
547 if (dev_autofs_fd
< 0) {
552 if (pipe2(p
, O_NONBLOCK
|O_CLOEXEC
) < 0) {
557 xsprintf(options
, "fd=%i,pgrp="PID_FMT
",minproto=5,maxproto=5,direct", p
[1], getpgrp());
558 xsprintf(name
, "systemd-"PID_FMT
, getpid());
559 if (mount(name
, a
->where
, "autofs", 0, options
) < 0) {
566 p
[1] = safe_close(p
[1]);
568 if (stat(a
->where
, &st
) < 0) {
573 ioctl_fd
= open_ioctl_fd(dev_autofs_fd
, a
->where
, st
.st_dev
);
579 r
= autofs_protocol(dev_autofs_fd
, ioctl_fd
);
583 r
= autofs_set_timeout(dev_autofs_fd
, ioctl_fd
, a
->timeout_idle_usec
);
589 * Unless we close the ioctl fd here, for some weird reason
590 * the direct mount will not receive events from the
593 r
= sd_event_add_io(UNIT(a
)->manager
->event
, &a
->pipe_event_source
, p
[0], EPOLLIN
, automount_dispatch_io
, a
);
597 (void) sd_event_source_set_description(a
->pipe_event_source
, "automount-io");
600 a
->dev_id
= st
.st_dev
;
602 automount_set_state(a
, AUTOMOUNT_WAITING
);
607 log_unit_error_errno(UNIT(a
), r
, "Failed to initialize automounter: %m");
612 r
= repeat_unmount(a
->where
, MNT_DETACH
);
614 log_error_errno(r
, "Failed to unmount, ignoring: %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
)), JOB_REPLACE
, &error
, NULL
);
733 log_unit_warning(UNIT(a
), "Failed to queue mount startup job: %s", bus_error_message(&error
, r
));
738 automount_set_state(a
, AUTOMOUNT_RUNNING
);
742 automount_enter_dead(a
, AUTOMOUNT_FAILURE_RESOURCES
);
745 static int automount_start(Unit
*u
) {
746 Automount
*a
= AUTOMOUNT(u
);
749 assert(a
->state
== AUTOMOUNT_DEAD
|| a
->state
== AUTOMOUNT_FAILED
);
751 if (path_is_mount_point(a
->where
, 0) > 0) {
752 log_unit_error(u
, "Path %s is already a mount point, refusing start.", a
->where
);
756 if (UNIT_TRIGGER(u
)->load_state
!= UNIT_LOADED
)
759 a
->result
= AUTOMOUNT_SUCCESS
;
760 automount_enter_waiting(a
);
764 static int automount_stop(Unit
*u
) {
765 Automount
*a
= AUTOMOUNT(u
);
768 assert(a
->state
== AUTOMOUNT_WAITING
|| a
->state
== AUTOMOUNT_RUNNING
);
770 automount_enter_dead(a
, AUTOMOUNT_SUCCESS
);
774 static int automount_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
775 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 r
= unit_serialize_item_fd(u
, f
, fds
, "pipe-fd", a
->pipe_fd
);
800 static int automount_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
801 Automount
*a
= AUTOMOUNT(u
);
807 if (streq(key
, "state")) {
808 AutomountState state
;
810 state
= automount_state_from_string(value
);
812 log_unit_debug(u
, "Failed to parse state value: %s", value
);
814 a
->deserialized_state
= state
;
815 } else if (streq(key
, "result")) {
818 f
= automount_result_from_string(value
);
820 log_unit_debug(u
, "Failed to parse result value: %s", value
);
821 else if (f
!= AUTOMOUNT_SUCCESS
)
824 } else if (streq(key
, "dev-id")) {
827 if (safe_atou(value
, &d
) < 0)
828 log_unit_debug(u
, "Failed to parse dev-id value: %s", value
);
830 a
->dev_id
= (unsigned) d
;
831 } else if (streq(key
, "token")) {
834 if (safe_atou(value
, &token
) < 0)
835 log_unit_debug(u
, "Failed to parse token value: %s", value
);
837 r
= set_ensure_allocated(&a
->tokens
, NULL
);
843 r
= set_put(a
->tokens
, UINT_TO_PTR(token
));
845 log_unit_error_errno(u
, r
, "Failed to add token to set: %m");
847 } else if (streq(key
, "expire-token")) {
850 if (safe_atou(value
, &token
) < 0)
851 log_unit_debug(u
, "Failed to parse token value: %s", value
);
853 r
= set_ensure_allocated(&a
->expire_tokens
, NULL
);
859 r
= set_put(a
->expire_tokens
, UINT_TO_PTR(token
));
861 log_unit_error_errno(u
, r
, "Failed to add expire token to set: %m");
863 } else if (streq(key
, "pipe-fd")) {
866 if (safe_atoi(value
, &fd
) < 0 || fd
< 0 || !fdset_contains(fds
, fd
))
867 log_unit_debug(u
, "Failed to parse pipe-fd value: %s", value
);
869 safe_close(a
->pipe_fd
);
870 a
->pipe_fd
= fdset_remove(fds
, fd
);
873 log_unit_debug(u
, "Unknown serialization key: %s", key
);
878 static UnitActiveState
automount_active_state(Unit
*u
) {
881 return state_translation_table
[AUTOMOUNT(u
)->state
];
884 static const char *automount_sub_state_to_string(Unit
*u
) {
887 return automount_state_to_string(AUTOMOUNT(u
)->state
);
890 static bool automount_check_gc(Unit
*u
) {
893 if (!UNIT_TRIGGER(u
))
896 return UNIT_VTABLE(UNIT_TRIGGER(u
))->check_gc(UNIT_TRIGGER(u
));
899 static int automount_dispatch_io(sd_event_source
*s
, int fd
, uint32_t events
, void *userdata
) {
900 _cleanup_bus_error_free_ sd_bus_error error
= SD_BUS_ERROR_NULL
;
901 union autofs_v5_packet_union packet
;
902 Automount
*a
= AUTOMOUNT(userdata
);
907 assert(fd
== a
->pipe_fd
);
909 if (events
!= EPOLLIN
) {
910 log_unit_error(UNIT(a
), "Got invalid poll event %"PRIu32
" on pipe (fd=%d)", events
, fd
);
914 r
= loop_read_exact(a
->pipe_fd
, &packet
, sizeof(packet
), true);
916 log_unit_error_errno(UNIT(a
), r
, "Invalid read from pipe: %m");
920 switch (packet
.hdr
.type
) {
922 case autofs_ptype_missing_direct
:
924 if (packet
.v5_packet
.pid
> 0) {
925 _cleanup_free_
char *p
= NULL
;
927 get_process_comm(packet
.v5_packet
.pid
, &p
);
928 log_unit_info(UNIT(a
), "Got automount request for %s, triggered by %"PRIu32
" (%s)", a
->where
, packet
.v5_packet
.pid
, strna(p
));
930 log_unit_debug(UNIT(a
), "Got direct mount request on %s", a
->where
);
932 r
= set_ensure_allocated(&a
->tokens
, NULL
);
934 log_unit_error(UNIT(a
), "Failed to allocate token set.");
938 r
= set_put(a
->tokens
, UINT_TO_PTR(packet
.v5_packet
.wait_queue_token
));
940 log_unit_error_errno(UNIT(a
), r
, "Failed to remember token: %m");
944 automount_enter_runnning(a
);
947 case autofs_ptype_expire_direct
:
948 log_unit_debug(UNIT(a
), "Got direct umount request on %s", a
->where
);
950 (void) sd_event_source_set_enabled(a
->expire_event_source
, SD_EVENT_OFF
);
952 r
= set_ensure_allocated(&a
->expire_tokens
, NULL
);
954 log_unit_error(UNIT(a
), "Failed to allocate token set.");
958 r
= set_put(a
->expire_tokens
, UINT_TO_PTR(packet
.v5_packet
.wait_queue_token
));
960 log_unit_error_errno(UNIT(a
), r
, "Failed to remember token: %m");
964 /* Before we do anything, let's see if somebody is playing games with us? */
965 if (lstat(a
->where
, &st
) < 0) {
966 log_unit_warning_errno(UNIT(a
), errno
, "Failed to stat automount point: %m");
970 if (!S_ISDIR(st
.st_mode
) || st
.st_dev
== a
->dev_id
) {
971 log_unit_info(UNIT(a
), "Automount point already unmounted?");
972 automount_send_ready(a
, a
->expire_tokens
, 0);
976 r
= manager_add_job(UNIT(a
)->manager
, JOB_STOP
, UNIT_TRIGGER(UNIT(a
)), JOB_REPLACE
, &error
, NULL
);
978 log_unit_warning(UNIT(a
), "Failed to queue umount startup job: %s", bus_error_message(&error
, r
));
984 log_unit_error(UNIT(a
), "Received unknown automount request %i", packet
.hdr
.type
);
991 automount_enter_dead(a
, AUTOMOUNT_FAILURE_RESOURCES
);
995 static void automount_shutdown(Manager
*m
) {
998 m
->dev_autofs_fd
= safe_close(m
->dev_autofs_fd
);
1001 static void automount_reset_failed(Unit
*u
) {
1002 Automount
*a
= AUTOMOUNT(u
);
1006 if (a
->state
== AUTOMOUNT_FAILED
)
1007 automount_set_state(a
, AUTOMOUNT_DEAD
);
1009 a
->result
= AUTOMOUNT_SUCCESS
;
1012 static bool automount_supported(void) {
1013 static int supported
= -1;
1016 supported
= access("/dev/autofs", F_OK
) >= 0;
1021 static const char* const automount_result_table
[_AUTOMOUNT_RESULT_MAX
] = {
1022 [AUTOMOUNT_SUCCESS
] = "success",
1023 [AUTOMOUNT_FAILURE_RESOURCES
] = "resources"
1026 DEFINE_STRING_TABLE_LOOKUP(automount_result
, AutomountResult
);
1028 const UnitVTable automount_vtable
= {
1029 .object_size
= sizeof(Automount
),
1037 .no_instances
= true,
1039 .init
= automount_init
,
1040 .load
= automount_load
,
1041 .done
= automount_done
,
1043 .coldplug
= automount_coldplug
,
1045 .dump
= automount_dump
,
1047 .start
= automount_start
,
1048 .stop
= automount_stop
,
1050 .serialize
= automount_serialize
,
1051 .deserialize_item
= automount_deserialize_item
,
1053 .active_state
= automount_active_state
,
1054 .sub_state_to_string
= automount_sub_state_to_string
,
1056 .check_gc
= automount_check_gc
,
1058 .reset_failed
= automount_reset_failed
,
1060 .bus_vtable
= bus_automount_vtable
,
1062 .shutdown
= automount_shutdown
,
1063 .supported
= automount_supported
,
1065 .status_message_formats
= {
1066 .finished_start_job
= {
1067 [JOB_DONE
] = "Set up automount %s.",
1068 [JOB_FAILED
] = "Failed to set up automount %s.",
1070 .finished_stop_job
= {
1071 [JOB_DONE
] = "Unset automount %s.",
1072 [JOB_FAILED
] = "Failed to unset automount %s.",