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 /* We need to make sure that /bin/mount is always called in
83 * the same process group as us, so that the autofs kernel
84 * side doesn't send us another mount request while we are
85 * already trying to comply its last one. */
86 m
->exec_context
.same_pgrp
= true;
88 m
->timer_watch
.type
= WATCH_INVALID
;
90 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
92 UNIT(m
)->ignore_on_isolate
= true;
95 static void mount_unwatch_control_pid(Mount
*m
) {
98 if (m
->control_pid
<= 0)
101 unit_unwatch_pid(UNIT(m
), m
->control_pid
);
105 static void mount_parameters_done(MountParameters
*p
) {
112 p
->what
= p
->options
= p
->fstype
= NULL
;
115 static void mount_done(Unit
*u
) {
123 mount_parameters_done(&m
->parameters_proc_self_mountinfo
);
124 mount_parameters_done(&m
->parameters_fragment
);
126 exec_context_done(&m
->exec_context
);
127 exec_command_done_array(m
->exec_command
, _MOUNT_EXEC_COMMAND_MAX
);
128 m
->control_command
= NULL
;
130 mount_unwatch_control_pid(m
);
132 unit_unwatch_timer(u
, &m
->timer_watch
);
135 static MountParameters
* get_mount_parameters_fragment(Mount
*m
) {
138 if (m
->from_fragment
)
139 return &m
->parameters_fragment
;
144 static MountParameters
* get_mount_parameters(Mount
*m
) {
147 if (m
->from_proc_self_mountinfo
)
148 return &m
->parameters_proc_self_mountinfo
;
150 return get_mount_parameters_fragment(m
);
153 static int mount_add_mount_links(Mount
*m
) {
160 pm
= get_mount_parameters_fragment(m
);
162 /* Adds in links to other mount points that might lie below or
163 * above us in the hierarchy */
165 LIST_FOREACH(units_by_type
, other
, UNIT(m
)->manager
->units_by_type
[UNIT_MOUNT
]) {
166 Mount
*n
= MOUNT(other
);
172 if (UNIT(n
)->load_state
!= UNIT_LOADED
)
175 pn
= get_mount_parameters_fragment(n
);
177 if (path_startswith(m
->where
, n
->where
)) {
179 if ((r
= unit_add_dependency(UNIT(m
), UNIT_AFTER
, UNIT(n
), true)) < 0)
183 if ((r
= unit_add_dependency(UNIT(m
), UNIT_REQUIRES
, UNIT(n
), true)) < 0)
186 } else if (path_startswith(n
->where
, m
->where
)) {
188 if ((r
= unit_add_dependency(UNIT(n
), UNIT_AFTER
, UNIT(m
), true)) < 0)
192 if ((r
= unit_add_dependency(UNIT(n
), UNIT_REQUIRES
, UNIT(m
), true)) < 0)
195 } else if (pm
&& pm
->what
&& path_startswith(pm
->what
, n
->where
)) {
197 if ((r
= unit_add_dependency(UNIT(m
), UNIT_AFTER
, UNIT(n
), true)) < 0)
200 if ((r
= unit_add_dependency(UNIT(m
), UNIT_REQUIRES
, UNIT(n
), true)) < 0)
203 } else if (pn
&& pn
->what
&& path_startswith(pn
->what
, m
->where
)) {
205 if ((r
= unit_add_dependency(UNIT(n
), UNIT_AFTER
, UNIT(m
), true)) < 0)
208 if ((r
= unit_add_dependency(UNIT(n
), UNIT_REQUIRES
, UNIT(m
), true)) < 0)
216 static int mount_add_swap_links(Mount
*m
) {
222 LIST_FOREACH(units_by_type
, other
, UNIT(m
)->manager
->units_by_type
[UNIT_SWAP
])
223 if ((r
= swap_add_one_mount_link(SWAP(other
), m
)) < 0)
229 static int mount_add_path_links(Mount
*m
) {
235 LIST_FOREACH(units_by_type
, other
, UNIT(m
)->manager
->units_by_type
[UNIT_PATH
])
236 if ((r
= path_add_one_mount_link(PATH(other
), m
)) < 0)
242 static int mount_add_automount_links(Mount
*m
) {
248 LIST_FOREACH(units_by_type
, other
, UNIT(m
)->manager
->units_by_type
[UNIT_AUTOMOUNT
])
249 if ((r
= automount_add_one_mount_link(AUTOMOUNT(other
), m
)) < 0)
255 static int mount_add_socket_links(Mount
*m
) {
261 LIST_FOREACH(units_by_type
, other
, UNIT(m
)->manager
->units_by_type
[UNIT_SOCKET
])
262 if ((r
= socket_add_one_mount_link(SOCKET(other
), m
)) < 0)
268 static int mount_add_requires_mounts_links(Mount
*m
) {
274 LIST_FOREACH(has_requires_mounts_for
, other
, UNIT(m
)->manager
->has_requires_mounts_for
) {
275 r
= unit_add_one_mount_link(other
, m
);
283 static char* mount_test_option(const char *haystack
, const char *needle
) {
288 /* Like glibc's hasmntopt(), but works on a string, not a
295 me
.mnt_opts
= (char*) haystack
;
297 return hasmntopt(&me
, needle
);
300 static bool mount_is_network(MountParameters
*p
) {
303 if (mount_test_option(p
->options
, "_netdev"))
306 if (p
->fstype
&& fstype_is_network(p
->fstype
))
312 static bool mount_is_bind(MountParameters
*p
) {
315 if (mount_test_option(p
->options
, "bind"))
318 if (p
->fstype
&& streq(p
->fstype
, "bind"))
324 static bool needs_quota(MountParameters
*p
) {
327 if (mount_is_network(p
))
330 if (mount_is_bind(p
))
333 return mount_test_option(p
->options
, "usrquota") ||
334 mount_test_option(p
->options
, "grpquota") ||
335 mount_test_option(p
->options
, "quota") ||
336 mount_test_option(p
->options
, "usrjquota") ||
337 mount_test_option(p
->options
, "grpjquota");
340 static int mount_add_device_links(Mount
*m
) {
346 p
= get_mount_parameters_fragment(m
);
353 if (!mount_is_bind(p
) &&
354 !path_equal(m
->where
, "/")) {
355 r
= unit_add_node_link(UNIT(m
), p
->what
, false);
362 !path_equal(m
->where
, "/") &&
363 UNIT(m
)->manager
->running_as
== MANAGER_SYSTEM
) {
366 /* Let's add in the fsck service */
368 /* aka SPECIAL_FSCK_SERVICE */
369 name
= unit_name_from_path_instance("systemd-fsck", p
->what
, ".service");
373 r
= manager_load_unit_prepare(UNIT(m
)->manager
, name
, NULL
, NULL
, &fsck
);
375 log_warning("Failed to prepare unit %s: %s", name
, strerror(-r
));
381 SERVICE(fsck
)->fsck_passno
= p
->passno
;
383 r
= unit_add_two_dependencies(UNIT(m
), UNIT_AFTER
, UNIT_REQUIRES
, fsck
, true);
391 static int mount_add_quota_links(Mount
*m
) {
397 if (UNIT(m
)->manager
->running_as
!= MANAGER_SYSTEM
)
400 p
= get_mount_parameters_fragment(m
);
407 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_BEFORE
, UNIT_WANTS
, SPECIAL_QUOTACHECK_SERVICE
, NULL
, true);
411 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_BEFORE
, UNIT_WANTS
, SPECIAL_QUOTAON_SERVICE
, NULL
, true);
418 static int mount_add_default_dependencies(Mount
*m
) {
425 if (UNIT(m
)->manager
->running_as
!= MANAGER_SYSTEM
)
428 p
= get_mount_parameters_fragment(m
);
432 if (path_equal(m
->where
, "/"))
435 if (mount_is_network(p
))
436 after
= SPECIAL_REMOTE_FS_PRE_TARGET
;
438 after
= SPECIAL_LOCAL_FS_PRE_TARGET
;
440 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_WANTS
, UNIT_AFTER
, after
, NULL
, true);
444 r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_UMOUNT_TARGET
, NULL
, true);
451 static int mount_fix_timeouts(Mount
*m
) {
453 const char *timeout
= NULL
;
462 p
= get_mount_parameters_fragment(m
);
466 /* Allow configuration how long we wait for a device that
467 * backs a mount point to show up. This is useful to support
468 * endless device timeouts for devices that show up only after
469 * user input, like crypto devices. */
471 if ((timeout
= mount_test_option(p
->options
, "comment=systemd.device-timeout")))
473 else if ((timeout
= mount_test_option(p
->options
, "x-systemd.device-timeout")))
478 t
= strndup(timeout
, strcspn(timeout
, ",;" WHITESPACE
));
482 r
= parse_usec(t
, &u
);
486 log_warning("Failed to parse timeout for %s, ignoring: %s", m
->where
, timeout
);
490 SET_FOREACH(other
, UNIT(m
)->dependencies
[UNIT_AFTER
], i
) {
491 if (other
->type
!= UNIT_DEVICE
)
494 other
->job_timeout
= u
;
500 static int mount_verify(Mount
*m
) {
505 if (UNIT(m
)->load_state
!= UNIT_LOADED
)
508 if (!m
->from_fragment
&& !m
->from_proc_self_mountinfo
)
511 if (!(e
= unit_name_from_path(m
->where
, ".mount")))
514 b
= unit_has_name(UNIT(m
), e
);
518 log_error("%s's Where setting doesn't match unit name. Refusing.", UNIT(m
)->id
);
522 if (mount_point_is_api(m
->where
) || mount_point_ignore(m
->where
)) {
523 log_error("Cannot create mount unit for API file system %s. Refusing.", m
->where
);
527 if (UNIT(m
)->fragment_path
&& !m
->parameters_fragment
.what
) {
528 log_error("%s's What setting is missing. Refusing.", UNIT(m
)->id
);
532 if (m
->exec_context
.pam_name
&& m
->exec_context
.kill_mode
!= KILL_CONTROL_GROUP
) {
533 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(m
)->id
);
540 static int mount_load(Unit
*u
) {
545 assert(u
->load_state
== UNIT_STUB
);
547 if ((r
= unit_load_fragment_and_dropin_optional(u
)) < 0)
550 /* This is a new unit? Then let's add in some extras */
551 if (u
->load_state
== UNIT_LOADED
) {
552 if ((r
= unit_add_exec_dependencies(u
, &m
->exec_context
)) < 0)
555 if (UNIT(m
)->fragment_path
)
556 m
->from_fragment
= true;
559 if (!(m
->where
= unit_name_to_path(u
->id
)))
562 path_kill_slashes(m
->where
);
564 if (!UNIT(m
)->description
)
565 if ((r
= unit_set_description(u
, m
->where
)) < 0)
568 if ((r
= mount_add_device_links(m
)) < 0)
571 if ((r
= mount_add_mount_links(m
)) < 0)
574 if ((r
= mount_add_socket_links(m
)) < 0)
577 if ((r
= mount_add_swap_links(m
)) < 0)
580 if ((r
= mount_add_path_links(m
)) < 0)
583 r
= mount_add_requires_mounts_links(m
);
587 if ((r
= mount_add_automount_links(m
)) < 0)
590 r
= mount_add_quota_links(m
);
594 if (UNIT(m
)->default_dependencies
)
595 if ((r
= mount_add_default_dependencies(m
)) < 0)
598 if ((r
= unit_add_default_cgroups(u
)) < 0)
601 mount_fix_timeouts(m
);
604 return mount_verify(m
);
607 static int mount_notify_automount(Mount
*m
, int status
) {
614 SET_FOREACH(p
, UNIT(m
)->dependencies
[UNIT_TRIGGERED_BY
], i
)
615 if (p
->type
== UNIT_AUTOMOUNT
) {
616 r
= automount_send_ready(AUTOMOUNT(p
), status
);
624 static void mount_set_state(Mount
*m
, MountState state
) {
625 MountState old_state
;
628 old_state
= m
->state
;
631 if (state
!= MOUNT_MOUNTING
&&
632 state
!= MOUNT_MOUNTING_DONE
&&
633 state
!= MOUNT_REMOUNTING
&&
634 state
!= MOUNT_UNMOUNTING
&&
635 state
!= MOUNT_MOUNTING_SIGTERM
&&
636 state
!= MOUNT_MOUNTING_SIGKILL
&&
637 state
!= MOUNT_UNMOUNTING_SIGTERM
&&
638 state
!= MOUNT_UNMOUNTING_SIGKILL
&&
639 state
!= MOUNT_REMOUNTING_SIGTERM
&&
640 state
!= MOUNT_REMOUNTING_SIGKILL
) {
641 unit_unwatch_timer(UNIT(m
), &m
->timer_watch
);
642 mount_unwatch_control_pid(m
);
643 m
->control_command
= NULL
;
644 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
647 if (state
== MOUNT_MOUNTED
||
648 state
== MOUNT_REMOUNTING
)
649 mount_notify_automount(m
, 0);
650 else if (state
== MOUNT_DEAD
||
651 state
== MOUNT_UNMOUNTING
||
652 state
== MOUNT_MOUNTING_SIGTERM
||
653 state
== MOUNT_MOUNTING_SIGKILL
||
654 state
== MOUNT_REMOUNTING_SIGTERM
||
655 state
== MOUNT_REMOUNTING_SIGKILL
||
656 state
== MOUNT_UNMOUNTING_SIGTERM
||
657 state
== MOUNT_UNMOUNTING_SIGKILL
||
658 state
== MOUNT_FAILED
)
659 mount_notify_automount(m
, -ENODEV
);
661 if (state
!= old_state
)
662 log_debug("%s changed %s -> %s",
664 mount_state_to_string(old_state
),
665 mount_state_to_string(state
));
667 unit_notify(UNIT(m
), state_translation_table
[old_state
], state_translation_table
[state
], m
->reload_result
== MOUNT_SUCCESS
);
668 m
->reload_result
= MOUNT_SUCCESS
;
671 static int mount_coldplug(Unit
*u
) {
673 MountState new_state
= MOUNT_DEAD
;
677 assert(m
->state
== MOUNT_DEAD
);
679 if (m
->deserialized_state
!= m
->state
)
680 new_state
= m
->deserialized_state
;
681 else if (m
->from_proc_self_mountinfo
)
682 new_state
= MOUNT_MOUNTED
;
684 if (new_state
!= m
->state
) {
686 if (new_state
== MOUNT_MOUNTING
||
687 new_state
== MOUNT_MOUNTING_DONE
||
688 new_state
== MOUNT_REMOUNTING
||
689 new_state
== MOUNT_UNMOUNTING
||
690 new_state
== MOUNT_MOUNTING_SIGTERM
||
691 new_state
== MOUNT_MOUNTING_SIGKILL
||
692 new_state
== MOUNT_UNMOUNTING_SIGTERM
||
693 new_state
== MOUNT_UNMOUNTING_SIGKILL
||
694 new_state
== MOUNT_REMOUNTING_SIGTERM
||
695 new_state
== MOUNT_REMOUNTING_SIGKILL
) {
697 if (m
->control_pid
<= 0)
700 if ((r
= unit_watch_pid(UNIT(m
), m
->control_pid
)) < 0)
703 if ((r
= unit_watch_timer(UNIT(m
), m
->timeout_usec
, &m
->timer_watch
)) < 0)
707 mount_set_state(m
, new_state
);
713 static void mount_dump(Unit
*u
, FILE *f
, const char *prefix
) {
720 p
= get_mount_parameters(m
);
723 "%sMount State: %s\n"
727 "%sFile System Type: %s\n"
729 "%sFrom /proc/self/mountinfo: %s\n"
730 "%sFrom fragment: %s\n"
731 "%sDirectoryMode: %04o\n",
732 prefix
, mount_state_to_string(m
->state
),
733 prefix
, mount_result_to_string(m
->result
),
735 prefix
, strna(p
->what
),
736 prefix
, strna(p
->fstype
),
737 prefix
, strna(p
->options
),
738 prefix
, yes_no(m
->from_proc_self_mountinfo
),
739 prefix
, yes_no(m
->from_fragment
),
740 prefix
, m
->directory_mode
);
742 if (m
->control_pid
> 0)
744 "%sControl PID: %lu\n",
745 prefix
, (unsigned long) m
->control_pid
);
747 exec_context_dump(&m
->exec_context
, f
, prefix
);
750 static int mount_spawn(Mount
*m
, ExecCommand
*c
, pid_t
*_pid
) {
758 if ((r
= unit_watch_timer(UNIT(m
), m
->timeout_usec
, &m
->timer_watch
)) < 0)
761 if ((r
= exec_spawn(c
,
765 UNIT(m
)->manager
->environment
,
769 UNIT(m
)->manager
->confirm_spawn
,
770 UNIT(m
)->cgroup_bondings
,
771 UNIT(m
)->cgroup_attributes
,
778 if ((r
= unit_watch_pid(UNIT(m
), pid
)) < 0)
779 /* FIXME: we need to do something here */
787 unit_unwatch_timer(UNIT(m
), &m
->timer_watch
);
792 static void mount_enter_dead(Mount
*m
, MountResult f
) {
795 if (f
!= MOUNT_SUCCESS
)
798 mount_set_state(m
, m
->result
!= MOUNT_SUCCESS
? MOUNT_FAILED
: MOUNT_DEAD
);
801 static void mount_enter_mounted(Mount
*m
, MountResult f
) {
804 if (f
!= MOUNT_SUCCESS
)
807 mount_set_state(m
, MOUNT_MOUNTED
);
810 static void mount_enter_signal(Mount
*m
, MountState state
, MountResult f
) {
813 bool wait_for_exit
= false;
817 if (f
!= MOUNT_SUCCESS
)
820 if (m
->exec_context
.kill_mode
!= KILL_NONE
) {
821 int sig
= (state
== MOUNT_MOUNTING_SIGTERM
||
822 state
== MOUNT_UNMOUNTING_SIGTERM
||
823 state
== MOUNT_REMOUNTING_SIGTERM
) ? m
->exec_context
.kill_signal
: SIGKILL
;
825 if (m
->control_pid
> 0) {
826 if (kill_and_sigcont(m
->control_pid
, sig
) < 0 && errno
!= ESRCH
)
828 log_warning("Failed to kill control process %li: %m", (long) m
->control_pid
);
830 wait_for_exit
= true;
833 if (m
->exec_context
.kill_mode
== KILL_CONTROL_GROUP
) {
835 if (!(pid_set
= set_new(trivial_hash_func
, trivial_compare_func
))) {
840 /* Exclude the control pid from being killed via the cgroup */
841 if (m
->control_pid
> 0)
842 if ((r
= set_put(pid_set
, LONG_TO_PTR(m
->control_pid
))) < 0)
845 r
= cgroup_bonding_kill_list(UNIT(m
)->cgroup_bondings
, sig
, true, false, pid_set
, NULL
);
847 if (r
!= -EAGAIN
&& r
!= -ESRCH
&& r
!= -ENOENT
)
848 log_warning("Failed to kill control group: %s", strerror(-r
));
850 wait_for_exit
= true;
858 if ((r
= unit_watch_timer(UNIT(m
), m
->timeout_usec
, &m
->timer_watch
)) < 0)
861 mount_set_state(m
, state
);
862 } else if (state
== MOUNT_REMOUNTING_SIGTERM
|| state
== MOUNT_REMOUNTING_SIGKILL
)
863 mount_enter_mounted(m
, MOUNT_SUCCESS
);
865 mount_enter_dead(m
, MOUNT_SUCCESS
);
870 log_warning("%s failed to kill processes: %s", UNIT(m
)->id
, strerror(-r
));
872 if (state
== MOUNT_REMOUNTING_SIGTERM
|| state
== MOUNT_REMOUNTING_SIGKILL
)
873 mount_enter_mounted(m
, MOUNT_FAILURE_RESOURCES
);
875 mount_enter_dead(m
, MOUNT_FAILURE_RESOURCES
);
881 static void mount_enter_unmounting(Mount
*m
) {
886 m
->control_command_id
= MOUNT_EXEC_UNMOUNT
;
887 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_UNMOUNT
;
889 if ((r
= exec_command_set(
896 mount_unwatch_control_pid(m
);
898 if ((r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
)) < 0)
901 mount_set_state(m
, MOUNT_UNMOUNTING
);
906 log_warning("%s failed to run 'umount' task: %s", UNIT(m
)->id
, strerror(-r
));
907 mount_enter_mounted(m
, MOUNT_FAILURE_RESOURCES
);
910 static void mount_enter_mounting(Mount
*m
) {
916 m
->control_command_id
= MOUNT_EXEC_MOUNT
;
917 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_MOUNT
;
919 mkdir_p_label(m
->where
, m
->directory_mode
);
921 /* Create the source directory for bind-mounts if needed */
922 p
= get_mount_parameters_fragment(m
);
923 if (p
&& mount_is_bind(p
))
924 mkdir_p_label(p
->what
, m
->directory_mode
);
926 if (m
->from_fragment
)
927 r
= exec_command_set(
930 m
->parameters_fragment
.what
,
932 "-t", m
->parameters_fragment
.fstype
? m
->parameters_fragment
.fstype
: "auto",
933 m
->parameters_fragment
.options
? "-o" : NULL
, m
->parameters_fragment
.options
,
941 mount_unwatch_control_pid(m
);
943 if ((r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
)) < 0)
946 mount_set_state(m
, MOUNT_MOUNTING
);
951 log_warning("%s failed to run 'mount' task: %s", UNIT(m
)->id
, strerror(-r
));
952 mount_enter_dead(m
, MOUNT_FAILURE_RESOURCES
);
955 static void mount_enter_mounting_done(Mount
*m
) {
958 mount_set_state(m
, MOUNT_MOUNTING_DONE
);
961 static void mount_enter_remounting(Mount
*m
) {
966 m
->control_command_id
= MOUNT_EXEC_REMOUNT
;
967 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_REMOUNT
;
969 if (m
->from_fragment
) {
973 if (m
->parameters_fragment
.options
) {
974 if (!(buf
= strappend("remount,", m
->parameters_fragment
.options
))) {
983 r
= exec_command_set(
986 m
->parameters_fragment
.what
,
988 "-t", m
->parameters_fragment
.fstype
? m
->parameters_fragment
.fstype
: "auto",
999 mount_unwatch_control_pid(m
);
1001 if ((r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
)) < 0)
1004 mount_set_state(m
, MOUNT_REMOUNTING
);
1009 log_warning("%s failed to run 'remount' task: %s", UNIT(m
)->id
, strerror(-r
));
1010 m
->reload_result
= MOUNT_FAILURE_RESOURCES
;
1011 mount_enter_mounted(m
, MOUNT_SUCCESS
);
1014 static int mount_start(Unit
*u
) {
1015 Mount
*m
= MOUNT(u
);
1019 /* We cannot fulfill this request right now, try again later
1021 if (m
->state
== MOUNT_UNMOUNTING
||
1022 m
->state
== MOUNT_UNMOUNTING_SIGTERM
||
1023 m
->state
== MOUNT_UNMOUNTING_SIGKILL
||
1024 m
->state
== MOUNT_MOUNTING_SIGTERM
||
1025 m
->state
== MOUNT_MOUNTING_SIGKILL
)
1028 /* Already on it! */
1029 if (m
->state
== MOUNT_MOUNTING
)
1032 assert(m
->state
== MOUNT_DEAD
|| m
->state
== MOUNT_FAILED
);
1034 m
->result
= MOUNT_SUCCESS
;
1035 m
->reload_result
= MOUNT_SUCCESS
;
1037 mount_enter_mounting(m
);
1041 static int mount_stop(Unit
*u
) {
1042 Mount
*m
= MOUNT(u
);
1047 if (m
->state
== MOUNT_UNMOUNTING
||
1048 m
->state
== MOUNT_UNMOUNTING_SIGKILL
||
1049 m
->state
== MOUNT_UNMOUNTING_SIGTERM
||
1050 m
->state
== MOUNT_MOUNTING_SIGTERM
||
1051 m
->state
== MOUNT_MOUNTING_SIGKILL
)
1054 assert(m
->state
== MOUNT_MOUNTING
||
1055 m
->state
== MOUNT_MOUNTING_DONE
||
1056 m
->state
== MOUNT_MOUNTED
||
1057 m
->state
== MOUNT_REMOUNTING
||
1058 m
->state
== MOUNT_REMOUNTING_SIGTERM
||
1059 m
->state
== MOUNT_REMOUNTING_SIGKILL
);
1061 mount_enter_unmounting(m
);
1065 static int mount_reload(Unit
*u
) {
1066 Mount
*m
= MOUNT(u
);
1070 if (m
->state
== MOUNT_MOUNTING_DONE
)
1073 assert(m
->state
== MOUNT_MOUNTED
);
1075 mount_enter_remounting(m
);
1079 static int mount_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
1080 Mount
*m
= MOUNT(u
);
1086 unit_serialize_item(u
, f
, "state", mount_state_to_string(m
->state
));
1087 unit_serialize_item(u
, f
, "result", mount_result_to_string(m
->result
));
1088 unit_serialize_item(u
, f
, "reload-result", mount_result_to_string(m
->reload_result
));
1090 if (m
->control_pid
> 0)
1091 unit_serialize_item_format(u
, f
, "control-pid", "%lu", (unsigned long) m
->control_pid
);
1093 if (m
->control_command_id
>= 0)
1094 unit_serialize_item(u
, f
, "control-command", mount_exec_command_to_string(m
->control_command_id
));
1099 static int mount_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
1100 Mount
*m
= MOUNT(u
);
1107 if (streq(key
, "state")) {
1110 if ((state
= mount_state_from_string(value
)) < 0)
1111 log_debug("Failed to parse state value %s", value
);
1113 m
->deserialized_state
= state
;
1114 } else if (streq(key
, "result")) {
1117 f
= mount_result_from_string(value
);
1119 log_debug("Failed to parse result value %s", value
);
1120 else if (f
!= MOUNT_SUCCESS
)
1123 } else if (streq(key
, "reload-result")) {
1126 f
= mount_result_from_string(value
);
1128 log_debug("Failed to parse reload result value %s", value
);
1129 else if (f
!= MOUNT_SUCCESS
)
1130 m
->reload_result
= f
;
1132 } else if (streq(key
, "control-pid")) {
1135 if (parse_pid(value
, &pid
) < 0)
1136 log_debug("Failed to parse control-pid value %s", value
);
1138 m
->control_pid
= pid
;
1139 } else if (streq(key
, "control-command")) {
1140 MountExecCommand id
;
1142 if ((id
= mount_exec_command_from_string(value
)) < 0)
1143 log_debug("Failed to parse exec-command value %s", value
);
1145 m
->control_command_id
= id
;
1146 m
->control_command
= m
->exec_command
+ id
;
1150 log_debug("Unknown serialization key '%s'", key
);
1155 static UnitActiveState
mount_active_state(Unit
*u
) {
1158 return state_translation_table
[MOUNT(u
)->state
];
1161 static const char *mount_sub_state_to_string(Unit
*u
) {
1164 return mount_state_to_string(MOUNT(u
)->state
);
1167 static bool mount_check_gc(Unit
*u
) {
1168 Mount
*m
= MOUNT(u
);
1172 return m
->from_proc_self_mountinfo
;
1175 static void mount_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
1176 Mount
*m
= MOUNT(u
);
1182 if (pid
!= m
->control_pid
)
1187 if (is_clean_exit(code
, status
))
1189 else if (code
== CLD_EXITED
)
1190 f
= MOUNT_FAILURE_EXIT_CODE
;
1191 else if (code
== CLD_KILLED
)
1192 f
= MOUNT_FAILURE_SIGNAL
;
1193 else if (code
== CLD_DUMPED
)
1194 f
= MOUNT_FAILURE_CORE_DUMP
;
1196 assert_not_reached("Unknown code");
1198 if (f
!= MOUNT_SUCCESS
)
1201 if (m
->control_command
) {
1202 exec_status_exit(&m
->control_command
->exec_status
, &m
->exec_context
, pid
, code
, status
);
1204 m
->control_command
= NULL
;
1205 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
1208 log_full(f
== MOUNT_SUCCESS
? LOG_DEBUG
: LOG_NOTICE
,
1209 "%s mount process exited, code=%s status=%i", u
->id
, sigchld_code_to_string(code
), status
);
1211 /* Note that mount(8) returning and the kernel sending us a
1212 * mount table change event might happen out-of-order. If an
1213 * operation succeed we assume the kernel will follow soon too
1214 * and already change into the resulting state. If it fails
1215 * we check if the kernel still knows about the mount. and
1216 * change state accordingly. */
1220 case MOUNT_MOUNTING
:
1221 case MOUNT_MOUNTING_DONE
:
1222 case MOUNT_MOUNTING_SIGKILL
:
1223 case MOUNT_MOUNTING_SIGTERM
:
1225 if (f
== MOUNT_SUCCESS
)
1226 mount_enter_mounted(m
, f
);
1227 else if (m
->from_proc_self_mountinfo
)
1228 mount_enter_mounted(m
, f
);
1230 mount_enter_dead(m
, f
);
1233 case MOUNT_REMOUNTING
:
1234 case MOUNT_REMOUNTING_SIGKILL
:
1235 case MOUNT_REMOUNTING_SIGTERM
:
1237 m
->reload_result
= f
;
1238 if (m
->from_proc_self_mountinfo
)
1239 mount_enter_mounted(m
, MOUNT_SUCCESS
);
1241 mount_enter_dead(m
, MOUNT_SUCCESS
);
1245 case MOUNT_UNMOUNTING
:
1246 case MOUNT_UNMOUNTING_SIGKILL
:
1247 case MOUNT_UNMOUNTING_SIGTERM
:
1249 if (f
== MOUNT_SUCCESS
)
1250 mount_enter_dead(m
, f
);
1251 else if (m
->from_proc_self_mountinfo
)
1252 mount_enter_mounted(m
, f
);
1254 mount_enter_dead(m
, f
);
1258 assert_not_reached("Uh, control process died at wrong time.");
1261 /* Notify clients about changed exit status */
1262 unit_add_to_dbus_queue(u
);
1265 static void mount_timer_event(Unit
*u
, uint64_t elapsed
, Watch
*w
) {
1266 Mount
*m
= MOUNT(u
);
1269 assert(elapsed
== 1);
1270 assert(w
== &m
->timer_watch
);
1274 case MOUNT_MOUNTING
:
1275 case MOUNT_MOUNTING_DONE
:
1276 log_warning("%s mounting timed out. Stopping.", u
->id
);
1277 mount_enter_signal(m
, MOUNT_MOUNTING_SIGTERM
, MOUNT_FAILURE_TIMEOUT
);
1280 case MOUNT_REMOUNTING
:
1281 log_warning("%s remounting timed out. Stopping.", u
->id
);
1282 m
->reload_result
= MOUNT_FAILURE_TIMEOUT
;
1283 mount_enter_mounted(m
, MOUNT_SUCCESS
);
1286 case MOUNT_UNMOUNTING
:
1287 log_warning("%s unmounting timed out. Stopping.", u
->id
);
1288 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGTERM
, MOUNT_FAILURE_TIMEOUT
);
1291 case MOUNT_MOUNTING_SIGTERM
:
1292 if (m
->exec_context
.send_sigkill
) {
1293 log_warning("%s mounting timed out. Killing.", u
->id
);
1294 mount_enter_signal(m
, MOUNT_MOUNTING_SIGKILL
, MOUNT_FAILURE_TIMEOUT
);
1296 log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u
->id
);
1298 if (m
->from_proc_self_mountinfo
)
1299 mount_enter_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1301 mount_enter_dead(m
, MOUNT_FAILURE_TIMEOUT
);
1305 case MOUNT_REMOUNTING_SIGTERM
:
1306 if (m
->exec_context
.send_sigkill
) {
1307 log_warning("%s remounting timed out. Killing.", u
->id
);
1308 mount_enter_signal(m
, MOUNT_REMOUNTING_SIGKILL
, MOUNT_FAILURE_TIMEOUT
);
1310 log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u
->id
);
1312 if (m
->from_proc_self_mountinfo
)
1313 mount_enter_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1315 mount_enter_dead(m
, MOUNT_FAILURE_TIMEOUT
);
1319 case MOUNT_UNMOUNTING_SIGTERM
:
1320 if (m
->exec_context
.send_sigkill
) {
1321 log_warning("%s unmounting timed out. Killing.", u
->id
);
1322 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGKILL
, MOUNT_FAILURE_TIMEOUT
);
1324 log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u
->id
);
1326 if (m
->from_proc_self_mountinfo
)
1327 mount_enter_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1329 mount_enter_dead(m
, MOUNT_FAILURE_TIMEOUT
);
1333 case MOUNT_MOUNTING_SIGKILL
:
1334 case MOUNT_REMOUNTING_SIGKILL
:
1335 case MOUNT_UNMOUNTING_SIGKILL
:
1336 log_warning("%s mount process still around after SIGKILL. Ignoring.", u
->id
);
1338 if (m
->from_proc_self_mountinfo
)
1339 mount_enter_mounted(m
, MOUNT_FAILURE_TIMEOUT
);
1341 mount_enter_dead(m
, MOUNT_FAILURE_TIMEOUT
);
1345 assert_not_reached("Timeout at wrong time.");
1349 static int mount_add_one(
1353 const char *options
,
1360 char *e
, *w
= NULL
, *o
= NULL
, *f
= NULL
;
1369 /* Ignore API mount points. They should never be referenced in
1370 * dependencies ever. */
1371 if (mount_point_is_api(where
) || mount_point_ignore(where
))
1374 if (streq(fstype
, "autofs"))
1377 /* probably some kind of swap, ignore */
1378 if (!is_path(where
))
1381 e
= unit_name_from_path(where
, ".mount");
1385 u
= manager_get_unit(m
, e
);
1389 u
= unit_new(m
, sizeof(Mount
));
1395 r
= unit_add_name(u
, e
);
1401 MOUNT(u
)->where
= strdup(where
);
1402 if (!MOUNT(u
)->where
) {
1407 unit_add_to_load_queue(u
);
1413 if (!(w
= strdup(what
)) ||
1414 !(o
= strdup(options
)) ||
1415 !(f
= strdup(fstype
))) {
1420 p
= &MOUNT(u
)->parameters_proc_self_mountinfo
;
1422 MOUNT(u
)->is_mounted
= true;
1423 MOUNT(u
)->just_mounted
= !MOUNT(u
)->from_proc_self_mountinfo
;
1424 MOUNT(u
)->just_changed
= !streq_ptr(p
->options
, o
);
1427 MOUNT(u
)->from_proc_self_mountinfo
= true;
1440 unit_add_to_dbus_queue(u
);
1455 static int mount_load_proc_self_mountinfo(Manager
*m
, bool set_flags
) {
1458 char *device
, *path
, *options
, *options2
, *fstype
, *d
, *p
, *o
;
1462 rewind(m
->proc_self_mountinfo
);
1467 device
= path
= options
= options2
= fstype
= d
= p
= o
= NULL
;
1469 if ((k
= fscanf(m
->proc_self_mountinfo
,
1470 "%*s " /* (1) mount id */
1471 "%*s " /* (2) parent id */
1472 "%*s " /* (3) major:minor */
1473 "%*s " /* (4) root */
1474 "%ms " /* (5) mount point */
1475 "%ms" /* (6) mount options */
1476 "%*[^-]" /* (7) optional fields */
1477 "- " /* (8) separator */
1478 "%ms " /* (9) file system type */
1479 "%ms" /* (10) mount source */
1480 "%ms" /* (11) mount options 2 */
1481 "%*[^\n]", /* some rubbish at the end */
1491 log_warning("Failed to parse /proc/self/mountinfo:%u.", i
);
1495 o
= join(options
, ",", options2
, NULL
);
1501 if (!(d
= cunescape(device
)) ||
1502 !(p
= cunescape(path
))) {
1507 if ((k
= mount_add_one(m
, d
, p
, o
, fstype
, 0, set_flags
)) < 0)
1534 static void mount_shutdown(Manager
*m
) {
1537 if (m
->proc_self_mountinfo
) {
1538 fclose(m
->proc_self_mountinfo
);
1539 m
->proc_self_mountinfo
= NULL
;
1543 static int mount_enumerate(Manager
*m
) {
1545 struct epoll_event ev
;
1548 if (!m
->proc_self_mountinfo
) {
1549 if (!(m
->proc_self_mountinfo
= fopen("/proc/self/mountinfo", "re")))
1552 m
->mount_watch
.type
= WATCH_MOUNT
;
1553 m
->mount_watch
.fd
= fileno(m
->proc_self_mountinfo
);
1556 ev
.events
= EPOLLPRI
;
1557 ev
.data
.ptr
= &m
->mount_watch
;
1559 if (epoll_ctl(m
->epoll_fd
, EPOLL_CTL_ADD
, m
->mount_watch
.fd
, &ev
) < 0)
1563 if ((r
= mount_load_proc_self_mountinfo(m
, false)) < 0)
1573 void mount_fd_event(Manager
*m
, int events
) {
1578 assert(events
& EPOLLPRI
);
1580 /* The manager calls this for every fd event happening on the
1581 * /proc/self/mountinfo file, which informs us about mounting
1584 if ((r
= mount_load_proc_self_mountinfo(m
, true)) < 0) {
1585 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r
));
1587 /* Reset flags, just in case, for later calls */
1588 LIST_FOREACH(units_by_type
, u
, m
->units_by_type
[UNIT_MOUNT
]) {
1589 Mount
*mount
= MOUNT(u
);
1591 mount
->is_mounted
= mount
->just_mounted
= mount
->just_changed
= false;
1597 manager_dispatch_load_queue(m
);
1599 LIST_FOREACH(units_by_type
, u
, m
->units_by_type
[UNIT_MOUNT
]) {
1600 Mount
*mount
= MOUNT(u
);
1602 if (!mount
->is_mounted
) {
1603 /* This has just been unmounted. */
1605 mount
->from_proc_self_mountinfo
= false;
1607 switch (mount
->state
) {
1610 mount_enter_dead(mount
, MOUNT_SUCCESS
);
1614 mount_set_state(mount
, mount
->state
);
1619 } else if (mount
->just_mounted
|| mount
->just_changed
) {
1621 /* New or changed mount entry */
1623 switch (mount
->state
) {
1627 mount_enter_mounted(mount
, MOUNT_SUCCESS
);
1630 case MOUNT_MOUNTING
:
1631 mount_enter_mounting_done(mount
);
1635 /* Nothing really changed, but let's
1636 * issue an notification call
1637 * nonetheless, in case somebody is
1638 * waiting for this. (e.g. file system
1639 * ro/rw remounts.) */
1640 mount_set_state(mount
, mount
->state
);
1645 /* Reset the flags for later calls */
1646 mount
->is_mounted
= mount
->just_mounted
= mount
->just_changed
= false;
1650 static void mount_reset_failed(Unit
*u
) {
1651 Mount
*m
= MOUNT(u
);
1655 if (m
->state
== MOUNT_FAILED
)
1656 mount_set_state(m
, MOUNT_DEAD
);
1658 m
->result
= MOUNT_SUCCESS
;
1659 m
->reload_result
= MOUNT_SUCCESS
;
1662 static int mount_kill(Unit
*u
, KillWho who
, KillMode mode
, int signo
, DBusError
*error
) {
1663 Mount
*m
= MOUNT(u
);
1665 Set
*pid_set
= NULL
;
1669 if (who
== KILL_MAIN
) {
1670 dbus_set_error(error
, BUS_ERROR_NO_SUCH_PROCESS
, "Mount units have no main processes");
1674 if (m
->control_pid
<= 0 && who
== KILL_CONTROL
) {
1675 dbus_set_error(error
, BUS_ERROR_NO_SUCH_PROCESS
, "No control process to kill");
1679 if (who
== KILL_CONTROL
|| who
== KILL_ALL
)
1680 if (m
->control_pid
> 0)
1681 if (kill(m
->control_pid
, signo
) < 0)
1684 if (who
== KILL_ALL
&& mode
== KILL_CONTROL_GROUP
) {
1687 if (!(pid_set
= set_new(trivial_hash_func
, trivial_compare_func
)))
1690 /* Exclude the control pid from being killed via the cgroup */
1691 if (m
->control_pid
> 0)
1692 if ((q
= set_put(pid_set
, LONG_TO_PTR(m
->control_pid
))) < 0) {
1697 q
= cgroup_bonding_kill_list(UNIT(m
)->cgroup_bondings
, signo
, false, false, pid_set
, NULL
);
1699 if (q
!= -EAGAIN
&& q
!= -ESRCH
&& q
!= -ENOENT
)
1710 static const char* const mount_state_table
[_MOUNT_STATE_MAX
] = {
1711 [MOUNT_DEAD
] = "dead",
1712 [MOUNT_MOUNTING
] = "mounting",
1713 [MOUNT_MOUNTING_DONE
] = "mounting-done",
1714 [MOUNT_MOUNTED
] = "mounted",
1715 [MOUNT_REMOUNTING
] = "remounting",
1716 [MOUNT_UNMOUNTING
] = "unmounting",
1717 [MOUNT_MOUNTING_SIGTERM
] = "mounting-sigterm",
1718 [MOUNT_MOUNTING_SIGKILL
] = "mounting-sigkill",
1719 [MOUNT_REMOUNTING_SIGTERM
] = "remounting-sigterm",
1720 [MOUNT_REMOUNTING_SIGKILL
] = "remounting-sigkill",
1721 [MOUNT_UNMOUNTING_SIGTERM
] = "unmounting-sigterm",
1722 [MOUNT_UNMOUNTING_SIGKILL
] = "unmounting-sigkill",
1723 [MOUNT_FAILED
] = "failed"
1726 DEFINE_STRING_TABLE_LOOKUP(mount_state
, MountState
);
1728 static const char* const mount_exec_command_table
[_MOUNT_EXEC_COMMAND_MAX
] = {
1729 [MOUNT_EXEC_MOUNT
] = "ExecMount",
1730 [MOUNT_EXEC_UNMOUNT
] = "ExecUnmount",
1731 [MOUNT_EXEC_REMOUNT
] = "ExecRemount",
1734 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command
, MountExecCommand
);
1736 static const char* const mount_result_table
[_MOUNT_RESULT_MAX
] = {
1737 [MOUNT_SUCCESS
] = "success",
1738 [MOUNT_FAILURE_RESOURCES
] = "resources",
1739 [MOUNT_FAILURE_TIMEOUT
] = "timeout",
1740 [MOUNT_FAILURE_EXIT_CODE
] = "exit-code",
1741 [MOUNT_FAILURE_SIGNAL
] = "signal",
1742 [MOUNT_FAILURE_CORE_DUMP
] = "core-dump"
1745 DEFINE_STRING_TABLE_LOOKUP(mount_result
, MountResult
);
1747 const UnitVTable mount_vtable
= {
1749 .object_size
= sizeof(Mount
),
1756 .no_instances
= true,
1762 .coldplug
= mount_coldplug
,
1766 .start
= mount_start
,
1768 .reload
= mount_reload
,
1772 .serialize
= mount_serialize
,
1773 .deserialize_item
= mount_deserialize_item
,
1775 .active_state
= mount_active_state
,
1776 .sub_state_to_string
= mount_sub_state_to_string
,
1778 .check_gc
= mount_check_gc
,
1780 .sigchld_event
= mount_sigchld_event
,
1781 .timer_event
= mount_timer_event
,
1783 .reset_failed
= mount_reset_failed
,
1785 .bus_interface
= "org.freedesktop.systemd1.Mount",
1786 .bus_message_handler
= bus_mount_message_handler
,
1787 .bus_invalidating_properties
= bus_mount_invalidating_properties
,
1789 .enumerate
= mount_enumerate
,
1790 .shutdown
= mount_shutdown
,
1792 .status_message_formats
= {
1793 .starting_stopping
= {
1794 [0] = "Mounting %s...",
1795 [1] = "Unmounting %s...",
1797 .finished_start_job
= {
1798 [JOB_DONE
] = "Mounted %s.",
1799 [JOB_FAILED
] = "Failed to mount %s.",
1800 [JOB_DEPENDENCY
] = "Dependency failed for %s.",
1801 [JOB_TIMEOUT
] = "Timed out mounting %s.",
1803 .finished_stop_job
= {
1804 [JOB_DONE
] = "Unmounted %s.",
1805 [JOB_FAILED
] = "Failed unmounting %s.",
1806 [JOB_TIMEOUT
] = "Timed out unmounting %s.",