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_add_extras(Mount *m) {
544 r = unit_add_exec_dependencies(u, &m->exec_context);
548 if (UNIT(m)->fragment_path)
549 m->from_fragment = true;
552 m->where = unit_name_to_path(u->id);
557 path_kill_slashes(m->where);
559 if (!UNIT(m)->description) {
560 r = unit_set_description(u, m->where);
565 r = mount_add_device_links(m);
569 r = mount_add_mount_links(m);
573 r = mount_add_socket_links(m);
577 r = mount_add_swap_links(m);
581 r = mount_add_path_links(m);
585 r = mount_add_requires_mounts_links(m);
589 r = mount_add_automount_links(m);
593 r = mount_add_quota_links(m);
597 if (UNIT(m)->default_dependencies) {
598 r = mount_add_default_dependencies(m);
603 r = unit_add_default_cgroups(u);
607 r = mount_fix_timeouts(m);
614 static int mount_load(Unit *u) {
619 assert(u->load_state == UNIT_STUB);
621 if (m->from_proc_self_mountinfo)
622 r = unit_load_fragment_and_dropin_optional(u);
624 r = unit_load_fragment_and_dropin(u);
629 /* This is a new unit? Then let's add in some extras */
630 if (u->load_state == UNIT_LOADED) {
631 r = mount_add_extras(m);
636 return mount_verify(m);
639 static int mount_notify_automount(Mount *m, int status) {
646 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
647 if (p->type == UNIT_AUTOMOUNT) {
648 r = automount_send_ready(AUTOMOUNT(p), status);
656 static void mount_set_state(Mount *m, MountState state) {
657 MountState old_state;
660 old_state = m->state;
663 if (state != MOUNT_MOUNTING &&
664 state != MOUNT_MOUNTING_DONE &&
665 state != MOUNT_REMOUNTING &&
666 state != MOUNT_UNMOUNTING &&
667 state != MOUNT_MOUNTING_SIGTERM &&
668 state != MOUNT_MOUNTING_SIGKILL &&
669 state != MOUNT_UNMOUNTING_SIGTERM &&
670 state != MOUNT_UNMOUNTING_SIGKILL &&
671 state != MOUNT_REMOUNTING_SIGTERM &&
672 state != MOUNT_REMOUNTING_SIGKILL) {
673 unit_unwatch_timer(UNIT(m), &m->timer_watch);
674 mount_unwatch_control_pid(m);
675 m->control_command = NULL;
676 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
679 if (state == MOUNT_MOUNTED ||
680 state == MOUNT_REMOUNTING)
681 mount_notify_automount(m, 0);
682 else if (state == MOUNT_DEAD ||
683 state == MOUNT_UNMOUNTING ||
684 state == MOUNT_MOUNTING_SIGTERM ||
685 state == MOUNT_MOUNTING_SIGKILL ||
686 state == MOUNT_REMOUNTING_SIGTERM ||
687 state == MOUNT_REMOUNTING_SIGKILL ||
688 state == MOUNT_UNMOUNTING_SIGTERM ||
689 state == MOUNT_UNMOUNTING_SIGKILL ||
690 state == MOUNT_FAILED)
691 mount_notify_automount(m, -ENODEV);
693 if (state != old_state)
694 log_debug("%s changed %s -> %s",
696 mount_state_to_string(old_state),
697 mount_state_to_string(state));
699 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
700 m->reload_result = MOUNT_SUCCESS;
703 static int mount_coldplug(Unit *u) {
705 MountState new_state = MOUNT_DEAD;
709 assert(m->state == MOUNT_DEAD);
711 if (m->deserialized_state != m->state)
712 new_state = m->deserialized_state;
713 else if (m->from_proc_self_mountinfo)
714 new_state = MOUNT_MOUNTED;
716 if (new_state != m->state) {
718 if (new_state == MOUNT_MOUNTING ||
719 new_state == MOUNT_MOUNTING_DONE ||
720 new_state == MOUNT_REMOUNTING ||
721 new_state == MOUNT_UNMOUNTING ||
722 new_state == MOUNT_MOUNTING_SIGTERM ||
723 new_state == MOUNT_MOUNTING_SIGKILL ||
724 new_state == MOUNT_UNMOUNTING_SIGTERM ||
725 new_state == MOUNT_UNMOUNTING_SIGKILL ||
726 new_state == MOUNT_REMOUNTING_SIGTERM ||
727 new_state == MOUNT_REMOUNTING_SIGKILL) {
729 if (m->control_pid <= 0)
732 if ((r = unit_watch_pid(UNIT(m), m->control_pid)) < 0)
735 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
739 mount_set_state(m, new_state);
745 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
752 p = get_mount_parameters(m);
755 "%sMount State: %s\n"
759 "%sFile System Type: %s\n"
761 "%sFrom /proc/self/mountinfo: %s\n"
762 "%sFrom fragment: %s\n"
763 "%sDirectoryMode: %04o\n",
764 prefix, mount_state_to_string(m->state),
765 prefix, mount_result_to_string(m->result),
767 prefix, strna(p->what),
768 prefix, strna(p->fstype),
769 prefix, strna(p->options),
770 prefix, yes_no(m->from_proc_self_mountinfo),
771 prefix, yes_no(m->from_fragment),
772 prefix, m->directory_mode);
774 if (m->control_pid > 0)
776 "%sControl PID: %lu\n",
777 prefix, (unsigned long) m->control_pid);
779 exec_context_dump(&m->exec_context, f, prefix);
782 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
790 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
793 if ((r = exec_spawn(c,
797 UNIT(m)->manager->environment,
801 UNIT(m)->manager->confirm_spawn,
802 UNIT(m)->cgroup_bondings,
803 UNIT(m)->cgroup_attributes,
810 if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
811 /* FIXME: we need to do something here */
819 unit_unwatch_timer(UNIT(m), &m->timer_watch);
824 static void mount_enter_dead(Mount *m, MountResult f) {
827 if (f != MOUNT_SUCCESS)
830 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
833 static void mount_enter_mounted(Mount *m, MountResult f) {
836 if (f != MOUNT_SUCCESS)
839 mount_set_state(m, MOUNT_MOUNTED);
842 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
845 bool wait_for_exit = false;
849 if (f != MOUNT_SUCCESS)
852 if (m->exec_context.kill_mode != KILL_NONE) {
853 int sig = (state == MOUNT_MOUNTING_SIGTERM ||
854 state == MOUNT_UNMOUNTING_SIGTERM ||
855 state == MOUNT_REMOUNTING_SIGTERM) ? m->exec_context.kill_signal : SIGKILL;
857 if (m->control_pid > 0) {
858 if (kill_and_sigcont(m->control_pid, sig) < 0 && errno != ESRCH)
860 log_warning("Failed to kill control process %li: %m", (long) m->control_pid);
862 wait_for_exit = true;
865 if (m->exec_context.kill_mode == KILL_CONTROL_GROUP) {
867 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
872 /* Exclude the control pid from being killed via the cgroup */
873 if (m->control_pid > 0)
874 if ((r = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0)
877 r = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, sig, true, false, pid_set, NULL);
879 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
880 log_warning("Failed to kill control group: %s", strerror(-r));
882 wait_for_exit = true;
890 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
893 mount_set_state(m, state);
894 } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
895 mount_enter_mounted(m, MOUNT_SUCCESS);
897 mount_enter_dead(m, MOUNT_SUCCESS);
902 log_warning("%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
904 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
905 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
907 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
913 static void mount_enter_unmounting(Mount *m) {
918 m->control_command_id = MOUNT_EXEC_UNMOUNT;
919 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
921 if ((r = exec_command_set(
928 mount_unwatch_control_pid(m);
930 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
933 mount_set_state(m, MOUNT_UNMOUNTING);
938 log_warning("%s failed to run 'umount' task: %s", UNIT(m)->id, strerror(-r));
939 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
942 static void mount_enter_mounting(Mount *m) {
948 m->control_command_id = MOUNT_EXEC_MOUNT;
949 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
951 mkdir_p_label(m->where, m->directory_mode);
953 /* Create the source directory for bind-mounts if needed */
954 p = get_mount_parameters_fragment(m);
955 if (p && mount_is_bind(p))
956 mkdir_p_label(p->what, m->directory_mode);
958 if (m->from_fragment)
959 r = exec_command_set(
962 m->parameters_fragment.what,
964 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
965 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
973 mount_unwatch_control_pid(m);
975 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
978 mount_set_state(m, MOUNT_MOUNTING);
983 log_warning("%s failed to run 'mount' task: %s", UNIT(m)->id, strerror(-r));
984 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
987 static void mount_enter_mounting_done(Mount *m) {
990 mount_set_state(m, MOUNT_MOUNTING_DONE);
993 static void mount_enter_remounting(Mount *m) {
998 m->control_command_id = MOUNT_EXEC_REMOUNT;
999 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1001 if (m->from_fragment) {
1005 if (m->parameters_fragment.options) {
1006 if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
1015 r = exec_command_set(
1018 m->parameters_fragment.what,
1020 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
1031 mount_unwatch_control_pid(m);
1033 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1036 mount_set_state(m, MOUNT_REMOUNTING);
1041 log_warning("%s failed to run 'remount' task: %s", UNIT(m)->id, strerror(-r));
1042 m->reload_result = MOUNT_FAILURE_RESOURCES;
1043 mount_enter_mounted(m, MOUNT_SUCCESS);
1046 static int mount_start(Unit *u) {
1047 Mount *m = MOUNT(u);
1051 /* We cannot fulfill this request right now, try again later
1053 if (m->state == MOUNT_UNMOUNTING ||
1054 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1055 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1056 m->state == MOUNT_MOUNTING_SIGTERM ||
1057 m->state == MOUNT_MOUNTING_SIGKILL)
1060 /* Already on it! */
1061 if (m->state == MOUNT_MOUNTING)
1064 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1066 m->result = MOUNT_SUCCESS;
1067 m->reload_result = MOUNT_SUCCESS;
1069 mount_enter_mounting(m);
1073 static int mount_stop(Unit *u) {
1074 Mount *m = MOUNT(u);
1079 if (m->state == MOUNT_UNMOUNTING ||
1080 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1081 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1082 m->state == MOUNT_MOUNTING_SIGTERM ||
1083 m->state == MOUNT_MOUNTING_SIGKILL)
1086 assert(m->state == MOUNT_MOUNTING ||
1087 m->state == MOUNT_MOUNTING_DONE ||
1088 m->state == MOUNT_MOUNTED ||
1089 m->state == MOUNT_REMOUNTING ||
1090 m->state == MOUNT_REMOUNTING_SIGTERM ||
1091 m->state == MOUNT_REMOUNTING_SIGKILL);
1093 mount_enter_unmounting(m);
1097 static int mount_reload(Unit *u) {
1098 Mount *m = MOUNT(u);
1102 if (m->state == MOUNT_MOUNTING_DONE)
1105 assert(m->state == MOUNT_MOUNTED);
1107 mount_enter_remounting(m);
1111 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1112 Mount *m = MOUNT(u);
1118 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1119 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1120 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1122 if (m->control_pid > 0)
1123 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1125 if (m->control_command_id >= 0)
1126 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1131 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1132 Mount *m = MOUNT(u);
1139 if (streq(key, "state")) {
1142 if ((state = mount_state_from_string(value)) < 0)
1143 log_debug("Failed to parse state value %s", value);
1145 m->deserialized_state = state;
1146 } else if (streq(key, "result")) {
1149 f = mount_result_from_string(value);
1151 log_debug("Failed to parse result value %s", value);
1152 else if (f != MOUNT_SUCCESS)
1155 } else if (streq(key, "reload-result")) {
1158 f = mount_result_from_string(value);
1160 log_debug("Failed to parse reload result value %s", value);
1161 else if (f != MOUNT_SUCCESS)
1162 m->reload_result = f;
1164 } else if (streq(key, "control-pid")) {
1167 if (parse_pid(value, &pid) < 0)
1168 log_debug("Failed to parse control-pid value %s", value);
1170 m->control_pid = pid;
1171 } else if (streq(key, "control-command")) {
1172 MountExecCommand id;
1174 if ((id = mount_exec_command_from_string(value)) < 0)
1175 log_debug("Failed to parse exec-command value %s", value);
1177 m->control_command_id = id;
1178 m->control_command = m->exec_command + id;
1182 log_debug("Unknown serialization key '%s'", key);
1187 static UnitActiveState mount_active_state(Unit *u) {
1190 return state_translation_table[MOUNT(u)->state];
1193 static const char *mount_sub_state_to_string(Unit *u) {
1196 return mount_state_to_string(MOUNT(u)->state);
1199 static bool mount_check_gc(Unit *u) {
1200 Mount *m = MOUNT(u);
1204 return m->from_proc_self_mountinfo;
1207 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1208 Mount *m = MOUNT(u);
1214 if (pid != m->control_pid)
1219 if (is_clean_exit(code, status))
1221 else if (code == CLD_EXITED)
1222 f = MOUNT_FAILURE_EXIT_CODE;
1223 else if (code == CLD_KILLED)
1224 f = MOUNT_FAILURE_SIGNAL;
1225 else if (code == CLD_DUMPED)
1226 f = MOUNT_FAILURE_CORE_DUMP;
1228 assert_not_reached("Unknown code");
1230 if (f != MOUNT_SUCCESS)
1233 if (m->control_command) {
1234 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1236 m->control_command = NULL;
1237 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1240 log_full(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1241 "%s mount process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1243 /* Note that mount(8) returning and the kernel sending us a
1244 * mount table change event might happen out-of-order. If an
1245 * operation succeed we assume the kernel will follow soon too
1246 * and already change into the resulting state. If it fails
1247 * we check if the kernel still knows about the mount. and
1248 * change state accordingly. */
1252 case MOUNT_MOUNTING:
1253 case MOUNT_MOUNTING_DONE:
1254 case MOUNT_MOUNTING_SIGKILL:
1255 case MOUNT_MOUNTING_SIGTERM:
1257 if (f == MOUNT_SUCCESS)
1258 mount_enter_mounted(m, f);
1259 else if (m->from_proc_self_mountinfo)
1260 mount_enter_mounted(m, f);
1262 mount_enter_dead(m, f);
1265 case MOUNT_REMOUNTING:
1266 case MOUNT_REMOUNTING_SIGKILL:
1267 case MOUNT_REMOUNTING_SIGTERM:
1269 m->reload_result = f;
1270 if (m->from_proc_self_mountinfo)
1271 mount_enter_mounted(m, MOUNT_SUCCESS);
1273 mount_enter_dead(m, MOUNT_SUCCESS);
1277 case MOUNT_UNMOUNTING:
1278 case MOUNT_UNMOUNTING_SIGKILL:
1279 case MOUNT_UNMOUNTING_SIGTERM:
1281 if (f == MOUNT_SUCCESS)
1282 mount_enter_dead(m, f);
1283 else if (m->from_proc_self_mountinfo)
1284 mount_enter_mounted(m, f);
1286 mount_enter_dead(m, f);
1290 assert_not_reached("Uh, control process died at wrong time.");
1293 /* Notify clients about changed exit status */
1294 unit_add_to_dbus_queue(u);
1297 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1298 Mount *m = MOUNT(u);
1301 assert(elapsed == 1);
1302 assert(w == &m->timer_watch);
1306 case MOUNT_MOUNTING:
1307 case MOUNT_MOUNTING_DONE:
1308 log_warning("%s mounting timed out. Stopping.", u->id);
1309 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1312 case MOUNT_REMOUNTING:
1313 log_warning("%s remounting timed out. Stopping.", u->id);
1314 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1315 mount_enter_mounted(m, MOUNT_SUCCESS);
1318 case MOUNT_UNMOUNTING:
1319 log_warning("%s unmounting timed out. Stopping.", u->id);
1320 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1323 case MOUNT_MOUNTING_SIGTERM:
1324 if (m->exec_context.send_sigkill) {
1325 log_warning("%s mounting timed out. Killing.", u->id);
1326 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1328 log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1330 if (m->from_proc_self_mountinfo)
1331 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1333 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1337 case MOUNT_REMOUNTING_SIGTERM:
1338 if (m->exec_context.send_sigkill) {
1339 log_warning("%s remounting timed out. Killing.", u->id);
1340 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1342 log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1344 if (m->from_proc_self_mountinfo)
1345 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1347 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1351 case MOUNT_UNMOUNTING_SIGTERM:
1352 if (m->exec_context.send_sigkill) {
1353 log_warning("%s unmounting timed out. Killing.", u->id);
1354 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1356 log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1358 if (m->from_proc_self_mountinfo)
1359 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1361 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1365 case MOUNT_MOUNTING_SIGKILL:
1366 case MOUNT_REMOUNTING_SIGKILL:
1367 case MOUNT_UNMOUNTING_SIGKILL:
1368 log_warning("%s mount process still around after SIGKILL. Ignoring.", u->id);
1370 if (m->from_proc_self_mountinfo)
1371 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1373 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1377 assert_not_reached("Timeout at wrong time.");
1381 static int mount_add_one(
1385 const char *options,
1392 char *e, *w = NULL, *o = NULL, *f = NULL;
1401 /* Ignore API mount points. They should never be referenced in
1402 * dependencies ever. */
1403 if (mount_point_is_api(where) || mount_point_ignore(where))
1406 if (streq(fstype, "autofs"))
1409 /* probably some kind of swap, ignore */
1410 if (!is_path(where))
1413 e = unit_name_from_path(where, ".mount");
1417 u = manager_get_unit(m, e);
1421 u = unit_new(m, sizeof(Mount));
1427 r = unit_add_name(u, e);
1433 MOUNT(u)->where = strdup(where);
1434 if (!MOUNT(u)->where) {
1439 unit_add_to_load_queue(u);
1444 if (u->load_state == UNIT_ERROR) {
1445 u->load_state = UNIT_LOADED;
1447 r = mount_add_extras(MOUNT(u));
1453 if (!(w = strdup(what)) ||
1454 !(o = strdup(options)) ||
1455 !(f = strdup(fstype))) {
1460 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1462 MOUNT(u)->is_mounted = true;
1463 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1464 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1467 MOUNT(u)->from_proc_self_mountinfo = true;
1480 unit_add_to_dbus_queue(u);
1495 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1498 char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1502 rewind(m->proc_self_mountinfo);
1507 device = path = options = options2 = fstype = d = p = o = NULL;
1509 if ((k = fscanf(m->proc_self_mountinfo,
1510 "%*s " /* (1) mount id */
1511 "%*s " /* (2) parent id */
1512 "%*s " /* (3) major:minor */
1513 "%*s " /* (4) root */
1514 "%ms " /* (5) mount point */
1515 "%ms" /* (6) mount options */
1516 "%*[^-]" /* (7) optional fields */
1517 "- " /* (8) separator */
1518 "%ms " /* (9) file system type */
1519 "%ms" /* (10) mount source */
1520 "%ms" /* (11) mount options 2 */
1521 "%*[^\n]", /* some rubbish at the end */
1531 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1535 o = join(options, ",", options2, NULL);
1541 if (!(d = cunescape(device)) ||
1542 !(p = cunescape(path))) {
1547 if ((k = mount_add_one(m, d, p, o, fstype, 0, set_flags)) < 0)
1574 static void mount_shutdown(Manager *m) {
1577 if (m->proc_self_mountinfo) {
1578 fclose(m->proc_self_mountinfo);
1579 m->proc_self_mountinfo = NULL;
1583 static int mount_enumerate(Manager *m) {
1585 struct epoll_event ev;
1588 if (!m->proc_self_mountinfo) {
1589 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1592 m->mount_watch.type = WATCH_MOUNT;
1593 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1596 ev.events = EPOLLPRI;
1597 ev.data.ptr = &m->mount_watch;
1599 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1603 if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1613 void mount_fd_event(Manager *m, int events) {
1618 assert(events & EPOLLPRI);
1620 /* The manager calls this for every fd event happening on the
1621 * /proc/self/mountinfo file, which informs us about mounting
1624 if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
1625 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1627 /* Reset flags, just in case, for later calls */
1628 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1629 Mount *mount = MOUNT(u);
1631 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1637 manager_dispatch_load_queue(m);
1639 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1640 Mount *mount = MOUNT(u);
1642 if (!mount->is_mounted) {
1643 /* This has just been unmounted. */
1645 mount->from_proc_self_mountinfo = false;
1647 switch (mount->state) {
1650 mount_enter_dead(mount, MOUNT_SUCCESS);
1654 mount_set_state(mount, mount->state);
1659 } else if (mount->just_mounted || mount->just_changed) {
1661 /* New or changed mount entry */
1663 switch (mount->state) {
1667 mount_enter_mounted(mount, MOUNT_SUCCESS);
1670 case MOUNT_MOUNTING:
1671 mount_enter_mounting_done(mount);
1675 /* Nothing really changed, but let's
1676 * issue an notification call
1677 * nonetheless, in case somebody is
1678 * waiting for this. (e.g. file system
1679 * ro/rw remounts.) */
1680 mount_set_state(mount, mount->state);
1685 /* Reset the flags for later calls */
1686 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1690 static void mount_reset_failed(Unit *u) {
1691 Mount *m = MOUNT(u);
1695 if (m->state == MOUNT_FAILED)
1696 mount_set_state(m, MOUNT_DEAD);
1698 m->result = MOUNT_SUCCESS;
1699 m->reload_result = MOUNT_SUCCESS;
1702 static int mount_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
1703 Mount *m = MOUNT(u);
1705 Set *pid_set = NULL;
1709 if (who == KILL_MAIN) {
1710 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1714 if (m->control_pid <= 0 && who == KILL_CONTROL) {
1715 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1719 if (who == KILL_CONTROL || who == KILL_ALL)
1720 if (m->control_pid > 0)
1721 if (kill(m->control_pid, signo) < 0)
1724 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
1727 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
1730 /* Exclude the control pid from being killed via the cgroup */
1731 if (m->control_pid > 0)
1732 if ((q = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0) {
1737 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, false, pid_set, NULL);
1739 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1750 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1751 [MOUNT_DEAD] = "dead",
1752 [MOUNT_MOUNTING] = "mounting",
1753 [MOUNT_MOUNTING_DONE] = "mounting-done",
1754 [MOUNT_MOUNTED] = "mounted",
1755 [MOUNT_REMOUNTING] = "remounting",
1756 [MOUNT_UNMOUNTING] = "unmounting",
1757 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1758 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1759 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1760 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1761 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1762 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1763 [MOUNT_FAILED] = "failed"
1766 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1768 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1769 [MOUNT_EXEC_MOUNT] = "ExecMount",
1770 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1771 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1774 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1776 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1777 [MOUNT_SUCCESS] = "success",
1778 [MOUNT_FAILURE_RESOURCES] = "resources",
1779 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1780 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1781 [MOUNT_FAILURE_SIGNAL] = "signal",
1782 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1785 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1787 const UnitVTable mount_vtable = {
1789 .object_size = sizeof(Mount),
1796 .no_instances = true,
1802 .coldplug = mount_coldplug,
1806 .start = mount_start,
1808 .reload = mount_reload,
1812 .serialize = mount_serialize,
1813 .deserialize_item = mount_deserialize_item,
1815 .active_state = mount_active_state,
1816 .sub_state_to_string = mount_sub_state_to_string,
1818 .check_gc = mount_check_gc,
1820 .sigchld_event = mount_sigchld_event,
1821 .timer_event = mount_timer_event,
1823 .reset_failed = mount_reset_failed,
1825 .bus_interface = "org.freedesktop.systemd1.Mount",
1826 .bus_message_handler = bus_mount_message_handler,
1827 .bus_invalidating_properties = bus_mount_invalidating_properties,
1829 .enumerate = mount_enumerate,
1830 .shutdown = mount_shutdown,
1832 .status_message_formats = {
1833 .starting_stopping = {
1834 [0] = "Mounting %s...",
1835 [1] = "Unmounting %s...",
1837 .finished_start_job = {
1838 [JOB_DONE] = "Mounted %s.",
1839 [JOB_FAILED] = "Failed to mount %s.",
1840 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1841 [JOB_TIMEOUT] = "Timed out mounting %s.",
1843 .finished_stop_job = {
1844 [JOB_DONE] = "Unmounted %s.",
1845 [JOB_FAILED] = "Failed unmounting %s.",
1846 [JOB_TIMEOUT] = "Timed out unmounting %s.",