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 <sys/epoll.h>
30 #include "load-fragment.h"
31 #include "load-dropin.h"
35 #include "path-util.h"
36 #include "mount-setup.h"
37 #include "unit-name.h"
38 #include "dbus-mount.h"
40 #include "bus-errors.h"
41 #include "exit-status.h"
44 static const UnitActiveState state_translation_table
[_MOUNT_STATE_MAX
] = {
45 [MOUNT_DEAD
] = UNIT_INACTIVE
,
46 [MOUNT_MOUNTING
] = UNIT_ACTIVATING
,
47 [MOUNT_MOUNTING_DONE
] = UNIT_ACTIVE
,
48 [MOUNT_MOUNTED
] = UNIT_ACTIVE
,
49 [MOUNT_REMOUNTING
] = UNIT_RELOADING
,
50 [MOUNT_UNMOUNTING
] = UNIT_DEACTIVATING
,
51 [MOUNT_MOUNTING_SIGTERM
] = UNIT_DEACTIVATING
,
52 [MOUNT_MOUNTING_SIGKILL
] = UNIT_DEACTIVATING
,
53 [MOUNT_REMOUNTING_SIGTERM
] = UNIT_RELOADING
,
54 [MOUNT_REMOUNTING_SIGKILL
] = UNIT_RELOADING
,
55 [MOUNT_UNMOUNTING_SIGTERM
] = UNIT_DEACTIVATING
,
56 [MOUNT_UNMOUNTING_SIGKILL
] = UNIT_DEACTIVATING
,
57 [MOUNT_FAILED
] = UNIT_FAILED
60 static void mount_init(Unit
*u
) {
64 assert(u
->load_state
== UNIT_STUB
);
66 m
->timeout_usec
= DEFAULT_TIMEOUT_USEC
;
67 m
->directory_mode
= 0755;
69 exec_context_init(&m
->exec_context
);
71 if (unit_has_name(u
, "-.mount")) {
72 /* Don't allow start/stop for root directory */
73 UNIT(m
)->refuse_manual_start
= true;
74 UNIT(m
)->refuse_manual_stop
= true;
76 /* The stdio/kmsg bridge socket is on /, in order to avoid a
77 * dep loop, don't use kmsg logging for -.mount */
78 m
->exec_context
.std_output
= u
->manager
->default_std_output
;
79 m
->exec_context
.std_error
= u
->manager
->default_std_error
;
82 kill_context_init(&m
->kill_context
);
84 /* We need to make sure that /bin/mount is always called in
85 * the same process group as us, so that the autofs kernel
86 * side doesn't send us another mount request while we are
87 * already trying to comply its last one. */
88 m
->exec_context
.same_pgrp
= true;
90 m
->timer_watch
.type
= WATCH_INVALID
;
92 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
94 UNIT(m
)->ignore_on_isolate
= true;
97 static void mount_unwatch_control_pid(Mount
*m
) {
100 if (m
->control_pid
<= 0)
103 unit_unwatch_pid(UNIT(m
), m
->control_pid
);
107 static void mount_parameters_done(MountParameters
*p
) {
114 p
->what
= p
->options
= p
->fstype
= NULL
;
117 static void mount_done(Unit
*u
) {
125 mount_parameters_done(&m
->parameters_proc_self_mountinfo
);
126 mount_parameters_done(&m
->parameters_fragment
);
128 exec_context_done(&m
->exec_context
);
129 exec_command_done_array(m
->exec_command
, _MOUNT_EXEC_COMMAND_MAX
);
130 m
->control_command
= NULL
;
132 mount_unwatch_control_pid(m
);
134 unit_unwatch_timer(u
, &m
->timer_watch
);
137 static MountParameters
* get_mount_parameters_fragment(Mount
*m
) {
140 if (m
->from_fragment
)
141 return &m
->parameters_fragment
;
146 static MountParameters
* get_mount_parameters(Mount
*m
) {
149 if (m
->from_proc_self_mountinfo
)
150 return &m
->parameters_proc_self_mountinfo
;
152 return get_mount_parameters_fragment(m
);
155 static int mount_add_mount_links(Mount
*m
) {
162 pm
= get_mount_parameters_fragment(m
);
164 /* Adds in links to other mount points that might lie below or
165 * above us in the hierarchy */
167 LIST_FOREACH(units_by_type
, other
, UNIT(m
)->manager
->units_by_type
[UNIT_MOUNT
]) {
168 Mount
*n
= MOUNT(other
);
174 if (UNIT(n
)->load_state
!= UNIT_LOADED
)
177 pn
= get_mount_parameters_fragment(n
);
179 if (path_startswith(m
->where
, n
->where
)) {
181 if ((r
= unit_add_dependency(UNIT(m
), UNIT_AFTER
, UNIT(n
), true)) < 0)
185 if ((r
= unit_add_dependency(UNIT(m
), UNIT_REQUIRES
, UNIT(n
), true)) < 0)
188 } else if (path_startswith(n
->where
, m
->where
)) {
190 if ((r
= unit_add_dependency(UNIT(n
), UNIT_AFTER
, UNIT(m
), true)) < 0)
194 if ((r
= unit_add_dependency(UNIT(n
), UNIT_REQUIRES
, UNIT(m
), true)) < 0)
197 } else if (pm
&& pm
->what
&& path_startswith(pm
->what
, n
->where
)) {
199 if ((r
= unit_add_dependency(UNIT(m
), UNIT_AFTER
, UNIT(n
), true)) < 0)
202 if ((r
= unit_add_dependency(UNIT(m
), UNIT_REQUIRES
, UNIT(n
), true)) < 0)
205 } else if (pn
&& pn
->what
&& path_startswith(pn
->what
, m
->where
)) {
207 if ((r
= unit_add_dependency(UNIT(n
), UNIT_AFTER
, UNIT(m
), true)) < 0)
210 if ((r
= unit_add_dependency(UNIT(n
), UNIT_REQUIRES
, UNIT(m
), true)) < 0)
218 static int mount_add_swap_links(Mount
*m
) {
224 LIST_FOREACH(units_by_type
, other
, UNIT(m
)->manager
->units_by_type
[UNIT_SWAP
])
225 if ((r
= swap_add_one_mount_link(SWAP(other
), m
)) < 0)
231 static int mount_add_path_links(Mount
*m
) {
237 LIST_FOREACH(units_by_type
, other
, UNIT(m
)->manager
->units_by_type
[UNIT_PATH
])
238 if ((r
= path_add_one_mount_link(PATH(other
), m
)) < 0)
244 static int mount_add_automount_links(Mount
*m
) {
250 LIST_FOREACH(units_by_type
, other
, UNIT(m
)->manager
->units_by_type
[UNIT_AUTOMOUNT
])
251 if ((r
= automount_add_one_mount_link(AUTOMOUNT(other
), m
)) < 0)
257 static int mount_add_socket_links(Mount
*m
) {
263 LIST_FOREACH(units_by_type
, other
, UNIT(m
)->manager
->units_by_type
[UNIT_SOCKET
])
264 if ((r
= socket_add_one_mount_link(SOCKET(other
), m
)) < 0)
270 static int mount_add_requires_mounts_links(Mount
*m
) {
276 LIST_FOREACH(has_requires_mounts_for
, other
, UNIT(m
)->manager
->has_requires_mounts_for
) {
277 r
= unit_add_one_mount_link(other
, m
);
285 static char* mount_test_option(const char *haystack
, const char *needle
) {
290 /* Like glibc's hasmntopt(), but works on a string, not a
297 me
.mnt_opts
= (char*) haystack
;
299 return hasmntopt(&me
, needle
);
302 static bool mount_is_network(MountParameters
*p
) {
305 if (mount_test_option(p
->options
, "_netdev"))
308 if (p
->fstype
&& fstype_is_network(p
->fstype
))
314 static bool mount_is_bind(MountParameters
*p
) {
317 if (mount_test_option(p
->options
, "bind"))
320 if (p
->fstype
&& streq(p
->fstype
, "bind"))
326 static bool needs_quota(MountParameters
*p
) {
329 if (mount_is_network(p
))
332 if (mount_is_bind(p
))
335 return mount_test_option(p
->options
, "usrquota") ||
336 mount_test_option(p
->options
, "grpquota") ||
337 mount_test_option(p
->options
, "quota") ||
338 mount_test_option(p
->options
, "usrjquota") ||
339 mount_test_option(p
->options
, "grpjquota");
342 static int mount_add_device_links(Mount
*m
) {
348 p
= get_mount_parameters_fragment(m
);
355 if (!mount_is_bind(p
) &&
356 !path_equal(m
->where
, "/")) {
357 r
= unit_add_node_link(UNIT(m
), p
->what
, false);
364 !path_equal(m
->where
, "/") &&
365 UNIT(m
)->manager
->running_as
== MANAGER_SYSTEM
) {
368 /* Let's add in the fsck service */
370 /* aka SPECIAL_FSCK_SERVICE */
371 name
= unit_name_from_path_instance("systemd-fsck", p
->what
, ".service");
375 r
= manager_load_unit_prepare(UNIT(m
)->manager
, name
, NULL
, NULL
, &fsck
);
377 log_warning("Failed to prepare unit %s: %s", name
, strerror(-r
));
383 SERVICE(fsck
)->fsck_passno
= p
->passno
;
385 r
= unit_add_two_dependencies(UNIT(m
), UNIT_AFTER
, UNIT_REQUIRES
, fsck
, true);
393 static int mount_add_quota_links(Mount
*m
) {
399 if (UNIT(m
)->manager
->running_as
!= MANAGER_SYSTEM
)
402 p
= get_mount_parameters_fragment(m
);
409 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_BEFORE
, UNIT_WANTS
, SPECIAL_QUOTACHECK_SERVICE
, NULL
, true);
413 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_BEFORE
, UNIT_WANTS
, SPECIAL_QUOTAON_SERVICE
, NULL
, true);
420 static int mount_add_default_dependencies(Mount
*m
) {
427 if (UNIT(m
)->manager
->running_as
!= MANAGER_SYSTEM
)
430 p
= get_mount_parameters_fragment(m
);
434 if (path_equal(m
->where
, "/"))
437 if (mount_is_network(p
))
438 after
= SPECIAL_REMOTE_FS_PRE_TARGET
;
440 after
= SPECIAL_LOCAL_FS_PRE_TARGET
;
442 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_WANTS
, UNIT_AFTER
, after
, NULL
, true);
446 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_UMOUNT_TARGET
, NULL
, true);
453 static int mount_fix_timeouts(Mount
*m
) {
455 const char *timeout
= NULL
;
464 p
= get_mount_parameters_fragment(m
);
468 /* Allow configuration how long we wait for a device that
469 * backs a mount point to show up. This is useful to support
470 * endless device timeouts for devices that show up only after
471 * user input, like crypto devices. */
473 if ((timeout
= mount_test_option(p
->options
, "comment=systemd.device-timeout")))
475 else if ((timeout
= mount_test_option(p
->options
, "x-systemd.device-timeout")))
480 t
= strndup(timeout
, strcspn(timeout
, ",;" WHITESPACE
));
484 r
= parse_usec(t
, &u
);
488 log_warning("Failed to parse timeout for %s, ignoring: %s", m
->where
, timeout
);
492 SET_FOREACH(other
, UNIT(m
)->dependencies
[UNIT_AFTER
], i
) {
493 if (other
->type
!= UNIT_DEVICE
)
496 other
->job_timeout
= u
;
502 static int mount_verify(Mount
*m
) {
507 if (UNIT(m
)->load_state
!= UNIT_LOADED
)
510 if (!m
->from_fragment
&& !m
->from_proc_self_mountinfo
)
513 if (!(e
= unit_name_from_path(m
->where
, ".mount")))
516 b
= unit_has_name(UNIT(m
), e
);
520 log_error("%s's Where setting doesn't match unit name. Refusing.", UNIT(m
)->id
);
524 if (mount_point_is_api(m
->where
) || mount_point_ignore(m
->where
)) {
525 log_error("Cannot create mount unit for API file system %s. Refusing.", m
->where
);
529 if (UNIT(m
)->fragment_path
&& !m
->parameters_fragment
.what
) {
530 log_error("%s's What setting is missing. Refusing.", UNIT(m
)->id
);
534 if (m
->exec_context
.pam_name
&& m
->kill_context
.kill_mode
!= KILL_CONTROL_GROUP
) {
535 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(m
)->id
);
542 static int mount_add_extras(Mount
*m
) {
546 r
= unit_add_exec_dependencies(u
, &m
->exec_context
);
550 if (UNIT(m
)->fragment_path
)
551 m
->from_fragment
= true;
554 m
->where
= unit_name_to_path(u
->id
);
559 path_kill_slashes(m
->where
);
561 if (!UNIT(m
)->description
) {
562 r
= unit_set_description(u
, m
->where
);
567 r
= mount_add_device_links(m
);
571 r
= mount_add_mount_links(m
);
575 r
= mount_add_socket_links(m
);
579 r
= mount_add_swap_links(m
);
583 r
= mount_add_path_links(m
);
587 r
= mount_add_requires_mounts_links(m
);
591 r
= mount_add_automount_links(m
);
595 r
= mount_add_quota_links(m
);
599 if (UNIT(m
)->default_dependencies
) {
600 r
= mount_add_default_dependencies(m
);
605 r
= unit_add_default_cgroups(u
);
609 r
= mount_fix_timeouts(m
);
616 static int mount_load(Unit
*u
) {
621 assert(u
->load_state
== UNIT_STUB
);
623 if (m
->from_proc_self_mountinfo
)
624 r
= unit_load_fragment_and_dropin_optional(u
);
626 r
= unit_load_fragment_and_dropin(u
);
631 /* This is a new unit? Then let's add in some extras */
632 if (u
->load_state
== UNIT_LOADED
) {
633 r
= mount_add_extras(m
);
637 r
= unit_patch_working_directory(UNIT(m
), &m
->exec_context
);
642 return mount_verify(m
);
645 static int mount_notify_automount(Mount
*m
, int status
) {
652 SET_FOREACH(p
, UNIT(m
)->dependencies
[UNIT_TRIGGERED_BY
], i
)
653 if (p
->type
== UNIT_AUTOMOUNT
) {
654 r
= automount_send_ready(AUTOMOUNT(p
), status
);
662 static void mount_set_state(Mount
*m
, MountState state
) {
663 MountState old_state
;
666 old_state
= m
->state
;
669 if (state
!= MOUNT_MOUNTING
&&
670 state
!= MOUNT_MOUNTING_DONE
&&
671 state
!= MOUNT_REMOUNTING
&&
672 state
!= MOUNT_UNMOUNTING
&&
673 state
!= MOUNT_MOUNTING_SIGTERM
&&
674 state
!= MOUNT_MOUNTING_SIGKILL
&&
675 state
!= MOUNT_UNMOUNTING_SIGTERM
&&
676 state
!= MOUNT_UNMOUNTING_SIGKILL
&&
677 state
!= MOUNT_REMOUNTING_SIGTERM
&&
678 state
!= MOUNT_REMOUNTING_SIGKILL
) {
679 unit_unwatch_timer(UNIT(m
), &m
->timer_watch
);
680 mount_unwatch_control_pid(m
);
681 m
->control_command
= NULL
;
682 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
685 if (state
== MOUNT_MOUNTED
||
686 state
== MOUNT_REMOUNTING
)
687 mount_notify_automount(m
, 0);
688 else if (state
== MOUNT_DEAD
||
689 state
== MOUNT_UNMOUNTING
||
690 state
== MOUNT_MOUNTING_SIGTERM
||
691 state
== MOUNT_MOUNTING_SIGKILL
||
692 state
== MOUNT_REMOUNTING_SIGTERM
||
693 state
== MOUNT_REMOUNTING_SIGKILL
||
694 state
== MOUNT_UNMOUNTING_SIGTERM
||
695 state
== MOUNT_UNMOUNTING_SIGKILL
||
696 state
== MOUNT_FAILED
) {
697 if (state
!= old_state
)
698 mount_notify_automount(m
, -ENODEV
);
701 if (state
!= old_state
)
702 log_debug("%s changed %s -> %s",
704 mount_state_to_string(old_state
),
705 mount_state_to_string(state
));
707 unit_notify(UNIT(m
), state_translation_table
[old_state
], state_translation_table
[state
], m
->reload_result
== MOUNT_SUCCESS
);
708 m
->reload_result
= MOUNT_SUCCESS
;
711 static int mount_coldplug(Unit
*u
) {
713 MountState new_state
= MOUNT_DEAD
;
717 assert(m
->state
== MOUNT_DEAD
);
719 if (m
->deserialized_state
!= m
->state
)
720 new_state
= m
->deserialized_state
;
721 else if (m
->from_proc_self_mountinfo
)
722 new_state
= MOUNT_MOUNTED
;
724 if (new_state
!= m
->state
) {
726 if (new_state
== MOUNT_MOUNTING
||
727 new_state
== MOUNT_MOUNTING_DONE
||
728 new_state
== MOUNT_REMOUNTING
||
729 new_state
== MOUNT_UNMOUNTING
||
730 new_state
== MOUNT_MOUNTING_SIGTERM
||
731 new_state
== MOUNT_MOUNTING_SIGKILL
||
732 new_state
== MOUNT_UNMOUNTING_SIGTERM
||
733 new_state
== MOUNT_UNMOUNTING_SIGKILL
||
734 new_state
== MOUNT_REMOUNTING_SIGTERM
||
735 new_state
== MOUNT_REMOUNTING_SIGKILL
) {
737 if (m
->control_pid
<= 0)
740 if ((r
= unit_watch_pid(UNIT(m
), m
->control_pid
)) < 0)
743 if ((r
= unit_watch_timer(UNIT(m
), m
->timeout_usec
, &m
->timer_watch
)) < 0)
747 mount_set_state(m
, new_state
);
753 static void mount_dump(Unit
*u
, FILE *f
, const char *prefix
) {
760 p
= get_mount_parameters(m
);
763 "%sMount State: %s\n"
767 "%sFile System Type: %s\n"
769 "%sFrom /proc/self/mountinfo: %s\n"
770 "%sFrom fragment: %s\n"
771 "%sDirectoryMode: %04o\n",
772 prefix
, mount_state_to_string(m
->state
),
773 prefix
, mount_result_to_string(m
->result
),
775 prefix
, strna(p
->what
),
776 prefix
, strna(p
->fstype
),
777 prefix
, strna(p
->options
),
778 prefix
, yes_no(m
->from_proc_self_mountinfo
),
779 prefix
, yes_no(m
->from_fragment
),
780 prefix
, m
->directory_mode
);
782 if (m
->control_pid
> 0)
784 "%sControl PID: %lu\n",
785 prefix
, (unsigned long) m
->control_pid
);
787 exec_context_dump(&m
->exec_context
, f
, prefix
);
788 kill_context_dump(&m
->kill_context
, f
, prefix
);
791 static int mount_spawn(Mount
*m
, ExecCommand
*c
, pid_t
*_pid
) {
799 if ((r
= unit_watch_timer(UNIT(m
), m
->timeout_usec
, &m
->timer_watch
)) < 0)
802 if ((r
= exec_spawn(c
,
806 UNIT(m
)->manager
->environment
,
810 UNIT(m
)->manager
->confirm_spawn
,
811 UNIT(m
)->cgroup_bondings
,
812 UNIT(m
)->cgroup_attributes
,
819 if ((r
= unit_watch_pid(UNIT(m
), pid
)) < 0)
820 /* FIXME: we need to do something here */
828 unit_unwatch_timer(UNIT(m
), &m
->timer_watch
);
833 static void mount_enter_dead(Mount
*m
, MountResult f
) {
836 if (f
!= MOUNT_SUCCESS
)
839 mount_set_state(m
, m
->result
!= MOUNT_SUCCESS
? MOUNT_FAILED
: MOUNT_DEAD
);
842 static void mount_enter_mounted(Mount
*m
, MountResult f
) {
845 if (f
!= MOUNT_SUCCESS
)
848 mount_set_state(m
, MOUNT_MOUNTED
);
851 static void mount_enter_signal(Mount
*m
, MountState state
, MountResult f
) {
854 bool wait_for_exit
= false;
858 if (f
!= MOUNT_SUCCESS
)
861 if (m
->kill_context
.kill_mode
!= KILL_NONE
) {
862 int sig
= (state
== MOUNT_MOUNTING_SIGTERM
||
863 state
== MOUNT_UNMOUNTING_SIGTERM
||
864 state
== MOUNT_REMOUNTING_SIGTERM
) ? m
->kill_context
.kill_signal
: SIGKILL
;
866 if (m
->control_pid
> 0) {
867 if (kill_and_sigcont(m
->control_pid
, sig
) < 0 && errno
!= ESRCH
)
869 log_warning("Failed to kill control process %li: %m", (long) m
->control_pid
);
871 wait_for_exit
= true;
874 if (m
->kill_context
.kill_mode
== KILL_CONTROL_GROUP
) {
876 if (!(pid_set
= set_new(trivial_hash_func
, trivial_compare_func
))) {
881 /* Exclude the control pid from being killed via the cgroup */
882 if (m
->control_pid
> 0)
883 if ((r
= set_put(pid_set
, LONG_TO_PTR(m
->control_pid
))) < 0)
886 r
= cgroup_bonding_kill_list(UNIT(m
)->cgroup_bondings
, sig
, true, false, pid_set
, NULL
);
888 if (r
!= -EAGAIN
&& r
!= -ESRCH
&& r
!= -ENOENT
)
889 log_warning("Failed to kill control group: %s", strerror(-r
));
891 wait_for_exit
= true;
899 if ((r
= unit_watch_timer(UNIT(m
), m
->timeout_usec
, &m
->timer_watch
)) < 0)
902 mount_set_state(m
, state
);
903 } else if (state
== MOUNT_REMOUNTING_SIGTERM
|| state
== MOUNT_REMOUNTING_SIGKILL
)
904 mount_enter_mounted(m
, MOUNT_SUCCESS
);
906 mount_enter_dead(m
, MOUNT_SUCCESS
);
911 log_warning("%s failed to kill processes: %s", UNIT(m
)->id
, strerror(-r
));
913 if (state
== MOUNT_REMOUNTING_SIGTERM
|| state
== MOUNT_REMOUNTING_SIGKILL
)
914 mount_enter_mounted(m
, MOUNT_FAILURE_RESOURCES
);
916 mount_enter_dead(m
, MOUNT_FAILURE_RESOURCES
);
922 static void mount_enter_unmounting(Mount
*m
) {
927 m
->control_command_id
= MOUNT_EXEC_UNMOUNT
;
928 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_UNMOUNT
;
930 if ((r
= exec_command_set(
937 mount_unwatch_control_pid(m
);
939 if ((r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
)) < 0)
942 mount_set_state(m
, MOUNT_UNMOUNTING
);
947 log_warning("%s failed to run 'umount' task: %s", UNIT(m
)->id
, strerror(-r
));
948 mount_enter_mounted(m
, MOUNT_FAILURE_RESOURCES
);
951 static void mount_enter_mounting(Mount
*m
) {
957 m
->control_command_id
= MOUNT_EXEC_MOUNT
;
958 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_MOUNT
;
960 mkdir_p_label(m
->where
, m
->directory_mode
);
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 mkdir_p_label(p
->what
, m
->directory_mode
);
967 if (m
->from_fragment
)
968 r
= exec_command_set(
971 m
->parameters_fragment
.what
,
973 "-t", m
->parameters_fragment
.fstype
? m
->parameters_fragment
.fstype
: "auto",
974 m
->parameters_fragment
.options
? "-o" : NULL
, m
->parameters_fragment
.options
,
982 mount_unwatch_control_pid(m
);
984 if ((r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
)) < 0)
987 mount_set_state(m
, MOUNT_MOUNTING
);
992 log_warning("%s failed to run 'mount' task: %s", UNIT(m
)->id
, strerror(-r
));
993 mount_enter_dead(m
, MOUNT_FAILURE_RESOURCES
);
996 static void mount_enter_mounting_done(Mount
*m
) {
999 mount_set_state(m
, MOUNT_MOUNTING_DONE
);
1002 static void mount_enter_remounting(Mount
*m
) {
1007 m
->control_command_id
= MOUNT_EXEC_REMOUNT
;
1008 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_REMOUNT
;
1010 if (m
->from_fragment
) {
1014 if (m
->parameters_fragment
.options
) {
1015 if (!(buf
= strappend("remount,", m
->parameters_fragment
.options
))) {
1024 r
= exec_command_set(
1027 m
->parameters_fragment
.what
,
1029 "-t", m
->parameters_fragment
.fstype
? m
->parameters_fragment
.fstype
: "auto",
1040 mount_unwatch_control_pid(m
);
1042 if ((r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
)) < 0)
1045 mount_set_state(m
, MOUNT_REMOUNTING
);
1050 log_warning("%s failed to run 'remount' task: %s", UNIT(m
)->id
, strerror(-r
));
1051 m
->reload_result
= MOUNT_FAILURE_RESOURCES
;
1052 mount_enter_mounted(m
, MOUNT_SUCCESS
);
1055 static int mount_start(Unit
*u
) {
1056 Mount
*m
= MOUNT(u
);
1060 /* We cannot fulfill this request right now, try again later
1062 if (m
->state
== MOUNT_UNMOUNTING
||
1063 m
->state
== MOUNT_UNMOUNTING_SIGTERM
||
1064 m
->state
== MOUNT_UNMOUNTING_SIGKILL
||
1065 m
->state
== MOUNT_MOUNTING_SIGTERM
||
1066 m
->state
== MOUNT_MOUNTING_SIGKILL
)
1069 /* Already on it! */
1070 if (m
->state
== MOUNT_MOUNTING
)
1073 assert(m
->state
== MOUNT_DEAD
|| m
->state
== MOUNT_FAILED
);
1075 m
->result
= MOUNT_SUCCESS
;
1076 m
->reload_result
= MOUNT_SUCCESS
;
1078 mount_enter_mounting(m
);
1082 static int mount_stop(Unit
*u
) {
1083 Mount
*m
= MOUNT(u
);
1088 if (m
->state
== MOUNT_UNMOUNTING
||
1089 m
->state
== MOUNT_UNMOUNTING_SIGKILL
||
1090 m
->state
== MOUNT_UNMOUNTING_SIGTERM
||
1091 m
->state
== MOUNT_MOUNTING_SIGTERM
||
1092 m
->state
== MOUNT_MOUNTING_SIGKILL
)
1095 assert(m
->state
== MOUNT_MOUNTING
||
1096 m
->state
== MOUNT_MOUNTING_DONE
||
1097 m
->state
== MOUNT_MOUNTED
||
1098 m
->state
== MOUNT_REMOUNTING
||
1099 m
->state
== MOUNT_REMOUNTING_SIGTERM
||
1100 m
->state
== MOUNT_REMOUNTING_SIGKILL
);
1102 mount_enter_unmounting(m
);
1106 static int mount_reload(Unit
*u
) {
1107 Mount
*m
= MOUNT(u
);
1111 if (m
->state
== MOUNT_MOUNTING_DONE
)
1114 assert(m
->state
== MOUNT_MOUNTED
);
1116 mount_enter_remounting(m
);
1120 static int mount_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
1121 Mount
*m
= MOUNT(u
);
1127 unit_serialize_item(u
, f
, "state", mount_state_to_string(m
->state
));
1128 unit_serialize_item(u
, f
, "result", mount_result_to_string(m
->result
));
1129 unit_serialize_item(u
, f
, "reload-result", mount_result_to_string(m
->reload_result
));
1131 if (m
->control_pid
> 0)
1132 unit_serialize_item_format(u
, f
, "control-pid", "%lu", (unsigned long) m
->control_pid
);
1134 if (m
->control_command_id
>= 0)
1135 unit_serialize_item(u
, f
, "control-command", mount_exec_command_to_string(m
->control_command_id
));
1140 static int mount_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
1141 Mount
*m
= MOUNT(u
);
1148 if (streq(key
, "state")) {
1151 if ((state
= mount_state_from_string(value
)) < 0)
1152 log_debug("Failed to parse state value %s", value
);
1154 m
->deserialized_state
= state
;
1155 } else if (streq(key
, "result")) {
1158 f
= mount_result_from_string(value
);
1160 log_debug("Failed to parse result value %s", value
);
1161 else if (f
!= MOUNT_SUCCESS
)
1164 } else if (streq(key
, "reload-result")) {
1167 f
= mount_result_from_string(value
);
1169 log_debug("Failed to parse reload result value %s", value
);
1170 else if (f
!= MOUNT_SUCCESS
)
1171 m
->reload_result
= f
;
1173 } else if (streq(key
, "control-pid")) {
1176 if (parse_pid(value
, &pid
) < 0)
1177 log_debug("Failed to parse control-pid value %s", value
);
1179 m
->control_pid
= pid
;
1180 } else if (streq(key
, "control-command")) {
1181 MountExecCommand id
;
1183 if ((id
= mount_exec_command_from_string(value
)) < 0)
1184 log_debug("Failed to parse exec-command value %s", value
);
1186 m
->control_command_id
= id
;
1187 m
->control_command
= m
->exec_command
+ id
;
1191 log_debug("Unknown serialization key '%s'", key
);
1196 static UnitActiveState
mount_active_state(Unit
*u
) {
1199 return state_translation_table
[MOUNT(u
)->state
];
1202 static const char *mount_sub_state_to_string(Unit
*u
) {
1205 return mount_state_to_string(MOUNT(u
)->state
);
1208 static bool mount_check_gc(Unit
*u
) {
1209 Mount
*m
= MOUNT(u
);
1213 return m
->from_proc_self_mountinfo
;
1216 static void mount_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
1217 Mount
*m
= MOUNT(u
);
1223 if (pid
!= m
->control_pid
)
1228 if (is_clean_exit(code
, status
))
1230 else if (code
== CLD_EXITED
)
1231 f
= MOUNT_FAILURE_EXIT_CODE
;
1232 else if (code
== CLD_KILLED
)
1233 f
= MOUNT_FAILURE_SIGNAL
;
1234 else if (code
== CLD_DUMPED
)
1235 f
= MOUNT_FAILURE_CORE_DUMP
;
1237 assert_not_reached("Unknown code");
1239 if (f
!= MOUNT_SUCCESS
)
1242 if (m
->control_command
) {
1243 exec_status_exit(&m
->control_command
->exec_status
, &m
->exec_context
, pid
, code
, status
);
1245 m
->control_command
= NULL
;
1246 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
1249 log_full(f
== MOUNT_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
,
1250 "%s mount process exited, code=%s status=%i", u
->id
, sigchld_code_to_string(code
), status
);
1252 /* Note that mount(8) returning and the kernel sending us a
1253 * mount table change event might happen out-of-order. If an
1254 * operation succeed we assume the kernel will follow soon too
1255 * and already change into the resulting state. If it fails
1256 * we check if the kernel still knows about the mount. and
1257 * change state accordingly. */
1261 case MOUNT_MOUNTING
:
1262 case MOUNT_MOUNTING_DONE
:
1263 case MOUNT_MOUNTING_SIGKILL
:
1264 case MOUNT_MOUNTING_SIGTERM
:
1266 if (f
== MOUNT_SUCCESS
)
1267 mount_enter_mounted(m
, f
);
1268 else if (m
->from_proc_self_mountinfo
)
1269 mount_enter_mounted(m
, f
);
1271 mount_enter_dead(m
, f
);
1274 case MOUNT_REMOUNTING
:
1275 case MOUNT_REMOUNTING_SIGKILL
:
1276 case MOUNT_REMOUNTING_SIGTERM
:
1278 m
->reload_result
= f
;
1279 if (m
->from_proc_self_mountinfo
)
1280 mount_enter_mounted(m
, MOUNT_SUCCESS
);
1282 mount_enter_dead(m
, MOUNT_SUCCESS
);
1286 case MOUNT_UNMOUNTING
:
1287 case MOUNT_UNMOUNTING_SIGKILL
:
1288 case MOUNT_UNMOUNTING_SIGTERM
:
1290 if (f
== MOUNT_SUCCESS
)
1291 mount_enter_dead(m
, f
);
1292 else if (m
->from_proc_self_mountinfo
)
1293 mount_enter_mounted(m
, f
);
1295 mount_enter_dead(m
, f
);
1299 assert_not_reached("Uh, control process died at wrong time.");
1302 /* Notify clients about changed exit status */
1303 unit_add_to_dbus_queue(u
);
1306 static void mount_timer_event(Unit
*u
, uint64_t elapsed
, Watch
*w
) {
1307 Mount
*m
= MOUNT(u
);
1310 assert(elapsed
== 1);
1311 assert(w
== &m
->timer_watch
);
1315 case MOUNT_MOUNTING
:
1316 case MOUNT_MOUNTING_DONE
:
1317 log_warning("%s mounting timed out. Stopping.", u
->id
);
1318 mount_enter_signal(m
, MOUNT_MOUNTING_SIGTERM
, MOUNT_FAILURE_TIMEOUT
);
1321 case MOUNT_REMOUNTING
:
1322 log_warning("%s remounting timed out. Stopping.", u
->id
);
1323 m
->reload_result
= MOUNT_FAILURE_TIMEOUT
;
1324 mount_enter_mounted(m
, MOUNT_SUCCESS
);
1327 case MOUNT_UNMOUNTING
:
1328 log_warning("%s unmounting timed out. Stopping.", u
->id
);
1329 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGTERM
, MOUNT_FAILURE_TIMEOUT
);
1332 case MOUNT_MOUNTING_SIGTERM
:
1333 if (m
->kill_context
.send_sigkill
) {
1334 log_warning("%s mounting timed out. Killing.", u
->id
);
1335 mount_enter_signal(m
, MOUNT_MOUNTING_SIGKILL
, MOUNT_FAILURE_TIMEOUT
);
1337 log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u
->id
);
1339 if (m
->from_proc_self_mountinfo
)
1340 mount_enter_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1342 mount_enter_dead(m
, MOUNT_FAILURE_TIMEOUT
);
1346 case MOUNT_REMOUNTING_SIGTERM
:
1347 if (m
->kill_context
.send_sigkill
) {
1348 log_warning("%s remounting timed out. Killing.", u
->id
);
1349 mount_enter_signal(m
, MOUNT_REMOUNTING_SIGKILL
, MOUNT_FAILURE_TIMEOUT
);
1351 log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u
->id
);
1353 if (m
->from_proc_self_mountinfo
)
1354 mount_enter_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1356 mount_enter_dead(m
, MOUNT_FAILURE_TIMEOUT
);
1360 case MOUNT_UNMOUNTING_SIGTERM
:
1361 if (m
->kill_context
.send_sigkill
) {
1362 log_warning("%s unmounting timed out. Killing.", u
->id
);
1363 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGKILL
, MOUNT_FAILURE_TIMEOUT
);
1365 log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u
->id
);
1367 if (m
->from_proc_self_mountinfo
)
1368 mount_enter_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1370 mount_enter_dead(m
, MOUNT_FAILURE_TIMEOUT
);
1374 case MOUNT_MOUNTING_SIGKILL
:
1375 case MOUNT_REMOUNTING_SIGKILL
:
1376 case MOUNT_UNMOUNTING_SIGKILL
:
1377 log_warning("%s mount process still around after SIGKILL. Ignoring.", u
->id
);
1379 if (m
->from_proc_self_mountinfo
)
1380 mount_enter_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1382 mount_enter_dead(m
, MOUNT_FAILURE_TIMEOUT
);
1386 assert_not_reached("Timeout at wrong time.");
1390 static int mount_add_one(
1394 const char *options
,
1401 char *e
, *w
= NULL
, *o
= NULL
, *f
= NULL
;
1410 /* Ignore API mount points. They should never be referenced in
1411 * dependencies ever. */
1412 if (mount_point_is_api(where
) || mount_point_ignore(where
))
1415 if (streq(fstype
, "autofs"))
1418 /* probably some kind of swap, ignore */
1419 if (!is_path(where
))
1422 e
= unit_name_from_path(where
, ".mount");
1426 u
= manager_get_unit(m
, e
);
1430 u
= unit_new(m
, sizeof(Mount
));
1436 r
= unit_add_name(u
, e
);
1442 MOUNT(u
)->where
= strdup(where
);
1443 if (!MOUNT(u
)->where
) {
1448 unit_add_to_load_queue(u
);
1453 if (u
->load_state
== UNIT_ERROR
) {
1454 u
->load_state
= UNIT_LOADED
;
1456 r
= mount_add_extras(MOUNT(u
));
1462 if (!(w
= strdup(what
)) ||
1463 !(o
= strdup(options
)) ||
1464 !(f
= strdup(fstype
))) {
1469 p
= &MOUNT(u
)->parameters_proc_self_mountinfo
;
1471 MOUNT(u
)->is_mounted
= true;
1472 MOUNT(u
)->just_mounted
= !MOUNT(u
)->from_proc_self_mountinfo
;
1473 MOUNT(u
)->just_changed
= !streq_ptr(p
->options
, o
);
1476 MOUNT(u
)->from_proc_self_mountinfo
= true;
1489 unit_add_to_dbus_queue(u
);
1504 static int mount_load_proc_self_mountinfo(Manager
*m
, bool set_flags
) {
1507 char *device
, *path
, *options
, *options2
, *fstype
, *d
, *p
, *o
;
1511 rewind(m
->proc_self_mountinfo
);
1516 device
= path
= options
= options2
= fstype
= d
= p
= o
= NULL
;
1518 if ((k
= fscanf(m
->proc_self_mountinfo
,
1519 "%*s " /* (1) mount id */
1520 "%*s " /* (2) parent id */
1521 "%*s " /* (3) major:minor */
1522 "%*s " /* (4) root */
1523 "%ms " /* (5) mount point */
1524 "%ms" /* (6) mount options */
1525 "%*[^-]" /* (7) optional fields */
1526 "- " /* (8) separator */
1527 "%ms " /* (9) file system type */
1528 "%ms" /* (10) mount source */
1529 "%ms" /* (11) mount options 2 */
1530 "%*[^\n]", /* some rubbish at the end */
1540 log_warning("Failed to parse /proc/self/mountinfo:%u.", i
);
1544 o
= strjoin(options
, ",", options2
, NULL
);
1550 if (!(d
= cunescape(device
)) ||
1551 !(p
= cunescape(path
))) {
1556 if ((k
= mount_add_one(m
, d
, p
, o
, fstype
, 0, set_flags
)) < 0)
1583 static void mount_shutdown(Manager
*m
) {
1586 if (m
->proc_self_mountinfo
) {
1587 fclose(m
->proc_self_mountinfo
);
1588 m
->proc_self_mountinfo
= NULL
;
1592 static int mount_enumerate(Manager
*m
) {
1594 struct epoll_event ev
;
1597 if (!m
->proc_self_mountinfo
) {
1598 if (!(m
->proc_self_mountinfo
= fopen("/proc/self/mountinfo", "re")))
1601 m
->mount_watch
.type
= WATCH_MOUNT
;
1602 m
->mount_watch
.fd
= fileno(m
->proc_self_mountinfo
);
1605 ev
.events
= EPOLLPRI
;
1606 ev
.data
.ptr
= &m
->mount_watch
;
1608 if (epoll_ctl(m
->epoll_fd
, EPOLL_CTL_ADD
, m
->mount_watch
.fd
, &ev
) < 0)
1612 if ((r
= mount_load_proc_self_mountinfo(m
, false)) < 0)
1622 void mount_fd_event(Manager
*m
, int events
) {
1627 assert(events
& EPOLLPRI
);
1629 /* The manager calls this for every fd event happening on the
1630 * /proc/self/mountinfo file, which informs us about mounting
1633 if ((r
= mount_load_proc_self_mountinfo(m
, true)) < 0) {
1634 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r
));
1636 /* Reset flags, just in case, for later calls */
1637 LIST_FOREACH(units_by_type
, u
, m
->units_by_type
[UNIT_MOUNT
]) {
1638 Mount
*mount
= MOUNT(u
);
1640 mount
->is_mounted
= mount
->just_mounted
= mount
->just_changed
= false;
1646 manager_dispatch_load_queue(m
);
1648 LIST_FOREACH(units_by_type
, u
, m
->units_by_type
[UNIT_MOUNT
]) {
1649 Mount
*mount
= MOUNT(u
);
1651 if (!mount
->is_mounted
) {
1652 /* This has just been unmounted. */
1654 mount
->from_proc_self_mountinfo
= false;
1656 switch (mount
->state
) {
1659 mount_enter_dead(mount
, MOUNT_SUCCESS
);
1663 mount_set_state(mount
, mount
->state
);
1668 } else if (mount
->just_mounted
|| mount
->just_changed
) {
1670 /* New or changed mount entry */
1672 switch (mount
->state
) {
1676 mount_enter_mounted(mount
, MOUNT_SUCCESS
);
1679 case MOUNT_MOUNTING
:
1680 mount_enter_mounting_done(mount
);
1684 /* Nothing really changed, but let's
1685 * issue an notification call
1686 * nonetheless, in case somebody is
1687 * waiting for this. (e.g. file system
1688 * ro/rw remounts.) */
1689 mount_set_state(mount
, mount
->state
);
1694 /* Reset the flags for later calls */
1695 mount
->is_mounted
= mount
->just_mounted
= mount
->just_changed
= false;
1699 static void mount_reset_failed(Unit
*u
) {
1700 Mount
*m
= MOUNT(u
);
1704 if (m
->state
== MOUNT_FAILED
)
1705 mount_set_state(m
, MOUNT_DEAD
);
1707 m
->result
= MOUNT_SUCCESS
;
1708 m
->reload_result
= MOUNT_SUCCESS
;
1711 static int mount_kill(Unit
*u
, KillWho who
, int signo
, DBusError
*error
) {
1712 Mount
*m
= MOUNT(u
);
1714 Set
*pid_set
= NULL
;
1718 if (who
== KILL_MAIN
) {
1719 dbus_set_error(error
, BUS_ERROR_NO_SUCH_PROCESS
, "Mount units have no main processes");
1723 if (m
->control_pid
<= 0 && who
== KILL_CONTROL
) {
1724 dbus_set_error(error
, BUS_ERROR_NO_SUCH_PROCESS
, "No control process to kill");
1728 if (who
== KILL_CONTROL
|| who
== KILL_ALL
)
1729 if (m
->control_pid
> 0)
1730 if (kill(m
->control_pid
, signo
) < 0)
1733 if (who
== KILL_ALL
) {
1736 pid_set
= set_new(trivial_hash_func
, trivial_compare_func
);
1740 /* Exclude the control pid from being killed via the cgroup */
1741 if (m
->control_pid
> 0) {
1742 q
= set_put(pid_set
, LONG_TO_PTR(m
->control_pid
));
1749 q
= cgroup_bonding_kill_list(UNIT(m
)->cgroup_bondings
, signo
, false, false, pid_set
, NULL
);
1750 if (q
< 0 && q
!= -EAGAIN
&& q
!= -ESRCH
&& q
!= -ENOENT
)
1761 static const char* const mount_state_table
[_MOUNT_STATE_MAX
] = {
1762 [MOUNT_DEAD
] = "dead",
1763 [MOUNT_MOUNTING
] = "mounting",
1764 [MOUNT_MOUNTING_DONE
] = "mounting-done",
1765 [MOUNT_MOUNTED
] = "mounted",
1766 [MOUNT_REMOUNTING
] = "remounting",
1767 [MOUNT_UNMOUNTING
] = "unmounting",
1768 [MOUNT_MOUNTING_SIGTERM
] = "mounting-sigterm",
1769 [MOUNT_MOUNTING_SIGKILL
] = "mounting-sigkill",
1770 [MOUNT_REMOUNTING_SIGTERM
] = "remounting-sigterm",
1771 [MOUNT_REMOUNTING_SIGKILL
] = "remounting-sigkill",
1772 [MOUNT_UNMOUNTING_SIGTERM
] = "unmounting-sigterm",
1773 [MOUNT_UNMOUNTING_SIGKILL
] = "unmounting-sigkill",
1774 [MOUNT_FAILED
] = "failed"
1777 DEFINE_STRING_TABLE_LOOKUP(mount_state
, MountState
);
1779 static const char* const mount_exec_command_table
[_MOUNT_EXEC_COMMAND_MAX
] = {
1780 [MOUNT_EXEC_MOUNT
] = "ExecMount",
1781 [MOUNT_EXEC_UNMOUNT
] = "ExecUnmount",
1782 [MOUNT_EXEC_REMOUNT
] = "ExecRemount",
1785 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command
, MountExecCommand
);
1787 static const char* const mount_result_table
[_MOUNT_RESULT_MAX
] = {
1788 [MOUNT_SUCCESS
] = "success",
1789 [MOUNT_FAILURE_RESOURCES
] = "resources",
1790 [MOUNT_FAILURE_TIMEOUT
] = "timeout",
1791 [MOUNT_FAILURE_EXIT_CODE
] = "exit-code",
1792 [MOUNT_FAILURE_SIGNAL
] = "signal",
1793 [MOUNT_FAILURE_CORE_DUMP
] = "core-dump"
1796 DEFINE_STRING_TABLE_LOOKUP(mount_result
, MountResult
);
1798 const UnitVTable mount_vtable
= {
1799 .object_size
= sizeof(Mount
),
1806 .no_instances
= true,
1812 .coldplug
= mount_coldplug
,
1816 .start
= mount_start
,
1818 .reload
= mount_reload
,
1822 .serialize
= mount_serialize
,
1823 .deserialize_item
= mount_deserialize_item
,
1825 .active_state
= mount_active_state
,
1826 .sub_state_to_string
= mount_sub_state_to_string
,
1828 .check_gc
= mount_check_gc
,
1830 .sigchld_event
= mount_sigchld_event
,
1831 .timer_event
= mount_timer_event
,
1833 .reset_failed
= mount_reset_failed
,
1835 .bus_interface
= "org.freedesktop.systemd1.Mount",
1836 .bus_message_handler
= bus_mount_message_handler
,
1837 .bus_invalidating_properties
= bus_mount_invalidating_properties
,
1839 .enumerate
= mount_enumerate
,
1840 .shutdown
= mount_shutdown
,
1842 .status_message_formats
= {
1843 .starting_stopping
= {
1844 [0] = "Mounting %s...",
1845 [1] = "Unmounting %s...",
1847 .finished_start_job
= {
1848 [JOB_DONE
] = "Mounted %s.",
1849 [JOB_FAILED
] = "Failed to mount %s.",
1850 [JOB_DEPENDENCY
] = "Dependency failed for %s.",
1851 [JOB_TIMEOUT
] = "Timed out mounting %s.",
1853 .finished_stop_job
= {
1854 [JOB_DONE
] = "Unmounted %s.",
1855 [JOB_FAILED
] = "Failed unmounting %s.",
1856 [JOB_TIMEOUT
] = "Timed out unmounting %s.",