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_fragment(m);
454 if (path_equal(m->where, "/"))
457 if (mount_is_network(p))
458 after = SPECIAL_REMOTE_FS_PRE_TARGET;
460 after = SPECIAL_LOCAL_FS_PRE_TARGET;
462 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, after, NULL, true);
466 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
473 static int mount_fix_timeouts(Mount *m) {
475 const char *timeout = NULL;
484 p = get_mount_parameters_fragment(m);
488 /* Allow configuration how long we wait for a device that
489 * backs a mount point to show up. This is useful to support
490 * endless device timeouts for devices that show up only after
491 * user input, like crypto devices. */
493 if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
495 else if ((timeout = mount_test_option(p->options, "x-systemd.device-timeout")))
500 t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
504 r = parse_usec(t, &u);
508 log_warning_unit(UNIT(m)->id,
509 "Failed to parse timeout for %s, ignoring: %s",
514 SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
515 if (other->type != UNIT_DEVICE)
518 other->job_timeout = u;
524 static int mount_verify(Mount *m) {
529 if (UNIT(m)->load_state != UNIT_LOADED)
532 if (!m->from_fragment && !m->from_proc_self_mountinfo)
535 if (!(e = unit_name_from_path(m->where, ".mount")))
538 b = unit_has_name(UNIT(m), e);
542 log_error_unit(UNIT(m)->id,
543 "%s's Where setting doesn't match unit name. Refusing.",
548 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
549 log_error_unit(UNIT(m)->id,
550 "Cannot create mount unit for API file system %s. Refusing.",
555 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
556 log_error_unit(UNIT(m)->id,
557 "%s's What setting is missing. Refusing.", UNIT(m)->id);
561 if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
562 log_error_unit(UNIT(m)->id,
563 "%s has PAM enabled. Kill mode must be set to control-group'. Refusing.",
571 static int mount_add_extras(Mount *m) {
575 if (UNIT(m)->fragment_path)
576 m->from_fragment = true;
579 m->where = unit_name_to_path(u->id);
584 path_kill_slashes(m->where);
586 r = unit_add_exec_dependencies(u, &m->exec_context);
590 if (!UNIT(m)->description) {
591 r = unit_set_description(u, m->where);
596 r = mount_add_device_links(m);
600 r = mount_add_mount_links(m);
604 r = mount_add_socket_links(m);
608 r = mount_add_swap_links(m);
612 r = mount_add_path_links(m);
616 r = mount_add_requires_mounts_links(m);
620 r = mount_add_automount_links(m);
624 r = mount_add_quota_links(m);
628 if (UNIT(m)->default_dependencies) {
629 r = mount_add_default_dependencies(m);
634 r = unit_add_default_cgroups(u);
638 r = mount_fix_timeouts(m);
645 static int mount_load(Unit *u) {
650 assert(u->load_state == UNIT_STUB);
652 if (m->from_proc_self_mountinfo)
653 r = unit_load_fragment_and_dropin_optional(u);
655 r = unit_load_fragment_and_dropin(u);
660 /* This is a new unit? Then let's add in some extras */
661 if (u->load_state == UNIT_LOADED) {
662 r = mount_add_extras(m);
666 r = unit_exec_context_defaults(u, &m->exec_context);
671 return mount_verify(m);
674 static int mount_notify_automount(Mount *m, int status) {
681 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
682 if (p->type == UNIT_AUTOMOUNT) {
683 r = automount_send_ready(AUTOMOUNT(p), status);
691 static void mount_set_state(Mount *m, MountState state) {
692 MountState old_state;
695 old_state = m->state;
698 if (state != MOUNT_MOUNTING &&
699 state != MOUNT_MOUNTING_DONE &&
700 state != MOUNT_REMOUNTING &&
701 state != MOUNT_UNMOUNTING &&
702 state != MOUNT_MOUNTING_SIGTERM &&
703 state != MOUNT_MOUNTING_SIGKILL &&
704 state != MOUNT_UNMOUNTING_SIGTERM &&
705 state != MOUNT_UNMOUNTING_SIGKILL &&
706 state != MOUNT_REMOUNTING_SIGTERM &&
707 state != MOUNT_REMOUNTING_SIGKILL) {
708 unit_unwatch_timer(UNIT(m), &m->timer_watch);
709 mount_unwatch_control_pid(m);
710 m->control_command = NULL;
711 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
714 if (state == MOUNT_MOUNTED ||
715 state == MOUNT_REMOUNTING)
716 mount_notify_automount(m, 0);
717 else if (state == MOUNT_DEAD ||
718 state == MOUNT_UNMOUNTING ||
719 state == MOUNT_MOUNTING_SIGTERM ||
720 state == MOUNT_MOUNTING_SIGKILL ||
721 state == MOUNT_REMOUNTING_SIGTERM ||
722 state == MOUNT_REMOUNTING_SIGKILL ||
723 state == MOUNT_UNMOUNTING_SIGTERM ||
724 state == MOUNT_UNMOUNTING_SIGKILL ||
725 state == MOUNT_FAILED) {
726 if (state != old_state)
727 mount_notify_automount(m, -ENODEV);
730 if (state != old_state)
731 log_debug_unit(UNIT(m)->id,
732 "%s changed %s -> %s",
734 mount_state_to_string(old_state),
735 mount_state_to_string(state));
737 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
738 m->reload_result = MOUNT_SUCCESS;
741 static int mount_coldplug(Unit *u) {
743 MountState new_state = MOUNT_DEAD;
747 assert(m->state == MOUNT_DEAD);
749 if (m->deserialized_state != m->state)
750 new_state = m->deserialized_state;
751 else if (m->from_proc_self_mountinfo)
752 new_state = MOUNT_MOUNTED;
754 if (new_state != m->state) {
756 if (new_state == MOUNT_MOUNTING ||
757 new_state == MOUNT_MOUNTING_DONE ||
758 new_state == MOUNT_REMOUNTING ||
759 new_state == MOUNT_UNMOUNTING ||
760 new_state == MOUNT_MOUNTING_SIGTERM ||
761 new_state == MOUNT_MOUNTING_SIGKILL ||
762 new_state == MOUNT_UNMOUNTING_SIGTERM ||
763 new_state == MOUNT_UNMOUNTING_SIGKILL ||
764 new_state == MOUNT_REMOUNTING_SIGTERM ||
765 new_state == MOUNT_REMOUNTING_SIGKILL) {
767 if (m->control_pid <= 0)
770 r = unit_watch_pid(UNIT(m), m->control_pid);
774 r = unit_watch_timer(UNIT(m), CLOCK_MONOTONIC, true, m->timeout_usec, &m->timer_watch);
779 mount_set_state(m, new_state);
785 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
792 p = get_mount_parameters(m);
795 "%sMount State: %s\n"
799 "%sFile System Type: %s\n"
801 "%sFrom /proc/self/mountinfo: %s\n"
802 "%sFrom fragment: %s\n"
803 "%sDirectoryMode: %04o\n",
804 prefix, mount_state_to_string(m->state),
805 prefix, mount_result_to_string(m->result),
807 prefix, strna(p->what),
808 prefix, strna(p->fstype),
809 prefix, strna(p->options),
810 prefix, yes_no(m->from_proc_self_mountinfo),
811 prefix, yes_no(m->from_fragment),
812 prefix, m->directory_mode);
814 if (m->control_pid > 0)
816 "%sControl PID: %lu\n",
817 prefix, (unsigned long) m->control_pid);
819 exec_context_dump(&m->exec_context, f, prefix);
820 kill_context_dump(&m->kill_context, f, prefix);
823 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
831 r = unit_watch_timer(UNIT(m), CLOCK_MONOTONIC, true, m->timeout_usec, &m->timer_watch);
835 if ((r = exec_spawn(c,
839 UNIT(m)->manager->environment,
843 UNIT(m)->manager->confirm_spawn,
844 UNIT(m)->cgroup_bondings,
845 UNIT(m)->cgroup_attributes,
852 if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
853 /* FIXME: we need to do something here */
861 unit_unwatch_timer(UNIT(m), &m->timer_watch);
866 static void mount_enter_dead(Mount *m, MountResult f) {
869 if (f != MOUNT_SUCCESS)
872 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
875 static void mount_enter_mounted(Mount *m, MountResult f) {
878 if (f != MOUNT_SUCCESS)
881 mount_set_state(m, MOUNT_MOUNTED);
884 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
889 if (f != MOUNT_SUCCESS)
892 r = unit_kill_context(
895 state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM,
903 r = unit_watch_timer(UNIT(m), CLOCK_MONOTONIC, true, m->timeout_usec, &m->timer_watch);
907 mount_set_state(m, state);
908 } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
909 mount_enter_mounted(m, MOUNT_SUCCESS);
911 mount_enter_dead(m, MOUNT_SUCCESS);
916 log_warning_unit(UNIT(m)->id,
917 "%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
919 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
920 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
922 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
925 void warn_if_dir_nonempty(const char *unit, const char* where) {
929 if (dir_is_empty(where) > 0)
932 log_struct_unit(LOG_NOTICE,
934 "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
937 MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
941 static void mount_enter_unmounting(Mount *m) {
946 m->control_command_id = MOUNT_EXEC_UNMOUNT;
947 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
949 if ((r = exec_command_set(
956 mount_unwatch_control_pid(m);
958 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
961 mount_set_state(m, MOUNT_UNMOUNTING);
966 log_warning_unit(UNIT(m)->id,
967 "%s failed to run 'umount' task: %s",
968 UNIT(m)->id, strerror(-r));
969 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
972 static void mount_enter_mounting(Mount *m) {
978 m->control_command_id = MOUNT_EXEC_MOUNT;
979 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
981 mkdir_p_label(m->where, m->directory_mode);
983 warn_if_dir_nonempty(m->meta.id, m->where);
985 /* Create the source directory for bind-mounts if needed */
986 p = get_mount_parameters_fragment(m);
987 if (p && mount_is_bind(p))
988 mkdir_p_label(p->what, m->directory_mode);
990 if (m->from_fragment)
991 r = exec_command_set(
994 m->parameters_fragment.what,
996 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
997 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
1005 mount_unwatch_control_pid(m);
1007 r = mount_spawn(m, m->control_command, &m->control_pid);
1011 mount_set_state(m, MOUNT_MOUNTING);
1016 log_warning_unit(UNIT(m)->id,
1017 "%s failed to run 'mount' task: %s",
1018 UNIT(m)->id, strerror(-r));
1019 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
1022 static void mount_enter_mounting_done(Mount *m) {
1025 mount_set_state(m, MOUNT_MOUNTING_DONE);
1028 static void mount_enter_remounting(Mount *m) {
1033 m->control_command_id = MOUNT_EXEC_REMOUNT;
1034 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1036 if (m->from_fragment) {
1040 if (m->parameters_fragment.options) {
1041 if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
1050 r = exec_command_set(
1053 m->parameters_fragment.what,
1055 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
1066 mount_unwatch_control_pid(m);
1068 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1071 mount_set_state(m, MOUNT_REMOUNTING);
1076 log_warning_unit(UNIT(m)->id,
1077 "%s failed to run 'remount' task: %s",
1078 UNIT(m)->id, strerror(-r));
1079 m->reload_result = MOUNT_FAILURE_RESOURCES;
1080 mount_enter_mounted(m, MOUNT_SUCCESS);
1083 static int mount_start(Unit *u) {
1084 Mount *m = MOUNT(u);
1088 /* We cannot fulfill this request right now, try again later
1090 if (m->state == MOUNT_UNMOUNTING ||
1091 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1092 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1093 m->state == MOUNT_MOUNTING_SIGTERM ||
1094 m->state == MOUNT_MOUNTING_SIGKILL)
1097 /* Already on it! */
1098 if (m->state == MOUNT_MOUNTING)
1101 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1103 m->result = MOUNT_SUCCESS;
1104 m->reload_result = MOUNT_SUCCESS;
1106 mount_enter_mounting(m);
1110 static int mount_stop(Unit *u) {
1111 Mount *m = MOUNT(u);
1116 if (m->state == MOUNT_UNMOUNTING ||
1117 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1118 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1119 m->state == MOUNT_MOUNTING_SIGTERM ||
1120 m->state == MOUNT_MOUNTING_SIGKILL)
1123 assert(m->state == MOUNT_MOUNTING ||
1124 m->state == MOUNT_MOUNTING_DONE ||
1125 m->state == MOUNT_MOUNTED ||
1126 m->state == MOUNT_REMOUNTING ||
1127 m->state == MOUNT_REMOUNTING_SIGTERM ||
1128 m->state == MOUNT_REMOUNTING_SIGKILL);
1130 mount_enter_unmounting(m);
1134 static int mount_reload(Unit *u) {
1135 Mount *m = MOUNT(u);
1139 if (m->state == MOUNT_MOUNTING_DONE)
1142 assert(m->state == MOUNT_MOUNTED);
1144 mount_enter_remounting(m);
1148 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1149 Mount *m = MOUNT(u);
1155 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1156 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1157 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1159 if (m->control_pid > 0)
1160 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1162 if (m->control_command_id >= 0)
1163 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1168 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1169 Mount *m = MOUNT(u);
1176 if (streq(key, "state")) {
1179 if ((state = mount_state_from_string(value)) < 0)
1180 log_debug_unit(u->id, "Failed to parse state value %s", value);
1182 m->deserialized_state = state;
1183 } else if (streq(key, "result")) {
1186 f = mount_result_from_string(value);
1188 log_debug_unit(UNIT(m)->id,
1189 "Failed to parse result value %s", value);
1190 else if (f != MOUNT_SUCCESS)
1193 } else if (streq(key, "reload-result")) {
1196 f = mount_result_from_string(value);
1198 log_debug_unit(UNIT(m)->id,
1199 "Failed to parse reload result value %s", value);
1200 else if (f != MOUNT_SUCCESS)
1201 m->reload_result = f;
1203 } else if (streq(key, "control-pid")) {
1206 if (parse_pid(value, &pid) < 0)
1207 log_debug_unit(UNIT(m)->id,
1208 "Failed to parse control-pid value %s", value);
1210 m->control_pid = pid;
1211 } else if (streq(key, "control-command")) {
1212 MountExecCommand id;
1214 if ((id = mount_exec_command_from_string(value)) < 0)
1215 log_debug_unit(UNIT(m)->id,
1216 "Failed to parse exec-command value %s", value);
1218 m->control_command_id = id;
1219 m->control_command = m->exec_command + id;
1223 log_debug_unit(UNIT(m)->id,
1224 "Unknown serialization key '%s'", key);
1229 static UnitActiveState mount_active_state(Unit *u) {
1232 return state_translation_table[MOUNT(u)->state];
1235 static const char *mount_sub_state_to_string(Unit *u) {
1238 return mount_state_to_string(MOUNT(u)->state);
1241 static bool mount_check_gc(Unit *u) {
1242 Mount *m = MOUNT(u);
1246 return m->from_proc_self_mountinfo;
1249 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1250 Mount *m = MOUNT(u);
1256 if (pid != m->control_pid)
1261 if (is_clean_exit(code, status, NULL))
1263 else if (code == CLD_EXITED)
1264 f = MOUNT_FAILURE_EXIT_CODE;
1265 else if (code == CLD_KILLED)
1266 f = MOUNT_FAILURE_SIGNAL;
1267 else if (code == CLD_DUMPED)
1268 f = MOUNT_FAILURE_CORE_DUMP;
1270 assert_not_reached("Unknown code");
1272 if (f != MOUNT_SUCCESS)
1275 if (m->control_command) {
1276 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1278 m->control_command = NULL;
1279 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1282 log_full_unit(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
1283 "%s mount process exited, code=%s status=%i",
1284 u->id, sigchld_code_to_string(code), status);
1286 /* Note that mount(8) returning and the kernel sending us a
1287 * mount table change event might happen out-of-order. If an
1288 * operation succeed we assume the kernel will follow soon too
1289 * and already change into the resulting state. If it fails
1290 * we check if the kernel still knows about the mount. and
1291 * change state accordingly. */
1295 case MOUNT_MOUNTING:
1296 case MOUNT_MOUNTING_DONE:
1297 case MOUNT_MOUNTING_SIGKILL:
1298 case MOUNT_MOUNTING_SIGTERM:
1300 if (f == MOUNT_SUCCESS)
1301 mount_enter_mounted(m, f);
1302 else if (m->from_proc_self_mountinfo)
1303 mount_enter_mounted(m, f);
1305 mount_enter_dead(m, f);
1308 case MOUNT_REMOUNTING:
1309 case MOUNT_REMOUNTING_SIGKILL:
1310 case MOUNT_REMOUNTING_SIGTERM:
1312 m->reload_result = f;
1313 if (m->from_proc_self_mountinfo)
1314 mount_enter_mounted(m, MOUNT_SUCCESS);
1316 mount_enter_dead(m, MOUNT_SUCCESS);
1320 case MOUNT_UNMOUNTING:
1321 case MOUNT_UNMOUNTING_SIGKILL:
1322 case MOUNT_UNMOUNTING_SIGTERM:
1324 if (f == MOUNT_SUCCESS)
1325 mount_enter_dead(m, f);
1326 else if (m->from_proc_self_mountinfo)
1327 mount_enter_mounted(m, f);
1329 mount_enter_dead(m, f);
1333 assert_not_reached("Uh, control process died at wrong time.");
1336 /* Notify clients about changed exit status */
1337 unit_add_to_dbus_queue(u);
1340 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1341 Mount *m = MOUNT(u);
1344 assert(elapsed == 1);
1345 assert(w == &m->timer_watch);
1349 case MOUNT_MOUNTING:
1350 case MOUNT_MOUNTING_DONE:
1351 log_warning_unit(u->id,
1352 "%s mounting timed out. Stopping.", u->id);
1353 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1356 case MOUNT_REMOUNTING:
1357 log_warning_unit(u->id,
1358 "%s remounting timed out. Stopping.", u->id);
1359 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1360 mount_enter_mounted(m, MOUNT_SUCCESS);
1363 case MOUNT_UNMOUNTING:
1364 log_warning_unit(u->id,
1365 "%s unmounting timed out. Stopping.", u->id);
1366 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1369 case MOUNT_MOUNTING_SIGTERM:
1370 if (m->kill_context.send_sigkill) {
1371 log_warning_unit(u->id,
1372 "%s mounting timed out. Killing.", u->id);
1373 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1375 log_warning_unit(u->id,
1376 "%s mounting timed out. Skipping SIGKILL. Ignoring.",
1379 if (m->from_proc_self_mountinfo)
1380 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1382 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1386 case MOUNT_REMOUNTING_SIGTERM:
1387 if (m->kill_context.send_sigkill) {
1388 log_warning_unit(u->id,
1389 "%s remounting timed out. Killing.", u->id);
1390 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1392 log_warning_unit(u->id,
1393 "%s remounting timed out. Skipping SIGKILL. Ignoring.",
1396 if (m->from_proc_self_mountinfo)
1397 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1399 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1403 case MOUNT_UNMOUNTING_SIGTERM:
1404 if (m->kill_context.send_sigkill) {
1405 log_warning_unit(u->id,
1406 "%s unmounting timed out. Killing.", u->id);
1407 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1409 log_warning_unit(u->id,
1410 "%s unmounting timed out. Skipping SIGKILL. Ignoring.",
1413 if (m->from_proc_self_mountinfo)
1414 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1416 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1420 case MOUNT_MOUNTING_SIGKILL:
1421 case MOUNT_REMOUNTING_SIGKILL:
1422 case MOUNT_UNMOUNTING_SIGKILL:
1423 log_warning_unit(u->id,
1424 "%s mount process still around after SIGKILL. Ignoring.",
1427 if (m->from_proc_self_mountinfo)
1428 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1430 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1434 assert_not_reached("Timeout at wrong time.");
1438 static int mount_add_one(
1442 const char *options,
1449 char *e, *w = NULL, *o = NULL, *f = NULL;
1451 bool load_extras = false;
1459 /* Ignore API mount points. They should never be referenced in
1460 * dependencies ever. */
1461 if (mount_point_is_api(where) || mount_point_ignore(where))
1464 if (streq(fstype, "autofs"))
1467 /* probably some kind of swap, ignore */
1468 if (!is_path(where))
1471 e = unit_name_from_path(where, ".mount");
1475 u = manager_get_unit(m, e);
1479 u = unit_new(m, sizeof(Mount));
1485 r = unit_add_name(u, e);
1491 MOUNT(u)->where = strdup(where);
1492 if (!MOUNT(u)->where) {
1497 u->source_path = strdup("/proc/self/mountinfo");
1498 if (!u->source_path) {
1503 unit_add_to_load_queue(u);
1508 if (!MOUNT(u)->where) {
1509 MOUNT(u)->where = strdup(where);
1510 if (!MOUNT(u)->where) {
1516 if (u->load_state == UNIT_ERROR) {
1517 u->load_state = UNIT_LOADED;
1520 /* Load in the extras later on, after we
1521 * finished initialization of the unit */
1526 if (!(w = strdup(what)) ||
1527 !(o = strdup(options)) ||
1528 !(f = strdup(fstype))) {
1533 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1535 MOUNT(u)->is_mounted = true;
1536 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1537 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1540 MOUNT(u)->from_proc_self_mountinfo = true;
1554 r = mount_add_extras(MOUNT(u));
1559 unit_add_to_dbus_queue(u);
1574 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1577 char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1581 rewind(m->proc_self_mountinfo);
1586 device = path = options = options2 = fstype = d = p = o = NULL;
1588 if ((k = fscanf(m->proc_self_mountinfo,
1589 "%*s " /* (1) mount id */
1590 "%*s " /* (2) parent id */
1591 "%*s " /* (3) major:minor */
1592 "%*s " /* (4) root */
1593 "%ms " /* (5) mount point */
1594 "%ms" /* (6) mount options */
1595 "%*[^-]" /* (7) optional fields */
1596 "- " /* (8) separator */
1597 "%ms " /* (9) file system type */
1598 "%ms" /* (10) mount source */
1599 "%ms" /* (11) mount options 2 */
1600 "%*[^\n]", /* some rubbish at the end */
1610 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1614 o = strjoin(options, ",", options2, NULL);
1620 if (!(d = cunescape(device)) ||
1621 !(p = cunescape(path))) {
1626 if ((k = mount_add_one(m, d, p, o, fstype, 0, set_flags)) < 0)
1653 static void mount_shutdown(Manager *m) {
1656 if (m->proc_self_mountinfo) {
1657 fclose(m->proc_self_mountinfo);
1658 m->proc_self_mountinfo = NULL;
1662 static int mount_enumerate(Manager *m) {
1664 struct epoll_event ev;
1667 if (!m->proc_self_mountinfo) {
1668 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1671 m->mount_watch.type = WATCH_MOUNT;
1672 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1675 ev.events = EPOLLPRI;
1676 ev.data.ptr = &m->mount_watch;
1678 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1682 if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1692 void mount_fd_event(Manager *m, int events) {
1697 assert(events & EPOLLPRI);
1699 /* The manager calls this for every fd event happening on the
1700 * /proc/self/mountinfo file, which informs us about mounting
1703 r = mount_load_proc_self_mountinfo(m, true);
1705 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1707 /* Reset flags, just in case, for later calls */
1708 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1709 Mount *mount = MOUNT(u);
1711 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1717 manager_dispatch_load_queue(m);
1719 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1720 Mount *mount = MOUNT(u);
1722 if (!mount->is_mounted) {
1723 /* This has just been unmounted. */
1725 mount->from_proc_self_mountinfo = false;
1727 switch (mount->state) {
1730 mount_enter_dead(mount, MOUNT_SUCCESS);
1734 mount_set_state(mount, mount->state);
1739 } else if (mount->just_mounted || mount->just_changed) {
1741 /* New or changed mount entry */
1743 switch (mount->state) {
1747 mount_enter_mounted(mount, MOUNT_SUCCESS);
1750 case MOUNT_MOUNTING:
1751 mount_enter_mounting_done(mount);
1755 /* Nothing really changed, but let's
1756 * issue an notification call
1757 * nonetheless, in case somebody is
1758 * waiting for this. (e.g. file system
1759 * ro/rw remounts.) */
1760 mount_set_state(mount, mount->state);
1765 /* Reset the flags for later calls */
1766 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1770 static void mount_reset_failed(Unit *u) {
1771 Mount *m = MOUNT(u);
1775 if (m->state == MOUNT_FAILED)
1776 mount_set_state(m, MOUNT_DEAD);
1778 m->result = MOUNT_SUCCESS;
1779 m->reload_result = MOUNT_SUCCESS;
1782 static int mount_kill(Unit *u, KillWho who, int signo, DBusError *error) {
1783 Mount *m = MOUNT(u);
1785 Set *pid_set = NULL;
1789 if (who == KILL_MAIN) {
1790 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1794 if (m->control_pid <= 0 && who == KILL_CONTROL) {
1795 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1799 if (who == KILL_CONTROL || who == KILL_ALL)
1800 if (m->control_pid > 0)
1801 if (kill(m->control_pid, signo) < 0)
1804 if (who == KILL_ALL) {
1807 pid_set = set_new(trivial_hash_func, trivial_compare_func);
1811 /* Exclude the control pid from being killed via the cgroup */
1812 if (m->control_pid > 0) {
1813 q = set_put(pid_set, LONG_TO_PTR(m->control_pid));
1820 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, false, pid_set, NULL);
1821 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1832 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1833 [MOUNT_DEAD] = "dead",
1834 [MOUNT_MOUNTING] = "mounting",
1835 [MOUNT_MOUNTING_DONE] = "mounting-done",
1836 [MOUNT_MOUNTED] = "mounted",
1837 [MOUNT_REMOUNTING] = "remounting",
1838 [MOUNT_UNMOUNTING] = "unmounting",
1839 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1840 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1841 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1842 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1843 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1844 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1845 [MOUNT_FAILED] = "failed"
1848 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1850 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1851 [MOUNT_EXEC_MOUNT] = "ExecMount",
1852 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1853 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1856 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1858 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1859 [MOUNT_SUCCESS] = "success",
1860 [MOUNT_FAILURE_RESOURCES] = "resources",
1861 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1862 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1863 [MOUNT_FAILURE_SIGNAL] = "signal",
1864 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1867 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1869 const UnitVTable mount_vtable = {
1870 .object_size = sizeof(Mount),
1877 .exec_context_offset = offsetof(Mount, exec_context),
1878 .exec_section = "Mount",
1881 .no_instances = true,
1887 .coldplug = mount_coldplug,
1891 .start = mount_start,
1893 .reload = mount_reload,
1897 .serialize = mount_serialize,
1898 .deserialize_item = mount_deserialize_item,
1900 .active_state = mount_active_state,
1901 .sub_state_to_string = mount_sub_state_to_string,
1903 .check_gc = mount_check_gc,
1905 .sigchld_event = mount_sigchld_event,
1906 .timer_event = mount_timer_event,
1908 .reset_failed = mount_reset_failed,
1910 .bus_interface = "org.freedesktop.systemd1.Mount",
1911 .bus_message_handler = bus_mount_message_handler,
1912 .bus_invalidating_properties = bus_mount_invalidating_properties,
1914 .enumerate = mount_enumerate,
1915 .shutdown = mount_shutdown,
1917 .status_message_formats = {
1918 .starting_stopping = {
1919 [0] = "Mounting %s...",
1920 [1] = "Unmounting %s...",
1922 .finished_start_job = {
1923 [JOB_DONE] = "Mounted %s.",
1924 [JOB_FAILED] = "Failed to mount %s.",
1925 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1926 [JOB_TIMEOUT] = "Timed out mounting %s.",
1928 .finished_stop_job = {
1929 [JOB_DONE] = "Unmounted %s.",
1930 [JOB_FAILED] = "Failed unmounting %s.",
1931 [JOB_TIMEOUT] = "Timed out unmounting %s.",