#include <errno.h>
#include <stdio.h>
-#include <mntent.h>
#include <sys/epoll.h>
#include <signal.h>
+#include <libmount.h>
+#include <sys/inotify.h>
#include "manager.h"
#include "unit.h"
#include "mount.h"
-#include "load-fragment.h"
-#include "load-dropin.h"
#include "log.h"
#include "sd-messages.h"
#include "strv.h"
#include "unit-name.h"
#include "dbus-mount.h"
#include "special.h"
-#include "bus-errors.h"
#include "exit-status.h"
-#include "def.h"
+#include "fstab-util.h"
+
+#define RETRY_UMOUNT_MAX 32
+
+DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_table*, mnt_free_table);
+DEFINE_TRIVIAL_CLEANUP_FUNC(struct libmnt_iter*, mnt_free_iter);
static const UnitActiveState state_translation_table[_MOUNT_STATE_MAX] = {
[MOUNT_DEAD] = UNIT_INACTIVE,
static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
static int mount_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
-static char* mount_test_option(const char *haystack, const char *needle) {
- struct mntent me = { .mnt_opts = (char*) haystack };
-
- assert(needle);
-
- /* Like glibc's hasmntopt(), but works on a string, not a
- * struct mntent */
-
- if (!haystack)
- return NULL;
-
- return hasmntopt(&me, needle);
-}
-
-static bool mount_is_network(MountParameters *p) {
- assert(p);
-
- if (mount_test_option(p->options, "_netdev"))
+static bool mount_needs_network(const char *options, const char *fstype) {
+ if (fstab_test_option(options, "_netdev\0"))
return true;
- if (p->fstype && fstype_is_network(p->fstype))
+ if (fstype && fstype_is_network(fstype))
return true;
return false;
}
-static bool mount_is_bind(MountParameters *p) {
+static bool mount_is_network(const MountParameters *p) {
assert(p);
- if (mount_test_option(p->options, "bind"))
- return true;
+ return mount_needs_network(p->options, p->fstype);
+}
- if (p->fstype && streq(p->fstype, "bind"))
- return true;
+static bool mount_is_bind(const MountParameters *p) {
+ assert(p);
- if (mount_test_option(p->options, "rbind"))
+ if (fstab_test_option(p->options, "bind\0" "rbind\0"))
return true;
- if (p->fstype && streq(p->fstype, "rbind"))
+ if (p->fstype && STR_IN_SET(p->fstype, "bind", "rbind"))
return true;
return false;
}
-static bool mount_is_auto(MountParameters *p) {
+static bool mount_is_auto(const MountParameters *p) {
assert(p);
- return !mount_test_option(p->options, "noauto");
+ return !fstab_test_option(p->options, "noauto\0");
}
-static bool needs_quota(MountParameters *p) {
+static bool needs_quota(const MountParameters *p) {
assert(p);
if (mount_is_network(p))
if (mount_is_bind(p))
return false;
- return mount_test_option(p->options, "usrquota") ||
- mount_test_option(p->options, "grpquota") ||
- mount_test_option(p->options, "quota") ||
- mount_test_option(p->options, "usrjquota") ||
- mount_test_option(p->options, "grpjquota");
+ return fstab_test_option(p->options,
+ "usrquota\0" "grpquota\0" "quota\0" "usrjquota\0" "grpjquota\0");
}
static void mount_init(Unit *u) {
m->timeout_usec = u->manager->default_timeout_start_usec;
m->directory_mode = 0755;
- exec_context_init(&m->exec_context);
- kill_context_init(&m->kill_context);
- cgroup_context_init(&m->cgroup_context);
-
if (unit_has_name(u, "-.mount")) {
/* Don't allow start/stop for root directory */
u->refuse_manual_start = true;
return sd_event_source_set_enabled(m->timer_event_source, SD_EVENT_ONESHOT);
}
- return sd_event_add_monotonic(UNIT(m)->manager->event, now(CLOCK_MONOTONIC) + m->timeout_usec, 0, mount_dispatch_timer, m, &m->timer_event_source);
+ return sd_event_add_time(
+ UNIT(m)->manager->event,
+ &m->timer_event_source,
+ CLOCK_MONOTONIC,
+ now(CLOCK_MONOTONIC) + m->timeout_usec, 0,
+ mount_dispatch_timer, m);
}
static void mount_unwatch_control_pid(Mount *m) {
mount_parameters_done(&m->parameters_proc_self_mountinfo);
mount_parameters_done(&m->parameters_fragment);
- cgroup_context_done(&m->cgroup_context);
- exec_context_done(&m->exec_context);
m->exec_runtime = exec_runtime_unref(m->exec_runtime);
exec_command_done_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
m->control_command = NULL;
assert(m);
- p = get_mount_parameters_fragment(m);
+ p = get_mount_parameters(m);
if (!p)
return 0;
return false;
p = get_mount_parameters(m);
- if (p && mount_test_option(p->options, "x-initrd.mount") &&
+ if (p && fstab_test_option(p->options, "x-initrd.mount\0") &&
!in_initrd())
return false;
if (UNIT(m)->manager->running_as != SYSTEMD_SYSTEM)
return 0;
- p = get_mount_parameters(m);
-
- if (!p)
+ /* We do not add any default dependencies to / and /usr, since
+ * they are guaranteed to stay mounted the whole time, since
+ * our system is on it. Also, don't bother with anything
+ * mounted below virtual file systems, it's also going to be
+ * virtual, and hence not worth the effort. */
+ if (path_equal(m->where, "/") ||
+ path_equal(m->where, "/usr") ||
+ path_startswith(m->where, "/proc") ||
+ path_startswith(m->where, "/sys") ||
+ path_startswith(m->where, "/dev"))
return 0;
- if (path_equal(m->where, "/"))
+ p = get_mount_parameters(m);
+ if (!p)
return 0;
if (mount_is_network(p)) {
return 0;
}
-static int mount_fix_timeouts(Mount *m) {
- MountParameters *p;
- const char *timeout = NULL;
- Unit *other;
- Iterator i;
- usec_t u;
- char *t;
- int r;
-
- assert(m);
-
- p = get_mount_parameters_fragment(m);
- if (!p)
- return 0;
-
- /* Allow configuration how long we wait for a device that
- * backs a mount point to show up. This is useful to support
- * endless device timeouts for devices that show up only after
- * user input, like crypto devices. */
-
- if ((timeout = mount_test_option(p->options, "comment=systemd.device-timeout")))
- timeout += 31;
- else if ((timeout = mount_test_option(p->options, "x-systemd.device-timeout")))
- timeout += 25;
- else
- return 0;
-
- t = strndup(timeout, strcspn(timeout, ",;" WHITESPACE));
- if (!t)
- return -ENOMEM;
-
- r = parse_sec(t, &u);
- free(t);
-
- if (r < 0) {
- log_warning_unit(UNIT(m)->id,
- "Failed to parse timeout for %s, ignoring: %s",
- m->where, timeout);
- return r;
- }
-
- SET_FOREACH(other, UNIT(m)->dependencies[UNIT_AFTER], i) {
- if (other->type != UNIT_DEVICE)
- continue;
-
- other->job_timeout = u;
- }
-
- return 0;
-}
-
static int mount_verify(Mount *m) {
_cleanup_free_ char *e = NULL;
bool b;
b = unit_has_name(UNIT(m), e);
if (!b) {
- log_error_unit(UNIT(m)->id, "%s's Where= setting doesn't match unit name. Refusing.", UNIT(m)->id);
+ log_unit_error(UNIT(m)->id, "%s's Where= setting doesn't match unit name. Refusing.", UNIT(m)->id);
return -EINVAL;
}
if (mount_point_is_api(m->where) || mount_point_ignore(m->where)) {
- log_error_unit(UNIT(m)->id, "Cannot create mount unit for API file system %s. Refusing.", m->where);
+ log_unit_error(UNIT(m)->id, "Cannot create mount unit for API file system %s. Refusing.", m->where);
return -EINVAL;
}
if (UNIT(m)->fragment_path && !m->parameters_fragment.what) {
- log_error_unit(UNIT(m)->id, "%s's What setting is missing. Refusing.", UNIT(m)->id);
+ log_unit_error(UNIT(m)->id, "%s's What setting is missing. Refusing.", UNIT(m)->id);
return -EBADMSG;
}
if (m->exec_context.pam_name && m->kill_context.kill_mode != KILL_CONTROL_GROUP) {
- log_error_unit(UNIT(m)->id, "%s has PAM enabled. Kill mode must be set to control-group'. Refusing.",UNIT(m)->id);
+ log_unit_error(UNIT(m)->id, "%s has PAM enabled. Kill mode must be set to control-group'. Refusing.",UNIT(m)->id);
return -EINVAL;
}
path_kill_slashes(m->where);
- r = unit_add_exec_dependencies(u, &m->exec_context);
- if (r < 0)
- return r;
-
if (!u->description) {
r = unit_set_description(u, m->where);
if (r < 0)
if (r < 0)
return r;
- if (u->default_dependencies) {
- r = mount_add_default_dependencies(m);
- if (r < 0)
- return r;
- }
-
- r = unit_add_default_slice(u);
+ r = unit_patch_contexts(u);
if (r < 0)
return r;
- r = mount_fix_timeouts(m);
+ r = unit_add_exec_dependencies(u, &m->exec_context);
if (r < 0)
return r;
- r = unit_exec_context_defaults(u, &m->exec_context);
+ r = unit_add_default_slice(u, &m->cgroup_context);
if (r < 0)
return r;
+ if (u->default_dependencies) {
+ r = mount_add_default_dependencies(m);
+ if (r < 0)
+ return r;
+ }
+
return 0;
}
}
if (state != old_state)
- log_debug_unit(UNIT(m)->id,
+ log_unit_debug(UNIT(m)->id,
"%s changed %s -> %s",
UNIT(m)->id,
mount_state_to_string(old_state),
static int mount_spawn(Mount *m, ExecCommand *c, pid_t *_pid) {
pid_t pid;
int r;
+ ExecParameters exec_params = {
+ .apply_permissions = true,
+ .apply_chroot = true,
+ .apply_tty_stdin = true,
+ };
assert(m);
assert(c);
if (r < 0)
goto fail;
+ exec_params.environment = UNIT(m)->manager->environment;
+ exec_params.confirm_spawn = UNIT(m)->manager->confirm_spawn;
+ exec_params.cgroup_supported = UNIT(m)->manager->cgroup_supported;
+ exec_params.cgroup_path = UNIT(m)->cgroup_path;
+ exec_params.cgroup_delegate = m->cgroup_context.delegate;
+ exec_params.runtime_prefix = manager_get_runtime_prefix(UNIT(m)->manager);
+ exec_params.unit_id = UNIT(m)->id;
+
r = exec_spawn(c,
- NULL,
&m->exec_context,
- NULL, 0,
- UNIT(m)->manager->environment,
- true,
- true,
- true,
- UNIT(m)->manager->confirm_spawn,
- UNIT(m)->manager->cgroup_supported,
- UNIT(m)->cgroup_path,
- UNIT(m)->id,
- 0,
- NULL,
+ &exec_params,
m->exec_runtime,
&pid);
if (r < 0)
exec_runtime_destroy(m->exec_runtime);
m->exec_runtime = exec_runtime_unref(m->exec_runtime);
+ exec_context_destroy_runtime_directory(&m->exec_context, manager_get_runtime_prefix(UNIT(m)->manager));
+
mount_set_state(m, m->result != MOUNT_SUCCESS ? MOUNT_FAILED : MOUNT_DEAD);
}
r = unit_kill_context(
UNIT(m),
&m->kill_context,
- state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM,
+ (state != MOUNT_MOUNTING_SIGTERM && state != MOUNT_UNMOUNTING_SIGTERM && state != MOUNT_REMOUNTING_SIGTERM) ?
+ KILL_KILL : KILL_TERMINATE,
-1,
m->control_pid,
false);
return;
fail:
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s failed to kill processes: %s", UNIT(m)->id, strerror(-r));
if (state == MOUNT_REMOUNTING_SIGTERM || state == MOUNT_REMOUNTING_SIGKILL)
}
void warn_if_dir_nonempty(const char *unit, const char* where) {
+ int r;
+
assert(unit);
assert(where);
- if (dir_is_empty(where) > 0)
+ r = dir_is_empty(where);
+ if (r > 0)
return;
+ else if (r == 0)
+ log_unit_struct(unit,
+ LOG_NOTICE,
+ LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
+ LOG_MESSAGE("%s: Directory %s to mount over is not empty, mounting anyway.",
+ unit, where),
+ "WHERE=%s", where,
+ NULL);
+ else
+ log_unit_warning(unit,
+ "MESSAGE=Failed to check directory %s: %s",
+ where, strerror(-r));
+}
+
+static int fail_if_symlink(const char *unit, const char* where) {
+ assert(where);
+
+ if (is_symlink(where) > 0) {
+ log_unit_struct(unit,
+ LOG_ERR,
+ LOG_MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
+ LOG_MESSAGE("%s: Mount on symlink %s not allowed.",
+ unit, where),
+ "WHERE=%s", where,
+ NULL);
- log_struct_unit(LOG_NOTICE,
- unit,
- "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
- unit, where,
- "WHERE=%s", where,
- MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
- NULL);
+ return -ELOOP;
+ }
+ return 0;
}
static void mount_enter_unmounting(Mount *m) {
assert(m);
+ /* Start counting our attempts */
+ if (!IN_SET(m->state,
+ MOUNT_UNMOUNTING,
+ MOUNT_UNMOUNTING_SIGTERM,
+ MOUNT_UNMOUNTING_SIGKILL))
+ m->n_retry_umount = 0;
+
m->control_command_id = MOUNT_EXEC_UNMOUNT;
m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
- if ((r = exec_command_set(
- m->control_command,
- "/bin/umount",
- m->where,
- NULL)) < 0)
+ r = exec_command_set(m->control_command, "/bin/umount", m->where, NULL);
+ if (r >= 0 && UNIT(m)->manager->running_as == SYSTEMD_SYSTEM)
+ r = exec_command_append(m->control_command, "-n", NULL);
+ if (r < 0)
goto fail;
mount_unwatch_control_pid(m);
- if ((r = mount_spawn(m, m->control_command, &m->control_pid)) < 0)
+ r = mount_spawn(m, m->control_command, &m->control_pid);
+ if (r < 0)
goto fail;
mount_set_state(m, MOUNT_UNMOUNTING);
return;
fail:
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s failed to run 'umount' task: %s",
UNIT(m)->id, strerror(-r));
mount_enter_mounted(m, MOUNT_FAILURE_RESOURCES);
if (p && mount_is_bind(p))
mkdir_p_label(p->what, m->directory_mode);
- if (m->from_fragment)
- r = exec_command_set(
- m->control_command,
- "/bin/mount",
- m->parameters_fragment.what,
- m->where,
- "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
- m->parameters_fragment.options ? "-o" : NULL, m->parameters_fragment.options,
- NULL);
- else
+ r = fail_if_symlink(m->meta.id, m->where);
+ if (r < 0)
+ goto fail;
+
+ if (m->from_fragment) {
+ _cleanup_free_ char *opts = NULL;
+
+ r = fstab_filter_options(m->parameters_fragment.options,
+ "nofail\0" "noauto\0" "auto\0", NULL, NULL, &opts);
+ if (r < 0)
+ goto fail;
+
+ r = exec_command_set(m->control_command, "/bin/mount",
+ m->parameters_fragment.what, m->where, NULL);
+ if (r >= 0 && UNIT(m)->manager->running_as == SYSTEMD_SYSTEM)
+ r = exec_command_append(m->control_command, "-n", NULL);
+ if (r >= 0 && m->sloppy_options)
+ r = exec_command_append(m->control_command, "-s", NULL);
+ if (r >= 0 && m->parameters_fragment.fstype)
+ r = exec_command_append(m->control_command, "-t", m->parameters_fragment.fstype, NULL);
+ if (r >= 0 && !isempty(opts))
+ r = exec_command_append(m->control_command, "-o", opts, NULL);
+ } else
r = -ENOENT;
if (r < 0)
return;
fail:
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s failed to run 'mount' task: %s",
UNIT(m)->id, strerror(-r));
mount_enter_dead(m, MOUNT_FAILURE_RESOURCES);
const char *o;
if (m->parameters_fragment.options)
- o = strappenda("remount,", m->parameters_fragment.options);
+ o = strjoina("remount,", m->parameters_fragment.options);
else
o = "remount";
- r = exec_command_set(
- m->control_command,
- "/bin/mount",
- m->parameters_fragment.what,
- m->where,
- "-t", m->parameters_fragment.fstype ? m->parameters_fragment.fstype : "auto",
- "-o", o,
- NULL);
+ r = exec_command_set(m->control_command, "/bin/mount",
+ m->parameters_fragment.what, m->where,
+ "-o", o, NULL);
+ if (r >= 0 && UNIT(m)->manager->running_as == SYSTEMD_SYSTEM)
+ r = exec_command_append(m->control_command, "-n", NULL);
+ if (r >= 0 && m->sloppy_options)
+ r = exec_command_append(m->control_command, "-s", NULL);
+ if (r >= 0 && m->parameters_fragment.fstype)
+ r = exec_command_append(m->control_command, "-t", m->parameters_fragment.fstype, NULL);
} else
r = -ENOENT;
return;
fail:
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s failed to run 'remount' task: %s",
UNIT(m)->id, strerror(-r));
m->reload_result = MOUNT_FAILURE_RESOURCES;
m->reload_result = MOUNT_SUCCESS;
mount_enter_mounting(m);
- return 0;
+ return 1;
}
static int mount_stop(Unit *u) {
m->state == MOUNT_REMOUNTING_SIGKILL);
mount_enter_unmounting(m);
- return 0;
+ return 1;
}
static int mount_reload(Unit *u) {
MountState state;
if ((state = mount_state_from_string(value)) < 0)
- log_debug_unit(u->id, "Failed to parse state value %s", value);
+ log_unit_debug(u->id, "Failed to parse state value %s", value);
else
m->deserialized_state = state;
} else if (streq(key, "result")) {
f = mount_result_from_string(value);
if (f < 0)
- log_debug_unit(UNIT(m)->id,
+ log_unit_debug(UNIT(m)->id,
"Failed to parse result value %s", value);
else if (f != MOUNT_SUCCESS)
m->result = f;
f = mount_result_from_string(value);
if (f < 0)
- log_debug_unit(UNIT(m)->id,
+ log_unit_debug(UNIT(m)->id,
"Failed to parse reload result value %s", value);
else if (f != MOUNT_SUCCESS)
m->reload_result = f;
pid_t pid;
if (parse_pid(value, &pid) < 0)
- log_debug_unit(UNIT(m)->id,
+ log_unit_debug(UNIT(m)->id,
"Failed to parse control-pid value %s", value);
else
m->control_pid = pid;
MountExecCommand id;
if ((id = mount_exec_command_from_string(value)) < 0)
- log_debug_unit(UNIT(m)->id,
+ log_unit_debug(UNIT(m)->id,
"Failed to parse exec-command value %s", value);
else {
m->control_command_id = id;
m->control_command = m->exec_command + id;
}
} else
- log_debug_unit(UNIT(m)->id,
+ log_unit_debug(UNIT(m)->id,
"Unknown serialization key '%s'", key);
return 0;
m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
}
- log_full_unit(f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE, u->id,
+ log_unit_full(u->id,
+ f == MOUNT_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
"%s mount process exited, code=%s status=%i",
u->id, sigchld_code_to_string(code), status);
case MOUNT_UNMOUNTING_SIGKILL:
case MOUNT_UNMOUNTING_SIGTERM:
- if (f == MOUNT_SUCCESS)
- mount_enter_dead(m, f);
- else if (m->from_proc_self_mountinfo)
+ if (f == MOUNT_SUCCESS) {
+
+ if (m->from_proc_self_mountinfo) {
+
+ /* Still a mount point? If so, let's
+ * try again. Most likely there were
+ * multiple mount points stacked on
+ * top of each other. Note that due to
+ * the io event priority logic we can
+ * be sure the new mountinfo is loaded
+ * before we process the SIGCHLD for
+ * the mount command. */
+
+ if (m->n_retry_umount < RETRY_UMOUNT_MAX) {
+ log_unit_debug(u->id, "%s: mount still present, trying again.", u->id);
+ m->n_retry_umount++;
+ mount_enter_unmounting(m);
+ } else {
+ log_unit_debug(u->id, "%s: mount still present after %u attempts to unmount, giving up.", u->id, m->n_retry_umount);
+ mount_enter_mounted(m, f);
+ }
+ } else
+ mount_enter_dead(m, f);
+
+ } else if (m->from_proc_self_mountinfo)
mount_enter_mounted(m, f);
else
mount_enter_dead(m, f);
case MOUNT_MOUNTING:
case MOUNT_MOUNTING_DONE:
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s mounting timed out. Stopping.", UNIT(m)->id);
mount_enter_signal(m, MOUNT_MOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
break;
case MOUNT_REMOUNTING:
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s remounting timed out. Stopping.", UNIT(m)->id);
m->reload_result = MOUNT_FAILURE_TIMEOUT;
mount_enter_mounted(m, MOUNT_SUCCESS);
break;
case MOUNT_UNMOUNTING:
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s unmounting timed out. Stopping.", UNIT(m)->id);
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
break;
case MOUNT_MOUNTING_SIGTERM:
if (m->kill_context.send_sigkill) {
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s mounting timed out. Killing.", UNIT(m)->id);
mount_enter_signal(m, MOUNT_MOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
} else {
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s mounting timed out. Skipping SIGKILL. Ignoring.",
UNIT(m)->id);
case MOUNT_REMOUNTING_SIGTERM:
if (m->kill_context.send_sigkill) {
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s remounting timed out. Killing.", UNIT(m)->id);
mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
} else {
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s remounting timed out. Skipping SIGKILL. Ignoring.",
UNIT(m)->id);
case MOUNT_UNMOUNTING_SIGTERM:
if (m->kill_context.send_sigkill) {
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s unmounting timed out. Killing.", UNIT(m)->id);
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
} else {
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s unmounting timed out. Skipping SIGKILL. Ignoring.",
UNIT(m)->id);
case MOUNT_MOUNTING_SIGKILL:
case MOUNT_REMOUNTING_SIGKILL:
case MOUNT_UNMOUNTING_SIGKILL:
- log_warning_unit(UNIT(m)->id,
+ log_unit_warning(UNIT(m)->id,
"%s mount process still around after SIGKILL. Ignoring.",
UNIT(m)->id);
_cleanup_free_ char *e = NULL, *w = NULL, *o = NULL, *f = NULL;
bool load_extras = false;
MountParameters *p;
- bool delete;
+ bool delete, changed = false;
Unit *u;
int r;
goto fail;
}
-
if (m->running_as == SYSTEMD_SYSTEM) {
const char* target;
- target = fstype_is_network(fstype) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
-
+ target = mount_needs_network(options, fstype) ? SPECIAL_REMOTE_FS_TARGET : SPECIAL_LOCAL_FS_TARGET;
r = unit_add_dependency_by_name(u, UNIT_BEFORE, target, NULL, true);
if (r < 0)
goto fail;
}
unit_add_to_load_queue(u);
+ changed = true;
} else {
delete = false;
}
}
+ if (m->running_as == SYSTEMD_SYSTEM &&
+ mount_needs_network(options, fstype)) {
+ /* _netdev option may have shown up late, or on a
+ * remount. Add remote-fs dependencies, even though
+ * local-fs ones may already be there. */
+ unit_add_dependency_by_name(u, UNIT_BEFORE, SPECIAL_REMOTE_FS_TARGET, NULL, true);
+ load_extras = true;
+ }
+
if (u->load_state == UNIT_NOT_FOUND) {
u->load_state = UNIT_LOADED;
u->load_error = 0;
/* Load in the extras later on, after we
* finished initialization of the unit */
load_extras = true;
+ changed = true;
}
}
- if (!(w = strdup(what)) ||
- !(o = strdup(options)) ||
- !(f = strdup(fstype))) {
+ w = strdup(what);
+ o = strdup(options);
+ f = strdup(fstype);
+ if (!w || !o || !f) {
r = -ENOMEM;
goto fail;
}
p = &MOUNT(u)->parameters_proc_self_mountinfo;
+
+ changed = changed ||
+ !streq_ptr(p->options, options) ||
+ !streq_ptr(p->what, what) ||
+ !streq_ptr(p->fstype, fstype);
+
if (set_flags) {
MOUNT(u)->is_mounted = true;
MOUNT(u)->just_mounted = !MOUNT(u)->from_proc_self_mountinfo;
- MOUNT(u)->just_changed = !streq_ptr(p->options, o);
+ MOUNT(u)->just_changed = changed;
}
MOUNT(u)->from_proc_self_mountinfo = true;
goto fail;
}
- unit_add_to_dbus_queue(u);
+ if (changed)
+ unit_add_to_dbus_queue(u);
return 0;
}
static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
+ _cleanup_(mnt_free_tablep) struct libmnt_table *tb = NULL;
+ _cleanup_(mnt_free_iterp) struct libmnt_iter *itr = NULL;
+ struct libmnt_fs *fs;
int r = 0;
- unsigned i;
assert(m);
- rewind(m->proc_self_mountinfo);
+ tb = mnt_new_table();
+ itr = mnt_new_iter(MNT_ITER_FORWARD);
+ if (!tb || !itr)
+ return log_oom();
- for (i = 1;; i++) {
- _cleanup_free_ char *device = NULL, *path = NULL, *options = NULL, *options2 = NULL, *fstype = NULL, *d = NULL, *p = NULL, *o = NULL;
+ r = mnt_table_parse_mtab(tb, NULL);
+ if (r < 0)
+ return r;
+
+ r = 0;
+ for (;;) {
+ const char *device, *path, *options, *fstype;
+ _cleanup_free_ const char *d = NULL, *p = NULL;
int k;
- k = fscanf(m->proc_self_mountinfo,
- "%*s " /* (1) mount id */
- "%*s " /* (2) parent id */
- "%*s " /* (3) major:minor */
- "%*s " /* (4) root */
- "%ms " /* (5) mount point */
- "%ms" /* (6) mount options */
- "%*[^-]" /* (7) optional fields */
- "- " /* (8) separator */
- "%ms " /* (9) file system type */
- "%ms" /* (10) mount source */
- "%ms" /* (11) mount options 2 */
- "%*[^\n]", /* some rubbish at the end */
- &path,
- &options,
- &fstype,
- &device,
- &options2);
-
- if (k == EOF)
+ k = mnt_table_next_fs(tb, itr, &fs);
+ if (k == 1)
break;
+ else if (k < 0)
+ return log_error_errno(k, "Failed to get next entry from /etc/fstab: %m");
- if (k != 5) {
- log_warning("Failed to parse /proc/self/mountinfo:%u.", i);
- continue;
- }
-
- o = strjoin(options, ",", options2, NULL);
- if (!o)
- return log_oom();
+ device = mnt_fs_get_source(fs);
+ path = mnt_fs_get_target(fs);
+ options = mnt_fs_get_options(fs);
+ fstype = mnt_fs_get_fstype(fs);
d = cunescape(device);
p = cunescape(path);
if (!d || !p)
return log_oom();
- k = mount_add_one(m, d, p, o, fstype, set_flags);
- if (k < 0)
+ k = mount_add_one(m, d, p, options, fstype, set_flags);
+ if (r == 0 && k < 0)
r = k;
}
assert(m);
m->mount_event_source = sd_event_source_unref(m->mount_event_source);
+ m->mount_utab_event_source = sd_event_source_unref(m->mount_utab_event_source);
if (m->proc_self_mountinfo) {
fclose(m->proc_self_mountinfo);
m->proc_self_mountinfo = NULL;
}
+ m->utab_inotify_fd = safe_close(m->utab_inotify_fd);
}
static int mount_get_timeout(Unit *u, uint64_t *timeout) {
int r;
assert(m);
+ mnt_init_debug(0);
+
if (!m->proc_self_mountinfo) {
m->proc_self_mountinfo = fopen("/proc/self/mountinfo", "re");
if (!m->proc_self_mountinfo)
return -errno;
- r = sd_event_add_io(m->event, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m, &m->mount_event_source);
+ r = sd_event_add_io(m->event, &m->mount_event_source, fileno(m->proc_self_mountinfo), EPOLLPRI, mount_dispatch_io, m);
if (r < 0)
goto fail;
goto fail;
}
+ if (m->utab_inotify_fd < 0) {
+ m->utab_inotify_fd = inotify_init1(IN_NONBLOCK|IN_CLOEXEC);
+ if (m->utab_inotify_fd < 0) {
+ r = -errno;
+ goto fail;
+ }
+
+ (void) mkdir_p_label("/run/mount", 0755);
+
+ r = inotify_add_watch(m->utab_inotify_fd, "/run/mount", IN_MOVED_TO);
+ if (r < 0) {
+ r = -errno;
+ goto fail;
+ }
+
+ r = sd_event_add_io(m->event, &m->mount_utab_event_source, m->utab_inotify_fd, EPOLLIN, mount_dispatch_io, m);
+ if (r < 0)
+ goto fail;
+
+ r = sd_event_source_set_priority(m->mount_utab_event_source, -10);
+ if (r < 0)
+ goto fail;
+ }
+
r = mount_load_proc_self_mountinfo(m, false);
if (r < 0)
goto fail;
int r;
assert(m);
- assert(revents & EPOLLPRI);
+ assert(revents & (EPOLLPRI | EPOLLIN));
/* The manager calls this for every fd event happening on the
* /proc/self/mountinfo file, which informs us about mounting
- * table changes */
+ * table changes, and for /run/mount events which we watch
+ * for mount options. */
+
+ if (fd == m->utab_inotify_fd) {
+ bool rescan = false;
+
+ /* FIXME: We *really* need to replace this with
+ * libmount's own API for this, we should not hardcode
+ * internal behaviour of libmount here. */
+
+ for (;;) {
+ union inotify_event_buffer buffer;
+ struct inotify_event *e;
+ ssize_t l;
+
+ l = read(fd, &buffer, sizeof(buffer));
+ if (l < 0) {
+ if (errno == EAGAIN || errno == EINTR)
+ break;
+
+ log_error_errno(errno, "Failed to read utab inotify: %m");
+ break;
+ }
+
+ FOREACH_INOTIFY_EVENT(e, buffer, l) {
+ /* Only care about changes to utab,
+ * but we have to monitor the
+ * directory to reliably get
+ * notifications about when utab is
+ * replaced using rename(2) */
+ if ((e->mask & IN_Q_OVERFLOW) || streq(e->name, "utab"))
+ rescan = true;
+ }
+ }
+
+ if (!rescan)
+ return 0;
+ }
r = mount_load_proc_self_mountinfo(m, true);
if (r < 0) {
- log_error("Failed to reread /proc/self/mountinfo: %s", strerror(-r));
+ log_error_errno(r, "Failed to reread /proc/self/mountinfo: %m");
/* Reset flags, just in case, for later calls */
LIST_FOREACH(units_by_type, u, m->units_by_type[UNIT_MOUNT]) {
Mount *mount = MOUNT(u);
if (!mount->is_mounted) {
- /* This has just been unmounted. */
mount->from_proc_self_mountinfo = false;
switch (mount->state) {
case MOUNT_MOUNTED:
+ /* This has just been unmounted by
+ * somebody else, follow the state
+ * change. */
mount_enter_dead(mount, MOUNT_SUCCESS);
break;
default:
- mount_set_state(mount, mount->state);
break;
-
}
} else if (mount->just_mounted || mount->just_changed) {
case MOUNT_DEAD:
case MOUNT_FAILED:
+ /* This has just been mounted by
+ * somebody else, follow the state
+ * change. */
mount_enter_mounted(mount, MOUNT_SUCCESS);
break;
.get_timeout = mount_get_timeout,
+ .can_transient = true,
+
.enumerate = mount_enumerate,
.shutdown = mount_shutdown,
~ianmdlvl / elogind.git / blobdiff