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 "mount-setup.h"
36 #include "unit-name.h"
37 #include "dbus-mount.h"
39 #include "bus-errors.h"
40 #include "exit-status.h"
43 static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
44 [MOUNT_DEAD] = UNIT_INACTIVE,
45 [MOUNT_MOUNTING] = UNIT_ACTIVATING,
46 [MOUNT_MOUNTING_DONE] = UNIT_ACTIVE,
47 [MOUNT_MOUNTED] = UNIT_ACTIVE,
48 [MOUNT_REMOUNTING] = UNIT_RELOADING,
49 [MOUNT_UNMOUNTING] = UNIT_DEACTIVATING,
50 [MOUNT_MOUNTING_SIGTERM] = UNIT_DEACTIVATING,
51 [MOUNT_MOUNTING_SIGKILL] = UNIT_DEACTIVATING,
52 [MOUNT_REMOUNTING_SIGTERM] = UNIT_RELOADING,
53 [MOUNT_REMOUNTING_SIGKILL] = UNIT_RELOADING,
54 [MOUNT_UNMOUNTING_SIGTERM] = UNIT_DEACTIVATING,
55 [MOUNT_UNMOUNTING_SIGKILL] = UNIT_DEACTIVATING,
56 [MOUNT_FAILED] = UNIT_FAILED
59 static void mount_init(Unit *u) {
63 assert(u->load_state == UNIT_STUB);
65 m->timeout_usec = DEFAULT_TIMEOUT_USEC;
66 m->directory_mode = 0755;
68 exec_context_init(&m->exec_context);
70 /* The stdio/kmsg bridge socket is on /, in order to avoid a
71 * dep loop, don't use kmsg logging for -.mount */
72 if (!unit_has_name(u, "-.mount")) {
73 m->exec_context.std_output = u->manager->default_std_output;
74 m->exec_context.std_error = u->manager->default_std_error;
77 /* We need to make sure that /bin/mount is always called in
78 * the same process group as us, so that the autofs kernel
79 * side doesn't send us another mount request while we are
80 * already trying to comply its last one. */
81 m->exec_context.same_pgrp = true;
83 m->timer_watch.type = WATCH_INVALID;
85 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
87 UNIT(m)->ignore_on_isolate = true;
90 static void mount_unwatch_control_pid(Mount *m) {
93 if (m->control_pid <= 0)
96 unit_unwatch_pid(UNIT(m), m->control_pid);
100 static void mount_parameters_done(MountParameters *p) {
107 p->what = p->options = p->fstype = NULL;
110 static void mount_done(Unit *u) {
118 mount_parameters_done(&m->parameters_etc_fstab);
119 mount_parameters_done(&m->parameters_proc_self_mountinfo);
120 mount_parameters_done(&m->parameters_fragment);
122 exec_context_done(&m->exec_context);
123 exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
124 m->control_command = NULL;
126 mount_unwatch_control_pid(m);
128 unit_unwatch_timer(u, &m->timer_watch);
131 static MountParameters* get_mount_parameters_configured(Mount *m) {
134 if (m->from_fragment)
135 return &m->parameters_fragment;
136 else if (m->from_etc_fstab)
137 return &m->parameters_etc_fstab;
142 static MountParameters* get_mount_parameters(Mount *m) {
145 if (m->from_proc_self_mountinfo)
146 return &m->parameters_proc_self_mountinfo;
148 return get_mount_parameters_configured(m);
151 static int mount_add_mount_links(Mount *m) {
158 pm = get_mount_parameters_configured(m);
160 /* Adds in links to other mount points that might lie below or
161 * above us in the hierarchy */
163 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_MOUNT]) {
164 Mount *n = MOUNT(other);
170 if (UNIT(n)->load_state != UNIT_LOADED)
173 pn = get_mount_parameters_configured(n);
175 if (path_startswith(m->where, n->where)) {
177 if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, UNIT(n), true)) < 0)
181 if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, UNIT(n), true)) < 0)
184 } else if (path_startswith(n->where, m->where)) {
186 if ((r = unit_add_dependency(UNIT(n), UNIT_AFTER, UNIT(m), true)) < 0)
190 if ((r = unit_add_dependency(UNIT(n), UNIT_REQUIRES, UNIT(m), true)) < 0)
193 } else if (pm && pm->what && path_startswith(pm->what, n->where)) {
195 if ((r = unit_add_dependency(UNIT(m), UNIT_AFTER, UNIT(n), true)) < 0)
198 if ((r = unit_add_dependency(UNIT(m), UNIT_REQUIRES, UNIT(n), true)) < 0)
201 } else if (pn && pn->what && path_startswith(pn->what, m->where)) {
203 if ((r = unit_add_dependency(UNIT(n), UNIT_AFTER, UNIT(m), true)) < 0)
206 if ((r = unit_add_dependency(UNIT(n), UNIT_REQUIRES, UNIT(m), true)) < 0)
214 static int mount_add_swap_links(Mount *m) {
220 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_SWAP])
221 if ((r = swap_add_one_mount_link(SWAP(other), m)) < 0)
227 static int mount_add_path_links(Mount *m) {
233 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_PATH])
234 if ((r = path_add_one_mount_link(PATH(other), m)) < 0)
240 static int mount_add_automount_links(Mount *m) {
246 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_AUTOMOUNT])
247 if ((r = automount_add_one_mount_link(AUTOMOUNT(other), m)) < 0)
253 static int mount_add_socket_links(Mount *m) {
259 LIST_FOREACH(units_by_type, other, UNIT(m)->manager->units_by_type[UNIT_SOCKET])
260 if ((r = socket_add_one_mount_link(SOCKET(other), m)) < 0)
266 static char* mount_test_option(const char *haystack, const char *needle) {
271 /* Like glibc's hasmntopt(), but works on a string, not a
278 me.mnt_opts = (char*) haystack;
280 return hasmntopt(&me, needle);
283 static bool mount_is_network(MountParameters *p) {
286 if (mount_test_option(p->options, "_netdev"))
289 if (p->fstype && fstype_is_network(p->fstype))
295 static bool mount_is_bind(MountParameters *p) {
298 if (mount_test_option(p->options, "bind"))
301 if (p->fstype && streq(p->fstype, "bind"))
307 static bool needs_quota(MountParameters *p) {
310 if (mount_is_network(p))
313 if (mount_is_bind(p))
316 return mount_test_option(p->options, "usrquota") ||
317 mount_test_option(p->options, "grpquota") ||
318 mount_test_option(p->options, "quota") ||
319 mount_test_option(p->options, "usrjquota") ||
320 mount_test_option(p->options, "grpjquota");
323 static int mount_add_fstab_links(Mount *m) {
324 const char *target, *after, *tu_wants = NULL;
328 bool noauto, nofail, handle, automount;
332 if (UNIT(m)->manager->running_as != MANAGER_SYSTEM)
335 if (!(p = get_mount_parameters_configured(m)))
338 if (p != &m->parameters_etc_fstab)
341 noauto = !!mount_test_option(p->options, "noauto");
342 nofail = !!mount_test_option(p->options, "nofail");
344 mount_test_option(p->options, "comment=systemd.automount") ||
345 mount_test_option(p->options, "x-systemd-automount");
348 mount_test_option(p->options, "comment=systemd.mount") ||
349 mount_test_option(p->options, "x-systemd-mount") ||
350 UNIT(m)->manager->mount_auto;
352 if (mount_is_network(p)) {
353 target = SPECIAL_REMOTE_FS_TARGET;
354 after = tu_wants = SPECIAL_REMOTE_FS_PRE_TARGET;
356 target = SPECIAL_LOCAL_FS_TARGET;
357 after = SPECIAL_LOCAL_FS_PRE_TARGET;
360 r = manager_load_unit(UNIT(m)->manager, target, NULL, NULL, &tu);
365 r = unit_add_dependency_by_name(tu, UNIT_WANTS, tu_wants, NULL, true);
371 r = unit_add_dependency_by_name(UNIT(m), UNIT_AFTER, after, NULL, true);
379 if ((r = unit_load_related_unit(UNIT(m), ".automount", &am)) < 0)
382 /* If auto is configured as well also pull in the
383 * mount right-away, but don't rely on it. */
384 if (!noauto) /* automount + auto */
385 if ((r = unit_add_dependency(tu, UNIT_WANTS, UNIT(m), true)) < 0)
388 /* Install automount unit */
389 if (!nofail) /* automount + fail */
390 return unit_add_two_dependencies(tu, UNIT_AFTER, UNIT_REQUIRES, am, true);
391 else /* automount + nofail */
392 return unit_add_two_dependencies(tu, UNIT_AFTER, UNIT_WANTS, am, true);
394 } else if (handle && !noauto) {
396 /* Automatically add mount points that aren't natively
397 * configured to local-fs.target */
399 if (!nofail) /* auto + fail */
400 return unit_add_two_dependencies(tu, UNIT_AFTER, UNIT_REQUIRES, UNIT(m), true);
401 else /* auto + nofail */
402 return unit_add_dependency(tu, UNIT_WANTS, UNIT(m), true);
408 static int mount_add_device_links(Mount *m) {
414 if (!(p = get_mount_parameters_configured(m)))
420 if (!mount_is_bind(p) &&
421 !path_equal(m->where, "/") &&
422 p == &m->parameters_etc_fstab) {
425 noauto = !!mount_test_option(p->options, "noauto");
426 nofail = !!mount_test_option(p->options, "nofail");
428 if ((r = unit_add_node_link(UNIT(m), p->what,
430 UNIT(m)->manager->running_as == MANAGER_SYSTEM)) < 0)
436 UNIT(m)->manager->running_as == MANAGER_SYSTEM &&
437 !path_equal(m->where, "/")) {
440 /* Let's add in the fsck service */
442 /* aka SPECIAL_FSCK_SERVICE */
443 if (!(name = unit_name_from_path_instance("fsck", p->what, ".service")))
446 if ((r = manager_load_unit_prepare(UNIT(m)->manager, name, NULL, NULL, &fsck)) < 0) {
447 log_warning("Failed to prepare unit %s: %s", name, strerror(-r));
454 SERVICE(fsck)->fsck_passno = p->passno;
456 if ((r = unit_add_two_dependencies(UNIT(m), UNIT_AFTER, UNIT_REQUIRES, fsck, true)) < 0)
463 static int mount_add_default_dependencies(Mount *m) {
469 if (UNIT(m)->manager->running_as != MANAGER_SYSTEM)
472 p = get_mount_parameters_configured(m);
473 if (p && needs_quota(p)) {
474 if ((r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTACHECK_SERVICE, NULL, true)) < 0 ||
475 (r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_WANTS, SPECIAL_QUOTAON_SERVICE, NULL, true)) < 0)
479 if (!path_equal(m->where, "/"))
480 if ((r = unit_add_two_dependencies_by_name(UNIT(m), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_UMOUNT_TARGET, NULL, true)) < 0)
486 static int mount_fix_timeouts(Mount *m) {
488 const char *timeout = NULL;
497 if (!(p = get_mount_parameters_configured(m)))
500 /* Allow configuration how long we wait for a device that
501 * backs a mount point to show up. This is useful to support
502 * endless device timeouts for devices that show up only after
503 * user input, like crypto devices. */
505 if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
507 else if ((timeout = mount_test_option(p->options, "x-systemd-device-timeout")))
512 t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
516 r = parse_usec(t, &u);
520 log_warning("Failed to parse timeout for %s, ignoring: %s", m->where, timeout);
524 SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
525 if (other->type != UNIT_DEVICE)
528 other->job_timeout = u;
534 static int mount_verify(Mount *m) {
539 if (UNIT(m)->load_state != UNIT_LOADED)
542 if (!m->from_etc_fstab && !m->from_fragment && !m->from_proc_self_mountinfo)
545 if (!(e = unit_name_from_path(m->where, ".mount")))
548 b = unit_has_name(UNIT(m), e);
552 log_error("%s's Where setting doesn't match unit name. Refusing.", UNIT(m)->id);
556 if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
557 log_error("Cannot create mount unit for API file system %s. Refusing.", m->where);
561 if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
562 log_error("%s's What setting is missing. Refusing.", UNIT(m)->id);
566 if (m->exec_context.pam_name && m->exec_context.kill_mode != KILL_CONTROL_GROUP) {
567 log_error("%s has PAM enabled. Kill mode must be set to 'control-group'. Refusing.", UNIT(m)->id);
574 static int mount_load(Unit *u) {
579 assert(u->load_state == UNIT_STUB);
581 if ((r = unit_load_fragment_and_dropin_optional(u)) < 0)
584 /* This is a new unit? Then let's add in some extras */
585 if (u->load_state == UNIT_LOADED) {
586 if ((r = unit_add_exec_dependencies(u, &m->exec_context)) < 0)
589 if (UNIT(m)->fragment_path)
590 m->from_fragment = true;
591 else if (m->from_etc_fstab)
592 /* We always add several default dependencies to fstab mounts,
593 * but we do not want the implicit complementing of Wants= with After=
594 * in the target unit that this mount unit will be hooked into. */
595 UNIT(m)->default_dependencies = false;
598 if (!(m->where = unit_name_to_path(u->id)))
601 path_kill_slashes(m->where);
603 if (!UNIT(m)->description)
604 if ((r = unit_set_description(u, m->where)) < 0)
607 if ((r = mount_add_device_links(m)) < 0)
610 if ((r = mount_add_mount_links(m)) < 0)
613 if ((r = mount_add_socket_links(m)) < 0)
616 if ((r = mount_add_swap_links(m)) < 0)
619 if ((r = mount_add_path_links(m)) < 0)
622 if ((r = mount_add_automount_links(m)) < 0)
625 if ((r = mount_add_fstab_links(m)) < 0)
628 if (UNIT(m)->default_dependencies || m->from_etc_fstab)
629 if ((r = mount_add_default_dependencies(m)) < 0)
632 if ((r = unit_add_default_cgroups(u)) < 0)
635 mount_fix_timeouts(m);
638 return mount_verify(m);
641 static int mount_notify_automount(Mount *m, int status) {
648 SET_FOREACH(p, UNIT(m)->dependencies[UNIT_TRIGGERED_BY], i)
649 if (p->type == UNIT_AUTOMOUNT) {
650 r = automount_send_ready(AUTOMOUNT(p), status);
658 static void mount_set_state(Mount *m, MountState state) {
659 MountState old_state;
662 old_state = m->state;
665 if (state != MOUNT_MOUNTING &&
666 state != MOUNT_MOUNTING_DONE &&
667 state != MOUNT_REMOUNTING &&
668 state != MOUNT_UNMOUNTING &&
669 state != MOUNT_MOUNTING_SIGTERM &&
670 state != MOUNT_MOUNTING_SIGKILL &&
671 state != MOUNT_UNMOUNTING_SIGTERM &&
672 state != MOUNT_UNMOUNTING_SIGKILL &&
673 state != MOUNT_REMOUNTING_SIGTERM &&
674 state != MOUNT_REMOUNTING_SIGKILL) {
675 unit_unwatch_timer(UNIT(m), &m->timer_watch);
676 mount_unwatch_control_pid(m);
677 m->control_command = NULL;
678 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
681 if (state == MOUNT_MOUNTED ||
682 state == MOUNT_REMOUNTING)
683 mount_notify_automount(m, 0);
684 else if (state == MOUNT_DEAD ||
685 state == MOUNT_UNMOUNTING ||
686 state == MOUNT_MOUNTING_SIGTERM ||
687 state == MOUNT_MOUNTING_SIGKILL ||
688 state == MOUNT_REMOUNTING_SIGTERM ||
689 state == MOUNT_REMOUNTING_SIGKILL ||
690 state == MOUNT_UNMOUNTING_SIGTERM ||
691 state == MOUNT_UNMOUNTING_SIGKILL ||
692 state == MOUNT_FAILED)
693 mount_notify_automount(m, -ENODEV);
695 if (state != old_state)
696 log_debug("%s changed %s -> %s",
698 mount_state_to_string(old_state),
699 mount_state_to_string(state));
701 unit_notify(UNIT(m), state_translation_table[old_state], state_translation_table[state], m->reload_result == MOUNT_SUCCESS);
702 m->reload_result = MOUNT_SUCCESS;
705 static int mount_coldplug(Unit *u) {
707 MountState new_state = MOUNT_DEAD;
711 assert(m->state == MOUNT_DEAD);
713 if (m->deserialized_state != m->state)
714 new_state = m->deserialized_state;
715 else if (m->from_proc_self_mountinfo)
716 new_state = MOUNT_MOUNTED;
718 if (new_state != m->state) {
720 if (new_state == MOUNT_MOUNTING ||
721 new_state == MOUNT_MOUNTING_DONE ||
722 new_state == MOUNT_REMOUNTING ||
723 new_state == MOUNT_UNMOUNTING ||
724 new_state == MOUNT_MOUNTING_SIGTERM ||
725 new_state == MOUNT_MOUNTING_SIGKILL ||
726 new_state == MOUNT_UNMOUNTING_SIGTERM ||
727 new_state == MOUNT_UNMOUNTING_SIGKILL ||
728 new_state == MOUNT_REMOUNTING_SIGTERM ||
729 new_state == MOUNT_REMOUNTING_SIGKILL) {
731 if (m->control_pid <= 0)
734 if ((r = unit_watch_pid(UNIT(m), m->control_pid)) < 0)
737 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
741 mount_set_state(m, new_state);
747 static void mount_dump(Unit *u, FILE *f, const char *prefix) {
754 p = get_mount_parameters(m);
757 "%sMount State: %s\n"
761 "%sFile System Type: %s\n"
763 "%sFrom /etc/fstab: %s\n"
764 "%sFrom /proc/self/mountinfo: %s\n"
765 "%sFrom fragment: %s\n"
766 "%sDirectoryMode: %04o\n",
767 prefix, mount_state_to_string(m->state),
768 prefix, mount_result_to_string(m->result),
770 prefix, strna(p->what),
771 prefix, strna(p->fstype),
772 prefix, strna(p->options),
773 prefix, yes_no(m->from_etc_fstab),
774 prefix, yes_no(m->from_proc_self_mountinfo),
775 prefix, yes_no(m->from_fragment),
776 prefix, m->directory_mode);
778 if (m->control_pid > 0)
780 "%sControl PID: %lu\n",
781 prefix, (unsigned long) m->control_pid);
783 exec_context_dump(&m->exec_context, f, prefix);
786 static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
794 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
797 if ((r = exec_spawn(c,
801 UNIT(m)->manager->environment,
805 UNIT(m)->manager->confirm_spawn,
806 UNIT(m)->cgroup_bondings,
807 UNIT(m)->cgroup_attributes,
811 if ((r = unit_watch_pid(UNIT(m), pid)) < 0)
812 /* FIXME: we need to do something here */
820 unit_unwatch_timer(UNIT(m), &m->timer_watch);
825 static void mount_enter_dead(Mount *m, MountResult f) {
828 if (f != MOUNT_SUCCESS)
831 mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
834 static void mount_enter_mounted(Mount *m, MountResult f) {
837 if (f != MOUNT_SUCCESS)
840 mount_set_state(m, MOUNT_MOUNTED);
843 static void mount_enter_signal(Mount *m, MountState state, MountResult f) {
846 bool wait_for_exit = false;
850 if (f != MOUNT_SUCCESS)
853 if (m->exec_context.kill_mode != KILL_NONE) {
854 int sig = (state == MOUNT_MOUNTING_SIGTERM ||
855 state == MOUNT_UNMOUNTING_SIGTERM ||
856 state == MOUNT_REMOUNTING_SIGTERM) ? m->exec_context.kill_signal : SIGKILL;
858 if (m->control_pid > 0) {
859 if (kill_and_sigcont(m->control_pid, sig) < 0 && errno != ESRCH)
861 log_warning("Failed to kill control process %li: %m", (long) m->control_pid);
863 wait_for_exit = true;
866 if (m->exec_context.kill_mode == KILL_CONTROL_GROUP) {
868 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func))) {
873 /* Exclude the control pid from being killed via the cgroup */
874 if (m->control_pid > 0)
875 if ((r = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0)
878 if ((r = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, sig, true, pid_set)) < 0) {
879 if (r != -EAGAIN && r != -ESRCH && r != -ENOENT)
880 log_warning("Failed to kill control group: %s", strerror(-r));
882 wait_for_exit = true;
890 if ((r = unit_watch_timer(UNIT(m), m->timeout_usec, &m->timer_watch)) < 0)
893 mount_set_state(m, state);
894 } else if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
895 mount_enter_mounted(m, MOUNT_SUCCESS);
897 mount_enter_dead(m, MOUNT_SUCCESS);
902 log_warning("%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
904 if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
905 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
907 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
913 static void mount_enter_unmounting(Mount *m) {
918 m->control_command_id = MOUNT_EXEC_UNMOUNT;
919 m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
921 if ((r = exec_command_set(
928 mount_unwatch_control_pid(m);
930 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
933 mount_set_state(m, MOUNT_UNMOUNTING);
938 log_warning("%s failed to run 'umount' task: %s", UNIT(m)->id, strerror(-r));
939 mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
942 static void mount_enter_mounting(Mount *m) {
948 m->control_command_id = MOUNT_EXEC_MOUNT;
949 m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
951 mkdir_p(m->where, m->directory_mode);
953 /* Create the source directory for bind-mounts if needed */
954 p = get_mount_parameters_configured(m);
955 if (p && mount_is_bind(p))
956 mkdir_p(p->what, m->directory_mode);
958 if (m->from_fragment)
959 r = exec_command_set(
962 m->parameters_fragment.what,
964 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
965 m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
967 else if (m->from_etc_fstab)
968 r = exec_command_set(
979 mount_unwatch_control_pid(m);
981 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
984 mount_set_state(m, MOUNT_MOUNTING);
989 log_warning("%s failed to run 'mount' task: %s", UNIT(m)->id, strerror(-r));
990 mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
993 static void mount_enter_mounting_done(Mount *m) {
996 mount_set_state(m, MOUNT_MOUNTING_DONE);
999 static void mount_enter_remounting(Mount *m) {
1004 m->control_command_id = MOUNT_EXEC_REMOUNT;
1005 m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
1007 if (m->from_fragment) {
1011 if (m->parameters_fragment.options) {
1012 if (!(buf = strappend("remount,", m->parameters_fragment.options))) {
1021 r = exec_command_set(
1024 m->parameters_fragment.what,
1026 "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
1031 } else if (m->from_etc_fstab)
1032 r = exec_command_set(
1044 mount_unwatch_control_pid(m);
1046 if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
1049 mount_set_state(m, MOUNT_REMOUNTING);
1054 log_warning("%s failed to run 'remount' task: %s", UNIT(m)->id, strerror(-r));
1055 m->reload_result = MOUNT_FAILURE_RESOURCES;
1056 mount_enter_mounted(m, MOUNT_SUCCESS);
1059 static int mount_start(Unit *u) {
1060 Mount *m = MOUNT(u);
1064 /* We cannot fulfill this request right now, try again later
1066 if (m->state == MOUNT_UNMOUNTING ||
1067 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1068 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1069 m->state == MOUNT_MOUNTING_SIGTERM ||
1070 m->state == MOUNT_MOUNTING_SIGKILL)
1073 /* Already on it! */
1074 if (m->state == MOUNT_MOUNTING)
1077 assert(m->state == MOUNT_DEAD || m->state == MOUNT_FAILED);
1079 m->result = MOUNT_SUCCESS;
1080 m->reload_result = MOUNT_SUCCESS;
1082 mount_enter_mounting(m);
1086 static int mount_stop(Unit *u) {
1087 Mount *m = MOUNT(u);
1092 if (m->state == MOUNT_UNMOUNTING ||
1093 m->state == MOUNT_UNMOUNTING_SIGKILL ||
1094 m->state == MOUNT_UNMOUNTING_SIGTERM ||
1095 m->state == MOUNT_MOUNTING_SIGTERM ||
1096 m->state == MOUNT_MOUNTING_SIGKILL)
1099 assert(m->state == MOUNT_MOUNTING ||
1100 m->state == MOUNT_MOUNTING_DONE ||
1101 m->state == MOUNT_MOUNTED ||
1102 m->state == MOUNT_REMOUNTING ||
1103 m->state == MOUNT_REMOUNTING_SIGTERM ||
1104 m->state == MOUNT_REMOUNTING_SIGKILL);
1106 mount_enter_unmounting(m);
1110 static int mount_reload(Unit *u) {
1111 Mount *m = MOUNT(u);
1115 if (m->state == MOUNT_MOUNTING_DONE)
1118 assert(m->state == MOUNT_MOUNTED);
1120 mount_enter_remounting(m);
1124 static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
1125 Mount *m = MOUNT(u);
1131 unit_serialize_item(u, f, "state", mount_state_to_string(m->state));
1132 unit_serialize_item(u, f, "result", mount_result_to_string(m->result));
1133 unit_serialize_item(u, f, "reload-result", mount_result_to_string(m->reload_result));
1135 if (m->control_pid > 0)
1136 unit_serialize_item_format(u, f, "control-pid", "%lu", (unsigned long) m->control_pid);
1138 if (m->control_command_id >= 0)
1139 unit_serialize_item(u, f, "control-command", mount_exec_command_to_string(m->control_command_id));
1144 static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
1145 Mount *m = MOUNT(u);
1152 if (streq(key, "state")) {
1155 if ((state = mount_state_from_string(value)) < 0)
1156 log_debug("Failed to parse state value %s", value);
1158 m->deserialized_state = state;
1159 } else if (streq(key, "result")) {
1162 f = mount_result_from_string(value);
1164 log_debug("Failed to parse result value %s", value);
1165 else if (f != MOUNT_SUCCESS)
1168 } else if (streq(key, "reload-result")) {
1171 f = mount_result_from_string(value);
1173 log_debug("Failed to parse reload result value %s", value);
1174 else if (f != MOUNT_SUCCESS)
1175 m->reload_result = f;
1177 } else if (streq(key, "control-pid")) {
1180 if (parse_pid(value, &pid) < 0)
1181 log_debug("Failed to parse control-pid value %s", value);
1183 m->control_pid = pid;
1184 } else if (streq(key, "control-command")) {
1185 MountExecCommand id;
1187 if ((id = mount_exec_command_from_string(value)) < 0)
1188 log_debug("Failed to parse exec-command value %s", value);
1190 m->control_command_id = id;
1191 m->control_command = m->exec_command + id;
1195 log_debug("Unknown serialization key '%s'", key);
1200 static UnitActiveState mount_active_state(Unit *u) {
1203 return state_translation_table[MOUNT(u)->state];
1206 static const char *mount_sub_state_to_string(Unit *u) {
1209 return mount_state_to_string(MOUNT(u)->state);
1212 static bool mount_check_gc(Unit *u) {
1213 Mount *m = MOUNT(u);
1217 return m->from_etc_fstab || m->from_proc_self_mountinfo;
1220 static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
1221 Mount *m = MOUNT(u);
1227 if (pid != m->control_pid)
1232 if (is_clean_exit(code, status))
1234 else if (code == CLD_EXITED)
1235 f = MOUNT_FAILURE_EXIT_CODE;
1236 else if (code == CLD_KILLED)
1237 f = MOUNT_FAILURE_SIGNAL;
1238 else if (code == CLD_DUMPED)
1239 f = MOUNT_FAILURE_CORE_DUMP;
1241 assert_not_reached("Unknown code");
1243 if (f != MOUNT_SUCCESS)
1246 if (m->control_command) {
1247 exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
1249 m->control_command = NULL;
1250 m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
1253 log_full(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
1254 "%s mount process exited, code=%s status=%i", u->id, sigchld_code_to_string(code), status);
1256 /* Note that mount(8) returning and the kernel sending us a
1257 * mount table change event might happen out-of-order. If an
1258 * operation succeed we assume the kernel will follow soon too
1259 * and already change into the resulting state. If it fails
1260 * we check if the kernel still knows about the mount. and
1261 * change state accordingly. */
1265 case MOUNT_MOUNTING:
1266 case MOUNT_MOUNTING_DONE:
1267 case MOUNT_MOUNTING_SIGKILL:
1268 case MOUNT_MOUNTING_SIGTERM:
1270 if (f == MOUNT_SUCCESS)
1271 mount_enter_mounted(m, f);
1272 else if (m->from_proc_self_mountinfo)
1273 mount_enter_mounted(m, f);
1275 mount_enter_dead(m, f);
1278 case MOUNT_REMOUNTING:
1279 case MOUNT_REMOUNTING_SIGKILL:
1280 case MOUNT_REMOUNTING_SIGTERM:
1282 m->reload_result = f;
1283 if (m->from_proc_self_mountinfo)
1284 mount_enter_mounted(m, MOUNT_SUCCESS);
1286 mount_enter_dead(m, MOUNT_SUCCESS);
1290 case MOUNT_UNMOUNTING:
1291 case MOUNT_UNMOUNTING_SIGKILL:
1292 case MOUNT_UNMOUNTING_SIGTERM:
1294 if (f == MOUNT_SUCCESS)
1295 mount_enter_dead(m, f);
1296 else if (m->from_proc_self_mountinfo)
1297 mount_enter_mounted(m, f);
1299 mount_enter_dead(m, f);
1303 assert_not_reached("Uh, control process died at wrong time.");
1306 /* Notify clients about changed exit status */
1307 unit_add_to_dbus_queue(u);
1310 static void mount_timer_event(Unit *u, uint64_t elapsed, Watch *w) {
1311 Mount *m = MOUNT(u);
1314 assert(elapsed == 1);
1315 assert(w == &m->timer_watch);
1319 case MOUNT_MOUNTING:
1320 case MOUNT_MOUNTING_DONE:
1321 log_warning("%s mounting timed out. Stopping.", u->id);
1322 mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1325 case MOUNT_REMOUNTING:
1326 log_warning("%s remounting timed out. Stopping.", u->id);
1327 m->reload_result = MOUNT_FAILURE_TIMEOUT;
1328 mount_enter_mounted(m, MOUNT_SUCCESS);
1331 case MOUNT_UNMOUNTING:
1332 log_warning("%s unmounting timed out. Stopping.", u->id);
1333 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
1336 case MOUNT_MOUNTING_SIGTERM:
1337 if (m->exec_context.send_sigkill) {
1338 log_warning("%s mounting timed out. Killing.", u->id);
1339 mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1341 log_warning("%s mounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1343 if (m->from_proc_self_mountinfo)
1344 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1346 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1350 case MOUNT_REMOUNTING_SIGTERM:
1351 if (m->exec_context.send_sigkill) {
1352 log_warning("%s remounting timed out. Killing.", u->id);
1353 mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1355 log_warning("%s remounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1357 if (m->from_proc_self_mountinfo)
1358 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1360 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1364 case MOUNT_UNMOUNTING_SIGTERM:
1365 if (m->exec_context.send_sigkill) {
1366 log_warning("%s unmounting timed out. Killing.", u->id);
1367 mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
1369 log_warning("%s unmounting timed out. Skipping SIGKILL. Ignoring.", u->id);
1371 if (m->from_proc_self_mountinfo)
1372 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1374 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1378 case MOUNT_MOUNTING_SIGKILL:
1379 case MOUNT_REMOUNTING_SIGKILL:
1380 case MOUNT_UNMOUNTING_SIGKILL:
1381 log_warning("%s mount process still around after SIGKILL. Ignoring.", u->id);
1383 if (m->from_proc_self_mountinfo)
1384 mount_enter_mounted(m, MOUNT_FAILURE_TIMEOUT);
1386 mount_enter_dead(m, MOUNT_FAILURE_TIMEOUT);
1390 assert_not_reached("Timeout at wrong time.");
1394 static int mount_add_one(
1398 const char *options,
1401 bool from_proc_self_mountinfo,
1406 char *e, *w = NULL, *o = NULL, *f = NULL;
1415 assert(!set_flags || from_proc_self_mountinfo);
1417 /* Ignore API mount points. They should never be referenced in
1418 * dependencies ever. */
1419 if (mount_point_is_api(where) || mount_point_ignore(where))
1422 if (streq(fstype, "autofs"))
1425 /* probably some kind of swap, ignore */
1426 if (!is_path(where))
1429 e = unit_name_from_path(where, ".mount");
1433 u = manager_get_unit(m, e);
1437 u = unit_new(m, sizeof(Mount));
1443 r = unit_add_name(u, e);
1449 MOUNT(u)->where = strdup(where);
1450 if (!MOUNT(u)->where) {
1455 unit_add_to_load_queue(u);
1461 if (!(w = strdup(what)) ||
1462 !(o = strdup(options)) ||
1463 !(f = strdup(fstype))) {
1468 if (from_proc_self_mountinfo) {
1469 p = &MOUNT(u)->parameters_proc_self_mountinfo;
1472 MOUNT(u)->is_mounted = true;
1473 MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
1474 MOUNT(u)->just_changed = !streq_ptr(p->options, o);
1477 MOUNT(u)->from_proc_self_mountinfo = true;
1479 p = &MOUNT(u)->parameters_etc_fstab;
1480 MOUNT(u)->from_etc_fstab = true;
1494 unit_add_to_dbus_queue(u);
1509 static int mount_find_pri(char *options) {
1513 if (!(pri = mount_test_option(options, "pri")))
1519 r = strtoul(pri, &end, 10);
1524 if (end == pri || (*end != ',' && *end != 0))
1530 static int mount_load_etc_fstab(Manager *m) {
1538 if (!(f = setmntent("/etc/fstab", "r")))
1541 while ((me = getmntent(f))) {
1545 if (!(what = fstab_node_to_udev_node(me->mnt_fsname))) {
1550 if (!(where = strdup(me->mnt_dir))) {
1557 path_kill_slashes(what);
1559 if (where[0] == '/')
1560 path_kill_slashes(where);
1562 if (streq(me->mnt_type, "swap")) {
1565 if ((pri = mount_find_pri(me->mnt_opts)) < 0)
1572 !!mount_test_option(me->mnt_opts, "noauto"),
1573 !!mount_test_option(me->mnt_opts, "nofail"),
1574 !!mount_test_option(me->mnt_opts, "comment=systemd.swapon"),
1577 k = mount_add_one(m, what, where, me->mnt_opts, me->mnt_type, me->mnt_passno, false, false);
1592 static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
1595 char *device, *path, *options, *options2, *fstype, *d, *p, *o;
1599 rewind(m->proc_self_mountinfo);
1604 device = path = options = options2 = fstype = d = p = o = NULL;
1606 if ((k = fscanf(m->proc_self_mountinfo,
1607 "%*s " /* (1) mount id */
1608 "%*s " /* (2) parent id */
1609 "%*s " /* (3) major:minor */
1610 "%*s " /* (4) root */
1611 "%ms " /* (5) mount point */
1612 "%ms" /* (6) mount options */
1613 "%*[^-]" /* (7) optional fields */
1614 "- " /* (8) separator */
1615 "%ms " /* (9) file system type */
1616 "%ms" /* (10) mount source */
1617 "%ms" /* (11) mount options 2 */
1618 "%*[^\n]", /* some rubbish at the end */
1628 log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
1632 if (asprintf(&o, "%s,%s", options, options2) < 0) {
1637 if (!(d = cunescape(device)) ||
1638 !(p = cunescape(path))) {
1643 if ((k = mount_add_one(m, d, p, o, fstype, 0, true, set_flags)) < 0)
1670 static void mount_shutdown(Manager *m) {
1673 if (m->proc_self_mountinfo) {
1674 fclose(m->proc_self_mountinfo);
1675 m->proc_self_mountinfo = NULL;
1679 static int mount_enumerate(Manager *m) {
1681 struct epoll_event ev;
1684 if (!m->proc_self_mountinfo) {
1685 if (!(m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re")))
1688 m->mount_watch.type = WATCH_MOUNT;
1689 m->mount_watch.fd = fileno(m->proc_self_mountinfo);
1692 ev.events = EPOLLPRI;
1693 ev.data.ptr = &m->mount_watch;
1695 if (epoll_ctl(m->epoll_fd, EPOLL_CTL_ADD, m->mount_watch.fd, &ev) < 0)
1699 if ((r = mount_load_etc_fstab(m)) < 0)
1702 if ((r = mount_load_proc_self_mountinfo(m, false)) < 0)
1712 void mount_fd_event(Manager *m, int events) {
1717 assert(events & EPOLLPRI);
1719 /* The manager calls this for every fd event happening on the
1720 * /proc/self/mountinfo file, which informs us about mounting
1723 if ((r = mount_load_proc_self_mountinfo(m, true)) < 0) {
1724 log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
1726 /* Reset flags, just in case, for later calls */
1727 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1728 Mount *mount = MOUNT(u);
1730 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1736 manager_dispatch_load_queue(m);
1738 LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
1739 Mount *mount = MOUNT(u);
1741 if (!mount->is_mounted) {
1742 /* This has just been unmounted. */
1744 mount->from_proc_self_mountinfo = false;
1746 switch (mount->state) {
1749 mount_enter_dead(mount, MOUNT_SUCCESS);
1753 mount_set_state(mount, mount->state);
1758 } else if (mount->just_mounted || mount->just_changed) {
1760 /* New or changed mount entry */
1762 switch (mount->state) {
1766 mount_enter_mounted(mount, MOUNT_SUCCESS);
1769 case MOUNT_MOUNTING:
1770 mount_enter_mounting_done(mount);
1774 /* Nothing really changed, but let's
1775 * issue an notification call
1776 * nonetheless, in case somebody is
1777 * waiting for this. (e.g. file system
1778 * ro/rw remounts.) */
1779 mount_set_state(mount, mount->state);
1784 /* Reset the flags for later calls */
1785 mount->is_mounted = mount->just_mounted = mount->just_changed = false;
1789 static void mount_reset_failed(Unit *u) {
1790 Mount *m = MOUNT(u);
1794 if (m->state == MOUNT_FAILED)
1795 mount_set_state(m, MOUNT_DEAD);
1797 m->result = MOUNT_SUCCESS;
1798 m->reload_result = MOUNT_SUCCESS;
1801 static int mount_kill(Unit *u, KillWho who, KillMode mode, int signo, DBusError *error) {
1802 Mount *m = MOUNT(u);
1804 Set *pid_set = NULL;
1808 if (who == KILL_MAIN) {
1809 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "Mount units have no main processes");
1813 if (m->control_pid <= 0 && who == KILL_CONTROL) {
1814 dbus_set_error(error, BUS_ERROR_NO_SUCH_PROCESS, "No control process to kill");
1818 if (who == KILL_CONTROL || who == KILL_ALL)
1819 if (m->control_pid > 0)
1820 if (kill(m->control_pid, signo) < 0)
1823 if (who == KILL_ALL && mode == KILL_CONTROL_GROUP) {
1826 if (!(pid_set = set_new(trivial_hash_func, trivial_compare_func)))
1829 /* Exclude the control pid from being killed via the cgroup */
1830 if (m->control_pid > 0)
1831 if ((q = set_put(pid_set, LONG_TO_PTR(m->control_pid))) < 0) {
1836 if ((q = cgroup_bonding_kill_list(UNIT(m)->cgroup_bondings, signo, false, pid_set)) < 0)
1837 if (q != -EAGAIN && q != -ESRCH && q != -ENOENT)
1848 static const char* const mount_state_table[_MOUNT_STATE_MAX] = {
1849 [MOUNT_DEAD] = "dead",
1850 [MOUNT_MOUNTING] = "mounting",
1851 [MOUNT_MOUNTING_DONE] = "mounting-done",
1852 [MOUNT_MOUNTED] = "mounted",
1853 [MOUNT_REMOUNTING] = "remounting",
1854 [MOUNT_UNMOUNTING] = "unmounting",
1855 [MOUNT_MOUNTING_SIGTERM] = "mounting-sigterm",
1856 [MOUNT_MOUNTING_SIGKILL] = "mounting-sigkill",
1857 [MOUNT_REMOUNTING_SIGTERM] = "remounting-sigterm",
1858 [MOUNT_REMOUNTING_SIGKILL] = "remounting-sigkill",
1859 [MOUNT_UNMOUNTING_SIGTERM] = "unmounting-sigterm",
1860 [MOUNT_UNMOUNTING_SIGKILL] = "unmounting-sigkill",
1861 [MOUNT_FAILED] = "failed"
1864 DEFINE_STRING_TABLE_LOOKUP(mount_state, MountState);
1866 static const char* const mount_exec_command_table[_MOUNT_EXEC_COMMAND_MAX] = {
1867 [MOUNT_EXEC_MOUNT] = "ExecMount",
1868 [MOUNT_EXEC_UNMOUNT] = "ExecUnmount",
1869 [MOUNT_EXEC_REMOUNT] = "ExecRemount",
1872 DEFINE_STRING_TABLE_LOOKUP(mount_exec_command, MountExecCommand);
1874 static const char* const mount_result_table[_MOUNT_RESULT_MAX] = {
1875 [MOUNT_SUCCESS] = "success",
1876 [MOUNT_FAILURE_RESOURCES] = "resources",
1877 [MOUNT_FAILURE_TIMEOUT] = "timeout",
1878 [MOUNT_FAILURE_EXIT_CODE] = "exit-code",
1879 [MOUNT_FAILURE_SIGNAL] = "signal",
1880 [MOUNT_FAILURE_CORE_DUMP] = "core-dump"
1883 DEFINE_STRING_TABLE_LOOKUP(mount_result, MountResult);
1885 const UnitVTable mount_vtable = {
1887 .object_size = sizeof(Mount),
1894 .no_instances = true,
1895 .show_status = true,
1901 .coldplug = mount_coldplug,
1905 .start = mount_start,
1907 .reload = mount_reload,
1911 .serialize = mount_serialize,
1912 .deserialize_item = mount_deserialize_item,
1914 .active_state = mount_active_state,
1915 .sub_state_to_string = mount_sub_state_to_string,
1917 .check_gc = mount_check_gc,
1919 .sigchld_event = mount_sigchld_event,
1920 .timer_event = mount_timer_event,
1922 .reset_failed = mount_reset_failed,
1924 .bus_interface = "org.freedesktop.systemd1.Mount",
1925 .bus_message_handler = bus_mount_message_handler,
1926 .bus_invalidating_properties = bus_mount_invalidating_properties,
1928 .enumerate = mount_enumerate,
1929 .shutdown = mount_shutdown