1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2010 Lennart Poettering
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
24 #include <sys/epoll.h>
26 #include "sd-messages.h"
28 #include "alloc-util.h"
29 #include "dbus-mount.h"
31 #include "exit-status.h"
32 #include "format-util.h"
33 #include "fstab-util.h"
37 #include "mount-setup.h"
38 #include "mount-util.h"
40 #include "parse-util.h"
41 #include "path-util.h"
42 #include "process-util.h"
44 #include "string-table.h"
45 #include "string-util.h"
47 #include "unit-name.h"
50 #define RETRY_UMOUNT_MAX 32
52 DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_table
*, mnt_free_table
);
53 DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_iter
*, mnt_free_iter
);
55 static const UnitActiveState state_translation_table
[_MOUNT_STATE_MAX
] = {
56 [MOUNT_DEAD
] = UNIT_INACTIVE
,
57 [MOUNT_MOUNTING
] = UNIT_ACTIVATING
,
58 [MOUNT_MOUNTING_DONE
] = UNIT_ACTIVATING
,
59 [MOUNT_MOUNTED
] = UNIT_ACTIVE
,
60 [MOUNT_REMOUNTING
] = UNIT_RELOADING
,
61 [MOUNT_UNMOUNTING
] = UNIT_DEACTIVATING
,
62 [MOUNT_REMOUNTING_SIGTERM
] = UNIT_RELOADING
,
63 [MOUNT_REMOUNTING_SIGKILL
] = UNIT_RELOADING
,
64 [MOUNT_UNMOUNTING_SIGTERM
] = UNIT_DEACTIVATING
,
65 [MOUNT_UNMOUNTING_SIGKILL
] = UNIT_DEACTIVATING
,
66 [MOUNT_FAILED
] = UNIT_FAILED
69 static int mount_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
);
70 static int mount_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
);
72 static bool MOUNT_STATE_WITH_PROCESS(MountState state
) {
77 MOUNT_REMOUNTING_SIGTERM
,
78 MOUNT_REMOUNTING_SIGKILL
,
80 MOUNT_UNMOUNTING_SIGTERM
,
81 MOUNT_UNMOUNTING_SIGKILL
);
84 static bool mount_needs_network(const char *options
, const char *fstype
) {
85 if (fstab_test_option(options
, "_netdev\0"))
88 if (fstype
&& fstype_is_network(fstype
))
94 static bool mount_is_network(const MountParameters
*p
) {
97 return mount_needs_network(p
->options
, p
->fstype
);
100 static bool mount_is_loop(const MountParameters
*p
) {
103 if (fstab_test_option(p
->options
, "loop\0"))
109 static bool mount_is_bind(const MountParameters
*p
) {
112 if (fstab_test_option(p
->options
, "bind\0" "rbind\0"))
115 if (p
->fstype
&& STR_IN_SET(p
->fstype
, "bind", "rbind"))
121 static bool mount_is_auto(const MountParameters
*p
) {
124 return !fstab_test_option(p
->options
, "noauto\0");
127 static bool mount_is_automount(const MountParameters
*p
) {
130 return fstab_test_option(p
->options
,
131 "comment=systemd.automount\0"
132 "x-systemd.automount\0");
135 static bool mount_is_bound_to_device(const Mount
*m
) {
136 const MountParameters
*p
;
138 if (m
->from_fragment
)
141 p
= &m
->parameters_proc_self_mountinfo
;
142 return fstab_test_option(p
->options
, "x-systemd.device-bound\0");
145 static bool needs_quota(const MountParameters
*p
) {
148 /* Quotas are not enabled on network filesystems,
149 * but we want them, for example, on storage connected via iscsi */
150 if (p
->fstype
&& fstype_is_network(p
->fstype
))
153 if (mount_is_bind(p
))
156 return fstab_test_option(p
->options
,
157 "usrquota\0" "grpquota\0" "quota\0" "usrjquota\0" "grpjquota\0");
160 static void mount_init(Unit
*u
) {
164 assert(u
->load_state
== UNIT_STUB
);
166 m
->timeout_usec
= u
->manager
->default_timeout_start_usec
;
168 m
->exec_context
.std_output
= u
->manager
->default_std_output
;
169 m
->exec_context
.std_error
= u
->manager
->default_std_error
;
171 m
->directory_mode
= 0755;
173 /* We need to make sure that /usr/bin/mount is always called
174 * in the same process group as us, so that the autofs kernel
175 * side doesn't send us another mount request while we are
176 * already trying to comply its last one. */
177 m
->exec_context
.same_pgrp
= true;
179 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
181 u
->ignore_on_isolate
= true;
184 static int mount_arm_timer(Mount
*m
, usec_t usec
) {
189 if (m
->timer_event_source
) {
190 r
= sd_event_source_set_time(m
->timer_event_source
, usec
);
194 return sd_event_source_set_enabled(m
->timer_event_source
, SD_EVENT_ONESHOT
);
197 if (usec
== USEC_INFINITY
)
200 r
= sd_event_add_time(
201 UNIT(m
)->manager
->event
,
202 &m
->timer_event_source
,
205 mount_dispatch_timer
, m
);
209 (void) sd_event_source_set_description(m
->timer_event_source
, "mount-timer");
214 static void mount_unwatch_control_pid(Mount
*m
) {
217 if (m
->control_pid
<= 0)
220 unit_unwatch_pid(UNIT(m
), m
->control_pid
);
224 static void mount_parameters_done(MountParameters
*p
) {
231 p
->what
= p
->options
= p
->fstype
= NULL
;
234 static void mount_done(Unit
*u
) {
239 m
->where
= mfree(m
->where
);
241 mount_parameters_done(&m
->parameters_proc_self_mountinfo
);
242 mount_parameters_done(&m
->parameters_fragment
);
244 m
->exec_runtime
= exec_runtime_unref(m
->exec_runtime
, false);
245 exec_command_done_array(m
->exec_command
, _MOUNT_EXEC_COMMAND_MAX
);
246 m
->control_command
= NULL
;
248 dynamic_creds_unref(&m
->dynamic_creds
);
250 mount_unwatch_control_pid(m
);
252 m
->timer_event_source
= sd_event_source_unref(m
->timer_event_source
);
255 _pure_
static MountParameters
* get_mount_parameters_fragment(Mount
*m
) {
258 if (m
->from_fragment
)
259 return &m
->parameters_fragment
;
264 _pure_
static MountParameters
* get_mount_parameters(Mount
*m
) {
267 if (m
->from_proc_self_mountinfo
)
268 return &m
->parameters_proc_self_mountinfo
;
270 return get_mount_parameters_fragment(m
);
273 static int mount_add_mount_dependencies(Mount
*m
) {
282 if (!path_equal(m
->where
, "/")) {
283 _cleanup_free_
char *parent
= NULL
;
285 /* Adds in links to other mount points that might lie further up in the hierarchy */
287 parent
= dirname_malloc(m
->where
);
291 r
= unit_require_mounts_for(UNIT(m
), parent
, UNIT_DEPENDENCY_IMPLICIT
);
296 /* Adds in dependencies to other mount points that might be needed for the source path (if this is a bind mount
297 * or a loop mount) to be available. */
298 pm
= get_mount_parameters_fragment(m
);
299 if (pm
&& pm
->what
&&
300 path_is_absolute(pm
->what
) &&
301 (mount_is_bind(pm
) || mount_is_loop(pm
) || !mount_is_network(pm
))) {
303 r
= unit_require_mounts_for(UNIT(m
), pm
->what
, UNIT_DEPENDENCY_FILE
);
308 /* Adds in dependencies to other units that use this path or paths further down in the hierarchy */
309 s
= manager_get_units_requiring_mounts_for(UNIT(m
)->manager
, m
->where
);
310 SET_FOREACH(other
, s
, i
) {
312 if (other
->load_state
!= UNIT_LOADED
)
315 if (other
== UNIT(m
))
318 r
= unit_add_dependency(other
, UNIT_AFTER
, UNIT(m
), true, UNIT_DEPENDENCY_PATH
);
322 if (UNIT(m
)->fragment_path
) {
323 /* If we have fragment configuration, then make this dependency required */
324 r
= unit_add_dependency(other
, UNIT_REQUIRES
, UNIT(m
), true, UNIT_DEPENDENCY_PATH
);
333 static int mount_add_device_dependencies(Mount
*m
) {
334 bool device_wants_mount
= false;
335 UnitDependencyMask mask
;
342 p
= get_mount_parameters(m
);
349 if (mount_is_bind(p
))
352 if (!is_device_path(p
->what
))
355 /* /dev/root is a really weird thing, it's not a real device,
356 * but just a path the kernel exports for the root file system
357 * specified on the kernel command line. Ignore it here. */
358 if (path_equal(p
->what
, "/dev/root"))
361 if (path_equal(m
->where
, "/"))
364 if (mount_is_auto(p
) && !mount_is_automount(p
) && MANAGER_IS_SYSTEM(UNIT(m
)->manager
))
365 device_wants_mount
= true;
367 /* Mount units from /proc/self/mountinfo are not bound to devices
368 * by default since they're subject to races when devices are
369 * unplugged. But the user can still force this dep with an
370 * appropriate option (or udev property) so the mount units are
371 * automatically stopped when the device disappears suddenly. */
372 dep
= mount_is_bound_to_device(m
) ? UNIT_BINDS_TO
: UNIT_REQUIRES
;
374 mask
= m
->from_fragment
? UNIT_DEPENDENCY_FILE
: UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT
;
376 r
= unit_add_node_dependency(UNIT(m
), p
->what
, device_wants_mount
, dep
, mask
);
383 static int mount_add_quota_dependencies(Mount
*m
) {
384 UnitDependencyMask mask
;
390 if (!MANAGER_IS_SYSTEM(UNIT(m
)->manager
))
393 p
= get_mount_parameters_fragment(m
);
400 mask
= m
->from_fragment
? UNIT_DEPENDENCY_FILE
: UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT
;
402 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_BEFORE
, UNIT_WANTS
, SPECIAL_QUOTACHECK_SERVICE
, NULL
, true, mask
);
406 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_BEFORE
, UNIT_WANTS
, SPECIAL_QUOTAON_SERVICE
, NULL
, true, mask
);
413 static bool mount_is_extrinsic(Mount
*m
) {
417 /* Returns true for all units that are "magic" and should be excluded from the usual start-up and shutdown
418 * dependencies. We call them "extrinsic" here, as they are generally mounted outside of the systemd dependency
419 * logic. We shouldn't attempt to manage them ourselves but it's fine if the user operates on them with us. */
421 if (!MANAGER_IS_SYSTEM(UNIT(m
)->manager
)) /* We only automatically manage mounts if we are in system mode */
424 if (PATH_IN_SET(m
->where
, /* Don't bother with the OS data itself */
429 if (PATH_STARTSWITH_SET(m
->where
,
430 "/run/initramfs", /* This should stay around from before we boot until after we shutdown */
431 "/proc", /* All of this is API VFS */
432 "/sys", /* … dito … */
433 "/dev")) /* … dito … */
436 /* If this is an initrd mount, and we are not in the initrd, then leave this around forever, too. */
437 p
= get_mount_parameters(m
);
438 if (p
&& fstab_test_option(p
->options
, "x-initrd.mount\0") && !in_initrd())
444 static int mount_add_default_dependencies(Mount
*m
) {
445 UnitDependencyMask mask
;
452 if (!UNIT(m
)->default_dependencies
)
455 /* We do not add any default dependencies to /, /usr or /run/initramfs/, since they are guaranteed to stay
456 * mounted the whole time, since our system is on it. Also, don't bother with anything mounted below virtual
457 * file systems, it's also going to be virtual, and hence not worth the effort. */
458 if (mount_is_extrinsic(m
))
461 p
= get_mount_parameters(m
);
465 mask
= m
->from_fragment
? UNIT_DEPENDENCY_FILE
: UNIT_DEPENDENCY_MOUNTINFO_DEFAULT
;
467 if (mount_is_network(p
)) {
468 /* We order ourselves after network.target. This is
469 * primarily useful at shutdown: services that take
470 * down the network should order themselves before
471 * network.target, so that they are shut down only
472 * after this mount unit is stopped. */
474 r
= unit_add_dependency_by_name(UNIT(m
), UNIT_AFTER
, SPECIAL_NETWORK_TARGET
, NULL
, true, mask
);
478 /* We pull in network-online.target, and order
479 * ourselves after it. This is useful at start-up to
480 * actively pull in tools that want to be started
481 * before we start mounting network file systems, and
482 * whose purpose it is to delay this until the network
485 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_WANTS
, UNIT_AFTER
, SPECIAL_NETWORK_ONLINE_TARGET
, NULL
, true, mask
);
489 after
= SPECIAL_REMOTE_FS_PRE_TARGET
;
491 after
= SPECIAL_LOCAL_FS_PRE_TARGET
;
493 r
= unit_add_dependency_by_name(UNIT(m
), UNIT_AFTER
, after
, NULL
, true, mask
);
497 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_UMOUNT_TARGET
, NULL
, true, mask
);
501 /* If this is a tmpfs mount then we have to unmount it before we try to deactivate swaps */
502 if (streq_ptr(p
->fstype
, "tmpfs")) {
503 r
= unit_add_dependency_by_name(UNIT(m
), UNIT_AFTER
, SPECIAL_SWAP_TARGET
, NULL
, true, mask
);
511 static int mount_verify(Mount
*m
) {
512 _cleanup_free_
char *e
= NULL
;
518 if (UNIT(m
)->load_state
!= UNIT_LOADED
)
521 if (!m
->from_fragment
&& !m
->from_proc_self_mountinfo
&& !UNIT(m
)->perpetual
)
524 r
= unit_name_from_path(m
->where
, ".mount", &e
);
526 return log_unit_error_errno(UNIT(m
), r
, "Failed to generate unit name from mount path: %m");
528 if (!unit_has_name(UNIT(m
), e
)) {
529 log_unit_error(UNIT(m
), "Where= setting doesn't match unit name. Refusing.");
533 if (mount_point_is_api(m
->where
) || mount_point_ignore(m
->where
)) {
534 log_unit_error(UNIT(m
), "Cannot create mount unit for API file system %s. Refusing.", m
->where
);
538 p
= get_mount_parameters_fragment(m
);
540 log_unit_error(UNIT(m
), "What= setting is missing. Refusing.");
544 if (m
->exec_context
.pam_name
&& m
->kill_context
.kill_mode
!= KILL_CONTROL_GROUP
) {
545 log_unit_error(UNIT(m
), "Unit has PAM enabled. Kill mode must be set to control-group'. Refusing.");
552 static int mount_add_extras(Mount
*m
) {
558 if (u
->fragment_path
)
559 m
->from_fragment
= true;
562 r
= unit_name_to_path(u
->id
, &m
->where
);
567 path_kill_slashes(m
->where
);
569 if (!u
->description
) {
570 r
= unit_set_description(u
, m
->where
);
575 r
= mount_add_device_dependencies(m
);
579 r
= mount_add_mount_dependencies(m
);
583 r
= mount_add_quota_dependencies(m
);
587 r
= unit_patch_contexts(u
);
591 r
= unit_add_exec_dependencies(u
, &m
->exec_context
);
595 r
= unit_set_default_slice(u
);
599 r
= mount_add_default_dependencies(m
);
606 static int mount_load_root_mount(Unit
*u
) {
609 if (!unit_has_name(u
, SPECIAL_ROOT_MOUNT
))
613 u
->default_dependencies
= false;
615 /* The stdio/kmsg bridge socket is on /, in order to avoid a dep loop, don't use kmsg logging for -.mount */
616 MOUNT(u
)->exec_context
.std_output
= EXEC_OUTPUT_NULL
;
617 MOUNT(u
)->exec_context
.std_input
= EXEC_INPUT_NULL
;
620 u
->description
= strdup("Root Mount");
625 static int mount_load(Unit
*u
) {
630 assert(u
->load_state
== UNIT_STUB
);
632 r
= mount_load_root_mount(u
);
636 if (m
->from_proc_self_mountinfo
|| u
->perpetual
)
637 r
= unit_load_fragment_and_dropin_optional(u
);
639 r
= unit_load_fragment_and_dropin(u
);
643 /* This is a new unit? Then let's add in some extras */
644 if (u
->load_state
== UNIT_LOADED
) {
645 r
= mount_add_extras(m
);
650 return mount_verify(m
);
653 static void mount_set_state(Mount
*m
, MountState state
) {
654 MountState old_state
;
657 old_state
= m
->state
;
660 if (!MOUNT_STATE_WITH_PROCESS(state
)) {
661 m
->timer_event_source
= sd_event_source_unref(m
->timer_event_source
);
662 mount_unwatch_control_pid(m
);
663 m
->control_command
= NULL
;
664 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
667 if (state
!= old_state
)
668 log_unit_debug(UNIT(m
), "Changed %s -> %s", mount_state_to_string(old_state
), mount_state_to_string(state
));
670 unit_notify(UNIT(m
), state_translation_table
[old_state
], state_translation_table
[state
], m
->reload_result
== MOUNT_SUCCESS
);
673 static int mount_coldplug(Unit
*u
) {
675 MountState new_state
= MOUNT_DEAD
;
679 assert(m
->state
== MOUNT_DEAD
);
681 if (m
->deserialized_state
!= m
->state
)
682 new_state
= m
->deserialized_state
;
683 else if (m
->from_proc_self_mountinfo
)
684 new_state
= MOUNT_MOUNTED
;
686 if (new_state
== m
->state
)
689 if (m
->control_pid
> 0 &&
690 pid_is_unwaited(m
->control_pid
) &&
691 MOUNT_STATE_WITH_PROCESS(new_state
)) {
693 r
= unit_watch_pid(UNIT(m
), m
->control_pid
);
697 r
= mount_arm_timer(m
, usec_add(u
->state_change_timestamp
.monotonic
, m
->timeout_usec
));
702 if (!IN_SET(new_state
, MOUNT_DEAD
, MOUNT_FAILED
)) {
703 (void) unit_setup_dynamic_creds(u
);
704 (void) unit_setup_exec_runtime(u
);
707 mount_set_state(m
, new_state
);
711 static void mount_dump(Unit
*u
, FILE *f
, const char *prefix
) {
712 char buf
[FORMAT_TIMESPAN_MAX
];
719 p
= get_mount_parameters(m
);
722 "%sMount State: %s\n"
726 "%sFile System Type: %s\n"
728 "%sFrom /proc/self/mountinfo: %s\n"
729 "%sFrom fragment: %s\n"
731 "%sDirectoryMode: %04o\n"
732 "%sSloppyOptions: %s\n"
733 "%sLazyUnmount: %s\n"
734 "%sForceUnmount: %s\n"
736 prefix
, mount_state_to_string(m
->state
),
737 prefix
, mount_result_to_string(m
->result
),
739 prefix
, p
? strna(p
->what
) : "n/a",
740 prefix
, p
? strna(p
->fstype
) : "n/a",
741 prefix
, p
? strna(p
->options
) : "n/a",
742 prefix
, yes_no(m
->from_proc_self_mountinfo
),
743 prefix
, yes_no(m
->from_fragment
),
744 prefix
, yes_no(mount_is_extrinsic(m
)),
745 prefix
, m
->directory_mode
,
746 prefix
, yes_no(m
->sloppy_options
),
747 prefix
, yes_no(m
->lazy_unmount
),
748 prefix
, yes_no(m
->force_unmount
),
749 prefix
, format_timespan(buf
, sizeof(buf
), m
->timeout_usec
, USEC_PER_SEC
));
751 if (m
->control_pid
> 0)
753 "%sControl PID: "PID_FMT
"\n",
754 prefix
, m
->control_pid
);
756 exec_context_dump(&m
->exec_context
, f
, prefix
);
757 kill_context_dump(&m
->kill_context
, f
, prefix
);
758 cgroup_context_dump(&m
->cgroup_context
, f
, prefix
);
761 static int mount_spawn(Mount
*m
, ExecCommand
*c
, pid_t
*_pid
) {
763 ExecParameters exec_params
= {
764 .flags
= EXEC_APPLY_SANDBOXING
|EXEC_APPLY_CHROOT
|EXEC_APPLY_TTY_STDIN
,
776 r
= unit_prepare_exec(UNIT(m
));
780 r
= mount_arm_timer(m
, usec_add(now(CLOCK_MONOTONIC
), m
->timeout_usec
));
784 manager_set_exec_params(UNIT(m
)->manager
, &exec_params
);
785 unit_set_exec_params(UNIT(m
), &exec_params
);
787 r
= exec_spawn(UNIT(m
),
797 r
= unit_watch_pid(UNIT(m
), pid
);
799 /* FIXME: we need to do something here */
807 static void mount_enter_dead(Mount
*m
, MountResult f
) {
810 if (m
->result
== MOUNT_SUCCESS
)
813 if (m
->result
!= MOUNT_SUCCESS
)
814 log_unit_warning(UNIT(m
), "Failed with result '%s'.", mount_result_to_string(m
->result
));
816 mount_set_state(m
, m
->result
!= MOUNT_SUCCESS
? MOUNT_FAILED
: MOUNT_DEAD
);
818 m
->exec_runtime
= exec_runtime_unref(m
->exec_runtime
, true);
820 exec_context_destroy_runtime_directory(&m
->exec_context
, UNIT(m
)->manager
->prefix
[EXEC_DIRECTORY_RUNTIME
]);
822 unit_unref_uid_gid(UNIT(m
), true);
824 dynamic_creds_destroy(&m
->dynamic_creds
);
827 static void mount_enter_mounted(Mount
*m
, MountResult f
) {
830 if (m
->result
== MOUNT_SUCCESS
)
833 mount_set_state(m
, MOUNT_MOUNTED
);
836 static void mount_enter_dead_or_mounted(Mount
*m
, MountResult f
) {
839 /* Enter DEAD or MOUNTED state, depending on what the kernel currently says about the mount point. We use this
840 * whenever we executed an operation, so that our internal state reflects what the kernel says again, after all
841 * ultimately we just mirror the kernel's internal state on this. */
843 if (m
->from_proc_self_mountinfo
)
844 mount_enter_mounted(m
, f
);
846 mount_enter_dead(m
, f
);
849 static int state_to_kill_operation(MountState state
) {
852 case MOUNT_REMOUNTING_SIGTERM
:
853 case MOUNT_UNMOUNTING_SIGTERM
:
854 return KILL_TERMINATE
;
856 case MOUNT_REMOUNTING_SIGKILL
:
857 case MOUNT_UNMOUNTING_SIGKILL
:
861 return _KILL_OPERATION_INVALID
;
865 static void mount_enter_signal(Mount
*m
, MountState state
, MountResult f
) {
870 if (m
->result
== MOUNT_SUCCESS
)
873 r
= unit_kill_context(
876 state_to_kill_operation(state
),
884 r
= mount_arm_timer(m
, usec_add(now(CLOCK_MONOTONIC
), m
->timeout_usec
));
888 mount_set_state(m
, state
);
889 } else if (state
== MOUNT_REMOUNTING_SIGTERM
&& m
->kill_context
.send_sigkill
)
890 mount_enter_signal(m
, MOUNT_REMOUNTING_SIGKILL
, MOUNT_SUCCESS
);
891 else if (IN_SET(state
, MOUNT_REMOUNTING_SIGTERM
, MOUNT_REMOUNTING_SIGKILL
))
892 mount_enter_mounted(m
, MOUNT_SUCCESS
);
893 else if (state
== MOUNT_UNMOUNTING_SIGTERM
&& m
->kill_context
.send_sigkill
)
894 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGKILL
, MOUNT_SUCCESS
);
896 mount_enter_dead_or_mounted(m
, MOUNT_SUCCESS
);
901 log_unit_warning_errno(UNIT(m
), r
, "Failed to kill processes: %m");
902 mount_enter_dead_or_mounted(m
, MOUNT_FAILURE_RESOURCES
);
905 static void mount_enter_unmounting(Mount
*m
) {
910 /* Start counting our attempts */
911 if (!IN_SET(m
->state
,
913 MOUNT_UNMOUNTING_SIGTERM
,
914 MOUNT_UNMOUNTING_SIGKILL
))
915 m
->n_retry_umount
= 0;
917 m
->control_command_id
= MOUNT_EXEC_UNMOUNT
;
918 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_UNMOUNT
;
920 r
= exec_command_set(m
->control_command
, UMOUNT_PATH
, m
->where
, "-c", NULL
);
921 if (r
>= 0 && m
->lazy_unmount
)
922 r
= exec_command_append(m
->control_command
, "-l", NULL
);
923 if (r
>= 0 && m
->force_unmount
)
924 r
= exec_command_append(m
->control_command
, "-f", NULL
);
928 mount_unwatch_control_pid(m
);
930 r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
);
934 mount_set_state(m
, MOUNT_UNMOUNTING
);
939 log_unit_warning_errno(UNIT(m
), r
, "Failed to run 'umount' task: %m");
940 mount_enter_dead_or_mounted(m
, MOUNT_FAILURE_RESOURCES
);
943 static void mount_enter_mounting(Mount
*m
) {
949 r
= unit_fail_if_noncanonical(UNIT(m
), m
->where
);
953 (void) mkdir_p_label(m
->where
, m
->directory_mode
);
955 unit_warn_if_dir_nonempty(UNIT(m
), m
->where
);
957 unit_warn_leftover_processes(UNIT(m
));
959 m
->control_command_id
= MOUNT_EXEC_MOUNT
;
960 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_MOUNT
;
962 /* Create the source directory for bind-mounts if needed */
963 p
= get_mount_parameters_fragment(m
);
964 if (p
&& mount_is_bind(p
))
965 (void) mkdir_p_label(p
->what
, m
->directory_mode
);
968 _cleanup_free_
char *opts
= NULL
;
970 r
= fstab_filter_options(p
->options
, "nofail\0" "noauto\0" "auto\0", NULL
, NULL
, &opts
);
974 r
= exec_command_set(m
->control_command
, MOUNT_PATH
, p
->what
, m
->where
, NULL
);
975 if (r
>= 0 && m
->sloppy_options
)
976 r
= exec_command_append(m
->control_command
, "-s", NULL
);
977 if (r
>= 0 && p
->fstype
)
978 r
= exec_command_append(m
->control_command
, "-t", p
->fstype
, NULL
);
979 if (r
>= 0 && !isempty(opts
))
980 r
= exec_command_append(m
->control_command
, "-o", opts
, NULL
);
986 mount_unwatch_control_pid(m
);
988 r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
);
992 mount_set_state(m
, MOUNT_MOUNTING
);
997 log_unit_warning_errno(UNIT(m
), r
, "Failed to run 'mount' task: %m");
998 mount_enter_dead_or_mounted(m
, MOUNT_FAILURE_RESOURCES
);
1001 static void mount_set_reload_result(Mount
*m
, MountResult result
) {
1004 /* Only store the first error we encounter */
1005 if (m
->reload_result
!= MOUNT_SUCCESS
)
1008 m
->reload_result
= result
;
1011 static void mount_enter_remounting(Mount
*m
) {
1017 /* Reset reload result when we are about to start a new remount operation */
1018 m
->reload_result
= MOUNT_SUCCESS
;
1020 m
->control_command_id
= MOUNT_EXEC_REMOUNT
;
1021 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_REMOUNT
;
1023 p
= get_mount_parameters_fragment(m
);
1028 o
= strjoina("remount,", p
->options
);
1032 r
= exec_command_set(m
->control_command
, MOUNT_PATH
,
1035 if (r
>= 0 && m
->sloppy_options
)
1036 r
= exec_command_append(m
->control_command
, "-s", NULL
);
1037 if (r
>= 0 && p
->fstype
)
1038 r
= exec_command_append(m
->control_command
, "-t", p
->fstype
, NULL
);
1044 mount_unwatch_control_pid(m
);
1046 r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
);
1050 mount_set_state(m
, MOUNT_REMOUNTING
);
1055 log_unit_warning_errno(UNIT(m
), r
, "Failed to run 'remount' task: %m");
1056 mount_set_reload_result(m
, MOUNT_FAILURE_RESOURCES
);
1057 mount_enter_dead_or_mounted(m
, MOUNT_SUCCESS
);
1060 static int mount_start(Unit
*u
) {
1061 Mount
*m
= MOUNT(u
);
1066 /* We cannot fulfill this request right now, try again later
1068 if (IN_SET(m
->state
,
1070 MOUNT_UNMOUNTING_SIGTERM
,
1071 MOUNT_UNMOUNTING_SIGKILL
))
1074 /* Already on it! */
1075 if (m
->state
== MOUNT_MOUNTING
)
1078 assert(IN_SET(m
->state
, MOUNT_DEAD
, MOUNT_FAILED
));
1080 r
= unit_start_limit_test(u
);
1082 mount_enter_dead(m
, MOUNT_FAILURE_START_LIMIT_HIT
);
1086 r
= unit_acquire_invocation_id(u
);
1090 m
->result
= MOUNT_SUCCESS
;
1091 m
->reload_result
= MOUNT_SUCCESS
;
1093 u
->reset_accounting
= true;
1095 mount_enter_mounting(m
);
1099 static int mount_stop(Unit
*u
) {
1100 Mount
*m
= MOUNT(u
);
1106 case MOUNT_UNMOUNTING
:
1107 case MOUNT_UNMOUNTING_SIGKILL
:
1108 case MOUNT_UNMOUNTING_SIGTERM
:
1112 case MOUNT_MOUNTING
:
1113 case MOUNT_MOUNTING_DONE
:
1114 case MOUNT_REMOUNTING
:
1115 /* If we are still waiting for /bin/mount, we go directly into kill mode. */
1116 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGTERM
, MOUNT_SUCCESS
);
1119 case MOUNT_REMOUNTING_SIGTERM
:
1120 /* If we are already waiting for a hung remount, convert this to the matching unmounting state */
1121 mount_set_state(m
, MOUNT_UNMOUNTING_SIGTERM
);
1124 case MOUNT_REMOUNTING_SIGKILL
:
1126 mount_set_state(m
, MOUNT_UNMOUNTING_SIGKILL
);
1130 mount_enter_unmounting(m
);
1134 assert_not_reached("Unexpected state.");
1138 static int mount_reload(Unit
*u
) {
1139 Mount
*m
= MOUNT(u
);
1142 assert(m
->state
== MOUNT_MOUNTED
);
1144 mount_enter_remounting(m
);
1149 static int mount_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
1150 Mount
*m
= MOUNT(u
);
1156 unit_serialize_item(u
, f
, "state", mount_state_to_string(m
->state
));
1157 unit_serialize_item(u
, f
, "result", mount_result_to_string(m
->result
));
1158 unit_serialize_item(u
, f
, "reload-result", mount_result_to_string(m
->reload_result
));
1160 if (m
->control_pid
> 0)
1161 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, m
->control_pid
);
1163 if (m
->control_command_id
>= 0)
1164 unit_serialize_item(u
, f
, "control-command", mount_exec_command_to_string(m
->control_command_id
));
1169 static int mount_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
1170 Mount
*m
= MOUNT(u
);
1177 if (streq(key
, "state")) {
1180 if ((state
= mount_state_from_string(value
)) < 0)
1181 log_unit_debug(u
, "Failed to parse state value: %s", value
);
1183 m
->deserialized_state
= state
;
1184 } else if (streq(key
, "result")) {
1187 f
= mount_result_from_string(value
);
1189 log_unit_debug(u
, "Failed to parse result value: %s", value
);
1190 else if (f
!= MOUNT_SUCCESS
)
1193 } else if (streq(key
, "reload-result")) {
1196 f
= mount_result_from_string(value
);
1198 log_unit_debug(u
, "Failed to parse reload result value: %s", value
);
1199 else if (f
!= MOUNT_SUCCESS
)
1200 m
->reload_result
= f
;
1202 } else if (streq(key
, "control-pid")) {
1205 if (parse_pid(value
, &pid
) < 0)
1206 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
1208 m
->control_pid
= pid
;
1209 } else if (streq(key
, "control-command")) {
1210 MountExecCommand id
;
1212 id
= mount_exec_command_from_string(value
);
1214 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
1216 m
->control_command_id
= id
;
1217 m
->control_command
= m
->exec_command
+ id
;
1220 log_unit_debug(u
, "Unknown serialization key: %s", key
);
1225 _pure_
static UnitActiveState
mount_active_state(Unit
*u
) {
1228 return state_translation_table
[MOUNT(u
)->state
];
1231 _pure_
static const char *mount_sub_state_to_string(Unit
*u
) {
1234 return mount_state_to_string(MOUNT(u
)->state
);
1237 _pure_
static bool mount_may_gc(Unit
*u
) {
1238 Mount
*m
= MOUNT(u
);
1242 if (m
->from_proc_self_mountinfo
)
1248 static void mount_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
1249 Mount
*m
= MOUNT(u
);
1255 if (pid
!= m
->control_pid
)
1260 if (is_clean_exit(code
, status
, EXIT_CLEAN_COMMAND
, NULL
))
1262 else if (code
== CLD_EXITED
)
1263 f
= MOUNT_FAILURE_EXIT_CODE
;
1264 else if (code
== CLD_KILLED
)
1265 f
= MOUNT_FAILURE_SIGNAL
;
1266 else if (code
== CLD_DUMPED
)
1267 f
= MOUNT_FAILURE_CORE_DUMP
;
1269 assert_not_reached("Unknown code");
1271 if (IN_SET(m
->state
, MOUNT_REMOUNTING
, MOUNT_REMOUNTING_SIGKILL
, MOUNT_REMOUNTING_SIGTERM
))
1272 mount_set_reload_result(m
, f
);
1273 else if (m
->result
== MOUNT_SUCCESS
)
1276 if (m
->control_command
) {
1277 exec_status_exit(&m
->control_command
->exec_status
, &m
->exec_context
, pid
, code
, status
);
1279 m
->control_command
= NULL
;
1280 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
1283 log_unit_full(u
, f
== MOUNT_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
1284 "Mount process exited, code=%s status=%i", sigchld_code_to_string(code
), status
);
1286 /* Note that due to the io event priority logic, we can be sure the new mountinfo is loaded
1287 * before we process the SIGCHLD for the mount command. */
1291 case MOUNT_MOUNTING
:
1292 /* Our mount point has not appeared in mountinfo. Something went wrong. */
1294 if (f
== MOUNT_SUCCESS
) {
1295 /* Either /bin/mount has an unexpected definition of success,
1296 * or someone raced us and we lost. */
1297 log_unit_warning(UNIT(m
), "Mount process finished, but there is no mount.");
1298 f
= MOUNT_FAILURE_PROTOCOL
;
1300 mount_enter_dead(m
, f
);
1303 case MOUNT_MOUNTING_DONE
:
1304 mount_enter_mounted(m
, f
);
1307 case MOUNT_REMOUNTING
:
1308 case MOUNT_REMOUNTING_SIGTERM
:
1309 case MOUNT_REMOUNTING_SIGKILL
:
1310 mount_enter_dead_or_mounted(m
, MOUNT_SUCCESS
);
1313 case MOUNT_UNMOUNTING
:
1315 if (f
== MOUNT_SUCCESS
&& m
->from_proc_self_mountinfo
) {
1317 /* Still a mount point? If so, let's try again. Most likely there were multiple mount points
1318 * stacked on top of each other. We might exceed the timeout specified by the user overall,
1319 * but we will stop as soon as any one umount times out. */
1321 if (m
->n_retry_umount
< RETRY_UMOUNT_MAX
) {
1322 log_unit_debug(u
, "Mount still present, trying again.");
1323 m
->n_retry_umount
++;
1324 mount_enter_unmounting(m
);
1326 log_unit_warning(u
, "Mount still present after %u attempts to unmount, giving up.", m
->n_retry_umount
);
1327 mount_enter_mounted(m
, f
);
1330 mount_enter_dead_or_mounted(m
, f
);
1334 case MOUNT_UNMOUNTING_SIGKILL
:
1335 case MOUNT_UNMOUNTING_SIGTERM
:
1336 mount_enter_dead_or_mounted(m
, f
);
1340 assert_not_reached("Uh, control process died at wrong time.");
1343 /* Notify clients about changed exit status */
1344 unit_add_to_dbus_queue(u
);
1347 static int mount_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
1348 Mount
*m
= MOUNT(userdata
);
1351 assert(m
->timer_event_source
== source
);
1355 case MOUNT_MOUNTING
:
1356 case MOUNT_MOUNTING_DONE
:
1357 log_unit_warning(UNIT(m
), "Mounting timed out. Terminating.");
1358 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGTERM
, MOUNT_FAILURE_TIMEOUT
);
1361 case MOUNT_REMOUNTING
:
1362 log_unit_warning(UNIT(m
), "Remounting timed out. Terminating remount process.");
1363 mount_set_reload_result(m
, MOUNT_FAILURE_TIMEOUT
);
1364 mount_enter_signal(m
, MOUNT_REMOUNTING_SIGTERM
, MOUNT_SUCCESS
);
1367 case MOUNT_REMOUNTING_SIGTERM
:
1368 mount_set_reload_result(m
, MOUNT_FAILURE_TIMEOUT
);
1370 if (m
->kill_context
.send_sigkill
) {
1371 log_unit_warning(UNIT(m
), "Remounting timed out. Killing.");
1372 mount_enter_signal(m
, MOUNT_REMOUNTING_SIGKILL
, MOUNT_SUCCESS
);
1374 log_unit_warning(UNIT(m
), "Remounting timed out. Skipping SIGKILL. Ignoring.");
1375 mount_enter_dead_or_mounted(m
, MOUNT_SUCCESS
);
1379 case MOUNT_REMOUNTING_SIGKILL
:
1380 mount_set_reload_result(m
, MOUNT_FAILURE_TIMEOUT
);
1382 log_unit_warning(UNIT(m
), "Mount process still around after SIGKILL. Ignoring.");
1383 mount_enter_dead_or_mounted(m
, MOUNT_SUCCESS
);
1386 case MOUNT_UNMOUNTING
:
1387 log_unit_warning(UNIT(m
), "Unmounting timed out. Terminating.");
1388 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGTERM
, MOUNT_FAILURE_TIMEOUT
);
1391 case MOUNT_UNMOUNTING_SIGTERM
:
1392 if (m
->kill_context
.send_sigkill
) {
1393 log_unit_warning(UNIT(m
), "Mount process timed out. Killing.");
1394 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGKILL
, MOUNT_FAILURE_TIMEOUT
);
1396 log_unit_warning(UNIT(m
), "Mount process timed out. Skipping SIGKILL. Ignoring.");
1397 mount_enter_dead_or_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1401 case MOUNT_UNMOUNTING_SIGKILL
:
1402 log_unit_warning(UNIT(m
), "Mount process still around after SIGKILL. Ignoring.");
1403 mount_enter_dead_or_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1407 assert_not_reached("Timeout at wrong time.");
1419 static int mount_setup_new_unit(
1423 const char *options
,
1425 MountSetupFlags
*flags
) {
1432 u
->source_path
= strdup("/proc/self/mountinfo");
1433 MOUNT(u
)->where
= strdup(where
);
1434 if (!u
->source_path
|| !MOUNT(u
)->where
)
1437 /* Make sure to initialize those fields before mount_is_extrinsic(). */
1438 MOUNT(u
)->from_proc_self_mountinfo
= true;
1439 p
= &MOUNT(u
)->parameters_proc_self_mountinfo
;
1441 p
->what
= strdup(what
);
1442 p
->options
= strdup(options
);
1443 p
->fstype
= strdup(fstype
);
1444 if (!p
->what
|| !p
->options
|| !p
->fstype
)
1447 if (!mount_is_extrinsic(MOUNT(u
))) {
1451 target
= mount_is_network(p
) ? SPECIAL_REMOTE_FS_TARGET
: SPECIAL_LOCAL_FS_TARGET
;
1452 r
= unit_add_dependency_by_name(u
, UNIT_BEFORE
, target
, NULL
, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT
);
1456 r
= unit_add_dependency_by_name(u
, UNIT_CONFLICTS
, SPECIAL_UMOUNT_TARGET
, NULL
, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT
);
1461 unit_add_to_load_queue(u
);
1462 flags
->is_mounted
= true;
1463 flags
->just_mounted
= true;
1464 flags
->just_changed
= true;
1469 static int mount_setup_existing_unit(
1473 const char *options
,
1475 MountSetupFlags
*flags
) {
1478 bool load_extras
= false;
1484 if (!MOUNT(u
)->where
) {
1485 MOUNT(u
)->where
= strdup(where
);
1486 if (!MOUNT(u
)->where
)
1490 /* Make sure to initialize those fields before mount_is_extrinsic(). */
1491 p
= &MOUNT(u
)->parameters_proc_self_mountinfo
;
1493 r1
= free_and_strdup(&p
->what
, what
);
1494 r2
= free_and_strdup(&p
->options
, options
);
1495 r3
= free_and_strdup(&p
->fstype
, fstype
);
1496 if (r1
< 0 || r2
< 0 || r3
< 0)
1499 flags
->just_changed
= r1
> 0 || r2
> 0 || r3
> 0;
1500 flags
->is_mounted
= true;
1501 flags
->just_mounted
= !MOUNT(u
)->from_proc_self_mountinfo
|| MOUNT(u
)->just_mounted
;
1503 MOUNT(u
)->from_proc_self_mountinfo
= true;
1505 if (!mount_is_extrinsic(MOUNT(u
)) && mount_is_network(p
)) {
1506 /* _netdev option may have shown up late, or on a
1507 * remount. Add remote-fs dependencies, even though
1508 * local-fs ones may already be there.
1510 * Note: due to a current limitation (we don't track
1511 * in the dependency "Set*" objects who created a
1512 * dependency), we can only add deps, never lose them,
1513 * until the next full daemon-reload. */
1514 unit_add_dependency_by_name(u
, UNIT_BEFORE
, SPECIAL_REMOTE_FS_TARGET
, NULL
, true, UNIT_DEPENDENCY_MOUNTINFO_IMPLICIT
);
1518 if (u
->load_state
== UNIT_NOT_FOUND
) {
1519 u
->load_state
= UNIT_LOADED
;
1522 /* Load in the extras later on, after we
1523 * finished initialization of the unit */
1525 /* FIXME: since we're going to load the unit later on, why setting load_extras=true ? */
1527 flags
->just_changed
= true;
1531 return mount_add_extras(MOUNT(u
));
1536 static int mount_setup_unit(
1540 const char *options
,
1544 _cleanup_free_
char *e
= NULL
;
1545 MountSetupFlags flags
;
1555 /* Ignore API mount points. They should never be referenced in
1556 * dependencies ever. */
1557 if (mount_point_is_api(where
) || mount_point_ignore(where
))
1560 if (streq(fstype
, "autofs"))
1563 /* probably some kind of swap, ignore */
1564 if (!is_path(where
))
1567 r
= unit_name_from_path(where
, ".mount", &e
);
1571 u
= manager_get_unit(m
, e
);
1573 /* First time we see this mount point meaning that it's
1574 * not been initiated by a mount unit but rather by the
1575 * sysadmin having called mount(8) directly. */
1576 r
= unit_new_for_name(m
, sizeof(Mount
), e
, &u
);
1580 r
= mount_setup_new_unit(u
, what
, where
, options
, fstype
, &flags
);
1584 r
= mount_setup_existing_unit(u
, what
, where
, options
, fstype
, &flags
);
1590 MOUNT(u
)->is_mounted
= flags
.is_mounted
;
1591 MOUNT(u
)->just_mounted
= flags
.just_mounted
;
1592 MOUNT(u
)->just_changed
= flags
.just_changed
;
1595 if (flags
.just_changed
)
1596 unit_add_to_dbus_queue(u
);
1600 log_warning_errno(r
, "Failed to set up mount unit: %m");
1604 static int mount_load_proc_self_mountinfo(Manager
*m
, bool set_flags
) {
1605 _cleanup_(mnt_free_tablep
) struct libmnt_table
*t
= NULL
;
1606 _cleanup_(mnt_free_iterp
) struct libmnt_iter
*i
= NULL
;
1611 t
= mnt_new_table();
1615 i
= mnt_new_iter(MNT_ITER_FORWARD
);
1619 r
= mnt_table_parse_mtab(t
, NULL
);
1621 return log_error_errno(r
, "Failed to parse /proc/self/mountinfo: %m");
1625 const char *device
, *path
, *options
, *fstype
;
1626 _cleanup_free_
char *d
= NULL
, *p
= NULL
;
1627 struct libmnt_fs
*fs
;
1630 k
= mnt_table_next_fs(t
, i
, &fs
);
1634 return log_error_errno(k
, "Failed to get next entry from /proc/self/mountinfo: %m");
1636 device
= mnt_fs_get_source(fs
);
1637 path
= mnt_fs_get_target(fs
);
1638 options
= mnt_fs_get_options(fs
);
1639 fstype
= mnt_fs_get_fstype(fs
);
1641 if (!device
|| !path
)
1644 if (cunescape(device
, UNESCAPE_RELAX
, &d
) < 0)
1647 if (cunescape(path
, UNESCAPE_RELAX
, &p
) < 0)
1650 (void) device_found_node(m
, d
, true, DEVICE_FOUND_MOUNT
, set_flags
);
1652 k
= mount_setup_unit(m
, d
, p
, options
, fstype
, set_flags
);
1653 if (r
== 0 && k
< 0)
1660 static void mount_shutdown(Manager
*m
) {
1663 m
->mount_event_source
= sd_event_source_unref(m
->mount_event_source
);
1665 mnt_unref_monitor(m
->mount_monitor
);
1666 m
->mount_monitor
= NULL
;
1669 static int mount_get_timeout(Unit
*u
, usec_t
*timeout
) {
1670 Mount
*m
= MOUNT(u
);
1674 if (!m
->timer_event_source
)
1677 r
= sd_event_source_get_time(m
->timer_event_source
, &t
);
1680 if (t
== USEC_INFINITY
)
1687 static int synthesize_root_mount(Manager
*m
) {
1693 /* Whatever happens, we know for sure that the root directory is around, and cannot go away. Let's
1694 * unconditionally synthesize it here and mark it as perpetual. */
1696 u
= manager_get_unit(m
, SPECIAL_ROOT_MOUNT
);
1698 r
= unit_new_for_name(m
, sizeof(Mount
), SPECIAL_ROOT_MOUNT
, &u
);
1700 return log_error_errno(r
, "Failed to allocate the special " SPECIAL_ROOT_MOUNT
" unit: %m");
1703 u
->perpetual
= true;
1704 MOUNT(u
)->deserialized_state
= MOUNT_MOUNTED
;
1706 unit_add_to_load_queue(u
);
1707 unit_add_to_dbus_queue(u
);
1712 static bool mount_is_mounted(Mount
*m
) {
1715 return UNIT(m
)->perpetual
|| m
->is_mounted
;
1718 static void mount_enumerate(Manager
*m
) {
1723 r
= synthesize_root_mount(m
);
1729 if (!m
->mount_monitor
) {
1732 m
->mount_monitor
= mnt_new_monitor();
1733 if (!m
->mount_monitor
) {
1738 r
= mnt_monitor_enable_kernel(m
->mount_monitor
, 1);
1740 log_error_errno(r
, "Failed to enable watching of kernel mount events: %m");
1744 r
= mnt_monitor_enable_userspace(m
->mount_monitor
, 1, NULL
);
1746 log_error_errno(r
, "Failed to enable watching of userspace mount events: %m");
1750 /* mnt_unref_monitor() will close the fd */
1751 fd
= r
= mnt_monitor_get_fd(m
->mount_monitor
);
1753 log_error_errno(r
, "Failed to acquire watch file descriptor: %m");
1757 r
= sd_event_add_io(m
->event
, &m
->mount_event_source
, fd
, EPOLLIN
, mount_dispatch_io
, m
);
1759 log_error_errno(r
, "Failed to watch mount file descriptor: %m");
1763 r
= sd_event_source_set_priority(m
->mount_event_source
, SD_EVENT_PRIORITY_NORMAL
-10);
1765 log_error_errno(r
, "Failed to adjust mount watch priority: %m");
1769 (void) sd_event_source_set_description(m
->mount_event_source
, "mount-monitor-dispatch");
1772 r
= mount_load_proc_self_mountinfo(m
, false);
1782 static int mount_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
1783 _cleanup_set_free_ Set
*around
= NULL
, *gone
= NULL
;
1784 Manager
*m
= userdata
;
1791 assert(revents
& EPOLLIN
);
1793 if (fd
== mnt_monitor_get_fd(m
->mount_monitor
)) {
1794 bool rescan
= false;
1796 /* Drain all events and verify that the event is valid.
1798 * Note that libmount also monitors /run/mount mkdir if the
1799 * directory does not exist yet. The mkdir may generate event
1800 * which is irrelevant for us.
1802 * error: r < 0; valid: r == 0, false positive: rc == 1 */
1804 r
= mnt_monitor_next_change(m
->mount_monitor
, NULL
, NULL
);
1808 return log_error_errno(r
, "Failed to drain libmount events");
1811 log_debug("libmount event [rescan: %s]", yes_no(rescan
));
1816 r
= mount_load_proc_self_mountinfo(m
, true);
1818 /* Reset flags, just in case, for later calls */
1819 LIST_FOREACH(units_by_type
, u
, m
->units_by_type
[UNIT_MOUNT
]) {
1820 Mount
*mount
= MOUNT(u
);
1822 mount
->is_mounted
= mount
->just_mounted
= mount
->just_changed
= false;
1828 manager_dispatch_load_queue(m
);
1830 LIST_FOREACH(units_by_type
, u
, m
->units_by_type
[UNIT_MOUNT
]) {
1831 Mount
*mount
= MOUNT(u
);
1833 if (!mount_is_mounted(mount
)) {
1835 /* A mount point is not around right now. It
1836 * might be gone, or might never have
1839 if (mount
->from_proc_self_mountinfo
&&
1840 mount
->parameters_proc_self_mountinfo
.what
) {
1842 /* Remember that this device might just have disappeared */
1843 if (set_ensure_allocated(&gone
, &string_hash_ops
) < 0 ||
1844 set_put(gone
, mount
->parameters_proc_self_mountinfo
.what
) < 0)
1845 log_oom(); /* we don't care too much about OOM here... */
1848 mount
->from_proc_self_mountinfo
= false;
1850 switch (mount
->state
) {
1853 /* This has just been unmounted by
1854 * somebody else, follow the state
1856 mount
->result
= MOUNT_SUCCESS
; /* make sure we forget any earlier umount failures */
1857 mount_enter_dead(mount
, MOUNT_SUCCESS
);
1864 } else if (mount
->just_mounted
|| mount
->just_changed
) {
1866 /* A mount point was added or changed */
1868 switch (mount
->state
) {
1873 /* This has just been mounted by somebody else, follow the state change, but let's
1874 * generate a new invocation ID for this implicitly and automatically. */
1875 (void) unit_acquire_invocation_id(UNIT(mount
));
1876 mount_enter_mounted(mount
, MOUNT_SUCCESS
);
1879 case MOUNT_MOUNTING
:
1880 mount_set_state(mount
, MOUNT_MOUNTING_DONE
);
1884 /* Nothing really changed, but let's
1885 * issue an notification call
1886 * nonetheless, in case somebody is
1887 * waiting for this. (e.g. file system
1888 * ro/rw remounts.) */
1889 mount_set_state(mount
, mount
->state
);
1894 if (mount_is_mounted(mount
) &&
1895 mount
->from_proc_self_mountinfo
&&
1896 mount
->parameters_proc_self_mountinfo
.what
) {
1898 if (set_ensure_allocated(&around
, &string_hash_ops
) < 0 ||
1899 set_put(around
, mount
->parameters_proc_self_mountinfo
.what
) < 0)
1903 /* Reset the flags for later calls */
1904 mount
->is_mounted
= mount
->just_mounted
= mount
->just_changed
= false;
1907 SET_FOREACH(what
, gone
, i
) {
1908 if (set_contains(around
, what
))
1911 /* Let the device units know that the device is no longer mounted */
1912 (void) device_found_node(m
, what
, false, DEVICE_FOUND_MOUNT
, true);
1918 static void mount_reset_failed(Unit
*u
) {
1919 Mount
*m
= MOUNT(u
);
1923 if (m
->state
== MOUNT_FAILED
)
1924 mount_set_state(m
, MOUNT_DEAD
);
1926 m
->result
= MOUNT_SUCCESS
;
1927 m
->reload_result
= MOUNT_SUCCESS
;
1930 static int mount_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
1931 Mount
*m
= MOUNT(u
);
1935 return unit_kill_common(u
, who
, signo
, -1, MOUNT(u
)->control_pid
, error
);
1938 static int mount_control_pid(Unit
*u
) {
1939 Mount
*m
= MOUNT(u
);
1943 return m
->control_pid
;
1946 static const char* const mount_exec_command_table
[_MOUNT_EXEC_COMMAND_MAX
] = {
1947 [MOUNT_EXEC_MOUNT
] = "ExecMount",
1948 [MOUNT_EXEC_UNMOUNT
] = "ExecUnmount",
1949 [MOUNT_EXEC_REMOUNT
] = "ExecRemount",
1952 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command
, MountExecCommand
);
1954 static const char* const mount_result_table
[_MOUNT_RESULT_MAX
] = {
1955 [MOUNT_SUCCESS
] = "success",
1956 [MOUNT_FAILURE_RESOURCES
] = "resources",
1957 [MOUNT_FAILURE_TIMEOUT
] = "timeout",
1958 [MOUNT_FAILURE_EXIT_CODE
] = "exit-code",
1959 [MOUNT_FAILURE_SIGNAL
] = "signal",
1960 [MOUNT_FAILURE_CORE_DUMP
] = "core-dump",
1961 [MOUNT_FAILURE_START_LIMIT_HIT
] = "start-limit-hit",
1962 [MOUNT_FAILURE_PROTOCOL
] = "protocol",
1965 DEFINE_STRING_TABLE_LOOKUP(mount_result
, MountResult
);
1967 const UnitVTable mount_vtable
= {
1968 .object_size
= sizeof(Mount
),
1969 .exec_context_offset
= offsetof(Mount
, exec_context
),
1970 .cgroup_context_offset
= offsetof(Mount
, cgroup_context
),
1971 .kill_context_offset
= offsetof(Mount
, kill_context
),
1972 .exec_runtime_offset
= offsetof(Mount
, exec_runtime
),
1973 .dynamic_creds_offset
= offsetof(Mount
, dynamic_creds
),
1979 .private_section
= "Mount",
1985 .coldplug
= mount_coldplug
,
1989 .start
= mount_start
,
1991 .reload
= mount_reload
,
1995 .serialize
= mount_serialize
,
1996 .deserialize_item
= mount_deserialize_item
,
1998 .active_state
= mount_active_state
,
1999 .sub_state_to_string
= mount_sub_state_to_string
,
2001 .may_gc
= mount_may_gc
,
2003 .sigchld_event
= mount_sigchld_event
,
2005 .reset_failed
= mount_reset_failed
,
2007 .control_pid
= mount_control_pid
,
2009 .bus_vtable
= bus_mount_vtable
,
2010 .bus_set_property
= bus_mount_set_property
,
2011 .bus_commit_properties
= bus_mount_commit_properties
,
2013 .get_timeout
= mount_get_timeout
,
2015 .can_transient
= true,
2017 .enumerate
= mount_enumerate
,
2018 .shutdown
= mount_shutdown
,
2020 .status_message_formats
= {
2021 .starting_stopping
= {
2022 [0] = "Mounting %s...",
2023 [1] = "Unmounting %s...",
2025 .finished_start_job
= {
2026 [JOB_DONE
] = "Mounted %s.",
2027 [JOB_FAILED
] = "Failed to mount %s.",
2028 [JOB_TIMEOUT
] = "Timed out mounting %s.",
2030 .finished_stop_job
= {
2031 [JOB_DONE
] = "Unmounted %s.",
2032 [JOB_FAILED
] = "Failed unmounting %s.",
2033 [JOB_TIMEOUT
] = "Timed out unmounting %s.",