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"
33 #include "sd-messages.h"
36 #include "path-util.h"
37 #include "mount-setup.h"
38 #include "unit-name.h"
39 #include "dbus-mount.h"
41 #include "bus-errors.h"
42 #include "exit-status.h"
45 static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
46 [MOUNT_DEAD] = UNIT_INACTIVE,
47 [MOUNT_MOUNTING] = UNIT_ACTIVATING,
48 [MOUNT_MOUNTING_DONE] = UNIT_ACTIVE,
49 [MOUNT_MOUNTED] = UNIT_ACTIVE,
50 [MOUNT_REMOUNTING] = UNIT_RELOADING,
51 [MOUNT_UNMOUNTING] = UNIT_DEACTIVATING,
52 [MOUNT_MOUNTING_SIGTERM] = UNIT_DEACTIVATING,
53 [MOUNT_MOUNTING_SIGKILL] = UNIT_DEACTIVATING,
54 [MOUNT_REMOUNTING_SIGTERM] = UNIT_RELOADING,
55 [MOUNT_REMOUNTING_SIGKILL] = UNIT_RELOADING,
56 [MOUNT_UNMOUNTING_SIGTERM] = UNIT_DEACTIVATING,
57 [MOUNT_UNMOUNTING_SIGKILL] = UNIT_DEACTIVATING,
58 [MOUNT_FAILED] = UNIT_FAILED
61 static void mount_init(Unit *u) {
65 assert(u->load_state == UNIT_STUB);
67 m->timeout_usec = DEFAULT_TIMEOUT_USEC;
68 m->directory_mode = 0755;
70 exec_context_init(&m->exec_context);
72 if (unit_has_name(u, "-.mount")) {
73 /* Don't allow start/stop for root directory */
74 UNIT(m)->refuse_manual_start = true;
75 UNIT(m)->refuse_manual_stop = true;
77 /* The stdio/kmsg bridge socket is on /, in order to avoid a
78 * dep loop, don't use kmsg logging for -.mount */
79 m->exec_context.std_output = u->manager->default_std_output;
80 m->exec_context.std_error = u->manager->default_std_error;
83 kill_context_init(&m->kill_context);
85 /* We need to make sure that /bin/mount is always called in
86 * the same process group as us, so that the autofs kernel
87 * side doesn't send us another mount request while we are
88 * already trying to comply its last one. */
89 m->exec_context.same_pgrp = true;
91 m->timer_watch.type = WATCH_INVALID;
93 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
95 UNIT(m)->ignore_on_isolate = true;
98 static void mount_unwatch_control_pid(Mount *m) {
101 if (m->control_pid <= 0)
104 unit_unwatch_pid(UNIT(m), m->control_pid);
108 static void mount_parameters_done(MountParameters *p) {
115 p->what = p->options = p->fstype = NULL;
118 static void mount_done(Unit *u) {
126 mount_parameters_done(&m->parameters_proc_self_mountinfo);
127 mount_parameters_done(&m->parameters_fragment);
129 exec_context_done(&m->exec_context);
130 exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
131 m->control_command = NULL;
133 mount_unwatch_control_pid(m);
135 unit_unwatch_timer(u, &m->timer_watch);
138 static MountParameters* get_mount_parameters_fragment(Mount *m) {
141 if (m->from_fragment)
142 return &m->parameters_fragment;
147 static MountParameters* get_mount_parameters(Mount *m) {
150 if (m->from_proc_self_mountinfo)
151 return &m->parameters_proc_self_mountinfo;
153 return get_mount_parameters_fragment(m);
156 static int mount_add_mount_links(Mount *m) {
163 pm = get_mount_parameters_fragment(m);
165 /* Adds in links to other mount points that might lie below or
166 * above us in the hierarchy */
168 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_MOUNT]) {
169 Mount *n = MOUNT(other);
175 if (UNIT(n)->load_state != UNIT_LOADED)
178 pn = get_mount_parameters_fragment(n);
180 if (path_startswith(m->where, n->where)) {
182 if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, UNIT(n), true)) < 0)
186 if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, UNIT(n), true)) < 0)
189 } else if (path_startswith(n->where, m->where)) {
191 if ((r = unit_add_dependency(UNIT(n), UNIT_AFTER, UNIT(m), true)) < 0)
195 if ((r = unit_add_dependency(UNIT(n), UNIT_REQUIRES, UNIT(m), true)) < 0)
198 } else if (pm && pm->what && path_startswith(pm->what, n->where)) {
200 if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, UNIT(n), true)) < 0)
203 if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, UNIT(n), true)) < 0)
206 } else if (pn && pn->what && path_startswith(pn->what, m->where)) {
208 if ((r = unit_add_dependency(UNIT(n), UNIT_AFTER, UNIT(m), true)) < 0)
211 if ((r = unit_add_dependency(UNIT(n), UNIT_REQUIRES, UNIT(m), true)) < 0)
219 static int mount_add_swap_links(Mount *m) {
225 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_SWAP]) {
226 r = swap_add_one_mount_link(SWAP(other), m);
234 static int mount_add_path_links(Mount *m) {
240 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_PATH]) {
241 r = path_add_one_mount_link(PATH(other), m);
249 static int mount_add_automount_links(Mount *m) {
255 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_AUTOMOUNT]) {
256 r = automount_add_one_mount_link(AUTOMOUNT(other), m);
264 static int mount_add_socket_links(Mount *m) {
270 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_SOCKET]) {
271 r = socket_add_one_mount_link(SOCKET(other), m);
279 static int mount_add_requires_mounts_links(Mount *m) {
285 LIST_FOREACH(has_requires_mounts_for, other, UNIT(m)->manager->has_requires_mounts_for) {
286 r = unit_add_one_mount_link(other, m);
294 static char* mount_test_option(const char *haystack, const char *needle) {
299 /* Like glibc's hasmntopt(), but works on a string, not a
306 me.mnt_opts = (char*) haystack;
308 return hasmntopt(&me, needle);
311 static bool mount_is_network(MountParameters *p) {
314 if (mount_test_option(p->options, "_netdev"))
317 if (p->fstype && fstype_is_network(p->fstype))
323 static bool mount_is_bind(MountParameters *p) {
326 if (mount_test_option(p->options, "bind"))
329 if (p->fstype && streq(p->fstype, "bind"))
332 if (mount_test_option(p->options, "rbind"))
335 if (p->fstype && streq(p->fstype, "rbind"))
341 static bool needs_quota(MountParameters *p) {
344 if (mount_is_network(p))
347 if (mount_is_bind(p))
350 return mount_test_option(p->options, "usrquota") ||
351 mount_test_option(p->options, "grpquota") ||
352 mount_test_option(p->options, "quota") ||
353 mount_test_option(p->options, "usrjquota") ||
354 mount_test_option(p->options, "grpjquota");
357 static int mount_add_device_links(Mount *m) {
363 p = get_mount_parameters_fragment(m);
370 if (mount_is_bind(p))
373 if (!is_device_path(p->what))
376 if (path_equal(m->where, "/"))
379 r = unit_add_node_link(UNIT(m), p->what, false);
384 UNIT(m)->manager->running_as == SYSTEMD_SYSTEM) {
387 /* Let's add in the fsck service */
389 /* aka SPECIAL_FSCK_SERVICE */
390 name = unit_name_from_path_instance("systemd-fsck", p->what, ".service");
394 r = manager_load_unit_prepare(UNIT(m)->manager, name, NULL, NULL, &fsck);
396 log_warning_unit(name,
397 "Failed to prepare unit %s: %s", name, strerror(-r));
403 SERVICE(fsck)->fsck_passno = p->passno;
405 r = unit_add_two_dependencies(UNIT(m), UNIT_AFTER, UNIT_REQUIRES, fsck, true);
413 static int mount_add_quota_links(Mount *m) {
419 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
422 p = get_mount_parameters_fragment(m);
429 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true);
433 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true);
440 static int mount_add_default_dependencies(Mount *m) {
447 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
450 p = get_mount_parameters(m);
455 if (path_equal(m->where, "/"))
458 if (mount_is_network(p))
459 after = SPECIAL_REMOTE_FS_PRE_TARGET;
461 after = SPECIAL_LOCAL_FS_PRE_TARGET;
463 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, after, NULL, true);
467 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
474 static int mount_fix_timeouts(Mount *m) {
476 const char *timeout = NULL;
485 p = get_mount_parameters_fragment(m);
489 /* Allow configuration how long we wait for a device that
490 * backs a mount point to show up. This is useful to support
491 * endless device timeouts for devices that show up only after
492 * user input, like crypto devices. */
494 if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
496 else if ((timeout = mount_test_option(p->options, "x-systemd.device-timeout")))
501 t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
505 r = parse_usec(t, &u);
509 log_warning_unit(UNIT(m)->id,
510 "Failed to parse timeout for %s, ignoring: %s",
515 SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
516 if (other->type != UNIT_DEVICE)
519 other->job_timeout = u;
525 static int mount_verify(Mount *m) {
530 if (UNIT(m)->load_state != UNIT_LOADED)
533 if (!m->from_fragment && !m->from_proc_self_mountinfo)
536 if (!(e = unit_name_from_path(m->where, ".mount")))
539 b = unit_has_name(UNIT(m), e);
543 log_error_unit(UNIT(m)->id,
544 "%s's Where setting doesn't match unit name. Refusing.",
549 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
550 log_error_unit(UNIT(m)->id,
551 "Cannot create mount unit for API file system %s. Refusing.",
556 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
557 log_error_unit(UNIT(m)->id,
558 "%s's What setting is missing. Refusing.", UNIT(m)->id);
562 if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
563 log_error_unit(UNIT(m)->id,
564 "%s has PAM enabled. Kill mode must be set to control-group'. Refusing.",
572 static int mount_add_extras(Mount *m) {
576 if (UNIT(m)->fragment_path)
577 m->from_fragment = true;
580 m->where = unit_name_to_path(u->id);
585 path_kill_slashes(m->where);
587 r = unit_add_exec_dependencies(u, &m->exec_context);
591 if (!UNIT(m)->description) {
592 r = unit_set_description(u, m->where);
597 r = mount_add_device_links(m);
601 r = mount_add_mount_links(m);
605 r = mount_add_socket_links(m);
609 r = mount_add_swap_links(m);
613 r = mount_add_path_links(m);
617 r = mount_add_requires_mounts_links(m);
621 r = mount_add_automount_links(m);
625 r = mount_add_quota_links(m);
629 if (UNIT(m)->default_dependencies) {
630 r = mount_add_default_dependencies(m);
635 r = unit_add_default_cgroups(u);
639 r = mount_fix_timeouts(m);
646 static int mount_load(Unit *u) {
651 assert(u->load_state == UNIT_STUB);
653 if (m->from_proc_self_mountinfo)
654 r = unit_load_fragment_and_dropin_optional(u);
656 r = unit_load_fragment_and_dropin(u);
661 /* This is a new unit? Then let's add in some extras */
662 if (u->load_state == UNIT_LOADED) {
663 r = mount_add_extras(m);
667 r = unit_exec_context_defaults(u, &m->exec_context);
672 return mount_verify(m);
675 static int mount_notify_automount(Mount *m, int status) {
682 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
683 if (p->type == UNIT_AUTOMOUNT) {
684 r = automount_send_ready(AUTOMOUNT(p), status);
692 static void mount_set_state(Mount *m, MountState state) {
693 MountState old_state;
696 old_state = m->state;
699 if (state != MOUNT_MOUNTING &&
700 state != MOUNT_MOUNTING_DONE &&
701 state != MOUNT_REMOUNTING &&
702 state != MOUNT_UNMOUNTING &&
703 state != MOUNT_MOUNTING_SIGTERM &&
704 state != MOUNT_MOUNTING_SIGKILL &&
705 state != MOUNT_UNMOUNTING_SIGTERM &&
706 state != MOUNT_UNMOUNTING_SIGKILL &&
707 state != MOUNT_REMOUNTING_SIGTERM &&
708 state != MOUNT_REMOUNTING_SIGKILL) {
709 unit_unwatch_timer(UNIT(m), &m->timer_watch);
710 mount_unwatch_control_pid(m);
711 m->control_command = NULL;
712 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
715 if (state == MOUNT_MOUNTED ||
716 state == MOUNT_REMOUNTING)
717 mount_notify_automount(m, 0);
718 else if (state == MOUNT_DEAD ||
719 state == MOUNT_UNMOUNTING ||
720 state == MOUNT_MOUNTING_SIGTERM ||
721 state == MOUNT_MOUNTING_SIGKILL ||
722 state == MOUNT_REMOUNTING_SIGTERM ||
723 state == MOUNT_REMOUNTING_SIGKILL ||
724 state == MOUNT_UNMOUNTING_SIGTERM ||
725 state == MOUNT_UNMOUNTING_SIGKILL ||
726 state == MOUNT_FAILED) {
727 if (state != old_state)
728 mount_notify_automount(m, -ENODEV);
731 if (state != old_state)
732 log_debug_unit(UNIT(m)->id,
733 "%s changed %s -> %s",
735 mount_state_to_string(old_state),
736 mount_state_to_string(state));
738 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
739 m->reload_result = MOUNT_SUCCESS;
742 static int mount_coldplug(Unit *u) {
744 MountState new_state = MOUNT_DEAD;
748 assert(m->state == MOUNT_DEAD);
750 if (m->deserialized_state != m->state)
751 new_state = m->deserialized_state;
752 else if (m->from_proc_self_mountinfo)
753 new_state = MOUNT_MOUNTED;
755 if (new_state != m->state) {
757 if (new_state == MOUNT_MOUNTING ||
758 new_state == MOUNT_MOUNTING_DONE ||
759 new_state == MOUNT_REMOUNTING ||
760 new_state == MOUNT_UNMOUNTING ||
761 new_state == MOUNT_MOUNTING_SIGTERM ||
762 new_state == MOUNT_MOUNTING_SIGKILL ||
763 new_state == MOUNT_UNMOUNTING_SIGTERM ||
764 new_state == MOUNT_UNMOUNTING_SIGKILL ||
765 new_state == MOUNT_REMOUNTING_SIGTERM ||
766 new_state == MOUNT_REMOUNTING_SIGKILL) {
768 if (m->control_pid <= 0)
771 r = unit_watch_pid(UNIT(m), m->control_pid);
775 r = unit_watch_timer(UNIT(m), CLOCK_MONOTONIC, true, m->timeout_usec, &m->timer_watch);
780 mount_set_state(m, new_state);
786 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
793 p = get_mount_parameters(m);
796 "%sMount State: %s\n"
800 "%sFile System Type: %s\n"
802 "%sFrom /proc/self/mountinfo: %s\n"
803 "%sFrom fragment: %s\n"
804 "%sDirectoryMode: %04o\n",
805 prefix, mount_state_to_string(m->state),
806 prefix, mount_result_to_string(m->result),
808 prefix, strna(p->what),
809 prefix, strna(p->fstype),
810 prefix, strna(p->options),
811 prefix, yes_no(m->from_proc_self_mountinfo),
812 prefix, yes_no(m->from_fragment),
813 prefix, m->directory_mode);
815 if (m->control_pid > 0)
817 "%sControl PID: %lu\n",
818 prefix, (unsigned long) m->control_pid);
820 exec_context_dump(&m->exec_context, f, prefix);
821 kill_context_dump(&m->kill_context, f, prefix);
824 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
832 r = unit_watch_timer(UNIT(m), CLOCK_MONOTONIC, true, m->timeout_usec, &m->timer_watch);
836 if ((r = exec_spawn(c,
840 UNIT(m)->manager->environment,
844 UNIT(m)->manager->confirm_spawn,
845 UNIT(m)->cgroup_bondings,
846 UNIT(m)->cgroup_attributes,
853 if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
854 /* FIXME: we need to do something here */
862 unit_unwatch_timer(UNIT(m), &m->timer_watch);
867 static void mount_enter_dead(Mount *m, MountResult f) {
870 if (f != MOUNT_SUCCESS)
873 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
876 static void mount_enter_mounted(Mount *m, MountResult f) {
879 if (f != MOUNT_SUCCESS)
882 mount_set_state(m, MOUNT_MOUNTED);
885 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
890 if (f != MOUNT_SUCCESS)
893 r = unit_kill_context(
896 state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM,
904 r = unit_watch_timer(UNIT(m), CLOCK_MONOTONIC, true, m->timeout_usec, &m->timer_watch);
908 mount_set_state(m, state);
909 } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
910 mount_enter_mounted(m, MOUNT_SUCCESS);
912 mount_enter_dead(m, MOUNT_SUCCESS);
917 log_warning_unit(UNIT(m)->id,
918 "%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
920 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
921 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
923 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
926 void warn_if_dir_nonempty(const char *unit, const char* where) {
930 if (dir_is_empty(where) > 0)
933 log_struct_unit(LOG_NOTICE,
935 "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
938 MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
942 static void mount_enter_unmounting(Mount *m) {
947 m->control_command_id = MOUNT_EXEC_UNMOUNT;
948 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
950 if ((r = exec_command_set(
957 mount_unwatch_control_pid(m);
959 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
962 mount_set_state(m, MOUNT_UNMOUNTING);
967 log_warning_unit(UNIT(m)->id,
968 "%s failed to run 'umount' task: %s",
969 UNIT(m)->id, strerror(-r));
970 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
973 static void mount_enter_mounting(Mount *m) {
979 m->control_command_id = MOUNT_EXEC_MOUNT;
980 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
982 mkdir_p_label(m->where, m->directory_mode);
984 warn_if_dir_nonempty(m->meta.id, m->where);
986 /* Create the source directory for bind-mounts if needed */
987 p = get_mount_parameters_fragment(m);
988 if (p && mount_is_bind(p))
989 mkdir_p_label(p->what, m->directory_mode);
991 if (m->from_fragment)
992 r = exec_command_set(
995 m->parameters_fragment.what,
997 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
998 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
1006 mount_unwatch_control_pid(m);
1008 r = mount_spawn(m, m->control_command, &m->control_pid);
1012 mount_set_state(m, MOUNT_MOUNTING);
1017 log_warning_unit(UNIT(m)->id,
1018 "%s failed to run 'mount' task: %s",
1019 UNIT(m)->id, strerror(-r));
1020 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
1023 static void mount_enter_mounting_done(Mount *m) {
1026 mount_set_state(m, MOUNT_MOUNTING_DONE);
1029 static void mount_enter_remounting(Mount *m) {
1034 m->control_command_id = MOUNT_EXEC_REMOUNT;
1035 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1037 if (m->from_fragment) {
1041 if (m->parameters_fragment.options) {
1042 if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
1051 r = exec_command_set(
1054 m->parameters_fragment.what,
1056 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
1067 mount_unwatch_control_pid(m);
1069 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1072 mount_set_state(m, MOUNT_REMOUNTING);
1077 log_warning_unit(UNIT(m)->id,
1078 "%s failed to run 'remount' task: %s",
1079 UNIT(m)->id, strerror(-r));
1080 m->reload_result = MOUNT_FAILURE_RESOURCES;
1081 mount_enter_mounted(m, MOUNT_SUCCESS);
1084 static int mount_start(Unit *u) {
1085 Mount *m = MOUNT(u);
1089 /* We cannot fulfill this request right now, try again later
1091 if (m->state == MOUNT_UNMOUNTING ||
1092 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1093 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1094 m->state == MOUNT_MOUNTING_SIGTERM ||
1095 m->state == MOUNT_MOUNTING_SIGKILL)
1098 /* Already on it! */
1099 if (m->state == MOUNT_MOUNTING)
1102 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1104 m->result = MOUNT_SUCCESS;
1105 m->reload_result = MOUNT_SUCCESS;
1107 mount_enter_mounting(m);
1111 static int mount_stop(Unit *u) {
1112 Mount *m = MOUNT(u);
1117 if (m->state == MOUNT_UNMOUNTING ||
1118 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1119 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1120 m->state == MOUNT_MOUNTING_SIGTERM ||
1121 m->state == MOUNT_MOUNTING_SIGKILL)
1124 assert(m->state == MOUNT_MOUNTING ||
1125 m->state == MOUNT_MOUNTING_DONE ||
1126 m->state == MOUNT_MOUNTED ||
1127 m->state == MOUNT_REMOUNTING ||
1128 m->state == MOUNT_REMOUNTING_SIGTERM ||
1129 m->state == MOUNT_REMOUNTING_SIGKILL);
1131 mount_enter_unmounting(m);
1135 static int mount_reload(Unit *u) {
1136 Mount *m = MOUNT(u);
1140 if (m->state == MOUNT_MOUNTING_DONE)
1143 assert(m->state == MOUNT_MOUNTED);
1145 mount_enter_remounting(m);
1149 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1150 Mount *m = MOUNT(u);
1156 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1157 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1158 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1160 if (m->control_pid > 0)
1161 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1163 if (m->control_command_id >= 0)
1164 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1169 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1170 Mount *m = MOUNT(u);
1177 if (streq(key, "state")) {
1180 if ((state = mount_state_from_string(value)) < 0)
1181 log_debug_unit(u->id, "Failed to parse state value %s", value);
1183 m->deserialized_state = state;
1184 } else if (streq(key, "result")) {
1187 f = mount_result_from_string(value);
1189 log_debug_unit(UNIT(m)->id,
1190 "Failed to parse result value %s", value);
1191 else if (f != MOUNT_SUCCESS)
1194 } else if (streq(key, "reload-result")) {
1197 f = mount_result_from_string(value);
1199 log_debug_unit(UNIT(m)->id,
1200 "Failed to parse reload result value %s", value);
1201 else if (f != MOUNT_SUCCESS)
1202 m->reload_result = f;
1204 } else if (streq(key, "control-pid")) {
1207 if (parse_pid(value, &pid) < 0)
1208 log_debug_unit(UNIT(m)->id,
1209 "Failed to parse control-pid value %s", value);
1211 m->control_pid = pid;
1212 } else if (streq(key, "control-command")) {
1213 MountExecCommand id;
1215 if ((id = mount_exec_command_from_string(value)) < 0)
1216 log_debug_unit(UNIT(m)->id,
1217 "Failed to parse exec-command value %s", value);
1219 m->control_command_id = id;
1220 m->control_command = m->exec_command + id;
1224 log_debug_unit(UNIT(m)->id,
1225 "Unknown serialization key '%s'", key);
1230 static UnitActiveState mount_active_state(Unit *u) {
1233 return state_translation_table[MOUNT(u)->state];
1236 static const char *mount_sub_state_to_string(Unit *u) {
1239 return mount_state_to_string(MOUNT(u)->state);
1242 static bool mount_check_gc(Unit *u) {
1243 Mount *m = MOUNT(u);
1247 return m->from_proc_self_mountinfo;
1250 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1251 Mount *m = MOUNT(u);
1257 if (pid != m->control_pid)
1262 if (is_clean_exit(code, status, NULL))
1264 else if (code == CLD_EXITED)
1265 f = MOUNT_FAILURE_EXIT_CODE;
1266 else if (code == CLD_KILLED)
1267 f = MOUNT_FAILURE_SIGNAL;
1268 else if (code == CLD_DUMPED)
1269 f = MOUNT_FAILURE_CORE_DUMP;
1271 assert_not_reached("Unknown code");
1273 if (f != MOUNT_SUCCESS)
1276 if (m->control_command) {
1277 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1279 m->control_command = NULL;
1280 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1283 log_full_unit(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
1284 "%s mount process exited, code=%s status=%i",
1285 u->id, sigchld_code_to_string(code), status);
1287 /* Note that mount(8) returning and the kernel sending us a
1288 * mount table change event might happen out-of-order. If an
1289 * operation succeed we assume the kernel will follow soon too
1290 * and already change into the resulting state. If it fails
1291 * we check if the kernel still knows about the mount. and
1292 * change state accordingly. */
1296 case MOUNT_MOUNTING:
1297 case MOUNT_MOUNTING_DONE:
1298 case MOUNT_MOUNTING_SIGKILL:
1299 case MOUNT_MOUNTING_SIGTERM:
1301 if (f == MOUNT_SUCCESS)
1302 mount_enter_mounted(m, f);
1303 else if (m->from_proc_self_mountinfo)
1304 mount_enter_mounted(m, f);
1306 mount_enter_dead(m, f);
1309 case MOUNT_REMOUNTING:
1310 case MOUNT_REMOUNTING_SIGKILL:
1311 case MOUNT_REMOUNTING_SIGTERM:
1313 m->reload_result = f;
1314 if (m->from_proc_self_mountinfo)
1315 mount_enter_mounted(m, MOUNT_SUCCESS);
1317 mount_enter_dead(m, MOUNT_SUCCESS);
1321 case MOUNT_UNMOUNTING:
1322 case MOUNT_UNMOUNTING_SIGKILL:
1323 case MOUNT_UNMOUNTING_SIGTERM:
1325 if (f == MOUNT_SUCCESS)
1326 mount_enter_dead(m, f);
1327 else if (m->from_proc_self_mountinfo)
1328 mount_enter_mounted(m, f);
1330 mount_enter_dead(m, f);
1334 assert_not_reached("Uh, control process died at wrong time.");
1337 /* Notify clients about changed exit status */
1338 unit_add_to_dbus_queue(u);
1341 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1342 Mount *m = MOUNT(u);
1345 assert(elapsed == 1);
1346 assert(w == &m->timer_watch);
1350 case MOUNT_MOUNTING:
1351 case MOUNT_MOUNTING_DONE:
1352 log_warning_unit(u->id,
1353 "%s mounting timed out. Stopping.", u->id);
1354 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1357 case MOUNT_REMOUNTING:
1358 log_warning_unit(u->id,
1359 "%s remounting timed out. Stopping.", u->id);
1360 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1361 mount_enter_mounted(m, MOUNT_SUCCESS);
1364 case MOUNT_UNMOUNTING:
1365 log_warning_unit(u->id,
1366 "%s unmounting timed out. Stopping.", u->id);
1367 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1370 case MOUNT_MOUNTING_SIGTERM:
1371 if (m->kill_context.send_sigkill) {
1372 log_warning_unit(u->id,
1373 "%s mounting timed out. Killing.", u->id);
1374 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1376 log_warning_unit(u->id,
1377 "%s mounting timed out. Skipping SIGKILL. Ignoring.",
1380 if (m->from_proc_self_mountinfo)
1381 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1383 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1387 case MOUNT_REMOUNTING_SIGTERM:
1388 if (m->kill_context.send_sigkill) {
1389 log_warning_unit(u->id,
1390 "%s remounting timed out. Killing.", u->id);
1391 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1393 log_warning_unit(u->id,
1394 "%s remounting timed out. Skipping SIGKILL. Ignoring.",
1397 if (m->from_proc_self_mountinfo)
1398 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1400 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1404 case MOUNT_UNMOUNTING_SIGTERM:
1405 if (m->kill_context.send_sigkill) {
1406 log_warning_unit(u->id,
1407 "%s unmounting timed out. Killing.", u->id);
1408 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1410 log_warning_unit(u->id,
1411 "%s unmounting timed out. Skipping SIGKILL. Ignoring.",
1414 if (m->from_proc_self_mountinfo)
1415 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1417 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1421 case MOUNT_MOUNTING_SIGKILL:
1422 case MOUNT_REMOUNTING_SIGKILL:
1423 case MOUNT_UNMOUNTING_SIGKILL:
1424 log_warning_unit(u->id,
1425 "%s mount process still around after SIGKILL. Ignoring.",
1428 if (m->from_proc_self_mountinfo)
1429 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1431 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1435 assert_not_reached("Timeout at wrong time.");
1439 static int mount_add_one(
1443 const char *options,
1450 char *e, *w = NULL, *o = NULL, *f = NULL;
1452 bool load_extras = false;
1460 /* Ignore API mount points. They should never be referenced in
1461 * dependencies ever. */
1462 if (mount_point_is_api(where) || mount_point_ignore(where))
1465 if (streq(fstype, "autofs"))
1468 /* probably some kind of swap, ignore */
1469 if (!is_path(where))
1472 e = unit_name_from_path(where, ".mount");
1476 u = manager_get_unit(m, e);
1480 u = unit_new(m, sizeof(Mount));
1486 r = unit_add_name(u, e);
1492 MOUNT(u)->where = strdup(where);
1493 if (!MOUNT(u)->where) {
1498 u->source_path = strdup("/proc/self/mountinfo");
1499 if (!u->source_path) {
1504 unit_add_to_load_queue(u);
1509 if (!MOUNT(u)->where) {
1510 MOUNT(u)->where = strdup(where);
1511 if (!MOUNT(u)->where) {
1517 if (u->load_state == UNIT_ERROR) {
1518 u->load_state = UNIT_LOADED;
1521 /* Load in the extras later on, after we
1522 * finished initialization of the unit */
1527 if (!(w = strdup(what)) ||
1528 !(o = strdup(options)) ||
1529 !(f = strdup(fstype))) {
1534 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1536 MOUNT(u)->is_mounted = true;
1537 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1538 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1541 MOUNT(u)->from_proc_self_mountinfo = true;
1555 r = mount_add_extras(MOUNT(u));
1560 unit_add_to_dbus_queue(u);
1575 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1578 char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1582 rewind(m->proc_self_mountinfo);
1587 device = path = options = options2 = fstype = d = p = o = NULL;
1589 if ((k = fscanf(m->proc_self_mountinfo,
1590 "%*s " /* (1) mount id */
1591 "%*s " /* (2) parent id */
1592 "%*s " /* (3) major:minor */
1593 "%*s " /* (4) root */
1594 "%ms " /* (5) mount point */
1595 "%ms" /* (6) mount options */
1596 "%*[^-]" /* (7) optional fields */
1597 "- " /* (8) separator */
1598 "%ms " /* (9) file system type */
1599 "%ms" /* (10) mount source */
1600 "%ms" /* (11) mount options 2 */
1601 "%*[^\n]", /* some rubbish at the end */
1611 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1615 o = strjoin(options, ",", options2, NULL);
1621 if (!(d = cunescape(device)) ||
1622 !(p = cunescape(path))) {
1627 if ((k = mount_add_one(m, d, p, o, fstype, 0, set_flags)) < 0)
1654 static void mount_shutdown(Manager *m) {
1657 if (m->proc_self_mountinfo) {
1658 fclose(m->proc_self_mountinfo);
1659 m->proc_self_mountinfo = NULL;
1663 static int mount_enumerate(Manager *m) {
1665 struct epoll_event ev;
1668 if (!m->proc_self_mountinfo) {
1669 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1672 m->mount_watch.type = WATCH_MOUNT;
1673 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1676 ev.events = EPOLLPRI;
1677 ev.data.ptr = &m->mount_watch;
1679 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1683 if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1693 void mount_fd_event(Manager *m, int events) {
1698 assert(events & EPOLLPRI);
1700 /* The manager calls this for every fd event happening on the
1701 * /proc/self/mountinfo file, which informs us about mounting
1704 r = mount_load_proc_self_mountinfo(m, true);
1706 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1708 /* Reset flags, just in case, for later calls */
1709 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1710 Mount *mount = MOUNT(u);
1712 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1718 manager_dispatch_load_queue(m);
1720 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1721 Mount *mount = MOUNT(u);
1723 if (!mount->is_mounted) {
1724 /* This has just been unmounted. */
1726 mount->from_proc_self_mountinfo = false;
1728 switch (mount->state) {
1731 mount_enter_dead(mount, MOUNT_SUCCESS);
1735 mount_set_state(mount, mount->state);
1740 } else if (mount->just_mounted || mount->just_changed) {
1742 /* New or changed mount entry */
1744 switch (mount->state) {
1748 mount_enter_mounted(mount, MOUNT_SUCCESS);
1751 case MOUNT_MOUNTING:
1752 mount_enter_mounting_done(mount);
1756 /* Nothing really changed, but let's
1757 * issue an notification call
1758 * nonetheless, in case somebody is
1759 * waiting for this. (e.g. file system
1760 * ro/rw remounts.) */
1761 mount_set_state(mount, mount->state);
1766 /* Reset the flags for later calls */
1767 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1771 static void mount_reset_failed(Unit *u) {
1772 Mount *m = MOUNT(u);
1776 if (m->state == MOUNT_FAILED)
1777 mount_set_state(m, MOUNT_DEAD);
1779 m->result = MOUNT_SUCCESS;
1780 m->reload_result = MOUNT_SUCCESS;
1783 static int mount_kill(Unit *u, KillWho who, int signo, DBusError *error) {
1784 Mount *m = MOUNT(u);
1786 Set *pid_set = NULL;
1790 if (who == KILL_MAIN) {
1791 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1795 if (m->control_pid <= 0 && who == KILL_CONTROL) {
1796 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1800 if (who == KILL_CONTROL || who == KILL_ALL)
1801 if (m->control_pid > 0)
1802 if (kill(m->control_pid, signo) < 0)
1805 if (who == KILL_ALL) {
1808 pid_set = set_new(trivial_hash_func, trivial_compare_func);
1812 /* Exclude the control pid from being killed via the cgroup */
1813 if (m->control_pid > 0) {
1814 q = set_put(pid_set, LONG_TO_PTR(m->control_pid));
1821 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, false, pid_set, NULL);
1822 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1833 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1834 [MOUNT_DEAD] = "dead",
1835 [MOUNT_MOUNTING] = "mounting",
1836 [MOUNT_MOUNTING_DONE] = "mounting-done",
1837 [MOUNT_MOUNTED] = "mounted",
1838 [MOUNT_REMOUNTING] = "remounting",
1839 [MOUNT_UNMOUNTING] = "unmounting",
1840 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1841 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1842 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1843 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1844 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1845 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1846 [MOUNT_FAILED] = "failed"
1849 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1851 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1852 [MOUNT_EXEC_MOUNT] = "ExecMount",
1853 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1854 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1857 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1859 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1860 [MOUNT_SUCCESS] = "success",
1861 [MOUNT_FAILURE_RESOURCES] = "resources",
1862 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1863 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1864 [MOUNT_FAILURE_SIGNAL] = "signal",
1865 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1868 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1870 const UnitVTable mount_vtable = {
1871 .object_size = sizeof(Mount),
1878 .exec_context_offset = offsetof(Mount, exec_context),
1879 .exec_section = "Mount",
1882 .no_instances = true,
1888 .coldplug = mount_coldplug,
1892 .start = mount_start,
1894 .reload = mount_reload,
1898 .serialize = mount_serialize,
1899 .deserialize_item = mount_deserialize_item,
1901 .active_state = mount_active_state,
1902 .sub_state_to_string = mount_sub_state_to_string,
1904 .check_gc = mount_check_gc,
1906 .sigchld_event = mount_sigchld_event,
1907 .timer_event = mount_timer_event,
1909 .reset_failed = mount_reset_failed,
1911 .bus_interface = "org.freedesktop.systemd1.Mount",
1912 .bus_message_handler = bus_mount_message_handler,
1913 .bus_invalidating_properties = bus_mount_invalidating_properties,
1915 .enumerate = mount_enumerate,
1916 .shutdown = mount_shutdown,
1918 .status_message_formats = {
1919 .starting_stopping = {
1920 [0] = "Mounting %s...",
1921 [1] = "Unmounting %s...",
1923 .finished_start_job = {
1924 [JOB_DONE] = "Mounted %s.",
1925 [JOB_FAILED] = "Failed to mount %s.",
1926 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1927 [JOB_TIMEOUT] = "Timed out mounting %s.",
1929 .finished_stop_job = {
1930 [JOB_DONE] = "Unmounted %s.",
1931 [JOB_FAILED] = "Failed unmounting %s.",
1932 [JOB_TIMEOUT] = "Timed out unmounting %s.",