1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include <sys/epoll.h>
31 #include "load-fragment.h"
32 #include "load-dropin.h"
34 #include "sd-messages.h"
37 #include "path-util.h"
38 #include "mount-setup.h"
39 #include "unit-name.h"
40 #include "dbus-mount.h"
42 #include "bus-errors.h"
43 #include "exit-status.h"
46 static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
47 [MOUNT_DEAD] = UNIT_INACTIVE,
48 [MOUNT_MOUNTING] = UNIT_ACTIVATING,
49 [MOUNT_MOUNTING_DONE] = UNIT_ACTIVE,
50 [MOUNT_MOUNTED] = UNIT_ACTIVE,
51 [MOUNT_REMOUNTING] = UNIT_RELOADING,
52 [MOUNT_UNMOUNTING] = UNIT_DEACTIVATING,
53 [MOUNT_MOUNTING_SIGTERM] = UNIT_DEACTIVATING,
54 [MOUNT_MOUNTING_SIGKILL] = UNIT_DEACTIVATING,
55 [MOUNT_REMOUNTING_SIGTERM] = UNIT_RELOADING,
56 [MOUNT_REMOUNTING_SIGKILL] = UNIT_RELOADING,
57 [MOUNT_UNMOUNTING_SIGTERM] = UNIT_DEACTIVATING,
58 [MOUNT_UNMOUNTING_SIGKILL] = UNIT_DEACTIVATING,
59 [MOUNT_FAILED] = UNIT_FAILED
62 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
63 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
65 static bool mount_is_network(MountParameters *p) {
68 if (mount_test_option(p->options, "_netdev"))
71 if (p->fstype && fstype_is_network(p->fstype))
77 static bool mount_is_bind(MountParameters *p) {
80 if (mount_test_option(p->options, "bind"))
83 if (p->fstype && streq(p->fstype, "bind"))
86 if (mount_test_option(p->options, "rbind"))
89 if (p->fstype && streq(p->fstype, "rbind"))
95 static bool mount_is_auto(MountParameters *p) {
98 return !mount_test_option(p->options, "noauto");
101 static bool needs_quota(MountParameters *p) {
104 if (mount_is_network(p))
107 if (mount_is_bind(p))
110 return mount_test_option(p->options, "usrquota") ||
111 mount_test_option(p->options, "grpquota") ||
112 mount_test_option(p->options, "quota") ||
113 mount_test_option(p->options, "usrjquota") ||
114 mount_test_option(p->options, "grpjquota");
117 static void mount_init(Unit *u) {
121 assert(u->load_state == UNIT_STUB);
123 m->timeout_usec = u->manager->default_timeout_start_usec;
124 m->directory_mode = 0755;
126 if (unit_has_name(u, "-.mount")) {
127 /* Don't allow start/stop for root directory */
128 u->refuse_manual_start = true;
129 u->refuse_manual_stop = true;
131 /* The stdio/kmsg bridge socket is on /, in order to avoid a
132 * dep loop, don't use kmsg logging for -.mount */
133 m->exec_context.std_output = u->manager->default_std_output;
134 m->exec_context.std_error = u->manager->default_std_error;
137 /* We need to make sure that /bin/mount is always called in
138 * the same process group as us, so that the autofs kernel
139 * side doesn't send us another mount request while we are
140 * already trying to comply its last one. */
141 m->exec_context.same_pgrp = true;
143 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
145 u->ignore_on_isolate = true;
148 static int mount_arm_timer(Mount *m) {
153 if (m->timeout_usec <= 0) {
154 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
158 if (m->timer_event_source) {
159 r = sd_event_source_set_time(m->timer_event_source, now(CLOCK_MONOTONIC) + m->timeout_usec);
163 return sd_event_source_set_enabled(m->timer_event_source, SD_EVENT_ONESHOT);
166 return sd_event_add_time(
167 UNIT(m)->manager->event,
168 &m->timer_event_source,
170 now(CLOCK_MONOTONIC) + m->timeout_usec, 0,
171 mount_dispatch_timer, m);
174 static void mount_unwatch_control_pid(Mount *m) {
177 if (m->control_pid <= 0)
180 unit_unwatch_pid(UNIT(m), m->control_pid);
184 static void mount_parameters_done(MountParameters *p) {
191 p->what = p->options = p->fstype = NULL;
194 static void mount_done(Unit *u) {
202 mount_parameters_done(&m->parameters_proc_self_mountinfo);
203 mount_parameters_done(&m->parameters_fragment);
205 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
206 exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
207 m->control_command = NULL;
209 mount_unwatch_control_pid(m);
211 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
214 _pure_ static MountParameters* get_mount_parameters_fragment(Mount *m) {
217 if (m->from_fragment)
218 return &m->parameters_fragment;
223 _pure_ static MountParameters* get_mount_parameters(Mount *m) {
226 if (m->from_proc_self_mountinfo)
227 return &m->parameters_proc_self_mountinfo;
229 return get_mount_parameters_fragment(m);
232 static int mount_add_mount_links(Mount *m) {
233 _cleanup_free_ char *parent = NULL;
242 if (!path_equal(m->where, "/")) {
243 /* Adds in links to other mount points that might lie further
244 * up in the hierarchy */
245 r = path_get_parent(m->where, &parent);
249 r = unit_require_mounts_for(UNIT(m), parent);
254 /* Adds in links to other mount points that might be needed
255 * for the source path (if this is a bind mount) to be
257 pm = get_mount_parameters_fragment(m);
258 if (pm && pm->what &&
259 path_is_absolute(pm->what) &&
260 !mount_is_network(pm)) {
262 r = unit_require_mounts_for(UNIT(m), pm->what);
267 /* Adds in links to other units that use this path or paths
268 * further down in the hierarchy */
269 s = manager_get_units_requiring_mounts_for(UNIT(m)->manager, m->where);
270 SET_FOREACH(other, s, i) {
272 if (other->load_state != UNIT_LOADED)
275 if (other == UNIT(m))
278 r = unit_add_dependency(other, UNIT_AFTER, UNIT(m), true);
282 if (UNIT(m)->fragment_path) {
283 /* If we have fragment configuration, then make this dependency required */
284 r = unit_add_dependency(other, UNIT_REQUIRES, UNIT(m), true);
293 static int mount_add_device_links(Mount *m) {
295 bool device_wants_mount = false;
300 p = get_mount_parameters_fragment(m);
307 if (mount_is_bind(p))
310 if (!is_device_path(p->what))
313 if (path_equal(m->where, "/"))
316 if (mount_is_auto(p) && UNIT(m)->manager->running_as == SYSTEMD_SYSTEM)
317 device_wants_mount = true;
319 r = unit_add_node_link(UNIT(m), p->what, device_wants_mount);
326 static int mount_add_quota_links(Mount *m) {
332 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
335 p = get_mount_parameters_fragment(m);
342 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true);
346 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true);
353 static bool should_umount(Mount *m) {
356 if (path_equal(m->where, "/") ||
357 path_equal(m->where, "/usr"))
360 p = get_mount_parameters(m);
361 if (p && mount_test_option(p->options, "x-initrd.mount") &&
368 static int mount_add_default_dependencies(Mount *m) {
369 const char *after, *after2, *online;
375 if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
378 p = get_mount_parameters(m);
383 if (path_equal(m->where, "/"))
386 if (mount_is_network(p)) {
387 after = SPECIAL_REMOTE_FS_PRE_TARGET;
388 after2 = SPECIAL_NETWORK_TARGET;
389 online = SPECIAL_NETWORK_ONLINE_TARGET;
391 after = SPECIAL_LOCAL_FS_PRE_TARGET;
396 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true);
401 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after2, NULL, true);
407 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_WANTS, UNIT_AFTER, online, NULL, true);
412 if (should_umount(m)) {
413 r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
421 static int mount_verify(Mount *m) {
422 _cleanup_free_ char *e = NULL;
427 if (UNIT(m)->load_state != UNIT_LOADED)
430 if (!m->from_fragment && !m->from_proc_self_mountinfo)
433 e = unit_name_from_path(m->where, ".mount");
437 b = unit_has_name(UNIT(m), e);
439 log_error_unit(UNIT(m)->id, "%s's Where= setting doesn't match unit name. Refusing.", UNIT(m)->id);
443 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
444 log_error_unit(UNIT(m)->id, "Cannot create mount unit for API file system %s. Refusing.", m->where);
448 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
449 log_error_unit(UNIT(m)->id, "%s's What setting is missing. Refusing.", UNIT(m)->id);
453 if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
454 log_error_unit(UNIT(m)->id, "%s has PAM enabled. Kill mode must be set to control-group'. Refusing.",UNIT(m)->id);
461 static int mount_add_extras(Mount *m) {
467 if (u->fragment_path)
468 m->from_fragment = true;
471 m->where = unit_name_to_path(u->id);
476 path_kill_slashes(m->where);
478 if (!u->description) {
479 r = unit_set_description(u, m->where);
484 r = mount_add_device_links(m);
488 r = mount_add_mount_links(m);
492 r = mount_add_quota_links(m);
496 r = unit_patch_contexts(u);
500 r = unit_add_exec_dependencies(u, &m->exec_context);
504 r = unit_add_default_slice(u, &m->cgroup_context);
508 if (u->default_dependencies) {
509 r = mount_add_default_dependencies(m);
517 static int mount_load(Unit *u) {
522 assert(u->load_state == UNIT_STUB);
524 if (m->from_proc_self_mountinfo)
525 r = unit_load_fragment_and_dropin_optional(u);
527 r = unit_load_fragment_and_dropin(u);
532 /* This is a new unit? Then let's add in some extras */
533 if (u->load_state == UNIT_LOADED) {
534 r = mount_add_extras(m);
539 return mount_verify(m);
542 static int mount_notify_automount(Mount *m, int status) {
549 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
550 if (p->type == UNIT_AUTOMOUNT) {
551 r = automount_send_ready(AUTOMOUNT(p), status);
559 static void mount_set_state(Mount *m, MountState state) {
560 MountState old_state;
563 old_state = m->state;
566 if (state != MOUNT_MOUNTING &&
567 state != MOUNT_MOUNTING_DONE &&
568 state != MOUNT_REMOUNTING &&
569 state != MOUNT_UNMOUNTING &&
570 state != MOUNT_MOUNTING_SIGTERM &&
571 state != MOUNT_MOUNTING_SIGKILL &&
572 state != MOUNT_UNMOUNTING_SIGTERM &&
573 state != MOUNT_UNMOUNTING_SIGKILL &&
574 state != MOUNT_REMOUNTING_SIGTERM &&
575 state != MOUNT_REMOUNTING_SIGKILL) {
576 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
577 mount_unwatch_control_pid(m);
578 m->control_command = NULL;
579 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
582 if (state == MOUNT_MOUNTED ||
583 state == MOUNT_REMOUNTING)
584 mount_notify_automount(m, 0);
585 else if (state == MOUNT_DEAD ||
586 state == MOUNT_UNMOUNTING ||
587 state == MOUNT_MOUNTING_SIGTERM ||
588 state == MOUNT_MOUNTING_SIGKILL ||
589 state == MOUNT_REMOUNTING_SIGTERM ||
590 state == MOUNT_REMOUNTING_SIGKILL ||
591 state == MOUNT_UNMOUNTING_SIGTERM ||
592 state == MOUNT_UNMOUNTING_SIGKILL ||
593 state == MOUNT_FAILED) {
594 if (state != old_state)
595 mount_notify_automount(m, -ENODEV);
598 if (state != old_state)
599 log_debug_unit(UNIT(m)->id,
600 "%s changed %s -> %s",
602 mount_state_to_string(old_state),
603 mount_state_to_string(state));
605 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
606 m->reload_result = MOUNT_SUCCESS;
609 static int mount_coldplug(Unit *u) {
611 MountState new_state = MOUNT_DEAD;
615 assert(m->state == MOUNT_DEAD);
617 if (m->deserialized_state != m->state)
618 new_state = m->deserialized_state;
619 else if (m->from_proc_self_mountinfo)
620 new_state = MOUNT_MOUNTED;
622 if (new_state == m->state)
625 if (new_state == MOUNT_MOUNTING ||
626 new_state == MOUNT_MOUNTING_DONE ||
627 new_state == MOUNT_REMOUNTING ||
628 new_state == MOUNT_UNMOUNTING ||
629 new_state == MOUNT_MOUNTING_SIGTERM ||
630 new_state == MOUNT_MOUNTING_SIGKILL ||
631 new_state == MOUNT_UNMOUNTING_SIGTERM ||
632 new_state == MOUNT_UNMOUNTING_SIGKILL ||
633 new_state == MOUNT_REMOUNTING_SIGTERM ||
634 new_state == MOUNT_REMOUNTING_SIGKILL) {
636 if (m->control_pid <= 0)
639 r = unit_watch_pid(UNIT(m), m->control_pid);
643 r = mount_arm_timer(m);
648 mount_set_state(m, new_state);
652 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
659 p = get_mount_parameters(m);
662 "%sMount State: %s\n"
666 "%sFile System Type: %s\n"
668 "%sFrom /proc/self/mountinfo: %s\n"
669 "%sFrom fragment: %s\n"
670 "%sDirectoryMode: %04o\n",
671 prefix, mount_state_to_string(m->state),
672 prefix, mount_result_to_string(m->result),
674 prefix, p ? strna(p->what) : "n/a",
675 prefix, p ? strna(p->fstype) : "n/a",
676 prefix, p ? strna(p->options) : "n/a",
677 prefix, yes_no(m->from_proc_self_mountinfo),
678 prefix, yes_no(m->from_fragment),
679 prefix, m->directory_mode);
681 if (m->control_pid > 0)
683 "%sControl PID: "PID_FMT"\n",
684 prefix, m->control_pid);
686 exec_context_dump(&m->exec_context, f, prefix);
687 kill_context_dump(&m->kill_context, f, prefix);
690 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
698 unit_realize_cgroup(UNIT(m));
700 r = unit_setup_exec_runtime(UNIT(m));
704 r = mount_arm_timer(m);
712 UNIT(m)->manager->environment,
716 UNIT(m)->manager->confirm_spawn,
717 UNIT(m)->manager->cgroup_supported,
718 UNIT(m)->cgroup_path,
719 manager_get_runtime_prefix(UNIT(m)->manager),
728 r = unit_watch_pid(UNIT(m), pid);
730 /* FIXME: we need to do something here */
738 m->timer_event_source = sd_event_source_unref(m->timer_event_source);
743 static void mount_enter_dead(Mount *m, MountResult f) {
746 if (f != MOUNT_SUCCESS)
749 exec_runtime_destroy(m->exec_runtime);
750 m->exec_runtime = exec_runtime_unref(m->exec_runtime);
752 exec_context_destroy_runtime_directory(&m->exec_context, manager_get_runtime_prefix(UNIT(m)->manager));
754 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
757 static void mount_enter_mounted(Mount *m, MountResult f) {
760 if (f != MOUNT_SUCCESS)
763 mount_set_state(m, MOUNT_MOUNTED);
766 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
771 if (f != MOUNT_SUCCESS)
774 r = unit_kill_context(
777 state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM,
785 r = mount_arm_timer(m);
789 mount_set_state(m, state);
790 } else if (state == MOUNT_REMOUNTING_SIGTERM)
791 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
792 else if (state == MOUNT_REMOUNTING_SIGKILL)
793 mount_enter_mounted(m, MOUNT_SUCCESS);
794 else if (state == MOUNT_MOUNTING_SIGTERM)
795 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_SUCCESS);
796 else if (state == MOUNT_UNMOUNTING_SIGTERM)
797 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
799 mount_enter_dead(m, MOUNT_SUCCESS);
804 log_warning_unit(UNIT(m)->id,
805 "%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
807 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
808 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
810 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
813 void warn_if_dir_nonempty(const char *unit, const char* where) {
817 if (dir_is_empty(where) > 0)
820 log_struct_unit(LOG_NOTICE,
822 "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
825 MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
829 static void mount_enter_unmounting(Mount *m) {
834 m->control_command_id = MOUNT_EXEC_UNMOUNT;
835 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
837 if ((r = exec_command_set(
845 mount_unwatch_control_pid(m);
847 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
850 mount_set_state(m, MOUNT_UNMOUNTING);
855 log_warning_unit(UNIT(m)->id,
856 "%s failed to run 'umount' task: %s",
857 UNIT(m)->id, strerror(-r));
858 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
861 static void mount_enter_mounting(Mount *m) {
867 m->control_command_id = MOUNT_EXEC_MOUNT;
868 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
870 mkdir_p_label(m->where, m->directory_mode);
872 warn_if_dir_nonempty(m->meta.id, m->where);
874 /* Create the source directory for bind-mounts if needed */
875 p = get_mount_parameters_fragment(m);
876 if (p && mount_is_bind(p))
877 mkdir_p_label(p->what, m->directory_mode);
879 if (m->from_fragment)
880 r = exec_command_set(
883 m->sloppy_options ? "-ns" : "-n",
884 m->parameters_fragment.what,
886 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
887 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
895 mount_unwatch_control_pid(m);
897 r = mount_spawn(m, m->control_command, &m->control_pid);
901 mount_set_state(m, MOUNT_MOUNTING);
906 log_warning_unit(UNIT(m)->id,
907 "%s failed to run 'mount' task: %s",
908 UNIT(m)->id, strerror(-r));
909 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
912 static void mount_enter_remounting(Mount *m) {
917 m->control_command_id = MOUNT_EXEC_REMOUNT;
918 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
920 if (m->from_fragment) {
923 if (m->parameters_fragment.options)
924 o = strappenda("remount,", m->parameters_fragment.options);
928 r = exec_command_set(
931 m->sloppy_options ? "-ns" : "-n",
932 m->parameters_fragment.what,
934 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
943 mount_unwatch_control_pid(m);
945 r = mount_spawn(m, m->control_command, &m->control_pid);
949 mount_set_state(m, MOUNT_REMOUNTING);
954 log_warning_unit(UNIT(m)->id,
955 "%s failed to run 'remount' task: %s",
956 UNIT(m)->id, strerror(-r));
957 m->reload_result = MOUNT_FAILURE_RESOURCES;
958 mount_enter_mounted(m, MOUNT_SUCCESS);
961 static int mount_start(Unit *u) {
966 /* We cannot fulfill this request right now, try again later
968 if (m->state == MOUNT_UNMOUNTING ||
969 m->state == MOUNT_UNMOUNTING_SIGTERM ||
970 m->state == MOUNT_UNMOUNTING_SIGKILL ||
971 m->state == MOUNT_MOUNTING_SIGTERM ||
972 m->state == MOUNT_MOUNTING_SIGKILL)
976 if (m->state == MOUNT_MOUNTING)
979 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
981 m->result = MOUNT_SUCCESS;
982 m->reload_result = MOUNT_SUCCESS;
984 mount_enter_mounting(m);
988 static int mount_stop(Unit *u) {
994 if (m->state == MOUNT_UNMOUNTING ||
995 m->state == MOUNT_UNMOUNTING_SIGKILL ||
996 m->state == MOUNT_UNMOUNTING_SIGTERM ||
997 m->state == MOUNT_MOUNTING_SIGTERM ||
998 m->state == MOUNT_MOUNTING_SIGKILL)
1001 assert(m->state == MOUNT_MOUNTING ||
1002 m->state == MOUNT_MOUNTING_DONE ||
1003 m->state == MOUNT_MOUNTED ||
1004 m->state == MOUNT_REMOUNTING ||
1005 m->state == MOUNT_REMOUNTING_SIGTERM ||
1006 m->state == MOUNT_REMOUNTING_SIGKILL);
1008 mount_enter_unmounting(m);
1012 static int mount_reload(Unit *u) {
1013 Mount *m = MOUNT(u);
1017 if (m->state == MOUNT_MOUNTING_DONE)
1020 assert(m->state == MOUNT_MOUNTED);
1022 mount_enter_remounting(m);
1026 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1027 Mount *m = MOUNT(u);
1033 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1034 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1035 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1037 if (m->control_pid > 0)
1038 unit_serialize_item_format(u, f, "control-pid", PID_FMT, m->control_pid);
1040 if (m->control_command_id >= 0)
1041 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1046 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1047 Mount *m = MOUNT(u);
1054 if (streq(key, "state")) {
1057 if ((state = mount_state_from_string(value)) < 0)
1058 log_debug_unit(u->id, "Failed to parse state value %s", value);
1060 m->deserialized_state = state;
1061 } else if (streq(key, "result")) {
1064 f = mount_result_from_string(value);
1066 log_debug_unit(UNIT(m)->id,
1067 "Failed to parse result value %s", value);
1068 else if (f != MOUNT_SUCCESS)
1071 } else if (streq(key, "reload-result")) {
1074 f = mount_result_from_string(value);
1076 log_debug_unit(UNIT(m)->id,
1077 "Failed to parse reload result value %s", value);
1078 else if (f != MOUNT_SUCCESS)
1079 m->reload_result = f;
1081 } else if (streq(key, "control-pid")) {
1084 if (parse_pid(value, &pid) < 0)
1085 log_debug_unit(UNIT(m)->id,
1086 "Failed to parse control-pid value %s", value);
1088 m->control_pid = pid;
1089 } else if (streq(key, "control-command")) {
1090 MountExecCommand id;
1092 if ((id = mount_exec_command_from_string(value)) < 0)
1093 log_debug_unit(UNIT(m)->id,
1094 "Failed to parse exec-command value %s", value);
1096 m->control_command_id = id;
1097 m->control_command = m->exec_command + id;
1100 log_debug_unit(UNIT(m)->id,
1101 "Unknown serialization key '%s'", key);
1106 _pure_ static UnitActiveState mount_active_state(Unit *u) {
1109 return state_translation_table[MOUNT(u)->state];
1112 _pure_ static const char *mount_sub_state_to_string(Unit *u) {
1115 return mount_state_to_string(MOUNT(u)->state);
1118 _pure_ static bool mount_check_gc(Unit *u) {
1119 Mount *m = MOUNT(u);
1123 return m->from_proc_self_mountinfo;
1126 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1127 Mount *m = MOUNT(u);
1133 if (pid != m->control_pid)
1138 if (is_clean_exit(code, status, NULL))
1140 else if (code == CLD_EXITED)
1141 f = MOUNT_FAILURE_EXIT_CODE;
1142 else if (code == CLD_KILLED)
1143 f = MOUNT_FAILURE_SIGNAL;
1144 else if (code == CLD_DUMPED)
1145 f = MOUNT_FAILURE_CORE_DUMP;
1147 assert_not_reached("Unknown code");
1149 if (f != MOUNT_SUCCESS)
1152 if (m->control_command) {
1153 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1155 m->control_command = NULL;
1156 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1159 log_full_unit(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
1160 "%s mount process exited, code=%s status=%i",
1161 u->id, sigchld_code_to_string(code), status);
1163 /* Note that mount(8) returning and the kernel sending us a
1164 * mount table change event might happen out-of-order. If an
1165 * operation succeed we assume the kernel will follow soon too
1166 * and already change into the resulting state. If it fails
1167 * we check if the kernel still knows about the mount. and
1168 * change state accordingly. */
1172 case MOUNT_MOUNTING:
1173 case MOUNT_MOUNTING_DONE:
1174 case MOUNT_MOUNTING_SIGKILL:
1175 case MOUNT_MOUNTING_SIGTERM:
1177 if (f == MOUNT_SUCCESS)
1178 mount_enter_mounted(m, f);
1179 else if (m->from_proc_self_mountinfo)
1180 mount_enter_mounted(m, f);
1182 mount_enter_dead(m, f);
1185 case MOUNT_REMOUNTING:
1186 case MOUNT_REMOUNTING_SIGKILL:
1187 case MOUNT_REMOUNTING_SIGTERM:
1189 m->reload_result = f;
1190 if (m->from_proc_self_mountinfo)
1191 mount_enter_mounted(m, MOUNT_SUCCESS);
1193 mount_enter_dead(m, MOUNT_SUCCESS);
1197 case MOUNT_UNMOUNTING:
1198 case MOUNT_UNMOUNTING_SIGKILL:
1199 case MOUNT_UNMOUNTING_SIGTERM:
1201 if (f == MOUNT_SUCCESS)
1202 mount_enter_dead(m, f);
1203 else if (m->from_proc_self_mountinfo)
1204 mount_enter_mounted(m, f);
1206 mount_enter_dead(m, f);
1210 assert_not_reached("Uh, control process died at wrong time.");
1213 /* Notify clients about changed exit status */
1214 unit_add_to_dbus_queue(u);
1217 static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
1218 Mount *m = MOUNT(userdata);
1221 assert(m->timer_event_source == source);
1225 case MOUNT_MOUNTING:
1226 case MOUNT_MOUNTING_DONE:
1227 log_warning_unit(UNIT(m)->id,
1228 "%s mounting timed out. Stopping.", UNIT(m)->id);
1229 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1232 case MOUNT_REMOUNTING:
1233 log_warning_unit(UNIT(m)->id,
1234 "%s remounting timed out. Stopping.", UNIT(m)->id);
1235 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1236 mount_enter_mounted(m, MOUNT_SUCCESS);
1239 case MOUNT_UNMOUNTING:
1240 log_warning_unit(UNIT(m)->id,
1241 "%s unmounting timed out. Stopping.", UNIT(m)->id);
1242 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1245 case MOUNT_MOUNTING_SIGTERM:
1246 if (m->kill_context.send_sigkill) {
1247 log_warning_unit(UNIT(m)->id,
1248 "%s mounting timed out. Killing.", UNIT(m)->id);
1249 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1251 log_warning_unit(UNIT(m)->id,
1252 "%s mounting timed out. Skipping SIGKILL. Ignoring.",
1255 if (m->from_proc_self_mountinfo)
1256 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1258 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1262 case MOUNT_REMOUNTING_SIGTERM:
1263 if (m->kill_context.send_sigkill) {
1264 log_warning_unit(UNIT(m)->id,
1265 "%s remounting timed out. Killing.", UNIT(m)->id);
1266 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1268 log_warning_unit(UNIT(m)->id,
1269 "%s remounting timed out. Skipping SIGKILL. Ignoring.",
1272 if (m->from_proc_self_mountinfo)
1273 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1275 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1279 case MOUNT_UNMOUNTING_SIGTERM:
1280 if (m->kill_context.send_sigkill) {
1281 log_warning_unit(UNIT(m)->id,
1282 "%s unmounting timed out. Killing.", UNIT(m)->id);
1283 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1285 log_warning_unit(UNIT(m)->id,
1286 "%s unmounting timed out. Skipping SIGKILL. Ignoring.",
1289 if (m->from_proc_self_mountinfo)
1290 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1292 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1296 case MOUNT_MOUNTING_SIGKILL:
1297 case MOUNT_REMOUNTING_SIGKILL:
1298 case MOUNT_UNMOUNTING_SIGKILL:
1299 log_warning_unit(UNIT(m)->id,
1300 "%s mount process still around after SIGKILL. Ignoring.",
1303 if (m->from_proc_self_mountinfo)
1304 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1306 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1310 assert_not_reached("Timeout at wrong time.");
1316 static int mount_add_one(
1320 const char *options,
1324 _cleanup_free_ char *e = NULL, *w = NULL, *o = NULL, *f = NULL;
1325 bool load_extras = false;
1327 bool delete, changed = false;
1337 /* Ignore API mount points. They should never be referenced in
1338 * dependencies ever. */
1339 if (mount_point_is_api(where) || mount_point_ignore(where))
1342 if (streq(fstype, "autofs"))
1345 /* probably some kind of swap, ignore */
1346 if (!is_path(where))
1349 e = unit_name_from_path(where, ".mount");
1353 u = manager_get_unit(m, e);
1357 u = unit_new(m, sizeof(Mount));
1361 r = unit_add_name(u, e);
1365 MOUNT(u)->where = strdup(where);
1366 if (!MOUNT(u)->where) {
1371 u->source_path = strdup("/proc/self/mountinfo");
1372 if (!u->source_path) {
1378 if (m->running_as == SYSTEMD_SYSTEM) {
1381 target = fstype_is_network(fstype) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
1383 r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true);
1387 if (should_umount(MOUNT(u))) {
1388 r = unit_add_dependency_by_name(u, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true);
1394 unit_add_to_load_queue(u);
1399 if (!MOUNT(u)->where) {
1400 MOUNT(u)->where = strdup(where);
1401 if (!MOUNT(u)->where) {
1407 if (u->load_state == UNIT_NOT_FOUND) {
1408 u->load_state = UNIT_LOADED;
1411 /* Load in the extras later on, after we
1412 * finished initialization of the unit */
1419 o = strdup(options);
1421 if (!w || !o || !f) {
1426 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1428 changed = changed ||
1429 !streq_ptr(p->options, options) ||
1430 !streq_ptr(p->what, what) ||
1431 !streq_ptr(p->fstype, fstype);
1434 MOUNT(u)->is_mounted = true;
1435 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1436 MOUNT(u)->just_changed = changed;
1439 MOUNT(u)->from_proc_self_mountinfo = true;
1454 r = mount_add_extras(MOUNT(u));
1460 unit_add_to_dbus_queue(u);
1471 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1477 rewind(m->proc_self_mountinfo);
1480 _cleanup_free_ char *device = NULL, *path = NULL, *options = NULL, *options2 = NULL, *fstype = NULL, *d = NULL, *p = NULL, *o = NULL;
1483 k = fscanf(m->proc_self_mountinfo,
1484 "%*s " /* (1) mount id */
1485 "%*s " /* (2) parent id */
1486 "%*s " /* (3) major:minor */
1487 "%*s " /* (4) root */
1488 "%ms " /* (5) mount point */
1489 "%ms" /* (6) mount options */
1490 "%*[^-]" /* (7) optional fields */
1491 "- " /* (8) separator */
1492 "%ms " /* (9) file system type */
1493 "%ms" /* (10) mount source */
1494 "%ms" /* (11) mount options 2 */
1495 "%*[^\n]", /* some rubbish at the end */
1506 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1510 o = strjoin(options, ",", options2, NULL);
1514 d = cunescape(device);
1515 p = cunescape(path);
1519 k = mount_add_one(m, d, p, o, fstype, set_flags);
1527 static void mount_shutdown(Manager *m) {
1530 m->mount_event_source = sd_event_source_unref(m->mount_event_source);
1532 if (m->proc_self_mountinfo) {
1533 fclose(m->proc_self_mountinfo);
1534 m->proc_self_mountinfo = NULL;
1538 static int mount_get_timeout(Unit *u, uint64_t *timeout) {
1539 Mount *m = MOUNT(u);
1542 if (!m->timer_event_source)
1545 r = sd_event_source_get_time(m->timer_event_source, timeout);
1552 static int mount_enumerate(Manager *m) {
1556 if (!m->proc_self_mountinfo) {
1557 m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
1558 if (!m->proc_self_mountinfo)
1561 r = sd_event_add_io(m->event, &m->mount_event_source, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m);
1565 /* Dispatch this before we dispatch SIGCHLD, so that
1566 * we always get the events from /proc/self/mountinfo
1567 * before the SIGCHLD of /bin/mount. */
1568 r = sd_event_source_set_priority(m->mount_event_source, -10);
1573 r = mount_load_proc_self_mountinfo(m, false);
1584 static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
1585 Manager *m = userdata;
1590 assert(revents & EPOLLPRI);
1592 /* The manager calls this for every fd event happening on the
1593 * /proc/self/mountinfo file, which informs us about mounting
1596 r = mount_load_proc_self_mountinfo(m, true);
1598 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1600 /* Reset flags, just in case, for later calls */
1601 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1602 Mount *mount = MOUNT(u);
1604 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1610 manager_dispatch_load_queue(m);
1612 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1613 Mount *mount = MOUNT(u);
1615 if (!mount->is_mounted) {
1617 mount->from_proc_self_mountinfo = false;
1619 switch (mount->state) {
1622 /* This has just been unmounted by
1623 * somebody else, follow the state
1625 mount_enter_dead(mount, MOUNT_SUCCESS);
1632 } else if (mount->just_mounted || mount->just_changed) {
1634 /* New or changed mount entry */
1636 switch (mount->state) {
1640 /* This has just been mounted by
1641 * somebody else, follow the state
1643 mount_enter_mounted(mount, MOUNT_SUCCESS);
1646 case MOUNT_MOUNTING:
1647 mount_set_state(mount, MOUNT_MOUNTING_DONE);
1651 /* Nothing really changed, but let's
1652 * issue an notification call
1653 * nonetheless, in case somebody is
1654 * waiting for this. (e.g. file system
1655 * ro/rw remounts.) */
1656 mount_set_state(mount, mount->state);
1661 /* Reset the flags for later calls */
1662 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1668 static void mount_reset_failed(Unit *u) {
1669 Mount *m = MOUNT(u);
1673 if (m->state == MOUNT_FAILED)
1674 mount_set_state(m, MOUNT_DEAD);
1676 m->result = MOUNT_SUCCESS;
1677 m->reload_result = MOUNT_SUCCESS;
1680 static int mount_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
1681 return unit_kill_common(u, who, signo, -1, MOUNT(u)->control_pid, error);
1684 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1685 [MOUNT_DEAD] = "dead",
1686 [MOUNT_MOUNTING] = "mounting",
1687 [MOUNT_MOUNTING_DONE] = "mounting-done",
1688 [MOUNT_MOUNTED] = "mounted",
1689 [MOUNT_REMOUNTING] = "remounting",
1690 [MOUNT_UNMOUNTING] = "unmounting",
1691 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1692 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1693 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1694 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1695 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1696 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1697 [MOUNT_FAILED] = "failed"
1700 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1702 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1703 [MOUNT_EXEC_MOUNT] = "ExecMount",
1704 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1705 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1708 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1710 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1711 [MOUNT_SUCCESS] = "success",
1712 [MOUNT_FAILURE_RESOURCES] = "resources",
1713 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1714 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1715 [MOUNT_FAILURE_SIGNAL] = "signal",
1716 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1719 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1721 const UnitVTable mount_vtable = {
1722 .object_size = sizeof(Mount),
1723 .exec_context_offset = offsetof(Mount, exec_context),
1724 .cgroup_context_offset = offsetof(Mount, cgroup_context),
1725 .kill_context_offset = offsetof(Mount, kill_context),
1726 .exec_runtime_offset = offsetof(Mount, exec_runtime),
1732 .private_section = "Mount",
1735 .no_instances = true,
1741 .coldplug = mount_coldplug,
1745 .start = mount_start,
1747 .reload = mount_reload,
1751 .serialize = mount_serialize,
1752 .deserialize_item = mount_deserialize_item,
1754 .active_state = mount_active_state,
1755 .sub_state_to_string = mount_sub_state_to_string,
1757 .check_gc = mount_check_gc,
1759 .sigchld_event = mount_sigchld_event,
1761 .reset_failed = mount_reset_failed,
1763 .bus_interface = "org.freedesktop.systemd1.Mount",
1764 .bus_vtable = bus_mount_vtable,
1765 .bus_set_property = bus_mount_set_property,
1766 .bus_commit_properties = bus_mount_commit_properties,
1768 .get_timeout = mount_get_timeout,
1770 .can_transient = true,
1772 .enumerate = mount_enumerate,
1773 .shutdown = mount_shutdown,
1775 .status_message_formats = {
1776 .starting_stopping = {
1777 [0] = "Mounting %s...",
1778 [1] = "Unmounting %s...",
1780 .finished_start_job = {
1781 [JOB_DONE] = "Mounted %s.",
1782 [JOB_FAILED] = "Failed to mount %s.",
1783 [JOB_DEPENDENCY] = "Dependency failed for %s.",
1784 [JOB_TIMEOUT] = "Timed out mounting %s.",
1786 .finished_stop_job = {
1787 [JOB_DONE] = "Unmounted %s.",
1788 [JOB_FAILED] = "Failed unmounting %s.",
1789 [JOB_TIMEOUT] = "Timed out unmounting %s.",