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 if (unit_has_name(u, "-.mount")) {
127 /* Don't allow start/stop for root directory */
128 u->refuse_manual_start = true;
129 u->refuse_manual_stop = true;
131 /* The stdio/kmsg bridge socket is on /, in order to avoid a
132 * dep loop, don't use kmsg logging for -.mount */
133 m->exec_context.std_output = u->manager->default_std_output;
134 m->exec_context.std_error = u->manager->default_std_error;
137 /* We need to make sure that /bin/mount is always called in
138 * the same process group as us, so that the autofs kernel
139 * side doesn't send us another mount request while we are
140 * already trying to comply its last one. */
141 m->exec_context.same_pgrp = true;
143 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
145 u->ignore_on_isolate = true;
148 static int mount_arm_timer(Mount *m) {
153 if (m->timeout_usec <= 0) {
154 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
158 if (m->timer_event_source) {
159 r = sd_event_source_set_time(m->timer_event_source, now(CLOCK_MONOTONIC) + m->timeout_usec);
163 return sd_event_source_set_enabled(m->timer_event_source, SD_EVENT_ONESHOT);
166 return sd_event_add_time(
167 UNIT(m)->manager->event,
168 &m->timer_event_source,
170 now(CLOCK_MONOTONIC) + m->timeout_usec, 0,
171 mount_dispatch_timer, m);
174 static void mount_unwatch_control_pid(Mount *m) {
177 if (m->control_pid <= 0)
180 unit_unwatch_pid(UNIT(m), m->control_pid);
184 static void mount_parameters_done(MountParameters *p) {
191 p->what = p->options = p->fstype = NULL;
194 static void mount_done(Unit *u) {
202 mount_parameters_done(&m->parameters_proc_self_mountinfo);
203 mount_parameters_done(&m->parameters_fragment);
205 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
206 exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
207 m->control_command = NULL;
209 mount_unwatch_control_pid(m);
211 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
214 _pure_ static MountParameters* get_mount_parameters_fragment(Mount *m) {
217 if (m->from_fragment)
218 return &m->parameters_fragment;
223 _pure_ static MountParameters* get_mount_parameters(Mount *m) {
226 if (m->from_proc_self_mountinfo)
227 return &m->parameters_proc_self_mountinfo;
229 return get_mount_parameters_fragment(m);
232 static int mount_add_mount_links(Mount *m) {
233 _cleanup_free_ char *parent = NULL;
242 if (!path_equal(m->where, "/")) {
243 /* Adds in links to other mount points that might lie further
244 * up in the hierarchy */
245 r = path_get_parent(m->where, &parent);
249 r = unit_require_mounts_for(UNIT(m), parent);
254 /* Adds in links to other mount points that might be needed
255 * for the source path (if this is a bind mount) to be
257 pm = get_mount_parameters_fragment(m);
258 if (pm && pm->what &&
259 path_is_absolute(pm->what) &&
260 !mount_is_network(pm)) {
262 r = unit_require_mounts_for(UNIT(m), pm->what);
267 /* Adds in links to other units that use this path or paths
268 * further down in the hierarchy */
269 s = manager_get_units_requiring_mounts_for(UNIT(m)->manager, m->where);
270 SET_FOREACH(other, s, i) {
272 if (other->load_state != UNIT_LOADED)
275 if (other == UNIT(m))
278 r = unit_add_dependency(other, UNIT_AFTER, UNIT(m), true);
282 if (UNIT(m)->fragment_path) {
283 /* If we have fragment configuration, then make this dependency required */
284 r = unit_add_dependency(other, UNIT_REQUIRES, UNIT(m), true);
293 static int mount_add_device_links(Mount *m) {
295 bool device_wants_mount = false;
300 p = get_mount_parameters_fragment(m);
307 if (mount_is_bind(p))
310 if (!is_device_path(p->what))
313 if (path_equal(m->where, "/"))
316 if (mount_is_auto(p) && UNIT(m)->manager->running_as == SYSTEMD_SYSTEM)
317 device_wants_mount = true;
319 r = unit_add_node_link(UNIT(m), p->what, device_wants_mount);
326 static int mount_add_quota_links(Mount *m) {
332 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
335 p = get_mount_parameters_fragment(m);
342 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true);
346 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true);
353 static bool should_umount(Mount *m) {
356 if (path_equal(m->where, "/") ||
357 path_equal(m->where, "/usr"))
360 p = get_mount_parameters(m);
361 if (p && mount_test_option(p->options, "x-initrd.mount") &&
368 static int mount_add_default_dependencies(Mount *m) {
369 const char *after, *after2, *online;
375 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
378 p = get_mount_parameters(m);
383 if (path_equal(m->where, "/") ||
384 path_equal(m->where, "/usr"))
387 if (mount_is_network(p)) {
388 after = SPECIAL_REMOTE_FS_PRE_TARGET;
389 after2 = SPECIAL_NETWORK_TARGET;
390 online = SPECIAL_NETWORK_ONLINE_TARGET;
392 after = SPECIAL_LOCAL_FS_PRE_TARGET;
397 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true);
402 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after2, NULL, true);
408 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, online, NULL, true);
413 if (should_umount(m)) {
414 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
422 static int mount_verify(Mount *m) {
423 _cleanup_free_ char *e = NULL;
428 if (UNIT(m)->load_state != UNIT_LOADED)
431 if (!m->from_fragment && !m->from_proc_self_mountinfo)
434 e = unit_name_from_path(m->where, ".mount");
438 b = unit_has_name(UNIT(m), e);
440 log_error_unit(UNIT(m)->id, "%s's Where= setting doesn't match unit name. Refusing.", UNIT(m)->id);
444 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
445 log_error_unit(UNIT(m)->id, "Cannot create mount unit for API file system %s. Refusing.", m->where);
449 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
450 log_error_unit(UNIT(m)->id, "%s's What setting is missing. Refusing.", UNIT(m)->id);
454 if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
455 log_error_unit(UNIT(m)->id, "%s has PAM enabled. Kill mode must be set to control-group'. Refusing.",UNIT(m)->id);
462 static int mount_add_extras(Mount *m) {
468 if (u->fragment_path)
469 m->from_fragment = true;
472 m->where = unit_name_to_path(u->id);
477 path_kill_slashes(m->where);
479 if (!u->description) {
480 r = unit_set_description(u, m->where);
485 r = mount_add_device_links(m);
489 r = mount_add_mount_links(m);
493 r = mount_add_quota_links(m);
497 r = unit_patch_contexts(u);
501 r = unit_add_exec_dependencies(u, &m->exec_context);
505 r = unit_add_default_slice(u, &m->cgroup_context);
509 if (u->default_dependencies) {
510 r = mount_add_default_dependencies(m);
518 static int mount_load(Unit *u) {
523 assert(u->load_state == UNIT_STUB);
525 if (m->from_proc_self_mountinfo)
526 r = unit_load_fragment_and_dropin_optional(u);
528 r = unit_load_fragment_and_dropin(u);
533 /* This is a new unit? Then let's add in some extras */
534 if (u->load_state == UNIT_LOADED) {
535 r = mount_add_extras(m);
540 return mount_verify(m);
543 static int mount_notify_automount(Mount *m, int status) {
550 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
551 if (p->type == UNIT_AUTOMOUNT) {
552 r = automount_send_ready(AUTOMOUNT(p), status);
560 static void mount_set_state(Mount *m, MountState state) {
561 MountState old_state;
564 old_state = m->state;
567 if (state != MOUNT_MOUNTING &&
568 state != MOUNT_MOUNTING_DONE &&
569 state != MOUNT_REMOUNTING &&
570 state != MOUNT_UNMOUNTING &&
571 state != MOUNT_MOUNTING_SIGTERM &&
572 state != MOUNT_MOUNTING_SIGKILL &&
573 state != MOUNT_UNMOUNTING_SIGTERM &&
574 state != MOUNT_UNMOUNTING_SIGKILL &&
575 state != MOUNT_REMOUNTING_SIGTERM &&
576 state != MOUNT_REMOUNTING_SIGKILL) {
577 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
578 mount_unwatch_control_pid(m);
579 m->control_command = NULL;
580 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
583 if (state == MOUNT_MOUNTED ||
584 state == MOUNT_REMOUNTING)
585 mount_notify_automount(m, 0);
586 else if (state == MOUNT_DEAD ||
587 state == MOUNT_UNMOUNTING ||
588 state == MOUNT_MOUNTING_SIGTERM ||
589 state == MOUNT_MOUNTING_SIGKILL ||
590 state == MOUNT_REMOUNTING_SIGTERM ||
591 state == MOUNT_REMOUNTING_SIGKILL ||
592 state == MOUNT_UNMOUNTING_SIGTERM ||
593 state == MOUNT_UNMOUNTING_SIGKILL ||
594 state == MOUNT_FAILED) {
595 if (state != old_state)
596 mount_notify_automount(m, -ENODEV);
599 if (state != old_state)
600 log_debug_unit(UNIT(m)->id,
601 "%s changed %s -> %s",
603 mount_state_to_string(old_state),
604 mount_state_to_string(state));
606 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
607 m->reload_result = MOUNT_SUCCESS;
610 static int mount_coldplug(Unit *u) {
612 MountState new_state = MOUNT_DEAD;
616 assert(m->state == MOUNT_DEAD);
618 if (m->deserialized_state != m->state)
619 new_state = m->deserialized_state;
620 else if (m->from_proc_self_mountinfo)
621 new_state = MOUNT_MOUNTED;
623 if (new_state == m->state)
626 if (new_state == MOUNT_MOUNTING ||
627 new_state == MOUNT_MOUNTING_DONE ||
628 new_state == MOUNT_REMOUNTING ||
629 new_state == MOUNT_UNMOUNTING ||
630 new_state == MOUNT_MOUNTING_SIGTERM ||
631 new_state == MOUNT_MOUNTING_SIGKILL ||
632 new_state == MOUNT_UNMOUNTING_SIGTERM ||
633 new_state == MOUNT_UNMOUNTING_SIGKILL ||
634 new_state == MOUNT_REMOUNTING_SIGTERM ||
635 new_state == MOUNT_REMOUNTING_SIGKILL) {
637 if (m->control_pid <= 0)
640 r = unit_watch_pid(UNIT(m), m->control_pid);
644 r = mount_arm_timer(m);
649 mount_set_state(m, new_state);
653 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
660 p = get_mount_parameters(m);
663 "%sMount State: %s\n"
667 "%sFile System Type: %s\n"
669 "%sFrom /proc/self/mountinfo: %s\n"
670 "%sFrom fragment: %s\n"
671 "%sDirectoryMode: %04o\n",
672 prefix, mount_state_to_string(m->state),
673 prefix, mount_result_to_string(m->result),
675 prefix, p ? strna(p->what) : "n/a",
676 prefix, p ? strna(p->fstype) : "n/a",
677 prefix, p ? strna(p->options) : "n/a",
678 prefix, yes_no(m->from_proc_self_mountinfo),
679 prefix, yes_no(m->from_fragment),
680 prefix, m->directory_mode);
682 if (m->control_pid > 0)
684 "%sControl PID: "PID_FMT"\n",
685 prefix, m->control_pid);
687 exec_context_dump(&m->exec_context, f, prefix);
688 kill_context_dump(&m->kill_context, f, prefix);
691 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
694 ExecParameters exec_params = {
695 .apply_permissions = true,
696 .apply_chroot = true,
697 .apply_tty_stdin = true,
704 unit_realize_cgroup(UNIT(m));
706 r = unit_setup_exec_runtime(UNIT(m));
710 r = mount_arm_timer(m);
714 exec_params.environment = UNIT(m)->manager->environment;
715 exec_params.confirm_spawn = UNIT(m)->manager->confirm_spawn;
716 exec_params.cgroup_supported = UNIT(m)->manager->cgroup_supported;
717 exec_params.cgroup_path = UNIT(m)->cgroup_path;
718 exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(m)->manager);
719 exec_params.unit_id = UNIT(m)->id;
729 r = unit_watch_pid(UNIT(m), pid);
731 /* FIXME: we need to do something here */
739 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
744 static void mount_enter_dead(Mount *m, MountResult f) {
747 if (f != MOUNT_SUCCESS)
750 exec_runtime_destroy(m->exec_runtime);
751 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
753 exec_context_destroy_runtime_directory(&m->exec_context, manager_get_runtime_prefix(UNIT(m)->manager));
755 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
758 static void mount_enter_mounted(Mount *m, MountResult f) {
761 if (f != MOUNT_SUCCESS)
764 mount_set_state(m, MOUNT_MOUNTED);
767 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
772 if (f != MOUNT_SUCCESS)
775 r = unit_kill_context(
778 (state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM) ?
779 KILL_KILL : KILL_TERMINATE,
787 r = mount_arm_timer(m);
791 mount_set_state(m, state);
792 } else if (state == MOUNT_REMOUNTING_SIGTERM)
793 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
794 else if (state == MOUNT_REMOUNTING_SIGKILL)
795 mount_enter_mounted(m, MOUNT_SUCCESS);
796 else if (state == MOUNT_MOUNTING_SIGTERM)
797 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_SUCCESS);
798 else if (state == MOUNT_UNMOUNTING_SIGTERM)
799 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
801 mount_enter_dead(m, MOUNT_SUCCESS);
806 log_warning_unit(UNIT(m)->id,
807 "%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
809 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
810 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
812 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
815 void warn_if_dir_nonempty(const char *unit, const char* where) {
819 if (dir_is_empty(where) > 0)
822 log_struct_unit(LOG_NOTICE,
824 "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
827 MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
831 static int fail_if_symlink(const char *unit, const char* where) {
834 if (is_symlink(where) > 0) {
835 log_struct_unit(LOG_WARNING,
837 "MESSAGE=%s: Mount on symlink %s not allowed.",
840 MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
848 static void mount_enter_unmounting(Mount *m) {
853 m->control_command_id = MOUNT_EXEC_UNMOUNT;
854 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
856 if ((r = exec_command_set(
864 mount_unwatch_control_pid(m);
866 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
869 mount_set_state(m, MOUNT_UNMOUNTING);
874 log_warning_unit(UNIT(m)->id,
875 "%s failed to run 'umount' task: %s",
876 UNIT(m)->id, strerror(-r));
877 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
880 static void mount_enter_mounting(Mount *m) {
886 m->control_command_id = MOUNT_EXEC_MOUNT;
887 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
889 mkdir_p_label(m->where, m->directory_mode);
891 warn_if_dir_nonempty(m->meta.id, m->where);
893 /* Create the source directory for bind-mounts if needed */
894 p = get_mount_parameters_fragment(m);
895 if (p && mount_is_bind(p))
896 mkdir_p_label(p->what, m->directory_mode);
898 r = fail_if_symlink(m->meta.id, m->where);
902 if (m->from_fragment)
903 r = exec_command_set(
906 m->sloppy_options ? "-ns" : "-n",
907 m->parameters_fragment.what,
909 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
910 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
918 mount_unwatch_control_pid(m);
920 r = mount_spawn(m, m->control_command, &m->control_pid);
924 mount_set_state(m, MOUNT_MOUNTING);
929 log_warning_unit(UNIT(m)->id,
930 "%s failed to run 'mount' task: %s",
931 UNIT(m)->id, strerror(-r));
932 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
935 static void mount_enter_remounting(Mount *m) {
940 m->control_command_id = MOUNT_EXEC_REMOUNT;
941 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
943 if (m->from_fragment) {
946 if (m->parameters_fragment.options)
947 o = strappenda("remount,", m->parameters_fragment.options);
951 r = exec_command_set(
954 m->sloppy_options ? "-ns" : "-n",
955 m->parameters_fragment.what,
957 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
966 mount_unwatch_control_pid(m);
968 r = mount_spawn(m, m->control_command, &m->control_pid);
972 mount_set_state(m, MOUNT_REMOUNTING);
977 log_warning_unit(UNIT(m)->id,
978 "%s failed to run 'remount' task: %s",
979 UNIT(m)->id, strerror(-r));
980 m->reload_result = MOUNT_FAILURE_RESOURCES;
981 mount_enter_mounted(m, MOUNT_SUCCESS);
984 static int mount_start(Unit *u) {
989 /* We cannot fulfill this request right now, try again later
991 if (m->state == MOUNT_UNMOUNTING ||
992 m->state == MOUNT_UNMOUNTING_SIGTERM ||
993 m->state == MOUNT_UNMOUNTING_SIGKILL ||
994 m->state == MOUNT_MOUNTING_SIGTERM ||
995 m->state == MOUNT_MOUNTING_SIGKILL)
999 if (m->state == MOUNT_MOUNTING)
1002 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1004 m->result = MOUNT_SUCCESS;
1005 m->reload_result = MOUNT_SUCCESS;
1007 mount_enter_mounting(m);
1011 static int mount_stop(Unit *u) {
1012 Mount *m = MOUNT(u);
1017 if (m->state == MOUNT_UNMOUNTING ||
1018 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1019 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1020 m->state == MOUNT_MOUNTING_SIGTERM ||
1021 m->state == MOUNT_MOUNTING_SIGKILL)
1024 assert(m->state == MOUNT_MOUNTING ||
1025 m->state == MOUNT_MOUNTING_DONE ||
1026 m->state == MOUNT_MOUNTED ||
1027 m->state == MOUNT_REMOUNTING ||
1028 m->state == MOUNT_REMOUNTING_SIGTERM ||
1029 m->state == MOUNT_REMOUNTING_SIGKILL);
1031 mount_enter_unmounting(m);
1035 static int mount_reload(Unit *u) {
1036 Mount *m = MOUNT(u);
1040 if (m->state == MOUNT_MOUNTING_DONE)
1043 assert(m->state == MOUNT_MOUNTED);
1045 mount_enter_remounting(m);
1049 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1050 Mount *m = MOUNT(u);
1056 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1057 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1058 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1060 if (m->control_pid > 0)
1061 unit_serialize_item_format(u, f, "control-pid", PID_FMT, m->control_pid);
1063 if (m->control_command_id >= 0)
1064 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1069 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1070 Mount *m = MOUNT(u);
1077 if (streq(key, "state")) {
1080 if ((state = mount_state_from_string(value)) < 0)
1081 log_debug_unit(u->id, "Failed to parse state value %s", value);
1083 m->deserialized_state = state;
1084 } else if (streq(key, "result")) {
1087 f = mount_result_from_string(value);
1089 log_debug_unit(UNIT(m)->id,
1090 "Failed to parse result value %s", value);
1091 else if (f != MOUNT_SUCCESS)
1094 } else if (streq(key, "reload-result")) {
1097 f = mount_result_from_string(value);
1099 log_debug_unit(UNIT(m)->id,
1100 "Failed to parse reload result value %s", value);
1101 else if (f != MOUNT_SUCCESS)
1102 m->reload_result = f;
1104 } else if (streq(key, "control-pid")) {
1107 if (parse_pid(value, &pid) < 0)
1108 log_debug_unit(UNIT(m)->id,
1109 "Failed to parse control-pid value %s", value);
1111 m->control_pid = pid;
1112 } else if (streq(key, "control-command")) {
1113 MountExecCommand id;
1115 if ((id = mount_exec_command_from_string(value)) < 0)
1116 log_debug_unit(UNIT(m)->id,
1117 "Failed to parse exec-command value %s", value);
1119 m->control_command_id = id;
1120 m->control_command = m->exec_command + id;
1123 log_debug_unit(UNIT(m)->id,
1124 "Unknown serialization key '%s'", key);
1129 _pure_ static UnitActiveState mount_active_state(Unit *u) {
1132 return state_translation_table[MOUNT(u)->state];
1135 _pure_ static const char *mount_sub_state_to_string(Unit *u) {
1138 return mount_state_to_string(MOUNT(u)->state);
1141 _pure_ static bool mount_check_gc(Unit *u) {
1142 Mount *m = MOUNT(u);
1146 return m->from_proc_self_mountinfo;
1149 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1150 Mount *m = MOUNT(u);
1156 if (pid != m->control_pid)
1161 if (is_clean_exit(code, status, NULL))
1163 else if (code == CLD_EXITED)
1164 f = MOUNT_FAILURE_EXIT_CODE;
1165 else if (code == CLD_KILLED)
1166 f = MOUNT_FAILURE_SIGNAL;
1167 else if (code == CLD_DUMPED)
1168 f = MOUNT_FAILURE_CORE_DUMP;
1170 assert_not_reached("Unknown code");
1172 if (f != MOUNT_SUCCESS)
1175 if (m->control_command) {
1176 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1178 m->control_command = NULL;
1179 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1182 log_full_unit(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
1183 "%s mount process exited, code=%s status=%i",
1184 u->id, sigchld_code_to_string(code), status);
1186 /* Note that mount(8) returning and the kernel sending us a
1187 * mount table change event might happen out-of-order. If an
1188 * operation succeed we assume the kernel will follow soon too
1189 * and already change into the resulting state. If it fails
1190 * we check if the kernel still knows about the mount. and
1191 * change state accordingly. */
1195 case MOUNT_MOUNTING:
1196 case MOUNT_MOUNTING_DONE:
1197 case MOUNT_MOUNTING_SIGKILL:
1198 case MOUNT_MOUNTING_SIGTERM:
1200 if (f == MOUNT_SUCCESS)
1201 mount_enter_mounted(m, f);
1202 else if (m->from_proc_self_mountinfo)
1203 mount_enter_mounted(m, f);
1205 mount_enter_dead(m, f);
1208 case MOUNT_REMOUNTING:
1209 case MOUNT_REMOUNTING_SIGKILL:
1210 case MOUNT_REMOUNTING_SIGTERM:
1212 m->reload_result = f;
1213 if (m->from_proc_self_mountinfo)
1214 mount_enter_mounted(m, MOUNT_SUCCESS);
1216 mount_enter_dead(m, MOUNT_SUCCESS);
1220 case MOUNT_UNMOUNTING:
1221 case MOUNT_UNMOUNTING_SIGKILL:
1222 case MOUNT_UNMOUNTING_SIGTERM:
1224 if (f == MOUNT_SUCCESS)
1225 mount_enter_dead(m, f);
1226 else if (m->from_proc_self_mountinfo)
1227 mount_enter_mounted(m, f);
1229 mount_enter_dead(m, f);
1233 assert_not_reached("Uh, control process died at wrong time.");
1236 /* Notify clients about changed exit status */
1237 unit_add_to_dbus_queue(u);
1240 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1241 Mount *m = MOUNT(userdata);
1244 assert(m->timer_event_source == source);
1248 case MOUNT_MOUNTING:
1249 case MOUNT_MOUNTING_DONE:
1250 log_warning_unit(UNIT(m)->id,
1251 "%s mounting timed out. Stopping.", UNIT(m)->id);
1252 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1255 case MOUNT_REMOUNTING:
1256 log_warning_unit(UNIT(m)->id,
1257 "%s remounting timed out. Stopping.", UNIT(m)->id);
1258 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1259 mount_enter_mounted(m, MOUNT_SUCCESS);
1262 case MOUNT_UNMOUNTING:
1263 log_warning_unit(UNIT(m)->id,
1264 "%s unmounting timed out. Stopping.", UNIT(m)->id);
1265 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1268 case MOUNT_MOUNTING_SIGTERM:
1269 if (m->kill_context.send_sigkill) {
1270 log_warning_unit(UNIT(m)->id,
1271 "%s mounting timed out. Killing.", UNIT(m)->id);
1272 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1274 log_warning_unit(UNIT(m)->id,
1275 "%s mounting timed out. Skipping SIGKILL. Ignoring.",
1278 if (m->from_proc_self_mountinfo)
1279 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1281 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1285 case MOUNT_REMOUNTING_SIGTERM:
1286 if (m->kill_context.send_sigkill) {
1287 log_warning_unit(UNIT(m)->id,
1288 "%s remounting timed out. Killing.", UNIT(m)->id);
1289 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1291 log_warning_unit(UNIT(m)->id,
1292 "%s remounting timed out. Skipping SIGKILL. Ignoring.",
1295 if (m->from_proc_self_mountinfo)
1296 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1298 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1302 case MOUNT_UNMOUNTING_SIGTERM:
1303 if (m->kill_context.send_sigkill) {
1304 log_warning_unit(UNIT(m)->id,
1305 "%s unmounting timed out. Killing.", UNIT(m)->id);
1306 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1308 log_warning_unit(UNIT(m)->id,
1309 "%s unmounting timed out. Skipping SIGKILL. Ignoring.",
1312 if (m->from_proc_self_mountinfo)
1313 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1315 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1319 case MOUNT_MOUNTING_SIGKILL:
1320 case MOUNT_REMOUNTING_SIGKILL:
1321 case MOUNT_UNMOUNTING_SIGKILL:
1322 log_warning_unit(UNIT(m)->id,
1323 "%s mount process still around after SIGKILL. Ignoring.",
1326 if (m->from_proc_self_mountinfo)
1327 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1329 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1333 assert_not_reached("Timeout at wrong time.");
1339 static int mount_add_one(
1343 const char *options,
1347 _cleanup_free_ char *e = NULL, *w = NULL, *o = NULL, *f = NULL;
1348 bool load_extras = false;
1350 bool delete, changed = false;
1360 /* Ignore API mount points. They should never be referenced in
1361 * dependencies ever. */
1362 if (mount_point_is_api(where) || mount_point_ignore(where))
1365 if (streq(fstype, "autofs"))
1368 /* probably some kind of swap, ignore */
1369 if (!is_path(where))
1372 e = unit_name_from_path(where, ".mount");
1376 u = manager_get_unit(m, e);
1380 u = unit_new(m, sizeof(Mount));
1384 r = unit_add_name(u, e);
1388 MOUNT(u)->where = strdup(where);
1389 if (!MOUNT(u)->where) {
1394 u->source_path = strdup("/proc/self/mountinfo");
1395 if (!u->source_path) {
1401 if (m->running_as == SYSTEMD_SYSTEM) {
1404 target = fstype_is_network(fstype) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1406 r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true);
1410 if (should_umount(MOUNT(u))) {
1411 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
1417 unit_add_to_load_queue(u);
1422 if (!MOUNT(u)->where) {
1423 MOUNT(u)->where = strdup(where);
1424 if (!MOUNT(u)->where) {
1430 if (u->load_state == UNIT_NOT_FOUND) {
1431 u->load_state = UNIT_LOADED;
1434 /* Load in the extras later on, after we
1435 * finished initialization of the unit */
1442 o = strdup(options);
1444 if (!w || !o || !f) {
1449 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1451 changed = changed ||
1452 !streq_ptr(p->options, options) ||
1453 !streq_ptr(p->what, what) ||
1454 !streq_ptr(p->fstype, fstype);
1457 MOUNT(u)->is_mounted = true;
1458 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1459 MOUNT(u)->just_changed = changed;
1462 MOUNT(u)->from_proc_self_mountinfo = true;
1477 r = mount_add_extras(MOUNT(u));
1483 unit_add_to_dbus_queue(u);
1494 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1500 rewind(m->proc_self_mountinfo);
1503 _cleanup_free_ char *device = NULL, *path = NULL, *options = NULL, *options2 = NULL, *fstype = NULL, *d = NULL, *p = NULL, *o = NULL;
1506 k = fscanf(m->proc_self_mountinfo,
1507 "%*s " /* (1) mount id */
1508 "%*s " /* (2) parent id */
1509 "%*s " /* (3) major:minor */
1510 "%*s " /* (4) root */
1511 "%ms " /* (5) mount point */
1512 "%ms" /* (6) mount options */
1513 "%*[^-]" /* (7) optional fields */
1514 "- " /* (8) separator */
1515 "%ms " /* (9) file system type */
1516 "%ms" /* (10) mount source */
1517 "%ms" /* (11) mount options 2 */
1518 "%*[^\n]", /* some rubbish at the end */
1529 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1533 o = strjoin(options, ",", options2, NULL);
1537 d = cunescape(device);
1538 p = cunescape(path);
1542 k = mount_add_one(m, d, p, o, fstype, set_flags);
1550 static void mount_shutdown(Manager *m) {
1553 m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1555 if (m->proc_self_mountinfo) {
1556 fclose(m->proc_self_mountinfo);
1557 m->proc_self_mountinfo = NULL;
1561 static int mount_get_timeout(Unit *u, uint64_t *timeout) {
1562 Mount *m = MOUNT(u);
1565 if (!m->timer_event_source)
1568 r = sd_event_source_get_time(m->timer_event_source, timeout);
1575 static int mount_enumerate(Manager *m) {
1579 if (!m->proc_self_mountinfo) {
1580 m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
1581 if (!m->proc_self_mountinfo)
1584 r = sd_event_add_io(m->event, &m->mount_event_source, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m);
1588 /* Dispatch this before we dispatch SIGCHLD, so that
1589 * we always get the events from /proc/self/mountinfo
1590 * before the SIGCHLD of /bin/mount. */
1591 r = sd_event_source_set_priority(m->mount_event_source, -10);
1596 r = mount_load_proc_self_mountinfo(m, false);
1607 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1608 Manager *m = userdata;
1613 assert(revents & EPOLLPRI);
1615 /* The manager calls this for every fd event happening on the
1616 * /proc/self/mountinfo file, which informs us about mounting
1619 r = mount_load_proc_self_mountinfo(m, true);
1621 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1623 /* Reset flags, just in case, for later calls */
1624 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1625 Mount *mount = MOUNT(u);
1627 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1633 manager_dispatch_load_queue(m);
1635 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1636 Mount *mount = MOUNT(u);
1638 if (!mount->is_mounted) {
1640 mount->from_proc_self_mountinfo = false;
1642 switch (mount->state) {
1645 /* This has just been unmounted by
1646 * somebody else, follow the state
1648 mount_enter_dead(mount, MOUNT_SUCCESS);
1655 } else if (mount->just_mounted || mount->just_changed) {
1657 /* New or changed mount entry */
1659 switch (mount->state) {
1663 /* This has just been mounted by
1664 * somebody else, follow the state
1666 mount_enter_mounted(mount, MOUNT_SUCCESS);
1669 case MOUNT_MOUNTING:
1670 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1674 /* Nothing really changed, but let's
1675 * issue an notification call
1676 * nonetheless, in case somebody is
1677 * waiting for this. (e.g. file system
1678 * ro/rw remounts.) */
1679 mount_set_state(mount, mount->state);
1684 /* Reset the flags for later calls */
1685 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1691 static void mount_reset_failed(Unit *u) {
1692 Mount *m = MOUNT(u);
1696 if (m->state == MOUNT_FAILED)
1697 mount_set_state(m, MOUNT_DEAD);
1699 m->result = MOUNT_SUCCESS;
1700 m->reload_result = MOUNT_SUCCESS;
1703 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1704 return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1707 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1708 [MOUNT_DEAD] = "dead",
1709 [MOUNT_MOUNTING] = "mounting",
1710 [MOUNT_MOUNTING_DONE] = "mounting-done",
1711 [MOUNT_MOUNTED] = "mounted",
1712 [MOUNT_REMOUNTING] = "remounting",
1713 [MOUNT_UNMOUNTING] = "unmounting",
1714 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1715 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1716 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1717 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1718 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1719 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1720 [MOUNT_FAILED] = "failed"
1723 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1725 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1726 [MOUNT_EXEC_MOUNT] = "ExecMount",
1727 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1728 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1731 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1733 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1734 [MOUNT_SUCCESS] = "success",
1735 [MOUNT_FAILURE_RESOURCES] = "resources",
1736 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1737 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1738 [MOUNT_FAILURE_SIGNAL] = "signal",
1739 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1742 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1744 const UnitVTable mount_vtable = {
1745 .object_size = sizeof(Mount),
1746 .exec_context_offset = offsetof(Mount, exec_context),
1747 .cgroup_context_offset = offsetof(Mount, cgroup_context),
1748 .kill_context_offset = offsetof(Mount, kill_context),
1749 .exec_runtime_offset = offsetof(Mount, exec_runtime),
1755 .private_section = "Mount",
1758 .no_instances = true,
1764 .coldplug = mount_coldplug,
1768 .start = mount_start,
1770 .reload = mount_reload,
1774 .serialize = mount_serialize,
1775 .deserialize_item = mount_deserialize_item,
1777 .active_state = mount_active_state,
1778 .sub_state_to_string = mount_sub_state_to_string,
1780 .check_gc = mount_check_gc,
1782 .sigchld_event = mount_sigchld_event,
1784 .reset_failed = mount_reset_failed,
1786 .bus_interface = "org.freedesktop.systemd1.Mount",
1787 .bus_vtable = bus_mount_vtable,
1788 .bus_set_property = bus_mount_set_property,
1789 .bus_commit_properties = bus_mount_commit_properties,
1791 .get_timeout = mount_get_timeout,
1793 .can_transient = true,
1795 .enumerate = mount_enumerate,
1796 .shutdown = mount_shutdown,
1798 .status_message_formats = {
1799 .starting_stopping = {
1800 [0] = "Mounting %s...",
1801 [1] = "Unmounting %s...",
1803 .finished_start_job = {
1804 [JOB_DONE] = "Mounted %s.",
1805 [JOB_FAILED] = "Failed to mount %s.",
1806 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1807 [JOB_TIMEOUT] = "Timed out mounting %s.",
1809 .finished_stop_job = {
1810 [JOB_DONE] = "Unmounted %s.",
1811 [JOB_FAILED] = "Failed unmounting %s.",
1812 [JOB_TIMEOUT] = "Timed out unmounting %s.",