#include <mntent.h>
#include <sys/epoll.h>
#include <signal.h>
+#include <libmount.h>
+#include <sys/inotify.h>
#include "manager.h"
#include "unit.h"
#include "unit-name.h"
#include "dbus-mount.h"
#include "special.h"
-#include "bus-errors.h"
+#include "bus-common-errors.h"
#include "exit-status.h"
#include "def.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,
[MOUNT_MOUNTING] = UNIT_ACTIVATING,
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 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 (mount_test_option(options, "_netdev"))
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);
+
+ return mount_needs_network(p->options, p->fstype);
+}
+
+static bool mount_is_bind(const MountParameters *p) {
assert(p);
if (mount_test_option(p->options, "bind"))
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");
}
-static bool needs_quota(MountParameters *p) {
+static bool needs_quota(const MountParameters *p) {
assert(p);
if (mount_is_network(p))
if (r > 0)
return;
else if (r == 0)
- log_unit_struct(LOG_NOTICE,
- unit,
- "MESSAGE=%s: Directory %s to mount over is not empty, mounting anyway.",
- unit, where,
+ 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,
- MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
NULL);
else
log_unit_warning(unit,
assert(where);
if (is_symlink(where) > 0) {
- log_unit_struct(LOG_WARNING,
- unit,
- "MESSAGE=%s: Mount on symlink %s not allowed.",
- unit, where,
+ 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,
- MESSAGE_ID(SD_MESSAGE_OVERMOUNTING),
NULL);
return -ELOOP;
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,
+ r = exec_command_set(m->control_command,
"/bin/umount",
"-n",
m->where,
- NULL)) < 0)
+ 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);
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);
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;
}
}
+ 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;
}
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)
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 (;;) {
+ uint8_t buffer[INOTIFY_EVENT_MAX] _alignas_(struct inotify_event);
+ 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]) {
~ianmdlvl / elogind.git / blobdiff