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 General Public License as published by
10 the Free Software Foundation; either version 2 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 General Public License for more details.
18 You should have received a copy of the GNU 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"
34 #include "mount-setup.h"
35 #include "unit-name.h"
36 #include "dbus-mount.h"
38 #include "bus-errors.h"
39 #include "exit-status.h"
41 static const UnitActiveState state_translation_table
[_MOUNT_STATE_MAX
] = {
42 [MOUNT_DEAD
] = UNIT_INACTIVE
,
43 [MOUNT_MOUNTING
] = UNIT_ACTIVATING
,
44 [MOUNT_MOUNTING_DONE
] = UNIT_ACTIVE
,
45 [MOUNT_MOUNTED
] = UNIT_ACTIVE
,
46 [MOUNT_REMOUNTING
] = UNIT_RELOADING
,
47 [MOUNT_UNMOUNTING
] = UNIT_DEACTIVATING
,
48 [MOUNT_MOUNTING_SIGTERM
] = UNIT_DEACTIVATING
,
49 [MOUNT_MOUNTING_SIGKILL
] = UNIT_DEACTIVATING
,
50 [MOUNT_REMOUNTING_SIGTERM
] = UNIT_RELOADING
,
51 [MOUNT_REMOUNTING_SIGKILL
] = UNIT_RELOADING
,
52 [MOUNT_UNMOUNTING_SIGTERM
] = UNIT_DEACTIVATING
,
53 [MOUNT_UNMOUNTING_SIGKILL
] = UNIT_DEACTIVATING
,
54 [MOUNT_FAILED
] = UNIT_FAILED
57 static void mount_init(Unit
*u
) {
61 assert(u
->meta
.load_state
== UNIT_STUB
);
63 m
->timeout_usec
= DEFAULT_TIMEOUT_USEC
;
64 m
->directory_mode
= 0755;
66 exec_context_init(&m
->exec_context
);
67 m
->exec_context
.std_output
= EXEC_OUTPUT_KMSG
;
69 /* We need to make sure that /bin/mount is always called in
70 * the same process group as us, so that the autofs kernel
71 * side doesn't send us another mount request while we are
72 * already trying to comply its last one. */
73 m
->exec_context
.same_pgrp
= true;
75 m
->timer_watch
.type
= WATCH_INVALID
;
77 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
80 static void mount_unwatch_control_pid(Mount
*m
) {
83 if (m
->control_pid
<= 0)
86 unit_unwatch_pid(UNIT(m
), m
->control_pid
);
90 static void mount_parameters_done(MountParameters
*p
) {
97 p
->what
= p
->options
= p
->fstype
= NULL
;
100 static void mount_done(Unit
*u
) {
109 /* Try to detach us from the automount unit if there is any */
110 LIST_FOREACH(units_per_type
, other
, m
->meta
.manager
->units_per_type
[UNIT_AUTOMOUNT
]) {
111 Automount
*a
= (Automount
*) other
;
117 mount_parameters_done(&m
->parameters_etc_fstab
);
118 mount_parameters_done(&m
->parameters_proc_self_mountinfo
);
119 mount_parameters_done(&m
->parameters_fragment
);
121 exec_context_done(&m
->exec_context
);
122 exec_command_done_array(m
->exec_command
, _MOUNT_EXEC_COMMAND_MAX
);
123 m
->control_command
= NULL
;
125 mount_unwatch_control_pid(m
);
127 unit_unwatch_timer(u
, &m
->timer_watch
);
130 static int mount_add_mount_links(Mount
*m
) {
137 if (m
->from_fragment
)
138 pm
= &m
->parameters_fragment
;
139 else if (m
->from_etc_fstab
)
140 pm
= &m
->parameters_etc_fstab
;
144 /* Adds in links to other mount points that might lie below or
145 * above us in the hierarchy */
147 LIST_FOREACH(units_per_type
, other
, m
->meta
.manager
->units_per_type
[UNIT_MOUNT
]) {
148 Mount
*n
= (Mount
*) other
;
154 if (n
->meta
.load_state
!= UNIT_LOADED
)
157 if (n
->from_fragment
)
158 pn
= &n
->parameters_fragment
;
159 else if (n
->from_etc_fstab
)
160 pn
= &n
->parameters_etc_fstab
;
164 if (path_startswith(m
->where
, n
->where
)) {
166 if ((r
= unit_add_dependency(UNIT(m
), UNIT_AFTER
, UNIT(n
), true)) < 0)
169 if (n
->from_etc_fstab
|| n
->from_fragment
)
170 if ((r
= unit_add_dependency(UNIT(m
), UNIT_REQUIRES
, UNIT(n
), true)) < 0)
173 } else if (path_startswith(n
->where
, m
->where
)) {
175 if ((r
= unit_add_dependency(UNIT(n
), UNIT_AFTER
, UNIT(m
), true)) < 0)
178 if (m
->from_etc_fstab
|| m
->from_fragment
)
179 if ((r
= unit_add_dependency(UNIT(n
), UNIT_REQUIRES
, UNIT(m
), true)) < 0)
182 } else if (pm
&& path_startswith(pm
->what
, n
->where
)) {
184 if ((r
= unit_add_dependency(UNIT(m
), UNIT_AFTER
, UNIT(n
), true)) < 0)
187 if (m
->from_etc_fstab
|| m
->from_fragment
)
188 if ((r
= unit_add_dependency(UNIT(m
), UNIT_REQUIRES
, UNIT(n
), true)) < 0)
191 } else if (pn
&& path_startswith(pn
->what
, m
->where
)) {
193 if ((r
= unit_add_dependency(UNIT(n
), UNIT_AFTER
, UNIT(m
), true)) < 0)
196 if (n
->from_etc_fstab
|| n
->from_fragment
)
197 if ((r
= unit_add_dependency(UNIT(n
), UNIT_REQUIRES
, UNIT(m
), true)) < 0)
205 static int mount_add_swap_links(Mount
*m
) {
211 LIST_FOREACH(units_per_type
, other
, m
->meta
.manager
->units_per_type
[UNIT_SWAP
])
212 if ((r
= swap_add_one_mount_link((Swap
*) other
, m
)) < 0)
218 static int mount_add_path_links(Mount
*m
) {
224 LIST_FOREACH(units_per_type
, other
, m
->meta
.manager
->units_per_type
[UNIT_PATH
])
225 if ((r
= path_add_one_mount_link((Path
*) other
, m
)) < 0)
231 static int mount_add_automount_links(Mount
*m
) {
237 LIST_FOREACH(units_per_type
, other
, m
->meta
.manager
->units_per_type
[UNIT_AUTOMOUNT
])
238 if ((r
= automount_add_one_mount_link((Automount
*) other
, m
)) < 0)
244 static int mount_add_socket_links(Mount
*m
) {
250 LIST_FOREACH(units_per_type
, other
, m
->meta
.manager
->units_per_type
[UNIT_SOCKET
])
251 if ((r
= socket_add_one_mount_link((Socket
*) other
, m
)) < 0)
257 static char* mount_test_option(const char *haystack
, const char *needle
) {
262 /* Like glibc's hasmntopt(), but works on a string, not a
269 me
.mnt_opts
= (char*) haystack
;
271 return hasmntopt(&me
, needle
);
274 static int mount_add_target_links(Mount
*m
) {
275 const char *target
, *after
= NULL
;
279 bool noauto
, nofail
, handle
, automount
;
283 if (m
->from_fragment
)
284 p
= &m
->parameters_fragment
;
285 else if (m
->from_etc_fstab
)
286 p
= &m
->parameters_etc_fstab
;
290 noauto
= !!mount_test_option(p
->options
, MNTOPT_NOAUTO
);
291 nofail
= !!mount_test_option(p
->options
, "nofail");
292 handle
= !!mount_test_option(p
->options
, "comment=systemd.mount") ||
293 m
->meta
.manager
->mount_auto
;
294 automount
= !!mount_test_option(p
->options
, "comment=systemd.automount");
296 if (mount_test_option(p
->options
, "_netdev") ||
297 (p
->fstype
&& fstype_is_network(p
->fstype
))) {
298 target
= SPECIAL_REMOTE_FS_TARGET
;
300 if (m
->meta
.manager
->running_as
== MANAGER_SYSTEM
)
301 after
= SPECIAL_NETWORK_TARGET
;
303 target
= SPECIAL_LOCAL_FS_TARGET
;
305 if ((r
= manager_load_unit(m
->meta
.manager
, target
, NULL
, NULL
, &tu
)) < 0)
309 if ((r
= unit_add_dependency_by_name(UNIT(m
), UNIT_AFTER
, after
, NULL
, true)) < 0)
312 if (automount
&& m
->meta
.manager
->running_as
== MANAGER_SYSTEM
) {
315 if ((r
= unit_load_related_unit(UNIT(m
), ".automount", &am
)) < 0)
318 return unit_add_two_dependencies(tu
, UNIT_AFTER
, UNIT_WANTS
, UNIT(am
), true);
321 /* Automatically add mount points that aren't natively
322 * configured to local-fs.target */
327 m
->meta
.manager
->running_as
== MANAGER_SYSTEM
)
328 if ((r
= unit_add_dependency(tu
, UNIT_WANTS
, UNIT(m
), true)) < 0)
331 return unit_add_dependency(UNIT(m
), UNIT_BEFORE
, tu
, true);
335 static bool mount_is_bind(MountParameters
*p
) {
338 if (p
->fstype
&& streq(p
->fstype
, "bind"))
341 if (mount_test_option(p
->options
, "bind"))
347 static int mount_add_device_links(Mount
*m
) {
353 if (m
->from_fragment
)
354 p
= &m
->parameters_fragment
;
355 else if (m
->from_etc_fstab
)
356 p
= &m
->parameters_etc_fstab
;
363 if (!mount_is_bind(p
) && !path_equal(m
->where
, "/")) {
366 noauto
= !!mount_test_option(p
->options
, MNTOPT_NOAUTO
);
367 nofail
= !!mount_test_option(p
->options
, "nofail");
369 if ((r
= unit_add_node_link(UNIT(m
), p
->what
,
371 UNIT(m
)->meta
.manager
->running_as
== MANAGER_SYSTEM
)) < 0)
377 UNIT(m
)->meta
.manager
->running_as
== MANAGER_SYSTEM
&&
378 !path_equal(m
->where
, "/")) {
381 /* Let's add in the fsck service */
383 /* aka SPECIAL_FSCK_SERVICE */
384 if (!(name
= unit_name_from_path_instance("fsck", p
->what
, ".service")))
387 if ((r
= manager_load_unit_prepare(m
->meta
.manager
, name
, NULL
, NULL
, &fsck
)) < 0) {
388 log_warning("Failed to prepare unit %s: %s", name
, strerror(-r
));
395 SERVICE(fsck
)->fsck_passno
= p
->passno
;
397 if ((r
= unit_add_two_dependencies(UNIT(m
), UNIT_AFTER
, UNIT_REQUIRES
, fsck
, true)) < 0)
404 static int mount_add_default_dependencies(Mount
*m
) {
409 if (m
->meta
.manager
->running_as
== MANAGER_SYSTEM
&&
410 !path_equal(m
->where
, "/")) {
412 if ((r
= unit_add_dependency_by_name(UNIT(m
), UNIT_BEFORE
, SPECIAL_QUOTACHECK_SERVICE
, NULL
, true)) < 0)
415 if ((r
= unit_add_two_dependencies_by_name(UNIT(m
), UNIT_BEFORE
, UNIT_CONFLICTS
, SPECIAL_UMOUNT_TARGET
, NULL
, true)) < 0)
422 static int mount_verify(Mount
*m
) {
427 if (m
->meta
.load_state
!= UNIT_LOADED
)
430 if (!m
->from_etc_fstab
&& !m
->from_fragment
&& !m
->from_proc_self_mountinfo
)
433 if (!(e
= unit_name_from_path(m
->where
, ".mount")))
436 b
= unit_has_name(UNIT(m
), e
);
440 log_error("%s's Where setting doesn't match unit name. Refusing.", m
->meta
.id
);
444 if (m
->meta
.fragment_path
&& !m
->parameters_fragment
.what
) {
445 log_error("%s's What setting is missing. Refusing.", m
->meta
.id
);
449 if (m
->exec_context
.pam_name
&& m
->exec_context
.kill_mode
!= KILL_CONTROL_GROUP
) {
450 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", m
->meta
.id
);
457 static int mount_load(Unit
*u
) {
462 assert(u
->meta
.load_state
== UNIT_STUB
);
464 if ((r
= unit_load_fragment_and_dropin_optional(u
)) < 0)
467 /* This is a new unit? Then let's add in some extras */
468 if (u
->meta
.load_state
== UNIT_LOADED
) {
469 if ((r
= unit_add_exec_dependencies(u
, &m
->exec_context
)) < 0)
472 if (m
->meta
.fragment_path
)
473 m
->from_fragment
= true;
476 if (!(m
->where
= unit_name_to_path(u
->meta
.id
)))
479 path_kill_slashes(m
->where
);
481 if (!m
->meta
.description
)
482 if ((r
= unit_set_description(u
, m
->where
)) < 0)
485 if ((r
= mount_add_device_links(m
)) < 0)
488 if ((r
= mount_add_mount_links(m
)) < 0)
491 if ((r
= mount_add_socket_links(m
)) < 0)
494 if ((r
= mount_add_swap_links(m
)) < 0)
497 if ((r
= mount_add_path_links(m
)) < 0)
500 if ((r
= mount_add_automount_links(m
)) < 0)
503 if ((r
= mount_add_target_links(m
)) < 0)
506 if ((r
= unit_add_default_cgroups(u
)) < 0)
509 if (m
->meta
.default_dependencies
)
510 if ((r
= mount_add_default_dependencies(m
)) < 0)
514 return mount_verify(m
);
517 static int mount_notify_automount(Mount
*m
, int status
) {
523 if ((r
= unit_get_related_unit(UNIT(m
), ".automount", &p
)) < 0)
524 return r
== -ENOENT
? 0 : r
;
526 return automount_send_ready(AUTOMOUNT(p
), status
);
529 static void mount_set_state(Mount
*m
, MountState state
) {
530 MountState old_state
;
533 old_state
= m
->state
;
536 if (state
!= MOUNT_MOUNTING
&&
537 state
!= MOUNT_MOUNTING_DONE
&&
538 state
!= MOUNT_REMOUNTING
&&
539 state
!= MOUNT_UNMOUNTING
&&
540 state
!= MOUNT_MOUNTING_SIGTERM
&&
541 state
!= MOUNT_MOUNTING_SIGKILL
&&
542 state
!= MOUNT_UNMOUNTING_SIGTERM
&&
543 state
!= MOUNT_UNMOUNTING_SIGKILL
&&
544 state
!= MOUNT_REMOUNTING_SIGTERM
&&
545 state
!= MOUNT_REMOUNTING_SIGKILL
) {
546 unit_unwatch_timer(UNIT(m
), &m
->timer_watch
);
547 mount_unwatch_control_pid(m
);
548 m
->control_command
= NULL
;
549 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
552 if (state
== MOUNT_MOUNTED
||
553 state
== MOUNT_REMOUNTING
)
554 mount_notify_automount(m
, 0);
555 else if (state
== MOUNT_DEAD
||
556 state
== MOUNT_UNMOUNTING
||
557 state
== MOUNT_MOUNTING_SIGTERM
||
558 state
== MOUNT_MOUNTING_SIGKILL
||
559 state
== MOUNT_REMOUNTING_SIGTERM
||
560 state
== MOUNT_REMOUNTING_SIGKILL
||
561 state
== MOUNT_UNMOUNTING_SIGTERM
||
562 state
== MOUNT_UNMOUNTING_SIGKILL
||
563 state
== MOUNT_FAILED
)
564 mount_notify_automount(m
, -ENODEV
);
566 if (state
!= old_state
)
567 log_debug("%s changed %s -> %s",
569 mount_state_to_string(old_state
),
570 mount_state_to_string(state
));
572 unit_notify(UNIT(m
), state_translation_table
[old_state
], state_translation_table
[state
], !m
->reload_failure
);
573 m
->reload_failure
= false;
576 static int mount_coldplug(Unit
*u
) {
578 MountState new_state
= MOUNT_DEAD
;
582 assert(m
->state
== MOUNT_DEAD
);
584 if (m
->deserialized_state
!= m
->state
)
585 new_state
= m
->deserialized_state
;
586 else if (m
->from_proc_self_mountinfo
)
587 new_state
= MOUNT_MOUNTED
;
589 if (new_state
!= m
->state
) {
591 if (new_state
== MOUNT_MOUNTING
||
592 new_state
== MOUNT_MOUNTING_DONE
||
593 new_state
== MOUNT_REMOUNTING
||
594 new_state
== MOUNT_UNMOUNTING
||
595 new_state
== MOUNT_MOUNTING_SIGTERM
||
596 new_state
== MOUNT_MOUNTING_SIGKILL
||
597 new_state
== MOUNT_UNMOUNTING_SIGTERM
||
598 new_state
== MOUNT_UNMOUNTING_SIGKILL
||
599 new_state
== MOUNT_REMOUNTING_SIGTERM
||
600 new_state
== MOUNT_REMOUNTING_SIGKILL
) {
602 if (m
->control_pid
<= 0)
605 if ((r
= unit_watch_pid(UNIT(m
), m
->control_pid
)) < 0)
608 if ((r
= unit_watch_timer(UNIT(m
), m
->timeout_usec
, &m
->timer_watch
)) < 0)
612 mount_set_state(m
, new_state
);
618 static void mount_dump(Unit
*u
, FILE *f
, const char *prefix
) {
625 if (m
->from_proc_self_mountinfo
)
626 p
= &m
->parameters_proc_self_mountinfo
;
627 else if (m
->from_fragment
)
628 p
= &m
->parameters_fragment
;
630 p
= &m
->parameters_etc_fstab
;
633 "%sMount State: %s\n"
636 "%sFile System Type: %s\n"
638 "%sFrom /etc/fstab: %s\n"
639 "%sFrom /proc/self/mountinfo: %s\n"
640 "%sFrom fragment: %s\n"
641 "%sDirectoryMode: %04o\n",
642 prefix
, mount_state_to_string(m
->state
),
644 prefix
, strna(p
->what
),
645 prefix
, strna(p
->fstype
),
646 prefix
, strna(p
->options
),
647 prefix
, yes_no(m
->from_etc_fstab
),
648 prefix
, yes_no(m
->from_proc_self_mountinfo
),
649 prefix
, yes_no(m
->from_fragment
),
650 prefix
, m
->directory_mode
);
652 if (m
->control_pid
> 0)
654 "%sControl PID: %lu\n",
655 prefix
, (unsigned long) m
->control_pid
);
657 exec_context_dump(&m
->exec_context
, f
, prefix
);
660 static int mount_spawn(Mount
*m
, ExecCommand
*c
, pid_t
*_pid
) {
668 if ((r
= unit_watch_timer(UNIT(m
), m
->timeout_usec
, &m
->timer_watch
)) < 0)
671 if ((r
= exec_spawn(c
,
675 m
->meta
.manager
->environment
,
679 m
->meta
.manager
->confirm_spawn
,
680 m
->meta
.cgroup_bondings
,
684 if ((r
= unit_watch_pid(UNIT(m
), pid
)) < 0)
685 /* FIXME: we need to do something here */
693 unit_unwatch_timer(UNIT(m
), &m
->timer_watch
);
698 static void mount_enter_dead(Mount
*m
, bool success
) {
704 mount_set_state(m
, m
->failure
? MOUNT_FAILED
: MOUNT_DEAD
);
707 static void mount_enter_mounted(Mount
*m
, bool success
) {
713 mount_set_state(m
, MOUNT_MOUNTED
);
716 static void mount_enter_signal(Mount
*m
, MountState state
, bool success
) {
719 bool wait_for_exit
= false;
726 if (m
->exec_context
.kill_mode
!= KILL_NONE
) {
727 int sig
= (state
== MOUNT_MOUNTING_SIGTERM
||
728 state
== MOUNT_UNMOUNTING_SIGTERM
||
729 state
== MOUNT_REMOUNTING_SIGTERM
) ? m
->exec_context
.kill_signal
: SIGKILL
;
731 if (m
->control_pid
> 0) {
732 if (kill_and_sigcont(m
->exec_context
.kill_mode
== KILL_PROCESS_GROUP
?
734 m
->control_pid
, sig
) < 0 && errno
!= ESRCH
)
736 log_warning("Failed to kill control process %li: %m", (long) m
->control_pid
);
738 wait_for_exit
= true;
741 if (m
->exec_context
.kill_mode
== KILL_CONTROL_GROUP
) {
743 if (!(pid_set
= set_new(trivial_hash_func
, trivial_compare_func
))) {
748 /* Exclude the control pid from being killed via the cgroup */
749 if (m
->control_pid
> 0)
750 if ((r
= set_put(pid_set
, LONG_TO_PTR(m
->control_pid
))) < 0)
753 if ((r
= cgroup_bonding_kill_list(m
->meta
.cgroup_bondings
, sig
, true, pid_set
)) < 0) {
754 if (r
!= -EAGAIN
&& r
!= -ESRCH
&& r
!= -ENOENT
)
755 log_warning("Failed to kill control group: %s", strerror(-r
));
757 wait_for_exit
= true;
764 if ((r
= unit_watch_timer(UNIT(m
), m
->timeout_usec
, &m
->timer_watch
)) < 0)
767 mount_set_state(m
, state
);
768 } else if (state
== MOUNT_REMOUNTING_SIGTERM
|| state
== MOUNT_REMOUNTING_SIGKILL
)
769 mount_enter_mounted(m
, true);
771 mount_enter_dead(m
, true);
776 log_warning("%s failed to kill processes: %s", m
->meta
.id
, strerror(-r
));
778 if (state
== MOUNT_REMOUNTING_SIGTERM
|| state
== MOUNT_REMOUNTING_SIGKILL
)
779 mount_enter_mounted(m
, false);
781 mount_enter_dead(m
, false);
787 static void mount_enter_unmounting(Mount
*m
, bool success
) {
795 m
->control_command_id
= MOUNT_EXEC_UNMOUNT
;
796 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_UNMOUNT
;
798 if ((r
= exec_command_set(
805 mount_unwatch_control_pid(m
);
807 if ((r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
)) < 0)
810 mount_set_state(m
, MOUNT_UNMOUNTING
);
815 log_warning("%s failed to run 'umount' task: %s", m
->meta
.id
, strerror(-r
));
816 mount_enter_mounted(m
, false);
819 static void mount_enter_mounting(Mount
*m
) {
824 m
->control_command_id
= MOUNT_EXEC_MOUNT
;
825 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_MOUNT
;
827 mkdir_p(m
->where
, m
->directory_mode
);
829 if (m
->from_fragment
)
830 r
= exec_command_set(
833 m
->parameters_fragment
.what
,
835 "-t", m
->parameters_fragment
.fstype
? m
->parameters_fragment
.fstype
: "auto",
836 m
->parameters_fragment
.options
? "-o" : NULL
, m
->parameters_fragment
.options
,
838 else if (m
->from_etc_fstab
)
839 r
= exec_command_set(
850 mount_unwatch_control_pid(m
);
852 if ((r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
)) < 0)
855 mount_set_state(m
, MOUNT_MOUNTING
);
860 log_warning("%s failed to run 'mount' task: %s", m
->meta
.id
, strerror(-r
));
861 mount_enter_dead(m
, false);
864 static void mount_enter_mounting_done(Mount
*m
) {
867 mount_set_state(m
, MOUNT_MOUNTING_DONE
);
870 static void mount_enter_remounting(Mount
*m
, bool success
) {
878 m
->control_command_id
= MOUNT_EXEC_REMOUNT
;
879 m
->control_command
= m
->exec_command
+ MOUNT_EXEC_REMOUNT
;
881 if (m
->from_fragment
) {
885 if (m
->parameters_fragment
.options
) {
886 if (!(buf
= strappend("remount,", m
->parameters_fragment
.options
))) {
895 r
= exec_command_set(
898 m
->parameters_fragment
.what
,
900 "-t", m
->parameters_fragment
.fstype
? m
->parameters_fragment
.fstype
: "auto",
905 } else if (m
->from_etc_fstab
)
906 r
= exec_command_set(
918 mount_unwatch_control_pid(m
);
920 if ((r
= mount_spawn(m
, m
->control_command
, &m
->control_pid
)) < 0)
923 mount_set_state(m
, MOUNT_REMOUNTING
);
928 log_warning("%s failed to run 'remount' task: %s", m
->meta
.id
, strerror(-r
));
929 m
->reload_failure
= true;
930 mount_enter_mounted(m
, true);
933 static int mount_start(Unit
*u
) {
938 /* We cannot fulfill this request right now, try again later
940 if (m
->state
== MOUNT_UNMOUNTING
||
941 m
->state
== MOUNT_UNMOUNTING_SIGTERM
||
942 m
->state
== MOUNT_UNMOUNTING_SIGKILL
||
943 m
->state
== MOUNT_MOUNTING_SIGTERM
||
944 m
->state
== MOUNT_MOUNTING_SIGKILL
)
948 if (m
->state
== MOUNT_MOUNTING
)
951 assert(m
->state
== MOUNT_DEAD
|| m
->state
== MOUNT_FAILED
);
954 mount_enter_mounting(m
);
958 static int mount_stop(Unit
*u
) {
964 if (m
->state
== MOUNT_UNMOUNTING
||
965 m
->state
== MOUNT_UNMOUNTING_SIGKILL
||
966 m
->state
== MOUNT_UNMOUNTING_SIGTERM
||
967 m
->state
== MOUNT_MOUNTING_SIGTERM
||
968 m
->state
== MOUNT_MOUNTING_SIGKILL
)
971 assert(m
->state
== MOUNT_MOUNTING
||
972 m
->state
== MOUNT_MOUNTING_DONE
||
973 m
->state
== MOUNT_MOUNTED
||
974 m
->state
== MOUNT_REMOUNTING
||
975 m
->state
== MOUNT_REMOUNTING_SIGTERM
||
976 m
->state
== MOUNT_REMOUNTING_SIGKILL
);
978 mount_enter_unmounting(m
, true);
982 static int mount_reload(Unit
*u
) {
987 if (m
->state
== MOUNT_MOUNTING_DONE
)
990 assert(m
->state
== MOUNT_MOUNTED
);
992 mount_enter_remounting(m
, true);
996 static int mount_serialize(Unit
*u
, FILE *f
, FDSet
*fds
) {
1003 unit_serialize_item(u
, f
, "state", mount_state_to_string(m
->state
));
1004 unit_serialize_item(u
, f
, "failure", yes_no(m
->failure
));
1006 if (m
->control_pid
> 0)
1007 unit_serialize_item_format(u
, f
, "control-pid", "%lu", (unsigned long) m
->control_pid
);
1009 if (m
->control_command_id
>= 0)
1010 unit_serialize_item(u
, f
, "control-command", mount_exec_command_to_string(m
->control_command_id
));
1015 static int mount_deserialize_item(Unit
*u
, const char *key
, const char *value
, FDSet
*fds
) {
1016 Mount
*m
= MOUNT(u
);
1023 if (streq(key
, "state")) {
1026 if ((state
= mount_state_from_string(value
)) < 0)
1027 log_debug("Failed to parse state value %s", value
);
1029 m
->deserialized_state
= state
;
1030 } else if (streq(key
, "failure")) {
1033 if ((b
= parse_boolean(value
)) < 0)
1034 log_debug("Failed to parse failure value %s", value
);
1036 m
->failure
= b
|| m
->failure
;
1038 } else if (streq(key
, "control-pid")) {
1041 if (parse_pid(value
, &pid
) < 0)
1042 log_debug("Failed to parse control-pid value %s", value
);
1044 m
->control_pid
= pid
;
1045 } else if (streq(key
, "control-command")) {
1046 MountExecCommand id
;
1048 if ((id
= mount_exec_command_from_string(value
)) < 0)
1049 log_debug("Failed to parse exec-command value %s", value
);
1051 m
->control_command_id
= id
;
1052 m
->control_command
= m
->exec_command
+ id
;
1056 log_debug("Unknown serialization key '%s'", key
);
1061 static UnitActiveState
mount_active_state(Unit
*u
) {
1064 return state_translation_table
[MOUNT(u
)->state
];
1067 static const char *mount_sub_state_to_string(Unit
*u
) {
1070 return mount_state_to_string(MOUNT(u
)->state
);
1073 static bool mount_check_gc(Unit
*u
) {
1074 Mount
*m
= MOUNT(u
);
1078 return m
->from_etc_fstab
|| m
->from_proc_self_mountinfo
;
1081 static void mount_sigchld_event(Unit
*u
, pid_t pid
, int code
, int status
) {
1082 Mount
*m
= MOUNT(u
);
1088 if (pid
!= m
->control_pid
)
1093 success
= is_clean_exit(code
, status
);
1094 m
->failure
= m
->failure
|| !success
;
1096 if (m
->control_command
) {
1097 exec_status_exit(&m
->control_command
->exec_status
, pid
, code
, status
, m
->exec_context
.utmp_id
);
1098 m
->control_command
= NULL
;
1099 m
->control_command_id
= _MOUNT_EXEC_COMMAND_INVALID
;
1102 log_full(success
? LOG_DEBUG
: LOG_NOTICE
,
1103 "%s mount process exited, code=%s status=%i", u
->meta
.id
, sigchld_code_to_string(code
), status
);
1105 /* Note that mount(8) returning and the kernel sending us a
1106 * mount table change event might happen out-of-order. If an
1107 * operation succeed we assume the kernel will follow soon too
1108 * and already change into the resulting state. If it fails
1109 * we check if the kernel still knows about the mount. and
1110 * change state accordingly. */
1114 case MOUNT_MOUNTING
:
1115 case MOUNT_MOUNTING_DONE
:
1116 case MOUNT_MOUNTING_SIGKILL
:
1117 case MOUNT_MOUNTING_SIGTERM
:
1120 mount_enter_mounted(m
, true);
1121 else if (m
->from_proc_self_mountinfo
)
1122 mount_enter_mounted(m
, false);
1124 mount_enter_dead(m
, false);
1127 case MOUNT_REMOUNTING
:
1128 case MOUNT_REMOUNTING_SIGKILL
:
1129 case MOUNT_REMOUNTING_SIGTERM
:
1131 m
->reload_failure
= !success
;
1132 if (m
->from_proc_self_mountinfo
)
1133 mount_enter_mounted(m
, true);
1135 mount_enter_dead(m
, true);
1139 case MOUNT_UNMOUNTING
:
1140 case MOUNT_UNMOUNTING_SIGKILL
:
1141 case MOUNT_UNMOUNTING_SIGTERM
:
1144 mount_enter_dead(m
, true);
1145 else if (m
->from_proc_self_mountinfo
)
1146 mount_enter_mounted(m
, false);
1148 mount_enter_dead(m
, false);
1152 assert_not_reached("Uh, control process died at wrong time.");
1155 /* Notify clients about changed exit status */
1156 unit_add_to_dbus_queue(u
);
1159 static void mount_timer_event(Unit
*u
, uint64_t elapsed
, Watch
*w
) {
1160 Mount
*m
= MOUNT(u
);
1163 assert(elapsed
== 1);
1164 assert(w
== &m
->timer_watch
);
1168 case MOUNT_MOUNTING
:
1169 case MOUNT_MOUNTING_DONE
:
1170 log_warning("%s mounting timed out. Stopping.", u
->meta
.id
);
1171 mount_enter_signal(m
, MOUNT_MOUNTING_SIGTERM
, false);
1174 case MOUNT_REMOUNTING
:
1175 log_warning("%s remounting timed out. Stopping.", u
->meta
.id
);
1176 m
->reload_failure
= true;
1177 mount_enter_mounted(m
, true);
1180 case MOUNT_UNMOUNTING
:
1181 log_warning("%s unmounting timed out. Stopping.", u
->meta
.id
);
1182 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGTERM
, false);
1185 case MOUNT_MOUNTING_SIGTERM
:
1186 if (m
->exec_context
.send_sigkill
) {
1187 log_warning("%s mounting timed out. Killing.", u
->meta
.id
);
1188 mount_enter_signal(m
, MOUNT_MOUNTING_SIGKILL
, false);
1190 log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u
->meta
.id
);
1192 if (m
->from_proc_self_mountinfo
)
1193 mount_enter_mounted(m
, false);
1195 mount_enter_dead(m
, false);
1199 case MOUNT_REMOUNTING_SIGTERM
:
1200 if (m
->exec_context
.send_sigkill
) {
1201 log_warning("%s remounting timed out. Killing.", u
->meta
.id
);
1202 mount_enter_signal(m
, MOUNT_REMOUNTING_SIGKILL
, false);
1204 log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u
->meta
.id
);
1206 if (m
->from_proc_self_mountinfo
)
1207 mount_enter_mounted(m
, false);
1209 mount_enter_dead(m
, false);
1213 case MOUNT_UNMOUNTING_SIGTERM
:
1214 if (m
->exec_context
.send_sigkill
) {
1215 log_warning("%s unmounting timed out. Killing.", u
->meta
.id
);
1216 mount_enter_signal(m
, MOUNT_UNMOUNTING_SIGKILL
, false);
1218 log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u
->meta
.id
);
1220 if (m
->from_proc_self_mountinfo
)
1221 mount_enter_mounted(m
, false);
1223 mount_enter_dead(m
, false);
1227 case MOUNT_MOUNTING_SIGKILL
:
1228 case MOUNT_REMOUNTING_SIGKILL
:
1229 case MOUNT_UNMOUNTING_SIGKILL
:
1230 log_warning("%s mount process still around after SIGKILL. Ignoring.", u
->meta
.id
);
1232 if (m
->from_proc_self_mountinfo
)
1233 mount_enter_mounted(m
, false);
1235 mount_enter_dead(m
, false);
1239 assert_not_reached("Timeout at wrong time.");
1243 static int mount_add_one(
1247 const char *options
,
1250 bool from_proc_self_mountinfo
,
1255 char *e
, *w
= NULL
, *o
= NULL
, *f
= NULL
;
1264 assert(!set_flags
|| from_proc_self_mountinfo
);
1266 /* Ignore API mount points. They should never be referenced in
1267 * dependencies ever. */
1268 if (mount_point_is_api(where
))
1270 if (mount_point_ignore(where
))
1273 if (streq(fstype
, "autofs"))
1276 /* probably some kind of swap, ignore */
1277 if (!is_path(where
))
1280 if (!(e
= unit_name_from_path(where
, ".mount")))
1283 if (!(u
= manager_get_unit(m
, e
))) {
1286 if (!(u
= unit_new(m
))) {
1291 r
= unit_add_name(u
, e
);
1297 if (!(MOUNT(u
)->where
= strdup(where
))) {
1302 unit_add_to_load_queue(u
);
1308 if (!(w
= strdup(what
)) ||
1309 !(o
= strdup(options
)) ||
1310 !(f
= strdup(fstype
))) {
1315 if (from_proc_self_mountinfo
) {
1316 p
= &MOUNT(u
)->parameters_proc_self_mountinfo
;
1319 MOUNT(u
)->is_mounted
= true;
1320 MOUNT(u
)->just_mounted
= !MOUNT(u
)->from_proc_self_mountinfo
;
1321 MOUNT(u
)->just_changed
= !streq_ptr(p
->options
, o
);
1324 MOUNT(u
)->from_proc_self_mountinfo
= true;
1326 p
= &MOUNT(u
)->parameters_etc_fstab
;
1327 MOUNT(u
)->from_etc_fstab
= true;
1341 unit_add_to_dbus_queue(u
);
1356 static int mount_find_pri(char *options
) {
1360 if (!(pri
= mount_test_option(options
, "pri=")))
1366 r
= strtoul(pri
, &end
, 10);
1371 if (end
== pri
|| (*end
!= ',' && *end
!= 0))
1377 static int mount_load_etc_fstab(Manager
*m
) {
1385 if (!(f
= setmntent("/etc/fstab", "r")))
1388 while ((me
= getmntent(f
))) {
1392 if (!(what
= fstab_node_to_udev_node(me
->mnt_fsname
))) {
1397 if (!(where
= strdup(me
->mnt_dir
))) {
1404 path_kill_slashes(what
);
1406 if (where
[0] == '/')
1407 path_kill_slashes(where
);
1409 if (streq(me
->mnt_type
, "swap")) {
1412 if ((pri
= mount_find_pri(me
->mnt_opts
)) < 0)
1419 !!mount_test_option(me
->mnt_opts
, MNTOPT_NOAUTO
),
1420 !!mount_test_option(me
->mnt_opts
, "nofail"),
1421 !!mount_test_option(me
->mnt_opts
, "comment=systemd.swapon"),
1424 k
= mount_add_one(m
, what
, where
, me
->mnt_opts
, me
->mnt_type
, me
->mnt_passno
, false, false);
1439 static int mount_load_proc_self_mountinfo(Manager
*m
, bool set_flags
) {
1442 char *device
, *path
, *options
, *options2
, *fstype
, *d
, *p
, *o
;
1446 rewind(m
->proc_self_mountinfo
);
1451 device
= path
= options
= options2
= fstype
= d
= p
= o
= NULL
;
1453 if ((k
= fscanf(m
->proc_self_mountinfo
,
1454 "%*s " /* (1) mount id */
1455 "%*s " /* (2) parent id */
1456 "%*s " /* (3) major:minor */
1457 "%*s " /* (4) root */
1458 "%ms " /* (5) mount point */
1459 "%ms" /* (6) mount options */
1460 "%*[^-]" /* (7) optional fields */
1461 "- " /* (8) separator */
1462 "%ms " /* (9) file system type */
1463 "%ms" /* (10) mount source */
1464 "%ms" /* (11) mount options 2 */
1465 "%*[^\n]", /* some rubbish at the end */
1475 log_warning("Failed to parse /proc/self/mountinfo:%u.", i
);
1479 if (asprintf(&o
, "%s,%s", options
, options2
) < 0) {
1484 if (!(d
= cunescape(device
)) ||
1485 !(p
= cunescape(path
))) {
1490 if ((k
= mount_add_one(m
, d
, p
, o
, fstype
, 0, true, set_flags
)) < 0)
1517 static void mount_shutdown(Manager
*m
) {
1520 if (m
->proc_self_mountinfo
) {
1521 fclose(m
->proc_self_mountinfo
);
1522 m
->proc_self_mountinfo
= NULL
;
1526 static int mount_enumerate(Manager
*m
) {
1528 struct epoll_event ev
;
1531 if (!m
->proc_self_mountinfo
) {
1532 if (!(m
->proc_self_mountinfo
= fopen("/proc/self/mountinfo", "re")))
1535 m
->mount_watch
.type
= WATCH_MOUNT
;
1536 m
->mount_watch
.fd
= fileno(m
->proc_self_mountinfo
);
1539 ev
.events
= EPOLLPRI
;
1540 ev
.data
.ptr
= &m
->mount_watch
;
1542 if (epoll_ctl(m
->epoll_fd
, EPOLL_CTL_ADD
, m
->mount_watch
.fd
, &ev
) < 0)
1546 if ((r
= mount_load_etc_fstab(m
)) < 0)
1549 if ((r
= mount_load_proc_self_mountinfo(m
, false)) < 0)
1559 void mount_fd_event(Manager
*m
, int events
) {
1564 assert(events
& EPOLLPRI
);
1566 /* The manager calls this for every fd event happening on the
1567 * /proc/self/mountinfo file, which informs us about mounting
1570 if ((r
= mount_load_proc_self_mountinfo(m
, true)) < 0) {
1571 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r
));
1573 /* Reset flags, just in case, for later calls */
1574 LIST_FOREACH(units_per_type
, meta
, m
->units_per_type
[UNIT_MOUNT
]) {
1575 Mount
*mount
= (Mount
*) meta
;
1577 mount
->is_mounted
= mount
->just_mounted
= mount
->just_changed
= false;
1583 manager_dispatch_load_queue(m
);
1585 LIST_FOREACH(units_per_type
, meta
, m
->units_per_type
[UNIT_MOUNT
]) {
1586 Mount
*mount
= (Mount
*) meta
;
1588 if (!mount
->is_mounted
) {
1589 /* This has just been unmounted. */
1591 mount
->from_proc_self_mountinfo
= false;
1593 switch (mount
->state
) {
1596 mount_enter_dead(mount
, true);
1600 mount_set_state(mount
, mount
->state
);
1605 } else if (mount
->just_mounted
|| mount
->just_changed
) {
1607 /* New or changed mount entry */
1609 switch (mount
->state
) {
1613 mount_enter_mounted(mount
, true);
1616 case MOUNT_MOUNTING
:
1617 mount_enter_mounting_done(mount
);
1621 /* Nothing really changed, but let's
1622 * issue an notification call
1623 * nonetheless, in case somebody is
1624 * waiting for this. (e.g. file system
1625 * ro/rw remounts.) */
1626 mount_set_state(mount
, mount
->state
);
1631 /* Reset the flags for later calls */
1632 mount
->is_mounted
= mount
->just_mounted
= mount
->just_changed
= false;
1636 static void mount_reset_failed(Unit
*u
) {
1637 Mount
*m
= MOUNT(u
);
1641 if (m
->state
== MOUNT_FAILED
)
1642 mount_set_state(m
, MOUNT_DEAD
);
1647 static int mount_kill(Unit
*u
, KillWho who
, KillMode mode
, int signo
, DBusError
*error
) {
1648 Mount
*m
= MOUNT(u
);
1650 Set
*pid_set
= NULL
;
1654 if (who
== KILL_MAIN
) {
1655 dbus_set_error(error
, BUS_ERROR_NO_SUCH_PROCESS
, "Mount units have no main processes");
1659 if (m
->control_pid
<= 0 && who
== KILL_CONTROL
) {
1660 dbus_set_error(error
, BUS_ERROR_NO_SUCH_PROCESS
, "No control process to kill");
1664 if (m
->control_pid
> 0)
1665 if (kill(mode
== KILL_PROCESS_GROUP
? -m
->control_pid
: m
->control_pid
, signo
) < 0)
1668 if (mode
== KILL_CONTROL_GROUP
) {
1671 if (!(pid_set
= set_new(trivial_hash_func
, trivial_compare_func
)))
1674 /* Exclude the control pid from being killed via the cgroup */
1675 if (m
->control_pid
> 0)
1676 if ((q
= set_put(pid_set
, LONG_TO_PTR(m
->control_pid
))) < 0) {
1681 if ((q
= cgroup_bonding_kill_list(m
->meta
.cgroup_bondings
, signo
, false, pid_set
)) < 0)
1682 if (r
!= -EAGAIN
&& r
!= -ESRCH
&& r
!= -ENOENT
)
1693 static const char* const mount_state_table
[_MOUNT_STATE_MAX
] = {
1694 [MOUNT_DEAD
] = "dead",
1695 [MOUNT_MOUNTING
] = "mounting",
1696 [MOUNT_MOUNTING_DONE
] = "mounting-done",
1697 [MOUNT_MOUNTED
] = "mounted",
1698 [MOUNT_REMOUNTING
] = "remounting",
1699 [MOUNT_UNMOUNTING
] = "unmounting",
1700 [MOUNT_MOUNTING_SIGTERM
] = "mounting-sigterm",
1701 [MOUNT_MOUNTING_SIGKILL
] = "mounting-sigkill",
1702 [MOUNT_REMOUNTING_SIGTERM
] = "remounting-sigterm",
1703 [MOUNT_REMOUNTING_SIGKILL
] = "remounting-sigkill",
1704 [MOUNT_UNMOUNTING_SIGTERM
] = "unmounting-sigterm",
1705 [MOUNT_UNMOUNTING_SIGKILL
] = "unmounting-sigkill",
1706 [MOUNT_FAILED
] = "failed"
1709 DEFINE_STRING_TABLE_LOOKUP(mount_state
, MountState
);
1711 static const char* const mount_exec_command_table
[_MOUNT_EXEC_COMMAND_MAX
] = {
1712 [MOUNT_EXEC_MOUNT
] = "ExecMount",
1713 [MOUNT_EXEC_UNMOUNT
] = "ExecUnmount",
1714 [MOUNT_EXEC_REMOUNT
] = "ExecRemount",
1717 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command
, MountExecCommand
);
1719 const UnitVTable mount_vtable
= {
1723 .no_instances
= true,
1725 .show_status
= true,
1731 .coldplug
= mount_coldplug
,
1735 .start
= mount_start
,
1737 .reload
= mount_reload
,
1741 .serialize
= mount_serialize
,
1742 .deserialize_item
= mount_deserialize_item
,
1744 .active_state
= mount_active_state
,
1745 .sub_state_to_string
= mount_sub_state_to_string
,
1747 .check_gc
= mount_check_gc
,
1749 .sigchld_event
= mount_sigchld_event
,
1750 .timer_event
= mount_timer_event
,
1752 .reset_failed
= mount_reset_failed
,
1754 .bus_interface
= "org.freedesktop.systemd1.Mount",
1755 .bus_message_handler
= bus_mount_message_handler
,
1756 .bus_invalidating_properties
= bus_mount_invalidating_properties
,
1758 .enumerate
= mount_enumerate
,
1759 .shutdown
= mount_shutdown