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/epoll.h>
27 #include <sys/inotify.h>
33 #include "sd-messages.h"
36 #include "path-util.h"
37 #include "mount-setup.h"
38 #include "unit-name.h"
39 #include "dbus-mount.h"
41 #include "exit-status.h"
42 #include "fstab-util.h"
43 #include "formats-util.h"
45 #define RETRY_UMOUNT_MAX 32
47 DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_table
*, mnt_free_table
);
48 DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_iter
*, mnt_free_iter
);
50 static const UnitActiveState state_translation_table
[_MOUNT_STATE_MAX
] = {
51 [MOUNT_DEAD
] = UNIT_INACTIVE
,
52 [MOUNT_MOUNTING
] = UNIT_ACTIVATING
,
53 [MOUNT_MOUNTING_DONE
] = UNIT_ACTIVE
,
54 [MOUNT_MOUNTED
] = UNIT_ACTIVE
,
55 [MOUNT_REMOUNTING
] = UNIT_RELOADING
,
56 [MOUNT_UNMOUNTING
] = UNIT_DEACTIVATING
,
57 [MOUNT_MOUNTING_SIGTERM
] = UNIT_DEACTIVATING
,
58 [MOUNT_MOUNTING_SIGKILL
] = UNIT_DEACTIVATING
,
59 [MOUNT_REMOUNTING_SIGTERM
] = UNIT_RELOADING
,
60 [MOUNT_REMOUNTING_SIGKILL
] = UNIT_RELOADING
,
61 [MOUNT_UNMOUNTING_SIGTERM
] = UNIT_DEACTIVATING
,
62 [MOUNT_UNMOUNTING_SIGKILL
] = UNIT_DEACTIVATING
,
63 [MOUNT_FAILED
] = UNIT_FAILED
66 static int mount_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
);
67 static int mount_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
);
69 static bool mount_needs_network(const char *options
, const char *fstype
) {
70 if (fstab_test_option(options
, "_netdev\0"))
73 if (fstype
&& fstype_is_network(fstype
))
79 static bool mount_is_network(const MountParameters
*p
) {
82 return mount_needs_network(p
->options
, p
->fstype
);
85 static bool mount_is_bind(const MountParameters
*p
) {
88 if (fstab_test_option(p
->options
, "bind\0" "rbind\0"))
91 if (p
->fstype
&& STR_IN_SET(p
->fstype
, "bind", "rbind"))
97 static bool mount_is_auto(const MountParameters
*p
) {
100 return !fstab_test_option(p
->options
, "noauto\0");
103 static bool needs_quota(const MountParameters
*p
) {
106 /* Quotas are not enabled on network filesystems,
107 * but we want them, for example, on storage connected via iscsi */
108 if (p
->fstype
&& fstype_is_network(p
->fstype
))
111 if (mount_is_bind(p
))
114 return fstab_test_option(p
->options
,
115 "usrquota\0" "grpquota\0" "quota\0" "usrjquota\0" "grpjquota\0");
118 static void mount_init(Unit
*u
) {
122 assert(u
->load_state
== UNIT_STUB
);
124 m
->timeout_usec
= u
->manager
->default_timeout_start_usec
;
125 m
->directory_mode
= 0755;
127 if (unit_has_name(u
, "-.mount")) {
128 /* Don't allow start/stop for root directory */
129 u
->refuse_manual_start
= true;
130 u
->refuse_manual_stop
= true;
132 /* The stdio/kmsg bridge socket is on /, in order to avoid a
133 * dep loop, don't use kmsg logging for -.mount */
134 m
->exec_context
.std_output
= u
->manager
->default_std_output
;
135 m
->exec_context
.std_error
= u
->manager
->default_std_error
;
138 /* We need to make sure that /usr/bin/mount is always called
139 * in the same process group as us, so that the autofs kernel
140 * side doesn't send us another mount request while we are
141 * already trying to comply its last one. */
142 m
->exec_context
.same_pgrp
= true;
144 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
146 u
->ignore_on_isolate
= true;
149 static int mount_arm_timer(Mount
*m
) {
154 if (m
->timeout_usec
<= 0) {
155 m
->timer_event_source
= sd_event_source_unref(m
->timer_event_source
);
159 if (m
->timer_event_source
) {
160 r
= sd_event_source_set_time(m
->timer_event_source
, now(CLOCK_MONOTONIC
) + m
->timeout_usec
);
164 return sd_event_source_set_enabled(m
->timer_event_source
, SD_EVENT_ONESHOT
);
167 r
= sd_event_add_time(
168 UNIT(m
)->manager
->event
,
169 &m
->timer_event_source
,
171 now(CLOCK_MONOTONIC
) + m
->timeout_usec
, 0,
172 mount_dispatch_timer
, m
);
176 (void) sd_event_source_set_description(m
->timer_event_source
, "mount-timer");
181 static void mount_unwatch_control_pid(Mount
*m
) {
184 if (m
->control_pid
<= 0)
187 unit_unwatch_pid(UNIT(m
), m
->control_pid
);
191 static void mount_parameters_done(MountParameters
*p
) {
198 p
->what
= p
->options
= p
->fstype
= NULL
;
201 static void mount_done(Unit
*u
) {
209 mount_parameters_done(&m
->parameters_proc_self_mountinfo
);
210 mount_parameters_done(&m
->parameters_fragment
);
212 m
->exec_runtime
= exec_runtime_unref(m
->exec_runtime
);
213 exec_command_done_array(m
->exec_command
, _MOUNT_EXEC_COMMAND_MAX
);
214 m
->control_command
= NULL
;
216 mount_unwatch_control_pid(m
);
218 m
->timer_event_source
= sd_event_source_unref(m
->timer_event_source
);
221 _pure_
static MountParameters
* get_mount_parameters_fragment(Mount
*m
) {
224 if (m
->from_fragment
)
225 return &m
->parameters_fragment
;
230 _pure_
static MountParameters
* get_mount_parameters(Mount
*m
) {
233 if (m
->from_proc_self_mountinfo
)
234 return &m
->parameters_proc_self_mountinfo
;
236 return get_mount_parameters_fragment(m
);
239 static int mount_add_mount_links(Mount
*m
) {
240 _cleanup_free_
char *parent
= NULL
;
249 if (!path_equal(m
->where
, "/")) {
250 /* Adds in links to other mount points that might lie further
251 * up in the hierarchy */
252 r
= path_get_parent(m
->where
, &parent
);
256 r
= unit_require_mounts_for(UNIT(m
), parent
);
261 /* Adds in links to other mount points that might be needed
262 * for the source path (if this is a bind mount) to be
264 pm
= get_mount_parameters_fragment(m
);
265 if (pm
&& pm
->what
&&
266 path_is_absolute(pm
->what
) &&
267 !mount_is_network(pm
)) {
269 r
= unit_require_mounts_for(UNIT(m
), pm
->what
);
274 /* Adds in links to other units that use this path or paths
275 * further down in the hierarchy */
276 s
= manager_get_units_requiring_mounts_for(UNIT(m
)->manager
, m
->where
);
277 SET_FOREACH(other
, s
, i
) {
279 if (other
->load_state
!= UNIT_LOADED
)
282 if (other
== UNIT(m
))
285 r
= unit_add_dependency(other
, UNIT_AFTER
, UNIT(m
), true);
289 if (UNIT(m
)->fragment_path
) {
290 /* If we have fragment configuration, then make this dependency required */
291 r
= unit_add_dependency(other
, UNIT_REQUIRES
, UNIT(m
), true);
300 static int mount_add_device_links(Mount
*m
) {
302 bool device_wants_mount
= false;
307 p
= get_mount_parameters(m
);
314 if (mount_is_bind(p
))
317 if (!is_device_path(p
->what
))
320 /* /dev/root is a really weird thing, it's not a real device,
321 * but just a path the kernel exports for the root file system
322 * specified on the kernel command line. Ignore it here. */
323 if (path_equal(p
->what
, "/dev/root"))
326 if (path_equal(m
->where
, "/"))
329 if (mount_is_auto(p
) && UNIT(m
)->manager
->running_as
== MANAGER_SYSTEM
)
330 device_wants_mount
= true;
332 r
= unit_add_node_link(UNIT(m
), p
->what
, device_wants_mount
);
339 static int mount_add_quota_links(Mount
*m
) {
345 if (UNIT(m
)->manager
->running_as
!= MANAGER_SYSTEM
)
348 p
= get_mount_parameters_fragment(m
);
355 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_BEFORE
, UNIT_WANTS
, SPECIAL_QUOTACHECK_SERVICE
, NULL
, true);
359 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_BEFORE
, UNIT_WANTS
, SPECIAL_QUOTAON_SERVICE
, NULL
, true);
366 static bool should_umount(Mount
*m
) {
369 if (path_equal(m
->where
, "/") ||
370 path_equal(m
->where
, "/usr"))
373 p
= get_mount_parameters(m
);
374 if (p
&& fstab_test_option(p
->options
, "x-initrd.mount\0") &&
381 static int mount_add_default_dependencies(Mount
*m
) {
382 const char *after
, *after2
, *online
;
388 if (UNIT(m
)->manager
->running_as
!= MANAGER_SYSTEM
)
391 /* We do not add any default dependencies to / and /usr, since
392 * they are guaranteed to stay mounted the whole time, since
393 * our system is on it. Also, don't bother with anything
394 * mounted below virtual file systems, it's also going to be
395 * virtual, and hence not worth the effort. */
396 if (path_equal(m
->where
, "/") ||
397 path_equal(m
->where
, "/usr") ||
398 path_startswith(m
->where
, "/proc") ||
399 path_startswith(m
->where
, "/sys") ||
400 path_startswith(m
->where
, "/dev"))
403 p
= get_mount_parameters(m
);
407 if (mount_is_network(p
)) {
408 after
= SPECIAL_REMOTE_FS_PRE_TARGET
;
409 after2
= SPECIAL_NETWORK_TARGET
;
410 online
= SPECIAL_NETWORK_ONLINE_TARGET
;
412 after
= SPECIAL_LOCAL_FS_PRE_TARGET
;
417 r
= unit_add_dependency_by_name(UNIT(m
), UNIT_AFTER
, after
, NULL
, true);
422 r
= unit_add_dependency_by_name(UNIT(m
), UNIT_AFTER
, after2
, NULL
, true);
428 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_WANTS
, UNIT_AFTER
, online
, NULL
, true);
433 if (should_umount(m
)) {
434 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_UMOUNT_TARGET
, NULL
, true);
442 static int mount_verify(Mount
*m
) {
443 _cleanup_free_
char *e
= NULL
;
448 if (UNIT(m
)->load_state
!= UNIT_LOADED
)
451 if (!m
->from_fragment
&& !m
->from_proc_self_mountinfo
)
454 r
= unit_name_from_path(m
->where
, ".mount", &e
);
456 return log_unit_error_errno(UNIT(m
), r
, "Failed to generate unit name from mount path: %m");
458 if (!unit_has_name(UNIT(m
), e
)) {
459 log_unit_error(UNIT(m
), "Where= setting doesn't match unit name. Refusing.");
463 if (mount_point_is_api(m
->where
) || mount_point_ignore(m
->where
)) {
464 log_unit_error(UNIT(m
), "Cannot create mount unit for API file system %s. Refusing.", m
->where
);
468 if (UNIT(m
)->fragment_path
&& !m
->parameters_fragment
.what
) {
469 log_unit_error(UNIT(m
), "What= setting is missing. Refusing.");
473 if (m
->exec_context
.pam_name
&& m
->kill_context
.kill_mode
!= KILL_CONTROL_GROUP
) {
474 log_unit_error(UNIT(m
), "Unit has PAM enabled. Kill mode must be set to control-group'. Refusing.");
481 static int mount_add_extras(Mount
*m
) {
487 if (u
->fragment_path
)
488 m
->from_fragment
= true;
491 r
= unit_name_to_path(u
->id
, &m
->where
);
496 path_kill_slashes(m
->where
);
498 if (!u
->description
) {
499 r
= unit_set_description(u
, m
->where
);
504 r
= mount_add_device_links(m
);
508 r
= mount_add_mount_links(m
);
512 r
= mount_add_quota_links(m
);
516 r
= unit_patch_contexts(u
);
520 r
= unit_add_exec_dependencies(u
, &m
->exec_context
);
524 r
= unit_add_default_slice(u
, &m
->cgroup_context
);
528 if (u
->default_dependencies
) {
529 r
= mount_add_default_dependencies(m
);
537 static int mount_load(Unit
*u
) {
542 assert(u
->load_state
== UNIT_STUB
);
544 if (m
->from_proc_self_mountinfo
)
545 r
= unit_load_fragment_and_dropin_optional(u
);
547 r
= unit_load_fragment_and_dropin(u
);
552 /* This is a new unit? Then let's add in some extras */
553 if (u
->load_state
== UNIT_LOADED
) {
554 r
= mount_add_extras(m
);
559 return mount_verify(m
);
562 static int mount_notify_automount(Mount
*m
, MountState old_state
, MountState state
) {
569 SET_FOREACH(p
, UNIT(m
)->dependencies
[UNIT_TRIGGERED_BY
], i
)
570 if (p
->type
== UNIT_AUTOMOUNT
) {
571 r
= automount_update_mount(AUTOMOUNT(p
), old_state
, state
);
579 static void mount_set_state(Mount
*m
, MountState state
) {
580 MountState old_state
;
583 old_state
= m
->state
;
586 if (state
!= MOUNT_MOUNTING
&&
587 state
!= MOUNT_MOUNTING_DONE
&&
588 state
!= MOUNT_REMOUNTING
&&
589 state
!= MOUNT_UNMOUNTING
&&
590 state
!= MOUNT_MOUNTING_SIGTERM
&&
591 state
!= MOUNT_MOUNTING_SIGKILL
&&
592 state
!= MOUNT_UNMOUNTING_SIGTERM
&&
593 state
!= MOUNT_UNMOUNTING_SIGKILL
&&
594 state
!= MOUNT_REMOUNTING_SIGTERM
&&
595 state
!= MOUNT_REMOUNTING_SIGKILL
) {
596 m
->timer_event_source
= sd_event_source_unref(m
->timer_event_source
);
597 mount_unwatch_control_pid(m
);
598 m
->control_command
= NULL
;
599 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
602 mount_notify_automount(m
, old_state
, state
);
604 if (state
!= old_state
)
605 log_unit_debug(UNIT(m
), "Changed %s -> %s", mount_state_to_string(old_state
), mount_state_to_string(state
));
607 unit_notify(UNIT(m
), state_translation_table
[old_state
], state_translation_table
[state
], m
->reload_result
== MOUNT_SUCCESS
);
608 m
->reload_result
= MOUNT_SUCCESS
;
611 static int mount_coldplug(Unit
*u
) {
613 MountState new_state
= MOUNT_DEAD
;
617 assert(m
->state
== MOUNT_DEAD
);
619 if (m
->deserialized_state
!= m
->state
)
620 new_state
= m
->deserialized_state
;
621 else if (m
->from_proc_self_mountinfo
)
622 new_state
= MOUNT_MOUNTED
;
624 if (new_state
== m
->state
)
627 if (new_state
== MOUNT_MOUNTING
||
628 new_state
== MOUNT_MOUNTING_DONE
||
629 new_state
== MOUNT_REMOUNTING
||
630 new_state
== MOUNT_UNMOUNTING
||
631 new_state
== MOUNT_MOUNTING_SIGTERM
||
632 new_state
== MOUNT_MOUNTING_SIGKILL
||
633 new_state
== MOUNT_UNMOUNTING_SIGTERM
||
634 new_state
== MOUNT_UNMOUNTING_SIGKILL
||
635 new_state
== MOUNT_REMOUNTING_SIGTERM
||
636 new_state
== MOUNT_REMOUNTING_SIGKILL
) {
638 if (m
->control_pid
<= 0)
641 r
= unit_watch_pid(UNIT(m
), m
->control_pid
);
645 r
= mount_arm_timer(m
);
650 mount_set_state(m
, new_state
);
654 static void mount_dump(Unit
*u
, FILE *f
, const char *prefix
) {
661 p
= get_mount_parameters(m
);
664 "%sMount State: %s\n"
668 "%sFile System Type: %s\n"
670 "%sFrom /proc/self/mountinfo: %s\n"
671 "%sFrom fragment: %s\n"
672 "%sDirectoryMode: %04o\n",
673 prefix
, mount_state_to_string(m
->state
),
674 prefix
, mount_result_to_string(m
->result
),
676 prefix
, p
? strna(p
->what
) : "n/a",
677 prefix
, p
? strna(p
->fstype
) : "n/a",
678 prefix
, p
? strna(p
->options
) : "n/a",
679 prefix
, yes_no(m
->from_proc_self_mountinfo
),
680 prefix
, yes_no(m
->from_fragment
),
681 prefix
, m
->directory_mode
);
683 if (m
->control_pid
> 0)
685 "%sControl PID: "PID_FMT
"\n",
686 prefix
, m
->control_pid
);
688 exec_context_dump(&m
->exec_context
, f
, prefix
);
689 kill_context_dump(&m
->kill_context
, f
, prefix
);
692 static int mount_spawn(Mount
*m
, ExecCommand
*c
, pid_t
*_pid
) {
695 ExecParameters exec_params
= {
696 .apply_permissions
= true,
697 .apply_chroot
= true,
698 .apply_tty_stdin
= true,
699 .bus_endpoint_fd
= -1,
706 (void) unit_realize_cgroup(UNIT(m
));
707 if (m
->reset_cpu_usage
) {
708 (void) unit_reset_cpu_usage(UNIT(m
));
709 m
->reset_cpu_usage
= false;
712 r
= unit_setup_exec_runtime(UNIT(m
));
716 r
= mount_arm_timer(m
);
720 exec_params
.environment
= UNIT(m
)->manager
->environment
;
721 exec_params
.confirm_spawn
= UNIT(m
)->manager
->confirm_spawn
;
722 exec_params
.cgroup_supported
= UNIT(m
)->manager
->cgroup_supported
;
723 exec_params
.cgroup_path
= UNIT(m
)->cgroup_path
;
724 exec_params
.cgroup_delegate
= m
->cgroup_context
.delegate
;
725 exec_params
.runtime_prefix
= manager_get_runtime_prefix(UNIT(m
)->manager
);
727 r
= exec_spawn(UNIT(m
),
736 r
= unit_watch_pid(UNIT(m
), pid
);
738 /* FIXME: we need to do something here */
746 m
->timer_event_source
= sd_event_source_unref(m
->timer_event_source
);
751 static void mount_enter_dead(Mount
*m
, MountResult f
) {
754 if (f
!= MOUNT_SUCCESS
)
757 exec_runtime_destroy(m
->exec_runtime
);
758 m
->exec_runtime
= exec_runtime_unref(m
->exec_runtime
);
760 exec_context_destroy_runtime_directory(&m
->exec_context
, manager_get_runtime_prefix(UNIT(m
)->manager
));
762 mount_set_state(m
, m
->result
!= MOUNT_SUCCESS
? MOUNT_FAILED
: MOUNT_DEAD
);
765 static void mount_enter_mounted(Mount
*m
, MountResult f
) {
768 if (f
!= MOUNT_SUCCESS
)
771 mount_set_state(m
, MOUNT_MOUNTED
);
774 static void mount_enter_signal(Mount
*m
, MountState state
, MountResult f
) {
779 if (f
!= MOUNT_SUCCESS
)
782 r
= unit_kill_context(
785 (state
!= MOUNT_MOUNTING_SIGTERM
&& state
!= MOUNT_UNMOUNTING_SIGTERM
&& state
!= MOUNT_REMOUNTING_SIGTERM
) ?
786 KILL_KILL
: KILL_TERMINATE
,
794 r
= mount_arm_timer(m
);
798 mount_set_state(m
, state
);
799 } else if (state
== MOUNT_REMOUNTING_SIGTERM
)
800 mount_enter_signal(m
, MOUNT_REMOUNTING_SIGKILL
, MOUNT_SUCCESS
);
801 else if (state
== MOUNT_REMOUNTING_SIGKILL
)
802 mount_enter_mounted(m
, MOUNT_SUCCESS
);
803 else if (state
== MOUNT_MOUNTING_SIGTERM
)
804 mount_enter_signal(m
, MOUNT_MOUNTING_SIGKILL
, MOUNT_SUCCESS
);
805 else if (state
== MOUNT_UNMOUNTING_SIGTERM
)
806 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGKILL
, MOUNT_SUCCESS
);
808 mount_enter_dead(m
, MOUNT_SUCCESS
);
813 log_unit_warning_errno(UNIT(m
), r
, "Failed to kill processes: %m");
815 if (state
== MOUNT_REMOUNTING_SIGTERM
|| state
== MOUNT_REMOUNTING_SIGKILL
)
816 mount_enter_mounted(m
, MOUNT_FAILURE_RESOURCES
);
818 mount_enter_dead(m
, MOUNT_FAILURE_RESOURCES
);
821 static void mount_enter_unmounting(Mount
*m
) {
826 /* Start counting our attempts */
827 if (!IN_SET(m
->state
,
829 MOUNT_UNMOUNTING_SIGTERM
,
830 MOUNT_UNMOUNTING_SIGKILL
))
831 m
->n_retry_umount
= 0;
833 m
->control_command_id
= MOUNT_EXEC_UNMOUNT
;
834 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_UNMOUNT
;
836 r
= exec_command_set(m
->control_command
, UMOUNT_PATH
, m
->where
, NULL
);
837 if (r
>= 0 && UNIT(m
)->manager
->running_as
== MANAGER_SYSTEM
)
838 r
= exec_command_append(m
->control_command
, "-n", NULL
);
842 mount_unwatch_control_pid(m
);
844 r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
);
848 mount_set_state(m
, MOUNT_UNMOUNTING
);
853 log_unit_warning_errno(UNIT(m
), r
, "Failed to run 'umount' task: %m");
854 mount_enter_mounted(m
, MOUNT_FAILURE_RESOURCES
);
857 static void mount_enter_mounting(Mount
*m
) {
863 m
->control_command_id
= MOUNT_EXEC_MOUNT
;
864 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_MOUNT
;
866 r
= unit_fail_if_symlink(UNIT(m
), m
->where
);
870 (void) mkdir_p_label(m
->where
, m
->directory_mode
);
872 unit_warn_if_dir_nonempty(UNIT(m
), m
->where
);
874 /* Create the source directory for bind-mounts if needed */
875 p
= get_mount_parameters_fragment(m
);
876 if (p
&& mount_is_bind(p
))
877 (void) mkdir_p_label(p
->what
, m
->directory_mode
);
879 if (m
->from_fragment
) {
880 _cleanup_free_
char *opts
= NULL
;
882 r
= fstab_filter_options(m
->parameters_fragment
.options
,
883 "nofail\0" "noauto\0" "auto\0", NULL
, NULL
, &opts
);
887 r
= exec_command_set(m
->control_command
, MOUNT_PATH
,
888 m
->parameters_fragment
.what
, m
->where
, NULL
);
889 if (r
>= 0 && UNIT(m
)->manager
->running_as
== MANAGER_SYSTEM
)
890 r
= exec_command_append(m
->control_command
, "-n", NULL
);
891 if (r
>= 0 && m
->sloppy_options
)
892 r
= exec_command_append(m
->control_command
, "-s", NULL
);
893 if (r
>= 0 && m
->parameters_fragment
.fstype
)
894 r
= exec_command_append(m
->control_command
, "-t", m
->parameters_fragment
.fstype
, NULL
);
895 if (r
>= 0 && !isempty(opts
))
896 r
= exec_command_append(m
->control_command
, "-o", opts
, NULL
);
903 mount_unwatch_control_pid(m
);
905 r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
);
909 mount_set_state(m
, MOUNT_MOUNTING
);
914 log_unit_warning_errno(UNIT(m
), r
, "Failed to run 'mount' task: %m");
915 mount_enter_dead(m
, MOUNT_FAILURE_RESOURCES
);
918 static void mount_enter_remounting(Mount
*m
) {
923 m
->control_command_id
= MOUNT_EXEC_REMOUNT
;
924 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_REMOUNT
;
926 if (m
->from_fragment
) {
929 if (m
->parameters_fragment
.options
)
930 o
= strjoina("remount,", m
->parameters_fragment
.options
);
934 r
= exec_command_set(m
->control_command
, MOUNT_PATH
,
935 m
->parameters_fragment
.what
, m
->where
,
937 if (r
>= 0 && UNIT(m
)->manager
->running_as
== MANAGER_SYSTEM
)
938 r
= exec_command_append(m
->control_command
, "-n", NULL
);
939 if (r
>= 0 && m
->sloppy_options
)
940 r
= exec_command_append(m
->control_command
, "-s", NULL
);
941 if (r
>= 0 && m
->parameters_fragment
.fstype
)
942 r
= exec_command_append(m
->control_command
, "-t", m
->parameters_fragment
.fstype
, NULL
);
949 mount_unwatch_control_pid(m
);
951 r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
);
955 mount_set_state(m
, MOUNT_REMOUNTING
);
960 log_unit_warning_errno(UNIT(m
), r
, "Failed to run 'remount' task: %m");
961 m
->reload_result
= MOUNT_FAILURE_RESOURCES
;
962 mount_enter_mounted(m
, MOUNT_SUCCESS
);
965 static int mount_start(Unit
*u
) {
970 /* We cannot fulfill this request right now, try again later
972 if (m
->state
== MOUNT_UNMOUNTING
||
973 m
->state
== MOUNT_UNMOUNTING_SIGTERM
||
974 m
->state
== MOUNT_UNMOUNTING_SIGKILL
||
975 m
->state
== MOUNT_MOUNTING_SIGTERM
||
976 m
->state
== MOUNT_MOUNTING_SIGKILL
)
980 if (m
->state
== MOUNT_MOUNTING
)
983 assert(m
->state
== MOUNT_DEAD
|| m
->state
== MOUNT_FAILED
);
985 m
->result
= MOUNT_SUCCESS
;
986 m
->reload_result
= MOUNT_SUCCESS
;
987 m
->reset_cpu_usage
= true;
989 mount_enter_mounting(m
);
993 static int mount_stop(Unit
*u
) {
999 if (m
->state
== MOUNT_UNMOUNTING
||
1000 m
->state
== MOUNT_UNMOUNTING_SIGKILL
||
1001 m
->state
== MOUNT_UNMOUNTING_SIGTERM
||
1002 m
->state
== MOUNT_MOUNTING_SIGTERM
||
1003 m
->state
== MOUNT_MOUNTING_SIGKILL
)
1006 assert(m
->state
== MOUNT_MOUNTING
||
1007 m
->state
== MOUNT_MOUNTING_DONE
||
1008 m
->state
== MOUNT_MOUNTED
||
1009 m
->state
== MOUNT_REMOUNTING
||
1010 m
->state
== MOUNT_REMOUNTING_SIGTERM
||
1011 m
->state
== MOUNT_REMOUNTING_SIGKILL
);
1013 mount_enter_unmounting(m
);
1017 static int mount_reload(Unit
*u
) {
1018 Mount
*m
= MOUNT(u
);
1022 if (m
->state
== MOUNT_MOUNTING_DONE
)
1025 assert(m
->state
== MOUNT_MOUNTED
);
1027 mount_enter_remounting(m
);
1031 static int mount_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
1032 Mount
*m
= MOUNT(u
);
1038 unit_serialize_item(u
, f
, "state", mount_state_to_string(m
->state
));
1039 unit_serialize_item(u
, f
, "result", mount_result_to_string(m
->result
));
1040 unit_serialize_item(u
, f
, "reload-result", mount_result_to_string(m
->reload_result
));
1042 if (m
->control_pid
> 0)
1043 unit_serialize_item_format(u
, f
, "control-pid", PID_FMT
, m
->control_pid
);
1045 if (m
->control_command_id
>= 0)
1046 unit_serialize_item(u
, f
, "control-command", mount_exec_command_to_string(m
->control_command_id
));
1051 static int mount_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
1052 Mount
*m
= MOUNT(u
);
1059 if (streq(key
, "state")) {
1062 if ((state
= mount_state_from_string(value
)) < 0)
1063 log_unit_debug(u
, "Failed to parse state value: %s", value
);
1065 m
->deserialized_state
= state
;
1066 } else if (streq(key
, "result")) {
1069 f
= mount_result_from_string(value
);
1071 log_unit_debug(u
, "Failed to parse result value: %s", value
);
1072 else if (f
!= MOUNT_SUCCESS
)
1075 } else if (streq(key
, "reload-result")) {
1078 f
= mount_result_from_string(value
);
1080 log_unit_debug(u
, "Failed to parse reload result value: %s", value
);
1081 else if (f
!= MOUNT_SUCCESS
)
1082 m
->reload_result
= f
;
1084 } else if (streq(key
, "control-pid")) {
1087 if (parse_pid(value
, &pid
) < 0)
1088 log_unit_debug(u
, "Failed to parse control-pid value: %s", value
);
1090 m
->control_pid
= pid
;
1091 } else if (streq(key
, "control-command")) {
1092 MountExecCommand id
;
1094 id
= mount_exec_command_from_string(value
);
1096 log_unit_debug(u
, "Failed to parse exec-command value: %s", value
);
1098 m
->control_command_id
= id
;
1099 m
->control_command
= m
->exec_command
+ id
;
1102 log_unit_debug(u
, "Unknown serialization key: %s", key
);
1107 _pure_
static UnitActiveState
mount_active_state(Unit
*u
) {
1110 return state_translation_table
[MOUNT(u
)->state
];
1113 _pure_
static const char *mount_sub_state_to_string(Unit
*u
) {
1116 return mount_state_to_string(MOUNT(u
)->state
);
1119 _pure_
static bool mount_check_gc(Unit
*u
) {
1120 Mount
*m
= MOUNT(u
);
1124 return m
->from_proc_self_mountinfo
;
1127 static void mount_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
1128 Mount
*m
= MOUNT(u
);
1134 if (pid
!= m
->control_pid
)
1139 if (is_clean_exit(code
, status
, NULL
))
1141 else if (code
== CLD_EXITED
)
1142 f
= MOUNT_FAILURE_EXIT_CODE
;
1143 else if (code
== CLD_KILLED
)
1144 f
= MOUNT_FAILURE_SIGNAL
;
1145 else if (code
== CLD_DUMPED
)
1146 f
= MOUNT_FAILURE_CORE_DUMP
;
1148 assert_not_reached("Unknown code");
1150 if (f
!= MOUNT_SUCCESS
)
1153 if (m
->control_command
) {
1154 exec_status_exit(&m
->control_command
->exec_status
, &m
->exec_context
, pid
, code
, status
);
1156 m
->control_command
= NULL
;
1157 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
1160 log_unit_full(u
, f
== MOUNT_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
, 0,
1161 "Mount process exited, code=%s status=%i", sigchld_code_to_string(code
), status
);
1163 /* Note that mount(8) returning and the kernel sending us a
1164 * mount table change event might happen out-of-order. If an
1165 * operation succeed we assume the kernel will follow soon too
1166 * and already change into the resulting state. If it fails
1167 * we check if the kernel still knows about the mount. and
1168 * change state accordingly. */
1172 case MOUNT_MOUNTING
:
1173 case MOUNT_MOUNTING_DONE
:
1174 case MOUNT_MOUNTING_SIGKILL
:
1175 case MOUNT_MOUNTING_SIGTERM
:
1177 if (f
== MOUNT_SUCCESS
)
1178 mount_enter_mounted(m
, f
);
1179 else if (m
->from_proc_self_mountinfo
)
1180 mount_enter_mounted(m
, f
);
1182 mount_enter_dead(m
, f
);
1185 case MOUNT_REMOUNTING
:
1186 case MOUNT_REMOUNTING_SIGKILL
:
1187 case MOUNT_REMOUNTING_SIGTERM
:
1189 m
->reload_result
= f
;
1190 if (m
->from_proc_self_mountinfo
)
1191 mount_enter_mounted(m
, MOUNT_SUCCESS
);
1193 mount_enter_dead(m
, MOUNT_SUCCESS
);
1197 case MOUNT_UNMOUNTING
:
1198 case MOUNT_UNMOUNTING_SIGKILL
:
1199 case MOUNT_UNMOUNTING_SIGTERM
:
1201 if (f
== MOUNT_SUCCESS
) {
1203 if (m
->from_proc_self_mountinfo
) {
1205 /* Still a mount point? If so, let's
1206 * try again. Most likely there were
1207 * multiple mount points stacked on
1208 * top of each other. Note that due to
1209 * the io event priority logic we can
1210 * be sure the new mountinfo is loaded
1211 * before we process the SIGCHLD for
1212 * the mount command. */
1214 if (m
->n_retry_umount
< RETRY_UMOUNT_MAX
) {
1215 log_unit_debug(u
, "Mount still present, trying again.");
1216 m
->n_retry_umount
++;
1217 mount_enter_unmounting(m
);
1219 log_unit_debug(u
, "Mount still present after %u attempts to unmount, giving up.", m
->n_retry_umount
);
1220 mount_enter_mounted(m
, f
);
1223 mount_enter_dead(m
, f
);
1225 } else if (m
->from_proc_self_mountinfo
)
1226 mount_enter_mounted(m
, f
);
1228 mount_enter_dead(m
, f
);
1232 assert_not_reached("Uh, control process died at wrong time.");
1235 /* Notify clients about changed exit status */
1236 unit_add_to_dbus_queue(u
);
1239 static int mount_dispatch_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
1240 Mount
*m
= MOUNT(userdata
);
1243 assert(m
->timer_event_source
== source
);
1247 case MOUNT_MOUNTING
:
1248 case MOUNT_MOUNTING_DONE
:
1249 log_unit_warning(UNIT(m
), "Mounting timed out. Stopping.");
1250 mount_enter_signal(m
, MOUNT_MOUNTING_SIGTERM
, MOUNT_FAILURE_TIMEOUT
);
1253 case MOUNT_REMOUNTING
:
1254 log_unit_warning(UNIT(m
), "Remounting timed out. Stopping.");
1255 m
->reload_result
= MOUNT_FAILURE_TIMEOUT
;
1256 mount_enter_mounted(m
, MOUNT_SUCCESS
);
1259 case MOUNT_UNMOUNTING
:
1260 log_unit_warning(UNIT(m
), "Unmounting timed out. Stopping.");
1261 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGTERM
, MOUNT_FAILURE_TIMEOUT
);
1264 case MOUNT_MOUNTING_SIGTERM
:
1265 if (m
->kill_context
.send_sigkill
) {
1266 log_unit_warning(UNIT(m
), "Mounting timed out. Killing.");
1267 mount_enter_signal(m
, MOUNT_MOUNTING_SIGKILL
, MOUNT_FAILURE_TIMEOUT
);
1269 log_unit_warning(UNIT(m
), "Mounting timed out. Skipping SIGKILL. Ignoring.");
1271 if (m
->from_proc_self_mountinfo
)
1272 mount_enter_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1274 mount_enter_dead(m
, MOUNT_FAILURE_TIMEOUT
);
1278 case MOUNT_REMOUNTING_SIGTERM
:
1279 if (m
->kill_context
.send_sigkill
) {
1280 log_unit_warning(UNIT(m
), "Remounting timed out. Killing.");
1281 mount_enter_signal(m
, MOUNT_REMOUNTING_SIGKILL
, MOUNT_FAILURE_TIMEOUT
);
1283 log_unit_warning(UNIT(m
), "Remounting timed out. Skipping SIGKILL. Ignoring.");
1285 if (m
->from_proc_self_mountinfo
)
1286 mount_enter_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1288 mount_enter_dead(m
, MOUNT_FAILURE_TIMEOUT
);
1292 case MOUNT_UNMOUNTING_SIGTERM
:
1293 if (m
->kill_context
.send_sigkill
) {
1294 log_unit_warning(UNIT(m
), "Unmounting timed out. Killing.");
1295 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGKILL
, MOUNT_FAILURE_TIMEOUT
);
1297 log_unit_warning(UNIT(m
), "Unmounting timed out. Skipping SIGKILL. Ignoring.");
1299 if (m
->from_proc_self_mountinfo
)
1300 mount_enter_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1302 mount_enter_dead(m
, MOUNT_FAILURE_TIMEOUT
);
1306 case MOUNT_MOUNTING_SIGKILL
:
1307 case MOUNT_REMOUNTING_SIGKILL
:
1308 case MOUNT_UNMOUNTING_SIGKILL
:
1309 log_unit_warning(UNIT(m
),"Mount process still around after SIGKILL. Ignoring.");
1311 if (m
->from_proc_self_mountinfo
)
1312 mount_enter_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1314 mount_enter_dead(m
, MOUNT_FAILURE_TIMEOUT
);
1318 assert_not_reached("Timeout at wrong time.");
1324 static int mount_setup_unit(
1328 const char *options
,
1332 _cleanup_free_
char *e
= NULL
, *w
= NULL
, *o
= NULL
, *f
= NULL
;
1333 bool load_extras
= false;
1335 bool delete, changed
= false;
1345 /* Ignore API mount points. They should never be referenced in
1346 * dependencies ever. */
1347 if (mount_point_is_api(where
) || mount_point_ignore(where
))
1350 if (streq(fstype
, "autofs"))
1353 /* probably some kind of swap, ignore */
1354 if (!is_path(where
))
1357 r
= unit_name_from_path(where
, ".mount", &e
);
1361 u
= manager_get_unit(m
, e
);
1365 u
= unit_new(m
, sizeof(Mount
));
1369 r
= unit_add_name(u
, e
);
1373 MOUNT(u
)->where
= strdup(where
);
1374 if (!MOUNT(u
)->where
) {
1379 u
->source_path
= strdup("/proc/self/mountinfo");
1380 if (!u
->source_path
) {
1385 if (m
->running_as
== MANAGER_SYSTEM
) {
1388 target
= mount_needs_network(options
, fstype
) ? SPECIAL_REMOTE_FS_TARGET
: SPECIAL_LOCAL_FS_TARGET
;
1389 r
= unit_add_dependency_by_name(u
, UNIT_BEFORE
, target
, NULL
, true);
1393 if (should_umount(MOUNT(u
))) {
1394 r
= unit_add_dependency_by_name(u
, UNIT_CONFLICTS
, SPECIAL_UMOUNT_TARGET
, NULL
, true);
1400 unit_add_to_load_queue(u
);
1405 if (!MOUNT(u
)->where
) {
1406 MOUNT(u
)->where
= strdup(where
);
1407 if (!MOUNT(u
)->where
) {
1413 if (m
->running_as
== MANAGER_SYSTEM
&&
1414 mount_needs_network(options
, fstype
)) {
1415 /* _netdev option may have shown up late, or on a
1416 * remount. Add remote-fs dependencies, even though
1417 * local-fs ones may already be there. */
1418 unit_add_dependency_by_name(u
, UNIT_BEFORE
, SPECIAL_REMOTE_FS_TARGET
, NULL
, true);
1422 if (u
->load_state
== UNIT_NOT_FOUND
) {
1423 u
->load_state
= UNIT_LOADED
;
1426 /* Load in the extras later on, after we
1427 * finished initialization of the unit */
1434 o
= strdup(options
);
1436 if (!w
|| !o
|| !f
) {
1441 p
= &MOUNT(u
)->parameters_proc_self_mountinfo
;
1443 changed
= changed
||
1444 !streq_ptr(p
->options
, options
) ||
1445 !streq_ptr(p
->what
, what
) ||
1446 !streq_ptr(p
->fstype
, fstype
);
1449 MOUNT(u
)->is_mounted
= true;
1450 MOUNT(u
)->just_mounted
= !MOUNT(u
)->from_proc_self_mountinfo
;
1451 MOUNT(u
)->just_changed
= changed
;
1454 MOUNT(u
)->from_proc_self_mountinfo
= true;
1469 r
= mount_add_extras(MOUNT(u
));
1475 unit_add_to_dbus_queue(u
);
1480 log_warning_errno(r
, "Failed to set up mount unit: %m");
1488 static int mount_load_proc_self_mountinfo(Manager
*m
, bool set_flags
) {
1489 _cleanup_(mnt_free_tablep
) struct libmnt_table
*t
= NULL
;
1490 _cleanup_(mnt_free_iterp
) struct libmnt_iter
*i
= NULL
;
1495 t
= mnt_new_table();
1499 i
= mnt_new_iter(MNT_ITER_FORWARD
);
1503 r
= mnt_table_parse_mtab(t
, NULL
);
1505 return log_error_errno(r
, "Failed to parse /proc/self/mountinfo: %m");
1509 const char *device
, *path
, *options
, *fstype
;
1510 _cleanup_free_
char *d
= NULL
, *p
= NULL
;
1511 struct libmnt_fs
*fs
;
1514 k
= mnt_table_next_fs(t
, i
, &fs
);
1518 return log_error_errno(k
, "Failed to get next entry from /proc/self/mountinfo: %m");
1520 device
= mnt_fs_get_source(fs
);
1521 path
= mnt_fs_get_target(fs
);
1522 options
= mnt_fs_get_options(fs
);
1523 fstype
= mnt_fs_get_fstype(fs
);
1525 if (!device
|| !path
)
1528 if (cunescape(device
, UNESCAPE_RELAX
, &d
) < 0)
1531 if (cunescape(path
, UNESCAPE_RELAX
, &p
) < 0)
1534 (void) device_found_node(m
, d
, true, DEVICE_FOUND_MOUNT
, set_flags
);
1536 k
= mount_setup_unit(m
, d
, p
, options
, fstype
, set_flags
);
1537 if (r
== 0 && k
< 0)
1544 static void mount_shutdown(Manager
*m
) {
1547 m
->mount_event_source
= sd_event_source_unref(m
->mount_event_source
);
1548 m
->mount_utab_event_source
= sd_event_source_unref(m
->mount_utab_event_source
);
1550 if (m
->proc_self_mountinfo
) {
1551 fclose(m
->proc_self_mountinfo
);
1552 m
->proc_self_mountinfo
= NULL
;
1554 m
->utab_inotify_fd
= safe_close(m
->utab_inotify_fd
);
1557 static int mount_get_timeout(Unit
*u
, uint64_t *timeout
) {
1558 Mount
*m
= MOUNT(u
);
1561 if (!m
->timer_event_source
)
1564 r
= sd_event_source_get_time(m
->timer_event_source
, timeout
);
1571 static int mount_enumerate(Manager
*m
) {
1577 if (!m
->proc_self_mountinfo
) {
1578 m
->proc_self_mountinfo
= fopen("/proc/self/mountinfo", "re");
1579 if (!m
->proc_self_mountinfo
)
1582 r
= sd_event_add_io(m
->event
, &m
->mount_event_source
, fileno(m
->proc_self_mountinfo
), EPOLLPRI
, mount_dispatch_io
, m
);
1586 /* Dispatch this before we dispatch SIGCHLD, so that
1587 * we always get the events from /proc/self/mountinfo
1588 * before the SIGCHLD of /usr/bin/mount. */
1589 r
= sd_event_source_set_priority(m
->mount_event_source
, -10);
1593 (void) sd_event_source_set_description(m
->mount_event_source
, "mount-mountinfo-dispatch");
1596 if (m
->utab_inotify_fd
< 0) {
1597 m
->utab_inotify_fd
= inotify_init1(IN_NONBLOCK
|IN_CLOEXEC
);
1598 if (m
->utab_inotify_fd
< 0) {
1603 (void) mkdir_p_label("/run/mount", 0755);
1605 r
= inotify_add_watch(m
->utab_inotify_fd
, "/run/mount", IN_MOVED_TO
);
1611 r
= sd_event_add_io(m
->event
, &m
->mount_utab_event_source
, m
->utab_inotify_fd
, EPOLLIN
, mount_dispatch_io
, m
);
1615 r
= sd_event_source_set_priority(m
->mount_utab_event_source
, -10);
1619 (void) sd_event_source_set_description(m
->mount_utab_event_source
, "mount-utab-dispatch");
1622 r
= mount_load_proc_self_mountinfo(m
, false);
1633 static int mount_dispatch_io(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
1634 _cleanup_set_free_ Set
*around
= NULL
, *gone
= NULL
;
1635 Manager
*m
= userdata
;
1642 assert(revents
& (EPOLLPRI
| EPOLLIN
));
1644 /* The manager calls this for every fd event happening on the
1645 * /proc/self/mountinfo file, which informs us about mounting
1646 * table changes, and for /run/mount events which we watch
1647 * for mount options. */
1649 if (fd
== m
->utab_inotify_fd
) {
1650 bool rescan
= false;
1652 /* FIXME: We *really* need to replace this with
1653 * libmount's own API for this, we should not hardcode
1654 * internal behaviour of libmount here. */
1657 union inotify_event_buffer buffer
;
1658 struct inotify_event
*e
;
1661 l
= read(fd
, &buffer
, sizeof(buffer
));
1663 if (errno
== EAGAIN
|| errno
== EINTR
)
1666 log_error_errno(errno
, "Failed to read utab inotify: %m");
1670 FOREACH_INOTIFY_EVENT(e
, buffer
, l
) {
1671 /* Only care about changes to utab,
1672 * but we have to monitor the
1673 * directory to reliably get
1674 * notifications about when utab is
1675 * replaced using rename(2) */
1676 if ((e
->mask
& IN_Q_OVERFLOW
) || streq(e
->name
, "utab"))
1685 r
= mount_load_proc_self_mountinfo(m
, true);
1687 /* Reset flags, just in case, for later calls */
1688 LIST_FOREACH(units_by_type
, u
, m
->units_by_type
[UNIT_MOUNT
]) {
1689 Mount
*mount
= MOUNT(u
);
1691 mount
->is_mounted
= mount
->just_mounted
= mount
->just_changed
= false;
1697 manager_dispatch_load_queue(m
);
1699 LIST_FOREACH(units_by_type
, u
, m
->units_by_type
[UNIT_MOUNT
]) {
1700 Mount
*mount
= MOUNT(u
);
1702 if (!mount
->is_mounted
) {
1704 /* A mount point is not around right now. It
1705 * might be gone, or might never have
1708 if (mount
->from_proc_self_mountinfo
&&
1709 mount
->parameters_proc_self_mountinfo
.what
) {
1711 /* Remember that this device might just have disappeared */
1712 if (set_ensure_allocated(&gone
, &string_hash_ops
) < 0 ||
1713 set_put(gone
, mount
->parameters_proc_self_mountinfo
.what
) < 0)
1714 log_oom(); /* we don't care too much about OOM here... */
1717 mount
->from_proc_self_mountinfo
= false;
1719 switch (mount
->state
) {
1722 /* This has just been unmounted by
1723 * somebody else, follow the state
1725 mount_enter_dead(mount
, MOUNT_SUCCESS
);
1732 } else if (mount
->just_mounted
|| mount
->just_changed
) {
1734 /* A mount point was added or changed */
1736 switch (mount
->state
) {
1740 /* This has just been mounted by
1741 * somebody else, follow the state
1743 mount_enter_mounted(mount
, MOUNT_SUCCESS
);
1746 case MOUNT_MOUNTING
:
1747 mount_set_state(mount
, MOUNT_MOUNTING_DONE
);
1751 /* Nothing really changed, but let's
1752 * issue an notification call
1753 * nonetheless, in case somebody is
1754 * waiting for this. (e.g. file system
1755 * ro/rw remounts.) */
1756 mount_set_state(mount
, mount
->state
);
1761 if (mount
->is_mounted
&&
1762 mount
->from_proc_self_mountinfo
&&
1763 mount
->parameters_proc_self_mountinfo
.what
) {
1765 if (set_ensure_allocated(&around
, &string_hash_ops
) < 0 ||
1766 set_put(around
, mount
->parameters_proc_self_mountinfo
.what
) < 0)
1770 /* Reset the flags for later calls */
1771 mount
->is_mounted
= mount
->just_mounted
= mount
->just_changed
= false;
1774 SET_FOREACH(what
, gone
, i
) {
1775 if (set_contains(around
, what
))
1778 /* Let the device units know that the device is no longer mounted */
1779 (void) device_found_node(m
, what
, false, DEVICE_FOUND_MOUNT
, true);
1785 static void mount_reset_failed(Unit
*u
) {
1786 Mount
*m
= MOUNT(u
);
1790 if (m
->state
== MOUNT_FAILED
)
1791 mount_set_state(m
, MOUNT_DEAD
);
1793 m
->result
= MOUNT_SUCCESS
;
1794 m
->reload_result
= MOUNT_SUCCESS
;
1797 static int mount_kill(Unit
*u
, KillWho who
, int signo
, sd_bus_error
*error
) {
1798 return unit_kill_common(u
, who
, signo
, -1, MOUNT(u
)->control_pid
, error
);
1801 static const char* const mount_state_table
[_MOUNT_STATE_MAX
] = {
1802 [MOUNT_DEAD
] = "dead",
1803 [MOUNT_MOUNTING
] = "mounting",
1804 [MOUNT_MOUNTING_DONE
] = "mounting-done",
1805 [MOUNT_MOUNTED
] = "mounted",
1806 [MOUNT_REMOUNTING
] = "remounting",
1807 [MOUNT_UNMOUNTING
] = "unmounting",
1808 [MOUNT_MOUNTING_SIGTERM
] = "mounting-sigterm",
1809 [MOUNT_MOUNTING_SIGKILL
] = "mounting-sigkill",
1810 [MOUNT_REMOUNTING_SIGTERM
] = "remounting-sigterm",
1811 [MOUNT_REMOUNTING_SIGKILL
] = "remounting-sigkill",
1812 [MOUNT_UNMOUNTING_SIGTERM
] = "unmounting-sigterm",
1813 [MOUNT_UNMOUNTING_SIGKILL
] = "unmounting-sigkill",
1814 [MOUNT_FAILED
] = "failed"
1817 DEFINE_STRING_TABLE_LOOKUP(mount_state
, MountState
);
1819 static const char* const mount_exec_command_table
[_MOUNT_EXEC_COMMAND_MAX
] = {
1820 [MOUNT_EXEC_MOUNT
] = "ExecMount",
1821 [MOUNT_EXEC_UNMOUNT
] = "ExecUnmount",
1822 [MOUNT_EXEC_REMOUNT
] = "ExecRemount",
1825 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command
, MountExecCommand
);
1827 static const char* const mount_result_table
[_MOUNT_RESULT_MAX
] = {
1828 [MOUNT_SUCCESS
] = "success",
1829 [MOUNT_FAILURE_RESOURCES
] = "resources",
1830 [MOUNT_FAILURE_TIMEOUT
] = "timeout",
1831 [MOUNT_FAILURE_EXIT_CODE
] = "exit-code",
1832 [MOUNT_FAILURE_SIGNAL
] = "signal",
1833 [MOUNT_FAILURE_CORE_DUMP
] = "core-dump"
1836 DEFINE_STRING_TABLE_LOOKUP(mount_result
, MountResult
);
1838 const UnitVTable mount_vtable
= {
1839 .object_size
= sizeof(Mount
),
1840 .exec_context_offset
= offsetof(Mount
, exec_context
),
1841 .cgroup_context_offset
= offsetof(Mount
, cgroup_context
),
1842 .kill_context_offset
= offsetof(Mount
, kill_context
),
1843 .exec_runtime_offset
= offsetof(Mount
, exec_runtime
),
1849 .private_section
= "Mount",
1852 .no_instances
= true,
1858 .coldplug
= mount_coldplug
,
1862 .start
= mount_start
,
1864 .reload
= mount_reload
,
1868 .serialize
= mount_serialize
,
1869 .deserialize_item
= mount_deserialize_item
,
1871 .active_state
= mount_active_state
,
1872 .sub_state_to_string
= mount_sub_state_to_string
,
1874 .check_gc
= mount_check_gc
,
1876 .sigchld_event
= mount_sigchld_event
,
1878 .reset_failed
= mount_reset_failed
,
1880 .bus_interface
= "org.freedesktop.systemd1.Mount",
1881 .bus_vtable
= bus_mount_vtable
,
1882 .bus_set_property
= bus_mount_set_property
,
1883 .bus_commit_properties
= bus_mount_commit_properties
,
1885 .get_timeout
= mount_get_timeout
,
1887 .can_transient
= true,
1889 .enumerate
= mount_enumerate
,
1890 .shutdown
= mount_shutdown
,
1892 .status_message_formats
= {
1893 .starting_stopping
= {
1894 [0] = "Mounting %s...",
1895 [1] = "Unmounting %s...",
1897 .finished_start_job
= {
1898 [JOB_DONE
] = "Mounted %s.",
1899 [JOB_FAILED
] = "Failed to mount %s.",
1900 [JOB_DEPENDENCY
] = "Dependency failed for %s.",
1901 [JOB_TIMEOUT
] = "Timed out mounting %s.",
1903 .finished_stop_job
= {
1904 [JOB_DONE
] = "Unmounted %s.",
1905 [JOB_FAILED
] = "Failed unmounting %s.",
1906 [JOB_TIMEOUT
] = "Timed out unmounting %s.",