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"
35 #include "path-util.h"
36 #include "mount-setup.h"
37 #include "unit-name.h"
38 #include "dbus-mount.h"
40 #include "bus-errors.h"
41 #include "exit-status.h"
44 static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
45 [MOUNT_DEAD] = UNIT_INACTIVE,
46 [MOUNT_MOUNTING] = UNIT_ACTIVATING,
47 [MOUNT_MOUNTING_DONE] = UNIT_ACTIVE,
48 [MOUNT_MOUNTED] = UNIT_ACTIVE,
49 [MOUNT_REMOUNTING] = UNIT_RELOADING,
50 [MOUNT_UNMOUNTING] = UNIT_DEACTIVATING,
51 [MOUNT_MOUNTING_SIGTERM] = UNIT_DEACTIVATING,
52 [MOUNT_MOUNTING_SIGKILL] = UNIT_DEACTIVATING,
53 [MOUNT_REMOUNTING_SIGTERM] = UNIT_RELOADING,
54 [MOUNT_REMOUNTING_SIGKILL] = UNIT_RELOADING,
55 [MOUNT_UNMOUNTING_SIGTERM] = UNIT_DEACTIVATING,
56 [MOUNT_UNMOUNTING_SIGKILL] = UNIT_DEACTIVATING,
57 [MOUNT_FAILED] = UNIT_FAILED
60 static void mount_init(Unit *u) {
64 assert(u->load_state == UNIT_STUB);
66 m->timeout_usec = DEFAULT_TIMEOUT_USEC;
67 m->directory_mode = 0755;
69 exec_context_init(&m->exec_context);
71 if (unit_has_name(u, "-.mount")) {
72 /* Don't allow start/stop for root directory */
73 UNIT(m)->refuse_manual_start = true;
74 UNIT(m)->refuse_manual_stop = true;
76 /* The stdio/kmsg bridge socket is on /, in order to avoid a
77 * dep loop, don't use kmsg logging for -.mount */
78 m->exec_context.std_output = u->manager->default_std_output;
79 m->exec_context.std_error = u->manager->default_std_error;
82 /* We need to make sure that /bin/mount is always called in
83 * the same process group as us, so that the autofs kernel
84 * side doesn't send us another mount request while we are
85 * already trying to comply its last one. */
86 m->exec_context.same_pgrp = true;
88 m->timer_watch.type = WATCH_INVALID;
90 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
92 UNIT(m)->ignore_on_isolate = true;
95 static void mount_unwatch_control_pid(Mount *m) {
98 if (m->control_pid <= 0)
101 unit_unwatch_pid(UNIT(m), m->control_pid);
105 static void mount_parameters_done(MountParameters *p) {
112 p->what = p->options = p->fstype = NULL;
115 static void mount_done(Unit *u) {
123 mount_parameters_done(&m->parameters_proc_self_mountinfo);
124 mount_parameters_done(&m->parameters_fragment);
126 exec_context_done(&m->exec_context);
127 exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
128 m->control_command = NULL;
130 mount_unwatch_control_pid(m);
132 unit_unwatch_timer(u, &m->timer_watch);
135 static MountParameters* get_mount_parameters_fragment(Mount *m) {
138 if (m->from_fragment)
139 return &m->parameters_fragment;
144 static MountParameters* get_mount_parameters(Mount *m) {
147 if (m->from_proc_self_mountinfo)
148 return &m->parameters_proc_self_mountinfo;
150 return get_mount_parameters_fragment(m);
153 static int mount_add_mount_links(Mount *m) {
160 pm = get_mount_parameters_fragment(m);
162 /* Adds in links to other mount points that might lie below or
163 * above us in the hierarchy */
165 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_MOUNT]) {
166 Mount *n = MOUNT(other);
172 if (UNIT(n)->load_state != UNIT_LOADED)
175 pn = get_mount_parameters_fragment(n);
177 if (path_startswith(m->where, n->where)) {
179 if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, UNIT(n), true)) < 0)
183 if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, UNIT(n), true)) < 0)
186 } else if (path_startswith(n->where, m->where)) {
188 if ((r = unit_add_dependency(UNIT(n), UNIT_AFTER, UNIT(m), true)) < 0)
192 if ((r = unit_add_dependency(UNIT(n), UNIT_REQUIRES, UNIT(m), true)) < 0)
195 } else if (pm && pm->what && path_startswith(pm->what, n->where)) {
197 if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, UNIT(n), true)) < 0)
200 if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, UNIT(n), true)) < 0)
203 } else if (pn && pn->what && path_startswith(pn->what, m->where)) {
205 if ((r = unit_add_dependency(UNIT(n), UNIT_AFTER, UNIT(m), true)) < 0)
208 if ((r = unit_add_dependency(UNIT(n), UNIT_REQUIRES, UNIT(m), true)) < 0)
216 static int mount_add_swap_links(Mount *m) {
222 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_SWAP])
223 if ((r = swap_add_one_mount_link(SWAP(other), m)) < 0)
229 static int mount_add_path_links(Mount *m) {
235 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_PATH])
236 if ((r = path_add_one_mount_link(PATH(other), m)) < 0)
242 static int mount_add_automount_links(Mount *m) {
248 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_AUTOMOUNT])
249 if ((r = automount_add_one_mount_link(AUTOMOUNT(other), m)) < 0)
255 static int mount_add_socket_links(Mount *m) {
261 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_SOCKET])
262 if ((r = socket_add_one_mount_link(SOCKET(other), m)) < 0)
268 static int mount_add_requires_mounts_links(Mount *m) {
274 LIST_FOREACH(has_requires_mounts_for, other, UNIT(m)->manager->has_requires_mounts_for) {
275 r = unit_add_one_mount_link(other, m);
283 static char* mount_test_option(const char *haystack, const char *needle) {
288 /* Like glibc's hasmntopt(), but works on a string, not a
295 me.mnt_opts = (char*) haystack;
297 return hasmntopt(&me, needle);
300 static bool mount_is_network(MountParameters *p) {
303 if (mount_test_option(p->options, "_netdev"))
306 if (p->fstype && fstype_is_network(p->fstype))
312 static bool mount_is_bind(MountParameters *p) {
315 if (mount_test_option(p->options, "bind"))
318 if (p->fstype && streq(p->fstype, "bind"))
324 static bool needs_quota(MountParameters *p) {
327 if (mount_is_network(p))
330 if (mount_is_bind(p))
333 return mount_test_option(p->options, "usrquota") ||
334 mount_test_option(p->options, "grpquota") ||
335 mount_test_option(p->options, "quota") ||
336 mount_test_option(p->options, "usrjquota") ||
337 mount_test_option(p->options, "grpjquota");
340 static int mount_add_device_links(Mount *m) {
346 p = get_mount_parameters_fragment(m);
353 if (!mount_is_bind(p) &&
354 !path_equal(m->where, "/")) {
355 r = unit_add_node_link(UNIT(m), p->what, false);
362 !path_equal(m->where, "/") &&
363 UNIT(m)->manager->running_as == MANAGER_SYSTEM) {
366 /* Let's add in the fsck service */
368 /* aka SPECIAL_FSCK_SERVICE */
369 name = unit_name_from_path_instance("fsck", p->what, ".service");
373 r = manager_load_unit_prepare(UNIT(m)->manager, name, NULL, NULL, &fsck);
375 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
381 SERVICE(fsck)->fsck_passno = p->passno;
383 r = unit_add_two_dependencies(UNIT(m), UNIT_AFTER, UNIT_REQUIRES, fsck, true);
391 static int mount_add_quota_links(Mount *m) {
397 if (UNIT(m)->manager->running_as != MANAGER_SYSTEM)
400 p = get_mount_parameters_fragment(m);
407 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true);
411 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true);
418 static int mount_add_default_dependencies(Mount *m) {
425 if (UNIT(m)->manager->running_as != MANAGER_SYSTEM)
428 p = get_mount_parameters_fragment(m);
432 if (path_equal(m->where, "/"))
435 if (mount_is_network(p))
436 after = SPECIAL_REMOTE_FS_PRE_TARGET;
438 after = SPECIAL_LOCAL_FS_PRE_TARGET;
440 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, after, NULL, true);
444 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
451 static int mount_fix_timeouts(Mount *m) {
453 const char *timeout = NULL;
462 p = get_mount_parameters_fragment(m);
466 /* Allow configuration how long we wait for a device that
467 * backs a mount point to show up. This is useful to support
468 * endless device timeouts for devices that show up only after
469 * user input, like crypto devices. */
471 if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
473 else if ((timeout = mount_test_option(p->options, "x-systemd.device-timeout")))
478 t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
482 r = parse_usec(t, &u);
486 log_warning("Failed to parse timeout for %s, ignoring: %s", m->where, timeout);
490 SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
491 if (other->type != UNIT_DEVICE)
494 other->job_timeout = u;
500 static int mount_verify(Mount *m) {
505 if (UNIT(m)->load_state != UNIT_LOADED)
508 if (!m->from_fragment && !m->from_proc_self_mountinfo)
511 if (!(e = unit_name_from_path(m->where, ".mount")))
514 b = unit_has_name(UNIT(m), e);
518 log_error("%s's Where setting doesn't match unit name. Refusing.", UNIT(m)->id);
522 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
523 log_error("Cannot create mount unit for API file system %s. Refusing.", m->where);
527 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
528 log_error("%s's What setting is missing. Refusing.", UNIT(m)->id);
532 if (m->exec_context.pam_name && m->exec_context.kill_mode != KILL_CONTROL_GROUP) {
533 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(m)->id);
540 static int mount_load(Unit *u) {
545 assert(u->load_state == UNIT_STUB);
547 if ((r = unit_load_fragment_and_dropin_optional(u)) < 0)
550 /* This is a new unit? Then let's add in some extras */
551 if (u->load_state == UNIT_LOADED) {
552 if ((r = unit_add_exec_dependencies(u, &m->exec_context)) < 0)
555 if (UNIT(m)->fragment_path)
556 m->from_fragment = true;
559 if (!(m->where = unit_name_to_path(u->id)))
562 path_kill_slashes(m->where);
564 if (!UNIT(m)->description)
565 if ((r = unit_set_description(u, m->where)) < 0)
568 if ((r = mount_add_device_links(m)) < 0)
571 if ((r = mount_add_mount_links(m)) < 0)
574 if ((r = mount_add_socket_links(m)) < 0)
577 if ((r = mount_add_swap_links(m)) < 0)
580 if ((r = mount_add_path_links(m)) < 0)
583 r = mount_add_requires_mounts_links(m);
587 if ((r = mount_add_automount_links(m)) < 0)
590 r = mount_add_quota_links(m);
594 if (UNIT(m)->default_dependencies)
595 if ((r = mount_add_default_dependencies(m)) < 0)
598 if ((r = unit_add_default_cgroups(u)) < 0)
601 mount_fix_timeouts(m);
604 return mount_verify(m);
607 static int mount_notify_automount(Mount *m, int status) {
614 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
615 if (p->type == UNIT_AUTOMOUNT) {
616 r = automount_send_ready(AUTOMOUNT(p), status);
624 static void mount_set_state(Mount *m, MountState state) {
625 MountState old_state;
628 old_state = m->state;
631 if (state != MOUNT_MOUNTING &&
632 state != MOUNT_MOUNTING_DONE &&
633 state != MOUNT_REMOUNTING &&
634 state != MOUNT_UNMOUNTING &&
635 state != MOUNT_MOUNTING_SIGTERM &&
636 state != MOUNT_MOUNTING_SIGKILL &&
637 state != MOUNT_UNMOUNTING_SIGTERM &&
638 state != MOUNT_UNMOUNTING_SIGKILL &&
639 state != MOUNT_REMOUNTING_SIGTERM &&
640 state != MOUNT_REMOUNTING_SIGKILL) {
641 unit_unwatch_timer(UNIT(m), &m->timer_watch);
642 mount_unwatch_control_pid(m);
643 m->control_command = NULL;
644 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
647 if (state == MOUNT_MOUNTED ||
648 state == MOUNT_REMOUNTING)
649 mount_notify_automount(m, 0);
650 else if (state == MOUNT_DEAD ||
651 state == MOUNT_UNMOUNTING ||
652 state == MOUNT_MOUNTING_SIGTERM ||
653 state == MOUNT_MOUNTING_SIGKILL ||
654 state == MOUNT_REMOUNTING_SIGTERM ||
655 state == MOUNT_REMOUNTING_SIGKILL ||
656 state == MOUNT_UNMOUNTING_SIGTERM ||
657 state == MOUNT_UNMOUNTING_SIGKILL ||
658 state == MOUNT_FAILED)
659 mount_notify_automount(m, -ENODEV);
661 if (state != old_state)
662 log_debug("%s changed %s -> %s",
664 mount_state_to_string(old_state),
665 mount_state_to_string(state));
667 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
668 m->reload_result = MOUNT_SUCCESS;
671 static int mount_coldplug(Unit *u) {
673 MountState new_state = MOUNT_DEAD;
677 assert(m->state == MOUNT_DEAD);
679 if (m->deserialized_state != m->state)
680 new_state = m->deserialized_state;
681 else if (m->from_proc_self_mountinfo)
682 new_state = MOUNT_MOUNTED;
684 if (new_state != m->state) {
686 if (new_state == MOUNT_MOUNTING ||
687 new_state == MOUNT_MOUNTING_DONE ||
688 new_state == MOUNT_REMOUNTING ||
689 new_state == MOUNT_UNMOUNTING ||
690 new_state == MOUNT_MOUNTING_SIGTERM ||
691 new_state == MOUNT_MOUNTING_SIGKILL ||
692 new_state == MOUNT_UNMOUNTING_SIGTERM ||
693 new_state == MOUNT_UNMOUNTING_SIGKILL ||
694 new_state == MOUNT_REMOUNTING_SIGTERM ||
695 new_state == MOUNT_REMOUNTING_SIGKILL) {
697 if (m->control_pid <= 0)
700 if ((r = unit_watch_pid(UNIT(m), m->control_pid)) < 0)
703 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
707 mount_set_state(m, new_state);
713 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
720 p = get_mount_parameters(m);
723 "%sMount State: %s\n"
727 "%sFile System Type: %s\n"
729 "%sFrom /proc/self/mountinfo: %s\n"
730 "%sFrom fragment: %s\n"
731 "%sDirectoryMode: %04o\n",
732 prefix, mount_state_to_string(m->state),
733 prefix, mount_result_to_string(m->result),
735 prefix, strna(p->what),
736 prefix, strna(p->fstype),
737 prefix, strna(p->options),
738 prefix, yes_no(m->from_proc_self_mountinfo),
739 prefix, yes_no(m->from_fragment),
740 prefix, m->directory_mode);
742 if (m->control_pid > 0)
744 "%sControl PID: %lu\n",
745 prefix, (unsigned long) m->control_pid);
747 exec_context_dump(&m->exec_context, f, prefix);
750 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
758 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
761 if ((r = exec_spawn(c,
765 UNIT(m)->manager->environment,
769 UNIT(m)->manager->confirm_spawn,
770 UNIT(m)->cgroup_bondings,
771 UNIT(m)->cgroup_attributes,
777 if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
778 /* FIXME: we need to do something here */
786 unit_unwatch_timer(UNIT(m), &m->timer_watch);
791 static void mount_enter_dead(Mount *m, MountResult f) {
794 if (f != MOUNT_SUCCESS)
797 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
800 static void mount_enter_mounted(Mount *m, MountResult f) {
803 if (f != MOUNT_SUCCESS)
806 mount_set_state(m, MOUNT_MOUNTED);
809 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
812 bool wait_for_exit = false;
816 if (f != MOUNT_SUCCESS)
819 if (m->exec_context.kill_mode != KILL_NONE) {
820 int sig = (state == MOUNT_MOUNTING_SIGTERM ||
821 state == MOUNT_UNMOUNTING_SIGTERM ||
822 state == MOUNT_REMOUNTING_SIGTERM) ? m->exec_context.kill_signal : SIGKILL;
824 if (m->control_pid > 0) {
825 if (kill_and_sigcont(m->control_pid, sig) < 0 && errno != ESRCH)
827 log_warning("Failed to kill control process %li: %m", (long) m->control_pid);
829 wait_for_exit = true;
832 if (m->exec_context.kill_mode == KILL_CONTROL_GROUP) {
834 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
839 /* Exclude the control pid from being killed via the cgroup */
840 if (m->control_pid > 0)
841 if ((r = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0)
844 r = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, sig, true, false, pid_set, NULL);
846 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
847 log_warning("Failed to kill control group: %s", strerror(-r));
849 wait_for_exit = true;
857 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
860 mount_set_state(m, state);
861 } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
862 mount_enter_mounted(m, MOUNT_SUCCESS);
864 mount_enter_dead(m, MOUNT_SUCCESS);
869 log_warning("%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
871 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
872 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
874 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
880 static void mount_enter_unmounting(Mount *m) {
885 m->control_command_id = MOUNT_EXEC_UNMOUNT;
886 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
888 if ((r = exec_command_set(
895 mount_unwatch_control_pid(m);
897 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
900 mount_set_state(m, MOUNT_UNMOUNTING);
905 log_warning("%s failed to run 'umount' task: %s", UNIT(m)->id, strerror(-r));
906 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
909 static void mount_enter_mounting(Mount *m) {
915 m->control_command_id = MOUNT_EXEC_MOUNT;
916 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
918 mkdir_p_label(m->where, m->directory_mode);
920 /* Create the source directory for bind-mounts if needed */
921 p = get_mount_parameters_fragment(m);
922 if (p && mount_is_bind(p))
923 mkdir_p_label(p->what, m->directory_mode);
925 if (m->from_fragment)
926 r = exec_command_set(
929 m->parameters_fragment.what,
931 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
932 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
940 mount_unwatch_control_pid(m);
942 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
945 mount_set_state(m, MOUNT_MOUNTING);
950 log_warning("%s failed to run 'mount' task: %s", UNIT(m)->id, strerror(-r));
951 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
954 static void mount_enter_mounting_done(Mount *m) {
957 mount_set_state(m, MOUNT_MOUNTING_DONE);
960 static void mount_enter_remounting(Mount *m) {
965 m->control_command_id = MOUNT_EXEC_REMOUNT;
966 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
968 if (m->from_fragment) {
972 if (m->parameters_fragment.options) {
973 if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
982 r = exec_command_set(
985 m->parameters_fragment.what,
987 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
998 mount_unwatch_control_pid(m);
1000 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1003 mount_set_state(m, MOUNT_REMOUNTING);
1008 log_warning("%s failed to run 'remount' task: %s", UNIT(m)->id, strerror(-r));
1009 m->reload_result = MOUNT_FAILURE_RESOURCES;
1010 mount_enter_mounted(m, MOUNT_SUCCESS);
1013 static int mount_start(Unit *u) {
1014 Mount *m = MOUNT(u);
1018 /* We cannot fulfill this request right now, try again later
1020 if (m->state == MOUNT_UNMOUNTING ||
1021 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1022 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1023 m->state == MOUNT_MOUNTING_SIGTERM ||
1024 m->state == MOUNT_MOUNTING_SIGKILL)
1027 /* Already on it! */
1028 if (m->state == MOUNT_MOUNTING)
1031 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1033 m->result = MOUNT_SUCCESS;
1034 m->reload_result = MOUNT_SUCCESS;
1036 mount_enter_mounting(m);
1040 static int mount_stop(Unit *u) {
1041 Mount *m = MOUNT(u);
1046 if (m->state == MOUNT_UNMOUNTING ||
1047 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1048 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1049 m->state == MOUNT_MOUNTING_SIGTERM ||
1050 m->state == MOUNT_MOUNTING_SIGKILL)
1053 assert(m->state == MOUNT_MOUNTING ||
1054 m->state == MOUNT_MOUNTING_DONE ||
1055 m->state == MOUNT_MOUNTED ||
1056 m->state == MOUNT_REMOUNTING ||
1057 m->state == MOUNT_REMOUNTING_SIGTERM ||
1058 m->state == MOUNT_REMOUNTING_SIGKILL);
1060 mount_enter_unmounting(m);
1064 static int mount_reload(Unit *u) {
1065 Mount *m = MOUNT(u);
1069 if (m->state == MOUNT_MOUNTING_DONE)
1072 assert(m->state == MOUNT_MOUNTED);
1074 mount_enter_remounting(m);
1078 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1079 Mount *m = MOUNT(u);
1085 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1086 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1087 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1089 if (m->control_pid > 0)
1090 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1092 if (m->control_command_id >= 0)
1093 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1098 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1099 Mount *m = MOUNT(u);
1106 if (streq(key, "state")) {
1109 if ((state = mount_state_from_string(value)) < 0)
1110 log_debug("Failed to parse state value %s", value);
1112 m->deserialized_state = state;
1113 } else if (streq(key, "result")) {
1116 f = mount_result_from_string(value);
1118 log_debug("Failed to parse result value %s", value);
1119 else if (f != MOUNT_SUCCESS)
1122 } else if (streq(key, "reload-result")) {
1125 f = mount_result_from_string(value);
1127 log_debug("Failed to parse reload result value %s", value);
1128 else if (f != MOUNT_SUCCESS)
1129 m->reload_result = f;
1131 } else if (streq(key, "control-pid")) {
1134 if (parse_pid(value, &pid) < 0)
1135 log_debug("Failed to parse control-pid value %s", value);
1137 m->control_pid = pid;
1138 } else if (streq(key, "control-command")) {
1139 MountExecCommand id;
1141 if ((id = mount_exec_command_from_string(value)) < 0)
1142 log_debug("Failed to parse exec-command value %s", value);
1144 m->control_command_id = id;
1145 m->control_command = m->exec_command + id;
1149 log_debug("Unknown serialization key '%s'", key);
1154 static UnitActiveState mount_active_state(Unit *u) {
1157 return state_translation_table[MOUNT(u)->state];
1160 static const char *mount_sub_state_to_string(Unit *u) {
1163 return mount_state_to_string(MOUNT(u)->state);
1166 static bool mount_check_gc(Unit *u) {
1167 Mount *m = MOUNT(u);
1171 return m->from_proc_self_mountinfo;
1174 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1175 Mount *m = MOUNT(u);
1181 if (pid != m->control_pid)
1186 if (is_clean_exit(code, status))
1188 else if (code == CLD_EXITED)
1189 f = MOUNT_FAILURE_EXIT_CODE;
1190 else if (code == CLD_KILLED)
1191 f = MOUNT_FAILURE_SIGNAL;
1192 else if (code == CLD_DUMPED)
1193 f = MOUNT_FAILURE_CORE_DUMP;
1195 assert_not_reached("Unknown code");
1197 if (f != MOUNT_SUCCESS)
1200 if (m->control_command) {
1201 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1203 m->control_command = NULL;
1204 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1207 log_full(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1208 "%s mount process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1210 /* Note that mount(8) returning and the kernel sending us a
1211 * mount table change event might happen out-of-order. If an
1212 * operation succeed we assume the kernel will follow soon too
1213 * and already change into the resulting state. If it fails
1214 * we check if the kernel still knows about the mount. and
1215 * change state accordingly. */
1219 case MOUNT_MOUNTING:
1220 case MOUNT_MOUNTING_DONE:
1221 case MOUNT_MOUNTING_SIGKILL:
1222 case MOUNT_MOUNTING_SIGTERM:
1224 if (f == MOUNT_SUCCESS)
1225 mount_enter_mounted(m, f);
1226 else if (m->from_proc_self_mountinfo)
1227 mount_enter_mounted(m, f);
1229 mount_enter_dead(m, f);
1232 case MOUNT_REMOUNTING:
1233 case MOUNT_REMOUNTING_SIGKILL:
1234 case MOUNT_REMOUNTING_SIGTERM:
1236 m->reload_result = f;
1237 if (m->from_proc_self_mountinfo)
1238 mount_enter_mounted(m, MOUNT_SUCCESS);
1240 mount_enter_dead(m, MOUNT_SUCCESS);
1244 case MOUNT_UNMOUNTING:
1245 case MOUNT_UNMOUNTING_SIGKILL:
1246 case MOUNT_UNMOUNTING_SIGTERM:
1248 if (f == MOUNT_SUCCESS)
1249 mount_enter_dead(m, f);
1250 else if (m->from_proc_self_mountinfo)
1251 mount_enter_mounted(m, f);
1253 mount_enter_dead(m, f);
1257 assert_not_reached("Uh, control process died at wrong time.");
1260 /* Notify clients about changed exit status */
1261 unit_add_to_dbus_queue(u);
1264 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1265 Mount *m = MOUNT(u);
1268 assert(elapsed == 1);
1269 assert(w == &m->timer_watch);
1273 case MOUNT_MOUNTING:
1274 case MOUNT_MOUNTING_DONE:
1275 log_warning("%s mounting timed out. Stopping.", u->id);
1276 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1279 case MOUNT_REMOUNTING:
1280 log_warning("%s remounting timed out. Stopping.", u->id);
1281 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1282 mount_enter_mounted(m, MOUNT_SUCCESS);
1285 case MOUNT_UNMOUNTING:
1286 log_warning("%s unmounting timed out. Stopping.", u->id);
1287 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1290 case MOUNT_MOUNTING_SIGTERM:
1291 if (m->exec_context.send_sigkill) {
1292 log_warning("%s mounting timed out. Killing.", u->id);
1293 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1295 log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1297 if (m->from_proc_self_mountinfo)
1298 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1300 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1304 case MOUNT_REMOUNTING_SIGTERM:
1305 if (m->exec_context.send_sigkill) {
1306 log_warning("%s remounting timed out. Killing.", u->id);
1307 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1309 log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1311 if (m->from_proc_self_mountinfo)
1312 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1314 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1318 case MOUNT_UNMOUNTING_SIGTERM:
1319 if (m->exec_context.send_sigkill) {
1320 log_warning("%s unmounting timed out. Killing.", u->id);
1321 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1323 log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1325 if (m->from_proc_self_mountinfo)
1326 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1328 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1332 case MOUNT_MOUNTING_SIGKILL:
1333 case MOUNT_REMOUNTING_SIGKILL:
1334 case MOUNT_UNMOUNTING_SIGKILL:
1335 log_warning("%s mount process still around after SIGKILL. Ignoring.", u->id);
1337 if (m->from_proc_self_mountinfo)
1338 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1340 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1344 assert_not_reached("Timeout at wrong time.");
1348 static int mount_add_one(
1352 const char *options,
1359 char *e, *w = NULL, *o = NULL, *f = NULL;
1368 /* Ignore API mount points. They should never be referenced in
1369 * dependencies ever. */
1370 if (mount_point_is_api(where) || mount_point_ignore(where))
1373 if (streq(fstype, "autofs"))
1376 /* probably some kind of swap, ignore */
1377 if (!is_path(where))
1380 e = unit_name_from_path(where, ".mount");
1384 u = manager_get_unit(m, e);
1388 u = unit_new(m, sizeof(Mount));
1394 r = unit_add_name(u, e);
1400 MOUNT(u)->where = strdup(where);
1401 if (!MOUNT(u)->where) {
1406 unit_add_to_load_queue(u);
1412 if (!(w = strdup(what)) ||
1413 !(o = strdup(options)) ||
1414 !(f = strdup(fstype))) {
1419 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1421 MOUNT(u)->is_mounted = true;
1422 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1423 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1426 MOUNT(u)->from_proc_self_mountinfo = true;
1439 unit_add_to_dbus_queue(u);
1454 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1457 char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1461 rewind(m->proc_self_mountinfo);
1466 device = path = options = options2 = fstype = d = p = o = NULL;
1468 if ((k = fscanf(m->proc_self_mountinfo,
1469 "%*s " /* (1) mount id */
1470 "%*s " /* (2) parent id */
1471 "%*s " /* (3) major:minor */
1472 "%*s " /* (4) root */
1473 "%ms " /* (5) mount point */
1474 "%ms" /* (6) mount options */
1475 "%*[^-]" /* (7) optional fields */
1476 "- " /* (8) separator */
1477 "%ms " /* (9) file system type */
1478 "%ms" /* (10) mount source */
1479 "%ms" /* (11) mount options 2 */
1480 "%*[^\n]", /* some rubbish at the end */
1490 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1494 o = join(options, ",", options2, NULL);
1500 if (!(d = cunescape(device)) ||
1501 !(p = cunescape(path))) {
1506 if ((k = mount_add_one(m, d, p, o, fstype, 0, set_flags)) < 0)
1533 static void mount_shutdown(Manager *m) {
1536 if (m->proc_self_mountinfo) {
1537 fclose(m->proc_self_mountinfo);
1538 m->proc_self_mountinfo = NULL;
1542 static int mount_enumerate(Manager *m) {
1544 struct epoll_event ev;
1547 if (!m->proc_self_mountinfo) {
1548 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1551 m->mount_watch.type = WATCH_MOUNT;
1552 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1555 ev.events = EPOLLPRI;
1556 ev.data.ptr = &m->mount_watch;
1558 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1562 if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1572 void mount_fd_event(Manager *m, int events) {
1577 assert(events & EPOLLPRI);
1579 /* The manager calls this for every fd event happening on the
1580 * /proc/self/mountinfo file, which informs us about mounting
1583 if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
1584 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1586 /* Reset flags, just in case, for later calls */
1587 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1588 Mount *mount = MOUNT(u);
1590 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1596 manager_dispatch_load_queue(m);
1598 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1599 Mount *mount = MOUNT(u);
1601 if (!mount->is_mounted) {
1602 /* This has just been unmounted. */
1604 mount->from_proc_self_mountinfo = false;
1606 switch (mount->state) {
1609 mount_enter_dead(mount, MOUNT_SUCCESS);
1613 mount_set_state(mount, mount->state);
1618 } else if (mount->just_mounted || mount->just_changed) {
1620 /* New or changed mount entry */
1622 switch (mount->state) {
1626 mount_enter_mounted(mount, MOUNT_SUCCESS);
1629 case MOUNT_MOUNTING:
1630 mount_enter_mounting_done(mount);
1634 /* Nothing really changed, but let's
1635 * issue an notification call
1636 * nonetheless, in case somebody is
1637 * waiting for this. (e.g. file system
1638 * ro/rw remounts.) */
1639 mount_set_state(mount, mount->state);
1644 /* Reset the flags for later calls */
1645 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1649 static void mount_reset_failed(Unit *u) {
1650 Mount *m = MOUNT(u);
1654 if (m->state == MOUNT_FAILED)
1655 mount_set_state(m, MOUNT_DEAD);
1657 m->result = MOUNT_SUCCESS;
1658 m->reload_result = MOUNT_SUCCESS;
1661 static int mount_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
1662 Mount *m = MOUNT(u);
1664 Set *pid_set = NULL;
1668 if (who == KILL_MAIN) {
1669 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1673 if (m->control_pid <= 0 && who == KILL_CONTROL) {
1674 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1678 if (who == KILL_CONTROL || who == KILL_ALL)
1679 if (m->control_pid > 0)
1680 if (kill(m->control_pid, signo) < 0)
1683 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
1686 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
1689 /* Exclude the control pid from being killed via the cgroup */
1690 if (m->control_pid > 0)
1691 if ((q = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0) {
1696 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, false, pid_set, NULL);
1698 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1709 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1710 [MOUNT_DEAD] = "dead",
1711 [MOUNT_MOUNTING] = "mounting",
1712 [MOUNT_MOUNTING_DONE] = "mounting-done",
1713 [MOUNT_MOUNTED] = "mounted",
1714 [MOUNT_REMOUNTING] = "remounting",
1715 [MOUNT_UNMOUNTING] = "unmounting",
1716 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1717 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1718 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1719 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1720 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1721 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1722 [MOUNT_FAILED] = "failed"
1725 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1727 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1728 [MOUNT_EXEC_MOUNT] = "ExecMount",
1729 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1730 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1733 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1735 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1736 [MOUNT_SUCCESS] = "success",
1737 [MOUNT_FAILURE_RESOURCES] = "resources",
1738 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1739 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1740 [MOUNT_FAILURE_SIGNAL] = "signal",
1741 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1744 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1746 const UnitVTable mount_vtable = {
1748 .object_size = sizeof(Mount),
1755 .no_instances = true,
1761 .coldplug = mount_coldplug,
1765 .start = mount_start,
1767 .reload = mount_reload,
1771 .serialize = mount_serialize,
1772 .deserialize_item = mount_deserialize_item,
1774 .active_state = mount_active_state,
1775 .sub_state_to_string = mount_sub_state_to_string,
1777 .check_gc = mount_check_gc,
1779 .sigchld_event = mount_sigchld_event,
1780 .timer_event = mount_timer_event,
1782 .reset_failed = mount_reset_failed,
1784 .bus_interface = "org.freedesktop.systemd1.Mount",
1785 .bus_message_handler = bus_mount_message_handler,
1786 .bus_invalidating_properties = bus_mount_invalidating_properties,
1788 .enumerate = mount_enumerate,
1789 .shutdown = mount_shutdown,
1791 .status_message_formats = {
1792 .starting_stopping = {
1793 [0] = "Mounting %s...",
1794 [1] = "Unmounting %s...",
1796 .finished_start_job = {
1797 [JOB_DONE] = "Mounted %s.",
1798 [JOB_FAILED] = "Failed to mount %s.",
1799 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1800 [JOB_TIMEOUT] = "Timed out mounting %s.",
1802 .finished_stop_job = {
1803 [JOB_DONE] = "Unmounted %s.",
1804 [JOB_FAILED] = "Failed unmounting %s.",
1805 [JOB_TIMEOUT] = "Timed out unmounting %s.",