HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/core/mount.c

93,351 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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) {