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"))
335 static bool needs_quota(MountParameters *p) {
338 if (mount_is_network(p))
341 if (mount_is_bind(p))
344 return mount_test_option(p->options, "usrquota") ||
345 mount_test_option(p->options, "grpquota") ||
346 mount_test_option(p->options, "quota") ||
347 mount_test_option(p->options, "usrjquota") ||
348 mount_test_option(p->options, "grpjquota");
351 static int mount_add_device_links(Mount *m) {
357 p = get_mount_parameters_fragment(m);
364 if (mount_is_bind(p))
367 if (!is_device_path(p->what))
370 if (path_equal(m->where, "/"))
373 r = unit_add_node_link(UNIT(m), p->what, false);
378 UNIT(m)->manager->running_as == SYSTEMD_SYSTEM) {
381 /* Let's add in the fsck service */
383 /* aka SPECIAL_FSCK_SERVICE */
384 name = unit_name_from_path_instance("systemd-fsck", p->what, ".service");
388 r = manager_load_unit_prepare(UNIT(m)->manager, name, NULL, NULL, &fsck);
390 log_warning_unit(name,
391 "Failed to prepare unit %s: %s", name, strerror(-r));
397 SERVICE(fsck)->fsck_passno = p->passno;
399 r = unit_add_two_dependencies(UNIT(m), UNIT_AFTER, UNIT_REQUIRES, fsck, true);
407 static int mount_add_quota_links(Mount *m) {
413 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
416 p = get_mount_parameters_fragment(m);
423 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true);
427 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true);
434 static int mount_add_default_dependencies(Mount *m) {
441 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
444 p = get_mount_parameters_fragment(m);
448 if (path_equal(m->where, "/"))
451 if (mount_is_network(p))
452 after = SPECIAL_REMOTE_FS_PRE_TARGET;
454 after = SPECIAL_LOCAL_FS_PRE_TARGET;
456 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, after, NULL, true);
460 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
467 static int mount_fix_timeouts(Mount *m) {
469 const char *timeout = NULL;
478 p = get_mount_parameters_fragment(m);
482 /* Allow configuration how long we wait for a device that
483 * backs a mount point to show up. This is useful to support
484 * endless device timeouts for devices that show up only after
485 * user input, like crypto devices. */
487 if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
489 else if ((timeout = mount_test_option(p->options, "x-systemd.device-timeout")))
494 t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
498 r = parse_usec(t, &u);
502 log_warning_unit(UNIT(m)->id,
503 "Failed to parse timeout for %s, ignoring: %s",
508 SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
509 if (other->type != UNIT_DEVICE)
512 other->job_timeout = u;
518 static int mount_verify(Mount *m) {
523 if (UNIT(m)->load_state != UNIT_LOADED)
526 if (!m->from_fragment && !m->from_proc_self_mountinfo)
529 if (!(e = unit_name_from_path(m->where, ".mount")))
532 b = unit_has_name(UNIT(m), e);
536 log_error_unit(UNIT(m)->id,
537 "%s's Where setting doesn't match unit name. Refusing.",
542 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
543 log_error_unit(UNIT(m)->id,
544 "Cannot create mount unit for API file system %s. Refusing.",
549 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
550 log_error_unit(UNIT(m)->id,
551 "%s's What setting is missing. Refusing.", UNIT(m)->id);
555 if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
556 log_error_unit(UNIT(m)->id,
557 "%s has PAM enabled. Kill mode must be set to control-group'. Refusing.",
565 static int mount_add_extras(Mount *m) {
569 if (UNIT(m)->fragment_path)
570 m->from_fragment = true;
573 m->where = unit_name_to_path(u->id);
578 path_kill_slashes(m->where);
580 r = unit_add_exec_dependencies(u, &m->exec_context);
584 if (!UNIT(m)->description) {
585 r = unit_set_description(u, m->where);
590 r = mount_add_device_links(m);
594 r = mount_add_mount_links(m);
598 r = mount_add_socket_links(m);
602 r = mount_add_swap_links(m);
606 r = mount_add_path_links(m);
610 r = mount_add_requires_mounts_links(m);
614 r = mount_add_automount_links(m);
618 r = mount_add_quota_links(m);
622 if (UNIT(m)->default_dependencies) {
623 r = mount_add_default_dependencies(m);
628 r = unit_add_default_cgroups(u);
632 r = mount_fix_timeouts(m);
639 static int mount_load(Unit *u) {
644 assert(u->load_state == UNIT_STUB);
646 if (m->from_proc_self_mountinfo)
647 r = unit_load_fragment_and_dropin_optional(u);
649 r = unit_load_fragment_and_dropin(u);
654 /* This is a new unit? Then let's add in some extras */
655 if (u->load_state == UNIT_LOADED) {
656 r = mount_add_extras(m);
660 r = unit_exec_context_defaults(u, &m->exec_context);
665 return mount_verify(m);
668 static int mount_notify_automount(Mount *m, int status) {
675 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
676 if (p->type == UNIT_AUTOMOUNT) {
677 r = automount_send_ready(AUTOMOUNT(p), status);
685 static void mount_set_state(Mount *m, MountState state) {
686 MountState old_state;
689 old_state = m->state;
692 if (state != MOUNT_MOUNTING &&
693 state != MOUNT_MOUNTING_DONE &&
694 state != MOUNT_REMOUNTING &&
695 state != MOUNT_UNMOUNTING &&
696 state != MOUNT_MOUNTING_SIGTERM &&
697 state != MOUNT_MOUNTING_SIGKILL &&
698 state != MOUNT_UNMOUNTING_SIGTERM &&
699 state != MOUNT_UNMOUNTING_SIGKILL &&
700 state != MOUNT_REMOUNTING_SIGTERM &&
701 state != MOUNT_REMOUNTING_SIGKILL) {
702 unit_unwatch_timer(UNIT(m), &m->timer_watch);
703 mount_unwatch_control_pid(m);
704 m->control_command = NULL;
705 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
708 if (state == MOUNT_MOUNTED ||
709 state == MOUNT_REMOUNTING)
710 mount_notify_automount(m, 0);
711 else if (state == MOUNT_DEAD ||
712 state == MOUNT_UNMOUNTING ||
713 state == MOUNT_MOUNTING_SIGTERM ||
714 state == MOUNT_MOUNTING_SIGKILL ||
715 state == MOUNT_REMOUNTING_SIGTERM ||
716 state == MOUNT_REMOUNTING_SIGKILL ||
717 state == MOUNT_UNMOUNTING_SIGTERM ||
718 state == MOUNT_UNMOUNTING_SIGKILL ||
719 state == MOUNT_FAILED) {
720 if (state != old_state)
721 mount_notify_automount(m, -ENODEV);
724 if (state != old_state)
725 log_debug_unit(UNIT(m)->id,
726 "%s changed %s -> %s",
728 mount_state_to_string(old_state),
729 mount_state_to_string(state));
731 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
732 m->reload_result = MOUNT_SUCCESS;
735 static int mount_coldplug(Unit *u) {
737 MountState new_state = MOUNT_DEAD;
741 assert(m->state == MOUNT_DEAD);
743 if (m->deserialized_state != m->state)
744 new_state = m->deserialized_state;
745 else if (m->from_proc_self_mountinfo)
746 new_state = MOUNT_MOUNTED;
748 if (new_state != m->state) {
750 if (new_state == MOUNT_MOUNTING ||
751 new_state == MOUNT_MOUNTING_DONE ||
752 new_state == MOUNT_REMOUNTING ||
753 new_state == MOUNT_UNMOUNTING ||
754 new_state == MOUNT_MOUNTING_SIGTERM ||
755 new_state == MOUNT_MOUNTING_SIGKILL ||
756 new_state == MOUNT_UNMOUNTING_SIGTERM ||
757 new_state == MOUNT_UNMOUNTING_SIGKILL ||
758 new_state == MOUNT_REMOUNTING_SIGTERM ||
759 new_state == MOUNT_REMOUNTING_SIGKILL) {
761 if (m->control_pid <= 0)
764 r = unit_watch_pid(UNIT(m), m->control_pid);
768 r = unit_watch_timer(UNIT(m), CLOCK_MONOTONIC, true, m->timeout_usec, &m->timer_watch);
773 mount_set_state(m, new_state);
779 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
786 p = get_mount_parameters(m);
789 "%sMount State: %s\n"
793 "%sFile System Type: %s\n"
795 "%sFrom /proc/self/mountinfo: %s\n"
796 "%sFrom fragment: %s\n"
797 "%sDirectoryMode: %04o\n",
798 prefix, mount_state_to_string(m->state),
799 prefix, mount_result_to_string(m->result),
801 prefix, strna(p->what),
802 prefix, strna(p->fstype),
803 prefix, strna(p->options),
804 prefix, yes_no(m->from_proc_self_mountinfo),
805 prefix, yes_no(m->from_fragment),
806 prefix, m->directory_mode);
808 if (m->control_pid > 0)
810 "%sControl PID: %lu\n",
811 prefix, (unsigned long) m->control_pid);
813 exec_context_dump(&m->exec_context, f, prefix);
814 kill_context_dump(&m->kill_context, f, prefix);
817 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
825 r = unit_watch_timer(UNIT(m), CLOCK_MONOTONIC, true, m->timeout_usec, &m->timer_watch);
829 if ((r = exec_spawn(c,
833 UNIT(m)->manager->environment,
837 UNIT(m)->manager->confirm_spawn,
838 UNIT(m)->cgroup_bondings,
839 UNIT(m)->cgroup_attributes,
846 if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
847 /* FIXME: we need to do something here */
855 unit_unwatch_timer(UNIT(m), &m->timer_watch);
860 static void mount_enter_dead(Mount *m, MountResult f) {
863 if (f != MOUNT_SUCCESS)
866 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
869 static void mount_enter_mounted(Mount *m, MountResult f) {
872 if (f != MOUNT_SUCCESS)
875 mount_set_state(m, MOUNT_MOUNTED);
878 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
881 bool wait_for_exit = false;
885 if (f != MOUNT_SUCCESS)
888 if (m->kill_context.kill_mode != KILL_NONE) {
889 int sig = (state == MOUNT_MOUNTING_SIGTERM ||
890 state == MOUNT_UNMOUNTING_SIGTERM ||
891 state == MOUNT_REMOUNTING_SIGTERM) ? m->kill_context.kill_signal : SIGKILL;
893 if (m->control_pid > 0) {
894 if (kill_and_sigcont(m->control_pid, sig) < 0 && errno != ESRCH)
896 log_warning_unit(UNIT(m)->id,
897 "Failed to kill control process %li: %m",
898 (long) m->control_pid);
900 wait_for_exit = true;
903 if (m->kill_context.kill_mode == KILL_CONTROL_GROUP) {
905 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
910 /* Exclude the control pid from being killed via the cgroup */
911 if (m->control_pid > 0)
912 if ((r = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0)
915 r = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, sig, true, false, pid_set, NULL);
917 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
918 log_warning_unit(UNIT(m)->id,
919 "Failed to kill control group: %s",
922 wait_for_exit = true;
930 r = unit_watch_timer(UNIT(m), CLOCK_MONOTONIC, true, m->timeout_usec, &m->timer_watch);
934 mount_set_state(m, state);
935 } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
936 mount_enter_mounted(m, MOUNT_SUCCESS);
938 mount_enter_dead(m, MOUNT_SUCCESS);
943 log_warning_unit(UNIT(m)->id,
944 "%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
946 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
947 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
949 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
955 void warn_if_dir_nonempty(const char *unit, const char* where) {
956 if (dir_is_empty(where) > 0)
958 log_struct_unit(LOG_NOTICE,
960 "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
963 MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
967 static void mount_enter_unmounting(Mount *m) {
972 m->control_command_id = MOUNT_EXEC_UNMOUNT;
973 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
975 if ((r = exec_command_set(
982 mount_unwatch_control_pid(m);
984 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
987 mount_set_state(m, MOUNT_UNMOUNTING);
992 log_warning_unit(UNIT(m)->id,
993 "%s failed to run 'umount' task: %s",
994 UNIT(m)->id, strerror(-r));
995 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
998 static void mount_enter_mounting(Mount *m) {
1004 m->control_command_id = MOUNT_EXEC_MOUNT;
1005 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
1007 mkdir_p_label(m->where, m->directory_mode);
1009 warn_if_dir_nonempty(m->meta.id, m->where);
1011 /* Create the source directory for bind-mounts if needed */
1012 p = get_mount_parameters_fragment(m);
1013 if (p && mount_is_bind(p))
1014 mkdir_p_label(p->what, m->directory_mode);
1016 if (m->from_fragment)
1017 r = exec_command_set(
1020 m->parameters_fragment.what,
1022 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
1023 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
1031 mount_unwatch_control_pid(m);
1033 r = mount_spawn(m, m->control_command, &m->control_pid);
1037 mount_set_state(m, MOUNT_MOUNTING);
1042 log_warning_unit(UNIT(m)->id,
1043 "%s failed to run 'mount' task: %s",
1044 UNIT(m)->id, strerror(-r));
1045 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
1048 static void mount_enter_mounting_done(Mount *m) {
1051 mount_set_state(m, MOUNT_MOUNTING_DONE);
1054 static void mount_enter_remounting(Mount *m) {
1059 m->control_command_id = MOUNT_EXEC_REMOUNT;
1060 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1062 if (m->from_fragment) {
1066 if (m->parameters_fragment.options) {
1067 if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
1076 r = exec_command_set(
1079 m->parameters_fragment.what,
1081 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
1092 mount_unwatch_control_pid(m);
1094 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1097 mount_set_state(m, MOUNT_REMOUNTING);
1102 log_warning_unit(UNIT(m)->id,
1103 "%s failed to run 'remount' task: %s",
1104 UNIT(m)->id, strerror(-r));
1105 m->reload_result = MOUNT_FAILURE_RESOURCES;
1106 mount_enter_mounted(m, MOUNT_SUCCESS);
1109 static int mount_start(Unit *u) {
1110 Mount *m = MOUNT(u);
1114 /* We cannot fulfill this request right now, try again later
1116 if (m->state == MOUNT_UNMOUNTING ||
1117 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1118 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1119 m->state == MOUNT_MOUNTING_SIGTERM ||
1120 m->state == MOUNT_MOUNTING_SIGKILL)
1123 /* Already on it! */
1124 if (m->state == MOUNT_MOUNTING)
1127 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1129 m->result = MOUNT_SUCCESS;
1130 m->reload_result = MOUNT_SUCCESS;
1132 mount_enter_mounting(m);
1136 static int mount_stop(Unit *u) {
1137 Mount *m = MOUNT(u);
1142 if (m->state == MOUNT_UNMOUNTING ||
1143 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1144 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1145 m->state == MOUNT_MOUNTING_SIGTERM ||
1146 m->state == MOUNT_MOUNTING_SIGKILL)
1149 assert(m->state == MOUNT_MOUNTING ||
1150 m->state == MOUNT_MOUNTING_DONE ||
1151 m->state == MOUNT_MOUNTED ||
1152 m->state == MOUNT_REMOUNTING ||
1153 m->state == MOUNT_REMOUNTING_SIGTERM ||
1154 m->state == MOUNT_REMOUNTING_SIGKILL);
1156 mount_enter_unmounting(m);
1160 static int mount_reload(Unit *u) {
1161 Mount *m = MOUNT(u);
1165 if (m->state == MOUNT_MOUNTING_DONE)
1168 assert(m->state == MOUNT_MOUNTED);
1170 mount_enter_remounting(m);
1174 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1175 Mount *m = MOUNT(u);
1181 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1182 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1183 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1185 if (m->control_pid > 0)
1186 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1188 if (m->control_command_id >= 0)
1189 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1194 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1195 Mount *m = MOUNT(u);
1202 if (streq(key, "state")) {
1205 if ((state = mount_state_from_string(value)) < 0)
1206 log_debug_unit(u->id, "Failed to parse state value %s", value);
1208 m->deserialized_state = state;
1209 } else if (streq(key, "result")) {
1212 f = mount_result_from_string(value);
1214 log_debug_unit(UNIT(m)->id,
1215 "Failed to parse result value %s", value);
1216 else if (f != MOUNT_SUCCESS)
1219 } else if (streq(key, "reload-result")) {
1222 f = mount_result_from_string(value);
1224 log_debug_unit(UNIT(m)->id,
1225 "Failed to parse reload result value %s", value);
1226 else if (f != MOUNT_SUCCESS)
1227 m->reload_result = f;
1229 } else if (streq(key, "control-pid")) {
1232 if (parse_pid(value, &pid) < 0)
1233 log_debug_unit(UNIT(m)->id,
1234 "Failed to parse control-pid value %s", value);
1236 m->control_pid = pid;
1237 } else if (streq(key, "control-command")) {
1238 MountExecCommand id;
1240 if ((id = mount_exec_command_from_string(value)) < 0)
1241 log_debug_unit(UNIT(m)->id,
1242 "Failed to parse exec-command value %s", value);
1244 m->control_command_id = id;
1245 m->control_command = m->exec_command + id;
1249 log_debug_unit(UNIT(m)->id,
1250 "Unknown serialization key '%s'", key);
1255 static UnitActiveState mount_active_state(Unit *u) {
1258 return state_translation_table[MOUNT(u)->state];
1261 static const char *mount_sub_state_to_string(Unit *u) {
1264 return mount_state_to_string(MOUNT(u)->state);
1267 static bool mount_check_gc(Unit *u) {
1268 Mount *m = MOUNT(u);
1272 return m->from_proc_self_mountinfo;
1275 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1276 Mount *m = MOUNT(u);
1282 if (pid != m->control_pid)
1287 if (is_clean_exit(code, status, NULL))
1289 else if (code == CLD_EXITED)
1290 f = MOUNT_FAILURE_EXIT_CODE;
1291 else if (code == CLD_KILLED)
1292 f = MOUNT_FAILURE_SIGNAL;
1293 else if (code == CLD_DUMPED)
1294 f = MOUNT_FAILURE_CORE_DUMP;
1296 assert_not_reached("Unknown code");
1298 if (f != MOUNT_SUCCESS)
1301 if (m->control_command) {
1302 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1304 m->control_command = NULL;
1305 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1308 log_full_unit(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
1309 "%s mount process exited, code=%s status=%i",
1310 u->id, sigchld_code_to_string(code), status);
1312 /* Note that mount(8) returning and the kernel sending us a
1313 * mount table change event might happen out-of-order. If an
1314 * operation succeed we assume the kernel will follow soon too
1315 * and already change into the resulting state. If it fails
1316 * we check if the kernel still knows about the mount. and
1317 * change state accordingly. */
1321 case MOUNT_MOUNTING:
1322 case MOUNT_MOUNTING_DONE:
1323 case MOUNT_MOUNTING_SIGKILL:
1324 case MOUNT_MOUNTING_SIGTERM:
1326 if (f == MOUNT_SUCCESS)
1327 mount_enter_mounted(m, f);
1328 else if (m->from_proc_self_mountinfo)
1329 mount_enter_mounted(m, f);
1331 mount_enter_dead(m, f);
1334 case MOUNT_REMOUNTING:
1335 case MOUNT_REMOUNTING_SIGKILL:
1336 case MOUNT_REMOUNTING_SIGTERM:
1338 m->reload_result = f;
1339 if (m->from_proc_self_mountinfo)
1340 mount_enter_mounted(m, MOUNT_SUCCESS);
1342 mount_enter_dead(m, MOUNT_SUCCESS);
1346 case MOUNT_UNMOUNTING:
1347 case MOUNT_UNMOUNTING_SIGKILL:
1348 case MOUNT_UNMOUNTING_SIGTERM:
1350 if (f == MOUNT_SUCCESS)
1351 mount_enter_dead(m, f);
1352 else if (m->from_proc_self_mountinfo)
1353 mount_enter_mounted(m, f);
1355 mount_enter_dead(m, f);
1359 assert_not_reached("Uh, control process died at wrong time.");
1362 /* Notify clients about changed exit status */
1363 unit_add_to_dbus_queue(u);
1366 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1367 Mount *m = MOUNT(u);
1370 assert(elapsed == 1);
1371 assert(w == &m->timer_watch);
1375 case MOUNT_MOUNTING:
1376 case MOUNT_MOUNTING_DONE:
1377 log_warning_unit(u->id,
1378 "%s mounting timed out. Stopping.", u->id);
1379 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1382 case MOUNT_REMOUNTING:
1383 log_warning_unit(u->id,
1384 "%s remounting timed out. Stopping.", u->id);
1385 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1386 mount_enter_mounted(m, MOUNT_SUCCESS);
1389 case MOUNT_UNMOUNTING:
1390 log_warning_unit(u->id,
1391 "%s unmounting timed out. Stopping.", u->id);
1392 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1395 case MOUNT_MOUNTING_SIGTERM:
1396 if (m->kill_context.send_sigkill) {
1397 log_warning_unit(u->id,
1398 "%s mounting timed out. Killing.", u->id);
1399 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1401 log_warning_unit(u->id,
1402 "%s mounting timed out. Skipping SIGKILL. Ignoring.",
1405 if (m->from_proc_self_mountinfo)
1406 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1408 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1412 case MOUNT_REMOUNTING_SIGTERM:
1413 if (m->kill_context.send_sigkill) {
1414 log_warning_unit(u->id,
1415 "%s remounting timed out. Killing.", u->id);
1416 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1418 log_warning_unit(u->id,
1419 "%s remounting timed out. Skipping SIGKILL. Ignoring.",
1422 if (m->from_proc_self_mountinfo)
1423 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1425 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1429 case MOUNT_UNMOUNTING_SIGTERM:
1430 if (m->kill_context.send_sigkill) {
1431 log_warning_unit(u->id,
1432 "%s unmounting timed out. Killing.", u->id);
1433 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1435 log_warning_unit(u->id,
1436 "%s unmounting timed out. Skipping SIGKILL. Ignoring.",
1439 if (m->from_proc_self_mountinfo)
1440 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1442 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1446 case MOUNT_MOUNTING_SIGKILL:
1447 case MOUNT_REMOUNTING_SIGKILL:
1448 case MOUNT_UNMOUNTING_SIGKILL:
1449 log_warning_unit(u->id,
1450 "%s mount process still around after SIGKILL. Ignoring.",
1453 if (m->from_proc_self_mountinfo)
1454 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1456 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1460 assert_not_reached("Timeout at wrong time.");
1464 static int mount_add_one(
1468 const char *options,
1475 char *e, *w = NULL, *o = NULL, *f = NULL;
1477 bool load_extras = false;
1485 /* Ignore API mount points. They should never be referenced in
1486 * dependencies ever. */
1487 if (mount_point_is_api(where) || mount_point_ignore(where))
1490 if (streq(fstype, "autofs"))
1493 /* probably some kind of swap, ignore */
1494 if (!is_path(where))
1497 e = unit_name_from_path(where, ".mount");
1501 u = manager_get_unit(m, e);
1505 u = unit_new(m, sizeof(Mount));
1511 r = unit_add_name(u, e);
1517 MOUNT(u)->where = strdup(where);
1518 if (!MOUNT(u)->where) {
1523 unit_add_to_load_queue(u);
1528 if (!MOUNT(u)->where) {
1529 MOUNT(u)->where = strdup(where);
1530 if (!MOUNT(u)->where) {
1536 if (u->load_state == UNIT_ERROR) {
1537 u->load_state = UNIT_LOADED;
1540 /* Load in the extras later on, after we
1541 * finished initialization of the unit */
1546 if (!(w = strdup(what)) ||
1547 !(o = strdup(options)) ||
1548 !(f = strdup(fstype))) {
1553 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1555 MOUNT(u)->is_mounted = true;
1556 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1557 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1560 MOUNT(u)->from_proc_self_mountinfo = true;
1574 r = mount_add_extras(MOUNT(u));
1579 unit_add_to_dbus_queue(u);
1594 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1597 char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1601 rewind(m->proc_self_mountinfo);
1606 device = path = options = options2 = fstype = d = p = o = NULL;
1608 if ((k = fscanf(m->proc_self_mountinfo,
1609 "%*s " /* (1) mount id */
1610 "%*s " /* (2) parent id */
1611 "%*s " /* (3) major:minor */
1612 "%*s " /* (4) root */
1613 "%ms " /* (5) mount point */
1614 "%ms" /* (6) mount options */
1615 "%*[^-]" /* (7) optional fields */
1616 "- " /* (8) separator */
1617 "%ms " /* (9) file system type */
1618 "%ms" /* (10) mount source */
1619 "%ms" /* (11) mount options 2 */
1620 "%*[^\n]", /* some rubbish at the end */
1630 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1634 o = strjoin(options, ",", options2, NULL);
1640 if (!(d = cunescape(device)) ||
1641 !(p = cunescape(path))) {
1646 if ((k = mount_add_one(m, d, p, o, fstype, 0, set_flags)) < 0)
1673 static void mount_shutdown(Manager *m) {
1676 if (m->proc_self_mountinfo) {
1677 fclose(m->proc_self_mountinfo);
1678 m->proc_self_mountinfo = NULL;
1682 static int mount_enumerate(Manager *m) {
1684 struct epoll_event ev;
1687 if (!m->proc_self_mountinfo) {
1688 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1691 m->mount_watch.type = WATCH_MOUNT;
1692 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1695 ev.events = EPOLLPRI;
1696 ev.data.ptr = &m->mount_watch;
1698 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1702 if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1712 void mount_fd_event(Manager *m, int events) {
1717 assert(events & EPOLLPRI);
1719 /* The manager calls this for every fd event happening on the
1720 * /proc/self/mountinfo file, which informs us about mounting
1723 r = mount_load_proc_self_mountinfo(m, true);
1725 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1727 /* Reset flags, just in case, for later calls */
1728 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1729 Mount *mount = MOUNT(u);
1731 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1737 manager_dispatch_load_queue(m);
1739 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1740 Mount *mount = MOUNT(u);
1742 if (!mount->is_mounted) {
1743 /* This has just been unmounted. */
1745 mount->from_proc_self_mountinfo = false;
1747 switch (mount->state) {
1750 mount_enter_dead(mount, MOUNT_SUCCESS);
1754 mount_set_state(mount, mount->state);
1759 } else if (mount->just_mounted || mount->just_changed) {
1761 /* New or changed mount entry */
1763 switch (mount->state) {
1767 mount_enter_mounted(mount, MOUNT_SUCCESS);
1770 case MOUNT_MOUNTING:
1771 mount_enter_mounting_done(mount);
1775 /* Nothing really changed, but let's
1776 * issue an notification call
1777 * nonetheless, in case somebody is
1778 * waiting for this. (e.g. file system
1779 * ro/rw remounts.) */
1780 mount_set_state(mount, mount->state);
1785 /* Reset the flags for later calls */
1786 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1790 static void mount_reset_failed(Unit *u) {
1791 Mount *m = MOUNT(u);
1795 if (m->state == MOUNT_FAILED)
1796 mount_set_state(m, MOUNT_DEAD);
1798 m->result = MOUNT_SUCCESS;
1799 m->reload_result = MOUNT_SUCCESS;
1802 static int mount_kill(Unit *u, KillWho who, int signo, DBusError *error) {
1803 Mount *m = MOUNT(u);
1805 Set *pid_set = NULL;
1809 if (who == KILL_MAIN) {
1810 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1814 if (m->control_pid <= 0 && who == KILL_CONTROL) {
1815 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1819 if (who == KILL_CONTROL || who == KILL_ALL)
1820 if (m->control_pid > 0)
1821 if (kill(m->control_pid, signo) < 0)
1824 if (who == KILL_ALL) {
1827 pid_set = set_new(trivial_hash_func, trivial_compare_func);
1831 /* Exclude the control pid from being killed via the cgroup */
1832 if (m->control_pid > 0) {
1833 q = set_put(pid_set, LONG_TO_PTR(m->control_pid));
1840 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, false, pid_set, NULL);
1841 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1852 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1853 [MOUNT_DEAD] = "dead",
1854 [MOUNT_MOUNTING] = "mounting",
1855 [MOUNT_MOUNTING_DONE] = "mounting-done",
1856 [MOUNT_MOUNTED] = "mounted",
1857 [MOUNT_REMOUNTING] = "remounting",
1858 [MOUNT_UNMOUNTING] = "unmounting",
1859 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1860 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1861 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1862 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1863 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1864 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1865 [MOUNT_FAILED] = "failed"
1868 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1870 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1871 [MOUNT_EXEC_MOUNT] = "ExecMount",
1872 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1873 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1876 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1878 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1879 [MOUNT_SUCCESS] = "success",
1880 [MOUNT_FAILURE_RESOURCES] = "resources",
1881 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1882 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1883 [MOUNT_FAILURE_SIGNAL] = "signal",
1884 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1887 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1889 const UnitVTable mount_vtable = {
1890 .object_size = sizeof(Mount),
1897 .exec_context_offset = offsetof(Mount, exec_context),
1898 .exec_section = "Mount",
1901 .no_instances = true,
1907 .coldplug = mount_coldplug,
1911 .start = mount_start,
1913 .reload = mount_reload,
1917 .serialize = mount_serialize,
1918 .deserialize_item = mount_deserialize_item,
1920 .active_state = mount_active_state,
1921 .sub_state_to_string = mount_sub_state_to_string,
1923 .check_gc = mount_check_gc,
1925 .sigchld_event = mount_sigchld_event,
1926 .timer_event = mount_timer_event,
1928 .reset_failed = mount_reset_failed,
1930 .bus_interface = "org.freedesktop.systemd1.Mount",
1931 .bus_message_handler = bus_mount_message_handler,
1932 .bus_invalidating_properties = bus_mount_invalidating_properties,
1934 .enumerate = mount_enumerate,
1935 .shutdown = mount_shutdown,
1937 .status_message_formats = {
1938 .starting_stopping = {
1939 [0] = "Mounting %s...",
1940 [1] = "Unmounting %s...",
1942 .finished_start_job = {
1943 [JOB_DONE] = "Mounted %s.",
1944 [JOB_FAILED] = "Failed to mount %s.",
1945 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1946 [JOB_TIMEOUT] = "Timed out mounting %s.",
1948 .finished_stop_job = {
1949 [JOB_DONE] = "Unmounted %s.",
1950 [JOB_FAILED] = "Failed unmounting %s.",
1951 [JOB_TIMEOUT] = "Timed out unmounting %s.",