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 if (state != old_state)
692 mount_notify_automount(m, -ENODEV);
695 if (state != old_state)
696 log_debug("%s changed %s -> %s",
698 mount_state_to_string(old_state),
699 mount_state_to_string(state));
701 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
702 m->reload_result = MOUNT_SUCCESS;
705 static int mount_coldplug(Unit *u) {
707 MountState new_state = MOUNT_DEAD;
711 assert(m->state == MOUNT_DEAD);
713 if (m->deserialized_state != m->state)
714 new_state = m->deserialized_state;
715 else if (m->from_proc_self_mountinfo)
716 new_state = MOUNT_MOUNTED;
718 if (new_state != m->state) {
720 if (new_state == MOUNT_MOUNTING ||
721 new_state == MOUNT_MOUNTING_DONE ||
722 new_state == MOUNT_REMOUNTING ||
723 new_state == MOUNT_UNMOUNTING ||
724 new_state == MOUNT_MOUNTING_SIGTERM ||
725 new_state == MOUNT_MOUNTING_SIGKILL ||
726 new_state == MOUNT_UNMOUNTING_SIGTERM ||
727 new_state == MOUNT_UNMOUNTING_SIGKILL ||
728 new_state == MOUNT_REMOUNTING_SIGTERM ||
729 new_state == MOUNT_REMOUNTING_SIGKILL) {
731 if (m->control_pid <= 0)
734 if ((r = unit_watch_pid(UNIT(m), m->control_pid)) < 0)
737 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
741 mount_set_state(m, new_state);
747 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
754 p = get_mount_parameters(m);
757 "%sMount State: %s\n"
761 "%sFile System Type: %s\n"
763 "%sFrom /proc/self/mountinfo: %s\n"
764 "%sFrom fragment: %s\n"
765 "%sDirectoryMode: %04o\n",
766 prefix, mount_state_to_string(m->state),
767 prefix, mount_result_to_string(m->result),
769 prefix, strna(p->what),
770 prefix, strna(p->fstype),
771 prefix, strna(p->options),
772 prefix, yes_no(m->from_proc_self_mountinfo),
773 prefix, yes_no(m->from_fragment),
774 prefix, m->directory_mode);
776 if (m->control_pid > 0)
778 "%sControl PID: %lu\n",
779 prefix, (unsigned long) m->control_pid);
781 exec_context_dump(&m->exec_context, f, prefix);
784 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
792 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
795 if ((r = exec_spawn(c,
799 UNIT(m)->manager->environment,
803 UNIT(m)->manager->confirm_spawn,
804 UNIT(m)->cgroup_bondings,
805 UNIT(m)->cgroup_attributes,
812 if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
813 /* FIXME: we need to do something here */
821 unit_unwatch_timer(UNIT(m), &m->timer_watch);
826 static void mount_enter_dead(Mount *m, MountResult f) {
829 if (f != MOUNT_SUCCESS)
832 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
835 static void mount_enter_mounted(Mount *m, MountResult f) {
838 if (f != MOUNT_SUCCESS)
841 mount_set_state(m, MOUNT_MOUNTED);
844 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
847 bool wait_for_exit = false;
851 if (f != MOUNT_SUCCESS)
854 if (m->exec_context.kill_mode != KILL_NONE) {
855 int sig = (state == MOUNT_MOUNTING_SIGTERM ||
856 state == MOUNT_UNMOUNTING_SIGTERM ||
857 state == MOUNT_REMOUNTING_SIGTERM) ? m->exec_context.kill_signal : SIGKILL;
859 if (m->control_pid > 0) {
860 if (kill_and_sigcont(m->control_pid, sig) < 0 && errno != ESRCH)
862 log_warning("Failed to kill control process %li: %m", (long) m->control_pid);
864 wait_for_exit = true;
867 if (m->exec_context.kill_mode == KILL_CONTROL_GROUP) {
869 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
874 /* Exclude the control pid from being killed via the cgroup */
875 if (m->control_pid > 0)
876 if ((r = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0)
879 r = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, sig, true, false, pid_set, NULL);
881 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
882 log_warning("Failed to kill control group: %s", strerror(-r));
884 wait_for_exit = true;
892 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
895 mount_set_state(m, state);
896 } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
897 mount_enter_mounted(m, MOUNT_SUCCESS);
899 mount_enter_dead(m, MOUNT_SUCCESS);
904 log_warning("%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
906 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
907 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
909 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
915 static void mount_enter_unmounting(Mount *m) {
920 m->control_command_id = MOUNT_EXEC_UNMOUNT;
921 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
923 if ((r = exec_command_set(
930 mount_unwatch_control_pid(m);
932 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
935 mount_set_state(m, MOUNT_UNMOUNTING);
940 log_warning("%s failed to run 'umount' task: %s", UNIT(m)->id, strerror(-r));
941 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
944 static void mount_enter_mounting(Mount *m) {
950 m->control_command_id = MOUNT_EXEC_MOUNT;
951 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
953 mkdir_p_label(m->where, m->directory_mode);
955 /* Create the source directory for bind-mounts if needed */
956 p = get_mount_parameters_fragment(m);
957 if (p && mount_is_bind(p))
958 mkdir_p_label(p->what, m->directory_mode);
960 if (m->from_fragment)
961 r = exec_command_set(
964 m->parameters_fragment.what,
966 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
967 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
975 mount_unwatch_control_pid(m);
977 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
980 mount_set_state(m, MOUNT_MOUNTING);
985 log_warning("%s failed to run 'mount' task: %s", UNIT(m)->id, strerror(-r));
986 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
989 static void mount_enter_mounting_done(Mount *m) {
992 mount_set_state(m, MOUNT_MOUNTING_DONE);
995 static void mount_enter_remounting(Mount *m) {
1000 m->control_command_id = MOUNT_EXEC_REMOUNT;
1001 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1003 if (m->from_fragment) {
1007 if (m->parameters_fragment.options) {
1008 if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
1017 r = exec_command_set(
1020 m->parameters_fragment.what,
1022 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
1033 mount_unwatch_control_pid(m);
1035 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1038 mount_set_state(m, MOUNT_REMOUNTING);
1043 log_warning("%s failed to run 'remount' task: %s", UNIT(m)->id, strerror(-r));
1044 m->reload_result = MOUNT_FAILURE_RESOURCES;
1045 mount_enter_mounted(m, MOUNT_SUCCESS);
1048 static int mount_start(Unit *u) {
1049 Mount *m = MOUNT(u);
1053 /* We cannot fulfill this request right now, try again later
1055 if (m->state == MOUNT_UNMOUNTING ||
1056 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1057 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1058 m->state == MOUNT_MOUNTING_SIGTERM ||
1059 m->state == MOUNT_MOUNTING_SIGKILL)
1062 /* Already on it! */
1063 if (m->state == MOUNT_MOUNTING)
1066 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1068 m->result = MOUNT_SUCCESS;
1069 m->reload_result = MOUNT_SUCCESS;
1071 mount_enter_mounting(m);
1075 static int mount_stop(Unit *u) {
1076 Mount *m = MOUNT(u);
1081 if (m->state == MOUNT_UNMOUNTING ||
1082 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1083 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1084 m->state == MOUNT_MOUNTING_SIGTERM ||
1085 m->state == MOUNT_MOUNTING_SIGKILL)
1088 assert(m->state == MOUNT_MOUNTING ||
1089 m->state == MOUNT_MOUNTING_DONE ||
1090 m->state == MOUNT_MOUNTED ||
1091 m->state == MOUNT_REMOUNTING ||
1092 m->state == MOUNT_REMOUNTING_SIGTERM ||
1093 m->state == MOUNT_REMOUNTING_SIGKILL);
1095 mount_enter_unmounting(m);
1099 static int mount_reload(Unit *u) {
1100 Mount *m = MOUNT(u);
1104 if (m->state == MOUNT_MOUNTING_DONE)
1107 assert(m->state == MOUNT_MOUNTED);
1109 mount_enter_remounting(m);
1113 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1114 Mount *m = MOUNT(u);
1120 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1121 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1122 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1124 if (m->control_pid > 0)
1125 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1127 if (m->control_command_id >= 0)
1128 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1133 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1134 Mount *m = MOUNT(u);
1141 if (streq(key, "state")) {
1144 if ((state = mount_state_from_string(value)) < 0)
1145 log_debug("Failed to parse state value %s", value);
1147 m->deserialized_state = state;
1148 } else if (streq(key, "result")) {
1151 f = mount_result_from_string(value);
1153 log_debug("Failed to parse result value %s", value);
1154 else if (f != MOUNT_SUCCESS)
1157 } else if (streq(key, "reload-result")) {
1160 f = mount_result_from_string(value);
1162 log_debug("Failed to parse reload result value %s", value);
1163 else if (f != MOUNT_SUCCESS)
1164 m->reload_result = f;
1166 } else if (streq(key, "control-pid")) {
1169 if (parse_pid(value, &pid) < 0)
1170 log_debug("Failed to parse control-pid value %s", value);
1172 m->control_pid = pid;
1173 } else if (streq(key, "control-command")) {
1174 MountExecCommand id;
1176 if ((id = mount_exec_command_from_string(value)) < 0)
1177 log_debug("Failed to parse exec-command value %s", value);
1179 m->control_command_id = id;
1180 m->control_command = m->exec_command + id;
1184 log_debug("Unknown serialization key '%s'", key);
1189 static UnitActiveState mount_active_state(Unit *u) {
1192 return state_translation_table[MOUNT(u)->state];
1195 static const char *mount_sub_state_to_string(Unit *u) {
1198 return mount_state_to_string(MOUNT(u)->state);
1201 static bool mount_check_gc(Unit *u) {
1202 Mount *m = MOUNT(u);
1206 return m->from_proc_self_mountinfo;
1209 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1210 Mount *m = MOUNT(u);
1216 if (pid != m->control_pid)
1221 if (is_clean_exit(code, status))
1223 else if (code == CLD_EXITED)
1224 f = MOUNT_FAILURE_EXIT_CODE;
1225 else if (code == CLD_KILLED)
1226 f = MOUNT_FAILURE_SIGNAL;
1227 else if (code == CLD_DUMPED)
1228 f = MOUNT_FAILURE_CORE_DUMP;
1230 assert_not_reached("Unknown code");
1232 if (f != MOUNT_SUCCESS)
1235 if (m->control_command) {
1236 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1238 m->control_command = NULL;
1239 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1242 log_full(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1243 "%s mount process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1245 /* Note that mount(8) returning and the kernel sending us a
1246 * mount table change event might happen out-of-order. If an
1247 * operation succeed we assume the kernel will follow soon too
1248 * and already change into the resulting state. If it fails
1249 * we check if the kernel still knows about the mount. and
1250 * change state accordingly. */
1254 case MOUNT_MOUNTING:
1255 case MOUNT_MOUNTING_DONE:
1256 case MOUNT_MOUNTING_SIGKILL:
1257 case MOUNT_MOUNTING_SIGTERM:
1259 if (f == MOUNT_SUCCESS)
1260 mount_enter_mounted(m, f);
1261 else if (m->from_proc_self_mountinfo)
1262 mount_enter_mounted(m, f);
1264 mount_enter_dead(m, f);
1267 case MOUNT_REMOUNTING:
1268 case MOUNT_REMOUNTING_SIGKILL:
1269 case MOUNT_REMOUNTING_SIGTERM:
1271 m->reload_result = f;
1272 if (m->from_proc_self_mountinfo)
1273 mount_enter_mounted(m, MOUNT_SUCCESS);
1275 mount_enter_dead(m, MOUNT_SUCCESS);
1279 case MOUNT_UNMOUNTING:
1280 case MOUNT_UNMOUNTING_SIGKILL:
1281 case MOUNT_UNMOUNTING_SIGTERM:
1283 if (f == MOUNT_SUCCESS)
1284 mount_enter_dead(m, f);
1285 else if (m->from_proc_self_mountinfo)
1286 mount_enter_mounted(m, f);
1288 mount_enter_dead(m, f);
1292 assert_not_reached("Uh, control process died at wrong time.");
1295 /* Notify clients about changed exit status */
1296 unit_add_to_dbus_queue(u);
1299 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1300 Mount *m = MOUNT(u);
1303 assert(elapsed == 1);
1304 assert(w == &m->timer_watch);
1308 case MOUNT_MOUNTING:
1309 case MOUNT_MOUNTING_DONE:
1310 log_warning("%s mounting timed out. Stopping.", u->id);
1311 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1314 case MOUNT_REMOUNTING:
1315 log_warning("%s remounting timed out. Stopping.", u->id);
1316 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1317 mount_enter_mounted(m, MOUNT_SUCCESS);
1320 case MOUNT_UNMOUNTING:
1321 log_warning("%s unmounting timed out. Stopping.", u->id);
1322 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1325 case MOUNT_MOUNTING_SIGTERM:
1326 if (m->exec_context.send_sigkill) {
1327 log_warning("%s mounting timed out. Killing.", u->id);
1328 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1330 log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1332 if (m->from_proc_self_mountinfo)
1333 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1335 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1339 case MOUNT_REMOUNTING_SIGTERM:
1340 if (m->exec_context.send_sigkill) {
1341 log_warning("%s remounting timed out. Killing.", u->id);
1342 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1344 log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1346 if (m->from_proc_self_mountinfo)
1347 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1349 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1353 case MOUNT_UNMOUNTING_SIGTERM:
1354 if (m->exec_context.send_sigkill) {
1355 log_warning("%s unmounting timed out. Killing.", u->id);
1356 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1358 log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1360 if (m->from_proc_self_mountinfo)
1361 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1363 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1367 case MOUNT_MOUNTING_SIGKILL:
1368 case MOUNT_REMOUNTING_SIGKILL:
1369 case MOUNT_UNMOUNTING_SIGKILL:
1370 log_warning("%s mount process still around after SIGKILL. Ignoring.", u->id);
1372 if (m->from_proc_self_mountinfo)
1373 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1375 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1379 assert_not_reached("Timeout at wrong time.");
1383 static int mount_add_one(
1387 const char *options,
1394 char *e, *w = NULL, *o = NULL, *f = NULL;
1403 /* Ignore API mount points. They should never be referenced in
1404 * dependencies ever. */
1405 if (mount_point_is_api(where) || mount_point_ignore(where))
1408 if (streq(fstype, "autofs"))
1411 /* probably some kind of swap, ignore */
1412 if (!is_path(where))
1415 e = unit_name_from_path(where, ".mount");
1419 u = manager_get_unit(m, e);
1423 u = unit_new(m, sizeof(Mount));
1429 r = unit_add_name(u, e);
1435 MOUNT(u)->where = strdup(where);
1436 if (!MOUNT(u)->where) {
1441 unit_add_to_load_queue(u);
1446 if (u->load_state == UNIT_ERROR) {
1447 u->load_state = UNIT_LOADED;
1449 r = mount_add_extras(MOUNT(u));
1455 if (!(w = strdup(what)) ||
1456 !(o = strdup(options)) ||
1457 !(f = strdup(fstype))) {
1462 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1464 MOUNT(u)->is_mounted = true;
1465 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1466 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1469 MOUNT(u)->from_proc_self_mountinfo = true;
1482 unit_add_to_dbus_queue(u);
1497 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1500 char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1504 rewind(m->proc_self_mountinfo);
1509 device = path = options = options2 = fstype = d = p = o = NULL;
1511 if ((k = fscanf(m->proc_self_mountinfo,
1512 "%*s " /* (1) mount id */
1513 "%*s " /* (2) parent id */
1514 "%*s " /* (3) major:minor */
1515 "%*s " /* (4) root */
1516 "%ms " /* (5) mount point */
1517 "%ms" /* (6) mount options */
1518 "%*[^-]" /* (7) optional fields */
1519 "- " /* (8) separator */
1520 "%ms " /* (9) file system type */
1521 "%ms" /* (10) mount source */
1522 "%ms" /* (11) mount options 2 */
1523 "%*[^\n]", /* some rubbish at the end */
1533 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1537 o = join(options, ",", options2, NULL);
1543 if (!(d = cunescape(device)) ||
1544 !(p = cunescape(path))) {
1549 if ((k = mount_add_one(m, d, p, o, fstype, 0, set_flags)) < 0)
1576 static void mount_shutdown(Manager *m) {
1579 if (m->proc_self_mountinfo) {
1580 fclose(m->proc_self_mountinfo);
1581 m->proc_self_mountinfo = NULL;
1585 static int mount_enumerate(Manager *m) {
1587 struct epoll_event ev;
1590 if (!m->proc_self_mountinfo) {
1591 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1594 m->mount_watch.type = WATCH_MOUNT;
1595 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1598 ev.events = EPOLLPRI;
1599 ev.data.ptr = &m->mount_watch;
1601 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1605 if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1615 void mount_fd_event(Manager *m, int events) {
1620 assert(events & EPOLLPRI);
1622 /* The manager calls this for every fd event happening on the
1623 * /proc/self/mountinfo file, which informs us about mounting
1626 if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
1627 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1629 /* Reset flags, just in case, for later calls */
1630 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1631 Mount *mount = MOUNT(u);
1633 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1639 manager_dispatch_load_queue(m);
1641 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1642 Mount *mount = MOUNT(u);
1644 if (!mount->is_mounted) {
1645 /* This has just been unmounted. */
1647 mount->from_proc_self_mountinfo = false;
1649 switch (mount->state) {
1652 mount_enter_dead(mount, MOUNT_SUCCESS);
1656 mount_set_state(mount, mount->state);
1661 } else if (mount->just_mounted || mount->just_changed) {
1663 /* New or changed mount entry */
1665 switch (mount->state) {
1669 mount_enter_mounted(mount, MOUNT_SUCCESS);
1672 case MOUNT_MOUNTING:
1673 mount_enter_mounting_done(mount);
1677 /* Nothing really changed, but let's
1678 * issue an notification call
1679 * nonetheless, in case somebody is
1680 * waiting for this. (e.g. file system
1681 * ro/rw remounts.) */
1682 mount_set_state(mount, mount->state);
1687 /* Reset the flags for later calls */
1688 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1692 static void mount_reset_failed(Unit *u) {
1693 Mount *m = MOUNT(u);
1697 if (m->state == MOUNT_FAILED)
1698 mount_set_state(m, MOUNT_DEAD);
1700 m->result = MOUNT_SUCCESS;
1701 m->reload_result = MOUNT_SUCCESS;
1704 static int mount_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
1705 Mount *m = MOUNT(u);
1707 Set *pid_set = NULL;
1711 if (who == KILL_MAIN) {
1712 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1716 if (m->control_pid <= 0 && who == KILL_CONTROL) {
1717 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1721 if (who == KILL_CONTROL || who == KILL_ALL)
1722 if (m->control_pid > 0)
1723 if (kill(m->control_pid, signo) < 0)
1726 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
1729 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
1732 /* Exclude the control pid from being killed via the cgroup */
1733 if (m->control_pid > 0)
1734 if ((q = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0) {
1739 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, false, pid_set, NULL);
1741 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1752 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1753 [MOUNT_DEAD] = "dead",
1754 [MOUNT_MOUNTING] = "mounting",
1755 [MOUNT_MOUNTING_DONE] = "mounting-done",
1756 [MOUNT_MOUNTED] = "mounted",
1757 [MOUNT_REMOUNTING] = "remounting",
1758 [MOUNT_UNMOUNTING] = "unmounting",
1759 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1760 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1761 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1762 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1763 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1764 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1765 [MOUNT_FAILED] = "failed"
1768 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1770 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1771 [MOUNT_EXEC_MOUNT] = "ExecMount",
1772 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1773 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1776 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1778 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1779 [MOUNT_SUCCESS] = "success",
1780 [MOUNT_FAILURE_RESOURCES] = "resources",
1781 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1782 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1783 [MOUNT_FAILURE_SIGNAL] = "signal",
1784 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1787 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1789 const UnitVTable mount_vtable = {
1790 .object_size = sizeof(Mount),
1797 .no_instances = true,
1803 .coldplug = mount_coldplug,
1807 .start = mount_start,
1809 .reload = mount_reload,
1813 .serialize = mount_serialize,
1814 .deserialize_item = mount_deserialize_item,
1816 .active_state = mount_active_state,
1817 .sub_state_to_string = mount_sub_state_to_string,
1819 .check_gc = mount_check_gc,
1821 .sigchld_event = mount_sigchld_event,
1822 .timer_event = mount_timer_event,
1824 .reset_failed = mount_reset_failed,
1826 .bus_interface = "org.freedesktop.systemd1.Mount",
1827 .bus_message_handler = bus_mount_message_handler,
1828 .bus_invalidating_properties = bus_mount_invalidating_properties,
1830 .enumerate = mount_enumerate,
1831 .shutdown = mount_shutdown,
1833 .status_message_formats = {
1834 .starting_stopping = {
1835 [0] = "Mounting %s...",
1836 [1] = "Unmounting %s...",
1838 .finished_start_job = {
1839 [JOB_DONE] = "Mounted %s.",
1840 [JOB_FAILED] = "Failed to mount %s.",
1841 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1842 [JOB_TIMEOUT] = "Timed out mounting %s.",
1844 .finished_stop_job = {
1845 [JOB_DONE] = "Unmounted %s.",
1846 [JOB_FAILED] = "Failed unmounting %s.",
1847 [JOB_TIMEOUT] = "Timed out unmounting %s.",