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 kill_context_init(&m->kill_context);
84 /* We need to make sure that /bin/mount is always called in
85 * the same process group as us, so that the autofs kernel
86 * side doesn't send us another mount request while we are
87 * already trying to comply its last one. */
88 m->exec_context.same_pgrp = true;
90 m->timer_watch.type = WATCH_INVALID;
92 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
94 UNIT(m)->ignore_on_isolate = true;
97 static void mount_unwatch_control_pid(Mount *m) {
100 if (m->control_pid <= 0)
103 unit_unwatch_pid(UNIT(m), m->control_pid);
107 static void mount_parameters_done(MountParameters *p) {
114 p->what = p->options = p->fstype = NULL;
117 static void mount_done(Unit *u) {
125 mount_parameters_done(&m->parameters_proc_self_mountinfo);
126 mount_parameters_done(&m->parameters_fragment);
128 exec_context_done(&m->exec_context);
129 exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
130 m->control_command = NULL;
132 mount_unwatch_control_pid(m);
134 unit_unwatch_timer(u, &m->timer_watch);
137 static MountParameters* get_mount_parameters_fragment(Mount *m) {
140 if (m->from_fragment)
141 return &m->parameters_fragment;
146 static MountParameters* get_mount_parameters(Mount *m) {
149 if (m->from_proc_self_mountinfo)
150 return &m->parameters_proc_self_mountinfo;
152 return get_mount_parameters_fragment(m);
155 static int mount_add_mount_links(Mount *m) {
162 pm = get_mount_parameters_fragment(m);
164 /* Adds in links to other mount points that might lie below or
165 * above us in the hierarchy */
167 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_MOUNT]) {
168 Mount *n = MOUNT(other);
174 if (UNIT(n)->load_state != UNIT_LOADED)
177 pn = get_mount_parameters_fragment(n);
179 if (path_startswith(m->where, n->where)) {
181 if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, UNIT(n), true)) < 0)
185 if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, UNIT(n), true)) < 0)
188 } else if (path_startswith(n->where, m->where)) {
190 if ((r = unit_add_dependency(UNIT(n), UNIT_AFTER, UNIT(m), true)) < 0)
194 if ((r = unit_add_dependency(UNIT(n), UNIT_REQUIRES, UNIT(m), true)) < 0)
197 } else if (pm && pm->what && path_startswith(pm->what, n->where)) {
199 if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, UNIT(n), true)) < 0)
202 if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, UNIT(n), true)) < 0)
205 } else if (pn && pn->what && path_startswith(pn->what, m->where)) {
207 if ((r = unit_add_dependency(UNIT(n), UNIT_AFTER, UNIT(m), true)) < 0)
210 if ((r = unit_add_dependency(UNIT(n), UNIT_REQUIRES, UNIT(m), true)) < 0)
218 static int mount_add_swap_links(Mount *m) {
224 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_SWAP])
225 if ((r = swap_add_one_mount_link(SWAP(other), m)) < 0)
231 static int mount_add_path_links(Mount *m) {
237 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_PATH])
238 if ((r = path_add_one_mount_link(PATH(other), m)) < 0)
244 static int mount_add_automount_links(Mount *m) {
250 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_AUTOMOUNT])
251 if ((r = automount_add_one_mount_link(AUTOMOUNT(other), m)) < 0)
257 static int mount_add_socket_links(Mount *m) {
263 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_SOCKET])
264 if ((r = socket_add_one_mount_link(SOCKET(other), m)) < 0)
270 static int mount_add_requires_mounts_links(Mount *m) {
276 LIST_FOREACH(has_requires_mounts_for, other, UNIT(m)->manager->has_requires_mounts_for) {
277 r = unit_add_one_mount_link(other, m);
285 static char* mount_test_option(const char *haystack, const char *needle) {
290 /* Like glibc's hasmntopt(), but works on a string, not a
297 me.mnt_opts = (char*) haystack;
299 return hasmntopt(&me, needle);
302 static bool mount_is_network(MountParameters *p) {
305 if (mount_test_option(p->options, "_netdev"))
308 if (p->fstype && fstype_is_network(p->fstype))
314 static bool mount_is_bind(MountParameters *p) {
317 if (mount_test_option(p->options, "bind"))
320 if (p->fstype && streq(p->fstype, "bind"))
326 static bool needs_quota(MountParameters *p) {
329 if (mount_is_network(p))
332 if (mount_is_bind(p))
335 return mount_test_option(p->options, "usrquota") ||
336 mount_test_option(p->options, "grpquota") ||
337 mount_test_option(p->options, "quota") ||
338 mount_test_option(p->options, "usrjquota") ||
339 mount_test_option(p->options, "grpjquota");
342 static int mount_add_device_links(Mount *m) {
348 p = get_mount_parameters_fragment(m);
355 if (mount_is_bind(p))
358 if (!is_device_path(p->what))
361 if (path_equal(m->where, "/"))
364 r = unit_add_node_link(UNIT(m), p->what, false);
369 UNIT(m)->manager->running_as == SYSTEMD_SYSTEM) {
372 /* Let's add in the fsck service */
374 /* aka SPECIAL_FSCK_SERVICE */
375 name = unit_name_from_path_instance("systemd-fsck", p->what, ".service");
379 r = manager_load_unit_prepare(UNIT(m)->manager, name, NULL, NULL, &fsck);
381 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
387 SERVICE(fsck)->fsck_passno = p->passno;
389 r = unit_add_two_dependencies(UNIT(m), UNIT_AFTER, UNIT_REQUIRES, fsck, true);
397 static int mount_add_quota_links(Mount *m) {
403 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
406 p = get_mount_parameters_fragment(m);
413 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true);
417 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true);
424 static int mount_add_default_dependencies(Mount *m) {
431 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
434 p = get_mount_parameters_fragment(m);
438 if (path_equal(m->where, "/"))
441 if (mount_is_network(p))
442 after = SPECIAL_REMOTE_FS_PRE_TARGET;
444 after = SPECIAL_LOCAL_FS_PRE_TARGET;
446 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, after, NULL, true);
450 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
457 static int mount_fix_timeouts(Mount *m) {
459 const char *timeout = NULL;
468 p = get_mount_parameters_fragment(m);
472 /* Allow configuration how long we wait for a device that
473 * backs a mount point to show up. This is useful to support
474 * endless device timeouts for devices that show up only after
475 * user input, like crypto devices. */
477 if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
479 else if ((timeout = mount_test_option(p->options, "x-systemd.device-timeout")))
484 t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
488 r = parse_usec(t, &u);
492 log_warning("Failed to parse timeout for %s, ignoring: %s", m->where, timeout);
496 SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
497 if (other->type != UNIT_DEVICE)
500 other->job_timeout = u;
506 static int mount_verify(Mount *m) {
511 if (UNIT(m)->load_state != UNIT_LOADED)
514 if (!m->from_fragment && !m->from_proc_self_mountinfo)
517 if (!(e = unit_name_from_path(m->where, ".mount")))
520 b = unit_has_name(UNIT(m), e);
524 log_error("%s's Where setting doesn't match unit name. Refusing.", UNIT(m)->id);
528 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
529 log_error("Cannot create mount unit for API file system %s. Refusing.", m->where);
533 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
534 log_error("%s's What setting is missing. Refusing.", UNIT(m)->id);
538 if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
539 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(m)->id);
546 static int mount_add_extras(Mount *m) {
550 if (UNIT(m)->fragment_path)
551 m->from_fragment = true;
554 m->where = unit_name_to_path(u->id);
559 path_kill_slashes(m->where);
561 r = unit_add_exec_dependencies(u, &m->exec_context);
565 if (!UNIT(m)->description) {
566 r = unit_set_description(u, m->where);
571 r = mount_add_device_links(m);
575 r = mount_add_mount_links(m);
579 r = mount_add_socket_links(m);
583 r = mount_add_swap_links(m);
587 r = mount_add_path_links(m);
591 r = mount_add_requires_mounts_links(m);
595 r = mount_add_automount_links(m);
599 r = mount_add_quota_links(m);
603 if (UNIT(m)->default_dependencies) {
604 r = mount_add_default_dependencies(m);
609 r = unit_add_default_cgroups(u);
613 r = mount_fix_timeouts(m);
620 static int mount_load(Unit *u) {
625 assert(u->load_state == UNIT_STUB);
627 if (m->from_proc_self_mountinfo)
628 r = unit_load_fragment_and_dropin_optional(u);
630 r = unit_load_fragment_and_dropin(u);
635 /* This is a new unit? Then let's add in some extras */
636 if (u->load_state == UNIT_LOADED) {
637 r = mount_add_extras(m);
641 r = unit_exec_context_defaults(u, &m->exec_context);
646 return mount_verify(m);
649 static int mount_notify_automount(Mount *m, int status) {
656 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
657 if (p->type == UNIT_AUTOMOUNT) {
658 r = automount_send_ready(AUTOMOUNT(p), status);
666 static void mount_set_state(Mount *m, MountState state) {
667 MountState old_state;
670 old_state = m->state;
673 if (state != MOUNT_MOUNTING &&
674 state != MOUNT_MOUNTING_DONE &&
675 state != MOUNT_REMOUNTING &&
676 state != MOUNT_UNMOUNTING &&
677 state != MOUNT_MOUNTING_SIGTERM &&
678 state != MOUNT_MOUNTING_SIGKILL &&
679 state != MOUNT_UNMOUNTING_SIGTERM &&
680 state != MOUNT_UNMOUNTING_SIGKILL &&
681 state != MOUNT_REMOUNTING_SIGTERM &&
682 state != MOUNT_REMOUNTING_SIGKILL) {
683 unit_unwatch_timer(UNIT(m), &m->timer_watch);
684 mount_unwatch_control_pid(m);
685 m->control_command = NULL;
686 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
689 if (state == MOUNT_MOUNTED ||
690 state == MOUNT_REMOUNTING)
691 mount_notify_automount(m, 0);
692 else if (state == MOUNT_DEAD ||
693 state == MOUNT_UNMOUNTING ||
694 state == MOUNT_MOUNTING_SIGTERM ||
695 state == MOUNT_MOUNTING_SIGKILL ||
696 state == MOUNT_REMOUNTING_SIGTERM ||
697 state == MOUNT_REMOUNTING_SIGKILL ||
698 state == MOUNT_UNMOUNTING_SIGTERM ||
699 state == MOUNT_UNMOUNTING_SIGKILL ||
700 state == MOUNT_FAILED) {
701 if (state != old_state)
702 mount_notify_automount(m, -ENODEV);
705 if (state != old_state)
706 log_debug("%s changed %s -> %s",
708 mount_state_to_string(old_state),
709 mount_state_to_string(state));
711 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
712 m->reload_result = MOUNT_SUCCESS;
715 static int mount_coldplug(Unit *u) {
717 MountState new_state = MOUNT_DEAD;
721 assert(m->state == MOUNT_DEAD);
723 if (m->deserialized_state != m->state)
724 new_state = m->deserialized_state;
725 else if (m->from_proc_self_mountinfo)
726 new_state = MOUNT_MOUNTED;
728 if (new_state != m->state) {
730 if (new_state == MOUNT_MOUNTING ||
731 new_state == MOUNT_MOUNTING_DONE ||
732 new_state == MOUNT_REMOUNTING ||
733 new_state == MOUNT_UNMOUNTING ||
734 new_state == MOUNT_MOUNTING_SIGTERM ||
735 new_state == MOUNT_MOUNTING_SIGKILL ||
736 new_state == MOUNT_UNMOUNTING_SIGTERM ||
737 new_state == MOUNT_UNMOUNTING_SIGKILL ||
738 new_state == MOUNT_REMOUNTING_SIGTERM ||
739 new_state == MOUNT_REMOUNTING_SIGKILL) {
741 if (m->control_pid <= 0)
744 if ((r = unit_watch_pid(UNIT(m), m->control_pid)) < 0)
747 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
751 mount_set_state(m, new_state);
757 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
764 p = get_mount_parameters(m);
767 "%sMount State: %s\n"
771 "%sFile System Type: %s\n"
773 "%sFrom /proc/self/mountinfo: %s\n"
774 "%sFrom fragment: %s\n"
775 "%sDirectoryMode: %04o\n",
776 prefix, mount_state_to_string(m->state),
777 prefix, mount_result_to_string(m->result),
779 prefix, strna(p->what),
780 prefix, strna(p->fstype),
781 prefix, strna(p->options),
782 prefix, yes_no(m->from_proc_self_mountinfo),
783 prefix, yes_no(m->from_fragment),
784 prefix, m->directory_mode);
786 if (m->control_pid > 0)
788 "%sControl PID: %lu\n",
789 prefix, (unsigned long) m->control_pid);
791 exec_context_dump(&m->exec_context, f, prefix);
792 kill_context_dump(&m->kill_context, f, prefix);
795 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
803 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
806 if ((r = exec_spawn(c,
810 UNIT(m)->manager->environment,
814 UNIT(m)->manager->confirm_spawn,
815 UNIT(m)->cgroup_bondings,
816 UNIT(m)->cgroup_attributes,
823 if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
824 /* FIXME: we need to do something here */
832 unit_unwatch_timer(UNIT(m), &m->timer_watch);
837 static void mount_enter_dead(Mount *m, MountResult f) {
840 if (f != MOUNT_SUCCESS)
843 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
846 static void mount_enter_mounted(Mount *m, MountResult f) {
849 if (f != MOUNT_SUCCESS)
852 mount_set_state(m, MOUNT_MOUNTED);
855 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
858 bool wait_for_exit = false;
862 if (f != MOUNT_SUCCESS)
865 if (m->kill_context.kill_mode != KILL_NONE) {
866 int sig = (state == MOUNT_MOUNTING_SIGTERM ||
867 state == MOUNT_UNMOUNTING_SIGTERM ||
868 state == MOUNT_REMOUNTING_SIGTERM) ? m->kill_context.kill_signal : SIGKILL;
870 if (m->control_pid > 0) {
871 if (kill_and_sigcont(m->control_pid, sig) < 0 && errno != ESRCH)
873 log_warning("Failed to kill control process %li: %m", (long) m->control_pid);
875 wait_for_exit = true;
878 if (m->kill_context.kill_mode == KILL_CONTROL_GROUP) {
880 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
885 /* Exclude the control pid from being killed via the cgroup */
886 if (m->control_pid > 0)
887 if ((r = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0)
890 r = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, sig, true, false, pid_set, NULL);
892 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
893 log_warning("Failed to kill control group: %s", strerror(-r));
895 wait_for_exit = true;
903 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
906 mount_set_state(m, state);
907 } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
908 mount_enter_mounted(m, MOUNT_SUCCESS);
910 mount_enter_dead(m, MOUNT_SUCCESS);
915 log_warning("%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
917 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
918 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
920 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
926 static void mount_enter_unmounting(Mount *m) {
931 m->control_command_id = MOUNT_EXEC_UNMOUNT;
932 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
934 if ((r = exec_command_set(
941 mount_unwatch_control_pid(m);
943 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
946 mount_set_state(m, MOUNT_UNMOUNTING);
951 log_warning("%s failed to run 'umount' task: %s", UNIT(m)->id, strerror(-r));
952 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
955 static void mount_enter_mounting(Mount *m) {
961 m->control_command_id = MOUNT_EXEC_MOUNT;
962 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
964 mkdir_p_label(m->where, m->directory_mode);
966 if (dir_is_empty(m->where) <= 0)
967 log_notice("%s: Directory %s to mount over is not empty, mounting anyway. (To see the over-mounted files, please manually mount the underlying file system to a secondary location.)", m->meta.id, m->where);
969 /* Create the source directory for bind-mounts if needed */
970 p = get_mount_parameters_fragment(m);
971 if (p && mount_is_bind(p))
972 mkdir_p_label(p->what, m->directory_mode);
974 if (m->from_fragment)
975 r = exec_command_set(
978 m->parameters_fragment.what,
980 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
981 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
989 mount_unwatch_control_pid(m);
991 r = mount_spawn(m, m->control_command, &m->control_pid);
995 mount_set_state(m, MOUNT_MOUNTING);
1000 log_warning("%s failed to run 'mount' task: %s", UNIT(m)->id, strerror(-r));
1001 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
1004 static void mount_enter_mounting_done(Mount *m) {
1007 mount_set_state(m, MOUNT_MOUNTING_DONE);
1010 static void mount_enter_remounting(Mount *m) {
1015 m->control_command_id = MOUNT_EXEC_REMOUNT;
1016 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1018 if (m->from_fragment) {
1022 if (m->parameters_fragment.options) {
1023 if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
1032 r = exec_command_set(
1035 m->parameters_fragment.what,
1037 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
1048 mount_unwatch_control_pid(m);
1050 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1053 mount_set_state(m, MOUNT_REMOUNTING);
1058 log_warning("%s failed to run 'remount' task: %s", UNIT(m)->id, strerror(-r));
1059 m->reload_result = MOUNT_FAILURE_RESOURCES;
1060 mount_enter_mounted(m, MOUNT_SUCCESS);
1063 static int mount_start(Unit *u) {
1064 Mount *m = MOUNT(u);
1068 /* We cannot fulfill this request right now, try again later
1070 if (m->state == MOUNT_UNMOUNTING ||
1071 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1072 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1073 m->state == MOUNT_MOUNTING_SIGTERM ||
1074 m->state == MOUNT_MOUNTING_SIGKILL)
1077 /* Already on it! */
1078 if (m->state == MOUNT_MOUNTING)
1081 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1083 m->result = MOUNT_SUCCESS;
1084 m->reload_result = MOUNT_SUCCESS;
1086 mount_enter_mounting(m);
1090 static int mount_stop(Unit *u) {
1091 Mount *m = MOUNT(u);
1096 if (m->state == MOUNT_UNMOUNTING ||
1097 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1098 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1099 m->state == MOUNT_MOUNTING_SIGTERM ||
1100 m->state == MOUNT_MOUNTING_SIGKILL)
1103 assert(m->state == MOUNT_MOUNTING ||
1104 m->state == MOUNT_MOUNTING_DONE ||
1105 m->state == MOUNT_MOUNTED ||
1106 m->state == MOUNT_REMOUNTING ||
1107 m->state == MOUNT_REMOUNTING_SIGTERM ||
1108 m->state == MOUNT_REMOUNTING_SIGKILL);
1110 mount_enter_unmounting(m);
1114 static int mount_reload(Unit *u) {
1115 Mount *m = MOUNT(u);
1119 if (m->state == MOUNT_MOUNTING_DONE)
1122 assert(m->state == MOUNT_MOUNTED);
1124 mount_enter_remounting(m);
1128 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1129 Mount *m = MOUNT(u);
1135 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1136 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1137 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1139 if (m->control_pid > 0)
1140 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1142 if (m->control_command_id >= 0)
1143 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1148 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1149 Mount *m = MOUNT(u);
1156 if (streq(key, "state")) {
1159 if ((state = mount_state_from_string(value)) < 0)
1160 log_debug("Failed to parse state value %s", value);
1162 m->deserialized_state = state;
1163 } else if (streq(key, "result")) {
1166 f = mount_result_from_string(value);
1168 log_debug("Failed to parse result value %s", value);
1169 else if (f != MOUNT_SUCCESS)
1172 } else if (streq(key, "reload-result")) {
1175 f = mount_result_from_string(value);
1177 log_debug("Failed to parse reload result value %s", value);
1178 else if (f != MOUNT_SUCCESS)
1179 m->reload_result = f;
1181 } else if (streq(key, "control-pid")) {
1184 if (parse_pid(value, &pid) < 0)
1185 log_debug("Failed to parse control-pid value %s", value);
1187 m->control_pid = pid;
1188 } else if (streq(key, "control-command")) {
1189 MountExecCommand id;
1191 if ((id = mount_exec_command_from_string(value)) < 0)
1192 log_debug("Failed to parse exec-command value %s", value);
1194 m->control_command_id = id;
1195 m->control_command = m->exec_command + id;
1199 log_debug("Unknown serialization key '%s'", key);
1204 static UnitActiveState mount_active_state(Unit *u) {
1207 return state_translation_table[MOUNT(u)->state];
1210 static const char *mount_sub_state_to_string(Unit *u) {
1213 return mount_state_to_string(MOUNT(u)->state);
1216 static bool mount_check_gc(Unit *u) {
1217 Mount *m = MOUNT(u);
1221 return m->from_proc_self_mountinfo;
1224 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1225 Mount *m = MOUNT(u);
1231 if (pid != m->control_pid)
1236 if (is_clean_exit(code, status, NULL))
1238 else if (code == CLD_EXITED)
1239 f = MOUNT_FAILURE_EXIT_CODE;
1240 else if (code == CLD_KILLED)
1241 f = MOUNT_FAILURE_SIGNAL;
1242 else if (code == CLD_DUMPED)
1243 f = MOUNT_FAILURE_CORE_DUMP;
1245 assert_not_reached("Unknown code");
1247 if (f != MOUNT_SUCCESS)
1250 if (m->control_command) {
1251 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1253 m->control_command = NULL;
1254 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1257 log_full(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1258 "%s mount process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1260 /* Note that mount(8) returning and the kernel sending us a
1261 * mount table change event might happen out-of-order. If an
1262 * operation succeed we assume the kernel will follow soon too
1263 * and already change into the resulting state. If it fails
1264 * we check if the kernel still knows about the mount. and
1265 * change state accordingly. */
1269 case MOUNT_MOUNTING:
1270 case MOUNT_MOUNTING_DONE:
1271 case MOUNT_MOUNTING_SIGKILL:
1272 case MOUNT_MOUNTING_SIGTERM:
1274 if (f == MOUNT_SUCCESS)
1275 mount_enter_mounted(m, f);
1276 else if (m->from_proc_self_mountinfo)
1277 mount_enter_mounted(m, f);
1279 mount_enter_dead(m, f);
1282 case MOUNT_REMOUNTING:
1283 case MOUNT_REMOUNTING_SIGKILL:
1284 case MOUNT_REMOUNTING_SIGTERM:
1286 m->reload_result = f;
1287 if (m->from_proc_self_mountinfo)
1288 mount_enter_mounted(m, MOUNT_SUCCESS);
1290 mount_enter_dead(m, MOUNT_SUCCESS);
1294 case MOUNT_UNMOUNTING:
1295 case MOUNT_UNMOUNTING_SIGKILL:
1296 case MOUNT_UNMOUNTING_SIGTERM:
1298 if (f == MOUNT_SUCCESS)
1299 mount_enter_dead(m, f);
1300 else if (m->from_proc_self_mountinfo)
1301 mount_enter_mounted(m, f);
1303 mount_enter_dead(m, f);
1307 assert_not_reached("Uh, control process died at wrong time.");
1310 /* Notify clients about changed exit status */
1311 unit_add_to_dbus_queue(u);
1314 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1315 Mount *m = MOUNT(u);
1318 assert(elapsed == 1);
1319 assert(w == &m->timer_watch);
1323 case MOUNT_MOUNTING:
1324 case MOUNT_MOUNTING_DONE:
1325 log_warning("%s mounting timed out. Stopping.", u->id);
1326 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1329 case MOUNT_REMOUNTING:
1330 log_warning("%s remounting timed out. Stopping.", u->id);
1331 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1332 mount_enter_mounted(m, MOUNT_SUCCESS);
1335 case MOUNT_UNMOUNTING:
1336 log_warning("%s unmounting timed out. Stopping.", u->id);
1337 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1340 case MOUNT_MOUNTING_SIGTERM:
1341 if (m->kill_context.send_sigkill) {
1342 log_warning("%s mounting timed out. Killing.", u->id);
1343 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1345 log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1347 if (m->from_proc_self_mountinfo)
1348 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1350 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1354 case MOUNT_REMOUNTING_SIGTERM:
1355 if (m->kill_context.send_sigkill) {
1356 log_warning("%s remounting timed out. Killing.", u->id);
1357 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1359 log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1361 if (m->from_proc_self_mountinfo)
1362 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1364 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1368 case MOUNT_UNMOUNTING_SIGTERM:
1369 if (m->kill_context.send_sigkill) {
1370 log_warning("%s unmounting timed out. Killing.", u->id);
1371 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1373 log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1375 if (m->from_proc_self_mountinfo)
1376 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1378 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1382 case MOUNT_MOUNTING_SIGKILL:
1383 case MOUNT_REMOUNTING_SIGKILL:
1384 case MOUNT_UNMOUNTING_SIGKILL:
1385 log_warning("%s mount process still around after SIGKILL. Ignoring.", u->id);
1387 if (m->from_proc_self_mountinfo)
1388 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1390 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1394 assert_not_reached("Timeout at wrong time.");
1398 static int mount_add_one(
1402 const char *options,
1409 char *e, *w = NULL, *o = NULL, *f = NULL;
1411 bool load_extras = false;
1419 /* Ignore API mount points. They should never be referenced in
1420 * dependencies ever. */
1421 if (mount_point_is_api(where) || mount_point_ignore(where))
1424 if (streq(fstype, "autofs"))
1427 /* probably some kind of swap, ignore */
1428 if (!is_path(where))
1431 e = unit_name_from_path(where, ".mount");
1435 u = manager_get_unit(m, e);
1439 u = unit_new(m, sizeof(Mount));
1445 r = unit_add_name(u, e);
1451 MOUNT(u)->where = strdup(where);
1452 if (!MOUNT(u)->where) {
1457 unit_add_to_load_queue(u);
1462 if (!MOUNT(u)->where) {
1463 MOUNT(u)->where = strdup(where);
1464 if (!MOUNT(u)->where) {
1470 if (u->load_state == UNIT_ERROR) {
1471 u->load_state = UNIT_LOADED;
1474 /* Load in the extras later on, after we
1475 * finished initialization of the unit */
1480 if (!(w = strdup(what)) ||
1481 !(o = strdup(options)) ||
1482 !(f = strdup(fstype))) {
1487 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1489 MOUNT(u)->is_mounted = true;
1490 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1491 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1494 MOUNT(u)->from_proc_self_mountinfo = true;
1508 r = mount_add_extras(MOUNT(u));
1513 unit_add_to_dbus_queue(u);
1528 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1531 char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1535 rewind(m->proc_self_mountinfo);
1540 device = path = options = options2 = fstype = d = p = o = NULL;
1542 if ((k = fscanf(m->proc_self_mountinfo,
1543 "%*s " /* (1) mount id */
1544 "%*s " /* (2) parent id */
1545 "%*s " /* (3) major:minor */
1546 "%*s " /* (4) root */
1547 "%ms " /* (5) mount point */
1548 "%ms" /* (6) mount options */
1549 "%*[^-]" /* (7) optional fields */
1550 "- " /* (8) separator */
1551 "%ms " /* (9) file system type */
1552 "%ms" /* (10) mount source */
1553 "%ms" /* (11) mount options 2 */
1554 "%*[^\n]", /* some rubbish at the end */
1564 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1568 o = strjoin(options, ",", options2, NULL);
1574 if (!(d = cunescape(device)) ||
1575 !(p = cunescape(path))) {
1580 if ((k = mount_add_one(m, d, p, o, fstype, 0, set_flags)) < 0)
1607 static void mount_shutdown(Manager *m) {
1610 if (m->proc_self_mountinfo) {
1611 fclose(m->proc_self_mountinfo);
1612 m->proc_self_mountinfo = NULL;
1616 static int mount_enumerate(Manager *m) {
1618 struct epoll_event ev;
1621 if (!m->proc_self_mountinfo) {
1622 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1625 m->mount_watch.type = WATCH_MOUNT;
1626 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1629 ev.events = EPOLLPRI;
1630 ev.data.ptr = &m->mount_watch;
1632 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1636 if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1646 void mount_fd_event(Manager *m, int events) {
1651 assert(events & EPOLLPRI);
1653 /* The manager calls this for every fd event happening on the
1654 * /proc/self/mountinfo file, which informs us about mounting
1657 if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
1658 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1660 /* Reset flags, just in case, for later calls */
1661 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1662 Mount *mount = MOUNT(u);
1664 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1670 manager_dispatch_load_queue(m);
1672 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1673 Mount *mount = MOUNT(u);
1675 if (!mount->is_mounted) {
1676 /* This has just been unmounted. */
1678 mount->from_proc_self_mountinfo = false;
1680 switch (mount->state) {
1683 mount_enter_dead(mount, MOUNT_SUCCESS);
1687 mount_set_state(mount, mount->state);
1692 } else if (mount->just_mounted || mount->just_changed) {
1694 /* New or changed mount entry */
1696 switch (mount->state) {
1700 mount_enter_mounted(mount, MOUNT_SUCCESS);
1703 case MOUNT_MOUNTING:
1704 mount_enter_mounting_done(mount);
1708 /* Nothing really changed, but let's
1709 * issue an notification call
1710 * nonetheless, in case somebody is
1711 * waiting for this. (e.g. file system
1712 * ro/rw remounts.) */
1713 mount_set_state(mount, mount->state);
1718 /* Reset the flags for later calls */
1719 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1723 static void mount_reset_failed(Unit *u) {
1724 Mount *m = MOUNT(u);
1728 if (m->state == MOUNT_FAILED)
1729 mount_set_state(m, MOUNT_DEAD);
1731 m->result = MOUNT_SUCCESS;
1732 m->reload_result = MOUNT_SUCCESS;
1735 static int mount_kill(Unit *u, KillWho who, int signo, DBusError *error) {
1736 Mount *m = MOUNT(u);
1738 Set *pid_set = NULL;
1742 if (who == KILL_MAIN) {
1743 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1747 if (m->control_pid <= 0 && who == KILL_CONTROL) {
1748 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1752 if (who == KILL_CONTROL || who == KILL_ALL)
1753 if (m->control_pid > 0)
1754 if (kill(m->control_pid, signo) < 0)
1757 if (who == KILL_ALL) {
1760 pid_set = set_new(trivial_hash_func, trivial_compare_func);
1764 /* Exclude the control pid from being killed via the cgroup */
1765 if (m->control_pid > 0) {
1766 q = set_put(pid_set, LONG_TO_PTR(m->control_pid));
1773 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, false, pid_set, NULL);
1774 if (q < 0 && q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1785 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1786 [MOUNT_DEAD] = "dead",
1787 [MOUNT_MOUNTING] = "mounting",
1788 [MOUNT_MOUNTING_DONE] = "mounting-done",
1789 [MOUNT_MOUNTED] = "mounted",
1790 [MOUNT_REMOUNTING] = "remounting",
1791 [MOUNT_UNMOUNTING] = "unmounting",
1792 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1793 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1794 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1795 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1796 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1797 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1798 [MOUNT_FAILED] = "failed"
1801 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1803 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1804 [MOUNT_EXEC_MOUNT] = "ExecMount",
1805 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1806 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1809 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1811 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1812 [MOUNT_SUCCESS] = "success",
1813 [MOUNT_FAILURE_RESOURCES] = "resources",
1814 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1815 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1816 [MOUNT_FAILURE_SIGNAL] = "signal",
1817 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1820 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1822 const UnitVTable mount_vtable = {
1823 .object_size = sizeof(Mount),
1824 .exec_context_offset = offsetof(Mount, exec_context),
1832 .no_instances = true,
1838 .coldplug = mount_coldplug,
1842 .start = mount_start,
1844 .reload = mount_reload,
1848 .serialize = mount_serialize,
1849 .deserialize_item = mount_deserialize_item,
1851 .active_state = mount_active_state,
1852 .sub_state_to_string = mount_sub_state_to_string,
1854 .check_gc = mount_check_gc,
1856 .sigchld_event = mount_sigchld_event,
1857 .timer_event = mount_timer_event,
1859 .reset_failed = mount_reset_failed,
1861 .bus_interface = "org.freedesktop.systemd1.Mount",
1862 .bus_message_handler = bus_mount_message_handler,
1863 .bus_invalidating_properties = bus_mount_invalidating_properties,
1865 .enumerate = mount_enumerate,
1866 .shutdown = mount_shutdown,
1868 .status_message_formats = {
1869 .starting_stopping = {
1870 [0] = "Mounting %s...",
1871 [1] = "Unmounting %s...",
1873 .finished_start_job = {
1874 [JOB_DONE] = "Mounted %s.",
1875 [JOB_FAILED] = "Failed to mount %s.",
1876 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1877 [JOB_TIMEOUT] = "Timed out mounting %s.",
1879 .finished_stop_job = {
1880 [JOB_DONE] = "Unmounted %s.",
1881 [JOB_FAILED] = "Failed unmounting %s.",
1882 [JOB_TIMEOUT] = "Timed out unmounting %s.",