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);
635 r = unit_patch_working_directory(UNIT(m), &m->exec_context);
640 return mount_verify(m);
643 static int mount_notify_automount(Mount *m, int status) {
650 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
651 if (p->type == UNIT_AUTOMOUNT) {
652 r = automount_send_ready(AUTOMOUNT(p), status);
660 static void mount_set_state(Mount *m, MountState state) {
661 MountState old_state;
664 old_state = m->state;
667 if (state != MOUNT_MOUNTING &&
668 state != MOUNT_MOUNTING_DONE &&
669 state != MOUNT_REMOUNTING &&
670 state != MOUNT_UNMOUNTING &&
671 state != MOUNT_MOUNTING_SIGTERM &&
672 state != MOUNT_MOUNTING_SIGKILL &&
673 state != MOUNT_UNMOUNTING_SIGTERM &&
674 state != MOUNT_UNMOUNTING_SIGKILL &&
675 state != MOUNT_REMOUNTING_SIGTERM &&
676 state != MOUNT_REMOUNTING_SIGKILL) {
677 unit_unwatch_timer(UNIT(m), &m->timer_watch);
678 mount_unwatch_control_pid(m);
679 m->control_command = NULL;
680 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
683 if (state == MOUNT_MOUNTED ||
684 state == MOUNT_REMOUNTING)
685 mount_notify_automount(m, 0);
686 else if (state == MOUNT_DEAD ||
687 state == MOUNT_UNMOUNTING ||
688 state == MOUNT_MOUNTING_SIGTERM ||
689 state == MOUNT_MOUNTING_SIGKILL ||
690 state == MOUNT_REMOUNTING_SIGTERM ||
691 state == MOUNT_REMOUNTING_SIGKILL ||
692 state == MOUNT_UNMOUNTING_SIGTERM ||
693 state == MOUNT_UNMOUNTING_SIGKILL ||
694 state == MOUNT_FAILED) {
695 if (state != old_state)
696 mount_notify_automount(m, -ENODEV);
699 if (state != old_state)
700 log_debug("%s changed %s -> %s",
702 mount_state_to_string(old_state),
703 mount_state_to_string(state));
705 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
706 m->reload_result = MOUNT_SUCCESS;
709 static int mount_coldplug(Unit *u) {
711 MountState new_state = MOUNT_DEAD;
715 assert(m->state == MOUNT_DEAD);
717 if (m->deserialized_state != m->state)
718 new_state = m->deserialized_state;
719 else if (m->from_proc_self_mountinfo)
720 new_state = MOUNT_MOUNTED;
722 if (new_state != m->state) {
724 if (new_state == MOUNT_MOUNTING ||
725 new_state == MOUNT_MOUNTING_DONE ||
726 new_state == MOUNT_REMOUNTING ||
727 new_state == MOUNT_UNMOUNTING ||
728 new_state == MOUNT_MOUNTING_SIGTERM ||
729 new_state == MOUNT_MOUNTING_SIGKILL ||
730 new_state == MOUNT_UNMOUNTING_SIGTERM ||
731 new_state == MOUNT_UNMOUNTING_SIGKILL ||
732 new_state == MOUNT_REMOUNTING_SIGTERM ||
733 new_state == MOUNT_REMOUNTING_SIGKILL) {
735 if (m->control_pid <= 0)
738 if ((r = unit_watch_pid(UNIT(m), m->control_pid)) < 0)
741 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
745 mount_set_state(m, new_state);
751 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
758 p = get_mount_parameters(m);
761 "%sMount State: %s\n"
765 "%sFile System Type: %s\n"
767 "%sFrom /proc/self/mountinfo: %s\n"
768 "%sFrom fragment: %s\n"
769 "%sDirectoryMode: %04o\n",
770 prefix, mount_state_to_string(m->state),
771 prefix, mount_result_to_string(m->result),
773 prefix, strna(p->what),
774 prefix, strna(p->fstype),
775 prefix, strna(p->options),
776 prefix, yes_no(m->from_proc_self_mountinfo),
777 prefix, yes_no(m->from_fragment),
778 prefix, m->directory_mode);
780 if (m->control_pid > 0)
782 "%sControl PID: %lu\n",
783 prefix, (unsigned long) m->control_pid);
785 exec_context_dump(&m->exec_context, f, prefix);
788 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
796 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
799 if ((r = exec_spawn(c,
803 UNIT(m)->manager->environment,
807 UNIT(m)->manager->confirm_spawn,
808 UNIT(m)->cgroup_bondings,
809 UNIT(m)->cgroup_attributes,
816 if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
817 /* FIXME: we need to do something here */
825 unit_unwatch_timer(UNIT(m), &m->timer_watch);
830 static void mount_enter_dead(Mount *m, MountResult f) {
833 if (f != MOUNT_SUCCESS)
836 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
839 static void mount_enter_mounted(Mount *m, MountResult f) {
842 if (f != MOUNT_SUCCESS)
845 mount_set_state(m, MOUNT_MOUNTED);
848 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
851 bool wait_for_exit = false;
855 if (f != MOUNT_SUCCESS)
858 if (m->exec_context.kill_mode != KILL_NONE) {
859 int sig = (state == MOUNT_MOUNTING_SIGTERM ||
860 state == MOUNT_UNMOUNTING_SIGTERM ||
861 state == MOUNT_REMOUNTING_SIGTERM) ? m->exec_context.kill_signal : SIGKILL;
863 if (m->control_pid > 0) {
864 if (kill_and_sigcont(m->control_pid, sig) < 0 && errno != ESRCH)
866 log_warning("Failed to kill control process %li: %m", (long) m->control_pid);
868 wait_for_exit = true;
871 if (m->exec_context.kill_mode == KILL_CONTROL_GROUP) {
873 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
878 /* Exclude the control pid from being killed via the cgroup */
879 if (m->control_pid > 0)
880 if ((r = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0)
883 r = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, sig, true, false, pid_set, NULL);
885 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
886 log_warning("Failed to kill control group: %s", strerror(-r));
888 wait_for_exit = true;
896 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
899 mount_set_state(m, state);
900 } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
901 mount_enter_mounted(m, MOUNT_SUCCESS);
903 mount_enter_dead(m, MOUNT_SUCCESS);
908 log_warning("%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
910 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
911 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
913 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
919 static void mount_enter_unmounting(Mount *m) {
924 m->control_command_id = MOUNT_EXEC_UNMOUNT;
925 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
927 if ((r = exec_command_set(
934 mount_unwatch_control_pid(m);
936 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
939 mount_set_state(m, MOUNT_UNMOUNTING);
944 log_warning("%s failed to run 'umount' task: %s", UNIT(m)->id, strerror(-r));
945 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
948 static void mount_enter_mounting(Mount *m) {
954 m->control_command_id = MOUNT_EXEC_MOUNT;
955 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
957 mkdir_p_label(m->where, m->directory_mode);
959 /* Create the source directory for bind-mounts if needed */
960 p = get_mount_parameters_fragment(m);
961 if (p && mount_is_bind(p))
962 mkdir_p_label(p->what, m->directory_mode);
964 if (m->from_fragment)
965 r = exec_command_set(
968 m->parameters_fragment.what,
970 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
971 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
979 mount_unwatch_control_pid(m);
981 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
984 mount_set_state(m, MOUNT_MOUNTING);
989 log_warning("%s failed to run 'mount' task: %s", UNIT(m)->id, strerror(-r));
990 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
993 static void mount_enter_mounting_done(Mount *m) {
996 mount_set_state(m, MOUNT_MOUNTING_DONE);
999 static void mount_enter_remounting(Mount *m) {
1004 m->control_command_id = MOUNT_EXEC_REMOUNT;
1005 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1007 if (m->from_fragment) {
1011 if (m->parameters_fragment.options) {
1012 if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
1021 r = exec_command_set(
1024 m->parameters_fragment.what,
1026 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
1037 mount_unwatch_control_pid(m);
1039 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1042 mount_set_state(m, MOUNT_REMOUNTING);
1047 log_warning("%s failed to run 'remount' task: %s", UNIT(m)->id, strerror(-r));
1048 m->reload_result = MOUNT_FAILURE_RESOURCES;
1049 mount_enter_mounted(m, MOUNT_SUCCESS);
1052 static int mount_start(Unit *u) {
1053 Mount *m = MOUNT(u);
1057 /* We cannot fulfill this request right now, try again later
1059 if (m->state == MOUNT_UNMOUNTING ||
1060 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1061 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1062 m->state == MOUNT_MOUNTING_SIGTERM ||
1063 m->state == MOUNT_MOUNTING_SIGKILL)
1066 /* Already on it! */
1067 if (m->state == MOUNT_MOUNTING)
1070 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1072 m->result = MOUNT_SUCCESS;
1073 m->reload_result = MOUNT_SUCCESS;
1075 mount_enter_mounting(m);
1079 static int mount_stop(Unit *u) {
1080 Mount *m = MOUNT(u);
1085 if (m->state == MOUNT_UNMOUNTING ||
1086 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1087 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1088 m->state == MOUNT_MOUNTING_SIGTERM ||
1089 m->state == MOUNT_MOUNTING_SIGKILL)
1092 assert(m->state == MOUNT_MOUNTING ||
1093 m->state == MOUNT_MOUNTING_DONE ||
1094 m->state == MOUNT_MOUNTED ||
1095 m->state == MOUNT_REMOUNTING ||
1096 m->state == MOUNT_REMOUNTING_SIGTERM ||
1097 m->state == MOUNT_REMOUNTING_SIGKILL);
1099 mount_enter_unmounting(m);
1103 static int mount_reload(Unit *u) {
1104 Mount *m = MOUNT(u);
1108 if (m->state == MOUNT_MOUNTING_DONE)
1111 assert(m->state == MOUNT_MOUNTED);
1113 mount_enter_remounting(m);
1117 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1118 Mount *m = MOUNT(u);
1124 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1125 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1126 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1128 if (m->control_pid > 0)
1129 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1131 if (m->control_command_id >= 0)
1132 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1137 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1138 Mount *m = MOUNT(u);
1145 if (streq(key, "state")) {
1148 if ((state = mount_state_from_string(value)) < 0)
1149 log_debug("Failed to parse state value %s", value);
1151 m->deserialized_state = state;
1152 } else if (streq(key, "result")) {
1155 f = mount_result_from_string(value);
1157 log_debug("Failed to parse result value %s", value);
1158 else if (f != MOUNT_SUCCESS)
1161 } else if (streq(key, "reload-result")) {
1164 f = mount_result_from_string(value);
1166 log_debug("Failed to parse reload result value %s", value);
1167 else if (f != MOUNT_SUCCESS)
1168 m->reload_result = f;
1170 } else if (streq(key, "control-pid")) {
1173 if (parse_pid(value, &pid) < 0)
1174 log_debug("Failed to parse control-pid value %s", value);
1176 m->control_pid = pid;
1177 } else if (streq(key, "control-command")) {
1178 MountExecCommand id;
1180 if ((id = mount_exec_command_from_string(value)) < 0)
1181 log_debug("Failed to parse exec-command value %s", value);
1183 m->control_command_id = id;
1184 m->control_command = m->exec_command + id;
1188 log_debug("Unknown serialization key '%s'", key);
1193 static UnitActiveState mount_active_state(Unit *u) {
1196 return state_translation_table[MOUNT(u)->state];
1199 static const char *mount_sub_state_to_string(Unit *u) {
1202 return mount_state_to_string(MOUNT(u)->state);
1205 static bool mount_check_gc(Unit *u) {
1206 Mount *m = MOUNT(u);
1210 return m->from_proc_self_mountinfo;
1213 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1214 Mount *m = MOUNT(u);
1220 if (pid != m->control_pid)
1225 if (is_clean_exit(code, status))
1227 else if (code == CLD_EXITED)
1228 f = MOUNT_FAILURE_EXIT_CODE;
1229 else if (code == CLD_KILLED)
1230 f = MOUNT_FAILURE_SIGNAL;
1231 else if (code == CLD_DUMPED)
1232 f = MOUNT_FAILURE_CORE_DUMP;
1234 assert_not_reached("Unknown code");
1236 if (f != MOUNT_SUCCESS)
1239 if (m->control_command) {
1240 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1242 m->control_command = NULL;
1243 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1246 log_full(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1247 "%s mount process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1249 /* Note that mount(8) returning and the kernel sending us a
1250 * mount table change event might happen out-of-order. If an
1251 * operation succeed we assume the kernel will follow soon too
1252 * and already change into the resulting state. If it fails
1253 * we check if the kernel still knows about the mount. and
1254 * change state accordingly. */
1258 case MOUNT_MOUNTING:
1259 case MOUNT_MOUNTING_DONE:
1260 case MOUNT_MOUNTING_SIGKILL:
1261 case MOUNT_MOUNTING_SIGTERM:
1263 if (f == MOUNT_SUCCESS)
1264 mount_enter_mounted(m, f);
1265 else if (m->from_proc_self_mountinfo)
1266 mount_enter_mounted(m, f);
1268 mount_enter_dead(m, f);
1271 case MOUNT_REMOUNTING:
1272 case MOUNT_REMOUNTING_SIGKILL:
1273 case MOUNT_REMOUNTING_SIGTERM:
1275 m->reload_result = f;
1276 if (m->from_proc_self_mountinfo)
1277 mount_enter_mounted(m, MOUNT_SUCCESS);
1279 mount_enter_dead(m, MOUNT_SUCCESS);
1283 case MOUNT_UNMOUNTING:
1284 case MOUNT_UNMOUNTING_SIGKILL:
1285 case MOUNT_UNMOUNTING_SIGTERM:
1287 if (f == MOUNT_SUCCESS)
1288 mount_enter_dead(m, f);
1289 else if (m->from_proc_self_mountinfo)
1290 mount_enter_mounted(m, f);
1292 mount_enter_dead(m, f);
1296 assert_not_reached("Uh, control process died at wrong time.");
1299 /* Notify clients about changed exit status */
1300 unit_add_to_dbus_queue(u);
1303 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1304 Mount *m = MOUNT(u);
1307 assert(elapsed == 1);
1308 assert(w == &m->timer_watch);
1312 case MOUNT_MOUNTING:
1313 case MOUNT_MOUNTING_DONE:
1314 log_warning("%s mounting timed out. Stopping.", u->id);
1315 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1318 case MOUNT_REMOUNTING:
1319 log_warning("%s remounting timed out. Stopping.", u->id);
1320 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1321 mount_enter_mounted(m, MOUNT_SUCCESS);
1324 case MOUNT_UNMOUNTING:
1325 log_warning("%s unmounting timed out. Stopping.", u->id);
1326 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1329 case MOUNT_MOUNTING_SIGTERM:
1330 if (m->exec_context.send_sigkill) {
1331 log_warning("%s mounting timed out. Killing.", u->id);
1332 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1334 log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1336 if (m->from_proc_self_mountinfo)
1337 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1339 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1343 case MOUNT_REMOUNTING_SIGTERM:
1344 if (m->exec_context.send_sigkill) {
1345 log_warning("%s remounting timed out. Killing.", u->id);
1346 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1348 log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1350 if (m->from_proc_self_mountinfo)
1351 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1353 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1357 case MOUNT_UNMOUNTING_SIGTERM:
1358 if (m->exec_context.send_sigkill) {
1359 log_warning("%s unmounting timed out. Killing.", u->id);
1360 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1362 log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1364 if (m->from_proc_self_mountinfo)
1365 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1367 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1371 case MOUNT_MOUNTING_SIGKILL:
1372 case MOUNT_REMOUNTING_SIGKILL:
1373 case MOUNT_UNMOUNTING_SIGKILL:
1374 log_warning("%s mount process still around after SIGKILL. Ignoring.", u->id);
1376 if (m->from_proc_self_mountinfo)
1377 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1379 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1383 assert_not_reached("Timeout at wrong time.");
1387 static int mount_add_one(
1391 const char *options,
1398 char *e, *w = NULL, *o = NULL, *f = NULL;
1407 /* Ignore API mount points. They should never be referenced in
1408 * dependencies ever. */
1409 if (mount_point_is_api(where) || mount_point_ignore(where))
1412 if (streq(fstype, "autofs"))
1415 /* probably some kind of swap, ignore */
1416 if (!is_path(where))
1419 e = unit_name_from_path(where, ".mount");
1423 u = manager_get_unit(m, e);
1427 u = unit_new(m, sizeof(Mount));
1433 r = unit_add_name(u, e);
1439 MOUNT(u)->where = strdup(where);
1440 if (!MOUNT(u)->where) {
1445 unit_add_to_load_queue(u);
1450 if (u->load_state == UNIT_ERROR) {
1451 u->load_state = UNIT_LOADED;
1453 r = mount_add_extras(MOUNT(u));
1459 if (!(w = strdup(what)) ||
1460 !(o = strdup(options)) ||
1461 !(f = strdup(fstype))) {
1466 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1468 MOUNT(u)->is_mounted = true;
1469 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1470 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1473 MOUNT(u)->from_proc_self_mountinfo = true;
1486 unit_add_to_dbus_queue(u);
1501 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1504 char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1508 rewind(m->proc_self_mountinfo);
1513 device = path = options = options2 = fstype = d = p = o = NULL;
1515 if ((k = fscanf(m->proc_self_mountinfo,
1516 "%*s " /* (1) mount id */
1517 "%*s " /* (2) parent id */
1518 "%*s " /* (3) major:minor */
1519 "%*s " /* (4) root */
1520 "%ms " /* (5) mount point */
1521 "%ms" /* (6) mount options */
1522 "%*[^-]" /* (7) optional fields */
1523 "- " /* (8) separator */
1524 "%ms " /* (9) file system type */
1525 "%ms" /* (10) mount source */
1526 "%ms" /* (11) mount options 2 */
1527 "%*[^\n]", /* some rubbish at the end */
1537 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1541 o = strjoin(options, ",", options2, NULL);
1547 if (!(d = cunescape(device)) ||
1548 !(p = cunescape(path))) {
1553 if ((k = mount_add_one(m, d, p, o, fstype, 0, set_flags)) < 0)
1580 static void mount_shutdown(Manager *m) {
1583 if (m->proc_self_mountinfo) {
1584 fclose(m->proc_self_mountinfo);
1585 m->proc_self_mountinfo = NULL;
1589 static int mount_enumerate(Manager *m) {
1591 struct epoll_event ev;
1594 if (!m->proc_self_mountinfo) {
1595 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1598 m->mount_watch.type = WATCH_MOUNT;
1599 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1602 ev.events = EPOLLPRI;
1603 ev.data.ptr = &m->mount_watch;
1605 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1609 if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1619 void mount_fd_event(Manager *m, int events) {
1624 assert(events & EPOLLPRI);
1626 /* The manager calls this for every fd event happening on the
1627 * /proc/self/mountinfo file, which informs us about mounting
1630 if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
1631 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1633 /* Reset flags, just in case, for later calls */
1634 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1635 Mount *mount = MOUNT(u);
1637 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1643 manager_dispatch_load_queue(m);
1645 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1646 Mount *mount = MOUNT(u);
1648 if (!mount->is_mounted) {
1649 /* This has just been unmounted. */
1651 mount->from_proc_self_mountinfo = false;
1653 switch (mount->state) {
1656 mount_enter_dead(mount, MOUNT_SUCCESS);
1660 mount_set_state(mount, mount->state);
1665 } else if (mount->just_mounted || mount->just_changed) {
1667 /* New or changed mount entry */
1669 switch (mount->state) {
1673 mount_enter_mounted(mount, MOUNT_SUCCESS);
1676 case MOUNT_MOUNTING:
1677 mount_enter_mounting_done(mount);
1681 /* Nothing really changed, but let's
1682 * issue an notification call
1683 * nonetheless, in case somebody is
1684 * waiting for this. (e.g. file system
1685 * ro/rw remounts.) */
1686 mount_set_state(mount, mount->state);
1691 /* Reset the flags for later calls */
1692 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1696 static void mount_reset_failed(Unit *u) {
1697 Mount *m = MOUNT(u);
1701 if (m->state == MOUNT_FAILED)
1702 mount_set_state(m, MOUNT_DEAD);
1704 m->result = MOUNT_SUCCESS;
1705 m->reload_result = MOUNT_SUCCESS;
1708 static int mount_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
1709 Mount *m = MOUNT(u);
1711 Set *pid_set = NULL;
1715 if (who == KILL_MAIN) {
1716 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1720 if (m->control_pid <= 0 && who == KILL_CONTROL) {
1721 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1725 if (who == KILL_CONTROL || who == KILL_ALL)
1726 if (m->control_pid > 0)
1727 if (kill(m->control_pid, signo) < 0)
1730 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
1733 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
1736 /* Exclude the control pid from being killed via the cgroup */
1737 if (m->control_pid > 0)
1738 if ((q = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0) {
1743 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, false, pid_set, NULL);
1745 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1756 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1757 [MOUNT_DEAD] = "dead",
1758 [MOUNT_MOUNTING] = "mounting",
1759 [MOUNT_MOUNTING_DONE] = "mounting-done",
1760 [MOUNT_MOUNTED] = "mounted",
1761 [MOUNT_REMOUNTING] = "remounting",
1762 [MOUNT_UNMOUNTING] = "unmounting",
1763 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1764 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1765 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1766 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1767 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1768 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1769 [MOUNT_FAILED] = "failed"
1772 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1774 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1775 [MOUNT_EXEC_MOUNT] = "ExecMount",
1776 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1777 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1780 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1782 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1783 [MOUNT_SUCCESS] = "success",
1784 [MOUNT_FAILURE_RESOURCES] = "resources",
1785 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1786 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1787 [MOUNT_FAILURE_SIGNAL] = "signal",
1788 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1791 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1793 const UnitVTable mount_vtable = {
1794 .object_size = sizeof(Mount),
1801 .no_instances = true,
1807 .coldplug = mount_coldplug,
1811 .start = mount_start,
1813 .reload = mount_reload,
1817 .serialize = mount_serialize,
1818 .deserialize_item = mount_deserialize_item,
1820 .active_state = mount_active_state,
1821 .sub_state_to_string = mount_sub_state_to_string,
1823 .check_gc = mount_check_gc,
1825 .sigchld_event = mount_sigchld_event,
1826 .timer_event = mount_timer_event,
1828 .reset_failed = mount_reset_failed,
1830 .bus_interface = "org.freedesktop.systemd1.Mount",
1831 .bus_message_handler = bus_mount_message_handler,
1832 .bus_invalidating_properties = bus_mount_invalidating_properties,
1834 .enumerate = mount_enumerate,
1835 .shutdown = mount_shutdown,
1837 .status_message_formats = {
1838 .starting_stopping = {
1839 [0] = "Mounting %s...",
1840 [1] = "Unmounting %s...",
1842 .finished_start_job = {
1843 [JOB_DONE] = "Mounted %s.",
1844 [JOB_FAILED] = "Failed to mount %s.",
1845 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1846 [JOB_TIMEOUT] = "Timed out mounting %s.",
1848 .finished_stop_job = {
1849 [JOB_DONE] = "Unmounted %s.",
1850 [JOB_FAILED] = "Failed unmounting %s.",
1851 [JOB_TIMEOUT] = "Timed out unmounting %s.",