HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/core/mount.c
Git blob: c05df5d10cff84a1ed7414c2a7c520c6e0845fdb
Lines 1001–2000 of 2,581
}
static int mount_set_umount_command(Mount *m, ExecCommand *c) {
int r;
assert(m);
assert(c);
r = exec_command_set(c, UMOUNT_PATH, m->where, "-c", NULL);
if (r < 0)
return r;
if (m->lazy_unmount) {
r = exec_command_append(c, "-l", NULL);
if (r < 0)
return r;
}
if (m->force_unmount) {
r = exec_command_append(c, "-f", NULL);
if (r < 0)
return r;
}
return 0;
}
static void mount_enter_unmounting(Mount *m) {
int r;
assert(m);
/* Start counting our attempts */
if (!IN_SET(m->state,
MOUNT_UNMOUNTING,
MOUNT_UNMOUNTING_SIGTERM,
MOUNT_UNMOUNTING_SIGKILL))
m->n_retry_umount = 0;
mount_unwatch_control_pid(m);
m->control_command_id = MOUNT_EXEC_UNMOUNT;
m->control_command = m->exec_command + MOUNT_EXEC_UNMOUNT;
r = mount_set_umount_command(m, m->control_command);
if (r < 0) {
log_unit_warning_errno(UNIT(m), r, "Failed to prepare umount command line: %m");
goto fail;
}
r = mount_spawn(m, m->control_command, mount_exec_flags(MOUNT_UNMOUNTING), &m->control_pid);
if (r < 0) {
log_unit_warning_errno(UNIT(m), r, "Failed to spawn 'umount' task: %m");
goto fail;
}
mount_set_state(m, MOUNT_UNMOUNTING);
return;
fail:
mount_enter_dead_or_mounted(m, MOUNT_FAILURE_RESOURCES, /* flush_result= */ false);
}
static int mount_apply_graceful_options(Mount *m, const MountParameters *p, char **opts) {
_cleanup_strv_free_ char **graceful = NULL;
_cleanup_free_ char *filtered = NULL;
int r;
assert(m);
assert(p);
assert(opts);
r = fstab_filter_options(*opts, "x-systemd.graceful-option\0", NULL, NULL, &graceful, &filtered);
if (r <= 0)
return r;
if (!p->fstype) {
log_unit_warning(UNIT(m), "x-systemd.graceful-option= used but file system type not known, suppressing all graceful options.");
return 0;
}
STRV_FOREACH(o, graceful) {
_cleanup_free_ char *k = NULL, *v = NULL;
r = split_pair(*o, "=", &k, &v);
if (r < 0 && r != -EINVAL) /* EINVAL → not a key/value pair */
return r;
r = mount_option_supported(p->fstype, k ?: *o, v);
if (r == -EAGAIN) {
log_unit_warning_errno(UNIT(m), r,
"x-systemd.graceful-option= used but not supported by file system %s, suppressing all.",
p->fstype);
break;
}
if (r < 0)
log_unit_warning_errno(UNIT(m), r,
"x-systemd.graceful-option=%s specified, but cannot determine availability, suppressing: %m", *o);
else if (r == 0)
log_unit_info(UNIT(m), "x-systemd.graceful-option=%s specified, but option is not available, suppressing.", *o);
else {
log_unit_debug(UNIT(m), "x-systemd.graceful-option=%s specified and supported, appending to mount option string.", *o);
if (!strextend_with_separator(&filtered, ",", *o))
return -ENOMEM;
}
}
return free_and_replace(*opts, filtered);
}
static int mount_set_mount_command(Mount *m, ExecCommand *c, const MountParameters *p, bool remount) {
int r;
assert(m);
assert(c);
assert(p);
r = exec_command_set(c, MOUNT_PATH, p->what, m->where, NULL);
if (r < 0)
return r;
if (m->sloppy_options) {
r = exec_command_append(c, "-s", NULL);
if (r < 0)
return r;
}
if (m->read_write_only) {
r = exec_command_append(c, "-w", NULL);
if (r < 0)
return r;
}
if (p->fstype) {
r = exec_command_append(c, "-t", p->fstype, NULL);
if (r < 0)
return r;
}
_cleanup_free_ char *opts = NULL;
r = fstab_filter_options(p->options, "nofail\0" "fail\0" "noauto\0" "auto\0", NULL, NULL, NULL, &opts);
if (r < 0)
return r;
r = mount_apply_graceful_options(m, p, &opts);
if (r < 0)
return r;
if (remount)
if (!strprepend_with_separator(&opts, ",", "remount"))
return -ENOMEM;
if (!isempty(opts)) {
r = exec_command_append(c, "-o", opts, NULL);
if (r < 0)
return r;
}
return 0;
}
static void mount_enter_mounting(Mount *m) {
_cleanup_close_ int fd = -EBADF;
_cleanup_free_ char *fn = NULL;
int r;
assert(m);
/* Validate that the path we are overmounting does not contain any symlinks, because if it does, we
* couldn't support that reasonably: the mounts in /proc/self/mountinfo would not be recognizable to
* us anymore. */
fd = chase_and_open_parent(m->where, /* root= */ NULL, CHASE_PROHIBIT_SYMLINKS|CHASE_MKDIR_0755|CHASE_TRIGGER_AUTOFS, &fn);
if (fd == -ELOOP) {
r = unit_log_noncanonical_mount_path(UNIT(m), m->where);
goto fail;
}
if (fd < 0) {
log_unit_error_errno(UNIT(m), fd, "Failed to resolve parent of mount point '%s': %m", m->where);
goto fail;
}
MountParameters *p = get_mount_parameters_fragment(m);
if (!p) {
r = log_unit_warning_errno(UNIT(m), SYNTHETIC_ERRNO(ENOENT), "No mount parameters to operate on.");
goto fail;
}
bool source_is_dir = true;
if (mount_is_bind(p)) {
r = is_dir(p->what, /* follow= */ true);
if (r < 0 && r != -ENOENT)
log_unit_info_errno(UNIT(m), r, "Failed to determine type of bind mount source '%s', ignoring: %m", p->what);
else if (r == 0)
source_is_dir = false;
}
r = make_mount_point_inode_from_mode(
fd,
fn,
source_is_dir ? S_IFDIR : S_IFREG,
m->directory_mode);
if (r < 0 && r != -EEXIST)
log_unit_warning_errno(UNIT(m), r, "Failed to create mount point '%s', ignoring: %m", m->where);
/* If we are asked to create an OverlayFS, create the upper/work directories if they are missing */
if (streq_ptr(p->fstype, "overlay")) {
_cleanup_strv_free_ char **dirs = NULL;
r = fstab_filter_options(
p->options,
"upperdir\0workdir\0",
/* ret_namefound= */ NULL,
/* ret_value= */ NULL,
&dirs,
/* ret_filtered= */ NULL);
if (r < 0)
log_unit_warning_errno(
UNIT(m),
r,
"Failed to determine upper directory for OverlayFS, ignoring: %m");
else
STRV_FOREACH(d, dirs) {
r = mkdir_p_label(*d, m->directory_mode);
if (r < 0 && r != -EEXIST)
log_unit_warning_errno(
UNIT(m),
r,
"Failed to create overlay directory '%s', ignoring: %m",
*d);
}
}
if (source_is_dir)
unit_warn_if_dir_nonempty(UNIT(m), m->where);
/* Create the source directory for bind-mounts if needed */
if (mount_is_bind(p)) {
r = mkdir_p_label(p->what, m->directory_mode);
/* mkdir_p_label() can return -EEXIST if the target path exists and is not a directory - which is
* totally OK, in case the user wants us to overmount a non-directory inode. Also -EROFS can be
* returned on read-only filesystem. Moreover, -EACCES (and also maybe -EPERM?) may be returned
* when the path is on NFS. See issue #24120. All such errors will be logged in the debug level. */
if (r < 0 && r != -EEXIST)
log_unit_full_errno(UNIT(m),
ERRNO_IS_NEG_FS_WRITE_REFUSED(r) ? LOG_DEBUG : LOG_WARNING,
r, "Failed to make bind mount source '%s', ignoring: %m", p->what);
}
mount_unwatch_control_pid(m);
unit_warn_leftover_processes(UNIT(m), /* start= */ true);
m->control_command_id = MOUNT_EXEC_MOUNT;
m->control_command = m->exec_command + MOUNT_EXEC_MOUNT;
r = mount_set_mount_command(m, m->control_command, p, /* remount= */ false);
if (r < 0) {
log_unit_error_errno(UNIT(m), r, "Failed to prepare mount command line: %m");
goto fail;
}
r = mount_spawn(m, m->control_command, mount_exec_flags(MOUNT_MOUNTING), &m->control_pid);
if (r < 0) {
log_unit_warning_errno(UNIT(m), r, "Failed to spawn 'mount' task: %m");
goto fail;
}
mount_set_state(m, MOUNT_MOUNTING);
return;
fail:
mount_enter_dead_or_mounted(m, MOUNT_FAILURE_RESOURCES, /* flush_result= */ false);
}
static void mount_set_reload_result(Mount *m, MountResult result) {
assert(m);
/* Only store the first error we encounter */
if (m->reload_result != MOUNT_SUCCESS)
return;
m->reload_result = result;
}
static void mount_enter_remounting(Mount *m) {
MountParameters *p;
int r;
assert(m);
p = get_mount_parameters_fragment(m);
if (!p) {
r = log_unit_warning_errno(UNIT(m), SYNTHETIC_ERRNO(ENOENT), "No mount parameters to operate on.");
goto fail;
}
mount_unwatch_control_pid(m);
m->reload_result = MOUNT_SUCCESS;
m->control_command_id = MOUNT_EXEC_REMOUNT;
m->control_command = m->exec_command + MOUNT_EXEC_REMOUNT;
r = mount_set_mount_command(m, m->control_command, p, /* remount= */ true);
if (r < 0) {
log_unit_error_errno(UNIT(m), r, "Failed to prepare remount command line: %m");
goto fail;
}
r = mount_spawn(m, m->control_command, mount_exec_flags(MOUNT_REMOUNTING), &m->control_pid);
if (r < 0) {
log_unit_warning_errno(UNIT(m), r, "Failed to spawn 'remount' task: %m");
goto fail;
}
mount_set_state(m, MOUNT_REMOUNTING);
return;
fail:
mount_set_reload_result(m, MOUNT_FAILURE_RESOURCES);
mount_enter_dead_or_mounted(m, MOUNT_SUCCESS, /* flush_result= */ false);
}
static void mount_cycle_clear(Mount *m) {
assert(m);
/* Clear all state we shall forget for this new cycle */
m->result = MOUNT_SUCCESS;
m->reload_result = MOUNT_SUCCESS;
exec_command_reset_status_array(m->exec_command, _MOUNT_EXEC_COMMAND_MAX);
if (m->cgroup_runtime)
m->cgroup_runtime->reset_accounting = true;
}
static int mount_start(Unit *u) {
Mount *m = ASSERT_PTR(MOUNT(u));
int r;
assert(IN_SET(m->state, MOUNT_DEAD, MOUNT_FAILED));
r = unit_acquire_invocation_id(u);
if (r < 0)
return r;
mount_cycle_clear(m);
mount_enter_mounting(m);
return 1;
}
static int mount_stop(Unit *u) {
Mount *m = ASSERT_PTR(MOUNT(u));
int r;
switch (m->state) {
case MOUNT_UNMOUNTING:
case MOUNT_UNMOUNTING_SIGKILL:
case MOUNT_UNMOUNTING_SIGTERM:
/* Already on it */
return 0;
case MOUNT_MOUNTING:
case MOUNT_MOUNTING_DONE:
/* If we are still waiting for /bin/mount, we go directly into kill mode. */
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_SUCCESS);
return 0;
case MOUNT_REMOUNTING:
case MOUNT_REMOUNTING_SIGTERM:
assert(pidref_is_set(&m->control_pid));
r = pidref_kill_and_sigcont(&m->control_pid, SIGKILL);
if (r < 0)
log_unit_debug_errno(u, r,
"Failed to kill remount process " PID_FMT ", ignoring: %m",
m->control_pid.pid);
_fallthrough_;
case MOUNT_REMOUNTING_SIGKILL:
case MOUNT_MOUNTED:
mount_enter_unmounting(m);
return 1;
case MOUNT_CLEANING:
/* If we are currently cleaning, then abort it, brutally. */
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_SUCCESS);
return 0;
default:
assert_not_reached();
}
}
static int mount_reload(Unit *u) {
Mount *m = ASSERT_PTR(MOUNT(u));
assert(m->state == MOUNT_MOUNTED);
mount_enter_remounting(m);
return 1;
}
static bool mount_can_reload(Unit *u) {
Mount *m = ASSERT_PTR(MOUNT(u));
return get_mount_parameters_fragment(m);
}
static int mount_serialize(Unit *u, FILE *f, FDSet *fds) {
Mount *m = ASSERT_PTR(MOUNT(u));
assert(f);
assert(fds);
(void) serialize_item(f, "state", mount_state_to_string(m->state));
(void) serialize_item(f, "result", mount_result_to_string(m->result));
(void) serialize_item(f, "reload-result", mount_result_to_string(m->reload_result));
(void) serialize_item_format(f, "n-retry-umount", "%u", m->n_retry_umount);
(void) serialize_pidref(f, fds, "control-pid", &m->control_pid);
if (m->control_command_id >= 0)
(void) serialize_item(f, "control-command", mount_exec_command_to_string(m->control_command_id));
return 0;
}
static int mount_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
Mount *m = ASSERT_PTR(MOUNT(u));
int r;
assert(key);
assert(value);
assert(fds);
if (streq(key, "state")) {
MountState state;
state = mount_state_from_string(value);
if (state < 0)
log_unit_debug_errno(u, state, "Failed to parse state value: %s", value);
else
m->deserialized_state = state;
} else if (streq(key, "result")) {
MountResult f;
f = mount_result_from_string(value);
if (f < 0)
log_unit_debug_errno(u, f, "Failed to parse result value: %s", value);
else if (f != MOUNT_SUCCESS)
m->result = f;
} else if (streq(key, "reload-result")) {
MountResult f;
f = mount_result_from_string(value);
if (f < 0)
log_unit_debug_errno(u, f, "Failed to parse reload result value: %s", value);
else if (f != MOUNT_SUCCESS)
m->reload_result = f;
} else if (streq(key, "n-retry-umount")) {
r = safe_atou(value, &m->n_retry_umount);
if (r < 0)
log_unit_debug_errno(u, r, "Failed to parse n-retry-umount value: %s", value);
} else if (streq(key, "control-pid")) {
if (!pidref_is_set(&m->control_pid))
(void) deserialize_pidref(fds, value, &m->control_pid);
} else if (streq(key, "control-command")) {
MountExecCommand id;
id = mount_exec_command_from_string(value);
if (id < 0)
log_unit_debug_errno(u, id, "Failed to parse exec-command value: %s", value);
else {
m->control_command_id = id;
m->control_command = m->exec_command + id;
}
} else
log_unit_debug(u, "Unknown serialization key: %s", key);
return 0;
}
static UnitActiveState mount_active_state(Unit *u) {
Mount *m = ASSERT_PTR(MOUNT(u));
return state_translation_table[m->state];
}
static const char *mount_sub_state_to_string(Unit *u) {
Mount *m = ASSERT_PTR(MOUNT(u));
return mount_state_to_string(m->state);
}
static bool mount_may_gc(Unit *u) {
Mount *m = ASSERT_PTR(MOUNT(u));
if (m->from_proc_self_mountinfo)
return false;
return true;
}
static void mount_sigchld_event(Unit *u, pid_t pid, int code, int status) {
Mount *m = ASSERT_PTR(MOUNT(u));
MountResult f;
assert(pid >= 0);
if (pid != m->control_pid.pid)
return;
/* So here's the thing, we really want to know before /usr/bin/mount or /usr/bin/umount exit whether
* they established/remove a mount. This is important when mounting, but even more so when unmounting
* since we need to deal with nested mounts and otherwise cannot safely determine whether to repeat
* the unmounts. In theory, the kernel fires /proc/self/mountinfo changes off before returning from
* the mount() or umount() syscalls, and thus we should see the changes to the proc file before we
* process the waitid() for the /usr/bin/(u)mount processes. However, this is unfortunately racy: we
* have to waitid() for processes using P_ALL (since we need to reap unexpected children that got
* reparented to PID 1), but when using P_ALL we might end up reaping processes that terminated just
* instants ago, i.e. already after our last event loop iteration (i.e. after the last point we might
* have noticed /proc/self/mountinfo events via epoll). This means event loop priorities for
* processing SIGCHLD vs. /proc/self/mountinfo IO events are not as relevant as we want. To fix that
* race, let's explicitly scan /proc/self/mountinfo before we start processing /usr/bin/(u)mount
* dying. It's ugly, but it makes our ordering systematic again, and makes sure we always see
* /proc/self/mountinfo changes before our mount/umount exits. */
(void) mount_process_proc_self_mountinfo(u->manager);
pidref_done(&m->control_pid);
if (is_clean_exit(code, status, EXIT_CLEAN_COMMAND, NULL))
f = MOUNT_SUCCESS;
else if (code == CLD_EXITED)
f = MOUNT_FAILURE_EXIT_CODE;
else if (code == CLD_KILLED)
f = MOUNT_FAILURE_SIGNAL;
else if (code == CLD_DUMPED)
f = MOUNT_FAILURE_CORE_DUMP;
else
assert_not_reached();
if (IN_SET(m->state, MOUNT_REMOUNTING, MOUNT_REMOUNTING_SIGKILL, MOUNT_REMOUNTING_SIGTERM))
mount_set_reload_result(m, f);
else if (m->result == MOUNT_SUCCESS && !IN_SET(m->state, MOUNT_MOUNTING, MOUNT_UNMOUNTING))
/* MOUNT_MOUNTING and MOUNT_UNMOUNTING states need to be patched, see below. */
m->result = f;
if (m->control_command)
exec_status_exit(&m->control_command->exec_status, &m->exec_context, pid, code, status);
unit_log_process_exit(
u,
"Mount process",
mount_exec_command_to_string(m->control_command_id),
f == MOUNT_SUCCESS,
code, status);
m->control_command = NULL;
m->control_command_id = _MOUNT_EXEC_COMMAND_INVALID;
/* 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. */
switch (m->state) {
case MOUNT_MOUNTING:
/* Our mount point has not appeared in mountinfo. Something went wrong. */
if (f == MOUNT_SUCCESS) {
/* Either /bin/mount has an unexpected definition of success, or someone raced us
* and we lost. */
log_unit_warning(UNIT(m), "Mount process finished, but there is no mount.");
f = MOUNT_FAILURE_PROTOCOL;
}
mount_enter_dead(m, f, /* flush_result= */ false);
break;
case MOUNT_MOUNTING_DONE:
mount_enter_mounted(m, f);
break;
case MOUNT_REMOUNTING:
case MOUNT_REMOUNTING_SIGTERM:
case MOUNT_REMOUNTING_SIGKILL:
mount_enter_dead_or_mounted(m, MOUNT_SUCCESS, /* flush_result= */ false);
break;
case MOUNT_UNMOUNTING:
if (f == MOUNT_SUCCESS && 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. We might exceed the timeout specified by the user overall,
* but we will stop as soon as any one umount times out. */
if (m->n_retry_umount < RETRY_UMOUNT_MAX) {
log_unit_debug(u, "Mount still present, trying again.");
m->n_retry_umount++;
mount_enter_unmounting(m);
} else {
log_unit_warning(u, "Mount still present after %u attempts to unmount, giving up.", m->n_retry_umount);
mount_enter_mounted(m, MOUNT_FAILURE_PROTOCOL);
}
} else if (f == MOUNT_FAILURE_EXIT_CODE && !m->from_proc_self_mountinfo) {
/* Hmm, umount process spawned by us failed, but the mount disappeared anyway?
* Maybe someone else is trying to unmount at the same time. */
log_unit_notice(u, "Mount disappeared even though umount process failed, continuing.");
mount_enter_dead(m, MOUNT_SUCCESS, /* flush_result= */ true);
} else
/* At this point, either the unmount succeeded or unexpected error occurred. We usually
* remember the first error in 'result', but here let's update that forcibly, since
* there could previous failed attempts yet we only care about the most recent
* attempt. IOW, if we eventually managed to unmount the stuff, don't enter failed
* end state. */
mount_enter_dead_or_mounted(m, f, /* flush_result= */ true);
break;
case MOUNT_UNMOUNTING_SIGTERM:
case MOUNT_UNMOUNTING_SIGKILL:
mount_enter_dead_or_mounted(m, f, /* flush_result= */ false);
break;
case MOUNT_CLEANING:
if (m->clean_result == MOUNT_SUCCESS)
m->clean_result = f;
mount_enter_dead(m, MOUNT_SUCCESS, /* flush_result= */ false);
break;
default:
assert_not_reached();
}
/* Notify clients about changed exit status */
unit_add_to_dbus_queue(u);
}
static int mount_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
Mount *m = ASSERT_PTR(MOUNT(userdata));
assert(m->timer_event_source == source);
switch (m->state) {
case MOUNT_MOUNTING:
case MOUNT_MOUNTING_DONE:
log_unit_warning(UNIT(m), "Mounting timed out. Terminating.");
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
break;
case MOUNT_REMOUNTING:
log_unit_warning(UNIT(m), "Remounting timed out. Terminating remount process.");
mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
mount_enter_signal(m, MOUNT_REMOUNTING_SIGTERM, MOUNT_SUCCESS);
break;
case MOUNT_REMOUNTING_SIGTERM:
mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
if (m->kill_context.send_sigkill) {
log_unit_warning(UNIT(m), "Remounting timed out. Killing.");
mount_enter_signal(m, MOUNT_REMOUNTING_SIGKILL, MOUNT_SUCCESS);
} else {
log_unit_warning(UNIT(m), "Remounting timed out. Skipping SIGKILL. Ignoring.");
mount_enter_dead_or_mounted(m, MOUNT_SUCCESS, /* flush_result= */ false);
}
break;
case MOUNT_REMOUNTING_SIGKILL:
mount_set_reload_result(m, MOUNT_FAILURE_TIMEOUT);
log_unit_warning(UNIT(m), "Mount process still around after SIGKILL. Ignoring.");
mount_enter_dead_or_mounted(m, MOUNT_SUCCESS, /* flush_result= */ false);
break;
case MOUNT_UNMOUNTING:
log_unit_warning(UNIT(m), "Unmounting timed out. Terminating.");
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGTERM, MOUNT_FAILURE_TIMEOUT);
break;
case MOUNT_UNMOUNTING_SIGTERM:
if (m->kill_context.send_sigkill) {
log_unit_warning(UNIT(m), "Mount process timed out. Killing.");
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, MOUNT_FAILURE_TIMEOUT);
} else {
log_unit_warning(UNIT(m), "Mount process timed out. Skipping SIGKILL. Ignoring.");
mount_enter_dead_or_mounted(m, MOUNT_FAILURE_TIMEOUT, /* flush_result= */ false);
}
break;
case MOUNT_UNMOUNTING_SIGKILL:
log_unit_warning(UNIT(m), "Mount process still around after SIGKILL. Ignoring.");
mount_enter_dead_or_mounted(m, MOUNT_FAILURE_TIMEOUT, /* flush_result= */ false);
break;
case MOUNT_CLEANING:
log_unit_warning(UNIT(m), "Cleaning timed out. killing.");
if (m->clean_result == MOUNT_SUCCESS)
m->clean_result = MOUNT_FAILURE_TIMEOUT;
mount_enter_signal(m, MOUNT_UNMOUNTING_SIGKILL, 0);
break;
default:
assert_not_reached();
}
return 0;
}
#if HAVE_LIBMOUNT
static int update_parameters_proc_self_mountinfo(
Mount *m,
const char *what,
const char *options,
const char *fstype) {
MountParameters *p;
int r, q, w;
assert(m);
p = &m->parameters_proc_self_mountinfo;
r = free_and_strdup(&p->what, what);
if (r < 0)
return r;
q = free_and_strdup(&p->options, options);
if (q < 0)
return q;
w = free_and_strdup(&p->fstype, fstype);
if (w < 0)
return w;
return r > 0 || q > 0 || w > 0;
}
static int mount_setup_new_unit(
Manager *m,
const char *name,
const char *what,
const char *where,
const char *options,
const char *fstype,
MountProcFlags *ret_flags,
Unit **ret) {
_cleanup_(unit_freep) Unit *u = NULL;
Mount *mnt;
int r;
assert(m);
assert(name);
assert(ret_flags);
assert(ret);
r = unit_new_for_name(m, sizeof(Mount), name, &u);
if (r < 0)
return r;
mnt = ASSERT_PTR(MOUNT(u));
r = free_and_strdup(&u->source_path, "/proc/self/mountinfo");
if (r < 0)
return r;
r = free_and_strdup(&mnt->where, where);
if (r < 0)
return r;
r = update_parameters_proc_self_mountinfo(mnt, what, options, fstype);
if (r < 0)
return r;
/* This unit was generated because /proc/self/mountinfo reported it. Remember this, so that by the
* time we load the unit file for it (and thus add in extra deps right after) we know what source to
* attributes the deps to. */
mnt->from_proc_self_mountinfo = true;
/* We have only allocated the stub now, let's enqueue this unit for loading now, so that everything
* else is loaded in now. */
unit_add_to_load_queue(u);
*ret_flags = MOUNT_PROC_IS_MOUNTED | MOUNT_PROC_JUST_MOUNTED | MOUNT_PROC_JUST_CHANGED;
*ret = TAKE_PTR(u);
return 0;
}
static int mount_setup_existing_unit(
Unit *u,
const char *what,
const char *where,
const char *options,
const char *fstype,
MountProcFlags *ret_flags) {
Mount *m = ASSERT_PTR(MOUNT(u));
int r;
assert(u);
assert(where);
assert(ret_flags);
if (!m->where) {
m->where = strdup(where);
if (!m->where)
return -ENOMEM;
}
/* In case we have multiple mounts established on the same mount point, let's merge flags set already
* for the current unit. Note that the flags field is reset on each iteration of reading
* /proc/self/mountinfo, hence we know for sure anything already set here is from the current
* iteration and thus worthy of taking into account. */
MountProcFlags flags = m->proc_flags | MOUNT_PROC_IS_MOUNTED;
r = update_parameters_proc_self_mountinfo(m, what, options, fstype);
if (r < 0)
return r;
if (r > 0)
flags |= MOUNT_PROC_JUST_CHANGED;
/* There are two conditions when we consider a mount point just mounted: when we haven't seen it in
* /proc/self/mountinfo before or when MOUNT_MOUNTING is our current state. Why bother with the
* latter? Shouldn't that be covered by the former? No, during reload it is not because we might then
* encounter a new /proc/self/mountinfo in combination with an old mount unit state (since it stems
* from the serialized state), and need to catch up. Since we know that the MOUNT_MOUNTING state is
* reached when we wait for the mount to appear we hence can assume that if we are in it, we are
* actually seeing it established for the first time. */
if (!m->from_proc_self_mountinfo || m->state == MOUNT_MOUNTING)
flags |= MOUNT_PROC_JUST_MOUNTED;
m->from_proc_self_mountinfo = true;
if (UNIT_IS_LOAD_ERROR(u->load_state)) {
/* The unit was previously not found or otherwise not loaded. Now that the unit shows up in
* /proc/self/mountinfo we should reconsider that. Hence, let's reset the load state and load
* error, and add the unit to load queue. */
u->load_state = UNIT_STUB;
u->load_error = 0;
unit_add_to_load_queue(u);
flags |= MOUNT_PROC_JUST_CHANGED;
}
if (FLAGS_SET(flags, MOUNT_PROC_JUST_CHANGED) && u->load_state == UNIT_LOADED) {
/* If things changed, and we have successfully loaded the unit, then make sure that all deps
* are regenerated. Let's first remove all automatic deps, and then add in the new ones. */
r = mount_add_non_exec_dependencies(m);
if (r < 0)
return r;
}
*ret_flags = flags;
return 0;
}
static int mount_setup_unit(
Manager *m,
const char *what,
const char *where,
const char *options,
const char *fstype,
bool set_flags) {
_cleanup_free_ char *e = NULL;
MountProcFlags flags;
Unit *u;
int r;
assert(m);
assert(what);
assert(where);
assert(options);
assert(fstype);
/* Ignore API and credential mount points. They should never be referenced in dependencies ever.
* Furthermore, the lifetime of credential mounts is strictly bound to the owning services,
* so mount units make little sense for them. */
if (mount_point_is_api(where) || mount_point_ignore(where) ||
mount_point_is_credentials(m->prefix[EXEC_DIRECTORY_RUNTIME], where))
return 0;
if (streq(fstype, "autofs"))
return 0;
/* probably some kind of swap, ignore */
if (!is_path(where))
return 0;
r = unit_name_from_path(where, ".mount", &e);
if (r < 0)
return log_struct_errno(
LOG_WARNING, r,
LOG_MESSAGE_ID(SD_MESSAGE_MOUNT_POINT_PATH_NOT_SUITABLE_STR),
LOG_ITEM("MOUNT_POINT=%s", where),
LOG_MESSAGE("Failed to generate valid unit name from mount point path '%s', ignoring mount point: %m",
where));
u = manager_get_unit(m, e);
if (u)
r = mount_setup_existing_unit(u, what, where, options, fstype, &flags);
else
/* First time we see this mount point meaning that it's not been initiated by a mount unit
* but rather by the sysadmin having called mount(8) directly. */
r = mount_setup_new_unit(m, e, what, where, options, fstype, &flags, &u);
if (r < 0)
return log_warning_errno(r, "Failed to set up mount unit for '%s': %m", where);
/* If the mount changed properties or state, let's notify our clients */
if (flags & (MOUNT_PROC_JUST_CHANGED|MOUNT_PROC_JUST_MOUNTED))
unit_add_to_dbus_queue(u);
if (set_flags)
MOUNT(u)->proc_flags = flags;
return 0;
}
static int mount_load_proc_self_mountinfo(Manager *m, bool set_flags) {
_cleanup_(mnt_free_tablep) struct libmnt_table *table = NULL;
_cleanup_(mnt_free_iterp) struct libmnt_iter *iter = NULL;
_cleanup_set_free_ Set *devices = NULL;
int r;
assert(m);
r = libmount_parse_with_utab(&table, &iter);
if (r < 0)
return log_error_errno(r, "Failed to parse /proc/self/mountinfo: %m");
for (;;) {
struct libmnt_fs *fs;
const char *device, *path, *options, *fstype;
r = sym_mnt_table_next_fs(table, iter, &fs);
if (r == 1)
break;
if (r < 0)
return log_error_errno(r, "Failed to get next entry from /proc/self/mountinfo: %m");
device = sym_mnt_fs_get_source(fs);
path = sym_mnt_fs_get_target(fs);
options = sym_mnt_fs_get_options(fs);
fstype = sym_mnt_fs_get_fstype(fs);
if (!device || !path)
continue;
/* Just to achieve device name uniqueness. Note that the suppression of the duplicate
* processing is merely an optimization, hence in case of OOM (unlikely) we'll just process
* it twice. */
if (set_put_strdup_full(&devices, &path_hash_ops_free, device) != 0)
device_found_node(m, device, DEVICE_FOUND_MOUNT, DEVICE_FOUND_MOUNT);
(void) mount_setup_unit(m, device, path, options, fstype, set_flags);
}
return 0;
}
#endif
static void mount_shutdown(Manager *m) {
assert(m);
m->mount_event_source = sd_event_source_disable_unref(m->mount_event_source);
if (m->mount_monitor) {
sym_mnt_unref_monitor(m->mount_monitor);
m->mount_monitor = NULL;
}
}
static void mount_handoff_timestamp(
Unit *u,
const struct ucred *ucred,
const dual_timestamp *ts) {
Mount *m = ASSERT_PTR(MOUNT(u));
assert(ucred);
assert(ts);
if (m->control_pid.pid == ucred->pid && m->control_command) {
exec_status_handoff(&m->control_command->exec_status, ucred, ts);
unit_add_to_dbus_queue(u);
}
}
static int mount_get_timeout(Unit *u, usec_t *timeout) {