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 if ((r = swap_add_one_mount_link(SWAP(other), m)) < 0)
232 static int mount_add_path_links(Mount *m) {
238 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_PATH])
239 if ((r = path_add_one_mount_link(PATH(other), m)) < 0)
245 static int mount_add_automount_links(Mount *m) {
251 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_AUTOMOUNT])
252 if ((r = automount_add_one_mount_link(AUTOMOUNT(other), m)) < 0)
258 static int mount_add_socket_links(Mount *m) {
264 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_SOCKET])
265 if ((r = socket_add_one_mount_link(SOCKET(other), m)) < 0)
271 static int mount_add_requires_mounts_links(Mount *m) {
277 LIST_FOREACH(has_requires_mounts_for, other, UNIT(m)->manager->has_requires_mounts_for) {
278 r = unit_add_one_mount_link(other, m);
286 static char* mount_test_option(const char *haystack, const char *needle) {
291 /* Like glibc's hasmntopt(), but works on a string, not a
298 me.mnt_opts = (char*) haystack;
300 return hasmntopt(&me, needle);
303 static bool mount_is_network(MountParameters *p) {
306 if (mount_test_option(p->options, "_netdev"))
309 if (p->fstype && fstype_is_network(p->fstype))
315 static bool mount_is_bind(MountParameters *p) {
318 if (mount_test_option(p->options, "bind"))
321 if (p->fstype && streq(p->fstype, "bind"))
327 static bool needs_quota(MountParameters *p) {
330 if (mount_is_network(p))
333 if (mount_is_bind(p))
336 return mount_test_option(p->options, "usrquota") ||
337 mount_test_option(p->options, "grpquota") ||
338 mount_test_option(p->options, "quota") ||
339 mount_test_option(p->options, "usrjquota") ||
340 mount_test_option(p->options, "grpjquota");
343 static int mount_add_device_links(Mount *m) {
349 p = get_mount_parameters_fragment(m);
356 if (mount_is_bind(p))
359 if (!is_device_path(p->what))
362 if (path_equal(m->where, "/"))
365 r = unit_add_node_link(UNIT(m), p->what, false);
370 UNIT(m)->manager->running_as == SYSTEMD_SYSTEM) {
373 /* Let's add in the fsck service */
375 /* aka SPECIAL_FSCK_SERVICE */
376 name = unit_name_from_path_instance("systemd-fsck", p->what, ".service");
380 r = manager_load_unit_prepare(UNIT(m)->manager, name, NULL, NULL, &fsck);
382 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
388 SERVICE(fsck)->fsck_passno = p->passno;
390 r = unit_add_two_dependencies(UNIT(m), UNIT_AFTER, UNIT_REQUIRES, fsck, true);
398 static int mount_add_quota_links(Mount *m) {
404 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
407 p = get_mount_parameters_fragment(m);
414 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true);
418 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true);
425 static int mount_add_default_dependencies(Mount *m) {
432 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
435 p = get_mount_parameters_fragment(m);
439 if (path_equal(m->where, "/"))
442 if (mount_is_network(p))
443 after = SPECIAL_REMOTE_FS_PRE_TARGET;
445 after = SPECIAL_LOCAL_FS_PRE_TARGET;
447 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, after, NULL, true);
451 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
458 static int mount_fix_timeouts(Mount *m) {
460 const char *timeout = NULL;
469 p = get_mount_parameters_fragment(m);
473 /* Allow configuration how long we wait for a device that
474 * backs a mount point to show up. This is useful to support
475 * endless device timeouts for devices that show up only after
476 * user input, like crypto devices. */
478 if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
480 else if ((timeout = mount_test_option(p->options, "x-systemd.device-timeout")))
485 t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
489 r = parse_usec(t, &u);
493 log_warning("Failed to parse timeout for %s, ignoring: %s", m->where, timeout);
497 SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
498 if (other->type != UNIT_DEVICE)
501 other->job_timeout = u;
507 static int mount_verify(Mount *m) {
512 if (UNIT(m)->load_state != UNIT_LOADED)
515 if (!m->from_fragment && !m->from_proc_self_mountinfo)
518 if (!(e = unit_name_from_path(m->where, ".mount")))
521 b = unit_has_name(UNIT(m), e);
525 log_error("%s's Where setting doesn't match unit name. Refusing.", UNIT(m)->id);
529 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
530 log_error("Cannot create mount unit for API file system %s. Refusing.", m->where);
534 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
535 log_error("%s's What setting is missing. Refusing.", UNIT(m)->id);
539 if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
540 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(m)->id);
547 static int mount_add_extras(Mount *m) {
551 if (UNIT(m)->fragment_path)
552 m->from_fragment = true;
555 m->where = unit_name_to_path(u->id);
560 path_kill_slashes(m->where);
562 r = unit_add_exec_dependencies(u, &m->exec_context);
566 if (!UNIT(m)->description) {
567 r = unit_set_description(u, m->where);
572 r = mount_add_device_links(m);
576 r = mount_add_mount_links(m);
580 r = mount_add_socket_links(m);
584 r = mount_add_swap_links(m);
588 r = mount_add_path_links(m);
592 r = mount_add_requires_mounts_links(m);
596 r = mount_add_automount_links(m);
600 r = mount_add_quota_links(m);
604 if (UNIT(m)->default_dependencies) {
605 r = mount_add_default_dependencies(m);
610 r = unit_add_default_cgroups(u);
614 r = mount_fix_timeouts(m);
621 static int mount_load(Unit *u) {
626 assert(u->load_state == UNIT_STUB);
628 if (m->from_proc_self_mountinfo)
629 r = unit_load_fragment_and_dropin_optional(u);
631 r = unit_load_fragment_and_dropin(u);
636 /* This is a new unit? Then let's add in some extras */
637 if (u->load_state == UNIT_LOADED) {
638 r = mount_add_extras(m);
642 r = unit_exec_context_defaults(u, &m->exec_context);
647 return mount_verify(m);
650 static int mount_notify_automount(Mount *m, int status) {
657 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
658 if (p->type == UNIT_AUTOMOUNT) {
659 r = automount_send_ready(AUTOMOUNT(p), status);
667 static void mount_set_state(Mount *m, MountState state) {
668 MountState old_state;
671 old_state = m->state;
674 if (state != MOUNT_MOUNTING &&
675 state != MOUNT_MOUNTING_DONE &&
676 state != MOUNT_REMOUNTING &&
677 state != MOUNT_UNMOUNTING &&
678 state != MOUNT_MOUNTING_SIGTERM &&
679 state != MOUNT_MOUNTING_SIGKILL &&
680 state != MOUNT_UNMOUNTING_SIGTERM &&
681 state != MOUNT_UNMOUNTING_SIGKILL &&
682 state != MOUNT_REMOUNTING_SIGTERM &&
683 state != MOUNT_REMOUNTING_SIGKILL) {
684 unit_unwatch_timer(UNIT(m), &m->timer_watch);
685 mount_unwatch_control_pid(m);
686 m->control_command = NULL;
687 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
690 if (state == MOUNT_MOUNTED ||
691 state == MOUNT_REMOUNTING)
692 mount_notify_automount(m, 0);
693 else if (state == MOUNT_DEAD ||
694 state == MOUNT_UNMOUNTING ||
695 state == MOUNT_MOUNTING_SIGTERM ||
696 state == MOUNT_MOUNTING_SIGKILL ||
697 state == MOUNT_REMOUNTING_SIGTERM ||
698 state == MOUNT_REMOUNTING_SIGKILL ||
699 state == MOUNT_UNMOUNTING_SIGTERM ||
700 state == MOUNT_UNMOUNTING_SIGKILL ||
701 state == MOUNT_FAILED) {
702 if (state != old_state)
703 mount_notify_automount(m, -ENODEV);
706 if (state != old_state)
707 log_debug("%s changed %s -> %s",
709 mount_state_to_string(old_state),
710 mount_state_to_string(state));
712 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
713 m->reload_result = MOUNT_SUCCESS;
716 static int mount_coldplug(Unit *u) {
718 MountState new_state = MOUNT_DEAD;
722 assert(m->state == MOUNT_DEAD);
724 if (m->deserialized_state != m->state)
725 new_state = m->deserialized_state;
726 else if (m->from_proc_self_mountinfo)
727 new_state = MOUNT_MOUNTED;
729 if (new_state != m->state) {
731 if (new_state == MOUNT_MOUNTING ||
732 new_state == MOUNT_MOUNTING_DONE ||
733 new_state == MOUNT_REMOUNTING ||
734 new_state == MOUNT_UNMOUNTING ||
735 new_state == MOUNT_MOUNTING_SIGTERM ||
736 new_state == MOUNT_MOUNTING_SIGKILL ||
737 new_state == MOUNT_UNMOUNTING_SIGTERM ||
738 new_state == MOUNT_UNMOUNTING_SIGKILL ||
739 new_state == MOUNT_REMOUNTING_SIGTERM ||
740 new_state == MOUNT_REMOUNTING_SIGKILL) {
742 if (m->control_pid <= 0)
745 r = unit_watch_pid(UNIT(m), m->control_pid);
749 r = unit_watch_timer(UNIT(m), CLOCK_MONOTONIC, true, m->timeout_usec, &m->timer_watch);
754 mount_set_state(m, new_state);
760 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
767 p = get_mount_parameters(m);
770 "%sMount State: %s\n"
774 "%sFile System Type: %s\n"
776 "%sFrom /proc/self/mountinfo: %s\n"
777 "%sFrom fragment: %s\n"
778 "%sDirectoryMode: %04o\n",
779 prefix, mount_state_to_string(m->state),
780 prefix, mount_result_to_string(m->result),
782 prefix, strna(p->what),
783 prefix, strna(p->fstype),
784 prefix, strna(p->options),
785 prefix, yes_no(m->from_proc_self_mountinfo),
786 prefix, yes_no(m->from_fragment),
787 prefix, m->directory_mode);
789 if (m->control_pid > 0)
791 "%sControl PID: %lu\n",
792 prefix, (unsigned long) m->control_pid);
794 exec_context_dump(&m->exec_context, f, prefix);
795 kill_context_dump(&m->kill_context, f, prefix);
798 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
806 r = unit_watch_timer(UNIT(m), CLOCK_MONOTONIC, true, m->timeout_usec, &m->timer_watch);
810 if ((r = exec_spawn(c,
814 UNIT(m)->manager->environment,
818 UNIT(m)->manager->confirm_spawn,
819 UNIT(m)->cgroup_bondings,
820 UNIT(m)->cgroup_attributes,
827 if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
828 /* FIXME: we need to do something here */
836 unit_unwatch_timer(UNIT(m), &m->timer_watch);
841 static void mount_enter_dead(Mount *m, MountResult f) {
844 if (f != MOUNT_SUCCESS)
847 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
850 static void mount_enter_mounted(Mount *m, MountResult f) {
853 if (f != MOUNT_SUCCESS)
856 mount_set_state(m, MOUNT_MOUNTED);
859 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
862 bool wait_for_exit = false;
866 if (f != MOUNT_SUCCESS)
869 if (m->kill_context.kill_mode != KILL_NONE) {
870 int sig = (state == MOUNT_MOUNTING_SIGTERM ||
871 state == MOUNT_UNMOUNTING_SIGTERM ||
872 state == MOUNT_REMOUNTING_SIGTERM) ? m->kill_context.kill_signal : SIGKILL;
874 if (m->control_pid > 0) {
875 if (kill_and_sigcont(m->control_pid, sig) < 0 && errno != ESRCH)
877 log_warning("Failed to kill control process %li: %m", (long) m->control_pid);
879 wait_for_exit = true;
882 if (m->kill_context.kill_mode == KILL_CONTROL_GROUP) {
884 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
889 /* Exclude the control pid from being killed via the cgroup */
890 if (m->control_pid > 0)
891 if ((r = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0)
894 r = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, sig, true, false, pid_set, NULL);
896 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
897 log_warning("Failed to kill control group: %s", strerror(-r));
899 wait_for_exit = true;
907 r = unit_watch_timer(UNIT(m), CLOCK_MONOTONIC, true, m->timeout_usec, &m->timer_watch);
911 mount_set_state(m, state);
912 } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
913 mount_enter_mounted(m, MOUNT_SUCCESS);
915 mount_enter_dead(m, MOUNT_SUCCESS);
920 log_warning("%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
922 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
923 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
925 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
931 void warn_if_dir_nonempty(const char *unit, const char* where) {
932 if (dir_is_empty(where) > 0)
934 log_struct(LOG_NOTICE,
935 "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
938 "_SYSTEMD_UNIT=%s", unit,
939 MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
943 static void mount_enter_unmounting(Mount *m) {
948 m->control_command_id = MOUNT_EXEC_UNMOUNT;
949 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
951 if ((r = exec_command_set(
958 mount_unwatch_control_pid(m);
960 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
963 mount_set_state(m, MOUNT_UNMOUNTING);
968 log_warning("%s failed to run 'umount' task: %s", UNIT(m)->id, strerror(-r));
969 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
972 static void mount_enter_mounting(Mount *m) {
978 m->control_command_id = MOUNT_EXEC_MOUNT;
979 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
981 mkdir_p_label(m->where, m->directory_mode);
983 warn_if_dir_nonempty(m->meta.id, m->where);
985 /* Create the source directory for bind-mounts if needed */
986 p = get_mount_parameters_fragment(m);
987 if (p && mount_is_bind(p))
988 mkdir_p_label(p->what, m->directory_mode);
990 if (m->from_fragment)
991 r = exec_command_set(
994 m->parameters_fragment.what,
996 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
997 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
1005 mount_unwatch_control_pid(m);
1007 r = mount_spawn(m, m->control_command, &m->control_pid);
1011 mount_set_state(m, MOUNT_MOUNTING);
1016 log_warning("%s failed to run 'mount' task: %s", UNIT(m)->id, strerror(-r));
1017 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
1020 static void mount_enter_mounting_done(Mount *m) {
1023 mount_set_state(m, MOUNT_MOUNTING_DONE);
1026 static void mount_enter_remounting(Mount *m) {
1031 m->control_command_id = MOUNT_EXEC_REMOUNT;
1032 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1034 if (m->from_fragment) {
1038 if (m->parameters_fragment.options) {
1039 if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
1048 r = exec_command_set(
1051 m->parameters_fragment.what,
1053 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
1064 mount_unwatch_control_pid(m);
1066 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1069 mount_set_state(m, MOUNT_REMOUNTING);
1074 log_warning("%s failed to run 'remount' task: %s", UNIT(m)->id, strerror(-r));
1075 m->reload_result = MOUNT_FAILURE_RESOURCES;
1076 mount_enter_mounted(m, MOUNT_SUCCESS);
1079 static int mount_start(Unit *u) {
1080 Mount *m = MOUNT(u);
1084 /* We cannot fulfill this request right now, try again later
1086 if (m->state == MOUNT_UNMOUNTING ||
1087 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1088 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1089 m->state == MOUNT_MOUNTING_SIGTERM ||
1090 m->state == MOUNT_MOUNTING_SIGKILL)
1093 /* Already on it! */
1094 if (m->state == MOUNT_MOUNTING)
1097 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1099 m->result = MOUNT_SUCCESS;
1100 m->reload_result = MOUNT_SUCCESS;
1102 mount_enter_mounting(m);
1106 static int mount_stop(Unit *u) {
1107 Mount *m = MOUNT(u);
1112 if (m->state == MOUNT_UNMOUNTING ||
1113 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1114 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1115 m->state == MOUNT_MOUNTING_SIGTERM ||
1116 m->state == MOUNT_MOUNTING_SIGKILL)
1119 assert(m->state == MOUNT_MOUNTING ||
1120 m->state == MOUNT_MOUNTING_DONE ||
1121 m->state == MOUNT_MOUNTED ||
1122 m->state == MOUNT_REMOUNTING ||
1123 m->state == MOUNT_REMOUNTING_SIGTERM ||
1124 m->state == MOUNT_REMOUNTING_SIGKILL);
1126 mount_enter_unmounting(m);
1130 static int mount_reload(Unit *u) {
1131 Mount *m = MOUNT(u);
1135 if (m->state == MOUNT_MOUNTING_DONE)
1138 assert(m->state == MOUNT_MOUNTED);
1140 mount_enter_remounting(m);
1144 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1145 Mount *m = MOUNT(u);
1151 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1152 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1153 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1155 if (m->control_pid > 0)
1156 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1158 if (m->control_command_id >= 0)
1159 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1164 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1165 Mount *m = MOUNT(u);
1172 if (streq(key, "state")) {
1175 if ((state = mount_state_from_string(value)) < 0)
1176 log_debug("Failed to parse state value %s", value);
1178 m->deserialized_state = state;
1179 } else if (streq(key, "result")) {
1182 f = mount_result_from_string(value);
1184 log_debug("Failed to parse result value %s", value);
1185 else if (f != MOUNT_SUCCESS)
1188 } else if (streq(key, "reload-result")) {
1191 f = mount_result_from_string(value);
1193 log_debug("Failed to parse reload result value %s", value);
1194 else if (f != MOUNT_SUCCESS)
1195 m->reload_result = f;
1197 } else if (streq(key, "control-pid")) {
1200 if (parse_pid(value, &pid) < 0)
1201 log_debug("Failed to parse control-pid value %s", value);
1203 m->control_pid = pid;
1204 } else if (streq(key, "control-command")) {
1205 MountExecCommand id;
1207 if ((id = mount_exec_command_from_string(value)) < 0)
1208 log_debug("Failed to parse exec-command value %s", value);
1210 m->control_command_id = id;
1211 m->control_command = m->exec_command + id;
1215 log_debug("Unknown serialization key '%s'", key);
1220 static UnitActiveState mount_active_state(Unit *u) {
1223 return state_translation_table[MOUNT(u)->state];
1226 static const char *mount_sub_state_to_string(Unit *u) {
1229 return mount_state_to_string(MOUNT(u)->state);
1232 static bool mount_check_gc(Unit *u) {
1233 Mount *m = MOUNT(u);
1237 return m->from_proc_self_mountinfo;
1240 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1241 Mount *m = MOUNT(u);
1247 if (pid != m->control_pid)
1252 if (is_clean_exit(code, status, NULL))
1254 else if (code == CLD_EXITED)
1255 f = MOUNT_FAILURE_EXIT_CODE;
1256 else if (code == CLD_KILLED)
1257 f = MOUNT_FAILURE_SIGNAL;
1258 else if (code == CLD_DUMPED)
1259 f = MOUNT_FAILURE_CORE_DUMP;
1261 assert_not_reached("Unknown code");
1263 if (f != MOUNT_SUCCESS)
1266 if (m->control_command) {
1267 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1269 m->control_command = NULL;
1270 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1273 log_full(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1274 "%s mount process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1276 /* Note that mount(8) returning and the kernel sending us a
1277 * mount table change event might happen out-of-order. If an
1278 * operation succeed we assume the kernel will follow soon too
1279 * and already change into the resulting state. If it fails
1280 * we check if the kernel still knows about the mount. and
1281 * change state accordingly. */
1285 case MOUNT_MOUNTING:
1286 case MOUNT_MOUNTING_DONE:
1287 case MOUNT_MOUNTING_SIGKILL:
1288 case MOUNT_MOUNTING_SIGTERM:
1290 if (f == MOUNT_SUCCESS)
1291 mount_enter_mounted(m, f);
1292 else if (m->from_proc_self_mountinfo)
1293 mount_enter_mounted(m, f);
1295 mount_enter_dead(m, f);
1298 case MOUNT_REMOUNTING:
1299 case MOUNT_REMOUNTING_SIGKILL:
1300 case MOUNT_REMOUNTING_SIGTERM:
1302 m->reload_result = f;
1303 if (m->from_proc_self_mountinfo)
1304 mount_enter_mounted(m, MOUNT_SUCCESS);
1306 mount_enter_dead(m, MOUNT_SUCCESS);
1310 case MOUNT_UNMOUNTING:
1311 case MOUNT_UNMOUNTING_SIGKILL:
1312 case MOUNT_UNMOUNTING_SIGTERM:
1314 if (f == MOUNT_SUCCESS)
1315 mount_enter_dead(m, f);
1316 else if (m->from_proc_self_mountinfo)
1317 mount_enter_mounted(m, f);
1319 mount_enter_dead(m, f);
1323 assert_not_reached("Uh, control process died at wrong time.");
1326 /* Notify clients about changed exit status */
1327 unit_add_to_dbus_queue(u);
1330 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1331 Mount *m = MOUNT(u);
1334 assert(elapsed == 1);
1335 assert(w == &m->timer_watch);
1339 case MOUNT_MOUNTING:
1340 case MOUNT_MOUNTING_DONE:
1341 log_warning("%s mounting timed out. Stopping.", u->id);
1342 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1345 case MOUNT_REMOUNTING:
1346 log_warning("%s remounting timed out. Stopping.", u->id);
1347 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1348 mount_enter_mounted(m, MOUNT_SUCCESS);
1351 case MOUNT_UNMOUNTING:
1352 log_warning("%s unmounting timed out. Stopping.", u->id);
1353 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1356 case MOUNT_MOUNTING_SIGTERM:
1357 if (m->kill_context.send_sigkill) {
1358 log_warning("%s mounting timed out. Killing.", u->id);
1359 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1361 log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1363 if (m->from_proc_self_mountinfo)
1364 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1366 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1370 case MOUNT_REMOUNTING_SIGTERM:
1371 if (m->kill_context.send_sigkill) {
1372 log_warning("%s remounting timed out. Killing.", u->id);
1373 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1375 log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1377 if (m->from_proc_self_mountinfo)
1378 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1380 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1384 case MOUNT_UNMOUNTING_SIGTERM:
1385 if (m->kill_context.send_sigkill) {
1386 log_warning("%s unmounting timed out. Killing.", u->id);
1387 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1389 log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1391 if (m->from_proc_self_mountinfo)
1392 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1394 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1398 case MOUNT_MOUNTING_SIGKILL:
1399 case MOUNT_REMOUNTING_SIGKILL:
1400 case MOUNT_UNMOUNTING_SIGKILL:
1401 log_warning("%s mount process still around after SIGKILL. Ignoring.", u->id);
1403 if (m->from_proc_self_mountinfo)
1404 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1406 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1410 assert_not_reached("Timeout at wrong time.");
1414 static int mount_add_one(
1418 const char *options,
1425 char *e, *w = NULL, *o = NULL, *f = NULL;
1427 bool load_extras = false;
1435 /* Ignore API mount points. They should never be referenced in
1436 * dependencies ever. */
1437 if (mount_point_is_api(where) || mount_point_ignore(where))
1440 if (streq(fstype, "autofs"))
1443 /* probably some kind of swap, ignore */
1444 if (!is_path(where))
1447 e = unit_name_from_path(where, ".mount");
1451 u = manager_get_unit(m, e);
1455 u = unit_new(m, sizeof(Mount));
1461 r = unit_add_name(u, e);
1467 MOUNT(u)->where = strdup(where);
1468 if (!MOUNT(u)->where) {
1473 unit_add_to_load_queue(u);
1478 if (!MOUNT(u)->where) {
1479 MOUNT(u)->where = strdup(where);
1480 if (!MOUNT(u)->where) {
1486 if (u->load_state == UNIT_ERROR) {
1487 u->load_state = UNIT_LOADED;
1490 /* Load in the extras later on, after we
1491 * finished initialization of the unit */
1496 if (!(w = strdup(what)) ||
1497 !(o = strdup(options)) ||
1498 !(f = strdup(fstype))) {
1503 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1505 MOUNT(u)->is_mounted = true;
1506 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1507 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1510 MOUNT(u)->from_proc_self_mountinfo = true;
1524 r = mount_add_extras(MOUNT(u));
1529 unit_add_to_dbus_queue(u);
1544 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1547 char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1551 rewind(m->proc_self_mountinfo);
1556 device = path = options = options2 = fstype = d = p = o = NULL;
1558 if ((k = fscanf(m->proc_self_mountinfo,
1559 "%*s " /* (1) mount id */
1560 "%*s " /* (2) parent id */
1561 "%*s " /* (3) major:minor */
1562 "%*s " /* (4) root */
1563 "%ms " /* (5) mount point */
1564 "%ms" /* (6) mount options */
1565 "%*[^-]" /* (7) optional fields */
1566 "- " /* (8) separator */
1567 "%ms " /* (9) file system type */
1568 "%ms" /* (10) mount source */
1569 "%ms" /* (11) mount options 2 */
1570 "%*[^\n]", /* some rubbish at the end */
1580 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1584 o = strjoin(options, ",", options2, NULL);
1590 if (!(d = cunescape(device)) ||
1591 !(p = cunescape(path))) {
1596 if ((k = mount_add_one(m, d, p, o, fstype, 0, set_flags)) < 0)
1623 static void mount_shutdown(Manager *m) {
1626 if (m->proc_self_mountinfo) {
1627 fclose(m->proc_self_mountinfo);
1628 m->proc_self_mountinfo = NULL;
1632 static int mount_enumerate(Manager *m) {
1634 struct epoll_event ev;
1637 if (!m->proc_self_mountinfo) {
1638 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1641 m->mount_watch.type = WATCH_MOUNT;
1642 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1645 ev.events = EPOLLPRI;
1646 ev.data.ptr = &m->mount_watch;
1648 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1652 if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1662 void mount_fd_event(Manager *m, int events) {
1667 assert(events & EPOLLPRI);
1669 /* The manager calls this for every fd event happening on the
1670 * /proc/self/mountinfo file, which informs us about mounting
1673 if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
1674 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1676 /* Reset flags, just in case, for later calls */
1677 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1678 Mount *mount = MOUNT(u);
1680 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1686 manager_dispatch_load_queue(m);
1688 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1689 Mount *mount = MOUNT(u);
1691 if (!mount->is_mounted) {
1692 /* This has just been unmounted. */
1694 mount->from_proc_self_mountinfo = false;
1696 switch (mount->state) {
1699 mount_enter_dead(mount, MOUNT_SUCCESS);
1703 mount_set_state(mount, mount->state);
1708 } else if (mount->just_mounted || mount->just_changed) {
1710 /* New or changed mount entry */
1712 switch (mount->state) {
1716 mount_enter_mounted(mount, MOUNT_SUCCESS);
1719 case MOUNT_MOUNTING:
1720 mount_enter_mounting_done(mount);
1724 /* Nothing really changed, but let's
1725 * issue an notification call
1726 * nonetheless, in case somebody is
1727 * waiting for this. (e.g. file system
1728 * ro/rw remounts.) */
1729 mount_set_state(mount, mount->state);
1734 /* Reset the flags for later calls */
1735 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1739 static void mount_reset_failed(Unit *u) {
1740 Mount *m = MOUNT(u);
1744 if (m->state == MOUNT_FAILED)
1745 mount_set_state(m, MOUNT_DEAD);
1747 m->result = MOUNT_SUCCESS;
1748 m->reload_result = MOUNT_SUCCESS;
1751 static int mount_kill(Unit *u, KillWho who, int signo, DBusError *error) {
1752 Mount *m = MOUNT(u);
1754 Set *pid_set = NULL;
1758 if (who == KILL_MAIN) {
1759 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1763 if (m->control_pid <= 0 && who == KILL_CONTROL) {
1764 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1768 if (who == KILL_CONTROL || who == KILL_ALL)
1769 if (m->control_pid > 0)
1770 if (kill(m->control_pid, signo) < 0)
1773 if (who == KILL_ALL) {
1776 pid_set = set_new(trivial_hash_func, trivial_compare_func);
1780 /* Exclude the control pid from being killed via the cgroup */
1781 if (m->control_pid > 0) {
1782 q = set_put(pid_set, LONG_TO_PTR(m->control_pid));
1789 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, false, pid_set, NULL);
1790 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1801 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1802 [MOUNT_DEAD] = "dead",
1803 [MOUNT_MOUNTING] = "mounting",
1804 [MOUNT_MOUNTING_DONE] = "mounting-done",
1805 [MOUNT_MOUNTED] = "mounted",
1806 [MOUNT_REMOUNTING] = "remounting",
1807 [MOUNT_UNMOUNTING] = "unmounting",
1808 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1809 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1810 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1811 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1812 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1813 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1814 [MOUNT_FAILED] = "failed"
1817 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1819 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1820 [MOUNT_EXEC_MOUNT] = "ExecMount",
1821 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1822 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1825 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1827 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1828 [MOUNT_SUCCESS] = "success",
1829 [MOUNT_FAILURE_RESOURCES] = "resources",
1830 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1831 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1832 [MOUNT_FAILURE_SIGNAL] = "signal",
1833 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1836 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1838 const UnitVTable mount_vtable = {
1839 .object_size = sizeof(Mount),
1840 .exec_context_offset = offsetof(Mount, exec_context),
1848 .no_instances = true,
1854 .coldplug = mount_coldplug,
1858 .start = mount_start,
1860 .reload = mount_reload,
1864 .serialize = mount_serialize,
1865 .deserialize_item = mount_deserialize_item,
1867 .active_state = mount_active_state,
1868 .sub_state_to_string = mount_sub_state_to_string,
1870 .check_gc = mount_check_gc,
1872 .sigchld_event = mount_sigchld_event,
1873 .timer_event = mount_timer_event,
1875 .reset_failed = mount_reset_failed,
1877 .bus_interface = "org.freedesktop.systemd1.Mount",
1878 .bus_message_handler = bus_mount_message_handler,
1879 .bus_invalidating_properties = bus_mount_invalidating_properties,
1881 .enumerate = mount_enumerate,
1882 .shutdown = mount_shutdown,
1884 .status_message_formats = {
1885 .starting_stopping = {
1886 [0] = "Mounting %s...",
1887 [1] = "Unmounting %s...",
1889 .finished_start_job = {
1890 [JOB_DONE] = "Mounted %s.",
1891 [JOB_FAILED] = "Failed to mount %s.",
1892 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1893 [JOB_TIMEOUT] = "Timed out mounting %s.",
1895 .finished_stop_job = {
1896 [JOB_DONE] = "Unmounted %s.",
1897 [JOB_FAILED] = "Failed unmounting %s.",
1898 [JOB_TIMEOUT] = "Timed out unmounting %s.",