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>
31 #include "load-fragment.h"
32 #include "load-dropin.h"
34 #include "sd-messages.h"
37 #include "path-util.h"
38 #include "mount-setup.h"
39 #include "unit-name.h"
40 #include "dbus-mount.h"
42 #include "bus-errors.h"
43 #include "exit-status.h"
46 static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
47 [MOUNT_DEAD] = UNIT_INACTIVE,
48 [MOUNT_MOUNTING] = UNIT_ACTIVATING,
49 [MOUNT_MOUNTING_DONE] = UNIT_ACTIVE,
50 [MOUNT_MOUNTED] = UNIT_ACTIVE,
51 [MOUNT_REMOUNTING] = UNIT_RELOADING,
52 [MOUNT_UNMOUNTING] = UNIT_DEACTIVATING,
53 [MOUNT_MOUNTING_SIGTERM] = UNIT_DEACTIVATING,
54 [MOUNT_MOUNTING_SIGKILL] = UNIT_DEACTIVATING,
55 [MOUNT_REMOUNTING_SIGTERM] = UNIT_RELOADING,
56 [MOUNT_REMOUNTING_SIGKILL] = UNIT_RELOADING,
57 [MOUNT_UNMOUNTING_SIGTERM] = UNIT_DEACTIVATING,
58 [MOUNT_UNMOUNTING_SIGKILL] = UNIT_DEACTIVATING,
59 [MOUNT_FAILED] = UNIT_FAILED
62 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
63 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
65 static bool mount_is_network(MountParameters *p) {
68 if (mount_test_option(p->options, "_netdev"))
71 if (p->fstype && fstype_is_network(p->fstype))
77 static bool mount_is_bind(MountParameters *p) {
80 if (mount_test_option(p->options, "bind"))
83 if (p->fstype && streq(p->fstype, "bind"))
86 if (mount_test_option(p->options, "rbind"))
89 if (p->fstype && streq(p->fstype, "rbind"))
95 static bool mount_is_auto(MountParameters *p) {
98 return !mount_test_option(p->options, "noauto");
101 static bool needs_quota(MountParameters *p) {
104 if (mount_is_network(p))
107 if (mount_is_bind(p))
110 return mount_test_option(p->options, "usrquota") ||
111 mount_test_option(p->options, "grpquota") ||
112 mount_test_option(p->options, "quota") ||
113 mount_test_option(p->options, "usrjquota") ||
114 mount_test_option(p->options, "grpjquota");
117 static void mount_init(Unit *u) {
121 assert(u->load_state == UNIT_STUB);
123 m->timeout_usec = u->manager->default_timeout_start_usec;
124 m->directory_mode = 0755;
126 exec_context_init(&m->exec_context);
127 kill_context_init(&m->kill_context);
128 cgroup_context_init(&m->cgroup_context);
130 unit_cgroup_context_init_defaults(u, &m->cgroup_context);
132 if (unit_has_name(u, "-.mount")) {
133 /* Don't allow start/stop for root directory */
134 u->refuse_manual_start = true;
135 u->refuse_manual_stop = true;
137 /* The stdio/kmsg bridge socket is on /, in order to avoid a
138 * dep loop, don't use kmsg logging for -.mount */
139 m->exec_context.std_output = u->manager->default_std_output;
140 m->exec_context.std_error = u->manager->default_std_error;
143 /* We need to make sure that /bin/mount is always called in
144 * the same process group as us, so that the autofs kernel
145 * side doesn't send us another mount request while we are
146 * already trying to comply its last one. */
147 m->exec_context.same_pgrp = true;
149 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
151 u->ignore_on_isolate = true;
154 static int mount_arm_timer(Mount *m) {
159 if (m->timeout_usec <= 0) {
160 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
164 if (m->timer_event_source) {
165 r = sd_event_source_set_time(m->timer_event_source, now(CLOCK_MONOTONIC) + m->timeout_usec);
169 return sd_event_source_set_enabled(m->timer_event_source, SD_EVENT_ONESHOT);
172 return sd_event_add_monotonic(UNIT(m)->manager->event, &m->timer_event_source, now(CLOCK_MONOTONIC) + m->timeout_usec, 0, mount_dispatch_timer, m);
175 static void mount_unwatch_control_pid(Mount *m) {
178 if (m->control_pid <= 0)
181 unit_unwatch_pid(UNIT(m), m->control_pid);
185 static void mount_parameters_done(MountParameters *p) {
192 p->what = p->options = p->fstype = NULL;
195 static void mount_done(Unit *u) {
203 mount_parameters_done(&m->parameters_proc_self_mountinfo);
204 mount_parameters_done(&m->parameters_fragment);
206 cgroup_context_done(&m->cgroup_context);
207 exec_context_done(&m->exec_context);
208 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
209 exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
210 m->control_command = NULL;
212 mount_unwatch_control_pid(m);
214 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
217 _pure_ static MountParameters* get_mount_parameters_fragment(Mount *m) {
220 if (m->from_fragment)
221 return &m->parameters_fragment;
226 _pure_ static MountParameters* get_mount_parameters(Mount *m) {
229 if (m->from_proc_self_mountinfo)
230 return &m->parameters_proc_self_mountinfo;
232 return get_mount_parameters_fragment(m);
235 static int mount_add_mount_links(Mount *m) {
236 _cleanup_free_ char *parent = NULL;
245 if (!path_equal(m->where, "/")) {
246 /* Adds in links to other mount points that might lie further
247 * up in the hierarchy */
248 r = path_get_parent(m->where, &parent);
252 r = unit_require_mounts_for(UNIT(m), parent);
257 /* Adds in links to other mount points that might be needed
258 * for the source path (if this is a bind mount) to be
260 pm = get_mount_parameters_fragment(m);
261 if (pm && pm->what &&
262 path_is_absolute(pm->what) &&
263 !mount_is_network(pm)) {
265 r = unit_require_mounts_for(UNIT(m), pm->what);
270 /* Adds in links to other units that use this path or paths
271 * further down in the hierarchy */
272 s = manager_get_units_requiring_mounts_for(UNIT(m)->manager, m->where);
273 SET_FOREACH(other, s, i) {
275 if (other->load_state != UNIT_LOADED)
278 if (other == UNIT(m))
281 r = unit_add_dependency(other, UNIT_AFTER, UNIT(m), true);
285 if (UNIT(m)->fragment_path) {
286 /* If we have fragment configuration, then make this dependency required */
287 r = unit_add_dependency(other, UNIT_REQUIRES, UNIT(m), true);
296 static int mount_add_device_links(Mount *m) {
298 bool device_wants_mount = false;
303 p = get_mount_parameters_fragment(m);
310 if (mount_is_bind(p))
313 if (!is_device_path(p->what))
316 if (path_equal(m->where, "/"))
319 if (mount_is_auto(p) && UNIT(m)->manager->running_as == SYSTEMD_SYSTEM)
320 device_wants_mount = true;
322 r = unit_add_node_link(UNIT(m), p->what, device_wants_mount);
329 static int mount_add_quota_links(Mount *m) {
335 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
338 p = get_mount_parameters_fragment(m);
345 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true);
349 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true);
356 static bool should_umount(Mount *m) {
359 if (path_equal(m->where, "/") ||
360 path_equal(m->where, "/usr"))
363 p = get_mount_parameters(m);
364 if (p && mount_test_option(p->options, "x-initrd.mount") &&
371 static int mount_add_default_dependencies(Mount *m) {
372 const char *after, *after2, *online;
378 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
381 p = get_mount_parameters(m);
386 if (path_equal(m->where, "/"))
389 if (mount_is_network(p)) {
390 after = SPECIAL_REMOTE_FS_PRE_TARGET;
391 after2 = SPECIAL_NETWORK_TARGET;
392 online = SPECIAL_NETWORK_ONLINE_TARGET;
394 after = SPECIAL_LOCAL_FS_PRE_TARGET;
399 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true);
404 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after2, NULL, true);
410 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, online, NULL, true);
415 if (should_umount(m)) {
416 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
424 static int mount_fix_timeouts(Mount *m) {
426 const char *timeout = NULL;
435 p = get_mount_parameters_fragment(m);
439 /* Allow configuration how long we wait for a device that
440 * backs a mount point to show up. This is useful to support
441 * endless device timeouts for devices that show up only after
442 * user input, like crypto devices. */
444 if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
446 else if ((timeout = mount_test_option(p->options, "x-systemd.device-timeout")))
451 t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
455 r = parse_sec(t, &u);
459 log_warning_unit(UNIT(m)->id,
460 "Failed to parse timeout for %s, ignoring: %s",
465 SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
466 if (other->type != UNIT_DEVICE)
469 other->job_timeout = u;
475 static int mount_verify(Mount *m) {
476 _cleanup_free_ char *e = NULL;
481 if (UNIT(m)->load_state != UNIT_LOADED)
484 if (!m->from_fragment && !m->from_proc_self_mountinfo)
487 e = unit_name_from_path(m->where, ".mount");
491 b = unit_has_name(UNIT(m), e);
493 log_error_unit(UNIT(m)->id, "%s's Where= setting doesn't match unit name. Refusing.", UNIT(m)->id);
497 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
498 log_error_unit(UNIT(m)->id, "Cannot create mount unit for API file system %s. Refusing.", m->where);
502 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
503 log_error_unit(UNIT(m)->id, "%s's What setting is missing. Refusing.", UNIT(m)->id);
507 if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
508 log_error_unit(UNIT(m)->id, "%s has PAM enabled. Kill mode must be set to control-group'. Refusing.",UNIT(m)->id);
515 static int mount_add_extras(Mount *m) {
521 if (u->fragment_path)
522 m->from_fragment = true;
525 m->where = unit_name_to_path(u->id);
530 path_kill_slashes(m->where);
532 r = unit_add_exec_dependencies(u, &m->exec_context);
536 if (!u->description) {
537 r = unit_set_description(u, m->where);
542 r = mount_add_device_links(m);
546 r = mount_add_mount_links(m);
550 r = mount_add_quota_links(m);
554 if (u->default_dependencies) {
555 r = mount_add_default_dependencies(m);
560 r = unit_add_default_slice(u);
564 r = mount_fix_timeouts(m);
568 r = unit_exec_context_patch_defaults(u, &m->exec_context);
575 static int mount_load(Unit *u) {
580 assert(u->load_state == UNIT_STUB);
582 if (m->from_proc_self_mountinfo)
583 r = unit_load_fragment_and_dropin_optional(u);
585 r = unit_load_fragment_and_dropin(u);
590 /* This is a new unit? Then let's add in some extras */
591 if (u->load_state == UNIT_LOADED) {
592 r = mount_add_extras(m);
597 return mount_verify(m);
600 static int mount_notify_automount(Mount *m, int status) {
607 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
608 if (p->type == UNIT_AUTOMOUNT) {
609 r = automount_send_ready(AUTOMOUNT(p), status);
617 static void mount_set_state(Mount *m, MountState state) {
618 MountState old_state;
621 old_state = m->state;
624 if (state != MOUNT_MOUNTING &&
625 state != MOUNT_MOUNTING_DONE &&
626 state != MOUNT_REMOUNTING &&
627 state != MOUNT_UNMOUNTING &&
628 state != MOUNT_MOUNTING_SIGTERM &&
629 state != MOUNT_MOUNTING_SIGKILL &&
630 state != MOUNT_UNMOUNTING_SIGTERM &&
631 state != MOUNT_UNMOUNTING_SIGKILL &&
632 state != MOUNT_REMOUNTING_SIGTERM &&
633 state != MOUNT_REMOUNTING_SIGKILL) {
634 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
635 mount_unwatch_control_pid(m);
636 m->control_command = NULL;
637 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
640 if (state == MOUNT_MOUNTED ||
641 state == MOUNT_REMOUNTING)
642 mount_notify_automount(m, 0);
643 else if (state == MOUNT_DEAD ||
644 state == MOUNT_UNMOUNTING ||
645 state == MOUNT_MOUNTING_SIGTERM ||
646 state == MOUNT_MOUNTING_SIGKILL ||
647 state == MOUNT_REMOUNTING_SIGTERM ||
648 state == MOUNT_REMOUNTING_SIGKILL ||
649 state == MOUNT_UNMOUNTING_SIGTERM ||
650 state == MOUNT_UNMOUNTING_SIGKILL ||
651 state == MOUNT_FAILED) {
652 if (state != old_state)
653 mount_notify_automount(m, -ENODEV);
656 if (state != old_state)
657 log_debug_unit(UNIT(m)->id,
658 "%s changed %s -> %s",
660 mount_state_to_string(old_state),
661 mount_state_to_string(state));
663 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
664 m->reload_result = MOUNT_SUCCESS;
667 static int mount_coldplug(Unit *u) {
669 MountState new_state = MOUNT_DEAD;
673 assert(m->state == MOUNT_DEAD);
675 if (m->deserialized_state != m->state)
676 new_state = m->deserialized_state;
677 else if (m->from_proc_self_mountinfo)
678 new_state = MOUNT_MOUNTED;
680 if (new_state == m->state)
683 if (new_state == MOUNT_MOUNTING ||
684 new_state == MOUNT_MOUNTING_DONE ||
685 new_state == MOUNT_REMOUNTING ||
686 new_state == MOUNT_UNMOUNTING ||
687 new_state == MOUNT_MOUNTING_SIGTERM ||
688 new_state == MOUNT_MOUNTING_SIGKILL ||
689 new_state == MOUNT_UNMOUNTING_SIGTERM ||
690 new_state == MOUNT_UNMOUNTING_SIGKILL ||
691 new_state == MOUNT_REMOUNTING_SIGTERM ||
692 new_state == MOUNT_REMOUNTING_SIGKILL) {
694 if (m->control_pid <= 0)
697 r = unit_watch_pid(UNIT(m), m->control_pid);
701 r = mount_arm_timer(m);
706 mount_set_state(m, new_state);
710 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
717 p = get_mount_parameters(m);
720 "%sMount State: %s\n"
724 "%sFile System Type: %s\n"
726 "%sFrom /proc/self/mountinfo: %s\n"
727 "%sFrom fragment: %s\n"
728 "%sDirectoryMode: %04o\n",
729 prefix, mount_state_to_string(m->state),
730 prefix, mount_result_to_string(m->result),
732 prefix, p ? strna(p->what) : "n/a",
733 prefix, p ? strna(p->fstype) : "n/a",
734 prefix, p ? strna(p->options) : "n/a",
735 prefix, yes_no(m->from_proc_self_mountinfo),
736 prefix, yes_no(m->from_fragment),
737 prefix, m->directory_mode);
739 if (m->control_pid > 0)
741 "%sControl PID: "PID_FMT"\n",
742 prefix, m->control_pid);
744 exec_context_dump(&m->exec_context, f, prefix);
745 kill_context_dump(&m->kill_context, f, prefix);
748 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
756 unit_realize_cgroup(UNIT(m));
758 r = unit_setup_exec_runtime(UNIT(m));
762 r = mount_arm_timer(m);
770 UNIT(m)->manager->environment,
774 UNIT(m)->manager->confirm_spawn,
775 UNIT(m)->manager->cgroup_supported,
776 UNIT(m)->cgroup_path,
777 manager_get_runtime_prefix(UNIT(m)->manager),
786 r = unit_watch_pid(UNIT(m), pid);
788 /* FIXME: we need to do something here */
796 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
801 static void mount_enter_dead(Mount *m, MountResult f) {
804 if (f != MOUNT_SUCCESS)
807 exec_runtime_destroy(m->exec_runtime);
808 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
810 exec_context_destroy_runtime_directory(&m->exec_context, manager_get_runtime_prefix(UNIT(m)->manager));
812 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
815 static void mount_enter_mounted(Mount *m, MountResult f) {
818 if (f != MOUNT_SUCCESS)
821 mount_set_state(m, MOUNT_MOUNTED);
824 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
829 if (f != MOUNT_SUCCESS)
832 r = unit_kill_context(
835 state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM,
843 r = mount_arm_timer(m);
847 mount_set_state(m, state);
848 } else if (state == MOUNT_REMOUNTING_SIGTERM)
849 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
850 else if (state == MOUNT_REMOUNTING_SIGKILL)
851 mount_enter_mounted(m, MOUNT_SUCCESS);
852 else if (state == MOUNT_MOUNTING_SIGTERM)
853 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_SUCCESS);
854 else if (state == MOUNT_UNMOUNTING_SIGTERM)
855 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
857 mount_enter_dead(m, MOUNT_SUCCESS);
862 log_warning_unit(UNIT(m)->id,
863 "%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
865 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
866 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
868 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
871 void warn_if_dir_nonempty(const char *unit, const char* where) {
875 if (dir_is_empty(where) > 0)
878 log_struct_unit(LOG_NOTICE,
880 "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
883 MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
887 static void mount_enter_unmounting(Mount *m) {
892 m->control_command_id = MOUNT_EXEC_UNMOUNT;
893 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
895 if ((r = exec_command_set(
902 mount_unwatch_control_pid(m);
904 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
907 mount_set_state(m, MOUNT_UNMOUNTING);
912 log_warning_unit(UNIT(m)->id,
913 "%s failed to run 'umount' task: %s",
914 UNIT(m)->id, strerror(-r));
915 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
918 static void mount_enter_mounting(Mount *m) {
924 m->control_command_id = MOUNT_EXEC_MOUNT;
925 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
927 mkdir_p_label(m->where, m->directory_mode);
929 warn_if_dir_nonempty(m->meta.id, m->where);
931 /* Create the source directory for bind-mounts if needed */
932 p = get_mount_parameters_fragment(m);
933 if (p && mount_is_bind(p))
934 mkdir_p_label(p->what, m->directory_mode);
936 if (m->from_fragment)
937 r = exec_command_set(
940 m->parameters_fragment.what,
942 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
943 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
951 mount_unwatch_control_pid(m);
953 r = mount_spawn(m, m->control_command, &m->control_pid);
957 mount_set_state(m, MOUNT_MOUNTING);
962 log_warning_unit(UNIT(m)->id,
963 "%s failed to run 'mount' task: %s",
964 UNIT(m)->id, strerror(-r));
965 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
968 static void mount_enter_remounting(Mount *m) {
973 m->control_command_id = MOUNT_EXEC_REMOUNT;
974 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
976 if (m->from_fragment) {
979 if (m->parameters_fragment.options)
980 o = strappenda("remount,", m->parameters_fragment.options);
984 r = exec_command_set(
987 m->parameters_fragment.what,
989 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
998 mount_unwatch_control_pid(m);
1000 r = mount_spawn(m, m->control_command, &m->control_pid);
1004 mount_set_state(m, MOUNT_REMOUNTING);
1009 log_warning_unit(UNIT(m)->id,
1010 "%s failed to run 'remount' task: %s",
1011 UNIT(m)->id, strerror(-r));
1012 m->reload_result = MOUNT_FAILURE_RESOURCES;
1013 mount_enter_mounted(m, MOUNT_SUCCESS);
1016 static int mount_start(Unit *u) {
1017 Mount *m = MOUNT(u);
1021 /* We cannot fulfill this request right now, try again later
1023 if (m->state == MOUNT_UNMOUNTING ||
1024 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1025 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1026 m->state == MOUNT_MOUNTING_SIGTERM ||
1027 m->state == MOUNT_MOUNTING_SIGKILL)
1030 /* Already on it! */
1031 if (m->state == MOUNT_MOUNTING)
1034 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1036 m->result = MOUNT_SUCCESS;
1037 m->reload_result = MOUNT_SUCCESS;
1039 mount_enter_mounting(m);
1043 static int mount_stop(Unit *u) {
1044 Mount *m = MOUNT(u);
1049 if (m->state == MOUNT_UNMOUNTING ||
1050 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1051 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1052 m->state == MOUNT_MOUNTING_SIGTERM ||
1053 m->state == MOUNT_MOUNTING_SIGKILL)
1056 assert(m->state == MOUNT_MOUNTING ||
1057 m->state == MOUNT_MOUNTING_DONE ||
1058 m->state == MOUNT_MOUNTED ||
1059 m->state == MOUNT_REMOUNTING ||
1060 m->state == MOUNT_REMOUNTING_SIGTERM ||
1061 m->state == MOUNT_REMOUNTING_SIGKILL);
1063 mount_enter_unmounting(m);
1067 static int mount_reload(Unit *u) {
1068 Mount *m = MOUNT(u);
1072 if (m->state == MOUNT_MOUNTING_DONE)
1075 assert(m->state == MOUNT_MOUNTED);
1077 mount_enter_remounting(m);
1081 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1082 Mount *m = MOUNT(u);
1088 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1089 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1090 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1092 if (m->control_pid > 0)
1093 unit_serialize_item_format(u, f, "control-pid", PID_FMT, m->control_pid);
1095 if (m->control_command_id >= 0)
1096 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1101 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1102 Mount *m = MOUNT(u);
1109 if (streq(key, "state")) {
1112 if ((state = mount_state_from_string(value)) < 0)
1113 log_debug_unit(u->id, "Failed to parse state value %s", value);
1115 m->deserialized_state = state;
1116 } else if (streq(key, "result")) {
1119 f = mount_result_from_string(value);
1121 log_debug_unit(UNIT(m)->id,
1122 "Failed to parse result value %s", value);
1123 else if (f != MOUNT_SUCCESS)
1126 } else if (streq(key, "reload-result")) {
1129 f = mount_result_from_string(value);
1131 log_debug_unit(UNIT(m)->id,
1132 "Failed to parse reload result value %s", value);
1133 else if (f != MOUNT_SUCCESS)
1134 m->reload_result = f;
1136 } else if (streq(key, "control-pid")) {
1139 if (parse_pid(value, &pid) < 0)
1140 log_debug_unit(UNIT(m)->id,
1141 "Failed to parse control-pid value %s", value);
1143 m->control_pid = pid;
1144 } else if (streq(key, "control-command")) {
1145 MountExecCommand id;
1147 if ((id = mount_exec_command_from_string(value)) < 0)
1148 log_debug_unit(UNIT(m)->id,
1149 "Failed to parse exec-command value %s", value);
1151 m->control_command_id = id;
1152 m->control_command = m->exec_command + id;
1155 log_debug_unit(UNIT(m)->id,
1156 "Unknown serialization key '%s'", key);
1161 _pure_ static UnitActiveState mount_active_state(Unit *u) {
1164 return state_translation_table[MOUNT(u)->state];
1167 _pure_ static const char *mount_sub_state_to_string(Unit *u) {
1170 return mount_state_to_string(MOUNT(u)->state);
1173 _pure_ static bool mount_check_gc(Unit *u) {
1174 Mount *m = MOUNT(u);
1178 return m->from_proc_self_mountinfo;
1181 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1182 Mount *m = MOUNT(u);
1188 if (pid != m->control_pid)
1193 if (is_clean_exit(code, status, NULL))
1195 else if (code == CLD_EXITED)
1196 f = MOUNT_FAILURE_EXIT_CODE;
1197 else if (code == CLD_KILLED)
1198 f = MOUNT_FAILURE_SIGNAL;
1199 else if (code == CLD_DUMPED)
1200 f = MOUNT_FAILURE_CORE_DUMP;
1202 assert_not_reached("Unknown code");
1204 if (f != MOUNT_SUCCESS)
1207 if (m->control_command) {
1208 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1210 m->control_command = NULL;
1211 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1214 log_full_unit(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
1215 "%s mount process exited, code=%s status=%i",
1216 u->id, sigchld_code_to_string(code), status);
1218 /* Note that mount(8) returning and the kernel sending us a
1219 * mount table change event might happen out-of-order. If an
1220 * operation succeed we assume the kernel will follow soon too
1221 * and already change into the resulting state. If it fails
1222 * we check if the kernel still knows about the mount. and
1223 * change state accordingly. */
1227 case MOUNT_MOUNTING:
1228 case MOUNT_MOUNTING_DONE:
1229 case MOUNT_MOUNTING_SIGKILL:
1230 case MOUNT_MOUNTING_SIGTERM:
1232 if (f == MOUNT_SUCCESS)
1233 mount_enter_mounted(m, f);
1234 else if (m->from_proc_self_mountinfo)
1235 mount_enter_mounted(m, f);
1237 mount_enter_dead(m, f);
1240 case MOUNT_REMOUNTING:
1241 case MOUNT_REMOUNTING_SIGKILL:
1242 case MOUNT_REMOUNTING_SIGTERM:
1244 m->reload_result = f;
1245 if (m->from_proc_self_mountinfo)
1246 mount_enter_mounted(m, MOUNT_SUCCESS);
1248 mount_enter_dead(m, MOUNT_SUCCESS);
1252 case MOUNT_UNMOUNTING:
1253 case MOUNT_UNMOUNTING_SIGKILL:
1254 case MOUNT_UNMOUNTING_SIGTERM:
1256 if (f == MOUNT_SUCCESS)
1257 mount_enter_dead(m, f);
1258 else if (m->from_proc_self_mountinfo)
1259 mount_enter_mounted(m, f);
1261 mount_enter_dead(m, f);
1265 assert_not_reached("Uh, control process died at wrong time.");
1268 /* Notify clients about changed exit status */
1269 unit_add_to_dbus_queue(u);
1272 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1273 Mount *m = MOUNT(userdata);
1276 assert(m->timer_event_source == source);
1280 case MOUNT_MOUNTING:
1281 case MOUNT_MOUNTING_DONE:
1282 log_warning_unit(UNIT(m)->id,
1283 "%s mounting timed out. Stopping.", UNIT(m)->id);
1284 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1287 case MOUNT_REMOUNTING:
1288 log_warning_unit(UNIT(m)->id,
1289 "%s remounting timed out. Stopping.", UNIT(m)->id);
1290 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1291 mount_enter_mounted(m, MOUNT_SUCCESS);
1294 case MOUNT_UNMOUNTING:
1295 log_warning_unit(UNIT(m)->id,
1296 "%s unmounting timed out. Stopping.", UNIT(m)->id);
1297 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1300 case MOUNT_MOUNTING_SIGTERM:
1301 if (m->kill_context.send_sigkill) {
1302 log_warning_unit(UNIT(m)->id,
1303 "%s mounting timed out. Killing.", UNIT(m)->id);
1304 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1306 log_warning_unit(UNIT(m)->id,
1307 "%s mounting timed out. Skipping SIGKILL. Ignoring.",
1310 if (m->from_proc_self_mountinfo)
1311 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1313 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1317 case MOUNT_REMOUNTING_SIGTERM:
1318 if (m->kill_context.send_sigkill) {
1319 log_warning_unit(UNIT(m)->id,
1320 "%s remounting timed out. Killing.", UNIT(m)->id);
1321 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1323 log_warning_unit(UNIT(m)->id,
1324 "%s remounting timed out. Skipping SIGKILL. Ignoring.",
1327 if (m->from_proc_self_mountinfo)
1328 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1330 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1334 case MOUNT_UNMOUNTING_SIGTERM:
1335 if (m->kill_context.send_sigkill) {
1336 log_warning_unit(UNIT(m)->id,
1337 "%s unmounting timed out. Killing.", UNIT(m)->id);
1338 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1340 log_warning_unit(UNIT(m)->id,
1341 "%s unmounting timed out. Skipping SIGKILL. Ignoring.",
1344 if (m->from_proc_self_mountinfo)
1345 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1347 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1351 case MOUNT_MOUNTING_SIGKILL:
1352 case MOUNT_REMOUNTING_SIGKILL:
1353 case MOUNT_UNMOUNTING_SIGKILL:
1354 log_warning_unit(UNIT(m)->id,
1355 "%s mount process still around after SIGKILL. Ignoring.",
1358 if (m->from_proc_self_mountinfo)
1359 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1361 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1365 assert_not_reached("Timeout at wrong time.");
1371 static int mount_add_one(
1375 const char *options,
1379 _cleanup_free_ char *e = NULL, *w = NULL, *o = NULL, *f = NULL;
1380 bool load_extras = false;
1382 bool delete, changed = false;
1392 /* Ignore API mount points. They should never be referenced in
1393 * dependencies ever. */
1394 if (mount_point_is_api(where) || mount_point_ignore(where))
1397 if (streq(fstype, "autofs"))
1400 /* probably some kind of swap, ignore */
1401 if (!is_path(where))
1404 e = unit_name_from_path(where, ".mount");
1408 u = manager_get_unit(m, e);
1412 u = unit_new(m, sizeof(Mount));
1416 r = unit_add_name(u, e);
1420 MOUNT(u)->where = strdup(where);
1421 if (!MOUNT(u)->where) {
1426 u->source_path = strdup("/proc/self/mountinfo");
1427 if (!u->source_path) {
1433 if (m->running_as == SYSTEMD_SYSTEM) {
1436 target = fstype_is_network(fstype) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1438 r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true);
1442 if (should_umount(MOUNT(u))) {
1443 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
1449 unit_add_to_load_queue(u);
1454 if (!MOUNT(u)->where) {
1455 MOUNT(u)->where = strdup(where);
1456 if (!MOUNT(u)->where) {
1462 if (u->load_state == UNIT_NOT_FOUND) {
1463 u->load_state = UNIT_LOADED;
1466 /* Load in the extras later on, after we
1467 * finished initialization of the unit */
1474 o = strdup(options);
1476 if (!w || !o || !f) {
1481 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1483 changed = changed ||
1484 !streq_ptr(p->options, options) ||
1485 !streq_ptr(p->what, what) ||
1486 !streq_ptr(p->fstype, fstype);
1489 MOUNT(u)->is_mounted = true;
1490 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1491 MOUNT(u)->just_changed = changed;
1494 MOUNT(u)->from_proc_self_mountinfo = true;
1509 r = mount_add_extras(MOUNT(u));
1515 unit_add_to_dbus_queue(u);
1526 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1532 rewind(m->proc_self_mountinfo);
1535 _cleanup_free_ char *device = NULL, *path = NULL, *options = NULL, *options2 = NULL, *fstype = NULL, *d = NULL, *p = NULL, *o = NULL;
1538 k = fscanf(m->proc_self_mountinfo,
1539 "%*s " /* (1) mount id */
1540 "%*s " /* (2) parent id */
1541 "%*s " /* (3) major:minor */
1542 "%*s " /* (4) root */
1543 "%ms " /* (5) mount point */
1544 "%ms" /* (6) mount options */
1545 "%*[^-]" /* (7) optional fields */
1546 "- " /* (8) separator */
1547 "%ms " /* (9) file system type */
1548 "%ms" /* (10) mount source */
1549 "%ms" /* (11) mount options 2 */
1550 "%*[^\n]", /* some rubbish at the end */
1561 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1565 o = strjoin(options, ",", options2, NULL);
1569 d = cunescape(device);
1570 p = cunescape(path);
1574 k = mount_add_one(m, d, p, o, fstype, set_flags);
1582 static void mount_shutdown(Manager *m) {
1585 m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1587 if (m->proc_self_mountinfo) {
1588 fclose(m->proc_self_mountinfo);
1589 m->proc_self_mountinfo = NULL;
1593 static int mount_get_timeout(Unit *u, uint64_t *timeout) {
1594 Mount *m = MOUNT(u);
1597 if (!m->timer_event_source)
1600 r = sd_event_source_get_time(m->timer_event_source, timeout);
1607 static int mount_enumerate(Manager *m) {
1611 if (!m->proc_self_mountinfo) {
1612 m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
1613 if (!m->proc_self_mountinfo)
1616 r = sd_event_add_io(m->event, &m->mount_event_source, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m);
1620 /* Dispatch this before we dispatch SIGCHLD, so that
1621 * we always get the events from /proc/self/mountinfo
1622 * before the SIGCHLD of /bin/mount. */
1623 r = sd_event_source_set_priority(m->mount_event_source, -10);
1628 r = mount_load_proc_self_mountinfo(m, false);
1639 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1640 Manager *m = userdata;
1645 assert(revents & EPOLLPRI);
1647 /* The manager calls this for every fd event happening on the
1648 * /proc/self/mountinfo file, which informs us about mounting
1651 r = mount_load_proc_self_mountinfo(m, true);
1653 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1655 /* Reset flags, just in case, for later calls */
1656 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1657 Mount *mount = MOUNT(u);
1659 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1665 manager_dispatch_load_queue(m);
1667 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1668 Mount *mount = MOUNT(u);
1670 if (!mount->is_mounted) {
1672 mount->from_proc_self_mountinfo = false;
1674 switch (mount->state) {
1677 /* This has just been unmounted by
1678 * somebody else, follow the state
1680 mount_enter_dead(mount, MOUNT_SUCCESS);
1687 } else if (mount->just_mounted || mount->just_changed) {
1689 /* New or changed mount entry */
1691 switch (mount->state) {
1695 /* This has just been mounted by
1696 * somebody else, follow the state
1698 mount_enter_mounted(mount, MOUNT_SUCCESS);
1701 case MOUNT_MOUNTING:
1702 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1706 /* Nothing really changed, but let's
1707 * issue an notification call
1708 * nonetheless, in case somebody is
1709 * waiting for this. (e.g. file system
1710 * ro/rw remounts.) */
1711 mount_set_state(mount, mount->state);
1716 /* Reset the flags for later calls */
1717 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1723 static void mount_reset_failed(Unit *u) {
1724 Mount *m = MOUNT(u);
1728 if (m->state == MOUNT_FAILED)
1729 mount_set_state(m, MOUNT_DEAD);
1731 m->result = MOUNT_SUCCESS;
1732 m->reload_result = MOUNT_SUCCESS;
1735 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1736 return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1739 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1740 [MOUNT_DEAD] = "dead",
1741 [MOUNT_MOUNTING] = "mounting",
1742 [MOUNT_MOUNTING_DONE] = "mounting-done",
1743 [MOUNT_MOUNTED] = "mounted",
1744 [MOUNT_REMOUNTING] = "remounting",
1745 [MOUNT_UNMOUNTING] = "unmounting",
1746 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1747 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1748 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1749 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1750 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1751 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1752 [MOUNT_FAILED] = "failed"
1755 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1757 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1758 [MOUNT_EXEC_MOUNT] = "ExecMount",
1759 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1760 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1763 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1765 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1766 [MOUNT_SUCCESS] = "success",
1767 [MOUNT_FAILURE_RESOURCES] = "resources",
1768 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1769 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1770 [MOUNT_FAILURE_SIGNAL] = "signal",
1771 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1774 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1776 const UnitVTable mount_vtable = {
1777 .object_size = sizeof(Mount),
1778 .exec_context_offset = offsetof(Mount, exec_context),
1779 .cgroup_context_offset = offsetof(Mount, cgroup_context),
1780 .kill_context_offset = offsetof(Mount, kill_context),
1781 .exec_runtime_offset = offsetof(Mount, exec_runtime),
1787 .private_section = "Mount",
1790 .no_instances = true,
1796 .coldplug = mount_coldplug,
1800 .start = mount_start,
1802 .reload = mount_reload,
1806 .serialize = mount_serialize,
1807 .deserialize_item = mount_deserialize_item,
1809 .active_state = mount_active_state,
1810 .sub_state_to_string = mount_sub_state_to_string,
1812 .check_gc = mount_check_gc,
1814 .sigchld_event = mount_sigchld_event,
1816 .reset_failed = mount_reset_failed,
1818 .bus_interface = "org.freedesktop.systemd1.Mount",
1819 .bus_vtable = bus_mount_vtable,
1820 .bus_set_property = bus_mount_set_property,
1821 .bus_commit_properties = bus_mount_commit_properties,
1823 .get_timeout = mount_get_timeout,
1825 .enumerate = mount_enumerate,
1826 .shutdown = mount_shutdown,
1828 .status_message_formats = {
1829 .starting_stopping = {
1830 [0] = "Mounting %s...",
1831 [1] = "Unmounting %s...",
1833 .finished_start_job = {
1834 [JOB_DONE] = "Mounted %s.",
1835 [JOB_FAILED] = "Failed to mount %s.",
1836 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1837 [JOB_TIMEOUT] = "Timed out mounting %s.",
1839 .finished_stop_job = {
1840 [JOB_DONE] = "Unmounted %s.",
1841 [JOB_FAILED] = "Failed unmounting %s.",
1842 [JOB_TIMEOUT] = "Timed out unmounting %s.",