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 /* The stdio/kmsg bridge socket is on /, in order to avoid a
72 * dep loop, don't use kmsg logging for -.mount */
73 if (!unit_has_name(u, "-.mount")) {
74 m->exec_context.std_output = u->manager->default_std_output;
75 m->exec_context.std_error = u->manager->default_std_error;
78 /* We need to make sure that /bin/mount is always called in
79 * the same process group as us, so that the autofs kernel
80 * side doesn't send us another mount request while we are
81 * already trying to comply its last one. */
82 m->exec_context.same_pgrp = true;
84 m->timer_watch.type = WATCH_INVALID;
86 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
88 UNIT(m)->ignore_on_isolate = true;
91 static void mount_unwatch_control_pid(Mount *m) {
94 if (m->control_pid <= 0)
97 unit_unwatch_pid(UNIT(m), m->control_pid);
101 static void mount_parameters_done(MountParameters *p) {
108 p->what = p->options = p->fstype = NULL;
111 static void mount_done(Unit *u) {
119 mount_parameters_done(&m->parameters_etc_fstab);
120 mount_parameters_done(&m->parameters_proc_self_mountinfo);
121 mount_parameters_done(&m->parameters_fragment);
123 exec_context_done(&m->exec_context);
124 exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
125 m->control_command = NULL;
127 mount_unwatch_control_pid(m);
129 unit_unwatch_timer(u, &m->timer_watch);
132 static MountParameters* get_mount_parameters_configured(Mount *m) {
135 if (m->from_fragment)
136 return &m->parameters_fragment;
137 else if (m->from_etc_fstab)
138 return &m->parameters_etc_fstab;
143 static MountParameters* get_mount_parameters(Mount *m) {
146 if (m->from_proc_self_mountinfo)
147 return &m->parameters_proc_self_mountinfo;
149 return get_mount_parameters_configured(m);
152 static int mount_add_mount_links(Mount *m) {
159 pm = get_mount_parameters_configured(m);
161 /* Adds in links to other mount points that might lie below or
162 * above us in the hierarchy */
164 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_MOUNT]) {
165 Mount *n = MOUNT(other);
171 if (UNIT(n)->load_state != UNIT_LOADED)
174 pn = get_mount_parameters_configured(n);
176 if (path_startswith(m->where, n->where)) {
178 if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, UNIT(n), true)) < 0)
182 if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, UNIT(n), true)) < 0)
185 } else if (path_startswith(n->where, m->where)) {
187 if ((r = unit_add_dependency(UNIT(n), UNIT_AFTER, UNIT(m), true)) < 0)
191 if ((r = unit_add_dependency(UNIT(n), UNIT_REQUIRES, UNIT(m), true)) < 0)
194 } else if (pm && pm->what && path_startswith(pm->what, n->where)) {
196 if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, UNIT(n), true)) < 0)
199 if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, UNIT(n), true)) < 0)
202 } else if (pn && pn->what && path_startswith(pn->what, m->where)) {
204 if ((r = unit_add_dependency(UNIT(n), UNIT_AFTER, UNIT(m), true)) < 0)
207 if ((r = unit_add_dependency(UNIT(n), UNIT_REQUIRES, UNIT(m), true)) < 0)
215 static int mount_add_swap_links(Mount *m) {
221 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_SWAP])
222 if ((r = swap_add_one_mount_link(SWAP(other), m)) < 0)
228 static int mount_add_path_links(Mount *m) {
234 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_PATH])
235 if ((r = path_add_one_mount_link(PATH(other), m)) < 0)
241 static int mount_add_automount_links(Mount *m) {
247 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_AUTOMOUNT])
248 if ((r = automount_add_one_mount_link(AUTOMOUNT(other), m)) < 0)
254 static int mount_add_socket_links(Mount *m) {
260 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_SOCKET])
261 if ((r = socket_add_one_mount_link(SOCKET(other), m)) < 0)
267 static int mount_add_requires_mounts_links(Mount *m) {
273 LIST_FOREACH(has_requires_mounts_for, other, UNIT(m)->manager->has_requires_mounts_for) {
274 r = unit_add_one_mount_link(other, m);
282 static char* mount_test_option(const char *haystack, const char *needle) {
287 /* Like glibc's hasmntopt(), but works on a string, not a
294 me.mnt_opts = (char*) haystack;
296 return hasmntopt(&me, needle);
299 static bool mount_is_network(MountParameters *p) {
302 if (mount_test_option(p->options, "_netdev"))
305 if (p->fstype && fstype_is_network(p->fstype))
311 static bool mount_is_bind(MountParameters *p) {
314 if (mount_test_option(p->options, "bind"))
317 if (p->fstype && streq(p->fstype, "bind"))
323 static bool needs_quota(MountParameters *p) {
326 if (mount_is_network(p))
329 if (mount_is_bind(p))
332 return mount_test_option(p->options, "usrquota") ||
333 mount_test_option(p->options, "grpquota") ||
334 mount_test_option(p->options, "quota") ||
335 mount_test_option(p->options, "usrjquota") ||
336 mount_test_option(p->options, "grpjquota");
339 static int mount_add_fstab_links(Mount *m) {
340 const char *target, *after, *tu_wants = NULL;
344 bool noauto, nofail, automount;
348 if (UNIT(m)->manager->running_as != MANAGER_SYSTEM)
351 if (!(p = get_mount_parameters_configured(m)))
354 if (p != &m->parameters_etc_fstab)
357 noauto = !!mount_test_option(p->options, "noauto");
358 nofail = !!mount_test_option(p->options, "nofail");
360 mount_test_option(p->options, "comment=systemd.automount") ||
361 mount_test_option(p->options, "x-systemd-automount");
363 if (mount_is_network(p)) {
364 target = SPECIAL_REMOTE_FS_TARGET;
365 after = tu_wants = SPECIAL_REMOTE_FS_PRE_TARGET;
367 target = SPECIAL_LOCAL_FS_TARGET;
368 after = SPECIAL_LOCAL_FS_PRE_TARGET;
371 r = manager_load_unit(UNIT(m)->manager, target, NULL, NULL, &tu);
376 r = unit_add_dependency_by_name(tu, UNIT_WANTS, tu_wants, NULL, true);
382 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true);
390 if ((r = unit_load_related_unit(UNIT(m), ".automount", &am)) < 0)
393 /* If auto is configured as well also pull in the
394 * mount right-away, but don't rely on it. */
395 if (!noauto) /* automount + auto */
396 if ((r = unit_add_dependency(tu, UNIT_WANTS, UNIT(m), true)) < 0)
399 /* Install automount unit */
400 if (!nofail) /* automount + fail */
401 return unit_add_two_dependencies(tu, UNIT_AFTER, UNIT_REQUIRES, am, true);
402 else /* automount + nofail */
403 return unit_add_two_dependencies(tu, UNIT_AFTER, UNIT_WANTS, am, true);
405 } else if (!noauto) {
407 /* Automatically add mount points that aren't natively
408 * configured to local-fs.target */
410 if (!nofail) /* auto + fail */
411 return unit_add_two_dependencies(tu, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
412 else /* auto + nofail */
413 return unit_add_dependency(tu, UNIT_WANTS, UNIT(m), true);
419 static int mount_add_device_links(Mount *m) {
425 if (!(p = get_mount_parameters_configured(m)))
431 if (!mount_is_bind(p) &&
432 !path_equal(m->where, "/") &&
433 p == &m->parameters_etc_fstab) {
436 noauto = !!mount_test_option(p->options, "noauto");
437 nofail = !!mount_test_option(p->options, "nofail");
439 if ((r = unit_add_node_link(UNIT(m), p->what,
441 UNIT(m)->manager->running_as == MANAGER_SYSTEM)) < 0)
447 UNIT(m)->manager->running_as == MANAGER_SYSTEM &&
448 !path_equal(m->where, "/")) {
451 /* Let's add in the fsck service */
453 /* aka SPECIAL_FSCK_SERVICE */
454 if (!(name = unit_name_from_path_instance("fsck", p->what, ".service")))
457 if ((r = manager_load_unit_prepare(UNIT(m)->manager, name, NULL, NULL, &fsck)) < 0) {
458 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
465 SERVICE(fsck)->fsck_passno = p->passno;
467 if ((r = unit_add_two_dependencies(UNIT(m), UNIT_AFTER, UNIT_REQUIRES, fsck, true)) < 0)
474 static int mount_add_default_dependencies(Mount *m) {
480 if (UNIT(m)->manager->running_as != MANAGER_SYSTEM)
483 p = get_mount_parameters_configured(m);
484 if (p && needs_quota(p)) {
485 if ((r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true)) < 0 ||
486 (r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true)) < 0)
490 if (!path_equal(m->where, "/"))
491 if ((r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true)) < 0)
497 static int mount_fix_timeouts(Mount *m) {
499 const char *timeout = NULL;
508 if (!(p = get_mount_parameters_configured(m)))
511 /* Allow configuration how long we wait for a device that
512 * backs a mount point to show up. This is useful to support
513 * endless device timeouts for devices that show up only after
514 * user input, like crypto devices. */
516 if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
518 else if ((timeout = mount_test_option(p->options, "x-systemd-device-timeout")))
523 t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
527 r = parse_usec(t, &u);
531 log_warning("Failed to parse timeout for %s, ignoring: %s", m->where, timeout);
535 SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
536 if (other->type != UNIT_DEVICE)
539 other->job_timeout = u;
545 static int mount_verify(Mount *m) {
550 if (UNIT(m)->load_state != UNIT_LOADED)
553 if (!m->from_etc_fstab && !m->from_fragment && !m->from_proc_self_mountinfo)
556 if (!(e = unit_name_from_path(m->where, ".mount")))
559 b = unit_has_name(UNIT(m), e);
563 log_error("%s's Where setting doesn't match unit name. Refusing.", UNIT(m)->id);
567 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
568 log_error("Cannot create mount unit for API file system %s. Refusing.", m->where);
572 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
573 log_error("%s's What setting is missing. Refusing.", UNIT(m)->id);
577 if (m->exec_context.pam_name && m->exec_context.kill_mode != KILL_CONTROL_GROUP) {
578 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(m)->id);
585 static int mount_load(Unit *u) {
590 assert(u->load_state == UNIT_STUB);
592 if ((r = unit_load_fragment_and_dropin_optional(u)) < 0)
595 /* This is a new unit? Then let's add in some extras */
596 if (u->load_state == UNIT_LOADED) {
597 if ((r = unit_add_exec_dependencies(u, &m->exec_context)) < 0)
600 if (UNIT(m)->fragment_path)
601 m->from_fragment = true;
602 else if (m->from_etc_fstab)
603 /* We always add several default dependencies to fstab mounts,
604 * but we do not want the implicit complementing of Wants= with After=
605 * in the target unit that this mount unit will be hooked into. */
606 UNIT(m)->default_dependencies = false;
609 if (!(m->where = unit_name_to_path(u->id)))
612 path_kill_slashes(m->where);
614 if (!UNIT(m)->description)
615 if ((r = unit_set_description(u, m->where)) < 0)
618 if ((r = mount_add_device_links(m)) < 0)
621 if ((r = mount_add_mount_links(m)) < 0)
624 if ((r = mount_add_socket_links(m)) < 0)
627 if ((r = mount_add_swap_links(m)) < 0)
630 if ((r = mount_add_path_links(m)) < 0)
633 r = mount_add_requires_mounts_links(m);
637 if ((r = mount_add_automount_links(m)) < 0)
640 if ((r = mount_add_fstab_links(m)) < 0)
643 if (UNIT(m)->default_dependencies || m->from_etc_fstab)
644 if ((r = mount_add_default_dependencies(m)) < 0)
647 if ((r = unit_add_default_cgroups(u)) < 0)
650 mount_fix_timeouts(m);
653 return mount_verify(m);
656 static int mount_notify_automount(Mount *m, int status) {
663 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
664 if (p->type == UNIT_AUTOMOUNT) {
665 r = automount_send_ready(AUTOMOUNT(p), status);
673 static void mount_set_state(Mount *m, MountState state) {
674 MountState old_state;
677 old_state = m->state;
680 if (state != MOUNT_MOUNTING &&
681 state != MOUNT_MOUNTING_DONE &&
682 state != MOUNT_REMOUNTING &&
683 state != MOUNT_UNMOUNTING &&
684 state != MOUNT_MOUNTING_SIGTERM &&
685 state != MOUNT_MOUNTING_SIGKILL &&
686 state != MOUNT_UNMOUNTING_SIGTERM &&
687 state != MOUNT_UNMOUNTING_SIGKILL &&
688 state != MOUNT_REMOUNTING_SIGTERM &&
689 state != MOUNT_REMOUNTING_SIGKILL) {
690 unit_unwatch_timer(UNIT(m), &m->timer_watch);
691 mount_unwatch_control_pid(m);
692 m->control_command = NULL;
693 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
696 if (state == MOUNT_MOUNTED ||
697 state == MOUNT_REMOUNTING)
698 mount_notify_automount(m, 0);
699 else if (state == MOUNT_DEAD ||
700 state == MOUNT_UNMOUNTING ||
701 state == MOUNT_MOUNTING_SIGTERM ||
702 state == MOUNT_MOUNTING_SIGKILL ||
703 state == MOUNT_REMOUNTING_SIGTERM ||
704 state == MOUNT_REMOUNTING_SIGKILL ||
705 state == MOUNT_UNMOUNTING_SIGTERM ||
706 state == MOUNT_UNMOUNTING_SIGKILL ||
707 state == MOUNT_FAILED)
708 mount_notify_automount(m, -ENODEV);
710 if (state != old_state)
711 log_debug("%s changed %s -> %s",
713 mount_state_to_string(old_state),
714 mount_state_to_string(state));
716 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
717 m->reload_result = MOUNT_SUCCESS;
720 static int mount_coldplug(Unit *u) {
722 MountState new_state = MOUNT_DEAD;
726 assert(m->state == MOUNT_DEAD);
728 if (m->deserialized_state != m->state)
729 new_state = m->deserialized_state;
730 else if (m->from_proc_self_mountinfo)
731 new_state = MOUNT_MOUNTED;
733 if (new_state != m->state) {
735 if (new_state == MOUNT_MOUNTING ||
736 new_state == MOUNT_MOUNTING_DONE ||
737 new_state == MOUNT_REMOUNTING ||
738 new_state == MOUNT_UNMOUNTING ||
739 new_state == MOUNT_MOUNTING_SIGTERM ||
740 new_state == MOUNT_MOUNTING_SIGKILL ||
741 new_state == MOUNT_UNMOUNTING_SIGTERM ||
742 new_state == MOUNT_UNMOUNTING_SIGKILL ||
743 new_state == MOUNT_REMOUNTING_SIGTERM ||
744 new_state == MOUNT_REMOUNTING_SIGKILL) {
746 if (m->control_pid <= 0)
749 if ((r = unit_watch_pid(UNIT(m), m->control_pid)) < 0)
752 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
756 mount_set_state(m, new_state);
762 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
769 p = get_mount_parameters(m);
772 "%sMount State: %s\n"
776 "%sFile System Type: %s\n"
778 "%sFrom /etc/fstab: %s\n"
779 "%sFrom /proc/self/mountinfo: %s\n"
780 "%sFrom fragment: %s\n"
781 "%sDirectoryMode: %04o\n",
782 prefix, mount_state_to_string(m->state),
783 prefix, mount_result_to_string(m->result),
785 prefix, strna(p->what),
786 prefix, strna(p->fstype),
787 prefix, strna(p->options),
788 prefix, yes_no(m->from_etc_fstab),
789 prefix, yes_no(m->from_proc_self_mountinfo),
790 prefix, yes_no(m->from_fragment),
791 prefix, m->directory_mode);
793 if (m->control_pid > 0)
795 "%sControl PID: %lu\n",
796 prefix, (unsigned long) m->control_pid);
798 exec_context_dump(&m->exec_context, f, prefix);
801 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
809 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
812 if ((r = exec_spawn(c,
816 UNIT(m)->manager->environment,
820 UNIT(m)->manager->confirm_spawn,
821 UNIT(m)->cgroup_bondings,
822 UNIT(m)->cgroup_attributes,
828 if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
829 /* FIXME: we need to do something here */
837 unit_unwatch_timer(UNIT(m), &m->timer_watch);
842 static void mount_enter_dead(Mount *m, MountResult f) {
845 if (f != MOUNT_SUCCESS)
848 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
851 static void mount_enter_mounted(Mount *m, MountResult f) {
854 if (f != MOUNT_SUCCESS)
857 mount_set_state(m, MOUNT_MOUNTED);
860 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
863 bool wait_for_exit = false;
867 if (f != MOUNT_SUCCESS)
870 if (m->exec_context.kill_mode != KILL_NONE) {
871 int sig = (state == MOUNT_MOUNTING_SIGTERM ||
872 state == MOUNT_UNMOUNTING_SIGTERM ||
873 state == MOUNT_REMOUNTING_SIGTERM) ? m->exec_context.kill_signal : SIGKILL;
875 if (m->control_pid > 0) {
876 if (kill_and_sigcont(m->control_pid, sig) < 0 && errno != ESRCH)
878 log_warning("Failed to kill control process %li: %m", (long) m->control_pid);
880 wait_for_exit = true;
883 if (m->exec_context.kill_mode == KILL_CONTROL_GROUP) {
885 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
890 /* Exclude the control pid from being killed via the cgroup */
891 if (m->control_pid > 0)
892 if ((r = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0)
895 r = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, sig, true, false, pid_set, NULL);
897 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
898 log_warning("Failed to kill control group: %s", strerror(-r));
900 wait_for_exit = true;
908 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
911 mount_set_state(m, state);
912 } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
913 mount_enter_mounted(m, MOUNT_SUCCESS);
915 mount_enter_dead(m, MOUNT_SUCCESS);
920 log_warning("%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
922 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
923 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
925 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
931 static void mount_enter_unmounting(Mount *m) {
936 m->control_command_id = MOUNT_EXEC_UNMOUNT;
937 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
939 if ((r = exec_command_set(
946 mount_unwatch_control_pid(m);
948 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
951 mount_set_state(m, MOUNT_UNMOUNTING);
956 log_warning("%s failed to run 'umount' task: %s", UNIT(m)->id, strerror(-r));
957 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
960 static void mount_enter_mounting(Mount *m) {
966 m->control_command_id = MOUNT_EXEC_MOUNT;
967 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
969 mkdir_p(m->where, m->directory_mode);
971 /* Create the source directory for bind-mounts if needed */
972 p = get_mount_parameters_configured(m);
973 if (p && mount_is_bind(p))
974 mkdir_p(p->what, m->directory_mode);
976 if (m->from_fragment)
977 r = exec_command_set(
980 m->parameters_fragment.what,
982 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
983 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
985 else if (m->from_etc_fstab)
986 r = exec_command_set(
997 mount_unwatch_control_pid(m);
999 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1002 mount_set_state(m, MOUNT_MOUNTING);
1007 log_warning("%s failed to run 'mount' task: %s", UNIT(m)->id, strerror(-r));
1008 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
1011 static void mount_enter_mounting_done(Mount *m) {
1014 mount_set_state(m, MOUNT_MOUNTING_DONE);
1017 static void mount_enter_remounting(Mount *m) {
1022 m->control_command_id = MOUNT_EXEC_REMOUNT;
1023 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1025 if (m->from_fragment) {
1029 if (m->parameters_fragment.options) {
1030 if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
1039 r = exec_command_set(
1042 m->parameters_fragment.what,
1044 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
1049 } else if (m->from_etc_fstab)
1050 r = exec_command_set(
1062 mount_unwatch_control_pid(m);
1064 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1067 mount_set_state(m, MOUNT_REMOUNTING);
1072 log_warning("%s failed to run 'remount' task: %s", UNIT(m)->id, strerror(-r));
1073 m->reload_result = MOUNT_FAILURE_RESOURCES;
1074 mount_enter_mounted(m, MOUNT_SUCCESS);
1077 static int mount_start(Unit *u) {
1078 Mount *m = MOUNT(u);
1082 /* We cannot fulfill this request right now, try again later
1084 if (m->state == MOUNT_UNMOUNTING ||
1085 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1086 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1087 m->state == MOUNT_MOUNTING_SIGTERM ||
1088 m->state == MOUNT_MOUNTING_SIGKILL)
1091 /* Already on it! */
1092 if (m->state == MOUNT_MOUNTING)
1095 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1097 m->result = MOUNT_SUCCESS;
1098 m->reload_result = MOUNT_SUCCESS;
1100 mount_enter_mounting(m);
1104 static int mount_stop(Unit *u) {
1105 Mount *m = MOUNT(u);
1110 if (m->state == MOUNT_UNMOUNTING ||
1111 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1112 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1113 m->state == MOUNT_MOUNTING_SIGTERM ||
1114 m->state == MOUNT_MOUNTING_SIGKILL)
1117 assert(m->state == MOUNT_MOUNTING ||
1118 m->state == MOUNT_MOUNTING_DONE ||
1119 m->state == MOUNT_MOUNTED ||
1120 m->state == MOUNT_REMOUNTING ||
1121 m->state == MOUNT_REMOUNTING_SIGTERM ||
1122 m->state == MOUNT_REMOUNTING_SIGKILL);
1124 mount_enter_unmounting(m);
1128 static int mount_reload(Unit *u) {
1129 Mount *m = MOUNT(u);
1133 if (m->state == MOUNT_MOUNTING_DONE)
1136 assert(m->state == MOUNT_MOUNTED);
1138 mount_enter_remounting(m);
1142 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1143 Mount *m = MOUNT(u);
1149 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1150 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1151 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1153 if (m->control_pid > 0)
1154 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1156 if (m->control_command_id >= 0)
1157 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1162 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1163 Mount *m = MOUNT(u);
1170 if (streq(key, "state")) {
1173 if ((state = mount_state_from_string(value)) < 0)
1174 log_debug("Failed to parse state value %s", value);
1176 m->deserialized_state = state;
1177 } else if (streq(key, "result")) {
1180 f = mount_result_from_string(value);
1182 log_debug("Failed to parse result value %s", value);
1183 else if (f != MOUNT_SUCCESS)
1186 } else if (streq(key, "reload-result")) {
1189 f = mount_result_from_string(value);
1191 log_debug("Failed to parse reload result value %s", value);
1192 else if (f != MOUNT_SUCCESS)
1193 m->reload_result = f;
1195 } else if (streq(key, "control-pid")) {
1198 if (parse_pid(value, &pid) < 0)
1199 log_debug("Failed to parse control-pid value %s", value);
1201 m->control_pid = pid;
1202 } else if (streq(key, "control-command")) {
1203 MountExecCommand id;
1205 if ((id = mount_exec_command_from_string(value)) < 0)
1206 log_debug("Failed to parse exec-command value %s", value);
1208 m->control_command_id = id;
1209 m->control_command = m->exec_command + id;
1213 log_debug("Unknown serialization key '%s'", key);
1218 static UnitActiveState mount_active_state(Unit *u) {
1221 return state_translation_table[MOUNT(u)->state];
1224 static const char *mount_sub_state_to_string(Unit *u) {
1227 return mount_state_to_string(MOUNT(u)->state);
1230 static bool mount_check_gc(Unit *u) {
1231 Mount *m = MOUNT(u);
1235 return m->from_etc_fstab || m->from_proc_self_mountinfo;
1238 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1239 Mount *m = MOUNT(u);
1245 if (pid != m->control_pid)
1250 if (is_clean_exit(code, status))
1252 else if (code == CLD_EXITED)
1253 f = MOUNT_FAILURE_EXIT_CODE;
1254 else if (code == CLD_KILLED)
1255 f = MOUNT_FAILURE_SIGNAL;
1256 else if (code == CLD_DUMPED)
1257 f = MOUNT_FAILURE_CORE_DUMP;
1259 assert_not_reached("Unknown code");
1261 if (f != MOUNT_SUCCESS)
1264 if (m->control_command) {
1265 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1267 m->control_command = NULL;
1268 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1271 log_full(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1272 "%s mount process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1274 /* Note that mount(8) returning and the kernel sending us a
1275 * mount table change event might happen out-of-order. If an
1276 * operation succeed we assume the kernel will follow soon too
1277 * and already change into the resulting state. If it fails
1278 * we check if the kernel still knows about the mount. and
1279 * change state accordingly. */
1283 case MOUNT_MOUNTING:
1284 case MOUNT_MOUNTING_DONE:
1285 case MOUNT_MOUNTING_SIGKILL:
1286 case MOUNT_MOUNTING_SIGTERM:
1288 if (f == MOUNT_SUCCESS)
1289 mount_enter_mounted(m, f);
1290 else if (m->from_proc_self_mountinfo)
1291 mount_enter_mounted(m, f);
1293 mount_enter_dead(m, f);
1296 case MOUNT_REMOUNTING:
1297 case MOUNT_REMOUNTING_SIGKILL:
1298 case MOUNT_REMOUNTING_SIGTERM:
1300 m->reload_result = f;
1301 if (m->from_proc_self_mountinfo)
1302 mount_enter_mounted(m, MOUNT_SUCCESS);
1304 mount_enter_dead(m, MOUNT_SUCCESS);
1308 case MOUNT_UNMOUNTING:
1309 case MOUNT_UNMOUNTING_SIGKILL:
1310 case MOUNT_UNMOUNTING_SIGTERM:
1312 if (f == MOUNT_SUCCESS)
1313 mount_enter_dead(m, f);
1314 else if (m->from_proc_self_mountinfo)
1315 mount_enter_mounted(m, f);
1317 mount_enter_dead(m, f);
1321 assert_not_reached("Uh, control process died at wrong time.");
1324 /* Notify clients about changed exit status */
1325 unit_add_to_dbus_queue(u);
1328 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1329 Mount *m = MOUNT(u);
1332 assert(elapsed == 1);
1333 assert(w == &m->timer_watch);
1337 case MOUNT_MOUNTING:
1338 case MOUNT_MOUNTING_DONE:
1339 log_warning("%s mounting timed out. Stopping.", u->id);
1340 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1343 case MOUNT_REMOUNTING:
1344 log_warning("%s remounting timed out. Stopping.", u->id);
1345 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1346 mount_enter_mounted(m, MOUNT_SUCCESS);
1349 case MOUNT_UNMOUNTING:
1350 log_warning("%s unmounting timed out. Stopping.", u->id);
1351 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1354 case MOUNT_MOUNTING_SIGTERM:
1355 if (m->exec_context.send_sigkill) {
1356 log_warning("%s mounting timed out. Killing.", u->id);
1357 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1359 log_warning("%s mounting 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_REMOUNTING_SIGTERM:
1369 if (m->exec_context.send_sigkill) {
1370 log_warning("%s remounting timed out. Killing.", u->id);
1371 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1373 log_warning("%s remounting 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_UNMOUNTING_SIGTERM:
1383 if (m->exec_context.send_sigkill) {
1384 log_warning("%s unmounting timed out. Killing.", u->id);
1385 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1387 log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1389 if (m->from_proc_self_mountinfo)
1390 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1392 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1396 case MOUNT_MOUNTING_SIGKILL:
1397 case MOUNT_REMOUNTING_SIGKILL:
1398 case MOUNT_UNMOUNTING_SIGKILL:
1399 log_warning("%s mount process still around after SIGKILL. Ignoring.", u->id);
1401 if (m->from_proc_self_mountinfo)
1402 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1404 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1408 assert_not_reached("Timeout at wrong time.");
1412 static int mount_add_one(
1416 const char *options,
1419 bool from_proc_self_mountinfo,
1424 char *e, *w = NULL, *o = NULL, *f = NULL;
1433 assert(!set_flags || from_proc_self_mountinfo);
1435 /* Ignore API mount points. They should never be referenced in
1436 * dependencies ever. */
1437 if (mount_point_is_api(where) || mount_point_ignore(where))
1440 if (streq(fstype, "autofs"))
1443 /* probably some kind of swap, ignore */
1444 if (!is_path(where))
1447 e = unit_name_from_path(where, ".mount");
1451 u = manager_get_unit(m, e);
1455 u = unit_new(m, sizeof(Mount));
1461 r = unit_add_name(u, e);
1467 MOUNT(u)->where = strdup(where);
1468 if (!MOUNT(u)->where) {
1473 unit_add_to_load_queue(u);
1479 if (!(w = strdup(what)) ||
1480 !(o = strdup(options)) ||
1481 !(f = strdup(fstype))) {
1486 if (from_proc_self_mountinfo) {
1487 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1490 MOUNT(u)->is_mounted = true;
1491 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1492 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1495 MOUNT(u)->from_proc_self_mountinfo = true;
1497 p = &MOUNT(u)->parameters_etc_fstab;
1498 MOUNT(u)->from_etc_fstab = true;
1512 unit_add_to_dbus_queue(u);
1527 static int mount_find_pri(char *options) {
1531 if (!(pri = mount_test_option(options, "pri")))
1537 r = strtoul(pri, &end, 10);
1542 if (end == pri || (*end != ',' && *end != 0))
1548 static int mount_load_etc_fstab(Manager *m) {
1556 f = setmntent("/etc/fstab", "r");
1558 return errno == ENOENT ? 0 : -errno;
1560 while ((me = getmntent(f))) {
1564 if (!(what = fstab_node_to_udev_node(me->mnt_fsname))) {
1569 if (!(where = strdup(me->mnt_dir))) {
1576 path_kill_slashes(what);
1578 if (where[0] == '/')
1579 path_kill_slashes(where);
1581 if (streq(me->mnt_type, "swap")) {
1584 if ((pri = mount_find_pri(me->mnt_opts)) < 0)
1591 !!mount_test_option(me->mnt_opts, "noauto"),
1592 !!mount_test_option(me->mnt_opts, "nofail"),
1595 k = mount_add_one(m, what, where, me->mnt_opts, me->mnt_type, me->mnt_passno, false, false);
1610 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1613 char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1617 rewind(m->proc_self_mountinfo);
1622 device = path = options = options2 = fstype = d = p = o = NULL;
1624 if ((k = fscanf(m->proc_self_mountinfo,
1625 "%*s " /* (1) mount id */
1626 "%*s " /* (2) parent id */
1627 "%*s " /* (3) major:minor */
1628 "%*s " /* (4) root */
1629 "%ms " /* (5) mount point */
1630 "%ms" /* (6) mount options */
1631 "%*[^-]" /* (7) optional fields */
1632 "- " /* (8) separator */
1633 "%ms " /* (9) file system type */
1634 "%ms" /* (10) mount source */
1635 "%ms" /* (11) mount options 2 */
1636 "%*[^\n]", /* some rubbish at the end */
1646 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1650 if (asprintf(&o, "%s,%s", options, options2) < 0) {
1655 if (!(d = cunescape(device)) ||
1656 !(p = cunescape(path))) {
1661 if ((k = mount_add_one(m, d, p, o, fstype, 0, true, set_flags)) < 0)
1688 static void mount_shutdown(Manager *m) {
1691 if (m->proc_self_mountinfo) {
1692 fclose(m->proc_self_mountinfo);
1693 m->proc_self_mountinfo = NULL;
1697 static int mount_enumerate(Manager *m) {
1699 struct epoll_event ev;
1702 if (!m->proc_self_mountinfo) {
1703 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1706 m->mount_watch.type = WATCH_MOUNT;
1707 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1710 ev.events = EPOLLPRI;
1711 ev.data.ptr = &m->mount_watch;
1713 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1717 if ((r = mount_load_etc_fstab(m)) < 0)
1720 if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1730 void mount_fd_event(Manager *m, int events) {
1735 assert(events & EPOLLPRI);
1737 /* The manager calls this for every fd event happening on the
1738 * /proc/self/mountinfo file, which informs us about mounting
1741 if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
1742 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1744 /* Reset flags, just in case, for later calls */
1745 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1746 Mount *mount = MOUNT(u);
1748 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1754 manager_dispatch_load_queue(m);
1756 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1757 Mount *mount = MOUNT(u);
1759 if (!mount->is_mounted) {
1760 /* This has just been unmounted. */
1762 mount->from_proc_self_mountinfo = false;
1764 switch (mount->state) {
1767 mount_enter_dead(mount, MOUNT_SUCCESS);
1771 mount_set_state(mount, mount->state);
1776 } else if (mount->just_mounted || mount->just_changed) {
1778 /* New or changed mount entry */
1780 switch (mount->state) {
1784 mount_enter_mounted(mount, MOUNT_SUCCESS);
1787 case MOUNT_MOUNTING:
1788 mount_enter_mounting_done(mount);
1792 /* Nothing really changed, but let's
1793 * issue an notification call
1794 * nonetheless, in case somebody is
1795 * waiting for this. (e.g. file system
1796 * ro/rw remounts.) */
1797 mount_set_state(mount, mount->state);
1802 /* Reset the flags for later calls */
1803 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1807 static void mount_reset_failed(Unit *u) {
1808 Mount *m = MOUNT(u);
1812 if (m->state == MOUNT_FAILED)
1813 mount_set_state(m, MOUNT_DEAD);
1815 m->result = MOUNT_SUCCESS;
1816 m->reload_result = MOUNT_SUCCESS;
1819 static int mount_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
1820 Mount *m = MOUNT(u);
1822 Set *pid_set = NULL;
1826 if (who == KILL_MAIN) {
1827 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1831 if (m->control_pid <= 0 && who == KILL_CONTROL) {
1832 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1836 if (who == KILL_CONTROL || who == KILL_ALL)
1837 if (m->control_pid > 0)
1838 if (kill(m->control_pid, signo) < 0)
1841 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
1844 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
1847 /* Exclude the control pid from being killed via the cgroup */
1848 if (m->control_pid > 0)
1849 if ((q = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0) {
1854 q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, false, pid_set, NULL);
1856 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1867 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1868 [MOUNT_DEAD] = "dead",
1869 [MOUNT_MOUNTING] = "mounting",
1870 [MOUNT_MOUNTING_DONE] = "mounting-done",
1871 [MOUNT_MOUNTED] = "mounted",
1872 [MOUNT_REMOUNTING] = "remounting",
1873 [MOUNT_UNMOUNTING] = "unmounting",
1874 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1875 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1876 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1877 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1878 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1879 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1880 [MOUNT_FAILED] = "failed"
1883 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1885 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1886 [MOUNT_EXEC_MOUNT] = "ExecMount",
1887 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1888 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1891 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1893 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1894 [MOUNT_SUCCESS] = "success",
1895 [MOUNT_FAILURE_RESOURCES] = "resources",
1896 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1897 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1898 [MOUNT_FAILURE_SIGNAL] = "signal",
1899 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1902 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1904 const UnitVTable mount_vtable = {
1906 .object_size = sizeof(Mount),
1913 .no_instances = true,
1914 .show_status = true,
1920 .coldplug = mount_coldplug,
1924 .start = mount_start,
1926 .reload = mount_reload,
1930 .serialize = mount_serialize,
1931 .deserialize_item = mount_deserialize_item,
1933 .active_state = mount_active_state,
1934 .sub_state_to_string = mount_sub_state_to_string,
1936 .check_gc = mount_check_gc,
1938 .sigchld_event = mount_sigchld_event,
1939 .timer_event = mount_timer_event,
1941 .reset_failed = mount_reset_failed,
1943 .bus_interface = "org.freedesktop.systemd1.Mount",
1944 .bus_message_handler = bus_mount_message_handler,
1945 .bus_invalidating_properties = bus_mount_invalidating_properties,
1947 .enumerate = mount_enumerate,
1948 .shutdown = mount_shutdown